[deliverable/linux.git] / drivers / hid / uhid.c

/*
 * User-space I/O driver support for HID subsystem
 * Copyright (c) 2012 David Herrmann
 */

/*
 * 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.
 */

#include <linux/atomic.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/hid.h>
#include <linux/input.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/uhid.h>
#include <linux/wait.h>

#define UHID_NAME	"uhid"
#define UHID_BUFSIZE	32

struct uhid_device {
	struct mutex devlock;
	bool running;

	__u8 *rd_data;
	uint rd_size;

	struct hid_device *hid;
	struct uhid_event input_buf;

	wait_queue_head_t waitq;
	spinlock_t qlock;
	__u8 head;
	__u8 tail;
	struct uhid_event *outq[UHID_BUFSIZE];
};

static struct miscdevice uhid_misc;

static void uhid_queue(struct uhid_device *uhid, struct uhid_event *ev)
{
	__u8 newhead;

	newhead = (uhid->head + 1) % UHID_BUFSIZE;

	if (newhead != uhid->tail) {
		uhid->outq[uhid->head] = ev;
		uhid->head = newhead;
		wake_up_interruptible(&uhid->waitq);
	} else {
		hid_warn(uhid->hid, "Output queue is full\n");
		kfree(ev);
	}
}

static int uhid_queue_event(struct uhid_device *uhid, __u32 event)
{
	unsigned long flags;
	struct uhid_event *ev;

	ev = kzalloc(sizeof(*ev), GFP_KERNEL);
	if (!ev)
		return -ENOMEM;

	ev->type = event;

	spin_lock_irqsave(&uhid->qlock, flags);
	uhid_queue(uhid, ev);
	spin_unlock_irqrestore(&uhid->qlock, flags);

	return 0;
}

static int uhid_hid_start(struct hid_device *hid)
{
	struct uhid_device *uhid = hid->driver_data;

	return uhid_queue_event(uhid, UHID_START);
}

static void uhid_hid_stop(struct hid_device *hid)
{
	struct uhid_device *uhid = hid->driver_data;

	hid->claimed = 0;
	uhid_queue_event(uhid, UHID_STOP);
}

static int uhid_hid_open(struct hid_device *hid)
{
	return 0;
}

static void uhid_hid_close(struct hid_device *hid)
{
}

static int uhid_hid_input(struct input_dev *input, unsigned int type,
			  unsigned int code, int value)
{
	return 0;
}

static int uhid_hid_parse(struct hid_device *hid)
{
	struct uhid_device *uhid = hid->driver_data;

	return hid_parse_report(hid, uhid->rd_data, uhid->rd_size);
}

static int uhid_hid_get_raw(struct hid_device *hid, unsigned char rnum,
			    __u8 *buf, size_t count, unsigned char rtype)
{
	return 0;
}

static int uhid_hid_output_raw(struct hid_device *hid, __u8 *buf, size_t count,
			       unsigned char report_type)
{
	return 0;
}

static struct hid_ll_driver uhid_hid_driver = {
	.start = uhid_hid_start,
	.stop = uhid_hid_stop,
	.open = uhid_hid_open,
	.close = uhid_hid_close,
	.hidinput_input_event = uhid_hid_input,
	.parse = uhid_hid_parse,
};

