cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

input.c (67870B)


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