Merge tag 'dt' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull ARM soc device tree updates from Olof Johansson:
 "Device tree conversion and enablement branch.  Mostly a bunch of new
  bindings and setup for various platforms, but the Via/Winchip VT8500
  platform is also converted over from being 100% legacy to now use
  device tree for probing.  More of that will come for 3.8."

Trivial conflicts due to removal of vt8500 files, and one documentation
file that was added with slightly different contents both here and in
the USb tree.

* tag 'dt' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (212 commits)
  arm: vt8500: Fixup for missing gpio.h
  ARM: LPC32xx: LED fix in PHY3250 DTS file
  ARM: dt: mmp-dma: add binding file
  arm: vt8500: Update arch-vt8500 to devicetree support.
  arm: vt8500: gpio: Devicetree support for arch-vt8500
  arm: vt8500: doc: Add device tree bindings for arch-vt8500 devices
  arm: vt8500: clk: Add Common Clock Framework support
  video: vt8500: Add devicetree support for vt8500-fb and wm8505-fb
  serial: vt8500: Add devicetree support for vt8500-serial
  rtc: vt8500: Add devicetree support for vt8500-rtc
  arm: vt8500: Add device tree files for VIA/Wondermedia SoC's
  ARM: tegra: Add Avionic Design Tamonten Evaluation Carrier support
  ARM: tegra: Add Avionic Design Medcom-Wide support
  ARM: tegra: Add Avionic Design Plutux support
  ARM: tegra: Add Avionic Design Tamonten support
  ARM: tegra: dts: Add pwm label
  ARM: ux500: Fix SSP register address format
  ARM: ux500: Apply tc3589x's GPIO/IRQ properties to HREF's DT
  ARM: ux500: Remove redundant #gpio-cell properties from Snowball DT
  ARM: ux500: Add all encompassing sound node to the HREF Device Tree
  ...

6 files changed, 461 insertions, 79 deletions

diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index ba7926f5c099..a00b828b1643 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -183,6 +183,12 @@ config GPIO_STA2X11
           Say yes here to support the STA2x11/ConneXt GPIO device.
           The GPIO module has 128 GPIO pins with alternate functions.
 
+config GPIO_VT8500
+        bool "VIA/Wondermedia SoC GPIO Support"
+        depends on ARCH_VT8500
+        help
+          Say yes here to support the VT8500/WM8505/WM8650 GPIO controller.
+
 config GPIO_XILINX
         bool "Xilinx GPIO support"
         depends on PPC_OF || MICROBLAZE
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 153caceeb053..a288142ad998 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -69,6 +69,7 @@ obj-$(CONFIG_GPIO_TPS65912)	+= gpio-tps65912.o
 obj-$(CONFIG_GPIO_TWL4030)      += gpio-twl4030.o
 obj-$(CONFIG_GPIO_UCB1400)      += gpio-ucb1400.o
 obj-$(CONFIG_GPIO_VR41XX)       += gpio-vr41xx.o
+obj-$(CONFIG_GPIO_VT8500)       += gpio-vt8500.o
 obj-$(CONFIG_GPIO_VX855)        += gpio-vx855.o
 obj-$(CONFIG_GPIO_WM831X)       += gpio-wm831x.o
 obj-$(CONFIG_GPIO_WM8350)       += gpio-wm8350.o
diff --git a/drivers/gpio/gpio-pxa.c b/drivers/gpio/gpio-pxa.c
index 9cac88a65f78..9528779ca463 100644
--- a/drivers/gpio/gpio-pxa.c
+++ b/drivers/gpio/gpio-pxa.c
@@ -26,6 +26,8 @@
 #include <linux/syscore_ops.h>
 #include <linux/slab.h>
 
