[ARM] pxa: add gpio_pwdown(_inverted) into pxaficp_ir.c
[linux-2.6.git] / arch / arm / mach-gemini / gpio.c
1 /*
2  * Gemini gpiochip and interrupt routines
3  *
4  * Copyright (C) 2008-2009 Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
5  *
6  * Based on plat-mxc/gpio.c:
7  *  MXC GPIO support. (c) 2008 Daniel Mack <daniel@caiaq.de>
8  *  Copyright 2008 Juergen Beisert, kernel@pengutronix.de
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/io.h>
19 #include <linux/irq.h>
20 #include <linux/gpio.h>
21
22 #include <mach/hardware.h>
23 #include <mach/irqs.h>
24
25 #define GPIO_BASE(x)            IO_ADDRESS(GEMINI_GPIO_BASE(x))
26
27 /* GPIO registers definition */
28 #define GPIO_DATA_OUT           0x0
29 #define GPIO_DATA_IN            0x4
30 #define GPIO_DIR                0x8
31 #define GPIO_DATA_SET           0x10
32 #define GPIO_DATA_CLR           0x14
33 #define GPIO_PULL_EN            0x18
34 #define GPIO_PULL_TYPE          0x1C
35 #define GPIO_INT_EN             0x20
36 #define GPIO_INT_STAT           0x24
37 #define GPIO_INT_MASK           0x2C
38 #define GPIO_INT_CLR            0x30
39 #define GPIO_INT_TYPE           0x34
40 #define GPIO_INT_BOTH_EDGE      0x38
41 #define GPIO_INT_LEVEL          0x3C
42 #define GPIO_DEBOUNCE_EN        0x40
43 #define GPIO_DEBOUNCE_PRESCALE  0x44
44
45 #define GPIO_PORT_NUM           3
46
47 static void _set_gpio_irqenable(unsigned int base, unsigned int index,
48                                 int enable)
49 {
50         unsigned int reg;
51
52         reg = __raw_readl(base + GPIO_INT_EN);
53         reg = (reg & (~(1 << index))) | (!!enable << index);
54         __raw_writel(reg, base + GPIO_INT_EN);
55 }
56
57 static void gpio_ack_irq(unsigned int irq)
58 {
59         unsigned int gpio = irq_to_gpio(irq);
60         unsigned int base = GPIO_BASE(gpio / 32);
61
62         __raw_writel(1 << (gpio % 32), base + GPIO_INT_CLR);
63 }
64
65 static void gpio_mask_irq(unsigned int irq)
66 {
67         unsigned int gpio = irq_to_gpio(irq);
68         unsigned int base = GPIO_BASE(gpio / 32);
69
70         _set_gpio_irqenable(base, gpio % 32, 0);
71 }
72
73 static void gpio_unmask_irq(unsigned int irq)
74 {
75         unsigned int gpio = irq_to_gpio(irq);
76         unsigned int base = GPIO_BASE(gpio / 32);
77
78         _set_gpio_irqenable(base, gpio % 32, 1);
79 }
80
81 static int gpio_set_irq_type(unsigned int irq, unsigned int type)
82 {
83         unsigned int gpio = irq_to_gpio(irq);
84         unsigned int gpio_mask = 1 << (gpio % 32);
85         unsigned int base = GPIO_BASE(gpio / 32);
86         unsigned int reg_both, reg_level, reg_type;
87
88         reg_type = __raw_readl(base + GPIO_INT_TYPE);
89         reg_level = __raw_readl(base + GPIO_INT_BOTH_EDGE);
90         reg_both = __raw_readl(base + GPIO_INT_BOTH_EDGE);
91
92         switch (type) {
93         case IRQ_TYPE_EDGE_BOTH:
94                 reg_type &= ~gpio_mask;
95                 reg_both |= gpio_mask;
96                 break;
97         case IRQ_TYPE_EDGE_RISING:
98                 reg_type &= ~gpio_mask;
99                 reg_both &= ~gpio_mask;
100                 reg_level &= ~gpio_mask;
101                 break;
102         case IRQ_TYPE_EDGE_FALLING:
103                 reg_type &= ~gpio_mask;
104                 reg_both &= ~gpio_mask;
105                 reg_level |= gpio_mask;
106                 break;
107         case IRQ_TYPE_LEVEL_HIGH:
108                 reg_type |= gpio_mask;
109                 reg_level &= ~gpio_mask;
110                 break;
111         case IRQ_TYPE_LEVEL_LOW:
112                 reg_type |= gpio_mask;
113                 reg_level |= gpio_mask;
114                 break;
115         default:
116                 return -EINVAL;
117         }
118
119         __raw_writel(reg_type, base + GPIO_INT_TYPE);
120         __raw_writel(reg_level, base + GPIO_INT_BOTH_EDGE);
121         __raw_writel(reg_both, base + GPIO_INT_BOTH_EDGE);
122
123         gpio_ack_irq(irq);
124
125         return 0;
126 }
127
128 static void gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
129 {
130         unsigned int gpio_irq_no, irq_stat;
131         unsigned int port = (unsigned int)get_irq_data(irq);
132
133         irq_stat = __raw_readl(GPIO_BASE(port) + GPIO_INT_STAT);
134
135         gpio_irq_no = GPIO_IRQ_BASE + port * 32;
136         for (; irq_stat != 0; irq_stat >>= 1, gpio_irq_no++) {
137
138                 if ((irq_stat & 1) == 0)
139                         continue;
140
141                 BUG_ON(!(irq_desc[gpio_irq_no].handle_irq));
142                 irq_desc[gpio_irq_no].handle_irq(gpio_irq_no,
143                                 &irq_desc[gpio_irq_no]);
144         }
145 }
146
147 static struct irq_chip gpio_irq_chip = {
148         .name = "GPIO",
149         .ack = gpio_ack_irq,
150         .mask = gpio_mask_irq,
151         .unmask = gpio_unmask_irq,
152         .set_type = gpio_set_irq_type,
153 };
154
155 static void _set_gpio_direction(struct gpio_chip *chip, unsigned offset,
156                                 int dir)
157 {
158         unsigned int base = GPIO_BASE(offset / 32);
159         unsigned int reg;
160
161         reg = __raw_readl(base + GPIO_DIR);
162         if (dir)
163                 reg |= 1 << (offset % 32);
164         else
165                 reg &= ~(1 << (offset % 32));
166         __raw_writel(reg, base + GPIO_DIR);
167 }
168
169 static void gemini_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
170 {
171         unsigned int base = GPIO_BASE(offset / 32);
172
173         if (value)
174                 __raw_writel(1 << (offset % 32), base + GPIO_DATA_SET);
175         else
176                 __raw_writel(1 << (offset % 32), base + GPIO_DATA_CLR);
177 }
178
179 static int gemini_gpio_get(struct gpio_chip *chip, unsigned offset)
180 {
181         unsigned int base = GPIO_BASE(offset / 32);
182
183         return (__raw_readl(base + GPIO_DATA_IN) >> (offset % 32)) & 1;
184 }
185
186 static int gemini_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
187 {
188         _set_gpio_direction(chip, offset, 0);
189         return 0;
190 }
191
192 static int gemini_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
193                                         int value)
194 {
195         _set_gpio_direction(chip, offset, 1);
196         gemini_gpio_set(chip, offset, value);
197         return 0;
198 }
199
200 static struct gpio_chip gemini_gpio_chip = {
201         .label                  = "Gemini",
202         .direction_input        = gemini_gpio_direction_input,
203         .get                    = gemini_gpio_get,
204         .direction_output       = gemini_gpio_direction_output,
205         .set                    = gemini_gpio_set,
206         .base                   = 0,
207         .ngpio                  = GPIO_PORT_NUM * 32,
208 };
209
210 void __init gemini_gpio_init(void)
211 {
212         int i, j;
213
214         for (i = 0; i < GPIO_PORT_NUM; i++) {
215                 /* disable, unmask and clear all interrupts */
216                 __raw_writel(0x0, GPIO_BASE(i) + GPIO_INT_EN);
217                 __raw_writel(0x0, GPIO_BASE(i) + GPIO_INT_MASK);
218                 __raw_writel(~0x0, GPIO_BASE(i) + GPIO_INT_CLR);
219
220                 for (j = GPIO_IRQ_BASE + i * 32;
221                      j < GPIO_IRQ_BASE + (i + 1) * 32; j++) {
222                         set_irq_chip(j, &gpio_irq_chip);
223                         set_irq_handler(j, handle_edge_irq);
224                         set_irq_flags(j, IRQF_VALID);
225                 }
226
227                 set_irq_chained_handler(IRQ_GPIO(i), gpio_irq_handler);
228                 set_irq_data(IRQ_GPIO(i), (void *)i);
229         }
230
231         BUG_ON(gpiochip_add(&gemini_gpio_chip));
232 }