xref: /openbmc/linux/drivers/gpio/gpiolib-of.c (revision 62e59c4e)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * OF helpers for the GPIO API
4  *
5  * Copyright (c) 2007-2008  MontaVista Software, Inc.
6  *
7  * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
8  */
9 
10 #include <linux/device.h>
11 #include <linux/err.h>
12 #include <linux/errno.h>
13 #include <linux/module.h>
14 #include <linux/io.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/of.h>
17 #include <linux/of_address.h>
18 #include <linux/of_gpio.h>
19 #include <linux/pinctrl/pinctrl.h>
20 #include <linux/slab.h>
21 #include <linux/gpio/machine.h>
22 
23 #include "gpiolib.h"
24 
25 static int of_gpiochip_match_node_and_xlate(struct gpio_chip *chip, void *data)
26 {
27 	struct of_phandle_args *gpiospec = data;
28 
29 	return chip->gpiodev->dev.of_node == gpiospec->np &&
30 				chip->of_xlate &&
31 				chip->of_xlate(chip, gpiospec, NULL) >= 0;
32 }
33 
34 static struct gpio_chip *of_find_gpiochip_by_xlate(
35 					struct of_phandle_args *gpiospec)
36 {
37 	return gpiochip_find(gpiospec, of_gpiochip_match_node_and_xlate);
38 }
39 
40 static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
41 					struct of_phandle_args *gpiospec,
42 					enum of_gpio_flags *flags)
43 {
44 	int ret;
45 
46 	if (chip->of_gpio_n_cells != gpiospec->args_count)
47 		return ERR_PTR(-EINVAL);
48 
49 	ret = chip->of_xlate(chip, gpiospec, flags);
50 	if (ret < 0)
51 		return ERR_PTR(ret);
52 
53 	return gpiochip_get_desc(chip, ret);
54 }
55 
56 static void of_gpio_flags_quirks(struct device_node *np,
57 				 const char *propname,
58 				 enum of_gpio_flags *flags,
59 				 int index)
60 {
61 	/*
62 	 * Handle MMC "cd-inverted" and "wp-inverted" semantics.
63 	 */
64 	if (IS_ENABLED(CONFIG_MMC)) {
65 		/*
66 		 * Active low is the default according to the
67 		 * SDHCI specification and the device tree
68 		 * bindings. However the code in the current
69 		 * kernel was written such that the phandle
70 		 * flags were always respected, and "cd-inverted"
71 		 * would invert the flag from the device phandle.
72 		 */
73 		if (!strcmp(propname, "cd-gpios")) {
74 			if (of_property_read_bool(np, "cd-inverted"))
75 				*flags ^= OF_GPIO_ACTIVE_LOW;
76 		}
77 		if (!strcmp(propname, "wp-gpios")) {
78 			if (of_property_read_bool(np, "wp-inverted"))
79 				*flags ^= OF_GPIO_ACTIVE_LOW;
80 		}
81 	}
82 	/*
83 	 * Some GPIO fixed regulator quirks.
84 	 * Note that active low is the default.
85 	 */
86 	if (IS_ENABLED(CONFIG_REGULATOR) &&
87 	    (of_device_is_compatible(np, "regulator-fixed") ||
88 	     of_device_is_compatible(np, "reg-fixed-voltage") ||
89 	     (of_device_is_compatible(np, "regulator-gpio") &&
90 	      !(strcmp(propname, "enable-gpio") &&
91 	        strcmp(propname, "enable-gpios"))))) {
92 		/*
93 		 * The regulator GPIO handles are specified such that the
94 		 * presence or absence of "enable-active-high" solely controls
95 		 * the polarity of the GPIO line. Any phandle flags must
96 		 * be actively ignored.
97 		 */
98 		if (*flags & OF_GPIO_ACTIVE_LOW) {
99 			pr_warn("%s GPIO handle specifies active low - ignored\n",
100 				of_node_full_name(np));
101 			*flags &= ~OF_GPIO_ACTIVE_LOW;
102 		}
103 		if (!of_property_read_bool(np, "enable-active-high"))
104 			*flags |= OF_GPIO_ACTIVE_LOW;
105 	}
106 	/*
107 	 * Legacy open drain handling for fixed voltage regulators.
108 	 */
109 	if (IS_ENABLED(CONFIG_REGULATOR) &&
110 	    of_device_is_compatible(np, "reg-fixed-voltage") &&
111 	    of_property_read_bool(np, "gpio-open-drain")) {
112 		*flags |= (OF_GPIO_SINGLE_ENDED | OF_GPIO_OPEN_DRAIN);
113 		pr_info("%s uses legacy open drain flag - update the DTS if you can\n",
114 			of_node_full_name(np));
115 	}
116 
117 	/*
118 	 * Legacy handling of SPI active high chip select. If we have a
119 	 * property named "cs-gpios" we need to inspect the child node
120 	 * to determine if the flags should have inverted semantics.
121 	 */
122 	if (IS_ENABLED(CONFIG_SPI_MASTER) &&
123 	    of_property_read_bool(np, "cs-gpios") &&
124 	    !strcmp(propname, "cs-gpios")) {
125 		struct device_node *child;
126 		u32 cs;
127 		int ret;
128 
129 		for_each_child_of_node(np, child) {
130 			ret = of_property_read_u32(child, "reg", &cs);
131 			if (ret)
132 				continue;
133 			if (cs == index) {
134 				/*
135 				 * SPI children have active low chip selects
136 				 * by default. This can be specified negatively
137 				 * by just omitting "spi-cs-high" in the
138 				 * device node, or actively by tagging on
139 				 * GPIO_ACTIVE_LOW as flag in the device
140 				 * tree. If the line is simultaneously
141 				 * tagged as active low in the device tree
142 				 * and has the "spi-cs-high" set, we get a
143 				 * conflict and the "spi-cs-high" flag will
144 				 * take precedence.
145 				 */
146 				if (of_property_read_bool(child, "spi-cs-high")) {
147 					if (*flags & OF_GPIO_ACTIVE_LOW) {
148 						pr_warn("%s GPIO handle specifies active low - ignored\n",
149 							of_node_full_name(child));
150 						*flags &= ~OF_GPIO_ACTIVE_LOW;
151 					}
152 				} else {
153 					if (!(*flags & OF_GPIO_ACTIVE_LOW))
154 						pr_info("%s enforce active low on chipselect handle\n",
155 							of_node_full_name(child));
156 					*flags |= OF_GPIO_ACTIVE_LOW;
157 				}
158 				break;
159 			}
160 		}
161 	}
162 }
163 
164 /**
165  * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
166  * @np:		device node to get GPIO from
167  * @propname:	property name containing gpio specifier(s)
168  * @index:	index of the GPIO
169  * @flags:	a flags pointer to fill in
170  *
171  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
172  * value on the error condition. If @flags is not NULL the function also fills
173  * in flags for the GPIO.
174  */
175 struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
176 		     const char *propname, int index, enum of_gpio_flags *flags)
177 {
178 	struct of_phandle_args gpiospec;
179 	struct gpio_chip *chip;
180 	struct gpio_desc *desc;
181 	int ret;
182 
183 	ret = of_parse_phandle_with_args_map(np, propname, "gpio", index,
184 					     &gpiospec);
185 	if (ret) {
186 		pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n",
187 			__func__, propname, np, index);
188 		return ERR_PTR(ret);
189 	}
190 
191 	chip = of_find_gpiochip_by_xlate(&gpiospec);
192 	if (!chip) {
193 		desc = ERR_PTR(-EPROBE_DEFER);
194 		goto out;
195 	}
196 
197 	desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
198 	if (IS_ERR(desc))
199 		goto out;
200 
201 	if (flags)
202 		of_gpio_flags_quirks(np, propname, flags, index);
203 
204 	pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n",
205 		 __func__, propname, np, index,
206 		 PTR_ERR_OR_ZERO(desc));
207 
208 out:
209 	of_node_put(gpiospec.np);
210 
211 	return desc;
212 }
213 
214 int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
215 			    int index, enum of_gpio_flags *flags)
216 {
217 	struct gpio_desc *desc;
218 
219 	desc = of_get_named_gpiod_flags(np, list_name, index, flags);
220 
221 	if (IS_ERR(desc))
222 		return PTR_ERR(desc);
223 	else
224 		return desc_to_gpio(desc);
225 }
226 EXPORT_SYMBOL(of_get_named_gpio_flags);
227 
228 /*
229  * The SPI GPIO bindings happened before we managed to establish that GPIO
230  * properties should be named "foo-gpios" so we have this special kludge for
231  * them.
232  */
233 static struct gpio_desc *of_find_spi_gpio(struct device *dev, const char *con_id,
234 					  enum of_gpio_flags *of_flags)
235 {
236 	char prop_name[32]; /* 32 is max size of property name */
237 	struct device_node *np = dev->of_node;
238 	struct gpio_desc *desc;
239 
240 	/*
241 	 * Hopefully the compiler stubs the rest of the function if this
242 	 * is false.
243 	 */
244 	if (!IS_ENABLED(CONFIG_SPI_MASTER))
245 		return ERR_PTR(-ENOENT);
246 
247 	/* Allow this specifically for "spi-gpio" devices */
248 	if (!of_device_is_compatible(np, "spi-gpio") || !con_id)
249 		return ERR_PTR(-ENOENT);
250 
251 	/* Will be "gpio-sck", "gpio-mosi" or "gpio-miso" */
252 	snprintf(prop_name, sizeof(prop_name), "%s-%s", "gpio", con_id);
253 
254 	desc = of_get_named_gpiod_flags(np, prop_name, 0, of_flags);
255 	return desc;
256 }
257 
258 /*
259  * Some regulator bindings happened before we managed to establish that GPIO
260  * properties should be named "foo-gpios" so we have this special kludge for
261  * them.
262  */
263 static struct gpio_desc *of_find_regulator_gpio(struct device *dev, const char *con_id,
264 						enum of_gpio_flags *of_flags)
265 {
266 	/* These are the connection IDs we accept as legacy GPIO phandles */
267 	const char *whitelist[] = {
268 		"wlf,ldoena", /* Arizona */
269 		"wlf,ldo1ena", /* WM8994 */
270 		"wlf,ldo2ena", /* WM8994 */
271 	};
272 	struct device_node *np = dev->of_node;
273 	struct gpio_desc *desc;
274 	int i;
275 
276 	if (!IS_ENABLED(CONFIG_REGULATOR))
277 		return ERR_PTR(-ENOENT);
278 
279 	if (!con_id)
280 		return ERR_PTR(-ENOENT);
281 
282 	i = match_string(whitelist, ARRAY_SIZE(whitelist), con_id);
283 	if (i < 0)
284 		return ERR_PTR(-ENOENT);
285 
286 	desc = of_get_named_gpiod_flags(np, con_id, 0, of_flags);
287 	return desc;
288 }
289 
290 struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
291 			       unsigned int idx,
292 			       enum gpio_lookup_flags *flags)
293 {
294 	char prop_name[32]; /* 32 is max size of property name */
295 	enum of_gpio_flags of_flags;
296 	struct gpio_desc *desc;
297 	unsigned int i;
298 
299 	/* Try GPIO property "foo-gpios" and "foo-gpio" */
300 	for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
301 		if (con_id)
302 			snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
303 				 gpio_suffixes[i]);
304 		else
305 			snprintf(prop_name, sizeof(prop_name), "%s",
306 				 gpio_suffixes[i]);
307 
308 		desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
309 						&of_flags);
310 		/*
311 		 * -EPROBE_DEFER in our case means that we found a
312 		 * valid GPIO property, but no controller has been
313 		 * registered so far.
314 		 *
315 		 * This means we don't need to look any further for
316 		 * alternate name conventions, and we should really
317 		 * preserve the return code for our user to be able to
318 		 * retry probing later.
319 		 */
320 		if (IS_ERR(desc) && PTR_ERR(desc) == -EPROBE_DEFER)
321 			return desc;
322 
323 		if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT))
324 			break;
325 	}
326 
327 	/* Special handling for SPI GPIOs if used */
328 	if (IS_ERR(desc))
329 		desc = of_find_spi_gpio(dev, con_id, &of_flags);
330 
331 	/* Special handling for regulator GPIOs if used */
332 	if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER)
333 		desc = of_find_regulator_gpio(dev, con_id, &of_flags);
334 
335 	if (IS_ERR(desc))
336 		return desc;
337 
338 	if (of_flags & OF_GPIO_ACTIVE_LOW)
339 		*flags |= GPIO_ACTIVE_LOW;
340 
341 	if (of_flags & OF_GPIO_SINGLE_ENDED) {
342 		if (of_flags & OF_GPIO_OPEN_DRAIN)
343 			*flags |= GPIO_OPEN_DRAIN;
344 		else
345 			*flags |= GPIO_OPEN_SOURCE;
346 	}
347 
348 	if (of_flags & OF_GPIO_TRANSITORY)
349 		*flags |= GPIO_TRANSITORY;
350 
351 	if (of_flags & OF_GPIO_PULL_UP)
352 		*flags |= GPIO_PULL_UP;
353 	if (of_flags & OF_GPIO_PULL_DOWN)
354 		*flags |= GPIO_PULL_DOWN;
355 
356 	return desc;
357 }
358 
359 /**
360  * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
361  * @np:		device node to get GPIO from
362  * @chip:	GPIO chip whose hog is parsed
363  * @idx:	Index of the GPIO to parse
364  * @name:	GPIO line name
365  * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
366  *		of_parse_own_gpio()
367  * @dflags:	gpiod_flags - optional GPIO initialization flags
368  *
369  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
370  * value on the error condition.
371  */
372 static struct gpio_desc *of_parse_own_gpio(struct device_node *np,
373 					   struct gpio_chip *chip,
374 					   unsigned int idx, const char **name,
375 					   enum gpio_lookup_flags *lflags,
376 					   enum gpiod_flags *dflags)
377 {
378 	struct device_node *chip_np;
379 	enum of_gpio_flags xlate_flags;
380 	struct of_phandle_args gpiospec;
381 	struct gpio_desc *desc;
382 	unsigned int i;
383 	u32 tmp;
384 	int ret;
385 
386 	chip_np = chip->of_node;
387 	if (!chip_np)
388 		return ERR_PTR(-EINVAL);
389 
390 	xlate_flags = 0;
391 	*lflags = 0;
392 	*dflags = 0;
393 
394 	ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
395 	if (ret)
396 		return ERR_PTR(ret);
397 
398 	gpiospec.np = chip_np;
399 	gpiospec.args_count = tmp;
400 
401 	for (i = 0; i < tmp; i++) {
402 		ret = of_property_read_u32_index(np, "gpios", idx * tmp + i,
403 						 &gpiospec.args[i]);
404 		if (ret)
405 			return ERR_PTR(ret);
406 	}
407 
408 	desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags);
409 	if (IS_ERR(desc))
410 		return desc;
411 
412 	if (xlate_flags & OF_GPIO_ACTIVE_LOW)
413 		*lflags |= GPIO_ACTIVE_LOW;
414 	if (xlate_flags & OF_GPIO_TRANSITORY)
415 		*lflags |= GPIO_TRANSITORY;
416 
417 	if (of_property_read_bool(np, "input"))
418 		*dflags |= GPIOD_IN;
419 	else if (of_property_read_bool(np, "output-low"))
420 		*dflags |= GPIOD_OUT_LOW;
421 	else if (of_property_read_bool(np, "output-high"))
422 		*dflags |= GPIOD_OUT_HIGH;
423 	else {
424 		pr_warn("GPIO line %d (%pOFn): no hogging state specified, bailing out\n",
425 			desc_to_gpio(desc), np);
426 		return ERR_PTR(-EINVAL);
427 	}
428 
429 	if (name && of_property_read_string(np, "line-name", name))
430 		*name = np->name;
431 
432 	return desc;
433 }
434 
435 /**
436  * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
437  * @chip:	gpio chip to act on
438  *
439  * This is only used by of_gpiochip_add to request/set GPIO initial
440  * configuration.
441  * It returns error if it fails otherwise 0 on success.
442  */
443 static int of_gpiochip_scan_gpios(struct gpio_chip *chip)
444 {
445 	struct gpio_desc *desc = NULL;
446 	struct device_node *np;
447 	const char *name;
448 	enum gpio_lookup_flags lflags;
449 	enum gpiod_flags dflags;
450 	unsigned int i;
451 	int ret;
452 
453 	for_each_available_child_of_node(chip->of_node, np) {
454 		if (!of_property_read_bool(np, "gpio-hog"))
455 			continue;
456 
457 		for (i = 0;; i++) {
458 			desc = of_parse_own_gpio(np, chip, i, &name, &lflags,
459 						 &dflags);
460 			if (IS_ERR(desc))
461 				break;
462 
463 			ret = gpiod_hog(desc, name, lflags, dflags);
464 			if (ret < 0) {
465 				of_node_put(np);
466 				return ret;
467 			}
468 		}
469 	}
470 
471 	return 0;
472 }
473 
474 /**
475  * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags
476  * @gc:		pointer to the gpio_chip structure
477  * @gpiospec:	GPIO specifier as found in the device tree
478  * @flags:	a flags pointer to fill in
479  *
480  * This is simple translation function, suitable for the most 1:1 mapped
481  * GPIO chips. This function performs only one sanity check: whether GPIO
482  * is less than ngpios (that is specified in the gpio_chip).
483  */
484 int of_gpio_simple_xlate(struct gpio_chip *gc,
485 			 const struct of_phandle_args *gpiospec, u32 *flags)
486 {
487 	/*
488 	 * We're discouraging gpio_cells < 2, since that way you'll have to
489 	 * write your own xlate function (that will have to retrieve the GPIO
490 	 * number and the flags from a single gpio cell -- this is possible,
491 	 * but not recommended).
492 	 */
493 	if (gc->of_gpio_n_cells < 2) {
494 		WARN_ON(1);
495 		return -EINVAL;
496 	}
497 
498 	if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
499 		return -EINVAL;
500 
501 	if (gpiospec->args[0] >= gc->ngpio)
502 		return -EINVAL;
503 
504 	if (flags)
505 		*flags = gpiospec->args[1];
506 
507 	return gpiospec->args[0];
508 }
509 EXPORT_SYMBOL(of_gpio_simple_xlate);
510 
511 /**
512  * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
513  * @np:		device node of the GPIO chip
514  * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
515  * @data:	driver data to store in the struct gpio_chip
516  *
517  * To use this function you should allocate and fill mm_gc with:
518  *
519  * 1) In the gpio_chip structure:
520  *    - all the callbacks
521  *    - of_gpio_n_cells
522  *    - of_xlate callback (optional)
523  *
524  * 3) In the of_mm_gpio_chip structure:
525  *    - save_regs callback (optional)
526  *
527  * If succeeded, this function will map bank's memory and will
528  * do all necessary work for you. Then you'll able to use .regs
529  * to manage GPIOs from the callbacks.
530  */
531 int of_mm_gpiochip_add_data(struct device_node *np,
532 			    struct of_mm_gpio_chip *mm_gc,
533 			    void *data)
534 {
535 	int ret = -ENOMEM;
536 	struct gpio_chip *gc = &mm_gc->gc;
537 
538 	gc->label = kasprintf(GFP_KERNEL, "%pOF", np);
539 	if (!gc->label)
540 		goto err0;
541 
542 	mm_gc->regs = of_iomap(np, 0);
543 	if (!mm_gc->regs)
544 		goto err1;
545 
546 	gc->base = -1;
547 
548 	if (mm_gc->save_regs)
549 		mm_gc->save_regs(mm_gc);
550 
551 	mm_gc->gc.of_node = np;
552 
553 	ret = gpiochip_add_data(gc, data);
554 	if (ret)
555 		goto err2;
556 
557 	return 0;
558 err2:
559 	iounmap(mm_gc->regs);
560 err1:
561 	kfree(gc->label);
562 err0:
563 	pr_err("%pOF: GPIO chip registration failed with status %d\n", np, ret);
564 	return ret;
565 }
566 EXPORT_SYMBOL(of_mm_gpiochip_add_data);
567 
568 /**
569  * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
570  * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
571  */
572 void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
573 {
574 	struct gpio_chip *gc = &mm_gc->gc;
575 
576 	if (!mm_gc)
577 		return;
578 
579 	gpiochip_remove(gc);
580 	iounmap(mm_gc->regs);
581 	kfree(gc->label);
582 }
583 EXPORT_SYMBOL(of_mm_gpiochip_remove);
584 
585 static void of_gpiochip_init_valid_mask(struct gpio_chip *chip)
586 {
587 	int len, i;
588 	u32 start, count;
589 	struct device_node *np = chip->of_node;
590 
591 	len = of_property_count_u32_elems(np,  "gpio-reserved-ranges");
592 	if (len < 0 || len % 2 != 0)
593 		return;
594 
595 	for (i = 0; i < len; i += 2) {
596 		of_property_read_u32_index(np, "gpio-reserved-ranges",
597 					   i, &start);
598 		of_property_read_u32_index(np, "gpio-reserved-ranges",
599 					   i + 1, &count);
600 		if (start >= chip->ngpio || start + count >= chip->ngpio)
601 			continue;
602 
603 		bitmap_clear(chip->valid_mask, start, count);
604 	}
605 };
606 
607 #ifdef CONFIG_PINCTRL
608 static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
609 {
610 	struct device_node *np = chip->of_node;
611 	struct of_phandle_args pinspec;
612 	struct pinctrl_dev *pctldev;
613 	int index = 0, ret;
614 	const char *name;
615 	static const char group_names_propname[] = "gpio-ranges-group-names";
616 	struct property *group_names;
617 
618 	if (!np)
619 		return 0;
620 
621 	group_names = of_find_property(np, group_names_propname, NULL);
622 
623 	for (;; index++) {
624 		ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
625 				index, &pinspec);
626 		if (ret)
627 			break;
628 
629 		pctldev = of_pinctrl_get(pinspec.np);
630 		of_node_put(pinspec.np);
631 		if (!pctldev)
632 			return -EPROBE_DEFER;
633 
634 		if (pinspec.args[2]) {
635 			if (group_names) {
636 				of_property_read_string_index(np,
637 						group_names_propname,
638 						index, &name);
639 				if (strlen(name)) {
640 					pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n",
641 						np);
642 					break;
643 				}
644 			}
645 			/* npins != 0: linear range */
646 			ret = gpiochip_add_pin_range(chip,
647 					pinctrl_dev_get_devname(pctldev),
648 					pinspec.args[0],
649 					pinspec.args[1],
650 					pinspec.args[2]);
651 			if (ret)
652 				return ret;
653 		} else {
654 			/* npins == 0: special range */
655 			if (pinspec.args[1]) {
656 				pr_err("%pOF: Illegal gpio-range format.\n",
657 					np);
658 				break;
659 			}
660 
661 			if (!group_names) {
662 				pr_err("%pOF: GPIO group range requested but no %s property.\n",
663 					np, group_names_propname);
664 				break;
665 			}
666 
667 			ret = of_property_read_string_index(np,
668 						group_names_propname,
669 						index, &name);
670 			if (ret)
671 				break;
672 
673 			if (!strlen(name)) {
674 				pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n",
675 				np);
676 				break;
677 			}
678 
679 			ret = gpiochip_add_pingroup_range(chip, pctldev,
680 						pinspec.args[0], name);
681 			if (ret)
682 				return ret;
683 		}
684 	}
685 
686 	return 0;
687 }
688 
689 #else
690 static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
691 #endif
692 
693 int of_gpiochip_add(struct gpio_chip *chip)
694 {
695 	int status;
696 
697 	if (!chip->of_node)
698 		return 0;
699 
700 	if (!chip->of_xlate) {
701 		chip->of_gpio_n_cells = 2;
702 		chip->of_xlate = of_gpio_simple_xlate;
703 	}
704 
705 	if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
706 		return -EINVAL;
707 
708 	of_gpiochip_init_valid_mask(chip);
709 
710 	status = of_gpiochip_add_pin_range(chip);
711 	if (status)
712 		return status;
713 
714 	/* If the chip defines names itself, these take precedence */
715 	if (!chip->names)
716 		devprop_gpiochip_set_names(chip,
717 					   of_fwnode_handle(chip->of_node));
718 
719 	of_node_get(chip->of_node);
720 
721 	status = of_gpiochip_scan_gpios(chip);
722 	if (status) {
723 		of_node_put(chip->of_node);
724 		gpiochip_remove_pin_ranges(chip);
725 	}
726 
727 	return status;
728 }
729 
730 void of_gpiochip_remove(struct gpio_chip *chip)
731 {
732 	gpiochip_remove_pin_ranges(chip);
733 	of_node_put(chip->of_node);
734 }
735