pinctrl-bcm2835: Fix cut-and-paste error in "pull" parsing
[projects/modsched/linux.git] / drivers / pinctrl / bcm / pinctrl-bcm2835.c
1 /*
2  * Driver for Broadcom BCM2835 GPIO unit (pinctrl + GPIO)
3  *
4  * Copyright (C) 2012 Chris Boot, Simon Arlott, Stephen Warren
5  *
6  * This driver is inspired by:
7  * pinctrl-nomadik.c, please see original file for copyright information
8  * pinctrl-tegra.c, please see original file for copyright information
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  */
20
21 #include <linux/bitmap.h>
22 #include <linux/bug.h>
23 #include <linux/delay.h>
24 #include <linux/device.h>
25 #include <linux/err.h>
26 #include <linux/gpio.h>
27 #include <linux/interrupt.h>
28 #include <linux/io.h>
29 #include <linux/irq.h>
30 #include <linux/irqdesc.h>
31 #include <linux/irqdomain.h>
32 #include <linux/module.h>
33 #include <linux/of_address.h>
34 #include <linux/of.h>
35 #include <linux/of_irq.h>
36 #include <linux/pinctrl/consumer.h>
37 #include <linux/pinctrl/machine.h>
38 #include <linux/pinctrl/pinconf.h>
39 #include <linux/pinctrl/pinctrl.h>
40 #include <linux/pinctrl/pinmux.h>
41 #include <linux/platform_device.h>
42 #include <linux/seq_file.h>
43 #include <linux/slab.h>
44 #include <linux/spinlock.h>
45 #include <linux/types.h>
46
47 #define MODULE_NAME "pinctrl-bcm2835"
48 #define BCM2835_NUM_GPIOS 54
49 #define BCM2835_NUM_BANKS 2
50 #define BCM2835_NUM_IRQS  3
51
52 #define BCM2835_PIN_BITMAP_SZ \
53         DIV_ROUND_UP(BCM2835_NUM_GPIOS, sizeof(unsigned long) * 8)
54
55 /* GPIO register offsets */
56 #define GPFSEL0         0x0     /* Function Select */
57 #define GPSET0          0x1c    /* Pin Output Set */
58 #define GPCLR0          0x28    /* Pin Output Clear */
59 #define GPLEV0          0x34    /* Pin Level */
60 #define GPEDS0          0x40    /* Pin Event Detect Status */
61 #define GPREN0          0x4c    /* Pin Rising Edge Detect Enable */
62 #define GPFEN0          0x58    /* Pin Falling Edge Detect Enable */
63 #define GPHEN0          0x64    /* Pin High Detect Enable */
64 #define GPLEN0          0x70    /* Pin Low Detect Enable */
65 #define GPAREN0         0x7c    /* Pin Async Rising Edge Detect */
66 #define GPAFEN0         0x88    /* Pin Async Falling Edge Detect */
67 #define GPPUD           0x94    /* Pin Pull-up/down Enable */
68 #define GPPUDCLK0       0x98    /* Pin Pull-up/down Enable Clock */
69
70 #define FSEL_REG(p)             (GPFSEL0 + (((p) / 10) * 4))
71 #define FSEL_SHIFT(p)           (((p) % 10) * 3)
72 #define GPIO_REG_OFFSET(p)      ((p) / 32)
73 #define GPIO_REG_SHIFT(p)       ((p) % 32)
74
75 enum bcm2835_pinconf_param {
76         /* argument: bcm2835_pinconf_pull */
77         BCM2835_PINCONF_PARAM_PULL,
78 };
79
80 enum bcm2835_pinconf_pull {
81         BCM2835_PINCONFIG_PULL_NONE,
82         BCM2835_PINCONFIG_PULL_DOWN,
83         BCM2835_PINCONFIG_PULL_UP,
84 };
85
86 #define BCM2835_PINCONF_PACK(_param_, _arg_) ((_param_) << 16 | (_arg_))
87 #define BCM2835_PINCONF_UNPACK_PARAM(_conf_) ((_conf_) >> 16)
88 #define BCM2835_PINCONF_UNPACK_ARG(_conf_) ((_conf_) & 0xffff)
89
90 struct bcm2835_gpio_irqdata {
91         struct bcm2835_pinctrl *pc;
92         int irqgroup;
93 };
94
95 struct bcm2835_pinctrl {
96         struct device *dev;
97         void __iomem *base;
98         int irq[BCM2835_NUM_IRQS];
99
100         /* note: locking assumes each bank will have its own unsigned long */
101         unsigned long enabled_irq_map[BCM2835_NUM_BANKS];
102         unsigned int irq_type[BCM2835_NUM_GPIOS];
103
104         struct pinctrl_dev *pctl_dev;
105         struct irq_domain *irq_domain;
106         struct gpio_chip gpio_chip;
107         struct pinctrl_gpio_range gpio_range;
108
109         struct bcm2835_gpio_irqdata irq_data[BCM2835_NUM_IRQS];
110         spinlock_t irq_lock[BCM2835_NUM_BANKS];
111 };
112
113 static struct lock_class_key gpio_lock_class;
114
115 /* pins are just named GPIO0..GPIO53 */
116 #define BCM2835_GPIO_PIN(a) PINCTRL_PIN(a, "gpio" #a)
117 static struct pinctrl_pin_desc bcm2835_gpio_pins[] = {
118         BCM2835_GPIO_PIN(0),
119         BCM2835_GPIO_PIN(1),
120         BCM2835_GPIO_PIN(2),
121         BCM2835_GPIO_PIN(3),
122         BCM2835_GPIO_PIN(4),
123         BCM2835_GPIO_PIN(5),
124         BCM2835_GPIO_PIN(6),
125         BCM2835_GPIO_PIN(7),
126         BCM2835_GPIO_PIN(8),
127         BCM2835_GPIO_PIN(9),
128         BCM2835_GPIO_PIN(10),
129         BCM2835_GPIO_PIN(11),
130         BCM2835_GPIO_PIN(12),
131         BCM2835_GPIO_PIN(13),
132         BCM2835_GPIO_PIN(14),
133         BCM2835_GPIO_PIN(15),
134         BCM2835_GPIO_PIN(16),
135         BCM2835_GPIO_PIN(17),
136         BCM2835_GPIO_PIN(18),
137         BCM2835_GPIO_PIN(19),
138         BCM2835_GPIO_PIN(20),
139         BCM2835_GPIO_PIN(21),
140         BCM2835_GPIO_PIN(22),
141         BCM2835_GPIO_PIN(23),
142         BCM2835_GPIO_PIN(24),
143         BCM2835_GPIO_PIN(25),
144         BCM2835_GPIO_PIN(26),
145         BCM2835_GPIO_PIN(27),
146         BCM2835_GPIO_PIN(28),
147         BCM2835_GPIO_PIN(29),
148         BCM2835_GPIO_PIN(30),
149         BCM2835_GPIO_PIN(31),
150         BCM2835_GPIO_PIN(32),
151         BCM2835_GPIO_PIN(33),
152         BCM2835_GPIO_PIN(34),
153         BCM2835_GPIO_PIN(35),
154         BCM2835_GPIO_PIN(36),
155         BCM2835_GPIO_PIN(37),
156         BCM2835_GPIO_PIN(38),
157         BCM2835_GPIO_PIN(39),
158         BCM2835_GPIO_PIN(40),
159         BCM2835_GPIO_PIN(41),
160         BCM2835_GPIO_PIN(42),
161         BCM2835_GPIO_PIN(43),
162         BCM2835_GPIO_PIN(44),
163         BCM2835_GPIO_PIN(45),
164         BCM2835_GPIO_PIN(46),
165         BCM2835_GPIO_PIN(47),
166         BCM2835_GPIO_PIN(48),
167         BCM2835_GPIO_PIN(49),
168         BCM2835_GPIO_PIN(50),
169         BCM2835_GPIO_PIN(51),
170         BCM2835_GPIO_PIN(52),
171         BCM2835_GPIO_PIN(53),
172 };
173
174 /* one pin per group */
175 static const char * const bcm2835_gpio_groups[] = {
176         "gpio0",
177         "gpio1",
178         "gpio2",
179         "gpio3",
180         "gpio4",
181         "gpio5",
182         "gpio6",
183         "gpio7",
184         "gpio8",
185         "gpio9",
186         "gpio10",
187         "gpio11",
188         "gpio12",
189         "gpio13",
190         "gpio14",
191         "gpio15",
192         "gpio16",
193         "gpio17",
194         "gpio18",
195         "gpio19",
196         "gpio20",
197         "gpio21",
198         "gpio22",
199         "gpio23",
200         "gpio24",
201         "gpio25",
202         "gpio26",
203         "gpio27",
204         "gpio28",
205         "gpio29",
206         "gpio30",
207         "gpio31",
208         "gpio32",
209         "gpio33",
210         "gpio34",
211         "gpio35",
212         "gpio36",
213         "gpio37",
214         "gpio38",
215         "gpio39",
216         "gpio40",
217         "gpio41",
218         "gpio42",
219         "gpio43",
220         "gpio44",
221         "gpio45",
222         "gpio46",
223         "gpio47",
224         "gpio48",
225         "gpio49",
226         "gpio50",
227         "gpio51",
228         "gpio52",
229         "gpio53",
230 };
231
232 enum bcm2835_fsel {
233         BCM2835_FSEL_GPIO_IN = 0,
234         BCM2835_FSEL_GPIO_OUT = 1,
235         BCM2835_FSEL_ALT0 = 4,
236         BCM2835_FSEL_ALT1 = 5,
237         BCM2835_FSEL_ALT2 = 6,
238         BCM2835_FSEL_ALT3 = 7,
239         BCM2835_FSEL_ALT4 = 3,
240         BCM2835_FSEL_ALT5 = 2,
241         BCM2835_FSEL_COUNT = 8,
242         BCM2835_FSEL_MASK = 0x7,
243 };
244
245 static const char * const bcm2835_functions[BCM2835_FSEL_COUNT] = {
246         [BCM2835_FSEL_GPIO_IN] = "gpio_in",
247         [BCM2835_FSEL_GPIO_OUT] = "gpio_out",
248         [BCM2835_FSEL_ALT0] = "alt0",
249         [BCM2835_FSEL_ALT1] = "alt1",
250         [BCM2835_FSEL_ALT2] = "alt2",
251         [BCM2835_FSEL_ALT3] = "alt3",
252         [BCM2835_FSEL_ALT4] = "alt4",
253         [BCM2835_FSEL_ALT5] = "alt5",
254 };
255
256 static const char * const irq_type_names[] = {
257         [IRQ_TYPE_NONE] = "none",
258         [IRQ_TYPE_EDGE_RISING] = "edge-rising",
259         [IRQ_TYPE_EDGE_FALLING] = "edge-falling",
260         [IRQ_TYPE_EDGE_BOTH] = "edge-both",
261         [IRQ_TYPE_LEVEL_HIGH] = "level-high",
262         [IRQ_TYPE_LEVEL_LOW] = "level-low",
263 };
264
265 static inline u32 bcm2835_gpio_rd(struct bcm2835_pinctrl *pc, unsigned reg)
266 {
267         return readl(pc->base + reg);
268 }
269
270 static inline void bcm2835_gpio_wr(struct bcm2835_pinctrl *pc, unsigned reg,
271                 u32 val)
272 {
273         writel(val, pc->base + reg);
274 }
275
276 static inline int bcm2835_gpio_get_bit(struct bcm2835_pinctrl *pc, unsigned reg,
277                 unsigned bit)
278 {
279         reg += GPIO_REG_OFFSET(bit) * 4;
280         return (bcm2835_gpio_rd(pc, reg) >> GPIO_REG_SHIFT(bit)) & 1;
281 }
282
283 /* note NOT a read/modify/write cycle */
284 static inline void bcm2835_gpio_set_bit(struct bcm2835_pinctrl *pc,
285                 unsigned reg, unsigned bit)
286 {
287         reg += GPIO_REG_OFFSET(bit) * 4;
288         bcm2835_gpio_wr(pc, reg, BIT(GPIO_REG_SHIFT(bit)));
289 }
290
291 static inline enum bcm2835_fsel bcm2835_pinctrl_fsel_get(
292                 struct bcm2835_pinctrl *pc, unsigned pin)
293 {
294         u32 val = bcm2835_gpio_rd(pc, FSEL_REG(pin));
295         enum bcm2835_fsel status = (val >> FSEL_SHIFT(pin)) & BCM2835_FSEL_MASK;
296
297         dev_dbg(pc->dev, "get %08x (%u => %s)\n", val, pin,
298                         bcm2835_functions[status]);
299
300         return status;
301 }
302
303 static inline void bcm2835_pinctrl_fsel_set(
304                 struct bcm2835_pinctrl *pc, unsigned pin,
305                 enum bcm2835_fsel fsel)
306 {
307         u32 val = bcm2835_gpio_rd(pc, FSEL_REG(pin));
308         enum bcm2835_fsel cur = (val >> FSEL_SHIFT(pin)) & BCM2835_FSEL_MASK;
309
310         dev_dbg(pc->dev, "read %08x (%u => %s)\n", val, pin,
311                         bcm2835_functions[cur]);
312
313         if (cur == fsel)
314                 return;
315
316         if (cur != BCM2835_FSEL_GPIO_IN && fsel != BCM2835_FSEL_GPIO_IN) {
317                 /* always transition through GPIO_IN */
318                 val &= ~(BCM2835_FSEL_MASK << FSEL_SHIFT(pin));
319                 val |= BCM2835_FSEL_GPIO_IN << FSEL_SHIFT(pin);
320
321                 dev_dbg(pc->dev, "trans %08x (%u <= %s)\n", val, pin,
322                                 bcm2835_functions[BCM2835_FSEL_GPIO_IN]);
323                 bcm2835_gpio_wr(pc, FSEL_REG(pin), val);
324         }
325
326         val &= ~(BCM2835_FSEL_MASK << FSEL_SHIFT(pin));
327         val |= fsel << FSEL_SHIFT(pin);
328
329         dev_dbg(pc->dev, "write %08x (%u <= %s)\n", val, pin,
330                         bcm2835_functions[fsel]);
331         bcm2835_gpio_wr(pc, FSEL_REG(pin), val);
332 }
333
334 static int bcm2835_gpio_request(struct gpio_chip *chip, unsigned offset)
335 {
336         return pinctrl_request_gpio(chip->base + offset);
337 }
338
339 static void bcm2835_gpio_free(struct gpio_chip *chip, unsigned offset)
340 {
341         pinctrl_free_gpio(chip->base + offset);
342 }
343
344 static int bcm2835_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
345 {
346         return pinctrl_gpio_direction_input(chip->base + offset);
347 }
348
349 static int bcm2835_gpio_get(struct gpio_chip *chip, unsigned offset)
350 {
351         struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
352
353         return bcm2835_gpio_get_bit(pc, GPLEV0, offset);
354 }
355
356 static int bcm2835_gpio_direction_output(struct gpio_chip *chip,
357                 unsigned offset, int value)
358 {
359         struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
360         int ret;
361
362         ret = pinctrl_gpio_direction_output(chip->base + offset);
363         if (ret >= 0)
364                 bcm2835_gpio_set_bit(pc, value ? GPSET0 : GPCLR0, offset);
365
366         return ret;
367 }
368
369 static void bcm2835_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
370 {
371         struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
372
373         bcm2835_gpio_set_bit(pc, value ? GPSET0 : GPCLR0, offset);
374 }
375
376 static int bcm2835_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
377 {
378         struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
379
380         return irq_linear_revmap(pc->irq_domain, offset);
381 }
382
383 static struct gpio_chip bcm2835_gpio_chip = {
384         .label = MODULE_NAME,
385         .owner = THIS_MODULE,
386         .request = bcm2835_gpio_request,
387         .free = bcm2835_gpio_free,
388         .direction_input = bcm2835_gpio_direction_input,
389         .direction_output = bcm2835_gpio_direction_output,
390         .get = bcm2835_gpio_get,
391         .set = bcm2835_gpio_set,
392         .to_irq = bcm2835_gpio_to_irq,
393         .base = 0,
394         .ngpio = BCM2835_NUM_GPIOS,
395         .can_sleep = false,
396 };
397
398 static int bcm2835_gpio_irq_handle_bank(struct bcm2835_pinctrl *pc,
399                                         unsigned int bank, u32 mask)
400 {
401         unsigned long events;
402         unsigned offset;
403         unsigned gpio;
404         unsigned int type;
405
406         events = bcm2835_gpio_rd(pc, GPEDS0 + bank * 4);
407         events &= mask;
408         events &= pc->enabled_irq_map[bank];
409         for_each_set_bit(offset, &events, 32) {
410                 gpio = (32 * bank) + offset;
411                 type = pc->irq_type[gpio];
412
413                 generic_handle_irq(irq_linear_revmap(pc->irq_domain, gpio));
414         }
415
416         return (events != 0);
417 }
418
419 static irqreturn_t bcm2835_gpio_irq_handler(int irq, void *dev_id)
420 {
421         struct bcm2835_gpio_irqdata *irqdata = dev_id;
422         struct bcm2835_pinctrl *pc = irqdata->pc;
423         int handled = 0;
424
425         switch (irqdata->irqgroup) {
426         case 0: /* IRQ0 covers GPIOs 0-27 */
427                 handled = bcm2835_gpio_irq_handle_bank(pc, 0, 0x0fffffff);
428                 break;
429         case 1: /* IRQ1 covers GPIOs 28-45 */
430                 handled = bcm2835_gpio_irq_handle_bank(pc, 0, 0xf0000000) |
431                           bcm2835_gpio_irq_handle_bank(pc, 1, 0x00003fff);
432                 break;
433         case 2: /* IRQ2 covers GPIOs 46-53 */
434                 handled = bcm2835_gpio_irq_handle_bank(pc, 1, 0x003fc000);
435                 break;
436         }
437
438         return handled ? IRQ_HANDLED : IRQ_NONE;
439 }
440
441 static inline void __bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
442         unsigned reg, unsigned offset, bool enable)
443 {
444         u32 value;
445         reg += GPIO_REG_OFFSET(offset) * 4;
446         value = bcm2835_gpio_rd(pc, reg);
447         if (enable)
448                 value |= BIT(GPIO_REG_SHIFT(offset));
449         else
450                 value &= ~(BIT(GPIO_REG_SHIFT(offset)));
451         bcm2835_gpio_wr(pc, reg, value);
452 }
453
454 /* fast path for IRQ handler */
455 static void bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
456         unsigned offset, bool enable)
457 {
458         switch (pc->irq_type[offset]) {
459         case IRQ_TYPE_EDGE_RISING:
460                 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable);
461                 break;
462
463         case IRQ_TYPE_EDGE_FALLING:
464                 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable);
465                 break;
466
467         case IRQ_TYPE_EDGE_BOTH:
468                 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable);
469                 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable);
470                 break;
471
472         case IRQ_TYPE_LEVEL_HIGH:
473                 __bcm2835_gpio_irq_config(pc, GPHEN0, offset, enable);
474                 break;
475
476         case IRQ_TYPE_LEVEL_LOW:
477                 __bcm2835_gpio_irq_config(pc, GPLEN0, offset, enable);
478                 break;
479         }
480 }
481
482 static void bcm2835_gpio_irq_enable(struct irq_data *data)
483 {
484         struct bcm2835_pinctrl *pc = irq_data_get_irq_chip_data(data);
485         unsigned gpio = irqd_to_hwirq(data);
486         unsigned offset = GPIO_REG_SHIFT(gpio);
487         unsigned bank = GPIO_REG_OFFSET(gpio);
488         unsigned long flags;
489
490         spin_lock_irqsave(&pc->irq_lock[bank], flags);
491         set_bit(offset, &pc->enabled_irq_map[bank]);
492         bcm2835_gpio_irq_config(pc, gpio, true);
493         spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
494 }
495
496 static void bcm2835_gpio_irq_disable(struct irq_data *data)
497 {
498         struct bcm2835_pinctrl *pc = irq_data_get_irq_chip_data(data);
499         unsigned gpio = irqd_to_hwirq(data);
500         unsigned offset = GPIO_REG_SHIFT(gpio);
501         unsigned bank = GPIO_REG_OFFSET(gpio);
502         unsigned long flags;
503
504         spin_lock_irqsave(&pc->irq_lock[bank], flags);
505         bcm2835_gpio_irq_config(pc, gpio, false);
506         /* Clear events that were latched prior to clearing event sources */
507         bcm2835_gpio_set_bit(pc, GPEDS0, gpio);
508         clear_bit(offset, &pc->enabled_irq_map[bank]);
509         spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
510 }
511
512 static int __bcm2835_gpio_irq_set_type_disabled(struct bcm2835_pinctrl *pc,
513         unsigned offset, unsigned int type)
514 {
515         switch (type) {
516         case IRQ_TYPE_NONE:
517         case IRQ_TYPE_EDGE_RISING:
518         case IRQ_TYPE_EDGE_FALLING:
519         case IRQ_TYPE_EDGE_BOTH:
520         case IRQ_TYPE_LEVEL_HIGH:
521         case IRQ_TYPE_LEVEL_LOW:
522                 pc->irq_type[offset] = type;
523                 break;
524
525         default:
526                 return -EINVAL;
527         }
528         return 0;
529 }
530
531 /* slower path for reconfiguring IRQ type */
532 static int __bcm2835_gpio_irq_set_type_enabled(struct bcm2835_pinctrl *pc,
533         unsigned offset, unsigned int type)
534 {
535         switch (type) {
536         case IRQ_TYPE_NONE:
537                 if (pc->irq_type[offset] != type) {
538                         bcm2835_gpio_irq_config(pc, offset, false);
539                         pc->irq_type[offset] = type;
540                 }
541                 break;
542
543         case IRQ_TYPE_EDGE_RISING:
544                 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) {
545                         /* RISING already enabled, disable FALLING */
546                         pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING;
547                         bcm2835_gpio_irq_config(pc, offset, false);
548                         pc->irq_type[offset] = type;
549                 } else if (pc->irq_type[offset] != type) {
550                         bcm2835_gpio_irq_config(pc, offset, false);
551                         pc->irq_type[offset] = type;
552                         bcm2835_gpio_irq_config(pc, offset, true);
553                 }
554                 break;
555
556         case IRQ_TYPE_EDGE_FALLING:
557                 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) {
558                         /* FALLING already enabled, disable RISING */
559                         pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING;
560                         bcm2835_gpio_irq_config(pc, offset, false);
561                         pc->irq_type[offset] = type;
562                 } else if (pc->irq_type[offset] != type) {
563                         bcm2835_gpio_irq_config(pc, offset, false);
564                         pc->irq_type[offset] = type;
565                         bcm2835_gpio_irq_config(pc, offset, true);
566                 }
567                 break;
568
569         case IRQ_TYPE_EDGE_BOTH:
570                 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_RISING) {
571                         /* RISING already enabled, enable FALLING too */
572                         pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING;
573                         bcm2835_gpio_irq_config(pc, offset, true);
574                         pc->irq_type[offset] = type;
575                 } else if (pc->irq_type[offset] == IRQ_TYPE_EDGE_FALLING) {
576                         /* FALLING already enabled, enable RISING too */
577                         pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING;
578                         bcm2835_gpio_irq_config(pc, offset, true);
579                         pc->irq_type[offset] = type;
580                 } else if (pc->irq_type[offset] != type) {
581                         bcm2835_gpio_irq_config(pc, offset, false);
582                         pc->irq_type[offset] = type;
583                         bcm2835_gpio_irq_config(pc, offset, true);
584                 }
585                 break;
586
587         case IRQ_TYPE_LEVEL_HIGH:
588         case IRQ_TYPE_LEVEL_LOW:
589                 if (pc->irq_type[offset] != type) {
590                         bcm2835_gpio_irq_config(pc, offset, false);
591                         pc->irq_type[offset] = type;
592                         bcm2835_gpio_irq_config(pc, offset, true);
593                 }
594                 break;
595
596         default:
597                 return -EINVAL;
598         }
599         return 0;
600 }
601
602 static int bcm2835_gpio_irq_set_type(struct irq_data *data, unsigned int type)
603 {
604         struct bcm2835_pinctrl *pc = irq_data_get_irq_chip_data(data);
605         unsigned gpio = irqd_to_hwirq(data);
606         unsigned offset = GPIO_REG_SHIFT(gpio);
607         unsigned bank = GPIO_REG_OFFSET(gpio);
608         unsigned long flags;
609         int ret;
610
611         spin_lock_irqsave(&pc->irq_lock[bank], flags);
612
613         if (test_bit(offset, &pc->enabled_irq_map[bank]))
614                 ret = __bcm2835_gpio_irq_set_type_enabled(pc, gpio, type);
615         else
616                 ret = __bcm2835_gpio_irq_set_type_disabled(pc, gpio, type);
617
618         if (type & IRQ_TYPE_EDGE_BOTH)
619                 __irq_set_handler_locked(data->irq, handle_edge_irq);
620         else
621                 __irq_set_handler_locked(data->irq, handle_level_irq);
622
623         spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
624
625         return ret;
626 }
627
628 static void bcm2835_gpio_irq_ack(struct irq_data *data)
629 {
630         struct bcm2835_pinctrl *pc = irq_data_get_irq_chip_data(data);
631         unsigned gpio = irqd_to_hwirq(data);
632
633         bcm2835_gpio_set_bit(pc, GPEDS0, gpio);
634 }
635
636 static struct irq_chip bcm2835_gpio_irq_chip = {
637         .name = MODULE_NAME,
638         .irq_enable = bcm2835_gpio_irq_enable,
639         .irq_disable = bcm2835_gpio_irq_disable,
640         .irq_set_type = bcm2835_gpio_irq_set_type,
641         .irq_ack = bcm2835_gpio_irq_ack,
642         .irq_mask = bcm2835_gpio_irq_disable,
643         .irq_unmask = bcm2835_gpio_irq_enable,
644 };
645
646 static int bcm2835_pctl_get_groups_count(struct pinctrl_dev *pctldev)
647 {
648         return ARRAY_SIZE(bcm2835_gpio_groups);
649 }
650
651 static const char *bcm2835_pctl_get_group_name(struct pinctrl_dev *pctldev,
652                 unsigned selector)
653 {
654         return bcm2835_gpio_groups[selector];
655 }
656
657 static int bcm2835_pctl_get_group_pins(struct pinctrl_dev *pctldev,
658                 unsigned selector,
659                 const unsigned **pins,
660                 unsigned *num_pins)
661 {
662         *pins = &bcm2835_gpio_pins[selector].number;
663         *num_pins = 1;
664
665         return 0;
666 }
667
668 static void bcm2835_pctl_pin_dbg_show(struct pinctrl_dev *pctldev,
669                 struct seq_file *s,
670                 unsigned offset)
671 {
672         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
673         enum bcm2835_fsel fsel = bcm2835_pinctrl_fsel_get(pc, offset);
674         const char *fname = bcm2835_functions[fsel];
675         int value = bcm2835_gpio_get_bit(pc, GPLEV0, offset);
676         int irq = irq_find_mapping(pc->irq_domain, offset);
677
678         seq_printf(s, "function %s in %s; irq %d (%s)",
679                 fname, value ? "hi" : "lo",
680                 irq, irq_type_names[pc->irq_type[offset]]);
681 }
682
683 static void bcm2835_pctl_dt_free_map(struct pinctrl_dev *pctldev,
684                 struct pinctrl_map *maps, unsigned num_maps)
685 {
686         int i;
687
688         for (i = 0; i < num_maps; i++)
689                 if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
690                         kfree(maps[i].data.configs.configs);
691
692         kfree(maps);
693 }
694
695 static int bcm2835_pctl_dt_node_to_map_func(struct bcm2835_pinctrl *pc,
696                 struct device_node *np, u32 pin, u32 fnum,
697                 struct pinctrl_map **maps)
698 {
699         struct pinctrl_map *map = *maps;
700
701         if (fnum >= ARRAY_SIZE(bcm2835_functions)) {
702                 dev_err(pc->dev, "%s: invalid brcm,function %d\n",
703                         of_node_full_name(np), fnum);
704                 return -EINVAL;
705         }
706
707         map->type = PIN_MAP_TYPE_MUX_GROUP;
708         map->data.mux.group = bcm2835_gpio_groups[pin];
709         map->data.mux.function = bcm2835_functions[fnum];
710         (*maps)++;
711
712         return 0;
713 }
714
715 static int bcm2835_pctl_dt_node_to_map_pull(struct bcm2835_pinctrl *pc,
716                 struct device_node *np, u32 pin, u32 pull,
717                 struct pinctrl_map **maps)
718 {
719         struct pinctrl_map *map = *maps;
720         unsigned long *configs;
721
722         if (pull > 2) {
723                 dev_err(pc->dev, "%s: invalid brcm,pull %d\n",
724                         of_node_full_name(np), pull);
725                 return -EINVAL;
726         }
727
728         configs = kzalloc(sizeof(*configs), GFP_KERNEL);
729         if (!configs)
730                 return -ENOMEM;
731         configs[0] = BCM2835_PINCONF_PACK(BCM2835_PINCONF_PARAM_PULL, pull);
732
733         map->type = PIN_MAP_TYPE_CONFIGS_PIN;
734         map->data.configs.group_or_pin = bcm2835_gpio_pins[pin].name;
735         map->data.configs.configs = configs;
736         map->data.configs.num_configs = 1;
737         (*maps)++;
738
739         return 0;
740 }
741
742 static int bcm2835_pctl_dt_node_to_map(struct pinctrl_dev *pctldev,
743                 struct device_node *np,
744                 struct pinctrl_map **map, unsigned *num_maps)
745 {
746         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
747         struct property *pins, *funcs, *pulls;
748         int num_pins, num_funcs, num_pulls, maps_per_pin;
749         struct pinctrl_map *maps, *cur_map;
750         int i, err;
751         u32 pin, func, pull;
752
753         pins = of_find_property(np, "brcm,pins", NULL);
754         if (!pins) {
755                 dev_err(pc->dev, "%s: missing brcm,pins property\n",
756                                 of_node_full_name(np));
757                 return -EINVAL;
758         }
759
760         funcs = of_find_property(np, "brcm,function", NULL);
761         pulls = of_find_property(np, "brcm,pull", NULL);
762
763         if (!funcs && !pulls) {
764                 dev_err(pc->dev,
765                         "%s: neither brcm,function nor brcm,pull specified\n",
766                         of_node_full_name(np));
767                 return -EINVAL;
768         }
769
770         num_pins = pins->length / 4;
771         num_funcs = funcs ? (funcs->length / 4) : 0;
772         num_pulls = pulls ? (pulls->length / 4) : 0;
773
774         if (num_funcs > 1 && num_funcs != num_pins) {
775                 dev_err(pc->dev,
776                         "%s: brcm,function must have 1 or %d entries\n",
777                         of_node_full_name(np), num_pins);
778                 return -EINVAL;
779         }
780
781         if (num_pulls > 1 && num_pulls != num_pins) {
782                 dev_err(pc->dev,
783                         "%s: brcm,pull must have 1 or %d entries\n",
784                         of_node_full_name(np), num_pins);
785                 return -EINVAL;
786         }
787
788         maps_per_pin = 0;
789         if (num_funcs)
790                 maps_per_pin++;
791         if (num_pulls)
792                 maps_per_pin++;
793         cur_map = maps = kzalloc(num_pins * maps_per_pin * sizeof(*maps),
794                                 GFP_KERNEL);
795         if (!maps)
796                 return -ENOMEM;
797
798         for (i = 0; i < num_pins; i++) {
799                 err = of_property_read_u32_index(np, "brcm,pins", i, &pin);
800                 if (err)
801                         goto out;
802                 if (pin >= ARRAY_SIZE(bcm2835_gpio_pins)) {
803                         dev_err(pc->dev, "%s: invalid brcm,pins value %d\n",
804                                 of_node_full_name(np), pin);
805                         err = -EINVAL;
806                         goto out;
807                 }
808
809                 if (num_funcs) {
810                         err = of_property_read_u32_index(np, "brcm,function",
811                                         (num_funcs > 1) ? i : 0, &func);
812                         if (err)
813                                 goto out;
814                         err = bcm2835_pctl_dt_node_to_map_func(pc, np, pin,
815                                                         func, &cur_map);
816                         if (err)
817                                 goto out;
818                 }
819                 if (num_pulls) {
820                         err = of_property_read_u32_index(np, "brcm,pull",
821                                         (num_pulls > 1) ? i : 0, &pull);
822                         if (err)
823                                 goto out;
824                         err = bcm2835_pctl_dt_node_to_map_pull(pc, np, pin,
825                                                         pull, &cur_map);
826                         if (err)
827                                 goto out;
828                 }
829         }
830
831         *map = maps;
832         *num_maps = num_pins * maps_per_pin;
833
834         return 0;
835
836 out:
837         kfree(maps);
838         return err;
839 }
840
841 static const struct pinctrl_ops bcm2835_pctl_ops = {
842         .get_groups_count = bcm2835_pctl_get_groups_count,
843         .get_group_name = bcm2835_pctl_get_group_name,
844         .get_group_pins = bcm2835_pctl_get_group_pins,
845         .pin_dbg_show = bcm2835_pctl_pin_dbg_show,
846         .dt_node_to_map = bcm2835_pctl_dt_node_to_map,
847         .dt_free_map = bcm2835_pctl_dt_free_map,
848 };
849
850 static int bcm2835_pmx_get_functions_count(struct pinctrl_dev *pctldev)
851 {
852         return BCM2835_FSEL_COUNT;
853 }
854
855 static const char *bcm2835_pmx_get_function_name(struct pinctrl_dev *pctldev,
856                 unsigned selector)
857 {
858         return bcm2835_functions[selector];
859 }
860
861 static int bcm2835_pmx_get_function_groups(struct pinctrl_dev *pctldev,
862                 unsigned selector,
863                 const char * const **groups,
864                 unsigned * const num_groups)
865 {
866         /* every pin can do every function */
867         *groups = bcm2835_gpio_groups;
868         *num_groups = ARRAY_SIZE(bcm2835_gpio_groups);
869
870         return 0;
871 }
872
873 static int bcm2835_pmx_set(struct pinctrl_dev *pctldev,
874                 unsigned func_selector,
875                 unsigned group_selector)
876 {
877         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
878
879         bcm2835_pinctrl_fsel_set(pc, group_selector, func_selector);
880
881         return 0;
882 }
883
884 static void bcm2835_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
885                 struct pinctrl_gpio_range *range,
886                 unsigned offset)
887 {
888         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
889
890         /* disable by setting to GPIO_IN */
891         bcm2835_pinctrl_fsel_set(pc, offset, BCM2835_FSEL_GPIO_IN);
892 }
893
894 static int bcm2835_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
895                 struct pinctrl_gpio_range *range,
896                 unsigned offset,
897                 bool input)
898 {
899         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
900         enum bcm2835_fsel fsel = input ?
901                 BCM2835_FSEL_GPIO_IN : BCM2835_FSEL_GPIO_OUT;
902
903         bcm2835_pinctrl_fsel_set(pc, offset, fsel);
904
905         return 0;
906 }
907
908 static const struct pinmux_ops bcm2835_pmx_ops = {
909         .get_functions_count = bcm2835_pmx_get_functions_count,
910         .get_function_name = bcm2835_pmx_get_function_name,
911         .get_function_groups = bcm2835_pmx_get_function_groups,
912         .set_mux = bcm2835_pmx_set,
913         .gpio_disable_free = bcm2835_pmx_gpio_disable_free,
914         .gpio_set_direction = bcm2835_pmx_gpio_set_direction,
915 };
916
917 static int bcm2835_pinconf_get(struct pinctrl_dev *pctldev,
918                         unsigned pin, unsigned long *config)
919 {
920         /* No way to read back config in HW */
921         return -ENOTSUPP;
922 }
923
924 static int bcm2835_pinconf_set(struct pinctrl_dev *pctldev,
925                         unsigned pin, unsigned long *configs,
926                         unsigned num_configs)
927 {
928         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
929         enum bcm2835_pinconf_param param;
930         u16 arg;
931         u32 off, bit;
932         int i;
933
934         for (i = 0; i < num_configs; i++) {
935                 param = BCM2835_PINCONF_UNPACK_PARAM(configs[i]);
936                 arg = BCM2835_PINCONF_UNPACK_ARG(configs[i]);
937
938                 if (param != BCM2835_PINCONF_PARAM_PULL)
939                         return -EINVAL;
940
941                 off = GPIO_REG_OFFSET(pin);
942                 bit = GPIO_REG_SHIFT(pin);
943
944                 bcm2835_gpio_wr(pc, GPPUD, arg & 3);
945                 /*
946                  * Docs say to wait 150 cycles, but not of what. We assume a
947                  * 1 MHz clock here, which is pretty slow...
948                  */
949                 udelay(150);
950                 bcm2835_gpio_wr(pc, GPPUDCLK0 + (off * 4), BIT(bit));
951                 udelay(150);
952                 bcm2835_gpio_wr(pc, GPPUDCLK0 + (off * 4), 0);
953         } /* for each config */
954
955         return 0;
956 }
957
958 static const struct pinconf_ops bcm2835_pinconf_ops = {
959         .pin_config_get = bcm2835_pinconf_get,
960         .pin_config_set = bcm2835_pinconf_set,
961 };
962
963 static struct pinctrl_desc bcm2835_pinctrl_desc = {
964         .name = MODULE_NAME,
965         .pins = bcm2835_gpio_pins,
966         .npins = ARRAY_SIZE(bcm2835_gpio_pins),
967         .pctlops = &bcm2835_pctl_ops,
968         .pmxops = &bcm2835_pmx_ops,
969         .confops = &bcm2835_pinconf_ops,
970         .owner = THIS_MODULE,
971 };
972
973 static struct pinctrl_gpio_range bcm2835_pinctrl_gpio_range = {
974         .name = MODULE_NAME,
975         .npins = BCM2835_NUM_GPIOS,
976 };
977
978 static int bcm2835_pinctrl_probe(struct platform_device *pdev)
979 {
980         struct device *dev = &pdev->dev;
981         struct device_node *np = dev->of_node;
982         struct bcm2835_pinctrl *pc;
983         struct resource iomem;
984         int err, i;
985         BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_pins) != BCM2835_NUM_GPIOS);
986         BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_groups) != BCM2835_NUM_GPIOS);
987
988         pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL);
989         if (!pc)
990                 return -ENOMEM;
991
992         platform_set_drvdata(pdev, pc);
993         pc->dev = dev;
994
995         err = of_address_to_resource(np, 0, &iomem);
996         if (err) {
997                 dev_err(dev, "could not get IO memory\n");
998                 return err;
999         }
1000
1001         pc->base = devm_ioremap_resource(dev, &iomem);
1002         if (IS_ERR(pc->base))
1003                 return PTR_ERR(pc->base);
1004
1005         pc->gpio_chip = bcm2835_gpio_chip;
1006         pc->gpio_chip.dev = dev;
1007         pc->gpio_chip.of_node = np;
1008
1009         pc->irq_domain = irq_domain_add_linear(np, BCM2835_NUM_GPIOS,
1010                         &irq_domain_simple_ops, NULL);
1011         if (!pc->irq_domain) {
1012                 dev_err(dev, "could not create IRQ domain\n");
1013                 return -ENOMEM;
1014         }
1015
1016         for (i = 0; i < BCM2835_NUM_GPIOS; i++) {
1017                 int irq = irq_create_mapping(pc->irq_domain, i);
1018                 irq_set_lockdep_class(irq, &gpio_lock_class);
1019                 irq_set_chip_and_handler(irq, &bcm2835_gpio_irq_chip,
1020                                 handle_level_irq);
1021                 irq_set_chip_data(irq, pc);
1022                 set_irq_flags(irq, IRQF_VALID);
1023         }
1024
1025         for (i = 0; i < BCM2835_NUM_BANKS; i++) {
1026                 unsigned long events;
1027                 unsigned offset;
1028
1029                 /* clear event detection flags */
1030                 bcm2835_gpio_wr(pc, GPREN0 + i * 4, 0);
1031                 bcm2835_gpio_wr(pc, GPFEN0 + i * 4, 0);
1032                 bcm2835_gpio_wr(pc, GPHEN0 + i * 4, 0);
1033                 bcm2835_gpio_wr(pc, GPLEN0 + i * 4, 0);
1034                 bcm2835_gpio_wr(pc, GPAREN0 + i * 4, 0);
1035                 bcm2835_gpio_wr(pc, GPAFEN0 + i * 4, 0);
1036
1037                 /* clear all the events */
1038                 events = bcm2835_gpio_rd(pc, GPEDS0 + i * 4);
1039                 for_each_set_bit(offset, &events, 32)
1040                         bcm2835_gpio_wr(pc, GPEDS0 + i * 4, BIT(offset));
1041
1042                 spin_lock_init(&pc->irq_lock[i]);
1043         }
1044
1045         for (i = 0; i < BCM2835_NUM_IRQS; i++) {
1046                 int len;
1047                 char *name;
1048                 pc->irq[i] = irq_of_parse_and_map(np, i);
1049                 if (pc->irq[i] == 0)
1050                         break;
1051                 pc->irq_data[i].pc = pc;
1052                 pc->irq_data[i].irqgroup = i;
1053
1054                 len = strlen(dev_name(pc->dev)) + 16;
1055                 name = devm_kzalloc(pc->dev, len, GFP_KERNEL);
1056                 if (!name)
1057                         return -ENOMEM;
1058                 snprintf(name, len, "%s:bank%d", dev_name(pc->dev), i);
1059
1060                 err = devm_request_irq(dev, pc->irq[i],
1061                         bcm2835_gpio_irq_handler, IRQF_SHARED,
1062                         name, &pc->irq_data[i]);
1063                 if (err) {
1064                         dev_err(dev, "unable to request IRQ %d\n", pc->irq[i]);
1065                         return err;
1066                 }
1067         }
1068
1069         err = gpiochip_add(&pc->gpio_chip);
1070         if (err) {
1071                 dev_err(dev, "could not add GPIO chip\n");
1072                 return err;
1073         }
1074
1075         pc->pctl_dev = pinctrl_register(&bcm2835_pinctrl_desc, dev, pc);
1076         if (!pc->pctl_dev) {
1077                 gpiochip_remove(&pc->gpio_chip);
1078                 return -EINVAL;
1079         }
1080
1081         pc->gpio_range = bcm2835_pinctrl_gpio_range;
1082         pc->gpio_range.base = pc->gpio_chip.base;
1083         pc->gpio_range.gc = &pc->gpio_chip;
1084         pinctrl_add_gpio_range(pc->pctl_dev, &pc->gpio_range);
1085
1086         return 0;
1087 }
1088
1089 static int bcm2835_pinctrl_remove(struct platform_device *pdev)
1090 {
1091         struct bcm2835_pinctrl *pc = platform_get_drvdata(pdev);
1092
1093         pinctrl_unregister(pc->pctl_dev);
1094         gpiochip_remove(&pc->gpio_chip);
1095
1096         return 0;
1097 }
1098
1099 static const struct of_device_id bcm2835_pinctrl_match[] = {
1100         { .compatible = "brcm,bcm2835-gpio" },
1101         {}
1102 };
1103 MODULE_DEVICE_TABLE(of, bcm2835_pinctrl_match);
1104
1105 static struct platform_driver bcm2835_pinctrl_driver = {
1106         .probe = bcm2835_pinctrl_probe,
1107         .remove = bcm2835_pinctrl_remove,
1108         .driver = {
1109                 .name = MODULE_NAME,
1110                 .owner = THIS_MODULE,
1111                 .of_match_table = bcm2835_pinctrl_match,
1112         },
1113 };
1114 module_platform_driver(bcm2835_pinctrl_driver);
1115
1116 MODULE_AUTHOR("Chris Boot, Simon Arlott, Stephen Warren");
1117 MODULE_DESCRIPTION("BCM2835 Pin control driver");
1118 MODULE_LICENSE("GPL");