evdev.c 17.2 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
/*
 * Event char devices, giving access to raw input device events.
 *
 * Copyright (c) 1999-2002 Vojtech Pavlik
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

#define EVDEV_MINOR_BASE	64
#define EVDEV_MINORS		32
#define EVDEV_BUFFER_SIZE	64

#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/major.h>
#include <linux/device.h>
22
#include <linux/compat.h>
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30

struct evdev {
	int exist;
	int open;
	int minor;
	char name[16];
	struct input_handle handle;
	wait_queue_head_t wait;
31 32
	struct evdev_client *grab;
	struct list_head client_list;
33
	struct device dev;
L
Linus Torvalds 已提交
34 35
};

36
struct evdev_client {
L
Linus Torvalds 已提交
37 38 39 40 41 42 43 44 45 46 47 48 49
	struct input_event buffer[EVDEV_BUFFER_SIZE];
	int head;
	int tail;
	struct fasync_struct *fasync;
	struct evdev *evdev;
	struct list_head node;
};

static struct evdev *evdev_table[EVDEV_MINORS];

static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
	struct evdev *evdev = handle->private;
50
	struct evdev_client *client;
L
Linus Torvalds 已提交
51 52

	if (evdev->grab) {
53
		client = evdev->grab;
L
Linus Torvalds 已提交
54

55 56 57 58 59
		do_gettimeofday(&client->buffer[client->head].time);
		client->buffer[client->head].type = type;
		client->buffer[client->head].code = code;
		client->buffer[client->head].value = value;
		client->head = (client->head + 1) & (EVDEV_BUFFER_SIZE - 1);
L
Linus Torvalds 已提交
60

61
		kill_fasync(&client->fasync, SIGIO, POLL_IN);
L
Linus Torvalds 已提交
62
	} else
63
		list_for_each_entry(client, &evdev->client_list, node) {
L
Linus Torvalds 已提交
64

65 66 67 68 69
			do_gettimeofday(&client->buffer[client->head].time);
			client->buffer[client->head].type = type;
			client->buffer[client->head].code = code;
			client->buffer[client->head].value = value;
			client->head = (client->head + 1) & (EVDEV_BUFFER_SIZE - 1);
L
Linus Torvalds 已提交
70

71
			kill_fasync(&client->fasync, SIGIO, POLL_IN);
L
Linus Torvalds 已提交
72 73 74 75 76 77 78
		}

	wake_up_interruptible(&evdev->wait);
}

static int evdev_fasync(int fd, struct file *file, int on)
{
79
	struct evdev_client *client = file->private_data;
L
Linus Torvalds 已提交
80
	int retval;
81

82
	retval = fasync_helper(fd, file, on, &client->fasync);
83

L
Linus Torvalds 已提交
84 85 86
	return retval < 0 ? retval : 0;
}

87
static int evdev_flush(struct file *file, fl_owner_t id)
L
Linus Torvalds 已提交
88
{
89 90
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
91

92
	if (!evdev->exist)
93 94
		return -ENODEV;

95
	return input_flush_device(&evdev->handle, file);
L
Linus Torvalds 已提交
96 97
}

98
static void evdev_free(struct device *dev)
L
Linus Torvalds 已提交
99
{
100 101
	struct evdev *evdev = container_of(dev, struct evdev, dev);

L
Linus Torvalds 已提交
102 103 104 105
	evdev_table[evdev->minor] = NULL;
	kfree(evdev);
}

106
static int evdev_release(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
107
{
108 109
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
L
Linus Torvalds 已提交
110

111 112 113
	if (evdev->grab == client) {
		input_release_device(&evdev->handle);
		evdev->grab = NULL;
L
Linus Torvalds 已提交
114 115 116
	}

	evdev_fasync(-1, file, 0);
117 118
	list_del(&client->node);
	kfree(client);
L
Linus Torvalds 已提交
119

120 121 122 123
	if (!--evdev->open && evdev->exist)
		input_close_device(&evdev->handle);

	put_device(&evdev->dev);
L
Linus Torvalds 已提交
124 125 126 127

	return 0;
}

128
static int evdev_open(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
129
{
130 131
	struct evdev_client *client;
	struct evdev *evdev;
L
Linus Torvalds 已提交
132
	int i = iminor(inode) - EVDEV_MINOR_BASE;
133
	int error;
L
Linus Torvalds 已提交
134

135
	if (i >= EVDEV_MINORS)
L
Linus Torvalds 已提交
136 137
		return -ENODEV;

138 139 140
	evdev = evdev_table[i];

	if (!evdev || !evdev->exist)
L
Linus Torvalds 已提交
141 142
		return -ENODEV;

143 144
	get_device(&evdev->dev);

145
	client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
146 147 148 149
	if (!client) {
		error = -ENOMEM;
		goto err_put_evdev;
	}
L
Linus Torvalds 已提交
150

151 152
	client->evdev = evdev;
	list_add_tail(&client->node, &evdev->client_list);
L
Linus Torvalds 已提交
153

154 155
	if (!evdev->open++ && evdev->exist) {
		error = input_open_device(&evdev->handle);
156 157
		if (error)
			goto err_free_client;
158
	}
L
Linus Torvalds 已提交
159

160
	file->private_data = client;
L
Linus Torvalds 已提交
161
	return 0;
162 163 164 165 166 167 168

 err_free_client:
	list_del(&client->node);
	kfree(client);
 err_put_evdev:
	put_device(&evdev->dev);
	return error;
L
Linus Torvalds 已提交
169 170
}

171
#ifdef CONFIG_COMPAT
172

173 174 175 176 177 178 179
struct input_event_compat {
	struct compat_timeval time;
	__u16 type;
	__u16 code;
	__s32 value;
};

180 181
/* Note to the author of this code: did it ever occur to
   you why the ifdefs are needed? Think about it again. -AK */
