186 files changed, 2692 insertions, 2505 deletions

diff --git a/Documentation/devicetree/bindings/gpio/gpio-pca953x.txt b/Documentation/devicetree/bindings/gpio/gpio-pca953x.txt
index 13df9933f4cd..6b4a98f74be3 100644
--- a/Documentation/devicetree/bindings/gpio/gpio-pca953x.txt
+++ b/Documentation/devicetree/bindings/gpio/gpio-pca953x.txt
@@ -25,6 +25,7 @@ Required properties:
         ti,tca6416
         ti,tca6424
         ti,tca9539
+        onsemi,pca9654
         exar,xra1202
 
 Example:
diff --git a/Documentation/devicetree/bindings/gpio/gpio-sx150x.txt b/Documentation/devicetree/bindings/gpio/gpio-sx150x.txt
index ba2bb84eeac3..c809acb9c71b 100644
--- a/Documentation/devicetree/bindings/gpio/gpio-sx150x.txt
+++ b/Documentation/devicetree/bindings/gpio/gpio-sx150x.txt
@@ -5,7 +5,8 @@ Required properties:
 
 - compatible: should be "semtech,sx1506q",
                         "semtech,sx1508q",
-                        "semtech,sx1509q".
+                        "semtech,sx1509q",
+                        "semtech,sx1502q".
 
 - reg: The I2C slave address for this device.
 
diff --git a/Documentation/devicetree/bindings/gpio/gpio-tps65086.txt b/Documentation/devicetree/bindings/gpio/gpio-tps65086.txt
new file mode 100644
index 000000000000..ba051074bedc
--- /dev/null
+++ b/Documentation/devicetree/bindings/gpio/gpio-tps65086.txt
@@ -0,0 +1,16 @@
+* TPS65086 GPO Controller bindings
+
+Required properties:
+ - compatible           : Should be "ti,tps65086-gpio".
+ - gpio-controller      : Marks the device node as a GPIO Controller.
+ - #gpio-cells          : Should be two. The first cell is the pin number
+                            and the second cell is used to specify flags.
+                            See ../gpio/gpio.txt for possible values.
+
+Example:
+
+        gpio4: gpio {
+                compatible = "ti,tps65086-gpio";
+                gpio-controller;
+                #gpio-cells = <2>;
+        };
diff --git a/MAINTAINERS b/MAINTAINERS
index 11073db4c0a0..d38c324191de 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -240,6 +240,12 @@ L:	lm-sensors@lm-sensors.org
 S:      Maintained
 F:      drivers/hwmon/abituguru3.c
 
+ACCES 104-IDI-48 GPIO DRIVER
+M:      "William Breathitt Gray" <vilhelm.gray@gmail.com>
+L:      linux-gpio@vger.kernel.org
+S:      Maintained
+F:      drivers/gpio/gpio-104-idi-48.c
+
 ACCES 104-IDIO-16 GPIO DRIVER
 M:      "William Breathitt Gray" <vilhelm.gray@gmail.com>
 L:      linux-gpio@vger.kernel.org
@@ -7821,11 +7827,12 @@ F:	drivers/usb/*/*omap*
 F:      arch/arm/*omap*/usb*
 
 OMAP GPIO DRIVER
-M:      Javier Martinez Canillas <javier@dowhile0.org>
+M:      Grygorii Strashko <grygorii.strashko@ti.com>
 M:      Santosh Shilimkar <ssantosh@kernel.org>
 M:      Kevin Hilman <khilman@deeprootsystems.com>
 L:      linux-omap@vger.kernel.org
 S:      Maintained
+F:      Documentation/devicetree/bindings/gpio/gpio-omap.txt
 F:      drivers/gpio/gpio-omap.c
 
 OMAP/NEWFLOW NANOBONE MACHINE SUPPORT
@@ -8685,6 +8692,12 @@ F:	include/sound/pxa2xx-lib.h
 F:      sound/arm/pxa*
 F:      sound/soc/pxa/
 
+PXA GPIO DRIVER
+M:      Robert Jarzmik <robert.jarzmik@free.fr>
+L:      linux-gpio@vger.kernel.org
+S:      Maintained
+F:      drivers/gpio/gpio-pxa.c
+
 PXA3xx NAND FLASH DRIVER
 M:      Ezequiel Garcia <ezequiel.garcia@free-electrons.com>
 L:      linux-mtd@lists.infradead.org
diff --git a/arch/arm/mach-clps711x/board-autcpu12.c b/arch/arm/mach-clps711x/board-autcpu12.c
index c3d964221767..ba3d7d1b28f8 100644
--- a/arch/arm/mach-clps711x/board-autcpu12.c
+++ b/arch/arm/mach-clps711x/board-autcpu12.c
@@ -31,7 +31,7 @@
 #include <linux/mtd/partitions.h>
 #include <linux/mtd/nand-gpio.h>
 #include <linux/platform_device.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 
 #include <mach/hardware.h>
 #include <asm/sizes.h>
diff --git a/arch/arm/mach-clps711x/board-p720t.c b/arch/arm/mach-clps711x/board-p720t.c
index e68dd629bda2..80a16a8b3776 100644
--- a/arch/arm/mach-clps711x/board-p720t.c
+++ b/arch/arm/mach-clps711x/board-p720t.c
@@ -28,7 +28,7 @@
 #include <linux/leds.h>
 #include <linux/sizes.h>
 #include <linux/backlight.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/platform_device.h>
 #include <linux/mtd/partitions.h>
 #include <linux/mtd/nand-gpio.h>
diff --git a/arch/arm/mach-imx/mach-mx21ads.c b/arch/arm/mach-imx/mach-mx21ads.c
index 703ce31d7379..9986f9a697c8 100644
--- a/arch/arm/mach-imx/mach-mx21ads.c
+++ b/arch/arm/mach-imx/mach-mx21ads.c
@@ -17,7 +17,7 @@
 #include <linux/platform_device.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/physmap.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/gpio.h>
 #include <linux/regulator/fixed.h>
 #include <linux/regulator/machine.h>
diff --git a/arch/arm/mach-omap1/board-ams-delta.c b/arch/arm/mach-omap1/board-ams-delta.c
index a95499ea8706..97e66558c238 100644
--- a/arch/arm/mach-omap1/board-ams-delta.c
+++ b/arch/arm/mach-omap1/board-ams-delta.c
@@ -11,7 +11,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/gpio.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
diff --git a/arch/arm/mach-s3c64xx/mach-crag6410.c b/arch/arm/mach-s3c64xx/mach-crag6410.c
index f776adcdaee8..723f47fefc81 100644
--- a/arch/arm/mach-s3c64xx/mach-crag6410.c
+++ b/arch/arm/mach-s3c64xx/mach-crag6410.c
@@ -29,7 +29,7 @@
 #include <linux/pwm_backlight.h>
 #include <linux/dm9000.h>
 #include <linux/gpio_keys.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/spi/spi.h>
 
 #include <linux/platform_data/pca953x.h>
diff --git a/arch/avr32/mach-at32ap/pio.c b/arch/avr32/mach-at32ap/pio.c
index 4f61378c3453..5020057ac7a2 100644
--- a/arch/avr32/mach-at32ap/pio.c
+++ b/arch/avr32/mach-at32ap/pio.c
@@ -203,7 +203,7 @@ fail:
 
 static int direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        struct pio_device *pio = gpiochip_get_data(chip);
         u32 mask = 1 << offset;
 
         if (!(pio_readl(pio, PSR) & mask))
@@ -215,7 +215,7 @@ static int direction_input(struct gpio_chip *chip, unsigned offset)
 
 static int gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        struct pio_device *pio = gpiochip_get_data(chip);
 
         return (pio_readl(pio, PDSR) >> offset) & 1;
 }
@@ -224,7 +224,7 @@ static void gpio_set(struct gpio_chip *chip, unsigned offset, int value);
 
 static int direction_output(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        struct pio_device *pio = gpiochip_get_data(chip);
         u32 mask = 1 << offset;
 
         if (!(pio_readl(pio, PSR) & mask))
@@ -237,7 +237,7 @@ static int direction_output(struct gpio_chip *chip, unsigned offset, int value)
 
 static void gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        struct pio_device *pio = gpiochip_get_data(chip);
         u32 mask = 1 << offset;
 
         if (value)
@@ -335,7 +335,7 @@ gpio_irq_setup(struct pio_device *pio, int irq, int gpio_irq)
  */
 static void pio_bank_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        struct pio_device *pio = gpiochip_get_data(chip);
         u32                     psr, osr, imr, pdsr, pusr, ifsr, mdsr;
         unsigned                i;
         u32                     mask;
@@ -397,7 +397,7 @@ static int __init pio_probe(struct platform_device *pdev)
         pio->chip.label = pio->name;
         pio->chip.base = pdev->id * 32;
         pio->chip.ngpio = 32;
-        pio->chip.dev = &pdev->dev;
+        pio->chip.parent = &pdev->dev;
         pio->chip.owner = THIS_MODULE;
 
         pio->chip.direction_input = direction_input;
@@ -406,7 +406,7 @@ static int __init pio_probe(struct platform_device *pdev)
         pio->chip.set = gpio_set;
         pio->chip.dbg_show = pio_bank_show;
 
-        gpiochip_add(&pio->chip);
+        gpiochip_add_data(&pio->chip, pio);
 
         gpio_irq_setup(pio, irq, gpio_irq_base);
 
diff --git a/drivers/bcma/driver_gpio.c b/drivers/bcma/driver_gpio.c
index 504899a72966..98067f757fb0 100644
--- a/drivers/bcma/driver_gpio.c
+++ b/drivers/bcma/driver_gpio.c
@@ -17,14 +17,9 @@
 
 #define BCMA_GPIO_MAX_PINS      32
 
-static inline struct bcma_drv_cc *bcma_gpio_get_cc(struct gpio_chip *chip)
-{
-        return container_of(chip, struct bcma_drv_cc, gpio);
-}
-
 static int bcma_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
 {
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
+        struct bcma_drv_cc *cc = gpiochip_get_data(chip);
 
         return !!bcma_chipco_gpio_in(cc, 1 << gpio);
 }
@@ -32,14 +27,14 @@ static int bcma_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
 static void bcma_gpio_set_value(struct gpio_chip *chip, unsigned gpio,
                                 int value)
 {
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
+        struct bcma_drv_cc *cc = gpiochip_get_data(chip);
 
         bcma_chipco_gpio_out(cc, 1 << gpio, value ? 1 << gpio : 0);
 }
 
 static int bcma_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 {
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
+        struct bcma_drv_cc *cc = gpiochip_get_data(chip);
 
         bcma_chipco_gpio_outen(cc, 1 << gpio, 0);
         return 0;
@@ -48,7 +43,7 @@ static int bcma_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 static int bcma_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
                                       int value)
 {
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
+        struct bcma_drv_cc *cc = gpiochip_get_data(chip);
 
         bcma_chipco_gpio_outen(cc, 1 << gpio, 1 << gpio);
         bcma_chipco_gpio_out(cc, 1 << gpio, value ? 1 << gpio : 0);
@@ -57,7 +52,7 @@ static int bcma_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
 
 static int bcma_gpio_request(struct gpio_chip *chip, unsigned gpio)
 {
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
+        struct bcma_drv_cc *cc = gpiochip_get_data(chip);
 
         bcma_chipco_gpio_control(cc, 1 << gpio, 0);
         /* clear pulldown */
@@ -70,7 +65,7 @@ static int bcma_gpio_request(struct gpio_chip *chip, unsigned gpio)
 
 static void bcma_gpio_free(struct gpio_chip *chip, unsigned gpio)
 {
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
+        struct bcma_drv_cc *cc = gpiochip_get_data(chip);
 
         /* clear pullup */
         bcma_chipco_gpio_pullup(cc, 1 << gpio, 0);
@@ -81,7 +76,7 @@ static void bcma_gpio_free(struct gpio_chip *chip, unsigned gpio)
 static void bcma_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(gc);
+        struct bcma_drv_cc *cc = gpiochip_get_data(gc);
         int gpio = irqd_to_hwirq(d);
         u32 val = bcma_chipco_gpio_in(cc, BIT(gpio));
 
@@ -92,7 +87,7 @@ static void bcma_gpio_irq_unmask(struct irq_data *d)
 static void bcma_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct bcma_drv_cc *cc = bcma_gpio_get_cc(gc);
+        struct bcma_drv_cc *cc = gpiochip_get_data(gc);
         int gpio = irqd_to_hwirq(d);
 
         bcma_chipco_gpio_intmask(cc, BIT(gpio), 0);
@@ -188,7 +183,7 @@ int bcma_gpio_init(struct bcma_drv_cc *cc)
         chip->direction_input   = bcma_gpio_direction_input;
         chip->direction_output  = bcma_gpio_direction_output;
         chip->owner             = THIS_MODULE;
-        chip->dev               = bcma_bus_get_host_dev(bus);
+        chip->parent            = bcma_bus_get_host_dev(bus);
 #if IS_BUILTIN(CONFIG_OF)
         if (cc->core->bus->hosttype == BCMA_HOSTTYPE_SOC)
                 chip->of_node   = cc->core->dev.of_node;
@@ -216,7 +211,7 @@ int bcma_gpio_init(struct bcma_drv_cc *cc)
         else
                 chip->base              = -1;
 
-        err = gpiochip_add(chip);
+        err = gpiochip_add_data(chip, cc);
         if (err)
                 return err;
 
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index b18bea08ff25..cb212ebb39ff 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -134,8 +134,8 @@ config GPIO_BCM_KONA
 
 config GPIO_BRCMSTB
         tristate "BRCMSTB GPIO support"
-        default y if ARCH_BRCMSTB
-        depends on OF_GPIO && (ARCH_BRCMSTB || COMPILE_TEST)
+        default y if (ARCH_BRCMSTB || BMIPS_GENERIC)
+        depends on OF_GPIO && (ARCH_BRCMSTB || BMIPS_GENERIC || COMPILE_TEST)
         select GPIO_GENERIC
         select GPIOLIB_IRQCHIP
         help
@@ -496,8 +496,21 @@ menu "Port-mapped I/O GPIO drivers"
 
 config GPIO_104_IDIO_16
         tristate "ACCES 104-IDIO-16 GPIO support"
+        select GPIOLIB_IRQCHIP
+        help
+          Enables GPIO support for the ACCES 104-IDIO-16 family. The base port
+          address for the device may be set via the idio_16_base module
+          parameter. The interrupt line number for the device may be set via the
+          idio_16_irq module parameter.
+
+config GPIO_104_IDI_48
+        tristate "ACCES 104-IDI-48 GPIO support"
+        select GPIOLIB_IRQCHIP
         help
-          Enables GPIO support for the ACCES 104-IDIO-16 family.
+          Enables GPIO support for the ACCES 104-IDI-48 family. The base port
+          address for the device may be configured via the idi_48_base module
+          parameter. The interrupt line number for the device may be configured
+          via the idi_48_irq module parameter.
 
 config GPIO_F7188X
         tristate "F71869, F71869A, F71882FG and F71889F GPIO support"
@@ -907,7 +920,6 @@ menu "PCI GPIO expanders"
 
 config GPIO_AMD8111
         tristate "AMD 8111 GPIO driver"
-        depends on PCI
         help
           The AMD 8111 south bridge contains 32 GPIO pins which can be used.
 
@@ -919,7 +931,7 @@ config GPIO_AMD8111
 
 config GPIO_BT8XX
         tristate "BT8XX GPIO abuser"
-        depends on PCI && VIDEO_BT848=n
+        depends on VIDEO_BT848=n
         help
           The BT8xx frame grabber chip has 24 GPIO pins that can be abused
           as a cheap PCI GPIO card.
@@ -935,14 +947,13 @@ config GPIO_BT8XX
 
 config GPIO_INTEL_MID
         bool "Intel Mid GPIO support"
-        depends on PCI && X86
+        depends on X86
         select GPIOLIB_IRQCHIP
         help
           Say Y here to support Intel Mid GPIO.
 
 config GPIO_ML_IOH
         tristate "OKI SEMICONDUCTOR ML7213 IOH GPIO support"
-        depends on PCI
         select GENERIC_IRQ_CHIP
         help
           ML7213 is companion chip for Intel Atom E6xx series.
@@ -952,7 +963,7 @@ config GPIO_ML_IOH
 
 config GPIO_PCH
         tristate "Intel EG20T PCH/LAPIS Semiconductor IOH(ML7223/ML7831) GPIO"
-        depends on PCI && (X86_32 || COMPILE_TEST)
+        depends on X86_32 || MIPS || COMPILE_TEST
         select GENERIC_IRQ_CHIP
         help
           This driver is for PCH(Platform controller Hub) GPIO of Intel Topcliff
@@ -968,7 +979,6 @@ config GPIO_PCH
 
 config GPIO_RDC321X
         tristate "RDC R-321x GPIO support"
-        depends on PCI
         select MFD_CORE
         select MFD_RDC321X
         help
@@ -977,7 +987,7 @@ config GPIO_RDC321X
 
 config GPIO_SODAVILLE
         bool "Intel Sodaville GPIO support"
-        depends on X86 && PCI && OF
+        depends on X86 && OF
         select GPIO_GENERIC
         select GENERIC_IRQ_CHIP
         help
@@ -1028,7 +1038,7 @@ menu "USB GPIO expanders"
 
 config GPIO_VIPERBOARD
         tristate "Viperboard GPIO a & b support"
-        depends on MFD_VIPERBOARD && USB
+        depends on MFD_VIPERBOARD
         help
           Say yes here to access the GPIO signals of Nano River
           Technologies Viperboard. There are two GPIO chips on the
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 986dbd838cea..548e9b5718ee 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_GPIO_ACPI)		+= gpiolib-acpi.o
 obj-$(CONFIG_GPIO_GENERIC)      += gpio-generic.o
 
 obj-$(CONFIG_GPIO_104_IDIO_16)  += gpio-104-idio-16.o
+obj-$(CONFIG_GPIO_104_IDI_48)   += gpio-104-idi-48.o
 obj-$(CONFIG_GPIO_74X164)       += gpio-74x164.o
 obj-$(CONFIG_GPIO_74XX_MMIO)    += gpio-74xx-mmio.o
 obj-$(CONFIG_GPIO_ADNP)         += gpio-adnp.o
diff --git a/drivers/gpio/gpio-104-idi-48.c b/drivers/gpio/gpio-104-idi-48.c
new file mode 100644
index 000000000000..52eed328ce99
--- /dev/null
+++ b/drivers/gpio/gpio-104-idi-48.c
@@ -0,0 +1,343 @@
+/*
+ * GPIO driver for the ACCES 104-IDI-48 family
+ * Copyright (C) 2015 William Breathitt Gray
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#include <linux/bitops.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/gpio/driver.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/interrupt.h>
+#include <linux/irqdesc.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+
+static unsigned idi_48_base;
+module_param(idi_48_base, uint, 0);
+MODULE_PARM_DESC(idi_48_base, "ACCES 104-IDI-48 base address");
+static unsigned idi_48_irq;
+module_param(idi_48_irq, uint, 0);
+MODULE_PARM_DESC(idi_48_irq, "ACCES 104-IDI-48 interrupt line number");
+
+/**
+ * struct idi_48_gpio - GPIO device private data structure
+ * @chip:       instance of the gpio_chip
+ * @lock:       synchronization lock to prevent I/O race conditions
+ * @ack_lock:   synchronization lock to prevent IRQ handler race conditions
+ * @irq_mask:   input bits affected by interrupts
+ * @base:       base port address of the GPIO device
+ * @extent:     extent of port address region of the GPIO device
+ * @irq:        Interrupt line number
+ * @cos_enb:    Change-Of-State IRQ enable boundaries mask
+ */
+struct idi_48_gpio {
+        struct gpio_chip chip;
+        spinlock_t lock;
+        spinlock_t ack_lock;
+        unsigned char irq_mask[6];
+        unsigned base;
+        unsigned extent;
+        unsigned irq;
+        unsigned char cos_enb;
+};
+
+static int idi_48_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
+{
+        return 1;
+}
+
+static int idi_48_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        return 0;
+}
+
+static int idi_48_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct idi_48_gpio *const idi48gpio = gpiochip_get_data(chip);
+        unsigned i;
+        const unsigned register_offset[6] = { 0, 1, 2, 4, 5, 6 };
+        unsigned base_offset;
+        unsigned mask;
+
+        for (i = 0; i < 48; i += 8)
+                if (offset < i + 8) {
+                        base_offset = register_offset[i / 8];
+                        mask = BIT(offset - i);
+
+                        return !!(inb(idi48gpio->base + base_offset) & mask);
+                }
+
+        /* The following line should never execute since offset < 48 */
+        return 0;
+}
+
+static void idi_48_irq_ack(struct irq_data *data)
+{
+}
+
+static void idi_48_irq_mask(struct irq_data *data)
+{
+        struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
+        struct idi_48_gpio *const idi48gpio = gpiochip_get_data(chip);
+        const unsigned offset = irqd_to_hwirq(data);
+        unsigned i;
+        unsigned mask;
+        unsigned boundary;
+        unsigned long flags;
+
+        for (i = 0; i < 48; i += 8)
+                if (offset < i + 8) {
+                        mask = BIT(offset - i);
+                        boundary = i / 8;
+
+                        idi48gpio->irq_mask[boundary] &= ~mask;
+
+                        if (!idi48gpio->irq_mask[boundary]) {
+                                idi48gpio->cos_enb &= ~BIT(boundary);
+
+                                spin_lock_irqsave(&idi48gpio->lock, flags);
+
+                                outb(idi48gpio->cos_enb, idi48gpio->base + 7);
+
+                                spin_unlock_irqrestore(&idi48gpio->lock, flags);
+                        }
+
+                        return;
+                }
+}
+
+static void idi_48_irq_unmask(struct irq_data *data)
+{
+        struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
+        struct idi_48_gpio *const idi48gpio = gpiochip_get_data(chip);
+        const unsigned offset = irqd_to_hwirq(data);
+        unsigned i;
+        unsigned mask;
+        unsigned boundary;
+        unsigned prev_irq_mask;
+        unsigned long flags;
+
+        for (i = 0; i < 48; i += 8)
+                if (offset < i + 8) {
+                        mask = BIT(offset - i);
+                        boundary = i / 8;
+                        prev_irq_mask = idi48gpio->irq_mask[boundary];
+
+                        idi48gpio->irq_mask[boundary] |= mask;
+
+                        if (!prev_irq_mask) {
+                                idi48gpio->cos_enb |= BIT(boundary);
+
+                                spin_lock_irqsave(&idi48gpio->lock, flags);
+
+                                outb(idi48gpio->cos_enb, idi48gpio->base + 7);
+
+                                spin_unlock_irqrestore(&idi48gpio->lock, flags);
+                        }
+
+                        return;
+                }
+}
+
+static int idi_48_irq_set_type(struct irq_data *data, unsigned flow_type)
+{
+        /* The only valid irq types are none and both-edges */
+        if (flow_type != IRQ_TYPE_NONE &&
+                (flow_type & IRQ_TYPE_EDGE_BOTH) != IRQ_TYPE_EDGE_BOTH)
+                return -EINVAL;
+
+        return 0;
+}
+
+static struct irq_chip idi_48_irqchip = {
+        .name = "104-idi-48",
+        .irq_ack = idi_48_irq_ack,
+        .irq_mask = idi_48_irq_mask,
+        .irq_unmask = idi_48_irq_unmask,
+        .irq_set_type = idi_48_irq_set_type
+};
+
+static irqreturn_t idi_48_irq_handler(int irq, void *dev_id)
+{
+        struct idi_48_gpio *const idi48gpio = dev_id;
+        unsigned long cos_status;
+        unsigned long boundary;
+        unsigned long irq_mask;
+        unsigned long bit_num;
+        unsigned long gpio;
+        struct gpio_chip *const chip = &idi48gpio->chip;
+
+        spin_lock(&idi48gpio->ack_lock);
+
+        spin_lock(&idi48gpio->lock);
+
+        cos_status = inb(idi48gpio->base + 7);
+
+        spin_unlock(&idi48gpio->lock);
+
+        /* IRQ Status (bit 6) is active low (0 = IRQ generated by device) */
+        if (cos_status & BIT(6)) {
+                spin_unlock(&idi48gpio->ack_lock);
+                return IRQ_NONE;
+        }
+
+        /* Bit 0-5 indicate which Change-Of-State boundary triggered the IRQ */
+        cos_status &= 0x3F;
+
+        for_each_set_bit(boundary, &cos_status, 6) {
+                irq_mask = idi48gpio->irq_mask[boundary];
+
+                for_each_set_bit(bit_num, &irq_mask, 8) {
+                        gpio = bit_num + boundary * 8;
+
+                        generic_handle_irq(irq_find_mapping(chip->irqdomain,
+                                gpio));
+                }
+        }
+
+        spin_unlock(&idi48gpio->ack_lock);
+
+        return IRQ_HANDLED;
+}
+
+static int __init idi_48_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct idi_48_gpio *idi48gpio;
+        const unsigned base = idi_48_base;
+        const unsigned extent = 8;
+        const char *const name = dev_name(dev);
+        int err;
+        const unsigned irq = idi_48_irq;
+
+        idi48gpio = devm_kzalloc(dev, sizeof(*idi48gpio), GFP_KERNEL);
+        if (!idi48gpio)
+                return -ENOMEM;
+
+        if (!request_region(base, extent, name)) {
+                dev_err(dev, "Unable to lock %s port addresses (0x%X-0x%X)\n",
+                        name, base, base + extent);
+                err = -EBUSY;
+                goto err_lock_io_port;
+        }
+
+        idi48gpio->chip.label = name;
+        idi48gpio->chip.parent = dev;
+        idi48gpio->chip.owner = THIS_MODULE;
+        idi48gpio->chip.base = -1;
+        idi48gpio->chip.ngpio = 48;
+        idi48gpio->chip.get_direction = idi_48_gpio_get_direction;
+        idi48gpio->chip.direction_input = idi_48_gpio_direction_input;
+        idi48gpio->chip.get = idi_48_gpio_get;
+        idi48gpio->base = base;
+        idi48gpio->extent = extent;
+        idi48gpio->irq = irq;
+
+        spin_lock_init(&idi48gpio->lock);
+
+        dev_set_drvdata(dev, idi48gpio);
+
+        err = gpiochip_add_data(&idi48gpio->chip, idi48gpio);
+        if (err) {
+                dev_err(dev, "GPIO registering failed (%d)\n", err);
+                goto err_gpio_register;
+        }
+
+        /* Disable IRQ by default */
+        outb(0, base + 7);
+        inb(base + 7);
+
+        err = gpiochip_irqchip_add(&idi48gpio->chip, &idi_48_irqchip, 0,
+                handle_edge_irq, IRQ_TYPE_NONE);
+        if (err) {
+                dev_err(dev, "Could not add irqchip (%d)\n", err);
+                goto err_gpiochip_irqchip_add;
+        }
+
+        err = request_irq(irq, idi_48_irq_handler, 0, name, idi48gpio);
+        if (err) {
+                dev_err(dev, "IRQ handler registering failed (%d)\n", err);
+                goto err_request_irq;
+        }
+
+        return 0;
+
+err_request_irq:
+err_gpiochip_irqchip_add:
+        gpiochip_remove(&idi48gpio->chip);
+err_gpio_register:
+        release_region(base, extent);
+err_lock_io_port:
+        return err;
+}
+
+static int idi_48_remove(struct platform_device *pdev)
+{
+        struct idi_48_gpio *const idi48gpio = platform_get_drvdata(pdev);
+
+        free_irq(idi48gpio->irq, idi48gpio);
+        gpiochip_remove(&idi48gpio->chip);
+        release_region(idi48gpio->base, idi48gpio->extent);
+
+        return 0;
+}
+
+static struct platform_device *idi_48_device;
+
+static struct platform_driver idi_48_driver = {
+        .driver = {
+                .name = "104-idi-48"
+        },
+        .remove = idi_48_remove
+};
+
+static void __exit idi_48_exit(void)
+{
+        platform_device_unregister(idi_48_device);
+        platform_driver_unregister(&idi_48_driver);
+}
+
+static int __init idi_48_init(void)
+{
+        int err;
+
+        idi_48_device = platform_device_alloc(idi_48_driver.driver.name, -1);
+        if (!idi_48_device)
+                return -ENOMEM;
+
+        err = platform_device_add(idi_48_device);
+        if (err)
+                goto err_platform_device;
+
+        err = platform_driver_probe(&idi_48_driver, idi_48_probe);
+        if (err)
+                goto err_platform_driver;
+
+        return 0;
+
+err_platform_driver:
+        platform_device_del(idi_48_device);
+err_platform_device:
+        platform_device_put(idi_48_device);
+        return err;
+}
+
+module_init(idi_48_init);
+module_exit(idi_48_exit);
+
+MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
+MODULE_DESCRIPTION("ACCES 104-IDI-48 GPIO driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/gpio/gpio-104-idio-16.c b/drivers/gpio/gpio-104-idio-16.c
index 5400d7d4d8fd..4d69b50b2d84 100644
--- a/drivers/gpio/gpio-104-idio-16.c
+++ b/drivers/gpio/gpio-104-idio-16.c
@@ -11,11 +11,14 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  */
+#include <linux/bitops.h>
 #include <linux/device.h>
 #include <linux/errno.h>
 #include <linux/gpio/driver.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
+#include <linux/interrupt.h>
+#include <linux/irqdesc.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
@@ -25,20 +28,27 @@
 static unsigned idio_16_base;
 module_param(idio_16_base, uint, 0);
 MODULE_PARM_DESC(idio_16_base, "ACCES 104-IDIO-16 base address");
+static unsigned idio_16_irq;
+module_param(idio_16_irq, uint, 0);
+MODULE_PARM_DESC(idio_16_irq, "ACCES 104-IDIO-16 interrupt line number");
 
 /**
  * struct idio_16_gpio - GPIO device private data structure
  * @chip:       instance of the gpio_chip
- * @lock:       synchronization lock to prevent gpio_set race conditions
+ * @lock:       synchronization lock to prevent I/O race conditions
+ * @irq_mask:   I/O bits affected by interrupts
  * @base:       base port address of the GPIO device
  * @extent:     extent of port address region of the GPIO device
+ * @irq:        Interrupt line number
  * @out_state:  output bits state
  */
 struct idio_16_gpio {
         struct gpio_chip chip;
         spinlock_t lock;
+        unsigned long irq_mask;
         unsigned base;
         unsigned extent;
+        unsigned irq;
         unsigned out_state;
 };
 
@@ -62,29 +72,24 @@ static int idio_16_gpio_direction_output(struct gpio_chip *chip,
         return 0;
 }
 
-static struct idio_16_gpio *to_idio16gpio(struct gpio_chip *gc)
-{
-        return container_of(gc, struct idio_16_gpio, chip);
-}
-
 static int idio_16_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct idio_16_gpio *const idio16gpio = to_idio16gpio(chip);
-        const unsigned BIT_MASK = 1U << (offset-16);
+        struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
+        const unsigned mask = BIT(offset-16);
 
         if (offset < 16)
                 return -EINVAL;
 
         if (offset < 24)
-                return !!(inb(idio16gpio->base + 1) & BIT_MASK);
+                return !!(inb(idio16gpio->base + 1) & mask);
 
-        return !!(inb(idio16gpio->base + 5) & (BIT_MASK>>8));
+        return !!(inb(idio16gpio->base + 5) & (mask>>8));
 }
 
 static void idio_16_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct idio_16_gpio *const idio16gpio = to_idio16gpio(chip);
-        const unsigned BIT_MASK = 1U << offset;
+        struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
+        const unsigned mask = BIT(offset);
         unsigned long flags;
 
         if (offset > 15)
@@ -93,9 +98,9 @@ static void idio_16_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
         spin_lock_irqsave(&idio16gpio->lock, flags);
 
         if (value)
-                idio16gpio->out_state |= BIT_MASK;
+                idio16gpio->out_state |= mask;
         else
-                idio16gpio->out_state &= ~BIT_MASK;
+                idio16gpio->out_state &= ~mask;
 
         if (offset > 7)
                 outb(idio16gpio->out_state >> 8, idio16gpio->base + 4);
@@ -105,29 +110,106 @@ static void idio_16_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
         spin_unlock_irqrestore(&idio16gpio->lock, flags);
 }
 
+static void idio_16_irq_ack(struct irq_data *data)
+{
+}
+
+static void idio_16_irq_mask(struct irq_data *data)
+{
+        struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
+        struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
+        const unsigned long mask = BIT(irqd_to_hwirq(data));
+        unsigned long flags;
+
+        idio16gpio->irq_mask &= ~mask;
+
+        if (!idio16gpio->irq_mask) {
+                spin_lock_irqsave(&idio16gpio->lock, flags);
+
+                outb(0, idio16gpio->base + 2);
+
+                spin_unlock_irqrestore(&idio16gpio->lock, flags);
+        }
+}
+
+static void idio_16_irq_unmask(struct irq_data *data)
+{
+        struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
+        struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
+        const unsigned long mask = BIT(irqd_to_hwirq(data));
+        const unsigned long prev_irq_mask = idio16gpio->irq_mask;
+        unsigned long flags;
+
+        idio16gpio->irq_mask |= mask;
+
+        if (!prev_irq_mask) {
+                spin_lock_irqsave(&idio16gpio->lock, flags);
+
+                inb(idio16gpio->base + 2);
+
+                spin_unlock_irqrestore(&idio16gpio->lock, flags);
+        }
+}
+
+static int idio_16_irq_set_type(struct irq_data *data, unsigned flow_type)
+{
+        /* The only valid irq types are none and both-edges */
+        if (flow_type != IRQ_TYPE_NONE &&
+                (flow_type & IRQ_TYPE_EDGE_BOTH) != IRQ_TYPE_EDGE_BOTH)
+                return -EINVAL;
+
+        return 0;
+}
+
+static struct irq_chip idio_16_irqchip = {
+        .name = "104-idio-16",
+        .irq_ack = idio_16_irq_ack,
+        .irq_mask = idio_16_irq_mask,
+        .irq_unmask = idio_16_irq_unmask,
+        .irq_set_type = idio_16_irq_set_type
+};
+
+static irqreturn_t idio_16_irq_handler(int irq, void *dev_id)
+{
+        struct idio_16_gpio *const idio16gpio = dev_id;
+        struct gpio_chip *const chip = &idio16gpio->chip;
+        int gpio;
+
+        for_each_set_bit(gpio, &idio16gpio->irq_mask, chip->ngpio)
+                generic_handle_irq(irq_find_mapping(chip->irqdomain, gpio));
+
+        spin_lock(&idio16gpio->lock);
+
+        outb(0, idio16gpio->base + 1);
+
+        spin_unlock(&idio16gpio->lock);
+
+        return IRQ_HANDLED;
+}
+
 static int __init idio_16_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct idio_16_gpio *idio16gpio;
+        const unsigned base = idio_16_base;
+        const unsigned extent = 8;
+        const char *const name = dev_name(dev);
         int err;
-
-        const unsigned BASE = idio_16_base;
-        const unsigned EXTENT = 8;
-        const char *const NAME = dev_name(dev);
+        const unsigned irq = idio_16_irq;
 
         idio16gpio = devm_kzalloc(dev, sizeof(*idio16gpio), GFP_KERNEL);
         if (!idio16gpio)
                 return -ENOMEM;
 
-        if (!request_region(BASE, EXTENT, NAME)) {
+        if (!request_region(base, extent, name)) {
                 dev_err(dev, "Unable to lock %s port addresses (0x%X-0x%X)\n",
-                        NAME, BASE, BASE + EXTENT);
+                        name, base, base + extent);
                 err = -EBUSY;
                 goto err_lock_io_port;
         }
 
-        idio16gpio->chip.label = NAME;
-        idio16gpio->chip.dev = dev;
+        idio16gpio->chip.label = name;
+        idio16gpio->chip.parent = dev;
         idio16gpio->chip.owner = THIS_MODULE;
         idio16gpio->chip.base = -1;
         idio16gpio->chip.ngpio = 32;
@@ -136,24 +218,45 @@ static int __init idio_16_probe(struct platform_device *pdev)
         idio16gpio->chip.direction_output = idio_16_gpio_direction_output;
         idio16gpio->chip.get = idio_16_gpio_get;
         idio16gpio->chip.set = idio_16_gpio_set;
-        idio16gpio->base = BASE;
-        idio16gpio->extent = EXTENT;
+        idio16gpio->base = base;
+        idio16gpio->extent = extent;
+        idio16gpio->irq = irq;
         idio16gpio->out_state = 0xFFFF;
 
         spin_lock_init(&idio16gpio->lock);
 
         dev_set_drvdata(dev, idio16gpio);
 
-        err = gpiochip_add(&idio16gpio->chip);
+        err = gpiochip_add_data(&idio16gpio->chip, idio16gpio);
         if (err) {
                 dev_err(dev, "GPIO registering failed (%d)\n", err);
                 goto err_gpio_register;
         }
 
+        /* Disable IRQ by default */
+        outb(0, base + 2);
+        outb(0, base + 1);
+
+        err = gpiochip_irqchip_add(&idio16gpio->chip, &idio_16_irqchip, 0,
+                handle_edge_irq, IRQ_TYPE_NONE);
+        if (err) {
+                dev_err(dev, "Could not add irqchip (%d)\n", err);
+                goto err_gpiochip_irqchip_add;
+        }
+
+        err = request_irq(irq, idio_16_irq_handler, 0, name, idio16gpio);
+        if (err) {
+                dev_err(dev, "IRQ handler registering failed (%d)\n", err);
+                goto err_request_irq;
+        }
+
         return 0;
 
+err_request_irq:
+err_gpiochip_irqchip_add:
+        gpiochip_remove(&idio16gpio->chip);
 err_gpio_register:
-        release_region(BASE, EXTENT);
+        release_region(base, extent);
 err_lock_io_port:
         return err;
 }
@@ -162,6 +265,7 @@ static int idio_16_remove(struct platform_device *pdev)
 {
         struct idio_16_gpio *const idio16gpio = platform_get_drvdata(pdev);
 
+        free_irq(idio16gpio->irq, idio16gpio);
         gpiochip_remove(&idio16gpio->chip);
         release_region(idio16gpio->base, idio16gpio->extent);
 
diff --git a/drivers/gpio/gpio-74x164.c b/drivers/gpio/gpio-74x164.c
index 60172f835d15..c81224ff2dca 100644
--- a/drivers/gpio/gpio-74x164.c
+++ b/drivers/gpio/gpio-74x164.c
@@ -20,56 +20,34 @@
 #define GEN_74X164_NUMBER_GPIOS 8
 
 struct gen_74x164_chip {
-        u8                      *buffer;
         struct gpio_chip        gpio_chip;
         struct mutex            lock;
         u32                     registers;
-};
-
-static struct gen_74x164_chip *gpio_to_74x164_chip(struct gpio_chip *gc)
-{
-        return container_of(gc, struct gen_74x164_chip, gpio_chip);
-}
-
-static int __gen_74x164_write_config(struct gen_74x164_chip *chip)
-{
-        struct spi_device *spi = to_spi_device(chip->gpio_chip.dev);
-        struct spi_message message;
-        struct spi_transfer *msg_buf;
-        int i, ret = 0;
-
-        msg_buf = kzalloc(chip->registers * sizeof(struct spi_transfer),
-                        GFP_KERNEL);
-        if (!msg_buf)
-                return -ENOMEM;
-
-        spi_message_init(&message);
-
         /*
          * Since the registers are chained, every byte sent will make
          * the previous byte shift to the next register in the
-         * chain. Thus, the first byte send will end up in the last
+         * chain. Thus, the first byte sent will end up in the last
          * register at the end of the transfer. So, to have a logical
-         * numbering, send the bytes in reverse order so that the last
-         * byte of the buffer will end up in the last register.
+         * numbering, store the bytes in reverse order.
          */
-        for (i = chip->registers - 1; i >= 0; i--) {
-                msg_buf[i].tx_buf = chip->buffer + i;
-                msg_buf[i].len = sizeof(u8);
-                spi_message_add_tail(msg_buf + i, &message);
-        }
-
-        ret = spi_sync(spi, &message);
+        u8                      buffer[0];
+};
 
-        kfree(msg_buf);
+static int __gen_74x164_write_config(struct gen_74x164_chip *chip)
+{
+        struct spi_transfer xfer = {
+                .tx_buf = chip->buffer,
+                .len = chip->registers,
+        };
 
-        return ret;
+        return spi_sync_transfer(to_spi_device(chip->gpio_chip.parent),
+                                 &xfer, 1);
 }
 
 static int gen_74x164_get_value(struct gpio_chip *gc, unsigned offset)
 {
-        struct gen_74x164_chip *chip = gpio_to_74x164_chip(gc);
-        u8 bank = offset / 8;
+        struct gen_74x164_chip *chip = gpiochip_get_data(gc);
+        u8 bank = chip->registers - 1 - offset / 8;
         u8 pin = offset % 8;
         int ret;
 
@@ -83,8 +61,8 @@ static int gen_74x164_get_value(struct gpio_chip *gc, unsigned offset)
 static void gen_74x164_set_value(struct gpio_chip *gc,
                 unsigned offset, int val)
 {
-        struct gen_74x164_chip *chip = gpio_to_74x164_chip(gc);
-        u8 bank = offset / 8;
+        struct gen_74x164_chip *chip = gpiochip_get_data(gc);
+        u8 bank = chip->registers - 1 - offset / 8;
         u8 pin = offset % 8;
 
         mutex_lock(&chip->lock);
@@ -107,6 +85,7 @@ static int gen_74x164_direction_output(struct gpio_chip *gc,
 static int gen_74x164_probe(struct spi_device *spi)
 {
         struct gen_74x164_chip *chip;
+        u32 nregs;
         int ret;
 
         /*
@@ -118,7 +97,14 @@ static int gen_74x164_probe(struct spi_device *spi)
         if (ret < 0)
                 return ret;
 
-        chip = devm_kzalloc(&spi->dev, sizeof(*chip), GFP_KERNEL);
+        if (of_property_read_u32(spi->dev.of_node, "registers-number",
+                                 &nregs)) {
+                dev_err(&spi->dev,
+                        "Missing registers-number property in the DT.\n");
+                return -EINVAL;
+        }
+
+        chip = devm_kzalloc(&spi->dev, sizeof(*chip) + nregs, GFP_KERNEL);
         if (!chip)
                 return -ENOMEM;
 
@@ -130,20 +116,11 @@ static int gen_74x164_probe(struct spi_device *spi)
         chip->gpio_chip.set = gen_74x164_set_value;
         chip->gpio_chip.base = -1;
 
-        if (of_property_read_u32(spi->dev.of_node, "registers-number",
-                                 &chip->registers)) {
-                dev_err(&spi->dev,
-                        "Missing registers-number property in the DT.\n");
-                return -EINVAL;
-        }
-
+        chip->registers = nregs;
         chip->gpio_chip.ngpio = GEN_74X164_NUMBER_GPIOS * chip->registers;
-        chip->buffer = devm_kzalloc(&spi->dev, chip->registers, GFP_KERNEL);
-        if (!chip->buffer)
-                return -ENOMEM;
 
         chip->gpio_chip.can_sleep = true;
-        chip->gpio_chip.dev = &spi->dev;
+        chip->gpio_chip.parent = &spi->dev;
         chip->gpio_chip.owner = THIS_MODULE;
 
         mutex_init(&chip->lock);
@@ -154,7 +131,7 @@ static int gen_74x164_probe(struct spi_device *spi)
                 goto exit_destroy;
         }
 
-        ret = gpiochip_add(&chip->gpio_chip);
+        ret = gpiochip_add_data(&chip->gpio_chip, chip);
         if (!ret)
                 return 0;
 
diff --git a/drivers/gpio/gpio-74xx-mmio.c b/drivers/gpio/gpio-74xx-mmio.c
index 6b186829087c..372b0e01adc6 100644
--- a/drivers/gpio/gpio-74xx-mmio.c
+++ b/drivers/gpio/gpio-74xx-mmio.c
@@ -10,10 +10,9 @@
  */
 
 #include <linux/err.h>
-#include <linux/gpio.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/platform_device.h>
 
 #define MMIO_74XX_DIR_IN        (0 << 8)
@@ -21,7 +20,7 @@
 #define MMIO_74XX_BIT_CNT(x)    ((x) & 0xff)
 
 struct mmio_74xx_gpio_priv {
-        struct bgpio_chip       bgc;
+        struct gpio_chip        gc;
         unsigned                flags;
 };
 
@@ -78,30 +77,23 @@ static const struct of_device_id mmio_74xx_gpio_ids[] = {
 };
 MODULE_DEVICE_TABLE(of, mmio_74xx_gpio_ids);
 
-static inline struct mmio_74xx_gpio_priv *to_74xx_gpio(struct gpio_chip *gc)
-{
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        return container_of(bgc, struct mmio_74xx_gpio_priv, bgc);
-}
-
 static int mmio_74xx_get_direction(struct gpio_chip *gc, unsigned offset)
 {
-        struct mmio_74xx_gpio_priv *priv = to_74xx_gpio(gc);
+        struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
 
-        return (priv->flags & MMIO_74XX_DIR_OUT) ? GPIOF_DIR_OUT : GPIOF_DIR_IN;
+        return !(priv->flags & MMIO_74XX_DIR_OUT);
 }
 
 static int mmio_74xx_dir_in(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct mmio_74xx_gpio_priv *priv = to_74xx_gpio(gc);
+        struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
 
         return (priv->flags & MMIO_74XX_DIR_OUT) ? -ENOTSUPP : 0;
 }
 
 static int mmio_74xx_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 {
-        struct mmio_74xx_gpio_priv *priv = to_74xx_gpio(gc);
+        struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
 
         if (priv->flags & MMIO_74XX_DIR_OUT) {
                 gc->set(gc, gpio, val);
@@ -134,28 +126,29 @@ static int mmio_74xx_gpio_probe(struct platform_device *pdev)
 
         priv->flags = (uintptr_t) of_id->data;
 
-        err = bgpio_init(&priv->bgc, &pdev->dev,
+        err = bgpio_init(&priv->gc, &pdev->dev,
                          DIV_ROUND_UP(MMIO_74XX_BIT_CNT(priv->flags), 8),
                          dat, NULL, NULL, NULL, NULL, 0);
         if (err)
                 return err;
 
-        priv->bgc.gc.direction_input = mmio_74xx_dir_in;
-        priv->bgc.gc.direction_output = mmio_74xx_dir_out;
-        priv->bgc.gc.get_direction = mmio_74xx_get_direction;
-        priv->bgc.gc.ngpio = MMIO_74XX_BIT_CNT(priv->flags);
-        priv->bgc.gc.owner = THIS_MODULE;
+        priv->gc.direction_input = mmio_74xx_dir_in;
+        priv->gc.direction_output = mmio_74xx_dir_out;
+        priv->gc.get_direction = mmio_74xx_get_direction;
+        priv->gc.ngpio = MMIO_74XX_BIT_CNT(priv->flags);
+        priv->gc.owner = THIS_MODULE;
 
         platform_set_drvdata(pdev, priv);
 
-        return gpiochip_add(&priv->bgc.gc);
+        return gpiochip_add_data(&priv->gc, priv);
 }
 
 static int mmio_74xx_gpio_remove(struct platform_device *pdev)
 {
         struct mmio_74xx_gpio_priv *priv = platform_get_drvdata(pdev);
 
-        return bgpio_remove(&priv->bgc);
+        gpiochip_remove(&priv->gc);
+        return 0;
 }
 
 static struct platform_driver mmio_74xx_gpio_driver = {
diff --git a/drivers/gpio/gpio-adnp.c b/drivers/gpio/gpio-adnp.c
index d3d0a90fe542..fb5b47b69f14 100644
--- a/drivers/gpio/gpio-adnp.c
+++ b/drivers/gpio/gpio-adnp.c
@@ -36,18 +36,13 @@ struct adnp {
         u8 *irq_low;
 };
 
-static inline struct adnp *to_adnp(struct gpio_chip *chip)
-{
-        return container_of(chip, struct adnp, gpio);
-}
-
 static int adnp_read(struct adnp *adnp, unsigned offset, uint8_t *value)
 {
         int err;
 
         err = i2c_smbus_read_byte_data(adnp->client, offset);
         if (err < 0) {
-                dev_err(adnp->gpio.dev, "%s failed: %d\n",
+                dev_err(adnp->gpio.parent, "%s failed: %d\n",
                         "i2c_smbus_read_byte_data()", err);
                 return err;
         }
@@ -62,7 +57,7 @@ static int adnp_write(struct adnp *adnp, unsigned offset, uint8_t value)
 
         err = i2c_smbus_write_byte_data(adnp->client, offset, value);
         if (err < 0) {
-                dev_err(adnp->gpio.dev, "%s failed: %d\n",
+                dev_err(adnp->gpio.parent, "%s failed: %d\n",
                         "i2c_smbus_write_byte_data()", err);
                 return err;
         }
@@ -72,7 +67,7 @@ static int adnp_write(struct adnp *adnp, unsigned offset, uint8_t value)
 
 static int adnp_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct adnp *adnp = to_adnp(chip);
+        struct adnp *adnp = gpiochip_get_data(chip);
         unsigned int reg = offset >> adnp->reg_shift;
         unsigned int pos = offset & 7;
         u8 value;
@@ -106,7 +101,7 @@ static void __adnp_gpio_set(struct adnp *adnp, unsigned offset, int value)
 
 static void adnp_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct adnp *adnp = to_adnp(chip);
+        struct adnp *adnp = gpiochip_get_data(chip);
 
         mutex_lock(&adnp->i2c_lock);
         __adnp_gpio_set(adnp, offset, value);
@@ -115,7 +110,7 @@ static void adnp_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int adnp_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct adnp *adnp = to_adnp(chip);
+        struct adnp *adnp = gpiochip_get_data(chip);
         unsigned int reg = offset >> adnp->reg_shift;
         unsigned int pos = offset & 7;
         u8 value;
@@ -150,7 +145,7 @@ out:
 static int adnp_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                       int value)
 {
-        struct adnp *adnp = to_adnp(chip);
+        struct adnp *adnp = gpiochip_get_data(chip);
         unsigned int reg = offset >> adnp->reg_shift;
         unsigned int pos = offset & 7;
         int err;
@@ -187,7 +182,7 @@ out:
 
 static void adnp_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct adnp *adnp = to_adnp(chip);
+        struct adnp *adnp = gpiochip_get_data(chip);
         unsigned int num_regs = 1 << adnp->reg_shift, i, j;
         int err;
 
@@ -266,11 +261,11 @@ static int adnp_gpio_setup(struct adnp *adnp, unsigned int num_gpios)
         chip->base = -1;
         chip->ngpio = num_gpios;
         chip->label = adnp->client->name;
-        chip->dev = &adnp->client->dev;
-        chip->of_node = chip->dev->of_node;
+        chip->parent = &adnp->client->dev;
+        chip->of_node = chip->parent->of_node;
         chip->owner = THIS_MODULE;
 
-        err = gpiochip_add(chip);
+        err = gpiochip_add_data(chip, adnp);
         if (err)
                 return err;
 
@@ -340,7 +335,7 @@ static irqreturn_t adnp_irq(int irq, void *data)
 static void adnp_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct adnp *adnp = to_adnp(gc);
+        struct adnp *adnp = gpiochip_get_data(gc);
         unsigned int reg = d->hwirq >> adnp->reg_shift;
         unsigned int pos = d->hwirq & 7;
 
@@ -350,7 +345,7 @@ static void adnp_irq_mask(struct irq_data *d)
 static void adnp_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct adnp *adnp = to_adnp(gc);
+        struct adnp *adnp = gpiochip_get_data(gc);
         unsigned int reg = d->hwirq >> adnp->reg_shift;
         unsigned int pos = d->hwirq & 7;
 
@@ -360,7 +355,7 @@ static void adnp_irq_unmask(struct irq_data *d)
 static int adnp_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct adnp *adnp = to_adnp(gc);
+        struct adnp *adnp = gpiochip_get_data(gc);
         unsigned int reg = d->hwirq >> adnp->reg_shift;
         unsigned int pos = d->hwirq & 7;
 
@@ -390,7 +385,7 @@ static int adnp_irq_set_type(struct irq_data *d, unsigned int type)
 static void adnp_irq_bus_lock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct adnp *adnp = to_adnp(gc);
+        struct adnp *adnp = gpiochip_get_data(gc);
 
         mutex_lock(&adnp->irq_lock);
 }
@@ -398,7 +393,7 @@ static void adnp_irq_bus_lock(struct irq_data *d)
 static void adnp_irq_bus_unlock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct adnp *adnp = to_adnp(gc);
+        struct adnp *adnp = gpiochip_get_data(gc);
         unsigned int num_regs = 1 << adnp->reg_shift, i;
 
         mutex_lock(&adnp->i2c_lock);
@@ -435,7 +430,8 @@ static int adnp_irq_setup(struct adnp *adnp)
          * is chosen to match the register layout of the hardware in that
          * each segment contains the corresponding bits for all interrupts.
          */
-        adnp->irq_enable = devm_kzalloc(chip->dev, num_regs * 6, GFP_KERNEL);
+        adnp->irq_enable = devm_kzalloc(chip->parent, num_regs * 6,
+                                        GFP_KERNEL);
         if (!adnp->irq_enable)
                 return -ENOMEM;
 
@@ -462,12 +458,12 @@ static int adnp_irq_setup(struct adnp *adnp)
                 adnp->irq_enable[i] = 0x00;
         }
 
-        err = devm_request_threaded_irq(chip->dev, adnp->client->irq,
+        err = devm_request_threaded_irq(chip->parent, adnp->client->irq,
                                         NULL, adnp_irq,
                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
-                                        dev_name(chip->dev), adnp);
+                                        dev_name(chip->parent), adnp);
         if (err != 0) {
-                dev_err(chip->dev, "can't request IRQ#%d: %d\n",
+                dev_err(chip->parent, "can't request IRQ#%d: %d\n",
                         adnp->client->irq, err);
                 return err;
         }
@@ -478,7 +474,7 @@ static int adnp_irq_setup(struct adnp *adnp)
                                    handle_simple_irq,
                                    IRQ_TYPE_NONE);
         if (err) {
-                dev_err(chip->dev,
+                dev_err(chip->parent,
                         "could not connect irqchip to gpiochip\n");
                 return err;
         }
@@ -547,7 +543,6 @@ MODULE_DEVICE_TABLE(of, adnp_of_match);
 static struct i2c_driver adnp_i2c_driver = {
         .driver = {
                 .name = "gpio-adnp",
-                .owner = THIS_MODULE,
                 .of_match_table = adnp_of_match,
         },
         .probe = adnp_i2c_probe,
diff --git a/drivers/gpio/gpio-adp5520.c b/drivers/gpio/gpio-adp5520.c
index caff711ca5a9..4fa7ff1fec9a 100644
--- a/drivers/gpio/gpio-adp5520.c
+++ b/drivers/gpio/gpio-adp5520.c
@@ -27,7 +27,7 @@ static int adp5520_gpio_get_value(struct gpio_chip *chip, unsigned off)
         struct adp5520_gpio *dev;
         uint8_t reg_val;
 
-        dev = container_of(chip, struct adp5520_gpio, gpio_chip);
+        dev = gpiochip_get_data(chip);
 
         /*
          * There are dedicated registers for GPIO IN/OUT.
@@ -46,7 +46,7 @@ static void adp5520_gpio_set_value(struct gpio_chip *chip,
                 unsigned off, int val)
 {
         struct adp5520_gpio *dev;
-        dev = container_of(chip, struct adp5520_gpio, gpio_chip);
+        dev = gpiochip_get_data(chip);
 
         if (val)
                 adp5520_set_bits(dev->master, ADP5520_GPIO_OUT, dev->lut[off]);
@@ -57,7 +57,7 @@ static void adp5520_gpio_set_value(struct gpio_chip *chip,
 static int adp5520_gpio_direction_input(struct gpio_chip *chip, unsigned off)
 {
         struct adp5520_gpio *dev;
-        dev = container_of(chip, struct adp5520_gpio, gpio_chip);
+        dev = gpiochip_get_data(chip);
 
         clear_bit(off, &dev->output);
 
@@ -70,7 +70,7 @@ static int adp5520_gpio_direction_output(struct gpio_chip *chip,
 {
         struct adp5520_gpio *dev;
         int ret = 0;
-        dev = container_of(chip, struct adp5520_gpio, gpio_chip);
+        dev = gpiochip_get_data(chip);
 
         set_bit(off, &dev->output);
 
@@ -153,7 +153,7 @@ static int adp5520_gpio_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        ret = gpiochip_add(&dev->gpio_chip);
+        ret = gpiochip_add_data(&dev->gpio_chip, dev);
         if (ret)
                 goto err;
 
diff --git a/drivers/gpio/gpio-adp5588.c b/drivers/gpio/gpio-adp5588.c
index 984186ee58a0..19a0eba1e942 100644
--- a/drivers/gpio/gpio-adp5588.c
+++ b/drivers/gpio/gpio-adp5588.c
@@ -65,8 +65,7 @@ static int adp5588_gpio_write(struct i2c_client *client, u8 reg, u8 val)
 
 static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
 {
-        struct adp5588_gpio *dev =
-            container_of(chip, struct adp5588_gpio, gpio_chip);
+        struct adp5588_gpio *dev = gpiochip_get_data(chip);
         unsigned bank = ADP5588_BANK(off);
         unsigned bit = ADP5588_BIT(off);
         int val;
@@ -87,8 +86,7 @@ static void adp5588_gpio_set_value(struct gpio_chip *chip,
                                    unsigned off, int val)
 {
         unsigned bank, bit;
-        struct adp5588_gpio *dev =
-            container_of(chip, struct adp5588_gpio, gpio_chip);
+        struct adp5588_gpio *dev = gpiochip_get_data(chip);
 
         bank = ADP5588_BANK(off);
         bit = ADP5588_BIT(off);
@@ -108,8 +106,7 @@ static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
 {
         int ret;
         unsigned bank;
-        struct adp5588_gpio *dev =
-            container_of(chip, struct adp5588_gpio, gpio_chip);
+        struct adp5588_gpio *dev = gpiochip_get_data(chip);
 
         bank = ADP5588_BANK(off);
 
@@ -126,8 +123,7 @@ static int adp5588_gpio_direction_output(struct gpio_chip *chip,
 {
         int ret;
         unsigned bank, bit;
-        struct adp5588_gpio *dev =
-            container_of(chip, struct adp5588_gpio, gpio_chip);
+        struct adp5588_gpio *dev = gpiochip_get_data(chip);
 
         bank = ADP5588_BANK(off);
         bit = ADP5588_BIT(off);
@@ -152,8 +148,8 @@ static int adp5588_gpio_direction_output(struct gpio_chip *chip,
 #ifdef CONFIG_GPIO_ADP5588_IRQ
 static int adp5588_gpio_to_irq(struct gpio_chip *chip, unsigned off)
 {
-        struct adp5588_gpio *dev =
-                container_of(chip, struct adp5588_gpio, gpio_chip);
+        struct adp5588_gpio *dev = gpiochip_get_data(chip);
+
         return dev->irq_base + off;
 }
 
@@ -418,7 +414,7 @@ static int adp5588_gpio_probe(struct i2c_client *client,
                 }
         }
 
-        ret = gpiochip_add(&dev->gpio_chip);
+        ret = gpiochip_add_data(&dev->gpio_chip, dev);
         if (ret)
                 goto err_irq;
 
diff --git a/drivers/gpio/gpio-altera.c b/drivers/gpio/gpio-altera.c
index 3e6661bab54a..2aeaebd1c6e7 100644
--- a/drivers/gpio/gpio-altera.c
+++ b/drivers/gpio/gpio-altera.c
@@ -42,11 +42,6 @@ struct altera_gpio_chip {
         int mapped_irq;
 };
 
-static struct altera_gpio_chip *to_altera(struct gpio_chip *gc)
-{
-        return container_of(gc, struct altera_gpio_chip, mmchip.gc);
-}
-
 static void altera_gpio_irq_unmask(struct irq_data *d)
 {
         struct altera_gpio_chip *altera_gc;
@@ -54,7 +49,7 @@ static void altera_gpio_irq_unmask(struct irq_data *d)
         unsigned long flags;
         u32 intmask;
 
-        altera_gc = to_altera(irq_data_get_irq_chip_data(d));
+        altera_gc = gpiochip_get_data(irq_data_get_irq_chip_data(d));
         mm_gc = &altera_gc->mmchip;
 
         spin_lock_irqsave(&altera_gc->gpio_lock, flags);
@@ -72,7 +67,7 @@ static void altera_gpio_irq_mask(struct irq_data *d)
         unsigned long flags;
         u32 intmask;
 
-        altera_gc = to_altera(irq_data_get_irq_chip_data(d));
+        altera_gc = gpiochip_get_data(irq_data_get_irq_chip_data(d));
         mm_gc = &altera_gc->mmchip;
 
         spin_lock_irqsave(&altera_gc->gpio_lock, flags);
@@ -92,7 +87,7 @@ static int altera_gpio_irq_set_type(struct irq_data *d,
 {
         struct altera_gpio_chip *altera_gc;
 
-        altera_gc = to_altera(irq_data_get_irq_chip_data(d));
+        altera_gc = gpiochip_get_data(irq_data_get_irq_chip_data(d));
 
         if (type == IRQ_TYPE_NONE)
                 return 0;
@@ -145,7 +140,7 @@ static void altera_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
         unsigned int data_reg;
 
         mm_gc = to_of_mm_gpio_chip(gc);
-        chip = container_of(mm_gc, struct altera_gpio_chip, mmchip);
+        chip = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&chip->gpio_lock, flags);
         data_reg = readl(mm_gc->regs + ALTERA_GPIO_DATA);
@@ -165,7 +160,7 @@ static int altera_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
         unsigned int gpio_ddr;
 
         mm_gc = to_of_mm_gpio_chip(gc);
-        chip = container_of(mm_gc, struct altera_gpio_chip, mmchip);
+        chip = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&chip->gpio_lock, flags);
         /* Set pin as input, assumes software controlled IP */
@@ -186,7 +181,7 @@ static int altera_gpio_direction_output(struct gpio_chip *gc,
         unsigned int data_reg, gpio_ddr;
 
         mm_gc = to_of_mm_gpio_chip(gc);
-        chip = container_of(mm_gc, struct altera_gpio_chip, mmchip);
+        chip = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&chip->gpio_lock, flags);
         /* Sets the GPIO value */
@@ -215,7 +210,7 @@ static void altera_gpio_irq_edge_handler(struct irq_desc *desc)
         unsigned long status;
         int i;
 
-        altera_gc = to_altera(irq_desc_get_handler_data(desc));
+        altera_gc = gpiochip_get_data(irq_desc_get_handler_data(desc));
         chip = irq_desc_get_chip(desc);
         mm_gc = &altera_gc->mmchip;
         irqdomain = altera_gc->mmchip.gc.irqdomain;
@@ -244,7 +239,7 @@ static void altera_gpio_irq_leveL_high_handler(struct irq_desc *desc)
         unsigned long status;
         int i;
 
-        altera_gc = to_altera(irq_desc_get_handler_data(desc));
+        altera_gc = gpiochip_get_data(irq_desc_get_handler_data(desc));
         chip = irq_desc_get_chip(desc);
         mm_gc = &altera_gc->mmchip;
         irqdomain = altera_gc->mmchip.gc.irqdomain;
@@ -290,9 +285,9 @@ static int altera_gpio_probe(struct platform_device *pdev)
         altera_gc->mmchip.gc.get                = altera_gpio_get;
         altera_gc->mmchip.gc.set                = altera_gpio_set;
         altera_gc->mmchip.gc.owner              = THIS_MODULE;
-        altera_gc->mmchip.gc.dev                = &pdev->dev;
+        altera_gc->mmchip.gc.parent             = &pdev->dev;
 
-        ret = of_mm_gpiochip_add(node, &altera_gc->mmchip);
+        ret = of_mm_gpiochip_add_data(node, &altera_gc->mmchip, altera_gc);
         if (ret) {
                 dev_err(&pdev->dev, "Failed adding memory mapped gpiochip\n");
                 return ret;
diff --git a/drivers/gpio/gpio-amd8111.c b/drivers/gpio/gpio-amd8111.c
index d00d81928fe8..c7040fffc5b4 100644
--- a/drivers/gpio/gpio-amd8111.c
+++ b/drivers/gpio/gpio-amd8111.c
@@ -75,11 +75,9 @@ struct amd_gpio {
         u8                      orig[32];
 };
 
-#define to_agp(chip)    container_of(chip, struct amd_gpio, chip)
-
 static int amd_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct amd_gpio *agp = to_agp(chip);
+        struct amd_gpio *agp = gpiochip_get_data(chip);
 
         agp->orig[offset] = ioread8(agp->pm + AMD_REG_GPIO(offset)) &
                 (AMD_GPIO_DEBOUNCE | AMD_GPIO_MODE_MASK | AMD_GPIO_X_MASK);
@@ -91,7 +89,7 @@ static int amd_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void amd_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct amd_gpio *agp = to_agp(chip);
+        struct amd_gpio *agp = gpiochip_get_data(chip);
 
         dev_dbg(&agp->pdev->dev, "Freed gpio %d, data %x\n", offset, agp->orig[offset]);
 
@@ -100,7 +98,7 @@ static void amd_gpio_free(struct gpio_chip *chip, unsigned offset)
 
 static void amd_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct amd_gpio *agp = to_agp(chip);
+        struct amd_gpio *agp = gpiochip_get_data(chip);
         u8 temp;
         unsigned long flags;
 
@@ -115,7 +113,7 @@ static void amd_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int amd_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct amd_gpio *agp = to_agp(chip);
+        struct amd_gpio *agp = gpiochip_get_data(chip);
         u8 temp;
 
         temp = ioread8(agp->pm + AMD_REG_GPIO(offset));
@@ -127,7 +125,7 @@ static int amd_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static int amd_gpio_dirout(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct amd_gpio *agp = to_agp(chip);
+        struct amd_gpio *agp = gpiochip_get_data(chip);
         u8 temp;
         unsigned long flags;
 
@@ -144,7 +142,7 @@ static int amd_gpio_dirout(struct gpio_chip *chip, unsigned offset, int value)
 
 static int amd_gpio_dirin(struct gpio_chip *chip, unsigned offset)
 {
-        struct amd_gpio *agp = to_agp(chip);
+        struct amd_gpio *agp = gpiochip_get_data(chip);
         u8 temp;
         unsigned long flags;
 
@@ -220,12 +218,12 @@ found:
                 goto out;
         }
         gp.pdev = pdev;
-        gp.chip.dev = &pdev->dev;
+        gp.chip.parent = &pdev->dev;
 
         spin_lock_init(&gp.lock);
 
         printk(KERN_INFO "AMD-8111 GPIO detected\n");
-        err = gpiochip_add(&gp.chip);
+        err = gpiochip_add_data(&gp.chip, &gp);
         if (err) {
                 printk(KERN_ERR "GPIO registering failed (%d)\n",
                        err);
diff --git a/drivers/gpio/gpio-amdpt.c b/drivers/gpio/gpio-amdpt.c
index cbbb966d4fc0..c2484046e8e9 100644
--- a/drivers/gpio/gpio-amdpt.c
+++ b/drivers/gpio/gpio-amdpt.c
@@ -31,22 +31,20 @@ struct pt_gpio_chip {
         spinlock_t               lock;
 };
 
-#define to_pt_gpio(c)   container_of(c, struct pt_gpio_chip, gc)
-
 static int pt_gpio_request(struct gpio_chip *gc, unsigned offset)
 {
-        struct pt_gpio_chip *pt_gpio = to_pt_gpio(gc);
+        struct pt_gpio_chip *pt_gpio = gpiochip_get_data(gc);
         unsigned long flags;
         u32 using_pins;
 
-        dev_dbg(gc->dev, "pt_gpio_request offset=%x\n", offset);
+        dev_dbg(gc->parent, "pt_gpio_request offset=%x\n", offset);
 
         spin_lock_irqsave(&pt_gpio->lock, flags);
 
         using_pins = readl(pt_gpio->reg_base + PT_SYNC_REG);
         if (using_pins & BIT(offset)) {
-                dev_warn(gc->dev, "PT GPIO pin %x reconfigured\n",
-                        offset);
+                dev_warn(gc->parent, "PT GPIO pin %x reconfigured\n",
+                         offset);
                 spin_unlock_irqrestore(&pt_gpio->lock, flags);
                 return -EINVAL;
         }
@@ -60,7 +58,7 @@ static int pt_gpio_request(struct gpio_chip *gc, unsigned offset)
 
 static void pt_gpio_free(struct gpio_chip *gc, unsigned offset)
 {
-        struct pt_gpio_chip *pt_gpio = to_pt_gpio(gc);
+        struct pt_gpio_chip *pt_gpio = gpiochip_get_data(gc);
         unsigned long flags;
         u32 using_pins;
 
@@ -72,16 +70,16 @@ static void pt_gpio_free(struct gpio_chip *gc, unsigned offset)
 
         spin_unlock_irqrestore(&pt_gpio->lock, flags);
 
-        dev_dbg(gc->dev, "pt_gpio_free offset=%x\n", offset);
+        dev_dbg(gc->parent, "pt_gpio_free offset=%x\n", offset);
 }
 
 static void pt_gpio_set_value(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct pt_gpio_chip *pt_gpio = to_pt_gpio(gc);
+        struct pt_gpio_chip *pt_gpio = gpiochip_get_data(gc);
         unsigned long flags;
         u32 data;
 
-        dev_dbg(gc->dev, "pt_gpio_set_value offset=%x, value=%x\n",
+        dev_dbg(gc->parent, "pt_gpio_set_value offset=%x, value=%x\n",
                 offset, value);
 
         spin_lock_irqsave(&pt_gpio->lock, flags);
@@ -97,7 +95,7 @@ static void pt_gpio_set_value(struct gpio_chip *gc, unsigned offset, int value)
 
 static int pt_gpio_get_value(struct gpio_chip *gc, unsigned offset)
 {
-        struct pt_gpio_chip *pt_gpio = to_pt_gpio(gc);
+        struct pt_gpio_chip *pt_gpio = gpiochip_get_data(gc);
         unsigned long flags;
         u32 data;
 
@@ -116,7 +114,7 @@ static int pt_gpio_get_value(struct gpio_chip *gc, unsigned offset)
         data >>= offset;
         data &= 1;
 
-        dev_dbg(gc->dev, "pt_gpio_get_value offset=%x, value=%x\n",
+        dev_dbg(gc->parent, "pt_gpio_get_value offset=%x, value=%x\n",
                 offset, data);
 
         return data;
@@ -124,11 +122,11 @@ static int pt_gpio_get_value(struct gpio_chip *gc, unsigned offset)
 
 static int pt_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct pt_gpio_chip *pt_gpio = to_pt_gpio(gc);
+        struct pt_gpio_chip *pt_gpio = gpiochip_get_data(gc);
         unsigned long flags;
         u32 data;
 
-        dev_dbg(gc->dev, "pt_gpio_dirction_input offset=%x\n", offset);
+        dev_dbg(gc->parent, "pt_gpio_dirction_input offset=%x\n", offset);
 
         spin_lock_irqsave(&pt_gpio->lock, flags);
 
@@ -144,11 +142,11 @@ static int pt_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 static int pt_gpio_direction_output(struct gpio_chip *gc,
                                         unsigned offset, int value)
 {
-        struct pt_gpio_chip *pt_gpio = to_pt_gpio(gc);
+        struct pt_gpio_chip *pt_gpio = gpiochip_get_data(gc);
         unsigned long flags;
         u32 data;
 
-        dev_dbg(gc->dev, "pt_gpio_direction_output offset=%x, value=%x\n",
+        dev_dbg(gc->parent, "pt_gpio_direction_output offset=%x, value=%x\n",
                 offset, value);
 
         spin_lock_irqsave(&pt_gpio->lock, flags);
@@ -202,7 +200,7 @@ static int pt_gpio_probe(struct platform_device *pdev)
 
         pt_gpio->gc.label            = pdev->name;
         pt_gpio->gc.owner            = THIS_MODULE;
-        pt_gpio->gc.dev              = dev;
+        pt_gpio->gc.parent              = dev;
         pt_gpio->gc.request          = pt_gpio_request;
         pt_gpio->gc.free             = pt_gpio_free;
         pt_gpio->gc.direction_input  = pt_gpio_direction_input;
@@ -214,7 +212,7 @@ static int pt_gpio_probe(struct platform_device *pdev)
 #if defined(CONFIG_OF_GPIO)
         pt_gpio->gc.of_node          = pdev->dev.of_node;
 #endif
-        ret = gpiochip_add(&pt_gpio->gc);
+        ret = gpiochip_add_data(&pt_gpio->gc, pt_gpio);
         if (ret) {
                 dev_err(&pdev->dev, "Failed to register GPIO lib\n");
                 return ret;
diff --git a/drivers/gpio/gpio-arizona.c b/drivers/gpio/gpio-arizona.c
index 624ea5421995..e910c1f41d93 100644
--- a/drivers/gpio/gpio-arizona.c
+++ b/drivers/gpio/gpio-arizona.c
@@ -28,14 +28,9 @@ struct arizona_gpio {
         struct gpio_chip gpio_chip;
 };
 
-static inline struct arizona_gpio *to_arizona_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct arizona_gpio, gpio_chip);
-}
-
 static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct arizona_gpio *arizona_gpio = to_arizona_gpio(chip);
+        struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
         struct arizona *arizona = arizona_gpio->arizona;
 
         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
@@ -44,7 +39,7 @@ static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 
 static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct arizona_gpio *arizona_gpio = to_arizona_gpio(chip);
+        struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
         struct arizona *arizona = arizona_gpio->arizona;
         unsigned int val;
         int ret;
@@ -62,7 +57,7 @@ static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset)
 static int arizona_gpio_direction_out(struct gpio_chip *chip,
                                      unsigned offset, int value)
 {
-        struct arizona_gpio *arizona_gpio = to_arizona_gpio(chip);
+        struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
         struct arizona *arizona = arizona_gpio->arizona;
 
         if (value)
@@ -74,7 +69,7 @@ static int arizona_gpio_direction_out(struct gpio_chip *chip,
 
 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct arizona_gpio *arizona_gpio = to_arizona_gpio(chip);
+        struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
         struct arizona *arizona = arizona_gpio->arizona;
 
         if (value)
@@ -108,7 +103,7 @@ static int arizona_gpio_probe(struct platform_device *pdev)
 
         arizona_gpio->arizona = arizona;
         arizona_gpio->gpio_chip = template_chip;
-        arizona_gpio->gpio_chip.dev = &pdev->dev;
+        arizona_gpio->gpio_chip.parent = &pdev->dev;
 #ifdef CONFIG_OF_GPIO
         arizona_gpio->gpio_chip.of_node = arizona->dev->of_node;
 #endif
@@ -137,7 +132,7 @@ static int arizona_gpio_probe(struct platform_device *pdev)
         else
                 arizona_gpio->gpio_chip.base = -1;
 
-        ret = gpiochip_add(&arizona_gpio->gpio_chip);
+        ret = gpiochip_add_data(&arizona_gpio->gpio_chip, arizona_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
                         ret);
diff --git a/drivers/gpio/gpio-ath79.c b/drivers/gpio/gpio-ath79.c
index 5eaea8b812cf..d13dd133a907 100644
--- a/drivers/gpio/gpio-ath79.c
+++ b/drivers/gpio/gpio-ath79.c
@@ -24,12 +24,10 @@ struct ath79_gpio_ctrl {
         spinlock_t lock;
 };
 
-#define to_ath79_gpio_ctrl(c) container_of(c, struct ath79_gpio_ctrl, chip)
-
 static void ath79_gpio_set_value(struct gpio_chip *chip,
                                 unsigned gpio, int value)
 {
-        struct ath79_gpio_ctrl *ctrl = to_ath79_gpio_ctrl(chip);
+        struct ath79_gpio_ctrl *ctrl = gpiochip_get_data(chip);
 
         if (value)
                 __raw_writel(BIT(gpio), ctrl->base + AR71XX_GPIO_REG_SET);
@@ -39,7 +37,7 @@ static void ath79_gpio_set_value(struct gpio_chip *chip,
 
 static int ath79_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
 {
-        struct ath79_gpio_ctrl *ctrl = to_ath79_gpio_ctrl(chip);
+        struct ath79_gpio_ctrl *ctrl = gpiochip_get_data(chip);
 
         return (__raw_readl(ctrl->base + AR71XX_GPIO_REG_IN) >> gpio) & 1;
 }
@@ -47,7 +45,7 @@ static int ath79_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
 static int ath79_gpio_direction_input(struct gpio_chip *chip,
                                        unsigned offset)
 {
-        struct ath79_gpio_ctrl *ctrl = to_ath79_gpio_ctrl(chip);
+        struct ath79_gpio_ctrl *ctrl = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&ctrl->lock, flags);
@@ -64,7 +62,7 @@ static int ath79_gpio_direction_input(struct gpio_chip *chip,
 static int ath79_gpio_direction_output(struct gpio_chip *chip,
                                         unsigned offset, int value)
 {
-        struct ath79_gpio_ctrl *ctrl = to_ath79_gpio_ctrl(chip);
+        struct ath79_gpio_ctrl *ctrl = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&ctrl->lock, flags);
@@ -85,7 +83,7 @@ static int ath79_gpio_direction_output(struct gpio_chip *chip,
 
 static int ar934x_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct ath79_gpio_ctrl *ctrl = to_ath79_gpio_ctrl(chip);
+        struct ath79_gpio_ctrl *ctrl = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&ctrl->lock, flags);
@@ -102,7 +100,7 @@ static int ar934x_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int ar934x_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                         int value)
 {
-        struct ath79_gpio_ctrl *ctrl = to_ath79_gpio_ctrl(chip);
+        struct ath79_gpio_ctrl *ctrl = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&ctrl->lock, flags);
@@ -138,7 +136,7 @@ static const struct of_device_id ath79_gpio_of_match[] = {
 
 static int ath79_gpio_probe(struct platform_device *pdev)
 {
-        struct ath79_gpio_platform_data *pdata = pdev->dev.platform_data;
+        struct ath79_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev);
         struct device_node *np = pdev->dev.of_node;
         struct ath79_gpio_ctrl *ctrl;
         struct resource *res;
@@ -177,14 +175,14 @@ static int ath79_gpio_probe(struct platform_device *pdev)
 
         spin_lock_init(&ctrl->lock);
         memcpy(&ctrl->chip, &ath79_gpio_chip, sizeof(ctrl->chip));
-        ctrl->chip.dev = &pdev->dev;
+        ctrl->chip.parent = &pdev->dev;
         ctrl->chip.ngpio = ath79_gpio_count;
         if (oe_inverted) {
                 ctrl->chip.direction_input = ar934x_gpio_direction_input;
                 ctrl->chip.direction_output = ar934x_gpio_direction_output;
         }
 
-        err = gpiochip_add(&ctrl->chip);
+        err = gpiochip_add_data(&ctrl->chip, ctrl);
         if (err) {
                 dev_err(&pdev->dev,
                         "cannot add AR71xx GPIO chip, error=%d", err);
diff --git a/drivers/gpio/gpio-bcm-kona.c b/drivers/gpio/gpio-bcm-kona.c
index 33a1f9779b86..b6c5abe85daf 100644
--- a/drivers/gpio/gpio-bcm-kona.c
+++ b/drivers/gpio/gpio-bcm-kona.c
@@ -78,11 +78,6 @@ struct bcm_kona_gpio_bank {
         struct bcm_kona_gpio *kona_gpio;
 };
 
-static inline struct bcm_kona_gpio *to_kona_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct bcm_kona_gpio, gpio_chip);
-}
-
 static inline void bcm_kona_gpio_write_lock_regs(void __iomem *reg_base,
                                                 int bank_id, u32 lockcode)
 {
@@ -124,7 +119,7 @@ static void bcm_kona_gpio_unlock_gpio(struct bcm_kona_gpio *kona_gpio,
 
 static int bcm_kona_gpio_get_dir(struct gpio_chip *chip, unsigned gpio)
 {
-        struct bcm_kona_gpio *kona_gpio = to_kona_gpio(chip);
+        struct bcm_kona_gpio *kona_gpio = gpiochip_get_data(chip);
         void __iomem *reg_base = kona_gpio->reg_base;
         u32 val;
 
@@ -141,7 +136,7 @@ static void bcm_kona_gpio_set(struct gpio_chip *chip, unsigned gpio, int value)
         u32 val, reg_offset;
         unsigned long flags;
 
-        kona_gpio = to_kona_gpio(chip);
+        kona_gpio = gpiochip_get_data(chip);
         reg_base = kona_gpio->reg_base;
         spin_lock_irqsave(&kona_gpio->lock, flags);
 
@@ -168,7 +163,7 @@ static int bcm_kona_gpio_get(struct gpio_chip *chip, unsigned gpio)
         u32 val, reg_offset;
         unsigned long flags;
 
-        kona_gpio = to_kona_gpio(chip);
+        kona_gpio = gpiochip_get_data(chip);
         reg_base = kona_gpio->reg_base;
         spin_lock_irqsave(&kona_gpio->lock, flags);
 
@@ -188,7 +183,7 @@ static int bcm_kona_gpio_get(struct gpio_chip *chip, unsigned gpio)
 
 static int bcm_kona_gpio_request(struct gpio_chip *chip, unsigned gpio)
 {
-        struct bcm_kona_gpio *kona_gpio = to_kona_gpio(chip);
+        struct bcm_kona_gpio *kona_gpio = gpiochip_get_data(chip);
 
         bcm_kona_gpio_unlock_gpio(kona_gpio, gpio);
         return 0;
@@ -196,7 +191,7 @@ static int bcm_kona_gpio_request(struct gpio_chip *chip, unsigned gpio)
 
 static void bcm_kona_gpio_free(struct gpio_chip *chip, unsigned gpio)
 {
-        struct bcm_kona_gpio *kona_gpio = to_kona_gpio(chip);
+        struct bcm_kona_gpio *kona_gpio = gpiochip_get_data(chip);
 
         bcm_kona_gpio_lock_gpio(kona_gpio, gpio);
 }
@@ -208,7 +203,7 @@ static int bcm_kona_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
         u32 val;
         unsigned long flags;
 
-        kona_gpio = to_kona_gpio(chip);
+        kona_gpio = gpiochip_get_data(chip);
         reg_base = kona_gpio->reg_base;
         spin_lock_irqsave(&kona_gpio->lock, flags);
 
@@ -232,7 +227,7 @@ static int bcm_kona_gpio_direction_output(struct gpio_chip *chip,
         u32 val, reg_offset;
         unsigned long flags;
 
-        kona_gpio = to_kona_gpio(chip);
+        kona_gpio = gpiochip_get_data(chip);
         reg_base = kona_gpio->reg_base;
         spin_lock_irqsave(&kona_gpio->lock, flags);
 
@@ -255,7 +250,7 @@ static int bcm_kona_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
 {
         struct bcm_kona_gpio *kona_gpio;
 
-        kona_gpio = to_kona_gpio(chip);
+        kona_gpio = gpiochip_get_data(chip);
         if (gpio >= kona_gpio->gpio_chip.ngpio)
                 return -ENXIO;
         return irq_create_mapping(kona_gpio->irq_domain, gpio);
@@ -269,11 +264,11 @@ static int bcm_kona_gpio_set_debounce(struct gpio_chip *chip, unsigned gpio,
         u32 val, res;
         unsigned long flags;
 
-        kona_gpio = to_kona_gpio(chip);
+        kona_gpio = gpiochip_get_data(chip);
         reg_base = kona_gpio->reg_base;
         /* debounce must be 1-128ms (or 0) */
         if ((debounce > 0 && debounce < 1000) || debounce > 128000) {
-                dev_err(chip->dev, "Debounce value %u not in range\n",
+                dev_err(chip->parent, "Debounce value %u not in range\n",
                         debounce);
                 return -EINVAL;
         }
@@ -416,7 +411,7 @@ static int bcm_kona_gpio_irq_set_type(struct irq_data *d, unsigned int type)
         case IRQ_TYPE_LEVEL_LOW:
                 /* BCM GPIO doesn't support level triggering */
         default:
-                dev_err(kona_gpio->gpio_chip.dev,
+                dev_err(kona_gpio->gpio_chip.parent,
                         "Invalid BCM GPIO irq type 0x%x\n", type);
                 return -EINVAL;
         }
@@ -477,7 +472,7 @@ static int bcm_kona_gpio_irq_reqres(struct irq_data *d)
         struct bcm_kona_gpio *kona_gpio = irq_data_get_irq_chip_data(d);
 
         if (gpiochip_lock_as_irq(&kona_gpio->gpio_chip, d->hwirq)) {
-                dev_err(kona_gpio->gpio_chip.dev,
+                dev_err(kona_gpio->gpio_chip.parent,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         d->hwirq);
                 return -EINVAL;
@@ -635,7 +630,7 @@ static int bcm_kona_gpio_probe(struct platform_device *pdev)
 
         bcm_kona_gpio_reset(kona_gpio);
 
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, kona_gpio);
         if (ret < 0) {
                 dev_err(dev, "Couldn't add GPIO chip -- %d\n", ret);
                 goto err_irq_domain;
diff --git a/drivers/gpio/gpio-brcmstb.c b/drivers/gpio/gpio-brcmstb.c
index 4c64627c6bb5..d7644251e869 100644
--- a/drivers/gpio/gpio-brcmstb.c
+++ b/drivers/gpio/gpio-brcmstb.c
@@ -16,7 +16,6 @@
 #include <linux/of_device.h>
 #include <linux/of_irq.h>
 #include <linux/module.h>
-#include <linux/basic_mmio_gpio.h>
 #include <linux/irqdomain.h>
 #include <linux/irqchip/chained_irq.h>
 #include <linux/interrupt.h>
@@ -35,7 +34,7 @@
 struct brcmstb_gpio_bank {
         struct list_head node;
         int id;
-        struct bgpio_chip bgc;
+        struct gpio_chip gc;
         struct brcmstb_gpio_priv *parent_priv;
         u32 width;
         struct irq_chip irq_chip;
@@ -57,37 +56,30 @@ struct brcmstb_gpio_priv {
 /* assumes MAX_GPIO_PER_BANK is a multiple of 2 */
 #define GPIO_BIT(gpio)          ((gpio) & (MAX_GPIO_PER_BANK - 1))
 
-static inline struct brcmstb_gpio_bank *
-brcmstb_gpio_gc_to_bank(struct gpio_chip *gc)
-{
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        return container_of(bgc, struct brcmstb_gpio_bank, bgc);
-}
-
 static inline struct brcmstb_gpio_priv *
 brcmstb_gpio_gc_to_priv(struct gpio_chip *gc)
 {
-        struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
+        struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
         return bank->parent_priv;
 }
 
 static void brcmstb_gpio_set_imask(struct brcmstb_gpio_bank *bank,
                 unsigned int offset, bool enable)
 {
-        struct bgpio_chip *bgc = &bank->bgc;
+        struct gpio_chip *gc = &bank->gc;
         struct brcmstb_gpio_priv *priv = bank->parent_priv;
-        u32 mask = bgc->pin2mask(bgc, offset);
+        u32 mask = gc->pin2mask(gc, offset);
         u32 imask;
         unsigned long flags;
 
-        spin_lock_irqsave(&bgc->lock, flags);
-        imask = bgc->read_reg(priv->reg_base + GIO_MASK(bank->id));
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
+        imask = gc->read_reg(priv->reg_base + GIO_MASK(bank->id));
         if (enable)
                 imask |= mask;
         else
                 imask &= ~mask;
-        bgc->write_reg(priv->reg_base + GIO_MASK(bank->id), imask);
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        gc->write_reg(priv->reg_base + GIO_MASK(bank->id), imask);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 }
 
 /* -------------------- IRQ chip functions -------------------- */
@@ -95,7 +87,7 @@ static void brcmstb_gpio_set_imask(struct brcmstb_gpio_bank *bank,
 static void brcmstb_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
+        struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 
         brcmstb_gpio_set_imask(bank, d->hwirq, false);
 }
@@ -103,7 +95,7 @@ static void brcmstb_gpio_irq_mask(struct irq_data *d)
 static void brcmstb_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
+        struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 
         brcmstb_gpio_set_imask(bank, d->hwirq, true);
 }
@@ -111,7 +103,7 @@ static void brcmstb_gpio_irq_unmask(struct irq_data *d)
 static int brcmstb_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
+        struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
         struct brcmstb_gpio_priv *priv = bank->parent_priv;
         u32 mask = BIT(d->hwirq);
         u32 edge_insensitive, iedge_insensitive;
@@ -149,23 +141,23 @@ static int brcmstb_gpio_irq_set_type(struct irq_data *d, unsigned int type)
                 return -EINVAL;
         }
 
-        spin_lock_irqsave(&bank->bgc.lock, flags);
+        spin_lock_irqsave(&bank->gc.bgpio_lock, flags);
 
-        iedge_config = bank->bgc.read_reg(priv->reg_base +
+        iedge_config = bank->gc.read_reg(priv->reg_base +
                         GIO_EC(bank->id)) & ~mask;
-        iedge_insensitive = bank->bgc.read_reg(priv->reg_base +
+        iedge_insensitive = bank->gc.read_reg(priv->reg_base +
                         GIO_EI(bank->id)) & ~mask;
-        ilevel = bank->bgc.read_reg(priv->reg_base +
+        ilevel = bank->gc.read_reg(priv->reg_base +
                         GIO_LEVEL(bank->id)) & ~mask;
 
-        bank->bgc.write_reg(priv->reg_base + GIO_EC(bank->id),
+        bank->gc.write_reg(priv->reg_base + GIO_EC(bank->id),
                         iedge_config | edge_config);
-        bank->bgc.write_reg(priv->reg_base + GIO_EI(bank->id),
+        bank->gc.write_reg(priv->reg_base + GIO_EI(bank->id),
                         iedge_insensitive | edge_insensitive);
-        bank->bgc.write_reg(priv->reg_base + GIO_LEVEL(bank->id),
+        bank->gc.write_reg(priv->reg_base + GIO_LEVEL(bank->id),
                         ilevel | level);
 
-        spin_unlock_irqrestore(&bank->bgc.lock, flags);
+        spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags);
         return 0;
 }
 
@@ -210,29 +202,29 @@ static irqreturn_t brcmstb_gpio_wake_irq_handler(int irq, void *data)
 static void brcmstb_gpio_irq_bank_handler(struct brcmstb_gpio_bank *bank)
 {
         struct brcmstb_gpio_priv *priv = bank->parent_priv;
-        struct irq_domain *irq_domain = bank->bgc.gc.irqdomain;
+        struct irq_domain *irq_domain = bank->gc.irqdomain;
         void __iomem *reg_base = priv->reg_base;
         unsigned long status;
         unsigned long flags;
 
-        spin_lock_irqsave(&bank->bgc.lock, flags);
-        while ((status = bank->bgc.read_reg(reg_base + GIO_STAT(bank->id)) &
-                         bank->bgc.read_reg(reg_base + GIO_MASK(bank->id)))) {
+        spin_lock_irqsave(&bank->gc.bgpio_lock, flags);
+        while ((status = bank->gc.read_reg(reg_base + GIO_STAT(bank->id)) &
+                         bank->gc.read_reg(reg_base + GIO_MASK(bank->id)))) {
                 int bit;
 
                 for_each_set_bit(bit, &status, 32) {
-                        u32 stat = bank->bgc.read_reg(reg_base +
+                        u32 stat = bank->gc.read_reg(reg_base +
                                                       GIO_STAT(bank->id));
                         if (bit >= bank->width)
                                 dev_warn(&priv->pdev->dev,
                                          "IRQ for invalid GPIO (bank=%d, offset=%d)\n",
                                          bank->id, bit);
-                        bank->bgc.write_reg(reg_base + GIO_STAT(bank->id),
+                        bank->gc.write_reg(reg_base + GIO_STAT(bank->id),
                                             stat | BIT(bit));
                         generic_handle_irq(irq_find_mapping(irq_domain, bit));
                 }
         }
-        spin_unlock_irqrestore(&bank->bgc.lock, flags);
+        spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags);
 }
 
 /* Each UPG GIO block has one IRQ for all banks */
@@ -303,9 +295,7 @@ static int brcmstb_gpio_remove(struct platform_device *pdev)
          */
         list_for_each(pos, &priv->bank_list) {
                 bank = list_entry(pos, struct brcmstb_gpio_bank, node);
-                ret = bgpio_remove(&bank->bgc);
-                if (ret)
-                        dev_err(&pdev->dev, "gpiochip_remove fail in cleanup\n");
+                gpiochip_remove(&bank->gc);
         }
         if (priv->reboot_notifier.notifier_call) {
                 ret = unregister_reboot_notifier(&priv->reboot_notifier);
@@ -320,7 +310,7 @@ static int brcmstb_gpio_of_xlate(struct gpio_chip *gc,
                 const struct of_phandle_args *gpiospec, u32 *flags)
 {
         struct brcmstb_gpio_priv *priv = brcmstb_gpio_gc_to_priv(gc);
-        struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
+        struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
         int offset;
 
         if (gc->of_gpio_n_cells != 2) {
@@ -398,9 +388,9 @@ static int brcmstb_gpio_irq_setup(struct platform_device *pdev,
         if (priv->can_wake)
                 bank->irq_chip.irq_set_wake = brcmstb_gpio_irq_set_wake;
 
-        gpiochip_irqchip_add(&bank->bgc.gc, &bank->irq_chip, 0,
+        gpiochip_irqchip_add(&bank->gc, &bank->irq_chip, 0,
                         handle_simple_irq, IRQ_TYPE_NONE);
-        gpiochip_set_chained_irqchip(&bank->bgc.gc, &bank->irq_chip,
+        gpiochip_set_chained_irqchip(&bank->gc, &bank->irq_chip,
                         priv->parent_irq, brcmstb_gpio_irq_handler);
 
         return 0;
@@ -419,6 +409,7 @@ static int brcmstb_gpio_probe(struct platform_device *pdev)
         int num_banks = 0;
         int err;
         static int gpio_base;
+        unsigned long flags = 0;
 
         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
         if (!priv)
@@ -448,10 +439,21 @@ static int brcmstb_gpio_probe(struct platform_device *pdev)
         if (brcmstb_gpio_sanity_check_banks(dev, np, res))
                 return -EINVAL;
 
+        /*
+         * MIPS endianness is configured by boot strap, which also reverses all
+         * bus endianness (i.e., big-endian CPU + big endian bus ==> native
+         * endian I/O).
+         *
+         * Other architectures (e.g., ARM) either do not support big endian, or
+         * else leave I/O in little endian mode.
+         */
+#if defined(CONFIG_MIPS) && defined(__BIG_ENDIAN)
+        flags = BGPIOF_BIG_ENDIAN_BYTE_ORDER;
+#endif
+
         of_property_for_each_u32(np, "brcm,gpio-bank-widths", prop, p,
                         bank_width) {
                 struct brcmstb_gpio_bank *bank;
-                struct bgpio_chip *bgc;
                 struct gpio_chip *gc;
 
                 bank = devm_kzalloc(dev, sizeof(*bank), GFP_KERNEL);
@@ -473,17 +475,16 @@ static int brcmstb_gpio_probe(struct platform_device *pdev)
                  * Regs are 4 bytes wide, have data reg, no set/clear regs,
                  * and direction bits have 0 = output and 1 = input
                  */
-                bgc = &bank->bgc;
-                err = bgpio_init(bgc, dev, 4,
+                gc = &bank->gc;
+                err = bgpio_init(gc, dev, 4,
                                 reg_base + GIO_DATA(bank->id),
                                 NULL, NULL, NULL,
-                                reg_base + GIO_IODIR(bank->id), 0);
+                                reg_base + GIO_IODIR(bank->id), flags);
                 if (err) {
                         dev_err(dev, "bgpio_init() failed\n");
                         goto fail;
                 }
 
-                gc = &bgc->gc;
                 gc->of_node = np;
                 gc->owner = THIS_MODULE;
                 gc->label = np->full_name;
@@ -497,9 +498,9 @@ static int brcmstb_gpio_probe(struct platform_device *pdev)
                  * Mask all interrupts by default, since wakeup interrupts may
                  * be retained from S5 cold boot
                  */
-                bank->bgc.write_reg(reg_base + GIO_MASK(bank->id), 0);
+                gc->write_reg(reg_base + GIO_MASK(bank->id), 0);
 
-                err = gpiochip_add(gc);
+                err = gpiochip_add_data(gc, bank);
                 if (err) {
                         dev_err(dev, "Could not add gpiochip for bank %d\n",
                                         bank->id);
diff --git a/drivers/gpio/gpio-bt8xx.c b/drivers/gpio/gpio-bt8xx.c
index 7e4c43c18960..acefb25e8eca 100644
--- a/drivers/gpio/gpio-bt8xx.c
+++ b/drivers/gpio/gpio-bt8xx.c
@@ -80,7 +80,7 @@ MODULE_PARM_DESC(gpiobase, "The GPIO number base. -1 means dynamic, which is the
 
 static int bt8xxgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 {
-        struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
+        struct bt8xxgpio *bg = gpiochip_get_data(gpio);
         unsigned long flags;
         u32 outen, data;
 
@@ -101,7 +101,7 @@ static int bt8xxgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 
 static int bt8xxgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
 {
-        struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
+        struct bt8xxgpio *bg = gpiochip_get_data(gpio);
         unsigned long flags;
         u32 val;
 
@@ -115,7 +115,7 @@ static int bt8xxgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
 static int bt8xxgpio_gpio_direction_output(struct gpio_chip *gpio,
                                         unsigned nr, int val)
 {
-        struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
+        struct bt8xxgpio *bg = gpiochip_get_data(gpio);
         unsigned long flags;
         u32 outen, data;
 
@@ -140,7 +140,7 @@ static int bt8xxgpio_gpio_direction_output(struct gpio_chip *gpio,
 static void bt8xxgpio_gpio_set(struct gpio_chip *gpio,
                             unsigned nr, int val)
 {
-        struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
+        struct bt8xxgpio *bg = gpiochip_get_data(gpio);
         unsigned long flags;
         u32 data;
 
@@ -217,7 +217,7 @@ static int bt8xxgpio_probe(struct pci_dev *dev,
         bgwrite(0, BT848_GPIO_OUT_EN);
 
         bt8xxgpio_gpio_setup(bg);
-        err = gpiochip_add(&bg->gpio);
+        err = gpiochip_add_data(&bg->gpio, bg);
         if (err) {
                 printk(KERN_ERR "bt8xxgpio: Failed to register GPIOs\n");
                 goto err_disable;
diff --git a/drivers/gpio/gpio-clps711x.c b/drivers/gpio/gpio-clps711x.c
index b6908f1ff1ab..c84f9551f108 100644
--- a/drivers/gpio/gpio-clps711x.c
+++ b/drivers/gpio/gpio-clps711x.c
@@ -10,24 +10,23 @@
  */
 
 #include <linux/err.h>
-#include <linux/gpio.h>
 #include <linux/module.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/platform_device.h>
 
 static int clps711x_gpio_probe(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node;
         void __iomem *dat, *dir;
-        struct bgpio_chip *bgc;
+        struct gpio_chip *gc;
         struct resource *res;
         int err, id = np ? of_alias_get_id(np, "gpio") : pdev->id;
 
         if ((id < 0) || (id > 4))
                 return -ENODEV;
 
-        bgc = devm_kzalloc(&pdev->dev, sizeof(*bgc), GFP_KERNEL);
-        if (!bgc)
+        gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
+        if (!gc)
                 return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -43,11 +42,11 @@ static int clps711x_gpio_probe(struct platform_device *pdev)
         switch (id) {
         case 3:
                 /* PORTD is inverted logic for direction register */
-                err = bgpio_init(bgc, &pdev->dev, 1, dat, NULL, NULL,
+                err = bgpio_init(gc, &pdev->dev, 1, dat, NULL, NULL,
                                  NULL, dir, 0);
                 break;
         default:
-                err = bgpio_init(bgc, &pdev->dev, 1, dat, NULL, NULL,
+                err = bgpio_init(gc, &pdev->dev, 1, dat, NULL, NULL,
                                  dir, NULL, 0);
                 break;
         }
@@ -58,24 +57,25 @@ static int clps711x_gpio_probe(struct platform_device *pdev)
         switch (id) {
         case 4:
                 /* PORTE is 3 lines only */
-                bgc->gc.ngpio = 3;
+                gc->ngpio = 3;
                 break;
         default:
                 break;
         }
 
-        bgc->gc.base = id * 8;
-        bgc->gc.owner = THIS_MODULE;
-        platform_set_drvdata(pdev, bgc);
+        gc->base = id * 8;
+        gc->owner = THIS_MODULE;
+        platform_set_drvdata(pdev, gc);
 
-        return gpiochip_add(&bgc->gc);
+        return gpiochip_add_data(gc, NULL);
 }
 
 static int clps711x_gpio_remove(struct platform_device *pdev)
 {
-        struct bgpio_chip *bgc = platform_get_drvdata(pdev);
+        struct gpio_chip *gc = platform_get_drvdata(pdev);
 
-        return bgpio_remove(bgc);
+        gpiochip_remove(gc);
+        return 0;
 }
 
 static const struct of_device_id __maybe_unused clps711x_gpio_ids[] = {
diff --git a/drivers/gpio/gpio-crystalcove.c b/drivers/gpio/gpio-crystalcove.c
index fddd204dc9b6..7865ef0d3352 100644
--- a/drivers/gpio/gpio-crystalcove.c
+++ b/drivers/gpio/gpio-crystalcove.c
@@ -86,11 +86,6 @@ struct crystalcove_gpio {
         bool set_irq_mask;
 };
 
-static inline struct crystalcove_gpio *to_cg(struct gpio_chip *gc)
-{
-        return container_of(gc, struct crystalcove_gpio, chip);
-}
-
 static inline int to_reg(int gpio, enum ctrl_register reg_type)
 {
         int reg;
@@ -134,7 +129,7 @@ static void crystalcove_update_irq_ctrl(struct crystalcove_gpio *cg, int gpio)
 
 static int crystalcove_gpio_dir_in(struct gpio_chip *chip, unsigned gpio)
 {
-        struct crystalcove_gpio *cg = to_cg(chip);
+        struct crystalcove_gpio *cg = gpiochip_get_data(chip);
 
         if (gpio > CRYSTALCOVE_VGPIO_NUM)
                 return 0;
@@ -146,7 +141,7 @@ static int crystalcove_gpio_dir_in(struct gpio_chip *chip, unsigned gpio)
 static int crystalcove_gpio_dir_out(struct gpio_chip *chip, unsigned gpio,
                                     int value)
 {
-        struct crystalcove_gpio *cg = to_cg(chip);
+        struct crystalcove_gpio *cg = gpiochip_get_data(chip);
 
         if (gpio > CRYSTALCOVE_VGPIO_NUM)
                 return 0;
@@ -157,7 +152,7 @@ static int crystalcove_gpio_dir_out(struct gpio_chip *chip, unsigned gpio,
 
 static int crystalcove_gpio_get(struct gpio_chip *chip, unsigned gpio)
 {
-        struct crystalcove_gpio *cg = to_cg(chip);
+        struct crystalcove_gpio *cg = gpiochip_get_data(chip);
         int ret;
         unsigned int val;
 
@@ -174,7 +169,7 @@ static int crystalcove_gpio_get(struct gpio_chip *chip, unsigned gpio)
 static void crystalcove_gpio_set(struct gpio_chip *chip,
                                  unsigned gpio, int value)
 {
-        struct crystalcove_gpio *cg = to_cg(chip);
+        struct crystalcove_gpio *cg = gpiochip_get_data(chip);
 
         if (gpio > CRYSTALCOVE_VGPIO_NUM)
                 return;
@@ -187,7 +182,8 @@ static void crystalcove_gpio_set(struct gpio_chip *chip,
 
 static int crystalcove_irq_type(struct irq_data *data, unsigned type)
 {
-        struct crystalcove_gpio *cg = to_cg(irq_data_get_irq_chip_data(data));
+        struct crystalcove_gpio *cg =
+                gpiochip_get_data(irq_data_get_irq_chip_data(data));
 
         switch (type) {
         case IRQ_TYPE_NONE:
@@ -213,14 +209,16 @@ static int crystalcove_irq_type(struct irq_data *data, unsigned type)
 
 static void crystalcove_bus_lock(struct irq_data *data)
 {
-        struct crystalcove_gpio *cg = to_cg(irq_data_get_irq_chip_data(data));
+        struct crystalcove_gpio *cg =
+                gpiochip_get_data(irq_data_get_irq_chip_data(data));
 
         mutex_lock(&cg->buslock);
 }
 
 static void crystalcove_bus_sync_unlock(struct irq_data *data)
 {
-        struct crystalcove_gpio *cg = to_cg(irq_data_get_irq_chip_data(data));
+        struct crystalcove_gpio *cg =
+                gpiochip_get_data(irq_data_get_irq_chip_data(data));
         int gpio = data->hwirq;
 
         if (cg->update & UPDATE_IRQ_TYPE)
@@ -234,7 +232,8 @@ static void crystalcove_bus_sync_unlock(struct irq_data *data)
 
 static void crystalcove_irq_unmask(struct irq_data *data)
 {
-        struct crystalcove_gpio *cg = to_cg(irq_data_get_irq_chip_data(data));
+        struct crystalcove_gpio *cg =
+                gpiochip_get_data(irq_data_get_irq_chip_data(data));
 
         cg->set_irq_mask = false;
         cg->update |= UPDATE_IRQ_MASK;
@@ -242,7 +241,8 @@ static void crystalcove_irq_unmask(struct irq_data *data)
 
 static void crystalcove_irq_mask(struct irq_data *data)
 {
-        struct crystalcove_gpio *cg = to_cg(irq_data_get_irq_chip_data(data));
+        struct crystalcove_gpio *cg =
+                gpiochip_get_data(irq_data_get_irq_chip_data(data));
 
         cg->set_irq_mask = true;
         cg->update |= UPDATE_IRQ_MASK;
@@ -288,7 +288,7 @@ static irqreturn_t crystalcove_gpio_irq_handler(int irq, void *data)
 static void crystalcove_gpio_dbg_show(struct seq_file *s,
                                       struct gpio_chip *chip)
 {
-        struct crystalcove_gpio *cg = to_cg(chip);
+        struct crystalcove_gpio *cg = gpiochip_get_data(chip);
         int gpio, offset;
         unsigned int ctlo, ctli, mirqs0, mirqsx, irq;
 
@@ -341,11 +341,11 @@ static int crystalcove_gpio_probe(struct platform_device *pdev)
         cg->chip.base = -1;
         cg->chip.ngpio = CRYSTALCOVE_VGPIO_NUM;
         cg->chip.can_sleep = true;
-        cg->chip.dev = dev;
+        cg->chip.parent = dev;
         cg->chip.dbg_show = crystalcove_gpio_dbg_show;
         cg->regmap = pmic->regmap;
 
-        retval = gpiochip_add(&cg->chip);
+        retval = gpiochip_add_data(&cg->chip, cg);
         if (retval) {
                 dev_warn(&pdev->dev, "add gpio chip error: %d\n", retval);
                 return retval;
diff --git a/drivers/gpio/gpio-cs5535.c b/drivers/gpio/gpio-cs5535.c
index 7b0b198a563d..eccb712e09fb 100644
--- a/drivers/gpio/gpio-cs5535.c
+++ b/drivers/gpio/gpio-cs5535.c
@@ -42,6 +42,10 @@ static ulong mask = GPIO_DEFAULT_MASK;
 module_param_named(mask, mask, ulong, 0444);
 MODULE_PARM_DESC(mask, "GPIO channel mask.");
 
+/*
+ * FIXME: convert this singleton driver to use the state container
+ * design pattern, see Documentation/driver-model/design-patterns.txt
+ */
 static struct cs5535_gpio_chip {
         struct gpio_chip chip;
         resource_size_t base;
@@ -201,8 +205,7 @@ EXPORT_SYMBOL_GPL(cs5535_gpio_setup_event);
 
 static int chip_gpio_request(struct gpio_chip *c, unsigned offset)
 {
-        struct cs5535_gpio_chip *chip =
-                container_of(c, struct cs5535_gpio_chip, chip);
+        struct cs5535_gpio_chip *chip = gpiochip_get_data(c);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->lock, flags);
@@ -242,8 +245,7 @@ static void chip_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 
 static int chip_direction_input(struct gpio_chip *c, unsigned offset)
 {
-        struct cs5535_gpio_chip *chip =
-                container_of(c, struct cs5535_gpio_chip, chip);
+        struct cs5535_gpio_chip *chip = gpiochip_get_data(c);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->lock, flags);
@@ -256,8 +258,7 @@ static int chip_direction_input(struct gpio_chip *c, unsigned offset)
 
 static int chip_direction_output(struct gpio_chip *c, unsigned offset, int val)
 {
-        struct cs5535_gpio_chip *chip =
-                container_of(c, struct cs5535_gpio_chip, chip);
+        struct cs5535_gpio_chip *chip = gpiochip_get_data(c);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->lock, flags);
@@ -347,7 +348,7 @@ static int cs5535_gpio_probe(struct platform_device *pdev)
                                 mask_orig, mask);
 
         /* finally, register with the generic GPIO API */
-        err = gpiochip_add(&cs5535_gpio_chip.chip);
+        err = gpiochip_add_data(&cs5535_gpio_chip.chip, &cs5535_gpio_chip);
         if (err)
                 goto done;
 
diff --git a/drivers/gpio/gpio-da9052.c b/drivers/gpio/gpio-da9052.c
index 2e9578ec0ca1..f9b3247ad14b 100644
--- a/drivers/gpio/gpio-da9052.c
+++ b/drivers/gpio/gpio-da9052.c
@@ -51,11 +51,6 @@ struct da9052_gpio {
         struct gpio_chip gp;
 };
 
-static inline struct da9052_gpio *to_da9052_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct da9052_gpio, gp);
-}
-
 static unsigned char da9052_gpio_port_odd(unsigned offset)
 {
         return offset % 2;
@@ -63,7 +58,7 @@ static unsigned char da9052_gpio_port_odd(unsigned offset)
 
 static int da9052_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct da9052_gpio *gpio = to_da9052_gpio(gc);
+        struct da9052_gpio *gpio = gpiochip_get_data(gc);
         int da9052_port_direction = 0;
         int ret;
 
@@ -89,15 +84,12 @@ static int da9052_gpio_get(struct gpio_chip *gc, unsigned offset)
                                               DA9052_STATUS_D_REG);
                 if (ret < 0)
                         return ret;
-                if (ret & (1 << DA9052_GPIO_SHIFT_COUNT(offset)))
-                        return 1;
-                else
-                        return 0;
+                return !!(ret & (1 << DA9052_GPIO_SHIFT_COUNT(offset)));
         case DA9052_OUTPUT_PUSHPULL:
                 if (da9052_gpio_port_odd(offset))
-                        return ret & DA9052_GPIO_ODD_PORT_MODE;
+                        return !!(ret & DA9052_GPIO_ODD_PORT_MODE);
                 else
-                        return ret & DA9052_GPIO_EVEN_PORT_MODE;
+                        return !!(ret & DA9052_GPIO_EVEN_PORT_MODE);
         default:
                 return -EINVAL;
         }
@@ -105,7 +97,7 @@ static int da9052_gpio_get(struct gpio_chip *gc, unsigned offset)
 
 static void da9052_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct da9052_gpio *gpio = to_da9052_gpio(gc);
+        struct da9052_gpio *gpio = gpiochip_get_data(gc);
         int ret;
 
         if (da9052_gpio_port_odd(offset)) {
@@ -131,7 +123,7 @@ static void da9052_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 
 static int da9052_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct da9052_gpio *gpio = to_da9052_gpio(gc);
+        struct da9052_gpio *gpio = gpiochip_get_data(gc);
         unsigned char register_value;
         int ret;
 
@@ -157,7 +149,7 @@ static int da9052_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 static int da9052_gpio_direction_output(struct gpio_chip *gc,
                                         unsigned offset, int value)
 {
-        struct da9052_gpio *gpio = to_da9052_gpio(gc);
+        struct da9052_gpio *gpio = gpiochip_get_data(gc);
         unsigned char register_value;
         int ret;
 
@@ -182,7 +174,7 @@ static int da9052_gpio_direction_output(struct gpio_chip *gc,
 
 static int da9052_gpio_to_irq(struct gpio_chip *gc, u32 offset)
 {
-        struct da9052_gpio *gpio = to_da9052_gpio(gc);
+        struct da9052_gpio *gpio = gpiochip_get_data(gc);
         struct da9052 *da9052 = gpio->da9052;
 
         int irq;
@@ -222,7 +214,7 @@ static int da9052_gpio_probe(struct platform_device *pdev)
         if (pdata && pdata->gpio_base)
                 gpio->gp.base = pdata->gpio_base;
 
-        ret = gpiochip_add(&gpio->gp);
+        ret = gpiochip_add_data(&gpio->gp, gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-da9055.c b/drivers/gpio/gpio-da9055.c
index 7227e6ed3cb9..18210fb2cb13 100644
--- a/drivers/gpio/gpio-da9055.c
+++ b/drivers/gpio/gpio-da9055.c
@@ -35,14 +35,9 @@ struct da9055_gpio {
         struct gpio_chip gp;
 };
 
-static inline struct da9055_gpio *to_da9055_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct da9055_gpio, gp);
-}
-
 static int da9055_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct da9055_gpio *gpio = to_da9055_gpio(gc);
+        struct da9055_gpio *gpio = gpiochip_get_data(gc);
         int gpio_direction = 0;
         int ret;
 
@@ -71,7 +66,7 @@ static int da9055_gpio_get(struct gpio_chip *gc, unsigned offset)
 
 static void da9055_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct da9055_gpio *gpio = to_da9055_gpio(gc);
+        struct da9055_gpio *gpio = gpiochip_get_data(gc);
 
         da9055_reg_update(gpio->da9055,
                         DA9055_REG_GPIO_MODE0_2,
@@ -81,7 +76,7 @@ static void da9055_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 
 static int da9055_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct da9055_gpio *gpio = to_da9055_gpio(gc);
+        struct da9055_gpio *gpio = gpiochip_get_data(gc);
         unsigned char reg_byte;
 
         reg_byte = (DA9055_ACT_LOW | DA9055_GPI)
@@ -97,7 +92,7 @@ static int da9055_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 static int da9055_gpio_direction_output(struct gpio_chip *gc,
                                         unsigned offset, int value)
 {
-        struct da9055_gpio *gpio = to_da9055_gpio(gc);
+        struct da9055_gpio *gpio = gpiochip_get_data(gc);
         unsigned char reg_byte;
         int ret;
 
@@ -119,7 +114,7 @@ static int da9055_gpio_direction_output(struct gpio_chip *gc,
 
 static int da9055_gpio_to_irq(struct gpio_chip *gc, u32 offset)
 {
-        struct da9055_gpio *gpio = to_da9055_gpio(gc);
+        struct da9055_gpio *gpio = gpiochip_get_data(gc);
         struct da9055 *da9055 = gpio->da9055;
 
         return regmap_irq_get_virq(da9055->irq_data,
@@ -156,7 +151,7 @@ static int da9055_gpio_probe(struct platform_device *pdev)
         if (pdata && pdata->gpio_base)
                 gpio->gp.base = pdata->gpio_base;
 
-        ret = gpiochip_add(&gpio->gp);
+        ret = gpiochip_add_data(&gpio->gp, gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
                 goto err_mem;
diff --git a/drivers/gpio/gpio-davinci.c b/drivers/gpio/gpio-davinci.c
index 5e715388803d..ec58f4288649 100644
--- a/drivers/gpio/gpio-davinci.c
+++ b/drivers/gpio/gpio-davinci.c
@@ -41,9 +41,6 @@ typedef struct irq_chip *(*gpio_get_irq_chip_cb_t)(unsigned int irq);
 
 #define BINTEN  0x8 /* GPIO Interrupt Per-Bank Enable Register */
 
-#define chip2controller(chip)   \
-        container_of(chip, struct davinci_gpio_controller, chip)
-
 static void __iomem *gpio_base;
 
 static struct davinci_gpio_regs __iomem *gpio2regs(unsigned gpio)
@@ -82,7 +79,7 @@ static int davinci_gpio_irq_setup(struct platform_device *pdev);
 static inline int __davinci_direction(struct gpio_chip *chip,
                         unsigned offset, bool out, int value)
 {
-        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_controller *d = gpiochip_get_data(chip);
         struct davinci_gpio_regs __iomem *g = d->regs;
         unsigned long flags;
         u32 temp;
@@ -122,10 +119,10 @@ davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
  */
 static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_controller *d = gpiochip_get_data(chip);
         struct davinci_gpio_regs __iomem *g = d->regs;
 
-        return (1 << offset) & readl_relaxed(&g->in_data);
+        return !!((1 << offset) & readl_relaxed(&g->in_data));
 }
 
 /*
@@ -134,7 +131,7 @@ static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
 static void
 davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_controller *d = gpiochip_get_data(chip);
         struct davinci_gpio_regs __iomem *g = d->regs;
 
         writel_relaxed((1 << offset), value ? &g->set_data : &g->clr_data);
@@ -149,7 +146,7 @@ davinci_gpio_get_pdata(struct platform_device *pdev)
         u32 val;
 
         if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node)
-                return pdev->dev.platform_data;
+                return dev_get_platdata(&pdev->dev);
 
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
@@ -179,8 +176,8 @@ static int davinci_gpio_of_xlate(struct gpio_chip *gc,
                              const struct of_phandle_args *gpiospec,
                              u32 *flags)
 {
-        struct davinci_gpio_controller *chips = dev_get_drvdata(gc->dev);
-        struct davinci_gpio_platform_data *pdata = dev_get_platdata(gc->dev);
+        struct davinci_gpio_controller *chips = dev_get_drvdata(gc->parent);
+        struct davinci_gpio_platform_data *pdata = dev_get_platdata(gc->parent);
 
         if (gpiospec->args[0] > pdata->ngpio)
                 return -EINVAL;
@@ -254,7 +251,7 @@ static int davinci_gpio_probe(struct platform_device *pdev)
 #ifdef CONFIG_OF_GPIO
                 chips[i].chip.of_gpio_n_cells = 2;
                 chips[i].chip.of_xlate = davinci_gpio_of_xlate;
-                chips[i].chip.dev = dev;
+                chips[i].chip.parent = dev;
                 chips[i].chip.of_node = dev->of_node;
 #endif
                 spin_lock_init(&chips[i].lock);
@@ -265,7 +262,7 @@ static int davinci_gpio_probe(struct platform_device *pdev)
                 chips[i].clr_data = &regs->clr_data;
                 chips[i].in_data = &regs->in_data;
 
-                gpiochip_add(&chips[i].chip);
+                gpiochip_add_data(&chips[i].chip, &chips[i]);
         }
 
         platform_set_drvdata(pdev, chips);
@@ -368,7 +365,7 @@ static void gpio_irq_handler(struct irq_desc *desc)
 
 static int gpio_to_irq_banked(struct gpio_chip *chip, unsigned offset)
 {
-        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_controller *d = gpiochip_get_data(chip);
 
         if (d->irq_domain)
                 return irq_create_mapping(d->irq_domain, d->chip.base + offset);
@@ -378,7 +375,7 @@ static int gpio_to_irq_banked(struct gpio_chip *chip, unsigned offset)
 
 static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
 {
-        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_controller *d = gpiochip_get_data(chip);
 
         /*
          * NOTE:  we assume for now that only irqs in the first gpio_chip
diff --git a/drivers/gpio/gpio-dln2.c b/drivers/gpio/gpio-dln2.c
index 6685712c15cf..e11a7d126e74 100644
--- a/drivers/gpio/gpio-dln2.c
+++ b/drivers/gpio/gpio-dln2.c
@@ -153,7 +153,7 @@ static int dln2_gpio_pin_set_out_val(struct dln2_gpio *dln2,
 
 static int dln2_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
         struct dln2_gpio_pin req = {
                 .pin = cpu_to_le16(offset),
         };
@@ -194,14 +194,14 @@ out_disable:
 
 static void dln2_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
 
         dln2_gpio_pin_cmd(dln2, DLN2_GPIO_PIN_DISABLE, offset);
 }
 
 static int dln2_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
 
         if (test_bit(offset, dln2->output_enabled))
                 return GPIOF_DIR_OUT;
@@ -211,7 +211,7 @@ static int dln2_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 
 static int dln2_gpio_get(struct gpio_chip *chip, unsigned int offset)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
         int dir;
 
         dir = dln2_gpio_get_direction(chip, offset);
@@ -226,7 +226,7 @@ static int dln2_gpio_get(struct gpio_chip *chip, unsigned int offset)
 
 static void dln2_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
 
         dln2_gpio_pin_set_out_val(dln2, offset, value);
 }
@@ -234,7 +234,7 @@ static void dln2_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 static int dln2_gpio_set_direction(struct gpio_chip *chip, unsigned offset,
                                    unsigned dir)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
         struct dln2_gpio_pin_val req = {
                 .pin = cpu_to_le16(offset),
                 .value = dir,
@@ -262,7 +262,7 @@ static int dln2_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int dln2_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                       int value)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
         int ret;
 
         ret = dln2_gpio_pin_set_out_val(dln2, offset, value);
@@ -275,7 +275,7 @@ static int dln2_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 static int dln2_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
                                   unsigned debounce)
 {
-        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(chip);
         __le32 duration = cpu_to_le32(debounce);
 
         return dln2_transfer_tx(dln2->pdev, DLN2_GPIO_SET_DEBOUNCE,
@@ -302,7 +302,7 @@ static int dln2_gpio_set_event_cfg(struct dln2_gpio *dln2, unsigned pin,
 static void dln2_irq_unmask(struct irq_data *irqd)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
-        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(gc);
         int pin = irqd_to_hwirq(irqd);
 
         set_bit(pin, dln2->unmasked_irqs);
@@ -311,7 +311,7 @@ static void dln2_irq_unmask(struct irq_data *irqd)
 static void dln2_irq_mask(struct irq_data *irqd)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
-        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(gc);
         int pin = irqd_to_hwirq(irqd);
 
         clear_bit(pin, dln2->unmasked_irqs);
@@ -320,7 +320,7 @@ static void dln2_irq_mask(struct irq_data *irqd)
 static int dln2_irq_set_type(struct irq_data *irqd, unsigned type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
-        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(gc);
         int pin = irqd_to_hwirq(irqd);
 
         switch (type) {
@@ -349,7 +349,7 @@ static int dln2_irq_set_type(struct irq_data *irqd, unsigned type)
 static void dln2_irq_bus_lock(struct irq_data *irqd)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
-        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(gc);
 
         mutex_lock(&dln2->irq_lock);
 }
@@ -357,7 +357,7 @@ static void dln2_irq_bus_lock(struct irq_data *irqd)
 static void dln2_irq_bus_unlock(struct irq_data *irqd)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
-        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        struct dln2_gpio *dln2 = gpiochip_get_data(gc);
         int pin = irqd_to_hwirq(irqd);
         int enabled, unmasked;
         unsigned type;
@@ -377,7 +377,7 @@ static void dln2_irq_bus_unlock(struct irq_data *irqd)
 
                 ret = dln2_gpio_set_event_cfg(dln2, pin, type, 0);
                 if (ret)
-                        dev_err(dln2->gpio.dev, "failed to set event\n");
+                        dev_err(dln2->gpio.parent, "failed to set event\n");
         }
 
         mutex_unlock(&dln2->irq_lock);
@@ -406,19 +406,19 @@ static void dln2_gpio_event(struct platform_device *pdev, u16 echo,
         struct dln2_gpio *dln2 = platform_get_drvdata(pdev);
 
         if (len < sizeof(*event)) {
-                dev_err(dln2->gpio.dev, "short event message\n");
+                dev_err(dln2->gpio.parent, "short event message\n");
                 return;
         }
 
         pin = le16_to_cpu(event->pin);
         if (pin >= dln2->gpio.ngpio) {
-                dev_err(dln2->gpio.dev, "out of bounds pin %d\n", pin);
+                dev_err(dln2->gpio.parent, "out of bounds pin %d\n", pin);
                 return;
         }
 
         irq = irq_find_mapping(dln2->gpio.irqdomain, pin);
         if (!irq) {
-                dev_err(dln2->gpio.dev, "pin %d not mapped to IRQ\n", pin);
+                dev_err(dln2->gpio.parent, "pin %d not mapped to IRQ\n", pin);
                 return;
         }
 
@@ -462,7 +462,7 @@ static int dln2_gpio_probe(struct platform_device *pdev)
         dln2->pdev = pdev;
 
         dln2->gpio.label = "dln2";
-        dln2->gpio.dev = dev;
+        dln2->gpio.parent = dev;
         dln2->gpio.owner = THIS_MODULE;
         dln2->gpio.base = -1;
         dln2->gpio.ngpio = pins;
@@ -479,7 +479,7 @@ static int dln2_gpio_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, dln2);
 
-        ret = gpiochip_add(&dln2->gpio);
+        ret = gpiochip_add_data(&dln2->gpio, dln2);
         if (ret < 0) {
                 dev_err(dev, "failed to add gpio chip: %d\n", ret);
                 goto out;
diff --git a/drivers/gpio/gpio-dwapb.c b/drivers/gpio/gpio-dwapb.c
index fcd5b0acfc72..597de1ef497b 100644
--- a/drivers/gpio/gpio-dwapb.c
+++ b/drivers/gpio/gpio-dwapb.c
@@ -7,7 +7,9 @@
  *
  * All enquiries to support@picochip.com
  */
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
+/* FIXME: for gpio_get_value(), replace this with direct register read */
+#include <linux/gpio.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
@@ -66,7 +68,7 @@ struct dwapb_context {
 #endif
 
 struct dwapb_gpio_port {
-        struct bgpio_chip       bgc;
+        struct gpio_chip        gc;
         bool                    is_registered;
         struct dwapb_gpio       *gpio;
 #ifdef CONFIG_PM_SLEEP
@@ -83,33 +85,26 @@ struct dwapb_gpio {
         struct irq_domain       *domain;
 };
 
-static inline struct dwapb_gpio_port *
-to_dwapb_gpio_port(struct bgpio_chip *bgc)
-{
-        return container_of(bgc, struct dwapb_gpio_port, bgc);
-}
-
 static inline u32 dwapb_read(struct dwapb_gpio *gpio, unsigned int offset)
 {
-        struct bgpio_chip *bgc  = &gpio->ports[0].bgc;
+        struct gpio_chip *gc    = &gpio->ports[0].gc;
         void __iomem *reg_base  = gpio->regs;
 
-        return bgc->read_reg(reg_base + offset);
+        return gc->read_reg(reg_base + offset);
 }
 
 static inline void dwapb_write(struct dwapb_gpio *gpio, unsigned int offset,
                                u32 val)
 {
-        struct bgpio_chip *bgc  = &gpio->ports[0].bgc;
+        struct gpio_chip *gc    = &gpio->ports[0].gc;
         void __iomem *reg_base  = gpio->regs;
 
-        bgc->write_reg(reg_base + offset, val);
+        gc->write_reg(reg_base + offset, val);
 }
 
 static int dwapb_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        struct dwapb_gpio_port *port = to_dwapb_gpio_port(bgc);
+        struct dwapb_gpio_port *port = gpiochip_get_data(gc);
         struct dwapb_gpio *gpio = port->gpio;
 
         return irq_find_mapping(gpio->domain, offset);
@@ -119,7 +114,7 @@ static void dwapb_toggle_trigger(struct dwapb_gpio *gpio, unsigned int offs)
 {
         u32 v = dwapb_read(gpio, GPIO_INT_POLARITY);
 
-        if (gpio_get_value(gpio->ports[0].bgc.gc.base + offs))
+        if (gpio_get_value(gpio->ports[0].gc.base + offs))
                 v &= ~BIT(offs);
         else
                 v |= BIT(offs);
@@ -162,39 +157,39 @@ static void dwapb_irq_enable(struct irq_data *d)
 {
         struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
         struct dwapb_gpio *gpio = igc->private;
-        struct bgpio_chip *bgc = &gpio->ports[0].bgc;
+        struct gpio_chip *gc = &gpio->ports[0].gc;
         unsigned long flags;
         u32 val;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
         val = dwapb_read(gpio, GPIO_INTEN);
         val |= BIT(d->hwirq);
         dwapb_write(gpio, GPIO_INTEN, val);
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 }
 
 static void dwapb_irq_disable(struct irq_data *d)
 {
         struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
         struct dwapb_gpio *gpio = igc->private;
-        struct bgpio_chip *bgc = &gpio->ports[0].bgc;
+        struct gpio_chip *gc = &gpio->ports[0].gc;
         unsigned long flags;
         u32 val;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
         val = dwapb_read(gpio, GPIO_INTEN);
         val &= ~BIT(d->hwirq);
         dwapb_write(gpio, GPIO_INTEN, val);
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 }
 
 static int dwapb_irq_reqres(struct irq_data *d)
 {
         struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
         struct dwapb_gpio *gpio = igc->private;
-        struct bgpio_chip *bgc = &gpio->ports[0].bgc;
+        struct gpio_chip *gc = &gpio->ports[0].gc;
 
-        if (gpiochip_lock_as_irq(&bgc->gc, irqd_to_hwirq(d))) {
+        if (gpiochip_lock_as_irq(gc, irqd_to_hwirq(d))) {
                 dev_err(gpio->dev, "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
                 return -EINVAL;
@@ -206,16 +201,16 @@ static void dwapb_irq_relres(struct irq_data *d)
 {
         struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
         struct dwapb_gpio *gpio = igc->private;
-        struct bgpio_chip *bgc = &gpio->ports[0].bgc;
+        struct gpio_chip *gc = &gpio->ports[0].gc;
 
-        gpiochip_unlock_as_irq(&bgc->gc, irqd_to_hwirq(d));
+        gpiochip_unlock_as_irq(gc, irqd_to_hwirq(d));
 }
 
 static int dwapb_irq_set_type(struct irq_data *d, u32 type)
 {
         struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
         struct dwapb_gpio *gpio = igc->private;
-        struct bgpio_chip *bgc = &gpio->ports[0].bgc;
+        struct gpio_chip *gc = &gpio->ports[0].gc;
         int bit = d->hwirq;
         unsigned long level, polarity, flags;
 
@@ -223,7 +218,7 @@ static int dwapb_irq_set_type(struct irq_data *d, u32 type)
                      IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
                 return -EINVAL;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
         level = dwapb_read(gpio, GPIO_INTTYPE_LEVEL);
         polarity = dwapb_read(gpio, GPIO_INT_POLARITY);
 
@@ -254,7 +249,7 @@ static int dwapb_irq_set_type(struct irq_data *d, u32 type)
 
         dwapb_write(gpio, GPIO_INTTYPE_LEVEL, level);
         dwapb_write(gpio, GPIO_INT_POLARITY, polarity);
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
@@ -262,13 +257,12 @@ static int dwapb_irq_set_type(struct irq_data *d, u32 type)
 static int dwapb_gpio_set_debounce(struct gpio_chip *gc,
                                    unsigned offset, unsigned debounce)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        struct dwapb_gpio_port *port = to_dwapb_gpio_port(bgc);
+        struct dwapb_gpio_port *port = gpiochip_get_data(gc);
         struct dwapb_gpio *gpio = port->gpio;
         unsigned long flags, val_deb;
-        unsigned long mask = bgc->pin2mask(bgc, offset);
+        unsigned long mask = gc->pin2mask(gc, offset);
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
         val_deb = dwapb_read(gpio, GPIO_PORTA_DEBOUNCE);
         if (debounce)
@@ -276,7 +270,7 @@ static int dwapb_gpio_set_debounce(struct gpio_chip *gc,
         else
                 dwapb_write(gpio, GPIO_PORTA_DEBOUNCE, val_deb & ~mask);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
@@ -295,7 +289,7 @@ static void dwapb_configure_irqs(struct dwapb_gpio *gpio,
                                  struct dwapb_gpio_port *port,
                                  struct dwapb_port_property *pp)
 {
-        struct gpio_chip *gc = &port->bgc.gc;
+        struct gpio_chip *gc = &port->gc;
         struct device_node *node = pp->node;
         struct irq_chip_generic *irq_gc = NULL;
         unsigned int hwirq, ngpio = gc->ngpio;
@@ -369,13 +363,13 @@ static void dwapb_configure_irqs(struct dwapb_gpio *gpio,
         for (hwirq = 0 ; hwirq < ngpio ; hwirq++)
                 irq_create_mapping(gpio->domain, hwirq);
 
-        port->bgc.gc.to_irq = dwapb_gpio_to_irq;
+        port->gc.to_irq = dwapb_gpio_to_irq;
 }
 
 static void dwapb_irq_teardown(struct dwapb_gpio *gpio)
 {
         struct dwapb_gpio_port *port = &gpio->ports[0];
-        struct gpio_chip *gc = &port->bgc.gc;
+        struct gpio_chip *gc = &port->gc;
         unsigned int ngpio = gc->ngpio;
         irq_hw_number_t hwirq;
 
@@ -412,7 +406,7 @@ static int dwapb_gpio_add_port(struct dwapb_gpio *gpio,
         dirout = gpio->regs + GPIO_SWPORTA_DDR +
                 (pp->idx * GPIO_SWPORT_DDR_SIZE);
 
-        err = bgpio_init(&port->bgc, gpio->dev, 4, dat, set, NULL, dirout,
+        err = bgpio_init(&port->gc, gpio->dev, 4, dat, set, NULL, dirout,
                          NULL, false);
         if (err) {
                 dev_err(gpio->dev, "failed to init gpio chip for %s\n",
@@ -421,19 +415,19 @@ static int dwapb_gpio_add_port(struct dwapb_gpio *gpio,
         }
 
 #ifdef CONFIG_OF_GPIO
-        port->bgc.gc.of_node = pp->node;
+        port->gc.of_node = pp->node;
 #endif
-        port->bgc.gc.ngpio = pp->ngpio;
-        port->bgc.gc.base = pp->gpio_base;
+        port->gc.ngpio = pp->ngpio;
+        port->gc.base = pp->gpio_base;
 
         /* Only port A support debounce */
         if (pp->idx == 0)
-                port->bgc.gc.set_debounce = dwapb_gpio_set_debounce;
+                port->gc.set_debounce = dwapb_gpio_set_debounce;
 
         if (pp->irq)
                 dwapb_configure_irqs(gpio, port, pp);
 
-        err = gpiochip_add(&port->bgc.gc);
+        err = gpiochip_add_data(&port->gc, port);
         if (err)
                 dev_err(gpio->dev, "failed to register gpiochip for %s\n",
                         pp->name);
@@ -449,7 +443,7 @@ static void dwapb_gpio_unregister(struct dwapb_gpio *gpio)
 
         for (m = 0; m < gpio->nr_ports; ++m)
                 if (gpio->ports[m].is_registered)
-                        gpiochip_remove(&gpio->ports[m].bgc.gc);
+                        gpiochip_remove(&gpio->ports[m].gc);
 }
 
 static struct dwapb_platform_data *
@@ -591,11 +585,11 @@ static int dwapb_gpio_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct dwapb_gpio *gpio = platform_get_drvdata(pdev);
-        struct bgpio_chip *bgc  = &gpio->ports[0].bgc;
+        struct gpio_chip *gc    = &gpio->ports[0].gc;
         unsigned long flags;
         int i;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
         for (i = 0; i < gpio->nr_ports; i++) {
                 unsigned int offset;
                 unsigned int idx = gpio->ports[i].idx;
@@ -624,7 +618,7 @@ static int dwapb_gpio_suspend(struct device *dev)
                         dwapb_write(gpio, GPIO_INTMASK, 0xffffffff);
                 }
         }
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
@@ -633,11 +627,11 @@ static int dwapb_gpio_resume(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct dwapb_gpio *gpio = platform_get_drvdata(pdev);
-        struct bgpio_chip *bgc  = &gpio->ports[0].bgc;
+        struct gpio_chip *gc    = &gpio->ports[0].gc;
         unsigned long flags;
         int i;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
         for (i = 0; i < gpio->nr_ports; i++) {
                 unsigned int offset;
                 unsigned int idx = gpio->ports[i].idx;
@@ -666,7 +660,7 @@ static int dwapb_gpio_resume(struct device *dev)
                         dwapb_write(gpio, GPIO_PORTA_EOI, 0xffffffff);
                 }
         }
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
diff --git a/drivers/gpio/gpio-em.c b/drivers/gpio/gpio-em.c
index 6bca1e125e12..8d32ccc980d9 100644
--- a/drivers/gpio/gpio-em.c
+++ b/drivers/gpio/gpio-em.c
@@ -103,7 +103,7 @@ static int em_gio_irq_reqres(struct irq_data *d)
         struct em_gio_priv *p = irq_data_get_irq_chip_data(d);
 
         if (gpiochip_lock_as_irq(&p->gpio_chip, irqd_to_hwirq(d))) {
-                dev_err(p->gpio_chip.dev,
+                dev_err(p->gpio_chip.parent,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
                 return -EINVAL;
@@ -192,7 +192,7 @@ static irqreturn_t em_gio_irq_handler(int irq, void *dev_id)
 
 static inline struct em_gio_priv *gpio_to_priv(struct gpio_chip *chip)
 {
-        return container_of(chip, struct em_gio_priv, gpio_chip);
+        return gpiochip_get_data(chip);
 }
 
 static int em_gio_direction_input(struct gpio_chip *chip, unsigned offset)
@@ -203,7 +203,7 @@ static int em_gio_direction_input(struct gpio_chip *chip, unsigned offset)
 
 static int em_gio_get(struct gpio_chip *chip, unsigned offset)
 {
-        return (int)(em_gio_read(gpio_to_priv(chip), GIO_I) & BIT(offset));
+        return !!(em_gio_read(gpio_to_priv(chip), GIO_I) & BIT(offset));
 }
 
 static void __em_gio_set(struct gpio_chip *chip, unsigned int reg,
@@ -332,7 +332,7 @@ static int em_gio_probe(struct platform_device *pdev)
         gpio_chip->request = em_gio_request;
         gpio_chip->free = em_gio_free;
         gpio_chip->label = name;
-        gpio_chip->dev = &pdev->dev;
+        gpio_chip->parent = &pdev->dev;
         gpio_chip->owner = THIS_MODULE;
         gpio_chip->base = -1;
         gpio_chip->ngpio = ngpios;
@@ -368,7 +368,7 @@ static int em_gio_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        ret = gpiochip_add(gpio_chip);
+        ret = gpiochip_add_data(gpio_chip, p);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add GPIO controller\n");
                 goto err1;
diff --git a/drivers/gpio/gpio-ep93xx.c b/drivers/gpio/gpio-ep93xx.c
index 3e3947b35c83..ad279078fed7 100644
--- a/drivers/gpio/gpio-ep93xx.c
+++ b/drivers/gpio/gpio-ep93xx.c
@@ -16,10 +16,11 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <linux/gpio.h>
 #include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
+/* FIXME: this is here for gpio_to_irq() - get rid of this! */
+#include <linux/gpio.h>
 
 #include <mach/hardware.h>
 #include <mach/gpio-ep93xx.h>
@@ -28,7 +29,7 @@
 
 struct ep93xx_gpio {
         void __iomem            *mmio_base;
-        struct bgpio_chip       bgc[8];
+        struct gpio_chip        gc[8];
 };
 
 /*************************************************************************
@@ -319,26 +320,26 @@ static int ep93xx_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
         return 64 + gpio;
 }
 
-static int ep93xx_gpio_add_bank(struct bgpio_chip *bgc, struct device *dev,
+static int ep93xx_gpio_add_bank(struct gpio_chip *gc, struct device *dev,
         void __iomem *mmio_base, struct ep93xx_gpio_bank *bank)
 {
         void __iomem *data = mmio_base + bank->data;
         void __iomem *dir =  mmio_base + bank->dir;
         int err;
 
-        err = bgpio_init(bgc, dev, 1, data, NULL, NULL, dir, NULL, 0);
+        err = bgpio_init(gc, dev, 1, data, NULL, NULL, dir, NULL, 0);
         if (err)
                 return err;
 
-        bgc->gc.label = bank->label;
-        bgc->gc.base = bank->base;
+        gc->label = bank->label;
+        gc->base = bank->base;
 
         if (bank->has_debounce) {
-                bgc->gc.set_debounce = ep93xx_gpio_set_debounce;
-                bgc->gc.to_irq = ep93xx_gpio_to_irq;
+                gc->set_debounce = ep93xx_gpio_set_debounce;
+                gc->to_irq = ep93xx_gpio_to_irq;
         }
 
-        return gpiochip_add(&bgc->gc);
+        return gpiochip_add_data(gc, NULL);
 }
 
 static int ep93xx_gpio_probe(struct platform_device *pdev)
@@ -358,10 +359,10 @@ static int ep93xx_gpio_probe(struct platform_device *pdev)
                 return PTR_ERR(ep93xx_gpio->mmio_base);
 
         for (i = 0; i < ARRAY_SIZE(ep93xx_gpio_banks); i++) {
-                struct bgpio_chip *bgc = &ep93xx_gpio->bgc[i];
+                struct gpio_chip *gc = &ep93xx_gpio->gc[i];
                 struct ep93xx_gpio_bank *bank = &ep93xx_gpio_banks[i];
 
-                if (ep93xx_gpio_add_bank(bgc, &pdev->dev,
+                if (ep93xx_gpio_add_bank(gc, &pdev->dev,
                                          ep93xx_gpio->mmio_base, bank))
                         dev_warn(&pdev->dev, "Unable to add gpio bank %s\n",
                                 bank->label);
diff --git a/drivers/gpio/gpio-etraxfs.c b/drivers/gpio/gpio-etraxfs.c
index 5c15dd12172d..00b022c9acb3 100644
--- a/drivers/gpio/gpio-etraxfs.c
+++ b/drivers/gpio/gpio-etraxfs.c
@@ -1,12 +1,10 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio.h>
 #include <linux/gpio/driver.h>
 #include <linux/of_gpio.h>
 #include <linux/io.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
-#include <linux/basic_mmio_gpio.h>
 
 #define ETRAX_FS_rw_pa_dout     0
 #define ETRAX_FS_r_pa_din       4
@@ -67,7 +65,7 @@ struct etraxfs_gpio_block {
 };
 
 struct etraxfs_gpio_chip {
-        struct bgpio_chip bgc;
+        struct gpio_chip gc;
         struct etraxfs_gpio_block *block;
 };
 
@@ -176,11 +174,6 @@ static const struct etraxfs_gpio_info etraxfs_gpio_artpec3 = {
         .rw_intr_pins   = ARTPEC3_rw_intr_pins,
 };
 
-static struct etraxfs_gpio_chip *to_etraxfs(struct gpio_chip *gc)
-{
-        return container_of(gc, struct etraxfs_gpio_chip, bgc.gc);
-}
-
 static unsigned int etraxfs_gpio_chip_to_port(struct gpio_chip *gc)
 {
         return gc->label[0] - 'A';
@@ -220,13 +213,13 @@ static unsigned int etraxfs_gpio_to_group_irq(unsigned int gpio)
 static unsigned int etraxfs_gpio_to_group_pin(struct etraxfs_gpio_chip *chip,
                                               unsigned int gpio)
 {
-        return 4 * etraxfs_gpio_chip_to_port(&chip->bgc.gc) + gpio / 8;
+        return 4 * etraxfs_gpio_chip_to_port(&chip->gc) + gpio / 8;
 }
 
 static void etraxfs_gpio_irq_ack(struct irq_data *d)
 {
         struct etraxfs_gpio_chip *chip =
-                to_etraxfs(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         struct etraxfs_gpio_block *block = chip->block;
         unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
 
@@ -236,7 +229,7 @@ static void etraxfs_gpio_irq_ack(struct irq_data *d)
 static void etraxfs_gpio_irq_mask(struct irq_data *d)
 {
         struct etraxfs_gpio_chip *chip =
-                to_etraxfs(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         struct etraxfs_gpio_block *block = chip->block;
         unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
 
@@ -249,7 +242,7 @@ static void etraxfs_gpio_irq_mask(struct irq_data *d)
 static void etraxfs_gpio_irq_unmask(struct irq_data *d)
 {
         struct etraxfs_gpio_chip *chip =
-                to_etraxfs(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         struct etraxfs_gpio_block *block = chip->block;
         unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
 
@@ -262,7 +255,7 @@ static void etraxfs_gpio_irq_unmask(struct irq_data *d)
 static int etraxfs_gpio_irq_set_type(struct irq_data *d, u32 type)
 {
         struct etraxfs_gpio_chip *chip =
-                to_etraxfs(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         struct etraxfs_gpio_block *block = chip->block;
         unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
         u32 cfg;
@@ -299,7 +292,7 @@ static int etraxfs_gpio_irq_set_type(struct irq_data *d, u32 type)
 static int etraxfs_gpio_irq_request_resources(struct irq_data *d)
 {
         struct etraxfs_gpio_chip *chip =
-                to_etraxfs(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         struct etraxfs_gpio_block *block = chip->block;
         unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
         int ret = -EBUSY;
@@ -308,7 +301,7 @@ static int etraxfs_gpio_irq_request_resources(struct irq_data *d)
         if (block->group[grpirq])
                 goto out;
 
-        ret = gpiochip_lock_as_irq(&chip->bgc.gc, d->hwirq);
+        ret = gpiochip_lock_as_irq(&chip->gc, d->hwirq);
         if (ret)
                 goto out;
 
@@ -330,13 +323,13 @@ out:
 static void etraxfs_gpio_irq_release_resources(struct irq_data *d)
 {
         struct etraxfs_gpio_chip *chip =
-                to_etraxfs(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         struct etraxfs_gpio_block *block = chip->block;
         unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
 
         spin_lock(&block->lock);
         block->group[grpirq] = 0;
-        gpiochip_unlock_as_irq(&chip->bgc.gc, d->hwirq);
+        gpiochip_unlock_as_irq(&chip->gc, d->hwirq);
         spin_unlock(&block->lock);
 }
 
@@ -419,7 +412,7 @@ static int etraxfs_gpio_probe(struct platform_device *pdev)
 
         for (i = 0; i < info->num_ports; i++) {
                 struct etraxfs_gpio_chip *chip = &chips[i];
-                struct bgpio_chip *bgc = &chip->bgc;
+                struct gpio_chip *gc = &chip->gc;
                 const struct etraxfs_gpio_port *port = &info->ports[i];
                 unsigned long flags = BGPIOF_READ_OUTPUT_REG_SET;
                 void __iomem *dat = regs + port->din;
@@ -433,7 +426,7 @@ static int etraxfs_gpio_probe(struct platform_device *pdev)
                         flags = BGPIOF_NO_OUTPUT;
                 }
 
-                ret = bgpio_init(bgc, dev, 4,
+                ret = bgpio_init(gc, dev, 4,
                                  dat, set, NULL, dirout, NULL,
                                  flags);
                 if (ret) {
@@ -442,28 +435,28 @@ static int etraxfs_gpio_probe(struct platform_device *pdev)
                         continue;
                 }
 
-                bgc->gc.ngpio = port->ngpio;
-                bgc->gc.label = port->label;
+                gc->ngpio = port->ngpio;
+                gc->label = port->label;
 
-                bgc->gc.of_node = dev->of_node;
-                bgc->gc.of_gpio_n_cells = 3;
-                bgc->gc.of_xlate = etraxfs_gpio_of_xlate;
+                gc->of_node = dev->of_node;
+                gc->of_gpio_n_cells = 3;
+                gc->of_xlate = etraxfs_gpio_of_xlate;
 
-                ret = gpiochip_add(&bgc->gc);
+                ret = gpiochip_add_data(gc, chip);
                 if (ret) {
                         dev_err(dev, "Unable to register port %s\n",
-                                bgc->gc.label);
+                                gc->label);
                         continue;
                 }
 
                 if (i > 0 && !allportsirq)
                         continue;
 
-                ret = gpiochip_irqchip_add(&bgc->gc, &etraxfs_gpio_irq_chip, 0,
+                ret = gpiochip_irqchip_add(gc, &etraxfs_gpio_irq_chip, 0,
                                            handle_level_irq, IRQ_TYPE_NONE);
                 if (ret) {
                         dev_err(dev, "Unable to add irqchip to port %s\n",
-                                bgc->gc.label);
+                                gc->label);
                 }
         }
 
diff --git a/drivers/gpio/gpio-f7188x.c b/drivers/gpio/gpio-f7188x.c
index 5e3c4fa67d82..d62fd6bbaf82 100644
--- a/drivers/gpio/gpio-f7188x.c
+++ b/drivers/gpio/gpio-f7188x.c
@@ -193,8 +193,7 @@ static struct f7188x_gpio_bank f71889_gpio_bank[] = {
 static int f7188x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 {
         int err;
-        struct f7188x_gpio_bank *bank =
-                container_of(chip, struct f7188x_gpio_bank, chip);
+        struct f7188x_gpio_bank *bank = gpiochip_get_data(chip);
         struct f7188x_sio *sio = bank->data->sio;
         u8 dir;
 
@@ -215,8 +214,7 @@ static int f7188x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 static int f7188x_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
         int err;
-        struct f7188x_gpio_bank *bank =
-                container_of(chip, struct f7188x_gpio_bank, chip);
+        struct f7188x_gpio_bank *bank = gpiochip_get_data(chip);
         struct f7188x_sio *sio = bank->data->sio;
         u8 dir, data;
 
@@ -241,8 +239,7 @@ static int f7188x_gpio_direction_out(struct gpio_chip *chip,
                                      unsigned offset, int value)
 {
         int err;
-        struct f7188x_gpio_bank *bank =
-                container_of(chip, struct f7188x_gpio_bank, chip);
+        struct f7188x_gpio_bank *bank = gpiochip_get_data(chip);
         struct f7188x_sio *sio = bank->data->sio;
         u8 dir, data_out;
 
@@ -270,8 +267,7 @@ static int f7188x_gpio_direction_out(struct gpio_chip *chip,
 static void f7188x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
         int err;
-        struct f7188x_gpio_bank *bank =
-                container_of(chip, struct f7188x_gpio_bank, chip);
+        struct f7188x_gpio_bank *bank = gpiochip_get_data(chip);
         struct f7188x_sio *sio = bank->data->sio;
         u8 data_out;
 
@@ -298,7 +294,7 @@ static int f7188x_gpio_probe(struct platform_device *pdev)
 {
         int err;
         int i;
-        struct f7188x_sio *sio = pdev->dev.platform_data;
+        struct f7188x_sio *sio = dev_get_platdata(&pdev->dev);
         struct f7188x_gpio_data *data;
 
         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
@@ -333,10 +329,10 @@ static int f7188x_gpio_probe(struct platform_device *pdev)
         for (i = 0; i < data->nr_bank; i++) {
                 struct f7188x_gpio_bank *bank = &data->bank[i];
 
-                bank->chip.dev = &pdev->dev;
+                bank->chip.parent = &pdev->dev;
                 bank->data = data;
 
-                err = gpiochip_add(&bank->chip);
+                err = gpiochip_add_data(&bank->chip, bank);
                 if (err) {
                         dev_err(&pdev->dev,
                                 "Failed to register gpiochip %d: %d\n",
diff --git a/drivers/gpio/gpio-ge.c b/drivers/gpio/gpio-ge.c
index f9ac3f351753..cbbec838a9d1 100644
--- a/drivers/gpio/gpio-ge.c
+++ b/drivers/gpio/gpio-ge.c
@@ -24,7 +24,7 @@
 #include <linux/of_gpio.h>
 #include <linux/of_address.h>
 #include <linux/module.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 
 #define GEF_GPIO_DIRECT         0x00
 #define GEF_GPIO_IN             0x04
@@ -55,19 +55,19 @@ static int __init gef_gpio_probe(struct platform_device *pdev)
 {
         const struct of_device_id *of_id =
                 of_match_device(gef_gpio_ids, &pdev->dev);
-        struct bgpio_chip *bgc;
+        struct gpio_chip *gc;
         void __iomem *regs;
         int ret;
 
-        bgc = devm_kzalloc(&pdev->dev, sizeof(*bgc), GFP_KERNEL);
-        if (!bgc)
+        gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
+        if (!gc)
                 return -ENOMEM;
 
         regs = of_iomap(pdev->dev.of_node, 0);
         if (!regs)
                 return -ENOMEM;
 
-        ret = bgpio_init(bgc, &pdev->dev, 4, regs + GEF_GPIO_IN,
+        ret = bgpio_init(gc, &pdev->dev, 4, regs + GEF_GPIO_IN,
                          regs + GEF_GPIO_OUT, NULL, NULL,
                          regs + GEF_GPIO_DIRECT, BGPIOF_BIG_ENDIAN_BYTE_ORDER);
         if (ret) {
@@ -76,20 +76,20 @@ static int __init gef_gpio_probe(struct platform_device *pdev)
         }
 
         /* Setup pointers to chip functions */
-        bgc->gc.label = devm_kstrdup(&pdev->dev, pdev->dev.of_node->full_name,
+        gc->label = devm_kstrdup(&pdev->dev, pdev->dev.of_node->full_name,
                                      GFP_KERNEL);
-        if (!bgc->gc.label) {
+        if (!gc->label) {
                 ret = -ENOMEM;
                 goto err0;
         }
 
-        bgc->gc.base = -1;
-        bgc->gc.ngpio = (u16)(uintptr_t)of_id->data;
-        bgc->gc.of_gpio_n_cells = 2;
-        bgc->gc.of_node = pdev->dev.of_node;
+        gc->base = -1;
+        gc->ngpio = (u16)(uintptr_t)of_id->data;
+        gc->of_gpio_n_cells = 2;
+        gc->of_node = pdev->dev.of_node;
 
         /* This function adds a memory mapped GPIO chip */
-        ret = gpiochip_add(&bgc->gc);
+        ret = gpiochip_add_data(gc, NULL);
         if (ret)
                 goto err0;
 
diff --git a/drivers/gpio/gpio-generic.c b/drivers/gpio/gpio-generic.c
index 88ae70ddb127..2a4f2333a50b 100644
--- a/drivers/gpio/gpio-generic.c
+++ b/drivers/gpio/gpio-generic.c
@@ -56,11 +56,11 @@ o        `                     ~~~~\___/~~~~    ` controller in FPGA is ,.`
 #include <linux/log2.h>
 #include <linux/ioport.h>
 #include <linux/io.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/slab.h>
+#include <linux/bitops.h>
 #include <linux/platform_device.h>
 #include <linux/mod_devicetable.h>
-#include <linux/basic_mmio_gpio.h>
 
 static void bgpio_write8(void __iomem *reg, unsigned long data)
 {
@@ -124,33 +124,30 @@ static unsigned long bgpio_read32be(void __iomem *reg)
         return ioread32be(reg);
 }
 
-static unsigned long bgpio_pin2mask(struct bgpio_chip *bgc, unsigned int pin)
+static unsigned long bgpio_pin2mask(struct gpio_chip *gc, unsigned int pin)
 {
-        return 1 << pin;
+        return BIT(pin);
 }
 
-static unsigned long bgpio_pin2mask_be(struct bgpio_chip *bgc,
+static unsigned long bgpio_pin2mask_be(struct gpio_chip *gc,
                                        unsigned int pin)
 {
-        return 1 << (bgc->bits - 1 - pin);
+        return BIT(gc->bgpio_bits - 1 - pin);
 }
 
 static int bgpio_get_set(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        unsigned long pinmask = bgc->pin2mask(bgc, gpio);
+        unsigned long pinmask = gc->pin2mask(gc, gpio);
 
-        if (bgc->dir & pinmask)
-                return !!(bgc->read_reg(bgc->reg_set) & pinmask);
+        if (gc->bgpio_dir & pinmask)
+                return !!(gc->read_reg(gc->reg_set) & pinmask);
         else
-                return !!(bgc->read_reg(bgc->reg_dat) & pinmask);
+                return !!(gc->read_reg(gc->reg_dat) & pinmask);
 }
 
 static int bgpio_get(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        return !!(bgc->read_reg(bgc->reg_dat) & bgc->pin2mask(bgc, gpio));
+        return !!(gc->read_reg(gc->reg_dat) & gc->pin2mask(gc, gpio));
 }
 
 static void bgpio_set_none(struct gpio_chip *gc, unsigned int gpio, int val)
@@ -159,53 +156,50 @@ static void bgpio_set_none(struct gpio_chip *gc, unsigned int gpio, int val)
 
 static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        unsigned long mask = bgc->pin2mask(bgc, gpio);
+        unsigned long mask = gc->pin2mask(gc, gpio);
         unsigned long flags;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
         if (val)
-                bgc->data |= mask;
+                gc->bgpio_data |= mask;
         else
-                bgc->data &= ~mask;
+                gc->bgpio_data &= ~mask;
 
-        bgc->write_reg(bgc->reg_dat, bgc->data);
+        gc->write_reg(gc->reg_dat, gc->bgpio_data);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 }
 
 static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio,
                                  int val)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        unsigned long mask = bgc->pin2mask(bgc, gpio);
+        unsigned long mask = gc->pin2mask(gc, gpio);
 
         if (val)
-                bgc->write_reg(bgc->reg_set, mask);
+                gc->write_reg(gc->reg_set, mask);
         else
-                bgc->write_reg(bgc->reg_clr, mask);
+                gc->write_reg(gc->reg_clr, mask);
 }
 
 static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        unsigned long mask = bgc->pin2mask(bgc, gpio);
+        unsigned long mask = gc->pin2mask(gc, gpio);
         unsigned long flags;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
         if (val)
-                bgc->data |= mask;
+                gc->bgpio_data |= mask;
         else
-                bgc->data &= ~mask;
+                gc->bgpio_data &= ~mask;
 
-        bgc->write_reg(bgc->reg_set, bgc->data);
+        gc->write_reg(gc->reg_set, gc->bgpio_data);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 }
 
-static void bgpio_multiple_get_masks(struct bgpio_chip *bgc,
+static void bgpio_multiple_get_masks(struct gpio_chip *gc,
                                      unsigned long *mask, unsigned long *bits,
                                      unsigned long *set_mask,
                                      unsigned long *clear_mask)
@@ -215,19 +209,19 @@ static void bgpio_multiple_get_masks(struct bgpio_chip *bgc,
         *set_mask = 0;
         *clear_mask = 0;
 
-        for (i = 0; i < bgc->bits; i++) {
+        for (i = 0; i < gc->bgpio_bits; i++) {
                 if (*mask == 0)
                         break;
                 if (__test_and_clear_bit(i, mask)) {
                         if (test_bit(i, bits))
-                                *set_mask |= bgc->pin2mask(bgc, i);
+                                *set_mask |= gc->pin2mask(gc, i);
                         else
-                                *clear_mask |= bgc->pin2mask(bgc, i);
+                                *clear_mask |= gc->pin2mask(gc, i);
                 }
         }
 }
 
-static void bgpio_set_multiple_single_reg(struct bgpio_chip *bgc,
+static void bgpio_set_multiple_single_reg(struct gpio_chip *gc,
                                           unsigned long *mask,
                                           unsigned long *bits,
                                           void __iomem *reg)
@@ -235,47 +229,42 @@ static void bgpio_set_multiple_single_reg(struct bgpio_chip *bgc,
         unsigned long flags;
         unsigned long set_mask, clear_mask;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
-        bgpio_multiple_get_masks(bgc, mask, bits, &set_mask, &clear_mask);
+        bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
 
-        bgc->data |= set_mask;
-        bgc->data &= ~clear_mask;
+        gc->bgpio_data |= set_mask;
+        gc->bgpio_data &= ~clear_mask;
 
-        bgc->write_reg(reg, bgc->data);
+        gc->write_reg(reg, gc->bgpio_data);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 }
 
 static void bgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
                                unsigned long *bits)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        bgpio_set_multiple_single_reg(bgc, mask, bits, bgc->reg_dat);
+        bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_dat);
 }
 
 static void bgpio_set_multiple_set(struct gpio_chip *gc, unsigned long *mask,
                                    unsigned long *bits)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        bgpio_set_multiple_single_reg(bgc, mask, bits, bgc->reg_set);
+        bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_set);
 }
 
 static void bgpio_set_multiple_with_clear(struct gpio_chip *gc,
                                           unsigned long *mask,
                                           unsigned long *bits)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
         unsigned long set_mask, clear_mask;
 
-        bgpio_multiple_get_masks(bgc, mask, bits, &set_mask, &clear_mask);
+        bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
 
         if (set_mask)
-                bgc->write_reg(bgc->reg_set, set_mask);
+                gc->write_reg(gc->reg_set, set_mask);
         if (clear_mask)
-                bgc->write_reg(bgc->reg_clr, clear_mask);
+                gc->write_reg(gc->reg_clr, clear_mask);
 }
 
 static int bgpio_simple_dir_in(struct gpio_chip *gc, unsigned int gpio)
@@ -299,111 +288,103 @@ static int bgpio_simple_dir_out(struct gpio_chip *gc, unsigned int gpio,
 
 static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
         unsigned long flags;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
-        bgc->dir &= ~bgc->pin2mask(bgc, gpio);
-        bgc->write_reg(bgc->reg_dir, bgc->dir);
+        gc->bgpio_dir &= ~gc->pin2mask(gc, gpio);
+        gc->write_reg(gc->reg_dir, gc->bgpio_dir);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
 
 static int bgpio_get_dir(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        return (bgc->read_reg(bgc->reg_dir) & bgc->pin2mask(bgc, gpio)) ?
-               GPIOF_DIR_OUT : GPIOF_DIR_IN;
+        /* Return 0 if output, 1 of input */
+        return !(gc->read_reg(gc->reg_dir) & gc->pin2mask(gc, gpio));
 }
 
 static int bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
         unsigned long flags;
 
         gc->set(gc, gpio, val);
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
-        bgc->dir |= bgc->pin2mask(bgc, gpio);
-        bgc->write_reg(bgc->reg_dir, bgc->dir);
+        gc->bgpio_dir |= gc->pin2mask(gc, gpio);
+        gc->write_reg(gc->reg_dir, gc->bgpio_dir);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
 
 static int bgpio_dir_in_inv(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
         unsigned long flags;
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
-        bgc->dir |= bgc->pin2mask(bgc, gpio);
-        bgc->write_reg(bgc->reg_dir, bgc->dir);
+        gc->bgpio_dir |= gc->pin2mask(gc, gpio);
+        gc->write_reg(gc->reg_dir, gc->bgpio_dir);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
 
 static int bgpio_dir_out_inv(struct gpio_chip *gc, unsigned int gpio, int val)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
         unsigned long flags;
 
         gc->set(gc, gpio, val);
 
-        spin_lock_irqsave(&bgc->lock, flags);
+        spin_lock_irqsave(&gc->bgpio_lock, flags);
 
-        bgc->dir &= ~bgc->pin2mask(bgc, gpio);
-        bgc->write_reg(bgc->reg_dir, bgc->dir);
+        gc->bgpio_dir &= ~gc->pin2mask(gc, gpio);
+        gc->write_reg(gc->reg_dir, gc->bgpio_dir);
 
-        spin_unlock_irqrestore(&bgc->lock, flags);
+        spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 
         return 0;
 }
 
 static int bgpio_get_dir_inv(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        return (bgc->read_reg(bgc->reg_dir) & bgc->pin2mask(bgc, gpio)) ?
-               GPIOF_DIR_IN : GPIOF_DIR_OUT;
+        /* Return 0 if output, 1 if input */
+        return !!(gc->read_reg(gc->reg_dir) & gc->pin2mask(gc, gpio));
 }
 
 static int bgpio_setup_accessors(struct device *dev,
-                                 struct bgpio_chip *bgc,
+                                 struct gpio_chip *gc,
                                  bool bit_be,
                                  bool byte_be)
 {
 
-        switch (bgc->bits) {
+        switch (gc->bgpio_bits) {
         case 8:
-                bgc->read_reg   = bgpio_read8;
-                bgc->write_reg  = bgpio_write8;
+                gc->read_reg    = bgpio_read8;
+                gc->write_reg   = bgpio_write8;
                 break;
         case 16:
                 if (byte_be) {
-                        bgc->read_reg   = bgpio_read16be;
-                        bgc->write_reg  = bgpio_write16be;
+                        gc->read_reg    = bgpio_read16be;
+                        gc->write_reg   = bgpio_write16be;
                 } else {
-                        bgc->read_reg   = bgpio_read16;
-                        bgc->write_reg  = bgpio_write16;
+                        gc->read_reg    = bgpio_read16;
+                        gc->write_reg   = bgpio_write16;
                 }
                 break;
         case 32:
                 if (byte_be) {
-                        bgc->read_reg   = bgpio_read32be;
-                        bgc->write_reg  = bgpio_write32be;
+                        gc->read_reg    = bgpio_read32be;
+                        gc->write_reg   = bgpio_write32be;
                 } else {
-                        bgc->read_reg   = bgpio_read32;
-                        bgc->write_reg  = bgpio_write32;
+                        gc->read_reg    = bgpio_read32;
+                        gc->write_reg   = bgpio_write32;
                 }
                 break;
 #if BITS_PER_LONG >= 64
@@ -413,17 +394,17 @@ static int bgpio_setup_accessors(struct device *dev,
                                 "64 bit big endian byte order unsupported\n");
                         return -EINVAL;
                 } else {
-                        bgc->read_reg   = bgpio_read64;
-                        bgc->write_reg  = bgpio_write64;
+                        gc->read_reg    = bgpio_read64;
+                        gc->write_reg   = bgpio_write64;
                 }
                 break;
 #endif /* BITS_PER_LONG >= 64 */
         default:
-                dev_err(dev, "unsupported data width %u bits\n", bgc->bits);
+                dev_err(dev, "unsupported data width %u bits\n", gc->bgpio_bits);
                 return -EINVAL;
         }
 
-        bgc->pin2mask = bit_be ? bgpio_pin2mask_be : bgpio_pin2mask;
+        gc->pin2mask = bit_be ? bgpio_pin2mask_be : bgpio_pin2mask;
 
         return 0;
 }
@@ -450,44 +431,44 @@ static int bgpio_setup_accessors(struct device *dev,
  *      - an input direction register (named "dirin") where a 1 bit indicates
  *      the GPIO is an input.
  */
-static int bgpio_setup_io(struct bgpio_chip *bgc,
+static int bgpio_setup_io(struct gpio_chip *gc,
                           void __iomem *dat,
                           void __iomem *set,
                           void __iomem *clr,
                           unsigned long flags)
 {
 
-        bgc->reg_dat = dat;
-        if (!bgc->reg_dat)
+        gc->reg_dat = dat;
+        if (!gc->reg_dat)
                 return -EINVAL;
 
         if (set && clr) {
-                bgc->reg_set = set;
-                bgc->reg_clr = clr;
-                bgc->gc.set = bgpio_set_with_clear;
-                bgc->gc.set_multiple = bgpio_set_multiple_with_clear;
+                gc->reg_set = set;
+                gc->reg_clr = clr;
+                gc->set = bgpio_set_with_clear;
+                gc->set_multiple = bgpio_set_multiple_with_clear;
         } else if (set && !clr) {
-                bgc->reg_set = set;
-                bgc->gc.set = bgpio_set_set;
-                bgc->gc.set_multiple = bgpio_set_multiple_set;
+                gc->reg_set = set;
+                gc->set = bgpio_set_set;
+                gc->set_multiple = bgpio_set_multiple_set;
         } else if (flags & BGPIOF_NO_OUTPUT) {
-                bgc->gc.set = bgpio_set_none;
-                bgc->gc.set_multiple = NULL;
+                gc->set = bgpio_set_none;
+                gc->set_multiple = NULL;
         } else {
-                bgc->gc.set = bgpio_set;
-                bgc->gc.set_multiple = bgpio_set_multiple;
+                gc->set = bgpio_set;
+                gc->set_multiple = bgpio_set_multiple;
         }
 
         if (!(flags & BGPIOF_UNREADABLE_REG_SET) &&
             (flags & BGPIOF_READ_OUTPUT_REG_SET))
-                bgc->gc.get = bgpio_get_set;
+                gc->get = bgpio_get_set;
         else
-                bgc->gc.get = bgpio_get;
+                gc->get = bgpio_get;
 
         return 0;
 }
 
-static int bgpio_setup_direction(struct bgpio_chip *bgc,
+static int bgpio_setup_direction(struct gpio_chip *gc,
                                  void __iomem *dirout,
                                  void __iomem *dirin,
                                  unsigned long flags)
@@ -495,21 +476,21 @@ static int bgpio_setup_direction(struct bgpio_chip *bgc,
         if (dirout && dirin) {
                 return -EINVAL;
         } else if (dirout) {
-                bgc->reg_dir = dirout;
-                bgc->gc.direction_output = bgpio_dir_out;
-                bgc->gc.direction_input = bgpio_dir_in;
-                bgc->gc.get_direction = bgpio_get_dir;
+                gc->reg_dir = dirout;
+                gc->direction_output = bgpio_dir_out;
+                gc->direction_input = bgpio_dir_in;
+                gc->get_direction = bgpio_get_dir;
         } else if (dirin) {
-                bgc->reg_dir = dirin;
-                bgc->gc.direction_output = bgpio_dir_out_inv;
-                bgc->gc.direction_input = bgpio_dir_in_inv;
-                bgc->gc.get_direction = bgpio_get_dir_inv;
+                gc->reg_dir = dirin;
+                gc->direction_output = bgpio_dir_out_inv;
+                gc->direction_input = bgpio_dir_in_inv;
+                gc->get_direction = bgpio_get_dir_inv;
         } else {
                 if (flags & BGPIOF_NO_OUTPUT)
-                        bgc->gc.direction_output = bgpio_dir_out_err;
+                        gc->direction_output = bgpio_dir_out_err;
                 else
-                        bgc->gc.direction_output = bgpio_simple_dir_out;
-                bgc->gc.direction_input = bgpio_simple_dir_in;
+                        gc->direction_output = bgpio_simple_dir_out;
+                gc->direction_input = bgpio_simple_dir_in;
         }
 
         return 0;
@@ -523,14 +504,7 @@ static int bgpio_request(struct gpio_chip *chip, unsigned gpio_pin)
         return -EINVAL;
 }
 
-int bgpio_remove(struct bgpio_chip *bgc)
-{
-        gpiochip_remove(&bgc->gc);
-        return 0;
-}
-EXPORT_SYMBOL_GPL(bgpio_remove);
-
-int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
+int bgpio_init(struct gpio_chip *gc, struct device *dev,
                unsigned long sz, void __iomem *dat, void __iomem *set,
                void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
                unsigned long flags)
@@ -540,36 +514,36 @@ int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
         if (!is_power_of_2(sz))
                 return -EINVAL;
 
-        bgc->bits = sz * 8;
-        if (bgc->bits > BITS_PER_LONG)
+        gc->bgpio_bits = sz * 8;
+        if (gc->bgpio_bits > BITS_PER_LONG)
                 return -EINVAL;
 
-        spin_lock_init(&bgc->lock);
-        bgc->gc.dev = dev;
-        bgc->gc.label = dev_name(dev);
-        bgc->gc.base = -1;
-        bgc->gc.ngpio = bgc->bits;
-        bgc->gc.request = bgpio_request;
+        spin_lock_init(&gc->bgpio_lock);
+        gc->parent = dev;
+        gc->label = dev_name(dev);
+        gc->base = -1;
+        gc->ngpio = gc->bgpio_bits;
+        gc->request = bgpio_request;
 
-        ret = bgpio_setup_io(bgc, dat, set, clr, flags);
+        ret = bgpio_setup_io(gc, dat, set, clr, flags);
         if (ret)
                 return ret;
 
-        ret = bgpio_setup_accessors(dev, bgc, flags & BGPIOF_BIG_ENDIAN,
+        ret = bgpio_setup_accessors(dev, gc, flags & BGPIOF_BIG_ENDIAN,
                                     flags & BGPIOF_BIG_ENDIAN_BYTE_ORDER);
         if (ret)
                 return ret;
 
-        ret = bgpio_setup_direction(bgc, dirout, dirin, flags);
+        ret = bgpio_setup_direction(gc, dirout, dirin, flags);
         if (ret)
                 return ret;
 
-        bgc->data = bgc->read_reg(bgc->reg_dat);
-        if (bgc->gc.set == bgpio_set_set &&
+        gc->bgpio_data = gc->read_reg(gc->reg_dat);
+        if (gc->set == bgpio_set_set &&
                         !(flags & BGPIOF_UNREADABLE_REG_SET))
-                bgc->data = bgc->read_reg(bgc->reg_set);
-        if (bgc->reg_dir && !(flags & BGPIOF_UNREADABLE_REG_DIR))
-                bgc->dir = bgc->read_reg(bgc->reg_dir);
+                gc->bgpio_data = gc->read_reg(gc->reg_set);
+        if (gc->reg_dir && !(flags & BGPIOF_UNREADABLE_REG_DIR))
+                gc->bgpio_dir = gc->read_reg(gc->reg_dir);
 
         return ret;
 }
@@ -607,7 +581,7 @@ static int bgpio_pdev_probe(struct platform_device *pdev)
         unsigned long sz;
         unsigned long flags = pdev->id_entry->driver_data;
         int err;
-        struct bgpio_chip *bgc;
+        struct gpio_chip *gc;
         struct bgpio_pdata *pdata = dev_get_platdata(dev);
 
         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
@@ -636,32 +610,33 @@ static int bgpio_pdev_probe(struct platform_device *pdev)
         if (IS_ERR(dirin))
                 return PTR_ERR(dirin);
 
-        bgc = devm_kzalloc(&pdev->dev, sizeof(*bgc), GFP_KERNEL);
-        if (!bgc)
+        gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
+        if (!gc)
                 return -ENOMEM;
 
-        err = bgpio_init(bgc, dev, sz, dat, set, clr, dirout, dirin, flags);
+        err = bgpio_init(gc, dev, sz, dat, set, clr, dirout, dirin, flags);
         if (err)
                 return err;
 
         if (pdata) {
                 if (pdata->label)
-                        bgc->gc.label = pdata->label;
-                bgc->gc.base = pdata->base;
+                        gc->label = pdata->label;
+                gc->base = pdata->base;
                 if (pdata->ngpio > 0)
-                        bgc->gc.ngpio = pdata->ngpio;
+                        gc->ngpio = pdata->ngpio;
         }
 
-        platform_set_drvdata(pdev, bgc);
+        platform_set_drvdata(pdev, gc);
 
-        return gpiochip_add(&bgc->gc);
+        return gpiochip_add_data(gc, NULL);
 }
 
 static int bgpio_pdev_remove(struct platform_device *pdev)
 {
-        struct bgpio_chip *bgc = platform_get_drvdata(pdev);
+        struct gpio_chip *gc = platform_get_drvdata(pdev);
 
-        return bgpio_remove(bgc);
+        gpiochip_remove(gc);
+        return 0;
 }
 
 static const struct platform_device_id bgpio_id_table[] = {
diff --git a/drivers/gpio/gpio-grgpio.c b/drivers/gpio/gpio-grgpio.c
index 801423fe8143..7847dd34f86f 100644
--- a/drivers/gpio/gpio-grgpio.c
+++ b/drivers/gpio/gpio-grgpio.c
@@ -31,7 +31,7 @@
 #include <linux/gpio.h>
 #include <linux/slab.h>
 #include <linux/err.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/irqdomain.h>
@@ -63,7 +63,7 @@ struct grgpio_lirq {
 };
 
 struct grgpio_priv {
-        struct bgpio_chip bgc;
+        struct gpio_chip gc;
         void __iomem *regs;
         struct device *dev;
 
@@ -92,29 +92,22 @@ struct grgpio_priv {
         struct grgpio_lirq lirqs[GRGPIO_MAX_NGPIO];
 };
 
-static inline struct grgpio_priv *grgpio_gc_to_priv(struct gpio_chip *gc)
-{
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        return container_of(bgc, struct grgpio_priv, bgc);
-}
-
 static void grgpio_set_imask(struct grgpio_priv *priv, unsigned int offset,
                              int val)
 {
-        struct bgpio_chip *bgc = &priv->bgc;
-        unsigned long mask = bgc->pin2mask(bgc, offset);
+        struct gpio_chip *gc = &priv->gc;
+        unsigned long mask = gc->pin2mask(gc, offset);
 
         if (val)
                 priv->imask |= mask;
         else
                 priv->imask &= ~mask;
-        bgc->write_reg(priv->regs + GRGPIO_IMASK, priv->imask);
+        gc->write_reg(priv->regs + GRGPIO_IMASK, priv->imask);
 }
 
 static int grgpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct grgpio_priv *priv = grgpio_gc_to_priv(gc);
+        struct grgpio_priv *priv = gpiochip_get_data(gc);
 
         if (offset >= gc->ngpio)
                 return -ENXIO;
@@ -158,15 +151,15 @@ static int grgpio_irq_set_type(struct irq_data *d, unsigned int type)
                 return -EINVAL;
         }
 
-        spin_lock_irqsave(&priv->bgc.lock, flags);
+        spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
 
-        ipol = priv->bgc.read_reg(priv->regs + GRGPIO_IPOL) & ~mask;
-        iedge = priv->bgc.read_reg(priv->regs + GRGPIO_IEDGE) & ~mask;
+        ipol = priv->gc.read_reg(priv->regs + GRGPIO_IPOL) & ~mask;
+        iedge = priv->gc.read_reg(priv->regs + GRGPIO_IEDGE) & ~mask;
 
-        priv->bgc.write_reg(priv->regs + GRGPIO_IPOL, ipol | pol);
-        priv->bgc.write_reg(priv->regs + GRGPIO_IEDGE, iedge | edge);
+        priv->gc.write_reg(priv->regs + GRGPIO_IPOL, ipol | pol);
+        priv->gc.write_reg(priv->regs + GRGPIO_IEDGE, iedge | edge);
 
-        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 
         return 0;
 }
@@ -177,11 +170,11 @@ static void grgpio_irq_mask(struct irq_data *d)
         int offset = d->hwirq;
         unsigned long flags;
 
-        spin_lock_irqsave(&priv->bgc.lock, flags);
+        spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
 
         grgpio_set_imask(priv, offset, 0);
 
-        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 }
 
 static void grgpio_irq_unmask(struct irq_data *d)
@@ -190,11 +183,11 @@ static void grgpio_irq_unmask(struct irq_data *d)
         int offset = d->hwirq;
         unsigned long flags;
 
-        spin_lock_irqsave(&priv->bgc.lock, flags);
+        spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
 
         grgpio_set_imask(priv, offset, 1);
 
-        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 }
 
 static struct irq_chip grgpio_irq_chip = {
@@ -207,12 +200,12 @@ static struct irq_chip grgpio_irq_chip = {
 static irqreturn_t grgpio_irq_handler(int irq, void *dev)
 {
         struct grgpio_priv *priv = dev;
-        int ngpio = priv->bgc.gc.ngpio;
+        int ngpio = priv->gc.ngpio;
         unsigned long flags;
         int i;
         int match = 0;
 
-        spin_lock_irqsave(&priv->bgc.lock, flags);
+        spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
 
         /*
          * For each gpio line, call its interrupt handler if it its underlying
@@ -228,7 +221,7 @@ static irqreturn_t grgpio_irq_handler(int irq, void *dev)
                 }
         }
 
-        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 
         if (!match)
                 dev_warn(priv->dev, "No gpio line matched irq %d\n", irq);
@@ -260,7 +253,7 @@ static int grgpio_irq_map(struct irq_domain *d, unsigned int irq,
         dev_dbg(priv->dev, "Mapping irq %d for gpio line %d\n",
                 irq, offset);
 
-        spin_lock_irqsave(&priv->bgc.lock, flags);
+        spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
 
         /* Request underlying irq if not already requested */
         lirq->irq = irq;
@@ -273,14 +266,14 @@ static int grgpio_irq_map(struct irq_domain *d, unsigned int irq,
                                 "Could not request underlying irq %d\n",
                                 uirq->uirq);
 
-                        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+                        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 
                         return ret;
                 }
         }
         uirq->refcnt++;
 
-        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 
         /* Setup irq  */
         irq_set_chip_data(irq, priv);
@@ -298,13 +291,13 @@ static void grgpio_irq_unmap(struct irq_domain *d, unsigned int irq)
         struct grgpio_lirq *lirq;
         struct grgpio_uirq *uirq;
         unsigned long flags;
-        int ngpio = priv->bgc.gc.ngpio;
+        int ngpio = priv->gc.ngpio;
         int i;
 
         irq_set_chip_and_handler(irq, NULL, NULL);
         irq_set_chip_data(irq, NULL);
 
-        spin_lock_irqsave(&priv->bgc.lock, flags);
+        spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
 
         /* Free underlying irq if last user unmapped */
         index = -1;
@@ -326,7 +319,7 @@ static void grgpio_irq_unmap(struct irq_domain *d, unsigned int irq)
                         free_irq(uirq->uirq, priv);
         }
 
-        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 }
 
 static const struct irq_domain_ops grgpio_irq_domain_ops = {
@@ -341,7 +334,6 @@ static int grgpio_probe(struct platform_device *ofdev)
         struct device_node *np = ofdev->dev.of_node;
         void  __iomem *regs;
         struct gpio_chip *gc;
-        struct bgpio_chip *bgc;
         struct grgpio_priv *priv;
         struct resource *res;
         int err;
@@ -359,8 +351,8 @@ static int grgpio_probe(struct platform_device *ofdev)
         if (IS_ERR(regs))
                 return PTR_ERR(regs);
 
-        bgc = &priv->bgc;
-        err = bgpio_init(bgc, &ofdev->dev, 4, regs + GRGPIO_DATA,
+        gc = &priv->gc;
+        err = bgpio_init(gc, &ofdev->dev, 4, regs + GRGPIO_DATA,
                          regs + GRGPIO_OUTPUT, NULL, regs + GRGPIO_DIR, NULL,
                          BGPIOF_BIG_ENDIAN_BYTE_ORDER);
         if (err) {
@@ -369,10 +361,9 @@ static int grgpio_probe(struct platform_device *ofdev)
         }
 
         priv->regs = regs;
-        priv->imask = bgc->read_reg(regs + GRGPIO_IMASK);
+        priv->imask = gc->read_reg(regs + GRGPIO_IMASK);
         priv->dev = &ofdev->dev;
 
-        gc = &bgc->gc;
         gc->of_node = np;
         gc->owner = THIS_MODULE;
         gc->to_irq = grgpio_to_irq;
@@ -435,7 +426,7 @@ static int grgpio_probe(struct platform_device *ofdev)
 
         platform_set_drvdata(ofdev, priv);
 
-        err = gpiochip_add(gc);
+        err = gpiochip_add_data(gc, priv);
         if (err) {
                 dev_err(&ofdev->dev, "Could not add gpiochip\n");
                 if (priv->domain)
@@ -456,7 +447,7 @@ static int grgpio_remove(struct platform_device *ofdev)
         int i;
         int ret = 0;
 
-        spin_lock_irqsave(&priv->bgc.lock, flags);
+        spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
 
         if (priv->domain) {
                 for (i = 0; i < GRGPIO_MAX_NGPIO; i++) {
@@ -467,13 +458,13 @@ static int grgpio_remove(struct platform_device *ofdev)
                 }
         }
 
-        gpiochip_remove(&priv->bgc.gc);
+        gpiochip_remove(&priv->gc);
 
         if (priv->domain)
                 irq_domain_remove(priv->domain);
 
 out:
-        spin_unlock_irqrestore(&priv->bgc.lock, flags);
+        spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
 
         return ret;
 }
diff --git a/drivers/gpio/gpio-ich.c b/drivers/gpio/gpio-ich.c
index 4ba7ed502131..a4893386abbf 100644
--- a/drivers/gpio/gpio-ich.c
+++ b/drivers/gpio/gpio-ich.c
@@ -282,7 +282,7 @@ static void ichx_gpiolib_setup(struct gpio_chip *chip)
 {
         chip->owner = THIS_MODULE;
         chip->label = DRV_NAME;
-        chip->dev = &ichx_priv.dev->dev;
+        chip->parent = &ichx_priv.dev->dev;
 
         /* Allow chip-specific overrides of request()/get() */
         chip->request = ichx_priv.desc->request ?
@@ -499,7 +499,7 @@ static int ichx_gpio_probe(struct platform_device *pdev)
 
 init:
         ichx_gpiolib_setup(&ichx_priv.chip);
-        err = gpiochip_add(&ichx_priv.chip);
+        err = gpiochip_add_data(&ichx_priv.chip, NULL);
         if (err) {
                 pr_err("Failed to register GPIOs\n");
                 goto add_err;
diff --git a/drivers/gpio/gpio-intel-mid.c b/drivers/gpio/gpio-intel-mid.c
index 70097472b02c..cdaba13cb8e8 100644
--- a/drivers/gpio/gpio-intel-mid.c
+++ b/drivers/gpio/gpio-intel-mid.c
@@ -78,15 +78,10 @@ struct intel_mid_gpio {
         struct pci_dev                  *pdev;
 };
 
-static inline struct intel_mid_gpio *to_intel_gpio_priv(struct gpio_chip *gc)
-{
-        return container_of(gc, struct intel_mid_gpio, chip);
-}
-
 static void __iomem *gpio_reg(struct gpio_chip *chip, unsigned offset,
                               enum GPIO_REG reg_type)
 {
-        struct intel_mid_gpio *priv = to_intel_gpio_priv(chip);
+        struct intel_mid_gpio *priv = gpiochip_get_data(chip);
         unsigned nreg = chip->ngpio / 32;
         u8 reg = offset / 32;
 
@@ -96,7 +91,7 @@ static void __iomem *gpio_reg(struct gpio_chip *chip, unsigned offset,
 static void __iomem *gpio_reg_2bit(struct gpio_chip *chip, unsigned offset,
                                    enum GPIO_REG reg_type)
 {
-        struct intel_mid_gpio *priv = to_intel_gpio_priv(chip);
+        struct intel_mid_gpio *priv = gpiochip_get_data(chip);
         unsigned nreg = chip->ngpio / 32;
         u8 reg = offset / 16;
 
@@ -120,7 +115,7 @@ static int intel_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
         void __iomem *gplr = gpio_reg(chip, offset, GPLR);
 
-        return readl(gplr) & BIT(offset % 32);
+        return !!(readl(gplr) & BIT(offset % 32));
 }
 
 static void intel_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
@@ -138,7 +133,7 @@ static void intel_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int intel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct intel_mid_gpio *priv = to_intel_gpio_priv(chip);
+        struct intel_mid_gpio *priv = gpiochip_get_data(chip);
         void __iomem *gpdr = gpio_reg(chip, offset, GPDR);
         u32 value;
         unsigned long flags;
@@ -161,7 +156,7 @@ static int intel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int intel_gpio_direction_output(struct gpio_chip *chip,
                         unsigned offset, int value)
 {
-        struct intel_mid_gpio *priv = to_intel_gpio_priv(chip);
+        struct intel_mid_gpio *priv = gpiochip_get_data(chip);
         void __iomem *gpdr = gpio_reg(chip, offset, GPDR);
         unsigned long flags;
 
@@ -185,7 +180,7 @@ static int intel_gpio_direction_output(struct gpio_chip *chip,
 static int intel_mid_irq_type(struct irq_data *d, unsigned type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct intel_mid_gpio *priv = to_intel_gpio_priv(gc);
+        struct intel_mid_gpio *priv = gpiochip_get_data(gc);
         u32 gpio = irqd_to_hwirq(d);
         unsigned long flags;
         u32 value;
@@ -304,7 +299,7 @@ MODULE_DEVICE_TABLE(pci, intel_gpio_ids);
 static void intel_mid_irq_handler(struct irq_desc *desc)
 {
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct intel_mid_gpio *priv = to_intel_gpio_priv(gc);
+        struct intel_mid_gpio *priv = gpiochip_get_data(gc);
         struct irq_data *data = irq_desc_get_irq_data(desc);
         struct irq_chip *chip = irq_data_get_irq_chip(data);
         u32 base, gpio, mask;
@@ -392,7 +387,7 @@ static int intel_gpio_probe(struct pci_dev *pdev,
 
         priv->reg_base = pcim_iomap_table(pdev)[0];
         priv->chip.label = dev_name(&pdev->dev);
-        priv->chip.dev = &pdev->dev;
+        priv->chip.parent = &pdev->dev;
         priv->chip.request = intel_gpio_request;
         priv->chip.direction_input = intel_gpio_direction_input;
         priv->chip.direction_output = intel_gpio_direction_output;
@@ -406,7 +401,7 @@ static int intel_gpio_probe(struct pci_dev *pdev,
         spin_lock_init(&priv->lock);
 
         pci_set_drvdata(pdev, priv);
-        retval = gpiochip_add(&priv->chip);
+        retval = gpiochip_add_data(&priv->chip, priv);
         if (retval) {
                 dev_err(&pdev->dev, "gpiochip_add error %d\n", retval);
                 return retval;
diff --git a/drivers/gpio/gpio-iop.c b/drivers/gpio/gpio-iop.c
index 2ed0237a8baf..fb65e5850e0c 100644
--- a/drivers/gpio/gpio-iop.c
+++ b/drivers/gpio/gpio-iop.c
@@ -114,7 +114,7 @@ static int iop3xx_gpio_probe(struct platform_device *pdev)
         if (IS_ERR(base))
                 return PTR_ERR(base);
 
-        return gpiochip_add(&iop3xx_chip);
+        return gpiochip_add_data(&iop3xx_chip, NULL);
 }
 
 static struct platform_driver iop3xx_gpio_driver = {
diff --git a/drivers/gpio/gpio-it87.c b/drivers/gpio/gpio-it87.c
index 21f6f7c0eb34..b219c82414bf 100644
--- a/drivers/gpio/gpio-it87.c
+++ b/drivers/gpio/gpio-it87.c
@@ -77,11 +77,6 @@ static struct it87_gpio it87_gpio_chip = {
         .lock = __SPIN_LOCK_UNLOCKED(it87_gpio_chip.lock),
 };
 
-static inline struct it87_gpio *to_it87_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct it87_gpio, chip);
-}
-
 /* Superio chip access functions; copied from wdt_it87 */
 
 static inline int superio_enter(void)
@@ -165,7 +160,7 @@ static int it87_gpio_request(struct gpio_chip *chip, unsigned gpio_num)
 {
         u8 mask, group;
         int rc = 0;
-        struct it87_gpio *it87_gpio = to_it87_gpio(chip);
+        struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
 
         mask = 1 << (gpio_num % 8);
         group = (gpio_num / 8);
@@ -198,7 +193,7 @@ static int it87_gpio_get(struct gpio_chip *chip, unsigned gpio_num)
 {
         u16 reg;
         u8 mask;
-        struct it87_gpio *it87_gpio = to_it87_gpio(chip);
+        struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
 
         mask = 1 << (gpio_num % 8);
         reg = (gpio_num / 8) + it87_gpio->io_base;
@@ -210,7 +205,7 @@ static int it87_gpio_direction_in(struct gpio_chip *chip, unsigned gpio_num)
 {
         u8 mask, group;
         int rc = 0;
-        struct it87_gpio *it87_gpio = to_it87_gpio(chip);
+        struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
 
         mask = 1 << (gpio_num % 8);
         group = (gpio_num / 8);
@@ -236,7 +231,7 @@ static void it87_gpio_set(struct gpio_chip *chip,
 {
         u8 mask, curr_vals;
         u16 reg;
-        struct it87_gpio *it87_gpio = to_it87_gpio(chip);
+        struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
 
         mask = 1 << (gpio_num % 8);
         reg = (gpio_num / 8) + it87_gpio->io_base;
@@ -253,7 +248,7 @@ static int it87_gpio_direction_out(struct gpio_chip *chip,
 {
         u8 mask, group;
         int rc = 0;
-        struct it87_gpio *it87_gpio = to_it87_gpio(chip);
+        struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
 
         mask = 1 << (gpio_num % 8);
         group = (gpio_num / 8);
@@ -380,7 +375,7 @@ static int __init it87_gpio_init(void)
 
         it87_gpio->chip.names = (const char *const*)labels_table;
 
-        rc = gpiochip_add(&it87_gpio->chip);
+        rc = gpiochip_add_data(&it87_gpio->chip, it87_gpio);
         if (rc)
                 goto labels_free;
 
diff --git a/drivers/gpio/gpio-janz-ttl.c b/drivers/gpio/gpio-janz-ttl.c
index 3a1664335f5e..482aa0353868 100644
--- a/drivers/gpio/gpio-janz-ttl.c
+++ b/drivers/gpio/gpio-janz-ttl.c
@@ -59,7 +59,7 @@ struct ttl_module {
 
 static int ttl_get_value(struct gpio_chip *gpio, unsigned offset)
 {
-        struct ttl_module *mod = dev_get_drvdata(gpio->dev);
+        struct ttl_module *mod = dev_get_drvdata(gpio->parent);
         u8 *shadow;
         int ret;
 
@@ -76,12 +76,12 @@ static int ttl_get_value(struct gpio_chip *gpio, unsigned offset)
         spin_lock(&mod->lock);
         ret = *shadow & (1 << offset);
         spin_unlock(&mod->lock);
-        return ret;
+        return !!ret;
 }
 
 static void ttl_set_value(struct gpio_chip *gpio, unsigned offset, int value)
 {
-        struct ttl_module *mod = dev_get_drvdata(gpio->dev);
+        struct ttl_module *mod = dev_get_drvdata(gpio->parent);
         void __iomem *port;
         u8 *shadow;
 
@@ -172,7 +172,7 @@ static int ttl_probe(struct platform_device *pdev)
 
         /* Initialize the GPIO data structures */
         gpio = &mod->gpio;
-        gpio->dev = &pdev->dev;
+        gpio->parent = &pdev->dev;
         gpio->label = pdev->name;
         gpio->get = ttl_get_value;
         gpio->set = ttl_set_value;
@@ -182,7 +182,7 @@ static int ttl_probe(struct platform_device *pdev)
         gpio->base = -1;
         gpio->ngpio = 20;
 
-        ret = gpiochip_add(gpio);
+        ret = gpiochip_add_data(gpio, NULL);
         if (ret) {
                 dev_err(dev, "unable to add GPIO chip\n");
                 return ret;
diff --git a/drivers/gpio/gpio-kempld.c b/drivers/gpio/gpio-kempld.c
index 83f281dda1e0..01117747b965 100644
--- a/drivers/gpio/gpio-kempld.c
+++ b/drivers/gpio/gpio-kempld.c
@@ -65,17 +65,15 @@ static int kempld_gpio_get_bit(struct kempld_device_data *pld, u8 reg, u8 bit)
 
 static int kempld_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct kempld_gpio_data *gpio
-                = container_of(chip, struct kempld_gpio_data, chip);
+        struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
         struct kempld_device_data *pld = gpio->pld;
 
-        return kempld_gpio_get_bit(pld, KEMPLD_GPIO_LVL_NUM(offset), offset);
+        return !!kempld_gpio_get_bit(pld, KEMPLD_GPIO_LVL_NUM(offset), offset);
 }
 
 static void kempld_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct kempld_gpio_data *gpio
-                = container_of(chip, struct kempld_gpio_data, chip);
+        struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
         struct kempld_device_data *pld = gpio->pld;
 
         kempld_get_mutex(pld);
@@ -85,8 +83,7 @@ static void kempld_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int kempld_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct kempld_gpio_data *gpio
-                = container_of(chip, struct kempld_gpio_data, chip);
+        struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
         struct kempld_device_data *pld = gpio->pld;
 
         kempld_get_mutex(pld);
@@ -99,8 +96,7 @@ static int kempld_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int kempld_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                         int value)
 {
-        struct kempld_gpio_data *gpio
-                = container_of(chip, struct kempld_gpio_data, chip);
+        struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
         struct kempld_device_data *pld = gpio->pld;
 
         kempld_get_mutex(pld);
@@ -113,8 +109,7 @@ static int kempld_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 
 static int kempld_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 {
-        struct kempld_gpio_data *gpio
-                = container_of(chip, struct kempld_gpio_data, chip);
+        struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
         struct kempld_device_data *pld = gpio->pld;
 
         return !kempld_gpio_get_bit(pld, KEMPLD_GPIO_DIR_NUM(offset), offset);
@@ -166,7 +161,7 @@ static int kempld_gpio_probe(struct platform_device *pdev)
         chip = &gpio->chip;
         chip->label = "gpio-kempld";
         chip->owner = THIS_MODULE;
-        chip->dev = dev;
+        chip->parent = dev;
         chip->can_sleep = true;
         if (pdata && pdata->gpio_base)
                 chip->base = pdata->gpio_base;
@@ -183,7 +178,7 @@ static int kempld_gpio_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, gpio);
         if (ret) {
                 dev_err(dev, "Could not register GPIO chip\n");
                 return ret;
diff --git a/drivers/gpio/gpio-ks8695.c b/drivers/gpio/gpio-ks8695.c
index cc09b237e88c..9f86ed9c753b 100644
--- a/drivers/gpio/gpio-ks8695.c
+++ b/drivers/gpio/gpio-ks8695.c
@@ -234,7 +234,7 @@ static struct gpio_chip ks8695_gpio_chip = {
 /* Register the GPIOs */
 void ks8695_register_gpios(void)
 {
-        if (gpiochip_add(&ks8695_gpio_chip))
+        if (gpiochip_add_data(&ks8695_gpio_chip, NULL))
                 printk(KERN_ERR "Unable to register core GPIOs\n");
 }
 
diff --git a/drivers/gpio/gpio-loongson.c b/drivers/gpio/gpio-loongson.c
index ccc65a1aea88..92c4fe7b2677 100644
--- a/drivers/gpio/gpio-loongson.c
+++ b/drivers/gpio/gpio-loongson.c
@@ -110,6 +110,6 @@ static struct gpio_chip loongson_chip = {
 
 static int __init loongson_gpio_setup(void)
 {
-        return gpiochip_add(&loongson_chip);
+        return gpiochip_add_data(&loongson_chip, NULL);
 }
 postcore_initcall(loongson_gpio_setup);
diff --git a/drivers/gpio/gpio-lp3943.c b/drivers/gpio/gpio-lp3943.c
index cfc5b12b43ad..1c8e2ae26938 100644
--- a/drivers/gpio/gpio-lp3943.c
+++ b/drivers/gpio/gpio-lp3943.c
@@ -45,14 +45,9 @@ struct lp3943_gpio {
         u16 input_mask;         /* 1 = GPIO is input direction, 0 = output */
 };
 
-static inline struct lp3943_gpio *to_lp3943_gpio(struct gpio_chip *_chip)
-{
-        return container_of(_chip, struct lp3943_gpio, chip);
-}
-
 static int lp3943_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct lp3943_gpio *lp3943_gpio = to_lp3943_gpio(chip);
+        struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip);
         struct lp3943 *lp3943 = lp3943_gpio->lp3943;
 
         /* Return an error if the pin is already assigned */
@@ -64,7 +59,7 @@ static int lp3943_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void lp3943_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct lp3943_gpio *lp3943_gpio = to_lp3943_gpio(chip);
+        struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip);
         struct lp3943 *lp3943 = lp3943_gpio->lp3943;
 
         clear_bit(offset, &lp3943->pin_used);
@@ -82,7 +77,7 @@ static int lp3943_gpio_set_mode(struct lp3943_gpio *lp3943_gpio, u8 offset,
 
 static int lp3943_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct lp3943_gpio *lp3943_gpio = to_lp3943_gpio(chip);
+        struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip);
 
         lp3943_gpio->input_mask |= BIT(offset);
 
@@ -138,7 +133,7 @@ static int lp3943_get_gpio_out_status(struct lp3943_gpio *lp3943_gpio,
 
 static int lp3943_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct lp3943_gpio *lp3943_gpio = to_lp3943_gpio(chip);
+        struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip);
 
         /*
          * Limitation:
@@ -157,7 +152,7 @@ static int lp3943_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void lp3943_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct lp3943_gpio *lp3943_gpio = to_lp3943_gpio(chip);
+        struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip);
         u8 data;
 
         if (value)
@@ -171,7 +166,7 @@ static void lp3943_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 static int lp3943_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                         int value)
 {
-        struct lp3943_gpio *lp3943_gpio = to_lp3943_gpio(chip);
+        struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip);
 
         lp3943_gpio_set(chip, offset, value);
         lp3943_gpio->input_mask &= ~BIT(offset);
@@ -205,11 +200,11 @@ static int lp3943_gpio_probe(struct platform_device *pdev)
 
         lp3943_gpio->lp3943 = lp3943;
         lp3943_gpio->chip = lp3943_gpio_chip;
-        lp3943_gpio->chip.dev = &pdev->dev;
+        lp3943_gpio->chip.parent = &pdev->dev;
 
         platform_set_drvdata(pdev, lp3943_gpio);
 
-        return gpiochip_add(&lp3943_gpio->chip);
+        return gpiochip_add_data(&lp3943_gpio->chip, lp3943_gpio);
 }
 
 static int lp3943_gpio_remove(struct platform_device *pdev)
diff --git a/drivers/gpio/gpio-lpc18xx.c b/drivers/gpio/gpio-lpc18xx.c
index e39dcb0af8ae..98832c9f614a 100644
--- a/drivers/gpio/gpio-lpc18xx.c
+++ b/drivers/gpio/gpio-lpc18xx.c
@@ -31,27 +31,22 @@ struct lpc18xx_gpio_chip {
         spinlock_t lock;
 };
 
-static inline struct lpc18xx_gpio_chip *to_lpc18xx_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct lpc18xx_gpio_chip, gpio);
-}
-
 static void lpc18xx_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct lpc18xx_gpio_chip *gc = to_lpc18xx_gpio(chip);
+        struct lpc18xx_gpio_chip *gc = gpiochip_get_data(chip);
         writeb(value ? 1 : 0, gc->base + offset);
 }
 
 static int lpc18xx_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct lpc18xx_gpio_chip *gc = to_lpc18xx_gpio(chip);
+        struct lpc18xx_gpio_chip *gc = gpiochip_get_data(chip);
         return !!readb(gc->base + offset);
 }
 
 static int lpc18xx_gpio_direction(struct gpio_chip *chip, unsigned offset,
                                   bool out)
 {
-        struct lpc18xx_gpio_chip *gc = to_lpc18xx_gpio(chip);
+        struct lpc18xx_gpio_chip *gc = gpiochip_get_data(chip);
         unsigned long flags;
         u32 port, pin, dir;
 
@@ -127,9 +122,9 @@ static int lpc18xx_gpio_probe(struct platform_device *pdev)
 
         spin_lock_init(&gc->lock);
 
-        gc->gpio.dev = &pdev->dev;
+        gc->gpio.parent = &pdev->dev;
 
-        ret = gpiochip_add(&gc->gpio);
+        ret = gpiochip_add_data(&gc->gpio, gc);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add gpio chip\n");
                 clk_disable_unprepare(gc->clk);
diff --git a/drivers/gpio/gpio-lpc32xx.c b/drivers/gpio/gpio-lpc32xx.c
index 47e2dde63734..4cecf4ce96c1 100644
--- a/drivers/gpio/gpio-lpc32xx.c
+++ b/drivers/gpio/gpio-lpc32xx.c
@@ -165,12 +165,6 @@ struct lpc32xx_gpio_chip {
         struct gpio_regs        *gpio_grp;
 };
 
-static inline struct lpc32xx_gpio_chip *to_lpc32xx_gpio(
-        struct gpio_chip *gpc)
-{
-        return container_of(gpc, struct lpc32xx_gpio_chip, chip);
-}
-
 static void __set_gpio_dir_p012(struct lpc32xx_gpio_chip *group,
         unsigned pin, int input)
 {
@@ -261,7 +255,7 @@ static int __get_gpo_state_p3(struct lpc32xx_gpio_chip *group,
 static int lpc32xx_gpio_dir_input_p012(struct gpio_chip *chip,
         unsigned pin)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpio_dir_p012(group, pin, 1);
 
@@ -271,7 +265,7 @@ static int lpc32xx_gpio_dir_input_p012(struct gpio_chip *chip,
 static int lpc32xx_gpio_dir_input_p3(struct gpio_chip *chip,
         unsigned pin)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpio_dir_p3(group, pin, 1);
 
@@ -286,29 +280,29 @@ static int lpc32xx_gpio_dir_in_always(struct gpio_chip *chip,
 
 static int lpc32xx_gpio_get_value_p012(struct gpio_chip *chip, unsigned pin)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
-        return __get_gpio_state_p012(group, pin);
+        return !!__get_gpio_state_p012(group, pin);
 }
 
 static int lpc32xx_gpio_get_value_p3(struct gpio_chip *chip, unsigned pin)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
-        return __get_gpio_state_p3(group, pin);
+        return !!__get_gpio_state_p3(group, pin);
 }
 
 static int lpc32xx_gpi_get_value(struct gpio_chip *chip, unsigned pin)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
-        return __get_gpi_state_p3(group, pin);
+        return !!__get_gpi_state_p3(group, pin);
 }
 
 static int lpc32xx_gpio_dir_output_p012(struct gpio_chip *chip, unsigned pin,
         int value)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpio_level_p012(group, pin, value);
         __set_gpio_dir_p012(group, pin, 0);
@@ -319,7 +313,7 @@ static int lpc32xx_gpio_dir_output_p012(struct gpio_chip *chip, unsigned pin,
 static int lpc32xx_gpio_dir_output_p3(struct gpio_chip *chip, unsigned pin,
         int value)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpio_level_p3(group, pin, value);
         __set_gpio_dir_p3(group, pin, 0);
@@ -330,7 +324,7 @@ static int lpc32xx_gpio_dir_output_p3(struct gpio_chip *chip, unsigned pin,
 static int lpc32xx_gpio_dir_out_always(struct gpio_chip *chip, unsigned pin,
         int value)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpo_level_p3(group, pin, value);
         return 0;
@@ -339,7 +333,7 @@ static int lpc32xx_gpio_dir_out_always(struct gpio_chip *chip, unsigned pin,
 static void lpc32xx_gpio_set_value_p012(struct gpio_chip *chip, unsigned pin,
         int value)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpio_level_p012(group, pin, value);
 }
@@ -347,7 +341,7 @@ static void lpc32xx_gpio_set_value_p012(struct gpio_chip *chip, unsigned pin,
 static void lpc32xx_gpio_set_value_p3(struct gpio_chip *chip, unsigned pin,
         int value)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpio_level_p3(group, pin, value);
 }
@@ -355,16 +349,16 @@ static void lpc32xx_gpio_set_value_p3(struct gpio_chip *chip, unsigned pin,
 static void lpc32xx_gpo_set_value(struct gpio_chip *chip, unsigned pin,
         int value)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
         __set_gpo_level_p3(group, pin, value);
 }
 
 static int lpc32xx_gpo_get_value(struct gpio_chip *chip, unsigned pin)
 {
-        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+        struct lpc32xx_gpio_chip *group = gpiochip_get_data(chip);
 
-        return __get_gpo_state_p3(group, pin);
+        return !!__get_gpo_state_p3(group, pin);
 }
 
 static int lpc32xx_gpio_request(struct gpio_chip *chip, unsigned pin)
@@ -553,7 +547,8 @@ static int lpc32xx_gpio_probe(struct platform_device *pdev)
                         lpc32xx_gpiochip[i].chip.of_gpio_n_cells = 3;
                         lpc32xx_gpiochip[i].chip.of_node = pdev->dev.of_node;
                 }
-                gpiochip_add(&lpc32xx_gpiochip[i].chip);
+                gpiochip_add_data(&lpc32xx_gpiochip[i].chip,
+                                  &lpc32xx_gpiochip[i]);
         }
 
         return 0;
diff --git a/drivers/gpio/gpio-lynxpoint.c b/drivers/gpio/gpio-lynxpoint.c
index 127c37b380ae..13107772be4f 100644
--- a/drivers/gpio/gpio-lynxpoint.c
+++ b/drivers/gpio/gpio-lynxpoint.c
@@ -97,7 +97,7 @@ struct lp_gpio {
 static unsigned long lp_gpio_reg(struct gpio_chip *chip, unsigned offset,
                                  int reg)
 {
-        struct lp_gpio *lg = container_of(chip, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(chip);
         int reg_offset;
 
         if (reg == LP_CONFIG1 || reg == LP_CONFIG2)
@@ -112,7 +112,7 @@ static unsigned long lp_gpio_reg(struct gpio_chip *chip, unsigned offset,
 
 static int lp_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct lp_gpio *lg = container_of(chip, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(chip);
         unsigned long reg = lp_gpio_reg(chip, offset, LP_CONFIG1);
         unsigned long conf2 = lp_gpio_reg(chip, offset, LP_CONFIG2);
         unsigned long acpi_use = lp_gpio_reg(chip, offset, LP_ACPI_OWNED);
@@ -137,7 +137,7 @@ static int lp_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void lp_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct lp_gpio *lg = container_of(chip, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(chip);
         unsigned long conf2 = lp_gpio_reg(chip, offset, LP_CONFIG2);
 
         /* disable input sensing */
@@ -149,7 +149,7 @@ static void lp_gpio_free(struct gpio_chip *chip, unsigned offset)
 static int lp_irq_type(struct irq_data *d, unsigned type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct lp_gpio *lg = container_of(gc, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(gc);
         u32 hwirq = irqd_to_hwirq(d);
         unsigned long flags;
         u32 value;
@@ -191,7 +191,7 @@ static int lp_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void lp_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct lp_gpio *lg = container_of(chip, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(chip);
         unsigned long reg = lp_gpio_reg(chip, offset, LP_CONFIG1);
         unsigned long flags;
 
@@ -207,7 +207,7 @@ static void lp_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int lp_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct lp_gpio *lg = container_of(chip, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(chip);
         unsigned long reg = lp_gpio_reg(chip, offset, LP_CONFIG1);
         unsigned long flags;
 
@@ -221,7 +221,7 @@ static int lp_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int lp_gpio_direction_output(struct gpio_chip *chip,
                                       unsigned offset, int value)
 {
-        struct lp_gpio *lg = container_of(chip, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(chip);
         unsigned long reg = lp_gpio_reg(chip, offset, LP_CONFIG1);
         unsigned long flags;
 
@@ -238,7 +238,7 @@ static void lp_gpio_irq_handler(struct irq_desc *desc)
 {
         struct irq_data *data = irq_desc_get_irq_data(desc);
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct lp_gpio *lg = container_of(gc, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(gc);
         struct irq_chip *chip = irq_data_get_irq_chip(data);
         u32 base, pin, mask;
         unsigned long reg, ena, pending;
@@ -273,7 +273,7 @@ static void lp_irq_mask(struct irq_data *d)
 static void lp_irq_enable(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct lp_gpio *lg = container_of(gc, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(gc);
         u32 hwirq = irqd_to_hwirq(d);
         unsigned long reg = lp_gpio_reg(&lg->chip, hwirq, LP_INT_ENABLE);
         unsigned long flags;
@@ -286,7 +286,7 @@ static void lp_irq_enable(struct irq_data *d)
 static void lp_irq_disable(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct lp_gpio *lg = container_of(gc, struct lp_gpio, chip);
+        struct lp_gpio *lg = gpiochip_get_data(gc);
         u32 hwirq = irqd_to_hwirq(d);
         unsigned long reg = lp_gpio_reg(&lg->chip, hwirq, LP_INT_ENABLE);
         unsigned long flags;
@@ -368,9 +368,9 @@ static int lp_gpio_probe(struct platform_device *pdev)
         gc->base = -1;
         gc->ngpio = LP_NUM_GPIO;
         gc->can_sleep = false;
-        gc->dev = dev;
+        gc->parent = dev;
 
-        ret = gpiochip_add(gc);
+        ret = gpiochip_add_data(gc, lg);
         if (ret) {
                 dev_err(dev, "failed adding lp-gpio chip\n");
                 return ret;
diff --git a/drivers/gpio/gpio-max7300.c b/drivers/gpio/gpio-max7300.c
index 0cc2c279ab5c..1ae9ba851c9a 100644
--- a/drivers/gpio/gpio-max7300.c
+++ b/drivers/gpio/gpio-max7300.c
@@ -65,7 +65,6 @@ MODULE_DEVICE_TABLE(i2c, max7300_id);
 static struct i2c_driver max7300_driver = {
         .driver = {
                 .name = "max7300",
-                .owner = THIS_MODULE,
         },
         .probe = max7300_probe,
         .remove = max7300_remove,
diff --git a/drivers/gpio/gpio-max730x.c b/drivers/gpio/gpio-max730x.c
index 0f57d2d248ec..08807368f007 100644
--- a/drivers/gpio/gpio-max730x.c
+++ b/drivers/gpio/gpio-max730x.c
@@ -50,7 +50,7 @@
 
 static int max7301_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        struct max7301 *ts = gpiochip_get_data(chip);
         u8 *config;
         u8 offset_bits, pin_config;
         int ret;
@@ -92,7 +92,7 @@ static int __max7301_set(struct max7301 *ts, unsigned offset, int value)
 static int max7301_direction_output(struct gpio_chip *chip, unsigned offset,
                                     int value)
 {
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        struct max7301 *ts = gpiochip_get_data(chip);
         u8 *config;
         u8 offset_bits;
         int ret;
@@ -120,7 +120,7 @@ static int max7301_direction_output(struct gpio_chip *chip, unsigned offset,
 
 static int max7301_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        struct max7301 *ts = gpiochip_get_data(chip);
         int config, level = -EINVAL;
 
         /* First 4 pins are unused in the controller */
@@ -148,7 +148,7 @@ static int max7301_get(struct gpio_chip *chip, unsigned offset)
 
 static void max7301_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        struct max7301 *ts = gpiochip_get_data(chip);
 
         /* First 4 pins are unused in the controller */
         offset += 4;
@@ -189,7 +189,7 @@ int __max730x_probe(struct max7301 *ts)
 
         ts->chip.ngpio = PIN_NUMBER;
         ts->chip.can_sleep = true;
-        ts->chip.dev = dev;
+        ts->chip.parent = dev;
         ts->chip.owner = THIS_MODULE;
 
         /*
@@ -213,7 +213,7 @@ int __max730x_probe(struct max7301 *ts)
                 }
         }
 
-        ret = gpiochip_add(&ts->chip);
+        ret = gpiochip_add_data(&ts->chip, ts);
         if (ret)
                 goto exit_destroy;
 
diff --git a/drivers/gpio/gpio-max732x.c b/drivers/gpio/gpio-max732x.c
index 8c5252c6c327..a9aaf9d822b4 100644
--- a/drivers/gpio/gpio-max732x.c
+++ b/drivers/gpio/gpio-max732x.c
@@ -158,11 +158,6 @@ struct max732x_chip {
 #endif
 };
 
-static inline struct max732x_chip *to_max732x(struct gpio_chip *gc)
-{
-        return container_of(gc, struct max732x_chip, gpio_chip);
-}
-
 static int max732x_writeb(struct max732x_chip *chip, int group_a, uint8_t val)
 {
         struct i2c_client *client;
@@ -201,21 +196,21 @@ static inline int is_group_a(struct max732x_chip *chip, unsigned off)
 
 static int max732x_gpio_get_value(struct gpio_chip *gc, unsigned off)
 {
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
         uint8_t reg_val;
         int ret;
 
         ret = max732x_readb(chip, is_group_a(chip, off), &reg_val);
         if (ret < 0)
-                return 0;
+                return ret;
 
-        return reg_val & (1u << (off & 0x7));
+        return !!(reg_val & (1u << (off & 0x7)));
 }
 
 static void max732x_gpio_set_mask(struct gpio_chip *gc, unsigned off, int mask,
                                   int val)
 {
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
         uint8_t reg_out;
         int ret;
 
@@ -259,7 +254,7 @@ static void max732x_gpio_set_multiple(struct gpio_chip *gc,
 
 static int max732x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
 {
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
         unsigned int mask = 1u << off;
 
         if ((mask & chip->dir_input) == 0) {
@@ -281,7 +276,7 @@ static int max732x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
 static int max732x_gpio_direction_output(struct gpio_chip *gc,
                 unsigned off, int val)
 {
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
         unsigned int mask = 1u << off;
 
         if ((mask & chip->dir_output) == 0) {
@@ -356,7 +351,7 @@ static void max732x_irq_update_mask(struct max732x_chip *chip)
 static void max732x_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
 
         chip->irq_mask_cur &= ~(1 << d->hwirq);
 }
@@ -364,7 +359,7 @@ static void max732x_irq_mask(struct irq_data *d)
 static void max732x_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
 
         chip->irq_mask_cur |= 1 << d->hwirq;
 }
@@ -372,7 +367,7 @@ static void max732x_irq_unmask(struct irq_data *d)
 static void max732x_irq_bus_lock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
 
         mutex_lock(&chip->irq_lock);
         chip->irq_mask_cur = chip->irq_mask;
@@ -381,7 +376,7 @@ static void max732x_irq_bus_lock(struct irq_data *d)
 static void max732x_irq_bus_sync_unlock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
         uint16_t new_irqs;
         uint16_t level;
 
@@ -400,7 +395,7 @@ static void max732x_irq_bus_sync_unlock(struct irq_data *d)
 static int max732x_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct max732x_chip *chip = to_max732x(gc);
+        struct max732x_chip *chip = gpiochip_get_data(gc);
         uint16_t off = d->hwirq;
         uint16_t mask = 1 << off;
 
@@ -603,7 +598,7 @@ static int max732x_setup_gpio(struct max732x_chip *chip,
         gc->base = gpio_start;
         gc->ngpio = port;
         gc->label = chip->client->name;
-        gc->dev = &chip->client->dev;
+        gc->parent = &chip->client->dev;
         gc->owner = THIS_MODULE;
 
         return port;
@@ -649,7 +644,7 @@ static int max732x_probe(struct i2c_client *client,
         chip->client = client;
 
         nr_port = max732x_setup_gpio(chip, id, pdata->gpio_base);
-        chip->gpio_chip.dev = &client->dev;
+        chip->gpio_chip.parent = &client->dev;
 
         addr_a = (client->addr & 0x0f) | 0x60;
         addr_b = (client->addr & 0x0f) | 0x50;
@@ -694,7 +689,7 @@ static int max732x_probe(struct i2c_client *client,
                         goto out_failed;
         }
 
-        ret = gpiochip_add(&chip->gpio_chip);
+        ret = gpiochip_add_data(&chip->gpio_chip, chip);
         if (ret)
                 goto out_failed;
 
@@ -749,7 +744,6 @@ static int max732x_remove(struct i2c_client *client)
 static struct i2c_driver max732x_driver = {
         .driver = {
                 .name           = "max732x",
-                .owner          = THIS_MODULE,
                 .of_match_table = of_match_ptr(max732x_of_table),
         },
         .probe          = max732x_probe,
diff --git a/drivers/gpio/gpio-mb86s7x.c b/drivers/gpio/gpio-mb86s7x.c
index ee93c0ab0a59..7fffc1d6c055 100644
--- a/drivers/gpio/gpio-mb86s7x.c
+++ b/drivers/gpio/gpio-mb86s7x.c
@@ -44,14 +44,9 @@ struct mb86s70_gpio_chip {
         spinlock_t lock;
 };
 
-static inline struct mb86s70_gpio_chip *chip_to_mb86s70(struct gpio_chip *gc)
-{
-        return container_of(gc, struct mb86s70_gpio_chip, gc);
-}
-
 static int mb86s70_gpio_request(struct gpio_chip *gc, unsigned gpio)
 {
-        struct mb86s70_gpio_chip *gchip = chip_to_mb86s70(gc);
+        struct mb86s70_gpio_chip *gchip = gpiochip_get_data(gc);
         unsigned long flags;
         u32 val;
 
@@ -73,7 +68,7 @@ static int mb86s70_gpio_request(struct gpio_chip *gc, unsigned gpio)
 
 static void mb86s70_gpio_free(struct gpio_chip *gc, unsigned gpio)
 {
-        struct mb86s70_gpio_chip *gchip = chip_to_mb86s70(gc);
+        struct mb86s70_gpio_chip *gchip = gpiochip_get_data(gc);
         unsigned long flags;
         u32 val;
 
@@ -88,7 +83,7 @@ static void mb86s70_gpio_free(struct gpio_chip *gc, unsigned gpio)
 
 static int mb86s70_gpio_direction_input(struct gpio_chip *gc, unsigned gpio)
 {
-        struct mb86s70_gpio_chip *gchip = chip_to_mb86s70(gc);
+        struct mb86s70_gpio_chip *gchip = gpiochip_get_data(gc);
         unsigned long flags;
         unsigned char val;
 
@@ -106,7 +101,7 @@ static int mb86s70_gpio_direction_input(struct gpio_chip *gc, unsigned gpio)
 static int mb86s70_gpio_direction_output(struct gpio_chip *gc,
                                          unsigned gpio, int value)
 {
-        struct mb86s70_gpio_chip *gchip = chip_to_mb86s70(gc);
+        struct mb86s70_gpio_chip *gchip = gpiochip_get_data(gc);
         unsigned long flags;
         unsigned char val;
 
@@ -130,14 +125,14 @@ static int mb86s70_gpio_direction_output(struct gpio_chip *gc,
 
 static int mb86s70_gpio_get(struct gpio_chip *gc, unsigned gpio)
 {
-        struct mb86s70_gpio_chip *gchip = chip_to_mb86s70(gc);
+        struct mb86s70_gpio_chip *gchip = gpiochip_get_data(gc);
 
         return !!(readl(gchip->base + PDR(gpio)) & OFFSET(gpio));
 }
 
 static void mb86s70_gpio_set(struct gpio_chip *gc, unsigned gpio, int value)
 {
-        struct mb86s70_gpio_chip *gchip = chip_to_mb86s70(gc);
+        struct mb86s70_gpio_chip *gchip = gpiochip_get_data(gc);
         unsigned long flags;
         unsigned char val;
 
@@ -187,12 +182,12 @@ static int mb86s70_gpio_probe(struct platform_device *pdev)
         gchip->gc.label = dev_name(&pdev->dev);
         gchip->gc.ngpio = 32;
         gchip->gc.owner = THIS_MODULE;
-        gchip->gc.dev = &pdev->dev;
+        gchip->gc.parent = &pdev->dev;
         gchip->gc.base = -1;
 
         platform_set_drvdata(pdev, gchip);
 
-        ret = gpiochip_add(&gchip->gc);
+        ret = gpiochip_add_data(&gchip->gc, gchip);
         if (ret) {
                 dev_err(&pdev->dev, "couldn't register gpio driver\n");
                 clk_disable_unprepare(gchip->clk);
diff --git a/drivers/gpio/gpio-mc33880.c b/drivers/gpio/gpio-mc33880.c
index 2853731db5bc..0f0df7956264 100644
--- a/drivers/gpio/gpio-mc33880.c
+++ b/drivers/gpio/gpio-mc33880.c
@@ -71,7 +71,7 @@ static int __mc33880_set(struct mc33880 *mc, unsigned offset, int value)
 
 static void mc33880_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct mc33880 *mc = container_of(chip, struct mc33880, chip);
+        struct mc33880 *mc = gpiochip_get_data(chip);
 
         mutex_lock(&mc->lock);
 
@@ -116,7 +116,7 @@ static int mc33880_probe(struct spi_device *spi)
         mc->chip.base = pdata->base;
         mc->chip.ngpio = PIN_NUMBER;
         mc->chip.can_sleep = true;
-        mc->chip.dev = &spi->dev;
+        mc->chip.parent = &spi->dev;
         mc->chip.owner = THIS_MODULE;
 
         mc->port_config = 0x00;
@@ -135,7 +135,7 @@ static int mc33880_probe(struct spi_device *spi)
                 goto exit_destroy;
         }
 
-        ret = gpiochip_add(&mc->chip);
+        ret = gpiochip_add_data(&mc->chip, mc);
         if (ret)
                 goto exit_destroy;
 
diff --git a/drivers/gpio/gpio-mc9s08dz60.c b/drivers/gpio/gpio-mc9s08dz60.c
index d62b4f8182bf..ba22fb92a6e7 100644
--- a/drivers/gpio/gpio-mc9s08dz60.c
+++ b/drivers/gpio/gpio-mc9s08dz60.c
@@ -29,12 +29,6 @@ struct mc9s08dz60 {
         struct gpio_chip chip;
 };
 
-static inline struct mc9s08dz60 *to_mc9s08dz60(struct gpio_chip *gc)
-{
-        return container_of(gc, struct mc9s08dz60, chip);
-}
-
-
 static void mc9s_gpio_to_reg_and_bit(int offset, u8 *reg, u8 *bit)
 {
         *reg = 0x20 + offset / GPIO_NUM_PER_GROUP;
@@ -45,7 +39,7 @@ static int mc9s08dz60_get_value(struct gpio_chip *gc, unsigned offset)
 {
         u8 reg, bit;
         s32 value;
-        struct mc9s08dz60 *mc9s = to_mc9s08dz60(gc);
+        struct mc9s08dz60 *mc9s = gpiochip_get_data(gc);
 
         mc9s_gpio_to_reg_and_bit(offset, &reg, &bit);
         value = i2c_smbus_read_byte_data(mc9s->client, reg);
@@ -75,7 +69,7 @@ static int mc9s08dz60_set(struct mc9s08dz60 *mc9s, unsigned offset, int val)
 
 static void mc9s08dz60_set_value(struct gpio_chip *gc, unsigned offset, int val)
 {
-        struct mc9s08dz60 *mc9s = to_mc9s08dz60(gc);
+        struct mc9s08dz60 *mc9s = gpiochip_get_data(gc);
 
         mc9s08dz60_set(mc9s, offset, val);
 }
@@ -83,7 +77,7 @@ static void mc9s08dz60_set_value(struct gpio_chip *gc, unsigned offset, int val)
 static int mc9s08dz60_direction_output(struct gpio_chip *gc,
                                        unsigned offset, int val)
 {
-        struct mc9s08dz60 *mc9s = to_mc9s08dz60(gc);
+        struct mc9s08dz60 *mc9s = gpiochip_get_data(gc);
 
         return mc9s08dz60_set(mc9s, offset, val);
 }
@@ -99,7 +93,7 @@ static int mc9s08dz60_probe(struct i2c_client *client,
 
         mc9s->chip.label = client->name;
         mc9s->chip.base = -1;
-        mc9s->chip.dev = &client->dev;
+        mc9s->chip.parent = &client->dev;
         mc9s->chip.owner = THIS_MODULE;
         mc9s->chip.ngpio = GPIO_NUM;
         mc9s->chip.can_sleep = true;
@@ -109,7 +103,7 @@ static int mc9s08dz60_probe(struct i2c_client *client,
         mc9s->client = client;
         i2c_set_clientdata(client, mc9s);
 
-        return gpiochip_add(&mc9s->chip);
+        return gpiochip_add_data(&mc9s->chip, mc9s);
 }
 
 static int mc9s08dz60_remove(struct i2c_client *client)
@@ -131,7 +125,6 @@ MODULE_DEVICE_TABLE(i2c, mc9s08dz60_id);
 
 static struct i2c_driver mc9s08dz60_i2c_driver = {
         .driver = {
-                .owner = THIS_MODULE,
                 .name = "mc9s08dz60",
         },
         .probe = mc9s08dz60_probe,
diff --git a/drivers/gpio/gpio-mcp23s08.c b/drivers/gpio/gpio-mcp23s08.c
index 4a41694919da..c767879e4dd9 100644
--- a/drivers/gpio/gpio-mcp23s08.c
+++ b/drivers/gpio/gpio-mcp23s08.c
@@ -269,7 +269,7 @@ static const struct mcp23s08_ops mcp23s17_ops = {
 
 static int mcp23s08_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct mcp23s08 *mcp = container_of(chip, struct mcp23s08, chip);
+        struct mcp23s08 *mcp = gpiochip_get_data(chip);
         int status;
 
         mutex_lock(&mcp->lock);
@@ -281,7 +281,7 @@ static int mcp23s08_direction_input(struct gpio_chip *chip, unsigned offset)
 
 static int mcp23s08_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct mcp23s08 *mcp = container_of(chip, struct mcp23s08, chip);
+        struct mcp23s08 *mcp = gpiochip_get_data(chip);
         int status;
 
         mutex_lock(&mcp->lock);
@@ -312,7 +312,7 @@ static int __mcp23s08_set(struct mcp23s08 *mcp, unsigned mask, int value)
 
 static void mcp23s08_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct mcp23s08 *mcp = container_of(chip, struct mcp23s08, chip);
+        struct mcp23s08 *mcp = gpiochip_get_data(chip);
         unsigned mask = 1 << offset;
 
         mutex_lock(&mcp->lock);
@@ -323,7 +323,7 @@ static void mcp23s08_set(struct gpio_chip *chip, unsigned offset, int value)
 static int
 mcp23s08_direction_output(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct mcp23s08 *mcp = container_of(chip, struct mcp23s08, chip);
+        struct mcp23s08 *mcp = gpiochip_get_data(chip);
         unsigned mask = 1 << offset;
         int status;
 
@@ -377,7 +377,7 @@ static irqreturn_t mcp23s08_irq(int irq, void *data)
 
 static int mcp23s08_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct mcp23s08 *mcp = container_of(chip, struct mcp23s08, chip);
+        struct mcp23s08 *mcp = gpiochip_get_data(chip);
 
         return irq_find_mapping(mcp->irq_domain, offset);
 }
@@ -446,7 +446,7 @@ static int mcp23s08_irq_reqres(struct irq_data *data)
         struct mcp23s08 *mcp = irq_data_get_irq_chip_data(data);
 
         if (gpiochip_lock_as_irq(&mcp->chip, data->hwirq)) {
-                dev_err(mcp->chip.dev,
+                dev_err(mcp->chip.parent,
                         "unable to lock HW IRQ %lu for IRQ usage\n",
                         data->hwirq);
                 return -EINVAL;
@@ -481,7 +481,8 @@ static int mcp23s08_irq_setup(struct mcp23s08 *mcp)
 
         mutex_init(&mcp->irq_lock);
 
-        mcp->irq_domain = irq_domain_add_linear(chip->dev->of_node, chip->ngpio,
+        mcp->irq_domain = irq_domain_add_linear(chip->parent->of_node,
+                                                chip->ngpio,
                                                 &irq_domain_simple_ops, mcp);
         if (!mcp->irq_domain)
                 return -ENODEV;
@@ -491,10 +492,11 @@ static int mcp23s08_irq_setup(struct mcp23s08 *mcp)
         else
                 irqflags |= IRQF_TRIGGER_LOW;
 
-        err = devm_request_threaded_irq(chip->dev, mcp->irq, NULL, mcp23s08_irq,
-                                        irqflags, dev_name(chip->dev), mcp);
+        err = devm_request_threaded_irq(chip->parent, mcp->irq, NULL,
+                                        mcp23s08_irq,
+                                        irqflags, dev_name(chip->parent), mcp);
         if (err != 0) {
-                dev_err(chip->dev, "unable to request IRQ#%d: %d\n",
+                dev_err(chip->parent, "unable to request IRQ#%d: %d\n",
                         mcp->irq, err);
                 return err;
         }
@@ -542,7 +544,7 @@ static void mcp23s08_dbg_show(struct seq_file *s, struct gpio_chip *chip)
         int             t;
         unsigned        mask;
 
-        mcp = container_of(chip, struct mcp23s08, chip);
+        mcp = gpiochip_get_data(chip);
 
         /* NOTE: we only handle one bank for now ... */
         bank = '0' + ((mcp->addr >> 1) & 0x7);
@@ -638,7 +640,7 @@ static int mcp23s08_probe_one(struct mcp23s08 *mcp, struct device *dev,
 
         mcp->chip.base = pdata->base;
         mcp->chip.can_sleep = true;
-        mcp->chip.dev = dev;
+        mcp->chip.parent = dev;
         mcp->chip.owner = THIS_MODULE;
 
         /* verify MCP_IOCON.SEQOP = 0, so sequential reads work,
@@ -652,7 +654,7 @@ static int mcp23s08_probe_one(struct mcp23s08 *mcp, struct device *dev,
         mcp->irq_controller = pdata->irq_controller;
         if (mcp->irq && mcp->irq_controller) {
                 mcp->irq_active_high =
-                        of_property_read_bool(mcp->chip.dev->of_node,
+                        of_property_read_bool(mcp->chip.parent->of_node,
                                               "microchip,irq-active-high");
 
                 if (type == MCP_TYPE_017)
@@ -702,7 +704,7 @@ static int mcp23s08_probe_one(struct mcp23s08 *mcp, struct device *dev,
                         goto fail;
         }
 
-        status = gpiochip_add(&mcp->chip);
+        status = gpiochip_add_data(&mcp->chip, mcp);
         if (status < 0)
                 goto fail;
 
diff --git a/drivers/gpio/gpio-ml-ioh.c b/drivers/gpio/gpio-ml-ioh.c
index 5536108aa9db..796a5a4bc4f5 100644
--- a/drivers/gpio/gpio-ml-ioh.c
+++ b/drivers/gpio/gpio-ml-ioh.c
@@ -106,7 +106,7 @@ static const int num_ports[] = {6, 12, 16, 16, 15, 16, 16, 12};
 static void ioh_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
 {
         u32 reg_val;
-        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+        struct ioh_gpio *chip = gpiochip_get_data(gpio);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->spinlock, flags);
@@ -122,15 +122,15 @@ static void ioh_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
 
 static int ioh_gpio_get(struct gpio_chip *gpio, unsigned nr)
 {
-        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+        struct ioh_gpio *chip = gpiochip_get_data(gpio);
 
-        return ioread32(&chip->reg->regs[chip->ch].pi) & (1 << nr);
+        return !!(ioread32(&chip->reg->regs[chip->ch].pi) & (1 << nr));
 }
 
 static int ioh_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
                                      int val)
 {
-        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+        struct ioh_gpio *chip = gpiochip_get_data(gpio);
         u32 pm;
         u32 reg_val;
         unsigned long flags;
@@ -155,7 +155,7 @@ static int ioh_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
 
 static int ioh_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 {
-        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+        struct ioh_gpio *chip = gpiochip_get_data(gpio);
         u32 pm;
         unsigned long flags;
 
@@ -225,7 +225,7 @@ static void ioh_gpio_restore_reg_conf(struct ioh_gpio *chip)
 
 static int ioh_gpio_to_irq(struct gpio_chip *gpio, unsigned offset)
 {
-        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+        struct ioh_gpio *chip = gpiochip_get_data(gpio);
         return chip->irq_base + offset;
 }
 
@@ -450,7 +450,7 @@ static int ioh_gpio_probe(struct pci_dev *pdev,
                 chip->ch = i;
                 spin_lock_init(&chip->spinlock);
                 ioh_gpio_setup(chip, num_ports[i]);
-                ret = gpiochip_add(&chip->gpio);
+                ret = gpiochip_add_data(&chip->gpio, chip);
                 if (ret) {
                         dev_err(&pdev->dev, "IOH gpio: Failed to register GPIO\n");
                         goto err_gpiochip_add;
diff --git a/drivers/gpio/gpio-mm-lantiq.c b/drivers/gpio/gpio-mm-lantiq.c
index f67ef2283d64..54e5d8257d34 100644
--- a/drivers/gpio/gpio-mm-lantiq.c
+++ b/drivers/gpio/gpio-mm-lantiq.c
@@ -61,9 +61,7 @@ static void ltq_mm_apply(struct ltq_mm *chip)
  */
 static void ltq_mm_set(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct ltq_mm *chip =
-                container_of(mm_gc, struct ltq_mm, mmchip);
+        struct ltq_mm *chip = gpiochip_get_data(gc);
 
         if (value)
                 chip->shadow |= (1 << offset);
@@ -122,7 +120,7 @@ static int ltq_mm_probe(struct platform_device *pdev)
         if (!of_property_read_u32(pdev->dev.of_node, "lantiq,shadow", &shadow))
                 chip->shadow = shadow;
 
-        return of_mm_gpiochip_add(pdev->dev.of_node, &chip->mmchip);
+        return of_mm_gpiochip_add_data(pdev->dev.of_node, &chip->mmchip, chip);
 }
 
 static int ltq_mm_remove(struct platform_device *pdev)
diff --git a/drivers/gpio/gpio-moxart.c b/drivers/gpio/gpio-moxart.c
index d3355a6dc9b1..ca604538ebf7 100644
--- a/drivers/gpio/gpio-moxart.c
+++ b/drivers/gpio/gpio-moxart.c
@@ -14,7 +14,6 @@
 #include <linux/init.h>
 #include <linux/irq.h>
 #include <linux/io.h>
-#include <linux/gpio.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
 #include <linux/of_address.h>
@@ -23,7 +22,7 @@
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/bitops.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 
 #define GPIO_DATA_OUT           0x00
 #define GPIO_DATA_IN            0x04
@@ -33,12 +32,12 @@ static int moxart_gpio_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct resource *res;
-        struct bgpio_chip *bgc;
+        struct gpio_chip *gc;
         void __iomem *base;
         int ret;
 
-        bgc = devm_kzalloc(dev, sizeof(*bgc), GFP_KERNEL);
-        if (!bgc)
+        gc = devm_kzalloc(dev, sizeof(*gc), GFP_KERNEL);
+        if (!gc)
                 return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -46,7 +45,7 @@ static int moxart_gpio_probe(struct platform_device *pdev)
         if (IS_ERR(base))
                 return PTR_ERR(base);
 
-        ret = bgpio_init(bgc, dev, 4, base + GPIO_DATA_IN,
+        ret = bgpio_init(gc, dev, 4, base + GPIO_DATA_IN,
                          base + GPIO_DATA_OUT, NULL,
                          base + GPIO_PIN_DIRECTION, NULL,
                          BGPIOF_READ_OUTPUT_REG_SET);
@@ -55,16 +54,16 @@ static int moxart_gpio_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        bgc->gc.label = "moxart-gpio";
-        bgc->gc.request = gpiochip_generic_request;
-        bgc->gc.free = gpiochip_generic_free;
-        bgc->data = bgc->read_reg(bgc->reg_set);
-        bgc->gc.base = 0;
-        bgc->gc.ngpio = 32;
-        bgc->gc.dev = dev;
-        bgc->gc.owner = THIS_MODULE;
+        gc->label = "moxart-gpio";
+        gc->request = gpiochip_generic_request;
+        gc->free = gpiochip_generic_free;
+        gc->bgpio_data = gc->read_reg(gc->reg_set);
+        gc->base = 0;
+        gc->ngpio = 32;
+        gc->parent = dev;
+        gc->owner = THIS_MODULE;
 
-        ret = gpiochip_add(&bgc->gc);
+        ret = gpiochip_add_data(gc, NULL);
         if (ret) {
                 dev_err(dev, "%s: gpiochip_add failed\n",
                         dev->of_node->full_name);
diff --git a/drivers/gpio/gpio-mpc5200.c b/drivers/gpio/gpio-mpc5200.c
index 4c542153e923..0e5a6709f27d 100644
--- a/drivers/gpio/gpio-mpc5200.c
+++ b/drivers/gpio/gpio-mpc5200.c
@@ -71,8 +71,7 @@ static inline void
 __mpc52xx_wkup_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct mpc52xx_gpiochip *chip = container_of(mm_gc,
-                        struct mpc52xx_gpiochip, mmchip);
+        struct mpc52xx_gpiochip *chip = gpiochip_get_data(gc);
         struct mpc52xx_gpio_wkup __iomem *regs = mm_gc->regs;
 
         if (val)
@@ -100,8 +99,7 @@ mpc52xx_wkup_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 static int mpc52xx_wkup_gpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
 {
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct mpc52xx_gpiochip *chip = container_of(mm_gc,
-                        struct mpc52xx_gpiochip, mmchip);
+        struct mpc52xx_gpiochip *chip = gpiochip_get_data(gc);
         struct mpc52xx_gpio_wkup __iomem *regs = mm_gc->regs;
         unsigned long flags;
 
@@ -125,8 +123,7 @@ mpc52xx_wkup_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
         struct mpc52xx_gpio_wkup __iomem *regs = mm_gc->regs;
-        struct mpc52xx_gpiochip *chip = container_of(mm_gc,
-                        struct mpc52xx_gpiochip, mmchip);
+        struct mpc52xx_gpiochip *chip = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&gpio_lock, flags);
@@ -169,7 +166,7 @@ static int mpc52xx_wkup_gpiochip_probe(struct platform_device *ofdev)
         gc->get              = mpc52xx_wkup_gpio_get;
         gc->set              = mpc52xx_wkup_gpio_set;
 
-        ret = of_mm_gpiochip_add(ofdev->dev.of_node, &chip->mmchip);
+        ret = of_mm_gpiochip_add_data(ofdev->dev.of_node, &chip->mmchip, chip);
         if (ret)
                 return ret;
 
@@ -236,8 +233,7 @@ static inline void
 __mpc52xx_simple_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct mpc52xx_gpiochip *chip = container_of(mm_gc,
-                        struct mpc52xx_gpiochip, mmchip);
+        struct mpc52xx_gpiochip *chip = gpiochip_get_data(gc);
         struct mpc52xx_gpio __iomem *regs = mm_gc->regs;
 
         if (val)
@@ -264,8 +260,7 @@ mpc52xx_simple_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 static int mpc52xx_simple_gpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
 {
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct mpc52xx_gpiochip *chip = container_of(mm_gc,
-                        struct mpc52xx_gpiochip, mmchip);
+        struct mpc52xx_gpiochip *chip = gpiochip_get_data(gc);
         struct mpc52xx_gpio __iomem *regs = mm_gc->regs;
         unsigned long flags;
 
@@ -288,8 +283,7 @@ static int
 mpc52xx_simple_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct mpc52xx_gpiochip *chip = container_of(mm_gc,
-                        struct mpc52xx_gpiochip, mmchip);
+        struct mpc52xx_gpiochip *chip = gpiochip_get_data(gc);
         struct mpc52xx_gpio __iomem *regs = mm_gc->regs;
         unsigned long flags;
 
@@ -334,7 +328,7 @@ static int mpc52xx_simple_gpiochip_probe(struct platform_device *ofdev)
         gc->get              = mpc52xx_simple_gpio_get;
         gc->set              = mpc52xx_simple_gpio_set;
 
-        ret = of_mm_gpiochip_add(ofdev->dev.of_node, &chip->mmchip);
+        ret = of_mm_gpiochip_add_data(ofdev->dev.of_node, &chip->mmchip, chip);
         if (ret)
                 return ret;
 
@@ -360,15 +354,14 @@ static struct platform_driver mpc52xx_simple_gpiochip_driver = {
         .remove = mpc52xx_gpiochip_remove,
 };
 
+static struct platform_driver * const drivers[] = {
+        &mpc52xx_wkup_gpiochip_driver,
+        &mpc52xx_simple_gpiochip_driver,
+};
+
 static int __init mpc52xx_gpio_init(void)
 {
-        if (platform_driver_register(&mpc52xx_wkup_gpiochip_driver))
-                printk(KERN_ERR "Unable to register wakeup GPIO driver\n");
-
-        if (platform_driver_register(&mpc52xx_simple_gpiochip_driver))
-                printk(KERN_ERR "Unable to register simple GPIO driver\n");
-
-        return 0;
+        return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
 }
 
 /* Make sure we get initialised before anyone else tries to use us */
@@ -376,9 +369,7 @@ subsys_initcall(mpc52xx_gpio_init);
 
 static void __exit mpc52xx_gpio_exit(void)
 {
-        platform_driver_unregister(&mpc52xx_wkup_gpiochip_driver);
-
-        platform_driver_unregister(&mpc52xx_simple_gpiochip_driver);
+        platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
 }
 module_exit(mpc52xx_gpio_exit);
 
diff --git a/drivers/gpio/gpio-mpc8xxx.c b/drivers/gpio/gpio-mpc8xxx.c
index 48ef368347ab..9d40787e66c0 100644
--- a/drivers/gpio/gpio-mpc8xxx.c
+++ b/drivers/gpio/gpio-mpc8xxx.c
@@ -49,15 +49,10 @@ static inline u32 mpc8xxx_gpio2mask(unsigned int gpio)
         return 1u << (MPC8XXX_GPIO_PINS - 1 - gpio);
 }
 
-static inline struct mpc8xxx_gpio_chip *
-to_mpc8xxx_gpio_chip(struct of_mm_gpio_chip *mm)
-{
-        return container_of(mm, struct mpc8xxx_gpio_chip, mm_gc);
-}
-
 static void mpc8xxx_gpio_save_regs(struct of_mm_gpio_chip *mm)
 {
-        struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc =
+                container_of(mm, struct mpc8xxx_gpio_chip, mm_gc);
 
         mpc8xxx_gc->data = in_be32(mm->regs + GPIO_DAT);
 }
@@ -71,7 +66,7 @@ static int mpc8572_gpio_get(struct gpio_chip *gc, unsigned int gpio)
 {
         u32 val;
         struct of_mm_gpio_chip *mm = to_of_mm_gpio_chip(gc);
-        struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = gpiochip_get_data(gc);
         u32 out_mask, out_shadow;
 
         out_mask = in_be32(mm->regs + GPIO_DIR);
@@ -79,7 +74,7 @@ static int mpc8572_gpio_get(struct gpio_chip *gc, unsigned int gpio)
         val = in_be32(mm->regs + GPIO_DAT) & ~out_mask;
         out_shadow = mpc8xxx_gc->data & out_mask;
 
-        return (val | out_shadow) & mpc8xxx_gpio2mask(gpio);
+        return !!((val | out_shadow) & mpc8xxx_gpio2mask(gpio));
 }
 
 static int mpc8xxx_gpio_get(struct gpio_chip *gc, unsigned int gpio)
@@ -92,7 +87,7 @@ static int mpc8xxx_gpio_get(struct gpio_chip *gc, unsigned int gpio)
 static void mpc8xxx_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         struct of_mm_gpio_chip *mm = to_of_mm_gpio_chip(gc);
-        struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = gpiochip_get_data(gc);
         unsigned long flags;
 
         raw_spin_lock_irqsave(&mpc8xxx_gc->lock, flags);
@@ -111,7 +106,7 @@ static void mpc8xxx_gpio_set_multiple(struct gpio_chip *gc,
                                       unsigned long *mask, unsigned long *bits)
 {
         struct of_mm_gpio_chip *mm = to_of_mm_gpio_chip(gc);
-        struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = gpiochip_get_data(gc);
         unsigned long flags;
         int i;
 
@@ -136,7 +131,7 @@ static void mpc8xxx_gpio_set_multiple(struct gpio_chip *gc,
 static int mpc8xxx_gpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
 {
         struct of_mm_gpio_chip *mm = to_of_mm_gpio_chip(gc);
-        struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = gpiochip_get_data(gc);
         unsigned long flags;
 
         raw_spin_lock_irqsave(&mpc8xxx_gc->lock, flags);
@@ -151,7 +146,7 @@ static int mpc8xxx_gpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
 static int mpc8xxx_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         struct of_mm_gpio_chip *mm = to_of_mm_gpio_chip(gc);
-        struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = gpiochip_get_data(gc);
         unsigned long flags;
 
         mpc8xxx_gpio_set(gc, gpio, val);
@@ -185,8 +180,7 @@ static int mpc5125_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val
 
 static int mpc8xxx_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct of_mm_gpio_chip *mm = to_of_mm_gpio_chip(gc);
-        struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = gpiochip_get_data(gc);
 
         if (mpc8xxx_gc->irq && offset < MPC8XXX_GPIO_PINS)
                 return irq_create_mapping(mpc8xxx_gc->irq, offset);
@@ -417,7 +411,7 @@ static int mpc8xxx_probe(struct platform_device *pdev)
         gc->set_multiple = mpc8xxx_gpio_set_multiple;
         gc->to_irq = mpc8xxx_gpio_to_irq;
 
-        ret = of_mm_gpiochip_add(np, mm_gc);
+        ret = of_mm_gpiochip_add_data(np, mm_gc, mpc8xxx_gc);
         if (ret)
                 return ret;
 
diff --git a/drivers/gpio/gpio-msic.c b/drivers/gpio/gpio-msic.c
index 22523aae8abe..d75649787e6c 100644
--- a/drivers/gpio/gpio-msic.c
+++ b/drivers/gpio/gpio-msic.c
@@ -143,7 +143,7 @@ static int msic_gpio_get(struct gpio_chip *chip, unsigned offset)
         if (ret < 0)
                 return ret;
 
-        return r & MSIC_GPIO_DIN_MASK;
+        return !!(r & MSIC_GPIO_DIN_MASK);
 }
 
 static void msic_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
@@ -179,7 +179,7 @@ static int msic_irq_type(struct irq_data *data, unsigned type)
 
 static int msic_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct msic_gpio *mg = container_of(chip, struct msic_gpio, chip);
+        struct msic_gpio *mg = gpiochip_get_data(chip);
         return mg->irq_base + offset;
 }
 
@@ -293,11 +293,11 @@ static int platform_msic_gpio_probe(struct platform_device *pdev)
         mg->chip.base = pdata->gpio_base;
         mg->chip.ngpio = MSIC_NUM_GPIO;
         mg->chip.can_sleep = true;
-        mg->chip.dev = dev;
+        mg->chip.parent = dev;
 
         mutex_init(&mg->buslock);
 
-        retval = gpiochip_add(&mg->chip);
+        retval = gpiochip_add_data(&mg->chip, mg);
         if (retval) {
                 dev_err(dev, "Adding MSIC gpio chip failed\n");
                 goto err;
diff --git a/drivers/gpio/gpio-mvebu.c b/drivers/gpio/gpio-mvebu.c
index d428b97876c5..a5eacc1dff09 100644
--- a/drivers/gpio/gpio-mvebu.c
+++ b/drivers/gpio/gpio-mvebu.c
@@ -187,8 +187,7 @@ static void __iomem *mvebu_gpioreg_level_mask(struct mvebu_gpio_chip *mvchip)
 
 static void mvebu_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
 {
-        struct mvebu_gpio_chip *mvchip =
-                container_of(chip, struct mvebu_gpio_chip, chip);
+        struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
         unsigned long flags;
         u32 u;
 
@@ -204,8 +203,7 @@ static void mvebu_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
 
 static int mvebu_gpio_get(struct gpio_chip *chip, unsigned pin)
 {
-        struct mvebu_gpio_chip *mvchip =
-                container_of(chip, struct mvebu_gpio_chip, chip);
+        struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
         u32 u;
 
         if (readl_relaxed(mvebu_gpioreg_io_conf(mvchip)) & (1 << pin)) {
@@ -220,8 +218,7 @@ static int mvebu_gpio_get(struct gpio_chip *chip, unsigned pin)
 
 static void mvebu_gpio_blink(struct gpio_chip *chip, unsigned pin, int value)
 {
-        struct mvebu_gpio_chip *mvchip =
-                container_of(chip, struct mvebu_gpio_chip, chip);
+        struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
         unsigned long flags;
         u32 u;
 
@@ -237,8 +234,7 @@ static void mvebu_gpio_blink(struct gpio_chip *chip, unsigned pin, int value)
 
 static int mvebu_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 {
-        struct mvebu_gpio_chip *mvchip =
-                container_of(chip, struct mvebu_gpio_chip, chip);
+        struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
         unsigned long flags;
         int ret;
         u32 u;
@@ -261,8 +257,7 @@ static int mvebu_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 static int mvebu_gpio_direction_output(struct gpio_chip *chip, unsigned pin,
                                        int value)
 {
-        struct mvebu_gpio_chip *mvchip =
-                container_of(chip, struct mvebu_gpio_chip, chip);
+        struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
         unsigned long flags;
         int ret;
         u32 u;
@@ -287,8 +282,7 @@ static int mvebu_gpio_direction_output(struct gpio_chip *chip, unsigned pin,
 
 static int mvebu_gpio_to_irq(struct gpio_chip *chip, unsigned pin)
 {
-        struct mvebu_gpio_chip *mvchip =
-                container_of(chip, struct mvebu_gpio_chip, chip);
+        struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
         return irq_create_mapping(mvchip->domain, pin);
 }
 
@@ -494,8 +488,7 @@ static void mvebu_gpio_irq_handler(struct irq_desc *desc)
 
 static void mvebu_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct mvebu_gpio_chip *mvchip =
-                container_of(chip, struct mvebu_gpio_chip, chip);
+        struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
         u32 out, io_conf, blink, in_pol, data_in, cause, edg_msk, lvl_msk;
         int i;
 
@@ -698,7 +691,7 @@ static int mvebu_gpio_probe(struct platform_device *pdev)
 
         mvchip->soc_variant = soc_variant;
         mvchip->chip.label = dev_name(&pdev->dev);
-        mvchip->chip.dev = &pdev->dev;
+        mvchip->chip.parent = &pdev->dev;
         mvchip->chip.request = gpiochip_generic_request;
         mvchip->chip.free = gpiochip_generic_free;
         mvchip->chip.direction_input = mvebu_gpio_direction_input;
@@ -763,7 +756,7 @@ static int mvebu_gpio_probe(struct platform_device *pdev)
                 BUG();
         }
 
-        gpiochip_add(&mvchip->chip);
+        gpiochip_add_data(&mvchip->chip, mvchip);
 
         /* Some gpio controllers do not provide irq support */
         if (!of_irq_count(np))
diff --git a/drivers/gpio/gpio-mxc.c b/drivers/gpio/gpio-mxc.c
index 6ea8df6c7397..7fd21cb53c81 100644
--- a/drivers/gpio/gpio-mxc.c
+++ b/drivers/gpio/gpio-mxc.c
@@ -26,10 +26,11 @@
 #include <linux/irq.h>
 #include <linux/irqdomain.h>
 #include <linux/irqchip/chained_irq.h>
-#include <linux/gpio.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
+/* FIXME: for gpio_get_value() replace this with direct register read */
+#include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/module.h>
@@ -64,7 +65,7 @@ struct mxc_gpio_port {
         int irq;
         int irq_high;
         struct irq_domain *domain;
-        struct bgpio_chip bgc;
+        struct gpio_chip gc;
         u32 both_edges;
 };
 
@@ -172,7 +173,7 @@ static int gpio_set_irq_type(struct irq_data *d, u32 type)
         struct mxc_gpio_port *port = gc->private;
         u32 bit, val;
         u32 gpio_idx = d->hwirq;
-        u32 gpio = port->bgc.gc.base + gpio_idx;
+        u32 gpio = port->gc.base + gpio_idx;
         int edge;
         void __iomem *reg = port->base;
 
@@ -398,9 +399,7 @@ static void mxc_gpio_get_hw(struct platform_device *pdev)
 
 static int mxc_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        struct mxc_gpio_port *port =
-                container_of(bgc, struct mxc_gpio_port, bgc);
+        struct mxc_gpio_port *port = gpiochip_get_data(gc);
 
         return irq_find_mapping(port->domain, offset);
 }
@@ -451,7 +450,7 @@ static int mxc_gpio_probe(struct platform_device *pdev)
                                                          port);
         }
 
-        err = bgpio_init(&port->bgc, &pdev->dev, 4,
+        err = bgpio_init(&port->gc, &pdev->dev, 4,
                          port->base + GPIO_PSR,
                          port->base + GPIO_DR, NULL,
                          port->base + GPIO_GDIR, NULL,
@@ -459,13 +458,13 @@ static int mxc_gpio_probe(struct platform_device *pdev)
         if (err)
                 goto out_bgio;
 
-        port->bgc.gc.to_irq = mxc_gpio_to_irq;
-        port->bgc.gc.base = (pdev->id < 0) ? of_alias_get_id(np, "gpio") * 32 :
+        port->gc.to_irq = mxc_gpio_to_irq;
+        port->gc.base = (pdev->id < 0) ? of_alias_get_id(np, "gpio") * 32 :
                                              pdev->id * 32;
 
-        err = gpiochip_add(&port->bgc.gc);
+        err = gpiochip_add_data(&port->gc, port);
         if (err)
-                goto out_bgpio_remove;
+                goto out_bgio;
 
         irq_base = irq_alloc_descs(-1, 0, 32, numa_node_id());
         if (irq_base < 0) {
@@ -494,9 +493,7 @@ out_irqdomain_remove:
 out_irqdesc_free:
         irq_free_descs(irq_base, 32);
 out_gpiochip_remove:
-        gpiochip_remove(&port->bgc.gc);
-out_bgpio_remove:
-        bgpio_remove(&port->bgc);
+        gpiochip_remove(&port->gc);
 out_bgio:
         dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, err);
         return err;
diff --git a/drivers/gpio/gpio-mxs.c b/drivers/gpio/gpio-mxs.c
index a4288f428819..b9daa0bf32a4 100644
--- a/drivers/gpio/gpio-mxs.c
+++ b/drivers/gpio/gpio-mxs.c
@@ -26,13 +26,14 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/irqdomain.h>
-#include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
+/* FIXME: for gpio_get_value(), replace this by direct register read */
+#include <linux/gpio.h>
 #include <linux/module.h>
 
 #define MXS_SET         0x4
@@ -64,7 +65,7 @@ struct mxs_gpio_port {
         int id;
         int irq;
         struct irq_domain *domain;
-        struct bgpio_chip bgc;
+        struct gpio_chip gc;
         enum mxs_gpio_id devid;
         u32 both_edges;
 };
@@ -93,7 +94,7 @@ static int mxs_gpio_set_irq_type(struct irq_data *d, unsigned int type)
         port->both_edges &= ~pin_mask;
         switch (type) {
         case IRQ_TYPE_EDGE_BOTH:
-                val = gpio_get_value(port->bgc.gc.base + d->hwirq);
+                val = gpio_get_value(port->gc.base + d->hwirq);
                 if (val)
                         edge = GPIO_INT_FALL_EDGE;
                 else
@@ -225,18 +226,14 @@ static int __init mxs_gpio_init_gc(struct mxs_gpio_port *port, int irq_base)
 
 static int mxs_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        struct mxs_gpio_port *port =
-                container_of(bgc, struct mxs_gpio_port, bgc);
+        struct mxs_gpio_port *port = gpiochip_get_data(gc);
 
         return irq_find_mapping(port->domain, offset);
 }
 
 static int mxs_gpio_get_direction(struct gpio_chip *gc, unsigned offset)
 {
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-        struct mxs_gpio_port *port =
-                container_of(bgc, struct mxs_gpio_port, bgc);
+        struct mxs_gpio_port *port = gpiochip_get_data(gc);
         u32 mask = 1 << offset;
         u32 dir;
 
@@ -330,26 +327,24 @@ static int mxs_gpio_probe(struct platform_device *pdev)
         irq_set_chained_handler_and_data(port->irq, mxs_gpio_irq_handler,
                                          port);
 
-        err = bgpio_init(&port->bgc, &pdev->dev, 4,
+        err = bgpio_init(&port->gc, &pdev->dev, 4,
                          port->base + PINCTRL_DIN(port),
                          port->base + PINCTRL_DOUT(port) + MXS_SET,
                          port->base + PINCTRL_DOUT(port) + MXS_CLR,
                          port->base + PINCTRL_DOE(port), NULL, 0);
         if (err)
-                goto out_irqdesc_free;
+                goto out_irqdomain_remove;
 
-        port->bgc.gc.to_irq = mxs_gpio_to_irq;
-        port->bgc.gc.get_direction = mxs_gpio_get_direction;
-        port->bgc.gc.base = port->id * 32;
+        port->gc.to_irq = mxs_gpio_to_irq;
+        port->gc.get_direction = mxs_gpio_get_direction;
+        port->gc.base = port->id * 32;
 
-        err = gpiochip_add(&port->bgc.gc);
+        err = gpiochip_add_data(&port->gc, port);
         if (err)
-                goto out_bgpio_remove;
+                goto out_irqdomain_remove;
 
         return 0;
 
-out_bgpio_remove:
-        bgpio_remove(&port->bgc);
 out_irqdomain_remove:
         irq_domain_remove(port->domain);
 out_irqdesc_free:
diff --git a/drivers/gpio/gpio-octeon.c b/drivers/gpio/gpio-octeon.c
index 62ae251d4490..7665ebcd0c1d 100644
--- a/drivers/gpio/gpio-octeon.c
+++ b/drivers/gpio/gpio-octeon.c
@@ -41,7 +41,7 @@ struct octeon_gpio {
 
 static int octeon_gpio_dir_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct octeon_gpio *gpio = container_of(chip, struct octeon_gpio, chip);
+        struct octeon_gpio *gpio = gpiochip_get_data(chip);
 
         cvmx_write_csr(gpio->register_base + bit_cfg_reg(offset), 0);
         return 0;
@@ -49,7 +49,7 @@ static int octeon_gpio_dir_in(struct gpio_chip *chip, unsigned offset)
 
 static void octeon_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct octeon_gpio *gpio = container_of(chip, struct octeon_gpio, chip);
+        struct octeon_gpio *gpio = gpiochip_get_data(chip);
         u64 mask = 1ull << offset;
         u64 reg = gpio->register_base + (value ? TX_SET : TX_CLEAR);
         cvmx_write_csr(reg, mask);
@@ -58,7 +58,7 @@ static void octeon_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 static int octeon_gpio_dir_out(struct gpio_chip *chip, unsigned offset,
                                int value)
 {
-        struct octeon_gpio *gpio = container_of(chip, struct octeon_gpio, chip);
+        struct octeon_gpio *gpio = gpiochip_get_data(chip);
         union cvmx_gpio_bit_cfgx cfgx;
 
         octeon_gpio_set(chip, offset, value);
@@ -72,7 +72,7 @@ static int octeon_gpio_dir_out(struct gpio_chip *chip, unsigned offset,
 
 static int octeon_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct octeon_gpio *gpio = container_of(chip, struct octeon_gpio, chip);
+        struct octeon_gpio *gpio = gpiochip_get_data(chip);
         u64 read_bits = cvmx_read_csr(gpio->register_base + RX_DAT);
 
         return ((1ull << offset) & read_bits) != 0;
@@ -108,7 +108,7 @@ static int octeon_gpio_probe(struct platform_device *pdev)
 
         pdev->dev.platform_data = chip;
         chip->label = "octeon-gpio";
-        chip->dev = &pdev->dev;
+        chip->parent = &pdev->dev;
         chip->owner = THIS_MODULE;
         chip->base = 0;
         chip->can_sleep = false;
@@ -117,7 +117,7 @@ static int octeon_gpio_probe(struct platform_device *pdev)
         chip->get = octeon_gpio_get;
         chip->direction_output = octeon_gpio_dir_out;
         chip->set = octeon_gpio_set;
-        err = gpiochip_add(chip);
+        err = gpiochip_add_data(chip, gpio);
         if (err)
                 goto out;
 
@@ -128,7 +128,7 @@ out:
 
 static int octeon_gpio_remove(struct platform_device *pdev)
 {
-        struct gpio_chip *chip = pdev->dev.platform_data;
+        struct gpio_chip *chip = dev_get_platdata(&pdev->dev);
         gpiochip_remove(chip);
         return 0;
 }
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
index f7fbb46d5d79..189f672bebc1 100644
--- a/drivers/gpio/gpio-omap.c
+++ b/drivers/gpio/gpio-omap.c
@@ -93,7 +93,7 @@ static void omap_gpio_unmask_irq(struct irq_data *d);
 static inline struct gpio_bank *omap_irq_data_get_bank(struct irq_data *d)
 {
         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
-        return container_of(chip, struct gpio_bank, chip);
+        return gpiochip_get_data(chip);
 }
 
 static void omap_set_gpio_direction(struct gpio_bank *bank, int gpio,
@@ -661,7 +661,7 @@ static int omap_gpio_wake_enable(struct irq_data *d, unsigned int enable)
 
 static int omap_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_bank *bank = container_of(chip, struct gpio_bank, chip);
+        struct gpio_bank *bank = gpiochip_get_data(chip);
         unsigned long flags;
 
         /*
@@ -681,7 +681,7 @@ static int omap_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void omap_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_bank *bank = container_of(chip, struct gpio_bank, chip);
+        struct gpio_bank *bank = gpiochip_get_data(chip);
         unsigned long flags;
 
         raw_spin_lock_irqsave(&bank->lock, flags);
@@ -954,7 +954,7 @@ static int omap_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
         void __iomem *reg;
         int dir;
 
-        bank = container_of(chip, struct gpio_bank, chip);
+        bank = gpiochip_get_data(chip);
         reg = bank->base + bank->regs->direction;
         raw_spin_lock_irqsave(&bank->lock, flags);
         dir = !!(readl_relaxed(reg) & BIT(offset));
@@ -967,7 +967,7 @@ static int omap_gpio_input(struct gpio_chip *chip, unsigned offset)
         struct gpio_bank *bank;
         unsigned long flags;
 
-        bank = container_of(chip, struct gpio_bank, chip);
+        bank = gpiochip_get_data(chip);
         raw_spin_lock_irqsave(&bank->lock, flags);
         omap_set_gpio_direction(bank, offset, 1);
         raw_spin_unlock_irqrestore(&bank->lock, flags);
@@ -978,7 +978,7 @@ static int omap_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
         struct gpio_bank *bank;
 
-        bank = container_of(chip, struct gpio_bank, chip);
+        bank = gpiochip_get_data(chip);
 
         if (omap_gpio_is_input(bank, offset))
                 return omap_get_gpio_datain(bank, offset);
@@ -991,7 +991,7 @@ static int omap_gpio_output(struct gpio_chip *chip, unsigned offset, int value)
         struct gpio_bank *bank;
         unsigned long flags;
 
-        bank = container_of(chip, struct gpio_bank, chip);
+        bank = gpiochip_get_data(chip);
         raw_spin_lock_irqsave(&bank->lock, flags);
         bank->set_dataout(bank, offset, value);
         omap_set_gpio_direction(bank, offset, 0);
@@ -1005,7 +1005,7 @@ static int omap_gpio_debounce(struct gpio_chip *chip, unsigned offset,
         struct gpio_bank *bank;
         unsigned long flags;
 
-        bank = container_of(chip, struct gpio_bank, chip);
+        bank = gpiochip_get_data(chip);
 
         raw_spin_lock_irqsave(&bank->lock, flags);
         omap2_set_gpio_debounce(bank, offset, debounce);
@@ -1019,7 +1019,7 @@ static void omap_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
         struct gpio_bank *bank;
         unsigned long flags;
 
-        bank = container_of(chip, struct gpio_bank, chip);
+        bank = gpiochip_get_data(chip);
         raw_spin_lock_irqsave(&bank->lock, flags);
         bank->set_dataout(bank, offset, value);
         raw_spin_unlock_irqrestore(&bank->lock, flags);
@@ -1090,7 +1090,7 @@ static int omap_gpio_chip_init(struct gpio_bank *bank, struct irq_chip *irqc)
         if (bank->is_mpuio) {
                 bank->chip.label = "mpuio";
                 if (bank->regs->wkup_en)
-                        bank->chip.dev = &omap_mpuio_device.dev;
+                        bank->chip.parent = &omap_mpuio_device.dev;
                 bank->chip.base = OMAP_MPUIO(0);
         } else {
                 bank->chip.label = "gpio";
@@ -1098,7 +1098,7 @@ static int omap_gpio_chip_init(struct gpio_bank *bank, struct irq_chip *irqc)
         }
         bank->chip.ngpio = bank->width;
 
-        ret = gpiochip_add(&bank->chip);
+        ret = gpiochip_add_data(&bank->chip, bank);
         if (ret) {
                 dev_err(bank->dev, "Could not register gpio chip %d\n", ret);
                 return ret;
@@ -1197,7 +1197,7 @@ static int omap_gpio_probe(struct platform_device *pdev)
         }
 
         bank->dev = dev;
-        bank->chip.dev = dev;
+        bank->chip.parent = dev;
         bank->chip.owner = THIS_MODULE;
         bank->dbck_flag = pdata->dbck_flag;
         bank->stride = pdata->bank_stride;
diff --git a/drivers/gpio/gpio-palmas.c b/drivers/gpio/gpio-palmas.c
index 52b447c071cb..fdfb3b1e0def 100644
--- a/drivers/gpio/gpio-palmas.c
+++ b/drivers/gpio/gpio-palmas.c
@@ -35,14 +35,9 @@ struct palmas_device_data {
         int ngpio;
 };
 
-static inline struct palmas_gpio *to_palmas_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct palmas_gpio, gpio_chip);
-}
-
 static int palmas_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct palmas_gpio *pg = to_palmas_gpio(gc);
+        struct palmas_gpio *pg = gpiochip_get_data(gc);
         struct palmas *palmas = pg->palmas;
         unsigned int val;
         int ret;
@@ -54,7 +49,7 @@ static int palmas_gpio_get(struct gpio_chip *gc, unsigned offset)
 
         ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val);
         if (ret < 0) {
-                dev_err(gc->dev, "Reg 0x%02x read failed, %d\n", reg, ret);
+                dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret);
                 return ret;
         }
 
@@ -65,7 +60,7 @@ static int palmas_gpio_get(struct gpio_chip *gc, unsigned offset)
 
         ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val);
         if (ret < 0) {
-                dev_err(gc->dev, "Reg 0x%02x read failed, %d\n", reg, ret);
+                dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret);
                 return ret;
         }
         return !!(val & BIT(offset));
@@ -74,7 +69,7 @@ static int palmas_gpio_get(struct gpio_chip *gc, unsigned offset)
 static void palmas_gpio_set(struct gpio_chip *gc, unsigned offset,
                         int value)
 {
-        struct palmas_gpio *pg = to_palmas_gpio(gc);
+        struct palmas_gpio *pg = gpiochip_get_data(gc);
         struct palmas *palmas = pg->palmas;
         int ret;
         unsigned int reg;
@@ -90,13 +85,13 @@ static void palmas_gpio_set(struct gpio_chip *gc, unsigned offset,
 
         ret = palmas_write(palmas, PALMAS_GPIO_BASE, reg, BIT(offset));
         if (ret < 0)
-                dev_err(gc->dev, "Reg 0x%02x write failed, %d\n", reg, ret);
+                dev_err(gc->parent, "Reg 0x%02x write failed, %d\n", reg, ret);
 }
 
 static int palmas_gpio_output(struct gpio_chip *gc, unsigned offset,
                                 int value)
 {
-        struct palmas_gpio *pg = to_palmas_gpio(gc);
+        struct palmas_gpio *pg = gpiochip_get_data(gc);
         struct palmas *palmas = pg->palmas;
         int ret;
         unsigned int reg;
@@ -111,13 +106,14 @@ static int palmas_gpio_output(struct gpio_chip *gc, unsigned offset,
         ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg,
                                 BIT(offset), BIT(offset));
         if (ret < 0)
-                dev_err(gc->dev, "Reg 0x%02x update failed, %d\n", reg, ret);
+                dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg,
+                        ret);
         return ret;
 }
 
 static int palmas_gpio_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct palmas_gpio *pg = to_palmas_gpio(gc);
+        struct palmas_gpio *pg = gpiochip_get_data(gc);
         struct palmas *palmas = pg->palmas;
         int ret;
         unsigned int reg;
@@ -128,13 +124,14 @@ static int palmas_gpio_input(struct gpio_chip *gc, unsigned offset)
 
         ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg, BIT(offset), 0);
         if (ret < 0)
-                dev_err(gc->dev, "Reg 0x%02x update failed, %d\n", reg, ret);
+                dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg,
+                        ret);
         return ret;
 }
 
 static int palmas_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct palmas_gpio *pg = to_palmas_gpio(gc);
+        struct palmas_gpio *pg = gpiochip_get_data(gc);
         struct palmas *palmas = pg->palmas;
 
         return palmas_irq_get_virq(palmas, PALMAS_GPIO_0_IRQ + offset);
@@ -188,7 +185,7 @@ static int palmas_gpio_probe(struct platform_device *pdev)
         palmas_gpio->gpio_chip.to_irq = palmas_gpio_to_irq;
         palmas_gpio->gpio_chip.set      = palmas_gpio_set;
         palmas_gpio->gpio_chip.get      = palmas_gpio_get;
-        palmas_gpio->gpio_chip.dev = &pdev->dev;
+        palmas_gpio->gpio_chip.parent = &pdev->dev;
 #ifdef CONFIG_OF_GPIO
         palmas_gpio->gpio_chip.of_node = pdev->dev.of_node;
 #endif
@@ -198,7 +195,7 @@ static int palmas_gpio_probe(struct platform_device *pdev)
         else
                 palmas_gpio->gpio_chip.base = -1;
 
-        ret = gpiochip_add(&palmas_gpio->gpio_chip);
+        ret = gpiochip_add_data(&palmas_gpio->gpio_chip, palmas_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c
index 2d4892cc70fb..23196c5fc17c 100644
--- a/drivers/gpio/gpio-pca953x.c
+++ b/drivers/gpio/gpio-pca953x.c
@@ -18,9 +18,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_data/pca953x.h>
 #include <linux/slab.h>
-#ifdef CONFIG_OF_GPIO
 #include <linux/of_platform.h>
-#endif
 #include <linux/acpi.h>
 
 #define PCA953X_INPUT           0
@@ -109,11 +107,6 @@ struct pca953x_chip {
         unsigned long driver_data;
 };
 
-static inline struct pca953x_chip *to_pca(struct gpio_chip *gc)
-{
-        return container_of(gc, struct pca953x_chip, gpio_chip);
-}
-
 static int pca953x_read_single(struct pca953x_chip *chip, int reg, u32 *val,
                                 int off)
 {
@@ -216,7 +209,7 @@ static int pca953x_read_regs(struct pca953x_chip *chip, int reg, u8 *val)
 
 static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
 {
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
         u8 reg_val;
         int ret, offset = 0;
 
@@ -245,7 +238,7 @@ exit:
 static int pca953x_gpio_direction_output(struct gpio_chip *gc,
                 unsigned off, int val)
 {
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
         u8 reg_val;
         int ret, offset = 0;
 
@@ -295,7 +288,7 @@ exit:
 
 static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
 {
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
         u32 reg_val;
         int ret, offset = 0;
 
@@ -323,7 +316,7 @@ static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
 
 static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
 {
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
         u8 reg_val;
         int ret, offset = 0;
 
@@ -352,6 +345,43 @@ exit:
         mutex_unlock(&chip->i2c_lock);
 }
 
+
+static void pca953x_gpio_set_multiple(struct gpio_chip *gc,
+                unsigned long *mask, unsigned long *bits)
+{
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
+        u8 reg_val[MAX_BANK];
+        int ret, offset = 0;
+        int bank_shift = fls((chip->gpio_chip.ngpio - 1) / BANK_SZ);
+        int bank;
+
+        switch (chip->chip_type) {
+        case PCA953X_TYPE:
+                offset = PCA953X_OUTPUT;
+                break;
+        case PCA957X_TYPE:
+                offset = PCA957X_OUT;
+                break;
+        }
+
+        memcpy(reg_val, chip->reg_output, NBANK(chip));
+        mutex_lock(&chip->i2c_lock);
+        for(bank=0; bank<NBANK(chip); bank++) {
+                unsigned bankmask = mask[bank/4] >> ((bank % 4) * 8);
+                if(bankmask) {
+                        unsigned bankval  = bits[bank/4] >> ((bank % 4) * 8);
+                        reg_val[bank] = (reg_val[bank] & ~bankmask) | bankval;
+                }
+        }
+        ret = i2c_smbus_write_i2c_block_data(chip->client, offset << bank_shift, NBANK(chip), reg_val);
+        if (ret)
+                goto exit;
+
+        memcpy(chip->reg_output, reg_val, NBANK(chip));
+exit:
+        mutex_unlock(&chip->i2c_lock);
+}
+
 static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
 {
         struct gpio_chip *gc;
@@ -362,12 +392,13 @@ static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
         gc->direction_output = pca953x_gpio_direction_output;
         gc->get = pca953x_gpio_get_value;
         gc->set = pca953x_gpio_set_value;
+        gc->set_multiple = pca953x_gpio_set_multiple;
         gc->can_sleep = true;
 
         gc->base = chip->gpio_start;
         gc->ngpio = gpios;
         gc->label = chip->client->name;
-        gc->dev = &chip->client->dev;
+        gc->parent = &chip->client->dev;
         gc->owner = THIS_MODULE;
         gc->names = chip->names;
 }
@@ -376,7 +407,7 @@ static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
 static void pca953x_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
 
         chip->irq_mask[d->hwirq / BANK_SZ] &= ~(1 << (d->hwirq % BANK_SZ));
 }
@@ -384,7 +415,7 @@ static void pca953x_irq_mask(struct irq_data *d)
 static void pca953x_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
 
         chip->irq_mask[d->hwirq / BANK_SZ] |= 1 << (d->hwirq % BANK_SZ);
 }
@@ -392,7 +423,7 @@ static void pca953x_irq_unmask(struct irq_data *d)
 static void pca953x_irq_bus_lock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
 
         mutex_lock(&chip->irq_lock);
 }
@@ -400,7 +431,7 @@ static void pca953x_irq_bus_lock(struct irq_data *d)
 static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
         u8 new_irqs;
         int level, i;
 
@@ -423,7 +454,7 @@ static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
 static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pca953x_chip *chip = to_pca(gc);
+        struct pca953x_chip *chip = gpiochip_get_data(gc);
         int bank_nb = d->hwirq / BANK_SZ;
         u8 mask = 1 << (d->hwirq % BANK_SZ);
 
@@ -660,6 +691,8 @@ out:
         return ret;
 }
 
+static const struct of_device_id pca953x_dt_ids[];
+
 static int pca953x_probe(struct i2c_client *client,
                                    const struct i2c_device_id *id)
 {
@@ -691,12 +724,18 @@ static int pca953x_probe(struct i2c_client *client,
                 chip->driver_data = id->driver_data;
         } else {
                 const struct acpi_device_id *id;
+                const struct of_device_id *match;
 
-                id = acpi_match_device(pca953x_acpi_ids, &client->dev);
-                if (!id)
-                        return -ENODEV;
+                match = of_match_device(pca953x_dt_ids, &client->dev);
+                if (match) {
+                        chip->driver_data = (int)(uintptr_t)match->data;
+                } else {
+                        id = acpi_match_device(pca953x_acpi_ids, &client->dev);
+                        if (!id)
+                                return -ENODEV;
 
-                chip->driver_data = id->driver_data;
+                        chip->driver_data = id->driver_data;
+                }
         }
 
         chip->chip_type = PCA_CHIP_TYPE(chip->driver_data);
@@ -715,7 +754,7 @@ static int pca953x_probe(struct i2c_client *client,
         if (ret)
                 return ret;
 
-        ret = gpiochip_add(&chip->gpio_chip);
+        ret = gpiochip_add_data(&chip->gpio_chip, chip);
         if (ret)
                 return ret;
 
@@ -755,33 +794,39 @@ static int pca953x_remove(struct i2c_client *client)
         return 0;
 }
 
+/* convenience to stop overlong match-table lines */
+#define OF_953X(__nrgpio, __int) (void *)(__nrgpio | PCA953X_TYPE | __int)
+#define OF_957X(__nrgpio, __int) (void *)(__nrgpio | PCA957X_TYPE | __int)
+
 static const struct of_device_id pca953x_dt_ids[] = {
-        { .compatible = "nxp,pca9505", },
-        { .compatible = "nxp,pca9534", },
-        { .compatible = "nxp,pca9535", },
-        { .compatible = "nxp,pca9536", },
-        { .compatible = "nxp,pca9537", },
-        { .compatible = "nxp,pca9538", },
-        { .compatible = "nxp,pca9539", },
-        { .compatible = "nxp,pca9554", },
-        { .compatible = "nxp,pca9555", },
-        { .compatible = "nxp,pca9556", },
-        { .compatible = "nxp,pca9557", },
-        { .compatible = "nxp,pca9574", },
-        { .compatible = "nxp,pca9575", },
-        { .compatible = "nxp,pca9698", },
-
-        { .compatible = "maxim,max7310", },
-        { .compatible = "maxim,max7312", },
-        { .compatible = "maxim,max7313", },
-        { .compatible = "maxim,max7315", },
-
-        { .compatible = "ti,pca6107", },
-        { .compatible = "ti,tca6408", },
-        { .compatible = "ti,tca6416", },
-        { .compatible = "ti,tca6424", },
-
-        { .compatible = "exar,xra1202", },
+        { .compatible = "nxp,pca9505", .data = OF_953X(40, PCA_INT), },
+        { .compatible = "nxp,pca9534", .data = OF_953X( 8, PCA_INT), },
+        { .compatible = "nxp,pca9535", .data = OF_953X(16, PCA_INT), },
+        { .compatible = "nxp,pca9536", .data = OF_953X( 4, 0), },
+        { .compatible = "nxp,pca9537", .data = OF_953X( 4, PCA_INT), },
+        { .compatible = "nxp,pca9538", .data = OF_953X( 8, PCA_INT), },
+        { .compatible = "nxp,pca9539", .data = OF_953X(16, PCA_INT), },
+        { .compatible = "nxp,pca9554", .data = OF_953X( 8, PCA_INT), },
+        { .compatible = "nxp,pca9555", .data = OF_953X(16, PCA_INT), },
+        { .compatible = "nxp,pca9556", .data = OF_953X( 8, 0), },
+        { .compatible = "nxp,pca9557", .data = OF_953X( 8, 0), },
+        { .compatible = "nxp,pca9574", .data = OF_957X( 8, PCA_INT), },
+        { .compatible = "nxp,pca9575", .data = OF_957X(16, PCA_INT), },
+        { .compatible = "nxp,pca9698", .data = OF_953X(40, 0), },
+
+        { .compatible = "maxim,max7310", .data = OF_953X( 8, 0), },
+        { .compatible = "maxim,max7312", .data = OF_953X(16, PCA_INT), },
+        { .compatible = "maxim,max7313", .data = OF_953X(16, PCA_INT), },
+        { .compatible = "maxim,max7315", .data = OF_953X( 8, PCA_INT), },
+
+        { .compatible = "ti,pca6107", .data = OF_953X( 8, PCA_INT), },
+        { .compatible = "ti,tca6408", .data = OF_953X( 8, PCA_INT), },
+        { .compatible = "ti,tca6416", .data = OF_953X(16, PCA_INT), },
+        { .compatible = "ti,tca6424", .data = OF_953X(24, PCA_INT), },
+
+        { .compatible = "onsemi,pca9654", .data = OF_953X( 8, PCA_INT), },
+
+        { .compatible = "exar,xra1202", .data = OF_953X( 8, 0), },
         { }
 };
 
diff --git a/drivers/gpio/gpio-pcf857x.c b/drivers/gpio/gpio-pcf857x.c
index 1d4d9bc8b69d..709cd3fc2a70 100644
--- a/drivers/gpio/gpio-pcf857x.c
+++ b/drivers/gpio/gpio-pcf857x.c
@@ -137,7 +137,7 @@ static int i2c_read_le16(struct i2c_client *client)
 
 static int pcf857x_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct pcf857x  *gpio = container_of(chip, struct pcf857x, chip);
+        struct pcf857x  *gpio = gpiochip_get_data(chip);
         int             status;
 
         mutex_lock(&gpio->lock);
@@ -150,16 +150,16 @@ static int pcf857x_input(struct gpio_chip *chip, unsigned offset)
 
 static int pcf857x_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct pcf857x  *gpio = container_of(chip, struct pcf857x, chip);
+        struct pcf857x  *gpio = gpiochip_get_data(chip);
         int             value;
 
         value = gpio->read(gpio->client);
-        return (value < 0) ? 0 : (value & (1 << offset));
+        return (value < 0) ? value : !!(value & (1 << offset));
 }
 
 static int pcf857x_output(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct pcf857x  *gpio = container_of(chip, struct pcf857x, chip);
+        struct pcf857x  *gpio = gpiochip_get_data(chip);
         unsigned        bit = 1 << offset;
         int             status;
 
@@ -293,7 +293,7 @@ static int pcf857x_probe(struct i2c_client *client,
 
         gpio->chip.base                 = pdata ? pdata->gpio_base : -1;
         gpio->chip.can_sleep            = true;
-        gpio->chip.dev                  = &client->dev;
+        gpio->chip.parent               = &client->dev;
         gpio->chip.owner                = THIS_MODULE;
         gpio->chip.get                  = pcf857x_get;
         gpio->chip.set                  = pcf857x_set;
@@ -372,7 +372,7 @@ static int pcf857x_probe(struct i2c_client *client,
         gpio->out = ~n_latch;
         gpio->status = gpio->out;
 
-        status = gpiochip_add(&gpio->chip);
+        status = gpiochip_add_data(&gpio->chip, gpio);
         if (status < 0)
                 goto fail;
 
@@ -447,7 +447,6 @@ static int pcf857x_remove(struct i2c_client *client)
 static struct i2c_driver pcf857x_driver = {
         .driver = {
                 .name   = "pcf857x",
-                .owner  = THIS_MODULE,
                 .of_match_table = of_match_ptr(pcf857x_of_table),
         },
         .probe  = pcf857x_probe,
diff --git a/drivers/gpio/gpio-pch.c b/drivers/gpio/gpio-pch.c
index 34ed176df15a..7c7135da5d4a 100644
--- a/drivers/gpio/gpio-pch.c
+++ b/drivers/gpio/gpio-pch.c
@@ -109,7 +109,7 @@ struct pch_gpio {
 static void pch_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
 {
         u32 reg_val;
-        struct pch_gpio *chip = container_of(gpio, struct pch_gpio, gpio);
+        struct pch_gpio *chip = gpiochip_get_data(gpio);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->spinlock, flags);
@@ -125,15 +125,15 @@ static void pch_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
 
 static int pch_gpio_get(struct gpio_chip *gpio, unsigned nr)
 {
-        struct pch_gpio *chip = container_of(gpio, struct pch_gpio, gpio);
+        struct pch_gpio *chip = gpiochip_get_data(gpio);
 
-        return ioread32(&chip->reg->pi) & (1 << nr);
+        return (ioread32(&chip->reg->pi) >> nr) & 1;
 }
 
 static int pch_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
                                      int val)
 {
-        struct pch_gpio *chip = container_of(gpio, struct pch_gpio, gpio);
+        struct pch_gpio *chip = gpiochip_get_data(gpio);
         u32 pm;
         u32 reg_val;
         unsigned long flags;
@@ -158,7 +158,7 @@ static int pch_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
 
 static int pch_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 {
-        struct pch_gpio *chip = container_of(gpio, struct pch_gpio, gpio);
+        struct pch_gpio *chip = gpiochip_get_data(gpio);
         u32 pm;
         unsigned long flags;
 
@@ -211,7 +211,7 @@ static void pch_gpio_restore_reg_conf(struct pch_gpio *chip)
 
 static int pch_gpio_to_irq(struct gpio_chip *gpio, unsigned offset)
 {
-        struct pch_gpio *chip = container_of(gpio, struct pch_gpio, gpio);
+        struct pch_gpio *chip = gpiochip_get_data(gpio);
         return chip->irq_base + offset;
 }
 
@@ -220,7 +220,7 @@ static void pch_gpio_setup(struct pch_gpio *chip)
         struct gpio_chip *gpio = &chip->gpio;
 
         gpio->label = dev_name(chip->dev);
-        gpio->dev = chip->dev;
+        gpio->parent = chip->dev;
         gpio->owner = THIS_MODULE;
         gpio->direction_input = pch_gpio_direction_input;
         gpio->get = pch_gpio_get;
@@ -394,7 +394,10 @@ static int pch_gpio_probe(struct pci_dev *pdev,
         pci_set_drvdata(pdev, chip);
         spin_lock_init(&chip->spinlock);
         pch_gpio_setup(chip);
-        ret = gpiochip_add(&chip->gpio);
+#ifdef CONFIG_OF_GPIO
+        chip->gpio.of_node = pdev->dev.of_node;
+#endif
+        ret = gpiochip_add_data(&chip->gpio, chip);
         if (ret) {
                 dev_err(&pdev->dev, "PCH gpio: Failed to register GPIO\n");
                 goto err_gpiochip_add;
diff --git a/drivers/gpio/gpio-pl061.c b/drivers/gpio/gpio-pl061.c
index 4d4b37676702..5cb38212bbc0 100644
--- a/drivers/gpio/gpio-pl061.c
+++ b/drivers/gpio/gpio-pl061.c
@@ -14,6 +14,7 @@
 #include <linux/module.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
+#include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/irqchip/chained_irq.h>
 #include <linux/bitops.h>
@@ -60,7 +61,7 @@ struct pl061_gpio {
 
 static int pl061_direction_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
         unsigned char gpiodir;
 
@@ -79,7 +80,7 @@ static int pl061_direction_input(struct gpio_chip *gc, unsigned offset)
 static int pl061_direction_output(struct gpio_chip *gc, unsigned offset,
                 int value)
 {
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
         unsigned char gpiodir;
 
@@ -104,14 +105,14 @@ static int pl061_direction_output(struct gpio_chip *gc, unsigned offset,
 
 static int pl061_get_value(struct gpio_chip *gc, unsigned offset)
 {
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
 
         return !!readb(chip->base + (BIT(offset + 2)));
 }
 
 static void pl061_set_value(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
 
         writeb(!!value << offset, chip->base + (BIT(offset + 2)));
 }
@@ -119,7 +120,7 @@ static void pl061_set_value(struct gpio_chip *gc, unsigned offset, int value)
 static int pl061_irq_type(struct irq_data *d, unsigned trigger)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
         int offset = irqd_to_hwirq(d);
         unsigned long flags;
         u8 gpiois, gpioibe, gpioiev;
@@ -131,7 +132,7 @@ static int pl061_irq_type(struct irq_data *d, unsigned trigger)
         if ((trigger & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) &&
             (trigger & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)))
         {
-                dev_err(gc->dev,
+                dev_err(gc->parent,
                         "trying to configure line %d for both level and edge "
                         "detection, choose one!\n",
                         offset);
@@ -158,7 +159,7 @@ static int pl061_irq_type(struct irq_data *d, unsigned trigger)
                 else
                         gpioiev &= ~bit;
                 irq_set_handler_locked(d, handle_level_irq);
-                dev_dbg(gc->dev, "line %d: IRQ on %s level\n",
+                dev_dbg(gc->parent, "line %d: IRQ on %s level\n",
                         offset,
                         polarity ? "HIGH" : "LOW");
         } else if ((trigger & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) {
@@ -167,7 +168,7 @@ static int pl061_irq_type(struct irq_data *d, unsigned trigger)
                 /* Select both edges, setting this makes GPIOEV be ignored */
                 gpioibe |= bit;
                 irq_set_handler_locked(d, handle_edge_irq);
-                dev_dbg(gc->dev, "line %d: IRQ on both edges\n", offset);
+                dev_dbg(gc->parent, "line %d: IRQ on both edges\n", offset);
         } else if ((trigger & IRQ_TYPE_EDGE_RISING) ||
                    (trigger & IRQ_TYPE_EDGE_FALLING)) {
                 bool rising = trigger & IRQ_TYPE_EDGE_RISING;
@@ -182,7 +183,7 @@ static int pl061_irq_type(struct irq_data *d, unsigned trigger)
                 else
                         gpioiev &= ~bit;
                 irq_set_handler_locked(d, handle_edge_irq);
-                dev_dbg(gc->dev, "line %d: IRQ on %s edge\n",
+                dev_dbg(gc->parent, "line %d: IRQ on %s edge\n",
                         offset,
                         rising ? "RISING" : "FALLING");
         } else {
@@ -191,7 +192,7 @@ static int pl061_irq_type(struct irq_data *d, unsigned trigger)
                 gpioibe &= ~bit;
                 gpioiev &= ~bit;
                 irq_set_handler_locked(d, handle_bad_irq);
-                dev_warn(gc->dev, "no trigger selected for line %d\n",
+                dev_warn(gc->parent, "no trigger selected for line %d\n",
                          offset);
         }
 
@@ -209,7 +210,7 @@ static void pl061_irq_handler(struct irq_desc *desc)
         unsigned long pending;
         int offset;
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
         struct irq_chip *irqchip = irq_desc_get_chip(desc);
 
         chained_irq_enter(irqchip, desc);
@@ -227,7 +228,7 @@ static void pl061_irq_handler(struct irq_desc *desc)
 static void pl061_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
         u8 mask = BIT(irqd_to_hwirq(d) % PL061_GPIO_NR);
         u8 gpioie;
 
@@ -240,7 +241,7 @@ static void pl061_irq_mask(struct irq_data *d)
 static void pl061_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
         u8 mask = BIT(irqd_to_hwirq(d) % PL061_GPIO_NR);
         u8 gpioie;
 
@@ -261,7 +262,7 @@ static void pl061_irq_unmask(struct irq_data *d)
 static void pl061_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        struct pl061_gpio *chip = gpiochip_get_data(gc);
         u8 mask = BIT(irqd_to_hwirq(d) % PL061_GPIO_NR);
 
         spin_lock(&chip->lock);
@@ -269,12 +270,20 @@ static void pl061_irq_ack(struct irq_data *d)
         spin_unlock(&chip->lock);
 }
 
+static int pl061_irq_set_wake(struct irq_data *d, unsigned int state)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+
+        return irq_set_irq_wake(gc->irq_parent, state);
+}
+
 static struct irq_chip pl061_irqchip = {
         .name           = "pl061",
         .irq_ack        = pl061_irq_ack,
         .irq_mask       = pl061_irq_mask,
         .irq_unmask     = pl061_irq_unmask,
         .irq_set_type   = pl061_irq_type,
+        .irq_set_wake   = pl061_irq_set_wake,
 };
 
 static int pl061_probe(struct amba_device *adev, const struct amba_id *id)
@@ -316,10 +325,10 @@ static int pl061_probe(struct amba_device *adev, const struct amba_id *id)
         chip->gc.set = pl061_set_value;
         chip->gc.ngpio = PL061_GPIO_NR;
         chip->gc.label = dev_name(dev);
-        chip->gc.dev = dev;
+        chip->gc.parent = dev;
         chip->gc.owner = THIS_MODULE;
 
-        ret = gpiochip_add(&chip->gc);
+        ret = gpiochip_add_data(&chip->gc, chip);
         if (ret)
                 return ret;
 
diff --git a/drivers/gpio/gpio-pxa.c b/drivers/gpio/gpio-pxa.c
index df2ce550f309..b2b7b78664b8 100644
--- a/drivers/gpio/gpio-pxa.c
+++ b/drivers/gpio/gpio-pxa.c
@@ -24,6 +24,7 @@
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pinctrl/consumer.h>
 #include <linux/platform_device.h>
 #include <linux/syscore_ops.h>
 #include <linux/slab.h>
@@ -64,20 +65,11 @@
 int pxa_last_gpio;
 static int irq_base;
 
-#ifdef CONFIG_OF
-static struct irq_domain *domain;
-static struct device_node *pxa_gpio_of_node;
-#endif
-
-struct pxa_gpio_chip {
-        struct gpio_chip chip;
+struct pxa_gpio_bank {
         void __iomem    *regbase;
-        char label[10];
-
         unsigned long   irq_mask;
         unsigned long   irq_edge_rise;
         unsigned long   irq_edge_fall;
-        int (*set_wake)(unsigned int gpio, unsigned int on);
 
 #ifdef CONFIG_PM
         unsigned long   saved_gplr;
@@ -87,6 +79,17 @@ struct pxa_gpio_chip {
 #endif
 };
 
+struct pxa_gpio_chip {
+        struct device *dev;
+        struct gpio_chip chip;
+        struct pxa_gpio_bank *banks;
+        struct irq_domain *irqdomain;
+
+        int irq0;
+        int irq1;
+        int (*set_wake)(unsigned int gpio, unsigned int on);
+};
+
 enum pxa_gpio_type {
         PXA25X_GPIO = 0,
         PXA26X_GPIO,
@@ -104,9 +107,8 @@ struct pxa_gpio_id {
 };
 
 static DEFINE_SPINLOCK(gpio_lock);
-static struct pxa_gpio_chip *pxa_gpio_chips;
+static struct pxa_gpio_chip *pxa_gpio_chip;
 static enum pxa_gpio_type gpio_type;
-static void __iomem *gpio_reg_base;
 
 static struct pxa_gpio_id pxa25x_id = {
         .type           = PXA25X_GPIO,
@@ -148,17 +150,28 @@ static struct pxa_gpio_id pxa1928_id = {
         .gpio_nums      = 224,
 };
 
-#define for_each_gpio_chip(i, c)                        \
-        for (i = 0, c = &pxa_gpio_chips[0]; i <= pxa_last_gpio; i += 32, c++)
+#define for_each_gpio_bank(i, b, pc)                                    \
+        for (i = 0, b = pc->banks; i <= pxa_last_gpio; i += 32, b++)
 
-static inline void __iomem *gpio_chip_base(struct gpio_chip *c)
+static inline struct pxa_gpio_chip *chip_to_pxachip(struct gpio_chip *c)
 {
-        return container_of(c, struct pxa_gpio_chip, chip)->regbase;
+        struct pxa_gpio_chip *pxa_chip = gpiochip_get_data(c);
+
+        return pxa_chip;
 }
 
-static inline struct pxa_gpio_chip *gpio_to_pxachip(unsigned gpio)
+static inline void __iomem *gpio_bank_base(struct gpio_chip *c, int gpio)
 {
-        return &pxa_gpio_chips[gpio_to_bank(gpio)];
+        struct pxa_gpio_chip *p = gpiochip_get_data(c);
+        struct pxa_gpio_bank *bank = p->banks + (gpio / 32);
+
+        return bank->regbase;
+}
+
+static inline struct pxa_gpio_bank *gpio_to_pxabank(struct gpio_chip *c,
+                                                    unsigned gpio)
+{
+        return chip_to_pxachip(c)->banks + gpio / 32;
 }
 
 static inline int gpio_is_pxa_type(int type)
@@ -187,15 +200,13 @@ static inline int __gpio_is_inverted(int gpio)
  * is attributed as "occupied" here (I know this terminology isn't
  * accurate, you are welcome to propose a better one :-)
  */
-static inline int __gpio_is_occupied(unsigned gpio)
+static inline int __gpio_is_occupied(struct pxa_gpio_chip *pchip, unsigned gpio)
 {
-        struct pxa_gpio_chip *pxachip;
         void __iomem *base;
         unsigned long gafr = 0, gpdr = 0;
         int ret, af = 0, dir = 0;
 
-        pxachip = gpio_to_pxachip(gpio);
-        base = gpio_chip_base(&pxachip->chip);
+        base = gpio_bank_base(&pchip->chip, gpio);
         gpdr = readl_relaxed(base + GPDR_OFFSET);
 
         switch (gpio_type) {
@@ -218,21 +229,35 @@ static inline int __gpio_is_occupied(unsigned gpio)
         return ret;
 }
 
-static int pxa_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+int pxa_irq_to_gpio(int irq)
 {
-        return chip->base + offset + irq_base;
+        struct pxa_gpio_chip *pchip = pxa_gpio_chip;
+        int irq_gpio0;
+
+        irq_gpio0 = irq_find_mapping(pchip->irqdomain, 0);
+        if (irq_gpio0 > 0)
+                return irq - irq_gpio0;
+
+        return irq_gpio0;
 }
 
-int pxa_irq_to_gpio(int irq)
+static int pxa_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        return irq - irq_base;
+        struct pxa_gpio_chip *pchip = chip_to_pxachip(chip);
+
+        return irq_find_mapping(pchip->irqdomain, offset);
 }
 
 static int pxa_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        void __iomem *base = gpio_chip_base(chip);
-        uint32_t value, mask = 1 << offset;
+        void __iomem *base = gpio_bank_base(chip, offset);
+        uint32_t value, mask = GPIO_bit(offset);
         unsigned long flags;
+        int ret;
+
+        ret = pinctrl_gpio_direction_input(chip->base + offset);
+        if (!ret)
+                return 0;
 
         spin_lock_irqsave(&gpio_lock, flags);
 
@@ -250,12 +275,17 @@ static int pxa_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int pxa_gpio_direction_output(struct gpio_chip *chip,
                                      unsigned offset, int value)
 {
-        void __iomem *base = gpio_chip_base(chip);
-        uint32_t tmp, mask = 1 << offset;
+        void __iomem *base = gpio_bank_base(chip, offset);
+        uint32_t tmp, mask = GPIO_bit(offset);
         unsigned long flags;
+        int ret;
 
         writel_relaxed(mask, base + (value ? GPSR_OFFSET : GPCR_OFFSET));
 
+        ret = pinctrl_gpio_direction_output(chip->base + offset);
+        if (!ret)
+                return 0;
+
         spin_lock_irqsave(&gpio_lock, flags);
 
         tmp = readl_relaxed(base + GPDR_OFFSET);
@@ -271,14 +301,18 @@ static int pxa_gpio_direction_output(struct gpio_chip *chip,
 
 static int pxa_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        u32 gplr = readl_relaxed(gpio_chip_base(chip) + GPLR_OFFSET);
-        return !!(gplr & (1 << offset));
+        void __iomem *base = gpio_bank_base(chip, offset);
+        u32 gplr = readl_relaxed(base + GPLR_OFFSET);
+
+        return !!(gplr & GPIO_bit(offset));
 }
 
 static void pxa_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        writel_relaxed(1 << offset, gpio_chip_base(chip) +
-                                (value ? GPSR_OFFSET : GPCR_OFFSET));
+        void __iomem *base = gpio_bank_base(chip, offset);
+
+        writel_relaxed(GPIO_bit(offset),
+                       base + (value ? GPSR_OFFSET : GPCR_OFFSET));
 }
 
 #ifdef CONFIG_OF_GPIO
@@ -289,61 +323,61 @@ static int pxa_gpio_of_xlate(struct gpio_chip *gc,
         if (gpiospec->args[0] > pxa_last_gpio)
                 return -EINVAL;
 
-        if (gc != &pxa_gpio_chips[gpiospec->args[0] / 32].chip)
-                return -EINVAL;
-
         if (flags)
                 *flags = gpiospec->args[1];
 
-        return gpiospec->args[0] % 32;
+        return gpiospec->args[0];
 }
 #endif
 
-static int pxa_init_gpio_chip(int gpio_end,
-                                        int (*set_wake)(unsigned int, unsigned int))
+static int pxa_gpio_request(struct gpio_chip *chip, unsigned int offset)
 {
-        int i, gpio, nbanks = gpio_to_bank(gpio_end) + 1;
-        struct pxa_gpio_chip *chips;
-
-        chips = kzalloc(nbanks * sizeof(struct pxa_gpio_chip), GFP_KERNEL);
-        if (chips == NULL) {
-                pr_err("%s: failed to allocate GPIO chips\n", __func__);
-                return -ENOMEM;
-        }
+        return pinctrl_request_gpio(chip->base + offset);
+}
 
-        for (i = 0, gpio = 0; i < nbanks; i++, gpio += 32) {
-                struct gpio_chip *c = &chips[i].chip;
+static void pxa_gpio_free(struct gpio_chip *chip, unsigned int offset)
+{
+        pinctrl_free_gpio(chip->base + offset);
+}
 
-                sprintf(chips[i].label, "gpio-%d", i);
-                chips[i].regbase = gpio_reg_base + BANK_OFF(i);
-                chips[i].set_wake = set_wake;
+static int pxa_init_gpio_chip(struct pxa_gpio_chip *pchip, int ngpio,
+                              struct device_node *np, void __iomem *regbase)
+{
+        int i, gpio, nbanks = DIV_ROUND_UP(ngpio, 32);
+        struct pxa_gpio_bank *bank;
 
-                c->base  = gpio;
-                c->label = chips[i].label;
+        pchip->banks = devm_kcalloc(pchip->dev, nbanks, sizeof(*pchip->banks),
+                                    GFP_KERNEL);
+        if (!pchip->banks)
+                return -ENOMEM;
 
-                c->direction_input  = pxa_gpio_direction_input;
-                c->direction_output = pxa_gpio_direction_output;
-                c->get = pxa_gpio_get;
-                c->set = pxa_gpio_set;
-                c->to_irq = pxa_gpio_to_irq;
+        pchip->chip.label = "gpio-pxa";
+        pchip->chip.direction_input  = pxa_gpio_direction_input;
+        pchip->chip.direction_output = pxa_gpio_direction_output;
+        pchip->chip.get = pxa_gpio_get;
+        pchip->chip.set = pxa_gpio_set;
+        pchip->chip.to_irq = pxa_gpio_to_irq;
+        pchip->chip.ngpio = ngpio;
+        pchip->chip.request = pxa_gpio_request;
+        pchip->chip.free = pxa_gpio_free;
 #ifdef CONFIG_OF_GPIO
-                c->of_node = pxa_gpio_of_node;
-                c->of_xlate = pxa_gpio_of_xlate;
-                c->of_gpio_n_cells = 2;
+        pchip->chip.of_node = np;
+        pchip->chip.of_xlate = pxa_gpio_of_xlate;
+        pchip->chip.of_gpio_n_cells = 2;
 #endif
 
-                /* number of GPIOs on last bank may be less than 32 */
-                c->ngpio = (gpio + 31 > gpio_end) ? (gpio_end - gpio + 1) : 32;
-                gpiochip_add(c);
+        for (i = 0, gpio = 0; i < nbanks; i++, gpio += 32) {
+                bank = pchip->banks + i;
+                bank->regbase = regbase + BANK_OFF(i);
         }
-        pxa_gpio_chips = chips;
-        return 0;
+
+        return gpiochip_add_data(&pchip->chip, pchip);
 }
 
 /* Update only those GRERx and GFERx edge detection register bits if those
  * bits are set in c->irq_mask
  */
-static inline void update_edge_detect(struct pxa_gpio_chip *c)
+static inline void update_edge_detect(struct pxa_gpio_bank *c)
 {
         uint32_t grer, gfer;
 
@@ -357,12 +391,11 @@ static inline void update_edge_detect(struct pxa_gpio_chip *c)
 
 static int pxa_gpio_irq_type(struct irq_data *d, unsigned int type)
 {
-        struct pxa_gpio_chip *c;
-        int gpio = pxa_irq_to_gpio(d->irq);
+        struct pxa_gpio_chip *pchip = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irqd_to_hwirq(d);
+        struct pxa_gpio_bank *c = gpio_to_pxabank(&pchip->chip, gpio);
         unsigned long gpdr, mask = GPIO_bit(gpio);
 
-        c = gpio_to_pxachip(gpio);
-
         if (type == IRQ_TYPE_PROBE) {
                 /* Don't mess with enabled GPIOs using preconfigured edges or
                  * GPIOs set to alternate function or to output during probe
@@ -370,7 +403,7 @@ static int pxa_gpio_irq_type(struct irq_data *d, unsigned int type)
                 if ((c->irq_edge_rise | c->irq_edge_fall) & GPIO_bit(gpio))
                         return 0;
 
-                if (__gpio_is_occupied(gpio))
+                if (__gpio_is_occupied(pchip, gpio))
                         return 0;
 
                 type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
@@ -401,20 +434,16 @@ static int pxa_gpio_irq_type(struct irq_data *d, unsigned int type)
         return 0;
 }
 
-static void pxa_gpio_demux_handler(struct irq_desc *desc)
+static irqreturn_t pxa_gpio_demux_handler(int in_irq, void *d)
 {
-        struct pxa_gpio_chip *c;
-        int loop, gpio, gpio_base, n;
+        int loop, gpio, n, handled = 0;
         unsigned long gedr;
-        struct irq_chip *chip = irq_desc_get_chip(desc);
-
-        chained_irq_enter(chip, desc);
+        struct pxa_gpio_chip *pchip = d;
+        struct pxa_gpio_bank *c;
 
         do {
                 loop = 0;
-                for_each_gpio_chip(gpio, c) {
-                        gpio_base = c->chip.base;
-
+                for_each_gpio_bank(gpio, c, pchip) {
                         gedr = readl_relaxed(c->regbase + GEDR_OFFSET);
                         gedr = gedr & c->irq_mask;
                         writel_relaxed(gedr, c->regbase + GEDR_OFFSET);
@@ -422,51 +451,71 @@ static void pxa_gpio_demux_handler(struct irq_desc *desc)
                         for_each_set_bit(n, &gedr, BITS_PER_LONG) {
                                 loop = 1;
 
-                                generic_handle_irq(gpio_to_irq(gpio_base + n));
+                                generic_handle_irq(gpio_to_irq(gpio + n));
                         }
                 }
+                handled += loop;
         } while (loop);
 
-        chained_irq_exit(chip, desc);
+        return handled ? IRQ_HANDLED : IRQ_NONE;
+}
+
+static irqreturn_t pxa_gpio_direct_handler(int in_irq, void *d)
+{
+        struct pxa_gpio_chip *pchip = d;
+
+        if (in_irq == pchip->irq0) {
+                generic_handle_irq(gpio_to_irq(0));
+        } else if (in_irq == pchip->irq1) {
+                generic_handle_irq(gpio_to_irq(1));
+        } else {
+                pr_err("%s() unknown irq %d\n", __func__, in_irq);
+                return IRQ_NONE;
+        }
+        return IRQ_HANDLED;
 }
 
 static void pxa_ack_muxed_gpio(struct irq_data *d)
 {
-        int gpio = pxa_irq_to_gpio(d->irq);
-        struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
+        struct pxa_gpio_chip *pchip = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irqd_to_hwirq(d);
+        void __iomem *base = gpio_bank_base(&pchip->chip, gpio);
 
-        writel_relaxed(GPIO_bit(gpio), c->regbase + GEDR_OFFSET);
+        writel_relaxed(GPIO_bit(gpio), base + GEDR_OFFSET);
 }
 
 static void pxa_mask_muxed_gpio(struct irq_data *d)
 {
-        int gpio = pxa_irq_to_gpio(d->irq);
-        struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
+        struct pxa_gpio_chip *pchip = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irqd_to_hwirq(d);
+        struct pxa_gpio_bank *b = gpio_to_pxabank(&pchip->chip, gpio);
+        void __iomem *base = gpio_bank_base(&pchip->chip, gpio);
         uint32_t grer, gfer;
 
-        c->irq_mask &= ~GPIO_bit(gpio);
+        b->irq_mask &= ~GPIO_bit(gpio);
 
-        grer = readl_relaxed(c->regbase + GRER_OFFSET) & ~GPIO_bit(gpio);
-        gfer = readl_relaxed(c->regbase + GFER_OFFSET) & ~GPIO_bit(gpio);
-        writel_relaxed(grer, c->regbase + GRER_OFFSET);
-        writel_relaxed(gfer, c->regbase + GFER_OFFSET);
+        grer = readl_relaxed(base + GRER_OFFSET) & ~GPIO_bit(gpio);
+        gfer = readl_relaxed(base + GFER_OFFSET) & ~GPIO_bit(gpio);
+        writel_relaxed(grer, base + GRER_OFFSET);
+        writel_relaxed(gfer, base + GFER_OFFSET);
 }
 
 static int pxa_gpio_set_wake(struct irq_data *d, unsigned int on)
 {
-        int gpio = pxa_irq_to_gpio(d->irq);
-        struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
+        struct pxa_gpio_chip *pchip = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irqd_to_hwirq(d);
 
-        if (c->set_wake)
-                return c->set_wake(gpio, on);
+        if (pchip->set_wake)
+                return pchip->set_wake(gpio, on);
         else
                 return 0;
 }
 
 static void pxa_unmask_muxed_gpio(struct irq_data *d)
 {
-        int gpio = pxa_irq_to_gpio(d->irq);
-        struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
+        struct pxa_gpio_chip *pchip = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irqd_to_hwirq(d);
+        struct pxa_gpio_bank *c = gpio_to_pxabank(&pchip->chip, gpio);
 
         c->irq_mask |= GPIO_bit(gpio);
         update_edge_detect(c);
@@ -506,24 +555,12 @@ static int pxa_gpio_nums(struct platform_device *pdev)
         return count;
 }
 
-#ifdef CONFIG_OF
-static const struct of_device_id pxa_gpio_dt_ids[] = {
-        { .compatible = "intel,pxa25x-gpio",    .data = &pxa25x_id, },
-        { .compatible = "intel,pxa26x-gpio",    .data = &pxa26x_id, },
-        { .compatible = "intel,pxa27x-gpio",    .data = &pxa27x_id, },
-        { .compatible = "intel,pxa3xx-gpio",    .data = &pxa3xx_id, },
-        { .compatible = "marvell,pxa93x-gpio",  .data = &pxa93x_id, },
-        { .compatible = "marvell,mmp-gpio",     .data = &mmp_id, },
-        { .compatible = "marvell,mmp2-gpio",    .data = &mmp2_id, },
-        { .compatible = "marvell,pxa1928-gpio", .data = &pxa1928_id, },
-        {}
-};
-
 static int pxa_irq_domain_map(struct irq_domain *d, unsigned int irq,
                               irq_hw_number_t hw)
 {
         irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
                                  handle_edge_irq);
+        irq_set_chip_data(irq, d->host_data);
         irq_set_noprobe(irq);
         return 0;
 }
@@ -533,10 +570,23 @@ const struct irq_domain_ops pxa_irq_domain_ops = {
         .xlate  = irq_domain_xlate_twocell,
 };
 
-static int pxa_gpio_probe_dt(struct platform_device *pdev)
+#ifdef CONFIG_OF
+static const struct of_device_id pxa_gpio_dt_ids[] = {
+        { .compatible = "intel,pxa25x-gpio",    .data = &pxa25x_id, },
+        { .compatible = "intel,pxa26x-gpio",    .data = &pxa26x_id, },
+        { .compatible = "intel,pxa27x-gpio",    .data = &pxa27x_id, },
+        { .compatible = "intel,pxa3xx-gpio",    .data = &pxa3xx_id, },
+        { .compatible = "marvell,pxa93x-gpio",  .data = &pxa93x_id, },
+        { .compatible = "marvell,mmp-gpio",     .data = &mmp_id, },
+        { .compatible = "marvell,mmp2-gpio",    .data = &mmp2_id, },
+        { .compatible = "marvell,pxa1928-gpio", .data = &pxa1928_id, },
+        {}
+};
+
+static int pxa_gpio_probe_dt(struct platform_device *pdev,
+                             struct pxa_gpio_chip *pchip)
 {
-        int ret = 0, nr_gpios;
-        struct device_node *np = pdev->dev.of_node;
+        int nr_gpios;
         const struct of_device_id *of_id =
                                 of_match_device(pxa_gpio_dt_ids, &pdev->dev);
         const struct pxa_gpio_id *gpio_id;
@@ -554,57 +604,64 @@ static int pxa_gpio_probe_dt(struct platform_device *pdev)
         irq_base = irq_alloc_descs(-1, 0, nr_gpios, 0);
         if (irq_base < 0) {
                 dev_err(&pdev->dev, "Failed to allocate IRQ numbers\n");
-                ret = irq_base;
-                goto err;
+                return irq_base;
         }
-        domain = irq_domain_add_legacy(np, nr_gpios, irq_base, 0,
-                                       &pxa_irq_domain_ops, NULL);
-        pxa_gpio_of_node = np;
-        return 0;
-err:
-        iounmap(gpio_reg_base);
-        return ret;
+        return irq_base;
 }
 #else
-#define pxa_gpio_probe_dt(pdev)         (-1)
+#define pxa_gpio_probe_dt(pdev, pchip)          (-1)
 #endif
 
 static int pxa_gpio_probe(struct platform_device *pdev)
 {
-        struct pxa_gpio_chip *c;
+        struct pxa_gpio_chip *pchip;
+        struct pxa_gpio_bank *c;
         struct resource *res;
         struct clk *clk;
         struct pxa_gpio_platform_data *info;
-        int gpio, irq, ret, use_of = 0;
+        void __iomem *gpio_reg_base;
+        int gpio, ret;
         int irq0 = 0, irq1 = 0, irq_mux, gpio_offset = 0;
 
+        pchip = devm_kzalloc(&pdev->dev, sizeof(*pchip), GFP_KERNEL);
+        if (!pchip)
+                return -ENOMEM;
+        pchip->dev = &pdev->dev;
+
         info = dev_get_platdata(&pdev->dev);
         if (info) {
                 irq_base = info->irq_base;
                 if (irq_base <= 0)
                         return -EINVAL;
                 pxa_last_gpio = pxa_gpio_nums(pdev);
+                pchip->set_wake = info->gpio_set_wake;
         } else {
-                irq_base = 0;
-                use_of = 1;
-                ret = pxa_gpio_probe_dt(pdev);
-                if (ret < 0)
+                irq_base = pxa_gpio_probe_dt(pdev, pchip);
+                if (irq_base < 0)
                         return -EINVAL;
         }
 
         if (!pxa_last_gpio)
                 return -EINVAL;
 
+        pchip->irqdomain = irq_domain_add_legacy(pdev->dev.of_node,
+                                                 pxa_last_gpio + 1, irq_base,
+                                                 0, &pxa_irq_domain_ops, pchip);
+        if (!pchip->irqdomain)
+                return -ENOMEM;
+
         irq0 = platform_get_irq_byname(pdev, "gpio0");
         irq1 = platform_get_irq_byname(pdev, "gpio1");
         irq_mux = platform_get_irq_byname(pdev, "gpio_mux");
         if ((irq0 > 0 && irq1 <= 0) || (irq0 <= 0 && irq1 > 0)
                 || (irq_mux <= 0))
                 return -EINVAL;
+
+        pchip->irq0 = irq0;
+        pchip->irq1 = irq1;
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -EINVAL;
-        gpio_reg_base = ioremap(res->start, resource_size(res));
+        gpio_reg_base = devm_ioremap(&pdev->dev, res->start,
+                                     resource_size(res));
         if (!gpio_reg_base)
                 return -EINVAL;
 
@@ -615,21 +672,24 @@ static int pxa_gpio_probe(struct platform_device *pdev)
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "Error %ld to get gpio clock\n",
                         PTR_ERR(clk));
-                iounmap(gpio_reg_base);
                 return PTR_ERR(clk);
         }
         ret = clk_prepare_enable(clk);
         if (ret) {
                 clk_put(clk);
-                iounmap(gpio_reg_base);
                 return ret;
         }
 
         /* Initialize GPIO chips */
-        pxa_init_gpio_chip(pxa_last_gpio, info ? info->gpio_set_wake : NULL);
+        ret = pxa_init_gpio_chip(pchip, pxa_last_gpio + 1, pdev->dev.of_node,
+                                 gpio_reg_base);
+        if (ret) {
+                clk_put(clk);
+                return ret;
+        }
 
         /* clear all GPIO edge detects */
-        for_each_gpio_chip(gpio, c) {
+        for_each_gpio_bank(gpio, c, pchip) {
                 writel_relaxed(0, c->regbase + GFER_OFFSET);
                 writel_relaxed(0, c->regbase + GRER_OFFSET);
                 writel_relaxed(~0, c->regbase + GEDR_OFFSET);
@@ -638,34 +698,31 @@ static int pxa_gpio_probe(struct platform_device *pdev)
                         writel_relaxed(~0, c->regbase + ED_MASK_OFFSET);
         }
 
-        if (!use_of) {
-                if (irq0 > 0) {
-                        irq = gpio_to_irq(0);
-                        irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
-                                                 handle_edge_irq);
-                        irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
-                }
-                if (irq1 > 0) {
-                        irq = gpio_to_irq(1);
-                        irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
-                                                 handle_edge_irq);
-                        irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
-                }
-
-                for (irq  = gpio_to_irq(gpio_offset);
-                        irq <= gpio_to_irq(pxa_last_gpio); irq++) {
-                        irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
-                                                 handle_edge_irq);
-                        irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
-                }
+        if (irq0 > 0) {
+                ret = devm_request_irq(&pdev->dev,
+                                       irq0, pxa_gpio_direct_handler, 0,
+                                       "gpio-0", pchip);
+                if (ret)
+                        dev_err(&pdev->dev, "request of gpio0 irq failed: %d\n",
+                                ret);
         }
+        if (irq1 > 0) {
+                ret = devm_request_irq(&pdev->dev,
+                                       irq1, pxa_gpio_direct_handler, 0,
+                                       "gpio-1", pchip);
+                if (ret)
+                        dev_err(&pdev->dev, "request of gpio1 irq failed: %d\n",
+                                ret);
+        }
+        ret = devm_request_irq(&pdev->dev,
+                               irq_mux, pxa_gpio_demux_handler, 0,
+                                       "gpio-mux", pchip);
+        if (ret)
+                dev_err(&pdev->dev, "request of gpio-mux irq failed: %d\n",
+                                ret);
 
-        if (irq0 > 0)
-                irq_set_chained_handler(irq0, pxa_gpio_demux_handler);
-        if (irq1 > 0)
-                irq_set_chained_handler(irq1, pxa_gpio_demux_handler);
+        pxa_gpio_chip = pchip;
 
-        irq_set_chained_handler(irq_mux, pxa_gpio_demux_handler);
         return 0;
 }
 
@@ -690,19 +747,32 @@ static struct platform_driver pxa_gpio_driver = {
         .id_table       = gpio_id_table,
 };
 
-static int __init pxa_gpio_init(void)
+static int __init pxa_gpio_legacy_init(void)
 {
+        if (of_have_populated_dt())
+                return 0;
+
         return platform_driver_register(&pxa_gpio_driver);
 }
-postcore_initcall(pxa_gpio_init);
+postcore_initcall(pxa_gpio_legacy_init);
+
+static int __init pxa_gpio_dt_init(void)
+{
+        if (of_have_populated_dt())
+                return platform_driver_register(&pxa_gpio_driver);
+
+        return 0;
+}
+device_initcall(pxa_gpio_dt_init);
 
 #ifdef CONFIG_PM
 static int pxa_gpio_suspend(void)
 {
-        struct pxa_gpio_chip *c;
+        struct pxa_gpio_chip *pchip = pxa_gpio_chip;
+        struct pxa_gpio_bank *c;
         int gpio;
 
-        for_each_gpio_chip(gpio, c) {
+        for_each_gpio_bank(gpio, c, pchip) {
                 c->saved_gplr = readl_relaxed(c->regbase + GPLR_OFFSET);
                 c->saved_gpdr = readl_relaxed(c->regbase + GPDR_OFFSET);
                 c->saved_grer = readl_relaxed(c->regbase + GRER_OFFSET);
@@ -716,10 +786,11 @@ static int pxa_gpio_suspend(void)
 
 static void pxa_gpio_resume(void)
 {
-        struct pxa_gpio_chip *c;
+        struct pxa_gpio_chip *pchip = pxa_gpio_chip;
+        struct pxa_gpio_bank *c;
         int gpio;
 
-        for_each_gpio_chip(gpio, c) {
+        for_each_gpio_bank(gpio, c, pchip) {
                 /* restore level with set/clear */
                 writel_relaxed(c->saved_gplr, c->regbase + GPSR_OFFSET);
                 writel_relaxed(~c->saved_gplr, c->regbase + GPCR_OFFSET);
diff --git a/drivers/gpio/gpio-rc5t583.c b/drivers/gpio/gpio-rc5t583.c
index 6eabf239676b..1e2d210b3369 100644
--- a/drivers/gpio/gpio-rc5t583.c
+++ b/drivers/gpio/gpio-rc5t583.c
@@ -34,14 +34,9 @@ struct rc5t583_gpio {
         struct rc5t583 *rc5t583;
 };
 
-static inline struct rc5t583_gpio *to_rc5t583_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct rc5t583_gpio, gpio_chip);
-}
-
 static int rc5t583_gpio_get(struct gpio_chip *gc, unsigned int offset)
 {
-        struct rc5t583_gpio *rc5t583_gpio = to_rc5t583_gpio(gc);
+        struct rc5t583_gpio *rc5t583_gpio = gpiochip_get_data(gc);
         struct device *parent = rc5t583_gpio->rc5t583->dev;
         uint8_t val = 0;
         int ret;
@@ -55,7 +50,7 @@ static int rc5t583_gpio_get(struct gpio_chip *gc, unsigned int offset)
 
 static void rc5t583_gpio_set(struct gpio_chip *gc, unsigned int offset, int val)
 {
-        struct rc5t583_gpio *rc5t583_gpio = to_rc5t583_gpio(gc);
+        struct rc5t583_gpio *rc5t583_gpio = gpiochip_get_data(gc);
         struct device *parent = rc5t583_gpio->rc5t583->dev;
         if (val)
                 rc5t583_set_bits(parent, RC5T583_GPIO_IOOUT, BIT(offset));
@@ -65,7 +60,7 @@ static void rc5t583_gpio_set(struct gpio_chip *gc, unsigned int offset, int val)
 
 static int rc5t583_gpio_dir_input(struct gpio_chip *gc, unsigned int offset)
 {
-        struct rc5t583_gpio *rc5t583_gpio = to_rc5t583_gpio(gc);
+        struct rc5t583_gpio *rc5t583_gpio = gpiochip_get_data(gc);
         struct device *parent = rc5t583_gpio->rc5t583->dev;
         int ret;
 
@@ -80,7 +75,7 @@ static int rc5t583_gpio_dir_input(struct gpio_chip *gc, unsigned int offset)
 static int rc5t583_gpio_dir_output(struct gpio_chip *gc, unsigned offset,
                         int value)
 {
-        struct rc5t583_gpio *rc5t583_gpio = to_rc5t583_gpio(gc);
+        struct rc5t583_gpio *rc5t583_gpio = gpiochip_get_data(gc);
         struct device *parent = rc5t583_gpio->rc5t583->dev;
         int ret;
 
@@ -95,7 +90,7 @@ static int rc5t583_gpio_dir_output(struct gpio_chip *gc, unsigned offset,
 
 static int rc5t583_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct rc5t583_gpio *rc5t583_gpio = to_rc5t583_gpio(gc);
+        struct rc5t583_gpio *rc5t583_gpio = gpiochip_get_data(gc);
 
         if (offset < RC5T583_MAX_GPIO)
                 return rc5t583_gpio->rc5t583->irq_base +
@@ -105,7 +100,7 @@ static int rc5t583_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 
 static void rc5t583_gpio_free(struct gpio_chip *gc, unsigned offset)
 {
-        struct rc5t583_gpio *rc5t583_gpio = to_rc5t583_gpio(gc);
+        struct rc5t583_gpio *rc5t583_gpio = gpiochip_get_data(gc);
         struct device *parent = rc5t583_gpio->rc5t583->dev;
 
         rc5t583_set_bits(parent, RC5T583_GPIO_PGSEL, BIT(offset));
@@ -132,7 +127,7 @@ static int rc5t583_gpio_probe(struct platform_device *pdev)
         rc5t583_gpio->gpio_chip.to_irq = rc5t583_gpio_to_irq,
         rc5t583_gpio->gpio_chip.ngpio = RC5T583_MAX_GPIO,
         rc5t583_gpio->gpio_chip.can_sleep = true,
-        rc5t583_gpio->gpio_chip.dev = &pdev->dev;
+        rc5t583_gpio->gpio_chip.parent = &pdev->dev;
         rc5t583_gpio->gpio_chip.base = -1;
         rc5t583_gpio->rc5t583 = rc5t583;
 
@@ -141,7 +136,7 @@ static int rc5t583_gpio_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, rc5t583_gpio);
 
-        return gpiochip_add(&rc5t583_gpio->gpio_chip);
+        return gpiochip_add_data(&rc5t583_gpio->gpio_chip, rc5t583_gpio);
 }
 
 static int rc5t583_gpio_remove(struct platform_device *pdev)
diff --git a/drivers/gpio/gpio-rcar.c b/drivers/gpio/gpio-rcar.c
index 2a8122444614..cf41440aff91 100644
--- a/drivers/gpio/gpio-rcar.c
+++ b/drivers/gpio/gpio-rcar.c
@@ -25,7 +25,6 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/pinctrl/consumer.h>
-#include <linux/platform_data/gpio-rcar.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/spinlock.h>
@@ -34,12 +33,13 @@
 struct gpio_rcar_priv {
         void __iomem *base;
         spinlock_t lock;
-        struct gpio_rcar_config config;
         struct platform_device *pdev;
         struct gpio_chip gpio_chip;
         struct irq_chip irq_chip;
-        unsigned int irq_parent;
         struct clk *clk;
+        unsigned int irq_parent;
+        bool has_both_edge_trigger;
+        bool needs_clk;
 };
 
 #define IOINTSEL 0x00   /* General IO/Interrupt Switching Register */
@@ -84,8 +84,7 @@ static void gpio_rcar_modify_bit(struct gpio_rcar_priv *p, int offs,
 static void gpio_rcar_irq_disable(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = container_of(gc, struct gpio_rcar_priv,
-                                                gpio_chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
 
         gpio_rcar_write(p, INTMSK, ~BIT(irqd_to_hwirq(d)));
 }
@@ -93,8 +92,7 @@ static void gpio_rcar_irq_disable(struct irq_data *d)
 static void gpio_rcar_irq_enable(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = container_of(gc, struct gpio_rcar_priv,
-                                                gpio_chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
 
         gpio_rcar_write(p, MSKCLR, BIT(irqd_to_hwirq(d)));
 }
@@ -121,7 +119,7 @@ static void gpio_rcar_config_interrupt_input_mode(struct gpio_rcar_priv *p,
         gpio_rcar_modify_bit(p, EDGLEVEL, hwirq, !level_trigger);
 
         /* Select one edge or both edges in BOTHEDGE */
-        if (p->config.has_both_edge_trigger)
+        if (p->has_both_edge_trigger)
                 gpio_rcar_modify_bit(p, BOTHEDGE, hwirq, both);
 
         /* Select "Interrupt Input Mode" in IOINTSEL */
@@ -137,8 +135,7 @@ static void gpio_rcar_config_interrupt_input_mode(struct gpio_rcar_priv *p,
 static int gpio_rcar_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = container_of(gc, struct gpio_rcar_priv,
-                                                gpio_chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
         unsigned int hwirq = irqd_to_hwirq(d);
 
         dev_dbg(&p->pdev->dev, "sense irq = %d, type = %d\n", hwirq, type);
@@ -161,7 +158,7 @@ static int gpio_rcar_irq_set_type(struct irq_data *d, unsigned int type)
                                                       false);
                 break;
         case IRQ_TYPE_EDGE_BOTH:
-                if (!p->config.has_both_edge_trigger)
+                if (!p->has_both_edge_trigger)
                         return -EINVAL;
                 gpio_rcar_config_interrupt_input_mode(p, hwirq, true, false,
                                                       true);
@@ -175,8 +172,7 @@ static int gpio_rcar_irq_set_type(struct irq_data *d, unsigned int type)
 static int gpio_rcar_irq_set_wake(struct irq_data *d, unsigned int on)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = container_of(gc, struct gpio_rcar_priv,
-                                                gpio_chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
         int error;
 
         if (p->irq_parent) {
@@ -218,16 +214,11 @@ static irqreturn_t gpio_rcar_irq_handler(int irq, void *dev_id)
         return irqs_handled ? IRQ_HANDLED : IRQ_NONE;
 }
 
-static inline struct gpio_rcar_priv *gpio_to_priv(struct gpio_chip *chip)
-{
-        return container_of(chip, struct gpio_rcar_priv, gpio_chip);
-}
-
 static void gpio_rcar_config_general_input_output_mode(struct gpio_chip *chip,
                                                        unsigned int gpio,
                                                        bool output)
 {
-        struct gpio_rcar_priv *p = gpio_to_priv(chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(chip);
         unsigned long flags;
 
         /* follow steps in the GPIO documentation for
@@ -251,7 +242,7 @@ static void gpio_rcar_config_general_input_output_mode(struct gpio_chip *chip,
 
 static int gpio_rcar_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_rcar_priv *p = gpio_to_priv(chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(chip);
         int error;
 
         error = pm_runtime_get_sync(&p->pdev->dev);
@@ -267,7 +258,7 @@ static int gpio_rcar_request(struct gpio_chip *chip, unsigned offset)
 
 static void gpio_rcar_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_rcar_priv *p = gpio_to_priv(chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(chip);
 
         pinctrl_free_gpio(chip->base + offset);
 
@@ -291,15 +282,15 @@ static int gpio_rcar_get(struct gpio_chip *chip, unsigned offset)
 
         /* testing on r8a7790 shows that INDT does not show correct pin state
          * when configured as output, so use OUTDT in case of output pins */
-        if (gpio_rcar_read(gpio_to_priv(chip), INOUTSEL) & bit)
-                return !!(gpio_rcar_read(gpio_to_priv(chip), OUTDT) & bit);
+        if (gpio_rcar_read(gpiochip_get_data(chip), INOUTSEL) & bit)
+                return !!(gpio_rcar_read(gpiochip_get_data(chip), OUTDT) & bit);
         else
-                return !!(gpio_rcar_read(gpio_to_priv(chip), INDT) & bit);
+                return !!(gpio_rcar_read(gpiochip_get_data(chip), INDT) & bit);
 }
 
 static void gpio_rcar_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct gpio_rcar_priv *p = gpio_to_priv(chip);
+        struct gpio_rcar_priv *p = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&p->lock, flags);
@@ -318,14 +309,17 @@ static int gpio_rcar_direction_output(struct gpio_chip *chip, unsigned offset,
 
 struct gpio_rcar_info {
         bool has_both_edge_trigger;
+        bool needs_clk;
 };
 
 static const struct gpio_rcar_info gpio_rcar_info_gen1 = {
         .has_both_edge_trigger = false,
+        .needs_clk = false,
 };
 
 static const struct gpio_rcar_info gpio_rcar_info_gen2 = {
         .has_both_edge_trigger = true,
+        .needs_clk = true,
 };
 
 static const struct of_device_id gpio_rcar_of_table[] = {
@@ -355,39 +349,30 @@ static const struct of_device_id gpio_rcar_of_table[] = {
 
 MODULE_DEVICE_TABLE(of, gpio_rcar_of_table);
 
-static int gpio_rcar_parse_pdata(struct gpio_rcar_priv *p)
+static int gpio_rcar_parse_dt(struct gpio_rcar_priv *p, unsigned int *npins)
 {
-        struct gpio_rcar_config *pdata = dev_get_platdata(&p->pdev->dev);
         struct device_node *np = p->pdev->dev.of_node;
+        const struct of_device_id *match;
+        const struct gpio_rcar_info *info;
         struct of_phandle_args args;
         int ret;
 
-        if (pdata) {
-                p->config = *pdata;
-        } else if (IS_ENABLED(CONFIG_OF) && np) {
-                const struct of_device_id *match;
-                const struct gpio_rcar_info *info;
-
-                match = of_match_node(gpio_rcar_of_table, np);
-                if (!match)
-                        return -EINVAL;
+        match = of_match_node(gpio_rcar_of_table, np);
+        if (!match)
+                return -EINVAL;
 
-                info = match->data;
+        info = match->data;
 
-                ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3, 0,
-                                                       &args);
-                p->config.number_of_pins = ret == 0 ? args.args[2]
-                                         : RCAR_MAX_GPIO_PER_BANK;
-                p->config.gpio_base = -1;
-                p->config.has_both_edge_trigger = info->has_both_edge_trigger;
-        }
+        ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3, 0, &args);
+        *npins = ret == 0 ? args.args[2] : RCAR_MAX_GPIO_PER_BANK;
+        p->has_both_edge_trigger = info->has_both_edge_trigger;
+        p->needs_clk = info->needs_clk;
 
-        if (p->config.number_of_pins == 0 ||
-            p->config.number_of_pins > RCAR_MAX_GPIO_PER_BANK) {
+        if (*npins == 0 || *npins > RCAR_MAX_GPIO_PER_BANK) {
                 dev_warn(&p->pdev->dev,
-                         "Invalid number of gpio lines %u, using %u\n",
-                         p->config.number_of_pins, RCAR_MAX_GPIO_PER_BANK);
-                p->config.number_of_pins = RCAR_MAX_GPIO_PER_BANK;
+                         "Invalid number of gpio lines %u, using %u\n", *npins,
+                         RCAR_MAX_GPIO_PER_BANK);
+                *npins = RCAR_MAX_GPIO_PER_BANK;
         }
 
         return 0;
@@ -401,6 +386,7 @@ static int gpio_rcar_probe(struct platform_device *pdev)
         struct irq_chip *irq_chip;
         struct device *dev = &pdev->dev;
         const char *name = dev_name(dev);
+        unsigned int npins;
         int ret;
 
         p = devm_kzalloc(dev, sizeof(*p), GFP_KERNEL);
@@ -410,8 +396,8 @@ static int gpio_rcar_probe(struct platform_device *pdev)
         p->pdev = pdev;
         spin_lock_init(&p->lock);
 
-        /* Get device configuration from DT node or platform data. */
-        ret = gpio_rcar_parse_pdata(p);
+        /* Get device configuration from DT node */
+        ret = gpio_rcar_parse_dt(p, &npins);
         if (ret < 0)
                 return ret;
 
@@ -419,7 +405,11 @@ static int gpio_rcar_probe(struct platform_device *pdev)
 
         p->clk = devm_clk_get(dev, NULL);
         if (IS_ERR(p->clk)) {
-                dev_warn(dev, "unable to get clock\n");
+                if (p->needs_clk) {
+                        dev_err(dev, "unable to get clock\n");
+                        ret = PTR_ERR(p->clk);
+                        goto err0;
+                }
                 p->clk = NULL;
         }
 
@@ -449,10 +439,10 @@ static int gpio_rcar_probe(struct platform_device *pdev)
         gpio_chip->direction_output = gpio_rcar_direction_output;
         gpio_chip->set = gpio_rcar_set;
         gpio_chip->label = name;
-        gpio_chip->dev = dev;
+        gpio_chip->parent = dev;
         gpio_chip->owner = THIS_MODULE;
-        gpio_chip->base = p->config.gpio_base;
-        gpio_chip->ngpio = p->config.number_of_pins;
+        gpio_chip->base = -1;
+        gpio_chip->ngpio = npins;
 
         irq_chip = &p->irq_chip;
         irq_chip->name = name;
@@ -462,14 +452,14 @@ static int gpio_rcar_probe(struct platform_device *pdev)
         irq_chip->irq_set_wake = gpio_rcar_irq_set_wake;
         irq_chip->flags = IRQCHIP_SET_TYPE_MASKED | IRQCHIP_MASK_ON_SUSPEND;
 
-        ret = gpiochip_add(gpio_chip);
+        ret = gpiochip_add_data(gpio_chip, p);
         if (ret) {
                 dev_err(dev, "failed to add GPIO controller\n");
                 goto err0;
         }
 
-        ret = gpiochip_irqchip_add(gpio_chip, irq_chip, p->config.irq_base,
-                                   handle_level_irq, IRQ_TYPE_NONE);
+        ret = gpiochip_irqchip_add(gpio_chip, irq_chip, 0, handle_level_irq,
+                                   IRQ_TYPE_NONE);
         if (ret) {
                 dev_err(dev, "cannot add irqchip\n");
                 goto err1;
@@ -483,22 +473,7 @@ static int gpio_rcar_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        dev_info(dev, "driving %d GPIOs\n", p->config.number_of_pins);
-
-        /* warn in case of mismatch if irq base is specified */
-        if (p->config.irq_base) {
-                ret = irq_find_mapping(gpio_chip->irqdomain, 0);
-                if (p->config.irq_base != ret)
-                        dev_warn(dev, "irq base mismatch (%u/%u)\n",
-                                 p->config.irq_base, ret);
-        }
-
-        if (p->config.pctl_name) {
-                ret = gpiochip_add_pin_range(gpio_chip, p->config.pctl_name, 0,
-                                             gpio_chip->base, gpio_chip->ngpio);
-                if (ret < 0)
-                        dev_warn(dev, "failed to add pin range\n");
-        }
+        dev_info(dev, "driving %d GPIOs\n", npins);
 
         return 0;
 
diff --git a/drivers/gpio/gpio-rdc321x.c b/drivers/gpio/gpio-rdc321x.c
index d729bc8a554d..96ddee3f464a 100644
--- a/drivers/gpio/gpio-rdc321x.c
+++ b/drivers/gpio/gpio-rdc321x.c
@@ -47,7 +47,7 @@ static int rdc_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
         u32 value = 0;
         int reg;
 
-        gpch = container_of(chip, struct rdc321x_gpio, chip);
+        gpch = gpiochip_get_data(chip);
         reg = gpio < 32 ? gpch->reg1_data_base : gpch->reg2_data_base;
 
         spin_lock(&gpch->lock);
@@ -65,7 +65,7 @@ static void rdc_gpio_set_value_impl(struct gpio_chip *chip,
         struct rdc321x_gpio *gpch;
         int reg = (gpio < 32) ? 0 : 1;
 
-        gpch = container_of(chip, struct rdc321x_gpio, chip);
+        gpch = gpiochip_get_data(chip);
 
         if (value)
                 gpch->data_reg[reg] |= 1 << (gpio & 0x1f);
@@ -83,7 +83,7 @@ static void rdc_gpio_set_value(struct gpio_chip *chip,
 {
         struct rdc321x_gpio *gpch;
 
-        gpch = container_of(chip, struct rdc321x_gpio, chip);
+        gpch = gpiochip_get_data(chip);
         spin_lock(&gpch->lock);
         rdc_gpio_set_value_impl(chip, gpio, value);
         spin_unlock(&gpch->lock);
@@ -96,7 +96,7 @@ static int rdc_gpio_config(struct gpio_chip *chip,
         int err;
         u32 reg;
 
-        gpch = container_of(chip, struct rdc321x_gpio, chip);
+        gpch = gpiochip_get_data(chip);
 
         spin_lock(&gpch->lock);
         err = pci_read_config_dword(gpch->sb_pdev, gpio < 32 ?
@@ -194,7 +194,7 @@ static int rdc321x_gpio_probe(struct platform_device *pdev)
 
         dev_info(&pdev->dev, "registering %d GPIOs\n",
                                         rdc321x_gpio_dev->chip.ngpio);
-        return gpiochip_add(&rdc321x_gpio_dev->chip);
+        return gpiochip_add_data(&rdc321x_gpio_dev->chip, rdc321x_gpio_dev);
 }
 
 static int rdc321x_gpio_remove(struct platform_device *pdev)
diff --git a/drivers/gpio/gpio-sa1100.c b/drivers/gpio/gpio-sa1100.c
index 990fa9023e22..0c99e8fb9af3 100644
--- a/drivers/gpio/gpio-sa1100.c
+++ b/drivers/gpio/gpio-sa1100.c
@@ -17,7 +17,7 @@
 
 static int sa1100_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        return GPLR & GPIO_GPIO(offset);
+        return !!(GPLR & GPIO_GPIO(offset));
 }
 
 static void sa1100_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
@@ -238,7 +238,7 @@ void __init sa1100_init_gpio(void)
         GRER = 0;
         GEDR = -1;
 
-        gpiochip_add(&sa1100_gpio_chip);
+        gpiochip_add_data(&sa1100_gpio_chip, NULL);
 
         sa1100_gpio_irqdomain = irq_domain_add_simple(NULL,
                         28, IRQ_GPIO0,
diff --git a/drivers/gpio/gpio-samsung.c b/drivers/gpio/gpio-samsung.c
index 7c288ba4dc87..4cb4a314c02b 100644
--- a/drivers/gpio/gpio-samsung.c
+++ b/drivers/gpio/gpio-samsung.c
@@ -753,7 +753,7 @@ static void __init samsung_gpiolib_add(struct samsung_gpio_chip *chip)
 #endif
 
         /* gpiochip_add() prints own failure message on error. */
-        ret = gpiochip_add(gc);
+        ret = gpiochip_add_data(gc, chip);
         if (ret >= 0)
                 s3c_gpiolib_track(chip);
 }
@@ -862,7 +862,7 @@ static void __init samsung_gpiolib_add_4bit2_chips(struct samsung_gpio_chip *chi
 
 int samsung_gpiolib_to_irq(struct gpio_chip *chip, unsigned int offset)
 {
-        struct samsung_gpio_chip *samsung_chip = container_of(chip, struct samsung_gpio_chip, chip);
+        struct samsung_gpio_chip *samsung_chip = gpiochip_get_data(chip);
 
         return samsung_chip->irq_base + offset;
 }
diff --git a/drivers/gpio/gpio-sch.c b/drivers/gpio/gpio-sch.c
index b72906f5b999..5314ee4b947d 100644
--- a/drivers/gpio/gpio-sch.c
+++ b/drivers/gpio/gpio-sch.c
@@ -41,8 +41,6 @@ struct sch_gpio {
         unsigned short resume_base;
 };
 
-#define to_sch_gpio(gc) container_of(gc, struct sch_gpio, chip)
-
 static unsigned sch_gpio_offset(struct sch_gpio *sch, unsigned gpio,
                                 unsigned reg)
 {
@@ -65,7 +63,7 @@ static unsigned sch_gpio_bit(struct sch_gpio *sch, unsigned gpio)
 
 static int sch_gpio_reg_get(struct gpio_chip *gc, unsigned gpio, unsigned reg)
 {
-        struct sch_gpio *sch = to_sch_gpio(gc);
+        struct sch_gpio *sch = gpiochip_get_data(gc);
         unsigned short offset, bit;
         u8 reg_val;
 
@@ -80,7 +78,7 @@ static int sch_gpio_reg_get(struct gpio_chip *gc, unsigned gpio, unsigned reg)
 static void sch_gpio_reg_set(struct gpio_chip *gc, unsigned gpio, unsigned reg,
                              int val)
 {
-        struct sch_gpio *sch = to_sch_gpio(gc);
+        struct sch_gpio *sch = gpiochip_get_data(gc);
         unsigned short offset, bit;
         u8 reg_val;
 
@@ -97,7 +95,7 @@ static void sch_gpio_reg_set(struct gpio_chip *gc, unsigned gpio, unsigned reg,
 
 static int sch_gpio_direction_in(struct gpio_chip *gc, unsigned gpio_num)
 {
-        struct sch_gpio *sch = to_sch_gpio(gc);
+        struct sch_gpio *sch = gpiochip_get_data(gc);
 
         spin_lock(&sch->lock);
         sch_gpio_reg_set(gc, gpio_num, GIO, 1);
@@ -112,7 +110,7 @@ static int sch_gpio_get(struct gpio_chip *gc, unsigned gpio_num)
 
 static void sch_gpio_set(struct gpio_chip *gc, unsigned gpio_num, int val)
 {
-        struct sch_gpio *sch = to_sch_gpio(gc);
+        struct sch_gpio *sch = gpiochip_get_data(gc);
 
         spin_lock(&sch->lock);
         sch_gpio_reg_set(gc, gpio_num, GLV, val);
@@ -122,7 +120,7 @@ static void sch_gpio_set(struct gpio_chip *gc, unsigned gpio_num, int val)
 static int sch_gpio_direction_out(struct gpio_chip *gc, unsigned gpio_num,
                                   int val)
 {
-        struct sch_gpio *sch = to_sch_gpio(gc);
+        struct sch_gpio *sch = gpiochip_get_data(gc);
 
         spin_lock(&sch->lock);
         sch_gpio_reg_set(gc, gpio_num, GIO, 0);
@@ -171,7 +169,7 @@ static int sch_gpio_probe(struct platform_device *pdev)
         sch->iobase = res->start;
         sch->chip = sch_gpio_chip;
         sch->chip.label = dev_name(&pdev->dev);
-        sch->chip.dev = &pdev->dev;
+        sch->chip.parent = &pdev->dev;
 
         switch (pdev->id) {
         case PCI_DEVICE_ID_INTEL_SCH_LPC:
@@ -217,7 +215,7 @@ static int sch_gpio_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, sch);
 
-        return gpiochip_add(&sch->chip);
+        return gpiochip_add_data(&sch->chip, sch);
 }
 
 static int sch_gpio_remove(struct platform_device *pdev)
diff --git a/drivers/gpio/gpio-sch311x.c b/drivers/gpio/gpio-sch311x.c
index 0cb11413e814..1cbd77a04e7b 100644
--- a/drivers/gpio/gpio-sch311x.c
+++ b/drivers/gpio/gpio-sch311x.c
@@ -93,13 +93,6 @@ static struct sch311x_gpio_block_def sch311x_gpio_blocks[] = {
         },
 };
 
-static inline struct sch311x_gpio_block *
-to_sch311x_gpio_block(struct gpio_chip *chip)
-{
-        return container_of(chip, struct sch311x_gpio_block, chip);
-}
-
-
 /*
  *      Super-IO functions
  */
@@ -142,14 +135,14 @@ static inline void sch311x_sio_outb(int sio_config_port, int reg, int val)
 
 static int sch311x_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip);
+        struct sch311x_gpio_block *block = gpiochip_get_data(chip);
 
         if (block->config_regs[offset] == 0) /* GPIO is not available */
                 return -ENODEV;
 
         if (!request_region(block->runtime_reg + block->config_regs[offset],
                             1, DRV_NAME)) {
-                dev_err(chip->dev, "Failed to request region 0x%04x.\n",
+                dev_err(chip->parent, "Failed to request region 0x%04x.\n",
                         block->runtime_reg + block->config_regs[offset]);
                 return -EBUSY;
         }
@@ -158,7 +151,7 @@ static int sch311x_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void sch311x_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip);
+        struct sch311x_gpio_block *block = gpiochip_get_data(chip);
 
         if (block->config_regs[offset] == 0) /* GPIO is not available */
                 return;
@@ -168,7 +161,7 @@ static void sch311x_gpio_free(struct gpio_chip *chip, unsigned offset)
 
 static int sch311x_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip);
+        struct sch311x_gpio_block *block = gpiochip_get_data(chip);
         unsigned char data;
 
         spin_lock(&block->lock);
@@ -192,7 +185,7 @@ static void __sch311x_gpio_set(struct sch311x_gpio_block *block,
 static void sch311x_gpio_set(struct gpio_chip *chip, unsigned offset,
                              int value)
 {
-        struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip);
+        struct sch311x_gpio_block *block = gpiochip_get_data(chip);
 
         spin_lock(&block->lock);
          __sch311x_gpio_set(block, offset, value);
@@ -201,7 +194,7 @@ static void sch311x_gpio_set(struct gpio_chip *chip, unsigned offset,
 
 static int sch311x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip);
+        struct sch311x_gpio_block *block = gpiochip_get_data(chip);
 
         spin_lock(&block->lock);
         outb(SCH311X_GPIO_CONF_IN, block->runtime_reg +
@@ -214,7 +207,7 @@ static int sch311x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 static int sch311x_gpio_direction_out(struct gpio_chip *chip, unsigned offset,
                                       int value)
 {
-        struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip);
+        struct sch311x_gpio_block *block = gpiochip_get_data(chip);
 
         spin_lock(&block->lock);
 
@@ -229,7 +222,7 @@ static int sch311x_gpio_direction_out(struct gpio_chip *chip, unsigned offset,
 
 static int sch311x_gpio_probe(struct platform_device *pdev)
 {
-        struct sch311x_pdev_data *pdata = pdev->dev.platform_data;
+        struct sch311x_pdev_data *pdata = dev_get_platdata(&pdev->dev);
         struct sch311x_gpio_priv *priv;
         struct sch311x_gpio_block *block;
         int err, i;
@@ -261,13 +254,13 @@ static int sch311x_gpio_probe(struct platform_device *pdev)
                 block->chip.get = sch311x_gpio_get;
                 block->chip.set = sch311x_gpio_set;
                 block->chip.ngpio = 8;
-                block->chip.dev = &pdev->dev;
+                block->chip.parent = &pdev->dev;
                 block->chip.base = sch311x_gpio_blocks[i].base;
                 block->config_regs = sch311x_gpio_blocks[i].config_regs;
                 block->data_reg = sch311x_gpio_blocks[i].data_reg;
                 block->runtime_reg = pdata->runtime_reg;
 
-                err = gpiochip_add(&block->chip);
+                err = gpiochip_add_data(&block->chip, block);
                 if (err < 0) {
                         dev_err(&pdev->dev,
                                 "Could not register gpiochip, %d\n", err);
@@ -289,7 +282,7 @@ exit_err:
 
 static int sch311x_gpio_remove(struct platform_device *pdev)
 {
-        struct sch311x_pdev_data *pdata = pdev->dev.platform_data;
+        struct sch311x_pdev_data *pdata = dev_get_platdata(&pdev->dev);
         struct sch311x_gpio_priv *priv = platform_get_drvdata(pdev);
         int i;
 
diff --git a/drivers/gpio/gpio-sodaville.c b/drivers/gpio/gpio-sodaville.c
index 34b02b42ab9e..e3cb6772f6ec 100644
--- a/drivers/gpio/gpio-sodaville.c
+++ b/drivers/gpio/gpio-sodaville.c
@@ -10,7 +10,6 @@
  */
 
 #include <linux/errno.h>
-#include <linux/gpio.h>
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/irq.h>
@@ -20,7 +19,7 @@
 #include <linux/pci.h>
 #include <linux/platform_device.h>
 #include <linux/of_irq.h>
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 
 #define DRV_NAME                "sdv_gpio"
 #define SDV_NUM_PUB_GPIOS       12
@@ -43,7 +42,7 @@ struct sdv_gpio_chip_data {
         void __iomem *gpio_pub_base;
         struct irq_domain *id;
         struct irq_chip_generic *gc;
-        struct bgpio_chip bgpio;
+        struct gpio_chip chip;
 };
 
 static int sdv_gpio_pub_set_type(struct irq_data *d, unsigned int type)
@@ -226,14 +225,14 @@ static int sdv_gpio_probe(struct pci_dev *pdev,
                 writel(mux_val, sd->gpio_pub_base + GPMUXCTL);
         }
 
-        ret = bgpio_init(&sd->bgpio, &pdev->dev, 4,
+        ret = bgpio_init(&sd->chip, &pdev->dev, 4,
                         sd->gpio_pub_base + GPINR, sd->gpio_pub_base + GPOUTR,
                         NULL, sd->gpio_pub_base + GPOER, NULL, 0);
         if (ret)
                 goto unmap;
-        sd->bgpio.gc.ngpio = SDV_NUM_PUB_GPIOS;
+        sd->chip.ngpio = SDV_NUM_PUB_GPIOS;
 
-        ret = gpiochip_add(&sd->bgpio.gc);
+        ret = gpiochip_add_data(&sd->chip, sd);
         if (ret < 0) {
                 dev_err(&pdev->dev, "gpiochip_add() failed.\n");
                 goto unmap;
@@ -265,7 +264,7 @@ static void sdv_gpio_remove(struct pci_dev *pdev)
         free_irq(pdev->irq, sd);
         irq_free_descs(sd->irq_base, SDV_NUM_PUB_GPIOS);
 
-        gpiochip_remove(&sd->bgpio.gc);
+        gpiochip_remove(&sd->chip);
         pci_release_region(pdev, GPIO_BAR);
         iounmap(sd->gpio_pub_base);
         pci_disable_device(pdev);
diff --git a/drivers/gpio/gpio-spear-spics.c b/drivers/gpio/gpio-spear-spics.c
index 69ffca5b073b..50fb09080a6b 100644
--- a/drivers/gpio/gpio-spear-spics.c
+++ b/drivers/gpio/gpio-spear-spics.c
@@ -62,8 +62,7 @@ static int spics_get_value(struct gpio_chip *chip, unsigned offset)
 
 static void spics_set_value(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct spear_spics *spics = container_of(chip, struct spear_spics,
-                        chip);
+        struct spear_spics *spics = gpiochip_get_data(chip);
         u32 tmp;
 
         /* select chip select from register */
@@ -94,8 +93,7 @@ static int spics_direction_output(struct gpio_chip *chip, unsigned offset,
 
 static int spics_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct spear_spics *spics = container_of(chip, struct spear_spics,
-                        chip);
+        struct spear_spics *spics = gpiochip_get_data(chip);
         u32 tmp;
 
         if (!spics->use_count++) {
@@ -110,8 +108,7 @@ static int spics_request(struct gpio_chip *chip, unsigned offset)
 
 static void spics_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct spear_spics *spics = container_of(chip, struct spear_spics,
-                        chip);
+        struct spear_spics *spics = gpiochip_get_data(chip);
         u32 tmp;
 
         if (!--spics->use_count) {
@@ -164,11 +161,11 @@ static int spics_gpio_probe(struct platform_device *pdev)
         spics->chip.get = spics_get_value;
         spics->chip.set = spics_set_value;
         spics->chip.label = dev_name(&pdev->dev);
-        spics->chip.dev = &pdev->dev;
+        spics->chip.parent = &pdev->dev;
         spics->chip.owner = THIS_MODULE;
         spics->last_off = -1;
 
-        ret = gpiochip_add(&spics->chip);
+        ret = gpiochip_add_data(&spics->chip, spics);
         if (ret) {
                 dev_err(&pdev->dev, "unable to add gpio chip\n");
                 return ret;
diff --git a/drivers/gpio/gpio-sta2x11.c b/drivers/gpio/gpio-sta2x11.c
index 55e47828ddfc..83af1cb36333 100644
--- a/drivers/gpio/gpio-sta2x11.c
+++ b/drivers/gpio/gpio-sta2x11.c
@@ -74,7 +74,7 @@ static inline u32 __bit(int nr)
 
 static void gsta_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
 {
-        struct gsta_gpio *chip = container_of(gpio, struct gsta_gpio, gpio);
+        struct gsta_gpio *chip = gpiochip_get_data(gpio);
         struct gsta_regs __iomem *regs = __regs(chip, nr);
         u32 bit = __bit(nr);
 
@@ -86,17 +86,17 @@ static void gsta_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
 
 static int gsta_gpio_get(struct gpio_chip *gpio, unsigned nr)
 {
-        struct gsta_gpio *chip = container_of(gpio, struct gsta_gpio, gpio);
+        struct gsta_gpio *chip = gpiochip_get_data(gpio);
         struct gsta_regs __iomem *regs = __regs(chip, nr);
         u32 bit = __bit(nr);
 
-        return readl(&regs->dat) & bit;
+        return !!(readl(&regs->dat) & bit);
 }
 
 static int gsta_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
                                       int val)
 {
-        struct gsta_gpio *chip = container_of(gpio, struct gsta_gpio, gpio);
+        struct gsta_gpio *chip = gpiochip_get_data(gpio);
         struct gsta_regs __iomem *regs = __regs(chip, nr);
         u32 bit = __bit(nr);
 
@@ -111,7 +111,7 @@ static int gsta_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
 
 static int gsta_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 {
-        struct gsta_gpio *chip = container_of(gpio, struct gsta_gpio, gpio);
+        struct gsta_gpio *chip = gpiochip_get_data(gpio);
         struct gsta_regs __iomem *regs = __regs(chip, nr);
         u32 bit = __bit(nr);
 
@@ -121,7 +121,7 @@ static int gsta_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 
 static int gsta_gpio_to_irq(struct gpio_chip *gpio, unsigned offset)
 {
-        struct gsta_gpio *chip = container_of(gpio, struct gsta_gpio, gpio);
+        struct gsta_gpio *chip = gpiochip_get_data(gpio);
         return chip->irq_base + offset;
 }
 
@@ -409,7 +409,7 @@ static int gsta_probe(struct platform_device *dev)
                 goto err_free_descs;
         }
 
-        err = gpiochip_add(&chip->gpio);
+        err = gpiochip_add_data(&chip->gpio, chip);
         if (err < 0) {
                 dev_err(&dev->dev, "sta2x11 gpio: Can't register (%i)\n",
                         -err);
diff --git a/drivers/gpio/gpio-stmpe.c b/drivers/gpio/gpio-stmpe.c
index dabfb99dddef..5197edf1acfd 100644
--- a/drivers/gpio/gpio-stmpe.c
+++ b/drivers/gpio/gpio-stmpe.c
@@ -36,14 +36,9 @@ struct stmpe_gpio {
         u8 oldregs[CACHE_NR_REGS][CACHE_NR_BANKS];
 };
 
-static inline struct stmpe_gpio *to_stmpe_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct stmpe_gpio, chip);
-}
-
 static int stmpe_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
         u8 reg = stmpe->regs[STMPE_IDX_GPMR_LSB] - (offset / 8);
         u8 mask = 1 << (offset % 8);
@@ -58,7 +53,7 @@ static int stmpe_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void stmpe_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
         int which = val ? STMPE_IDX_GPSR_LSB : STMPE_IDX_GPCR_LSB;
         u8 reg = stmpe->regs[which] - (offset / 8);
@@ -77,7 +72,7 @@ static void stmpe_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 static int stmpe_gpio_direction_output(struct gpio_chip *chip,
                                          unsigned offset, int val)
 {
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
         u8 reg = stmpe->regs[STMPE_IDX_GPDR_LSB] - (offset / 8);
         u8 mask = 1 << (offset % 8);
@@ -90,7 +85,7 @@ static int stmpe_gpio_direction_output(struct gpio_chip *chip,
 static int stmpe_gpio_direction_input(struct gpio_chip *chip,
                                         unsigned offset)
 {
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
         u8 reg = stmpe->regs[STMPE_IDX_GPDR_LSB] - (offset / 8);
         u8 mask = 1 << (offset % 8);
@@ -100,7 +95,7 @@ static int stmpe_gpio_direction_input(struct gpio_chip *chip,
 
 static int stmpe_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
 
         if (stmpe_gpio->norequest_mask & (1 << offset))
@@ -123,7 +118,7 @@ static struct gpio_chip template_chip = {
 static int stmpe_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(gc);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
@@ -151,7 +146,7 @@ static int stmpe_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 static void stmpe_gpio_irq_lock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(gc);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
 
         mutex_lock(&stmpe_gpio->irq_lock);
 }
@@ -159,7 +154,7 @@ static void stmpe_gpio_irq_lock(struct irq_data *d)
 static void stmpe_gpio_irq_sync_unlock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(gc);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
         int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);
         static const u8 regmap[] = {
@@ -193,7 +188,7 @@ static void stmpe_gpio_irq_sync_unlock(struct irq_data *d)
 static void stmpe_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(gc);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
@@ -204,7 +199,7 @@ static void stmpe_gpio_irq_mask(struct irq_data *d)
 static void stmpe_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(gc);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
@@ -216,7 +211,7 @@ static void stmpe_dbg_show_one(struct seq_file *s,
                                struct gpio_chip *gc,
                                unsigned offset, unsigned gpio)
 {
-        struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(gc);
+        struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
         const char *label = gpiochip_is_requested(gc, offset);
         int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);
@@ -356,7 +351,7 @@ static int stmpe_gpio_probe(struct platform_device *pdev)
         stmpe_gpio->stmpe = stmpe;
         stmpe_gpio->chip = template_chip;
         stmpe_gpio->chip.ngpio = stmpe->num_gpios;
-        stmpe_gpio->chip.dev = &pdev->dev;
+        stmpe_gpio->chip.parent = &pdev->dev;
         stmpe_gpio->chip.of_node = np;
         stmpe_gpio->chip.base = -1;
 
@@ -375,7 +370,7 @@ static int stmpe_gpio_probe(struct platform_device *pdev)
         if (ret)
                 goto out_free;
 
-        ret = gpiochip_add(&stmpe_gpio->chip);
+        ret = gpiochip_add_data(&stmpe_gpio->chip, stmpe_gpio);
         if (ret) {
                 dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret);
                 goto out_disable;
diff --git a/drivers/gpio/gpio-stp-xway.c b/drivers/gpio/gpio-stp-xway.c
index 81bdbe7ba2a4..d11dd48570b2 100644
--- a/drivers/gpio/gpio-stp-xway.c
+++ b/drivers/gpio/gpio-stp-xway.c
@@ -100,8 +100,7 @@ struct xway_stp {
  */
 static void xway_stp_set(struct gpio_chip *gc, unsigned gpio, int val)
 {
-        struct xway_stp *chip =
-                container_of(gc, struct xway_stp, gc);
+        struct xway_stp *chip = gpiochip_get_data(gc);
 
         if (val)
                 chip->shadow |= BIT(gpio);
@@ -135,11 +134,10 @@ static int xway_stp_dir_out(struct gpio_chip *gc, unsigned gpio, int val)
  */
 static int xway_stp_request(struct gpio_chip *gc, unsigned gpio)
 {
-        struct xway_stp *chip =
-                container_of(gc, struct xway_stp, gc);
+        struct xway_stp *chip = gpiochip_get_data(gc);
 
         if ((gpio < 8) && (chip->reserved & BIT(gpio))) {
-                dev_err(gc->dev, "GPIO %d is driven by hardware\n", gpio);
+                dev_err(gc->parent, "GPIO %d is driven by hardware\n", gpio);
                 return -ENODEV;
         }
 
@@ -214,7 +212,7 @@ static int xway_stp_probe(struct platform_device *pdev)
         if (IS_ERR(chip->virt))
                 return PTR_ERR(chip->virt);
 
-        chip->gc.dev = &pdev->dev;
+        chip->gc.parent = &pdev->dev;
         chip->gc.label = "stp-xway";
         chip->gc.direction_output = xway_stp_dir_out;
         chip->gc.set = xway_stp_set;
@@ -260,7 +258,7 @@ static int xway_stp_probe(struct platform_device *pdev)
 
         ret = xway_stp_hw_init(chip);
         if (!ret)
-                ret = gpiochip_add(&chip->gc);
+                ret = gpiochip_add_data(&chip->gc, chip);
 
         if (!ret)
                 dev_info(&pdev->dev, "Init done\n");
diff --git a/drivers/gpio/gpio-sx150x.c b/drivers/gpio/gpio-sx150x.c
index 76f920173a2f..e6cff1cabd0c 100644
--- a/drivers/gpio/gpio-sx150x.c
+++ b/drivers/gpio/gpio-sx150x.c
@@ -32,8 +32,19 @@
 #define NO_UPDATE_PENDING       -1
 
 /* The chip models of sx150x */
-#define SX150X_456 0
-#define SX150X_789 1
+#define SX150X_123 0
+#define SX150X_456 1
+#define SX150X_789 2
+
+struct sx150x_123_pri {
+        u8 reg_pld_mode;
+        u8 reg_pld_table0;
+        u8 reg_pld_table1;
+        u8 reg_pld_table2;
+        u8 reg_pld_table3;
+        u8 reg_pld_table4;
+        u8 reg_advance;
+};
 
 struct sx150x_456_pri {
         u8 reg_pld_mode;
@@ -65,6 +76,7 @@ struct sx150x_device_data {
         u8 reg_sense;
         u8 ngpios;
         union {
+                struct sx150x_123_pri x123;
                 struct sx150x_456_pri x456;
                 struct sx150x_789_pri x789;
         } pri;
@@ -142,12 +154,33 @@ static const struct sx150x_device_data sx150x_devices[] = {
                 },
                 .ngpios = 16
         },
+        [3] = { /* sx1502q */
+                .model = SX150X_123,
+                .reg_pullup     = 0x02,
+                .reg_pulldn     = 0x03,
+                .reg_dir        = 0x01,
+                .reg_data       = 0x00,
+                .reg_irq_mask   = 0x05,
+                .reg_irq_src    = 0x08,
+                .reg_sense      = 0x07,
+                .pri.x123 = {
+                        .reg_pld_mode   = 0x10,
+                        .reg_pld_table0 = 0x11,
+                        .reg_pld_table1 = 0x12,
+                        .reg_pld_table2 = 0x13,
+                        .reg_pld_table3 = 0x14,
+                        .reg_pld_table4 = 0x15,
+                        .reg_advance    = 0xad,
+                },
+                .ngpios = 8,
+        },
 };
 
 static const struct i2c_device_id sx150x_id[] = {
         {"sx1508q", 0},
         {"sx1509q", 1},
         {"sx1506q", 2},
+        {"sx1502q", 3},
         {}
 };
 MODULE_DEVICE_TABLE(i2c, sx150x_id);
@@ -156,15 +189,11 @@ static const struct of_device_id sx150x_of_match[] = {
         { .compatible = "semtech,sx1508q" },
         { .compatible = "semtech,sx1509q" },
         { .compatible = "semtech,sx1506q" },
+        { .compatible = "semtech,sx1502q" },
         {},
 };
 MODULE_DEVICE_TABLE(of, sx150x_of_match);
 
-struct sx150x_chip *to_sx150x(struct gpio_chip *gc)
-{
-        return container_of(gc, struct sx150x_chip, gpio_chip);
-}
-
 static s32 sx150x_i2c_write(struct i2c_client *client, u8 reg, u8 val)
 {
         s32 err = i2c_smbus_write_byte_data(client, reg, val);
@@ -301,7 +330,7 @@ static int sx150x_io_output(struct sx150x_chip *chip, unsigned offset, int val)
 
 static int sx150x_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct sx150x_chip *chip = to_sx150x(gc);
+        struct sx150x_chip *chip = gpiochip_get_data(gc);
         int status = -EINVAL;
 
         if (!offset_is_oscio(chip, offset)) {
@@ -310,12 +339,12 @@ static int sx150x_gpio_get(struct gpio_chip *gc, unsigned offset)
                 mutex_unlock(&chip->lock);
         }
 
-        return status;
+        return (status < 0) ? status : !!status;
 }
 
 static void sx150x_gpio_set(struct gpio_chip *gc, unsigned offset, int val)
 {
-        struct sx150x_chip *chip = to_sx150x(gc);
+        struct sx150x_chip *chip = gpiochip_get_data(gc);
 
         mutex_lock(&chip->lock);
         if (offset_is_oscio(chip, offset))
@@ -327,7 +356,7 @@ static void sx150x_gpio_set(struct gpio_chip *gc, unsigned offset, int val)
 
 static int sx150x_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct sx150x_chip *chip = to_sx150x(gc);
+        struct sx150x_chip *chip = gpiochip_get_data(gc);
         int status = -EINVAL;
 
         if (!offset_is_oscio(chip, offset)) {
@@ -342,7 +371,7 @@ static int sx150x_gpio_direction_output(struct gpio_chip *gc,
                                         unsigned offset,
                                         int val)
 {
-        struct sx150x_chip *chip = to_sx150x(gc);
+        struct sx150x_chip *chip = gpiochip_get_data(gc);
         int status = 0;
 
         if (!offset_is_oscio(chip, offset)) {
@@ -355,7 +384,7 @@ static int sx150x_gpio_direction_output(struct gpio_chip *gc,
 
 static void sx150x_irq_mask(struct irq_data *d)
 {
-        struct sx150x_chip *chip = to_sx150x(irq_data_get_irq_chip_data(d));
+        struct sx150x_chip *chip = gpiochip_get_data(irq_data_get_irq_chip_data(d));
         unsigned n = d->hwirq;
 
         chip->irq_masked |= (1 << n);
@@ -364,7 +393,7 @@ static void sx150x_irq_mask(struct irq_data *d)
 
 static void sx150x_irq_unmask(struct irq_data *d)
 {
-        struct sx150x_chip *chip = to_sx150x(irq_data_get_irq_chip_data(d));
+        struct sx150x_chip *chip = gpiochip_get_data(irq_data_get_irq_chip_data(d));
         unsigned n = d->hwirq;
 
         chip->irq_masked &= ~(1 << n);
@@ -373,7 +402,7 @@ static void sx150x_irq_unmask(struct irq_data *d)
 
 static int sx150x_irq_set_type(struct irq_data *d, unsigned int flow_type)
 {
-        struct sx150x_chip *chip = to_sx150x(irq_data_get_irq_chip_data(d));
+        struct sx150x_chip *chip = gpiochip_get_data(irq_data_get_irq_chip_data(d));
         unsigned n, val = 0;
 
         if (flow_type & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
@@ -428,14 +457,14 @@ static irqreturn_t sx150x_irq_thread_fn(int irq, void *dev_id)
 
 static void sx150x_irq_bus_lock(struct irq_data *d)
 {
-        struct sx150x_chip *chip = to_sx150x(irq_data_get_irq_chip_data(d));
+        struct sx150x_chip *chip = gpiochip_get_data(irq_data_get_irq_chip_data(d));
 
         mutex_lock(&chip->lock);
 }
 
 static void sx150x_irq_bus_sync_unlock(struct irq_data *d)
 {
-        struct sx150x_chip *chip = to_sx150x(irq_data_get_irq_chip_data(d));
+        struct sx150x_chip *chip = gpiochip_get_data(irq_data_get_irq_chip_data(d));
         unsigned n;
 
         if (chip->irq_update == NO_UPDATE_PENDING)
@@ -473,7 +502,7 @@ static void sx150x_init_chip(struct sx150x_chip *chip,
 
         chip->client                     = client;
         chip->dev_cfg                    = &sx150x_devices[driver_data];
-        chip->gpio_chip.dev              = &client->dev;
+        chip->gpio_chip.parent              = &client->dev;
         chip->gpio_chip.label            = client->name;
         chip->gpio_chip.direction_input  = sx150x_gpio_direction_input;
         chip->gpio_chip.direction_output = sx150x_gpio_direction_output;
@@ -545,10 +574,14 @@ static int sx150x_init_hw(struct sx150x_chip *chip,
                 err = sx150x_i2c_write(chip->client,
                                 chip->dev_cfg->pri.x789.reg_misc,
                                 0x01);
-        else
+        else if (chip->dev_cfg->model == SX150X_456)
                 err = sx150x_i2c_write(chip->client,
                                 chip->dev_cfg->pri.x456.reg_advance,
                                 0x04);
+        else
+                err = sx150x_i2c_write(chip->client,
+                                chip->dev_cfg->pri.x123.reg_advance,
+                                0x00);
         if (err < 0)
                 return err;
 
@@ -574,13 +607,20 @@ static int sx150x_init_hw(struct sx150x_chip *chip,
                                 pdata->io_polarity);
                 if (err < 0)
                         return err;
-        } else {
+        } else if (chip->dev_cfg->model == SX150X_456) {
                 /* Set all pins to work in normal mode */
                 err = sx150x_init_io(chip,
                                 chip->dev_cfg->pri.x456.reg_pld_mode,
                                 0);
                 if (err < 0)
                         return err;
+        } else {
+                /* Set all pins to work in normal mode */
+                err = sx150x_init_io(chip,
+                                chip->dev_cfg->pri.x123.reg_pld_mode,
+                                0);
+                if (err < 0)
+                        return err;
         }
 
 
@@ -647,7 +687,7 @@ static int sx150x_probe(struct i2c_client *client,
         if (rc < 0)
                 return rc;
 
-        rc = gpiochip_add(&chip->gpio_chip);
+        rc = gpiochip_add_data(&chip->gpio_chip, chip);
         if (rc)
                 return rc;
 
@@ -680,7 +720,6 @@ static int sx150x_remove(struct i2c_client *client)
 static struct i2c_driver sx150x_driver = {
         .driver = {
                 .name = "sx150x",
-                .owner = THIS_MODULE,
                 .of_match_table = of_match_ptr(sx150x_of_match),
         },
         .probe    = sx150x_probe,
diff --git a/drivers/gpio/gpio-syscon.c b/drivers/gpio/gpio-syscon.c
index 7b25fdf64802..e5c5b6205886 100644
--- a/drivers/gpio/gpio-syscon.c
+++ b/drivers/gpio/gpio-syscon.c
@@ -59,14 +59,9 @@ struct syscon_gpio_priv {
         u32                             dir_reg_offset;
 };
 
-static inline struct syscon_gpio_priv *to_syscon_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct syscon_gpio_priv, chip);
-}
-
 static int syscon_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct syscon_gpio_priv *priv = to_syscon_gpio(chip);
+        struct syscon_gpio_priv *priv = gpiochip_get_data(chip);
         unsigned int val, offs;
         int ret;
 
@@ -82,7 +77,7 @@ static int syscon_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void syscon_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct syscon_gpio_priv *priv = to_syscon_gpio(chip);
+        struct syscon_gpio_priv *priv = gpiochip_get_data(chip);
         unsigned int offs;
 
         offs = priv->dreg_offset + priv->data->dat_bit_offset + offset;
@@ -95,7 +90,7 @@ static void syscon_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 
 static int syscon_gpio_dir_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct syscon_gpio_priv *priv = to_syscon_gpio(chip);
+        struct syscon_gpio_priv *priv = gpiochip_get_data(chip);
 
         if (priv->data->flags & GPIO_SYSCON_FEAT_DIR) {
                 unsigned int offs;
@@ -113,7 +108,7 @@ static int syscon_gpio_dir_in(struct gpio_chip *chip, unsigned offset)
 
 static int syscon_gpio_dir_out(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct syscon_gpio_priv *priv = to_syscon_gpio(chip);
+        struct syscon_gpio_priv *priv = gpiochip_get_data(chip);
 
         if (priv->data->flags & GPIO_SYSCON_FEAT_DIR) {
                 unsigned int offs;
@@ -144,7 +139,7 @@ static const struct syscon_gpio_data clps711x_mctrl_gpio = {
 
 static void keystone_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct syscon_gpio_priv *priv = to_syscon_gpio(chip);
+        struct syscon_gpio_priv *priv = gpiochip_get_data(chip);
         unsigned int offs;
         int ret;
 
@@ -159,7 +154,7 @@ static void keystone_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
                         BIT(offs % SYSCON_REG_BITS) | KEYSTONE_LOCK_BIT,
                         BIT(offs % SYSCON_REG_BITS) | KEYSTONE_LOCK_BIT);
         if (ret < 0)
-                dev_err(chip->dev, "gpio write failed ret(%d)\n", ret);
+                dev_err(chip->parent, "gpio write failed ret(%d)\n", ret);
 }
 
 static const struct syscon_gpio_data keystone_dsp_gpio = {
@@ -228,7 +223,7 @@ static int syscon_gpio_probe(struct platform_device *pdev)
                 priv->dir_reg_offset <<= 3;
         }
 
-        priv->chip.dev = dev;
+        priv->chip.parent = dev;
         priv->chip.owner = THIS_MODULE;
         priv->chip.label = dev_name(dev);
         priv->chip.base = -1;
@@ -243,7 +238,7 @@ static int syscon_gpio_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, priv);
 
-        return gpiochip_add(&priv->chip);
+        return gpiochip_add_data(&priv->chip, priv);
 }
 
 static int syscon_gpio_remove(struct platform_device *pdev)
diff --git a/drivers/gpio/gpio-tb10x.c b/drivers/gpio/gpio-tb10x.c
index 4356e6c20fc5..5eaec20ddbc7 100644
--- a/drivers/gpio/gpio-tb10x.c
+++ b/drivers/gpio/gpio-tb10x.c
@@ -87,14 +87,9 @@ static inline void tb10x_set_bits(struct tb10x_gpio *gpio, unsigned int offs,
         spin_unlock_irqrestore(&gpio->spinlock, flags);
 }
 
-static inline struct tb10x_gpio *to_tb10x_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct tb10x_gpio, gc);
-}
-
 static int tb10x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct tb10x_gpio *tb10x_gpio = to_tb10x_gpio(chip);
+        struct tb10x_gpio *tb10x_gpio = gpiochip_get_data(chip);
         int mask = BIT(offset);
         int val = TB10X_GPIO_DIR_IN << offset;
 
@@ -105,7 +100,7 @@ static int tb10x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 
 static int tb10x_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct tb10x_gpio *tb10x_gpio = to_tb10x_gpio(chip);
+        struct tb10x_gpio *tb10x_gpio = gpiochip_get_data(chip);
         int val;
 
         val = tb10x_reg_read(tb10x_gpio, OFFSET_TO_REG_DATA);
@@ -118,7 +113,7 @@ static int tb10x_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void tb10x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct tb10x_gpio *tb10x_gpio = to_tb10x_gpio(chip);
+        struct tb10x_gpio *tb10x_gpio = gpiochip_get_data(chip);
         int mask = BIT(offset);
         int val = value << offset;
 
@@ -128,7 +123,7 @@ static void tb10x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 static int tb10x_gpio_direction_out(struct gpio_chip *chip,
                                         unsigned offset, int value)
 {
-        struct tb10x_gpio *tb10x_gpio = to_tb10x_gpio(chip);
+        struct tb10x_gpio *tb10x_gpio = gpiochip_get_data(chip);
         int mask = BIT(offset);
         int val = TB10X_GPIO_DIR_OUT << offset;
 
@@ -140,7 +135,7 @@ static int tb10x_gpio_direction_out(struct gpio_chip *chip,
 
 static int tb10x_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct tb10x_gpio *tb10x_gpio = to_tb10x_gpio(chip);
+        struct tb10x_gpio *tb10x_gpio = gpiochip_get_data(chip);
 
         return irq_create_mapping(tb10x_gpio->domain, offset);
 }
@@ -197,7 +192,7 @@ static int tb10x_gpio_probe(struct platform_device *pdev)
                 return PTR_ERR(tb10x_gpio->base);
 
         tb10x_gpio->gc.label            = of_node_full_name(dn);
-        tb10x_gpio->gc.dev              = &pdev->dev;
+        tb10x_gpio->gc.parent           = &pdev->dev;
         tb10x_gpio->gc.owner            = THIS_MODULE;
         tb10x_gpio->gc.direction_input  = tb10x_gpio_direction_in;
         tb10x_gpio->gc.get              = tb10x_gpio_get;
@@ -210,7 +205,7 @@ static int tb10x_gpio_probe(struct platform_device *pdev)
         tb10x_gpio->gc.can_sleep        = false;
 
 
-        ret = gpiochip_add(&tb10x_gpio->gc);
+        ret = gpiochip_add_data(&tb10x_gpio->gc, tb10x_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not add gpiochip.\n");
                 goto fail_gpiochip_registration;
diff --git a/drivers/gpio/gpio-tc3589x.c b/drivers/gpio/gpio-tc3589x.c
index d1d585ddb9ab..05a27ec55add 100644
--- a/drivers/gpio/gpio-tc3589x.c
+++ b/drivers/gpio/gpio-tc3589x.c
@@ -34,14 +34,9 @@ struct tc3589x_gpio {
         u8 oldregs[CACHE_NR_REGS][CACHE_NR_BANKS];
 };
 
-static inline struct tc3589x_gpio *to_tc3589x_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct tc3589x_gpio, chip);
-}
-
 static int tc3589x_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(chip);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(chip);
         struct tc3589x *tc3589x = tc3589x_gpio->tc3589x;
         u8 reg = TC3589x_GPIODATA0 + (offset / 8) * 2;
         u8 mask = 1 << (offset % 8);
@@ -51,12 +46,12 @@ static int tc3589x_gpio_get(struct gpio_chip *chip, unsigned offset)
         if (ret < 0)
                 return ret;
 
-        return ret & mask;
+        return !!(ret & mask);
 }
 
 static void tc3589x_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(chip);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(chip);
         struct tc3589x *tc3589x = tc3589x_gpio->tc3589x;
         u8 reg = TC3589x_GPIODATA0 + (offset / 8) * 2;
         unsigned pos = offset % 8;
@@ -68,7 +63,7 @@ static void tc3589x_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 static int tc3589x_gpio_direction_output(struct gpio_chip *chip,
                                          unsigned offset, int val)
 {
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(chip);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(chip);
         struct tc3589x *tc3589x = tc3589x_gpio->tc3589x;
         u8 reg = TC3589x_GPIODIR0 + offset / 8;
         unsigned pos = offset % 8;
@@ -81,7 +76,7 @@ static int tc3589x_gpio_direction_output(struct gpio_chip *chip,
 static int tc3589x_gpio_direction_input(struct gpio_chip *chip,
                                         unsigned offset)
 {
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(chip);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(chip);
         struct tc3589x *tc3589x = tc3589x_gpio->tc3589x;
         u8 reg = TC3589x_GPIODIR0 + offset / 8;
         unsigned pos = offset % 8;
@@ -102,7 +97,7 @@ static struct gpio_chip template_chip = {
 static int tc3589x_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(gc);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
@@ -130,7 +125,7 @@ static int tc3589x_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 static void tc3589x_gpio_irq_lock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(gc);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(gc);
 
         mutex_lock(&tc3589x_gpio->irq_lock);
 }
@@ -138,7 +133,7 @@ static void tc3589x_gpio_irq_lock(struct irq_data *d)
 static void tc3589x_gpio_irq_sync_unlock(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(gc);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(gc);
         struct tc3589x *tc3589x = tc3589x_gpio->tc3589x;
         static const u8 regmap[] = {
                 [REG_IBE]       = TC3589x_GPIOIBE0,
@@ -167,7 +162,7 @@ static void tc3589x_gpio_irq_sync_unlock(struct irq_data *d)
 static void tc3589x_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(gc);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
@@ -178,7 +173,7 @@ static void tc3589x_gpio_irq_mask(struct irq_data *d)
 static void tc3589x_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct tc3589x_gpio *tc3589x_gpio = to_tc3589x_gpio(gc);
+        struct tc3589x_gpio *tc3589x_gpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
@@ -258,7 +253,7 @@ static int tc3589x_gpio_probe(struct platform_device *pdev)
 
         tc3589x_gpio->chip = template_chip;
         tc3589x_gpio->chip.ngpio = tc3589x->num_gpio;
-        tc3589x_gpio->chip.dev = &pdev->dev;
+        tc3589x_gpio->chip.parent = &pdev->dev;
         tc3589x_gpio->chip.base = -1;
         tc3589x_gpio->chip.of_node = np;
 
@@ -277,7 +272,7 @@ static int tc3589x_gpio_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        ret = gpiochip_add(&tc3589x_gpio->chip);
+        ret = gpiochip_add_data(&tc3589x_gpio->chip, tc3589x_gpio);
         if (ret) {
                 dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-tegra.c b/drivers/gpio/gpio-tegra.c
index 896bf29776b0..9a1a7e2ef388 100644
--- a/drivers/gpio/gpio-tegra.c
+++ b/drivers/gpio/gpio-tegra.c
@@ -545,7 +545,7 @@ static int tegra_gpio_probe(struct platform_device *pdev)
 
         tegra_gpio_chip.of_node = pdev->dev.of_node;
 
-        ret = gpiochip_add(&tegra_gpio_chip);
+        ret = gpiochip_add_data(&tegra_gpio_chip, NULL);
         if (ret < 0) {
                 irq_domain_remove(irq_domain);
                 return ret;
diff --git a/drivers/gpio/gpio-timberdale.c b/drivers/gpio/gpio-timberdale.c
index 30653e6319e9..a6de10c5275b 100644
--- a/drivers/gpio/gpio-timberdale.c
+++ b/drivers/gpio/gpio-timberdale.c
@@ -53,7 +53,7 @@ struct timbgpio {
 static int timbgpio_update_bit(struct gpio_chip *gpio, unsigned index,
         unsigned offset, bool enabled)
 {
-        struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio);
+        struct timbgpio *tgpio = gpiochip_get_data(gpio);
         u32 reg;
 
         spin_lock(&tgpio->lock);
@@ -77,7 +77,7 @@ static int timbgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 
 static int timbgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
 {
-        struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio);
+        struct timbgpio *tgpio = gpiochip_get_data(gpio);
         u32 value;
 
         value = ioread32(tgpio->membase + TGPIOVAL);
@@ -98,7 +98,7 @@ static void timbgpio_gpio_set(struct gpio_chip *gpio,
 
 static int timbgpio_to_irq(struct gpio_chip *gpio, unsigned offset)
 {
-        struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio);
+        struct timbgpio *tgpio = gpiochip_get_data(gpio);
 
         if (tgpio->irq_base <= 0)
                 return -EINVAL;
@@ -268,7 +268,7 @@ static int timbgpio_probe(struct platform_device *pdev)
 
         gc->label = dev_name(&pdev->dev);
         gc->owner = THIS_MODULE;
-        gc->dev = &pdev->dev;
+        gc->parent = &pdev->dev;
         gc->direction_input = timbgpio_gpio_direction_input;
         gc->get = timbgpio_gpio_get;
         gc->direction_output = timbgpio_gpio_direction_output;
@@ -279,7 +279,7 @@ static int timbgpio_probe(struct platform_device *pdev)
         gc->ngpio = pdata->nr_pins;
         gc->can_sleep = false;
 
-        err = gpiochip_add(gc);
+        err = gpiochip_add_data(gc, tgpio);
         if (err)
                 return err;
 
diff --git a/drivers/gpio/gpio-tps6586x.c b/drivers/gpio/gpio-tps6586x.c
index 9c9238e838a9..87de5486a29e 100644
--- a/drivers/gpio/gpio-tps6586x.c
+++ b/drivers/gpio/gpio-tps6586x.c
@@ -38,14 +38,9 @@ struct tps6586x_gpio {
         struct device *parent;
 };
 
-static inline struct tps6586x_gpio *to_tps6586x_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct tps6586x_gpio, gpio_chip);
-}
-
 static int tps6586x_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps6586x_gpio *tps6586x_gpio = to_tps6586x_gpio(gc);
+        struct tps6586x_gpio *tps6586x_gpio = gpiochip_get_data(gc);
         uint8_t val;
         int ret;
 
@@ -59,7 +54,7 @@ static int tps6586x_gpio_get(struct gpio_chip *gc, unsigned offset)
 static void tps6586x_gpio_set(struct gpio_chip *gc, unsigned offset,
                               int value)
 {
-        struct tps6586x_gpio *tps6586x_gpio = to_tps6586x_gpio(gc);
+        struct tps6586x_gpio *tps6586x_gpio = gpiochip_get_data(gc);
 
         tps6586x_update(tps6586x_gpio->parent, TPS6586X_GPIOSET2,
                         value << offset, 1 << offset);
@@ -68,7 +63,7 @@ static void tps6586x_gpio_set(struct gpio_chip *gc, unsigned offset,
 static int tps6586x_gpio_output(struct gpio_chip *gc, unsigned offset,
                                 int value)
 {
-        struct tps6586x_gpio *tps6586x_gpio = to_tps6586x_gpio(gc);
+        struct tps6586x_gpio *tps6586x_gpio = gpiochip_get_data(gc);
         uint8_t val, mask;
 
         tps6586x_gpio_set(gc, offset, value);
@@ -82,7 +77,7 @@ static int tps6586x_gpio_output(struct gpio_chip *gc, unsigned offset,
 
 static int tps6586x_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps6586x_gpio *tps6586x_gpio = to_tps6586x_gpio(gc);
+        struct tps6586x_gpio *tps6586x_gpio = gpiochip_get_data(gc);
 
         return tps6586x_irq_get_virq(tps6586x_gpio->parent,
                                 TPS6586X_INT_PLDO_0 + offset);
@@ -104,7 +99,7 @@ static int tps6586x_gpio_probe(struct platform_device *pdev)
 
         tps6586x_gpio->gpio_chip.owner = THIS_MODULE;
         tps6586x_gpio->gpio_chip.label = pdev->name;
-        tps6586x_gpio->gpio_chip.dev = &pdev->dev;
+        tps6586x_gpio->gpio_chip.parent = &pdev->dev;
         tps6586x_gpio->gpio_chip.ngpio = 4;
         tps6586x_gpio->gpio_chip.can_sleep = true;
 
@@ -122,7 +117,7 @@ static int tps6586x_gpio_probe(struct platform_device *pdev)
         else
                 tps6586x_gpio->gpio_chip.base = -1;
 
-        ret = gpiochip_add(&tps6586x_gpio->gpio_chip);
+        ret = gpiochip_add_data(&tps6586x_gpio->gpio_chip, tps6586x_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-tps65910.c b/drivers/gpio/gpio-tps65910.c
index 88f1f5ff4e96..e81eee7627a3 100644
--- a/drivers/gpio/gpio-tps65910.c
+++ b/drivers/gpio/gpio-tps65910.c
@@ -27,14 +27,9 @@ struct tps65910_gpio {
         struct tps65910 *tps65910;
 };
 
-static inline struct tps65910_gpio *to_tps65910_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct tps65910_gpio, gpio_chip);
-}
-
 static int tps65910_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps65910_gpio *tps65910_gpio = to_tps65910_gpio(gc);
+        struct tps65910_gpio *tps65910_gpio = gpiochip_get_data(gc);
         struct tps65910 *tps65910 = tps65910_gpio->tps65910;
         unsigned int val;
 
@@ -49,7 +44,7 @@ static int tps65910_gpio_get(struct gpio_chip *gc, unsigned offset)
 static void tps65910_gpio_set(struct gpio_chip *gc, unsigned offset,
                               int value)
 {
-        struct tps65910_gpio *tps65910_gpio = to_tps65910_gpio(gc);
+        struct tps65910_gpio *tps65910_gpio = gpiochip_get_data(gc);
         struct tps65910 *tps65910 = tps65910_gpio->tps65910;
 
         if (value)
@@ -63,7 +58,7 @@ static void tps65910_gpio_set(struct gpio_chip *gc, unsigned offset,
 static int tps65910_gpio_output(struct gpio_chip *gc, unsigned offset,
                                 int value)
 {
-        struct tps65910_gpio *tps65910_gpio = to_tps65910_gpio(gc);
+        struct tps65910_gpio *tps65910_gpio = gpiochip_get_data(gc);
         struct tps65910 *tps65910 = tps65910_gpio->tps65910;
 
         /* Set the initial value */
@@ -75,7 +70,7 @@ static int tps65910_gpio_output(struct gpio_chip *gc, unsigned offset,
 
 static int tps65910_gpio_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps65910_gpio *tps65910_gpio = to_tps65910_gpio(gc);
+        struct tps65910_gpio *tps65910_gpio = gpiochip_get_data(gc);
         struct tps65910 *tps65910 = tps65910_gpio->tps65910;
 
         return tps65910_reg_clear_bits(tps65910, TPS65910_GPIO0 + offset,
@@ -146,7 +141,7 @@ static int tps65910_gpio_probe(struct platform_device *pdev)
         tps65910_gpio->gpio_chip.direction_output = tps65910_gpio_output;
         tps65910_gpio->gpio_chip.set    = tps65910_gpio_set;
         tps65910_gpio->gpio_chip.get    = tps65910_gpio_get;
-        tps65910_gpio->gpio_chip.dev = &pdev->dev;
+        tps65910_gpio->gpio_chip.parent = &pdev->dev;
 #ifdef CONFIG_OF_GPIO
         tps65910_gpio->gpio_chip.of_node = tps65910->dev->of_node;
 #endif
@@ -175,7 +170,7 @@ static int tps65910_gpio_probe(struct platform_device *pdev)
         }
 
 skip_init:
-        ret = gpiochip_add(&tps65910_gpio->gpio_chip);
+        ret = gpiochip_add_data(&tps65910_gpio->gpio_chip, tps65910_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-tps65912.c b/drivers/gpio/gpio-tps65912.c
index 9cdbc0c9cb2d..4f2029c7da3a 100644
--- a/drivers/gpio/gpio-tps65912.c
+++ b/drivers/gpio/gpio-tps65912.c
@@ -26,11 +26,9 @@ struct tps65912_gpio_data {
         struct gpio_chip gpio_chip;
 };
 
-#define to_tgd(gc) container_of(gc, struct tps65912_gpio_data, gpio_chip)
-
 static int tps65912_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912_gpio_data *tps65912_gpio = gpiochip_get_data(gc);
         struct tps65912 *tps65912 = tps65912_gpio->tps65912;
         int val;
 
@@ -45,7 +43,7 @@ static int tps65912_gpio_get(struct gpio_chip *gc, unsigned offset)
 static void tps65912_gpio_set(struct gpio_chip *gc, unsigned offset,
                               int value)
 {
-        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912_gpio_data *tps65912_gpio = gpiochip_get_data(gc);
         struct tps65912 *tps65912 = tps65912_gpio->tps65912;
 
         if (value)
@@ -59,7 +57,7 @@ static void tps65912_gpio_set(struct gpio_chip *gc, unsigned offset,
 static int tps65912_gpio_output(struct gpio_chip *gc, unsigned offset,
                                 int value)
 {
-        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912_gpio_data *tps65912_gpio = gpiochip_get_data(gc);
         struct tps65912 *tps65912 = tps65912_gpio->tps65912;
 
         /* Set the initial value */
@@ -71,7 +69,7 @@ static int tps65912_gpio_output(struct gpio_chip *gc, unsigned offset,
 
 static int tps65912_gpio_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912_gpio_data *tps65912_gpio = gpiochip_get_data(gc);
         struct tps65912 *tps65912 = tps65912_gpio->tps65912;
 
         return tps65912_clear_bits(tps65912, TPS65912_GPIO1 + offset,
@@ -104,11 +102,11 @@ static int tps65912_gpio_probe(struct platform_device *pdev)
 
         tps65912_gpio->tps65912 = tps65912;
         tps65912_gpio->gpio_chip = template_chip;
-        tps65912_gpio->gpio_chip.dev = &pdev->dev;
+        tps65912_gpio->gpio_chip.parent = &pdev->dev;
         if (pdata && pdata->gpio_base)
                 tps65912_gpio->gpio_chip.base = pdata->gpio_base;
 
-        ret = gpiochip_add(&tps65912_gpio->gpio_chip);
+        ret = gpiochip_add_data(&tps65912_gpio->gpio_chip, tps65912_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Failed to register gpiochip, %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-ts5500.c b/drivers/gpio/gpio-ts5500.c
index b29a102d136b..5f945083f9d8 100644
--- a/drivers/gpio/gpio-ts5500.c
+++ b/drivers/gpio/gpio-ts5500.c
@@ -185,11 +185,6 @@ static const struct ts5500_dio ts5500_lcd[] = {
         TS5500_DIO_IN_IRQ(0x73, 7, 1),
 };
 
-static inline struct ts5500_priv *ts5500_gc_to_priv(struct gpio_chip *chip)
-{
-        return container_of(chip, struct ts5500_priv, gpio_chip);
-}
-
 static inline void ts5500_set_mask(u8 mask, u8 addr)
 {
         u8 val = inb(addr);
@@ -206,7 +201,7 @@ static inline void ts5500_clear_mask(u8 mask, u8 addr)
 
 static int ts5500_gpio_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
+        struct ts5500_priv *priv = gpiochip_get_data(chip);
         const struct ts5500_dio line = priv->pinout[offset];
         unsigned long flags;
 
@@ -225,7 +220,7 @@ static int ts5500_gpio_input(struct gpio_chip *chip, unsigned offset)
 
 static int ts5500_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
+        struct ts5500_priv *priv = gpiochip_get_data(chip);
         const struct ts5500_dio line = priv->pinout[offset];
 
         return !!(inb(line.value_addr) & line.value_mask);
@@ -233,7 +228,7 @@ static int ts5500_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static int ts5500_gpio_output(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
+        struct ts5500_priv *priv = gpiochip_get_data(chip);
         const struct ts5500_dio line = priv->pinout[offset];
         unsigned long flags;
 
@@ -255,7 +250,7 @@ static int ts5500_gpio_output(struct gpio_chip *chip, unsigned offset, int val)
 
 static void ts5500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
+        struct ts5500_priv *priv = gpiochip_get_data(chip);
         const struct ts5500_dio line = priv->pinout[offset];
         unsigned long flags;
 
@@ -269,7 +264,7 @@ static void ts5500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 
 static int ts5500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
+        struct ts5500_priv *priv = gpiochip_get_data(chip);
         const struct ts5500_dio *block = priv->pinout;
         const struct ts5500_dio line = block[offset];
 
@@ -315,7 +310,8 @@ static void ts5500_disable_irq(struct ts5500_priv *priv)
         else if (priv->hwirq == 1)
                 ts5500_clear_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
         else
-                dev_err(priv->gpio_chip.dev, "invalid hwirq %d\n", priv->hwirq);
+                dev_err(priv->gpio_chip.parent, "invalid hwirq %d\n",
+                        priv->hwirq);
         spin_unlock_irqrestore(&priv->lock, flags);
 }
 
@@ -346,7 +342,7 @@ static int ts5500_dio_probe(struct platform_device *pdev)
 
         priv->gpio_chip.owner = THIS_MODULE;
         priv->gpio_chip.label = name;
-        priv->gpio_chip.dev = dev;
+        priv->gpio_chip.parent = dev;
         priv->gpio_chip.direction_input = ts5500_gpio_input;
         priv->gpio_chip.direction_output = ts5500_gpio_output;
         priv->gpio_chip.get = ts5500_gpio_get;
@@ -413,7 +409,7 @@ static int ts5500_dio_probe(struct platform_device *pdev)
                 break;
         }
 
-        ret = gpiochip_add(&priv->gpio_chip);
+        ret = gpiochip_add_data(&priv->gpio_chip, priv);
         if (ret) {
                 dev_err(dev, "failed to register the gpio chip\n");
                 return ret;
diff --git a/drivers/gpio/gpio-twl4030.c b/drivers/gpio/gpio-twl4030.c
index 9e1dbb9877c1..4b807b0e0c8e 100644
--- a/drivers/gpio/gpio-twl4030.c
+++ b/drivers/gpio/gpio-twl4030.c
@@ -76,11 +76,6 @@ struct gpio_twl4030_priv {
 
 /*----------------------------------------------------------------------*/
 
-static inline struct gpio_twl4030_priv *to_gpio_twl4030(struct gpio_chip *chip)
-{
-        return container_of(chip, struct gpio_twl4030_priv, gpio_chip);
-}
-
 /*
  * To configure TWL4030 GPIO module registers
  */
@@ -205,7 +200,7 @@ static int twl4030_get_gpio_datain(int gpio)
 
 static int twl_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
+        struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
         int status = 0;
 
         mutex_lock(&priv->mutex);
@@ -256,7 +251,7 @@ static int twl_request(struct gpio_chip *chip, unsigned offset)
                 /* optionally have the first two GPIOs switch vMMC1
                  * and vMMC2 power supplies based on card presence.
                  */
-                pdata = dev_get_platdata(chip->dev);
+                pdata = dev_get_platdata(chip->parent);
                 if (pdata)
                         value |= pdata->mmc_cd & 0x03;
 
@@ -273,7 +268,7 @@ done:
 
 static void twl_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
+        struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
 
         mutex_lock(&priv->mutex);
         if (offset >= TWL4030_GPIO_MAX) {
@@ -293,7 +288,7 @@ out:
 
 static int twl_direction_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
+        struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
         int ret;
 
         mutex_lock(&priv->mutex);
@@ -312,7 +307,7 @@ static int twl_direction_in(struct gpio_chip *chip, unsigned offset)
 
 static int twl_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
+        struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
         int ret;
         int status = 0;
 
@@ -327,7 +322,7 @@ static int twl_get(struct gpio_chip *chip, unsigned offset)
         else
                 status = twl4030_get_gpio_datain(offset);
 
-        ret = (status <= 0) ? 0 : 1;
+        ret = (status < 0) ? status : !!status;
 out:
         mutex_unlock(&priv->mutex);
         return ret;
@@ -335,7 +330,7 @@ out:
 
 static void twl_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
+        struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
 
         mutex_lock(&priv->mutex);
         if (offset < TWL4030_GPIO_MAX)
@@ -353,7 +348,7 @@ static void twl_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
+        struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
         int ret = 0;
 
         mutex_lock(&priv->mutex);
@@ -379,7 +374,7 @@ static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value)
 
 static int twl_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
+        struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
 
         return (priv->irq_base && (offset < TWL4030_GPIO_MAX))
                 ? (priv->irq_base + offset)
@@ -509,7 +504,7 @@ no_irqs:
         priv->gpio_chip = template_chip;
         priv->gpio_chip.base = -1;
         priv->gpio_chip.ngpio = TWL4030_GPIO_MAX;
-        priv->gpio_chip.dev = &pdev->dev;
+        priv->gpio_chip.parent = &pdev->dev;
 
         mutex_init(&priv->mutex);
 
@@ -544,7 +539,7 @@ no_irqs:
         if (pdata->use_leds)
                 priv->gpio_chip.ngpio += 2;
 
-        ret = gpiochip_add(&priv->gpio_chip);
+        ret = gpiochip_add_data(&priv->gpio_chip, priv);
         if (ret < 0) {
                 dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret);
                 priv->gpio_chip.ngpio = 0;
diff --git a/drivers/gpio/gpio-twl6040.c b/drivers/gpio/gpio-twl6040.c
index c946e7eef3ee..8e9e9853f3bd 100644
--- a/drivers/gpio/gpio-twl6040.c
+++ b/drivers/gpio/gpio-twl6040.c
@@ -36,7 +36,7 @@ static struct gpio_chip twl6040gpo_chip;
 
 static int twl6040gpo_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct twl6040 *twl6040 = dev_get_drvdata(chip->dev->parent);
+        struct twl6040 *twl6040 = dev_get_drvdata(chip->parent->parent);
         int ret = 0;
 
         ret = twl6040_reg_read(twl6040, TWL6040_REG_GPOCTL);
@@ -55,7 +55,7 @@ static int twl6040gpo_direction_out(struct gpio_chip *chip, unsigned offset,
 
 static void twl6040gpo_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct twl6040 *twl6040 = dev_get_drvdata(chip->dev->parent);
+        struct twl6040 *twl6040 = dev_get_drvdata(chip->parent->parent);
         int ret;
         u8 gpoctl;
 
@@ -95,12 +95,12 @@ static int gpo_twl6040_probe(struct platform_device *pdev)
         else
                 twl6040gpo_chip.ngpio = 1; /* twl6041 have 1 GPO */
 
-        twl6040gpo_chip.dev = &pdev->dev;
+        twl6040gpo_chip.parent = &pdev->dev;
 #ifdef CONFIG_OF_GPIO
         twl6040gpo_chip.of_node = twl6040_core_dev->of_node;
 #endif
 
-        ret = gpiochip_add(&twl6040gpo_chip);
+        ret = gpiochip_add_data(&twl6040gpo_chip, NULL);
         if (ret < 0) {
                 dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret);
                 twl6040gpo_chip.ngpio = 0;
diff --git a/drivers/gpio/gpio-tz1090-pdc.c b/drivers/gpio/gpio-tz1090-pdc.c
index 3623d009d808..5b7781741ee9 100644
--- a/drivers/gpio/gpio-tz1090-pdc.c
+++ b/drivers/gpio/gpio-tz1090-pdc.c
@@ -49,7 +49,6 @@ struct tz1090_pdc_gpio {
         void __iomem *reg;
         int irq[GPIO_PDC_NIRQ];
 };
-#define to_pdc(c)       container_of(c, struct tz1090_pdc_gpio, chip)
 
 /* Register accesses into the PDC MMIO area */
 
@@ -70,7 +69,7 @@ static inline unsigned int pdc_read(struct tz1090_pdc_gpio *priv,
 static int tz1090_pdc_gpio_direction_input(struct gpio_chip *chip,
                                            unsigned int offset)
 {
-        struct tz1090_pdc_gpio *priv = to_pdc(chip);
+        struct tz1090_pdc_gpio *priv = gpiochip_get_data(chip);
         u32 value;
         int lstat;
 
@@ -87,7 +86,7 @@ static int tz1090_pdc_gpio_direction_output(struct gpio_chip *chip,
                                             unsigned int offset,
                                             int output_value)
 {
-        struct tz1090_pdc_gpio *priv = to_pdc(chip);
+        struct tz1090_pdc_gpio *priv = gpiochip_get_data(chip);
         u32 value;
         int lstat;
 
@@ -112,14 +111,14 @@ static int tz1090_pdc_gpio_direction_output(struct gpio_chip *chip,
 
 static int tz1090_pdc_gpio_get(struct gpio_chip *chip, unsigned int offset)
 {
-        struct tz1090_pdc_gpio *priv = to_pdc(chip);
-        return pdc_read(priv, REG_SOC_GPIO_STATUS) & BIT(offset);
+        struct tz1090_pdc_gpio *priv = gpiochip_get_data(chip);
+        return !!(pdc_read(priv, REG_SOC_GPIO_STATUS) & BIT(offset));
 }
 
 static void tz1090_pdc_gpio_set(struct gpio_chip *chip, unsigned int offset,
                                 int output_value)
 {
-        struct tz1090_pdc_gpio *priv = to_pdc(chip);
+        struct tz1090_pdc_gpio *priv = gpiochip_get_data(chip);
         u32 value;
         int lstat;
 
@@ -139,7 +138,7 @@ static void tz1090_pdc_gpio_set(struct gpio_chip *chip, unsigned int offset,
 
 static int tz1090_pdc_gpio_to_irq(struct gpio_chip *chip, unsigned int offset)
 {
-        struct tz1090_pdc_gpio *priv = to_pdc(chip);
+        struct tz1090_pdc_gpio *priv = gpiochip_get_data(chip);
         unsigned int syswake = offset - GPIO_PDC_IRQ_FIRST;
         int irq;
 
@@ -188,7 +187,7 @@ static int tz1090_pdc_gpio_probe(struct platform_device *pdev)
 
         /* Set up GPIO chip */
         priv->chip.label                = "tz1090-pdc-gpio";
-        priv->chip.dev                  = &pdev->dev;
+        priv->chip.parent               = &pdev->dev;
         priv->chip.direction_input      = tz1090_pdc_gpio_direction_input;
         priv->chip.direction_output     = tz1090_pdc_gpio_direction_output;
         priv->chip.get                  = tz1090_pdc_gpio_get;
@@ -207,7 +206,7 @@ static int tz1090_pdc_gpio_probe(struct platform_device *pdev)
                 priv->irq[i] = irq_of_parse_and_map(np, i);
 
         /* Add the GPIO bank */
-        gpiochip_add(&priv->chip);
+        gpiochip_add_data(&priv->chip, priv);
 
         return 0;
 }
diff --git a/drivers/gpio/gpio-tz1090.c b/drivers/gpio/gpio-tz1090.c
index 87bb1b1eee8d..ca958e0f6909 100644
--- a/drivers/gpio/gpio-tz1090.c
+++ b/drivers/gpio/gpio-tz1090.c
@@ -62,7 +62,6 @@ struct tz1090_gpio_bank {
         int irq;
         char label[16];
 };
-#define to_bank(c)      container_of(c, struct tz1090_gpio_bank, chip)
 
 /**
  * struct tz1090_gpio - Overall GPIO device private data
@@ -187,7 +186,7 @@ static inline int tz1090_gpio_read_bit(struct tz1090_gpio_bank *bank,
 static int tz1090_gpio_direction_input(struct gpio_chip *chip,
                                        unsigned int offset)
 {
-        struct tz1090_gpio_bank *bank = to_bank(chip);
+        struct tz1090_gpio_bank *bank = gpiochip_get_data(chip);
         tz1090_gpio_set_bit(bank, REG_GPIO_DIR, offset);
 
         return 0;
@@ -196,7 +195,7 @@ static int tz1090_gpio_direction_input(struct gpio_chip *chip,
 static int tz1090_gpio_direction_output(struct gpio_chip *chip,
                                         unsigned int offset, int output_value)
 {
-        struct tz1090_gpio_bank *bank = to_bank(chip);
+        struct tz1090_gpio_bank *bank = gpiochip_get_data(chip);
         int lstat;
 
         __global_lock2(lstat);
@@ -212,9 +211,9 @@ static int tz1090_gpio_direction_output(struct gpio_chip *chip,
  */
 static int tz1090_gpio_get(struct gpio_chip *chip, unsigned int offset)
 {
-        struct tz1090_gpio_bank *bank = to_bank(chip);
+        struct tz1090_gpio_bank *bank = gpiochip_get_data(chip);
 
-        return tz1090_gpio_read_bit(bank, REG_GPIO_DIN, offset);
+        return !!tz1090_gpio_read_bit(bank, REG_GPIO_DIN, offset);
 }
 
 /*
@@ -223,14 +222,14 @@ static int tz1090_gpio_get(struct gpio_chip *chip, unsigned int offset)
 static void tz1090_gpio_set(struct gpio_chip *chip, unsigned int offset,
                             int output_value)
 {
-        struct tz1090_gpio_bank *bank = to_bank(chip);
+        struct tz1090_gpio_bank *bank = gpiochip_get_data(chip);
 
         tz1090_gpio_mod_bit(bank, REG_GPIO_DOUT, offset, output_value);
 }
 
 static int tz1090_gpio_request(struct gpio_chip *chip, unsigned int offset)
 {
-        struct tz1090_gpio_bank *bank = to_bank(chip);
+        struct tz1090_gpio_bank *bank = gpiochip_get_data(chip);
         int ret;
 
         ret = pinctrl_request_gpio(chip->base + offset);
@@ -245,7 +244,7 @@ static int tz1090_gpio_request(struct gpio_chip *chip, unsigned int offset)
 
 static void tz1090_gpio_free(struct gpio_chip *chip, unsigned int offset)
 {
-        struct tz1090_gpio_bank *bank = to_bank(chip);
+        struct tz1090_gpio_bank *bank = gpiochip_get_data(chip);
 
         pinctrl_free_gpio(chip->base + offset);
 
@@ -254,7 +253,7 @@ static void tz1090_gpio_free(struct gpio_chip *chip, unsigned int offset)
 
 static int tz1090_gpio_to_irq(struct gpio_chip *chip, unsigned int offset)
 {
-        struct tz1090_gpio_bank *bank = to_bank(chip);
+        struct tz1090_gpio_bank *bank = gpiochip_get_data(chip);
 
         if (!bank->domain)
                 return -EINVAL;
@@ -425,7 +424,7 @@ static int tz1090_gpio_bank_probe(struct tz1090_gpio_bank_info *info)
         snprintf(bank->label, sizeof(bank->label), "tz1090-gpio-%u",
                  info->index);
         bank->chip.label                = bank->label;
-        bank->chip.dev                  = dev;
+        bank->chip.parent               = dev;
         bank->chip.direction_input      = tz1090_gpio_direction_input;
         bank->chip.direction_output     = tz1090_gpio_direction_output;
         bank->chip.get                  = tz1090_gpio_get;
@@ -440,7 +439,7 @@ static int tz1090_gpio_bank_probe(struct tz1090_gpio_bank_info *info)
         bank->chip.ngpio                = 30;
 
         /* Add the GPIO bank */
-        gpiochip_add(&bank->chip);
+        gpiochip_add_data(&bank->chip, bank);
 
         /* Get the GPIO bank IRQ if provided */
         bank->irq = irq_of_parse_and_map(np, 0);
diff --git a/drivers/gpio/gpio-ucb1400.c b/drivers/gpio/gpio-ucb1400.c
index d502825159b9..2c5cd46bfa6e 100644
--- a/drivers/gpio/gpio-ucb1400.c
+++ b/drivers/gpio/gpio-ucb1400.c
@@ -15,7 +15,7 @@
 static int ucb1400_gpio_dir_in(struct gpio_chip *gc, unsigned off)
 {
         struct ucb1400_gpio *gpio;
-        gpio = container_of(gc, struct ucb1400_gpio, gc);
+        gpio = gpiochip_get_data(gc);
         ucb1400_gpio_set_direction(gpio->ac97, off, 0);
         return 0;
 }
@@ -23,7 +23,7 @@ static int ucb1400_gpio_dir_in(struct gpio_chip *gc, unsigned off)
 static int ucb1400_gpio_dir_out(struct gpio_chip *gc, unsigned off, int val)
 {
         struct ucb1400_gpio *gpio;
-        gpio = container_of(gc, struct ucb1400_gpio, gc);
+        gpio = gpiochip_get_data(gc);
         ucb1400_gpio_set_direction(gpio->ac97, off, 1);
         ucb1400_gpio_set_value(gpio->ac97, off, val);
         return 0;
@@ -32,14 +32,15 @@ static int ucb1400_gpio_dir_out(struct gpio_chip *gc, unsigned off, int val)
 static int ucb1400_gpio_get(struct gpio_chip *gc, unsigned off)
 {
         struct ucb1400_gpio *gpio;
-        gpio = container_of(gc, struct ucb1400_gpio, gc);
-        return ucb1400_gpio_get_value(gpio->ac97, off);
+
+        gpio = gpiochip_get_data(gc);
+        return !!ucb1400_gpio_get_value(gpio->ac97, off);
 }
 
 static void ucb1400_gpio_set(struct gpio_chip *gc, unsigned off, int val)
 {
         struct ucb1400_gpio *gpio;
-        gpio = container_of(gc, struct ucb1400_gpio, gc);
+        gpio = gpiochip_get_data(gc);
         ucb1400_gpio_set_value(gpio->ac97, off, val);
 }
 
@@ -66,7 +67,7 @@ static int ucb1400_gpio_probe(struct platform_device *dev)
         ucb->gc.set = ucb1400_gpio_set;
         ucb->gc.can_sleep = true;
 
-        err = gpiochip_add(&ucb->gc);
+        err = gpiochip_add_data(&ucb->gc, ucb);
         if (err)
                 goto err;
 
diff --git a/drivers/gpio/gpio-vf610.c b/drivers/gpio/gpio-vf610.c
index 87b950cec6ec..6284bdbe1e0c 100644
--- a/drivers/gpio/gpio-vf610.c
+++ b/drivers/gpio/gpio-vf610.c
@@ -62,11 +62,6 @@ struct vf610_gpio_port {
 
 static struct irq_chip vf610_gpio_irq_chip;
 
-static struct vf610_gpio_port *to_vf610_gp(struct gpio_chip *gc)
-{
-        return container_of(gc, struct vf610_gpio_port, gc);
-}
-
 static const struct of_device_id vf610_gpio_dt_ids[] = {
         { .compatible = "fsl,vf610-gpio" },
         { /* sentinel */ }
@@ -84,14 +79,14 @@ static inline u32 vf610_gpio_readl(void __iomem *reg)
 
 static int vf610_gpio_get(struct gpio_chip *gc, unsigned int gpio)
 {
-        struct vf610_gpio_port *port = to_vf610_gp(gc);
+        struct vf610_gpio_port *port = gpiochip_get_data(gc);
 
         return !!(vf610_gpio_readl(port->gpio_base + GPIO_PDIR) & BIT(gpio));
 }
 
 static void vf610_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 {
-        struct vf610_gpio_port *port = to_vf610_gp(gc);
+        struct vf610_gpio_port *port = gpiochip_get_data(gc);
         unsigned long mask = BIT(gpio);
 
         if (val)
@@ -116,7 +111,7 @@ static int vf610_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
 static void vf610_gpio_irq_handler(struct irq_desc *desc)
 {
         struct vf610_gpio_port *port =
-                to_vf610_gp(irq_desc_get_handler_data(desc));
+                gpiochip_get_data(irq_desc_get_handler_data(desc));
         struct irq_chip *chip = irq_desc_get_chip(desc);
         int pin;
         unsigned long irq_isfr;
@@ -137,7 +132,7 @@ static void vf610_gpio_irq_handler(struct irq_desc *desc)
 static void vf610_gpio_irq_ack(struct irq_data *d)
 {
         struct vf610_gpio_port *port =
-                to_vf610_gp(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         int gpio = d->hwirq;
 
         vf610_gpio_writel(BIT(gpio), port->base + PORT_ISFR);
@@ -146,7 +141,7 @@ static void vf610_gpio_irq_ack(struct irq_data *d)
 static int vf610_gpio_irq_set_type(struct irq_data *d, u32 type)
 {
         struct vf610_gpio_port *port =
-                to_vf610_gp(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         u8 irqc;
 
         switch (type) {
@@ -182,7 +177,7 @@ static int vf610_gpio_irq_set_type(struct irq_data *d, u32 type)
 static void vf610_gpio_irq_mask(struct irq_data *d)
 {
         struct vf610_gpio_port *port =
-                to_vf610_gp(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         void __iomem *pcr_base = port->base + PORT_PCR(d->hwirq);
 
         vf610_gpio_writel(0, pcr_base);
@@ -191,7 +186,7 @@ static void vf610_gpio_irq_mask(struct irq_data *d)
 static void vf610_gpio_irq_unmask(struct irq_data *d)
 {
         struct vf610_gpio_port *port =
-                to_vf610_gp(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
         void __iomem *pcr_base = port->base + PORT_PCR(d->hwirq);
 
         vf610_gpio_writel(port->irqc[d->hwirq] << PORT_PCR_IRQC_OFFSET,
@@ -201,7 +196,7 @@ static void vf610_gpio_irq_unmask(struct irq_data *d)
 static int vf610_gpio_irq_set_wake(struct irq_data *d, u32 enable)
 {
         struct vf610_gpio_port *port =
-                to_vf610_gp(irq_data_get_irq_chip_data(d));
+                gpiochip_get_data(irq_data_get_irq_chip_data(d));
 
         if (enable)
                 enable_irq_wake(port->irq);
@@ -249,7 +244,7 @@ static int vf610_gpio_probe(struct platform_device *pdev)
 
         gc = &port->gc;
         gc->of_node = np;
-        gc->dev = dev;
+        gc->parent = dev;
         gc->label = "vf610-gpio";
         gc->ngpio = VF610_GPIO_PER_PORT;
         gc->base = of_alias_get_id(np, "gpio") * VF610_GPIO_PER_PORT;
@@ -261,7 +256,7 @@ static int vf610_gpio_probe(struct platform_device *pdev)
         gc->direction_output = vf610_gpio_direction_output;
         gc->set = vf610_gpio_set;
 
-        ret = gpiochip_add(gc);
+        ret = gpiochip_add_data(gc, port);
         if (ret < 0)
                 return ret;
 
diff --git a/drivers/gpio/gpio-viperboard.c b/drivers/gpio/gpio-viperboard.c
index e2a11f27807f..1170b035cb92 100644
--- a/drivers/gpio/gpio-viperboard.c
+++ b/drivers/gpio/gpio-viperboard.c
@@ -88,14 +88,13 @@ static int vprbrd_gpioa_get(struct gpio_chip *chip,
                 unsigned offset)
 {
         int ret, answer, error = 0;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpioa);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
         struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;
 
         /* if io is set to output, just return the saved value */
         if (gpio->gpioa_out & (1 << offset))
-                return gpio->gpioa_val & (1 << offset);
+                return !!(gpio->gpioa_val & (1 << offset));
 
         mutex_lock(&vb->lock);
 
@@ -139,8 +138,7 @@ static void vprbrd_gpioa_set(struct gpio_chip *chip,
                 unsigned offset, int value)
 {
         int ret;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpioa);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
         struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;
 
@@ -173,7 +171,7 @@ static void vprbrd_gpioa_set(struct gpio_chip *chip,
                 mutex_unlock(&vb->lock);
 
                 if (ret != sizeof(struct vprbrd_gpioa_msg))
-                        dev_err(chip->dev, "usb error setting pin value\n");
+                        dev_err(chip->parent, "usb error setting pin value\n");
         }
 }
 
@@ -181,8 +179,7 @@ static int vprbrd_gpioa_direction_input(struct gpio_chip *chip,
                         unsigned offset)
 {
         int ret;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpioa);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
         struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;
 
@@ -219,8 +216,7 @@ static int vprbrd_gpioa_direction_output(struct gpio_chip *chip,
                         unsigned offset, int value)
 {
         int ret;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpioa);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
         struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;
 
@@ -287,8 +283,7 @@ static int vprbrd_gpiob_get(struct gpio_chip *chip,
 {
         int ret;
         u16 val;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpiob);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
         struct vprbrd_gpiob_msg *gbmsg = (struct vprbrd_gpiob_msg *)vb->buf;
 
@@ -319,8 +314,7 @@ static void vprbrd_gpiob_set(struct gpio_chip *chip,
                 unsigned offset, int value)
 {
         int ret;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpiob);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
         struct vprbrd_gpiob_msg *gbmsg = (struct vprbrd_gpiob_msg *)vb->buf;
 
@@ -345,7 +339,7 @@ static void vprbrd_gpiob_set(struct gpio_chip *chip,
                 mutex_unlock(&vb->lock);
 
                 if (ret != sizeof(struct vprbrd_gpiob_msg))
-                        dev_err(chip->dev, "usb error setting pin value\n");
+                        dev_err(chip->parent, "usb error setting pin value\n");
         }
 }
 
@@ -353,8 +347,7 @@ static int vprbrd_gpiob_direction_input(struct gpio_chip *chip,
                         unsigned offset)
 {
         int ret;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpiob);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
 
         gpio->gpiob_out &= ~(1 << offset);
@@ -366,7 +359,7 @@ static int vprbrd_gpiob_direction_input(struct gpio_chip *chip,
         mutex_unlock(&vb->lock);
 
         if (ret)
-                dev_err(chip->dev, "usb error setting pin to input\n");
+                dev_err(chip->parent, "usb error setting pin to input\n");
 
         return ret;
 }
@@ -375,8 +368,7 @@ static int vprbrd_gpiob_direction_output(struct gpio_chip *chip,
                         unsigned offset, int value)
 {
         int ret;
-        struct vprbrd_gpio *gpio =
-                        container_of(chip, struct vprbrd_gpio, gpiob);
+        struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
         struct vprbrd *vb = gpio->vb;
 
         gpio->gpiob_out |= (1 << offset);
@@ -385,7 +377,7 @@ static int vprbrd_gpiob_direction_output(struct gpio_chip *chip,
 
         ret = vprbrd_gpiob_setdir(vb, offset, 1);
         if (ret)
-                dev_err(chip->dev, "usb error setting pin to output\n");
+                dev_err(chip->parent, "usb error setting pin to output\n");
 
         mutex_unlock(&vb->lock);
 
@@ -409,7 +401,7 @@ static int vprbrd_gpio_probe(struct platform_device *pdev)
         vb_gpio->vb = vb;
         /* registering gpio a */
         vb_gpio->gpioa.label = "viperboard gpio a";
-        vb_gpio->gpioa.dev = &pdev->dev;
+        vb_gpio->gpioa.parent = &pdev->dev;
         vb_gpio->gpioa.owner = THIS_MODULE;
         vb_gpio->gpioa.base = -1;
         vb_gpio->gpioa.ngpio = 16;
@@ -418,15 +410,15 @@ static int vprbrd_gpio_probe(struct platform_device *pdev)
         vb_gpio->gpioa.get = vprbrd_gpioa_get;
         vb_gpio->gpioa.direction_input = vprbrd_gpioa_direction_input;
         vb_gpio->gpioa.direction_output = vprbrd_gpioa_direction_output;
-        ret = gpiochip_add(&vb_gpio->gpioa);
+        ret = gpiochip_add_data(&vb_gpio->gpioa, vb_gpio);
         if (ret < 0) {
-                dev_err(vb_gpio->gpioa.dev, "could not add gpio a");
+                dev_err(vb_gpio->gpioa.parent, "could not add gpio a");
                 goto err_gpioa;
         }
 
         /* registering gpio b */
         vb_gpio->gpiob.label = "viperboard gpio b";
-        vb_gpio->gpiob.dev = &pdev->dev;
+        vb_gpio->gpiob.parent = &pdev->dev;
         vb_gpio->gpiob.owner = THIS_MODULE;
         vb_gpio->gpiob.base = -1;
         vb_gpio->gpiob.ngpio = 16;
@@ -435,9 +427,9 @@ static int vprbrd_gpio_probe(struct platform_device *pdev)
         vb_gpio->gpiob.get = vprbrd_gpiob_get;
         vb_gpio->gpiob.direction_input = vprbrd_gpiob_direction_input;
         vb_gpio->gpiob.direction_output = vprbrd_gpiob_direction_output;
-        ret = gpiochip_add(&vb_gpio->gpiob);
+        ret = gpiochip_add_data(&vb_gpio->gpiob, vb_gpio);
         if (ret < 0) {
-                dev_err(vb_gpio->gpiob.dev, "could not add gpio b");
+                dev_err(vb_gpio->gpiob.parent, "could not add gpio b");
                 goto err_gpiob;
         }
 
diff --git a/drivers/gpio/gpio-vr41xx.c b/drivers/gpio/gpio-vr41xx.c
index c1caa459c02d..ac8deb01f6f6 100644
--- a/drivers/gpio/gpio-vr41xx.c
+++ b/drivers/gpio/gpio-vr41xx.c
@@ -139,7 +139,7 @@ static void unmask_giuint_low(struct irq_data *d)
 static unsigned int startup_giuint(struct irq_data *data)
 {
         if (gpiochip_lock_as_irq(&vr41xx_gpio_chip, data->hwirq))
-                dev_err(vr41xx_gpio_chip.dev,
+                dev_err(vr41xx_gpio_chip.parent,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         data->hwirq);
         /* Satisfy the .enable semantics by unmasking the line */
@@ -542,9 +542,9 @@ static int giu_probe(struct platform_device *pdev)
         if (!giu_base)
                 return -ENOMEM;
 
-        vr41xx_gpio_chip.dev = &pdev->dev;
+        vr41xx_gpio_chip.parent = &pdev->dev;
 
-        ret = gpiochip_add(&vr41xx_gpio_chip);
+        ret = gpiochip_add_data(&vr41xx_gpio_chip, NULL);
         if (!ret) {
                 iounmap(giu_base);
                 return -ENODEV;
diff --git a/drivers/gpio/gpio-vx855.c b/drivers/gpio/gpio-vx855.c
index 57b470d5b39e..764999cc0794 100644
--- a/drivers/gpio/gpio-vx855.c
+++ b/drivers/gpio/gpio-vx855.c
@@ -96,7 +96,7 @@ static inline u_int32_t gpio_o_bit(int i)
 static int vx855gpio_direction_input(struct gpio_chip *gpio,
                                      unsigned int nr)
 {
-        struct vx855_gpio *vg = container_of(gpio, struct vx855_gpio, gpio);
+        struct vx855_gpio *vg = gpiochip_get_data(gpio);
         unsigned long flags;
         u_int32_t reg_out;
 
@@ -120,7 +120,7 @@ static int vx855gpio_direction_input(struct gpio_chip *gpio,
 
 static int vx855gpio_get(struct gpio_chip *gpio, unsigned int nr)
 {
-        struct vx855_gpio *vg = container_of(gpio, struct vx855_gpio, gpio);
+        struct vx855_gpio *vg = gpiochip_get_data(gpio);
         u_int32_t reg_in;
         int ret = 0;
 
@@ -146,7 +146,7 @@ static int vx855gpio_get(struct gpio_chip *gpio, unsigned int nr)
 static void vx855gpio_set(struct gpio_chip *gpio, unsigned int nr,
                           int val)
 {
-        struct vx855_gpio *vg = container_of(gpio, struct vx855_gpio, gpio);
+        struct vx855_gpio *vg = gpiochip_get_data(gpio);
         unsigned long flags;
         u_int32_t reg_out;
 
@@ -259,7 +259,7 @@ static int vx855gpio_probe(struct platform_device *pdev)
 
         vx855gpio_gpio_setup(vg);
 
-        return gpiochip_add(&vg->gpio);
+        return gpiochip_add_data(&vg->gpio, vg);
 }
 
 static int vx855gpio_remove(struct platform_device *pdev)
diff --git a/drivers/gpio/gpio-wm831x.c b/drivers/gpio/gpio-wm831x.c
index 58ce75c188b7..98390070fb64 100644
--- a/drivers/gpio/gpio-wm831x.c
+++ b/drivers/gpio/gpio-wm831x.c
@@ -30,14 +30,9 @@ struct wm831x_gpio {
         struct gpio_chip gpio_chip;
 };
 
-static inline struct wm831x_gpio *to_wm831x_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct wm831x_gpio, gpio_chip);
-}
-
 static int wm831x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
         int val = WM831X_GPN_DIR;
 
@@ -51,7 +46,7 @@ static int wm831x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 
 static int wm831x_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
         int ret;
 
@@ -67,7 +62,7 @@ static int wm831x_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void wm831x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
 
         wm831x_set_bits(wm831x, WM831X_GPIO_LEVEL, 1 << offset,
@@ -77,7 +72,7 @@ static void wm831x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 static int wm831x_gpio_direction_out(struct gpio_chip *chip,
                                      unsigned offset, int value)
 {
-        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
         int val = 0;
         int ret;
@@ -99,7 +94,7 @@ static int wm831x_gpio_direction_out(struct gpio_chip *chip,
 
 static int wm831x_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
 
         return irq_create_mapping(wm831x->irq_domain,
@@ -109,7 +104,7 @@ static int wm831x_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 static int wm831x_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
                                     unsigned debounce)
 {
-        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
         int reg = WM831X_GPIO1_CONTROL + offset;
         int ret, fn;
@@ -140,7 +135,7 @@ static int wm831x_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
 #ifdef CONFIG_DEBUG_FS
 static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
         int i, tristated;
 
@@ -258,13 +253,13 @@ static int wm831x_gpio_probe(struct platform_device *pdev)
         wm831x_gpio->wm831x = wm831x;
         wm831x_gpio->gpio_chip = template_chip;
         wm831x_gpio->gpio_chip.ngpio = wm831x->num_gpio;
-        wm831x_gpio->gpio_chip.dev = &pdev->dev;
+        wm831x_gpio->gpio_chip.parent = &pdev->dev;
         if (pdata && pdata->gpio_base)
                 wm831x_gpio->gpio_chip.base = pdata->gpio_base;
         else
                 wm831x_gpio->gpio_chip.base = -1;
 
-        ret = gpiochip_add(&wm831x_gpio->gpio_chip);
+        ret = gpiochip_add_data(&wm831x_gpio->gpio_chip, wm831x_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-wm8350.c b/drivers/gpio/gpio-wm8350.c
index 060b89303bb6..0a306b4baa73 100644
--- a/drivers/gpio/gpio-wm8350.c
+++ b/drivers/gpio/gpio-wm8350.c
@@ -28,14 +28,9 @@ struct wm8350_gpio_data {
         struct gpio_chip gpio_chip;
 };
 
-static inline struct wm8350_gpio_data *to_wm8350_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct wm8350_gpio_data, gpio_chip);
-}
-
 static int wm8350_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);
+        struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
         struct wm8350 *wm8350 = wm8350_gpio->wm8350;
 
         return wm8350_set_bits(wm8350, WM8350_GPIO_CONFIGURATION_I_O,
@@ -44,7 +39,7 @@ static int wm8350_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 
 static int wm8350_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);
+        struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
         struct wm8350 *wm8350 = wm8350_gpio->wm8350;
         int ret;
 
@@ -60,7 +55,7 @@ static int wm8350_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void wm8350_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);
+        struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
         struct wm8350 *wm8350 = wm8350_gpio->wm8350;
 
         if (value)
@@ -72,7 +67,7 @@ static void wm8350_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 static int wm8350_gpio_direction_out(struct gpio_chip *chip,
                                      unsigned offset, int value)
 {
-        struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);
+        struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
         struct wm8350 *wm8350 = wm8350_gpio->wm8350;
         int ret;
 
@@ -89,7 +84,7 @@ static int wm8350_gpio_direction_out(struct gpio_chip *chip,
 
 static int wm8350_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);
+        struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
         struct wm8350 *wm8350 = wm8350_gpio->wm8350;
 
         if (!wm8350->irq_base)
@@ -124,13 +119,13 @@ static int wm8350_gpio_probe(struct platform_device *pdev)
         wm8350_gpio->wm8350 = wm8350;
         wm8350_gpio->gpio_chip = template_chip;
         wm8350_gpio->gpio_chip.ngpio = 13;
-        wm8350_gpio->gpio_chip.dev = &pdev->dev;
+        wm8350_gpio->gpio_chip.parent = &pdev->dev;
         if (pdata && pdata->gpio_base)
                 wm8350_gpio->gpio_chip.base = pdata->gpio_base;
         else
                 wm8350_gpio->gpio_chip.base = -1;
 
-        ret = gpiochip_add(&wm8350_gpio->gpio_chip);
+        ret = gpiochip_add_data(&wm8350_gpio->gpio_chip, wm8350_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
                 return ret;
diff --git a/drivers/gpio/gpio-wm8994.c b/drivers/gpio/gpio-wm8994.c
index 6f5e42db4b9e..3ae4c1597494 100644
--- a/drivers/gpio/gpio-wm8994.c
+++ b/drivers/gpio/gpio-wm8994.c
@@ -31,14 +31,9 @@ struct wm8994_gpio {
         struct gpio_chip gpio_chip;
 };
 
-static inline struct wm8994_gpio *to_wm8994_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct wm8994_gpio, gpio_chip);
-}
-
 static int wm8994_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
+        struct wm8994_gpio *wm8994_gpio = gpiochip_get_data(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
 
         switch (wm8994->type) {
@@ -61,7 +56,7 @@ static int wm8994_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static int wm8994_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
+        struct wm8994_gpio *wm8994_gpio = gpiochip_get_data(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
 
         return wm8994_set_bits(wm8994, WM8994_GPIO_1 + offset,
@@ -70,7 +65,7 @@ static int wm8994_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 
 static int wm8994_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
+        struct wm8994_gpio *wm8994_gpio = gpiochip_get_data(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
         int ret;
 
@@ -87,7 +82,7 @@ static int wm8994_gpio_get(struct gpio_chip *chip, unsigned offset)
 static int wm8994_gpio_direction_out(struct gpio_chip *chip,
                                      unsigned offset, int value)
 {
-        struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
+        struct wm8994_gpio *wm8994_gpio = gpiochip_get_data(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
 
         if (value)
@@ -99,7 +94,7 @@ static int wm8994_gpio_direction_out(struct gpio_chip *chip,
 
 static void wm8994_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
+        struct wm8994_gpio *wm8994_gpio = gpiochip_get_data(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
 
         if (value)
@@ -110,7 +105,7 @@ static void wm8994_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int wm8994_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
+        struct wm8994_gpio *wm8994_gpio = gpiochip_get_data(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
 
         return regmap_irq_get_virq(wm8994->irq_data, offset);
@@ -174,7 +169,7 @@ static const char *wm8994_gpio_fn(u16 fn)
 
 static void wm8994_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
+        struct wm8994_gpio *wm8994_gpio = gpiochip_get_data(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
         int i;
 
@@ -260,13 +255,13 @@ static int wm8994_gpio_probe(struct platform_device *pdev)
         wm8994_gpio->wm8994 = wm8994;
         wm8994_gpio->gpio_chip = template_chip;
         wm8994_gpio->gpio_chip.ngpio = WM8994_GPIO_MAX;
-        wm8994_gpio->gpio_chip.dev = &pdev->dev;
+        wm8994_gpio->gpio_chip.parent = &pdev->dev;
         if (pdata && pdata->gpio_base)
                 wm8994_gpio->gpio_chip.base = pdata->gpio_base;
         else
                 wm8994_gpio->gpio_chip.base = -1;
 
-        ret = gpiochip_add(&wm8994_gpio->gpio_chip);
+        ret = gpiochip_add_data(&wm8994_gpio->gpio_chip, wm8994_gpio);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
                         ret);
diff --git a/drivers/gpio/gpio-xgene-sb.c b/drivers/gpio/gpio-xgene-sb.c
index d57068b9083e..282004deb5d4 100644
--- a/drivers/gpio/gpio-xgene-sb.c
+++ b/drivers/gpio/gpio-xgene-sb.c
@@ -23,10 +23,8 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/of_gpio.h>
-#include <linux/gpio.h>
 #include <linux/gpio/driver.h>
 #include <linux/acpi.h>
-#include <linux/basic_mmio_gpio.h>
 
 #include "gpiolib.h"
 
@@ -43,38 +41,31 @@
 
 /**
  * struct xgene_gpio_sb - GPIO-Standby private data structure.
- * @bgc:                        memory-mapped GPIO controllers.
+ * @gc:                         memory-mapped GPIO controllers.
  * @irq:                        Mapping GPIO pins and interrupt number
  * nirq:                        Number of GPIO pins that supports interrupt
  */
 struct xgene_gpio_sb {
-        struct bgpio_chip       bgc;
+        struct gpio_chip        gc;
         u32 *irq;
         u32 nirq;
 };
 
-static inline struct xgene_gpio_sb *to_xgene_gpio_sb(struct gpio_chip *gc)
-{
-        struct bgpio_chip *bgc = to_bgpio_chip(gc);
-
-        return container_of(bgc, struct xgene_gpio_sb, bgc);
-}
-
-static void xgene_gpio_set_bit(struct bgpio_chip *bgc, void __iomem *reg, u32 gpio, int val)
+static void xgene_gpio_set_bit(struct gpio_chip *gc, void __iomem *reg, u32 gpio, int val)
 {
         u32 data;
 
-        data = bgc->read_reg(reg);
+        data = gc->read_reg(reg);
         if (val)
                 data |= GPIO_MASK(gpio);
         else
                 data &= ~GPIO_MASK(gpio);
-        bgc->write_reg(reg, data);
+        gc->write_reg(reg, data);
 }
 
 static int apm_gpio_sb_to_irq(struct gpio_chip *gc, u32 gpio)
 {
-        struct xgene_gpio_sb *priv = to_xgene_gpio_sb(gc);
+        struct xgene_gpio_sb *priv = gpiochip_get_data(gc);
 
         if (priv->irq[gpio])
                 return priv->irq[gpio];
@@ -99,15 +90,15 @@ static int xgene_gpio_sb_probe(struct platform_device *pdev)
         if (IS_ERR(regs))
                 return PTR_ERR(regs);
 
-        ret = bgpio_init(&priv->bgc, &pdev->dev, 4,
+        ret = bgpio_init(&priv->gc, &pdev->dev, 4,
                         regs + MPA_GPIO_IN_ADDR,
                         regs + MPA_GPIO_OUT_ADDR, NULL,
                         regs + MPA_GPIO_OE_ADDR, NULL, 0);
         if (ret)
                 return ret;
 
-        priv->bgc.gc.to_irq = apm_gpio_sb_to_irq;
-        priv->bgc.gc.ngpio = XGENE_MAX_GPIO_DS;
+        priv->gc.to_irq = apm_gpio_sb_to_irq;
+        priv->gc.ngpio = XGENE_MAX_GPIO_DS;
 
         priv->nirq = XGENE_MAX_GPIO_DS_IRQ;
 
@@ -118,14 +109,14 @@ static int xgene_gpio_sb_probe(struct platform_device *pdev)
 
         for (i = 0; i < priv->nirq; i++) {
                 priv->irq[default_lines[i]] = platform_get_irq(pdev, i);
-                xgene_gpio_set_bit(&priv->bgc, regs + MPA_GPIO_SEL_LO,
+                xgene_gpio_set_bit(&priv->gc, regs + MPA_GPIO_SEL_LO,
                                    default_lines[i] * 2, 1);
-                xgene_gpio_set_bit(&priv->bgc, regs + MPA_GPIO_INT_LVL, i, 1);
+                xgene_gpio_set_bit(&priv->gc, regs + MPA_GPIO_INT_LVL, i, 1);
         }
 
         platform_set_drvdata(pdev, priv);
 
-        ret = gpiochip_add(&priv->bgc.gc);
+        ret = gpiochip_add_data(&priv->gc, priv);
         if (ret)
                 dev_err(&pdev->dev, "failed to register X-Gene GPIO Standby driver\n");
         else
@@ -133,7 +124,7 @@ static int xgene_gpio_sb_probe(struct platform_device *pdev)
 
         if (priv->nirq > 0) {
                 /* Register interrupt handlers for gpio signaled acpi events */
-                acpi_gpiochip_request_interrupts(&priv->bgc.gc);
+                acpi_gpiochip_request_interrupts(&priv->gc);
         }
 
         return ret;
@@ -144,10 +135,11 @@ static int xgene_gpio_sb_remove(struct platform_device *pdev)
         struct xgene_gpio_sb *priv = platform_get_drvdata(pdev);
 
         if (priv->nirq > 0) {
-                acpi_gpiochip_free_interrupts(&priv->bgc.gc);
+                acpi_gpiochip_free_interrupts(&priv->gc);
         }
 
-        return bgpio_remove(&priv->bgc);
+        gpiochip_remove(&priv->gc);
+        return 0;
 }
 
 static const struct of_device_id xgene_gpio_sb_of_match[] = {
diff --git a/drivers/gpio/gpio-xgene.c b/drivers/gpio/gpio-xgene.c
index 18a8182d4fec..592e9cdf9c53 100644
--- a/drivers/gpio/gpio-xgene.c
+++ b/drivers/gpio/gpio-xgene.c
@@ -47,14 +47,9 @@ struct xgene_gpio {
 #endif
 };
 
-static inline struct xgene_gpio *to_xgene_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct xgene_gpio, chip);
-}
-
 static int xgene_gpio_get(struct gpio_chip *gc, unsigned int offset)
 {
-        struct xgene_gpio *chip = to_xgene_gpio(gc);
+        struct xgene_gpio *chip = gpiochip_get_data(gc);
         unsigned long bank_offset;
         u32 bit_offset;
 
@@ -65,7 +60,7 @@ static int xgene_gpio_get(struct gpio_chip *gc, unsigned int offset)
 
 static void __xgene_gpio_set(struct gpio_chip *gc, unsigned int offset, int val)
 {
-        struct xgene_gpio *chip = to_xgene_gpio(gc);
+        struct xgene_gpio *chip = gpiochip_get_data(gc);
         unsigned long bank_offset;
         u32 setval, bit_offset;
 
@@ -82,7 +77,7 @@ static void __xgene_gpio_set(struct gpio_chip *gc, unsigned int offset, int val)
 
 static void xgene_gpio_set(struct gpio_chip *gc, unsigned int offset, int val)
 {
-        struct xgene_gpio *chip = to_xgene_gpio(gc);
+        struct xgene_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->lock, flags);
@@ -92,7 +87,7 @@ static void xgene_gpio_set(struct gpio_chip *gc, unsigned int offset, int val)
 
 static int xgene_gpio_dir_in(struct gpio_chip *gc, unsigned int offset)
 {
-        struct xgene_gpio *chip = to_xgene_gpio(gc);
+        struct xgene_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags, bank_offset;
         u32 dirval, bit_offset;
 
@@ -113,7 +108,7 @@ static int xgene_gpio_dir_in(struct gpio_chip *gc, unsigned int offset)
 static int xgene_gpio_dir_out(struct gpio_chip *gc,
                                         unsigned int offset, int val)
 {
-        struct xgene_gpio *chip = to_xgene_gpio(gc);
+        struct xgene_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags, bank_offset;
         u32 dirval, bit_offset;
 
@@ -188,7 +183,7 @@ static int xgene_gpio_probe(struct platform_device *pdev)
         gpio->chip.ngpio = XGENE_MAX_GPIOS;
 
         spin_lock_init(&gpio->lock);
-        gpio->chip.dev = &pdev->dev;
+        gpio->chip.parent = &pdev->dev;
         gpio->chip.direction_input = xgene_gpio_dir_in;
         gpio->chip.direction_output = xgene_gpio_dir_out;
         gpio->chip.get = xgene_gpio_get;
@@ -198,7 +193,7 @@ static int xgene_gpio_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, gpio);
 
-        err = gpiochip_add(&gpio->chip);
+        err = gpiochip_add_data(&gpio->chip, gpio);
         if (err) {
                 dev_err(&pdev->dev,
                         "failed to register gpiochip.\n");
diff --git a/drivers/gpio/gpio-xilinx.c b/drivers/gpio/gpio-xilinx.c
index d5284dfe01fe..d0fbb7f99523 100644
--- a/drivers/gpio/gpio-xilinx.c
+++ b/drivers/gpio/gpio-xilinx.c
@@ -92,8 +92,7 @@ static inline int xgpio_offset(struct xgpio_instance *chip, int gpio)
 static int xgpio_get(struct gpio_chip *gc, unsigned int gpio)
 {
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct xgpio_instance *chip =
-            container_of(mm_gc, struct xgpio_instance, mmchip);
+        struct xgpio_instance *chip = gpiochip_get_data(gc);
         u32 val;
 
         val = xgpio_readreg(mm_gc->regs + XGPIO_DATA_OFFSET +
@@ -115,8 +114,7 @@ static void xgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         unsigned long flags;
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct xgpio_instance *chip =
-            container_of(mm_gc, struct xgpio_instance, mmchip);
+        struct xgpio_instance *chip = gpiochip_get_data(gc);
         int index =  xgpio_index(chip, gpio);
         int offset =  xgpio_offset(chip, gpio);
 
@@ -147,8 +145,7 @@ static int xgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
 {
         unsigned long flags;
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct xgpio_instance *chip =
-            container_of(mm_gc, struct xgpio_instance, mmchip);
+        struct xgpio_instance *chip = gpiochip_get_data(gc);
         int index =  xgpio_index(chip, gpio);
         int offset =  xgpio_offset(chip, gpio);
 
@@ -180,8 +177,7 @@ static int xgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 {
         unsigned long flags;
         struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
-        struct xgpio_instance *chip =
-            container_of(mm_gc, struct xgpio_instance, mmchip);
+        struct xgpio_instance *chip = gpiochip_get_data(gc);
         int index =  xgpio_index(chip, gpio);
         int offset =  xgpio_offset(chip, gpio);
 
@@ -212,7 +208,7 @@ static int xgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 static void xgpio_save_regs(struct of_mm_gpio_chip *mm_gc)
 {
         struct xgpio_instance *chip =
-            container_of(mm_gc, struct xgpio_instance, mmchip);
+                container_of(mm_gc, struct xgpio_instance, mmchip);
 
         xgpio_writereg(mm_gc->regs + XGPIO_DATA_OFFSET, chip->gpio_state[0]);
         xgpio_writereg(mm_gc->regs + XGPIO_TRI_OFFSET, chip->gpio_dir[0]);
@@ -305,7 +301,7 @@ static int xgpio_probe(struct platform_device *pdev)
         }
 
         chip->mmchip.gc.ngpio = chip->gpio_width[0] + chip->gpio_width[1];
-        chip->mmchip.gc.dev = &pdev->dev;
+        chip->mmchip.gc.parent = &pdev->dev;
         chip->mmchip.gc.direction_input = xgpio_dir_in;
         chip->mmchip.gc.direction_output = xgpio_dir_out;
         chip->mmchip.gc.get = xgpio_get;
@@ -314,7 +310,7 @@ static int xgpio_probe(struct platform_device *pdev)
         chip->mmchip.save_regs = xgpio_save_regs;
 
         /* Call the OF gpio helper to setup and register the GPIO device */
-        status = of_mm_gpiochip_add(np, &chip->mmchip);
+        status = of_mm_gpiochip_add_data(np, &chip->mmchip, chip);
         if (status) {
                 pr_err("%s: error in probe function with status %d\n",
                        np->full_name, status);
diff --git a/drivers/gpio/gpio-xlp.c b/drivers/gpio/gpio-xlp.c
index bc06a2cd2c1d..aa5813d2deb1 100644
--- a/drivers/gpio/gpio-xlp.c
+++ b/drivers/gpio/gpio-xlp.c
@@ -100,11 +100,6 @@ struct xlp_gpio_priv {
         spinlock_t lock;
 };
 
-static struct xlp_gpio_priv *gpio_chip_to_xlp_priv(struct gpio_chip *gc)
-{
-        return container_of(gc, struct xlp_gpio_priv, chip);
-}
-
 static int xlp_gpio_get_reg(void __iomem *addr, unsigned gpio)
 {
         u32 pos, regset;
@@ -133,7 +128,7 @@ static void xlp_gpio_set_reg(void __iomem *addr, unsigned gpio, int state)
 static void xlp_gpio_irq_disable(struct irq_data *d)
 {
         struct gpio_chip *gc  = irq_data_get_irq_chip_data(d);
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&priv->lock, flags);
@@ -145,7 +140,7 @@ static void xlp_gpio_irq_disable(struct irq_data *d)
 static void xlp_gpio_irq_mask_ack(struct irq_data *d)
 {
         struct gpio_chip *gc  = irq_data_get_irq_chip_data(d);
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&priv->lock, flags);
@@ -158,7 +153,7 @@ static void xlp_gpio_irq_mask_ack(struct irq_data *d)
 static void xlp_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc  = irq_data_get_irq_chip_data(d);
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&priv->lock, flags);
@@ -170,7 +165,7 @@ static void xlp_gpio_irq_unmask(struct irq_data *d)
 static int xlp_gpio_set_irq_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc  = irq_data_get_irq_chip_data(d);
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
         int pol, irq_type;
 
         switch (type) {
@@ -235,7 +230,7 @@ static void xlp_gpio_generic_handler(struct irq_desc *desc)
 
 static int xlp_gpio_dir_output(struct gpio_chip *gc, unsigned gpio, int state)
 {
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
 
         BUG_ON(gpio >= gc->ngpio);
         xlp_gpio_set_reg(priv->gpio_out_en, gpio, 0x1);
@@ -245,7 +240,7 @@ static int xlp_gpio_dir_output(struct gpio_chip *gc, unsigned gpio, int state)
 
 static int xlp_gpio_dir_input(struct gpio_chip *gc, unsigned gpio)
 {
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
 
         BUG_ON(gpio >= gc->ngpio);
         xlp_gpio_set_reg(priv->gpio_out_en, gpio, 0x0);
@@ -255,7 +250,7 @@ static int xlp_gpio_dir_input(struct gpio_chip *gc, unsigned gpio)
 
 static int xlp_gpio_get(struct gpio_chip *gc, unsigned gpio)
 {
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
 
         BUG_ON(gpio >= gc->ngpio);
         return xlp_gpio_get_reg(priv->gpio_paddrv, gpio);
@@ -263,7 +258,7 @@ static int xlp_gpio_get(struct gpio_chip *gc, unsigned gpio)
 
 static void xlp_gpio_set(struct gpio_chip *gc, unsigned gpio, int state)
 {
-        struct xlp_gpio_priv *priv = gpio_chip_to_xlp_priv(gc);
+        struct xlp_gpio_priv *priv = gpiochip_get_data(gc);
 
         BUG_ON(gpio >= gc->ngpio);
         xlp_gpio_set_reg(priv->gpio_paddrv, gpio, state);
@@ -373,7 +368,7 @@ static int xlp_gpio_probe(struct platform_device *pdev)
         gc->owner = THIS_MODULE;
         gc->label = dev_name(&pdev->dev);
         gc->base = 0;
-        gc->dev = &pdev->dev;
+        gc->parent = &pdev->dev;
         gc->ngpio = ngpio;
         gc->of_node = pdev->dev.of_node;
         gc->direction_output = xlp_gpio_dir_output;
@@ -388,7 +383,7 @@ static int xlp_gpio_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        err = gpiochip_add(gc);
+        err = gpiochip_add_data(gc, priv);
         if (err < 0)
                 goto out_free_desc;
 
diff --git a/drivers/gpio/gpio-xtensa.c b/drivers/gpio/gpio-xtensa.c
index 93ec95df67a3..f16c0427952e 100644
--- a/drivers/gpio/gpio-xtensa.c
+++ b/drivers/gpio/gpio-xtensa.c
@@ -148,10 +148,10 @@ static int xtensa_gpio_probe(struct platform_device *pdev)
 {
         int ret;
 
-        ret = gpiochip_add(&impwire_chip);
+        ret = gpiochip_add_data(&impwire_chip, NULL);
         if (ret)
                 return ret;
-        return gpiochip_add(&expstate_chip);
+        return gpiochip_add_data(&expstate_chip, NULL);
 }
 
 static struct platform_driver xtensa_gpio_driver = {
diff --git a/drivers/gpio/gpio-zevio.c b/drivers/gpio/gpio-zevio.c
index 6f02d7c4cc57..cda6d922be98 100644
--- a/drivers/gpio/gpio-zevio.c
+++ b/drivers/gpio/gpio-zevio.c
@@ -52,9 +52,6 @@
 #define ZEVIO_GPIO_INPUT                        0x18
 #define ZEVIO_GPIO_INT_STICKY           0x20
 
-#define to_zevio_gpio(chip) container_of(to_of_mm_gpio_chip(chip), \
-                                struct zevio_gpio, chip)
-
 /* Bit number of GPIO in its section */
 #define ZEVIO_GPIO_BIT(gpio) (gpio&7)
 
@@ -80,7 +77,7 @@ static inline void zevio_gpio_port_set(struct zevio_gpio *c, unsigned pin,
 /* Functions for struct gpio_chip */
 static int zevio_gpio_get(struct gpio_chip *chip, unsigned pin)
 {
-        struct zevio_gpio *controller = to_zevio_gpio(chip);
+        struct zevio_gpio *controller = gpiochip_get_data(chip);
         u32 val, dir;
 
         spin_lock(&controller->lock);
@@ -96,7 +93,7 @@ static int zevio_gpio_get(struct gpio_chip *chip, unsigned pin)
 
 static void zevio_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
 {
-        struct zevio_gpio *controller = to_zevio_gpio(chip);
+        struct zevio_gpio *controller = gpiochip_get_data(chip);
         u32 val;
 
         spin_lock(&controller->lock);
@@ -112,7 +109,7 @@ static void zevio_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
 
 static int zevio_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 {
-        struct zevio_gpio *controller = to_zevio_gpio(chip);
+        struct zevio_gpio *controller = gpiochip_get_data(chip);
         u32 val;
 
         spin_lock(&controller->lock);
@@ -129,7 +126,7 @@ static int zevio_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 static int zevio_gpio_direction_output(struct gpio_chip *chip,
                                        unsigned pin, int value)
 {
-        struct zevio_gpio *controller = to_zevio_gpio(chip);
+        struct zevio_gpio *controller = gpiochip_get_data(chip);
         u32 val;
 
         spin_lock(&controller->lock);
@@ -185,9 +182,11 @@ static int zevio_gpio_probe(struct platform_device *pdev)
 
         /* Copy our reference */
         controller->chip.gc = zevio_gpio_chip;
-        controller->chip.gc.dev = &pdev->dev;
+        controller->chip.gc.parent = &pdev->dev;
 
-        status = of_mm_gpiochip_add(pdev->dev.of_node, &(controller->chip));
+        status = of_mm_gpiochip_add_data(pdev->dev.of_node,
+                                         &(controller->chip),
+                                         controller);
         if (status) {
                 dev_err(&pdev->dev, "failed to add gpiochip: %d\n", status);
                 return status;
@@ -199,7 +198,7 @@ static int zevio_gpio_probe(struct platform_device *pdev)
         for (i = 0; i < controller->chip.gc.ngpio; i += 8)
                 zevio_gpio_port_set(controller, i, ZEVIO_GPIO_INT_MASK, 0xFF);
 
-        dev_dbg(controller->chip.gc.dev, "ZEVIO GPIO controller set up!\n");
+        dev_dbg(controller->chip.gc.parent, "ZEVIO GPIO controller set up!\n");
 
         return 0;
 }
diff --git a/drivers/gpio/gpio-zx.c b/drivers/gpio/gpio-zx.c
index 1dcf7a66dd36..47c79fa65670 100644
--- a/drivers/gpio/gpio-zx.c
+++ b/drivers/gpio/gpio-zx.c
@@ -43,14 +43,9 @@ struct zx_gpio {
         struct gpio_chip        gc;
 };
 
-static inline struct zx_gpio *to_zx(struct gpio_chip *gc)
-{
-        return container_of(gc, struct zx_gpio, gc);
-}
-
 static int zx_direction_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
         u16 gpiodir;
 
@@ -69,7 +64,7 @@ static int zx_direction_input(struct gpio_chip *gc, unsigned offset)
 static int zx_direction_output(struct gpio_chip *gc, unsigned offset,
                 int value)
 {
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
         u16 gpiodir;
 
@@ -92,14 +87,14 @@ static int zx_direction_output(struct gpio_chip *gc, unsigned offset,
 
 static int zx_get_value(struct gpio_chip *gc, unsigned offset)
 {
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
 
         return !!(readw_relaxed(chip->base + ZX_GPIO_DI) & BIT(offset));
 }
 
 static void zx_set_value(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
 
         if (value)
                 writew_relaxed(BIT(offset), chip->base + ZX_GPIO_DO1);
@@ -110,7 +105,7 @@ static void zx_set_value(struct gpio_chip *gc, unsigned offset, int value)
 static int zx_irq_type(struct irq_data *d, unsigned trigger)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
         int offset = irqd_to_hwirq(d);
         unsigned long flags;
         u16 gpiois, gpioi_epos, gpioi_eneg, gpioiev;
@@ -162,7 +157,7 @@ static void zx_irq_handler(struct irq_desc *desc)
         unsigned long pending;
         int offset;
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
         struct irq_chip *irqchip = irq_desc_get_chip(desc);
 
         chained_irq_enter(irqchip, desc);
@@ -181,7 +176,7 @@ static void zx_irq_handler(struct irq_desc *desc)
 static void zx_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
         u16 mask = BIT(irqd_to_hwirq(d) % ZX_GPIO_NR);
         u16 gpioie;
 
@@ -196,7 +191,7 @@ static void zx_irq_mask(struct irq_data *d)
 static void zx_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct zx_gpio *chip = to_zx(gc);
+        struct zx_gpio *chip = gpiochip_get_data(gc);
         u16 mask = BIT(irqd_to_hwirq(d) % ZX_GPIO_NR);
         u16 gpioie;
 
@@ -245,10 +240,10 @@ static int zx_gpio_probe(struct platform_device *pdev)
         chip->gc.base = ZX_GPIO_NR * id;
         chip->gc.ngpio = ZX_GPIO_NR;
         chip->gc.label = dev_name(dev);
-        chip->gc.dev = dev;
+        chip->gc.parent = dev;
         chip->gc.owner = THIS_MODULE;
 
-        ret = gpiochip_add(&chip->gc);
+        ret = gpiochip_add_data(&chip->gc, chip);
         if (ret)
                 return ret;
 
diff --git a/drivers/gpio/gpio-zynq.c b/drivers/gpio/gpio-zynq.c
index 8abeacac5885..66d3d247d76d 100644
--- a/drivers/gpio/gpio-zynq.c
+++ b/drivers/gpio/gpio-zynq.c
@@ -131,11 +131,6 @@ struct zynq_platform_data {
 static struct irq_chip zynq_gpio_level_irqchip;
 static struct irq_chip zynq_gpio_edge_irqchip;
 
-static struct zynq_gpio *to_zynq_gpio(struct gpio_chip *gc)
-{
-        return container_of(gc, struct zynq_gpio, chip);
-}
-
 /**
  * zynq_gpio_get_bank_pin - Get the bank number and pin number within that bank
  * for a given pin in the GPIO device
@@ -183,7 +178,7 @@ static int zynq_gpio_get_value(struct gpio_chip *chip, unsigned int pin)
 {
         u32 data;
         unsigned int bank_num, bank_pin_num;
-        struct zynq_gpio *gpio = to_zynq_gpio(chip);
+        struct zynq_gpio *gpio = gpiochip_get_data(chip);
 
         zynq_gpio_get_bank_pin(pin, &bank_num, &bank_pin_num, gpio);
 
@@ -207,7 +202,7 @@ static void zynq_gpio_set_value(struct gpio_chip *chip, unsigned int pin,
                                 int state)
 {
         unsigned int reg_offset, bank_num, bank_pin_num;
-        struct zynq_gpio *gpio = to_zynq_gpio(chip);
+        struct zynq_gpio *gpio = gpiochip_get_data(chip);
 
         zynq_gpio_get_bank_pin(pin, &bank_num, &bank_pin_num, gpio);
 
@@ -244,7 +239,7 @@ static int zynq_gpio_dir_in(struct gpio_chip *chip, unsigned int pin)
 {
         u32 reg;
         unsigned int bank_num, bank_pin_num;
-        struct zynq_gpio *gpio = to_zynq_gpio(chip);
+        struct zynq_gpio *gpio = gpiochip_get_data(chip);
 
         zynq_gpio_get_bank_pin(pin, &bank_num, &bank_pin_num, gpio);
 
@@ -277,7 +272,7 @@ static int zynq_gpio_dir_out(struct gpio_chip *chip, unsigned int pin,
 {
         u32 reg;
         unsigned int bank_num, bank_pin_num;
-        struct zynq_gpio *gpio = to_zynq_gpio(chip);
+        struct zynq_gpio *gpio = gpiochip_get_data(chip);
 
         zynq_gpio_get_bank_pin(pin, &bank_num, &bank_pin_num, gpio);
 
@@ -308,7 +303,7 @@ static void zynq_gpio_irq_mask(struct irq_data *irq_data)
 {
         unsigned int device_pin_num, bank_num, bank_pin_num;
         struct zynq_gpio *gpio =
-                to_zynq_gpio(irq_data_get_irq_chip_data(irq_data));
+                gpiochip_get_data(irq_data_get_irq_chip_data(irq_data));
 
         device_pin_num = irq_data->hwirq;
         zynq_gpio_get_bank_pin(device_pin_num, &bank_num, &bank_pin_num, gpio);
@@ -329,7 +324,7 @@ static void zynq_gpio_irq_unmask(struct irq_data *irq_data)
 {
         unsigned int device_pin_num, bank_num, bank_pin_num;
         struct zynq_gpio *gpio =
-                to_zynq_gpio(irq_data_get_irq_chip_data(irq_data));
+                gpiochip_get_data(irq_data_get_irq_chip_data(irq_data));
 
         device_pin_num = irq_data->hwirq;
         zynq_gpio_get_bank_pin(device_pin_num, &bank_num, &bank_pin_num, gpio);
@@ -349,7 +344,7 @@ static void zynq_gpio_irq_ack(struct irq_data *irq_data)
 {
         unsigned int device_pin_num, bank_num, bank_pin_num;
         struct zynq_gpio *gpio =
-                to_zynq_gpio(irq_data_get_irq_chip_data(irq_data));
+                gpiochip_get_data(irq_data_get_irq_chip_data(irq_data));
 
         device_pin_num = irq_data->hwirq;
         zynq_gpio_get_bank_pin(device_pin_num, &bank_num, &bank_pin_num, gpio);
@@ -400,7 +395,7 @@ static int zynq_gpio_set_irq_type(struct irq_data *irq_data, unsigned int type)
         u32 int_type, int_pol, int_any;
         unsigned int device_pin_num, bank_num, bank_pin_num;
         struct zynq_gpio *gpio =
-                to_zynq_gpio(irq_data_get_irq_chip_data(irq_data));
+                gpiochip_get_data(irq_data_get_irq_chip_data(irq_data));
 
         device_pin_num = irq_data->hwirq;
         zynq_gpio_get_bank_pin(device_pin_num, &bank_num, &bank_pin_num, gpio);
@@ -464,7 +459,7 @@ static int zynq_gpio_set_irq_type(struct irq_data *irq_data, unsigned int type)
 static int zynq_gpio_set_wake(struct irq_data *data, unsigned int on)
 {
         struct zynq_gpio *gpio =
-                to_zynq_gpio(irq_data_get_irq_chip_data(data));
+                gpiochip_get_data(irq_data_get_irq_chip_data(data));
 
         irq_set_irq_wake(gpio->irq, on);
 
@@ -530,7 +525,7 @@ static void zynq_gpio_irqhandler(struct irq_desc *desc)
         u32 int_sts, int_enb;
         unsigned int bank_num;
         struct zynq_gpio *gpio =
-                to_zynq_gpio(irq_desc_get_handler_data(desc));
+                gpiochip_get_data(irq_desc_get_handler_data(desc));
         struct irq_chip *irqchip = irq_desc_get_chip(desc);
 
         chained_irq_enter(irqchip, desc);
@@ -592,7 +587,7 @@ static int zynq_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
         int ret;
 
-        ret = pm_runtime_get_sync(chip->dev);
+        ret = pm_runtime_get_sync(chip->parent);
 
         /*
          * If the device is already active pm_runtime_get() will return 1 on
@@ -603,7 +598,7 @@ static int zynq_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void zynq_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        pm_runtime_put(chip->dev);
+        pm_runtime_put(chip->parent);
 }
 
 static const struct dev_pm_ops zynq_gpio_dev_pm_ops = {
@@ -698,7 +693,7 @@ static int zynq_gpio_probe(struct platform_device *pdev)
         chip = &gpio->chip;
         chip->label = gpio->p_data->label;
         chip->owner = THIS_MODULE;
-        chip->dev = &pdev->dev;
+        chip->parent = &pdev->dev;
         chip->get = zynq_gpio_get_value;
         chip->set = zynq_gpio_set_value;
         chip->request = zynq_gpio_request;
@@ -708,23 +703,23 @@ static int zynq_gpio_probe(struct platform_device *pdev)
         chip->base = -1;
         chip->ngpio = gpio->p_data->ngpio;
 
-        /* Enable GPIO clock */
+        /* Retrieve GPIO clock */
         gpio->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(gpio->clk)) {
                 dev_err(&pdev->dev, "input clock not found.\n");
                 return PTR_ERR(gpio->clk);
         }
-        ret = clk_prepare_enable(gpio->clk);
-        if (ret) {
-                dev_err(&pdev->dev, "Unable to enable clock.\n");
+
+        pm_runtime_enable(&pdev->dev);
+        ret = pm_runtime_get_sync(&pdev->dev);
+        if (ret < 0)
                 return ret;
-        }
 
         /* report a bug if gpio chip registration fails */
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, gpio);
         if (ret) {
                 dev_err(&pdev->dev, "Failed to add gpio chip\n");
-                goto err_disable_clk;
+                goto err_pm_put;
         }
 
         /* disable interrupts for all banks */
@@ -742,15 +737,14 @@ static int zynq_gpio_probe(struct platform_device *pdev)
         gpiochip_set_chained_irqchip(chip, &zynq_gpio_edge_irqchip, gpio->irq,
                                      zynq_gpio_irqhandler);
 
-        pm_runtime_set_active(&pdev->dev);
-        pm_runtime_enable(&pdev->dev);
+        pm_runtime_put(&pdev->dev);
 
         return 0;
 
 err_rm_gpiochip:
         gpiochip_remove(chip);
-err_disable_clk:
-        clk_disable_unprepare(gpio->clk);
+err_pm_put:
+        pm_runtime_put(&pdev->dev);
 
         return ret;
 }
diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
index bc34bc51a948..540cbc88c7a2 100644
--- a/drivers/gpio/gpiolib-acpi.c
+++ b/drivers/gpio/gpiolib-acpi.c
@@ -51,10 +51,10 @@ struct acpi_gpio_chip {
 
 static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
 {
-        if (!gc->dev)
+        if (!gc->parent)
                 return false;
 
-        return ACPI_HANDLE(gc->dev) == data;
+        return ACPI_HANDLE(gc->parent) == data;
 }
 
 #ifdef CONFIG_PINCTRL
@@ -184,7 +184,7 @@ static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares,
         if (agpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT)
                 return AE_OK;
 
-        handle = ACPI_HANDLE(chip->dev);
+        handle = ACPI_HANDLE(chip->parent);
         pin = agpio->pin_table[0];
 
         if (pin <= 255) {
@@ -208,7 +208,7 @@ static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares,
 
         desc = gpiochip_request_own_desc(chip, pin, "ACPI:Event");
         if (IS_ERR(desc)) {
-                dev_err(chip->dev, "Failed to request GPIO\n");
+                dev_err(chip->parent, "Failed to request GPIO\n");
                 return AE_ERROR;
         }
 
@@ -216,13 +216,13 @@ static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares,
 
         ret = gpiochip_lock_as_irq(chip, pin);
         if (ret) {
-                dev_err(chip->dev, "Failed to lock GPIO as interrupt\n");
+                dev_err(chip->parent, "Failed to lock GPIO as interrupt\n");
                 goto fail_free_desc;
         }
 
         irq = gpiod_to_irq(desc);
         if (irq < 0) {
-                dev_err(chip->dev, "Failed to translate GPIO to IRQ\n");
+                dev_err(chip->parent, "Failed to translate GPIO to IRQ\n");
                 goto fail_unlock_irq;
         }
 
@@ -259,7 +259,8 @@ static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares,
         ret = request_threaded_irq(event->irq, NULL, handler, irqflags,
                                    "ACPI:Event", event);
         if (ret) {
-                dev_err(chip->dev, "Failed to setup interrupt handler for %d\n",
+                dev_err(chip->parent,
+                        "Failed to setup interrupt handler for %d\n",
                         event->irq);
                 goto fail_free_event;
         }
@@ -293,10 +294,10 @@ void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
         acpi_handle handle;
         acpi_status status;
 
-        if (!chip->dev || !chip->to_irq)
+        if (!chip->parent || !chip->to_irq)
                 return;
 
-        handle = ACPI_HANDLE(chip->dev);
+        handle = ACPI_HANDLE(chip->parent);
         if (!handle)
                 return;
 
@@ -323,10 +324,10 @@ void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
         acpi_handle handle;
         acpi_status status;
 
-        if (!chip->dev || !chip->to_irq)
+        if (!chip->parent || !chip->to_irq)
                 return;
 
-        handle = ACPI_HANDLE(chip->dev);
+        handle = ACPI_HANDLE(chip->parent);
         if (!handle)
                 return;
 
@@ -769,7 +770,7 @@ out:
 static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)
 {
         struct gpio_chip *chip = achip->chip;
-        acpi_handle handle = ACPI_HANDLE(chip->dev);
+        acpi_handle handle = ACPI_HANDLE(chip->parent);
         acpi_status status;
 
         INIT_LIST_HEAD(&achip->conns);
@@ -778,20 +779,22 @@ static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)
                                                     acpi_gpio_adr_space_handler,
                                                     NULL, achip);
         if (ACPI_FAILURE(status))
-                dev_err(chip->dev, "Failed to install GPIO OpRegion handler\n");
+                dev_err(chip->parent,
+                        "Failed to install GPIO OpRegion handler\n");
 }
 
 static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip)
 {
         struct gpio_chip *chip = achip->chip;
-        acpi_handle handle = ACPI_HANDLE(chip->dev);
+        acpi_handle handle = ACPI_HANDLE(chip->parent);
         struct acpi_gpio_connection *conn, *tmp;
         acpi_status status;
 
         status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
                                                    acpi_gpio_adr_space_handler);
         if (ACPI_FAILURE(status)) {
-                dev_err(chip->dev, "Failed to remove GPIO OpRegion handler\n");
+                dev_err(chip->parent,
+                        "Failed to remove GPIO OpRegion handler\n");
                 return;
         }
 
@@ -808,16 +811,16 @@ void acpi_gpiochip_add(struct gpio_chip *chip)
         acpi_handle handle;
         acpi_status status;
 
-        if (!chip || !chip->dev)
+        if (!chip || !chip->parent)
                 return;
 
-        handle = ACPI_HANDLE(chip->dev);
+        handle = ACPI_HANDLE(chip->parent);
         if (!handle)
                 return;
 
         acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);
         if (!acpi_gpio) {
-                dev_err(chip->dev,
+                dev_err(chip->parent,
                         "Failed to allocate memory for ACPI GPIO chip\n");
                 return;
         }
@@ -827,7 +830,7 @@ void acpi_gpiochip_add(struct gpio_chip *chip)
 
         status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio);
         if (ACPI_FAILURE(status)) {
-                dev_err(chip->dev, "Failed to attach ACPI GPIO chip\n");
+                dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n");
                 kfree(acpi_gpio);
                 return;
         }
@@ -841,16 +844,16 @@ void acpi_gpiochip_remove(struct gpio_chip *chip)
         acpi_handle handle;
         acpi_status status;
 
-        if (!chip || !chip->dev)
+        if (!chip || !chip->parent)
                 return;
 
-        handle = ACPI_HANDLE(chip->dev);
+        handle = ACPI_HANDLE(chip->parent);
         if (!handle)
                 return;
 
         status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
         if (ACPI_FAILURE(status)) {
-                dev_warn(chip->dev, "Failed to retrieve ACPI GPIO chip\n");
+                dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n");
                 return;
         }
 
diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c
index 5fe34a9df3e6..42a4bb7cf49a 100644
--- a/drivers/gpio/gpiolib-of.c
+++ b/drivers/gpio/gpiolib-of.c
@@ -262,9 +262,10 @@ int of_gpio_simple_xlate(struct gpio_chip *gc,
 EXPORT_SYMBOL(of_gpio_simple_xlate);
 
 /**
- * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
+ * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
  * @np:         device node of the GPIO chip
  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
+ * @data:       driver data to store in the struct gpio_chip
  *
  * To use this function you should allocate and fill mm_gc with:
  *
@@ -280,8 +281,9 @@ EXPORT_SYMBOL(of_gpio_simple_xlate);
  * do all necessary work for you. Then you'll able to use .regs
  * to manage GPIOs from the callbacks.
  */
-int of_mm_gpiochip_add(struct device_node *np,
-                       struct of_mm_gpio_chip *mm_gc)
+int of_mm_gpiochip_add_data(struct device_node *np,
+                            struct of_mm_gpio_chip *mm_gc,
+                            void *data)
 {
         int ret = -ENOMEM;
         struct gpio_chip *gc = &mm_gc->gc;
@@ -301,7 +303,7 @@ int of_mm_gpiochip_add(struct device_node *np,
 
         mm_gc->gc.of_node = np;
 
-        ret = gpiochip_add(gc);
+        ret = gpiochip_add_data(gc, data);
         if (ret)
                 goto err2;
 
@@ -315,7 +317,7 @@ err0:
                np->full_name, ret);
         return ret;
 }
-EXPORT_SYMBOL(of_mm_gpiochip_add);
+EXPORT_SYMBOL(of_mm_gpiochip_add_data);
 
 /**
  * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
@@ -423,8 +425,8 @@ int of_gpiochip_add(struct gpio_chip *chip)
 {
         int status;
 
-        if ((!chip->of_node) && (chip->dev))
-                chip->of_node = chip->dev->of_node;
+        if ((!chip->of_node) && (chip->parent))
+                chip->of_node = chip->parent->of_node;
 
         if (!chip->of_node)
                 return 0;
diff --git a/drivers/gpio/gpiolib-sysfs.c b/drivers/gpio/gpiolib-sysfs.c
index b57ed8e55ab5..405dfcaadc4c 100644
--- a/drivers/gpio/gpiolib-sysfs.c
+++ b/drivers/gpio/gpiolib-sysfs.c
@@ -605,7 +605,7 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
         if (chip->names && chip->names[offset])
                 ioname = chip->names[offset];
 
-        dev = device_create_with_groups(&gpio_class, chip->dev,
+        dev = device_create_with_groups(&gpio_class, chip->parent,
                                         MKDEV(0, 0), data, gpio_groups,
                                         ioname ? ioname : "gpio%u",
                                         desc_to_gpio(desc));
@@ -730,7 +730,8 @@ int gpiochip_sysfs_register(struct gpio_chip *chip)
                 return 0;
 
         /* use chip->base for the ID; it's already known to be unique */
-        dev = device_create_with_groups(&gpio_class, chip->dev, MKDEV(0, 0),
+        dev = device_create_with_groups(&gpio_class, chip->parent,
+                                        MKDEV(0, 0),
                                         chip, gpiochip_groups,
                                         "gpiochip%d", chip->base);
         if (IS_ERR(dev))
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 3346abd29b52..5c1ba879f889 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -182,39 +182,62 @@ EXPORT_SYMBOL_GPL(gpiod_get_direction);
 
 /*
  * Add a new chip to the global chips list, keeping the list of chips sorted
- * by base order.
+ * by range(means [base, base + ngpio - 1]) order.
  *
  * Return -EBUSY if the new chip overlaps with some other chip's integer
  * space.
  */
 static int gpiochip_add_to_list(struct gpio_chip *chip)
 {
-        struct list_head *pos;
-        struct gpio_chip *_chip;
-        int err = 0;
+        struct gpio_chip *iterator;
+        struct gpio_chip *previous = NULL;
 
-        /* find where to insert our chip */
-        list_for_each(pos, &gpio_chips) {
-                _chip = list_entry(pos, struct gpio_chip, list);
-                /* shall we insert before _chip? */
-                if (_chip->base >= chip->base + chip->ngpio)
-                        break;
+        if (list_empty(&gpio_chips)) {
+                list_add_tail(&chip->list, &gpio_chips);
+                return 0;
         }
 
-        /* are we stepping on the chip right before? */
-        if (pos != &gpio_chips && pos->prev != &gpio_chips) {
-                _chip = list_entry(pos->prev, struct gpio_chip, list);
-                if (_chip->base + _chip->ngpio > chip->base) {
-                        dev_err(chip->dev,
-                               "GPIO integer space overlap, cannot add chip\n");
-                        err = -EBUSY;
+        list_for_each_entry(iterator, &gpio_chips, list) {
+                if (iterator->base >= chip->base + chip->ngpio) {
+                        /*
+                         * Iterator is the first GPIO chip so there is no
+                         * previous one
+                         */
+                        if (!previous) {
+                                goto found;
+                        } else {
+                                /*
+                                 * We found a valid range(means
+                                 * [base, base + ngpio - 1]) between previous
+                                 * and iterator chip.
+                                 */
+                                if (previous->base + previous->ngpio
+                                                <= chip->base)
+                                        goto found;
+                        }
                 }
+                previous = iterator;
+        }
+
+        /*
+         * We are beyond the last chip in the list and iterator now
+         * points to the head.
+         * Let iterator point to the last chip in the list.
+         */
+
+        iterator = list_last_entry(&gpio_chips, struct gpio_chip, list);
+        if (iterator->base + iterator->ngpio <= chip->base) {
+                list_add(&chip->list, &iterator->list);
+                return 0;
         }
 
-        if (!err)
-                list_add_tail(&chip->list, pos);
+        dev_err(chip->parent,
+               "GPIO integer space overlap, cannot add chip\n");
+        return -EBUSY;
 
-        return err;
+found:
+        list_add_tail(&chip->list, &iterator->list);
+        return 0;
 }
 
 /**
@@ -252,7 +275,7 @@ static struct gpio_desc *gpio_name_to_desc(const char * const name)
  * Takes the names from gc->names and checks if they are all unique. If they
  * are, they are assigned to their gpio descriptors.
  *
- * Returns -EEXIST if one of the names is already used for a different GPIO.
+ * Warning if one of the names is already used for a different GPIO.
  */
 static int gpiochip_set_desc_names(struct gpio_chip *gc)
 {
@@ -267,7 +290,7 @@ static int gpiochip_set_desc_names(struct gpio_chip *gc)
 
                 gpio = gpio_name_to_desc(gc->names[i]);
                 if (gpio)
-                        dev_warn(gc->dev, "Detected name collision for "
+                        dev_warn(gc->parent, "Detected name collision for "
                                  "GPIO name '%s'\n",
                                  gc->names[i]);
         }
@@ -280,7 +303,7 @@ static int gpiochip_set_desc_names(struct gpio_chip *gc)
 }
 
 /**
- * gpiochip_add() - register a gpio_chip
+ * gpiochip_add_data() - register a gpio_chip
  * @chip: the chip to register, with chip->base initialized
  * Context: potentially before irqs will work
  *
@@ -288,15 +311,15 @@ static int gpiochip_set_desc_names(struct gpio_chip *gc)
  * because the chip->base is invalid or already associated with a
  * different chip.  Otherwise it returns zero as a success code.
  *
- * When gpiochip_add() is called very early during boot, so that GPIOs
- * can be freely used, the chip->dev device must be registered before
+ * When gpiochip_add_data() is called very early during boot, so that GPIOs
+ * can be freely used, the chip->parent device must be registered before
  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
  * for GPIOs will fail rudely.
  *
  * If chip->base is negative, this requests dynamic assignment of
  * a range of valid GPIOs.
  */
-int gpiochip_add(struct gpio_chip *chip)
+int gpiochip_add_data(struct gpio_chip *chip, void *data)
 {
         unsigned long   flags;
         int             status = 0;
@@ -308,6 +331,13 @@ int gpiochip_add(struct gpio_chip *chip)
         if (!descs)
                 return -ENOMEM;
 
+        chip->data = data;
+
+        if (chip->ngpio == 0) {
+                chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
+                return -EINVAL;
+        }
+
         spin_lock_irqsave(&gpio_lock, flags);
 
         if (base < 0) {
@@ -348,8 +378,8 @@ int gpiochip_add(struct gpio_chip *chip)
         INIT_LIST_HEAD(&chip->pin_ranges);
 #endif
 
-        if (!chip->owner && chip->dev && chip->dev->driver)
-                chip->owner = chip->dev->driver->owner;
+        if (!chip->owner && chip->parent && chip->parent->driver)
+                chip->owner = chip->parent->driver->owner;
 
         status = gpiochip_set_desc_names(chip);
         if (status)
@@ -389,7 +419,7 @@ err_free_descs:
                 chip->label ? : "generic");
         return status;
 }
-EXPORT_SYMBOL_GPL(gpiochip_add);
+EXPORT_SYMBOL_GPL(gpiochip_add_data);
 
 /**
  * gpiochip_remove() - unregister a gpio_chip
@@ -424,7 +454,8 @@ void gpiochip_remove(struct gpio_chip *chip)
         spin_unlock_irqrestore(&gpio_lock, flags);
 
         if (requested)
-                dev_crit(chip->dev, "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
+                dev_crit(chip->parent,
+                         "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
 
         kfree(chip->desc);
         chip->desc = NULL;
@@ -659,7 +690,7 @@ static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
  * gpiochip, providing an irq domain to translate the local IRQs to
  * global irqs in the gpiolib core, and making sure that the gpiochip
  * is passed as chip data to all related functions. Driver callbacks
- * need to use container_of() to get their local state containers back
+ * need to use gpiochip_get_data() to get their local state containers back
  * from the gpiochip passed as chip data. An irqdomain will be stored
  * in the gpiochip that shall be used by the driver to handle IRQ number
  * translation. The gpiochip will need to be initialized and registered
@@ -683,15 +714,16 @@ int _gpiochip_irqchip_add(struct gpio_chip *gpiochip,
         if (!gpiochip || !irqchip)
                 return -EINVAL;
 
-        if (!gpiochip->dev) {
+        if (!gpiochip->parent) {
                 pr_err("missing gpiochip .dev parent pointer\n");
                 return -EINVAL;
         }
-        of_node = gpiochip->dev->of_node;
+        of_node = gpiochip->parent->of_node;
 #ifdef CONFIG_OF_GPIO
         /*
          * If the gpiochip has an assigned OF node this takes precedence
-         * FIXME: get rid of this and use gpiochip->dev->of_node everywhere
+         * FIXME: get rid of this and use gpiochip->parent->of_node
+         * everywhere
          */
         if (gpiochip->of_node)
                 of_node = gpiochip->of_node;
@@ -1279,13 +1311,7 @@ static int _gpiod_get_raw_value(const struct gpio_desc *desc)
         chip = desc->chip;
         offset = gpio_chip_hwgpio(desc);
         value = chip->get ? chip->get(chip, offset) : -EIO;
-        /*
-         * FIXME: fix all drivers to clamp to [0,1] or return negative,
-         * then change this to:
-         * value = value < 0 ? value : !!value;
-         * so we can properly propagate error codes.
-         */
-        value = !!value;
+        value = value < 0 ? value : !!value;
         trace_gpio_value(desc_to_gpio(desc), 1, value);
         return value;
 }
@@ -2512,7 +2538,7 @@ static int gpiolib_seq_show(struct seq_file *s, void *v)
 
         seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
                         chip->base, chip->base + chip->ngpio - 1);
-        dev = chip->dev;
+        dev = chip->parent;
         if (dev)
                 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
                         dev_name(dev));
diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h
index be3a977d0349..99ed3b00ffe9 100644
--- a/drivers/gpio/gpiolib.h
+++ b/drivers/gpio/gpiolib.h
@@ -16,7 +16,7 @@
 #include <linux/device.h>
 
 enum of_gpio_flags;
-
+enum gpiod_flags;
 struct acpi_device;
 
 /**
diff --git a/drivers/hid/hid-cp2112.c b/drivers/hid/hid-cp2112.c
index 7c38bfa05fac..086d8a507157 100644
--- a/drivers/hid/hid-cp2112.c
+++ b/drivers/hid/hid-cp2112.c
@@ -24,7 +24,7 @@
  *   http://www.silabs.com/Support%20Documents/TechnicalDocs/AN495.pdf
  */
 
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/hid.h>
 #include <linux/i2c.h>
 #include <linux/module.h>
@@ -169,8 +169,7 @@ MODULE_PARM_DESC(gpio_push_pull, "GPIO push-pull configuration bitmask");
 
 static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct cp2112_device *dev = container_of(chip, struct cp2112_device,
-                                                 gc);
+        struct cp2112_device *dev = gpiochip_get_data(chip);
         struct hid_device *hdev = dev->hdev;
         u8 buf[5];
         int ret;
@@ -198,8 +197,7 @@ static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 
 static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct cp2112_device *dev = container_of(chip, struct cp2112_device,
-                                                 gc);
+        struct cp2112_device *dev = gpiochip_get_data(chip);
         struct hid_device *hdev = dev->hdev;
         u8 buf[3];
         int ret;
@@ -216,8 +214,7 @@ static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct cp2112_device *dev = container_of(chip, struct cp2112_device,
-                                                 gc);
+        struct cp2112_device *dev = gpiochip_get_data(chip);
         struct hid_device *hdev = dev->hdev;
         u8 buf[2];
         int ret;
@@ -235,8 +232,7 @@ static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset)
 static int cp2112_gpio_direction_output(struct gpio_chip *chip,
                                         unsigned offset, int value)
 {
-        struct cp2112_device *dev = container_of(chip, struct cp2112_device,
-                                                 gc);
+        struct cp2112_device *dev = gpiochip_get_data(chip);
         struct hid_device *hdev = dev->hdev;
         u8 buf[5];
         int ret;
@@ -1104,9 +1100,9 @@ static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
         dev->gc.base                    = -1;
         dev->gc.ngpio                   = 8;
         dev->gc.can_sleep               = 1;
-        dev->gc.dev                     = &hdev->dev;
+        dev->gc.parent                  = &hdev->dev;
 
-        ret = gpiochip_add(&dev->gc);
+        ret = gpiochip_add_data(&dev->gc, dev);
         if (ret < 0) {
                 hid_err(hdev, "error registering gpio chip\n");
                 goto err_free_i2c;
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index fec66ad80513..16b5cc2196f2 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -454,7 +454,7 @@ static int ad7879_gpio_add(struct ad7879 *ts,
                 ts->gc.ngpio = 1;
                 ts->gc.label = "AD7879-GPIO";
                 ts->gc.owner = THIS_MODULE;
-                ts->gc.dev = ts->dev;
+                ts->gc.parent = ts->dev;
 
                 ret = gpiochip_add(&ts->gc);
                 if (ret)
diff --git a/drivers/leds/leds-pca9532.c b/drivers/leds/leds-pca9532.c
index 17c63ec9fb9e..e3d3b1aaa9e0 100644
--- a/drivers/leds/leds-pca9532.c
+++ b/drivers/leds/leds-pca9532.c
@@ -242,7 +242,7 @@ static void pca9532_input_work(struct work_struct *work)
 #ifdef CONFIG_LEDS_PCA9532_GPIO
 static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset)
 {
-        struct pca9532_data *data = container_of(gc, struct pca9532_data, gpio);
+        struct pca9532_data *data = gpiochip_get_data(gc);
         struct pca9532_led *led = &data->leds[offset];
 
         if (led->type == PCA9532_TYPE_GPIO)
@@ -253,7 +253,7 @@ static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset)
 
 static void pca9532_gpio_set_value(struct gpio_chip *gc, unsigned offset, int val)
 {
-        struct pca9532_data *data = container_of(gc, struct pca9532_data, gpio);
+        struct pca9532_data *data = gpiochip_get_data(gc);
         struct pca9532_led *led = &data->leds[offset];
 
         if (val)
@@ -266,7 +266,7 @@ static void pca9532_gpio_set_value(struct gpio_chip *gc, unsigned offset, int va
 
 static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset)
 {
-        struct pca9532_data *data = container_of(gc, struct pca9532_data, gpio);
+        struct pca9532_data *data = gpiochip_get_data(gc);
         unsigned char reg;
 
         reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset));
@@ -315,7 +315,7 @@ static int pca9532_destroy_devices(struct pca9532_data *data, int n_devs)
         }
 
 #ifdef CONFIG_LEDS_PCA9532_GPIO
-        if (data->gpio.dev)
+        if (data->gpio.parent)
                 gpiochip_remove(&data->gpio);
 #endif
 
@@ -409,13 +409,13 @@ static int pca9532_configure(struct i2c_client *client,
                 data->gpio.can_sleep = 1;
                 data->gpio.base = pdata->gpio_base;
                 data->gpio.ngpio = data->chip_info->num_leds;
-                data->gpio.dev = &client->dev;
+                data->gpio.parent = &client->dev;
                 data->gpio.owner = THIS_MODULE;
 
-                err = gpiochip_add(&data->gpio);
+                err = gpiochip_add_data(&data->gpio, data);
                 if (err) {
                         /* Use data->gpio.dev as a flag for freeing gpiochip */
-                        data->gpio.dev = NULL;
+                        data->gpio.parent = NULL;
                         dev_warn(&client->dev, "could not add gpiochip\n");
                 } else {
                         dev_info(&client->dev, "gpios %i...%i\n",
diff --git a/drivers/leds/leds-tca6507.c b/drivers/leds/leds-tca6507.c
index edbecc4ca2da..c548ea10f0f0 100644
--- a/drivers/leds/leds-tca6507.c
+++ b/drivers/leds/leds-tca6507.c
@@ -603,7 +603,7 @@ static int tca6507_blink_set(struct led_classdev *led_cdev,
 static void tca6507_gpio_set_value(struct gpio_chip *gc,
                                    unsigned offset, int val)
 {
-        struct tca6507_chip *tca = container_of(gc, struct tca6507_chip, gpio);
+        struct tca6507_chip *tca = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&tca->lock, flags);
@@ -651,11 +651,11 @@ static int tca6507_probe_gpios(struct i2c_client *client,
         tca->gpio.owner = THIS_MODULE;
         tca->gpio.direction_output = tca6507_gpio_direction_output;
         tca->gpio.set = tca6507_gpio_set_value;
-        tca->gpio.dev = &client->dev;
+        tca->gpio.parent = &client->dev;
 #ifdef CONFIG_OF_GPIO
         tca->gpio.of_node = of_node_get(client->dev.of_node);
 #endif
-        err = gpiochip_add(&tca->gpio);
+        err = gpiochip_add_data(&tca->gpio, tca);
         if (err) {
                 tca->gpio.ngpio = 0;
                 return err;
diff --git a/drivers/media/dvb-frontends/cxd2820r_core.c b/drivers/media/dvb-frontends/cxd2820r_core.c
index def6d21d1445..24a457d9d803 100644
--- a/drivers/media/dvb-frontends/cxd2820r_core.c
+++ b/drivers/media/dvb-frontends/cxd2820r_core.c
@@ -722,7 +722,7 @@ struct dvb_frontend *cxd2820r_attach(const struct cxd2820r_config *cfg,
 #ifdef CONFIG_GPIOLIB
                 /* add GPIOs */
                 priv->gpio_chip.label = KBUILD_MODNAME;
-                priv->gpio_chip.dev = &priv->i2c->dev;
+                priv->gpio_chip.parent = &priv->i2c->dev;
                 priv->gpio_chip.owner = THIS_MODULE;
                 priv->gpio_chip.direction_output =
                                 cxd2820r_gpio_direction_output;
diff --git a/drivers/mfd/dm355evm_msp.c b/drivers/mfd/dm355evm_msp.c
index bf3e0b21b247..ec4438ed2faf 100644
--- a/drivers/mfd/dm355evm_msp.c
+++ b/drivers/mfd/dm355evm_msp.c
@@ -259,7 +259,7 @@ static int add_children(struct i2c_client *client)
         int             i;
 
         /* GPIO-ish stuff */
-        dm355evm_msp_gpio.dev = &client->dev;
+        dm355evm_msp_gpio.parent = &client->dev;
         status = gpiochip_add(&dm355evm_msp_gpio);
         if (status < 0)
                 return status;
diff --git a/drivers/mfd/htc-egpio.c b/drivers/mfd/htc-egpio.c
index e4f4a31b76d9..c636b5f83cfb 100644
--- a/drivers/mfd/htc-egpio.c
+++ b/drivers/mfd/htc-egpio.c
@@ -321,7 +321,7 @@ static int __init egpio_probe(struct platform_device *pdev)
                 ei->chip[i].dev = &(pdev->dev);
                 chip = &(ei->chip[i].chip);
                 chip->label           = "htc-egpio";
-                chip->dev             = &pdev->dev;
+                chip->parent          = &pdev->dev;
                 chip->owner           = THIS_MODULE;
                 chip->get             = egpio_get;
                 chip->set             = egpio_set;
diff --git a/drivers/mfd/htc-i2cpld.c b/drivers/mfd/htc-i2cpld.c
index 0c6ff727b2ec..bd6b96d07ab8 100644
--- a/drivers/mfd/htc-i2cpld.c
+++ b/drivers/mfd/htc-i2cpld.c
@@ -429,7 +429,7 @@ static int htcpld_register_chip_gpio(
         /* Setup the GPIO chips */
         gpio_chip = &(chip->chip_out);
         gpio_chip->label           = "htcpld-out";
-        gpio_chip->dev             = dev;
+        gpio_chip->parent             = dev;
         gpio_chip->owner           = THIS_MODULE;
         gpio_chip->get             = htcpld_chip_get;
         gpio_chip->set             = htcpld_chip_set;
@@ -440,7 +440,7 @@ static int htcpld_register_chip_gpio(
 
         gpio_chip = &(chip->chip_in);
         gpio_chip->label           = "htcpld-in";
-        gpio_chip->dev             = dev;
+        gpio_chip->parent             = dev;
         gpio_chip->owner           = THIS_MODULE;
         gpio_chip->get             = htcpld_chip_get;
         gpio_chip->set             = NULL;
diff --git a/drivers/mfd/tps65010.c b/drivers/mfd/tps65010.c
index 677a127619d4..83e615ed100a 100644
--- a/drivers/mfd/tps65010.c
+++ b/drivers/mfd/tps65010.c
@@ -638,7 +638,7 @@ static int tps65010_probe(struct i2c_client *client,
                 tps->outmask = board->outmask;
 
                 tps->chip.label = client->name;
-                tps->chip.dev = &client->dev;
+                tps->chip.parent = &client->dev;
                 tps->chip.owner = THIS_MODULE;
 
                 tps->chip.set = tps65010_gpio_set;
diff --git a/drivers/mfd/ucb1x00-core.c b/drivers/mfd/ucb1x00-core.c
index e0dd83fb95d3..bcafe1ecd71c 100644
--- a/drivers/mfd/ucb1x00-core.c
+++ b/drivers/mfd/ucb1x00-core.c
@@ -570,7 +570,7 @@ static int ucb1x00_probe(struct mcp *mcp)
 
         if (pdata && pdata->gpio_base) {
                 ucb->gpio.label = dev_name(&ucb->dev);
-                ucb->gpio.dev = &ucb->dev;
+                ucb->gpio.parent = &ucb->dev;
                 ucb->gpio.owner = THIS_MODULE;
                 ucb->gpio.base = pdata->gpio_base;
                 ucb->gpio.ngpio = 10;
diff --git a/drivers/mfd/vexpress-sysreg.c b/drivers/mfd/vexpress-sysreg.c
index 3e628df9280c..855c0204f09a 100644
--- a/drivers/mfd/vexpress-sysreg.c
+++ b/drivers/mfd/vexpress-sysreg.c
@@ -11,7 +11,7 @@
  * Copyright (C) 2012 ARM Limited
  */
 
-#include <linux/basic_mmio_gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/mfd/core.h>
@@ -164,7 +164,7 @@ static int vexpress_sysreg_probe(struct platform_device *pdev)
 {
         struct resource *mem;
         void __iomem *base;
-        struct bgpio_chip *mmc_gpio_chip;
+        struct gpio_chip *mmc_gpio_chip;
         int master;
         u32 dt_hbi;
 
@@ -201,8 +201,8 @@ static int vexpress_sysreg_probe(struct platform_device *pdev)
                 return -ENOMEM;
         bgpio_init(mmc_gpio_chip, &pdev->dev, 0x4, base + SYS_MCI,
                         NULL, NULL, NULL, NULL, 0);
-        mmc_gpio_chip->gc.ngpio = 2;
-        gpiochip_add(&mmc_gpio_chip->gc);
+        mmc_gpio_chip->ngpio = 2;
+        gpiochip_add(mmc_gpio_chip);
 
         return mfd_add_devices(&pdev->dev, PLATFORM_DEVID_AUTO,
                         vexpress_sysreg_cells,
diff --git a/drivers/pinctrl/bcm/pinctrl-bcm2835.c b/drivers/pinctrl/bcm/pinctrl-bcm2835.c
index 75b0d8c8f058..0f5997ceb494 100644
--- a/drivers/pinctrl/bcm/pinctrl-bcm2835.c
+++ b/drivers/pinctrl/bcm/pinctrl-bcm2835.c
@@ -23,7 +23,7 @@
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/err.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/irq.h>
@@ -337,14 +337,14 @@ static int bcm2835_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 
 static int bcm2835_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
+        struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 
         return bcm2835_gpio_get_bit(pc, GPLEV0, offset);
 }
 
 static void bcm2835_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
+        struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 
         bcm2835_gpio_set_bit(pc, value ? GPSET0 : GPCLR0, offset);
 }
@@ -358,7 +358,7 @@ static int bcm2835_gpio_direction_output(struct gpio_chip *chip,
 
 static int bcm2835_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
+        struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 
         return irq_linear_revmap(pc->irq_domain, offset);
 }
@@ -964,7 +964,7 @@ static int bcm2835_pinctrl_probe(struct platform_device *pdev)
                 return PTR_ERR(pc->base);
 
         pc->gpio_chip = bcm2835_gpio_chip;
-        pc->gpio_chip.dev = dev;
+        pc->gpio_chip.parent = dev;
         pc->gpio_chip.of_node = np;
 
         pc->irq_domain = irq_domain_add_linear(np, BCM2835_NUM_GPIOS,
@@ -1021,7 +1021,7 @@ static int bcm2835_pinctrl_probe(struct platform_device *pdev)
                 }
         }
 
-        err = gpiochip_add(&pc->gpio_chip);
+        err = gpiochip_add_data(&pc->gpio_chip, pc);
         if (err) {
                 dev_err(dev, "could not add GPIO chip\n");
                 return err;
diff --git a/drivers/pinctrl/bcm/pinctrl-iproc-gpio.c b/drivers/pinctrl/bcm/pinctrl-iproc-gpio.c
index 314591a4609b..3b2ac8f771ed 100644
--- a/drivers/pinctrl/bcm/pinctrl-iproc-gpio.c
+++ b/drivers/pinctrl/bcm/pinctrl-iproc-gpio.c
@@ -694,7 +694,7 @@ static int iproc_gpio_probe(struct platform_device *pdev)
         gc->ngpio = ngpios;
         chip->num_banks = (ngpios + NGPIOS_PER_BANK - 1) / NGPIOS_PER_BANK;
         gc->label = dev_name(dev);
-        gc->dev = dev;
+        gc->parent = dev;
         gc->of_node = dev->of_node;
         gc->request = iproc_gpio_request;
         gc->free = iproc_gpio_free;
diff --git a/drivers/pinctrl/bcm/pinctrl-nsp-gpio.c b/drivers/pinctrl/bcm/pinctrl-nsp-gpio.c
index 725c36f917f9..ac900435dc39 100644
--- a/drivers/pinctrl/bcm/pinctrl-nsp-gpio.c
+++ b/drivers/pinctrl/bcm/pinctrl-nsp-gpio.c
@@ -18,7 +18,7 @@
  * through the interaction with the NSP IOMUX controller.
  */
 
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
@@ -81,11 +81,6 @@ enum base_type {
         IO_CTRL
 };
 
-static inline struct nsp_gpio *to_nsp_gpio(struct gpio_chip *gc)
-{
-        return container_of(gc, struct nsp_gpio, gc);
-}
-
 /*
  * Mapping from PINCONF pins to GPIO pins is 1-to-1
  */
@@ -297,7 +292,7 @@ static void nsp_gpio_free(struct gpio_chip *gc, unsigned offset)
 
 static int nsp_gpio_direction_input(struct gpio_chip *gc, unsigned gpio)
 {
-        struct nsp_gpio *chip = to_nsp_gpio(gc);
+        struct nsp_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->lock, flags);
@@ -311,7 +306,7 @@ static int nsp_gpio_direction_input(struct gpio_chip *gc, unsigned gpio)
 static int nsp_gpio_direction_output(struct gpio_chip *gc, unsigned gpio,
                                      int val)
 {
-        struct nsp_gpio *chip = to_nsp_gpio(gc);
+        struct nsp_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->lock, flags);
@@ -325,7 +320,7 @@ static int nsp_gpio_direction_output(struct gpio_chip *gc, unsigned gpio,
 
 static void nsp_gpio_set(struct gpio_chip *gc, unsigned gpio, int val)
 {
-        struct nsp_gpio *chip = to_nsp_gpio(gc);
+        struct nsp_gpio *chip = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&chip->lock, flags);
@@ -337,14 +332,14 @@ static void nsp_gpio_set(struct gpio_chip *gc, unsigned gpio, int val)
 
 static int nsp_gpio_get(struct gpio_chip *gc, unsigned gpio)
 {
-        struct nsp_gpio *chip = to_nsp_gpio(gc);
+        struct nsp_gpio *chip = gpiochip_get_data(gc);
 
         return !!(readl(chip->base + NSP_GPIO_DATA_IN) & BIT(gpio));
 }
 
 static int nsp_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct nsp_gpio *chip = to_nsp_gpio(gc);
+        struct nsp_gpio *chip = gpiochip_get_data(gc);
 
         return irq_linear_revmap(chip->irq_domain, offset);
 }
@@ -669,7 +664,7 @@ static int nsp_gpio_probe(struct platform_device *pdev)
         gc->can_sleep = false;
         gc->ngpio = val;
         gc->label = dev_name(dev);
-        gc->dev = dev;
+        gc->parent = dev;
         gc->of_node = dev->of_node;
         gc->request = nsp_gpio_request;
         gc->free = nsp_gpio_free;
@@ -714,7 +709,7 @@ static int nsp_gpio_probe(struct platform_device *pdev)
                 writel(val, (chip->base + NSP_CHIP_A_INT_MASK));
         }
 
-        ret = gpiochip_add(gc);
+        ret = gpiochip_add_data(gc, chip);
         if (ret < 0) {
                 dev_err(dev, "unable to add GPIO chip\n");
                 return ret;
diff --git a/drivers/pinctrl/intel/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c
index b59ce75b1947..21b79a446d5a 100644
--- a/drivers/pinctrl/intel/pinctrl-baytrail.c
+++ b/drivers/pinctrl/intel/pinctrl-baytrail.c
@@ -20,7 +20,7 @@
 #include <linux/types.h>
 #include <linux/bitops.h>
 #include <linux/interrupt.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/acpi.h>
 #include <linux/platform_device.h>
 #include <linux/seq_file.h>
@@ -147,12 +147,10 @@ struct byt_gpio {
         struct byt_gpio_pin_context     *saved_context;
 };
 
-#define to_byt_gpio(c)  container_of(c, struct byt_gpio, chip)
-
 static void __iomem *byt_gpio_reg(struct gpio_chip *chip, unsigned offset,
                                  int reg)
 {
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
         u32 reg_offset;
 
         if (reg == BYT_INT_STAT_REG)
@@ -193,7 +191,7 @@ static u32 byt_get_gpio_mux(struct byt_gpio *vg, unsigned offset)
 
 static int byt_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
         void __iomem *reg = byt_gpio_reg(chip, offset, BYT_CONF0_REG);
         u32 value, gpio_mux;
         unsigned long flags;
@@ -229,7 +227,7 @@ static int byt_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void byt_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
 
         byt_gpio_clear_triggering(vg, offset);
         pm_runtime_put(&vg->pdev->dev);
@@ -237,7 +235,7 @@ static void byt_gpio_free(struct gpio_chip *chip, unsigned offset)
 
 static int byt_irq_type(struct irq_data *d, unsigned type)
 {
-        struct byt_gpio *vg = to_byt_gpio(irq_data_get_irq_chip_data(d));
+        struct byt_gpio *vg = gpiochip_get_data(irq_data_get_irq_chip_data(d));
         u32 offset = irqd_to_hwirq(d);
         u32 value;
         unsigned long flags;
@@ -273,7 +271,7 @@ static int byt_irq_type(struct irq_data *d, unsigned type)
 static int byt_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
         void __iomem *reg = byt_gpio_reg(chip, offset, BYT_VAL_REG);
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
         unsigned long flags;
         u32 val;
 
@@ -281,12 +279,12 @@ static int byt_gpio_get(struct gpio_chip *chip, unsigned offset)
         val = readl(reg);
         raw_spin_unlock_irqrestore(&vg->lock, flags);
 
-        return val & BYT_LEVEL;
+        return !!(val & BYT_LEVEL);
 }
 
 static void byt_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
         void __iomem *reg = byt_gpio_reg(chip, offset, BYT_VAL_REG);
         unsigned long flags;
         u32 old_val;
@@ -305,7 +303,7 @@ static void byt_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int byt_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
         void __iomem *reg = byt_gpio_reg(chip, offset, BYT_VAL_REG);
         unsigned long flags;
         u32 value;
@@ -324,7 +322,7 @@ static int byt_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int byt_gpio_direction_output(struct gpio_chip *chip,
                                      unsigned gpio, int value)
 {
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
         void __iomem *conf_reg = byt_gpio_reg(chip, gpio, BYT_CONF0_REG);
         void __iomem *reg = byt_gpio_reg(chip, gpio, BYT_VAL_REG);
         unsigned long flags;
@@ -356,7 +354,7 @@ static int byt_gpio_direction_output(struct gpio_chip *chip,
 
 static void byt_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct byt_gpio *vg = to_byt_gpio(chip);
+        struct byt_gpio *vg = gpiochip_get_data(chip);
         int i;
         u32 conf0, val, offs;
 
@@ -428,7 +426,7 @@ static void byt_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 static void byt_gpio_irq_handler(struct irq_desc *desc)
 {
         struct irq_data *data = irq_desc_get_irq_data(desc);
-        struct byt_gpio *vg = to_byt_gpio(irq_desc_get_handler_data(desc));
+        struct byt_gpio *vg = gpiochip_get_data(irq_desc_get_handler_data(desc));
         struct irq_chip *chip = irq_data_get_irq_chip(data);
         u32 base, pin;
         void __iomem *reg;
@@ -450,7 +448,7 @@ static void byt_gpio_irq_handler(struct irq_desc *desc)
 static void byt_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct byt_gpio *vg = to_byt_gpio(gc);
+        struct byt_gpio *vg = gpiochip_get_data(gc);
         unsigned offset = irqd_to_hwirq(d);
         void __iomem *reg;
 
@@ -463,7 +461,7 @@ static void byt_irq_ack(struct irq_data *d)
 static void byt_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct byt_gpio *vg = to_byt_gpio(gc);
+        struct byt_gpio *vg = gpiochip_get_data(gc);
         unsigned offset = irqd_to_hwirq(d);
         unsigned long flags;
         void __iomem *reg;
@@ -498,7 +496,7 @@ static void byt_irq_unmask(struct irq_data *d)
 static void byt_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct byt_gpio *vg = to_byt_gpio(gc);
+        struct byt_gpio *vg = gpiochip_get_data(gc);
 
         byt_gpio_clear_triggering(vg, irqd_to_hwirq(d));
 }
@@ -598,14 +596,14 @@ static int byt_gpio_probe(struct platform_device *pdev)
         gc->dbg_show = byt_gpio_dbg_show;
         gc->base = -1;
         gc->can_sleep = false;
-        gc->dev = dev;
+        gc->parent = dev;
 
 #ifdef CONFIG_PM_SLEEP
         vg->saved_context = devm_kcalloc(&pdev->dev, gc->ngpio,
                                        sizeof(*vg->saved_context), GFP_KERNEL);
 #endif
 
-        ret = gpiochip_add(gc);
+        ret = gpiochip_add_data(gc, vg);
         if (ret) {
                 dev_err(&pdev->dev, "failed adding byt-gpio chip\n");
                 return ret;
diff --git a/drivers/pinctrl/intel/pinctrl-cherryview.c b/drivers/pinctrl/intel/pinctrl-cherryview.c
index 84936bae6e5e..4251e0747a3a 100644
--- a/drivers/pinctrl/intel/pinctrl-cherryview.c
+++ b/drivers/pinctrl/intel/pinctrl-cherryview.c
@@ -181,8 +181,6 @@ struct chv_pinctrl {
         struct chv_pin_context *saved_pin_context;
 };
 
-#define gpiochip_to_pinctrl(c) container_of(c, struct chv_pinctrl, chip)
-
 #define ALTERNATE_FUNCTION(p, m, i)             \
         {                                       \
                 .pin = (p),                     \
@@ -1157,7 +1155,7 @@ static unsigned chv_gpio_offset_to_pin(struct chv_pinctrl *pctrl,
 
 static int chv_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        struct chv_pinctrl *pctrl = gpiochip_get_data(chip);
         int pin = chv_gpio_offset_to_pin(pctrl, offset);
         unsigned long flags;
         u32 ctrl0, cfg;
@@ -1176,7 +1174,7 @@ static int chv_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void chv_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        struct chv_pinctrl *pctrl = gpiochip_get_data(chip);
         unsigned pin = chv_gpio_offset_to_pin(pctrl, offset);
         unsigned long flags;
         void __iomem *reg;
@@ -1199,7 +1197,7 @@ static void chv_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int chv_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 {
-        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        struct chv_pinctrl *pctrl = gpiochip_get_data(chip);
         unsigned pin = chv_gpio_offset_to_pin(pctrl, offset);
         u32 ctrl0, direction;
         unsigned long flags;
@@ -1240,7 +1238,7 @@ static const struct gpio_chip chv_gpio_chip = {
 static void chv_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct chv_pinctrl *pctrl = gpiochip_get_data(gc);
         int pin = chv_gpio_offset_to_pin(pctrl, irqd_to_hwirq(d));
         u32 intr_line;
 
@@ -1257,7 +1255,7 @@ static void chv_gpio_irq_ack(struct irq_data *d)
 static void chv_gpio_irq_mask_unmask(struct irq_data *d, bool mask)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct chv_pinctrl *pctrl = gpiochip_get_data(gc);
         int pin = chv_gpio_offset_to_pin(pctrl, irqd_to_hwirq(d));
         u32 value, intr_line;
         unsigned long flags;
@@ -1302,7 +1300,7 @@ static unsigned chv_gpio_irq_startup(struct irq_data *d)
          */
         if (irqd_get_trigger_type(d) == IRQ_TYPE_NONE) {
                 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-                struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+                struct chv_pinctrl *pctrl = gpiochip_get_data(gc);
                 unsigned offset = irqd_to_hwirq(d);
                 int pin = chv_gpio_offset_to_pin(pctrl, offset);
                 irq_flow_handler_t handler;
@@ -1334,7 +1332,7 @@ static unsigned chv_gpio_irq_startup(struct irq_data *d)
 static int chv_gpio_irq_type(struct irq_data *d, unsigned type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct chv_pinctrl *pctrl = gpiochip_get_data(gc);
         unsigned offset = irqd_to_hwirq(d);
         int pin = chv_gpio_offset_to_pin(pctrl, offset);
         unsigned long flags;
@@ -1407,7 +1405,7 @@ static struct irq_chip chv_gpio_irqchip = {
 static void chv_gpio_irq_handler(struct irq_desc *desc)
 {
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct chv_pinctrl *pctrl = gpiochip_get_data(gc);
         struct irq_chip *chip = irq_desc_get_chip(desc);
         unsigned long pending;
         u32 intr_line;
@@ -1436,10 +1434,10 @@ static int chv_gpio_probe(struct chv_pinctrl *pctrl, int irq)
 
         chip->ngpio = pctrl->community->ngpios;
         chip->label = dev_name(pctrl->dev);
-        chip->dev = pctrl->dev;
+        chip->parent = pctrl->dev;
         chip->base = -1;
 
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, pctrl);
         if (ret) {
                 dev_err(pctrl->dev, "Failed to register gpiochip\n");
                 return ret;
diff --git a/drivers/pinctrl/intel/pinctrl-intel.c b/drivers/pinctrl/intel/pinctrl-intel.c
index 26f6b6ffea5b..c0f5586218c4 100644
--- a/drivers/pinctrl/intel/pinctrl-intel.c
+++ b/drivers/pinctrl/intel/pinctrl-intel.c
@@ -103,7 +103,6 @@ struct intel_pinctrl {
         struct intel_pinctrl_context context;
 };
 
-#define gpiochip_to_pinctrl(c)  container_of(c, struct intel_pinctrl, chip)
 #define pin_to_padno(c, p)      ((p) - (c)->pin_base)
 
 static struct intel_community *intel_get_community(struct intel_pinctrl *pctrl,
@@ -596,7 +595,7 @@ static const struct pinctrl_desc intel_pinctrl_desc = {
 
 static int intel_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        struct intel_pinctrl *pctrl = gpiochip_get_data(chip);
         void __iomem *reg;
 
         reg = intel_get_padcfg(pctrl, offset, PADCFG0);
@@ -608,7 +607,7 @@ static int intel_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void intel_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        struct intel_pinctrl *pctrl = gpiochip_get_data(chip);
         void __iomem *reg;
 
         reg = intel_get_padcfg(pctrl, offset, PADCFG0);
@@ -652,7 +651,7 @@ static const struct gpio_chip intel_gpio_chip = {
 static void intel_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct intel_pinctrl *pctrl = gpiochip_get_data(gc);
         const struct intel_community *community;
         unsigned pin = irqd_to_hwirq(d);
 
@@ -673,7 +672,7 @@ static void intel_gpio_irq_ack(struct irq_data *d)
 static void intel_gpio_irq_mask_unmask(struct irq_data *d, bool mask)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct intel_pinctrl *pctrl = gpiochip_get_data(gc);
         const struct intel_community *community;
         unsigned pin = irqd_to_hwirq(d);
         unsigned long flags;
@@ -713,7 +712,7 @@ static void intel_gpio_irq_unmask(struct irq_data *d)
 static int intel_gpio_irq_type(struct irq_data *d, unsigned type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct intel_pinctrl *pctrl = gpiochip_get_data(gc);
         unsigned pin = irqd_to_hwirq(d);
         unsigned long flags;
         void __iomem *reg;
@@ -767,7 +766,7 @@ static int intel_gpio_irq_type(struct irq_data *d, unsigned type)
 static int intel_gpio_irq_wake(struct irq_data *d, unsigned int on)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct intel_pinctrl *pctrl = gpiochip_get_data(gc);
         const struct intel_community *community;
         unsigned pin = irqd_to_hwirq(d);
         unsigned padno, gpp, gpp_offset;
@@ -872,10 +871,10 @@ static int intel_gpio_probe(struct intel_pinctrl *pctrl, int irq)
 
         pctrl->chip.ngpio = pctrl->soc->npins;
         pctrl->chip.label = dev_name(pctrl->dev);
-        pctrl->chip.dev = pctrl->dev;
+        pctrl->chip.parent = pctrl->dev;
         pctrl->chip.base = -1;
 
-        ret = gpiochip_add(&pctrl->chip);
+        ret = gpiochip_add_data(&pctrl->chip, pctrl);
         if (ret) {
                 dev_err(pctrl->dev, "failed to register gpiochip\n");
                 return ret;
diff --git a/drivers/pinctrl/mediatek/pinctrl-mtk-common.c b/drivers/pinctrl/mediatek/pinctrl-mtk-common.c
index e22cbaf9f9cf..16d48a4ed225 100644
--- a/drivers/pinctrl/mediatek/pinctrl-mtk-common.c
+++ b/drivers/pinctrl/mediatek/pinctrl-mtk-common.c
@@ -14,7 +14,7 @@
  */
 
 #include <linux/io.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
@@ -95,7 +95,7 @@ static void mtk_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
         unsigned int reg_addr;
         unsigned int bit;
-        struct mtk_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct mtk_pinctrl *pctl = gpiochip_get_data(chip);
 
         reg_addr = mtk_get_port(pctl, offset) + pctl->devdata->dout_offset;
         bit = BIT(offset & 0xf);
@@ -750,7 +750,7 @@ static int mtk_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
         unsigned int bit;
         unsigned int read_val = 0;
 
-        struct mtk_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct mtk_pinctrl *pctl = gpiochip_get_data(chip);
 
         reg_addr =  mtk_get_port(pctl, offset) + pctl->devdata->dir_offset;
         bit = BIT(offset & 0xf);
@@ -763,7 +763,7 @@ static int mtk_gpio_get(struct gpio_chip *chip, unsigned offset)
         unsigned int reg_addr;
         unsigned int bit;
         unsigned int read_val = 0;
-        struct mtk_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct mtk_pinctrl *pctl = gpiochip_get_data(chip);
 
         reg_addr = mtk_get_port(pctl, offset) +
                 pctl->devdata->din_offset;
@@ -776,7 +776,7 @@ static int mtk_gpio_get(struct gpio_chip *chip, unsigned offset)
 static int mtk_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
         const struct mtk_desc_pin *pin;
-        struct mtk_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct mtk_pinctrl *pctl = gpiochip_get_data(chip);
         int irq;
 
         pin = pctl->devdata->pins + offset;
@@ -944,7 +944,7 @@ static void mtk_eint_unmask(struct irq_data *d)
 static int mtk_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
         unsigned debounce)
 {
-        struct mtk_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct mtk_pinctrl *pctl = dev_get_drvdata(chip->parent);
         int eint_num, virq, eint_offset;
         unsigned int set_offset, bit, clr_bit, clr_offset, rst, i, unmask, dbnc;
         static const unsigned int dbnc_arr[] = {0 , 1, 16, 32, 64, 128, 256};
@@ -1353,10 +1353,10 @@ int mtk_pctrl_init(struct platform_device *pdev,
         *pctl->chip = mtk_gpio_chip;
         pctl->chip->ngpio = pctl->devdata->npins;
         pctl->chip->label = dev_name(&pdev->dev);
-        pctl->chip->dev = &pdev->dev;
+        pctl->chip->parent = &pdev->dev;
         pctl->chip->base = -1;
 
-        ret = gpiochip_add(pctl->chip);
+        ret = gpiochip_add_data(pctl->chip, pctl);
         if (ret) {
                 ret = -EINVAL;
                 goto pctrl_error;
diff --git a/drivers/pinctrl/meson/pinctrl-meson.c b/drivers/pinctrl/meson/pinctrl-meson.c
index 84943e4cff09..50cab27c64d4 100644
--- a/drivers/pinctrl/meson/pinctrl-meson.c
+++ b/drivers/pinctrl/meson/pinctrl-meson.c
@@ -448,11 +448,6 @@ static const struct pinconf_ops meson_pinconf_ops = {
         .is_generic             = true,
 };
 
-static inline struct meson_domain *to_meson_domain(struct gpio_chip *chip)
-{
-        return container_of(chip, struct meson_domain, chip);
-}
-
 static int meson_gpio_request(struct gpio_chip *chip, unsigned gpio)
 {
         return pinctrl_request_gpio(chip->base + gpio);
@@ -460,14 +455,14 @@ static int meson_gpio_request(struct gpio_chip *chip, unsigned gpio)
 
 static void meson_gpio_free(struct gpio_chip *chip, unsigned gpio)
 {
-        struct meson_domain *domain = to_meson_domain(chip);
+        struct meson_domain *domain = gpiochip_get_data(chip);
 
         pinctrl_free_gpio(domain->data->pin_base + gpio);
 }
 
 static int meson_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 {
-        struct meson_domain *domain = to_meson_domain(chip);
+        struct meson_domain *domain = gpiochip_get_data(chip);
         unsigned int reg, bit, pin;
         struct meson_bank *bank;
         int ret;
@@ -485,7 +480,7 @@ static int meson_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 static int meson_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
                                        int value)
 {
-        struct meson_domain *domain = to_meson_domain(chip);
+        struct meson_domain *domain = gpiochip_get_data(chip);
         unsigned int reg, bit, pin;
         struct meson_bank *bank;
         int ret;
@@ -507,7 +502,7 @@ static int meson_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
 
 static void meson_gpio_set(struct gpio_chip *chip, unsigned gpio, int value)
 {
-        struct meson_domain *domain = to_meson_domain(chip);
+        struct meson_domain *domain = gpiochip_get_data(chip);
         unsigned int reg, bit, pin;
         struct meson_bank *bank;
         int ret;
@@ -524,7 +519,7 @@ static void meson_gpio_set(struct gpio_chip *chip, unsigned gpio, int value)
 
 static int meson_gpio_get(struct gpio_chip *chip, unsigned gpio)
 {
-        struct meson_domain *domain = to_meson_domain(chip);
+        struct meson_domain *domain = gpiochip_get_data(chip);
         unsigned int reg, bit, val, pin;
         struct meson_bank *bank;
         int ret;
@@ -562,7 +557,7 @@ static int meson_gpiolib_register(struct meson_pinctrl *pc)
                 domain = &pc->domains[i];
 
                 domain->chip.label = domain->data->name;
-                domain->chip.dev = pc->dev;
+                domain->chip.parent = pc->dev;
                 domain->chip.request = meson_gpio_request;
                 domain->chip.free = meson_gpio_free;
                 domain->chip.direction_input = meson_gpio_direction_input;
@@ -575,7 +570,7 @@ static int meson_gpiolib_register(struct meson_pinctrl *pc)
                 domain->chip.of_node = domain->of_node;
                 domain->chip.of_gpio_n_cells = 2;
 
-                ret = gpiochip_add(&domain->chip);
+                ret = gpiochip_add_data(&domain->chip, domain);
                 if (ret) {
                         dev_err(pc->dev, "can't add gpio chip %s\n",
                                 domain->data->name);
diff --git a/drivers/pinctrl/nomadik/pinctrl-abx500.c b/drivers/pinctrl/nomadik/pinctrl-abx500.c
index b59fbb4b1fb1..085e60106ec2 100644
--- a/drivers/pinctrl/nomadik/pinctrl-abx500.c
+++ b/drivers/pinctrl/nomadik/pinctrl-abx500.c
@@ -109,19 +109,10 @@ struct abx500_pinctrl {
         int irq_cluster_size;
 };
 
-/**
- * to_abx500_pinctrl() - get the pointer to abx500_pinctrl
- * @chip:       Member of the structure abx500_pinctrl
- */
-static inline struct abx500_pinctrl *to_abx500_pinctrl(struct gpio_chip *chip)
-{
-        return container_of(chip, struct abx500_pinctrl, chip);
-}
-
 static int abx500_gpio_get_bit(struct gpio_chip *chip, u8 reg,
                                unsigned offset, bool *bit)
 {
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         u8 pos = offset % 8;
         u8 val;
         int ret;
@@ -143,7 +134,7 @@ static int abx500_gpio_get_bit(struct gpio_chip *chip, u8 reg,
 static int abx500_gpio_set_bits(struct gpio_chip *chip, u8 reg,
                                 unsigned offset, int val)
 {
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         u8 pos = offset % 8;
         int ret;
 
@@ -164,7 +155,7 @@ static int abx500_gpio_set_bits(struct gpio_chip *chip, u8 reg,
  */
 static int abx500_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         bool bit;
         bool is_out;
         u8 gpio_offset = offset - 1;
@@ -192,7 +183,7 @@ out:
 
 static void abx500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         int ret;
 
         ret = abx500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, val);
@@ -272,7 +263,7 @@ out:
 
 static bool abx500_pullud_supported(struct gpio_chip *chip, unsigned gpio)
 {
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         struct pullud *pullud = pct->soc->pullud;
 
         return (pullud &&
@@ -284,7 +275,7 @@ static int abx500_gpio_direction_output(struct gpio_chip *chip,
                                         unsigned offset,
                                         int val)
 {
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         unsigned gpio;
         int ret;
 
@@ -332,7 +323,7 @@ static int abx500_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 
 static int abx500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         /* The AB8500 GPIO numbers are off by one */
         int gpio = offset + 1;
         int hwirq;
@@ -634,7 +625,7 @@ static void abx500_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
         unsigned i;
         unsigned gpio = chip->base;
-        struct abx500_pinctrl *pct = to_abx500_pinctrl(chip);
+        struct abx500_pinctrl *pct = gpiochip_get_data(chip);
         struct pinctrl_dev *pctldev = pct->pctldev;
 
         for (i = 0; i < chip->ngpio; i++, gpio++) {
@@ -986,7 +977,7 @@ static int abx500_pin_config_set(struct pinctrl_dev *pctldev,
                 param = pinconf_to_config_param(configs[i]);
                 argument = pinconf_to_config_argument(configs[i]);
 
-                dev_dbg(chip->dev, "pin %d [%#lx]: %s %s\n",
+                dev_dbg(chip->parent, "pin %d [%#lx]: %s %s\n",
                         pin, configs[i],
                         (param == PIN_CONFIG_OUTPUT) ? "output " : "input",
                         (param == PIN_CONFIG_OUTPUT) ?
@@ -1077,7 +1068,8 @@ static int abx500_pin_config_set(struct pinctrl_dev *pctldev,
                         break;
 
                 default:
-                        dev_err(chip->dev, "illegal configuration requested\n");
+                        dev_err(chip->parent,
+                                "illegal configuration requested\n");
                 }
         } /* for each config */
 out:
@@ -1172,7 +1164,7 @@ static int abx500_gpio_probe(struct platform_device *pdev)
         pct->dev = &pdev->dev;
         pct->parent = dev_get_drvdata(pdev->dev.parent);
         pct->chip = abx500gpio_chip;
-        pct->chip.dev = &pdev->dev;
+        pct->chip.parent = &pdev->dev;
         pct->chip.base = -1; /* Dynamic allocation */
 
         match = of_match_device(abx500_gpio_match, &pdev->dev);
@@ -1210,7 +1202,7 @@ static int abx500_gpio_probe(struct platform_device *pdev)
         pct->irq_cluster = pct->soc->gpio_irq_cluster;
         pct->irq_cluster_size = pct->soc->ngpio_irq_cluster;
 
-        ret = gpiochip_add(&pct->chip);
+        ret = gpiochip_add_data(&pct->chip, pct);
         if (ret) {
                 dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret);
                 return ret;
diff --git a/drivers/pinctrl/nomadik/pinctrl-nomadik.c b/drivers/pinctrl/nomadik/pinctrl-nomadik.c
index eebfae0c9b7c..352406108fa0 100644
--- a/drivers/pinctrl/nomadik/pinctrl-nomadik.c
+++ b/drivers/pinctrl/nomadik/pinctrl-nomadik.c
@@ -438,7 +438,7 @@ nmk_gpio_disable_lazy_irq(struct nmk_gpio_chip *nmk_chip, unsigned offset)
                                nmk_chip->addr + NMK_GPIO_FIMSC);
         }
 
-        dev_dbg(nmk_chip->chip.dev, "%d: clearing interrupt mask\n", gpio);
+        dev_dbg(nmk_chip->chip.parent, "%d: clearing interrupt mask\n", gpio);
 }
 
 static void nmk_write_masked(void __iomem *reg, u32 mask, u32 value)
@@ -646,7 +646,7 @@ static inline int nmk_gpio_get_bitmask(int gpio)
 static void nmk_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
-        struct nmk_gpio_chip *nmk_chip = container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
 
         clk_enable(nmk_chip->clk);
         writel(nmk_gpio_get_bitmask(d->hwirq), nmk_chip->addr + NMK_GPIO_IC);
@@ -863,7 +863,7 @@ static void __nmk_gpio_irq_handler(struct irq_desc *desc, u32 status)
 static void nmk_gpio_irq_handler(struct irq_desc *desc)
 {
         struct gpio_chip *chip = irq_desc_get_handler_data(desc);
-        struct nmk_gpio_chip *nmk_chip = container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
         u32 status;
 
         clk_enable(nmk_chip->clk);
@@ -876,7 +876,7 @@ static void nmk_gpio_irq_handler(struct irq_desc *desc)
 static void nmk_gpio_latent_irq_handler(struct irq_desc *desc)
 {
         struct gpio_chip *chip = irq_desc_get_handler_data(desc);
-        struct nmk_gpio_chip *nmk_chip = container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
         u32 status = nmk_chip->get_latent_status(nmk_chip->bank);
 
         __nmk_gpio_irq_handler(desc, status);
@@ -886,8 +886,7 @@ static void nmk_gpio_latent_irq_handler(struct irq_desc *desc)
 
 static int nmk_gpio_make_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct nmk_gpio_chip *nmk_chip =
-                container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
 
         clk_enable(nmk_chip->clk);
 
@@ -900,8 +899,7 @@ static int nmk_gpio_make_input(struct gpio_chip *chip, unsigned offset)
 
 static int nmk_gpio_get_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct nmk_gpio_chip *nmk_chip =
-                container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
         u32 bit = 1 << offset;
         int value;
 
@@ -917,8 +915,7 @@ static int nmk_gpio_get_input(struct gpio_chip *chip, unsigned offset)
 static void nmk_gpio_set_output(struct gpio_chip *chip, unsigned offset,
                                 int val)
 {
-        struct nmk_gpio_chip *nmk_chip =
-                container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
 
         clk_enable(nmk_chip->clk);
 
@@ -930,8 +927,7 @@ static void nmk_gpio_set_output(struct gpio_chip *chip, unsigned offset,
 static int nmk_gpio_make_output(struct gpio_chip *chip, unsigned offset,
                                 int val)
 {
-        struct nmk_gpio_chip *nmk_chip =
-                container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
 
         clk_enable(nmk_chip->clk);
 
@@ -951,8 +947,7 @@ static void nmk_gpio_dbg_show_one(struct seq_file *s,
         unsigned offset, unsigned gpio)
 {
         const char *label = gpiochip_is_requested(chip, offset);
-        struct nmk_gpio_chip *nmk_chip =
-                container_of(chip, struct nmk_gpio_chip, chip);
+        struct nmk_gpio_chip *nmk_chip = gpiochip_get_data(chip);
         int mode;
         bool is_out;
         bool data_out;
@@ -1188,7 +1183,7 @@ static struct nmk_gpio_chip *nmk_gpio_populate_chip(struct device_node *np,
         chip->base = id * NMK_GPIO_PER_CHIP;
         chip->ngpio = NMK_GPIO_PER_CHIP;
         chip->label = dev_name(&gpio_pdev->dev);
-        chip->dev = &gpio_pdev->dev;
+        chip->parent = &gpio_pdev->dev;
 
         res = platform_get_resource(gpio_pdev, IORESOURCE_MEM, 0);
         base = devm_ioremap_resource(&pdev->dev, res);
@@ -1278,7 +1273,7 @@ static int nmk_gpio_probe(struct platform_device *dev)
         clk_disable(nmk_chip->clk);
         chip->of_node = np;
 
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, nmk_chip);
         if (ret)
                 return ret;
 
@@ -1789,7 +1784,7 @@ static int nmk_gpio_request_enable(struct pinctrl_dev *pctldev,
                 return -EINVAL;
         }
         chip = range->gc;
-        nmk_chip = container_of(chip, struct nmk_gpio_chip, chip);
+        nmk_chip = gpiochip_get_data(chip);
 
         dev_dbg(npct->dev, "enable pin %u as GPIO\n", offset);
 
@@ -1890,7 +1885,7 @@ static int nmk_pin_config_set(struct pinctrl_dev *pctldev, unsigned pin,
                         if (slpm_val)
                                 val = slpm_val - 1;
 
-                        dev_dbg(nmk_chip->chip.dev,
+                        dev_dbg(nmk_chip->chip.parent,
                                 "pin %d: sleep pull %s, dir %s, val %s\n",
                                 pin,
                                 slpm_pull ? pullnames[pull] : "same",
@@ -1899,7 +1894,7 @@ static int nmk_pin_config_set(struct pinctrl_dev *pctldev, unsigned pin,
                                 slpm_val ? (val ? "high" : "low") : "same");
                 }
 
-                dev_dbg(nmk_chip->chip.dev,
+                dev_dbg(nmk_chip->chip.parent,
                         "pin %d [%#lx]: pull %s, slpm %s (%s%s), lowemi %s\n",
                         pin, cfg, pullnames[pull], slpmnames[slpm],
                         output ? "output " : "input",
diff --git a/drivers/pinctrl/pinctrl-adi2.c b/drivers/pinctrl/pinctrl-adi2.c
index 8e9e8eab59ba..ecb57635a37e 100644
--- a/drivers/pinctrl/pinctrl-adi2.c
+++ b/drivers/pinctrl/pinctrl-adi2.c
@@ -636,7 +636,7 @@ static int adi_pinmux_set(struct pinctrl_dev *pctldev, unsigned func_id,
                 if (range == NULL) /* should not happen */
                         return -ENODEV;
 
-                port = container_of(range->gc, struct gpio_port, chip);
+                port = gpiochip_get_data(range->gc);
 
                 spin_lock_irqsave(&port->lock, flags);
 
@@ -684,7 +684,7 @@ static int adi_pinmux_request_gpio(struct pinctrl_dev *pctldev,
         unsigned long flags;
         u8 offset;
 
-        port = container_of(range->gc, struct gpio_port, chip);
+        port = gpiochip_get_data(range->gc);
         offset = pin_to_offset(range, pin);
 
         spin_lock_irqsave(&port->lock, flags);
@@ -718,7 +718,7 @@ static int adi_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
         struct gpio_port *port;
         unsigned long flags;
 
-        port = container_of(chip, struct gpio_port, chip);
+        port = gpiochip_get_data(chip);
 
         spin_lock_irqsave(&port->lock, flags);
 
@@ -733,7 +733,7 @@ static int adi_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static void adi_gpio_set_value(struct gpio_chip *chip, unsigned offset,
         int value)
 {
-        struct gpio_port *port = container_of(chip, struct gpio_port, chip);
+        struct gpio_port *port = gpiochip_get_data(chip);
         struct gpio_port_t *regs = port->regs;
         unsigned long flags;
 
@@ -750,7 +750,7 @@ static void adi_gpio_set_value(struct gpio_chip *chip, unsigned offset,
 static int adi_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
         int value)
 {
-        struct gpio_port *port = container_of(chip, struct gpio_port, chip);
+        struct gpio_port *port = gpiochip_get_data(chip);
         struct gpio_port_t *regs = port->regs;
         unsigned long flags;
 
@@ -770,7 +770,7 @@ static int adi_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 
 static int adi_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_port *port = container_of(chip, struct gpio_port, chip);
+        struct gpio_port *port = gpiochip_get_data(chip);
         struct gpio_port_t *regs = port->regs;
         unsigned long flags;
         int ret;
@@ -786,7 +786,7 @@ static int adi_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 
 static int adi_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_port *port = container_of(chip, struct gpio_port, chip);
+        struct gpio_port *port = gpiochip_get_data(chip);
 
         if (port->irq_base >= 0)
                 return irq_find_mapping(port->domain, offset);
@@ -994,7 +994,7 @@ static int adi_gpio_probe(struct platform_device *pdev)
         port->chip.ngpio                = port->width;
         gpio = port->chip.base + port->width;
 
-        ret = gpiochip_add(&port->chip);
+        ret = gpiochip_add_data(&port->chip, port);
         if (ret) {
                 dev_err(&pdev->dev, "Fail to add GPIO chip.\n");
                 goto out_remove_domain;
diff --git a/drivers/pinctrl/pinctrl-amd.c b/drivers/pinctrl/pinctrl-amd.c
index 3318f1d6193c..657449431301 100644
--- a/drivers/pinctrl/pinctrl-amd.c
+++ b/drivers/pinctrl/pinctrl-amd.c
@@ -35,16 +35,11 @@
 #include "pinctrl-utils.h"
 #include "pinctrl-amd.h"
 
-static inline struct amd_gpio *to_amd_gpio(struct gpio_chip *gc)
-{
-        return container_of(gc, struct amd_gpio, gc);
-}
-
 static int amd_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 {
         unsigned long flags;
         u32 pin_reg;
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + offset * 4);
@@ -71,7 +66,7 @@ static int amd_gpio_direction_output(struct gpio_chip *gc, unsigned offset,
 {
         u32 pin_reg;
         unsigned long flags;
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + offset * 4);
@@ -90,7 +85,7 @@ static int amd_gpio_get_value(struct gpio_chip *gc, unsigned offset)
 {
         u32 pin_reg;
         unsigned long flags;
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + offset * 4);
@@ -103,7 +98,7 @@ static void amd_gpio_set_value(struct gpio_chip *gc, unsigned offset, int value)
 {
         u32 pin_reg;
         unsigned long flags;
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + offset * 4);
@@ -122,7 +117,7 @@ static int amd_gpio_set_debounce(struct gpio_chip *gc, unsigned offset,
         u32 pin_reg;
         int ret = 0;
         unsigned long flags;
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + offset * 4);
@@ -186,7 +181,7 @@ static void amd_gpio_dbg_show(struct seq_file *s, struct gpio_chip *gc)
         u32 pin_reg;
         unsigned long flags;
         unsigned int bank, i, pin_num;
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         char *level_trig;
         char *active_level;
@@ -327,7 +322,7 @@ static void amd_gpio_irq_enable(struct irq_data *d)
         u32 pin_reg;
         unsigned long flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + (d->hwirq)*4);
@@ -351,7 +346,7 @@ static void amd_gpio_irq_disable(struct irq_data *d)
         u32 pin_reg;
         unsigned long flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + (d->hwirq)*4);
@@ -366,7 +361,7 @@ static void amd_gpio_irq_mask(struct irq_data *d)
         u32 pin_reg;
         unsigned long flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + (d->hwirq)*4);
@@ -380,7 +375,7 @@ static void amd_gpio_irq_unmask(struct irq_data *d)
         u32 pin_reg;
         unsigned long flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + (d->hwirq)*4);
@@ -394,7 +389,7 @@ static void amd_gpio_irq_eoi(struct irq_data *d)
         u32 reg;
         unsigned long flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         reg = readl(gpio_dev->base + WAKE_INT_MASTER_REG);
@@ -409,7 +404,7 @@ static int amd_gpio_irq_set_type(struct irq_data *d, unsigned int type)
         u32 pin_reg;
         unsigned long flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + (d->hwirq)*4);
@@ -504,7 +499,7 @@ static void amd_gpio_irq_handler(struct irq_desc *desc)
         unsigned long flags;
         struct irq_chip *chip = irq_desc_get_chip(desc);
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct amd_gpio *gpio_dev = to_amd_gpio(gc);
+        struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
 
         chained_irq_enter(chip, desc);
         /*enable GPIO interrupt again*/
@@ -778,7 +773,7 @@ static int amd_gpio_probe(struct platform_device *pdev)
         gpio_dev->gc.base                       = 0;
         gpio_dev->gc.label                      = pdev->name;
         gpio_dev->gc.owner                      = THIS_MODULE;
-        gpio_dev->gc.dev                        = &pdev->dev;
+        gpio_dev->gc.parent                     = &pdev->dev;
         gpio_dev->gc.ngpio                      = TOTAL_NUMBER_OF_PINS;
 #if defined(CONFIG_OF_GPIO)
         gpio_dev->gc.of_node                    = pdev->dev.of_node;
@@ -795,7 +790,7 @@ static int amd_gpio_probe(struct platform_device *pdev)
                 return PTR_ERR(gpio_dev->pctrl);
         }
 
-        ret = gpiochip_add(&gpio_dev->gc);
+        ret = gpiochip_add_data(&gpio_dev->gc, gpio_dev);
         if (ret)
                 goto out1;
 
diff --git a/drivers/pinctrl/pinctrl-as3722.c b/drivers/pinctrl/pinctrl-as3722.c
index 56af28b95a44..e844fdc6d3a8 100644
--- a/drivers/pinctrl/pinctrl-as3722.c
+++ b/drivers/pinctrl/pinctrl-as3722.c
@@ -436,14 +436,9 @@ static struct pinctrl_desc as3722_pinctrl_desc = {
         .owner = THIS_MODULE,
 };
 
-static inline struct as3722_pctrl_info *to_as_pci(struct gpio_chip *chip)
-{
-        return container_of(chip, struct as3722_pctrl_info, gpio_chip);
-}
-
 static int as3722_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct as3722_pctrl_info *as_pci = to_as_pci(chip);
+        struct as3722_pctrl_info *as_pci = gpiochip_get_data(chip);
         struct as3722 *as3722 = as_pci->as3722;
         int ret;
         u32 reg;
@@ -491,7 +486,7 @@ static int as3722_gpio_get(struct gpio_chip *chip, unsigned offset)
 static void as3722_gpio_set(struct gpio_chip *chip, unsigned offset,
                 int value)
 {
-        struct as3722_pctrl_info *as_pci = to_as_pci(chip);
+        struct as3722_pctrl_info *as_pci = gpiochip_get_data(chip);
         struct as3722 *as3722 = as_pci->as3722;
         int en_invert;
         u32 val;
@@ -531,7 +526,7 @@ static int as3722_gpio_direction_output(struct gpio_chip *chip,
 
 static int as3722_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct as3722_pctrl_info *as_pci = to_as_pci(chip);
+        struct as3722_pctrl_info *as_pci = gpiochip_get_data(chip);
 
         return as3722_irq_get_virq(as_pci->as3722, offset);
 }
@@ -582,9 +577,9 @@ static int as3722_pinctrl_probe(struct platform_device *pdev)
         }
 
         as_pci->gpio_chip = as3722_gpio_chip;
-        as_pci->gpio_chip.dev = &pdev->dev;
+        as_pci->gpio_chip.parent = &pdev->dev;
         as_pci->gpio_chip.of_node = pdev->dev.parent->of_node;
-        ret = gpiochip_add(&as_pci->gpio_chip);
+        ret = gpiochip_add_data(&as_pci->gpio_chip, as_pci);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Couldn't register gpiochip, %d\n", ret);
                 goto fail_chip_add;
diff --git a/drivers/pinctrl/pinctrl-at91-pio4.c b/drivers/pinctrl/pinctrl-at91-pio4.c
index d5bdcebc6aa6..ee69db6ae1c7 100644
--- a/drivers/pinctrl/pinctrl-at91-pio4.c
+++ b/drivers/pinctrl/pinctrl-at91-pio4.c
@@ -15,6 +15,8 @@
  */
 
 #include <linux/clk.h>
+#include <linux/gpio/driver.h>
+/* FIXME: needed for gpio_to_irq(), get rid of this */
 #include <linux/gpio.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
@@ -290,7 +292,7 @@ static void atmel_gpio_irq_handler(struct irq_desc *desc)
 
 static int atmel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct atmel_pioctrl *atmel_pioctrl = dev_get_drvdata(chip->dev);
+        struct atmel_pioctrl *atmel_pioctrl = gpiochip_get_data(chip);
         struct atmel_pin *pin = atmel_pioctrl->pins[offset];
         unsigned reg;
 
@@ -305,7 +307,7 @@ static int atmel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 
 static int atmel_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct atmel_pioctrl *atmel_pioctrl = dev_get_drvdata(chip->dev);
+        struct atmel_pioctrl *atmel_pioctrl = gpiochip_get_data(chip);
         struct atmel_pin *pin = atmel_pioctrl->pins[offset];
         unsigned reg;
 
@@ -317,7 +319,7 @@ static int atmel_gpio_get(struct gpio_chip *chip, unsigned offset)
 static int atmel_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                        int value)
 {
-        struct atmel_pioctrl *atmel_pioctrl = dev_get_drvdata(chip->dev);
+        struct atmel_pioctrl *atmel_pioctrl = gpiochip_get_data(chip);
         struct atmel_pin *pin = atmel_pioctrl->pins[offset];
         unsigned reg;
 
@@ -336,7 +338,7 @@ static int atmel_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 
 static void atmel_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 {
-        struct atmel_pioctrl *atmel_pioctrl = dev_get_drvdata(chip->dev);
+        struct atmel_pioctrl *atmel_pioctrl = gpiochip_get_data(chip);
         struct atmel_pin *pin = atmel_pioctrl->pins[offset];
 
         atmel_gpio_write(atmel_pioctrl, pin->bank,
@@ -346,7 +348,7 @@ static void atmel_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 
 static int atmel_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct atmel_pioctrl *atmel_pioctrl = dev_get_drvdata(chip->dev);
+        struct atmel_pioctrl *atmel_pioctrl = gpiochip_get_data(chip);
 
         return irq_find_mapping(atmel_pioctrl->irq_domain, offset);
 }
@@ -972,7 +974,7 @@ static int atmel_pinctrl_probe(struct platform_device *pdev)
         atmel_pioctrl->gpio_chip->of_node = dev->of_node;
         atmel_pioctrl->gpio_chip->ngpio = atmel_pioctrl->npins;
         atmel_pioctrl->gpio_chip->label = dev_name(dev);
-        atmel_pioctrl->gpio_chip->dev = dev;
+        atmel_pioctrl->gpio_chip->parent = dev;
         atmel_pioctrl->gpio_chip->names = atmel_pioctrl->group_names;
 
         atmel_pioctrl->pm_wakeup_sources = devm_kzalloc(dev,
@@ -1040,7 +1042,7 @@ static int atmel_pinctrl_probe(struct platform_device *pdev)
                 goto pinctrl_register_error;
         }
 
-        ret = gpiochip_add(atmel_pioctrl->gpio_chip);
+        ret = gpiochip_add_data(atmel_pioctrl->gpio_chip, atmel_pioctrl);
         if (ret) {
                 dev_err(dev, "failed to add gpiochip\n");
                 goto gpiochip_add_error;
diff --git a/drivers/pinctrl/pinctrl-at91.c b/drivers/pinctrl/pinctrl-at91.c
index 47b625b1b789..523b6b794d1f 100644
--- a/drivers/pinctrl/pinctrl-at91.c
+++ b/drivers/pinctrl/pinctrl-at91.c
@@ -45,8 +45,6 @@ struct at91_gpio_chip {
         struct at91_pinctrl_mux_ops *ops;       /* ops */
 };
 
-#define to_at91_gpio_chip(c) container_of(c, struct at91_gpio_chip, chip)
-
 static struct at91_gpio_chip *gpio_chips[MAX_GPIO_BANKS];
 
 static int gpio_banks;
@@ -811,7 +809,7 @@ static int at91_gpio_request_enable(struct pinctrl_dev *pctldev,
                 return -EINVAL;
         }
         chip = range->gc;
-        at91_chip = container_of(chip, struct at91_gpio_chip, chip);
+        at91_chip = gpiochip_get_data(chip);
 
         dev_dbg(npct->dev, "enable pin %u as GPIO\n", offset);
 
@@ -1282,7 +1280,7 @@ static int at91_pinctrl_remove(struct platform_device *pdev)
 
 static int at91_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 {
-        struct at91_gpio_chip *at91_gpio = to_at91_gpio_chip(chip);
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(chip);
         void __iomem *pio = at91_gpio->regbase;
         unsigned mask = 1 << offset;
         u32 osr;
@@ -1293,7 +1291,7 @@ static int at91_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 
 static int at91_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct at91_gpio_chip *at91_gpio = to_at91_gpio_chip(chip);
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(chip);
         void __iomem *pio = at91_gpio->regbase;
         unsigned mask = 1 << offset;
 
@@ -1303,7 +1301,7 @@ static int at91_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 
 static int at91_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct at91_gpio_chip *at91_gpio = to_at91_gpio_chip(chip);
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(chip);
         void __iomem *pio = at91_gpio->regbase;
         unsigned mask = 1 << offset;
         u32 pdsr;
@@ -1315,7 +1313,7 @@ static int at91_gpio_get(struct gpio_chip *chip, unsigned offset)
 static void at91_gpio_set(struct gpio_chip *chip, unsigned offset,
                                 int val)
 {
-        struct at91_gpio_chip *at91_gpio = to_at91_gpio_chip(chip);
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(chip);
         void __iomem *pio = at91_gpio->regbase;
         unsigned mask = 1 << offset;
 
@@ -1325,7 +1323,7 @@ static void at91_gpio_set(struct gpio_chip *chip, unsigned offset,
 static void at91_gpio_set_multiple(struct gpio_chip *chip,
                                       unsigned long *mask, unsigned long *bits)
 {
-        struct at91_gpio_chip *at91_gpio = to_at91_gpio_chip(chip);
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(chip);
         void __iomem *pio = at91_gpio->regbase;
 
 #define BITS_MASK(bits) (((bits) == 32) ? ~0U : (BIT(bits) - 1))
@@ -1340,7 +1338,7 @@ static void at91_gpio_set_multiple(struct gpio_chip *chip,
 static int at91_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                 int val)
 {
-        struct at91_gpio_chip *at91_gpio = to_at91_gpio_chip(chip);
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(chip);
         void __iomem *pio = at91_gpio->regbase;
         unsigned mask = 1 << offset;
 
@@ -1355,7 +1353,7 @@ static void at91_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
         enum at91_mux mode;
         int i;
-        struct at91_gpio_chip *at91_gpio = to_at91_gpio_chip(chip);
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(chip);
         void __iomem *pio = at91_gpio->regbase;
 
         for (i = 0; i < chip->ngpio; i++) {
@@ -1570,9 +1568,7 @@ static void gpio_irq_handler(struct irq_desc *desc)
 {
         struct irq_chip *chip = irq_desc_get_chip(desc);
         struct gpio_chip *gpio_chip = irq_desc_get_handler_data(desc);
-        struct at91_gpio_chip *at91_gpio = container_of(gpio_chip,
-                                           struct at91_gpio_chip, chip);
-
+        struct at91_gpio_chip *at91_gpio = gpiochip_get_data(gpio_chip);
         void __iomem    *pio = at91_gpio->regbase;
         unsigned long   isr;
         int             n;
@@ -1648,7 +1644,7 @@ static int at91_gpio_of_irq_setup(struct platform_device *pdev,
                 return 0;
         }
 
-        prev = container_of(gpiochip_prev, struct at91_gpio_chip, chip);
+        prev = gpiochip_get_data(gpiochip_prev);
 
         /* we can only have 2 banks before */
         for (i = 0; i < 2; i++) {
@@ -1750,7 +1746,7 @@ static int at91_gpio_probe(struct platform_device *pdev)
         chip = &at91_chip->chip;
         chip->of_node = np;
         chip->label = dev_name(&pdev->dev);
-        chip->dev = &pdev->dev;
+        chip->parent = &pdev->dev;
         chip->owner = THIS_MODULE;
         chip->base = alias_idx * MAX_NB_GPIO_PER_BANK;
 
@@ -1783,7 +1779,7 @@ static int at91_gpio_probe(struct platform_device *pdev)
         range->npins = chip->ngpio;
         range->gc = chip;
 
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, at91_chip);
         if (ret)
                 goto gpiochip_add_err;
 
diff --git a/drivers/pinctrl/pinctrl-coh901.c b/drivers/pinctrl/pinctrl-coh901.c
index 813eb7c771ec..cf7788df0f95 100644
--- a/drivers/pinctrl/pinctrl-coh901.c
+++ b/drivers/pinctrl/pinctrl-coh901.c
@@ -208,25 +208,16 @@ bs335_gpio_config[U300_GPIO_NUM_PORTS][U300_GPIO_PINS_PER_PORT] = {
         }
 };
 
-/**
- * to_u300_gpio() - get the pointer to u300_gpio
- * @chip: the gpio chip member of the structure u300_gpio
- */
-static inline struct u300_gpio *to_u300_gpio(struct gpio_chip *chip)
-{
-        return container_of(chip, struct u300_gpio, chip);
-}
-
 static int u300_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
 
-        return readl(U300_PIN_REG(offset, dir)) & U300_PIN_BIT(offset);
+        return !!(readl(U300_PIN_REG(offset, dir)) & U300_PIN_BIT(offset));
 }
 
 static void u300_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         unsigned long flags;
         u32 val;
 
@@ -243,7 +234,7 @@ static void u300_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 static int u300_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         unsigned long flags;
         u32 val;
 
@@ -259,7 +250,7 @@ static int u300_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int u300_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
                                       int value)
 {
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         unsigned long flags;
         u32 oldmode;
         u32 val;
@@ -290,7 +281,7 @@ int u300_gpio_config_get(struct gpio_chip *chip,
                          unsigned offset,
                          unsigned long *config)
 {
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         enum pin_config_param param = (enum pin_config_param) *config;
         bool biasmode;
         u32 drmode;
@@ -348,7 +339,7 @@ int u300_gpio_config_get(struct gpio_chip *chip,
 int u300_gpio_config_set(struct gpio_chip *chip, unsigned offset,
                          enum pin_config_param param)
 {
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         unsigned long flags;
         u32 val;
 
@@ -429,7 +420,7 @@ static void u300_toggle_trigger(struct u300_gpio *gpio, unsigned offset)
 static int u300_gpio_irq_type(struct irq_data *d, unsigned trigger)
 {
         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         struct u300_gpio_port *port = &gpio->ports[d->hwirq >> 3];
         int offset = d->hwirq;
         u32 val;
@@ -466,7 +457,7 @@ static int u300_gpio_irq_type(struct irq_data *d, unsigned trigger)
 static void u300_gpio_irq_enable(struct irq_data *d)
 {
         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         struct u300_gpio_port *port = &gpio->ports[d->hwirq >> 3];
         int offset = d->hwirq;
         u32 val;
@@ -483,7 +474,7 @@ static void u300_gpio_irq_enable(struct irq_data *d)
 static void u300_gpio_irq_disable(struct irq_data *d)
 {
         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         int offset = d->hwirq;
         u32 val;
         unsigned long flags;
@@ -506,7 +497,7 @@ static void u300_gpio_irq_handler(struct irq_desc *desc)
         unsigned int irq = irq_desc_get_irq(desc);
         struct irq_chip *parent_chip = irq_desc_get_chip(desc);
         struct gpio_chip *chip = irq_desc_get_handler_data(desc);
-        struct u300_gpio *gpio = to_u300_gpio(chip);
+        struct u300_gpio *gpio = gpiochip_get_data(chip);
         struct u300_gpio_port *port = &gpio->ports[irq - chip->base];
         int pinoffset = port->number << 3; /* get the right stride */
         unsigned long val;
@@ -637,7 +628,7 @@ static int __init u300_gpio_probe(struct platform_device *pdev)
 
         gpio->chip = u300_gpio_chip;
         gpio->chip.ngpio = U300_GPIO_NUM_PORTS * U300_GPIO_PINS_PER_PORT;
-        gpio->chip.dev = &pdev->dev;
+        gpio->chip.parent = &pdev->dev;
         gpio->chip.base = 0;
         gpio->dev = &pdev->dev;
 
@@ -684,7 +675,7 @@ static int __init u300_gpio_probe(struct platform_device *pdev)
 #ifdef CONFIG_OF_GPIO
         gpio->chip.of_node = pdev->dev.of_node;
 #endif
-        err = gpiochip_add(&gpio->chip);
+        err = gpiochip_add_data(&gpio->chip, gpio);
         if (err) {
                 dev_err(gpio->dev, "unable to add gpiochip: %d\n", err);
                 goto err_no_chip;
diff --git a/drivers/pinctrl/pinctrl-digicolor.c b/drivers/pinctrl/pinctrl-digicolor.c
index 38a7799f8257..f1343d6ca823 100644
--- a/drivers/pinctrl/pinctrl-digicolor.c
+++ b/drivers/pinctrl/pinctrl-digicolor.c
@@ -171,7 +171,7 @@ static struct pinmux_ops dc_pmxops = {
 
 static int dc_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 {
-        struct dc_pinmap *pmap = container_of(chip, struct dc_pinmap, chip);
+        struct dc_pinmap *pmap = gpiochip_get_data(chip);
         int reg_off = GP_DRIVE0(gpio/PINS_PER_COLLECTION);
         int bit_off = gpio % PINS_PER_COLLECTION;
         u8 drive;
@@ -191,7 +191,7 @@ static void dc_gpio_set(struct gpio_chip *chip, unsigned gpio, int value);
 static int dc_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
                                     int value)
 {
-        struct dc_pinmap *pmap = container_of(chip, struct dc_pinmap, chip);
+        struct dc_pinmap *pmap = gpiochip_get_data(chip);
         int reg_off = GP_DRIVE0(gpio/PINS_PER_COLLECTION);
         int bit_off = gpio % PINS_PER_COLLECTION;
         u8 drive;
@@ -210,7 +210,7 @@ static int dc_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
 
 static int dc_gpio_get(struct gpio_chip *chip, unsigned gpio)
 {
-        struct dc_pinmap *pmap = container_of(chip, struct dc_pinmap, chip);
+        struct dc_pinmap *pmap = gpiochip_get_data(chip);
         int reg_off = GP_INPUT(gpio/PINS_PER_COLLECTION);
         int bit_off = gpio % PINS_PER_COLLECTION;
         u8 input;
@@ -222,7 +222,7 @@ static int dc_gpio_get(struct gpio_chip *chip, unsigned gpio)
 
 static void dc_gpio_set(struct gpio_chip *chip, unsigned gpio, int value)
 {
-        struct dc_pinmap *pmap = container_of(chip, struct dc_pinmap, chip);
+        struct dc_pinmap *pmap = gpiochip_get_data(chip);
         int reg_off = GP_OUTPUT0(gpio/PINS_PER_COLLECTION);
         int bit_off = gpio % PINS_PER_COLLECTION;
         u8 output;
@@ -244,7 +244,7 @@ static int dc_gpiochip_add(struct dc_pinmap *pmap, struct device_node *np)
         int ret;
 
         chip->label             = DRIVER_NAME;
-        chip->dev               = pmap->dev;
+        chip->parent            = pmap->dev;
         chip->request           = gpiochip_generic_request;
         chip->free              = gpiochip_generic_free;
         chip->direction_input   = dc_gpio_direction_input;
@@ -258,7 +258,7 @@ static int dc_gpiochip_add(struct dc_pinmap *pmap, struct device_node *np)
 
         spin_lock_init(&pmap->lock);
 
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, pmap);
         if (ret < 0)
                 return ret;
 
diff --git a/drivers/pinctrl/pinctrl-pistachio.c b/drivers/pinctrl/pinctrl-pistachio.c
index 85c9046c690e..856f736cb1a6 100644
--- a/drivers/pinctrl/pinctrl-pistachio.c
+++ b/drivers/pinctrl/pinctrl-pistachio.c
@@ -842,14 +842,9 @@ static inline void pctl_writel(struct pistachio_pinctrl *pctl, u32 val, u32 reg)
         writel(val, pctl->base + reg);
 }
 
-static inline struct pistachio_gpio_bank *gc_to_bank(struct gpio_chip *gc)
-{
-        return container_of(gc, struct pistachio_gpio_bank, gpio_chip);
-}
-
 static inline struct pistachio_gpio_bank *irqd_to_bank(struct irq_data *d)
 {
-        return gc_to_bank(irq_data_get_irq_chip_data(d));
+        return gpiochip_get_data(irq_data_get_irq_chip_data(d));
 }
 
 static inline u32 gpio_readl(struct pistachio_gpio_bank *bank, u32 reg)
@@ -992,7 +987,7 @@ static int pistachio_pinmux_enable(struct pinctrl_dev *pctldev,
 
         range = pinctrl_find_gpio_range_from_pin(pctl->pctldev, pg->pin);
         if (range)
-                gpio_disable(gc_to_bank(range->gc), pg->pin - range->pin_base);
+                gpio_disable(gpiochip_get_data(range->gc), pg->pin - range->pin_base);
 
         return 0;
 }
@@ -1173,14 +1168,14 @@ static struct pinctrl_desc pistachio_pinctrl_desc = {
 
 static int pistachio_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 {
-        struct pistachio_gpio_bank *bank = gc_to_bank(chip);
+        struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
 
         return !(gpio_readl(bank, GPIO_OUTPUT_EN) & BIT(offset));
 }
 
 static int pistachio_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct pistachio_gpio_bank *bank = gc_to_bank(chip);
+        struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
         u32 reg;
 
         if (gpio_readl(bank, GPIO_OUTPUT_EN) & BIT(offset))
@@ -1194,7 +1189,7 @@ static int pistachio_gpio_get(struct gpio_chip *chip, unsigned offset)
 static void pistachio_gpio_set(struct gpio_chip *chip, unsigned offset,
                                int value)
 {
-        struct pistachio_gpio_bank *bank = gc_to_bank(chip);
+        struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
 
         gpio_mask_writel(bank, GPIO_OUTPUT, offset, !!value);
 }
@@ -1202,7 +1197,7 @@ static void pistachio_gpio_set(struct gpio_chip *chip, unsigned offset,
 static int pistachio_gpio_direction_input(struct gpio_chip *chip,
                                           unsigned offset)
 {
-        struct pistachio_gpio_bank *bank = gc_to_bank(chip);
+        struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
 
         gpio_mask_writel(bank, GPIO_OUTPUT_EN, offset, 0);
         gpio_enable(bank, offset);
@@ -1213,7 +1208,7 @@ static int pistachio_gpio_direction_input(struct gpio_chip *chip,
 static int pistachio_gpio_direction_output(struct gpio_chip *chip,
                                            unsigned offset, int value)
 {
-        struct pistachio_gpio_bank *bank = gc_to_bank(chip);
+        struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
 
         pistachio_gpio_set(chip, offset, value);
         gpio_mask_writel(bank, GPIO_OUTPUT_EN, offset, 1);
@@ -1303,7 +1298,7 @@ static int pistachio_gpio_irq_set_type(struct irq_data *data, unsigned int type)
 static void pistachio_gpio_irq_handler(struct irq_desc *desc)
 {
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct pistachio_gpio_bank *bank = gc_to_bank(gc);
+        struct pistachio_gpio_bank *bank = gpiochip_get_data(gc);
         struct irq_chip *chip = irq_desc_get_chip(desc);
         unsigned long pending;
         unsigned int pin;
@@ -1388,9 +1383,9 @@ static int pistachio_gpio_register(struct pistachio_pinctrl *pctl)
                 bank->pctl = pctl;
                 bank->base = pctl->base + GPIO_BANK_BASE(i);
 
-                bank->gpio_chip.dev = pctl->dev;
+                bank->gpio_chip.parent = pctl->dev;
                 bank->gpio_chip.of_node = child;
-                ret = gpiochip_add(&bank->gpio_chip);
+                ret = gpiochip_add_data(&bank->gpio_chip, bank);
                 if (ret < 0) {
                         dev_err(pctl->dev, "Failed to add GPIO chip %u: %d\n",
                                 i, ret);
diff --git a/drivers/pinctrl/pinctrl-rockchip.c b/drivers/pinctrl/pinctrl-rockchip.c
index 91288265e856..183545a068ad 100644
--- a/drivers/pinctrl/pinctrl-rockchip.c
+++ b/drivers/pinctrl/pinctrl-rockchip.c
@@ -224,11 +224,6 @@ static struct regmap_config rockchip_regmap_config = {
         .reg_stride = 4,
 };
 
-static inline struct rockchip_pin_bank *gc_to_pin_bank(struct gpio_chip *gc)
-{
-        return container_of(gc, struct rockchip_pin_bank, gpio_chip);
-}
-
 static const inline struct rockchip_pin_group *pinctrl_name_to_group(
                                         const struct rockchip_pinctrl *info,
                                         const char *name)
@@ -973,7 +968,7 @@ static int _rockchip_pmx_gpio_set_direction(struct gpio_chip *chip,
         unsigned long flags;
         u32 data;
 
-        bank = gc_to_pin_bank(chip);
+        bank = gpiochip_get_data(chip);
 
         ret = rockchip_set_mux(bank, pin, RK_FUNC_GPIO);
         if (ret < 0)
@@ -1413,7 +1408,7 @@ static int rockchip_pinctrl_register(struct platform_device *pdev,
 
 static void rockchip_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
+        struct rockchip_pin_bank *bank = gpiochip_get_data(gc);
         void __iomem *reg = bank->reg_base + GPIO_SWPORT_DR;
         unsigned long flags;
         u32 data;
@@ -1437,7 +1432,7 @@ static void rockchip_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
  */
 static int rockchip_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
+        struct rockchip_pin_bank *bank = gpiochip_get_data(gc);
         u32 data;
 
         clk_enable(bank->clk);
@@ -1476,7 +1471,7 @@ static int rockchip_gpio_direction_output(struct gpio_chip *gc,
  */
 static int rockchip_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
+        struct rockchip_pin_bank *bank = gpiochip_get_data(gc);
         unsigned int virq;
 
         if (!bank->domain)
@@ -1791,11 +1786,11 @@ static int rockchip_gpiolib_register(struct platform_device *pdev,
                 gc = &bank->gpio_chip;
                 gc->base = bank->pin_base;
                 gc->ngpio = bank->nr_pins;
-                gc->dev = &pdev->dev;
+                gc->parent = &pdev->dev;
                 gc->of_node = bank->of_node;
                 gc->label = bank->name;
 
-                ret = gpiochip_add(gc);
+                ret = gpiochip_add_data(gc, bank);
                 if (ret) {
                         dev_err(&pdev->dev, "failed to register gpio_chip %s, error code: %d\n",
                                                         gc->label, ret);
diff --git a/drivers/pinctrl/pinctrl-st.c b/drivers/pinctrl/pinctrl-st.c
index b58d3f29148a..fac844a85cb4 100644
--- a/drivers/pinctrl/pinctrl-st.c
+++ b/drivers/pinctrl/pinctrl-st.c
@@ -203,9 +203,6 @@
 #define gpio_range_to_bank(chip) \
                 container_of(chip, struct st_gpio_bank, range)
 
-#define gpio_chip_to_bank(chip) \
-                container_of(chip, struct st_gpio_bank, gpio_chip)
-
 #define pc_to_bank(pc) \
                 container_of(pc, struct st_gpio_bank, pc)
 
@@ -744,14 +741,14 @@ static void st_gpio_direction(struct st_gpio_bank *bank,
 
 static int st_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct st_gpio_bank *bank = gpio_chip_to_bank(chip);
+        struct st_gpio_bank *bank = gpiochip_get_data(chip);
 
         return !!(readl(bank->base + REG_PIO_PIN) & BIT(offset));
 }
 
 static void st_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct st_gpio_bank *bank = gpio_chip_to_bank(chip);
+        struct st_gpio_bank *bank = gpiochip_get_data(chip);
         __st_gpio_set(bank, offset, value);
 }
 
@@ -765,7 +762,7 @@ static int st_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int st_gpio_direction_output(struct gpio_chip *chip,
         unsigned offset, int value)
 {
-        struct st_gpio_bank *bank = gpio_chip_to_bank(chip);
+        struct st_gpio_bank *bank = gpiochip_get_data(chip);
 
         __st_gpio_set(bank, offset, value);
         pinctrl_gpio_direction_output(chip->base + offset);
@@ -775,7 +772,7 @@ static int st_gpio_direction_output(struct gpio_chip *chip,
 
 static int st_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 {
-        struct st_gpio_bank *bank = gpio_chip_to_bank(chip);
+        struct st_gpio_bank *bank = gpiochip_get_data(chip);
         struct st_pio_control pc = bank->pc;
         unsigned long config;
         unsigned int direction = 0;
@@ -1325,7 +1322,7 @@ static int st_pctl_parse_functions(struct device_node *np,
 static void st_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct st_gpio_bank *bank = gpio_chip_to_bank(gc);
+        struct st_gpio_bank *bank = gpiochip_get_data(gc);
 
         writel(BIT(d->hwirq), bank->base + REG_PIO_CLR_PMASK);
 }
@@ -1333,7 +1330,7 @@ static void st_gpio_irq_mask(struct irq_data *d)
 static void st_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct st_gpio_bank *bank = gpio_chip_to_bank(gc);
+        struct st_gpio_bank *bank = gpiochip_get_data(gc);
 
         writel(BIT(d->hwirq), bank->base + REG_PIO_SET_PMASK);
 }
@@ -1341,7 +1338,7 @@ static void st_gpio_irq_unmask(struct irq_data *d)
 static int st_gpio_irq_set_type(struct irq_data *d, unsigned type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct st_gpio_bank *bank = gpio_chip_to_bank(gc);
+        struct st_gpio_bank *bank = gpiochip_get_data(gc);
         unsigned long flags;
         int comp, pin = d->hwirq;
         u32 val;
@@ -1455,7 +1452,7 @@ static void st_gpio_irq_handler(struct irq_desc *desc)
         /* interrupt dedicated per bank */
         struct irq_chip *chip = irq_desc_get_chip(desc);
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct st_gpio_bank *bank = gpio_chip_to_bank(gc);
+        struct st_gpio_bank *bank = gpiochip_get_data(gc);
 
         chained_irq_enter(chip, desc);
         __gpio_irq_handler(bank);
@@ -1522,7 +1519,7 @@ static int st_gpiolib_register_bank(struct st_pinctrl *info,
         bank->gpio_chip.base = bank_num * ST_GPIO_PINS_PER_BANK;
         bank->gpio_chip.ngpio = ST_GPIO_PINS_PER_BANK;
         bank->gpio_chip.of_node = np;
-        bank->gpio_chip.dev = dev;
+        bank->gpio_chip.parent = dev;
         spin_lock_init(&bank->lock);
 
         of_property_read_string(np, "st,bank-name", &range->name);
@@ -1532,7 +1529,7 @@ static int st_gpiolib_register_bank(struct st_pinctrl *info,
         range->pin_base = range->base = range->id * ST_GPIO_PINS_PER_BANK;
         range->npins = bank->gpio_chip.ngpio;
         range->gc = &bank->gpio_chip;
-        err  = gpiochip_add(&bank->gpio_chip);
+        err  = gpiochip_add_data(&bank->gpio_chip, bank);
         if (err) {
                 dev_err(dev, "Failed to add gpiochip(%d)!\n", bank_num);
                 return err;
diff --git a/drivers/pinctrl/pinctrl-xway.c b/drivers/pinctrl/pinctrl-xway.c
index 7db74699fda4..412c6b78140a 100644
--- a/drivers/pinctrl/pinctrl-xway.c
+++ b/drivers/pinctrl/pinctrl-xway.c
@@ -1535,7 +1535,7 @@ static struct ltq_pinmux_info xway_info = {
 /* ---------  gpio_chip related code --------- */
 static void xway_gpio_set(struct gpio_chip *chip, unsigned int pin, int val)
 {
-        struct ltq_pinmux_info *info = dev_get_drvdata(chip->dev);
+        struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
 
         if (val)
                 gpio_setbit(info->membase[0], GPIO_OUT(pin), PORT_PIN(pin));
@@ -1545,14 +1545,14 @@ static void xway_gpio_set(struct gpio_chip *chip, unsigned int pin, int val)
 
 static int xway_gpio_get(struct gpio_chip *chip, unsigned int pin)
 {
-        struct ltq_pinmux_info *info = dev_get_drvdata(chip->dev);
+        struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
 
-        return gpio_getbit(info->membase[0], GPIO_IN(pin), PORT_PIN(pin));
+        return !!gpio_getbit(info->membase[0], GPIO_IN(pin), PORT_PIN(pin));
 }
 
 static int xway_gpio_dir_in(struct gpio_chip *chip, unsigned int pin)
 {
-        struct ltq_pinmux_info *info = dev_get_drvdata(chip->dev);
+        struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
 
         gpio_clearbit(info->membase[0], GPIO_DIR(pin), PORT_PIN(pin));
 
@@ -1561,7 +1561,7 @@ static int xway_gpio_dir_in(struct gpio_chip *chip, unsigned int pin)
 
 static int xway_gpio_dir_out(struct gpio_chip *chip, unsigned int pin, int val)
 {
-        struct ltq_pinmux_info *info = dev_get_drvdata(chip->dev);
+        struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
 
         if (PORT(pin) == PORT3)
                 gpio_setbit(info->membase[0], GPIO3_OD, PORT_PIN(pin));
@@ -1708,7 +1708,7 @@ static int pinmux_xway_probe(struct platform_device *pdev)
         xway_pctrl_desc.pins = xway_info.pads;
 
         /* load the gpio chip */
-        xway_chip.dev = &pdev->dev;
+        xway_chip.parent = &pdev->dev;
         ret = gpiochip_add(&xway_chip);
         if (ret) {
                 dev_err(&pdev->dev, "Failed to register gpio chip\n");
diff --git a/drivers/pinctrl/qcom/pinctrl-msm.c b/drivers/pinctrl/qcom/pinctrl-msm.c
index 146264a41ec8..8777cf083eef 100644
--- a/drivers/pinctrl/qcom/pinctrl-msm.c
+++ b/drivers/pinctrl/qcom/pinctrl-msm.c
@@ -69,11 +69,6 @@ struct msm_pinctrl {
         void __iomem *regs;
 };
 
-static inline struct msm_pinctrl *to_msm_pinctrl(struct gpio_chip *gc)
-{
-        return container_of(gc, struct msm_pinctrl, chip);
-}
-
 static int msm_get_groups_count(struct pinctrl_dev *pctldev)
 {
         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
@@ -381,7 +376,7 @@ static struct pinctrl_desc msm_pinctrl_desc = {
 static int msm_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
         const struct msm_pingroup *g;
-        struct msm_pinctrl *pctrl = container_of(chip, struct msm_pinctrl, chip);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
         unsigned long flags;
         u32 val;
 
@@ -401,7 +396,7 @@ static int msm_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int msm_gpio_direction_output(struct gpio_chip *chip, unsigned offset, int value)
 {
         const struct msm_pingroup *g;
-        struct msm_pinctrl *pctrl = container_of(chip, struct msm_pinctrl, chip);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
         unsigned long flags;
         u32 val;
 
@@ -428,7 +423,7 @@ static int msm_gpio_direction_output(struct gpio_chip *chip, unsigned offset, in
 static int msm_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
         const struct msm_pingroup *g;
-        struct msm_pinctrl *pctrl = container_of(chip, struct msm_pinctrl, chip);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
         u32 val;
 
         g = &pctrl->soc->groups[offset];
@@ -440,7 +435,7 @@ static int msm_gpio_get(struct gpio_chip *chip, unsigned offset)
 static void msm_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
         const struct msm_pingroup *g;
-        struct msm_pinctrl *pctrl = container_of(chip, struct msm_pinctrl, chip);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
         unsigned long flags;
         u32 val;
 
@@ -468,7 +463,7 @@ static void msm_gpio_dbg_show_one(struct seq_file *s,
                                   unsigned gpio)
 {
         const struct msm_pingroup *g;
-        struct msm_pinctrl *pctrl = container_of(chip, struct msm_pinctrl, chip);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
         unsigned func;
         int is_out;
         int drive;
@@ -567,7 +562,7 @@ static void msm_gpio_update_dual_edge_pos(struct msm_pinctrl *pctrl,
 static void msm_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct msm_pinctrl *pctrl = to_msm_pinctrl(gc);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
         const struct msm_pingroup *g;
         unsigned long flags;
         u32 val;
@@ -588,7 +583,7 @@ static void msm_gpio_irq_mask(struct irq_data *d)
 static void msm_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct msm_pinctrl *pctrl = to_msm_pinctrl(gc);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
         const struct msm_pingroup *g;
         unsigned long flags;
         u32 val;
@@ -613,7 +608,7 @@ static void msm_gpio_irq_unmask(struct irq_data *d)
 static void msm_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct msm_pinctrl *pctrl = to_msm_pinctrl(gc);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
         const struct msm_pingroup *g;
         unsigned long flags;
         u32 val;
@@ -638,7 +633,7 @@ static void msm_gpio_irq_ack(struct irq_data *d)
 static int msm_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct msm_pinctrl *pctrl = to_msm_pinctrl(gc);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
         const struct msm_pingroup *g;
         unsigned long flags;
         u32 val;
@@ -732,7 +727,7 @@ static int msm_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 static int msm_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct msm_pinctrl *pctrl = to_msm_pinctrl(gc);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&pctrl->lock, flags);
@@ -757,7 +752,7 @@ static void msm_gpio_irq_handler(struct irq_desc *desc)
 {
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
         const struct msm_pingroup *g;
-        struct msm_pinctrl *pctrl = to_msm_pinctrl(gc);
+        struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
         struct irq_chip *chip = irq_desc_get_chip(desc);
         int irq_pin;
         int handled = 0;
@@ -800,11 +795,11 @@ static int msm_gpio_init(struct msm_pinctrl *pctrl)
         chip->base = 0;
         chip->ngpio = ngpio;
         chip->label = dev_name(pctrl->dev);
-        chip->dev = pctrl->dev;
+        chip->parent = pctrl->dev;
         chip->owner = THIS_MODULE;
         chip->of_node = pctrl->dev->of_node;
 
-        ret = gpiochip_add(&pctrl->chip);
+        ret = gpiochip_add_data(&pctrl->chip, pctrl);
         if (ret) {
                 dev_err(pctrl->dev, "Failed register gpiochip\n");
                 return ret;
diff --git a/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c b/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c
index 77f6a5cb1008..4e12ded3c773 100644
--- a/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c
+++ b/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c
@@ -159,11 +159,6 @@ static const char *const pmic_gpio_functions[] = {
         PMIC_GPIO_FUNC_DTEST3, PMIC_GPIO_FUNC_DTEST4,
 };
 
-static inline struct pmic_gpio_state *to_gpio_state(struct gpio_chip *chip)
-{
-        return container_of(chip, struct pmic_gpio_state, chip);
-};
-
 static int pmic_gpio_read(struct pmic_gpio_state *state,
                           struct pmic_gpio_pad *pad, unsigned int addr)
 {
@@ -496,7 +491,7 @@ static const struct pinconf_ops pmic_gpio_pinconf_ops = {
 
 static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 {
-        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_state *state = gpiochip_get_data(chip);
         unsigned long config;
 
         config = pinconf_to_config_packed(PIN_CONFIG_INPUT_ENABLE, 1);
@@ -507,7 +502,7 @@ static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 static int pmic_gpio_direction_output(struct gpio_chip *chip,
                                       unsigned pin, int val)
 {
-        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_state *state = gpiochip_get_data(chip);
         unsigned long config;
 
         config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, val);
@@ -517,7 +512,7 @@ static int pmic_gpio_direction_output(struct gpio_chip *chip,
 
 static int pmic_gpio_get(struct gpio_chip *chip, unsigned pin)
 {
-        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_state *state = gpiochip_get_data(chip);
         struct pmic_gpio_pad *pad;
         int ret;
 
@@ -534,12 +529,12 @@ static int pmic_gpio_get(struct gpio_chip *chip, unsigned pin)
                 pad->out_value = ret & PMIC_MPP_REG_RT_STS_VAL_MASK;
         }
 
-        return pad->out_value;
+        return !!pad->out_value;
 }
 
 static void pmic_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
 {
-        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_state *state = gpiochip_get_data(chip);
         unsigned long config;
 
         config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, value);
@@ -562,7 +557,7 @@ static int pmic_gpio_of_xlate(struct gpio_chip *chip,
 
 static int pmic_gpio_to_irq(struct gpio_chip *chip, unsigned pin)
 {
-        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_state *state = gpiochip_get_data(chip);
         struct pmic_gpio_pad *pad;
 
         pad = state->ctrl->desc->pins[pin].drv_data;
@@ -572,7 +567,7 @@ static int pmic_gpio_to_irq(struct gpio_chip *chip, unsigned pin)
 
 static void pmic_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_state *state = gpiochip_get_data(chip);
         unsigned i;
 
         for (i = 0; i < chip->ngpio; i++) {
@@ -762,7 +757,7 @@ static int pmic_gpio_probe(struct platform_device *pdev)
         }
 
         state->chip = pmic_gpio_gpio_template;
-        state->chip.dev = dev;
+        state->chip.parent = dev;
         state->chip.base = -1;
         state->chip.ngpio = npins;
         state->chip.label = dev_name(dev);
@@ -773,7 +768,7 @@ static int pmic_gpio_probe(struct platform_device *pdev)
         if (IS_ERR(state->ctrl))
                 return PTR_ERR(state->ctrl);
 
-        ret = gpiochip_add(&state->chip);
+        ret = gpiochip_add_data(&state->chip, state);
         if (ret) {
                 dev_err(state->dev, "can't add gpio chip\n");
                 goto err_chip;
diff --git a/drivers/pinctrl/qcom/pinctrl-spmi-mpp.c b/drivers/pinctrl/qcom/pinctrl-spmi-mpp.c
index 2df4f29175ae..2f18323571a6 100644
--- a/drivers/pinctrl/qcom/pinctrl-spmi-mpp.c
+++ b/drivers/pinctrl/qcom/pinctrl-spmi-mpp.c
@@ -179,11 +179,6 @@ static const char *const pmic_mpp_functions[] = {
         "digital", "analog", "sink"
 };
 
-static inline struct pmic_mpp_state *to_mpp_state(struct gpio_chip *chip)
-{
-        return container_of(chip, struct pmic_mpp_state, chip);
-};
-
 static int pmic_mpp_read(struct pmic_mpp_state *state,
                          struct pmic_mpp_pad *pad, unsigned int addr)
 {
@@ -557,7 +552,7 @@ static const struct pinconf_ops pmic_mpp_pinconf_ops = {
 
 static int pmic_mpp_direction_input(struct gpio_chip *chip, unsigned pin)
 {
-        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_state *state = gpiochip_get_data(chip);
         unsigned long config;
 
         config = pinconf_to_config_packed(PIN_CONFIG_INPUT_ENABLE, 1);
@@ -568,7 +563,7 @@ static int pmic_mpp_direction_input(struct gpio_chip *chip, unsigned pin)
 static int pmic_mpp_direction_output(struct gpio_chip *chip,
                                      unsigned pin, int val)
 {
-        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_state *state = gpiochip_get_data(chip);
         unsigned long config;
 
         config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, val);
@@ -578,7 +573,7 @@ static int pmic_mpp_direction_output(struct gpio_chip *chip,
 
 static int pmic_mpp_get(struct gpio_chip *chip, unsigned pin)
 {
-        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_state *state = gpiochip_get_data(chip);
         struct pmic_mpp_pad *pad;
         int ret;
 
@@ -592,12 +587,12 @@ static int pmic_mpp_get(struct gpio_chip *chip, unsigned pin)
                 pad->out_value = ret & PMIC_MPP_REG_RT_STS_VAL_MASK;
         }
 
-        return pad->out_value;
+        return !!pad->out_value;
 }
 
 static void pmic_mpp_set(struct gpio_chip *chip, unsigned pin, int value)
 {
-        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_state *state = gpiochip_get_data(chip);
         unsigned long config;
 
         config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, value);
@@ -620,7 +615,7 @@ static int pmic_mpp_of_xlate(struct gpio_chip *chip,
 
 static int pmic_mpp_to_irq(struct gpio_chip *chip, unsigned pin)
 {
-        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_state *state = gpiochip_get_data(chip);
         struct pmic_mpp_pad *pad;
 
         pad = state->ctrl->desc->pins[pin].drv_data;
@@ -630,7 +625,7 @@ static int pmic_mpp_to_irq(struct gpio_chip *chip, unsigned pin)
 
 static void pmic_mpp_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
-        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_state *state = gpiochip_get_data(chip);
         unsigned i;
 
         for (i = 0; i < chip->ngpio; i++) {
@@ -865,7 +860,7 @@ static int pmic_mpp_probe(struct platform_device *pdev)
         }
 
         state->chip = pmic_mpp_gpio_template;
-        state->chip.dev = dev;
+        state->chip.parent = dev;
         state->chip.base = -1;
         state->chip.ngpio = npins;
         state->chip.label = dev_name(dev);
@@ -876,7 +871,7 @@ static int pmic_mpp_probe(struct platform_device *pdev)
         if (IS_ERR(state->ctrl))
                 return PTR_ERR(state->ctrl);
 
-        ret = gpiochip_add(&state->chip);
+        ret = gpiochip_add_data(&state->chip, state);
         if (ret) {
                 dev_err(state->dev, "can't add gpio chip\n");
                 goto err_chip;
diff --git a/drivers/pinctrl/qcom/pinctrl-ssbi-gpio.c b/drivers/pinctrl/qcom/pinctrl-ssbi-gpio.c
index e51176ec83d2..cd8580d9741d 100644
--- a/drivers/pinctrl/qcom/pinctrl-ssbi-gpio.c
+++ b/drivers/pinctrl/qcom/pinctrl-ssbi-gpio.c
@@ -444,7 +444,7 @@ static struct pinctrl_desc pm8xxx_pinctrl_desc = {
 static int pm8xxx_gpio_direction_input(struct gpio_chip *chip,
                                        unsigned offset)
 {
-        struct pm8xxx_gpio *pctrl = container_of(chip, struct pm8xxx_gpio, chip);
+        struct pm8xxx_gpio *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
         u8 val;
 
@@ -460,7 +460,7 @@ static int pm8xxx_gpio_direction_output(struct gpio_chip *chip,
                                         unsigned offset,
                                         int value)
 {
-        struct pm8xxx_gpio *pctrl = container_of(chip, struct pm8xxx_gpio, chip);
+        struct pm8xxx_gpio *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
         u8 val;
 
@@ -478,7 +478,7 @@ static int pm8xxx_gpio_direction_output(struct gpio_chip *chip,
 
 static int pm8xxx_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct pm8xxx_gpio *pctrl = container_of(chip, struct pm8xxx_gpio, chip);
+        struct pm8xxx_gpio *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
         bool state;
         int ret;
@@ -496,7 +496,7 @@ static int pm8xxx_gpio_get(struct gpio_chip *chip, unsigned offset)
 
 static void pm8xxx_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct pm8xxx_gpio *pctrl = container_of(chip, struct pm8xxx_gpio, chip);
+        struct pm8xxx_gpio *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
         u8 val;
 
@@ -525,7 +525,7 @@ static int pm8xxx_gpio_of_xlate(struct gpio_chip *chip,
 
 static int pm8xxx_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct pm8xxx_gpio *pctrl = container_of(chip, struct pm8xxx_gpio, chip);
+        struct pm8xxx_gpio *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
 
         return pin->irq;
@@ -540,7 +540,7 @@ static void pm8xxx_gpio_dbg_show_one(struct seq_file *s,
                                   unsigned offset,
                                   unsigned gpio)
 {
-        struct pm8xxx_gpio *pctrl = container_of(chip, struct pm8xxx_gpio, chip);
+        struct pm8xxx_gpio *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
 
         static const char * const modes[] = {
@@ -737,12 +737,12 @@ static int pm8xxx_gpio_probe(struct platform_device *pdev)
 
         pctrl->chip = pm8xxx_gpio_template;
         pctrl->chip.base = -1;
-        pctrl->chip.dev = &pdev->dev;
+        pctrl->chip.parent = &pdev->dev;
         pctrl->chip.of_node = pdev->dev.of_node;
         pctrl->chip.of_gpio_n_cells = 2;
         pctrl->chip.label = dev_name(pctrl->dev);
         pctrl->chip.ngpio = pctrl->npins;
-        ret = gpiochip_add(&pctrl->chip);
+        ret = gpiochip_add_data(&pctrl->chip, pctrl);
         if (ret) {
                 dev_err(&pdev->dev, "failed register gpiochip\n");
                 goto unregister_pinctrl;
diff --git a/drivers/pinctrl/qcom/pinctrl-ssbi-mpp.c b/drivers/pinctrl/qcom/pinctrl-ssbi-mpp.c
index e9f01de51e18..54a5402a9079 100644
--- a/drivers/pinctrl/qcom/pinctrl-ssbi-mpp.c
+++ b/drivers/pinctrl/qcom/pinctrl-ssbi-mpp.c
@@ -449,7 +449,7 @@ static struct pinctrl_desc pm8xxx_pinctrl_desc = {
 static int pm8xxx_mpp_direction_input(struct gpio_chip *chip,
                                        unsigned offset)
 {
-        struct pm8xxx_mpp *pctrl = container_of(chip, struct pm8xxx_mpp, chip);
+        struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
 
         switch (pin->mode) {
@@ -473,7 +473,7 @@ static int pm8xxx_mpp_direction_output(struct gpio_chip *chip,
                                         unsigned offset,
                                         int value)
 {
-        struct pm8xxx_mpp *pctrl = container_of(chip, struct pm8xxx_mpp, chip);
+        struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
 
         switch (pin->mode) {
@@ -497,13 +497,13 @@ static int pm8xxx_mpp_direction_output(struct gpio_chip *chip,
 
 static int pm8xxx_mpp_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct pm8xxx_mpp *pctrl = container_of(chip, struct pm8xxx_mpp, chip);
+        struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
         bool state;
         int ret;
 
         if (!pin->input)
-                return pin->output_value;
+                return !!pin->output_value;
 
         ret = irq_get_irqchip_state(pin->irq, IRQCHIP_STATE_LINE_LEVEL, &state);
         if (!ret)
@@ -514,7 +514,7 @@ static int pm8xxx_mpp_get(struct gpio_chip *chip, unsigned offset)
 
 static void pm8xxx_mpp_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct pm8xxx_mpp *pctrl = container_of(chip, struct pm8xxx_mpp, chip);
+        struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
 
         pin->output_value = !!value;
@@ -538,7 +538,7 @@ static int pm8xxx_mpp_of_xlate(struct gpio_chip *chip,
 
 static int pm8xxx_mpp_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct pm8xxx_mpp *pctrl = container_of(chip, struct pm8xxx_mpp, chip);
+        struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
 
         return pin->irq;
@@ -553,7 +553,7 @@ static void pm8xxx_mpp_dbg_show_one(struct seq_file *s,
                                   unsigned offset,
                                   unsigned gpio)
 {
-        struct pm8xxx_mpp *pctrl = container_of(chip, struct pm8xxx_mpp, chip);
+        struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
 
         static const char * const aout_lvls[] = {
@@ -828,12 +828,12 @@ static int pm8xxx_mpp_probe(struct platform_device *pdev)
 
         pctrl->chip = pm8xxx_mpp_template;
         pctrl->chip.base = -1;
-        pctrl->chip.dev = &pdev->dev;
+        pctrl->chip.parent = &pdev->dev;
         pctrl->chip.of_node = pdev->dev.of_node;
         pctrl->chip.of_gpio_n_cells = 2;
         pctrl->chip.label = dev_name(pctrl->dev);
         pctrl->chip.ngpio = pctrl->npins;
-        ret = gpiochip_add(&pctrl->chip);
+        ret = gpiochip_add_data(&pctrl->chip, pctrl);
         if (ret) {
                 dev_err(&pdev->dev, "failed register gpiochip\n");
                 goto unregister_pinctrl;
diff --git a/drivers/pinctrl/samsung/pinctrl-exynos.c b/drivers/pinctrl/samsung/pinctrl-exynos.c
index 16e2293cc2bc..051b5bf701a8 100644
--- a/drivers/pinctrl/samsung/pinctrl-exynos.c
+++ b/drivers/pinctrl/samsung/pinctrl-exynos.c
@@ -176,7 +176,8 @@ static int exynos_irq_request_resources(struct irq_data *irqd)
 
         ret = gpiochip_lock_as_irq(&bank->gpio_chip, irqd->hwirq);
         if (ret) {
-                dev_err(bank->gpio_chip.dev, "unable to lock pin %s-%lu IRQ\n",
+                dev_err(bank->gpio_chip.parent,
+                        "unable to lock pin %s-%lu IRQ\n",
                         bank->name, irqd->hwirq);
                 return ret;
         }
diff --git a/drivers/pinctrl/samsung/pinctrl-exynos5440.c b/drivers/pinctrl/samsung/pinctrl-exynos5440.c
index 82dc109f7ed4..00ab63abf1d9 100644
--- a/drivers/pinctrl/samsung/pinctrl-exynos5440.c
+++ b/drivers/pinctrl/samsung/pinctrl-exynos5440.c
@@ -15,7 +15,7 @@
 #include <linux/io.h>
 #include <linux/slab.h>
 #include <linux/err.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/device.h>
 #include <linux/pinctrl/pinctrl.h>
 #include <linux/pinctrl/pinmux.h>
@@ -539,7 +539,7 @@ static const struct pinconf_ops exynos5440_pinconf_ops = {
 /* gpiolib gpio_set callback function */
 static void exynos5440_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct exynos5440_pinctrl_priv_data *priv = dev_get_drvdata(gc->dev);
+        struct exynos5440_pinctrl_priv_data *priv = gpiochip_get_data(gc);
         void __iomem *base = priv->reg_base;
         u32 data;
 
@@ -553,7 +553,7 @@ static void exynos5440_gpio_set(struct gpio_chip *gc, unsigned offset, int value
 /* gpiolib gpio_get callback function */
 static int exynos5440_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct exynos5440_pinctrl_priv_data *priv = dev_get_drvdata(gc->dev);
+        struct exynos5440_pinctrl_priv_data *priv = gpiochip_get_data(gc);
         void __iomem *base = priv->reg_base;
         u32 data;
 
@@ -566,7 +566,7 @@ static int exynos5440_gpio_get(struct gpio_chip *gc, unsigned offset)
 /* gpiolib gpio_direction_input callback function */
 static int exynos5440_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct exynos5440_pinctrl_priv_data *priv = dev_get_drvdata(gc->dev);
+        struct exynos5440_pinctrl_priv_data *priv = gpiochip_get_data(gc);
         void __iomem *base = priv->reg_base;
         u32 data;
 
@@ -586,7 +586,7 @@ static int exynos5440_gpio_direction_input(struct gpio_chip *gc, unsigned offset
 static int exynos5440_gpio_direction_output(struct gpio_chip *gc, unsigned offset,
                                                         int value)
 {
-        struct exynos5440_pinctrl_priv_data *priv = dev_get_drvdata(gc->dev);
+        struct exynos5440_pinctrl_priv_data *priv = gpiochip_get_data(gc);
         void __iomem *base = priv->reg_base;
         u32 data;
 
@@ -607,7 +607,7 @@ static int exynos5440_gpio_direction_output(struct gpio_chip *gc, unsigned offse
 /* gpiolib gpio_to_irq callback function */
 static int exynos5440_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct exynos5440_pinctrl_priv_data *priv = dev_get_drvdata(gc->dev);
+        struct exynos5440_pinctrl_priv_data *priv = gpiochip_get_data(gc);
         unsigned int virq;
 
         if (offset < 16 || offset > 23)
@@ -817,7 +817,7 @@ static int exynos5440_gpiolib_register(struct platform_device *pdev,
         priv->gc = gc;
         gc->base = 0;
         gc->ngpio = EXYNOS5440_MAX_PINS;
-        gc->dev = &pdev->dev;
+        gc->parent = &pdev->dev;
         gc->set = exynos5440_gpio_set;
         gc->get = exynos5440_gpio_get;
         gc->direction_input = exynos5440_gpio_direction_input;
@@ -825,7 +825,7 @@ static int exynos5440_gpiolib_register(struct platform_device *pdev,
         gc->to_irq = exynos5440_gpio_to_irq;
         gc->label = "gpiolib-exynos5440";
         gc->owner = THIS_MODULE;
-        ret = gpiochip_add(gc);
+        ret = gpiochip_add_data(gc, priv);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register gpio_chip %s, error "
                                         "code: %d\n", gc->label, ret);
diff --git a/drivers/pinctrl/samsung/pinctrl-samsung.c b/drivers/pinctrl/samsung/pinctrl-samsung.c
index 48294e7449a4..f67b1e958589 100644
--- a/drivers/pinctrl/samsung/pinctrl-samsung.c
+++ b/drivers/pinctrl/samsung/pinctrl-samsung.c
@@ -50,11 +50,6 @@ static LIST_HEAD(drvdata_list);
 
 static unsigned int pin_base;
 
-static inline struct samsung_pin_bank *gc_to_pin_bank(struct gpio_chip *gc)
-{
-        return container_of(gc, struct samsung_pin_bank, gpio_chip);
-}
-
 static int samsung_get_group_count(struct pinctrl_dev *pctldev)
 {
         struct samsung_pinctrl_drv_data *pmx = pinctrl_dev_get_drvdata(pctldev);
@@ -522,7 +517,7 @@ static const struct pinconf_ops samsung_pinconf_ops = {
 /* gpiolib gpio_set callback function */
 static void samsung_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 {
-        struct samsung_pin_bank *bank = gc_to_pin_bank(gc);
+        struct samsung_pin_bank *bank = gpiochip_get_data(gc);
         const struct samsung_pin_bank_type *type = bank->type;
         unsigned long flags;
         void __iomem *reg;
@@ -546,7 +541,7 @@ static int samsung_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
         void __iomem *reg;
         u32 data;
-        struct samsung_pin_bank *bank = gc_to_pin_bank(gc);
+        struct samsung_pin_bank *bank = gpiochip_get_data(gc);
         const struct samsung_pin_bank_type *type = bank->type;
 
         reg = bank->drvdata->virt_base + bank->pctl_offset;
@@ -571,7 +566,7 @@ static int samsung_gpio_set_direction(struct gpio_chip *gc,
         u32 data, mask, shift;
         unsigned long flags;
 
-        bank = gc_to_pin_bank(gc);
+        bank = gpiochip_get_data(gc);
         type = bank->type;
         drvdata = bank->drvdata;
 
@@ -619,7 +614,7 @@ static int samsung_gpio_direction_output(struct gpio_chip *gc, unsigned offset,
  */
 static int samsung_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 {
-        struct samsung_pin_bank *bank = gc_to_pin_bank(gc);
+        struct samsung_pin_bank *bank = gpiochip_get_data(gc);
         unsigned int virq;
 
         if (!bank->irq_domain)
@@ -914,11 +909,11 @@ static int samsung_gpiolib_register(struct platform_device *pdev,
                 gc = &bank->gpio_chip;
                 gc->base = drvdata->pin_base + bank->pin_base;
                 gc->ngpio = bank->nr_pins;
-                gc->dev = &pdev->dev;
+                gc->parent = &pdev->dev;
                 gc->of_node = bank->of_node;
                 gc->label = bank->name;
 
-                ret = gpiochip_add(gc);
+                ret = gpiochip_add_data(gc, bank);
                 if (ret) {
                         dev_err(&pdev->dev, "failed to register gpio_chip %s, error code: %d\n",
                                                         gc->label, ret);
diff --git a/drivers/pinctrl/sh-pfc/gpio.c b/drivers/pinctrl/sh-pfc/gpio.c
index db3f09aa8993..a6681b8b17c3 100644
--- a/drivers/pinctrl/sh-pfc/gpio.c
+++ b/drivers/pinctrl/sh-pfc/gpio.c
@@ -38,14 +38,10 @@ struct sh_pfc_chip {
         struct sh_pfc_gpio_pin          *pins;
 };
 
-static struct sh_pfc_chip *gpio_to_pfc_chip(struct gpio_chip *gc)
-{
-        return container_of(gc, struct sh_pfc_chip, gpio_chip);
-}
-
 static struct sh_pfc *gpio_to_pfc(struct gpio_chip *gc)
 {
-        return gpio_to_pfc_chip(gc)->pfc;
+        struct sh_pfc_chip *chip = gpiochip_get_data(gc);
+        return chip->pfc;
 }
 
 static void gpio_get_data_reg(struct sh_pfc_chip *chip, unsigned int offset,
@@ -178,14 +174,14 @@ static int gpio_pin_direction_input(struct gpio_chip *gc, unsigned offset)
 static int gpio_pin_direction_output(struct gpio_chip *gc, unsigned offset,
                                     int value)
 {
-        gpio_pin_set_value(gpio_to_pfc_chip(gc), offset, value);
+        gpio_pin_set_value(gpiochip_get_data(gc), offset, value);
 
         return pinctrl_gpio_direction_output(offset);
 }
 
 static int gpio_pin_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct sh_pfc_chip *chip = gpio_to_pfc_chip(gc);
+        struct sh_pfc_chip *chip = gpiochip_get_data(gc);
         struct sh_pfc_gpio_data_reg *reg;
         unsigned int bit;
         unsigned int pos;
@@ -199,7 +195,7 @@ static int gpio_pin_get(struct gpio_chip *gc, unsigned offset)
 
 static void gpio_pin_set(struct gpio_chip *gc, unsigned offset, int value)
 {
-        gpio_pin_set_value(gpio_to_pfc_chip(gc), offset, value);
+        gpio_pin_set_value(gpiochip_get_data(gc), offset, value);
 }
 
 static int gpio_pin_to_irq(struct gpio_chip *gc, unsigned offset)
@@ -246,7 +242,7 @@ static int gpio_pin_setup(struct sh_pfc_chip *chip)
         gc->to_irq = gpio_pin_to_irq;
 
         gc->label = pfc->info->name;
-        gc->dev = pfc->dev;
+        gc->parent = pfc->dev;
         gc->owner = THIS_MODULE;
         gc->base = 0;
         gc->ngpio = pfc->nr_gpio_pins;
@@ -322,7 +318,7 @@ sh_pfc_add_gpiochip(struct sh_pfc *pfc, int(*setup)(struct sh_pfc_chip *),
         if (ret < 0)
                 return ERR_PTR(ret);
 
-        ret = gpiochip_add(&chip->gpio_chip);
+        ret = gpiochip_add_data(&chip->gpio_chip, chip);
         if (unlikely(ret < 0))
                 return ERR_PTR(ret);
 
diff --git a/drivers/pinctrl/sirf/pinctrl-atlas7.c b/drivers/pinctrl/sirf/pinctrl-atlas7.c
index 053d98e33944..beb024c31a5d 100644
--- a/drivers/pinctrl/sirf/pinctrl-atlas7.c
+++ b/drivers/pinctrl/sirf/pinctrl-atlas7.c
@@ -358,11 +358,6 @@ struct atlas7_gpio_chip {
         struct atlas7_gpio_bank banks[0];
 };
 
-static inline struct atlas7_gpio_chip *to_atlas7_gpio(struct gpio_chip *gc)
-{
-        return container_of(gc, struct atlas7_gpio_chip, chip);
-}
-
 /**
  * @dev: a pointer back to containing device
  * @virtbase: the offset to the controller in virtual memory
@@ -5642,7 +5637,7 @@ static int __atlas7_gpio_to_pin(struct atlas7_gpio_chip *a7gc, u32 gpio)
 static void atlas7_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(gc);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(gc);
         struct atlas7_gpio_bank *bank;
         void __iomem *ctrl_reg;
         u32 val, pin_in_bank;
@@ -5680,7 +5675,7 @@ static void __atlas7_gpio_irq_mask(struct atlas7_gpio_chip *a7gc, int idx)
 static void atlas7_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(gc);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(gc);
         unsigned long flags;
 
         spin_lock_irqsave(&a7gc->lock, flags);
@@ -5693,7 +5688,7 @@ static void atlas7_gpio_irq_mask(struct irq_data *d)
 static void atlas7_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(gc);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(gc);
         struct atlas7_gpio_bank *bank;
         void __iomem *ctrl_reg;
         u32 val, pin_in_bank;
@@ -5717,7 +5712,7 @@ static int atlas7_gpio_irq_type(struct irq_data *d,
                                 unsigned int type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(gc);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(gc);
         struct atlas7_gpio_bank *bank;
         void __iomem *ctrl_reg;
         u32 val, pin_in_bank;
@@ -5786,7 +5781,7 @@ static struct irq_chip atlas7_gpio_irq_chip = {
 static void atlas7_gpio_handle_irq(struct irq_desc *desc)
 {
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(gc);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(gc);
         struct atlas7_gpio_bank *bank = NULL;
         u32 status, ctrl;
         int pin_in_bank = 0, idx;
@@ -5854,7 +5849,7 @@ static void __atlas7_gpio_set_input(struct atlas7_gpio_chip *a7gc,
 static int atlas7_gpio_request(struct gpio_chip *chip,
                                 unsigned int gpio)
 {
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(chip);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(chip);
         int ret;
         unsigned long flags;
 
@@ -5882,7 +5877,7 @@ static int atlas7_gpio_request(struct gpio_chip *chip,
 static void atlas7_gpio_free(struct gpio_chip *chip,
                                 unsigned int gpio)
 {
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(chip);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&a7gc->lock, flags);
@@ -5898,7 +5893,7 @@ static void atlas7_gpio_free(struct gpio_chip *chip,
 static int atlas7_gpio_direction_input(struct gpio_chip *chip,
                                         unsigned int gpio)
 {
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(chip);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&a7gc->lock, flags);
@@ -5935,7 +5930,7 @@ static void __atlas7_gpio_set_output(struct atlas7_gpio_chip *a7gc,
 static int atlas7_gpio_direction_output(struct gpio_chip *chip,
                                 unsigned int gpio, int value)
 {
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(chip);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(chip);
         unsigned long flags;
 
         spin_lock_irqsave(&a7gc->lock, flags);
@@ -5950,7 +5945,7 @@ static int atlas7_gpio_direction_output(struct gpio_chip *chip,
 static int atlas7_gpio_get_value(struct gpio_chip *chip,
                                         unsigned int gpio)
 {
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(chip);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(chip);
         struct atlas7_gpio_bank *bank;
         u32 val, pin_in_bank;
         unsigned long flags;
@@ -5970,7 +5965,7 @@ static int atlas7_gpio_get_value(struct gpio_chip *chip,
 static void atlas7_gpio_set_value(struct gpio_chip *chip,
                                 unsigned int gpio, int value)
 {
-        struct atlas7_gpio_chip *a7gc = to_atlas7_gpio(chip);
+        struct atlas7_gpio_chip *a7gc = gpiochip_get_data(chip);
         struct atlas7_gpio_bank *bank;
         void __iomem *ctrl_reg;
         u32 ctrl, pin_in_bank;
@@ -6054,10 +6049,10 @@ static int atlas7_gpio_probe(struct platform_device *pdev)
         chip->label = kstrdup(np->name, GFP_KERNEL);
         chip->of_node = np;
         chip->of_gpio_n_cells = 2;
-        chip->dev = &pdev->dev;
+        chip->parent = &pdev->dev;
 
         /* Add gpio chip to system */
-        ret = gpiochip_add(chip);
+        ret = gpiochip_add_data(chip, a7gc);
         if (ret) {
                 dev_err(&pdev->dev,
                 "%s: error in probe function with status %d\n",
diff --git a/drivers/pinctrl/sirf/pinctrl-sirf.c b/drivers/pinctrl/sirf/pinctrl-sirf.c
index edf40df05ec0..762c0c9c1278 100644
--- a/drivers/pinctrl/sirf/pinctrl-sirf.c
+++ b/drivers/pinctrl/sirf/pinctrl-sirf.c
@@ -403,11 +403,6 @@ static int __init sirfsoc_pinmux_init(void)
 }
 arch_initcall(sirfsoc_pinmux_init);
 
-static inline struct sirfsoc_gpio_chip *to_sirfsoc_gpio(struct gpio_chip *gc)
-{
-        return container_of(gc, struct sirfsoc_gpio_chip, chip.gc);
-}
-
 static inline struct sirfsoc_gpio_bank *
 sirfsoc_gpio_to_bank(struct sirfsoc_gpio_chip *sgpio, unsigned int offset)
 {
@@ -422,7 +417,7 @@ static inline int sirfsoc_gpio_to_bankoff(unsigned int offset)
 static void sirfsoc_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(gc);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(gc);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, d->hwirq);
         int idx = sirfsoc_gpio_to_bankoff(d->hwirq);
         u32 val, offset;
@@ -461,7 +456,7 @@ static void __sirfsoc_gpio_irq_mask(struct sirfsoc_gpio_chip *sgpio,
 static void sirfsoc_gpio_irq_mask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(gc);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(gc);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, d->hwirq);
 
         __sirfsoc_gpio_irq_mask(sgpio, bank, d->hwirq % SIRFSOC_GPIO_BANK_SIZE);
@@ -470,7 +465,7 @@ static void sirfsoc_gpio_irq_mask(struct irq_data *d)
 static void sirfsoc_gpio_irq_unmask(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(gc);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(gc);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, d->hwirq);
         int idx = sirfsoc_gpio_to_bankoff(d->hwirq);
         u32 val, offset;
@@ -491,7 +486,7 @@ static void sirfsoc_gpio_irq_unmask(struct irq_data *d)
 static int sirfsoc_gpio_irq_type(struct irq_data *d, unsigned type)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(gc);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(gc);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, d->hwirq);
         int idx = sirfsoc_gpio_to_bankoff(d->hwirq);
         u32 val, offset;
@@ -553,7 +548,7 @@ static void sirfsoc_gpio_handle_irq(struct irq_desc *desc)
 {
         unsigned int irq = irq_desc_get_irq(desc);
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(gc);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(gc);
         struct sirfsoc_gpio_bank *bank;
         u32 status, ctrl;
         int idx = 0;
@@ -611,7 +606,7 @@ static inline void sirfsoc_gpio_set_input(struct sirfsoc_gpio_chip *sgpio,
 
 static int sirfsoc_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(chip);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(chip);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, offset);
         unsigned long flags;
 
@@ -634,7 +629,7 @@ static int sirfsoc_gpio_request(struct gpio_chip *chip, unsigned offset)
 
 static void sirfsoc_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(chip);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(chip);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, offset);
         unsigned long flags;
 
@@ -650,7 +645,7 @@ static void sirfsoc_gpio_free(struct gpio_chip *chip, unsigned offset)
 
 static int sirfsoc_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 {
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(chip);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(chip);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, gpio);
         int idx = sirfsoc_gpio_to_bankoff(gpio);
         unsigned long flags;
@@ -693,7 +688,7 @@ static inline void sirfsoc_gpio_set_output(struct sirfsoc_gpio_chip *sgpio,
 static int sirfsoc_gpio_direction_output(struct gpio_chip *chip,
         unsigned gpio, int value)
 {
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(chip);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(chip);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, gpio);
         int idx = sirfsoc_gpio_to_bankoff(gpio);
         u32 offset;
@@ -712,7 +707,7 @@ static int sirfsoc_gpio_direction_output(struct gpio_chip *chip,
 
 static int sirfsoc_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 {
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(chip);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(chip);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, offset);
         u32 val;
         unsigned long flags;
@@ -729,7 +724,7 @@ static int sirfsoc_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 static void sirfsoc_gpio_set_value(struct gpio_chip *chip, unsigned offset,
         int value)
 {
-        struct sirfsoc_gpio_chip *sgpio = to_sirfsoc_gpio(chip);
+        struct sirfsoc_gpio_chip *sgpio = gpiochip_get_data(chip);
         struct sirfsoc_gpio_bank *bank = sirfsoc_gpio_to_bank(sgpio, offset);
         u32 ctrl;
         unsigned long flags;
@@ -815,10 +810,10 @@ static int sirfsoc_gpio_probe(struct device_node *np)
         sgpio->chip.gc.of_node = np;
         sgpio->chip.gc.of_xlate = sirfsoc_gpio_of_xlate;
         sgpio->chip.gc.of_gpio_n_cells = 2;
-        sgpio->chip.gc.dev = &pdev->dev;
+        sgpio->chip.gc.parent = &pdev->dev;
         sgpio->chip.regs = regs;
 
-        err = gpiochip_add(&sgpio->chip.gc);
+        err = gpiochip_add_data(&sgpio->chip.gc, sgpio);
         if (err) {
                 dev_err(&pdev->dev, "%s: error in probe function with status %d\n",
                         np->full_name, err);
diff --git a/drivers/pinctrl/spear/pinctrl-plgpio.c b/drivers/pinctrl/spear/pinctrl-plgpio.c
index 1f0af250dbb5..4c9b863f8267 100644
--- a/drivers/pinctrl/spear/pinctrl-plgpio.c
+++ b/drivers/pinctrl/spear/pinctrl-plgpio.c
@@ -107,7 +107,7 @@ static inline void plgpio_reg_reset(void __iomem *base, u32 pin, u32 reg)
 /* gpio framework specific routines */
 static int plgpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct plgpio *plgpio = container_of(chip, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(chip);
         unsigned long flags;
 
         /* get correct offset for "offset" pin */
@@ -127,7 +127,7 @@ static int plgpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int plgpio_direction_output(struct gpio_chip *chip, unsigned offset,
                 int value)
 {
-        struct plgpio *plgpio = container_of(chip, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(chip);
         unsigned long flags;
         unsigned dir_offset = offset, wdata_offset = offset, tmp;
 
@@ -159,7 +159,7 @@ static int plgpio_direction_output(struct gpio_chip *chip, unsigned offset,
 
 static int plgpio_get_value(struct gpio_chip *chip, unsigned offset)
 {
-        struct plgpio *plgpio = container_of(chip, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(chip);
 
         if (offset >= chip->ngpio)
                 return -EINVAL;
@@ -176,7 +176,7 @@ static int plgpio_get_value(struct gpio_chip *chip, unsigned offset)
 
 static void plgpio_set_value(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct plgpio *plgpio = container_of(chip, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(chip);
 
         if (offset >= chip->ngpio)
                 return;
@@ -196,7 +196,7 @@ static void plgpio_set_value(struct gpio_chip *chip, unsigned offset, int value)
 
 static int plgpio_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct plgpio *plgpio = container_of(chip, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(chip);
         int gpio = chip->base + offset;
         unsigned long flags;
         int ret = 0;
@@ -248,7 +248,7 @@ err0:
 
 static void plgpio_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct plgpio *plgpio = container_of(chip, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(chip);
         int gpio = chip->base + offset;
         unsigned long flags;
 
@@ -280,7 +280,7 @@ disable_clk:
 static void plgpio_irq_disable(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct plgpio *plgpio = container_of(gc, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         unsigned long flags;
 
@@ -299,7 +299,7 @@ static void plgpio_irq_disable(struct irq_data *d)
 static void plgpio_irq_enable(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct plgpio *plgpio = container_of(gc, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         unsigned long flags;
 
@@ -318,7 +318,7 @@ static void plgpio_irq_enable(struct irq_data *d)
 static int plgpio_irq_set_type(struct irq_data *d, unsigned trigger)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct plgpio *plgpio = container_of(gc, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(gc);
         int offset = d->hwirq;
         void __iomem *reg_off;
         unsigned int supported_type = 0, val;
@@ -359,7 +359,7 @@ static struct irq_chip plgpio_irqchip = {
 static void plgpio_irq_handler(struct irq_desc *desc)
 {
         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
-        struct plgpio *plgpio = container_of(gc, struct plgpio, chip);
+        struct plgpio *plgpio = gpiochip_get_data(gc);
         struct irq_chip *irqchip = irq_desc_get_chip(desc);
         int regs_count, count, pin, offset, i = 0;
         unsigned long pending;
@@ -561,7 +561,7 @@ static int plgpio_probe(struct platform_device *pdev)
         plgpio->chip.get = plgpio_get_value;
         plgpio->chip.set = plgpio_set_value;
         plgpio->chip.label = dev_name(&pdev->dev);
-        plgpio->chip.dev = &pdev->dev;
+        plgpio->chip.parent = &pdev->dev;
         plgpio->chip.owner = THIS_MODULE;
         plgpio->chip.of_node = pdev->dev.of_node;
 
@@ -573,7 +573,7 @@ static int plgpio_probe(struct platform_device *pdev)
                 }
         }
 
-        ret = gpiochip_add(&plgpio->chip);
+        ret = gpiochip_add_data(&plgpio->chip, plgpio);
         if (ret) {
                 dev_err(&pdev->dev, "unable to add gpio chip\n");
                 goto unprepare_clk;
diff --git a/drivers/pinctrl/sunxi/pinctrl-sunxi.c b/drivers/pinctrl/sunxi/pinctrl-sunxi.c
index dead97daca35..7a2465f5e71e 100644
--- a/drivers/pinctrl/sunxi/pinctrl-sunxi.c
+++ b/drivers/pinctrl/sunxi/pinctrl-sunxi.c
@@ -12,7 +12,7 @@
 
 #include <linux/io.h>
 #include <linux/clk.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/irqdomain.h>
 #include <linux/irqchip/chained_irq.h>
 #include <linux/module.h>
@@ -454,7 +454,7 @@ static int sunxi_pinctrl_gpio_direction_input(struct gpio_chip *chip,
 
 static int sunxi_pinctrl_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct sunxi_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct sunxi_pinctrl *pctl = gpiochip_get_data(chip);
         u32 reg = sunxi_data_reg(offset);
         u8 index = sunxi_data_offset(offset);
         u32 set_mux = pctl->desc->irq_read_needs_mux &&
@@ -469,13 +469,13 @@ static int sunxi_pinctrl_gpio_get(struct gpio_chip *chip, unsigned offset)
         if (set_mux)
                 sunxi_pmx_set(pctl->pctl_dev, offset, SUN4I_FUNC_IRQ);
 
-        return val;
+        return !!val;
 }
 
 static void sunxi_pinctrl_gpio_set(struct gpio_chip *chip,
                                 unsigned offset, int value)
 {
-        struct sunxi_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct sunxi_pinctrl *pctl = gpiochip_get_data(chip);
         u32 reg = sunxi_data_reg(offset);
         u8 index = sunxi_data_offset(offset);
         unsigned long flags;
@@ -522,7 +522,7 @@ static int sunxi_pinctrl_gpio_of_xlate(struct gpio_chip *gc,
 
 static int sunxi_pinctrl_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        struct sunxi_pinctrl *pctl = dev_get_drvdata(chip->dev);
+        struct sunxi_pinctrl *pctl = gpiochip_get_data(chip);
         struct sunxi_desc_function *desc;
         unsigned pinnum = pctl->desc->pin_base + offset;
         unsigned irqnum;
@@ -536,7 +536,7 @@ static int sunxi_pinctrl_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 
         irqnum = desc->irqbank * IRQ_PER_BANK + desc->irqnum;
 
-        dev_dbg(chip->dev, "%s: request IRQ for GPIO %d, return %d\n",
+        dev_dbg(chip->parent, "%s: request IRQ for GPIO %d, return %d\n",
                 chip->label, offset + chip->base, irqnum);
 
         return irq_find_mapping(pctl->domain, irqnum);
@@ -959,10 +959,10 @@ int sunxi_pinctrl_init(struct platform_device *pdev,
         pctl->chip->ngpio = round_up(last_pin, PINS_PER_BANK) -
                             pctl->desc->pin_base;
         pctl->chip->label = dev_name(&pdev->dev);
-        pctl->chip->dev = &pdev->dev;
+        pctl->chip->parent = &pdev->dev;
         pctl->chip->base = pctl->desc->pin_base;
 
-        ret = gpiochip_add(pctl->chip);
+        ret = gpiochip_add_data(pctl->chip, pctl);
         if (ret)
                 goto pinctrl_error;
 
diff --git a/drivers/pinctrl/vt8500/pinctrl-wmt.c b/drivers/pinctrl/vt8500/pinctrl-wmt.c
index fb22d3f62480..5c261bf5542f 100644
--- a/drivers/pinctrl/vt8500/pinctrl-wmt.c
+++ b/drivers/pinctrl/vt8500/pinctrl-wmt.c
@@ -14,7 +14,7 @@
  */
 
 #include <linux/err.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/irq.h>
@@ -488,7 +488,7 @@ static struct pinctrl_desc wmt_desc = {
 
 static int wmt_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 {
-        struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
+        struct wmt_pinctrl_data *data = gpiochip_get_data(chip);
         u32 bank = WMT_BANK_FROM_PIN(offset);
         u32 bit = WMT_BIT_FROM_PIN(offset);
         u32 reg_dir = data->banks[bank].reg_dir;
@@ -503,7 +503,7 @@ static int wmt_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 
 static int wmt_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 {
-        struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
+        struct wmt_pinctrl_data *data = gpiochip_get_data(chip);
         u32 bank = WMT_BANK_FROM_PIN(offset);
         u32 bit = WMT_BIT_FROM_PIN(offset);
         u32 reg_data_in = data->banks[bank].reg_data_in;
@@ -519,7 +519,7 @@ static int wmt_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 static void wmt_gpio_set_value(struct gpio_chip *chip, unsigned offset,
                                int val)
 {
-        struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
+        struct wmt_pinctrl_data *data = gpiochip_get_data(chip);
         u32 bank = WMT_BANK_FROM_PIN(offset);
         u32 bit = WMT_BIT_FROM_PIN(offset);
         u32 reg_data_out = data->banks[bank].reg_data_out;
@@ -575,7 +575,7 @@ int wmt_pinctrl_probe(struct platform_device *pdev,
         wmt_desc.npins = data->npins;
 
         data->gpio_chip = wmt_gpio_chip;
-        data->gpio_chip.dev = &pdev->dev;
+        data->gpio_chip.parent = &pdev->dev;
         data->gpio_chip.of_node = pdev->dev.of_node;
         data->gpio_chip.ngpio = data->nbanks * 32;
 
@@ -589,7 +589,7 @@ int wmt_pinctrl_probe(struct platform_device *pdev,
                 return PTR_ERR(data->pctl_dev);
         }
 
-        err = gpiochip_add(&data->gpio_chip);
+        err = gpiochip_add_data(&data->gpio_chip, data);
         if (err) {
                 dev_err(&pdev->dev, "could not add GPIO chip\n");
                 goto fail_gpio;
diff --git a/drivers/platform/x86/intel_pmic_gpio.c b/drivers/platform/x86/intel_pmic_gpio.c
index 709f0afdafa8..0e73fd10ba72 100644
--- a/drivers/platform/x86/intel_pmic_gpio.c
+++ b/drivers/platform/x86/intel_pmic_gpio.c
@@ -274,11 +274,11 @@ static int platform_pmic_gpio_probe(struct platform_device *pdev)
         pg->chip.base = pdata->gpio_base;
         pg->chip.ngpio = NUM_GPIO;
         pg->chip.can_sleep = 1;
-        pg->chip.dev = dev;
+        pg->chip.parent = dev;
 
         mutex_init(&pg->buslock);
 
-        pg->chip.dev = dev;
+        pg->chip.parent = dev;
         retval = gpiochip_add(&pg->chip);
         if (retval) {
                 pr_err("Can not add pmic gpio chip\n");
diff --git a/drivers/tty/serial/max310x.c b/drivers/tty/serial/max310x.c
index d45133056f51..3f98165b479c 100644
--- a/drivers/tty/serial/max310x.c
+++ b/drivers/tty/serial/max310x.c
@@ -1174,7 +1174,7 @@ static int max310x_probe(struct device *dev, struct max310x_devtype *devtype,
 #ifdef CONFIG_GPIOLIB
         /* Setup GPIO cotroller */
         s->gpio.owner           = THIS_MODULE;
-        s->gpio.dev             = dev;
+        s->gpio.parent          = dev;
         s->gpio.label           = dev_name(dev);
         s->gpio.direction_input = max310x_gpio_direction_input;
         s->gpio.get             = max310x_gpio_get;
diff --git a/drivers/tty/serial/sc16is7xx.c b/drivers/tty/serial/sc16is7xx.c
index 5815bcbc55b2..13f8d5f70272 100644
--- a/drivers/tty/serial/sc16is7xx.c
+++ b/drivers/tty/serial/sc16is7xx.c
@@ -1193,7 +1193,7 @@ static int sc16is7xx_probe(struct device *dev,
         if (devtype->nr_gpio) {
                 /* Setup GPIO cotroller */
                 s->gpio.owner            = THIS_MODULE;
-                s->gpio.dev              = dev;
+                s->gpio.parent           = dev;
                 s->gpio.label            = dev_name(dev);
                 s->gpio.direction_input  = sc16is7xx_gpio_direction_input;
                 s->gpio.get              = sc16is7xx_gpio_get;
diff --git a/drivers/video/fbdev/via/via-gpio.c b/drivers/video/fbdev/via/via-gpio.c
index 6f433b8cee12..1e89c3434071 100644
--- a/drivers/video/fbdev/via/via-gpio.c
+++ b/drivers/video/fbdev/via/via-gpio.c
@@ -6,7 +6,7 @@
  */
 
 #include <linux/spinlock.h>
-#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
 #include <linux/platform_device.h>
 #include <linux/via-core.h>
 #include <linux/via-gpio.h>
@@ -83,9 +83,7 @@ struct viafb_gpio_cfg {
 static void via_gpio_set(struct gpio_chip *chip, unsigned int nr,
                          int value)
 {
-        struct viafb_gpio_cfg *cfg = container_of(chip,
-                                                  struct viafb_gpio_cfg,
-                                                  gpio_chip);
+        struct viafb_gpio_cfg *cfg = gpiochip_get_data(chip);
         u8 reg;
         struct viafb_gpio *gpio;
         unsigned long flags;
@@ -115,9 +113,7 @@ static int via_gpio_dir_out(struct gpio_chip *chip, unsigned int nr,
  */
 static int via_gpio_dir_input(struct gpio_chip *chip, unsigned int nr)
 {
-        struct viafb_gpio_cfg *cfg = container_of(chip,
-                                                  struct viafb_gpio_cfg,
-                                                  gpio_chip);
+        struct viafb_gpio_cfg *cfg = gpiochip_get_data(chip);
         struct viafb_gpio *gpio;
         unsigned long flags;
 
@@ -131,9 +127,7 @@ static int via_gpio_dir_input(struct gpio_chip *chip, unsigned int nr)
 
 static int via_gpio_get(struct gpio_chip *chip, unsigned int nr)
 {
-        struct viafb_gpio_cfg *cfg = container_of(chip,
-                                                  struct viafb_gpio_cfg,
-                                                  gpio_chip);
+        struct viafb_gpio_cfg *cfg = gpiochip_get_data(chip);
         u8 reg;
         struct viafb_gpio *gpio;
         unsigned long flags;
@@ -142,7 +136,7 @@ static int via_gpio_get(struct gpio_chip *chip, unsigned int nr)
         gpio = cfg->active_gpios[nr];
         reg = via_read_reg(VIASR, gpio->vg_port_index);
         spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
-        return reg & (0x04 << gpio->vg_mask_shift);
+        return !!(reg & (0x04 << gpio->vg_mask_shift));
 }
 
 
@@ -255,7 +249,8 @@ static int viafb_gpio_probe(struct platform_device *platdev)
          * Get registered.
          */
         viafb_gpio_config.gpio_chip.base = -1;  /* Dynamic */
-        ret = gpiochip_add(&viafb_gpio_config.gpio_chip);
+        ret = gpiochip_add_data(&viafb_gpio_config.gpio_chip,
+                                &viafb_gpio_config);
         if (ret) {
                 printk(KERN_ERR "viafb: failed to add gpios (%d)\n", ret);
                 viafb_gpio_config.gpio_chip.ngpio = 0;
diff --git a/include/linux/basic_mmio_gpio.h b/include/linux/basic_mmio_gpio.h
deleted file mode 100644
index ed3768f4ecc7..000000000000
--- a/include/linux/basic_mmio_gpio.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Basic memory-mapped GPIO controllers.
- *
- * Copyright 2008 MontaVista Software, Inc.
- * Copyright 2008,2010 Anton Vorontsov <cbouatmailru@gmail.com>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- */
-
-#ifndef __BASIC_MMIO_GPIO_H
-#define __BASIC_MMIO_GPIO_H
-
-#include <linux/gpio.h>
-#include <linux/types.h>
-#include <linux/compiler.h>
-#include <linux/spinlock_types.h>
-
-struct bgpio_pdata {
-        const char *label;
-        int base;
-        int ngpio;
-};
-
-struct device;
-
-struct bgpio_chip {
-        struct gpio_chip gc;
-
-        unsigned long (*read_reg)(void __iomem *reg);
-        void (*write_reg)(void __iomem *reg, unsigned long data);
-
-        void __iomem *reg_dat;
-        void __iomem *reg_set;
-        void __iomem *reg_clr;
-        void __iomem *reg_dir;
-
-        /* Number of bits (GPIOs): <register width> * 8. */
-        int bits;
-
-        /*
-         * Some GPIO controllers work with the big-endian bits notation,
-         * e.g. in a 8-bits register, GPIO7 is the least significant bit.
-         */
-        unsigned long (*pin2mask)(struct bgpio_chip *bgc, unsigned int pin);
-
-        /*
-         * Used to lock bgpio_chip->data. Also, this is needed to keep
-         * shadowed and real data registers writes together.
-         */
-        spinlock_t lock;
-
-        /* Shadowed data register to clear/set bits safely. */
-        unsigned long data;
-
-        /* Shadowed direction registers to clear/set direction safely. */
-        unsigned long dir;
-};
-
-static inline struct bgpio_chip *to_bgpio_chip(struct gpio_chip *gc)
-{
-        return container_of(gc, struct bgpio_chip, gc);
-}
-
-int bgpio_remove(struct bgpio_chip *bgc);
-int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
-               unsigned long sz, void __iomem *dat, void __iomem *set,
-               void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
-               unsigned long flags);
-
-#define BGPIOF_BIG_ENDIAN               BIT(0)
-#define BGPIOF_UNREADABLE_REG_SET       BIT(1) /* reg_set is unreadable */
-#define BGPIOF_UNREADABLE_REG_DIR       BIT(2) /* reg_dir is unreadable */
-#define BGPIOF_BIG_ENDIAN_BYTE_ORDER    BIT(3)
-#define BGPIOF_READ_OUTPUT_REG_SET     BIT(4) /* reg_set stores output value */
-#define BGPIOF_NO_OUTPUT                BIT(5) /* only input */
-
-#endif /* __BASIC_MMIO_GPIO_H */
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index d1baebf350d8..82fda487453f 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -8,6 +8,7 @@
 #include <linux/irqdomain.h>
 #include <linux/lockdep.h>
 #include <linux/pinctrl/pinctrl.h>
+#include <linux/kconfig.h>
 
 struct device;
 struct gpio_desc;
@@ -20,9 +21,10 @@ struct seq_file;
 /**
  * struct gpio_chip - abstract a GPIO controller
  * @label: for diagnostics
- * @dev: optional device providing the GPIOs
+ * @parent: optional parent device providing the GPIOs
  * @cdev: class device used by sysfs interface (may be NULL)
  * @owner: helps prevent removal of modules exporting active GPIOs
+ * @data: per-instance data assigned by the driver
  * @list: links gpio_chips together for traversal
  * @request: optional hook for chip-specific activation, such as
  *      enabling module power and clock; may sleep
@@ -32,8 +34,7 @@ struct seq_file;
  *      (same as GPIOF_DIR_XXX), or negative error
  * @direction_input: configures signal "offset" as input, or returns error
  * @direction_output: configures signal "offset" as output, or returns error
- * @get: returns value for signal "offset"; for output signals this
- *      returns either the value actually sensed, or zero
+ * @get: returns value for signal "offset", 0=low, 1=high, or negative error
  * @set: assigns output value for signal "offset"
  * @set_multiple: assigns output values for multiple signals defined by "mask"
  * @set_debounce: optional hook for setting debounce time for specified gpio in
@@ -65,6 +66,23 @@ struct seq_file;
  *      registers.
  * @irq_not_threaded: flag must be set if @can_sleep is set but the
  *      IRQs don't need to be threaded
+ * @read_reg: reader function for generic GPIO
+ * @write_reg: writer function for generic GPIO
+ * @pin2mask: some generic GPIO controllers work with the big-endian bits
+ *      notation, e.g. in a 8-bits register, GPIO7 is the least significant
+ *      bit. This callback assigns the right bit mask.
+ * @reg_dat: data (in) register for generic GPIO
+ * @reg_set: output set register (out=high) for generic GPIO
+ * @reg_clk: output clear register (out=low) for generic GPIO
+ * @reg_dir: direction setting register for generic GPIO
+ * @bgpio_bits: number of register bits used for a generic GPIO i.e.
+ *      <register width> * 8
+ * @bgpio_lock: used to lock chip->bgpio_data. Also, this is needed to keep
+ *      shadowed and real data registers writes together.
+ * @bgpio_data: shadowed data register for generic GPIO to clear/set bits
+ *      safely.
+ * @bgpio_dir: shadowed direction register for generic GPIO to clear/set
+ *      direction safely.
  * @irqchip: GPIO IRQ chip impl, provided by GPIO driver
  * @irqdomain: Interrupt translation domain; responsible for mapping
  *      between GPIO hwirq number and linux irq number
@@ -89,9 +107,10 @@ struct seq_file;
  */
 struct gpio_chip {
         const char              *label;
-        struct device           *dev;
+        struct device           *parent;
         struct device           *cdev;
         struct module           *owner;
+        void                    *data;
         struct list_head        list;
 
         int                     (*request)(struct gpio_chip *chip,
@@ -127,6 +146,20 @@ struct gpio_chip {
         bool                    can_sleep;
         bool                    irq_not_threaded;
 
+#if IS_ENABLED(CONFIG_GPIO_GENERIC)
+        unsigned long (*read_reg)(void __iomem *reg);
+        void (*write_reg)(void __iomem *reg, unsigned long data);
+        unsigned long (*pin2mask)(struct gpio_chip *gc, unsigned int pin);
+        void __iomem *reg_dat;
+        void __iomem *reg_set;
+        void __iomem *reg_clr;
+        void __iomem *reg_dir;
+        int bgpio_bits;
+        spinlock_t bgpio_lock;
+        unsigned long bgpio_data;
+        unsigned long bgpio_dir;
+#endif
+
 #ifdef CONFIG_GPIOLIB_IRQCHIP
         /*
          * With CONFIG_GPIOLIB_IRQCHIP we get an irqchip inside the gpiolib
@@ -166,7 +199,11 @@ extern const char *gpiochip_is_requested(struct gpio_chip *chip,
                         unsigned offset);
 
 /* add/remove chips */
-extern int gpiochip_add(struct gpio_chip *chip);
+extern int gpiochip_add_data(struct gpio_chip *chip, void *data);
+static inline int gpiochip_add(struct gpio_chip *chip)
+{
+        return gpiochip_add_data(chip, NULL);
+}
 extern void gpiochip_remove(struct gpio_chip *chip);
 extern struct gpio_chip *gpiochip_find(void *data,
                               int (*match)(struct gpio_chip *chip, void *data));
@@ -175,8 +212,36 @@ extern struct gpio_chip *gpiochip_find(void *data,
 int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset);
 void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset);
 
+/* get driver data */
+static inline void *gpiochip_get_data(struct gpio_chip *chip)
+{
+        return chip->data;
+}
+
 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc);
 
+struct bgpio_pdata {
+        const char *label;
+        int base;
+        int ngpio;
+};
+
+#if IS_ENABLED(CONFIG_GPIO_GENERIC)
+
+int bgpio_init(struct gpio_chip *gc, struct device *dev,
+               unsigned long sz, void __iomem *dat, void __iomem *set,
+               void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
+               unsigned long flags);
+
+#define BGPIOF_BIG_ENDIAN               BIT(0)
+#define BGPIOF_UNREADABLE_REG_SET       BIT(1) /* reg_set is unreadable */
+#define BGPIOF_UNREADABLE_REG_DIR       BIT(2) /* reg_dir is unreadable */
+#define BGPIOF_BIG_ENDIAN_BYTE_ORDER    BIT(3)
+#define BGPIOF_READ_OUTPUT_REG_SET      BIT(4) /* reg_set stores output value */
+#define BGPIOF_NO_OUTPUT                BIT(5) /* only input */
+
+#endif
+
 #ifdef CONFIG_GPIOLIB_IRQCHIP
 
 void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h
index 87d6d1632dd4..092186c62ff4 100644
--- a/include/linux/of_gpio.h
+++ b/include/linux/of_gpio.h
@@ -51,8 +51,14 @@ static inline struct of_mm_gpio_chip *to_of_mm_gpio_chip(struct gpio_chip *gc)
 extern int of_get_named_gpio_flags(struct device_node *np,
                 const char *list_name, int index, enum of_gpio_flags *flags);
 
-extern int of_mm_gpiochip_add(struct device_node *np,
-                              struct of_mm_gpio_chip *mm_gc);
+extern int of_mm_gpiochip_add_data(struct device_node *np,
+                                   struct of_mm_gpio_chip *mm_gc,
+                                   void *data);
+static inline int of_mm_gpiochip_add(struct device_node *np,
+                                     struct of_mm_gpio_chip *mm_gc)
+{
+        return of_mm_gpiochip_add_data(np, mm_gc, NULL);
+}
 extern void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc);
 
 extern int of_gpiochip_add(struct gpio_chip *gc);
@@ -67,6 +73,9 @@ extern int of_gpio_simple_xlate(struct gpio_chip *gc,
 static inline int of_get_named_gpio_flags(struct device_node *np,
                 const char *list_name, int index, enum of_gpio_flags *flags)
 {
+        if (flags)
+                *flags = 0;
+
         return -ENOSYS;
 }
 
diff --git a/include/linux/platform_data/gpio-rcar.h b/include/linux/platform_data/gpio-rcar.h
deleted file mode 100644
index 2d8d69432813..000000000000
--- a/include/linux/platform_data/gpio-rcar.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Renesas R-Car GPIO Support
- *
- *  Copyright (C) 2013 Magnus Damm
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#ifndef __GPIO_RCAR_H__
-#define __GPIO_RCAR_H__
-
-struct gpio_rcar_config {
-        int gpio_base;
-        unsigned int irq_base;
-        unsigned int number_of_pins;
-        const char *pctl_name;
-        unsigned has_both_edge_trigger:1;
-};
-
-#define RCAR_GP_PIN(bank, pin)          (((bank) * 32) + (pin))
-
-#endif /* __GPIO_RCAR_H__ */
diff --git a/sound/soc/codecs/rt5677.c b/sound/soc/codecs/rt5677.c
index 967678e7f48e..33e290b703df 100644
--- a/sound/soc/codecs/rt5677.c
+++ b/sound/soc/codecs/rt5677.c
@@ -4694,7 +4694,7 @@ static void rt5677_init_gpio(struct i2c_client *i2c)
 
         rt5677->gpio_chip = rt5677_template_chip;
         rt5677->gpio_chip.ngpio = RT5677_GPIO_NUM;
-        rt5677->gpio_chip.dev = &i2c->dev;
+        rt5677->gpio_chip.parent = &i2c->dev;
         rt5677->gpio_chip.base = -1;
 
         ret = gpiochip_add(&rt5677->gpio_chip);
diff --git a/sound/soc/codecs/wm5100.c b/sound/soc/codecs/wm5100.c
index c2cdcae18ff6..171a23ddd15d 100644
--- a/sound/soc/codecs/wm5100.c
+++ b/sound/soc/codecs/wm5100.c
@@ -2306,7 +2306,7 @@ static void wm5100_init_gpio(struct i2c_client *i2c)
 
         wm5100->gpio_chip = wm5100_template_chip;
         wm5100->gpio_chip.ngpio = 6;
-        wm5100->gpio_chip.dev = &i2c->dev;
+        wm5100->gpio_chip.parent = &i2c->dev;
 
         if (wm5100->pdata.gpio_base)
                 wm5100->gpio_chip.base = wm5100->pdata.gpio_base;
diff --git a/sound/soc/codecs/wm8903.c b/sound/soc/codecs/wm8903.c
index 2ed6419c181e..a82b8bc2cfc0 100644
--- a/sound/soc/codecs/wm8903.c
+++ b/sound/soc/codecs/wm8903.c
@@ -1853,7 +1853,7 @@ static void wm8903_init_gpio(struct wm8903_priv *wm8903)
 
         wm8903->gpio_chip = wm8903_template_chip;
         wm8903->gpio_chip.ngpio = WM8903_NUM_GPIO;
-        wm8903->gpio_chip.dev = wm8903->dev;
+        wm8903->gpio_chip.parent = wm8903->dev;
 
         if (pdata->gpio_base)
                 wm8903->gpio_chip.base = pdata->gpio_base;
diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c
index 949f632fc3f8..88223608a33f 100644
--- a/sound/soc/codecs/wm8962.c
+++ b/sound/soc/codecs/wm8962.c
@@ -3379,7 +3379,7 @@ static void wm8962_init_gpio(struct snd_soc_codec *codec)
 
         wm8962->gpio_chip = wm8962_template_chip;
         wm8962->gpio_chip.ngpio = WM8962_MAX_GPIO;
-        wm8962->gpio_chip.dev = codec->dev;
+        wm8962->gpio_chip.parent = codec->dev;
 
         if (pdata->gpio_base)
                 wm8962->gpio_chip.base = pdata->gpio_base;
diff --git a/sound/soc/codecs/wm8996.c b/sound/soc/codecs/wm8996.c
index f7ccd9fc5808..8d7d6c01a2f7 100644
--- a/sound/soc/codecs/wm8996.c
+++ b/sound/soc/codecs/wm8996.c
@@ -2204,7 +2204,7 @@ static void wm8996_init_gpio(struct wm8996_priv *wm8996)
 
         wm8996->gpio_chip = wm8996_template_chip;
         wm8996->gpio_chip.ngpio = 5;
-        wm8996->gpio_chip.dev = wm8996->dev;
+        wm8996->gpio_chip.parent = wm8996->dev;
 
         if (wm8996->pdata.gpio_base)
                 wm8996->gpio_chip.base = wm8996->pdata.gpio_base;
diff --git a/sound/soc/soc-ac97.c b/sound/soc/soc-ac97.c
index 733f5128eeff..7e0acd83b0e6 100644
--- a/sound/soc/soc-ac97.c
+++ b/sound/soc/soc-ac97.c
@@ -142,7 +142,7 @@ static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
         gpio_priv->codec = codec;
         gpio_priv->gpio_chip = snd_soc_ac97_gpio_chip;
         gpio_priv->gpio_chip.ngpio = AC97_NUM_GPIOS;
-        gpio_priv->gpio_chip.dev = codec->dev;
+        gpio_priv->gpio_chip.parent = codec->dev;
         gpio_priv->gpio_chip.base = -1;
 
         ret = gpiochip_add(&gpio_priv->gpio_chip);