V4L/DVB: IR: add lirc device interface (4a62a5ab) · Commits · e / devices / android_kernel_sony_msm8998

drivers/media/IR/Kconfig

+11 −0

Original line number	Diff line number	Diff line
		@@ -8,6 +8,17 @@ config VIDEO_IR
		depends on IR_CORE
		default IR_CORE

		config LIRC
		tristate
		default y

		---help---
		Enable this option to build the Linux Infrared Remote
		Control (LIRC) core device interface driver. The LIRC
		interface passes raw IR to and from userspace, where the
		LIRC daemon handles protocol decoding for IR reception ann
		encoding for IR transmitting (aka "blasting").

		source "drivers/media/IR/keymaps/Kconfig"

		config IR_NEC_DECODER

drivers/media/IR/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -5,6 +5,7 @@ obj-y += keymaps/

		obj-$(CONFIG_IR_CORE) += ir-core.o
		obj-$(CONFIG_VIDEO_IR) += ir-common.o
		obj-$(CONFIG_LIRC) += lirc_dev.o
		obj-$(CONFIG_IR_NEC_DECODER) += ir-nec-decoder.o
		obj-$(CONFIG_IR_RC5_DECODER) += ir-rc5-decoder.o
		obj-$(CONFIG_IR_RC6_DECODER) += ir-rc6-decoder.o

drivers/media/IR/lirc_dev.c

0 → 100644

