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