input.c 60.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12
/*
 * The input core
 *
 * 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.
 */

13 14
#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
15
#include <linux/init.h>
16
#include <linux/types.h>
17
#include <linux/idr.h>
18
#include <linux/input/mt.h>
Linus Torvalds's avatar
Linus Torvalds committed
19
#include <linux/module.h>
20
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
21 22 23
#include <linux/random.h>
#include <linux/major.h>
#include <linux/proc_fs.h>
24
#include <linux/sched.h>
25
#include <linux/seq_file.h>
Linus Torvalds's avatar
Linus Torvalds committed
26 27
#include <linux/poll.h>
#include <linux/device.h>
28
#include <linux/mutex.h>
29
#include <linux/rcupdate.h>
30
#include "input-compat.h"
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35

MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
MODULE_DESCRIPTION("Input core");
MODULE_LICENSE("GPL");

36 37 38
#define INPUT_MAX_CHAR_DEVICES		1024
#define INPUT_FIRST_DYNAMIC_DEV		256
static DEFINE_IDA(input_ida);
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41 42

static LIST_HEAD(input_dev_list);
static LIST_HEAD(input_handler_list);

43 44 45 46 47 48 49 50
/*
 * input_mutex protects access to both input_dev_list and input_handler_list.
 * This also causes input_[un]register_device and input_[un]register_handler
 * be mutually exclusive which simplifies locking in drivers implementing
 * input handlers.
 */
static DEFINE_MUTEX(input_mutex);

51 52
static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 };

53 54
static inline int is_event_supported(unsigned int code,
				     unsigned long *bm, unsigned int max)
Linus Torvalds's avatar
Linus Torvalds committed
55
{
56 57
	return code <= max && test_bit(code, bm);
}
Linus Torvalds's avatar
Linus Torvalds committed
58

59 60 61 62 63
static int input_defuzz_abs_event(int value, int old_val, int fuzz)
{
	if (fuzz) {
		if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
			return old_val;
Linus Torvalds's avatar
Linus Torvalds committed
64

65 66
		if (value > old_val - fuzz && value < old_val + fuzz)
			return (old_val * 3 + value) / 4;
Linus Torvalds's avatar
Linus Torvalds committed
67

68 69 70
		if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
			return (old_val + value) / 2;
	}
Linus Torvalds's avatar
Linus Torvalds committed
71

72 73
	return value;
}
Linus Torvalds's avatar
Linus Torvalds committed
74

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
static void input_start_autorepeat(struct input_dev *dev, int code)
{
	if (test_bit(EV_REP, dev->evbit) &&
	    dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
	    dev->timer.data) {
		dev->repeat_key = code;
		mod_timer(&dev->timer,
			  jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
	}
}

static void input_stop_autorepeat(struct input_dev *dev)
{
	del_timer(&dev->timer);
}

91
/*
92 93
 * Pass event first through all filters and then, if event has not been
 * filtered out, through all open handles. This function is called with
Dmitry Torokhov's avatar
Dmitry Torokhov committed
94
 * dev->event_lock held and interrupts disabled.
95
 */
96 97
static unsigned int input_to_handler(struct input_handle *handle,
			struct input_value *vals, unsigned int count)
98
{
99 100 101
	struct input_handler *handler = handle->handler;
	struct input_value *end = vals;
	struct input_value *v;
Dmitry Torokhov's avatar
Dmitry Torokhov committed
102

103 104 105 106 107 108 109 110 111
	if (handler->filter) {
		for (v = vals; v != vals + count; v++) {
			if (handler->filter(handle, v->type, v->code, v->value))
				continue;
			if (end != v)
				*end = *v;
			end++;
		}
		count = end - vals;
112
	}
Linus Torvalds's avatar
Linus Torvalds committed
113

114 115
	if (!count)
		return 0;
116

117 118 119
	if (handler->events)
		handler->events(handle, vals, count);
	else if (handler->event)
120
		for (v = vals; v != vals + count; v++)
121
			handler->event(handle, v->type, v->code, v->value);
122

123 124
	return count;
}
125

126 127 128 129 130 131 132
/*
 * Pass values first through all filters and then, if event has not been
 * filtered out, through all open handles. This function is called with
 * dev->event_lock held and interrupts disabled.
 */
static void input_pass_values(struct input_dev *dev,
			      struct input_value *vals, unsigned int count)
133
{
Dmitry Torokhov's avatar
Dmitry Torokhov committed
134
	struct input_handle *handle;
135
	struct input_value *v;
136

137 138
	if (!count)
		return;
Dmitry Torokhov's avatar
Dmitry Torokhov committed
139 140

	rcu_read_lock();
Linus Torvalds's avatar
Linus Torvalds committed
141

Dmitry Torokhov's avatar
Dmitry Torokhov committed
142
	handle = rcu_dereference(dev->grab);
143 144 145 146
	if (handle) {
		count = input_to_handler(handle, vals, count);
	} else {
		list_for_each_entry_rcu(handle, &dev->h_list, d_node)
147
			if (handle->open) {
148
				count = input_to_handler(handle, vals, count);
149 150 151
				if (!count)
					break;
			}
152 153
	}

Dmitry Torokhov's avatar
Dmitry Torokhov committed
154
	rcu_read_unlock();
155

156
	/* trigger auto repeat for key events */
157 158 159 160 161 162 163 164
	if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
		for (v = vals; v != vals + count; v++) {
			if (v->type == EV_KEY && v->value != 2) {
				if (v->value)
					input_start_autorepeat(dev, v->code);
				else
					input_stop_autorepeat(dev);
			}
165 166
		}
	}
167
}
168

