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