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