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