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/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>
38 #include <media/lirc.h>
39 #include <media/lirc_dev.h>
43 #define IRCTL_DEV_NAME "BaseRemoteCtl"
45 #define LOGHEAD "lirc_dev (%s[%d]): "
47 static dev_t lirc_base_dev;
54 struct mutex irctl_lock;
55 struct lirc_buffer *buf;
56 unsigned int chunk_size;
58 struct task_struct *task;
64 static DEFINE_MUTEX(lirc_dev_lock);
66 static struct irctl *irctls[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 init_irctl(struct irctl *ir)
76 dev_dbg(ir->d.dev, LOGHEAD "initializing irctl\n",
77 ir->d.name, ir->d.minor);
78 mutex_init(&ir->irctl_lock);
82 static void cleanup(struct irctl *ir)
84 dev_dbg(ir->d.dev, LOGHEAD "cleaning up\n", ir->d.name, ir->d.minor);
86 device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
88 if (ir->buf != ir->d.rbuf) {
89 lirc_buffer_free(ir->buf);
96 * reads key codes from driver and puts them into buffer
97 * returns 0 on success
99 static int add_to_buf(struct irctl *ir)
101 if (ir->d.add_to_buf) {
106 * service the device as long as it is returning
107 * data and we have space
110 res = ir->d.add_to_buf(ir->d.data, ir->buf);
117 kthread_stop(ir->task);
119 return got_data ? 0 : res;
125 /* main function of the polling thread
127 static int lirc_thread(void *irctl)
129 struct irctl *ir = irctl;
131 dev_dbg(ir->d.dev, LOGHEAD "poll thread started\n",
132 ir->d.name, ir->d.minor);
136 if (ir->jiffies_to_wait) {
137 set_current_state(TASK_INTERRUPTIBLE);
138 schedule_timeout(ir->jiffies_to_wait);
140 if (kthread_should_stop())
143 wake_up_interruptible(&ir->buf->wait_poll);
145 set_current_state(TASK_INTERRUPTIBLE);
148 } while (!kthread_should_stop());
150 dev_dbg(ir->d.dev, LOGHEAD "poll thread ended\n",
151 ir->d.name, ir->d.minor);
157 static struct file_operations fops = {
158 .owner = THIS_MODULE,
159 .read = lirc_dev_fop_read,
160 .write = lirc_dev_fop_write,
161 .poll = lirc_dev_fop_poll,
162 .unlocked_ioctl = lirc_dev_fop_ioctl,
163 .open = lirc_dev_fop_open,
164 .release = lirc_dev_fop_close,
165 .llseek = noop_llseek,
168 static int lirc_cdev_add(struct irctl *ir)
171 struct lirc_driver *d = &ir->d;
174 cdev_init(&ir->cdev, d->fops);
175 ir->cdev.owner = d->owner;
177 cdev_init(&ir->cdev, &fops);
178 ir->cdev.owner = THIS_MODULE;
180 kobject_set_name(&ir->cdev.kobj, "lirc%d", d->minor);
182 retval = cdev_add(&ir->cdev, MKDEV(MAJOR(lirc_base_dev), d->minor), 1);
184 kobject_put(&ir->cdev.kobj);
189 int lirc_register_driver(struct lirc_driver *d)
194 unsigned int chunk_size;
195 unsigned int buffer_size;
199 printk(KERN_ERR "lirc_dev: lirc_register_driver: "
200 "driver pointer must be not NULL!\n");
205 if (MAX_IRCTL_DEVICES <= d->minor) {
206 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
207 "\"minor\" must be between 0 and %d (%d)!\n",
208 MAX_IRCTL_DEVICES-1, d->minor);
213 if (1 > d->code_length || (BUFLEN * 8) < d->code_length) {
214 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
215 "code length in bits for minor (%d) "
216 "must be less than %d!\n",
217 d->minor, BUFLEN * 8);
222 dev_dbg(d->dev, "lirc_dev: lirc_register_driver: sample_rate: %d\n",
224 if (d->sample_rate) {
225 if (2 > d->sample_rate || HZ < d->sample_rate) {
226 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
227 "sample_rate must be between 2 and %d!\n", HZ);
231 if (!d->add_to_buf) {
232 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
233 "add_to_buf cannot be NULL when "
234 "sample_rate is set\n");
238 } else if (!(d->fops && d->fops->read) && !d->rbuf) {
239 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
240 "fops->read and rbuf cannot all be NULL!\n");
243 } else if (!d->rbuf) {
244 if (!(d->fops && d->fops->read && d->fops->poll &&
245 d->fops->unlocked_ioctl)) {
246 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
247 "neither read, poll nor unlocked_ioctl can be NULL!\n");
253 mutex_lock(&lirc_dev_lock);
258 /* find first free slot for driver */
259 for (minor = 0; minor < MAX_IRCTL_DEVICES; minor++)
262 if (MAX_IRCTL_DEVICES == minor) {
263 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
264 "no free slots for drivers!\n");
268 } else if (irctls[minor]) {
269 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
270 "minor (%d) just registered!\n", minor);
275 ir = kzalloc(sizeof(struct irctl), GFP_KERNEL);
284 if (d->sample_rate) {
285 ir->jiffies_to_wait = HZ / d->sample_rate;
287 /* it means - wait for external event in task queue */
288 ir->jiffies_to_wait = 0;
291 /* some safety check 8-) */
292 d->name[sizeof(d->name)-1] = '\0';
294 bytes_in_key = BITS_TO_LONGS(d->code_length) +
295 (d->code_length % 8 ? 1 : 0);
296 buffer_size = d->buffer_size ? d->buffer_size : BUFLEN / bytes_in_key;
297 chunk_size = d->chunk_size ? d->chunk_size : bytes_in_key;
302 ir->buf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
307 err = lirc_buffer_init(ir->buf, chunk_size, buffer_size);
313 ir->chunk_size = ir->buf->chunk_size;
315 if (d->features == 0)
316 d->features = LIRC_CAN_REC_LIRCCODE;
321 device_create(lirc_class, ir->d.dev,
322 MKDEV(MAJOR(lirc_base_dev), ir->d.minor), NULL,
323 "lirc%u", ir->d.minor);
325 if (d->sample_rate) {
326 /* try to fire up polling thread */
327 ir->task = kthread_run(lirc_thread, (void *)ir, "lirc_dev");
328 if (IS_ERR(ir->task)) {
329 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
330 "cannot run poll thread for minor = %d\n",
337 err = lirc_cdev_add(ir);
342 mutex_unlock(&lirc_dev_lock);
344 dev_info(ir->d.dev, "lirc_dev: driver %s registered at minor = %d\n",
345 ir->d.name, ir->d.minor);
349 device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
351 mutex_unlock(&lirc_dev_lock);
355 EXPORT_SYMBOL(lirc_register_driver);
357 int lirc_unregister_driver(int minor)
361 if (minor < 0 || minor >= MAX_IRCTL_DEVICES) {
362 printk(KERN_ERR "lirc_dev: lirc_unregister_driver: "
363 "\"minor (%d)\" must be between 0 and %d!\n",
364 minor, MAX_IRCTL_DEVICES-1);
370 mutex_lock(&lirc_dev_lock);
372 if (ir->d.minor != minor) {
373 printk(KERN_ERR "lirc_dev: lirc_unregister_driver: "
374 "minor (%d) device not registered!", minor);
375 mutex_unlock(&lirc_dev_lock);
379 /* end up polling thread */
381 kthread_stop(ir->task);
383 dev_dbg(ir->d.dev, "lirc_dev: driver %s unregistered from minor = %d\n",
384 ir->d.name, ir->d.minor);
388 dev_dbg(ir->d.dev, LOGHEAD "releasing opened driver\n",
389 ir->d.name, ir->d.minor);
390 wake_up_interruptible(&ir->buf->wait_poll);
391 mutex_lock(&ir->irctl_lock);
392 ir->d.set_use_dec(ir->d.data);
393 module_put(ir->d.owner);
394 mutex_unlock(&ir->irctl_lock);
400 irctls[minor] = NULL;
403 mutex_unlock(&lirc_dev_lock);
407 EXPORT_SYMBOL(lirc_unregister_driver);
409 int lirc_dev_fop_open(struct inode *inode, struct file *file)
414 if (iminor(inode) >= MAX_IRCTL_DEVICES) {
415 printk(KERN_WARNING "lirc_dev [%d]: open result = -ENODEV\n",
420 if (mutex_lock_interruptible(&lirc_dev_lock))
423 ir = irctls[iminor(inode)];
428 file->private_data = ir;
430 dev_dbg(ir->d.dev, LOGHEAD "open called\n", ir->d.name, ir->d.minor);
432 if (ir->d.minor == NOPLUG) {
442 if (try_module_get(ir->d.owner)) {
444 retval = ir->d.set_use_inc(ir->d.data);
447 module_put(ir->d.owner);
450 lirc_buffer_clear(ir->buf);
453 wake_up_process(ir->task);
458 dev_dbg(ir->d.dev, LOGHEAD "open result = %d\n",
459 ir->d.name, ir->d.minor, retval);
461 mutex_unlock(&lirc_dev_lock);
463 nonseekable_open(inode, file);
467 EXPORT_SYMBOL(lirc_dev_fop_open);
469 int lirc_dev_fop_close(struct inode *inode, struct file *file)
471 struct irctl *ir = irctls[iminor(inode)];
473 dev_dbg(ir->d.dev, LOGHEAD "close called\n", ir->d.name, ir->d.minor);
475 WARN_ON(mutex_lock_killable(&lirc_dev_lock));
479 ir->d.set_use_dec(ir->d.data);
480 module_put(ir->d.owner);
483 irctls[ir->d.minor] = NULL;
487 mutex_unlock(&lirc_dev_lock);
491 EXPORT_SYMBOL(lirc_dev_fop_close);
493 unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait)
495 struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];
498 dev_dbg(ir->d.dev, LOGHEAD "poll called\n", ir->d.name, ir->d.minor);
501 mutex_unlock(&ir->irctl_lock);
505 poll_wait(file, &ir->buf->wait_poll, wait);
508 if (lirc_buffer_empty(ir->buf))
511 ret = POLLIN | POLLRDNORM;
515 dev_dbg(ir->d.dev, LOGHEAD "poll result = %d\n",
516 ir->d.name, ir->d.minor, ret);
520 EXPORT_SYMBOL(lirc_dev_fop_poll);
522 long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
526 struct irctl *ir = file->private_data;
528 dev_dbg(ir->d.dev, LOGHEAD "ioctl called (0x%x)\n",
529 ir->d.name, ir->d.minor, cmd);
531 if (ir->d.minor == NOPLUG || !ir->attached) {
532 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = -ENODEV\n",
533 ir->d.name, ir->d.minor);
537 mutex_lock(&ir->irctl_lock);
540 case LIRC_GET_FEATURES:
541 result = put_user(ir->d.features, (unsigned long *)arg);
543 case LIRC_GET_REC_MODE:
544 if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
549 result = put_user(LIRC_REC2MODE
550 (ir->d.features & LIRC_CAN_REC_MASK),
551 (unsigned long *)arg);
553 case LIRC_SET_REC_MODE:
554 if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
559 result = get_user(mode, (unsigned long *)arg);
560 if (!result && !(LIRC_MODE2REC(mode) & ir->d.features))
563 * FIXME: We should actually set the mode somehow but
564 * for now, lirc_serial doesn't support mode changing either
567 case LIRC_GET_LENGTH:
568 result = put_user(ir->d.code_length, (unsigned long *)arg);
570 case LIRC_GET_MIN_TIMEOUT:
571 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
572 ir->d.min_timeout == 0) {
577 result = put_user(ir->d.min_timeout, (unsigned long *)arg);
579 case LIRC_GET_MAX_TIMEOUT:
580 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
581 ir->d.max_timeout == 0) {
586 result = put_user(ir->d.max_timeout, (unsigned long *)arg);
592 dev_dbg(ir->d.dev, LOGHEAD "ioctl result = %d\n",
593 ir->d.name, ir->d.minor, result);
595 mutex_unlock(&ir->irctl_lock);
599 EXPORT_SYMBOL(lirc_dev_fop_ioctl);
601 ssize_t lirc_dev_fop_read(struct file *file,
606 struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];
607 unsigned char buf[ir->chunk_size];
608 int ret = 0, written = 0;
609 DECLARE_WAITQUEUE(wait, current);
611 dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor);
613 if (mutex_lock_interruptible(&ir->irctl_lock))
616 mutex_unlock(&ir->irctl_lock);
620 if (length % ir->chunk_size) {
621 dev_dbg(ir->d.dev, LOGHEAD "read result = -EINVAL\n",
622 ir->d.name, ir->d.minor);
623 mutex_unlock(&ir->irctl_lock);
628 * we add ourselves to the task queue before buffer check
629 * to avoid losing scan code (in case when queue is awaken somewhere
630 * between while condition checking and scheduling)
632 add_wait_queue(&ir->buf->wait_poll, &wait);
633 set_current_state(TASK_INTERRUPTIBLE);
636 * while we didn't provide 'length' bytes, device is opened in blocking
637 * mode and 'copy_to_user' is happy, wait for data.
639 while (written < length && ret == 0) {
640 if (lirc_buffer_empty(ir->buf)) {
641 /* According to the read(2) man page, 'written' can be
642 * returned as less than 'length', instead of blocking
643 * again, returning -EWOULDBLOCK, or returning
647 if (file->f_flags & O_NONBLOCK) {
651 if (signal_pending(current)) {
656 mutex_unlock(&ir->irctl_lock);
658 set_current_state(TASK_INTERRUPTIBLE);
660 if (mutex_lock_interruptible(&ir->irctl_lock)) {
662 remove_wait_queue(&ir->buf->wait_poll, &wait);
663 set_current_state(TASK_RUNNING);
672 lirc_buffer_read(ir->buf, buf);
673 ret = copy_to_user((void *)buffer+written, buf,
674 ir->buf->chunk_size);
675 written += ir->buf->chunk_size;
679 remove_wait_queue(&ir->buf->wait_poll, &wait);
680 set_current_state(TASK_RUNNING);
681 mutex_unlock(&ir->irctl_lock);
684 dev_dbg(ir->d.dev, LOGHEAD "read result = %s (%d)\n",
685 ir->d.name, ir->d.minor, ret ? "-EFAULT" : "OK", ret);
687 return ret ? ret : written;
689 EXPORT_SYMBOL(lirc_dev_fop_read);
691 void *lirc_get_pdata(struct file *file)
695 if (file && file->f_dentry && file->f_dentry->d_inode &&
696 file->f_dentry->d_inode->i_rdev) {
698 ir = irctls[iminor(file->f_dentry->d_inode)];
704 EXPORT_SYMBOL(lirc_get_pdata);
707 ssize_t lirc_dev_fop_write(struct file *file, const char *buffer,
708 size_t length, loff_t *ppos)
710 struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];
712 dev_dbg(ir->d.dev, LOGHEAD "write called\n", ir->d.name, ir->d.minor);
719 EXPORT_SYMBOL(lirc_dev_fop_write);
722 static int __init lirc_dev_init(void)
726 lirc_class = class_create(THIS_MODULE, "lirc");
727 if (IS_ERR(lirc_class)) {
728 retval = PTR_ERR(lirc_class);
729 printk(KERN_ERR "lirc_dev: class_create failed\n");
733 retval = alloc_chrdev_region(&lirc_base_dev, 0, MAX_IRCTL_DEVICES,
736 class_destroy(lirc_class);
737 printk(KERN_ERR "lirc_dev: alloc_chrdev_region failed\n");
742 printk(KERN_INFO "lirc_dev: IR Remote Control driver registered, "
743 "major %d \n", MAJOR(lirc_base_dev));
751 static void __exit lirc_dev_exit(void)
753 class_destroy(lirc_class);
754 unregister_chrdev_region(lirc_base_dev, MAX_IRCTL_DEVICES);
755 printk(KERN_INFO "lirc_dev: module unloaded\n");
758 module_init(lirc_dev_init);
759 module_exit(lirc_dev_exit);
761 MODULE_DESCRIPTION("LIRC base driver module");
762 MODULE_AUTHOR("Artur Lipowski");
763 MODULE_LICENSE("GPL");
765 module_param(debug, bool, S_IRUGO | S_IWUSR);
766 MODULE_PARM_DESC(debug, "Enable debugging messages");