4 * by Artur Lipowski <alipowski@interia.pl>
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.
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.
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
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>
28 #include <linux/poll.h>
29 #include <linux/completion.h>
30 #include <linux/errno.h>
31 #include <linux/mutex.h>
32 #include <linux/wait.h>
33 #include <linux/unistd.h>
34 #include <linux/kthread.h>
35 #include <linux/bitops.h>
36 #include <linux/device.h>
37 #include <linux/cdev.h>
39 #include <media/lirc.h>
40 #include <media/lirc_dev.h>
44 #define IRCTL_DEV_NAME "BaseRemoteCtl"
46 #define LOGHEAD "lirc_dev (%s[%d]): "
48 static dev_t lirc_base_dev
;
55 struct mutex irctl_lock
;
56 struct lirc_buffer
*buf
;
57 unsigned int chunk_size
;
59 struct task_struct
*task
;
63 static DEFINE_MUTEX(lirc_dev_lock
);
65 static struct irctl
*irctls
[MAX_IRCTL_DEVICES
];
66 static struct cdev cdevs
[MAX_IRCTL_DEVICES
];
68 /* Only used for sysfs but defined to void otherwise */
69 static struct class *lirc_class
;
72 * initializes the irctl structure
74 static void lirc_irctl_init(struct irctl
*ir
)
76 mutex_init(&ir
->irctl_lock
);
80 static void lirc_irctl_cleanup(struct irctl
*ir
)
82 dev_dbg(ir
->d
.dev
, LOGHEAD
"cleaning up\n", ir
->d
.name
, ir
->d
.minor
);
84 device_destroy(lirc_class
, MKDEV(MAJOR(lirc_base_dev
), ir
->d
.minor
));
86 if (ir
->buf
!= ir
->d
.rbuf
) {
87 lirc_buffer_free(ir
->buf
);
94 * reads key codes from driver and puts them into buffer
95 * returns 0 on success
97 static int lirc_add_to_buf(struct irctl
*ir
)
99 if (ir
->d
.add_to_buf
) {
104 * service the device as long as it is returning
105 * data and we have space
108 res
= ir
->d
.add_to_buf(ir
->d
.data
, ir
->buf
);
115 kthread_stop(ir
->task
);
117 return got_data
? 0 : res
;
123 /* main function of the polling thread
125 static int lirc_thread(void *irctl
)
127 struct irctl
*ir
= irctl
;
129 dev_dbg(ir
->d
.dev
, LOGHEAD
"poll thread started\n",
130 ir
->d
.name
, ir
->d
.minor
);
134 if (ir
->jiffies_to_wait
) {
135 set_current_state(TASK_INTERRUPTIBLE
);
136 schedule_timeout(ir
->jiffies_to_wait
);
138 if (kthread_should_stop())
140 if (!lirc_add_to_buf(ir
))
141 wake_up_interruptible(&ir
->buf
->wait_poll
);
143 set_current_state(TASK_INTERRUPTIBLE
);
146 } while (!kthread_should_stop());
148 dev_dbg(ir
->d
.dev
, LOGHEAD
"poll thread ended\n",
149 ir
->d
.name
, ir
->d
.minor
);
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
,
162 .compat_ioctl
= lirc_dev_fop_ioctl
,
164 .open
= lirc_dev_fop_open
,
165 .release
= lirc_dev_fop_close
,
168 static int lirc_cdev_add(struct irctl
*ir
)
171 struct lirc_driver
*d
= &ir
->d
;
172 struct cdev
*cdev
= &cdevs
[d
->minor
];
175 cdev_init(cdev
, d
->fops
);
176 cdev
->owner
= d
->owner
;
178 cdev_init(cdev
, &lirc_dev_fops
);
179 cdev
->owner
= THIS_MODULE
;
181 kobject_set_name(&cdev
->kobj
, "lirc%d", d
->minor
);
183 retval
= cdev_add(cdev
, MKDEV(MAJOR(lirc_base_dev
), d
->minor
), 1);
185 kobject_put(&cdev
->kobj
);
190 int lirc_register_driver(struct lirc_driver
*d
)
195 unsigned int chunk_size
;
196 unsigned int buffer_size
;
200 printk(KERN_ERR
"lirc_dev: lirc_register_driver: "
201 "driver pointer must be not NULL!\n");
207 printk(KERN_ERR
"%s: dev pointer not filled in!\n", __func__
);
212 if (MAX_IRCTL_DEVICES
<= d
->minor
) {
213 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
214 "\"minor\" must be between 0 and %d (%d)!\n",
215 MAX_IRCTL_DEVICES
-1, d
->minor
);
220 if (1 > d
->code_length
|| (BUFLEN
* 8) < d
->code_length
) {
221 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
222 "code length in bits for minor (%d) "
223 "must be less than %d!\n",
224 d
->minor
, BUFLEN
* 8);
229 dev_dbg(d
->dev
, "lirc_dev: lirc_register_driver: sample_rate: %d\n",
231 if (d
->sample_rate
) {
232 if (2 > d
->sample_rate
|| HZ
< d
->sample_rate
) {
233 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
234 "sample_rate must be between 2 and %d!\n", HZ
);
238 if (!d
->add_to_buf
) {
239 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
240 "add_to_buf cannot be NULL when "
241 "sample_rate is set\n");
245 } else if (!(d
->fops
&& d
->fops
->read
) && !d
->rbuf
) {
246 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
247 "fops->read and rbuf cannot all be NULL!\n");
250 } else if (!d
->rbuf
) {
251 if (!(d
->fops
&& d
->fops
->read
&& d
->fops
->poll
&&
252 d
->fops
->unlocked_ioctl
)) {
253 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
254 "neither read, poll nor unlocked_ioctl can be NULL!\n");
260 mutex_lock(&lirc_dev_lock
);
265 /* find first free slot for driver */
266 for (minor
= 0; minor
< MAX_IRCTL_DEVICES
; minor
++)
269 if (MAX_IRCTL_DEVICES
== minor
) {
270 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
271 "no free slots for drivers!\n");
275 } else if (irctls
[minor
]) {
276 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
277 "minor (%d) just registered!\n", minor
);
282 ir
= kzalloc(sizeof(struct irctl
), GFP_KERNEL
);
291 if (d
->sample_rate
) {
292 ir
->jiffies_to_wait
= HZ
/ d
->sample_rate
;
294 /* it means - wait for external event in task queue */
295 ir
->jiffies_to_wait
= 0;
298 /* some safety check 8-) */
299 d
->name
[sizeof(d
->name
)-1] = '\0';
301 bytes_in_key
= BITS_TO_LONGS(d
->code_length
) +
302 (d
->code_length
% 8 ? 1 : 0);
303 buffer_size
= d
->buffer_size
? d
->buffer_size
: BUFLEN
/ bytes_in_key
;
304 chunk_size
= d
->chunk_size
? d
->chunk_size
: bytes_in_key
;
309 ir
->buf
= kmalloc(sizeof(struct lirc_buffer
), GFP_KERNEL
);
314 err
= lirc_buffer_init(ir
->buf
, chunk_size
, buffer_size
);
320 ir
->chunk_size
= ir
->buf
->chunk_size
;
322 if (d
->features
== 0)
323 d
->features
= LIRC_CAN_REC_LIRCCODE
;
327 device_create(lirc_class
, ir
->d
.dev
,
328 MKDEV(MAJOR(lirc_base_dev
), ir
->d
.minor
), NULL
,
329 "lirc%u", ir
->d
.minor
);
331 if (d
->sample_rate
) {
332 /* try to fire up polling thread */
333 ir
->task
= kthread_run(lirc_thread
, (void *)ir
, "lirc_dev");
334 if (IS_ERR(ir
->task
)) {
335 dev_err(d
->dev
, "lirc_dev: lirc_register_driver: "
336 "cannot run poll thread for minor = %d\n",
343 err
= lirc_cdev_add(ir
);
348 mutex_unlock(&lirc_dev_lock
);
350 dev_info(ir
->d
.dev
, "lirc_dev: driver %s registered at minor = %d\n",
351 ir
->d
.name
, ir
->d
.minor
);
355 device_destroy(lirc_class
, MKDEV(MAJOR(lirc_base_dev
), ir
->d
.minor
));
357 mutex_unlock(&lirc_dev_lock
);
361 EXPORT_SYMBOL(lirc_register_driver
);
363 int lirc_unregister_driver(int minor
)
368 if (minor
< 0 || minor
>= MAX_IRCTL_DEVICES
) {
369 printk(KERN_ERR
"lirc_dev: %s: minor (%d) must be between "
370 "0 and %d!\n", __func__
, minor
, MAX_IRCTL_DEVICES
-1);
376 printk(KERN_ERR
"lirc_dev: %s: failed to get irctl struct "
377 "for minor %d!\n", __func__
, minor
);
381 cdev
= &cdevs
[minor
];
383 mutex_lock(&lirc_dev_lock
);
385 if (ir
->d
.minor
!= minor
) {
386 printk(KERN_ERR
"lirc_dev: %s: minor (%d) device not "
387 "registered!\n", __func__
, minor
);
388 mutex_unlock(&lirc_dev_lock
);
392 /* end up polling thread */
394 kthread_stop(ir
->task
);
396 dev_dbg(ir
->d
.dev
, "lirc_dev: driver %s unregistered from minor = %d\n",
397 ir
->d
.name
, ir
->d
.minor
);
401 dev_dbg(ir
->d
.dev
, LOGHEAD
"releasing opened driver\n",
402 ir
->d
.name
, ir
->d
.minor
);
403 wake_up_interruptible(&ir
->buf
->wait_poll
);
404 mutex_lock(&ir
->irctl_lock
);
405 ir
->d
.set_use_dec(ir
->d
.data
);
406 module_put(cdev
->owner
);
407 mutex_unlock(&ir
->irctl_lock
);
409 lirc_irctl_cleanup(ir
);
412 irctls
[minor
] = NULL
;
415 mutex_unlock(&lirc_dev_lock
);
419 EXPORT_SYMBOL(lirc_unregister_driver
);
421 int lirc_dev_fop_open(struct inode
*inode
, struct file
*file
)
427 if (iminor(inode
) >= MAX_IRCTL_DEVICES
) {
428 printk(KERN_WARNING
"lirc_dev [%d]: open result = -ENODEV\n",
433 if (mutex_lock_interruptible(&lirc_dev_lock
))
436 ir
= irctls
[iminor(inode
)];
442 dev_dbg(ir
->d
.dev
, LOGHEAD
"open called\n", ir
->d
.name
, ir
->d
.minor
);
444 if (ir
->d
.minor
== NOPLUG
) {
454 cdev
= &cdevs
[iminor(inode
)];
455 if (try_module_get(cdev
->owner
)) {
457 retval
= ir
->d
.set_use_inc(ir
->d
.data
);
460 module_put(cdev
->owner
);
463 lirc_buffer_clear(ir
->buf
);
466 wake_up_process(ir
->task
);
471 dev_dbg(ir
->d
.dev
, LOGHEAD
"open result = %d\n",
472 ir
->d
.name
, ir
->d
.minor
, retval
);
474 mutex_unlock(&lirc_dev_lock
);
478 EXPORT_SYMBOL(lirc_dev_fop_open
);
480 int lirc_dev_fop_close(struct inode
*inode
, struct file
*file
)
482 struct irctl
*ir
= irctls
[iminor(inode
)];
483 struct cdev
*cdev
= &cdevs
[iminor(inode
)];
486 printk(KERN_ERR
"%s: called with invalid irctl\n", __func__
);
490 dev_dbg(ir
->d
.dev
, LOGHEAD
"close called\n", ir
->d
.name
, ir
->d
.minor
);
492 WARN_ON(mutex_lock_killable(&lirc_dev_lock
));
496 ir
->d
.set_use_dec(ir
->d
.data
);
497 module_put(cdev
->owner
);
499 lirc_irctl_cleanup(ir
);
501 irctls
[ir
->d
.minor
] = NULL
;
505 mutex_unlock(&lirc_dev_lock
);
509 EXPORT_SYMBOL(lirc_dev_fop_close
);
511 unsigned int lirc_dev_fop_poll(struct file
*file
, poll_table
*wait
)
513 struct irctl
*ir
= irctls
[iminor(file
->f_dentry
->d_inode
)];
517 printk(KERN_ERR
"%s: called with invalid irctl\n", __func__
);
521 dev_dbg(ir
->d
.dev
, LOGHEAD
"poll called\n", ir
->d
.name
, ir
->d
.minor
);
524 mutex_unlock(&ir
->irctl_lock
);
528 poll_wait(file
, &ir
->buf
->wait_poll
, wait
);
531 if (lirc_buffer_empty(ir
->buf
))
534 ret
= POLLIN
| POLLRDNORM
;
538 dev_dbg(ir
->d
.dev
, LOGHEAD
"poll result = %d\n",
539 ir
->d
.name
, ir
->d
.minor
, ret
);
543 EXPORT_SYMBOL(lirc_dev_fop_poll
);
545 long lirc_dev_fop_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
549 struct irctl
*ir
= irctls
[iminor(file
->f_dentry
->d_inode
)];
552 printk(KERN_ERR
"lirc_dev: %s: no irctl found!\n", __func__
);
556 dev_dbg(ir
->d
.dev
, LOGHEAD
"ioctl called (0x%x)\n",
557 ir
->d
.name
, ir
->d
.minor
, cmd
);
559 if (ir
->d
.minor
== NOPLUG
|| !ir
->attached
) {
560 dev_dbg(ir
->d
.dev
, LOGHEAD
"ioctl result = -ENODEV\n",
561 ir
->d
.name
, ir
->d
.minor
);
565 mutex_lock(&ir
->irctl_lock
);
568 case LIRC_GET_FEATURES
:
569 result
= put_user(ir
->d
.features
, (__u32
*)arg
);
571 case LIRC_GET_REC_MODE
:
572 if (!(ir
->d
.features
& LIRC_CAN_REC_MASK
)) {
577 result
= put_user(LIRC_REC2MODE
578 (ir
->d
.features
& LIRC_CAN_REC_MASK
),
581 case LIRC_SET_REC_MODE
:
582 if (!(ir
->d
.features
& LIRC_CAN_REC_MASK
)) {
587 result
= get_user(mode
, (__u32
*)arg
);
588 if (!result
&& !(LIRC_MODE2REC(mode
) & ir
->d
.features
))
591 * FIXME: We should actually set the mode somehow but
592 * for now, lirc_serial doesn't support mode changing either
595 case LIRC_GET_LENGTH
:
596 result
= put_user(ir
->d
.code_length
, (__u32
*)arg
);
598 case LIRC_GET_MIN_TIMEOUT
:
599 if (!(ir
->d
.features
& LIRC_CAN_SET_REC_TIMEOUT
) ||
600 ir
->d
.min_timeout
== 0) {
605 result
= put_user(ir
->d
.min_timeout
, (__u32
*)arg
);
607 case LIRC_GET_MAX_TIMEOUT
:
608 if (!(ir
->d
.features
& LIRC_CAN_SET_REC_TIMEOUT
) ||
609 ir
->d
.max_timeout
== 0) {
614 result
= put_user(ir
->d
.max_timeout
, (__u32
*)arg
);
620 dev_dbg(ir
->d
.dev
, LOGHEAD
"ioctl result = %d\n",
621 ir
->d
.name
, ir
->d
.minor
, result
);
623 mutex_unlock(&ir
->irctl_lock
);
627 EXPORT_SYMBOL(lirc_dev_fop_ioctl
);
629 ssize_t
lirc_dev_fop_read(struct file
*file
,
634 struct irctl
*ir
= irctls
[iminor(file
->f_dentry
->d_inode
)];
636 int ret
= 0, written
= 0;
637 DECLARE_WAITQUEUE(wait
, current
);
640 printk(KERN_ERR
"%s: called with invalid irctl\n", __func__
);
644 dev_dbg(ir
->d
.dev
, LOGHEAD
"read called\n", ir
->d
.name
, ir
->d
.minor
);
646 buf
= kzalloc(ir
->chunk_size
, GFP_KERNEL
);
650 if (mutex_lock_interruptible(&ir
->irctl_lock
))
653 mutex_unlock(&ir
->irctl_lock
);
657 if (length
% ir
->chunk_size
) {
658 dev_dbg(ir
->d
.dev
, LOGHEAD
"read result = -EINVAL\n",
659 ir
->d
.name
, ir
->d
.minor
);
660 mutex_unlock(&ir
->irctl_lock
);
665 * we add ourselves to the task queue before buffer check
666 * to avoid losing scan code (in case when queue is awaken somewhere
667 * between while condition checking and scheduling)
669 add_wait_queue(&ir
->buf
->wait_poll
, &wait
);
670 set_current_state(TASK_INTERRUPTIBLE
);
673 * while we didn't provide 'length' bytes, device is opened in blocking
674 * mode and 'copy_to_user' is happy, wait for data.
676 while (written
< length
&& ret
== 0) {
677 if (lirc_buffer_empty(ir
->buf
)) {
678 /* According to the read(2) man page, 'written' can be
679 * returned as less than 'length', instead of blocking
680 * again, returning -EWOULDBLOCK, or returning
684 if (file
->f_flags
& O_NONBLOCK
) {
688 if (signal_pending(current
)) {
693 mutex_unlock(&ir
->irctl_lock
);
695 set_current_state(TASK_INTERRUPTIBLE
);
697 if (mutex_lock_interruptible(&ir
->irctl_lock
)) {
699 remove_wait_queue(&ir
->buf
->wait_poll
, &wait
);
700 set_current_state(TASK_RUNNING
);
709 lirc_buffer_read(ir
->buf
, buf
);
710 ret
= copy_to_user((void *)buffer
+written
, buf
,
711 ir
->buf
->chunk_size
);
712 written
+= ir
->buf
->chunk_size
;
716 remove_wait_queue(&ir
->buf
->wait_poll
, &wait
);
717 set_current_state(TASK_RUNNING
);
718 mutex_unlock(&ir
->irctl_lock
);
722 dev_dbg(ir
->d
.dev
, LOGHEAD
"read result = %s (%d)\n",
723 ir
->d
.name
, ir
->d
.minor
, ret
? "-EFAULT" : "OK", ret
);
725 return ret
? ret
: written
;
727 EXPORT_SYMBOL(lirc_dev_fop_read
);
729 void *lirc_get_pdata(struct file
*file
)
733 if (file
&& file
->f_dentry
&& file
->f_dentry
->d_inode
&&
734 file
->f_dentry
->d_inode
->i_rdev
) {
736 ir
= irctls
[iminor(file
->f_dentry
->d_inode
)];
742 EXPORT_SYMBOL(lirc_get_pdata
);
745 ssize_t
lirc_dev_fop_write(struct file
*file
, const char *buffer
,
746 size_t length
, loff_t
*ppos
)
748 struct irctl
*ir
= irctls
[iminor(file
->f_dentry
->d_inode
)];
751 printk(KERN_ERR
"%s: called with invalid irctl\n", __func__
);
755 dev_dbg(ir
->d
.dev
, LOGHEAD
"write called\n", ir
->d
.name
, ir
->d
.minor
);
762 EXPORT_SYMBOL(lirc_dev_fop_write
);
765 static int __init
lirc_dev_init(void)
769 lirc_class
= class_create(THIS_MODULE
, "lirc");
770 if (IS_ERR(lirc_class
)) {
771 retval
= PTR_ERR(lirc_class
);
772 printk(KERN_ERR
"lirc_dev: class_create failed\n");
776 retval
= alloc_chrdev_region(&lirc_base_dev
, 0, MAX_IRCTL_DEVICES
,
779 class_destroy(lirc_class
);
780 printk(KERN_ERR
"lirc_dev: alloc_chrdev_region failed\n");
785 printk(KERN_INFO
"lirc_dev: IR Remote Control driver registered, "
786 "major %d \n", MAJOR(lirc_base_dev
));
794 static void __exit
lirc_dev_exit(void)
796 class_destroy(lirc_class
);
797 unregister_chrdev_region(lirc_base_dev
, MAX_IRCTL_DEVICES
);
798 printk(KERN_INFO
"lirc_dev: module unloaded\n");
801 module_init(lirc_dev_init
);
802 module_exit(lirc_dev_exit
);
804 MODULE_DESCRIPTION("LIRC base driver module");
805 MODULE_AUTHOR("Artur Lipowski");
806 MODULE_LICENSE("GPL");
808 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
809 MODULE_PARM_DESC(debug
, "Enable debugging messages");