Merge branch 'master' of git://git.denx.de/u-boot-arm
[platform/kernel/u-boot.git] / drivers / gpio / xilinx_gpio.c
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 }