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