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.
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <linux/clk.h>
16 #include <linux/err.h>
19 #include <mach/gpio.h>
21 #include <asm/mach/irq.h>
23 struct davinci_gpio_regs
{
36 static DEFINE_SPINLOCK(gpio_lock
);
38 #define chip2controller(chip) \
39 container_of(chip, struct davinci_gpio_controller, chip)
41 static struct davinci_gpio_controller chips
[DIV_ROUND_UP(DAVINCI_N_GPIO
, 32)];
43 static struct davinci_gpio_regs __iomem __init
*gpio2regs(unsigned gpio
)
46 void __iomem
*base
= davinci_soc_info
.gpio_base
;
50 else if (gpio
< 32 * 2)
52 else if (gpio
< 32 * 3)
54 else if (gpio
< 32 * 4)
56 else if (gpio
< 32 * 5)
63 static inline struct davinci_gpio_regs __iomem
*irq2regs(int irq
)
65 struct davinci_gpio_regs __iomem
*g
;
67 g
= (__force
struct davinci_gpio_regs __iomem
*)get_irq_chip_data(irq
);
72 static int __init
davinci_gpio_irq_setup(void);
74 /*--------------------------------------------------------------------------*/
77 * board setup code *MUST* set PINMUX0 and PINMUX1 as
78 * needed, and enable the GPIO clock.
81 static inline int __davinci_direction(struct gpio_chip
*chip
,
82 unsigned offset
, bool out
, int value
)
84 struct davinci_gpio_controller
*d
= chip2controller(chip
);
85 struct davinci_gpio_regs __iomem
*g
= d
->regs
;
87 u32 mask
= 1 << offset
;
89 spin_lock(&gpio_lock
);
90 temp
= __raw_readl(&g
->dir
);
93 __raw_writel(mask
, value
? &g
->set_data
: &g
->clr_data
);
97 __raw_writel(temp
, &g
->dir
);
98 spin_unlock(&gpio_lock
);
103 static int davinci_direction_in(struct gpio_chip
*chip
, unsigned offset
)
105 return __davinci_direction(chip
, offset
, false, 0);
109 davinci_direction_out(struct gpio_chip
*chip
, unsigned offset
, int value
)
111 return __davinci_direction(chip
, offset
, true, value
);
115 * Read the pin's value (works even if it's set up as output);
116 * returns zero/nonzero.
118 * Note that changes are synched to the GPIO clock, so reading values back
119 * right after you've set them may give old values.
121 static int davinci_gpio_get(struct gpio_chip
*chip
, unsigned offset
)
123 struct davinci_gpio_controller
*d
= chip2controller(chip
);
124 struct davinci_gpio_regs __iomem
*g
= d
->regs
;
126 return (1 << offset
) & __raw_readl(&g
->in_data
);
130 * Assuming the pin is muxed as a gpio output, set its output value.
133 davinci_gpio_set(struct gpio_chip
*chip
, unsigned offset
, int value
)
135 struct davinci_gpio_controller
*d
= chip2controller(chip
);
136 struct davinci_gpio_regs __iomem
*g
= d
->regs
;
138 __raw_writel((1 << offset
), value
? &g
->set_data
: &g
->clr_data
);
141 static int __init
davinci_gpio_setup(void)
145 struct davinci_soc_info
*soc_info
= &davinci_soc_info
;
146 struct davinci_gpio_regs
*regs
;
148 if (soc_info
->gpio_type
!= GPIO_TYPE_DAVINCI
)
152 * The gpio banks conceptually expose a segmented bitmap,
153 * and "ngpio" is one more than the largest zero-based
154 * bit index that's valid.
156 ngpio
= soc_info
->gpio_num
;
158 pr_err("GPIO setup: how many GPIOs?\n");
162 if (WARN_ON(DAVINCI_N_GPIO
< ngpio
))
163 ngpio
= DAVINCI_N_GPIO
;
165 for (i
= 0, base
= 0; base
< ngpio
; i
++, base
+= 32) {
166 chips
[i
].chip
.label
= "DaVinci";
168 chips
[i
].chip
.direction_input
= davinci_direction_in
;
169 chips
[i
].chip
.get
= davinci_gpio_get
;
170 chips
[i
].chip
.direction_output
= davinci_direction_out
;
171 chips
[i
].chip
.set
= davinci_gpio_set
;
173 chips
[i
].chip
.base
= base
;
174 chips
[i
].chip
.ngpio
= ngpio
- base
;
175 if (chips
[i
].chip
.ngpio
> 32)
176 chips
[i
].chip
.ngpio
= 32;
178 regs
= gpio2regs(base
);
179 chips
[i
].regs
= regs
;
180 chips
[i
].set_data
= ®s
->set_data
;
181 chips
[i
].clr_data
= ®s
->clr_data
;
182 chips
[i
].in_data
= ®s
->in_data
;
184 gpiochip_add(&chips
[i
].chip
);
187 soc_info
->gpio_ctlrs
= chips
;
188 soc_info
->gpio_ctlrs_num
= DIV_ROUND_UP(ngpio
, 32);
190 davinci_gpio_irq_setup();
193 pure_initcall(davinci_gpio_setup
);
195 /*--------------------------------------------------------------------------*/
197 * We expect irqs will normally be set up as input pins, but they can also be
198 * used as output pins ... which is convenient for testing.
200 * NOTE: The first few GPIOs also have direct INTC hookups in addition
201 * to their GPIOBNK0 irq, with a bit less overhead.
203 * All those INTC hookups (direct, plus several IRQ banks) can also
204 * serve as EDMA event triggers.
207 static void gpio_irq_disable(unsigned irq
)
209 struct davinci_gpio_regs __iomem
*g
= irq2regs(irq
);
210 u32 mask
= (u32
) get_irq_data(irq
);
212 __raw_writel(mask
, &g
->clr_falling
);
213 __raw_writel(mask
, &g
->clr_rising
);
216 static void gpio_irq_enable(unsigned irq
)
218 struct davinci_gpio_regs __iomem
*g
= irq2regs(irq
);
219 u32 mask
= (u32
) get_irq_data(irq
);
220 unsigned status
= irq_desc
[irq
].status
;
222 status
&= IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_EDGE_RISING
;
224 status
= IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_EDGE_RISING
;
226 if (status
& IRQ_TYPE_EDGE_FALLING
)
227 __raw_writel(mask
, &g
->set_falling
);
228 if (status
& IRQ_TYPE_EDGE_RISING
)
229 __raw_writel(mask
, &g
->set_rising
);
232 static int gpio_irq_type(unsigned irq
, unsigned trigger
)
234 struct davinci_gpio_regs __iomem
*g
= irq2regs(irq
);
235 u32 mask
= (u32
) get_irq_data(irq
);
237 if (trigger
& ~(IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_EDGE_RISING
))
240 irq_desc
[irq
].status
&= ~IRQ_TYPE_SENSE_MASK
;
241 irq_desc
[irq
].status
|= trigger
;
243 /* don't enable the IRQ if it's currently disabled */
244 if (irq_desc
[irq
].depth
== 0) {
245 __raw_writel(mask
, (trigger
& IRQ_TYPE_EDGE_FALLING
)
246 ? &g
->set_falling
: &g
->clr_falling
);
247 __raw_writel(mask
, (trigger
& IRQ_TYPE_EDGE_RISING
)
248 ? &g
->set_rising
: &g
->clr_rising
);
253 static struct irq_chip gpio_irqchip
= {
255 .enable
= gpio_irq_enable
,
256 .disable
= gpio_irq_disable
,
257 .set_type
= gpio_irq_type
,
261 gpio_irq_handler(unsigned irq
, struct irq_desc
*desc
)
263 struct davinci_gpio_regs __iomem
*g
= irq2regs(irq
);
266 /* we only care about one bank */
270 /* temporarily mask (level sensitive) parent IRQ */
271 desc
->chip
->mask(irq
);
272 desc
->chip
->ack(irq
);
279 status
= __raw_readl(&g
->intstat
) & mask
;
282 __raw_writel(status
, &g
->intstat
);
286 /* now demux them to the right lowlevel handler */
287 n
= (int)get_irq_data(irq
);
291 generic_handle_irq(n
- 1);
295 desc
->chip
->unmask(irq
);
296 /* now it may re-trigger */
299 static int gpio_to_irq_banked(struct gpio_chip
*chip
, unsigned offset
)
301 struct davinci_gpio_controller
*d
= chip2controller(chip
);
303 if (d
->irq_base
>= 0)
304 return d
->irq_base
+ offset
;
309 static int gpio_to_irq_unbanked(struct gpio_chip
*chip
, unsigned offset
)
311 struct davinci_soc_info
*soc_info
= &davinci_soc_info
;
313 /* NOTE: we assume for now that only irqs in the first gpio_chip
314 * can provide direct-mapped IRQs to AINTC (up to 32 GPIOs).
316 if (offset
< soc_info
->gpio_unbanked
)
317 return soc_info
->gpio_irq
+ offset
;
322 static int gpio_irq_type_unbanked(unsigned irq
, unsigned trigger
)
324 struct davinci_gpio_regs __iomem
*g
= irq2regs(irq
);
325 u32 mask
= (u32
) get_irq_data(irq
);
327 if (trigger
& ~(IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_EDGE_RISING
))
330 __raw_writel(mask
, (trigger
& IRQ_TYPE_EDGE_FALLING
)
331 ? &g
->set_falling
: &g
->clr_falling
);
332 __raw_writel(mask
, (trigger
& IRQ_TYPE_EDGE_RISING
)
333 ? &g
->set_rising
: &g
->clr_rising
);
339 * NOTE: for suspend/resume, probably best to make a platform_device with
340 * suspend_late/resume_resume calls hooking into results of the set_wake()
341 * calls ... so if no gpios are wakeup events the clock can be disabled,
342 * with outputs left at previously set levels, and so that VDD3P3V.IOPWDN0
343 * (dm6446) can be set appropriately for GPIOV33 pins.
346 static int __init
davinci_gpio_irq_setup(void)
348 unsigned gpio
, irq
, bank
;
351 unsigned ngpio
, bank_irq
;
352 struct davinci_soc_info
*soc_info
= &davinci_soc_info
;
353 struct davinci_gpio_regs __iomem
*g
;
355 ngpio
= soc_info
->gpio_num
;
357 bank_irq
= soc_info
->gpio_irq
;
359 printk(KERN_ERR
"Don't know first GPIO bank IRQ.\n");
363 clk
= clk_get(NULL
, "gpio");
365 printk(KERN_ERR
"Error %ld getting gpio clock?\n",
371 /* Arrange gpio_to_irq() support, handling either direct IRQs or
372 * banked IRQs. Having GPIOs in the first GPIO bank use direct
373 * IRQs, while the others use banked IRQs, would need some setup
374 * tweaks to recognize hardware which can do that.
376 for (gpio
= 0, bank
= 0; gpio
< ngpio
; bank
++, gpio
+= 32) {
377 chips
[bank
].chip
.to_irq
= gpio_to_irq_banked
;
378 chips
[bank
].irq_base
= soc_info
->gpio_unbanked
380 : (soc_info
->intc_irq_num
+ gpio
);
384 * AINTC can handle direct/unbanked IRQs for GPIOs, with the GPIO
385 * controller only handling trigger modes. We currently assume no
386 * IRQ mux conflicts; gpio_irq_type_unbanked() is only for GPIOs.
388 if (soc_info
->gpio_unbanked
) {
389 static struct irq_chip gpio_irqchip_unbanked
;
391 /* pass "bank 0" GPIO IRQs to AINTC */
392 chips
[0].chip
.to_irq
= gpio_to_irq_unbanked
;
395 /* AINTC handles mask/unmask; GPIO handles triggering */
397 gpio_irqchip_unbanked
= *get_irq_desc_chip(irq_to_desc(irq
));
398 gpio_irqchip_unbanked
.name
= "GPIO-AINTC";
399 gpio_irqchip_unbanked
.set_type
= gpio_irq_type_unbanked
;
401 /* default trigger: both edges */
403 __raw_writel(~0, &g
->set_falling
);
404 __raw_writel(~0, &g
->set_rising
);
406 /* set the direct IRQs up to use that irqchip */
407 for (gpio
= 0; gpio
< soc_info
->gpio_unbanked
; gpio
++, irq
++) {
408 set_irq_chip(irq
, &gpio_irqchip_unbanked
);
409 set_irq_data(irq
, (void *) __gpio_mask(gpio
));
410 set_irq_chip_data(irq
, (__force
void *) g
);
411 irq_desc
[irq
].status
|= IRQ_TYPE_EDGE_BOTH
;
418 * Or, AINTC can handle IRQs for banks of 16 GPIO IRQs, which we
419 * then chain through our own handler.
421 for (gpio
= 0, irq
= gpio_to_irq(0), bank
= 0;
423 bank
++, bank_irq
++) {
426 /* disabled by default, enabled only as needed */
428 __raw_writel(~0, &g
->clr_falling
);
429 __raw_writel(~0, &g
->clr_rising
);
431 /* set up all irqs in this bank */
432 set_irq_chained_handler(bank_irq
, gpio_irq_handler
);
433 set_irq_chip_data(bank_irq
, (__force
void *) g
);
434 set_irq_data(bank_irq
, (void *) irq
);
436 for (i
= 0; i
< 16 && gpio
< ngpio
; i
++, irq
++, gpio
++) {
437 set_irq_chip(irq
, &gpio_irqchip
);
438 set_irq_chip_data(irq
, (__force
void *) g
);
439 set_irq_data(irq
, (void *) __gpio_mask(gpio
));
440 set_irq_handler(irq
, handle_simple_irq
);
441 set_irq_flags(irq
, IRQF_VALID
);
448 /* BINTEN -- per-bank interrupt enable. genirq would also let these
449 * bits be set/cleared dynamically.
451 __raw_writel(binten
, soc_info
->gpio_base
+ 0x08);
453 printk(KERN_INFO
"DaVinci: %d gpio irqs\n", irq
- gpio_to_irq(0));