goto exit_destroy;
        }
 
-       chip->gpio_chip.can_sleep = 1;
+       chip->gpio_chip.can_sleep = true;
        chip->gpio_chip.dev = &spi->dev;
        chip->gpio_chip.owner = THIS_MODULE;
 
 
        chip->direction_output = adnp_gpio_direction_output;
        chip->get = adnp_gpio_get;
        chip->set = adnp_gpio_set;
-       chip->can_sleep = 1;
+       chip->can_sleep = true;
 
        if (IS_ENABLED(CONFIG_DEBUG_FS))
                chip->dbg_show = adnp_gpio_dbg_show;
 
        gc->direction_output = adp5520_gpio_direction_output;
        gc->get = adp5520_gpio_get_value;
        gc->set = adp5520_gpio_set_value;
-       gc->can_sleep = 1;
+       gc->can_sleep = true;
 
        gc->base = pdata->gpio_start;
        gc->ngpio = gpios;
 
        gc->direction_output = adp5588_gpio_direction_output;
        gc->get = adp5588_gpio_get_value;
        gc->set = adp5588_gpio_set_value;
-       gc->can_sleep = 1;
+       gc->can_sleep = true;
 
        gc->base = pdata->gpio_start;
        gc->ngpio = ADP5588_MAXGPIO;
 
        .get                    = arizona_gpio_get,
        .direction_output       = arizona_gpio_direction_out,
        .set                    = arizona_gpio_set,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 static int arizona_gpio_probe(struct platform_device *pdev)
 
        c->dbg_show = NULL;
        c->base = modparam_gpiobase;
        c->ngpio = BT8XXGPIO_NR_GPIOS;
-       c->can_sleep = 0;
+       c->can_sleep = false;
 }
 
 static int bt8xxgpio_probe(struct pci_dev *dev,
 
        .direction_input = da9052_gpio_direction_input,
        .direction_output = da9052_gpio_direction_output,
        .to_irq = da9052_gpio_to_irq,
-       .can_sleep = 1,
+       .can_sleep = true,
        .ngpio = 16,
        .base = -1,
 };
 
        .direction_input = da9055_gpio_direction_input,
        .direction_output = da9055_gpio_direction_output,
        .to_irq = da9055_gpio_to_irq,
-       .can_sleep = 1,
+       .can_sleep = true,
        .ngpio = 3,
        .base = -1,
 };
 
        chip->direction_output = ichx_gpio_direction_output;
        chip->base = modparam_gpiobase;
        chip->ngpio = ichx_priv.desc->ngpio;
-       chip->can_sleep = 0;
+       chip->can_sleep = false;
        chip->dbg_show = NULL;
 }
 
 
        priv->chip.to_irq = intel_gpio_to_irq;
        priv->chip.base = gpio_base;
        priv->chip.ngpio = ddata->ngpio;
-       priv->chip.can_sleep = 0;
+       priv->chip.can_sleep = false;
        priv->pdev = pdev;
 
        spin_lock_init(&priv->lock);
 
        chip->label = "gpio-kempld";
        chip->owner = THIS_MODULE;
        chip->dev = dev;
-       chip->can_sleep = 1;
+       chip->can_sleep = true;
        if (pdata && pdata->gpio_base)
                chip->base = pdata->gpio_base;
        else
 
        .to_irq                 = ks8695_gpio_to_irq,
        .base                   = 0,
        .ngpio                  = 16,
-       .can_sleep              = 0,
+       .can_sleep              = false,
 };
 
 /* Register the GPIOs */
 
                        .base                   = LPC32XX_GPIO_P0_GRP,
                        .ngpio                  = LPC32XX_GPIO_P0_MAX,
                        .names                  = gpio_p0_names,
-                       .can_sleep              = 0,
+                       .can_sleep              = false,
                },
                .gpio_grp = &gpio_grp_regs_p0,
        },
                        .base                   = LPC32XX_GPIO_P1_GRP,
                        .ngpio                  = LPC32XX_GPIO_P1_MAX,
                        .names                  = gpio_p1_names,
