drivers/pinctrl/core.c

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