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