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