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