1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * LIRC base driver 4 * 5 * by Artur Lipowski <alipowski@interia.pl> 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/module.h> 11 #include <linux/mutex.h> 12 #include <linux/device.h> 13 #include <linux/file.h> 14 #include <linux/idr.h> 15 #include <linux/poll.h> 16 #include <linux/sched.h> 17 #include <linux/wait.h> 18 19 #include "rc-core-priv.h" 20 #include <uapi/linux/lirc.h> 21 22 #define LIRCBUF_SIZE 1024 23 24 static dev_t lirc_base_dev; 25 26 /* Used to keep track of allocated lirc devices */ 27 static DEFINE_IDA(lirc_ida); 28 29 /* Only used for sysfs but defined to void otherwise */ 30 static struct class *lirc_class; 31 32 /** 33 * lirc_raw_event() - Send raw IR data to lirc to be relayed to userspace 34 * 35 * @dev: the struct rc_dev descriptor of the device 36 * @ev: the struct ir_raw_event descriptor of the pulse/space 37 */ 38 void lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev) 39 { 40 unsigned long flags; 41 struct lirc_fh *fh; 42 int sample; 43 44 /* Packet start */ 45 if (ev.reset) { 46 /* 47 * Userspace expects a long space event before the start of 48 * the signal to use as a sync. This may be done with repeat 49 * packets and normal samples. But if a reset has been sent 50 * then we assume that a long time has passed, so we send a 51 * space with the maximum time value. 52 */ 53 sample = LIRC_SPACE(LIRC_VALUE_MASK); 54 dev_dbg(&dev->dev, "delivering reset sync space to lirc_dev\n"); 55 56 /* Carrier reports */ 57 } else if (ev.carrier_report) { 58 sample = LIRC_FREQUENCY(ev.carrier); 59 dev_dbg(&dev->dev, "carrier report (freq: %d)\n", sample); 60 61 /* Packet end */ 62 } else if (ev.timeout) { 63 dev->gap_start = ktime_get(); 64 65 sample = LIRC_TIMEOUT(ev.duration); 66 dev_dbg(&dev->dev, "timeout report (duration: %d)\n", sample); 67 68 /* Normal sample */ 69 } else { 70 if (dev->gap_start) { 71 u64 duration = ktime_us_delta(ktime_get(), 72 dev->gap_start); 73 74 /* Cap by LIRC_VALUE_MASK */ 75 duration = min_t(u64, duration, LIRC_VALUE_MASK); 76 77 spin_lock_irqsave(&dev->lirc_fh_lock, flags); 78 list_for_each_entry(fh, &dev->lirc_fh, list) 79 kfifo_put(&fh->rawir, LIRC_SPACE(duration)); 80 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags); 81 dev->gap_start = 0; 82 } 83 84 sample = ev.pulse ? LIRC_PULSE(ev.duration) : 85 LIRC_SPACE(ev.duration); 86 dev_dbg(&dev->dev, "delivering %uus %s to lirc_dev\n", 87 ev.duration, TO_STR(ev.pulse)); 88 } 89 90 /* 91 * bpf does not care about the gap generated above; that exists 92 * for backwards compatibility 93 */ 94 lirc_bpf_run(dev, sample); 95 96 spin_lock_irqsave(&dev->lirc_fh_lock, flags); 97 list_for_each_entry(fh, &dev->lirc_fh, list) { 98 if (kfifo_put(&fh->rawir, sample)) 99 wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM); 100 } 101 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags); 102 } 103 104 /** 105 * lirc_scancode_event() - Send scancode data to lirc to be relayed to 106 * userspace. This can be called in atomic context. 107 * @dev: the struct rc_dev descriptor of the device 108 * @lsc: the struct lirc_scancode describing the decoded scancode 109 */ 110 void lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc) 111 { 112 unsigned long flags; 113 struct lirc_fh *fh; 114 115 lsc->timestamp = ktime_get_ns(); 116 117 spin_lock_irqsave(&dev->lirc_fh_lock, flags); 118 list_for_each_entry(fh, &dev->lirc_fh, list) { 119 if (kfifo_put(&fh->scancodes, *lsc)) 120 wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM); 121 } 122 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags); 123 } 124 EXPORT_SYMBOL_GPL(lirc_scancode_event); 125 126 static int lirc_open(struct inode *inode, struct file *file) 127 { 128 struct rc_dev *dev = container_of(inode->i_cdev, struct rc_dev, 129 lirc_cdev); 130 struct lirc_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL); 131 unsigned long flags; 132 int retval; 133 134 if (!fh) 135 return -ENOMEM; 136 137 get_device(&dev->dev); 138 139 if (!dev->registered) { 140 retval = -ENODEV; 141 goto out_fh; 142 } 143 144 if (dev->driver_type == RC_DRIVER_IR_RAW) { 145 if (kfifo_alloc(&fh->rawir, MAX_IR_EVENT_SIZE, GFP_KERNEL)) { 146 retval = -ENOMEM; 147 goto out_fh; 148 } 149 } 150 151 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) { 152 if (kfifo_alloc(&fh->scancodes, 32, GFP_KERNEL)) { 153 retval = -ENOMEM; 154 goto out_rawir; 155 } 156 } 157 158 fh->send_mode = LIRC_MODE_PULSE; 159 fh->rc = dev; 160 161 if (dev->driver_type == RC_DRIVER_SCANCODE) 162 fh->rec_mode = LIRC_MODE_SCANCODE; 163 else 164 fh->rec_mode = LIRC_MODE_MODE2; 165 166 retval = rc_open(dev); 167 if (retval) 168 goto out_kfifo; 169 170 init_waitqueue_head(&fh->wait_poll); 171 172 file->private_data = fh; 173 spin_lock_irqsave(&dev->lirc_fh_lock, flags); 174 list_add(&fh->list, &dev->lirc_fh); 175 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags); 176 177 stream_open(inode, file); 178 179 return 0; 180 out_kfifo: 181 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) 182 kfifo_free(&fh->scancodes); 183 out_rawir: 184 if (dev->driver_type == RC_DRIVER_IR_RAW) 185 kfifo_free(&fh->rawir); 186 out_fh: 187 kfree(fh); 188 put_device(&dev->dev); 189 190 return retval; 191 } 192 193 static int lirc_close(struct inode *inode, struct file *file) 194 { 195 struct lirc_fh *fh = file->private_data; 196 struct rc_dev *dev = fh->rc; 197 unsigned long flags; 198 199 spin_lock_irqsave(&dev->lirc_fh_lock, flags); 200 list_del(&fh->list); 201 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags); 202 203 if (dev->driver_type == RC_DRIVER_IR_RAW) 204 kfifo_free(&fh->rawir); 205 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) 206 kfifo_free(&fh->scancodes); 207 kfree(fh); 208 209 rc_close(dev); 210 put_device(&dev->dev); 211 212 return 0; 213 } 214 215 static ssize_t lirc_transmit(struct file *file, const char __user *buf, 216 size_t n, loff_t *ppos) 217 { 218 struct lirc_fh *fh = file->private_data; 219 struct rc_dev *dev = fh->rc; 220 unsigned int *txbuf; 221 struct ir_raw_event *raw = NULL; 222 ssize_t ret; 223 size_t count; 224 ktime_t start; 225 s64 towait; 226 unsigned int duration = 0; /* signal duration in us */ 227 int i; 228 229 ret = mutex_lock_interruptible(&dev->lock); 230 if (ret) 231 return ret; 232 233 if (!dev->registered) { 234 ret = -ENODEV; 235 goto out_unlock; 236 } 237 238 if (!dev->tx_ir) { 239 ret = -EINVAL; 240 goto out_unlock; 241 } 242 243 if (fh->send_mode == LIRC_MODE_SCANCODE) { 244 struct lirc_scancode scan; 245 246 if (n != sizeof(scan)) { 247 ret = -EINVAL; 248 goto out_unlock; 249 } 250 251 if (copy_from_user(&scan, buf, sizeof(scan))) { 252 ret = -EFAULT; 253 goto out_unlock; 254 } 255 256 if (scan.flags || scan.keycode || scan.timestamp || 257 scan.rc_proto > RC_PROTO_MAX) { 258 ret = -EINVAL; 259 goto out_unlock; 260 } 261 262 /* We only have encoders for 32-bit protocols. */ 263 if (scan.scancode > U32_MAX || 264 !rc_validate_scancode(scan.rc_proto, scan.scancode)) { 265 ret = -EINVAL; 266 goto out_unlock; 267 } 268 269 raw = kmalloc_array(LIRCBUF_SIZE, sizeof(*raw), GFP_KERNEL); 270 if (!raw) { 271 ret = -ENOMEM; 272 goto out_unlock; 273 } 274 275 ret = ir_raw_encode_scancode(scan.rc_proto, scan.scancode, 276 raw, LIRCBUF_SIZE); 277 if (ret < 0) 278 goto out_kfree_raw; 279 280 count = ret; 281 282 txbuf = kmalloc_array(count, sizeof(unsigned int), GFP_KERNEL); 283 if (!txbuf) { 284 ret = -ENOMEM; 285 goto out_kfree_raw; 286 } 287 288 for (i = 0; i < count; i++) 289 txbuf[i] = raw[i].duration; 290 291 if (dev->s_tx_carrier) { 292 int carrier = ir_raw_encode_carrier(scan.rc_proto); 293 294 if (carrier > 0) 295 dev->s_tx_carrier(dev, carrier); 296 } 297 } else { 298 if (n < sizeof(unsigned int) || n % sizeof(unsigned int)) { 299 ret = -EINVAL; 300 goto out_unlock; 301 } 302 303 count = n / sizeof(unsigned int); 304 if (count > LIRCBUF_SIZE || count % 2 == 0) { 305 ret = -EINVAL; 306 goto out_unlock; 307 } 308 309 txbuf = memdup_user(buf, n); 310 if (IS_ERR(txbuf)) { 311 ret = PTR_ERR(txbuf); 312 goto out_unlock; 313 } 314 } 315 316 for (i = 0; i < count; i++) { 317 if (txbuf[i] > IR_MAX_DURATION - duration || !txbuf[i]) { 318 ret = -EINVAL; 319 goto out_kfree; 320 } 321 322 duration += txbuf[i]; 323 } 324 325 start = ktime_get(); 326 327 ret = dev->tx_ir(dev, txbuf, count); 328 if (ret < 0) 329 goto out_kfree; 330 331 kfree(txbuf); 332 kfree(raw); 333 mutex_unlock(&dev->lock); 334 335 /* 336 * The lircd gap calculation expects the write function to 337 * wait for the actual IR signal to be transmitted before 338 * returning. 339 */ 340 towait = ktime_us_delta(ktime_add_us(start, duration), 341 ktime_get()); 342 if (towait > 0) { 343 set_current_state(TASK_INTERRUPTIBLE); 344 schedule_timeout(usecs_to_jiffies(towait)); 345 } 346 347 return n; 348 out_kfree: 349 kfree(txbuf); 350 out_kfree_raw: 351 kfree(raw); 352 out_unlock: 353 mutex_unlock(&dev->lock); 354 return ret; 355 } 356 357 static long lirc_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 358 { 359 struct lirc_fh *fh = file->private_data; 360 struct rc_dev *dev = fh->rc; 361 u32 __user *argp = (u32 __user *)(arg); 362 u32 val = 0; 363 int ret; 364 365 if (_IOC_DIR(cmd) & _IOC_WRITE) { 366 ret = get_user(val, argp); 367 if (ret) 368 return ret; 369 } 370 371 ret = mutex_lock_interruptible(&dev->lock); 372 if (ret) 373 return ret; 374 375 if (!dev->registered) { 376 ret = -ENODEV; 377 goto out; 378 } 379 380 switch (cmd) { 381 case LIRC_GET_FEATURES: 382 if (dev->driver_type == RC_DRIVER_SCANCODE) 383 val |= LIRC_CAN_REC_SCANCODE; 384 385 if (dev->driver_type == RC_DRIVER_IR_RAW) { 386 val |= LIRC_CAN_REC_MODE2; 387 if (dev->rx_resolution) 388 val |= LIRC_CAN_GET_REC_RESOLUTION; 389 } 390 391 if (dev->tx_ir) { 392 val |= LIRC_CAN_SEND_PULSE; 393 if (dev->s_tx_mask) 394 val |= LIRC_CAN_SET_TRANSMITTER_MASK; 395 if (dev->s_tx_carrier) 396 val |= LIRC_CAN_SET_SEND_CARRIER; 397 if (dev->s_tx_duty_cycle) 398 val |= LIRC_CAN_SET_SEND_DUTY_CYCLE; 399 } 400 401 if (dev->s_rx_carrier_range) 402 val |= LIRC_CAN_SET_REC_CARRIER | 403 LIRC_CAN_SET_REC_CARRIER_RANGE; 404 405 if (dev->s_wideband_receiver) 406 val |= LIRC_CAN_USE_WIDEBAND_RECEIVER; 407 408 if (dev->s_carrier_report) 409 val |= LIRC_CAN_MEASURE_CARRIER; 410 411 if (dev->max_timeout) 412 val |= LIRC_CAN_SET_REC_TIMEOUT; 413 414 break; 415 416 /* mode support */ 417 case LIRC_GET_REC_MODE: 418 if (dev->driver_type == RC_DRIVER_IR_RAW_TX) 419 ret = -ENOTTY; 420 else 421 val = fh->rec_mode; 422 break; 423 424 case LIRC_SET_REC_MODE: 425 switch (dev->driver_type) { 426 case RC_DRIVER_IR_RAW_TX: 427 ret = -ENOTTY; 428 break; 429 case RC_DRIVER_SCANCODE: 430 if (val != LIRC_MODE_SCANCODE) 431 ret = -EINVAL; 432 break; 433 case RC_DRIVER_IR_RAW: 434 if (!(val == LIRC_MODE_MODE2 || 435 val == LIRC_MODE_SCANCODE)) 436 ret = -EINVAL; 437 break; 438 } 439 440 if (!ret) 441 fh->rec_mode = val; 442 break; 443 444 case LIRC_GET_SEND_MODE: 445 if (!dev->tx_ir) 446 ret = -ENOTTY; 447 else 448 val = fh->send_mode; 449 break; 450 451 case LIRC_SET_SEND_MODE: 452 if (!dev->tx_ir) 453 ret = -ENOTTY; 454 else if (!(val == LIRC_MODE_PULSE || val == LIRC_MODE_SCANCODE)) 455 ret = -EINVAL; 456 else 457 fh->send_mode = val; 458 break; 459 460 /* TX settings */ 461 case LIRC_SET_TRANSMITTER_MASK: 462 if (!dev->s_tx_mask) 463 ret = -ENOTTY; 464 else 465 ret = dev->s_tx_mask(dev, val); 466 break; 467 468 case LIRC_SET_SEND_CARRIER: 469 if (!dev->s_tx_carrier) 470 ret = -ENOTTY; 471 else 472 ret = dev->s_tx_carrier(dev, val); 473 break; 474 475 case LIRC_SET_SEND_DUTY_CYCLE: 476 if (!dev->s_tx_duty_cycle) 477 ret = -ENOTTY; 478 else if (val <= 0 || val >= 100) 479 ret = -EINVAL; 480 else 481 ret = dev->s_tx_duty_cycle(dev, val); 482 break; 483 484 /* RX settings */ 485 case LIRC_SET_REC_CARRIER: 486 if (!dev->s_rx_carrier_range) 487 ret = -ENOTTY; 488 else if (val <= 0) 489 ret = -EINVAL; 490 else 491 ret = dev->s_rx_carrier_range(dev, fh->carrier_low, 492 val); 493 break; 494 495 case LIRC_SET_REC_CARRIER_RANGE: 496 if (!dev->s_rx_carrier_range) 497 ret = -ENOTTY; 498 else if (val <= 0) 499 ret = -EINVAL; 500 else 501 fh->carrier_low = val; 502 break; 503 504 case LIRC_GET_REC_RESOLUTION: 505 if (!dev->rx_resolution) 506 ret = -ENOTTY; 507 else 508 val = dev->rx_resolution; 509 break; 510 511 case LIRC_SET_WIDEBAND_RECEIVER: 512 if (!dev->s_wideband_receiver) 513 ret = -ENOTTY; 514 else 515 ret = dev->s_wideband_receiver(dev, !!val); 516 break; 517 518 case LIRC_SET_MEASURE_CARRIER_MODE: 519 if (!dev->s_carrier_report) 520 ret = -ENOTTY; 521 else 522 ret = dev->s_carrier_report(dev, !!val); 523 break; 524 525 /* Generic timeout support */ 526 case LIRC_GET_MIN_TIMEOUT: 527 if (!dev->max_timeout) 528 ret = -ENOTTY; 529 else 530 val = dev->min_timeout; 531 break; 532 533 case LIRC_GET_MAX_TIMEOUT: 534 if (!dev->max_timeout) 535 ret = -ENOTTY; 536 else 537 val = dev->max_timeout; 538 break; 539 540 case LIRC_SET_REC_TIMEOUT: 541 if (!dev->max_timeout) { 542 ret = -ENOTTY; 543 } else { 544 if (val < dev->min_timeout || val > dev->max_timeout) 545 ret = -EINVAL; 546 else if (dev->s_timeout) 547 ret = dev->s_timeout(dev, val); 548 else 549 dev->timeout = val; 550 } 551 break; 552 553 case LIRC_GET_REC_TIMEOUT: 554 if (!dev->timeout) 555 ret = -ENOTTY; 556 else 557 val = dev->timeout; 558 break; 559 560 case LIRC_SET_REC_TIMEOUT_REPORTS: 561 if (dev->driver_type != RC_DRIVER_IR_RAW) 562 ret = -ENOTTY; 563 break; 564 565 default: 566 ret = -ENOTTY; 567 } 568 569 if (!ret && _IOC_DIR(cmd) & _IOC_READ) 570 ret = put_user(val, argp); 571 572 out: 573 mutex_unlock(&dev->lock); 574 return ret; 575 } 576 577 static __poll_t lirc_poll(struct file *file, struct poll_table_struct *wait) 578 { 579 struct lirc_fh *fh = file->private_data; 580 struct rc_dev *rcdev = fh->rc; 581 __poll_t events = 0; 582 583 poll_wait(file, &fh->wait_poll, wait); 584 585 if (!rcdev->registered) { 586 events = EPOLLHUP | EPOLLERR; 587 } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) { 588 if (fh->rec_mode == LIRC_MODE_SCANCODE && 589 !kfifo_is_empty(&fh->scancodes)) 590 events = EPOLLIN | EPOLLRDNORM; 591 592 if (fh->rec_mode == LIRC_MODE_MODE2 && 593 !kfifo_is_empty(&fh->rawir)) 594 events = EPOLLIN | EPOLLRDNORM; 595 } 596 597 return events; 598 } 599 600 static ssize_t lirc_read_mode2(struct file *file, char __user *buffer, 601 size_t length) 602 { 603 struct lirc_fh *fh = file->private_data; 604 struct rc_dev *rcdev = fh->rc; 605 unsigned int copied; 606 int ret; 607 608 if (length < sizeof(unsigned int) || length % sizeof(unsigned int)) 609 return -EINVAL; 610 611 do { 612 if (kfifo_is_empty(&fh->rawir)) { 613 if (file->f_flags & O_NONBLOCK) 614 return -EAGAIN; 615 616 ret = wait_event_interruptible(fh->wait_poll, 617 !kfifo_is_empty(&fh->rawir) || 618 !rcdev->registered); 619 if (ret) 620 return ret; 621 } 622 623 if (!rcdev->registered) 624 return -ENODEV; 625 626 ret = mutex_lock_interruptible(&rcdev->lock); 627 if (ret) 628 return ret; 629 ret = kfifo_to_user(&fh->rawir, buffer, length, &copied); 630 mutex_unlock(&rcdev->lock); 631 if (ret) 632 return ret; 633 } while (copied == 0); 634 635 return copied; 636 } 637 638 static ssize_t lirc_read_scancode(struct file *file, char __user *buffer, 639 size_t length) 640 { 641 struct lirc_fh *fh = file->private_data; 642 struct rc_dev *rcdev = fh->rc; 643 unsigned int copied; 644 int ret; 645 646 if (length < sizeof(struct lirc_scancode) || 647 length % sizeof(struct lirc_scancode)) 648 return -EINVAL; 649 650 do { 651 if (kfifo_is_empty(&fh->scancodes)) { 652 if (file->f_flags & O_NONBLOCK) 653 return -EAGAIN; 654 655 ret = wait_event_interruptible(fh->wait_poll, 656 !kfifo_is_empty(&fh->scancodes) || 657 !rcdev->registered); 658 if (ret) 659 return ret; 660 } 661 662 if (!rcdev->registered) 663 return -ENODEV; 664 665 ret = mutex_lock_interruptible(&rcdev->lock); 666 if (ret) 667 return ret; 668 ret = kfifo_to_user(&fh->scancodes, buffer, length, &copied); 669 mutex_unlock(&rcdev->lock); 670 if (ret) 671 return ret; 672 } while (copied == 0); 673 674 return copied; 675 } 676 677 static ssize_t lirc_read(struct file *file, char __user *buffer, size_t length, 678 loff_t *ppos) 679 { 680 struct lirc_fh *fh = file->private_data; 681 struct rc_dev *rcdev = fh->rc; 682 683 if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX) 684 return -EINVAL; 685 686 if (!rcdev->registered) 687 return -ENODEV; 688 689 if (fh->rec_mode == LIRC_MODE_MODE2) 690 return lirc_read_mode2(file, buffer, length); 691 else /* LIRC_MODE_SCANCODE */ 692 return lirc_read_scancode(file, buffer, length); 693 } 694 695 static const struct file_operations lirc_fops = { 696 .owner = THIS_MODULE, 697 .write = lirc_transmit, 698 .unlocked_ioctl = lirc_ioctl, 699 .compat_ioctl = compat_ptr_ioctl, 700 .read = lirc_read, 701 .poll = lirc_poll, 702 .open = lirc_open, 703 .release = lirc_close, 704 .llseek = no_llseek, 705 }; 706 707 static void lirc_release_device(struct device *ld) 708 { 709 struct rc_dev *rcdev = container_of(ld, struct rc_dev, lirc_dev); 710 711 put_device(&rcdev->dev); 712 } 713 714 int lirc_register(struct rc_dev *dev) 715 { 716 const char *rx_type, *tx_type; 717 int err, minor; 718 719 minor = ida_simple_get(&lirc_ida, 0, RC_DEV_MAX, GFP_KERNEL); 720 if (minor < 0) 721 return minor; 722 723 device_initialize(&dev->lirc_dev); 724 dev->lirc_dev.class = lirc_class; 725 dev->lirc_dev.parent = &dev->dev; 726 dev->lirc_dev.release = lirc_release_device; 727 dev->lirc_dev.devt = MKDEV(MAJOR(lirc_base_dev), minor); 728 dev_set_name(&dev->lirc_dev, "lirc%d", minor); 729 730 INIT_LIST_HEAD(&dev->lirc_fh); 731 spin_lock_init(&dev->lirc_fh_lock); 732 733 cdev_init(&dev->lirc_cdev, &lirc_fops); 734 735 err = cdev_device_add(&dev->lirc_cdev, &dev->lirc_dev); 736 if (err) 737 goto out_ida; 738 739 get_device(&dev->dev); 740 741 switch (dev->driver_type) { 742 case RC_DRIVER_SCANCODE: 743 rx_type = "scancode"; 744 break; 745 case RC_DRIVER_IR_RAW: 746 rx_type = "raw IR"; 747 break; 748 default: 749 rx_type = "no"; 750 break; 751 } 752 753 if (dev->tx_ir) 754 tx_type = "raw IR"; 755 else 756 tx_type = "no"; 757 758 dev_info(&dev->dev, "lirc_dev: driver %s registered at minor = %d, %s receiver, %s transmitter", 759 dev->driver_name, minor, rx_type, tx_type); 760 761 return 0; 762 763 out_ida: 764 ida_simple_remove(&lirc_ida, minor); 765 return err; 766 } 767 768 void lirc_unregister(struct rc_dev *dev) 769 { 770 unsigned long flags; 771 struct lirc_fh *fh; 772 773 dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n", 774 dev->driver_name, MINOR(dev->lirc_dev.devt)); 775 776 spin_lock_irqsave(&dev->lirc_fh_lock, flags); 777 list_for_each_entry(fh, &dev->lirc_fh, list) 778 wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR); 779 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags); 780 781 cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev); 782 ida_simple_remove(&lirc_ida, MINOR(dev->lirc_dev.devt)); 783 } 784 785 int __init lirc_dev_init(void) 786 { 787 int retval; 788 789 lirc_class = class_create(THIS_MODULE, "lirc"); 790 if (IS_ERR(lirc_class)) { 791 pr_err("class_create failed\n"); 792 return PTR_ERR(lirc_class); 793 } 794 795 retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX, "lirc"); 796 if (retval) { 797 class_destroy(lirc_class); 798 pr_err("alloc_chrdev_region failed\n"); 799 return retval; 800 } 801 802 pr_debug("IR Remote Control driver registered, major %d\n", 803 MAJOR(lirc_base_dev)); 804 805 return 0; 806 } 807 808 void __exit lirc_dev_exit(void) 809 { 810 class_destroy(lirc_class); 811 unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX); 812 } 813 814 struct rc_dev *rc_dev_get_from_fd(int fd) 815 { 816 struct fd f = fdget(fd); 817 struct lirc_fh *fh; 818 struct rc_dev *dev; 819 820 if (!f.file) 821 return ERR_PTR(-EBADF); 822 823 if (f.file->f_op != &lirc_fops) { 824 fdput(f); 825 return ERR_PTR(-EINVAL); 826 } 827 828 fh = f.file->private_data; 829 dev = fh->rc; 830 831 get_device(&dev->dev); 832 fdput(f); 833 834 return dev; 835 } 836 837 MODULE_ALIAS("lirc_dev"); 838