169 170 171 172 173 174
static void input_pass_event(struct input_dev *dev,
			     unsigned int type, unsigned int code, int value)
{
	struct input_value vals[] = { { type, code, value } };

	input_pass_values(dev, vals, ARRAY_SIZE(vals));
175
}
Linus Torvalds's avatar
Linus Torvalds committed
176

177 178 179 180 181 182 183 184 185
/*
 * Generate software autorepeat event. Note that we take
 * dev->event_lock here to avoid racing with input_event
 * which may cause keys get "stuck".
 */
static void input_repeat_key(unsigned long data)
{
	struct input_dev *dev = (void *) data;
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
186

187
	spin_lock_irqsave(&dev->event_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
188

189 190
	if (test_bit(dev->repeat_key, dev->key) &&
	    is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
191 192 193 194
		struct input_value vals[] =  {
			{ EV_KEY, dev->repeat_key, 2 },
			input_value_sync
		};
Linus Torvalds's avatar
Linus Torvalds committed
195

196
		input_pass_values(dev, vals, ARRAY_SIZE(vals));
197

198 199 200 201
		if (dev->rep[REP_PERIOD])
			mod_timer(&dev->timer, jiffies +
					msecs_to_jiffies(dev->rep[REP_PERIOD]));
	}
202

203 204
	spin_unlock_irqrestore(&dev->event_lock, flags);
}
205

206 207 208
#define INPUT_IGNORE_EVENT	0
#define INPUT_PASS_TO_HANDLERS	1
#define INPUT_PASS_TO_DEVICE	2
209 210
#define INPUT_SLOT		4
#define INPUT_FLUSH		8
211
#define INPUT_PASS_TO_ALL	(INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
Linus Torvalds's avatar
Linus Torvalds committed
212

213 214 215
static int input_handle_abs_event(struct input_dev *dev,
				  unsigned int code, int *pval)
{
Henrik Rydberg's avatar
Henrik Rydberg committed
216
	struct input_mt *mt = dev->mt;
217 218 219 220 221 222
	bool is_mt_event;
	int *pold;

	if (code == ABS_MT_SLOT) {
		/*
		 * "Stage" the event; we'll flush it later, when we
Dmitry Torokhov's avatar
Dmitry Torokhov committed
223
		 * get actual touch data.
224
		 */
Henrik Rydberg's avatar
Henrik Rydberg committed
225 226
		if (mt && *pval >= 0 && *pval < mt->num_slots)
			mt->slot = *pval;
227 228 229 230

		return INPUT_IGNORE_EVENT;
	}

231
	is_mt_event = input_is_mt_value(code);
232 233

	if (!is_mt_event) {
234
		pold = &dev->absinfo[code].value;
Henrik Rydberg's avatar
Henrik Rydberg committed
235 236
	} else if (mt) {
		pold = &mt->slots[mt->slot].abs[code - ABS_MT_FIRST];
237 238
	} else {
		/*
Dmitry Torokhov's avatar
Dmitry Torokhov committed
239
		 * Bypass filtering for multi-touch events when
240 241 242 243 244 245 246
		 * not employing slots.
		 */
		pold = NULL;
	}

	if (pold) {
		*pval = input_defuzz_abs_event(*pval, *pold,
247
						dev->absinfo[code].fuzz);
248 249 250 251 252 253 254
		if (*pold == *pval)
			return INPUT_IGNORE_EVENT;

		*pold = *pval;
	}

	/* Flush pending "slot" event */
Henrik Rydberg's avatar
Henrik Rydberg committed
255 256
	if (is_mt_event && mt && mt->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
		input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
257
		return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
258 259 260 261 262
	}

	return INPUT_PASS_TO_HANDLERS;
}

263
static int input_get_disposition(struct input_dev *dev,
Dmitry Torokhov's avatar
Dmitry Torokhov committed
264
			  unsigned int type, unsigned int code, int *pval)
265 266
{
	int disposition = INPUT_IGNORE_EVENT;
Dmitry Torokhov's avatar
Dmitry Torokhov committed
267
	int value = *pval;
Linus Torvalds's avatar
Linus Torvalds committed
268

269
	switch (type) {
Linus Torvalds's avatar
Linus Torvalds committed
270

271 272 273 274 275
	case EV_SYN:
		switch (code) {
		case SYN_CONFIG:
			disposition = INPUT_PASS_TO_ALL;
			break;
Linus Torvalds's avatar
Linus Torvalds committed
276

277
		case SYN_REPORT:
278
			disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
Linus Torvalds's avatar
Linus Torvalds committed
279
			break;
280 281 282
		case SYN_MT_REPORT:
			disposition = INPUT_PASS_TO_HANDLERS;
			break;
283 284
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
285

286
	case EV_KEY:
287
		if (is_event_supported(code, dev->keybit, KEY_MAX)) {
Linus Torvalds's avatar
Linus Torvalds committed
288

289 290 291 292
			/* auto-repeat bypasses state updates */
			if (value == 2) {
				disposition = INPUT_PASS_TO_HANDLERS;
				break;
293
			}
Linus Torvalds's avatar
Linus Torvalds committed
294

295
			if (!!test_bit(code, dev->key) != !!value) {
Linus Torvalds's avatar
Linus Torvalds committed
296

297
				__change_bit(code, dev->key);
298
				disposition = INPUT_PASS_TO_HANDLERS;
299 300 301
			}
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
302

303 304
	case EV_SW:
		if (is_event_supported(code, dev->swbit, SW_MAX) &&
305
		    !!test_bit(code, dev->sw) != !!value) {
Linus Torvalds's avatar
Linus Torvalds committed
306

307 308 309 310
			__change_bit(code, dev->sw);
			disposition = INPUT_PASS_TO_HANDLERS;
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
311

312
	case EV_ABS:
313
		if (is_event_supported(code, dev->absbit, ABS_MAX))
314
			disposition = input_handle_abs_event(dev, code, &value);
315

316
		break;
Linus Torvalds's avatar
Linus Torvalds committed
317

318 319 320
	case EV_REL:
		if (is_event_supported(code, dev->relbit, REL_MAX) && value)
			disposition = INPUT_PASS_TO_HANDLERS;
Linus Torvalds's avatar
Linus Torvalds committed
321

322
		break;
323

324 325 326
	case EV_MSC:
		if (is_event_supported(code, dev->mscbit, MSC_MAX))
			disposition = INPUT_PASS_TO_ALL;
Linus Torvalds's avatar
Linus Torvalds committed
327

328
		break;
Linus Torvalds's avatar
Linus Torvalds committed
329

330 331
	case EV_LED:
		if (is_event_supported(code, dev->ledbit, LED_MAX) &&
332
		    !!test_bit(code, dev->led) != !!value) {
Linus Torvalds's avatar
Linus Torvalds committed
333

334 335 336 337 338 339 340
			__change_bit(code, dev->led);
			disposition = INPUT_PASS_TO_ALL;
		}
		break;

	case EV_SND:
		if (is_event_supported(code, dev->sndbit, SND_MAX)) {
Linus Torvalds's avatar
Linus Torvalds committed
341

342
			if (!!test_bit(code, dev->snd) != !!value)
343 344 345 346
				__change_bit(code, dev->snd);
			disposition = INPUT_PASS_TO_ALL;
		}
		break;
347

348 349 350 351 352 353
	case EV_REP:
		if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
			dev->rep[code] = value;
			disposition = INPUT_PASS_TO_ALL;
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
354

355 356 357 358
	case EV_FF:
		if (value >= 0)
			disposition = INPUT_PASS_TO_ALL;
		break;
359 360 361 362

	case EV_PWR:
		disposition = INPUT_PASS_TO_ALL;
		break;
363
	}
Linus Torvalds's avatar
Linus Torvalds committed
364

Dmitry Torokhov's avatar
Dmitry Torokhov committed
365
	*pval = value;
366 367 368 369 370 371
	return disposition;
}

static void input_handle_event(struct input_dev *dev,
			       unsigned int type, unsigned int code, int value)
{
372
	int disposition = input_get_disposition(dev, type, code, &value);
373

374 375
	if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
		add_input_randomness(type, code, value);
Linus Torvalds's avatar
Linus Torvalds committed
376

377 378
	if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
		dev->event(dev, type, code, value);
Linus Torvalds's avatar
Linus Torvalds committed
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
	if (!dev->vals)
		return;

	if (disposition & INPUT_PASS_TO_HANDLERS) {
		struct input_value *v;

		if (disposition & INPUT_SLOT) {
			v = &dev->vals[dev->num_vals++];
			v->type = EV_ABS;
			v->code = ABS_MT_SLOT;
			v->value = dev->mt->slot;
		}

		v = &dev->vals[dev->num_vals++];
		v->type = type;
		v->code = code;
		v->value = value;
	}

	if (disposition & INPUT_FLUSH) {
		if (dev->num_vals >= 2)
			input_pass_values(dev, dev->vals, dev->num_vals);
		dev->num_vals = 0;
	} else if (dev->num_vals >= dev->max_vals - 2) {
		dev->vals[dev->num_vals++] = input_value_sync;
		input_pass_values(dev, dev->vals, dev->num_vals);
		dev->num_vals = 0;
	}

409
}
Linus Torvalds's avatar
Linus Torvalds committed
410

411 412 413 414 415 416 417 418
/**
 * input_event() - report new input event
 * @dev: device that generated the event
 * @type: type of the event
 * @code: event code
 * @value: value of the event
 *
 * This function should be used by drivers implementing various input
419 420 421 422 423 424 425 426
 * devices to report input events. See also input_inject_event().
 *
 * NOTE: input_event() may be safely used right after input device was
 * allocated with input_allocate_device(), even before it is registered
 * with input_register_device(), but the event will not reach any of the
 * input handlers. Such early invocation of input_event() may be used
 * to 'seed' initial state of a switch or initial position of absolute
 * axis, etc.
427 428 429 430 431
 */
void input_event(struct input_dev *dev,
		 unsigned int type, unsigned int code, int value)
{
	unsigned long flags;
432

433
	if (is_event_supported(type, dev->evbit, EV_MAX)) {
434

435
		spin_lock_irqsave(&dev->event_lock, flags);
436
		input_handle_event(dev, type, code, value);
437
		spin_unlock_irqrestore(&dev->event_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
438 439
	}
}
Dmitry Torokhov's avatar
Dmitry Torokhov committed
440
EXPORT_SYMBOL(input_event);
Linus Torvalds's avatar
Linus Torvalds committed
441

442 443 444 445 446 447 448
/**
 * input_inject_event() - send input event from input handler
 * @handle: input handle to send event through
 * @type: type of the event
 * @code: event code
 * @value: value of the event
 *
449 450 451
 * Similar to input_event() but will ignore event if device is
 * "grabbed" and handle injecting event is not the one that owns
 * the device.
452
 */
453 454
void input_inject_event(struct input_handle *handle,
			unsigned int type, unsigned int code, int value)
Linus Torvalds's avatar
Linus Torvalds committed
455
{
456 457 458
	struct input_dev *dev = handle->dev;
	struct input_handle *grab;
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
459

460 461
	if (is_event_supported(type, dev->evbit, EV_MAX)) {
		spin_lock_irqsave(&dev->event_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
462

Dmitry Torokhov's avatar
Dmitry Torokhov committed
463
		rcu_read_lock();
464 465
		grab = rcu_dereference(dev->grab);
		if (!grab || grab == handle)
466
			input_handle_event(dev, type, code, value);
Dmitry Torokhov's avatar
Dmitry Torokhov committed
467
		rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
468

469 470
		spin_unlock_irqrestore(&dev->event_lock, flags);
	}
Linus Torvalds's avatar
Linus Torvalds committed
471
}
472
EXPORT_SYMBOL(input_inject_event);
Linus Torvalds's avatar
Linus Torvalds committed
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 499 500 501 502 503 504 505
/**
 * input_alloc_absinfo - allocates array of input_absinfo structs
 * @dev: the input device emitting absolute events
 *
 * If the absinfo struct the caller asked for is already allocated, this
 * functions will not do anything.
 */
void input_alloc_absinfo(struct input_dev *dev)
{
	if (!dev->absinfo)
		dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
					GFP_KERNEL);

	WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
}
EXPORT_SYMBOL(input_alloc_absinfo);

void input_set_abs_params(struct input_dev *dev, unsigned int axis,
			  int min, int max, int fuzz, int flat)
{
	struct input_absinfo *absinfo;

	input_alloc_absinfo(dev);
	if (!dev->absinfo)
		return;

	absinfo = &dev->absinfo[axis];
	absinfo->minimum = min;
	absinfo->maximum = max;
	absinfo->fuzz = fuzz;
	absinfo->flat = flat;

506 507
	__set_bit(EV_ABS, dev->evbit);
	__set_bit(axis, dev->absbit);
508 509 510 511
}
EXPORT_SYMBOL(input_set_abs_params);


512 513 514 515 516 517 518 519
/**
 * input_grab_device - grabs device for exclusive use
 * @handle: input handle that wants to own the device
 *
 * When a device is grabbed by an input handle all events generated by
 * the device are delivered only to this handle. Also events injected
 * by other input handles are ignored while device is grabbed.
 */
Linus Torvalds's avatar
Linus Torvalds committed
520 521
int input_grab_device(struct input_handle *handle)
{
522 523
	struct input_dev *dev = handle->dev;
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
524

525 526 527 528 529 530 531 532 533 534 535 536 537 538
	retval = mutex_lock_interruptible(&dev->mutex);
	if (retval)
		return retval;

	if (dev->grab) {
		retval = -EBUSY;
		goto out;
	}

	rcu_assign_pointer(dev->grab, handle);

 out:
	mutex_unlock(&dev->mutex);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
539
}
Dmitry Torokhov's avatar
Dmitry Torokhov committed
540
EXPORT_SYMBOL(input_grab_device);
Linus Torvalds's avatar
Linus Torvalds committed
541

542
static void __input_release_device(struct input_handle *handle)
Linus Torvalds's avatar
Linus Torvalds committed
543
{
544
	struct input_dev *dev = handle->dev;
545
	struct input_handle *grabber;
546

547 548 549
	grabber = rcu_dereference_protected(dev->grab,
					    lockdep_is_held(&dev->mutex));
	if (grabber == handle) {
550 551
		rcu_assign_pointer(dev->grab, NULL);
		/* Make sure input_pass_event() notices that grab is gone */
Dmitry Torokhov's avatar
Dmitry Torokhov committed
552
		synchronize_rcu();
553 554

		list_for_each_entry(handle, &dev->h_list, d_node)
555
			if (handle->open && handle->handler->start)
556 557
				handle->handler->start(handle);
	}
Linus Torvalds's avatar
Linus Torvalds committed
558
}
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576

/**
 * input_release_device - release previously grabbed device
 * @handle: input handle that owns the device
 *
 * Releases previously grabbed device so that other input handles can
 * start receiving input events. Upon release all handlers attached
 * to the device have their start() method called so they have a change
 * to synchronize device state with the rest of the system.
 */
void input_release_device(struct input_handle *handle)
{
	struct input_dev *dev = handle->dev;

	mutex_lock(&dev->mutex);
	__input_release_device(handle);
	mutex_unlock(&dev->mutex);
}
Dmitry Torokhov's avatar
Dmitry Torokhov committed
577
EXPORT_SYMBOL(input_release_device);
Linus Torvalds's avatar
Linus Torvalds committed
578

579 580 581 582 583 584 585
/**
 * input_open_device - open input device
 * @handle: handle through which device is being accessed
 *
 * This function should be called by input handlers when they
 * want to start receive events from given input device.
 */
Linus Torvalds's avatar
Linus Torvalds committed
586 587
int input_open_device(struct input_handle *handle)
{
588
	struct input_dev *dev = handle->dev;
589
	int retval;
590

591 592 593 594 595 596 597 598
	retval = mutex_lock_interruptible(&dev->mutex);
	if (retval)
		return retval;

	if (dev->going_away) {
		retval = -ENODEV;
		goto out;
	}
599

Linus Torvalds's avatar
Linus Torvalds committed
600
	handle->open++;
601 602

	if (!dev->users++ && dev->open)
603 604 605 606 607 608 609 610 611
		retval = dev->open(dev);

	if (retval) {
		dev->users--;
		if (!--handle->open) {
			/*
			 * Make sure we are not delivering any more events
			 * through this handle
			 */
Dmitry Torokhov's avatar
Dmitry Torokhov committed
612
			synchronize_rcu();
613 614
		}
	}
615

616
 out:
617
	mutex_unlock(&dev->mutex);
618
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
619
}
Dmitry Torokhov's avatar
Dmitry Torokhov committed
620
EXPORT_SYMBOL(input_open_device);
Linus Torvalds's avatar
Linus Torvalds committed
621

622
int input_flush_device(struct input_handle *handle, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
623
{
624 625
	struct input_dev *dev = handle->dev;
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
626

627 628 629 630 631 632 633 634 635
	retval = mutex_lock_interruptible(&dev->mutex);
	if (retval)
		return retval;

	if (dev->flush)
		retval = dev->flush(dev, file);

	mutex_unlock(&dev->mutex);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
636
}
Dmitry Torokhov's avatar
Dmitry Torokhov committed
637
EXPORT_SYMBOL(input_flush_device);
Linus Torvalds's avatar
Linus Torvalds committed
638

639 640 641 642 643 644 645
/**
 * input_close_device - close input device
 * @handle: handle through which device is being accessed
 *
 * This function should be called by input handlers when they
 * want to stop receive events from given input device.
 */
Linus Torvalds's avatar
Linus Torvalds committed
646 647
void input_close_device(struct input_handle *handle)
{
648 649
	struct input_dev *dev = handle->dev;

650
	mutex_lock(&dev->mutex);
651

652 653
	__input_release_device(handle);

654 655
	if (!--dev->users && dev->close)
		dev->close(dev);
656 657 658

	if (!--handle->open) {
		/*
Dmitry Torokhov's avatar
Dmitry Torokhov committed
659
		 * synchronize_rcu() makes sure that input_pass_event()
660 661 662
		 * completed and that no more input events are delivered
		 * through this handle
		 */
Dmitry Torokhov's avatar
Dmitry Torokhov committed
663
		synchronize_rcu();
664
	}
665

666
	mutex_unlock(&dev->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
667
}
Dmitry Torokhov's avatar
Dmitry Torokhov committed
668
EXPORT_SYMBOL(input_close_device);
Linus Torvalds's avatar
Linus Torvalds committed
669

670 671 672 673 674 675
/*
 * Simulate keyup events for all keys that are marked as pressed.
 * The function must be called with dev->event_lock held.
 */
static void input_dev_release_keys(struct input_dev *dev)
{
676
	bool need_sync = false;
677 678 679
	int code;

	if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
680
		for_each_set_bit(code, dev->key, KEY_CNT) {
681
			input_pass_event(dev, EV_KEY, code, 0);
682 683 684 685 686 687
			need_sync = true;
		}

		if (need_sync)
			input_pass_event(dev, EV_SYN, SYN_REPORT, 1);

688
		memset(dev->key, 0, sizeof(dev->key));
689 690 691
	}
}

692 693 694 695 696 697 698 699 700 701 702 703 704
/*
 * Prepare device for unregistering
 */
static void input_disconnect_device(struct input_dev *dev)
{
	struct input_handle *handle;

	/*
	 * Mark device as going away. Note that we take dev->mutex here
	 * not to protect access to dev->going_away but rather to ensure
	 * that there are no threads in the middle of input_open_device()
	 */
	mutex_lock(&dev->mutex);
705
	dev->going_away = true;
706 707 708 709 710 711 712 713 714 715
	mutex_unlock(&dev->mutex);

	spin_lock_irq(&dev->event_lock);

	/*
	 * Simulate keyup events for all pressed keys so that handlers
	 * are not left with "stuck" keys. The driver may continue
	 * generate events even after we done here but they will not
	 * reach any handlers.
	 */
716
	input_dev_release_keys(dev);
717 718 719 720 721 722 723

	list_for_each_entry(handle, &dev->h_list, d_node)
		handle->open = 0;

	spin_unlock_irq(&dev->event_lock);
}

724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
/**
 * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
 * @ke: keymap entry containing scancode to be converted.
 * @scancode: pointer to the location where converted scancode should
 *	be stored.
 *
 * This function is used to convert scancode stored in &struct keymap_entry
 * into scalar form understood by legacy keymap handling methods. These
 * methods expect scancodes to be represented as 'unsigned int'.
 */
int input_scancode_to_scalar(const struct input_keymap_entry *ke,
			     unsigned int *scancode)
{
	switch (ke->len) {
	case 1:
		*scancode = *((u8 *)ke->scancode);
		break;

	case 2:
		*scancode = *((u16 *)ke->scancode);
		break;

	case 4:
		*scancode = *((u32 *)ke->scancode);
		break;

	default:
		return -EINVAL;
	}

	return 0;
}
EXPORT_SYMBOL(input_scancode_to_scalar);

/*
 * Those routines handle the default case where no [gs]etkeycode() is
 * defined. In this case, an array indexed by the scancode is used.
 */

static unsigned int input_fetch_keycode(struct input_dev *dev,
					unsigned int index)
765 766
{
	switch (dev->keycodesize) {
767 768
	case 1:
		return ((u8 *)dev->keycode)[index];
769

770 771
	case 2:
		return ((u16 *)dev->keycode)[index];
772

773 774
	default:
		return ((u32 *)dev->keycode)[index];
775 776 777 778
	}
}

static int input_default_getkeycode(struct input_dev *dev,
779
				    struct input_keymap_entry *ke)
780
{
781 782 783
	unsigned int index;
	int error;

784 785 786
	if (!dev->keycodesize)
		return -EINVAL;

787 788 789 790 791 792 793 794 795
	if (ke->flags & INPUT_KEYMAP_BY_INDEX)
		index = ke->index;
	else {
		error = input_scancode_to_scalar(ke, &index);
		if (error)
			return error;
	}

	if (index >= dev->keycodemax)
796 797
		return -EINVAL;

798 799 800 801
	ke->keycode = input_fetch_keycode(dev, index);
	ke->index = index;
	ke->len = sizeof(index);
	memcpy(ke->scancode, &index, sizeof(index));
802 803 804 805 806

	return 0;
}

static int input_default_setkeycode(struct input_dev *dev,
807 808
				    const struct input_keymap_entry *ke,
				    unsigned int *old_keycode)
809
{
810 811
	unsigned int index;
	int error;
812 813
	int i;

814
	if (!dev->keycodesize)
815 816
		return -EINVAL;

817 818 819 820 821 822 823 824 825
	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
		index = ke->index;
	} else {
		error = input_scancode_to_scalar(ke, &index);
		if (error)
			return error;
	}

	if (index >= dev->keycodemax)
826 827
		return -EINVAL;

828
	if (dev->keycodesize < sizeof(ke->keycode) &&
829
			(ke->keycode >> (dev->keycodesize * 8)))
830 831 832 833 834
		return -EINVAL;

	switch (dev->keycodesize) {
		case 1: {
			u8 *k = (u8 *)dev->keycode;
835 836
			*old_keycode = k[index];
			k[index] = ke->keycode;
837 838 839 840
			break;
		}
		case 2: {
			u16 *k = (u16 *)dev->keycode;
841 842
			*old_keycode = k[index];
			k[index] = ke->keycode;
843 844 845 846
			break;
		}
		default: {
			u32 *k = (u32 *)dev->keycode;
847 848
			*old_keycode = k[index];
			k[index] = ke->keycode;
849 850 851 852
			break;
		}
	}

853 854
	__clear_bit(*old_keycode, dev->keybit);
	__set_bit(ke->keycode, dev->keybit);
855 856

	for (i = 0; i < dev->keycodemax; i++) {
857 858
		if (input_fetch_keycode(dev, i) == *old_keycode) {
			__set_bit(*old_keycode, dev->keybit);
859 860 861 862 863 864 865
			break; /* Setting the bit twice is useless, so break */
		}
	}

	return 0;
}

866 867 868
/**
 * input_get_keycode - retrieve keycode currently mapped to a given scancode
 * @dev: input device which keymap is being queried
869
 * @ke: keymap entry
870 871
 *
 * This function should be called by anyone interested in retrieving current
872
 * keymap. Presently evdev handlers use it.
873
 */
874
int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
875
{
876 877 878 879
	unsigned long flags;
	int retval;

	spin_lock_irqsave(&dev->event_lock, flags);
880
	retval = dev->getkeycode(dev, ke);
881
	spin_unlock_irqrestore(&dev->event_lock, flags);
882

883
	return retval;
884 885 886 887
}
EXPORT_SYMBOL(input_get_keycode);

/**
888
 * input_set_keycode - attribute a keycode to a given scancode
889
 * @dev: input device which keymap is being updated
890
 * @ke: new keymap entry
891 892 893 894
 *
 * This function should be called by anyone needing to update current
 * keymap. Presently keyboard and evdev handlers use it.
 */
895
int input_set_keycode(struct input_dev *dev,
896
		      const struct input_keymap_entry *ke)
897 898
{
	unsigned long flags;
899
	unsigned int old_keycode;
900 901
	int retval;

902
	if (ke->keycode > KEY_MAX)
903 904 905 906
		return -EINVAL;

	spin_lock_irqsave(&dev->event_lock, flags);

907
	retval = dev->setkeycode(dev, ke, &old_keycode);
908 909 910
	if (retval)
		goto out;

911 912 913
	/* Make sure KEY_RESERVED did not get enabled. */
	__clear_bit(KEY_RESERVED, dev->keybit);

914 915 916 917 918 919 920
	/*
	 * Simulate keyup event if keycode is not present
	 * in the keymap anymore
	 */
	if (test_bit(EV_KEY, dev->evbit) &&
	    !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
	    __test_and_clear_bit(old_keycode, dev->key)) {
921 922 923 924
		struct input_value vals[] =  {
			{ EV_KEY, old_keycode, 0 },
			input_value_sync
		};
925

926
		input_pass_values(dev, vals, ARRAY_SIZE(vals));
927 928 929 930 931 932 933 934
	}

 out:
	spin_unlock_irqrestore(&dev->event_lock, flags);

	return retval;
}
EXPORT_SYMBOL(input_set_keycode);
935

936
static const struct input_device_id *input_match_device(struct input_handler *handler,
Dmitry Torokhov's avatar
Dmitry Torokhov committed
937
							struct input_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
938
{
939
	const struct input_device_id *id;
Linus Torvalds's avatar
Linus Torvalds committed
940

941
	for (id = handler->id_table; id->flags || id->driver_info; id++) {
Linus Torvalds's avatar
Linus Torvalds committed
942 943

		if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
944
			if (id->bustype != dev->id.bustype)
Linus Torvalds's avatar
Linus Torvalds committed
945 946 947
				continue;

		if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
948
			if (id->vendor != dev->id.vendor)
Linus Torvalds's avatar
Linus Torvalds committed
949 950 951
				continue;

		if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
952
			if (id->product != dev->id.product)
Linus Torvalds's avatar
Linus Torvalds committed
953 954 955
				continue;

		if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
956
			if (id->version != dev->id.version)
Linus Torvalds's avatar
Linus Torvalds committed
957 958
				continue;

959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
		if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
			continue;

		if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
			continue;

		if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
			continue;

		if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
			continue;

		if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
			continue;

		if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
			continue;

		if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
			continue;

		if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
			continue;

		if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
			continue;
Linus Torvalds's avatar
Linus Torvalds committed
985

986 987
		if (!handler->match || handler->match(handler, dev))
			return id;
Linus Torvalds's avatar
Linus Torvalds committed
988 989 990 991 992
	}

	return NULL;
}

993 994 995 996 997
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	const struct input_device_id *id;
	int error;

998
	id = input_match_device(handler, dev);
999 1000 1001 1002 1003
	if (!id)
		return -ENODEV;

	error = handler->connect(handler, dev, id);
	if (error && error != -ENODEV)
1004 1005
		pr_err("failed to attach handler %s to device %s, error: %d\n",
		       handler->name, kobject_name(&dev->dev.kobj), error);
1006 1007 1008 1009

	return error;
}

1010 1011 1012 1013 1014 1015 1016
#ifdef CONFIG_COMPAT

static int input_bits_to_string(char *buf, int buf_size,
				unsigned long bits, bool skip_empty)
{
	int len = 0;

1017
	if (in_compat_syscall()) {
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
		u32 dword = bits >> 32;
		if (dword || !skip_empty)
			len += snprintf(buf, buf_size, "%x ", dword);

		dword = bits & 0xffffffffUL;
		if (dword || !skip_empty || len)
			len += snprintf(buf + len, max(buf_size - len, 0),
					"%x", dword);
	} else {
		if (bits || !skip_empty)
			len += snprintf(buf, buf_size, "%lx", bits);
	}

	return len;
}

#else /* !CONFIG_COMPAT */

static int input_bits_to_string(char *buf, int buf_size,
				unsigned long bits, bool skip_empty)
{
	return bits || !skip_empty ?
		snprintf(buf, buf_size, "%lx", bits) : 0;
}

#endif
1044

1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
#ifdef CONFIG_PROC_FS

static struct proc_dir_entry *proc_bus_input_dir;
static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
static int input_devices_state;

static inline void input_wakeup_procfs_readers(void)
{
	input_devices_state++;
	wake_up(&input_devices_poll_wait);
}

1057
static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
1058 1059
{
	poll_wait(file, &input_devices_poll_wait, wait);
1060 1061
	if (file->f_version != input_devices_state) {
		file->f_version = input_devices_state;
1062
		return POLLIN | POLLRDNORM;
1063
	}
1064

1065 1066 1067
	return 0;
}

1068 1069 1070 1071 1072 1073 1074 1075
union input_seq_state {
	struct {
		unsigned short pos;
		bool mutex_acquired;
	};
	void *p;
};

1076 1077
static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
{
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
	union input_seq_state *state = (union input_seq_state *)&seq->private;
	int error;

	/* We need to fit into seq->private pointer */
	BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));

	error = mutex_lock_interruptible(&input_mutex);
	if (error) {
		state->mutex_acquired = false;
		return ERR_PTR(error);
	}

	state->mutex_acquired = true;
1091

1092
	return seq_list_start(&input_dev_list, *pos);
1093
}
1094

1095 1096
static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
1097
	return seq_list_next(v, &input_dev_list, pos);
1098
}
1099

1100
static void input_seq_stop(struct seq_file *seq, void *v)
1101
{
1102 1103 1104 1105
	union input_seq_state *state = (union input_seq_state *)&seq->private;

	if (state->mutex_acquired)
		mutex_unlock(&input_mutex);
1106
}
1107

1108 1109 1110 1111
static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
				   unsigned long *bitmap, int max)
{
	int i;
1112 1113
	bool skip_empty = true;
	char buf[18];
1114

1115
	seq_printf(seq, "B: %s=", name);
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130

	for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
		if (input_bits_to_string(buf, sizeof(buf),
					 bitmap[i], skip_empty)) {
			skip_empty = false;
			seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
		}
	}

	/*
	 * If no output was produced print a single 0.
	 */
	if (skip_empty)
		seq_puts(seq, "0");

1131 1132
	seq_putc(seq, '\n');
}
1133

