2 * linux/arch/arm/mach-at91rm9200/gpio.c
4 * Copyright (C) 2005 HP Labs
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
12 #include <linux/errno.h>
13 #include <linux/kernel.h>
14 #include <linux/list.h>
15 #include <linux/module.h>
18 #include <asm/mach/irq.h>
19 #include <asm/arch/hardware.h>
20 #include <asm/arch/gpio.h>
22 static const u32 pio_controller_offset
[4] = {
29 static inline void __iomem
*pin_to_controller(unsigned pin
)
31 void __iomem
*sys_base
= (void __iomem
*) AT91_VA_BASE_SYS
;
35 if (likely(pin
< BGA_GPIO_BANKS
))
36 return sys_base
+ pio_controller_offset
[pin
];
41 static inline unsigned pin_to_mask(unsigned pin
)
44 return 1 << (pin
% 32);
48 /*--------------------------------------------------------------------------*/
50 /* Not all hardware capabilities are exposed through these calls; they
51 * only encapsulate the most common features and modes. (So if you
52 * want to change signals in groups, do it directly.)
54 * Bootloaders will usually handle some of the pin multiplexing setup.
55 * The intent is certainly that by the time Linux is fully booted, all
56 * pins should have been fully initialized. These setup calls should
57 * only be used by board setup routines, or possibly in driver probe().
59 * For bootloaders doing all that setup, these calls could be inlined
60 * as NOPs so Linux won't duplicate any setup code
65 * mux the pin to the "A" internal peripheral role.
67 int __init_or_module
at91_set_A_periph(unsigned pin
, int use_pullup
)
69 void __iomem
*pio
= pin_to_controller(pin
);
70 unsigned mask
= pin_to_mask(pin
);
75 __raw_writel(mask
, pio
+ PIO_IDR
);
76 __raw_writel(mask
, pio
+ (use_pullup
? PIO_PUER
: PIO_PUDR
));
77 __raw_writel(mask
, pio
+ PIO_ASR
);
78 __raw_writel(mask
, pio
+ PIO_PDR
);
81 EXPORT_SYMBOL(at91_set_A_periph
);
85 * mux the pin to the "B" internal peripheral role.
87 int __init_or_module
at91_set_B_periph(unsigned pin
, int use_pullup
)
89 void __iomem
*pio
= pin_to_controller(pin
);
90 unsigned mask
= pin_to_mask(pin
);
95 __raw_writel(mask
, pio
+ PIO_IDR
);
96 __raw_writel(mask
, pio
+ (use_pullup
? PIO_PUER
: PIO_PUDR
));
97 __raw_writel(mask
, pio
+ PIO_BSR
);
98 __raw_writel(mask
, pio
+ PIO_PDR
);
101 EXPORT_SYMBOL(at91_set_B_periph
);
105 * mux the pin to the gpio controller (instead of "A" or "B" peripheral), and
106 * configure it for an input.
108 int __init_or_module
at91_set_gpio_input(unsigned pin
, int use_pullup
)
110 void __iomem
*pio
= pin_to_controller(pin
);
111 unsigned mask
= pin_to_mask(pin
);
116 __raw_writel(mask
, pio
+ PIO_IDR
);
117 __raw_writel(mask
, pio
+ (use_pullup
? PIO_PUER
: PIO_PUDR
));
118 __raw_writel(mask
, pio
+ PIO_ODR
);
119 __raw_writel(mask
, pio
+ PIO_PER
);
122 EXPORT_SYMBOL(at91_set_gpio_input
);
126 * mux the pin to the gpio controller (instead of "A" or "B" peripheral),
127 * and configure it for an output.
129 int __init_or_module
at91_set_gpio_output(unsigned pin
, int value
)
131 void __iomem
*pio
= pin_to_controller(pin
);
132 unsigned mask
= pin_to_mask(pin
);
137 __raw_writel(mask
, pio
+ PIO_IDR
);
138 __raw_writel(mask
, pio
+ PIO_PUDR
);
139 __raw_writel(mask
, pio
+ (value
? PIO_SODR
: PIO_CODR
));
140 __raw_writel(mask
, pio
+ PIO_OER
);
141 __raw_writel(mask
, pio
+ PIO_PER
);
144 EXPORT_SYMBOL(at91_set_gpio_output
);
148 * enable/disable the glitch filter; mostly used with IRQ handling.
150 int __init_or_module
at91_set_deglitch(unsigned pin
, int is_on
)
152 void __iomem
*pio
= pin_to_controller(pin
);
153 unsigned mask
= pin_to_mask(pin
);
157 __raw_writel(mask
, pio
+ (is_on
? PIO_IFER
: PIO_IFDR
));
160 EXPORT_SYMBOL(at91_set_deglitch
);
162 /*--------------------------------------------------------------------------*/
166 * assuming the pin is muxed as a gpio output, set its value.
168 int at91_set_gpio_value(unsigned pin
, int value
)
170 void __iomem
*pio
= pin_to_controller(pin
);
171 unsigned mask
= pin_to_mask(pin
);
175 __raw_writel(mask
, pio
+ (value
? PIO_SODR
: PIO_CODR
));
178 EXPORT_SYMBOL(at91_set_gpio_value
);
182 * read the pin's value (works even if it's not muxed as a gpio).
184 int at91_get_gpio_value(unsigned pin
)
186 void __iomem
*pio
= pin_to_controller(pin
);
187 unsigned mask
= pin_to_mask(pin
);
192 pdsr
= __raw_readl(pio
+ PIO_PDSR
);
193 return (pdsr
& mask
) != 0;
195 EXPORT_SYMBOL(at91_get_gpio_value
);
197 /*--------------------------------------------------------------------------*/
200 /* Several AIC controller irqs are dispatched through this GPIO handler.
201 * To use any AT91_PIN_* as an externally triggered IRQ, first call
202 * at91_set_gpio_input() then maybe enable its glitch filter.
203 * Then just request_irq() with the pin ID; it works like any ARM IRQ
204 * handler, though it always triggers on rising and falling edges.
206 * Alternatively, certain pins may be used directly as IRQ0..IRQ6 after
207 * configuring them with at91_set_a_periph() or at91_set_b_periph().
208 * IRQ0..IRQ6 should be configurable, e.g. level vs edge triggering.
211 static void gpio_irq_mask(unsigned pin
)
213 void __iomem
*pio
= pin_to_controller(pin
);
214 unsigned mask
= pin_to_mask(pin
);
217 __raw_writel(mask
, pio
+ PIO_IDR
);
220 static void gpio_irq_unmask(unsigned pin
)
222 void __iomem
*pio
= pin_to_controller(pin
);
223 unsigned mask
= pin_to_mask(pin
);
226 __raw_writel(mask
, pio
+ PIO_IER
);
229 static int gpio_irq_type(unsigned pin
, unsigned type
)
231 return (type
== IRQT_BOTHEDGE
) ? 0 : -EINVAL
;
234 static struct irqchip gpio_irqchip
= {
235 .mask
= gpio_irq_mask
,
236 .unmask
= gpio_irq_unmask
,
237 .set_type
= gpio_irq_type
,
240 static void gpio_irq_handler(unsigned irq
, struct irqdesc
*desc
, struct pt_regs
*regs
)
243 struct irqdesc
*gpio
;
247 pio
= (void __force __iomem
*) desc
->chipdata
;
249 /* temporarily mask (level sensitive) parent IRQ */
250 desc
->chip
->ack(irq
);
252 isr
= __raw_readl(pio
+ PIO_ISR
) & __raw_readl(pio
+ PIO_IMR
);
256 pin
= (unsigned) desc
->data
;
257 gpio
= &irq_desc
[pin
];
261 gpio
->handle(pin
, gpio
, regs
);
267 desc
->chip
->unmask(irq
);
268 /* now it may re-trigger */
271 /* call this from board-specific init_irq */
272 void __init
at91_gpio_irq_setup(unsigned banks
)
274 unsigned pioc
, pin
, id
;
278 for (pioc
= 0, pin
= PIN_BASE
, id
= AT91_ID_PIOA
;
281 void __iomem
*controller
;
284 controller
= (void __iomem
*) AT91_VA_BASE_SYS
+ pio_controller_offset
[pioc
];
285 __raw_writel(~0, controller
+ PIO_IDR
);
287 set_irq_data(id
, (void *) pin
);
288 set_irq_chipdata(id
, (void __force
*) controller
);
290 for (i
= 0; i
< 32; i
++, pin
++) {
291 set_irq_chip(pin
, &gpio_irqchip
);
292 set_irq_handler(pin
, do_simple_IRQ
);
293 set_irq_flags(pin
, IRQF_VALID
);
296 set_irq_chained_handler(id
, gpio_irq_handler
);
298 /* enable the PIO peripheral clock */
299 at91_sys_write(AT91_PMC_PCER
, 1 << id
);
301 pr_info("AT91: %d gpio irqs in %d banks\n", pin
- PIN_BASE
, banks
);