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