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