1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <linux/bitmap.h> 4 #include <linux/kernel.h> 5 #include <linux/module.h> 6 #include <linux/interrupt.h> 7 #include <linux/irq.h> 8 #include <linux/spinlock.h> 9 #include <linux/list.h> 10 #include <linux/device.h> 11 #include <linux/err.h> 12 #include <linux/debugfs.h> 13 #include <linux/seq_file.h> 14 #include <linux/gpio.h> 15 #include <linux/idr.h> 16 #include <linux/slab.h> 17 #include <linux/acpi.h> 18 #include <linux/gpio/driver.h> 19 #include <linux/gpio/machine.h> 20 #include <linux/pinctrl/consumer.h> 21 #include <linux/fs.h> 22 #include <linux/compat.h> 23 #include <linux/file.h> 24 #include <uapi/linux/gpio.h> 25 26 #include "gpiolib.h" 27 #include "gpiolib-of.h" 28 #include "gpiolib-acpi.h" 29 #include "gpiolib-cdev.h" 30 #include "gpiolib-sysfs.h" 31 32 #define CREATE_TRACE_POINTS 33 #include <trace/events/gpio.h> 34 35 /* Implementation infrastructure for GPIO interfaces. 36 * 37 * The GPIO programming interface allows for inlining speed-critical 38 * get/set operations for common cases, so that access to SOC-integrated 39 * GPIOs can sometimes cost only an instruction or two per bit. 40 */ 41 42 43 /* When debugging, extend minimal trust to callers and platform code. 44 * Also emit diagnostic messages that may help initial bringup, when 45 * board setup or driver bugs are most common. 46 * 47 * Otherwise, minimize overhead in what may be bitbanging codepaths. 48 */ 49 #ifdef DEBUG 50 #define extra_checks 1 51 #else 52 #define extra_checks 0 53 #endif 54 55 /* Device and char device-related information */ 56 static DEFINE_IDA(gpio_ida); 57 static dev_t gpio_devt; 58 #define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */ 59 static int gpio_bus_match(struct device *dev, struct device_driver *drv); 60 static struct bus_type gpio_bus_type = { 61 .name = "gpio", 62 .match = gpio_bus_match, 63 }; 64 65 /* 66 * Number of GPIOs to use for the fast path in set array 67 */ 68 #define FASTPATH_NGPIO CONFIG_GPIOLIB_FASTPATH_LIMIT 69 70 /* gpio_lock prevents conflicts during gpio_desc[] table updates. 71 * While any GPIO is requested, its gpio_chip is not removable; 72 * each GPIO's "requested" flag serves as a lock and refcount. 73 */ 74 DEFINE_SPINLOCK(gpio_lock); 75 76 static DEFINE_MUTEX(gpio_lookup_lock); 77 static LIST_HEAD(gpio_lookup_list); 78 LIST_HEAD(gpio_devices); 79 80 static DEFINE_MUTEX(gpio_machine_hogs_mutex); 81 static LIST_HEAD(gpio_machine_hogs); 82 83 static void gpiochip_free_hogs(struct gpio_chip *gc); 84 static int gpiochip_add_irqchip(struct gpio_chip *gc, 85 struct lock_class_key *lock_key, 86 struct lock_class_key *request_key); 87 static void gpiochip_irqchip_remove(struct gpio_chip *gc); 88 static int gpiochip_irqchip_init_hw(struct gpio_chip *gc); 89 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc); 90 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gc); 91 92 static bool gpiolib_initialized; 93 94 static inline void desc_set_label(struct gpio_desc *d, const char *label) 95 { 96 d->label = label; 97 } 98 99 /** 100 * gpio_to_desc - Convert a GPIO number to its descriptor 101 * @gpio: global GPIO number 102 * 103 * Returns: 104 * The GPIO descriptor associated with the given GPIO, or %NULL if no GPIO 105 * with the given number exists in the system. 106 */ 107 struct gpio_desc *gpio_to_desc(unsigned gpio) 108 { 109 struct gpio_device *gdev; 110 unsigned long flags; 111 112 spin_lock_irqsave(&gpio_lock, flags); 113 114 list_for_each_entry(gdev, &gpio_devices, list) { 115 if (gdev->base <= gpio && 116 gdev->base + gdev->ngpio > gpio) { 117 spin_unlock_irqrestore(&gpio_lock, flags); 118 return &gdev->descs[gpio - gdev->base]; 119 } 120 } 121 122 spin_unlock_irqrestore(&gpio_lock, flags); 123 124 if (!gpio_is_valid(gpio)) 125 pr_warn("invalid GPIO %d\n", gpio); 126 127 return NULL; 128 } 129 EXPORT_SYMBOL_GPL(gpio_to_desc); 130 131 /** 132 * gpiochip_get_desc - get the GPIO descriptor corresponding to the given 133 * hardware number for this chip 134 * @gc: GPIO chip 135 * @hwnum: hardware number of the GPIO for this chip 136 * 137 * Returns: 138 * A pointer to the GPIO descriptor or ``ERR_PTR(-EINVAL)`` if no GPIO exists 139 * in the given chip for the specified hardware number. 140 */ 141 struct gpio_desc *gpiochip_get_desc(struct gpio_chip *gc, 142 unsigned int hwnum) 143 { 144 struct gpio_device *gdev = gc->gpiodev; 145 146 if (hwnum >= gdev->ngpio) 147 return ERR_PTR(-EINVAL); 148 149 return &gdev->descs[hwnum]; 150 } 151 EXPORT_SYMBOL_GPL(gpiochip_get_desc); 152 153 /** 154 * desc_to_gpio - convert a GPIO descriptor to the integer namespace 155 * @desc: GPIO descriptor 156 * 157 * This should disappear in the future but is needed since we still 158 * use GPIO numbers for error messages and sysfs nodes. 159 * 160 * Returns: 161 * The global GPIO number for the GPIO specified by its descriptor. 162 */ 163 int desc_to_gpio(const struct gpio_desc *desc) 164 { 165 return desc->gdev->base + (desc - &desc->gdev->descs[0]); 166 } 167 EXPORT_SYMBOL_GPL(desc_to_gpio); 168 169 170 /** 171 * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs 172 * @desc: descriptor to return the chip of 173 */ 174 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc) 175 { 176 if (!desc || !desc->gdev) 177 return NULL; 178 return desc->gdev->chip; 179 } 180 EXPORT_SYMBOL_GPL(gpiod_to_chip); 181 182 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */ 183 static int gpiochip_find_base(int ngpio) 184 { 185 struct gpio_device *gdev; 186 int base = ARCH_NR_GPIOS - ngpio; 187 188 list_for_each_entry_reverse(gdev, &gpio_devices, list) { 189 /* found a free space? */ 190 if (gdev->base + gdev->ngpio <= base) 191 break; 192 /* nope, check the space right before the chip */ 193 base = gdev->base - ngpio; 194 } 195 196 if (gpio_is_valid(base)) { 197 pr_debug("%s: found new base at %d\n", __func__, base); 198 return base; 199 } else { 200 pr_err("%s: cannot find free range\n", __func__); 201 return -ENOSPC; 202 } 203 } 204 205 /** 206 * gpiod_get_direction - return the current direction of a GPIO 207 * @desc: GPIO to get the direction of 208 * 209 * Returns 0 for output, 1 for input, or an error code in case of error. 210 * 211 * This function may sleep if gpiod_cansleep() is true. 212 */ 213 int gpiod_get_direction(struct gpio_desc *desc) 214 { 215 struct gpio_chip *gc; 216 unsigned int offset; 217 int ret; 218 219 gc = gpiod_to_chip(desc); 220 offset = gpio_chip_hwgpio(desc); 221 222 /* 223 * Open drain emulation using input mode may incorrectly report 224 * input here, fix that up. 225 */ 226 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && 227 test_bit(FLAG_IS_OUT, &desc->flags)) 228 return 0; 229 230 if (!gc->get_direction) 231 return -ENOTSUPP; 232 233 ret = gc->get_direction(gc, offset); 234 if (ret < 0) 235 return ret; 236 237 /* GPIOF_DIR_IN or other positive, otherwise GPIOF_DIR_OUT */ 238 if (ret > 0) 239 ret = 1; 240 241 assign_bit(FLAG_IS_OUT, &desc->flags, !ret); 242 243 return ret; 244 } 245 EXPORT_SYMBOL_GPL(gpiod_get_direction); 246 247 /* 248 * Add a new chip to the global chips list, keeping the list of chips sorted 249 * by range(means [base, base + ngpio - 1]) order. 250 * 251 * Return -EBUSY if the new chip overlaps with some other chip's integer 252 * space. 253 */ 254 static int gpiodev_add_to_list(struct gpio_device *gdev) 255 { 256 struct gpio_device *prev, *next; 257 258 if (list_empty(&gpio_devices)) { 259 /* initial entry in list */ 260 list_add_tail(&gdev->list, &gpio_devices); 261 return 0; 262 } 263 264 next = list_first_entry(&gpio_devices, struct gpio_device, list); 265 if (gdev->base + gdev->ngpio <= next->base) { 266 /* add before first entry */ 267 list_add(&gdev->list, &gpio_devices); 268 return 0; 269 } 270 271 prev = list_last_entry(&gpio_devices, struct gpio_device, list); 272 if (prev->base + prev->ngpio <= gdev->base) { 273 /* add behind last entry */ 274 list_add_tail(&gdev->list, &gpio_devices); 275 return 0; 276 } 277 278 list_for_each_entry_safe(prev, next, &gpio_devices, list) { 279 /* at the end of the list */ 280 if (&next->list == &gpio_devices) 281 break; 282 283 /* add between prev and next */ 284 if (prev->base + prev->ngpio <= gdev->base 285 && gdev->base + gdev->ngpio <= next->base) { 286 list_add(&gdev->list, &prev->list); 287 return 0; 288 } 289 } 290 291 return -EBUSY; 292 } 293 294 /* 295 * Convert a GPIO name to its descriptor 296 * Note that there is no guarantee that GPIO names are globally unique! 297 * Hence this function will return, if it exists, a reference to the first GPIO 298 * line found that matches the given name. 299 */ 300 static struct gpio_desc *gpio_name_to_desc(const char * const name) 301 { 302 struct gpio_device *gdev; 303 unsigned long flags; 304 305 if (!name) 306 return NULL; 307 308 spin_lock_irqsave(&gpio_lock, flags); 309 310 list_for_each_entry(gdev, &gpio_devices, list) { 311 struct gpio_desc *desc; 312 313 for_each_gpio_desc(gdev->chip, desc) { 314 if (desc->name && !strcmp(desc->name, name)) { 315 spin_unlock_irqrestore(&gpio_lock, flags); 316 return desc; 317 } 318 } 319 } 320 321 spin_unlock_irqrestore(&gpio_lock, flags); 322 323 return NULL; 324 } 325 326 /* 327 * Take the names from gc->names and assign them to their GPIO descriptors. 328 * Warn if a name is already used for a GPIO line on a different GPIO chip. 329 * 330 * Note that: 331 * 1. Non-unique names are still accepted, 332 * 2. Name collisions within the same GPIO chip are not reported. 333 */ 334 static int gpiochip_set_desc_names(struct gpio_chip *gc) 335 { 336 struct gpio_device *gdev = gc->gpiodev; 337 int i; 338 339 /* First check all names if they are unique */ 340 for (i = 0; i != gc->ngpio; ++i) { 341 struct gpio_desc *gpio; 342 343 gpio = gpio_name_to_desc(gc->names[i]); 344 if (gpio) 345 dev_warn(&gdev->dev, 346 "Detected name collision for GPIO name '%s'\n", 347 gc->names[i]); 348 } 349 350 /* Then add all names to the GPIO descriptors */ 351 for (i = 0; i != gc->ngpio; ++i) 352 gdev->descs[i].name = gc->names[i]; 353 354 return 0; 355 } 356 357 /* 358 * devprop_gpiochip_set_names - Set GPIO line names using device properties 359 * @chip: GPIO chip whose lines should be named, if possible 360 * 361 * Looks for device property "gpio-line-names" and if it exists assigns 362 * GPIO line names for the chip. The memory allocated for the assigned 363 * names belong to the underlying firmware node and should not be released 364 * by the caller. 365 */ 366 static int devprop_gpiochip_set_names(struct gpio_chip *chip) 367 { 368 struct gpio_device *gdev = chip->gpiodev; 369 struct fwnode_handle *fwnode = dev_fwnode(&gdev->dev); 370 const char **names; 371 int ret, i; 372 int count; 373 374 count = fwnode_property_string_array_count(fwnode, "gpio-line-names"); 375 if (count < 0) 376 return 0; 377 378 /* 379 * When offset is set in the driver side we assume the driver internally 380 * is using more than one gpiochip per the same device. We have to stop 381 * setting friendly names if the specified ones with 'gpio-line-names' 382 * are less than the offset in the device itself. This means all the 383 * lines are not present for every single pin within all the internal 384 * gpiochips. 385 */ 386 if (count <= chip->offset) { 387 dev_warn(&gdev->dev, "gpio-line-names too short (length %d), cannot map names for the gpiochip at offset %u\n", 388 count, chip->offset); 389 return 0; 390 } 391 392 names = kcalloc(count, sizeof(*names), GFP_KERNEL); 393 if (!names) 394 return -ENOMEM; 395 396 ret = fwnode_property_read_string_array(fwnode, "gpio-line-names", 397 names, count); 398 if (ret < 0) { 399 dev_warn(&gdev->dev, "failed to read GPIO line names\n"); 400 kfree(names); 401 return ret; 402 } 403 404 /* 405 * When more that one gpiochip per device is used, 'count' can 406 * contain at most number gpiochips x chip->ngpio. We have to 407 * correctly distribute all defined lines taking into account 408 * chip->offset as starting point from where we will assign 409 * the names to pins from the 'names' array. Since property 410 * 'gpio-line-names' cannot contains gaps, we have to be sure 411 * we only assign those pins that really exists since chip->ngpio 412 * can be different of the chip->offset. 413 */ 414 count = (count > chip->offset) ? count - chip->offset : count; 415 if (count > chip->ngpio) 416 count = chip->ngpio; 417 418 for (i = 0; i < count; i++) { 419 /* 420 * Allow overriding "fixed" names provided by the GPIO 421 * provider. The "fixed" names are more often than not 422 * generic and less informative than the names given in 423 * device properties. 424 */ 425 if (names[chip->offset + i] && names[chip->offset + i][0]) 426 gdev->descs[i].name = names[chip->offset + i]; 427 } 428 429 kfree(names); 430 431 return 0; 432 } 433 434 static unsigned long *gpiochip_allocate_mask(struct gpio_chip *gc) 435 { 436 unsigned long *p; 437 438 p = bitmap_alloc(gc->ngpio, GFP_KERNEL); 439 if (!p) 440 return NULL; 441 442 /* Assume by default all GPIOs are valid */ 443 bitmap_fill(p, gc->ngpio); 444 445 return p; 446 } 447 448 static int gpiochip_alloc_valid_mask(struct gpio_chip *gc) 449 { 450 if (!(of_gpio_need_valid_mask(gc) || gc->init_valid_mask)) 451 return 0; 452 453 gc->valid_mask = gpiochip_allocate_mask(gc); 454 if (!gc->valid_mask) 455 return -ENOMEM; 456 457 return 0; 458 } 459 460 static int gpiochip_init_valid_mask(struct gpio_chip *gc) 461 { 462 if (gc->init_valid_mask) 463 return gc->init_valid_mask(gc, 464 gc->valid_mask, 465 gc->ngpio); 466 467 return 0; 468 } 469 470 static void gpiochip_free_valid_mask(struct gpio_chip *gc) 471 { 472 bitmap_free(gc->valid_mask); 473 gc->valid_mask = NULL; 474 } 475 476 static int gpiochip_add_pin_ranges(struct gpio_chip *gc) 477 { 478 if (gc->add_pin_ranges) 479 return gc->add_pin_ranges(gc); 480 481 return 0; 482 } 483 484 bool gpiochip_line_is_valid(const struct gpio_chip *gc, 485 unsigned int offset) 486 { 487 /* No mask means all valid */ 488 if (likely(!gc->valid_mask)) 489 return true; 490 return test_bit(offset, gc->valid_mask); 491 } 492 EXPORT_SYMBOL_GPL(gpiochip_line_is_valid); 493 494 static void gpiodevice_release(struct device *dev) 495 { 496 struct gpio_device *gdev = container_of(dev, struct gpio_device, dev); 497 unsigned long flags; 498 499 spin_lock_irqsave(&gpio_lock, flags); 500 list_del(&gdev->list); 501 spin_unlock_irqrestore(&gpio_lock, flags); 502 503 ida_free(&gpio_ida, gdev->id); 504 kfree_const(gdev->label); 505 kfree(gdev->descs); 506 kfree(gdev); 507 } 508 509 #ifdef CONFIG_GPIO_CDEV 510 #define gcdev_register(gdev, devt) gpiolib_cdev_register((gdev), (devt)) 511 #define gcdev_unregister(gdev) gpiolib_cdev_unregister((gdev)) 512 #else 513 /* 514 * gpiolib_cdev_register() indirectly calls device_add(), which is still 515 * required even when cdev is not selected. 516 */ 517 #define gcdev_register(gdev, devt) device_add(&(gdev)->dev) 518 #define gcdev_unregister(gdev) device_del(&(gdev)->dev) 519 #endif 520 521 static int gpiochip_setup_dev(struct gpio_device *gdev) 522 { 523 int ret; 524 525 ret = gcdev_register(gdev, gpio_devt); 526 if (ret) 527 return ret; 528 529 ret = gpiochip_sysfs_register(gdev); 530 if (ret) 531 goto err_remove_device; 532 533 /* From this point, the .release() function cleans up gpio_device */ 534 gdev->dev.release = gpiodevice_release; 535 dev_dbg(&gdev->dev, "registered GPIOs %d to %d on %s\n", gdev->base, 536 gdev->base + gdev->ngpio - 1, gdev->chip->label ? : "generic"); 537 538 return 0; 539 540 err_remove_device: 541 gcdev_unregister(gdev); 542 return ret; 543 } 544 545 static void gpiochip_machine_hog(struct gpio_chip *gc, struct gpiod_hog *hog) 546 { 547 struct gpio_desc *desc; 548 int rv; 549 550 desc = gpiochip_get_desc(gc, hog->chip_hwnum); 551 if (IS_ERR(desc)) { 552 chip_err(gc, "%s: unable to get GPIO desc: %ld\n", __func__, 553 PTR_ERR(desc)); 554 return; 555 } 556 557 if (test_bit(FLAG_IS_HOGGED, &desc->flags)) 558 return; 559 560 rv = gpiod_hog(desc, hog->line_name, hog->lflags, hog->dflags); 561 if (rv) 562 gpiod_err(desc, "%s: unable to hog GPIO line (%s:%u): %d\n", 563 __func__, gc->label, hog->chip_hwnum, rv); 564 } 565 566 static void machine_gpiochip_add(struct gpio_chip *gc) 567 { 568 struct gpiod_hog *hog; 569 570 mutex_lock(&gpio_machine_hogs_mutex); 571 572 list_for_each_entry(hog, &gpio_machine_hogs, list) { 573 if (!strcmp(gc->label, hog->chip_label)) 574 gpiochip_machine_hog(gc, hog); 575 } 576 577 mutex_unlock(&gpio_machine_hogs_mutex); 578 } 579 580 static void gpiochip_setup_devs(void) 581 { 582 struct gpio_device *gdev; 583 int ret; 584 585 list_for_each_entry(gdev, &gpio_devices, list) { 586 ret = gpiochip_setup_dev(gdev); 587 if (ret) 588 dev_err(&gdev->dev, 589 "Failed to initialize gpio device (%d)\n", ret); 590 } 591 } 592 593 int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, 594 struct lock_class_key *lock_key, 595 struct lock_class_key *request_key) 596 { 597 struct fwnode_handle *fwnode = NULL; 598 struct gpio_device *gdev; 599 unsigned long flags; 600 int base = gc->base; 601 unsigned int i; 602 int ret = 0; 603 u32 ngpios; 604 605 if (gc->fwnode) 606 fwnode = gc->fwnode; 607 else if (gc->parent) 608 fwnode = dev_fwnode(gc->parent); 609 610 /* 611 * First: allocate and populate the internal stat container, and 612 * set up the struct device. 613 */ 614 gdev = kzalloc(sizeof(*gdev), GFP_KERNEL); 615 if (!gdev) 616 return -ENOMEM; 617 gdev->dev.bus = &gpio_bus_type; 618 gdev->dev.parent = gc->parent; 619 gdev->chip = gc; 620 gc->gpiodev = gdev; 621 622 of_gpio_dev_init(gc, gdev); 623 acpi_gpio_dev_init(gc, gdev); 624 625 /* 626 * Assign fwnode depending on the result of the previous calls, 627 * if none of them succeed, assign it to the parent's one. 628 */ 629 gdev->dev.fwnode = dev_fwnode(&gdev->dev) ?: fwnode; 630 631 gdev->id = ida_alloc(&gpio_ida, GFP_KERNEL); 632 if (gdev->id < 0) { 633 ret = gdev->id; 634 goto err_free_gdev; 635 } 636 637 ret = dev_set_name(&gdev->dev, GPIOCHIP_NAME "%d", gdev->id); 638 if (ret) 639 goto err_free_ida; 640 641 device_initialize(&gdev->dev); 642 if (gc->parent && gc->parent->driver) 643 gdev->owner = gc->parent->driver->owner; 644 else if (gc->owner) 645 /* TODO: remove chip->owner */ 646 gdev->owner = gc->owner; 647 else 648 gdev->owner = THIS_MODULE; 649 650 gdev->descs = kcalloc(gc->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL); 651 if (!gdev->descs) { 652 ret = -ENOMEM; 653 goto err_free_dev_name; 654 } 655 656 /* 657 * Try the device properties if the driver didn't supply the number 658 * of GPIO lines. 659 */ 660 if (gc->ngpio == 0) { 661 ret = device_property_read_u32(&gdev->dev, "ngpios", &ngpios); 662 if (ret == -ENODATA) 663 /* 664 * -ENODATA means that there is no property found and 665 * we want to issue the error message to the user. 666 * Besides that, we want to return different error code 667 * to state that supplied value is not valid. 668 */ 669 ngpios = 0; 670 else if (ret) 671 goto err_free_descs; 672 673 gc->ngpio = ngpios; 674 } 675 676 if (gc->ngpio == 0) { 677 chip_err(gc, "tried to insert a GPIO chip with zero lines\n"); 678 ret = -EINVAL; 679 goto err_free_descs; 680 } 681 682 if (gc->ngpio > FASTPATH_NGPIO) 683 chip_warn(gc, "line cnt %u is greater than fast path cnt %u\n", 684 gc->ngpio, FASTPATH_NGPIO); 685 686 gdev->label = kstrdup_const(gc->label ?: "unknown", GFP_KERNEL); 687 if (!gdev->label) { 688 ret = -ENOMEM; 689 goto err_free_descs; 690 } 691 692 gdev->ngpio = gc->ngpio; 693 gdev->data = data; 694 695 spin_lock_irqsave(&gpio_lock, flags); 696 697 /* 698 * TODO: this allocates a Linux GPIO number base in the global 699 * GPIO numberspace for this chip. In the long run we want to 700 * get *rid* of this numberspace and use only descriptors, but 701 * it may be a pipe dream. It will not happen before we get rid 702 * of the sysfs interface anyways. 703 */ 704 if (base < 0) { 705 base = gpiochip_find_base(gc->ngpio); 706 if (base < 0) { 707 ret = base; 708 spin_unlock_irqrestore(&gpio_lock, flags); 709 goto err_free_label; 710 } 711 /* 712 * TODO: it should not be necessary to reflect the assigned 713 * base outside of the GPIO subsystem. Go over drivers and 714 * see if anyone makes use of this, else drop this and assign 715 * a poison instead. 716 */ 717 gc->base = base; 718 } 719 gdev->base = base; 720 721 ret = gpiodev_add_to_list(gdev); 722 if (ret) { 723 spin_unlock_irqrestore(&gpio_lock, flags); 724 chip_err(gc, "GPIO integer space overlap, cannot add chip\n"); 725 goto err_free_label; 726 } 727 728 for (i = 0; i < gc->ngpio; i++) 729 gdev->descs[i].gdev = gdev; 730 731 spin_unlock_irqrestore(&gpio_lock, flags); 732 733 BLOCKING_INIT_NOTIFIER_HEAD(&gdev->notifier); 734 735 #ifdef CONFIG_PINCTRL 736 INIT_LIST_HEAD(&gdev->pin_ranges); 737 #endif 738 739 if (gc->names) { 740 ret = gpiochip_set_desc_names(gc); 741 if (ret) 742 goto err_remove_from_list; 743 } 744 ret = devprop_gpiochip_set_names(gc); 745 if (ret) 746 goto err_remove_from_list; 747 748 ret = gpiochip_alloc_valid_mask(gc); 749 if (ret) 750 goto err_remove_from_list; 751 752 ret = of_gpiochip_add(gc); 753 if (ret) 754 goto err_free_gpiochip_mask; 755 756 ret = gpiochip_init_valid_mask(gc); 757 if (ret) 758 goto err_remove_of_chip; 759 760 for (i = 0; i < gc->ngpio; i++) { 761 struct gpio_desc *desc = &gdev->descs[i]; 762 763 if (gc->get_direction && gpiochip_line_is_valid(gc, i)) { 764 assign_bit(FLAG_IS_OUT, 765 &desc->flags, !gc->get_direction(gc, i)); 766 } else { 767 assign_bit(FLAG_IS_OUT, 768 &desc->flags, !gc->direction_input); 769 } 770 } 771 772 ret = gpiochip_add_pin_ranges(gc); 773 if (ret) 774 goto err_remove_of_chip; 775 776 acpi_gpiochip_add(gc); 777 778 machine_gpiochip_add(gc); 779 780 ret = gpiochip_irqchip_init_valid_mask(gc); 781 if (ret) 782 goto err_remove_acpi_chip; 783 784 ret = gpiochip_irqchip_init_hw(gc); 785 if (ret) 786 goto err_remove_acpi_chip; 787 788 ret = gpiochip_add_irqchip(gc, lock_key, request_key); 789 if (ret) 790 goto err_remove_irqchip_mask; 791 792 /* 793 * By first adding the chardev, and then adding the device, 794 * we get a device node entry in sysfs under 795 * /sys/bus/gpio/devices/gpiochipN/dev that can be used for 796 * coldplug of device nodes and other udev business. 797 * We can do this only if gpiolib has been initialized. 798 * Otherwise, defer until later. 799 */ 800 if (gpiolib_initialized) { 801 ret = gpiochip_setup_dev(gdev); 802 if (ret) 803 goto err_remove_irqchip; 804 } 805 return 0; 806 807 err_remove_irqchip: 808 gpiochip_irqchip_remove(gc); 809 err_remove_irqchip_mask: 810 gpiochip_irqchip_free_valid_mask(gc); 811 err_remove_acpi_chip: 812 acpi_gpiochip_remove(gc); 813 err_remove_of_chip: 814 gpiochip_free_hogs(gc); 815 of_gpiochip_remove(gc); 816 err_free_gpiochip_mask: 817 gpiochip_remove_pin_ranges(gc); 818 gpiochip_free_valid_mask(gc); 819 err_remove_from_list: 820 spin_lock_irqsave(&gpio_lock, flags); 821 list_del(&gdev->list); 822 spin_unlock_irqrestore(&gpio_lock, flags); 823 err_free_label: 824 kfree_const(gdev->label); 825 err_free_descs: 826 kfree(gdev->descs); 827 err_free_dev_name: 828 kfree(dev_name(&gdev->dev)); 829 err_free_ida: 830 ida_free(&gpio_ida, gdev->id); 831 err_free_gdev: 832 /* failures here can mean systems won't boot... */ 833 if (ret != -EPROBE_DEFER) { 834 pr_err("%s: GPIOs %d..%d (%s) failed to register, %d\n", __func__, 835 gdev->base, gdev->base + gdev->ngpio - 1, 836 gc->label ? : "generic", ret); 837 } 838 kfree(gdev); 839 return ret; 840 } 841 EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key); 842 843 /** 844 * gpiochip_get_data() - get per-subdriver data for the chip 845 * @gc: GPIO chip 846 * 847 * Returns: 848 * The per-subdriver data for the chip. 849 */ 850 void *gpiochip_get_data(struct gpio_chip *gc) 851 { 852 return gc->gpiodev->data; 853 } 854 EXPORT_SYMBOL_GPL(gpiochip_get_data); 855 856 /** 857 * gpiochip_remove() - unregister a gpio_chip 858 * @gc: the chip to unregister 859 * 860 * A gpio_chip with any GPIOs still requested may not be removed. 861 */ 862 void gpiochip_remove(struct gpio_chip *gc) 863 { 864 struct gpio_device *gdev = gc->gpiodev; 865 unsigned long flags; 866 unsigned int i; 867 868 /* FIXME: should the legacy sysfs handling be moved to gpio_device? */ 869 gpiochip_sysfs_unregister(gdev); 870 gpiochip_free_hogs(gc); 871 /* Numb the device, cancelling all outstanding operations */ 872 gdev->chip = NULL; 873 gpiochip_irqchip_remove(gc); 874 acpi_gpiochip_remove(gc); 875 of_gpiochip_remove(gc); 876 gpiochip_remove_pin_ranges(gc); 877 gpiochip_free_valid_mask(gc); 878 /* 879 * We accept no more calls into the driver from this point, so 880 * NULL the driver data pointer 881 */ 882 gdev->data = NULL; 883 884 spin_lock_irqsave(&gpio_lock, flags); 885 for (i = 0; i < gdev->ngpio; i++) { 886 if (gpiochip_is_requested(gc, i)) 887 break; 888 } 889 spin_unlock_irqrestore(&gpio_lock, flags); 890 891 if (i != gdev->ngpio) 892 dev_crit(&gdev->dev, 893 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n"); 894 895 /* 896 * The gpiochip side puts its use of the device to rest here: 897 * if there are no userspace clients, the chardev and device will 898 * be removed, else it will be dangling until the last user is 899 * gone. 900 */ 901 gcdev_unregister(gdev); 902 put_device(&gdev->dev); 903 } 904 EXPORT_SYMBOL_GPL(gpiochip_remove); 905 906 /** 907 * gpiochip_find() - iterator for locating a specific gpio_chip 908 * @data: data to pass to match function 909 * @match: Callback function to check gpio_chip 910 * 911 * Similar to bus_find_device. It returns a reference to a gpio_chip as 912 * determined by a user supplied @match callback. The callback should return 913 * 0 if the device doesn't match and non-zero if it does. If the callback is 914 * non-zero, this function will return to the caller and not iterate over any 915 * more gpio_chips. 916 */ 917 struct gpio_chip *gpiochip_find(void *data, 918 int (*match)(struct gpio_chip *gc, 919 void *data)) 920 { 921 struct gpio_device *gdev; 922 struct gpio_chip *gc = NULL; 923 unsigned long flags; 924 925 spin_lock_irqsave(&gpio_lock, flags); 926 list_for_each_entry(gdev, &gpio_devices, list) 927 if (gdev->chip && match(gdev->chip, data)) { 928 gc = gdev->chip; 929 break; 930 } 931 932 spin_unlock_irqrestore(&gpio_lock, flags); 933 934 return gc; 935 } 936 EXPORT_SYMBOL_GPL(gpiochip_find); 937 938 static int gpiochip_match_name(struct gpio_chip *gc, void *data) 939 { 940 const char *name = data; 941 942 return !strcmp(gc->label, name); 943 } 944 945 static struct gpio_chip *find_chip_by_name(const char *name) 946 { 947 return gpiochip_find((void *)name, gpiochip_match_name); 948 } 949 950 #ifdef CONFIG_GPIOLIB_IRQCHIP 951 952 /* 953 * The following is irqchip helper code for gpiochips. 954 */ 955 956 static int gpiochip_irqchip_init_hw(struct gpio_chip *gc) 957 { 958 struct gpio_irq_chip *girq = &gc->irq; 959 960 if (!girq->init_hw) 961 return 0; 962 963 return girq->init_hw(gc); 964 } 965 966 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc) 967 { 968 struct gpio_irq_chip *girq = &gc->irq; 969 970 if (!girq->init_valid_mask) 971 return 0; 972 973 girq->valid_mask = gpiochip_allocate_mask(gc); 974 if (!girq->valid_mask) 975 return -ENOMEM; 976 977 girq->init_valid_mask(gc, girq->valid_mask, gc->ngpio); 978 979 return 0; 980 } 981 982 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gc) 983 { 984 bitmap_free(gc->irq.valid_mask); 985 gc->irq.valid_mask = NULL; 986 } 987 988 bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gc, 989 unsigned int offset) 990 { 991 if (!gpiochip_line_is_valid(gc, offset)) 992 return false; 993 /* No mask means all valid */ 994 if (likely(!gc->irq.valid_mask)) 995 return true; 996 return test_bit(offset, gc->irq.valid_mask); 997 } 998 EXPORT_SYMBOL_GPL(gpiochip_irqchip_irq_valid); 999 1000 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY 1001 1002 /** 1003 * gpiochip_set_hierarchical_irqchip() - connects a hierarchical irqchip 1004 * to a gpiochip 1005 * @gc: the gpiochip to set the irqchip hierarchical handler to 1006 * @irqchip: the irqchip to handle this level of the hierarchy, the interrupt 1007 * will then percolate up to the parent 1008 */ 1009 static void gpiochip_set_hierarchical_irqchip(struct gpio_chip *gc, 1010 struct irq_chip *irqchip) 1011 { 1012 /* DT will deal with mapping each IRQ as we go along */ 1013 if (is_of_node(gc->irq.fwnode)) 1014 return; 1015 1016 /* 1017 * This is for legacy and boardfile "irqchip" fwnodes: allocate 1018 * irqs upfront instead of dynamically since we don't have the 1019 * dynamic type of allocation that hardware description languages 1020 * provide. Once all GPIO drivers using board files are gone from 1021 * the kernel we can delete this code, but for a transitional period 1022 * it is necessary to keep this around. 1023 */ 1024 if (is_fwnode_irqchip(gc->irq.fwnode)) { 1025 int i; 1026 int ret; 1027 1028 for (i = 0; i < gc->ngpio; i++) { 1029 struct irq_fwspec fwspec; 1030 unsigned int parent_hwirq; 1031 unsigned int parent_type; 1032 struct gpio_irq_chip *girq = &gc->irq; 1033 1034 /* 1035 * We call the child to parent translation function 1036 * only to check if the child IRQ is valid or not. 1037 * Just pick the rising edge type here as that is what 1038 * we likely need to support. 1039 */ 1040 ret = girq->child_to_parent_hwirq(gc, i, 1041 IRQ_TYPE_EDGE_RISING, 1042 &parent_hwirq, 1043 &parent_type); 1044 if (ret) { 1045 chip_err(gc, "skip set-up on hwirq %d\n", 1046 i); 1047 continue; 1048 } 1049 1050 fwspec.fwnode = gc->irq.fwnode; 1051 /* This is the hwirq for the GPIO line side of things */ 1052 fwspec.param[0] = girq->child_offset_to_irq(gc, i); 1053 /* Just pick something */ 1054 fwspec.param[1] = IRQ_TYPE_EDGE_RISING; 1055 fwspec.param_count = 2; 1056 ret = __irq_domain_alloc_irqs(gc->irq.domain, 1057 /* just pick something */ 1058 -1, 1059 1, 1060 NUMA_NO_NODE, 1061 &fwspec, 1062 false, 1063 NULL); 1064 if (ret < 0) { 1065 chip_err(gc, 1066 "can not allocate irq for GPIO line %d parent hwirq %d in hierarchy domain: %d\n", 1067 i, parent_hwirq, 1068 ret); 1069 } 1070 } 1071 } 1072 1073 chip_err(gc, "%s unknown fwnode type proceed anyway\n", __func__); 1074 1075 return; 1076 } 1077 1078 static int gpiochip_hierarchy_irq_domain_translate(struct irq_domain *d, 1079 struct irq_fwspec *fwspec, 1080 unsigned long *hwirq, 1081 unsigned int *type) 1082 { 1083 /* We support standard DT translation */ 1084 if (is_of_node(fwspec->fwnode) && fwspec->param_count == 2) { 1085 return irq_domain_translate_twocell(d, fwspec, hwirq, type); 1086 } 1087 1088 /* This is for board files and others not using DT */ 1089 if (is_fwnode_irqchip(fwspec->fwnode)) { 1090 int ret; 1091 1092 ret = irq_domain_translate_twocell(d, fwspec, hwirq, type); 1093 if (ret) 1094 return ret; 1095 WARN_ON(*type == IRQ_TYPE_NONE); 1096 return 0; 1097 } 1098 return -EINVAL; 1099 } 1100 1101 static int gpiochip_hierarchy_irq_domain_alloc(struct irq_domain *d, 1102 unsigned int irq, 1103 unsigned int nr_irqs, 1104 void *data) 1105 { 1106 struct gpio_chip *gc = d->host_data; 1107 irq_hw_number_t hwirq; 1108 unsigned int type = IRQ_TYPE_NONE; 1109 struct irq_fwspec *fwspec = data; 1110 void *parent_arg; 1111 unsigned int parent_hwirq; 1112 unsigned int parent_type; 1113 struct gpio_irq_chip *girq = &gc->irq; 1114 int ret; 1115 1116 /* 1117 * The nr_irqs parameter is always one except for PCI multi-MSI 1118 * so this should not happen. 1119 */ 1120 WARN_ON(nr_irqs != 1); 1121 1122 ret = gc->irq.child_irq_domain_ops.translate(d, fwspec, &hwirq, &type); 1123 if (ret) 1124 return ret; 1125 1126 chip_dbg(gc, "allocate IRQ %d, hwirq %lu\n", irq, hwirq); 1127 1128 ret = girq->child_to_parent_hwirq(gc, hwirq, type, 1129 &parent_hwirq, &parent_type); 1130 if (ret) { 1131 chip_err(gc, "can't look up hwirq %lu\n", hwirq); 1132 return ret; 1133 } 1134 chip_dbg(gc, "found parent hwirq %u\n", parent_hwirq); 1135 1136 /* 1137 * We set handle_bad_irq because the .set_type() should 1138 * always be invoked and set the right type of handler. 1139 */ 1140 irq_domain_set_info(d, 1141 irq, 1142 hwirq, 1143 gc->irq.chip, 1144 gc, 1145 girq->handler, 1146 NULL, NULL); 1147 irq_set_probe(irq); 1148 1149 /* This parent only handles asserted level IRQs */ 1150 parent_arg = girq->populate_parent_alloc_arg(gc, parent_hwirq, parent_type); 1151 if (!parent_arg) 1152 return -ENOMEM; 1153 1154 chip_dbg(gc, "alloc_irqs_parent for %d parent hwirq %d\n", 1155 irq, parent_hwirq); 1156 irq_set_lockdep_class(irq, gc->irq.lock_key, gc->irq.request_key); 1157 ret = irq_domain_alloc_irqs_parent(d, irq, 1, parent_arg); 1158 /* 1159 * If the parent irqdomain is msi, the interrupts have already 1160 * been allocated, so the EEXIST is good. 1161 */ 1162 if (irq_domain_is_msi(d->parent) && (ret == -EEXIST)) 1163 ret = 0; 1164 if (ret) 1165 chip_err(gc, 1166 "failed to allocate parent hwirq %d for hwirq %lu\n", 1167 parent_hwirq, hwirq); 1168 1169 kfree(parent_arg); 1170 return ret; 1171 } 1172 1173 static unsigned int gpiochip_child_offset_to_irq_noop(struct gpio_chip *gc, 1174 unsigned int offset) 1175 { 1176 return offset; 1177 } 1178 1179 static void gpiochip_hierarchy_setup_domain_ops(struct irq_domain_ops *ops) 1180 { 1181 ops->activate = gpiochip_irq_domain_activate; 1182 ops->deactivate = gpiochip_irq_domain_deactivate; 1183 ops->alloc = gpiochip_hierarchy_irq_domain_alloc; 1184 ops->free = irq_domain_free_irqs_common; 1185 1186 /* 1187 * We only allow overriding the translate() function for 1188 * hierarchical chips, and this should only be done if the user 1189 * really need something other than 1:1 translation. 1190 */ 1191 if (!ops->translate) 1192 ops->translate = gpiochip_hierarchy_irq_domain_translate; 1193 } 1194 1195 static int gpiochip_hierarchy_add_domain(struct gpio_chip *gc) 1196 { 1197 if (!gc->irq.child_to_parent_hwirq || 1198 !gc->irq.fwnode) { 1199 chip_err(gc, "missing irqdomain vital data\n"); 1200 return -EINVAL; 1201 } 1202 1203 if (!gc->irq.child_offset_to_irq) 1204 gc->irq.child_offset_to_irq = gpiochip_child_offset_to_irq_noop; 1205 1206 if (!gc->irq.populate_parent_alloc_arg) 1207 gc->irq.populate_parent_alloc_arg = 1208 gpiochip_populate_parent_fwspec_twocell; 1209 1210 gpiochip_hierarchy_setup_domain_ops(&gc->irq.child_irq_domain_ops); 1211 1212 gc->irq.domain = irq_domain_create_hierarchy( 1213 gc->irq.parent_domain, 1214 0, 1215 gc->ngpio, 1216 gc->irq.fwnode, 1217 &gc->irq.child_irq_domain_ops, 1218 gc); 1219 1220 if (!gc->irq.domain) 1221 return -ENOMEM; 1222 1223 gpiochip_set_hierarchical_irqchip(gc, gc->irq.chip); 1224 1225 return 0; 1226 } 1227 1228 static bool gpiochip_hierarchy_is_hierarchical(struct gpio_chip *gc) 1229 { 1230 return !!gc->irq.parent_domain; 1231 } 1232 1233 void *gpiochip_populate_parent_fwspec_twocell(struct gpio_chip *gc, 1234 unsigned int parent_hwirq, 1235 unsigned int parent_type) 1236 { 1237 struct irq_fwspec *fwspec; 1238 1239 fwspec = kmalloc(sizeof(*fwspec), GFP_KERNEL); 1240 if (!fwspec) 1241 return NULL; 1242 1243 fwspec->fwnode = gc->irq.parent_domain->fwnode; 1244 fwspec->param_count = 2; 1245 fwspec->param[0] = parent_hwirq; 1246 fwspec->param[1] = parent_type; 1247 1248 return fwspec; 1249 } 1250 EXPORT_SYMBOL_GPL(gpiochip_populate_parent_fwspec_twocell); 1251 1252 void *gpiochip_populate_parent_fwspec_fourcell(struct gpio_chip *gc, 1253 unsigned int parent_hwirq, 1254 unsigned int parent_type) 1255 { 1256 struct irq_fwspec *fwspec; 1257 1258 fwspec = kmalloc(sizeof(*fwspec), GFP_KERNEL); 1259 if (!fwspec) 1260 return NULL; 1261 1262 fwspec->fwnode = gc->irq.parent_domain->fwnode; 1263 fwspec->param_count = 4; 1264 fwspec->param[0] = 0; 1265 fwspec->param[1] = parent_hwirq; 1266 fwspec->param[2] = 0; 1267 fwspec->param[3] = parent_type; 1268 1269 return fwspec; 1270 } 1271 EXPORT_SYMBOL_GPL(gpiochip_populate_parent_fwspec_fourcell); 1272 1273 #else 1274 1275 static int gpiochip_hierarchy_add_domain(struct gpio_chip *gc) 1276 { 1277 return -EINVAL; 1278 } 1279 1280 static bool gpiochip_hierarchy_is_hierarchical(struct gpio_chip *gc) 1281 { 1282 return false; 1283 } 1284 1285 #endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */ 1286 1287 /** 1288 * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip 1289 * @d: the irqdomain used by this irqchip 1290 * @irq: the global irq number used by this GPIO irqchip irq 1291 * @hwirq: the local IRQ/GPIO line offset on this gpiochip 1292 * 1293 * This function will set up the mapping for a certain IRQ line on a 1294 * gpiochip by assigning the gpiochip as chip data, and using the irqchip 1295 * stored inside the gpiochip. 1296 */ 1297 int gpiochip_irq_map(struct irq_domain *d, unsigned int irq, 1298 irq_hw_number_t hwirq) 1299 { 1300 struct gpio_chip *gc = d->host_data; 1301 int ret = 0; 1302 1303 if (!gpiochip_irqchip_irq_valid(gc, hwirq)) 1304 return -ENXIO; 1305 1306 irq_set_chip_data(irq, gc); 1307 /* 1308 * This lock class tells lockdep that GPIO irqs are in a different 1309 * category than their parents, so it won't report false recursion. 1310 */ 1311 irq_set_lockdep_class(irq, gc->irq.lock_key, gc->irq.request_key); 1312 irq_set_chip_and_handler(irq, gc->irq.chip, gc->irq.handler); 1313 /* Chips that use nested thread handlers have them marked */ 1314 if (gc->irq.threaded) 1315 irq_set_nested_thread(irq, 1); 1316 irq_set_noprobe(irq); 1317 1318 if (gc->irq.num_parents == 1) 1319 ret = irq_set_parent(irq, gc->irq.parents[0]); 1320 else if (gc->irq.map) 1321 ret = irq_set_parent(irq, gc->irq.map[hwirq]); 1322 1323 if (ret < 0) 1324 return ret; 1325 1326 /* 1327 * No set-up of the hardware will happen if IRQ_TYPE_NONE 1328 * is passed as default type. 1329 */ 1330 if (gc->irq.default_type != IRQ_TYPE_NONE) 1331 irq_set_irq_type(irq, gc->irq.default_type); 1332 1333 return 0; 1334 } 1335 EXPORT_SYMBOL_GPL(gpiochip_irq_map); 1336 1337 void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq) 1338 { 1339 struct gpio_chip *gc = d->host_data; 1340 1341 if (gc->irq.threaded) 1342 irq_set_nested_thread(irq, 0); 1343 irq_set_chip_and_handler(irq, NULL, NULL); 1344 irq_set_chip_data(irq, NULL); 1345 } 1346 EXPORT_SYMBOL_GPL(gpiochip_irq_unmap); 1347 1348 static const struct irq_domain_ops gpiochip_domain_ops = { 1349 .map = gpiochip_irq_map, 1350 .unmap = gpiochip_irq_unmap, 1351 /* Virtually all GPIO irqchips are twocell:ed */ 1352 .xlate = irq_domain_xlate_twocell, 1353 }; 1354 1355 /* 1356 * TODO: move these activate/deactivate in under the hierarchicial 1357 * irqchip implementation as static once SPMI and SSBI (all external 1358 * users) are phased over. 1359 */ 1360 /** 1361 * gpiochip_irq_domain_activate() - Lock a GPIO to be used as an IRQ 1362 * @domain: The IRQ domain used by this IRQ chip 1363 * @data: Outermost irq_data associated with the IRQ 1364 * @reserve: If set, only reserve an interrupt vector instead of assigning one 1365 * 1366 * This function is a wrapper that calls gpiochip_lock_as_irq() and is to be 1367 * used as the activate function for the &struct irq_domain_ops. The host_data 1368 * for the IRQ domain must be the &struct gpio_chip. 1369 */ 1370 int gpiochip_irq_domain_activate(struct irq_domain *domain, 1371 struct irq_data *data, bool reserve) 1372 { 1373 struct gpio_chip *gc = domain->host_data; 1374 1375 return gpiochip_lock_as_irq(gc, data->hwirq); 1376 } 1377 EXPORT_SYMBOL_GPL(gpiochip_irq_domain_activate); 1378 1379 /** 1380 * gpiochip_irq_domain_deactivate() - Unlock a GPIO used as an IRQ 1381 * @domain: The IRQ domain used by this IRQ chip 1382 * @data: Outermost irq_data associated with the IRQ 1383 * 1384 * This function is a wrapper that will call gpiochip_unlock_as_irq() and is to 1385 * be used as the deactivate function for the &struct irq_domain_ops. The 1386 * host_data for the IRQ domain must be the &struct gpio_chip. 1387 */ 1388 void gpiochip_irq_domain_deactivate(struct irq_domain *domain, 1389 struct irq_data *data) 1390 { 1391 struct gpio_chip *gc = domain->host_data; 1392 1393 return gpiochip_unlock_as_irq(gc, data->hwirq); 1394 } 1395 EXPORT_SYMBOL_GPL(gpiochip_irq_domain_deactivate); 1396 1397 static int gpiochip_to_irq(struct gpio_chip *gc, unsigned int offset) 1398 { 1399 struct irq_domain *domain = gc->irq.domain; 1400 1401 #ifdef CONFIG_GPIOLIB_IRQCHIP 1402 /* 1403 * Avoid race condition with other code, which tries to lookup 1404 * an IRQ before the irqchip has been properly registered, 1405 * i.e. while gpiochip is still being brought up. 1406 */ 1407 if (!gc->irq.initialized) 1408 return -EPROBE_DEFER; 1409 #endif 1410 1411 if (!gpiochip_irqchip_irq_valid(gc, offset)) 1412 return -ENXIO; 1413 1414 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY 1415 if (irq_domain_is_hierarchy(domain)) { 1416 struct irq_fwspec spec; 1417 1418 spec.fwnode = domain->fwnode; 1419 spec.param_count = 2; 1420 spec.param[0] = gc->irq.child_offset_to_irq(gc, offset); 1421 spec.param[1] = IRQ_TYPE_NONE; 1422 1423 return irq_create_fwspec_mapping(&spec); 1424 } 1425 #endif 1426 1427 return irq_create_mapping(domain, offset); 1428 } 1429 1430 int gpiochip_irq_reqres(struct irq_data *d) 1431 { 1432 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 1433 1434 return gpiochip_reqres_irq(gc, d->hwirq); 1435 } 1436 EXPORT_SYMBOL(gpiochip_irq_reqres); 1437 1438 void gpiochip_irq_relres(struct irq_data *d) 1439 { 1440 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 1441 1442 gpiochip_relres_irq(gc, d->hwirq); 1443 } 1444 EXPORT_SYMBOL(gpiochip_irq_relres); 1445 1446 static void gpiochip_irq_mask(struct irq_data *d) 1447 { 1448 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 1449 1450 if (gc->irq.irq_mask) 1451 gc->irq.irq_mask(d); 1452 gpiochip_disable_irq(gc, d->hwirq); 1453 } 1454 1455 static void gpiochip_irq_unmask(struct irq_data *d) 1456 { 1457 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 1458 1459 gpiochip_enable_irq(gc, d->hwirq); 1460 if (gc->irq.irq_unmask) 1461 gc->irq.irq_unmask(d); 1462 } 1463 1464 static void gpiochip_irq_enable(struct irq_data *d) 1465 { 1466 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 1467 1468 gpiochip_enable_irq(gc, d->hwirq); 1469 gc->irq.irq_enable(d); 1470 } 1471 1472 static void gpiochip_irq_disable(struct irq_data *d) 1473 { 1474 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 1475 1476 gc->irq.irq_disable(d); 1477 gpiochip_disable_irq(gc, d->hwirq); 1478 } 1479 1480 static void gpiochip_set_irq_hooks(struct gpio_chip *gc) 1481 { 1482 struct irq_chip *irqchip = gc->irq.chip; 1483 1484 if (irqchip->flags & IRQCHIP_IMMUTABLE) 1485 return; 1486 1487 chip_warn(gc, "not an immutable chip, please consider fixing it!\n"); 1488 1489 if (!irqchip->irq_request_resources && 1490 !irqchip->irq_release_resources) { 1491 irqchip->irq_request_resources = gpiochip_irq_reqres; 1492 irqchip->irq_release_resources = gpiochip_irq_relres; 1493 } 1494 if (WARN_ON(gc->irq.irq_enable)) 1495 return; 1496 /* Check if the irqchip already has this hook... */ 1497 if (irqchip->irq_enable == gpiochip_irq_enable || 1498 irqchip->irq_mask == gpiochip_irq_mask) { 1499 /* 1500 * ...and if so, give a gentle warning that this is bad 1501 * practice. 1502 */ 1503 chip_info(gc, 1504 "detected irqchip that is shared with multiple gpiochips: please fix the driver.\n"); 1505 return; 1506 } 1507 1508 if (irqchip->irq_disable) { 1509 gc->irq.irq_disable = irqchip->irq_disable; 1510 irqchip->irq_disable = gpiochip_irq_disable; 1511 } else { 1512 gc->irq.irq_mask = irqchip->irq_mask; 1513 irqchip->irq_mask = gpiochip_irq_mask; 1514 } 1515 1516 if (irqchip->irq_enable) { 1517 gc->irq.irq_enable = irqchip->irq_enable; 1518 irqchip->irq_enable = gpiochip_irq_enable; 1519 } else { 1520 gc->irq.irq_unmask = irqchip->irq_unmask; 1521 irqchip->irq_unmask = gpiochip_irq_unmask; 1522 } 1523 } 1524 1525 /** 1526 * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip 1527 * @gc: the GPIO chip to add the IRQ chip to 1528 * @lock_key: lockdep class for IRQ lock 1529 * @request_key: lockdep class for IRQ request 1530 */ 1531 static int gpiochip_add_irqchip(struct gpio_chip *gc, 1532 struct lock_class_key *lock_key, 1533 struct lock_class_key *request_key) 1534 { 1535 struct fwnode_handle *fwnode = dev_fwnode(&gc->gpiodev->dev); 1536 struct irq_chip *irqchip = gc->irq.chip; 1537 unsigned int type; 1538 unsigned int i; 1539 1540 if (!irqchip) 1541 return 0; 1542 1543 if (gc->irq.parent_handler && gc->can_sleep) { 1544 chip_err(gc, "you cannot have chained interrupts on a chip that may sleep\n"); 1545 return -EINVAL; 1546 } 1547 1548 type = gc->irq.default_type; 1549 1550 /* 1551 * Specifying a default trigger is a terrible idea if DT or ACPI is 1552 * used to configure the interrupts, as you may end up with 1553 * conflicting triggers. Tell the user, and reset to NONE. 1554 */ 1555 if (WARN(fwnode && type != IRQ_TYPE_NONE, 1556 "%pfw: Ignoring %u default trigger\n", fwnode, type)) 1557 type = IRQ_TYPE_NONE; 1558 1559 if (gc->to_irq) 1560 chip_warn(gc, "to_irq is redefined in %s and you shouldn't rely on it\n", __func__); 1561 1562 gc->to_irq = gpiochip_to_irq; 1563 gc->irq.default_type = type; 1564 gc->irq.lock_key = lock_key; 1565 gc->irq.request_key = request_key; 1566 1567 /* If a parent irqdomain is provided, let's build a hierarchy */ 1568 if (gpiochip_hierarchy_is_hierarchical(gc)) { 1569 int ret = gpiochip_hierarchy_add_domain(gc); 1570 if (ret) 1571 return ret; 1572 } else { 1573 /* Some drivers provide custom irqdomain ops */ 1574 gc->irq.domain = irq_domain_create_simple(fwnode, 1575 gc->ngpio, 1576 gc->irq.first, 1577 gc->irq.domain_ops ?: &gpiochip_domain_ops, 1578 gc); 1579 if (!gc->irq.domain) 1580 return -EINVAL; 1581 } 1582 1583 if (gc->irq.parent_handler) { 1584 for (i = 0; i < gc->irq.num_parents; i++) { 1585 void *data; 1586 1587 if (gc->irq.per_parent_data) 1588 data = gc->irq.parent_handler_data_array[i]; 1589 else 1590 data = gc->irq.parent_handler_data ?: gc; 1591 1592 /* 1593 * The parent IRQ chip is already using the chip_data 1594 * for this IRQ chip, so our callbacks simply use the 1595 * handler_data. 1596 */ 1597 irq_set_chained_handler_and_data(gc->irq.parents[i], 1598 gc->irq.parent_handler, 1599 data); 1600 } 1601 } 1602 1603 gpiochip_set_irq_hooks(gc); 1604 1605 /* 1606 * Using barrier() here to prevent compiler from reordering 1607 * gc->irq.initialized before initialization of above 1608 * GPIO chip irq members. 1609 */ 1610 barrier(); 1611 1612 gc->irq.initialized = true; 1613 1614 acpi_gpiochip_request_interrupts(gc); 1615 1616 return 0; 1617 } 1618 1619 /** 1620 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip 1621 * @gc: the gpiochip to remove the irqchip from 1622 * 1623 * This is called only from gpiochip_remove() 1624 */ 1625 static void gpiochip_irqchip_remove(struct gpio_chip *gc) 1626 { 1627 struct irq_chip *irqchip = gc->irq.chip; 1628 unsigned int offset; 1629 1630 acpi_gpiochip_free_interrupts(gc); 1631 1632 if (irqchip && gc->irq.parent_handler) { 1633 struct gpio_irq_chip *irq = &gc->irq; 1634 unsigned int i; 1635 1636 for (i = 0; i < irq->num_parents; i++) 1637 irq_set_chained_handler_and_data(irq->parents[i], 1638 NULL, NULL); 1639 } 1640 1641 /* Remove all IRQ mappings and delete the domain */ 1642 if (gc->irq.domain) { 1643 unsigned int irq; 1644 1645 for (offset = 0; offset < gc->ngpio; offset++) { 1646 if (!gpiochip_irqchip_irq_valid(gc, offset)) 1647 continue; 1648 1649 irq = irq_find_mapping(gc->irq.domain, offset); 1650 irq_dispose_mapping(irq); 1651 } 1652 1653 irq_domain_remove(gc->irq.domain); 1654 } 1655 1656 if (irqchip && !(irqchip->flags & IRQCHIP_IMMUTABLE)) { 1657 if (irqchip->irq_request_resources == gpiochip_irq_reqres) { 1658 irqchip->irq_request_resources = NULL; 1659 irqchip->irq_release_resources = NULL; 1660 } 1661 if (irqchip->irq_enable == gpiochip_irq_enable) { 1662 irqchip->irq_enable = gc->irq.irq_enable; 1663 irqchip->irq_disable = gc->irq.irq_disable; 1664 } 1665 } 1666 gc->irq.irq_enable = NULL; 1667 gc->irq.irq_disable = NULL; 1668 gc->irq.chip = NULL; 1669 1670 gpiochip_irqchip_free_valid_mask(gc); 1671 } 1672 1673 /** 1674 * gpiochip_irqchip_add_domain() - adds an irqdomain to a gpiochip 1675 * @gc: the gpiochip to add the irqchip to 1676 * @domain: the irqdomain to add to the gpiochip 1677 * 1678 * This function adds an IRQ domain to the gpiochip. 1679 */ 1680 int gpiochip_irqchip_add_domain(struct gpio_chip *gc, 1681 struct irq_domain *domain) 1682 { 1683 if (!domain) 1684 return -EINVAL; 1685 1686 gc->to_irq = gpiochip_to_irq; 1687 gc->irq.domain = domain; 1688 1689 return 0; 1690 } 1691 EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_domain); 1692 1693 #else /* CONFIG_GPIOLIB_IRQCHIP */ 1694 1695 static inline int gpiochip_add_irqchip(struct gpio_chip *gc, 1696 struct lock_class_key *lock_key, 1697 struct lock_class_key *request_key) 1698 { 1699 return 0; 1700 } 1701 static void gpiochip_irqchip_remove(struct gpio_chip *gc) {} 1702 1703 static inline int gpiochip_irqchip_init_hw(struct gpio_chip *gc) 1704 { 1705 return 0; 1706 } 1707 1708 static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc) 1709 { 1710 return 0; 1711 } 1712 static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gc) 1713 { } 1714 1715 #endif /* CONFIG_GPIOLIB_IRQCHIP */ 1716 1717 /** 1718 * gpiochip_generic_request() - request the gpio function for a pin 1719 * @gc: the gpiochip owning the GPIO 1720 * @offset: the offset of the GPIO to request for GPIO function 1721 */ 1722 int gpiochip_generic_request(struct gpio_chip *gc, unsigned int offset) 1723 { 1724 #ifdef CONFIG_PINCTRL 1725 if (list_empty(&gc->gpiodev->pin_ranges)) 1726 return 0; 1727 #endif 1728 1729 return pinctrl_gpio_request(gc->gpiodev->base + offset); 1730 } 1731 EXPORT_SYMBOL_GPL(gpiochip_generic_request); 1732 1733 /** 1734 * gpiochip_generic_free() - free the gpio function from a pin 1735 * @gc: the gpiochip to request the gpio function for 1736 * @offset: the offset of the GPIO to free from GPIO function 1737 */ 1738 void gpiochip_generic_free(struct gpio_chip *gc, unsigned int offset) 1739 { 1740 #ifdef CONFIG_PINCTRL 1741 if (list_empty(&gc->gpiodev->pin_ranges)) 1742 return; 1743 #endif 1744 1745 pinctrl_gpio_free(gc->gpiodev->base + offset); 1746 } 1747 EXPORT_SYMBOL_GPL(gpiochip_generic_free); 1748 1749 /** 1750 * gpiochip_generic_config() - apply configuration for a pin 1751 * @gc: the gpiochip owning the GPIO 1752 * @offset: the offset of the GPIO to apply the configuration 1753 * @config: the configuration to be applied 1754 */ 1755 int gpiochip_generic_config(struct gpio_chip *gc, unsigned int offset, 1756 unsigned long config) 1757 { 1758 return pinctrl_gpio_set_config(gc->gpiodev->base + offset, config); 1759 } 1760 EXPORT_SYMBOL_GPL(gpiochip_generic_config); 1761 1762 #ifdef CONFIG_PINCTRL 1763 1764 /** 1765 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping 1766 * @gc: the gpiochip to add the range for 1767 * @pctldev: the pin controller to map to 1768 * @gpio_offset: the start offset in the current gpio_chip number space 1769 * @pin_group: name of the pin group inside the pin controller 1770 * 1771 * Calling this function directly from a DeviceTree-supported 1772 * pinctrl driver is DEPRECATED. Please see Section 2.1 of 1773 * Documentation/devicetree/bindings/gpio/gpio.txt on how to 1774 * bind pinctrl and gpio drivers via the "gpio-ranges" property. 1775 */ 1776 int gpiochip_add_pingroup_range(struct gpio_chip *gc, 1777 struct pinctrl_dev *pctldev, 1778 unsigned int gpio_offset, const char *pin_group) 1779 { 1780 struct gpio_pin_range *pin_range; 1781 struct gpio_device *gdev = gc->gpiodev; 1782 int ret; 1783 1784 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL); 1785 if (!pin_range) { 1786 chip_err(gc, "failed to allocate pin ranges\n"); 1787 return -ENOMEM; 1788 } 1789 1790 /* Use local offset as range ID */ 1791 pin_range->range.id = gpio_offset; 1792 pin_range->range.gc = gc; 1793 pin_range->range.name = gc->label; 1794 pin_range->range.base = gdev->base + gpio_offset; 1795 pin_range->pctldev = pctldev; 1796 1797 ret = pinctrl_get_group_pins(pctldev, pin_group, 1798 &pin_range->range.pins, 1799 &pin_range->range.npins); 1800 if (ret < 0) { 1801 kfree(pin_range); 1802 return ret; 1803 } 1804 1805 pinctrl_add_gpio_range(pctldev, &pin_range->range); 1806 1807 chip_dbg(gc, "created GPIO range %d->%d ==> %s PINGRP %s\n", 1808 gpio_offset, gpio_offset + pin_range->range.npins - 1, 1809 pinctrl_dev_get_devname(pctldev), pin_group); 1810 1811 list_add_tail(&pin_range->node, &gdev->pin_ranges); 1812 1813 return 0; 1814 } 1815 EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range); 1816 1817 /** 1818 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping 1819 * @gc: the gpiochip to add the range for 1820 * @pinctl_name: the dev_name() of the pin controller to map to 1821 * @gpio_offset: the start offset in the current gpio_chip number space 1822 * @pin_offset: the start offset in the pin controller number space 1823 * @npins: the number of pins from the offset of each pin space (GPIO and 1824 * pin controller) to accumulate in this range 1825 * 1826 * Returns: 1827 * 0 on success, or a negative error-code on failure. 1828 * 1829 * Calling this function directly from a DeviceTree-supported 1830 * pinctrl driver is DEPRECATED. Please see Section 2.1 of 1831 * Documentation/devicetree/bindings/gpio/gpio.txt on how to 1832 * bind pinctrl and gpio drivers via the "gpio-ranges" property. 1833 */ 1834 int gpiochip_add_pin_range(struct gpio_chip *gc, const char *pinctl_name, 1835 unsigned int gpio_offset, unsigned int pin_offset, 1836 unsigned int npins) 1837 { 1838 struct gpio_pin_range *pin_range; 1839 struct gpio_device *gdev = gc->gpiodev; 1840 int ret; 1841 1842 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL); 1843 if (!pin_range) { 1844 chip_err(gc, "failed to allocate pin ranges\n"); 1845 return -ENOMEM; 1846 } 1847 1848 /* Use local offset as range ID */ 1849 pin_range->range.id = gpio_offset; 1850 pin_range->range.gc = gc; 1851 pin_range->range.name = gc->label; 1852 pin_range->range.base = gdev->base + gpio_offset; 1853 pin_range->range.pin_base = pin_offset; 1854 pin_range->range.npins = npins; 1855 pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name, 1856 &pin_range->range); 1857 if (IS_ERR(pin_range->pctldev)) { 1858 ret = PTR_ERR(pin_range->pctldev); 1859 chip_err(gc, "could not create pin range\n"); 1860 kfree(pin_range); 1861 return ret; 1862 } 1863 chip_dbg(gc, "created GPIO range %d->%d ==> %s PIN %d->%d\n", 1864 gpio_offset, gpio_offset + npins - 1, 1865 pinctl_name, 1866 pin_offset, pin_offset + npins - 1); 1867 1868 list_add_tail(&pin_range->node, &gdev->pin_ranges); 1869 1870 return 0; 1871 } 1872 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range); 1873 1874 /** 1875 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings 1876 * @gc: the chip to remove all the mappings for 1877 */ 1878 void gpiochip_remove_pin_ranges(struct gpio_chip *gc) 1879 { 1880 struct gpio_pin_range *pin_range, *tmp; 1881 struct gpio_device *gdev = gc->gpiodev; 1882 1883 list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) { 1884 list_del(&pin_range->node); 1885 pinctrl_remove_gpio_range(pin_range->pctldev, 1886 &pin_range->range); 1887 kfree(pin_range); 1888 } 1889 } 1890 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges); 1891 1892 #endif /* CONFIG_PINCTRL */ 1893 1894 /* These "optional" allocation calls help prevent drivers from stomping 1895 * on each other, and help provide better diagnostics in debugfs. 1896 * They're called even less than the "set direction" calls. 1897 */ 1898 static int gpiod_request_commit(struct gpio_desc *desc, const char *label) 1899 { 1900 struct gpio_chip *gc = desc->gdev->chip; 1901 int ret; 1902 unsigned long flags; 1903 unsigned offset; 1904 1905 if (label) { 1906 label = kstrdup_const(label, GFP_KERNEL); 1907 if (!label) 1908 return -ENOMEM; 1909 } 1910 1911 spin_lock_irqsave(&gpio_lock, flags); 1912 1913 /* NOTE: gpio_request() can be called in early boot, 1914 * before IRQs are enabled, for non-sleeping (SOC) GPIOs. 1915 */ 1916 1917 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) { 1918 desc_set_label(desc, label ? : "?"); 1919 } else { 1920 ret = -EBUSY; 1921 goto out_free_unlock; 1922 } 1923 1924 if (gc->request) { 1925 /* gc->request may sleep */ 1926 spin_unlock_irqrestore(&gpio_lock, flags); 1927 offset = gpio_chip_hwgpio(desc); 1928 if (gpiochip_line_is_valid(gc, offset)) 1929 ret = gc->request(gc, offset); 1930 else 1931 ret = -EINVAL; 1932 spin_lock_irqsave(&gpio_lock, flags); 1933 1934 if (ret) { 1935 desc_set_label(desc, NULL); 1936 clear_bit(FLAG_REQUESTED, &desc->flags); 1937 goto out_free_unlock; 1938 } 1939 } 1940 if (gc->get_direction) { 1941 /* gc->get_direction may sleep */ 1942 spin_unlock_irqrestore(&gpio_lock, flags); 1943 gpiod_get_direction(desc); 1944 spin_lock_irqsave(&gpio_lock, flags); 1945 } 1946 spin_unlock_irqrestore(&gpio_lock, flags); 1947 return 0; 1948 1949 out_free_unlock: 1950 spin_unlock_irqrestore(&gpio_lock, flags); 1951 kfree_const(label); 1952 return ret; 1953 } 1954 1955 /* 1956 * This descriptor validation needs to be inserted verbatim into each 1957 * function taking a descriptor, so we need to use a preprocessor 1958 * macro to avoid endless duplication. If the desc is NULL it is an 1959 * optional GPIO and calls should just bail out. 1960 */ 1961 static int validate_desc(const struct gpio_desc *desc, const char *func) 1962 { 1963 if (!desc) 1964 return 0; 1965 if (IS_ERR(desc)) { 1966 pr_warn("%s: invalid GPIO (errorpointer)\n", func); 1967 return PTR_ERR(desc); 1968 } 1969 if (!desc->gdev) { 1970 pr_warn("%s: invalid GPIO (no device)\n", func); 1971 return -EINVAL; 1972 } 1973 if (!desc->gdev->chip) { 1974 dev_warn(&desc->gdev->dev, 1975 "%s: backing chip is gone\n", func); 1976 return 0; 1977 } 1978 return 1; 1979 } 1980 1981 #define VALIDATE_DESC(desc) do { \ 1982 int __valid = validate_desc(desc, __func__); \ 1983 if (__valid <= 0) \ 1984 return __valid; \ 1985 } while (0) 1986 1987 #define VALIDATE_DESC_VOID(desc) do { \ 1988 int __valid = validate_desc(desc, __func__); \ 1989 if (__valid <= 0) \ 1990 return; \ 1991 } while (0) 1992 1993 int gpiod_request(struct gpio_desc *desc, const char *label) 1994 { 1995 int ret = -EPROBE_DEFER; 1996 struct gpio_device *gdev; 1997 1998 VALIDATE_DESC(desc); 1999 gdev = desc->gdev; 2000 2001 if (try_module_get(gdev->owner)) { 2002 ret = gpiod_request_commit(desc, label); 2003 if (ret) 2004 module_put(gdev->owner); 2005 else 2006 get_device(&gdev->dev); 2007 } 2008 2009 if (ret) 2010 gpiod_dbg(desc, "%s: status %d\n", __func__, ret); 2011 2012 return ret; 2013 } 2014 2015 static bool gpiod_free_commit(struct gpio_desc *desc) 2016 { 2017 bool ret = false; 2018 unsigned long flags; 2019 struct gpio_chip *gc; 2020 2021 might_sleep(); 2022 2023 gpiod_unexport(desc); 2024 2025 spin_lock_irqsave(&gpio_lock, flags); 2026 2027 gc = desc->gdev->chip; 2028 if (gc && test_bit(FLAG_REQUESTED, &desc->flags)) { 2029 if (gc->free) { 2030 spin_unlock_irqrestore(&gpio_lock, flags); 2031 might_sleep_if(gc->can_sleep); 2032 gc->free(gc, gpio_chip_hwgpio(desc)); 2033 spin_lock_irqsave(&gpio_lock, flags); 2034 } 2035 kfree_const(desc->label); 2036 desc_set_label(desc, NULL); 2037 clear_bit(FLAG_ACTIVE_LOW, &desc->flags); 2038 clear_bit(FLAG_REQUESTED, &desc->flags); 2039 clear_bit(FLAG_OPEN_DRAIN, &desc->flags); 2040 clear_bit(FLAG_OPEN_SOURCE, &desc->flags); 2041 clear_bit(FLAG_PULL_UP, &desc->flags); 2042 clear_bit(FLAG_PULL_DOWN, &desc->flags); 2043 clear_bit(FLAG_BIAS_DISABLE, &desc->flags); 2044 clear_bit(FLAG_EDGE_RISING, &desc->flags); 2045 clear_bit(FLAG_EDGE_FALLING, &desc->flags); 2046 clear_bit(FLAG_IS_HOGGED, &desc->flags); 2047 #ifdef CONFIG_OF_DYNAMIC 2048 desc->hog = NULL; 2049 #endif 2050 #ifdef CONFIG_GPIO_CDEV 2051 WRITE_ONCE(desc->debounce_period_us, 0); 2052 #endif 2053 ret = true; 2054 } 2055 2056 spin_unlock_irqrestore(&gpio_lock, flags); 2057 blocking_notifier_call_chain(&desc->gdev->notifier, 2058 GPIOLINE_CHANGED_RELEASED, desc); 2059 2060 return ret; 2061 } 2062 2063 void gpiod_free(struct gpio_desc *desc) 2064 { 2065 if (desc && desc->gdev && gpiod_free_commit(desc)) { 2066 module_put(desc->gdev->owner); 2067 put_device(&desc->gdev->dev); 2068 } else { 2069 WARN_ON(extra_checks); 2070 } 2071 } 2072 2073 /** 2074 * gpiochip_is_requested - return string iff signal was requested 2075 * @gc: controller managing the signal 2076 * @offset: of signal within controller's 0..(ngpio - 1) range 2077 * 2078 * Returns NULL if the GPIO is not currently requested, else a string. 2079 * The string returned is the label passed to gpio_request(); if none has been 2080 * passed it is a meaningless, non-NULL constant. 2081 * 2082 * This function is for use by GPIO controller drivers. The label can 2083 * help with diagnostics, and knowing that the signal is used as a GPIO 2084 * can help avoid accidentally multiplexing it to another controller. 2085 */ 2086 const char *gpiochip_is_requested(struct gpio_chip *gc, unsigned int offset) 2087 { 2088 struct gpio_desc *desc; 2089 2090 desc = gpiochip_get_desc(gc, offset); 2091 if (IS_ERR(desc)) 2092 return NULL; 2093 2094 if (test_bit(FLAG_REQUESTED, &desc->flags) == 0) 2095 return NULL; 2096 return desc->label; 2097 } 2098 EXPORT_SYMBOL_GPL(gpiochip_is_requested); 2099 2100 /** 2101 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor 2102 * @gc: GPIO chip 2103 * @hwnum: hardware number of the GPIO for which to request the descriptor 2104 * @label: label for the GPIO 2105 * @lflags: lookup flags for this GPIO or 0 if default, this can be used to 2106 * specify things like line inversion semantics with the machine flags 2107 * such as GPIO_OUT_LOW 2108 * @dflags: descriptor request flags for this GPIO or 0 if default, this 2109 * can be used to specify consumer semantics such as open drain 2110 * 2111 * Function allows GPIO chip drivers to request and use their own GPIO 2112 * descriptors via gpiolib API. Difference to gpiod_request() is that this 2113 * function will not increase reference count of the GPIO chip module. This 2114 * allows the GPIO chip module to be unloaded as needed (we assume that the 2115 * GPIO chip driver handles freeing the GPIOs it has requested). 2116 * 2117 * Returns: 2118 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error 2119 * code on failure. 2120 */ 2121 struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *gc, 2122 unsigned int hwnum, 2123 const char *label, 2124 enum gpio_lookup_flags lflags, 2125 enum gpiod_flags dflags) 2126 { 2127 struct gpio_desc *desc = gpiochip_get_desc(gc, hwnum); 2128 int ret; 2129 2130 if (IS_ERR(desc)) { 2131 chip_err(gc, "failed to get GPIO descriptor\n"); 2132 return desc; 2133 } 2134 2135 ret = gpiod_request_commit(desc, label); 2136 if (ret < 0) 2137 return ERR_PTR(ret); 2138 2139 ret = gpiod_configure_flags(desc, label, lflags, dflags); 2140 if (ret) { 2141 chip_err(gc, "setup of own GPIO %s failed\n", label); 2142 gpiod_free_commit(desc); 2143 return ERR_PTR(ret); 2144 } 2145 2146 return desc; 2147 } 2148 EXPORT_SYMBOL_GPL(gpiochip_request_own_desc); 2149 2150 /** 2151 * gpiochip_free_own_desc - Free GPIO requested by the chip driver 2152 * @desc: GPIO descriptor to free 2153 * 2154 * Function frees the given GPIO requested previously with 2155 * gpiochip_request_own_desc(). 2156 */ 2157 void gpiochip_free_own_desc(struct gpio_desc *desc) 2158 { 2159 if (desc) 2160 gpiod_free_commit(desc); 2161 } 2162 EXPORT_SYMBOL_GPL(gpiochip_free_own_desc); 2163 2164 /* 2165 * Drivers MUST set GPIO direction before making get/set calls. In 2166 * some cases this is done in early boot, before IRQs are enabled. 2167 * 2168 * As a rule these aren't called more than once (except for drivers 2169 * using the open-drain emulation idiom) so these are natural places 2170 * to accumulate extra debugging checks. Note that we can't (yet) 2171 * rely on gpio_request() having been called beforehand. 2172 */ 2173 2174 static int gpio_do_set_config(struct gpio_chip *gc, unsigned int offset, 2175 unsigned long config) 2176 { 2177 if (!gc->set_config) 2178 return -ENOTSUPP; 2179 2180 return gc->set_config(gc, offset, config); 2181 } 2182 2183 static int gpio_set_config_with_argument(struct gpio_desc *desc, 2184 enum pin_config_param mode, 2185 u32 argument) 2186 { 2187 struct gpio_chip *gc = desc->gdev->chip; 2188 unsigned long config; 2189 2190 config = pinconf_to_config_packed(mode, argument); 2191 return gpio_do_set_config(gc, gpio_chip_hwgpio(desc), config); 2192 } 2193 2194 static int gpio_set_config_with_argument_optional(struct gpio_desc *desc, 2195 enum pin_config_param mode, 2196 u32 argument) 2197 { 2198 struct device *dev = &desc->gdev->dev; 2199 int gpio = gpio_chip_hwgpio(desc); 2200 int ret; 2201 2202 ret = gpio_set_config_with_argument(desc, mode, argument); 2203 if (ret != -ENOTSUPP) 2204 return ret; 2205 2206 switch (mode) { 2207 case PIN_CONFIG_PERSIST_STATE: 2208 dev_dbg(dev, "Persistence not supported for GPIO %d\n", gpio); 2209 break; 2210 default: 2211 break; 2212 } 2213 2214 return 0; 2215 } 2216 2217 static int gpio_set_config(struct gpio_desc *desc, enum pin_config_param mode) 2218 { 2219 return gpio_set_config_with_argument(desc, mode, 0); 2220 } 2221 2222 static int gpio_set_bias(struct gpio_desc *desc) 2223 { 2224 enum pin_config_param bias; 2225 unsigned int arg; 2226 2227 if (test_bit(FLAG_BIAS_DISABLE, &desc->flags)) 2228 bias = PIN_CONFIG_BIAS_DISABLE; 2229 else if (test_bit(FLAG_PULL_UP, &desc->flags)) 2230 bias = PIN_CONFIG_BIAS_PULL_UP; 2231 else if (test_bit(FLAG_PULL_DOWN, &desc->flags)) 2232 bias = PIN_CONFIG_BIAS_PULL_DOWN; 2233 else 2234 return 0; 2235 2236 switch (bias) { 2237 case PIN_CONFIG_BIAS_PULL_DOWN: 2238 case PIN_CONFIG_BIAS_PULL_UP: 2239 arg = 1; 2240 break; 2241 2242 default: 2243 arg = 0; 2244 break; 2245 } 2246 2247 return gpio_set_config_with_argument_optional(desc, bias, arg); 2248 } 2249 2250 /** 2251 * gpio_set_debounce_timeout() - Set debounce timeout 2252 * @desc: GPIO descriptor to set the debounce timeout 2253 * @debounce: Debounce timeout in microseconds 2254 * 2255 * The function calls the certain GPIO driver to set debounce timeout 2256 * in the hardware. 2257 * 2258 * Returns 0 on success, or negative error code otherwise. 2259 */ 2260 int gpio_set_debounce_timeout(struct gpio_desc *desc, unsigned int debounce) 2261 { 2262 return gpio_set_config_with_argument_optional(desc, 2263 PIN_CONFIG_INPUT_DEBOUNCE, 2264 debounce); 2265 } 2266 2267 /** 2268 * gpiod_direction_input - set the GPIO direction to input 2269 * @desc: GPIO to set to input 2270 * 2271 * Set the direction of the passed GPIO to input, such as gpiod_get_value() can 2272 * be called safely on it. 2273 * 2274 * Return 0 in case of success, else an error code. 2275 */ 2276 int gpiod_direction_input(struct gpio_desc *desc) 2277 { 2278 struct gpio_chip *gc; 2279 int ret = 0; 2280 2281 VALIDATE_DESC(desc); 2282 gc = desc->gdev->chip; 2283 2284 /* 2285 * It is legal to have no .get() and .direction_input() specified if 2286 * the chip is output-only, but you can't specify .direction_input() 2287 * and not support the .get() operation, that doesn't make sense. 2288 */ 2289 if (!gc->get && gc->direction_input) { 2290 gpiod_warn(desc, 2291 "%s: missing get() but have direction_input()\n", 2292 __func__); 2293 return -EIO; 2294 } 2295 2296 /* 2297 * If we have a .direction_input() callback, things are simple, 2298 * just call it. Else we are some input-only chip so try to check the 2299 * direction (if .get_direction() is supported) else we silently 2300 * assume we are in input mode after this. 2301 */ 2302 if (gc->direction_input) { 2303 ret = gc->direction_input(gc, gpio_chip_hwgpio(desc)); 2304 } else if (gc->get_direction && 2305 (gc->get_direction(gc, gpio_chip_hwgpio(desc)) != 1)) { 2306 gpiod_warn(desc, 2307 "%s: missing direction_input() operation and line is output\n", 2308 __func__); 2309 return -EIO; 2310 } 2311 if (ret == 0) { 2312 clear_bit(FLAG_IS_OUT, &desc->flags); 2313 ret = gpio_set_bias(desc); 2314 } 2315 2316 trace_gpio_direction(desc_to_gpio(desc), 1, ret); 2317 2318 return ret; 2319 } 2320 EXPORT_SYMBOL_GPL(gpiod_direction_input); 2321 2322 static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value) 2323 { 2324 struct gpio_chip *gc = desc->gdev->chip; 2325 int val = !!value; 2326 int ret = 0; 2327 2328 /* 2329 * It's OK not to specify .direction_output() if the gpiochip is 2330 * output-only, but if there is then not even a .set() operation it 2331 * is pretty tricky to drive the output line. 2332 */ 2333 if (!gc->set && !gc->direction_output) { 2334 gpiod_warn(desc, 2335 "%s: missing set() and direction_output() operations\n", 2336 __func__); 2337 return -EIO; 2338 } 2339 2340 if (gc->direction_output) { 2341 ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val); 2342 } else { 2343 /* Check that we are in output mode if we can */ 2344 if (gc->get_direction && 2345 gc->get_direction(gc, gpio_chip_hwgpio(desc))) { 2346 gpiod_warn(desc, 2347 "%s: missing direction_output() operation\n", 2348 __func__); 2349 return -EIO; 2350 } 2351 /* 2352 * If we can't actively set the direction, we are some 2353 * output-only chip, so just drive the output as desired. 2354 */ 2355 gc->set(gc, gpio_chip_hwgpio(desc), val); 2356 } 2357 2358 if (!ret) 2359 set_bit(FLAG_IS_OUT, &desc->flags); 2360 trace_gpio_value(desc_to_gpio(desc), 0, val); 2361 trace_gpio_direction(desc_to_gpio(desc), 0, ret); 2362 return ret; 2363 } 2364 2365 /** 2366 * gpiod_direction_output_raw - set the GPIO direction to output 2367 * @desc: GPIO to set to output 2368 * @value: initial output value of the GPIO 2369 * 2370 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can 2371 * be called safely on it. The initial value of the output must be specified 2372 * as raw value on the physical line without regard for the ACTIVE_LOW status. 2373 * 2374 * Return 0 in case of success, else an error code. 2375 */ 2376 int gpiod_direction_output_raw(struct gpio_desc *desc, int value) 2377 { 2378 VALIDATE_DESC(desc); 2379 return gpiod_direction_output_raw_commit(desc, value); 2380 } 2381 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw); 2382 2383 /** 2384 * gpiod_direction_output - set the GPIO direction to output 2385 * @desc: GPIO to set to output 2386 * @value: initial output value of the GPIO 2387 * 2388 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can 2389 * be called safely on it. The initial value of the output must be specified 2390 * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into 2391 * account. 2392 * 2393 * Return 0 in case of success, else an error code. 2394 */ 2395 int gpiod_direction_output(struct gpio_desc *desc, int value) 2396 { 2397 int ret; 2398 2399 VALIDATE_DESC(desc); 2400 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 2401 value = !value; 2402 else 2403 value = !!value; 2404 2405 /* GPIOs used for enabled IRQs shall not be set as output */ 2406 if (test_bit(FLAG_USED_AS_IRQ, &desc->flags) && 2407 test_bit(FLAG_IRQ_IS_ENABLED, &desc->flags)) { 2408 gpiod_err(desc, 2409 "%s: tried to set a GPIO tied to an IRQ as output\n", 2410 __func__); 2411 return -EIO; 2412 } 2413 2414 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) { 2415 /* First see if we can enable open drain in hardware */ 2416 ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_DRAIN); 2417 if (!ret) 2418 goto set_output_value; 2419 /* Emulate open drain by not actively driving the line high */ 2420 if (value) { 2421 ret = gpiod_direction_input(desc); 2422 goto set_output_flag; 2423 } 2424 } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) { 2425 ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_SOURCE); 2426 if (!ret) 2427 goto set_output_value; 2428 /* Emulate open source by not actively driving the line low */ 2429 if (!value) { 2430 ret = gpiod_direction_input(desc); 2431 goto set_output_flag; 2432 } 2433 } else { 2434 gpio_set_config(desc, PIN_CONFIG_DRIVE_PUSH_PULL); 2435 } 2436 2437 set_output_value: 2438 ret = gpio_set_bias(desc); 2439 if (ret) 2440 return ret; 2441 return gpiod_direction_output_raw_commit(desc, value); 2442 2443 set_output_flag: 2444 /* 2445 * When emulating open-source or open-drain functionalities by not 2446 * actively driving the line (setting mode to input) we still need to 2447 * set the IS_OUT flag or otherwise we won't be able to set the line 2448 * value anymore. 2449 */ 2450 if (ret == 0) 2451 set_bit(FLAG_IS_OUT, &desc->flags); 2452 return ret; 2453 } 2454 EXPORT_SYMBOL_GPL(gpiod_direction_output); 2455 2456 /** 2457 * gpiod_set_config - sets @config for a GPIO 2458 * @desc: descriptor of the GPIO for which to set the configuration 2459 * @config: Same packed config format as generic pinconf 2460 * 2461 * Returns: 2462 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the 2463 * configuration. 2464 */ 2465 int gpiod_set_config(struct gpio_desc *desc, unsigned long config) 2466 { 2467 struct gpio_chip *gc; 2468 2469 VALIDATE_DESC(desc); 2470 gc = desc->gdev->chip; 2471 2472 return gpio_do_set_config(gc, gpio_chip_hwgpio(desc), config); 2473 } 2474 EXPORT_SYMBOL_GPL(gpiod_set_config); 2475 2476 /** 2477 * gpiod_set_debounce - sets @debounce time for a GPIO 2478 * @desc: descriptor of the GPIO for which to set debounce time 2479 * @debounce: debounce time in microseconds 2480 * 2481 * Returns: 2482 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the 2483 * debounce time. 2484 */ 2485 int gpiod_set_debounce(struct gpio_desc *desc, unsigned int debounce) 2486 { 2487 unsigned long config; 2488 2489 config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce); 2490 return gpiod_set_config(desc, config); 2491 } 2492 EXPORT_SYMBOL_GPL(gpiod_set_debounce); 2493 2494 /** 2495 * gpiod_set_transitory - Lose or retain GPIO state on suspend or reset 2496 * @desc: descriptor of the GPIO for which to configure persistence 2497 * @transitory: True to lose state on suspend or reset, false for persistence 2498 * 2499 * Returns: 2500 * 0 on success, otherwise a negative error code. 2501 */ 2502 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory) 2503 { 2504 VALIDATE_DESC(desc); 2505 /* 2506 * Handle FLAG_TRANSITORY first, enabling queries to gpiolib for 2507 * persistence state. 2508 */ 2509 assign_bit(FLAG_TRANSITORY, &desc->flags, transitory); 2510 2511 /* If the driver supports it, set the persistence state now */ 2512 return gpio_set_config_with_argument_optional(desc, 2513 PIN_CONFIG_PERSIST_STATE, 2514 !transitory); 2515 } 2516 EXPORT_SYMBOL_GPL(gpiod_set_transitory); 2517 2518 /** 2519 * gpiod_is_active_low - test whether a GPIO is active-low or not 2520 * @desc: the gpio descriptor to test 2521 * 2522 * Returns 1 if the GPIO is active-low, 0 otherwise. 2523 */ 2524 int gpiod_is_active_low(const struct gpio_desc *desc) 2525 { 2526 VALIDATE_DESC(desc); 2527 return test_bit(FLAG_ACTIVE_LOW, &desc->flags); 2528 } 2529 EXPORT_SYMBOL_GPL(gpiod_is_active_low); 2530 2531 /** 2532 * gpiod_toggle_active_low - toggle whether a GPIO is active-low or not 2533 * @desc: the gpio descriptor to change 2534 */ 2535 void gpiod_toggle_active_low(struct gpio_desc *desc) 2536 { 2537 VALIDATE_DESC_VOID(desc); 2538 change_bit(FLAG_ACTIVE_LOW, &desc->flags); 2539 } 2540 EXPORT_SYMBOL_GPL(gpiod_toggle_active_low); 2541 2542 static int gpio_chip_get_value(struct gpio_chip *gc, const struct gpio_desc *desc) 2543 { 2544 return gc->get ? gc->get(gc, gpio_chip_hwgpio(desc)) : -EIO; 2545 } 2546 2547 /* I/O calls are only valid after configuration completed; the relevant 2548 * "is this a valid GPIO" error checks should already have been done. 2549 * 2550 * "Get" operations are often inlinable as reading a pin value register, 2551 * and masking the relevant bit in that register. 2552 * 2553 * When "set" operations are inlinable, they involve writing that mask to 2554 * one register to set a low value, or a different register to set it high. 2555 * Otherwise locking is needed, so there may be little value to inlining. 2556 * 2557 *------------------------------------------------------------------------ 2558 * 2559 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers 2560 * have requested the GPIO. That can include implicit requesting by 2561 * a direction setting call. Marking a gpio as requested locks its chip 2562 * in memory, guaranteeing that these table lookups need no more locking 2563 * and that gpiochip_remove() will fail. 2564 * 2565 * REVISIT when debugging, consider adding some instrumentation to ensure 2566 * that the GPIO was actually requested. 2567 */ 2568 2569 static int gpiod_get_raw_value_commit(const struct gpio_desc *desc) 2570 { 2571 struct gpio_chip *gc; 2572 int value; 2573 2574 gc = desc->gdev->chip; 2575 value = gpio_chip_get_value(gc, desc); 2576 value = value < 0 ? value : !!value; 2577 trace_gpio_value(desc_to_gpio(desc), 1, value); 2578 return value; 2579 } 2580 2581 static int gpio_chip_get_multiple(struct gpio_chip *gc, 2582 unsigned long *mask, unsigned long *bits) 2583 { 2584 if (gc->get_multiple) 2585 return gc->get_multiple(gc, mask, bits); 2586 if (gc->get) { 2587 int i, value; 2588 2589 for_each_set_bit(i, mask, gc->ngpio) { 2590 value = gc->get(gc, i); 2591 if (value < 0) 2592 return value; 2593 __assign_bit(i, bits, value); 2594 } 2595 return 0; 2596 } 2597 return -EIO; 2598 } 2599 2600 int gpiod_get_array_value_complex(bool raw, bool can_sleep, 2601 unsigned int array_size, 2602 struct gpio_desc **desc_array, 2603 struct gpio_array *array_info, 2604 unsigned long *value_bitmap) 2605 { 2606 int ret, i = 0; 2607 2608 /* 2609 * Validate array_info against desc_array and its size. 2610 * It should immediately follow desc_array if both 2611 * have been obtained from the same gpiod_get_array() call. 2612 */ 2613 if (array_info && array_info->desc == desc_array && 2614 array_size <= array_info->size && 2615 (void *)array_info == desc_array + array_info->size) { 2616 if (!can_sleep) 2617 WARN_ON(array_info->chip->can_sleep); 2618 2619 ret = gpio_chip_get_multiple(array_info->chip, 2620 array_info->get_mask, 2621 value_bitmap); 2622 if (ret) 2623 return ret; 2624 2625 if (!raw && !bitmap_empty(array_info->invert_mask, array_size)) 2626 bitmap_xor(value_bitmap, value_bitmap, 2627 array_info->invert_mask, array_size); 2628 2629 i = find_first_zero_bit(array_info->get_mask, array_size); 2630 if (i == array_size) 2631 return 0; 2632 } else { 2633 array_info = NULL; 2634 } 2635 2636 while (i < array_size) { 2637 struct gpio_chip *gc = desc_array[i]->gdev->chip; 2638 DECLARE_BITMAP(fastpath_mask, FASTPATH_NGPIO); 2639 DECLARE_BITMAP(fastpath_bits, FASTPATH_NGPIO); 2640 unsigned long *mask, *bits; 2641 int first, j; 2642 2643 if (likely(gc->ngpio <= FASTPATH_NGPIO)) { 2644 mask = fastpath_mask; 2645 bits = fastpath_bits; 2646 } else { 2647 gfp_t flags = can_sleep ? GFP_KERNEL : GFP_ATOMIC; 2648 2649 mask = bitmap_alloc(gc->ngpio, flags); 2650 if (!mask) 2651 return -ENOMEM; 2652 2653 bits = bitmap_alloc(gc->ngpio, flags); 2654 if (!bits) { 2655 bitmap_free(mask); 2656 return -ENOMEM; 2657 } 2658 } 2659 2660 bitmap_zero(mask, gc->ngpio); 2661 2662 if (!can_sleep) 2663 WARN_ON(gc->can_sleep); 2664 2665 /* collect all inputs belonging to the same chip */ 2666 first = i; 2667 do { 2668 const struct gpio_desc *desc = desc_array[i]; 2669 int hwgpio = gpio_chip_hwgpio(desc); 2670 2671 __set_bit(hwgpio, mask); 2672 i++; 2673 2674 if (array_info) 2675 i = find_next_zero_bit(array_info->get_mask, 2676 array_size, i); 2677 } while ((i < array_size) && 2678 (desc_array[i]->gdev->chip == gc)); 2679 2680 ret = gpio_chip_get_multiple(gc, mask, bits); 2681 if (ret) { 2682 if (mask != fastpath_mask) 2683 bitmap_free(mask); 2684 if (bits != fastpath_bits) 2685 bitmap_free(bits); 2686 return ret; 2687 } 2688 2689 for (j = first; j < i; ) { 2690 const struct gpio_desc *desc = desc_array[j]; 2691 int hwgpio = gpio_chip_hwgpio(desc); 2692 int value = test_bit(hwgpio, bits); 2693 2694 if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 2695 value = !value; 2696 __assign_bit(j, value_bitmap, value); 2697 trace_gpio_value(desc_to_gpio(desc), 1, value); 2698 j++; 2699 2700 if (array_info) 2701 j = find_next_zero_bit(array_info->get_mask, i, 2702 j); 2703 } 2704 2705 if (mask != fastpath_mask) 2706 bitmap_free(mask); 2707 if (bits != fastpath_bits) 2708 bitmap_free(bits); 2709 } 2710 return 0; 2711 } 2712 2713 /** 2714 * gpiod_get_raw_value() - return a gpio's raw value 2715 * @desc: gpio whose value will be returned 2716 * 2717 * Return the GPIO's raw value, i.e. the value of the physical line disregarding 2718 * its ACTIVE_LOW status, or negative errno on failure. 2719 * 2720 * This function can be called from contexts where we cannot sleep, and will 2721 * complain if the GPIO chip functions potentially sleep. 2722 */ 2723 int gpiod_get_raw_value(const struct gpio_desc *desc) 2724 { 2725 VALIDATE_DESC(desc); 2726 /* Should be using gpiod_get_raw_value_cansleep() */ 2727 WARN_ON(desc->gdev->chip->can_sleep); 2728 return gpiod_get_raw_value_commit(desc); 2729 } 2730 EXPORT_SYMBOL_GPL(gpiod_get_raw_value); 2731 2732 /** 2733 * gpiod_get_value() - return a gpio's value 2734 * @desc: gpio whose value will be returned 2735 * 2736 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into 2737 * account, or negative errno on failure. 2738 * 2739 * This function can be called from contexts where we cannot sleep, and will 2740 * complain if the GPIO chip functions potentially sleep. 2741 */ 2742 int gpiod_get_value(const struct gpio_desc *desc) 2743 { 2744 int value; 2745 2746 VALIDATE_DESC(desc); 2747 /* Should be using gpiod_get_value_cansleep() */ 2748 WARN_ON(desc->gdev->chip->can_sleep); 2749 2750 value = gpiod_get_raw_value_commit(desc); 2751 if (value < 0) 2752 return value; 2753 2754 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 2755 value = !value; 2756 2757 return value; 2758 } 2759 EXPORT_SYMBOL_GPL(gpiod_get_value); 2760 2761 /** 2762 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs 2763 * @array_size: number of elements in the descriptor array / value bitmap 2764 * @desc_array: array of GPIO descriptors whose values will be read 2765 * @array_info: information on applicability of fast bitmap processing path 2766 * @value_bitmap: bitmap to store the read values 2767 * 2768 * Read the raw values of the GPIOs, i.e. the values of the physical lines 2769 * without regard for their ACTIVE_LOW status. Return 0 in case of success, 2770 * else an error code. 2771 * 2772 * This function can be called from contexts where we cannot sleep, 2773 * and it will complain if the GPIO chip functions potentially sleep. 2774 */ 2775 int gpiod_get_raw_array_value(unsigned int array_size, 2776 struct gpio_desc **desc_array, 2777 struct gpio_array *array_info, 2778 unsigned long *value_bitmap) 2779 { 2780 if (!desc_array) 2781 return -EINVAL; 2782 return gpiod_get_array_value_complex(true, false, array_size, 2783 desc_array, array_info, 2784 value_bitmap); 2785 } 2786 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value); 2787 2788 /** 2789 * gpiod_get_array_value() - read values from an array of GPIOs 2790 * @array_size: number of elements in the descriptor array / value bitmap 2791 * @desc_array: array of GPIO descriptors whose values will be read 2792 * @array_info: information on applicability of fast bitmap processing path 2793 * @value_bitmap: bitmap to store the read values 2794 * 2795 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status 2796 * into account. Return 0 in case of success, else an error code. 2797 * 2798 * This function can be called from contexts where we cannot sleep, 2799 * and it will complain if the GPIO chip functions potentially sleep. 2800 */ 2801 int gpiod_get_array_value(unsigned int array_size, 2802 struct gpio_desc **desc_array, 2803 struct gpio_array *array_info, 2804 unsigned long *value_bitmap) 2805 { 2806 if (!desc_array) 2807 return -EINVAL; 2808 return gpiod_get_array_value_complex(false, false, array_size, 2809 desc_array, array_info, 2810 value_bitmap); 2811 } 2812 EXPORT_SYMBOL_GPL(gpiod_get_array_value); 2813 2814 /* 2815 * gpio_set_open_drain_value_commit() - Set the open drain gpio's value. 2816 * @desc: gpio descriptor whose state need to be set. 2817 * @value: Non-zero for setting it HIGH otherwise it will set to LOW. 2818 */ 2819 static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value) 2820 { 2821 int ret = 0; 2822 struct gpio_chip *gc = desc->gdev->chip; 2823 int offset = gpio_chip_hwgpio(desc); 2824 2825 if (value) { 2826 ret = gc->direction_input(gc, offset); 2827 } else { 2828 ret = gc->direction_output(gc, offset, 0); 2829 if (!ret) 2830 set_bit(FLAG_IS_OUT, &desc->flags); 2831 } 2832 trace_gpio_direction(desc_to_gpio(desc), value, ret); 2833 if (ret < 0) 2834 gpiod_err(desc, 2835 "%s: Error in set_value for open drain err %d\n", 2836 __func__, ret); 2837 } 2838 2839 /* 2840 * _gpio_set_open_source_value() - Set the open source gpio's value. 2841 * @desc: gpio descriptor whose state need to be set. 2842 * @value: Non-zero for setting it HIGH otherwise it will set to LOW. 2843 */ 2844 static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value) 2845 { 2846 int ret = 0; 2847 struct gpio_chip *gc = desc->gdev->chip; 2848 int offset = gpio_chip_hwgpio(desc); 2849 2850 if (value) { 2851 ret = gc->direction_output(gc, offset, 1); 2852 if (!ret) 2853 set_bit(FLAG_IS_OUT, &desc->flags); 2854 } else { 2855 ret = gc->direction_input(gc, offset); 2856 } 2857 trace_gpio_direction(desc_to_gpio(desc), !value, ret); 2858 if (ret < 0) 2859 gpiod_err(desc, 2860 "%s: Error in set_value for open source err %d\n", 2861 __func__, ret); 2862 } 2863 2864 static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value) 2865 { 2866 struct gpio_chip *gc; 2867 2868 gc = desc->gdev->chip; 2869 trace_gpio_value(desc_to_gpio(desc), 0, value); 2870 gc->set(gc, gpio_chip_hwgpio(desc), value); 2871 } 2872 2873 /* 2874 * set multiple outputs on the same chip; 2875 * use the chip's set_multiple function if available; 2876 * otherwise set the outputs sequentially; 2877 * @chip: the GPIO chip we operate on 2878 * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word 2879 * defines which outputs are to be changed 2880 * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word 2881 * defines the values the outputs specified by mask are to be set to 2882 */ 2883 static void gpio_chip_set_multiple(struct gpio_chip *gc, 2884 unsigned long *mask, unsigned long *bits) 2885 { 2886 if (gc->set_multiple) { 2887 gc->set_multiple(gc, mask, bits); 2888 } else { 2889 unsigned int i; 2890 2891 /* set outputs if the corresponding mask bit is set */ 2892 for_each_set_bit(i, mask, gc->ngpio) 2893 gc->set(gc, i, test_bit(i, bits)); 2894 } 2895 } 2896 2897 int gpiod_set_array_value_complex(bool raw, bool can_sleep, 2898 unsigned int array_size, 2899 struct gpio_desc **desc_array, 2900 struct gpio_array *array_info, 2901 unsigned long *value_bitmap) 2902 { 2903 int i = 0; 2904 2905 /* 2906 * Validate array_info against desc_array and its size. 2907 * It should immediately follow desc_array if both 2908 * have been obtained from the same gpiod_get_array() call. 2909 */ 2910 if (array_info && array_info->desc == desc_array && 2911 array_size <= array_info->size && 2912 (void *)array_info == desc_array + array_info->size) { 2913 if (!can_sleep) 2914 WARN_ON(array_info->chip->can_sleep); 2915 2916 if (!raw && !bitmap_empty(array_info->invert_mask, array_size)) 2917 bitmap_xor(value_bitmap, value_bitmap, 2918 array_info->invert_mask, array_size); 2919 2920 gpio_chip_set_multiple(array_info->chip, array_info->set_mask, 2921 value_bitmap); 2922 2923 i = find_first_zero_bit(array_info->set_mask, array_size); 2924 if (i == array_size) 2925 return 0; 2926 } else { 2927 array_info = NULL; 2928 } 2929 2930 while (i < array_size) { 2931 struct gpio_chip *gc = desc_array[i]->gdev->chip; 2932 DECLARE_BITMAP(fastpath_mask, FASTPATH_NGPIO); 2933 DECLARE_BITMAP(fastpath_bits, FASTPATH_NGPIO); 2934 unsigned long *mask, *bits; 2935 int count = 0; 2936 2937 if (likely(gc->ngpio <= FASTPATH_NGPIO)) { 2938 mask = fastpath_mask; 2939 bits = fastpath_bits; 2940 } else { 2941 gfp_t flags = can_sleep ? GFP_KERNEL : GFP_ATOMIC; 2942 2943 mask = bitmap_alloc(gc->ngpio, flags); 2944 if (!mask) 2945 return -ENOMEM; 2946 2947 bits = bitmap_alloc(gc->ngpio, flags); 2948 if (!bits) { 2949 bitmap_free(mask); 2950 return -ENOMEM; 2951 } 2952 } 2953 2954 bitmap_zero(mask, gc->ngpio); 2955 2956 if (!can_sleep) 2957 WARN_ON(gc->can_sleep); 2958 2959 do { 2960 struct gpio_desc *desc = desc_array[i]; 2961 int hwgpio = gpio_chip_hwgpio(desc); 2962 int value = test_bit(i, value_bitmap); 2963 2964 /* 2965 * Pins applicable for fast input but not for 2966 * fast output processing may have been already 2967 * inverted inside the fast path, skip them. 2968 */ 2969 if (!raw && !(array_info && 2970 test_bit(i, array_info->invert_mask)) && 2971 test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 2972 value = !value; 2973 trace_gpio_value(desc_to_gpio(desc), 0, value); 2974 /* 2975 * collect all normal outputs belonging to the same chip 2976 * open drain and open source outputs are set individually 2977 */ 2978 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) { 2979 gpio_set_open_drain_value_commit(desc, value); 2980 } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) { 2981 gpio_set_open_source_value_commit(desc, value); 2982 } else { 2983 __set_bit(hwgpio, mask); 2984 __assign_bit(hwgpio, bits, value); 2985 count++; 2986 } 2987 i++; 2988 2989 if (array_info) 2990 i = find_next_zero_bit(array_info->set_mask, 2991 array_size, i); 2992 } while ((i < array_size) && 2993 (desc_array[i]->gdev->chip == gc)); 2994 /* push collected bits to outputs */ 2995 if (count != 0) 2996 gpio_chip_set_multiple(gc, mask, bits); 2997 2998 if (mask != fastpath_mask) 2999 bitmap_free(mask); 3000 if (bits != fastpath_bits) 3001 bitmap_free(bits); 3002 } 3003 return 0; 3004 } 3005 3006 /** 3007 * gpiod_set_raw_value() - assign a gpio's raw value 3008 * @desc: gpio whose value will be assigned 3009 * @value: value to assign 3010 * 3011 * Set the raw value of the GPIO, i.e. the value of its physical line without 3012 * regard for its ACTIVE_LOW status. 3013 * 3014 * This function can be called from contexts where we cannot sleep, and will 3015 * complain if the GPIO chip functions potentially sleep. 3016 */ 3017 void gpiod_set_raw_value(struct gpio_desc *desc, int value) 3018 { 3019 VALIDATE_DESC_VOID(desc); 3020 /* Should be using gpiod_set_raw_value_cansleep() */ 3021 WARN_ON(desc->gdev->chip->can_sleep); 3022 gpiod_set_raw_value_commit(desc, value); 3023 } 3024 EXPORT_SYMBOL_GPL(gpiod_set_raw_value); 3025 3026 /** 3027 * gpiod_set_value_nocheck() - set a GPIO line value without checking 3028 * @desc: the descriptor to set the value on 3029 * @value: value to set 3030 * 3031 * This sets the value of a GPIO line backing a descriptor, applying 3032 * different semantic quirks like active low and open drain/source 3033 * handling. 3034 */ 3035 static void gpiod_set_value_nocheck(struct gpio_desc *desc, int value) 3036 { 3037 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 3038 value = !value; 3039 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) 3040 gpio_set_open_drain_value_commit(desc, value); 3041 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) 3042 gpio_set_open_source_value_commit(desc, value); 3043 else 3044 gpiod_set_raw_value_commit(desc, value); 3045 } 3046 3047 /** 3048 * gpiod_set_value() - assign a gpio's value 3049 * @desc: gpio whose value will be assigned 3050 * @value: value to assign 3051 * 3052 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW, 3053 * OPEN_DRAIN and OPEN_SOURCE flags into account. 3054 * 3055 * This function can be called from contexts where we cannot sleep, and will 3056 * complain if the GPIO chip functions potentially sleep. 3057 */ 3058 void gpiod_set_value(struct gpio_desc *desc, int value) 3059 { 3060 VALIDATE_DESC_VOID(desc); 3061 /* Should be using gpiod_set_value_cansleep() */ 3062 WARN_ON(desc->gdev->chip->can_sleep); 3063 gpiod_set_value_nocheck(desc, value); 3064 } 3065 EXPORT_SYMBOL_GPL(gpiod_set_value); 3066 3067 /** 3068 * gpiod_set_raw_array_value() - assign values to an array of GPIOs 3069 * @array_size: number of elements in the descriptor array / value bitmap 3070 * @desc_array: array of GPIO descriptors whose values will be assigned 3071 * @array_info: information on applicability of fast bitmap processing path 3072 * @value_bitmap: bitmap of values to assign 3073 * 3074 * Set the raw values of the GPIOs, i.e. the values of the physical lines 3075 * without regard for their ACTIVE_LOW status. 3076 * 3077 * This function can be called from contexts where we cannot sleep, and will 3078 * complain if the GPIO chip functions potentially sleep. 3079 */ 3080 int gpiod_set_raw_array_value(unsigned int array_size, 3081 struct gpio_desc **desc_array, 3082 struct gpio_array *array_info, 3083 unsigned long *value_bitmap) 3084 { 3085 if (!desc_array) 3086 return -EINVAL; 3087 return gpiod_set_array_value_complex(true, false, array_size, 3088 desc_array, array_info, value_bitmap); 3089 } 3090 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value); 3091 3092 /** 3093 * gpiod_set_array_value() - assign values to an array of GPIOs 3094 * @array_size: number of elements in the descriptor array / value bitmap 3095 * @desc_array: array of GPIO descriptors whose values will be assigned 3096 * @array_info: information on applicability of fast bitmap processing path 3097 * @value_bitmap: bitmap of values to assign 3098 * 3099 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status 3100 * into account. 3101 * 3102 * This function can be called from contexts where we cannot sleep, and will 3103 * complain if the GPIO chip functions potentially sleep. 3104 */ 3105 int gpiod_set_array_value(unsigned int array_size, 3106 struct gpio_desc **desc_array, 3107 struct gpio_array *array_info, 3108 unsigned long *value_bitmap) 3109 { 3110 if (!desc_array) 3111 return -EINVAL; 3112 return gpiod_set_array_value_complex(false, false, array_size, 3113 desc_array, array_info, 3114 value_bitmap); 3115 } 3116 EXPORT_SYMBOL_GPL(gpiod_set_array_value); 3117 3118 /** 3119 * gpiod_cansleep() - report whether gpio value access may sleep 3120 * @desc: gpio to check 3121 * 3122 */ 3123 int gpiod_cansleep(const struct gpio_desc *desc) 3124 { 3125 VALIDATE_DESC(desc); 3126 return desc->gdev->chip->can_sleep; 3127 } 3128 EXPORT_SYMBOL_GPL(gpiod_cansleep); 3129 3130 /** 3131 * gpiod_set_consumer_name() - set the consumer name for the descriptor 3132 * @desc: gpio to set the consumer name on 3133 * @name: the new consumer name 3134 */ 3135 int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name) 3136 { 3137 VALIDATE_DESC(desc); 3138 if (name) { 3139 name = kstrdup_const(name, GFP_KERNEL); 3140 if (!name) 3141 return -ENOMEM; 3142 } 3143 3144 kfree_const(desc->label); 3145 desc_set_label(desc, name); 3146 3147 return 0; 3148 } 3149 EXPORT_SYMBOL_GPL(gpiod_set_consumer_name); 3150 3151 /** 3152 * gpiod_to_irq() - return the IRQ corresponding to a GPIO 3153 * @desc: gpio whose IRQ will be returned (already requested) 3154 * 3155 * Return the IRQ corresponding to the passed GPIO, or an error code in case of 3156 * error. 3157 */ 3158 int gpiod_to_irq(const struct gpio_desc *desc) 3159 { 3160 struct gpio_chip *gc; 3161 int offset; 3162 3163 /* 3164 * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics 3165 * requires this function to not return zero on an invalid descriptor 3166 * but rather a negative error number. 3167 */ 3168 if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip) 3169 return -EINVAL; 3170 3171 gc = desc->gdev->chip; 3172 offset = gpio_chip_hwgpio(desc); 3173 if (gc->to_irq) { 3174 int retirq = gc->to_irq(gc, offset); 3175 3176 /* Zero means NO_IRQ */ 3177 if (!retirq) 3178 return -ENXIO; 3179 3180 return retirq; 3181 } 3182 #ifdef CONFIG_GPIOLIB_IRQCHIP 3183 if (gc->irq.chip) { 3184 /* 3185 * Avoid race condition with other code, which tries to lookup 3186 * an IRQ before the irqchip has been properly registered, 3187 * i.e. while gpiochip is still being brought up. 3188 */ 3189 return -EPROBE_DEFER; 3190 } 3191 #endif 3192 return -ENXIO; 3193 } 3194 EXPORT_SYMBOL_GPL(gpiod_to_irq); 3195 3196 /** 3197 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ 3198 * @gc: the chip the GPIO to lock belongs to 3199 * @offset: the offset of the GPIO to lock as IRQ 3200 * 3201 * This is used directly by GPIO drivers that want to lock down 3202 * a certain GPIO line to be used for IRQs. 3203 */ 3204 int gpiochip_lock_as_irq(struct gpio_chip *gc, unsigned int offset) 3205 { 3206 struct gpio_desc *desc; 3207 3208 desc = gpiochip_get_desc(gc, offset); 3209 if (IS_ERR(desc)) 3210 return PTR_ERR(desc); 3211 3212 /* 3213 * If it's fast: flush the direction setting if something changed 3214 * behind our back 3215 */ 3216 if (!gc->can_sleep && gc->get_direction) { 3217 int dir = gpiod_get_direction(desc); 3218 3219 if (dir < 0) { 3220 chip_err(gc, "%s: cannot get GPIO direction\n", 3221 __func__); 3222 return dir; 3223 } 3224 } 3225 3226 /* To be valid for IRQ the line needs to be input or open drain */ 3227 if (test_bit(FLAG_IS_OUT, &desc->flags) && 3228 !test_bit(FLAG_OPEN_DRAIN, &desc->flags)) { 3229 chip_err(gc, 3230 "%s: tried to flag a GPIO set as output for IRQ\n", 3231 __func__); 3232 return -EIO; 3233 } 3234 3235 set_bit(FLAG_USED_AS_IRQ, &desc->flags); 3236 set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 3237 3238 /* 3239 * If the consumer has not set up a label (such as when the 3240 * IRQ is referenced from .to_irq()) we set up a label here 3241 * so it is clear this is used as an interrupt. 3242 */ 3243 if (!desc->label) 3244 desc_set_label(desc, "interrupt"); 3245 3246 return 0; 3247 } 3248 EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq); 3249 3250 /** 3251 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ 3252 * @gc: the chip the GPIO to lock belongs to 3253 * @offset: the offset of the GPIO to lock as IRQ 3254 * 3255 * This is used directly by GPIO drivers that want to indicate 3256 * that a certain GPIO is no longer used exclusively for IRQ. 3257 */ 3258 void gpiochip_unlock_as_irq(struct gpio_chip *gc, unsigned int offset) 3259 { 3260 struct gpio_desc *desc; 3261 3262 desc = gpiochip_get_desc(gc, offset); 3263 if (IS_ERR(desc)) 3264 return; 3265 3266 clear_bit(FLAG_USED_AS_IRQ, &desc->flags); 3267 clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 3268 3269 /* If we only had this marking, erase it */ 3270 if (desc->label && !strcmp(desc->label, "interrupt")) 3271 desc_set_label(desc, NULL); 3272 } 3273 EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq); 3274 3275 void gpiochip_disable_irq(struct gpio_chip *gc, unsigned int offset) 3276 { 3277 struct gpio_desc *desc = gpiochip_get_desc(gc, offset); 3278 3279 if (!IS_ERR(desc) && 3280 !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) 3281 clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 3282 } 3283 EXPORT_SYMBOL_GPL(gpiochip_disable_irq); 3284 3285 void gpiochip_enable_irq(struct gpio_chip *gc, unsigned int offset) 3286 { 3287 struct gpio_desc *desc = gpiochip_get_desc(gc, offset); 3288 3289 if (!IS_ERR(desc) && 3290 !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) { 3291 /* 3292 * We must not be output when using IRQ UNLESS we are 3293 * open drain. 3294 */ 3295 WARN_ON(test_bit(FLAG_IS_OUT, &desc->flags) && 3296 !test_bit(FLAG_OPEN_DRAIN, &desc->flags)); 3297 set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 3298 } 3299 } 3300 EXPORT_SYMBOL_GPL(gpiochip_enable_irq); 3301 3302 bool gpiochip_line_is_irq(struct gpio_chip *gc, unsigned int offset) 3303 { 3304 if (offset >= gc->ngpio) 3305 return false; 3306 3307 return test_bit(FLAG_USED_AS_IRQ, &gc->gpiodev->descs[offset].flags); 3308 } 3309 EXPORT_SYMBOL_GPL(gpiochip_line_is_irq); 3310 3311 int gpiochip_reqres_irq(struct gpio_chip *gc, unsigned int offset) 3312 { 3313 int ret; 3314 3315 if (!try_module_get(gc->gpiodev->owner)) 3316 return -ENODEV; 3317 3318 ret = gpiochip_lock_as_irq(gc, offset); 3319 if (ret) { 3320 chip_err(gc, "unable to lock HW IRQ %u for IRQ\n", offset); 3321 module_put(gc->gpiodev->owner); 3322 return ret; 3323 } 3324 return 0; 3325 } 3326 EXPORT_SYMBOL_GPL(gpiochip_reqres_irq); 3327 3328 void gpiochip_relres_irq(struct gpio_chip *gc, unsigned int offset) 3329 { 3330 gpiochip_unlock_as_irq(gc, offset); 3331 module_put(gc->gpiodev->owner); 3332 } 3333 EXPORT_SYMBOL_GPL(gpiochip_relres_irq); 3334 3335 bool gpiochip_line_is_open_drain(struct gpio_chip *gc, unsigned int offset) 3336 { 3337 if (offset >= gc->ngpio) 3338 return false; 3339 3340 return test_bit(FLAG_OPEN_DRAIN, &gc->gpiodev->descs[offset].flags); 3341 } 3342 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain); 3343 3344 bool gpiochip_line_is_open_source(struct gpio_chip *gc, unsigned int offset) 3345 { 3346 if (offset >= gc->ngpio) 3347 return false; 3348 3349 return test_bit(FLAG_OPEN_SOURCE, &gc->gpiodev->descs[offset].flags); 3350 } 3351 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source); 3352 3353 bool gpiochip_line_is_persistent(struct gpio_chip *gc, unsigned int offset) 3354 { 3355 if (offset >= gc->ngpio) 3356 return false; 3357 3358 return !test_bit(FLAG_TRANSITORY, &gc->gpiodev->descs[offset].flags); 3359 } 3360 EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent); 3361 3362 /** 3363 * gpiod_get_raw_value_cansleep() - return a gpio's raw value 3364 * @desc: gpio whose value will be returned 3365 * 3366 * Return the GPIO's raw value, i.e. the value of the physical line disregarding 3367 * its ACTIVE_LOW status, or negative errno on failure. 3368 * 3369 * This function is to be called from contexts that can sleep. 3370 */ 3371 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc) 3372 { 3373 might_sleep_if(extra_checks); 3374 VALIDATE_DESC(desc); 3375 return gpiod_get_raw_value_commit(desc); 3376 } 3377 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep); 3378 3379 /** 3380 * gpiod_get_value_cansleep() - return a gpio's value 3381 * @desc: gpio whose value will be returned 3382 * 3383 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into 3384 * account, or negative errno on failure. 3385 * 3386 * This function is to be called from contexts that can sleep. 3387 */ 3388 int gpiod_get_value_cansleep(const struct gpio_desc *desc) 3389 { 3390 int value; 3391 3392 might_sleep_if(extra_checks); 3393 VALIDATE_DESC(desc); 3394 value = gpiod_get_raw_value_commit(desc); 3395 if (value < 0) 3396 return value; 3397 3398 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 3399 value = !value; 3400 3401 return value; 3402 } 3403 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep); 3404 3405 /** 3406 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs 3407 * @array_size: number of elements in the descriptor array / value bitmap 3408 * @desc_array: array of GPIO descriptors whose values will be read 3409 * @array_info: information on applicability of fast bitmap processing path 3410 * @value_bitmap: bitmap to store the read values 3411 * 3412 * Read the raw values of the GPIOs, i.e. the values of the physical lines 3413 * without regard for their ACTIVE_LOW status. Return 0 in case of success, 3414 * else an error code. 3415 * 3416 * This function is to be called from contexts that can sleep. 3417 */ 3418 int gpiod_get_raw_array_value_cansleep(unsigned int array_size, 3419 struct gpio_desc **desc_array, 3420 struct gpio_array *array_info, 3421 unsigned long *value_bitmap) 3422 { 3423 might_sleep_if(extra_checks); 3424 if (!desc_array) 3425 return -EINVAL; 3426 return gpiod_get_array_value_complex(true, true, array_size, 3427 desc_array, array_info, 3428 value_bitmap); 3429 } 3430 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep); 3431 3432 /** 3433 * gpiod_get_array_value_cansleep() - read values from an array of GPIOs 3434 * @array_size: number of elements in the descriptor array / value bitmap 3435 * @desc_array: array of GPIO descriptors whose values will be read 3436 * @array_info: information on applicability of fast bitmap processing path 3437 * @value_bitmap: bitmap to store the read values 3438 * 3439 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status 3440 * into account. Return 0 in case of success, else an error code. 3441 * 3442 * This function is to be called from contexts that can sleep. 3443 */ 3444 int gpiod_get_array_value_cansleep(unsigned int array_size, 3445 struct gpio_desc **desc_array, 3446 struct gpio_array *array_info, 3447 unsigned long *value_bitmap) 3448 { 3449 might_sleep_if(extra_checks); 3450 if (!desc_array) 3451 return -EINVAL; 3452 return gpiod_get_array_value_complex(false, true, array_size, 3453 desc_array, array_info, 3454 value_bitmap); 3455 } 3456 EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep); 3457 3458 /** 3459 * gpiod_set_raw_value_cansleep() - assign a gpio's raw value 3460 * @desc: gpio whose value will be assigned 3461 * @value: value to assign 3462 * 3463 * Set the raw value of the GPIO, i.e. the value of its physical line without 3464 * regard for its ACTIVE_LOW status. 3465 * 3466 * This function is to be called from contexts that can sleep. 3467 */ 3468 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value) 3469 { 3470 might_sleep_if(extra_checks); 3471 VALIDATE_DESC_VOID(desc); 3472 gpiod_set_raw_value_commit(desc, value); 3473 } 3474 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep); 3475 3476 /** 3477 * gpiod_set_value_cansleep() - assign a gpio's value 3478 * @desc: gpio whose value will be assigned 3479 * @value: value to assign 3480 * 3481 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into 3482 * account 3483 * 3484 * This function is to be called from contexts that can sleep. 3485 */ 3486 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) 3487 { 3488 might_sleep_if(extra_checks); 3489 VALIDATE_DESC_VOID(desc); 3490 gpiod_set_value_nocheck(desc, value); 3491 } 3492 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep); 3493 3494 /** 3495 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs 3496 * @array_size: number of elements in the descriptor array / value bitmap 3497 * @desc_array: array of GPIO descriptors whose values will be assigned 3498 * @array_info: information on applicability of fast bitmap processing path 3499 * @value_bitmap: bitmap of values to assign 3500 * 3501 * Set the raw values of the GPIOs, i.e. the values of the physical lines 3502 * without regard for their ACTIVE_LOW status. 3503 * 3504 * This function is to be called from contexts that can sleep. 3505 */ 3506 int gpiod_set_raw_array_value_cansleep(unsigned int array_size, 3507 struct gpio_desc **desc_array, 3508 struct gpio_array *array_info, 3509 unsigned long *value_bitmap) 3510 { 3511 might_sleep_if(extra_checks); 3512 if (!desc_array) 3513 return -EINVAL; 3514 return gpiod_set_array_value_complex(true, true, array_size, desc_array, 3515 array_info, value_bitmap); 3516 } 3517 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep); 3518 3519 /** 3520 * gpiod_add_lookup_tables() - register GPIO device consumers 3521 * @tables: list of tables of consumers to register 3522 * @n: number of tables in the list 3523 */ 3524 void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n) 3525 { 3526 unsigned int i; 3527 3528 mutex_lock(&gpio_lookup_lock); 3529 3530 for (i = 0; i < n; i++) 3531 list_add_tail(&tables[i]->list, &gpio_lookup_list); 3532 3533 mutex_unlock(&gpio_lookup_lock); 3534 } 3535 3536 /** 3537 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs 3538 * @array_size: number of elements in the descriptor array / value bitmap 3539 * @desc_array: array of GPIO descriptors whose values will be assigned 3540 * @array_info: information on applicability of fast bitmap processing path 3541 * @value_bitmap: bitmap of values to assign 3542 * 3543 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status 3544 * into account. 3545 * 3546 * This function is to be called from contexts that can sleep. 3547 */ 3548 int gpiod_set_array_value_cansleep(unsigned int array_size, 3549 struct gpio_desc **desc_array, 3550 struct gpio_array *array_info, 3551 unsigned long *value_bitmap) 3552 { 3553 might_sleep_if(extra_checks); 3554 if (!desc_array) 3555 return -EINVAL; 3556 return gpiod_set_array_value_complex(false, true, array_size, 3557 desc_array, array_info, 3558 value_bitmap); 3559 } 3560 EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep); 3561 3562 /** 3563 * gpiod_add_lookup_table() - register GPIO device consumers 3564 * @table: table of consumers to register 3565 */ 3566 void gpiod_add_lookup_table(struct gpiod_lookup_table *table) 3567 { 3568 gpiod_add_lookup_tables(&table, 1); 3569 } 3570 EXPORT_SYMBOL_GPL(gpiod_add_lookup_table); 3571 3572 /** 3573 * gpiod_remove_lookup_table() - unregister GPIO device consumers 3574 * @table: table of consumers to unregister 3575 */ 3576 void gpiod_remove_lookup_table(struct gpiod_lookup_table *table) 3577 { 3578 /* Nothing to remove */ 3579 if (!table) 3580 return; 3581 3582 mutex_lock(&gpio_lookup_lock); 3583 3584 list_del(&table->list); 3585 3586 mutex_unlock(&gpio_lookup_lock); 3587 } 3588 EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table); 3589 3590 /** 3591 * gpiod_add_hogs() - register a set of GPIO hogs from machine code 3592 * @hogs: table of gpio hog entries with a zeroed sentinel at the end 3593 */ 3594 void gpiod_add_hogs(struct gpiod_hog *hogs) 3595 { 3596 struct gpio_chip *gc; 3597 struct gpiod_hog *hog; 3598 3599 mutex_lock(&gpio_machine_hogs_mutex); 3600 3601 for (hog = &hogs[0]; hog->chip_label; hog++) { 3602 list_add_tail(&hog->list, &gpio_machine_hogs); 3603 3604 /* 3605 * The chip may have been registered earlier, so check if it 3606 * exists and, if so, try to hog the line now. 3607 */ 3608 gc = find_chip_by_name(hog->chip_label); 3609 if (gc) 3610 gpiochip_machine_hog(gc, hog); 3611 } 3612 3613 mutex_unlock(&gpio_machine_hogs_mutex); 3614 } 3615 EXPORT_SYMBOL_GPL(gpiod_add_hogs); 3616 3617 void gpiod_remove_hogs(struct gpiod_hog *hogs) 3618 { 3619 struct gpiod_hog *hog; 3620 3621 mutex_lock(&gpio_machine_hogs_mutex); 3622 for (hog = &hogs[0]; hog->chip_label; hog++) 3623 list_del(&hog->list); 3624 mutex_unlock(&gpio_machine_hogs_mutex); 3625 } 3626 EXPORT_SYMBOL_GPL(gpiod_remove_hogs); 3627 3628 static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev) 3629 { 3630 const char *dev_id = dev ? dev_name(dev) : NULL; 3631 struct gpiod_lookup_table *table; 3632 3633 mutex_lock(&gpio_lookup_lock); 3634 3635 list_for_each_entry(table, &gpio_lookup_list, list) { 3636 if (table->dev_id && dev_id) { 3637 /* 3638 * Valid strings on both ends, must be identical to have 3639 * a match 3640 */ 3641 if (!strcmp(table->dev_id, dev_id)) 3642 goto found; 3643 } else { 3644 /* 3645 * One of the pointers is NULL, so both must be to have 3646 * a match 3647 */ 3648 if (dev_id == table->dev_id) 3649 goto found; 3650 } 3651 } 3652 table = NULL; 3653 3654 found: 3655 mutex_unlock(&gpio_lookup_lock); 3656 return table; 3657 } 3658 3659 static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id, 3660 unsigned int idx, unsigned long *flags) 3661 { 3662 struct gpio_desc *desc = ERR_PTR(-ENOENT); 3663 struct gpiod_lookup_table *table; 3664 struct gpiod_lookup *p; 3665 3666 table = gpiod_find_lookup_table(dev); 3667 if (!table) 3668 return desc; 3669 3670 for (p = &table->table[0]; p->key; p++) { 3671 struct gpio_chip *gc; 3672 3673 /* idx must always match exactly */ 3674 if (p->idx != idx) 3675 continue; 3676 3677 /* If the lookup entry has a con_id, require exact match */ 3678 if (p->con_id && (!con_id || strcmp(p->con_id, con_id))) 3679 continue; 3680 3681 if (p->chip_hwnum == U16_MAX) { 3682 desc = gpio_name_to_desc(p->key); 3683 if (desc) { 3684 *flags = p->flags; 3685 return desc; 3686 } 3687 3688 dev_warn(dev, "cannot find GPIO line %s, deferring\n", 3689 p->key); 3690 return ERR_PTR(-EPROBE_DEFER); 3691 } 3692 3693 gc = find_chip_by_name(p->key); 3694 3695 if (!gc) { 3696 /* 3697 * As the lookup table indicates a chip with 3698 * p->key should exist, assume it may 3699 * still appear later and let the interested 3700 * consumer be probed again or let the Deferred 3701 * Probe infrastructure handle the error. 3702 */ 3703 dev_warn(dev, "cannot find GPIO chip %s, deferring\n", 3704 p->key); 3705 return ERR_PTR(-EPROBE_DEFER); 3706 } 3707 3708 if (gc->ngpio <= p->chip_hwnum) { 3709 dev_err(dev, 3710 "requested GPIO %u (%u) is out of range [0..%u] for chip %s\n", 3711 idx, p->chip_hwnum, gc->ngpio - 1, 3712 gc->label); 3713 return ERR_PTR(-EINVAL); 3714 } 3715 3716 desc = gpiochip_get_desc(gc, p->chip_hwnum); 3717 *flags = p->flags; 3718 3719 return desc; 3720 } 3721 3722 return desc; 3723 } 3724 3725 static int platform_gpio_count(struct device *dev, const char *con_id) 3726 { 3727 struct gpiod_lookup_table *table; 3728 struct gpiod_lookup *p; 3729 unsigned int count = 0; 3730 3731 table = gpiod_find_lookup_table(dev); 3732 if (!table) 3733 return -ENOENT; 3734 3735 for (p = &table->table[0]; p->key; p++) { 3736 if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) || 3737 (!con_id && !p->con_id)) 3738 count++; 3739 } 3740 if (!count) 3741 return -ENOENT; 3742 3743 return count; 3744 } 3745 3746 /** 3747 * fwnode_gpiod_get_index - obtain a GPIO from firmware node 3748 * @fwnode: handle of the firmware node 3749 * @con_id: function within the GPIO consumer 3750 * @index: index of the GPIO to obtain for the consumer 3751 * @flags: GPIO initialization flags 3752 * @label: label to attach to the requested GPIO 3753 * 3754 * This function can be used for drivers that get their configuration 3755 * from opaque firmware. 3756 * 3757 * The function properly finds the corresponding GPIO using whatever is the 3758 * underlying firmware interface and then makes sure that the GPIO 3759 * descriptor is requested before it is returned to the caller. 3760 * 3761 * Returns: 3762 * On successful request the GPIO pin is configured in accordance with 3763 * provided @flags. 3764 * 3765 * In case of error an ERR_PTR() is returned. 3766 */ 3767 struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode, 3768 const char *con_id, int index, 3769 enum gpiod_flags flags, 3770 const char *label) 3771 { 3772 struct gpio_desc *desc; 3773 char prop_name[32]; /* 32 is max size of property name */ 3774 unsigned int i; 3775 3776 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 3777 if (con_id) 3778 snprintf(prop_name, sizeof(prop_name), "%s-%s", 3779 con_id, gpio_suffixes[i]); 3780 else 3781 snprintf(prop_name, sizeof(prop_name), "%s", 3782 gpio_suffixes[i]); 3783 3784 desc = fwnode_get_named_gpiod(fwnode, prop_name, index, flags, 3785 label); 3786 if (!gpiod_not_found(desc)) 3787 break; 3788 } 3789 3790 return desc; 3791 } 3792 EXPORT_SYMBOL_GPL(fwnode_gpiod_get_index); 3793 3794 /** 3795 * gpiod_count - return the number of GPIOs associated with a device / function 3796 * or -ENOENT if no GPIO has been assigned to the requested function 3797 * @dev: GPIO consumer, can be NULL for system-global GPIOs 3798 * @con_id: function within the GPIO consumer 3799 */ 3800 int gpiod_count(struct device *dev, const char *con_id) 3801 { 3802 const struct fwnode_handle *fwnode = dev ? dev_fwnode(dev) : NULL; 3803 int count = -ENOENT; 3804 3805 if (is_of_node(fwnode)) 3806 count = of_gpio_get_count(dev, con_id); 3807 else if (is_acpi_node(fwnode)) 3808 count = acpi_gpio_count(dev, con_id); 3809 3810 if (count < 0) 3811 count = platform_gpio_count(dev, con_id); 3812 3813 return count; 3814 } 3815 EXPORT_SYMBOL_GPL(gpiod_count); 3816 3817 /** 3818 * gpiod_get - obtain a GPIO for a given GPIO function 3819 * @dev: GPIO consumer, can be NULL for system-global GPIOs 3820 * @con_id: function within the GPIO consumer 3821 * @flags: optional GPIO initialization flags 3822 * 3823 * Return the GPIO descriptor corresponding to the function con_id of device 3824 * dev, -ENOENT if no GPIO has been assigned to the requested function, or 3825 * another IS_ERR() code if an error occurred while trying to acquire the GPIO. 3826 */ 3827 struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id, 3828 enum gpiod_flags flags) 3829 { 3830 return gpiod_get_index(dev, con_id, 0, flags); 3831 } 3832 EXPORT_SYMBOL_GPL(gpiod_get); 3833 3834 /** 3835 * gpiod_get_optional - obtain an optional GPIO for a given GPIO function 3836 * @dev: GPIO consumer, can be NULL for system-global GPIOs 3837 * @con_id: function within the GPIO consumer 3838 * @flags: optional GPIO initialization flags 3839 * 3840 * This is equivalent to gpiod_get(), except that when no GPIO was assigned to 3841 * the requested function it will return NULL. This is convenient for drivers 3842 * that need to handle optional GPIOs. 3843 */ 3844 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev, 3845 const char *con_id, 3846 enum gpiod_flags flags) 3847 { 3848 return gpiod_get_index_optional(dev, con_id, 0, flags); 3849 } 3850 EXPORT_SYMBOL_GPL(gpiod_get_optional); 3851 3852 3853 /** 3854 * gpiod_configure_flags - helper function to configure a given GPIO 3855 * @desc: gpio whose value will be assigned 3856 * @con_id: function within the GPIO consumer 3857 * @lflags: bitmask of gpio_lookup_flags GPIO_* values - returned from 3858 * of_find_gpio() or of_get_gpio_hog() 3859 * @dflags: gpiod_flags - optional GPIO initialization flags 3860 * 3861 * Return 0 on success, -ENOENT if no GPIO has been assigned to the 3862 * requested function and/or index, or another IS_ERR() code if an error 3863 * occurred while trying to acquire the GPIO. 3864 */ 3865 int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id, 3866 unsigned long lflags, enum gpiod_flags dflags) 3867 { 3868 int ret; 3869 3870 if (lflags & GPIO_ACTIVE_LOW) 3871 set_bit(FLAG_ACTIVE_LOW, &desc->flags); 3872 3873 if (lflags & GPIO_OPEN_DRAIN) 3874 set_bit(FLAG_OPEN_DRAIN, &desc->flags); 3875 else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) { 3876 /* 3877 * This enforces open drain mode from the consumer side. 3878 * This is necessary for some busses like I2C, but the lookup 3879 * should *REALLY* have specified them as open drain in the 3880 * first place, so print a little warning here. 3881 */ 3882 set_bit(FLAG_OPEN_DRAIN, &desc->flags); 3883 gpiod_warn(desc, 3884 "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n"); 3885 } 3886 3887 if (lflags & GPIO_OPEN_SOURCE) 3888 set_bit(FLAG_OPEN_SOURCE, &desc->flags); 3889 3890 if ((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DOWN)) { 3891 gpiod_err(desc, 3892 "both pull-up and pull-down enabled, invalid configuration\n"); 3893 return -EINVAL; 3894 } 3895 3896 if (lflags & GPIO_PULL_UP) 3897 set_bit(FLAG_PULL_UP, &desc->flags); 3898 else if (lflags & GPIO_PULL_DOWN) 3899 set_bit(FLAG_PULL_DOWN, &desc->flags); 3900 3901 ret = gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY)); 3902 if (ret < 0) 3903 return ret; 3904 3905 /* No particular flag request, return here... */ 3906 if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) { 3907 gpiod_dbg(desc, "no flags found for %s\n", con_id); 3908 return 0; 3909 } 3910 3911 /* Process flags */ 3912 if (dflags & GPIOD_FLAGS_BIT_DIR_OUT) 3913 ret = gpiod_direction_output(desc, 3914 !!(dflags & GPIOD_FLAGS_BIT_DIR_VAL)); 3915 else 3916 ret = gpiod_direction_input(desc); 3917 3918 return ret; 3919 } 3920 3921 /** 3922 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function 3923 * @dev: GPIO consumer, can be NULL for system-global GPIOs 3924 * @con_id: function within the GPIO consumer 3925 * @idx: index of the GPIO to obtain in the consumer 3926 * @flags: optional GPIO initialization flags 3927 * 3928 * This variant of gpiod_get() allows to access GPIOs other than the first 3929 * defined one for functions that define several GPIOs. 3930 * 3931 * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the 3932 * requested function and/or index, or another IS_ERR() code if an error 3933 * occurred while trying to acquire the GPIO. 3934 */ 3935 struct gpio_desc *__must_check gpiod_get_index(struct device *dev, 3936 const char *con_id, 3937 unsigned int idx, 3938 enum gpiod_flags flags) 3939 { 3940 unsigned long lookupflags = GPIO_LOOKUP_FLAGS_DEFAULT; 3941 struct gpio_desc *desc = NULL; 3942 int ret; 3943 /* Maybe we have a device name, maybe not */ 3944 const char *devname = dev ? dev_name(dev) : "?"; 3945 const struct fwnode_handle *fwnode = dev ? dev_fwnode(dev) : NULL; 3946 3947 dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id); 3948 3949 /* Using device tree? */ 3950 if (is_of_node(fwnode)) { 3951 dev_dbg(dev, "using device tree for GPIO lookup\n"); 3952 desc = of_find_gpio(dev, con_id, idx, &lookupflags); 3953 } else if (is_acpi_node(fwnode)) { 3954 dev_dbg(dev, "using ACPI for GPIO lookup\n"); 3955 desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags); 3956 } 3957 3958 /* 3959 * Either we are not using DT or ACPI, or their lookup did not return 3960 * a result. In that case, use platform lookup as a fallback. 3961 */ 3962 if (!desc || gpiod_not_found(desc)) { 3963 dev_dbg(dev, "using lookup tables for GPIO lookup\n"); 3964 desc = gpiod_find(dev, con_id, idx, &lookupflags); 3965 } 3966 3967 if (IS_ERR(desc)) { 3968 dev_dbg(dev, "No GPIO consumer %s found\n", con_id); 3969 return desc; 3970 } 3971 3972 /* 3973 * If a connection label was passed use that, else attempt to use 3974 * the device name as label 3975 */ 3976 ret = gpiod_request(desc, con_id ?: devname); 3977 if (ret) { 3978 if (!(ret == -EBUSY && flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE)) 3979 return ERR_PTR(ret); 3980 3981 /* 3982 * This happens when there are several consumers for 3983 * the same GPIO line: we just return here without 3984 * further initialization. It is a bit of a hack. 3985 * This is necessary to support fixed regulators. 3986 * 3987 * FIXME: Make this more sane and safe. 3988 */ 3989 dev_info(dev, "nonexclusive access to GPIO for %s\n", con_id ?: devname); 3990 return desc; 3991 } 3992 3993 ret = gpiod_configure_flags(desc, con_id, lookupflags, flags); 3994 if (ret < 0) { 3995 dev_dbg(dev, "setup of GPIO %s failed\n", con_id); 3996 gpiod_put(desc); 3997 return ERR_PTR(ret); 3998 } 3999 4000 blocking_notifier_call_chain(&desc->gdev->notifier, 4001 GPIOLINE_CHANGED_REQUESTED, desc); 4002 4003 return desc; 4004 } 4005 EXPORT_SYMBOL_GPL(gpiod_get_index); 4006 4007 /** 4008 * fwnode_get_named_gpiod - obtain a GPIO from firmware node 4009 * @fwnode: handle of the firmware node 4010 * @propname: name of the firmware property representing the GPIO 4011 * @index: index of the GPIO to obtain for the consumer 4012 * @dflags: GPIO initialization flags 4013 * @label: label to attach to the requested GPIO 4014 * 4015 * This function can be used for drivers that get their configuration 4016 * from opaque firmware. 4017 * 4018 * The function properly finds the corresponding GPIO using whatever is the 4019 * underlying firmware interface and then makes sure that the GPIO 4020 * descriptor is requested before it is returned to the caller. 4021 * 4022 * Returns: 4023 * On successful request the GPIO pin is configured in accordance with 4024 * provided @dflags. 4025 * 4026 * In case of error an ERR_PTR() is returned. 4027 */ 4028 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode, 4029 const char *propname, int index, 4030 enum gpiod_flags dflags, 4031 const char *label) 4032 { 4033 unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT; 4034 struct gpio_desc *desc = ERR_PTR(-ENODEV); 4035 int ret; 4036 4037 if (is_of_node(fwnode)) { 4038 desc = gpiod_get_from_of_node(to_of_node(fwnode), 4039 propname, index, 4040 dflags, 4041 label); 4042 return desc; 4043 } else if (is_acpi_node(fwnode)) { 4044 struct acpi_gpio_info info; 4045 4046 desc = acpi_node_get_gpiod(fwnode, propname, index, &info); 4047 if (IS_ERR(desc)) 4048 return desc; 4049 4050 acpi_gpio_update_gpiod_flags(&dflags, &info); 4051 acpi_gpio_update_gpiod_lookup_flags(&lflags, &info); 4052 } else 4053 return ERR_PTR(-EINVAL); 4054 4055 /* Currently only ACPI takes this path */ 4056 ret = gpiod_request(desc, label); 4057 if (ret) 4058 return ERR_PTR(ret); 4059 4060 ret = gpiod_configure_flags(desc, propname, lflags, dflags); 4061 if (ret < 0) { 4062 gpiod_put(desc); 4063 return ERR_PTR(ret); 4064 } 4065 4066 blocking_notifier_call_chain(&desc->gdev->notifier, 4067 GPIOLINE_CHANGED_REQUESTED, desc); 4068 4069 return desc; 4070 } 4071 EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod); 4072 4073 /** 4074 * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO 4075 * function 4076 * @dev: GPIO consumer, can be NULL for system-global GPIOs 4077 * @con_id: function within the GPIO consumer 4078 * @index: index of the GPIO to obtain in the consumer 4079 * @flags: optional GPIO initialization flags 4080 * 4081 * This is equivalent to gpiod_get_index(), except that when no GPIO with the 4082 * specified index was assigned to the requested function it will return NULL. 4083 * This is convenient for drivers that need to handle optional GPIOs. 4084 */ 4085 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev, 4086 const char *con_id, 4087 unsigned int index, 4088 enum gpiod_flags flags) 4089 { 4090 struct gpio_desc *desc; 4091 4092 desc = gpiod_get_index(dev, con_id, index, flags); 4093 if (gpiod_not_found(desc)) 4094 return NULL; 4095 4096 return desc; 4097 } 4098 EXPORT_SYMBOL_GPL(gpiod_get_index_optional); 4099 4100 /** 4101 * gpiod_hog - Hog the specified GPIO desc given the provided flags 4102 * @desc: gpio whose value will be assigned 4103 * @name: gpio line name 4104 * @lflags: bitmask of gpio_lookup_flags GPIO_* values - returned from 4105 * of_find_gpio() or of_get_gpio_hog() 4106 * @dflags: gpiod_flags - optional GPIO initialization flags 4107 */ 4108 int gpiod_hog(struct gpio_desc *desc, const char *name, 4109 unsigned long lflags, enum gpiod_flags dflags) 4110 { 4111 struct gpio_chip *gc; 4112 struct gpio_desc *local_desc; 4113 int hwnum; 4114 int ret; 4115 4116 gc = gpiod_to_chip(desc); 4117 hwnum = gpio_chip_hwgpio(desc); 4118 4119 local_desc = gpiochip_request_own_desc(gc, hwnum, name, 4120 lflags, dflags); 4121 if (IS_ERR(local_desc)) { 4122 ret = PTR_ERR(local_desc); 4123 pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n", 4124 name, gc->label, hwnum, ret); 4125 return ret; 4126 } 4127 4128 /* Mark GPIO as hogged so it can be identified and removed later */ 4129 set_bit(FLAG_IS_HOGGED, &desc->flags); 4130 4131 gpiod_info(desc, "hogged as %s%s\n", 4132 (dflags & GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input", 4133 (dflags & GPIOD_FLAGS_BIT_DIR_OUT) ? 4134 (dflags & GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low" : ""); 4135 4136 return 0; 4137 } 4138 4139 /** 4140 * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog 4141 * @gc: gpio chip to act on 4142 */ 4143 static void gpiochip_free_hogs(struct gpio_chip *gc) 4144 { 4145 struct gpio_desc *desc; 4146 4147 for_each_gpio_desc_with_flag(gc, desc, FLAG_IS_HOGGED) 4148 gpiochip_free_own_desc(desc); 4149 } 4150 4151 /** 4152 * gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function 4153 * @dev: GPIO consumer, can be NULL for system-global GPIOs 4154 * @con_id: function within the GPIO consumer 4155 * @flags: optional GPIO initialization flags 4156 * 4157 * This function acquires all the GPIOs defined under a given function. 4158 * 4159 * Return a struct gpio_descs containing an array of descriptors, -ENOENT if 4160 * no GPIO has been assigned to the requested function, or another IS_ERR() 4161 * code if an error occurred while trying to acquire the GPIOs. 4162 */ 4163 struct gpio_descs *__must_check gpiod_get_array(struct device *dev, 4164 const char *con_id, 4165 enum gpiod_flags flags) 4166 { 4167 struct gpio_desc *desc; 4168 struct gpio_descs *descs; 4169 struct gpio_array *array_info = NULL; 4170 struct gpio_chip *gc; 4171 int count, bitmap_size; 4172 4173 count = gpiod_count(dev, con_id); 4174 if (count < 0) 4175 return ERR_PTR(count); 4176 4177 descs = kzalloc(struct_size(descs, desc, count), GFP_KERNEL); 4178 if (!descs) 4179 return ERR_PTR(-ENOMEM); 4180 4181 for (descs->ndescs = 0; descs->ndescs < count; ) { 4182 desc = gpiod_get_index(dev, con_id, descs->ndescs, flags); 4183 if (IS_ERR(desc)) { 4184 gpiod_put_array(descs); 4185 return ERR_CAST(desc); 4186 } 4187 4188 descs->desc[descs->ndescs] = desc; 4189 4190 gc = gpiod_to_chip(desc); 4191 /* 4192 * If pin hardware number of array member 0 is also 0, select 4193 * its chip as a candidate for fast bitmap processing path. 4194 */ 4195 if (descs->ndescs == 0 && gpio_chip_hwgpio(desc) == 0) { 4196 struct gpio_descs *array; 4197 4198 bitmap_size = BITS_TO_LONGS(gc->ngpio > count ? 4199 gc->ngpio : count); 4200 4201 array = kzalloc(struct_size(descs, desc, count) + 4202 struct_size(array_info, invert_mask, 4203 3 * bitmap_size), GFP_KERNEL); 4204 if (!array) { 4205 gpiod_put_array(descs); 4206 return ERR_PTR(-ENOMEM); 4207 } 4208 4209 memcpy(array, descs, 4210 struct_size(descs, desc, descs->ndescs + 1)); 4211 kfree(descs); 4212 4213 descs = array; 4214 array_info = (void *)(descs->desc + count); 4215 array_info->get_mask = array_info->invert_mask + 4216 bitmap_size; 4217 array_info->set_mask = array_info->get_mask + 4218 bitmap_size; 4219 4220 array_info->desc = descs->desc; 4221 array_info->size = count; 4222 array_info->chip = gc; 4223 bitmap_set(array_info->get_mask, descs->ndescs, 4224 count - descs->ndescs); 4225 bitmap_set(array_info->set_mask, descs->ndescs, 4226 count - descs->ndescs); 4227 descs->info = array_info; 4228 } 4229 /* Unmark array members which don't belong to the 'fast' chip */ 4230 if (array_info && array_info->chip != gc) { 4231 __clear_bit(descs->ndescs, array_info->get_mask); 4232 __clear_bit(descs->ndescs, array_info->set_mask); 4233 } 4234 /* 4235 * Detect array members which belong to the 'fast' chip 4236 * but their pins are not in hardware order. 4237 */ 4238 else if (array_info && 4239 gpio_chip_hwgpio(desc) != descs->ndescs) { 4240 /* 4241 * Don't use fast path if all array members processed so 4242 * far belong to the same chip as this one but its pin 4243 * hardware number is different from its array index. 4244 */ 4245 if (bitmap_full(array_info->get_mask, descs->ndescs)) { 4246 array_info = NULL; 4247 } else { 4248 __clear_bit(descs->ndescs, 4249 array_info->get_mask); 4250 __clear_bit(descs->ndescs, 4251 array_info->set_mask); 4252 } 4253 } else if (array_info) { 4254 /* Exclude open drain or open source from fast output */ 4255 if (gpiochip_line_is_open_drain(gc, descs->ndescs) || 4256 gpiochip_line_is_open_source(gc, descs->ndescs)) 4257 __clear_bit(descs->ndescs, 4258 array_info->set_mask); 4259 /* Identify 'fast' pins which require invertion */ 4260 if (gpiod_is_active_low(desc)) 4261 __set_bit(descs->ndescs, 4262 array_info->invert_mask); 4263 } 4264 4265 descs->ndescs++; 4266 } 4267 if (array_info) 4268 dev_dbg(dev, 4269 "GPIO array info: chip=%s, size=%d, get_mask=%lx, set_mask=%lx, invert_mask=%lx\n", 4270 array_info->chip->label, array_info->size, 4271 *array_info->get_mask, *array_info->set_mask, 4272 *array_info->invert_mask); 4273 return descs; 4274 } 4275 EXPORT_SYMBOL_GPL(gpiod_get_array); 4276 4277 /** 4278 * gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO 4279 * function 4280 * @dev: GPIO consumer, can be NULL for system-global GPIOs 4281 * @con_id: function within the GPIO consumer 4282 * @flags: optional GPIO initialization flags 4283 * 4284 * This is equivalent to gpiod_get_array(), except that when no GPIO was 4285 * assigned to the requested function it will return NULL. 4286 */ 4287 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev, 4288 const char *con_id, 4289 enum gpiod_flags flags) 4290 { 4291 struct gpio_descs *descs; 4292 4293 descs = gpiod_get_array(dev, con_id, flags); 4294 if (gpiod_not_found(descs)) 4295 return NULL; 4296 4297 return descs; 4298 } 4299 EXPORT_SYMBOL_GPL(gpiod_get_array_optional); 4300 4301 /** 4302 * gpiod_put - dispose of a GPIO descriptor 4303 * @desc: GPIO descriptor to dispose of 4304 * 4305 * No descriptor can be used after gpiod_put() has been called on it. 4306 */ 4307 void gpiod_put(struct gpio_desc *desc) 4308 { 4309 if (desc) 4310 gpiod_free(desc); 4311 } 4312 EXPORT_SYMBOL_GPL(gpiod_put); 4313 4314 /** 4315 * gpiod_put_array - dispose of multiple GPIO descriptors 4316 * @descs: struct gpio_descs containing an array of descriptors 4317 */ 4318 void gpiod_put_array(struct gpio_descs *descs) 4319 { 4320 unsigned int i; 4321 4322 for (i = 0; i < descs->ndescs; i++) 4323 gpiod_put(descs->desc[i]); 4324 4325 kfree(descs); 4326 } 4327 EXPORT_SYMBOL_GPL(gpiod_put_array); 4328 4329 4330 static int gpio_bus_match(struct device *dev, struct device_driver *drv) 4331 { 4332 struct fwnode_handle *fwnode = dev_fwnode(dev); 4333 4334 /* 4335 * Only match if the fwnode doesn't already have a proper struct device 4336 * created for it. 4337 */ 4338 if (fwnode && fwnode->dev != dev) 4339 return 0; 4340 return 1; 4341 } 4342 4343 static int gpio_stub_drv_probe(struct device *dev) 4344 { 4345 /* 4346 * The DT node of some GPIO chips have a "compatible" property, but 4347 * never have a struct device added and probed by a driver to register 4348 * the GPIO chip with gpiolib. In such cases, fw_devlink=on will cause 4349 * the consumers of the GPIO chip to get probe deferred forever because 4350 * they will be waiting for a device associated with the GPIO chip 4351 * firmware node to get added and bound to a driver. 4352 * 4353 * To allow these consumers to probe, we associate the struct 4354 * gpio_device of the GPIO chip with the firmware node and then simply 4355 * bind it to this stub driver. 4356 */ 4357 return 0; 4358 } 4359 4360 static struct device_driver gpio_stub_drv = { 4361 .name = "gpio_stub_drv", 4362 .bus = &gpio_bus_type, 4363 .probe = gpio_stub_drv_probe, 4364 }; 4365 4366 static int __init gpiolib_dev_init(void) 4367 { 4368 int ret; 4369 4370 /* Register GPIO sysfs bus */ 4371 ret = bus_register(&gpio_bus_type); 4372 if (ret < 0) { 4373 pr_err("gpiolib: could not register GPIO bus type\n"); 4374 return ret; 4375 } 4376 4377 ret = driver_register(&gpio_stub_drv); 4378 if (ret < 0) { 4379 pr_err("gpiolib: could not register GPIO stub driver\n"); 4380 bus_unregister(&gpio_bus_type); 4381 return ret; 4382 } 4383 4384 ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, GPIOCHIP_NAME); 4385 if (ret < 0) { 4386 pr_err("gpiolib: failed to allocate char dev region\n"); 4387 driver_unregister(&gpio_stub_drv); 4388 bus_unregister(&gpio_bus_type); 4389 return ret; 4390 } 4391 4392 gpiolib_initialized = true; 4393 gpiochip_setup_devs(); 4394 4395 #if IS_ENABLED(CONFIG_OF_DYNAMIC) && IS_ENABLED(CONFIG_OF_GPIO) 4396 WARN_ON(of_reconfig_notifier_register(&gpio_of_notifier)); 4397 #endif /* CONFIG_OF_DYNAMIC && CONFIG_OF_GPIO */ 4398 4399 return ret; 4400 } 4401 core_initcall(gpiolib_dev_init); 4402 4403 #ifdef CONFIG_DEBUG_FS 4404 4405 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev) 4406 { 4407 struct gpio_chip *gc = gdev->chip; 4408 struct gpio_desc *desc; 4409 unsigned gpio = gdev->base; 4410 int value; 4411 bool is_out; 4412 bool is_irq; 4413 bool active_low; 4414 4415 for_each_gpio_desc(gc, desc) { 4416 if (test_bit(FLAG_REQUESTED, &desc->flags)) { 4417 gpiod_get_direction(desc); 4418 is_out = test_bit(FLAG_IS_OUT, &desc->flags); 4419 value = gpio_chip_get_value(gc, desc); 4420 is_irq = test_bit(FLAG_USED_AS_IRQ, &desc->flags); 4421 active_low = test_bit(FLAG_ACTIVE_LOW, &desc->flags); 4422 seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s%s\n", 4423 gpio, desc->name ?: "", desc->label, 4424 is_out ? "out" : "in ", 4425 value >= 0 ? (value ? "hi" : "lo") : "? ", 4426 is_irq ? "IRQ " : "", 4427 active_low ? "ACTIVE LOW" : ""); 4428 } else if (desc->name) { 4429 seq_printf(s, " gpio-%-3d (%-20.20s)\n", gpio, desc->name); 4430 } 4431 4432 gpio++; 4433 } 4434 } 4435 4436 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos) 4437 { 4438 unsigned long flags; 4439 struct gpio_device *gdev = NULL; 4440 loff_t index = *pos; 4441 4442 s->private = ""; 4443 4444 spin_lock_irqsave(&gpio_lock, flags); 4445 list_for_each_entry(gdev, &gpio_devices, list) 4446 if (index-- == 0) { 4447 spin_unlock_irqrestore(&gpio_lock, flags); 4448 return gdev; 4449 } 4450 spin_unlock_irqrestore(&gpio_lock, flags); 4451 4452 return NULL; 4453 } 4454 4455 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos) 4456 { 4457 unsigned long flags; 4458 struct gpio_device *gdev = v; 4459 void *ret = NULL; 4460 4461 spin_lock_irqsave(&gpio_lock, flags); 4462 if (list_is_last(&gdev->list, &gpio_devices)) 4463 ret = NULL; 4464 else 4465 ret = list_first_entry(&gdev->list, struct gpio_device, list); 4466 spin_unlock_irqrestore(&gpio_lock, flags); 4467 4468 s->private = "\n"; 4469 ++*pos; 4470 4471 return ret; 4472 } 4473 4474 static void gpiolib_seq_stop(struct seq_file *s, void *v) 4475 { 4476 } 4477 4478 static int gpiolib_seq_show(struct seq_file *s, void *v) 4479 { 4480 struct gpio_device *gdev = v; 4481 struct gpio_chip *gc = gdev->chip; 4482 struct device *parent; 4483 4484 if (!gc) { 4485 seq_printf(s, "%s%s: (dangling chip)", (char *)s->private, 4486 dev_name(&gdev->dev)); 4487 return 0; 4488 } 4489 4490 seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private, 4491 dev_name(&gdev->dev), 4492 gdev->base, gdev->base + gdev->ngpio - 1); 4493 parent = gc->parent; 4494 if (parent) 4495 seq_printf(s, ", parent: %s/%s", 4496 parent->bus ? parent->bus->name : "no-bus", 4497 dev_name(parent)); 4498 if (gc->label) 4499 seq_printf(s, ", %s", gc->label); 4500 if (gc->can_sleep) 4501 seq_printf(s, ", can sleep"); 4502 seq_printf(s, ":\n"); 4503 4504 if (gc->dbg_show) 4505 gc->dbg_show(s, gc); 4506 else 4507 gpiolib_dbg_show(s, gdev); 4508 4509 return 0; 4510 } 4511 4512 static const struct seq_operations gpiolib_sops = { 4513 .start = gpiolib_seq_start, 4514 .next = gpiolib_seq_next, 4515 .stop = gpiolib_seq_stop, 4516 .show = gpiolib_seq_show, 4517 }; 4518 DEFINE_SEQ_ATTRIBUTE(gpiolib); 4519 4520 static int __init gpiolib_debugfs_init(void) 4521 { 4522 /* /sys/kernel/debug/gpio */ 4523 debugfs_create_file("gpio", 0444, NULL, NULL, &gpiolib_fops); 4524 return 0; 4525 } 4526 subsys_initcall(gpiolib_debugfs_init); 4527 4528 #endif /* DEBUG_FS */ 4529