blob: 051073cee3b5d47a2caeb4a9e600e3ed616aa866 [file] [log] [blame]
Sonic Zhangda34aae2013-05-02 13:46:21 +08001/*
2 * ADI GPIO2 Abstraction Layer
3 * Support BF54x, BF60x and future processors.
4 *
5 * Copyright 2008-2013 Analog Devices Inc.
6 *
7 * Licensed under the GPL-2 or later
8 */
9
10#include <common.h>
11#include <asm/errno.h>
12#include <asm/gpio.h>
13#include <asm/portmux.h>
14
15static struct gpio_port_t * const gpio_array[] = {
16 (struct gpio_port_t *)PORTA_FER,
17 (struct gpio_port_t *)PORTB_FER,
18 (struct gpio_port_t *)PORTC_FER,
19 (struct gpio_port_t *)PORTD_FER,
20 (struct gpio_port_t *)PORTE_FER,
21 (struct gpio_port_t *)PORTF_FER,
22 (struct gpio_port_t *)PORTG_FER,
23#if defined(CONFIG_BF54x)
24 (struct gpio_port_t *)PORTH_FER,
25 (struct gpio_port_t *)PORTI_FER,
26 (struct gpio_port_t *)PORTJ_FER,
27#endif
28};
29
30#define RESOURCE_LABEL_SIZE 16
31
32static struct str_ident {
33 char name[RESOURCE_LABEL_SIZE];
34} str_ident[MAX_RESOURCES];
35
36static void gpio_error(unsigned gpio)
37{
38 printf("adi_gpio2: GPIO %d wasn't requested!\n", gpio);
39}
40
41static void set_label(unsigned short ident, const char *label)
42{
43 if (label) {
44 strncpy(str_ident[ident].name, label,
45 RESOURCE_LABEL_SIZE);
46 str_ident[ident].name[RESOURCE_LABEL_SIZE - 1] = 0;
47 }
48}
49
50static char *get_label(unsigned short ident)
51{
52 return *str_ident[ident].name ? str_ident[ident].name : "UNKNOWN";
53}
54
55static int cmp_label(unsigned short ident, const char *label)
56{
57 if (label == NULL)
58 printf("adi_gpio2: please provide none-null label\n");
59
60 if (label)
61 return strcmp(str_ident[ident].name, label);
62 else
63 return -EINVAL;
64}
65
66#define map_entry(m, i) reserved_##m##_map[gpio_bank(i)]
67#define is_reserved(m, i, e) (map_entry(m, i) & gpio_bit(i))
68#define reserve(m, i) (map_entry(m, i) |= gpio_bit(i))
69#define unreserve(m, i) (map_entry(m, i) &= ~gpio_bit(i))
70#define DECLARE_RESERVED_MAP(m, c) unsigned short reserved_##m##_map[c]
71
72static DECLARE_RESERVED_MAP(gpio, GPIO_BANK_NUM);
73static DECLARE_RESERVED_MAP(peri, gpio_bank(MAX_RESOURCES));
74
75inline int check_gpio(unsigned gpio)
76{
77#if defined(CONFIG_BF54x)
78 if (gpio == GPIO_PB15 || gpio == GPIO_PC14 || gpio == GPIO_PC15 ||
79 gpio == GPIO_PH14 || gpio == GPIO_PH15 ||
80 gpio == GPIO_PJ14 || gpio == GPIO_PJ15)
81 return -EINVAL;
82#endif
83 if (gpio >= MAX_GPIOS)
84 return -EINVAL;
85 return 0;
86}
87
88static void port_setup(unsigned gpio, unsigned short usage)
89{
90#if defined(CONFIG_BF54x)
91 if (usage == GPIO_USAGE)
92 gpio_array[gpio_bank(gpio)]->port_fer &= ~gpio_bit(gpio);
93 else
94 gpio_array[gpio_bank(gpio)]->port_fer |= gpio_bit(gpio);
95#else
96 if (usage == GPIO_USAGE)
97 gpio_array[gpio_bank(gpio)]->port_fer_clear = gpio_bit(gpio);
98 else
99 gpio_array[gpio_bank(gpio)]->port_fer_set = gpio_bit(gpio);
100#endif
101 SSYNC();
102}
103
104inline void portmux_setup(unsigned short per)
105{
106 u32 pmux;
107 u16 ident = P_IDENT(per);
108 u16 function = P_FUNCT2MUX(per);
109
110 pmux = gpio_array[gpio_bank(ident)]->port_mux;
111
112 pmux &= ~(0x3 << (2 * gpio_sub_n(ident)));
113 pmux |= (function & 0x3) << (2 * gpio_sub_n(ident));
114
115 gpio_array[gpio_bank(ident)]->port_mux = pmux;
116}
117
118inline u16 get_portmux(unsigned short per)
119{
120 u32 pmux;
121 u16 ident = P_IDENT(per);
122
123 pmux = gpio_array[gpio_bank(ident)]->port_mux;
124
125 return pmux >> (2 * gpio_sub_n(ident)) & 0x3;
126}
127
128unsigned short get_gpio_dir(unsigned gpio)
129{
130 return 0x01 &
131 (gpio_array[gpio_bank(gpio)]->dir_clear >> gpio_sub_n(gpio));
132}
133
134/***********************************************************
135*
136* FUNCTIONS: Peripheral Resource Allocation
137* and PortMux Setup
138*
139* INPUTS/OUTPUTS:
140* per Peripheral Identifier
141* label String
142*
143* DESCRIPTION: Peripheral Resource Allocation and Setup API
144**************************************************************/
145
146int peripheral_request(unsigned short per, const char *label)
147{
148 unsigned short ident = P_IDENT(per);
149
150 /*
151 * Don't cares are pins with only one dedicated function
152 */
153
154 if (per & P_DONTCARE)
155 return 0;
156
157 if (!(per & P_DEFINED))
158 return -ENODEV;
159
160 BUG_ON(ident >= MAX_RESOURCES);
161
162 /* If a pin can be muxed as either GPIO or peripheral, make
163 * sure it is not already a GPIO pin when we request it.
164 */
165 if (unlikely(!check_gpio(ident) && is_reserved(gpio, ident, 1))) {
166 printf("%s: Peripheral %d is already reserved as GPIO by %s!\n",
167 __func__, ident, get_label(ident));
168 return -EBUSY;
169 }
170
171 if (unlikely(is_reserved(peri, ident, 1))) {
172 /*
173 * Pin functions like AMC address strobes my
174 * be requested and used by several drivers
175 */
176
177 if (!((per & P_MAYSHARE) &&
178 get_portmux(per) == P_FUNCT2MUX(per))) {
179 /*
180 * Allow that the identical pin function can
181 * be requested from the same driver twice
182 */
183
184 if (cmp_label(ident, label) == 0)
185 goto anyway;
186
187 printf("%s: Peripheral %d function %d is already "
188 "reserved by %s!\n", __func__, ident,
189 P_FUNCT2MUX(per), get_label(ident));
190 return -EBUSY;
191 }
192 }
193
194 anyway:
195 reserve(peri, ident);
196
197 portmux_setup(per);
198 port_setup(ident, PERIPHERAL_USAGE);
199
200 set_label(ident, label);
201
202 return 0;
203}
204
205int peripheral_request_list(const unsigned short per[], const char *label)
206{
207 u16 cnt;
208 int ret;
209
210 for (cnt = 0; per[cnt] != 0; cnt++) {
211 ret = peripheral_request(per[cnt], label);
212
213 if (ret < 0) {
214 for (; cnt > 0; cnt--)
215 peripheral_free(per[cnt - 1]);
216
217 return ret;
218 }
219 }
220
221 return 0;
222}
223
224void peripheral_free(unsigned short per)
225{
226 unsigned short ident = P_IDENT(per);
227
228 if (per & P_DONTCARE)
229 return;
230
231 if (!(per & P_DEFINED))
232 return;
233
234 if (unlikely(!is_reserved(peri, ident, 0)))
235 return;
236
237 if (!(per & P_MAYSHARE))
238 port_setup(ident, GPIO_USAGE);
239
240 unreserve(peri, ident);
241
242 set_label(ident, "free");
243}
244
245void peripheral_free_list(const unsigned short per[])
246{
247 u16 cnt;
248 for (cnt = 0; per[cnt] != 0; cnt++)
249 peripheral_free(per[cnt]);
250}
251
252/***********************************************************
253*
254* FUNCTIONS: GPIO Driver
255*
256* INPUTS/OUTPUTS:
257* gpio PIO Number between 0 and MAX_GPIOS
258* label String
259*
260* DESCRIPTION: GPIO Driver API
261**************************************************************/
262
263int gpio_request(unsigned gpio, const char *label)
264{
265 if (check_gpio(gpio) < 0)
266 return -EINVAL;
267
268 /*
269 * Allow that the identical GPIO can
270 * be requested from the same driver twice
271 * Do nothing and return -
272 */
273
274 if (cmp_label(gpio, label) == 0)
275 return 0;
276
277 if (unlikely(is_reserved(gpio, gpio, 1))) {
278 printf("adi_gpio2: GPIO %d is already reserved by %s!\n",
279 gpio, get_label(gpio));
280 return -EBUSY;
281 }
282 if (unlikely(is_reserved(peri, gpio, 1))) {
283 printf("adi_gpio2: GPIO %d is already reserved as Peripheral "
284 "by %s!\n", gpio, get_label(gpio));
285 return -EBUSY;
286 }
287
288 reserve(gpio, gpio);
289 set_label(gpio, label);
290
291 port_setup(gpio, GPIO_USAGE);
292
293 return 0;
294}
295
296int gpio_free(unsigned gpio)
297{
298 if (check_gpio(gpio) < 0)
299 return -1;
300
301 if (unlikely(!is_reserved(gpio, gpio, 0))) {
302 gpio_error(gpio);
303 return -1;
304 }
305
306 unreserve(gpio, gpio);
307
308 set_label(gpio, "free");
309
310 return 0;
311}
312
313#ifdef ADI_SPECIAL_GPIO_BANKS
314static DECLARE_RESERVED_MAP(special_gpio, gpio_bank(MAX_RESOURCES));
315
316int special_gpio_request(unsigned gpio, const char *label)
317{
318 /*
319 * Allow that the identical GPIO can
320 * be requested from the same driver twice
321 * Do nothing and return -
322 */
323
324 if (cmp_label(gpio, label) == 0)
325 return 0;
326
327 if (unlikely(is_reserved(special_gpio, gpio, 1))) {
328 printf("adi_gpio2: GPIO %d is already reserved by %s!\n",
329 gpio, get_label(gpio));
330 return -EBUSY;
331 }
332 if (unlikely(is_reserved(peri, gpio, 1))) {
333 printf("adi_gpio2: GPIO %d is already reserved as Peripheral "
334 "by %s!\n", gpio, get_label(gpio));
335
336 return -EBUSY;
337 }
338
339 reserve(special_gpio, gpio);
340 reserve(peri, gpio);
341
342 set_label(gpio, label);
343 port_setup(gpio, GPIO_USAGE);
344
345 return 0;
346}
347
348void special_gpio_free(unsigned gpio)
349{
350 if (unlikely(!is_reserved(special_gpio, gpio, 0))) {
351 gpio_error(gpio);
352 return;
353 }
354
Axel Lin2ced7732013-06-26 10:10:04 +0800355 unreserve(special_gpio, gpio);
356 unreserve(peri, gpio);
Sonic Zhangda34aae2013-05-02 13:46:21 +0800357 set_label(gpio, "free");
358}
359#endif
360
361static inline void __gpio_direction_input(unsigned gpio)
362{
363 gpio_array[gpio_bank(gpio)]->dir_clear = gpio_bit(gpio);
364#if defined(CONFIG_BF54x)
365 gpio_array[gpio_bank(gpio)]->inen |= gpio_bit(gpio);
366#else
367 gpio_array[gpio_bank(gpio)]->inen_set = gpio_bit(gpio);
368#endif
369}
370
371int gpio_direction_input(unsigned gpio)
372{
373 unsigned long flags;
374
375 if (!is_reserved(gpio, gpio, 0)) {
376 gpio_error(gpio);
377 return -EINVAL;
378 }
379
380 local_irq_save(flags);
381 __gpio_direction_input(gpio);
382 local_irq_restore(flags);
383
384 return 0;
385}
386
387int gpio_set_value(unsigned gpio, int arg)
388{
389 if (arg)
390 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
391 else
392 gpio_array[gpio_bank(gpio)]->data_clear = gpio_bit(gpio);
393
394 return 0;
395}
396
397int gpio_direction_output(unsigned gpio, int value)
398{
399 unsigned long flags;
400
401 if (!is_reserved(gpio, gpio, 0)) {
402 gpio_error(gpio);
403 return -EINVAL;
404 }
405
406 local_irq_save(flags);
407
408#if defined(CONFIG_BF54x)
409 gpio_array[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio);
410#else
411 gpio_array[gpio_bank(gpio)]->inen_clear = gpio_bit(gpio);
412#endif
413 gpio_set_value(gpio, value);
414 gpio_array[gpio_bank(gpio)]->dir_set = gpio_bit(gpio);
415
416 local_irq_restore(flags);
417
418 return 0;
419}
420
421int gpio_get_value(unsigned gpio)
422{
423 return 1 & (gpio_array[gpio_bank(gpio)]->data >> gpio_sub_n(gpio));
424}
425
426void gpio_labels(void)
427{
428 int c, gpio;
429
430 for (c = 0; c < MAX_RESOURCES; c++) {
431 gpio = is_reserved(gpio, c, 1);
432 if (!check_gpio(c) && gpio)
433 printf("GPIO_%d:\t%s\tGPIO %s\n", c, get_label(c),
434 get_gpio_dir(c) ? "OUTPUT" : "INPUT");
435 else if (is_reserved(peri, c, 1))
436 printf("GPIO_%d:\t%s\tPeripheral\n", c, get_label(c));
437 else
438 continue;
439 }
440}