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