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 24static dev_t lirc_base_dev; 25 26/* Used to keep track of allocated lirc devices */ 27static DEFINE_IDA(lirc_ida); 28 29/* Only used for sysfs but defined to void otherwise */ 30static 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 */ 38void 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 */ 119void 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} 133EXPORT_SYMBOL_GPL(lirc_scancode_event); 134 135static 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; 190out_kfifo: 191 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) 192 kfifo_free(&fh->scancodes); 193out_rawir: 194 if (dev->driver_type == RC_DRIVER_IR_RAW) 195 kfifo_free(&fh->rawir); 196out_fh: 197 kfree(fh); 198 put_device(&dev->dev); 199 200 return retval; 201} 202 203static 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 225static 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 ret = -EINVAL; 268 goto out_unlock; 269 } 270 271 /* We only have encoders for 32-bit protocols. */ 272 if (scan.scancode > U32_MAX || 273 !rc_validate_scancode(scan.rc_proto, scan.scancode)) { 274 ret = -EINVAL; 275 goto out_unlock; 276 } 277 278 raw = kmalloc_array(LIRCBUF_SIZE, sizeof(*raw), GFP_KERNEL); 279 if (!raw) { 280 ret = -ENOMEM; 281 goto out_unlock; 282 } 283 284 ret = ir_raw_encode_scancode(scan.rc_proto, scan.scancode, 285 raw, LIRCBUF_SIZE); 286 if (ret < 0) 287 goto out_kfree_raw; 288 289 /* drop trailing space */ 290 if (!(ret % 2)) 291 count = ret - 1; 292 else 293 count = ret; 294 295 txbuf = kmalloc_array(count, sizeof(unsigned int), GFP_KERNEL); 296 if (!txbuf) { 297 ret = -ENOMEM; 298 goto out_kfree_raw; 299 } 300 301 for (i = 0; i < count; i++) 302 txbuf[i] = raw[i].duration; 303 304 if (dev->s_tx_carrier) { 305 int carrier = ir_raw_encode_carrier(scan.rc_proto); 306 307 if (carrier > 0) 308 dev->s_tx_carrier(dev, carrier); 309 } 310 } else { 311 if (n < sizeof(unsigned int) || n % sizeof(unsigned int)) { 312 ret = -EINVAL; 313 goto out_unlock; 314 } 315 316 count = n / sizeof(unsigned int); 317 if (count > LIRCBUF_SIZE || count % 2 == 0) { 318 ret = -EINVAL; 319 goto out_unlock; 320 } 321 322 txbuf = memdup_user(buf, n); 323 if (IS_ERR(txbuf)) { 324 ret = PTR_ERR(txbuf); 325 goto out_unlock; 326 } 327 } 328 329 for (i = 0; i < count; i++) { 330 if (txbuf[i] > IR_MAX_DURATION - duration || !txbuf[i]) { 331 ret = -EINVAL; 332 goto out_kfree; 333 } 334 335 duration += txbuf[i]; 336 } 337 338 start = ktime_get(); 339 340 ret = dev->tx_ir(dev, txbuf, count); 341 if (ret < 0) 342 goto out_kfree; 343 344 kfree(txbuf); 345 kfree(raw); 346 mutex_unlock(&dev->lock); 347 348 /* 349 * The lircd gap calculation expects the write function to 350 * wait for the actual IR signal to be transmitted before 351 * returning. 352 */ 353 towait = ktime_us_delta(ktime_add_us(start, duration), 354 ktime_get()); 355 if (towait > 0) { 356 set_current_state(TASK_INTERRUPTIBLE); 357 schedule_timeout(usecs_to_jiffies(towait)); 358 } 359 360 return n; 361out_kfree: 362 kfree(txbuf); 363out_kfree_raw: 364 kfree(raw); 365out_unlock: 366 mutex_unlock(&dev->lock); 367 return ret; 368} 369 370static long lirc_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 371{ 372 struct lirc_fh *fh = file->private_data; 373 struct rc_dev *dev = fh->rc; 374 u32 __user *argp = (u32 __user *)(arg); 375 u32 val = 0; 376 int ret; 377 378 if (_IOC_DIR(cmd) & _IOC_WRITE) { 379 ret = get_user(val, argp); 380 if (ret) 381 return ret; 382 } 383 384 ret = mutex_lock_interruptible(&dev->lock); 385 if (ret) 386 return ret; 387 388 if (!dev->registered) { 389 ret = -ENODEV; 390 goto out; 391 } 392 393 switch (cmd) { 394 case LIRC_GET_FEATURES: 395 if (dev->driver_type == RC_DRIVER_SCANCODE) 396 val |= LIRC_CAN_REC_SCANCODE; 397 398 if (dev->driver_type == RC_DRIVER_IR_RAW) { 399 val |= LIRC_CAN_REC_MODE2; 400 if (dev->rx_resolution) 401 val |= LIRC_CAN_GET_REC_RESOLUTION; 402 } 403 404 if (dev->tx_ir) { 405 val |= LIRC_CAN_SEND_PULSE; 406 if (dev->s_tx_mask) 407 val |= LIRC_CAN_SET_TRANSMITTER_MASK; 408 if (dev->s_tx_carrier) 409 val |= LIRC_CAN_SET_SEND_CARRIER; 410 if (dev->s_tx_duty_cycle) 411 val |= LIRC_CAN_SET_SEND_DUTY_CYCLE; 412 } 413 414 if (dev->s_rx_carrier_range) 415 val |= LIRC_CAN_SET_REC_CARRIER | 416 LIRC_CAN_SET_REC_CARRIER_RANGE; 417 418 if (dev->s_learning_mode) 419 val |= LIRC_CAN_USE_WIDEBAND_RECEIVER; 420 421 if (dev->s_carrier_report) 422 val |= LIRC_CAN_MEASURE_CARRIER; 423 424 if (dev->max_timeout) 425 val |= LIRC_CAN_SET_REC_TIMEOUT; 426 427 break; 428 429 /* mode support */ 430 case LIRC_GET_REC_MODE: 431 if (dev->driver_type == RC_DRIVER_IR_RAW_TX) 432 ret = -ENOTTY; 433 else 434 val = fh->rec_mode; 435 break; 436 437 case LIRC_SET_REC_MODE: 438 switch (dev->driver_type) { 439 case RC_DRIVER_IR_RAW_TX: 440 ret = -ENOTTY; 441 break; 442 case RC_DRIVER_SCANCODE: 443 if (val != LIRC_MODE_SCANCODE) 444 ret = -EINVAL; 445 break; 446 case RC_DRIVER_IR_RAW: 447 if (!(val == LIRC_MODE_MODE2 || 448 val == LIRC_MODE_SCANCODE)) 449 ret = -EINVAL; 450 break; 451 } 452 453 if (!ret) 454 fh->rec_mode = val; 455 break; 456 457 case LIRC_GET_SEND_MODE: 458 if (!dev->tx_ir) 459 ret = -ENOTTY; 460 else 461 val = fh->send_mode; 462 break; 463 464 case LIRC_SET_SEND_MODE: 465 if (!dev->tx_ir) 466 ret = -ENOTTY; 467 else if (!(val == LIRC_MODE_PULSE || val == LIRC_MODE_SCANCODE)) 468 ret = -EINVAL; 469 else 470 fh->send_mode = val; 471 break; 472 473 /* TX settings */ 474 case LIRC_SET_TRANSMITTER_MASK: 475 if (!dev->s_tx_mask) 476 ret = -ENOTTY; 477 else 478 ret = dev->s_tx_mask(dev, val); 479 break; 480 481 case LIRC_SET_SEND_CARRIER: 482 if (!dev->s_tx_carrier) 483 ret = -ENOTTY; 484 else 485 ret = dev->s_tx_carrier(dev, val); 486 break; 487 488 case LIRC_SET_SEND_DUTY_CYCLE: 489 if (!dev->s_tx_duty_cycle) 490 ret = -ENOTTY; 491 else if (val <= 0 || val >= 100) 492 ret = -EINVAL; 493 else 494 ret = dev->s_tx_duty_cycle(dev, val); 495 break; 496 497 /* RX settings */ 498 case LIRC_SET_REC_CARRIER: 499 if (!dev->s_rx_carrier_range) 500 ret = -ENOTTY; 501 else if (val <= 0) 502 ret = -EINVAL; 503 else 504 ret = dev->s_rx_carrier_range(dev, fh->carrier_low, 505 val); 506 break; 507 508 case LIRC_SET_REC_CARRIER_RANGE: 509 if (!dev->s_rx_carrier_range) 510 ret = -ENOTTY; 511 else if (val <= 0) 512 ret = -EINVAL; 513 else 514 fh->carrier_low = val; 515 break; 516 517 case LIRC_GET_REC_RESOLUTION: 518 if (!dev->rx_resolution) 519 ret = -ENOTTY; 520 else 521 val = dev->rx_resolution; 522 break; 523 524 case LIRC_SET_WIDEBAND_RECEIVER: 525 if (!dev->s_learning_mode) 526 ret = -ENOTTY; 527 else 528 ret = dev->s_learning_mode(dev, !!val); 529 break; 530 531 case LIRC_SET_MEASURE_CARRIER_MODE: 532 if (!dev->s_carrier_report) 533 ret = -ENOTTY; 534 else 535 ret = dev->s_carrier_report(dev, !!val); 536 break; 537 538 /* Generic timeout support */ 539 case LIRC_GET_MIN_TIMEOUT: 540 if (!dev->max_timeout) 541 ret = -ENOTTY; 542 else 543 val = dev->min_timeout; 544 break; 545 546 case LIRC_GET_MAX_TIMEOUT: 547 if (!dev->max_timeout) 548 ret = -ENOTTY; 549 else 550 val = dev->max_timeout; 551 break; 552 553 case LIRC_SET_REC_TIMEOUT: 554 if (!dev->max_timeout) { 555 ret = -ENOTTY; 556 } else { 557 if (val < dev->min_timeout || val > dev->max_timeout) 558 ret = -EINVAL; 559 else if (dev->s_timeout) 560 ret = dev->s_timeout(dev, val); 561 else 562 dev->timeout = val; 563 } 564 break; 565 566 case LIRC_GET_REC_TIMEOUT: 567 if (!dev->timeout) 568 ret = -ENOTTY; 569 else 570 val = dev->timeout; 571 break; 572 573 case LIRC_SET_REC_TIMEOUT_REPORTS: 574 if (dev->driver_type != RC_DRIVER_IR_RAW) 575 ret = -ENOTTY; 576 else 577 fh->send_timeout_reports = !!val; 578 break; 579 580 default: 581 ret = -ENOTTY; 582 } 583 584 if (!ret && _IOC_DIR(cmd) & _IOC_READ) 585 ret = put_user(val, argp); 586 587out: 588 mutex_unlock(&dev->lock); 589 return ret; 590} 591 592static __poll_t lirc_poll(struct file *file, struct poll_table_struct *wait) 593{ 594 struct lirc_fh *fh = file->private_data; 595 struct rc_dev *rcdev = fh->rc; 596 __poll_t events = 0; 597 598 poll_wait(file, &fh->wait_poll, wait); 599 600 if (!rcdev->registered) { 601 events = EPOLLHUP | EPOLLERR; 602 } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) { 603 if (fh->rec_mode == LIRC_MODE_SCANCODE && 604 !kfifo_is_empty(&fh->scancodes)) 605 events = EPOLLIN | EPOLLRDNORM; 606 607 if (fh->rec_mode == LIRC_MODE_MODE2 && 608 !kfifo_is_empty(&fh->rawir)) 609 events = EPOLLIN | EPOLLRDNORM; 610 } 611 612 return events; 613} 614 615static ssize_t lirc_read_mode2(struct file *file, char __user *buffer, 616 size_t length) 617{ 618 struct lirc_fh *fh = file->private_data; 619 struct rc_dev *rcdev = fh->rc; 620 unsigned int copied; 621 int ret; 622 623 if (length < sizeof(unsigned int) || length % sizeof(unsigned int)) 624 return -EINVAL; 625 626 do { 627 if (kfifo_is_empty(&fh->rawir)) { 628 if (file->f_flags & O_NONBLOCK) 629 return -EAGAIN; 630 631 ret = wait_event_interruptible(fh->wait_poll, 632 !kfifo_is_empty(&fh->rawir) || 633 !rcdev->registered); 634 if (ret) 635 return ret; 636 } 637 638 if (!rcdev->registered) 639 return -ENODEV; 640 641 ret = mutex_lock_interruptible(&rcdev->lock); 642 if (ret) 643 return ret; 644 ret = kfifo_to_user(&fh->rawir, buffer, length, &copied); 645 mutex_unlock(&rcdev->lock); 646 if (ret) 647 return ret; 648 } while (copied == 0); 649 650 return copied; 651} 652 653static ssize_t lirc_read_scancode(struct file *file, char __user *buffer, 654 size_t length) 655{ 656 struct lirc_fh *fh = file->private_data; 657 struct rc_dev *rcdev = fh->rc; 658 unsigned int copied; 659 int ret; 660 661 if (length < sizeof(struct lirc_scancode) || 662 length % sizeof(struct lirc_scancode)) 663 return -EINVAL; 664 665 do { 666 if (kfifo_is_empty(&fh->scancodes)) { 667 if (file->f_flags & O_NONBLOCK) 668 return -EAGAIN; 669 670 ret = wait_event_interruptible(fh->wait_poll, 671 !kfifo_is_empty(&fh->scancodes) || 672 !rcdev->registered); 673 if (ret) 674 return ret; 675 } 676 677 if (!rcdev->registered) 678 return -ENODEV; 679 680 ret = mutex_lock_interruptible(&rcdev->lock); 681 if (ret) 682 return ret; 683 ret = kfifo_to_user(&fh->scancodes, buffer, length, &copied); 684 mutex_unlock(&rcdev->lock); 685 if (ret) 686 return ret; 687 } while (copied == 0); 688 689 return copied; 690} 691 692static ssize_t lirc_read(struct file *file, char __user *buffer, size_t length, 693 loff_t *ppos) 694{ 695 struct lirc_fh *fh = file->private_data; 696 struct rc_dev *rcdev = fh->rc; 697 698 if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX) 699 return -EINVAL; 700 701 if (!rcdev->registered) 702 return -ENODEV; 703 704 if (fh->rec_mode == LIRC_MODE_MODE2) 705 return lirc_read_mode2(file, buffer, length); 706 else /* LIRC_MODE_SCANCODE */ 707 return lirc_read_scancode(file, buffer, length); 708} 709 710static const struct file_operations lirc_fops = { 711 .owner = THIS_MODULE, 712 .write = lirc_transmit, 713 .unlocked_ioctl = lirc_ioctl, 714 .compat_ioctl = compat_ptr_ioctl, 715 .read = lirc_read, 716 .poll = lirc_poll, 717 .open = lirc_open, 718 .release = lirc_close, 719 .llseek = no_llseek, 720}; 721 722static void lirc_release_device(struct device *ld) 723{ 724 struct rc_dev *rcdev = container_of(ld, struct rc_dev, lirc_dev); 725 726 put_device(&rcdev->dev); 727} 728 729int lirc_register(struct rc_dev *dev) 730{ 731 const char *rx_type, *tx_type; 732 int err, minor; 733 734 minor = ida_simple_get(&lirc_ida, 0, RC_DEV_MAX, GFP_KERNEL); 735 if (minor < 0) 736 return minor; 737 738 device_initialize(&dev->lirc_dev); 739 dev->lirc_dev.class = lirc_class; 740 dev->lirc_dev.parent = &dev->dev; 741 dev->lirc_dev.release = lirc_release_device; 742 dev->lirc_dev.devt = MKDEV(MAJOR(lirc_base_dev), minor); 743 dev_set_name(&dev->lirc_dev, "lirc%d", minor); 744 745 INIT_LIST_HEAD(&dev->lirc_fh); 746 spin_lock_init(&dev->lirc_fh_lock); 747 748 cdev_init(&dev->lirc_cdev, &lirc_fops); 749 750 err = cdev_device_add(&dev->lirc_cdev, &dev->lirc_dev); 751 if (err) 752 goto out_ida; 753 754 get_device(&dev->dev); 755 756 switch (dev->driver_type) { 757 case RC_DRIVER_SCANCODE: 758 rx_type = "scancode"; 759 break; 760 case RC_DRIVER_IR_RAW: 761 rx_type = "raw IR"; 762 break; 763 default: 764 rx_type = "no"; 765 break; 766 } 767 768 if (dev->tx_ir) 769 tx_type = "raw IR"; 770 else 771 tx_type = "no"; 772 773 dev_info(&dev->dev, "lirc_dev: driver %s registered at minor = %d, %s receiver, %s transmitter", 774 dev->driver_name, minor, rx_type, tx_type); 775 776 return 0; 777 778out_ida: 779 ida_simple_remove(&lirc_ida, minor); 780 return err; 781} 782 783void lirc_unregister(struct rc_dev *dev) 784{ 785 unsigned long flags; 786 struct lirc_fh *fh; 787 788 dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n", 789 dev->driver_name, MINOR(dev->lirc_dev.devt)); 790 791 spin_lock_irqsave(&dev->lirc_fh_lock, flags); 792 list_for_each_entry(fh, &dev->lirc_fh, list) 793 wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR); 794 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags); 795 796 cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev); 797 ida_simple_remove(&lirc_ida, MINOR(dev->lirc_dev.devt)); 798} 799 800int __init lirc_dev_init(void) 801{ 802 int retval; 803 804 lirc_class = class_create(THIS_MODULE, "lirc"); 805 if (IS_ERR(lirc_class)) { 806 pr_err("class_create failed\n"); 807 return PTR_ERR(lirc_class); 808 } 809 810 retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX, "lirc"); 811 if (retval) { 812 class_destroy(lirc_class); 813 pr_err("alloc_chrdev_region failed\n"); 814 return retval; 815 } 816 817 pr_debug("IR Remote Control driver registered, major %d\n", 818 MAJOR(lirc_base_dev)); 819 820 return 0; 821} 822 823void __exit lirc_dev_exit(void) 824{ 825 class_destroy(lirc_class); 826 unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX); 827} 828 829struct rc_dev *rc_dev_get_from_fd(int fd, bool write) 830{ 831 struct fd f = fdget(fd); 832 struct lirc_fh *fh; 833 struct rc_dev *dev; 834 835 if (!f.file) 836 return ERR_PTR(-EBADF); 837 838 if (f.file->f_op != &lirc_fops) { 839 fdput(f); 840 return ERR_PTR(-EINVAL); 841 } 842 843 if (write && !(f.file->f_mode & FMODE_WRITE)) 844 return ERR_PTR(-EPERM); 845 846 fh = f.file->private_data; 847 dev = fh->rc; 848 849 get_device(&dev->dev); 850 fdput(f); 851 852 return dev; 853} 854 855MODULE_ALIAS("lirc_dev"); 856