-                       .can_sleep              = 0,
+                       .can_sleep              = false,
                },
                .gpio_grp = &gpio_grp_regs_p1,
        },
                        .base                   = LPC32XX_GPIO_P2_GRP,
                        .ngpio                  = LPC32XX_GPIO_P2_MAX,
                        .names                  = gpio_p2_names,
-                       .can_sleep              = 0,
+                       .can_sleep              = false,
                },
                .gpio_grp = &gpio_grp_regs_p2,
        },
                        .base                   = LPC32XX_GPIO_P3_GRP,
                        .ngpio                  = LPC32XX_GPIO_P3_MAX,
                        .names                  = gpio_p3_names,
-                       .can_sleep              = 0,
+                       .can_sleep              = false,
                },
                .gpio_grp = &gpio_grp_regs_p3,
        },
                        .base                   = LPC32XX_GPI_P3_GRP,
                        .ngpio                  = LPC32XX_GPI_P3_MAX,
                        .names                  = gpi_p3_names,
-                       .can_sleep              = 0,
+                       .can_sleep              = false,
                },
                .gpio_grp = &gpio_grp_regs_p3,
        },
                        .base                   = LPC32XX_GPO_P3_GRP,
                        .ngpio                  = LPC32XX_GPO_P3_MAX,
                        .names                  = gpo_p3_names,
-                       .can_sleep              = 0,
+                       .can_sleep              = false,
                },
                .gpio_grp = &gpio_grp_regs_p3,
        },
 
        gc->set = lp_gpio_set;
        gc->base = -1;
        gc->ngpio = LP_NUM_GPIO;
-       gc->can_sleep = 0;
+       gc->can_sleep = false;
        gc->dev = dev;
 
        /* set up interrupts  */
 
        ts->chip.set = max7301_set;
 
        ts->chip.ngpio = PIN_NUMBER;
-       ts->chip.can_sleep = 1;
+       ts->chip.can_sleep = true;
        ts->chip.dev = dev;
        ts->chip.owner = THIS_MODULE;
 
 
                gc->set = max732x_gpio_set_value;
        }
        gc->get = max732x_gpio_get_value;
-       gc->can_sleep = 1;
+       gc->can_sleep = true;
 
        gc->base = gpio_start;
        gc->ngpio = port;
 
        mc->chip.set = mc33880_set;
        mc->chip.base = pdata->base;
        mc->chip.ngpio = PIN_NUMBER;
-       mc->chip.can_sleep = 1;
+       mc->chip.can_sleep = true;
        mc->chip.dev = &spi->dev;
        mc->chip.owner = THIS_MODULE;
 
 
        mc9s->chip.dev = &client->dev;
        mc9s->chip.owner = THIS_MODULE;
        mc9s->chip.ngpio = GPIO_NUM;
-       mc9s->chip.can_sleep = 1;
+       mc9s->chip.can_sleep = true;
        mc9s->chip.get = mc9s08dz60_get_value;
        mc9s->chip.set = mc9s08dz60_set_value;
        mc9s->chip.direction_output = mc9s08dz60_direction_output;
 
        }
 
        mcp->chip.base = base;
-       mcp->chip.can_sleep = 1;
+       mcp->chip.can_sleep = true;
        mcp->chip.dev = dev;
        mcp->chip.owner = THIS_MODULE;
 
 
        gpio->dbg_show = NULL;
        gpio->base = -1;
        gpio->ngpio = num_port;
-       gpio->can_sleep = 0;
+       gpio->can_sleep = false;
        gpio->to_irq = ioh_gpio_to_irq;
 }
 
 
        mg->chip.to_irq = msic_gpio_to_irq;
        mg->chip.base = pdata->gpio_base;
        mg->chip.ngpio = MSIC_NUM_GPIO;
-       mg->chip.can_sleep = 1;
+       mg->chip.can_sleep = true;
        mg->chip.dev = dev;
 
        mutex_init(&mg->buslock);
 
        mvchip->chip.to_irq = mvebu_gpio_to_irq;
        mvchip->chip.base = id * MVEBU_MAX_GPIO_PER_BANK;
        mvchip->chip.ngpio = ngpios;
