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