gpio: davinci: Use dev name for label and automatic base selection
[muen/linux.git] / drivers / gpio / gpio-davinci.c
1 /*
2  * TI DaVinci GPIO Support
3  *
4  * Copyright (c) 2006-2007 David Brownell
5  * Copyright (c) 2007, MontaVista Software, Inc. <source@mvista.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  */
12 #include <linux/gpio/driver.h>
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <linux/clk.h>
16 #include <linux/err.h>
17 #include <linux/io.h>
18 #include <linux/irq.h>
19 #include <linux/irqdomain.h>
20 #include <linux/module.h>
21 #include <linux/of.h>
22 #include <linux/of_device.h>
23 #include <linux/pinctrl/consumer.h>
24 #include <linux/platform_device.h>
25 #include <linux/platform_data/gpio-davinci.h>
26 #include <linux/irqchip/chained_irq.h>
27
28 struct davinci_gpio_regs {
29         u32     dir;
30         u32     out_data;
31         u32     set_data;
32         u32     clr_data;
33         u32     in_data;
34         u32     set_rising;
35         u32     clr_rising;
36         u32     set_falling;
37         u32     clr_falling;
38         u32     intstat;
39 };
40
41 typedef struct irq_chip *(*gpio_get_irq_chip_cb_t)(unsigned int irq);
42
43 #define BINTEN  0x8 /* GPIO Interrupt Per-Bank Enable Register */
44
45 static void __iomem *gpio_base;
46 static unsigned int offset_array[5] = {0x10, 0x38, 0x60, 0x88, 0xb0};
47
48 static inline struct davinci_gpio_regs __iomem *irq2regs(struct irq_data *d)
49 {
50         struct davinci_gpio_regs __iomem *g;
51
52         g = (__force struct davinci_gpio_regs __iomem *)irq_data_get_irq_chip_data(d);
53
54         return g;
55 }
56
57 static int davinci_gpio_irq_setup(struct platform_device *pdev);
58
59 /*--------------------------------------------------------------------------*/
60
61 /* board setup code *MUST* setup pinmux and enable the GPIO clock. */
62 static inline int __davinci_direction(struct gpio_chip *chip,
63                         unsigned offset, bool out, int value)
64 {
65         struct davinci_gpio_controller *d = gpiochip_get_data(chip);
66         struct davinci_gpio_regs __iomem *g;
67         unsigned long flags;
68         u32 temp;
69         int bank = offset / 32;
70         u32 mask = __gpio_mask(offset);
71
72         g = d->regs[bank];
73         spin_lock_irqsave(&d->lock, flags);
74         temp = readl_relaxed(&g->dir);
75         if (out) {
76                 temp &= ~mask;
77                 writel_relaxed(mask, value ? &g->set_data : &g->clr_data);
78         } else {
79                 temp |= mask;
80         }
81         writel_relaxed(temp, &g->dir);
82         spin_unlock_irqrestore(&d->lock, flags);
83
84         return 0;
85 }
86
87 static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
88 {
89         return __davinci_direction(chip, offset, false, 0);
90 }
91
92 static int
93 davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
94 {
95         return __davinci_direction(chip, offset, true, value);
96 }
97
98 /*
99  * Read the pin's value (works even if it's set up as output);
100  * returns zero/nonzero.
101  *
102  * Note that changes are synched to the GPIO clock, so reading values back
103  * right after you've set them may give old values.
104  */
105 static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
106 {
107         struct davinci_gpio_controller *d = gpiochip_get_data(chip);
108         struct davinci_gpio_regs __iomem *g;
109         int bank = offset / 32;
110
111         g = d->regs[bank];
112
113         return !!(__gpio_mask(offset) & readl_relaxed(&g->in_data));
114 }
115
116 /*
117  * Assuming the pin is muxed as a gpio output, set its output value.
118  */
119 static void
120 davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
121 {
122         struct davinci_gpio_controller *d = gpiochip_get_data(chip);
123         struct davinci_gpio_regs __iomem *g;
124         int bank = offset / 32;
125
126         g = d->regs[bank];
127
128         writel_relaxed(__gpio_mask(offset),
129                        value ? &g->set_data : &g->clr_data);
130 }
131
132 static struct davinci_gpio_platform_data *
133 davinci_gpio_get_pdata(struct platform_device *pdev)
134 {
135         struct device_node *dn = pdev->dev.of_node;
136         struct davinci_gpio_platform_data *pdata;
137         int ret;
138         u32 val;
139
140         if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node)
141                 return dev_get_platdata(&pdev->dev);
142
143         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
144         if (!pdata)
145                 return NULL;
146
147         ret = of_property_read_u32(dn, "ti,ngpio", &val);
148         if (ret)
149                 goto of_err;
150
151         pdata->ngpio = val;
152
153         ret = of_property_read_u32(dn, "ti,davinci-gpio-unbanked", &val);
154         if (ret)
155                 goto of_err;
156
157         pdata->gpio_unbanked = val;
158
159         return pdata;
160
161 of_err:
162         dev_err(&pdev->dev, "Populating pdata from DT failed: err %d\n", ret);
163         return NULL;
164 }
165
166 static int davinci_gpio_probe(struct platform_device *pdev)
167 {
168         int gpio, bank, i, ret = 0;
169         unsigned int ngpio, nbank, nirq;
170         struct davinci_gpio_controller *chips;
171         struct davinci_gpio_platform_data *pdata;
172         struct device *dev = &pdev->dev;
173         struct resource *res;
174
175         pdata = davinci_gpio_get_pdata(pdev);
176         if (!pdata) {
177                 dev_err(dev, "No platform data found\n");
178                 return -EINVAL;
179         }
180
181         dev->platform_data = pdata;
182
183         /*
184          * The gpio banks conceptually expose a segmented bitmap,
185          * and "ngpio" is one more than the largest zero-based
186          * bit index that's valid.
187          */
188         ngpio = pdata->ngpio;
189         if (ngpio == 0) {
190                 dev_err(dev, "How many GPIOs?\n");
191                 return -EINVAL;
192         }
193
194         if (WARN_ON(ARCH_NR_GPIOS < ngpio))
195                 ngpio = ARCH_NR_GPIOS;
196
197         /*
198          * If there are unbanked interrupts then the number of
199          * interrupts is equal to number of gpios else all are banked so
200          * number of interrupts is equal to number of banks(each with 16 gpios)
201          */
202         if (pdata->gpio_unbanked)
203                 nirq = pdata->gpio_unbanked;
204         else
205                 nirq = DIV_ROUND_UP(ngpio, 16);
206
207         nbank = DIV_ROUND_UP(ngpio, 32);
208         chips = devm_kcalloc(dev,
209                              nbank, sizeof(struct davinci_gpio_controller),
210                              GFP_KERNEL);
211         if (!chips)
212                 return -ENOMEM;
213
214         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
215         gpio_base = devm_ioremap_resource(dev, res);
216         if (IS_ERR(gpio_base))
217                 return PTR_ERR(gpio_base);
218
219         for (i = 0; i < nirq; i++) {
220                 chips->irqs[i] = platform_get_irq(pdev, i);
221                 if (chips->irqs[i] < 0) {
222                         dev_info(dev, "IRQ not populated, err = %d\n",
223                                  chips->irqs[i]);
224                         return chips->irqs[i];
225                 }
226         }
227
228         chips->chip.label = dev_name(dev);
229
230         chips->chip.direction_input = davinci_direction_in;
231         chips->chip.get = davinci_gpio_get;
232         chips->chip.direction_output = davinci_direction_out;
233         chips->chip.set = davinci_gpio_set;
234
235         chips->chip.ngpio = ngpio;
236         chips->chip.base = -1;
237
238 #ifdef CONFIG_OF_GPIO
239         chips->chip.of_gpio_n_cells = 2;
240         chips->chip.parent = dev;
241         chips->chip.of_node = dev->of_node;
242
243         if (of_property_read_bool(dev->of_node, "gpio-ranges")) {
244                 chips->chip.request = gpiochip_generic_request;
245                 chips->chip.free = gpiochip_generic_free;
246         }
247 #endif
248         spin_lock_init(&chips->lock);
249
250         for (gpio = 0, bank = 0; gpio < ngpio; gpio += 32, bank++)
251                 chips->regs[bank] = gpio_base + offset_array[bank];
252
253         ret = devm_gpiochip_add_data(dev, &chips->chip, chips);
254         if (ret)
255                 return ret;
256
257         platform_set_drvdata(pdev, chips);
258         ret = davinci_gpio_irq_setup(pdev);
259         if (ret)
260                 return ret;
261
262         return 0;
263 }
264
265 /*--------------------------------------------------------------------------*/
266 /*
267  * We expect irqs will normally be set up as input pins, but they can also be
268  * used as output pins ... which is convenient for testing.
269  *
270  * NOTE:  The first few GPIOs also have direct INTC hookups in addition
271  * to their GPIOBNK0 irq, with a bit less overhead.
272  *
273  * All those INTC hookups (direct, plus several IRQ banks) can also
274  * serve as EDMA event triggers.
275  */
276
277 static void gpio_irq_disable(struct irq_data *d)
278 {
279         struct davinci_gpio_regs __iomem *g = irq2regs(d);
280         u32 mask = (u32) irq_data_get_irq_handler_data(d);
281
282         writel_relaxed(mask, &g->clr_falling);
283         writel_relaxed(mask, &g->clr_rising);
284 }
285
286 static void gpio_irq_enable(struct irq_data *d)
287 {
288         struct davinci_gpio_regs __iomem *g = irq2regs(d);
289         u32 mask = (u32) irq_data_get_irq_handler_data(d);
290         unsigned status = irqd_get_trigger_type(d);
291
292         status &= IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
293         if (!status)
294                 status = IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
295
296         if (status & IRQ_TYPE_EDGE_FALLING)
297                 writel_relaxed(mask, &g->set_falling);
298         if (status & IRQ_TYPE_EDGE_RISING)
299                 writel_relaxed(mask, &g->set_rising);
300 }
301
302 static int gpio_irq_type(struct irq_data *d, unsigned trigger)
303 {
304         if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
305                 return -EINVAL;
306
307         return 0;
308 }
309
310 static struct irq_chip gpio_irqchip = {
311         .name           = "GPIO",
312         .irq_enable     = gpio_irq_enable,
313         .irq_disable    = gpio_irq_disable,
314         .irq_set_type   = gpio_irq_type,
315         .flags          = IRQCHIP_SET_TYPE_MASKED,
316 };
317
318 static void gpio_irq_handler(struct irq_desc *desc)
319 {
320         struct davinci_gpio_regs __iomem *g;
321         u32 mask = 0xffff;
322         int bank_num;
323         struct davinci_gpio_controller *d;
324         struct davinci_gpio_irq_data *irqdata;
325
326         irqdata = (struct davinci_gpio_irq_data *)irq_desc_get_handler_data(desc);
327         bank_num = irqdata->bank_num;
328         g = irqdata->regs;
329         d = irqdata->chip;
330
331         /* we only care about one bank */
332         if ((bank_num % 2) == 1)
333                 mask <<= 16;
334
335         /* temporarily mask (level sensitive) parent IRQ */
336         chained_irq_enter(irq_desc_get_chip(desc), desc);
337         while (1) {
338                 u32             status;
339                 int             bit;
340                 irq_hw_number_t hw_irq;
341
342                 /* ack any irqs */
343                 status = readl_relaxed(&g->intstat) & mask;
344                 if (!status)
345                         break;
346                 writel_relaxed(status, &g->intstat);
347
348                 /* now demux them to the right lowlevel handler */
349
350                 while (status) {
351                         bit = __ffs(status);
352                         status &= ~BIT(bit);
353                         /* Max number of gpios per controller is 144 so
354                          * hw_irq will be in [0..143]
355                          */
356                         hw_irq = (bank_num / 2) * 32 + bit;
357
358                         generic_handle_irq(
359                                 irq_find_mapping(d->irq_domain, hw_irq));
360                 }
361         }
362         chained_irq_exit(irq_desc_get_chip(desc), desc);
363         /* now it may re-trigger */
364 }
365
366 static int gpio_to_irq_banked(struct gpio_chip *chip, unsigned offset)
367 {
368         struct davinci_gpio_controller *d = gpiochip_get_data(chip);
369
370         if (d->irq_domain)
371                 return irq_create_mapping(d->irq_domain, offset);
372         else
373                 return -ENXIO;
374 }
375
376 static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
377 {
378         struct davinci_gpio_controller *d = gpiochip_get_data(chip);
379
380         /*
381          * NOTE:  we assume for now that only irqs in the first gpio_chip
382          * can provide direct-mapped IRQs to AINTC (up to 32 GPIOs).
383          */
384         if (offset < d->gpio_unbanked)
385                 return d->irqs[offset];
386         else
387                 return -ENODEV;
388 }
389
390 static int gpio_irq_type_unbanked(struct irq_data *data, unsigned trigger)
391 {
392         struct davinci_gpio_controller *d;
393         struct davinci_gpio_regs __iomem *g;
394         u32 mask, i;
395
396         d = (struct davinci_gpio_controller *)irq_data_get_irq_handler_data(data);
397         g = (struct davinci_gpio_regs __iomem *)d->regs[0];
398         for (i = 0; i < MAX_INT_PER_BANK; i++)
399                 if (data->irq == d->irqs[i])
400                         break;
401
402         if (i == MAX_INT_PER_BANK)
403                 return -EINVAL;
404
405         mask = __gpio_mask(i);
406
407         if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
408                 return -EINVAL;
409
410         writel_relaxed(mask, (trigger & IRQ_TYPE_EDGE_FALLING)
411                      ? &g->set_falling : &g->clr_falling);
412         writel_relaxed(mask, (trigger & IRQ_TYPE_EDGE_RISING)
413                      ? &g->set_rising : &g->clr_rising);
414
415         return 0;
416 }
417
418 static int
419 davinci_gpio_irq_map(struct irq_domain *d, unsigned int irq,
420                      irq_hw_number_t hw)
421 {
422         struct davinci_gpio_controller *chips =
423                                 (struct davinci_gpio_controller *)d->host_data;
424         struct davinci_gpio_regs __iomem *g = chips->regs[hw / 32];
425
426         irq_set_chip_and_handler_name(irq, &gpio_irqchip, handle_simple_irq,
427                                 "davinci_gpio");
428         irq_set_irq_type(irq, IRQ_TYPE_NONE);
429         irq_set_chip_data(irq, (__force void *)g);
430         irq_set_handler_data(irq, (void *)__gpio_mask(hw));
431
432         return 0;
433 }
434
435 static const struct irq_domain_ops davinci_gpio_irq_ops = {
436         .map = davinci_gpio_irq_map,
437         .xlate = irq_domain_xlate_onetwocell,
438 };
439
440 static struct irq_chip *davinci_gpio_get_irq_chip(unsigned int irq)
441 {
442         static struct irq_chip_type gpio_unbanked;
443
444         gpio_unbanked = *irq_data_get_chip_type(irq_get_irq_data(irq));
445
446         return &gpio_unbanked.chip;
447 };
448
449 static struct irq_chip *keystone_gpio_get_irq_chip(unsigned int irq)
450 {
451         static struct irq_chip gpio_unbanked;
452
453         gpio_unbanked = *irq_get_chip(irq);
454         return &gpio_unbanked;
455 };
456
457 static const struct of_device_id davinci_gpio_ids[];
458
459 /*
460  * NOTE:  for suspend/resume, probably best to make a platform_device with
461  * suspend_late/resume_resume calls hooking into results of the set_wake()
462  * calls ... so if no gpios are wakeup events the clock can be disabled,
463  * with outputs left at previously set levels, and so that VDD3P3V.IOPWDN0
464  * (dm6446) can be set appropriately for GPIOV33 pins.
465  */
466
467 static int davinci_gpio_irq_setup(struct platform_device *pdev)
468 {
469         unsigned        gpio, bank;
470         int             irq;
471         int             ret;
472         struct clk      *clk;
473         u32             binten = 0;
474         unsigned        ngpio;
475         struct device *dev = &pdev->dev;
476         struct davinci_gpio_controller *chips = platform_get_drvdata(pdev);
477         struct davinci_gpio_platform_data *pdata = dev->platform_data;
478         struct davinci_gpio_regs __iomem *g;
479         struct irq_domain       *irq_domain = NULL;
480         const struct of_device_id *match;
481         struct irq_chip *irq_chip;
482         struct davinci_gpio_irq_data *irqdata;
483         gpio_get_irq_chip_cb_t gpio_get_irq_chip;
484
485         /*
486          * Use davinci_gpio_get_irq_chip by default to handle non DT cases
487          */
488         gpio_get_irq_chip = davinci_gpio_get_irq_chip;
489         match = of_match_device(of_match_ptr(davinci_gpio_ids),
490                                 dev);
491         if (match)
492                 gpio_get_irq_chip = (gpio_get_irq_chip_cb_t)match->data;
493
494         ngpio = pdata->ngpio;
495
496         clk = devm_clk_get(dev, "gpio");
497         if (IS_ERR(clk)) {
498                 dev_err(dev, "Error %ld getting gpio clock\n", PTR_ERR(clk));
499                 return PTR_ERR(clk);
500         }
501
502         ret = clk_prepare_enable(clk);
503         if (ret)
504                 return ret;
505
506         if (!pdata->gpio_unbanked) {
507                 irq = devm_irq_alloc_descs(dev, -1, 0, ngpio, 0);
508                 if (irq < 0) {
509                         dev_err(dev, "Couldn't allocate IRQ numbers\n");
510                         clk_disable_unprepare(clk);
511                         return irq;
512                 }
513
514                 irq_domain = irq_domain_add_legacy(dev->of_node, ngpio, irq, 0,
515                                                         &davinci_gpio_irq_ops,
516                                                         chips);
517                 if (!irq_domain) {
518                         dev_err(dev, "Couldn't register an IRQ domain\n");
519                         clk_disable_unprepare(clk);
520                         return -ENODEV;
521                 }
522         }
523
524         /*
525          * Arrange gpio_to_irq() support, handling either direct IRQs or
526          * banked IRQs.  Having GPIOs in the first GPIO bank use direct
527          * IRQs, while the others use banked IRQs, would need some setup
528          * tweaks to recognize hardware which can do that.
529          */
530         chips->chip.to_irq = gpio_to_irq_banked;
531         chips->irq_domain = irq_domain;
532
533         /*
534          * AINTC can handle direct/unbanked IRQs for GPIOs, with the GPIO
535          * controller only handling trigger modes.  We currently assume no
536          * IRQ mux conflicts; gpio_irq_type_unbanked() is only for GPIOs.
537          */
538         if (pdata->gpio_unbanked) {
539                 /* pass "bank 0" GPIO IRQs to AINTC */
540                 chips->chip.to_irq = gpio_to_irq_unbanked;
541                 chips->gpio_unbanked = pdata->gpio_unbanked;
542                 binten = GENMASK(pdata->gpio_unbanked / 16, 0);
543
544                 /* AINTC handles mask/unmask; GPIO handles triggering */
545                 irq = chips->irqs[0];
546                 irq_chip = gpio_get_irq_chip(irq);
547                 irq_chip->name = "GPIO-AINTC";
548                 irq_chip->irq_set_type = gpio_irq_type_unbanked;
549
550                 /* default trigger: both edges */
551                 g = chips->regs[0];
552                 writel_relaxed(~0, &g->set_falling);
553                 writel_relaxed(~0, &g->set_rising);
554
555                 /* set the direct IRQs up to use that irqchip */
556                 for (gpio = 0; gpio < pdata->gpio_unbanked; gpio++) {
557                         irq_set_chip(chips->irqs[gpio], irq_chip);
558                         irq_set_handler_data(chips->irqs[gpio], chips);
559                         irq_set_status_flags(chips->irqs[gpio],
560                                              IRQ_TYPE_EDGE_BOTH);
561                 }
562
563                 goto done;
564         }
565
566         /*
567          * Or, AINTC can handle IRQs for banks of 16 GPIO IRQs, which we
568          * then chain through our own handler.
569          */
570         for (gpio = 0, bank = 0; gpio < ngpio; bank++, gpio += 16) {
571                 /* disabled by default, enabled only as needed
572                  * There are register sets for 32 GPIOs. 2 banks of 16
573                  * GPIOs are covered by each set of registers hence divide by 2
574                  */
575                 g = chips->regs[bank / 2];
576                 writel_relaxed(~0, &g->clr_falling);
577                 writel_relaxed(~0, &g->clr_rising);
578
579                 /*
580                  * Each chip handles 32 gpios, and each irq bank consists of 16
581                  * gpio irqs. Pass the irq bank's corresponding controller to
582                  * the chained irq handler.
583                  */
584                 irqdata = devm_kzalloc(&pdev->dev,
585                                        sizeof(struct
586                                               davinci_gpio_irq_data),
587                                               GFP_KERNEL);
588                 if (!irqdata) {
589                         clk_disable_unprepare(clk);
590                         return -ENOMEM;
591                 }
592
593                 irqdata->regs = g;
594                 irqdata->bank_num = bank;
595                 irqdata->chip = chips;
596
597                 irq_set_chained_handler_and_data(chips->irqs[bank],
598                                                  gpio_irq_handler, irqdata);
599
600                 binten |= BIT(bank);
601         }
602
603 done:
604         /*
605          * BINTEN -- per-bank interrupt enable. genirq would also let these
606          * bits be set/cleared dynamically.
607          */
608         writel_relaxed(binten, gpio_base + BINTEN);
609
610         return 0;
611 }
612
613 static const struct of_device_id davinci_gpio_ids[] = {
614         { .compatible = "ti,keystone-gpio", keystone_gpio_get_irq_chip},
615         { .compatible = "ti,dm6441-gpio", davinci_gpio_get_irq_chip},
616         { /* sentinel */ },
617 };
618 MODULE_DEVICE_TABLE(of, davinci_gpio_ids);
619
620 static struct platform_driver davinci_gpio_driver = {
621         .probe          = davinci_gpio_probe,
622         .driver         = {
623                 .name           = "davinci_gpio",
624                 .of_match_table = of_match_ptr(davinci_gpio_ids),
625         },
626 };
627
628 /**
629  * GPIO driver registration needs to be done before machine_init functions
630  * access GPIO. Hence davinci_gpio_drv_reg() is a postcore_initcall.
631  */
632 static int __init davinci_gpio_drv_reg(void)
633 {
634         return platform_driver_register(&davinci_gpio_driver);
635 }
636 postcore_initcall(davinci_gpio_drv_reg);