[SCSI] jazz_esp, sgiwd93, sni_53c710, sun3x_esp: fix platform driver hotplug/coldplug
[linux-2.6] / arch / arm / mach-ks8695 / gpio.c
1 /*
2  * arch/arm/mach-ks8695/gpio.c
3  *
4  * Copyright (C) 2006 Andrew Victor
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/mm.h>
22 #include <linux/init.h>
23 #include <linux/debugfs.h>
24 #include <linux/seq_file.h>
25 #include <linux/module.h>
26
27 #include <asm/io.h>
28 #include <asm/hardware.h>
29 #include <asm/mach/irq.h>
30
31 #include <asm/arch/regs-gpio.h>
32 #include <asm/arch/gpio.h>
33
34 /*
35  * Configure a GPIO line for either GPIO function, or its internal
36  * function (Interrupt, Timer, etc).
37  */
38 static void __init_or_module ks8695_gpio_mode(unsigned int pin, short gpio)
39 {
40         unsigned int enable[] = { IOPC_IOEINT0EN, IOPC_IOEINT1EN, IOPC_IOEINT2EN, IOPC_IOEINT3EN, IOPC_IOTIM0EN, IOPC_IOTIM1EN };
41         unsigned long x, flags;
42
43         if (pin > KS8695_GPIO_5)        /* only GPIO 0..5 have internal functions */
44                 return;
45
46         local_irq_save(flags);
47
48         x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPC);
49         if (gpio)                       /* GPIO: set bit to 0 */
50                 x &= ~enable[pin];
51         else                            /* Internal function: set bit to 1 */
52                 x |= enable[pin];
53         __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPC);
54
55         local_irq_restore(flags);
56 }
57
58
59 static unsigned short gpio_irq[] = { KS8695_IRQ_EXTERN0, KS8695_IRQ_EXTERN1, KS8695_IRQ_EXTERN2, KS8695_IRQ_EXTERN3 };
60
61 /*
62  * Configure GPIO pin as external interrupt source.
63  */
64 int __init_or_module ks8695_gpio_interrupt(unsigned int pin, unsigned int type)
65 {
66         unsigned long x, flags;
67
68         if (pin > KS8695_GPIO_3)        /* only GPIO 0..3 can generate IRQ */
69                 return -EINVAL;
70
71         local_irq_save(flags);
72
73         /* set pin as input */
74         x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
75         x &= ~IOPM_(pin);
76         __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM);
77
78         local_irq_restore(flags);
79
80         /* Set IRQ triggering type */
81         set_irq_type(gpio_irq[pin], type);
82
83         /* enable interrupt mode */
84         ks8695_gpio_mode(pin, 0);
85
86         return 0;
87 }
88 EXPORT_SYMBOL(ks8695_gpio_interrupt);
89
90
91
92 /* .... Generic GPIO interface .............................................. */
93
94 /*
95  * Configure the GPIO line as an input.
96  */
97 int __init_or_module gpio_direction_input(unsigned int pin)
98 {
99         unsigned long x, flags;
100
101         if (pin > KS8695_GPIO_15)
102                 return -EINVAL;
103
104         /* set pin to GPIO mode */
105         ks8695_gpio_mode(pin, 1);
106
107         local_irq_save(flags);
108
109         /* set pin as input */
110         x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
111         x &= ~IOPM_(pin);
112         __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM);
113
114         local_irq_restore(flags);
115
116         return 0;
117 }
118 EXPORT_SYMBOL(gpio_direction_input);
119
120
121 /*
122  * Configure the GPIO line as an output, with default state.
123  */
124 int __init_or_module gpio_direction_output(unsigned int pin, unsigned int state)
125 {
126         unsigned long x, flags;
127
128         if (pin > KS8695_GPIO_15)
129                 return -EINVAL;
130
131         /* set pin to GPIO mode */
132         ks8695_gpio_mode(pin, 1);
133
134         local_irq_save(flags);
135
136         /* set line state */
137         x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
138         if (state)
139                 x |= (1 << pin);
140         else
141                 x &= ~(1 << pin);
142         __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPD);
143
144         /* set pin as output */
145         x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
146         x |= IOPM_(pin);
147         __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM);
148
149         local_irq_restore(flags);
150
151         return 0;
152 }
153 EXPORT_SYMBOL(gpio_direction_output);
154
155
156 /*
157  * Set the state of an output GPIO line.
158  */
159 void gpio_set_value(unsigned int pin, unsigned int state)
160 {
161         unsigned long x, flags;
162
163         if (pin > KS8695_GPIO_15)
164                 return;
165
166         local_irq_save(flags);
167
168         /* set output line state */
169         x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
170         if (state)
171                 x |= (1 << pin);
172         else
173                 x &= ~(1 << pin);
174         __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPD);
175
176         local_irq_restore(flags);
177 }
178 EXPORT_SYMBOL(gpio_set_value);
179
180
181 /*
182  * Read the state of a GPIO line.
183  */
184 int gpio_get_value(unsigned int pin)
185 {
186         unsigned long x;
187
188         if (pin > KS8695_GPIO_15)
189                 return -EINVAL;
190
191         x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
192         return (x & (1 << pin)) != 0;
193 }
194 EXPORT_SYMBOL(gpio_get_value);
195
196
197 /*
198  * Map GPIO line to IRQ number.
199  */
200 int gpio_to_irq(unsigned int pin)
201 {
202         if (pin > KS8695_GPIO_3)        /* only GPIO 0..3 can generate IRQ */
203                 return -EINVAL;
204
205         return gpio_irq[pin];
206 }
207 EXPORT_SYMBOL(gpio_to_irq);
208
209
210 /*
211  * Map IRQ number to GPIO line.
212  */
213 int irq_to_gpio(unsigned int irq)
214 {
215         if ((irq < KS8695_IRQ_EXTERN0) || (irq > KS8695_IRQ_EXTERN3))
216                 return -EINVAL;
217
218         return (irq - KS8695_IRQ_EXTERN0);
219 }
220 EXPORT_SYMBOL(irq_to_gpio);
221
222
223 /* .... Debug interface ..................................................... */
224
225 #ifdef CONFIG_DEBUG_FS
226
227 static int ks8695_gpio_show(struct seq_file *s, void *unused)
228 {
229         unsigned int enable[] = { IOPC_IOEINT0EN, IOPC_IOEINT1EN, IOPC_IOEINT2EN, IOPC_IOEINT3EN, IOPC_IOTIM0EN, IOPC_IOTIM1EN };
230         unsigned int intmask[] = { IOPC_IOEINT0TM, IOPC_IOEINT1TM, IOPC_IOEINT2TM, IOPC_IOEINT3TM };
231         unsigned long mode, ctrl, data;
232         int i;
233
234         mode = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
235         ctrl = __raw_readl(KS8695_GPIO_VA + KS8695_IOPC);
236         data = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
237
238         seq_printf(s, "Pin\tI/O\tFunction\tState\n\n");
239
240         for (i = KS8695_GPIO_0; i <= KS8695_GPIO_15 ; i++) {
241                 seq_printf(s, "%i:\t", i);
242
243                 seq_printf(s, "%s\t", (mode & IOPM_(i)) ? "Output" : "Input");
244
245                 if (i <= KS8695_GPIO_3) {
246                         if (ctrl & enable[i]) {
247                                 seq_printf(s, "EXT%i ", i);
248
249                                 switch ((ctrl & intmask[i]) >> (4 * i)) {
250                                         case IOPC_TM_LOW:
251                                                 seq_printf(s, "(Low)");         break;
252                                         case IOPC_TM_HIGH:
253                                                 seq_printf(s, "(High)");        break;
254                                         case IOPC_TM_RISING:
255                                                 seq_printf(s, "(Rising)");      break;
256                                         case IOPC_TM_FALLING:
257                                                 seq_printf(s, "(Falling)");     break;
258                                         case IOPC_TM_EDGE:
259                                                 seq_printf(s, "(Edges)");       break;
260                                 }
261                         }
262                         else
263                                 seq_printf(s, "GPIO\t");
264                 }
265                 else if (i <= KS8695_GPIO_5) {
266                         if (ctrl & enable[i])
267                                 seq_printf(s, "TOUT%i\t", i - KS8695_GPIO_4);
268                         else
269                                 seq_printf(s, "GPIO\t");
270                 }
271                 else
272                         seq_printf(s, "GPIO\t");
273
274                 seq_printf(s, "\t");
275
276                 seq_printf(s, "%i\n", (data & IOPD_(i)) ? 1 : 0);
277         }
278         return 0;
279 }
280
281 static int ks8695_gpio_open(struct inode *inode, struct file *file)
282 {
283         return single_open(file, ks8695_gpio_show, NULL);
284 }
285
286 static const struct file_operations ks8695_gpio_operations = {
287         .open           = ks8695_gpio_open,
288         .read           = seq_read,
289         .llseek         = seq_lseek,
290         .release        = single_release,
291 };
292
293 static int __init ks8695_gpio_debugfs_init(void)
294 {
295         /* /sys/kernel/debug/ks8695_gpio */
296         (void) debugfs_create_file("ks8695_gpio", S_IFREG | S_IRUGO, NULL, NULL, &ks8695_gpio_operations);
297         return 0;
298 }
299 postcore_initcall(ks8695_gpio_debugfs_init);
300
301 #endif