xref: /openbmc/linux/drivers/input/input.c (revision fd589a8f)
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 #include <linux/init.h>
14 #include <linux/input.h>
15 #include <linux/module.h>
16 #include <linux/random.h>
17 #include <linux/major.h>
18 #include <linux/proc_fs.h>
19 #include <linux/seq_file.h>
20 #include <linux/poll.h>
21 #include <linux/device.h>
22 #include <linux/mutex.h>
23 #include <linux/rcupdate.h>
24 #include <linux/smp_lock.h>
25 
26 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
27 MODULE_DESCRIPTION("Input core");
28 MODULE_LICENSE("GPL");
29 
30 #define INPUT_DEVICES	256
31 
32 /*
33  * EV_ABS events which should not be cached are listed here.
34  */
35 static unsigned int input_abs_bypass_init_data[] __initdata = {
36 	ABS_MT_TOUCH_MAJOR,
37 	ABS_MT_TOUCH_MINOR,
38 	ABS_MT_WIDTH_MAJOR,
39 	ABS_MT_WIDTH_MINOR,
40 	ABS_MT_ORIENTATION,
41 	ABS_MT_POSITION_X,
42 	ABS_MT_POSITION_Y,
43 	ABS_MT_TOOL_TYPE,
44 	ABS_MT_BLOB_ID,
45 	ABS_MT_TRACKING_ID,
46 	0
47 };
48 static unsigned long input_abs_bypass[BITS_TO_LONGS(ABS_CNT)];
49 
50 static LIST_HEAD(input_dev_list);
51 static LIST_HEAD(input_handler_list);
52 
53 /*
54  * input_mutex protects access to both input_dev_list and input_handler_list.
55  * This also causes input_[un]register_device and input_[un]register_handler
56  * be mutually exclusive which simplifies locking in drivers implementing
57  * input handlers.
58  */
59 static DEFINE_MUTEX(input_mutex);
60 
61 static struct input_handler *input_table[8];
62 
63 static inline int is_event_supported(unsigned int code,
64 				     unsigned long *bm, unsigned int max)
65 {
66 	return code <= max && test_bit(code, bm);
67 }
68 
69 static int input_defuzz_abs_event(int value, int old_val, int fuzz)
70 {
71 	if (fuzz) {
72 		if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
73 			return old_val;
74 
75 		if (value > old_val - fuzz && value < old_val + fuzz)
76 			return (old_val * 3 + value) / 4;
77 
78 		if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
79 			return (old_val + value) / 2;
80 	}
81 
82 	return value;
83 }
84 
85 /*
86  * Pass event through all open handles. This function is called with
87  * dev->event_lock held and interrupts disabled.
88  */
89 static void input_pass_event(struct input_dev *dev,
90 			     unsigned int type, unsigned int code, int value)
91 {
92 	struct input_handle *handle;
93 
94 	rcu_read_lock();
95 
96 	handle = rcu_dereference(dev->grab);
97 	if (handle)
98 		handle->handler->event(handle, type, code, value);
99 	else
100 		list_for_each_entry_rcu(handle, &dev->h_list, d_node)
101 			if (handle->open)
102 				handle->handler->event(handle,
103 							type, code, value);
104 	rcu_read_unlock();
105 }
106 
107 /*
108  * Generate software autorepeat event. Note that we take
109  * dev->event_lock here to avoid racing with input_event
110  * which may cause keys get "stuck".
111  */
112 static void input_repeat_key(unsigned long data)
113 {
114 	struct input_dev *dev = (void *) data;
115 	unsigned long flags;
116 
117 	spin_lock_irqsave(&dev->event_lock, flags);
118 
119 	if (test_bit(dev->repeat_key, dev->key) &&
120 	    is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
121 
122 		input_pass_event(dev, EV_KEY, dev->repeat_key, 2);
123 
124 		if (dev->sync) {
125 			/*
126 			 * Only send SYN_REPORT if we are not in a middle
127 			 * of driver parsing a new hardware packet.
128 			 * Otherwise assume that the driver will send
129 			 * SYN_REPORT once it's done.
130 			 */
131 			input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
132 		}
133 
134 		if (dev->rep[REP_PERIOD])
135 			mod_timer(&dev->timer, jiffies +
136 					msecs_to_jiffies(dev->rep[REP_PERIOD]));
137 	}
138 
139 	spin_unlock_irqrestore(&dev->event_lock, flags);
140 }
141 
142 static void input_start_autorepeat(struct input_dev *dev, int code)
143 {
144 	if (test_bit(EV_REP, dev->evbit) &&
145 	    dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
146 	    dev->timer.data) {
147 		dev->repeat_key = code;
148 		mod_timer(&dev->timer,
149 			  jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
150 	}
151 }
152 
153 static void input_stop_autorepeat(struct input_dev *dev)
154 {
155 	del_timer(&dev->timer);
156 }
157 
158 #define INPUT_IGNORE_EVENT	0
159 #define INPUT_PASS_TO_HANDLERS	1
160 #define INPUT_PASS_TO_DEVICE	2
161 #define INPUT_PASS_TO_ALL	(INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
162 
163 static void input_handle_event(struct input_dev *dev,
164 			       unsigned int type, unsigned int code, int value)
165 {
166 	int disposition = INPUT_IGNORE_EVENT;
167 
168 	switch (type) {
169 
170 	case EV_SYN:
171 		switch (code) {
172 		case SYN_CONFIG:
173 			disposition = INPUT_PASS_TO_ALL;
174 			break;
175 
176 		case SYN_REPORT:
177 			if (!dev->sync) {
178 				dev->sync = 1;
179 				disposition = INPUT_PASS_TO_HANDLERS;
180 			}
181 			break;
182 		case SYN_MT_REPORT:
183 			dev->sync = 0;
184 			disposition = INPUT_PASS_TO_HANDLERS;
185 			break;
186 		}
187 		break;
188 
189 	case EV_KEY:
190 		if (is_event_supported(code, dev->keybit, KEY_MAX) &&
191 		    !!test_bit(code, dev->key) != value) {
192 
193 			if (value != 2) {
194 				__change_bit(code, dev->key);
195 				if (value)
196 					input_start_autorepeat(dev, code);
197 				else
198 					input_stop_autorepeat(dev);
199 			}
200 
201 			disposition = INPUT_PASS_TO_HANDLERS;
202 		}
203 		break;
204 
205 	case EV_SW:
206 		if (is_event_supported(code, dev->swbit, SW_MAX) &&
207 		    !!test_bit(code, dev->sw) != value) {
208 
209 			__change_bit(code, dev->sw);
210 			disposition = INPUT_PASS_TO_HANDLERS;
211 		}
212 		break;
213 
214 	case EV_ABS:
215 		if (is_event_supported(code, dev->absbit, ABS_MAX)) {
216 
217 			if (test_bit(code, input_abs_bypass)) {
218 				disposition = INPUT_PASS_TO_HANDLERS;
219 				break;
220 			}
221 
222 			value = input_defuzz_abs_event(value,
223 					dev->abs[code], dev->absfuzz[code]);
224 
225 			if (dev->abs[code] != value) {
226 				dev->abs[code] = value;
227 				disposition = INPUT_PASS_TO_HANDLERS;
228 			}
229 		}
230 		break;
231 
232 	case EV_REL:
233 		if (is_event_supported(code, dev->relbit, REL_MAX) && value)
234 			disposition = INPUT_PASS_TO_HANDLERS;
235 
236 		break;
237 
238 	case EV_MSC:
239 		if (is_event_supported(code, dev->mscbit, MSC_MAX))
240 			disposition = INPUT_PASS_TO_ALL;
241 
242 		break;
243 
244 	case EV_LED:
245 		if (is_event_supported(code, dev->ledbit, LED_MAX) &&
246 		    !!test_bit(code, dev->led) != value) {
247 
248 			__change_bit(code, dev->led);
249 			disposition = INPUT_PASS_TO_ALL;
250 		}
251 		break;
252 
253 	case EV_SND:
254 		if (is_event_supported(code, dev->sndbit, SND_MAX)) {
255 
256 			if (!!test_bit(code, dev->snd) != !!value)
257 				__change_bit(code, dev->snd);
258 			disposition = INPUT_PASS_TO_ALL;
259 		}
260 		break;
261 
262 	case EV_REP:
263 		if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
264 			dev->rep[code] = value;
265 			disposition = INPUT_PASS_TO_ALL;
266 		}
267 		break;
268 
269 	case EV_FF:
270 		if (value >= 0)
271 			disposition = INPUT_PASS_TO_ALL;
272 		break;
273 
274 	case EV_PWR:
275 		disposition = INPUT_PASS_TO_ALL;
276 		break;
277 	}
278 
279 	if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
280 		dev->sync = 0;
281 
282 	if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
283 		dev->event(dev, type, code, value);
284 
285 	if (disposition & INPUT_PASS_TO_HANDLERS)
286 		input_pass_event(dev, type, code, value);
287 }
288 
289 /**
290  * input_event() - report new input event
291  * @dev: device that generated the event
292  * @type: type of the event
293  * @code: event code
294  * @value: value of the event
295  *
296  * This function should be used by drivers implementing various input
297  * devices. See also input_inject_event().
298  */
299 
300 void input_event(struct input_dev *dev,
301 		 unsigned int type, unsigned int code, int value)
302 {
303 	unsigned long flags;
304 
305 	if (is_event_supported(type, dev->evbit, EV_MAX)) {
306 
307 		spin_lock_irqsave(&dev->event_lock, flags);
308 		add_input_randomness(type, code, value);
309 		input_handle_event(dev, type, code, value);
310 		spin_unlock_irqrestore(&dev->event_lock, flags);
311 	}
312 }
313 EXPORT_SYMBOL(input_event);
314 
315 /**
316  * input_inject_event() - send input event from input handler
317  * @handle: input handle to send event through
318  * @type: type of the event
319  * @code: event code
320  * @value: value of the event
321  *
322  * Similar to input_event() but will ignore event if device is
323  * "grabbed" and handle injecting event is not the one that owns
324  * the device.
325  */
326 void input_inject_event(struct input_handle *handle,
327 			unsigned int type, unsigned int code, int value)
328 {
329 	struct input_dev *dev = handle->dev;
330 	struct input_handle *grab;
331 	unsigned long flags;
332 
333 	if (is_event_supported(type, dev->evbit, EV_MAX)) {
334 		spin_lock_irqsave(&dev->event_lock, flags);
335 
336 		rcu_read_lock();
337 		grab = rcu_dereference(dev->grab);
338 		if (!grab || grab == handle)
339 			input_handle_event(dev, type, code, value);
340 		rcu_read_unlock();
341 
342 		spin_unlock_irqrestore(&dev->event_lock, flags);
343 	}
344 }
345 EXPORT_SYMBOL(input_inject_event);
346 
347 /**
348  * input_grab_device - grabs device for exclusive use
349  * @handle: input handle that wants to own the device
350  *
351  * When a device is grabbed by an input handle all events generated by
352  * the device are delivered only to this handle. Also events injected
353  * by other input handles are ignored while device is grabbed.
354  */
355 int input_grab_device(struct input_handle *handle)
356 {
357 	struct input_dev *dev = handle->dev;
358 	int retval;
359 
360 	retval = mutex_lock_interruptible(&dev->mutex);
361 	if (retval)
362 		return retval;
363 
364 	if (dev->grab) {
365 		retval = -EBUSY;
366 		goto out;
367 	}
368 
369 	rcu_assign_pointer(dev->grab, handle);
370 	synchronize_rcu();
371 
372  out:
373 	mutex_unlock(&dev->mutex);
374 	return retval;
375 }
376 EXPORT_SYMBOL(input_grab_device);
377 
378 static void __input_release_device(struct input_handle *handle)
379 {
380 	struct input_dev *dev = handle->dev;
381 
382 	if (dev->grab == handle) {
383 		rcu_assign_pointer(dev->grab, NULL);
384 		/* Make sure input_pass_event() notices that grab is gone */
385 		synchronize_rcu();
386 
387 		list_for_each_entry(handle, &dev->h_list, d_node)
388 			if (handle->open && handle->handler->start)
389 				handle->handler->start(handle);
390 	}
391 }
392 
393 /**
394  * input_release_device - release previously grabbed device
395  * @handle: input handle that owns the device
396  *
397  * Releases previously grabbed device so that other input handles can
398  * start receiving input events. Upon release all handlers attached
399  * to the device have their start() method called so they have a change
400  * to synchronize device state with the rest of the system.
401  */
402 void input_release_device(struct input_handle *handle)
403 {
404 	struct input_dev *dev = handle->dev;
405 
406 	mutex_lock(&dev->mutex);
407 	__input_release_device(handle);
408 	mutex_unlock(&dev->mutex);
409 }
410 EXPORT_SYMBOL(input_release_device);
411 
412 /**
413  * input_open_device - open input device
414  * @handle: handle through which device is being accessed
415  *
416  * This function should be called by input handlers when they
417  * want to start receive events from given input device.
418  */
419 int input_open_device(struct input_handle *handle)
420 {
421 	struct input_dev *dev = handle->dev;
422 	int retval;
423 
424 	retval = mutex_lock_interruptible(&dev->mutex);
425 	if (retval)
426 		return retval;
427 
428 	if (dev->going_away) {
429 		retval = -ENODEV;
430 		goto out;
431 	}
432 
433 	handle->open++;
434 
435 	if (!dev->users++ && dev->open)
436 		retval = dev->open(dev);
437 
438 	if (retval) {
439 		dev->users--;
440 		if (!--handle->open) {
441 			/*
442 			 * Make sure we are not delivering any more events
443 			 * through this handle
444 			 */
445 			synchronize_rcu();
446 		}
447 	}
448 
449  out:
450 	mutex_unlock(&dev->mutex);
451 	return retval;
452 }
453 EXPORT_SYMBOL(input_open_device);
454 
455 int input_flush_device(struct input_handle *handle, struct file *file)
456 {
457 	struct input_dev *dev = handle->dev;
458 	int retval;
459 
460 	retval = mutex_lock_interruptible(&dev->mutex);
461 	if (retval)
462 		return retval;
463 
464 	if (dev->flush)
465 		retval = dev->flush(dev, file);
466 
467 	mutex_unlock(&dev->mutex);
468 	return retval;
469 }
470 EXPORT_SYMBOL(input_flush_device);
471 
472 /**
473  * input_close_device - close input device
474  * @handle: handle through which device is being accessed
475  *
476  * This function should be called by input handlers when they
477  * want to stop receive events from given input device.
478  */
479 void input_close_device(struct input_handle *handle)
480 {
481 	struct input_dev *dev = handle->dev;
482 
483 	mutex_lock(&dev->mutex);
484 
485 	__input_release_device(handle);
486 
487 	if (!--dev->users && dev->close)
488 		dev->close(dev);
489 
490 	if (!--handle->open) {
491 		/*
492 		 * synchronize_rcu() makes sure that input_pass_event()
493 		 * completed and that no more input events are delivered
494 		 * through this handle
495 		 */
496 		synchronize_rcu();
497 	}
498 
499 	mutex_unlock(&dev->mutex);
500 }
501 EXPORT_SYMBOL(input_close_device);
502 
503 /*
504  * Prepare device for unregistering
505  */
506 static void input_disconnect_device(struct input_dev *dev)
507 {
508 	struct input_handle *handle;
509 	int code;
510 
511 	/*
512 	 * Mark device as going away. Note that we take dev->mutex here
513 	 * not to protect access to dev->going_away but rather to ensure
514 	 * that there are no threads in the middle of input_open_device()
515 	 */
516 	mutex_lock(&dev->mutex);
517 	dev->going_away = 1;
518 	mutex_unlock(&dev->mutex);
519 
520 	spin_lock_irq(&dev->event_lock);
521 
522 	/*
523 	 * Simulate keyup events for all pressed keys so that handlers
524 	 * are not left with "stuck" keys. The driver may continue
525 	 * generate events even after we done here but they will not
526 	 * reach any handlers.
527 	 */
528 	if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
529 		for (code = 0; code <= KEY_MAX; code++) {
530 			if (is_event_supported(code, dev->keybit, KEY_MAX) &&
531 			    __test_and_clear_bit(code, dev->key)) {
532 				input_pass_event(dev, EV_KEY, code, 0);
533 			}
534 		}
535 		input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
536 	}
537 
538 	list_for_each_entry(handle, &dev->h_list, d_node)
539 		handle->open = 0;
540 
541 	spin_unlock_irq(&dev->event_lock);
542 }
543 
544 static int input_fetch_keycode(struct input_dev *dev, int scancode)
545 {
546 	switch (dev->keycodesize) {
547 		case 1:
548 			return ((u8 *)dev->keycode)[scancode];
549 
550 		case 2:
551 			return ((u16 *)dev->keycode)[scancode];
552 
553 		default:
554 			return ((u32 *)dev->keycode)[scancode];
555 	}
556 }
557 
558 static int input_default_getkeycode(struct input_dev *dev,
559 				    int scancode, int *keycode)
560 {
561 	if (!dev->keycodesize)
562 		return -EINVAL;
563 
564 	if (scancode >= dev->keycodemax)
565 		return -EINVAL;
566 
567 	*keycode = input_fetch_keycode(dev, scancode);
568 
569 	return 0;
570 }
571 
572 static int input_default_setkeycode(struct input_dev *dev,
573 				    int scancode, int keycode)
574 {
575 	int old_keycode;
576 	int i;
577 
578 	if (scancode >= dev->keycodemax)
579 		return -EINVAL;
580 
581 	if (!dev->keycodesize)
582 		return -EINVAL;
583 
584 	if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
585 		return -EINVAL;
586 
587 	switch (dev->keycodesize) {
588 		case 1: {
589 			u8 *k = (u8 *)dev->keycode;
590 			old_keycode = k[scancode];
591 			k[scancode] = keycode;
592 			break;
593 		}
594 		case 2: {
595 			u16 *k = (u16 *)dev->keycode;
596 			old_keycode = k[scancode];
597 			k[scancode] = keycode;
598 			break;
599 		}
600 		default: {
601 			u32 *k = (u32 *)dev->keycode;
602 			old_keycode = k[scancode];
603 			k[scancode] = keycode;
604 			break;
605 		}
606 	}
607 
608 	clear_bit(old_keycode, dev->keybit);
609 	set_bit(keycode, dev->keybit);
610 
611 	for (i = 0; i < dev->keycodemax; i++) {
612 		if (input_fetch_keycode(dev, i) == old_keycode) {
613 			set_bit(old_keycode, dev->keybit);
614 			break; /* Setting the bit twice is useless, so break */
615 		}
616 	}
617 
618 	return 0;
619 }
620 
621 /**
622  * input_get_keycode - retrieve keycode currently mapped to a given scancode
623  * @dev: input device which keymap is being queried
624  * @scancode: scancode (or its equivalent for device in question) for which
625  *	keycode is needed
626  * @keycode: result
627  *
628  * This function should be called by anyone interested in retrieving current
629  * keymap. Presently keyboard and evdev handlers use it.
630  */
631 int input_get_keycode(struct input_dev *dev, int scancode, int *keycode)
632 {
633 	if (scancode < 0)
634 		return -EINVAL;
635 
636 	return dev->getkeycode(dev, scancode, keycode);
637 }
638 EXPORT_SYMBOL(input_get_keycode);
639 
640 /**
641  * input_get_keycode - assign new keycode to a given scancode
642  * @dev: input device which keymap is being updated
643  * @scancode: scancode (or its equivalent for device in question)
644  * @keycode: new keycode to be assigned to the scancode
645  *
646  * This function should be called by anyone needing to update current
647  * keymap. Presently keyboard and evdev handlers use it.
648  */
649 int input_set_keycode(struct input_dev *dev, int scancode, int keycode)
650 {
651 	unsigned long flags;
652 	int old_keycode;
653 	int retval;
654 
655 	if (scancode < 0)
656 		return -EINVAL;
657 
658 	if (keycode < 0 || keycode > KEY_MAX)
659 		return -EINVAL;
660 
661 	spin_lock_irqsave(&dev->event_lock, flags);
662 
663 	retval = dev->getkeycode(dev, scancode, &old_keycode);
664 	if (retval)
665 		goto out;
666 
667 	retval = dev->setkeycode(dev, scancode, keycode);
668 	if (retval)
669 		goto out;
670 
671 	/*
672 	 * Simulate keyup event if keycode is not present
673 	 * in the keymap anymore
674 	 */
675 	if (test_bit(EV_KEY, dev->evbit) &&
676 	    !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
677 	    __test_and_clear_bit(old_keycode, dev->key)) {
678 
679 		input_pass_event(dev, EV_KEY, old_keycode, 0);
680 		if (dev->sync)
681 			input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
682 	}
683 
684  out:
685 	spin_unlock_irqrestore(&dev->event_lock, flags);
686 
687 	return retval;
688 }
689 EXPORT_SYMBOL(input_set_keycode);
690 
691 #define MATCH_BIT(bit, max) \
692 		for (i = 0; i < BITS_TO_LONGS(max); i++) \
693 			if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
694 				break; \
695 		if (i != BITS_TO_LONGS(max)) \
696 			continue;
697 
698 static const struct input_device_id *input_match_device(const struct input_device_id *id,
699 							struct input_dev *dev)
700 {
701 	int i;
702 
703 	for (; id->flags || id->driver_info; id++) {
704 
705 		if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
706 			if (id->bustype != dev->id.bustype)
707 				continue;
708 
709 		if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
710 			if (id->vendor != dev->id.vendor)
711 				continue;
712 
713 		if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
714 			if (id->product != dev->id.product)
715 				continue;
716 
717 		if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
718 			if (id->version != dev->id.version)
719 				continue;
720 
721 		MATCH_BIT(evbit,  EV_MAX);
722 		MATCH_BIT(keybit, KEY_MAX);
723 		MATCH_BIT(relbit, REL_MAX);
724 		MATCH_BIT(absbit, ABS_MAX);
725 		MATCH_BIT(mscbit, MSC_MAX);
726 		MATCH_BIT(ledbit, LED_MAX);
727 		MATCH_BIT(sndbit, SND_MAX);
728 		MATCH_BIT(ffbit,  FF_MAX);
729 		MATCH_BIT(swbit,  SW_MAX);
730 
731 		return id;
732 	}
733 
734 	return NULL;
735 }
736 
737 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
738 {
739 	const struct input_device_id *id;
740 	int error;
741 
742 	if (handler->blacklist && input_match_device(handler->blacklist, dev))
743 		return -ENODEV;
744 
745 	id = input_match_device(handler->id_table, dev);
746 	if (!id)
747 		return -ENODEV;
748 
749 	error = handler->connect(handler, dev, id);
750 	if (error && error != -ENODEV)
751 		printk(KERN_ERR
752 			"input: failed to attach handler %s to device %s, "
753 			"error: %d\n",
754 			handler->name, kobject_name(&dev->dev.kobj), error);
755 
756 	return error;
757 }
758 
759 
760 #ifdef CONFIG_PROC_FS
761 
762 static struct proc_dir_entry *proc_bus_input_dir;
763 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
764 static int input_devices_state;
765 
766 static inline void input_wakeup_procfs_readers(void)
767 {
768 	input_devices_state++;
769 	wake_up(&input_devices_poll_wait);
770 }
771 
772 static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
773 {
774 	poll_wait(file, &input_devices_poll_wait, wait);
775 	if (file->f_version != input_devices_state) {
776 		file->f_version = input_devices_state;
777 		return POLLIN | POLLRDNORM;
778 	}
779 
780 	return 0;
781 }
782 
783 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
784 {
785 	if (mutex_lock_interruptible(&input_mutex))
786 		return NULL;
787 
788 	return seq_list_start(&input_dev_list, *pos);
789 }
790 
791 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
792 {
793 	return seq_list_next(v, &input_dev_list, pos);
794 }
795 
796 static void input_devices_seq_stop(struct seq_file *seq, void *v)
797 {
798 	mutex_unlock(&input_mutex);
799 }
800 
801 static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
802 				   unsigned long *bitmap, int max)
803 {
804 	int i;
805 
806 	for (i = BITS_TO_LONGS(max) - 1; i > 0; i--)
807 		if (bitmap[i])
808 			break;
809 
810 	seq_printf(seq, "B: %s=", name);
811 	for (; i >= 0; i--)
812 		seq_printf(seq, "%lx%s", bitmap[i], i > 0 ? " " : "");
813 	seq_putc(seq, '\n');
814 }
815 
816 static int input_devices_seq_show(struct seq_file *seq, void *v)
817 {
818 	struct input_dev *dev = container_of(v, struct input_dev, node);
819 	const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
820 	struct input_handle *handle;
821 
822 	seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
823 		   dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
824 
825 	seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
826 	seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
827 	seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
828 	seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
829 	seq_printf(seq, "H: Handlers=");
830 
831 	list_for_each_entry(handle, &dev->h_list, d_node)
832 		seq_printf(seq, "%s ", handle->name);
833 	seq_putc(seq, '\n');
834 
835 	input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
836 	if (test_bit(EV_KEY, dev->evbit))
837 		input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
838 	if (test_bit(EV_REL, dev->evbit))
839 		input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
840 	if (test_bit(EV_ABS, dev->evbit))
841 		input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
842 	if (test_bit(EV_MSC, dev->evbit))
843 		input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
844 	if (test_bit(EV_LED, dev->evbit))
845 		input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
846 	if (test_bit(EV_SND, dev->evbit))
847 		input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
848 	if (test_bit(EV_FF, dev->evbit))
849 		input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
850 	if (test_bit(EV_SW, dev->evbit))
851 		input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
852 
853 	seq_putc(seq, '\n');
854 
855 	kfree(path);
856 	return 0;
857 }
858 
859 static const struct seq_operations input_devices_seq_ops = {
860 	.start	= input_devices_seq_start,
861 	.next	= input_devices_seq_next,
862 	.stop	= input_devices_seq_stop,
863 	.show	= input_devices_seq_show,
864 };
865 
866 static int input_proc_devices_open(struct inode *inode, struct file *file)
867 {
868 	return seq_open(file, &input_devices_seq_ops);
869 }
870 
871 static const struct file_operations input_devices_fileops = {
872 	.owner		= THIS_MODULE,
873 	.open		= input_proc_devices_open,
874 	.poll		= input_proc_devices_poll,
875 	.read		= seq_read,
876 	.llseek		= seq_lseek,
877 	.release	= seq_release,
878 };
879 
880 static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
881 {
882 	if (mutex_lock_interruptible(&input_mutex))
883 		return NULL;
884 
885 	seq->private = (void *)(unsigned long)*pos;
886 	return seq_list_start(&input_handler_list, *pos);
887 }
888 
889 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
890 {
891 	seq->private = (void *)(unsigned long)(*pos + 1);
892 	return seq_list_next(v, &input_handler_list, pos);
893 }
894 
895 static void input_handlers_seq_stop(struct seq_file *seq, void *v)
896 {
897 	mutex_unlock(&input_mutex);
898 }
899 
900 static int input_handlers_seq_show(struct seq_file *seq, void *v)
901 {
902 	struct input_handler *handler = container_of(v, struct input_handler, node);
903 
904 	seq_printf(seq, "N: Number=%ld Name=%s",
905 		   (unsigned long)seq->private, handler->name);
906 	if (handler->fops)
907 		seq_printf(seq, " Minor=%d", handler->minor);
908 	seq_putc(seq, '\n');
909 
910 	return 0;
911 }
912 static const struct seq_operations input_handlers_seq_ops = {
913 	.start	= input_handlers_seq_start,
914 	.next	= input_handlers_seq_next,
915 	.stop	= input_handlers_seq_stop,
916 	.show	= input_handlers_seq_show,
917 };
918 
919 static int input_proc_handlers_open(struct inode *inode, struct file *file)
920 {
921 	return seq_open(file, &input_handlers_seq_ops);
922 }
923 
924 static const struct file_operations input_handlers_fileops = {
925 	.owner		= THIS_MODULE,
926 	.open		= input_proc_handlers_open,
927 	.read		= seq_read,
928 	.llseek		= seq_lseek,
929 	.release	= seq_release,
930 };
931 
932 static int __init input_proc_init(void)
933 {
934 	struct proc_dir_entry *entry;
935 
936 	proc_bus_input_dir = proc_mkdir("bus/input", NULL);
937 	if (!proc_bus_input_dir)
938 		return -ENOMEM;
939 
940 	entry = proc_create("devices", 0, proc_bus_input_dir,
941 			    &input_devices_fileops);
942 	if (!entry)
943 		goto fail1;
944 
945 	entry = proc_create("handlers", 0, proc_bus_input_dir,
946 			    &input_handlers_fileops);
947 	if (!entry)
948 		goto fail2;
949 
950 	return 0;
951 
952  fail2:	remove_proc_entry("devices", proc_bus_input_dir);
953  fail1: remove_proc_entry("bus/input", NULL);
954 	return -ENOMEM;
955 }
956 
957 static void input_proc_exit(void)
958 {
959 	remove_proc_entry("devices", proc_bus_input_dir);
960 	remove_proc_entry("handlers", proc_bus_input_dir);
961 	remove_proc_entry("bus/input", NULL);
962 }
963 
964 #else /* !CONFIG_PROC_FS */
965 static inline void input_wakeup_procfs_readers(void) { }
966 static inline int input_proc_init(void) { return 0; }
967 static inline void input_proc_exit(void) { }
968 #endif
969 
970 #define INPUT_DEV_STRING_ATTR_SHOW(name)				\
971 static ssize_t input_dev_show_##name(struct device *dev,		\
972 				     struct device_attribute *attr,	\
973 				     char *buf)				\
974 {									\
975 	struct input_dev *input_dev = to_input_dev(dev);		\
976 									\
977 	return scnprintf(buf, PAGE_SIZE, "%s\n",			\
978 			 input_dev->name ? input_dev->name : "");	\
979 }									\
980 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
981 
982 INPUT_DEV_STRING_ATTR_SHOW(name);
983 INPUT_DEV_STRING_ATTR_SHOW(phys);
984 INPUT_DEV_STRING_ATTR_SHOW(uniq);
985 
986 static int input_print_modalias_bits(char *buf, int size,
987 				     char name, unsigned long *bm,
988 				     unsigned int min_bit, unsigned int max_bit)
989 {
990 	int len = 0, i;
991 
992 	len += snprintf(buf, max(size, 0), "%c", name);
993 	for (i = min_bit; i < max_bit; i++)
994 		if (bm[BIT_WORD(i)] & BIT_MASK(i))
995 			len += snprintf(buf + len, max(size - len, 0), "%X,", i);
996 	return len;
997 }
998 
999 static int input_print_modalias(char *buf, int size, struct input_dev *id,
1000 				int add_cr)
1001 {
1002 	int len;
1003 
1004 	len = snprintf(buf, max(size, 0),
1005 		       "input:b%04Xv%04Xp%04Xe%04X-",
1006 		       id->id.bustype, id->id.vendor,
1007 		       id->id.product, id->id.version);
1008 
1009 	len += input_print_modalias_bits(buf + len, size - len,
1010 				'e', id->evbit, 0, EV_MAX);
1011 	len += input_print_modalias_bits(buf + len, size - len,
1012 				'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1013 	len += input_print_modalias_bits(buf + len, size - len,
1014 				'r', id->relbit, 0, REL_MAX);
1015 	len += input_print_modalias_bits(buf + len, size - len,
1016 				'a', id->absbit, 0, ABS_MAX);
1017 	len += input_print_modalias_bits(buf + len, size - len,
1018 				'm', id->mscbit, 0, MSC_MAX);
1019 	len += input_print_modalias_bits(buf + len, size - len,
1020 				'l', id->ledbit, 0, LED_MAX);
1021 	len += input_print_modalias_bits(buf + len, size - len,
1022 				's', id->sndbit, 0, SND_MAX);
1023 	len += input_print_modalias_bits(buf + len, size - len,
1024 				'f', id->ffbit, 0, FF_MAX);
1025 	len += input_print_modalias_bits(buf + len, size - len,
1026 				'w', id->swbit, 0, SW_MAX);
1027 
1028 	if (add_cr)
1029 		len += snprintf(buf + len, max(size - len, 0), "\n");
1030 
1031 	return len;
1032 }
1033 
1034 static ssize_t input_dev_show_modalias(struct device *dev,
1035 				       struct device_attribute *attr,
1036 				       char *buf)
1037 {
1038 	struct input_dev *id = to_input_dev(dev);
1039 	ssize_t len;
1040 
1041 	len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1042 
1043 	return min_t(int, len, PAGE_SIZE);
1044 }
1045 static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1046 
1047 static struct attribute *input_dev_attrs[] = {
1048 	&dev_attr_name.attr,
1049 	&dev_attr_phys.attr,
1050 	&dev_attr_uniq.attr,
1051 	&dev_attr_modalias.attr,
1052 	NULL
1053 };
1054 
1055 static struct attribute_group input_dev_attr_group = {
1056 	.attrs	= input_dev_attrs,
1057 };
1058 
1059 #define INPUT_DEV_ID_ATTR(name)						\
1060 static ssize_t input_dev_show_id_##name(struct device *dev,		\
1061 					struct device_attribute *attr,	\
1062 					char *buf)			\
1063 {									\
1064 	struct input_dev *input_dev = to_input_dev(dev);		\
1065 	return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name);	\
1066 }									\
1067 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1068 
1069 INPUT_DEV_ID_ATTR(bustype);
1070 INPUT_DEV_ID_ATTR(vendor);
1071 INPUT_DEV_ID_ATTR(product);
1072 INPUT_DEV_ID_ATTR(version);
1073 
1074 static struct attribute *input_dev_id_attrs[] = {
1075 	&dev_attr_bustype.attr,
1076 	&dev_attr_vendor.attr,
1077 	&dev_attr_product.attr,
1078 	&dev_attr_version.attr,
1079 	NULL
1080 };
1081 
1082 static struct attribute_group input_dev_id_attr_group = {
1083 	.name	= "id",
1084 	.attrs	= input_dev_id_attrs,
1085 };
1086 
1087 static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1088 			      int max, int add_cr)
1089 {
1090 	int i;
1091 	int len = 0;
1092 
1093 	for (i = BITS_TO_LONGS(max) - 1; i > 0; i--)
1094 		if (bitmap[i])
1095 			break;
1096 
1097 	for (; i >= 0; i--)
1098 		len += snprintf(buf + len, max(buf_size - len, 0),
1099 				"%lx%s", bitmap[i], i > 0 ? " " : "");
1100 
1101 	if (add_cr)
1102 		len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1103 
1104 	return len;
1105 }
1106 
1107 #define INPUT_DEV_CAP_ATTR(ev, bm)					\
1108 static ssize_t input_dev_show_cap_##bm(struct device *dev,		\
1109 				       struct device_attribute *attr,	\
1110 				       char *buf)			\
1111 {									\
1112 	struct input_dev *input_dev = to_input_dev(dev);		\
1113 	int len = input_print_bitmap(buf, PAGE_SIZE,			\
1114 				     input_dev->bm##bit, ev##_MAX, 1);	\
1115 	return min_t(int, len, PAGE_SIZE);				\
1116 }									\
1117 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1118 
1119 INPUT_DEV_CAP_ATTR(EV, ev);
1120 INPUT_DEV_CAP_ATTR(KEY, key);
1121 INPUT_DEV_CAP_ATTR(REL, rel);
1122 INPUT_DEV_CAP_ATTR(ABS, abs);
1123 INPUT_DEV_CAP_ATTR(MSC, msc);
1124 INPUT_DEV_CAP_ATTR(LED, led);
1125 INPUT_DEV_CAP_ATTR(SND, snd);
1126 INPUT_DEV_CAP_ATTR(FF, ff);
1127 INPUT_DEV_CAP_ATTR(SW, sw);
1128 
1129 static struct attribute *input_dev_caps_attrs[] = {
1130 	&dev_attr_ev.attr,
1131 	&dev_attr_key.attr,
1132 	&dev_attr_rel.attr,
1133 	&dev_attr_abs.attr,
1134 	&dev_attr_msc.attr,
1135 	&dev_attr_led.attr,
1136 	&dev_attr_snd.attr,
1137 	&dev_attr_ff.attr,
1138 	&dev_attr_sw.attr,
1139 	NULL
1140 };
1141 
1142 static struct attribute_group input_dev_caps_attr_group = {
1143 	.name	= "capabilities",
1144 	.attrs	= input_dev_caps_attrs,
1145 };
1146 
1147 static const struct attribute_group *input_dev_attr_groups[] = {
1148 	&input_dev_attr_group,
1149 	&input_dev_id_attr_group,
1150 	&input_dev_caps_attr_group,
1151 	NULL
1152 };
1153 
1154 static void input_dev_release(struct device *device)
1155 {
1156 	struct input_dev *dev = to_input_dev(device);
1157 
1158 	input_ff_destroy(dev);
1159 	kfree(dev);
1160 
1161 	module_put(THIS_MODULE);
1162 }
1163 
1164 /*
1165  * Input uevent interface - loading event handlers based on
1166  * device bitfields.
1167  */
1168 static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1169 				   const char *name, unsigned long *bitmap, int max)
1170 {
1171 	int len;
1172 
1173 	if (add_uevent_var(env, "%s=", name))
1174 		return -ENOMEM;
1175 
1176 	len = input_print_bitmap(&env->buf[env->buflen - 1],
1177 				 sizeof(env->buf) - env->buflen,
1178 				 bitmap, max, 0);
1179 	if (len >= (sizeof(env->buf) - env->buflen))
1180 		return -ENOMEM;
1181 
1182 	env->buflen += len;
1183 	return 0;
1184 }
1185 
1186 static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1187 					 struct input_dev *dev)
1188 {
1189 	int len;
1190 
1191 	if (add_uevent_var(env, "MODALIAS="))
1192 		return -ENOMEM;
1193 
1194 	len = input_print_modalias(&env->buf[env->buflen - 1],
1195 				   sizeof(env->buf) - env->buflen,
1196 				   dev, 0);
1197 	if (len >= (sizeof(env->buf) - env->buflen))
1198 		return -ENOMEM;
1199 
1200 	env->buflen += len;
1201 	return 0;
1202 }
1203 
1204 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...)				\
1205 	do {								\
1206 		int err = add_uevent_var(env, fmt, val);		\
1207 		if (err)						\
1208 			return err;					\
1209 	} while (0)
1210 
1211 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)				\
1212 	do {								\
1213 		int err = input_add_uevent_bm_var(env, name, bm, max);	\
1214 		if (err)						\
1215 			return err;					\
1216 	} while (0)
1217 
1218 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)				\
1219 	do {								\
1220 		int err = input_add_uevent_modalias_var(env, dev);	\
1221 		if (err)						\
1222 			return err;					\
1223 	} while (0)
1224 
1225 static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1226 {
1227 	struct input_dev *dev = to_input_dev(device);
1228 
1229 	INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1230 				dev->id.bustype, dev->id.vendor,
1231 				dev->id.product, dev->id.version);
1232 	if (dev->name)
1233 		INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1234 	if (dev->phys)
1235 		INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1236 	if (dev->uniq)
1237 		INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1238 
1239 	INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1240 	if (test_bit(EV_KEY, dev->evbit))
1241 		INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1242 	if (test_bit(EV_REL, dev->evbit))
1243 		INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1244 	if (test_bit(EV_ABS, dev->evbit))
1245 		INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1246 	if (test_bit(EV_MSC, dev->evbit))
1247 		INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1248 	if (test_bit(EV_LED, dev->evbit))
1249 		INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1250 	if (test_bit(EV_SND, dev->evbit))
1251 		INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1252 	if (test_bit(EV_FF, dev->evbit))
1253 		INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1254 	if (test_bit(EV_SW, dev->evbit))
1255 		INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1256 
1257 	INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1258 
1259 	return 0;
1260 }
1261 
1262 static struct device_type input_dev_type = {
1263 	.groups		= input_dev_attr_groups,
1264 	.release	= input_dev_release,
1265 	.uevent		= input_dev_uevent,
1266 };
1267 
1268 static char *input_devnode(struct device *dev, mode_t *mode)
1269 {
1270 	return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1271 }
1272 
1273 struct class input_class = {
1274 	.name		= "input",
1275 	.devnode	= input_devnode,
1276 };
1277 EXPORT_SYMBOL_GPL(input_class);
1278 
1279 /**
1280  * input_allocate_device - allocate memory for new input device
1281  *
1282  * Returns prepared struct input_dev or NULL.
1283  *
1284  * NOTE: Use input_free_device() to free devices that have not been
1285  * registered; input_unregister_device() should be used for already
1286  * registered devices.
1287  */
1288 struct input_dev *input_allocate_device(void)
1289 {
1290 	struct input_dev *dev;
1291 
1292 	dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
1293 	if (dev) {
1294 		dev->dev.type = &input_dev_type;
1295 		dev->dev.class = &input_class;
1296 		device_initialize(&dev->dev);
1297 		mutex_init(&dev->mutex);
1298 		spin_lock_init(&dev->event_lock);
1299 		INIT_LIST_HEAD(&dev->h_list);
1300 		INIT_LIST_HEAD(&dev->node);
1301 
1302 		__module_get(THIS_MODULE);
1303 	}
1304 
1305 	return dev;
1306 }
1307 EXPORT_SYMBOL(input_allocate_device);
1308 
1309 /**
1310  * input_free_device - free memory occupied by input_dev structure
1311  * @dev: input device to free
1312  *
1313  * This function should only be used if input_register_device()
1314  * was not called yet or if it failed. Once device was registered
1315  * use input_unregister_device() and memory will be freed once last
1316  * reference to the device is dropped.
1317  *
1318  * Device should be allocated by input_allocate_device().
1319  *
1320  * NOTE: If there are references to the input device then memory
1321  * will not be freed until last reference is dropped.
1322  */
1323 void input_free_device(struct input_dev *dev)
1324 {
1325 	if (dev)
1326 		input_put_device(dev);
1327 }
1328 EXPORT_SYMBOL(input_free_device);
1329 
1330 /**
1331  * input_set_capability - mark device as capable of a certain event
1332  * @dev: device that is capable of emitting or accepting event
1333  * @type: type of the event (EV_KEY, EV_REL, etc...)
1334  * @code: event code
1335  *
1336  * In addition to setting up corresponding bit in appropriate capability
1337  * bitmap the function also adjusts dev->evbit.
1338  */
1339 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1340 {
1341 	switch (type) {
1342 	case EV_KEY:
1343 		__set_bit(code, dev->keybit);
1344 		break;
1345 
1346 	case EV_REL:
1347 		__set_bit(code, dev->relbit);
1348 		break;
1349 
1350 	case EV_ABS:
1351 		__set_bit(code, dev->absbit);
1352 		break;
1353 
1354 	case EV_MSC:
1355 		__set_bit(code, dev->mscbit);
1356 		break;
1357 
1358 	case EV_SW:
1359 		__set_bit(code, dev->swbit);
1360 		break;
1361 
1362 	case EV_LED:
1363 		__set_bit(code, dev->ledbit);
1364 		break;
1365 
1366 	case EV_SND:
1367 		__set_bit(code, dev->sndbit);
1368 		break;
1369 
1370 	case EV_FF:
1371 		__set_bit(code, dev->ffbit);
1372 		break;
1373 
1374 	case EV_PWR:
1375 		/* do nothing */
1376 		break;
1377 
1378 	default:
1379 		printk(KERN_ERR
1380 			"input_set_capability: unknown type %u (code %u)\n",
1381 			type, code);
1382 		dump_stack();
1383 		return;
1384 	}
1385 
1386 	__set_bit(type, dev->evbit);
1387 }
1388 EXPORT_SYMBOL(input_set_capability);
1389 
1390 /**
1391  * input_register_device - register device with input core
1392  * @dev: device to be registered
1393  *
1394  * This function registers device with input core. The device must be
1395  * allocated with input_allocate_device() and all it's capabilities
1396  * set up before registering.
1397  * If function fails the device must be freed with input_free_device().
1398  * Once device has been successfully registered it can be unregistered
1399  * with input_unregister_device(); input_free_device() should not be
1400  * called in this case.
1401  */
1402 int input_register_device(struct input_dev *dev)
1403 {
1404 	static atomic_t input_no = ATOMIC_INIT(0);
1405 	struct input_handler *handler;
1406 	const char *path;
1407 	int error;
1408 
1409 	__set_bit(EV_SYN, dev->evbit);
1410 
1411 	/*
1412 	 * If delay and period are pre-set by the driver, then autorepeating
1413 	 * is handled by the driver itself and we don't do it in input.c.
1414 	 */
1415 
1416 	init_timer(&dev->timer);
1417 	if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
1418 		dev->timer.data = (long) dev;
1419 		dev->timer.function = input_repeat_key;
1420 		dev->rep[REP_DELAY] = 250;
1421 		dev->rep[REP_PERIOD] = 33;
1422 	}
1423 
1424 	if (!dev->getkeycode)
1425 		dev->getkeycode = input_default_getkeycode;
1426 
1427 	if (!dev->setkeycode)
1428 		dev->setkeycode = input_default_setkeycode;
1429 
1430 	dev_set_name(&dev->dev, "input%ld",
1431 		     (unsigned long) atomic_inc_return(&input_no) - 1);
1432 
1433 	error = device_add(&dev->dev);
1434 	if (error)
1435 		return error;
1436 
1437 	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1438 	printk(KERN_INFO "input: %s as %s\n",
1439 		dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
1440 	kfree(path);
1441 
1442 	error = mutex_lock_interruptible(&input_mutex);
1443 	if (error) {
1444 		device_del(&dev->dev);
1445 		return error;
1446 	}
1447 
1448 	list_add_tail(&dev->node, &input_dev_list);
1449 
1450 	list_for_each_entry(handler, &input_handler_list, node)
1451 		input_attach_handler(dev, handler);
1452 
1453 	input_wakeup_procfs_readers();
1454 
1455 	mutex_unlock(&input_mutex);
1456 
1457 	return 0;
1458 }
1459 EXPORT_SYMBOL(input_register_device);
1460 
1461 /**
1462  * input_unregister_device - unregister previously registered device
1463  * @dev: device to be unregistered
1464  *
1465  * This function unregisters an input device. Once device is unregistered
1466  * the caller should not try to access it as it may get freed at any moment.
1467  */
1468 void input_unregister_device(struct input_dev *dev)
1469 {
1470 	struct input_handle *handle, *next;
1471 
1472 	input_disconnect_device(dev);
1473 
1474 	mutex_lock(&input_mutex);
1475 
1476 	list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
1477 		handle->handler->disconnect(handle);
1478 	WARN_ON(!list_empty(&dev->h_list));
1479 
1480 	del_timer_sync(&dev->timer);
1481 	list_del_init(&dev->node);
1482 
1483 	input_wakeup_procfs_readers();
1484 
1485 	mutex_unlock(&input_mutex);
1486 
1487 	device_unregister(&dev->dev);
1488 }
1489 EXPORT_SYMBOL(input_unregister_device);
1490 
1491 /**
1492  * input_register_handler - register a new input handler
1493  * @handler: handler to be registered
1494  *
1495  * This function registers a new input handler (interface) for input
1496  * devices in the system and attaches it to all input devices that
1497  * are compatible with the handler.
1498  */
1499 int input_register_handler(struct input_handler *handler)
1500 {
1501 	struct input_dev *dev;
1502 	int retval;
1503 
1504 	retval = mutex_lock_interruptible(&input_mutex);
1505 	if (retval)
1506 		return retval;
1507 
1508 	INIT_LIST_HEAD(&handler->h_list);
1509 
1510 	if (handler->fops != NULL) {
1511 		if (input_table[handler->minor >> 5]) {
1512 			retval = -EBUSY;
1513 			goto out;
1514 		}
1515 		input_table[handler->minor >> 5] = handler;
1516 	}
1517 
1518 	list_add_tail(&handler->node, &input_handler_list);
1519 
1520 	list_for_each_entry(dev, &input_dev_list, node)
1521 		input_attach_handler(dev, handler);
1522 
1523 	input_wakeup_procfs_readers();
1524 
1525  out:
1526 	mutex_unlock(&input_mutex);
1527 	return retval;
1528 }
1529 EXPORT_SYMBOL(input_register_handler);
1530 
1531 /**
1532  * input_unregister_handler - unregisters an input handler
1533  * @handler: handler to be unregistered
1534  *
1535  * This function disconnects a handler from its input devices and
1536  * removes it from lists of known handlers.
1537  */
1538 void input_unregister_handler(struct input_handler *handler)
1539 {
1540 	struct input_handle *handle, *next;
1541 
1542 	mutex_lock(&input_mutex);
1543 
1544 	list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
1545 		handler->disconnect(handle);
1546 	WARN_ON(!list_empty(&handler->h_list));
1547 
1548 	list_del_init(&handler->node);
1549 
1550 	if (handler->fops != NULL)
1551 		input_table[handler->minor >> 5] = NULL;
1552 
1553 	input_wakeup_procfs_readers();
1554 
1555 	mutex_unlock(&input_mutex);
1556 }
1557 EXPORT_SYMBOL(input_unregister_handler);
1558 
1559 /**
1560  * input_register_handle - register a new input handle
1561  * @handle: handle to register
1562  *
1563  * This function puts a new input handle onto device's
1564  * and handler's lists so that events can flow through
1565  * it once it is opened using input_open_device().
1566  *
1567  * This function is supposed to be called from handler's
1568  * connect() method.
1569  */
1570 int input_register_handle(struct input_handle *handle)
1571 {
1572 	struct input_handler *handler = handle->handler;
1573 	struct input_dev *dev = handle->dev;
1574 	int error;
1575 
1576 	/*
1577 	 * We take dev->mutex here to prevent race with
1578 	 * input_release_device().
1579 	 */
1580 	error = mutex_lock_interruptible(&dev->mutex);
1581 	if (error)
1582 		return error;
1583 	list_add_tail_rcu(&handle->d_node, &dev->h_list);
1584 	mutex_unlock(&dev->mutex);
1585 
1586 	/*
1587 	 * Since we are supposed to be called from ->connect()
1588 	 * which is mutually exclusive with ->disconnect()
1589 	 * we can't be racing with input_unregister_handle()
1590 	 * and so separate lock is not needed here.
1591 	 */
1592 	list_add_tail(&handle->h_node, &handler->h_list);
1593 
1594 	if (handler->start)
1595 		handler->start(handle);
1596 
1597 	return 0;
1598 }
1599 EXPORT_SYMBOL(input_register_handle);
1600 
1601 /**
1602  * input_unregister_handle - unregister an input handle
1603  * @handle: handle to unregister
1604  *
1605  * This function removes input handle from device's
1606  * and handler's lists.
1607  *
1608  * This function is supposed to be called from handler's
1609  * disconnect() method.
1610  */
1611 void input_unregister_handle(struct input_handle *handle)
1612 {
1613 	struct input_dev *dev = handle->dev;
1614 
1615 	list_del_init(&handle->h_node);
1616 
1617 	/*
1618 	 * Take dev->mutex to prevent race with input_release_device().
1619 	 */
1620 	mutex_lock(&dev->mutex);
1621 	list_del_rcu(&handle->d_node);
1622 	mutex_unlock(&dev->mutex);
1623 	synchronize_rcu();
1624 }
1625 EXPORT_SYMBOL(input_unregister_handle);
1626 
1627 static int input_open_file(struct inode *inode, struct file *file)
1628 {
1629 	struct input_handler *handler;
1630 	const struct file_operations *old_fops, *new_fops = NULL;
1631 	int err;
1632 
1633 	lock_kernel();
1634 	/* No load-on-demand here? */
1635 	handler = input_table[iminor(inode) >> 5];
1636 	if (!handler || !(new_fops = fops_get(handler->fops))) {
1637 		err = -ENODEV;
1638 		goto out;
1639 	}
1640 
1641 	/*
1642 	 * That's _really_ odd. Usually NULL ->open means "nothing special",
1643 	 * not "no device". Oh, well...
1644 	 */
1645 	if (!new_fops->open) {
1646 		fops_put(new_fops);
1647 		err = -ENODEV;
1648 		goto out;
1649 	}
1650 	old_fops = file->f_op;
1651 	file->f_op = new_fops;
1652 
1653 	err = new_fops->open(inode, file);
1654 
1655 	if (err) {
1656 		fops_put(file->f_op);
1657 		file->f_op = fops_get(old_fops);
1658 	}
1659 	fops_put(old_fops);
1660 out:
1661 	unlock_kernel();
1662 	return err;
1663 }
1664 
1665 static const struct file_operations input_fops = {
1666 	.owner = THIS_MODULE,
1667 	.open = input_open_file,
1668 };
1669 
1670 static void __init input_init_abs_bypass(void)
1671 {
1672 	const unsigned int *p;
1673 
1674 	for (p = input_abs_bypass_init_data; *p; p++)
1675 		input_abs_bypass[BIT_WORD(*p)] |= BIT_MASK(*p);
1676 }
1677 
1678 static int __init input_init(void)
1679 {
1680 	int err;
1681 
1682 	input_init_abs_bypass();
1683 
1684 	err = class_register(&input_class);
1685 	if (err) {
1686 		printk(KERN_ERR "input: unable to register input_dev class\n");
1687 		return err;
1688 	}
1689 
1690 	err = input_proc_init();
1691 	if (err)
1692 		goto fail1;
1693 
1694 	err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
1695 	if (err) {
1696 		printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
1697 		goto fail2;
1698 	}
1699 
1700 	return 0;
1701 
1702  fail2:	input_proc_exit();
1703  fail1:	class_unregister(&input_class);
1704 	return err;
1705 }
1706 
1707 static void __exit input_exit(void)
1708 {
1709 	input_proc_exit();
1710 	unregister_chrdev(INPUT_MAJOR, "input");
1711 	class_unregister(&input_class);
1712 }
1713 
1714 subsys_initcall(input_init);
1715 module_exit(input_exit);
1716