projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus-4.8' of git://git.kernel.org/pub/scm/linux/kernel/git/mason...
[deliverable/linux.git] / arch / blackfin / kernel / bfin_gpio.c
1 /*
2 * GPIO Abstraction Layer
3 *
4 * Copyright 2006-2010 Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later
7 */
8
9 #include <linux/delay.h>
10 #include <linux/module.h>
11 #include <linux/err.h>
12 #include <linux/proc_fs.h>
13 #include <linux/seq_file.h>
14 #include <linux/gpio/driver.h>
15 /* FIXME: consumer API required for gpio_set_value() etc, get rid of this */
16 #include <linux/gpio.h>
17 #include <linux/irq.h>
18
19 #if ANOMALY_05000311 || ANOMALY_05000323
20 enum {
21 AWA_data = SYSCR,
22 AWA_data_clear = SYSCR,
23 AWA_data_set = SYSCR,
24 AWA_toggle = SYSCR,
25 AWA_maska = BFIN_UART_SCR,
26 AWA_maska_clear = BFIN_UART_SCR,
27 AWA_maska_set = BFIN_UART_SCR,
28 AWA_maska_toggle = BFIN_UART_SCR,
29 AWA_maskb = BFIN_UART_GCTL,
30 AWA_maskb_clear = BFIN_UART_GCTL,
31 AWA_maskb_set = BFIN_UART_GCTL,
32 AWA_maskb_toggle = BFIN_UART_GCTL,
33 AWA_dir = SPORT1_STAT,
34 AWA_polar = SPORT1_STAT,
35 AWA_edge = SPORT1_STAT,
36 AWA_both = SPORT1_STAT,
37 #if ANOMALY_05000311
38 AWA_inen = TIMER_ENABLE,
39 #elif ANOMALY_05000323
40 AWA_inen = DMA1_1_CONFIG,
41 #endif
42 };
43 /* Anomaly Workaround */
44 #define AWA_DUMMY_READ(name) bfin_read16(AWA_ ## name)
45 #else
46 #define AWA_DUMMY_READ(...) do { } while (0)
47 #endif
48
49 static struct gpio_port_t * const gpio_array[] = {
50 #if defined(BF533_FAMILY) || defined(BF538_FAMILY)
51 (struct gpio_port_t *) FIO_FLAG_D,
52 #elif defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
53 (struct gpio_port_t *) PORTFIO,
54 (struct gpio_port_t *) PORTGIO,
55 (struct gpio_port_t *) PORTHIO,
56 #elif defined(BF561_FAMILY)
57 (struct gpio_port_t *) FIO0_FLAG_D,
58 (struct gpio_port_t *) FIO1_FLAG_D,
59 (struct gpio_port_t *) FIO2_FLAG_D,
60 #else
61 # error no gpio arrays defined
62 #endif
63 };
64
65 #if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
66 static unsigned short * const port_fer[] = {
67 (unsigned short *) PORTF_FER,
68 (unsigned short *) PORTG_FER,
69 (unsigned short *) PORTH_FER,
70 };
71
72 # if !defined(BF537_FAMILY)
73 static unsigned short * const port_mux[] = {
74 (unsigned short *) PORTF_MUX,
75 (unsigned short *) PORTG_MUX,
76 (unsigned short *) PORTH_MUX,
77 };
78
79 static const
80 u8 pmux_offset[][16] = {
81 # if defined(CONFIG_BF52x)
82 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 4, 6, 8, 8, 10, 10 }, /* PORTF */
83 { 0, 0, 0, 0, 0, 2, 2, 4, 4, 6, 8, 10, 10, 10, 12, 12 }, /* PORTG */
84 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 4, 4, 4, 4, 4 }, /* PORTH */
85 # elif defined(CONFIG_BF51x)
86 { 0, 2, 2, 2, 2, 2, 2, 4, 6, 6, 6, 8, 8, 8, 8, 10 }, /* PORTF */
87 { 0, 0, 0, 2, 4, 6, 6, 6, 8, 10, 10, 12, 14, 14, 14, 14 }, /* PORTG */
88 { 0, 0, 0, 0, 2, 2, 4, 6, 10, 10, 10, 10, 10, 10, 10, 10 }, /* PORTH */
89 # endif
90 };
91 # endif
92
93 #elif defined(BF538_FAMILY)
94 static unsigned short * const port_fer[] = {
95 (unsigned short *) PORTCIO_FER,
96 (unsigned short *) PORTDIO_FER,
97 (unsigned short *) PORTEIO_FER,
98 };
99 #endif
100
101 #define RESOURCE_LABEL_SIZE 16
102
103 static struct str_ident {
104 char name[RESOURCE_LABEL_SIZE];
105 } str_ident[MAX_RESOURCES];
106
107 #if defined(CONFIG_PM)
108 static struct gpio_port_s gpio_bank_saved[GPIO_BANK_NUM];
109 # ifdef BF538_FAMILY
110 static unsigned short port_fer_saved[3];
111 # endif
112 #endif
113
114 static void gpio_error(unsigned gpio)
115 {
116 printk(KERN_ERR "bfin-gpio: GPIO %d wasn't requested!\n", gpio);
117 }
118
119 static void set_label(unsigned short ident, const char *label)
120 {
121 if (label) {
122 strncpy(str_ident[ident].name, label,
123 RESOURCE_LABEL_SIZE);
124 str_ident[ident].name[RESOURCE_LABEL_SIZE - 1] = 0;
125 }
126 }
127
128 static char *get_label(unsigned short ident)
129 {
130 return (*str_ident[ident].name ? str_ident[ident].name : "UNKNOWN");
131 }
132
133 static int cmp_label(unsigned short ident, const char *label)
134 {
135 if (label == NULL) {
136 dump_stack();
137 printk(KERN_ERR "Please provide none-null label\n");
138 }
139
140 if (label)
141 return strcmp(str_ident[ident].name, label);
142 else
143 return -EINVAL;
144 }
145
146 #define map_entry(m, i) reserved_##m##_map[gpio_bank(i)]
147 #define is_reserved(m, i, e) (map_entry(m, i) & gpio_bit(i))
148 #define reserve(m, i) (map_entry(m, i) |= gpio_bit(i))
149 #define unreserve(m, i) (map_entry(m, i) &= ~gpio_bit(i))
150 #define DECLARE_RESERVED_MAP(m, c) static unsigned short reserved_##m##_map[c]
151
152 DECLARE_RESERVED_MAP(gpio, GPIO_BANK_NUM);
153 DECLARE_RESERVED_MAP(peri, DIV_ROUND_UP(MAX_RESOURCES, GPIO_BANKSIZE));
154 DECLARE_RESERVED_MAP(gpio_irq, GPIO_BANK_NUM);
155
156 inline int check_gpio(unsigned gpio)
157 {
158 if (gpio >= MAX_BLACKFIN_GPIOS)
159 return -EINVAL;
160 return 0;
161 }
162
163 static void port_setup(unsigned gpio, unsigned short usage)
164 {
165 #if defined(BF538_FAMILY)
166 /*
167 * BF538/9 Port C,D and E are special.
168 * Inverted PORT_FER polarity on CDE and no PORF_FER on F
169 * Regular PORT F GPIOs are handled here, CDE are exclusively
170 * managed by GPIOLIB
171 */
172
173 if (gpio < MAX_BLACKFIN_GPIOS || gpio >= MAX_RESOURCES)
174 return;
175
176 gpio -= MAX_BLACKFIN_GPIOS;
177
178 if (usage == GPIO_USAGE)
179 *port_fer[gpio_bank(gpio)] |= gpio_bit(gpio);
180 else
181 *port_fer[gpio_bank(gpio)] &= ~gpio_bit(gpio);
182 SSYNC();
183 return;
184 #endif
185
186 if (check_gpio(gpio))
187 return;
188
189 #if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
190 if (usage == GPIO_USAGE)
191 *port_fer[gpio_bank(gpio)] &= ~gpio_bit(gpio);
192 else
193 *port_fer[gpio_bank(gpio)] |= gpio_bit(gpio);
194 SSYNC();
195 #endif
196 }
197
198 #ifdef BF537_FAMILY
199 static const s8 port_mux[] = {
200 [GPIO_PF0] = 3,
201 [GPIO_PF1] = 3,
202 [GPIO_PF2] = 4,
203 [GPIO_PF3] = 4,
204 [GPIO_PF4] = 5,
205 [GPIO_PF5] = 6,
206 [GPIO_PF6] = 7,
207 [GPIO_PF7] = 8,
208 [GPIO_PF8 ... GPIO_PF15] = -1,
209 [GPIO_PG0 ... GPIO_PG7] = -1,
210 [GPIO_PG8] = 9,
211 [GPIO_PG9] = 9,
212 [GPIO_PG10] = 10,
213 [GPIO_PG11] = 10,
214 [GPIO_PG12] = 10,
215 [GPIO_PG13] = 11,
216 [GPIO_PG14] = 11,
217 [GPIO_PG15] = 11,
218 [GPIO_PH0 ... GPIO_PH15] = -1,
219 [PORT_PJ0 ... PORT_PJ3] = -1,
220 [PORT_PJ4] = 1,
221 [PORT_PJ5] = 1,
222 [PORT_PJ6 ... PORT_PJ9] = -1,
223 [PORT_PJ10] = 0,
224 [PORT_PJ11] = 0,
225 };
226
227 static int portmux_group_check(unsigned short per)
228 {
229 u16 ident = P_IDENT(per);
230 u16 function = P_FUNCT2MUX(per);
231 s8 offset = port_mux[ident];
232 u16 m, pmux, pfunc, mask;
233
234 if (offset < 0)
235 return 0;
236
237 pmux = bfin_read_PORT_MUX();
238 for (m = 0; m < ARRAY_SIZE(port_mux); ++m) {
239 if (m == ident)
240 continue;
241 if (port_mux[m] != offset)
242 continue;
243 if (!is_reserved(peri, m, 1))
244 continue;
245
246 if (offset == 1)
247 mask = 3;
248 else
249 mask = 1;
250
251 pfunc = (pmux >> offset) & mask;
252 if (pfunc != (function & mask)) {
253 pr_err("pin group conflict! request pin %d func %d conflict with pin %d func %d\n",
254 ident, function, m, pfunc);
255 return -EINVAL;
256 }
257 }
258
259 return 0;
260 }
261
262 static void portmux_setup(unsigned short per)
263 {
264 u16 ident = P_IDENT(per);
265 u16 function = P_FUNCT2MUX(per);
266 s8 offset = port_mux[ident];
267 u16 pmux, mask;
268
269 if (offset == -1)
270 return;
271
272 pmux = bfin_read_PORT_MUX();
273 if (offset == 1)
274 mask = 3;
275 else
276 mask = 1;
277
278 pmux &= ~(mask << offset);
279 pmux |= ((function & mask) << offset);
280
281 bfin_write_PORT_MUX(pmux);
282 }
283 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
284 static int portmux_group_check(unsigned short per)
285 {
286 u16 ident = P_IDENT(per);
287 u16 function = P_FUNCT2MUX(per);
288 u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
289 u16 pin, gpiopin, pfunc;
290
291 for (pin = 0; pin < GPIO_BANKSIZE; ++pin) {
292 if (offset != pmux_offset[gpio_bank(ident)][pin])
293 continue;
294
295 gpiopin = gpio_bank(ident) * GPIO_BANKSIZE + pin;
296 if (gpiopin == ident)
297 continue;
298 if (!is_reserved(peri, gpiopin, 1))
299 continue;
300
301 pfunc = *port_mux[gpio_bank(ident)];
302 pfunc = (pfunc >> offset) & 3;
303 if (pfunc != function) {
304 pr_err("pin group conflict! request pin %d func %d conflict with pin %d func %d\n",
305 ident, function, gpiopin, pfunc);
306 return -EINVAL;
307 }
308 }
309
310 return 0;
311 }
312
313 inline void portmux_setup(unsigned short per)
314 {
315 u16 ident = P_IDENT(per);
316 u16 function = P_FUNCT2MUX(per);
317 u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
318 u16 pmux;
319
320 pmux = *port_mux[gpio_bank(ident)];
321 if (((pmux >> offset) & 3) == function)
322 return;
323 pmux &= ~(3 << offset);
324 pmux |= (function & 3) << offset;
325 *port_mux[gpio_bank(ident)] = pmux;
326 SSYNC();
327 }
328 #else
329 # define portmux_setup(...) do { } while (0)
330 static int portmux_group_check(unsigned short per)
331 {
332 return 0;
333 }
334 #endif
335
336 /***********************************************************
337 *
338 * FUNCTIONS: Blackfin General Purpose Ports Access Functions
339 *
340 * INPUTS/OUTPUTS:
341 * gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
342 *
343 *
344 * DESCRIPTION: These functions abstract direct register access
345 * to Blackfin processor General Purpose
346 * Ports Regsiters
347 *
348 * CAUTION: These functions do not belong to the GPIO Driver API
349 *************************************************************
350 * MODIFICATION HISTORY :
351 **************************************************************/
352
353 /* Set a specific bit */
354
355 #define SET_GPIO(name) \
356 void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
357 { \
358 unsigned long flags; \
359 flags = hard_local_irq_save(); \
360 if (arg) \
361 gpio_array[gpio_bank(gpio)]->name |= gpio_bit(gpio); \
362 else \
363 gpio_array[gpio_bank(gpio)]->name &= ~gpio_bit(gpio); \
364 AWA_DUMMY_READ(name); \
365 hard_local_irq_restore(flags); \
366 } \
367 EXPORT_SYMBOL(set_gpio_ ## name);
368
369 SET_GPIO(dir) /* set_gpio_dir() */
370 SET_GPIO(inen) /* set_gpio_inen() */
371 SET_GPIO(polar) /* set_gpio_polar() */
372 SET_GPIO(edge) /* set_gpio_edge() */
373 SET_GPIO(both) /* set_gpio_both() */
374
375
376 #define SET_GPIO_SC(name) \
377 void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
378 { \
379 unsigned long flags; \
380 if (ANOMALY_05000311 || ANOMALY_05000323) \
381 flags = hard_local_irq_save(); \
382 if (arg) \
383 gpio_array[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
384 else \
385 gpio_array[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
386 if (ANOMALY_05000311 || ANOMALY_05000323) { \
387 AWA_DUMMY_READ(name); \
388 hard_local_irq_restore(flags); \
389 } \
390 } \
391 EXPORT_SYMBOL(set_gpio_ ## name);
392
393 SET_GPIO_SC(maska)
394 SET_GPIO_SC(maskb)
395 SET_GPIO_SC(data)
396
397 void set_gpio_toggle(unsigned gpio)
398 {
399 unsigned long flags;
400 if (ANOMALY_05000311 || ANOMALY_05000323)
401 flags = hard_local_irq_save();
402 gpio_array[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
403 if (ANOMALY_05000311 || ANOMALY_05000323) {
404 AWA_DUMMY_READ(toggle);
405 hard_local_irq_restore(flags);
406 }
407 }
408 EXPORT_SYMBOL(set_gpio_toggle);
409
410
411 /*Set current PORT date (16-bit word)*/
412
413 #define SET_GPIO_P(name) \
414 void set_gpiop_ ## name(unsigned gpio, unsigned short arg) \
415 { \
416 unsigned long flags; \
417 if (ANOMALY_05000311 || ANOMALY_05000323) \
418 flags = hard_local_irq_save(); \
419 gpio_array[gpio_bank(gpio)]->name = arg; \
420 if (ANOMALY_05000311 || ANOMALY_05000323) { \
421 AWA_DUMMY_READ(name); \
422 hard_local_irq_restore(flags); \
423 } \
424 } \
425 EXPORT_SYMBOL(set_gpiop_ ## name);
426
427 SET_GPIO_P(data)
428 SET_GPIO_P(dir)
429 SET_GPIO_P(inen)
430 SET_GPIO_P(polar)
431 SET_GPIO_P(edge)
432 SET_GPIO_P(both)
433 SET_GPIO_P(maska)
434 SET_GPIO_P(maskb)
435
436 /* Get a specific bit */
437 #define GET_GPIO(name) \
438 unsigned short get_gpio_ ## name(unsigned gpio) \
439 { \
440 unsigned long flags; \
441 unsigned short ret; \
442 if (ANOMALY_05000311 || ANOMALY_05000323) \
443 flags = hard_local_irq_save(); \
444 ret = 0x01 & (gpio_array[gpio_bank(gpio)]->name >> gpio_sub_n(gpio)); \
445 if (ANOMALY_05000311 || ANOMALY_05000323) { \
446 AWA_DUMMY_READ(name); \
447 hard_local_irq_restore(flags); \
448 } \
449 return ret; \
450 } \
451 EXPORT_SYMBOL(get_gpio_ ## name);
452
453 GET_GPIO(data)
454 GET_GPIO(dir)
455 GET_GPIO(inen)
456 GET_GPIO(polar)
457 GET_GPIO(edge)
458 GET_GPIO(both)
459 GET_GPIO(maska)
460 GET_GPIO(maskb)
461
462 /*Get current PORT date (16-bit word)*/
463
464 #define GET_GPIO_P(name) \
465 unsigned short get_gpiop_ ## name(unsigned gpio) \
466 { \
467 unsigned long flags; \
468 unsigned short ret; \
469 if (ANOMALY_05000311 || ANOMALY_05000323) \
470 flags = hard_local_irq_save(); \
471 ret = (gpio_array[gpio_bank(gpio)]->name); \
472 if (ANOMALY_05000311 || ANOMALY_05000323) { \
473 AWA_DUMMY_READ(name); \
474 hard_local_irq_restore(flags); \
475 } \
476 return ret; \
477 } \
478 EXPORT_SYMBOL(get_gpiop_ ## name);
479
480 GET_GPIO_P(data)
481 GET_GPIO_P(dir)
482 GET_GPIO_P(inen)
483 GET_GPIO_P(polar)
484 GET_GPIO_P(edge)
485 GET_GPIO_P(both)
486 GET_GPIO_P(maska)
487 GET_GPIO_P(maskb)
488
489
490 #ifdef CONFIG_PM
491 DECLARE_RESERVED_MAP(wakeup, GPIO_BANK_NUM);
492
493 static const unsigned int sic_iwr_irqs[] = {
494 #if defined(BF533_FAMILY)
495 IRQ_PROG_INTB
496 #elif defined(BF537_FAMILY)
497 IRQ_PF_INTB_WATCH, IRQ_PORTG_INTB, IRQ_PH_INTB_MAC_TX
498 #elif defined(BF538_FAMILY)
499 IRQ_PORTF_INTB
500 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
501 IRQ_PORTF_INTB, IRQ_PORTG_INTB, IRQ_PORTH_INTB
502 #elif defined(BF561_FAMILY)
503 IRQ_PROG0_INTB, IRQ_PROG1_INTB, IRQ_PROG2_INTB
504 #else
505 # error no SIC_IWR defined
506 #endif
507 };
508
509 /***********************************************************
510 *
511 * FUNCTIONS: Blackfin PM Setup API
512 *
513 * INPUTS/OUTPUTS:
514 * gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
515 * type -
516 * PM_WAKE_RISING
517 * PM_WAKE_FALLING
518 * PM_WAKE_HIGH
519 * PM_WAKE_LOW
520 * PM_WAKE_BOTH_EDGES
521 *
522 * DESCRIPTION: Blackfin PM Driver API
523 *
524 * CAUTION:
525 *************************************************************
526 * MODIFICATION HISTORY :
527 **************************************************************/
528 int bfin_gpio_pm_wakeup_ctrl(unsigned gpio, unsigned ctrl)
529 {
530 unsigned long flags;
531
532 if (check_gpio(gpio) < 0)
533 return -EINVAL;
534
535 flags = hard_local_irq_save();
536 if (ctrl)
537 reserve(wakeup, gpio);
538 else
539 unreserve(wakeup, gpio);
540
541 set_gpio_maskb(gpio, ctrl);
542 hard_local_irq_restore(flags);
543
544 return 0;
545 }
546
547 int bfin_gpio_pm_standby_ctrl(unsigned ctrl)
548 {
549 u16 bank, mask, i;
550
551 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
552 mask = map_entry(wakeup, i);
553 bank = gpio_bank(i);
554
555 if (mask)
556 bfin_internal_set_wake(sic_iwr_irqs[bank], ctrl);
557 }
558 return 0;
559 }
560
561 void bfin_gpio_pm_hibernate_suspend(void)
562 {
563 int i, bank;
564
565 #ifdef BF538_FAMILY
566 for (i = 0; i < ARRAY_SIZE(port_fer_saved); ++i)
567 port_fer_saved[i] = *port_fer[i];
568 #endif
569
570 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
571 bank = gpio_bank(i);
572
573 #if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
574 gpio_bank_saved[bank].fer = *port_fer[bank];
575 #if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
576 gpio_bank_saved[bank].mux = *port_mux[bank];
577 #else
578 if (bank == 0)
579 gpio_bank_saved[bank].mux = bfin_read_PORT_MUX();
580 #endif
581 #endif
582 gpio_bank_saved[bank].data = gpio_array[bank]->data;
583 gpio_bank_saved[bank].inen = gpio_array[bank]->inen;
584 gpio_bank_saved[bank].polar = gpio_array[bank]->polar;
585 gpio_bank_saved[bank].dir = gpio_array[bank]->dir;
586 gpio_bank_saved[bank].edge = gpio_array[bank]->edge;
587 gpio_bank_saved[bank].both = gpio_array[bank]->both;
588 gpio_bank_saved[bank].maska = gpio_array[bank]->maska;
589 }
590
591 #ifdef BFIN_SPECIAL_GPIO_BANKS
592 bfin_special_gpio_pm_hibernate_suspend();
593 #endif
594
595 AWA_DUMMY_READ(maska);
596 }
597
598 void bfin_gpio_pm_hibernate_restore(void)
599 {
600 int i, bank;
601
602 #ifdef BF538_FAMILY
603 for (i = 0; i < ARRAY_SIZE(port_fer_saved); ++i)
604 *port_fer[i] = port_fer_saved[i];
605 #endif
606
607 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
608 bank = gpio_bank(i);
609
610 #if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
611 #if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
612 *port_mux[bank] = gpio_bank_saved[bank].mux;
613 #else
614 if (bank == 0)
615 bfin_write_PORT_MUX(gpio_bank_saved[bank].mux);
616 #endif
617 *port_fer[bank] = gpio_bank_saved[bank].fer;
618 #endif
619 gpio_array[bank]->inen = gpio_bank_saved[bank].inen;
620 gpio_array[bank]->data_set = gpio_bank_saved[bank].data
621 & gpio_bank_saved[bank].dir;
622 gpio_array[bank]->dir = gpio_bank_saved[bank].dir;
623 gpio_array[bank]->polar = gpio_bank_saved[bank].polar;
624 gpio_array[bank]->edge = gpio_bank_saved[bank].edge;
625 gpio_array[bank]->both = gpio_bank_saved[bank].both;
626 gpio_array[bank]->maska = gpio_bank_saved[bank].maska;
627 }
628
629 #ifdef BFIN_SPECIAL_GPIO_BANKS
630 bfin_special_gpio_pm_hibernate_restore();
631 #endif
632
633 AWA_DUMMY_READ(maska);
634 }
635
636
637 #endif
638
639 /***********************************************************
640 *
641 * FUNCTIONS: Blackfin Peripheral Resource Allocation
642 * and PortMux Setup
643 *
644 * INPUTS/OUTPUTS:
645 * per Peripheral Identifier
646 * label String
647 *
648 * DESCRIPTION: Blackfin Peripheral Resource Allocation and Setup API
649 *
650 * CAUTION:
651 *************************************************************
652 * MODIFICATION HISTORY :
653 **************************************************************/
654
655 int peripheral_request(unsigned short per, const char *label)
656 {
657 unsigned long flags;
658 unsigned short ident = P_IDENT(per);
659
660 /*
661 * Don't cares are pins with only one dedicated function
662 */
663
664 if (per & P_DONTCARE)
665 return 0;
666
667 if (!(per & P_DEFINED))
668 return -ENODEV;
669
670 BUG_ON(ident >= MAX_RESOURCES);
671
672 flags = hard_local_irq_save();
673
674 /* If a pin can be muxed as either GPIO or peripheral, make
675 * sure it is not already a GPIO pin when we request it.
676 */
677 if (unlikely(!check_gpio(ident) && is_reserved(gpio, ident, 1))) {
678 if (system_state == SYSTEM_BOOTING)
679 dump_stack();
680 printk(KERN_ERR
681 "%s: Peripheral %d is already reserved as GPIO by %s !\n",
682 __func__, ident, get_label(ident));
683 hard_local_irq_restore(flags);
684 return -EBUSY;
685 }
686
687 if (unlikely(is_reserved(peri, ident, 1))) {
688
689 /*
690 * Pin functions like AMC address strobes my
691 * be requested and used by several drivers
692 */
693
694 if (!(per & P_MAYSHARE)) {
695 /*
696 * Allow that the identical pin function can
697 * be requested from the same driver twice
698 */
699
700 if (cmp_label(ident, label) == 0)
701 goto anyway;
702
703 if (system_state == SYSTEM_BOOTING)
704 dump_stack();
705 printk(KERN_ERR
706 "%s: Peripheral %d function %d is already reserved by %s !\n",
707 __func__, ident, P_FUNCT2MUX(per), get_label(ident));
708 hard_local_irq_restore(flags);
709 return -EBUSY;
710 }
711 }
712
713 if (unlikely(portmux_group_check(per))) {
714 hard_local_irq_restore(flags);
715 return -EBUSY;
716 }
717 anyway:
718 reserve(peri, ident);
719
720 portmux_setup(per);
721 port_setup(ident, PERIPHERAL_USAGE);
722
723 hard_local_irq_restore(flags);
724 set_label(ident, label);
725
726 return 0;
727 }
728 EXPORT_SYMBOL(peripheral_request);
729
730 int peripheral_request_list(const unsigned short per[], const char *label)
731 {
732 u16 cnt;
733 int ret;
734
735 for (cnt = 0; per[cnt] != 0; cnt++) {
736
737 ret = peripheral_request(per[cnt], label);
738
739 if (ret < 0) {
740 for ( ; cnt > 0; cnt--)
741 peripheral_free(per[cnt - 1]);
742
743 return ret;
744 }
745 }
746
747 return 0;
748 }
749 EXPORT_SYMBOL(peripheral_request_list);
750
751 void peripheral_free(unsigned short per)
752 {
753 unsigned long flags;
754 unsigned short ident = P_IDENT(per);
755
756 if (per & P_DONTCARE)
757 return;
758
759 if (!(per & P_DEFINED))
760 return;
761
762 flags = hard_local_irq_save();
763
764 if (unlikely(!is_reserved(peri, ident, 0))) {
765 hard_local_irq_restore(flags);
766 return;
767 }
768
769 if (!(per & P_MAYSHARE))
770 port_setup(ident, GPIO_USAGE);
771
772 unreserve(peri, ident);
773
774 set_label(ident, "free");
775
776 hard_local_irq_restore(flags);
777 }
778 EXPORT_SYMBOL(peripheral_free);
779
780 void peripheral_free_list(const unsigned short per[])
781 {
782 u16 cnt;
783 for (cnt = 0; per[cnt] != 0; cnt++)
784 peripheral_free(per[cnt]);
785 }
786 EXPORT_SYMBOL(peripheral_free_list);
787
788 /***********************************************************
789 *
790 * FUNCTIONS: Blackfin GPIO Driver
791 *
792 * INPUTS/OUTPUTS:
793 * gpio PIO Number between 0 and MAX_BLACKFIN_GPIOS
794 * label String
795 *
796 * DESCRIPTION: Blackfin GPIO Driver API
797 *
798 * CAUTION:
799 *************************************************************
800 * MODIFICATION HISTORY :
801 **************************************************************/
802
803 int bfin_gpio_request(unsigned gpio, const char *label)
804 {
805 unsigned long flags;
806
807 if (check_gpio(gpio) < 0)
808 return -EINVAL;
809
810 flags = hard_local_irq_save();
811
812 /*
813 * Allow that the identical GPIO can
814 * be requested from the same driver twice
815 * Do nothing and return -
816 */
817
818 if (cmp_label(gpio, label) == 0) {
819 hard_local_irq_restore(flags);
820 return 0;
821 }
822
823 if (unlikely(is_reserved(gpio, gpio, 1))) {
824 if (system_state == SYSTEM_BOOTING)
825 dump_stack();
826 printk(KERN_ERR "bfin-gpio: GPIO %d is already reserved by %s !\n",
827 gpio, get_label(gpio));
828 hard_local_irq_restore(flags);
829 return -EBUSY;
830 }
831 if (unlikely(is_reserved(peri, gpio, 1))) {
832 if (system_state == SYSTEM_BOOTING)
833 dump_stack();
834 printk(KERN_ERR
835 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
836 gpio, get_label(gpio));
837 hard_local_irq_restore(flags);
838 return -EBUSY;
839 }
840 if (unlikely(is_reserved(gpio_irq, gpio, 1))) {
841 printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved as gpio-irq!"
842 " (Documentation/blackfin/bfin-gpio-notes.txt)\n", gpio);
843 } else { /* Reset POLAR setting when acquiring a gpio for the first time */
844 set_gpio_polar(gpio, 0);
845 }
846
847 reserve(gpio, gpio);
848 set_label(gpio, label);
849
850 hard_local_irq_restore(flags);
851
852 port_setup(gpio, GPIO_USAGE);
853
854 return 0;
855 }
856 EXPORT_SYMBOL(bfin_gpio_request);
857
858 void bfin_gpio_free(unsigned gpio)
859 {
860 unsigned long flags;
861
862 if (check_gpio(gpio) < 0)
863 return;
864
865 might_sleep();
866
867 flags = hard_local_irq_save();
868
869 if (unlikely(!is_reserved(gpio, gpio, 0))) {
870 if (system_state == SYSTEM_BOOTING)
871 dump_stack();
872 gpio_error(gpio);
873 hard_local_irq_restore(flags);
874 return;
875 }
876
877 unreserve(gpio, gpio);
878
879 set_label(gpio, "free");
880
881 hard_local_irq_restore(flags);
882 }
883 EXPORT_SYMBOL(bfin_gpio_free);
884
885 #ifdef BFIN_SPECIAL_GPIO_BANKS
886 DECLARE_RESERVED_MAP(special_gpio, gpio_bank(MAX_RESOURCES));
887
888 int bfin_special_gpio_request(unsigned gpio, const char *label)
889 {
890 unsigned long flags;
891
892 flags = hard_local_irq_save();
893
894 /*
895 * Allow that the identical GPIO can
896 * be requested from the same driver twice
897 * Do nothing and return -
898 */
899
900 if (cmp_label(gpio, label) == 0) {
901 hard_local_irq_restore(flags);
902 return 0;
903 }
904
905 if (unlikely(is_reserved(special_gpio, gpio, 1))) {
906 hard_local_irq_restore(flags);
907 printk(KERN_ERR "bfin-gpio: GPIO %d is already reserved by %s !\n",
908 gpio, get_label(gpio));
909
910 return -EBUSY;
911 }
912 if (unlikely(is_reserved(peri, gpio, 1))) {
913 hard_local_irq_restore(flags);
914 printk(KERN_ERR
915 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
916 gpio, get_label(gpio));
917
918 return -EBUSY;
919 }
920
921 reserve(special_gpio, gpio);
922 reserve(peri, gpio);
923
924 set_label(gpio, label);
925 hard_local_irq_restore(flags);
926 port_setup(gpio, GPIO_USAGE);
927
928 return 0;
929 }
930 EXPORT_SYMBOL(bfin_special_gpio_request);
931
932 void bfin_special_gpio_free(unsigned gpio)
933 {
934 unsigned long flags;
935
936 might_sleep();
937
938 flags = hard_local_irq_save();
939
940 if (unlikely(!is_reserved(special_gpio, gpio, 0))) {
941 gpio_error(gpio);
942 hard_local_irq_restore(flags);
943 return;
944 }
945
946 unreserve(special_gpio, gpio);
947 unreserve(peri, gpio);
948 set_label(gpio, "free");
949 hard_local_irq_restore(flags);
950 }
951 EXPORT_SYMBOL(bfin_special_gpio_free);
952 #endif
953
954
955 int bfin_gpio_irq_request(unsigned gpio, const char *label)
956 {
957 unsigned long flags;
958
959 if (check_gpio(gpio) < 0)
960 return -EINVAL;
961
962 flags = hard_local_irq_save();
963
964 if (unlikely(is_reserved(peri, gpio, 1))) {
965 if (system_state == SYSTEM_BOOTING)
966 dump_stack();
967 printk(KERN_ERR
968 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
969 gpio, get_label(gpio));
970 hard_local_irq_restore(flags);
971 return -EBUSY;
972 }
973 if (unlikely(is_reserved(gpio, gpio, 1)))
974 printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved by %s! "
975 "(Documentation/blackfin/bfin-gpio-notes.txt)\n",
976 gpio, get_label(gpio));
977
978 reserve(gpio_irq, gpio);
979 set_label(gpio, label);
980
981 hard_local_irq_restore(flags);
982
983 port_setup(gpio, GPIO_USAGE);
984
985 return 0;
986 }
987
988 void bfin_gpio_irq_free(unsigned gpio)
989 {
990 unsigned long flags;
991
992 if (check_gpio(gpio) < 0)
993 return;
994
995 flags = hard_local_irq_save();
996
997 if (unlikely(!is_reserved(gpio_irq, gpio, 0))) {
998 if (system_state == SYSTEM_BOOTING)
999 dump_stack();
1000 gpio_error(gpio);
1001 hard_local_irq_restore(flags);
1002 return;
1003 }
1004
1005 unreserve(gpio_irq, gpio);
1006
1007 set_label(gpio, "free");
1008
1009 hard_local_irq_restore(flags);
1010 }
1011
1012 static inline void __bfin_gpio_direction_input(unsigned gpio)
1013 {
1014 gpio_array[gpio_bank(gpio)]->dir &= ~gpio_bit(gpio);
1015 gpio_array[gpio_bank(gpio)]->inen |= gpio_bit(gpio);
1016 }
1017
1018 int bfin_gpio_direction_input(unsigned gpio)
1019 {
1020 unsigned long flags;
1021
1022 if (unlikely(!is_reserved(gpio, gpio, 0))) {
1023 gpio_error(gpio);
1024 return -EINVAL;
1025 }
1026
1027 flags = hard_local_irq_save();
1028 __bfin_gpio_direction_input(gpio);
1029 AWA_DUMMY_READ(inen);
1030 hard_local_irq_restore(flags);
1031
1032 return 0;
1033 }
1034 EXPORT_SYMBOL(bfin_gpio_direction_input);
1035
1036 void bfin_gpio_irq_prepare(unsigned gpio)
1037 {
1038 port_setup(gpio, GPIO_USAGE);
1039 }
1040
1041 void bfin_gpio_set_value(unsigned gpio, int arg)
1042 {
1043 if (arg)
1044 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
1045 else
1046 gpio_array[gpio_bank(gpio)]->data_clear = gpio_bit(gpio);
1047 }
1048 EXPORT_SYMBOL(bfin_gpio_set_value);
1049
1050 int bfin_gpio_direction_output(unsigned gpio, int value)
1051 {
1052 unsigned long flags;
1053
1054 if (unlikely(!is_reserved(gpio, gpio, 0))) {
1055 gpio_error(gpio);
1056 return -EINVAL;
1057 }
1058
1059 flags = hard_local_irq_save();
1060
1061 gpio_array[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio);
1062 gpio_set_value(gpio, value);
1063 gpio_array[gpio_bank(gpio)]->dir |= gpio_bit(gpio);
1064
1065 AWA_DUMMY_READ(dir);
1066 hard_local_irq_restore(flags);
1067
1068 return 0;
1069 }
1070 EXPORT_SYMBOL(bfin_gpio_direction_output);
1071
1072 int bfin_gpio_get_value(unsigned gpio)
1073 {
1074 unsigned long flags;
1075
1076 if (unlikely(get_gpio_edge(gpio))) {
1077 int ret;
1078 flags = hard_local_irq_save();
1079 set_gpio_edge(gpio, 0);
1080 ret = get_gpio_data(gpio);
1081 set_gpio_edge(gpio, 1);
1082 hard_local_irq_restore(flags);
1083 return ret;
1084 } else
1085 return get_gpio_data(gpio);
1086 }
1087 EXPORT_SYMBOL(bfin_gpio_get_value);
1088
1089 /* If we are booting from SPI and our board lacks a strong enough pull up,
1090 * the core can reset and execute the bootrom faster than the resistor can
1091 * pull the signal logically high. To work around this (common) error in
1092 * board design, we explicitly set the pin back to GPIO mode, force /CS
1093 * high, and wait for the electrons to do their thing.
1094 *
1095 * This function only makes sense to be called from reset code, but it
1096 * lives here as we need to force all the GPIO states w/out going through
1097 * BUG() checks and such.
1098 */
1099 void bfin_reset_boot_spi_cs(unsigned short pin)
1100 {
1101 unsigned short gpio = P_IDENT(pin);
1102 port_setup(gpio, GPIO_USAGE);
1103 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
1104 AWA_DUMMY_READ(data_set);
1105 udelay(1);
1106 }
1107
1108 #if defined(CONFIG_PROC_FS)
1109 static int gpio_proc_show(struct seq_file *m, void *v)
1110 {
1111 int c, irq, gpio;
1112
1113 for (c = 0; c < MAX_RESOURCES; c++) {
1114 irq = is_reserved(gpio_irq, c, 1);
1115 gpio = is_reserved(gpio, c, 1);
1116 if (!check_gpio(c) && (gpio || irq))
1117 seq_printf(m, "GPIO_%d: \t%s%s \t\tGPIO %s\n", c,
1118 get_label(c), (gpio && irq) ? " *" : "",
1119 get_gpio_dir(c) ? "OUTPUT" : "INPUT");
1120 else if (is_reserved(peri, c, 1))
1121 seq_printf(m, "GPIO_%d: \t%s \t\tPeripheral\n", c, get_label(c));
1122 else
1123 continue;
1124 }
1125
1126 return 0;
1127 }
1128
1129 static int gpio_proc_open(struct inode *inode, struct file *file)
1130 {
1131 return single_open(file, gpio_proc_show, NULL);
1132 }
1133
1134 static const struct file_operations gpio_proc_ops = {
1135 .open = gpio_proc_open,
1136 .read = seq_read,
1137 .llseek = seq_lseek,
1138 .release = single_release,
1139 };
1140
1141 static __init int gpio_register_proc(void)
1142 {
1143 struct proc_dir_entry *proc_gpio;
1144
1145 proc_gpio = proc_create("gpio", 0, NULL, &gpio_proc_ops);
1146 return proc_gpio == NULL;
1147 }
1148 __initcall(gpio_register_proc);
1149 #endif
1150
1151 #ifdef CONFIG_GPIOLIB
1152 static int bfin_gpiolib_direction_input(struct gpio_chip *chip, unsigned gpio)
1153 {
1154 return bfin_gpio_direction_input(gpio);
1155 }
1156
1157 static int bfin_gpiolib_direction_output(struct gpio_chip *chip, unsigned gpio, int level)
1158 {
1159 return bfin_gpio_direction_output(gpio, level);
1160 }
1161
1162 static int bfin_gpiolib_get_value(struct gpio_chip *chip, unsigned gpio)
1163 {
1164 return !!bfin_gpio_get_value(gpio);
1165 }
1166
1167 static void bfin_gpiolib_set_value(struct gpio_chip *chip, unsigned gpio, int value)
1168 {
1169 return bfin_gpio_set_value(gpio, value);
1170 }
1171
1172 static int bfin_gpiolib_gpio_request(struct gpio_chip *chip, unsigned gpio)
1173 {
1174 return bfin_gpio_request(gpio, chip->label);
1175 }
1176
1177 static void bfin_gpiolib_gpio_free(struct gpio_chip *chip, unsigned gpio)
1178 {
1179 return bfin_gpio_free(gpio);
1180 }
1181
1182 static int bfin_gpiolib_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
1183 {
1184 return gpio + GPIO_IRQ_BASE;
1185 }
1186
1187 static struct gpio_chip bfin_chip = {
1188 .label = "BFIN-GPIO",
1189 .direction_input = bfin_gpiolib_direction_input,
1190 .get = bfin_gpiolib_get_value,
1191 .direction_output = bfin_gpiolib_direction_output,
1192 .set = bfin_gpiolib_set_value,
1193 .request = bfin_gpiolib_gpio_request,
1194 .free = bfin_gpiolib_gpio_free,
1195 .to_irq = bfin_gpiolib_gpio_to_irq,
1196 .base = 0,
1197 .ngpio = MAX_BLACKFIN_GPIOS,
1198 };
1199
1200 static int __init bfin_gpiolib_setup(void)
1201 {
1202 return gpiochip_add_data(&bfin_chip, NULL);
1203 }
1204 arch_initcall(bfin_gpiolib_setup);
1205 #endif
Linux kernel - Deliverables
This page took 0.092849 seconds and 5 git commands to generate.