Merge tag 'gpio-for-linus' of git://git.secretlab.ca/git/linux-2.6

Pull GPIO changes for v3.4 from Grant Likely:
 "Primarily gpio device driver changes with some minor side effects
  under arch/arm and arch/x86.  Also includes a few core changes such as
  explicitly supporting (electrical) open source and open drain outputs
  and some help for parsing gpio devicetree properties."

Fix up context conflict due to Laxman Dewangan adding sleep control for
the tps65910 driver separately for gpio's and regulators.

* tag 'gpio-for-linus' of git://git.secretlab.ca/git/linux-2.6: (34 commits)
  gpio/ep93xx: Remove unused inline function and useless pr_err message
  gpio/sodaville: Mark broken due to core irqdomain migration
  gpio/omap: fix redundant decoding of gpio offset
  gpio/omap: fix incorrect update to context.irqenable1
  gpio/omap: fix incorrect context restore logic in omap_gpio_runtime_*
  gpio/omap: fix missing dataout context save in _set_gpio_dataout_reg
  gpio/omap: fix _set_gpio_irqenable implementation
  gpio/omap: fix trigger type to unsigned
  gpio/omap: fix wakeup_en register update in _set_gpio_wakeup()
  gpio: tegra: tegra_gpio_config shouldn't be __init
  gpio/davinci: fix enabling unbanked GPIO IRQs
  gpio/davinci: fix oops on unbanked gpio irq request
  gpio/omap: Fix section warning for omap_mpuio_alloc_gc()
  ARM: tegra: export tegra_gpio_{en,dis}able
  gpio/gpio-stmpe: Fix the value returned by _get_value routine
  Documentation/gpio.txt: Explain expected pinctrl interaction
  GPIO: LPC32xx: Add output reading to GPO P3
  GPIO: LPC32xx: Fix missing bit selection mask
  gpio/omap: fix wakeups on level-triggered GPIOs
  gpio/omap: Fix IRQ handling for SPARSE_IRQ
  ...

13 files changed, 843 insertions, 111 deletions

diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 0409cf35adda..edadbdad31d0 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -236,6 +236,12 @@ config GPIO_MAX732X_IRQ
           Say yes here to enable the max732x to be used as an interrupt
           controller. It requires the driver to be built in the kernel.
 
+config GPIO_MC9S08DZ60
+        bool "MX35 3DS BOARD MC9S08DZ60 GPIO functions"
+        depends on I2C && MACH_MX35_3DS
+        help
+          Select this to enable the MC9S08DZ60 GPIO driver
+
 config GPIO_PCA953X
         tristate "PCA953x, PCA955x, TCA64xx, and MAX7310 I/O ports"
         depends on I2C
@@ -422,6 +428,14 @@ config GPIO_ML_IOH
           Hub) which is for IVI(In-Vehicle Infotainment) use.
           This driver can access the IOH's GPIO device.
 
+config GPIO_SODAVILLE
+        bool "Intel Sodaville GPIO support"
+        depends on X86 && PCI && OF && BROKEN
+        select GPIO_GENERIC
+        select GENERIC_IRQ_CHIP
+        help
+          Say Y here to support Intel Sodaville GPIO.
+
 config GPIO_TIMBERDALE
         bool "Support for timberdale GPIO IP"
         depends on MFD_TIMBERDALE && HAS_IOMEM
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 9a8fb54ae462..007f54bd0081 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -27,6 +27,7 @@ obj-$(CONFIG_GPIO_MAX7300)	+= gpio-max7300.o
 obj-$(CONFIG_GPIO_MAX7301)      += gpio-max7301.o
 obj-$(CONFIG_GPIO_MAX732X)      += gpio-max732x.o
 obj-$(CONFIG_GPIO_MC33880)      += gpio-mc33880.o
+obj-$(CONFIG_GPIO_MC9S08DZ60)   += gpio-mc9s08dz60.o
 obj-$(CONFIG_GPIO_MCP23S08)     += gpio-mcp23s08.o
 obj-$(CONFIG_GPIO_ML_IOH)       += gpio-ml-ioh.o
 obj-$(CONFIG_GPIO_MPC5200)      += gpio-mpc5200.o
@@ -46,6 +47,7 @@ obj-$(CONFIG_GPIO_RDC321X)	+= gpio-rdc321x.o
 obj-$(CONFIG_PLAT_SAMSUNG)      += gpio-samsung.o
 obj-$(CONFIG_ARCH_SA1100)       += gpio-sa1100.o
 obj-$(CONFIG_GPIO_SCH)          += gpio-sch.o
+obj-$(CONFIG_GPIO_SODAVILLE)    += gpio-sodaville.o
 obj-$(CONFIG_GPIO_STMPE)        += gpio-stmpe.o
 obj-$(CONFIG_GPIO_SX150X)       += gpio-sx150x.o
 obj-$(CONFIG_GPIO_TC3589X)      += gpio-tc3589x.o
diff --git a/drivers/gpio/gpio-davinci.c b/drivers/gpio/gpio-davinci.c
index df0d59570a84..3d000169285d 100644
--- a/drivers/gpio/gpio-davinci.c
+++ b/drivers/gpio/gpio-davinci.c
@@ -313,10 +313,16 @@ static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
                 return -ENODEV;
 }
 
-static int gpio_irq_type_unbanked(struct irq_data *d, unsigned trigger)
+static int gpio_irq_type_unbanked(struct irq_data *data, unsigned trigger)
 {
-        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
-        u32 mask = (u32) irq_data_get_irq_handler_data(d);
+        struct davinci_gpio_controller *d;
+        struct davinci_gpio_regs __iomem *g;
+        struct davinci_soc_info *soc_info = &davinci_soc_info;
+        u32 mask;
+
+        d = (struct davinci_gpio_controller *)data->handler_data;
+        g = (struct davinci_gpio_regs __iomem *)d->regs;
+        mask = __gpio_mask(data->irq - soc_info->gpio_irq);
 
         if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
                 return -EINVAL;
@@ -380,7 +386,7 @@ static int __init davinci_gpio_irq_setup(void)
          * IRQ mux conflicts; gpio_irq_type_unbanked() is only for GPIOs.
          */
         if (soc_info->gpio_unbanked) {
-                static struct irq_chip gpio_irqchip_unbanked;
+                static struct irq_chip_type gpio_unbanked;
 
                 /* pass "bank 0" GPIO IRQs to AINTC */
                 chips[0].chip.to_irq = gpio_to_irq_unbanked;
@@ -388,9 +394,10 @@ static int __init davinci_gpio_irq_setup(void)
 
                 /* AINTC handles mask/unmask; GPIO handles triggering */
                 irq = bank_irq;
-                gpio_irqchip_unbanked = *irq_get_chip(irq);
-                gpio_irqchip_unbanked.name = "GPIO-AINTC";
-                gpio_irqchip_unbanked.irq_set_type = gpio_irq_type_unbanked;
+                gpio_unbanked = *container_of(irq_get_chip(irq),
+                                              struct irq_chip_type, chip);
+                gpio_unbanked.chip.name = "GPIO-AINTC";
+                gpio_unbanked.chip.irq_set_type = gpio_irq_type_unbanked;
 
                 /* default trigger: both edges */
                 g = gpio2regs(0);
@@ -399,9 +406,8 @@ static int __init davinci_gpio_irq_setup(void)
 
                 /* set the direct IRQs up to use that irqchip */
                 for (gpio = 0; gpio < soc_info->gpio_unbanked; gpio++, irq++) {
-                        irq_set_chip(irq, &gpio_irqchip_unbanked);
-                        irq_set_handler_data(irq, (void *)__gpio_mask(gpio));
-                        irq_set_chip_data(irq, (__force void *)g);
+                        irq_set_chip(irq, &gpio_unbanked.chip);
+                        irq_set_handler_data(irq, &chips[gpio / 32]);
                         irq_set_status_flags(irq, IRQ_TYPE_EDGE_BOTH);
                 }
 
diff --git a/drivers/gpio/gpio-ep93xx.c b/drivers/gpio/gpio-ep93xx.c
index 4ca5642e9776..776b772523e5 100644
--- a/drivers/gpio/gpio-ep93xx.c
+++ b/drivers/gpio/gpio-ep93xx.c
@@ -12,8 +12,6 @@
  *  published by the Free Software Foundation.
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
@@ -65,11 +63,6 @@ static void ep93xx_gpio_update_int_params(unsigned port)
                 EP93XX_GPIO_REG(int_en_register_offset[port]));
 }
 
