gpio/pca953x: Deprecate meaningless device-tree bindings
[linux-2.6.git] / drivers / gpio / gpio-mxc.c
1 /*
2  * MXC GPIO support. (c) 2008 Daniel Mack <daniel@caiaq.de>
3  * Copyright 2008 Juergen Beisert, kernel@pengutronix.de
4  *
5  * Based on code from Freescale,
6  * Copyright (C) 2004-2010 Freescale Semiconductor, Inc. All Rights Reserved.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20  */
21
22 #include <linux/init.h>
23 #include <linux/interrupt.h>
24 #include <linux/io.h>
25 #include <linux/irq.h>
26 #include <linux/gpio.h>
27 #include <linux/platform_device.h>
28 #include <linux/slab.h>
29 #include <linux/basic_mmio_gpio.h>
30 #include <mach/hardware.h>
31 #include <asm-generic/bug.h>
32
33 struct mxc_gpio_port {
34         struct list_head node;
35         void __iomem *base;
36         int irq;
37         int irq_high;
38         int virtual_irq_start;
39         struct bgpio_chip bgc;
40         u32 both_edges;
41 };
42
43 /*
44  * MX2 has one interrupt *for all* gpio ports. The list is used
45  * to save the references to all ports, so that mx2_gpio_irq_handler
46  * can walk through all interrupt status registers.
47  */
48 static LIST_HEAD(mxc_gpio_ports);
49
50 #define cpu_is_mx1_mx2()        (cpu_is_mx1() || cpu_is_mx2())
51
52 #define GPIO_DR         (cpu_is_mx1_mx2() ? 0x1c : 0x00)
53 #define GPIO_GDIR       (cpu_is_mx1_mx2() ? 0x00 : 0x04)
54 #define GPIO_PSR        (cpu_is_mx1_mx2() ? 0x24 : 0x08)
55 #define GPIO_ICR1       (cpu_is_mx1_mx2() ? 0x28 : 0x0C)
56 #define GPIO_ICR2       (cpu_is_mx1_mx2() ? 0x2C : 0x10)
57 #define GPIO_IMR        (cpu_is_mx1_mx2() ? 0x30 : 0x14)
58 #define GPIO_ISR        (cpu_is_mx1_mx2() ? 0x34 : 0x18)
59
60 #define GPIO_INT_LOW_LEV        (cpu_is_mx1_mx2() ? 0x3 : 0x0)
61 #define GPIO_INT_HIGH_LEV       (cpu_is_mx1_mx2() ? 0x2 : 0x1)
62 #define GPIO_INT_RISE_EDGE      (cpu_is_mx1_mx2() ? 0x0 : 0x2)
63 #define GPIO_INT_FALL_EDGE      (cpu_is_mx1_mx2() ? 0x1 : 0x3)
64 #define GPIO_INT_NONE           0x4
65
66 /* Note: This driver assumes 32 GPIOs are handled in one register */
67
68 static int gpio_set_irq_type(struct irq_data *d, u32 type)
69 {
70         u32 gpio = irq_to_gpio(d->irq);
71         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
72         struct mxc_gpio_port *port = gc->private;
73         u32 bit, val;
74         int edge;
75         void __iomem *reg = port->base;
76
77         port->both_edges &= ~(1 << (gpio & 31));
78         switch (type) {
79         case IRQ_TYPE_EDGE_RISING:
80                 edge = GPIO_INT_RISE_EDGE;
81                 break;
82         case IRQ_TYPE_EDGE_FALLING:
83                 edge = GPIO_INT_FALL_EDGE;
84                 break;
85         case IRQ_TYPE_EDGE_BOTH:
86                 val = gpio_get_value(gpio);
87                 if (val) {
88                         edge = GPIO_INT_LOW_LEV;
89                         pr_debug("mxc: set GPIO %d to low trigger\n", gpio);
90                 } else {
91                         edge = GPIO_INT_HIGH_LEV;
92                         pr_debug("mxc: set GPIO %d to high trigger\n", gpio);
93                 }
94                 port->both_edges |= 1 << (gpio & 31);
95                 break;
96         case IRQ_TYPE_LEVEL_LOW:
97                 edge = GPIO_INT_LOW_LEV;
98                 break;
99         case IRQ_TYPE_LEVEL_HIGH:
100                 edge = GPIO_INT_HIGH_LEV;
101                 break;
102         default:
103                 return -EINVAL;
104         }
105
106         reg += GPIO_ICR1 + ((gpio & 0x10) >> 2); /* lower or upper register */
107         bit = gpio & 0xf;
108         val = readl(reg) & ~(0x3 << (bit << 1));
109         writel(val | (edge << (bit << 1)), reg);
110         writel(1 << (gpio & 0x1f), port->base + GPIO_ISR);
111
112         return 0;
113 }
114
115 static void mxc_flip_edge(struct mxc_gpio_port *port, u32 gpio)
116 {
117         void __iomem *reg = port->base;
118         u32 bit, val;
119         int edge;
120
121         reg += GPIO_ICR1 + ((gpio & 0x10) >> 2); /* lower or upper register */
122         bit = gpio & 0xf;
123         val = readl(reg);
124         edge = (val >> (bit << 1)) & 3;
125         val &= ~(0x3 << (bit << 1));
126         if (edge == GPIO_INT_HIGH_LEV) {
127                 edge = GPIO_INT_LOW_LEV;
128                 pr_debug("mxc: switch GPIO %d to low trigger\n", gpio);
129         } else if (edge == GPIO_INT_LOW_LEV) {
130                 edge = GPIO_INT_HIGH_LEV;
131                 pr_debug("mxc: switch GPIO %d to high trigger\n", gpio);
132         } else {
133                 pr_err("mxc: invalid configuration for GPIO %d: %x\n",
134                        gpio, edge);
135                 return;
136         }
137         writel(val | (edge << (bit << 1)), reg);
138 }
139
140 /* handle 32 interrupts in one status register */
141 static void mxc_gpio_irq_handler(struct mxc_gpio_port *port, u32 irq_stat)
142 {
143         u32 gpio_irq_no_base = port->virtual_irq_start;
144
145         while (irq_stat != 0) {
146                 int irqoffset = fls(irq_stat) - 1;
147
148                 if (port->both_edges & (1 << irqoffset))
149                         mxc_flip_edge(port, irqoffset);
150
151                 generic_handle_irq(gpio_irq_no_base + irqoffset);
152
153                 irq_stat &= ~(1 << irqoffset);
154         }
155 }
156
157 /* MX1 and MX3 has one interrupt *per* gpio port */
158 static void mx3_gpio_irq_handler(u32 irq, struct irq_desc *desc)
159 {
160         u32 irq_stat;
161         struct mxc_gpio_port *port = irq_get_handler_data(irq);
162
163         irq_stat = readl(port->base + GPIO_ISR) & readl(port->base + GPIO_IMR);
164
165         mxc_gpio_irq_handler(port, irq_stat);
166 }
167
168 /* MX2 has one interrupt *for all* gpio ports */
169 static void mx2_gpio_irq_handler(u32 irq, struct irq_desc *desc)
170 {
171         u32 irq_msk, irq_stat;
172         struct mxc_gpio_port *port;
173
174         /* walk through all interrupt status registers */
175         list_for_each_entry(port, &mxc_gpio_ports, node) {
176                 irq_msk = readl(port->base + GPIO_IMR);
177                 if (!irq_msk)
178                         continue;
179
180                 irq_stat = readl(port->base + GPIO_ISR) & irq_msk;
181                 if (irq_stat)
182                         mxc_gpio_irq_handler(port, irq_stat);
183         }
184 }
185
186 /*
187  * Set interrupt number "irq" in the GPIO as a wake-up source.
188  * While system is running, all registered GPIO interrupts need to have
189  * wake-up enabled. When system is suspended, only selected GPIO interrupts
190  * need to have wake-up enabled.
191  * @param  irq          interrupt source number
192  * @param  enable       enable as wake-up if equal to non-zero
193  * @return       This function returns 0 on success.
194  */
195 static int gpio_set_wake_irq(struct irq_data *d, u32 enable)
196 {
197         u32 gpio = irq_to_gpio(d->irq);
198         u32 gpio_idx = gpio & 0x1F;
199         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
200         struct mxc_gpio_port *port = gc->private;
201
202         if (enable) {
203                 if (port->irq_high && (gpio_idx >= 16))
204                         enable_irq_wake(port->irq_high);
205                 else
206                         enable_irq_wake(port->irq);
207         } else {
208                 if (port->irq_high && (gpio_idx >= 16))
209                         disable_irq_wake(port->irq_high);
210                 else
211                         disable_irq_wake(port->irq);
212         }
213
214         return 0;
215 }
216
217 static void __init mxc_gpio_init_gc(struct mxc_gpio_port *port)
218 {
219         struct irq_chip_generic *gc;
220         struct irq_chip_type *ct;
221
222         gc = irq_alloc_generic_chip("gpio-mxc", 1, port->virtual_irq_start,
223                                     port->base, handle_level_irq);
224         gc->private = port;
225
226         ct = gc->chip_types;
227         ct->chip.irq_ack = irq_gc_ack,
228         ct->chip.irq_mask = irq_gc_mask_clr_bit;
229         ct->chip.irq_unmask = irq_gc_mask_set_bit;
230         ct->chip.irq_set_type = gpio_set_irq_type;
231         ct->chip.irq_set_wake = gpio_set_wake_irq,
232         ct->regs.ack = GPIO_ISR;
233         ct->regs.mask = GPIO_IMR;
234
235         irq_setup_generic_chip(gc, IRQ_MSK(32), IRQ_GC_INIT_NESTED_LOCK,
236                                IRQ_NOREQUEST, 0);
237 }
238
239 static int __devinit mxc_gpio_probe(struct platform_device *pdev)
240 {
241         struct mxc_gpio_port *port;
242         struct resource *iores;
243         int err;
244
245         port = kzalloc(sizeof(struct mxc_gpio_port), GFP_KERNEL);
246         if (!port)
247                 return -ENOMEM;
248
249         port->virtual_irq_start = MXC_GPIO_IRQ_START + pdev->id * 32;
250
251         iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
252         if (!iores) {
253                 err = -ENODEV;
254                 goto out_kfree;
255         }
256
257         if (!request_mem_region(iores->start, resource_size(iores),
258                                 pdev->name)) {
259                 err = -EBUSY;
260                 goto out_kfree;
261         }
262
263         port->base = ioremap(iores->start, resource_size(iores));
264         if (!port->base) {
265                 err = -ENOMEM;
266                 goto out_release_mem;
267         }
268
269         port->irq_high = platform_get_irq(pdev, 1);
270         port->irq = platform_get_irq(pdev, 0);
271         if (port->irq < 0) {
272                 err = -EINVAL;
273                 goto out_iounmap;
274         }
275
276         /* disable the interrupt and clear the status */
277         writel(0, port->base + GPIO_IMR);
278         writel(~0, port->base + GPIO_ISR);
279
280         /* gpio-mxc can be a generic irq chip */
281         mxc_gpio_init_gc(port);
282
283         if (cpu_is_mx2()) {
284                 /* setup one handler for all GPIO interrupts */
285                 if (pdev->id == 0)
286                         irq_set_chained_handler(port->irq,
287                                                 mx2_gpio_irq_handler);
288         } else {
289                 /* setup one handler for each entry */
290                 irq_set_chained_handler(port->irq, mx3_gpio_irq_handler);
291                 irq_set_handler_data(port->irq, port);
292                 if (port->irq_high > 0) {
293                         /* setup handler for GPIO 16 to 31 */
294                         irq_set_chained_handler(port->irq_high,
295                                                 mx3_gpio_irq_handler);
296                         irq_set_handler_data(port->irq_high, port);
297                 }
298         }
299
300         err = bgpio_init(&port->bgc, &pdev->dev, 4,
301                          port->base + GPIO_PSR,
302                          port->base + GPIO_DR, NULL,
303                          port->base + GPIO_GDIR, NULL, false);
304         if (err)
305                 goto out_iounmap;
306
307         port->bgc.gc.base = pdev->id * 32;
308
309         err = gpiochip_add(&port->bgc.gc);
310         if (err)
311                 goto out_bgpio_remove;
312
313         list_add_tail(&port->node, &mxc_gpio_ports);
314
315         return 0;
316
317 out_bgpio_remove:
318         bgpio_remove(&port->bgc);
319 out_iounmap:
320         iounmap(port->base);
321 out_release_mem:
322         release_mem_region(iores->start, resource_size(iores));
323 out_kfree:
324         kfree(port);
325         dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, err);
326         return err;
327 }
328
329 static struct platform_driver mxc_gpio_driver = {
330         .driver         = {
331                 .name   = "gpio-mxc",
332                 .owner  = THIS_MODULE,
333         },
334         .probe          = mxc_gpio_probe,
335 };
336
337 static int __init gpio_mxc_init(void)
338 {
339         return platform_driver_register(&mxc_gpio_driver);
340 }
341 postcore_initcall(gpio_mxc_init);
342
343 MODULE_AUTHOR("Freescale Semiconductor, "
344               "Daniel Mack <danielncaiaq.de>, "
345               "Juergen Beisert <kernel@pengutronix.de>");
346 MODULE_DESCRIPTION("Freescale MXC GPIO");
347 MODULE_LICENSE("GPL");