Merge branch 'devel-stable' into devel
[linux-3.10.git] / arch / arm / plat-nomadik / gpio.c
similarity index 74%
rename from arch/arm/mach-nomadik/gpio.c
rename to arch/arm/plat-nomadik/gpio.c
index 66b1c91..5a6ef25 100644 (file)
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/device.h>
-#include <linux/amba/bus.h>
+#include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/err.h>
 #include <linux/gpio.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
@@ -36,8 +38,9 @@
 struct nmk_gpio_chip {
        struct gpio_chip chip;
        void __iomem *addr;
+       struct clk *clk;
        unsigned int parent_irq;
-       spinlock_t *lock;
+       spinlock_t lock;
        /* Keep track of configured edges */
        u32 edge_rising;
        u32 edge_falling;
@@ -108,40 +111,37 @@ static void nmk_gpio_irq_ack(unsigned int irq)
        writel(nmk_gpio_get_bitmask(gpio), nmk_chip->addr + NMK_GPIO_IC);
 }
 
-static void nmk_gpio_irq_mask(unsigned int irq)
+static void __nmk_gpio_irq_modify(struct nmk_gpio_chip *nmk_chip,
+                                 int gpio, bool enable)
 {
-       int gpio;
-       struct nmk_gpio_chip *nmk_chip;
-       unsigned long flags;
-       u32 bitmask, reg;
-
-       gpio = NOMADIK_IRQ_TO_GPIO(irq);
-       nmk_chip = get_irq_chip_data(irq);
-       bitmask = nmk_gpio_get_bitmask(gpio);
-       if (!nmk_chip)
-               return;
+       u32 bitmask = nmk_gpio_get_bitmask(gpio);
+       u32 reg;
 
-       /* we must individually clear the two edges */
-       spin_lock_irqsave(&nmk_chip->lock, flags);
+       /* we must individually set/clear the two edges */
        if (nmk_chip->edge_rising & bitmask) {
-               reg = readl(nmk_chip->addr + NMK_GPIO_RWIMSC);
-               reg &= ~bitmask;
-               writel(reg, nmk_chip->addr + NMK_GPIO_RWIMSC);
+               reg = readl(nmk_chip->addr + NMK_GPIO_RIMSC);
+               if (enable)
+                       reg |= bitmask;
+               else
+                       reg &= ~bitmask;
+               writel(reg, nmk_chip->addr + NMK_GPIO_RIMSC);
        }
        if (nmk_chip->edge_falling & bitmask) {
-               reg = readl(nmk_chip->addr + NMK_GPIO_FWIMSC);
-               reg &= ~bitmask;
-               writel(reg, nmk_chip->addr + NMK_GPIO_FWIMSC);
+               reg = readl(nmk_chip->addr + NMK_GPIO_FIMSC);
+               if (enable)
+                       reg |= bitmask;
+               else
+                       reg &= ~bitmask;
+               writel(reg, nmk_chip->addr + NMK_GPIO_FIMSC);
        }
-       spin_unlock_irqrestore(&nmk_chip->lock, flags);
-};
+}
 
-static void nmk_gpio_irq_unmask(unsigned int irq)
+static void nmk_gpio_irq_modify(unsigned int irq, bool enable)
 {
        int gpio;
        struct nmk_gpio_chip *nmk_chip;
        unsigned long flags;
-       u32 bitmask, reg;
+       u32 bitmask;
 
        gpio = NOMADIK_IRQ_TO_GPIO(irq);
        nmk_chip = get_irq_chip_data(irq);
@@ -149,23 +149,24 @@ static void nmk_gpio_irq_unmask(unsigned int irq)
        if (!nmk_chip)
                return;
 
-       /* we must individually set the two edges */
        spin_lock_irqsave(&nmk_chip->lock, flags);
-       if (nmk_chip->edge_rising & bitmask) {
-               reg = readl(nmk_chip->addr + NMK_GPIO_RWIMSC);
-               reg |= bitmask;
-               writel(reg, nmk_chip->addr + NMK_GPIO_RWIMSC);
-       }
-       if (nmk_chip->edge_falling & bitmask) {
-               reg = readl(nmk_chip->addr + NMK_GPIO_FWIMSC);
-               reg |= bitmask;
-               writel(reg, nmk_chip->addr + NMK_GPIO_FWIMSC);
-       }
+       __nmk_gpio_irq_modify(nmk_chip, gpio, enable);
        spin_unlock_irqrestore(&nmk_chip->lock, flags);
 }
 