static int uhid_dev_create(struct uhid_device *uhid,
			   const struct uhid_event *ev)
{
	struct hid_device *hid;
	int ret;

	if (uhid->running)
		return -EALREADY;

	uhid->rd_size = ev->u.create.rd_size;
	if (uhid->rd_size <= 0 || uhid->rd_size > HID_MAX_DESCRIPTOR_SIZE)
		return -EINVAL;

	uhid->rd_data = kmalloc(uhid->rd_size, GFP_KERNEL);
	if (!uhid->rd_data)
		return -ENOMEM;

	if (copy_from_user(uhid->rd_data, ev->u.create.rd_data,
			   uhid->rd_size)) {
		ret = -EFAULT;
		goto err_free;
	}

	hid = hid_allocate_device();
	if (IS_ERR(hid)) {
		ret = PTR_ERR(hid);
		goto err_free;
	}

	strncpy(hid->name, ev->u.create.name, 127);
	hid->name[127] = 0;
	strncpy(hid->phys, ev->u.create.phys, 63);
	hid->phys[63] = 0;
	strncpy(hid->uniq, ev->u.create.uniq, 63);
	hid->uniq[63] = 0;

	hid->ll_driver = &uhid_hid_driver;
	hid->hid_get_raw_report = uhid_hid_get_raw;
	hid->hid_output_raw_report = uhid_hid_output_raw;
	hid->bus = ev->u.create.bus;
	hid->vendor = ev->u.create.vendor;
	hid->product = ev->u.create.product;
	hid->version = ev->u.create.version;
	hid->country = ev->u.create.country;
	hid->driver_data = uhid;
	hid->dev.parent = uhid_misc.this_device;

	uhid->hid = hid;
	uhid->running = true;

	ret = hid_add_device(hid);
	if (ret) {
		hid_err(hid, "Cannot register HID device\n");
		goto err_hid;
	}

	return 0;

err_hid:
	hid_destroy_device(hid);
	uhid->hid = NULL;
	uhid->running = false;
err_free:
	kfree(uhid->rd_data);
	return ret;
}

static int uhid_dev_destroy(struct uhid_device *uhid)
{
	if (!uhid->running)
		return -EINVAL;

	uhid->running = false;

	hid_destroy_device(uhid->hid);
	kfree(uhid->rd_data);

	return 0;
}

static int uhid_dev_input(struct uhid_device *uhid, struct uhid_event *ev)
{
	if (!uhid->running)
		return -EINVAL;

	hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input.data,
			 min_t(size_t, ev->u.input.size, UHID_DATA_MAX), 0);

	return 0;
}

static int uhid_char_open(struct inode *inode, struct file *file)
{
	struct uhid_device *uhid;

	uhid = kzalloc(sizeof(*uhid), GFP_KERNEL);
	if (!uhid)
		return -ENOMEM;

	mutex_init(&uhid->devlock);
	spin_lock_init(&uhid->qlock);
	init_waitqueue_head(&uhid->waitq);
	uhid->running = false;

	file->private_data = uhid;
	nonseekable_open(inode, file);

	return 0;
}

static int uhid_char_release(struct inode *inode, struct file *file)
{
	struct uhid_device *uhid = file->private_data;
	unsigned int i;

	uhid_dev_destroy(uhid);

	for (i = 0; i < UHID_BUFSIZE; ++i)
		kfree(uhid->outq[i]);

	kfree(uhid);

	return 0;
}

static ssize_t uhid_char_read(struct file *file, char __user *buffer,
				size_t count, loff_t *ppos)
{
	struct uhid_device *uhid = file->private_data;
	int ret;
	unsigned long flags;
	size_t len;

	/* they need at least the "type" member of uhid_event */
	if (count < sizeof(__u32))
		return -EINVAL;

try_again:
	if (file->f_flags & O_NONBLOCK) {
		if (uhid->head == uhid->tail)
			return -EAGAIN;
	} else {
		ret = wait_event_interruptible(uhid->waitq,
						uhid->head != uhid->tail);
		if (ret)
			return ret;
	}

	ret = mutex_lock_interruptible(&uhid->devlock);
	if (ret)
		return ret;

	if (uhid->head == uhid->tail) {
		mutex_unlock(&uhid->devlock);
		goto try_again;
	} else {
		len = min(count, sizeof(**uhid->outq));
		if (copy_to_user(buffer, &uhid->outq[uhid->tail], len)) {
			ret = -EFAULT;
		} else {
			kfree(uhid->outq[uhid->tail]);
			uhid->outq[uhid->tail] = NULL;

			spin_lock_irqsave(&uhid->qlock, flags);
			uhid->tail = (uhid->tail + 1) % UHID_BUFSIZE;
			spin_unlock_irqrestore(&uhid->qlock, flags);
		}
	}

	mutex_unlock(&uhid->devlock);
	return ret ? ret : len;
}

