4 files changed, 102 insertions, 176 deletions

diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 573c449c49b9..ec1dcdca5b8a 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -109,8 +109,11 @@ config GPIO_MAX730X
 comment "Memory mapped GPIO drivers:"
 
 config GPIO_CLPS711X
-        def_bool y
+        tristate "CLPS711X GPIO support"
         depends on ARCH_CLPS711X
+        select GPIO_GENERIC
+        help
+          Say yes here to support GPIO on CLPS711X SoCs.
 
 config GPIO_GENERIC_PLATFORM
         tristate "Generic memory-mapped GPIO controller support (MMIO platform device)"
@@ -209,6 +212,13 @@ config GPIO_RCAR
         help
           Say yes here to support GPIO on Renesas R-Car SoCs.
 
+config GPIO_SAMSUNG
+        bool
+        depends on PLAT_SAMSUNG
+        help
+          Legacy GPIO support. Use only for platforms without support for
+          pinctrl.
+
 config GPIO_SPEAR_SPICS
         bool "ST SPEAr13xx SPI Chip Select as GPIO support"
         depends on PLAT_SPEAR
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 0cb2d656ad16..ef3e983a2f1e 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -59,7 +59,7 @@ obj-$(CONFIG_GPIO_PXA)		+= gpio-pxa.o
 obj-$(CONFIG_GPIO_RC5T583)      += gpio-rc5t583.o
 obj-$(CONFIG_GPIO_RDC321X)      += gpio-rdc321x.o
 obj-$(CONFIG_GPIO_RCAR)         += gpio-rcar.o
-obj-$(CONFIG_PLAT_SAMSUNG)      += gpio-samsung.o
+obj-$(CONFIG_GPIO_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
diff --git a/drivers/gpio/gpio-clps711x.c b/drivers/gpio/gpio-clps711x.c
index ce63b75b13f5..0edaf2ce9266 100644
--- a/drivers/gpio/gpio-clps711x.c
+++ b/drivers/gpio/gpio-clps711x.c
@@ -1,7 +1,7 @@
 /*
  *  CLPS711X GPIO driver
  *
- *  Copyright (C) 2012 Alexander Shiyan <shc_work@mail.ru>
+ *  Copyright (C) 2012,2013 Alexander Shiyan <shc_work@mail.ru>
  *
  * 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
@@ -9,191 +9,91 @@
  * (at your option) any later version.
  */
 
-#include <linux/io.h>
-#include <linux/slab.h>
+#include <linux/err.h>
 #include <linux/gpio.h>
 #include <linux/module.h>
-#include <linux/spinlock.h>
+#include <linux/basic_mmio_gpio.h>
 #include <linux/platform_device.h>
 
-#include <mach/hardware.h>
-
-#define CLPS711X_GPIO_PORTS     5
-#define CLPS711X_GPIO_NAME      "gpio-clps711x"
-
-struct clps711x_gpio {
-        struct gpio_chip        chip[CLPS711X_GPIO_PORTS];
-        spinlock_t              lock;
-};
-
-static void __iomem *clps711x_ports[] = {
-        CLPS711X_VIRT_BASE + PADR,
-        CLPS711X_VIRT_BASE + PBDR,
-        CLPS711X_VIRT_BASE + PCDR,
-        CLPS711X_VIRT_BASE + PDDR,
-        CLPS711X_VIRT_BASE + PEDR,
-};
-
-static void __iomem *clps711x_pdirs[] = {
-        CLPS711X_VIRT_BASE + PADDR,
-        CLPS711X_VIRT_BASE + PBDDR,
-        CLPS711X_VIRT_BASE + PCDDR,
-        CLPS711X_VIRT_BASE + PDDDR,
-        CLPS711X_VIRT_BASE + PEDDR,
-};
-
-#define clps711x_port(x)        clps711x_ports[x->base / 8]
-#define clps711x_pdir(x)        clps711x_pdirs[x->base / 8]
-
-static int gpio_clps711x_get(struct gpio_chip *chip, unsigned offset)
+static int clps711x_gpio_probe(struct platform_device *pdev)
 {
-        return !!(readb(clps711x_port(chip)) & (1 << offset));
-}
+        struct device_node *np = pdev->dev.of_node;
+        void __iomem *dat, *dir;
+        struct bgpio_chip *bgc;
+        struct resource *res;
+        int err, id = np ? of_alias_get_id(np, "gpio") : pdev->id;
 
-static void gpio_clps711x_set(struct gpio_chip *chip, unsigned offset,
-                              int value)
-{
-        int tmp;
-        unsigned long flags;
-        struct clps711x_gpio *gpio = dev_get_drvdata(chip->dev);
-
-        spin_lock_irqsave(&gpio->lock, flags);
-        tmp = readb(clps711x_port(chip)) & ~(1 << offset);
-        if (value)
-                tmp |= 1 << offset;
-        writeb(tmp, clps711x_port(chip));
-        spin_unlock_irqrestore(&gpio->lock, flags);
-}
-
-static int gpio_clps711x_dir_in(struct gpio_chip *chip, unsigned offset)
-{
-        int tmp;
-        unsigned long flags;
-        struct clps711x_gpio *gpio = dev_get_drvdata(chip->dev);
+        if ((id < 0) || (id > 4))
+                return -ENODEV;
 
-        spin_lock_irqsave(&gpio->lock, flags);
-        tmp = readb(clps711x_pdir(chip)) & ~(1 << offset);
-        writeb(tmp, clps711x_pdir(chip));
-        spin_unlock_irqrestore(&gpio->lock, flags);
+        bgc = devm_kzalloc(&pdev->dev, sizeof(*bgc), GFP_KERNEL);
+        if (!bgc)
+                return -ENOMEM;
 
-        return 0;
-}
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        dat = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(dat))
+                return PTR_ERR(dat);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        dir = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(dir))
+                return PTR_ERR(dir);
+
+        switch (id) {
+        case 3:
+                /* PORTD is inverted logic for direction register */
+                err = bgpio_init(bgc, &pdev->dev, 1, dat, NULL, NULL,
+                                 NULL, dir, 0);
+                break;
+        default:
+                err = bgpio_init(bgc, &pdev->dev, 1, dat, NULL, NULL,
+                                 dir, NULL, 0);
+                break;
+        }
 
