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