static ssize_t uhid_char_write(struct file *file, const char __user *buffer,
				size_t count, loff_t *ppos)
{
	struct uhid_device *uhid = file->private_data;
	int ret;
	size_t len;

	/* we need at least the "type" member of uhid_event */
	if (count < sizeof(__u32))
		return -EINVAL;

	ret = mutex_lock_interruptible(&uhid->devlock);
	if (ret)
		return ret;

	memset(&uhid->input_buf, 0, sizeof(uhid->input_buf));
	len = min(count, sizeof(uhid->input_buf));
	if (copy_from_user(&uhid->input_buf, buffer, len)) {
		ret = -EFAULT;
		goto unlock;
	}

	switch (uhid->input_buf.type) {
	case UHID_CREATE:
		ret = uhid_dev_create(uhid, &uhid->input_buf);
		break;
	case UHID_DESTROY:
		ret = uhid_dev_destroy(uhid);
		break;
	case UHID_INPUT:
		ret = uhid_dev_input(uhid, &uhid->input_buf);
		break;
	default:
		ret = -EOPNOTSUPP;
	}

unlock:
	mutex_unlock(&uhid->devlock);

	/* return "count" not "len" to not confuse the caller */
	return ret ? ret : count;
}

static unsigned int uhid_char_poll(struct file *file, poll_table *wait)
{
	struct uhid_device *uhid = file->private_data;

	poll_wait(file, &uhid->waitq, wait);

	if (uhid->head != uhid->tail)
		return POLLIN | POLLRDNORM;

	return 0;
}

static const struct file_operations uhid_fops = {
	.owner		= THIS_MODULE,
	.open		= uhid_char_open,
	.release	= uhid_char_release,
	.read		= uhid_char_read,
	.write		= uhid_char_write,
	.poll		= uhid_char_poll,
	.llseek		= no_llseek,
};

static struct miscdevice uhid_misc = {
	.fops		= &uhid_fops,
	.minor		= MISC_DYNAMIC_MINOR,
	.name		= UHID_NAME,
};

static int __init uhid_init(void)
{
	return misc_register(&uhid_misc);
}

static void __exit uhid_exit(void)
{
	misc_deregister(&uhid_misc);
}

