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