[net-next-2.6.git] / drivers / media / IR / 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.
 *
 *  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/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 <media/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,
	.unlocked_ioctl	= lirc_dev_fop_ioctl,
	.open		= lirc_dev_fop_open,
	.release	= lirc_dev_fop_close,
	.llseek		= noop_llseek,
};

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->unlocked_ioctl)) {
			dev_err(d->dev, "lirc_dev: lirc_register_driver: "
				"neither read, poll nor unlocked_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;
	}
	file->private_data = ir;

	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);

	nonseekable_open(inode, file);

	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);

long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	unsigned long mode;
	int result = 0;
	struct irctl *ir = file->private_data;

	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;
				remove_wait_queue(&ir->buf->wait_poll, &wait);
				set_current_state(TASK_RUNNING);
				goto out_unlocked;
			}

			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);

out_unlocked:
	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");
Commit	Line	Data
4a62a5ab JW	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>
4a62a5ab JW	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/lirc.h>
5690085e	39	#include <media/lirc_dev.h>
4a62a5ab JW	40
	41	static int debug;
	42
	43	#define IRCTL_DEV_NAME "BaseRemoteCtl"
	44	#define NOPLUG -1
	45	#define LOGHEAD "lirc_dev (%s[%d]): "
	46
	47	static dev_t lirc_base_dev;
	48
	49	struct irctl {
	50	struct lirc_driver d;
	51	int attached;
	52	int open;
	53
	54	struct mutex irctl_lock;
	55	struct lirc_buffer *buf;
	56	unsigned int chunk_size;
	57
	58	struct task_struct *task;
	59	long jiffies_to_wait;
	60
	61	struct cdev cdev;
	62	};
	63
	64	static DEFINE_MUTEX(lirc_dev_lock);
	65
	66	static struct irctl *irctls[MAX_IRCTL_DEVICES];
	67
	68	/* Only used for sysfs but defined to void otherwise */
	69	static struct class *lirc_class;
	70
	71	/* helper function
	72	* initializes the irctl structure
	73	*/
	74	static void init_irctl(struct irctl *ir)
	75	{
	76	dev_dbg(ir->d.dev, LOGHEAD "initializing irctl\n",
	77	ir->d.name, ir->d.minor);
	78	mutex_init(&ir->irctl_lock);
	79	ir->d.minor = NOPLUG;
	80	}
	81
	82	static void cleanup(struct irctl *ir)
	83	{
	84	dev_dbg(ir->d.dev, LOGHEAD "cleaning up\n", ir->d.name, ir->d.minor);
	85
	86	device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
	87
	88	if (ir->buf != ir->d.rbuf) {
	89	lirc_buffer_free(ir->buf);
	90	kfree(ir->buf);
	91	}
	92	ir->buf = NULL;
	93	}
	94
	95	/* helper function
	96	* reads key codes from driver and puts them into buffer
	97	* returns 0 on success
	98	*/
	99	static int add_to_buf(struct irctl *ir)
	100	{
	101	if (ir->d.add_to_buf) {
	102	int res = -ENODATA;
	103	int got_data = 0;
104
105	/*
106	* service the device as long as it is returning
107	* data and we have space
108	*/
109	get_data:
110	res = ir->d.add_to_buf(ir->d.data, ir->buf);
111	if (res == 0) {
112	got_data++;
113	goto get_data;
114	}
115
116	if (res == -ENODEV)
117	kthread_stop(ir->task);
118
119	return got_data ? 0 : res;
120	}
121
122	return 0;
123	}
124
125	/* main function of the polling thread
126	*/
127	static int lirc_thread(void *irctl)
128	{
129	struct irctl *ir = irctl;
130
131	dev_dbg(ir->d.dev, LOGHEAD "poll thread started\n",
132	ir->d.name, ir->d.minor);
133
134	do {
135	if (ir->open) {
136	if (ir->jiffies_to_wait) {
137	set_current_state(TASK_INTERRUPTIBLE);
138	schedule_timeout(ir->jiffies_to_wait);
139	}
140	if (kthread_should_stop())
141	break;
142	if (!add_to_buf(ir))
143	wake_up_interruptible(&ir->buf->wait_poll);
144	} else {
145	set_current_state(TASK_INTERRUPTIBLE);
146	schedule();
147	}
148	} while (!kthread_should_stop());
149
150	dev_dbg(ir->d.dev, LOGHEAD "poll thread ended\n",
151	ir->d.name, ir->d.minor);
152
153	return 0;
154	}
155
156
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,
044e5878	162	.unlocked_ioctl = lirc_dev_fop_ioctl,
4a62a5ab JW	163	.open = lirc_dev_fop_open,
4a62a5ab JW	164	.release = lirc_dev_fop_close,
6038f373	165	.llseek = noop_llseek,
4a62a5ab JW	166	};
	167
	168	static int lirc_cdev_add(struct irctl *ir)
	169	{
	170	int retval;
	171	struct lirc_driver *d = &ir->d;
	172
	173	if (d->fops) {
	174	cdev_init(&ir->cdev, d->fops);
	175	ir->cdev.owner = d->owner;
	176	} else {
	177	cdev_init(&ir->cdev, &fops);
	178	ir->cdev.owner = THIS_MODULE;
	179	}
	180	kobject_set_name(&ir->cdev.kobj, "lirc%d", d->minor);
	181
	182	retval = cdev_add(&ir->cdev, MKDEV(MAJOR(lirc_base_dev), d->minor), 1);
	183	if (retval)
	184	kobject_put(&ir->cdev.kobj);
	185
	186	return retval;
	187	}
	188
	189	int lirc_register_driver(struct lirc_driver *d)
	190	{
	191	struct irctl *ir;
	192	int minor;
	193	int bytes_in_key;
	194	unsigned int chunk_size;
	195	unsigned int buffer_size;
	196	int err;
	197
	198	if (!d) {
	199	printk(KERN_ERR "lirc_dev: lirc_register_driver: "
	200	"driver pointer must be not NULL!\n");
	201	err = -EBADRQC;
	202	goto out;
	203	}
	204
	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);
	209	err = -EBADRQC;
	210	goto out;
	211	}
	212
	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);
	218	err = -EBADRQC;
	219	goto out;
	220	}
	221
	222	dev_dbg(d->dev, "lirc_dev: lirc_register_driver: sample_rate: %d\n",
	223	d->sample_rate);
	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);
	228	err = -EBADRQC;
	229	goto out;