-static int gpio_clps711x_dir_out(struct gpio_chip *chip, unsigned offset,
-                                 int value)
-{
-        int tmp;
-        unsigned long flags;
-        struct clps711x_gpio *gpio = dev_get_drvdata(chip->dev);
-
-        spin_lock_irqsave(&gpio->lock, flags);
-        tmp = readb(clps711x_pdir(chip)) | (1 << offset);
-        writeb(tmp, clps711x_pdir(chip));
-        tmp = readb(clps711x_port(chip)) & ~(1 << offset);
-        if (value)
-                tmp |= 1 << offset;
-        writeb(tmp, clps711x_port(chip));
-        spin_unlock_irqrestore(&gpio->lock, flags);
-
-        return 0;
-}
+        if (err)
+                return err;
 
-static int gpio_clps711x_dir_in_inv(struct gpio_chip *chip, unsigned offset)
-{
-        int tmp;
-        unsigned long flags;
-        struct clps711x_gpio *gpio = dev_get_drvdata(chip->dev);
+        switch (id) {
+        case 4:
+                /* PORTE is 3 lines only */
+                bgc->gc.ngpio = 3;
+                break;
+        default:
+                break;
+        }
 
-        spin_lock_irqsave(&gpio->lock, flags);
-        tmp = readb(clps711x_pdir(chip)) | (1 << offset);
-        writeb(tmp, clps711x_pdir(chip));
-        spin_unlock_irqrestore(&gpio->lock, flags);
+        bgc->gc.base = id * 8;
+        platform_set_drvdata(pdev, bgc);
 
-        return 0;
+        return gpiochip_add(&bgc->gc);
 }
 
