1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
42static bool debug;
43
44#define IRCTL_DEV_NAME "BaseRemoteCtl"
45#define NOPLUG -1
46#define LOGHEAD "lirc_dev (%s[%d]): "
47
48static dev_t lirc_base_dev;
49
50struct 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
65static DEFINE_MUTEX(lirc_dev_lock);
66
67static struct irctl *irctls[MAX_IRCTL_DEVICES];
68
69
70static struct class *lirc_class;
71
72
73
74
75static void lirc_irctl_init(struct irctl *ir)
76{
77 mutex_init(&ir->irctl_lock);
78 ir->d.minor = NOPLUG;
79}
80
81static 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
95
96
97
98static 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
106
107
108get_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
125
126static 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
156static 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
170static 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
201err_out:
202 kfree(cdev);
203 return retval;
204}
205
206int 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
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
311 ir->jiffies_to_wait = 0;
312 }
313
314
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
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
370out_sysfs:
371 device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
372out_lock:
373 mutex_unlock(&lirc_dev_lock);
374out:
375 return err;
376}
377EXPORT_SYMBOL(lirc_register_driver);
378
379int 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
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}
436EXPORT_SYMBOL(lirc_unregister_driver);
437
438int 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
492error:
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}
503EXPORT_SYMBOL(lirc_dev_fop_open);
504
505int 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 rc_close(ir->d.rdev);
522
523 ir->open--;
524 if (ir->attached) {
525 ir->d.set_use_dec(ir->d.data);
526 module_put(cdev->owner);
527 } else {
528 lirc_irctl_cleanup(ir);
529 cdev_del(cdev);
530 irctls[ir->d.minor] = NULL;
531 kfree(cdev);
532 kfree(ir);
533 }
534
535 mutex_unlock(&lirc_dev_lock);
536
537 return 0;
538}
539EXPORT_SYMBOL(lirc_dev_fop_close);
540
541unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait)
542{
543 struct irctl *ir = irctls[iminor(file_inode(file))];
544 unsigned int ret;
545
546 if (!ir) {
547 printk(KERN_ERR "%s: called with invalid irctl\n", __func__);
548 return POLLERR;
549 }
550
551 dev_dbg(ir->d.dev, LOGHEAD "poll called\n", ir->d.name, ir->d.minor);
552
553 if (!ir->attached)
554 return POLLERR;
555
556 poll_wait(file, &ir->buf->wait_poll, wait);
557
558 if (ir->buf)
559 if (lirc_buffer_empty(ir->buf))
560 ret = 0;
561 else
562 ret = POLLIN | POLLRDNORM;
563 else
564 ret = POLLERR;
565
566 dev_dbg(ir->d.dev, LOGHEAD "poll result = %d\n",
567 ir->d.name, ir->d.minor, ret);
568
569 return ret;
570}
571EXPORT_SYMBOL(lirc_dev_fop_poll);
572
573long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
574{
575 __u32 mode;
576 int result = 0;
577 struct irctl *ir = irctls[iminor(file_inode(file))];
578
579 if (!ir) {
580 printk(KERN_ERR "lirc_dev: %s: no irctl found!\n", __func__);
581 return -ENODEV;
582 }
583
584 dev_dbg(ir->d.dev, LOGHEAD "ioctl called (0x%x)\n",
585 ir->d.name, ir->d.minor, cmd);
586
587 if (ir->d.minor == NOPLUG || !ir->attached) {
588 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = -ENODEV\n",
589 ir->d.name, ir->d.minor);
590 return -ENODEV;
591 }
592
593 mutex_lock(&ir->irctl_lock);
594
595 switch (cmd) {
596 case LIRC_GET_FEATURES:
597 result = put_user(ir->d.features, (__u32 __user *)arg);
598 break;
599 case LIRC_GET_REC_MODE:
600 if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
601 result = -ENOSYS;
602 break;
603 }
604
605 result = put_user(LIRC_REC2MODE
606 (ir->d.features & LIRC_CAN_REC_MASK),
607 (__u32 __user *)arg);
608 break;
609 case LIRC_SET_REC_MODE:
610 if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
611 result = -ENOSYS;
612 break;
613 }
614
615 result = get_user(mode, (__u32 __user *)arg);
616 if (!result && !(LIRC_MODE2REC(mode) & ir->d.features))
617 result = -EINVAL;
618
619
620
621
622 break;
623 case LIRC_GET_LENGTH:
624 result = put_user(ir->d.code_length, (__u32 __user *)arg);
625 break;
626 case LIRC_GET_MIN_TIMEOUT:
627 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
628 ir->d.min_timeout == 0) {
629 result = -ENOSYS;
630 break;
631 }
632
633 result = put_user(ir->d.min_timeout, (__u32 __user *)arg);
634 break;
635 case LIRC_GET_MAX_TIMEOUT:
636 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
637 ir->d.max_timeout == 0) {
638 result = -ENOSYS;
639 break;
640 }
641
642 result = put_user(ir->d.max_timeout, (__u32 __user *)arg);
643 break;
644 default:
645 result = -EINVAL;
646 }
647
648 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = %d\n",
649 ir->d.name, ir->d.minor, result);
650
651 mutex_unlock(&ir->irctl_lock);
652
653 return result;
654}
655EXPORT_SYMBOL(lirc_dev_fop_ioctl);
656
657ssize_t lirc_dev_fop_read(struct file *file,
658 char __user *buffer,
659 size_t length,
660 loff_t *ppos)
661{
662 struct irctl *ir = irctls[iminor(file_inode(file))];
663 unsigned char *buf;
664 int ret = 0, written = 0;
665 DECLARE_WAITQUEUE(wait, current);
666
667 if (!ir) {
668 printk(KERN_ERR "%s: called with invalid irctl\n", __func__);
669 return -ENODEV;
670 }
671
672 dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor);
673
674 buf = kzalloc(ir->chunk_size, GFP_KERNEL);
675 if (!buf)
676 return -ENOMEM;
677
678 if (mutex_lock_interruptible(&ir->irctl_lock)) {
679 ret = -ERESTARTSYS;
680 goto out_unlocked;
681 }
682 if (!ir->attached) {
683 ret = -ENODEV;
684 goto out_locked;
685 }
686
687 if (length % ir->chunk_size) {
688 ret = -EINVAL;
689 goto out_locked;
690 }
691
692
693
694
695
696
697 add_wait_queue(&ir->buf->wait_poll, &wait);
698 set_current_state(TASK_INTERRUPTIBLE);
699
700
701
702
703
704 while (written < length && ret == 0) {
705 if (lirc_buffer_empty(ir->buf)) {
706
707
708
709
710 if (written)
711 break;
712 if (file->f_flags & O_NONBLOCK) {
713 ret = -EWOULDBLOCK;
714 break;
715 }
716 if (signal_pending(current)) {
717 ret = -ERESTARTSYS;
718 break;
719 }
720
721 mutex_unlock(&ir->irctl_lock);
722 schedule();
723 set_current_state(TASK_INTERRUPTIBLE);
724
725 if (mutex_lock_interruptible(&ir->irctl_lock)) {
726 ret = -ERESTARTSYS;
727 remove_wait_queue(&ir->buf->wait_poll, &wait);
728 set_current_state(TASK_RUNNING);
729 goto out_unlocked;
730 }
731
732 if (!ir->attached) {
733 ret = -ENODEV;
734 break;
735 }
736 } else {
737 lirc_buffer_read(ir->buf, buf);
738 ret = copy_to_user((void __user *)buffer+written, buf,
739 ir->buf->chunk_size);
740 if (!ret)
741 written += ir->buf->chunk_size;
742 else
743 ret = -EFAULT;
744 }
745 }
746
747 remove_wait_queue(&ir->buf->wait_poll, &wait);
748 set_current_state(TASK_RUNNING);
749
750out_locked:
751 mutex_unlock(&ir->irctl_lock);
752
753out_unlocked:
754 kfree(buf);
755 dev_dbg(ir->d.dev, LOGHEAD "read result = %s (%d)\n",
756 ir->d.name, ir->d.minor, ret ? "<fail>" : "<ok>", ret);
757
758 return ret ? ret : written;
759}
760EXPORT_SYMBOL(lirc_dev_fop_read);
761
762void *lirc_get_pdata(struct file *file)
763{
764 return irctls[iminor(file_inode(file))]->d.data;
765}
766EXPORT_SYMBOL(lirc_get_pdata);
767
768
769ssize_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_inode(file))];
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}
786EXPORT_SYMBOL(lirc_dev_fop_write);
787
788
789static 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
812error:
813 return retval;
814}
815
816
817
818static 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
825module_init(lirc_dev_init);
826module_exit(lirc_dev_exit);
827
828MODULE_DESCRIPTION("LIRC base driver module");
829MODULE_AUTHOR("Artur Lipowski");
830MODULE_LICENSE("GPL");
831
832module_param(debug, bool, S_IRUGO | S_IWUSR);
833MODULE_PARM_DESC(debug, "Enable debugging messages");
834
