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 510 if (!ir) { 511 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 512 return -EINVAL; 513 } 514 515 cdev = ir->cdev; 516 517 dev_dbg(ir->d.dev, LOGHEAD "close called\n", ir->d.name, ir->d.minor); 518 519 WARN_ON(mutex_lock_killable(&lirc_dev_lock)); 520 521 if (ir->d.rdev) 522 rc_close(ir->d.rdev); 523 524 ir->open--; 525 if (ir->attached) { 526 ir->d.set_use_dec(ir->d.data); 527 module_put(cdev->owner); 528 } else { 529 lirc_irctl_cleanup(ir); 530 cdev_del(cdev); 531 irctls[ir->d.minor] = NULL; 532 kfree(cdev); 533 kfree(ir); 534 } 535 536 mutex_unlock(&lirc_dev_lock); 537 538 return 0; 539 } 540 EXPORT_SYMBOL(lirc_dev_fop_close); 541 542 unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait) 543 { 544 struct irctl *ir = irctls[iminor(file_inode(file))]; 545 unsigned int ret; 546 547 if (!ir) { 548 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 549 return POLLERR; 550 } 551 552 dev_dbg(ir->d.dev, LOGHEAD "poll called\n", ir->d.name, ir->d.minor); 553 554 if (!ir->attached) 555 return POLLERR; 556 557 poll_wait(file, &ir->buf->wait_poll, wait); 558 559 if (ir->buf) 560 if (lirc_buffer_empty(ir->buf)) 561 ret = 0; 562 else 563 ret = POLLIN | POLLRDNORM; 564 else 565 ret = POLLERR; 566 567 dev_dbg(ir->d.dev, LOGHEAD "poll result = %d\n", 568 ir->d.name, ir->d.minor, ret); 569 570 return ret; 571 } 572 EXPORT_SYMBOL(lirc_dev_fop_poll); 573 574 long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 575 { 576 __u32 mode; 577 int result = 0; 578 struct irctl *ir = irctls[iminor(file_inode(file))]; 579 580 if (!ir) { 581 printk(KERN_ERR "lirc_dev: %s: no irctl found!\n", __func__); 582 return -ENODEV; 583 } 584 585 dev_dbg(ir->d.dev, LOGHEAD "ioctl called (0x%x)\n", 586 ir->d.name, ir->d.minor, cmd); 587 588 if (ir->d.minor == NOPLUG || !ir->attached) { 589 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = -ENODEV\n", 590 ir->d.name, ir->d.minor); 591 return -ENODEV; 592 } 593 594 mutex_lock(&ir->irctl_lock); 595 596 switch (cmd) { 597 case LIRC_GET_FEATURES: 598 result = put_user(ir->d.features, (__u32 *)arg); 599 break; 600 case LIRC_GET_REC_MODE: 601 if (!(ir->d.features & LIRC_CAN_REC_MASK)) { 602 result = -ENOSYS; 603 break; 604 } 605 606 result = put_user(LIRC_REC2MODE 607 (ir->d.features & LIRC_CAN_REC_MASK), 608 (__u32 *)arg); 609 break; 610 case LIRC_SET_REC_MODE: 611 if (!(ir->d.features & LIRC_CAN_REC_MASK)) { 612 result = -ENOSYS; 613 break; 614 } 615 616 result = get_user(mode, (__u32 *)arg); 617 if (!result && !(LIRC_MODE2REC(mode) & ir->d.features)) 618 result = -EINVAL; 619 /* 620 * FIXME: We should actually set the mode somehow but 621 * for now, lirc_serial doesn't support mode changing either 622 */ 623 break; 624 case LIRC_GET_LENGTH: 625 result = put_user(ir->d.code_length, (__u32 *)arg); 626 break; 627 case LIRC_GET_MIN_TIMEOUT: 628 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) || 629 ir->d.min_timeout == 0) { 630 result = -ENOSYS; 631 break; 632 } 633 634 result = put_user(ir->d.min_timeout, (__u32 *)arg); 635 break; 636 case LIRC_GET_MAX_TIMEOUT: 637 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) || 638 ir->d.max_timeout == 0) { 639 result = -ENOSYS; 640 break; 641 } 642 643 result = put_user(ir->d.max_timeout, (__u32 *)arg); 644 break; 645 default: 646 result = -EINVAL; 647 } 648 649 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = %d\n", 650 ir->d.name, ir->d.minor, result); 651 652 mutex_unlock(&ir->irctl_lock); 653 654 return result; 655 } 656 EXPORT_SYMBOL(lirc_dev_fop_ioctl); 657 658 ssize_t lirc_dev_fop_read(struct file *file, 659 char __user *buffer, 660 size_t length, 661 loff_t *ppos) 662 { 663 struct irctl *ir = irctls[iminor(file_inode(file))]; 664 unsigned char *buf; 665 int ret = 0, written = 0; 666 DECLARE_WAITQUEUE(wait, current); 667 668 if (!ir) { 669 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 670 return -ENODEV; 671 } 672 673 dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor); 674 675 buf = kzalloc(ir->chunk_size, GFP_KERNEL); 676 if (!buf) 677 return -ENOMEM; 678 679 if (mutex_lock_interruptible(&ir->irctl_lock)) { 680 ret = -ERESTARTSYS; 681 goto out_unlocked; 682 } 683 if (!ir->attached) { 684 ret = -ENODEV; 685 goto out_locked; 686 } 687 688 if (length % ir->chunk_size) { 689 ret = -EINVAL; 690 goto out_locked; 691 } 692 693 /* 694 * we add ourselves to the task queue before buffer check 695 * to avoid losing scan code (in case when queue is awaken somewhere 696 * between while condition checking and scheduling) 697 */ 698 add_wait_queue(&ir->buf->wait_poll, &wait); 699 set_current_state(TASK_INTERRUPTIBLE); 700 701 /* 702 * while we didn't provide 'length' bytes, device is opened in blocking 703 * mode and 'copy_to_user' is happy, wait for data. 704 */ 705 while (written < length && ret == 0) { 706 if (lirc_buffer_empty(ir->buf)) { 707 /* According to the read(2) man page, 'written' can be 708 * returned as less than 'length', instead of blocking 709 * again, returning -EWOULDBLOCK, or returning 710 * -ERESTARTSYS */ 711 if (written) 712 break; 713 if (file->f_flags & O_NONBLOCK) { 714 ret = -EWOULDBLOCK; 715 break; 716 } 717 if (signal_pending(current)) { 718 ret = -ERESTARTSYS; 719 break; 720 } 721 722 mutex_unlock(&ir->irctl_lock); 723 schedule(); 724 set_current_state(TASK_INTERRUPTIBLE); 725 726 if (mutex_lock_interruptible(&ir->irctl_lock)) { 727 ret = -ERESTARTSYS; 728 remove_wait_queue(&ir->buf->wait_poll, &wait); 729 set_current_state(TASK_RUNNING); 730 goto out_unlocked; 731 } 732 733 if (!ir->attached) { 734 ret = -ENODEV; 735 break; 736 } 737 } else { 738 lirc_buffer_read(ir->buf, buf); 739 ret = copy_to_user((void *)buffer+written, buf, 740 ir->buf->chunk_size); 741 if (!ret) 742 written += ir->buf->chunk_size; 743 else 744 ret = -EFAULT; 745 } 746 } 747 748 remove_wait_queue(&ir->buf->wait_poll, &wait); 749 set_current_state(TASK_RUNNING); 750 751 out_locked: 752 mutex_unlock(&ir->irctl_lock); 753 754 out_unlocked: 755 kfree(buf); 756 dev_dbg(ir->d.dev, LOGHEAD "read result = %s (%d)\n", 757 ir->d.name, ir->d.minor, ret ? "<fail>" : "<ok>", ret); 758 759 return ret ? ret : written; 760 } 761 EXPORT_SYMBOL(lirc_dev_fop_read); 762 763 void *lirc_get_pdata(struct file *file) 764 { 765 return irctls[iminor(file_inode(file))]->d.data; 766 } 767 EXPORT_SYMBOL(lirc_get_pdata); 768 769 770 ssize_t lirc_dev_fop_write(struct file *file, const char __user *buffer, 771 size_t length, loff_t *ppos) 772 { 773 struct irctl *ir = irctls[iminor(file_inode(file))]; 774 775 if (!ir) { 776 printk(KERN_ERR "%s: called with invalid irctl\n", __func__); 777 return -ENODEV; 778 } 779 780 dev_dbg(ir->d.dev, LOGHEAD "write called\n", ir->d.name, ir->d.minor); 781 782 if (!ir->attached) 783 return -ENODEV; 784 785 return -EINVAL; 786 } 787 EXPORT_SYMBOL(lirc_dev_fop_write); 788 789 790 static int __init lirc_dev_init(void) 791 { 792 int retval; 793 794 lirc_class = class_create(THIS_MODULE, "lirc"); 795 if (IS_ERR(lirc_class)) { 796 retval = PTR_ERR(lirc_class); 797 printk(KERN_ERR "lirc_dev: class_create failed\n"); 798 goto error; 799 } 800 801 retval = alloc_chrdev_region(&lirc_base_dev, 0, MAX_IRCTL_DEVICES, 802 IRCTL_DEV_NAME); 803 if (retval) { 804 class_destroy(lirc_class); 805 printk(KERN_ERR "lirc_dev: alloc_chrdev_region failed\n"); 806 goto error; 807 } 808 809 810 printk(KERN_INFO "lirc_dev: IR Remote Control driver registered, " 811 "major %d \n", MAJOR(lirc_base_dev)); 812 813 error: 814 return retval; 815 } 816 817 818 819 static void __exit lirc_dev_exit(void) 820 { 821 class_destroy(lirc_class); 822 unregister_chrdev_region(lirc_base_dev, MAX_IRCTL_DEVICES); 823 printk(KERN_INFO "lirc_dev: module unloaded\n"); 824 } 825 826 module_init(lirc_dev_init); 827 module_exit(lirc_dev_exit); 828 829 MODULE_DESCRIPTION("LIRC base driver module"); 830 MODULE_AUTHOR("Artur Lipowski"); 831 MODULE_LICENSE("GPL"); 832 833 module_param(debug, bool, S_IRUGO | S_IWUSR); 834 MODULE_PARM_DESC(debug, "Enable debugging messages"); 835