+static void nmk_gpio_irq_mask(unsigned int irq)
+{
+       nmk_gpio_irq_modify(irq, false);
+};
+
+static void nmk_gpio_irq_unmask(unsigned int irq)
+{
+       nmk_gpio_irq_modify(irq, true);
+}
+
 static int nmk_gpio_irq_set_type(unsigned int irq, unsigned int type)
 {
+       bool enabled = !(irq_to_desc(irq)->status & IRQ_DISABLED);
        int gpio;
        struct nmk_gpio_chip *nmk_chip;
        unsigned long flags;
@@ -184,19 +185,21 @@ static int nmk_gpio_irq_set_type(unsigned int irq, unsigned int type)
 
        spin_lock_irqsave(&nmk_chip->lock, flags);
 
+       if (enabled)
+               __nmk_gpio_irq_modify(nmk_chip, gpio, false);
+
        nmk_chip->edge_rising &= ~bitmask;
        if (type & IRQ_TYPE_EDGE_RISING)
                nmk_chip->edge_rising |= bitmask;
-       writel(nmk_chip->edge_rising, nmk_chip->addr + NMK_GPIO_RIMSC);
 
        nmk_chip->edge_falling &= ~bitmask;
        if (type & IRQ_TYPE_EDGE_FALLING)
                nmk_chip->edge_falling |= bitmask;
-       writel(nmk_chip->edge_falling, nmk_chip->addr + NMK_GPIO_FIMSC);
 
-       spin_unlock_irqrestore(&nmk_chip->lock, flags);
+       if (enabled)
+               __nmk_gpio_irq_modify(nmk_chip, gpio, true);
 
-       nmk_gpio_irq_unmask(irq);
+       spin_unlock_irqrestore(&nmk_chip->lock, flags);
 
        return 0;
 }
@@ -212,21 +215,27 @@ static struct irq_chip nmk_gpio_irq_chip = {
 static void nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
 {
        struct nmk_gpio_chip *nmk_chip;
-       struct irq_chip *host_chip;
+       struct irq_chip *host_chip = get_irq_chip(irq);
        unsigned int gpio_irq;
        u32 pending;
        unsigned int first_irq;
 
+       if (host_chip->mask_ack)
+               host_chip->mask_ack(irq);
+       else {
+               host_chip->mask(irq);
+               if (host_chip->ack)
+                       host_chip->ack(irq);
+       }
+
        nmk_chip = get_irq_data(irq);
        first_irq = NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base);
        while ( (pending = readl(nmk_chip->addr + NMK_GPIO_IS)) ) {
                gpio_irq = first_irq + __ffs(pending);
                generic_handle_irq(gpio_irq);
        }
-       if (0) {/* don't ack parent irq, as ack == disable */
-               host_chip = get_irq_chip(irq);
-               host_chip->ack(irq);
-       }
+
+       host_chip->unmask(irq);
 }
 
 static int nmk_gpio_init_irq(struct nmk_gpio_chip *nmk_chip)
@@ -240,6 +249,7 @@ static int nmk_gpio_init_irq(struct nmk_gpio_chip *nmk_chip)
                set_irq_handler(i, handle_edge_irq);
                set_irq_flags(i, IRQF_VALID);
                set_irq_chip_data(i, nmk_chip);
+               set_irq_type(i, IRQ_TYPE_EDGE_FALLING);
        }
        set_irq_chained_handler(nmk_chip->parent_irq, nmk_gpio_irq_handler);
        set_irq_data(nmk_chip->parent_irq, nmk_chip);
@@ -298,30 +308,59 @@ static struct gpio_chip nmk_gpio_template = {
        .can_sleep              = 0,
 };
 