230	}
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");
235	err = -EBADRQC;
236	goto out;
237	}
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");
241	err = -EBADRQC;
242	goto out;
243	} else if (!d->rbuf) {
244	if (!(d->fops && d->fops->read && d->fops->poll &&
044e5878	245	d->fops->unlocked_ioctl)) {
4a62a5ab	246	dev_err(d->dev, "lirc_dev: lirc_register_driver: "
044e5878	247	"neither read, poll nor unlocked_ioctl can be NULL!\n");
4a62a5ab JW	248	err = -EBADRQC;
	249	goto out;
	250	}
	251	}
	252
	253	mutex_lock(&lirc_dev_lock);
	254
	255	minor = d->minor;
	256
	257	if (minor < 0) {
	258	/* find first free slot for driver */
	259	for (minor = 0; minor < MAX_IRCTL_DEVICES; minor++)
	260	if (!irctls[minor])
	261	break;
	262	if (MAX_IRCTL_DEVICES == minor) {
	263	dev_err(d->dev, "lirc_dev: lirc_register_driver: "
	264	"no free slots for drivers!\n");
	265	err = -ENOMEM;
	266	goto out_lock;
	267	}
	268	} else if (irctls[minor]) {
	269	dev_err(d->dev, "lirc_dev: lirc_register_driver: "
	270	"minor (%d) just registered!\n", minor);
	271	err = -EBUSY;
	272	goto out_lock;
	273	}
	274
	275	ir = kzalloc(sizeof(struct irctl), GFP_KERNEL);
	276	if (!ir) {
	277	err = -ENOMEM;
	278	goto out_lock;
	279	}
	280	init_irctl(ir);
	281	irctls[minor] = ir;
	282	d->minor = minor;
	283
	284	if (d->sample_rate) {
	285	ir->jiffies_to_wait = HZ / d->sample_rate;
	286	} else {
	287	/* it means - wait for external event in task queue */
	288	ir->jiffies_to_wait = 0;
	289	}
	290
	291	/* some safety check 8-) */
	292	d->name[sizeof(d->name)-1] = '\0';
	293
	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;
	298
	299	if (d->rbuf) {
	300	ir->buf = d->rbuf;
	301	} else {
	302	ir->buf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
	303	if (!ir->buf) {
	304	err = -ENOMEM;
	305	goto out_lock;
	306	}
	307	err = lirc_buffer_init(ir->buf, chunk_size, buffer_size);
	308	if (err) {
	309	kfree(ir->buf);
	310	goto out_lock;
	311	}
312	}
313	ir->chunk_size = ir->buf->chunk_size;
314
315	if (d->features == 0)
316	d->features = LIRC_CAN_REC_LIRCCODE;
317
318	ir->d = *d;
319	ir->d.minor = minor;
320
321	device_create(lirc_class, ir->d.dev,
322	MKDEV(MAJOR(lirc_base_dev), ir->d.minor), NULL,
323	"lirc%u", ir->d.minor);
324
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",
331	d->minor);
332	err = -ECHILD;
333	goto out_sysfs;
334	}
335	}
336
337	err = lirc_cdev_add(ir);
338	if (err)
339	goto out_sysfs;
340
341	ir->attached = 1;
342	mutex_unlock(&lirc_dev_lock);
343
344	dev_info(ir->d.dev, "lirc_dev: driver %s registered at minor = %d\n",
345	ir->d.name, ir->d.minor);
346	return minor;
347
348	out_sysfs:
349	device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
350	out_lock:
351	mutex_unlock(&lirc_dev_lock);
352	out:
353	return err;
354	}
355	EXPORT_SYMBOL(lirc_register_driver);
356
357	int lirc_unregister_driver(int minor)
358	{
359	struct irctl *ir;
360
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);
365	return -EBADRQC;
366	}
367
368	ir = irctls[minor];
369
370	mutex_lock(&lirc_dev_lock);
371
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);
376	return -ENOENT;
377	}
378
379	/* end up polling thread */
380	if (ir->task)
381	kthread_stop(ir->task);
382
383	dev_dbg(ir->d.dev, "lirc_dev: driver %s unregistered from minor = %d\n",
384	ir->d.name, ir->d.minor);
385
386	ir->attached = 0;
387	if (ir->open) {
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);
395	cdev_del(&ir->cdev);
396	} else {
397	cleanup(ir);
398	cdev_del(&ir->cdev);
399	kfree(ir);
400	irctls[minor] = NULL;
401	}
402
403	mutex_unlock(&lirc_dev_lock);
404
405	return 0;
406	}
407	EXPORT_SYMBOL(lirc_unregister_driver);
408
409	int lirc_dev_fop_open(struct inode inode, struct file file)
410	{
411	struct irctl *ir;
412	int retval = 0;
413
414	if (iminor(inode) >= MAX_IRCTL_DEVICES) {
415	printk(KERN_WARNING "lirc_dev [%d]: open result = -ENODEV\n",
416	iminor(inode));
417	return -ENODEV;
418	}
419
420	if (mutex_lock_interruptible(&lirc_dev_lock))
421	return -ERESTARTSYS;
422
423	ir = irctls[iminor(inode)];
424	if (!ir) {
425	retval = -ENODEV;
426	goto error;
427	}
044e5878	428	file->private_data = ir;
4a62a5ab JW	429
	430	dev_dbg(ir->d.dev, LOGHEAD "open called\n", ir->d.name, ir->d.minor);
	431
	432	if (ir->d.minor == NOPLUG) {
	433	retval = -ENODEV;
	434	goto error;
	435	}
	436
	437	if (ir->open) {
	438	retval = -EBUSY;
	439	goto error;
	440	}
	441
	442	if (try_module_get(ir->d.owner)) {
	443	++ir->open;
	444	retval = ir->d.set_use_inc(ir->d.data);
	445
	446	if (retval) {
	447	module_put(ir->d.owner);
	448	--ir->open;
	449	} else {
	450	lirc_buffer_clear(ir->buf);
	451	}
	452	if (ir->task)
	453	wake_up_process(ir->task);
	454	}
	455
	456	error:
	457	if (ir)
	458	dev_dbg(ir->d.dev, LOGHEAD "open result = %d\n",
	459	ir->d.name, ir->d.minor, retval);
	460
	461	mutex_unlock(&lirc_dev_lock);
	462
d9d2e9d5 AB	463	nonseekable_open(inode, file);
d9d2e9d5 AB	464
4a62a5ab JW	465	return retval;
	466	}
	467	EXPORT_SYMBOL(lirc_dev_fop_open);
	468
	469	int lirc_dev_fop_close(struct inode inode, struct file file)
	470	{
	471	struct irctl *ir = irctls[iminor(inode)];
	472
	473	dev_dbg(ir->d.dev, LOGHEAD "close called\n", ir->d.name, ir->d.minor);
	474
	475	WARN_ON(mutex_lock_killable(&lirc_dev_lock));
	476
	477	--ir->open;
	478	if (ir->attached) {
	479	ir->d.set_use_dec(ir->d.data);
	480	module_put(ir->d.owner);
	481	} else {
	482	cleanup(ir);
	483	irctls[ir->d.minor] = NULL;
	484	kfree(ir);
	485	}
	486
	487	mutex_unlock(&lirc_dev_lock);
	488
	489	return 0;
	490	}
	491	EXPORT_SYMBOL(lirc_dev_fop_close);
	492
	493	unsigned int lirc_dev_fop_poll(struct file file, poll_table wait)
	494	{
	495	struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];
	496	unsigned int ret;
	497
	498	dev_dbg(ir->d.dev, LOGHEAD "poll called\n", ir->d.name, ir->d.minor);
	499
	500	if (!ir->attached) {
	501	mutex_unlock(&ir->irctl_lock);
	502	return POLLERR;
	503	}
	504
	505	poll_wait(file, &ir->buf->wait_poll, wait);
	506
	507	if (ir->buf)
	508	if (lirc_buffer_empty(ir->buf))
	509	ret = 0;
	510	else
	511	ret = POLLIN \| POLLRDNORM;
	512	else
	513	ret = POLLERR;
	514
	515	dev_dbg(ir->d.dev, LOGHEAD "poll result = %d\n",
	516	ir->d.name, ir->d.minor, ret);
	517
	518	return ret;
	519	}
	520	EXPORT_SYMBOL(lirc_dev_fop_poll);
	521
