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