gpio: Rework of_gpiochip_set_names() to use device property accessors
[muen/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 static int of_gpiochip_match_node(struct gpio_chip *chip, void *data)
30 {
31         return chip->gpiodev->dev.of_node == data;
32 }
33
34 static struct gpio_chip *of_find_gpiochip_by_node(struct device_node *np)
35 {
36         return gpiochip_find(np, of_gpiochip_match_node);
37 }
38
39 static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
40                                         struct of_phandle_args *gpiospec,
41                                         enum of_gpio_flags *flags)
42 {
43         int ret;
44
45         if (chip->of_gpio_n_cells != gpiospec->args_count)
46                 return ERR_PTR(-EINVAL);
47
48         ret = chip->of_xlate(chip, gpiospec, flags);
49         if (ret < 0)
50                 return ERR_PTR(ret);
51
52         return gpiochip_get_desc(chip, ret);
53 }
54
55 /**
56  * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
57  * @np:         device node to get GPIO from
58  * @propname:   property name containing gpio specifier(s)
59  * @index:      index of the GPIO
60  * @flags:      a flags pointer to fill in
61  *
62  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
63  * value on the error condition. If @flags is not NULL the function also fills
64  * in flags for the GPIO.
65  */
66 struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
67                      const char *propname, int index, enum of_gpio_flags *flags)
68 {
69         struct of_phandle_args gpiospec;
70         struct gpio_chip *chip;
71         struct gpio_desc *desc;
72         int ret;
73
74         ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
75                                          &gpiospec);
76         if (ret) {
77                 pr_debug("%s: can't parse '%s' property of node '%s[%d]'\n",
78                         __func__, propname, np->full_name, index);
79                 return ERR_PTR(ret);
80         }
81
82         chip = of_find_gpiochip_by_node(gpiospec.np);
83         if (!chip) {
84                 desc = ERR_PTR(-EPROBE_DEFER);
85                 goto out;
86         }
87
88         desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
89         if (IS_ERR(desc))
90                 goto out;
91
92         pr_debug("%s: parsed '%s' property of node '%s[%d]' - status (%d)\n",
93                  __func__, propname, np->full_name, index,
94                  PTR_ERR_OR_ZERO(desc));
95
96 out:
97         of_node_put(gpiospec.np);
98
99         return desc;
100 }
101
102 int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
103                             int index, enum of_gpio_flags *flags)
104 {
105         struct gpio_desc *desc;
106
107         desc = of_get_named_gpiod_flags(np, list_name, index, flags);
108
109         if (IS_ERR(desc))
110                 return PTR_ERR(desc);
111         else
112                 return desc_to_gpio(desc);
113 }
114 EXPORT_SYMBOL(of_get_named_gpio_flags);
115
116 struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
117                                unsigned int idx,
118                                enum gpio_lookup_flags *flags)
119 {
120         char prop_name[32]; /* 32 is max size of property name */
121         enum of_gpio_flags of_flags;
122         struct gpio_desc *desc;
123         unsigned int i;
124
125         for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
126                 if (con_id)
127                         snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
128                                  gpio_suffixes[i]);
129                 else
130                         snprintf(prop_name, sizeof(prop_name), "%s",
131                                  gpio_suffixes[i]);
132
133                 desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
134                                                 &of_flags);
135                 if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT))
136                         break;
137         }
138
139         if (IS_ERR(desc))
140                 return desc;
141
142         if (of_flags & OF_GPIO_ACTIVE_LOW)
143                 *flags |= GPIO_ACTIVE_LOW;
144
145         if (of_flags & OF_GPIO_SINGLE_ENDED) {
146                 if (of_flags & OF_GPIO_ACTIVE_LOW)
147                         *flags |= GPIO_OPEN_DRAIN;
148                 else
149                         *flags |= GPIO_OPEN_SOURCE;
150         }
151
152         return desc;
153 }
154
155 /**
156  * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
157  * @np:         device node to get GPIO from
158  * @chip:       GPIO chip whose hog is parsed
159  * @name:       GPIO line name
160  * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
161  *              of_parse_own_gpio()
162  * @dflags:     gpiod_flags - optional GPIO initialization flags
163  *
164  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
165  * value on the error condition.
166  */
167 static struct gpio_desc *of_parse_own_gpio(struct device_node *np,
168                                            struct gpio_chip *chip,
169                                            const char **name,
170                                            enum gpio_lookup_flags *lflags,
171                                            enum gpiod_flags *dflags)
172 {
173         struct device_node *chip_np;
174         enum of_gpio_flags xlate_flags;
175         struct of_phandle_args gpiospec;
176         struct gpio_desc *desc;
177         u32 tmp;
178         int ret;
179
180         chip_np = chip->of_node;
181         if (!chip_np)
182                 return ERR_PTR(-EINVAL);
183
184         xlate_flags = 0;
185         *lflags = 0;
186         *dflags = 0;
187
188         ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
189         if (ret)
190                 return ERR_PTR(ret);
191
192         gpiospec.np = chip_np;
193         gpiospec.args_count = tmp;
194
195         ret = of_property_read_u32_array(np, "gpios", gpiospec.args, tmp);
196         if (ret)
197                 return ERR_PTR(ret);
198
199         desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags);
200         if (IS_ERR(desc))
201                 return desc;
202
203         if (xlate_flags & OF_GPIO_ACTIVE_LOW)
204                 *lflags |= GPIO_ACTIVE_LOW;
205
206         if (of_property_read_bool(np, "input"))
207                 *dflags |= GPIOD_IN;
208         else if (of_property_read_bool(np, "output-low"))
209                 *dflags |= GPIOD_OUT_LOW;
210         else if (of_property_read_bool(np, "output-high"))
211                 *dflags |= GPIOD_OUT_HIGH;
212         else {
213                 pr_warn("GPIO line %d (%s): no hogging state specified, bailing out\n",
214                         desc_to_gpio(desc), np->name);
215                 return ERR_PTR(-EINVAL);
216         }
217
218         if (name && of_property_read_string(np, "line-name", name))
219                 *name = np->name;
220
221         return desc;
222 }
223
224 /**
225  * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
226  * @chip:       gpio chip to act on
227  *
228  * This is only used by of_gpiochip_add to request/set GPIO initial
229  * configuration.
230  * It retures error if it fails otherwise 0 on success.
231  */
232 static int of_gpiochip_scan_gpios(struct gpio_chip *chip)
233 {
234         struct gpio_desc *desc = NULL;
235         struct device_node *np;
236         const char *name;
237         enum gpio_lookup_flags lflags;
238         enum gpiod_flags dflags;
239         int ret;
240
241         for_each_available_child_of_node(chip->of_node, np) {
242                 if (!of_property_read_bool(np, "gpio-hog"))
243                         continue;
244
245                 desc = of_parse_own_gpio(np, chip, &name, &lflags, &dflags);
246                 if (IS_ERR(desc))
247                         continue;
248
249                 ret = gpiod_hog(desc, name, lflags, dflags);
250                 if (ret < 0)
251                         return ret;
252         }
253
254         return 0;
255 }
256
257 /**
258  * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
259  * @gc:         pointer to the gpio_chip structure
260  * @np:         device node of the GPIO chip
261  * @gpio_spec:  gpio specifier as found in the device tree
262  * @flags:      a flags pointer to fill in
263  *
264  * This is simple translation function, suitable for the most 1:1 mapped
265  * gpio chips. This function performs only one sanity check: whether gpio
266  * is less than ngpios (that is specified in the gpio_chip).
267  */
268 int of_gpio_simple_xlate(struct gpio_chip *gc,
269                          const struct of_phandle_args *gpiospec, u32 *flags)
270 {
271         /*
272          * We're discouraging gpio_cells < 2, since that way you'll have to
273          * write your own xlate function (that will have to retrieve the GPIO
274          * number and the flags from a single gpio cell -- this is possible,
275          * but not recommended).
276          */
277         if (gc->of_gpio_n_cells < 2) {
278                 WARN_ON(1);
279                 return -EINVAL;
280         }
281
282         if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
283                 return -EINVAL;
284
285         if (gpiospec->args[0] >= gc->ngpio)
286                 return -EINVAL;
287
288         if (flags)
289                 *flags = gpiospec->args[1];
290
291         return gpiospec->args[0];
292 }
293 EXPORT_SYMBOL(of_gpio_simple_xlate);
294
295 /**
296  * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
297  * @np:         device node of the GPIO chip
298  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
299  * @data:       driver data to store in the struct gpio_chip
300  *
301  * To use this function you should allocate and fill mm_gc with:
302  *
303  * 1) In the gpio_chip structure:
304  *    - all the callbacks
305  *    - of_gpio_n_cells
306  *    - of_xlate callback (optional)
307  *
308  * 3) In the of_mm_gpio_chip structure:
309  *    - save_regs callback (optional)
310  *
311  * If succeeded, this function will map bank's memory and will
312  * do all necessary work for you. Then you'll able to use .regs
313  * to manage GPIOs from the callbacks.
314  */
315 int of_mm_gpiochip_add_data(struct device_node *np,
316                             struct of_mm_gpio_chip *mm_gc,
317                             void *data)
318 {
319         int ret = -ENOMEM;
320         struct gpio_chip *gc = &mm_gc->gc;
321
322         gc->label = kstrdup(np->full_name, GFP_KERNEL);
323         if (!gc->label)
324                 goto err0;
325
326         mm_gc->regs = of_iomap(np, 0);
327         if (!mm_gc->regs)
328                 goto err1;
329
330         gc->base = -1;
331
332         if (mm_gc->save_regs)
333                 mm_gc->save_regs(mm_gc);
334
335         mm_gc->gc.of_node = np;
336
337         ret = gpiochip_add_data(gc, data);
338         if (ret)
339                 goto err2;
340
341         return 0;
342 err2:
343         iounmap(mm_gc->regs);
344 err1:
345         kfree(gc->label);
346 err0:
347         pr_err("%s: GPIO chip registration failed with status %d\n",
348                np->full_name, ret);
349         return ret;
350 }
351 EXPORT_SYMBOL(of_mm_gpiochip_add_data);
352
353 /**
354  * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
355  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
356  */
357 void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
358 {
359         struct gpio_chip *gc = &mm_gc->gc;
360
361         if (!mm_gc)
362                 return;
363
364         gpiochip_remove(gc);
365         iounmap(mm_gc->regs);
366         kfree(gc->label);
367 }
368 EXPORT_SYMBOL(of_mm_gpiochip_remove);
369
370 #ifdef CONFIG_PINCTRL
371 static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
372 {
373         struct device_node *np = chip->of_node;
374         struct of_phandle_args pinspec;
375         struct pinctrl_dev *pctldev;
376         int index = 0, ret;
377         const char *name;
378         static const char group_names_propname[] = "gpio-ranges-group-names";
379         struct property *group_names;
380
381         if (!np)
382                 return 0;
383
384         group_names = of_find_property(np, group_names_propname, NULL);
385
386         for (;; index++) {
387                 ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
388                                 index, &pinspec);
389                 if (ret)
390                         break;
391
392                 pctldev = of_pinctrl_get(pinspec.np);
393                 of_node_put(pinspec.np);
394                 if (!pctldev)
395                         return -EPROBE_DEFER;
396
397                 if (pinspec.args[2]) {
398                         if (group_names) {
399                                 of_property_read_string_index(np,
400                                                 group_names_propname,
401                                                 index, &name);
402                                 if (strlen(name)) {
403                                         pr_err("%s: Group name of numeric GPIO ranges must be the empty string.\n",
404                                                 np->full_name);
405                                         break;
406                                 }
407                         }
408                         /* npins != 0: linear range */
409                         ret = gpiochip_add_pin_range(chip,
410                                         pinctrl_dev_get_devname(pctldev),
411                                         pinspec.args[0],
412                                         pinspec.args[1],
413                                         pinspec.args[2]);
414                         if (ret)
415                                 return ret;
416                 } else {
417                         /* npins == 0: special range */
418                         if (pinspec.args[1]) {
419                                 pr_err("%s: Illegal gpio-range format.\n",
420                                         np->full_name);
421                                 break;
422                         }
423
424                         if (!group_names) {
425                                 pr_err("%s: GPIO group range requested but no %s property.\n",
426                                         np->full_name, group_names_propname);
427                                 break;
428                         }
429
430                         ret = of_property_read_string_index(np,
431                                                 group_names_propname,
432                                                 index, &name);
433                         if (ret)
434                                 break;
435
436                         if (!strlen(name)) {
437                                 pr_err("%s: Group name of GPIO group range cannot be the empty string.\n",
438                                 np->full_name);
439                                 break;
440                         }
441
442                         ret = gpiochip_add_pingroup_range(chip, pctldev,
443                                                 pinspec.args[0], name);
444                         if (ret)
445                                 return ret;
446                 }
447         }
448
449         return 0;
450 }
451
452 #else
453 static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
454 #endif
455
456 int of_gpiochip_add(struct gpio_chip *chip)
457 {
458         int status;
459
460         if ((!chip->of_node) && (chip->parent))
461                 chip->of_node = chip->parent->of_node;
462
463         if (!chip->of_node)
464                 return 0;
465
466         if (!chip->of_xlate) {
467                 chip->of_gpio_n_cells = 2;
468                 chip->of_xlate = of_gpio_simple_xlate;
469         }
470
471         if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
472                 return -EINVAL;
473
474         status = of_gpiochip_add_pin_range(chip);
475         if (status)
476                 return status;
477
478         /* If the chip defines names itself, these take precedence */
479         if (!chip->names)
480                 devprop_gpiochip_set_names(chip);
481
482         of_node_get(chip->of_node);
483
484         return of_gpiochip_scan_gpios(chip);
485 }
486
487 void of_gpiochip_remove(struct gpio_chip *chip)
488 {
489         gpiochip_remove_pin_ranges(chip);
490         of_node_put(chip->of_node);
491 }