182
#ifdef CONFIG_X86_64
183
#  define COMPAT_TEST is_compat_task()
184
#elif defined(CONFIG_IA64)
A
Al Viro 已提交
185
#  define COMPAT_TEST IS_IA32_PROCESS(task_pt_regs(current))
186
#elif defined(CONFIG_S390)
187
#  define COMPAT_TEST test_thread_flag(TIF_31BIT)
188 189
#elif defined(CONFIG_MIPS)
#  define COMPAT_TEST (current->thread.mflags & MF_32BIT_ADDR)
190 191 192 193
#else
#  define COMPAT_TEST test_thread_flag(TIF_32BIT)
#endif

194
static inline size_t evdev_event_size(void)
195
{
196 197 198
	return COMPAT_TEST ?
		sizeof(struct input_event_compat) : sizeof(struct input_event);
}
199

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
static int evdev_event_from_user(const char __user *buffer, struct input_event *event)
{
	if (COMPAT_TEST) {
		struct input_event_compat compat_event;

		if (copy_from_user(&compat_event, buffer, sizeof(struct input_event_compat)))
			return -EFAULT;

		event->time.tv_sec = compat_event.time.tv_sec;
		event->time.tv_usec = compat_event.time.tv_usec;
		event->type = compat_event.type;
		event->code = compat_event.code;
		event->value = compat_event.value;

	} else {
		if (copy_from_user(event, buffer, sizeof(struct input_event)))
216 217 218
			return -EFAULT;
	}

219
	return 0;
220 221
}

222
static int evdev_event_to_user(char __user *buffer, const struct input_event *event)
L
Linus Torvalds 已提交
223
{
224 225
	if (COMPAT_TEST) {
		struct input_event_compat compat_event;
L
Linus Torvalds 已提交
226

227 228 229 230 231
		compat_event.time.tv_sec = event->time.tv_sec;
		compat_event.time.tv_usec = event->time.tv_usec;
		compat_event.type = event->type;
		compat_event.code = event->code;
		compat_event.value = event->value;
232

233 234
		if (copy_to_user(buffer, &compat_event, sizeof(struct input_event_compat)))
			return -EFAULT;
L
Linus Torvalds 已提交
235

236 237
	} else {
		if (copy_to_user(buffer, event, sizeof(struct input_event)))
L
Linus Torvalds 已提交
238 239 240
			return -EFAULT;
	}

241
	return 0;
L
Linus Torvalds 已提交
242 243
}

