]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - drivers/gpio/gpiolib-of.c
Merge branch 'strscpy' of git://git.kernel.org/pub/scm/linux/kernel/git/cmetcalf...
[karo-tx-linux.git] / drivers / gpio / gpiolib-of.c
1 /*
2  * OF helpers for the GPIO API
3  *
4  * Copyright (c) 2007-2008  MontaVista Software, Inc.
5  *
6  * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  */
13
14 #include <linux/device.h>
15 #include <linux/err.h>
16 #include <linux/errno.h>
17 #include <linux/module.h>
18 #include <linux/io.h>
19 #include <linux/gpio/consumer.h>
20 #include <linux/of.h>
21 #include <linux/of_address.h>
22 #include <linux/of_gpio.h>
23 #include <linux/pinctrl/pinctrl.h>
24 #include <linux/slab.h>
25 #include <linux/gpio/machine.h>
26
27 #include "gpiolib.h"
28
29 /* Private data structure for of_gpiochip_find_and_xlate */
30 struct gg_data {
31         enum of_gpio_flags *flags;
32         struct of_phandle_args gpiospec;
33
34         struct gpio_desc *out_gpio;
35 };
36
37 /* Private function for resolving node pointer to gpio_chip */
38 static int of_gpiochip_find_and_xlate(struct gpio_chip *gc, void *data)
39 {
40         struct gg_data *gg_data = data;
41         int ret;
42
43         if ((gc->of_node != gg_data->gpiospec.np) ||
44             (gc->of_gpio_n_cells != gg_data->gpiospec.args_count) ||
45             (!gc->of_xlate))
46                 return false;
47
48         ret = gc->of_xlate(gc, &gg_data->gpiospec, gg_data->flags);
49         if (ret < 0) {
50                 /* We've found a gpio chip, but the translation failed.
51                  * Store translation error in out_gpio.
52                  * Return false to keep looking, as more than one gpio chip
53                  * could be registered per of-node.
54                  */
55                 gg_data->out_gpio = ERR_PTR(ret);
56                 return false;
57          }
58
59         gg_data->out_gpio = gpiochip_get_desc(gc, ret);
60         return true;
61 }
62
63 /**
64  * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
65  * @np:         device node to get GPIO from
66  * @propname:   property name containing gpio specifier(s)
67  * @index:      index of the GPIO
68  * @flags:      a flags pointer to fill in
69  *
70  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
71  * value on the error condition. If @flags is not NULL the function also fills
72  * in flags for the GPIO.
73  */
74 struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
75                      const char *propname, int index, enum of_gpio_flags *flags)
76 {
77         /* Return -EPROBE_DEFER to support probe() functions to be called
78          * later when the GPIO actually becomes available
79          */
80         struct gg_data gg_data = {
81                 .flags = flags,
82                 .out_gpio = ERR_PTR(-EPROBE_DEFER)
83         };
84         int ret;
85
86         /* .of_xlate might decide to not fill in the flags, so clear it. */
87         if (flags)
88                 *flags = 0;
89
90         ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
91                                          &gg_data.gpiospec);
92         if (ret) {
93                 pr_debug("%s: can't parse '%s' property of node '%s[%d]'\n",
94                         __func__, propname, np->full_name, index);
95                 return ERR_PTR(ret);
96         }
97
98         gpiochip_find(&gg_data, of_gpiochip_find_and_xlate);
99
100         of_node_put(gg_data.gpiospec.np);
101         pr_debug("%s: parsed '%s' property of node '%s[%d]' - status (%d)\n",
102                  __func__, propname, np->full_name, index,
103                  PTR_ERR_OR_ZERO(gg_data.out_gpio));
104         return gg_data.out_gpio;
105 }
106
107 int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
108                             int index, enum of_gpio_flags *flags)
109 {
110         struct gpio_desc *desc;
111
112         desc = of_get_named_gpiod_flags(np, list_name, index, flags);
113
114         if (IS_ERR(desc))
115                 return PTR_ERR(desc);
116         else
117                 return desc_to_gpio(desc);
118 }
119 EXPORT_SYMBOL(of_get_named_gpio_flags);
120
121 /**
122  * of_get_gpio_hog() - Get a GPIO hog descriptor, names and flags for GPIO API
123  * @np:         device node to get GPIO from
124  * @name:       GPIO line name
125  * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
126  *              of_get_gpio_hog()
127  * @dflags:     gpiod_flags - optional GPIO initialization flags
128  *
129  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
130  * value on the error condition.
131  */
132 static struct gpio_desc *of_get_gpio_hog(struct device_node *np,
133                                   const char **name,
134                                   enum gpio_lookup_flags *lflags,
135                                   enum gpiod_flags *dflags)
136 {
137         struct device_node *chip_np;
138         enum of_gpio_flags xlate_flags;
139         struct gg_data gg_data = {
140                 .flags = &xlate_flags,
141         };
142         u32 tmp;
143         int i, ret;
144
145         chip_np = np->parent;
146         if (!chip_np)
147                 return ERR_PTR(-EINVAL);
148
149         xlate_flags = 0;
150         *lflags = 0;
151         *dflags = 0;
152
153         ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
154         if (ret)
155                 return ERR_PTR(ret);
156
157         if (tmp > MAX_PHANDLE_ARGS)
158                 return ERR_PTR(-EINVAL);
159
160         gg_data.gpiospec.args_count = tmp;
161         gg_data.gpiospec.np = chip_np;
162         for (i = 0; i < tmp; i++) {
163                 ret = of_property_read_u32_index(np, "gpios", i,
164                                            &gg_data.gpiospec.args[i]);
165                 if (ret)
166                         return ERR_PTR(ret);
167         }
168
169         gpiochip_find(&gg_data, of_gpiochip_find_and_xlate);
170         if (!gg_data.out_gpio) {
171                 if (np->parent == np)
172                         return ERR_PTR(-ENXIO);
173                 else
174                         return ERR_PTR(-EINVAL);
175         }
176
177         if (xlate_flags & OF_GPIO_ACTIVE_LOW)
178                 *lflags |= GPIO_ACTIVE_LOW;
179
180         if (of_property_read_bool(np, "input"))
181                 *dflags |= GPIOD_IN;
182         else if (of_property_read_bool(np, "output-low"))
183                 *dflags |= GPIOD_OUT_LOW;
184         else if (of_property_read_bool(np, "output-high"))
185                 *dflags |= GPIOD_OUT_HIGH;
186         else {
187                 pr_warn("GPIO line %d (%s): no hogging state specified, bailing out\n",
188                         desc_to_gpio(gg_data.out_gpio), np->name);
189                 return ERR_PTR(-EINVAL);
190         }
191
192         if (name && of_property_read_string(np, "line-name", name))
193                 *name = np->name;
194
195         return gg_data.out_gpio;
196 }
197
198 /**
199  * of_gpiochip_scan_hogs - Scan gpio-controller and apply GPIO hog as requested
200  * @chip:       gpio chip to act on
201  *
202  * This is only used by of_gpiochip_add to request/set GPIO initial
203  * configuration.
204  */
205 static void of_gpiochip_scan_hogs(struct gpio_chip *chip)
206 {
207         struct gpio_desc *desc = NULL;
208         struct device_node *np;
209         const char *name;
210         enum gpio_lookup_flags lflags;
211         enum gpiod_flags dflags;
212
213         for_each_child_of_node(chip->of_node, np) {
214                 if (!of_property_read_bool(np, "gpio-hog"))
215                         continue;
216
217                 desc = of_get_gpio_hog(np, &name, &lflags, &dflags);
218                 if (IS_ERR(desc))
219                         continue;
220
221                 if (gpiod_hog(desc, name, lflags, dflags))
222                         continue;
223         }
224 }
225
226 /**
227  * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
228  * @gc:         pointer to the gpio_chip structure
229  * @np:         device node of the GPIO chip
230  * @gpio_spec:  gpio specifier as found in the device tree
231  * @flags:      a flags pointer to fill in
232  *
233  * This is simple translation function, suitable for the most 1:1 mapped
234  * gpio chips. This function performs only one sanity check: whether gpio
235  * is less than ngpios (that is specified in the gpio_chip).
236  */
237 int of_gpio_simple_xlate(struct gpio_chip *gc,
238                          const struct of_phandle_args *gpiospec, u32 *flags)
239 {
240         /*
241          * We're discouraging gpio_cells < 2, since that way you'll have to
242          * write your own xlate function (that will have to retrieve the GPIO
243          * number and the flags from a single gpio cell -- this is possible,
244          * but not recommended).
245          */
246         if (gc->of_gpio_n_cells < 2) {
247                 WARN_ON(1);
248                 return -EINVAL;
249         }
250
251         if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
252                 return -EINVAL;
253
254         if (gpiospec->args[0] >= gc->ngpio)
255                 return -EINVAL;
256
257         if (flags)
258                 *flags = gpiospec->args[1];
259
260         return gpiospec->args[0];
261 }
262 EXPORT_SYMBOL(of_gpio_simple_xlate);
263
264 /**
265  * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
266  * @np:         device node of the GPIO chip
267  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
268  *
269  * To use this function you should allocate and fill mm_gc with:
270  *
271  * 1) In the gpio_chip structure:
272  *    - all the callbacks
273  *    - of_gpio_n_cells
274  *    - of_xlate callback (optional)
275  *
276  * 3) In the of_mm_gpio_chip structure:
277  *    - save_regs callback (optional)
278  *
279  * If succeeded, this function will map bank's memory and will
280  * do all necessary work for you. Then you'll able to use .regs
281  * to manage GPIOs from the callbacks.
282  */
283 int of_mm_gpiochip_add(struct device_node *np,
284                        struct of_mm_gpio_chip *mm_gc)
285 {
286         int ret = -ENOMEM;
287         struct gpio_chip *gc = &mm_gc->gc;
288
289         gc->label = kstrdup(np->full_name, GFP_KERNEL);
290         if (!gc->label)
291                 goto err0;
292
293         mm_gc->regs = of_iomap(np, 0);
294         if (!mm_gc->regs)
295                 goto err1;
296
297         gc->base = -1;
298
299         if (mm_gc->save_regs)
300                 mm_gc->save_regs(mm_gc);
301
302         mm_gc->gc.of_node = np;
303
304         ret = gpiochip_add(gc);
305         if (ret)
306                 goto err2;
307
308         return 0;
309 err2:
310         iounmap(mm_gc->regs);
311 err1:
312         kfree(gc->label);
313 err0:
314         pr_err("%s: GPIO chip registration failed with status %d\n",
315                np->full_name, ret);
316         return ret;
317 }
318 EXPORT_SYMBOL(of_mm_gpiochip_add);
319
320 /**
321  * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
322  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
323  */
324 void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
325 {
326         struct gpio_chip *gc = &mm_gc->gc;
327
328         if (!mm_gc)
329                 return;
330
331         gpiochip_remove(gc);
332         iounmap(mm_gc->regs);
333         kfree(gc->label);
334 }
335 EXPORT_SYMBOL(of_mm_gpiochip_remove);
336
337 #ifdef CONFIG_PINCTRL
338 static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
339 {
340         struct device_node *np = chip->of_node;
341         struct of_phandle_args pinspec;
342         struct pinctrl_dev *pctldev;
343         int index = 0, ret;
344         const char *name;
345         static const char group_names_propname[] = "gpio-ranges-group-names";
346         struct property *group_names;
347
348         if (!np)
349                 return 0;
350
351         group_names = of_find_property(np, group_names_propname, NULL);
352
353         for (;; index++) {
354                 ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
355                                 index, &pinspec);
356                 if (ret)
357                         break;
358
359                 pctldev = of_pinctrl_get(pinspec.np);
360                 if (!pctldev)
361                         return -EPROBE_DEFER;
362
363                 if (pinspec.args[2]) {
364                         if (group_names) {
365                                 of_property_read_string_index(np,
366                                                 group_names_propname,
367                                                 index, &name);
368                                 if (strlen(name)) {
369                                         pr_err("%s: Group name of numeric GPIO ranges must be the empty string.\n",
370                                                 np->full_name);
371                                         break;
372                                 }
373                         }
374                         /* npins != 0: linear range */
375                         ret = gpiochip_add_pin_range(chip,
376                                         pinctrl_dev_get_devname(pctldev),
377                                         pinspec.args[0],
378                                         pinspec.args[1],
379                                         pinspec.args[2]);
380                         if (ret)
381                                 return ret;
382                 } else {
383                         /* npins == 0: special range */
384                         if (pinspec.args[1]) {
385                                 pr_err("%s: Illegal gpio-range format.\n",
386                                         np->full_name);
387                                 break;
388                         }
389
390                         if (!group_names) {
391                                 pr_err("%s: GPIO group range requested but no %s property.\n",
392                                         np->full_name, group_names_propname);
393                                 break;
394                         }
395
396                         ret = of_property_read_string_index(np,
397                                                 group_names_propname,
398                                                 index, &name);
399                         if (ret)
400                                 break;
401
402                         if (!strlen(name)) {
403                                 pr_err("%s: Group name of GPIO group range cannot be the empty string.\n",
404                                 np->full_name);
405                                 break;
406                         }
407
408                         ret = gpiochip_add_pingroup_range(chip, pctldev,
409                                                 pinspec.args[0], name);
410                         if (ret)
411                                 return ret;
412                 }
413         }
414
415         return 0;
416 }
417
418 #else
419 static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
420 #endif
421
422 int of_gpiochip_add(struct gpio_chip *chip)
423 {
424         int status;
425
426         if ((!chip->of_node) && (chip->dev))
427                 chip->of_node = chip->dev->of_node;
428
429         if (!chip->of_node)
430                 return 0;
431
432         if (!chip->of_xlate) {
433                 chip->of_gpio_n_cells = 2;
434                 chip->of_xlate = of_gpio_simple_xlate;
435         }
436
437         status = of_gpiochip_add_pin_range(chip);
438         if (status)
439                 return status;
440
441         of_node_get(chip->of_node);
442
443         of_gpiochip_scan_hogs(chip);
444
445         return 0;
446 }
447
448 void of_gpiochip_remove(struct gpio_chip *chip)
449 {
450         gpiochip_remove_pin_ranges(chip);
451         of_node_put(chip->of_node);
452 }