2 * linux/arch/arm/plat-pxa/gpio.c
4 * Generic PXA GPIO handling
6 * Author: Nicolas Pitre
7 * Created: Jun 15, 2001
8 * Copyright: MontaVista Software Inc.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/init.h>
16 #include <linux/irq.h>
18 #include <linux/sysdev.h>
19 #include <linux/bootmem.h>
21 #include <mach/gpio.h>
25 struct pxa_gpio_chip
{
26 struct gpio_chip chip
;
27 void __iomem
*regbase
;
30 unsigned long irq_mask
;
31 unsigned long irq_edge_rise
;
32 unsigned long irq_edge_fall
;
35 unsigned long saved_gplr
;
36 unsigned long saved_gpdr
;
37 unsigned long saved_grer
;
38 unsigned long saved_gfer
;
42 static DEFINE_SPINLOCK(gpio_lock
);
43 static struct pxa_gpio_chip
*pxa_gpio_chips
;
45 #define for_each_gpio_chip(i, c) \
46 for (i = 0, c = &pxa_gpio_chips[0]; i <= pxa_last_gpio; i += 32, c++)
48 static inline void __iomem
*gpio_chip_base(struct gpio_chip
*c
)
50 return container_of(c
, struct pxa_gpio_chip
, chip
)->regbase
;
53 static inline struct pxa_gpio_chip
*gpio_to_chip(unsigned gpio
)
55 return &pxa_gpio_chips
[gpio_to_bank(gpio
)];
58 static int pxa_gpio_direction_input(struct gpio_chip
*chip
, unsigned offset
)
60 void __iomem
*base
= gpio_chip_base(chip
);
61 uint32_t value
, mask
= 1 << offset
;
64 spin_lock_irqsave(&gpio_lock
, flags
);
66 value
= __raw_readl(base
+ GPDR_OFFSET
);
67 if (__gpio_is_inverted(chip
->base
+ offset
))
71 __raw_writel(value
, base
+ GPDR_OFFSET
);
73 spin_unlock_irqrestore(&gpio_lock
, flags
);
77 static int pxa_gpio_direction_output(struct gpio_chip
*chip
,
78 unsigned offset
, int value
)
80 void __iomem
*base
= gpio_chip_base(chip
);
81 uint32_t tmp
, mask
= 1 << offset
;
84 __raw_writel(mask
, base
+ (value
? GPSR_OFFSET
: GPCR_OFFSET
));
86 spin_lock_irqsave(&gpio_lock
, flags
);
88 tmp
= __raw_readl(base
+ GPDR_OFFSET
);
89 if (__gpio_is_inverted(chip
->base
+ offset
))
93 __raw_writel(tmp
, base
+ GPDR_OFFSET
);
95 spin_unlock_irqrestore(&gpio_lock
, flags
);
99 static int pxa_gpio_get(struct gpio_chip
*chip
, unsigned offset
)
101 return __raw_readl(gpio_chip_base(chip
) + GPLR_OFFSET
) & (1 << offset
);
104 static void pxa_gpio_set(struct gpio_chip
*chip
, unsigned offset
, int value
)
106 __raw_writel(1 << offset
, gpio_chip_base(chip
) +
107 (value
? GPSR_OFFSET
: GPCR_OFFSET
));
110 static int __init
pxa_init_gpio_chip(int gpio_end
)
112 int i
, gpio
, nbanks
= gpio_to_bank(gpio_end
) + 1;
113 struct pxa_gpio_chip
*chips
;
115 /* this is early, we have to use bootmem allocator, and we really
116 * want this to be allocated dynamically for different 'gpio_end'
118 chips
= alloc_bootmem_low(nbanks
* sizeof(struct pxa_gpio_chip
));
120 pr_err("%s: failed to allocate GPIO chips\n", __func__
);
124 memset(chips
, 0, nbanks
* sizeof(struct pxa_gpio_chip
));
126 for (i
= 0, gpio
= 0; i
< nbanks
; i
++, gpio
+= 32) {
127 struct gpio_chip
*c
= &chips
[i
].chip
;
129 sprintf(chips
[i
].label
, "gpio-%d", i
);
130 chips
[i
].regbase
= (void __iomem
*)GPIO_BANK(i
);
133 c
->label
= chips
[i
].label
;
135 c
->direction_input
= pxa_gpio_direction_input
;
136 c
->direction_output
= pxa_gpio_direction_output
;
137 c
->get
= pxa_gpio_get
;
138 c
->set
= pxa_gpio_set
;
140 /* number of GPIOs on last bank may be less than 32 */
141 c
->ngpio
= (gpio
+ 31 > gpio_end
) ? (gpio_end
- gpio
+ 1) : 32;
144 pxa_gpio_chips
= chips
;
148 /* Update only those GRERx and GFERx edge detection register bits if those
149 * bits are set in c->irq_mask
151 static inline void update_edge_detect(struct pxa_gpio_chip
*c
)
155 grer
= __raw_readl(c
->regbase
+ GRER_OFFSET
) & ~c
->irq_mask
;
156 gfer
= __raw_readl(c
->regbase
+ GFER_OFFSET
) & ~c
->irq_mask
;
157 grer
|= c
->irq_edge_rise
& c
->irq_mask
;
158 gfer
|= c
->irq_edge_fall
& c
->irq_mask
;
159 __raw_writel(grer
, c
->regbase
+ GRER_OFFSET
);
160 __raw_writel(gfer
, c
->regbase
+ GFER_OFFSET
);
163 static int pxa_gpio_irq_type(unsigned int irq
, unsigned int type
)
165 struct pxa_gpio_chip
*c
;
166 int gpio
= irq_to_gpio(irq
);
167 unsigned long gpdr
, mask
= GPIO_bit(gpio
);
169 c
= gpio_to_chip(gpio
);
171 if (type
== IRQ_TYPE_PROBE
) {
172 /* Don't mess with enabled GPIOs using preconfigured edges or
173 * GPIOs set to alternate function or to output during probe
175 if ((c
->irq_edge_rise
| c
->irq_edge_fall
) & GPIO_bit(gpio
))
178 if (__gpio_is_occupied(gpio
))
181 type
= IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
;
184 gpdr
= __raw_readl(c
->regbase
+ GPDR_OFFSET
);
186 if (__gpio_is_inverted(gpio
))
187 __raw_writel(gpdr
| mask
, c
->regbase
+ GPDR_OFFSET
);
189 __raw_writel(gpdr
& ~mask
, c
->regbase
+ GPDR_OFFSET
);
191 if (type
& IRQ_TYPE_EDGE_RISING
)
192 c
->irq_edge_rise
|= mask
;
194 c
->irq_edge_rise
&= ~mask
;
196 if (type
& IRQ_TYPE_EDGE_FALLING
)
197 c
->irq_edge_fall
|= mask
;
199 c
->irq_edge_fall
&= ~mask
;
201 update_edge_detect(c
);
203 pr_debug("%s: IRQ%d (GPIO%d) - edge%s%s\n", __func__
, irq
, gpio
,
204 ((type
& IRQ_TYPE_EDGE_RISING
) ? " rising" : ""),
205 ((type
& IRQ_TYPE_EDGE_FALLING
) ? " falling" : ""));
209 static void pxa_gpio_demux_handler(unsigned int irq
, struct irq_desc
*desc
)
211 struct pxa_gpio_chip
*c
;
212 int loop
, gpio
, gpio_base
, n
;
217 for_each_gpio_chip(gpio
, c
) {
218 gpio_base
= c
->chip
.base
;
220 gedr
= __raw_readl(c
->regbase
+ GEDR_OFFSET
);
221 gedr
= gedr
& c
->irq_mask
;
222 __raw_writel(gedr
, c
->regbase
+ GEDR_OFFSET
);
224 n
= find_first_bit(&gedr
, BITS_PER_LONG
);
225 while (n
< BITS_PER_LONG
) {
228 generic_handle_irq(gpio_to_irq(gpio_base
+ n
));
229 n
= find_next_bit(&gedr
, BITS_PER_LONG
, n
+ 1);
235 static void pxa_ack_muxed_gpio(unsigned int irq
)
237 int gpio
= irq_to_gpio(irq
);
238 struct pxa_gpio_chip
*c
= gpio_to_chip(gpio
);
240 __raw_writel(GPIO_bit(gpio
), c
->regbase
+ GEDR_OFFSET
);
243 static void pxa_mask_muxed_gpio(unsigned int irq
)
245 int gpio
= irq_to_gpio(irq
);
246 struct pxa_gpio_chip
*c
= gpio_to_chip(gpio
);
249 c
->irq_mask
&= ~GPIO_bit(gpio
);
251 grer
= __raw_readl(c
->regbase
+ GRER_OFFSET
) & ~GPIO_bit(gpio
);
252 gfer
= __raw_readl(c
->regbase
+ GFER_OFFSET
) & ~GPIO_bit(gpio
);
253 __raw_writel(grer
, c
->regbase
+ GRER_OFFSET
);
254 __raw_writel(gfer
, c
->regbase
+ GFER_OFFSET
);
257 static void pxa_unmask_muxed_gpio(unsigned int irq
)
259 int gpio
= irq_to_gpio(irq
);
260 struct pxa_gpio_chip
*c
= gpio_to_chip(gpio
);
262 c
->irq_mask
|= GPIO_bit(gpio
);
263 update_edge_detect(c
);
266 static struct irq_chip pxa_muxed_gpio_chip
= {
268 .ack
= pxa_ack_muxed_gpio
,
269 .mask
= pxa_mask_muxed_gpio
,
270 .unmask
= pxa_unmask_muxed_gpio
,
271 .set_type
= pxa_gpio_irq_type
,
274 void __init
pxa_init_gpio(int mux_irq
, int start
, int end
, set_wake_t fn
)
276 struct pxa_gpio_chip
*c
;
281 /* Initialize GPIO chips */
282 pxa_init_gpio_chip(end
);
284 /* clear all GPIO edge detects */
285 for_each_gpio_chip(gpio
, c
) {
286 __raw_writel(0, c
->regbase
+ GFER_OFFSET
);
287 __raw_writel(0, c
->regbase
+ GRER_OFFSET
);
288 __raw_writel(~0,c
->regbase
+ GEDR_OFFSET
);
291 for (irq
= gpio_to_irq(start
); irq
<= gpio_to_irq(end
); irq
++) {
292 set_irq_chip(irq
, &pxa_muxed_gpio_chip
);
293 set_irq_handler(irq
, handle_edge_irq
);
294 set_irq_flags(irq
, IRQF_VALID
| IRQF_PROBE
);
297 /* Install handler for GPIO>=2 edge detect interrupts */
298 set_irq_chained_handler(mux_irq
, pxa_gpio_demux_handler
);
299 pxa_muxed_gpio_chip
.set_wake
= fn
;
303 static int pxa_gpio_suspend(struct sys_device
*dev
, pm_message_t state
)
305 struct pxa_gpio_chip
*c
;
308 for_each_gpio_chip(gpio
, c
) {
309 c
->saved_gplr
= __raw_readl(c
->regbase
+ GPLR_OFFSET
);
310 c
->saved_gpdr
= __raw_readl(c
->regbase
+ GPDR_OFFSET
);
311 c
->saved_grer
= __raw_readl(c
->regbase
+ GRER_OFFSET
);
312 c
->saved_gfer
= __raw_readl(c
->regbase
+ GFER_OFFSET
);
314 /* Clear GPIO transition detect bits */
315 __raw_writel(0xffffffff, c
->regbase
+ GEDR_OFFSET
);
320 static int pxa_gpio_resume(struct sys_device
*dev
)
322 struct pxa_gpio_chip
*c
;
325 for_each_gpio_chip(gpio
, c
) {
326 /* restore level with set/clear */
327 __raw_writel( c
->saved_gplr
, c
->regbase
+ GPSR_OFFSET
);
328 __raw_writel(~c
->saved_gplr
, c
->regbase
+ GPCR_OFFSET
);
330 __raw_writel(c
->saved_grer
, c
->regbase
+ GRER_OFFSET
);
331 __raw_writel(c
->saved_gfer
, c
->regbase
+ GFER_OFFSET
);
332 __raw_writel(c
->saved_gpdr
, c
->regbase
+ GPDR_OFFSET
);
337 #define pxa_gpio_suspend NULL
338 #define pxa_gpio_resume NULL
341 struct sysdev_class pxa_gpio_sysclass
= {
343 .suspend
= pxa_gpio_suspend
,
344 .resume
= pxa_gpio_resume
,
347 static int __init
pxa_gpio_init(void)
349 return sysdev_class_register(&pxa_gpio_sysclass
);
352 core_initcall(pxa_gpio_init
);