-static int __init nmk_gpio_probe(struct amba_device *dev, struct amba_id *id)
+static int __init nmk_gpio_probe(struct platform_device *dev)
 {
-       struct nmk_gpio_platform_data *pdata;
+       struct nmk_gpio_platform_data *pdata = dev->dev.platform_data;
        struct nmk_gpio_chip *nmk_chip;
        struct gpio_chip *chip;
+       struct resource *res;
+       struct clk *clk;
+       int irq;
        int ret;
 
-       pdata = dev->dev.platform_data;
-       ret = amba_request_regions(dev, pdata->name);
-       if (ret)
-               return ret;
+       if (!pdata)
+               return -ENODEV;
+
+       res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+       if (!res) {
+               ret = -ENOENT;
+               goto out;
+       }
+
+       irq = platform_get_irq(dev, 0);
+       if (irq < 0) {
+               ret = irq;
+               goto out;
+       }
+
+       if (request_mem_region(res->start, resource_size(res),
+                              dev_name(&dev->dev)) == NULL) {
+               ret = -EBUSY;
+               goto out;
+       }
+
+       clk = clk_get(&dev->dev, NULL);
+       if (IS_ERR(clk)) {
+               ret = PTR_ERR(clk);
+               goto out_release;
+       }
+
+       clk_enable(clk);
 
        nmk_chip = kzalloc(sizeof(*nmk_chip), GFP_KERNEL);
        if (!nmk_chip) {
                ret = -ENOMEM;
-               goto out_amba;
+               goto out_clk;
        }
        /*
         * The virt address in nmk_chip->addr is in the nomadik register space,
         * so we can simply convert the resource address, without remapping
         */
-       nmk_chip->addr = io_p2v(dev->res.start);
+       nmk_chip->clk = clk;
+       nmk_chip->addr = io_p2v(res->start);
        nmk_chip->chip = nmk_gpio_template;
-       nmk_chip->parent_irq = pdata->parent_irq;
+       nmk_chip->parent_irq = irq;
+       spin_lock_init(&nmk_chip->lock);
 
        chip = &nmk_chip->chip;
        chip->base = pdata->first_gpio;
@@ -333,7 +372,7 @@ static int __init nmk_gpio_probe(struct amba_device *dev, struct amba_id *id)
        if (ret)
                goto out_free;
 
-       amba_set_drvdata(dev, nmk_chip);
+       platform_set_drvdata(dev, nmk_chip);
 
        nmk_gpio_init_irq(nmk_chip);
 
@@ -341,51 +380,50 @@ static int __init nmk_gpio_probe(struct amba_device *dev, struct amba_id *id)
                 nmk_chip->chip.base, nmk_chip->chip.base+31, nmk_chip->addr);
        return 0;
 
- out_free:
+out_free:
        kfree(nmk_chip);
- out_amba:
-       amba_release_regions(dev);
+out_clk:
+       clk_disable(clk);
+       clk_put(clk);
+out_release:
+       release_mem_region(res->start, resource_size(res));
+out:
        dev_err(&dev->dev, "Failure %i for GPIO %i-%i\n", ret,
                  pdata->first_gpio, pdata->first_gpio+31);
        return ret;
 }
 
-static int nmk_gpio_remove(struct amba_device *dev)
+static int __exit nmk_gpio_remove(struct platform_device *dev)
 {
        struct nmk_gpio_chip *nmk_chip;
+       struct resource *res;
 
-       nmk_chip = amba_get_drvdata(dev);
+       res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+
+       nmk_chip = platform_get_drvdata(dev);
        gpiochip_remove(&nmk_chip->chip);
+       clk_disable(nmk_chip->clk);
+       clk_put(nmk_chip->clk);
        kfree(nmk_chip);
-       amba_release_regions(dev);
+       release_mem_region(res->start, resource_size(res));
        return 0;
 }
 
 
-/* We have 0x1f080060 and 0x1f180060, accept both using the mask */
-static struct amba_id nmk_gpio_ids[] = {
-       {
-               .id     = 0x1f080060,
-               .mask   = 0xffefffff,
-       },
-       {0, 0},
-};
-
-static struct amba_driver nmk_gpio_driver = {
-       .drv = {
+static struct platform_driver nmk_gpio_driver = {
+       .driver = {
                .owner = THIS_MODULE,
                .name = "gpio",
                },
        .probe = nmk_gpio_probe,
-       .remove = nmk_gpio_remove,
+       .remove = __exit_p(nmk_gpio_remove),
        .suspend = NULL, /* to be done */
        .resume = NULL,
-       .id_table = nmk_gpio_ids,
 };
 
 static int __init nmk_gpio_init(void)
 {
-       return amba_driver_register(&nmk_gpio_driver);
+       return platform_driver_register(&nmk_gpio_driver);
 }
 
 arch_initcall(nmk_gpio_init);