044e5878	522	long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
4a62a5ab JW	523	{
	524	unsigned long mode;
	525	int result = 0;
044e5878	526	struct irctl *ir = file->private_data;
4a62a5ab JW	527
	528	dev_dbg(ir->d.dev, LOGHEAD "ioctl called (0x%x)\n",
	529	ir->d.name, ir->d.minor, cmd);
	530
	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);
	534	return -ENODEV;
	535	}
	536
	537	mutex_lock(&ir->irctl_lock);
	538
	539	switch (cmd) {
	540	case LIRC_GET_FEATURES:
	541	result = put_user(ir->d.features, (unsigned long *)arg);
	542	break;
	543	case LIRC_GET_REC_MODE:
	544	if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
	545	result = -ENOSYS;
	546	break;
	547	}
	548
	549	result = put_user(LIRC_REC2MODE
	550	(ir->d.features & LIRC_CAN_REC_MASK),
	551	(unsigned long *)arg);
	552	break;
	553	case LIRC_SET_REC_MODE:
	554	if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
	555	result = -ENOSYS;
	556	break;
	557	}
	558
	559	result = get_user(mode, (unsigned long *)arg);
	560	if (!result && !(LIRC_MODE2REC(mode) & ir->d.features))
	561	result = -EINVAL;
	562	/*
	563	* FIXME: We should actually set the mode somehow but
	564	* for now, lirc_serial doesn't support mode changing either
	565	*/
	566	break;
	567	case LIRC_GET_LENGTH:
	568	result = put_user(ir->d.code_length, (unsigned long *)arg);
	569	break;
	570	case LIRC_GET_MIN_TIMEOUT:
	571	if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) \|\|
	572	ir->d.min_timeout == 0) {
	573	result = -ENOSYS;
	574	break;
	575	}
	576
	577	result = put_user(ir->d.min_timeout, (unsigned long *)arg);
	578	break;
	579	case LIRC_GET_MAX_TIMEOUT:
	580	if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) \|\|
	581	ir->d.max_timeout == 0) {
	582	result = -ENOSYS;
	583	break;
	584	}
	585
	586	result = put_user(ir->d.max_timeout, (unsigned long *)arg);
	587	break;
	588	default:
	589	result = -EINVAL;
	590	}
