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