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