uinput.c 14.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
/*
 *  User level driver support for input subsystem
 *
 * Heavily based on evdev.c by Vojtech Pavlik
 *
 * 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
 *
 * Author: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
 *
 * Changes/Revisions:
 *	0.2	16/10/2004 (Micah Dowty <micah@navi.cx>)
 *		- added force feedback support
 *              - added UI_SET_PHYS
 *	0.1	20/06/2002
 *		- first public version
 */
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/smp_lock.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/uinput.h>

static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
	struct uinput_device	*udev;

	udev = dev->private;

	udev->buff[udev->head].type = type;
	udev->buff[udev->head].code = code;
	udev->buff[udev->head].value = value;
	do_gettimeofday(&udev->buff[udev->head].time);
	udev->head = (udev->head + 1) % UINPUT_BUFFER_SIZE;

	wake_up_interruptible(&udev->waitq);

	return 0;
}

56
static int uinput_request_alloc_id(struct uinput_device *udev, struct uinput_request *request)
L
Linus Torvalds 已提交
57 58 59
{
	/* Atomically allocate an ID for the given request. Returns 0 on success. */
	int id;
60
	int err = -1;
L
Linus Torvalds 已提交
61

62
	spin_lock(&udev->requests_lock);
63 64

	for (id = 0; id < UINPUT_NUM_REQUESTS; id++)
L
Linus Torvalds 已提交
65 66
		if (!udev->requests[id]) {
			request->id = id;
67
			udev->requests[id] = request;
68 69
			err = 0;
			break;
L
Linus Torvalds 已提交
70
		}
71

72
	spin_unlock(&udev->requests_lock);
73
	return err;
L
Linus Torvalds 已提交
74 75 76 77 78 79 80 81 82 83
}

static struct uinput_request* uinput_request_find(struct uinput_device *udev, int id)
{
	/* Find an input request, by ID. Returns NULL if the ID isn't valid. */
	if (id >= UINPUT_NUM_REQUESTS || id < 0)
		return NULL;
	return udev->requests[id];
}

84
static inline int uinput_request_reserve_slot(struct uinput_device *udev, struct uinput_request *request)
L
Linus Torvalds 已提交
85
{
86 87 88 89
	/* Allocate slot. If none are available right away, wait. */
	return wait_event_interruptible(udev->requests_waitq,
					!uinput_request_alloc_id(udev, request));
}
L
Linus Torvalds 已提交
90

91 92 93 94 95
static void uinput_request_done(struct uinput_device *udev, struct uinput_request *request)
{
	/* Mark slot as available */
	udev->requests[request->id] = NULL;
	wake_up_interruptible(&udev->requests_waitq);
96 97

	complete(&request->done);
L
Linus Torvalds 已提交
98 99
}

100
static int uinput_request_submit(struct input_dev *dev, struct uinput_request *request)
L
Linus Torvalds 已提交
101 102 103 104 105 106 107
{
	int retval;

	/* Tell our userspace app about this new request by queueing an input event */
	uinput_dev_event(dev, EV_UINPUT, request->code, request->id);

	/* Wait for the request to complete */
108 109 110
	retval = wait_for_completion_interruptible(&request->done);
	if (!retval)
		retval = request->retval;
L
Linus Torvalds 已提交
111

112
	return retval;
L
Linus Torvalds 已提交
113 114 115 116 117
}

static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *effect)
{
	struct uinput_request request;
118
	int retval;
L
Linus Torvalds 已提交
119 120 121 122

	if (!test_bit(EV_FF, dev->evbit))
		return -ENOSYS;

123 124 125
	request.id = -1;
	init_completion(&request.done);
	request.code = UI_FF_UPLOAD;
L
Linus Torvalds 已提交
126
	request.u.effect = effect;
127 128 129 130 131 132

	retval = uinput_request_reserve_slot(dev->private, &request);
	if (!retval)
		retval = uinput_request_submit(dev, &request);

	return retval;
L
Linus Torvalds 已提交
133 134 135 136 137
}

static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id)
{
	struct uinput_request request;
138
	int retval;
L
Linus Torvalds 已提交
139 140 141 142

	if (!test_bit(EV_FF, dev->evbit))
		return -ENOSYS;

143 144 145
	request.id = -1;
	init_completion(&request.done);
	request.code = UI_FF_ERASE;
L
Linus Torvalds 已提交
146
	request.u.effect_id = effect_id;
147 148 149 150 151 152

	retval = uinput_request_reserve_slot(dev->private, &request);
	if (!retval)
		retval = uinput_request_submit(dev, &request);

	return retval;
L
Linus Torvalds 已提交
153 154 155 156 157 158 159 160 161 162 163 164 165 166
}