module_init(uhid_init);
module_exit(uhid_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
MODULE_DESCRIPTION("User-space I/O driver support for HID subsystem");
Commit	Line	Data
1ccd7a2a DH	1	/*
	2	* User-space I/O driver support for HID subsystem
	3	* Copyright (c) 2012 David Herrmann
	4	*/
	5
	6	/*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the Free
	9	* Software Foundation; either version 2 of the License, or (at your option)
	10	* any later version.
	11	*/
	12
	13	#include <linux/atomic.h>
	14	#include <linux/device.h>
	15	#include <linux/fs.h>
	16	#include <linux/hid.h>
	17	#include <linux/input.h>
	18	#include <linux/miscdevice.h>
	19	#include <linux/module.h>
	20	#include <linux/mutex.h>
	21	#include <linux/poll.h>
	22	#include <linux/sched.h>
	23	#include <linux/spinlock.h>
	24	#include <linux/uhid.h>
	25	#include <linux/wait.h>
	26
	27	#define UHID_NAME "uhid"
ace3d861 DH	28	#define UHID_BUFSIZE 32
	29
	30	struct uhid_device {
d937ae5f	31	struct mutex devlock;
d365c6cf DH	32	bool running;
	33
	34	__u8 *rd_data;
	35	uint rd_size;
	36
ace3d861	37	struct hid_device *hid;
6664ef72	38	struct uhid_event input_buf;
ace3d861 DH	39
	40	wait_queue_head_t waitq;
	41	spinlock_t qlock;
	42	__u8 head;
	43	__u8 tail;
	44	struct uhid_event *outq[UHID_BUFSIZE];
	45	};
1ccd7a2a DH	46
	47	static struct miscdevice uhid_misc;
	48
ace3d861 DH	49	static void uhid_queue(struct uhid_device uhid, struct uhid_event ev)
	50	{
	51	__u8 newhead;
	52
	53	newhead = (uhid->head + 1) % UHID_BUFSIZE;
	54
	55	if (newhead != uhid->tail) {
	56	uhid->outq[uhid->head] = ev;
	57	uhid->head = newhead;
	58	wake_up_interruptible(&uhid->waitq);
	59	} else {
	60	hid_warn(uhid->hid, "Output queue is full\n");
	61	kfree(ev);
	62	}
	63	}
	64
	65	static int uhid_queue_event(struct uhid_device *uhid, __u32 event)
	66	{
	67	unsigned long flags;
	68	struct uhid_event *ev;
	69
	70	ev = kzalloc(sizeof(*ev), GFP_KERNEL);
	71	if (!ev)
	72	return -ENOMEM;
	73
	74	ev->type = event;
	75
	76	spin_lock_irqsave(&uhid->qlock, flags);
	77	uhid_queue(uhid, ev);
	78	spin_unlock_irqrestore(&uhid->qlock, flags);
	79
	80	return 0;
	81	}
	82
d365c6cf DH	83	static int uhid_hid_start(struct hid_device *hid)
d365c6cf DH	84	{
ec4b7dea DH	85	struct uhid_device *uhid = hid->driver_data;
	86
	87	return uhid_queue_event(uhid, UHID_START);
d365c6cf DH	88	}
	89
	90	static void uhid_hid_stop(struct hid_device *hid)
	91	{
ec4b7dea DH	92	struct uhid_device *uhid = hid->driver_data;
	93
	94	hid->claimed = 0;
	95	uhid_queue_event(uhid, UHID_STOP);
d365c6cf DH	96	}
	97
	98	static int uhid_hid_open(struct hid_device *hid)
	99	{
	100	return 0;
	101	}
	102
	103	static void uhid_hid_close(struct hid_device *hid)
	104	{
	105	}
	106
	107	static int uhid_hid_input(struct input_dev *input, unsigned int type,
	108	unsigned int code, int value)
	109	{
	110	return 0;
	111	}
	112
	113	static int uhid_hid_parse(struct hid_device *hid)
	114	{
037c061b DH	115	struct uhid_device *uhid = hid->driver_data;
	116
	117	return hid_parse_report(hid, uhid->rd_data, uhid->rd_size);
d365c6cf DH	118	}
	119
	120	static int uhid_hid_get_raw(struct hid_device *hid, unsigned char rnum,
	121	__u8 *buf, size_t count, unsigned char rtype)
	122	{
	123	return 0;
	124	}
	125
	126	static int uhid_hid_output_raw(struct hid_device hid, __u8 buf, size_t count,
	127	unsigned char report_type)
	128	{
	129	return 0;
	130	}
	131
	132	static struct hid_ll_driver uhid_hid_driver = {
	133	.start = uhid_hid_start,
	134	.stop = uhid_hid_stop,
	135	.open = uhid_hid_open,
	136	.close = uhid_hid_close,
	137	.hidinput_input_event = uhid_hid_input,
	138	.parse = uhid_hid_parse,
	139	};
	140
	141	static int uhid_dev_create(struct uhid_device *uhid,
	142	const struct uhid_event *ev)
	143	{
	144	struct hid_device *hid;
	145	int ret;
	146
	147	if (uhid->running)
	148	return -EALREADY;
	149
	150	uhid->rd_size = ev->u.create.rd_size;
	151	if (uhid->rd_size <= 0 \|\| uhid->rd_size > HID_MAX_DESCRIPTOR_SIZE)
	152	return -EINVAL;
	153
	154	uhid->rd_data = kmalloc(uhid->rd_size, GFP_KERNEL);
	155	if (!uhid->rd_data)
	156	return -ENOMEM;
	157
	158	if (copy_from_user(uhid->rd_data, ev->u.create.rd_data,
	159	uhid->rd_size)) {
	160	ret = -EFAULT;
	161	goto err_free;
	162	}
	163
	164	hid = hid_allocate_device();
	165	if (IS_ERR(hid)) {
	166	ret = PTR_ERR(hid);
	167	goto err_free;
	168	}
	169
	170	strncpy(hid->name, ev->u.create.name, 127);
	171	hid->name[127] = 0;
	172	strncpy(hid->phys, ev->u.create.phys, 63);
	173	hid->phys[63] = 0;
	174	strncpy(hid->uniq, ev->u.create.uniq, 63);
	175	hid->uniq[63] = 0;
	176
	177	hid->ll_driver = &uhid_hid_driver;
	178	hid->hid_get_raw_report = uhid_hid_get_raw;
	179	hid->hid_output_raw_report = uhid_hid_output_raw;
	180	hid->bus = ev->u.create.bus;
	181	hid->vendor = ev->u.create.vendor;
182	hid->product = ev->u.create.product;
183	hid->version = ev->u.create.version;
184	hid->country = ev->u.create.country;
185	hid->driver_data = uhid;
186	hid->dev.parent = uhid_misc.this_device;
187
188	uhid->hid = hid;
189	uhid->running = true;
190
191	ret = hid_add_device(hid);
192	if (ret) {
193	hid_err(hid, "Cannot register HID device\n");
194	goto err_hid;
195	}
196
197	return 0;
198
199	err_hid:
200	hid_destroy_device(hid);
201	uhid->hid = NULL;
202	uhid->running = false;
203	err_free:
204	kfree(uhid->rd_data);
205	return ret;
206	}
207
208	static int uhid_dev_destroy(struct uhid_device *uhid)
209	{
210	if (!uhid->running)
211	return -EINVAL;
212
213	uhid->running = false;
214
215	hid_destroy_device(uhid->hid);
216	kfree(uhid->rd_data);
217
218	return 0;
219	}
220
5e87a36a DH	221	static int uhid_dev_input(struct uhid_device uhid, struct uhid_event ev)
	222	{
	223	if (!uhid->running)
	224	return -EINVAL;
	225
	226	hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input.data,
	227	min_t(size_t, ev->u.input.size, UHID_DATA_MAX), 0);
	228
	229	return 0;
	230	}
	231
