2 * OF helpers for the GPIO API
4 * Copyright (c) 2007-2008 MontaVista Software, Inc.
6 * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
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.
14 #include <linux/device.h>
15 #include <linux/err.h>
16 #include <linux/errno.h>
17 #include <linux/module.h>
19 #include <linux/gpio/consumer.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>
29 static int of_gpiochip_match_node_and_xlate(struct gpio_chip
*chip
, void *data
)
31 struct of_phandle_args
*gpiospec
= data
;
33 return chip
->gpiodev
->dev
.of_node
== gpiospec
->np
&&
34 chip
->of_xlate(chip
, gpiospec
, NULL
) >= 0;
37 static struct gpio_chip
*of_find_gpiochip_by_xlate(
38 struct of_phandle_args
*gpiospec
)
40 return gpiochip_find(gpiospec
, of_gpiochip_match_node_and_xlate
);
43 static struct gpio_desc
*of_xlate_and_get_gpiod_flags(struct gpio_chip
*chip
,
44 struct of_phandle_args
*gpiospec
,
45 enum of_gpio_flags
*flags
)
49 if (chip
->of_gpio_n_cells
!= gpiospec
->args_count
)
50 return ERR_PTR(-EINVAL
);
52 ret
= chip
->of_xlate(chip
, gpiospec
, flags
);
56 return gpiochip_get_desc(chip
, ret
);
60 * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
61 * @np: device node to get GPIO from
62 * @propname: property name containing gpio specifier(s)
63 * @index: index of the GPIO
64 * @flags: a flags pointer to fill in
66 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
67 * value on the error condition. If @flags is not NULL the function also fills
68 * in flags for the GPIO.
70 struct gpio_desc
*of_get_named_gpiod_flags(struct device_node
*np
,
71 const char *propname
, int index
, enum of_gpio_flags
*flags
)
73 struct of_phandle_args gpiospec
;
74 struct gpio_chip
*chip
;
75 struct gpio_desc
*desc
;
78 ret
= of_parse_phandle_with_args(np
, propname
, "#gpio-cells", index
,
81 pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n",
82 __func__
, propname
, np
, index
);
86 chip
= of_find_gpiochip_by_xlate(&gpiospec
);
88 desc
= ERR_PTR(-EPROBE_DEFER
);
92 desc
= of_xlate_and_get_gpiod_flags(chip
, &gpiospec
, flags
);
96 pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n",
97 __func__
, propname
, np
, index
,
98 PTR_ERR_OR_ZERO(desc
));
101 of_node_put(gpiospec
.np
);
106 int of_get_named_gpio_flags(struct device_node
*np
, const char *list_name
,
107 int index
, enum of_gpio_flags
*flags
)
109 struct gpio_desc
*desc
;
111 desc
= of_get_named_gpiod_flags(np
, list_name
, index
, flags
);
114 return PTR_ERR(desc
);
116 return desc_to_gpio(desc
);
118 EXPORT_SYMBOL(of_get_named_gpio_flags
);
120 struct gpio_desc
*of_find_gpio(struct device
*dev
, const char *con_id
,
122 enum gpio_lookup_flags
*flags
)
124 char prop_name
[32]; /* 32 is max size of property name */
125 enum of_gpio_flags of_flags
;
126 struct gpio_desc
*desc
;
129 for (i
= 0; i
< ARRAY_SIZE(gpio_suffixes
); i
++) {
131 snprintf(prop_name
, sizeof(prop_name
), "%s-%s", con_id
,
134 snprintf(prop_name
, sizeof(prop_name
), "%s",
137 desc
= of_get_named_gpiod_flags(dev
->of_node
, prop_name
, idx
,
139 if (!IS_ERR(desc
) || (PTR_ERR(desc
) != -ENOENT
))
146 if (of_flags
& OF_GPIO_ACTIVE_LOW
)
147 *flags
|= GPIO_ACTIVE_LOW
;
149 if (of_flags
& OF_GPIO_SINGLE_ENDED
) {
150 if (of_flags
& OF_GPIO_OPEN_DRAIN
)
151 *flags
|= GPIO_OPEN_DRAIN
;
153 *flags
|= GPIO_OPEN_SOURCE
;
156 if (of_flags
& OF_GPIO_SLEEP_MAY_LOSE_VALUE
)
157 *flags
|= GPIO_SLEEP_MAY_LOSE_VALUE
;
163 * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
164 * @np: device node to get GPIO from
165 * @chip: GPIO chip whose hog is parsed
166 * @idx: Index of the GPIO to parse
167 * @name: GPIO line name
168 * @lflags: gpio_lookup_flags - returned from of_find_gpio() or
169 * of_parse_own_gpio()
170 * @dflags: gpiod_flags - optional GPIO initialization flags
172 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
173 * value on the error condition.
175 static struct gpio_desc
*of_parse_own_gpio(struct device_node
*np
,
176 struct gpio_chip
*chip
,
177 unsigned int idx
, const char **name
,
178 enum gpio_lookup_flags
*lflags
,
179 enum gpiod_flags
*dflags
)
181 struct device_node
*chip_np
;
182 enum of_gpio_flags xlate_flags
;
183 struct of_phandle_args gpiospec
;
184 struct gpio_desc
*desc
;
189 chip_np
= chip
->of_node
;
191 return ERR_PTR(-EINVAL
);
197 ret
= of_property_read_u32(chip_np
, "#gpio-cells", &tmp
);
201 gpiospec
.np
= chip_np
;
202 gpiospec
.args_count
= tmp
;
204 for (i
= 0; i
< tmp
; i
++) {
205 ret
= of_property_read_u32_index(np
, "gpios", idx
* tmp
+ i
,
211 desc
= of_xlate_and_get_gpiod_flags(chip
, &gpiospec
, &xlate_flags
);
215 if (xlate_flags
& OF_GPIO_ACTIVE_LOW
)
216 *lflags
|= GPIO_ACTIVE_LOW
;
218 if (of_property_read_bool(np
, "input"))
220 else if (of_property_read_bool(np
, "output-low"))
221 *dflags
|= GPIOD_OUT_LOW
;
222 else if (of_property_read_bool(np
, "output-high"))
223 *dflags
|= GPIOD_OUT_HIGH
;
225 pr_warn("GPIO line %d (%s): no hogging state specified, bailing out\n",
226 desc_to_gpio(desc
), np
->name
);
227 return ERR_PTR(-EINVAL
);
230 if (name
&& of_property_read_string(np
, "line-name", name
))
237 * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
238 * @chip: gpio chip to act on
240 * This is only used by of_gpiochip_add to request/set GPIO initial
242 * It returns error if it fails otherwise 0 on success.
244 static int of_gpiochip_scan_gpios(struct gpio_chip
*chip
)
246 struct gpio_desc
*desc
= NULL
;
247 struct device_node
*np
;
249 enum gpio_lookup_flags lflags
;
250 enum gpiod_flags dflags
;
254 for_each_available_child_of_node(chip
->of_node
, np
) {
255 if (!of_property_read_bool(np
, "gpio-hog"))
259 desc
= of_parse_own_gpio(np
, chip
, i
, &name
, &lflags
,
264 ret
= gpiod_hog(desc
, name
, lflags
, dflags
);
276 * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags
277 * @gc: pointer to the gpio_chip structure
278 * @gpiospec: GPIO specifier as found in the device tree
279 * @flags: a flags pointer to fill in
281 * This is simple translation function, suitable for the most 1:1 mapped
282 * GPIO chips. This function performs only one sanity check: whether GPIO
283 * is less than ngpios (that is specified in the gpio_chip).
285 int of_gpio_simple_xlate(struct gpio_chip
*gc
,
286 const struct of_phandle_args
*gpiospec
, u32
*flags
)
289 * We're discouraging gpio_cells < 2, since that way you'll have to
290 * write your own xlate function (that will have to retrieve the GPIO
291 * number and the flags from a single gpio cell -- this is possible,
292 * but not recommended).
294 if (gc
->of_gpio_n_cells
< 2) {
299 if (WARN_ON(gpiospec
->args_count
< gc
->of_gpio_n_cells
))
302 if (gpiospec
->args
[0] >= gc
->ngpio
)
306 *flags
= gpiospec
->args
[1];
308 return gpiospec
->args
[0];
310 EXPORT_SYMBOL(of_gpio_simple_xlate
);
313 * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
314 * @np: device node of the GPIO chip
315 * @mm_gc: pointer to the of_mm_gpio_chip allocated structure
316 * @data: driver data to store in the struct gpio_chip
318 * To use this function you should allocate and fill mm_gc with:
320 * 1) In the gpio_chip structure:
321 * - all the callbacks
323 * - of_xlate callback (optional)
325 * 3) In the of_mm_gpio_chip structure:
326 * - save_regs callback (optional)
328 * If succeeded, this function will map bank's memory and will
329 * do all necessary work for you. Then you'll able to use .regs
330 * to manage GPIOs from the callbacks.
332 int of_mm_gpiochip_add_data(struct device_node
*np
,
333 struct of_mm_gpio_chip
*mm_gc
,
337 struct gpio_chip
*gc
= &mm_gc
->gc
;
339 gc
->label
= kasprintf(GFP_KERNEL
, "%pOF", np
);
343 mm_gc
->regs
= of_iomap(np
, 0);
349 if (mm_gc
->save_regs
)
350 mm_gc
->save_regs(mm_gc
);
352 mm_gc
->gc
.of_node
= np
;
354 ret
= gpiochip_add_data(gc
, data
);
360 iounmap(mm_gc
->regs
);
364 pr_err("%pOF: GPIO chip registration failed with status %d\n", np
, ret
);
367 EXPORT_SYMBOL(of_mm_gpiochip_add_data
);
370 * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
371 * @mm_gc: pointer to the of_mm_gpio_chip allocated structure
373 void of_mm_gpiochip_remove(struct of_mm_gpio_chip
*mm_gc
)
375 struct gpio_chip
*gc
= &mm_gc
->gc
;
381 iounmap(mm_gc
->regs
);
384 EXPORT_SYMBOL(of_mm_gpiochip_remove
);
386 #ifdef CONFIG_PINCTRL
387 static int of_gpiochip_add_pin_range(struct gpio_chip
*chip
)
389 struct device_node
*np
= chip
->of_node
;
390 struct of_phandle_args pinspec
;
391 struct pinctrl_dev
*pctldev
;
394 static const char group_names_propname
[] = "gpio-ranges-group-names";
395 struct property
*group_names
;
400 group_names
= of_find_property(np
, group_names_propname
, NULL
);
403 ret
= of_parse_phandle_with_fixed_args(np
, "gpio-ranges", 3,
408 pctldev
= of_pinctrl_get(pinspec
.np
);
409 of_node_put(pinspec
.np
);
411 return -EPROBE_DEFER
;
413 if (pinspec
.args
[2]) {
415 of_property_read_string_index(np
,
416 group_names_propname
,
419 pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n",
424 /* npins != 0: linear range */
425 ret
= gpiochip_add_pin_range(chip
,
426 pinctrl_dev_get_devname(pctldev
),
433 /* npins == 0: special range */
434 if (pinspec
.args
[1]) {
435 pr_err("%pOF: Illegal gpio-range format.\n",
441 pr_err("%pOF: GPIO group range requested but no %s property.\n",
442 np
, group_names_propname
);
446 ret
= of_property_read_string_index(np
,
447 group_names_propname
,
453 pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n",
458 ret
= gpiochip_add_pingroup_range(chip
, pctldev
,
459 pinspec
.args
[0], name
);
469 static int of_gpiochip_add_pin_range(struct gpio_chip
*chip
) { return 0; }
472 int of_gpiochip_add(struct gpio_chip
*chip
)
476 if ((!chip
->of_node
) && (chip
->parent
))
477 chip
->of_node
= chip
->parent
->of_node
;
482 if (!chip
->of_xlate
) {
483 chip
->of_gpio_n_cells
= 2;
484 chip
->of_xlate
= of_gpio_simple_xlate
;
487 if (chip
->of_gpio_n_cells
> MAX_PHANDLE_ARGS
)
490 status
= of_gpiochip_add_pin_range(chip
);
494 /* If the chip defines names itself, these take precedence */
496 devprop_gpiochip_set_names(chip
);
498 of_node_get(chip
->of_node
);
500 return of_gpiochip_scan_gpios(chip
);
503 void of_gpiochip_remove(struct gpio_chip
*chip
)
505 gpiochip_remove_pin_ranges(chip
);
506 of_node_put(chip
->of_node
);