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