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