xref: /openbmc/u-boot/drivers/gpio/xilinx_gpio.c (revision cf0bcd7d) 
1 /*
2  * Copyright (c) 2013 Xilinx, Michal Simek
3  *
4  * SPDX-License-Identifier:	GPL-2.0+
5  */
6 
7 #include <common.h>
8 #include <errno.h>
9 #include <malloc.h>
10 #include <linux/list.h>
11 #include <asm/io.h>
12 #include <asm/gpio.h>
13 
14 static LIST_HEAD(gpio_list);
15 
16 enum gpio_direction {
17 	GPIO_DIRECTION_OUT = 0,
18 	GPIO_DIRECTION_IN = 1,
19 };
20 
21 /* Gpio simple map */
22 struct gpio_regs {
23 	u32 gpiodata;
24 	u32 gpiodir;
25 };
26 
27 #define GPIO_NAME_SIZE	10
28 
29 struct gpio_names {
30 	char name[GPIO_NAME_SIZE];
31 };
32 
33 /* Initialized, rxbd_current, rx_first_buf must be 0 after init */
34 struct xilinx_gpio_priv {
35 	struct gpio_regs *regs;
36 	u32 gpio_min;
37 	u32 gpio_max;
38 	u32 gpiodata_store;
39 	char name[GPIO_NAME_SIZE];
40 	struct list_head list;
41 	struct gpio_names *gpio_name;
42 };
43 
44 /* Store number of allocated gpio pins */
45 static u32 xilinx_gpio_max;
46 
47 /* Get associated gpio controller */
48 static struct xilinx_gpio_priv *gpio_get_controller(unsigned gpio)
49 {
50 	struct list_head *entry;
51 	struct xilinx_gpio_priv *priv = NULL;
52 
53 	list_for_each(entry, &gpio_list) {
54 		priv = list_entry(entry, struct xilinx_gpio_priv, list);
55 		if (gpio >= priv->gpio_min && gpio <= priv->gpio_max) {
56 			debug("%s: reg: %x, min-max: %d-%d\n", __func__,
57 			      (u32)priv->regs, priv->gpio_min, priv->gpio_max);
58 			return priv;
59 		}
60 	}
61 	puts("!!!Can't get gpio controller!!!\n");
62 	return NULL;
63 }
64 
65 /* Get gpio pin name if used/setup */
66 static char *get_name(unsigned gpio)
67 {
68 	u32 gpio_priv;
69 	struct xilinx_gpio_priv *priv;
70 
71 	debug("%s\n", __func__);
72 
73 	priv = gpio_get_controller(gpio);
74 	if (priv) {
75 		gpio_priv = gpio - priv->gpio_min;
76 
77 		return *priv->gpio_name[gpio_priv].name ?
78 			priv->gpio_name[gpio_priv].name : "UNKNOWN";
79 	}
80 	return "UNKNOWN";
81 }
82 
83 /* Get output value */
84 static int gpio_get_output_value(unsigned gpio)
85 {
86 	u32 val, gpio_priv;
87 	struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
88 
89 	if (priv) {
90 		gpio_priv = gpio - priv->gpio_min;
91 		val = !!(priv->gpiodata_store & (1 << gpio_priv));
92 		debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
93 		      (u32)priv->regs, gpio_priv, val);
94 
95 		return val;
96 	}
97 	return -1;
98 }
99 
100 /* Get input value */
101 static int gpio_get_input_value(unsigned gpio)
102 {
103 	u32 val, gpio_priv;
104 	struct gpio_regs *regs;
105 	struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
106 
107 	if (priv) {
108 		regs = priv->regs;
109 		gpio_priv = gpio - priv->gpio_min;
110 		val = readl(&regs->gpiodata);
111 		val = !!(val & (1 << gpio_priv));
112 		debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
113 		      (u32)priv->regs, gpio_priv, val);
114 
115 		return val;
116 	}
117 	return -1;
118 }
119 
120 /* Set gpio direction */
121 static int gpio_set_direction(unsigned gpio, enum gpio_direction direction)
122 {
123 	u32 val, gpio_priv;
124 	struct gpio_regs *regs;
125 	struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
126 
127 	if (priv) {
128 		regs = priv->regs;
129 		val = readl(&regs->gpiodir);
130 
131 		gpio_priv = gpio - priv->gpio_min;
132 		if (direction == GPIO_DIRECTION_OUT)
133 			val &= ~(1 << gpio_priv);
134 		else
135 			val |= 1 << gpio_priv;
136 
137 		writel(val, &regs->gpiodir);
138 		debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
139 		      (u32)priv->regs, gpio_priv, val);
140 
141 		return 0;
142 	}
143 
144 	return -1;
145 }
146 
147 /* Get gpio direction */
148 static int gpio_get_direction(unsigned gpio)
149 {
150 	u32 val, gpio_priv;
151 	struct gpio_regs *regs;
152 	struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
153 
154 	if (priv) {
155 		regs = priv->regs;
156 		gpio_priv = gpio - priv->gpio_min;
157 		val = readl(&regs->gpiodir);
158 		val = !!(val & (1 << gpio_priv));
159 		debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
160 		      (u32)priv->regs, gpio_priv, val);
161 
162 		return val;
163 	}
164 
165 	return -1;
166 }
167 
168 /*
169  * Get input value
170  * for example gpio setup to output only can't get input value
171  * which is breaking gpio toggle command
172  */
173 int gpio_get_value(unsigned gpio)
174 {
175 	u32 val;
176 
177 	if (gpio_get_direction(gpio) == GPIO_DIRECTION_OUT)
178 		val = gpio_get_output_value(gpio);
179 	else
180 		val = gpio_get_input_value(gpio);
181 
182 	return val;
183 }
184 
185 /* Set output value */
186 static int gpio_set_output_value(unsigned gpio, int value)
187 {
188 	u32 val, gpio_priv;
189 	struct gpio_regs *regs;
190 	struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
191 
192 	if (priv) {
193 		regs = priv->regs;
194 		gpio_priv = gpio - priv->gpio_min;
195 		val = priv->gpiodata_store;
196 		if (value)
197 			val |= 1 << gpio_priv;
198 		else
199 			val &= ~(1 << gpio_priv);
200 
201 		writel(val, &regs->gpiodata);
202 		debug("%s: reg: %x, gpio_no: %d, output_val: %d\n", __func__,
203 		      (u32)priv->regs, gpio_priv, val);
204 		priv->gpiodata_store = val;
205 
206 		return 0;
207 	}
208 
209 	return -1;
210 }
211 
212 int gpio_set_value(unsigned gpio, int value)
213 {
214 	if (gpio_get_direction(gpio) == GPIO_DIRECTION_OUT)
215 		return gpio_set_output_value(gpio, value);
216 
217 	return -1;
218 }
219 
220 /* Set GPIO as input */
221 int gpio_direction_input(unsigned gpio)
222 {
223 	debug("%s\n", __func__);
224 	return gpio_set_direction(gpio, GPIO_DIRECTION_IN);
225 }
226 
227 /* Setup GPIO as output and set output value */
228 int gpio_direction_output(unsigned gpio, int value)
229 {
230 	int ret = gpio_set_direction(gpio, GPIO_DIRECTION_OUT);
231 
232 	debug("%s\n", __func__);
233 
234 	if (ret < 0)
235 		return ret;
236 
237 	return gpio_set_output_value(gpio, value);
238 }
239 
240 /* Show gpio status */
241 void gpio_info(void)
242 {
243 	unsigned gpio;
244 
245 	struct list_head *entry;
246 	struct xilinx_gpio_priv *priv = NULL;
247 
248 	list_for_each(entry, &gpio_list) {
249 		priv = list_entry(entry, struct xilinx_gpio_priv, list);
250 		printf("\n%s: %s/%x (%d-%d)\n", __func__, priv->name,
251 		       (u32)priv->regs, priv->gpio_min, priv->gpio_max);
252 
253 		for (gpio = priv->gpio_min; gpio <= priv->gpio_max; gpio++) {
254 			printf("GPIO_%d:\t%s is an ", gpio, get_name(gpio));
255 			if (gpio_get_direction(gpio) == GPIO_DIRECTION_OUT)
256 				printf("OUTPUT value = %d\n",
257 				       gpio_get_output_value(gpio));
258 			else
259 				printf("INPUT value = %d\n",
260 				       gpio_get_input_value(gpio));
261 		}
262 	}
263 }
264 
265 int gpio_request(unsigned gpio, const char *label)
266 {
267 	u32 gpio_priv;
268 	struct xilinx_gpio_priv *priv;
269 
270 	if (gpio >= xilinx_gpio_max)
271 		return -EINVAL;
272 
273 	priv = gpio_get_controller(gpio);
274 	if (priv) {
275 		gpio_priv = gpio - priv->gpio_min;
276 
277 		if (label != NULL) {
278 			strncpy(priv->gpio_name[gpio_priv].name, label,
279 				GPIO_NAME_SIZE);
280 			priv->gpio_name[gpio_priv].name[GPIO_NAME_SIZE - 1] =
281 					'\0';
282 		}
283 		return 0;
284 	}
285 
286 	return -1;
287 }
288 
289 int gpio_free(unsigned gpio)
290 {
291 	u32 gpio_priv;
292 	struct xilinx_gpio_priv *priv;
293 
294 	if (gpio >= xilinx_gpio_max)
295 		return -EINVAL;
296 
297 	priv = gpio_get_controller(gpio);
298 	if (priv) {
299 		gpio_priv = gpio - priv->gpio_min;
300 		priv->gpio_name[gpio_priv].name[0] = '\0';
301 
302 		/* Do nothing here */
303 		return 0;
304 	}
305 
306 	return -1;
307 }
308 
309 int gpio_alloc(u32 baseaddr, const char *name, u32 gpio_no)
310 {
311 	struct xilinx_gpio_priv *priv;
312 
313 	priv = calloc(1, sizeof(struct xilinx_gpio_priv));
314 
315 	/* Setup gpio name */
316 	if (name != NULL) {
317 		strncpy(priv->name, name, GPIO_NAME_SIZE);
318 		priv->name[GPIO_NAME_SIZE - 1] = '\0';
319 	}
320 	priv->regs = (struct gpio_regs *)baseaddr;
321 
322 	priv->gpio_min = xilinx_gpio_max;
323 	xilinx_gpio_max = priv->gpio_min + gpio_no;
324 	priv->gpio_max = xilinx_gpio_max - 1;
325 
326 	priv->gpio_name = calloc(gpio_no, sizeof(struct gpio_names));
327 
328 	INIT_LIST_HEAD(&priv->list);
329 	list_add_tail(&priv->list, &gpio_list);
330 
331 	printf("%s: Add %s (%d-%d)\n", __func__, name,
332 	       priv->gpio_min, priv->gpio_max);
333 
334 	/* Return the first gpio allocated for this device */
335 	return priv->gpio_min;
336 }
337 
338 /* Dual channel gpio is one IP with two independent channels */
339 int gpio_alloc_dual(u32 baseaddr, const char *name, u32 gpio_no0, u32 gpio_no1)
340 {
341 	int ret;
342 
343 	ret = gpio_alloc(baseaddr, name, gpio_no0);
344 	gpio_alloc(baseaddr + 8, strcat((char *)name, "_1"), gpio_no1);
345 
346 	/* Return the first gpio allocated for this device */
347 	return ret;
348 }
349