-static int gpio_clps711x_dir_out_inv(struct gpio_chip *chip, unsigned offset,
-                                     int value)
+static int clps711x_gpio_remove(struct platform_device *pdev)
 {
-        int tmp;
-        unsigned long flags;
-        struct clps711x_gpio *gpio = dev_get_drvdata(chip->dev);
-
-        spin_lock_irqsave(&gpio->lock, flags);
-        tmp = readb(clps711x_pdir(chip)) & ~(1 << offset);
-        writeb(tmp, clps711x_pdir(chip));
-        tmp = readb(clps711x_port(chip)) & ~(1 << offset);
-        if (value)
-                tmp |= 1 << offset;
-        writeb(tmp, clps711x_port(chip));
-        spin_unlock_irqrestore(&gpio->lock, flags);
-
-        return 0;
+        struct bgpio_chip *bgc = platform_get_drvdata(pdev);
+
+        return bgpio_remove(bgc);
 }
 
-static struct {
-        char    *name;
-        int     nr;
-        int     inv_dir;
-} clps711x_gpio_ports[] __initconst = {
-        { "PORTA", 8, 0, },
-        { "PORTB", 8, 0, },
-        { "PORTC", 8, 0, },
-        { "PORTD", 8, 1, },
-        { "PORTE", 3, 0, },
+static const struct of_device_id clps711x_gpio_ids[] = {
+        { .compatible = "cirrus,clps711x-gpio" },
+        { }
 };
+MODULE_DEVICE_TABLE(of, clps711x_gpio_ids);
+
+static struct platform_driver clps711x_gpio_driver = {
+        .driver = {
+                .name           = "clps711x-gpio",
+                .owner          = THIS_MODULE,
+                .of_match_table = of_match_ptr(clps711x_gpio_ids),
+        },
+        .probe  = clps711x_gpio_probe,
+        .remove = clps711x_gpio_remove,
+};
+module_platform_driver(clps711x_gpio_driver);
 
-static int __init gpio_clps711x_init(void)
-{
-        int i;
-        struct platform_device *pdev;
-        struct clps711x_gpio *gpio;
-
-        pdev = platform_device_alloc(CLPS711X_GPIO_NAME, 0);
-        if (!pdev) {
-                pr_err("Cannot create platform device: %s\n",
-                       CLPS711X_GPIO_NAME);
-                return -ENOMEM;
-        }
-
-        platform_device_add(pdev);
-
-        gpio = devm_kzalloc(&pdev->dev, sizeof(struct clps711x_gpio),
-                            GFP_KERNEL);
-        if (!gpio) {
-                dev_err(&pdev->dev, "GPIO allocating memory error\n");
-                platform_device_unregister(pdev);
-                return -ENOMEM;
-        }
-
-        platform_set_drvdata(pdev, gpio);
-
-        spin_lock_init(&gpio->lock);
-
-        for (i = 0; i < CLPS711X_GPIO_PORTS; i++) {
-                gpio->chip[i].owner             = THIS_MODULE;
-                gpio->chip[i].dev               = &pdev->dev;
-                gpio->chip[i].label             = clps711x_gpio_ports[i].name;
-                gpio->chip[i].base              = i * 8;
-                gpio->chip[i].ngpio             = clps711x_gpio_ports[i].nr;
-                gpio->chip[i].get               = gpio_clps711x_get;
-                gpio->chip[i].set               = gpio_clps711x_set;
-                if (!clps711x_gpio_ports[i].inv_dir) {
-                        gpio->chip[i].direction_input = gpio_clps711x_dir_in;
-                        gpio->chip[i].direction_output = gpio_clps711x_dir_out;
-                } else {
-                        gpio->chip[i].direction_input = gpio_clps711x_dir_in_inv;
-                        gpio->chip[i].direction_output = gpio_clps711x_dir_out_inv;
-                }
-                WARN_ON(gpiochip_add(&gpio->chip[i]));
-        }
-
-        dev_info(&pdev->dev, "GPIO driver initialized\n");
-
-        return 0;
-}
-arch_initcall(gpio_clps711x_init);
-
-MODULE_LICENSE("GPL v2");
+MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
 MODULE_DESCRIPTION("CLPS711X GPIO driver");
diff --git a/drivers/gpio/gpio-rcar.c b/drivers/gpio/gpio-rcar.c
index b4ca450947b8..d173d56dbb8c 100644
--- a/drivers/gpio/gpio-rcar.c
+++ b/drivers/gpio/gpio-rcar.c
@@ -49,6 +49,7 @@ struct gpio_rcar_priv {
 #define POSNEG 0x20
 #define EDGLEVEL 0x24
 #define FILONOFF 0x28
+#define BOTHEDGE 0x4c
 
 static inline u32 gpio_rcar_read(struct gpio_rcar_priv *p, int offs)
 {
@@ -91,7 +92,8 @@ static void gpio_rcar_irq_enable(struct irq_data *d)
 static void gpio_rcar_config_interrupt_input_mode(struct gpio_rcar_priv *p,
                                                   unsigned int hwirq,
                                                   bool active_high_rising_edge,
-                                                  bool level_trigger)
+                                                  bool level_trigger,
+                                                  bool both)
 {
         unsigned long flags;
 
@@ -108,6 +110,10 @@ static void gpio_rcar_config_interrupt_input_mode(struct gpio_rcar_priv *p,
         /* Configure edge or level trigger in EDGLEVEL */
         gpio_rcar_modify_bit(p, EDGLEVEL, hwirq, !level_trigger);
 
+        /* Select one edge or both edges in BOTHEDGE */
+        if (p->config.has_both_edge_trigger)
+                gpio_rcar_modify_bit(p, BOTHEDGE, hwirq, both);
+
         /* Select "Interrupt Input Mode" in IOINTSEL */
         gpio_rcar_modify_bit(p, IOINTSEL, hwirq, true);
 
@@ -127,16 +133,26 @@ static int gpio_rcar_irq_set_type(struct irq_data *d, unsigned int type)
 
         switch (type & IRQ_TYPE_SENSE_MASK) {
         case IRQ_TYPE_LEVEL_HIGH:
-                gpio_rcar_config_interrupt_input_mode(p, hwirq, true, true);
+                gpio_rcar_config_interrupt_input_mode(p, hwirq, true, true,
+                                                      false);
                 break;
         case IRQ_TYPE_LEVEL_LOW:
-                gpio_rcar_config_interrupt_input_mode(p, hwirq, false, true);
+                gpio_rcar_config_interrupt_input_mode(p, hwirq, false, true,
+                                                      false);
                 break;
         case IRQ_TYPE_EDGE_RISING:
-                gpio_rcar_config_interrupt_input_mode(p, hwirq, true, false);
+                gpio_rcar_config_interrupt_input_mode(p, hwirq, true, false,
+                                                      false);
                 break;
         case IRQ_TYPE_EDGE_FALLING:
-                gpio_rcar_config_interrupt_input_mode(p, hwirq, false, false);
+                gpio_rcar_config_interrupt_input_mode(p, hwirq, false, false,
+                                                      false);
+                break;
+        case IRQ_TYPE_EDGE_BOTH:
+                if (!p->config.has_both_edge_trigger)
+                        return -EINVAL;
+                gpio_rcar_config_interrupt_input_mode(p, hwirq, true, false,
+                                                      true);
                 break;
         default:
                 return -EINVAL;
@@ -333,7 +349,7 @@ static int gpio_rcar_probe(struct platform_device *pdev)
         }
 
         if (devm_request_irq(&pdev->dev, irq->start,
-                             gpio_rcar_irq_handler, 0, name, p)) {
+                             gpio_rcar_irq_handler, IRQF_SHARED, name, p)) {
                 dev_err(&pdev->dev, "failed to request IRQ\n");
                 ret = -ENOENT;
                 goto err1;