1/*
   2 * The input core
   3 *
   4 * Copyright (c) 1999-2002 Vojtech Pavlik
   5 */
   6
   7/*
   8 * This program is free software; you can redistribute it and/or modify it
   9 * under the terms of the GNU General Public License version 2 as published by
  10 * the Free Software Foundation.
  11 */
  12
  13#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
  14
  15#include <linux/init.h>
  16#include <linux/types.h>
  17#include <linux/idr.h>
  18#include <linux/input/mt.h>
  19#include <linux/module.h>
  20#include <linux/slab.h>
  21#include <linux/random.h>
  22#include <linux/major.h>
  23#include <linux/proc_fs.h>
  24#include <linux/sched.h>
  25#include <linux/seq_file.h>
  26#include <linux/poll.h>
  27#include <linux/device.h>
  28#include <linux/mutex.h>
  29#include <linux/rcupdate.h>
  30#include "input-compat.h"
 
  31
  32MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  33MODULE_DESCRIPTION("Input core");
  34MODULE_LICENSE("GPL");
  35
  36#define INPUT_MAX_CHAR_DEVICES		1024
  37#define INPUT_FIRST_DYNAMIC_DEV		256
  38static DEFINE_IDA(input_ida);
  39
  40static LIST_HEAD(input_dev_list);
  41static LIST_HEAD(input_handler_list);
  42
  43/*
  44 * input_mutex protects access to both input_dev_list and input_handler_list.
  45 * This also causes input_[un]register_device and input_[un]register_handler
  46 * be mutually exclusive which simplifies locking in drivers implementing
  47 * input handlers.
  48 */
  49static DEFINE_MUTEX(input_mutex);
  50
  51static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 };
  52
  53static inline int is_event_supported(unsigned int code,
  54				     unsigned long *bm, unsigned int max)
  55{
  56	return code <= max && test_bit(code, bm);
  57}
  58
  59static int input_defuzz_abs_event(int value, int old_val, int fuzz)
  60{
  61	if (fuzz) {
  62		if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
  63			return old_val;
  64
  65		if (value > old_val - fuzz && value < old_val + fuzz)
  66			return (old_val * 3 + value) / 4;
  67
  68		if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
  69			return (old_val + value) / 2;
  70	}
  71
  72	return value;
  73}
  74
  75static void input_start_autorepeat(struct input_dev *dev, int code)
  76{
  77	if (test_bit(EV_REP, dev->evbit) &&
  78	    dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
  79	    dev->timer.data) {
  80		dev->repeat_key = code;
  81		mod_timer(&dev->timer,
  82			  jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
  83	}
  84}
  85
  86static void input_stop_autorepeat(struct input_dev *dev)
  87{
  88	del_timer(&dev->timer);
  89}
  90
  91/*
  92 * Pass event first through all filters and then, if event has not been
  93 * filtered out, through all open handles. This function is called with
  94 * dev->event_lock held and interrupts disabled.
  95 */
  96static unsigned int input_to_handler(struct input_handle *handle,
  97			struct input_value *vals, unsigned int count)
  98{
  99	struct input_handler *handler = handle->handler;
 100	struct input_value *end = vals;
 101	struct input_value *v;
 102
 103	for (v = vals; v != vals + count; v++) {
 104		if (handler->filter &&
 105		    handler->filter(handle, v->type, v->code, v->value))
 106			continue;
 107		if (end != v)
 108			*end = *v;
 109		end++;
 
 
 110	}
 111
 112	count = end - vals;
 113	if (!count)
 114		return 0;
 115
 116	if (handler->events)
 117		handler->events(handle, vals, count);
 118	else if (handler->event)
 119		for (v = vals; v != end; v++)
 120			handler->event(handle, v->type, v->code, v->value);
 121
 122	return count;
 123}
 124
 125/*
 126 * Pass values first through all filters and then, if event has not been
 127 * filtered out, through all open handles. This function is called with
 128 * dev->event_lock held and interrupts disabled.
 129 */
 130static void input_pass_values(struct input_dev *dev,
 131			      struct input_value *vals, unsigned int count)
 132{
 133	struct input_handle *handle;
 134	struct input_value *v;
 135
 136	if (!count)
 137		return;
 138
 139	rcu_read_lock();
 140
 141	handle = rcu_dereference(dev->grab);
 142	if (handle) {
 143		count = input_to_handler(handle, vals, count);
 144	} else {
 145		list_for_each_entry_rcu(handle, &dev->h_list, d_node)
 146			if (handle->open)
 147				count = input_to_handler(handle, vals, count);
 
 
 
 148	}
 149
 150	rcu_read_unlock();
 151
 152	add_input_randomness(vals->type, vals->code, vals->value);
 153
 154	/* trigger auto repeat for key events */
 155	for (v = vals; v != vals + count; v++) {
 156		if (v->type == EV_KEY && v->value != 2) {
 157			if (v->value)
 158				input_start_autorepeat(dev, v->code);
 159			else
 160				input_stop_autorepeat(dev);
 
 
 161		}
 162	}
 163}
 164
 165static void input_pass_event(struct input_dev *dev,
 166			     unsigned int type, unsigned int code, int value)
 167{
 168	struct input_value vals[] = { { type, code, value } };
 169
 170	input_pass_values(dev, vals, ARRAY_SIZE(vals));
 171}
 172
 173/*
 174 * Generate software autorepeat event. Note that we take
 175 * dev->event_lock here to avoid racing with input_event
 176 * which may cause keys get "stuck".
 177 */
 178static void input_repeat_key(unsigned long data)
 179{
 180	struct input_dev *dev = (void *) data;
 181	unsigned long flags;
 182
 183	spin_lock_irqsave(&dev->event_lock, flags);
 184
 185	if (test_bit(dev->repeat_key, dev->key) &&
 186	    is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
 187		struct input_value vals[] =  {
 188			{ EV_KEY, dev->repeat_key, 2 },
 189			input_value_sync
 190		};
 191
 
 192		input_pass_values(dev, vals, ARRAY_SIZE(vals));
 193
 194		if (dev->rep[REP_PERIOD])
 195			mod_timer(&dev->timer, jiffies +
 196					msecs_to_jiffies(dev->rep[REP_PERIOD]));
 197	}
 198
 199	spin_unlock_irqrestore(&dev->event_lock, flags);
 200}
 201
 202#define INPUT_IGNORE_EVENT	0
 203#define INPUT_PASS_TO_HANDLERS	1
 204#define INPUT_PASS_TO_DEVICE	2
 205#define INPUT_SLOT		4
 206#define INPUT_FLUSH		8
 207#define INPUT_PASS_TO_ALL	(INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
 208
 209static int input_handle_abs_event(struct input_dev *dev,
 210				  unsigned int code, int *pval)
 211{
 212	struct input_mt *mt = dev->mt;
 213	bool is_mt_event;
 214	int *pold;
 215
 216	if (code == ABS_MT_SLOT) {
 217		/*
 218		 * "Stage" the event; we'll flush it later, when we
 219		 * get actual touch data.
 220		 */
 221		if (mt && *pval >= 0 && *pval < mt->num_slots)
 222			mt->slot = *pval;
 223
 224		return INPUT_IGNORE_EVENT;
 225	}
 226
 227	is_mt_event = input_is_mt_value(code);
 228
 229	if (!is_mt_event) {
 230		pold = &dev->absinfo[code].value;
 231	} else if (mt) {
 232		pold = &mt->slots[mt->slot].abs[code - ABS_MT_FIRST];
 233	} else {
 234		/*
 235		 * Bypass filtering for multi-touch events when
 236		 * not employing slots.
 237		 */
 238		pold = NULL;
 239	}
 240
 241	if (pold) {
 242		*pval = input_defuzz_abs_event(*pval, *pold,
 243						dev->absinfo[code].fuzz);
 244		if (*pold == *pval)
 245			return INPUT_IGNORE_EVENT;
 246
 247		*pold = *pval;
 248	}
 249
 250	/* Flush pending "slot" event */
 251	if (is_mt_event && mt && mt->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
 252		input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
 253		return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
 254	}
 255
 256	return INPUT_PASS_TO_HANDLERS;
 257}
 258
 259static int input_get_disposition(struct input_dev *dev,
 260			  unsigned int type, unsigned int code, int value)
 261{
 262	int disposition = INPUT_IGNORE_EVENT;
 
 263
 264	switch (type) {
 265
 266	case EV_SYN:
 267		switch (code) {
 268		case SYN_CONFIG:
 269			disposition = INPUT_PASS_TO_ALL;
 270			break;
 271
 272		case SYN_REPORT:
 273			disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
 274			break;
 275		case SYN_MT_REPORT:
 276			disposition = INPUT_PASS_TO_HANDLERS;
 277			break;
 278		}
 279		break;
 280
 281	case EV_KEY:
 282		if (is_event_supported(code, dev->keybit, KEY_MAX)) {
 283
 284			/* auto-repeat bypasses state updates */
 285			if (value == 2) {
 286				disposition = INPUT_PASS_TO_HANDLERS;
 287				break;
 288			}
 289
 290			if (!!test_bit(code, dev->key) != !!value) {
 291
 292				__change_bit(code, dev->key);
 293				disposition = INPUT_PASS_TO_HANDLERS;
 294			}
 295		}
 296		break;
 297
 298	case EV_SW:
 299		if (is_event_supported(code, dev->swbit, SW_MAX) &&
 300		    !!test_bit(code, dev->sw) != !!value) {
 301
 302			__change_bit(code, dev->sw);
 303			disposition = INPUT_PASS_TO_HANDLERS;
 304		}
 305		break;
 306
 307	case EV_ABS:
 308		if (is_event_supported(code, dev->absbit, ABS_MAX))
 309			disposition = input_handle_abs_event(dev, code, &value);
 310
 311		break;
 312
 313	case EV_REL:
 314		if (is_event_supported(code, dev->relbit, REL_MAX) && value)
 315			disposition = INPUT_PASS_TO_HANDLERS;
 316
 317		break;
 318
 319	case EV_MSC:
 320		if (is_event_supported(code, dev->mscbit, MSC_MAX))
 321			disposition = INPUT_PASS_TO_ALL;
 322
 323		break;
 324
 325	case EV_LED:
 326		if (is_event_supported(code, dev->ledbit, LED_MAX) &&
 327		    !!test_bit(code, dev->led) != !!value) {
 328
 329			__change_bit(code, dev->led);
 330			disposition = INPUT_PASS_TO_ALL;
 331		}
 332		break;
 333
 334	case EV_SND:
 335		if (is_event_supported(code, dev->sndbit, SND_MAX)) {
 336
 337			if (!!test_bit(code, dev->snd) != !!value)
 338				__change_bit(code, dev->snd);
 339			disposition = INPUT_PASS_TO_ALL;
 340		}
 341		break;
 342
 343	case EV_REP:
 344		if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
 345			dev->rep[code] = value;
 346			disposition = INPUT_PASS_TO_ALL;
 347		}
 348		break;
 349
 350	case EV_FF:
 351		if (value >= 0)
 352			disposition = INPUT_PASS_TO_ALL;
 353		break;
 354
 355	case EV_PWR:
 356		disposition = INPUT_PASS_TO_ALL;
 357		break;
 358	}
 359
 
 360	return disposition;
 361}
 362
 363static void input_handle_event(struct input_dev *dev,
 364			       unsigned int type, unsigned int code, int value)
 365{
 366	int disposition;
 367
 368	disposition = input_get_disposition(dev, type, code, value);
 
 
 
 
 
 
 369
 370	if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
 371		dev->event(dev, type, code, value);
 372
 373	if (!dev->vals)
 374		return;
 375
 376	if (disposition & INPUT_PASS_TO_HANDLERS) {
 377		struct input_value *v;
 378
 379		if (disposition & INPUT_SLOT) {
 380			v = &dev->vals[dev->num_vals++];
 381			v->type = EV_ABS;
 382			v->code = ABS_MT_SLOT;
 383			v->value = dev->mt->slot;
 384		}
 385
 386		v = &dev->vals[dev->num_vals++];
 387		v->type = type;
 388		v->code = code;
 389		v->value = value;
 390	}
 391
 392	if (disposition & INPUT_FLUSH) {
 393		if (dev->num_vals >= 2)
 394			input_pass_values(dev, dev->vals, dev->num_vals);
 395		dev->num_vals = 0;
 
 
 
 
 
 
 
 396	} else if (dev->num_vals >= dev->max_vals - 2) {
 397		dev->vals[dev->num_vals++] = input_value_sync;
 398		input_pass_values(dev, dev->vals, dev->num_vals);
 399		dev->num_vals = 0;
 400	}
 401
 402}
 403
 404/**
 405 * input_event() - report new input event
 406 * @dev: device that generated the event
 407 * @type: type of the event
 408 * @code: event code
 409 * @value: value of the event
 410 *
 411 * This function should be used by drivers implementing various input
 412 * devices to report input events. See also input_inject_event().
 413 *
 414 * NOTE: input_event() may be safely used right after input device was
 415 * allocated with input_allocate_device(), even before it is registered
 416 * with input_register_device(), but the event will not reach any of the
 417 * input handlers. Such early invocation of input_event() may be used
 418 * to 'seed' initial state of a switch or initial position of absolute
 419 * axis, etc.
 420 */
 421void input_event(struct input_dev *dev,
 422		 unsigned int type, unsigned int code, int value)
 423{
 424	unsigned long flags;
 425
 426	if (is_event_supported(type, dev->evbit, EV_MAX)) {
 427
 428		spin_lock_irqsave(&dev->event_lock, flags);
 429		input_handle_event(dev, type, code, value);
 430		spin_unlock_irqrestore(&dev->event_lock, flags);
 431	}
 432}
 433EXPORT_SYMBOL(input_event);
 434
 435/**
 436 * input_inject_event() - send input event from input handler
 437 * @handle: input handle to send event through
 438 * @type: type of the event
 439 * @code: event code
 440 * @value: value of the event
 441 *
 442 * Similar to input_event() but will ignore event if device is
 443 * "grabbed" and handle injecting event is not the one that owns
 444 * the device.
 445 */
 446void input_inject_event(struct input_handle *handle,
 447			unsigned int type, unsigned int code, int value)
 448{
 449	struct input_dev *dev = handle->dev;
 450	struct input_handle *grab;
 451	unsigned long flags;
 452
 453	if (is_event_supported(type, dev->evbit, EV_MAX)) {
 454		spin_lock_irqsave(&dev->event_lock, flags);
 455
 456		rcu_read_lock();
 457		grab = rcu_dereference(dev->grab);
 458		if (!grab || grab == handle)
 459			input_handle_event(dev, type, code, value);
 460		rcu_read_unlock();
 461
 462		spin_unlock_irqrestore(&dev->event_lock, flags);
 463	}
 464}
 465EXPORT_SYMBOL(input_inject_event);
 466
 467/**
 468 * input_alloc_absinfo - allocates array of input_absinfo structs
 469 * @dev: the input device emitting absolute events
 470 *
 471 * If the absinfo struct the caller asked for is already allocated, this
 472 * functions will not do anything.
 473 */
 474void input_alloc_absinfo(struct input_dev *dev)
 475{
 476	if (!dev->absinfo)
 477		dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
 478					GFP_KERNEL);
 479
 480	WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
 
 
 
 
 
 
 
 
 
 481}
 482EXPORT_SYMBOL(input_alloc_absinfo);
 483
 484void input_set_abs_params(struct input_dev *dev, unsigned int axis,
 485			  int min, int max, int fuzz, int flat)
 486{
 487	struct input_absinfo *absinfo;
 488
 489	input_alloc_absinfo(dev);
 490	if (!dev->absinfo)
 491		return;
 492
 493	absinfo = &dev->absinfo[axis];
 494	absinfo->minimum = min;
 495	absinfo->maximum = max;
 496	absinfo->fuzz = fuzz;
 497	absinfo->flat = flat;
 498
 499	dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
 
 500}
 501EXPORT_SYMBOL(input_set_abs_params);
 502
 503
 504/**
 505 * input_grab_device - grabs device for exclusive use
 506 * @handle: input handle that wants to own the device
 507 *
 508 * When a device is grabbed by an input handle all events generated by
 509 * the device are delivered only to this handle. Also events injected
 510 * by other input handles are ignored while device is grabbed.
 511 */
 512int input_grab_device(struct input_handle *handle)
 513{
 514	struct input_dev *dev = handle->dev;
 515	int retval;
 516
 517	retval = mutex_lock_interruptible(&dev->mutex);
 518	if (retval)
 519		return retval;
 520
 521	if (dev->grab) {
 522		retval = -EBUSY;
 523		goto out;
 524	}
 525
 526	rcu_assign_pointer(dev->grab, handle);
 527
 528 out:
 529	mutex_unlock(&dev->mutex);
 530	return retval;
 531}
 532EXPORT_SYMBOL(input_grab_device);
 533
 534static void __input_release_device(struct input_handle *handle)
 535{
 536	struct input_dev *dev = handle->dev;
 537	struct input_handle *grabber;
 538
 539	grabber = rcu_dereference_protected(dev->grab,
 540					    lockdep_is_held(&dev->mutex));
 541	if (grabber == handle) {
 542		rcu_assign_pointer(dev->grab, NULL);
 543		/* Make sure input_pass_event() notices that grab is gone */
 544		synchronize_rcu();
 545
 546		list_for_each_entry(handle, &dev->h_list, d_node)
 547			if (handle->open && handle->handler->start)
 548				handle->handler->start(handle);
 549	}
 550}
 551
 552/**
 553 * input_release_device - release previously grabbed device
 554 * @handle: input handle that owns the device
 555 *
 556 * Releases previously grabbed device so that other input handles can
 557 * start receiving input events. Upon release all handlers attached
 558 * to the device have their start() method called so they have a change
 559 * to synchronize device state with the rest of the system.
 560 */
 561void input_release_device(struct input_handle *handle)
 562{
 563	struct input_dev *dev = handle->dev;
 564
 565	mutex_lock(&dev->mutex);
 566	__input_release_device(handle);
 567	mutex_unlock(&dev->mutex);
 568}
 569EXPORT_SYMBOL(input_release_device);
 570
 571/**
 572 * input_open_device - open input device
 573 * @handle: handle through which device is being accessed
 574 *
 575 * This function should be called by input handlers when they
 576 * want to start receive events from given input device.
 577 */
 578int input_open_device(struct input_handle *handle)
 579{
 580	struct input_dev *dev = handle->dev;
 581	int retval;
 582
 583	retval = mutex_lock_interruptible(&dev->mutex);
 584	if (retval)
 585		return retval;
 586
 587	if (dev->going_away) {
 588		retval = -ENODEV;
 589		goto out;
 590	}
 591
 592	handle->open++;
 593
 594	if (!dev->users++ && dev->open)
 595		retval = dev->open(dev);
 
 
 
 
 
 596
 597	if (retval) {
 598		dev->users--;
 599		if (!--handle->open) {
 
 
 600			/*
 601			 * Make sure we are not delivering any more events
 602			 * through this handle
 603			 */
 604			synchronize_rcu();
 
 605		}
 606	}
 607
 
 
 
 608 out:
 609	mutex_unlock(&dev->mutex);
 610	return retval;
 611}
 612EXPORT_SYMBOL(input_open_device);
 613
 614int input_flush_device(struct input_handle *handle, struct file *file)
 615{
 616	struct input_dev *dev = handle->dev;
 617	int retval;
 618
 619	retval = mutex_lock_interruptible(&dev->mutex);
 620	if (retval)
 621		return retval;
 622
 623	if (dev->flush)
 624		retval = dev->flush(dev, file);
 625
 626	mutex_unlock(&dev->mutex);
 627	return retval;
 628}
 629EXPORT_SYMBOL(input_flush_device);
 630
 631/**
 632 * input_close_device - close input device
 633 * @handle: handle through which device is being accessed
 634 *
 635 * This function should be called by input handlers when they
 636 * want to stop receive events from given input device.
 637 */
 638void input_close_device(struct input_handle *handle)
 639{
 640	struct input_dev *dev = handle->dev;
 641
 642	mutex_lock(&dev->mutex);
 643
 644	__input_release_device(handle);
 645
 646	if (!--dev->users && dev->close)
 647		dev->close(dev);
 
 
 
 
 648
 649	if (!--handle->open) {
 650		/*
 651		 * synchronize_rcu() makes sure that input_pass_event()
 652		 * completed and that no more input events are delivered
 653		 * through this handle
 654		 */
 655		synchronize_rcu();
 656	}
 657
 658	mutex_unlock(&dev->mutex);
 659}
 660EXPORT_SYMBOL(input_close_device);
 661
 662/*
 663 * Simulate keyup events for all keys that are marked as pressed.
 664 * The function must be called with dev->event_lock held.
 665 */
 666static void input_dev_release_keys(struct input_dev *dev)
 667{
 
 668	int code;
 669
 670	if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
 671		for (code = 0; code <= KEY_MAX; code++) {
 672			if (is_event_supported(code, dev->keybit, KEY_MAX) &&
 673			    __test_and_clear_bit(code, dev->key)) {
 674				input_pass_event(dev, EV_KEY, code, 0);
 675			}
 676		}
 677		input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
 
 
 
 
 678	}
 679}
 680
 681/*
 682 * Prepare device for unregistering
 683 */
 684static void input_disconnect_device(struct input_dev *dev)
 685{
 686	struct input_handle *handle;
 687
 688	/*
 689	 * Mark device as going away. Note that we take dev->mutex here
 690	 * not to protect access to dev->going_away but rather to ensure
 691	 * that there are no threads in the middle of input_open_device()
 692	 */
 693	mutex_lock(&dev->mutex);
 694	dev->going_away = true;
 695	mutex_unlock(&dev->mutex);
 696
 697	spin_lock_irq(&dev->event_lock);
 698
 699	/*
 700	 * Simulate keyup events for all pressed keys so that handlers
 701	 * are not left with "stuck" keys. The driver may continue
 702	 * generate events even after we done here but they will not
 703	 * reach any handlers.
 704	 */
 705	input_dev_release_keys(dev);
 706
 707	list_for_each_entry(handle, &dev->h_list, d_node)
 708		handle->open = 0;
 709
 710	spin_unlock_irq(&dev->event_lock);
 711}
 712
 713/**
 714 * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
 715 * @ke: keymap entry containing scancode to be converted.
 716 * @scancode: pointer to the location where converted scancode should
 717 *	be stored.
 718 *
 719 * This function is used to convert scancode stored in &struct keymap_entry
 720 * into scalar form understood by legacy keymap handling methods. These
 721 * methods expect scancodes to be represented as 'unsigned int'.
 722 */
 723int input_scancode_to_scalar(const struct input_keymap_entry *ke,
 724			     unsigned int *scancode)
 725{
 726	switch (ke->len) {
 727	case 1:
 728		*scancode = *((u8 *)ke->scancode);
 729		break;
 730
 731	case 2:
 732		*scancode = *((u16 *)ke->scancode);
 733		break;
 734
 735	case 4:
 736		*scancode = *((u32 *)ke->scancode);
 737		break;
 738
 739	default:
 740		return -EINVAL;
 741	}
 742
 743	return 0;
 744}
 745EXPORT_SYMBOL(input_scancode_to_scalar);
 746
 747/*
 748 * Those routines handle the default case where no [gs]etkeycode() is
 749 * defined. In this case, an array indexed by the scancode is used.
 750 */
 751
 752static unsigned int input_fetch_keycode(struct input_dev *dev,
 753					unsigned int index)
 754{
 755	switch (dev->keycodesize) {
 756	case 1:
 757		return ((u8 *)dev->keycode)[index];
 758
 759	case 2:
 760		return ((u16 *)dev->keycode)[index];
 761
 762	default:
 763		return ((u32 *)dev->keycode)[index];
 764	}
 765}
 766
 767static int input_default_getkeycode(struct input_dev *dev,
 768				    struct input_keymap_entry *ke)
 769{
 770	unsigned int index;
 771	int error;
 772
 773	if (!dev->keycodesize)
 774		return -EINVAL;
 775
 776	if (ke->flags & INPUT_KEYMAP_BY_INDEX)
 777		index = ke->index;
 778	else {
 779		error = input_scancode_to_scalar(ke, &index);
 780		if (error)
 781			return error;
 782	}
 783
 784	if (index >= dev->keycodemax)
 785		return -EINVAL;
 786
 787	ke->keycode = input_fetch_keycode(dev, index);
 788	ke->index = index;
 789	ke->len = sizeof(index);
 790	memcpy(ke->scancode, &index, sizeof(index));
 791
 792	return 0;
 793}
 794
 795static int input_default_setkeycode(struct input_dev *dev,
 796				    const struct input_keymap_entry *ke,
 797				    unsigned int *old_keycode)
 798{
 799	unsigned int index;
 800	int error;
 801	int i;
 802
 803	if (!dev->keycodesize)
 804		return -EINVAL;
 805
 806	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
 807		index = ke->index;
 808	} else {
 809		error = input_scancode_to_scalar(ke, &index);
 810		if (error)
 811			return error;
 812	}
 813
 814	if (index >= dev->keycodemax)
 815		return -EINVAL;
 816
 817	if (dev->keycodesize < sizeof(ke->keycode) &&
 818			(ke->keycode >> (dev->keycodesize * 8)))
 819		return -EINVAL;
 820
 821	switch (dev->keycodesize) {
 822		case 1: {
 823			u8 *k = (u8 *)dev->keycode;
 824			*old_keycode = k[index];
 825			k[index] = ke->keycode;
 826			break;
 827		}
 828		case 2: {
 829			u16 *k = (u16 *)dev->keycode;
 830			*old_keycode = k[index];
 831			k[index] = ke->keycode;
 832			break;
 833		}
 834		default: {
 835			u32 *k = (u32 *)dev->keycode;
 836			*old_keycode = k[index];
 837			k[index] = ke->keycode;
 838			break;
 839		}
 840	}
 841
 842	__clear_bit(*old_keycode, dev->keybit);
 843	__set_bit(ke->keycode, dev->keybit);
 844
 845	for (i = 0; i < dev->keycodemax; i++) {
 846		if (input_fetch_keycode(dev, i) == *old_keycode) {
 847			__set_bit(*old_keycode, dev->keybit);
 848			break; /* Setting the bit twice is useless, so break */
 
 849		}
 850	}
 851
 
 852	return 0;
 853}
 854
 855/**
 856 * input_get_keycode - retrieve keycode currently mapped to a given scancode
 857 * @dev: input device which keymap is being queried
 858 * @ke: keymap entry
 859 *
 860 * This function should be called by anyone interested in retrieving current
 861 * keymap. Presently evdev handlers use it.
 862 */
 863int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
 864{
 865	unsigned long flags;
 866	int retval;
 867
 868	spin_lock_irqsave(&dev->event_lock, flags);
 869	retval = dev->getkeycode(dev, ke);
 870	spin_unlock_irqrestore(&dev->event_lock, flags);
 871
 872	return retval;
 873}
 874EXPORT_SYMBOL(input_get_keycode);
 875
 876/**
 877 * input_set_keycode - attribute a keycode to a given scancode
 878 * @dev: input device which keymap is being updated
 879 * @ke: new keymap entry
 880 *
 881 * This function should be called by anyone needing to update current
 882 * keymap. Presently keyboard and evdev handlers use it.
 883 */
 884int input_set_keycode(struct input_dev *dev,
 885		      const struct input_keymap_entry *ke)
 886{
 887	unsigned long flags;
 888	unsigned int old_keycode;
 889	int retval;
 890
 891	if (ke->keycode > KEY_MAX)
 892		return -EINVAL;
 893
 894	spin_lock_irqsave(&dev->event_lock, flags);
 895
 896	retval = dev->setkeycode(dev, ke, &old_keycode);
 897	if (retval)
 898		goto out;
 899
 900	/* Make sure KEY_RESERVED did not get enabled. */
 901	__clear_bit(KEY_RESERVED, dev->keybit);
 902
 903	/*
 904	 * Simulate keyup event if keycode is not present
 905	 * in the keymap anymore
 906	 */
 907	if (test_bit(EV_KEY, dev->evbit) &&
 908	    !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
 909	    __test_and_clear_bit(old_keycode, dev->key)) {
 
 
 
 
 910		struct input_value vals[] =  {
 911			{ EV_KEY, old_keycode, 0 },
 912			input_value_sync
 913		};
 914
 915		input_pass_values(dev, vals, ARRAY_SIZE(vals));
 916	}
 917
 918 out:
 919	spin_unlock_irqrestore(&dev->event_lock, flags);
 920
 921	return retval;
 922}
 923EXPORT_SYMBOL(input_set_keycode);
 924
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 925static const struct input_device_id *input_match_device(struct input_handler *handler,
 926							struct input_dev *dev)
 927{
 928	const struct input_device_id *id;
 929
 930	for (id = handler->id_table; id->flags || id->driver_info; id++) {
 931
 932		if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
 933			if (id->bustype != dev->id.bustype)
 934				continue;
 935
 936		if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
 937			if (id->vendor != dev->id.vendor)
 938				continue;
 939
 940		if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
 941			if (id->product != dev->id.product)
 942				continue;
 943
 944		if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
 945			if (id->version != dev->id.version)
 946				continue;
 947
 948		if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
 949			continue;
 950
 951		if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
 952			continue;
 953
 954		if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
 955			continue;
 956
 957		if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
 958			continue;
 959
 960		if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
 961			continue;
 962
 963		if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
 964			continue;
 965
 966		if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
 967			continue;
 968
 969		if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
 970			continue;
 971
 972		if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
 973			continue;
 974
 975		if (!handler->match || handler->match(handler, dev))
 976			return id;
 
 977	}
 978
 979	return NULL;
 980}
 981
 982static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
 983{
 984	const struct input_device_id *id;
 985	int error;
 986
 987	id = input_match_device(handler, dev);
 988	if (!id)
 989		return -ENODEV;
 990
 991	error = handler->connect(handler, dev, id);
 992	if (error && error != -ENODEV)
 993		pr_err("failed to attach handler %s to device %s, error: %d\n",
 994		       handler->name, kobject_name(&dev->dev.kobj), error);
 995
 996	return error;
 997}
 998
 999#ifdef CONFIG_COMPAT