static int uinput_create_device(struct uinput_device *udev)
{
	if (!udev->dev->name) {
		printk(KERN_DEBUG "%s: write device info first\n", UINPUT_NAME);
		return -EINVAL;
	}

	udev->dev->event = uinput_dev_event;
	udev->dev->upload_effect = uinput_dev_upload_effect;
	udev->dev->erase_effect = uinput_dev_erase_effect;
	udev->dev->private = udev;

167
	init_waitqueue_head(&udev->waitq);
L
Linus Torvalds 已提交
168 169 170

	input_register_device(udev->dev);

171
	set_bit(UIST_CREATED, &udev->state);
L
Linus Torvalds 已提交
172 173 174 175 176 177

	return 0;
}

static int uinput_destroy_device(struct uinput_device *udev)
{
178
	if (!test_bit(UIST_CREATED, &udev->state)) {
L
Linus Torvalds 已提交
179 180 181 182 183 184
		printk(KERN_WARNING "%s: create the device first\n", UINPUT_NAME);
		return -EINVAL;
	}

	input_unregister_device(udev->dev);

185
	clear_bit(UIST_CREATED, &udev->state);
L
Linus Torvalds 已提交
186 187 188 189 190 191 192 193 194 195 196 197 198

	return 0;
}

static int uinput_open(struct inode *inode, struct file *file)
{
	struct uinput_device	*newdev;
	struct input_dev	*newinput;

	newdev = kmalloc(sizeof(struct uinput_device), GFP_KERNEL);
	if (!newdev)
		goto error;
	memset(newdev, 0, sizeof(struct uinput_device));
199
	spin_lock_init(&newdev->requests_lock);
L
Linus Torvalds 已提交
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
	init_waitqueue_head(&newdev->requests_waitq);

	newinput = kmalloc(sizeof(struct input_dev), GFP_KERNEL);
	if (!newinput)
		goto cleanup;
	memset(newinput, 0, sizeof(struct input_dev));

	newdev->dev = newinput;

	file->private_data = newdev;

	return 0;
cleanup:
	kfree(newdev);
error:
	return -ENOMEM;
}

static int uinput_validate_absbits(struct input_dev *dev)
{
	unsigned int cnt;
	int retval = 0;

	for (cnt = 0; cnt < ABS_MAX + 1; cnt++) {
		if (!test_bit(cnt, dev->absbit))
			continue;

		if ((dev->absmax[cnt] <= dev->absmin[cnt])) {
			printk(KERN_DEBUG
				"%s: invalid abs[%02x] min:%d max:%d\n",
				UINPUT_NAME, cnt,
				dev->absmin[cnt], dev->absmax[cnt]);
			retval = -EINVAL;
			break;
		}

		if (dev->absflat[cnt] > (dev->absmax[cnt] - dev->absmin[cnt])) {
			printk(KERN_DEBUG
				"%s: absflat[%02x] out of range: %d "
				"(min:%d/max:%d)\n",
				UINPUT_NAME, cnt, dev->absflat[cnt],
				dev->absmin[cnt], dev->absmax[cnt]);
			retval = -EINVAL;
			break;
		}
	}
	return retval;
}

static int uinput_alloc_device(struct file *file, const char __user *buffer, size_t count)
{
	struct uinput_user_dev	*user_dev;
	struct input_dev	*dev;
	struct uinput_device	*udev;
254
	char			*name;
255 256
	int			size;
	int			retval;
L
Linus Torvalds 已提交
257 258 259 260 261 262

	retval = count;

	udev = file->private_data;
	dev = udev->dev;

263
	user_dev = kmalloc(sizeof(struct uinput_user_dev), GFP_KERNEL);
L
Linus Torvalds 已提交
264 265 266 267 268 269 270 271 272 273
	if (!user_dev) {
		retval = -ENOMEM;
		goto exit;
	}

	if (copy_from_user(user_dev, buffer, sizeof(struct uinput_user_dev))) {
		retval = -EFAULT;
		goto exit;
	}

274
	if (dev->name)
L
Linus Torvalds 已提交
275 276 277
		kfree(dev->name);

	size = strnlen(user_dev->name, UINPUT_MAX_NAME_SIZE) + 1;
278 279
	dev->name = name = kmalloc(size, GFP_KERNEL);
	if (!name) {
L
Linus Torvalds 已提交
280 281 282
		retval = -ENOMEM;
		goto exit;
	}
283
	strlcpy(name, user_dev->name, size);
L
Linus Torvalds 已提交
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299

	dev->id.bustype	= user_dev->id.bustype;
	dev->id.vendor	= user_dev->id.vendor;
	dev->id.product	= user_dev->id.product;
	dev->id.version	= user_dev->id.version;
	dev->ff_effects_max = user_dev->ff_effects_max;

	size = sizeof(int) * (ABS_MAX + 1);
	memcpy(dev->absmax, user_dev->absmax, size);
	memcpy(dev->absmin, user_dev->absmin, size);
	memcpy(dev->absfuzz, user_dev->absfuzz, size);
	memcpy(dev->absflat, user_dev->absflat, size);

	/* check if absmin/absmax/absfuzz/absflat are filled as
	 * told in Documentation/input/input-programming.txt */
	if (test_bit(EV_ABS, dev->evbit)) {
300 301 302
		int err = uinput_validate_absbits(dev);
		if (err < 0) {
			retval = err;
L
Linus Torvalds 已提交
303
			kfree(dev->name);
304
		}
L
Linus Torvalds 已提交
305 306 307 308 309 310 311 312 313 314 315
	}

exit:
	kfree(user_dev);
	return retval;
}

