Release 4.15 drivers/media/rc/lirc_dev.c

/*
 * LIRC base driver
 *
 * by Artur Lipowski <alipowski@interia.pl>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/sched/signal.h>
#include <linux/ioctl.h>
#include <linux/poll.h>
#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/idr.h>

#include <media/rc-core.h>
#include <media/lirc.h>
#include <media/lirc_dev.h>


#define LOGHEAD		"lirc_dev (%s[%d]): "


static dev_t lirc_base_dev;

/* Used to keep track of allocated lirc devices */

#define LIRC_MAX_DEVICES 256
static DEFINE_IDA(lirc_ida);

/* Only used for sysfs but defined to void otherwise */

static struct class *lirc_class;



static void lirc_release_device(struct device *ld)
{
	struct lirc_dev *d = container_of(ld, struct lirc_dev, dev);

	put_device(d->dev.parent);

	if (d->buf_internal) {
		lirc_buffer_free(d->buf);
		kfree(d->buf);
		d->buf = NULL;
	}
	kfree(d);
	module_put(THIS_MODULE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Härdeman
38
52.05%
3
50.00%
Jarod Wilson
23
31.51%
1
16.67%
Sean Young
12
16.44%
2
33.33%
Total
73
100.00%
6
100.00%



static int lirc_allocate_buffer(struct lirc_dev *d)
{
	int err;

	if (d->buf) {
		d->buf_internal = false;
		return 0;
	}

	d->buf = kmalloc(sizeof(*d->buf), GFP_KERNEL);
	if (!d->buf)
		return -ENOMEM;

	err = lirc_buffer_init(d->buf, d->chunk_size, d->buffer_size);
	if (err) {
		kfree(d->buf);
		d->buf = NULL;
		return err;
	}

	d->buf_internal = true;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andi Shyti
62
57.94%
1
20.00%
David Härdeman
40
37.38%
3
60.00%
Jarod Wilson
5
4.67%
1
20.00%
Total
107
100.00%
5
100.00%


struct lirc_dev *

lirc_allocate_device(void)
{
	struct lirc_dev *d;

	d = kzalloc(sizeof(*d), GFP_KERNEL);
	if (d) {
		mutex_init(&d->mutex);
		device_initialize(&d->dev);
		d->dev.class = lirc_class;
		d->dev.release = lirc_release_device;
		__module_get(THIS_MODULE);
	}

	return d;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Härdeman
73
100.00%
2
100.00%
Total
73
100.00%
2
100.00%


EXPORT_SYMBOL(lirc_allocate_device);



void lirc_free_device(struct lirc_dev *d)
{
	if (!d)
		return;

	put_device(&d->dev);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Härdeman
24
100.00%
2
100.00%
Total
24
100.00%
2
100.00%


EXPORT_SYMBOL(lirc_free_device);



int lirc_register_device(struct lirc_dev *d)
{
	int minor;
	int err;

	if (!d) {
		pr_err("driver pointer must be not NULL!\n");
		return -EBADRQC;
	}

	if (!d->dev.parent) {
		pr_err("dev parent pointer not filled in!\n");
		return -EINVAL;
	}

	if (!d->fops) {
		pr_err("fops pointer not filled in!\n");
		return -EINVAL;
	}

	if (!d->buf && d->chunk_size < 1) {
		pr_err("chunk_size must be set!\n");
		return -EINVAL;
	}

	if (!d->buf && d->buffer_size < 1) {
		pr_err("buffer_size must be set!\n");
		return -EINVAL;
	}

	if (d->code_length < 1 || d->code_length > (BUFLEN * 8)) {
		dev_err(&d->dev, "code length must be less than %d bits\n",
			BUFLEN * 8);
		return -EBADRQC;
	}

	if (!d->buf && !(d->fops && d->fops->read &&
			 d->fops->poll && d->fops->unlocked_ioctl)) {
		dev_err(&d->dev, "undefined read, poll, ioctl\n");
		return -EBADRQC;
	}

	/* some safety check 8-) */
	d->name[sizeof(d->name) - 1] = '\0';

	if (d->features == 0)
		d->features = LIRC_CAN_REC_LIRCCODE;

	if (LIRC_CAN_REC(d->features)) {
		err = lirc_allocate_buffer(d);
		if (err)
			return err;
	}

	minor = ida_simple_get(&lirc_ida, 0, LIRC_MAX_DEVICES, GFP_KERNEL);
	if (minor < 0)
		return minor;

	d->minor = minor;
	d->dev.devt = MKDEV(MAJOR(lirc_base_dev), d->minor);
	dev_set_name(&d->dev, "lirc%d", d->minor);

	cdev_init(&d->cdev, d->fops);
	d->cdev.owner = d->owner;
	d->attached = true;

	err = cdev_device_add(&d->cdev, &d->dev);
	if (err) {
		ida_simple_remove(&lirc_ida, minor);
		return err;
	}

	get_device(d->dev.parent);

	dev_info(&d->dev, "lirc_dev: driver %s registered at minor = %d\n",
		 d->name, d->minor);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Härdeman
207
50.36%
9
47.37%
Jarod Wilson
147
35.77%
2
10.53%
Andi Shyti
29
7.06%
5
26.32%
Sean Young
27
6.57%
2
10.53%
Arnd Bergmann
1
0.24%
1
5.26%
Total
411
100.00%
19
100.00%


EXPORT_SYMBOL(lirc_register_device);



void lirc_unregister_device(struct lirc_dev *d)
{
	if (!d)
		return;

	dev_dbg(&d->dev, "lirc_dev: driver %s unregistered from minor = %d\n",
		d->name, d->minor);

	mutex_lock(&d->mutex);

	d->attached = false;
	if (d->open) {
		dev_dbg(&d->dev, LOGHEAD "releasing opened driver\n",
			d->name, d->minor);
		wake_up_interruptible(&d->buf->wait_poll);
	}

	mutex_unlock(&d->mutex);

	cdev_device_del(&d->cdev, &d->dev);
	ida_simple_remove(&lirc_ida, d->minor);
	put_device(&d->dev);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Härdeman
59
47.58%
6
75.00%
Jarod Wilson
58
46.77%
1
12.50%
Sean Young
7
5.65%
1
12.50%
Total
124
100.00%
8
100.00%


EXPORT_SYMBOL(lirc_unregister_device);



int lirc_dev_fop_open(struct inode *inode, struct file *file)
{
	struct lirc_dev *d = container_of(inode->i_cdev, struct lirc_dev, cdev);
	int retval;

	dev_dbg(&d->dev, LOGHEAD "open called\n", d->name, d->minor);

	retval = mutex_lock_interruptible(&d->mutex);
	if (retval)
		return retval;

	if (!d->attached) {
		retval = -ENODEV;
		goto out;
	}

	if (d->open) {
		retval = -EBUSY;
		goto out;
	}

	if (d->rdev) {
		retval = rc_open(d->rdev);
		if (retval)
			goto out;
	}

	if (d->buf)
		lirc_buffer_clear(d->buf);

	d->open++;

	lirc_init_pdata(inode, file);
	nonseekable_open(inode, file);
	mutex_unlock(&d->mutex);

	return 0;

out:
	mutex_unlock(&d->mutex);
	return retval;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Härdeman
102
55.43%
5
50.00%
Jarod Wilson
50
27.17%
1
10.00%
Srinivas Kandagatla
19
10.33%
1
10.00%
Arnd Bergmann
7
3.80%
1
10.00%
Sean Young
6
3.26%
2
20.00%
Total
184
100.00%
10
100.00%


EXPORT_SYMBOL(lirc_dev_fop_open);



int lirc_dev_fop_close(struct inode *inode, struct file *file)
{
	struct lirc_dev *d = file->private_data;

	mutex_lock(&d->mutex);

	rc_close(d->rdev);
	d->open--;

	mutex_unlock(&d->mutex);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
35
63.64%
2
33.33%
David Härdeman
14
25.45%
3
50.00%
Srinivas Kandagatla
6
10.91%
1
16.67%
Total
55
100.00%
6
100.00%


EXPORT_SYMBOL(lirc_dev_fop_close);



unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait)
{
	struct lirc_dev *d = file->private_data;
	unsigned int ret;

	if (!d->attached)
		return POLLHUP | POLLERR;

	if (d->buf) {
		poll_wait(file, &d->buf->wait_poll, wait);

		if (lirc_buffer_empty(d->buf))
			ret = 0;
		else
			ret = POLLIN | POLLRDNORM;
	} else {
		ret = POLLERR;
	}

	dev_dbg(&d->dev, LOGHEAD "poll result = %d\n", d->name, d->minor, ret);

	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
90
79.65%
2
33.33%
David Härdeman
16
14.16%
3
50.00%
Andy Shevchenko
7
6.19%
1
16.67%
Total
113
100.00%
6
100.00%


EXPORT_SYMBOL(lirc_dev_fop_poll);



long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct lirc_dev *d = file->private_data;
	__u32 mode;
	int result;

	dev_dbg(&d->dev, LOGHEAD "ioctl called (0x%x)\n",
		d->name, d->minor, cmd);

	result = mutex_lock_interruptible(&d->mutex);
	if (result)
		return result;

	if (!d->attached) {
		result = -ENODEV;
		goto out;
	}

	switch (cmd) {
	case LIRC_GET_FEATURES:
		result = put_user(d->features, (__u32 __user *)arg);
		break;
	case LIRC_GET_REC_MODE:
		if (!LIRC_CAN_REC(d->features)) {
			result = -ENOTTY;
			break;
		}

		result = put_user(LIRC_REC2MODE
				  (d->features & LIRC_CAN_REC_MASK),
				  (__u32 __user *)arg);
		break;
	case LIRC_SET_REC_MODE:
		if (!LIRC_CAN_REC(d->features)) {
			result = -ENOTTY;
			break;
		}

		result = get_user(mode, (__u32 __user *)arg);
		if (!result && !(LIRC_MODE2REC(mode) & d->features))
			result = -EINVAL;
		/*
                 * FIXME: We should actually set the mode somehow but
                 * for now, lirc_serial doesn't support mode changing either
                 */
		break;
	case LIRC_GET_LENGTH:
		result = put_user(d->code_length, (__u32 __user *)arg);
		break;
	default:
		result = -ENOTTY;
	}

out:
	mutex_unlock(&d->mutex);
	return result;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
192
75.29%
2
18.18%
David Härdeman
47
18.43%
3
27.27%
Andi Shyti
8
3.14%
2
18.18%
Hans Verkuil
4
1.57%
1
9.09%
Sean Young
3
1.18%
2
18.18%
Arnd Bergmann
1
0.39%
1
9.09%
Total
255
100.00%
11
100.00%


EXPORT_SYMBOL(lirc_dev_fop_ioctl);



ssize_t lirc_dev_fop_read(struct file *file,
			  char __user *buffer,
			  size_t length,
			  loff_t *ppos)
{
	struct lirc_dev *d = file->private_data;
	unsigned char *buf;
	int ret, written = 0;
	DECLARE_WAITQUEUE(wait, current);

	buf = kzalloc(d->buf->chunk_size, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	dev_dbg(&d->dev, LOGHEAD "read called\n", d->name, d->minor);

	ret = mutex_lock_interruptible(&d->mutex);
	if (ret) {
		kfree(buf);
		return ret;
	}

	if (!d->attached) {
		ret = -ENODEV;
		goto out_locked;
	}

	if (!LIRC_CAN_REC(d->features)) {
		ret = -EINVAL;
		goto out_locked;
	}

	if (length % d->buf->chunk_size) {
		ret = -EINVAL;
		goto out_locked;
	}

	/*
         * we add ourselves to the task queue before buffer check
         * to avoid losing scan code (in case when queue is awaken somewhere
         * between while condition checking and scheduling)
         */
	add_wait_queue(&d->buf->wait_poll, &wait);

	/*
         * while we didn't provide 'length' bytes, device is opened in blocking
         * mode and 'copy_to_user' is happy, wait for data.
         */
	while (written < length && ret == 0) {
		if (lirc_buffer_empty(d->buf)) {
			/* According to the read(2) man page, 'written' can be
                         * returned as less than 'length', instead of blocking
                         * again, returning -EWOULDBLOCK, or returning
                         * -ERESTARTSYS
                         */
			if (written)
				break;
			if (file->f_flags & O_NONBLOCK) {
				ret = -EWOULDBLOCK;
				break;
			}
			if (signal_pending(current)) {
				ret = -ERESTARTSYS;
				break;
			}

			mutex_unlock(&d->mutex);
			set_current_state(TASK_INTERRUPTIBLE);
			schedule();
			set_current_state(TASK_RUNNING);

			ret = mutex_lock_interruptible(&d->mutex);
			if (ret) {
				remove_wait_queue(&d->buf->wait_poll, &wait);
				goto out_unlocked;
			}

			if (!d->attached) {
				ret = -ENODEV;
				goto out_locked;
			}
		} else {
			lirc_buffer_read(d->buf, buf);
			ret = copy_to_user((void __user *)buffer+written, buf,
					   d->buf->chunk_size);
			if (!ret)
				written += d->buf->chunk_size;
			else
				ret = -EFAULT;
		}
	}

	remove_wait_queue(&d->buf->wait_poll, &wait);

out_locked:
	mutex_unlock(&d->mutex);

out_unlocked:
	kfree(buf);

	return ret ? ret : written;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
280
68.80%
3
23.08%
David Härdeman
83
20.39%
4
30.77%
Dan Carpenter
33
8.11%
2
15.38%
Sean Young
9
2.21%
2
15.38%
Hans Verkuil
1
0.25%
1
7.69%
Andi Shyti
1
0.25%
1
7.69%
Total
407
100.00%
13
100.00%


EXPORT_SYMBOL(lirc_dev_fop_read);



void lirc_init_pdata(struct inode *inode, struct file *file)
{
	struct lirc_dev *d = container_of(inode->i_cdev, struct lirc_dev, cdev);

	file->private_data = d;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Härdeman
38
100.00%
2
100.00%
Total
38
100.00%
2
100.00%


EXPORT_SYMBOL(lirc_init_pdata);



void *lirc_get_pdata(struct file *file)
{
	struct lirc_dev *d = file->private_data;

	return d->data;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
15
60.00%
1
33.33%
David Härdeman
10
40.00%
2
66.67%
Total
25
100.00%
3
100.00%


EXPORT_SYMBOL(lirc_get_pdata);




static int __init lirc_dev_init(void)
{
	int retval;

	lirc_class = class_create(THIS_MODULE, "lirc");
	if (IS_ERR(lirc_class)) {
		pr_err("class_create failed\n");
		return PTR_ERR(lirc_class);
	}

	retval = alloc_chrdev_region(&lirc_base_dev, 0, LIRC_MAX_DEVICES,
				     "BaseRemoteCtl");
	if (retval) {
		class_destroy(lirc_class);
		pr_err("alloc_chrdev_region failed\n");
		return retval;
	}

	pr_info("IR Remote Control driver registered, major %d\n",
						MAJOR(lirc_base_dev));

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
69
79.31%
1
20.00%
Andi Shyti
16
18.39%
2
40.00%
David Härdeman
2
2.30%
2
40.00%
Total
87
100.00%
5
100.00%



static void __exit lirc_dev_exit(void)
{
	class_destroy(lirc_class);
	unregister_chrdev_region(lirc_base_dev, LIRC_MAX_DEVICES);
	pr_info("module unloaded\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
23
88.46%
1
33.33%
Andi Shyti
2
7.69%
1
33.33%
David Härdeman
1
3.85%
1
33.33%
Total
26
100.00%
3
100.00%


module_init(lirc_dev_init);

module_exit(lirc_dev_exit);

MODULE_DESCRIPTION("LIRC base driver module");
MODULE_AUTHOR("Artur Lipowski");
MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarod Wilson
1095
50.95%
5
10.87%
David Härdeman
781
36.34%
16
34.78%
Andi Shyti
125
5.82%
8
17.39%
Sean Young
64
2.98%
8
17.39%
Dan Carpenter
33
1.54%
2
4.35%
Srinivas Kandagatla
28
1.30%
1
2.17%
Arnd Bergmann
9
0.42%
2
4.35%
Andy Shevchenko
7
0.33%
1
2.17%
Hans Verkuil
5
0.23%
1
2.17%
Ingo Molnar
1
0.05%
1
2.17%
Sakari Ailus
1
0.05%
1
2.17%
Total
2149
100.00%
46
100.00%
Directory: drivers/media/rc

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.