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