fea9d17f8e628b1a98fdbd2c921396ba78f3d644
[karo-tx-uboot.git] / drivers / gpio / tegra_gpio.c
1 /*
2  * NVIDIA Tegra20 GPIO handling.
3  *  (C) Copyright 2010-2012
4  *  NVIDIA Corporation <www.nvidia.com>
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 /*
10  * Based on (mostly copied from) kw_gpio.c based Linux 2.6 kernel driver.
11  * Tom Warren (twarren@nvidia.com)
12  */
13
14 #include <common.h>
15 #include <asm/io.h>
16 #include <asm/bitops.h>
17 #include <asm/arch/tegra.h>
18 #include <asm/gpio.h>
19
20 enum {
21         TEGRA_CMD_INFO,
22         TEGRA_CMD_PORT,
23         TEGRA_CMD_OUTPUT,
24         TEGRA_CMD_INPUT,
25 };
26
27 static struct gpio_names {
28         char name[GPIO_NAME_SIZE];
29 } gpio_names[MAX_NUM_GPIOS];
30
31 static char *get_name(int i)
32 {
33         return *gpio_names[i].name ? gpio_names[i].name : "UNKNOWN";
34 }
35
36 /* Return config of pin 'gpio' as GPIO (1) or SFPIO (0) */
37 static int get_config(unsigned gpio)
38 {
39         struct gpio_ctlr *ctlr = (struct gpio_ctlr *)NV_PA_GPIO_BASE;
40         struct gpio_ctlr_bank *bank = &ctlr->gpio_bank[GPIO_BANK(gpio)];
41         u32 u;
42         int type;
43
44         u = readl(&bank->gpio_config[GPIO_PORT(gpio)]);
45         type =  (u >> GPIO_BIT(gpio)) & 1;
46
47         debug("get_config: port = %d, bit = %d is %s\n",
48                 GPIO_FULLPORT(gpio), GPIO_BIT(gpio), type ? "GPIO" : "SFPIO");
49
50         return type;
51 }
52
53 /* Config pin 'gpio' as GPIO or SFPIO, based on 'type' */
54 static void set_config(unsigned gpio, int type)
55 {
56         struct gpio_ctlr *ctlr = (struct gpio_ctlr *)NV_PA_GPIO_BASE;
57         struct gpio_ctlr_bank *bank = &ctlr->gpio_bank[GPIO_BANK(gpio)];
58         u32 u;
59
60         debug("set_config: port = %d, bit = %d, %s\n",
61                 GPIO_FULLPORT(gpio), GPIO_BIT(gpio), type ? "GPIO" : "SFPIO");
62
63         u = readl(&bank->gpio_config[GPIO_PORT(gpio)]);
64         if (type)                               /* GPIO */
65                 u |= 1 << GPIO_BIT(gpio);
66         else
67                 u &= ~(1 << GPIO_BIT(gpio));
68         writel(u, &bank->gpio_config[GPIO_PORT(gpio)]);
69 }
70
71 /* Return GPIO pin 'gpio' direction - 0 = input or 1 = output */
72 static int get_direction(unsigned gpio)
73 {
74         struct gpio_ctlr *ctlr = (struct gpio_ctlr *)NV_PA_GPIO_BASE;
75         struct gpio_ctlr_bank *bank = &ctlr->gpio_bank[GPIO_BANK(gpio)];
76         u32 u;
77         int dir;
78
79         u = readl(&bank->gpio_dir_out[GPIO_PORT(gpio)]);
80         dir =  (u >> GPIO_BIT(gpio)) & 1;
81
82         debug("get_direction: port = %d, bit = %d, %s\n",
83                 GPIO_FULLPORT(gpio), GPIO_BIT(gpio), dir ? "OUT" : "IN");
84
85         return dir;
86 }
87
88 /* Config GPIO pin 'gpio' as input or output (OE) as per 'output' */
89 static void set_direction(unsigned gpio, int output)
90 {
91         struct gpio_ctlr *ctlr = (struct gpio_ctlr *)NV_PA_GPIO_BASE;
92         struct gpio_ctlr_bank *bank = &ctlr->gpio_bank[GPIO_BANK(gpio)];
93         u32 u;
94
95         debug("set_direction: port = %d, bit = %d, %s\n",
96                 GPIO_FULLPORT(gpio), GPIO_BIT(gpio), output ? "OUT" : "IN");
97
98         u = readl(&bank->gpio_dir_out[GPIO_PORT(gpio)]);
99         if (output)
100                 u |= 1 << GPIO_BIT(gpio);
101         else
102                 u &= ~(1 << GPIO_BIT(gpio));
103         writel(u, &bank->gpio_dir_out[GPIO_PORT(gpio)]);
104 }
105
106 /* set GPIO pin 'gpio' output bit as 0 or 1 as per 'high' */
107 static void set_level(unsigned gpio, int high)
108 {
109         struct gpio_ctlr *ctlr = (struct gpio_ctlr *)NV_PA_GPIO_BASE;
110         struct gpio_ctlr_bank *bank = &ctlr->gpio_bank[GPIO_BANK(gpio)];
111         u32 u;
112
113         debug("set_level: port = %d, bit %d == %d\n",
114                 GPIO_FULLPORT(gpio), GPIO_BIT(gpio), high);
115
116         u = readl(&bank->gpio_out[GPIO_PORT(gpio)]);
117         if (high)
118                 u |= 1 << GPIO_BIT(gpio);
119         else
120                 u &= ~(1 << GPIO_BIT(gpio));
121         writel(u, &bank->gpio_out[GPIO_PORT(gpio)]);
122 }
123
124 /*
125  * Generic_GPIO primitives.
126  */
127
128 int gpio_request(unsigned gpio, const char *label)
129 {
130         if (gpio >= MAX_NUM_GPIOS)
131                 return -1;
132
133         if (label != NULL) {
134                 strncpy(gpio_names[gpio].name, label, GPIO_NAME_SIZE);
135                 gpio_names[gpio].name[GPIO_NAME_SIZE - 1] = '\0';
136         }
137
138         /* Configure as a GPIO */
139         set_config(gpio, 1);
140
141         return 0;
142 }
143
144 int gpio_free(unsigned gpio)
145 {
146         if (gpio >= MAX_NUM_GPIOS)
147                 return -1;
148
149         gpio_names[gpio].name[0] = '\0';
150         /* Do not configure as input or change pin mux here */
151         return 0;
152 }
153
154 /* read GPIO OUT value of pin 'gpio' */
155 static int gpio_get_output_value(unsigned gpio)
156 {
157         struct gpio_ctlr *ctlr = (struct gpio_ctlr *)NV_PA_GPIO_BASE;
158         struct gpio_ctlr_bank *bank = &ctlr->gpio_bank[GPIO_BANK(gpio)];
159         int val;
160
161         debug("gpio_get_output_value: pin = %d (port %d:bit %d)\n",
162                 gpio, GPIO_FULLPORT(gpio), GPIO_BIT(gpio));
163
164         val = readl(&bank->gpio_out[GPIO_PORT(gpio)]);
165
166         return (val >> GPIO_BIT(gpio)) & 1;
167 }
168
169 /* set GPIO pin 'gpio' as an input */
170 int gpio_direction_input(unsigned gpio)
171 {
172         debug("gpio_direction_input: pin = %d (port %d:bit %d)\n",
173                 gpio, GPIO_FULLPORT(gpio), GPIO_BIT(gpio));
174
175         /* Configure GPIO direction as input. */
176         set_direction(gpio, 0);
177
178         return 0;
179 }
180
181 /* set GPIO pin 'gpio' as an output, with polarity 'value' */
182 int gpio_direction_output(unsigned gpio, int value)
183 {
184         debug("gpio_direction_output: pin = %d (port %d:bit %d) = %s\n",
185                 gpio, GPIO_FULLPORT(gpio), GPIO_BIT(gpio),
186                 value ? "HIGH" : "LOW");
187
188         /* Configure GPIO output value. */
189         set_level(gpio, value);
190
191         /* Configure GPIO direction as output. */
192         set_direction(gpio, 1);
193
194         return 0;
195 }
196
197 /* read GPIO IN value of pin 'gpio' */
198 int gpio_get_value(unsigned gpio)
199 {
200         struct gpio_ctlr *ctlr = (struct gpio_ctlr *)NV_PA_GPIO_BASE;
201         struct gpio_ctlr_bank *bank = &ctlr->gpio_bank[GPIO_BANK(gpio)];
202         int val;
203
204         debug("gpio_get_value: pin = %d (port %d:bit %d)\n",
205                 gpio, GPIO_FULLPORT(gpio), GPIO_BIT(gpio));
206
207         val = readl(&bank->gpio_in[GPIO_PORT(gpio)]);
208
209         return (val >> GPIO_BIT(gpio)) & 1;
210 }
211
212 /* write GPIO OUT value to pin 'gpio' */
213 int gpio_set_value(unsigned gpio, int value)
214 {
215         debug("gpio_set_value: pin = %d (port %d:bit %d), value = %d\n",
216                 gpio, GPIO_FULLPORT(gpio), GPIO_BIT(gpio), value);
217
218         /* Configure GPIO output value. */
219         set_level(gpio, value);
220
221         return 0;
222 }
223
224 void gpio_config_table(const struct tegra_gpio_config *config, int len)
225 {
226         int i;
227
228         for (i = 0; i < len; i++) {
229                 switch (config[i].init) {
230                 case TEGRA_GPIO_INIT_IN:
231                         gpio_direction_input(config[i].gpio);
232                         break;
233                 case TEGRA_GPIO_INIT_OUT0:
234                         gpio_direction_output(config[i].gpio, 0);
235                         break;
236                 case TEGRA_GPIO_INIT_OUT1:
237                         gpio_direction_output(config[i].gpio, 1);
238                         break;
239                 }
240                 set_config(config[i].gpio, 1);
241         }
242 }
243
244 /*
245  * Display Tegra GPIO information
246  */
247 void gpio_info(void)
248 {
249         unsigned c;
250         int type;
251
252         for (c = 0; c < MAX_NUM_GPIOS; c++) {
253                 type = get_config(c);           /* GPIO, not SFPIO */
254                 if (type) {
255                         printf("GPIO_%d:\t%s is an %s, ", c,
256                                 get_name(c),
257                                 get_direction(c) ? "OUTPUT" : "INPUT");
258                         if (get_direction(c))
259                                 printf("value = %d", gpio_get_output_value(c));
260                         else
261                                 printf("value = %d", gpio_get_value(c));
262                         printf("\n");
263                 } else
264                         continue;
265         }
266 }