static ssize_t uinput_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
{
	struct uinput_device *udev = file->private_data;

316
	if (test_bit(UIST_CREATED, &udev->state)) {
L
Linus Torvalds 已提交
317 318 319 320 321
		struct input_event	ev;

		if (copy_from_user(&ev, buffer, sizeof(struct input_event)))
			return -EFAULT;
		input_event(udev->dev, ev.type, ev.code, ev.value);
322
	} else
L
Linus Torvalds 已提交
323 324 325 326 327 328 329 330 331 332
		count = uinput_alloc_device(file, buffer, count);

	return count;
}

static ssize_t uinput_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
	struct uinput_device *udev = file->private_data;
	int retval = 0;

333
	if (!test_bit(UIST_CREATED, &udev->state))
L
Linus Torvalds 已提交
334 335
		return -ENODEV;

336
	if (udev->head == udev->tail && (file->f_flags & O_NONBLOCK))
L
Linus Torvalds 已提交
337 338 339
		return -EAGAIN;

	retval = wait_event_interruptible(udev->waitq,
340
			udev->head != udev->tail || !test_bit(UIST_CREATED, &udev->state));
L
Linus Torvalds 已提交
341 342 343
	if (retval)
		return retval;

344
	if (!test_bit(UIST_CREATED, &udev->state))
L
Linus Torvalds 已提交
345 346 347 348
		return -ENODEV;

	while ((udev->head != udev->tail) &&
	    (retval + sizeof(struct input_event) <= count)) {
349 350
		if (copy_to_user(buffer + retval, &udev->buff[udev->tail], sizeof(struct input_event)))
			return -EFAULT;
L
Linus Torvalds 已提交
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
		udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
		retval += sizeof(struct input_event);
	}

	return retval;
}

static unsigned int uinput_poll(struct file *file, poll_table *wait)
{
	struct uinput_device *udev = file->private_data;

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

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

	return 0;
}

static int uinput_burn_device(struct uinput_device *udev)
{
372
	if (test_bit(UIST_CREATED, &udev->state))
L
Linus Torvalds 已提交
373 374
		uinput_destroy_device(udev);

375
	if (udev->dev->name)
L
Linus Torvalds 已提交
376
		kfree(udev->dev->name);
377
	if (udev->dev->phys)
L
Linus Torvalds 已提交
378 379 380 381 382 383 384 385 386 387
		kfree(udev->dev->phys);

	kfree(udev->dev);
	kfree(udev);

	return 0;
}

static int uinput_close(struct inode *inode, struct file *file)
{
388 389
	uinput_burn_device(file->private_data);
	return 0;
L
Linus Torvalds 已提交
390 391 392 393 394 395 396 397 398 399 400
}

static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	int			retval = 0;
	struct uinput_device	*udev;
	void __user             *p = (void __user *)arg;
	struct uinput_ff_upload ff_up;
	struct uinput_ff_erase  ff_erase;
	struct uinput_request   *req;
	int                     length;
401
	char			*phys;