-       mvchip->chip.can_sleep = 0;
+       mvchip->chip.can_sleep = false;
        mvchip->chip.of_node = np;
        mvchip->chip.dbg_show = mvebu_gpio_dbg_show;
 
 
        chip->dev = &pdev->dev;
        chip->owner = THIS_MODULE;
        chip->base = 0;
-       chip->can_sleep = 0;
+       chip->can_sleep = false;
        chip->ngpio = 20;
        chip->direction_input = octeon_gpio_dir_in;
        chip->get = octeon_gpio_get;
 
        palmas_gpio->gpio_chip.owner = THIS_MODULE;
        palmas_gpio->gpio_chip.label = dev_name(&pdev->dev);
        palmas_gpio->gpio_chip.ngpio = dev_data->ngpio;
-       palmas_gpio->gpio_chip.can_sleep = 1;
+       palmas_gpio->gpio_chip.can_sleep = true;
        palmas_gpio->gpio_chip.direction_input = palmas_gpio_input;
        palmas_gpio->gpio_chip.direction_output = palmas_gpio_output;
        palmas_gpio->gpio_chip.to_irq = palmas_gpio_to_irq;
 
        gc->direction_output = pca953x_gpio_direction_output;
        gc->get = pca953x_gpio_get_value;
        gc->set = pca953x_gpio_set_value;
-       gc->can_sleep = 1;
+       gc->can_sleep = true;
 
        gc->base = chip->gpio_start;
        gc->ngpio = gpios;
 
        spin_lock_init(&gpio->slock);
 
        gpio->chip.base                 = pdata ? pdata->gpio_base : -1;
-       gpio->chip.can_sleep            = 1;
+       gpio->chip.can_sleep            = true;
        gpio->chip.dev                  = &client->dev;
        gpio->chip.owner                = THIS_MODULE;
        gpio->chip.get                  = pcf857x_get;
 
        gpio->dbg_show = NULL;
        gpio->base = -1;
        gpio->ngpio = gpio_pins[chip->ioh];
-       gpio->can_sleep = 0;
+       gpio->can_sleep = false;
        gpio->to_irq = pch_gpio_to_irq;
 }
 
 
        rc5t583_gpio->gpio_chip.get = rc5t583_gpio_get,
        rc5t583_gpio->gpio_chip.to_irq = rc5t583_gpio_to_irq,
        rc5t583_gpio->gpio_chip.ngpio = RC5T583_MAX_GPIO,
-       rc5t583_gpio->gpio_chip.can_sleep = 1,
+       rc5t583_gpio->gpio_chip.can_sleep = true,
        rc5t583_gpio->gpio_chip.dev = &pdev->dev;
        rc5t583_gpio->gpio_chip.base = -1;
        rc5t583_gpio->rc5t583 = rc5t583;
 
        gpio->dbg_show = NULL;
        gpio->base = gpio_base;
        gpio->ngpio = GSTA_NR_GPIO;
-       gpio->can_sleep = 0;
+       gpio->can_sleep = false;
        gpio->to_irq = gsta_gpio_to_irq;
 
        /*
 
        .set                    = stmpe_gpio_set,
        .to_irq                 = stmpe_gpio_to_irq,
        .request                = stmpe_gpio_request,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 static int stmpe_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 
        chip->gpio_chip.set              = sx150x_gpio_set;
        chip->gpio_chip.to_irq           = sx150x_gpio_to_irq;
        chip->gpio_chip.base             = pdata->gpio_base;
-       chip->gpio_chip.can_sleep        = 1;
+       chip->gpio_chip.can_sleep        = true;
        chip->gpio_chip.ngpio            = chip->dev_cfg->ngpios;
        if (pdata->oscio_is_gpo)
                ++chip->gpio_chip.ngpio;
 
        tb10x_gpio->gc.free             = tb10x_gpio_free;
        tb10x_gpio->gc.base             = -1;
        tb10x_gpio->gc.ngpio            = ngpio;
-       tb10x_gpio->gc.can_sleep        = 0;
+       tb10x_gpio->gc.can_sleep        = false;
 
 
        ret = gpiochip_add(&tb10x_gpio->gc);
 
        .direction_output       = tc3589x_gpio_direction_output,
        .set                    = tc3589x_gpio_set,
        .to_irq                 = tc3589x_gpio_to_irq,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 static int tc3589x_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 
        gc->dbg_show = NULL;
        gc->base = pdata->gpio_base;
        gc->ngpio = pdata->nr_pins;
-       gc->can_sleep = 0;
+       gc->can_sleep = false;
 
        err = gpiochip_add(gc);
        if (err)
 
                ctlr = &chips[i];
 
                ctlr->chip.label        = "tnetv107x";
-               ctlr->chip.can_sleep    = 0;
+               ctlr->chip.can_sleep    = false;
                ctlr->chip.base         = base;
                ctlr->chip.ngpio        = ngpio - base;
                if (ctlr->chip.ngpio > 32)
 
        tps6586x_gpio->gpio_chip.label = pdev->name;
        tps6586x_gpio->gpio_chip.dev = &pdev->dev;
        tps6586x_gpio->gpio_chip.ngpio = 4;
-       tps6586x_gpio->gpio_chip.can_sleep = 1;
+       tps6586x_gpio->gpio_chip.can_sleep = true;
 
        /* FIXME: add handling of GPIOs as dedicated inputs */
        tps6586x_gpio->gpio_chip.direction_output = tps6586x_gpio_output;
 
        default:
                return -EINVAL;
        }
