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