blob: c5d31287de0153587e9c5cce99f59b7a5d82c0c0 [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 *
steven miao05bbec32010-09-17 03:03:17 +00004 * Copyright 2006-2010 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 Frysinger168f12122007-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>
Alexey Dobriyan6362ec272011-05-14 19:48:46 +030013#include <linux/seq_file.h>
Linus Walleij03be35d2015-12-08 13:54:10 +010014#include <linux/gpio/driver.h>
15/* FIXME: consumer API required for gpio_set_value() etc, get rid of this */
Sonic Zhang54e4ff42013-05-30 18:37:28 +080016#include <linux/gpio.h>
Bryan Wu1394f032007-05-06 14:50:22 -070017#include <linux/irq.h>
18
Michael Hennerich2b393312007-10-10 16:58:49 +080019#if ANOMALY_05000311 || ANOMALY_05000323
20enum {
21 AWA_data = SYSCR,
22 AWA_data_clear = SYSCR,
23 AWA_data_set = SYSCR,
24 AWA_toggle = SYSCR,
Graf Yang6ed83942008-04-24 04:43:14 +080025 AWA_maska = BFIN_UART_SCR,
26 AWA_maska_clear = BFIN_UART_SCR,
27 AWA_maska_set = BFIN_UART_SCR,
28 AWA_maska_toggle = BFIN_UART_SCR,
29 AWA_maskb = BFIN_UART_GCTL,
30 AWA_maskb_clear = BFIN_UART_GCTL,
31 AWA_maskb_set = BFIN_UART_GCTL,
32 AWA_maskb_toggle = BFIN_UART_GCTL,
Michael Hennerich2b393312007-10-10 16:58:49 +080033 AWA_dir = SPORT1_STAT,
34 AWA_polar = SPORT1_STAT,
35 AWA_edge = SPORT1_STAT,
36 AWA_both = SPORT1_STAT,
37#if ANOMALY_05000311
38 AWA_inen = TIMER_ENABLE,
39#elif ANOMALY_05000323
40 AWA_inen = DMA1_1_CONFIG,
41#endif
42};
43 /* Anomaly Workaround */
44#define AWA_DUMMY_READ(name) bfin_read16(AWA_ ## name)
45#else
46#define AWA_DUMMY_READ(...) do { } while (0)
47#endif
48
Mike Frysingerf5563092009-02-04 16:49:45 +080049static struct gpio_port_t * const gpio_array[] = {
Michael Hennerichdc26aec2008-11-18 17:48:22 +080050#if defined(BF533_FAMILY) || defined(BF538_FAMILY)
Bryan Wu1394f032007-05-06 14:50:22 -070051 (struct gpio_port_t *) FIO_FLAG_D,
Mike Frysinger269647d2009-03-28 20:32:57 +080052#elif defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Bryan Wu1394f032007-05-06 14:50:22 -070053 (struct gpio_port_t *) PORTFIO,
54 (struct gpio_port_t *) PORTGIO,
55 (struct gpio_port_t *) PORTHIO,
Mike Frysingerf5563092009-02-04 16:49:45 +080056#elif defined(BF561_FAMILY)
57 (struct gpio_port_t *) FIO0_FLAG_D,
58 (struct gpio_port_t *) FIO1_FLAG_D,
59 (struct gpio_port_t *) FIO2_FLAG_D,
Mike Frysingerf5563092009-02-04 16:49:45 +080060#else
61# error no gpio arrays defined
62#endif
Bryan Wu1394f032007-05-06 14:50:22 -070063};
64
Mike Frysinger269647d2009-03-28 20:32:57 +080065#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +080066static unsigned short * const port_fer[] = {
Bryan Wu1394f032007-05-06 14:50:22 -070067 (unsigned short *) PORTF_FER,
68 (unsigned short *) PORTG_FER,
69 (unsigned short *) PORTH_FER,
70};
Bryan Wu1394f032007-05-06 14:50:22 -070071
Mike Frysingerf5563092009-02-04 16:49:45 +080072# if !defined(BF537_FAMILY)
73static unsigned short * const port_mux[] = {
Michael Hennerich59003142007-10-21 16:54:27 +080074 (unsigned short *) PORTF_MUX,
75 (unsigned short *) PORTG_MUX,
76 (unsigned short *) PORTH_MUX,
77};
78
79static const
Graf Yang0ce5eaf2009-02-04 16:49:45 +080080u8 pmux_offset[][16] = {
Mike Frysinger269647d2009-03-28 20:32:57 +080081# if defined(CONFIG_BF52x)
Graf Yang0ce5eaf2009-02-04 16:49:45 +080082 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 4, 6, 8, 8, 10, 10 }, /* PORTF */
83 { 0, 0, 0, 0, 0, 2, 2, 4, 4, 6, 8, 10, 10, 10, 12, 12 }, /* PORTG */
84 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 4, 4, 4, 4, 4 }, /* PORTH */
Mike Frysinger269647d2009-03-28 20:32:57 +080085# elif defined(CONFIG_BF51x)
Graf Yang0ce5eaf2009-02-04 16:49:45 +080086 { 0, 2, 2, 2, 2, 2, 2, 4, 6, 6, 6, 8, 8, 8, 8, 10 }, /* PORTF */
87 { 0, 0, 0, 2, 4, 6, 6, 6, 8, 10, 10, 12, 14, 14, 14, 14 }, /* PORTG */
88 { 0, 0, 0, 0, 2, 2, 4, 6, 10, 10, 10, 10, 10, 10, 10, 10 }, /* PORTH */
89# endif
90};
Mike Frysingerf5563092009-02-04 16:49:45 +080091# endif
Graf Yang0ce5eaf2009-02-04 16:49:45 +080092
Michael Hennerich621dd242009-09-28 12:23:41 +000093#elif defined(BF538_FAMILY)
94static unsigned short * const port_fer[] = {
95 (unsigned short *) PORTCIO_FER,
96 (unsigned short *) PORTDIO_FER,
97 (unsigned short *) PORTEIO_FER,
98};
Michael Hennerichd2b11a42007-08-28 16:47:46 +080099#endif
100
Mike Frysinger812ae982010-07-05 08:40:41 +0000101#define RESOURCE_LABEL_SIZE 16
Michael Hennerich8c613622007-08-03 17:48:09 +0800102
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800103static struct str_ident {
Michael Hennerich8c613622007-08-03 17:48:09 +0800104 char name[RESOURCE_LABEL_SIZE];
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800105} str_ident[MAX_RESOURCES];
Bryan Wu1394f032007-05-06 14:50:22 -0700106
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800107#if defined(CONFIG_PM)
Bryan Wu397861c2008-11-18 17:48:22 +0800108static struct gpio_port_s gpio_bank_saved[GPIO_BANK_NUM];
Mike Frysinger9466a052011-06-27 14:46:14 -0400109# ifdef BF538_FAMILY
110static unsigned short port_fer_saved[3];
111# endif
Bryan Wu1394f032007-05-06 14:50:22 -0700112#endif
113
Mike Frysinger74c04502008-10-08 16:13:17 +0800114static void gpio_error(unsigned gpio)
Michael Hennerichacbcd262008-01-22 18:36:20 +0800115{
116 printk(KERN_ERR "bfin-gpio: GPIO %d wasn't requested!\n", gpio);
117}
118
Michael Hennerichc58c2142007-10-04 00:35:05 +0800119static void set_label(unsigned short ident, const char *label)
120{
Michael Henneriche9fae182008-10-13 11:35:22 +0800121 if (label) {
Michael Hennerich8c613622007-08-03 17:48:09 +0800122 strncpy(str_ident[ident].name, label,
Michael Hennerichc58c2142007-10-04 00:35:05 +0800123 RESOURCE_LABEL_SIZE);
Michael Hennerich8c613622007-08-03 17:48:09 +0800124 str_ident[ident].name[RESOURCE_LABEL_SIZE - 1] = 0;
Michael Hennerichc58c2142007-10-04 00:35:05 +0800125 }
126}
127
128static char *get_label(unsigned short ident)
129{
Michael Hennerich8c613622007-08-03 17:48:09 +0800130 return (*str_ident[ident].name ? str_ident[ident].name : "UNKNOWN");
Michael Hennerichc58c2142007-10-04 00:35:05 +0800131}
132
133static int cmp_label(unsigned short ident, const char *label)
134{
Michael Hennerichfac3cf42007-12-24 20:07:03 +0800135 if (label == NULL) {
136 dump_stack();
137 printk(KERN_ERR "Please provide none-null label\n");
138 }
139
Michael Henneriche9fae182008-10-13 11:35:22 +0800140 if (label)
Mike Frysinger1f7d3732008-10-28 15:47:11 +0800141 return strcmp(str_ident[ident].name, label);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800142 else
143 return -EINVAL;
144}
145
Mike Frysinger332824b2010-06-02 04:22:01 +0000146#define map_entry(m, i) reserved_##m##_map[gpio_bank(i)]
147#define is_reserved(m, i, e) (map_entry(m, i) & gpio_bit(i))
148#define reserve(m, i) (map_entry(m, i) |= gpio_bit(i))
149#define unreserve(m, i) (map_entry(m, i) &= ~gpio_bit(i))
150#define DECLARE_RESERVED_MAP(m, c) static unsigned short reserved_##m##_map[c]
151
152DECLARE_RESERVED_MAP(gpio, GPIO_BANK_NUM);
Michael Hennerich382dbe52010-07-13 08:26:10 +0000153DECLARE_RESERVED_MAP(peri, DIV_ROUND_UP(MAX_RESOURCES, GPIO_BANKSIZE));
Mike Frysinger332824b2010-06-02 04:22:01 +0000154DECLARE_RESERVED_MAP(gpio_irq, GPIO_BANK_NUM);
155
156inline int check_gpio(unsigned gpio)
157{
Mike Frysinger332824b2010-06-02 04:22:01 +0000158 if (gpio >= MAX_BLACKFIN_GPIOS)
159 return -EINVAL;
160 return 0;
161}
162
Mike Frysingera2d03a12008-10-28 15:53:37 +0800163static void port_setup(unsigned gpio, unsigned short usage)
164{
Michael Hennerich621dd242009-09-28 12:23:41 +0000165#if defined(BF538_FAMILY)
166 /*
167 * BF538/9 Port C,D and E are special.
168 * Inverted PORT_FER polarity on CDE and no PORF_FER on F
169 * Regular PORT F GPIOs are handled here, CDE are exclusively
170 * managed by GPIOLIB
171 */
172
173 if (gpio < MAX_BLACKFIN_GPIOS || gpio >= MAX_RESOURCES)
174 return;
175
176 gpio -= MAX_BLACKFIN_GPIOS;
177
178 if (usage == GPIO_USAGE)
179 *port_fer[gpio_bank(gpio)] |= gpio_bit(gpio);
180 else
181 *port_fer[gpio_bank(gpio)] &= ~gpio_bit(gpio);
182 SSYNC();
183 return;
184#endif
185
Mike Frysingera2d03a12008-10-28 15:53:37 +0800186 if (check_gpio(gpio))
187 return;
188
Mike Frysinger269647d2009-03-28 20:32:57 +0800189#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Mike Frysingera2d03a12008-10-28 15:53:37 +0800190 if (usage == GPIO_USAGE)
191 *port_fer[gpio_bank(gpio)] &= ~gpio_bit(gpio);
192 else
193 *port_fer[gpio_bank(gpio)] |= gpio_bit(gpio);
194 SSYNC();
Bryan Wu1394f032007-05-06 14:50:22 -0700195#endif
Mike Frysingera2d03a12008-10-28 15:53:37 +0800196}
Bryan Wu1394f032007-05-06 14:50:22 -0700197
Michael Hennerichc58c2142007-10-04 00:35:05 +0800198#ifdef BF537_FAMILY
steven miao05bbec32010-09-17 03:03:17 +0000199static const s8 port_mux[] = {
200 [GPIO_PF0] = 3,
201 [GPIO_PF1] = 3,
202 [GPIO_PF2] = 4,
203 [GPIO_PF3] = 4,
204 [GPIO_PF4] = 5,
205 [GPIO_PF5] = 6,
206 [GPIO_PF6] = 7,
207 [GPIO_PF7] = 8,
208 [GPIO_PF8 ... GPIO_PF15] = -1,
209 [GPIO_PG0 ... GPIO_PG7] = -1,
210 [GPIO_PG8] = 9,
211 [GPIO_PG9] = 9,
212 [GPIO_PG10] = 10,
213 [GPIO_PG11] = 10,
214 [GPIO_PG12] = 10,
215 [GPIO_PG13] = 11,
216 [GPIO_PG14] = 11,
217 [GPIO_PG15] = 11,
218 [GPIO_PH0 ... GPIO_PH15] = -1,
219 [PORT_PJ0 ... PORT_PJ3] = -1,
220 [PORT_PJ4] = 1,
221 [PORT_PJ5] = 1,
222 [PORT_PJ6 ... PORT_PJ9] = -1,
223 [PORT_PJ10] = 0,
224 [PORT_PJ11] = 0,
Michael Hennerichc58c2142007-10-04 00:35:05 +0800225};
226
steven miao05bbec32010-09-17 03:03:17 +0000227static int portmux_group_check(unsigned short per)
228{
229 u16 ident = P_IDENT(per);
230 u16 function = P_FUNCT2MUX(per);
231 s8 offset = port_mux[ident];
Sonic Zhangf70de482013-07-01 11:24:46 +0800232 u16 m, pmux, pfunc, mask;
steven miao05bbec32010-09-17 03:03:17 +0000233
234 if (offset < 0)
235 return 0;
236
237 pmux = bfin_read_PORT_MUX();
238 for (m = 0; m < ARRAY_SIZE(port_mux); ++m) {
239 if (m == ident)
240 continue;
241 if (port_mux[m] != offset)
242 continue;
243 if (!is_reserved(peri, m, 1))
244 continue;
245
246 if (offset == 1)
Sonic Zhangf70de482013-07-01 11:24:46 +0800247 mask = 3;
steven miao05bbec32010-09-17 03:03:17 +0000248 else
Sonic Zhangf70de482013-07-01 11:24:46 +0800249 mask = 1;
250
251 pfunc = (pmux >> offset) & mask;
252 if (pfunc != (function & mask)) {
steven miao05bbec32010-09-17 03:03:17 +0000253 pr_err("pin group conflict! request pin %d func %d conflict with pin %d func %d\n",
254 ident, function, m, pfunc);
255 return -EINVAL;
256 }
257 }
258
259 return 0;
260}
261
Mike Frysingerf5563092009-02-04 16:49:45 +0800262static void portmux_setup(unsigned short per)
Michael Hennerichc58c2142007-10-04 00:35:05 +0800263{
steven miao05bbec32010-09-17 03:03:17 +0000264 u16 ident = P_IDENT(per);
Mike Frysingerf5563092009-02-04 16:49:45 +0800265 u16 function = P_FUNCT2MUX(per);
steven miao05bbec32010-09-17 03:03:17 +0000266 s8 offset = port_mux[ident];
Sonic Zhangf70de482013-07-01 11:24:46 +0800267 u16 pmux, mask;
Michael Hennerichc58c2142007-10-04 00:35:05 +0800268
steven miao05bbec32010-09-17 03:03:17 +0000269 if (offset == -1)
270 return;
Michael Hennerichc58c2142007-10-04 00:35:05 +0800271
steven miao05bbec32010-09-17 03:03:17 +0000272 pmux = bfin_read_PORT_MUX();
Sonic Zhangf70de482013-07-01 11:24:46 +0800273 if (offset == 1)
274 mask = 3;
steven miao05bbec32010-09-17 03:03:17 +0000275 else
Sonic Zhangf70de482013-07-01 11:24:46 +0800276 mask = 1;
277
278 pmux &= ~(mask << offset);
279 pmux |= ((function & mask) << offset);
280
steven miao05bbec32010-09-17 03:03:17 +0000281 bfin_write_PORT_MUX(pmux);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800282}
Mike Frysinger269647d2009-03-28 20:32:57 +0800283#elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
steven miao05bbec32010-09-17 03:03:17 +0000284static int portmux_group_check(unsigned short per)
285{
286 u16 ident = P_IDENT(per);
287 u16 function = P_FUNCT2MUX(per);
288 u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
289 u16 pin, gpiopin, pfunc;
290
291 for (pin = 0; pin < GPIO_BANKSIZE; ++pin) {
292 if (offset != pmux_offset[gpio_bank(ident)][pin])
293 continue;
294
295 gpiopin = gpio_bank(ident) * GPIO_BANKSIZE + pin;
296 if (gpiopin == ident)
297 continue;
298 if (!is_reserved(peri, gpiopin, 1))
299 continue;
300
301 pfunc = *port_mux[gpio_bank(ident)];
302 pfunc = (pfunc >> offset) & 3;
303 if (pfunc != function) {
304 pr_err("pin group conflict! request pin %d func %d conflict with pin %d func %d\n",
305 ident, function, gpiopin, pfunc);
306 return -EINVAL;
307 }
308 }
309
310 return 0;
311}
312
Mike Frysingerf5563092009-02-04 16:49:45 +0800313inline void portmux_setup(unsigned short per)
Michael Hennerich59003142007-10-21 16:54:27 +0800314{
steven miao05bbec32010-09-17 03:03:17 +0000315 u16 ident = P_IDENT(per);
316 u16 function = P_FUNCT2MUX(per);
Michael Hennerich59003142007-10-21 16:54:27 +0800317 u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
steven miao05bbec32010-09-17 03:03:17 +0000318 u16 pmux;
Michael Hennerich59003142007-10-21 16:54:27 +0800319
320 pmux = *port_mux[gpio_bank(ident)];
steven miao05bbec32010-09-17 03:03:17 +0000321 if (((pmux >> offset) & 3) == function)
322 return;
Michael Hennerich59003142007-10-21 16:54:27 +0800323 pmux &= ~(3 << offset);
324 pmux |= (function & 3) << offset;
325 *port_mux[gpio_bank(ident)] = pmux;
326 SSYNC();
327}
Michael Hennerichc58c2142007-10-04 00:35:05 +0800328#else
329# define portmux_setup(...) do { } while (0)
steven miao05bbec32010-09-17 03:03:17 +0000330static int portmux_group_check(unsigned short per)
331{
332 return 0;
333}
Michael Hennerichc58c2142007-10-04 00:35:05 +0800334#endif
Bryan Wu1394f032007-05-06 14:50:22 -0700335
Bryan Wu1394f032007-05-06 14:50:22 -0700336/***********************************************************
337*
338* FUNCTIONS: Blackfin General Purpose Ports Access Functions
339*
340* INPUTS/OUTPUTS:
341* gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
342*
343*
344* DESCRIPTION: These functions abstract direct register access
345* to Blackfin processor General Purpose
346* Ports Regsiters
347*
348* CAUTION: These functions do not belong to the GPIO Driver API
349*************************************************************
350* MODIFICATION HISTORY :
351**************************************************************/
352
353/* Set a specific bit */
354
355#define SET_GPIO(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800356void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
Bryan Wu1394f032007-05-06 14:50:22 -0700357{ \
358 unsigned long flags; \
David Howells3b139cd2010-10-07 14:08:52 +0100359 flags = hard_local_irq_save(); \
Bryan Wu1394f032007-05-06 14:50:22 -0700360 if (arg) \
Mike Frysingerf5563092009-02-04 16:49:45 +0800361 gpio_array[gpio_bank(gpio)]->name |= gpio_bit(gpio); \
Bryan Wu1394f032007-05-06 14:50:22 -0700362 else \
Mike Frysingerf5563092009-02-04 16:49:45 +0800363 gpio_array[gpio_bank(gpio)]->name &= ~gpio_bit(gpio); \
Michael Hennerich2b393312007-10-10 16:58:49 +0800364 AWA_DUMMY_READ(name); \
David Howells3b139cd2010-10-07 14:08:52 +0100365 hard_local_irq_restore(flags); \
Bryan Wu1394f032007-05-06 14:50:22 -0700366} \
367EXPORT_SYMBOL(set_gpio_ ## name);
368
Mike Frysingerf5563092009-02-04 16:49:45 +0800369SET_GPIO(dir) /* set_gpio_dir() */
370SET_GPIO(inen) /* set_gpio_inen() */
371SET_GPIO(polar) /* set_gpio_polar() */
372SET_GPIO(edge) /* set_gpio_edge() */
373SET_GPIO(both) /* set_gpio_both() */
Bryan Wu1394f032007-05-06 14:50:22 -0700374
375
Michael Hennerich2b393312007-10-10 16:58:49 +0800376#define SET_GPIO_SC(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800377void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800378{ \
379 unsigned long flags; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800380 if (ANOMALY_05000311 || ANOMALY_05000323) \
David Howells3b139cd2010-10-07 14:08:52 +0100381 flags = hard_local_irq_save(); \
Michael Hennerich2b393312007-10-10 16:58:49 +0800382 if (arg) \
Mike Frysingerf5563092009-02-04 16:49:45 +0800383 gpio_array[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
Michael Hennerich2b393312007-10-10 16:58:49 +0800384 else \
Mike Frysingerf5563092009-02-04 16:49:45 +0800385 gpio_array[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
386 if (ANOMALY_05000311 || ANOMALY_05000323) { \
387 AWA_DUMMY_READ(name); \
David Howells3b139cd2010-10-07 14:08:52 +0100388 hard_local_irq_restore(flags); \
Mike Frysingerf5563092009-02-04 16:49:45 +0800389 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800390} \
391EXPORT_SYMBOL(set_gpio_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700392
393SET_GPIO_SC(maska)
394SET_GPIO_SC(maskb)
Bryan Wu1394f032007-05-06 14:50:22 -0700395SET_GPIO_SC(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700396
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800397void set_gpio_toggle(unsigned gpio)
Bryan Wu1394f032007-05-06 14:50:22 -0700398{
399 unsigned long flags;
Mike Frysingerf5563092009-02-04 16:49:45 +0800400 if (ANOMALY_05000311 || ANOMALY_05000323)
David Howells3b139cd2010-10-07 14:08:52 +0100401 flags = hard_local_irq_save();
Mike Frysingerf5563092009-02-04 16:49:45 +0800402 gpio_array[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
403 if (ANOMALY_05000311 || ANOMALY_05000323) {
404 AWA_DUMMY_READ(toggle);
David Howells3b139cd2010-10-07 14:08:52 +0100405 hard_local_irq_restore(flags);
Mike Frysingerf5563092009-02-04 16:49:45 +0800406 }
Bryan Wu1394f032007-05-06 14:50:22 -0700407}
Bryan Wu1394f032007-05-06 14:50:22 -0700408EXPORT_SYMBOL(set_gpio_toggle);
409
410
411/*Set current PORT date (16-bit word)*/
412
Michael Hennerich2b393312007-10-10 16:58:49 +0800413#define SET_GPIO_P(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800414void set_gpiop_ ## name(unsigned gpio, unsigned short arg) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800415{ \
416 unsigned long flags; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800417 if (ANOMALY_05000311 || ANOMALY_05000323) \
David Howells3b139cd2010-10-07 14:08:52 +0100418 flags = hard_local_irq_save(); \
Mike Frysingerf5563092009-02-04 16:49:45 +0800419 gpio_array[gpio_bank(gpio)]->name = arg; \
420 if (ANOMALY_05000311 || ANOMALY_05000323) { \
421 AWA_DUMMY_READ(name); \
David Howells3b139cd2010-10-07 14:08:52 +0100422 hard_local_irq_restore(flags); \
Mike Frysingerf5563092009-02-04 16:49:45 +0800423 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800424} \
425EXPORT_SYMBOL(set_gpiop_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700426
Michael Hennerich2b393312007-10-10 16:58:49 +0800427SET_GPIO_P(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700428SET_GPIO_P(dir)
429SET_GPIO_P(inen)
430SET_GPIO_P(polar)
431SET_GPIO_P(edge)
432SET_GPIO_P(both)
433SET_GPIO_P(maska)
434SET_GPIO_P(maskb)
435
Bryan Wu1394f032007-05-06 14:50:22 -0700436/* Get a specific bit */
Michael Hennerich2b393312007-10-10 16:58:49 +0800437#define GET_GPIO(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800438unsigned short get_gpio_ ## name(unsigned gpio) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800439{ \
440 unsigned long flags; \
441 unsigned short ret; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800442 if (ANOMALY_05000311 || ANOMALY_05000323) \
David Howells3b139cd2010-10-07 14:08:52 +0100443 flags = hard_local_irq_save(); \
Mike Frysingerf5563092009-02-04 16:49:45 +0800444 ret = 0x01 & (gpio_array[gpio_bank(gpio)]->name >> gpio_sub_n(gpio)); \
445 if (ANOMALY_05000311 || ANOMALY_05000323) { \
446 AWA_DUMMY_READ(name); \
David Howells3b139cd2010-10-07 14:08:52 +0100447 hard_local_irq_restore(flags); \
Mike Frysingerf5563092009-02-04 16:49:45 +0800448 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800449 return ret; \
450} \
451EXPORT_SYMBOL(get_gpio_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700452
Michael Hennerich2b393312007-10-10 16:58:49 +0800453GET_GPIO(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700454GET_GPIO(dir)
455GET_GPIO(inen)
456GET_GPIO(polar)
457GET_GPIO(edge)
458GET_GPIO(both)
459GET_GPIO(maska)
460GET_GPIO(maskb)
461
Bryan Wu1394f032007-05-06 14:50:22 -0700462/*Get current PORT date (16-bit word)*/
463
Michael Hennerich2b393312007-10-10 16:58:49 +0800464#define GET_GPIO_P(name) \
Michael Hennericha2c8cfe2008-01-22 17:20:10 +0800465unsigned short get_gpiop_ ## name(unsigned gpio) \
Michael Hennerich2b393312007-10-10 16:58:49 +0800466{ \
467 unsigned long flags; \
468 unsigned short ret; \
Mike Frysingerf5563092009-02-04 16:49:45 +0800469 if (ANOMALY_05000311 || ANOMALY_05000323) \
David Howells3b139cd2010-10-07 14:08:52 +0100470 flags = hard_local_irq_save(); \
Mike Frysingerf5563092009-02-04 16:49:45 +0800471 ret = (gpio_array[gpio_bank(gpio)]->name); \
472 if (ANOMALY_05000311 || ANOMALY_05000323) { \
473 AWA_DUMMY_READ(name); \
David Howells3b139cd2010-10-07 14:08:52 +0100474 hard_local_irq_restore(flags); \
Mike Frysingerf5563092009-02-04 16:49:45 +0800475 } \
Michael Hennerich2b393312007-10-10 16:58:49 +0800476 return ret; \
477} \
478EXPORT_SYMBOL(get_gpiop_ ## name);
Bryan Wu1394f032007-05-06 14:50:22 -0700479
Michael Hennerich2b393312007-10-10 16:58:49 +0800480GET_GPIO_P(data)
Bryan Wu1394f032007-05-06 14:50:22 -0700481GET_GPIO_P(dir)
482GET_GPIO_P(inen)
483GET_GPIO_P(polar)
484GET_GPIO_P(edge)
485GET_GPIO_P(both)
486GET_GPIO_P(maska)
487GET_GPIO_P(maskb)
488
Bryan Wu1394f032007-05-06 14:50:22 -0700489
490#ifdef CONFIG_PM
Mike Frysinger332824b2010-06-02 04:22:01 +0000491DECLARE_RESERVED_MAP(wakeup, GPIO_BANK_NUM);
Mike Frysingerf5563092009-02-04 16:49:45 +0800492
493static const unsigned int sic_iwr_irqs[] = {
494#if defined(BF533_FAMILY)
495 IRQ_PROG_INTB
496#elif defined(BF537_FAMILY)
Mike Frysinger8c054102011-04-15 13:04:59 -0400497 IRQ_PF_INTB_WATCH, IRQ_PORTG_INTB, IRQ_PH_INTB_MAC_TX
Mike Frysingerf5563092009-02-04 16:49:45 +0800498#elif defined(BF538_FAMILY)
499 IRQ_PORTF_INTB
Mike Frysinger269647d2009-03-28 20:32:57 +0800500#elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800501 IRQ_PORTF_INTB, IRQ_PORTG_INTB, IRQ_PORTH_INTB
502#elif defined(BF561_FAMILY)
503 IRQ_PROG0_INTB, IRQ_PROG1_INTB, IRQ_PROG2_INTB
504#else
505# error no SIC_IWR defined
506#endif
507};
508
Bryan Wu1394f032007-05-06 14:50:22 -0700509/***********************************************************
510*
511* FUNCTIONS: Blackfin PM Setup API
512*
513* INPUTS/OUTPUTS:
514* gpio - GPIO Number between 0 and MAX_BLACKFIN_GPIOS
515* type -
516* PM_WAKE_RISING
517* PM_WAKE_FALLING
518* PM_WAKE_HIGH
519* PM_WAKE_LOW
520* PM_WAKE_BOTH_EDGES
521*
522* DESCRIPTION: Blackfin PM Driver API
523*
524* CAUTION:
525*************************************************************
526* MODIFICATION HISTORY :
527**************************************************************/
Sonic Zhang54e4ff42013-05-30 18:37:28 +0800528int bfin_gpio_pm_wakeup_ctrl(unsigned gpio, unsigned ctrl)
Bryan Wu1394f032007-05-06 14:50:22 -0700529{
530 unsigned long flags;
531
532 if (check_gpio(gpio) < 0)
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000533 return -EINVAL;
Bryan Wu1394f032007-05-06 14:50:22 -0700534
David Howells3b139cd2010-10-07 14:08:52 +0100535 flags = hard_local_irq_save();
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000536 if (ctrl)
Mike Frysinger332824b2010-06-02 04:22:01 +0000537 reserve(wakeup, gpio);
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000538 else
Mike Frysinger332824b2010-06-02 04:22:01 +0000539 unreserve(wakeup, gpio);
Bryan Wu1394f032007-05-06 14:50:22 -0700540
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000541 set_gpio_maskb(gpio, ctrl);
David Howells3b139cd2010-10-07 14:08:52 +0100542 hard_local_irq_restore(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700543
544 return 0;
545}
546
Sonic Zhang54e4ff42013-05-30 18:37:28 +0800547int bfin_gpio_pm_standby_ctrl(unsigned ctrl)
Bryan Wu1394f032007-05-06 14:50:22 -0700548{
549 u16 bank, mask, i;
550
Mike Frysinger1f83b8f2007-07-12 22:58:21 +0800551 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
Mike Frysinger332824b2010-06-02 04:22:01 +0000552 mask = map_entry(wakeup, i);
Bryan Wu1394f032007-05-06 14:50:22 -0700553 bank = gpio_bank(i);
554
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000555 if (mask)
556 bfin_internal_set_wake(sic_iwr_irqs[bank], ctrl);
Bryan Wu1394f032007-05-06 14:50:22 -0700557 }
Michael Hennerichbb84dbf2010-03-10 14:26:06 +0000558 return 0;
Bryan Wu1394f032007-05-06 14:50:22 -0700559}
560
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800561void bfin_gpio_pm_hibernate_suspend(void)
562{
563 int i, bank;
564
Mike Frysinger9466a052011-06-27 14:46:14 -0400565#ifdef BF538_FAMILY
566 for (i = 0; i < ARRAY_SIZE(port_fer_saved); ++i)
567 port_fer_saved[i] = *port_fer[i];
568#endif
569
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800570 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
571 bank = gpio_bank(i);
572
Mike Frysinger269647d2009-03-28 20:32:57 +0800573#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800574 gpio_bank_saved[bank].fer = *port_fer[bank];
Mike Frysinger269647d2009-03-28 20:32:57 +0800575#if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800576 gpio_bank_saved[bank].mux = *port_mux[bank];
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800577#else
Mike Frysingerf5563092009-02-04 16:49:45 +0800578 if (bank == 0)
579 gpio_bank_saved[bank].mux = bfin_read_PORT_MUX();
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800580#endif
581#endif
Mike Frysingerf5563092009-02-04 16:49:45 +0800582 gpio_bank_saved[bank].data = gpio_array[bank]->data;
583 gpio_bank_saved[bank].inen = gpio_array[bank]->inen;
584 gpio_bank_saved[bank].polar = gpio_array[bank]->polar;
585 gpio_bank_saved[bank].dir = gpio_array[bank]->dir;
586 gpio_bank_saved[bank].edge = gpio_array[bank]->edge;
587 gpio_bank_saved[bank].both = gpio_array[bank]->both;
588 gpio_bank_saved[bank].maska = gpio_array[bank]->maska;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800589 }
590
Mike Frysinger9466a052011-06-27 14:46:14 -0400591#ifdef BFIN_SPECIAL_GPIO_BANKS
592 bfin_special_gpio_pm_hibernate_suspend();
593#endif
594
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800595 AWA_DUMMY_READ(maska);
596}
597
598void bfin_gpio_pm_hibernate_restore(void)
599{
600 int i, bank;
601
Mike Frysinger9466a052011-06-27 14:46:14 -0400602#ifdef BF538_FAMILY
603 for (i = 0; i < ARRAY_SIZE(port_fer_saved); ++i)
604 *port_fer[i] = port_fer_saved[i];
605#endif
606
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800607 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
Mike Frysingerf5563092009-02-04 16:49:45 +0800608 bank = gpio_bank(i);
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800609
Mike Frysinger269647d2009-03-28 20:32:57 +0800610#if defined(CONFIG_BF52x) || defined(BF537_FAMILY) || defined(CONFIG_BF51x)
611#if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
Mike Frysingerf5563092009-02-04 16:49:45 +0800612 *port_mux[bank] = gpio_bank_saved[bank].mux;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800613#else
Mike Frysingerf5563092009-02-04 16:49:45 +0800614 if (bank == 0)
615 bfin_write_PORT_MUX(gpio_bank_saved[bank].mux);
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800616#endif
Mike Frysingerf5563092009-02-04 16:49:45 +0800617 *port_fer[bank] = gpio_bank_saved[bank].fer;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800618#endif
Mike Frysingerf5563092009-02-04 16:49:45 +0800619 gpio_array[bank]->inen = gpio_bank_saved[bank].inen;
Michael Hennerichc03c2a872009-07-08 12:04:43 +0000620 gpio_array[bank]->data_set = gpio_bank_saved[bank].data
621 & gpio_bank_saved[bank].dir;
Mike Frysingerf5563092009-02-04 16:49:45 +0800622 gpio_array[bank]->dir = gpio_bank_saved[bank].dir;
623 gpio_array[bank]->polar = gpio_bank_saved[bank].polar;
624 gpio_array[bank]->edge = gpio_bank_saved[bank].edge;
625 gpio_array[bank]->both = gpio_bank_saved[bank].both;
Mike Frysingerf5563092009-02-04 16:49:45 +0800626 gpio_array[bank]->maska = gpio_bank_saved[bank].maska;
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800627 }
Mike Frysinger9466a052011-06-27 14:46:14 -0400628
629#ifdef BFIN_SPECIAL_GPIO_BANKS
630 bfin_special_gpio_pm_hibernate_restore();
631#endif
632
Michael Hennerich1efc80b2008-07-19 16:57:32 +0800633 AWA_DUMMY_READ(maska);
634}
635
636
Bryan Wu1394f032007-05-06 14:50:22 -0700637#endif
638
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800639/***********************************************************
640*
Mike Frysinger812ae982010-07-05 08:40:41 +0000641* FUNCTIONS: Blackfin Peripheral Resource Allocation
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800642* and PortMux Setup
643*
644* INPUTS/OUTPUTS:
645* per Peripheral Identifier
646* label String
647*
648* DESCRIPTION: Blackfin Peripheral Resource Allocation and Setup API
649*
650* CAUTION:
651*************************************************************
652* MODIFICATION HISTORY :
653**************************************************************/
Michael Hennerichc58c2142007-10-04 00:35:05 +0800654
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800655int peripheral_request(unsigned short per, const char *label)
656{
657 unsigned long flags;
658 unsigned short ident = P_IDENT(per);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800659
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800660 /*
661 * Don't cares are pins with only one dedicated function
662 */
663
664 if (per & P_DONTCARE)
665 return 0;
666
667 if (!(per & P_DEFINED))
668 return -ENODEV;
669
Barry Song89e84ee2009-09-16 04:36:29 +0000670 BUG_ON(ident >= MAX_RESOURCES);
671
David Howells3b139cd2010-10-07 14:08:52 +0100672 flags = hard_local_irq_save();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800673
Mike Frysinger6a87d292008-10-28 16:16:29 +0800674 /* If a pin can be muxed as either GPIO or peripheral, make
675 * sure it is not already a GPIO pin when we request it.
676 */
Mike Frysinger332824b2010-06-02 04:22:01 +0000677 if (unlikely(!check_gpio(ident) && is_reserved(gpio, ident, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800678 if (system_state == SYSTEM_BOOTING)
679 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800680 printk(KERN_ERR
Mike Frysinger6c7ec0e2008-10-28 15:49:59 +0800681 "%s: Peripheral %d is already reserved as GPIO by %s !\n",
Harvey Harrisonb85d8582008-04-23 09:39:01 +0800682 __func__, ident, get_label(ident));
David Howells3b139cd2010-10-07 14:08:52 +0100683 hard_local_irq_restore(flags);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800684 return -EBUSY;
685 }
686
Mike Frysinger332824b2010-06-02 04:22:01 +0000687 if (unlikely(is_reserved(peri, ident, 1))) {
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800688
Mike Frysingerd171c232008-03-26 08:35:46 +0800689 /*
690 * Pin functions like AMC address strobes my
691 * be requested and used by several drivers
692 */
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800693
Mike Frysinger6c7ec0e2008-10-28 15:49:59 +0800694 if (!(per & P_MAYSHARE)) {
Mike Frysingerd171c232008-03-26 08:35:46 +0800695 /*
696 * Allow that the identical pin function can
697 * be requested from the same driver twice
698 */
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800699
Mike Frysingerd171c232008-03-26 08:35:46 +0800700 if (cmp_label(ident, label) == 0)
701 goto anyway;
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800702
Robin Getzd6879c52009-03-29 01:10:30 +0800703 if (system_state == SYSTEM_BOOTING)
704 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800705 printk(KERN_ERR
706 "%s: Peripheral %d function %d is already reserved by %s !\n",
Harvey Harrisonb85d8582008-04-23 09:39:01 +0800707 __func__, ident, P_FUNCT2MUX(per), get_label(ident));
David Howells3b139cd2010-10-07 14:08:52 +0100708 hard_local_irq_restore(flags);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800709 return -EBUSY;
710 }
711 }
712
steven miao05bbec32010-09-17 03:03:17 +0000713 if (unlikely(portmux_group_check(per))) {
714 hard_local_irq_restore(flags);
715 return -EBUSY;
716 }
Mike Frysingerd171c232008-03-26 08:35:46 +0800717 anyway:
Mike Frysinger332824b2010-06-02 04:22:01 +0000718 reserve(peri, ident);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800719
Mike Frysingerf5563092009-02-04 16:49:45 +0800720 portmux_setup(per);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800721 port_setup(ident, PERIPHERAL_USAGE);
722
David Howells3b139cd2010-10-07 14:08:52 +0100723 hard_local_irq_restore(flags);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800724 set_label(ident, label);
725
726 return 0;
727}
728EXPORT_SYMBOL(peripheral_request);
729
Mike Frysinger68179372008-04-24 05:04:24 +0800730int peripheral_request_list(const unsigned short per[], const char *label)
Michael Hennerichc58c2142007-10-04 00:35:05 +0800731{
732 u16 cnt;
733 int ret;
734
735 for (cnt = 0; per[cnt] != 0; cnt++) {
Michael Hennerich314c98d2007-07-24 18:03:45 +0800736
Michael Hennerichc58c2142007-10-04 00:35:05 +0800737 ret = peripheral_request(per[cnt], label);
Michael Hennerich314c98d2007-07-24 18:03:45 +0800738
739 if (ret < 0) {
Mike Frysingerd171c232008-03-26 08:35:46 +0800740 for ( ; cnt > 0; cnt--)
Michael Hennerich314c98d2007-07-24 18:03:45 +0800741 peripheral_free(per[cnt - 1]);
Mike Frysingerd171c232008-03-26 08:35:46 +0800742
743 return ret;
Michael Hennerich314c98d2007-07-24 18:03:45 +0800744 }
Michael Hennerichc58c2142007-10-04 00:35:05 +0800745 }
746
747 return 0;
748}
749EXPORT_SYMBOL(peripheral_request_list);
750
751void peripheral_free(unsigned short per)
752{
753 unsigned long flags;
754 unsigned short ident = P_IDENT(per);
755
756 if (per & P_DONTCARE)
757 return;
758
759 if (!(per & P_DEFINED))
760 return;
761
David Howells3b139cd2010-10-07 14:08:52 +0100762 flags = hard_local_irq_save();
Michael Hennerichc58c2142007-10-04 00:35:05 +0800763
Mike Frysinger332824b2010-06-02 04:22:01 +0000764 if (unlikely(!is_reserved(peri, ident, 0))) {
David Howells3b139cd2010-10-07 14:08:52 +0100765 hard_local_irq_restore(flags);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800766 return;
767 }
768
Mike Frysingerd171c232008-03-26 08:35:46 +0800769 if (!(per & P_MAYSHARE))
Michael Hennerichc58c2142007-10-04 00:35:05 +0800770 port_setup(ident, GPIO_USAGE);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800771
Mike Frysinger332824b2010-06-02 04:22:01 +0000772 unreserve(peri, ident);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800773
Michael Hennerich2acde902007-10-11 00:24:40 +0800774 set_label(ident, "free");
775
David Howells3b139cd2010-10-07 14:08:52 +0100776 hard_local_irq_restore(flags);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800777}
778EXPORT_SYMBOL(peripheral_free);
779
Mike Frysinger68179372008-04-24 05:04:24 +0800780void peripheral_free_list(const unsigned short per[])
Michael Hennerichc58c2142007-10-04 00:35:05 +0800781{
782 u16 cnt;
Mike Frysingerd171c232008-03-26 08:35:46 +0800783 for (cnt = 0; per[cnt] != 0; cnt++)
Michael Hennerichc58c2142007-10-04 00:35:05 +0800784 peripheral_free(per[cnt]);
Michael Hennerichc58c2142007-10-04 00:35:05 +0800785}
786EXPORT_SYMBOL(peripheral_free_list);
787
Bryan Wu1394f032007-05-06 14:50:22 -0700788/***********************************************************
789*
790* FUNCTIONS: Blackfin GPIO Driver
791*
792* INPUTS/OUTPUTS:
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800793* gpio PIO Number between 0 and MAX_BLACKFIN_GPIOS
794* label String
Bryan Wu1394f032007-05-06 14:50:22 -0700795*
796* DESCRIPTION: Blackfin GPIO Driver API
797*
798* CAUTION:
799*************************************************************
800* MODIFICATION HISTORY :
801**************************************************************/
802
Michael Hennericha4f0b32c2008-11-18 17:48:22 +0800803int bfin_gpio_request(unsigned gpio, const char *label)
Bryan Wu1394f032007-05-06 14:50:22 -0700804{
805 unsigned long flags;
806
807 if (check_gpio(gpio) < 0)
808 return -EINVAL;
809
David Howells3b139cd2010-10-07 14:08:52 +0100810 flags = hard_local_irq_save();
Bryan Wu1394f032007-05-06 14:50:22 -0700811
Michael Hennerich2acde902007-10-11 00:24:40 +0800812 /*
813 * Allow that the identical GPIO can
814 * be requested from the same driver twice
815 * Do nothing and return -
816 */
817
818 if (cmp_label(gpio, label) == 0) {
David Howells3b139cd2010-10-07 14:08:52 +0100819 hard_local_irq_restore(flags);
Michael Hennerich2acde902007-10-11 00:24:40 +0800820 return 0;
821 }
822
Mike Frysinger332824b2010-06-02 04:22:01 +0000823 if (unlikely(is_reserved(gpio, gpio, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800824 if (system_state == SYSTEM_BOOTING)
825 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800826 printk(KERN_ERR "bfin-gpio: GPIO %d is already reserved by %s !\n",
Graf Yang9570ff42009-01-07 23:14:38 +0800827 gpio, get_label(gpio));
David Howells3b139cd2010-10-07 14:08:52 +0100828 hard_local_irq_restore(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700829 return -EBUSY;
830 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000831 if (unlikely(is_reserved(peri, gpio, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800832 if (system_state == SYSTEM_BOOTING)
833 dump_stack();
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800834 printk(KERN_ERR
835 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
836 gpio, get_label(gpio));
David Howells3b139cd2010-10-07 14:08:52 +0100837 hard_local_irq_restore(flags);
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800838 return -EBUSY;
839 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000840 if (unlikely(is_reserved(gpio_irq, gpio, 1))) {
Graf Yang9570ff42009-01-07 23:14:38 +0800841 printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved as gpio-irq!"
842 " (Documentation/blackfin/bfin-gpio-notes.txt)\n", gpio);
Sonic Zhang54e4ff42013-05-30 18:37:28 +0800843 } else { /* Reset POLAR setting when acquiring a gpio for the first time */
Michael Hennericha2be3932009-02-04 16:49:45 +0800844 set_gpio_polar(gpio, 0);
845 }
Michael Hennerichd2b11a42007-08-28 16:47:46 +0800846
Mike Frysinger332824b2010-06-02 04:22:01 +0000847 reserve(gpio, gpio);
Graf Yang9570ff42009-01-07 23:14:38 +0800848 set_label(gpio, label);
Bryan Wu1394f032007-05-06 14:50:22 -0700849
David Howells3b139cd2010-10-07 14:08:52 +0100850 hard_local_irq_restore(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700851
852 port_setup(gpio, GPIO_USAGE);
853
854 return 0;
855}
Michael Hennericha4f0b32c2008-11-18 17:48:22 +0800856EXPORT_SYMBOL(bfin_gpio_request);
Bryan Wu1394f032007-05-06 14:50:22 -0700857
Michael Hennericha4f0b32c2008-11-18 17:48:22 +0800858void bfin_gpio_free(unsigned gpio)
Bryan Wu1394f032007-05-06 14:50:22 -0700859{
860 unsigned long flags;
861
862 if (check_gpio(gpio) < 0)
863 return;
864
Uwe Kleine-Koenig45c4f2a2009-02-04 17:02:30 +0800865 might_sleep();
866
David Howells3b139cd2010-10-07 14:08:52 +0100867 flags = hard_local_irq_save();
Bryan Wu1394f032007-05-06 14:50:22 -0700868
Mike Frysinger332824b2010-06-02 04:22:01 +0000869 if (unlikely(!is_reserved(gpio, gpio, 0))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800870 if (system_state == SYSTEM_BOOTING)
871 dump_stack();
Mike Frysingerf85c4ab2008-03-26 08:34:23 +0800872 gpio_error(gpio);
David Howells3b139cd2010-10-07 14:08:52 +0100873 hard_local_irq_restore(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700874 return;
875 }
876
Mike Frysinger332824b2010-06-02 04:22:01 +0000877 unreserve(gpio, gpio);
Bryan Wu1394f032007-05-06 14:50:22 -0700878
Michael Hennerich2acde902007-10-11 00:24:40 +0800879 set_label(gpio, "free");
880
David Howells3b139cd2010-10-07 14:08:52 +0100881 hard_local_irq_restore(flags);
Bryan Wu1394f032007-05-06 14:50:22 -0700882}
Michael Hennericha4f0b32c2008-11-18 17:48:22 +0800883EXPORT_SYMBOL(bfin_gpio_free);
Bryan Wu1394f032007-05-06 14:50:22 -0700884
Michael Hennerich621dd242009-09-28 12:23:41 +0000885#ifdef BFIN_SPECIAL_GPIO_BANKS
Mike Frysinger332824b2010-06-02 04:22:01 +0000886DECLARE_RESERVED_MAP(special_gpio, gpio_bank(MAX_RESOURCES));
Michael Hennerich621dd242009-09-28 12:23:41 +0000887
888int bfin_special_gpio_request(unsigned gpio, const char *label)
889{
890 unsigned long flags;
891
David Howells3b139cd2010-10-07 14:08:52 +0100892 flags = hard_local_irq_save();
Michael Hennerich621dd242009-09-28 12:23:41 +0000893
894 /*
895 * Allow that the identical GPIO can
896 * be requested from the same driver twice
897 * Do nothing and return -
898 */
899
900 if (cmp_label(gpio, label) == 0) {
David Howells3b139cd2010-10-07 14:08:52 +0100901 hard_local_irq_restore(flags);
Michael Hennerich621dd242009-09-28 12:23:41 +0000902 return 0;
903 }
904
Mike Frysinger332824b2010-06-02 04:22:01 +0000905 if (unlikely(is_reserved(special_gpio, gpio, 1))) {
David Howells3b139cd2010-10-07 14:08:52 +0100906 hard_local_irq_restore(flags);
Michael Hennerich621dd242009-09-28 12:23:41 +0000907 printk(KERN_ERR "bfin-gpio: GPIO %d is already reserved by %s !\n",
908 gpio, get_label(gpio));
909
910 return -EBUSY;
911 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000912 if (unlikely(is_reserved(peri, gpio, 1))) {
David Howells3b139cd2010-10-07 14:08:52 +0100913 hard_local_irq_restore(flags);
Michael Hennerich621dd242009-09-28 12:23:41 +0000914 printk(KERN_ERR
915 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
916 gpio, get_label(gpio));
917
918 return -EBUSY;
919 }
920
Mike Frysinger332824b2010-06-02 04:22:01 +0000921 reserve(special_gpio, gpio);
922 reserve(peri, gpio);
Michael Hennerich621dd242009-09-28 12:23:41 +0000923
924 set_label(gpio, label);
David Howells3b139cd2010-10-07 14:08:52 +0100925 hard_local_irq_restore(flags);
Michael Hennerich621dd242009-09-28 12:23:41 +0000926 port_setup(gpio, GPIO_USAGE);
927
928 return 0;
929}
930EXPORT_SYMBOL(bfin_special_gpio_request);
931
932void bfin_special_gpio_free(unsigned gpio)
933{
934 unsigned long flags;
935
936 might_sleep();
937
David Howells3b139cd2010-10-07 14:08:52 +0100938 flags = hard_local_irq_save();
Michael Hennerich621dd242009-09-28 12:23:41 +0000939
Mike Frysinger332824b2010-06-02 04:22:01 +0000940 if (unlikely(!is_reserved(special_gpio, gpio, 0))) {
Michael Hennerich621dd242009-09-28 12:23:41 +0000941 gpio_error(gpio);
David Howells3b139cd2010-10-07 14:08:52 +0100942 hard_local_irq_restore(flags);
Michael Hennerich621dd242009-09-28 12:23:41 +0000943 return;
944 }
945
Mike Frysinger332824b2010-06-02 04:22:01 +0000946 unreserve(special_gpio, gpio);
947 unreserve(peri, gpio);
Michael Hennerich621dd242009-09-28 12:23:41 +0000948 set_label(gpio, "free");
David Howells3b139cd2010-10-07 14:08:52 +0100949 hard_local_irq_restore(flags);
Michael Hennerich621dd242009-09-28 12:23:41 +0000950}
951EXPORT_SYMBOL(bfin_special_gpio_free);
952#endif
953
954
Graf Yang9570ff42009-01-07 23:14:38 +0800955int bfin_gpio_irq_request(unsigned gpio, const char *label)
956{
957 unsigned long flags;
958
959 if (check_gpio(gpio) < 0)
960 return -EINVAL;
961
David Howells3b139cd2010-10-07 14:08:52 +0100962 flags = hard_local_irq_save();
Graf Yang9570ff42009-01-07 23:14:38 +0800963
Mike Frysinger332824b2010-06-02 04:22:01 +0000964 if (unlikely(is_reserved(peri, gpio, 1))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800965 if (system_state == SYSTEM_BOOTING)
966 dump_stack();
Graf Yang9570ff42009-01-07 23:14:38 +0800967 printk(KERN_ERR
968 "bfin-gpio: GPIO %d is already reserved as Peripheral by %s !\n",
969 gpio, get_label(gpio));
David Howells3b139cd2010-10-07 14:08:52 +0100970 hard_local_irq_restore(flags);
Graf Yang9570ff42009-01-07 23:14:38 +0800971 return -EBUSY;
972 }
Mike Frysinger332824b2010-06-02 04:22:01 +0000973 if (unlikely(is_reserved(gpio, gpio, 1)))
Graf Yang9570ff42009-01-07 23:14:38 +0800974 printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved by %s! "
975 "(Documentation/blackfin/bfin-gpio-notes.txt)\n",
976 gpio, get_label(gpio));
977
Mike Frysinger332824b2010-06-02 04:22:01 +0000978 reserve(gpio_irq, gpio);
Graf Yang9570ff42009-01-07 23:14:38 +0800979 set_label(gpio, label);
980
David Howells3b139cd2010-10-07 14:08:52 +0100981 hard_local_irq_restore(flags);
Graf Yang9570ff42009-01-07 23:14:38 +0800982
983 port_setup(gpio, GPIO_USAGE);
984
985 return 0;
986}
987
988void bfin_gpio_irq_free(unsigned gpio)
989{
990 unsigned long flags;
991
992 if (check_gpio(gpio) < 0)
993 return;
994
David Howells3b139cd2010-10-07 14:08:52 +0100995 flags = hard_local_irq_save();
Graf Yang9570ff42009-01-07 23:14:38 +0800996
Mike Frysinger332824b2010-06-02 04:22:01 +0000997 if (unlikely(!is_reserved(gpio_irq, gpio, 0))) {
Robin Getzd6879c52009-03-29 01:10:30 +0800998 if (system_state == SYSTEM_BOOTING)
999 dump_stack();
Graf Yang9570ff42009-01-07 23:14:38 +08001000 gpio_error(gpio);
David Howells3b139cd2010-10-07 14:08:52 +01001001 hard_local_irq_restore(flags);
Graf Yang9570ff42009-01-07 23:14:38 +08001002 return;
1003 }
1004
Mike Frysinger332824b2010-06-02 04:22:01 +00001005 unreserve(gpio_irq, gpio);
Graf Yang9570ff42009-01-07 23:14:38 +08001006
1007 set_label(gpio, "free");
1008
David Howells3b139cd2010-10-07 14:08:52 +01001009 hard_local_irq_restore(flags);
Graf Yang9570ff42009-01-07 23:14:38 +08001010}
1011
Mike Frysingerf5563092009-02-04 16:49:45 +08001012static inline void __bfin_gpio_direction_input(unsigned gpio)
1013{
Mike Frysingerf5563092009-02-04 16:49:45 +08001014 gpio_array[gpio_bank(gpio)]->dir &= ~gpio_bit(gpio);
Mike Frysingerf5563092009-02-04 16:49:45 +08001015 gpio_array[gpio_bank(gpio)]->inen |= gpio_bit(gpio);
Michael Hennerich803a8d22008-05-17 16:01:51 +08001016}
Michael Hennerich803a8d22008-05-17 16:01:51 +08001017
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001018int bfin_gpio_direction_input(unsigned gpio)
Bryan Wu1394f032007-05-06 14:50:22 -07001019{
1020 unsigned long flags;
1021
Mike Frysinger332824b2010-06-02 04:22:01 +00001022 if (unlikely(!is_reserved(gpio, gpio, 0))) {
Michael Hennerichacbcd262008-01-22 18:36:20 +08001023 gpio_error(gpio);
1024 return -EINVAL;
1025 }
Bryan Wu1394f032007-05-06 14:50:22 -07001026
David Howells3b139cd2010-10-07 14:08:52 +01001027 flags = hard_local_irq_save();
Mike Frysingerf5563092009-02-04 16:49:45 +08001028 __bfin_gpio_direction_input(gpio);
Michael Hennerich2b393312007-10-10 16:58:49 +08001029 AWA_DUMMY_READ(inen);
David Howells3b139cd2010-10-07 14:08:52 +01001030 hard_local_irq_restore(flags);
Michael Hennerichacbcd262008-01-22 18:36:20 +08001031
1032 return 0;
Bryan Wu1394f032007-05-06 14:50:22 -07001033}
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001034EXPORT_SYMBOL(bfin_gpio_direction_input);
Bryan Wu1394f032007-05-06 14:50:22 -07001035
Mike Frysingerf5563092009-02-04 16:49:45 +08001036void bfin_gpio_irq_prepare(unsigned gpio)
1037{
Mike Frysingerf5563092009-02-04 16:49:45 +08001038 port_setup(gpio, GPIO_USAGE);
Mike Frysingerf5563092009-02-04 16:49:45 +08001039}
1040
1041void bfin_gpio_set_value(unsigned gpio, int arg)
1042{
1043 if (arg)
1044 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
1045 else
1046 gpio_array[gpio_bank(gpio)]->data_clear = gpio_bit(gpio);
1047}
1048EXPORT_SYMBOL(bfin_gpio_set_value);
1049
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001050int bfin_gpio_direction_output(unsigned gpio, int value)
Bryan Wu1394f032007-05-06 14:50:22 -07001051{
1052 unsigned long flags;
1053
Mike Frysinger332824b2010-06-02 04:22:01 +00001054 if (unlikely(!is_reserved(gpio, gpio, 0))) {
Michael Hennerichacbcd262008-01-22 18:36:20 +08001055 gpio_error(gpio);
1056 return -EINVAL;
1057 }
Bryan Wu1394f032007-05-06 14:50:22 -07001058
David Howells3b139cd2010-10-07 14:08:52 +01001059 flags = hard_local_irq_save();
Michael Hennericha2c8cfe2008-01-22 17:20:10 +08001060
Mike Frysingerf5563092009-02-04 16:49:45 +08001061 gpio_array[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio);
1062 gpio_set_value(gpio, value);
Mike Frysingerf5563092009-02-04 16:49:45 +08001063 gpio_array[gpio_bank(gpio)]->dir |= gpio_bit(gpio);
Michael Hennericha2c8cfe2008-01-22 17:20:10 +08001064
Michael Hennerich2b393312007-10-10 16:58:49 +08001065 AWA_DUMMY_READ(dir);
David Howells3b139cd2010-10-07 14:08:52 +01001066 hard_local_irq_restore(flags);
Michael Hennerichacbcd262008-01-22 18:36:20 +08001067
1068 return 0;
Bryan Wu1394f032007-05-06 14:50:22 -07001069}
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001070EXPORT_SYMBOL(bfin_gpio_direction_output);
Mike Frysinger168f12122007-10-11 00:22:35 +08001071
Mike Frysingerf5563092009-02-04 16:49:45 +08001072int bfin_gpio_get_value(unsigned gpio)
1073{
Mike Frysingerf5563092009-02-04 16:49:45 +08001074 unsigned long flags;
1075
1076 if (unlikely(get_gpio_edge(gpio))) {
1077 int ret;
David Howells3b139cd2010-10-07 14:08:52 +01001078 flags = hard_local_irq_save();
Mike Frysingerf5563092009-02-04 16:49:45 +08001079 set_gpio_edge(gpio, 0);
1080 ret = get_gpio_data(gpio);
1081 set_gpio_edge(gpio, 1);
David Howells3b139cd2010-10-07 14:08:52 +01001082 hard_local_irq_restore(flags);
Mike Frysingerf5563092009-02-04 16:49:45 +08001083 return ret;
1084 } else
1085 return get_gpio_data(gpio);
Mike Frysingerf5563092009-02-04 16:49:45 +08001086}
1087EXPORT_SYMBOL(bfin_gpio_get_value);
1088
Mike Frysinger168f12122007-10-11 00:22:35 +08001089/* If we are booting from SPI and our board lacks a strong enough pull up,
1090 * the core can reset and execute the bootrom faster than the resistor can
1091 * pull the signal logically high. To work around this (common) error in
1092 * board design, we explicitly set the pin back to GPIO mode, force /CS
1093 * high, and wait for the electrons to do their thing.
1094 *
1095 * This function only makes sense to be called from reset code, but it
1096 * lives here as we need to force all the GPIO states w/out going through
1097 * BUG() checks and such.
1098 */
Sonic Zhangb52dae32009-02-04 16:49:45 +08001099void bfin_reset_boot_spi_cs(unsigned short pin)
Mike Frysinger168f12122007-10-11 00:22:35 +08001100{
Sonic Zhangb52dae32009-02-04 16:49:45 +08001101 unsigned short gpio = P_IDENT(pin);
Michael Hennerich4d5f4ed2007-08-27 16:46:17 +08001102 port_setup(gpio, GPIO_USAGE);
Mike Frysingerf5563092009-02-04 16:49:45 +08001103 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
Michael Hennericha2c8cfe2008-01-22 17:20:10 +08001104 AWA_DUMMY_READ(data_set);
Mike Frysinger168f12122007-10-11 00:22:35 +08001105 udelay(1);
1106}
Michael Hennerichd2b11a42007-08-28 16:47:46 +08001107
Mike Frysinger1545a112007-12-24 16:54:48 +08001108#if defined(CONFIG_PROC_FS)
Alexey Dobriyan6362ec272011-05-14 19:48:46 +03001109static int gpio_proc_show(struct seq_file *m, void *v)
Mike Frysinger1545a112007-12-24 16:54:48 +08001110{
Alexey Dobriyan6362ec272011-05-14 19:48:46 +03001111 int c, irq, gpio;
Mike Frysinger1545a112007-12-24 16:54:48 +08001112
1113 for (c = 0; c < MAX_RESOURCES; c++) {
Mike Frysinger332824b2010-06-02 04:22:01 +00001114 irq = is_reserved(gpio_irq, c, 1);
1115 gpio = is_reserved(gpio, c, 1);
Graf Yang9570ff42009-01-07 23:14:38 +08001116 if (!check_gpio(c) && (gpio || irq))
Alexey Dobriyan6362ec272011-05-14 19:48:46 +03001117 seq_printf(m, "GPIO_%d: \t%s%s \t\tGPIO %s\n", c,
Graf Yang9570ff42009-01-07 23:14:38 +08001118 get_label(c), (gpio && irq) ? " *" : "",
1119 get_gpio_dir(c) ? "OUTPUT" : "INPUT");
Mike Frysinger332824b2010-06-02 04:22:01 +00001120 else if (is_reserved(peri, c, 1))
Alexey Dobriyan6362ec272011-05-14 19:48:46 +03001121 seq_printf(m, "GPIO_%d: \t%s \t\tPeripheral\n", c, get_label(c));
Mike Frysinger1545a112007-12-24 16:54:48 +08001122 else
1123 continue;
Mike Frysinger1545a112007-12-24 16:54:48 +08001124 }
Alexey Dobriyan6362ec272011-05-14 19:48:46 +03001125
1126 return 0;
Mike Frysinger1545a112007-12-24 16:54:48 +08001127}
1128
Alexey Dobriyan6362ec272011-05-14 19:48:46 +03001129static int gpio_proc_open(struct inode *inode, struct file *file)
1130{
1131 return single_open(file, gpio_proc_show, NULL);
1132}
1133
1134static const struct file_operations gpio_proc_ops = {
1135 .open = gpio_proc_open,
1136 .read = seq_read,
1137 .llseek = seq_lseek,
1138 .release = single_release,
1139};
1140
Mike Frysinger1545a112007-12-24 16:54:48 +08001141static __init int gpio_register_proc(void)
1142{
1143 struct proc_dir_entry *proc_gpio;
1144
Steven Miaoce860912012-08-16 13:41:47 +08001145 proc_gpio = proc_create("gpio", 0, NULL, &gpio_proc_ops);
1146 return proc_gpio == NULL;
Mike Frysinger1545a112007-12-24 16:54:48 +08001147}
Mike Frysinger1545a112007-12-24 16:54:48 +08001148__initcall(gpio_register_proc);
1149#endif
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001150
1151#ifdef CONFIG_GPIOLIB
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001152static int bfin_gpiolib_direction_input(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001153{
1154 return bfin_gpio_direction_input(gpio);
1155}
1156
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001157static int bfin_gpiolib_direction_output(struct gpio_chip *chip, unsigned gpio, int level)
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001158{
1159 return bfin_gpio_direction_output(gpio, level);
1160}
1161
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001162static int bfin_gpiolib_get_value(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001163{
Linus Walleij48295fe2015-12-21 16:50:18 +01001164 return !!bfin_gpio_get_value(gpio);
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001165}
1166
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001167static void bfin_gpiolib_set_value(struct gpio_chip *chip, unsigned gpio, int value)
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001168{
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001169 return bfin_gpio_set_value(gpio, value);
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001170}
1171
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001172static int bfin_gpiolib_gpio_request(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001173{
1174 return bfin_gpio_request(gpio, chip->label);
1175}
1176
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001177static void bfin_gpiolib_gpio_free(struct gpio_chip *chip, unsigned gpio)
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001178{
1179 return bfin_gpio_free(gpio);
1180}
1181
Joachim Eastwoodf9c29e82010-02-11 12:41:11 +01001182static int bfin_gpiolib_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
Joachim Eastwood7f4f69f2010-02-10 12:31:41 +01001183{
1184 return gpio + GPIO_IRQ_BASE;
1185}
1186
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001187static struct gpio_chip bfin_chip = {
Michael Hennerichedd07992009-12-16 08:45:17 +00001188 .label = "BFIN-GPIO",
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001189 .direction_input = bfin_gpiolib_direction_input,
1190 .get = bfin_gpiolib_get_value,
1191 .direction_output = bfin_gpiolib_direction_output,
1192 .set = bfin_gpiolib_set_value,
1193 .request = bfin_gpiolib_gpio_request,
1194 .free = bfin_gpiolib_gpio_free,
Joachim Eastwood7f4f69f2010-02-10 12:31:41 +01001195 .to_irq = bfin_gpiolib_gpio_to_irq,
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001196 .base = 0,
1197 .ngpio = MAX_BLACKFIN_GPIOS,
1198};
1199
1200static int __init bfin_gpiolib_setup(void)
1201{
Linus Walleij03be35d2015-12-08 13:54:10 +01001202 return gpiochip_add_data(&bfin_chip, NULL);
Michael Hennericha4f0b32c2008-11-18 17:48:22 +08001203}
1204arch_initcall(bfin_gpiolib_setup);
1205#endif