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 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 */ 21 22 #include <linux/module.h> 23 #include <linux/kernel.h> 24 #include <linux/sched.h> 25 #include <linux/errno.h> 26 #include <linux/ioctl.h> 27 #include <linux/fs.h> 28 #include <linux/poll.h> 29 #include <linux/completion.h> 30 #include <linux/mutex.h> 31 #include <linux/wait.h> 32 #include <linux/unistd.h> 33 #include <linux/kthread.h> 34 #include <linux/bitops.h> 35 #include <linux/device.h> 36 #include <linux/cdev.h> 37 38 #include <media/lirc.h> 39 #include <media/lirc_dev.h> 40 41 static bool debug; 42 43 #define IRCTL_DEV_NAME "BaseRemoteCtl" 44 #define NOPLUG -1 45 #define LOGHEAD "lirc_dev (%s[%d]): " 46 47 static dev_t lirc_base_dev; 48 49 struct irctl { 50 struct lirc_driver d; 51 int attached; 52 int open; 53 54 struct mutex irctl_lock; 55 struct lirc_buffer *buf; 56 unsigned int chunk_size; 57 58 struct cdev *cdev; 59 60 struct task_struct *task; 61 long jiffies_to_wait; 62 }; 63 64 static DEFINE_MUTEX(lirc_dev_lock); 65 66 static struct irctl *irctls[MAX_IRCTL_DEVICES]; 67 68 /* Only used for sysfs but defined to void otherwise */ 69 static struct class *lirc_class; 70 71 /* helper function 72 * initializes the irctl structure 73 */ 74 static void lirc_irctl_init(struct irctl *ir) 75 { 76 mutex_init(&ir->irctl_lock); 77 ir->d.minor = NOPLUG; 78 } 79 80 static void lirc_irctl_cleanup(struct irctl *ir) 81 { 82 dev_dbg(ir->d.dev, LOGHEAD "cleaning up\n", ir->d.name, ir->d.minor); 83 84 device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor)); 85 86 if (ir->buf != ir->d.rbuf) { 87 lirc_buffer_free(ir->buf); 88 kfree(ir->buf); 89 } 90 ir->buf = NULL; 91 } 92 93 /* helper function 94 * reads key codes from driver and puts them into buffer 95 * returns 0 on success 96 */ 97 static int lirc_add_to_buf(struct irctl *ir) 98 { 99 if (ir->d.add_to_buf) { 100 int res = -ENODATA; 101 int got_data = 0; 102 103 /* 104 * service the device as long as it is returning 105 * data and we have space 106 */ 107 get_data: 108 res = ir->d.add_to_buf(ir->d.data, ir->buf); 109 if (res == 0) { 110 got_data++; 111 goto get_data; 112 } 113 114 if (res == -ENODEV) 115 kthread_stop(ir->task); 116 117 return got_data ? 0 : res; 118 } 119 120 return 0; 121 } 122 123 /* main function of the polling thread 124 */ 125 static int lirc_thread(void *irctl) 126 { 127 struct irctl *ir = irctl; 128 129 dev_dbg(ir->d.dev, LOGHEAD "poll thread started\n", 130 ir->d.name, ir->d.minor); 131 132 do { 133 if (ir->open) { 134 if (ir->jiffies_to_wait) { 135 set_current_state(TASK_INTERRUPTIBLE); 136 schedule_timeout(ir->jiffies_to_wait); 137 } 138 if (kthread_should_stop()) 139 break; 140 if (!lirc_add_to_buf(ir)) 141 wake_up_interruptible(&ir->buf->wait_poll); 142 } else { 143 set_current_state(TASK_INTERRUPTIBLE); 144 schedule(); 145 } 146 } while (!kthread_should_stop()); 147 148 dev_dbg(ir->d.dev, LOGHEAD "poll thread ended\n", 149 ir->d.name, ir->d.minor); 150 151 return 0; 152 } 153 154 155 static struct file_operations lirc_dev_fops = { 156 .owner = THIS_MODULE, 157 .read = lirc_dev_fop_read, 158 .write = lirc_dev_fop_write, 159 .poll = lirc_dev_fop_poll, 160 .unlocked_ioctl = lirc_dev_fop_ioctl, 161 #ifdef CONFIG_COMPAT 162 .compat_ioctl = lirc_dev_fop_ioctl, 163 #endif 164 .open = lirc_dev_fop_open, 165 .release = lirc_dev_fop_close, 166 .llseek = noop_llseek, 167 }; 168 169 static int lirc_cdev_add(struct irctl *ir) 170 { 171 int retval = -ENOMEM; 172 struct lirc_driver *d = &ir->d; 173 struct cdev *cdev; 174 175 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL); 176 if (!cdev) 177 goto err_out; 178 179 if (d->fops) { 180 cdev_init(cdev, d->fops); 181 cdev->owner = d->owner; 182 } else { 183 cdev_init(cdev, &lirc_dev_fops); 184 cdev->owner = THIS_MODULE; 185 } 186 retval = kobject_set_name(&cdev->kobj, "lirc%d", d->minor); 187 if (retval) 188 goto err_out; 189 190 retval = cdev_add(cdev, MKDEV(MAJOR(lirc_base_dev), d->minor), 1); 191 if (retval) { 192 kobject_put(&cdev->kobj); 193 goto err_out; 194 } 195 196 ir->cdev = cdev; 197 198 return 0; 199 200 err_out: 201 kfree(cdev); 202 return retval; 203 } 204 205 int lirc_register_driver(struct lirc_driver *d) 206 { 207 struct irctl *ir; 208 int minor; 209 int bytes_in_key; 210 unsigned int chunk_size; 211 unsigned int buffer_size; 212 int err; 213 214 if (!d) { 215 printk(KERN_ERR "lirc_dev: lirc_register_driver: " 216 "driver pointer must be not NULL!\n"); 217 err = -EBADRQC; 218 goto out; 219 } 220 221 if (!d->dev) { 222 printk(KERN_ERR "%s: dev pointer not filled in!\n", __func__); 223 err = -EINVAL; 224 goto out; 225 } 226 227 if (MAX_IRCTL_DEVICES <= d->minor) { 228 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 229 "\"minor\" must be between 0 and %d (%d)!\n", 230 MAX_IRCTL_DEVICES - 1, d->minor); 231 err = -EBADRQC; 232 goto out; 233 } 234 235 if (1 > d->code_length || (BUFLEN * 8) < d->code_length) { 236 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 237 "code length in bits for minor (%d) " 238 "must be less than %d!\n", 239 d->minor, BUFLEN * 8); 240 err = -EBADRQC; 241 goto out; 242 } 243 244 dev_dbg(d->dev, "lirc_dev: lirc_register_driver: sample_rate: %d\n", 245 d->sample_rate); 246 if (d->sample_rate) { 247 if (2 > d->sample_rate || HZ < d->sample_rate) { 248 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 249 "sample_rate must be between 2 and %d!\n", HZ); 250 err = -EBADRQC; 251 goto out; 252 } 253 if (!d->add_to_buf) { 254 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 255 "add_to_buf cannot be NULL when " 256 "sample_rate is set\n"); 257 err = -EBADRQC; 258 goto out; 259 } 260 } else if (!(d->fops && d->fops->read) && !d->rbuf) { 261 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 262 "fops->read and rbuf cannot all be NULL!\n"); 263 err = -EBADRQC; 264 goto out; 265 } else if (!d->rbuf) { 266 if (!(d->fops && d->fops->read && d->fops->poll && 267 d->fops->unlocked_ioctl)) { 268 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 269 "neither read, poll nor unlocked_ioctl can be NULL!\n"); 270 err = -EBADRQC; 271 goto out; 272 } 273 } 274 275 mutex_lock(&lirc_dev_lock); 276 277 minor = d->minor; 278 279 if (minor < 0) { 280 /* find first free slot for driver */ 281 for (minor = 0; minor < MAX_IRCTL_DEVICES; minor++) 282 if (!irctls[minor]) 283 break; 284 if (MAX_IRCTL_DEVICES == minor) { 285 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 286 "no free slots for drivers!\n"); 287 err = -ENOMEM; 288 goto out_lock; 289 } 290 } else if (irctls[minor]) { 291 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 292 "minor (%d) just registered!\n", minor); 293 err = -EBUSY; 294 goto out_lock; 295 } 296 297 ir = kzalloc(sizeof(struct irctl), GFP_KERNEL); 298 if (!ir) { 299 err = -ENOMEM; 300 goto out_lock; 301 } 302 lirc_irctl_init(ir); 303 irctls[minor] = ir; 304 d->minor = minor; 305 306 if (d->sample_rate) { 307 ir->jiffies_to_wait = HZ / d->sample_rate; 308 } else { 309 /* it means - wait for external event in task queue */ 310 ir->jiffies_to_wait = 0; 311 } 312 313 /* some safety check 8-) */ 314 d->name[sizeof(d->name)-1] = '\0'; 315 316 bytes_in_key = BITS_TO_LONGS(d->code_length) + 317 (d->code_length % 8 ? 1 : 0); 318 buffer_size = d->buffer_size ? d->buffer_size : BUFLEN / bytes_in_key; 319 chunk_size = d->chunk_size ? d->chunk_size : bytes_in_key; 320 321 if (d->rbuf) { 322 ir->buf = d->rbuf; 323 } else { 324 ir->buf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL); 325 if (!ir->buf) { 326 err = -ENOMEM; 327 goto out_lock; 328 } 329 err = lirc_buffer_init(ir->buf, chunk_size, buffer_size); 330 if (err) { 331 kfree(ir->buf); 332 goto out_lock; 333 } 334 } 335 ir->chunk_size = ir->buf->chunk_size; 336 337 if (d->features == 0) 338 d->features = LIRC_CAN_REC_LIRCCODE; 339 340 ir->d = *d; 341 342 device_create(lirc_class, ir->d.dev, 343 MKDEV(MAJOR(lirc_base_dev), ir->d.minor), NULL, 344 "lirc%u", ir->d.minor); 345 346 if (d->sample_rate) { 347 /* try to fire up polling thread */ 348 ir->task = kthread_run(lirc_thread, (void *)ir, "lirc_dev"); 349 if (IS_ERR(ir->task)) { 350 dev_err(d->dev, "lirc_dev: lirc_register_driver: " 351 "cannot run poll thread for minor = %d\n", 352 d->minor); 353 err = -ECHILD; 354 goto out_sysfs; 355 } 356 } 357 358 err = lirc_cdev_add(ir); 359 if (err) 360 goto out_sysfs; 361 362 ir->attached = 1; 363 mutex_unlock(&lirc_dev_lock); 364 365 dev_info(ir->d.dev, "lirc_dev: driver %s registered at minor = %d\n", 366 ir->d.name, ir->d.minor); 367 return minor; 368 369 out_sysfs: 370 device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor)); 371 out_lock: 372 mutex_unlock(&lirc_dev_lock); 373 out: 374 return err; 375 } 376 EXPORT_SYMBOL(lirc_register_driver); 377 378 int lirc_unregister_driver(int minor) 379 { 380 struct irctl *ir; 381 struct cdev *cdev; 382 383 if (minor < 0 || minor >= MAX_IRCTL_DEVICES) { 384 printk(KERN_ERR "lirc_dev: %s: minor (%d) must be between " 385 "0 and %d!\n", __func__, minor, MAX_IRCTL_DEVICES - 1); 386 return -EBADRQC; 387 } 388 389 ir = irctls[minor]; 390 if (!ir) { 391 printk(KERN_ERR "lirc_dev: %s: failed to get irctl struct " 392 "for minor %d!\n", __func__, minor); 393 return -ENOENT; 394 } 395 396 cdev = ir->cdev; 397 398 mutex_lock(&lirc_dev_lock); 399 400 if (ir->d.minor != minor) { 401 printk(KERN_ERR "lirc_dev: %s: minor (%d) device not " 402 "registered!\n", __func__, minor); 403 mutex_unlock(&lirc_dev_lock); 404 return -ENOENT; 405 } 406 407 /* end up polling thread */ 408 if (ir->task) 409 kthread_stop(ir->task); 410 411 dev_dbg(ir->d.dev, "lirc_dev: driver %s unregistered from minor = %d\n", 412 ir->d.name, ir->d.minor); 413 414 ir->attached = 0; 415 if (ir->open) { 416 dev_dbg(ir->d.dev, LOGHEAD "releasing opened driver\n", 417 ir->d.name, ir->d.minor); 418 wake_up_interruptible(&ir->buf->wait_poll); 419 mutex_lock(&ir->irctl_lock); 420 ir->d.set_use_dec(ir->d.data); 421 module_put(cdev->owner); 422 mutex_unlock(&ir->irctl_lock); 423 } else { 424 lirc_irctl_cleanup(ir); 425 cdev_del(cdev); 426 kfree(cdev); 427 kfree(ir); 428 irctls[minor] = NULL; 429 } 430 431 mutex_unlock(&lirc_dev_lock); 432 433 return 0; 434 } 435 EXPORT_SYMBOL(lirc_unregister_driver); 436 437 int lirc_dev_fop_open(struct inode *inode, struct file *file) 438 { 439 struct irctl *ir; 440 struct cdev *cdev; 441 int retval = 0; 442 443 if (iminor(inode) >= MAX_IRCTL_DEVICES) { 444 printk(KERN_WARNING "lirc_dev [%d]: open result = -ENODEV\n", 445 iminor(inode)); 446 return -ENODEV; 447 } 448 449 if (mutex_lock_interruptible(&lirc_dev_lock)) 450 return -ERESTARTSYS; 451 452 ir = irctls[iminor(inode)]; 453 if (!ir) { 454 retval = -ENODEV; 455 goto error; 456 } 457 458 dev_dbg(ir->d.dev, LOGHEAD "open called\n", ir->d.name, ir->d.minor); 459 460 if (ir->d.minor == NOPLUG) { 461 retval = -ENODEV; 462 goto error; 463 } 464 465 if (ir->open) { 466 retval = -EBUSY; 467 goto error; 468 } 469 470 cdev = ir->cdev; 471 if (try_module_get(cdev->owner)) { 472 ir->open++; 473 retval = ir->d.set_use_inc(ir->d.data); 474 475 if (retval) { 476 module_put(cdev->owner); 477 ir->open--; 478 } else { 479 lirc_buffer_clear(ir->buf); 480 } 481 if (ir->task) 482 wake_up_process(ir->task); 483 } 484 485 error: 486 if (ir) 487 dev_dbg(ir->d.dev, LOGHEAD "open result = %d\n", 488 ir->d.name, ir->d.minor, retval); 489 490 mutex_unlock(&lirc_dev_lock); 491 492 nonseekable_open(inode, file); 493 494 return retval; 495 } 496 EXPORT_SYMBOL(lirc_dev_fop_open); 497 498 int lirc_dev_fop_close(struct inode *inode, struct file *file) 499 { 500 struct irctl *ir = irctls[iminor(inode)]; 501 struct cdev *cdev; 502 503 if (!ir) { 504 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 505 return -EINVAL; 506 } 507 508 cdev = ir->cdev; 509 510 dev_dbg(ir->d.dev, LOGHEAD "close called\n", ir->d.name, ir->d.minor); 511 512 WARN_ON(mutex_lock_killable(&lirc_dev_lock)); 513 514 ir->open--; 515 if (ir->attached) { 516 ir->d.set_use_dec(ir->d.data); 517 module_put(cdev->owner); 518 } else { 519 lirc_irctl_cleanup(ir); 520 cdev_del(cdev); 521 irctls[ir->d.minor] = NULL; 522 kfree(cdev); 523 kfree(ir); 524 } 525 526 mutex_unlock(&lirc_dev_lock); 527 528 return 0; 529 } 530 EXPORT_SYMBOL(lirc_dev_fop_close); 531 532 unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait) 533 { 534 struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)]; 535 unsigned int ret; 536 537 if (!ir) { 538 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 539 return POLLERR; 540 } 541 542 dev_dbg(ir->d.dev, LOGHEAD "poll called\n", ir->d.name, ir->d.minor); 543 544 if (!ir->attached) 545 return POLLERR; 546 547 poll_wait(file, &ir->buf->wait_poll, wait); 548 549 if (ir->buf) 550 if (lirc_buffer_empty(ir->buf)) 551 ret = 0; 552 else 553 ret = POLLIN | POLLRDNORM; 554 else 555 ret = POLLERR; 556 557 dev_dbg(ir->d.dev, LOGHEAD "poll result = %d\n", 558 ir->d.name, ir->d.minor, ret); 559 560 return ret; 561 } 562 EXPORT_SYMBOL(lirc_dev_fop_poll); 563 564 long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 565 { 566 __u32 mode; 567 int result = 0; 568 struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)]; 569 570 if (!ir) { 571 printk(KERN_ERR "lirc_dev: %s: no irctl found!\n", __func__); 572 return -ENODEV; 573 } 574 575 dev_dbg(ir->d.dev, LOGHEAD "ioctl called (0x%x)\n", 576 ir->d.name, ir->d.minor, cmd); 577 578 if (ir->d.minor == NOPLUG || !ir->attached) { 579 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = -ENODEV\n", 580 ir->d.name, ir->d.minor); 581 return -ENODEV; 582 } 583 584 mutex_lock(&ir->irctl_lock); 585 586 switch (cmd) { 587 case LIRC_GET_FEATURES: 588 result = put_user(ir->d.features, (__u32 *)arg); 589 break; 590 case LIRC_GET_REC_MODE: 591 if (!(ir->d.features & LIRC_CAN_REC_MASK)) { 592 result = -ENOSYS; 593 break; 594 } 595 596 result = put_user(LIRC_REC2MODE 597 (ir->d.features & LIRC_CAN_REC_MASK), 598 (__u32 *)arg); 599 break; 600 case LIRC_SET_REC_MODE: 601 if (!(ir->d.features & LIRC_CAN_REC_MASK)) { 602 result = -ENOSYS; 603 break; 604 } 605 606 result = get_user(mode, (__u32 *)arg); 607 if (!result && !(LIRC_MODE2REC(mode) & ir->d.features)) 608 result = -EINVAL; 609 /* 610 * FIXME: We should actually set the mode somehow but 611 * for now, lirc_serial doesn't support mode changing either 612 */ 613 break; 614 case LIRC_GET_LENGTH: 615 result = put_user(ir->d.code_length, (__u32 *)arg); 616 break; 617 case LIRC_GET_MIN_TIMEOUT: 618 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) || 619 ir->d.min_timeout == 0) { 620 result = -ENOSYS; 621 break; 622 } 623 624 result = put_user(ir->d.min_timeout, (__u32 *)arg); 625 break; 626 case LIRC_GET_MAX_TIMEOUT: 627 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) || 628 ir->d.max_timeout == 0) { 629 result = -ENOSYS; 630 break; 631 } 632 633 result = put_user(ir->d.max_timeout, (__u32 *)arg); 634 break; 635 default: 636 result = -EINVAL; 637 } 638 639 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = %d\n", 640 ir->d.name, ir->d.minor, result); 641 642 mutex_unlock(&ir->irctl_lock); 643 644 return result; 645 } 646 EXPORT_SYMBOL(lirc_dev_fop_ioctl); 647 648 ssize_t lirc_dev_fop_read(struct file *file, 649 char __user *buffer, 650 size_t length, 651 loff_t *ppos) 652 { 653 struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)]; 654 unsigned char *buf; 655 int ret = 0, written = 0; 656 DECLARE_WAITQUEUE(wait, current); 657 658 if (!ir) { 659 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 660 return -ENODEV; 661 } 662 663 dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor); 664 665 buf = kzalloc(ir->chunk_size, GFP_KERNEL); 666 if (!buf) 667 return -ENOMEM; 668 669 if (mutex_lock_interruptible(&ir->irctl_lock)) { 670 ret = -ERESTARTSYS; 671 goto out_unlocked; 672 } 673 if (!ir->attached) { 674 ret = -ENODEV; 675 goto out_locked; 676 } 677 678 if (length % ir->chunk_size) { 679 ret = -EINVAL; 680 goto out_locked; 681 } 682 683 /* 684 * we add ourselves to the task queue before buffer check 685 * to avoid losing scan code (in case when queue is awaken somewhere 686 * between while condition checking and scheduling) 687 */ 688 add_wait_queue(&ir->buf->wait_poll, &wait); 689 set_current_state(TASK_INTERRUPTIBLE); 690 691 /* 692 * while we didn't provide 'length' bytes, device is opened in blocking 693 * mode and 'copy_to_user' is happy, wait for data. 694 */ 695 while (written < length && ret == 0) { 696 if (lirc_buffer_empty(ir->buf)) { 697 /* According to the read(2) man page, 'written' can be 698 * returned as less than 'length', instead of blocking 699 * again, returning -EWOULDBLOCK, or returning 700 * -ERESTARTSYS */ 701 if (written) 702 break; 703 if (file->f_flags & O_NONBLOCK) { 704 ret = -EWOULDBLOCK; 705 break; 706 } 707 if (signal_pending(current)) { 708 ret = -ERESTARTSYS; 709 break; 710 } 711 712 mutex_unlock(&ir->irctl_lock); 713 schedule(); 714 set_current_state(TASK_INTERRUPTIBLE); 715 716 if (mutex_lock_interruptible(&ir->irctl_lock)) { 717 ret = -ERESTARTSYS; 718 remove_wait_queue(&ir->buf->wait_poll, &wait); 719 set_current_state(TASK_RUNNING); 720 goto out_unlocked; 721 } 722 723 if (!ir->attached) { 724 ret = -ENODEV; 725 break; 726 } 727 } else { 728 lirc_buffer_read(ir->buf, buf); 729 ret = copy_to_user((void *)buffer+written, buf, 730 ir->buf->chunk_size); 731 if (!ret) 732 written += ir->buf->chunk_size; 733 else 734 ret = -EFAULT; 735 } 736 } 737 738 remove_wait_queue(&ir->buf->wait_poll, &wait); 739 set_current_state(TASK_RUNNING); 740 741 out_locked: 742 mutex_unlock(&ir->irctl_lock); 743 744 out_unlocked: 745 kfree(buf); 746 dev_dbg(ir->d.dev, LOGHEAD "read result = %s (%d)\n", 747 ir->d.name, ir->d.minor, ret ? "<fail>" : "<ok>", ret); 748 749 return ret ? ret : written; 750 } 751 EXPORT_SYMBOL(lirc_dev_fop_read); 752 753 void *lirc_get_pdata(struct file *file) 754 { 755 void *data = NULL; 756 757 if (file && file->f_dentry && file->f_dentry->d_inode && 758 file->f_dentry->d_inode->i_rdev) { 759 struct irctl *ir; 760 ir = irctls[iminor(file->f_dentry->d_inode)]; 761 data = ir->d.data; 762 } 763 764 return data; 765 } 766 EXPORT_SYMBOL(lirc_get_pdata); 767 768 769 ssize_t lirc_dev_fop_write(struct file *file, const char __user *buffer, 770 size_t length, loff_t *ppos) 771 { 772 struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)]; 773 774 if (!ir) { 775 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 776 return -ENODEV; 777 } 778 779 dev_dbg(ir->d.dev, LOGHEAD "write called\n", ir->d.name, ir->d.minor); 780 781 if (!ir->attached) 782 return -ENODEV; 783 784 return -EINVAL; 785 } 786 EXPORT_SYMBOL(lirc_dev_fop_write); 787 788 789 static int __init lirc_dev_init(void) 790 { 791 int retval; 792 793 lirc_class = class_create(THIS_MODULE, "lirc"); 794 if (IS_ERR(lirc_class)) { 795 retval = PTR_ERR(lirc_class); 796 printk(KERN_ERR "lirc_dev: class_create failed\n"); 797 goto error; 798 } 799 800 retval = alloc_chrdev_region(&lirc_base_dev, 0, MAX_IRCTL_DEVICES, 801 IRCTL_DEV_NAME); 802 if (retval) { 803 class_destroy(lirc_class); 804 printk(KERN_ERR "lirc_dev: alloc_chrdev_region failed\n"); 805 goto error; 806 } 807 808 809 printk(KERN_INFO "lirc_dev: IR Remote Control driver registered, " 810 "major %d \n", MAJOR(lirc_base_dev)); 811 812 error: 813 return retval; 814 } 815 816 817 818 static void __exit lirc_dev_exit(void) 819 { 820 class_destroy(lirc_class); 821 unregister_chrdev_region(lirc_base_dev, MAX_IRCTL_DEVICES); 822 printk(KERN_INFO "lirc_dev: module unloaded\n"); 823 } 824 825 module_init(lirc_dev_init); 826 module_exit(lirc_dev_exit); 827 828 MODULE_DESCRIPTION("LIRC base driver module"); 829 MODULE_AUTHOR("Artur Lipowski"); 830 MODULE_LICENSE("GPL"); 831 832 module_param(debug, bool, S_IRUGO | S_IWUSR); 833 MODULE_PARM_DESC(debug, "Enable debugging messages"); 834