-       tps65910_gpio->gpio_chip.can_sleep = 1;
+       tps65910_gpio->gpio_chip.can_sleep = true;
        tps65910_gpio->gpio_chip.direction_input = tps65910_gpio_input;
        tps65910_gpio->gpio_chip.direction_output = tps65910_gpio_output;
        tps65910_gpio->gpio_chip.set    = tps65910_gpio_set;
 
        .direction_output       = tps65912_gpio_output,
        .get                    = tps65912_gpio_get,
        .set                    = tps65912_gpio_set,
-       .can_sleep              = 1,
+       .can_sleep              = true,
        .ngpio                  = 5,
        .base                   = -1,
 };
 
        .direction_output       = twl_direction_out,
        .set                    = twl_set,
        .to_irq                 = twl_to_irq,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 /*----------------------------------------------------------------------*/
 
        .get                    = twl6040gpo_get,
        .direction_output       = twl6040gpo_direction_out,
        .set                    = twl6040gpo_set,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 /*----------------------------------------------------------------------*/
 
        ucb->gc.direction_output = ucb1400_gpio_dir_out;
        ucb->gc.get = ucb1400_gpio_get;
        ucb->gc.set = ucb1400_gpio_set;
-       ucb->gc.can_sleep = 1;
+       ucb->gc.can_sleep = true;
 
        err = gpiochip_add(&ucb->gc);
        if (err)
 
        vb_gpio->gpioa.owner = THIS_MODULE;
        vb_gpio->gpioa.base = -1;
        vb_gpio->gpioa.ngpio = 16;
-       vb_gpio->gpioa.can_sleep = 1;
+       vb_gpio->gpioa.can_sleep = true;
        vb_gpio->gpioa.set = vprbrd_gpioa_set;
        vb_gpio->gpioa.get = vprbrd_gpioa_get;
        vb_gpio->gpioa.direction_input = vprbrd_gpioa_direction_input;
        vb_gpio->gpiob.owner = THIS_MODULE;
        vb_gpio->gpiob.base = -1;
        vb_gpio->gpiob.ngpio = 16;
-       vb_gpio->gpiob.can_sleep = 1;
+       vb_gpio->gpiob.can_sleep = true;
        vb_gpio->gpiob.set = vprbrd_gpiob_set;
        vb_gpio->gpiob.get = vprbrd_gpiob_get;
        vb_gpio->gpiob.direction_input = vprbrd_gpiob_direction_input;
 
        c->dbg_show = NULL;
        c->base = 0;
        c->ngpio = NR_VX855_GP;
-       c->can_sleep = 0;
+       c->can_sleep = false;
        c->names = vx855gpio_names;
 }
 
 
        .to_irq                 = wm831x_gpio_to_irq,
        .set_debounce           = wm831x_gpio_set_debounce,
        .dbg_show               = wm831x_gpio_dbg_show,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 static int wm831x_gpio_probe(struct platform_device *pdev)
 
        .direction_output       = wm8350_gpio_direction_out,
        .set                    = wm8350_gpio_set,
        .to_irq                 = wm8350_gpio_to_irq,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 static int wm8350_gpio_probe(struct platform_device *pdev)
 
        .set                    = wm8994_gpio_set,
        .to_irq                 = wm8994_gpio_to_irq,
        .dbg_show               = wm8994_gpio_dbg_show,
