drivers/pinctrl/core.c

   1 /*
   2  * Core driver for the pin control subsystem
   3  *
   4  * Copyright (C) 2011 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  * License terms: GNU General Public License (GPL) version 2
  11  */
  12 #define pr_fmt(fmt) "pinctrl core: " fmt
  13
  14 #include <linux/kernel.h>
  15 #include <linux/export.h>
  16 #include <linux/init.h>
  17 #include <linux/device.h>
  18 #include <linux/slab.h>
  19 #include <linux/radix-tree.h>
  20 #include <linux/err.h>
  21 #include <linux/list.h>
  22 #include <linux/mutex.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/sysfs.h>
  25 #include <linux/debugfs.h>
  26 #include <linux/seq_file.h>
  27 #include <linux/pinctrl/pinctrl.h>
  28 #include <linux/pinctrl/machine.h>
  29 #include "core.h"
  30 #include "pinmux.h"
  31
  32 /* Global list of pin control devices */
  33 static DEFINE_MUTEX(pinctrldev_list_mutex);
  34 static LIST_HEAD(pinctrldev_list);
  35
  36 static void pinctrl_dev_release(struct device *dev)
  37 {
  38         struct pinctrl_dev *pctldev = dev_get_drvdata(dev);
  39         kfree(pctldev);
  40 }
  41
  42 const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev)
  43 {
  44         /* We're not allowed to register devices without name */
  45         return pctldev->desc->name;
  46 }
  47 EXPORT_SYMBOL_GPL(pinctrl_dev_get_name);
  48
  49 void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev)
  50 {
  51         return pctldev->driver_data;
  52 }
  53 EXPORT_SYMBOL_GPL(pinctrl_dev_get_drvdata);
  54
  55 /**
  56  * get_pinctrl_dev_from_dev() - look up pin controller device
  57  * @dev: a device pointer, this may be NULL but then devname needs to be
  58  *      defined instead
  59  * @devname: the name of a device instance, as returned by dev_name(), this
  60  *      may be NULL but then dev needs to be defined instead
  61  *
  62  * Looks up a pin control device matching a certain device name or pure device
  63  * pointer, the pure device pointer will take precedence.
  64  */
  65 struct pinctrl_dev *get_pinctrl_dev_from_dev(struct device *dev,
  66                                              const char *devname)
  67 {
  68         struct pinctrl_dev *pctldev = NULL;
  69         bool found = false;
  70
  71         mutex_lock(&pinctrldev_list_mutex);
  72         list_for_each_entry(pctldev, &pinctrldev_list, node) {
  73                 if (dev &&  &pctldev->dev == dev) {
  74                         /* Matched on device pointer */
  75                         found = true;
  76                         break;
  77                 }
  78
  79                 if (devname &&
  80                     !strcmp(dev_name(&pctldev->dev), devname)) {
  81                         /* Matched on device name */
  82                         found = true;
  83                         break;
  84                 }
  85         }
  86         mutex_unlock(&pinctrldev_list_mutex);
  87
  88         return found ? pctldev : NULL;
  89 }
  90
  91 struct pin_desc *pin_desc_get(struct pinctrl_dev *pctldev, int pin)
  92 {
  93         struct pin_desc *pindesc;
  94         unsigned long flags;
  95
  96         spin_lock_irqsave(&pctldev->pin_desc_tree_lock, flags);
  97         pindesc = radix_tree_lookup(&pctldev->pin_desc_tree, pin);
  98         spin_unlock_irqrestore(&pctldev->pin_desc_tree_lock, flags);
  99
 100         return pindesc;
 101 }
 102
 103 /**
 104  * pin_is_valid() - check if pin exists on controller
 105  * @pctldev: the pin control device to check the pin on
 106  * @pin: pin to check, use the local pin controller index number
 107  *
 108  * This tells us whether a certain pin exist on a certain pin controller or
 109  * not. Pin lists may be sparse, so some pins may not exist.
 110  */
 111 bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
 112 {
 113         struct pin_desc *pindesc;
 114
 115         if (pin < 0)
 116                 return false;
 117
 118         pindesc = pin_desc_get(pctldev, pin);
 119         if (pindesc == NULL)
 120                 return false;
 121
 122         return true;
 123 }
 124 EXPORT_SYMBOL_GPL(pin_is_valid);
 125
 126 /* Deletes a range of pin descriptors */
 127 static void pinctrl_free_pindescs(struct pinctrl_dev *pctldev,
 128                                   const struct pinctrl_pin_desc *pins,
 129                                   unsigned num_pins)
 130 {
 131         int i;
 132
 133         spin_lock(&pctldev->pin_desc_tree_lock);
 134         for (i = 0; i < num_pins; i++) {
 135                 struct pin_desc *pindesc;
 136
 137                 pindesc = radix_tree_lookup(&pctldev->pin_desc_tree,
 138                                             pins[i].number);
 139                 if (pindesc != NULL) {
 140                         radix_tree_delete(&pctldev->pin_desc_tree,
 141                                           pins[i].number);
 142                 }
 143                 kfree(pindesc);
 144         }
 145         spin_unlock(&pctldev->pin_desc_tree_lock);
 146 }
 147
 148 static int pinctrl_register_one_pin(struct pinctrl_dev *pctldev,
 149                                     unsigned number, const char *name)
 150 {
 151         struct pin_desc *pindesc;
 152
 153         pindesc = pin_desc_get(pctldev, number);
 154         if (pindesc != NULL) {
 155                 pr_err("pin %d already registered on %s\n", number,
 156                        pctldev->desc->name);
 157                 return -EINVAL;
 158         }
 159
 160         pindesc = kzalloc(sizeof(*pindesc), GFP_KERNEL);
 161         if (pindesc == NULL)
 162                 return -ENOMEM;
 163         spin_lock_init(&pindesc->lock);
 164
 165         /* Set owner */
 166         pindesc->pctldev = pctldev;
 167
 168         /* Copy basic pin info */
 169         pindesc->name = name;
 170
 171         spin_lock(&pctldev->pin_desc_tree_lock);
 172         radix_tree_insert(&pctldev->pin_desc_tree, number, pindesc);
 173         spin_unlock(&pctldev->pin_desc_tree_lock);
 174         pr_debug("registered pin %d (%s) on %s\n",
 175                  number, name ? name : "(unnamed)", pctldev->desc->name);
 176         return 0;
 177 }
 178
 179 static int pinctrl_register_pins(struct pinctrl_dev *pctldev,
 180                                  struct pinctrl_pin_desc const *pins,
 181                                  unsigned num_descs)
 182 {
 183         unsigned i;
 184         int ret = 0;
 185
 186         for (i = 0; i < num_descs; i++) {
 187                 ret = pinctrl_register_one_pin(pctldev,
 188                                                pins[i].number, pins[i].name);
 189                 if (ret)
 190                         return ret;
 191         }
 192
 193         return 0;
 194 }
 195
 196 /**
 197  * pinctrl_match_gpio_range() - check if a certain GPIO pin is in range
 198  * @pctldev: pin controller device to check
 199  * @gpio: gpio pin to check taken from the global GPIO pin space
 200  *
 201  * Tries to match a GPIO pin number to the ranges handled by a certain pin
 202  * controller, return the range or NULL
 203  */
 204 static struct pinctrl_gpio_range *
 205 pinctrl_match_gpio_range(struct pinctrl_dev *pctldev, unsigned gpio)
 206 {
 207         struct pinctrl_gpio_range *range = NULL;
 208
 209         /* Loop over the ranges */
 210         mutex_lock(&pctldev->gpio_ranges_lock);
 211         list_for_each_entry(range, &pctldev->gpio_ranges, node) {
 212                 /* Check if we're in the valid range */
 213                 if (gpio >= range->base &&
 214                     gpio < range->base + range->npins) {
 215                         mutex_unlock(&pctldev->gpio_ranges_lock);
 216                         return range;
 217                 }
 218         }
 219         mutex_unlock(&pctldev->gpio_ranges_lock);
 220
 221         return NULL;
 222 }
 223
 224 /**
 225  * pinctrl_get_device_gpio_range() - find device for GPIO range
 226  * @gpio: the pin to locate the pin controller for
 227  * @outdev: the pin control device if found
 228  * @outrange: the GPIO range if found
 229  *
 230  * Find the pin controller handling a certain GPIO pin from the pinspace of
 231  * the GPIO subsystem, return the device and the matching GPIO range. Returns
 232  * negative if the GPIO range could not be found in any device.
 233  */
 234 int pinctrl_get_device_gpio_range(unsigned gpio,
 235                                 struct pinctrl_dev **outdev,
 236                                 struct pinctrl_gpio_range **outrange)
 237 {
 238         struct pinctrl_dev *pctldev = NULL;
 239
 240         /* Loop over the pin controllers */
 241         mutex_lock(&pinctrldev_list_mutex);
 242         list_for_each_entry(pctldev, &pinctrldev_list, node) {
 243                 struct pinctrl_gpio_range *range;
 244
 245                 range = pinctrl_match_gpio_range(pctldev, gpio);
 246                 if (range != NULL) {
 247                         *outdev = pctldev;
 248                         *outrange = range;
 249                         mutex_unlock(&pinctrldev_list_mutex);
 250                         return 0;
 251                 }
 252         }
 253         mutex_unlock(&pinctrldev_list_mutex);
 254
 255         return -EINVAL;
 256 }
 257
 258 /**
 259  * pinctrl_add_gpio_range() - register a GPIO range for a controller
 260  * @pctldev: pin controller device to add the range to
 261  * @range: the GPIO range to add
 262  *
 263  * This adds a range of GPIOs to be handled by a certain pin controller. Call
 264  * this to register handled ranges after registering your pin controller.
 265  */
 266 void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
 267                             struct pinctrl_gpio_range *range)
 268 {
 269         mutex_lock(&pctldev->gpio_ranges_lock);
 270         list_add(&range->node, &pctldev->gpio_ranges);
 271         mutex_unlock(&pctldev->gpio_ranges_lock);
 272 }
 273
 274 /**
 275  * pinctrl_remove_gpio_range() - remove a range of GPIOs fro a pin controller
 276  * @pctldev: pin controller device to remove the range from
 277  * @range: the GPIO range to remove
 278  */
 279 void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
 280                                struct pinctrl_gpio_range *range)
 281 {
 282         mutex_lock(&pctldev->gpio_ranges_lock);
 283         list_del(&range->node);
 284         mutex_unlock(&pctldev->gpio_ranges_lock);
 285 }
 286
 287 #ifdef CONFIG_DEBUG_FS
 288
 289 static int pinctrl_pins_show(struct seq_file *s, void *what)
 290 {
 291         struct pinctrl_dev *pctldev = s->private;
 292         const struct pinctrl_ops *ops = pctldev->desc->pctlops;
 293         unsigned pin;
 294
 295         seq_printf(s, "registered pins: %d\n", pctldev->desc->npins);
 296         seq_printf(s, "max pin number: %d\n", pctldev->desc->maxpin);
 297
 298         /* The highest pin number need to be included in the loop, thus <= */
 299         for (pin = 0; pin <= pctldev->desc->maxpin; pin++) {
 300                 struct pin_desc *desc;
 301
 302                 desc = pin_desc_get(pctldev, pin);
 303                 /* Pin space may be sparse */
 304                 if (desc == NULL)
 305                         continue;
 306
 307                 seq_printf(s, "pin %d (%s) ", pin,
 308                            desc->name ? desc->name : "unnamed");
 309
 310                 /* Driver-specific info per pin */
 311                 if (ops->pin_dbg_show)
 312                         ops->pin_dbg_show(pctldev, s, pin);
 313
 314                 seq_puts(s, "\n");
 315         }
 316
 317         return 0;
 318 }
 319
 320 static int pinctrl_groups_show(struct seq_file *s, void *what)
 321 {
 322         struct pinctrl_dev *pctldev = s->private;
 323         const struct pinctrl_ops *ops = pctldev->desc->pctlops;
 324         unsigned selector = 0;
 325
 326         /* No grouping */
 327         if (!ops)
 328                 return 0;
 329
 330         seq_puts(s, "registered pin groups:\n");
 331         while (ops->list_groups(pctldev, selector) >= 0) {
 332                 const unsigned *pins;
 333                 unsigned num_pins;
 334                 const char *gname = ops->get_group_name(pctldev, selector);
 335                 int ret;
 336                 int i;
 337
 338                 ret = ops->get_group_pins(pctldev, selector,
 339                                           &pins, &num_pins);
 340                 if (ret)
 341                         seq_printf(s, "%s [ERROR GETTING PINS]\n",
 342                                    gname);
 343                 else {
 344                         seq_printf(s, "group: %s, pins = [ ", gname);
 345                         for (i = 0; i < num_pins; i++)
 346                                 seq_printf(s, "%d ", pins[i]);
 347                         seq_puts(s, "]\n");
 348                 }
 349                 selector++;
 350         }
 351
 352
 353         return 0;
 354 }
 355
 356 static int pinctrl_gpioranges_show(struct seq_file *s, void *what)
 357 {
 358         struct pinctrl_dev *pctldev = s->private;
 359         struct pinctrl_gpio_range *range = NULL;
 360
 361         seq_puts(s, "GPIO ranges handled:\n");
 362
 363         /* Loop over the ranges */
 364         mutex_lock(&pctldev->gpio_ranges_lock);
 365         list_for_each_entry(range, &pctldev->gpio_ranges, node) {
 366                 seq_printf(s, "%u: %s [%u - %u]\n", range->id, range->name,
 367                            range->base, (range->base + range->npins - 1));
 368         }
 369         mutex_unlock(&pctldev->gpio_ranges_lock);
 370
 371         return 0;
 372 }
 373
 374 static int pinctrl_devices_show(struct seq_file *s, void *what)
 375 {
 376         struct pinctrl_dev *pctldev;
 377
 378         seq_puts(s, "name [pinmux]\n");
 379         mutex_lock(&pinctrldev_list_mutex);
 380         list_for_each_entry(pctldev, &pinctrldev_list, node) {
 381                 seq_printf(s, "%s ", pctldev->desc->name);
 382                 if (pctldev->desc->pmxops)
 383                         seq_puts(s, "yes");
 384                 else
 385                         seq_puts(s, "no");
 386                 seq_puts(s, "\n");
 387         }
 388         mutex_unlock(&pinctrldev_list_mutex);
 389
 390         return 0;
 391 }
 392
 393 static int pinctrl_pins_open(struct inode *inode, struct file *file)
 394 {
 395         return single_open(file, pinctrl_pins_show, inode->i_private);
 396 }
 397
 398 static int pinctrl_groups_open(struct inode *inode, struct file *file)
 399 {
 400         return single_open(file, pinctrl_groups_show, inode->i_private);
 401 }
 402
 403 static int pinctrl_gpioranges_open(struct inode *inode, struct file *file)
 404 {
 405         return single_open(file, pinctrl_gpioranges_show, inode->i_private);
 406 }
 407
 408 static int pinctrl_devices_open(struct inode *inode, struct file *file)
 409 {
 410         return single_open(file, pinctrl_devices_show, NULL);
 411 }
 412
 413 static const struct file_operations pinctrl_pins_ops = {
 414         .open           = pinctrl_pins_open,
 415         .read           = seq_read,
 416         .llseek         = seq_lseek,
 417         .release        = single_release,
 418 };
 419
 420 static const struct file_operations pinctrl_groups_ops = {
 421         .open           = pinctrl_groups_open,
 422         .read           = seq_read,
 423         .llseek         = seq_lseek,
 424         .release        = single_release,
 425 };
 426
 427 static const struct file_operations pinctrl_gpioranges_ops = {
 428         .open           = pinctrl_gpioranges_open,
 429         .read           = seq_read,
 430         .llseek         = seq_lseek,
 431         .release        = single_release,
 432 };
 433
 434 static const struct file_operations pinctrl_devices_ops = {
 435         .open           = pinctrl_devices_open,
 436         .read           = seq_read,
 437         .llseek         = seq_lseek,
 438         .release        = single_release,
 439 };
 440
 441 static struct dentry *debugfs_root;
 442
 443 static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
 444 {
 445         static struct dentry *device_root;
 446
 447         device_root = debugfs_create_dir(dev_name(&pctldev->dev),
 448                                          debugfs_root);
 449         if (IS_ERR(device_root) || !device_root) {
 450                 pr_warn("failed to create debugfs directory for %s\n",
 451                         dev_name(&pctldev->dev));
 452                 return;
 453         }
 454         debugfs_create_file("pins", S_IFREG | S_IRUGO,
 455                             device_root, pctldev, &pinctrl_pins_ops);
 456         debugfs_create_file("pingroups", S_IFREG | S_IRUGO,
 457                             device_root, pctldev, &pinctrl_groups_ops);
 458         debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO,
 459                             device_root, pctldev, &pinctrl_gpioranges_ops);
 460         pinmux_init_device_debugfs(device_root, pctldev);
 461 }
 462
 463 static void pinctrl_init_debugfs(void)
 464 {
 465         debugfs_root = debugfs_create_dir("pinctrl", NULL);
 466         if (IS_ERR(debugfs_root) || !debugfs_root) {
 467                 pr_warn("failed to create debugfs directory\n");
 468                 debugfs_root = NULL;
 469                 return;
 470         }
 471
 472         debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO,
 473                             debugfs_root, NULL, &pinctrl_devices_ops);
 474         pinmux_init_debugfs(debugfs_root);
 475 }
 476
 477 #else /* CONFIG_DEBUG_FS */
 478
 479 static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
 480 {
 481 }
 482
 483 static void pinctrl_init_debugfs(void)
 484 {
 485 }
 486
 487 #endif
 488
 489 /**
 490  * pinctrl_register() - register a pin controller device
 491  * @pctldesc: descriptor for this pin controller
 492  * @dev: parent device for this pin controller
 493  * @driver_data: private pin controller data for this pin controller
 494  */
 495 struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
 496                                     struct device *dev, void *driver_data)
 497 {
 498         static atomic_t pinmux_no = ATOMIC_INIT(0);
 499         struct pinctrl_dev *pctldev;
 500         int ret;
 501
 502         if (pctldesc == NULL)
 503                 return NULL;
 504         if (pctldesc->name == NULL)
 505                 return NULL;
 506
 507         /* If we're implementing pinmuxing, check the ops for sanity */
 508         if (pctldesc->pmxops) {
 509                 ret = pinmux_check_ops(pctldesc->pmxops);
 510                 if (ret) {
 511                         pr_err("%s pinmux ops lacks necessary functions\n",
 512                                pctldesc->name);
 513                         return NULL;
 514                 }
 515         }
 516
 517         pctldev = kzalloc(sizeof(struct pinctrl_dev), GFP_KERNEL);
 518         if (pctldev == NULL)
 519                 return NULL;
 520
 521         /* Initialize pin control device struct */
 522         pctldev->owner = pctldesc->owner;
 523         pctldev->desc = pctldesc;
 524         pctldev->driver_data = driver_data;
 525         INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL);
 526         spin_lock_init(&pctldev->pin_desc_tree_lock);
 527         INIT_LIST_HEAD(&pctldev->gpio_ranges);
 528         mutex_init(&pctldev->gpio_ranges_lock);
 529
 530         /* Register device */
 531         pctldev->dev.parent = dev;
 532         dev_set_name(&pctldev->dev, "pinctrl.%d",
 533                      atomic_inc_return(&pinmux_no) - 1);
 534         pctldev->dev.release = pinctrl_dev_release;
 535         ret = device_register(&pctldev->dev);
 536         if (ret != 0) {
 537                 pr_err("error in device registration\n");
 538                 goto out_reg_dev_err;
 539         }
 540         dev_set_drvdata(&pctldev->dev, pctldev);
 541
 542         /* Register all the pins */
 543         pr_debug("try to register %d pins on %s...\n",
 544                  pctldesc->npins, pctldesc->name);
 545         ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);
 546         if (ret) {
 547                 pr_err("error during pin registration\n");
 548                 pinctrl_free_pindescs(pctldev, pctldesc->pins,
 549                                       pctldesc->npins);
 550                 goto out_reg_pins_err;
 551         }
 552
 553         pinctrl_init_device_debugfs(pctldev);
 554         mutex_lock(&pinctrldev_list_mutex);
 555         list_add(&pctldev->node, &pinctrldev_list);
 556         mutex_unlock(&pinctrldev_list_mutex);
 557         pinmux_hog_maps(pctldev);
 558         return pctldev;
 559
 560 out_reg_pins_err:
 561         device_del(&pctldev->dev);
 562 out_reg_dev_err:
 563         put_device(&pctldev->dev);
 564         return NULL;
 565 }
 566 EXPORT_SYMBOL_GPL(pinctrl_register);
 567
 568 /**
 569  * pinctrl_unregister() - unregister pinmux
 570  * @pctldev: pin controller to unregister
 571  *
 572  * Called by pinmux drivers to unregister a pinmux.
 573  */
 574 void pinctrl_unregister(struct pinctrl_dev *pctldev)
 575 {
 576         if (pctldev == NULL)
 577                 return;
 578
 579         pinmux_unhog_maps(pctldev);
 580         /* TODO: check that no pinmuxes are still active? */
 581         mutex_lock(&pinctrldev_list_mutex);
 582         list_del(&pctldev->node);
 583         mutex_unlock(&pinctrldev_list_mutex);
 584         /* Destroy descriptor tree */
 585         pinctrl_free_pindescs(pctldev, pctldev->desc->pins,
 586                               pctldev->desc->npins);
 587         device_unregister(&pctldev->dev);
 588 }
 589 EXPORT_SYMBOL_GPL(pinctrl_unregister);
 590
 591 static int __init pinctrl_init(void)
 592 {
 593         pr_info("initialized pinctrl subsystem\n");
 594         pinctrl_init_debugfs();
 595         return 0;
 596 }
 597
 598 /* init early since many drivers really need to initialized pinmux early */
 599 core_initcall(pinctrl_init);