244 245 246
#else

static inline size_t evdev_event_size(void)
247
{
248 249
	return sizeof(struct input_event);
}
250

251 252 253 254
static int evdev_event_from_user(const char __user *buffer, struct input_event *event)
{
	if (copy_from_user(event, buffer, sizeof(struct input_event)))
		return -EFAULT;
255

256 257
	return 0;
}
258

259 260 261 262
static int evdev_event_to_user(char __user *buffer, const struct input_event *event)
{
	if (copy_to_user(buffer, event, sizeof(struct input_event)))
		return -EFAULT;
263

264 265 266 267 268
	return 0;
}

#endif /* CONFIG_COMPAT */

269
static ssize_t evdev_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
270
{
271 272
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
273 274
	struct input_event event;
	int retval = 0;
275

276
	if (!evdev->exist)
277 278
		return -ENODEV;

279 280 281 282
	while (retval < count) {

		if (evdev_event_from_user(buffer + retval, &event))
			return -EFAULT;
283
		input_inject_event(&evdev->handle, event.type, event.code, event.value);
284
		retval += evdev_event_size();
285 286 287 288 289
	}

	return retval;
}

290
static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
L
Linus Torvalds 已提交
291
{
292 293
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
L
Linus Torvalds 已提交
294 295
	int retval;

296
	if (count < evdev_event_size())
L
Linus Torvalds 已提交
297 298
		return -EINVAL;

299
	if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK))
L
Linus Torvalds 已提交
300 301
		return -EAGAIN;

302 303
	retval = wait_event_interruptible(evdev->wait,
		client->head != client->tail || !evdev->exist);
L
Linus Torvalds 已提交
304 305 306
	if (retval)
		return retval;

307
	if (!evdev->exist)
L
Linus Torvalds 已提交
308 309
		return -ENODEV;

310
	while (client->head != client->tail && retval + evdev_event_size() <= count) {
311

312
		struct input_event *event = (struct input_event *) client->buffer + client->tail;
313 314 315 316

		if (evdev_event_to_user(buffer + retval, event))
			return -EFAULT;

317
		client->tail = (client->tail + 1) & (EVDEV_BUFFER_SIZE - 1);
318
		retval += evdev_event_size();
L
Linus Torvalds 已提交
319 320 321 322 323 324 325 326
	}

	return retval;
}

/* No kernel lock - fine */
static unsigned int evdev_poll(struct file *file, poll_table *wait)
{
327 328
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
329

330 331 332
	poll_wait(file, &evdev->wait, wait);
	return ((client->head == client->tail) ? 0 : (POLLIN | POLLRDNORM)) |
		(evdev->exist ? 0 : (POLLHUP | POLLERR));
L
Linus Torvalds 已提交
333 334
}

335 336 337 338 339 340 341 342 343 344 345 346 347
#ifdef CONFIG_COMPAT

#define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
#define NBITS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)

#ifdef __BIG_ENDIAN
static int bits_to_user(unsigned long *bits, unsigned int maxbit,
			unsigned int maxlen, void __user *p, int compat)
{
	int len, i;

	if (compat) {
		len = NBITS_COMPAT(maxbit) * sizeof(compat_long_t);
348
		if (len > maxlen)
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
			len = maxlen;

		for (i = 0; i < len / sizeof(compat_long_t); i++)
			if (copy_to_user((compat_long_t __user *) p + i,
					 (compat_long_t *) bits +
						i + 1 - ((i % 2) << 1),
					 sizeof(compat_long_t)))
				return -EFAULT;
	} else {
		len = NBITS(maxbit) * sizeof(long);
		if (len > maxlen)
			len = maxlen;

		if (copy_to_user(p, bits, len))
			return -EFAULT;
	}

	return len;
}
#else
static int bits_to_user(unsigned long *bits, unsigned int maxbit,
			unsigned int maxlen, void __user *p, int compat)
{
	int len = compat ?
			NBITS_COMPAT(maxbit) * sizeof(compat_long_t) :
			NBITS(maxbit) * sizeof(long);

	if (len > maxlen)
		len = maxlen;

	return copy_to_user(p, bits, len) ? -EFAULT : len;
}
#endif /* __BIG_ENDIAN */

