blob: dc07ed08b37f858403f716093d211d0793576b00 [file] [log] [blame]
Bryan Wu1394f032007-05-06 14:50:22 -07001/*
Robin Getz96f10502009-09-24 14:11:24 +00002 * GPIO Abstraction Layer
Bryan Wu1394f032007-05-06 14:50:22 -07003 *
Robin Getz96f10502009-09-24 14:11:24 +00004 * Copyright 2006-2009 Analog Devices Inc.
Bryan Wu1394f032007-05-06 14:50:22 -07005 *
Robin Getz96f10502009-09-24 14:11:24 +00006 * Licensed under the GPL-2 or later
Bryan Wu1394f032007-05-06 14:50:22 -07007 */
8
Mike Frysinger168f1212007-10-11 00:22:35 +08009#include <linux/delay.h>
Bryan Wu1394f032007-05-06 14:50:22 -070010#include <linux/module.h>
11#include <linux/err.h>
Mike Frysinger1545a112007-12-24 16:54:48 +080012#include <linux/proc_fs.h>
Bryan Wu1394f032007-05-06 14:50:22 -070013#include <asm/blackfin.h>
14#include <asm/gpio.h>
Michael Hennerichc58c2142007-10-04 00:35:05 +080015#include <asm/portmux.h>
Bryan Wu1394f032007-05-06 14:50:22 -070016#include <linux/irq.h>
17
Michael Hennerich2b393312007-10-10 16:58:49 +080018#if ANOMALY_05000311 || ANOMALY_05000323
19enum {
20 AWA_data = SYSCR,
21 AWA_data_clear = SYSCR,
22 AWA_data_set = SYSCR,
23 AWA_toggle = SYSCR,
Graf Yang6ed83942008-04-24 04:43:14 +080024 AWA_maska = BFIN_UART_SCR,
25 AWA_maska_clear = BFIN_UART_SCR,
26 AWA_maska_set = BFIN_UART_SCR,
27 AWA_maska_toggle = BFIN_UART_SCR,
28 AWA_maskb = BFIN_UART_GCTL,
29 AWA_maskb_clear = BFIN_UART_GCTL,
30 AWA_maskb_set = BFIN_UART_GCTL,
31 AWA_maskb_toggle = BFIN_UART_GCTL,
Michael Hennerich2b393312007-10-10 16:58:49 +080032 AWA_dir = SPORT1_STAT,
33 AWA_polar = SPORT1_STAT,
34 AWA_edge = SPORT1_STAT,
35 AWA_both = SPORT1_STAT,
36#if ANOMALY_05000311
37 AWA_inen = TIMER_ENABLE,
38#elif ANOMALY_05000323
39 AWA_inen = DMA1_1_CONFIG,
40#endif
41};
42 /* Anomaly Workaround */
43#define AWA_DUMMY_READ(name) bfin_read16(AWA_ ## name)
44#else
45#define AWA_DUMMY_READ(...) do { } while (0)
46#endif
47
Mike Frysingerf5563092009-02-04 16:49:45 +080048static struct gpio_port_t * const gpio_array[] = {
Michael Hennerichdc26aec2008-11-18 17:48:22 +080049#if defined(BF533_FAMILY) || defined(BF538_FAMILY)
Bryan Wu1394f032007-05-06 14:50:22 -070050 (struct gpio_port_t *) FIO_FLAG_D,
Mike Frysinger269647d2009-03-28 20:32:57 +080051#elif defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Bryan Wu1394f032007-05-06 14:50:22 -070052 (struct gpio_port_t *) PORTFIO,
53 (struct gpio_port_t *) PORTGIO,
54 (struct gpio_port_t *) PORTHIO,
Mike Frysingerf5563092009-02-04 16:49:45 +080055#elif defined(BF561_FAMILY)
56 (struct gpio_port_t *) FIO0_FLAG_D,
57 (struct gpio_port_t *) FIO1_FLAG_D,
58 (struct gpio_port_t *) FIO2_FLAG_D,
Mike Frysinger269647d2009-03-28 20:32:57 +080059#elif defined(CONFIG_BF54x)
Mike Frysingerf5563092009-02-04 16:49:45 +080060 (struct gpio_port_t *)PORTA_FER,
61 (struct gpio_port_t *)PORTB_FER,
62 (struct gpio_port_t *)PORTC_FER,
63 (struct gpio_port_t *)PORTD_FER,
64 (struct gpio_port_t *)PORTE_FER,
65 (struct gpio_port_t *)PORTF_FER,
66 (struct gpio_port_t *)PORTG_FER,
67 (struct gpio_port_t *)PORTH_FER,
68 (struct gpio_port_t *)PORTI_FER,
69 (struct gpio_port_t *)PORTJ_FER,
70#else
71# error no gpio arrays defined
72#endif
Bryan Wu1394f032007-05-06 14:50:22 -070073};
74
Mike Frysinger269647d2009-03-28 20:32:57 +080075#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +080076static unsigned short * const port_fer[] = {
Bryan Wu1394f032007-05-06 14:50:22 -070077 (unsigned short *) PORTF_FER,
78 (unsigned short *) PORTG_FER,
79 (unsigned short *) PORTH_FER,
80};
Bryan Wu1394f032007-05-06 14:50:22 -070081
Mike Frysingerf5563092009-02-04 16:49:45 +080082# if !defined(BF537_FAMILY)
83static unsigned short * const port_mux[] = {
Michael Hennerich59003142007-10-21 16:54:27 +080084 (unsigned short *) PORTF_MUX,
85 (unsigned short *) PORTG_MUX,
86 (unsigned short *) PORTH_MUX,
87};
88
89static const
Graf Yang0ce5eaf2009-02-04 16:49:45 +080090u8 pmux_offset[][16] = {
Mike Frysinger269647d2009-03-28 20:32:57 +080091# if defined(CONFIG_BF52x)
Graf Yang0ce5eaf2009-02-04 16:49:45 +080092 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 4, 6, 8, 8, 10, 10 }, /* PORTF */
93 { 0, 0, 0, 0, 0, 2, 2, 4, 4, 6, 8, 10, 10, 10, 12, 12 }, /* PORTG */
94 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 4, 4, 4, 4, 4 }, /* PORTH */
Mike Frysinger269647d2009-03-28 20:32:57 +080095# elif defined(CONFIG_BF51x)
Graf Yang0ce5eaf2009-02-04 16:49:45 +080096 { 0, 2, 2, 2, 2, 2, 2, 4, 6, 6, 6, 8, 8, 8, 8, 10 }, /* PORTF */
97 { 0, 0, 0, 2, 4, 6, 6, 6, 8, 10, 10, 12, 14, 14, 14, 14 }, /* PORTG */
98 { 0, 0, 0, 0, 2, 2, 4, 6, 10, 10, 10, 10, 10, 10, 10, 10 }, /* PORTH */
99# endif
100};
Mike Frysingerf5563092009-02-04 16:49:45 +0800101# endif
Graf Yang0ce5eaf2009-02-04 16:49:45 +0800102
Michael Hennerich621dd242009-09-28 12:23:41 +0000103#elif defined(BF538_FAMILY)
104static unsigned short * const port_fer[] = {
105 (unsigned short *) PORTCIO_FER,
106 (unsigned short *) PORTDIO_FER,
107 (unsigned short *) PORTEIO_FER,
108};
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800109#endif
110
Mike Frysinger812ae982010-07-05 08:40:41 +0000111#define RESOURCE_LABEL_SIZE 16
Michael Hennerich8c613622007-08-03 17:48:09 +0800112
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800113static struct str_ident {
Michael Hennerich8c613622007-08-03 17:48:09 +0800114 char name[RESOURCE_LABEL_SIZE];
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800115} str_ident[MAX_RESOURCES];
Bryan Wu1394f032007-05-06 14:50:22 -0700116
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800117#if defined(CONFIG_PM)
Bryan Wu397861c2008-11-18 17:48:22 +0800118static struct gpio_port_s gpio_bank_saved[GPIO_BANK_NUM];
Bryan Wu1394f032007-05-06 14:50:22 -0700119#endif
120
Mike Frysinger74c04502008-10-08 16:13:17 +0800121static void gpio_error(unsigned gpio)
Michael Hennerichacbcd262008-01-22 18:36:20 +0800122{
123 printk(KERN_ERR "bfin-gpio: GPIO %d wasn't requested!\n", gpio);
124}
125
Michael Hennerichc58c2142007-10-04 00:35:05 +0800126static void set_label(unsigned short ident, const char *label)
127{
Michael Henneriche9fae182008-10-13 11:35:22 +0800128 if (label) {
Michael Hennerich8c613622007-08-03 17:48:09 +0800129 strncpy(str_ident[ident].name, label,
Michael Hennerichc58c2142007-10-04 00:35:05 +0800130 RESOURCE_LABEL_SIZE);
Michael Hennerich8c613622007-08-03 17:48:09 +0800131 str_ident[ident].name[RESOURCE_LABEL_SIZE - 1] = 0;
Michael Hennerichc58c2142007-10-04 00:35:05 +0800132 }
133}
134
135static char *get_label(unsigned short ident)
136{
Michael Hennerich8c613622007-08-03 17:48:09 +0800137 return (*str_ident[ident].name ? str_ident[ident].name : "UNKNOWN");
Michael Hennerichc58c2142007-10-04 00:35:05 +0800138}
139
140static int cmp_label(unsigned short ident, const char *label)
141{
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800142 if (label == NULL) {
143 dump_stack();
144 printk(KERN_ERR "Please provide none-null label\n");
145 }
146
Michael Henneriche9fae182008-10-13 11:35:22 +0800147 if (label)
Mike Frysinger1f7d3732008-10-28 15:47:11 +0800148 return strcmp(str_ident[ident].name, label);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800149 else
150 return -EINVAL;
151}
152
Mike Frysinger332824b2010-06-02 04:22:01 +0000153#define map_entry(m, i) reserved_##m##_map[gpio_bank(i)]
154#define is_reserved(m, i, e) (map_entry(m, i) & gpio_bit(i))
155#define reserve(m, i) (map_entry(m, i) |= gpio_bit(i))
156#define unreserve(m, i) (map_entry(m, i) &= ~gpio_bit(i))
157#define DECLARE_RESERVED_MAP(m, c) static unsigned short reserved_##m##_map[c]
158
159DECLARE_RESERVED_MAP(gpio, GPIO_BANK_NUM);
Michael Hennerich382dbe52010-07-13 08:26:10 +0000160DECLARE_RESERVED_MAP(peri, DIV_ROUND_UP(MAX_RESOURCES, GPIO_BANKSIZE));
Mike Frysinger332824b2010-06-02 04:22:01 +0000161DECLARE_RESERVED_MAP(gpio_irq, GPIO_BANK_NUM);
162
163inline int check_gpio(unsigned gpio)
164{
165#if defined(CONFIG_BF54x)
166 if (gpio == GPIO_PB15 || gpio == GPIO_PC14 || gpio == GPIO_PC15
167 || gpio == GPIO_PH14 || gpio == GPIO_PH15
168 || gpio == GPIO_PJ14 || gpio == GPIO_PJ15)
169 return -EINVAL;
170#endif
171 if (gpio >= MAX_BLACKFIN_GPIOS)
172 return -EINVAL;
173 return 0;
174}
175
Mike Frysingera2d03a12008-10-28 15:53:37 +0800176static void port_setup(unsigned gpio, unsigned short usage)
177{
Michael Hennerich621dd242009-09-28 12:23:41 +0000178#if defined(BF538_FAMILY)
179 /*
180 * BF538/9 Port C,D and E are special.
181 * Inverted PORT_FER polarity on CDE and no PORF_FER on F
182 * Regular PORT F GPIOs are handled here, CDE are exclusively
183 * managed by GPIOLIB
184 */
185
186 if (gpio < MAX_BLACKFIN_GPIOS || gpio >= MAX_RESOURCES)
187 return;
188
189 gpio -= MAX_BLACKFIN_GPIOS;
190
191 if (usage == GPIO_USAGE)
192 *port_fer[gpio_bank(gpio)] |= gpio_bit(gpio);
193 else
194 *port_fer[gpio_bank(gpio)] &= ~gpio_bit(gpio);
195 SSYNC();
196 return;
197#endif
198
Mike Frysingera2d03a12008-10-28 15:53:37 +0800199 if (check_gpio(gpio))
200 return;
201
Mike Frysinger269647d2009-03-28 20:32:57 +0800202#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Mike Frysingera2d03a12008-10-28 15:53:37 +0800203 if (usage == GPIO_USAGE)
204 *port_fer[gpio_bank(gpio)] &= ~gpio_bit(gpio);
205 else
206 *port_fer[gpio_bank(gpio)] |= gpio_bit(gpio);
207 SSYNC();
Mike Frysinger269647d2009-03-28 20:32:57 +0800208#elif defined(CONFIG_BF54x)
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800209 if (usage == GPIO_USAGE)
210 gpio_array[gpio_bank(gpio)]->port_fer &= ~gpio_bit(gpio);
211 else
212 gpio_array[gpio_bank(gpio)]->port_fer |= gpio_bit(gpio);
213 SSYNC();
Bryan Wu1394f032007-05-06 14:50:22 -0700214#endif
Mike Frysingera2d03a12008-10-28 15:53:37 +0800215}
Bryan Wu1394f032007-05-06 14:50:22 -0700216
Michael Hennerichc58c2142007-10-04 00:35:05 +0800217#ifdef BF537_FAMILY
Michael Hennerich8c613622007-08-03 17:48:09 +0800218static struct {
219 unsigned short res;
220 unsigned short offset;
221} port_mux_lut[] = {
222 {.res = P_PPI0_D13, .offset = 11},
223 {.res = P_PPI0_D14, .offset = 11},
224 {.res = P_PPI0_D15, .offset = 11},
225 {.res = P_SPORT1_TFS, .offset = 11},
226 {.res = P_SPORT1_TSCLK, .offset = 11},
227 {.res = P_SPORT1_DTPRI, .offset = 11},
228 {.res = P_PPI0_D10, .offset = 10},
229 {.res = P_PPI0_D11, .offset = 10},
230 {.res = P_PPI0_D12, .offset = 10},
231 {.res = P_SPORT1_RSCLK, .offset = 10},
232 {.res = P_SPORT1_RFS, .offset = 10},
233 {.res = P_SPORT1_DRPRI, .offset = 10},
234 {.res = P_PPI0_D8, .offset = 9},
235 {.res = P_PPI0_D9, .offset = 9},
236 {.res = P_SPORT1_DRSEC, .offset = 9},
237 {.res = P_SPORT1_DTSEC, .offset = 9},
238 {.res = P_TMR2, .offset = 8},
239 {.res = P_PPI0_FS3, .offset = 8},
240 {.res = P_TMR3, .offset = 7},
241 {.res = P_SPI0_SSEL4, .offset = 7},
242 {.res = P_TMR4, .offset = 6},
243 {.res = P_SPI0_SSEL5, .offset = 6},
244 {.res = P_TMR5, .offset = 5},
245 {.res = P_SPI0_SSEL6, .offset = 5},
246 {.res = P_UART1_RX, .offset = 4},
247 {.res = P_UART1_TX, .offset = 4},
248 {.res = P_TMR6, .offset = 4},
249 {.res = P_TMR7, .offset = 4},
250 {.res = P_UART0_RX, .offset = 3},
251 {.res = P_UART0_TX, .offset = 3},
252 {.res = P_DMAR0, .offset = 3},
253 {.res = P_DMAR1, .offset = 3},
254 {.res = P_SPORT0_DTSEC, .offset = 1},
255 {.res = P_SPORT0_DRSEC, .offset = 1},
256 {.res = P_CAN0_RX, .offset = 1},
257 {.res = P_CAN0_TX, .offset = 1},
258 {.res = P_SPI0_SSEL7, .offset = 1},
259 {.res = P_SPORT0_TFS, .offset = 0},
260 {.res = P_SPORT0_DTPRI, .offset = 0},
261 {.res = P_SPI0_SSEL2, .offset = 0},
262 {.res = P_SPI0_SSEL3, .offset = 0},
Michael Hennerichc58c2142007-10-04 00:35:05 +0800263};
264
Mike Frysingerf5563092009-02-04 16:49:45 +0800265static void portmux_setup(unsigned short per)
Michael Hennerichc58c2142007-10-04 00:35:05 +0800266{
Michael Hennerich8c613622007-08-03 17:48:09 +0800267 u16 y, offset, muxreg;
Mike Frysingerf5563092009-02-04 16:49:45 +0800268 u16 function = P_FUNCT2MUX(per);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800269
Michael Hennerich8c613622007-08-03 17:48:09 +0800270 for (y = 0; y < ARRAY_SIZE(port_mux_lut); y++) {
271 if (port_mux_lut[y].res == per) {
Michael Hennerichc58c2142007-10-04 00:35:05 +0800272
273 /* SET PORTMUX REG */
274
Michael Hennerich8c613622007-08-03 17:48:09 +0800275 offset = port_mux_lut[y].offset;
Michael Hennerichc58c2142007-10-04 00:35:05 +0800276 muxreg = bfin_read_PORT_MUX();
277
Mike Frysingerd171c232008-03-26 08:35:46 +0800278 if (offset != 1)
Michael Hennerichc58c2142007-10-04 00:35:05 +0800279 muxreg &= ~(1 << offset);
Mike Frysingerd171c232008-03-26 08:35:46 +0800280 else
Michael Hennerichc58c2142007-10-04 00:35:05 +0800281 muxreg &= ~(3 << 1);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800282
283 muxreg |= (function << offset);
284 bfin_write_PORT_MUX(muxreg);
285 }
286 }
287}
Mike Frysinger269647d2009-03-28 20:32:57 +0800288#elif defined(CONFIG_BF54x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800289inline void portmux_setup(unsigned short per)
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800290{
291 u32 pmux;
Mike Frysingerf5563092009-02-04 16:49:45 +0800292 u16 ident = P_IDENT(per);
293 u16 function = P_FUNCT2MUX(per);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800294
Mike Frysingerf5563092009-02-04 16:49:45 +0800295 pmux = gpio_array[gpio_bank(ident)]->port_mux;
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800296
Mike Frysingerf5563092009-02-04 16:49:45 +0800297 pmux &= ~(0x3 << (2 * gpio_sub_n(ident)));
298 pmux |= (function & 0x3) << (2 * gpio_sub_n(ident));
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800299
Mike Frysingerf5563092009-02-04 16:49:45 +0800300 gpio_array[gpio_bank(ident)]->port_mux = pmux;
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800301}
302
Mike Frysingerf5563092009-02-04 16:49:45 +0800303inline u16 get_portmux(unsigned short per)
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800304{
305 u32 pmux;
Mike Frysingerf5563092009-02-04 16:49:45 +0800306 u16 ident = P_IDENT(per);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800307
Mike Frysingerf5563092009-02-04 16:49:45 +0800308 pmux = gpio_array[gpio_bank(ident)]->port_mux;
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800309
Mike Frysingerf5563092009-02-04 16:49:45 +0800310 return (pmux >> (2 * gpio_sub_n(ident)) & 0x3);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800311}
Mike Frysinger269647d2009-03-28 20:32:57 +0800312#elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800313inline void portmux_setup(unsigned short per)
Michael Hennerich59003142007-10-21 16:54:27 +0800314{
Mike Frysingerf5563092009-02-04 16:49:45 +0800315 u16 pmux, ident = P_IDENT(per), function = P_FUNCT2MUX(per);
Michael Hennerich59003142007-10-21 16:54:27 +0800316 u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
317
318 pmux = *port_mux[gpio_bank(ident)];
319 pmux &= ~(3 << offset);
320 pmux |= (function & 3) << offset;
321 *port_mux[gpio_bank(ident)] = pmux;
322 SSYNC();
323}
Michael Hennerichc58c2142007-10-04 00:35:05 +0800324#else
325# define portmux_setup(...) do { } while (0)
326#endif
Bryan Wu1394f032007-05-06 14:50:22 -0700327
Mike Frysinger269647d2009-03-28 20:32:57 +0800328#ifndef CONFIG_BF54x
Bryan Wu1394f032007-05-06 14:50:22 -0700329/***********************************************************
330*
331* FUNCTIONS: Blackfin General Purpose Ports Access Functions
332*
333* INPUTS/OUTPUTS:
334* gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
335*
336*
337* DESCRIPTION: These functions abstract direct register access
338* to Blackfin processor General Purpose
339* Ports Regsiters
340*
341* CAUTION: These functions do not belong to the GPIO Driver API
342*************************************************************
343* MODIFICATION HISTORY :
344**************************************************************/
345
346/* Set a specific bit */
347
348#define SET_GPIO(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800349void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
Bryan Wu1394f032007-05-06 14:50:22 -0700350{ \
351 unsigned long flags; \
Yi Li6a01f232009-01-07 23:14:39 +0800352 local_irq_save_hw(flags); \
Bryan Wu1394f032007-05-06 14:50:22 -0700353 if (arg) \
Mike Frysingerf5563092009-02-04 16:49:45 +0800354 gpio_array[gpio_bank(gpio)]->name |= gpio_bit(gpio); \
Bryan Wu1394f032007-05-06 14:50:22 -0700355 else \
Mike Frysingerf5563092009-02-04 16:49:45 +0800356 gpio_array[gpio_bank(gpio)]->name &= ~gpio_bit(gpio); \
Michael Hennerich2b393312007-10-10 16:58:49 +0800357 AWA_DUMMY_READ(name); \
Yi Li6a01f232009-01-07 23:14:39 +0800358 local_irq_restore_hw(flags); \
Bryan Wu1394f032007-05-06 14:50:22 -0700359} \
360EXPORT_SYMBOL(set_gpio_ ## name);
361
Mike Frysingerf5563092009-02-04 16:49:45 +0800362SET_GPIO(dir) /* set_gpio_dir() */
363SET_GPIO(inen) /* set_gpio_inen() */
364SET_GPIO(polar) /* set_gpio_polar() */
365SET_GPIO(edge) /* set_gpio_edge() */
366SET_GPIO(both) /* set_gpio_both() */
Bryan Wu1394f032007-05-06 14:50:22 -0700367
368
Michael Hennerich2b393312007-10-10 16:58:49 +0800369#define SET_GPIO_SC(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800370void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800371{ \
372 unsigned long flags; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800373 if (ANOMALY_05000311 || ANOMALY_05000323) \
374 local_irq_save_hw(flags); \
Michael Hennerich2b393312007-10-10 16:58:49 +0800375 if (arg) \
Mike Frysingerf5563092009-02-04 16:49:45 +0800376 gpio_array[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
Michael Hennerich2b393312007-10-10 16:58:49 +0800377 else \
Mike Frysingerf5563092009-02-04 16:49:45 +0800378 gpio_array[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
379 if (ANOMALY_05000311 || ANOMALY_05000323) { \
380 AWA_DUMMY_READ(name); \
381 local_irq_restore_hw(flags); \
382 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800383} \
384EXPORT_SYMBOL(set_gpio_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700385
386SET_GPIO_SC(maska)
387SET_GPIO_SC(maskb)
Bryan Wu1394f032007-05-06 14:50:22 -0700388SET_GPIO_SC(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700389
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800390void set_gpio_toggle(unsigned gpio)
Bryan Wu1394f032007-05-06 14:50:22 -0700391{
392 unsigned long flags;
Mike Frysingerf5563092009-02-04 16:49:45 +0800393 if (ANOMALY_05000311 || ANOMALY_05000323)
394 local_irq_save_hw(flags);
395 gpio_array[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
396 if (ANOMALY_05000311 || ANOMALY_05000323) {
397 AWA_DUMMY_READ(toggle);
398 local_irq_restore_hw(flags);
399 }
Bryan Wu1394f032007-05-06 14:50:22 -0700400}
Bryan Wu1394f032007-05-06 14:50:22 -0700401EXPORT_SYMBOL(set_gpio_toggle);
402
403
404/*Set current PORT date (16-bit word)*/
405
Michael Hennerich2b393312007-10-10 16:58:49 +0800406#define SET_GPIO_P(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800407void set_gpiop_ ## name(unsigned gpio, unsigned short arg) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800408{ \
409 unsigned long flags; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800410 if (ANOMALY_05000311 || ANOMALY_05000323) \
411 local_irq_save_hw(flags); \
412 gpio_array[gpio_bank(gpio)]->name = arg; \
413 if (ANOMALY_05000311 || ANOMALY_05000323) { \
414 AWA_DUMMY_READ(name); \
415 local_irq_restore_hw(flags); \
416 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800417} \
418EXPORT_SYMBOL(set_gpiop_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700419
Michael Hennerich2b393312007-10-10 16:58:49 +0800420SET_GPIO_P(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700421SET_GPIO_P(dir)
422SET_GPIO_P(inen)
423SET_GPIO_P(polar)
424SET_GPIO_P(edge)
425SET_GPIO_P(both)
426SET_GPIO_P(maska)
427SET_GPIO_P(maskb)
428
Bryan Wu1394f032007-05-06 14:50:22 -0700429/* Get a specific bit */
Michael Hennerich2b393312007-10-10 16:58:49 +0800430#define GET_GPIO(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800431unsigned short get_gpio_ ## name(unsigned gpio) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800432{ \
433 unsigned long flags; \
434 unsigned short ret; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800435 if (ANOMALY_05000311 || ANOMALY_05000323) \
436 local_irq_save_hw(flags); \
437 ret = 0x01 & (gpio_array[gpio_bank(gpio)]->name >> gpio_sub_n(gpio)); \
438 if (ANOMALY_05000311 || ANOMALY_05000323) { \
439 AWA_DUMMY_READ(name); \
440 local_irq_restore_hw(flags); \
441 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800442 return ret; \
443} \
444EXPORT_SYMBOL(get_gpio_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700445
Michael Hennerich2b393312007-10-10 16:58:49 +0800446GET_GPIO(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700447GET_GPIO(dir)
448GET_GPIO(inen)
449GET_GPIO(polar)
450GET_GPIO(edge)
451GET_GPIO(both)
452GET_GPIO(maska)
453GET_GPIO(maskb)
454
Bryan Wu1394f032007-05-06 14:50:22 -0700455/*Get current PORT date (16-bit word)*/
456
Michael Hennerich2b393312007-10-10 16:58:49 +0800457#define GET_GPIO_P(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800458unsigned short get_gpiop_ ## name(unsigned gpio) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800459{ \
460 unsigned long flags; \
461 unsigned short ret; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800462 if (ANOMALY_05000311 || ANOMALY_05000323) \
463 local_irq_save_hw(flags); \
464 ret = (gpio_array[gpio_bank(gpio)]->name); \
465 if (ANOMALY_05000311 || ANOMALY_05000323) { \
466 AWA_DUMMY_READ(name); \
467 local_irq_restore_hw(flags); \
468 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800469 return ret; \
470} \
471EXPORT_SYMBOL(get_gpiop_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700472
Michael Hennerich2b393312007-10-10 16:58:49 +0800473GET_GPIO_P(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700474GET_GPIO_P(dir)
475GET_GPIO_P(inen)
476GET_GPIO_P(polar)
477GET_GPIO_P(edge)
478GET_GPIO_P(both)
479GET_GPIO_P(maska)
480GET_GPIO_P(maskb)
481
Bryan Wu1394f032007-05-06 14:50:22 -0700482
483#ifdef CONFIG_PM
Mike Frysinger332824b2010-06-02 04:22:01 +0000484DECLARE_RESERVED_MAP(wakeup, GPIO_BANK_NUM);
Mike Frysingerf5563092009-02-04 16:49:45 +0800485
486static const unsigned int sic_iwr_irqs[] = {
487#if defined(BF533_FAMILY)
488 IRQ_PROG_INTB
489#elif defined(BF537_FAMILY)
490 IRQ_PROG_INTB, IRQ_PORTG_INTB, IRQ_MAC_TX
491#elif defined(BF538_FAMILY)
492 IRQ_PORTF_INTB
Mike Frysinger269647d2009-03-28 20:32:57 +0800493#elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800494 IRQ_PORTF_INTB, IRQ_PORTG_INTB, IRQ_PORTH_INTB
495#elif defined(BF561_FAMILY)
496 IRQ_PROG0_INTB, IRQ_PROG1_INTB, IRQ_PROG2_INTB
497#else
498# error no SIC_IWR defined
499#endif
500};
501
Bryan Wu1394f032007-05-06 14:50:22 -0700502/***********************************************************
503*
504* FUNCTIONS: Blackfin PM Setup API
505*
506* INPUTS/OUTPUTS:
507* gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
508* type -
509* PM_WAKE_RISING
510* PM_WAKE_FALLING
511* PM_WAKE_HIGH
512* PM_WAKE_LOW
513* PM_WAKE_BOTH_EDGES
514*
515* DESCRIPTION: Blackfin PM Driver API
516*
517* CAUTION:
518*************************************************************
519* MODIFICATION HISTORY :
520**************************************************************/
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000521int gpio_pm_wakeup_ctrl(unsigned gpio, unsigned ctrl)
Bryan Wu1394f032007-05-06 14:50:22 -0700522{
523 unsigned long flags;
524
525 if (check_gpio(gpio) < 0)
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000526 return -EINVAL;
Bryan Wu1394f032007-05-06 14:50:22 -0700527
Yi Li6a01f232009-01-07 23:14:39 +0800528 local_irq_save_hw(flags);
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000529 if (ctrl)
Mike Frysinger332824b2010-06-02 04:22:01 +0000530 reserve(wakeup, gpio);
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000531 else
Mike Frysinger332824b2010-06-02 04:22:01 +0000532 unreserve(wakeup, gpio);
Bryan Wu1394f032007-05-06 14:50:22 -0700533
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000534 set_gpio_maskb(gpio, ctrl);
Yi Li6a01f232009-01-07 23:14:39 +0800535 local_irq_restore_hw(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700536
537 return 0;
538}
539
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000540int bfin_pm_standby_ctrl(unsigned ctrl)
Bryan Wu1394f032007-05-06 14:50:22 -0700541{
542 u16 bank, mask, i;
543
Mike Frysinger1f83b8f2007-07-12 22:58:21 +0800544 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
Mike Frysinger332824b2010-06-02 04:22:01 +0000545 mask = map_entry(wakeup, i);
Bryan Wu1394f032007-05-06 14:50:22 -0700546 bank = gpio_bank(i);
547
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000548 if (mask)
549 bfin_internal_set_wake(sic_iwr_irqs[bank], ctrl);
Bryan Wu1394f032007-05-06 14:50:22 -0700550 }
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000551 return 0;
Bryan Wu1394f032007-05-06 14:50:22 -0700552}
553
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800554void bfin_gpio_pm_hibernate_suspend(void)
555{
556 int i, bank;
557
558 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
559 bank = gpio_bank(i);
560
Mike Frysinger269647d2009-03-28 20:32:57 +0800561#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800562 gpio_bank_saved[bank].fer = *port_fer[bank];
Mike Frysinger269647d2009-03-28 20:32:57 +0800563#if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800564 gpio_bank_saved[bank].mux = *port_mux[bank];
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800565#else
Mike Frysingerf5563092009-02-04 16:49:45 +0800566 if (bank == 0)
567 gpio_bank_saved[bank].mux = bfin_read_PORT_MUX();
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800568#endif
569#endif
Mike Frysingerf5563092009-02-04 16:49:45 +0800570 gpio_bank_saved[bank].data = gpio_array[bank]->data;
571 gpio_bank_saved[bank].inen = gpio_array[bank]->inen;
572 gpio_bank_saved[bank].polar = gpio_array[bank]->polar;
573 gpio_bank_saved[bank].dir = gpio_array[bank]->dir;
574 gpio_bank_saved[bank].edge = gpio_array[bank]->edge;
575 gpio_bank_saved[bank].both = gpio_array[bank]->both;
576 gpio_bank_saved[bank].maska = gpio_array[bank]->maska;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800577 }
578
579 AWA_DUMMY_READ(maska);
580}
581
582void bfin_gpio_pm_hibernate_restore(void)
583{
584 int i, bank;
585
586 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
Mike Frysingerf5563092009-02-04 16:49:45 +0800587 bank = gpio_bank(i);
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800588
Mike Frysinger269647d2009-03-28 20:32:57 +0800589#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
590#if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800591 *port_mux[bank] = gpio_bank_saved[bank].mux;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800592#else
Mike Frysingerf5563092009-02-04 16:49:45 +0800593 if (bank == 0)
594 bfin_write_PORT_MUX(gpio_bank_saved[bank].mux);
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800595#endif
Mike Frysingerf5563092009-02-04 16:49:45 +0800596 *port_fer[bank] = gpio_bank_saved[bank].fer;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800597#endif
Mike Frysingerf5563092009-02-04 16:49:45 +0800598 gpio_array[bank]->inen = gpio_bank_saved[bank].inen;
Michael Hennerichc03c2a82009-07-08 12:04:43 +0000599 gpio_array[bank]->data_set = gpio_bank_saved[bank].data
600 & gpio_bank_saved[bank].dir;
Mike Frysingerf5563092009-02-04 16:49:45 +0800601 gpio_array[bank]->dir = gpio_bank_saved[bank].dir;
602 gpio_array[bank]->polar = gpio_bank_saved[bank].polar;
603 gpio_array[bank]->edge = gpio_bank_saved[bank].edge;
604 gpio_array[bank]->both = gpio_bank_saved[bank].both;
Mike Frysingerf5563092009-02-04 16:49:45 +0800605 gpio_array[bank]->maska = gpio_bank_saved[bank].maska;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800606 }
607 AWA_DUMMY_READ(maska);
608}
609
610
Bryan Wu1394f032007-05-06 14:50:22 -0700611#endif
Mike Frysinger269647d2009-03-28 20:32:57 +0800612#else /* CONFIG_BF54x */
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800613#ifdef CONFIG_PM
614
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000615int bfin_pm_standby_ctrl(unsigned ctrl)
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800616{
617 return 0;
618}
619
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800620void bfin_gpio_pm_hibernate_suspend(void)
621{
622 int i, bank;
623
624 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
625 bank = gpio_bank(i);
626
Mike Frysingerf5563092009-02-04 16:49:45 +0800627 gpio_bank_saved[bank].fer = gpio_array[bank]->port_fer;
628 gpio_bank_saved[bank].mux = gpio_array[bank]->port_mux;
629 gpio_bank_saved[bank].data = gpio_array[bank]->data;
Mike Frysingerf5563092009-02-04 16:49:45 +0800630 gpio_bank_saved[bank].inen = gpio_array[bank]->inen;
631 gpio_bank_saved[bank].dir = gpio_array[bank]->dir_set;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800632 }
633}
634
635void bfin_gpio_pm_hibernate_restore(void)
636{
637 int i, bank;
638
639 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
Mike Frysingerf5563092009-02-04 16:49:45 +0800640 bank = gpio_bank(i);
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800641
Mike Frysingerf5563092009-02-04 16:49:45 +0800642 gpio_array[bank]->port_mux = gpio_bank_saved[bank].mux;
643 gpio_array[bank]->port_fer = gpio_bank_saved[bank].fer;
644 gpio_array[bank]->inen = gpio_bank_saved[bank].inen;
645 gpio_array[bank]->dir_set = gpio_bank_saved[bank].dir;
646 gpio_array[bank]->data_set = gpio_bank_saved[bank].data
647 | gpio_bank_saved[bank].dir;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800648 }
649}
650#endif
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800651
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800652unsigned short get_gpio_dir(unsigned gpio)
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800653{
Mike Frysingerf5563092009-02-04 16:49:45 +0800654 return (0x01 & (gpio_array[gpio_bank(gpio)]->dir_clear >> gpio_sub_n(gpio)));
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800655}
656EXPORT_SYMBOL(get_gpio_dir);
657
Mike Frysinger269647d2009-03-28 20:32:57 +0800658#endif /* CONFIG_BF54x */
Bryan Wu1394f032007-05-06 14:50:22 -0700659
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800660/***********************************************************
661*
Mike Frysinger812ae982010-07-05 08:40:41 +0000662* FUNCTIONS: Blackfin Peripheral Resource Allocation
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800663* and PortMux Setup
664*
665* INPUTS/OUTPUTS:
666* per Peripheral Identifier
667* label String
668*
669* DESCRIPTION: Blackfin Peripheral Resource Allocation and Setup API
670*
671* CAUTION:
672*************************************************************
673* MODIFICATION HISTORY :
674**************************************************************/
Michael Hennerichc58c2142007-10-04 00:35:05 +0800675
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800676int peripheral_request(unsigned short per, const char *label)
677{
678 unsigned long flags;
679 unsigned short ident = P_IDENT(per);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800680
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800681 /*
682 * Don't cares are pins with only one dedicated function
683 */
684
685 if (per & P_DONTCARE)
686 return 0;
687
688 if (!(per & P_DEFINED))
689 return -ENODEV;
690
Barry Song89e84ee2009-09-16 04:36:29 +0000691 BUG_ON(ident >= MAX_RESOURCES);
692
Yi Li6a01f232009-01-07 23:14:39 +0800693 local_irq_save_hw(flags);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800694
Mike Frysinger6a87d292008-10-28 16:16:29 +0800695 /* If a pin can be muxed as either GPIO or peripheral, make
696 * sure it is not already a GPIO pin when we request it.
697 */
Mike Frysinger332824b2010-06-02 04:22:01 +0000698 if (unlikely(!check_gpio(ident) && is_reserved(gpio, ident, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800699 if (system_state == SYSTEM_BOOTING)
700 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800701 printk(KERN_ERR
Mike Frysinger6c7ec0e2008-10-28 15:49:59 +0800702 "%s: Peripheral %d is already reserved as GPIO by %s !\n",
Harvey Harrisonb85d8582008-04-23 09:39:01 +0800703 __func__, ident, get_label(ident));
Yi Li6a01f232009-01-07 23:14:39 +0800704 local_irq_restore_hw(flags);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800705 return -EBUSY;
706 }
707
Mike Frysinger332824b2010-06-02 04:22:01 +0000708 if (unlikely(is_reserved(peri, ident, 1))) {
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800709
Mike Frysingerd171c232008-03-26 08:35:46 +0800710 /*
711 * Pin functions like AMC address strobes my
712 * be requested and used by several drivers
713 */
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800714
Mike Frysinger269647d2009-03-28 20:32:57 +0800715#ifdef CONFIG_BF54x
Mike Frysingerf5563092009-02-04 16:49:45 +0800716 if (!((per & P_MAYSHARE) && get_portmux(per) == P_FUNCT2MUX(per))) {
Mike Frysinger6c7ec0e2008-10-28 15:49:59 +0800717#else
718 if (!(per & P_MAYSHARE)) {
719#endif
Mike Frysingerd171c232008-03-26 08:35:46 +0800720 /*
721 * Allow that the identical pin function can
722 * be requested from the same driver twice
723 */
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800724
Mike Frysingerd171c232008-03-26 08:35:46 +0800725 if (cmp_label(ident, label) == 0)
726 goto anyway;
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800727
Robin Getzd6879c52009-03-29 01:10:30 +0800728 if (system_state == SYSTEM_BOOTING)
729 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800730 printk(KERN_ERR
731 "%s: Peripheral %d function %d is already reserved by %s !\n",
Harvey Harrisonb85d8582008-04-23 09:39:01 +0800732 __func__, ident, P_FUNCT2MUX(per), get_label(ident));
Yi Li6a01f232009-01-07 23:14:39 +0800733 local_irq_restore_hw(flags);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800734 return -EBUSY;
735 }
736 }
737
Mike Frysingerd171c232008-03-26 08:35:46 +0800738 anyway:
Mike Frysinger332824b2010-06-02 04:22:01 +0000739 reserve(peri, ident);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800740
Mike Frysingerf5563092009-02-04 16:49:45 +0800741 portmux_setup(per);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800742 port_setup(ident, PERIPHERAL_USAGE);
743
Yi Li6a01f232009-01-07 23:14:39 +0800744 local_irq_restore_hw(flags);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800745 set_label(ident, label);
746
747 return 0;
748}
749EXPORT_SYMBOL(peripheral_request);
750
Mike Frysinger68179372008-04-24 05:04:24 +0800751int peripheral_request_list(const unsigned short per[], const char *label)
Michael Hennerichc58c2142007-10-04 00:35:05 +0800752{
753 u16 cnt;
754 int ret;
755
756 for (cnt = 0; per[cnt] != 0; cnt++) {
Michael Hennerich314c98d2007-07-24 18:03:45 +0800757
Michael Hennerichc58c2142007-10-04 00:35:05 +0800758 ret = peripheral_request(per[cnt], label);
Michael Hennerich314c98d2007-07-24 18:03:45 +0800759
760 if (ret < 0) {
Mike Frysingerd171c232008-03-26 08:35:46 +0800761 for ( ; cnt > 0; cnt--)
Michael Hennerich314c98d2007-07-24 18:03:45 +0800762 peripheral_free(per[cnt - 1]);
Mike Frysingerd171c232008-03-26 08:35:46 +0800763
764 return ret;
Michael Hennerich314c98d2007-07-24 18:03:45 +0800765 }
Michael Hennerichc58c2142007-10-04 00:35:05 +0800766 }
767
768 return 0;
769}
770EXPORT_SYMBOL(peripheral_request_list);
771
772void peripheral_free(unsigned short per)
773{
774 unsigned long flags;
775 unsigned short ident = P_IDENT(per);
776
777 if (per & P_DONTCARE)
778 return;
779
780 if (!(per & P_DEFINED))
781 return;
782
Yi Li6a01f232009-01-07 23:14:39 +0800783 local_irq_save_hw(flags);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800784
Mike Frysinger332824b2010-06-02 04:22:01 +0000785 if (unlikely(!is_reserved(peri, ident, 0))) {
Yi Li6a01f232009-01-07 23:14:39 +0800786 local_irq_restore_hw(flags);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800787 return;
788 }
789
Mike Frysingerd171c232008-03-26 08:35:46 +0800790 if (!(per & P_MAYSHARE))
Michael Hennerichc58c2142007-10-04 00:35:05 +0800791 port_setup(ident, GPIO_USAGE);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800792
Mike Frysinger332824b2010-06-02 04:22:01 +0000793 unreserve(peri, ident);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800794
Michael Hennerich2acde902007-10-11 00:24:40 +0800795 set_label(ident, "free");
796
Yi Li6a01f232009-01-07 23:14:39 +0800797 local_irq_restore_hw(flags);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800798}
799EXPORT_SYMBOL(peripheral_free);
800
Mike Frysinger68179372008-04-24 05:04:24 +0800801void peripheral_free_list(const unsigned short per[])
Michael Hennerichc58c2142007-10-04 00:35:05 +0800802{
803 u16 cnt;
Mike Frysingerd171c232008-03-26 08:35:46 +0800804 for (cnt = 0; per[cnt] != 0; cnt++)
Michael Hennerichc58c2142007-10-04 00:35:05 +0800805 peripheral_free(per[cnt]);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800806}
807EXPORT_SYMBOL(peripheral_free_list);
808
Bryan Wu1394f032007-05-06 14:50:22 -0700809/***********************************************************
810*
811* FUNCTIONS: Blackfin GPIO Driver
812*
813* INPUTS/OUTPUTS:
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800814* gpio PIO Number between 0 and MAX_BLACKFIN_GPIOS
815* label String
Bryan Wu1394f032007-05-06 14:50:22 -0700816*
817* DESCRIPTION: Blackfin GPIO Driver API
818*
819* CAUTION:
820*************************************************************
821* MODIFICATION HISTORY :
822**************************************************************/
823
Michael Hennericha4f0b322008-11-18 17:48:22 +0800824int bfin_gpio_request(unsigned gpio, const char *label)
Bryan Wu1394f032007-05-06 14:50:22 -0700825{
826 unsigned long flags;
827
828 if (check_gpio(gpio) < 0)
829 return -EINVAL;
830
Yi Li6a01f232009-01-07 23:14:39 +0800831 local_irq_save_hw(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700832
Michael Hennerich2acde902007-10-11 00:24:40 +0800833 /*
834 * Allow that the identical GPIO can
835 * be requested from the same driver twice
836 * Do nothing and return -
837 */
838
839 if (cmp_label(gpio, label) == 0) {
Yi Li6a01f232009-01-07 23:14:39 +0800840 local_irq_restore_hw(flags);
Michael Hennerich2acde902007-10-11 00:24:40 +0800841 return 0;
842 }
843
Mike Frysinger332824b2010-06-02 04:22:01 +0000844 if (unlikely(is_reserved(gpio, gpio, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800845 if (system_state == SYSTEM_BOOTING)
846 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800847 printk(KERN_ERR "bfin-gpio: GPIO %d is already reserved by %s !\n",
Graf Yang9570ff42009-01-07 23:14:38 +0800848 gpio, get_label(gpio));
Yi Li6a01f232009-01-07 23:14:39 +0800849 local_irq_restore_hw(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700850 return -EBUSY;
851 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000852 if (unlikely(is_reserved(peri, gpio, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800853 if (system_state == SYSTEM_BOOTING)
854 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800855 printk(KERN_ERR
856 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
857 gpio, get_label(gpio));
Yi Li6a01f232009-01-07 23:14:39 +0800858 local_irq_restore_hw(flags);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800859 return -EBUSY;
860 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000861 if (unlikely(is_reserved(gpio_irq, gpio, 1))) {
Graf Yang9570ff42009-01-07 23:14:38 +0800862 printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved as gpio-irq!"
863 " (Documentation/blackfin/bfin-gpio-notes.txt)\n", gpio);
Michael Hennericha2be3932009-02-04 16:49:45 +0800864 }
Mike Frysinger269647d2009-03-28 20:32:57 +0800865#ifndef CONFIG_BF54x
Michael Hennericha2be3932009-02-04 16:49:45 +0800866 else { /* Reset POLAR setting when acquiring a gpio for the first time */
867 set_gpio_polar(gpio, 0);
868 }
869#endif
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800870
Mike Frysinger332824b2010-06-02 04:22:01 +0000871 reserve(gpio, gpio);
Graf Yang9570ff42009-01-07 23:14:38 +0800872 set_label(gpio, label);
Bryan Wu1394f032007-05-06 14:50:22 -0700873
Yi Li6a01f232009-01-07 23:14:39 +0800874 local_irq_restore_hw(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700875
876 port_setup(gpio, GPIO_USAGE);
877
878 return 0;
879}
Michael Hennericha4f0b322008-11-18 17:48:22 +0800880EXPORT_SYMBOL(bfin_gpio_request);
Bryan Wu1394f032007-05-06 14:50:22 -0700881
Michael Hennericha4f0b322008-11-18 17:48:22 +0800882void bfin_gpio_free(unsigned gpio)
Bryan Wu1394f032007-05-06 14:50:22 -0700883{
884 unsigned long flags;
885
886 if (check_gpio(gpio) < 0)
887 return;
888
Uwe Kleine-Koenig45c4f2a2009-02-04 17:02:30 +0800889 might_sleep();
890
Yi Li6a01f232009-01-07 23:14:39 +0800891 local_irq_save_hw(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700892
Mike Frysinger332824b2010-06-02 04:22:01 +0000893 if (unlikely(!is_reserved(gpio, gpio, 0))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800894 if (system_state == SYSTEM_BOOTING)
895 dump_stack();
Mike Frysingerf85c4ab2008-03-26 08:34:23 +0800896 gpio_error(gpio);
Yi Li6a01f232009-01-07 23:14:39 +0800897 local_irq_restore_hw(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700898 return;
899 }
900
Mike Frysinger332824b2010-06-02 04:22:01 +0000901 unreserve(gpio, gpio);
Bryan Wu1394f032007-05-06 14:50:22 -0700902
Michael Hennerich2acde902007-10-11 00:24:40 +0800903 set_label(gpio, "free");
904
Yi Li6a01f232009-01-07 23:14:39 +0800905 local_irq_restore_hw(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700906}
Michael Hennericha4f0b322008-11-18 17:48:22 +0800907EXPORT_SYMBOL(bfin_gpio_free);
Bryan Wu1394f032007-05-06 14:50:22 -0700908
Michael Hennerich621dd242009-09-28 12:23:41 +0000909#ifdef BFIN_SPECIAL_GPIO_BANKS
Mike Frysinger332824b2010-06-02 04:22:01 +0000910DECLARE_RESERVED_MAP(special_gpio, gpio_bank(MAX_RESOURCES));
Michael Hennerich621dd242009-09-28 12:23:41 +0000911
912int bfin_special_gpio_request(unsigned gpio, const char *label)
913{
914 unsigned long flags;
915
916 local_irq_save_hw(flags);
917
918 /*
919 * Allow that the identical GPIO can
920 * be requested from the same driver twice
921 * Do nothing and return -
922 */
923
924 if (cmp_label(gpio, label) == 0) {
925 local_irq_restore_hw(flags);
926 return 0;
927 }
928
Mike Frysinger332824b2010-06-02 04:22:01 +0000929 if (unlikely(is_reserved(special_gpio, gpio, 1))) {
Michael Hennerich621dd242009-09-28 12:23:41 +0000930 local_irq_restore_hw(flags);
931 printk(KERN_ERR "bfin-gpio: GPIO %d is already reserved by %s !\n",
932 gpio, get_label(gpio));
933
934 return -EBUSY;
935 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000936 if (unlikely(is_reserved(peri, gpio, 1))) {
Michael Hennerich621dd242009-09-28 12:23:41 +0000937 local_irq_restore_hw(flags);
938 printk(KERN_ERR
939 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
940 gpio, get_label(gpio));
941
942 return -EBUSY;
943 }
944
Mike Frysinger332824b2010-06-02 04:22:01 +0000945 reserve(special_gpio, gpio);
946 reserve(peri, gpio);
Michael Hennerich621dd242009-09-28 12:23:41 +0000947
948 set_label(gpio, label);
949 local_irq_restore_hw(flags);
950 port_setup(gpio, GPIO_USAGE);
951
952 return 0;
953}
954EXPORT_SYMBOL(bfin_special_gpio_request);
955
956void bfin_special_gpio_free(unsigned gpio)
957{
958 unsigned long flags;
959
960 might_sleep();
961
962 local_irq_save_hw(flags);
963
Mike Frysinger332824b2010-06-02 04:22:01 +0000964 if (unlikely(!is_reserved(special_gpio, gpio, 0))) {
Michael Hennerich621dd242009-09-28 12:23:41 +0000965 gpio_error(gpio);
966 local_irq_restore_hw(flags);
967 return;
968 }
969
Mike Frysinger332824b2010-06-02 04:22:01 +0000970 unreserve(special_gpio, gpio);
971 unreserve(peri, gpio);
Michael Hennerich621dd242009-09-28 12:23:41 +0000972 set_label(gpio, "free");
973 local_irq_restore_hw(flags);
974}
975EXPORT_SYMBOL(bfin_special_gpio_free);
976#endif
977
978
Graf Yang9570ff42009-01-07 23:14:38 +0800979int bfin_gpio_irq_request(unsigned gpio, const char *label)
980{
981 unsigned long flags;
982
983 if (check_gpio(gpio) < 0)
984 return -EINVAL;
985
Yi Li6a01f232009-01-07 23:14:39 +0800986 local_irq_save_hw(flags);
Graf Yang9570ff42009-01-07 23:14:38 +0800987
Mike Frysinger332824b2010-06-02 04:22:01 +0000988 if (unlikely(is_reserved(peri, gpio, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800989 if (system_state == SYSTEM_BOOTING)
990 dump_stack();
Graf Yang9570ff42009-01-07 23:14:38 +0800991 printk(KERN_ERR
992 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
993 gpio, get_label(gpio));
Yi Li6a01f232009-01-07 23:14:39 +0800994 local_irq_restore_hw(flags);
Graf Yang9570ff42009-01-07 23:14:38 +0800995 return -EBUSY;
996 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000997 if (unlikely(is_reserved(gpio, gpio, 1)))
Graf Yang9570ff42009-01-07 23:14:38 +0800998 printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved by %s! "
999 "(Documentation/blackfin/bfin-gpio-notes.txt)\n",
1000 gpio, get_label(gpio));
1001
Mike Frysinger332824b2010-06-02 04:22:01 +00001002 reserve(gpio_irq, gpio);
Graf Yang9570ff42009-01-07 23:14:38 +08001003 set_label(gpio, label);
1004
Yi Li6a01f232009-01-07 23:14:39 +08001005 local_irq_restore_hw(flags);
Graf Yang9570ff42009-01-07 23:14:38 +08001006
1007 port_setup(gpio, GPIO_USAGE);
1008
1009 return 0;
1010}
1011
1012void bfin_gpio_irq_free(unsigned gpio)
1013{
1014 unsigned long flags;
1015
1016 if (check_gpio(gpio) < 0)
1017 return;
1018
Yi Li6a01f232009-01-07 23:14:39 +08001019 local_irq_save_hw(flags);
Graf Yang9570ff42009-01-07 23:14:38 +08001020
Mike Frysinger332824b2010-06-02 04:22:01 +00001021 if (unlikely(!is_reserved(gpio_irq, gpio, 0))) {
Robin Getzd6879c52009-03-29 01:10:30 +08001022 if (system_state == SYSTEM_BOOTING)
1023 dump_stack();
Graf Yang9570ff42009-01-07 23:14:38 +08001024 gpio_error(gpio);
Yi Li6a01f232009-01-07 23:14:39 +08001025 local_irq_restore_hw(flags);
Graf Yang9570ff42009-01-07 23:14:38 +08001026 return;
1027 }
1028
Mike Frysinger332824b2010-06-02 04:22:01 +00001029 unreserve(gpio_irq, gpio);
Graf Yang9570ff42009-01-07 23:14:38 +08001030
1031 set_label(gpio, "free");
1032
Yi Li6a01f232009-01-07 23:14:39 +08001033 local_irq_restore_hw(flags);
Graf Yang9570ff42009-01-07 23:14:38 +08001034}
1035
Mike Frysingerf5563092009-02-04 16:49:45 +08001036static inline void __bfin_gpio_direction_input(unsigned gpio)
1037{
Mike Frysinger269647d2009-03-28 20:32:57 +08001038#ifdef CONFIG_BF54x
Mike Frysingerf5563092009-02-04 16:49:45 +08001039 gpio_array[gpio_bank(gpio)]->dir_clear = gpio_bit(gpio);
Michael Hennerichd2b11a42007-08-28 16:47:46 +08001040#else
Mike Frysingerf5563092009-02-04 16:49:45 +08001041 gpio_array[gpio_bank(gpio)]->dir &= ~gpio_bit(gpio);
1042#endif
1043 gpio_array[gpio_bank(gpio)]->inen |= gpio_bit(gpio);
Michael Hennerich803a8d22008-05-17 16:01:51 +08001044}
Michael Hennerich803a8d22008-05-17 16:01:51 +08001045
Michael Hennericha4f0b322008-11-18 17:48:22 +08001046int bfin_gpio_direction_input(unsigned gpio)
Bryan Wu1394f032007-05-06 14:50:22 -07001047{
1048 unsigned long flags;
1049
Mike Frysinger332824b2010-06-02 04:22:01 +00001050 if (unlikely(!is_reserved(gpio, gpio, 0))) {
Michael Hennerichacbcd262008-01-22 18:36:20 +08001051 gpio_error(gpio);
1052 return -EINVAL;
1053 }
Bryan Wu1394f032007-05-06 14:50:22 -07001054
Yi Li6a01f232009-01-07 23:14:39 +08001055 local_irq_save_hw(flags);
Mike Frysingerf5563092009-02-04 16:49:45 +08001056 __bfin_gpio_direction_input(gpio);
Michael Hennerich2b393312007-10-10 16:58:49 +08001057 AWA_DUMMY_READ(inen);
Yi Li6a01f232009-01-07 23:14:39 +08001058 local_irq_restore_hw(flags);
Michael Hennerichacbcd262008-01-22 18:36:20 +08001059
1060 return 0;
Bryan Wu1394f032007-05-06 14:50:22 -07001061}
Michael Hennericha4f0b322008-11-18 17:48:22 +08001062EXPORT_SYMBOL(bfin_gpio_direction_input);
Bryan Wu1394f032007-05-06 14:50:22 -07001063
Mike Frysingerf5563092009-02-04 16:49:45 +08001064void bfin_gpio_irq_prepare(unsigned gpio)
1065{
Mike Frysinger269647d2009-03-28 20:32:57 +08001066#ifdef CONFIG_BF54x
Mike Frysingerf5563092009-02-04 16:49:45 +08001067 unsigned long flags;
1068#endif
1069
1070 port_setup(gpio, GPIO_USAGE);
1071
Mike Frysinger269647d2009-03-28 20:32:57 +08001072#ifdef CONFIG_BF54x
Mike Frysingerf5563092009-02-04 16:49:45 +08001073 local_irq_save_hw(flags);
1074 __bfin_gpio_direction_input(gpio);
1075 local_irq_restore_hw(flags);
1076#endif
1077}
1078
1079void bfin_gpio_set_value(unsigned gpio, int arg)
1080{
1081 if (arg)
1082 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
1083 else
1084 gpio_array[gpio_bank(gpio)]->data_clear = gpio_bit(gpio);
1085}
1086EXPORT_SYMBOL(bfin_gpio_set_value);
1087
Michael Hennericha4f0b322008-11-18 17:48:22 +08001088int bfin_gpio_direction_output(unsigned gpio, int value)
Bryan Wu1394f032007-05-06 14:50:22 -07001089{
1090 unsigned long flags;
1091
Mike Frysinger332824b2010-06-02 04:22:01 +00001092 if (unlikely(!is_reserved(gpio, gpio, 0))) {
Michael Hennerichacbcd262008-01-22 18:36:20 +08001093 gpio_error(gpio);
1094 return -EINVAL;
1095 }
Bryan Wu1394f032007-05-06 14:50:22 -07001096
Yi Li6a01f232009-01-07 23:14:39 +08001097 local_irq_save_hw(flags);
Michael Hennericha2c8cfe2008-01-22 17:20:10 +08001098
Mike Frysingerf5563092009-02-04 16:49:45 +08001099 gpio_array[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio);
1100 gpio_set_value(gpio, value);
Mike Frysinger269647d2009-03-28 20:32:57 +08001101#ifdef CONFIG_BF54x
Mike Frysingerf5563092009-02-04 16:49:45 +08001102 gpio_array[gpio_bank(gpio)]->dir_set = gpio_bit(gpio);
1103#else
1104 gpio_array[gpio_bank(gpio)]->dir |= gpio_bit(gpio);
1105#endif
Michael Hennericha2c8cfe2008-01-22 17:20:10 +08001106
Michael Hennerich2b393312007-10-10 16:58:49 +08001107 AWA_DUMMY_READ(dir);
Yi Li6a01f232009-01-07 23:14:39 +08001108 local_irq_restore_hw(flags);
Michael Hennerichacbcd262008-01-22 18:36:20 +08001109
1110 return 0;
Bryan Wu1394f032007-05-06 14:50:22 -07001111}
Michael Hennericha4f0b322008-11-18 17:48:22 +08001112EXPORT_SYMBOL(bfin_gpio_direction_output);
Mike Frysinger168f1212007-10-11 00:22:35 +08001113
Mike Frysingerf5563092009-02-04 16:49:45 +08001114int bfin_gpio_get_value(unsigned gpio)
1115{
Mike Frysinger269647d2009-03-28 20:32:57 +08001116#ifdef CONFIG_BF54x
Mike Frysingerf5563092009-02-04 16:49:45 +08001117 return (1 & (gpio_array[gpio_bank(gpio)]->data >> gpio_sub_n(gpio)));
1118#else
1119 unsigned long flags;
1120
1121 if (unlikely(get_gpio_edge(gpio))) {
1122 int ret;
1123 local_irq_save_hw(flags);
1124 set_gpio_edge(gpio, 0);
1125 ret = get_gpio_data(gpio);
1126 set_gpio_edge(gpio, 1);
1127 local_irq_restore_hw(flags);
1128 return ret;
1129 } else
1130 return get_gpio_data(gpio);
1131#endif
1132}
1133EXPORT_SYMBOL(bfin_gpio_get_value);
1134
Mike Frysinger168f1212007-10-11 00:22:35 +08001135/* If we are booting from SPI and our board lacks a strong enough pull up,
1136 * the core can reset and execute the bootrom faster than the resistor can
1137 * pull the signal logically high. To work around this (common) error in
1138 * board design, we explicitly set the pin back to GPIO mode, force /CS
1139 * high, and wait for the electrons to do their thing.
1140 *
1141 * This function only makes sense to be called from reset code, but it
1142 * lives here as we need to force all the GPIO states w/out going through
1143 * BUG() checks and such.
1144 */
Sonic Zhangb52dae32009-02-04 16:49:45 +08001145void bfin_reset_boot_spi_cs(unsigned short pin)
Mike Frysinger168f1212007-10-11 00:22:35 +08001146{
Sonic Zhangb52dae32009-02-04 16:49:45 +08001147 unsigned short gpio = P_IDENT(pin);
Michael Hennerich4d5f4ed2007-08-27 16:46:17 +08001148 port_setup(gpio, GPIO_USAGE);
Mike Frysingerf5563092009-02-04 16:49:45 +08001149 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
Michael Hennericha2c8cfe2008-01-22 17:20:10 +08001150 AWA_DUMMY_READ(data_set);
Mike Frysinger168f1212007-10-11 00:22:35 +08001151 udelay(1);
1152}
Michael Hennerichd2b11a42007-08-28 16:47:46 +08001153
Mike Frysinger1545a112007-12-24 16:54:48 +08001154#if defined(CONFIG_PROC_FS)
1155static int gpio_proc_read(char *buf, char **start, off_t offset,
1156 int len, int *unused_i, void *unused_v)
1157{
Graf Yang9570ff42009-01-07 23:14:38 +08001158 int c, irq, gpio, outlen = 0;
Mike Frysinger1545a112007-12-24 16:54:48 +08001159
1160 for (c = 0; c < MAX_RESOURCES; c++) {
Mike Frysinger332824b2010-06-02 04:22:01 +00001161 irq = is_reserved(gpio_irq, c, 1);
1162 gpio = is_reserved(gpio, c, 1);
Graf Yang9570ff42009-01-07 23:14:38 +08001163 if (!check_gpio(c) && (gpio || irq))
1164 len = sprintf(buf, "GPIO_%d: \t%s%s \t\tGPIO %s\n", c,
1165 get_label(c), (gpio && irq) ? " *" : "",
1166 get_gpio_dir(c) ? "OUTPUT" : "INPUT");
Mike Frysinger332824b2010-06-02 04:22:01 +00001167 else if (is_reserved(peri, c, 1))
Graf Yang8eb3e3b2008-11-18 17:48:22 +08001168 len = sprintf(buf, "GPIO_%d: \t%s \t\tPeripheral\n", c, get_label(c));
Mike Frysinger1545a112007-12-24 16:54:48 +08001169 else
1170 continue;
1171 buf += len;
1172 outlen += len;
1173 }
1174 return outlen;
1175}
1176
1177static __init int gpio_register_proc(void)
1178{
1179 struct proc_dir_entry *proc_gpio;
1180
1181 proc_gpio = create_proc_entry("gpio", S_IRUGO, NULL);
1182 if (proc_gpio)
1183 proc_gpio->read_proc = gpio_proc_read;
1184 return proc_gpio != NULL;
1185}
Mike Frysinger1545a112007-12-24 16:54:48 +08001186__initcall(gpio_register_proc);
1187#endif
Michael Hennericha4f0b322008-11-18 17:48:22 +08001188
1189#ifdef CONFIG_GPIOLIB
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001190static int bfin_gpiolib_direction_input(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b322008-11-18 17:48:22 +08001191{
1192 return bfin_gpio_direction_input(gpio);
1193}
1194
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001195static int bfin_gpiolib_direction_output(struct gpio_chip *chip, unsigned gpio, int level)
Michael Hennericha4f0b322008-11-18 17:48:22 +08001196{
1197 return bfin_gpio_direction_output(gpio, level);
1198}
1199
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001200static int bfin_gpiolib_get_value(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b322008-11-18 17:48:22 +08001201{
1202 return bfin_gpio_get_value(gpio);
1203}
1204
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001205static void bfin_gpiolib_set_value(struct gpio_chip *chip, unsigned gpio, int value)
Michael Hennericha4f0b322008-11-18 17:48:22 +08001206{
Michael Hennericha4f0b322008-11-18 17:48:22 +08001207 return bfin_gpio_set_value(gpio, value);
Michael Hennericha4f0b322008-11-18 17:48:22 +08001208}
1209
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001210static int bfin_gpiolib_gpio_request(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b322008-11-18 17:48:22 +08001211{
1212 return bfin_gpio_request(gpio, chip->label);
1213}
1214
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001215static void bfin_gpiolib_gpio_free(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b322008-11-18 17:48:22 +08001216{
1217 return bfin_gpio_free(gpio);
1218}
1219
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001220static int bfin_gpiolib_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
Joachim Eastwood7f4f69f2010-02-10 12:31:41 +01001221{
1222 return gpio + GPIO_IRQ_BASE;
1223}
1224
Michael Hennericha4f0b322008-11-18 17:48:22 +08001225static struct gpio_chip bfin_chip = {
Michael Hennerichedd07992009-12-16 08:45:17 +00001226 .label = "BFIN-GPIO",
Michael Hennericha4f0b322008-11-18 17:48:22 +08001227 .direction_input = bfin_gpiolib_direction_input,
1228 .get = bfin_gpiolib_get_value,
1229 .direction_output = bfin_gpiolib_direction_output,
1230 .set = bfin_gpiolib_set_value,
1231 .request = bfin_gpiolib_gpio_request,
1232 .free = bfin_gpiolib_gpio_free,
Joachim Eastwood7f4f69f2010-02-10 12:31:41 +01001233 .to_irq = bfin_gpiolib_gpio_to_irq,
Michael Hennericha4f0b322008-11-18 17:48:22 +08001234 .base = 0,
1235 .ngpio = MAX_BLACKFIN_GPIOS,
1236};
1237
1238static int __init bfin_gpiolib_setup(void)
1239{
1240 return gpiochip_add(&bfin_chip);
1241}
1242arch_initcall(bfin_gpiolib_setup);
1243#endif