Merge branch 'linus' into x86/cleanups
[linux-2.6] / arch / arm / mach-pxa / mfp-pxa2xx.c
1 /*
2  *  linux/arch/arm/mach-pxa/mfp-pxa2xx.c
3  *
4  *  PXA2xx pin mux configuration support
5  *
6  *  The GPIOs on PXA2xx can be configured as one of many alternate
7  *  functions, this is by concept samilar to the MFP configuration
8  *  on PXA3xx,  what's more important, the low power pin state and
9  *  wakeup detection are also supported by the same framework.
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License version 2 as
13  *  published by the Free Software Foundation.
14  */
15
16 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/sysdev.h>
20
21 #include <asm/arch/hardware.h>
22 #include <asm/arch/pxa-regs.h>
23 #include <asm/arch/pxa2xx-regs.h>
24 #include <asm/arch/mfp-pxa2xx.h>
25
26 #include "generic.h"
27
28 #define PGSR(x)         __REG2(0x40F00020, ((x) & 0x60) >> 3)
29
30 #define PWER_WE35       (1 << 24)
31
32 struct gpio_desc {
33         unsigned        valid           : 1;
34         unsigned        can_wakeup      : 1;
35         unsigned        keypad_gpio     : 1;
36         unsigned int    mask; /* bit mask in PWER or PKWR */
37         unsigned long   config;
38 };
39
40 static struct gpio_desc gpio_desc[MFP_PIN_GPIO127 + 1];
41
42 static int __mfp_config_gpio(unsigned gpio, unsigned long c)
43 {
44         unsigned long gafr, mask = GPIO_bit(gpio);
45         int fn;
46
47         fn = MFP_AF(c);
48         if (fn > 3)
49                 return -EINVAL;
50
51         /* alternate function and direction */
52         gafr = GAFR(gpio) & ~(0x3 << ((gpio & 0xf) * 2));
53         GAFR(gpio) = gafr |  (fn  << ((gpio & 0xf) * 2));
54
55         if (c & MFP_DIR_OUT)
56                 GPDR(gpio) |= mask;
57         else
58                 GPDR(gpio) &= ~mask;
59
60         /* low power state */
61         switch (c & MFP_LPM_STATE_MASK) {
62         case MFP_LPM_DRIVE_HIGH:
63                 PGSR(gpio) |= mask;
64                 break;
65         case MFP_LPM_DRIVE_LOW:
66                 PGSR(gpio) &= ~mask;
67                 break;
68         case MFP_LPM_INPUT:
69                 break;
70         default:
71                 pr_warning("%s: invalid low power state for GPIO%d\n",
72                                 __func__, gpio);
73                 return -EINVAL;
74         }
75
76         /* give early warning if MFP_LPM_CAN_WAKEUP is set on the
77          * configurations of those pins not able to wakeup
78          */
79         if ((c & MFP_LPM_CAN_WAKEUP) && !gpio_desc[gpio].can_wakeup) {
80                 pr_warning("%s: GPIO%d unable to wakeup\n",
81                                 __func__, gpio);
82                 return -EINVAL;
83         }
84
85         if ((c & MFP_LPM_CAN_WAKEUP) && (c & MFP_DIR_OUT)) {
86                 pr_warning("%s: output GPIO%d unable to wakeup\n",
87                                 __func__, gpio);
88                 return -EINVAL;
89         }
90
91         return 0;
92 }
93
94 void pxa2xx_mfp_config(unsigned long *mfp_cfgs, int num)
95 {
96         unsigned long flags;
97         unsigned long *c;
98         int i, gpio;
99
100         for (i = 0, c = mfp_cfgs; i < num; i++, c++) {
101
102                 gpio = mfp_to_gpio(MFP_PIN(*c));
103
104                 if (!gpio_desc[gpio].valid) {
105                         pr_warning("%s: GPIO%d is invalid pin\n",
106                                 __func__, gpio);
107                         continue;
108                 }
109
110                 local_irq_save(flags);
111
112                 gpio_desc[gpio].config = *c;
113                 __mfp_config_gpio(gpio, *c);
114
115                 local_irq_restore(flags);
116         }
117 }
118
119 int gpio_set_wake(unsigned int gpio, unsigned int on)
120 {
121         struct gpio_desc *d;
122         unsigned long c;
123
124         if (gpio > mfp_to_gpio(MFP_PIN_GPIO127))
125                 return -EINVAL;
126
127         d = &gpio_desc[gpio];
128         c = d->config;
129
130         if (!d->valid)
131                 return -EINVAL;
132
133         if (d->keypad_gpio)
134                 return -EINVAL;
135
136         if (d->can_wakeup && (c & MFP_LPM_CAN_WAKEUP)) {
137                 if (on) {
138                         PWER |= d->mask;
139
140                         if (c & MFP_LPM_EDGE_RISE)
141                                 PRER |= d->mask;
142                         else
143                                 PRER &= ~d->mask;
144
145                         if (c & MFP_LPM_EDGE_FALL)
146                                 PFER |= d->mask;
147                         else
148                                 PFER &= ~d->mask;
149                 } else {
150                         PWER &= ~d->mask;
151                         PRER &= ~d->mask;
152                         PFER &= ~d->mask;
153                 }
154         }
155         return 0;
156 }
157
158 #ifdef CONFIG_PXA25x
159 static int __init pxa25x_mfp_init(void)
160 {
161         int i;
162
163         if (cpu_is_pxa25x()) {
164                 for (i = 0; i <= 84; i++)
165                         gpio_desc[i].valid = 1;
166
167                 for (i = 0; i <= 15; i++) {
168                         gpio_desc[i].can_wakeup = 1;
169                         gpio_desc[i].mask = GPIO_bit(i);
170                 }
171         }
172
173         return 0;
174 }
175 postcore_initcall(pxa25x_mfp_init);
176 #endif /* CONFIG_PXA25x */
177
178 #ifdef CONFIG_PXA27x
179 static int pxa27x_pkwr_gpio[] = {
180         13, 16, 17, 34, 36, 37, 38, 39, 90, 91, 93, 94,
181         95, 96, 97, 98, 99, 100, 101, 102
182 };
183
184 int keypad_set_wake(unsigned int on)
185 {
186         unsigned int i, gpio, mask = 0;
187
188         if (!on) {
189                 PKWR = 0;
190                 return 0;
191         }
192
193         for (i = 0; i < ARRAY_SIZE(pxa27x_pkwr_gpio); i++) {
194
195                 gpio = pxa27x_pkwr_gpio[i];
196
197                 if (gpio_desc[gpio].config & MFP_LPM_CAN_WAKEUP)
198                         mask |= gpio_desc[gpio].mask;
199         }
200
201         PKWR = mask;
202         return 0;
203 }
204
205 static int __init pxa27x_mfp_init(void)
206 {
207         int i, gpio;
208
209         if (cpu_is_pxa27x()) {
210                 for (i = 0; i <= 120; i++) {
211                         /* skip GPIO2, 5, 6, 7, 8, they are not
212                          * valid pins allow configuration
213                          */
214                         if (i == 2 || i == 5 || i == 6 ||
215                             i == 7 || i == 8)
216                                 continue;
217
218                         gpio_desc[i].valid = 1;
219                 }
220
221                 /* Keypad GPIOs */
222                 for (i = 0; i < ARRAY_SIZE(pxa27x_pkwr_gpio); i++) {
223                         gpio = pxa27x_pkwr_gpio[i];
224                         gpio_desc[gpio].can_wakeup = 1;
225                         gpio_desc[gpio].keypad_gpio = 1;
226                         gpio_desc[gpio].mask = 1 << i;
227                 }
228
229                 /* Overwrite GPIO13 as a PWER wakeup source */
230                 for (i = 0; i <= 15; i++) {
231                         /* skip GPIO2, 5, 6, 7, 8 */
232                         if (GPIO_bit(i) & 0x1e4)
233                                 continue;
234
235                         gpio_desc[i].can_wakeup = 1;
236                         gpio_desc[i].mask = GPIO_bit(i);
237                 }
238
239                 gpio_desc[35].can_wakeup = 1;
240                 gpio_desc[35].mask = PWER_WE35;
241         }
242
243         return 0;
244 }
245 postcore_initcall(pxa27x_mfp_init);
246 #endif /* CONFIG_PXA27x */