1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <linux/anon_inodes.h> 4 #include <linux/atomic.h> 5 #include <linux/bitmap.h> 6 #include <linux/build_bug.h> 7 #include <linux/cdev.h> 8 #include <linux/cleanup.h> 9 #include <linux/compat.h> 10 #include <linux/compiler.h> 11 #include <linux/device.h> 12 #include <linux/err.h> 13 #include <linux/file.h> 14 #include <linux/gpio.h> 15 #include <linux/gpio/driver.h> 16 #include <linux/hte.h> 17 #include <linux/interrupt.h> 18 #include <linux/irqreturn.h> 19 #include <linux/kernel.h> 20 #include <linux/kfifo.h> 21 #include <linux/module.h> 22 #include <linux/mutex.h> 23 #include <linux/overflow.h> 24 #include <linux/pinctrl/consumer.h> 25 #include <linux/poll.h> 26 #include <linux/rbtree.h> 27 #include <linux/seq_file.h> 28 #include <linux/spinlock.h> 29 #include <linux/timekeeping.h> 30 #include <linux/uaccess.h> 31 #include <linux/workqueue.h> 32 33 #include <uapi/linux/gpio.h> 34 35 #include "gpiolib.h" 36 #include "gpiolib-cdev.h" 37 38 /* 39 * Array sizes must ensure 64-bit alignment and not create holes in the 40 * struct packing. 41 */ 42 static_assert(IS_ALIGNED(GPIO_V2_LINES_MAX, 2)); 43 static_assert(IS_ALIGNED(GPIO_MAX_NAME_SIZE, 8)); 44 45 /* 46 * Check that uAPI structs are 64-bit aligned for 32/64-bit compatibility 47 */ 48 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_attribute), 8)); 49 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_config_attribute), 8)); 50 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_config), 8)); 51 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_request), 8)); 52 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_info), 8)); 53 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_info_changed), 8)); 54 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_event), 8)); 55 static_assert(IS_ALIGNED(sizeof(struct gpio_v2_line_values), 8)); 56 57 /* Character device interface to GPIO. 58 * 59 * The GPIO character device, /dev/gpiochipN, provides userspace an 60 * interface to gpiolib GPIOs via ioctl()s. 61 */ 62 63 /* 64 * GPIO line handle management 65 */ 66 67 #ifdef CONFIG_GPIO_CDEV_V1 68 /** 69 * struct linehandle_state - contains the state of a userspace handle 70 * @gdev: the GPIO device the handle pertains to 71 * @label: consumer label used to tag descriptors 72 * @descs: the GPIO descriptors held by this handle 73 * @num_descs: the number of descriptors held in the descs array 74 */ 75 struct linehandle_state { 76 struct gpio_device *gdev; 77 const char *label; 78 struct gpio_desc *descs[GPIOHANDLES_MAX]; 79 u32 num_descs; 80 }; 81 82 #define GPIOHANDLE_REQUEST_VALID_FLAGS \ 83 (GPIOHANDLE_REQUEST_INPUT | \ 84 GPIOHANDLE_REQUEST_OUTPUT | \ 85 GPIOHANDLE_REQUEST_ACTIVE_LOW | \ 86 GPIOHANDLE_REQUEST_BIAS_PULL_UP | \ 87 GPIOHANDLE_REQUEST_BIAS_PULL_DOWN | \ 88 GPIOHANDLE_REQUEST_BIAS_DISABLE | \ 89 GPIOHANDLE_REQUEST_OPEN_DRAIN | \ 90 GPIOHANDLE_REQUEST_OPEN_SOURCE) 91 92 static int linehandle_validate_flags(u32 flags) 93 { 94 /* Return an error if an unknown flag is set */ 95 if (flags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) 96 return -EINVAL; 97 98 /* 99 * Do not allow both INPUT & OUTPUT flags to be set as they are 100 * contradictory. 101 */ 102 if ((flags & GPIOHANDLE_REQUEST_INPUT) && 103 (flags & GPIOHANDLE_REQUEST_OUTPUT)) 104 return -EINVAL; 105 106 /* 107 * Do not allow OPEN_SOURCE & OPEN_DRAIN flags in a single request. If 108 * the hardware actually supports enabling both at the same time the 109 * electrical result would be disastrous. 110 */ 111 if ((flags & GPIOHANDLE_REQUEST_OPEN_DRAIN) && 112 (flags & GPIOHANDLE_REQUEST_OPEN_SOURCE)) 113 return -EINVAL; 114 115 /* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */ 116 if (!(flags & GPIOHANDLE_REQUEST_OUTPUT) && 117 ((flags & GPIOHANDLE_REQUEST_OPEN_DRAIN) || 118 (flags & GPIOHANDLE_REQUEST_OPEN_SOURCE))) 119 return -EINVAL; 120 121 /* Bias flags only allowed for input or output mode. */ 122 if (!((flags & GPIOHANDLE_REQUEST_INPUT) || 123 (flags & GPIOHANDLE_REQUEST_OUTPUT)) && 124 ((flags & GPIOHANDLE_REQUEST_BIAS_DISABLE) || 125 (flags & GPIOHANDLE_REQUEST_BIAS_PULL_UP) || 126 (flags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN))) 127 return -EINVAL; 128 129 /* Only one bias flag can be set. */ 130 if (((flags & GPIOHANDLE_REQUEST_BIAS_DISABLE) && 131 (flags & (GPIOHANDLE_REQUEST_BIAS_PULL_DOWN | 132 GPIOHANDLE_REQUEST_BIAS_PULL_UP))) || 133 ((flags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN) && 134 (flags & GPIOHANDLE_REQUEST_BIAS_PULL_UP))) 135 return -EINVAL; 136 137 return 0; 138 } 139 140 static void linehandle_flags_to_desc_flags(u32 lflags, unsigned long *flagsp) 141 { 142 assign_bit(FLAG_ACTIVE_LOW, flagsp, 143 lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW); 144 assign_bit(FLAG_OPEN_DRAIN, flagsp, 145 lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN); 146 assign_bit(FLAG_OPEN_SOURCE, flagsp, 147 lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE); 148 assign_bit(FLAG_PULL_UP, flagsp, 149 lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP); 150 assign_bit(FLAG_PULL_DOWN, flagsp, 151 lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN); 152 assign_bit(FLAG_BIAS_DISABLE, flagsp, 153 lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE); 154 } 155 156 static long linehandle_set_config(struct linehandle_state *lh, 157 void __user *ip) 158 { 159 struct gpiohandle_config gcnf; 160 struct gpio_desc *desc; 161 int i, ret; 162 u32 lflags; 163 164 if (copy_from_user(&gcnf, ip, sizeof(gcnf))) 165 return -EFAULT; 166 167 lflags = gcnf.flags; 168 ret = linehandle_validate_flags(lflags); 169 if (ret) 170 return ret; 171 172 for (i = 0; i < lh->num_descs; i++) { 173 desc = lh->descs[i]; 174 linehandle_flags_to_desc_flags(gcnf.flags, &desc->flags); 175 176 /* 177 * Lines have to be requested explicitly for input 178 * or output, else the line will be treated "as is". 179 */ 180 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) { 181 int val = !!gcnf.default_values[i]; 182 183 ret = gpiod_direction_output(desc, val); 184 if (ret) 185 return ret; 186 } else if (lflags & GPIOHANDLE_REQUEST_INPUT) { 187 ret = gpiod_direction_input(desc); 188 if (ret) 189 return ret; 190 } 191 192 gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_CONFIG); 193 } 194 return 0; 195 } 196 197 static long linehandle_ioctl(struct file *file, unsigned int cmd, 198 unsigned long arg) 199 { 200 struct linehandle_state *lh = file->private_data; 201 void __user *ip = (void __user *)arg; 202 struct gpiohandle_data ghd; 203 DECLARE_BITMAP(vals, GPIOHANDLES_MAX); 204 unsigned int i; 205 int ret; 206 207 guard(srcu)(&lh->gdev->srcu); 208 209 if (!rcu_access_pointer(lh->gdev->chip)) 210 return -ENODEV; 211 212 switch (cmd) { 213 case GPIOHANDLE_GET_LINE_VALUES_IOCTL: 214 /* NOTE: It's okay to read values of output lines */ 215 ret = gpiod_get_array_value_complex(false, true, 216 lh->num_descs, lh->descs, 217 NULL, vals); 218 if (ret) 219 return ret; 220 221 memset(&ghd, 0, sizeof(ghd)); 222 for (i = 0; i < lh->num_descs; i++) 223 ghd.values[i] = test_bit(i, vals); 224 225 if (copy_to_user(ip, &ghd, sizeof(ghd))) 226 return -EFAULT; 227 228 return 0; 229 case GPIOHANDLE_SET_LINE_VALUES_IOCTL: 230 /* 231 * All line descriptors were created at once with the same 232 * flags so just check if the first one is really output. 233 */ 234 if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags)) 235 return -EPERM; 236 237 if (copy_from_user(&ghd, ip, sizeof(ghd))) 238 return -EFAULT; 239 240 /* Clamp all values to [0,1] */ 241 for (i = 0; i < lh->num_descs; i++) 242 __assign_bit(i, vals, ghd.values[i]); 243 244 /* Reuse the array setting function */ 245 return gpiod_set_array_value_complex(false, 246 true, 247 lh->num_descs, 248 lh->descs, 249 NULL, 250 vals); 251 case GPIOHANDLE_SET_CONFIG_IOCTL: 252 return linehandle_set_config(lh, ip); 253 default: 254 return -EINVAL; 255 } 256 } 257 258 #ifdef CONFIG_COMPAT 259 static long linehandle_ioctl_compat(struct file *file, unsigned int cmd, 260 unsigned long arg) 261 { 262 return linehandle_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 263 } 264 #endif 265 266 static void linehandle_free(struct linehandle_state *lh) 267 { 268 int i; 269 270 for (i = 0; i < lh->num_descs; i++) 271 if (lh->descs[i]) 272 gpiod_free(lh->descs[i]); 273 kfree(lh->label); 274 gpio_device_put(lh->gdev); 275 kfree(lh); 276 } 277 278 static int linehandle_release(struct inode *inode, struct file *file) 279 { 280 linehandle_free(file->private_data); 281 return 0; 282 } 283 284 static const struct file_operations linehandle_fileops = { 285 .release = linehandle_release, 286 .owner = THIS_MODULE, 287 .llseek = noop_llseek, 288 .unlocked_ioctl = linehandle_ioctl, 289 #ifdef CONFIG_COMPAT 290 .compat_ioctl = linehandle_ioctl_compat, 291 #endif 292 }; 293 294 static int linehandle_create(struct gpio_device *gdev, void __user *ip) 295 { 296 struct gpiohandle_request handlereq; 297 struct linehandle_state *lh; 298 struct file *file; 299 int fd, i, ret; 300 u32 lflags; 301 302 if (copy_from_user(&handlereq, ip, sizeof(handlereq))) 303 return -EFAULT; 304 if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX)) 305 return -EINVAL; 306 307 lflags = handlereq.flags; 308 309 ret = linehandle_validate_flags(lflags); 310 if (ret) 311 return ret; 312 313 lh = kzalloc(sizeof(*lh), GFP_KERNEL); 314 if (!lh) 315 return -ENOMEM; 316 lh->gdev = gpio_device_get(gdev); 317 318 if (handlereq.consumer_label[0] != '\0') { 319 /* label is only initialized if consumer_label is set */ 320 lh->label = kstrndup(handlereq.consumer_label, 321 sizeof(handlereq.consumer_label) - 1, 322 GFP_KERNEL); 323 if (!lh->label) { 324 ret = -ENOMEM; 325 goto out_free_lh; 326 } 327 } 328 329 lh->num_descs = handlereq.lines; 330 331 /* Request each GPIO */ 332 for (i = 0; i < handlereq.lines; i++) { 333 u32 offset = handlereq.lineoffsets[i]; 334 struct gpio_desc *desc = gpio_device_get_desc(gdev, offset); 335 336 if (IS_ERR(desc)) { 337 ret = PTR_ERR(desc); 338 goto out_free_lh; 339 } 340 341 ret = gpiod_request_user(desc, lh->label); 342 if (ret) 343 goto out_free_lh; 344 lh->descs[i] = desc; 345 linehandle_flags_to_desc_flags(handlereq.flags, &desc->flags); 346 347 ret = gpiod_set_transitory(desc, false); 348 if (ret < 0) 349 goto out_free_lh; 350 351 /* 352 * Lines have to be requested explicitly for input 353 * or output, else the line will be treated "as is". 354 */ 355 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) { 356 int val = !!handlereq.default_values[i]; 357 358 ret = gpiod_direction_output(desc, val); 359 if (ret) 360 goto out_free_lh; 361 } else if (lflags & GPIOHANDLE_REQUEST_INPUT) { 362 ret = gpiod_direction_input(desc); 363 if (ret) 364 goto out_free_lh; 365 } 366 367 gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_REQUESTED); 368 369 dev_dbg(&gdev->dev, "registered chardev handle for line %d\n", 370 offset); 371 } 372 373 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC); 374 if (fd < 0) { 375 ret = fd; 376 goto out_free_lh; 377 } 378 379 file = anon_inode_getfile("gpio-linehandle", 380 &linehandle_fileops, 381 lh, 382 O_RDONLY | O_CLOEXEC); 383 if (IS_ERR(file)) { 384 ret = PTR_ERR(file); 385 goto out_put_unused_fd; 386 } 387 388 handlereq.fd = fd; 389 if (copy_to_user(ip, &handlereq, sizeof(handlereq))) { 390 /* 391 * fput() will trigger the release() callback, so do not go onto 392 * the regular error cleanup path here. 393 */ 394 fput(file); 395 put_unused_fd(fd); 396 return -EFAULT; 397 } 398 399 fd_install(fd, file); 400 401 dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n", 402 lh->num_descs); 403 404 return 0; 405 406 out_put_unused_fd: 407 put_unused_fd(fd); 408 out_free_lh: 409 linehandle_free(lh); 410 return ret; 411 } 412 #endif /* CONFIG_GPIO_CDEV_V1 */ 413 414 /** 415 * struct line - contains the state of a requested line 416 * @node: to store the object in supinfo_tree if supplemental 417 * @desc: the GPIO descriptor for this line. 418 * @req: the corresponding line request 419 * @irq: the interrupt triggered in response to events on this GPIO 420 * @edflags: the edge flags, GPIO_V2_LINE_FLAG_EDGE_RISING and/or 421 * GPIO_V2_LINE_FLAG_EDGE_FALLING, indicating the edge detection applied 422 * @timestamp_ns: cache for the timestamp storing it between hardirq and 423 * IRQ thread, used to bring the timestamp close to the actual event 424 * @req_seqno: the seqno for the current edge event in the sequence of 425 * events for the corresponding line request. This is drawn from the @req. 426 * @line_seqno: the seqno for the current edge event in the sequence of 427 * events for this line. 428 * @work: the worker that implements software debouncing 429 * @debounce_period_us: the debounce period in microseconds 430 * @sw_debounced: flag indicating if the software debouncer is active 431 * @level: the current debounced physical level of the line 432 * @hdesc: the Hardware Timestamp Engine (HTE) descriptor 433 * @raw_level: the line level at the time of event 434 * @total_discard_seq: the running counter of the discarded events 435 * @last_seqno: the last sequence number before debounce period expires 436 */ 437 struct line { 438 struct rb_node node; 439 struct gpio_desc *desc; 440 /* 441 * -- edge detector specific fields -- 442 */ 443 struct linereq *req; 444 unsigned int irq; 445 /* 446 * The flags for the active edge detector configuration. 447 * 448 * edflags is set by linereq_create(), linereq_free(), and 449 * linereq_set_config_unlocked(), which are themselves mutually 450 * exclusive, and is accessed by edge_irq_thread(), 451 * process_hw_ts_thread() and debounce_work_func(), 452 * which can all live with a slightly stale value. 453 */ 454 u64 edflags; 455 /* 456 * timestamp_ns and req_seqno are accessed only by 457 * edge_irq_handler() and edge_irq_thread(), which are themselves 458 * mutually exclusive, so no additional protection is necessary. 459 */ 460 u64 timestamp_ns; 461 u32 req_seqno; 462 /* 463 * line_seqno is accessed by either edge_irq_thread() or 464 * debounce_work_func(), which are themselves mutually exclusive, 465 * so no additional protection is necessary. 466 */ 467 u32 line_seqno; 468 /* 469 * -- debouncer specific fields -- 470 */ 471 struct delayed_work work; 472 /* 473 * debounce_period_us is accessed by debounce_irq_handler() and 474 * process_hw_ts() which are disabled when modified by 475 * debounce_setup(), edge_detector_setup() or edge_detector_stop() 476 * or can live with a stale version when updated by 477 * edge_detector_update(). 478 * The modifying functions are themselves mutually exclusive. 479 */ 480 unsigned int debounce_period_us; 481 /* 482 * sw_debounce is accessed by linereq_set_config(), which is the 483 * only setter, and linereq_get_values(), which can live with a 484 * slightly stale value. 485 */ 486 unsigned int sw_debounced; 487 /* 488 * level is accessed by debounce_work_func(), which is the only 489 * setter, and linereq_get_values() which can live with a slightly 490 * stale value. 491 */ 492 unsigned int level; 493 #ifdef CONFIG_HTE 494 struct hte_ts_desc hdesc; 495 /* 496 * HTE provider sets line level at the time of event. The valid 497 * value is 0 or 1 and negative value for an error. 498 */ 499 int raw_level; 500 /* 501 * when sw_debounce is set on HTE enabled line, this is running 502 * counter of the discarded events. 503 */ 504 u32 total_discard_seq; 505 /* 506 * when sw_debounce is set on HTE enabled line, this variable records 507 * last sequence number before debounce period expires. 508 */ 509 u32 last_seqno; 510 #endif /* CONFIG_HTE */ 511 }; 512 513 /* 514 * a rbtree of the struct lines containing supplemental info. 515 * Used to populate gpio_v2_line_info with cdev specific fields not contained 516 * in the struct gpio_desc. 517 * A line is determined to contain supplemental information by 518 * line_has_supinfo(). 519 */ 520 static struct rb_root supinfo_tree = RB_ROOT; 521 /* covers supinfo_tree */ 522 static DEFINE_SPINLOCK(supinfo_lock); 523 524 /** 525 * struct linereq - contains the state of a userspace line request 526 * @gdev: the GPIO device the line request pertains to 527 * @label: consumer label used to tag GPIO descriptors 528 * @num_lines: the number of lines in the lines array 529 * @wait: wait queue that handles blocking reads of events 530 * @device_unregistered_nb: notifier block for receiving gdev unregister events 531 * @event_buffer_size: the number of elements allocated in @events 532 * @events: KFIFO for the GPIO events 533 * @seqno: the sequence number for edge events generated on all lines in 534 * this line request. Note that this is not used when @num_lines is 1, as 535 * the line_seqno is then the same and is cheaper to calculate. 536 * @config_mutex: mutex for serializing ioctl() calls to ensure consistency 537 * of configuration, particularly multi-step accesses to desc flags and 538 * changes to supinfo status. 539 * @lines: the lines held by this line request, with @num_lines elements. 540 */ 541 struct linereq { 542 struct gpio_device *gdev; 543 const char *label; 544 u32 num_lines; 545 wait_queue_head_t wait; 546 struct notifier_block device_unregistered_nb; 547 u32 event_buffer_size; 548 DECLARE_KFIFO_PTR(events, struct gpio_v2_line_event); 549 atomic_t seqno; 550 struct mutex config_mutex; 551 struct line lines[] __counted_by(num_lines); 552 }; 553 554 static void supinfo_insert(struct line *line) 555 { 556 struct rb_node **new = &(supinfo_tree.rb_node), *parent = NULL; 557 struct line *entry; 558 559 guard(spinlock)(&supinfo_lock); 560 561 while (*new) { 562 entry = container_of(*new, struct line, node); 563 564 parent = *new; 565 if (line->desc < entry->desc) { 566 new = &((*new)->rb_left); 567 } else if (line->desc > entry->desc) { 568 new = &((*new)->rb_right); 569 } else { 570 /* this should never happen */ 571 WARN(1, "duplicate line inserted"); 572 return; 573 } 574 } 575 576 rb_link_node(&line->node, parent, new); 577 rb_insert_color(&line->node, &supinfo_tree); 578 } 579 580 static void supinfo_erase(struct line *line) 581 { 582 guard(spinlock)(&supinfo_lock); 583 584 rb_erase(&line->node, &supinfo_tree); 585 } 586 587 static struct line *supinfo_find(struct gpio_desc *desc) 588 { 589 struct rb_node *node = supinfo_tree.rb_node; 590 struct line *line; 591 592 while (node) { 593 line = container_of(node, struct line, node); 594 if (desc < line->desc) 595 node = node->rb_left; 596 else if (desc > line->desc) 597 node = node->rb_right; 598 else 599 return line; 600 } 601 return NULL; 602 } 603 604 static void supinfo_to_lineinfo(struct gpio_desc *desc, 605 struct gpio_v2_line_info *info) 606 { 607 struct gpio_v2_line_attribute *attr; 608 struct line *line; 609 610 guard(spinlock)(&supinfo_lock); 611 612 line = supinfo_find(desc); 613 if (!line) 614 return; 615 616 attr = &info->attrs[info->num_attrs]; 617 attr->id = GPIO_V2_LINE_ATTR_ID_DEBOUNCE; 618 attr->debounce_period_us = READ_ONCE(line->debounce_period_us); 619 info->num_attrs++; 620 } 621 622 static inline bool line_has_supinfo(struct line *line) 623 { 624 return READ_ONCE(line->debounce_period_us); 625 } 626 627 /* 628 * Checks line_has_supinfo() before and after the change to avoid unnecessary 629 * supinfo_tree access. 630 * Called indirectly by linereq_create() or linereq_set_config() so line 631 * is already protected from concurrent changes. 632 */ 633 static void line_set_debounce_period(struct line *line, 634 unsigned int debounce_period_us) 635 { 636 bool was_suppl = line_has_supinfo(line); 637 638 WRITE_ONCE(line->debounce_period_us, debounce_period_us); 639 640 /* if supinfo status is unchanged then we're done */ 641 if (line_has_supinfo(line) == was_suppl) 642 return; 643 644 /* supinfo status has changed, so update the tree */ 645 if (was_suppl) 646 supinfo_erase(line); 647 else 648 supinfo_insert(line); 649 } 650 651 #define GPIO_V2_LINE_BIAS_FLAGS \ 652 (GPIO_V2_LINE_FLAG_BIAS_PULL_UP | \ 653 GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN | \ 654 GPIO_V2_LINE_FLAG_BIAS_DISABLED) 655 656 #define GPIO_V2_LINE_DIRECTION_FLAGS \ 657 (GPIO_V2_LINE_FLAG_INPUT | \ 658 GPIO_V2_LINE_FLAG_OUTPUT) 659 660 #define GPIO_V2_LINE_DRIVE_FLAGS \ 661 (GPIO_V2_LINE_FLAG_OPEN_DRAIN | \ 662 GPIO_V2_LINE_FLAG_OPEN_SOURCE) 663 664 #define GPIO_V2_LINE_EDGE_FLAGS \ 665 (GPIO_V2_LINE_FLAG_EDGE_RISING | \ 666 GPIO_V2_LINE_FLAG_EDGE_FALLING) 667 668 #define GPIO_V2_LINE_FLAG_EDGE_BOTH GPIO_V2_LINE_EDGE_FLAGS 669 670 #define GPIO_V2_LINE_VALID_FLAGS \ 671 (GPIO_V2_LINE_FLAG_ACTIVE_LOW | \ 672 GPIO_V2_LINE_DIRECTION_FLAGS | \ 673 GPIO_V2_LINE_DRIVE_FLAGS | \ 674 GPIO_V2_LINE_EDGE_FLAGS | \ 675 GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME | \ 676 GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE | \ 677 GPIO_V2_LINE_BIAS_FLAGS) 678 679 /* subset of flags relevant for edge detector configuration */ 680 #define GPIO_V2_LINE_EDGE_DETECTOR_FLAGS \ 681 (GPIO_V2_LINE_FLAG_ACTIVE_LOW | \ 682 GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE | \ 683 GPIO_V2_LINE_EDGE_FLAGS) 684 685 static int linereq_unregistered_notify(struct notifier_block *nb, 686 unsigned long action, void *data) 687 { 688 struct linereq *lr = container_of(nb, struct linereq, 689 device_unregistered_nb); 690 691 wake_up_poll(&lr->wait, EPOLLIN | EPOLLERR); 692 693 return NOTIFY_OK; 694 } 695 696 static void linereq_put_event(struct linereq *lr, 697 struct gpio_v2_line_event *le) 698 { 699 bool overflow = false; 700 701 scoped_guard(spinlock, &lr->wait.lock) { 702 if (kfifo_is_full(&lr->events)) { 703 overflow = true; 704 kfifo_skip(&lr->events); 705 } 706 kfifo_in(&lr->events, le, 1); 707 } 708 if (!overflow) 709 wake_up_poll(&lr->wait, EPOLLIN); 710 else 711 pr_debug_ratelimited("event FIFO is full - event dropped\n"); 712 } 713 714 static u64 line_event_timestamp(struct line *line) 715 { 716 if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &line->desc->flags)) 717 return ktime_get_real_ns(); 718 else if (IS_ENABLED(CONFIG_HTE) && 719 test_bit(FLAG_EVENT_CLOCK_HTE, &line->desc->flags)) 720 return line->timestamp_ns; 721 722 return ktime_get_ns(); 723 } 724 725 static u32 line_event_id(int level) 726 { 727 return level ? GPIO_V2_LINE_EVENT_RISING_EDGE : 728 GPIO_V2_LINE_EVENT_FALLING_EDGE; 729 } 730 731 static inline char *make_irq_label(const char *orig) 732 { 733 char *new; 734 735 if (!orig) 736 return NULL; 737 738 new = kstrdup_and_replace(orig, '/', ':', GFP_KERNEL); 739 if (!new) 740 return ERR_PTR(-ENOMEM); 741 742 return new; 743 } 744 745 static inline void free_irq_label(const char *label) 746 { 747 kfree(label); 748 } 749 750 #ifdef CONFIG_HTE 751 752 static enum hte_return process_hw_ts_thread(void *p) 753 { 754 struct line *line; 755 struct linereq *lr; 756 struct gpio_v2_line_event le; 757 u64 edflags; 758 int level; 759 760 if (!p) 761 return HTE_CB_HANDLED; 762 763 line = p; 764 lr = line->req; 765 766 memset(&le, 0, sizeof(le)); 767 768 le.timestamp_ns = line->timestamp_ns; 769 edflags = READ_ONCE(line->edflags); 770 771 switch (edflags & GPIO_V2_LINE_EDGE_FLAGS) { 772 case GPIO_V2_LINE_FLAG_EDGE_BOTH: 773 level = (line->raw_level >= 0) ? 774 line->raw_level : 775 gpiod_get_raw_value_cansleep(line->desc); 776 777 if (edflags & GPIO_V2_LINE_FLAG_ACTIVE_LOW) 778 level = !level; 779 780 le.id = line_event_id(level); 781 break; 782 case GPIO_V2_LINE_FLAG_EDGE_RISING: 783 le.id = GPIO_V2_LINE_EVENT_RISING_EDGE; 784 break; 785 case GPIO_V2_LINE_FLAG_EDGE_FALLING: 786 le.id = GPIO_V2_LINE_EVENT_FALLING_EDGE; 787 break; 788 default: 789 return HTE_CB_HANDLED; 790 } 791 le.line_seqno = line->line_seqno; 792 le.seqno = (lr->num_lines == 1) ? le.line_seqno : line->req_seqno; 793 le.offset = gpio_chip_hwgpio(line->desc); 794 795 linereq_put_event(lr, &le); 796 797 return HTE_CB_HANDLED; 798 } 799 800 static enum hte_return process_hw_ts(struct hte_ts_data *ts, void *p) 801 { 802 struct line *line; 803 struct linereq *lr; 804 int diff_seqno = 0; 805 806 if (!ts || !p) 807 return HTE_CB_HANDLED; 808 809 line = p; 810 line->timestamp_ns = ts->tsc; 811 line->raw_level = ts->raw_level; 812 lr = line->req; 813 814 if (READ_ONCE(line->sw_debounced)) { 815 line->total_discard_seq++; 816 line->last_seqno = ts->seq; 817 mod_delayed_work(system_wq, &line->work, 818 usecs_to_jiffies(READ_ONCE(line->debounce_period_us))); 819 } else { 820 if (unlikely(ts->seq < line->line_seqno)) 821 return HTE_CB_HANDLED; 822 823 diff_seqno = ts->seq - line->line_seqno; 824 line->line_seqno = ts->seq; 825 if (lr->num_lines != 1) 826 line->req_seqno = atomic_add_return(diff_seqno, 827 &lr->seqno); 828 829 return HTE_RUN_SECOND_CB; 830 } 831 832 return HTE_CB_HANDLED; 833 } 834 835 static int hte_edge_setup(struct line *line, u64 eflags) 836 { 837 int ret; 838 unsigned long flags = 0; 839 struct hte_ts_desc *hdesc = &line->hdesc; 840 841 if (eflags & GPIO_V2_LINE_FLAG_EDGE_RISING) 842 flags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? 843 HTE_FALLING_EDGE_TS : 844 HTE_RISING_EDGE_TS; 845 if (eflags & GPIO_V2_LINE_FLAG_EDGE_FALLING) 846 flags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? 847 HTE_RISING_EDGE_TS : 848 HTE_FALLING_EDGE_TS; 849 850 line->total_discard_seq = 0; 851 852 hte_init_line_attr(hdesc, desc_to_gpio(line->desc), flags, NULL, 853 line->desc); 854 855 ret = hte_ts_get(NULL, hdesc, 0); 856 if (ret) 857 return ret; 858 859 return hte_request_ts_ns(hdesc, process_hw_ts, process_hw_ts_thread, 860 line); 861 } 862 863 #else 864 865 static int hte_edge_setup(struct line *line, u64 eflags) 866 { 867 return 0; 868 } 869 #endif /* CONFIG_HTE */ 870 871 static irqreturn_t edge_irq_thread(int irq, void *p) 872 { 873 struct line *line = p; 874 struct linereq *lr = line->req; 875 struct gpio_v2_line_event le; 876 877 /* Do not leak kernel stack to userspace */ 878 memset(&le, 0, sizeof(le)); 879 880 if (line->timestamp_ns) { 881 le.timestamp_ns = line->timestamp_ns; 882 } else { 883 /* 884 * We may be running from a nested threaded interrupt in 885 * which case we didn't get the timestamp from 886 * edge_irq_handler(). 887 */ 888 le.timestamp_ns = line_event_timestamp(line); 889 if (lr->num_lines != 1) 890 line->req_seqno = atomic_inc_return(&lr->seqno); 891 } 892 line->timestamp_ns = 0; 893 894 switch (READ_ONCE(line->edflags) & GPIO_V2_LINE_EDGE_FLAGS) { 895 case GPIO_V2_LINE_FLAG_EDGE_BOTH: 896 le.id = line_event_id(gpiod_get_value_cansleep(line->desc)); 897 break; 898 case GPIO_V2_LINE_FLAG_EDGE_RISING: 899 le.id = GPIO_V2_LINE_EVENT_RISING_EDGE; 900 break; 901 case GPIO_V2_LINE_FLAG_EDGE_FALLING: 902 le.id = GPIO_V2_LINE_EVENT_FALLING_EDGE; 903 break; 904 default: 905 return IRQ_NONE; 906 } 907 line->line_seqno++; 908 le.line_seqno = line->line_seqno; 909 le.seqno = (lr->num_lines == 1) ? le.line_seqno : line->req_seqno; 910 le.offset = gpio_chip_hwgpio(line->desc); 911 912 linereq_put_event(lr, &le); 913 914 return IRQ_HANDLED; 915 } 916 917 static irqreturn_t edge_irq_handler(int irq, void *p) 918 { 919 struct line *line = p; 920 struct linereq *lr = line->req; 921 922 /* 923 * Just store the timestamp in hardirq context so we get it as 924 * close in time as possible to the actual event. 925 */ 926 line->timestamp_ns = line_event_timestamp(line); 927 928 if (lr->num_lines != 1) 929 line->req_seqno = atomic_inc_return(&lr->seqno); 930 931 return IRQ_WAKE_THREAD; 932 } 933 934 /* 935 * returns the current debounced logical value. 936 */ 937 static bool debounced_value(struct line *line) 938 { 939 bool value; 940 941 /* 942 * minor race - debouncer may be stopped here, so edge_detector_stop() 943 * must leave the value unchanged so the following will read the level 944 * from when the debouncer was last running. 945 */ 946 value = READ_ONCE(line->level); 947 948 if (test_bit(FLAG_ACTIVE_LOW, &line->desc->flags)) 949 value = !value; 950 951 return value; 952 } 953 954 static irqreturn_t debounce_irq_handler(int irq, void *p) 955 { 956 struct line *line = p; 957 958 mod_delayed_work(system_wq, &line->work, 959 usecs_to_jiffies(READ_ONCE(line->debounce_period_us))); 960 961 return IRQ_HANDLED; 962 } 963 964 static void debounce_work_func(struct work_struct *work) 965 { 966 struct gpio_v2_line_event le; 967 struct line *line = container_of(work, struct line, work.work); 968 struct linereq *lr; 969 u64 eflags, edflags = READ_ONCE(line->edflags); 970 int level = -1; 971 #ifdef CONFIG_HTE 972 int diff_seqno; 973 974 if (edflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE) 975 level = line->raw_level; 976 #endif 977 if (level < 0) 978 level = gpiod_get_raw_value_cansleep(line->desc); 979 if (level < 0) { 980 pr_debug_ratelimited("debouncer failed to read line value\n"); 981 return; 982 } 983 984 if (READ_ONCE(line->level) == level) 985 return; 986 987 WRITE_ONCE(line->level, level); 988 989 /* -- edge detection -- */ 990 eflags = edflags & GPIO_V2_LINE_EDGE_FLAGS; 991 if (!eflags) 992 return; 993 994 /* switch from physical level to logical - if they differ */ 995 if (edflags & GPIO_V2_LINE_FLAG_ACTIVE_LOW) 996 level = !level; 997 998 /* ignore edges that are not being monitored */ 999 if (((eflags == GPIO_V2_LINE_FLAG_EDGE_RISING) && !level) || 1000 ((eflags == GPIO_V2_LINE_FLAG_EDGE_FALLING) && level)) 1001 return; 1002 1003 /* Do not leak kernel stack to userspace */ 1004 memset(&le, 0, sizeof(le)); 1005 1006 lr = line->req; 1007 le.timestamp_ns = line_event_timestamp(line); 1008 le.offset = gpio_chip_hwgpio(line->desc); 1009 #ifdef CONFIG_HTE 1010 if (edflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE) { 1011 /* discard events except the last one */ 1012 line->total_discard_seq -= 1; 1013 diff_seqno = line->last_seqno - line->total_discard_seq - 1014 line->line_seqno; 1015 line->line_seqno = line->last_seqno - line->total_discard_seq; 1016 le.line_seqno = line->line_seqno; 1017 le.seqno = (lr->num_lines == 1) ? 1018 le.line_seqno : atomic_add_return(diff_seqno, &lr->seqno); 1019 } else 1020 #endif /* CONFIG_HTE */ 1021 { 1022 line->line_seqno++; 1023 le.line_seqno = line->line_seqno; 1024 le.seqno = (lr->num_lines == 1) ? 1025 le.line_seqno : atomic_inc_return(&lr->seqno); 1026 } 1027 1028 le.id = line_event_id(level); 1029 1030 linereq_put_event(lr, &le); 1031 } 1032 1033 static int debounce_setup(struct line *line, unsigned int debounce_period_us) 1034 { 1035 unsigned long irqflags; 1036 int ret, level, irq; 1037 char *label; 1038 1039 /* try hardware */ 1040 ret = gpiod_set_debounce(line->desc, debounce_period_us); 1041 if (!ret) { 1042 line_set_debounce_period(line, debounce_period_us); 1043 return ret; 1044 } 1045 if (ret != -ENOTSUPP) 1046 return ret; 1047 1048 if (debounce_period_us) { 1049 /* setup software debounce */ 1050 level = gpiod_get_raw_value_cansleep(line->desc); 1051 if (level < 0) 1052 return level; 1053 1054 if (!(IS_ENABLED(CONFIG_HTE) && 1055 test_bit(FLAG_EVENT_CLOCK_HTE, &line->desc->flags))) { 1056 irq = gpiod_to_irq(line->desc); 1057 if (irq < 0) 1058 return -ENXIO; 1059 1060 label = make_irq_label(line->req->label); 1061 if (IS_ERR(label)) 1062 return -ENOMEM; 1063 1064 irqflags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING; 1065 ret = request_irq(irq, debounce_irq_handler, irqflags, 1066 label, line); 1067 if (ret) { 1068 free_irq_label(label); 1069 return ret; 1070 } 1071 line->irq = irq; 1072 } else { 1073 ret = hte_edge_setup(line, GPIO_V2_LINE_FLAG_EDGE_BOTH); 1074 if (ret) 1075 return ret; 1076 } 1077 1078 WRITE_ONCE(line->level, level); 1079 WRITE_ONCE(line->sw_debounced, 1); 1080 } 1081 return 0; 1082 } 1083 1084 static bool gpio_v2_line_config_debounced(struct gpio_v2_line_config *lc, 1085 unsigned int line_idx) 1086 { 1087 unsigned int i; 1088 u64 mask = BIT_ULL(line_idx); 1089 1090 for (i = 0; i < lc->num_attrs; i++) { 1091 if ((lc->attrs[i].attr.id == GPIO_V2_LINE_ATTR_ID_DEBOUNCE) && 1092 (lc->attrs[i].mask & mask)) 1093 return true; 1094 } 1095 return false; 1096 } 1097 1098 static u32 gpio_v2_line_config_debounce_period(struct gpio_v2_line_config *lc, 1099 unsigned int line_idx) 1100 { 1101 unsigned int i; 1102 u64 mask = BIT_ULL(line_idx); 1103 1104 for (i = 0; i < lc->num_attrs; i++) { 1105 if ((lc->attrs[i].attr.id == GPIO_V2_LINE_ATTR_ID_DEBOUNCE) && 1106 (lc->attrs[i].mask & mask)) 1107 return lc->attrs[i].attr.debounce_period_us; 1108 } 1109 return 0; 1110 } 1111 1112 static void edge_detector_stop(struct line *line) 1113 { 1114 if (line->irq) { 1115 free_irq_label(free_irq(line->irq, line)); 1116 line->irq = 0; 1117 } 1118 1119 #ifdef CONFIG_HTE 1120 if (READ_ONCE(line->edflags) & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE) 1121 hte_ts_put(&line->hdesc); 1122 #endif 1123 1124 cancel_delayed_work_sync(&line->work); 1125 WRITE_ONCE(line->sw_debounced, 0); 1126 WRITE_ONCE(line->edflags, 0); 1127 line_set_debounce_period(line, 0); 1128 /* do not change line->level - see comment in debounced_value() */ 1129 } 1130 1131 static int edge_detector_setup(struct line *line, 1132 struct gpio_v2_line_config *lc, 1133 unsigned int line_idx, u64 edflags) 1134 { 1135 u32 debounce_period_us; 1136 unsigned long irqflags = 0; 1137 u64 eflags; 1138 int irq, ret; 1139 char *label; 1140 1141 eflags = edflags & GPIO_V2_LINE_EDGE_FLAGS; 1142 if (eflags && !kfifo_initialized(&line->req->events)) { 1143 ret = kfifo_alloc(&line->req->events, 1144 line->req->event_buffer_size, GFP_KERNEL); 1145 if (ret) 1146 return ret; 1147 } 1148 if (gpio_v2_line_config_debounced(lc, line_idx)) { 1149 debounce_period_us = gpio_v2_line_config_debounce_period(lc, line_idx); 1150 ret = debounce_setup(line, debounce_period_us); 1151 if (ret) 1152 return ret; 1153 line_set_debounce_period(line, debounce_period_us); 1154 } 1155 1156 /* detection disabled or sw debouncer will provide edge detection */ 1157 if (!eflags || READ_ONCE(line->sw_debounced)) 1158 return 0; 1159 1160 if (IS_ENABLED(CONFIG_HTE) && 1161 (edflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE)) 1162 return hte_edge_setup(line, edflags); 1163 1164 irq = gpiod_to_irq(line->desc); 1165 if (irq < 0) 1166 return -ENXIO; 1167 1168 if (eflags & GPIO_V2_LINE_FLAG_EDGE_RISING) 1169 irqflags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? 1170 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; 1171 if (eflags & GPIO_V2_LINE_FLAG_EDGE_FALLING) 1172 irqflags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? 1173 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; 1174 irqflags |= IRQF_ONESHOT; 1175 1176 label = make_irq_label(line->req->label); 1177 if (IS_ERR(label)) 1178 return PTR_ERR(label); 1179 1180 /* Request a thread to read the events */ 1181 ret = request_threaded_irq(irq, edge_irq_handler, edge_irq_thread, 1182 irqflags, label, line); 1183 if (ret) { 1184 free_irq_label(label); 1185 return ret; 1186 } 1187 1188 line->irq = irq; 1189 return 0; 1190 } 1191 1192 static int edge_detector_update(struct line *line, 1193 struct gpio_v2_line_config *lc, 1194 unsigned int line_idx, u64 edflags) 1195 { 1196 u64 active_edflags = READ_ONCE(line->edflags); 1197 unsigned int debounce_period_us = 1198 gpio_v2_line_config_debounce_period(lc, line_idx); 1199 1200 if ((active_edflags == edflags) && 1201 (READ_ONCE(line->debounce_period_us) == debounce_period_us)) 1202 return 0; 1203 1204 /* sw debounced and still will be...*/ 1205 if (debounce_period_us && READ_ONCE(line->sw_debounced)) { 1206 line_set_debounce_period(line, debounce_period_us); 1207 return 0; 1208 } 1209 1210 /* reconfiguring edge detection or sw debounce being disabled */ 1211 if ((line->irq && !READ_ONCE(line->sw_debounced)) || 1212 (active_edflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE) || 1213 (!debounce_period_us && READ_ONCE(line->sw_debounced))) 1214 edge_detector_stop(line); 1215 1216 return edge_detector_setup(line, lc, line_idx, edflags); 1217 } 1218 1219 static u64 gpio_v2_line_config_flags(struct gpio_v2_line_config *lc, 1220 unsigned int line_idx) 1221 { 1222 unsigned int i; 1223 u64 mask = BIT_ULL(line_idx); 1224 1225 for (i = 0; i < lc->num_attrs; i++) { 1226 if ((lc->attrs[i].attr.id == GPIO_V2_LINE_ATTR_ID_FLAGS) && 1227 (lc->attrs[i].mask & mask)) 1228 return lc->attrs[i].attr.flags; 1229 } 1230 return lc->flags; 1231 } 1232 1233 static int gpio_v2_line_config_output_value(struct gpio_v2_line_config *lc, 1234 unsigned int line_idx) 1235 { 1236 unsigned int i; 1237 u64 mask = BIT_ULL(line_idx); 1238 1239 for (i = 0; i < lc->num_attrs; i++) { 1240 if ((lc->attrs[i].attr.id == GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES) && 1241 (lc->attrs[i].mask & mask)) 1242 return !!(lc->attrs[i].attr.values & mask); 1243 } 1244 return 0; 1245 } 1246 1247 static int gpio_v2_line_flags_validate(u64 flags) 1248 { 1249 /* Return an error if an unknown flag is set */ 1250 if (flags & ~GPIO_V2_LINE_VALID_FLAGS) 1251 return -EINVAL; 1252 1253 if (!IS_ENABLED(CONFIG_HTE) && 1254 (flags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE)) 1255 return -EOPNOTSUPP; 1256 1257 /* 1258 * Do not allow both INPUT and OUTPUT flags to be set as they are 1259 * contradictory. 1260 */ 1261 if ((flags & GPIO_V2_LINE_FLAG_INPUT) && 1262 (flags & GPIO_V2_LINE_FLAG_OUTPUT)) 1263 return -EINVAL; 1264 1265 /* Only allow one event clock source */ 1266 if (IS_ENABLED(CONFIG_HTE) && 1267 (flags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME) && 1268 (flags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE)) 1269 return -EINVAL; 1270 1271 /* Edge detection requires explicit input. */ 1272 if ((flags & GPIO_V2_LINE_EDGE_FLAGS) && 1273 !(flags & GPIO_V2_LINE_FLAG_INPUT)) 1274 return -EINVAL; 1275 1276 /* 1277 * Do not allow OPEN_SOURCE and OPEN_DRAIN flags in a single 1278 * request. If the hardware actually supports enabling both at the 1279 * same time the electrical result would be disastrous. 1280 */ 1281 if ((flags & GPIO_V2_LINE_FLAG_OPEN_DRAIN) && 1282 (flags & GPIO_V2_LINE_FLAG_OPEN_SOURCE)) 1283 return -EINVAL; 1284 1285 /* Drive requires explicit output direction. */ 1286 if ((flags & GPIO_V2_LINE_DRIVE_FLAGS) && 1287 !(flags & GPIO_V2_LINE_FLAG_OUTPUT)) 1288 return -EINVAL; 1289 1290 /* Bias requires explicit direction. */ 1291 if ((flags & GPIO_V2_LINE_BIAS_FLAGS) && 1292 !(flags & GPIO_V2_LINE_DIRECTION_FLAGS)) 1293 return -EINVAL; 1294 1295 /* Only one bias flag can be set. */ 1296 if (((flags & GPIO_V2_LINE_FLAG_BIAS_DISABLED) && 1297 (flags & (GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN | 1298 GPIO_V2_LINE_FLAG_BIAS_PULL_UP))) || 1299 ((flags & GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN) && 1300 (flags & GPIO_V2_LINE_FLAG_BIAS_PULL_UP))) 1301 return -EINVAL; 1302 1303 return 0; 1304 } 1305 1306 static int gpio_v2_line_config_validate(struct gpio_v2_line_config *lc, 1307 unsigned int num_lines) 1308 { 1309 unsigned int i; 1310 u64 flags; 1311 int ret; 1312 1313 if (lc->num_attrs > GPIO_V2_LINE_NUM_ATTRS_MAX) 1314 return -EINVAL; 1315 1316 if (memchr_inv(lc->padding, 0, sizeof(lc->padding))) 1317 return -EINVAL; 1318 1319 for (i = 0; i < num_lines; i++) { 1320 flags = gpio_v2_line_config_flags(lc, i); 1321 ret = gpio_v2_line_flags_validate(flags); 1322 if (ret) 1323 return ret; 1324 1325 /* debounce requires explicit input */ 1326 if (gpio_v2_line_config_debounced(lc, i) && 1327 !(flags & GPIO_V2_LINE_FLAG_INPUT)) 1328 return -EINVAL; 1329 } 1330 return 0; 1331 } 1332 1333 static void gpio_v2_line_config_flags_to_desc_flags(u64 flags, 1334 unsigned long *flagsp) 1335 { 1336 assign_bit(FLAG_ACTIVE_LOW, flagsp, 1337 flags & GPIO_V2_LINE_FLAG_ACTIVE_LOW); 1338 1339 if (flags & GPIO_V2_LINE_FLAG_OUTPUT) 1340 set_bit(FLAG_IS_OUT, flagsp); 1341 else if (flags & GPIO_V2_LINE_FLAG_INPUT) 1342 clear_bit(FLAG_IS_OUT, flagsp); 1343 1344 assign_bit(FLAG_EDGE_RISING, flagsp, 1345 flags & GPIO_V2_LINE_FLAG_EDGE_RISING); 1346 assign_bit(FLAG_EDGE_FALLING, flagsp, 1347 flags & GPIO_V2_LINE_FLAG_EDGE_FALLING); 1348 1349 assign_bit(FLAG_OPEN_DRAIN, flagsp, 1350 flags & GPIO_V2_LINE_FLAG_OPEN_DRAIN); 1351 assign_bit(FLAG_OPEN_SOURCE, flagsp, 1352 flags & GPIO_V2_LINE_FLAG_OPEN_SOURCE); 1353 1354 assign_bit(FLAG_PULL_UP, flagsp, 1355 flags & GPIO_V2_LINE_FLAG_BIAS_PULL_UP); 1356 assign_bit(FLAG_PULL_DOWN, flagsp, 1357 flags & GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN); 1358 assign_bit(FLAG_BIAS_DISABLE, flagsp, 1359 flags & GPIO_V2_LINE_FLAG_BIAS_DISABLED); 1360 1361 assign_bit(FLAG_EVENT_CLOCK_REALTIME, flagsp, 1362 flags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME); 1363 assign_bit(FLAG_EVENT_CLOCK_HTE, flagsp, 1364 flags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE); 1365 } 1366 1367 static long linereq_get_values(struct linereq *lr, void __user *ip) 1368 { 1369 struct gpio_v2_line_values lv; 1370 DECLARE_BITMAP(vals, GPIO_V2_LINES_MAX); 1371 struct gpio_desc **descs; 1372 unsigned int i, didx, num_get; 1373 bool val; 1374 int ret; 1375 1376 /* NOTE: It's ok to read values of output lines. */ 1377 if (copy_from_user(&lv, ip, sizeof(lv))) 1378 return -EFAULT; 1379 1380 /* 1381 * gpiod_get_array_value_complex() requires compacted desc and val 1382 * arrays, rather than the sparse ones in lv. 1383 * Calculation of num_get and construction of the desc array is 1384 * optimized to avoid allocation for the desc array for the common 1385 * num_get == 1 case. 1386 */ 1387 /* scan requested lines to calculate the subset to get */ 1388 for (num_get = 0, i = 0; i < lr->num_lines; i++) { 1389 if (lv.mask & BIT_ULL(i)) { 1390 num_get++; 1391 /* capture desc for the num_get == 1 case */ 1392 descs = &lr->lines[i].desc; 1393 } 1394 } 1395 1396 if (num_get == 0) 1397 return -EINVAL; 1398 1399 if (num_get != 1) { 1400 /* build compacted desc array */ 1401 descs = kmalloc_array(num_get, sizeof(*descs), GFP_KERNEL); 1402 if (!descs) 1403 return -ENOMEM; 1404 for (didx = 0, i = 0; i < lr->num_lines; i++) { 1405 if (lv.mask & BIT_ULL(i)) { 1406 descs[didx] = lr->lines[i].desc; 1407 didx++; 1408 } 1409 } 1410 } 1411 ret = gpiod_get_array_value_complex(false, true, num_get, 1412 descs, NULL, vals); 1413 1414 if (num_get != 1) 1415 kfree(descs); 1416 if (ret) 1417 return ret; 1418 1419 lv.bits = 0; 1420 for (didx = 0, i = 0; i < lr->num_lines; i++) { 1421 /* unpack compacted vals for the response */ 1422 if (lv.mask & BIT_ULL(i)) { 1423 if (lr->lines[i].sw_debounced) 1424 val = debounced_value(&lr->lines[i]); 1425 else 1426 val = test_bit(didx, vals); 1427 if (val) 1428 lv.bits |= BIT_ULL(i); 1429 didx++; 1430 } 1431 } 1432 1433 if (copy_to_user(ip, &lv, sizeof(lv))) 1434 return -EFAULT; 1435 1436 return 0; 1437 } 1438 1439 static long linereq_set_values(struct linereq *lr, void __user *ip) 1440 { 1441 DECLARE_BITMAP(vals, GPIO_V2_LINES_MAX); 1442 struct gpio_v2_line_values lv; 1443 struct gpio_desc **descs; 1444 unsigned int i, didx, num_set; 1445 int ret; 1446 1447 if (copy_from_user(&lv, ip, sizeof(lv))) 1448 return -EFAULT; 1449 1450 guard(mutex)(&lr->config_mutex); 1451 1452 /* 1453 * gpiod_set_array_value_complex() requires compacted desc and val 1454 * arrays, rather than the sparse ones in lv. 1455 * Calculation of num_set and construction of the descs and vals arrays 1456 * is optimized to minimize scanning the lv->mask, and to avoid 1457 * allocation for the desc array for the common num_set == 1 case. 1458 */ 1459 bitmap_zero(vals, GPIO_V2_LINES_MAX); 1460 /* scan requested lines to determine the subset to be set */ 1461 for (num_set = 0, i = 0; i < lr->num_lines; i++) { 1462 if (lv.mask & BIT_ULL(i)) { 1463 /* setting inputs is not allowed */ 1464 if (!test_bit(FLAG_IS_OUT, &lr->lines[i].desc->flags)) 1465 return -EPERM; 1466 /* add to compacted values */ 1467 if (lv.bits & BIT_ULL(i)) 1468 __set_bit(num_set, vals); 1469 num_set++; 1470 /* capture desc for the num_set == 1 case */ 1471 descs = &lr->lines[i].desc; 1472 } 1473 } 1474 if (num_set == 0) 1475 return -EINVAL; 1476 1477 if (num_set != 1) { 1478 /* build compacted desc array */ 1479 descs = kmalloc_array(num_set, sizeof(*descs), GFP_KERNEL); 1480 if (!descs) 1481 return -ENOMEM; 1482 for (didx = 0, i = 0; i < lr->num_lines; i++) { 1483 if (lv.mask & BIT_ULL(i)) { 1484 descs[didx] = lr->lines[i].desc; 1485 didx++; 1486 } 1487 } 1488 } 1489 ret = gpiod_set_array_value_complex(false, true, num_set, 1490 descs, NULL, vals); 1491 1492 if (num_set != 1) 1493 kfree(descs); 1494 return ret; 1495 } 1496 1497 static long linereq_set_config(struct linereq *lr, void __user *ip) 1498 { 1499 struct gpio_v2_line_config lc; 1500 struct gpio_desc *desc; 1501 struct line *line; 1502 unsigned int i; 1503 u64 flags, edflags; 1504 int ret; 1505 1506 if (copy_from_user(&lc, ip, sizeof(lc))) 1507 return -EFAULT; 1508 1509 ret = gpio_v2_line_config_validate(&lc, lr->num_lines); 1510 if (ret) 1511 return ret; 1512 1513 guard(mutex)(&lr->config_mutex); 1514 1515 for (i = 0; i < lr->num_lines; i++) { 1516 line = &lr->lines[i]; 1517 desc = lr->lines[i].desc; 1518 flags = gpio_v2_line_config_flags(&lc, i); 1519 gpio_v2_line_config_flags_to_desc_flags(flags, &desc->flags); 1520 edflags = flags & GPIO_V2_LINE_EDGE_DETECTOR_FLAGS; 1521 /* 1522 * Lines have to be requested explicitly for input 1523 * or output, else the line will be treated "as is". 1524 */ 1525 if (flags & GPIO_V2_LINE_FLAG_OUTPUT) { 1526 int val = gpio_v2_line_config_output_value(&lc, i); 1527 1528 edge_detector_stop(line); 1529 ret = gpiod_direction_output(desc, val); 1530 if (ret) 1531 return ret; 1532 } else if (flags & GPIO_V2_LINE_FLAG_INPUT) { 1533 ret = gpiod_direction_input(desc); 1534 if (ret) 1535 return ret; 1536 1537 ret = edge_detector_update(line, &lc, i, edflags); 1538 if (ret) 1539 return ret; 1540 } 1541 1542 WRITE_ONCE(line->edflags, edflags); 1543 1544 gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_CONFIG); 1545 } 1546 return 0; 1547 } 1548 1549 static long linereq_ioctl(struct file *file, unsigned int cmd, 1550 unsigned long arg) 1551 { 1552 struct linereq *lr = file->private_data; 1553 void __user *ip = (void __user *)arg; 1554 1555 guard(srcu)(&lr->gdev->srcu); 1556 1557 if (!rcu_access_pointer(lr->gdev->chip)) 1558 return -ENODEV; 1559 1560 switch (cmd) { 1561 case GPIO_V2_LINE_GET_VALUES_IOCTL: 1562 return linereq_get_values(lr, ip); 1563 case GPIO_V2_LINE_SET_VALUES_IOCTL: 1564 return linereq_set_values(lr, ip); 1565 case GPIO_V2_LINE_SET_CONFIG_IOCTL: 1566 return linereq_set_config(lr, ip); 1567 default: 1568 return -EINVAL; 1569 } 1570 } 1571 1572 #ifdef CONFIG_COMPAT 1573 static long linereq_ioctl_compat(struct file *file, unsigned int cmd, 1574 unsigned long arg) 1575 { 1576 return linereq_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 1577 } 1578 #endif 1579 1580 static __poll_t linereq_poll(struct file *file, 1581 struct poll_table_struct *wait) 1582 { 1583 struct linereq *lr = file->private_data; 1584 __poll_t events = 0; 1585 1586 guard(srcu)(&lr->gdev->srcu); 1587 1588 if (!rcu_access_pointer(lr->gdev->chip)) 1589 return EPOLLHUP | EPOLLERR; 1590 1591 poll_wait(file, &lr->wait, wait); 1592 1593 if (!kfifo_is_empty_spinlocked_noirqsave(&lr->events, 1594 &lr->wait.lock)) 1595 events = EPOLLIN | EPOLLRDNORM; 1596 1597 return events; 1598 } 1599 1600 static ssize_t linereq_read(struct file *file, char __user *buf, 1601 size_t count, loff_t *f_ps) 1602 { 1603 struct linereq *lr = file->private_data; 1604 struct gpio_v2_line_event le; 1605 ssize_t bytes_read = 0; 1606 int ret; 1607 1608 guard(srcu)(&lr->gdev->srcu); 1609 1610 if (!rcu_access_pointer(lr->gdev->chip)) 1611 return -ENODEV; 1612 1613 if (count < sizeof(le)) 1614 return -EINVAL; 1615 1616 do { 1617 scoped_guard(spinlock, &lr->wait.lock) { 1618 if (kfifo_is_empty(&lr->events)) { 1619 if (bytes_read) 1620 return bytes_read; 1621 1622 if (file->f_flags & O_NONBLOCK) 1623 return -EAGAIN; 1624 1625 ret = wait_event_interruptible_locked(lr->wait, 1626 !kfifo_is_empty(&lr->events)); 1627 if (ret) 1628 return ret; 1629 } 1630 1631 ret = kfifo_out(&lr->events, &le, 1); 1632 } 1633 if (ret != 1) { 1634 /* 1635 * This should never happen - we were holding the 1636 * lock from the moment we learned the fifo is no 1637 * longer empty until now. 1638 */ 1639 ret = -EIO; 1640 break; 1641 } 1642 1643 if (copy_to_user(buf + bytes_read, &le, sizeof(le))) 1644 return -EFAULT; 1645 bytes_read += sizeof(le); 1646 } while (count >= bytes_read + sizeof(le)); 1647 1648 return bytes_read; 1649 } 1650 1651 static void linereq_free(struct linereq *lr) 1652 { 1653 struct line *line; 1654 unsigned int i; 1655 1656 if (lr->device_unregistered_nb.notifier_call) 1657 blocking_notifier_chain_unregister(&lr->gdev->device_notifier, 1658 &lr->device_unregistered_nb); 1659 1660 for (i = 0; i < lr->num_lines; i++) { 1661 line = &lr->lines[i]; 1662 if (!line->desc) 1663 continue; 1664 1665 edge_detector_stop(line); 1666 if (line_has_supinfo(line)) 1667 supinfo_erase(line); 1668 gpiod_free(line->desc); 1669 } 1670 kfifo_free(&lr->events); 1671 kfree(lr->label); 1672 gpio_device_put(lr->gdev); 1673 kvfree(lr); 1674 } 1675 1676 static int linereq_release(struct inode *inode, struct file *file) 1677 { 1678 struct linereq *lr = file->private_data; 1679 1680 linereq_free(lr); 1681 return 0; 1682 } 1683 1684 #ifdef CONFIG_PROC_FS 1685 static void linereq_show_fdinfo(struct seq_file *out, struct file *file) 1686 { 1687 struct linereq *lr = file->private_data; 1688 struct device *dev = &lr->gdev->dev; 1689 u16 i; 1690 1691 seq_printf(out, "gpio-chip:\t%s\n", dev_name(dev)); 1692 1693 for (i = 0; i < lr->num_lines; i++) 1694 seq_printf(out, "gpio-line:\t%d\n", 1695 gpio_chip_hwgpio(lr->lines[i].desc)); 1696 } 1697 #endif 1698 1699 static const struct file_operations line_fileops = { 1700 .release = linereq_release, 1701 .read = linereq_read, 1702 .poll = linereq_poll, 1703 .owner = THIS_MODULE, 1704 .llseek = noop_llseek, 1705 .unlocked_ioctl = linereq_ioctl, 1706 #ifdef CONFIG_COMPAT 1707 .compat_ioctl = linereq_ioctl_compat, 1708 #endif 1709 #ifdef CONFIG_PROC_FS 1710 .show_fdinfo = linereq_show_fdinfo, 1711 #endif 1712 }; 1713 1714 static int linereq_create(struct gpio_device *gdev, void __user *ip) 1715 { 1716 struct gpio_v2_line_request ulr; 1717 struct gpio_v2_line_config *lc; 1718 struct linereq *lr; 1719 struct file *file; 1720 u64 flags, edflags; 1721 unsigned int i; 1722 int fd, ret; 1723 1724 if (copy_from_user(&ulr, ip, sizeof(ulr))) 1725 return -EFAULT; 1726 1727 if ((ulr.num_lines == 0) || (ulr.num_lines > GPIO_V2_LINES_MAX)) 1728 return -EINVAL; 1729 1730 if (memchr_inv(ulr.padding, 0, sizeof(ulr.padding))) 1731 return -EINVAL; 1732 1733 lc = &ulr.config; 1734 ret = gpio_v2_line_config_validate(lc, ulr.num_lines); 1735 if (ret) 1736 return ret; 1737 1738 lr = kvzalloc(struct_size(lr, lines, ulr.num_lines), GFP_KERNEL); 1739 if (!lr) 1740 return -ENOMEM; 1741 lr->num_lines = ulr.num_lines; 1742 1743 lr->gdev = gpio_device_get(gdev); 1744 1745 for (i = 0; i < ulr.num_lines; i++) { 1746 lr->lines[i].req = lr; 1747 WRITE_ONCE(lr->lines[i].sw_debounced, 0); 1748 INIT_DELAYED_WORK(&lr->lines[i].work, debounce_work_func); 1749 } 1750 1751 if (ulr.consumer[0] != '\0') { 1752 /* label is only initialized if consumer is set */ 1753 lr->label = kstrndup(ulr.consumer, sizeof(ulr.consumer) - 1, 1754 GFP_KERNEL); 1755 if (!lr->label) { 1756 ret = -ENOMEM; 1757 goto out_free_linereq; 1758 } 1759 } 1760 1761 mutex_init(&lr->config_mutex); 1762 init_waitqueue_head(&lr->wait); 1763 lr->event_buffer_size = ulr.event_buffer_size; 1764 if (lr->event_buffer_size == 0) 1765 lr->event_buffer_size = ulr.num_lines * 16; 1766 else if (lr->event_buffer_size > GPIO_V2_LINES_MAX * 16) 1767 lr->event_buffer_size = GPIO_V2_LINES_MAX * 16; 1768 1769 atomic_set(&lr->seqno, 0); 1770 1771 /* Request each GPIO */ 1772 for (i = 0; i < ulr.num_lines; i++) { 1773 u32 offset = ulr.offsets[i]; 1774 struct gpio_desc *desc = gpio_device_get_desc(gdev, offset); 1775 1776 if (IS_ERR(desc)) { 1777 ret = PTR_ERR(desc); 1778 goto out_free_linereq; 1779 } 1780 1781 ret = gpiod_request_user(desc, lr->label); 1782 if (ret) 1783 goto out_free_linereq; 1784 1785 lr->lines[i].desc = desc; 1786 flags = gpio_v2_line_config_flags(lc, i); 1787 gpio_v2_line_config_flags_to_desc_flags(flags, &desc->flags); 1788 1789 ret = gpiod_set_transitory(desc, false); 1790 if (ret < 0) 1791 goto out_free_linereq; 1792 1793 edflags = flags & GPIO_V2_LINE_EDGE_DETECTOR_FLAGS; 1794 /* 1795 * Lines have to be requested explicitly for input 1796 * or output, else the line will be treated "as is". 1797 */ 1798 if (flags & GPIO_V2_LINE_FLAG_OUTPUT) { 1799 int val = gpio_v2_line_config_output_value(lc, i); 1800 1801 ret = gpiod_direction_output(desc, val); 1802 if (ret) 1803 goto out_free_linereq; 1804 } else if (flags & GPIO_V2_LINE_FLAG_INPUT) { 1805 ret = gpiod_direction_input(desc); 1806 if (ret) 1807 goto out_free_linereq; 1808 1809 ret = edge_detector_setup(&lr->lines[i], lc, i, 1810 edflags); 1811 if (ret) 1812 goto out_free_linereq; 1813 } 1814 1815 lr->lines[i].edflags = edflags; 1816 1817 gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_REQUESTED); 1818 1819 dev_dbg(&gdev->dev, "registered chardev handle for line %d\n", 1820 offset); 1821 } 1822 1823 lr->device_unregistered_nb.notifier_call = linereq_unregistered_notify; 1824 ret = blocking_notifier_chain_register(&gdev->device_notifier, 1825 &lr->device_unregistered_nb); 1826 if (ret) 1827 goto out_free_linereq; 1828 1829 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC); 1830 if (fd < 0) { 1831 ret = fd; 1832 goto out_free_linereq; 1833 } 1834 1835 file = anon_inode_getfile("gpio-line", &line_fileops, lr, 1836 O_RDONLY | O_CLOEXEC); 1837 if (IS_ERR(file)) { 1838 ret = PTR_ERR(file); 1839 goto out_put_unused_fd; 1840 } 1841 1842 ulr.fd = fd; 1843 if (copy_to_user(ip, &ulr, sizeof(ulr))) { 1844 /* 1845 * fput() will trigger the release() callback, so do not go onto 1846 * the regular error cleanup path here. 1847 */ 1848 fput(file); 1849 put_unused_fd(fd); 1850 return -EFAULT; 1851 } 1852 1853 fd_install(fd, file); 1854 1855 dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n", 1856 lr->num_lines); 1857 1858 return 0; 1859 1860 out_put_unused_fd: 1861 put_unused_fd(fd); 1862 out_free_linereq: 1863 linereq_free(lr); 1864 return ret; 1865 } 1866 1867 #ifdef CONFIG_GPIO_CDEV_V1 1868 1869 /* 1870 * GPIO line event management 1871 */ 1872 1873 /** 1874 * struct lineevent_state - contains the state of a userspace event 1875 * @gdev: the GPIO device the event pertains to 1876 * @label: consumer label used to tag descriptors 1877 * @desc: the GPIO descriptor held by this event 1878 * @eflags: the event flags this line was requested with 1879 * @irq: the interrupt that trigger in response to events on this GPIO 1880 * @wait: wait queue that handles blocking reads of events 1881 * @device_unregistered_nb: notifier block for receiving gdev unregister events 1882 * @events: KFIFO for the GPIO events 1883 * @timestamp: cache for the timestamp storing it between hardirq 1884 * and IRQ thread, used to bring the timestamp close to the actual 1885 * event 1886 */ 1887 struct lineevent_state { 1888 struct gpio_device *gdev; 1889 const char *label; 1890 struct gpio_desc *desc; 1891 u32 eflags; 1892 int irq; 1893 wait_queue_head_t wait; 1894 struct notifier_block device_unregistered_nb; 1895 DECLARE_KFIFO(events, struct gpioevent_data, 16); 1896 u64 timestamp; 1897 }; 1898 1899 #define GPIOEVENT_REQUEST_VALID_FLAGS \ 1900 (GPIOEVENT_REQUEST_RISING_EDGE | \ 1901 GPIOEVENT_REQUEST_FALLING_EDGE) 1902 1903 static __poll_t lineevent_poll(struct file *file, 1904 struct poll_table_struct *wait) 1905 { 1906 struct lineevent_state *le = file->private_data; 1907 __poll_t events = 0; 1908 1909 guard(srcu)(&le->gdev->srcu); 1910 1911 if (!rcu_access_pointer(le->gdev->chip)) 1912 return EPOLLHUP | EPOLLERR; 1913 1914 poll_wait(file, &le->wait, wait); 1915 1916 if (!kfifo_is_empty_spinlocked_noirqsave(&le->events, &le->wait.lock)) 1917 events = EPOLLIN | EPOLLRDNORM; 1918 1919 return events; 1920 } 1921 1922 static int lineevent_unregistered_notify(struct notifier_block *nb, 1923 unsigned long action, void *data) 1924 { 1925 struct lineevent_state *le = container_of(nb, struct lineevent_state, 1926 device_unregistered_nb); 1927 1928 wake_up_poll(&le->wait, EPOLLIN | EPOLLERR); 1929 1930 return NOTIFY_OK; 1931 } 1932 1933 struct compat_gpioeevent_data { 1934 compat_u64 timestamp; 1935 u32 id; 1936 }; 1937 1938 static ssize_t lineevent_read(struct file *file, char __user *buf, 1939 size_t count, loff_t *f_ps) 1940 { 1941 struct lineevent_state *le = file->private_data; 1942 struct gpioevent_data ge; 1943 ssize_t bytes_read = 0; 1944 ssize_t ge_size; 1945 int ret; 1946 1947 guard(srcu)(&le->gdev->srcu); 1948 1949 if (!rcu_access_pointer(le->gdev->chip)) 1950 return -ENODEV; 1951 1952 /* 1953 * When compatible system call is being used the struct gpioevent_data, 1954 * in case of at least ia32, has different size due to the alignment 1955 * differences. Because we have first member 64 bits followed by one of 1956 * 32 bits there is no gap between them. The only difference is the 1957 * padding at the end of the data structure. Hence, we calculate the 1958 * actual sizeof() and pass this as an argument to copy_to_user() to 1959 * drop unneeded bytes from the output. 1960 */ 1961 if (compat_need_64bit_alignment_fixup()) 1962 ge_size = sizeof(struct compat_gpioeevent_data); 1963 else 1964 ge_size = sizeof(struct gpioevent_data); 1965 if (count < ge_size) 1966 return -EINVAL; 1967 1968 do { 1969 scoped_guard(spinlock, &le->wait.lock) { 1970 if (kfifo_is_empty(&le->events)) { 1971 if (bytes_read) 1972 return bytes_read; 1973 1974 if (file->f_flags & O_NONBLOCK) 1975 return -EAGAIN; 1976 1977 ret = wait_event_interruptible_locked(le->wait, 1978 !kfifo_is_empty(&le->events)); 1979 if (ret) 1980 return ret; 1981 } 1982 1983 ret = kfifo_out(&le->events, &ge, 1); 1984 } 1985 if (ret != 1) { 1986 /* 1987 * This should never happen - we were holding the lock 1988 * from the moment we learned the fifo is no longer 1989 * empty until now. 1990 */ 1991 ret = -EIO; 1992 break; 1993 } 1994 1995 if (copy_to_user(buf + bytes_read, &ge, ge_size)) 1996 return -EFAULT; 1997 bytes_read += ge_size; 1998 } while (count >= bytes_read + ge_size); 1999 2000 return bytes_read; 2001 } 2002 2003 static void lineevent_free(struct lineevent_state *le) 2004 { 2005 if (le->device_unregistered_nb.notifier_call) 2006 blocking_notifier_chain_unregister(&le->gdev->device_notifier, 2007 &le->device_unregistered_nb); 2008 if (le->irq) 2009 free_irq_label(free_irq(le->irq, le)); 2010 if (le->desc) 2011 gpiod_free(le->desc); 2012 kfree(le->label); 2013 gpio_device_put(le->gdev); 2014 kfree(le); 2015 } 2016 2017 static int lineevent_release(struct inode *inode, struct file *file) 2018 { 2019 lineevent_free(file->private_data); 2020 return 0; 2021 } 2022 2023 static long lineevent_ioctl(struct file *file, unsigned int cmd, 2024 unsigned long arg) 2025 { 2026 struct lineevent_state *le = file->private_data; 2027 void __user *ip = (void __user *)arg; 2028 struct gpiohandle_data ghd; 2029 2030 guard(srcu)(&le->gdev->srcu); 2031 2032 if (!rcu_access_pointer(le->gdev->chip)) 2033 return -ENODEV; 2034 2035 /* 2036 * We can get the value for an event line but not set it, 2037 * because it is input by definition. 2038 */ 2039 if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) { 2040 int val; 2041 2042 memset(&ghd, 0, sizeof(ghd)); 2043 2044 val = gpiod_get_value_cansleep(le->desc); 2045 if (val < 0) 2046 return val; 2047 ghd.values[0] = val; 2048 2049 if (copy_to_user(ip, &ghd, sizeof(ghd))) 2050 return -EFAULT; 2051 2052 return 0; 2053 } 2054 return -EINVAL; 2055 } 2056 2057 #ifdef CONFIG_COMPAT 2058 static long lineevent_ioctl_compat(struct file *file, unsigned int cmd, 2059 unsigned long arg) 2060 { 2061 return lineevent_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 2062 } 2063 #endif 2064 2065 static const struct file_operations lineevent_fileops = { 2066 .release = lineevent_release, 2067 .read = lineevent_read, 2068 .poll = lineevent_poll, 2069 .owner = THIS_MODULE, 2070 .llseek = noop_llseek, 2071 .unlocked_ioctl = lineevent_ioctl, 2072 #ifdef CONFIG_COMPAT 2073 .compat_ioctl = lineevent_ioctl_compat, 2074 #endif 2075 }; 2076 2077 static irqreturn_t lineevent_irq_thread(int irq, void *p) 2078 { 2079 struct lineevent_state *le = p; 2080 struct gpioevent_data ge; 2081 int ret; 2082 2083 /* Do not leak kernel stack to userspace */ 2084 memset(&ge, 0, sizeof(ge)); 2085 2086 /* 2087 * We may be running from a nested threaded interrupt in which case 2088 * we didn't get the timestamp from lineevent_irq_handler(). 2089 */ 2090 if (!le->timestamp) 2091 ge.timestamp = ktime_get_ns(); 2092 else 2093 ge.timestamp = le->timestamp; 2094 2095 if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE 2096 && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) { 2097 int level = gpiod_get_value_cansleep(le->desc); 2098 2099 if (level) 2100 /* Emit low-to-high event */ 2101 ge.id = GPIOEVENT_EVENT_RISING_EDGE; 2102 else 2103 /* Emit high-to-low event */ 2104 ge.id = GPIOEVENT_EVENT_FALLING_EDGE; 2105 } else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) { 2106 /* Emit low-to-high event */ 2107 ge.id = GPIOEVENT_EVENT_RISING_EDGE; 2108 } else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) { 2109 /* Emit high-to-low event */ 2110 ge.id = GPIOEVENT_EVENT_FALLING_EDGE; 2111 } else { 2112 return IRQ_NONE; 2113 } 2114 2115 ret = kfifo_in_spinlocked_noirqsave(&le->events, &ge, 2116 1, &le->wait.lock); 2117 if (ret) 2118 wake_up_poll(&le->wait, EPOLLIN); 2119 else 2120 pr_debug_ratelimited("event FIFO is full - event dropped\n"); 2121 2122 return IRQ_HANDLED; 2123 } 2124 2125 static irqreturn_t lineevent_irq_handler(int irq, void *p) 2126 { 2127 struct lineevent_state *le = p; 2128 2129 /* 2130 * Just store the timestamp in hardirq context so we get it as 2131 * close in time as possible to the actual event. 2132 */ 2133 le->timestamp = ktime_get_ns(); 2134 2135 return IRQ_WAKE_THREAD; 2136 } 2137 2138 static int lineevent_create(struct gpio_device *gdev, void __user *ip) 2139 { 2140 struct gpioevent_request eventreq; 2141 struct lineevent_state *le; 2142 struct gpio_desc *desc; 2143 struct file *file; 2144 u32 offset; 2145 u32 lflags; 2146 u32 eflags; 2147 int fd; 2148 int ret; 2149 int irq, irqflags = 0; 2150 char *label; 2151 2152 if (copy_from_user(&eventreq, ip, sizeof(eventreq))) 2153 return -EFAULT; 2154 2155 offset = eventreq.lineoffset; 2156 lflags = eventreq.handleflags; 2157 eflags = eventreq.eventflags; 2158 2159 desc = gpio_device_get_desc(gdev, offset); 2160 if (IS_ERR(desc)) 2161 return PTR_ERR(desc); 2162 2163 /* Return an error if a unknown flag is set */ 2164 if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) || 2165 (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS)) 2166 return -EINVAL; 2167 2168 /* This is just wrong: we don't look for events on output lines */ 2169 if ((lflags & GPIOHANDLE_REQUEST_OUTPUT) || 2170 (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) || 2171 (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)) 2172 return -EINVAL; 2173 2174 /* Only one bias flag can be set. */ 2175 if (((lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE) && 2176 (lflags & (GPIOHANDLE_REQUEST_BIAS_PULL_DOWN | 2177 GPIOHANDLE_REQUEST_BIAS_PULL_UP))) || 2178 ((lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN) && 2179 (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP))) 2180 return -EINVAL; 2181 2182 le = kzalloc(sizeof(*le), GFP_KERNEL); 2183 if (!le) 2184 return -ENOMEM; 2185 le->gdev = gpio_device_get(gdev); 2186 2187 if (eventreq.consumer_label[0] != '\0') { 2188 /* label is only initialized if consumer_label is set */ 2189 le->label = kstrndup(eventreq.consumer_label, 2190 sizeof(eventreq.consumer_label) - 1, 2191 GFP_KERNEL); 2192 if (!le->label) { 2193 ret = -ENOMEM; 2194 goto out_free_le; 2195 } 2196 } 2197 2198 ret = gpiod_request_user(desc, le->label); 2199 if (ret) 2200 goto out_free_le; 2201 le->desc = desc; 2202 le->eflags = eflags; 2203 2204 linehandle_flags_to_desc_flags(lflags, &desc->flags); 2205 2206 ret = gpiod_direction_input(desc); 2207 if (ret) 2208 goto out_free_le; 2209 2210 gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_REQUESTED); 2211 2212 irq = gpiod_to_irq(desc); 2213 if (irq <= 0) { 2214 ret = -ENODEV; 2215 goto out_free_le; 2216 } 2217 2218 if (eflags & GPIOEVENT_REQUEST_RISING_EDGE) 2219 irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? 2220 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; 2221 if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE) 2222 irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? 2223 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; 2224 irqflags |= IRQF_ONESHOT; 2225 2226 INIT_KFIFO(le->events); 2227 init_waitqueue_head(&le->wait); 2228 2229 le->device_unregistered_nb.notifier_call = lineevent_unregistered_notify; 2230 ret = blocking_notifier_chain_register(&gdev->device_notifier, 2231 &le->device_unregistered_nb); 2232 if (ret) 2233 goto out_free_le; 2234 2235 label = make_irq_label(le->label); 2236 if (IS_ERR(label)) { 2237 ret = PTR_ERR(label); 2238 goto out_free_le; 2239 } 2240 2241 /* Request a thread to read the events */ 2242 ret = request_threaded_irq(irq, 2243 lineevent_irq_handler, 2244 lineevent_irq_thread, 2245 irqflags, 2246 label, 2247 le); 2248 if (ret) { 2249 free_irq_label(label); 2250 goto out_free_le; 2251 } 2252 2253 le->irq = irq; 2254 2255 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC); 2256 if (fd < 0) { 2257 ret = fd; 2258 goto out_free_le; 2259 } 2260 2261 file = anon_inode_getfile("gpio-event", 2262 &lineevent_fileops, 2263 le, 2264 O_RDONLY | O_CLOEXEC); 2265 if (IS_ERR(file)) { 2266 ret = PTR_ERR(file); 2267 goto out_put_unused_fd; 2268 } 2269 2270 eventreq.fd = fd; 2271 if (copy_to_user(ip, &eventreq, sizeof(eventreq))) { 2272 /* 2273 * fput() will trigger the release() callback, so do not go onto 2274 * the regular error cleanup path here. 2275 */ 2276 fput(file); 2277 put_unused_fd(fd); 2278 return -EFAULT; 2279 } 2280 2281 fd_install(fd, file); 2282 2283 return 0; 2284 2285 out_put_unused_fd: 2286 put_unused_fd(fd); 2287 out_free_le: 2288 lineevent_free(le); 2289 return ret; 2290 } 2291 2292 static void gpio_v2_line_info_to_v1(struct gpio_v2_line_info *info_v2, 2293 struct gpioline_info *info_v1) 2294 { 2295 u64 flagsv2 = info_v2->flags; 2296 2297 memcpy(info_v1->name, info_v2->name, sizeof(info_v1->name)); 2298 memcpy(info_v1->consumer, info_v2->consumer, sizeof(info_v1->consumer)); 2299 info_v1->line_offset = info_v2->offset; 2300 info_v1->flags = 0; 2301 2302 if (flagsv2 & GPIO_V2_LINE_FLAG_USED) 2303 info_v1->flags |= GPIOLINE_FLAG_KERNEL; 2304 2305 if (flagsv2 & GPIO_V2_LINE_FLAG_OUTPUT) 2306 info_v1->flags |= GPIOLINE_FLAG_IS_OUT; 2307 2308 if (flagsv2 & GPIO_V2_LINE_FLAG_ACTIVE_LOW) 2309 info_v1->flags |= GPIOLINE_FLAG_ACTIVE_LOW; 2310 2311 if (flagsv2 & GPIO_V2_LINE_FLAG_OPEN_DRAIN) 2312 info_v1->flags |= GPIOLINE_FLAG_OPEN_DRAIN; 2313 if (flagsv2 & GPIO_V2_LINE_FLAG_OPEN_SOURCE) 2314 info_v1->flags |= GPIOLINE_FLAG_OPEN_SOURCE; 2315 2316 if (flagsv2 & GPIO_V2_LINE_FLAG_BIAS_PULL_UP) 2317 info_v1->flags |= GPIOLINE_FLAG_BIAS_PULL_UP; 2318 if (flagsv2 & GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN) 2319 info_v1->flags |= GPIOLINE_FLAG_BIAS_PULL_DOWN; 2320 if (flagsv2 & GPIO_V2_LINE_FLAG_BIAS_DISABLED) 2321 info_v1->flags |= GPIOLINE_FLAG_BIAS_DISABLE; 2322 } 2323 2324 static void gpio_v2_line_info_changed_to_v1( 2325 struct gpio_v2_line_info_changed *lic_v2, 2326 struct gpioline_info_changed *lic_v1) 2327 { 2328 memset(lic_v1, 0, sizeof(*lic_v1)); 2329 gpio_v2_line_info_to_v1(&lic_v2->info, &lic_v1->info); 2330 lic_v1->timestamp = lic_v2->timestamp_ns; 2331 lic_v1->event_type = lic_v2->event_type; 2332 } 2333 2334 #endif /* CONFIG_GPIO_CDEV_V1 */ 2335 2336 static void gpio_desc_to_lineinfo(struct gpio_desc *desc, 2337 struct gpio_v2_line_info *info) 2338 { 2339 unsigned long dflags; 2340 const char *label; 2341 2342 CLASS(gpio_chip_guard, guard)(desc); 2343 if (!guard.gc) 2344 return; 2345 2346 memset(info, 0, sizeof(*info)); 2347 info->offset = gpio_chip_hwgpio(desc); 2348 2349 if (desc->name) 2350 strscpy(info->name, desc->name, sizeof(info->name)); 2351 2352 dflags = READ_ONCE(desc->flags); 2353 2354 scoped_guard(srcu, &desc->srcu) { 2355 label = gpiod_get_label(desc); 2356 if (label && test_bit(FLAG_REQUESTED, &dflags)) 2357 strscpy(info->consumer, label, 2358 sizeof(info->consumer)); 2359 } 2360 2361 /* 2362 * Userspace only need know that the kernel is using this GPIO so it 2363 * can't use it. 2364 * The calculation of the used flag is slightly racy, as it may read 2365 * desc, gc and pinctrl state without a lock covering all three at 2366 * once. Worst case if the line is in transition and the calculation 2367 * is inconsistent then it looks to the user like they performed the 2368 * read on the other side of the transition - but that can always 2369 * happen. 2370 * The definitive test that a line is available to userspace is to 2371 * request it. 2372 */ 2373 if (test_bit(FLAG_REQUESTED, &dflags) || 2374 test_bit(FLAG_IS_HOGGED, &dflags) || 2375 test_bit(FLAG_USED_AS_IRQ, &dflags) || 2376 test_bit(FLAG_EXPORT, &dflags) || 2377 test_bit(FLAG_SYSFS, &dflags) || 2378 !gpiochip_line_is_valid(guard.gc, info->offset) || 2379 !pinctrl_gpio_can_use_line(guard.gc, info->offset)) 2380 info->flags |= GPIO_V2_LINE_FLAG_USED; 2381 2382 if (test_bit(FLAG_IS_OUT, &dflags)) 2383 info->flags |= GPIO_V2_LINE_FLAG_OUTPUT; 2384 else 2385 info->flags |= GPIO_V2_LINE_FLAG_INPUT; 2386 2387 if (test_bit(FLAG_ACTIVE_LOW, &dflags)) 2388 info->flags |= GPIO_V2_LINE_FLAG_ACTIVE_LOW; 2389 2390 if (test_bit(FLAG_OPEN_DRAIN, &dflags)) 2391 info->flags |= GPIO_V2_LINE_FLAG_OPEN_DRAIN; 2392 if (test_bit(FLAG_OPEN_SOURCE, &dflags)) 2393 info->flags |= GPIO_V2_LINE_FLAG_OPEN_SOURCE; 2394 2395 if (test_bit(FLAG_BIAS_DISABLE, &dflags)) 2396 info->flags |= GPIO_V2_LINE_FLAG_BIAS_DISABLED; 2397 if (test_bit(FLAG_PULL_DOWN, &dflags)) 2398 info->flags |= GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN; 2399 if (test_bit(FLAG_PULL_UP, &dflags)) 2400 info->flags |= GPIO_V2_LINE_FLAG_BIAS_PULL_UP; 2401 2402 if (test_bit(FLAG_EDGE_RISING, &dflags)) 2403 info->flags |= GPIO_V2_LINE_FLAG_EDGE_RISING; 2404 if (test_bit(FLAG_EDGE_FALLING, &dflags)) 2405 info->flags |= GPIO_V2_LINE_FLAG_EDGE_FALLING; 2406 2407 if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &dflags)) 2408 info->flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME; 2409 else if (test_bit(FLAG_EVENT_CLOCK_HTE, &dflags)) 2410 info->flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE; 2411 } 2412 2413 struct gpio_chardev_data { 2414 struct gpio_device *gdev; 2415 wait_queue_head_t wait; 2416 DECLARE_KFIFO(events, struct gpio_v2_line_info_changed, 32); 2417 struct notifier_block lineinfo_changed_nb; 2418 struct notifier_block device_unregistered_nb; 2419 unsigned long *watched_lines; 2420 #ifdef CONFIG_GPIO_CDEV_V1 2421 atomic_t watch_abi_version; 2422 #endif 2423 }; 2424 2425 static int chipinfo_get(struct gpio_chardev_data *cdev, void __user *ip) 2426 { 2427 struct gpio_device *gdev = cdev->gdev; 2428 struct gpiochip_info chipinfo; 2429 2430 memset(&chipinfo, 0, sizeof(chipinfo)); 2431 2432 strscpy(chipinfo.name, dev_name(&gdev->dev), sizeof(chipinfo.name)); 2433 strscpy(chipinfo.label, gdev->label, sizeof(chipinfo.label)); 2434 chipinfo.lines = gdev->ngpio; 2435 if (copy_to_user(ip, &chipinfo, sizeof(chipinfo))) 2436 return -EFAULT; 2437 return 0; 2438 } 2439 2440 #ifdef CONFIG_GPIO_CDEV_V1 2441 /* 2442 * returns 0 if the versions match, else the previously selected ABI version 2443 */ 2444 static int lineinfo_ensure_abi_version(struct gpio_chardev_data *cdata, 2445 unsigned int version) 2446 { 2447 int abiv = atomic_cmpxchg(&cdata->watch_abi_version, 0, version); 2448 2449 if (abiv == version) 2450 return 0; 2451 2452 return abiv; 2453 } 2454 2455 static int lineinfo_get_v1(struct gpio_chardev_data *cdev, void __user *ip, 2456 bool watch) 2457 { 2458 struct gpio_desc *desc; 2459 struct gpioline_info lineinfo; 2460 struct gpio_v2_line_info lineinfo_v2; 2461 2462 if (copy_from_user(&lineinfo, ip, sizeof(lineinfo))) 2463 return -EFAULT; 2464 2465 /* this doubles as a range check on line_offset */ 2466 desc = gpio_device_get_desc(cdev->gdev, lineinfo.line_offset); 2467 if (IS_ERR(desc)) 2468 return PTR_ERR(desc); 2469 2470 if (watch) { 2471 if (lineinfo_ensure_abi_version(cdev, 1)) 2472 return -EPERM; 2473 2474 if (test_and_set_bit(lineinfo.line_offset, cdev->watched_lines)) 2475 return -EBUSY; 2476 } 2477 2478 gpio_desc_to_lineinfo(desc, &lineinfo_v2); 2479 gpio_v2_line_info_to_v1(&lineinfo_v2, &lineinfo); 2480 2481 if (copy_to_user(ip, &lineinfo, sizeof(lineinfo))) { 2482 if (watch) 2483 clear_bit(lineinfo.line_offset, cdev->watched_lines); 2484 return -EFAULT; 2485 } 2486 2487 return 0; 2488 } 2489 #endif 2490 2491 static int lineinfo_get(struct gpio_chardev_data *cdev, void __user *ip, 2492 bool watch) 2493 { 2494 struct gpio_desc *desc; 2495 struct gpio_v2_line_info lineinfo; 2496 2497 if (copy_from_user(&lineinfo, ip, sizeof(lineinfo))) 2498 return -EFAULT; 2499 2500 if (memchr_inv(lineinfo.padding, 0, sizeof(lineinfo.padding))) 2501 return -EINVAL; 2502 2503 desc = gpio_device_get_desc(cdev->gdev, lineinfo.offset); 2504 if (IS_ERR(desc)) 2505 return PTR_ERR(desc); 2506 2507 if (watch) { 2508 #ifdef CONFIG_GPIO_CDEV_V1 2509 if (lineinfo_ensure_abi_version(cdev, 2)) 2510 return -EPERM; 2511 #endif 2512 if (test_and_set_bit(lineinfo.offset, cdev->watched_lines)) 2513 return -EBUSY; 2514 } 2515 gpio_desc_to_lineinfo(desc, &lineinfo); 2516 supinfo_to_lineinfo(desc, &lineinfo); 2517 2518 if (copy_to_user(ip, &lineinfo, sizeof(lineinfo))) { 2519 if (watch) 2520 clear_bit(lineinfo.offset, cdev->watched_lines); 2521 return -EFAULT; 2522 } 2523 2524 return 0; 2525 } 2526 2527 static int lineinfo_unwatch(struct gpio_chardev_data *cdev, void __user *ip) 2528 { 2529 __u32 offset; 2530 2531 if (copy_from_user(&offset, ip, sizeof(offset))) 2532 return -EFAULT; 2533 2534 if (offset >= cdev->gdev->ngpio) 2535 return -EINVAL; 2536 2537 if (!test_and_clear_bit(offset, cdev->watched_lines)) 2538 return -EBUSY; 2539 2540 return 0; 2541 } 2542 2543 /* 2544 * gpio_ioctl() - ioctl handler for the GPIO chardev 2545 */ 2546 static long gpio_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2547 { 2548 struct gpio_chardev_data *cdev = file->private_data; 2549 struct gpio_device *gdev = cdev->gdev; 2550 void __user *ip = (void __user *)arg; 2551 2552 guard(srcu)(&gdev->srcu); 2553 2554 /* We fail any subsequent ioctl():s when the chip is gone */ 2555 if (!rcu_access_pointer(gdev->chip)) 2556 return -ENODEV; 2557 2558 /* Fill in the struct and pass to userspace */ 2559 switch (cmd) { 2560 case GPIO_GET_CHIPINFO_IOCTL: 2561 return chipinfo_get(cdev, ip); 2562 #ifdef CONFIG_GPIO_CDEV_V1 2563 case GPIO_GET_LINEHANDLE_IOCTL: 2564 return linehandle_create(gdev, ip); 2565 case GPIO_GET_LINEEVENT_IOCTL: 2566 return lineevent_create(gdev, ip); 2567 case GPIO_GET_LINEINFO_IOCTL: 2568 return lineinfo_get_v1(cdev, ip, false); 2569 case GPIO_GET_LINEINFO_WATCH_IOCTL: 2570 return lineinfo_get_v1(cdev, ip, true); 2571 #endif /* CONFIG_GPIO_CDEV_V1 */ 2572 case GPIO_V2_GET_LINEINFO_IOCTL: 2573 return lineinfo_get(cdev, ip, false); 2574 case GPIO_V2_GET_LINEINFO_WATCH_IOCTL: 2575 return lineinfo_get(cdev, ip, true); 2576 case GPIO_V2_GET_LINE_IOCTL: 2577 return linereq_create(gdev, ip); 2578 case GPIO_GET_LINEINFO_UNWATCH_IOCTL: 2579 return lineinfo_unwatch(cdev, ip); 2580 default: 2581 return -EINVAL; 2582 } 2583 } 2584 2585 #ifdef CONFIG_COMPAT 2586 static long gpio_ioctl_compat(struct file *file, unsigned int cmd, 2587 unsigned long arg) 2588 { 2589 return gpio_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 2590 } 2591 #endif 2592 2593 static int lineinfo_changed_notify(struct notifier_block *nb, 2594 unsigned long action, void *data) 2595 { 2596 struct gpio_chardev_data *cdev = 2597 container_of(nb, struct gpio_chardev_data, lineinfo_changed_nb); 2598 struct gpio_v2_line_info_changed chg; 2599 struct gpio_desc *desc = data; 2600 int ret; 2601 2602 if (!test_bit(gpio_chip_hwgpio(desc), cdev->watched_lines)) 2603 return NOTIFY_DONE; 2604 2605 memset(&chg, 0, sizeof(chg)); 2606 chg.event_type = action; 2607 chg.timestamp_ns = ktime_get_ns(); 2608 gpio_desc_to_lineinfo(desc, &chg.info); 2609 supinfo_to_lineinfo(desc, &chg.info); 2610 2611 ret = kfifo_in_spinlocked(&cdev->events, &chg, 1, &cdev->wait.lock); 2612 if (ret) 2613 wake_up_poll(&cdev->wait, EPOLLIN); 2614 else 2615 pr_debug_ratelimited("lineinfo event FIFO is full - event dropped\n"); 2616 2617 return NOTIFY_OK; 2618 } 2619 2620 static int gpio_device_unregistered_notify(struct notifier_block *nb, 2621 unsigned long action, void *data) 2622 { 2623 struct gpio_chardev_data *cdev = container_of(nb, 2624 struct gpio_chardev_data, 2625 device_unregistered_nb); 2626 2627 wake_up_poll(&cdev->wait, EPOLLIN | EPOLLERR); 2628 2629 return NOTIFY_OK; 2630 } 2631 2632 static __poll_t lineinfo_watch_poll(struct file *file, 2633 struct poll_table_struct *pollt) 2634 { 2635 struct gpio_chardev_data *cdev = file->private_data; 2636 __poll_t events = 0; 2637 2638 guard(srcu)(&cdev->gdev->srcu); 2639 2640 if (!rcu_access_pointer(cdev->gdev->chip)) 2641 return EPOLLHUP | EPOLLERR; 2642 2643 poll_wait(file, &cdev->wait, pollt); 2644 2645 if (!kfifo_is_empty_spinlocked_noirqsave(&cdev->events, 2646 &cdev->wait.lock)) 2647 events = EPOLLIN | EPOLLRDNORM; 2648 2649 return events; 2650 } 2651 2652 static ssize_t lineinfo_watch_read(struct file *file, char __user *buf, 2653 size_t count, loff_t *off) 2654 { 2655 struct gpio_chardev_data *cdev = file->private_data; 2656 struct gpio_v2_line_info_changed event; 2657 ssize_t bytes_read = 0; 2658 int ret; 2659 size_t event_size; 2660 2661 guard(srcu)(&cdev->gdev->srcu); 2662 2663 if (!rcu_access_pointer(cdev->gdev->chip)) 2664 return -ENODEV; 2665 2666 #ifndef CONFIG_GPIO_CDEV_V1 2667 event_size = sizeof(struct gpio_v2_line_info_changed); 2668 if (count < event_size) 2669 return -EINVAL; 2670 #endif 2671 2672 do { 2673 scoped_guard(spinlock, &cdev->wait.lock) { 2674 if (kfifo_is_empty(&cdev->events)) { 2675 if (bytes_read) 2676 return bytes_read; 2677 2678 if (file->f_flags & O_NONBLOCK) 2679 return -EAGAIN; 2680 2681 ret = wait_event_interruptible_locked(cdev->wait, 2682 !kfifo_is_empty(&cdev->events)); 2683 if (ret) 2684 return ret; 2685 } 2686 #ifdef CONFIG_GPIO_CDEV_V1 2687 /* must be after kfifo check so watch_abi_version is set */ 2688 if (atomic_read(&cdev->watch_abi_version) == 2) 2689 event_size = sizeof(struct gpio_v2_line_info_changed); 2690 else 2691 event_size = sizeof(struct gpioline_info_changed); 2692 if (count < event_size) 2693 return -EINVAL; 2694 #endif 2695 ret = kfifo_out(&cdev->events, &event, 1); 2696 } 2697 if (ret != 1) { 2698 ret = -EIO; 2699 break; 2700 /* We should never get here. See lineevent_read(). */ 2701 } 2702 2703 #ifdef CONFIG_GPIO_CDEV_V1 2704 if (event_size == sizeof(struct gpio_v2_line_info_changed)) { 2705 if (copy_to_user(buf + bytes_read, &event, event_size)) 2706 return -EFAULT; 2707 } else { 2708 struct gpioline_info_changed event_v1; 2709 2710 gpio_v2_line_info_changed_to_v1(&event, &event_v1); 2711 if (copy_to_user(buf + bytes_read, &event_v1, 2712 event_size)) 2713 return -EFAULT; 2714 } 2715 #else 2716 if (copy_to_user(buf + bytes_read, &event, event_size)) 2717 return -EFAULT; 2718 #endif 2719 bytes_read += event_size; 2720 } while (count >= bytes_read + sizeof(event)); 2721 2722 return bytes_read; 2723 } 2724 2725 /** 2726 * gpio_chrdev_open() - open the chardev for ioctl operations 2727 * @inode: inode for this chardev 2728 * @file: file struct for storing private data 2729 * Returns 0 on success 2730 */ 2731 static int gpio_chrdev_open(struct inode *inode, struct file *file) 2732 { 2733 struct gpio_device *gdev = container_of(inode->i_cdev, 2734 struct gpio_device, chrdev); 2735 struct gpio_chardev_data *cdev; 2736 int ret = -ENOMEM; 2737 2738 guard(srcu)(&gdev->srcu); 2739 2740 /* Fail on open if the backing gpiochip is gone */ 2741 if (!rcu_access_pointer(gdev->chip)) 2742 return -ENODEV; 2743 2744 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL); 2745 if (!cdev) 2746 return -ENODEV; 2747 2748 cdev->watched_lines = bitmap_zalloc(gdev->ngpio, GFP_KERNEL); 2749 if (!cdev->watched_lines) 2750 goto out_free_cdev; 2751 2752 init_waitqueue_head(&cdev->wait); 2753 INIT_KFIFO(cdev->events); 2754 cdev->gdev = gpio_device_get(gdev); 2755 2756 cdev->lineinfo_changed_nb.notifier_call = lineinfo_changed_notify; 2757 ret = blocking_notifier_chain_register(&gdev->line_state_notifier, 2758 &cdev->lineinfo_changed_nb); 2759 if (ret) 2760 goto out_free_bitmap; 2761 2762 cdev->device_unregistered_nb.notifier_call = 2763 gpio_device_unregistered_notify; 2764 ret = blocking_notifier_chain_register(&gdev->device_notifier, 2765 &cdev->device_unregistered_nb); 2766 if (ret) 2767 goto out_unregister_line_notifier; 2768 2769 file->private_data = cdev; 2770 2771 ret = nonseekable_open(inode, file); 2772 if (ret) 2773 goto out_unregister_device_notifier; 2774 2775 return ret; 2776 2777 out_unregister_device_notifier: 2778 blocking_notifier_chain_unregister(&gdev->device_notifier, 2779 &cdev->device_unregistered_nb); 2780 out_unregister_line_notifier: 2781 blocking_notifier_chain_unregister(&gdev->line_state_notifier, 2782 &cdev->lineinfo_changed_nb); 2783 out_free_bitmap: 2784 gpio_device_put(gdev); 2785 bitmap_free(cdev->watched_lines); 2786 out_free_cdev: 2787 kfree(cdev); 2788 return ret; 2789 } 2790 2791 /** 2792 * gpio_chrdev_release() - close chardev after ioctl operations 2793 * @inode: inode for this chardev 2794 * @file: file struct for storing private data 2795 * Returns 0 on success 2796 */ 2797 static int gpio_chrdev_release(struct inode *inode, struct file *file) 2798 { 2799 struct gpio_chardev_data *cdev = file->private_data; 2800 struct gpio_device *gdev = cdev->gdev; 2801 2802 bitmap_free(cdev->watched_lines); 2803 blocking_notifier_chain_unregister(&gdev->device_notifier, 2804 &cdev->device_unregistered_nb); 2805 blocking_notifier_chain_unregister(&gdev->line_state_notifier, 2806 &cdev->lineinfo_changed_nb); 2807 gpio_device_put(gdev); 2808 kfree(cdev); 2809 2810 return 0; 2811 } 2812 2813 static const struct file_operations gpio_fileops = { 2814 .release = gpio_chrdev_release, 2815 .open = gpio_chrdev_open, 2816 .poll = lineinfo_watch_poll, 2817 .read = lineinfo_watch_read, 2818 .owner = THIS_MODULE, 2819 .llseek = no_llseek, 2820 .unlocked_ioctl = gpio_ioctl, 2821 #ifdef CONFIG_COMPAT 2822 .compat_ioctl = gpio_ioctl_compat, 2823 #endif 2824 }; 2825 2826 int gpiolib_cdev_register(struct gpio_device *gdev, dev_t devt) 2827 { 2828 struct gpio_chip *gc; 2829 int ret; 2830 2831 cdev_init(&gdev->chrdev, &gpio_fileops); 2832 gdev->chrdev.owner = THIS_MODULE; 2833 gdev->dev.devt = MKDEV(MAJOR(devt), gdev->id); 2834 2835 ret = cdev_device_add(&gdev->chrdev, &gdev->dev); 2836 if (ret) 2837 return ret; 2838 2839 guard(srcu)(&gdev->srcu); 2840 gc = srcu_dereference(gdev->chip, &gdev->srcu); 2841 if (!gc) 2842 return -ENODEV; 2843 2844 chip_dbg(gc, "added GPIO chardev (%d:%d)\n", MAJOR(devt), gdev->id); 2845 2846 return 0; 2847 } 2848 2849 void gpiolib_cdev_unregister(struct gpio_device *gdev) 2850 { 2851 cdev_device_del(&gdev->chrdev, &gdev->dev); 2852 blocking_notifier_call_chain(&gdev->device_notifier, 0, NULL); 2853 } 2854