Remove all inclusions of <linux/config.h>
[linux-3.10.git] / arch / arm / mach-pnx4008 / gpio.c
1 /*
2  * arch/arm/mach-pnx4008/gpio.c
3  *
4  * PNX4008 GPIO driver
5  *
6  * Author: Dmitry Chigirev <source@mvista.com>
7  *
8  * Based on reference code by Iwo Mergler and Z.Tabaaloute from Philips:
9  * Copyright (c) 2005 Koninklijke Philips Electronics N.V.
10  *
11  * 2005 (c) MontaVista Software, Inc. This file is licensed under
12  * the terms of the GNU General Public License version 2. This program
13  * is licensed "as is" without any warranty of any kind, whether express
14  * or implied.
15  */
16
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <asm/semaphore.h>
21 #include <asm/io.h>
22 #include <asm/arch/platform.h>
23 #include <asm/arch/gpio.h>
24
25 /* register definitions */
26 #define PIO_VA_BASE     IO_ADDRESS(PNX4008_PIO_BASE)
27
28 #define PIO_INP_STATE   (0x00U)
29 #define PIO_OUTP_SET    (0x04U)
30 #define PIO_OUTP_CLR    (0x08U)
31 #define PIO_OUTP_STATE  (0x0CU)
32 #define PIO_DRV_SET     (0x10U)
33 #define PIO_DRV_CLR     (0x14U)
34 #define PIO_DRV_STATE   (0x18U)
35 #define PIO_SDINP_STATE (0x1CU)
36 #define PIO_SDOUTP_SET  (0x20U)
37 #define PIO_SDOUTP_CLR  (0x24U)
38 #define PIO_MUX_SET     (0x28U)
39 #define PIO_MUX_CLR     (0x2CU)
40 #define PIO_MUX_STATE   (0x30U)
41
42 static inline void gpio_lock(void)
43 {
44         local_irq_disable();
45 }
46
47 static inline void gpio_unlock(void)
48 {
49         local_irq_enable();
50 }
51
52 /* Inline functions */
53 static inline int gpio_read_bit(u32 reg, int gpio)
54 {
55         u32 bit, val;
56         int ret = -EFAULT;
57
58         if (gpio < 0)
59                 goto out;
60
61         bit = GPIO_BIT(gpio);
62         if (bit) {
63                 val = __raw_readl(PIO_VA_BASE + reg);
64                 ret = (val & bit) ? 1 : 0;
65         }
66 out:
67         return ret;
68 }
69
70 static inline int gpio_set_bit(u32 reg, int gpio)
71 {
72         u32 bit, val;
73         int ret = -EFAULT;
74
75         if (gpio < 0)
76                 goto out;
77
78         bit = GPIO_BIT(gpio);
79         if (bit) {
80                 val = __raw_readl(PIO_VA_BASE + reg);
81                 val |= bit;
82                 __raw_writel(val, PIO_VA_BASE + reg);
83                 ret = 0;
84         }
85 out:
86         return ret;
87 }
88
89 /* Very simple access control, bitmap for allocated/free */
90 static unsigned long access_map[4];
91 #define INP_INDEX       0
92 #define OUTP_INDEX      1
93 #define GPIO_INDEX      2
94 #define MUX_INDEX       3
95
96 /*GPIO to Input Mapping */
97 static short gpio_to_inp_map[32] = {
98         -1, -1, -1, -1, -1, -1, -1, -1,
99         -1, -1, -1, -1, -1, -1, -1, -1,
100         -1, -1, -1, -1, -1, -1, -1, -1,
101         -1, 10, 11, 12, 13, 14, 24, -1
102 };
103
104 /*GPIO to Mux Mapping */
105 static short gpio_to_mux_map[32] = {
106         -1, -1, -1, -1, -1, -1, -1, -1,
107         -1, -1, -1, -1, -1, -1, -1, -1,
108         -1, -1, -1, -1, -1, -1, -1, -1,
109         -1, -1, -1, 0, 1, 4, 5, -1
110 };
111
112 /*Output to Mux Mapping */
113 static short outp_to_mux_map[32] = {
114         -1, -1, -1, 6, -1, -1, -1, -1,
115         -1, -1, -1, -1, -1, -1, -1, -1,
116         -1, -1, -1, -1, -1, 2, -1, -1,
117         -1, -1, -1, -1, -1, -1, -1, -1
118 };
119
120 int pnx4008_gpio_register_pin(unsigned short pin)
121 {
122         unsigned long bit = GPIO_BIT(pin);
123         int ret = -EBUSY;       /* Already in use */
124
125         gpio_lock();
126
127         if (GPIO_ISBID(pin)) {
128                 if (access_map[GPIO_INDEX] & bit)
129                         goto out;
130                 access_map[GPIO_INDEX] |= bit;
131
132         } else if (GPIO_ISRAM(pin)) {
133                 if (access_map[GPIO_INDEX] & bit)
134                         goto out;
135                 access_map[GPIO_INDEX] |= bit;
136
137         } else if (GPIO_ISMUX(pin)) {
138                 if (access_map[MUX_INDEX] & bit)
139                         goto out;
140                 access_map[MUX_INDEX] |= bit;
141
142         } else if (GPIO_ISOUT(pin)) {
143                 if (access_map[OUTP_INDEX] & bit)
144                         goto out;
145                 access_map[OUTP_INDEX] |= bit;
146
147         } else if (GPIO_ISIN(pin)) {
148                 if (access_map[INP_INDEX] & bit)
149                         goto out;
150                 access_map[INP_INDEX] |= bit;
151         } else
152                 goto out;
153         ret = 0;
154
155 out:
156         gpio_unlock();
157         return ret;
158 }
159
160 EXPORT_SYMBOL(pnx4008_gpio_register_pin);
161
162 int pnx4008_gpio_unregister_pin(unsigned short pin)
163 {
164         unsigned long bit = GPIO_BIT(pin);
165         int ret = -EFAULT;      /* Not registered */
166
167         gpio_lock();
168
169         if (GPIO_ISBID(pin)) {
170                 if (~access_map[GPIO_INDEX] & bit)
171                         goto out;
172                 access_map[GPIO_INDEX] &= ~bit;
173         } else if (GPIO_ISRAM(pin)) {
174                 if (~access_map[GPIO_INDEX] & bit)
175                         goto out;
176                 access_map[GPIO_INDEX] &= ~bit;
177         } else if (GPIO_ISMUX(pin)) {
178                 if (~access_map[MUX_INDEX] & bit)
179                         goto out;
180                 access_map[MUX_INDEX] &= ~bit;
181         } else if (GPIO_ISOUT(pin)) {
182                 if (~access_map[OUTP_INDEX] & bit)
183                         goto out;
184                 access_map[OUTP_INDEX] &= ~bit;
185         } else if (GPIO_ISIN(pin)) {
186                 if (~access_map[INP_INDEX] & bit)
187                         goto out;
188                 access_map[INP_INDEX] &= ~bit;
189         } else
190                 goto out;
191         ret = 0;
192
193 out:
194         gpio_unlock();
195         return ret;
196 }
197
198 EXPORT_SYMBOL(pnx4008_gpio_unregister_pin);
199
200 unsigned long pnx4008_gpio_read_pin(unsigned short pin)
201 {
202         unsigned long ret = -EFAULT;
203         int gpio = GPIO_BIT_MASK(pin);
204         gpio_lock();
205         if (GPIO_ISOUT(pin)) {
206                 ret = gpio_read_bit(PIO_OUTP_STATE, gpio);
207         } else if (GPIO_ISRAM(pin)) {
208                 if (gpio_read_bit(PIO_DRV_STATE, gpio) == 0) {
209                         ret = gpio_read_bit(PIO_SDINP_STATE, gpio);
210                 }
211         } else if (GPIO_ISBID(pin)) {
212                 ret = gpio_read_bit(PIO_DRV_STATE, gpio);
213                 if (ret > 0)
214                         ret = gpio_read_bit(PIO_OUTP_STATE, gpio);
215                 else if (ret == 0)
216                         ret =
217                             gpio_read_bit(PIO_INP_STATE, gpio_to_inp_map[gpio]);
218         } else if (GPIO_ISIN(pin)) {
219                 ret = gpio_read_bit(PIO_INP_STATE, gpio);
220         }
221         gpio_unlock();
222         return ret;
223 }
224
225 EXPORT_SYMBOL(pnx4008_gpio_read_pin);
226
227 /* Write Value to output */
228 int pnx4008_gpio_write_pin(unsigned short pin, int output)
229 {
230         int gpio = GPIO_BIT_MASK(pin);
231         int ret = -EFAULT;
232
233         gpio_lock();
234         if (GPIO_ISOUT(pin)) {
235                 printk( "writing '%x' to '%x'\n",
236                                 gpio, output ? PIO_OUTP_SET : PIO_OUTP_CLR );
237                 ret = gpio_set_bit(output ? PIO_OUTP_SET : PIO_OUTP_CLR, gpio);
238         } else if (GPIO_ISRAM(pin)) {
239                 if (gpio_read_bit(PIO_DRV_STATE, gpio) > 0)
240                         ret = gpio_set_bit(output ? PIO_SDOUTP_SET :
241                                            PIO_SDOUTP_CLR, gpio);
242         } else if (GPIO_ISBID(pin)) {
243                 if (gpio_read_bit(PIO_DRV_STATE, gpio) > 0)
244                         ret = gpio_set_bit(output ? PIO_OUTP_SET :
245                                            PIO_OUTP_CLR, gpio);
246         }
247         gpio_unlock();
248         return ret;
249 }
250
251 EXPORT_SYMBOL(pnx4008_gpio_write_pin);
252
253 /* Value = 1 : Set GPIO pin as output */
254 /* Value = 0 : Set GPIO pin as input */
255 int pnx4008_gpio_set_pin_direction(unsigned short pin, int output)
256 {
257         int gpio = GPIO_BIT_MASK(pin);
258         int ret = -EFAULT;
259
260         gpio_lock();
261         if (GPIO_ISBID(pin) || GPIO_ISRAM(pin)) {
262                 ret = gpio_set_bit(output ? PIO_DRV_SET : PIO_DRV_CLR, gpio);
263         }
264         gpio_unlock();
265         return ret;
266 }
267
268 EXPORT_SYMBOL(pnx4008_gpio_set_pin_direction);
269
270 /* Read GPIO pin direction: 0= pin used as input, 1= pin used as output*/
271 int pnx4008_gpio_read_pin_direction(unsigned short pin)
272 {
273         int gpio = GPIO_BIT_MASK(pin);
274         int ret = -EFAULT;
275
276         gpio_lock();
277         if (GPIO_ISBID(pin) || GPIO_ISRAM(pin)) {
278                 ret = gpio_read_bit(PIO_DRV_STATE, gpio);
279         }
280         gpio_unlock();
281         return ret;
282 }
283
284 EXPORT_SYMBOL(pnx4008_gpio_read_pin_direction);
285
286 /* Value = 1 : Set pin to muxed function  */
287 /* Value = 0 : Set pin as GPIO */
288 int pnx4008_gpio_set_pin_mux(unsigned short pin, int output)
289 {
290         int gpio = GPIO_BIT_MASK(pin);
291         int ret = -EFAULT;
292
293         gpio_lock();
294         if (GPIO_ISBID(pin)) {
295                 ret =
296                     gpio_set_bit(output ? PIO_MUX_SET : PIO_MUX_CLR,
297                                  gpio_to_mux_map[gpio]);
298         } else if (GPIO_ISOUT(pin)) {
299                 ret =
300                     gpio_set_bit(output ? PIO_MUX_SET : PIO_MUX_CLR,
301                                  outp_to_mux_map[gpio]);
302         } else if (GPIO_ISMUX(pin)) {
303                 ret = gpio_set_bit(output ? PIO_MUX_SET : PIO_MUX_CLR, gpio);
304         }
305         gpio_unlock();
306         return ret;
307 }
308
309 EXPORT_SYMBOL(pnx4008_gpio_set_pin_mux);
310
311 /* Read pin mux function: 0= pin used as GPIO, 1= pin used for muxed function*/
312 int pnx4008_gpio_read_pin_mux(unsigned short pin)
313 {
314         int gpio = GPIO_BIT_MASK(pin);
315         int ret = -EFAULT;
316
317         gpio_lock();
318         if (GPIO_ISBID(pin)) {
319                 ret = gpio_read_bit(PIO_MUX_STATE, gpio_to_mux_map[gpio]);
320         } else if (GPIO_ISOUT(pin)) {
321                 ret = gpio_read_bit(PIO_MUX_STATE, outp_to_mux_map[gpio]);
322         } else if (GPIO_ISMUX(pin)) {
323                 ret = gpio_read_bit(PIO_MUX_STATE, gpio);
324         }
325         gpio_unlock();
326         return ret;
327 }
328
329 EXPORT_SYMBOL(pnx4008_gpio_read_pin_mux);