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