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: The empty GPIO specifiers count too.
  50  *
  51  * Returns:
  52  * Either number of GPIOs defined in the property, or
  53  * *  %-EINVAL for an incorrectly formed "gpios" property, or
  54  * *  %-ENOENT for a missing "gpios" property.
  55  *
  56  * Example::
  57  *
  58  *     gpios = <0
  59  *              &gpio1 1 2
  60  *              0
  61  *              &gpio2 3 4>;
  62  *
  63  * The above example defines four GPIOs, two of which are not specified.
  64  * This function will return '4'
  65  */
  66 static int of_gpio_named_count(const struct device_node *np,
  67                                const char *propname)
  68 {
  69         return of_count_phandle_with_args(np, propname, "#gpio-cells");
  70 }
  71
  72 /**
  73  * of_gpio_spi_cs_get_count() - special GPIO counting for SPI
  74  * @np:    Consuming device node
  75  * @con_id: Function within the GPIO consumer
  76  *
  77  * Some elder GPIO controllers need special quirks. Currently we handle
  78  * the Freescale and PPC GPIO controller with bindings that doesn't use the
  79  * established "cs-gpios" for chip selects but instead rely on
  80  * "gpios" for the chip select lines. If we detect this, we redirect
  81  * the counting of "cs-gpios" to count "gpios" transparent to the
  82  * driver.
  83  *
  84  * Returns:
  85  * Either number of GPIOs defined in the property, or
  86  * *  %-EINVAL for an incorrectly formed "gpios" property, or
  87  * *  %-ENOENT for a missing "gpios" property.
  88  */
  89 static int of_gpio_spi_cs_get_count(const struct device_node *np,
  90                                     const char *con_id)
  91 {
  92         if (!IS_ENABLED(CONFIG_SPI_MASTER))
  93                 return 0;
  94         if (!con_id || strcmp(con_id, "cs"))
  95                 return 0;
  96         if (!of_device_is_compatible(np, "fsl,spi") &&
  97             !of_device_is_compatible(np, "aeroflexgaisler,spictrl") &&
  98             !of_device_is_compatible(np, "ibm,ppc4xx-spi"))
  99                 return 0;
 100         return of_gpio_named_count(np, "gpios");
 101 }
 102
 103 int of_gpio_count(const struct fwnode_handle *fwnode, const char *con_id)
 104 {
 105         const struct device_node *np = to_of_node(fwnode);
 106         int ret;
 107         char propname[32];
 108
 109         ret = of_gpio_spi_cs_get_count(np, con_id);
 110         if (ret > 0)
 111                 return ret;
 112
 113         for_each_gpio_property_name(propname, con_id) {
 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_present(np, "cs-gpios")) {
 341                 u32 cs;
 342                 int ret;
 343
 344                 for_each_child_of_node_scoped(np, child) {
 345                         ret = of_property_read_u32(child, "reg", &cs);
 346                         if (ret)
 347                                 continue;
 348                         if (cs == index) {
 349                                 /*
 350                                  * SPI children have active low chip selects
 351                                  * by default. This can be specified negatively
 352                                  * by just omitting "spi-cs-high" in the
 353                                  * device node, or actively by tagging on
 354                                  * GPIO_ACTIVE_LOW as flag in the device
 355                                  * tree. If the line is simultaneously
 356                                  * tagged as active low in the device tree
 357                                  * and has the "spi-cs-high" set, we get a
 358                                  * conflict and the "spi-cs-high" flag will
 359                                  * take precedence.
 360                                  */
 361                                 bool active_high = of_property_read_bool(child,
 362                                                                 "spi-cs-high");
 363                                 of_gpio_quirk_polarity(child, active_high,
 364                                                        flags);
 365                                 break;
 366                         }
 367                 }
 368         }
 369
 370         /* Legacy handling of stmmac's active-low PHY reset line */
 371         if (IS_ENABLED(CONFIG_STMMAC_ETH) &&
 372             !strcmp(propname, "snps,reset-gpio") &&
 373             of_property_read_bool(np, "snps,reset-active-low"))
 374                 *flags |= OF_GPIO_ACTIVE_LOW;
 375 }
 376
 377 /**
 378  * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
 379  * @np:         device node to get GPIO from
 380  * @propname:   property name containing gpio specifier(s)
 381  * @index:      index of the GPIO
 382  * @flags:      a flags pointer to fill in
 383  *
 384  * Returns:
 385  * GPIO descriptor to use with Linux GPIO API, or one of the errno
 386  * value on the error condition. If @flags is not NULL the function also fills
 387  * in flags for the GPIO.
 388  */
 389 static struct gpio_desc *of_get_named_gpiod_flags(const struct device_node *np,
 390                      const char *propname, int index, enum of_gpio_flags *flags)
 391 {
 392         struct of_phandle_args gpiospec;
 393         struct gpio_desc *desc;
 394         int ret;
 395
 396         ret = of_parse_phandle_with_args_map(np, propname, "gpio", index,
 397                                              &gpiospec);
 398         if (ret) {
 399                 pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n",
 400                         __func__, propname, np, index);
 401                 return ERR_PTR(ret);
 402         }
 403
 404         struct gpio_device *gdev __free(gpio_device_put) =
 405                                 of_find_gpio_device_by_xlate(&gpiospec);
 406         if (!gdev) {
 407                 desc = ERR_PTR(-EPROBE_DEFER);
 408                 goto out;
 409         }
 410
 411         desc = of_xlate_and_get_gpiod_flags(gpio_device_get_chip(gdev),
 412                                             &gpiospec, flags);
 413         if (IS_ERR(desc))
 414                 goto out;
 415
 416         if (flags)
 417                 of_gpio_flags_quirks(np, propname, flags, index);
 418
 419         pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n",
 420                  __func__, propname, np, index,
 421                  PTR_ERR_OR_ZERO(desc));
 422
 423 out:
 424         of_node_put(gpiospec.np);
 425
 426         return desc;
 427 }
 428
 429 /**
 430  * of_get_named_gpio() - Get a GPIO number to use with GPIO API
 431  * @np:         device node to get GPIO from
 432  * @propname:   Name of property containing gpio specifier(s)
 433  * @index:      index of the GPIO
 434  *
 435  * **DEPRECATED** This function is deprecated and must not be used in new code.
 436  *
 437  * Returns:
 438  * 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 propname[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
 695         /* Try GPIO property "foo-gpios" and "foo-gpio" */
 696         for_each_gpio_property_name(propname, con_id) {
 697                 desc = of_get_named_gpiod_flags(np, propname, idx, &of_flags);
 698                 if (!gpiod_not_found(desc))
 699                         break;
 700         }
 701
 702         /* Properly named GPIO was not found, try workarounds */
 703         for (q = of_find_gpio_quirks; gpiod_not_found(desc) && *q; q++)
 704                 desc = (*q)(np, con_id, idx, &of_flags);
 705
 706         if (IS_ERR(desc))
 707                 return desc;
 708
 709         *flags = of_convert_gpio_flags(of_flags);
 710
 711         return desc;
 712 }
 713
 714 /**
 715  * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
 716  * @np:         device node to get GPIO from
 717  * @chip:       GPIO chip whose hog is parsed
 718  * @idx:        Index of the GPIO to parse
 719  * @name:       GPIO line name
 720  * @lflags:     bitmask of gpio_lookup_flags GPIO_* values - returned from
 721  *              of_find_gpio() or of_parse_own_gpio()
 722  * @dflags:     gpiod_flags - optional GPIO initialization flags
 723  *
 724  * Returns:
 725  * GPIO descriptor to use with Linux GPIO API, or one of the errno
 726  * value on the error condition.
 727  */
 728 static struct gpio_desc *of_parse_own_gpio(struct device_node *np,
 729                                            struct gpio_chip *chip,
 730                                            unsigned int idx, const char **name,
 731                                            unsigned long *lflags,
 732                                            enum gpiod_flags *dflags)
 733 {
 734         struct device_node *chip_np;
 735         enum of_gpio_flags xlate_flags;
 736         struct of_phandle_args gpiospec;
 737         struct gpio_desc *desc;
 738         unsigned int i;
 739         u32 tmp;
 740         int ret;
 741
 742         chip_np = dev_of_node(&chip->gpiodev->dev);
 743         if (!chip_np)
 744                 return ERR_PTR(-EINVAL);
 745
 746         xlate_flags = 0;
 747         *lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
 748         *dflags = GPIOD_ASIS;
 749
 750         ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
 751         if (ret)
 752                 return ERR_PTR(ret);
 753
 754         gpiospec.np = chip_np;
 755         gpiospec.args_count = tmp;
 756
 757         for (i = 0; i < tmp; i++) {
 758                 ret = of_property_read_u32_index(np, "gpios", idx * tmp + i,
 759                                                  &gpiospec.args[i]);
 760                 if (ret)
 761                         return ERR_PTR(ret);
 762         }
 763
 764         desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags);
 765         if (IS_ERR(desc))
 766                 return desc;
 767
 768         *lflags = of_convert_gpio_flags(xlate_flags);
 769
 770         if (of_property_read_bool(np, "input"))
 771                 *dflags |= GPIOD_IN;
 772         else if (of_property_read_bool(np, "output-low"))
 773                 *dflags |= GPIOD_OUT_LOW;
 774         else if (of_property_read_bool(np, "output-high"))
 775                 *dflags |= GPIOD_OUT_HIGH;
 776         else {
 777                 pr_warn("GPIO line %d (%pOFn): no hogging state specified, bailing out\n",
 778                         desc_to_gpio(desc), np);
 779                 return ERR_PTR(-EINVAL);
 780         }
 781
 782         if (name && of_property_read_string(np, "line-name", name))
 783                 *name = np->name;
 784
 785         return desc;
 786 }
 787
 788 /**
 789  * of_gpiochip_add_hog - Add all hogs in a hog device node
 790  * @chip:       gpio chip to act on
 791  * @hog:        device node describing the hogs
 792  *
 793  * Returns:
 794  * 0 on success, or negative errno on failure.
 795  */
 796 static int of_gpiochip_add_hog(struct gpio_chip *chip, struct device_node *hog)
 797 {
 798         enum gpiod_flags dflags;
 799         struct gpio_desc *desc;
 800         unsigned long lflags;
 801         const char *name;
 802         unsigned int i;
 803         int ret;
 804
 805         for (i = 0;; i++) {
 806                 desc = of_parse_own_gpio(hog, chip, i, &name, &lflags, &dflags);
 807                 if (IS_ERR(desc))
 808                         break;
 809
 810                 ret = gpiod_hog(desc, name, lflags, dflags);
 811                 if (ret < 0)
 812                         return ret;
 813
 814 #ifdef CONFIG_OF_DYNAMIC
 815                 WRITE_ONCE(desc->hog, hog);
 816 #endif
 817         }
 818
 819         return 0;
 820 }
 821
 822 /**
 823  * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
 824  * @chip:       gpio chip to act on
 825  *
 826  * This is only used by of_gpiochip_add to request/set GPIO initial
 827  * configuration.
 828  *
 829  * Returns:
 830  * 0 on success, or negative errno on failure.
 831  */
 832 static int of_gpiochip_scan_gpios(struct gpio_chip *chip)
 833 {
 834         int ret;
 835
 836         for_each_available_child_of_node_scoped(dev_of_node(&chip->gpiodev->dev), np) {
 837                 if (!of_property_read_bool(np, "gpio-hog"))
 838                         continue;
 839
 840                 ret = of_gpiochip_add_hog(chip, np);
 841                 if (ret < 0)
 842                         return ret;
 843
 844                 of_node_set_flag(np, OF_POPULATED);
 845         }
 846
 847         return 0;
 848 }
 849
 850 #ifdef CONFIG_OF_DYNAMIC
 851 /**
 852  * of_gpiochip_remove_hog - Remove all hogs in a hog device node
 853  * @chip:       gpio chip to act on
 854  * @hog:        device node describing the hogs
 855  */
 856 static void of_gpiochip_remove_hog(struct gpio_chip *chip,
 857                                    struct device_node *hog)
 858 {
 859         struct gpio_desc *desc;
 860
 861         for_each_gpio_desc_with_flag(chip, desc, FLAG_IS_HOGGED)
 862                 if (READ_ONCE(desc->hog) == hog)
 863                         gpiochip_free_own_desc(desc);
 864 }
 865
 866 static int of_gpiochip_match_node(struct gpio_chip *chip, const void *data)
 867 {
 868         return device_match_of_node(&chip->gpiodev->dev, data);
 869 }
 870
 871 static struct gpio_device *of_find_gpio_device_by_node(struct device_node *np)
 872 {
 873         return gpio_device_find(np, of_gpiochip_match_node);
 874 }
 875
 876 static int of_gpio_notify(struct notifier_block *nb, unsigned long action,
 877                           void *arg)
 878 {
 879         struct gpio_device *gdev __free(gpio_device_put) = NULL;
 880         struct of_reconfig_data *rd = arg;
 881         int ret;
 882
 883         /*
 884          * This only supports adding and removing complete gpio-hog nodes.
 885          * Modifying an existing gpio-hog node is not supported (except for
 886          * changing its "status" property, which is treated the same as
 887          * addition/removal).
 888          */
 889         switch (of_reconfig_get_state_change(action, arg)) {
 890         case OF_RECONFIG_CHANGE_ADD:
 891                 if (!of_property_read_bool(rd->dn, "gpio-hog"))
 892                         return NOTIFY_DONE;     /* not for us */
 893
 894                 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED))
 895                         return NOTIFY_DONE;
 896
 897                 gdev = of_find_gpio_device_by_node(rd->dn->parent);
 898                 if (!gdev)
 899                         return NOTIFY_DONE;     /* not for us */
 900
 901                 ret = of_gpiochip_add_hog(gpio_device_get_chip(gdev), rd->dn);
 902                 if (ret < 0) {
 903                         pr_err("%s: failed to add hogs for %pOF\n", __func__,
 904                                rd->dn);
 905                         of_node_clear_flag(rd->dn, OF_POPULATED);
 906                         return notifier_from_errno(ret);
 907                 }
 908                 return NOTIFY_OK;
 909
 910         case OF_RECONFIG_CHANGE_REMOVE:
 911                 if (!of_node_check_flag(rd->dn, OF_POPULATED))
 912                         return NOTIFY_DONE;     /* already depopulated */
 913
 914                 gdev = of_find_gpio_device_by_node(rd->dn->parent);
 915                 if (!gdev)
 916                         return NOTIFY_DONE;     /* not for us */
 917
 918                 of_gpiochip_remove_hog(gpio_device_get_chip(gdev), rd->dn);
 919                 of_node_clear_flag(rd->dn, OF_POPULATED);
 920                 return NOTIFY_OK;
 921         }
 922
 923         return NOTIFY_DONE;
 924 }
 925
 926 struct notifier_block gpio_of_notifier = {
 927         .notifier_call = of_gpio_notify,
 928 };
 929 #endif /* CONFIG_OF_DYNAMIC */
 930
 931 /**
 932  * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags
 933  * @gc:         pointer to the gpio_chip structure
 934  * @gpiospec:   GPIO specifier as found in the device tree
 935  * @flags:      a flags pointer to fill in
 936  *
 937  * This is simple translation function, suitable for the most 1:1 mapped
 938  * GPIO chips. This function performs only one sanity check: whether GPIO
 939  * is less than ngpios (that is specified in the gpio_chip).
 940  *
 941  * Returns:
 942  * GPIO number (>= 0) on success, negative errno on failure.
 943  */
 944 static int of_gpio_simple_xlate(struct gpio_chip *gc,
 945                                 const struct of_phandle_args *gpiospec,
 946                                 u32 *flags)
 947 {
 948         /*
 949          * We're discouraging gpio_cells < 2, since that way you'll have to
 950          * write your own xlate function (that will have to retrieve the GPIO
 951          * number and the flags from a single gpio cell -- this is possible,
 952          * but not recommended).
 953          */
 954         if (gc->of_gpio_n_cells < 2) {
 955                 WARN_ON(1);
 956                 return -EINVAL;
 957         }
 958
 959         if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
 960                 return -EINVAL;
 961
 962         if (gpiospec->args[0] >= gc->ngpio)
 963                 return -EINVAL;
 964
 965         if (flags)
 966                 *flags = gpiospec->args[1];
 967
 968         return gpiospec->args[0];
 969 }
 970
 971 #if IS_ENABLED(CONFIG_OF_GPIO_MM_GPIOCHIP)
 972 #include <linux/gpio/legacy-of-mm-gpiochip.h>
 973 /**
 974  * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
 975  * @np:         device node of the GPIO chip
 976  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
 977  * @data:       driver data to store in the struct gpio_chip
 978  *
 979  * To use this function you should allocate and fill mm_gc with:
 980  *
 981  * 1) In the gpio_chip structure:
 982  *    - all the callbacks
 983  *    - of_gpio_n_cells
 984  *    - of_xlate callback (optional)
 985  *
 986  * 3) In the of_mm_gpio_chip structure:
 987  *    - save_regs callback (optional)
 988  *
 989  * If succeeded, this function will map bank's memory and will
 990  * do all necessary work for you. Then you'll able to use .regs
 991  * to manage GPIOs from the callbacks.
 992  *
 993  * Returns:
 994  * 0 on success, or negative errno on failure.
 995  */
 996 int of_mm_gpiochip_add_data(struct device_node *np,
 997                             struct of_mm_gpio_chip *mm_gc,
 998                             void *data)
 999 {
1000         int ret = -ENOMEM;
1001         struct gpio_chip *gc = &mm_gc->gc;
1002
1003         gc->label = kasprintf(GFP_KERNEL, "%pOF", np);
1004         if (!gc->label)
1005                 goto err0;
1006
1007         mm_gc->regs = of_iomap(np, 0);
1008         if (!mm_gc->regs)
1009                 goto err1;
1010
1011         gc->base = -1;
1012
1013         if (mm_gc->save_regs)
1014                 mm_gc->save_regs(mm_gc);
1015
1016         fwnode_handle_put(mm_gc->gc.fwnode);
1017         mm_gc->gc.fwnode = fwnode_handle_get(of_fwnode_handle(np));
1018
1019         ret = gpiochip_add_data(gc, data);
1020         if (ret)
1021                 goto err2;
1022
1023         return 0;
1024 err2:
1025         of_node_put(np);
1026         iounmap(mm_gc->regs);
1027 err1:
1028         kfree(gc->label);
1029 err0:
1030         pr_err("%pOF: GPIO chip registration failed with status %d\n", np, ret);
1031         return ret;
1032 }
1033 EXPORT_SYMBOL_GPL(of_mm_gpiochip_add_data);
1034
1035 /**
1036  * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
1037  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
1038  */
1039 void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
1040 {
1041         struct gpio_chip *gc = &mm_gc->gc;
1042
1043         gpiochip_remove(gc);
1044         iounmap(mm_gc->regs);
1045         kfree(gc->label);
1046 }
1047 EXPORT_SYMBOL_GPL(of_mm_gpiochip_remove);
1048 #endif
1049
1050 #ifdef CONFIG_PINCTRL
1051 static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
1052 {
1053         struct of_phandle_args pinspec;
1054         struct pinctrl_dev *pctldev;
1055         struct device_node *np;
1056         int index = 0, ret, trim;
1057         const char *name;
1058         static const char group_names_propname[] = "gpio-ranges-group-names";
1059         bool has_group_names;
1060
1061         np = dev_of_node(&chip->gpiodev->dev);
1062         if (!np)
1063                 return 0;
1064
1065         has_group_names = of_property_present(np, group_names_propname);
1066
1067         for (;; index++) {
1068                 ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
1069                                 index, &pinspec);
1070                 if (ret)
1071                         break;
1072
1073                 pctldev = of_pinctrl_get(pinspec.np);
1074                 of_node_put(pinspec.np);
1075                 if (!pctldev)
1076                         return -EPROBE_DEFER;
1077
1078                 /* Ignore ranges outside of this GPIO chip */
1079                 if (pinspec.args[0] >= (chip->offset + chip->ngpio))
1080                         continue;
1081                 if (pinspec.args[0] + pinspec.args[2] <= chip->offset)
1082                         continue;
1083
1084                 if (pinspec.args[2]) {
1085                         /* npins != 0: linear range */
1086                         if (has_group_names) {
1087                                 of_property_read_string_index(np,
1088                                                 group_names_propname,
1089                                                 index, &name);
1090                                 if (strlen(name)) {
1091                                         pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n",
1092                                                 np);
1093                                         break;
1094                                 }
1095                         }
1096
1097                         /* Trim the range to fit this GPIO chip */
1098                         if (chip->offset > pinspec.args[0]) {
1099                                 trim = chip->offset - pinspec.args[0];
1100                                 pinspec.args[2] -= trim;
1101                                 pinspec.args[1] += trim;
1102                                 pinspec.args[0] = 0;
1103                         } else {
1104                                 pinspec.args[0] -= chip->offset;
1105                         }
1106                         if ((pinspec.args[0] + pinspec.args[2]) > chip->ngpio)
1107                                 pinspec.args[2] = chip->ngpio - pinspec.args[0];
1108
1109                         ret = gpiochip_add_pin_range(chip,
1110                                         pinctrl_dev_get_devname(pctldev),
1111                                         pinspec.args[0],
1112                                         pinspec.args[1],
1113                                         pinspec.args[2]);
1114                         if (ret)
1115                                 return ret;
1116                 } else {
1117                         /* npins == 0: special range */
1118                         if (pinspec.args[1]) {
1119                                 pr_err("%pOF: Illegal gpio-range format.\n",
1120                                         np);
1121                                 break;
1122                         }
1123
1124                         if (!has_group_names) {
1125                                 pr_err("%pOF: GPIO group range requested but no %s property.\n",
1126                                         np, group_names_propname);
1127                                 break;
1128                         }
1129
1130                         ret = of_property_read_string_index(np,
1131                                                 group_names_propname,
1132                                                 index, &name);
1133                         if (ret)
1134                                 break;
1135
1136                         if (!strlen(name)) {
1137                                 pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n",
1138                                 np);
1139                                 break;
1140                         }
1141
1142                         ret = gpiochip_add_pingroup_range(chip, pctldev,
1143                                                 pinspec.args[0], name);
1144                         if (ret)
1145                                 return ret;
1146                 }
1147         }
1148
1149         return 0;
1150 }
1151
1152 #else
1153 static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
1154 #endif
1155
1156 int of_gpiochip_add(struct gpio_chip *chip)
1157 {
1158         struct device_node *np;
1159         int ret;
1160
1161         np = dev_of_node(&chip->gpiodev->dev);
1162         if (!np)
1163                 return 0;
1164
1165         if (!chip->of_xlate) {
1166                 chip->of_gpio_n_cells = 2;
1167                 chip->of_xlate = of_gpio_simple_xlate;
1168         }
1169
1170         if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
1171                 return -EINVAL;
1172
1173         ret = of_gpiochip_add_pin_range(chip);
1174         if (ret)
1175                 return ret;
1176
1177         of_node_get(np);
1178
1179         ret = of_gpiochip_scan_gpios(chip);
1180         if (ret)
1181                 of_node_put(np);
1182
1183         return ret;
1184 }
1185
1186 void of_gpiochip_remove(struct gpio_chip *chip)
1187 {
1188         of_node_put(dev_of_node(&chip->gpiodev->dev));
1189 }