L
Linus Torvalds 已提交
402 403 404 405 406 407 408 409 410 411 412 413 414 415

	udev = file->private_data;

	/* device attributes can not be changed after the device is created */
	switch (cmd) {
		case UI_SET_EVBIT:
		case UI_SET_KEYBIT:
		case UI_SET_RELBIT:
		case UI_SET_ABSBIT:
		case UI_SET_MSCBIT:
		case UI_SET_LEDBIT:
		case UI_SET_SNDBIT:
		case UI_SET_FFBIT:
		case UI_SET_PHYS:
416
			if (test_bit(UIST_CREATED, &udev->state))
L
Linus Torvalds 已提交
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
				return -EINVAL;
	}

	switch (cmd) {
		case UI_DEV_CREATE:
			retval = uinput_create_device(udev);
			break;

		case UI_DEV_DESTROY:
			retval = uinput_destroy_device(udev);
			break;

		case UI_SET_EVBIT:
			if (arg > EV_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->evbit);
			break;

		case UI_SET_KEYBIT:
			if (arg > KEY_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->keybit);
			break;

		case UI_SET_RELBIT:
			if (arg > REL_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->relbit);
			break;

		case UI_SET_ABSBIT:
			if (arg > ABS_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->absbit);
			break;

		case UI_SET_MSCBIT:
			if (arg > MSC_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->mscbit);
			break;

		case UI_SET_LEDBIT:
			if (arg > LED_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->ledbit);
			break;

		case UI_SET_SNDBIT:
			if (arg > SND_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->sndbit);
			break;

		case UI_SET_FFBIT:
			if (arg > FF_MAX) {
				retval = -EINVAL;
				break;
			}
			set_bit(arg, udev->dev->ffbit);
			break;

		case UI_SET_PHYS:
			length = strnlen_user(p, 1024);
			if (length <= 0) {
				retval = -EFAULT;
				break;
			}
499 500 501
			kfree(udev->dev->phys);
			udev->dev->phys = phys = kmalloc(length, GFP_KERNEL);
			if (!phys) {
L
Linus Torvalds 已提交
502 503 504
				retval = -ENOMEM;
				break;
			}
505
			if (copy_from_user(phys, p, length)) {
L
Linus Torvalds 已提交
506
				udev->dev->phys = NULL;
507 508
				kfree(phys);
				retval = -EFAULT;
L
Linus Torvalds 已提交
509 510
				break;
			}
511
			phys[length - 1] = '\0';
L
Linus Torvalds 已提交
512 513 514 515 516 517 518 519
			break;

		case UI_BEGIN_FF_UPLOAD:
			if (copy_from_user(&ff_up, p, sizeof(ff_up))) {
				retval = -EFAULT;
				break;
			}
			req = uinput_request_find(udev, ff_up.request_id);
520
			if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) {
L
Linus Torvalds 已提交
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
				retval = -EINVAL;
				break;
			}
			ff_up.retval = 0;
			memcpy(&ff_up.effect, req->u.effect, sizeof(struct ff_effect));
			if (copy_to_user(p, &ff_up, sizeof(ff_up))) {
				retval = -EFAULT;
				break;
			}
			break;

		case UI_BEGIN_FF_ERASE:
			if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
				retval = -EFAULT;
				break;
			}
			req = uinput_request_find(udev, ff_erase.request_id);
538
			if (!(req && req->code == UI_FF_ERASE)) {
L
Linus Torvalds 已提交
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
				retval = -EINVAL;
				break;
			}
			ff_erase.retval = 0;
			ff_erase.effect_id = req->u.effect_id;
			if (copy_to_user(p, &ff_erase, sizeof(ff_erase))) {
				retval = -EFAULT;
				break;
			}
			break;

		case UI_END_FF_UPLOAD:
			if (copy_from_user(&ff_up, p, sizeof(ff_up))) {
				retval = -EFAULT;
				break;
			}
			req = uinput_request_find(udev, ff_up.request_id);
556
			if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) {
L
Linus Torvalds 已提交
557 558 559 560 561
				retval = -EINVAL;
				break;
			}
			req->retval = ff_up.retval;
			memcpy(req->u.effect, &ff_up.effect, sizeof(struct ff_effect));
562
			uinput_request_done(udev, req);
L
Linus Torvalds 已提交
563 564 565 566 567 568 569 570
			break;

		case UI_END_FF_ERASE:
			if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
				retval = -EFAULT;
				break;
			}
			req = uinput_request_find(udev, ff_erase.request_id);
571
			if (!(req && req->code == UI_FF_ERASE)) {
L
Linus Torvalds 已提交
572 573 574 575
				retval = -EINVAL;
				break;
			}
			req->retval = ff_erase.retval;
576
			uinput_request_done(udev, req);
L
Linus Torvalds 已提交
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
			break;

		default:
			retval = -EINVAL;
	}
	return retval;
}

static struct file_operations uinput_fops = {
	.owner =	THIS_MODULE,
	.open =		uinput_open,
	.release =	uinput_close,
	.read =		uinput_read,
	.write =	uinput_write,
	.poll =		uinput_poll,
	.ioctl =	uinput_ioctl,
};

static struct miscdevice uinput_misc = {
	.fops =		&uinput_fops,
	.minor =	UINPUT_MINOR,
	.name =		UINPUT_NAME,
};

static int __init uinput_init(void)
{
	return misc_register(&uinput_misc);
}

static void __exit uinput_exit(void)
{
	misc_deregister(&uinput_misc);
}

MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
MODULE_DESCRIPTION("User level driver support for input subsystem");
MODULE_LICENSE("GPL");

module_init(uinput_init);
module_exit(uinput_exit);