1
2
3
4
5
6
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
16#include <linux/gpio.h>
17#include <linux/irq.h>
18
19#if ANOMALY_05000311 || ANOMALY_05000323
20enum {
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
44#define AWA_DUMMY_READ(name) bfin_read16(AWA_ ## name)
45#else
46#define AWA_DUMMY_READ(...) do { } while (0)
47#endif
48
49static 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)
66static 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)
73static unsigned short * const port_mux[] = {
74 (unsigned short *) PORTF_MUX,
75 (unsigned short *) PORTG_MUX,
76 (unsigned short *) PORTH_MUX,
77};
78
79static const
80u8 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 },
83 { 0, 0, 0, 0, 0, 2, 2, 4, 4, 6, 8, 10, 10, 10, 12, 12 },
84 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 4, 4, 4, 4, 4 },
85# elif defined(CONFIG_BF51x)
86 { 0, 2, 2, 2, 2, 2, 2, 4, 6, 6, 6, 8, 8, 8, 8, 10 },
87 { 0, 0, 0, 2, 4, 6, 6, 6, 8, 10, 10, 12, 14, 14, 14, 14 },
88 { 0, 0, 0, 0, 2, 2, 4, 6, 10, 10, 10, 10, 10, 10, 10, 10 },
89# endif
90};
91# endif
92
93#elif defined(BF538_FAMILY)
94static 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
103static struct str_ident {
104 char name[RESOURCE_LABEL_SIZE];
105} str_ident[MAX_RESOURCES];
106
107#if defined(CONFIG_PM)
108static struct gpio_port_s gpio_bank_saved[GPIO_BANK_NUM];
109# ifdef BF538_FAMILY
110static unsigned short port_fer_saved[3];
111# endif
112#endif
113
114static void gpio_error(unsigned gpio)
115{
116 printk(KERN_ERR "bfin-gpio: GPIO %d wasn't requested!\n", gpio);
117}
118
119static 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
128static char *get_label(unsigned short ident)
129{
130 return (*str_ident[ident].name ? str_ident[ident].name : "UNKNOWN");
131}
132
133static 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
152DECLARE_RESERVED_MAP(gpio, GPIO_BANK_NUM);
153DECLARE_RESERVED_MAP(peri, DIV_ROUND_UP(MAX_RESOURCES, GPIO_BANKSIZE));
154DECLARE_RESERVED_MAP(gpio_irq, GPIO_BANK_NUM);
155
156inline int check_gpio(unsigned gpio)
157{
158 if (gpio >= MAX_BLACKFIN_GPIOS)
159 return -EINVAL;
160 return 0;
161}
162
163static void port_setup(unsigned gpio, unsigned short usage)
164{
165#if defined(BF538_FAMILY)
166
167
168
169
170
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
199static 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
227static 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
262static 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)
284static 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
313inline 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)
330static int portmux_group_check(unsigned short per)
331{
332 return 0;
333}
334#endif
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355#define SET_GPIO(name) \
356void 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} \
367EXPORT_SYMBOL(set_gpio_ ## name);
368
369SET_GPIO(dir)
370SET_GPIO(inen)
371SET_GPIO(polar)
372SET_GPIO(edge)
373SET_GPIO(both)
374
375
376#define SET_GPIO_SC(name) \
377void 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} \
391EXPORT_SYMBOL(set_gpio_ ## name);
392
393SET_GPIO_SC(maska)
394SET_GPIO_SC(maskb)
395SET_GPIO_SC(data)
396
397void 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}
408EXPORT_SYMBOL(set_gpio_toggle);
409
410
411
412
413#define SET_GPIO_P(name) \
414void 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} \
425EXPORT_SYMBOL(set_gpiop_ ## name);
426
427SET_GPIO_P(data)
428SET_GPIO_P(dir)
429SET_GPIO_P(inen)
430SET_GPIO_P(polar)
431SET_GPIO_P(edge)
432SET_GPIO_P(both)
433SET_GPIO_P(maska)
434SET_GPIO_P(maskb)
435
436
437#define GET_GPIO(name) \
438unsigned 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} \
451EXPORT_SYMBOL(get_gpio_ ## name);
452
453GET_GPIO(data)
454GET_GPIO(dir)
455GET_GPIO(inen)
456GET_GPIO(polar)
457GET_GPIO(edge)
458GET_GPIO(both)
459GET_GPIO(maska)
460GET_GPIO(maskb)
461
462
463
464#define GET_GPIO_P(name) \
465unsigned 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} \
478EXPORT_SYMBOL(get_gpiop_ ## name);
479
480GET_GPIO_P(data)
481GET_GPIO_P(dir)
482GET_GPIO_P(inen)
483GET_GPIO_P(polar)
484GET_GPIO_P(edge)
485GET_GPIO_P(both)
486GET_GPIO_P(maska)
487GET_GPIO_P(maskb)
488
489
490#ifdef CONFIG_PM
491DECLARE_RESERVED_MAP(wakeup, GPIO_BANK_NUM);
492
493static 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
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528int 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
547int 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
561void 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
598void 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
642
643
644
645
646
647
648
649
650
651
652
653
654
655int peripheral_request(unsigned short per, const char *label)
656{
657 unsigned long flags;
658 unsigned short ident = P_IDENT(per);
659
660
661
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
675
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
691
692
693
694 if (!(per & P_MAYSHARE)) {
695
696
697
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}
728EXPORT_SYMBOL(peripheral_request);
729
730int 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}
749EXPORT_SYMBOL(peripheral_request_list);
750
751void 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}
778EXPORT_SYMBOL(peripheral_free);
779
780void 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}
786EXPORT_SYMBOL(peripheral_free_list);
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803int 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
814
815
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 {
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}
856EXPORT_SYMBOL(bfin_gpio_request);
857
858void 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}
883EXPORT_SYMBOL(bfin_gpio_free);
884
885#ifdef BFIN_SPECIAL_GPIO_BANKS
886DECLARE_RESERVED_MAP(special_gpio, gpio_bank(MAX_RESOURCES));
887
888int bfin_special_gpio_request(unsigned gpio, const char *label)
889{
890 unsigned long flags;
891
892 flags = hard_local_irq_save();
893
894
895
896
897
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}
930EXPORT_SYMBOL(bfin_special_gpio_request);
931
932void 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}
951EXPORT_SYMBOL(bfin_special_gpio_free);
952#endif
953
954
955int 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
988void 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
1012static 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
1018int 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}
1034EXPORT_SYMBOL(bfin_gpio_direction_input);
1035
1036void bfin_gpio_irq_prepare(unsigned gpio)
1037{
1038 port_setup(gpio, GPIO_USAGE);
1039}
1040
1041void 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}
1048EXPORT_SYMBOL(bfin_gpio_set_value);
1049
1050int 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}
1070EXPORT_SYMBOL(bfin_gpio_direction_output);
1071
1072int 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}
1087EXPORT_SYMBOL(bfin_gpio_get_value);
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099void 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)
1109static 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
1129static int gpio_proc_open(struct inode *inode, struct file *file)
1130{
1131 return single_open(file, gpio_proc_show, NULL);
1132}
1133
1134static 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
1141static __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
1152static int bfin_gpiolib_direction_input(struct gpio_chip *chip, unsigned gpio)
1153{
1154 return bfin_gpio_direction_input(gpio);
1155}
1156
1157static int bfin_gpiolib_direction_output(struct gpio_chip *chip, unsigned gpio, int level)
1158{
1159 return bfin_gpio_direction_output(gpio, level);
1160}
1161
1162static int bfin_gpiolib_get_value(struct gpio_chip *chip, unsigned gpio)
1163{
1164 return !!bfin_gpio_get_value(gpio);
1165}
1166
1167static void bfin_gpiolib_set_value(struct gpio_chip *chip, unsigned gpio, int value)
1168{
1169 return bfin_gpio_set_value(gpio, value);
1170}
1171
1172static int bfin_gpiolib_gpio_request(struct gpio_chip *chip, unsigned gpio)
1173{
1174 return bfin_gpio_request(gpio, chip->label);
1175}
1176
1177static void bfin_gpiolib_gpio_free(struct gpio_chip *chip, unsigned gpio)
1178{
1179 return bfin_gpio_free(gpio);
1180}
1181
1182static int bfin_gpiolib_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
1183{
1184 return gpio + GPIO_IRQ_BASE;
1185}
1186
1187static 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
1200static int __init bfin_gpiolib_setup(void)
1201{
1202 return gpiochip_add_data(&bfin_chip, NULL);
1203}
1204arch_initcall(bfin_gpiolib_setup);
1205#endif
1206
