projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'exynos-drm-next' of git://git.infradead.org/users/kmpark/linux-samsung...
[deliverable/linux.git] / drivers / pinctrl / 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/irq.h>
33 #include <linux/module.h>
34 #include <linux/of_address.h>
35 #include <linux/of.h>
36 #include <linux/of_irq.h>
37 #include <linux/pinctrl/consumer.h>
38 #include <linux/pinctrl/machine.h>
39 #include <linux/pinctrl/pinconf.h>
40 #include <linux/pinctrl/pinctrl.h>
41 #include <linux/pinctrl/pinmux.h>
42 #include <linux/platform_device.h>
43 #include <linux/seq_file.h>
44 #include <linux/slab.h>
45 #include <linux/spinlock.h>
46 #include <linux/types.h>
47
48 #define MODULE_NAME "pinctrl-bcm2835"
49 #define BCM2835_NUM_GPIOS 54
50 #define BCM2835_NUM_BANKS 2
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 bank;
93 };
94
95 struct bcm2835_pinctrl {
96 struct device *dev;
97 void __iomem *base;
98 int irq[BCM2835_NUM_BANKS];
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_BANKS];
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 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 return pinctrl_gpio_direction_output(chip->base + offset);
360 }
361
362 static void bcm2835_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
363 {
364 struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
365
366 bcm2835_gpio_set_bit(pc, value ? GPSET0 : GPCLR0, offset);
367 }
368
369 static int bcm2835_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
370 {
371 struct bcm2835_pinctrl *pc = dev_get_drvdata(chip->dev);
372
373 return irq_linear_revmap(pc->irq_domain, offset);
374 }
375
376 static struct gpio_chip bcm2835_gpio_chip __devinitconst = {
377 .label = MODULE_NAME,
378 .owner = THIS_MODULE,
379 .request = bcm2835_gpio_request,
380 .free = bcm2835_gpio_free,
381 .direction_input = bcm2835_gpio_direction_input,
382 .direction_output = bcm2835_gpio_direction_output,
383 .get = bcm2835_gpio_get,
384 .set = bcm2835_gpio_set,
385 .to_irq = bcm2835_gpio_to_irq,
386 .base = -1,
387 .ngpio = BCM2835_NUM_GPIOS,
388 .can_sleep = 0,
389 };
390
391 static irqreturn_t bcm2835_gpio_irq_handler(int irq, void *dev_id)
392 {
393 struct bcm2835_gpio_irqdata *irqdata = dev_id;
394 struct bcm2835_pinctrl *pc = irqdata->pc;
395 int bank = irqdata->bank;
396 unsigned long events;
397 unsigned offset;
398 unsigned gpio;
399 unsigned int type;
400
401 events = bcm2835_gpio_rd(pc, GPEDS0 + bank * 4);
402 events &= pc->enabled_irq_map[bank];
403 for_each_set_bit(offset, &events, 32) {
404 gpio = (32 * bank) + offset;
405 type = pc->irq_type[gpio];
406
407 /* ack edge triggered IRQs immediately */
408 if (!(type & IRQ_TYPE_LEVEL_MASK))
409 bcm2835_gpio_set_bit(pc, GPEDS0, gpio);
410
411 generic_handle_irq(irq_linear_revmap(pc->irq_domain, gpio));
412
413 /* ack level triggered IRQ after handling them */
414 if (type & IRQ_TYPE_LEVEL_MASK)
415 bcm2835_gpio_set_bit(pc, GPEDS0, gpio);
416 }
417 return events ? IRQ_HANDLED : IRQ_NONE;
418 }
419
420 static inline void __bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
421 unsigned reg, unsigned offset, bool enable)
422 {
423 u32 value;
424 reg += GPIO_REG_OFFSET(offset) * 4;
425 value = bcm2835_gpio_rd(pc, reg);
426 if (enable)
427 value |= BIT(GPIO_REG_SHIFT(offset));
428 else
429 value &= ~(BIT(GPIO_REG_SHIFT(offset)));
430 bcm2835_gpio_wr(pc, reg, value);
431 }
432
433 /* fast path for IRQ handler */
434 static void bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
435 unsigned offset, bool enable)
436 {
437 switch (pc->irq_type[offset]) {
438 case IRQ_TYPE_EDGE_RISING:
439 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable);
440 break;
441
442 case IRQ_TYPE_EDGE_FALLING:
443 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable);
444 break;
445
446 case IRQ_TYPE_EDGE_BOTH:
447 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable);
448 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable);
449 break;
450
451 case IRQ_TYPE_LEVEL_HIGH:
452 __bcm2835_gpio_irq_config(pc, GPHEN0, offset, enable);
453 break;
454
455 case IRQ_TYPE_LEVEL_LOW:
456 __bcm2835_gpio_irq_config(pc, GPLEN0, offset, enable);
457 break;
458 }
459 }
460
461 static void bcm2835_gpio_irq_enable(struct irq_data *data)
462 {
463 struct bcm2835_pinctrl *pc = irq_data_get_irq_chip_data(data);
464 unsigned gpio = irqd_to_hwirq(data);
465 unsigned offset = GPIO_REG_SHIFT(gpio);
466 unsigned bank = GPIO_REG_OFFSET(gpio);
467 unsigned long flags;
468
469 spin_lock_irqsave(&pc->irq_lock[bank], flags);
470 set_bit(offset, &pc->enabled_irq_map[bank]);
471 bcm2835_gpio_irq_config(pc, gpio, true);
472 spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
473 }
474
475 static void bcm2835_gpio_irq_disable(struct irq_data *data)
476 {
477 struct bcm2835_pinctrl *pc = irq_data_get_irq_chip_data(data);
478 unsigned gpio = irqd_to_hwirq(data);
479 unsigned offset = GPIO_REG_SHIFT(gpio);
480 unsigned bank = GPIO_REG_OFFSET(gpio);
481 unsigned long flags;
482
483 spin_lock_irqsave(&pc->irq_lock[bank], flags);
484 bcm2835_gpio_irq_config(pc, gpio, false);
485 clear_bit(offset, &pc->enabled_irq_map[bank]);
486 spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
487 }
488
489 static int __bcm2835_gpio_irq_set_type_disabled(struct bcm2835_pinctrl *pc,
490 unsigned offset, unsigned int type)
491 {
492 switch (type) {
493 case IRQ_TYPE_NONE:
494 case IRQ_TYPE_EDGE_RISING:
495 case IRQ_TYPE_EDGE_FALLING:
496 case IRQ_TYPE_EDGE_BOTH:
497 case IRQ_TYPE_LEVEL_HIGH:
498 case IRQ_TYPE_LEVEL_LOW:
499 pc->irq_type[offset] = type;
500 break;
501
502 default:
503 return -EINVAL;
504 }
505 return 0;
506 }
507
508 /* slower path for reconfiguring IRQ type */
509 static int __bcm2835_gpio_irq_set_type_enabled(struct bcm2835_pinctrl *pc,
510 unsigned offset, unsigned int type)
511 {
512 switch (type) {
513 case IRQ_TYPE_NONE:
514 if (pc->irq_type[offset] != type) {
515 bcm2835_gpio_irq_config(pc, offset, false);
516 pc->irq_type[offset] = type;
517 }
518 break;
519
520 case IRQ_TYPE_EDGE_RISING:
521 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) {
522 /* RISING already enabled, disable FALLING */
523 pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING;
524 bcm2835_gpio_irq_config(pc, offset, false);
525 pc->irq_type[offset] = type;
526 } else if (pc->irq_type[offset] != type) {
527 bcm2835_gpio_irq_config(pc, offset, false);
528 pc->irq_type[offset] = type;
529 bcm2835_gpio_irq_config(pc, offset, true);
530 }
531 break;
532
533 case IRQ_TYPE_EDGE_FALLING:
534 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) {
535 /* FALLING already enabled, disable RISING */
536 pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING;
537 bcm2835_gpio_irq_config(pc, offset, false);
538 pc->irq_type[offset] = type;
539 } else if (pc->irq_type[offset] != type) {
540 bcm2835_gpio_irq_config(pc, offset, false);
541 pc->irq_type[offset] = type;
542 bcm2835_gpio_irq_config(pc, offset, true);
543 }
544 break;
545
546 case IRQ_TYPE_EDGE_BOTH:
547 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_RISING) {
548 /* RISING already enabled, enable FALLING too */
549 pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING;
550 bcm2835_gpio_irq_config(pc, offset, true);
551 pc->irq_type[offset] = type;
552 } else if (pc->irq_type[offset] == IRQ_TYPE_EDGE_FALLING) {
553 /* FALLING already enabled, enable RISING too */
554 pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING;
555 bcm2835_gpio_irq_config(pc, offset, true);
556 pc->irq_type[offset] = type;
557 } else if (pc->irq_type[offset] != type) {
558 bcm2835_gpio_irq_config(pc, offset, false);
559 pc->irq_type[offset] = type;
560 bcm2835_gpio_irq_config(pc, offset, true);
561 }
562 break;
563
564 case IRQ_TYPE_LEVEL_HIGH:
565 case IRQ_TYPE_LEVEL_LOW:
566 if (pc->irq_type[offset] != type) {
567 bcm2835_gpio_irq_config(pc, offset, false);
568 pc->irq_type[offset] = type;
569 bcm2835_gpio_irq_config(pc, offset, true);
570 }
571 break;
572
573 default:
574 return -EINVAL;
575 }
576 return 0;
577 }
578
579 static int bcm2835_gpio_irq_set_type(struct irq_data *data, unsigned int type)
580 {
581 struct bcm2835_pinctrl *pc = irq_data_get_irq_chip_data(data);
582 unsigned gpio = irqd_to_hwirq(data);
583 unsigned offset = GPIO_REG_SHIFT(gpio);
584 unsigned bank = GPIO_REG_OFFSET(gpio);
585 unsigned long flags;
586 int ret;
587
588 spin_lock_irqsave(&pc->irq_lock[bank], flags);
589
590 if (test_bit(offset, &pc->enabled_irq_map[bank]))
591 ret = __bcm2835_gpio_irq_set_type_enabled(pc, gpio, type);
592 else
593 ret = __bcm2835_gpio_irq_set_type_disabled(pc, gpio, type);
594
595 spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
596
597 return ret;
598 }
599
600 static struct irq_chip bcm2835_gpio_irq_chip = {
601 .name = MODULE_NAME,
602 .irq_enable = bcm2835_gpio_irq_enable,
603 .irq_disable = bcm2835_gpio_irq_disable,
604 .irq_set_type = bcm2835_gpio_irq_set_type,
605 };
606
607 static int bcm2835_pctl_get_groups_count(struct pinctrl_dev *pctldev)
608 {
609 return ARRAY_SIZE(bcm2835_gpio_groups);
610 }
611
612 static const char *bcm2835_pctl_get_group_name(struct pinctrl_dev *pctldev,
613 unsigned selector)
614 {
615 return bcm2835_gpio_groups[selector];
616 }
617
618 static int bcm2835_pctl_get_group_pins(struct pinctrl_dev *pctldev,
619 unsigned selector,
620 const unsigned **pins,
621 unsigned *num_pins)
622 {
623 *pins = &bcm2835_gpio_pins[selector].number;
624 *num_pins = 1;
625
626 return 0;
627 }
628
629 static void bcm2835_pctl_pin_dbg_show(struct pinctrl_dev *pctldev,
630 struct seq_file *s,
631 unsigned offset)
632 {
633 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
634 enum bcm2835_fsel fsel = bcm2835_pinctrl_fsel_get(pc, offset);
635 const char *fname = bcm2835_functions[fsel];
636 int value = bcm2835_gpio_get_bit(pc, GPLEV0, offset);
637 int irq = irq_find_mapping(pc->irq_domain, offset);
638
639 seq_printf(s, "function %s in %s; irq %d (%s)",
640 fname, value ? "hi" : "lo",
641 irq, irq_type_names[pc->irq_type[offset]]);
642 }
643
644 static void bcm2835_pctl_dt_free_map(struct pinctrl_dev *pctldev,
645 struct pinctrl_map *maps, unsigned num_maps)
646 {
647 int i;
648
649 for (i = 0; i < num_maps; i++)
650 if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
651 kfree(maps[i].data.configs.configs);
652
653 kfree(maps);
654 }
655
656 static int bcm2835_pctl_dt_node_to_map_func(struct bcm2835_pinctrl *pc,
657 struct device_node *np, u32 pin, u32 fnum,
658 struct pinctrl_map **maps)
659 {
660 struct pinctrl_map *map = *maps;
661
662 if (fnum >= ARRAY_SIZE(bcm2835_functions)) {
663 dev_err(pc->dev, "%s: invalid brcm,function %d\n",
664 of_node_full_name(np), fnum);
665 return -EINVAL;
666 }
667
668 map->type = PIN_MAP_TYPE_MUX_GROUP;
669 map->data.mux.group = bcm2835_gpio_groups[pin];
670 map->data.mux.function = bcm2835_functions[fnum];
671 (*maps)++;
672
673 return 0;
674 }
675
676 static int bcm2835_pctl_dt_node_to_map_pull(struct bcm2835_pinctrl *pc,
677 struct device_node *np, u32 pin, u32 pull,
678 struct pinctrl_map **maps)
679 {
680 struct pinctrl_map *map = *maps;
681 unsigned long *configs;
682
683 if (pull > 2) {
684 dev_err(pc->dev, "%s: invalid brcm,pull %d\n",
685 of_node_full_name(np), pull);
686 return -EINVAL;
687 }
688
689 configs = kzalloc(sizeof(*configs), GFP_KERNEL);
690 if (!configs)
691 return -ENOMEM;
692 configs[0] = BCM2835_PINCONF_PACK(BCM2835_PINCONF_PARAM_PULL, pull);
693
694 map->type = PIN_MAP_TYPE_CONFIGS_PIN;
695 map->data.configs.group_or_pin = bcm2835_gpio_pins[pin].name;
696 map->data.configs.configs = configs;
697 map->data.configs.num_configs = 1;
698 (*maps)++;
699
700 return 0;
701 }
702
703 static inline u32 prop_u32(struct property *p, int i)
704 {
705 return be32_to_cpup(((__be32 *)p->value) + i);
706 }
707
708 static int bcm2835_pctl_dt_node_to_map(struct pinctrl_dev *pctldev,
709 struct device_node *np,
710 struct pinctrl_map **map, unsigned *num_maps)
711 {
712 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
713 struct property *pins, *funcs, *pulls;
714 int num_pins, num_funcs, num_pulls, maps_per_pin;
715 struct pinctrl_map *maps, *cur_map;
716 int i, err;
717 u32 pin, func, pull;
718
719 pins = of_find_property(np, "brcm,pins", NULL);
720 if (!pins) {
721 dev_err(pc->dev, "%s: missing brcm,pins property\n",
722 of_node_full_name(np));
723 return -EINVAL;
724 }
725
726 funcs = of_find_property(np, "brcm,function", NULL);
727 pulls = of_find_property(np, "brcm,pull", NULL);
728
729 if (!funcs && !pulls) {
730 dev_err(pc->dev,
731 "%s: neither brcm,function nor brcm,pull specified\n",
732 of_node_full_name(np));
733 return -EINVAL;
734 }
735
736 num_pins = pins->length / 4;
737 num_funcs = funcs ? (funcs->length / 4) : 0;
738 num_pulls = pulls ? (pulls->length / 4) : 0;
739
740 if (num_funcs > 1 && num_funcs != num_pins) {
741 dev_err(pc->dev,
742 "%s: brcm,function must have 1 or %d entries\n",
743 of_node_full_name(np), num_pins);
744 return -EINVAL;
745 }
746
747 if (num_pulls > 1 && num_pulls != num_pins) {
748 dev_err(pc->dev,
749 "%s: brcm,pull must have 1 or %d entries\n",
750 of_node_full_name(np), num_pins);
751 return -EINVAL;
752 }
753
754 maps_per_pin = 0;
755 if (num_funcs)
756 maps_per_pin++;
757 if (num_pulls)
758 maps_per_pin++;
759 cur_map = maps = kzalloc(num_pins * maps_per_pin * sizeof(*maps),
760 GFP_KERNEL);
761 if (!maps)
762 return -ENOMEM;
763
764 for (i = 0; i < num_pins; i++) {
765 pin = prop_u32(pins, i);
766 if (pin >= ARRAY_SIZE(bcm2835_gpio_pins)) {
767 dev_err(pc->dev, "%s: invalid brcm,pins value %d\n",
768 of_node_full_name(np), pin);
769 err = -EINVAL;
770 goto out;
771 }
772
773 if (num_funcs) {
774 func = prop_u32(funcs, (num_funcs > 1) ? i : 0);
775 err = bcm2835_pctl_dt_node_to_map_func(pc, np, pin,
776 func, &cur_map);
777 if (err)
778 goto out;
779 }
780 if (num_pulls) {
781 pull = prop_u32(pulls, (num_pulls > 1) ? i : 0);
782 err = bcm2835_pctl_dt_node_to_map_pull(pc, np, pin,
783 pull, &cur_map);
784 if (err)
785 goto out;
786 }
787 }
788
789 *map = maps;
790 *num_maps = num_pins * maps_per_pin;
791
792 return 0;
793
794 out:
795 kfree(maps);
796 return err;
797 }
798
799 static struct pinctrl_ops bcm2835_pctl_ops = {
800 .get_groups_count = bcm2835_pctl_get_groups_count,
801 .get_group_name = bcm2835_pctl_get_group_name,
802 .get_group_pins = bcm2835_pctl_get_group_pins,
803 .pin_dbg_show = bcm2835_pctl_pin_dbg_show,
804 .dt_node_to_map = bcm2835_pctl_dt_node_to_map,
805 .dt_free_map = bcm2835_pctl_dt_free_map,
806 };
807
808 static int bcm2835_pmx_get_functions_count(struct pinctrl_dev *pctldev)
809 {
810 return BCM2835_FSEL_COUNT;
811 }
812
813 static const char *bcm2835_pmx_get_function_name(struct pinctrl_dev *pctldev,
814 unsigned selector)
815 {
816 return bcm2835_functions[selector];
817 }
818
819 static int bcm2835_pmx_get_function_groups(struct pinctrl_dev *pctldev,
820 unsigned selector,
821 const char * const **groups,
822 unsigned * const num_groups)
823 {
824 /* every pin can do every function */
825 *groups = bcm2835_gpio_groups;
826 *num_groups = ARRAY_SIZE(bcm2835_gpio_groups);
827
828 return 0;
829 }
830
831 static int bcm2835_pmx_enable(struct pinctrl_dev *pctldev,
832 unsigned func_selector,
833 unsigned group_selector)
834 {
835 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
836
837 bcm2835_pinctrl_fsel_set(pc, group_selector, func_selector);
838
839 return 0;
840 }
841
842 static void bcm2835_pmx_disable(struct pinctrl_dev *pctldev,
843 unsigned func_selector,
844 unsigned group_selector)
845 {
846 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
847
848 /* disable by setting to GPIO_IN */
849 bcm2835_pinctrl_fsel_set(pc, group_selector, BCM2835_FSEL_GPIO_IN);
850 }
851
852 static void bcm2835_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
853 struct pinctrl_gpio_range *range,
854 unsigned offset)
855 {
856 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
857
858 /* disable by setting to GPIO_IN */
859 bcm2835_pinctrl_fsel_set(pc, offset, BCM2835_FSEL_GPIO_IN);
860 }
861
862 static int bcm2835_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
863 struct pinctrl_gpio_range *range,
864 unsigned offset,
865 bool input)
866 {
867 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
868 enum bcm2835_fsel fsel = input ?
869 BCM2835_FSEL_GPIO_IN : BCM2835_FSEL_GPIO_OUT;
870
871 bcm2835_pinctrl_fsel_set(pc, offset, fsel);
872
873 return 0;
874 }
875
876 static struct pinmux_ops bcm2835_pmx_ops = {
877 .get_functions_count = bcm2835_pmx_get_functions_count,
878 .get_function_name = bcm2835_pmx_get_function_name,
879 .get_function_groups = bcm2835_pmx_get_function_groups,
880 .enable = bcm2835_pmx_enable,
881 .disable = bcm2835_pmx_disable,
882 .gpio_disable_free = bcm2835_pmx_gpio_disable_free,
883 .gpio_set_direction = bcm2835_pmx_gpio_set_direction,
884 };
885
886 static int bcm2835_pinconf_get(struct pinctrl_dev *pctldev,
887 unsigned pin, unsigned long *config)
888 {
889 /* No way to read back config in HW */
890 return -ENOTSUPP;
891 }
892
893 static int bcm2835_pinconf_set(struct pinctrl_dev *pctldev,
894 unsigned pin, unsigned long config)
895 {
896 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
897 enum bcm2835_pinconf_param param = BCM2835_PINCONF_UNPACK_PARAM(config);
898 u16 arg = BCM2835_PINCONF_UNPACK_ARG(config);
899 u32 off, bit;
900
901 if (param != BCM2835_PINCONF_PARAM_PULL)
902 return -EINVAL;
903
904 off = GPIO_REG_OFFSET(pin);
905 bit = GPIO_REG_SHIFT(pin);
906
907 bcm2835_gpio_wr(pc, GPPUD, arg & 3);
908 /*
909 * Docs say to wait 150 cycles, but not of what. We assume a
910 * 1 MHz clock here, which is pretty slow...
911 */
912 udelay(150);
913 bcm2835_gpio_wr(pc, GPPUDCLK0 + (off * 4), BIT(bit));
914 udelay(150);
915 bcm2835_gpio_wr(pc, GPPUDCLK0 + (off * 4), 0);
916
917 return 0;
918 }
919
920 struct pinconf_ops bcm2835_pinconf_ops = {
921 .pin_config_get = bcm2835_pinconf_get,
922 .pin_config_set = bcm2835_pinconf_set,
923 };
924
925 static struct pinctrl_desc bcm2835_pinctrl_desc = {
926 .name = MODULE_NAME,
927 .pins = bcm2835_gpio_pins,
928 .npins = ARRAY_SIZE(bcm2835_gpio_pins),
929 .pctlops = &bcm2835_pctl_ops,
930 .pmxops = &bcm2835_pmx_ops,
931 .confops = &bcm2835_pinconf_ops,
932 .owner = THIS_MODULE,
933 };
934
935 static struct pinctrl_gpio_range bcm2835_pinctrl_gpio_range __devinitconst = {
936 .name = MODULE_NAME,
937 .npins = BCM2835_NUM_GPIOS,
938 };
939
940 static int __devinit bcm2835_pinctrl_probe(struct platform_device *pdev)
941 {
942 struct device *dev = &pdev->dev;
943 struct device_node *np = dev->of_node;
944 struct bcm2835_pinctrl *pc;
945 struct resource iomem;
946 int err, i;
947 BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_pins) != BCM2835_NUM_GPIOS);
948 BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_groups) != BCM2835_NUM_GPIOS);
949
950 pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL);
951 if (!pc)
952 return -ENOMEM;
953
954 platform_set_drvdata(pdev, pc);
955 pc->dev = dev;
956
957 err = of_address_to_resource(np, 0, &iomem);
958 if (err) {
959 dev_err(dev, "could not get IO memory\n");
960 return err;
961 }
962
963 pc->base = devm_request_and_ioremap(&pdev->dev, &iomem);
964 if (!pc->base)
965 return -EADDRNOTAVAIL;
966
967 pc->gpio_chip = bcm2835_gpio_chip;
968 pc->gpio_chip.dev = dev;
969 pc->gpio_chip.of_node = np;
970
971 pc->irq_domain = irq_domain_add_linear(np, BCM2835_NUM_GPIOS,
972 &irq_domain_simple_ops, NULL);
973 if (!pc->irq_domain) {
974 dev_err(dev, "could not create IRQ domain\n");
975 return -ENOMEM;
976 }
977
978 for (i = 0; i < BCM2835_NUM_GPIOS; i++) {
979 int irq = irq_create_mapping(pc->irq_domain, i);
980 irq_set_lockdep_class(irq, &gpio_lock_class);
981 irq_set_chip_and_handler(irq, &bcm2835_gpio_irq_chip,
982 handle_simple_irq);
983 irq_set_chip_data(irq, pc);
984 set_irq_flags(irq, IRQF_VALID);
985 }
986
987 for (i = 0; i < BCM2835_NUM_BANKS; i++) {
988 unsigned long events;
989 unsigned offset;
990 int len;
991 char *name;
992
993 /* clear event detection flags */
994 bcm2835_gpio_wr(pc, GPREN0 + i * 4, 0);
995 bcm2835_gpio_wr(pc, GPFEN0 + i * 4, 0);
996 bcm2835_gpio_wr(pc, GPHEN0 + i * 4, 0);
997 bcm2835_gpio_wr(pc, GPLEN0 + i * 4, 0);
998 bcm2835_gpio_wr(pc, GPAREN0 + i * 4, 0);
999 bcm2835_gpio_wr(pc, GPAFEN0 + i * 4, 0);
1000
1001 /* clear all the events */
1002 events = bcm2835_gpio_rd(pc, GPEDS0 + i * 4);
1003 for_each_set_bit(offset, &events, 32)
1004 bcm2835_gpio_wr(pc, GPEDS0 + i * 4, BIT(offset));
1005
1006 pc->irq[i] = irq_of_parse_and_map(np, i);
1007 pc->irq_data[i].pc = pc;
1008 pc->irq_data[i].bank = i;
1009 spin_lock_init(&pc->irq_lock[i]);
1010
1011 len = strlen(dev_name(pc->dev)) + 16;
1012 name = devm_kzalloc(pc->dev, len, GFP_KERNEL);
1013 if (!name)
1014 return -ENOMEM;
1015 snprintf(name, len, "%s:bank%d", dev_name(pc->dev), i);
1016
1017 err = devm_request_irq(dev, pc->irq[i],
1018 bcm2835_gpio_irq_handler, IRQF_SHARED,
1019 name, &pc->irq_data[i]);
1020 if (err) {
1021 dev_err(dev, "unable to request IRQ %d\n", pc->irq[i]);
1022 return err;
1023 }
1024 }
1025
1026 err = gpiochip_add(&pc->gpio_chip);
1027 if (err) {
1028 dev_err(dev, "could not add GPIO chip\n");
1029 return err;
1030 }
1031
1032 pc->pctl_dev = pinctrl_register(&bcm2835_pinctrl_desc, dev, pc);
1033 if (!pc->pctl_dev) {
1034 gpiochip_remove(&pc->gpio_chip);
1035 return PTR_ERR(pc->pctl_dev);
1036 }
1037
1038 pc->gpio_range = bcm2835_pinctrl_gpio_range;
1039 pc->gpio_range.base = pc->gpio_chip.base;
1040 pc->gpio_range.gc = &pc->gpio_chip;
1041 pinctrl_add_gpio_range(pc->pctl_dev, &pc->gpio_range);
1042
1043 return 0;
1044 }
1045
1046 static int __devexit bcm2835_pinctrl_remove(struct platform_device *pdev)
1047 {
1048 struct bcm2835_pinctrl *pc = platform_get_drvdata(pdev);
1049
1050 pinctrl_unregister(pc->pctl_dev);
1051 gpiochip_remove(&pc->gpio_chip);
1052
1053 return 0;
1054 }
1055
1056 static struct of_device_id bcm2835_pinctrl_match[] __devinitconst = {
1057 { .compatible = "brcm,bcm2835-gpio" },
1058 {}
1059 };
1060 MODULE_DEVICE_TABLE(of, bcm2835_pinctrl_match);
1061
1062 static struct platform_driver bcm2835_pinctrl_driver = {
1063 .probe = bcm2835_pinctrl_probe,
1064 .remove = bcm2835_pinctrl_remove,
1065 .driver = {
1066 .name = MODULE_NAME,
1067 .owner = THIS_MODULE,
1068 .of_match_table = bcm2835_pinctrl_match,
1069 },
1070 };
1071 module_platform_driver(bcm2835_pinctrl_driver);
1072
1073 MODULE_AUTHOR("Chris Boot, Simon Arlott, Stephen Warren");
1074 MODULE_DESCRIPTION("BCM2835 Pin control driver");
1075 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.176743 seconds and 5 git commands to generate.