]>
Commit | Line | Data |
---|---|---|
8a87a996 AV |
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/module.h> | |
24 | ||
25 | #include <asm/io.h> | |
26 | #include <asm/hardware.h> | |
27 | #include <asm/mach/irq.h> | |
28 | ||
29 | #include <asm/arch/regs-gpio.h> | |
30 | #include <asm/arch/gpio.h> | |
31 | ||
32 | /* | |
33 | * Configure a GPIO line for either GPIO function, or its internal | |
34 | * function (Interrupt, Timer, etc). | |
35 | */ | |
36 | static void __init_or_module ks8695_gpio_mode(unsigned int pin, short gpio) | |
37 | { | |
38 | unsigned int enable[] = { IOPC_IOEINT0EN, IOPC_IOEINT1EN, IOPC_IOEINT2EN, IOPC_IOEINT3EN, IOPC_IOTIM0EN, IOPC_IOTIM1EN }; | |
39 | unsigned long x, flags; | |
40 | ||
41 | if (pin > KS8695_GPIO_5) /* only GPIO 0..5 have internal functions */ | |
42 | return; | |
43 | ||
44 | local_irq_save(flags); | |
45 | ||
46 | x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPC); | |
47 | if (gpio) /* GPIO: set bit to 0 */ | |
48 | x &= ~enable[pin]; | |
49 | else /* Internal function: set bit to 1 */ | |
50 | x |= enable[pin]; | |
51 | __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPC); | |
52 | ||
53 | local_irq_restore(flags); | |
54 | } | |
55 | ||
56 | ||
57 | static unsigned short gpio_irq[] = { KS8695_IRQ_EXTERN0, KS8695_IRQ_EXTERN1, KS8695_IRQ_EXTERN2, KS8695_IRQ_EXTERN3 }; | |
58 | ||
59 | /* | |
60 | * Configure GPIO pin as external interrupt source. | |
61 | */ | |
62 | int __init_or_module ks8695_gpio_interrupt(unsigned int pin, unsigned int type) | |
63 | { | |
64 | unsigned long x, flags; | |
65 | ||
66 | if (pin > KS8695_GPIO_3) /* only GPIO 0..3 can generate IRQ */ | |
67 | return -EINVAL; | |
68 | ||
69 | local_irq_save(flags); | |
70 | ||
71 | /* set pin as input */ | |
72 | x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM); | |
73 | x &= ~IOPM_(pin); | |
74 | __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM); | |
75 | ||
76 | local_irq_restore(flags); | |
77 | ||
78 | /* Set IRQ triggering type */ | |
79 | set_irq_type(gpio_irq[pin], type); | |
80 | ||
81 | /* enable interrupt mode */ | |
82 | ks8695_gpio_mode(pin, 0); | |
83 | ||
84 | return 0; | |
85 | } | |
86 | EXPORT_SYMBOL(ks8695_gpio_interrupt); | |
87 | ||
88 | ||
89 | ||
90 | /* .... Generic GPIO interface .............................................. */ | |
91 | ||
92 | /* | |
93 | * Configure the GPIO line as an input. | |
94 | */ | |
95 | int __init_or_module gpio_direction_input(unsigned int pin) | |
96 | { | |
97 | unsigned long x, flags; | |
98 | ||
99 | if (pin > KS8695_GPIO_15) | |
100 | return -EINVAL; | |
101 | ||
102 | /* set pin to GPIO mode */ | |
103 | ks8695_gpio_mode(pin, 1); | |
104 | ||
105 | local_irq_save(flags); | |
106 | ||
107 | /* set pin as input */ | |
108 | x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM); | |
109 | x &= ~IOPM_(pin); | |
110 | __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM); | |
111 | ||
112 | local_irq_restore(flags); | |
113 | ||
114 | return 0; | |
115 | } | |
116 | EXPORT_SYMBOL(gpio_direction_input); | |
117 | ||
118 | ||
119 | /* | |
120 | * Configure the GPIO line as an output, with default state. | |
121 | */ | |
122 | int __init_or_module gpio_direction_output(unsigned int pin, unsigned int state) | |
123 | { | |
124 | unsigned long x, flags; | |
125 | ||
126 | if (pin > KS8695_GPIO_15) | |
127 | return -EINVAL; | |
128 | ||
129 | /* set pin to GPIO mode */ | |
130 | ks8695_gpio_mode(pin, 1); | |
131 | ||
132 | local_irq_save(flags); | |
133 | ||
134 | /* set line state */ | |
135 | x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD); | |
136 | if (state) | |
137 | x |= (1 << pin); | |
138 | else | |
139 | x &= ~(1 << pin); | |
140 | __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPD); | |
141 | ||
142 | /* set pin as output */ | |
143 | x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM); | |
144 | x |= IOPM_(pin); | |
145 | __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM); | |
146 | ||
147 | local_irq_restore(flags); | |
148 | ||
149 | return 0; | |
150 | } | |
151 | EXPORT_SYMBOL(gpio_direction_output); | |
152 | ||
153 | ||
154 | /* | |
155 | * Set the state of an output GPIO line. | |
156 | */ | |
157 | void gpio_set_value(unsigned int pin, unsigned int state) | |
158 | { | |
159 | unsigned long x, flags; | |
160 | ||
161 | if (pin > KS8695_GPIO_15) | |
162 | return; | |
163 | ||
164 | local_irq_save(flags); | |
165 | ||
166 | /* set output line state */ | |
167 | x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD); | |
168 | if (state) | |
169 | x |= (1 << pin); | |
170 | else | |
171 | x &= ~(1 << pin); | |
172 | __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPD); | |
173 | ||
174 | local_irq_restore(flags); | |
175 | } | |
176 | EXPORT_SYMBOL(gpio_set_value); | |
177 | ||
178 | ||
179 | /* | |
180 | * Read the state of a GPIO line. | |
181 | */ | |
182 | int gpio_get_value(unsigned int pin) | |
183 | { | |
184 | unsigned long x; | |
185 | ||
186 | if (pin > KS8695_GPIO_15) | |
187 | return -EINVAL; | |
188 | ||
189 | x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD); | |
190 | return (x & (1 << pin)) != 0; | |
191 | } | |
192 | EXPORT_SYMBOL(gpio_get_value); | |
193 | ||
194 | ||
195 | /* | |
196 | * Map GPIO line to IRQ number. | |
197 | */ | |
198 | int gpio_to_irq(unsigned int pin) | |
199 | { | |
200 | if (pin > KS8695_GPIO_3) /* only GPIO 0..3 can generate IRQ */ | |
201 | return -EINVAL; | |
202 | ||
203 | return gpio_irq[pin]; | |
204 | } | |
205 | EXPORT_SYMBOL(gpio_to_irq); | |
206 | ||
207 | ||
208 | /* | |
209 | * Map IRQ number to GPIO line. | |
210 | */ | |
211 | int irq_to_gpio(unsigned int irq) | |
212 | { | |
213 | if ((irq < KS8695_IRQ_EXTERN0) || (irq > KS8695_IRQ_EXTERN3)) | |
214 | return -EINVAL; | |
215 | ||
216 | return (irq - KS8695_IRQ_EXTERN0); | |
217 | } | |
218 | EXPORT_SYMBOL(irq_to_gpio); |