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

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

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ 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.77 ] ~ [ 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 <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
1206 

~ [ 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