1ccd7a2a DH	232	static int uhid_char_open(struct inode inode, struct file file)
1ccd7a2a DH	233	{
ace3d861 DH	234	struct uhid_device *uhid;
	235
	236	uhid = kzalloc(sizeof(*uhid), GFP_KERNEL);
	237	if (!uhid)
	238	return -ENOMEM;
	239
d937ae5f	240	mutex_init(&uhid->devlock);
ace3d861 DH	241	spin_lock_init(&uhid->qlock);
ace3d861 DH	242	init_waitqueue_head(&uhid->waitq);
d365c6cf	243	uhid->running = false;
ace3d861 DH	244
	245	file->private_data = uhid;
	246	nonseekable_open(inode, file);
	247
1ccd7a2a DH	248	return 0;
	249	}
	250
	251	static int uhid_char_release(struct inode inode, struct file file)
	252	{
ace3d861 DH	253	struct uhid_device *uhid = file->private_data;
	254	unsigned int i;
	255
d365c6cf DH	256	uhid_dev_destroy(uhid);
d365c6cf DH	257
ace3d861 DH	258	for (i = 0; i < UHID_BUFSIZE; ++i)
	259	kfree(uhid->outq[i]);
	260
	261	kfree(uhid);
	262
1ccd7a2a DH	263	return 0;
	264	}
	265
	266	static ssize_t uhid_char_read(struct file file, char __user buffer,
	267	size_t count, loff_t *ppos)
	268	{
d937ae5f DH	269	struct uhid_device *uhid = file->private_data;
	270	int ret;
	271	unsigned long flags;
	272	size_t len;
	273
	274	/* they need at least the "type" member of uhid_event */
	275	if (count < sizeof(__u32))
	276	return -EINVAL;
	277
	278	try_again:
	279	if (file->f_flags & O_NONBLOCK) {
	280	if (uhid->head == uhid->tail)
	281	return -EAGAIN;
	282	} else {
	283	ret = wait_event_interruptible(uhid->waitq,
	284	uhid->head != uhid->tail);
	285	if (ret)
	286	return ret;
	287	}
	288
	289	ret = mutex_lock_interruptible(&uhid->devlock);
	290	if (ret)
	291	return ret;
	292
	293	if (uhid->head == uhid->tail) {
	294	mutex_unlock(&uhid->devlock);
	295	goto try_again;
	296	} else {
	297	len = min(count, sizeof(**uhid->outq));
	298	if (copy_to_user(buffer, &uhid->outq[uhid->tail], len)) {
	299	ret = -EFAULT;
	300	} else {
	301	kfree(uhid->outq[uhid->tail]);
	302	uhid->outq[uhid->tail] = NULL;
	303
	304	spin_lock_irqsave(&uhid->qlock, flags);
	305	uhid->tail = (uhid->tail + 1) % UHID_BUFSIZE;
	306	spin_unlock_irqrestore(&uhid->qlock, flags);
	307	}
	308	}
	309
	310	mutex_unlock(&uhid->devlock);
	311	return ret ? ret : len;
1ccd7a2a DH	312	}
	313
	314	static ssize_t uhid_char_write(struct file file, const char __user buffer,
	315	size_t count, loff_t *ppos)
	316	{
6664ef72 DH	317	struct uhid_device *uhid = file->private_data;
	318	int ret;
	319	size_t len;
	320
	321	/* we need at least the "type" member of uhid_event */
	322	if (count < sizeof(__u32))
	323	return -EINVAL;
	324
	325	ret = mutex_lock_interruptible(&uhid->devlock);
	326	if (ret)
	327	return ret;
	328
	329	memset(&uhid->input_buf, 0, sizeof(uhid->input_buf));
	330	len = min(count, sizeof(uhid->input_buf));
	331	if (copy_from_user(&uhid->input_buf, buffer, len)) {
	332	ret = -EFAULT;
	333	goto unlock;
	334	}
	335
	336	switch (uhid->input_buf.type) {
d365c6cf DH	337	case UHID_CREATE:
	338	ret = uhid_dev_create(uhid, &uhid->input_buf);
	339	break;
	340	case UHID_DESTROY:
	341	ret = uhid_dev_destroy(uhid);
	342	break;
5e87a36a DH	343	case UHID_INPUT:
	344	ret = uhid_dev_input(uhid, &uhid->input_buf);
	345	break;
6664ef72 DH	346	default:
	347	ret = -EOPNOTSUPP;
	348	}
	349
	350	unlock:
	351	mutex_unlock(&uhid->devlock);
	352
	353	/* return "count" not "len" to not confuse the caller */
	354	return ret ? ret : count;
1ccd7a2a DH	355	}
	356
	357	static unsigned int uhid_char_poll(struct file file, poll_table wait)
	358	{
1f9dec1e DH	359	struct uhid_device *uhid = file->private_data;
	360
	361	poll_wait(file, &uhid->waitq, wait);
	362
	363	if (uhid->head != uhid->tail)
	364	return POLLIN \| POLLRDNORM;
	365
1ccd7a2a DH	366	return 0;
	367	}
	368
	369	static const struct file_operations uhid_fops = {
	370	.owner = THIS_MODULE,
	371	.open = uhid_char_open,
	372	.release = uhid_char_release,
	373	.read = uhid_char_read,
	374	.write = uhid_char_write,
	375	.poll = uhid_char_poll,
	376	.llseek = no_llseek,
	377	};
	378
	379	static struct miscdevice uhid_misc = {
	380	.fops = &uhid_fops,
	381	.minor = MISC_DYNAMIC_MINOR,
	382	.name = UHID_NAME,
	383	};
	384
	385	static int __init uhid_init(void)
	386	{
	387	return misc_register(&uhid_misc);
	388	}
	389
	390	static void __exit uhid_exit(void)
	391	{
	392	misc_deregister(&uhid_misc);
	393	}
	394
	395	module_init(uhid_init);
	396	module_exit(uhid_exit);
	397	MODULE_LICENSE("GPL");
	398	MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
	399	MODULE_DESCRIPTION("User-space I/O driver support for HID subsystem");