591
592	dev_dbg(ir->d.dev, LOGHEAD "ioctl result = %d\n",
593	ir->d.name, ir->d.minor, result);
594
595	mutex_unlock(&ir->irctl_lock);
596
597	return result;
598	}
599	EXPORT_SYMBOL(lirc_dev_fop_ioctl);
600
601	ssize_t lirc_dev_fop_read(struct file *file,
602	char *buffer,
603	size_t length,
604	loff_t *ppos)
605	{
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);
610
611	dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor);
612
613	if (mutex_lock_interruptible(&ir->irctl_lock))
614	return -ERESTARTSYS;
615	if (!ir->attached) {
616	mutex_unlock(&ir->irctl_lock);
617	return -ENODEV;
618	}
619
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);
624	return -EINVAL;
625	}
626
627	/*
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)
631	*/
632	add_wait_queue(&ir->buf->wait_poll, &wait);
633	set_current_state(TASK_INTERRUPTIBLE);
634
635	/*
636	* while we didn't provide 'length' bytes, device is opened in blocking
637	* mode and 'copy_to_user' is happy, wait for data.
638	*/
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
644	* -ERESTARTSYS */
645	if (written)
646	break;
647	if (file->f_flags & O_NONBLOCK) {
648	ret = -EWOULDBLOCK;
649	break;
650	}
651	if (signal_pending(current)) {
652	ret = -ERESTARTSYS;
653	break;
654	}
655
656	mutex_unlock(&ir->irctl_lock);
657	schedule();
658	set_current_state(TASK_INTERRUPTIBLE);
659
660	if (mutex_lock_interruptible(&ir->irctl_lock)) {
661	ret = -ERESTARTSYS;
69c271f3 JW	662	remove_wait_queue(&ir->buf->wait_poll, &wait);
	663	set_current_state(TASK_RUNNING);
	664	goto out_unlocked;
4a62a5ab JW	665	}
	666
	667	if (!ir->attached) {
	668	ret = -ENODEV;
	669	break;
	670	}
	671	} else {
	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;
	676	}
	677	}
	678
	679	remove_wait_queue(&ir->buf->wait_poll, &wait);
	680	set_current_state(TASK_RUNNING);
	681	mutex_unlock(&ir->irctl_lock);
	682