-static inline void ep93xx_gpio_int_mask(unsigned line)
-{
-        gpio_int_unmasked[line >> 3] &= ~(1 << (line & 7));
-}
-
 static void ep93xx_gpio_int_debounce(unsigned int irq, bool enable)
 {
         int line = irq_to_gpio(irq);
@@ -212,7 +205,6 @@ static int ep93xx_gpio_irq_type(struct irq_data *d, unsigned int type)
                 handler = handle_edge_irq;
                 break;
         default:
-                pr_err("failed to set irq type %d for gpio %d\n", type, gpio);
                 return -EINVAL;
         }
 
diff --git a/drivers/gpio/gpio-lpc32xx.c b/drivers/gpio/gpio-lpc32xx.c
index ddfacc5ce56d..61c2d08d37b6 100644
--- a/drivers/gpio/gpio-lpc32xx.c
+++ b/drivers/gpio/gpio-lpc32xx.c
@@ -59,12 +59,14 @@
 #define GPO3_PIN_TO_BIT(x)                      (1 << (x))
 #define GPIO012_PIN_IN_SEL(x, y)                (((x) >> (y)) & 1)
 #define GPIO3_PIN_IN_SHIFT(x)                   ((x) == 5 ? 24 : 10 + (x))
-#define GPIO3_PIN_IN_SEL(x, y)                  ((x) >> GPIO3_PIN_IN_SHIFT(y))
+#define GPIO3_PIN_IN_SEL(x, y)                  (((x) >> GPIO3_PIN_IN_SHIFT(y)) & 1)
 #define GPIO3_PIN5_IN_SEL(x)                    (((x) >> 24) & 1)
 #define GPI3_PIN_IN_SEL(x, y)                   (((x) >> (y)) & 1)