+#include <asm/mach/irq.h>
+
 #include <mach/irqs.h>
 
 /*
@@ -59,6 +61,7 @@
 #define BANK_OFF(n)     (((n) < 3) ? (n) << 2 : 0x100 + (((n) - 3) << 2))
 
 int pxa_last_gpio;
+static int irq_base;
 
 #ifdef CONFIG_OF
 static struct irq_domain *domain;
@@ -167,63 +170,14 @@ static inline int __gpio_is_occupied(unsigned gpio)
         return ret;
 }
 
-#ifdef CONFIG_ARCH_PXA
-static inline int __pxa_gpio_to_irq(int gpio)
-{
-        if (gpio_is_pxa_type(gpio_type))
-                return PXA_GPIO_TO_IRQ(gpio);
-        return -1;
-}
-
-static inline int __pxa_irq_to_gpio(int irq)
-{
-        if (gpio_is_pxa_type(gpio_type))
-                return irq - PXA_GPIO_TO_IRQ(0);
-        return -1;
-}
-#else
-static inline int __pxa_gpio_to_irq(int gpio) { return -1; }
-static inline int __pxa_irq_to_gpio(int irq) { return -1; }
-#endif
-
-#ifdef CONFIG_ARCH_MMP
-static inline int __mmp_gpio_to_irq(int gpio)
-{
-        if (gpio_is_mmp_type(gpio_type))
-                return MMP_GPIO_TO_IRQ(gpio);
-        return -1;
-}
-
-static inline int __mmp_irq_to_gpio(int irq)
-{
-        if (gpio_is_mmp_type(gpio_type))
-                return irq - MMP_GPIO_TO_IRQ(0);
-        return -1;
-}
-#else
-static inline int __mmp_gpio_to_irq(int gpio) { return -1; }
-static inline int __mmp_irq_to_gpio(int irq) { return -1; }
-#endif
-
 static int pxa_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        int gpio, ret;
-
-        gpio = chip->base + offset;
-        ret = __pxa_gpio_to_irq(gpio);
-        if (ret >= 0)
-                return ret;
-        return __mmp_gpio_to_irq(gpio);
+        return chip->base + offset + irq_base;
 }
 
 int pxa_irq_to_gpio(int irq)
 {
-        int ret;
-
-        ret = __pxa_irq_to_gpio(irq);
-        if (ret >= 0)
-                return ret;
-        return __mmp_irq_to_gpio(irq);
+        return irq - irq_base;
 }
 
 static int pxa_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
@@ -403,6 +357,9 @@ static void pxa_gpio_demux_handler(unsigned int irq, struct irq_desc *desc)
         struct pxa_gpio_chip *c;
         int loop, gpio, gpio_base, n;
         unsigned long gedr;
+        struct irq_chip *chip = irq_desc_get_chip(desc);
+
+        chained_irq_enter(chip, desc);
 
         do {
                 loop = 0;
@@ -422,6 +379,8 @@ static void pxa_gpio_demux_handler(unsigned int irq, struct irq_desc *desc)
                         }
                 }
         } while (loop);
+
+        chained_irq_exit(chip, desc);
 }
 
 static void pxa_ack_muxed_gpio(struct irq_data *d)
@@ -535,7 +494,7 @@ const struct irq_domain_ops pxa_irq_domain_ops = {
 
 static int __devinit pxa_gpio_probe_dt(struct platform_device *pdev)
 {
-        int ret, nr_banks, nr_gpios, irq_base;
+        int ret, nr_banks, nr_gpios;
         struct device_node *prev, *next, *np = pdev->dev.of_node;
         const struct of_device_id *of_id =
                                 of_match_device(pxa_gpio_dt_ids, &pdev->dev);
@@ -590,10 +549,20 @@ static int __devinit pxa_gpio_probe(struct platform_device *pdev)
         int irq0 = 0, irq1 = 0, irq_mux, gpio_offset = 0;
 
         ret = pxa_gpio_probe_dt(pdev);
-        if (ret < 0)
+        if (ret < 0) {
                 pxa_last_gpio = pxa_gpio_nums();
-        else
+#ifdef CONFIG_ARCH_PXA
+                if (gpio_is_pxa_type(gpio_type))
+                        irq_base = PXA_GPIO_TO_IRQ(0);
+#endif
+#ifdef CONFIG_ARCH_MMP
+                if (gpio_is_mmp_type(gpio_type))
+                        irq_base = MMP_GPIO_TO_IRQ(0);
+#endif
+        } else {
                 use_of = 1;
+        }
+
         if (!pxa_last_gpio)
                 return -EINVAL;
 
diff --git a/drivers/gpio/gpio-samsung.c b/drivers/gpio/gpio-samsung.c
index 1c169324e357..8af4b06e80f7 100644
--- a/drivers/gpio/gpio-samsung.c
+++ b/drivers/gpio/gpio-samsung.c
@@ -938,6 +938,67 @@ static void __init samsung_gpiolib_add(struct samsung_gpio_chip *chip)
                 s3c_gpiolib_track(chip);
 }
 
+#if defined(CONFIG_PLAT_S3C24XX) && defined(CONFIG_OF)
+static int s3c24xx_gpio_xlate(struct gpio_chip *gc,
+                        const struct of_phandle_args *gpiospec, u32 *flags)
+{
+        unsigned int pin;
+
+        if (WARN_ON(gc->of_gpio_n_cells < 3))
+                return -EINVAL;
+
+        if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
+                return -EINVAL;
+
+        if (gpiospec->args[0] > gc->ngpio)
+                return -EINVAL;
+
+        pin = gc->base + gpiospec->args[0];
+
+        if (s3c_gpio_cfgpin(pin, S3C_GPIO_SFN(gpiospec->args[1])))
+                pr_warn("gpio_xlate: failed to set pin function\n");
+        if (s3c_gpio_setpull(pin, gpiospec->args[2] & 0xffff))
+                pr_warn("gpio_xlate: failed to set pin pull up/down\n");
+
+        if (flags)
+                *flags = gpiospec->args[2] >> 16;
+
+        return gpiospec->args[0];
+}
+
+static const struct of_device_id s3c24xx_gpio_dt_match[] __initdata = {
+        { .compatible = "samsung,s3c24xx-gpio", },
+        {}
+};
+
+static __init void s3c24xx_gpiolib_attach_ofnode(struct samsung_gpio_chip *chip,
+                                                 u64 base, u64 offset)
+{
+        struct gpio_chip *gc =  &chip->chip;
+        u64 address;
+
+        if (!of_have_populated_dt())
+                return;
+
+        address = chip->base ? base + ((u32)chip->base & 0xfff) : base + offset;
+        gc->of_node = of_find_matching_node_by_address(NULL,
+                        s3c24xx_gpio_dt_match, address);
+        if (!gc->of_node) {
+                pr_info("gpio: device tree node not found for gpio controller"
+                        " with base address %08llx\n", address);
+                return;
+        }
+        gc->of_gpio_n_cells = 3;
+        gc->of_xlate = s3c24xx_gpio_xlate;
+}
+#else
+static __init void s3c24xx_gpiolib_attach_ofnode(struct samsung_gpio_chip *chip,
+                                                 u64 base, u64 offset)
+{
+        return;
+}
+#endif /* defined(CONFIG_PLAT_S3C24XX) && defined(CONFIG_OF) */
+
 static void __init s3c24xx_gpiolib_add_chips(struct samsung_gpio_chip *chip,
                                              int nr_chips, void __iomem *base)
 {
@@ -962,6 +1023,8 @@ static void __init s3c24xx_gpiolib_add_chips(struct samsung_gpio_chip *chip,
                         gc->direction_output = samsung_gpiolib_2bit_output;
 
                 samsung_gpiolib_add(chip);
+
+                s3c24xx_gpiolib_attach_ofnode(chip, S3C24XX_PA_GPIO, i * 0x10);
         }
 }
 
