media: lirc: use kfifo rather than lirc_buffer for raw IR (71695aff) · Commits · e / devices / android_kernel_teracube_emerald

drivers/media/rc/ir-lirc-codec.c

+67 −14

Original line number	Diff line number	Diff line
		@@ -66,8 +66,6 @@ void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
		} else {

		if (dev->gap) {
		int gap_sample;

		dev->gap_duration += ktime_to_ns(ktime_sub(ktime_get(),
		dev->gap_start));

		@@ -76,9 +74,7 @@ void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
		dev->gap_duration = min_t(u64, dev->gap_duration,
		LIRC_VALUE_MASK);

		gap_sample = LIRC_SPACE(dev->gap_duration);
		lirc_buffer_write(dev->lirc_dev->buf,
		(unsigned char *)&gap_sample);
		kfifo_put(&dev->rawir, LIRC_SPACE(dev->gap_duration));
		dev->gap = false;
		}

		@@ -88,10 +84,8 @@ void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
		TO_US(ev.duration), TO_STR(ev.pulse));
		}

		lirc_buffer_write(dev->lirc_dev->buf,
		(unsigned char *) &sample);

		wake_up(&dev->lirc_dev->buf->wait_poll);
		kfifo_put(&dev->rawir, sample);
		wake_up_poll(&dev->wait_poll, POLLIN \| POLLRDNORM);
		}

		static ssize_t ir_lirc_transmit_ir(struct file file, const char __user buf,
		@@ -408,6 +402,68 @@ static long ir_lirc_ioctl(struct file *filep, unsigned int cmd,
		return ret;
		}

		static unsigned int ir_lirc_poll(struct file *file,
		struct poll_table_struct *wait)
		{
		struct rc_dev *rcdev = file->private_data;
		struct lirc_dev *d = rcdev->lirc_dev;
		unsigned int events = 0;

		poll_wait(file, &rcdev->wait_poll, wait);

		if (!d->attached)
		events = POLLHUP \| POLLERR;
		else if (rcdev->driver_type == RC_DRIVER_IR_RAW &&
		!kfifo_is_empty(&rcdev->rawir))
		events = POLLIN \| POLLRDNORM;

		return events;
		}

		static ssize_t ir_lirc_read(struct file file, char __user buffer,
		size_t length, loff_t *ppos)
		{
		struct rc_dev *rcdev = file->private_data;
		struct lirc_dev *d = rcdev->lirc_dev;
		unsigned int copied;
		int ret;

		if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX)
		return -EINVAL;

		if (length < sizeof(unsigned int) \|\| length % sizeof(unsigned int))
		return -EINVAL;

		if (!d->attached)
		return -ENODEV;

		do {
		if (kfifo_is_empty(&rcdev->rawir)) {
		if (file->f_flags & O_NONBLOCK)
		return -EAGAIN;

		ret = wait_event_interruptible(rcdev->wait_poll,
		!kfifo_is_empty(&rcdev->rawir) \|\|
		!d->attached);
		if (ret)
		return ret;
		}

		if (!d->attached)
		return -ENODEV;

		ret = mutex_lock_interruptible(&rcdev->lock);
		if (ret)
		return ret;
		ret = kfifo_to_user(&rcdev->rawir, buffer, length, &copied);
		mutex_unlock(&rcdev->lock);
		if (ret)
		return ret;
		} while (copied == 0);

		return copied;
		}

		static const struct file_operations lirc_fops = {
		.owner = THIS_MODULE,
		.write = ir_lirc_transmit_ir,
		@@ -415,8 +471,8 @@ static const struct file_operations lirc_fops = {
		#ifdef CONFIG_COMPAT
		.compat_ioctl = ir_lirc_ioctl,
		#endif
		.read = lirc_dev_fop_read,
		.poll = lirc_dev_fop_poll,
		.read = ir_lirc_read,
		.poll = ir_lirc_poll,
		.open = lirc_dev_fop_open,
		.release = lirc_dev_fop_close,
		.llseek = no_llseek,
		@@ -433,9 +489,6 @@ int ir_lirc_register(struct rc_dev *dev)

		snprintf(ldev->name, sizeof(ldev->name), "ir-lirc-codec (%s)",
		dev->driver_name);
		ldev->buf = NULL;
		ldev->chunk_size = sizeof(int);
		ldev->buffer_size = LIRCBUF_SIZE;
		ldev->fops = &lirc_fops;
		ldev->dev.parent = &dev->dev;
		ldev->rdev = dev;

drivers/media/rc/lirc_dev.c

+16 −183

Original line number	Diff line number	Diff line
		@@ -44,40 +44,14 @@ static struct class *lirc_class;
		static void lirc_release_device(struct device *ld)
		{
		struct lirc_dev *d = container_of(ld, struct lirc_dev, dev);
		struct rc_dev *rcdev = d->rdev;

		put_device(d->dev.parent);
		if (rcdev->driver_type == RC_DRIVER_IR_RAW)
		kfifo_free(&rcdev->rawir);

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

		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;
		put_device(d->dev.parent);
		}

		struct lirc_dev *
		@@ -128,31 +102,16 @@ int lirc_register_device(struct lirc_dev *d)
		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->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 (rcdev->driver_type == RC_DRIVER_IR_RAW) {
		err = lirc_allocate_buffer(d);
		if (err)
		return err;
		if (kfifo_alloc(&rcdev->rawir, MAX_IR_EVENT_SIZE, GFP_KERNEL))
		return -ENOMEM;
		}

		init_waitqueue_head(&rcdev->wait_poll);

		minor = ida_simple_get(&lirc_ida, 0, LIRC_MAX_DEVICES, GFP_KERNEL);
		if (minor < 0)
		return minor;
		@@ -182,9 +141,13 @@ EXPORT_SYMBOL(lirc_register_device);

		void lirc_unregister_device(struct lirc_dev *d)
		{
		struct rc_dev *rcdev;

		if (!d)
		return;

		rcdev = d->rdev;

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

		@@ -194,7 +157,7 @@ void lirc_unregister_device(struct lirc_dev *d)
		if (d->open) {
		dev_dbg(&d->dev, LOGHEAD "releasing opened driver\n",
		d->name, d->minor);
		wake_up_interruptible(&d->buf->wait_poll);
		wake_up_poll(&rcdev->wait_poll, POLLHUP);
		}

		mutex_unlock(&d->mutex);
		@@ -208,6 +171,7 @@ 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);
		struct rc_dev *rcdev = d->rdev;
		int retval;

		dev_dbg(&d->dev, LOGHEAD "open called\n", d->name, d->minor);
		@@ -232,8 +196,8 @@ int lirc_dev_fop_open(struct inode inode, struct file file)
		goto out;
		}

		if (d->buf)
		lirc_buffer_clear(d->buf);
		if (rcdev->driver_type == RC_DRIVER_IR_RAW)
		kfifo_reset_out(&rcdev->rawir);

		d->open++;

		@@ -265,137 +229,6 @@ int lirc_dev_fop_close(struct inode inode, struct file file)
		}
		EXPORT_SYMBOL(lirc_dev_fop_close);

		unsigned int lirc_dev_fop_poll(struct file file, poll_table wait)
		{
		struct rc_dev *rcdev = file->private_data;
		struct lirc_dev *d = rcdev->lirc_dev;
		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;
		}
		EXPORT_SYMBOL(lirc_dev_fop_poll);

		ssize_t lirc_dev_fop_read(struct file *file,
		char __user *buffer,
		size_t length,
		loff_t *ppos)
		{
		struct rc_dev *rcdev = file->private_data;
		struct lirc_dev *d = rcdev->lirc_dev;
		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 (rcdev->driver_type != RC_DRIVER_IR_RAW) {
		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;
		}
		EXPORT_SYMBOL(lirc_dev_fop_read);

		int __init lirc_dev_init(void)
		{
		int retval;

include/media/lirc_dev.h

+0 −109

Original line number	Diff line number	Diff line
		@@ -18,112 +18,11 @@
		#include <linux/device.h>
		#include <linux/cdev.h>

		struct lirc_buffer {
		wait_queue_head_t wait_poll;
		spinlock_t fifo_lock;
		unsigned int chunk_size;
		unsigned int size; /* in chunks */
		/* Using chunks instead of bytes pretends to simplify boundary checking
		* And should allow for some performance fine tunning later */
		struct kfifo fifo;
		};

		static inline void lirc_buffer_clear(struct lirc_buffer *buf)
		{
		unsigned long flags;

		if (kfifo_initialized(&buf->fifo)) {
		spin_lock_irqsave(&buf->fifo_lock, flags);
		kfifo_reset(&buf->fifo);
		spin_unlock_irqrestore(&buf->fifo_lock, flags);
		} else
		WARN(1, "calling %s on an uninitialized lirc_buffer\n",
		__func__);
		}

		static inline int lirc_buffer_init(struct lirc_buffer *buf,
		unsigned int chunk_size,
		unsigned int size)
		{
		int ret;

		init_waitqueue_head(&buf->wait_poll);
		spin_lock_init(&buf->fifo_lock);
		buf->chunk_size = chunk_size;
		buf->size = size;
		ret = kfifo_alloc(&buf->fifo, size * chunk_size, GFP_KERNEL);

		return ret;
		}

		static inline void lirc_buffer_free(struct lirc_buffer *buf)
		{
		if (kfifo_initialized(&buf->fifo)) {
		kfifo_free(&buf->fifo);
		} else
		WARN(1, "calling %s on an uninitialized lirc_buffer\n",
		__func__);
		}

		static inline int lirc_buffer_len(struct lirc_buffer *buf)
		{
		int len;
		unsigned long flags;

		spin_lock_irqsave(&buf->fifo_lock, flags);
		len = kfifo_len(&buf->fifo);
		spin_unlock_irqrestore(&buf->fifo_lock, flags);

		return len;
		}

		static inline int lirc_buffer_full(struct lirc_buffer *buf)
		{
		return lirc_buffer_len(buf) == buf->size * buf->chunk_size;
		}

		static inline int lirc_buffer_empty(struct lirc_buffer *buf)
		{
		return !lirc_buffer_len(buf);
		}

		static inline unsigned int lirc_buffer_read(struct lirc_buffer *buf,
		unsigned char *dest)
		{
		unsigned int ret = 0;

		if (lirc_buffer_len(buf) >= buf->chunk_size)
		ret = kfifo_out_locked(&buf->fifo, dest, buf->chunk_size,
		&buf->fifo_lock);
		return ret;

		}

		static inline unsigned int lirc_buffer_write(struct lirc_buffer *buf,
		unsigned char *orig)
		{
		unsigned int ret;

		ret = kfifo_in_locked(&buf->fifo, orig, buf->chunk_size,
		&buf->fifo_lock);

		return ret;
		}

		/**
		* struct lirc_dev - represents a LIRC device
		*
		* @name: used for logging
		* @minor: the minor device (/dev/lircX) number for the device
		* @buffer_size: Number of FIFO buffers with @chunk_size size.
		* Only used if @rbuf is NULL.
		* @chunk_size: Size of each FIFO buffer.
		* Only used if @rbuf is NULL.
		* @buf: if %NULL, lirc_dev will allocate and manage the buffer,
		* otherwise allocated by the caller which will
		* have to write to the buffer by other means, like irq's
		* (see also lirc_serial.c).
		* @buf_internal: whether lirc_dev has allocated the read buffer or not
		* @rdev: &struct rc_dev associated with the device
		* @fops: &struct file_operations for the device
		* @owner: the module owning this struct
		@@ -137,11 +36,6 @@ struct lirc_dev {
		char name[40];
		unsigned int minor;

		unsigned int buffer_size; /* in chunks holding one code each */
		unsigned int chunk_size;
		struct lirc_buffer *buf;
		bool buf_internal;

		struct rc_dev *rdev;
		const struct file_operations *fops;
		struct module *owner;
		@@ -168,7 +62,4 @@ void lirc_unregister_device(struct lirc_dev *d);
		*/
		int lirc_dev_fop_open(struct inode inode, struct file file);
		int lirc_dev_fop_close(struct inode inode, struct file file);
		unsigned int lirc_dev_fop_poll(struct file file, poll_table wait);
		ssize_t lirc_dev_fop_read(struct file file, char __user buffer, size_t length,
		loff_t *ppos);
		#endif

include/media/rc-core.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -123,6 +123,8 @@ enum rc_filter_type {
		* @gap_duration: duration of initial gap
		* @gap: true if we're in a gap
		* @send_timeout_reports: report timeouts in lirc raw IR.
		* @rawir: queue for incoming raw IR
		* @wait_poll: poll struct for lirc device
		* @send_mode: lirc mode for sending, either LIRC_MODE_SCANCODE or
		* LIRC_MODE_PULSE
		* @change_protocol: allow changing the protocol used on hardware decoders
		@@ -191,6 +193,8 @@ struct rc_dev {
		u64 gap_duration;
		bool gap;
		bool send_timeout_reports;
		DECLARE_KFIFO_PTR(rawir, unsigned int);
		wait_queue_head_t wait_poll;
		u8 send_mode;
		#endif
		int (change_protocol)(struct rc_dev dev, u64 *rc_proto);