+#define GPO3_PIN_IN_SEL(x, y)                   (((x) >> (y)) & 1)
 
 struct gpio_regs {
         void __iomem *inp_state;
+        void __iomem *outp_state;
         void __iomem *outp_set;
         void __iomem *outp_clr;
         void __iomem *dir_set;
@@ -145,6 +147,7 @@ static struct gpio_regs gpio_grp_regs_p2 = {
 
 static struct gpio_regs gpio_grp_regs_p3 = {
         .inp_state      = LPC32XX_GPIO_P3_INP_STATE,
+        .outp_state     = LPC32XX_GPIO_P3_OUTP_STATE,
         .outp_set       = LPC32XX_GPIO_P3_OUTP_SET,
         .outp_clr       = LPC32XX_GPIO_P3_OUTP_CLR,
         .dir_set        = LPC32XX_GPIO_P2_DIR_SET,
@@ -240,6 +243,12 @@ static int __get_gpi_state_p3(struct lpc32xx_gpio_chip *group,
         return GPI3_PIN_IN_SEL(__raw_readl(group->gpio_grp->inp_state), pin);
 }
 
+static int __get_gpo_state_p3(struct lpc32xx_gpio_chip *group,
+        unsigned pin)
+{
+        return GPO3_PIN_IN_SEL(__raw_readl(group->gpio_grp->outp_state), pin);
+}
+
 /*
  * GENERIC_GPIO primitives.
  */
@@ -340,6 +349,13 @@ static void lpc32xx_gpo_set_value(struct gpio_chip *chip, unsigned pin,
         __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);
+
+        return __get_gpo_state_p3(group, pin);
+}
+
 static int lpc32xx_gpio_request(struct gpio_chip *chip, unsigned pin)
 {
         if (pin < chip->ngpio)
@@ -427,6 +443,7 @@ static struct lpc32xx_gpio_chip lpc32xx_gpiochip[] = {
                         .label                  = "gpo_p3",
                         .direction_output       = lpc32xx_gpio_dir_out_always,
                         .set                    = lpc32xx_gpo_set_value,
+                        .get                    = lpc32xx_gpo_get_value,
                         .request                = lpc32xx_gpio_request,
                         .base                   = LPC32XX_GPO_P3_GRP,
                         .ngpio                  = LPC32XX_GPO_P3_MAX,
diff --git a/drivers/gpio/gpio-mc9s08dz60.c b/drivers/gpio/gpio-mc9s08dz60.c
new file mode 100644
index 000000000000..2738cc44d636
--- /dev/null
+++ b/drivers/gpio/gpio-mc9s08dz60.c
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2009-2012 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * Author: Wu Guoxing <b39297@freescale.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.
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/gpio.h>
+
+#define GPIO_GROUP_NUM 2
+#define GPIO_NUM_PER_GROUP 8
+#define GPIO_NUM (GPIO_GROUP_NUM*GPIO_NUM_PER_GROUP)
+
+struct mc9s08dz60 {
+        struct i2c_client *client;
+        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;
+        *bit = offset % GPIO_NUM_PER_GROUP;
+}
+
+static int mc9s08dz60_get_value(struct gpio_chip *gc, unsigned offset)
+{
+        u8 reg, bit;
+        s32 value;
+        struct mc9s08dz60 *mc9s = to_mc9s08dz60(gc);
+
+        mc9s_gpio_to_reg_and_bit(offset, &reg, &bit);
+        value = i2c_smbus_read_byte_data(mc9s->client, reg);
+
+        return (value >= 0) ? (value >> bit) & 0x1 : 0;
+}
+
+static int mc9s08dz60_set(struct mc9s08dz60 *mc9s, unsigned offset, int val)
+{
+        u8 reg, bit;
+        s32 value;
+
+        mc9s_gpio_to_reg_and_bit(offset, &reg, &bit);
+        value = i2c_smbus_read_byte_data(mc9s->client, reg);
+        if (value >= 0) {
+                if (val)
+                        value |= 1 << bit;
+                else
+                        value &= ~(1 << bit);
+
+                return i2c_smbus_write_byte_data(mc9s->client, reg, value);
+        } else
+                return value;
+
+}
+
+
+static void mc9s08dz60_set_value(struct gpio_chip *gc, unsigned offset, int val)
+{
+        struct mc9s08dz60 *mc9s = to_mc9s08dz60(gc);
+
+        mc9s08dz60_set(mc9s, offset, val);
+}
+
+static int mc9s08dz60_direction_output(struct gpio_chip *gc,
+                                       unsigned offset, int val)
+{
+        struct mc9s08dz60 *mc9s = to_mc9s08dz60(gc);
+
+        return mc9s08dz60_set(mc9s, offset, val);
+}
+
+static int mc9s08dz60_probe(struct i2c_client *client,
+                            const struct i2c_device_id *id)
+{
+        int ret = 0;
+        struct mc9s08dz60 *mc9s;
+
+        mc9s = kzalloc(sizeof(*mc9s), GFP_KERNEL);
+        if (!mc9s)
+                return -ENOMEM;
+
+        mc9s->chip.label = client->name;
+        mc9s->chip.base = -1;
+        mc9s->chip.dev = &client->dev;
+        mc9s->chip.owner = THIS_MODULE;
+        mc9s->chip.ngpio = GPIO_NUM;
+        mc9s->chip.can_sleep = 1;
+        mc9s->chip.get = mc9s08dz60_get_value;
+        mc9s->chip.set = mc9s08dz60_set_value;
+        mc9s->chip.direction_output = mc9s08dz60_direction_output;
+        mc9s->client = client;
+        i2c_set_clientdata(client, mc9s);
+
+        ret = gpiochip_add(&mc9s->chip);
+        if (ret)
+                goto error;
+
+        return 0;
+
+ error:
+        kfree(mc9s);
+        return ret;
+}
+
+static int mc9s08dz60_remove(struct i2c_client *client)
+{
+        struct mc9s08dz60 *mc9s;
+        int ret;
+
+        mc9s = i2c_get_clientdata(client);
+
+        ret = gpiochip_remove(&mc9s->chip);
+        if (!ret)
+                kfree(mc9s);
+
+        return ret;
+
+}
+
+static const struct i2c_device_id mc9s08dz60_id[] = {
+        {"mc9s08dz60", 0},
+        {},
+};
+
+MODULE_DEVICE_TABLE(i2c, mc9s08dz60_id);
+
+static struct i2c_driver mc9s08dz60_i2c_driver = {
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "mc9s08dz60",
+        },
+        .probe = mc9s08dz60_probe,
+        .remove = mc9s08dz60_remove,
+        .id_table = mc9s08dz60_id,
+};
+
+module_i2c_driver(mc9s08dz60_i2c_driver);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc. "
+                "Wu Guoxing <b39297@freescale.com>");
+MODULE_DESCRIPTION("mc9s08dz60 gpio function on mx35 3ds board");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
index f49bd6f47a50..1adc2ec1e383 100644
--- a/drivers/gpio/gpio-omap.c
+++ b/drivers/gpio/gpio-omap.c
@@ -19,9 +19,12 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/io.h>
-#include <linux/slab.h>
+#include <linux/device.h>
 #include <linux/pm_runtime.h>
 #include <linux/pm.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/irqdomain.h>
 
 #include <mach/hardware.h>
 #include <asm/irq.h>
@@ -50,10 +53,10 @@ struct gpio_regs {
 
 struct gpio_bank {
         struct list_head node;
-        unsigned long pbase;
         void __iomem *base;
         u16 irq;
-        u16 virtual_irq_start;
+        int irq_base;
+        struct irq_domain *domain;
         u32 suspend_wakeup;
         u32 saved_wakeup;
         u32 non_wakeup_gpios;
@@ -77,7 +80,6 @@ struct gpio_bank {
         int stride;
         u32 width;
         int context_loss_count;
-        u16 id;
         int power_mode;
         bool workaround_enabled;
 
@@ -91,6 +93,11 @@ struct gpio_bank {
 #define GPIO_BIT(bank, gpio) (1 << GPIO_INDEX(bank, gpio))
 #define GPIO_MOD_CTRL_BIT       BIT(0)
 
+static int irq_to_gpio(struct gpio_bank *bank, unsigned int gpio_irq)
+{
+        return gpio_irq - bank->irq_base + bank->chip.base;
+}
+
 static void _set_gpio_direction(struct gpio_bank *bank, int gpio, int is_input)
 {
         void __iomem *reg = bank->base;
@@ -113,10 +120,13 @@ static void _set_gpio_dataout_reg(struct gpio_bank *bank, int gpio, int enable)
         void __iomem *reg = bank->base;
         u32 l = GPIO_BIT(bank, gpio);
 
-        if (enable)
+        if (enable) {
                 reg += bank->regs->set_dataout;
-        else
+                bank->context.dataout |= l;
+        } else {
                 reg += bank->regs->clr_dataout;
+                bank->context.dataout &= ~l;
+        }
 
         __raw_writel(l, reg);
 }
@@ -137,25 +147,25 @@ static void _set_gpio_dataout_mask(struct gpio_bank *bank, int gpio, int enable)
         bank->context.dataout = l;
 }
 
-static int _get_gpio_datain(struct gpio_bank *bank, int gpio)
+static int _get_gpio_datain(struct gpio_bank *bank, int offset)
 {
         void __iomem *reg = bank->base + bank->regs->datain;
 
-        return (__raw_readl(reg) & GPIO_BIT(bank, gpio)) != 0;
+        return (__raw_readl(reg) & (1 << offset)) != 0;
 }
 
-static int _get_gpio_dataout(struct gpio_bank *bank, int gpio)
+static int _get_gpio_dataout(struct gpio_bank *bank, int offset)
 {
         void __iomem *reg = bank->base + bank->regs->dataout;
 
-        return (__raw_readl(reg) & GPIO_BIT(bank, gpio)) != 0;
+        return (__raw_readl(reg) & (1 << offset)) != 0;
 }
 
 static inline void _gpio_rmw(void __iomem *base, u32 reg, u32 mask, bool set)
 {
         int l = __raw_readl(base + reg);
 
-        if (set) 
+        if (set)
                 l |= mask;
         else
                 l &= ~mask;
@@ -238,7 +248,7 @@ static void _set_gpio_debounce(struct gpio_bank *bank, unsigned gpio,
 }
 
 static inline void set_gpio_trigger(struct gpio_bank *bank, int gpio,
-                                                int trigger)
+                                                unsigned trigger)
 {
         void __iomem *base = bank->base;
         u32 gpio_bit = 1 << gpio;
@@ -320,7 +330,8 @@ static void _toggle_gpio_edge_triggering(struct gpio_bank *bank, int gpio)
 static void _toggle_gpio_edge_triggering(struct gpio_bank *bank, int gpio) {}
 #endif
 
-static int _set_gpio_triggering(struct gpio_bank *bank, int gpio, int trigger)
+static int _set_gpio_triggering(struct gpio_bank *bank, int gpio,
+                                                        unsigned trigger)
 {
         void __iomem *reg = bank->base;
         void __iomem *base = bank->base;
@@ -367,7 +378,7 @@ static int _set_gpio_triggering(struct gpio_bank *bank, int gpio, int trigger)
 
 static int gpio_irq_type(struct irq_data *d, unsigned type)
 {
-        struct gpio_bank *bank;
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
         unsigned gpio;
         int retval;
         unsigned long flags;
@@ -375,13 +386,11 @@ static int gpio_irq_type(struct irq_data *d, unsigned type)
         if (!cpu_class_is_omap2() && d->irq > IH_MPUIO_BASE)
                 gpio = OMAP_MPUIO(d->irq - IH_MPUIO_BASE);
         else
-                gpio = d->irq - IH_GPIO_BASE;
+                gpio = irq_to_gpio(bank, d->irq);
 
         if (type & ~IRQ_TYPE_SENSE_MASK)
                 return -EINVAL;
 
-        bank = irq_data_get_irq_chip_data(d);
-
         if (!bank->regs->leveldetect0 &&
                 (type & (IRQ_TYPE_LEVEL_LOW|IRQ_TYPE_LEVEL_HIGH)))
                 return -EINVAL;
@@ -442,6 +451,7 @@ static void _enable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
         if (bank->regs->set_irqenable) {
                 reg += bank->regs->set_irqenable;
                 l = gpio_mask;
+                bank->context.irqenable1 |= gpio_mask;
         } else {
                 reg += bank->regs->irqenable;
                 l = __raw_readl(reg);
@@ -449,10 +459,10 @@ static void _enable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
                         l &= ~gpio_mask;
                 else
                         l |= gpio_mask;
+                bank->context.irqenable1 = l;
         }
 
         __raw_writel(l, reg);
-        bank->context.irqenable1 = l;
 }
 
 static void _disable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
@@ -463,6 +473,7 @@ static void _disable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
         if (bank->regs->clr_irqenable) {
                 reg += bank->regs->clr_irqenable;
                 l = gpio_mask;
+                bank->context.irqenable1 &= ~gpio_mask;
         } else {
                 reg += bank->regs->irqenable;
                 l = __raw_readl(reg);
@@ -470,15 +481,18 @@ static void _disable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
                         l |= gpio_mask;
                 else
                         l &= ~gpio_mask;
+                bank->context.irqenable1 = l;
         }
 
         __raw_writel(l, reg);
-        bank->context.irqenable1 = l;
 }
 
 static inline void _set_gpio_irqenable(struct gpio_bank *bank, int gpio, int enable)
 {
-        _enable_gpio_irqbank(bank, GPIO_BIT(bank, gpio));
+        if (enable)
+                _enable_gpio_irqbank(bank, GPIO_BIT(bank, gpio));
+        else
+                _disable_gpio_irqbank(bank, GPIO_BIT(bank, gpio));
 }
 
 /*
@@ -495,7 +509,7 @@ static int _set_gpio_wakeup(struct gpio_bank *bank, int gpio, int enable)
         unsigned long flags;
 
         if (bank->non_wakeup_gpios & gpio_bit) {
-                dev_err(bank->dev, 
+                dev_err(bank->dev,
                         "Unable to modify wakeup on non-wakeup GPIO%d\n", gpio);
                 return -EINVAL;
         }
@@ -506,6 +520,7 @@ static int _set_gpio_wakeup(struct gpio_bank *bank, int gpio, int enable)
         else
                 bank->suspend_wakeup &= ~gpio_bit;
 
+        __raw_writel(bank->suspend_wakeup, bank->base + bank->regs->wkup_en);
         spin_unlock_irqrestore(&bank->lock, flags);
 
         return 0;
@@ -522,14 +537,10 @@ static void _reset_gpio(struct gpio_bank *bank, int gpio)
 /* Use disable_irq_wake() and enable_irq_wake() functions from drivers */
 static int gpio_wake_enable(struct irq_data *d, unsigned int enable)
 {
-        unsigned int gpio = d->irq - IH_GPIO_BASE;
-        struct gpio_bank *bank;
-        int retval;
-
-        bank = irq_data_get_irq_chip_data(d);
-        retval = _set_gpio_wakeup(bank, gpio, enable);
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irq_to_gpio(bank, d->irq);
 
-        return retval;
+        return _set_gpio_wakeup(bank, gpio, enable);
 }
 
 static int omap_gpio_request(struct gpio_chip *chip, unsigned offset)
@@ -671,13 +682,15 @@ static void gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
                 if (!isr)
                         break;
 
-                gpio_irq = bank->virtual_irq_start;
+                gpio_irq = bank->irq_base;
                 for (; isr != 0; isr >>= 1, gpio_irq++) {
-                        gpio_index = GPIO_INDEX(bank, irq_to_gpio(gpio_irq));
+                        int gpio = irq_to_gpio(bank, gpio_irq);
 
                         if (!(isr & 1))
                                 continue;
 
+                        gpio_index = GPIO_INDEX(bank, gpio);
+
                         /*
                          * Some chips can't respond to both rising and falling
                          * at the same time.  If this irq was requested with
@@ -703,8 +716,8 @@ exit:
 
 static void gpio_irq_shutdown(struct irq_data *d)
 {
-        unsigned int gpio = d->irq - IH_GPIO_BASE;
         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irq_to_gpio(bank, d->irq);
         unsigned long flags;
 
         spin_lock_irqsave(&bank->lock, flags);
@@ -714,16 +727,16 @@ static void gpio_irq_shutdown(struct irq_data *d)
 
 static void gpio_ack_irq(struct irq_data *d)
 {
-        unsigned int gpio = d->irq - IH_GPIO_BASE;
         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irq_to_gpio(bank, d->irq);
 
         _clear_gpio_irqstatus(bank, gpio);
 }
 
 static void gpio_mask_irq(struct irq_data *d)
 {
-        unsigned int gpio = d->irq - IH_GPIO_BASE;
         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irq_to_gpio(bank, d->irq);
         unsigned long flags;
 
         spin_lock_irqsave(&bank->lock, flags);
@@ -734,8 +747,8 @@ static void gpio_mask_irq(struct irq_data *d)
 
 static void gpio_unmask_irq(struct irq_data *d)
 {
-        unsigned int gpio = d->irq - IH_GPIO_BASE;
         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+        unsigned int gpio = irq_to_gpio(bank, d->irq);
         unsigned int irq_mask = GPIO_BIT(bank, gpio);
         u32 trigger = irqd_get_trigger_type(d);
         unsigned long flags;
@@ -852,19 +865,15 @@ static int gpio_is_input(struct gpio_bank *bank, int mask)
 static int gpio_get(struct gpio_chip *chip, unsigned offset)
 {
         struct gpio_bank *bank;
-        void __iomem *reg;
-        int gpio;
         u32 mask;
 
-        gpio = chip->base + offset;
         bank = container_of(chip, struct gpio_bank, chip);
-        reg = bank->base;
-        mask = GPIO_BIT(bank, gpio);
+        mask = (1 << offset);
 
         if (gpio_is_input(bank, mask))
-                return _get_gpio_datain(bank, gpio);
+                return _get_gpio_datain(bank, offset);
         else
-                return _get_gpio_dataout(bank, gpio);
+                return _get_gpio_dataout(bank, offset);
 }
 
 static int gpio_output(struct gpio_chip *chip, unsigned offset, int value)
@@ -917,7 +926,7 @@ static int gpio_2irq(struct gpio_chip *chip, unsigned offset)
         struct gpio_bank *bank;
 
         bank = container_of(chip, struct gpio_bank, chip);
-        return bank->virtual_irq_start + offset;
+        return bank->irq_base + offset;
 }
 
 /*---------------------------------------------------------------------*/
@@ -970,7 +979,7 @@ static void omap_gpio_mod_init(struct gpio_bank *bank)
                 _gpio_rmw(base, bank->regs->ctrl, 0, 1);
 }
 
-static __init void
+static __devinit void
 omap_mpuio_alloc_gc(struct gpio_bank *bank, unsigned int irq_start,
                     unsigned int num)
 {
@@ -1030,8 +1039,7 @@ static void __devinit omap_gpio_chip_init(struct gpio_bank *bank)
 
         gpiochip_add(&bank->chip);
 
-        for (j = bank->virtual_irq_start;
-                     j < bank->virtual_irq_start + bank->width; j++) {
+        for (j = bank->irq_base; j < bank->irq_base + bank->width; j++) {
                 irq_set_lockdep_class(j, &gpio_lock_class);
                 irq_set_chip_data(j, bank);
                 if (bank->is_mpuio) {
@@ -1046,39 +1054,38 @@ static void __devinit omap_gpio_chip_init(struct gpio_bank *bank)
         irq_set_handler_data(bank->irq, bank);
 }
 
+static const struct of_device_id omap_gpio_match[];
+
 static int __devinit omap_gpio_probe(struct platform_device *pdev)
 {
+        struct device *dev = &pdev->dev;
+        struct device_node *node = dev->of_node;
+        const struct of_device_id *match;
         struct omap_gpio_platform_data *pdata;
         struct resource *res;
         struct gpio_bank *bank;
         int ret = 0;
 
-        if (!pdev->dev.platform_data) {
-                ret = -EINVAL;
-                goto err_exit;
-        }
+        match = of_match_device(of_match_ptr(omap_gpio_match), dev);
+
+        pdata = match ? match->data : dev->platform_data;
+        if (!pdata)
+                return -EINVAL;
 
-        bank = kzalloc(sizeof(struct gpio_bank), GFP_KERNEL);
+        bank = devm_kzalloc(&pdev->dev, sizeof(struct gpio_bank), GFP_KERNEL);
         if (!bank) {
-                dev_err(&pdev->dev, "Memory alloc failed for gpio_bank\n");
-                ret = -ENOMEM;
-                goto err_exit;
+                dev_err(dev, "Memory alloc failed\n");
+                return -ENOMEM;
         }
 
         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (unlikely(!res)) {
-                dev_err(&pdev->dev, "GPIO Bank %i Invalid IRQ resource\n",
-                                pdev->id);
-                ret = -ENODEV;
-                goto err_free;
+                dev_err(dev, "Invalid IRQ resource\n");
+                return -ENODEV;
         }
 
         bank->irq = res->start;
-        bank->id = pdev->id;
-
-        pdata = pdev->dev.platform_data;
-        bank->virtual_irq_start = pdata->virtual_irq_start;
-        bank->dev = &pdev->dev;
+        bank->dev = dev;
         bank->dbck_flag = pdata->dbck_flag;
         bank->stride = pdata->bank_stride;
         bank->width = pdata->bank_width;
@@ -1087,6 +1094,18 @@ static int __devinit omap_gpio_probe(struct platform_device *pdev)
         bank->loses_context = pdata->loses_context;
         bank->get_context_loss_count = pdata->get_context_loss_count;
         bank->regs = pdata->regs;
+#ifdef CONFIG_OF_GPIO
+        bank->chip.of_node = of_node_get(node);
+#endif
+
+        bank->irq_base = irq_alloc_descs(-1, 0, bank->width, 0);
+        if (bank->irq_base < 0) {
+                dev_err(dev, "Couldn't allocate IRQ numbers\n");
+                return -ENODEV;
+        }
+
+        bank->domain = irq_domain_add_legacy(node, bank->width, bank->irq_base,
+                                             0, &irq_domain_simple_ops, NULL);
 
         if (bank->regs->set_dataout && bank->regs->clr_dataout)
                 bank->set_dataout = _set_gpio_dataout_reg;
@@ -1098,18 +1117,20 @@ static int __devinit omap_gpio_probe(struct platform_device *pdev)
         /* Static mapping, never released */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (unlikely(!res)) {
-                dev_err(&pdev->dev, "GPIO Bank %i Invalid mem resource\n",
-                                pdev->id);
-                ret = -ENODEV;
-                goto err_free;
+                dev_err(dev, "Invalid mem resource\n");
+                return -ENODEV;
         }
 
-        bank->base = ioremap(res->start, resource_size(res));
+        if (!devm_request_mem_region(dev, res->start, resource_size(res),
+                                     pdev->name)) {
+                dev_err(dev, "Region already claimed\n");
+                return -EBUSY;
+        }
+
+        bank->base = devm_ioremap(dev, res->start, resource_size(res));
         if (!bank->base) {
-                dev_err(&pdev->dev, "Could not ioremap gpio bank%i\n",
-                                pdev->id);
-                ret = -ENOMEM;
-                goto err_free;
+                dev_err(dev, "Could not ioremap\n");
+                return -ENOMEM;
         }
 
         platform_set_drvdata(pdev, bank);
@@ -1130,11 +1151,6 @@ static int __devinit omap_gpio_probe(struct platform_device *pdev)
         list_add_tail(&bank->node, &omap_gpio_list);
 
         return ret;
-
-err_free:
-        kfree(bank);
-err_exit:
-        return ret;
 }
 
 #ifdef CONFIG_ARCH_OMAP2PLUS
@@ -1196,8 +1212,30 @@ static int omap_gpio_runtime_suspend(struct device *dev)
         struct gpio_bank *bank = platform_get_drvdata(pdev);
         u32 l1 = 0, l2 = 0;
         unsigned long flags;
+        u32 wake_low, wake_hi;
 
         spin_lock_irqsave(&bank->lock, flags);
+
+        /*
+         * Only edges can generate a wakeup event to the PRCM.
+         *
+         * Therefore, ensure any wake-up capable GPIOs have
+         * edge-detection enabled before going idle to ensure a wakeup
+         * to the PRCM is generated on a GPIO transition. (c.f. 34xx
+         * NDA TRM 25.5.3.1)
+         *
+         * The normal values will be restored upon ->runtime_resume()
+         * by writing back the values saved in bank->context.
+         */
+        wake_low = bank->context.leveldetect0 & bank->context.wake_en;
+        if (wake_low)
+                __raw_writel(wake_low | bank->context.fallingdetect,
+                             bank->base + bank->regs->fallingdetect);
+        wake_hi = bank->context.leveldetect1 & bank->context.wake_en;
+        if (wake_hi)
+                __raw_writel(wake_hi | bank->context.risingdetect,
+                             bank->base + bank->regs->risingdetect);
+
         if (bank->power_mode != OFF_MODE) {
                 bank->power_mode = 0;
                 goto update_gpio_context_count;
@@ -1207,9 +1245,6 @@ static int omap_gpio_runtime_suspend(struct device *dev)
          * non-wakeup GPIOs.  Otherwise spurious IRQs will be
          * generated.  See OMAP2420 Errata item 1.101.
          */
-        if (!(bank->enabled_non_wakeup_gpios))
-                goto update_gpio_context_count;
-
         bank->saved_datain = __raw_readl(bank->base +
                                                 bank->regs->datain);
         l1 = __raw_readl(bank->base + bank->regs->fallingdetect);
@@ -1246,7 +1281,19 @@ static int omap_gpio_runtime_resume(struct device *dev)
 
         spin_lock_irqsave(&bank->lock, flags);
         _gpio_dbck_enable(bank);
-        if (!bank->enabled_non_wakeup_gpios || !bank->workaround_enabled) {
+
+        /*
+         * In ->runtime_suspend(), level-triggered, wakeup-enabled
+         * GPIOs were set to edge trigger also in order to be able to
+         * generate a PRCM wakeup.  Here we restore the
+         * pre-runtime_suspend() values for edge triggering.
+         */
+        __raw_writel(bank->context.fallingdetect,
+                     bank->base + bank->regs->fallingdetect);
+        __raw_writel(bank->context.risingdetect,
+                     bank->base + bank->regs->risingdetect);
+
+        if (!bank->workaround_enabled) {
                 spin_unlock_irqrestore(&bank->lock, flags);
                 return 0;
         }
@@ -1397,11 +1444,95 @@ static const struct dev_pm_ops gpio_pm_ops = {
                                                                         NULL)
 };
 
+#if defined(CONFIG_OF)
+static struct omap_gpio_reg_offs omap2_gpio_regs = {
+        .revision =             OMAP24XX_GPIO_REVISION,
+        .direction =            OMAP24XX_GPIO_OE,
+        .datain =               OMAP24XX_GPIO_DATAIN,
+        .dataout =              OMAP24XX_GPIO_DATAOUT,
+        .set_dataout =          OMAP24XX_GPIO_SETDATAOUT,
+        .clr_dataout =          OMAP24XX_GPIO_CLEARDATAOUT,
+        .irqstatus =            OMAP24XX_GPIO_IRQSTATUS1,
+        .irqstatus2 =           OMAP24XX_GPIO_IRQSTATUS2,
+        .irqenable =            OMAP24XX_GPIO_IRQENABLE1,
+        .irqenable2 =           OMAP24XX_GPIO_IRQENABLE2,
+        .set_irqenable =        OMAP24XX_GPIO_SETIRQENABLE1,
+        .clr_irqenable =        OMAP24XX_GPIO_CLEARIRQENABLE1,
+        .debounce =             OMAP24XX_GPIO_DEBOUNCE_VAL,
+        .debounce_en =          OMAP24XX_GPIO_DEBOUNCE_EN,
+        .ctrl =                 OMAP24XX_GPIO_CTRL,
+        .wkup_en =              OMAP24XX_GPIO_WAKE_EN,
+        .leveldetect0 =         OMAP24XX_GPIO_LEVELDETECT0,
+        .leveldetect1 =         OMAP24XX_GPIO_LEVELDETECT1,
+        .risingdetect =         OMAP24XX_GPIO_RISINGDETECT,
+        .fallingdetect =        OMAP24XX_GPIO_FALLINGDETECT,
+};
+
+static struct omap_gpio_reg_offs omap4_gpio_regs = {
+        .revision =             OMAP4_GPIO_REVISION,
+        .direction =            OMAP4_GPIO_OE,
+        .datain =               OMAP4_GPIO_DATAIN,
+        .dataout =              OMAP4_GPIO_DATAOUT,
+        .set_dataout =          OMAP4_GPIO_SETDATAOUT,
+        .clr_dataout =          OMAP4_GPIO_CLEARDATAOUT,
+        .irqstatus =            OMAP4_GPIO_IRQSTATUS0,
+        .irqstatus2 =           OMAP4_GPIO_IRQSTATUS1,
+        .irqenable =            OMAP4_GPIO_IRQSTATUSSET0,
+        .irqenable2 =           OMAP4_GPIO_IRQSTATUSSET1,
+        .set_irqenable =        OMAP4_GPIO_IRQSTATUSSET0,
+        .clr_irqenable =        OMAP4_GPIO_IRQSTATUSCLR0,
+        .debounce =             OMAP4_GPIO_DEBOUNCINGTIME,
+        .debounce_en =          OMAP4_GPIO_DEBOUNCENABLE,
+        .ctrl =                 OMAP4_GPIO_CTRL,
+        .wkup_en =              OMAP4_GPIO_IRQWAKEN0,
+        .leveldetect0 =         OMAP4_GPIO_LEVELDETECT0,
+        .leveldetect1 =         OMAP4_GPIO_LEVELDETECT1,
+        .risingdetect =         OMAP4_GPIO_RISINGDETECT,
+        .fallingdetect =        OMAP4_GPIO_FALLINGDETECT,
+};
+
+static struct omap_gpio_platform_data omap2_pdata = {
+        .regs = &omap2_gpio_regs,
+        .bank_width = 32,
+        .dbck_flag = false,
+};
+
+static struct omap_gpio_platform_data omap3_pdata = {
+        .regs = &omap2_gpio_regs,
+        .bank_width = 32,
+        .dbck_flag = true,
+};
+
+static struct omap_gpio_platform_data omap4_pdata = {
+        .regs = &omap4_gpio_regs,
+        .bank_width = 32,
+        .dbck_flag = true,
+};
+
+static const struct of_device_id omap_gpio_match[] = {
+        {
+                .compatible = "ti,omap4-gpio",
+                .data = &omap4_pdata,
+        },
+        {
+                .compatible = "ti,omap3-gpio",
+                .data = &omap3_pdata,
+        },
+        {
+                .compatible = "ti,omap2-gpio",
+                .data = &omap2_pdata,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(of, omap_gpio_match);
+#endif
+
 static struct platform_driver omap_gpio_driver = {
         .probe          = omap_gpio_probe,
         .driver         = {
                 .name   = "omap_gpio",
                 .pm     = &gpio_pm_ops,
+                .of_match_table = of_match_ptr(omap_gpio_match),
         },
 };
 
diff --git a/drivers/gpio/gpio-pl061.c b/drivers/gpio/gpio-pl061.c
index 77c9cc70fa77..b4b5da4fd2cc 100644
--- a/drivers/gpio/gpio-pl061.c
+++ b/drivers/gpio/gpio-pl061.c
@@ -352,7 +352,12 @@ static int pl061_resume(struct device *dev)
         return 0;
 }
 
-static SIMPLE_DEV_PM_OPS(pl061_dev_pm_ops, pl061_suspend, pl061_resume);
+static const struct dev_pm_ops pl061_dev_pm_ops = {
+        .suspend = pl061_suspend,
+        .resume = pl061_resume,
+        .freeze = pl061_suspend,
+        .restore = pl061_resume,
+};
 #endif
 
 static struct amba_id pl061_ids[] = {
diff --git a/drivers/gpio/gpio-sodaville.c b/drivers/gpio/gpio-sodaville.c
new file mode 100644
index 000000000000..9ba15d31d242
--- /dev/null
+++ b/drivers/gpio/gpio-sodaville.c
@@ -0,0 +1,302 @@
+/*
+ *  GPIO interface for Intel Sodaville SoCs.
+ *
+ *  Copyright (c) 2010, 2011 Intel Corporation
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License 2 as published
+ *  by the Free Software Foundation.
+ *
+ */
+
+#include <linux/errno.h>
+#include <linux/gpio.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/platform_device.h>
+#include <linux/of_irq.h>
+#include <linux/basic_mmio_gpio.h>
+
+#define DRV_NAME                "sdv_gpio"
+#define SDV_NUM_PUB_GPIOS       12
+#define PCI_DEVICE_ID_SDV_GPIO  0x2e67
+#define GPIO_BAR                0
+
+#define GPOUTR          0x00
+#define GPOER           0x04
+#define GPINR           0x08
+
+#define GPSTR           0x0c
+#define GPIT1R0         0x10
+#define GPIO_INT        0x14
+#define GPIT1R1         0x18
+
+#define GPMUXCTL        0x1c
+
+struct sdv_gpio_chip_data {
+        int irq_base;
+        void __iomem *gpio_pub_base;
+        struct irq_domain id;
+        struct irq_chip_generic *gc;
+        struct bgpio_chip bgpio;
+};
+
+static int sdv_gpio_pub_set_type(struct irq_data *d, unsigned int type)
+{
+        struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
+        struct sdv_gpio_chip_data *sd = gc->private;
+        void __iomem *type_reg;
+        u32 irq_offs = d->irq - sd->irq_base;
+        u32 reg;
+
+        if (irq_offs < 8)
+                type_reg = sd->gpio_pub_base + GPIT1R0;
+        else
+                type_reg = sd->gpio_pub_base + GPIT1R1;
+
+        reg = readl(type_reg);
+
+        switch (type) {
+        case IRQ_TYPE_LEVEL_HIGH:
+                reg &= ~BIT(4 * (irq_offs % 8));
+                break;
+
+        case IRQ_TYPE_LEVEL_LOW:
+                reg |= BIT(4 * (irq_offs % 8));
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        writel(reg, type_reg);
+        return 0;
+}
+
+static irqreturn_t sdv_gpio_pub_irq_handler(int irq, void *data)
+{
+        struct sdv_gpio_chip_data *sd = data;
+        u32 irq_stat = readl(sd->gpio_pub_base + GPSTR);
+
+        irq_stat &= readl(sd->gpio_pub_base + GPIO_INT);
+        if (!irq_stat)
+                return IRQ_NONE;
+
+        while (irq_stat) {
+                u32 irq_bit = __fls(irq_stat);
+
+                irq_stat &= ~BIT(irq_bit);
+                generic_handle_irq(sd->irq_base + irq_bit);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int sdv_xlate(struct irq_domain *h, struct device_node *node,
+                const u32 *intspec, u32 intsize, irq_hw_number_t *out_hwirq,
+                u32 *out_type)
+{
+        u32 line, type;
+
+        if (node != h->of_node)
+                return -EINVAL;
+
+        if (intsize < 2)
+                return -EINVAL;
+
+        line = *intspec;
+        *out_hwirq = line;
+
+        intspec++;
+        type = *intspec;
+
+        switch (type) {
+        case IRQ_TYPE_LEVEL_LOW:
+        case IRQ_TYPE_LEVEL_HIGH:
+                *out_type = type;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static struct irq_domain_ops irq_domain_sdv_ops = {
+        .dt_translate   = sdv_xlate,
+};
+
+static __devinit int sdv_register_irqsupport(struct sdv_gpio_chip_data *sd,
+                struct pci_dev *pdev)
+{
+        struct irq_chip_type *ct;
+        int ret;
+
+        sd->irq_base = irq_alloc_descs(-1, 0, SDV_NUM_PUB_GPIOS, -1);
+        if (sd->irq_base < 0)
+                return sd->irq_base;
+
+        /* mask + ACK all interrupt sources */
+        writel(0, sd->gpio_pub_base + GPIO_INT);
+        writel((1 << 11) - 1, sd->gpio_pub_base + GPSTR);
+
+        ret = request_irq(pdev->irq, sdv_gpio_pub_irq_handler, IRQF_SHARED,
+                        "sdv_gpio", sd);
+        if (ret)
+                goto out_free_desc;
+
+        sd->id.irq_base = sd->irq_base;
+        sd->id.of_node = of_node_get(pdev->dev.of_node);
+        sd->id.ops = &irq_domain_sdv_ops;
+
+        /*
+         * This gpio irq controller latches level irqs. Testing shows that if
+         * we unmask & ACK the IRQ before the source of the interrupt is gone
+         * then the interrupt is active again.
+         */
+        sd->gc = irq_alloc_generic_chip("sdv-gpio", 1, sd->irq_base,
+                        sd->gpio_pub_base, handle_fasteoi_irq);
+        if (!sd->gc) {
+                ret = -ENOMEM;
+                goto out_free_irq;
+        }
+
+        sd->gc->private = sd;
+        ct = sd->gc->chip_types;
+        ct->type = IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW;
+        ct->regs.eoi = GPSTR;
+        ct->regs.mask = GPIO_INT;
+        ct->chip.irq_mask = irq_gc_mask_clr_bit;
+        ct->chip.irq_unmask = irq_gc_mask_set_bit;
+        ct->chip.irq_eoi = irq_gc_eoi;
+        ct->chip.irq_set_type = sdv_gpio_pub_set_type;
+
+        irq_setup_generic_chip(sd->gc, IRQ_MSK(SDV_NUM_PUB_GPIOS),
+                        IRQ_GC_INIT_MASK_CACHE, IRQ_NOREQUEST,
+                        IRQ_LEVEL | IRQ_NOPROBE);
+
+        irq_domain_add(&sd->id);
+        return 0;
+out_free_irq:
+        free_irq(pdev->irq, sd);
+out_free_desc:
+        irq_free_descs(sd->irq_base, SDV_NUM_PUB_GPIOS);
+        return ret;
+}
+
+static int __devinit sdv_gpio_probe(struct pci_dev *pdev,
+                                        const struct pci_device_id *pci_id)
+{
+        struct sdv_gpio_chip_data *sd;
+        unsigned long addr;
+        const void *prop;
+        int len;
+        int ret;
+        u32 mux_val;
+
+        sd = kzalloc(sizeof(struct sdv_gpio_chip_data), GFP_KERNEL);
+        if (!sd)
+                return -ENOMEM;
+        ret = pci_enable_device(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "can't enable device.\n");
+                goto done;
+        }
+
+        ret = pci_request_region(pdev, GPIO_BAR, DRV_NAME);
+        if (ret) {
+                dev_err(&pdev->dev, "can't alloc PCI BAR #%d\n", GPIO_BAR);
+                goto disable_pci;
+        }
+
+        addr = pci_resource_start(pdev, GPIO_BAR);
+        if (!addr)
+                goto release_reg;
+        sd->gpio_pub_base = ioremap(addr, pci_resource_len(pdev, GPIO_BAR));
+
+        prop = of_get_property(pdev->dev.of_node, "intel,muxctl", &len);
+        if (prop && len == 4) {
+                mux_val = of_read_number(prop, 1);
+                writel(mux_val, sd->gpio_pub_base + GPMUXCTL);
+        }
+
+        ret = bgpio_init(&sd->bgpio, &pdev->dev, 4,
+                        sd->gpio_pub_base + GPINR, sd->gpio_pub_base + GPOUTR,
+                        NULL, sd->gpio_pub_base + GPOER, NULL, false);
+        if (ret)
+                goto unmap;
+        sd->bgpio.gc.ngpio = SDV_NUM_PUB_GPIOS;
+
+        ret = gpiochip_add(&sd->bgpio.gc);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "gpiochip_add() failed.\n");
+                goto unmap;
+        }
+
+        ret = sdv_register_irqsupport(sd, pdev);
+        if (ret)
+                goto unmap;
+
+        pci_set_drvdata(pdev, sd);
+        dev_info(&pdev->dev, "Sodaville GPIO driver registered.\n");
+        return 0;
+
+unmap:
+        iounmap(sd->gpio_pub_base);
+release_reg:
+        pci_release_region(pdev, GPIO_BAR);
+disable_pci:
+        pci_disable_device(pdev);
+done:
+        kfree(sd);
+        return ret;
+}
+
+static void sdv_gpio_remove(struct pci_dev *pdev)
+{
+        struct sdv_gpio_chip_data *sd = pci_get_drvdata(pdev);
+
+        irq_domain_del(&sd->id);
+        free_irq(pdev->irq, sd);
+        irq_free_descs(sd->irq_base, SDV_NUM_PUB_GPIOS);
+
+        if (gpiochip_remove(&sd->bgpio.gc))
+                dev_err(&pdev->dev, "gpiochip_remove() failed.\n");
+
+        pci_release_region(pdev, GPIO_BAR);
+        iounmap(sd->gpio_pub_base);
+        pci_disable_device(pdev);
+        kfree(sd);
+}
+
+static struct pci_device_id sdv_gpio_pci_ids[] __devinitdata = {
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_SDV_GPIO) },
+        { 0, },
+};
+
+static struct pci_driver sdv_gpio_driver = {
+        .name = DRV_NAME,
+        .id_table = sdv_gpio_pci_ids,
+        .probe = sdv_gpio_probe,
+        .remove = sdv_gpio_remove,
+};
+
+static int __init sdv_gpio_init(void)
+{
+        return pci_register_driver(&sdv_gpio_driver);
+}
+module_init(sdv_gpio_init);
+
+static void __exit sdv_gpio_exit(void)
+{
+        pci_unregister_driver(&sdv_gpio_driver);
+}
+module_exit(sdv_gpio_exit);
+
+MODULE_AUTHOR("Hans J. Koch <hjk@linutronix.de>");
+MODULE_DESCRIPTION("GPIO interface for Intel Sodaville SoCs");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/gpio/gpio-stmpe.c b/drivers/gpio/gpio-stmpe.c
index 094c5c4fd7f2..dce34727bbf8 100644
--- a/drivers/gpio/gpio-stmpe.c
+++ b/drivers/gpio/gpio-stmpe.c
@@ -54,7 +54,7 @@ static int stmpe_gpio_get(struct gpio_chip *chip, unsigned offset)
         if (ret < 0)
                 return ret;
 
-        return ret & mask;
+        return !!(ret & mask);
 }
 
 static void stmpe_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
diff --git a/drivers/gpio/gpio-tegra.c b/drivers/gpio/gpio-tegra.c
index 6f17671260e1..32de6707e3c4 100644
--- a/drivers/gpio/gpio-tegra.c
+++ b/drivers/gpio/gpio-tegra.c
@@ -109,11 +109,13 @@ void tegra_gpio_enable(int gpio)
 {
         tegra_gpio_mask_write(GPIO_MSK_CNF(gpio), gpio, 1);
 }
+EXPORT_SYMBOL_GPL(tegra_gpio_enable);
 
 void tegra_gpio_disable(int gpio)
 {
         tegra_gpio_mask_write(GPIO_MSK_CNF(gpio), gpio, 0);
 }
+EXPORT_SYMBOL_GPL(tegra_gpio_disable);
 
 static void tegra_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
@@ -459,7 +461,7 @@ static int __init tegra_gpio_init(void)
 }
 postcore_initcall(tegra_gpio_init);
 
-void __init tegra_gpio_config(struct tegra_gpio_table *table, int num)
+void tegra_gpio_config(struct tegra_gpio_table *table, int num)
 {
         int i;
 
diff --git a/drivers/gpio/gpio-tps65910.c b/drivers/gpio/gpio-tps65910.c
index 91f45b965d1e..7eef648a3351 100644
--- a/drivers/gpio/gpio-tps65910.c
+++ b/drivers/gpio/gpio-tps65910.c
@@ -69,6 +69,7 @@ static int tps65910_gpio_input(struct gpio_chip *gc, unsigned offset)
 void tps65910_gpio_init(struct tps65910 *tps65910, int gpio_base)
 {
         int ret;
+        struct tps65910_board *board_data;
 
         if (!gpio_base)
                 return;
@@ -80,10 +81,10 @@ void tps65910_gpio_init(struct tps65910 *tps65910, int gpio_base)
 
         switch(tps65910_chip_id(tps65910)) {
         case TPS65910:
-                tps65910->gpio.ngpio    = 6;
+                tps65910->gpio.ngpio    = TPS65910_NUM_GPIO;
                 break;
         case TPS65911:
-                tps65910->gpio.ngpio    = 9;
+                tps65910->gpio.ngpio    = TPS65911_NUM_GPIO;
                 break;
         default:
                 return;
@@ -95,6 +96,21 @@ void tps65910_gpio_init(struct tps65910 *tps65910, int gpio_base)
         tps65910->gpio.set              = tps65910_gpio_set;
         tps65910->gpio.get              = tps65910_gpio_get;
 
+        /* Configure sleep control for gpios */
+        board_data = dev_get_platdata(tps65910->dev);
+        if (board_data) {
+                int i;
+                for (i = 0; i < tps65910->gpio.ngpio; ++i) {
+                        if (board_data->en_gpio_sleep[i]) {
+                                ret = tps65910_set_bits(tps65910,
+                                        TPS65910_GPIO0 + i, GPIO_SLEEP_MASK);
+                                if (ret < 0)
+                                        dev_warn(tps65910->dev,
+                                                "GPIO Sleep setting failed\n");
+                        }
+                }
+        }
+
         ret = gpiochip_add(&tps65910->gpio);
 
         if (ret)
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 17fdf4b6af93..5a75510d66bb 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -58,6 +58,8 @@ struct gpio_desc {
 #define FLAG_TRIG_FALL  5       /* trigger on falling edge */
 #define FLAG_TRIG_RISE  6       /* trigger on rising edge */
 #define FLAG_ACTIVE_LOW 7       /* sysfs value has active low */
+#define FLAG_OPEN_DRAIN 8       /* Gpio is open drain type */
+#define FLAG_OPEN_SOURCE 9      /* Gpio is open source type */
 
 #define ID_SHIFT        16      /* add new flags before this one */
 
@@ -873,6 +875,7 @@ void gpio_unexport(unsigned gpio)
 {
         struct gpio_desc        *desc;
         int                     status = 0;
+        struct device           *dev = NULL;
 
         if (!gpio_is_valid(gpio)) {
                 status = -EINVAL;
@@ -884,19 +887,20 @@ void gpio_unexport(unsigned gpio)
         desc = &gpio_desc[gpio];
 
         if (test_bit(FLAG_EXPORT, &desc->flags)) {
-                struct device   *dev = NULL;
 
                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
                 if (dev) {
                         gpio_setup_irq(desc, dev, 0);
                         clear_bit(FLAG_EXPORT, &desc->flags);
-                        put_device(dev);
-                        device_unregister(dev);
                 } else
                         status = -ENODEV;
         }
 
         mutex_unlock(&sysfs_lock);
+        if (dev) {
+                device_unregister(dev);
+                put_device(dev);
+        }
 done:
         if (status)
                 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
@@ -1150,8 +1154,9 @@ EXPORT_SYMBOL_GPL(gpiochip_remove);
  * non-zero, this function will return to the caller and not iterate over any
  * more gpio_chips.
  */
-struct gpio_chip *gpiochip_find(void *data,
-                                int (*match)(struct gpio_chip *chip, void *data))
+struct gpio_chip *gpiochip_find(const void *data,
+                                int (*match)(struct gpio_chip *chip,
+                                             const void *data))
 {
         struct gpio_chip *chip = NULL;
         unsigned long flags;
@@ -1261,6 +1266,8 @@ void gpio_free(unsigned gpio)
                 module_put(desc->chip->owner);
                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
                 clear_bit(FLAG_REQUESTED, &desc->flags);
+                clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
+                clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
         } else
                 WARN_ON(extra_checks);
 
@@ -1282,6 +1289,12 @@ int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
         if (err)
                 return err;
 
+        if (flags & GPIOF_OPEN_DRAIN)
+                set_bit(FLAG_OPEN_DRAIN, &gpio_desc[gpio].flags);
+
+        if (flags & GPIOF_OPEN_SOURCE)
+                set_bit(FLAG_OPEN_SOURCE, &gpio_desc[gpio].flags);
+
         if (flags & GPIOF_DIR_IN)
                 err = gpio_direction_input(gpio);
         else
@@ -1431,6 +1444,14 @@ int gpio_direction_output(unsigned gpio, int value)
         struct gpio_desc        *desc = &gpio_desc[gpio];
         int                     status = -EINVAL;
 
+        /* Open drain pin should not be driven to 1 */
+        if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
+                return gpio_direction_input(gpio);
+
+        /* Open source pin should not be driven to 0 */
+        if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
+                return gpio_direction_input(gpio);
+
         spin_lock_irqsave(&gpio_lock, flags);
 
         if (!gpio_is_valid(gpio))
@@ -1560,6 +1581,7 @@ int __gpio_get_value(unsigned gpio)
         int value;
 
         chip = gpio_to_chip(gpio);
+        /* Should be using gpio_get_value_cansleep() */
         WARN_ON(chip->can_sleep);
         value = chip->get ? chip->get(chip, gpio - chip->base) : 0;
         trace_gpio_value(gpio, 1, value);
@@ -1567,6 +1589,57 @@ int __gpio_get_value(unsigned gpio)
 }
 EXPORT_SYMBOL_GPL(__gpio_get_value);
 
+/*
+ *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
+ * @gpio: Gpio whose state need to be set.
+ * @chip: Gpio chip.
+ * @value: Non-zero for setting it HIGH otherise it will set to LOW.
+ */
+static void _gpio_set_open_drain_value(unsigned gpio,
+                        struct gpio_chip *chip, int value)
+{
+        int err = 0;
+        if (value) {
+                err = chip->direction_input(chip, gpio - chip->base);
+                if (!err)
+                        clear_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+        } else {
+                err = chip->direction_output(chip, gpio - chip->base, 0);
+                if (!err)
+                        set_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+        }
+        trace_gpio_direction(gpio, value, err);
+        if (err < 0)
+                pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
+                                        __func__, gpio, err);
+}
+
+/*
+ *  _gpio_set_open_source() - Set the open source gpio's value.
+ * @gpio: Gpio whose state need to be set.
+ * @chip: Gpio chip.
+ * @value: Non-zero for setting it HIGH otherise it will set to LOW.
+ */
+static void _gpio_set_open_source_value(unsigned gpio,
+                        struct gpio_chip *chip, int value)
+{
+        int err = 0;
+        if (value) {
+                err = chip->direction_output(chip, gpio - chip->base, 1);
+                if (!err)
+                        set_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+        } else {
+                err = chip->direction_input(chip, gpio - chip->base);
+                if (!err)
+                        clear_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+        }
+        trace_gpio_direction(gpio, !value, err);
+        if (err < 0)
+                pr_err("%s: Error in set_value for open source gpio%d err %d\n",
+                                        __func__, gpio, err);
+}
+
+
 /**
  * __gpio_set_value() - assign a gpio's value
  * @gpio: gpio whose value will be assigned
@@ -1581,9 +1654,15 @@ void __gpio_set_value(unsigned gpio, int value)
         struct gpio_chip        *chip;
 
         chip = gpio_to_chip(gpio);
+        /* Should be using gpio_set_value_cansleep() */
         WARN_ON(chip->can_sleep);
         trace_gpio_value(gpio, 0, value);
-        chip->set(chip, gpio - chip->base, value);
+        if (test_bit(FLAG_OPEN_DRAIN,  &gpio_desc[gpio].flags))
+                _gpio_set_open_drain_value(gpio, chip, value);
+        else if (test_bit(FLAG_OPEN_SOURCE,  &gpio_desc[gpio].flags))
+                _gpio_set_open_source_value(gpio, chip, value);
+        else
+                chip->set(chip, gpio - chip->base, value);
 }
 EXPORT_SYMBOL_GPL(__gpio_set_value);
 
@@ -1650,7 +1729,12 @@ void gpio_set_value_cansleep(unsigned gpio, int value)
         might_sleep_if(extra_checks);
         chip = gpio_to_chip(gpio);
         trace_gpio_value(gpio, 0, value);
-        chip->set(chip, gpio - chip->base, value);
+        if (test_bit(FLAG_OPEN_DRAIN,  &gpio_desc[gpio].flags))
+                _gpio_set_open_drain_value(gpio, chip, value);
+        else if (test_bit(FLAG_OPEN_SOURCE,  &gpio_desc[gpio].flags))
+                _gpio_set_open_source_value(gpio, chip, value);
+        else
+                chip->set(chip, gpio - chip->base, value);
 }
 EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);