1000
1001static int input_bits_to_string(char *buf, int buf_size,
1002				unsigned long bits, bool skip_empty)
1003{
1004	int len = 0;
1005
1006	if (INPUT_COMPAT_TEST) {
1007		u32 dword = bits >> 32;
1008		if (dword || !skip_empty)
1009			len += snprintf(buf, buf_size, "%x ", dword);
1010
1011		dword = bits & 0xffffffffUL;
1012		if (dword || !skip_empty || len)
1013			len += snprintf(buf + len, max(buf_size - len, 0),
1014					"%x", dword);
1015	} else {
1016		if (bits || !skip_empty)
1017			len += snprintf(buf, buf_size, "%lx", bits);
1018	}
1019
1020	return len;
1021}
1022
1023#else /* !CONFIG_COMPAT */
1024
1025static int input_bits_to_string(char *buf, int buf_size,
1026				unsigned long bits, bool skip_empty)
1027{
1028	return bits || !skip_empty ?
1029		snprintf(buf, buf_size, "%lx", bits) : 0;
1030}
1031
1032#endif
1033
1034#ifdef CONFIG_PROC_FS
1035
1036static struct proc_dir_entry *proc_bus_input_dir;
1037static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
1038static int input_devices_state;
1039
1040static inline void input_wakeup_procfs_readers(void)
1041{
1042	input_devices_state++;
1043	wake_up(&input_devices_poll_wait);
1044}
1045
1046static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
1047{
1048	poll_wait(file, &input_devices_poll_wait, wait);
1049	if (file->f_version != input_devices_state) {
1050		file->f_version = input_devices_state;
1051		return POLLIN | POLLRDNORM;
1052	}
1053
1054	return 0;
1055}
1056
1057union input_seq_state {
1058	struct {
1059		unsigned short pos;
1060		bool mutex_acquired;
1061	};
1062	void *p;
1063};
1064
1065static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
1066{
1067	union input_seq_state *state = (union input_seq_state *)&seq->private;
1068	int error;
1069
1070	/* We need to fit into seq->private pointer */
1071	BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1072
1073	error = mutex_lock_interruptible(&input_mutex);
1074	if (error) {
1075		state->mutex_acquired = false;
1076		return ERR_PTR(error);
1077	}
1078
1079	state->mutex_acquired = true;
1080
1081	return seq_list_start(&input_dev_list, *pos);
1082}
1083
1084static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1085{
1086	return seq_list_next(v, &input_dev_list, pos);
1087}
1088
1089static void input_seq_stop(struct seq_file *seq, void *v)
1090{
1091	union input_seq_state *state = (union input_seq_state *)&seq->private;
1092
1093	if (state->mutex_acquired)
1094		mutex_unlock(&input_mutex);
1095}
1096
1097static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
1098				   unsigned long *bitmap, int max)
1099{
1100	int i;
1101	bool skip_empty = true;
1102	char buf[18];
1103
1104	seq_printf(seq, "B: %s=", name);
1105
1106	for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1107		if (input_bits_to_string(buf, sizeof(buf),
1108					 bitmap[i], skip_empty)) {
1109			skip_empty = false;
1110			seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
1111		}
1112	}
1113
1114	/*
1115	 * If no output was produced print a single 0.
1116	 */
1117	if (skip_empty)
1118		seq_puts(seq, "0");
1119
1120	seq_putc(seq, '\n');
1121}
1122
1123static int input_devices_seq_show(struct seq_file *seq, void *v)
1124{
1125	struct input_dev *dev = container_of(v, struct input_dev, node);
1126	const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1127	struct input_handle *handle;
1128
1129	seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1130		   dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
1131
1132	seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1133	seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1134	seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
1135	seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1136	seq_printf(seq, "H: Handlers=");
1137
1138	list_for_each_entry(handle, &dev->h_list, d_node)
1139		seq_printf(seq, "%s ", handle->name);
1140	seq_putc(seq, '\n');
1141
1142	input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);
1143
1144	input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1145	if (test_bit(EV_KEY, dev->evbit))
1146		input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1147	if (test_bit(EV_REL, dev->evbit))
1148		input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1149	if (test_bit(EV_ABS, dev->evbit))
1150		input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1151	if (test_bit(EV_MSC, dev->evbit))
1152		input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1153	if (test_bit(EV_LED, dev->evbit))
1154		input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1155	if (test_bit(EV_SND, dev->evbit))
1156		input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1157	if (test_bit(EV_FF, dev->evbit))
1158		input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1159	if (test_bit(EV_SW, dev->evbit))
1160		input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
1161
1162	seq_putc(seq, '\n');
1163
1164	kfree(path);
1165	return 0;
1166}
1167
1168static const struct seq_operations input_devices_seq_ops = {
1169	.start	= input_devices_seq_start,
1170	.next	= input_devices_seq_next,
1171	.stop	= input_seq_stop,
1172	.show	= input_devices_seq_show,
1173};
1174
1175static int input_proc_devices_open(struct inode *inode, struct file *file)
1176{
1177	return seq_open(file, &input_devices_seq_ops);
1178}
1179
1180static const struct file_operations input_devices_fileops = {
1181	.owner		= THIS_MODULE,
1182	.open		= input_proc_devices_open,
1183	.poll		= input_proc_devices_poll,
1184	.read		= seq_read,
1185	.llseek		= seq_lseek,
1186	.release	= seq_release,
1187};
1188
1189static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1190{
1191	union input_seq_state *state = (union input_seq_state *)&seq->private;
1192	int error;
1193
1194	/* We need to fit into seq->private pointer */
1195	BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1196
1197	error = mutex_lock_interruptible(&input_mutex);
1198	if (error) {
1199		state->mutex_acquired = false;
1200		return ERR_PTR(error);
1201	}
1202
1203	state->mutex_acquired = true;
1204	state->pos = *pos;
1205
1206	return seq_list_start(&input_handler_list, *pos);
1207}
1208
1209static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1210{
1211	union input_seq_state *state = (union input_seq_state *)&seq->private;
1212
1213	state->pos = *pos + 1;
1214	return seq_list_next(v, &input_handler_list, pos);
1215}
1216
1217static int input_handlers_seq_show(struct seq_file *seq, void *v)
1218{
1219	struct input_handler *handler = container_of(v, struct input_handler, node);
1220	union input_seq_state *state = (union input_seq_state *)&seq->private;
1221
1222	seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
1223	if (handler->filter)
1224		seq_puts(seq, " (filter)");
1225	if (handler->legacy_minors)
1226		seq_printf(seq, " Minor=%d", handler->minor);
1227	seq_putc(seq, '\n');
1228
1229	return 0;
1230}
1231
1232static const struct seq_operations input_handlers_seq_ops = {
1233	.start	= input_handlers_seq_start,
1234	.next	= input_handlers_seq_next,
1235	.stop	= input_seq_stop,
1236	.show	= input_handlers_seq_show,
1237};
1238
1239static int input_proc_handlers_open(struct inode *inode, struct file *file)
1240{
1241	return seq_open(file, &input_handlers_seq_ops);
1242}
1243
1244static const struct file_operations input_handlers_fileops = {
1245	.owner		= THIS_MODULE,
1246	.open		= input_proc_handlers_open,
1247	.read		= seq_read,
1248	.llseek		= seq_lseek,
1249	.release	= seq_release,
1250};
1251
1252static int __init input_proc_init(void)
1253{
1254	struct proc_dir_entry *entry;
1255
1256	proc_bus_input_dir = proc_mkdir("bus/input", NULL);
1257	if (!proc_bus_input_dir)
1258		return -ENOMEM;
1259
1260	entry = proc_create("devices", 0, proc_bus_input_dir,
1261			    &input_devices_fileops);
1262	if (!entry)
1263		goto fail1;
1264
1265	entry = proc_create("handlers", 0, proc_bus_input_dir,
1266			    &input_handlers_fileops);
1267	if (!entry)
1268		goto fail2;
1269
1270	return 0;
1271
1272 fail2:	remove_proc_entry("devices", proc_bus_input_dir);
1273 fail1: remove_proc_entry("bus/input", NULL);
1274	return -ENOMEM;
1275}
1276
1277static void input_proc_exit(void)
1278{
1279	remove_proc_entry("devices", proc_bus_input_dir);
1280	remove_proc_entry("handlers", proc_bus_input_dir);
1281	remove_proc_entry("bus/input", NULL);
1282}
1283
1284#else /* !CONFIG_PROC_FS */
1285static inline void input_wakeup_procfs_readers(void) { }
1286static inline int input_proc_init(void) { return 0; }
1287static inline void input_proc_exit(void) { }
1288#endif
1289
1290#define INPUT_DEV_STRING_ATTR_SHOW(name)				\
1291static ssize_t input_dev_show_##name(struct device *dev,		\
1292				     struct device_attribute *attr,	\
1293				     char *buf)				\
1294{									\
1295	struct input_dev *input_dev = to_input_dev(dev);		\
1296									\
1297	return scnprintf(buf, PAGE_SIZE, "%s\n",			\
1298			 input_dev->name ? input_dev->name : "");	\
1299}									\
1300static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1301
1302INPUT_DEV_STRING_ATTR_SHOW(name);
1303INPUT_DEV_STRING_ATTR_SHOW(phys);
1304INPUT_DEV_STRING_ATTR_SHOW(uniq);
1305
1306static int input_print_modalias_bits(char *buf, int size,
1307				     char name, unsigned long *bm,
1308				     unsigned int min_bit, unsigned int max_bit)
1309{
1310	int len = 0, i;
1311
1312	len += snprintf(buf, max(size, 0), "%c", name);
1313	for (i = min_bit; i < max_bit; i++)
1314		if (bm[BIT_WORD(i)] & BIT_MASK(i))
1315			len += snprintf(buf + len, max(size - len, 0), "%X,", i);
1316	return len;
1317}
1318
1319static int input_print_modalias(char *buf, int size, struct input_dev *id,
1320				int add_cr)
1321{
1322	int len;
1323
1324	len = snprintf(buf, max(size, 0),
1325		       "input:b%04Xv%04Xp%04Xe%04X-",
1326		       id->id.bustype, id->id.vendor,
1327		       id->id.product, id->id.version);
1328
1329	len += input_print_modalias_bits(buf + len, size - len,
1330				'e', id->evbit, 0, EV_MAX);
1331	len += input_print_modalias_bits(buf + len, size - len,
1332				'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1333	len += input_print_modalias_bits(buf + len, size - len,
1334				'r', id->relbit, 0, REL_MAX);
1335	len += input_print_modalias_bits(buf + len, size - len,
1336				'a', id->absbit, 0, ABS_MAX);
1337	len += input_print_modalias_bits(buf + len, size - len,
1338				'm', id->mscbit, 0, MSC_MAX);
1339	len += input_print_modalias_bits(buf + len, size - len,
1340				'l', id->ledbit, 0, LED_MAX);
1341	len += input_print_modalias_bits(buf + len, size - len,
1342				's', id->sndbit, 0, SND_MAX);
1343	len += input_print_modalias_bits(buf + len, size - len,
1344				'f', id->ffbit, 0, FF_MAX);
1345	len += input_print_modalias_bits(buf + len, size - len,
1346				'w', id->swbit, 0, SW_MAX);
1347
1348	if (add_cr)
1349		len += snprintf(buf + len, max(size - len, 0), "\n");
1350
1351	return len;
1352}
1353
1354static ssize_t input_dev_show_modalias(struct device *dev,
1355				       struct device_attribute *attr,
1356				       char *buf)
1357{
1358	struct input_dev *id = to_input_dev(dev);
1359	ssize_t len;
1360
1361	len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1362
1363	return min_t(int, len, PAGE_SIZE);
1364}
1365static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1366
1367static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1368			      int max, int add_cr);
1369
1370static ssize_t input_dev_show_properties(struct device *dev,
1371					 struct device_attribute *attr,
1372					 char *buf)
1373{
1374	struct input_dev *input_dev = to_input_dev(dev);
1375	int len = input_print_bitmap(buf, PAGE_SIZE, input_dev->propbit,
1376				     INPUT_PROP_MAX, true);
1377	return min_t(int, len, PAGE_SIZE);
1378}
1379static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL);
1380
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1381static struct attribute *input_dev_attrs[] = {
1382	&dev_attr_name.attr,
1383	&dev_attr_phys.attr,
1384	&dev_attr_uniq.attr,
1385	&dev_attr_modalias.attr,
1386	&dev_attr_properties.attr,
 
1387	NULL
1388};
1389
1390static struct attribute_group input_dev_attr_group = {
1391	.attrs	= input_dev_attrs,
1392};
1393
1394#define INPUT_DEV_ID_ATTR(name)						\
1395static ssize_t input_dev_show_id_##name(struct device *dev,		\
1396					struct device_attribute *attr,	\
1397					char *buf)			\
1398{									\
1399	struct input_dev *input_dev = to_input_dev(dev);		\
1400	return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name);	\
1401}									\
1402static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1403
1404INPUT_DEV_ID_ATTR(bustype);
1405INPUT_DEV_ID_ATTR(vendor);
1406INPUT_DEV_ID_ATTR(product);
1407INPUT_DEV_ID_ATTR(version);
1408
1409static struct attribute *input_dev_id_attrs[] = {
1410	&dev_attr_bustype.attr,
1411	&dev_attr_vendor.attr,
1412	&dev_attr_product.attr,
1413	&dev_attr_version.attr,
1414	NULL
1415};
1416
1417static struct attribute_group input_dev_id_attr_group = {
1418	.name	= "id",
1419	.attrs	= input_dev_id_attrs,
1420};
1421
1422static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1423			      int max, int add_cr)
1424{
1425	int i;
1426	int len = 0;
1427	bool skip_empty = true;
1428
1429	for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1430		len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1431					    bitmap[i], skip_empty);
1432		if (len) {
1433			skip_empty = false;
1434			if (i > 0)
1435				len += snprintf(buf + len, max(buf_size - len, 0), " ");
1436		}
1437	}
1438
1439	/*
1440	 * If no output was produced print a single 0.
1441	 */
1442	if (len == 0)
1443		len = snprintf(buf, buf_size, "%d", 0);
1444
1445	if (add_cr)
1446		len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1447
1448	return len;
1449}
1450
1451#define INPUT_DEV_CAP_ATTR(ev, bm)					\
1452static ssize_t input_dev_show_cap_##bm(struct device *dev,		\
1453				       struct device_attribute *attr,	\
1454				       char *buf)			\
1455{									\
1456	struct input_dev *input_dev = to_input_dev(dev);		\
1457	int len = input_print_bitmap(buf, PAGE_SIZE,			\
1458				     input_dev->bm##bit, ev##_MAX,	\
1459				     true);				\
1460	return min_t(int, len, PAGE_SIZE);				\
1461}									\
1462static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1463
1464INPUT_DEV_CAP_ATTR(EV, ev);
1465INPUT_DEV_CAP_ATTR(KEY, key);
1466INPUT_DEV_CAP_ATTR(REL, rel);
1467INPUT_DEV_CAP_ATTR(ABS, abs);
1468INPUT_DEV_CAP_ATTR(MSC, msc);
1469INPUT_DEV_CAP_ATTR(LED, led);
1470INPUT_DEV_CAP_ATTR(SND, snd);
1471INPUT_DEV_CAP_ATTR(FF, ff);
1472INPUT_DEV_CAP_ATTR(SW, sw);
1473
1474static struct attribute *input_dev_caps_attrs[] = {
1475	&dev_attr_ev.attr,
1476	&dev_attr_key.attr,
1477	&dev_attr_rel.attr,
1478	&dev_attr_abs.attr,
1479	&dev_attr_msc.attr,
1480	&dev_attr_led.attr,
1481	&dev_attr_snd.attr,
1482	&dev_attr_ff.attr,
1483	&dev_attr_sw.attr,
1484	NULL
1485};
1486
1487static struct attribute_group input_dev_caps_attr_group = {
1488	.name	= "capabilities",
1489	.attrs	= input_dev_caps_attrs,
1490};
1491
1492static const struct attribute_group *input_dev_attr_groups[] = {
1493	&input_dev_attr_group,
1494	&input_dev_id_attr_group,
1495	&input_dev_caps_attr_group,
 
1496	NULL
1497};
1498
1499static void input_dev_release(struct device *device)
1500{
1501	struct input_dev *dev = to_input_dev(device);
1502
1503	input_ff_destroy(dev);
1504	input_mt_destroy_slots(dev);
 
1505	kfree(dev->absinfo);
1506	kfree(dev->vals);
1507	kfree(dev);
1508
1509	module_put(THIS_MODULE);
1510}
1511
1512/*
1513 * Input uevent interface - loading event handlers based on
1514 * device bitfields.
1515 */
1516static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1517				   const char *name, unsigned long *bitmap, int max)
1518{
1519	int len;
1520
1521	if (add_uevent_var(env, "%s", name))
1522		return -ENOMEM;
1523
1524	len = input_print_bitmap(&env->buf[env->buflen - 1],
1525				 sizeof(env->buf) - env->buflen,
1526				 bitmap, max, false);
1527	if (len >= (sizeof(env->buf) - env->buflen))
1528		return -ENOMEM;
1529
1530	env->buflen += len;
1531	return 0;
1532}
1533
1534static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1535					 struct input_dev *dev)
1536{
1537	int len;
1538
1539	if (add_uevent_var(env, "MODALIAS="))
1540		return -ENOMEM;
1541
1542	len = input_print_modalias(&env->buf[env->buflen - 1],
1543				   sizeof(env->buf) - env->buflen,
1544				   dev, 0);
1545	if (len >= (sizeof(env->buf) - env->buflen))
1546		return -ENOMEM;
1547
1548	env->buflen += len;
1549	return 0;
1550}
1551
1552#define INPUT_ADD_HOTPLUG_VAR(fmt, val...)				\
1553	do {								\
1554		int err = add_uevent_var(env, fmt, val);		\
1555		if (err)						\
1556			return err;					\
1557	} while (0)
1558
1559#define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)				\
1560	do {								\
1561		int err = input_add_uevent_bm_var(env, name, bm, max);	\
1562		if (err)						\
1563			return err;					\
1564	} while (0)
1565
1566#define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)				\
1567	do {								\
1568		int err = input_add_uevent_modalias_var(env, dev);	\
1569		if (err)						\
1570			return err;					\
1571	} while (0)
1572
1573static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1574{
1575	struct input_dev *dev = to_input_dev(device);
1576
1577	INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1578				dev->id.bustype, dev->id.vendor,
1579				dev->id.product, dev->id.version);
1580	if (dev->name)
1581		INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1582	if (dev->phys)
1583		INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1584	if (dev->uniq)
1585		INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1586
1587	INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
1588
1589	INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1590	if (test_bit(EV_KEY, dev->evbit))
1591		INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1592	if (test_bit(EV_REL, dev->evbit))
1593		INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1594	if (test_bit(EV_ABS, dev->evbit))
1595		INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1596	if (test_bit(EV_MSC, dev->evbit))
1597		INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1598	if (test_bit(EV_LED, dev->evbit))
1599		INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1600	if (test_bit(EV_SND, dev->evbit))
1601		INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1602	if (test_bit(EV_FF, dev->evbit))
1603		INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1604	if (test_bit(EV_SW, dev->evbit))
1605		INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1606
1607	INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1608
1609	return 0;
1610}
1611
1612#define INPUT_DO_TOGGLE(dev, type, bits, on)				\
1613	do {								\
1614		int i;							\
1615		bool active;						\
1616									\
1617		if (!test_bit(EV_##type, dev->evbit))			\
1618			break;						\
1619									\
1620		for (i = 0; i < type##_MAX; i++) {			\
1621			if (!test_bit(i, dev->bits##bit))		\
1622				continue;				\
1623									\
1624			active = test_bit(i, dev->bits);		\
1625			if (!active && !on)				\
1626				continue;				\
1627									\
1628			dev->event(dev, EV_##type, i, on ? active : 0);	\
1629		}							\
1630	} while (0)
1631
1632static void input_dev_toggle(struct input_dev *dev, bool activate)
1633{
1634	if (!dev->event)
1635		return;
1636
1637	INPUT_DO_TOGGLE(dev, LED, led, activate);
1638	INPUT_DO_TOGGLE(dev, SND, snd, activate);
1639
1640	if (activate && test_bit(EV_REP, dev->evbit)) {
1641		dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1642		dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1643	}
1644}
1645
1646/**
1647 * input_reset_device() - reset/restore the state of input device
1648 * @dev: input device whose state needs to be reset
1649 *
1650 * This function tries to reset the state of an opened input device and
1651 * bring internal state and state if the hardware in sync with each other.
1652 * We mark all keys as released, restore LED state, repeat rate, etc.
1653 */
1654void input_reset_device(struct input_dev *dev)
1655{
1656	unsigned long flags;
1657
1658	mutex_lock(&dev->mutex);
1659	spin_lock_irqsave(&dev->event_lock, flags);
1660
1661	input_dev_toggle(dev, true);
1662	input_dev_release_keys(dev);
1663
1664	spin_unlock_irqrestore(&dev->event_lock, flags);
1665	mutex_unlock(&dev->mutex);
1666}
1667EXPORT_SYMBOL(input_reset_device);
1668
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1669#ifdef CONFIG_PM_SLEEP
1670static int input_dev_suspend(struct device *dev)
1671{
1672	struct input_dev *input_dev = to_input_dev(dev);
1673
1674	spin_lock_irq(&input_dev->event_lock);
1675
1676	/*
1677	 * Keys that are pressed now are unlikely to be
1678	 * still pressed when we resume.
1679	 */
1680	input_dev_release_keys(input_dev);
1681
1682	/* Turn off LEDs and sounds, if any are active. */
1683	input_dev_toggle(input_dev, false);
1684
1685	spin_unlock_irq(&input_dev->event_lock);
1686
1687	return 0;
1688}
1689
1690static int input_dev_resume(struct device *dev)
1691{
1692	struct input_dev *input_dev = to_input_dev(dev);
1693
1694	spin_lock_irq(&input_dev->event_lock);
1695
1696	/* Restore state of LEDs and sounds, if any were active. */
1697	input_dev_toggle(input_dev, true);
1698
1699	spin_unlock_irq(&input_dev->event_lock);
1700
1701	return 0;
1702}
1703
1704static int input_dev_freeze(struct device *dev)
1705{
1706	struct input_dev *input_dev = to_input_dev(dev);
1707
1708	spin_lock_irq(&input_dev->event_lock);
1709
1710	/*
1711	 * Keys that are pressed now are unlikely to be
1712	 * still pressed when we resume.
1713	 */
1714	input_dev_release_keys(input_dev);
1715
1716	spin_unlock_irq(&input_dev->event_lock);
1717
1718	return 0;
1719}
1720
1721static int input_dev_poweroff(struct device *dev)
1722{
1723	struct input_dev *input_dev = to_input_dev(dev);
1724
1725	spin_lock_irq(&input_dev->event_lock);
1726
1727	/* Turn off LEDs and sounds, if any are active. */
1728	input_dev_toggle(input_dev, false);
1729
1730	spin_unlock_irq(&input_dev->event_lock);
1731
1732	return 0;
1733}
1734
1735static const struct dev_pm_ops input_dev_pm_ops = {
1736	.suspend	= input_dev_suspend,
1737	.resume		= input_dev_resume,
1738	.freeze		= input_dev_freeze,
1739	.poweroff	= input_dev_poweroff,
1740	.restore	= input_dev_resume,
1741};
1742#endif /* CONFIG_PM */
1743
1744static struct device_type input_dev_type = {
1745	.groups		= input_dev_attr_groups,
1746	.release	= input_dev_release,
1747	.uevent		= input_dev_uevent,
1748#ifdef CONFIG_PM_SLEEP
1749	.pm		= &input_dev_pm_ops,
1750#endif
1751};
1752
1753static char *input_devnode(struct device *dev, umode_t *mode)
1754{
1755	return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1756}
1757
1758struct class input_class = {
1759	.name		= "input",
1760	.devnode	= input_devnode,
1761};
1762EXPORT_SYMBOL_GPL(input_class);
1763
1764/**
1765 * input_allocate_device - allocate memory for new input device
1766 *
1767 * Returns prepared struct input_dev or %NULL.
1768 *
1769 * NOTE: Use input_free_device() to free devices that have not been
1770 * registered; input_unregister_device() should be used for already
1771 * registered devices.
1772 */
1773struct input_dev *input_allocate_device(void)
1774{
1775	static atomic_t input_no = ATOMIC_INIT(0);
1776	struct input_dev *dev;
1777
1778	dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
1779	if (dev) {
1780		dev->dev.type = &input_dev_type;
1781		dev->dev.class = &input_class;
1782		device_initialize(&dev->dev);
1783		mutex_init(&dev->mutex);
1784		spin_lock_init(&dev->event_lock);
1785		init_timer(&dev->timer);
1786		INIT_LIST_HEAD(&dev->h_list);
1787		INIT_LIST_HEAD(&dev->node);
1788
1789		dev_set_name(&dev->dev, "input%ld",
1790			     (unsigned long) atomic_inc_return(&input_no) - 1);
1791
1792		__module_get(THIS_MODULE);
1793	}
1794
1795	return dev;
1796}
1797EXPORT_SYMBOL(input_allocate_device);
1798
1799struct input_devres {
1800	struct input_dev *input;
1801};
1802
1803static int devm_input_device_match(struct device *dev, void *res, void *data)
1804{
1805	struct input_devres *devres = res;
1806
1807	return devres->input == data;
1808}
1809
1810static void devm_input_device_release(struct device *dev, void *res)
1811{
1812	struct input_devres *devres = res;
1813	struct input_dev *input = devres->input;
1814
1815	dev_dbg(dev, "%s: dropping reference to %s\n",
1816		__func__, dev_name(&input->dev));
1817	input_put_device(input);
1818}
1819
1820/**
1821 * devm_input_allocate_device - allocate managed input device
1822 * @dev: device owning the input device being created
1823 *
1824 * Returns prepared struct input_dev or %NULL.
1825 *
1826 * Managed input devices do not need to be explicitly unregistered or
1827 * freed as it will be done automatically when owner device unbinds from
1828 * its driver (or binding fails). Once managed input device is allocated,
1829 * it is ready to be set up and registered in the same fashion as regular
1830 * input device. There are no special devm_input_device_[un]register()
1831 * variants, regular ones work with both managed and unmanaged devices,
1832 * should you need them. In most cases however, managed input device need
1833 * not be explicitly unregistered or freed.
1834 *
1835 * NOTE: the owner device is set up as parent of input device and users
1836 * should not override it.
1837 */
1838struct input_dev *devm_input_allocate_device(struct device *dev)
1839{
1840	struct input_dev *input;
1841	struct input_devres *devres;
1842
1843	devres = devres_alloc(devm_input_device_release,
1844			      sizeof(struct input_devres), GFP_KERNEL);
1845	if (!devres)
1846		return NULL;
1847
1848	input = input_allocate_device();
1849	if (!input) {
1850		devres_free(devres);
1851		return NULL;
1852	}
1853
1854	input->dev.parent = dev;
1855	input->devres_managed = true;
1856
1857	devres->input = input;
1858	devres_add(dev, devres);
1859
1860	return input;
1861}
1862EXPORT_SYMBOL(devm_input_allocate_device);
1863
1864/**
1865 * input_free_device - free memory occupied by input_dev structure
1866 * @dev: input device to free
1867 *
1868 * This function should only be used if input_register_device()
1869 * was not called yet or if it failed. Once device was registered
1870 * use input_unregister_device() and memory will be freed once last
1871 * reference to the device is dropped.
1872 *
1873 * Device should be allocated by input_allocate_device().
1874 *
1875 * NOTE: If there are references to the input device then memory
1876 * will not be freed until last reference is dropped.
1877 */
1878void input_free_device(struct input_dev *dev)
1879{
1880	if (dev) {
1881		if (dev->devres_managed)
1882			WARN_ON(devres_destroy(dev->dev.parent,
1883						devm_input_device_release,
1884						devm_input_device_match,
1885						dev));
1886		input_put_device(dev);
1887	}
1888}
1889EXPORT_SYMBOL(input_free_device);
1890
1891/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1892 * input_set_capability - mark device as capable of a certain event
1893 * @dev: device that is capable of emitting or accepting event
1894 * @type: type of the event (EV_KEY, EV_REL, etc...)
1895 * @code: event code
1896 *
1897 * In addition to setting up corresponding bit in appropriate capability
1898 * bitmap the function also adjusts dev->evbit.
1899 */
1900void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1901{
1902	switch (type) {
1903	case EV_KEY:
1904		__set_bit(code, dev->keybit);
1905		break;
1906
1907	case EV_REL:
1908		__set_bit(code, dev->relbit);
1909		break;
1910
1911	case EV_ABS:
1912		input_alloc_absinfo(dev);
1913		if (!dev->absinfo)
1914			return;
1915
1916		__set_bit(code, dev->absbit);
1917		break;
1918
1919	case EV_MSC:
1920		__set_bit(code, dev->mscbit);
1921		break;
1922
1923	case EV_SW:
1924		__set_bit(code, dev->swbit);
1925		break;
1926
1927	case EV_LED:
1928		__set_bit(code, dev->ledbit);
1929		break;
1930
1931	case EV_SND:
1932		__set_bit(code, dev->sndbit);
1933		break;
1934
1935	case EV_FF:
1936		__set_bit(code, dev->ffbit);
1937		break;
1938
1939	case EV_PWR:
1940		/* do nothing */
1941		break;
1942
1943	default:
1944		pr_err("input_set_capability: unknown type %u (code %u)\n",
1945		       type, code);
1946		dump_stack();
1947		return;
1948	}
1949
1950	__set_bit(type, dev->evbit);
1951}
1952EXPORT_SYMBOL(input_set_capability);
1953
1954static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
1955{
1956	int mt_slots;
1957	int i;
1958	unsigned int events;
1959
1960	if (dev->mt) {
1961		mt_slots = dev->mt->num_slots;
1962	} else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
1963		mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
1964			   dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
1965		mt_slots = clamp(mt_slots, 2, 32);
1966	} else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
1967		mt_slots = 2;
1968	} else {
1969		mt_slots = 0;
1970	}
1971
1972	events = mt_slots + 1; /* count SYN_MT_REPORT and SYN_REPORT */
1973
1974	for (i = 0; i < ABS_CNT; i++) {
1975		if (test_bit(i, dev->absbit)) {
1976			if (input_is_mt_axis(i))
1977				events += mt_slots;
1978			else
1979				events++;
1980		}
1981	}
1982
1983	for (i = 0; i < REL_CNT; i++)
1984		if (test_bit(i, dev->relbit))
1985			events++;
1986
1987	/* Make room for KEY and MSC events */
1988	events += 7;
1989
1990	return events;
1991}
1992
1993#define INPUT_CLEANSE_BITMASK(dev, type, bits)				\
1994	do {								\
1995		if (!test_bit(EV_##type, dev->evbit))			\
1996			memset(dev->bits##bit, 0,			\
1997				sizeof(dev->bits##bit));		\
1998	} while (0)
1999
2000static void input_cleanse_bitmasks(struct input_dev *dev)
2001{
2002	INPUT_CLEANSE_BITMASK(dev, KEY, key);
2003	INPUT_CLEANSE_BITMASK(dev, REL, rel);
2004	INPUT_CLEANSE_BITMASK(dev, ABS, abs);
2005	INPUT_CLEANSE_BITMASK(dev, MSC, msc);
2006	INPUT_CLEANSE_BITMASK(dev, LED, led);
2007	INPUT_CLEANSE_BITMASK(dev, SND, snd);
2008	INPUT_CLEANSE_BITMASK(dev, FF, ff);
2009	INPUT_CLEANSE_BITMASK(dev, SW, sw);
2010}
2011
2012static void __input_unregister_device(struct input_dev *dev)
2013{
2014	struct input_handle *handle, *next;
2015
2016	input_disconnect_device(dev);
2017
2018	mutex_lock(&input_mutex);
2019
2020	list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
2021		handle->handler->disconnect(handle);
2022	WARN_ON(!list_empty(&dev->h_list));
2023
2024	del_timer_sync(&dev->timer);
2025	list_del_init(&dev->node);
2026
2027	input_wakeup_procfs_readers();
2028
2029	mutex_unlock(&input_mutex);
2030
2031	device_del(&dev->dev);
2032}
2033
2034static void devm_input_device_unregister(struct device *dev, void *res)
2035{
2036	struct input_devres *devres = res;
2037	struct input_dev *input = devres->input;
2038
2039	dev_dbg(dev, "%s: unregistering device %s\n",
2040		__func__, dev_name(&input->dev));
2041	__input_unregister_device(input);
2042}
2043
2044/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2045 * input_register_device - register device with input core
2046 * @dev: device to be registered
2047 *
2048 * This function registers device with input core. The device must be
2049 * allocated with input_allocate_device() and all it's capabilities
2050 * set up before registering.
2051 * If function fails the device must be freed with input_free_device().
2052 * Once device has been successfully registered it can be unregistered
2053 * with input_unregister_device(); input_free_device() should not be
2054 * called in this case.
2055 *
2056 * Note that this function is also used to register managed input devices
2057 * (ones allocated with devm_input_allocate_device()). Such managed input
2058 * devices need not be explicitly unregistered or freed, their tear down
2059 * is controlled by the devres infrastructure. It is also worth noting
2060 * that tear down of managed input devices is internally a 2-step process:
2061 * registered managed input device is first unregistered, but stays in
2062 * memory and can still handle input_event() calls (although events will
2063 * not be delivered anywhere). The freeing of managed input device will
2064 * happen later, when devres stack is unwound to the point where device
2065 * allocation was made.
2066 */
2067int input_register_device(struct input_dev *dev)
2068{
2069	struct input_devres *devres = NULL;
2070	struct input_handler *handler;
2071	unsigned int packet_size;
2072	const char *path;
2073	int error;
2074
 
 
 
 
 
 
2075	if (dev->devres_managed) {
2076		devres = devres_alloc(devm_input_device_unregister,
2077				      sizeof(struct input_devres), GFP_KERNEL);
2078		if (!devres)
2079			return -ENOMEM;
2080
2081		devres->input = dev;
2082	}
2083
2084	/* Every input device generates EV_SYN/SYN_REPORT events. */
2085	__set_bit(EV_SYN, dev->evbit);
2086
2087	/* KEY_RESERVED is not supposed to be transmitted to userspace. */
2088	__clear_bit(KEY_RESERVED, dev->keybit);
2089
2090	/* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2091	input_cleanse_bitmasks(dev);
2092
2093	packet_size = input_estimate_events_per_packet(dev);
2094	if (dev->hint_events_per_packet < packet_size)
2095		dev->hint_events_per_packet = packet_size;
2096
2097	dev->max_vals = dev->hint_events_per_packet + 2;
2098	dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
2099	if (!dev->vals) {
2100		error = -ENOMEM;
2101		goto err_devres_free;
2102	}
2103
2104	/*
2105	 * If delay and period are pre-set by the driver, then autorepeating
2106	 * is handled by the driver itself and we don't do it in input.c.
2107	 */
2108	if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
2109		dev->timer.data = (long) dev;
2110		dev->timer.function = input_repeat_key;
2111		dev->rep[REP_DELAY] = 250;
2112		dev->rep[REP_PERIOD] = 33;
2113	}
2114
2115	if (!dev->getkeycode)
2116		dev->getkeycode = input_default_getkeycode;
2117
2118	if (!dev->setkeycode)
2119		dev->setkeycode = input_default_setkeycode;
2120
 
 
 
2121	error = device_add(&dev->dev);
2122	if (error)
2123		goto err_free_vals;
2124
2125	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
2126	pr_info("%s as %s\n",
2127		dev->name ? dev->name : "Unspecified device",
2128		path ? path : "N/A");
2129	kfree(path);
2130
2131	error = mutex_lock_interruptible(&input_mutex);
2132	if (error)
2133		goto err_device_del;
2134
2135	list_add_tail(&dev->node, &input_dev_list);
2136
2137	list_for_each_entry(handler, &input_handler_list, node)
2138		input_attach_handler(dev, handler);
2139
2140	input_wakeup_procfs_readers();
2141
2142	mutex_unlock(&input_mutex);
2143
2144	if (dev->devres_managed) {
2145		dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
2146			__func__, dev_name(&dev->dev));
2147		devres_add(dev->dev.parent, devres);
2148	}
2149	return 0;
2150
2151err_device_del:
2152	device_del(&dev->dev);
2153err_free_vals:
2154	kfree(dev->vals);
2155	dev->vals = NULL;
2156err_devres_free:
2157	devres_free(devres);
2158	return error;
2159}
2160EXPORT_SYMBOL(input_register_device);
2161
2162/**
2163 * input_unregister_device - unregister previously registered device
2164 * @dev: device to be unregistered
2165 *
2166 * This function unregisters an input device. Once device is unregistered
2167 * the caller should not try to access it as it may get freed at any moment.
2168 */
2169void input_unregister_device(struct input_dev *dev)
2170{
2171	if (dev->devres_managed) {
2172		WARN_ON(devres_destroy(dev->dev.parent,
2173					devm_input_device_unregister,
2174					devm_input_device_match,
2175					dev));
2176		__input_unregister_device(dev);
2177		/*
2178		 * We do not do input_put_device() here because it will be done
2179		 * when 2nd devres fires up.
2180		 */
2181	} else {
2182		__input_unregister_device(dev);
2183		input_put_device(dev);
2184	}
2185}
2186EXPORT_SYMBOL(input_unregister_device);
2187
2188/**
2189 * input_register_handler - register a new input handler
2190 * @handler: handler to be registered
2191 *
2192 * This function registers a new input handler (interface) for input
2193 * devices in the system and attaches it to all input devices that
2194 * are compatible with the handler.
2195 */
2196int input_register_handler(struct input_handler *handler)
2197{
2198	struct input_dev *dev;
2199	int error;
2200
2201	error = mutex_lock_interruptible(&input_mutex);
2202	if (error)
2203		return error;
2204
2205	INIT_LIST_HEAD(&handler->h_list);
2206
2207	list_add_tail(&handler->node, &input_handler_list);
2208
2209	list_for_each_entry(dev, &input_dev_list, node)
2210		input_attach_handler(dev, handler);
2211
2212	input_wakeup_procfs_readers();
2213
2214	mutex_unlock(&input_mutex);
2215	return 0;
2216}
2217EXPORT_SYMBOL(input_register_handler);
2218
2219/**
2220 * input_unregister_handler - unregisters an input handler
2221 * @handler: handler to be unregistered
2222 *
2223 * This function disconnects a handler from its input devices and
2224 * removes it from lists of known handlers.
2225 */
2226void input_unregister_handler(struct input_handler *handler)
2227{
2228	struct input_handle *handle, *next;
2229
2230	mutex_lock(&input_mutex);
2231
2232	list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
2233		handler->disconnect(handle);
2234	WARN_ON(!list_empty(&handler->h_list));
2235
2236	list_del_init(&handler->node);
2237
2238	input_wakeup_procfs_readers();
2239
2240	mutex_unlock(&input_mutex);
2241}
2242EXPORT_SYMBOL(input_unregister_handler);
2243
2244/**
2245 * input_handler_for_each_handle - handle iterator
2246 * @handler: input handler to iterate
2247 * @data: data for the callback
2248 * @fn: function to be called for each handle
2249 *
2250 * Iterate over @bus's list of devices, and call @fn for each, passing
2251 * it @data and stop when @fn returns a non-zero value. The function is
2252 * using RCU to traverse the list and therefore may be usind in atonic
2253 * contexts. The @fn callback is invoked from RCU critical section and
2254 * thus must not sleep.
2255 */
2256int input_handler_for_each_handle(struct input_handler *handler, void *data,
2257				  int (*fn)(struct input_handle *, void *))
2258{
2259	struct input_handle *handle;
2260	int retval = 0;
2261
2262	rcu_read_lock();
2263
2264	list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2265		retval = fn(handle, data);
2266		if (retval)
2267			break;
2268	}
2269
2270	rcu_read_unlock();
2271
2272	return retval;
2273}
2274EXPORT_SYMBOL(input_handler_for_each_handle);
2275
2276/**
2277 * input_register_handle - register a new input handle
2278 * @handle: handle to register
2279 *
2280 * This function puts a new input handle onto device's
2281 * and handler's lists so that events can flow through
2282 * it once it is opened using input_open_device().
2283 *
2284 * This function is supposed to be called from handler's
2285 * connect() method.
2286 */
2287int input_register_handle(struct input_handle *handle)
2288{
2289	struct input_handler *handler = handle->handler;
2290	struct input_dev *dev = handle->dev;
2291	int error;
2292
2293	/*
2294	 * We take dev->mutex here to prevent race with
2295	 * input_release_device().
2296	 */
2297	error = mutex_lock_interruptible(&dev->mutex);
2298	if (error)
2299		return error;
2300
2301	/*
2302	 * Filters go to the head of the list, normal handlers
2303	 * to the tail.
2304	 */
2305	if (handler->filter)
2306		list_add_rcu(&handle->d_node, &dev->h_list);
2307	else
2308		list_add_tail_rcu(&handle->d_node, &dev->h_list);
2309
2310	mutex_unlock(&dev->mutex);
2311
2312	/*
2313	 * Since we are supposed to be called from ->connect()
2314	 * which is mutually exclusive with ->disconnect()
2315	 * we can't be racing with input_unregister_handle()
2316	 * and so separate lock is not needed here.
2317	 */
2318	list_add_tail_rcu(&handle->h_node, &handler->h_list);
2319
2320	if (handler->start)
2321		handler->start(handle);
2322
2323	return 0;
2324}
2325EXPORT_SYMBOL(input_register_handle);
2326
2327/**
2328 * input_unregister_handle - unregister an input handle
2329 * @handle: handle to unregister
2330 *
2331 * This function removes input handle from device's
2332 * and handler's lists.
2333 *
2334 * This function is supposed to be called from handler's
2335 * disconnect() method.
2336 */
2337void input_unregister_handle(struct input_handle *handle)
2338{
2339	struct input_dev *dev = handle->dev;
2340
2341	list_del_rcu(&handle->h_node);
2342
2343	/*
2344	 * Take dev->mutex to prevent race with input_release_device().
2345	 */
2346	mutex_lock(&dev->mutex);
2347	list_del_rcu(&handle->d_node);
2348	mutex_unlock(&dev->mutex);
2349
2350	synchronize_rcu();
2351}
2352EXPORT_SYMBOL(input_unregister_handle);
2353
2354/**
2355 * input_get_new_minor - allocates a new input minor number
2356 * @legacy_base: beginning or the legacy range to be searched
2357 * @legacy_num: size of legacy range
2358 * @allow_dynamic: whether we can also take ID from the dynamic range
2359 *
2360 * This function allocates a new device minor for from input major namespace.
2361 * Caller can request legacy minor by specifying @legacy_base and @legacy_num
2362 * parameters and whether ID can be allocated from dynamic range if there are
2363 * no free IDs in legacy range.
2364 */
2365int input_get_new_minor(int legacy_base, unsigned int legacy_num,
2366			bool allow_dynamic)
2367{
2368	/*
2369	 * This function should be called from input handler's ->connect()
2370	 * methods, which are serialized with input_mutex, so no additional
2371	 * locking is needed here.
2372	 */
2373	if (legacy_base >= 0) {
2374		int minor = ida_simple_get(&input_ida,
2375					   legacy_base,
2376					   legacy_base + legacy_num,
2377					   GFP_KERNEL);
2378		if (minor >= 0 || !allow_dynamic)
2379			return minor;
2380	}
2381
2382	return ida_simple_get(&input_ida,
2383			      INPUT_FIRST_DYNAMIC_DEV, INPUT_MAX_CHAR_DEVICES,
2384			      GFP_KERNEL);
2385}
2386EXPORT_SYMBOL(input_get_new_minor);
2387
2388/**
2389 * input_free_minor - release previously allocated minor
2390 * @minor: minor to be released
2391 *
2392 * This function releases previously allocated input minor so that it can be
2393 * reused later.
2394 */
2395void input_free_minor(unsigned int minor)
2396{
2397	ida_simple_remove(&input_ida, minor);
2398}
2399EXPORT_SYMBOL(input_free_minor);
2400
2401static int __init input_init(void)
2402{
2403	int err;
2404
2405	err = class_register(&input_class);
2406	if (err) {
2407		pr_err("unable to register input_dev class\n");
2408		return err;
2409	}
2410
2411	err = input_proc_init();
2412	if (err)
2413		goto fail1;
2414
2415	err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2416				     INPUT_MAX_CHAR_DEVICES, "input");
2417	if (err) {
2418		pr_err("unable to register char major %d", INPUT_MAJOR);
2419		goto fail2;
2420	}
2421
2422	return 0;
2423
2424 fail2:	input_proc_exit();
2425 fail1:	class_unregister(&input_class);
2426	return err;
2427}
2428
2429static void __exit input_exit(void)
2430{
2431	input_proc_exit();
2432	unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2433				 INPUT_MAX_CHAR_DEVICES);
2434	class_unregister(&input_class);
2435}
2436
2437subsys_initcall(input_init);
2438module_exit(input_exit);