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