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 <mach/hardware.h> 22 #include <mach/pxa-regs.h> 23 #include <mach/pxa2xx-regs.h> 24 #include <mach/mfp-pxa2xx.h> 25 26 #include "generic.h" 27 28 #define gpio_to_bank(gpio) ((gpio) >> 5) 29 30 #define PGSR(x) __REG2(0x40F00020, (x) << 2) 31 #define __GAFR(u, x) __REG2((u) ? 0x40E00058 : 0x40E00054, (x) << 3) 32 #define GAFR_L(x) __GAFR(0, x) 33 #define GAFR_U(x) __GAFR(1, x) 34 35 #define PWER_WE35 (1 << 24) 36 37 struct gpio_desc { 38 unsigned valid : 1; 39 unsigned can_wakeup : 1; 40 unsigned keypad_gpio : 1; 41 unsigned int mask; /* bit mask in PWER or PKWR */ 42 unsigned long config; 43 }; 44 45 static struct gpio_desc gpio_desc[MFP_PIN_GPIO127 + 1]; 46 static int gpio_nr; 47 48 static unsigned long gpdr_lpm[4]; 49 50 static int __mfp_config_gpio(unsigned gpio, unsigned long c) 51 { 52 unsigned long gafr, mask = GPIO_bit(gpio); 53 int bank = gpio_to_bank(gpio); 54 int uorl = !!(gpio & 0x10); /* GAFRx_U or GAFRx_L ? */ 55 int shft = (gpio & 0xf) << 1; 56 int fn = MFP_AF(c); 57 int dir = c & MFP_DIR_OUT; 58 59 if (fn > 3) 60 return -EINVAL; 61 62 /* alternate function and direction at run-time */ 63 gafr = (uorl == 0) ? GAFR_L(bank) : GAFR_U(bank); 64 gafr = (gafr & ~(0x3 << shft)) | (fn << shft); 65 66 if (uorl == 0) 67 GAFR_L(bank) = gafr; 68 else 69 GAFR_U(bank) = gafr; 70 71 if (dir == MFP_DIR_OUT) 72 GPDR(gpio) |= mask; 73 else 74 GPDR(gpio) &= ~mask; 75 76 /* alternate function and direction at low power mode */ 77 switch (c & MFP_LPM_STATE_MASK) { 78 case MFP_LPM_DRIVE_HIGH: 79 PGSR(bank) |= mask; 80 dir = MFP_DIR_OUT; 81 break; 82 case MFP_LPM_DRIVE_LOW: 83 PGSR(bank) &= ~mask; 84 dir = MFP_DIR_OUT; 85 break; 86 case MFP_LPM_DEFAULT: 87 break; 88 default: 89 /* warning and fall through, treat as MFP_LPM_DEFAULT */ 90 pr_warning("%s: GPIO%d: unsupported low power mode\n", 91 __func__, gpio); 92 break; 93 } 94 95 if (dir == MFP_DIR_OUT) 96 gpdr_lpm[bank] |= mask; 97 else 98 gpdr_lpm[bank] &= ~mask; 99 100 /* give early warning if MFP_LPM_CAN_WAKEUP is set on the 101 * configurations of those pins not able to wakeup 102 */ 103 if ((c & MFP_LPM_CAN_WAKEUP) && !gpio_desc[gpio].can_wakeup) { 104 pr_warning("%s: GPIO%d unable to wakeup\n", 105 __func__, gpio); 106 return -EINVAL; 107 } 108 109 if ((c & MFP_LPM_CAN_WAKEUP) && (dir == MFP_DIR_OUT)) { 110 pr_warning("%s: output GPIO%d unable to wakeup\n", 111 __func__, gpio); 112 return -EINVAL; 113 } 114 115 return 0; 116 } 117 118 static inline int __mfp_validate(int mfp) 119 { 120 int gpio = mfp_to_gpio(mfp); 121 122 if ((mfp > MFP_PIN_GPIO127) || !gpio_desc[gpio].valid) { 123 pr_warning("%s: GPIO%d is invalid pin\n", __func__, gpio); 124 return -1; 125 } 126 127 return gpio; 128 } 129 130 void pxa2xx_mfp_config(unsigned long *mfp_cfgs, int num) 131 { 132 unsigned long flags; 133 unsigned long *c; 134 int i, gpio; 135 136 for (i = 0, c = mfp_cfgs; i < num; i++, c++) { 137 138 gpio = __mfp_validate(MFP_PIN(*c)); 139 if (gpio < 0) 140 continue; 141 142 local_irq_save(flags); 143 144 gpio_desc[gpio].config = *c; 145 __mfp_config_gpio(gpio, *c); 146 147 local_irq_restore(flags); 148 } 149 } 150 151 void pxa2xx_mfp_set_lpm(int mfp, unsigned long lpm) 152 { 153 unsigned long flags, c; 154 int gpio; 155 156 gpio = __mfp_validate(mfp); 157 if (gpio < 0) 158 return; 159 160 local_irq_save(flags); 161 162 c = gpio_desc[gpio].config; 163 c = (c & ~MFP_LPM_STATE_MASK) | lpm; 164 __mfp_config_gpio(gpio, c); 165 166 local_irq_restore(flags); 167 } 168 169 int gpio_set_wake(unsigned int gpio, unsigned int on) 170 { 171 struct gpio_desc *d; 172 unsigned long c; 173 174 if (gpio > mfp_to_gpio(MFP_PIN_GPIO127)) 175 return -EINVAL; 176 177 d = &gpio_desc[gpio]; 178 c = d->config; 179 180 if (!d->valid) 181 return -EINVAL; 182 183 if (d->keypad_gpio) 184 return -EINVAL; 185 186 if (d->can_wakeup && (c & MFP_LPM_CAN_WAKEUP)) { 187 if (on) { 188 PWER |= d->mask; 189 190 if (c & MFP_LPM_EDGE_RISE) 191 PRER |= d->mask; 192 else 193 PRER &= ~d->mask; 194 195 if (c & MFP_LPM_EDGE_FALL) 196 PFER |= d->mask; 197 else 198 PFER &= ~d->mask; 199 } else { 200 PWER &= ~d->mask; 201 PRER &= ~d->mask; 202 PFER &= ~d->mask; 203 } 204 } 205 return 0; 206 } 207 208 #ifdef CONFIG_PXA25x 209 static void __init pxa25x_mfp_init(void) 210 { 211 int i; 212 213 for (i = 0; i <= 84; i++) 214 gpio_desc[i].valid = 1; 215 216 for (i = 0; i <= 15; i++) { 217 gpio_desc[i].can_wakeup = 1; 218 gpio_desc[i].mask = GPIO_bit(i); 219 } 220 221 gpio_nr = 85; 222 } 223 #else 224 static inline void pxa25x_mfp_init(void) {} 225 #endif /* CONFIG_PXA25x */ 226 227 #ifdef CONFIG_PXA27x 228 static int pxa27x_pkwr_gpio[] = { 229 13, 16, 17, 34, 36, 37, 38, 39, 90, 91, 93, 94, 230 95, 96, 97, 98, 99, 100, 101, 102 231 }; 232 233 int keypad_set_wake(unsigned int on) 234 { 235 unsigned int i, gpio, mask = 0; 236 237 if (!on) { 238 PKWR = 0; 239 return 0; 240 } 241 242 for (i = 0; i < ARRAY_SIZE(pxa27x_pkwr_gpio); i++) { 243 244 gpio = pxa27x_pkwr_gpio[i]; 245 246 if (gpio_desc[gpio].config & MFP_LPM_CAN_WAKEUP) 247 mask |= gpio_desc[gpio].mask; 248 } 249 250 PKWR = mask; 251 return 0; 252 } 253 254 static void __init pxa27x_mfp_init(void) 255 { 256 int i, gpio; 257 258 for (i = 0; i <= 120; i++) { 259 /* skip GPIO2, 5, 6, 7, 8, they are not 260 * valid pins allow configuration 261 */ 262 if (i == 2 || i == 5 || i == 6 || i == 7 || i == 8) 263 continue; 264 265 gpio_desc[i].valid = 1; 266 } 267 268 /* Keypad GPIOs */ 269 for (i = 0; i < ARRAY_SIZE(pxa27x_pkwr_gpio); i++) { 270 gpio = pxa27x_pkwr_gpio[i]; 271 gpio_desc[gpio].can_wakeup = 1; 272 gpio_desc[gpio].keypad_gpio = 1; 273 gpio_desc[gpio].mask = 1 << i; 274 } 275 276 /* Overwrite GPIO13 as a PWER wakeup source */ 277 for (i = 0; i <= 15; i++) { 278 /* skip GPIO2, 5, 6, 7, 8 */ 279 if (GPIO_bit(i) & 0x1e4) 280 continue; 281 282 gpio_desc[i].can_wakeup = 1; 283 gpio_desc[i].mask = GPIO_bit(i); 284 } 285 286 gpio_desc[35].can_wakeup = 1; 287 gpio_desc[35].mask = PWER_WE35; 288 289 gpio_nr = 121; 290 } 291 #else 292 static inline void pxa27x_mfp_init(void) {} 293 #endif /* CONFIG_PXA27x */ 294 295 #ifdef CONFIG_PM 296 static unsigned long saved_gafr[2][4]; 297 static unsigned long saved_gpdr[4]; 298 299 static int pxa2xx_mfp_suspend(struct sys_device *d, pm_message_t state) 300 { 301 int i; 302 303 for (i = 0; i <= gpio_to_bank(gpio_nr); i++) { 304 305 saved_gafr[0][i] = GAFR_L(i); 306 saved_gafr[1][i] = GAFR_U(i); 307 saved_gpdr[i] = GPDR(i * 32); 308 309 GPDR(i * 32) = gpdr_lpm[i]; 310 } 311 return 0; 312 } 313 314 static int pxa2xx_mfp_resume(struct sys_device *d) 315 { 316 int i; 317 318 for (i = 0; i <= gpio_to_bank(gpio_nr); i++) { 319 GAFR_L(i) = saved_gafr[0][i]; 320 GAFR_U(i) = saved_gafr[1][i]; 321 GPDR(i * 32) = saved_gpdr[i]; 322 } 323 PSSR = PSSR_RDH | PSSR_PH; 324 return 0; 325 } 326 #else 327 #define pxa2xx_mfp_suspend NULL 328 #define pxa2xx_mfp_resume NULL 329 #endif 330 331 struct sysdev_class pxa2xx_mfp_sysclass = { 332 .name = "mfp", 333 .suspend = pxa2xx_mfp_suspend, 334 .resume = pxa2xx_mfp_resume, 335 }; 336 337 static int __init pxa2xx_mfp_init(void) 338 { 339 int i; 340 341 if (!cpu_is_pxa2xx()) 342 return 0; 343 344 if (cpu_is_pxa25x()) 345 pxa25x_mfp_init(); 346 347 if (cpu_is_pxa27x()) 348 pxa27x_mfp_init(); 349 350 /* initialize gafr_run[], pgsr_lpm[] from existing values */ 351 for (i = 0; i <= gpio_to_bank(gpio_nr); i++) 352 gpdr_lpm[i] = GPDR(i * 32); 353 354 return sysdev_class_register(&pxa2xx_mfp_sysclass); 355 } 356 postcore_initcall(pxa2xx_mfp_init); 357