kprobes: remove redundant config check
[linux-2.6.git] / arch / avr32 / mach-at32ap / pio.c
1 /*
2  * Atmel PIO2 Port Multiplexer support
3  *
4  * Copyright (C) 2004-2006 Atmel Corporation
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10
11 #include <linux/clk.h>
12 #include <linux/debugfs.h>
13 #include <linux/fs.h>
14 #include <linux/platform_device.h>
15 #include <linux/irq.h>
16
17 #include <asm/gpio.h>
18 #include <asm/io.h>
19
20 #include <asm/arch/portmux.h>
21
22 #include "pio.h"
23
24 #define MAX_NR_PIO_DEVICES              8
25
26 struct pio_device {
27         struct gpio_chip chip;
28         void __iomem *regs;
29         const struct platform_device *pdev;
30         struct clk *clk;
31         u32 pinmux_mask;
32         char name[8];
33 };
34
35 static struct pio_device pio_dev[MAX_NR_PIO_DEVICES];
36
37 static struct pio_device *gpio_to_pio(unsigned int gpio)
38 {
39         struct pio_device *pio;
40         unsigned int index;
41
42         index = gpio >> 5;
43         if (index >= MAX_NR_PIO_DEVICES)
44                 return NULL;
45         pio = &pio_dev[index];
46         if (!pio->regs)
47                 return NULL;
48
49         return pio;
50 }
51
52 /* Pin multiplexing API */
53
54 void __init at32_select_periph(unsigned int pin, unsigned int periph,
55                                unsigned long flags)
56 {
57         struct pio_device *pio;
58         unsigned int pin_index = pin & 0x1f;
59         u32 mask = 1 << pin_index;
60
61         pio = gpio_to_pio(pin);
62         if (unlikely(!pio)) {
63                 printk("pio: invalid pin %u\n", pin);
64                 goto fail;
65         }
66
67         if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask)
68                          || gpiochip_is_requested(&pio->chip, pin_index))) {
69                 printk("%s: pin %u is busy\n", pio->name, pin_index);
70                 goto fail;
71         }
72
73         pio_writel(pio, PUER, mask);
74         if (periph)
75                 pio_writel(pio, BSR, mask);
76         else
77                 pio_writel(pio, ASR, mask);
78
79         pio_writel(pio, PDR, mask);
80         if (!(flags & AT32_GPIOF_PULLUP))
81                 pio_writel(pio, PUDR, mask);
82
83         return;
84
85 fail:
86         dump_stack();
87 }
88
89 void __init at32_select_gpio(unsigned int pin, unsigned long flags)
90 {
91         struct pio_device *pio;
92         unsigned int pin_index = pin & 0x1f;
93         u32 mask = 1 << pin_index;
94
95         pio = gpio_to_pio(pin);
96         if (unlikely(!pio)) {
97                 printk("pio: invalid pin %u\n", pin);
98                 goto fail;
99         }
100
101         if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask))) {
102                 printk("%s: pin %u is busy\n", pio->name, pin_index);
103                 goto fail;
104         }
105
106         if (flags & AT32_GPIOF_OUTPUT) {
107                 if (flags & AT32_GPIOF_HIGH)
108                         pio_writel(pio, SODR, mask);
109                 else
110                         pio_writel(pio, CODR, mask);
111                 if (flags & AT32_GPIOF_MULTIDRV)
112                         pio_writel(pio, MDER, mask);
113                 else
114                         pio_writel(pio, MDDR, mask);
115                 pio_writel(pio, PUDR, mask);
116                 pio_writel(pio, OER, mask);
117         } else {
118                 if (flags & AT32_GPIOF_PULLUP)
119                         pio_writel(pio, PUER, mask);
120                 else
121                         pio_writel(pio, PUDR, mask);
122                 if (flags & AT32_GPIOF_DEGLITCH)
123                         pio_writel(pio, IFER, mask);
124                 else
125                         pio_writel(pio, IFDR, mask);
126                 pio_writel(pio, ODR, mask);
127         }
128
129         pio_writel(pio, PER, mask);
130
131         return;
132
133 fail:
134         dump_stack();
135 }
136
137 /* Reserve a pin, preventing anyone else from changing its configuration. */
138 void __init at32_reserve_pin(unsigned int pin)
139 {
140         struct pio_device *pio;
141         unsigned int pin_index = pin & 0x1f;
142
143         pio = gpio_to_pio(pin);
144         if (unlikely(!pio)) {
145                 printk("pio: invalid pin %u\n", pin);
146                 goto fail;
147         }
148
149         if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask))) {
150                 printk("%s: pin %u is busy\n", pio->name, pin_index);
151                 goto fail;
152         }
153
154         return;
155
156 fail:
157         dump_stack();
158 }
159
160 /*--------------------------------------------------------------------------*/
161
162 /* GPIO API */
163
164 static int direction_input(struct gpio_chip *chip, unsigned offset)
165 {
166         struct pio_device *pio = container_of(chip, struct pio_device, chip);
167         u32 mask = 1 << offset;
168
169         if (!(pio_readl(pio, PSR) & mask))
170                 return -EINVAL;
171
172         pio_writel(pio, ODR, mask);
173         return 0;
174 }
175
176 static int gpio_get(struct gpio_chip *chip, unsigned offset)
177 {
178         struct pio_device *pio = container_of(chip, struct pio_device, chip);
179
180         return (pio_readl(pio, PDSR) >> offset) & 1;
181 }
182
183 static void gpio_set(struct gpio_chip *chip, unsigned offset, int value);
184
185 static int direction_output(struct gpio_chip *chip, unsigned offset, int value)
186 {
187         struct pio_device *pio = container_of(chip, struct pio_device, chip);
188         u32 mask = 1 << offset;
189
190         if (!(pio_readl(pio, PSR) & mask))
191                 return -EINVAL;
192
193         gpio_set(chip, offset, value);
194         pio_writel(pio, OER, mask);
195         return 0;
196 }
197
198 static void gpio_set(struct gpio_chip *chip, unsigned offset, int value)
199 {
200         struct pio_device *pio = container_of(chip, struct pio_device, chip);
201         u32 mask = 1 << offset;
202
203         if (value)
204                 pio_writel(pio, SODR, mask);
205         else
206                 pio_writel(pio, CODR, mask);
207 }
208
209 /*--------------------------------------------------------------------------*/
210
211 /* GPIO IRQ support */
212
213 static void gpio_irq_mask(unsigned irq)
214 {
215         unsigned                gpio = irq_to_gpio(irq);
216         struct pio_device       *pio = &pio_dev[gpio >> 5];
217
218         pio_writel(pio, IDR, 1 << (gpio & 0x1f));
219 }
220
221 static void gpio_irq_unmask(unsigned irq)
222 {
223         unsigned                gpio = irq_to_gpio(irq);
224         struct pio_device       *pio = &pio_dev[gpio >> 5];
225
226         pio_writel(pio, IER, 1 << (gpio & 0x1f));
227 }
228
229 static int gpio_irq_type(unsigned irq, unsigned type)
230 {
231         if (type != IRQ_TYPE_EDGE_BOTH && type != IRQ_TYPE_NONE)
232                 return -EINVAL;
233
234         return 0;
235 }
236
237 static struct irq_chip gpio_irqchip = {
238         .name           = "gpio",
239         .mask           = gpio_irq_mask,
240         .unmask         = gpio_irq_unmask,
241         .set_type       = gpio_irq_type,
242 };
243
244 static void gpio_irq_handler(unsigned irq, struct irq_desc *desc)
245 {
246         struct pio_device       *pio = get_irq_chip_data(irq);
247         unsigned                gpio_irq;
248
249         gpio_irq = (unsigned) get_irq_data(irq);
250         for (;;) {
251                 u32             isr;
252                 struct irq_desc *d;
253
254                 /* ack pending GPIO interrupts */
255                 isr = pio_readl(pio, ISR) & pio_readl(pio, IMR);
256                 if (!isr)
257                         break;
258                 do {
259                         int i;
260
261                         i = ffs(isr) - 1;
262                         isr &= ~(1 << i);
263
264                         i += gpio_irq;
265                         d = &irq_desc[i];
266
267                         d->handle_irq(i, d);
268                 } while (isr);
269         }
270 }
271
272 static void __init
273 gpio_irq_setup(struct pio_device *pio, int irq, int gpio_irq)
274 {
275         unsigned        i;
276
277         set_irq_chip_data(irq, pio);
278         set_irq_data(irq, (void *) gpio_irq);
279
280         for (i = 0; i < 32; i++, gpio_irq++) {
281                 set_irq_chip_data(gpio_irq, pio);
282                 set_irq_chip_and_handler(gpio_irq, &gpio_irqchip,
283                                 handle_simple_irq);
284         }
285
286         set_irq_chained_handler(irq, gpio_irq_handler);
287 }
288
289 /*--------------------------------------------------------------------------*/
290
291 #ifdef CONFIG_DEBUG_FS
292
293 #include <linux/seq_file.h>
294
295 /*
296  * This shows more info than the generic gpio dump code:
297  * pullups, deglitching, open drain drive.
298  */
299 static void pio_bank_show(struct seq_file *s, struct gpio_chip *chip)
300 {
301         struct pio_device *pio = container_of(chip, struct pio_device, chip);
302         u32                     psr, osr, imr, pdsr, pusr, ifsr, mdsr;
303         unsigned                i;
304         u32                     mask;
305         char                    bank;
306
307         psr = pio_readl(pio, PSR);
308         osr = pio_readl(pio, OSR);
309         imr = pio_readl(pio, IMR);
310         pdsr = pio_readl(pio, PDSR);
311         pusr = pio_readl(pio, PUSR);
312         ifsr = pio_readl(pio, IFSR);
313         mdsr = pio_readl(pio, MDSR);
314
315         bank = 'A' + pio->pdev->id;
316
317         for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
318                 const char *label;
319
320                 label = gpiochip_is_requested(chip, i);
321                 if (!label && (imr & mask))
322                         label = "[irq]";
323                 if (!label)
324                         continue;
325
326                 seq_printf(s, " gpio-%-3d P%c%-2d (%-12s) %s %s %s",
327                         chip->base + i, bank, i,
328                         label,
329                         (osr & mask) ? "out" : "in ",
330                         (mask & pdsr) ? "hi" : "lo",
331                         (mask & pusr) ? "  " : "up");
332                 if (ifsr & mask)
333                         seq_printf(s, " deglitch");
334                 if ((osr & mdsr) & mask)
335                         seq_printf(s, " open-drain");
336                 if (imr & mask)
337                         seq_printf(s, " irq-%d edge-both",
338                                 gpio_to_irq(chip->base + i));
339                 seq_printf(s, "\n");
340         }
341 }
342
343 #else
344 #define pio_bank_show   NULL
345 #endif
346
347
348 /*--------------------------------------------------------------------------*/
349
350 static int __init pio_probe(struct platform_device *pdev)
351 {
352         struct pio_device *pio = NULL;
353         int irq = platform_get_irq(pdev, 0);
354         int gpio_irq_base = GPIO_IRQ_BASE + pdev->id * 32;
355
356         BUG_ON(pdev->id >= MAX_NR_PIO_DEVICES);
357         pio = &pio_dev[pdev->id];
358         BUG_ON(!pio->regs);
359
360         pio->chip.label = pio->name;
361         pio->chip.base = pdev->id * 32;
362         pio->chip.ngpio = 32;
363
364         pio->chip.direction_input = direction_input;
365         pio->chip.get = gpio_get;
366         pio->chip.direction_output = direction_output;
367         pio->chip.set = gpio_set;
368         pio->chip.dbg_show = pio_bank_show;
369
370         gpiochip_add(&pio->chip);
371
372         gpio_irq_setup(pio, irq, gpio_irq_base);
373
374         platform_set_drvdata(pdev, pio);
375
376         printk(KERN_DEBUG "%s: base 0x%p, irq %d chains %d..%d\n",
377                pio->name, pio->regs, irq, gpio_irq_base, gpio_irq_base + 31);
378
379         return 0;
380 }
381
382 static struct platform_driver pio_driver = {
383         .probe          = pio_probe,
384         .driver         = {
385                 .name           = "pio",
386         },
387 };
388
389 static int __init pio_init(void)
390 {
391         return platform_driver_register(&pio_driver);
392 }
393 postcore_initcall(pio_init);
394
395 void __init at32_init_pio(struct platform_device *pdev)
396 {
397         struct resource *regs;
398         struct pio_device *pio;
399
400         if (pdev->id > MAX_NR_PIO_DEVICES) {
401                 dev_err(&pdev->dev, "only %d PIO devices supported\n",
402                         MAX_NR_PIO_DEVICES);
403                 return;
404         }
405
406         pio = &pio_dev[pdev->id];
407         snprintf(pio->name, sizeof(pio->name), "pio%d", pdev->id);
408
409         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
410         if (!regs) {
411                 dev_err(&pdev->dev, "no mmio resource defined\n");
412                 return;
413         }
414
415         pio->clk = clk_get(&pdev->dev, "mck");
416         if (IS_ERR(pio->clk))
417                 /*
418                  * This is a fatal error, but if we continue we might
419                  * be so lucky that we manage to initialize the
420                  * console and display this message...
421                  */
422                 dev_err(&pdev->dev, "no mck clock defined\n");
423         else
424                 clk_enable(pio->clk);
425
426         pio->pdev = pdev;
427         pio->regs = ioremap(regs->start, regs->end - regs->start + 1);
428
429         /* start with irqs disabled and acked */
430         pio_writel(pio, IDR, ~0UL);
431         (void) pio_readl(pio, ISR);
432 }