~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/blackfin/kernel/bfin_gpio.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 {
118         char name[RESOURCE_LABEL_SIZE];
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,
137                          RESOURCE_LABEL_SIZE);
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 
166 DECLARE_RESERVED_MAP(gpio, GPIO_BANK_NUM);
167 DECLARE_RESERVED_MAP(peri, DIV_ROUND_UP(MAX_RESOURCES, GPIO_BANKSIZE));
168 DECLARE_RESERVED_MAP(gpio_irq, GPIO_BANK_NUM);
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 
193         if (gpio < MAX_BLACKFIN_GPIOS || gpio >= MAX_RESOURCES)
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;
447         if (ANOMALY_05000311 || ANOMALY_05000323)
448                 flags = hard_local_irq_save();
449         gpio_array[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
450         if (ANOMALY_05000311 || ANOMALY_05000323) {
451                 AWA_DUMMY_READ(toggle);
452                 hard_local_irq_restore(flags);
453         }
454 }
455 EXPORT_SYMBOL(set_gpio_toggle);
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 
474 SET_GPIO_P(data)
475 SET_GPIO_P(dir)
476 SET_GPIO_P(inen)
477 SET_GPIO_P(polar)
478 SET_GPIO_P(edge)
479 SET_GPIO_P(both)
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 
527 GET_GPIO_P(data)
528 GET_GPIO_P(dir)
529 GET_GPIO_P(inen)
530 GET_GPIO_P(polar)
531 GET_GPIO_P(edge)
532 GET_GPIO_P(both)
533 GET_GPIO_P(maska)
534 GET_GPIO_P(maskb)
535 
536 
537 #ifdef CONFIG_PM
538 DECLARE_RESERVED_MAP(wakeup, GPIO_BANK_NUM);
539 
540 static const unsigned int sic_iwr_irqs[] = {
541 #if defined(BF533_FAMILY)
542         IRQ_PROG_INTB
543 #elif defined(BF537_FAMILY)
544         IRQ_PF_INTB_WATCH, IRQ_PORTG_INTB, IRQ_PH_INTB_MAC_TX
545 #elif defined(BF538_FAMILY)
546         IRQ_PORTF_INTB
547 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
548         IRQ_PORTF_INTB, IRQ_PORTG_INTB, IRQ_PORTH_INTB
549 #elif defined(BF561_FAMILY)
550         IRQ_PROG0_INTB, IRQ_PROG1_INTB, IRQ_PROG2_INTB
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 }
729 EXPORT_SYMBOL(get_gpio_dir);
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))) {
772                 if (system_state == SYSTEM_BOOTING)
773                         dump_stack();
774                 printk(KERN_ERR
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 
801                         if (system_state == SYSTEM_BOOTING)
802                                 dump_stack();
803                         printk(KERN_ERR
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 }
826 EXPORT_SYMBOL(peripheral_request);
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 }
847 EXPORT_SYMBOL(peripheral_request_list);
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 }
876 EXPORT_SYMBOL(peripheral_free);
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 }
884 EXPORT_SYMBOL(peripheral_free_list);
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))) {
922                 if (system_state == SYSTEM_BOOTING)
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))) {
930                 if (system_state == SYSTEM_BOOTING)
931                         dump_stack();
932                 printk(KERN_ERR
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 }
957 EXPORT_SYMBOL(bfin_gpio_request);
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))) {
971                 if (system_state == SYSTEM_BOOTING)
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 }
984 EXPORT_SYMBOL(bfin_gpio_free);
985 
986 #ifdef BFIN_SPECIAL_GPIO_BANKS
987 DECLARE_RESERVED_MAP(special_gpio, gpio_bank(MAX_RESOURCES));
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);
1015                 printk(KERN_ERR
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))) {
1066                 if (system_state == SYSTEM_BOOTING)
1067                         dump_stack();
1068                 printk(KERN_ERR
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))) {
1099                 if (system_state == SYSTEM_BOOTING)
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);
1134         AWA_DUMMY_READ(inen);
1135         hard_local_irq_restore(flags);
1136 
1137         return 0;
1138 }
1139 EXPORT_SYMBOL(bfin_gpio_direction_input);
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 }
1163 EXPORT_SYMBOL(bfin_gpio_set_value);
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 
1184         AWA_DUMMY_READ(dir);
1185         hard_local_irq_restore(flags);
1186 
1187         return 0;
1188 }
1189 EXPORT_SYMBOL(bfin_gpio_direction_output);
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 }
1210 EXPORT_SYMBOL(bfin_gpio_get_value);
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
1329 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp