pinmux.c revision 8b9c139f166cd55d76728a5910fa862a4e16e833
1/* 2 * Core driver for the pin muxing portions of 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 * License terms: GNU General Public License (GPL) version 2 11 */ 12#define pr_fmt(fmt) "pinmux core: " fmt 13 14#include <linux/kernel.h> 15#include <linux/module.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/string.h> 25#include <linux/sysfs.h> 26#include <linux/debugfs.h> 27#include <linux/seq_file.h> 28#include <linux/pinctrl/machine.h> 29#include <linux/pinctrl/pinmux.h> 30#include "core.h" 31#include "pinmux.h" 32 33/** 34 * struct pinmux_group - group list item for pinmux groups 35 * @node: pinmux group list node 36 * @group_selector: the group selector for this group 37 */ 38struct pinmux_group { 39 struct list_head node; 40 unsigned group_selector; 41}; 42 43/** 44 * pin_request() - request a single pin to be muxed in, typically for GPIO 45 * @pin: the pin number in the global pin space 46 * @function: a functional name to give to this pin, passed to the driver 47 * so it knows what function to mux in, e.g. the string "gpioNN" 48 * means that you want to mux in the pin for use as GPIO number NN 49 * @gpio_range: the range matching the GPIO pin if this is a request for a 50 * single GPIO pin 51 */ 52static int pin_request(struct pinctrl_dev *pctldev, 53 int pin, const char *function, 54 struct pinctrl_gpio_range *gpio_range) 55{ 56 struct pin_desc *desc; 57 const struct pinmux_ops *ops = pctldev->desc->pmxops; 58 int status = -EINVAL; 59 60 dev_dbg(pctldev->dev, "request pin %d for %s\n", pin, function); 61 62 desc = pin_desc_get(pctldev, pin); 63 if (desc == NULL) { 64 dev_err(pctldev->dev, 65 "pin is not registered so it cannot be requested\n"); 66 goto out; 67 } 68 69 if (!function) { 70 dev_err(pctldev->dev, "no function name given\n"); 71 return -EINVAL; 72 } 73 74 spin_lock(&desc->lock); 75 if (desc->mux_function) { 76 spin_unlock(&desc->lock); 77 dev_err(pctldev->dev, 78 "pin already requested\n"); 79 goto out; 80 } 81 desc->mux_function = function; 82 spin_unlock(&desc->lock); 83 84 /* Let each pin increase references to this module */ 85 if (!try_module_get(pctldev->owner)) { 86 dev_err(pctldev->dev, 87 "could not increase module refcount for pin %d\n", 88 pin); 89 status = -EINVAL; 90 goto out_free_pin; 91 } 92 93 /* 94 * If there is no kind of request function for the pin we just assume 95 * we got it by default and proceed. 96 */ 97 if (gpio_range && ops->gpio_request_enable) 98 /* This requests and enables a single GPIO pin */ 99 status = ops->gpio_request_enable(pctldev, gpio_range, pin); 100 else if (ops->request) 101 status = ops->request(pctldev, pin); 102 else 103 status = 0; 104 105 if (status) 106 dev_err(pctldev->dev, "->request on device %s failed for pin %d\n", 107 pctldev->desc->name, pin); 108out_free_pin: 109 if (status) { 110 spin_lock(&desc->lock); 111 desc->mux_function = NULL; 112 spin_unlock(&desc->lock); 113 } 114out: 115 if (status) 116 dev_err(pctldev->dev, "pin-%d (%s) status %d\n", 117 pin, function ? : "?", status); 118 119 return status; 120} 121 122/** 123 * pin_free() - release a single muxed in pin so something else can be muxed 124 * @pctldev: pin controller device handling this pin 125 * @pin: the pin to free 126 * @gpio_range: the range matching the GPIO pin if this is a request for a 127 * single GPIO pin 128 * 129 * This function returns a pointer to the function name in use. This is used 130 * for callers that dynamically allocate a function name so it can be freed 131 * once the pin is free. This is done for GPIO request functions. 132 */ 133static const char *pin_free(struct pinctrl_dev *pctldev, int pin, 134 struct pinctrl_gpio_range *gpio_range) 135{ 136 const struct pinmux_ops *ops = pctldev->desc->pmxops; 137 struct pin_desc *desc; 138 const char *func; 139 140 desc = pin_desc_get(pctldev, pin); 141 if (desc == NULL) { 142 dev_err(pctldev->dev, 143 "pin is not registered so it cannot be freed\n"); 144 return NULL; 145 } 146 147 /* 148 * If there is no kind of request function for the pin we just assume 149 * we got it by default and proceed. 150 */ 151 if (gpio_range && ops->gpio_disable_free) 152 ops->gpio_disable_free(pctldev, gpio_range, pin); 153 else if (ops->free) 154 ops->free(pctldev, pin); 155 156 spin_lock(&desc->lock); 157 func = desc->mux_function; 158 desc->mux_function = NULL; 159 spin_unlock(&desc->lock); 160 module_put(pctldev->owner); 161 162 return func; 163} 164 165/** 166 * pinmux_request_gpio() - request pinmuxing for a GPIO pin 167 * @pctldev: pin controller device affected 168 * @pin: the pin to mux in for GPIO 169 * @range: the applicable GPIO range 170 */ 171int pinmux_request_gpio(struct pinctrl_dev *pctldev, 172 struct pinctrl_gpio_range *range, 173 unsigned pin, unsigned gpio) 174{ 175 char gpiostr[16]; 176 const char *function; 177 int ret; 178 179 /* Conjure some name stating what chip and pin this is taken by */ 180 snprintf(gpiostr, 15, "%s:%d", range->name, gpio); 181 182 function = kstrdup(gpiostr, GFP_KERNEL); 183 if (!function) 184 return -EINVAL; 185 186 ret = pin_request(pctldev, pin, function, range); 187 if (ret < 0) 188 kfree(function); 189 190 return ret; 191} 192 193/** 194 * pinmux_free_gpio() - release a pin from GPIO muxing 195 * @pctldev: the pin controller device for the pin 196 * @pin: the affected currently GPIO-muxed in pin 197 * @range: applicable GPIO range 198 */ 199void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin, 200 struct pinctrl_gpio_range *range) 201{ 202 const char *func; 203 204 func = pin_free(pctldev, pin, range); 205 kfree(func); 206} 207 208/** 209 * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin 210 * @pctldev: the pin controller handling this pin 211 * @range: applicable GPIO range 212 * @pin: the affected GPIO pin in this controller 213 * @input: true if we set the pin as input, false for output 214 */ 215int pinmux_gpio_direction(struct pinctrl_dev *pctldev, 216 struct pinctrl_gpio_range *range, 217 unsigned pin, bool input) 218{ 219 const struct pinmux_ops *ops; 220 int ret; 221 222 ops = pctldev->desc->pmxops; 223 224 if (ops->gpio_set_direction) 225 ret = ops->gpio_set_direction(pctldev, range, pin, input); 226 else 227 ret = 0; 228 229 return ret; 230} 231 232/** 233 * acquire_pins() - acquire all the pins for a certain function on a pinmux 234 * @pctldev: the device to take the pins on 235 * @func_selector: the function selector to acquire the pins for 236 * @group_selector: the group selector containing the pins to acquire 237 */ 238static int acquire_pins(struct pinctrl_dev *pctldev, 239 unsigned func_selector, 240 unsigned group_selector) 241{ 242 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 243 const struct pinmux_ops *pmxops = pctldev->desc->pmxops; 244 const char *func = pmxops->get_function_name(pctldev, 245 func_selector); 246 const unsigned *pins; 247 unsigned num_pins; 248 int ret; 249 int i; 250 251 ret = pctlops->get_group_pins(pctldev, group_selector, 252 &pins, &num_pins); 253 if (ret) 254 return ret; 255 256 dev_dbg(pctldev->dev, "requesting the %u pins from group %u\n", 257 num_pins, group_selector); 258 259 /* Try to allocate all pins in this group, one by one */ 260 for (i = 0; i < num_pins; i++) { 261 ret = pin_request(pctldev, pins[i], func, NULL); 262 if (ret) { 263 dev_err(pctldev->dev, 264 "could not get pin %d for function %s on device %s - conflicting mux mappings?\n", 265 pins[i], func ? : "(undefined)", 266 pinctrl_dev_get_name(pctldev)); 267 /* On error release all taken pins */ 268 i--; /* this pin just failed */ 269 for (; i >= 0; i--) 270 pin_free(pctldev, pins[i], NULL); 271 return -ENODEV; 272 } 273 } 274 return 0; 275} 276 277/** 278 * release_pins() - release pins taken by earlier acquirement 279 * @pctldev: the device to free the pins on 280 * @group_selector: the group selector containing the pins to free 281 */ 282static void release_pins(struct pinctrl_dev *pctldev, 283 unsigned group_selector) 284{ 285 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 286 const unsigned *pins; 287 unsigned num_pins; 288 int ret; 289 int i; 290 291 ret = pctlops->get_group_pins(pctldev, group_selector, 292 &pins, &num_pins); 293 if (ret) { 294 dev_err(pctldev->dev, "could not get pins to release for group selector %d\n", 295 group_selector); 296 return; 297 } 298 for (i = 0; i < num_pins; i++) 299 pin_free(pctldev, pins[i], NULL); 300} 301 302/** 303 * pinmux_check_pin_group() - check function and pin group combo 304 * @pctldev: device to check the pin group vs function for 305 * @func_selector: the function selector to check the pin group for, we have 306 * already looked this up in the calling function 307 * @pin_group: the pin group to match to the function 308 * 309 * This function will check that the pinmux driver can supply the 310 * selected pin group for a certain function, returns the group selector if 311 * the group and function selector will work fine together, else returns 312 * negative 313 */ 314static int pinmux_check_pin_group(struct pinctrl_dev *pctldev, 315 unsigned func_selector, 316 const char *pin_group) 317{ 318 const struct pinmux_ops *pmxops = pctldev->desc->pmxops; 319 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 320 int ret; 321 322 /* 323 * If the driver does not support different pin groups for the 324 * functions, we only support group 0, and assume this exists. 325 */ 326 if (!pctlops || !pctlops->list_groups) 327 return 0; 328 329 /* 330 * Passing NULL (no specific group) will select the first and 331 * hopefully only group of pins available for this function. 332 */ 333 if (!pin_group) { 334 char const * const *groups; 335 unsigned num_groups; 336 337 ret = pmxops->get_function_groups(pctldev, func_selector, 338 &groups, &num_groups); 339 if (ret) 340 return ret; 341 if (num_groups < 1) 342 return -EINVAL; 343 ret = pinctrl_get_group_selector(pctldev, groups[0]); 344 if (ret < 0) { 345 dev_err(pctldev->dev, 346 "function %s wants group %s but the pin controller does not seem to have that group\n", 347 pmxops->get_function_name(pctldev, func_selector), 348 groups[0]); 349 return ret; 350 } 351 352 if (num_groups > 1) 353 dev_dbg(pctldev->dev, 354 "function %s support more than one group, default-selecting first group %s (%d)\n", 355 pmxops->get_function_name(pctldev, func_selector), 356 groups[0], 357 ret); 358 359 return ret; 360 } 361 362 dev_dbg(pctldev->dev, 363 "check if we have pin group %s on controller %s\n", 364 pin_group, pinctrl_dev_get_name(pctldev)); 365 366 ret = pinctrl_get_group_selector(pctldev, pin_group); 367 if (ret < 0) { 368 dev_dbg(pctldev->dev, 369 "%s does not support pin group %s with function %s\n", 370 pinctrl_dev_get_name(pctldev), 371 pin_group, 372 pmxops->get_function_name(pctldev, func_selector)); 373 } 374 return ret; 375} 376 377/** 378 * pinmux_search_function() - check pin control driver for a certain function 379 * @pctldev: device to check for function and position 380 * @map: function map containing the function and position to look for 381 * @func_selector: returns the applicable function selector if found 382 * @group_selector: returns the applicable group selector if found 383 * 384 * This will search the pinmux driver for an applicable 385 * function with a specific pin group, returns 0 if these can be mapped 386 * negative otherwise 387 */ 388static int pinmux_search_function(struct pinctrl_dev *pctldev, 389 struct pinctrl_map const *map, 390 unsigned *func_selector, 391 unsigned *group_selector) 392{ 393 const struct pinmux_ops *ops = pctldev->desc->pmxops; 394 unsigned selector = 0; 395 396 /* See if this pctldev has this function */ 397 while (ops->list_functions(pctldev, selector) >= 0) { 398 const char *fname = ops->get_function_name(pctldev, 399 selector); 400 int ret; 401 402 if (!strcmp(map->function, fname)) { 403 /* Found the function, check pin group */ 404 ret = pinmux_check_pin_group(pctldev, selector, 405 map->group); 406 if (ret < 0) 407 return ret; 408 409 /* This function and group selector can be used */ 410 *func_selector = selector; 411 *group_selector = ret; 412 return 0; 413 414 } 415 selector++; 416 } 417 418 pr_err("%s does not support function %s\n", 419 pinctrl_dev_get_name(pctldev), map->function); 420 return -EINVAL; 421} 422 423/** 424 * pinmux_enable_muxmap() - enable a map entry for a certain pinmux 425 */ 426static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev, 427 struct pinctrl *p, 428 struct device *dev, 429 const char *devname, 430 struct pinctrl_map const *map) 431{ 432 unsigned func_selector; 433 unsigned group_selector; 434 struct pinmux_group *grp; 435 int ret; 436 437 /* 438 * Note that we're not locking the pinmux mutex here, because 439 * this is only called at pinmux initialization time when it 440 * has not been added to any list and thus is not reachable 441 * by anyone else. 442 */ 443 444 if (p->pctldev && p->pctldev != pctldev) { 445 dev_err(pctldev->dev, 446 "different pin control devices given for device %s, function %s\n", 447 devname, map->function); 448 return -EINVAL; 449 } 450 p->dev = dev; 451 p->pctldev = pctldev; 452 453 /* Now go into the driver and try to match a function and group */ 454 ret = pinmux_search_function(pctldev, map, &func_selector, 455 &group_selector); 456 if (ret < 0) 457 return ret; 458 459 /* 460 * If the function selector is already set, it needs to be identical, 461 * we support several groups with one function but not several 462 * functions with one or several groups in the same pinmux. 463 */ 464 if (p->func_selector != UINT_MAX && 465 p->func_selector != func_selector) { 466 dev_err(pctldev->dev, 467 "dual function defines in the map for device %s\n", 468 devname); 469 return -EINVAL; 470 } 471 p->func_selector = func_selector; 472 473 /* Now add this group selector, we may have many of them */ 474 grp = kmalloc(sizeof(struct pinmux_group), GFP_KERNEL); 475 if (!grp) 476 return -ENOMEM; 477 grp->group_selector = group_selector; 478 ret = acquire_pins(pctldev, func_selector, group_selector); 479 if (ret) { 480 kfree(grp); 481 return ret; 482 } 483 list_add_tail(&grp->node, &p->groups); 484 485 return 0; 486} 487 488/** 489 * pinmux_apply_muxmap() - apply a certain mux mapping entry 490 */ 491int pinmux_apply_muxmap(struct pinctrl_dev *pctldev, 492 struct pinctrl *p, 493 struct device *dev, 494 const char *devname, 495 struct pinctrl_map const *map) 496{ 497 int ret; 498 499 ret = pinmux_enable_muxmap(pctldev, p, dev, 500 devname, map); 501 if (ret) { 502 pinmux_put(p); 503 return ret; 504 } 505 506 return 0; 507} 508 509/** 510 * pinmux_put() - free up the pinmux portions of a pin controller handle 511 */ 512void pinmux_put(struct pinctrl *p) 513{ 514 struct list_head *node, *tmp; 515 516 list_for_each_safe(node, tmp, &p->groups) { 517 struct pinmux_group *grp = 518 list_entry(node, struct pinmux_group, node); 519 /* Release all pins taken by this group */ 520 release_pins(p->pctldev, grp->group_selector); 521 list_del(node); 522 kfree(grp); 523 } 524} 525 526/** 527 * pinmux_enable() - enable the pinmux portion of a pin control handle 528 */ 529int pinmux_enable(struct pinctrl *p) 530{ 531 struct pinctrl_dev *pctldev = p->pctldev; 532 const struct pinmux_ops *ops = pctldev->desc->pmxops; 533 struct pinmux_group *grp; 534 int ret; 535 536 list_for_each_entry(grp, &p->groups, node) { 537 ret = ops->enable(pctldev, p->func_selector, 538 grp->group_selector); 539 if (ret) 540 /* 541 * TODO: call disable() on all groups we called 542 * enable() on to this point? 543 */ 544 return ret; 545 } 546 return 0; 547} 548 549/** 550 * pinmux_disable() - disable the pinmux portions of a pin control handle 551 */ 552void pinmux_disable(struct pinctrl *p) 553{ 554 struct pinctrl_dev *pctldev = p->pctldev; 555 const struct pinmux_ops *ops = pctldev->desc->pmxops; 556 struct pinmux_group *grp; 557 558 list_for_each_entry(grp, &p->groups, node) { 559 ops->disable(pctldev, p->func_selector, 560 grp->group_selector); 561 } 562} 563 564int pinmux_check_ops(struct pinctrl_dev *pctldev) 565{ 566 const struct pinmux_ops *ops = pctldev->desc->pmxops; 567 unsigned selector = 0; 568 569 /* Check that we implement required operations */ 570 if (!ops->list_functions || 571 !ops->get_function_name || 572 !ops->get_function_groups || 573 !ops->enable || 574 !ops->disable) 575 return -EINVAL; 576 577 /* Check that all functions registered have names */ 578 while (ops->list_functions(pctldev, selector) >= 0) { 579 const char *fname = ops->get_function_name(pctldev, 580 selector); 581 if (!fname) { 582 pr_err("pinmux ops has no name for function%u\n", 583 selector); 584 return -EINVAL; 585 } 586 selector++; 587 } 588 589 return 0; 590} 591 592#ifdef CONFIG_DEBUG_FS 593 594/* Called from pincontrol core */ 595static int pinmux_functions_show(struct seq_file *s, void *what) 596{ 597 struct pinctrl_dev *pctldev = s->private; 598 const struct pinmux_ops *pmxops = pctldev->desc->pmxops; 599 unsigned func_selector = 0; 600 601 while (pmxops->list_functions(pctldev, func_selector) >= 0) { 602 const char *func = pmxops->get_function_name(pctldev, 603 func_selector); 604 const char * const *groups; 605 unsigned num_groups; 606 int ret; 607 int i; 608 609 ret = pmxops->get_function_groups(pctldev, func_selector, 610 &groups, &num_groups); 611 if (ret) 612 seq_printf(s, "function %s: COULD NOT GET GROUPS\n", 613 func); 614 615 seq_printf(s, "function: %s, groups = [ ", func); 616 for (i = 0; i < num_groups; i++) 617 seq_printf(s, "%s ", groups[i]); 618 seq_puts(s, "]\n"); 619 620 func_selector++; 621 622 } 623 624 return 0; 625} 626 627static int pinmux_pins_show(struct seq_file *s, void *what) 628{ 629 struct pinctrl_dev *pctldev = s->private; 630 unsigned i, pin; 631 632 seq_puts(s, "Pinmux settings per pin\n"); 633 seq_puts(s, "Format: pin (name): pinmuxfunction\n"); 634 635 /* The pin number can be retrived from the pin controller descriptor */ 636 for (i = 0; i < pctldev->desc->npins; i++) { 637 638 struct pin_desc *desc; 639 640 pin = pctldev->desc->pins[i].number; 641 desc = pin_desc_get(pctldev, pin); 642 /* Skip if we cannot search the pin */ 643 if (desc == NULL) 644 continue; 645 646 seq_printf(s, "pin %d (%s): %s\n", pin, 647 desc->name ? desc->name : "unnamed", 648 desc->mux_function ? desc->mux_function 649 : "UNCLAIMED"); 650 } 651 652 return 0; 653} 654 655void pinmux_dbg_show(struct seq_file *s, struct pinctrl *p) 656{ 657 struct pinctrl_dev *pctldev = p->pctldev; 658 const struct pinmux_ops *pmxops; 659 const struct pinctrl_ops *pctlops; 660 struct pinmux_group *grp; 661 662 pmxops = pctldev->desc->pmxops; 663 pctlops = pctldev->desc->pctlops; 664 665 seq_printf(s, " function: %s (%u),", 666 pmxops->get_function_name(pctldev, 667 p->func_selector), 668 p->func_selector); 669 670 seq_printf(s, " groups: ["); 671 list_for_each_entry(grp, &p->groups, node) { 672 seq_printf(s, " %s (%u)", 673 pctlops->get_group_name(pctldev, 674 grp->group_selector), 675 grp->group_selector); 676 } 677 seq_printf(s, " ]"); 678} 679 680static int pinmux_functions_open(struct inode *inode, struct file *file) 681{ 682 return single_open(file, pinmux_functions_show, inode->i_private); 683} 684 685static int pinmux_pins_open(struct inode *inode, struct file *file) 686{ 687 return single_open(file, pinmux_pins_show, inode->i_private); 688} 689 690static const struct file_operations pinmux_functions_ops = { 691 .open = pinmux_functions_open, 692 .read = seq_read, 693 .llseek = seq_lseek, 694 .release = single_release, 695}; 696 697static const struct file_operations pinmux_pins_ops = { 698 .open = pinmux_pins_open, 699 .read = seq_read, 700 .llseek = seq_lseek, 701 .release = single_release, 702}; 703 704void pinmux_init_device_debugfs(struct dentry *devroot, 705 struct pinctrl_dev *pctldev) 706{ 707 debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO, 708 devroot, pctldev, &pinmux_functions_ops); 709 debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO, 710 devroot, pctldev, &pinmux_pins_ops); 711} 712 713#endif /* CONFIG_DEBUG_FS */ 714