drivers/gpio/gpiolib-of.c

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