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