#else

static int bits_to_user(unsigned long *bits, unsigned int maxbit,
			unsigned int maxlen, void __user *p, int compat)
{
	int len = NBITS(maxbit) * sizeof(long);

	if (len > maxlen)
		len = maxlen;

	return copy_to_user(p, bits, len) ? -EFAULT : len;
}

#endif /* CONFIG_COMPAT */

static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
{
	int len;

	if (!str)
		return -ENOENT;

	len = strlen(str) + 1;
	if (len > maxlen)
		len = maxlen;

	return copy_to_user(p, str, len) ? -EFAULT : len;
}

static long evdev_ioctl_handler(struct file *file, unsigned int cmd,
				void __user *p, int compat_mode)
L
Linus Torvalds 已提交
414
{
415 416
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
L
Linus Torvalds 已提交
417 418
	struct input_dev *dev = evdev->handle.dev;
	struct input_absinfo abs;
419
	struct ff_effect effect;
420
	int __user *ip = (int __user *)p;
L
Linus Torvalds 已提交
421
	int i, t, u, v;
422
	int error;
L
Linus Torvalds 已提交
423

424 425
	if (!evdev->exist)
		return -ENODEV;
L
Linus Torvalds 已提交
426 427 428 429 430 431 432

	switch (cmd) {

		case EVIOCGVERSION:
			return put_user(EV_VERSION, ip);

		case EVIOCGID:
433 434
			if (copy_to_user(p, &dev->id, sizeof(struct input_id)))
				return -EFAULT;
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
			return 0;

		case EVIOCGREP:
			if (!test_bit(EV_REP, dev->evbit))
				return -ENOSYS;
			if (put_user(dev->rep[REP_DELAY], ip))
				return -EFAULT;
			if (put_user(dev->rep[REP_PERIOD], ip + 1))
				return -EFAULT;
			return 0;

		case EVIOCSREP:
			if (!test_bit(EV_REP, dev->evbit))
				return -ENOSYS;
			if (get_user(u, ip))
				return -EFAULT;
			if (get_user(v, ip + 1))
				return -EFAULT;

454 455
			input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u);
			input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v);
456 457

			return 0;
L
Linus Torvalds 已提交
458 459

		case EVIOCGKEYCODE:
460 461
			if (get_user(t, ip))
				return -EFAULT;
462 463 464 465 466 467

			error = dev->getkeycode(dev, t, &v);
			if (error)
				return error;

			if (put_user(v, ip + 1))
468
				return -EFAULT;
469

L
Linus Torvalds 已提交
470 471 472
			return 0;

		case EVIOCSKEYCODE:
473
			if (get_user(t, ip) || get_user(v, ip + 1))
474 475
				return -EFAULT;

476
			return dev->setkeycode(dev, t, v);
L
Linus Torvalds 已提交
477 478

		case EVIOCSFF:
479 480
			if (copy_from_user(&effect, p, sizeof(effect)))
				return -EFAULT;
L
Linus Torvalds 已提交
481

482
			error = input_ff_upload(dev, &effect, file);
483

484 485 486 487 488 489 490
			if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
				return -EFAULT;

			return error;

		case EVIOCRMFF:
			return input_ff_erase(dev, (int)(unsigned long) p, file);
L
Linus Torvalds 已提交
491 492

		case EVIOCGEFFECTS:
493 494
			i = test_bit(EV_FF, dev->evbit) ? dev->ff->max_effects : 0;
			if (put_user(i, ip))
L
Linus Torvalds 已提交
495 496 497 498
				return -EFAULT;
			return 0;

		case EVIOCGRAB:
