1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Core driver for the pin control subsystem
   4 *
   5 * Copyright (C) 2011-2012 ST-Ericsson SA
   6 * Written on behalf of Linaro for ST-Ericsson
   7 * Based on bits of regulator core, gpio core and clk core
   8 *
   9 * Author: Linus Walleij <linus.walleij@linaro.org>
  10 *
  11 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
  12 */
  13#define pr_fmt(fmt) "pinctrl core: " fmt
  14
  15#include <linux/array_size.h>
  16#include <linux/cleanup.h>
  17#include <linux/debugfs.h>
  18#include <linux/device.h>
  19#include <linux/err.h>
  20#include <linux/export.h>
  21#include <linux/init.h>
  22#include <linux/kref.h>
  23#include <linux/list.h>
  24#include <linux/seq_file.h>
  25#include <linux/slab.h>
  26
  27#include <linux/gpio.h>
  28#include <linux/gpio/driver.h>
  29
  30#include <linux/pinctrl/consumer.h>
  31#include <linux/pinctrl/devinfo.h>
  32#include <linux/pinctrl/machine.h>
  33#include <linux/pinctrl/pinctrl.h>
  34
  35#include "core.h"
  36#include "devicetree.h"
  37#include "pinconf.h"
  38#include "pinmux.h"
  39
  40static bool pinctrl_dummy_state;
  41
  42/* Mutex taken to protect pinctrl_list */
  43static DEFINE_MUTEX(pinctrl_list_mutex);
  44
  45/* Mutex taken to protect pinctrl_maps */
  46DEFINE_MUTEX(pinctrl_maps_mutex);
  47
  48/* Mutex taken to protect pinctrldev_list */
  49static DEFINE_MUTEX(pinctrldev_list_mutex);
  50
  51/* Global list of pin control devices (struct pinctrl_dev) */
  52static LIST_HEAD(pinctrldev_list);
  53
  54/* List of pin controller handles (struct pinctrl) */
  55static LIST_HEAD(pinctrl_list);
  56
  57/* List of pinctrl maps (struct pinctrl_maps) */
  58LIST_HEAD(pinctrl_maps);
  59
  60
  61/**
  62 * pinctrl_provide_dummies() - indicate if pinctrl provides dummy state support
  63 *
  64 * Usually this function is called by platforms without pinctrl driver support
  65 * but run with some shared drivers using pinctrl APIs.
  66 * After calling this function, the pinctrl core will return successfully
  67 * with creating a dummy state for the driver to keep going smoothly.
  68 */
  69void pinctrl_provide_dummies(void)
  70{
  71	pinctrl_dummy_state = true;
  72}
  73
  74const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev)
  75{
  76	/* We're not allowed to register devices without name */
  77	return pctldev->desc->name;
  78}
  79EXPORT_SYMBOL_GPL(pinctrl_dev_get_name);
  80
  81const char *pinctrl_dev_get_devname(struct pinctrl_dev *pctldev)
  82{
  83	return dev_name(pctldev->dev);
  84}
  85EXPORT_SYMBOL_GPL(pinctrl_dev_get_devname);
  86
  87void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev)
  88{
  89	return pctldev->driver_data;
  90}
  91EXPORT_SYMBOL_GPL(pinctrl_dev_get_drvdata);
  92
  93/**
  94 * get_pinctrl_dev_from_devname() - look up pin controller device
  95 * @devname: the name of a device instance, as returned by dev_name()
  96 *
  97 * Looks up a pin control device matching a certain device name or pure device
  98 * pointer, the pure device pointer will take precedence.
  99 */
 100struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *devname)
 101{
 102	struct pinctrl_dev *pctldev;
 103
 104	if (!devname)
 105		return NULL;
 106
 107	mutex_lock(&pinctrldev_list_mutex);
 108
 109	list_for_each_entry(pctldev, &pinctrldev_list, node) {
 110		if (!strcmp(dev_name(pctldev->dev), devname)) {
 111			/* Matched on device name */
 112			mutex_unlock(&pinctrldev_list_mutex);
 113			return pctldev;
 114		}
 115	}
 116
 117	mutex_unlock(&pinctrldev_list_mutex);
 118
 119	return NULL;
 120}
 121
 122struct pinctrl_dev *get_pinctrl_dev_from_of_node(struct device_node *np)
 123{
 124	struct pinctrl_dev *pctldev;
 125
 126	mutex_lock(&pinctrldev_list_mutex);
 127
 128	list_for_each_entry(pctldev, &pinctrldev_list, node)
 129		if (device_match_of_node(pctldev->dev, np)) {
 130			mutex_unlock(&pinctrldev_list_mutex);
 131			return pctldev;
 132		}
 133
 134	mutex_unlock(&pinctrldev_list_mutex);
 135
 136	return NULL;
 137}
 138
 139/**
 140 * pin_get_from_name() - look up a pin number from a name
 141 * @pctldev: the pin control device to lookup the pin on
 142 * @name: the name of the pin to look up
 143 */
 144int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name)
 145{
 146	unsigned int i, pin;
 147
 148	/* The pin number can be retrived from the pin controller descriptor */
 149	for (i = 0; i < pctldev->desc->npins; i++) {
 150		struct pin_desc *desc;
 151
 152		pin = pctldev->desc->pins[i].number;
 153		desc = pin_desc_get(pctldev, pin);
 154		/* Pin space may be sparse */
 155		if (desc && !strcmp(name, desc->name))
 156			return pin;
 157	}
 158
 159	return -EINVAL;
 160}
 161
 162/**
 163 * pin_get_name() - look up a pin name from a pin id
 164 * @pctldev: the pin control device to lookup the pin on
 165 * @pin: pin number/id to look up
 166 */
 167const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned int pin)
 168{
 169	const struct pin_desc *desc;
 170
 171	desc = pin_desc_get(pctldev, pin);
 172	if (!desc) {
 173		dev_err(pctldev->dev, "failed to get pin(%d) name\n",
 174			pin);
 175		return NULL;
 176	}
 177
 178	return desc->name;
 179}
 180EXPORT_SYMBOL_GPL(pin_get_name);
 181
 182/* Deletes a range of pin descriptors */
 183static void pinctrl_free_pindescs(struct pinctrl_dev *pctldev,
 184				  const struct pinctrl_pin_desc *pins,
 185				  unsigned int num_pins)
 186{
 187	int i;
 188
 189	for (i = 0; i < num_pins; i++) {
 190		struct pin_desc *pindesc;
 191
 192		pindesc = radix_tree_lookup(&pctldev->pin_desc_tree,
 193					    pins[i].number);
 194		if (pindesc) {
 195			radix_tree_delete(&pctldev->pin_desc_tree,
 196					  pins[i].number);
 197			if (pindesc->dynamic_name)
 198				kfree(pindesc->name);
 199		}
 200		kfree(pindesc);
 201	}
 202}
 203
 204static int pinctrl_register_one_pin(struct pinctrl_dev *pctldev,
 205				    const struct pinctrl_pin_desc *pin)
 206{
 207	struct pin_desc *pindesc;
 208	int error;
 209
 210	pindesc = pin_desc_get(pctldev, pin->number);
 211	if (pindesc) {
 212		dev_err(pctldev->dev, "pin %d already registered\n",
 213			pin->number);
 214		return -EINVAL;
 215	}
 216
 217	pindesc = kzalloc(sizeof(*pindesc), GFP_KERNEL);
 218	if (!pindesc)
 219		return -ENOMEM;
 220
 221	/* Set owner */
 222	pindesc->pctldev = pctldev;
 223#ifdef CONFIG_PINMUX
 224	mutex_init(&pindesc->mux_lock);
 225#endif
 226
 227	/* Copy basic pin info */
 228	if (pin->name) {
 229		pindesc->name = pin->name;
 230	} else {
 231		pindesc->name = kasprintf(GFP_KERNEL, "PIN%u", pin->number);
 232		if (!pindesc->name) {
 233			error = -ENOMEM;
 234			goto failed;
 235		}
 236		pindesc->dynamic_name = true;
 237	}
 238
 239	pindesc->drv_data = pin->drv_data;
 240
 241	error = radix_tree_insert(&pctldev->pin_desc_tree, pin->number, pindesc);
 242	if (error)
 243		goto failed;
 244
 245	pr_debug("registered pin %d (%s) on %s\n",
 246		 pin->number, pindesc->name, pctldev->desc->name);
 247	return 0;
 248
 249failed:
 250	kfree(pindesc);
 251	return error;
 252}
 253
 254static int pinctrl_register_pins(struct pinctrl_dev *pctldev,
 255				 const struct pinctrl_pin_desc *pins,
 256				 unsigned int num_descs)
 257{
 258	unsigned int i;
 259	int ret = 0;
 260
 261	for (i = 0; i < num_descs; i++) {
 262		ret = pinctrl_register_one_pin(pctldev, &pins[i]);
 263		if (ret)
 264			return ret;
 265	}
 266
 267	return 0;
 268}
 269
 270/**
 271 * gpio_to_pin() - GPIO range GPIO number to pin number translation
 272 * @range: GPIO range used for the translation
 273 * @gc: GPIO chip structure from the GPIO subsystem
 274 * @offset: hardware offset of the GPIO relative to the controller
 275 *
 276 * Finds the pin number for a given GPIO using the specified GPIO range
 277 * as a base for translation. The distinction between linear GPIO ranges
 278 * and pin list based GPIO ranges is managed correctly by this function.
 279 *
 280 * This function assumes the gpio is part of the specified GPIO range, use
 281 * only after making sure this is the case (e.g. by calling it on the
 282 * result of successful pinctrl_get_device_gpio_range calls)!
 283 */
 284static inline int gpio_to_pin(struct pinctrl_gpio_range *range,
 285			      struct gpio_chip *gc, unsigned int offset)
 286{
 287	unsigned int pin = gc->base + offset - range->base;
 288	if (range->pins)
 289		return range->pins[pin];
 290	else
 291		return range->pin_base + pin;
 292}
 293
 294/**
 295 * pinctrl_match_gpio_range() - check if a certain GPIO pin is in range
 296 * @pctldev: pin controller device to check
 297 * @gc: GPIO chip structure from the GPIO subsystem
 298 * @offset: hardware offset of the GPIO relative to the controller
 299 *
 300 * Tries to match a GPIO pin number to the ranges handled by a certain pin
 301 * controller, return the range or NULL
 302 */
 303static struct pinctrl_gpio_range *
 304pinctrl_match_gpio_range(struct pinctrl_dev *pctldev, struct gpio_chip *gc,
 305			 unsigned int offset)
 306{
 307	struct pinctrl_gpio_range *range;
 308
 309	mutex_lock(&pctldev->mutex);
 310	/* Loop over the ranges */
 311	list_for_each_entry(range, &pctldev->gpio_ranges, node) {
 312		/* Check if we're in the valid range */
 313		if ((gc->base + offset) >= range->base &&
 314		    (gc->base + offset) < range->base + range->npins) {
 315			mutex_unlock(&pctldev->mutex);
 316			return range;
 317		}
 318	}
 319	mutex_unlock(&pctldev->mutex);
 320	return NULL;
 321}
 322
 323/**
 324 * pinctrl_ready_for_gpio_range() - check if other GPIO pins of
 325 * the same GPIO chip are in range
 326 * @gc: GPIO chip structure from the GPIO subsystem
 327 * @offset: hardware offset of the GPIO relative to the controller
 328 *
 329 * This function is complement of pinctrl_match_gpio_range(). If the return
 330 * value of pinctrl_match_gpio_range() is NULL, this function could be used
 331 * to check whether pinctrl device is ready or not. Maybe some GPIO pins
 332 * of the same GPIO chip don't have back-end pinctrl interface.
 333 * If the return value is true, it means that pinctrl device is ready & the
 334 * certain GPIO pin doesn't have back-end pinctrl device. If the return value
 335 * is false, it means that pinctrl device may not be ready.
 336 */
 337#ifdef CONFIG_GPIOLIB
 338static bool pinctrl_ready_for_gpio_range(struct gpio_chip *gc,
 339					 unsigned int offset)
 340{
 341	struct pinctrl_dev *pctldev;
 342	struct pinctrl_gpio_range *range = NULL;
 343
 344	mutex_lock(&pinctrldev_list_mutex);
 345
 346	/* Loop over the pin controllers */
 347	list_for_each_entry(pctldev, &pinctrldev_list, node) {
 348		/* Loop over the ranges */
 349		mutex_lock(&pctldev->mutex);
 350		list_for_each_entry(range, &pctldev->gpio_ranges, node) {
 351			/* Check if any gpio range overlapped with gpio chip */
 352			if (range->base + range->npins - 1 < gc->base ||
 353			    range->base > gc->base + gc->ngpio - 1)
 354				continue;
 355			mutex_unlock(&pctldev->mutex);
 356			mutex_unlock(&pinctrldev_list_mutex);
 357			return true;
 358		}
 359		mutex_unlock(&pctldev->mutex);
 360	}
 361
 362	mutex_unlock(&pinctrldev_list_mutex);
 363
 364	return false;
 365}
 366#else
 367static inline bool
 368pinctrl_ready_for_gpio_range(struct gpio_chip *gc, unsigned int offset)
 369{
 370	return true;
 371}
 372#endif
 373
 374/**
 375 * pinctrl_get_device_gpio_range() - find device for GPIO range
 376 * @gc: GPIO chip structure from the GPIO subsystem
 377 * @offset: hardware offset of the GPIO relative to the controller
 378 * @outdev: the pin control device if found
 379 * @outrange: the GPIO range if found
 380 *
 381 * Find the pin controller handling a certain GPIO pin from the pinspace of
 382 * the GPIO subsystem, return the device and the matching GPIO range. Returns
 383 * -EPROBE_DEFER if the GPIO range could not be found in any device since it
 384 * may still have not been registered.
 385 */
 386static int pinctrl_get_device_gpio_range(struct gpio_chip *gc,
 387					 unsigned int offset,
 388					 struct pinctrl_dev **outdev,
 389					 struct pinctrl_gpio_range **outrange)
 390{
 391	struct pinctrl_dev *pctldev;
 392
 393	mutex_lock(&pinctrldev_list_mutex);
 394
 395	/* Loop over the pin controllers */
 396	list_for_each_entry(pctldev, &pinctrldev_list, node) {
 397		struct pinctrl_gpio_range *range;
 398
 399		range = pinctrl_match_gpio_range(pctldev, gc, offset);
 400		if (range) {
 401			*outdev = pctldev;
 402			*outrange = range;
 403			mutex_unlock(&pinctrldev_list_mutex);
 404			return 0;
 405		}
 406	}
 407
 408	mutex_unlock(&pinctrldev_list_mutex);
 409
 410	return -EPROBE_DEFER;
 411}
 412
 413/**
 414 * pinctrl_add_gpio_range() - register a GPIO range for a controller
 415 * @pctldev: pin controller device to add the range to
 416 * @range: the GPIO range to add
 417 *
 418 * DEPRECATED: Don't use this function in new code.  See section 2 of
 419 * Documentation/devicetree/bindings/gpio/gpio.txt on how to bind pinctrl and
 420 * gpio drivers.
 421 *
 422 * This adds a range of GPIOs to be handled by a certain pin controller. Call
 423 * this to register handled ranges after registering your pin controller.
 424 */
 425void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
 426			    struct pinctrl_gpio_range *range)
 427{
 428	mutex_lock(&pctldev->mutex);
 429	list_add_tail(&range->node, &pctldev->gpio_ranges);
 430	mutex_unlock(&pctldev->mutex);
 431}
 432EXPORT_SYMBOL_GPL(pinctrl_add_gpio_range);
 433
 434void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev,
 435			     struct pinctrl_gpio_range *ranges,
 436			     unsigned int nranges)
 437{
 438	int i;
 439
 440	for (i = 0; i < nranges; i++)
 441		pinctrl_add_gpio_range(pctldev, &ranges[i]);
 442}
 443EXPORT_SYMBOL_GPL(pinctrl_add_gpio_ranges);
 444
 445struct pinctrl_dev *pinctrl_find_and_add_gpio_range(const char *devname,
 446		struct pinctrl_gpio_range *range)
 447{
 448	struct pinctrl_dev *pctldev;
 449
 450	pctldev = get_pinctrl_dev_from_devname(devname);
 451
 452	/*
 453	 * If we can't find this device, let's assume that is because
 454	 * it has not probed yet, so the driver trying to register this
 455	 * range need to defer probing.
 456	 */
 457	if (!pctldev)
 458		return ERR_PTR(-EPROBE_DEFER);
 459
 460	pinctrl_add_gpio_range(pctldev, range);
 461
 462	return pctldev;
 463}
 464EXPORT_SYMBOL_GPL(pinctrl_find_and_add_gpio_range);
 465
 466int pinctrl_get_group_pins(struct pinctrl_dev *pctldev, const char *pin_group,
 467			   const unsigned int **pins, unsigned int *num_pins)
 468{
 469	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 470	int gs;
 471
 472	if (!pctlops->get_group_pins)
 473		return -EINVAL;
 474
 475	gs = pinctrl_get_group_selector(pctldev, pin_group);
 476	if (gs < 0)
 477		return gs;
 478
 479	return pctlops->get_group_pins(pctldev, gs, pins, num_pins);
 480}
 481EXPORT_SYMBOL_GPL(pinctrl_get_group_pins);
 482
 483struct pinctrl_gpio_range *
 484pinctrl_find_gpio_range_from_pin_nolock(struct pinctrl_dev *pctldev,
 485					unsigned int pin)
 486{
 487	struct pinctrl_gpio_range *range;
 488
 489	/* Loop over the ranges */
 490	list_for_each_entry(range, &pctldev->gpio_ranges, node) {
 491		/* Check if we're in the valid range */
 492		if (range->pins) {
 493			int a;
 494			for (a = 0; a < range->npins; a++) {
 495				if (range->pins[a] == pin)
 496					return range;
 497			}
 498		} else if (pin >= range->pin_base &&
 499			   pin < range->pin_base + range->npins)
 500			return range;
 501	}
 502
 503	return NULL;
 504}
 505EXPORT_SYMBOL_GPL(pinctrl_find_gpio_range_from_pin_nolock);
 506
 507/**
 508 * pinctrl_find_gpio_range_from_pin() - locate the GPIO range for a pin
 509 * @pctldev: the pin controller device to look in
 510 * @pin: a controller-local number to find the range for
 511 */
 512struct pinctrl_gpio_range *
 513pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev,
 514				 unsigned int pin)
 515{
 516	struct pinctrl_gpio_range *range;
 517
 518	mutex_lock(&pctldev->mutex);
 519	range = pinctrl_find_gpio_range_from_pin_nolock(pctldev, pin);
 520	mutex_unlock(&pctldev->mutex);
 521
 522	return range;
 523}
 524EXPORT_SYMBOL_GPL(pinctrl_find_gpio_range_from_pin);
 525
 526/**
 527 * pinctrl_remove_gpio_range() - remove a range of GPIOs from a pin controller
 528 * @pctldev: pin controller device to remove the range from
 529 * @range: the GPIO range to remove
 530 */
 531void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
 532			       struct pinctrl_gpio_range *range)
 533{
 534	mutex_lock(&pctldev->mutex);
 535	list_del(&range->node);
 536	mutex_unlock(&pctldev->mutex);
 537}
 538EXPORT_SYMBOL_GPL(pinctrl_remove_gpio_range);
 539
 540#ifdef CONFIG_GENERIC_PINCTRL_GROUPS
 541
 542/**
 543 * pinctrl_generic_get_group_count() - returns the number of pin groups
 544 * @pctldev: pin controller device
 545 */
 546int pinctrl_generic_get_group_count(struct pinctrl_dev *pctldev)
 547{
 548	return pctldev->num_groups;
 549}
 550EXPORT_SYMBOL_GPL(pinctrl_generic_get_group_count);
 551
 552/**
 553 * pinctrl_generic_get_group_name() - returns the name of a pin group
 554 * @pctldev: pin controller device
 555 * @selector: group number
 556 */
 557const char *pinctrl_generic_get_group_name(struct pinctrl_dev *pctldev,
 558					   unsigned int selector)
 559{
 560	struct group_desc *group;
 561
 562	group = radix_tree_lookup(&pctldev->pin_group_tree,
 563				  selector);
 564	if (!group)
 565		return NULL;
 566
 567	return group->grp.name;
 568}
 569EXPORT_SYMBOL_GPL(pinctrl_generic_get_group_name);
 570
 571/**
 572 * pinctrl_generic_get_group_pins() - gets the pin group pins
 573 * @pctldev: pin controller device
 574 * @selector: group number
 575 * @pins: pins in the group
 576 * @num_pins: number of pins in the group
 577 */
 578int pinctrl_generic_get_group_pins(struct pinctrl_dev *pctldev,
 579				   unsigned int selector,
 580				   const unsigned int **pins,
 581				   unsigned int *num_pins)
 582{
 583	struct group_desc *group;
 584
 585	group = radix_tree_lookup(&pctldev->pin_group_tree,
 586				  selector);
 587	if (!group) {
 588		dev_err(pctldev->dev, "%s could not find pingroup%i\n",
 589			__func__, selector);
 590		return -EINVAL;
 591	}
 592
 593	*pins = group->grp.pins;
 594	*num_pins = group->grp.npins;
 595
 596	return 0;
 597}
 598EXPORT_SYMBOL_GPL(pinctrl_generic_get_group_pins);
 599
 600/**
 601 * pinctrl_generic_get_group() - returns a pin group based on the number
 602 * @pctldev: pin controller device
 603 * @selector: group number
 604 */
 605struct group_desc *pinctrl_generic_get_group(struct pinctrl_dev *pctldev,
 606					     unsigned int selector)
 607{
 608	struct group_desc *group;
 609
 610	group = radix_tree_lookup(&pctldev->pin_group_tree,
 611				  selector);
 612	if (!group)
 613		return NULL;
 614
 615	return group;
 616}
 617EXPORT_SYMBOL_GPL(pinctrl_generic_get_group);
 618
 619static int pinctrl_generic_group_name_to_selector(struct pinctrl_dev *pctldev,
 620						  const char *function)
 621{
 622	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
 623	int ngroups = ops->get_groups_count(pctldev);
 624	int selector = 0;
 625
 626	/* See if this pctldev has this group */
 627	while (selector < ngroups) {
 628		const char *gname = ops->get_group_name(pctldev, selector);
 629
 630		if (gname && !strcmp(function, gname))
 631			return selector;
 632
 633		selector++;
 634	}
 635
 636	return -EINVAL;
 637}
 638
 639/**
 640 * pinctrl_generic_add_group() - adds a new pin group
 641 * @pctldev: pin controller device
 642 * @name: name of the pin group
 643 * @pins: pins in the pin group
 644 * @num_pins: number of pins in the pin group
 645 * @data: pin controller driver specific data
 646 *
 647 * Note that the caller must take care of locking.
 648 */
 649int pinctrl_generic_add_group(struct pinctrl_dev *pctldev, const char *name,
 650			      const unsigned int *pins, int num_pins, void *data)
 651{
 652	struct group_desc *group;
 653	int selector, error;
 654
 655	if (!name)
 656		return -EINVAL;
 657
 658	selector = pinctrl_generic_group_name_to_selector(pctldev, name);
 659	if (selector >= 0)
 660		return selector;
 661
 662	selector = pctldev->num_groups;
 663
 664	group = devm_kzalloc(pctldev->dev, sizeof(*group), GFP_KERNEL);
 665	if (!group)
 666		return -ENOMEM;
 667
 668	*group = PINCTRL_GROUP_DESC(name, pins, num_pins, data);
 669
 670	error = radix_tree_insert(&pctldev->pin_group_tree, selector, group);
 671	if (error)
 672		return error;
 673
 674	pctldev->num_groups++;
 675
 676	return selector;
 677}
 678EXPORT_SYMBOL_GPL(pinctrl_generic_add_group);
 679
 680/**
 681 * pinctrl_generic_remove_group() - removes a numbered pin group
 682 * @pctldev: pin controller device
 683 * @selector: group number
 684 *
 685 * Note that the caller must take care of locking.
 686 */
 687int pinctrl_generic_remove_group(struct pinctrl_dev *pctldev,
 688				 unsigned int selector)
 689{
 690	struct group_desc *group;
 691
 692	group = radix_tree_lookup(&pctldev->pin_group_tree,
 693				  selector);
 694	if (!group)
 695		return -ENOENT;
 696
 697	radix_tree_delete(&pctldev->pin_group_tree, selector);
 698	devm_kfree(pctldev->dev, group);
 699
 700	pctldev->num_groups--;
 701
 702	return 0;
 703}
 704EXPORT_SYMBOL_GPL(pinctrl_generic_remove_group);
 705
 706/**
 707 * pinctrl_generic_free_groups() - removes all pin groups
 708 * @pctldev: pin controller device
 709 *
 710 * Note that the caller must take care of locking. The pinctrl groups
 711 * are allocated with devm_kzalloc() so no need to free them here.
 712 */
 713static void pinctrl_generic_free_groups(struct pinctrl_dev *pctldev)
 714{
 715	struct radix_tree_iter iter;
 716	void __rcu **slot;
 717
 718	radix_tree_for_each_slot(slot, &pctldev->pin_group_tree, &iter, 0)
 719		radix_tree_delete(&pctldev->pin_group_tree, iter.index);
 720
 721	pctldev->num_groups = 0;
 722}
 723
 724#else
 725static inline void pinctrl_generic_free_groups(struct pinctrl_dev *pctldev)
 726{
 727}
 728#endif /* CONFIG_GENERIC_PINCTRL_GROUPS */
 729
 730/**
 731 * pinctrl_get_group_selector() - returns the group selector for a group
 732 * @pctldev: the pin controller handling the group
 733 * @pin_group: the pin group to look up
 734 */
 735int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
 736			       const char *pin_group)
 737{
 738	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 739	unsigned int ngroups = pctlops->get_groups_count(pctldev);
 740	unsigned int group_selector = 0;
 741
 742	while (group_selector < ngroups) {
 743		const char *gname = pctlops->get_group_name(pctldev,
 744							    group_selector);
 745		if (gname && !strcmp(gname, pin_group)) {
 746			dev_dbg(pctldev->dev,
 747				"found group selector %u for %s\n",
 748				group_selector,
 749				pin_group);
 750			return group_selector;
 751		}
 752
 753		group_selector++;
 754	}
 755
 756	dev_err(pctldev->dev, "does not have pin group %s\n",
 757		pin_group);
 758
 759	return -EINVAL;
 760}
 761
 762bool pinctrl_gpio_can_use_line(struct gpio_chip *gc, unsigned int offset)
 763{
 764	struct pinctrl_dev *pctldev;
 765	struct pinctrl_gpio_range *range;
 766	bool result;
 767	int pin;
 768
 769	/*
 770	 * Try to obtain GPIO range, if it fails
 771	 * we're probably dealing with GPIO driver
 772	 * without a backing pin controller - bail out.
 773	 */
 774	if (pinctrl_get_device_gpio_range(gc, offset, &pctldev, &range))
 775		return true;
 776
 777	mutex_lock(&pctldev->mutex);
 778
 779	/* Convert to the pin controllers number space */
 780	pin = gpio_to_pin(range, gc, offset);
 781
 782	result = pinmux_can_be_used_for_gpio(pctldev, pin);
 783
 784	mutex_unlock(&pctldev->mutex);
 785
 786	return result;
 787}
 788EXPORT_SYMBOL_GPL(pinctrl_gpio_can_use_line);
 789
 790/**
 791 * pinctrl_gpio_request() - request a single pin to be used as GPIO
 792 * @gc: GPIO chip structure from the GPIO subsystem
 793 * @offset: hardware offset of the GPIO relative to the controller
 794 *
 795 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
 796 * as part of their gpio_request() semantics, platforms and individual drivers
 797 * shall *NOT* request GPIO pins to be muxed in.
 798 */
 799int pinctrl_gpio_request(struct gpio_chip *gc, unsigned int offset)
 800{
 801	struct pinctrl_gpio_range *range;
 802	struct pinctrl_dev *pctldev;
 803	int ret, pin;
 804
 805	ret = pinctrl_get_device_gpio_range(gc, offset, &pctldev, &range);
 806	if (ret) {
 807		if (pinctrl_ready_for_gpio_range(gc, offset))
 808			ret = 0;
 809		return ret;
 810	}
 811
 812	mutex_lock(&pctldev->mutex);
 813
 814	/* Convert to the pin controllers number space */
 815	pin = gpio_to_pin(range, gc, offset);
 816
 817	ret = pinmux_request_gpio(pctldev, range, pin, gc->base + offset);
 818
 819	mutex_unlock(&pctldev->mutex);
 820
 821	return ret;
 822}
 823EXPORT_SYMBOL_GPL(pinctrl_gpio_request);
 824
 825/**
 826 * pinctrl_gpio_free() - free control on a single pin, currently used as GPIO
 827 * @gc: GPIO chip structure from the GPIO subsystem
 828 * @offset: hardware offset of the GPIO relative to the controller
 829 *
 830 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
 831 * as part of their gpio_request() semantics, platforms and individual drivers
 832 * shall *NOT* request GPIO pins to be muxed in.
 833 */
 834void pinctrl_gpio_free(struct gpio_chip *gc, unsigned int offset)
 835{
 836	struct pinctrl_gpio_range *range;
 837	struct pinctrl_dev *pctldev;
 838	int ret, pin;
 839
 840	ret = pinctrl_get_device_gpio_range(gc, offset, &pctldev, &range);
 841	if (ret)
 842		return;
 843
 844	mutex_lock(&pctldev->mutex);
 845
 846	/* Convert to the pin controllers number space */
 847	pin = gpio_to_pin(range, gc, offset);
 848
 849	pinmux_free_gpio(pctldev, pin, range);
 850
 851	mutex_unlock(&pctldev->mutex);
 852}
 853EXPORT_SYMBOL_GPL(pinctrl_gpio_free);
 854
 855static int pinctrl_gpio_direction(struct gpio_chip *gc, unsigned int offset,
 856				  bool input)
 857{
 858	struct pinctrl_dev *pctldev;
 859	struct pinctrl_gpio_range *range;
 860	int ret;
 861	int pin;
 862
 863	ret = pinctrl_get_device_gpio_range(gc, offset, &pctldev, &range);
 864	if (ret) {
 865		return ret;
 866	}
 867
 868	mutex_lock(&pctldev->mutex);
 869
 870	/* Convert to the pin controllers number space */
 871	pin = gpio_to_pin(range, gc, offset);
 872	ret = pinmux_gpio_direction(pctldev, range, pin, input);
 873
 874	mutex_unlock(&pctldev->mutex);
 875
 876	return ret;
 877}
 878
 879/**
 880 * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode
 881 * @gc: GPIO chip structure from the GPIO subsystem
 882 * @offset: hardware offset of the GPIO relative to the controller
 883 *
 884 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
 885 * as part of their gpio_direction_input() semantics, platforms and individual
 886 * drivers shall *NOT* touch pin control GPIO calls.
 887 */
 888int pinctrl_gpio_direction_input(struct gpio_chip *gc, unsigned int offset)
 889{
 890	return pinctrl_gpio_direction(gc, offset, true);
 891}
 892EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_input);
 893
 894/**
 895 * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode
 896 * @gc: GPIO chip structure from the GPIO subsystem
 897 * @offset: hardware offset of the GPIO relative to the controller
 898 *
 899 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
 900 * as part of their gpio_direction_output() semantics, platforms and individual
 901 * drivers shall *NOT* touch pin control GPIO calls.
 902 */
 903int pinctrl_gpio_direction_output(struct gpio_chip *gc, unsigned int offset)
 904{
 905	return pinctrl_gpio_direction(gc, offset, false);
 906}
 907EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_output);
 908
 909/**
 910 * pinctrl_gpio_set_config() - Apply config to given GPIO pin
 911 * @gc: GPIO chip structure from the GPIO subsystem
 912 * @offset: hardware offset of the GPIO relative to the controller
 913 * @config: the configuration to apply to the GPIO
 914 *
 915 * This function should *ONLY* be used from gpiolib-based GPIO drivers, if
 916 * they need to call the underlying pin controller to change GPIO config
 917 * (for example set debounce time).
 918 */
 919int pinctrl_gpio_set_config(struct gpio_chip *gc, unsigned int offset,
 920				unsigned long config)
 921{
 922	unsigned long configs[] = { config };
 923	struct pinctrl_gpio_range *range;
 924	struct pinctrl_dev *pctldev;
 925	int ret, pin;
 926
 927	ret = pinctrl_get_device_gpio_range(gc, offset, &pctldev, &range);
 928	if (ret)
 929		return ret;
 930
 931	mutex_lock(&pctldev->mutex);
 932	pin = gpio_to_pin(range, gc, offset);
 933	ret = pinconf_set_config(pctldev, pin, configs, ARRAY_SIZE(configs));
 934	mutex_unlock(&pctldev->mutex);
 935
 936	return ret;
 937}
 938EXPORT_SYMBOL_GPL(pinctrl_gpio_set_config);
 939
 940static struct pinctrl_state *find_state(struct pinctrl *p,
 941					const char *name)
 942{
 943	struct pinctrl_state *state;
 944
 945	list_for_each_entry(state, &p->states, node)
 946		if (!strcmp(state->name, name))
 947			return state;
 948
 949	return NULL;
 950}
 951
 952static struct pinctrl_state *create_state(struct pinctrl *p,
 953					  const char *name)
 954{
 955	struct pinctrl_state *state;
 956
 957	state = kzalloc(sizeof(*state), GFP_KERNEL);
 958	if (!state)
 959		return ERR_PTR(-ENOMEM);
 960
 961	state->name = name;
 962	INIT_LIST_HEAD(&state->settings);
 963
 964	list_add_tail(&state->node, &p->states);
 965
 966	return state;
 967}
 968
 969static int add_setting(struct pinctrl *p, struct pinctrl_dev *pctldev,
 970		       const struct pinctrl_map *map)
 971{
 972	struct pinctrl_state *state;
 973	struct pinctrl_setting *setting;
 974	int ret;
 975
 976	state = find_state(p, map->name);
 977	if (!state)
 978		state = create_state(p, map->name);
 979	if (IS_ERR(state))
 980		return PTR_ERR(state);
 981
 982	if (map->type == PIN_MAP_TYPE_DUMMY_STATE)
 983		return 0;
 984
 985	setting = kzalloc(sizeof(*setting), GFP_KERNEL);
 986	if (!setting)
 987		return -ENOMEM;
 988
 989	setting->type = map->type;
 990
 991	if (pctldev)
 992		setting->pctldev = pctldev;
 993	else
 994		setting->pctldev =
 995			get_pinctrl_dev_from_devname(map->ctrl_dev_name);
 996	if (!setting->pctldev) {
 997		kfree(setting);
 998		/* Do not defer probing of hogs (circular loop) */
 999		if (!strcmp(map->ctrl_dev_name, map->dev_name))
1000			return -ENODEV;
1001		/*
1002		 * OK let us guess that the driver is not there yet, and
1003		 * let's defer obtaining this pinctrl handle to later...
1004		 */
1005		dev_info(p->dev, "unknown pinctrl device %s in map entry, deferring probe",
1006			map->ctrl_dev_name);
1007		return -EPROBE_DEFER;
1008	}
1009
1010	setting->dev_name = map->dev_name;
1011
1012	switch (map->type) {
1013	case PIN_MAP_TYPE_MUX_GROUP:
1014		ret = pinmux_map_to_setting(map, setting);
1015		break;
1016	case PIN_MAP_TYPE_CONFIGS_PIN:
1017	case PIN_MAP_TYPE_CONFIGS_GROUP:
1018		ret = pinconf_map_to_setting(map, setting);
1019		break;
1020	default:
1021		ret = -EINVAL;
1022		break;
1023	}
1024	if (ret < 0) {
1025		kfree(setting);
1026		return ret;
1027	}
1028
1029	list_add_tail(&setting->node, &state->settings);
1030
1031	return 0;
1032}
1033
1034static struct pinctrl *find_pinctrl(struct device *dev)
1035{
1036	struct pinctrl *p;
1037
1038	mutex_lock(&pinctrl_list_mutex);
1039	list_for_each_entry(p, &pinctrl_list, node)
1040		if (p->dev == dev) {
1041			mutex_unlock(&pinctrl_list_mutex);
1042			return p;
1043		}
1044
1045	mutex_unlock(&pinctrl_list_mutex);
1046	return NULL;
1047}
1048
1049static void pinctrl_free(struct pinctrl *p, bool inlist);
1050
1051static struct pinctrl *create_pinctrl(struct device *dev,
1052				      struct pinctrl_dev *pctldev)
1053{
1054	struct pinctrl *p;
1055	const char *devname;
1056	struct pinctrl_maps *maps_node;
1057	const struct pinctrl_map *map;
1058	int ret;
1059
1060	/*
1061	 * create the state cookie holder struct pinctrl for each
1062	 * mapping, this is what consumers will get when requesting
1063	 * a pin control handle with pinctrl_get()
1064	 */
1065	p = kzalloc(sizeof(*p), GFP_KERNEL);
1066	if (!p)
1067		return ERR_PTR(-ENOMEM);
1068	p->dev = dev;
1069	INIT_LIST_HEAD(&p->states);
1070	INIT_LIST_HEAD(&p->dt_maps);
1071
1072	ret = pinctrl_dt_to_map(p, pctldev);
1073	if (ret < 0) {
1074		kfree(p);
1075		return ERR_PTR(ret);
1076	}
1077
1078	devname = dev_name(dev);
1079
1080	mutex_lock(&pinctrl_maps_mutex);
1081	/* Iterate over the pin control maps to locate the right ones */
1082	for_each_pin_map(maps_node, map) {
1083		/* Map must be for this device */
1084		if (strcmp(map->dev_name, devname))
1085			continue;
1086		/*
1087		 * If pctldev is not null, we are claiming hog for it,
1088		 * that means, setting that is served by pctldev by itself.
1089		 *
1090		 * Thus we must skip map that is for this device but is served
1091		 * by other device.
1092		 */
1093		if (pctldev &&
1094		    strcmp(dev_name(pctldev->dev), map->ctrl_dev_name))
1095			continue;
1096
1097		ret = add_setting(p, pctldev, map);
1098		/*
1099		 * At this point the adding of a setting may:
1100		 *
1101		 * - Defer, if the pinctrl device is not yet available
1102		 * - Fail, if the pinctrl device is not yet available,
1103		 *   AND the setting is a hog. We cannot defer that, since
1104		 *   the hog will kick in immediately after the device
1105		 *   is registered.
1106		 *
1107		 * If the error returned was not -EPROBE_DEFER then we
1108		 * accumulate the errors to see if we end up with
1109		 * an -EPROBE_DEFER later, as that is the worst case.
1110		 */
1111		if (ret == -EPROBE_DEFER) {
1112			mutex_unlock(&pinctrl_maps_mutex);
1113			pinctrl_free(p, false);
 
1114			return ERR_PTR(ret);
1115		}
1116	}
1117	mutex_unlock(&pinctrl_maps_mutex);
1118
1119	if (ret < 0) {
1120		/* If some other error than deferral occurred, return here */
1121		pinctrl_free(p, false);
1122		return ERR_PTR(ret);
1123	}
1124
1125	kref_init(&p->users);
1126
1127	/* Add the pinctrl handle to the global list */
1128	mutex_lock(&pinctrl_list_mutex);
1129	list_add_tail(&p->node, &pinctrl_list);
1130	mutex_unlock(&pinctrl_list_mutex);
1131
1132	return p;
1133}
1134
1135/**
1136 * pinctrl_get() - retrieves the pinctrl handle for a device
1137 * @dev: the device to obtain the handle for
1138 */
1139struct pinctrl *pinctrl_get(struct device *dev)
1140{
1141	struct pinctrl *p;
1142
1143	if (WARN_ON(!dev))
1144		return ERR_PTR(-EINVAL);
1145
1146	/*
1147	 * See if somebody else (such as the device core) has already
1148	 * obtained a handle to the pinctrl for this device. In that case,
1149	 * return another pointer to it.
1150	 */
1151	p = find_pinctrl(dev);
1152	if (p) {
1153		dev_dbg(dev, "obtain a copy of previously claimed pinctrl\n");
1154		kref_get(&p->users);
1155		return p;
1156	}
1157
1158	return create_pinctrl(dev, NULL);
1159}
1160EXPORT_SYMBOL_GPL(pinctrl_get);
1161
1162static void pinctrl_free_setting(bool disable_setting,
1163				 struct pinctrl_setting *setting)
1164{
1165	switch (setting->type) {
1166	case PIN_MAP_TYPE_MUX_GROUP:
1167		if (disable_setting)
1168			pinmux_disable_setting(setting);
1169		pinmux_free_setting(setting);
1170		break;
1171	case PIN_MAP_TYPE_CONFIGS_PIN:
1172	case PIN_MAP_TYPE_CONFIGS_GROUP:
1173		pinconf_free_setting(setting);
1174		break;
1175	default:
1176		break;
1177	}
1178}
1179
1180static void pinctrl_free(struct pinctrl *p, bool inlist)
1181{
1182	struct pinctrl_state *state, *n1;
1183	struct pinctrl_setting *setting, *n2;
1184
1185	mutex_lock(&pinctrl_list_mutex);
1186	list_for_each_entry_safe(state, n1, &p->states, node) {
1187		list_for_each_entry_safe(setting, n2, &state->settings, node) {
1188			pinctrl_free_setting(state == p->state, setting);
1189			list_del(&setting->node);
1190			kfree(setting);
1191		}
1192		list_del(&state->node);
1193		kfree(state);
1194	}
1195
1196	pinctrl_dt_free_maps(p);
1197
1198	if (inlist)
1199		list_del(&p->node);
1200	kfree(p);
1201	mutex_unlock(&pinctrl_list_mutex);
1202}
1203
1204/**
1205 * pinctrl_release() - release the pinctrl handle
1206 * @kref: the kref in the pinctrl being released
1207 */
1208static void pinctrl_release(struct kref *kref)
1209{
1210	struct pinctrl *p = container_of(kref, struct pinctrl, users);
1211
1212	pinctrl_free(p, true);
1213}
1214
1215/**
1216 * pinctrl_put() - decrease use count on a previously claimed pinctrl handle
1217 * @p: the pinctrl handle to release
1218 */
1219void pinctrl_put(struct pinctrl *p)
1220{
1221	kref_put(&p->users, pinctrl_release);
1222}
1223EXPORT_SYMBOL_GPL(pinctrl_put);
1224
1225/**
1226 * pinctrl_lookup_state() - retrieves a state handle from a pinctrl handle
1227 * @p: the pinctrl handle to retrieve the state from
1228 * @name: the state name to retrieve
1229 */
1230struct pinctrl_state *pinctrl_lookup_state(struct pinctrl *p,
1231						 const char *name)
1232{
1233	struct pinctrl_state *state;
1234
1235	state = find_state(p, name);
1236	if (!state) {
1237		if (pinctrl_dummy_state) {
1238			/* create dummy state */
1239			dev_dbg(p->dev, "using pinctrl dummy state (%s)\n",
1240				name);
1241			state = create_state(p, name);
1242		} else
1243			state = ERR_PTR(-ENODEV);
1244	}
1245
1246	return state;
1247}
1248EXPORT_SYMBOL_GPL(pinctrl_lookup_state);
1249
1250static void pinctrl_link_add(struct pinctrl_dev *pctldev,
1251			     struct device *consumer)
1252{
1253	if (pctldev->desc->link_consumers)
1254		device_link_add(consumer, pctldev->dev,
1255				DL_FLAG_PM_RUNTIME |
1256				DL_FLAG_AUTOREMOVE_CONSUMER);
1257}
1258
1259/**
1260 * pinctrl_commit_state() - select/activate/program a pinctrl state to HW
1261 * @p: the pinctrl handle for the device that requests configuration
1262 * @state: the state handle to select/activate/program
1263 */
1264static int pinctrl_commit_state(struct pinctrl *p, struct pinctrl_state *state)
1265{
1266	struct pinctrl_setting *setting, *setting2;
1267	struct pinctrl_state *old_state = READ_ONCE(p->state);
1268	int ret;
1269
1270	if (old_state) {
1271		/*
1272		 * For each pinmux setting in the old state, forget SW's record
1273		 * of mux owner for that pingroup. Any pingroups which are
1274		 * still owned by the new state will be re-acquired by the call
1275		 * to pinmux_enable_setting() in the loop below.
1276		 */
1277		list_for_each_entry(setting, &old_state->settings, node) {
1278			if (setting->type != PIN_MAP_TYPE_MUX_GROUP)
1279				continue;
1280			pinmux_disable_setting(setting);
1281		}
1282	}
1283
1284	p->state = NULL;
1285
1286	/* Apply all the settings for the new state - pinmux first */
1287	list_for_each_entry(setting, &state->settings, node) {
1288		switch (setting->type) {
1289		case PIN_MAP_TYPE_MUX_GROUP:
1290			ret = pinmux_enable_setting(setting);
1291			break;
1292		case PIN_MAP_TYPE_CONFIGS_PIN:
1293		case PIN_MAP_TYPE_CONFIGS_GROUP:
1294			ret = 0;
1295			break;
1296		default:
1297			ret = -EINVAL;
1298			break;
1299		}
1300
1301		if (ret < 0)
1302			goto unapply_new_state;
1303
1304		/* Do not link hogs (circular dependency) */
1305		if (p != setting->pctldev->p)
1306			pinctrl_link_add(setting->pctldev, p->dev);
1307	}
1308
1309	/* Apply all the settings for the new state - pinconf after */
1310	list_for_each_entry(setting, &state->settings, node) {
1311		switch (setting->type) {
1312		case PIN_MAP_TYPE_MUX_GROUP:
1313			ret = 0;
1314			break;
1315		case PIN_MAP_TYPE_CONFIGS_PIN:
1316		case PIN_MAP_TYPE_CONFIGS_GROUP:
1317			ret = pinconf_apply_setting(setting);
1318			break;
1319		default:
1320			ret = -EINVAL;
1321			break;
1322		}
1323
1324		if (ret < 0) {
1325			goto unapply_new_state;
1326		}
1327
1328		/* Do not link hogs (circular dependency) */
1329		if (p != setting->pctldev->p)
1330			pinctrl_link_add(setting->pctldev, p->dev);
1331	}
1332
1333	p->state = state;
1334
1335	return 0;
1336
1337unapply_new_state:
1338	dev_err(p->dev, "Error applying setting, reverse things back\n");
1339
1340	list_for_each_entry(setting2, &state->settings, node) {
1341		if (&setting2->node == &setting->node)
1342			break;
1343		/*
1344		 * All we can do here is pinmux_disable_setting.
1345		 * That means that some pins are muxed differently now
1346		 * than they were before applying the setting (We can't
1347		 * "unmux a pin"!), but it's not a big deal since the pins
1348		 * are free to be muxed by another apply_setting.
1349		 */
1350		if (setting2->type == PIN_MAP_TYPE_MUX_GROUP)
1351			pinmux_disable_setting(setting2);
1352	}
1353
1354	/* There's no infinite recursive loop here because p->state is NULL */
1355	if (old_state)
1356		pinctrl_select_state(p, old_state);
1357
1358	return ret;
1359}
1360
1361/**
1362 * pinctrl_select_state() - select/activate/program a pinctrl state to HW
1363 * @p: the pinctrl handle for the device that requests configuration
1364 * @state: the state handle to select/activate/program
1365 */
1366int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *state)
1367{
1368	if (p->state == state)
1369		return 0;
1370
1371	return pinctrl_commit_state(p, state);
1372}
1373EXPORT_SYMBOL_GPL(pinctrl_select_state);
1374
1375static void devm_pinctrl_release(struct device *dev, void *res)
1376{
1377	pinctrl_put(*(struct pinctrl **)res);
1378}
1379
1380/**
1381 * devm_pinctrl_get() - Resource managed pinctrl_get()
1382 * @dev: the device to obtain the handle for
1383 *
1384 * If there is a need to explicitly destroy the returned struct pinctrl,
1385 * devm_pinctrl_put() should be used, rather than plain pinctrl_put().
1386 */
1387struct pinctrl *devm_pinctrl_get(struct device *dev)
1388{
1389	struct pinctrl **ptr, *p;
1390
1391	ptr = devres_alloc(devm_pinctrl_release, sizeof(*ptr), GFP_KERNEL);
1392	if (!ptr)
1393		return ERR_PTR(-ENOMEM);
1394
1395	p = pinctrl_get(dev);
1396	if (!IS_ERR(p)) {
1397		*ptr = p;
1398		devres_add(dev, ptr);
1399	} else {
1400		devres_free(ptr);
1401	}
1402
1403	return p;
1404}
1405EXPORT_SYMBOL_GPL(devm_pinctrl_get);
1406
1407static int devm_pinctrl_match(struct device *dev, void *res, void *data)
1408{
1409	struct pinctrl **p = res;
1410
1411	return *p == data;
1412}
1413
1414/**
1415 * devm_pinctrl_put() - Resource managed pinctrl_put()
1416 * @p: the pinctrl handle to release
1417 *
1418 * Deallocate a struct pinctrl obtained via devm_pinctrl_get(). Normally
1419 * this function will not need to be called and the resource management
1420 * code will ensure that the resource is freed.
1421 */
1422void devm_pinctrl_put(struct pinctrl *p)
1423{
1424	WARN_ON(devres_release(p->dev, devm_pinctrl_release,
1425			       devm_pinctrl_match, p));
1426}
1427EXPORT_SYMBOL_GPL(devm_pinctrl_put);
1428
1429/**
1430 * pinctrl_register_mappings() - register a set of pin controller mappings
1431 * @maps: the pincontrol mappings table to register. Note the pinctrl-core
1432 *	keeps a reference to the passed in maps, so they should _not_ be
1433 *	marked with __initdata.
1434 * @num_maps: the number of maps in the mapping table
1435 */
1436int pinctrl_register_mappings(const struct pinctrl_map *maps,
1437			      unsigned int num_maps)
1438{
1439	int i, ret;
1440	struct pinctrl_maps *maps_node;
1441
1442	pr_debug("add %u pinctrl maps\n", num_maps);
1443
1444	/* First sanity check the new mapping */
1445	for (i = 0; i < num_maps; i++) {
1446		if (!maps[i].dev_name) {
1447			pr_err("failed to register map %s (%d): no device given\n",
1448			       maps[i].name, i);
1449			return -EINVAL;
1450		}
1451
1452		if (!maps[i].name) {
1453			pr_err("failed to register map %d: no map name given\n",
1454			       i);
1455			return -EINVAL;
1456		}
1457
1458		if (maps[i].type != PIN_MAP_TYPE_DUMMY_STATE &&
1459				!maps[i].ctrl_dev_name) {
1460			pr_err("failed to register map %s (%d): no pin control device given\n",
1461			       maps[i].name, i);
1462			return -EINVAL;
1463		}
1464
1465		switch (maps[i].type) {
1466		case PIN_MAP_TYPE_DUMMY_STATE:
1467			break;
1468		case PIN_MAP_TYPE_MUX_GROUP:
1469			ret = pinmux_validate_map(&maps[i], i);
1470			if (ret < 0)
1471				return ret;
1472			break;
1473		case PIN_MAP_TYPE_CONFIGS_PIN:
1474		case PIN_MAP_TYPE_CONFIGS_GROUP:
1475			ret = pinconf_validate_map(&maps[i], i);
1476			if (ret < 0)
1477				return ret;
1478			break;
1479		default:
1480			pr_err("failed to register map %s (%d): invalid type given\n",
1481			       maps[i].name, i);
1482			return -EINVAL;
1483		}
1484	}
1485
1486	maps_node = kzalloc(sizeof(*maps_node), GFP_KERNEL);
1487	if (!maps_node)
1488		return -ENOMEM;
1489
1490	maps_node->maps = maps;
1491	maps_node->num_maps = num_maps;
1492
1493	mutex_lock(&pinctrl_maps_mutex);
1494	list_add_tail(&maps_node->node, &pinctrl_maps);
1495	mutex_unlock(&pinctrl_maps_mutex);
1496
1497	return 0;
1498}
1499EXPORT_SYMBOL_GPL(pinctrl_register_mappings);
1500
1501/**
1502 * pinctrl_unregister_mappings() - unregister a set of pin controller mappings
1503 * @map: the pincontrol mappings table passed to pinctrl_register_mappings()
1504 *	when registering the mappings.
1505 */
1506void pinctrl_unregister_mappings(const struct pinctrl_map *map)
1507{
1508	struct pinctrl_maps *maps_node;
1509
1510	mutex_lock(&pinctrl_maps_mutex);
1511	list_for_each_entry(maps_node, &pinctrl_maps, node) {
1512		if (maps_node->maps == map) {
1513			list_del(&maps_node->node);
1514			kfree(maps_node);
1515			mutex_unlock(&pinctrl_maps_mutex);
1516			return;
1517		}
1518	}
1519	mutex_unlock(&pinctrl_maps_mutex);
1520}
1521EXPORT_SYMBOL_GPL(pinctrl_unregister_mappings);
1522
1523/**
1524 * pinctrl_force_sleep() - turn a given controller device into sleep state
1525 * @pctldev: pin controller device
1526 */
1527int pinctrl_force_sleep(struct pinctrl_dev *pctldev)
1528{
1529	if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_sleep))
1530		return pinctrl_commit_state(pctldev->p, pctldev->hog_sleep);
1531	return 0;
1532}
1533EXPORT_SYMBOL_GPL(pinctrl_force_sleep);
1534
1535/**
1536 * pinctrl_force_default() - turn a given controller device into default state
1537 * @pctldev: pin controller device
1538 */
1539int pinctrl_force_default(struct pinctrl_dev *pctldev)
1540{
1541	if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_default))
1542		return pinctrl_commit_state(pctldev->p, pctldev->hog_default);
1543	return 0;
1544}
1545EXPORT_SYMBOL_GPL(pinctrl_force_default);
1546
1547/**
1548 * pinctrl_init_done() - tell pinctrl probe is done
1549 *
1550 * We'll use this time to switch the pins from "init" to "default" unless the
1551 * driver selected some other state.
1552 *
1553 * @dev: device to that's done probing
1554 */
1555int pinctrl_init_done(struct device *dev)
1556{
1557	struct dev_pin_info *pins = dev->pins;
1558	int ret;
1559
1560	if (!pins)
1561		return 0;
1562
1563	if (IS_ERR(pins->init_state))
1564		return 0; /* No such state */
1565
1566	if (pins->p->state != pins->init_state)
1567		return 0; /* Not at init anyway */
1568
1569	if (IS_ERR(pins->default_state))
1570		return 0; /* No default state */
1571
1572	ret = pinctrl_select_state(pins->p, pins->default_state);
1573	if (ret)
1574		dev_err(dev, "failed to activate default pinctrl state\n");
1575
1576	return ret;
1577}
1578
1579static int pinctrl_select_bound_state(struct device *dev,
1580				      struct pinctrl_state *state)
1581{
1582	struct dev_pin_info *pins = dev->pins;
1583	int ret;
1584
1585	if (IS_ERR(state))
1586		return 0; /* No such state */
1587	ret = pinctrl_select_state(pins->p, state);
1588	if (ret)
1589		dev_err(dev, "failed to activate pinctrl state %s\n",
1590			state->name);
1591	return ret;
1592}
1593
1594/**
1595 * pinctrl_select_default_state() - select default pinctrl state
1596 * @dev: device to select default state for
1597 */
1598int pinctrl_select_default_state(struct device *dev)
1599{
1600	if (!dev->pins)
1601		return 0;
1602
1603	return pinctrl_select_bound_state(dev, dev->pins->default_state);
1604}
1605EXPORT_SYMBOL_GPL(pinctrl_select_default_state);
1606
1607#ifdef CONFIG_PM
1608
1609/**
1610 * pinctrl_pm_select_default_state() - select default pinctrl state for PM
1611 * @dev: device to select default state for
1612 */
1613int pinctrl_pm_select_default_state(struct device *dev)
1614{
1615	return pinctrl_select_default_state(dev);
1616}
1617EXPORT_SYMBOL_GPL(pinctrl_pm_select_default_state);
1618
1619/**
1620 * pinctrl_pm_select_sleep_state() - select sleep pinctrl state for PM
1621 * @dev: device to select sleep state for
1622 */
1623int pinctrl_pm_select_sleep_state(struct device *dev)
1624{
1625	if (!dev->pins)
1626		return 0;
1627
1628	return pinctrl_select_bound_state(dev, dev->pins->sleep_state);
1629}
1630EXPORT_SYMBOL_GPL(pinctrl_pm_select_sleep_state);
1631
1632/**
1633 * pinctrl_pm_select_idle_state() - select idle pinctrl state for PM
1634 * @dev: device to select idle state for
1635 */
1636int pinctrl_pm_select_idle_state(struct device *dev)
1637{
1638	if (!dev->pins)
1639		return 0;
1640
1641	return pinctrl_select_bound_state(dev, dev->pins->idle_state);
1642}
1643EXPORT_SYMBOL_GPL(pinctrl_pm_select_idle_state);
1644#endif
1645
1646#ifdef CONFIG_DEBUG_FS
1647
1648static int pinctrl_pins_show(struct seq_file *s, void *what)
1649{
1650	struct pinctrl_dev *pctldev = s->private;
1651	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1652	unsigned int i, pin;
1653#ifdef CONFIG_GPIOLIB
1654	struct gpio_device *gdev = NULL;
1655	struct pinctrl_gpio_range *range;
1656	int gpio_num;
1657#endif
1658
1659	seq_printf(s, "registered pins: %d\n", pctldev->desc->npins);
1660
1661	mutex_lock(&pctldev->mutex);
1662
1663	/* The pin number can be retrived from the pin controller descriptor */
1664	for (i = 0; i < pctldev->desc->npins; i++) {
1665		struct pin_desc *desc;
1666
1667		pin = pctldev->desc->pins[i].number;
1668		desc = pin_desc_get(pctldev, pin);
1669		/* Pin space may be sparse */
1670		if (!desc)
1671			continue;
1672
1673		seq_printf(s, "pin %d (%s) ", pin, desc->name);
1674
1675#ifdef CONFIG_GPIOLIB
1676		gdev = NULL;
1677		gpio_num = -1;
1678		list_for_each_entry(range, &pctldev->gpio_ranges, node) {
1679			if (range->pins != NULL) {
1680				for (int i = 0; i < range->npins; ++i) {
1681					if (range->pins[i] == pin) {
1682						gpio_num = range->base + i;
1683						break;
1684					}
1685				}
1686			} else if ((pin >= range->pin_base) &&
1687				   (pin < (range->pin_base + range->npins))) {
1688				gpio_num =
1689					range->base + (pin - range->pin_base);
1690			}
1691			if (gpio_num != -1)
1692				break;
 
1693		}
1694		if (gpio_num >= 0)
1695			/*
1696			 * FIXME: gpio_num comes from the global GPIO numberspace.
1697			 * we need to get rid of the range->base eventually and
1698			 * get the descriptor directly from the gpio_chip.
1699			 */
1700			gdev = gpiod_to_gpio_device(gpio_to_desc(gpio_num));
1701		if (gdev)
1702			seq_printf(s, "%u:%s ",
1703				   gpio_num - gpio_device_get_base(gdev),
1704				   gpio_device_get_label(gdev));
1705		else
1706			seq_puts(s, "0:? ");
1707#endif
1708
1709		/* Driver-specific info per pin */
1710		if (ops->pin_dbg_show)
1711			ops->pin_dbg_show(pctldev, s, pin);
1712
1713		seq_puts(s, "\n");
1714	}
1715
1716	mutex_unlock(&pctldev->mutex);
1717
1718	return 0;
1719}
1720DEFINE_SHOW_ATTRIBUTE(pinctrl_pins);
1721
1722static int pinctrl_groups_show(struct seq_file *s, void *what)
1723{
1724	struct pinctrl_dev *pctldev = s->private;
1725	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1726	unsigned int ngroups, selector = 0;
1727
1728	mutex_lock(&pctldev->mutex);
1729
1730	ngroups = ops->get_groups_count(pctldev);
1731
1732	seq_puts(s, "registered pin groups:\n");
1733	while (selector < ngroups) {
1734		const unsigned int *pins = NULL;
1735		unsigned int num_pins = 0;
1736		const char *gname = ops->get_group_name(pctldev, selector);
1737		const char *pname;
1738		int ret = 0;
1739		int i;
1740
1741		if (ops->get_group_pins)
1742			ret = ops->get_group_pins(pctldev, selector,
1743						  &pins, &num_pins);
1744		if (ret)
1745			seq_printf(s, "%s [ERROR GETTING PINS]\n",
1746				   gname);
1747		else {
1748			seq_printf(s, "group: %s\n", gname);
1749			for (i = 0; i < num_pins; i++) {
1750				pname = pin_get_name(pctldev, pins[i]);
1751				if (WARN_ON(!pname)) {
1752					mutex_unlock(&pctldev->mutex);
1753					return -EINVAL;
1754				}
1755				seq_printf(s, "pin %d (%s)\n", pins[i], pname);
1756			}
1757			seq_puts(s, "\n");
1758		}
1759		selector++;
1760	}
1761
1762	mutex_unlock(&pctldev->mutex);
1763
1764	return 0;
1765}
1766DEFINE_SHOW_ATTRIBUTE(pinctrl_groups);
1767
1768static int pinctrl_gpioranges_show(struct seq_file *s, void *what)
1769{
1770	struct pinctrl_dev *pctldev = s->private;
1771	struct pinctrl_gpio_range *range;
1772
1773	seq_puts(s, "GPIO ranges handled:\n");
1774
1775	mutex_lock(&pctldev->mutex);
1776
1777	/* Loop over the ranges */
1778	list_for_each_entry(range, &pctldev->gpio_ranges, node) {
1779		if (range->pins) {
1780			int a;
1781			seq_printf(s, "%u: %s GPIOS [%u - %u] PINS {",
1782				range->id, range->name,
1783				range->base, (range->base + range->npins - 1));
1784			for (a = 0; a < range->npins - 1; a++)
1785				seq_printf(s, "%u, ", range->pins[a]);
1786			seq_printf(s, "%u}\n", range->pins[a]);
1787		}
1788		else
1789			seq_printf(s, "%u: %s GPIOS [%u - %u] PINS [%u - %u]\n",
1790				range->id, range->name,
1791				range->base, (range->base + range->npins - 1),
1792				range->pin_base,
1793				(range->pin_base + range->npins - 1));
1794	}
1795
1796	mutex_unlock(&pctldev->mutex);
1797
1798	return 0;
1799}
1800DEFINE_SHOW_ATTRIBUTE(pinctrl_gpioranges);
1801
1802static int pinctrl_devices_show(struct seq_file *s, void *what)
1803{
1804	struct pinctrl_dev *pctldev;
1805
1806	seq_puts(s, "name [pinmux] [pinconf]\n");
1807
1808	mutex_lock(&pinctrldev_list_mutex);
1809
1810	list_for_each_entry(pctldev, &pinctrldev_list, node) {
1811		seq_printf(s, "%s ", pctldev->desc->name);
1812		if (pctldev->desc->pmxops)
1813			seq_puts(s, "yes ");
1814		else
1815			seq_puts(s, "no ");
1816		if (pctldev->desc->confops)
1817			seq_puts(s, "yes");
1818		else
1819			seq_puts(s, "no");
1820		seq_puts(s, "\n");
1821	}
1822
1823	mutex_unlock(&pinctrldev_list_mutex);
1824
1825	return 0;
1826}
1827DEFINE_SHOW_ATTRIBUTE(pinctrl_devices);
1828
1829static inline const char *map_type(enum pinctrl_map_type type)
1830{
1831	static const char * const names[] = {
1832		"INVALID",
1833		"DUMMY_STATE",
1834		"MUX_GROUP",
1835		"CONFIGS_PIN",
1836		"CONFIGS_GROUP",
1837	};
1838
1839	if (type >= ARRAY_SIZE(names))
1840		return "UNKNOWN";
1841
1842	return names[type];
1843}
1844
1845static int pinctrl_maps_show(struct seq_file *s, void *what)
1846{
1847	struct pinctrl_maps *maps_node;
1848	const struct pinctrl_map *map;
1849
1850	seq_puts(s, "Pinctrl maps:\n");
1851
1852	mutex_lock(&pinctrl_maps_mutex);
1853	for_each_pin_map(maps_node, map) {
1854		seq_printf(s, "device %s\nstate %s\ntype %s (%d)\n",
1855			   map->dev_name, map->name, map_type(map->type),
1856			   map->type);
1857
1858		if (map->type != PIN_MAP_TYPE_DUMMY_STATE)
1859			seq_printf(s, "controlling device %s\n",
1860				   map->ctrl_dev_name);
1861
1862		switch (map->type) {
1863		case PIN_MAP_TYPE_MUX_GROUP:
1864			pinmux_show_map(s, map);
1865			break;
1866		case PIN_MAP_TYPE_CONFIGS_PIN:
1867		case PIN_MAP_TYPE_CONFIGS_GROUP:
1868			pinconf_show_map(s, map);
1869			break;
1870		default:
1871			break;
1872		}
1873
1874		seq_putc(s, '\n');
1875	}
1876	mutex_unlock(&pinctrl_maps_mutex);
1877
1878	return 0;
1879}
1880DEFINE_SHOW_ATTRIBUTE(pinctrl_maps);
1881
1882static int pinctrl_show(struct seq_file *s, void *what)
1883{
1884	struct pinctrl *p;
1885	struct pinctrl_state *state;
1886	struct pinctrl_setting *setting;
1887
1888	seq_puts(s, "Requested pin control handlers their pinmux maps:\n");
1889
1890	mutex_lock(&pinctrl_list_mutex);
1891
1892	list_for_each_entry(p, &pinctrl_list, node) {
1893		seq_printf(s, "device: %s current state: %s\n",
1894			   dev_name(p->dev),
1895			   p->state ? p->state->name : "none");
1896
1897		list_for_each_entry(state, &p->states, node) {
1898			seq_printf(s, "  state: %s\n", state->name);
1899
1900			list_for_each_entry(setting, &state->settings, node) {
1901				struct pinctrl_dev *pctldev = setting->pctldev;
1902
1903				seq_printf(s, "    type: %s controller %s ",
1904					   map_type(setting->type),
1905					   pinctrl_dev_get_name(pctldev));
1906
1907				switch (setting->type) {
1908				case PIN_MAP_TYPE_MUX_GROUP:
1909					pinmux_show_setting(s, setting);
1910					break;
1911				case PIN_MAP_TYPE_CONFIGS_PIN:
1912				case PIN_MAP_TYPE_CONFIGS_GROUP:
1913					pinconf_show_setting(s, setting);
1914					break;
1915				default:
1916					break;
1917				}
1918			}
1919		}
1920	}
1921
1922	mutex_unlock(&pinctrl_list_mutex);
1923
1924	return 0;
1925}
1926DEFINE_SHOW_ATTRIBUTE(pinctrl);
1927
1928static struct dentry *debugfs_root;
1929
1930static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
1931{
1932	struct dentry *device_root;
1933	const char *debugfs_name;
1934
1935	if (pctldev->desc->name &&
1936			strcmp(dev_name(pctldev->dev), pctldev->desc->name)) {
1937		debugfs_name = devm_kasprintf(pctldev->dev, GFP_KERNEL,
1938				"%s-%s", dev_name(pctldev->dev),
1939				pctldev->desc->name);
1940		if (!debugfs_name) {
1941			pr_warn("failed to determine debugfs dir name for %s\n",
1942				dev_name(pctldev->dev));
1943			return;
1944		}
1945	} else {
1946		debugfs_name = dev_name(pctldev->dev);
1947	}
1948
1949	device_root = debugfs_create_dir(debugfs_name, debugfs_root);
1950	pctldev->device_root = device_root;
1951
1952	if (IS_ERR(device_root) || !device_root) {
1953		pr_warn("failed to create debugfs directory for %s\n",
1954			dev_name(pctldev->dev));
1955		return;
1956	}
1957	debugfs_create_file("pins", 0444,
1958			    device_root, pctldev, &pinctrl_pins_fops);
1959	debugfs_create_file("pingroups", 0444,
1960			    device_root, pctldev, &pinctrl_groups_fops);
1961	debugfs_create_file("gpio-ranges", 0444,
1962			    device_root, pctldev, &pinctrl_gpioranges_fops);
1963	if (pctldev->desc->pmxops)
1964		pinmux_init_device_debugfs(device_root, pctldev);
1965	if (pctldev->desc->confops)
1966		pinconf_init_device_debugfs(device_root, pctldev);
1967}
1968
1969static void pinctrl_remove_device_debugfs(struct pinctrl_dev *pctldev)
1970{
1971	debugfs_remove_recursive(pctldev->device_root);
1972}
1973
1974static void pinctrl_init_debugfs(void)
1975{
1976	debugfs_root = debugfs_create_dir("pinctrl", NULL);
1977	if (IS_ERR(debugfs_root)) {
1978		pr_warn("failed to create debugfs directory\n");
1979		debugfs_root = NULL;
1980		return;
1981	}
1982
1983	debugfs_create_file("pinctrl-devices", 0444,
1984			    debugfs_root, NULL, &pinctrl_devices_fops);
1985	debugfs_create_file("pinctrl-maps", 0444,
1986			    debugfs_root, NULL, &pinctrl_maps_fops);
1987	debugfs_create_file("pinctrl-handles", 0444,
1988			    debugfs_root, NULL, &pinctrl_fops);
1989}
1990
1991#else /* CONFIG_DEBUG_FS */
1992
1993static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
1994{
1995}
1996
1997static void pinctrl_init_debugfs(void)
1998{
1999}
2000
2001static void pinctrl_remove_device_debugfs(struct pinctrl_dev *pctldev)
2002{
2003}
2004
2005#endif
2006
2007static int pinctrl_check_ops(struct pinctrl_dev *pctldev)
2008{
2009	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
2010
2011	if (!ops ||
2012	    !ops->get_groups_count ||
2013	    !ops->get_group_name)
2014		return -EINVAL;
2015
2016	return 0;
2017}
2018
2019/**
2020 * pinctrl_init_controller() - init a pin controller device
2021 * @pctldesc: descriptor for this pin controller
2022 * @dev: parent device for this pin controller
2023 * @driver_data: private pin controller data for this pin controller
2024 */
2025static struct pinctrl_dev *
2026pinctrl_init_controller(struct pinctrl_desc *pctldesc, struct device *dev,
2027			void *driver_data)
2028{
2029	struct pinctrl_dev *pctldev;
2030	int ret;
2031
2032	if (!pctldesc)
2033		return ERR_PTR(-EINVAL);
2034	if (!pctldesc->name)
2035		return ERR_PTR(-EINVAL);
2036
2037	pctldev = kzalloc(sizeof(*pctldev), GFP_KERNEL);
2038	if (!pctldev)
2039		return ERR_PTR(-ENOMEM);
2040
2041	/* Initialize pin control device struct */
2042	pctldev->owner = pctldesc->owner;
2043	pctldev->desc = pctldesc;
2044	pctldev->driver_data = driver_data;
2045	INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL);
2046#ifdef CONFIG_GENERIC_PINCTRL_GROUPS
2047	INIT_RADIX_TREE(&pctldev->pin_group_tree, GFP_KERNEL);
2048#endif
2049#ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
2050	INIT_RADIX_TREE(&pctldev->pin_function_tree, GFP_KERNEL);
2051#endif
2052	INIT_LIST_HEAD(&pctldev->gpio_ranges);
2053	INIT_LIST_HEAD(&pctldev->node);
2054	pctldev->dev = dev;
2055	mutex_init(&pctldev->mutex);
2056
2057	/* check core ops for sanity */
2058	ret = pinctrl_check_ops(pctldev);
2059	if (ret) {
2060		dev_err(dev, "pinctrl ops lacks necessary functions\n");
2061		goto out_err;
2062	}
2063
2064	/* If we're implementing pinmuxing, check the ops for sanity */
2065	if (pctldesc->pmxops) {
2066		ret = pinmux_check_ops(pctldev);
2067		if (ret)
2068			goto out_err;
2069	}
2070
2071	/* If we're implementing pinconfig, check the ops for sanity */
2072	if (pctldesc->confops) {
2073		ret = pinconf_check_ops(pctldev);
2074		if (ret)
2075			goto out_err;
2076	}
2077
2078	/* Register all the pins */
2079	dev_dbg(dev, "try to register %d pins ...\n",  pctldesc->npins);
2080	ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);
2081	if (ret) {
2082		dev_err(dev, "error during pin registration\n");
2083		pinctrl_free_pindescs(pctldev, pctldesc->pins,
2084				      pctldesc->npins);
2085		goto out_err;
2086	}
2087
2088	return pctldev;
2089
2090out_err:
2091	mutex_destroy(&pctldev->mutex);
2092	kfree(pctldev);
2093	return ERR_PTR(ret);
2094}
2095
2096static void pinctrl_uninit_controller(struct pinctrl_dev *pctldev, struct pinctrl_desc *pctldesc)
2097{
2098	pinctrl_free_pindescs(pctldev, pctldesc->pins,
2099			      pctldesc->npins);
2100	mutex_destroy(&pctldev->mutex);
2101	kfree(pctldev);
2102}
2103
2104static int pinctrl_claim_hogs(struct pinctrl_dev *pctldev)
2105{
2106	pctldev->p = create_pinctrl(pctldev->dev, pctldev);
2107	if (PTR_ERR(pctldev->p) == -ENODEV) {
2108		dev_dbg(pctldev->dev, "no hogs found\n");
2109
2110		return 0;
2111	}
2112
2113	if (IS_ERR(pctldev->p)) {
2114		dev_err(pctldev->dev, "error claiming hogs: %li\n",
2115			PTR_ERR(pctldev->p));
2116
2117		return PTR_ERR(pctldev->p);
2118	}
2119
2120	pctldev->hog_default =
2121		pinctrl_lookup_state(pctldev->p, PINCTRL_STATE_DEFAULT);
2122	if (IS_ERR(pctldev->hog_default)) {
2123		dev_dbg(pctldev->dev,
2124			"failed to lookup the default state\n");
2125	} else {
2126		if (pinctrl_select_state(pctldev->p,
2127					 pctldev->hog_default))
2128			dev_err(pctldev->dev,
2129				"failed to select default state\n");
2130	}
2131
2132	pctldev->hog_sleep =
2133		pinctrl_lookup_state(pctldev->p,
2134				     PINCTRL_STATE_SLEEP);
2135	if (IS_ERR(pctldev->hog_sleep))
2136		dev_dbg(pctldev->dev,
2137			"failed to lookup the sleep state\n");
2138
2139	return 0;
2140}
2141
2142int pinctrl_enable(struct pinctrl_dev *pctldev)
2143{
2144	int error;
2145
2146	error = pinctrl_claim_hogs(pctldev);
2147	if (error) {
2148		dev_err(pctldev->dev, "could not claim hogs: %i\n", error);
 
 
 
 
 
 
2149		return error;
2150	}
2151
2152	mutex_lock(&pinctrldev_list_mutex);
2153	list_add_tail(&pctldev->node, &pinctrldev_list);
2154	mutex_unlock(&pinctrldev_list_mutex);
2155
2156	pinctrl_init_device_debugfs(pctldev);
2157
2158	return 0;
2159}
2160EXPORT_SYMBOL_GPL(pinctrl_enable);
2161
2162/**
2163 * pinctrl_register() - register a pin controller device
2164 * @pctldesc: descriptor for this pin controller
2165 * @dev: parent device for this pin controller
2166 * @driver_data: private pin controller data for this pin controller
2167 *
2168 * Note that pinctrl_register() is known to have problems as the pin
2169 * controller driver functions are called before the driver has a
2170 * struct pinctrl_dev handle. To avoid issues later on, please use the
2171 * new pinctrl_register_and_init() below instead.
2172 */
2173struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
2174				    struct device *dev, void *driver_data)
2175{
2176	struct pinctrl_dev *pctldev;
2177	int error;
2178
2179	pctldev = pinctrl_init_controller(pctldesc, dev, driver_data);
2180	if (IS_ERR(pctldev))
2181		return pctldev;
2182
2183	error = pinctrl_enable(pctldev);
2184	if (error) {
2185		pinctrl_uninit_controller(pctldev, pctldesc);
2186		return ERR_PTR(error);
2187	}
2188
2189	return pctldev;
2190}
2191EXPORT_SYMBOL_GPL(pinctrl_register);
2192
2193/**
2194 * pinctrl_register_and_init() - register and init pin controller device
2195 * @pctldesc: descriptor for this pin controller
2196 * @dev: parent device for this pin controller
2197 * @driver_data: private pin controller data for this pin controller
2198 * @pctldev: pin controller device
2199 *
2200 * Note that pinctrl_enable() still needs to be manually called after
2201 * this once the driver is ready.
2202 */
2203int pinctrl_register_and_init(struct pinctrl_desc *pctldesc,
2204			      struct device *dev, void *driver_data,
2205			      struct pinctrl_dev **pctldev)
2206{
2207	struct pinctrl_dev *p;
2208
2209	p = pinctrl_init_controller(pctldesc, dev, driver_data);
2210	if (IS_ERR(p))
2211		return PTR_ERR(p);
2212
2213	/*
2214	 * We have pinctrl_start() call functions in the pin controller
2215	 * driver with create_pinctrl() for at least dt_node_to_map(). So
2216	 * let's make sure pctldev is properly initialized for the
2217	 * pin controller driver before we do anything.
2218	 */
2219	*pctldev = p;
2220
2221	return 0;
2222}
2223EXPORT_SYMBOL_GPL(pinctrl_register_and_init);
2224
2225/**
2226 * pinctrl_unregister() - unregister pinmux
2227 * @pctldev: pin controller to unregister
2228 *
2229 * Called by pinmux drivers to unregister a pinmux.
2230 */
2231void pinctrl_unregister(struct pinctrl_dev *pctldev)
2232{
2233	struct pinctrl_gpio_range *range, *n;
2234
2235	if (!pctldev)
2236		return;
2237
2238	mutex_lock(&pctldev->mutex);
2239	pinctrl_remove_device_debugfs(pctldev);
2240	mutex_unlock(&pctldev->mutex);
2241
2242	if (!IS_ERR_OR_NULL(pctldev->p))
2243		pinctrl_put(pctldev->p);
2244
2245	mutex_lock(&pinctrldev_list_mutex);
2246	mutex_lock(&pctldev->mutex);
2247	/* TODO: check that no pinmuxes are still active? */
2248	list_del(&pctldev->node);
2249	pinmux_generic_free_functions(pctldev);
2250	pinctrl_generic_free_groups(pctldev);
2251	/* Destroy descriptor tree */
2252	pinctrl_free_pindescs(pctldev, pctldev->desc->pins,
2253			      pctldev->desc->npins);
2254	/* remove gpio ranges map */
2255	list_for_each_entry_safe(range, n, &pctldev->gpio_ranges, node)
2256		list_del(&range->node);
2257
2258	mutex_unlock(&pctldev->mutex);
2259	mutex_destroy(&pctldev->mutex);
2260	kfree(pctldev);
2261	mutex_unlock(&pinctrldev_list_mutex);
2262}
2263EXPORT_SYMBOL_GPL(pinctrl_unregister);
2264
2265static void devm_pinctrl_dev_release(struct device *dev, void *res)
2266{
2267	struct pinctrl_dev *pctldev = *(struct pinctrl_dev **)res;
2268
2269	pinctrl_unregister(pctldev);
2270}
2271
2272static int devm_pinctrl_dev_match(struct device *dev, void *res, void *data)
2273{
2274	struct pctldev **r = res;
2275
2276	if (WARN_ON(!r || !*r))
2277		return 0;
2278
2279	return *r == data;
2280}
2281
2282/**
2283 * devm_pinctrl_register() - Resource managed version of pinctrl_register().
2284 * @dev: parent device for this pin controller
2285 * @pctldesc: descriptor for this pin controller
2286 * @driver_data: private pin controller data for this pin controller
2287 *
2288 * Returns an error pointer if pincontrol register failed. Otherwise
2289 * it returns valid pinctrl handle.
2290 *
2291 * The pinctrl device will be automatically released when the device is unbound.
2292 */
2293struct pinctrl_dev *devm_pinctrl_register(struct device *dev,
2294					  struct pinctrl_desc *pctldesc,
2295					  void *driver_data)
2296{
2297	struct pinctrl_dev **ptr, *pctldev;
2298
2299	ptr = devres_alloc(devm_pinctrl_dev_release, sizeof(*ptr), GFP_KERNEL);
2300	if (!ptr)
2301		return ERR_PTR(-ENOMEM);
2302
2303	pctldev = pinctrl_register(pctldesc, dev, driver_data);
2304	if (IS_ERR(pctldev)) {
2305		devres_free(ptr);
2306		return pctldev;
2307	}
2308
2309	*ptr = pctldev;
2310	devres_add(dev, ptr);
2311
2312	return pctldev;
2313}
2314EXPORT_SYMBOL_GPL(devm_pinctrl_register);
2315
2316/**
2317 * devm_pinctrl_register_and_init() - Resource managed pinctrl register and init
2318 * @dev: parent device for this pin controller
2319 * @pctldesc: descriptor for this pin controller
2320 * @driver_data: private pin controller data for this pin controller
2321 * @pctldev: pin controller device
2322 *
2323 * Returns zero on success or an error number on failure.
2324 *
2325 * The pinctrl device will be automatically released when the device is unbound.
2326 */
2327int devm_pinctrl_register_and_init(struct device *dev,
2328				   struct pinctrl_desc *pctldesc,
2329				   void *driver_data,
2330				   struct pinctrl_dev **pctldev)
2331{
2332	struct pinctrl_dev **ptr;
2333	int error;
2334
2335	ptr = devres_alloc(devm_pinctrl_dev_release, sizeof(*ptr), GFP_KERNEL);
2336	if (!ptr)
2337		return -ENOMEM;
2338
2339	error = pinctrl_register_and_init(pctldesc, dev, driver_data, pctldev);
2340	if (error) {
2341		devres_free(ptr);
2342		return error;
2343	}
2344
2345	*ptr = *pctldev;
2346	devres_add(dev, ptr);
2347
2348	return 0;
2349}
2350EXPORT_SYMBOL_GPL(devm_pinctrl_register_and_init);
2351
2352/**
2353 * devm_pinctrl_unregister() - Resource managed version of pinctrl_unregister().
2354 * @dev: device for which resource was allocated
2355 * @pctldev: the pinctrl device to unregister.
2356 */
2357void devm_pinctrl_unregister(struct device *dev, struct pinctrl_dev *pctldev)
2358{
2359	WARN_ON(devres_release(dev, devm_pinctrl_dev_release,
2360			       devm_pinctrl_dev_match, pctldev));
2361}
2362EXPORT_SYMBOL_GPL(devm_pinctrl_unregister);
2363
2364static int __init pinctrl_init(void)
2365{
2366	pr_info("initialized pinctrl subsystem\n");
2367	pinctrl_init_debugfs();
2368	return 0;
2369}
2370
2371/* init early since many drivers really need to initialized pinmux early */
2372core_initcall(pinctrl_init);