-       .can_sleep              = 1,
+       .can_sleep              = true,
 };
 
 static int wm8994_gpio_probe(struct platform_device *pdev)
 
        if (dev) {
                put_device(dev);
                device_unregister(dev);
-               chip->exported = 0;
+               chip->exported = false;
                status = 0;
        } else
                status = -ENODEV;
 
        .direction_input        = as3722_gpio_direction_input,
        .direction_output       = as3722_gpio_direction_output,
        .to_irq                 = as3722_gpio_to_irq,
-       .can_sleep              = 1,
+       .can_sleep              = true,
        .ngpio                  = AS3722_PIN_NUM,
        .base                   = -1,
 };
 
        .set                    = at91_gpio_set,
        .to_irq                 = at91_gpio_to_irq,
        .dbg_show               = at91_gpio_dbg_show,
-       .can_sleep              = 0,
+       .can_sleep              = false,
        .ngpio                  = MAX_NB_GPIO_PER_BANK,
 };
 
 
        gc->set = byt_gpio_set;
        gc->dbg_show = byt_gpio_dbg_show;
        gc->base = -1;
-       gc->can_sleep = 0;
+       gc->can_sleep = false;
        gc->dev = dev;
 
        ret = gpiochip_add(gc);
 
        .to_irq = bcm2835_gpio_to_irq,
        .base = -1,
        .ngpio = BCM2835_NUM_GPIOS,
-       .can_sleep = 0,
+       .can_sleep = false,
 };
 
 static irqreturn_t bcm2835_gpio_irq_handler(int irq, void *dev_id)
 
        .set                    = nmk_gpio_set_output,
        .to_irq                 = nmk_gpio_to_irq,
        .dbg_show               = nmk_gpio_dbg_show,
-       .can_sleep              = 0,
+       .can_sleep              = false,
 };
 
 void nmk_gpio_clocks_enable(void)
 
        .of_xlate               = sunxi_pinctrl_gpio_of_xlate,
        .to_irq                 = sunxi_pinctrl_gpio_to_irq,
        .of_gpio_n_cells        = 3,
-       .can_sleep              = 0,
+       .can_sleep              = false,
 };
 
 static int sunxi_pinctrl_irq_set_type(struct irq_data *d,
 
        .direction_output = wmt_gpio_direction_output,
        .get = wmt_gpio_get_value,
        .set = wmt_gpio_set_value,
-       .can_sleep = 0,
+       .can_sleep = false,
 };
 
 int wmt_pinctrl_probe(struct platform_device *pdev,
 
  * @ngpio: the number of GPIOs handled by this controller; the last GPIO
  *     handled is (base + ngpio - 1).
  * @desc: array of ngpio descriptors. Private.
- * @can_sleep: flag must be set iff get()/set() methods sleep, as they
- *     must while accessing GPIO expander chips over I2C or SPI
  * @names: if set, must be an array of strings to use as alternative
  *      names for the GPIOs in this chip. Any entry in the array
  *      may be NULL if there is no alias for the GPIO, however the
  *      array must be @ngpio entries long.  A name can include a single printk
  *      format specifier for an unsigned int.  It is substituted by the actual
  *      number of the gpio.
+ * @can_sleep: flag must be set iff get()/set() methods sleep, as they
+ *     must while accessing GPIO expander chips over I2C or SPI
+ * @exported: flags if the gpiochip is exported for use from sysfs. Private.
  *
  * A gpio_chip can help platforms abstract various sources of GPIOs so
  * they can all be accessed through a common programing interface.
        u16                     ngpio;
        struct gpio_desc        *desc;
        const char              *const *names;
-       unsigned                can_sleep:1;
-       unsigned                exported:1;
+       bool                    can_sleep;
+       bool                    exported;
 
 #if defined(CONFIG_OF_GPIO)
        /*