499
			if (p) {
L
Linus Torvalds 已提交
500 501 502 503
				if (evdev->grab)
					return -EBUSY;
				if (input_grab_device(&evdev->handle))
					return -EBUSY;
504
				evdev->grab = client;
L
Linus Torvalds 已提交
505 506
				return 0;
			} else {
507
				if (evdev->grab != client)
L
Linus Torvalds 已提交
508 509 510 511 512 513 514 515
					return -EINVAL;
				input_release_device(&evdev->handle);
				evdev->grab = NULL;
				return 0;
			}

		default:

516
			if (_IOC_TYPE(cmd) != 'E')
L
Linus Torvalds 已提交
517 518
				return -EINVAL;

519 520 521 522
			if (_IOC_DIR(cmd) == _IOC_READ) {

				if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {

523
					unsigned long *bits;
524 525 526 527 528 529 530 531 532 533 534
					int len;

					switch (_IOC_NR(cmd) & EV_MAX) {
						case      0: bits = dev->evbit;  len = EV_MAX;  break;
						case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
						case EV_REL: bits = dev->relbit; len = REL_MAX; break;
						case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
						case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
						case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
						case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
						case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
535
						case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;
536 537
						default: return -EINVAL;
					}
538
					return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);
L
Linus Torvalds 已提交
539 540
				}

541 542 543
				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))
					return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd),
							    p, compat_mode);
L
Linus Torvalds 已提交
544

545 546 547
				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0)))
					return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd),
							    p, compat_mode);
L
Linus Torvalds 已提交
548

549 550 551
				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))
					return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd),
							    p, compat_mode);
L
Linus Torvalds 已提交
552

553 554 555
				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))
					return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd),
							    p, compat_mode);
556

557 558
				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0)))
					return str_to_user(dev->name, _IOC_SIZE(cmd), p);
L
Linus Torvalds 已提交
559

560 561
				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0)))
					return str_to_user(dev->phys, _IOC_SIZE(cmd), p);
L
Linus Torvalds 已提交
562

563 564
				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0)))
					return str_to_user(dev->uniq, _IOC_SIZE(cmd), p);
L
Linus Torvalds 已提交
565

566
				if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
L
Linus Torvalds 已提交
567

568
					t = _IOC_NR(cmd) & ABS_MAX;
L
Linus Torvalds 已提交
569

570 571 572 573 574
					abs.value = dev->abs[t];
					abs.minimum = dev->absmin[t];
					abs.maximum = dev->absmax[t];
					abs.fuzz = dev->absfuzz[t];
					abs.flat = dev->absflat[t];
L
Linus Torvalds 已提交
575

576 577 578 579 580
					if (copy_to_user(p, &abs, sizeof(struct input_absinfo)))
						return -EFAULT;

					return 0;
				}
L
Linus Torvalds 已提交
581 582 583

			}

584
			if (_IOC_DIR(cmd) == _IOC_WRITE) {
L
Linus Torvalds 已提交
585

586
				if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
L
Linus Torvalds 已提交
587

588
					t = _IOC_NR(cmd) & ABS_MAX;
589 590 591

					if (copy_from_user(&abs, p, sizeof(struct input_absinfo)))
						return -EFAULT;
L
Linus Torvalds 已提交
592

593 594 595 596 597
					dev->abs[t] = abs.value;
					dev->absmin[t] = abs.minimum;
					dev->absmax[t] = abs.maximum;
					dev->absfuzz[t] = abs.fuzz;
					dev->absflat[t] = abs.flat;
L
Linus Torvalds 已提交
598

599 600
					return 0;
				}
L
Linus Torvalds 已提交
601 602 603 604 605
			}
	}
	return -EINVAL;
}

606 607 608 609
static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0);
}
610

611
#ifdef CONFIG_COMPAT
612 613
static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
{
614
	return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1);
L
Linus Torvalds 已提交
615
}
616
#endif
L
Linus Torvalds 已提交
617

D
Dmitry Torokhov 已提交
618
static const struct file_operations evdev_fops = {
L
Linus Torvalds 已提交
619 620 621 622 623 624
	.owner =	THIS_MODULE,
	.read =		evdev_read,
	.write =	evdev_write,
	.poll =		evdev_poll,
	.open =		evdev_open,
	.release =	evdev_release,
625 626 627 628
	.unlocked_ioctl = evdev_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl =	evdev_ioctl_compat,
#endif
L
Linus Torvalds 已提交
629 630 631 632
	.fasync =	evdev_fasync,
	.flush =	evdev_flush
};

