1#include <linux/kernel.h> 2#include <linux/module.h> 3#include <linux/interrupt.h> 4#include <linux/irq.h> 5#include <linux/spinlock.h> 6#include <linux/device.h> 7#include <linux/err.h> 8#include <linux/debugfs.h> 9#include <linux/seq_file.h> 10#include <linux/gpio.h> 11#include <linux/of_gpio.h> 12#include <linux/idr.h> 13#include <linux/slab.h> 14 15#define CREATE_TRACE_POINTS 16#include <trace/events/gpio.h> 17 18/* Optional implementation infrastructure for GPIO interfaces. 19 * 20 * Platforms may want to use this if they tend to use very many GPIOs 21 * that aren't part of a System-On-Chip core; or across I2C/SPI/etc. 22 * 23 * When kernel footprint or instruction count is an issue, simpler 24 * implementations may be preferred. The GPIO programming interface 25 * allows for inlining speed-critical get/set operations for common 26 * cases, so that access to SOC-integrated GPIOs can sometimes cost 27 * only an instruction or two per bit. 28 */ 29 30 31/* When debugging, extend minimal trust to callers and platform code. 32 * Also emit diagnostic messages that may help initial bringup, when 33 * board setup or driver bugs are most common. 34 * 35 * Otherwise, minimize overhead in what may be bitbanging codepaths. 36 */ 37#ifdef DEBUG 38#define extra_checks 1 39#else 40#define extra_checks 0 41#endif 42 43/* gpio_lock prevents conflicts during gpio_desc[] table updates. 44 * While any GPIO is requested, its gpio_chip is not removable; 45 * each GPIO's "requested" flag serves as a lock and refcount. 46 */ 47static DEFINE_SPINLOCK(gpio_lock); 48 49struct gpio_desc { 50 struct gpio_chip *chip; 51 unsigned long flags; 52/* flag symbols are bit numbers */ 53#define FLAG_REQUESTED 0 54#define FLAG_IS_OUT 1 55#define FLAG_RESERVED 2 56#define FLAG_EXPORT 3 /* protected by sysfs_lock */ 57#define FLAG_SYSFS 4 /* exported via /sys/class/gpio/control */ 58#define FLAG_TRIG_FALL 5 /* trigger on falling edge */ 59#define FLAG_TRIG_RISE 6 /* trigger on rising edge */ 60#define FLAG_ACTIVE_LOW 7 /* sysfs value has active low */ 61 62#define ID_SHIFT 16 /* add new flags before this one */ 63 64#define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1) 65#define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE)) 66 67#ifdef CONFIG_DEBUG_FS 68 const char *label; 69#endif 70}; 71static struct gpio_desc gpio_desc[ARCH_NR_GPIOS]; 72 73#ifdef CONFIG_GPIO_SYSFS 74static DEFINE_IDR(dirent_idr); 75#endif 76 77static inline void desc_set_label(struct gpio_desc *d, const char *label) 78{ 79#ifdef CONFIG_DEBUG_FS 80 d->label = label; 81#endif 82} 83 84/* Warn when drivers omit gpio_request() calls -- legal but ill-advised 85 * when setting direction, and otherwise illegal. Until board setup code 86 * and drivers use explicit requests everywhere (which won't happen when 87 * those calls have no teeth) we can't avoid autorequesting. This nag 88 * message should motivate switching to explicit requests... so should 89 * the weaker cleanup after faults, compared to gpio_request(). 90 * 91 * NOTE: the autorequest mechanism is going away; at this point it's 92 * only "legal" in the sense that (old) code using it won't break yet, 93 * but instead only triggers a WARN() stack dump. 94 */ 95static int gpio_ensure_requested(struct gpio_desc *desc, unsigned offset) 96{ 97 const struct gpio_chip *chip = desc->chip; 98 const int gpio = chip->base + offset; 99 100 if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0, 101 "autorequest GPIO-%d\n", gpio)) { 102 if (!try_module_get(chip->owner)) { 103 pr_err("GPIO-%d: module can't be gotten \n", gpio); 104 clear_bit(FLAG_REQUESTED, &desc->flags); 105 /* lose */ 106 return -EIO; 107 } 108 desc_set_label(desc, "[auto]"); 109 /* caller must chip->request() w/o spinlock */ 110 if (chip->request) 111 return 1; 112 } 113 return 0; 114} 115 116/* caller holds gpio_lock *OR* gpio is marked as requested */ 117struct gpio_chip *gpio_to_chip(unsigned gpio) 118{ 119 return gpio_desc[gpio].chip; 120} 121 122/* dynamic allocation of GPIOs, e.g. on a hotplugged device */ 123static int gpiochip_find_base(int ngpio) 124{ 125 int i; 126 int spare = 0; 127 int base = -ENOSPC; 128 129 for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) { 130 struct gpio_desc *desc = &gpio_desc[i]; 131 struct gpio_chip *chip = desc->chip; 132 133 if (!chip && !test_bit(FLAG_RESERVED, &desc->flags)) { 134 spare++; 135 if (spare == ngpio) { 136 base = i; 137 break; 138 } 139 } else { 140 spare = 0; 141 if (chip) 142 i -= chip->ngpio - 1; 143 } 144 } 145 146 if (gpio_is_valid(base)) 147 pr_debug("%s: found new base at %d\n", __func__, base); 148 return base; 149} 150 151/** 152 * gpiochip_reserve() - reserve range of gpios to use with platform code only 153 * @start: starting gpio number 154 * @ngpio: number of gpios to reserve 155 * Context: platform init, potentially before irqs or kmalloc will work 156 * 157 * Returns a negative errno if any gpio within the range is already reserved 158 * or registered, else returns zero as a success code. Use this function 159 * to mark a range of gpios as unavailable for dynamic gpio number allocation, 160 * for example because its driver support is not yet loaded. 161 */ 162int __init gpiochip_reserve(int start, int ngpio) 163{ 164 int ret = 0; 165 unsigned long flags; 166 int i; 167 168 if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio - 1)) 169 return -EINVAL; 170 171 spin_lock_irqsave(&gpio_lock, flags); 172 173 for (i = start; i < start + ngpio; i++) { 174 struct gpio_desc *desc = &gpio_desc[i]; 175 176 if (desc->chip || test_bit(FLAG_RESERVED, &desc->flags)) { 177 ret = -EBUSY; 178 goto err; 179 } 180 181 set_bit(FLAG_RESERVED, &desc->flags); 182 } 183 184 pr_debug("%s: reserved gpios from %d to %d\n", 185 __func__, start, start + ngpio - 1); 186err: 187 spin_unlock_irqrestore(&gpio_lock, flags); 188 189 return ret; 190} 191 192#ifdef CONFIG_GPIO_SYSFS 193 194/* lock protects against unexport_gpio() being called while 195 * sysfs files are active. 196 */ 197static DEFINE_MUTEX(sysfs_lock); 198 199/* 200 * /sys/class/gpio/gpioN... only for GPIOs that are exported 201 * /direction 202 * * MAY BE OMITTED if kernel won't allow direction changes 203 * * is read/write as "in" or "out" 204 * * may also be written as "high" or "low", initializing 205 * output value as specified ("out" implies "low") 206 * /value 207 * * always readable, subject to hardware behavior 208 * * may be writable, as zero/nonzero 209 * /edge 210 * * configures behavior of poll(2) on /value 211 * * available only if pin can generate IRQs on input 212 * * is read/write as "none", "falling", "rising", or "both" 213 * /active_low 214 * * configures polarity of /value 215 * * is read/write as zero/nonzero 216 * * also affects existing and subsequent "falling" and "rising" 217 * /edge configuration 218 */ 219 220static ssize_t gpio_direction_show(struct device *dev, 221 struct device_attribute *attr, char *buf) 222{ 223 const struct gpio_desc *desc = dev_get_drvdata(dev); 224 ssize_t status; 225 226 mutex_lock(&sysfs_lock); 227 228 if (!test_bit(FLAG_EXPORT, &desc->flags)) 229 status = -EIO; 230 else 231 status = sprintf(buf, "%s\n", 232 test_bit(FLAG_IS_OUT, &desc->flags) 233 ? "out" : "in"); 234 235 mutex_unlock(&sysfs_lock); 236 return status; 237} 238 239static ssize_t gpio_direction_store(struct device *dev, 240 struct device_attribute *attr, const char *buf, size_t size) 241{ 242 const struct gpio_desc *desc = dev_get_drvdata(dev); 243 unsigned gpio = desc - gpio_desc; 244 ssize_t status; 245 246 mutex_lock(&sysfs_lock); 247 248 if (!test_bit(FLAG_EXPORT, &desc->flags)) 249 status = -EIO; 250 else if (sysfs_streq(buf, "high")) 251 status = gpio_direction_output(gpio, 1); 252 else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low")) 253 status = gpio_direction_output(gpio, 0); 254 else if (sysfs_streq(buf, "in")) 255 status = gpio_direction_input(gpio); 256 else 257 status = -EINVAL; 258 259 mutex_unlock(&sysfs_lock); 260 return status ? : size; 261} 262 263static /* const */ DEVICE_ATTR(direction, 0644, 264 gpio_direction_show, gpio_direction_store); 265 266static ssize_t gpio_value_show(struct device *dev, 267 struct device_attribute *attr, char *buf) 268{ 269 const struct gpio_desc *desc = dev_get_drvdata(dev); 270 unsigned gpio = desc - gpio_desc; 271 ssize_t status; 272 273 mutex_lock(&sysfs_lock); 274 275 if (!test_bit(FLAG_EXPORT, &desc->flags)) { 276 status = -EIO; 277 } else { 278 int value; 279 280 value = !!gpio_get_value_cansleep(gpio); 281 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 282 value = !value; 283 284 status = sprintf(buf, "%d\n", value); 285 } 286 287 mutex_unlock(&sysfs_lock); 288 return status; 289} 290 291static ssize_t gpio_value_store(struct device *dev, 292 struct device_attribute *attr, const char *buf, size_t size) 293{ 294 const struct gpio_desc *desc = dev_get_drvdata(dev); 295 unsigned gpio = desc - gpio_desc; 296 ssize_t status; 297 298 mutex_lock(&sysfs_lock); 299 300 if (!test_bit(FLAG_EXPORT, &desc->flags)) 301 status = -EIO; 302 else if (!test_bit(FLAG_IS_OUT, &desc->flags)) 303 status = -EPERM; 304 else { 305 long value; 306 307 status = strict_strtol(buf, 0, &value); 308 if (status == 0) { 309 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 310 value = !value; 311 gpio_set_value_cansleep(gpio, value != 0); 312 status = size; 313 } 314 } 315 316 mutex_unlock(&sysfs_lock); 317 return status; 318} 319 320static const DEVICE_ATTR(value, 0644, 321 gpio_value_show, gpio_value_store); 322 323static irqreturn_t gpio_sysfs_irq(int irq, void *priv) 324{ 325 struct sysfs_dirent *value_sd = priv; 326 327 sysfs_notify_dirent(value_sd); 328 return IRQ_HANDLED; 329} 330 331static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev, 332 unsigned long gpio_flags) 333{ 334 struct sysfs_dirent *value_sd; 335 unsigned long irq_flags; 336 int ret, irq, id; 337 338 if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags) 339 return 0; 340 341 irq = gpio_to_irq(desc - gpio_desc); 342 if (irq < 0) 343 return -EIO; 344 345 id = desc->flags >> ID_SHIFT; 346 value_sd = idr_find(&dirent_idr, id); 347 if (value_sd) 348 free_irq(irq, value_sd); 349 350 desc->flags &= ~GPIO_TRIGGER_MASK; 351 352 if (!gpio_flags) { 353 ret = 0; 354 goto free_id; 355 } 356 357 irq_flags = IRQF_SHARED; 358 if (test_bit(FLAG_TRIG_FALL, &gpio_flags)) 359 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? 360 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; 361 if (test_bit(FLAG_TRIG_RISE, &gpio_flags)) 362 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? 363 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; 364 365 if (!value_sd) { 366 value_sd = sysfs_get_dirent(dev->kobj.sd, NULL, "value"); 367 if (!value_sd) { 368 ret = -ENODEV; 369 goto err_out; 370 } 371 372 do { 373 ret = -ENOMEM; 374 if (idr_pre_get(&dirent_idr, GFP_KERNEL)) 375 ret = idr_get_new_above(&dirent_idr, value_sd, 376 1, &id); 377 } while (ret == -EAGAIN); 378 379 if (ret) 380 goto free_sd; 381 382 desc->flags &= GPIO_FLAGS_MASK; 383 desc->flags |= (unsigned long)id << ID_SHIFT; 384 385 if (desc->flags >> ID_SHIFT != id) { 386 ret = -ERANGE; 387 goto free_id; 388 } 389 } 390 391 ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags, 392 "gpiolib", value_sd); 393 if (ret < 0) 394 goto free_id; 395 396 desc->flags |= gpio_flags; 397 return 0; 398 399free_id: 400 idr_remove(&dirent_idr, id); 401 desc->flags &= GPIO_FLAGS_MASK; 402free_sd: 403 if (value_sd) 404 sysfs_put(value_sd); 405err_out: 406 return ret; 407} 408 409static const struct { 410 const char *name; 411 unsigned long flags; 412} trigger_types[] = { 413 { "none", 0 }, 414 { "falling", BIT(FLAG_TRIG_FALL) }, 415 { "rising", BIT(FLAG_TRIG_RISE) }, 416 { "both", BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) }, 417}; 418 419static ssize_t gpio_edge_show(struct device *dev, 420 struct device_attribute *attr, char *buf) 421{ 422 const struct gpio_desc *desc = dev_get_drvdata(dev); 423 ssize_t status; 424 425 mutex_lock(&sysfs_lock); 426 427 if (!test_bit(FLAG_EXPORT, &desc->flags)) 428 status = -EIO; 429 else { 430 int i; 431 432 status = 0; 433 for (i = 0; i < ARRAY_SIZE(trigger_types); i++) 434 if ((desc->flags & GPIO_TRIGGER_MASK) 435 == trigger_types[i].flags) { 436 status = sprintf(buf, "%s\n", 437 trigger_types[i].name); 438 break; 439 } 440 } 441 442 mutex_unlock(&sysfs_lock); 443 return status; 444} 445 446static ssize_t gpio_edge_store(struct device *dev, 447 struct device_attribute *attr, const char *buf, size_t size) 448{ 449 struct gpio_desc *desc = dev_get_drvdata(dev); 450 ssize_t status; 451 int i; 452 453 for (i = 0; i < ARRAY_SIZE(trigger_types); i++) 454 if (sysfs_streq(trigger_types[i].name, buf)) 455 goto found; 456 return -EINVAL; 457 458found: 459 mutex_lock(&sysfs_lock); 460 461 if (!test_bit(FLAG_EXPORT, &desc->flags)) 462 status = -EIO; 463 else { 464 status = gpio_setup_irq(desc, dev, trigger_types[i].flags); 465 if (!status) 466 status = size; 467 } 468 469 mutex_unlock(&sysfs_lock); 470 471 return status; 472} 473 474static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store); 475 476static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev, 477 int value) 478{ 479 int status = 0; 480 481 if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value) 482 return 0; 483 484 if (value) 485 set_bit(FLAG_ACTIVE_LOW, &desc->flags); 486 else 487 clear_bit(FLAG_ACTIVE_LOW, &desc->flags); 488 489 /* reconfigure poll(2) support if enabled on one edge only */ 490 if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^ 491 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) { 492 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK; 493 494 gpio_setup_irq(desc, dev, 0); 495 status = gpio_setup_irq(desc, dev, trigger_flags); 496 } 497 498 return status; 499} 500 501static ssize_t gpio_active_low_show(struct device *dev, 502 struct device_attribute *attr, char *buf) 503{ 504 const struct gpio_desc *desc = dev_get_drvdata(dev); 505 ssize_t status; 506 507 mutex_lock(&sysfs_lock); 508 509 if (!test_bit(FLAG_EXPORT, &desc->flags)) 510 status = -EIO; 511 else 512 status = sprintf(buf, "%d\n", 513 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags)); 514 515 mutex_unlock(&sysfs_lock); 516 517 return status; 518} 519 520static ssize_t gpio_active_low_store(struct device *dev, 521 struct device_attribute *attr, const char *buf, size_t size) 522{ 523 struct gpio_desc *desc = dev_get_drvdata(dev); 524 ssize_t status; 525 526 mutex_lock(&sysfs_lock); 527 528 if (!test_bit(FLAG_EXPORT, &desc->flags)) { 529 status = -EIO; 530 } else { 531 long value; 532 533 status = strict_strtol(buf, 0, &value); 534 if (status == 0) 535 status = sysfs_set_active_low(desc, dev, value != 0); 536 } 537 538 mutex_unlock(&sysfs_lock); 539 540 return status ? : size; 541} 542 543static const DEVICE_ATTR(active_low, 0644, 544 gpio_active_low_show, gpio_active_low_store); 545 546static const struct attribute *gpio_attrs[] = { 547 &dev_attr_value.attr, 548 &dev_attr_active_low.attr, 549 NULL, 550}; 551 552static const struct attribute_group gpio_attr_group = { 553 .attrs = (struct attribute **) gpio_attrs, 554}; 555 556/* 557 * /sys/class/gpio/gpiochipN/ 558 * /base ... matching gpio_chip.base (N) 559 * /label ... matching gpio_chip.label 560 * /ngpio ... matching gpio_chip.ngpio 561 */ 562 563static ssize_t chip_base_show(struct device *dev, 564 struct device_attribute *attr, char *buf) 565{ 566 const struct gpio_chip *chip = dev_get_drvdata(dev); 567 568 return sprintf(buf, "%d\n", chip->base); 569} 570static DEVICE_ATTR(base, 0444, chip_base_show, NULL); 571 572static ssize_t chip_label_show(struct device *dev, 573 struct device_attribute *attr, char *buf) 574{ 575 const struct gpio_chip *chip = dev_get_drvdata(dev); 576 577 return sprintf(buf, "%s\n", chip->label ? : ""); 578} 579static DEVICE_ATTR(label, 0444, chip_label_show, NULL); 580 581static ssize_t chip_ngpio_show(struct device *dev, 582 struct device_attribute *attr, char *buf) 583{ 584 const struct gpio_chip *chip = dev_get_drvdata(dev); 585 586 return sprintf(buf, "%u\n", chip->ngpio); 587} 588static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL); 589 590static const struct attribute *gpiochip_attrs[] = { 591 &dev_attr_base.attr, 592 &dev_attr_label.attr, 593 &dev_attr_ngpio.attr, 594 NULL, 595}; 596 597static const struct attribute_group gpiochip_attr_group = { 598 .attrs = (struct attribute **) gpiochip_attrs, 599}; 600 601/* 602 * /sys/class/gpio/export ... write-only 603 * integer N ... number of GPIO to export (full access) 604 * /sys/class/gpio/unexport ... write-only 605 * integer N ... number of GPIO to unexport 606 */ 607static ssize_t export_store(struct class *class, 608 struct class_attribute *attr, 609 const char *buf, size_t len) 610{ 611 long gpio; 612 int status; 613 614 status = strict_strtol(buf, 0, &gpio); 615 if (status < 0) 616 goto done; 617 618 /* No extra locking here; FLAG_SYSFS just signifies that the 619 * request and export were done by on behalf of userspace, so 620 * they may be undone on its behalf too. 621 */ 622 623 status = gpio_request(gpio, "sysfs"); 624 if (status < 0) 625 goto done; 626 627 status = gpio_export(gpio, true); 628 if (status < 0) 629 gpio_free(gpio); 630 else 631 set_bit(FLAG_SYSFS, &gpio_desc[gpio].flags); 632 633done: 634 if (status) 635 pr_debug("%s: status %d\n", __func__, status); 636 return status ? : len; 637} 638 639static ssize_t unexport_store(struct class *class, 640 struct class_attribute *attr, 641 const char *buf, size_t len) 642{ 643 long gpio; 644 int status; 645 646 status = strict_strtol(buf, 0, &gpio); 647 if (status < 0) 648 goto done; 649 650 status = -EINVAL; 651 652 /* reject bogus commands (gpio_unexport ignores them) */ 653 if (!gpio_is_valid(gpio)) 654 goto done; 655 656 /* No extra locking here; FLAG_SYSFS just signifies that the 657 * request and export were done by on behalf of userspace, so 658 * they may be undone on its behalf too. 659 */ 660 if (test_and_clear_bit(FLAG_SYSFS, &gpio_desc[gpio].flags)) { 661 status = 0; 662 gpio_free(gpio); 663 } 664done: 665 if (status) 666 pr_debug("%s: status %d\n", __func__, status); 667 return status ? : len; 668} 669 670static struct class_attribute gpio_class_attrs[] = { 671 __ATTR(export, 0200, NULL, export_store), 672 __ATTR(unexport, 0200, NULL, unexport_store), 673 __ATTR_NULL, 674}; 675 676static struct class gpio_class = { 677 .name = "gpio", 678 .owner = THIS_MODULE, 679 680 .class_attrs = gpio_class_attrs, 681}; 682 683 684/** 685 * gpio_export - export a GPIO through sysfs 686 * @gpio: gpio to make available, already requested 687 * @direction_may_change: true if userspace may change gpio direction 688 * Context: arch_initcall or later 689 * 690 * When drivers want to make a GPIO accessible to userspace after they 691 * have requested it -- perhaps while debugging, or as part of their 692 * public interface -- they may use this routine. If the GPIO can 693 * change direction (some can't) and the caller allows it, userspace 694 * will see "direction" sysfs attribute which may be used to change 695 * the gpio's direction. A "value" attribute will always be provided. 696 * 697 * Returns zero on success, else an error. 698 */ 699int gpio_export(unsigned gpio, bool direction_may_change) 700{ 701 unsigned long flags; 702 struct gpio_desc *desc; 703 int status = -EINVAL; 704 const char *ioname = NULL; 705 706 /* can't export until sysfs is available ... */ 707 if (!gpio_class.p) { 708 pr_debug("%s: called too early!\n", __func__); 709 return -ENOENT; 710 } 711 712 if (!gpio_is_valid(gpio)) 713 goto done; 714 715 mutex_lock(&sysfs_lock); 716 717 spin_lock_irqsave(&gpio_lock, flags); 718 desc = &gpio_desc[gpio]; 719 if (test_bit(FLAG_REQUESTED, &desc->flags) 720 && !test_bit(FLAG_EXPORT, &desc->flags)) { 721 status = 0; 722 if (!desc->chip->direction_input 723 || !desc->chip->direction_output) 724 direction_may_change = false; 725 } 726 spin_unlock_irqrestore(&gpio_lock, flags); 727 728 if (desc->chip->names && desc->chip->names[gpio - desc->chip->base]) 729 ioname = desc->chip->names[gpio - desc->chip->base]; 730 731 if (status == 0) { 732 struct device *dev; 733 734 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0), 735 desc, ioname ? ioname : "gpio%u", gpio); 736 if (!IS_ERR(dev)) { 737 status = sysfs_create_group(&dev->kobj, 738 &gpio_attr_group); 739 740 if (!status && direction_may_change) 741 status = device_create_file(dev, 742 &dev_attr_direction); 743 744 if (!status && gpio_to_irq(gpio) >= 0 745 && (direction_may_change 746 || !test_bit(FLAG_IS_OUT, 747 &desc->flags))) 748 status = device_create_file(dev, 749 &dev_attr_edge); 750 751 if (status != 0) 752 device_unregister(dev); 753 } else 754 status = PTR_ERR(dev); 755 if (status == 0) 756 set_bit(FLAG_EXPORT, &desc->flags); 757 } 758 759 mutex_unlock(&sysfs_lock); 760 761done: 762 if (status) 763 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status); 764 765 return status; 766} 767EXPORT_SYMBOL_GPL(gpio_export); 768 769static int match_export(struct device *dev, void *data) 770{ 771 return dev_get_drvdata(dev) == data; 772} 773 774/** 775 * gpio_export_link - create a sysfs link to an exported GPIO node 776 * @dev: device under which to create symlink 777 * @name: name of the symlink 778 * @gpio: gpio to create symlink to, already exported 779 * 780 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN 781 * node. Caller is responsible for unlinking. 782 * 783 * Returns zero on success, else an error. 784 */ 785int gpio_export_link(struct device *dev, const char *name, unsigned gpio) 786{ 787 struct gpio_desc *desc; 788 int status = -EINVAL; 789 790 if (!gpio_is_valid(gpio)) 791 goto done; 792 793 mutex_lock(&sysfs_lock); 794 795 desc = &gpio_desc[gpio]; 796 797 if (test_bit(FLAG_EXPORT, &desc->flags)) { 798 struct device *tdev; 799 800 tdev = class_find_device(&gpio_class, NULL, desc, match_export); 801 if (tdev != NULL) { 802 status = sysfs_create_link(&dev->kobj, &tdev->kobj, 803 name); 804 } else { 805 status = -ENODEV; 806 } 807 } 808 809 mutex_unlock(&sysfs_lock); 810 811done: 812 if (status) 813 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status); 814 815 return status; 816} 817EXPORT_SYMBOL_GPL(gpio_export_link); 818 819 820/** 821 * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value 822 * @gpio: gpio to change 823 * @value: non-zero to use active low, i.e. inverted values 824 * 825 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute. 826 * The GPIO does not have to be exported yet. If poll(2) support has 827 * been enabled for either rising or falling edge, it will be 828 * reconfigured to follow the new polarity. 829 * 830 * Returns zero on success, else an error. 831 */ 832int gpio_sysfs_set_active_low(unsigned gpio, int value) 833{ 834 struct gpio_desc *desc; 835 struct device *dev = NULL; 836 int status = -EINVAL; 837 838 if (!gpio_is_valid(gpio)) 839 goto done; 840 841 mutex_lock(&sysfs_lock); 842 843 desc = &gpio_desc[gpio]; 844 845 if (test_bit(FLAG_EXPORT, &desc->flags)) { 846 dev = class_find_device(&gpio_class, NULL, desc, match_export); 847 if (dev == NULL) { 848 status = -ENODEV; 849 goto unlock; 850 } 851 } 852 853 status = sysfs_set_active_low(desc, dev, value); 854 855unlock: 856 mutex_unlock(&sysfs_lock); 857 858done: 859 if (status) 860 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status); 861 862 return status; 863} 864EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low); 865 866/** 867 * gpio_unexport - reverse effect of gpio_export() 868 * @gpio: gpio to make unavailable 869 * 870 * This is implicit on gpio_free(). 871 */ 872void gpio_unexport(unsigned gpio) 873{ 874 struct gpio_desc *desc; 875 int status = 0; 876 877 if (!gpio_is_valid(gpio)) { 878 status = -EINVAL; 879 goto done; 880 } 881 882 mutex_lock(&sysfs_lock); 883 884 desc = &gpio_desc[gpio]; 885 886 if (test_bit(FLAG_EXPORT, &desc->flags)) { 887 struct device *dev = NULL; 888 889 dev = class_find_device(&gpio_class, NULL, desc, match_export); 890 if (dev) { 891 gpio_setup_irq(desc, dev, 0); 892 clear_bit(FLAG_EXPORT, &desc->flags); 893 put_device(dev); 894 device_unregister(dev); 895 } else 896 status = -ENODEV; 897 } 898 899 mutex_unlock(&sysfs_lock); 900done: 901 if (status) 902 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status); 903} 904EXPORT_SYMBOL_GPL(gpio_unexport); 905 906static int gpiochip_export(struct gpio_chip *chip) 907{ 908 int status; 909 struct device *dev; 910 911 /* Many systems register gpio chips for SOC support very early, 912 * before driver model support is available. In those cases we 913 * export this later, in gpiolib_sysfs_init() ... here we just 914 * verify that _some_ field of gpio_class got initialized. 915 */ 916 if (!gpio_class.p) 917 return 0; 918 919 /* use chip->base for the ID; it's already known to be unique */ 920 mutex_lock(&sysfs_lock); 921 dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip, 922 "gpiochip%d", chip->base); 923 if (!IS_ERR(dev)) { 924 status = sysfs_create_group(&dev->kobj, 925 &gpiochip_attr_group); 926 } else 927 status = PTR_ERR(dev); 928 chip->exported = (status == 0); 929 mutex_unlock(&sysfs_lock); 930 931 if (status) { 932 unsigned long flags; 933 unsigned gpio; 934 935 spin_lock_irqsave(&gpio_lock, flags); 936 gpio = chip->base; 937 while (gpio_desc[gpio].chip == chip) 938 gpio_desc[gpio++].chip = NULL; 939 spin_unlock_irqrestore(&gpio_lock, flags); 940 941 pr_debug("%s: chip %s status %d\n", __func__, 942 chip->label, status); 943 } 944 945 return status; 946} 947 948static void gpiochip_unexport(struct gpio_chip *chip) 949{ 950 int status; 951 struct device *dev; 952 953 mutex_lock(&sysfs_lock); 954 dev = class_find_device(&gpio_class, NULL, chip, match_export); 955 if (dev) { 956 put_device(dev); 957 device_unregister(dev); 958 chip->exported = 0; 959 status = 0; 960 } else 961 status = -ENODEV; 962 mutex_unlock(&sysfs_lock); 963 964 if (status) 965 pr_debug("%s: chip %s status %d\n", __func__, 966 chip->label, status); 967} 968 969static int __init gpiolib_sysfs_init(void) 970{ 971 int status; 972 unsigned long flags; 973 unsigned gpio; 974 975 status = class_register(&gpio_class); 976 if (status < 0) 977 return status; 978 979 /* Scan and register the gpio_chips which registered very 980 * early (e.g. before the class_register above was called). 981 * 982 * We run before arch_initcall() so chip->dev nodes can have 983 * registered, and so arch_initcall() can always gpio_export(). 984 */ 985 spin_lock_irqsave(&gpio_lock, flags); 986 for (gpio = 0; gpio < ARCH_NR_GPIOS; gpio++) { 987 struct gpio_chip *chip; 988 989 chip = gpio_desc[gpio].chip; 990 if (!chip || chip->exported) 991 continue; 992 993 spin_unlock_irqrestore(&gpio_lock, flags); 994 status = gpiochip_export(chip); 995 spin_lock_irqsave(&gpio_lock, flags); 996 } 997 spin_unlock_irqrestore(&gpio_lock, flags); 998 999 1000 return status; 1001} 1002postcore_initcall(gpiolib_sysfs_init); 1003 1004#else 1005static inline int gpiochip_export(struct gpio_chip *chip) 1006{ 1007 return 0; 1008} 1009 1010static inline void gpiochip_unexport(struct gpio_chip *chip) 1011{ 1012} 1013 1014#endif /* CONFIG_GPIO_SYSFS */ 1015 1016/** 1017 * gpiochip_add() - register a gpio_chip 1018 * @chip: the chip to register, with chip->base initialized 1019 * Context: potentially before irqs or kmalloc will work 1020 * 1021 * Returns a negative errno if the chip can't be registered, such as 1022 * because the chip->base is invalid or already associated with a 1023 * different chip. Otherwise it returns zero as a success code. 1024 * 1025 * When gpiochip_add() is called very early during boot, so that GPIOs 1026 * can be freely used, the chip->dev device must be registered before 1027 * the gpio framework's arch_initcall(). Otherwise sysfs initialization 1028 * for GPIOs will fail rudely. 1029 * 1030 * If chip->base is negative, this requests dynamic assignment of 1031 * a range of valid GPIOs. 1032 */ 1033int gpiochip_add(struct gpio_chip *chip) 1034{ 1035 unsigned long flags; 1036 int status = 0; 1037 unsigned id; 1038 int base = chip->base; 1039 1040 if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1)) 1041 && base >= 0) { 1042 status = -EINVAL; 1043 goto fail; 1044 } 1045 1046 spin_lock_irqsave(&gpio_lock, flags); 1047 1048 if (base < 0) { 1049 base = gpiochip_find_base(chip->ngpio); 1050 if (base < 0) { 1051 status = base; 1052 goto unlock; 1053 } 1054 chip->base = base; 1055 } 1056 1057 /* these GPIO numbers must not be managed by another gpio_chip */ 1058 for (id = base; id < base + chip->ngpio; id++) { 1059 if (gpio_desc[id].chip != NULL) { 1060 status = -EBUSY; 1061 break; 1062 } 1063 } 1064 if (status == 0) { 1065 for (id = base; id < base + chip->ngpio; id++) { 1066 gpio_desc[id].chip = chip; 1067 1068 /* REVISIT: most hardware initializes GPIOs as 1069 * inputs (often with pullups enabled) so power 1070 * usage is minimized. Linux code should set the 1071 * gpio direction first thing; but until it does, 1072 * we may expose the wrong direction in sysfs. 1073 */ 1074 gpio_desc[id].flags = !chip->direction_input 1075 ? (1 << FLAG_IS_OUT) 1076 : 0; 1077 } 1078 } 1079 1080 of_gpiochip_add(chip); 1081 1082unlock: 1083 spin_unlock_irqrestore(&gpio_lock, flags); 1084 1085 if (status) 1086 goto fail; 1087 1088 status = gpiochip_export(chip); 1089 if (status) 1090 goto fail; 1091 1092 pr_info("gpiochip_add: registered GPIOs %d to %d on device: %s\n", 1093 chip->base, chip->base + chip->ngpio - 1, 1094 chip->label ? : "generic"); 1095 1096 return 0; 1097fail: 1098 /* failures here can mean systems won't boot... */ 1099 pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n", 1100 chip->base, chip->base + chip->ngpio - 1, 1101 chip->label ? : "generic"); 1102 return status; 1103} 1104EXPORT_SYMBOL_GPL(gpiochip_add); 1105 1106/** 1107 * gpiochip_remove() - unregister a gpio_chip 1108 * @chip: the chip to unregister 1109 * 1110 * A gpio_chip with any GPIOs still requested may not be removed. 1111 */ 1112int gpiochip_remove(struct gpio_chip *chip) 1113{ 1114 unsigned long flags; 1115 int status = 0; 1116 unsigned id; 1117 1118 spin_lock_irqsave(&gpio_lock, flags); 1119 1120 of_gpiochip_remove(chip); 1121 1122 for (id = chip->base; id < chip->base + chip->ngpio; id++) { 1123 if (test_bit(FLAG_REQUESTED, &gpio_desc[id].flags)) { 1124 status = -EBUSY; 1125 break; 1126 } 1127 } 1128 if (status == 0) { 1129 for (id = chip->base; id < chip->base + chip->ngpio; id++) 1130 gpio_desc[id].chip = NULL; 1131 } 1132 1133 spin_unlock_irqrestore(&gpio_lock, flags); 1134 1135 if (status == 0) 1136 gpiochip_unexport(chip); 1137 1138 return status; 1139} 1140EXPORT_SYMBOL_GPL(gpiochip_remove); 1141 1142/** 1143 * gpiochip_find() - iterator for locating a specific gpio_chip 1144 * @data: data to pass to match function 1145 * @callback: Callback function to check gpio_chip 1146 * 1147 * Similar to bus_find_device. It returns a reference to a gpio_chip as 1148 * determined by a user supplied @match callback. The callback should return 1149 * 0 if the device doesn't match and non-zero if it does. If the callback is 1150 * non-zero, this function will return to the caller and not iterate over any 1151 * more gpio_chips. 1152 */ 1153struct gpio_chip *gpiochip_find(void *data, 1154 int (*match)(struct gpio_chip *chip, void *data)) 1155{ 1156 struct gpio_chip *chip = NULL; 1157 unsigned long flags; 1158 int i; 1159 1160 spin_lock_irqsave(&gpio_lock, flags); 1161 for (i = 0; i < ARCH_NR_GPIOS; i++) { 1162 if (!gpio_desc[i].chip) 1163 continue; 1164 1165 if (match(gpio_desc[i].chip, data)) { 1166 chip = gpio_desc[i].chip; 1167 break; 1168 } 1169 } 1170 spin_unlock_irqrestore(&gpio_lock, flags); 1171 1172 return chip; 1173} 1174EXPORT_SYMBOL_GPL(gpiochip_find); 1175 1176/* These "optional" allocation calls help prevent drivers from stomping 1177 * on each other, and help provide better diagnostics in debugfs. 1178 * They're called even less than the "set direction" calls. 1179 */ 1180int gpio_request(unsigned gpio, const char *label) 1181{ 1182 struct gpio_desc *desc; 1183 struct gpio_chip *chip; 1184 int status = -EINVAL; 1185 unsigned long flags; 1186 1187 spin_lock_irqsave(&gpio_lock, flags); 1188 1189 if (!gpio_is_valid(gpio)) 1190 goto done; 1191 desc = &gpio_desc[gpio]; 1192 chip = desc->chip; 1193 if (chip == NULL) 1194 goto done; 1195 1196 if (!try_module_get(chip->owner)) 1197 goto done; 1198 1199 /* NOTE: gpio_request() can be called in early boot, 1200 * before IRQs are enabled, for non-sleeping (SOC) GPIOs. 1201 */ 1202 1203 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) { 1204 desc_set_label(desc, label ? : "?"); 1205 status = 0; 1206 } else { 1207 status = -EBUSY; 1208 module_put(chip->owner); 1209 goto done; 1210 } 1211 1212 if (chip->request) { 1213 /* chip->request may sleep */ 1214 spin_unlock_irqrestore(&gpio_lock, flags); 1215 status = chip->request(chip, gpio - chip->base); 1216 spin_lock_irqsave(&gpio_lock, flags); 1217 1218 if (status < 0) { 1219 desc_set_label(desc, NULL); 1220 module_put(chip->owner); 1221 clear_bit(FLAG_REQUESTED, &desc->flags); 1222 } 1223 } 1224 1225done: 1226 if (status) 1227 pr_debug("gpio_request: gpio-%d (%s) status %d\n", 1228 gpio, label ? : "?", status); 1229 spin_unlock_irqrestore(&gpio_lock, flags); 1230 return status; 1231} 1232EXPORT_SYMBOL_GPL(gpio_request); 1233 1234void gpio_free(unsigned gpio) 1235{ 1236 unsigned long flags; 1237 struct gpio_desc *desc; 1238 struct gpio_chip *chip; 1239 1240 might_sleep(); 1241 1242 if (!gpio_is_valid(gpio)) { 1243 WARN_ON(extra_checks); 1244 return; 1245 } 1246 1247 gpio_unexport(gpio); 1248 1249 spin_lock_irqsave(&gpio_lock, flags); 1250 1251 desc = &gpio_desc[gpio]; 1252 chip = desc->chip; 1253 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) { 1254 if (chip->free) { 1255 spin_unlock_irqrestore(&gpio_lock, flags); 1256 might_sleep_if(chip->can_sleep); 1257 chip->free(chip, gpio - chip->base); 1258 spin_lock_irqsave(&gpio_lock, flags); 1259 } 1260 desc_set_label(desc, NULL); 1261 module_put(desc->chip->owner); 1262 clear_bit(FLAG_ACTIVE_LOW, &desc->flags); 1263 clear_bit(FLAG_REQUESTED, &desc->flags); 1264 } else 1265 WARN_ON(extra_checks); 1266 1267 spin_unlock_irqrestore(&gpio_lock, flags); 1268} 1269EXPORT_SYMBOL_GPL(gpio_free); 1270 1271/** 1272 * gpio_request_one - request a single GPIO with initial configuration 1273 * @gpio: the GPIO number 1274 * @flags: GPIO configuration as specified by GPIOF_* 1275 * @label: a literal description string of this GPIO 1276 */ 1277int gpio_request_one(unsigned gpio, unsigned long flags, const char *label) 1278{ 1279 int err; 1280 1281 err = gpio_request(gpio, label); 1282 if (err) 1283 return err; 1284 1285 if (flags & GPIOF_DIR_IN) 1286 err = gpio_direction_input(gpio); 1287 else 1288 err = gpio_direction_output(gpio, 1289 (flags & GPIOF_INIT_HIGH) ? 1 : 0); 1290 1291 if (err) 1292 gpio_free(gpio); 1293 1294 return err; 1295} 1296EXPORT_SYMBOL_GPL(gpio_request_one); 1297 1298/** 1299 * gpio_request_array - request multiple GPIOs in a single call 1300 * @array: array of the 'struct gpio' 1301 * @num: how many GPIOs in the array 1302 */ 1303int gpio_request_array(const struct gpio *array, size_t num) 1304{ 1305 int i, err; 1306 1307 for (i = 0; i < num; i++, array++) { 1308 err = gpio_request_one(array->gpio, array->flags, array->label); 1309 if (err) 1310 goto err_free; 1311 } 1312 return 0; 1313 1314err_free: 1315 while (i--) 1316 gpio_free((--array)->gpio); 1317 return err; 1318} 1319EXPORT_SYMBOL_GPL(gpio_request_array); 1320 1321/** 1322 * gpio_free_array - release multiple GPIOs in a single call 1323 * @array: array of the 'struct gpio' 1324 * @num: how many GPIOs in the array 1325 */ 1326void gpio_free_array(const struct gpio *array, size_t num) 1327{ 1328 while (num--) 1329 gpio_free((array++)->gpio); 1330} 1331EXPORT_SYMBOL_GPL(gpio_free_array); 1332 1333/** 1334 * gpiochip_is_requested - return string iff signal was requested 1335 * @chip: controller managing the signal 1336 * @offset: of signal within controller's 0..(ngpio - 1) range 1337 * 1338 * Returns NULL if the GPIO is not currently requested, else a string. 1339 * If debugfs support is enabled, the string returned is the label passed 1340 * to gpio_request(); otherwise it is a meaningless constant. 1341 * 1342 * This function is for use by GPIO controller drivers. The label can 1343 * help with diagnostics, and knowing that the signal is used as a GPIO 1344 * can help avoid accidentally multiplexing it to another controller. 1345 */ 1346const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset) 1347{ 1348 unsigned gpio = chip->base + offset; 1349 1350 if (!gpio_is_valid(gpio) || gpio_desc[gpio].chip != chip) 1351 return NULL; 1352 if (test_bit(FLAG_REQUESTED, &gpio_desc[gpio].flags) == 0) 1353 return NULL; 1354#ifdef CONFIG_DEBUG_FS 1355 return gpio_desc[gpio].label; 1356#else 1357 return "?"; 1358#endif 1359} 1360EXPORT_SYMBOL_GPL(gpiochip_is_requested); 1361 1362 1363/* Drivers MUST set GPIO direction before making get/set calls. In 1364 * some cases this is done in early boot, before IRQs are enabled. 1365 * 1366 * As a rule these aren't called more than once (except for drivers 1367 * using the open-drain emulation idiom) so these are natural places 1368 * to accumulate extra debugging checks. Note that we can't (yet) 1369 * rely on gpio_request() having been called beforehand. 1370 */ 1371 1372int gpio_direction_input(unsigned gpio) 1373{ 1374 unsigned long flags; 1375 struct gpio_chip *chip; 1376 struct gpio_desc *desc = &gpio_desc[gpio]; 1377 int status = -EINVAL; 1378 1379 spin_lock_irqsave(&gpio_lock, flags); 1380 1381 if (!gpio_is_valid(gpio)) 1382 goto fail; 1383 chip = desc->chip; 1384 if (!chip || !chip->get || !chip->direction_input) 1385 goto fail; 1386 gpio -= chip->base; 1387 if (gpio >= chip->ngpio) 1388 goto fail; 1389 status = gpio_ensure_requested(desc, gpio); 1390 if (status < 0) 1391 goto fail; 1392 1393 /* now we know the gpio is valid and chip won't vanish */ 1394 1395 spin_unlock_irqrestore(&gpio_lock, flags); 1396 1397 might_sleep_if(chip->can_sleep); 1398 1399 if (status) { 1400 status = chip->request(chip, gpio); 1401 if (status < 0) { 1402 pr_debug("GPIO-%d: chip request fail, %d\n", 1403 chip->base + gpio, status); 1404 /* and it's not available to anyone else ... 1405 * gpio_request() is the fully clean solution. 1406 */ 1407 goto lose; 1408 } 1409 } 1410 1411 status = chip->direction_input(chip, gpio); 1412 if (status == 0) 1413 clear_bit(FLAG_IS_OUT, &desc->flags); 1414 1415 trace_gpio_direction(chip->base + gpio, 1, status); 1416lose: 1417 return status; 1418fail: 1419 spin_unlock_irqrestore(&gpio_lock, flags); 1420 if (status) 1421 pr_debug("%s: gpio-%d status %d\n", 1422 __func__, gpio, status); 1423 return status; 1424} 1425EXPORT_SYMBOL_GPL(gpio_direction_input); 1426 1427int gpio_direction_output(unsigned gpio, int value) 1428{ 1429 unsigned long flags; 1430 struct gpio_chip *chip; 1431 struct gpio_desc *desc = &gpio_desc[gpio]; 1432 int status = -EINVAL; 1433 1434 spin_lock_irqsave(&gpio_lock, flags); 1435 1436 if (!gpio_is_valid(gpio)) 1437 goto fail; 1438 chip = desc->chip; 1439 if (!chip || !chip->set || !chip->direction_output) 1440 goto fail; 1441 gpio -= chip->base; 1442 if (gpio >= chip->ngpio) 1443 goto fail; 1444 status = gpio_ensure_requested(desc, gpio); 1445 if (status < 0) 1446 goto fail; 1447 1448 /* now we know the gpio is valid and chip won't vanish */ 1449 1450 spin_unlock_irqrestore(&gpio_lock, flags); 1451 1452 might_sleep_if(chip->can_sleep); 1453 1454 if (status) { 1455 status = chip->request(chip, gpio); 1456 if (status < 0) { 1457 pr_debug("GPIO-%d: chip request fail, %d\n", 1458 chip->base + gpio, status); 1459 /* and it's not available to anyone else ... 1460 * gpio_request() is the fully clean solution. 1461 */ 1462 goto lose; 1463 } 1464 } 1465 1466 status = chip->direction_output(chip, gpio, value); 1467 if (status == 0) 1468 set_bit(FLAG_IS_OUT, &desc->flags); 1469 trace_gpio_value(chip->base + gpio, 0, value); 1470 trace_gpio_direction(chip->base + gpio, 0, status); 1471lose: 1472 return status; 1473fail: 1474 spin_unlock_irqrestore(&gpio_lock, flags); 1475 if (status) 1476 pr_debug("%s: gpio-%d status %d\n", 1477 __func__, gpio, status); 1478 return status; 1479} 1480EXPORT_SYMBOL_GPL(gpio_direction_output); 1481 1482/** 1483 * gpio_set_debounce - sets @debounce time for a @gpio 1484 * @gpio: the gpio to set debounce time 1485 * @debounce: debounce time is microseconds 1486 */ 1487int gpio_set_debounce(unsigned gpio, unsigned debounce) 1488{ 1489 unsigned long flags; 1490 struct gpio_chip *chip; 1491 struct gpio_desc *desc = &gpio_desc[gpio]; 1492 int status = -EINVAL; 1493 1494 spin_lock_irqsave(&gpio_lock, flags); 1495 1496 if (!gpio_is_valid(gpio)) 1497 goto fail; 1498 chip = desc->chip; 1499 if (!chip || !chip->set || !chip->set_debounce) 1500 goto fail; 1501 gpio -= chip->base; 1502 if (gpio >= chip->ngpio) 1503 goto fail; 1504 status = gpio_ensure_requested(desc, gpio); 1505 if (status < 0) 1506 goto fail; 1507 1508 /* now we know the gpio is valid and chip won't vanish */ 1509 1510 spin_unlock_irqrestore(&gpio_lock, flags); 1511 1512 might_sleep_if(chip->can_sleep); 1513 1514 return chip->set_debounce(chip, gpio, debounce); 1515 1516fail: 1517 spin_unlock_irqrestore(&gpio_lock, flags); 1518 if (status) 1519 pr_debug("%s: gpio-%d status %d\n", 1520 __func__, gpio, status); 1521 1522 return status; 1523} 1524EXPORT_SYMBOL_GPL(gpio_set_debounce); 1525 1526/* I/O calls are only valid after configuration completed; the relevant 1527 * "is this a valid GPIO" error checks should already have been done. 1528 * 1529 * "Get" operations are often inlinable as reading a pin value register, 1530 * and masking the relevant bit in that register. 1531 * 1532 * When "set" operations are inlinable, they involve writing that mask to 1533 * one register to set a low value, or a different register to set it high. 1534 * Otherwise locking is needed, so there may be little value to inlining. 1535 * 1536 *------------------------------------------------------------------------ 1537 * 1538 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers 1539 * have requested the GPIO. That can include implicit requesting by 1540 * a direction setting call. Marking a gpio as requested locks its chip 1541 * in memory, guaranteeing that these table lookups need no more locking 1542 * and that gpiochip_remove() will fail. 1543 * 1544 * REVISIT when debugging, consider adding some instrumentation to ensure 1545 * that the GPIO was actually requested. 1546 */ 1547 1548/** 1549 * __gpio_get_value() - return a gpio's value 1550 * @gpio: gpio whose value will be returned 1551 * Context: any 1552 * 1553 * This is used directly or indirectly to implement gpio_get_value(). 1554 * It returns the zero or nonzero value provided by the associated 1555 * gpio_chip.get() method; or zero if no such method is provided. 1556 */ 1557int __gpio_get_value(unsigned gpio) 1558{ 1559 struct gpio_chip *chip; 1560 int value; 1561 1562 chip = gpio_to_chip(gpio); 1563 WARN_ON(chip->can_sleep); 1564 value = chip->get ? chip->get(chip, gpio - chip->base) : 0; 1565 trace_gpio_value(gpio, 1, value); 1566 return value; 1567} 1568EXPORT_SYMBOL_GPL(__gpio_get_value); 1569 1570/** 1571 * __gpio_set_value() - assign a gpio's value 1572 * @gpio: gpio whose value will be assigned 1573 * @value: value to assign 1574 * Context: any 1575 * 1576 * This is used directly or indirectly to implement gpio_set_value(). 1577 * It invokes the associated gpio_chip.set() method. 1578 */ 1579void __gpio_set_value(unsigned gpio, int value) 1580{ 1581 struct gpio_chip *chip; 1582 1583 chip = gpio_to_chip(gpio); 1584 WARN_ON(chip->can_sleep); 1585 trace_gpio_value(gpio, 0, value); 1586 chip->set(chip, gpio - chip->base, value); 1587} 1588EXPORT_SYMBOL_GPL(__gpio_set_value); 1589 1590/** 1591 * __gpio_cansleep() - report whether gpio value access will sleep 1592 * @gpio: gpio in question 1593 * Context: any 1594 * 1595 * This is used directly or indirectly to implement gpio_cansleep(). It 1596 * returns nonzero if access reading or writing the GPIO value can sleep. 1597 */ 1598int __gpio_cansleep(unsigned gpio) 1599{ 1600 struct gpio_chip *chip; 1601 1602 /* only call this on GPIOs that are valid! */ 1603 chip = gpio_to_chip(gpio); 1604 1605 return chip->can_sleep; 1606} 1607EXPORT_SYMBOL_GPL(__gpio_cansleep); 1608 1609/** 1610 * __gpio_to_irq() - return the IRQ corresponding to a GPIO 1611 * @gpio: gpio whose IRQ will be returned (already requested) 1612 * Context: any 1613 * 1614 * This is used directly or indirectly to implement gpio_to_irq(). 1615 * It returns the number of the IRQ signaled by this (input) GPIO, 1616 * or a negative errno. 1617 */ 1618int __gpio_to_irq(unsigned gpio) 1619{ 1620 struct gpio_chip *chip; 1621 1622 chip = gpio_to_chip(gpio); 1623 return chip->to_irq ? chip->to_irq(chip, gpio - chip->base) : -ENXIO; 1624} 1625EXPORT_SYMBOL_GPL(__gpio_to_irq); 1626 1627 1628 1629/* There's no value in making it easy to inline GPIO calls that may sleep. 1630 * Common examples include ones connected to I2C or SPI chips. 1631 */ 1632 1633int gpio_get_value_cansleep(unsigned gpio) 1634{ 1635 struct gpio_chip *chip; 1636 int value; 1637 1638 might_sleep_if(extra_checks); 1639 chip = gpio_to_chip(gpio); 1640 value = chip->get ? chip->get(chip, gpio - chip->base) : 0; 1641 trace_gpio_value(gpio, 1, value); 1642 return value; 1643} 1644EXPORT_SYMBOL_GPL(gpio_get_value_cansleep); 1645 1646void gpio_set_value_cansleep(unsigned gpio, int value) 1647{ 1648 struct gpio_chip *chip; 1649 1650 might_sleep_if(extra_checks); 1651 chip = gpio_to_chip(gpio); 1652 trace_gpio_value(gpio, 0, value); 1653 chip->set(chip, gpio - chip->base, value); 1654} 1655EXPORT_SYMBOL_GPL(gpio_set_value_cansleep); 1656 1657 1658#ifdef CONFIG_DEBUG_FS 1659 1660static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip) 1661{ 1662 unsigned i; 1663 unsigned gpio = chip->base; 1664 struct gpio_desc *gdesc = &gpio_desc[gpio]; 1665 int is_out; 1666 1667 for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) { 1668 if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) 1669 continue; 1670 1671 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags); 1672 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s", 1673 gpio, gdesc->label, 1674 is_out ? "out" : "in ", 1675 chip->get 1676 ? (chip->get(chip, i) ? "hi" : "lo") 1677 : "? "); 1678 seq_printf(s, "\n"); 1679 } 1680} 1681 1682static int gpiolib_show(struct seq_file *s, void *unused) 1683{ 1684 struct gpio_chip *chip = NULL; 1685 unsigned gpio; 1686 int started = 0; 1687 1688 /* REVISIT this isn't locked against gpio_chip removal ... */ 1689 1690 for (gpio = 0; gpio_is_valid(gpio); gpio++) { 1691 struct device *dev; 1692 1693 if (chip == gpio_desc[gpio].chip) 1694 continue; 1695 chip = gpio_desc[gpio].chip; 1696 if (!chip) 1697 continue; 1698 1699 seq_printf(s, "%sGPIOs %d-%d", 1700 started ? "\n" : "", 1701 chip->base, chip->base + chip->ngpio - 1); 1702 dev = chip->dev; 1703 if (dev) 1704 seq_printf(s, ", %s/%s", 1705 dev->bus ? dev->bus->name : "no-bus", 1706 dev_name(dev)); 1707 if (chip->label) 1708 seq_printf(s, ", %s", chip->label); 1709 if (chip->can_sleep) 1710 seq_printf(s, ", can sleep"); 1711 seq_printf(s, ":\n"); 1712 1713 started = 1; 1714 if (chip->dbg_show) 1715 chip->dbg_show(s, chip); 1716 else 1717 gpiolib_dbg_show(s, chip); 1718 } 1719 return 0; 1720} 1721 1722static int gpiolib_open(struct inode *inode, struct file *file) 1723{ 1724 return single_open(file, gpiolib_show, NULL); 1725} 1726 1727static const struct file_operations gpiolib_operations = { 1728 .open = gpiolib_open, 1729 .read = seq_read, 1730 .llseek = seq_lseek, 1731 .release = single_release, 1732}; 1733 1734static int __init gpiolib_debugfs_init(void) 1735{ 1736 /* /sys/kernel/debug/gpio */ 1737 (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO, 1738 NULL, NULL, &gpiolib_operations); 1739 return 0; 1740} 1741subsys_initcall(gpiolib_debugfs_init); 1742 1743#endif /* DEBUG_FS */ 1744