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/module.h>
  14#include <linux/io.h>
  15#include <linux/gpio/consumer.h>
  16#include <linux/of.h>
  17#include <linux/of_address.h>
  18#include <linux/of_gpio.h>
  19#include <linux/pinctrl/pinctrl.h>
  20#include <linux/slab.h>
  21#include <linux/gpio/machine.h>
  22
  23#include "gpiolib.h"
  24#include "gpiolib-of.h"
  25
  26/**
  27 * of_gpio_spi_cs_get_count() - special GPIO counting for SPI
  28 * @dev:    Consuming device
  29 * @con_id: Function within the GPIO consumer
  30 *
  31 * Some elder GPIO controllers need special quirks. Currently we handle
  32 * the Freescale and PPC GPIO controller with bindings that doesn't use the
  33 * established "cs-gpios" for chip selects but instead rely on
  34 * "gpios" for the chip select lines. If we detect this, we redirect
  35 * the counting of "cs-gpios" to count "gpios" transparent to the
  36 * driver.
  37 */
  38static int of_gpio_spi_cs_get_count(struct device *dev, const char *con_id)
  39{
  40	struct device_node *np = dev->of_node;
  41
  42	if (!IS_ENABLED(CONFIG_SPI_MASTER))
  43		return 0;
  44	if (!con_id || strcmp(con_id, "cs"))
  45		return 0;
  46	if (!of_device_is_compatible(np, "fsl,spi") &&
  47	    !of_device_is_compatible(np, "aeroflexgaisler,spictrl") &&
  48	    !of_device_is_compatible(np, "ibm,ppc4xx-spi"))
  49		return 0;
  50	return of_gpio_named_count(np, "gpios");
  51}
  52
  53/*
  54 * This is used by external users of of_gpio_count() from <linux/of_gpio.h>
  55 *
  56 * FIXME: get rid of those external users by converting them to GPIO
  57 * descriptors and let them all use gpiod_count()
  58 */
  59int of_gpio_get_count(struct device *dev, const char *con_id)
  60{
  61	int ret;
  62	char propname[32];
  63	unsigned int i;
  64
  65	ret = of_gpio_spi_cs_get_count(dev, con_id);
  66	if (ret > 0)
  67		return ret;
  68
  69	for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
  70		if (con_id)
  71			snprintf(propname, sizeof(propname), "%s-%s",
  72				 con_id, gpio_suffixes[i]);
  73		else
  74			snprintf(propname, sizeof(propname), "%s",
  75				 gpio_suffixes[i]);
  76
  77		ret = of_gpio_named_count(dev->of_node, propname);
  78		if (ret > 0)
  79			break;
  80	}
  81	return ret ? ret : -ENOENT;
  82}
  83
  84static int of_gpiochip_match_node_and_xlate(struct gpio_chip *chip, void *data)
  85{
  86	struct of_phandle_args *gpiospec = data;
  87
  88	return device_match_of_node(&chip->gpiodev->dev, gpiospec->np) &&
  89				chip->of_xlate &&
  90				chip->of_xlate(chip, gpiospec, NULL) >= 0;
  91}
  92
  93static struct gpio_chip *of_find_gpiochip_by_xlate(
  94					struct of_phandle_args *gpiospec)
  95{
  96	return gpiochip_find(gpiospec, of_gpiochip_match_node_and_xlate);
  97}
  98
  99static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
 100					struct of_phandle_args *gpiospec,
 101					enum of_gpio_flags *flags)
 102{
 103	int ret;
 104
 105	if (chip->of_gpio_n_cells != gpiospec->args_count)
 106		return ERR_PTR(-EINVAL);
 107
 108	ret = chip->of_xlate(chip, gpiospec, flags);
 109	if (ret < 0)
 110		return ERR_PTR(ret);
 111
 112	return gpiochip_get_desc(chip, ret);
 113}
 114
 115/*
 116 * Overrides stated polarity of a gpio line and warns when there is a
 117 * discrepancy.
 118 */
 119static void of_gpio_quirk_polarity(const struct device_node *np,
 120				   bool active_high,
 121				   enum of_gpio_flags *flags)
 122{
 123	if (active_high) {
 124		if (*flags & OF_GPIO_ACTIVE_LOW) {
 125			pr_warn("%s GPIO handle specifies active low - ignored\n",
 126				of_node_full_name(np));
 127			*flags &= ~OF_GPIO_ACTIVE_LOW;
 128		}
 129	} else {
 130		if (!(*flags & OF_GPIO_ACTIVE_LOW))
 131			pr_info("%s enforce active low on GPIO handle\n",
 132				of_node_full_name(np));
 133		*flags |= OF_GPIO_ACTIVE_LOW;
 134	}
 135}
 136
 137/*
 138 * This quirk does static polarity overrides in cases where existing
 139 * DTS specified incorrect polarity.
 140 */
 141static void of_gpio_try_fixup_polarity(const struct device_node *np,
 142				       const char *propname,
 143				       enum of_gpio_flags *flags)
 144{
 145	static const struct {
 146		const char *compatible;
 147		const char *propname;
 148		bool active_high;
 149	} gpios[] = {
 150#if !IS_ENABLED(CONFIG_LCD_HX8357)
 151		/*
 152		 * Himax LCD controllers used incorrectly named
 153		 * "gpios-reset" property and also specified wrong
 154		 * polarity.
 155		 */
 156		{ "himax,hx8357",	"gpios-reset",	false },
 157		{ "himax,hx8369",	"gpios-reset",	false },
 158#endif
 159	};
 160	unsigned int i;
 161
 162	for (i = 0; i < ARRAY_SIZE(gpios); i++) {
 163		if (of_device_is_compatible(np, gpios[i].compatible) &&
 164		    !strcmp(propname, gpios[i].propname)) {
 165			of_gpio_quirk_polarity(np, gpios[i].active_high, flags);
 166			break;
 167		}
 168	}
 169}
 170
 171static void of_gpio_set_polarity_by_property(const struct device_node *np,
 172					     const char *propname,
 173					     enum of_gpio_flags *flags)
 174{
 175	static const struct {
 176		const char *compatible;
 177		const char *gpio_propname;
 178		const char *polarity_propname;
 179	} gpios[] = {
 180#if IS_ENABLED(CONFIG_FEC)
 181		/* Freescale Fast Ethernet Controller */
 182		{ "fsl,imx25-fec",   "phy-reset-gpios", "phy-reset-active-high" },
 183		{ "fsl,imx27-fec",   "phy-reset-gpios", "phy-reset-active-high" },
 184		{ "fsl,imx28-fec",   "phy-reset-gpios", "phy-reset-active-high" },
 185		{ "fsl,imx6q-fec",   "phy-reset-gpios", "phy-reset-active-high" },
 186		{ "fsl,mvf600-fec",  "phy-reset-gpios", "phy-reset-active-high" },
 187		{ "fsl,imx6sx-fec",  "phy-reset-gpios", "phy-reset-active-high" },
 188		{ "fsl,imx6ul-fec",  "phy-reset-gpios", "phy-reset-active-high" },
 189		{ "fsl,imx8mq-fec",  "phy-reset-gpios", "phy-reset-active-high" },
 190		{ "fsl,imx8qm-fec",  "phy-reset-gpios", "phy-reset-active-high" },
 191		{ "fsl,s32v234-fec", "phy-reset-gpios", "phy-reset-active-high" },
 192#endif
 193#if IS_ENABLED(CONFIG_PCI_IMX6)
 194		{ "fsl,imx6q-pcie",  "reset-gpio", "reset-gpio-active-high" },
 195		{ "fsl,imx6sx-pcie", "reset-gpio", "reset-gpio-active-high" },
 196		{ "fsl,imx6qp-pcie", "reset-gpio", "reset-gpio-active-high" },
 197		{ "fsl,imx7d-pcie",  "reset-gpio", "reset-gpio-active-high" },
 198		{ "fsl,imx8mq-pcie", "reset-gpio", "reset-gpio-active-high" },
 199		{ "fsl,imx8mm-pcie", "reset-gpio", "reset-gpio-active-high" },
 200		{ "fsl,imx8mp-pcie", "reset-gpio", "reset-gpio-active-high" },
 201#endif
 202
 203		/*
 204		 * The regulator GPIO handles are specified such that the
 205		 * presence or absence of "enable-active-high" solely controls
 206		 * the polarity of the GPIO line. Any phandle flags must
 207		 * be actively ignored.
 208		 */
 209#if IS_ENABLED(CONFIG_REGULATOR_FIXED_VOLTAGE)
 210		{ "regulator-fixed",   "gpios",        "enable-active-high" },
 211		{ "regulator-fixed",   "gpio",         "enable-active-high" },
 212		{ "reg-fixed-voltage", "gpios",        "enable-active-high" },
 213		{ "reg-fixed-voltage", "gpio",         "enable-active-high" },
 214#endif
 215#if IS_ENABLED(CONFIG_REGULATOR_GPIO)
 216		{ "regulator-gpio",    "enable-gpio",  "enable-active-high" },
 217		{ "regulator-gpio",    "enable-gpios", "enable-active-high" },
 218#endif
 219	};
 220	unsigned int i;
 221	bool active_high;
 222
 223	for (i = 0; i < ARRAY_SIZE(gpios); i++) {
 224		if (of_device_is_compatible(np, gpios[i].compatible) &&
 225		    !strcmp(propname, gpios[i].gpio_propname)) {
 226			active_high = of_property_read_bool(np,
 227						gpios[i].polarity_propname);
 228			of_gpio_quirk_polarity(np, active_high, flags);
 229			break;
 230		}
 231	}
 232}
 233
 234static void of_gpio_flags_quirks(const struct device_node *np,
 235				 const char *propname,
 236				 enum of_gpio_flags *flags,
 237				 int index)
 238{
 239	of_gpio_try_fixup_polarity(np, propname, flags);
 240	of_gpio_set_polarity_by_property(np, propname, flags);
 241
 242	/*
 243	 * Legacy open drain handling for fixed voltage regulators.
 244	 */
 245	if (IS_ENABLED(CONFIG_REGULATOR) &&
 246	    of_device_is_compatible(np, "reg-fixed-voltage") &&
 247	    of_property_read_bool(np, "gpio-open-drain")) {
 248		*flags |= (OF_GPIO_SINGLE_ENDED | OF_GPIO_OPEN_DRAIN);
 249		pr_info("%s uses legacy open drain flag - update the DTS if you can\n",
 250			of_node_full_name(np));
 251	}
 252
 253	/*
 254	 * Legacy handling of SPI active high chip select. If we have a
 255	 * property named "cs-gpios" we need to inspect the child node
 256	 * to determine if the flags should have inverted semantics.
 257	 */
 258	if (IS_ENABLED(CONFIG_SPI_MASTER) && !strcmp(propname, "cs-gpios") &&
 259	    of_property_read_bool(np, "cs-gpios")) {
 260		struct device_node *child;
 261		u32 cs;
 262		int ret;
 263
 264		for_each_child_of_node(np, child) {
 265			ret = of_property_read_u32(child, "reg", &cs);
 266			if (ret)
 267				continue;
 268			if (cs == index) {
 269				/*
 270				 * SPI children have active low chip selects
 271				 * by default. This can be specified negatively
 272				 * by just omitting "spi-cs-high" in the
 273				 * device node, or actively by tagging on
 274				 * GPIO_ACTIVE_LOW as flag in the device
 275				 * tree. If the line is simultaneously
 276				 * tagged as active low in the device tree
 277				 * and has the "spi-cs-high" set, we get a
 278				 * conflict and the "spi-cs-high" flag will
 279				 * take precedence.
 280				 */
 281				bool active_high = of_property_read_bool(child,
 282								"spi-cs-high");
 283				of_gpio_quirk_polarity(child, active_high,
 284						       flags);
 285				of_node_put(child);
 286				break;
 287			}
 288		}
 289	}
 290
 291	/* Legacy handling of stmmac's active-low PHY reset line */
 292	if (IS_ENABLED(CONFIG_STMMAC_ETH) &&
 293	    !strcmp(propname, "snps,reset-gpio") &&
 294	    of_property_read_bool(np, "snps,reset-active-low"))
 295		*flags |= OF_GPIO_ACTIVE_LOW;
 296}
 297
 298/**
 299 * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
 300 * @np:		device node to get GPIO from
 301 * @propname:	property name containing gpio specifier(s)
 302 * @index:	index of the GPIO
 303 * @flags:	a flags pointer to fill in
 304 *
 305 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
 306 * value on the error condition. If @flags is not NULL the function also fills
 307 * in flags for the GPIO.
 308 */
 309static struct gpio_desc *of_get_named_gpiod_flags(const struct device_node *np,
 310		     const char *propname, int index, enum of_gpio_flags *flags)
 311{
 312	struct of_phandle_args gpiospec;
 313	struct gpio_chip *chip;
 314	struct gpio_desc *desc;
 315	int ret;
 316
 317	ret = of_parse_phandle_with_args_map(np, propname, "gpio", index,
 318					     &gpiospec);
 319	if (ret) {
 320		pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n",
 321			__func__, propname, np, index);
 322		return ERR_PTR(ret);
 323	}
 324
 325	chip = of_find_gpiochip_by_xlate(&gpiospec);
 326	if (!chip) {
 327		desc = ERR_PTR(-EPROBE_DEFER);
 328		goto out;
 329	}
 330
 331	desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
 332	if (IS_ERR(desc))
 333		goto out;
 334
 335	if (flags)
 336		of_gpio_flags_quirks(np, propname, flags, index);
 337
 338	pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n",
 339		 __func__, propname, np, index,
 340		 PTR_ERR_OR_ZERO(desc));
 341
 342out:
 343	of_node_put(gpiospec.np);
 344
 345	return desc;
 346}
 347
 348int of_get_named_gpio_flags(const struct device_node *np, const char *list_name,
 349			    int index, enum of_gpio_flags *flags)
 350{
 351	struct gpio_desc *desc;
 352
 353	desc = of_get_named_gpiod_flags(np, list_name, index, flags);
 354
 355	if (IS_ERR(desc))
 356		return PTR_ERR(desc);
 357	else
 358		return desc_to_gpio(desc);
 359}
 360EXPORT_SYMBOL_GPL(of_get_named_gpio_flags);
 361
 362/* Converts gpio_lookup_flags into bitmask of GPIO_* values */
 363static unsigned long of_convert_gpio_flags(enum of_gpio_flags flags)
 364{
 365	unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
 366
 367	if (flags & OF_GPIO_ACTIVE_LOW)
 368		lflags |= GPIO_ACTIVE_LOW;
 369
 370	if (flags & OF_GPIO_SINGLE_ENDED) {
 371		if (flags & OF_GPIO_OPEN_DRAIN)
 372			lflags |= GPIO_OPEN_DRAIN;
 373		else
 374			lflags |= GPIO_OPEN_SOURCE;
 375	}
 376
 377	if (flags & OF_GPIO_TRANSITORY)
 378		lflags |= GPIO_TRANSITORY;
 379
 380	if (flags & OF_GPIO_PULL_UP)
 381		lflags |= GPIO_PULL_UP;
 382
 383	if (flags & OF_GPIO_PULL_DOWN)
 384		lflags |= GPIO_PULL_DOWN;
 385
 386	if (flags & OF_GPIO_PULL_DISABLE)
 387		lflags |= GPIO_PULL_DISABLE;
 388
 389	return lflags;
 390}
 391
 392/**
 393 * gpiod_get_from_of_node() - obtain a GPIO from an OF node
 394 * @node:	handle of the OF node
 395 * @propname:	name of the DT property representing the GPIO
 396 * @index:	index of the GPIO to obtain for the consumer
 397 * @dflags:	GPIO initialization flags
 398 * @label:	label to attach to the requested GPIO
 399 *
 400 * Returns:
 401 * On successful request the GPIO pin is configured in accordance with
 402 * provided @dflags.
 403 *
 404 * In case of error an ERR_PTR() is returned.
 405 */
 406struct gpio_desc *gpiod_get_from_of_node(const struct device_node *node,
 407					 const char *propname, int index,
 408					 enum gpiod_flags dflags,
 409					 const char *label)
 410{
 411	unsigned long lflags;
 412	struct gpio_desc *desc;
 413	enum of_gpio_flags of_flags;
 414	int ret;
 415
 416	desc = of_get_named_gpiod_flags(node, propname, index, &of_flags);
 417	if (!desc || IS_ERR(desc))
 418		return desc;
 419
 420	ret = gpiod_request(desc, label);
 421	if (ret == -EBUSY && (dflags & GPIOD_FLAGS_BIT_NONEXCLUSIVE))
 422		return desc;
 423	if (ret)
 424		return ERR_PTR(ret);
 425
 426	lflags = of_convert_gpio_flags(of_flags);
 427
 428	ret = gpiod_configure_flags(desc, propname, lflags, dflags);
 429	if (ret < 0) {
 430		gpiod_put(desc);
 431		return ERR_PTR(ret);
 432	}
 433
 434	return desc;
 435}
 436EXPORT_SYMBOL_GPL(gpiod_get_from_of_node);
 437
 438static 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
 566static 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
 598typedef 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);
 602static const of_find_gpio_quirk of_find_gpio_quirks[] = {
 603	of_find_gpio_rename,
 604	of_find_mt2701_gpio,
 605	NULL
 606};
 607
 608struct 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 */
 657static 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 = chip->of_node;
 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 */
 724static 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 */
 758static 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(chip->of_node, 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 */
 785static 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
 795static int of_gpiochip_match_node(struct gpio_chip *chip, void *data)
 796{
 797	return device_match_of_node(&chip->gpiodev->dev, data);
 798}
 799
 800static struct gpio_chip *of_find_gpiochip_by_node(struct device_node *np)
 801{
 802	return gpiochip_find(np, of_gpiochip_match_node);
 803}
 804
 805static 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
 855struct 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 */
 870static 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/**
 898 * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
 899 * @np:		device node of the GPIO chip
 900 * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
 901 * @data:	driver data to store in the struct gpio_chip
 902 *
 903 * To use this function you should allocate and fill mm_gc with:
 904 *
 905 * 1) In the gpio_chip structure:
 906 *    - all the callbacks
 907 *    - of_gpio_n_cells
 908 *    - of_xlate callback (optional)
 909 *
 910 * 3) In the of_mm_gpio_chip structure:
 911 *    - save_regs callback (optional)
 912 *
 913 * If succeeded, this function will map bank's memory and will
 914 * do all necessary work for you. Then you'll able to use .regs
 915 * to manage GPIOs from the callbacks.
 916 */
 917int of_mm_gpiochip_add_data(struct device_node *np,
 918			    struct of_mm_gpio_chip *mm_gc,
 919			    void *data)
 920{
 921	int ret = -ENOMEM;
 922	struct gpio_chip *gc = &mm_gc->gc;
 923
 924	gc->label = kasprintf(GFP_KERNEL, "%pOF", np);
 925	if (!gc->label)
 926		goto err0;
 927
 928	mm_gc->regs = of_iomap(np, 0);
 929	if (!mm_gc->regs)
 930		goto err1;
 931
 932	gc->base = -1;
 933
 934	if (mm_gc->save_regs)
 935		mm_gc->save_regs(mm_gc);
 936
 937	fwnode_handle_put(mm_gc->gc.fwnode);
 938	mm_gc->gc.fwnode = fwnode_handle_get(of_fwnode_handle(np));
 939
 940	ret = gpiochip_add_data(gc, data);
 941	if (ret)
 942		goto err2;
 943
 944	return 0;
 945err2:
 946	of_node_put(np);
 947	iounmap(mm_gc->regs);
 948err1:
 949	kfree(gc->label);
 950err0:
 951	pr_err("%pOF: GPIO chip registration failed with status %d\n", np, ret);
 
 952	return ret;
 953}
 954EXPORT_SYMBOL_GPL(of_mm_gpiochip_add_data);
 955
 956/**
 957 * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
 958 * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
 959 */
 960void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
 961{
 962	struct gpio_chip *gc = &mm_gc->gc;
 963
 
 
 
 964	gpiochip_remove(gc);
 965	iounmap(mm_gc->regs);
 966	kfree(gc->label);
 967}
 968EXPORT_SYMBOL_GPL(of_mm_gpiochip_remove);
 969
 970#ifdef CONFIG_PINCTRL
 971static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
 972{
 973	struct device_node *np = chip->of_node;
 974	struct of_phandle_args pinspec;
 975	struct pinctrl_dev *pctldev;
 976	int index = 0, ret;
 977	const char *name;
 978	static const char group_names_propname[] = "gpio-ranges-group-names";
 979	struct property *group_names;
 980
 981	if (!np)
 982		return 0;
 983
 984	if (!of_property_read_bool(np, "gpio-ranges") &&
 985	    chip->of_gpio_ranges_fallback) {
 986		return chip->of_gpio_ranges_fallback(chip, np);
 987	}
 988
 989	group_names = of_find_property(np, group_names_propname, NULL);
 990
 991	for (;; index++) {
 992		ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
 993				index, &pinspec);
 994		if (ret)
 995			break;
 996
 997		pctldev = of_pinctrl_get(pinspec.np);
 998		of_node_put(pinspec.np);
 999		if (!pctldev)
1000			return -EPROBE_DEFER;
1001
1002		if (pinspec.args[2]) {
1003			if (group_names) {
1004				of_property_read_string_index(np,
1005						group_names_propname,
1006						index, &name);
1007				if (strlen(name)) {
1008					pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n",
1009						np);
1010					break;
1011				}
1012			}
1013			/* npins != 0: linear range */
1014			ret = gpiochip_add_pin_range(chip,
1015					pinctrl_dev_get_devname(pctldev),
1016					pinspec.args[0],
1017					pinspec.args[1],
1018					pinspec.args[2]);
1019			if (ret)
1020				return ret;
1021		} else {
1022			/* npins == 0: special range */
1023			if (pinspec.args[1]) {
1024				pr_err("%pOF: Illegal gpio-range format.\n",
1025					np);
1026				break;
1027			}
1028
1029			if (!group_names) {
1030				pr_err("%pOF: GPIO group range requested but no %s property.\n",
1031					np, group_names_propname);
1032				break;
1033			}
1034
1035			ret = of_property_read_string_index(np,
1036						group_names_propname,
1037						index, &name);
1038			if (ret)
1039				break;
1040
1041			if (!strlen(name)) {
1042				pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n",
1043				np);
1044				break;
1045			}
1046
1047			ret = gpiochip_add_pingroup_range(chip, pctldev,
1048						pinspec.args[0], name);
1049			if (ret)
1050				return ret;
1051		}
1052	}
1053
1054	return 0;
1055}
1056
1057#else
1058static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
1059#endif
1060
1061int of_gpiochip_add(struct gpio_chip *chip)
1062{
1063	struct device_node *np;
1064	int ret;
1065
1066	np = to_of_node(dev_fwnode(&chip->gpiodev->dev));
1067	if (!np)
 
 
1068		return 0;
1069
1070	if (!chip->of_xlate) {
1071		chip->of_gpio_n_cells = 2;
1072		chip->of_xlate = of_gpio_simple_xlate;
1073	}
1074
1075	if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
1076		return -EINVAL;
1077
1078	ret = of_gpiochip_add_pin_range(chip);
1079	if (ret)
1080		return ret;
1081
1082	fwnode_handle_get(chip->fwnode);
 
 
1083
1084	ret = of_gpiochip_scan_gpios(chip);
1085	if (ret)
1086		fwnode_handle_put(chip->fwnode);
1087
1088	return ret;
1089}
1090
1091void of_gpiochip_remove(struct gpio_chip *chip)
1092{
1093	fwnode_handle_put(chip->fwnode);
1094}
1095
1096void of_gpio_dev_init(struct gpio_chip *gc, struct gpio_device *gdev)
1097{
1098	/* Set default OF node to parent's one if present */
1099	if (gc->parent)
1100		gdev->dev.of_node = gc->parent->of_node;
1101
1102	if (gc->fwnode)
1103		gc->of_node = to_of_node(gc->fwnode);
1104
1105	/* If the gpiochip has an assigned OF node this takes precedence */
1106	if (gc->of_node)
1107		gdev->dev.of_node = gc->of_node;
1108	else
1109		gc->of_node = gdev->dev.of_node;
1110}