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