diff --git a/drivers/gpio/gpio-twl4030.c b/drivers/gpio/gpio-twl4030.c
index f030880bc9bb..c5f8ca233e1f 100644
--- a/drivers/gpio/gpio-twl4030.c
+++ b/drivers/gpio/gpio-twl4030.c
@@ -396,6 +396,29 @@ static int __devinit gpio_twl4030_debounce(u32 debounce, u8 mmc_cd)
 
 static int gpio_twl4030_remove(struct platform_device *pdev);
 
+static struct twl4030_gpio_platform_data *of_gpio_twl4030(struct device *dev)
+{
+        struct twl4030_gpio_platform_data *omap_twl_info;
+
+        omap_twl_info = devm_kzalloc(dev, sizeof(*omap_twl_info), GFP_KERNEL);
+        if (!omap_twl_info)
+                return NULL;
+
+        omap_twl_info->use_leds = of_property_read_bool(dev->of_node,
+                        "ti,use-leds");
+
+        of_property_read_u32(dev->of_node, "ti,debounce",
+                             &omap_twl_info->debounce);
+        of_property_read_u32(dev->of_node, "ti,mmc-cd",
+                             (u32 *)&omap_twl_info->mmc_cd);
+        of_property_read_u32(dev->of_node, "ti,pullups",
+                             &omap_twl_info->pullups);
+        of_property_read_u32(dev->of_node, "ti,pulldowns",
+                             &omap_twl_info->pulldowns);
+
+        return omap_twl_info;
+}
+
 static int __devinit gpio_twl4030_probe(struct platform_device *pdev)
 {
         struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data;
@@ -428,33 +451,37 @@ no_irqs:
         twl_gpiochip.ngpio = TWL4030_GPIO_MAX;
         twl_gpiochip.dev = &pdev->dev;
 
-        if (pdata) {
-                /*
-                 * NOTE:  boards may waste power if they don't set pullups
-                 * and pulldowns correctly ... default for non-ULPI pins is
-                 * pulldown, and some other pins may have external pullups
-                 * or pulldowns.  Careful!
-                 */
-                ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns);
-                if (ret)
-                        dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n",
-                                        pdata->pullups, pdata->pulldowns,
-                                        ret);
-
-                ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd);
-                if (ret)
-                        dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n",
-                                        pdata->debounce, pdata->mmc_cd,
-                                        ret);
-
-                /*
-                 * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
-                 * is (still) clear if use_leds is set.
-                 */
-                if (pdata->use_leds)
-                        twl_gpiochip.ngpio += 2;
+        if (node)
+                pdata = of_gpio_twl4030(&pdev->dev);
+
+        if (pdata == NULL) {
+                dev_err(&pdev->dev, "Platform data is missing\n");
+                return -ENXIO;
         }
 