633 634
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
L
Linus Torvalds 已提交
635 636 637
{
	struct evdev *evdev;
	int minor;
638
	int error;
L
Linus Torvalds 已提交
639 640 641 642

	for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);
	if (minor == EVDEV_MINORS) {
		printk(KERN_ERR "evdev: no more free evdev devices\n");
643
		return -ENFILE;
L
Linus Torvalds 已提交
644 645
	}

646 647 648
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	if (!evdev)
		return -ENOMEM;
L
Linus Torvalds 已提交
649

650
	INIT_LIST_HEAD(&evdev->client_list);
L
Linus Torvalds 已提交
651 652 653 654 655 656 657 658
	init_waitqueue_head(&evdev->wait);

	evdev->exist = 1;
	evdev->minor = minor;
	evdev->handle.dev = dev;
	evdev->handle.name = evdev->name;
	evdev->handle.handler = handler;
	evdev->handle.private = evdev;
659
	snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);
L
Linus Torvalds 已提交
660

661 662 663 664 665 666 667
	snprintf(evdev->dev.bus_id, sizeof(evdev->dev.bus_id),
		 "event%d", minor);
	evdev->dev.class = &input_class;
	evdev->dev.parent = &dev->dev;
	evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
	evdev->dev.release = evdev_free;
	device_initialize(&evdev->dev);
668

669
	evdev_table[minor] = evdev;
670

671
	error = device_add(&evdev->dev);
672
	if (error)
673
		goto err_free_evdev;
674 675 676

	error = input_register_handle(&evdev->handle);
	if (error)
677
		goto err_delete_evdev;
L
Linus Torvalds 已提交
678

679
	return 0;
L
Linus Torvalds 已提交
680

681 682
 err_delete_evdev:
	device_del(&evdev->dev);
683
 err_free_evdev:
684
	put_device(&evdev->dev);
685
	return error;
L
Linus Torvalds 已提交
686 687 688 689 690
}

static void evdev_disconnect(struct input_handle *handle)
{
	struct evdev *evdev = handle->private;
691
	struct evdev_client *client;
L
Linus Torvalds 已提交
692

693
	input_unregister_handle(handle);
694
	device_del(&evdev->dev);
L
Linus Torvalds 已提交
695 696 697 698

	evdev->exist = 0;

	if (evdev->open) {
699
		input_flush_device(handle, NULL);
L
Linus Torvalds 已提交
700
		input_close_device(handle);
701 702
		list_for_each_entry(client, &evdev->client_list, node)
			kill_fasync(&client->fasync, SIGIO, POLL_HUP);
703
		wake_up_interruptible(&evdev->wait);
704 705 706
	}

	put_device(&evdev->dev);
L
Linus Torvalds 已提交
707 708
}

D
Dmitry Torokhov 已提交
709
static const struct input_device_id evdev_ids[] = {
L
Linus Torvalds 已提交
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
	{ .driver_info = 1 },	/* Matches all devices */
	{ },			/* Terminating zero entry */
};

MODULE_DEVICE_TABLE(input, evdev_ids);

static struct input_handler evdev_handler = {
	.event =	evdev_event,
	.connect =	evdev_connect,
	.disconnect =	evdev_disconnect,
	.fops =		&evdev_fops,
	.minor =	EVDEV_MINOR_BASE,
	.name =		"evdev",
	.id_table =	evdev_ids,
};

static int __init evdev_init(void)
{
728
	return input_register_handler(&evdev_handler);
L
Linus Torvalds 已提交
729 730 731 732 733 734 735 736 737 738 739 740 741
}

static void __exit evdev_exit(void)
{
	input_unregister_handler(&evdev_handler);
}

module_init(evdev_init);
module_exit(evdev_exit);

MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
MODULE_DESCRIPTION("Input driver event char devices");
MODULE_LICENSE("GPL");