2 * TI DaVinci GPIO Support
4 * Copyright (c) 2006-2007 David Brownell
5 * Copyright (c) 2007, MontaVista Software, Inc. <source@mvista.com>
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.
12 #include <linux/gpio.h>
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <linux/clk.h>
16 #include <linux/err.h>
18 #include <linux/irq.h>
19 #include <linux/irqdomain.h>
20 #include <linux/platform_device.h>
21 #include <linux/platform_data/gpio-davinci.h>
23 struct davinci_gpio_regs {
36 #define BINTEN 0x8 /* GPIO Interrupt Per-Bank Enable Register */
38 #define chip2controller(chip) \
39 container_of(chip, struct davinci_gpio_controller, chip)
41 static void __iomem *gpio_base;
43 static struct davinci_gpio_regs __iomem *gpio2regs(unsigned gpio)
48 ptr = gpio_base + 0x10;
49 else if (gpio < 32 * 2)
50 ptr = gpio_base + 0x38;
51 else if (gpio < 32 * 3)
52 ptr = gpio_base + 0x60;
53 else if (gpio < 32 * 4)
54 ptr = gpio_base + 0x88;
55 else if (gpio < 32 * 5)
56 ptr = gpio_base + 0xb0;
62 static inline struct davinci_gpio_regs __iomem *irq2regs(int irq)
64 struct davinci_gpio_regs __iomem *g;
66 g = (__force struct davinci_gpio_regs __iomem *)irq_get_chip_data(irq);
71 static int davinci_gpio_irq_setup(struct platform_device *pdev);
73 /*--------------------------------------------------------------------------*/
75 /* board setup code *MUST* setup pinmux and enable the GPIO clock. */
76 static inline int __davinci_direction(struct gpio_chip *chip,
77 unsigned offset, bool out, int value)
79 struct davinci_gpio_controller *d = chip2controller(chip);
80 struct davinci_gpio_regs __iomem *g = d->regs;
83 u32 mask = 1 << offset;
85 spin_lock_irqsave(&d->lock, flags);
86 temp = readl_relaxed(&g->dir);
89 writel_relaxed(mask, value ? &g->set_data : &g->clr_data);
93 writel_relaxed(temp, &g->dir);
94 spin_unlock_irqrestore(&d->lock, flags);
99 static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
101 return __davinci_direction(chip, offset, false, 0);
105 davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
107 return __davinci_direction(chip, offset, true, value);
111 * Read the pin's value (works even if it's set up as output);
112 * returns zero/nonzero.
114 * Note that changes are synched to the GPIO clock, so reading values back
115 * right after you've set them may give old values.
117 static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
119 struct davinci_gpio_controller *d = chip2controller(chip);
120 struct davinci_gpio_regs __iomem *g = d->regs;
122 return (1 << offset) & readl_relaxed(&g->in_data);
126 * Assuming the pin is muxed as a gpio output, set its output value.
129 davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
131 struct davinci_gpio_controller *d = chip2controller(chip);
132 struct davinci_gpio_regs __iomem *g = d->regs;
134 writel_relaxed((1 << offset), value ? &g->set_data : &g->clr_data);
137 static int davinci_gpio_probe(struct platform_device *pdev)
141 struct davinci_gpio_controller *chips;
142 struct davinci_gpio_platform_data *pdata;
143 struct davinci_gpio_regs __iomem *regs;
144 struct device *dev = &pdev->dev;
145 struct resource *res;
147 pdata = dev->platform_data;
149 dev_err(dev, "No platform data found\n");
154 * The gpio banks conceptually expose a segmented bitmap,
155 * and "ngpio" is one more than the largest zero-based
156 * bit index that's valid.
158 ngpio = pdata->ngpio;
160 dev_err(dev, "How many GPIOs?\n");
164 if (WARN_ON(ARCH_NR_GPIOS < ngpio))
165 ngpio = ARCH_NR_GPIOS;
167 chips = devm_kzalloc(dev,
168 ngpio * sizeof(struct davinci_gpio_controller),
171 dev_err(dev, "Memory allocation failed\n");
175 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
177 dev_err(dev, "Invalid memory resource\n");
181 gpio_base = devm_ioremap_resource(dev, res);
182 if (IS_ERR(gpio_base))
183 return PTR_ERR(gpio_base);
185 for (i = 0, base = 0; base < ngpio; i++, base += 32) {
186 chips[i].chip.label = "DaVinci";
188 chips[i].chip.direction_input = davinci_direction_in;
189 chips[i].chip.get = davinci_gpio_get;
190 chips[i].chip.direction_output = davinci_direction_out;
191 chips[i].chip.set = davinci_gpio_set;
193 chips[i].chip.base = base;
194 chips[i].chip.ngpio = ngpio - base;
195 if (chips[i].chip.ngpio > 32)
196 chips[i].chip.ngpio = 32;
198 spin_lock_init(&chips[i].lock);
200 regs = gpio2regs(base);
201 chips[i].regs = regs;
202 chips[i].set_data = ®s->set_data;
203 chips[i].clr_data = ®s->clr_data;
204 chips[i].in_data = ®s->in_data;
206 gpiochip_add(&chips[i].chip);
209 platform_set_drvdata(pdev, chips);
210 davinci_gpio_irq_setup(pdev);
214 /*--------------------------------------------------------------------------*/
216 * We expect irqs will normally be set up as input pins, but they can also be
217 * used as output pins ... which is convenient for testing.
219 * NOTE: The first few GPIOs also have direct INTC hookups in addition
220 * to their GPIOBNK0 irq, with a bit less overhead.
222 * All those INTC hookups (direct, plus several IRQ banks) can also
223 * serve as EDMA event triggers.
226 static void gpio_irq_disable(struct irq_data *d)
228 struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
229 u32 mask = (u32) irq_data_get_irq_handler_data(d);
231 writel_relaxed(mask, &g->clr_falling);
232 writel_relaxed(mask, &g->clr_rising);
235 static void gpio_irq_enable(struct irq_data *d)
237 struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
238 u32 mask = (u32) irq_data_get_irq_handler_data(d);
239 unsigned status = irqd_get_trigger_type(d);
241 status &= IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
243 status = IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
245 if (status & IRQ_TYPE_EDGE_FALLING)
246 writel_relaxed(mask, &g->set_falling);
247 if (status & IRQ_TYPE_EDGE_RISING)
248 writel_relaxed(mask, &g->set_rising);
251 static int gpio_irq_type(struct irq_data *d, unsigned trigger)
253 if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
259 static struct irq_chip gpio_irqchip = {
261 .irq_enable = gpio_irq_enable,
262 .irq_disable = gpio_irq_disable,
263 .irq_set_type = gpio_irq_type,
264 .flags = IRQCHIP_SET_TYPE_MASKED,
268 gpio_irq_handler(unsigned irq, struct irq_desc *desc)
270 struct davinci_gpio_regs __iomem *g;
272 struct davinci_gpio_controller *d;
274 d = (struct davinci_gpio_controller *)irq_desc_get_handler_data(desc);
275 g = (struct davinci_gpio_regs __iomem *)d->regs;
277 /* we only care about one bank */
281 /* temporarily mask (level sensitive) parent IRQ */
282 desc->irq_data.chip->irq_mask(&desc->irq_data);
283 desc->irq_data.chip->irq_ack(&desc->irq_data);
289 status = readl_relaxed(&g->intstat) & mask;
292 writel_relaxed(status, &g->intstat);
294 /* now demux them to the right lowlevel handler */
300 irq_find_mapping(d->irq_domain,
301 d->chip.base + bit));
304 desc->irq_data.chip->irq_unmask(&desc->irq_data);
305 /* now it may re-trigger */
308 static int gpio_to_irq_banked(struct gpio_chip *chip, unsigned offset)
310 struct davinci_gpio_controller *d = chip2controller(chip);
312 return irq_create_mapping(d->irq_domain, d->chip.base + offset);
315 static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
317 struct davinci_gpio_controller *d = chip2controller(chip);
320 * NOTE: we assume for now that only irqs in the first gpio_chip
321 * can provide direct-mapped IRQs to AINTC (up to 32 GPIOs).
323 if (offset < d->gpio_unbanked)
324 return d->gpio_irq + offset;
329 static int gpio_irq_type_unbanked(struct irq_data *data, unsigned trigger)
331 struct davinci_gpio_controller *d;
332 struct davinci_gpio_regs __iomem *g;
335 d = (struct davinci_gpio_controller *)data->handler_data;
336 g = (struct davinci_gpio_regs __iomem *)d->regs;
337 mask = __gpio_mask(data->irq - d->gpio_irq);
339 if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
342 writel_relaxed(mask, (trigger & IRQ_TYPE_EDGE_FALLING)
343 ? &g->set_falling : &g->clr_falling);
344 writel_relaxed(mask, (trigger & IRQ_TYPE_EDGE_RISING)
345 ? &g->set_rising : &g->clr_rising);
351 davinci_gpio_irq_map(struct irq_domain *d, unsigned int irq,
354 struct davinci_gpio_regs __iomem *g = gpio2regs(hw);
356 irq_set_chip_and_handler_name(irq, &gpio_irqchip, handle_simple_irq,
358 irq_set_irq_type(irq, IRQ_TYPE_NONE);
359 irq_set_chip_data(irq, (__force void *)g);
360 irq_set_handler_data(irq, (void *)__gpio_mask(hw));
361 set_irq_flags(irq, IRQF_VALID);
366 static const struct irq_domain_ops davinci_gpio_irq_ops = {
367 .map = davinci_gpio_irq_map,
368 .xlate = irq_domain_xlate_onetwocell,
372 * NOTE: for suspend/resume, probably best to make a platform_device with
373 * suspend_late/resume_resume calls hooking into results of the set_wake()
374 * calls ... so if no gpios are wakeup events the clock can be disabled,
375 * with outputs left at previously set levels, and so that VDD3P3V.IOPWDN0
376 * (dm6446) can be set appropriately for GPIOV33 pins.
379 static int davinci_gpio_irq_setup(struct platform_device *pdev)
381 unsigned gpio, irq, bank;
384 unsigned ngpio, bank_irq;
385 struct device *dev = &pdev->dev;
386 struct resource *res;
387 struct davinci_gpio_controller *chips = platform_get_drvdata(pdev);
388 struct davinci_gpio_platform_data *pdata = dev->platform_data;
389 struct davinci_gpio_regs __iomem *g;
390 struct irq_domain *irq_domain;
392 ngpio = pdata->ngpio;
393 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
395 dev_err(dev, "Invalid IRQ resource\n");
399 bank_irq = res->start;
402 dev_err(dev, "Invalid IRQ resource\n");
406 clk = devm_clk_get(dev, "gpio");
408 printk(KERN_ERR "Error %ld getting gpio clock?\n",
412 clk_prepare_enable(clk);
414 irq = irq_alloc_descs(-1, 0, ngpio, 0);
416 dev_err(dev, "Couldn't allocate IRQ numbers\n");
420 irq_domain = irq_domain_add_legacy(NULL, ngpio, irq, 0,
421 &davinci_gpio_irq_ops,
424 dev_err(dev, "Couldn't register an IRQ domain\n");
429 * Arrange gpio_to_irq() support, handling either direct IRQs or
430 * banked IRQs. Having GPIOs in the first GPIO bank use direct
431 * IRQs, while the others use banked IRQs, would need some setup
432 * tweaks to recognize hardware which can do that.
434 for (gpio = 0, bank = 0; gpio < ngpio; bank++, gpio += 32) {
435 chips[bank].chip.to_irq = gpio_to_irq_banked;
436 if (!pdata->gpio_unbanked)
437 chips[bank].irq_domain = irq_domain;
441 * AINTC can handle direct/unbanked IRQs for GPIOs, with the GPIO
442 * controller only handling trigger modes. We currently assume no
443 * IRQ mux conflicts; gpio_irq_type_unbanked() is only for GPIOs.
445 if (pdata->gpio_unbanked) {
446 static struct irq_chip_type gpio_unbanked;
448 /* pass "bank 0" GPIO IRQs to AINTC */
449 chips[0].chip.to_irq = gpio_to_irq_unbanked;
450 chips[0].gpio_irq = bank_irq;
451 chips[0].gpio_unbanked = pdata->gpio_unbanked;
454 /* AINTC handles mask/unmask; GPIO handles triggering */
456 gpio_unbanked = *container_of(irq_get_chip(irq),
457 struct irq_chip_type, chip);
458 gpio_unbanked.chip.name = "GPIO-AINTC";
459 gpio_unbanked.chip.irq_set_type = gpio_irq_type_unbanked;
461 /* default trigger: both edges */
463 writel_relaxed(~0, &g->set_falling);
464 writel_relaxed(~0, &g->set_rising);
466 /* set the direct IRQs up to use that irqchip */
467 for (gpio = 0; gpio < pdata->gpio_unbanked; gpio++, irq++) {
468 irq_set_chip(irq, &gpio_unbanked.chip);
469 irq_set_handler_data(irq, &chips[gpio / 32]);
470 irq_set_status_flags(irq, IRQ_TYPE_EDGE_BOTH);
477 * Or, AINTC can handle IRQs for banks of 16 GPIO IRQs, which we
478 * then chain through our own handler.
480 for (gpio = 0, bank = 0; gpio < ngpio; bank++, bank_irq++, gpio += 16) {
481 /* disabled by default, enabled only as needed */
483 writel_relaxed(~0, &g->clr_falling);
484 writel_relaxed(~0, &g->clr_rising);
486 /* set up all irqs in this bank */
487 irq_set_chained_handler(bank_irq, gpio_irq_handler);
490 * Each chip handles 32 gpios, and each irq bank consists of 16
491 * gpio irqs. Pass the irq bank's corresponding controller to
492 * the chained irq handler.
494 irq_set_handler_data(bank_irq, &chips[gpio / 32]);
501 * BINTEN -- per-bank interrupt enable. genirq would also let these
502 * bits be set/cleared dynamically.
504 writel_relaxed(binten, gpio_base + BINTEN);
509 static struct platform_driver davinci_gpio_driver = {
510 .probe = davinci_gpio_probe,
512 .name = "davinci_gpio",
513 .owner = THIS_MODULE,
518 * GPIO driver registration needs to be done before machine_init functions
519 * access GPIO. Hence davinci_gpio_drv_reg() is a postcore_initcall.
521 static int __init davinci_gpio_drv_reg(void)
523 return platform_driver_register(&davinci_gpio_driver);
525 postcore_initcall(davinci_gpio_drv_reg);