69c271f3	683	out_unlocked:
4a62a5ab JW	684	dev_dbg(ir->d.dev, LOGHEAD "read result = %s (%d)\n",
	685	ir->d.name, ir->d.minor, ret ? "-EFAULT" : "OK", ret);
	686
	687	return ret ? ret : written;
	688	}
	689	EXPORT_SYMBOL(lirc_dev_fop_read);
	690
	691	void lirc_get_pdata(struct file file)
	692	{
	693	void *data = NULL;
	694
	695	if (file && file->f_dentry && file->f_dentry->d_inode &&
	696	file->f_dentry->d_inode->i_rdev) {
	697	struct irctl *ir;
	698	ir = irctls[iminor(file->f_dentry->d_inode)];
	699	data = ir->d.data;
	700	}
	701
	702	return data;
	703	}
	704	EXPORT_SYMBOL(lirc_get_pdata);
	705
	706
	707	ssize_t lirc_dev_fop_write(struct file file, const char buffer,
	708	size_t length, loff_t *ppos)
	709	{
	710	struct irctl *ir = irctls[iminor(file->f_dentry->d_inode)];
	711
	712	dev_dbg(ir->d.dev, LOGHEAD "write called\n", ir->d.name, ir->d.minor);
	713
	714	if (!ir->attached)
	715	return -ENODEV;
	716
	717	return -EINVAL;
	718	}
	719	EXPORT_SYMBOL(lirc_dev_fop_write);
	720
	721
	722	static int __init lirc_dev_init(void)
	723	{
	724	int retval;
	725
	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");
	730	goto error;
	731	}
	732
	733	retval = alloc_chrdev_region(&lirc_base_dev, 0, MAX_IRCTL_DEVICES,
	734	IRCTL_DEV_NAME);
	735	if (retval) {
	736	class_destroy(lirc_class);
	737	printk(KERN_ERR "lirc_dev: alloc_chrdev_region failed\n");
	738	goto error;
	739	}
	740
	741
	742	printk(KERN_INFO "lirc_dev: IR Remote Control driver registered, "
	743	"major %d \n", MAJOR(lirc_base_dev));
	744
	745	error:
	746	return retval;
	747	}
748
749
750
751	static void __exit lirc_dev_exit(void)
752	{
753	class_destroy(lirc_class);
754	unregister_chrdev_region(lirc_base_dev, MAX_IRCTL_DEVICES);
755	printk(KERN_INFO "lirc_dev: module unloaded\n");
756	}
757
758	module_init(lirc_dev_init);
759	module_exit(lirc_dev_exit);
760
761	MODULE_DESCRIPTION("LIRC base driver module");
762	MODULE_AUTHOR("Artur Lipowski");
763	MODULE_LICENSE("GPL");
764
765	module_param(debug, bool, S_IRUGO \| S_IWUSR);
766	MODULE_PARM_DESC(debug, "Enable debugging messages");