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