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#include "gpiolib-of.h" 25 26/** 27 * of_gpio_spi_cs_get_count() - special GPIO counting for SPI 28 * @dev: Consuming device 29 * @con_id: Function within the GPIO consumer 30 * 31 * Some elder GPIO controllers need special quirks. Currently we handle 32 * the Freescale and PPC GPIO controller with bindings that doesn't use the 33 * established "cs-gpios" for chip selects but instead rely on 34 * "gpios" for the chip select lines. If we detect this, we redirect 35 * the counting of "cs-gpios" to count "gpios" transparent to the 36 * driver. 37 */ 38static int of_gpio_spi_cs_get_count(struct device *dev, const char *con_id) 39{ 40 struct device_node *np = dev->of_node; 41 42 if (!IS_ENABLED(CONFIG_SPI_MASTER)) 43 return 0; 44 if (!con_id || strcmp(con_id, "cs")) 45 return 0; 46 if (!of_device_is_compatible(np, "fsl,spi") && 47 !of_device_is_compatible(np, "aeroflexgaisler,spictrl") && 48 !of_device_is_compatible(np, "ibm,ppc4xx-spi")) 49 return 0; 50 return of_gpio_named_count(np, "gpios"); 51} 52 53/* 54 * This is used by external users of of_gpio_count() from <linux/of_gpio.h> 55 * 56 * FIXME: get rid of those external users by converting them to GPIO 57 * descriptors and let them all use gpiod_count() 58 */ 59int of_gpio_get_count(struct device *dev, const char *con_id) 60{ 61 int ret; 62 char propname[32]; 63 unsigned int i; 64 65 ret = of_gpio_spi_cs_get_count(dev, con_id); 66 if (ret > 0) 67 return ret; 68 69 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 70 if (con_id) 71 snprintf(propname, sizeof(propname), "%s-%s", 72 con_id, gpio_suffixes[i]); 73 else 74 snprintf(propname, sizeof(propname), "%s", 75 gpio_suffixes[i]); 76 77 ret = of_gpio_named_count(dev->of_node, propname); 78 if (ret > 0) 79 break; 80 } 81 return ret ? ret : -ENOENT; 82} 83 84static int of_gpiochip_match_node_and_xlate(struct gpio_chip *chip, void *data) 85{ 86 struct of_phandle_args *gpiospec = data; 87 88 return chip->gpiodev->dev.of_node == gpiospec->np && 89 chip->of_xlate && 90 chip->of_xlate(chip, gpiospec, NULL) >= 0; 91} 92 93static struct gpio_chip *of_find_gpiochip_by_xlate( 94 struct of_phandle_args *gpiospec) 95{ 96 return gpiochip_find(gpiospec, of_gpiochip_match_node_and_xlate); 97} 98 99static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip, 100 struct of_phandle_args *gpiospec, 101 enum of_gpio_flags *flags) 102{ 103 int ret; 104 105 if (chip->of_gpio_n_cells != gpiospec->args_count) 106 return ERR_PTR(-EINVAL); 107 108 ret = chip->of_xlate(chip, gpiospec, flags); 109 if (ret < 0) 110 return ERR_PTR(ret); 111 112 return gpiochip_get_desc(chip, ret); 113} 114 115/** 116 * of_gpio_need_valid_mask() - figure out if the OF GPIO driver needs 117 * to set the .valid_mask 118 * @gc: the target gpio_chip 119 * 120 * Return: true if the valid mask needs to be set 121 */ 122bool of_gpio_need_valid_mask(const struct gpio_chip *gc) 123{ 124 int size; 125 struct device_node *np = gc->of_node; 126 127 size = of_property_count_u32_elems(np, "gpio-reserved-ranges"); 128 if (size > 0 && size % 2 == 0) 129 return true; 130 return false; 131} 132 133static void of_gpio_flags_quirks(struct device_node *np, 134 const char *propname, 135 enum of_gpio_flags *flags, 136 int index) 137{ 138 /* 139 * Some GPIO fixed regulator quirks. 140 * Note that active low is the default. 141 */ 142 if (IS_ENABLED(CONFIG_REGULATOR) && 143 (of_device_is_compatible(np, "regulator-fixed") || 144 of_device_is_compatible(np, "reg-fixed-voltage") || 145 (!(strcmp(propname, "enable-gpio") && 146 strcmp(propname, "enable-gpios")) && 147 of_device_is_compatible(np, "regulator-gpio")))) { 148 bool active_low = !of_property_read_bool(np, 149 "enable-active-high"); 150 /* 151 * The regulator GPIO handles are specified such that the 152 * presence or absence of "enable-active-high" solely controls 153 * the polarity of the GPIO line. Any phandle flags must 154 * be actively ignored. 155 */ 156 if ((*flags & OF_GPIO_ACTIVE_LOW) && !active_low) { 157 pr_warn("%s GPIO handle specifies active low - ignored\n", 158 of_node_full_name(np)); 159 *flags &= ~OF_GPIO_ACTIVE_LOW; 160 } 161 if (active_low) 162 *flags |= OF_GPIO_ACTIVE_LOW; 163 } 164 /* 165 * Legacy open drain handling for fixed voltage regulators. 166 */ 167 if (IS_ENABLED(CONFIG_REGULATOR) && 168 of_device_is_compatible(np, "reg-fixed-voltage") && 169 of_property_read_bool(np, "gpio-open-drain")) { 170 *flags |= (OF_GPIO_SINGLE_ENDED | OF_GPIO_OPEN_DRAIN); 171 pr_info("%s uses legacy open drain flag - update the DTS if you can\n", 172 of_node_full_name(np)); 173 } 174 175 /* 176 * Legacy handling of SPI active high chip select. If we have a 177 * property named "cs-gpios" we need to inspect the child node 178 * to determine if the flags should have inverted semantics. 179 */ 180 if (IS_ENABLED(CONFIG_SPI_MASTER) && !strcmp(propname, "cs-gpios") && 181 of_property_read_bool(np, "cs-gpios")) { 182 struct device_node *child; 183 u32 cs; 184 int ret; 185 186 for_each_child_of_node(np, child) { 187 ret = of_property_read_u32(child, "reg", &cs); 188 if (ret) 189 continue; 190 if (cs == index) { 191 /* 192 * SPI children have active low chip selects 193 * by default. This can be specified negatively 194 * by just omitting "spi-cs-high" in the 195 * device node, or actively by tagging on 196 * GPIO_ACTIVE_LOW as flag in the device 197 * tree. If the line is simultaneously 198 * tagged as active low in the device tree 199 * and has the "spi-cs-high" set, we get a 200 * conflict and the "spi-cs-high" flag will 201 * take precedence. 202 */ 203 if (of_property_read_bool(child, "spi-cs-high")) { 204 if (*flags & OF_GPIO_ACTIVE_LOW) { 205 pr_warn("%s GPIO handle specifies active low - ignored\n", 206 of_node_full_name(child)); 207 *flags &= ~OF_GPIO_ACTIVE_LOW; 208 } 209 } else { 210 if (!(*flags & OF_GPIO_ACTIVE_LOW)) 211 pr_info("%s enforce active low on chipselect handle\n", 212 of_node_full_name(child)); 213 *flags |= OF_GPIO_ACTIVE_LOW; 214 } 215 of_node_put(child); 216 break; 217 } 218 } 219 } 220 221 /* Legacy handling of stmmac's active-low PHY reset line */ 222 if (IS_ENABLED(CONFIG_STMMAC_ETH) && 223 !strcmp(propname, "snps,reset-gpio") && 224 of_property_read_bool(np, "snps,reset-active-low")) 225 *flags |= OF_GPIO_ACTIVE_LOW; 226} 227 228/** 229 * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API 230 * @np: device node to get GPIO from 231 * @propname: property name containing gpio specifier(s) 232 * @index: index of the GPIO 233 * @flags: a flags pointer to fill in 234 * 235 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno 236 * value on the error condition. If @flags is not NULL the function also fills 237 * in flags for the GPIO. 238 */ 239static struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np, 240 const char *propname, int index, enum of_gpio_flags *flags) 241{ 242 struct of_phandle_args gpiospec; 243 struct gpio_chip *chip; 244 struct gpio_desc *desc; 245 int ret; 246 247 ret = of_parse_phandle_with_args_map(np, propname, "gpio", index, 248 &gpiospec); 249 if (ret) { 250 pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n", 251 __func__, propname, np, index); 252 return ERR_PTR(ret); 253 } 254 255 chip = of_find_gpiochip_by_xlate(&gpiospec); 256 if (!chip) { 257 desc = ERR_PTR(-EPROBE_DEFER); 258 goto out; 259 } 260 261 desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags); 262 if (IS_ERR(desc)) 263 goto out; 264 265 if (flags) 266 of_gpio_flags_quirks(np, propname, flags, index); 267 268 pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n", 269 __func__, propname, np, index, 270 PTR_ERR_OR_ZERO(desc)); 271 272out: 273 of_node_put(gpiospec.np); 274 275 return desc; 276} 277 278int of_get_named_gpio_flags(struct device_node *np, const char *list_name, 279 int index, enum of_gpio_flags *flags) 280{ 281 struct gpio_desc *desc; 282 283 desc = of_get_named_gpiod_flags(np, list_name, index, flags); 284 285 if (IS_ERR(desc)) 286 return PTR_ERR(desc); 287 else 288 return desc_to_gpio(desc); 289} 290EXPORT_SYMBOL_GPL(of_get_named_gpio_flags); 291 292/** 293 * gpiod_get_from_of_node() - obtain a GPIO from an OF node 294 * @node: handle of the OF node 295 * @propname: name of the DT property representing the GPIO 296 * @index: index of the GPIO to obtain for the consumer 297 * @dflags: GPIO initialization flags 298 * @label: label to attach to the requested GPIO 299 * 300 * Returns: 301 * On successful request the GPIO pin is configured in accordance with 302 * provided @dflags. 303 * 304 * In case of error an ERR_PTR() is returned. 305 */ 306struct gpio_desc *gpiod_get_from_of_node(struct device_node *node, 307 const char *propname, int index, 308 enum gpiod_flags dflags, 309 const char *label) 310{ 311 unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT; 312 struct gpio_desc *desc; 313 enum of_gpio_flags flags; 314 bool active_low = false; 315 bool single_ended = false; 316 bool open_drain = false; 317 bool transitory = false; 318 int ret; 319 320 desc = of_get_named_gpiod_flags(node, propname, 321 index, &flags); 322 323 if (!desc || IS_ERR(desc)) { 324 return desc; 325 } 326 327 active_low = flags & OF_GPIO_ACTIVE_LOW; 328 single_ended = flags & OF_GPIO_SINGLE_ENDED; 329 open_drain = flags & OF_GPIO_OPEN_DRAIN; 330 transitory = flags & OF_GPIO_TRANSITORY; 331 332 ret = gpiod_request(desc, label); 333 if (ret == -EBUSY && (dflags & GPIOD_FLAGS_BIT_NONEXCLUSIVE)) 334 return desc; 335 if (ret) 336 return ERR_PTR(ret); 337 338 if (active_low) 339 lflags |= GPIO_ACTIVE_LOW; 340 341 if (single_ended) { 342 if (open_drain) 343 lflags |= GPIO_OPEN_DRAIN; 344 else 345 lflags |= GPIO_OPEN_SOURCE; 346 } 347 348 if (transitory) 349 lflags |= GPIO_TRANSITORY; 350 351 if (flags & OF_GPIO_PULL_UP) 352 lflags |= GPIO_PULL_UP; 353 354 if (flags & OF_GPIO_PULL_DOWN) 355 lflags |= GPIO_PULL_DOWN; 356 357 ret = gpiod_configure_flags(desc, propname, lflags, dflags); 358 if (ret < 0) { 359 gpiod_put(desc); 360 return ERR_PTR(ret); 361 } 362 363 return desc; 364} 365EXPORT_SYMBOL_GPL(gpiod_get_from_of_node); 366 367/* 368 * The SPI GPIO bindings happened before we managed to establish that GPIO 369 * properties should be named "foo-gpios" so we have this special kludge for 370 * them. 371 */ 372static struct gpio_desc *of_find_spi_gpio(struct device *dev, const char *con_id, 373 enum of_gpio_flags *of_flags) 374{ 375 char prop_name[32]; /* 32 is max size of property name */ 376 struct device_node *np = dev->of_node; 377 struct gpio_desc *desc; 378 379 /* 380 * Hopefully the compiler stubs the rest of the function if this 381 * is false. 382 */ 383 if (!IS_ENABLED(CONFIG_SPI_MASTER)) 384 return ERR_PTR(-ENOENT); 385 386 /* Allow this specifically for "spi-gpio" devices */ 387 if (!of_device_is_compatible(np, "spi-gpio") || !con_id) 388 return ERR_PTR(-ENOENT); 389 390 /* Will be "gpio-sck", "gpio-mosi" or "gpio-miso" */ 391 snprintf(prop_name, sizeof(prop_name), "%s-%s", "gpio", con_id); 392 393 desc = of_get_named_gpiod_flags(np, prop_name, 0, of_flags); 394 return desc; 395} 396 397/* 398 * The old Freescale bindings use simply "gpios" as name for the chip select 399 * lines rather than "cs-gpios" like all other SPI hardware. Account for this 400 * with a special quirk. 401 */ 402static struct gpio_desc *of_find_spi_cs_gpio(struct device *dev, 403 const char *con_id, 404 unsigned int idx, 405 unsigned long *flags) 406{ 407 struct device_node *np = dev->of_node; 408 409 if (!IS_ENABLED(CONFIG_SPI_MASTER)) 410 return ERR_PTR(-ENOENT); 411 412 /* Allow this specifically for Freescale and PPC devices */ 413 if (!of_device_is_compatible(np, "fsl,spi") && 414 !of_device_is_compatible(np, "aeroflexgaisler,spictrl") && 415 !of_device_is_compatible(np, "ibm,ppc4xx-spi")) 416 return ERR_PTR(-ENOENT); 417 /* Allow only if asking for "cs-gpios" */ 418 if (!con_id || strcmp(con_id, "cs")) 419 return ERR_PTR(-ENOENT); 420 421 /* 422 * While all other SPI controllers use "cs-gpios" the Freescale 423 * uses just "gpios" so translate to that when "cs-gpios" is 424 * requested. 425 */ 426 return of_find_gpio(dev, NULL, idx, flags); 427} 428 429/* 430 * Some regulator bindings happened before we managed to establish that GPIO 431 * properties should be named "foo-gpios" so we have this special kludge for 432 * them. 433 */ 434static struct gpio_desc *of_find_regulator_gpio(struct device *dev, const char *con_id, 435 enum of_gpio_flags *of_flags) 436{ 437 /* These are the connection IDs we accept as legacy GPIO phandles */ 438 const char *whitelist[] = { 439 "wlf,ldoena", /* Arizona */ 440 "wlf,ldo1ena", /* WM8994 */ 441 "wlf,ldo2ena", /* WM8994 */ 442 }; 443 struct device_node *np = dev->of_node; 444 struct gpio_desc *desc; 445 int i; 446 447 if (!IS_ENABLED(CONFIG_REGULATOR)) 448 return ERR_PTR(-ENOENT); 449 450 if (!con_id) 451 return ERR_PTR(-ENOENT); 452 453 i = match_string(whitelist, ARRAY_SIZE(whitelist), con_id); 454 if (i < 0) 455 return ERR_PTR(-ENOENT); 456 457 desc = of_get_named_gpiod_flags(np, con_id, 0, of_flags); 458 return desc; 459} 460 461static struct gpio_desc *of_find_arizona_gpio(struct device *dev, 462 const char *con_id, 463 enum of_gpio_flags *of_flags) 464{ 465 if (!IS_ENABLED(CONFIG_MFD_ARIZONA)) 466 return ERR_PTR(-ENOENT); 467 468 if (!con_id || strcmp(con_id, "wlf,reset")) 469 return ERR_PTR(-ENOENT); 470 471 return of_get_named_gpiod_flags(dev->of_node, con_id, 0, of_flags); 472} 473 474static struct gpio_desc *of_find_usb_gpio(struct device *dev, 475 const char *con_id, 476 enum of_gpio_flags *of_flags) 477{ 478 /* 479 * Currently this USB quirk is only for the Fairchild FUSB302 host which is using 480 * an undocumented DT GPIO line named "fcs,int_n" without the compulsory "-gpios" 481 * suffix. 482 */ 483 if (!IS_ENABLED(CONFIG_TYPEC_FUSB302)) 484 return ERR_PTR(-ENOENT); 485 486 if (!con_id || strcmp(con_id, "fcs,int_n")) 487 return ERR_PTR(-ENOENT); 488 489 return of_get_named_gpiod_flags(dev->of_node, con_id, 0, of_flags); 490} 491 492struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id, 493 unsigned int idx, unsigned long *flags) 494{ 495 char prop_name[32]; /* 32 is max size of property name */ 496 enum of_gpio_flags of_flags; 497 struct gpio_desc *desc; 498 unsigned int i; 499 500 /* Try GPIO property "foo-gpios" and "foo-gpio" */ 501 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 502 if (con_id) 503 snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id, 504 gpio_suffixes[i]); 505 else 506 snprintf(prop_name, sizeof(prop_name), "%s", 507 gpio_suffixes[i]); 508 509 desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx, 510 &of_flags); 511 512 if (!IS_ERR(desc) || PTR_ERR(desc) != -ENOENT) 513 break; 514 } 515 516 if (PTR_ERR(desc) == -ENOENT) { 517 /* Special handling for SPI GPIOs if used */ 518 desc = of_find_spi_gpio(dev, con_id, &of_flags); 519 } 520 521 if (PTR_ERR(desc) == -ENOENT) { 522 /* This quirk looks up flags and all */ 523 desc = of_find_spi_cs_gpio(dev, con_id, idx, flags); 524 if (!IS_ERR(desc)) 525 return desc; 526 } 527 528 if (PTR_ERR(desc) == -ENOENT) { 529 /* Special handling for regulator GPIOs if used */ 530 desc = of_find_regulator_gpio(dev, con_id, &of_flags); 531 } 532 533 if (PTR_ERR(desc) == -ENOENT) 534 desc = of_find_arizona_gpio(dev, con_id, &of_flags); 535 536 if (PTR_ERR(desc) == -ENOENT) 537 desc = of_find_usb_gpio(dev, con_id, &of_flags); 538 539 if (IS_ERR(desc)) 540 return desc; 541 542 if (of_flags & OF_GPIO_ACTIVE_LOW) 543 *flags |= GPIO_ACTIVE_LOW; 544 545 if (of_flags & OF_GPIO_SINGLE_ENDED) { 546 if (of_flags & OF_GPIO_OPEN_DRAIN) 547 *flags |= GPIO_OPEN_DRAIN; 548 else 549 *flags |= GPIO_OPEN_SOURCE; 550 } 551 552 if (of_flags & OF_GPIO_TRANSITORY) 553 *flags |= GPIO_TRANSITORY; 554 555 if (of_flags & OF_GPIO_PULL_UP) 556 *flags |= GPIO_PULL_UP; 557 if (of_flags & OF_GPIO_PULL_DOWN) 558 *flags |= GPIO_PULL_DOWN; 559 560 return desc; 561} 562 563/** 564 * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API 565 * @np: device node to get GPIO from 566 * @chip: GPIO chip whose hog is parsed 567 * @idx: Index of the GPIO to parse 568 * @name: GPIO line name 569 * @lflags: bitmask of gpio_lookup_flags GPIO_* values - returned from 570 * of_find_gpio() or of_parse_own_gpio() 571 * @dflags: gpiod_flags - optional GPIO initialization flags 572 * 573 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno 574 * value on the error condition. 575 */ 576static struct gpio_desc *of_parse_own_gpio(struct device_node *np, 577 struct gpio_chip *chip, 578 unsigned int idx, const char **name, 579 unsigned long *lflags, 580 enum gpiod_flags *dflags) 581{ 582 struct device_node *chip_np; 583 enum of_gpio_flags xlate_flags; 584 struct of_phandle_args gpiospec; 585 struct gpio_desc *desc; 586 unsigned int i; 587 u32 tmp; 588 int ret; 589 590 chip_np = chip->of_node; 591 if (!chip_np) 592 return ERR_PTR(-EINVAL); 593 594 xlate_flags = 0; 595 *lflags = GPIO_LOOKUP_FLAGS_DEFAULT; 596 *dflags = 0; 597 598 ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp); 599 if (ret) 600 return ERR_PTR(ret); 601 602 gpiospec.np = chip_np; 603 gpiospec.args_count = tmp; 604 605 for (i = 0; i < tmp; i++) { 606 ret = of_property_read_u32_index(np, "gpios", idx * tmp + i, 607 &gpiospec.args[i]); 608 if (ret) 609 return ERR_PTR(ret); 610 } 611 612 desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags); 613 if (IS_ERR(desc)) 614 return desc; 615 616 if (xlate_flags & OF_GPIO_ACTIVE_LOW) 617 *lflags |= GPIO_ACTIVE_LOW; 618 if (xlate_flags & OF_GPIO_TRANSITORY) 619 *lflags |= GPIO_TRANSITORY; 620 if (xlate_flags & OF_GPIO_PULL_UP) 621 *lflags |= GPIO_PULL_UP; 622 if (xlate_flags & OF_GPIO_PULL_DOWN) 623 *lflags |= GPIO_PULL_DOWN; 624 625 if (of_property_read_bool(np, "input")) 626 *dflags |= GPIOD_IN; 627 else if (of_property_read_bool(np, "output-low")) 628 *dflags |= GPIOD_OUT_LOW; 629 else if (of_property_read_bool(np, "output-high")) 630 *dflags |= GPIOD_OUT_HIGH; 631 else { 632 pr_warn("GPIO line %d (%pOFn): no hogging state specified, bailing out\n", 633 desc_to_gpio(desc), np); 634 return ERR_PTR(-EINVAL); 635 } 636 637 if (name && of_property_read_string(np, "line-name", name)) 638 *name = np->name; 639 640 return desc; 641} 642 643/** 644 * of_gpiochip_add_hog - Add all hogs in a hog device node 645 * @chip: gpio chip to act on 646 * @hog: device node describing the hogs 647 * 648 * Returns error if it fails otherwise 0 on success. 649 */ 650static int of_gpiochip_add_hog(struct gpio_chip *chip, struct device_node *hog) 651{ 652 enum gpiod_flags dflags; 653 struct gpio_desc *desc; 654 unsigned long lflags; 655 const char *name; 656 unsigned int i; 657 int ret; 658 659 for (i = 0;; i++) { 660 desc = of_parse_own_gpio(hog, chip, i, &name, &lflags, &dflags); 661 if (IS_ERR(desc)) 662 break; 663 664 ret = gpiod_hog(desc, name, lflags, dflags); 665 if (ret < 0) 666 return ret; 667 668#ifdef CONFIG_OF_DYNAMIC 669 desc->hog = hog; 670#endif 671 } 672 673 return 0; 674} 675 676/** 677 * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions 678 * @chip: gpio chip to act on 679 * 680 * This is only used by of_gpiochip_add to request/set GPIO initial 681 * configuration. 682 * It returns error if it fails otherwise 0 on success. 683 */ 684static int of_gpiochip_scan_gpios(struct gpio_chip *chip) 685{ 686 struct device_node *np; 687 int ret; 688 689 for_each_available_child_of_node(chip->of_node, np) { 690 if (!of_property_read_bool(np, "gpio-hog")) 691 continue; 692 693 ret = of_gpiochip_add_hog(chip, np); 694 if (ret < 0) { 695 of_node_put(np); 696 return ret; 697 } 698 699 of_node_set_flag(np, OF_POPULATED); 700 } 701 702 return 0; 703} 704 705#ifdef CONFIG_OF_DYNAMIC 706/** 707 * of_gpiochip_remove_hog - Remove all hogs in a hog device node 708 * @chip: gpio chip to act on 709 * @hog: device node describing the hogs 710 */ 711static void of_gpiochip_remove_hog(struct gpio_chip *chip, 712 struct device_node *hog) 713{ 714 struct gpio_desc *descs = chip->gpiodev->descs; 715 unsigned int i; 716 717 for (i = 0; i < chip->ngpio; i++) { 718 if (test_bit(FLAG_IS_HOGGED, &descs[i].flags) && 719 descs[i].hog == hog) 720 gpiochip_free_own_desc(&descs[i]); 721 } 722} 723 724static int of_gpiochip_match_node(struct gpio_chip *chip, void *data) 725{ 726 return chip->gpiodev->dev.of_node == data; 727} 728 729static struct gpio_chip *of_find_gpiochip_by_node(struct device_node *np) 730{ 731 return gpiochip_find(np, of_gpiochip_match_node); 732} 733 734static int of_gpio_notify(struct notifier_block *nb, unsigned long action, 735 void *arg) 736{ 737 struct of_reconfig_data *rd = arg; 738 struct gpio_chip *chip; 739 int ret; 740 741 /* 742 * This only supports adding and removing complete gpio-hog nodes. 743 * Modifying an existing gpio-hog node is not supported (except for 744 * changing its "status" property, which is treated the same as 745 * addition/removal). 746 */ 747 switch (of_reconfig_get_state_change(action, arg)) { 748 case OF_RECONFIG_CHANGE_ADD: 749 if (!of_property_read_bool(rd->dn, "gpio-hog")) 750 return NOTIFY_OK; /* not for us */ 751 752 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) 753 return NOTIFY_OK; 754 755 chip = of_find_gpiochip_by_node(rd->dn->parent); 756 if (chip == NULL) 757 return NOTIFY_OK; /* not for us */ 758 759 ret = of_gpiochip_add_hog(chip, rd->dn); 760 if (ret < 0) { 761 pr_err("%s: failed to add hogs for %pOF\n", __func__, 762 rd->dn); 763 of_node_clear_flag(rd->dn, OF_POPULATED); 764 return notifier_from_errno(ret); 765 } 766 break; 767 768 case OF_RECONFIG_CHANGE_REMOVE: 769 if (!of_node_check_flag(rd->dn, OF_POPULATED)) 770 return NOTIFY_OK; /* already depopulated */ 771 772 chip = of_find_gpiochip_by_node(rd->dn->parent); 773 if (chip == NULL) 774 return NOTIFY_OK; /* not for us */ 775 776 of_gpiochip_remove_hog(chip, rd->dn); 777 of_node_clear_flag(rd->dn, OF_POPULATED); 778 break; 779 } 780 781 return NOTIFY_OK; 782} 783 784struct notifier_block gpio_of_notifier = { 785 .notifier_call = of_gpio_notify, 786}; 787#endif /* CONFIG_OF_DYNAMIC */ 788 789/** 790 * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags 791 * @gc: pointer to the gpio_chip structure 792 * @gpiospec: GPIO specifier as found in the device tree 793 * @flags: a flags pointer to fill in 794 * 795 * This is simple translation function, suitable for the most 1:1 mapped 796 * GPIO chips. This function performs only one sanity check: whether GPIO 797 * is less than ngpios (that is specified in the gpio_chip). 798 */ 799static int of_gpio_simple_xlate(struct gpio_chip *gc, 800 const struct of_phandle_args *gpiospec, 801 u32 *flags) 802{ 803 /* 804 * We're discouraging gpio_cells < 2, since that way you'll have to 805 * write your own xlate function (that will have to retrieve the GPIO 806 * number and the flags from a single gpio cell -- this is possible, 807 * but not recommended). 808 */ 809 if (gc->of_gpio_n_cells < 2) { 810 WARN_ON(1); 811 return -EINVAL; 812 } 813 814 if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells)) 815 return -EINVAL; 816 817 if (gpiospec->args[0] >= gc->ngpio) 818 return -EINVAL; 819 820 if (flags) 821 *flags = gpiospec->args[1]; 822 823 return gpiospec->args[0]; 824} 825 826/** 827 * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank) 828 * @np: device node of the GPIO chip 829 * @mm_gc: pointer to the of_mm_gpio_chip allocated structure 830 * @data: driver data to store in the struct gpio_chip 831 * 832 * To use this function you should allocate and fill mm_gc with: 833 * 834 * 1) In the gpio_chip structure: 835 * - all the callbacks 836 * - of_gpio_n_cells 837 * - of_xlate callback (optional) 838 * 839 * 3) In the of_mm_gpio_chip structure: 840 * - save_regs callback (optional) 841 * 842 * If succeeded, this function will map bank's memory and will 843 * do all necessary work for you. Then you'll able to use .regs 844 * to manage GPIOs from the callbacks. 845 */ 846int of_mm_gpiochip_add_data(struct device_node *np, 847 struct of_mm_gpio_chip *mm_gc, 848 void *data) 849{ 850 int ret = -ENOMEM; 851 struct gpio_chip *gc = &mm_gc->gc; 852 853 gc->label = kasprintf(GFP_KERNEL, "%pOF", np); 854 if (!gc->label) 855 goto err0; 856 857 mm_gc->regs = of_iomap(np, 0); 858 if (!mm_gc->regs) 859 goto err1; 860 861 gc->base = -1; 862 863 if (mm_gc->save_regs) 864 mm_gc->save_regs(mm_gc); 865 866 of_node_put(mm_gc->gc.of_node); 867 mm_gc->gc.of_node = of_node_get(np); 868 869 ret = gpiochip_add_data(gc, data); 870 if (ret) 871 goto err2; 872 873 return 0; 874err2: 875 of_node_put(np); 876 iounmap(mm_gc->regs); 877err1: 878 kfree(gc->label); 879err0: 880 pr_err("%pOF: GPIO chip registration failed with status %d\n", np, ret); 881 return ret; 882} 883EXPORT_SYMBOL_GPL(of_mm_gpiochip_add_data); 884 885/** 886 * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank) 887 * @mm_gc: pointer to the of_mm_gpio_chip allocated structure 888 */ 889void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc) 890{ 891 struct gpio_chip *gc = &mm_gc->gc; 892 893 if (!mm_gc) 894 return; 895 896 gpiochip_remove(gc); 897 iounmap(mm_gc->regs); 898 kfree(gc->label); 899} 900EXPORT_SYMBOL_GPL(of_mm_gpiochip_remove); 901 902static void of_gpiochip_init_valid_mask(struct gpio_chip *chip) 903{ 904 int len, i; 905 u32 start, count; 906 struct device_node *np = chip->of_node; 907 908 len = of_property_count_u32_elems(np, "gpio-reserved-ranges"); 909 if (len < 0 || len % 2 != 0) 910 return; 911 912 for (i = 0; i < len; i += 2) { 913 of_property_read_u32_index(np, "gpio-reserved-ranges", 914 i, &start); 915 of_property_read_u32_index(np, "gpio-reserved-ranges", 916 i + 1, &count); 917 if (start >= chip->ngpio || start + count > chip->ngpio) 918 continue; 919 920 bitmap_clear(chip->valid_mask, start, count); 921 } 922}; 923 924#ifdef CONFIG_PINCTRL 925static int of_gpiochip_add_pin_range(struct gpio_chip *chip) 926{ 927 struct device_node *np = chip->of_node; 928 struct of_phandle_args pinspec; 929 struct pinctrl_dev *pctldev; 930 int index = 0, ret; 931 const char *name; 932 static const char group_names_propname[] = "gpio-ranges-group-names"; 933 struct property *group_names; 934 935 if (!np) 936 return 0; 937 938 if (!of_property_read_bool(np, "gpio-ranges") && 939 chip->of_gpio_ranges_fallback) { 940 return chip->of_gpio_ranges_fallback(chip, np); 941 } 942 943 group_names = of_find_property(np, group_names_propname, NULL); 944 945 for (;; index++) { 946 ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3, 947 index, &pinspec); 948 if (ret) 949 break; 950 951 pctldev = of_pinctrl_get(pinspec.np); 952 of_node_put(pinspec.np); 953 if (!pctldev) 954 return -EPROBE_DEFER; 955 956 if (pinspec.args[2]) { 957 if (group_names) { 958 of_property_read_string_index(np, 959 group_names_propname, 960 index, &name); 961 if (strlen(name)) { 962 pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n", 963 np); 964 break; 965 } 966 } 967 /* npins != 0: linear range */ 968 ret = gpiochip_add_pin_range(chip, 969 pinctrl_dev_get_devname(pctldev), 970 pinspec.args[0], 971 pinspec.args[1], 972 pinspec.args[2]); 973 if (ret) 974 return ret; 975 } else { 976 /* npins == 0: special range */ 977 if (pinspec.args[1]) { 978 pr_err("%pOF: Illegal gpio-range format.\n", 979 np); 980 break; 981 } 982 983 if (!group_names) { 984 pr_err("%pOF: GPIO group range requested but no %s property.\n", 985 np, group_names_propname); 986 break; 987 } 988 989 ret = of_property_read_string_index(np, 990 group_names_propname, 991 index, &name); 992 if (ret) 993 break; 994 995 if (!strlen(name)) { 996 pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n", 997 np); 998 break; 999 } 1000 1001 ret = gpiochip_add_pingroup_range(chip, pctldev, 1002 pinspec.args[0], name); 1003 if (ret) 1004 return ret; 1005 } 1006 } 1007 1008 return 0; 1009} 1010 1011#else 1012static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; } 1013#endif 1014 1015int of_gpiochip_add(struct gpio_chip *chip) 1016{ 1017 int ret; 1018 1019 if (!chip->of_node) 1020 return 0; 1021 1022 if (!chip->of_xlate) { 1023 chip->of_gpio_n_cells = 2; 1024 chip->of_xlate = of_gpio_simple_xlate; 1025 } 1026 1027 if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS) 1028 return -EINVAL; 1029 1030 of_gpiochip_init_valid_mask(chip); 1031 1032 ret = of_gpiochip_add_pin_range(chip); 1033 if (ret) 1034 return ret; 1035 1036 of_node_get(chip->of_node); 1037 1038 ret = of_gpiochip_scan_gpios(chip); 1039 if (ret) 1040 of_node_put(chip->of_node); 1041 1042 return ret; 1043} 1044 1045void of_gpiochip_remove(struct gpio_chip *chip) 1046{ 1047 of_node_put(chip->of_node); 1048} 1049