1134 1135 1136
static int input_devices_seq_show(struct seq_file *seq, void *v)
{
	struct input_dev *dev = container_of(v, struct input_dev, node);
1137
	const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1138 1139 1140 1141 1142 1143 1144 1145
	struct input_handle *handle;

	seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
		   dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);

	seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
	seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
	seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
1146
	seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1147 1148 1149 1150 1151 1152
	seq_printf(seq, "H: Handlers=");

	list_for_each_entry(handle, &dev->h_list, d_node)
		seq_printf(seq, "%s ", handle->name);
	seq_putc(seq, '\n');

1153 1154
	input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);

1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
	input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
	if (test_bit(EV_KEY, dev->evbit))
		input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
	if (test_bit(EV_REL, dev->evbit))
		input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
	if (test_bit(EV_ABS, dev->evbit))
		input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
	if (test_bit(EV_MSC, dev->evbit))
		input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
	if (test_bit(EV_LED, dev->evbit))
		input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
	if (test_bit(EV_SND, dev->evbit))
		input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
	if (test_bit(EV_FF, dev->evbit))
		input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
	if (test_bit(EV_SW, dev->evbit))
		input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);

	seq_putc(seq, '\n');

	kfree(path);
	return 0;
1177 1178
}

1179
static const struct seq_operations input_devices_seq_ops = {
1180 1181
	.start	= input_devices_seq_start,
	.next	= input_devices_seq_next,
1182
	.stop	= input_seq_stop,
1183 1184 1185 1186
	.show	= input_devices_seq_show,
};

static int input_proc_devices_open(struct inode *inode, struct file *file)
1187
{
1188 1189 1190
	return seq_open(file, &input_devices_seq_ops);
}

1191
static const struct file_operations input_devices_fileops = {
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
	.owner		= THIS_MODULE,
	.open		= input_proc_devices_open,
	.poll		= input_proc_devices_poll,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};

static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
{
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
	union input_seq_state *state = (union input_seq_state *)&seq->private;
	int error;

	/* We need to fit into seq->private pointer */
	BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));

	error = mutex_lock_interruptible(&input_mutex);
	if (error) {
		state->mutex_acquired = false;
		return ERR_PTR(error);
	}

	state->mutex_acquired = true;
	state->pos = *pos;
1216

1217
	return seq_list_start(&input_handler_list, *pos);
1218
}
1219

1220 1221
static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
1222
	union input_seq_state *state = (union input_seq_state *)&seq->private;