1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2009 Wind River Systems, Inc.
4 * Tom Rix <Tom.Rix@windriver.com>
5 *
6 * This work is derived from the linux 2.6.27 kernel source
7 * To fetch, use the kernel repository
8 * git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
9 * Use the v2.6.27 tag.
10 *
11 * Below is the original's header including its copyright
12 *
13 * linux/arch/arm/plat-omap/gpio.c
14 *
15 * Support functions for OMAP GPIO
16 *
17 * Copyright (C) 2003-2005 Nokia Corporation
18 * Written by Juha Yrjölä <juha.yrjola@nokia.com>
19 */
20 #include <common.h>
21 #include <dm.h>
22 #include <fdtdec.h>
23 #include <asm/gpio.h>
24 #include <asm/io.h>
25 #include <linux/errno.h>
26 #include <malloc.h>
27
28 DECLARE_GLOBAL_DATA_PTR;
29
30 #define OMAP_GPIO_DIR_OUT 0
31 #define OMAP_GPIO_DIR_IN 1
32
33 #ifdef CONFIG_DM_GPIO
34
35 #define GPIO_PER_BANK 32
36
37 struct gpio_bank {
38 /* TODO(sjg@chromium.org): Can we use a struct here? */
39 void *base; /* address of registers in physical memory */
40 };
41
42 #endif
43
get_gpio_index(int gpio)44 static inline int get_gpio_index(int gpio)
45 {
46 return gpio & 0x1f;
47 }
48
gpio_is_valid(int gpio)49 int gpio_is_valid(int gpio)
50 {
51 return (gpio >= 0) && (gpio < OMAP_MAX_GPIO);
52 }
53
_set_gpio_direction(const struct gpio_bank * bank,int gpio,int is_input)54 static void _set_gpio_direction(const struct gpio_bank *bank, int gpio,
55 int is_input)
56 {
57 void *reg = bank->base;
58 u32 l;
59
60 reg += OMAP_GPIO_OE;
61
62 l = __raw_readl(reg);
63 if (is_input)
64 l |= 1 << gpio;
65 else
66 l &= ~(1 << gpio);
67 __raw_writel(l, reg);
68 }
69
70 /**
71 * Get the direction of the GPIO by reading the GPIO_OE register
72 * corresponding to the specified bank.
73 */
_get_gpio_direction(const struct gpio_bank * bank,int gpio)74 static int _get_gpio_direction(const struct gpio_bank *bank, int gpio)
75 {
76 void *reg = bank->base;
77 u32 v;
78
79 reg += OMAP_GPIO_OE;
80
81 v = __raw_readl(reg);
82
83 if (v & (1 << gpio))
84 return OMAP_GPIO_DIR_IN;
85 else
86 return OMAP_GPIO_DIR_OUT;
87 }
88
_set_gpio_dataout(const struct gpio_bank * bank,int gpio,int enable)89 static void _set_gpio_dataout(const struct gpio_bank *bank, int gpio,
90 int enable)
91 {
92 void *reg = bank->base;
93 u32 l = 0;
94
95 if (enable)
96 reg += OMAP_GPIO_SETDATAOUT;
97 else
98 reg += OMAP_GPIO_CLEARDATAOUT;
99
100 l = 1 << gpio;
101 __raw_writel(l, reg);
102 }
103
_get_gpio_value(const struct gpio_bank * bank,int gpio)104 static int _get_gpio_value(const struct gpio_bank *bank, int gpio)
105 {
106 void *reg = bank->base;
107 int input;
108
109 input = _get_gpio_direction(bank, gpio);
110 switch (input) {
111 case OMAP_GPIO_DIR_IN:
112 reg += OMAP_GPIO_DATAIN;
113 break;
114 case OMAP_GPIO_DIR_OUT:
115 reg += OMAP_GPIO_DATAOUT;
116 break;
117 default:
118 return -1;
119 }
120
121 return (__raw_readl(reg) & (1 << gpio)) != 0;
122 }
123
124 #ifndef CONFIG_DM_GPIO
125
get_gpio_bank(int gpio)126 static inline const struct gpio_bank *get_gpio_bank(int gpio)
127 {
128 return &omap_gpio_bank[gpio >> 5];
129 }
130
check_gpio(int gpio)131 static int check_gpio(int gpio)
132 {
133 if (!gpio_is_valid(gpio)) {
134 printf("ERROR : check_gpio: invalid GPIO %d\n", gpio);
135 return -1;
136 }
137 return 0;
138 }
139
140 /**
141 * Set value of the specified gpio
142 */
gpio_set_value(unsigned gpio,int value)143 int gpio_set_value(unsigned gpio, int value)
144 {
145 const struct gpio_bank *bank;
146
147 if (check_gpio(gpio) < 0)
148 return -1;
149 bank = get_gpio_bank(gpio);
150 _set_gpio_dataout(bank, get_gpio_index(gpio), value);
151
152 return 0;
153 }
154
155 /**
156 * Get value of the specified gpio
157 */
gpio_get_value(unsigned gpio)158 int gpio_get_value(unsigned gpio)
159 {
160 const struct gpio_bank *bank;
161
162 if (check_gpio(gpio) < 0)
163 return -1;
164 bank = get_gpio_bank(gpio);
165
166 return _get_gpio_value(bank, get_gpio_index(gpio));
167 }
168
169 /**
170 * Set gpio direction as input
171 */
gpio_direction_input(unsigned gpio)172 int gpio_direction_input(unsigned gpio)
173 {
174 const struct gpio_bank *bank;
175
176 if (check_gpio(gpio) < 0)
177 return -1;
178
179 bank = get_gpio_bank(gpio);
180 _set_gpio_direction(bank, get_gpio_index(gpio), 1);
181
182 return 0;
183 }
184
185 /**
186 * Set gpio direction as output
187 */
gpio_direction_output(unsigned gpio,int value)188 int gpio_direction_output(unsigned gpio, int value)
189 {
190 const struct gpio_bank *bank;
191
192 if (check_gpio(gpio) < 0)
193 return -1;
194
195 bank = get_gpio_bank(gpio);
196 _set_gpio_dataout(bank, get_gpio_index(gpio), value);
197 _set_gpio_direction(bank, get_gpio_index(gpio), 0);
198
199 return 0;
200 }
201
202 /**
203 * Request a gpio before using it.
204 *
205 * NOTE: Argument 'label' is unused.
206 */
gpio_request(unsigned gpio,const char * label)207 int gpio_request(unsigned gpio, const char *label)
208 {
209 if (check_gpio(gpio) < 0)
210 return -1;
211
212 return 0;
213 }
214
215 /**
216 * Reset and free the gpio after using it.
217 */
gpio_free(unsigned gpio)218 int gpio_free(unsigned gpio)
219 {
220 return 0;
221 }
222
223 #else /* new driver model interface CONFIG_DM_GPIO */
224
225 /* set GPIO pin 'gpio' as an input */
omap_gpio_direction_input(struct udevice * dev,unsigned offset)226 static int omap_gpio_direction_input(struct udevice *dev, unsigned offset)
227 {
228 struct gpio_bank *bank = dev_get_priv(dev);
229
230 /* Configure GPIO direction as input. */
231 _set_gpio_direction(bank, offset, 1);
232
233 return 0;
234 }
235
236 /* set GPIO pin 'gpio' as an output, with polarity 'value' */
omap_gpio_direction_output(struct udevice * dev,unsigned offset,int value)237 static int omap_gpio_direction_output(struct udevice *dev, unsigned offset,
238 int value)
239 {
240 struct gpio_bank *bank = dev_get_priv(dev);
241
242 _set_gpio_dataout(bank, offset, value);
243 _set_gpio_direction(bank, offset, 0);
244
245 return 0;
246 }
247
248 /* read GPIO IN value of pin 'gpio' */
omap_gpio_get_value(struct udevice * dev,unsigned offset)249 static int omap_gpio_get_value(struct udevice *dev, unsigned offset)
250 {
251 struct gpio_bank *bank = dev_get_priv(dev);
252
253 return _get_gpio_value(bank, offset);
254 }
255
256 /* write GPIO OUT value to pin 'gpio' */
omap_gpio_set_value(struct udevice * dev,unsigned offset,int value)257 static int omap_gpio_set_value(struct udevice *dev, unsigned offset,
258 int value)
259 {
260 struct gpio_bank *bank = dev_get_priv(dev);
261
262 _set_gpio_dataout(bank, offset, value);
263
264 return 0;
265 }
266
omap_gpio_get_function(struct udevice * dev,unsigned offset)267 static int omap_gpio_get_function(struct udevice *dev, unsigned offset)
268 {
269 struct gpio_bank *bank = dev_get_priv(dev);
270
271 /* GPIOF_FUNC is not implemented yet */
272 if (_get_gpio_direction(bank, offset) == OMAP_GPIO_DIR_OUT)
273 return GPIOF_OUTPUT;
274 else
275 return GPIOF_INPUT;
276 }
277
278 static const struct dm_gpio_ops gpio_omap_ops = {
279 .direction_input = omap_gpio_direction_input,
280 .direction_output = omap_gpio_direction_output,
281 .get_value = omap_gpio_get_value,
282 .set_value = omap_gpio_set_value,
283 .get_function = omap_gpio_get_function,
284 };
285
omap_gpio_probe(struct udevice * dev)286 static int omap_gpio_probe(struct udevice *dev)
287 {
288 struct gpio_bank *bank = dev_get_priv(dev);
289 struct omap_gpio_platdata *plat = dev_get_platdata(dev);
290 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
291 char name[18], *str;
292
293 sprintf(name, "gpio@%4x_", (unsigned int)plat->base);
294 str = strdup(name);
295 if (!str)
296 return -ENOMEM;
297 uc_priv->bank_name = str;
298 uc_priv->gpio_count = GPIO_PER_BANK;
299 bank->base = (void *)plat->base;
300 return 0;
301 }
302
303 #if !CONFIG_IS_ENABLED(OF_CONTROL)
omap_gpio_bind(struct udevice * dev)304 static int omap_gpio_bind(struct udevice *dev)
305 {
306 struct omap_gpio_platdata *plat = dev_get_platdata(dev);
307 fdt_addr_t base_addr;
308
309 if (plat)
310 return 0;
311
312 base_addr = devfdt_get_addr(dev);
313 if (base_addr == FDT_ADDR_T_NONE)
314 return -EINVAL;
315
316 /*
317 * TODO:
318 * When every board is converted to driver model and DT is
319 * supported, this can be done by auto-alloc feature, but
320 * not using calloc to alloc memory for platdata.
321 *
322 * For example am33xx_gpio uses platform data rather than device tree.
323 *
324 * NOTE: DO NOT COPY this code if you are using device tree.
325 */
326 plat = calloc(1, sizeof(*plat));
327 if (!plat)
328 return -ENOMEM;
329
330 plat->base = base_addr;
331 plat->port_name = fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL);
332 dev->platdata = plat;
333
334 return 0;
335 }
336 #endif
337
338 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
339 static const struct udevice_id omap_gpio_ids[] = {
340 { .compatible = "ti,omap3-gpio" },
341 { .compatible = "ti,omap4-gpio" },
342 { .compatible = "ti,am4372-gpio" },
343 { }
344 };
345
omap_gpio_ofdata_to_platdata(struct udevice * dev)346 static int omap_gpio_ofdata_to_platdata(struct udevice *dev)
347 {
348 struct omap_gpio_platdata *plat = dev_get_platdata(dev);
349 fdt_addr_t addr;
350
351 addr = devfdt_get_addr(dev);
352 if (addr == FDT_ADDR_T_NONE)
353 return -EINVAL;
354
355 plat->base = addr;
356 return 0;
357 }
358 #endif
359
360 U_BOOT_DRIVER(gpio_omap) = {
361 .name = "gpio_omap",
362 .id = UCLASS_GPIO,
363 #if CONFIG_IS_ENABLED(OF_CONTROL)
364 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
365 .of_match = omap_gpio_ids,
366 .ofdata_to_platdata = of_match_ptr(omap_gpio_ofdata_to_platdata),
367 .platdata_auto_alloc_size = sizeof(struct omap_gpio_platdata),
368 #endif
369 #else
370 .bind = omap_gpio_bind,
371 #endif
372 .ops = &gpio_omap_ops,
373 .probe = omap_gpio_probe,
374 .priv_auto_alloc_size = sizeof(struct gpio_bank),
375 #if !CONFIG_IS_ENABLED(OF_CONTROL)
376 .flags = DM_FLAG_PRE_RELOC,
377 #endif
378 };
379
380 #endif /* CONFIG_DM_GPIO */
381