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