+        /*
+         * NOTE:  boards may waste power if they don't set pullups
+         * and pulldowns correctly ... default for non-ULPI pins is
+         * pulldown, and some other pins may have external pullups
+         * or pulldowns.  Careful!
+         */
+        ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns);
+        if (ret)
+                dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n",
+                        pdata->pullups, pdata->pulldowns, ret);
+
+        ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd);
+        if (ret)
+                dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n",
+                        pdata->debounce, pdata->mmc_cd, ret);
+
+        /*
+         * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
+         * is (still) clear if use_leds is set.
+         */
+        if (pdata->use_leds)
+                twl_gpiochip.ngpio += 2;
+
         ret = gpiochip_add(&twl_gpiochip);
         if (ret < 0) {
                 dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret);
diff --git a/drivers/gpio/gpio-vt8500.c b/drivers/gpio/gpio-vt8500.c
new file mode 100644
index 000000000000..bcd8e4aa7c7d
--- /dev/null
+++ b/drivers/gpio/gpio-vt8500.c
@@ -0,0 +1,316 @@
+/* drivers/gpio/gpio-vt8500.c
+ *
+ * Copyright (C) 2012 Tony Prisk <linux@prisktech.co.nz>
+ * Based on arch/arm/mach-vt8500/gpio.c:
+ * - Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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/module.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/platform_device.h>
+#include <linux/bitops.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
+#include <linux/of_device.h>
+
+/*
+        We handle GPIOs by bank, each bank containing up to 32 GPIOs covered
+        by one set of registers (although not all may be valid).
+
+        Because different SoC's have different register offsets, we pass the
+        register offsets as data in vt8500_gpio_dt_ids[].
+
+        A value of NO_REG is used to indicate that this register is not
+        supported. Only used for ->en at the moment.
+*/
+
+#define NO_REG  0xFFFF
+
+/*
+ * struct vt8500_gpio_bank_regoffsets
+ * @en: offset to enable register of the bank
+ * @dir: offset to direction register of the bank
+ * @data_out: offset to the data out register of the bank
+ * @data_in: offset to the data in register of the bank
+ * @ngpio: highest valid pin in this bank
+ */
+
+struct vt8500_gpio_bank_regoffsets {
+        unsigned int    en;
+        unsigned int    dir;
+        unsigned int    data_out;
+        unsigned int    data_in;
+        unsigned char   ngpio;
+};
+
+struct vt8500_gpio_data {
+        unsigned int                            num_banks;
+        struct vt8500_gpio_bank_regoffsets      banks[];
+};
+
+#define VT8500_BANK(__en, __dir, __out, __in, __ngpio)          \
+{                                                               \
+        .en = __en,                                             \
+        .dir = __dir,                                           \
+        .data_out = __out,                                      \
+        .data_in = __in,                                        \
+        .ngpio = __ngpio,                                       \
+}
+
+static struct vt8500_gpio_data vt8500_data = {
+        .num_banks      = 7,
+        .banks  = {
+                VT8500_BANK(0x00, 0x20, 0x40, 0x60, 26),
+                VT8500_BANK(0x04, 0x24, 0x44, 0x64, 28),
+                VT8500_BANK(0x08, 0x28, 0x48, 0x68, 31),
+                VT8500_BANK(0x0C, 0x2C, 0x4C, 0x6C, 19),
+                VT8500_BANK(0x10, 0x30, 0x50, 0x70, 19),
+                VT8500_BANK(0x14, 0x34, 0x54, 0x74, 23),
+                VT8500_BANK(NO_REG, 0x3C, 0x5C, 0x7C, 9),
+        },
+};
+
+static struct vt8500_gpio_data wm8505_data = {
+        .num_banks      = 10,
+        .banks  = {
+                VT8500_BANK(0x40, 0x68, 0x90, 0xB8, 8),
+                VT8500_BANK(0x44, 0x6C, 0x94, 0xBC, 32),
+                VT8500_BANK(0x48, 0x70, 0x98, 0xC0, 6),
+                VT8500_BANK(0x4C, 0x74, 0x9C, 0xC4, 16),
+                VT8500_BANK(0x50, 0x78, 0xA0, 0xC8, 25),
+                VT8500_BANK(0x54, 0x7C, 0xA4, 0xCC, 5),
+                VT8500_BANK(0x58, 0x80, 0xA8, 0xD0, 5),
+                VT8500_BANK(0x5C, 0x84, 0xAC, 0xD4, 12),
+                VT8500_BANK(0x60, 0x88, 0xB0, 0xD8, 16),
+                VT8500_BANK(0x64, 0x8C, 0xB4, 0xDC, 22),
+        },
+};
+
+/*
+ * No information about which bits are valid so we just make
+ * them all available until its figured out.
+ */
+static struct vt8500_gpio_data wm8650_data = {
+        .num_banks      = 9,
+        .banks  = {
+                VT8500_BANK(0x40, 0x80, 0xC0, 0x00, 32),
+                VT8500_BANK(0x44, 0x84, 0xC4, 0x04, 32),
+                VT8500_BANK(0x48, 0x88, 0xC8, 0x08, 32),
+                VT8500_BANK(0x4C, 0x8C, 0xCC, 0x0C, 32),
+                VT8500_BANK(0x50, 0x90, 0xD0, 0x10, 32),
+                VT8500_BANK(0x54, 0x94, 0xD4, 0x14, 32),
+                VT8500_BANK(0x58, 0x98, 0xD8, 0x18, 32),
+                VT8500_BANK(0x5C, 0x9C, 0xDC, 0x1C, 32),
+                VT8500_BANK(0x7C, 0xBC, 0xFC, 0x3C, 32),
+        },
+};
+
+struct vt8500_gpio_chip {
+        struct gpio_chip                chip;
+
+        const struct vt8500_gpio_bank_regoffsets *regs;
+        void __iomem    *base;
+};
+
+
+#define to_vt8500(__chip) container_of(__chip, struct vt8500_gpio_chip, chip)
+
+static int vt8500_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        u32 val;
+        struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
+
+        if (vt8500_chip->regs->en == NO_REG)
+                return 0;
+
+        val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->en);
+        val |= BIT(offset);
+        writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->en);
+
+        return 0;
+}
+
+static void vt8500_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
+        u32 val;
+
+        if (vt8500_chip->regs->en == NO_REG)
+                return;
+
+        val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->en);
+        val &= ~BIT(offset);
+        writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->en);
+}
+
+static int vt8500_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
+
+        u32 val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->dir);
+        val &= ~BIT(offset);
+        writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->dir);
+
+        return 0;
+}
+
+static int vt8500_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                                                int value)
+{
+        struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
+
+        u32 val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->dir);
+        val |= BIT(offset);
+        writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->dir);
+
+        if (value) {
+                val = readl_relaxed(vt8500_chip->base +
+                                                vt8500_chip->regs->data_out);
+                val |= BIT(offset);
+                writel_relaxed(val, vt8500_chip->base +
+                                                vt8500_chip->regs->data_out);
+        }
+        return 0;
+}
+
+static int vt8500_gpio_get_value(struct gpio_chip *chip, unsigned offset)
+{
+        struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
+
+        return (readl_relaxed(vt8500_chip->base + vt8500_chip->regs->data_in) >>
+                                                                offset) & 1;
+}
+
+static void vt8500_gpio_set_value(struct gpio_chip *chip, unsigned offset,
+                                                                int value)
+{
+        struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
+
+        u32 val = readl_relaxed(vt8500_chip->base +
+                                                vt8500_chip->regs->data_out);
+        if (value)
+                val |= BIT(offset);
+        else
+                val &= ~BIT(offset);
+
+        writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->data_out);
+}
+
+static int vt8500_of_xlate(struct gpio_chip *gc,
+                            const struct of_phandle_args *gpiospec, u32 *flags)
+{
+        /* bank if specificed in gpiospec->args[0] */
+        if (flags)
+                *flags = gpiospec->args[2];
+
+        return gpiospec->args[1];
+}
+
+static int vt8500_add_chips(struct platform_device *pdev, void __iomem *base,
+                                const struct vt8500_gpio_data *data)
+{
+        struct vt8500_gpio_chip *vtchip;
+        struct gpio_chip *chip;
+        int i;
+        int pin_cnt = 0;
+
+        vtchip = devm_kzalloc(&pdev->dev,
+                        sizeof(struct vt8500_gpio_chip) * data->num_banks,
+                        GFP_KERNEL);
+        if (!vtchip) {
+                pr_err("%s: failed to allocate chip memory\n", __func__);
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < data->num_banks; i++) {
+                vtchip[i].base = base;
+                vtchip[i].regs = &data->banks[i];
+
+                chip = &vtchip[i].chip;
+
+                chip->of_xlate = vt8500_of_xlate;
+                chip->of_gpio_n_cells = 3;
+                chip->of_node = pdev->dev.of_node;
+
+                chip->request = vt8500_gpio_request;
+                chip->free = vt8500_gpio_free;
+                chip->direction_input = vt8500_gpio_direction_input;
+                chip->direction_output = vt8500_gpio_direction_output;
+                chip->get = vt8500_gpio_get_value;
+                chip->set = vt8500_gpio_set_value;
+                chip->can_sleep = 0;
+                chip->base = pin_cnt;
+                chip->ngpio = data->banks[i].ngpio;
+
+                pin_cnt += data->banks[i].ngpio;
+
+                gpiochip_add(chip);
+        }
+        return 0;
+}
+
+static struct of_device_id vt8500_gpio_dt_ids[] = {
+        { .compatible = "via,vt8500-gpio", .data = &vt8500_data, },
+        { .compatible = "wm,wm8505-gpio", .data = &wm8505_data, },
+        { .compatible = "wm,wm8650-gpio", .data = &wm8650_data, },
+        { /* Sentinel */ },
+};
+
+static int __devinit vt8500_gpio_probe(struct platform_device *pdev)
+{
+        void __iomem *gpio_base;
+        struct device_node *np;
+        const struct of_device_id *of_id =
+                                of_match_device(vt8500_gpio_dt_ids, &pdev->dev);
+
+        if (!of_id) {
+                dev_err(&pdev->dev, "Failed to find gpio controller\n");
+                return -ENODEV;
+        }
+
+        np = pdev->dev.of_node;
+        if (!np) {
+                dev_err(&pdev->dev, "Missing GPIO description in devicetree\n");
+                return -EFAULT;
+        }
+
+        gpio_base = of_iomap(np, 0);
+        if (!gpio_base) {
+                dev_err(&pdev->dev, "Unable to map GPIO registers\n");
+                of_node_put(np);
+                return -ENOMEM;
+        }
+
+        vt8500_add_chips(pdev, gpio_base, of_id->data);
+
+        return 0;
+}
+
+static struct platform_driver vt8500_gpio_driver = {
+        .probe          = vt8500_gpio_probe,
+        .driver         = {
+                .name   = "vt8500-gpio",
+                .owner  = THIS_MODULE,
+                .of_match_table = vt8500_gpio_dt_ids,
+        },
+};
+
+module_platform_driver(vt8500_gpio_driver);
+
+MODULE_DESCRIPTION("VT8500 GPIO Driver");
+MODULE_AUTHOR("Tony Prisk <linux@prisktech.co.nz>");
+MODULE_LICENSE("GPL v2");
+MODULE_DEVICE_TABLE(of, vt8500_gpio_dt_ids);