Merge branch 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6
[linux-2.6] / arch / blackfin / kernel / bfin_gpio.c
1 /*
2  * File:         arch/blackfin/kernel/bfin_gpio.c
3  * Based on:
4  * Author:       Michael Hennerich (hennerich@blackfin.uclinux.org)
5  *
6  * Created:
7  * Description:  GPIO Abstraction Layer
8  *
9  * Modified:
10  *               Copyright 2007 Analog Devices Inc.
11  *
12  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, see the file COPYING, or write
26  * to the Free Software Foundation, Inc.,
27  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
28  */
29
30 /*
31 *  Number     BF537/6/4    BF561    BF533/2/1      BF549/8/4/2
32 *
33 *  GPIO_0       PF0         PF0        PF0         PA0...PJ13
34 *  GPIO_1       PF1         PF1        PF1
35 *  GPIO_2       PF2         PF2        PF2
36 *  GPIO_3       PF3         PF3        PF3
37 *  GPIO_4       PF4         PF4        PF4
38 *  GPIO_5       PF5         PF5        PF5
39 *  GPIO_6       PF6         PF6        PF6
40 *  GPIO_7       PF7         PF7        PF7
41 *  GPIO_8       PF8         PF8        PF8
42 *  GPIO_9       PF9         PF9        PF9
43 *  GPIO_10      PF10        PF10       PF10
44 *  GPIO_11      PF11        PF11       PF11
45 *  GPIO_12      PF12        PF12       PF12
46 *  GPIO_13      PF13        PF13       PF13
47 *  GPIO_14      PF14        PF14       PF14
48 *  GPIO_15      PF15        PF15       PF15
49 *  GPIO_16      PG0         PF16
50 *  GPIO_17      PG1         PF17
51 *  GPIO_18      PG2         PF18
52 *  GPIO_19      PG3         PF19
53 *  GPIO_20      PG4         PF20
54 *  GPIO_21      PG5         PF21
55 *  GPIO_22      PG6         PF22
56 *  GPIO_23      PG7         PF23
57 *  GPIO_24      PG8         PF24
58 *  GPIO_25      PG9         PF25
59 *  GPIO_26      PG10        PF26
60 *  GPIO_27      PG11        PF27
61 *  GPIO_28      PG12        PF28
62 *  GPIO_29      PG13        PF29
63 *  GPIO_30      PG14        PF30
64 *  GPIO_31      PG15        PF31
65 *  GPIO_32      PH0         PF32
66 *  GPIO_33      PH1         PF33
67 *  GPIO_34      PH2         PF34
68 *  GPIO_35      PH3         PF35
69 *  GPIO_36      PH4         PF36
70 *  GPIO_37      PH5         PF37
71 *  GPIO_38      PH6         PF38
72 *  GPIO_39      PH7         PF39
73 *  GPIO_40      PH8         PF40
74 *  GPIO_41      PH9         PF41
75 *  GPIO_42      PH10        PF42
76 *  GPIO_43      PH11        PF43
77 *  GPIO_44      PH12        PF44
78 *  GPIO_45      PH13        PF45
79 *  GPIO_46      PH14        PF46
80 *  GPIO_47      PH15        PF47
81 */
82
83 #include <linux/delay.h>
84 #include <linux/module.h>
85 #include <linux/err.h>
86 #include <asm/blackfin.h>
87 #include <asm/gpio.h>
88 #include <asm/portmux.h>
89 #include <linux/irq.h>
90
91 #if ANOMALY_05000311 || ANOMALY_05000323
92 enum {
93         AWA_data = SYSCR,
94         AWA_data_clear = SYSCR,
95         AWA_data_set = SYSCR,
96         AWA_toggle = SYSCR,
97         AWA_maska = UART_SCR,
98         AWA_maska_clear = UART_SCR,
99         AWA_maska_set = UART_SCR,
100         AWA_maska_toggle = UART_SCR,
101         AWA_maskb = UART_GCTL,
102         AWA_maskb_clear = UART_GCTL,
103         AWA_maskb_set = UART_GCTL,
104         AWA_maskb_toggle = UART_GCTL,
105         AWA_dir = SPORT1_STAT,
106         AWA_polar = SPORT1_STAT,
107         AWA_edge = SPORT1_STAT,
108         AWA_both = SPORT1_STAT,
109 #if ANOMALY_05000311
110         AWA_inen = TIMER_ENABLE,
111 #elif ANOMALY_05000323
112         AWA_inen = DMA1_1_CONFIG,
113 #endif
114 };
115         /* Anomaly Workaround */
116 #define AWA_DUMMY_READ(name) bfin_read16(AWA_ ## name)
117 #else
118 #define AWA_DUMMY_READ(...)  do { } while (0)
119 #endif
120
121 #ifdef BF533_FAMILY
122 static struct gpio_port_t *gpio_bankb[gpio_bank(MAX_BLACKFIN_GPIOS)] = {
123         (struct gpio_port_t *) FIO_FLAG_D,
124 };
125 #endif
126
127 #if defined(BF527_FAMILY) || defined(BF537_FAMILY)
128 static struct gpio_port_t *gpio_bankb[gpio_bank(MAX_BLACKFIN_GPIOS)] = {
129         (struct gpio_port_t *) PORTFIO,
130         (struct gpio_port_t *) PORTGIO,
131         (struct gpio_port_t *) PORTHIO,
132 };
133
134 static unsigned short *port_fer[gpio_bank(MAX_BLACKFIN_GPIOS)] = {
135         (unsigned short *) PORTF_FER,
136         (unsigned short *) PORTG_FER,
137         (unsigned short *) PORTH_FER,
138 };
139
140 #endif
141
142 #ifdef BF527_FAMILY
143 static unsigned short *port_mux[gpio_bank(MAX_BLACKFIN_GPIOS)] = {
144         (unsigned short *) PORTF_MUX,
145         (unsigned short *) PORTG_MUX,
146         (unsigned short *) PORTH_MUX,
147 };
148
149 static const
150 u8 pmux_offset[][16] =
151         {{ 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 4, 6, 8, 8, 10, 10 }, /* PORTF */
152          { 0, 0, 0, 0, 0, 2, 2, 4, 4, 6, 8, 10, 10, 10, 12, 12 }, /* PORTG */
153          { 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 4, 4, 4, 4, 4 }, /* PORTH */
154         };
155 #endif
156
157 #ifdef BF561_FAMILY
158 static struct gpio_port_t *gpio_bankb[gpio_bank(MAX_BLACKFIN_GPIOS)] = {
159         (struct gpio_port_t *) FIO0_FLAG_D,
160         (struct gpio_port_t *) FIO1_FLAG_D,
161         (struct gpio_port_t *) FIO2_FLAG_D,
162 };
163 #endif
164
165 #ifdef BF548_FAMILY
166 static struct gpio_port_t *gpio_array[gpio_bank(MAX_BLACKFIN_GPIOS)] = {
167         (struct gpio_port_t *)PORTA_FER,
168         (struct gpio_port_t *)PORTB_FER,
169         (struct gpio_port_t *)PORTC_FER,
170         (struct gpio_port_t *)PORTD_FER,
171         (struct gpio_port_t *)PORTE_FER,
172         (struct gpio_port_t *)PORTF_FER,
173         (struct gpio_port_t *)PORTG_FER,
174         (struct gpio_port_t *)PORTH_FER,
175         (struct gpio_port_t *)PORTI_FER,
176         (struct gpio_port_t *)PORTJ_FER,
177 };
178 #endif
179
180 static unsigned short reserved_gpio_map[gpio_bank(MAX_BLACKFIN_GPIOS)];
181 static unsigned short reserved_peri_map[gpio_bank(MAX_BLACKFIN_GPIOS + 16)];
182
183 #define MAX_RESOURCES           256
184 #define RESOURCE_LABEL_SIZE     16
185
186 struct str_ident {
187         char name[RESOURCE_LABEL_SIZE];
188 } *str_ident;
189
190
191 #ifdef CONFIG_PM
192 static unsigned short wakeup_map[gpio_bank(MAX_BLACKFIN_GPIOS)];
193 static unsigned char wakeup_flags_map[MAX_BLACKFIN_GPIOS];
194 static struct gpio_port_s gpio_bank_saved[gpio_bank(MAX_BLACKFIN_GPIOS)];
195
196 #ifdef BF533_FAMILY
197 static unsigned int sic_iwr_irqs[gpio_bank(MAX_BLACKFIN_GPIOS)] = {IRQ_PROG_INTB};
198 #endif
199
200 #ifdef BF537_FAMILY
201 static unsigned int sic_iwr_irqs[gpio_bank(MAX_BLACKFIN_GPIOS)] = {IRQ_PROG_INTB, IRQ_PORTG_INTB, IRQ_MAC_TX};
202 #endif
203
204 #ifdef BF527_FAMILY
205 static unsigned int sic_iwr_irqs[gpio_bank(MAX_BLACKFIN_GPIOS)] = {IRQ_PORTF_INTB, IRQ_PORTG_INTB, IRQ_PORTH_INTB};
206 #endif
207
208 #ifdef BF561_FAMILY
209 static unsigned int sic_iwr_irqs[gpio_bank(MAX_BLACKFIN_GPIOS)] = {IRQ_PROG0_INTB, IRQ_PROG1_INTB, IRQ_PROG2_INTB};
210 #endif
211
212 #endif /* CONFIG_PM */
213
214 #if defined(BF548_FAMILY)
215 inline int check_gpio(unsigned short gpio)
216 {
217         if (gpio == GPIO_PB15 || gpio == GPIO_PC14 || gpio == GPIO_PC15
218             || gpio == GPIO_PH14 || gpio == GPIO_PH15
219             || gpio == GPIO_PJ14 || gpio == GPIO_PJ15
220             || gpio > MAX_BLACKFIN_GPIOS)
221                 return -EINVAL;
222         return 0;
223 }
224 #else
225 inline int check_gpio(unsigned short gpio)
226 {
227         if (gpio >= MAX_BLACKFIN_GPIOS)
228                 return -EINVAL;
229         return 0;
230 }
231 #endif
232
233 static void set_label(unsigned short ident, const char *label)
234 {
235
236         if (label && str_ident) {
237                 strncpy(str_ident[ident].name, label,
238                          RESOURCE_LABEL_SIZE);
239                 str_ident[ident].name[RESOURCE_LABEL_SIZE - 1] = 0;
240         }
241 }
242
243 static char *get_label(unsigned short ident)
244 {
245         if (!str_ident)
246                 return "UNKNOWN";
247
248         return (*str_ident[ident].name ? str_ident[ident].name : "UNKNOWN");
249 }
250
251 static int cmp_label(unsigned short ident, const char *label)
252 {
253         if (label && str_ident)
254                 return strncmp(str_ident[ident].name,
255                                  label, strlen(label));
256         else
257                 return -EINVAL;
258 }
259
260 #if defined(BF527_FAMILY) || defined(BF537_FAMILY)
261 static void port_setup(unsigned short gpio, unsigned short usage)
262 {
263         if (!check_gpio(gpio)) {
264                 if (usage == GPIO_USAGE)
265                         *port_fer[gpio_bank(gpio)] &= ~gpio_bit(gpio);
266                 else
267                         *port_fer[gpio_bank(gpio)] |= gpio_bit(gpio);
268                 SSYNC();
269         }
270 }
271 #elif defined(BF548_FAMILY)
272 static void port_setup(unsigned short gpio, unsigned short usage)
273 {
274         if (usage == GPIO_USAGE)
275                 gpio_array[gpio_bank(gpio)]->port_fer &= ~gpio_bit(gpio);
276         else
277                 gpio_array[gpio_bank(gpio)]->port_fer |= gpio_bit(gpio);
278         SSYNC();
279 }
280 #else
281 # define port_setup(...)  do { } while (0)
282 #endif
283
284 #ifdef BF537_FAMILY
285 static struct {
286         unsigned short res;
287         unsigned short offset;
288 } port_mux_lut[] = {
289         {.res = P_PPI0_D13, .offset = 11},
290         {.res = P_PPI0_D14, .offset = 11},
291         {.res = P_PPI0_D15, .offset = 11},
292         {.res = P_SPORT1_TFS, .offset = 11},
293         {.res = P_SPORT1_TSCLK, .offset = 11},
294         {.res = P_SPORT1_DTPRI, .offset = 11},
295         {.res = P_PPI0_D10, .offset = 10},
296         {.res = P_PPI0_D11, .offset = 10},
297         {.res = P_PPI0_D12, .offset = 10},
298         {.res = P_SPORT1_RSCLK, .offset = 10},
299         {.res = P_SPORT1_RFS, .offset = 10},
300         {.res = P_SPORT1_DRPRI, .offset = 10},
301         {.res = P_PPI0_D8, .offset = 9},
302         {.res = P_PPI0_D9, .offset = 9},
303         {.res = P_SPORT1_DRSEC, .offset = 9},
304         {.res = P_SPORT1_DTSEC, .offset = 9},
305         {.res = P_TMR2, .offset = 8},
306         {.res = P_PPI0_FS3, .offset = 8},
307         {.res = P_TMR3, .offset = 7},
308         {.res = P_SPI0_SSEL4, .offset = 7},
309         {.res = P_TMR4, .offset = 6},
310         {.res = P_SPI0_SSEL5, .offset = 6},
311         {.res = P_TMR5, .offset = 5},
312         {.res = P_SPI0_SSEL6, .offset = 5},
313         {.res = P_UART1_RX, .offset = 4},
314         {.res = P_UART1_TX, .offset = 4},
315         {.res = P_TMR6, .offset = 4},
316         {.res = P_TMR7, .offset = 4},
317         {.res = P_UART0_RX, .offset = 3},
318         {.res = P_UART0_TX, .offset = 3},
319         {.res = P_DMAR0, .offset = 3},
320         {.res = P_DMAR1, .offset = 3},
321         {.res = P_SPORT0_DTSEC, .offset = 1},
322         {.res = P_SPORT0_DRSEC, .offset = 1},
323         {.res = P_CAN0_RX, .offset = 1},
324         {.res = P_CAN0_TX, .offset = 1},
325         {.res = P_SPI0_SSEL7, .offset = 1},
326         {.res = P_SPORT0_TFS, .offset = 0},
327         {.res = P_SPORT0_DTPRI, .offset = 0},
328         {.res = P_SPI0_SSEL2, .offset = 0},
329         {.res = P_SPI0_SSEL3, .offset = 0},
330 };
331
332 static void portmux_setup(unsigned short per, unsigned short function)
333 {
334         u16 y, offset, muxreg;
335
336         for (y = 0; y < ARRAY_SIZE(port_mux_lut); y++) {
337                 if (port_mux_lut[y].res == per) {
338
339                         /* SET PORTMUX REG */
340
341                         offset = port_mux_lut[y].offset;
342                         muxreg = bfin_read_PORT_MUX();
343
344                         if (offset != 1) {
345                                 muxreg &= ~(1 << offset);
346                         } else {
347                                 muxreg &= ~(3 << 1);
348                         }
349
350                         muxreg |= (function << offset);
351                         bfin_write_PORT_MUX(muxreg);
352                 }
353         }
354 }
355 #elif defined(BF548_FAMILY)
356 inline void portmux_setup(unsigned short portno, unsigned short function)
357 {
358         u32 pmux;
359
360         pmux = gpio_array[gpio_bank(portno)]->port_mux;
361
362         pmux &= ~(0x3 << (2 * gpio_sub_n(portno)));
363         pmux |= (function & 0x3) << (2 * gpio_sub_n(portno));
364
365         gpio_array[gpio_bank(portno)]->port_mux = pmux;
366 }
367
368 inline u16 get_portmux(unsigned short portno)
369 {
370         u32 pmux;
371
372         pmux = gpio_array[gpio_bank(portno)]->port_mux;
373
374         return (pmux >> (2 * gpio_sub_n(portno)) & 0x3);
375 }
376 #elif defined(BF527_FAMILY)
377 inline void portmux_setup(unsigned short portno, unsigned short function)
378 {
379         u16 pmux, ident = P_IDENT(portno);
380         u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
381
382         pmux = *port_mux[gpio_bank(ident)];
383         pmux &= ~(3 << offset);
384         pmux |= (function & 3) << offset;
385         *port_mux[gpio_bank(ident)] = pmux;
386         SSYNC();
387 }
388 #else
389 # define portmux_setup(...)  do { } while (0)
390 #endif
391
392 #ifndef BF548_FAMILY
393 static void default_gpio(unsigned short gpio)
394 {
395         unsigned short bank, bitmask;
396         unsigned long flags;
397
398         bank = gpio_bank(gpio);
399         bitmask = gpio_bit(gpio);
400
401         local_irq_save(flags);
402
403         gpio_bankb[bank]->maska_clear = bitmask;
404         gpio_bankb[bank]->maskb_clear = bitmask;
405         SSYNC();
406         gpio_bankb[bank]->inen &= ~bitmask;
407         gpio_bankb[bank]->dir &= ~bitmask;
408         gpio_bankb[bank]->polar &= ~bitmask;
409         gpio_bankb[bank]->both &= ~bitmask;
410         gpio_bankb[bank]->edge &= ~bitmask;
411         AWA_DUMMY_READ(edge);
412         local_irq_restore(flags);
413
414 }
415 #else
416 # define default_gpio(...)  do { } while (0)
417 #endif
418
419 static int __init bfin_gpio_init(void)
420 {
421         str_ident = kcalloc(MAX_RESOURCES,
422                                  sizeof(struct str_ident), GFP_KERNEL);
423         if (str_ident == NULL)
424                 return -ENOMEM;
425
426         memset(str_ident, 0, MAX_RESOURCES * sizeof(struct str_ident));
427
428         printk(KERN_INFO "Blackfin GPIO Controller\n");
429
430         return 0;
431
432 }
433 arch_initcall(bfin_gpio_init);
434
435
436 #ifndef BF548_FAMILY
437 /***********************************************************
438 *
439 * FUNCTIONS: Blackfin General Purpose Ports Access Functions
440 *
441 * INPUTS/OUTPUTS:
442 * gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
443 *
444 *
445 * DESCRIPTION: These functions abstract direct register access
446 *              to Blackfin processor General Purpose
447 *              Ports Regsiters
448 *
449 * CAUTION: These functions do not belong to the GPIO Driver API
450 *************************************************************
451 * MODIFICATION HISTORY :
452 **************************************************************/
453
454 /* Set a specific bit */
455
456 #define SET_GPIO(name) \
457 void set_gpio_ ## name(unsigned short gpio, unsigned short arg) \
458 { \
459         unsigned long flags; \
460         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))); \
461         local_irq_save(flags); \
462         if (arg) \
463                 gpio_bankb[gpio_bank(gpio)]->name |= gpio_bit(gpio); \
464         else \
465                 gpio_bankb[gpio_bank(gpio)]->name &= ~gpio_bit(gpio); \
466         AWA_DUMMY_READ(name); \
467         local_irq_restore(flags); \
468 } \
469 EXPORT_SYMBOL(set_gpio_ ## name);
470
471 SET_GPIO(dir)
472 SET_GPIO(inen)
473 SET_GPIO(polar)
474 SET_GPIO(edge)
475 SET_GPIO(both)
476
477
478 #if ANOMALY_05000311 || ANOMALY_05000323
479 #define SET_GPIO_SC(name) \
480 void set_gpio_ ## name(unsigned short gpio, unsigned short arg) \
481 { \
482         unsigned long flags; \
483         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))); \
484         local_irq_save(flags); \
485         if (arg) \
486                 gpio_bankb[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
487         else \
488                 gpio_bankb[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
489         AWA_DUMMY_READ(name); \
490         local_irq_restore(flags); \
491 } \
492 EXPORT_SYMBOL(set_gpio_ ## name);
493 #else
494 #define SET_GPIO_SC(name) \
495 void set_gpio_ ## name(unsigned short gpio, unsigned short arg) \
496 { \
497         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))); \
498         if (arg) \
499                 gpio_bankb[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
500         else \
501                 gpio_bankb[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
502 } \
503 EXPORT_SYMBOL(set_gpio_ ## name);
504 #endif
505
506 SET_GPIO_SC(maska)
507 SET_GPIO_SC(maskb)
508 SET_GPIO_SC(data)
509
510 #if ANOMALY_05000311 || ANOMALY_05000323
511 void set_gpio_toggle(unsigned short gpio)
512 {
513         unsigned long flags;
514         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)));
515         local_irq_save(flags);
516         gpio_bankb[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
517         AWA_DUMMY_READ(toggle);
518         local_irq_restore(flags);
519 }
520 #else
521 void set_gpio_toggle(unsigned short gpio)
522 {
523         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)));
524         gpio_bankb[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
525 }
526 #endif
527 EXPORT_SYMBOL(set_gpio_toggle);
528
529
530 /*Set current PORT date (16-bit word)*/
531
532 #if ANOMALY_05000311 || ANOMALY_05000323
533 #define SET_GPIO_P(name) \
534 void set_gpiop_ ## name(unsigned short gpio, unsigned short arg) \
535 { \
536         unsigned long flags; \
537         local_irq_save(flags); \
538         gpio_bankb[gpio_bank(gpio)]->name = arg; \
539         AWA_DUMMY_READ(name); \
540         local_irq_restore(flags); \
541 } \
542 EXPORT_SYMBOL(set_gpiop_ ## name);
543 #else
544 #define SET_GPIO_P(name) \
545 void set_gpiop_ ## name(unsigned short gpio, unsigned short arg) \
546 { \
547         gpio_bankb[gpio_bank(gpio)]->name = arg; \
548 } \
549 EXPORT_SYMBOL(set_gpiop_ ## name);
550 #endif
551
552 SET_GPIO_P(data)
553 SET_GPIO_P(dir)
554 SET_GPIO_P(inen)
555 SET_GPIO_P(polar)
556 SET_GPIO_P(edge)
557 SET_GPIO_P(both)
558 SET_GPIO_P(maska)
559 SET_GPIO_P(maskb)
560
561
562 /* Get a specific bit */
563 #if ANOMALY_05000311 || ANOMALY_05000323
564 #define GET_GPIO(name) \
565 unsigned short get_gpio_ ## name(unsigned short gpio) \
566 { \
567         unsigned long flags; \
568         unsigned short ret; \
569         local_irq_save(flags); \
570         ret = 0x01 & (gpio_bankb[gpio_bank(gpio)]->name >> gpio_sub_n(gpio)); \
571         AWA_DUMMY_READ(name); \
572         local_irq_restore(flags); \
573         return ret; \
574 } \
575 EXPORT_SYMBOL(get_gpio_ ## name);
576 #else
577 #define GET_GPIO(name) \
578 unsigned short get_gpio_ ## name(unsigned short gpio) \
579 { \
580         return (0x01 & (gpio_bankb[gpio_bank(gpio)]->name >> gpio_sub_n(gpio))); \
581 } \
582 EXPORT_SYMBOL(get_gpio_ ## name);
583 #endif
584
585 GET_GPIO(data)
586 GET_GPIO(dir)
587 GET_GPIO(inen)
588 GET_GPIO(polar)
589 GET_GPIO(edge)
590 GET_GPIO(both)
591 GET_GPIO(maska)
592 GET_GPIO(maskb)
593
594 /*Get current PORT date (16-bit word)*/
595
596 #if ANOMALY_05000311 || ANOMALY_05000323
597 #define GET_GPIO_P(name) \
598 unsigned short get_gpiop_ ## name(unsigned short gpio) \
599 { \
600         unsigned long flags; \
601         unsigned short ret; \
602         local_irq_save(flags); \
603         ret = (gpio_bankb[gpio_bank(gpio)]->name); \
604         AWA_DUMMY_READ(name); \
605         local_irq_restore(flags); \
606         return ret; \
607 } \
608 EXPORT_SYMBOL(get_gpiop_ ## name);
609 #else
610 #define GET_GPIO_P(name) \
611 unsigned short get_gpiop_ ## name(unsigned short gpio) \
612 { \
613         return (gpio_bankb[gpio_bank(gpio)]->name);\
614 } \
615 EXPORT_SYMBOL(get_gpiop_ ## name);
616 #endif
617
618 GET_GPIO_P(data)
619 GET_GPIO_P(dir)
620 GET_GPIO_P(inen)
621 GET_GPIO_P(polar)
622 GET_GPIO_P(edge)
623 GET_GPIO_P(both)
624 GET_GPIO_P(maska)
625 GET_GPIO_P(maskb)
626
627
628 #ifdef CONFIG_PM
629 /***********************************************************
630 *
631 * FUNCTIONS: Blackfin PM Setup API
632 *
633 * INPUTS/OUTPUTS:
634 * gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
635 * type -
636 *       PM_WAKE_RISING
637 *       PM_WAKE_FALLING
638 *       PM_WAKE_HIGH
639 *       PM_WAKE_LOW
640 *       PM_WAKE_BOTH_EDGES
641 *
642 * DESCRIPTION: Blackfin PM Driver API
643 *
644 * CAUTION:
645 *************************************************************
646 * MODIFICATION HISTORY :
647 **************************************************************/
648 int gpio_pm_wakeup_request(unsigned short gpio, unsigned char type)
649 {
650         unsigned long flags;
651
652         if ((check_gpio(gpio) < 0) || !type)
653                 return -EINVAL;
654
655         local_irq_save(flags);
656
657         wakeup_map[gpio_bank(gpio)] |= gpio_bit(gpio);
658         wakeup_flags_map[gpio] = type;
659         local_irq_restore(flags);
660
661         return 0;
662 }
663 EXPORT_SYMBOL(gpio_pm_wakeup_request);
664
665 void gpio_pm_wakeup_free(unsigned short gpio)
666 {
667         unsigned long flags;
668
669         if (check_gpio(gpio) < 0)
670                 return;
671
672         local_irq_save(flags);
673
674         wakeup_map[gpio_bank(gpio)] &= ~gpio_bit(gpio);
675
676         local_irq_restore(flags);
677 }
678 EXPORT_SYMBOL(gpio_pm_wakeup_free);
679
680 static int bfin_gpio_wakeup_type(unsigned short gpio, unsigned char type)
681 {
682         port_setup(gpio, GPIO_USAGE);
683         set_gpio_dir(gpio, 0);
684         set_gpio_inen(gpio, 1);
685
686         if (type & (PM_WAKE_RISING | PM_WAKE_FALLING))
687                 set_gpio_edge(gpio, 1);
688          else
689                 set_gpio_edge(gpio, 0);
690
691         if ((type & (PM_WAKE_BOTH_EDGES)) == (PM_WAKE_BOTH_EDGES))
692                 set_gpio_both(gpio, 1);
693         else
694                 set_gpio_both(gpio, 0);
695
696         if ((type & (PM_WAKE_FALLING | PM_WAKE_LOW)))
697                 set_gpio_polar(gpio, 1);
698         else
699                 set_gpio_polar(gpio, 0);
700
701         SSYNC();
702
703         return 0;
704 }
705
706 u32 gpio_pm_setup(void)
707 {
708         u32 sic_iwr = 0;
709         u16 bank, mask, i, gpio;
710
711         for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
712                 mask = wakeup_map[gpio_bank(i)];
713                 bank = gpio_bank(i);
714
715                 gpio_bank_saved[bank].maskb = gpio_bankb[bank]->maskb;
716                 gpio_bankb[bank]->maskb = 0;
717
718                 if (mask) {
719 #ifdef BF537_FAMILY
720                         gpio_bank_saved[bank].fer   = *port_fer[bank];
721 #endif
722                         gpio_bank_saved[bank].inen  = gpio_bankb[bank]->inen;
723                         gpio_bank_saved[bank].polar = gpio_bankb[bank]->polar;
724                         gpio_bank_saved[bank].dir   = gpio_bankb[bank]->dir;
725                         gpio_bank_saved[bank].edge  = gpio_bankb[bank]->edge;
726                         gpio_bank_saved[bank].both  = gpio_bankb[bank]->both;
727                         gpio_bank_saved[bank].reserved =
728                                                 reserved_gpio_map[bank];
729
730                         gpio = i;
731
732                         while (mask) {
733                                 if (mask & 1) {
734                                         reserved_gpio_map[gpio_bank(gpio)] |=
735                                                         gpio_bit(gpio);
736                                         bfin_gpio_wakeup_type(gpio,
737                                                 wakeup_flags_map[gpio]);
738                                         set_gpio_data(gpio, 0); /*Clear*/
739                                 }
740                                 gpio++;
741                                 mask >>= 1;
742                         }
743
744                         sic_iwr |= 1 <<
745                                 (sic_iwr_irqs[bank] - (IRQ_CORETMR + 1));
746                         gpio_bankb[bank]->maskb_set = wakeup_map[gpio_bank(i)];
747                 }
748         }
749
750         AWA_DUMMY_READ(maskb_set);
751
752         if (sic_iwr)
753                 return sic_iwr;
754         else
755                 return IWR_ENABLE_ALL;
756 }
757
758 void gpio_pm_restore(void)
759 {
760         u16 bank, mask, i;
761
762         for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
763                 mask = wakeup_map[gpio_bank(i)];
764                 bank = gpio_bank(i);
765
766                 if (mask) {
767 #ifdef BF537_FAMILY
768                         *port_fer[bank]         = gpio_bank_saved[bank].fer;
769 #endif
770                         gpio_bankb[bank]->inen  = gpio_bank_saved[bank].inen;
771                         gpio_bankb[bank]->dir   = gpio_bank_saved[bank].dir;
772                         gpio_bankb[bank]->polar = gpio_bank_saved[bank].polar;
773                         gpio_bankb[bank]->edge  = gpio_bank_saved[bank].edge;
774                         gpio_bankb[bank]->both  = gpio_bank_saved[bank].both;
775
776                         reserved_gpio_map[bank] =
777                                         gpio_bank_saved[bank].reserved;
778
779                 }
780
781                 gpio_bankb[bank]->maskb = gpio_bank_saved[bank].maskb;
782         }
783         AWA_DUMMY_READ(maskb);
784 }
785
786 #endif
787 #endif /* BF548_FAMILY */
788
789 /***********************************************************
790 *
791 * FUNCTIONS:    Blackfin Peripheral Resource Allocation
792 *               and PortMux Setup
793 *
794 * INPUTS/OUTPUTS:
795 * per   Peripheral Identifier
796 * label String
797 *
798 * DESCRIPTION: Blackfin Peripheral Resource Allocation and Setup API
799 *
800 * CAUTION:
801 *************************************************************
802 * MODIFICATION HISTORY :
803 **************************************************************/
804
805 #ifdef BF548_FAMILY
806 int peripheral_request(unsigned short per, const char *label)
807 {
808         unsigned long flags;
809         unsigned short ident = P_IDENT(per);
810
811         /*
812          * Don't cares are pins with only one dedicated function
813          */
814
815         if (per & P_DONTCARE)
816                 return 0;
817
818         if (!(per & P_DEFINED))
819                 return -ENODEV;
820
821         if (check_gpio(ident) < 0)
822                 return -EINVAL;
823
824         local_irq_save(flags);
825
826         if (unlikely(reserved_gpio_map[gpio_bank(ident)] & gpio_bit(ident))) {
827                 printk(KERN_ERR
828                     "%s: Peripheral %d is already reserved as GPIO by %s !\n",
829                        __FUNCTION__, ident, get_label(ident));
830                 dump_stack();
831                 local_irq_restore(flags);
832                 return -EBUSY;
833         }
834
835         if (unlikely(reserved_peri_map[gpio_bank(ident)] & gpio_bit(ident))) {
836
837                 u16 funct = get_portmux(ident);
838
839         /*
840          * Pin functions like AMC address strobes my
841          * be requested and used by several drivers
842          */
843
844                 if (!((per & P_MAYSHARE) && (funct == P_FUNCT2MUX(per)))) {
845
846                 /*
847                  * Allow that the identical pin function can
848                  * be requested from the same driver twice
849                  */
850
851                 if (cmp_label(ident, label) == 0)
852                         goto anyway;
853
854                         printk(KERN_ERR
855                                "%s: Peripheral %d function %d is already reserved by %s !\n",
856                                __FUNCTION__, ident, P_FUNCT2MUX(per), get_label(ident));
857                         dump_stack();
858                         local_irq_restore(flags);
859                         return -EBUSY;
860                 }
861         }
862
863 anyway:
864         reserved_peri_map[gpio_bank(ident)] |= gpio_bit(ident);
865
866         portmux_setup(ident, P_FUNCT2MUX(per));
867         port_setup(ident, PERIPHERAL_USAGE);
868
869         local_irq_restore(flags);
870         set_label(ident, label);
871
872         return 0;
873 }
874 EXPORT_SYMBOL(peripheral_request);
875 #else
876
877 int peripheral_request(unsigned short per, const char *label)
878 {
879         unsigned long flags;
880         unsigned short ident = P_IDENT(per);
881
882         /*
883          * Don't cares are pins with only one dedicated function
884          */
885
886         if (per & P_DONTCARE)
887                 return 0;
888
889         if (!(per & P_DEFINED))
890                 return -ENODEV;
891
892         local_irq_save(flags);
893
894         if (!check_gpio(ident)) {
895
896         if (unlikely(reserved_gpio_map[gpio_bank(ident)] & gpio_bit(ident))) {
897                 printk(KERN_ERR
898                        "%s: Peripheral %d is already reserved as GPIO by %s !\n",
899                        __FUNCTION__, ident, get_label(ident));
900                 dump_stack();
901                 local_irq_restore(flags);
902                 return -EBUSY;
903         }
904
905         }
906
907         if (unlikely(reserved_peri_map[gpio_bank(ident)] & gpio_bit(ident))) {
908
909         /*
910          * Pin functions like AMC address strobes my
911          * be requested and used by several drivers
912          */
913
914         if (!(per & P_MAYSHARE)) {
915
916         /*
917          * Allow that the identical pin function can
918          * be requested from the same driver twice
919          */
920
921                 if (cmp_label(ident, label) == 0)
922                         goto anyway;
923
924                         printk(KERN_ERR
925                                "%s: Peripheral %d function %d is already"
926                                " reserved by %s !\n",
927                                __FUNCTION__, ident, P_FUNCT2MUX(per),
928                                 get_label(ident));
929                         dump_stack();
930                         local_irq_restore(flags);
931                         return -EBUSY;
932                 }
933
934         }
935
936 anyway:
937         portmux_setup(per, P_FUNCT2MUX(per));
938
939         port_setup(ident, PERIPHERAL_USAGE);
940
941         reserved_peri_map[gpio_bank(ident)] |= gpio_bit(ident);
942         local_irq_restore(flags);
943         set_label(ident, label);
944
945         return 0;
946 }
947 EXPORT_SYMBOL(peripheral_request);
948 #endif
949
950 int peripheral_request_list(unsigned short per[], const char *label)
951 {
952         u16 cnt;
953         int ret;
954
955         for (cnt = 0; per[cnt] != 0; cnt++) {
956
957                 ret = peripheral_request(per[cnt], label);
958
959                 if (ret < 0) {
960                         for ( ; cnt > 0; cnt--) {
961                                 peripheral_free(per[cnt - 1]);
962                         }
963                 return ret;
964                 }
965         }
966
967         return 0;
968 }
969 EXPORT_SYMBOL(peripheral_request_list);
970
971 void peripheral_free(unsigned short per)
972 {
973         unsigned long flags;
974         unsigned short ident = P_IDENT(per);
975
976         if (per & P_DONTCARE)
977                 return;
978
979         if (!(per & P_DEFINED))
980                 return;
981
982         if (check_gpio(ident) < 0)
983                 return;
984
985         local_irq_save(flags);
986
987         if (unlikely(!(reserved_peri_map[gpio_bank(ident)]
988                          & gpio_bit(ident)))) {
989                 local_irq_restore(flags);
990                 return;
991         }
992
993         if (!(per & P_MAYSHARE)) {
994                 port_setup(ident, GPIO_USAGE);
995         }
996
997         reserved_peri_map[gpio_bank(ident)] &= ~gpio_bit(ident);
998
999         set_label(ident, "free");
1000
1001         local_irq_restore(flags);
1002 }
1003 EXPORT_SYMBOL(peripheral_free);
1004
1005 void peripheral_free_list(unsigned short per[])
1006 {
1007         u16 cnt;
1008
1009         for (cnt = 0; per[cnt] != 0; cnt++) {
1010                 peripheral_free(per[cnt]);
1011         }
1012
1013 }
1014 EXPORT_SYMBOL(peripheral_free_list);
1015
1016 /***********************************************************
1017 *
1018 * FUNCTIONS: Blackfin GPIO Driver
1019 *
1020 * INPUTS/OUTPUTS:
1021 * gpio  PIO Number between 0 and MAX_BLACKFIN_GPIOS
1022 * label String
1023 *
1024 * DESCRIPTION: Blackfin GPIO Driver API
1025 *
1026 * CAUTION:
1027 *************************************************************
1028 * MODIFICATION HISTORY :
1029 **************************************************************/
1030
1031 int gpio_request(unsigned short gpio, const char *label)
1032 {
1033         unsigned long flags;
1034
1035         if (check_gpio(gpio) < 0)
1036                 return -EINVAL;
1037
1038         local_irq_save(flags);
1039
1040         /*
1041          * Allow that the identical GPIO can
1042          * be requested from the same driver twice
1043          * Do nothing and return -
1044          */
1045
1046         if (cmp_label(gpio, label) == 0) {
1047                 local_irq_restore(flags);
1048                 return 0;
1049         }
1050
1051         if (unlikely(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
1052                 printk(KERN_ERR "bfin-gpio: GPIO %d is already reserved by %s !\n",
1053                          gpio, get_label(gpio));
1054                 dump_stack();
1055                 local_irq_restore(flags);
1056                 return -EBUSY;
1057         }
1058         if (unlikely(reserved_peri_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
1059                 printk(KERN_ERR
1060                        "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
1061                        gpio, get_label(gpio));
1062                 dump_stack();
1063                 local_irq_restore(flags);
1064                 return -EBUSY;
1065         }
1066
1067         reserved_gpio_map[gpio_bank(gpio)] |= gpio_bit(gpio);
1068
1069         local_irq_restore(flags);
1070
1071         port_setup(gpio, GPIO_USAGE);
1072         set_label(gpio, label);
1073
1074         return 0;
1075 }
1076 EXPORT_SYMBOL(gpio_request);
1077
1078 void gpio_free(unsigned short gpio)
1079 {
1080         unsigned long flags;
1081
1082         if (check_gpio(gpio) < 0)
1083                 return;
1084
1085         local_irq_save(flags);
1086
1087         if (unlikely(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)))) {
1088                 printk(KERN_ERR "bfin-gpio: GPIO %d wasn't reserved!\n", gpio);
1089                 dump_stack();
1090                 local_irq_restore(flags);
1091                 return;
1092         }
1093
1094         default_gpio(gpio);
1095
1096         reserved_gpio_map[gpio_bank(gpio)] &= ~gpio_bit(gpio);
1097
1098         set_label(gpio, "free");
1099
1100         local_irq_restore(flags);
1101 }
1102 EXPORT_SYMBOL(gpio_free);
1103
1104 #ifdef BF548_FAMILY
1105 void gpio_direction_input(unsigned short gpio)
1106 {
1107         unsigned long flags;
1108
1109         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)));
1110
1111         local_irq_save(flags);
1112         gpio_array[gpio_bank(gpio)]->port_dir_clear = gpio_bit(gpio);
1113         gpio_array[gpio_bank(gpio)]->port_inen |= gpio_bit(gpio);
1114         local_irq_restore(flags);
1115 }
1116 EXPORT_SYMBOL(gpio_direction_input);
1117
1118 void gpio_direction_output(unsigned short gpio)
1119 {
1120         unsigned long flags;
1121
1122         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)));
1123
1124         local_irq_save(flags);
1125         gpio_array[gpio_bank(gpio)]->port_inen &= ~gpio_bit(gpio);
1126         gpio_array[gpio_bank(gpio)]->port_dir_set = gpio_bit(gpio);
1127         local_irq_restore(flags);
1128 }
1129 EXPORT_SYMBOL(gpio_direction_output);
1130
1131 void gpio_set_value(unsigned short gpio, unsigned short arg)
1132 {
1133         if (arg)
1134                 gpio_array[gpio_bank(gpio)]->port_set = gpio_bit(gpio);
1135         else
1136                 gpio_array[gpio_bank(gpio)]->port_clear = gpio_bit(gpio);
1137
1138 }
1139 EXPORT_SYMBOL(gpio_set_value);
1140
1141 unsigned short gpio_get_value(unsigned short gpio)
1142 {
1143         return (1 & (gpio_array[gpio_bank(gpio)]->port_data >> gpio_sub_n(gpio)));
1144 }
1145 EXPORT_SYMBOL(gpio_get_value);
1146
1147 #else
1148
1149 void gpio_direction_input(unsigned short gpio)
1150 {
1151         unsigned long flags;
1152
1153         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)));
1154
1155         local_irq_save(flags);
1156         gpio_bankb[gpio_bank(gpio)]->dir &= ~gpio_bit(gpio);
1157         gpio_bankb[gpio_bank(gpio)]->inen |= gpio_bit(gpio);
1158         AWA_DUMMY_READ(inen);
1159         local_irq_restore(flags);
1160 }
1161 EXPORT_SYMBOL(gpio_direction_input);
1162
1163 void gpio_direction_output(unsigned short gpio)
1164 {
1165         unsigned long flags;
1166
1167         BUG_ON(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)));
1168
1169         local_irq_save(flags);
1170         gpio_bankb[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio);
1171         gpio_bankb[gpio_bank(gpio)]->dir |= gpio_bit(gpio);
1172         AWA_DUMMY_READ(dir);
1173         local_irq_restore(flags);
1174 }
1175 EXPORT_SYMBOL(gpio_direction_output);
1176
1177 /* If we are booting from SPI and our board lacks a strong enough pull up,
1178  * the core can reset and execute the bootrom faster than the resistor can
1179  * pull the signal logically high.  To work around this (common) error in
1180  * board design, we explicitly set the pin back to GPIO mode, force /CS
1181  * high, and wait for the electrons to do their thing.
1182  *
1183  * This function only makes sense to be called from reset code, but it
1184  * lives here as we need to force all the GPIO states w/out going through
1185  * BUG() checks and such.
1186  */
1187 void bfin_gpio_reset_spi0_ssel1(void)
1188 {
1189         u16 gpio = P_IDENT(P_SPI0_SSEL1);
1190
1191         port_setup(gpio, GPIO_USAGE);
1192         gpio_bankb[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
1193         udelay(1);
1194 }
1195
1196 #endif /*BF548_FAMILY */