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