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