+761 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*
		* You should have received a copy of the GNU General Public License
		* along with this program; if not, write to the Free Software
		* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		*
		*/

		#include <linux/module.h>
		#include <linux/kernel.h>
		#include <linux/sched.h>
		#include <linux/errno.h>
		#include <linux/ioctl.h>
		#include <linux/fs.h>
		#include <linux/poll.h>
		#include <linux/completion.h>
		#include <linux/errno.h>
		#include <linux/mutex.h>
		#include <linux/wait.h>
		#include <linux/unistd.h>
		#include <linux/kthread.h>
		#include <linux/bitops.h>
		#include <linux/device.h>
		#include <linux/cdev.h>

		#include <media/lirc.h>
		#include "lirc_dev.h"

		static int debug;

		#define IRCTL_DEV_NAME "BaseRemoteCtl"
		#define NOPLUG -1
		#define LOGHEAD "lirc_dev (%s[%d]): "

		static dev_t lirc_base_dev;

		struct irctl {
		struct lirc_driver d;
		int attached;
		int open;

		struct mutex irctl_lock;
		struct lirc_buffer *buf;
		unsigned int chunk_size;

		struct task_struct *task;
		long jiffies_to_wait;

		struct cdev cdev;
		};

		static DEFINE_MUTEX(lirc_dev_lock);

		static struct irctl *irctls[MAX_IRCTL_DEVICES];

		/* Only used for sysfs but defined to void otherwise */
		static struct class *lirc_class;

		/* helper function
		* initializes the irctl structure
		*/
		static void init_irctl(struct irctl *ir)
		{
		dev_dbg(ir->d.dev, LOGHEAD "initializing irctl\n",
		ir->d.name, ir->d.minor);
		mutex_init(&ir->irctl_lock);
		ir->d.minor = NOPLUG;
		}

		static void cleanup(struct irctl *ir)
		{
		dev_dbg(ir->d.dev, LOGHEAD "cleaning up\n", ir->d.name, ir->d.minor);

		device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));

		if (ir->buf != ir->d.rbuf) {
		lirc_buffer_free(ir->buf);
		kfree(ir->buf);
		}
		ir->buf = NULL;
		}

		/* helper function
		* reads key codes from driver and puts them into buffer
		* returns 0 on success
		*/
		static int add_to_buf(struct irctl *ir)
		{
		if (ir->d.add_to_buf) {
		int res = -ENODATA;
		int got_data = 0;

		/*
		* service the device as long as it is returning
		* data and we have space
		*/
		get_data:
		res = ir->d.add_to_buf(ir->d.data, ir->buf);
		if (res == 0) {
		got_data++;
		goto get_data;
		}

		if (res == -ENODEV)
		kthread_stop(ir->task);

		return got_data ? 0 : res;
		}

		return 0;
		}

		/* main function of the polling thread
		*/
		static int lirc_thread(void *irctl)
		{
		struct irctl *ir = irctl;

		dev_dbg(ir->d.dev, LOGHEAD "poll thread started\n",
		ir->d.name, ir->d.minor);

		do {
		if (ir->open) {
		if (ir->jiffies_to_wait) {
		set_current_state(TASK_INTERRUPTIBLE);
		schedule_timeout(ir->jiffies_to_wait);
		}
		if (kthread_should_stop())
		break;
		if (!add_to_buf(ir))
		wake_up_interruptible(&ir->buf->wait_poll);
		} else {
		set_current_state(TASK_INTERRUPTIBLE);
		schedule();
		}
		} while (!kthread_should_stop());

		dev_dbg(ir->d.dev, LOGHEAD "poll thread ended\n",
		ir->d.name, ir->d.minor);

		return 0;
		}


		static struct file_operations fops = {
		.owner = THIS_MODULE,
		.read = lirc_dev_fop_read,
		.write = lirc_dev_fop_write,
		.poll = lirc_dev_fop_poll,
		.ioctl = lirc_dev_fop_ioctl,
		.open = lirc_dev_fop_open,
		.release = lirc_dev_fop_close,
		};

		static int lirc_cdev_add(struct irctl *ir)
		{
		int retval;
		struct lirc_driver *d = &ir->d;

		if (d->fops) {
		cdev_init(&ir->cdev, d->fops);
		ir->cdev.owner = d->owner;
		} else {
		cdev_init(&ir->cdev, &fops);
		ir->cdev.owner = THIS_MODULE;
		}
		kobject_set_name(&ir->cdev.kobj, "lirc%d", d->minor);

		retval = cdev_add(&ir->cdev, MKDEV(MAJOR(lirc_base_dev), d->minor), 1);
		if (retval)
		kobject_put(&ir->cdev.kobj);

		return retval;
		}

		int lirc_register_driver(struct lirc_driver *d)
		{
		struct irctl *ir;
		int minor;
		int bytes_in_key;
		unsigned int chunk_size;
		unsigned int buffer_size;
		int err;

		if (!d) {
		printk(KERN_ERR "lirc_dev: lirc_register_driver: "
		"driver pointer must be not NULL!\n");
		err = -EBADRQC;
		goto out;
		}

		if (MAX_IRCTL_DEVICES <= d->minor) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"\"minor\" must be between 0 and %d (%d)!\n",
		MAX_IRCTL_DEVICES-1, d->minor);
		err = -EBADRQC;
		goto out;
		}

		if (1 > d->code_length \|\| (BUFLEN * 8) < d->code_length) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"code length in bits for minor (%d) "
		"must be less than %d!\n",
		d->minor, BUFLEN * 8);
		err = -EBADRQC;
		goto out;
		}

		dev_dbg(d->dev, "lirc_dev: lirc_register_driver: sample_rate: %d\n",
		d->sample_rate);
		if (d->sample_rate) {
		if (2 > d->sample_rate \|\| HZ < d->sample_rate) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"sample_rate must be between 2 and %d!\n", HZ);
		err = -EBADRQC;
		goto out;
		}
		if (!d->add_to_buf) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"add_to_buf cannot be NULL when "
		"sample_rate is set\n");
		err = -EBADRQC;
		goto out;
		}
		} else if (!(d->fops && d->fops->read) && !d->rbuf) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"fops->read and rbuf cannot all be NULL!\n");
		err = -EBADRQC;
		goto out;
		} else if (!d->rbuf) {
		if (!(d->fops && d->fops->read && d->fops->poll &&
		d->fops->ioctl)) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"neither read, poll nor ioctl can be NULL!\n");
		err = -EBADRQC;
		goto out;
		}
		}

		mutex_lock(&lirc_dev_lock);

		minor = d->minor;

		if (minor < 0) {
		/* find first free slot for driver */
		for (minor = 0; minor < MAX_IRCTL_DEVICES; minor++)
		if (!irctls[minor])
		break;
		if (MAX_IRCTL_DEVICES == minor) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"no free slots for drivers!\n");
		err = -ENOMEM;
		goto out_lock;
		}
		} else if (irctls[minor]) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"minor (%d) just registered!\n", minor);
		err = -EBUSY;
		goto out_lock;
		}

		ir = kzalloc(sizeof(struct irctl), GFP_KERNEL);
		if (!ir) {
		err = -ENOMEM;
		goto out_lock;
		}
		init_irctl(ir);
		irctls[minor] = ir;
		d->minor = minor;

		if (d->sample_rate) {
		ir->jiffies_to_wait = HZ / d->sample_rate;
		} else {
		/* it means - wait for external event in task queue */
		ir->jiffies_to_wait = 0;
		}

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

		bytes_in_key = BITS_TO_LONGS(d->code_length) +
		(d->code_length % 8 ? 1 : 0);
		buffer_size = d->buffer_size ? d->buffer_size : BUFLEN / bytes_in_key;
		chunk_size = d->chunk_size ? d->chunk_size : bytes_in_key;

		if (d->rbuf) {
		ir->buf = d->rbuf;
		} else {
		ir->buf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
		if (!ir->buf) {
		err = -ENOMEM;
		goto out_lock;
		}
		err = lirc_buffer_init(ir->buf, chunk_size, buffer_size);
		if (err) {
		kfree(ir->buf);
		goto out_lock;
		}
		}
		ir->chunk_size = ir->buf->chunk_size;

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

		ir->d = *d;
		ir->d.minor = minor;

		device_create(lirc_class, ir->d.dev,
		MKDEV(MAJOR(lirc_base_dev), ir->d.minor), NULL,
		"lirc%u", ir->d.minor);

		if (d->sample_rate) {
		/* try to fire up polling thread */
		ir->task = kthread_run(lirc_thread, (void *)ir, "lirc_dev");
		if (IS_ERR(ir->task)) {
		dev_err(d->dev, "lirc_dev: lirc_register_driver: "
		"cannot run poll thread for minor = %d\n",
		d->minor);
		err = -ECHILD;
		goto out_sysfs;
		}
		}

		err = lirc_cdev_add(ir);
		if (err)
		goto out_sysfs;

		ir->attached = 1;
		mutex_unlock(&lirc_dev_lock);

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

		out_sysfs:
		device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
		out_lock:
		mutex_unlock(&lirc_dev_lock);
		out:
		return err;
		}
		EXPORT_SYMBOL(lirc_register_driver);

		int lirc_unregister_driver(int minor)
		{
		struct irctl *ir;

		if (minor < 0 \|\| minor >= MAX_IRCTL_DEVICES) {
		printk(KERN_ERR "lirc_dev: lirc_unregister_driver: "
		"\"minor (%d)\" must be between 0 and %d!\n",
		minor, MAX_IRCTL_DEVICES-1);
		return -EBADRQC;
		}

		ir = irctls[minor];

		mutex_lock(&lirc_dev_lock);

		if (ir->d.minor != minor) {
		printk(KERN_ERR "lirc_dev: lirc_unregister_driver: "
		"minor (%d) device not registered!", minor);
		mutex_unlock(&lirc_dev_lock);
		return -ENOENT;
		}

		/* end up polling thread */
		if (ir->task)
		kthread_stop(ir->task);

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

		ir->attached = 0;
		if (ir->open) {
		dev_dbg(ir->d.dev, LOGHEAD "releasing opened driver\n",
		ir->d.name, ir->d.minor);
		wake_up_interruptible(&ir->buf->wait_poll);
		mutex_lock(&ir->irctl_lock);
		ir->d.set_use_dec(ir->d.data);
		module_put(ir->d.owner);
		mutex_unlock(&ir->irctl_lock);
		cdev_del(&ir->cdev);
		} else {
		cleanup(ir);
		cdev_del(&ir->cdev);
		kfree(ir);
		irctls[minor] = NULL;
		}

		mutex_unlock(&lirc_dev_lock);

		return 0;
		}
		EXPORT_SYMBOL(lirc_unregister_driver);

		int lirc_dev_fop_open(struct inode inode, struct file file)
		{
		struct irctl *ir;
		int retval = 0;

		if (iminor(inode) >= MAX_IRCTL_DEVICES) {
		printk(KERN_WARNING "lirc_dev [%d]: open result = -ENODEV\n",
		iminor(inode));
		return -ENODEV;
		}

		if (mutex_lock_interruptible(&lirc_dev_lock))
		return -ERESTARTSYS;

		ir = irctls[iminor(inode)];
		if (!ir) {
		retval = -ENODEV;
		goto error;
		}

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

		if (ir->d.minor == NOPLUG) {
		retval = -ENODEV;
		goto error;
		}

		if (ir->open) {
		retval = -EBUSY;
		goto error;
		}

		if (try_module_get(ir->d.owner)) {
		++ir->open;
		retval = ir->d.set_use_inc(ir->d.data);

		if (retval) {
		module_put(ir->d.owner);
		--ir->open;
		} else {
		lirc_buffer_clear(ir->buf);
		}
		if (ir->task)
		wake_up_process(ir->task);
		}

		error:
		if (ir)
		dev_dbg(ir->d.dev, LOGHEAD "open result = %d\n",
		ir->d.name, ir->d.minor, retval);

		mutex_unlock(&lirc_dev_lock);

		return retval;
		}
		EXPORT_SYMBOL(lirc_dev_fop_open);

		int lirc_dev_fop_close(struct inode inode, struct file file)
		{
		struct irctl *ir = irctls[iminor(inode)];

		dev_dbg(ir->d.dev, LOGHEAD "close called\n", ir->d.name, ir->d.minor);

		WARN_ON(mutex_lock_killable(&lirc_dev_lock));

		--ir->open;
		if (ir->attached) {
		ir->d.set_use_dec(ir->d.data);
		module_put(ir->d.owner);
		} else {
		cleanup(ir);
		irctls[ir->d.minor] = NULL;
		kfree(ir);
		}

		mutex_unlock(&lirc_dev_lock);

		return 0;
		}
		EXPORT_SYMBOL(lirc_dev_fop_close);

		unsigned int lirc_dev_fop_poll(struct file file, poll_table wait)
		{
		struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];
		unsigned int ret;

		dev_dbg(ir->d.dev, LOGHEAD "poll called\n", ir->d.name, ir->d.minor);

		if (!ir->attached) {
		mutex_unlock(&ir->irctl_lock);
		return POLLERR;
		}

		poll_wait(file, &ir->buf->wait_poll, wait);

		if (ir->buf)
		if (lirc_buffer_empty(ir->buf))
		ret = 0;
		else
		ret = POLLIN \| POLLRDNORM;
		else
		ret = POLLERR;

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

		return ret;
		}
		EXPORT_SYMBOL(lirc_dev_fop_poll);

		int lirc_dev_fop_ioctl(struct inode inode, struct file file,
		unsigned int cmd, unsigned long arg)
		{
		unsigned long mode;
		int result = 0;
		struct irctl *ir = irctls[iminor(inode)];

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

		if (ir->d.minor == NOPLUG \|\| !ir->attached) {
		dev_dbg(ir->d.dev, LOGHEAD "ioctl result = -ENODEV\n",
		ir->d.name, ir->d.minor);
		return -ENODEV;
		}

		mutex_lock(&ir->irctl_lock);

		switch (cmd) {
		case LIRC_GET_FEATURES:
		result = put_user(ir->d.features, (unsigned long *)arg);
		break;
		case LIRC_GET_REC_MODE:
		if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
		result = -ENOSYS;
		break;
		}

		result = put_user(LIRC_REC2MODE
		(ir->d.features & LIRC_CAN_REC_MASK),
		(unsigned long *)arg);
		break;
		case LIRC_SET_REC_MODE:
		if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
		result = -ENOSYS;
		break;
		}

		result = get_user(mode, (unsigned long *)arg);
		if (!result && !(LIRC_MODE2REC(mode) & ir->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(ir->d.code_length, (unsigned long *)arg);
		break;
		case LIRC_GET_MIN_TIMEOUT:
		if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) \|\|
		ir->d.min_timeout == 0) {
		result = -ENOSYS;
		break;
		}

		result = put_user(ir->d.min_timeout, (unsigned long *)arg);
		break;
		case LIRC_GET_MAX_TIMEOUT:
		if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) \|\|
		ir->d.max_timeout == 0) {
		result = -ENOSYS;
		break;
		}

		result = put_user(ir->d.max_timeout, (unsigned long *)arg);
		break;
		default:
		result = -EINVAL;
		}

		dev_dbg(ir->d.dev, LOGHEAD "ioctl result = %d\n",
		ir->d.name, ir->d.minor, result);

		mutex_unlock(&ir->irctl_lock);

		return result;
		}
		EXPORT_SYMBOL(lirc_dev_fop_ioctl);

		ssize_t lirc_dev_fop_read(struct file *file,
		char *buffer,
		size_t length,
		loff_t *ppos)
		{
		struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];
		unsigned char buf[ir->chunk_size];
		int ret = 0, written = 0;
		DECLARE_WAITQUEUE(wait, current);

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

		if (mutex_lock_interruptible(&ir->irctl_lock))
		return -ERESTARTSYS;
		if (!ir->attached) {
		mutex_unlock(&ir->irctl_lock);
		return -ENODEV;
		}

		if (length % ir->chunk_size) {
		dev_dbg(ir->d.dev, LOGHEAD "read result = -EINVAL\n",
		ir->d.name, ir->d.minor);
		mutex_unlock(&ir->irctl_lock);
		return -EINVAL;
		}

		/*
		* 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(&ir->buf->wait_poll, &wait);
		set_current_state(TASK_INTERRUPTIBLE);

		/*
		* 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(ir->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(&ir->irctl_lock);
		schedule();
		set_current_state(TASK_INTERRUPTIBLE);

		if (mutex_lock_interruptible(&ir->irctl_lock)) {
		ret = -ERESTARTSYS;
		break;
		}

		if (!ir->attached) {
		ret = -ENODEV;
		break;
		}
		} else {
		lirc_buffer_read(ir->buf, buf);
		ret = copy_to_user((void *)buffer+written, buf,
		ir->buf->chunk_size);
		written += ir->buf->chunk_size;
		}
		}

		remove_wait_queue(&ir->buf->wait_poll, &wait);
		set_current_state(TASK_RUNNING);
		mutex_unlock(&ir->irctl_lock);

		dev_dbg(ir->d.dev, LOGHEAD "read result = %s (%d)\n",
		ir->d.name, ir->d.minor, ret ? "-EFAULT" : "OK", ret);

		return ret ? ret : written;
		}
		EXPORT_SYMBOL(lirc_dev_fop_read);

		void lirc_get_pdata(struct file file)
		{
		void *data = NULL;

		if (file && file->f_dentry && file->f_dentry->d_inode &&
		file->f_dentry->d_inode->i_rdev) {
		struct irctl *ir;
		ir = irctls[iminor(file->f_dentry->d_inode)];
		data = ir->d.data;
		}

		return data;
		}
		EXPORT_SYMBOL(lirc_get_pdata);


		ssize_t lirc_dev_fop_write(struct file file, const char buffer,
		size_t length, loff_t *ppos)
		{
		struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];

		dev_dbg(ir->d.dev, LOGHEAD "write called\n", ir->d.name, ir->d.minor);

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

		return -EINVAL;
		}
		EXPORT_SYMBOL(lirc_dev_fop_write);


		static int __init lirc_dev_init(void)
		{
		int retval;

		lirc_class = class_create(THIS_MODULE, "lirc");
		if (IS_ERR(lirc_class)) {
		retval = PTR_ERR(lirc_class);
		printk(KERN_ERR "lirc_dev: class_create failed\n");
		goto error;
		}

		retval = alloc_chrdev_region(&lirc_base_dev, 0, MAX_IRCTL_DEVICES,
		IRCTL_DEV_NAME);
		if (retval) {
		class_destroy(lirc_class);
		printk(KERN_ERR "lirc_dev: alloc_chrdev_region failed\n");
		goto error;
		}


		printk(KERN_INFO "lirc_dev: IR Remote Control driver registered, "
		"major %d \n", MAJOR(lirc_base_dev));

		error:
		return retval;
		}



		static void __exit lirc_dev_exit(void)
		{
		class_destroy(lirc_class);
		unregister_chrdev_region(lirc_base_dev, MAX_IRCTL_DEVICES);
		printk(KERN_INFO "lirc_dev: module unloaded\n");
		}

		module_init(lirc_dev_init);
		module_exit(lirc_dev_exit);

		MODULE_DESCRIPTION("LIRC base driver module");
		MODULE_AUTHOR("Artur Lipowski");
		MODULE_LICENSE("GPL");

		module_param(debug, bool, S_IRUGO \| S_IWUSR);
		MODULE_PARM_DESC(debug, "Enable debugging messages");

drivers/media/IR/lirc_dev.h

0 → 100644

+226 −0

Original line number	Diff line number	Diff line
		/*
		* LIRC base driver
		*
		* by Artur Lipowski <alipowski@interia.pl>
		* This code is licensed under GNU GPL
		*
		*/

		#ifndef _LINUX_LIRC_DEV_H
		#define _LINUX_LIRC_DEV_H

		#define MAX_IRCTL_DEVICES 4
		#define BUFLEN 16

		#define mod(n, div) ((n) % (div))

		#include <linux/slab.h>
		#include <linux/fs.h>
		#include <linux/ioctl.h>
		#include <linux/poll.h>
		#include <linux/kfifo.h>
		#include <media/lirc.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;
		u8 fifo_initialized;
		};

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

		if (buf->fifo_initialized) {
		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);
		if (ret == 0)
		buf->fifo_initialized = 1;

		return ret;
		}

		static inline void lirc_buffer_free(struct lirc_buffer *buf)
		{
		if (buf->fifo_initialized) {
		kfifo_free(&buf->fifo);
		buf->fifo_initialized = 0;
		} 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 int lirc_buffer_available(struct lirc_buffer *buf)
		{
		return buf->size - (lirc_buffer_len(buf) / buf->chunk_size);
		}

		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_driver {
		char name[40];
		int minor;
		unsigned long code_length;
		unsigned int buffer_size; /* in chunks holding one code each */
		int sample_rate;
		unsigned long features;

		unsigned int chunk_size;

		void *data;
		int min_timeout;
		int max_timeout;
		int (add_to_buf) (void data, struct lirc_buffer *buf);
		struct lirc_buffer *rbuf;
		int (set_use_inc) (void data);
		void (set_use_dec) (void data);
		struct file_operations *fops;
		struct device *dev;
		struct module *owner;
		};

		/* name:
		* this string will be used for logs
		*
		* minor:
		* indicates minor device (/dev/lirc) number for registered driver
		* if caller fills it with negative value, then the first free minor
		* number will be used (if available)
		*
		* code_length:
		* length of the remote control key code expressed in bits
		*
		* sample_rate:
		*
		* data:
		* it may point to any driver data and this pointer will be passed to
		* all callback functions
		*
		* add_to_buf:
		* add_to_buf will be called after specified period of the time or
		* triggered by the external event, this behavior depends on value of
		* the sample_rate this function will be called in user context. This
		* routine should return 0 if data was added to the buffer and
		* -ENODATA if none was available. This should add some number of bits
		* evenly divisible by code_length to the buffer
		*
		* rbuf:
		* if not NULL, it will be used as a read buffer, you will have to
		* write to the buffer by other means, like irq's (see also
		* lirc_serial.c).
		*
		* set_use_inc:
		* set_use_inc will be called after device is opened
		*
		* set_use_dec:
		* set_use_dec will be called after device is closed
		*
		* fops:
		* file_operations for drivers which don't fit the current driver model.
		*
		* Some ioctl's can be directly handled by lirc_dev if the driver's
		* ioctl function is NULL or if it returns -ENOIOCTLCMD (see also
		* lirc_serial.c).
		*
		* owner:
		* the module owning this struct
		*
		*/


		/* following functions can be called ONLY from user context
		*
		* returns negative value on error or minor number
		* of the registered device if success
		* contents of the structure pointed by p is copied
		*/
		extern int lirc_register_driver(struct lirc_driver *d);

		/* returns negative value on error or 0 if success
		*/
		extern int lirc_unregister_driver(int minor);

		/* Returns the private data stored in the lirc_driver
		* associated with the given device file pointer.
		*/
		void lirc_get_pdata(struct file file);

		/* default file operations
		* used by drivers if they override only some operations
		*/
		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);
		int lirc_dev_fop_ioctl(struct inode inode, struct file file,
		unsigned int cmd, unsigned long arg);
		ssize_t lirc_dev_fop_read(struct file file, char buffer, size_t length,
		loff_t *ppos);
		ssize_t lirc_dev_fop_write(struct file file, const char buffer, size_t length,
		loff_t *ppos);

		#endif

include/media/lirc.h

0 → 100644

+163 −0

File added.

Preview size limit exceeded, changes collapsed.