1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (c) 1999-2002 Vojtech Pavlik
9 #define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
11 #include <linux/init.h>
12 #include <linux/types.h>
13 #include <linux/idr.h>
14 #include <linux/input/mt.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/random.h>
18 #include <linux/major.h>
19 #include <linux/proc_fs.h>
20 #include <linux/sched.h>
21 #include <linux/seq_file.h>
23 #include <linux/poll.h>
24 #include <linux/device.h>
25 #include <linux/kstrtox.h>
26 #include <linux/mutex.h>
27 #include <linux/rcupdate.h>
28 #include "input-compat.h"
29 #include "input-core-private.h"
30 #include "input-poller.h"
32 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
33 MODULE_DESCRIPTION("Input core");
34 MODULE_LICENSE("GPL");
36 #define INPUT_MAX_CHAR_DEVICES 1024
37 #define INPUT_FIRST_DYNAMIC_DEV 256
38 static DEFINE_IDA(input_ida
);
40 static LIST_HEAD(input_dev_list
);
41 static LIST_HEAD(input_handler_list
);
44 * input_mutex protects access to both input_dev_list and input_handler_list.
45 * This also causes input_[un]register_device and input_[un]register_handler
46 * be mutually exclusive which simplifies locking in drivers implementing
49 static DEFINE_MUTEX(input_mutex
);
51 static const struct input_value input_value_sync
= { EV_SYN
, SYN_REPORT
, 1 };
53 static const unsigned int input_max_code
[EV_CNT
] = {
64 static inline int is_event_supported(unsigned int code
,
65 unsigned long *bm
, unsigned int max
)
67 return code
<= max
&& test_bit(code
, bm
);
70 static int input_defuzz_abs_event(int value
, int old_val
, int fuzz
)
73 if (value
> old_val
- fuzz
/ 2 && value
< old_val
+ fuzz
/ 2)
76 if (value
> old_val
- fuzz
&& value
< old_val
+ fuzz
)
77 return (old_val
* 3 + value
) / 4;
79 if (value
> old_val
- fuzz
* 2 && value
< old_val
+ fuzz
* 2)
80 return (old_val
+ value
) / 2;
86 static void input_start_autorepeat(struct input_dev
*dev
, int code
)
88 if (test_bit(EV_REP
, dev
->evbit
) &&
89 dev
->rep
[REP_PERIOD
] && dev
->rep
[REP_DELAY
] &&
90 dev
->timer
.function
) {
91 dev
->repeat_key
= code
;
92 mod_timer(&dev
->timer
,
93 jiffies
+ msecs_to_jiffies(dev
->rep
[REP_DELAY
]));
97 static void input_stop_autorepeat(struct input_dev
*dev
)
99 del_timer(&dev
->timer
);
103 * Pass values first through all filters and then, if event has not been
104 * filtered out, through all open handles. This order is achieved by placing
105 * filters at the head of the list of handles attached to the device, and
106 * placing regular handles at the tail of the list.
108 * This function is called with dev->event_lock held and interrupts disabled.
110 static void input_pass_values(struct input_dev
*dev
,
111 struct input_value
*vals
, unsigned int count
)
113 struct input_handle
*handle
;
114 struct input_value
*v
;
116 lockdep_assert_held(&dev
->event_lock
);
120 handle
= rcu_dereference(dev
->grab
);
122 count
= handle
->handle_events(handle
, vals
, count
);
124 list_for_each_entry_rcu(handle
, &dev
->h_list
, d_node
)
126 count
= handle
->handle_events(handle
, vals
,
135 /* trigger auto repeat for key events */
136 if (test_bit(EV_REP
, dev
->evbit
) && test_bit(EV_KEY
, dev
->evbit
)) {
137 for (v
= vals
; v
!= vals
+ count
; v
++) {
138 if (v
->type
== EV_KEY
&& v
->value
!= 2) {
140 input_start_autorepeat(dev
, v
->code
);
142 input_stop_autorepeat(dev
);
148 #define INPUT_IGNORE_EVENT 0
149 #define INPUT_PASS_TO_HANDLERS 1
150 #define INPUT_PASS_TO_DEVICE 2
152 #define INPUT_FLUSH 8
153 #define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
155 static int input_handle_abs_event(struct input_dev
*dev
,
156 unsigned int code
, int *pval
)
158 struct input_mt
*mt
= dev
->mt
;
159 bool is_new_slot
= false;
163 if (code
== ABS_MT_SLOT
) {
165 * "Stage" the event; we'll flush it later, when we
166 * get actual touch data.
168 if (mt
&& *pval
>= 0 && *pval
< mt
->num_slots
)
171 return INPUT_IGNORE_EVENT
;
174 is_mt_event
= input_is_mt_value(code
);
177 pold
= &dev
->absinfo
[code
].value
;
179 pold
= &mt
->slots
[mt
->slot
].abs
[code
- ABS_MT_FIRST
];
180 is_new_slot
= mt
->slot
!= dev
->absinfo
[ABS_MT_SLOT
].value
;
183 * Bypass filtering for multi-touch events when
184 * not employing slots.
190 *pval
= input_defuzz_abs_event(*pval
, *pold
,
191 dev
->absinfo
[code
].fuzz
);
193 return INPUT_IGNORE_EVENT
;
198 /* Flush pending "slot" event */
200 dev
->absinfo
[ABS_MT_SLOT
].value
= mt
->slot
;
201 return INPUT_PASS_TO_HANDLERS
| INPUT_SLOT
;
204 return INPUT_PASS_TO_HANDLERS
;
207 static int input_get_disposition(struct input_dev
*dev
,
208 unsigned int type
, unsigned int code
, int *pval
)
210 int disposition
= INPUT_IGNORE_EVENT
;
213 /* filter-out events from inhibited devices */
215 return INPUT_IGNORE_EVENT
;
222 disposition
= INPUT_PASS_TO_ALL
;
226 disposition
= INPUT_PASS_TO_HANDLERS
| INPUT_FLUSH
;
229 disposition
= INPUT_PASS_TO_HANDLERS
;
235 if (is_event_supported(code
, dev
->keybit
, KEY_MAX
)) {
237 /* auto-repeat bypasses state updates */
239 disposition
= INPUT_PASS_TO_HANDLERS
;
243 if (!!test_bit(code
, dev
->key
) != !!value
) {
245 __change_bit(code
, dev
->key
);
246 disposition
= INPUT_PASS_TO_HANDLERS
;
252 if (is_event_supported(code
, dev
->swbit
, SW_MAX
) &&
253 !!test_bit(code
, dev
->sw
) != !!value
) {
255 __change_bit(code
, dev
->sw
);
256 disposition
= INPUT_PASS_TO_HANDLERS
;
261 if (is_event_supported(code
, dev
->absbit
, ABS_MAX
))
262 disposition
= input_handle_abs_event(dev
, code
, &value
);
267 if (is_event_supported(code
, dev
->relbit
, REL_MAX
) && value
)
268 disposition
= INPUT_PASS_TO_HANDLERS
;
273 if (is_event_supported(code
, dev
->mscbit
, MSC_MAX
))
274 disposition
= INPUT_PASS_TO_ALL
;
279 if (is_event_supported(code
, dev
->ledbit
, LED_MAX
) &&
280 !!test_bit(code
, dev
->led
) != !!value
) {
282 __change_bit(code
, dev
->led
);
283 disposition
= INPUT_PASS_TO_ALL
;
288 if (is_event_supported(code
, dev
->sndbit
, SND_MAX
)) {
290 if (!!test_bit(code
, dev
->snd
) != !!value
)
291 __change_bit(code
, dev
->snd
);
292 disposition
= INPUT_PASS_TO_ALL
;
297 if (code
<= REP_MAX
&& value
>= 0 && dev
->rep
[code
] != value
) {
298 dev
->rep
[code
] = value
;
299 disposition
= INPUT_PASS_TO_ALL
;
305 disposition
= INPUT_PASS_TO_ALL
;
309 disposition
= INPUT_PASS_TO_ALL
;
317 static void input_event_dispose(struct input_dev
*dev
, int disposition
,
318 unsigned int type
, unsigned int code
, int value
)
320 if ((disposition
& INPUT_PASS_TO_DEVICE
) && dev
->event
)
321 dev
->event(dev
, type
, code
, value
);
323 if (disposition
& INPUT_PASS_TO_HANDLERS
) {
324 struct input_value
*v
;
326 if (disposition
& INPUT_SLOT
) {
327 v
= &dev
->vals
[dev
->num_vals
++];
329 v
->code
= ABS_MT_SLOT
;
330 v
->value
= dev
->mt
->slot
;
333 v
= &dev
->vals
[dev
->num_vals
++];
339 if (disposition
& INPUT_FLUSH
) {
340 if (dev
->num_vals
>= 2)
341 input_pass_values(dev
, dev
->vals
, dev
->num_vals
);
344 * Reset the timestamp on flush so we won't end up
345 * with a stale one. Note we only need to reset the
346 * monolithic one as we use its presence when deciding
347 * whether to generate a synthetic timestamp.
349 dev
->timestamp
[INPUT_CLK_MONO
] = ktime_set(0, 0);
350 } else if (dev
->num_vals
>= dev
->max_vals
- 2) {
351 dev
->vals
[dev
->num_vals
++] = input_value_sync
;
352 input_pass_values(dev
, dev
->vals
, dev
->num_vals
);
357 void input_handle_event(struct input_dev
*dev
,
358 unsigned int type
, unsigned int code
, int value
)
362 lockdep_assert_held(&dev
->event_lock
);
364 disposition
= input_get_disposition(dev
, type
, code
, &value
);
365 if (disposition
!= INPUT_IGNORE_EVENT
) {
367 add_input_randomness(type
, code
, value
);
369 input_event_dispose(dev
, disposition
, type
, code
, value
);
374 * input_event() - report new input event
375 * @dev: device that generated the event
376 * @type: type of the event
378 * @value: value of the event
380 * This function should be used by drivers implementing various input
381 * devices to report input events. See also input_inject_event().
383 * NOTE: input_event() may be safely used right after input device was
384 * allocated with input_allocate_device(), even before it is registered
385 * with input_register_device(), but the event will not reach any of the
386 * input handlers. Such early invocation of input_event() may be used
387 * to 'seed' initial state of a switch or initial position of absolute
390 void input_event(struct input_dev
*dev
,
391 unsigned int type
, unsigned int code
, int value
)
395 if (is_event_supported(type
, dev
->evbit
, EV_MAX
)) {
397 spin_lock_irqsave(&dev
->event_lock
, flags
);
398 input_handle_event(dev
, type
, code
, value
);
399 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
402 EXPORT_SYMBOL(input_event
);
405 * input_inject_event() - send input event from input handler
406 * @handle: input handle to send event through
407 * @type: type of the event
409 * @value: value of the event
411 * Similar to input_event() but will ignore event if device is
412 * "grabbed" and handle injecting event is not the one that owns
415 void input_inject_event(struct input_handle
*handle
,
416 unsigned int type
, unsigned int code
, int value
)
418 struct input_dev
*dev
= handle
->dev
;
419 struct input_handle
*grab
;
422 if (is_event_supported(type
, dev
->evbit
, EV_MAX
)) {
423 spin_lock_irqsave(&dev
->event_lock
, flags
);
426 grab
= rcu_dereference(dev
->grab
);
427 if (!grab
|| grab
== handle
)
428 input_handle_event(dev
, type
, code
, value
);
431 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
434 EXPORT_SYMBOL(input_inject_event
);
437 * input_alloc_absinfo - allocates array of input_absinfo structs
438 * @dev: the input device emitting absolute events
440 * If the absinfo struct the caller asked for is already allocated, this
441 * functions will not do anything.
443 void input_alloc_absinfo(struct input_dev
*dev
)
448 dev
->absinfo
= kcalloc(ABS_CNT
, sizeof(*dev
->absinfo
), GFP_KERNEL
);
450 dev_err(dev
->dev
.parent
?: &dev
->dev
,
451 "%s: unable to allocate memory\n", __func__
);
453 * We will handle this allocation failure in
454 * input_register_device() when we refuse to register input
455 * device with ABS bits but without absinfo.
459 EXPORT_SYMBOL(input_alloc_absinfo
);
461 void input_set_abs_params(struct input_dev
*dev
, unsigned int axis
,
462 int min
, int max
, int fuzz
, int flat
)
464 struct input_absinfo
*absinfo
;
466 __set_bit(EV_ABS
, dev
->evbit
);
467 __set_bit(axis
, dev
->absbit
);
469 input_alloc_absinfo(dev
);
473 absinfo
= &dev
->absinfo
[axis
];
474 absinfo
->minimum
= min
;
475 absinfo
->maximum
= max
;
476 absinfo
->fuzz
= fuzz
;
477 absinfo
->flat
= flat
;
479 EXPORT_SYMBOL(input_set_abs_params
);
482 * input_copy_abs - Copy absinfo from one input_dev to another
483 * @dst: Destination input device to copy the abs settings to
484 * @dst_axis: ABS_* value selecting the destination axis
485 * @src: Source input device to copy the abs settings from
486 * @src_axis: ABS_* value selecting the source axis
488 * Set absinfo for the selected destination axis by copying it from
489 * the specified source input device's source axis.
490 * This is useful to e.g. setup a pen/stylus input-device for combined
491 * touchscreen/pen hardware where the pen uses the same coordinates as
494 void input_copy_abs(struct input_dev
*dst
, unsigned int dst_axis
,
495 const struct input_dev
*src
, unsigned int src_axis
)
497 /* src must have EV_ABS and src_axis set */
498 if (WARN_ON(!(test_bit(EV_ABS
, src
->evbit
) &&
499 test_bit(src_axis
, src
->absbit
))))
503 * input_alloc_absinfo() may have failed for the source. Our caller is
504 * expected to catch this when registering the input devices, which may
505 * happen after the input_copy_abs() call.
510 input_set_capability(dst
, EV_ABS
, dst_axis
);
514 dst
->absinfo
[dst_axis
] = src
->absinfo
[src_axis
];
516 EXPORT_SYMBOL(input_copy_abs
);
519 * input_grab_device - grabs device for exclusive use
520 * @handle: input handle that wants to own the device
522 * When a device is grabbed by an input handle all events generated by
523 * the device are delivered only to this handle. Also events injected
524 * by other input handles are ignored while device is grabbed.
526 int input_grab_device(struct input_handle
*handle
)
528 struct input_dev
*dev
= handle
->dev
;
531 retval
= mutex_lock_interruptible(&dev
->mutex
);
540 rcu_assign_pointer(dev
->grab
, handle
);
543 mutex_unlock(&dev
->mutex
);
546 EXPORT_SYMBOL(input_grab_device
);
548 static void __input_release_device(struct input_handle
*handle
)
550 struct input_dev
*dev
= handle
->dev
;
551 struct input_handle
*grabber
;
553 grabber
= rcu_dereference_protected(dev
->grab
,
554 lockdep_is_held(&dev
->mutex
));
555 if (grabber
== handle
) {
556 rcu_assign_pointer(dev
->grab
, NULL
);
557 /* Make sure input_pass_values() notices that grab is gone */
560 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
561 if (handle
->open
&& handle
->handler
->start
)
562 handle
->handler
->start(handle
);
567 * input_release_device - release previously grabbed device
568 * @handle: input handle that owns the device
570 * Releases previously grabbed device so that other input handles can
571 * start receiving input events. Upon release all handlers attached
572 * to the device have their start() method called so they have a change
573 * to synchronize device state with the rest of the system.
575 void input_release_device(struct input_handle
*handle
)
577 struct input_dev
*dev
= handle
->dev
;
579 mutex_lock(&dev
->mutex
);
580 __input_release_device(handle
);
581 mutex_unlock(&dev
->mutex
);
583 EXPORT_SYMBOL(input_release_device
);
586 * input_open_device - open input device
587 * @handle: handle through which device is being accessed
589 * This function should be called by input handlers when they
590 * want to start receive events from given input device.
592 int input_open_device(struct input_handle
*handle
)
594 struct input_dev
*dev
= handle
->dev
;
597 retval
= mutex_lock_interruptible(&dev
->mutex
);
601 if (dev
->going_away
) {
608 if (handle
->handler
->passive_observer
)
611 if (dev
->users
++ || dev
->inhibited
) {
613 * Device is already opened and/or inhibited,
614 * so we can exit immediately and report success.
620 retval
= dev
->open(dev
);
625 * Make sure we are not delivering any more events
626 * through this handle
634 input_dev_poller_start(dev
->poller
);
637 mutex_unlock(&dev
->mutex
);
640 EXPORT_SYMBOL(input_open_device
);
642 int input_flush_device(struct input_handle
*handle
, struct file
*file
)
644 struct input_dev
*dev
= handle
->dev
;
647 retval
= mutex_lock_interruptible(&dev
->mutex
);
652 retval
= dev
->flush(dev
, file
);
654 mutex_unlock(&dev
->mutex
);
657 EXPORT_SYMBOL(input_flush_device
);
660 * input_close_device - close input device
661 * @handle: handle through which device is being accessed
663 * This function should be called by input handlers when they
664 * want to stop receive events from given input device.
666 void input_close_device(struct input_handle
*handle
)
668 struct input_dev
*dev
= handle
->dev
;
670 mutex_lock(&dev
->mutex
);
672 __input_release_device(handle
);
674 if (!handle
->handler
->passive_observer
) {
675 if (!--dev
->users
&& !dev
->inhibited
) {
677 input_dev_poller_stop(dev
->poller
);
683 if (!--handle
->open
) {
685 * synchronize_rcu() makes sure that input_pass_values()
686 * completed and that no more input events are delivered
687 * through this handle
692 mutex_unlock(&dev
->mutex
);
694 EXPORT_SYMBOL(input_close_device
);
697 * Simulate keyup events for all keys that are marked as pressed.
698 * The function must be called with dev->event_lock held.
700 static bool input_dev_release_keys(struct input_dev
*dev
)
702 bool need_sync
= false;
705 lockdep_assert_held(&dev
->event_lock
);
707 if (is_event_supported(EV_KEY
, dev
->evbit
, EV_MAX
)) {
708 for_each_set_bit(code
, dev
->key
, KEY_CNT
) {
709 input_handle_event(dev
, EV_KEY
, code
, 0);
718 * Prepare device for unregistering
720 static void input_disconnect_device(struct input_dev
*dev
)
722 struct input_handle
*handle
;
725 * Mark device as going away. Note that we take dev->mutex here
726 * not to protect access to dev->going_away but rather to ensure
727 * that there are no threads in the middle of input_open_device()
729 mutex_lock(&dev
->mutex
);
730 dev
->going_away
= true;
731 mutex_unlock(&dev
->mutex
);
733 spin_lock_irq(&dev
->event_lock
);
736 * Simulate keyup events for all pressed keys so that handlers
737 * are not left with "stuck" keys. The driver may continue
738 * generate events even after we done here but they will not
739 * reach any handlers.
741 if (input_dev_release_keys(dev
))
742 input_handle_event(dev
, EV_SYN
, SYN_REPORT
, 1);
744 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
747 spin_unlock_irq(&dev
->event_lock
);
751 * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
752 * @ke: keymap entry containing scancode to be converted.
753 * @scancode: pointer to the location where converted scancode should
756 * This function is used to convert scancode stored in &struct keymap_entry
757 * into scalar form understood by legacy keymap handling methods. These
758 * methods expect scancodes to be represented as 'unsigned int'.
760 int input_scancode_to_scalar(const struct input_keymap_entry
*ke
,
761 unsigned int *scancode
)
765 *scancode
= *((u8
*)ke
->scancode
);
769 *scancode
= *((u16
*)ke
->scancode
);
773 *scancode
= *((u32
*)ke
->scancode
);
782 EXPORT_SYMBOL(input_scancode_to_scalar
);
785 * Those routines handle the default case where no [gs]etkeycode() is
786 * defined. In this case, an array indexed by the scancode is used.
789 static unsigned int input_fetch_keycode(struct input_dev
*dev
,
792 switch (dev
->keycodesize
) {
794 return ((u8
*)dev
->keycode
)[index
];
797 return ((u16
*)dev
->keycode
)[index
];
800 return ((u32
*)dev
->keycode
)[index
];
804 static int input_default_getkeycode(struct input_dev
*dev
,
805 struct input_keymap_entry
*ke
)
810 if (!dev
->keycodesize
)
813 if (ke
->flags
& INPUT_KEYMAP_BY_INDEX
)
816 error
= input_scancode_to_scalar(ke
, &index
);
821 if (index
>= dev
->keycodemax
)
824 ke
->keycode
= input_fetch_keycode(dev
, index
);
826 ke
->len
= sizeof(index
);
827 memcpy(ke
->scancode
, &index
, sizeof(index
));
832 static int input_default_setkeycode(struct input_dev
*dev
,
833 const struct input_keymap_entry
*ke
,
834 unsigned int *old_keycode
)
840 if (!dev
->keycodesize
)
843 if (ke
->flags
& INPUT_KEYMAP_BY_INDEX
) {
846 error
= input_scancode_to_scalar(ke
, &index
);
851 if (index
>= dev
->keycodemax
)
854 if (dev
->keycodesize
< sizeof(ke
->keycode
) &&
855 (ke
->keycode
>> (dev
->keycodesize
* 8)))
858 switch (dev
->keycodesize
) {
860 u8
*k
= (u8
*)dev
->keycode
;
861 *old_keycode
= k
[index
];
862 k
[index
] = ke
->keycode
;
866 u16
*k
= (u16
*)dev
->keycode
;
867 *old_keycode
= k
[index
];
868 k
[index
] = ke
->keycode
;
872 u32
*k
= (u32
*)dev
->keycode
;
873 *old_keycode
= k
[index
];
874 k
[index
] = ke
->keycode
;
879 if (*old_keycode
<= KEY_MAX
) {
880 __clear_bit(*old_keycode
, dev
->keybit
);
881 for (i
= 0; i
< dev
->keycodemax
; i
++) {
882 if (input_fetch_keycode(dev
, i
) == *old_keycode
) {
883 __set_bit(*old_keycode
, dev
->keybit
);
884 /* Setting the bit twice is useless, so break */
890 __set_bit(ke
->keycode
, dev
->keybit
);
895 * input_get_keycode - retrieve keycode currently mapped to a given scancode
896 * @dev: input device which keymap is being queried
899 * This function should be called by anyone interested in retrieving current
900 * keymap. Presently evdev handlers use it.
902 int input_get_keycode(struct input_dev
*dev
, struct input_keymap_entry
*ke
)
907 spin_lock_irqsave(&dev
->event_lock
, flags
);
908 retval
= dev
->getkeycode(dev
, ke
);
909 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
913 EXPORT_SYMBOL(input_get_keycode
);
916 * input_set_keycode - attribute a keycode to a given scancode
917 * @dev: input device which keymap is being updated
918 * @ke: new keymap entry
920 * This function should be called by anyone needing to update current
921 * keymap. Presently keyboard and evdev handlers use it.
923 int input_set_keycode(struct input_dev
*dev
,
924 const struct input_keymap_entry
*ke
)
927 unsigned int old_keycode
;
930 if (ke
->keycode
> KEY_MAX
)
933 spin_lock_irqsave(&dev
->event_lock
, flags
);
935 retval
= dev
->setkeycode(dev
, ke
, &old_keycode
);
939 /* Make sure KEY_RESERVED did not get enabled. */
940 __clear_bit(KEY_RESERVED
, dev
->keybit
);
943 * Simulate keyup event if keycode is not present
944 * in the keymap anymore
946 if (old_keycode
> KEY_MAX
) {
947 dev_warn(dev
->dev
.parent
?: &dev
->dev
,
948 "%s: got too big old keycode %#x\n",
949 __func__
, old_keycode
);
950 } else if (test_bit(EV_KEY
, dev
->evbit
) &&
951 !is_event_supported(old_keycode
, dev
->keybit
, KEY_MAX
) &&
952 __test_and_clear_bit(old_keycode
, dev
->key
)) {
954 * We have to use input_event_dispose() here directly instead
955 * of input_handle_event() because the key we want to release
956 * here is considered no longer supported by the device and
957 * input_handle_event() will ignore it.
959 input_event_dispose(dev
, INPUT_PASS_TO_HANDLERS
,
960 EV_KEY
, old_keycode
, 0);
961 input_event_dispose(dev
, INPUT_PASS_TO_HANDLERS
| INPUT_FLUSH
,
962 EV_SYN
, SYN_REPORT
, 1);
966 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
970 EXPORT_SYMBOL(input_set_keycode
);
972 bool input_match_device_id(const struct input_dev
*dev
,
973 const struct input_device_id
*id
)
975 if (id
->flags
& INPUT_DEVICE_ID_MATCH_BUS
)
976 if (id
->bustype
!= dev
->id
.bustype
)
979 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VENDOR
)
980 if (id
->vendor
!= dev
->id
.vendor
)
983 if (id
->flags
& INPUT_DEVICE_ID_MATCH_PRODUCT
)
984 if (id
->product
!= dev
->id
.product
)
987 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VERSION
)
988 if (id
->version
!= dev
->id
.version
)
991 if (!bitmap_subset(id
->evbit
, dev
->evbit
, EV_MAX
) ||
992 !bitmap_subset(id
->keybit
, dev
->keybit
, KEY_MAX
) ||
993 !bitmap_subset(id
->relbit
, dev
->relbit
, REL_MAX
) ||
994 !bitmap_subset(id
->absbit
, dev
->absbit
, ABS_MAX
) ||
995 !bitmap_subset(id
->mscbit
, dev
->mscbit
, MSC_MAX
) ||
996 !bitmap_subset(id
->ledbit
, dev
->ledbit
, LED_MAX
) ||
997 !bitmap_subset(id
->sndbit
, dev
->sndbit
, SND_MAX
) ||
998 !bitmap_subset(id
->ffbit
, dev
->ffbit
, FF_MAX
) ||
999 !bitmap_subset(id
->swbit
, dev
->swbit
, SW_MAX
) ||
1000 !bitmap_subset(id
->propbit
, dev
->propbit
, INPUT_PROP_MAX
)) {
1006 EXPORT_SYMBOL(input_match_device_id
);
1008 static const struct input_device_id
*input_match_device(struct input_handler
*handler
,
1009 struct input_dev
*dev
)
1011 const struct input_device_id
*id
;
1013 for (id
= handler
->id_table
; id
->flags
|| id
->driver_info
; id
++) {
1014 if (input_match_device_id(dev
, id
) &&
1015 (!handler
->match
|| handler
->match(handler
, dev
))) {
1023 static int input_attach_handler(struct input_dev
*dev
, struct input_handler
*handler
)
1025 const struct input_device_id
*id
;
1028 id
= input_match_device(handler
, dev
);
1032 error
= handler
->connect(handler
, dev
, id
);
1033 if (error
&& error
!= -ENODEV
)
1034 pr_err("failed to attach handler %s to device %s, error: %d\n",
1035 handler
->name
, kobject_name(&dev
->dev
.kobj
), error
);
1040 #ifdef CONFIG_COMPAT
1042 static int input_bits_to_string(char *buf
, int buf_size
,
1043 unsigned long bits
, bool skip_empty
)
1047 if (in_compat_syscall()) {
1048 u32 dword
= bits
>> 32;
1049 if (dword
|| !skip_empty
)
1050 len
+= snprintf(buf
, buf_size
, "%x ", dword
);
1052 dword
= bits
& 0xffffffffUL
;
1053 if (dword
|| !skip_empty
|| len
)
1054 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0),
1057 if (bits
|| !skip_empty
)
1058 len
+= snprintf(buf
, buf_size
, "%lx", bits
);
1064 #else /* !CONFIG_COMPAT */
1066 static int input_bits_to_string(char *buf
, int buf_size
,
1067 unsigned long bits
, bool skip_empty
)
1069 return bits
|| !skip_empty
?
1070 snprintf(buf
, buf_size
, "%lx", bits
) : 0;
1075 #ifdef CONFIG_PROC_FS
1077 static struct proc_dir_entry
*proc_bus_input_dir
;
1078 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait
);
1079 static int input_devices_state
;
1081 static inline void input_wakeup_procfs_readers(void)
1083 input_devices_state
++;
1084 wake_up(&input_devices_poll_wait
);
1087 struct input_seq_state
{
1089 bool mutex_acquired
;
1090 int input_devices_state
;
1093 static __poll_t
input_proc_devices_poll(struct file
*file
, poll_table
*wait
)
1095 struct seq_file
*seq
= file
->private_data
;
1096 struct input_seq_state
*state
= seq
->private;
1098 poll_wait(file
, &input_devices_poll_wait
, wait
);
1099 if (state
->input_devices_state
!= input_devices_state
) {
1100 state
->input_devices_state
= input_devices_state
;
1101 return EPOLLIN
| EPOLLRDNORM
;
1107 static void *input_devices_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1109 struct input_seq_state
*state
= seq
->private;
1112 error
= mutex_lock_interruptible(&input_mutex
);
1114 state
->mutex_acquired
= false;
1115 return ERR_PTR(error
);
1118 state
->mutex_acquired
= true;
1120 return seq_list_start(&input_dev_list
, *pos
);
1123 static void *input_devices_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1125 return seq_list_next(v
, &input_dev_list
, pos
);
1128 static void input_seq_stop(struct seq_file
*seq
, void *v
)
1130 struct input_seq_state
*state
= seq
->private;
1132 if (state
->mutex_acquired
)
1133 mutex_unlock(&input_mutex
);
1136 static void input_seq_print_bitmap(struct seq_file
*seq
, const char *name
,
1137 unsigned long *bitmap
, int max
)
1140 bool skip_empty
= true;
1143 seq_printf(seq
, "B: %s=", name
);
1145 for (i
= BITS_TO_LONGS(max
) - 1; i
>= 0; i
--) {
1146 if (input_bits_to_string(buf
, sizeof(buf
),
1147 bitmap
[i
], skip_empty
)) {
1149 seq_printf(seq
, "%s%s", buf
, i
> 0 ? " " : "");
1154 * If no output was produced print a single 0.
1159 seq_putc(seq
, '\n');
1162 static int input_devices_seq_show(struct seq_file
*seq
, void *v
)
1164 struct input_dev
*dev
= container_of(v
, struct input_dev
, node
);
1165 const char *path
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
1166 struct input_handle
*handle
;
1168 seq_printf(seq
, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1169 dev
->id
.bustype
, dev
->id
.vendor
, dev
->id
.product
, dev
->id
.version
);
1171 seq_printf(seq
, "N: Name=\"%s\"\n", dev
->name
? dev
->name
: "");
1172 seq_printf(seq
, "P: Phys=%s\n", dev
->phys
? dev
->phys
: "");
1173 seq_printf(seq
, "S: Sysfs=%s\n", path
? path
: "");
1174 seq_printf(seq
, "U: Uniq=%s\n", dev
->uniq
? dev
->uniq
: "");
1175 seq_puts(seq
, "H: Handlers=");
1177 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
1178 seq_printf(seq
, "%s ", handle
->name
);
1179 seq_putc(seq
, '\n');
1181 input_seq_print_bitmap(seq
, "PROP", dev
->propbit
, INPUT_PROP_MAX
);
1183 input_seq_print_bitmap(seq
, "EV", dev
->evbit
, EV_MAX
);
1184 if (test_bit(EV_KEY
, dev
->evbit
))
1185 input_seq_print_bitmap(seq
, "KEY", dev
->keybit
, KEY_MAX
);
1186 if (test_bit(EV_REL
, dev
->evbit
))
1187 input_seq_print_bitmap(seq
, "REL", dev
->relbit
, REL_MAX
);
1188 if (test_bit(EV_ABS
, dev
->evbit
))
1189 input_seq_print_bitmap(seq
, "ABS", dev
->absbit
, ABS_MAX
);
1190 if (test_bit(EV_MSC
, dev
->evbit
))
1191 input_seq_print_bitmap(seq
, "MSC", dev
->mscbit
, MSC_MAX
);
1192 if (test_bit(EV_LED
, dev
->evbit
))
1193 input_seq_print_bitmap(seq
, "LED", dev
->ledbit
, LED_MAX
);
1194 if (test_bit(EV_SND
, dev
->evbit
))
1195 input_seq_print_bitmap(seq
, "SND", dev
->sndbit
, SND_MAX
);
1196 if (test_bit(EV_FF
, dev
->evbit
))
1197 input_seq_print_bitmap(seq
, "FF", dev
->ffbit
, FF_MAX
);
1198 if (test_bit(EV_SW
, dev
->evbit
))
1199 input_seq_print_bitmap(seq
, "SW", dev
->swbit
, SW_MAX
);
1201 seq_putc(seq
, '\n');
1207 static const struct seq_operations input_devices_seq_ops
= {
1208 .start
= input_devices_seq_start
,
1209 .next
= input_devices_seq_next
,
1210 .stop
= input_seq_stop
,
1211 .show
= input_devices_seq_show
,
1214 static int input_proc_devices_open(struct inode
*inode
, struct file
*file
)
1216 return seq_open_private(file
, &input_devices_seq_ops
,
1217 sizeof(struct input_seq_state
));
1220 static const struct proc_ops input_devices_proc_ops
= {
1221 .proc_open
= input_proc_devices_open
,
1222 .proc_poll
= input_proc_devices_poll
,
1223 .proc_read
= seq_read
,
1224 .proc_lseek
= seq_lseek
,
1225 .proc_release
= seq_release_private
,
1228 static void *input_handlers_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1230 struct input_seq_state
*state
= seq
->private;
1233 error
= mutex_lock_interruptible(&input_mutex
);
1235 state
->mutex_acquired
= false;
1236 return ERR_PTR(error
);
1239 state
->mutex_acquired
= true;
1242 return seq_list_start(&input_handler_list
, *pos
);
1245 static void *input_handlers_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1247 struct input_seq_state
*state
= seq
->private;
1249 state
->pos
= *pos
+ 1;
1250 return seq_list_next(v
, &input_handler_list
, pos
);
1253 static int input_handlers_seq_show(struct seq_file
*seq
, void *v
)
1255 struct input_handler
*handler
= container_of(v
, struct input_handler
, node
);
1256 struct input_seq_state
*state
= seq
->private;
1258 seq_printf(seq
, "N: Number=%u Name=%s", state
->pos
, handler
->name
);
1259 if (handler
->filter
)
1260 seq_puts(seq
, " (filter)");
1261 if (handler
->legacy_minors
)
1262 seq_printf(seq
, " Minor=%d", handler
->minor
);
1263 seq_putc(seq
, '\n');
1268 static const struct seq_operations input_handlers_seq_ops
= {
1269 .start
= input_handlers_seq_start
,
1270 .next
= input_handlers_seq_next
,
1271 .stop
= input_seq_stop
,
1272 .show
= input_handlers_seq_show
,
1275 static int input_proc_handlers_open(struct inode
*inode
, struct file
*file
)
1277 return seq_open_private(file
, &input_handlers_seq_ops
,
1278 sizeof(struct input_seq_state
));
1281 static const struct proc_ops input_handlers_proc_ops
= {
1282 .proc_open
= input_proc_handlers_open
,
1283 .proc_read
= seq_read
,
1284 .proc_lseek
= seq_lseek
,
1285 .proc_release
= seq_release_private
,
1288 static int __init
input_proc_init(void)
1290 struct proc_dir_entry
*entry
;
1292 proc_bus_input_dir
= proc_mkdir("bus/input", NULL
);
1293 if (!proc_bus_input_dir
)
1296 entry
= proc_create("devices", 0, proc_bus_input_dir
,
1297 &input_devices_proc_ops
);
1301 entry
= proc_create("handlers", 0, proc_bus_input_dir
,
1302 &input_handlers_proc_ops
);
1308 fail2
: remove_proc_entry("devices", proc_bus_input_dir
);
1309 fail1
: remove_proc_entry("bus/input", NULL
);
1313 static void input_proc_exit(void)
1315 remove_proc_entry("devices", proc_bus_input_dir
);
1316 remove_proc_entry("handlers", proc_bus_input_dir
);
1317 remove_proc_entry("bus/input", NULL
);
1320 #else /* !CONFIG_PROC_FS */
1321 static inline void input_wakeup_procfs_readers(void) { }
1322 static inline int input_proc_init(void) { return 0; }
1323 static inline void input_proc_exit(void) { }
1326 #define INPUT_DEV_STRING_ATTR_SHOW(name) \
1327 static ssize_t input_dev_show_##name(struct device *dev, \
1328 struct device_attribute *attr, \
1331 struct input_dev *input_dev = to_input_dev(dev); \
1333 return sysfs_emit(buf, "%s\n", \
1334 input_dev->name ? input_dev->name : ""); \
1336 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1338 INPUT_DEV_STRING_ATTR_SHOW(name
);
1339 INPUT_DEV_STRING_ATTR_SHOW(phys
);
1340 INPUT_DEV_STRING_ATTR_SHOW(uniq
);
1342 static int input_print_modalias_bits(char *buf
, int size
,
1343 char name
, const unsigned long *bm
,
1344 unsigned int min_bit
, unsigned int max_bit
)
1349 len
+= snprintf(buf
, max(size
, 0), "%c", name
);
1350 for_each_set_bit_from(bit
, bm
, max_bit
)
1351 len
+= snprintf(buf
+ len
, max(size
- len
, 0), "%X,", bit
);
1355 static int input_print_modalias_parts(char *buf
, int size
, int full_len
,
1356 const struct input_dev
*id
)
1358 int len
, klen
, remainder
, space
;
1360 len
= snprintf(buf
, max(size
, 0),
1361 "input:b%04Xv%04Xp%04Xe%04X-",
1362 id
->id
.bustype
, id
->id
.vendor
,
1363 id
->id
.product
, id
->id
.version
);
1365 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1366 'e', id
->evbit
, 0, EV_MAX
);
1369 * Calculate the remaining space in the buffer making sure we
1370 * have place for the terminating 0.
1372 space
= max(size
- (len
+ 1), 0);
1374 klen
= input_print_modalias_bits(buf
+ len
, size
- len
,
1375 'k', id
->keybit
, KEY_MIN_INTERESTING
, KEY_MAX
);
1379 * If we have more data than we can fit in the buffer, check
1380 * if we can trim key data to fit in the rest. We will indicate
1381 * that key data is incomplete by adding "+" sign at the end, like
1382 * this: * "k1,2,3,45,+,".
1384 * Note that we shortest key info (if present) is "k+," so we
1385 * can only try to trim if key data is longer than that.
1387 if (full_len
&& size
< full_len
+ 1 && klen
> 3) {
1388 remainder
= full_len
- len
;
1390 * We can only trim if we have space for the remainder
1391 * and also for at least "k+," which is 3 more characters.
1393 if (remainder
<= space
- 3) {
1395 * We are guaranteed to have 'k' in the buffer, so
1396 * we need at least 3 additional bytes for storing
1397 * "+," in addition to the remainder.
1399 for (int i
= size
- 1 - remainder
- 3; i
>= 0; i
--) {
1400 if (buf
[i
] == 'k' || buf
[i
] == ',') {
1401 strcpy(buf
+ i
+ 1, "+,");
1402 len
= i
+ 3; /* Not counting '\0' */
1409 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1410 'r', id
->relbit
, 0, REL_MAX
);
1411 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1412 'a', id
->absbit
, 0, ABS_MAX
);
1413 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1414 'm', id
->mscbit
, 0, MSC_MAX
);
1415 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1416 'l', id
->ledbit
, 0, LED_MAX
);
1417 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1418 's', id
->sndbit
, 0, SND_MAX
);
1419 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1420 'f', id
->ffbit
, 0, FF_MAX
);
1421 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1422 'w', id
->swbit
, 0, SW_MAX
);
1427 static int input_print_modalias(char *buf
, int size
, const struct input_dev
*id
)
1432 * Printing is done in 2 passes: first one figures out total length
1433 * needed for the modalias string, second one will try to trim key
1434 * data in case when buffer is too small for the entire modalias.
1435 * If the buffer is too small regardless, it will fill as much as it
1436 * can (without trimming key data) into the buffer and leave it to
1437 * the caller to figure out what to do with the result.
1439 full_len
= input_print_modalias_parts(NULL
, 0, 0, id
);
1440 return input_print_modalias_parts(buf
, size
, full_len
, id
);
1443 static ssize_t
input_dev_show_modalias(struct device
*dev
,
1444 struct device_attribute
*attr
,
1447 struct input_dev
*id
= to_input_dev(dev
);
1450 len
= input_print_modalias(buf
, PAGE_SIZE
, id
);
1451 if (len
< PAGE_SIZE
- 2)
1452 len
+= snprintf(buf
+ len
, PAGE_SIZE
- len
, "\n");
1454 return min_t(int, len
, PAGE_SIZE
);
1456 static DEVICE_ATTR(modalias
, S_IRUGO
, input_dev_show_modalias
, NULL
);
1458 static int input_print_bitmap(char *buf
, int buf_size
, const unsigned long *bitmap
,
1459 int max
, int add_cr
);
1461 static ssize_t
input_dev_show_properties(struct device
*dev
,
1462 struct device_attribute
*attr
,
1465 struct input_dev
*input_dev
= to_input_dev(dev
);
1466 int len
= input_print_bitmap(buf
, PAGE_SIZE
, input_dev
->propbit
,
1467 INPUT_PROP_MAX
, true);
1468 return min_t(int, len
, PAGE_SIZE
);
1470 static DEVICE_ATTR(properties
, S_IRUGO
, input_dev_show_properties
, NULL
);
1472 static int input_inhibit_device(struct input_dev
*dev
);
1473 static int input_uninhibit_device(struct input_dev
*dev
);
1475 static ssize_t
inhibited_show(struct device
*dev
,
1476 struct device_attribute
*attr
,
1479 struct input_dev
*input_dev
= to_input_dev(dev
);
1481 return sysfs_emit(buf
, "%d\n", input_dev
->inhibited
);
1484 static ssize_t
inhibited_store(struct device
*dev
,
1485 struct device_attribute
*attr
, const char *buf
,
1488 struct input_dev
*input_dev
= to_input_dev(dev
);
1492 if (kstrtobool(buf
, &inhibited
))
1496 rv
= input_inhibit_device(input_dev
);
1498 rv
= input_uninhibit_device(input_dev
);
1506 static DEVICE_ATTR_RW(inhibited
);
1508 static struct attribute
*input_dev_attrs
[] = {
1509 &dev_attr_name
.attr
,
1510 &dev_attr_phys
.attr
,
1511 &dev_attr_uniq
.attr
,
1512 &dev_attr_modalias
.attr
,
1513 &dev_attr_properties
.attr
,
1514 &dev_attr_inhibited
.attr
,
1518 static const struct attribute_group input_dev_attr_group
= {
1519 .attrs
= input_dev_attrs
,
1522 #define INPUT_DEV_ID_ATTR(name) \
1523 static ssize_t input_dev_show_id_##name(struct device *dev, \
1524 struct device_attribute *attr, \
1527 struct input_dev *input_dev = to_input_dev(dev); \
1528 return sysfs_emit(buf, "%04x\n", input_dev->id.name); \
1530 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1532 INPUT_DEV_ID_ATTR(bustype
);
1533 INPUT_DEV_ID_ATTR(vendor
);
1534 INPUT_DEV_ID_ATTR(product
);
1535 INPUT_DEV_ID_ATTR(version
);
1537 static struct attribute
*input_dev_id_attrs
[] = {
1538 &dev_attr_bustype
.attr
,
1539 &dev_attr_vendor
.attr
,
1540 &dev_attr_product
.attr
,
1541 &dev_attr_version
.attr
,
1545 static const struct attribute_group input_dev_id_attr_group
= {
1547 .attrs
= input_dev_id_attrs
,
1550 static int input_print_bitmap(char *buf
, int buf_size
, const unsigned long *bitmap
,
1551 int max
, int add_cr
)
1555 bool skip_empty
= true;
1557 for (i
= BITS_TO_LONGS(max
) - 1; i
>= 0; i
--) {
1558 len
+= input_bits_to_string(buf
+ len
, max(buf_size
- len
, 0),
1559 bitmap
[i
], skip_empty
);
1563 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0), " ");
1568 * If no output was produced print a single 0.
1571 len
= snprintf(buf
, buf_size
, "%d", 0);
1574 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0), "\n");
1579 #define INPUT_DEV_CAP_ATTR(ev, bm) \
1580 static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1581 struct device_attribute *attr, \
1584 struct input_dev *input_dev = to_input_dev(dev); \
1585 int len = input_print_bitmap(buf, PAGE_SIZE, \
1586 input_dev->bm##bit, ev##_MAX, \
1588 return min_t(int, len, PAGE_SIZE); \
1590 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1592 INPUT_DEV_CAP_ATTR(EV
, ev
);
1593 INPUT_DEV_CAP_ATTR(KEY
, key
);
1594 INPUT_DEV_CAP_ATTR(REL
, rel
);
1595 INPUT_DEV_CAP_ATTR(ABS
, abs
);
1596 INPUT_DEV_CAP_ATTR(MSC
, msc
);
1597 INPUT_DEV_CAP_ATTR(LED
, led
);
1598 INPUT_DEV_CAP_ATTR(SND
, snd
);
1599 INPUT_DEV_CAP_ATTR(FF
, ff
);
1600 INPUT_DEV_CAP_ATTR(SW
, sw
);
1602 static struct attribute
*input_dev_caps_attrs
[] = {
1615 static const struct attribute_group input_dev_caps_attr_group
= {
1616 .name
= "capabilities",
1617 .attrs
= input_dev_caps_attrs
,
1620 static const struct attribute_group
*input_dev_attr_groups
[] = {
1621 &input_dev_attr_group
,
1622 &input_dev_id_attr_group
,
1623 &input_dev_caps_attr_group
,
1624 &input_poller_attribute_group
,
1628 static void input_dev_release(struct device
*device
)
1630 struct input_dev
*dev
= to_input_dev(device
);
1632 input_ff_destroy(dev
);
1633 input_mt_destroy_slots(dev
);
1635 kfree(dev
->absinfo
);
1639 module_put(THIS_MODULE
);
1643 * Input uevent interface - loading event handlers based on
1646 static int input_add_uevent_bm_var(struct kobj_uevent_env
*env
,
1647 const char *name
, const unsigned long *bitmap
, int max
)
1651 if (add_uevent_var(env
, "%s", name
))
1654 len
= input_print_bitmap(&env
->buf
[env
->buflen
- 1],
1655 sizeof(env
->buf
) - env
->buflen
,
1656 bitmap
, max
, false);
1657 if (len
>= (sizeof(env
->buf
) - env
->buflen
))
1665 * This is a pretty gross hack. When building uevent data the driver core
1666 * may try adding more environment variables to kobj_uevent_env without
1667 * telling us, so we have no idea how much of the buffer we can use to
1668 * avoid overflows/-ENOMEM elsewhere. To work around this let's artificially
1669 * reduce amount of memory we will use for the modalias environment variable.
1671 * The potential additions are:
1673 * SEQNUM=18446744073709551615 - (%llu - 28 bytes)
1675 * PATH=/sbin:/bin:/usr/sbin:/usr/bin (34 bytes)
1677 * 68 bytes total. Allow extra buffer - 96 bytes
1679 #define UEVENT_ENV_EXTRA_LEN 96
1681 static int input_add_uevent_modalias_var(struct kobj_uevent_env
*env
,
1682 const struct input_dev
*dev
)
1686 if (add_uevent_var(env
, "MODALIAS="))
1689 len
= input_print_modalias(&env
->buf
[env
->buflen
- 1],
1690 (int)sizeof(env
->buf
) - env
->buflen
-
1691 UEVENT_ENV_EXTRA_LEN
,
1693 if (len
>= ((int)sizeof(env
->buf
) - env
->buflen
-
1694 UEVENT_ENV_EXTRA_LEN
))
1701 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
1703 int err = add_uevent_var(env, fmt, val); \
1708 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
1710 int err = input_add_uevent_bm_var(env, name, bm, max); \
1715 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1717 int err = input_add_uevent_modalias_var(env, dev); \
1722 static int input_dev_uevent(const struct device
*device
, struct kobj_uevent_env
*env
)
1724 const struct input_dev
*dev
= to_input_dev(device
);
1726 INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1727 dev
->id
.bustype
, dev
->id
.vendor
,
1728 dev
->id
.product
, dev
->id
.version
);
1730 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev
->name
);
1732 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev
->phys
);
1734 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev
->uniq
);
1736 INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev
->propbit
, INPUT_PROP_MAX
);
1738 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev
->evbit
, EV_MAX
);
1739 if (test_bit(EV_KEY
, dev
->evbit
))
1740 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev
->keybit
, KEY_MAX
);
1741 if (test_bit(EV_REL
, dev
->evbit
))
1742 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev
->relbit
, REL_MAX
);
1743 if (test_bit(EV_ABS
, dev
->evbit
))
1744 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev
->absbit
, ABS_MAX
);
1745 if (test_bit(EV_MSC
, dev
->evbit
))
1746 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev
->mscbit
, MSC_MAX
);
1747 if (test_bit(EV_LED
, dev
->evbit
))
1748 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev
->ledbit
, LED_MAX
);
1749 if (test_bit(EV_SND
, dev
->evbit
))
1750 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev
->sndbit
, SND_MAX
);
1751 if (test_bit(EV_FF
, dev
->evbit
))
1752 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev
->ffbit
, FF_MAX
);
1753 if (test_bit(EV_SW
, dev
->evbit
))
1754 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev
->swbit
, SW_MAX
);
1756 INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev
);
1761 #define INPUT_DO_TOGGLE(dev, type, bits, on) \
1766 if (!test_bit(EV_##type, dev->evbit)) \
1769 for_each_set_bit(i, dev->bits##bit, type##_CNT) { \
1770 active = test_bit(i, dev->bits); \
1771 if (!active && !on) \
1774 dev->event(dev, EV_##type, i, on ? active : 0); \
1778 static void input_dev_toggle(struct input_dev
*dev
, bool activate
)
1783 INPUT_DO_TOGGLE(dev
, LED
, led
, activate
);
1784 INPUT_DO_TOGGLE(dev
, SND
, snd
, activate
);
1786 if (activate
&& test_bit(EV_REP
, dev
->evbit
)) {
1787 dev
->event(dev
, EV_REP
, REP_PERIOD
, dev
->rep
[REP_PERIOD
]);
1788 dev
->event(dev
, EV_REP
, REP_DELAY
, dev
->rep
[REP_DELAY
]);
1793 * input_reset_device() - reset/restore the state of input device
1794 * @dev: input device whose state needs to be reset
1796 * This function tries to reset the state of an opened input device and
1797 * bring internal state and state if the hardware in sync with each other.
1798 * We mark all keys as released, restore LED state, repeat rate, etc.
1800 void input_reset_device(struct input_dev
*dev
)
1802 unsigned long flags
;
1804 mutex_lock(&dev
->mutex
);
1805 spin_lock_irqsave(&dev
->event_lock
, flags
);
1807 input_dev_toggle(dev
, true);
1808 if (input_dev_release_keys(dev
))
1809 input_handle_event(dev
, EV_SYN
, SYN_REPORT
, 1);
1811 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1812 mutex_unlock(&dev
->mutex
);
1814 EXPORT_SYMBOL(input_reset_device
);
1816 static int input_inhibit_device(struct input_dev
*dev
)
1818 mutex_lock(&dev
->mutex
);
1827 input_dev_poller_stop(dev
->poller
);
1830 spin_lock_irq(&dev
->event_lock
);
1831 input_mt_release_slots(dev
);
1832 input_dev_release_keys(dev
);
1833 input_handle_event(dev
, EV_SYN
, SYN_REPORT
, 1);
1834 input_dev_toggle(dev
, false);
1835 spin_unlock_irq(&dev
->event_lock
);
1837 dev
->inhibited
= true;
1840 mutex_unlock(&dev
->mutex
);
1844 static int input_uninhibit_device(struct input_dev
*dev
)
1848 mutex_lock(&dev
->mutex
);
1850 if (!dev
->inhibited
)
1855 ret
= dev
->open(dev
);
1860 input_dev_poller_start(dev
->poller
);
1863 dev
->inhibited
= false;
1864 spin_lock_irq(&dev
->event_lock
);
1865 input_dev_toggle(dev
, true);
1866 spin_unlock_irq(&dev
->event_lock
);
1869 mutex_unlock(&dev
->mutex
);
1873 static int input_dev_suspend(struct device
*dev
)
1875 struct input_dev
*input_dev
= to_input_dev(dev
);
1877 spin_lock_irq(&input_dev
->event_lock
);
1880 * Keys that are pressed now are unlikely to be
1881 * still pressed when we resume.
1883 if (input_dev_release_keys(input_dev
))
1884 input_handle_event(input_dev
, EV_SYN
, SYN_REPORT
, 1);
1886 /* Turn off LEDs and sounds, if any are active. */
1887 input_dev_toggle(input_dev
, false);
1889 spin_unlock_irq(&input_dev
->event_lock
);
1894 static int input_dev_resume(struct device
*dev
)
1896 struct input_dev
*input_dev
= to_input_dev(dev
);
1898 spin_lock_irq(&input_dev
->event_lock
);
1900 /* Restore state of LEDs and sounds, if any were active. */
1901 input_dev_toggle(input_dev
, true);
1903 spin_unlock_irq(&input_dev
->event_lock
);
1908 static int input_dev_freeze(struct device
*dev
)
1910 struct input_dev
*input_dev
= to_input_dev(dev
);
1912 spin_lock_irq(&input_dev
->event_lock
);
1915 * Keys that are pressed now are unlikely to be
1916 * still pressed when we resume.
1918 if (input_dev_release_keys(input_dev
))
1919 input_handle_event(input_dev
, EV_SYN
, SYN_REPORT
, 1);
1921 spin_unlock_irq(&input_dev
->event_lock
);
1926 static int input_dev_poweroff(struct device
*dev
)
1928 struct input_dev
*input_dev
= to_input_dev(dev
);
1930 spin_lock_irq(&input_dev
->event_lock
);
1932 /* Turn off LEDs and sounds, if any are active. */
1933 input_dev_toggle(input_dev
, false);
1935 spin_unlock_irq(&input_dev
->event_lock
);
1940 static const struct dev_pm_ops input_dev_pm_ops
= {
1941 .suspend
= input_dev_suspend
,
1942 .resume
= input_dev_resume
,
1943 .freeze
= input_dev_freeze
,
1944 .poweroff
= input_dev_poweroff
,
1945 .restore
= input_dev_resume
,
1948 static const struct device_type input_dev_type
= {
1949 .groups
= input_dev_attr_groups
,
1950 .release
= input_dev_release
,
1951 .uevent
= input_dev_uevent
,
1952 .pm
= pm_sleep_ptr(&input_dev_pm_ops
),
1955 static char *input_devnode(const struct device
*dev
, umode_t
*mode
)
1957 return kasprintf(GFP_KERNEL
, "input/%s", dev_name(dev
));
1960 const struct class input_class
= {
1962 .devnode
= input_devnode
,
1964 EXPORT_SYMBOL_GPL(input_class
);
1967 * input_allocate_device - allocate memory for new input device
1969 * Returns prepared struct input_dev or %NULL.
1971 * NOTE: Use input_free_device() to free devices that have not been
1972 * registered; input_unregister_device() should be used for already
1973 * registered devices.
1975 struct input_dev
*input_allocate_device(void)
1977 static atomic_t input_no
= ATOMIC_INIT(-1);
1978 struct input_dev
*dev
;
1980 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1985 * Start with space for SYN_REPORT + 7 EV_KEY/EV_MSC events + 2 spare,
1986 * see input_estimate_events_per_packet(). We will tune the number
1987 * when we register the device.
1990 dev
->vals
= kcalloc(dev
->max_vals
, sizeof(*dev
->vals
), GFP_KERNEL
);
1996 mutex_init(&dev
->mutex
);
1997 spin_lock_init(&dev
->event_lock
);
1998 timer_setup(&dev
->timer
, NULL
, 0);
1999 INIT_LIST_HEAD(&dev
->h_list
);
2000 INIT_LIST_HEAD(&dev
->node
);
2002 dev
->dev
.type
= &input_dev_type
;
2003 dev
->dev
.class = &input_class
;
2004 device_initialize(&dev
->dev
);
2006 * From this point on we can no longer simply "kfree(dev)", we need
2007 * to use input_free_device() so that device core properly frees its
2008 * resources associated with the input device.
2011 dev_set_name(&dev
->dev
, "input%lu",
2012 (unsigned long)atomic_inc_return(&input_no
));
2014 __module_get(THIS_MODULE
);
2018 EXPORT_SYMBOL(input_allocate_device
);
2020 struct input_devres
{
2021 struct input_dev
*input
;
2024 static int devm_input_device_match(struct device
*dev
, void *res
, void *data
)
2026 struct input_devres
*devres
= res
;
2028 return devres
->input
== data
;
2031 static void devm_input_device_release(struct device
*dev
, void *res
)
2033 struct input_devres
*devres
= res
;
2034 struct input_dev
*input
= devres
->input
;
2036 dev_dbg(dev
, "%s: dropping reference to %s\n",
2037 __func__
, dev_name(&input
->dev
));
2038 input_put_device(input
);
2042 * devm_input_allocate_device - allocate managed input device
2043 * @dev: device owning the input device being created
2045 * Returns prepared struct input_dev or %NULL.
2047 * Managed input devices do not need to be explicitly unregistered or
2048 * freed as it will be done automatically when owner device unbinds from
2049 * its driver (or binding fails). Once managed input device is allocated,
2050 * it is ready to be set up and registered in the same fashion as regular
2051 * input device. There are no special devm_input_device_[un]register()
2052 * variants, regular ones work with both managed and unmanaged devices,
2053 * should you need them. In most cases however, managed input device need
2054 * not be explicitly unregistered or freed.
2056 * NOTE: the owner device is set up as parent of input device and users
2057 * should not override it.
2059 struct input_dev
*devm_input_allocate_device(struct device
*dev
)
2061 struct input_dev
*input
;
2062 struct input_devres
*devres
;
2064 devres
= devres_alloc(devm_input_device_release
,
2065 sizeof(*devres
), GFP_KERNEL
);
2069 input
= input_allocate_device();
2071 devres_free(devres
);
2075 input
->dev
.parent
= dev
;
2076 input
->devres_managed
= true;
2078 devres
->input
= input
;
2079 devres_add(dev
, devres
);
2083 EXPORT_SYMBOL(devm_input_allocate_device
);
2086 * input_free_device - free memory occupied by input_dev structure
2087 * @dev: input device to free
2089 * This function should only be used if input_register_device()
2090 * was not called yet or if it failed. Once device was registered
2091 * use input_unregister_device() and memory will be freed once last
2092 * reference to the device is dropped.
2094 * Device should be allocated by input_allocate_device().
2096 * NOTE: If there are references to the input device then memory
2097 * will not be freed until last reference is dropped.
2099 void input_free_device(struct input_dev
*dev
)
2102 if (dev
->devres_managed
)
2103 WARN_ON(devres_destroy(dev
->dev
.parent
,
2104 devm_input_device_release
,
2105 devm_input_device_match
,
2107 input_put_device(dev
);
2110 EXPORT_SYMBOL(input_free_device
);
2113 * input_set_timestamp - set timestamp for input events
2114 * @dev: input device to set timestamp for
2115 * @timestamp: the time at which the event has occurred
2116 * in CLOCK_MONOTONIC
2118 * This function is intended to provide to the input system a more
2119 * accurate time of when an event actually occurred. The driver should
2120 * call this function as soon as a timestamp is acquired ensuring
2121 * clock conversions in input_set_timestamp are done correctly.
2123 * The system entering suspend state between timestamp acquisition and
2124 * calling input_set_timestamp can result in inaccurate conversions.
2126 void input_set_timestamp(struct input_dev
*dev
, ktime_t timestamp
)
2128 dev
->timestamp
[INPUT_CLK_MONO
] = timestamp
;
2129 dev
->timestamp
[INPUT_CLK_REAL
] = ktime_mono_to_real(timestamp
);
2130 dev
->timestamp
[INPUT_CLK_BOOT
] = ktime_mono_to_any(timestamp
,
2133 EXPORT_SYMBOL(input_set_timestamp
);
2136 * input_get_timestamp - get timestamp for input events
2137 * @dev: input device to get timestamp from
2139 * A valid timestamp is a timestamp of non-zero value.
2141 ktime_t
*input_get_timestamp(struct input_dev
*dev
)
2143 const ktime_t invalid_timestamp
= ktime_set(0, 0);
2145 if (!ktime_compare(dev
->timestamp
[INPUT_CLK_MONO
], invalid_timestamp
))
2146 input_set_timestamp(dev
, ktime_get());
2148 return dev
->timestamp
;
2150 EXPORT_SYMBOL(input_get_timestamp
);
2153 * input_set_capability - mark device as capable of a certain event
2154 * @dev: device that is capable of emitting or accepting event
2155 * @type: type of the event (EV_KEY, EV_REL, etc...)
2158 * In addition to setting up corresponding bit in appropriate capability
2159 * bitmap the function also adjusts dev->evbit.
2161 void input_set_capability(struct input_dev
*dev
, unsigned int type
, unsigned int code
)
2163 if (type
< EV_CNT
&& input_max_code
[type
] &&
2164 code
> input_max_code
[type
]) {
2165 pr_err("%s: invalid code %u for type %u\n", __func__
, code
,
2173 __set_bit(code
, dev
->keybit
);
2177 __set_bit(code
, dev
->relbit
);
2181 input_alloc_absinfo(dev
);
2182 __set_bit(code
, dev
->absbit
);
2186 __set_bit(code
, dev
->mscbit
);
2190 __set_bit(code
, dev
->swbit
);
2194 __set_bit(code
, dev
->ledbit
);
2198 __set_bit(code
, dev
->sndbit
);
2202 __set_bit(code
, dev
->ffbit
);
2210 pr_err("%s: unknown type %u (code %u)\n", __func__
, type
, code
);
2215 __set_bit(type
, dev
->evbit
);
2217 EXPORT_SYMBOL(input_set_capability
);
2219 static unsigned int input_estimate_events_per_packet(struct input_dev
*dev
)
2223 unsigned int events
;
2226 mt_slots
= dev
->mt
->num_slots
;
2227 } else if (test_bit(ABS_MT_TRACKING_ID
, dev
->absbit
)) {
2228 mt_slots
= dev
->absinfo
[ABS_MT_TRACKING_ID
].maximum
-
2229 dev
->absinfo
[ABS_MT_TRACKING_ID
].minimum
+ 1;
2230 mt_slots
= clamp(mt_slots
, 2, 32);
2231 } else if (test_bit(ABS_MT_POSITION_X
, dev
->absbit
)) {
2237 events
= mt_slots
+ 1; /* count SYN_MT_REPORT and SYN_REPORT */
2239 if (test_bit(EV_ABS
, dev
->evbit
))
2240 for_each_set_bit(i
, dev
->absbit
, ABS_CNT
)
2241 events
+= input_is_mt_axis(i
) ? mt_slots
: 1;
2243 if (test_bit(EV_REL
, dev
->evbit
))
2244 events
+= bitmap_weight(dev
->relbit
, REL_CNT
);
2246 /* Make room for KEY and MSC events */
2252 #define INPUT_CLEANSE_BITMASK(dev, type, bits) \
2254 if (!test_bit(EV_##type, dev->evbit)) \
2255 memset(dev->bits##bit, 0, \
2256 sizeof(dev->bits##bit)); \
2259 static void input_cleanse_bitmasks(struct input_dev
*dev
)
2261 INPUT_CLEANSE_BITMASK(dev
, KEY
, key
);
2262 INPUT_CLEANSE_BITMASK(dev
, REL
, rel
);
2263 INPUT_CLEANSE_BITMASK(dev
, ABS
, abs
);
2264 INPUT_CLEANSE_BITMASK(dev
, MSC
, msc
);
2265 INPUT_CLEANSE_BITMASK(dev
, LED
, led
);
2266 INPUT_CLEANSE_BITMASK(dev
, SND
, snd
);
2267 INPUT_CLEANSE_BITMASK(dev
, FF
, ff
);
2268 INPUT_CLEANSE_BITMASK(dev
, SW
, sw
);
2271 static void __input_unregister_device(struct input_dev
*dev
)
2273 struct input_handle
*handle
, *next
;
2275 input_disconnect_device(dev
);
2277 mutex_lock(&input_mutex
);
2279 list_for_each_entry_safe(handle
, next
, &dev
->h_list
, d_node
)
2280 handle
->handler
->disconnect(handle
);
2281 WARN_ON(!list_empty(&dev
->h_list
));
2283 del_timer_sync(&dev
->timer
);
2284 list_del_init(&dev
->node
);
2286 input_wakeup_procfs_readers();
2288 mutex_unlock(&input_mutex
);
2290 device_del(&dev
->dev
);
2293 static void devm_input_device_unregister(struct device
*dev
, void *res
)
2295 struct input_devres
*devres
= res
;
2296 struct input_dev
*input
= devres
->input
;
2298 dev_dbg(dev
, "%s: unregistering device %s\n",
2299 __func__
, dev_name(&input
->dev
));
2300 __input_unregister_device(input
);
2304 * Generate software autorepeat event. Note that we take
2305 * dev->event_lock here to avoid racing with input_event
2306 * which may cause keys get "stuck".
2308 static void input_repeat_key(struct timer_list
*t
)
2310 struct input_dev
*dev
= from_timer(dev
, t
, timer
);
2311 unsigned long flags
;
2313 spin_lock_irqsave(&dev
->event_lock
, flags
);
2315 if (!dev
->inhibited
&&
2316 test_bit(dev
->repeat_key
, dev
->key
) &&
2317 is_event_supported(dev
->repeat_key
, dev
->keybit
, KEY_MAX
)) {
2319 input_set_timestamp(dev
, ktime_get());
2320 input_handle_event(dev
, EV_KEY
, dev
->repeat_key
, 2);
2321 input_handle_event(dev
, EV_SYN
, SYN_REPORT
, 1);
2323 if (dev
->rep
[REP_PERIOD
])
2324 mod_timer(&dev
->timer
, jiffies
+
2325 msecs_to_jiffies(dev
->rep
[REP_PERIOD
]));
2328 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
2332 * input_enable_softrepeat - enable software autorepeat
2333 * @dev: input device
2334 * @delay: repeat delay
2335 * @period: repeat period
2337 * Enable software autorepeat on the input device.
2339 void input_enable_softrepeat(struct input_dev
*dev
, int delay
, int period
)
2341 dev
->timer
.function
= input_repeat_key
;
2342 dev
->rep
[REP_DELAY
] = delay
;
2343 dev
->rep
[REP_PERIOD
] = period
;
2345 EXPORT_SYMBOL(input_enable_softrepeat
);
2347 bool input_device_enabled(struct input_dev
*dev
)
2349 lockdep_assert_held(&dev
->mutex
);
2351 return !dev
->inhibited
&& dev
->users
> 0;
2353 EXPORT_SYMBOL_GPL(input_device_enabled
);
2355 static int input_device_tune_vals(struct input_dev
*dev
)
2357 struct input_value
*vals
;
2358 unsigned int packet_size
;
2359 unsigned int max_vals
;
2361 packet_size
= input_estimate_events_per_packet(dev
);
2362 if (dev
->hint_events_per_packet
< packet_size
)
2363 dev
->hint_events_per_packet
= packet_size
;
2365 max_vals
= dev
->hint_events_per_packet
+ 2;
2366 if (dev
->max_vals
>= max_vals
)
2369 vals
= kcalloc(max_vals
, sizeof(*vals
), GFP_KERNEL
);
2373 spin_lock_irq(&dev
->event_lock
);
2374 dev
->max_vals
= max_vals
;
2375 swap(dev
->vals
, vals
);
2376 spin_unlock_irq(&dev
->event_lock
);
2378 /* Because of swap() above, this frees the old vals memory */
2385 * input_register_device - register device with input core
2386 * @dev: device to be registered
2388 * This function registers device with input core. The device must be
2389 * allocated with input_allocate_device() and all it's capabilities
2390 * set up before registering.
2391 * If function fails the device must be freed with input_free_device().
2392 * Once device has been successfully registered it can be unregistered
2393 * with input_unregister_device(); input_free_device() should not be
2394 * called in this case.
2396 * Note that this function is also used to register managed input devices
2397 * (ones allocated with devm_input_allocate_device()). Such managed input
2398 * devices need not be explicitly unregistered or freed, their tear down
2399 * is controlled by the devres infrastructure. It is also worth noting
2400 * that tear down of managed input devices is internally a 2-step process:
2401 * registered managed input device is first unregistered, but stays in
2402 * memory and can still handle input_event() calls (although events will
2403 * not be delivered anywhere). The freeing of managed input device will
2404 * happen later, when devres stack is unwound to the point where device
2405 * allocation was made.
2407 int input_register_device(struct input_dev
*dev
)
2409 struct input_devres
*devres
= NULL
;
2410 struct input_handler
*handler
;
2414 if (test_bit(EV_ABS
, dev
->evbit
) && !dev
->absinfo
) {
2416 "Absolute device without dev->absinfo, refusing to register\n");
2420 if (dev
->devres_managed
) {
2421 devres
= devres_alloc(devm_input_device_unregister
,
2422 sizeof(*devres
), GFP_KERNEL
);
2426 devres
->input
= dev
;
2429 /* Every input device generates EV_SYN/SYN_REPORT events. */
2430 __set_bit(EV_SYN
, dev
->evbit
);
2432 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
2433 __clear_bit(KEY_RESERVED
, dev
->keybit
);
2435 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2436 input_cleanse_bitmasks(dev
);
2438 error
= input_device_tune_vals(dev
);
2440 goto err_devres_free
;
2443 * If delay and period are pre-set by the driver, then autorepeating
2444 * is handled by the driver itself and we don't do it in input.c.
2446 if (!dev
->rep
[REP_DELAY
] && !dev
->rep
[REP_PERIOD
])
2447 input_enable_softrepeat(dev
, 250, 33);
2449 if (!dev
->getkeycode
)
2450 dev
->getkeycode
= input_default_getkeycode
;
2452 if (!dev
->setkeycode
)
2453 dev
->setkeycode
= input_default_setkeycode
;
2456 input_dev_poller_finalize(dev
->poller
);
2458 error
= device_add(&dev
->dev
);
2460 goto err_devres_free
;
2462 path
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
2463 pr_info("%s as %s\n",
2464 dev
->name
? dev
->name
: "Unspecified device",
2465 path
? path
: "N/A");
2468 error
= mutex_lock_interruptible(&input_mutex
);
2470 goto err_device_del
;
2472 list_add_tail(&dev
->node
, &input_dev_list
);
2474 list_for_each_entry(handler
, &input_handler_list
, node
)
2475 input_attach_handler(dev
, handler
);
2477 input_wakeup_procfs_readers();
2479 mutex_unlock(&input_mutex
);
2481 if (dev
->devres_managed
) {
2482 dev_dbg(dev
->dev
.parent
, "%s: registering %s with devres.\n",
2483 __func__
, dev_name(&dev
->dev
));
2484 devres_add(dev
->dev
.parent
, devres
);
2489 device_del(&dev
->dev
);
2491 devres_free(devres
);
2494 EXPORT_SYMBOL(input_register_device
);
2497 * input_unregister_device - unregister previously registered device
2498 * @dev: device to be unregistered
2500 * This function unregisters an input device. Once device is unregistered
2501 * the caller should not try to access it as it may get freed at any moment.
2503 void input_unregister_device(struct input_dev
*dev
)
2505 if (dev
->devres_managed
) {
2506 WARN_ON(devres_destroy(dev
->dev
.parent
,
2507 devm_input_device_unregister
,
2508 devm_input_device_match
,
2510 __input_unregister_device(dev
);
2512 * We do not do input_put_device() here because it will be done
2513 * when 2nd devres fires up.
2516 __input_unregister_device(dev
);
2517 input_put_device(dev
);
2520 EXPORT_SYMBOL(input_unregister_device
);
2522 static int input_handler_check_methods(const struct input_handler
*handler
)
2526 if (handler
->filter
)
2528 if (handler
->events
)
2534 pr_err("%s: only one event processing method can be defined (%s)\n",
2535 __func__
, handler
->name
);
2543 * input_register_handler - register a new input handler
2544 * @handler: handler to be registered
2546 * This function registers a new input handler (interface) for input
2547 * devices in the system and attaches it to all input devices that
2548 * are compatible with the handler.
2550 int input_register_handler(struct input_handler
*handler
)
2552 struct input_dev
*dev
;
2555 error
= input_handler_check_methods(handler
);
2559 INIT_LIST_HEAD(&handler
->h_list
);
2561 error
= mutex_lock_interruptible(&input_mutex
);
2565 list_add_tail(&handler
->node
, &input_handler_list
);
2567 list_for_each_entry(dev
, &input_dev_list
, node
)
2568 input_attach_handler(dev
, handler
);
2570 input_wakeup_procfs_readers();
2572 mutex_unlock(&input_mutex
);
2575 EXPORT_SYMBOL(input_register_handler
);
2578 * input_unregister_handler - unregisters an input handler
2579 * @handler: handler to be unregistered
2581 * This function disconnects a handler from its input devices and
2582 * removes it from lists of known handlers.
2584 void input_unregister_handler(struct input_handler
*handler
)
2586 struct input_handle
*handle
, *next
;
2588 mutex_lock(&input_mutex
);
2590 list_for_each_entry_safe(handle
, next
, &handler
->h_list
, h_node
)
2591 handler
->disconnect(handle
);
2592 WARN_ON(!list_empty(&handler
->h_list
));
2594 list_del_init(&handler
->node
);
2596 input_wakeup_procfs_readers();
2598 mutex_unlock(&input_mutex
);
2600 EXPORT_SYMBOL(input_unregister_handler
);
2603 * input_handler_for_each_handle - handle iterator
2604 * @handler: input handler to iterate
2605 * @data: data for the callback
2606 * @fn: function to be called for each handle
2608 * Iterate over @bus's list of devices, and call @fn for each, passing
2609 * it @data and stop when @fn returns a non-zero value. The function is
2610 * using RCU to traverse the list and therefore may be using in atomic
2611 * contexts. The @fn callback is invoked from RCU critical section and
2612 * thus must not sleep.
2614 int input_handler_for_each_handle(struct input_handler
*handler
, void *data
,
2615 int (*fn
)(struct input_handle
*, void *))
2617 struct input_handle
*handle
;
2622 list_for_each_entry_rcu(handle
, &handler
->h_list
, h_node
) {
2623 retval
= fn(handle
, data
);
2632 EXPORT_SYMBOL(input_handler_for_each_handle
);
2635 * An implementation of input_handle's handle_events() method that simply
2636 * invokes handler->event() method for each event one by one.
2638 static unsigned int input_handle_events_default(struct input_handle
*handle
,
2639 struct input_value
*vals
,
2642 struct input_handler
*handler
= handle
->handler
;
2643 struct input_value
*v
;
2645 for (v
= vals
; v
!= vals
+ count
; v
++)
2646 handler
->event(handle
, v
->type
, v
->code
, v
->value
);
2652 * An implementation of input_handle's handle_events() method that invokes
2653 * handler->filter() method for each event one by one and removes events
2654 * that were filtered out from the "vals" array.
2656 static unsigned int input_handle_events_filter(struct input_handle
*handle
,
2657 struct input_value
*vals
,
2660 struct input_handler
*handler
= handle
->handler
;
2661 struct input_value
*end
= vals
;
2662 struct input_value
*v
;
2664 for (v
= vals
; v
!= vals
+ count
; v
++) {
2665 if (handler
->filter(handle
, v
->type
, v
->code
, v
->value
))
2676 * An implementation of input_handle's handle_events() method that does nothing.
2678 static unsigned int input_handle_events_null(struct input_handle
*handle
,
2679 struct input_value
*vals
,
2686 * Sets up appropriate handle->event_handler based on the input_handler
2687 * associated with the handle.
2689 static void input_handle_setup_event_handler(struct input_handle
*handle
)
2691 struct input_handler
*handler
= handle
->handler
;
2693 if (handler
->filter
)
2694 handle
->handle_events
= input_handle_events_filter
;
2695 else if (handler
->event
)
2696 handle
->handle_events
= input_handle_events_default
;
2697 else if (handler
->events
)
2698 handle
->handle_events
= handler
->events
;
2700 handle
->handle_events
= input_handle_events_null
;
2704 * input_register_handle - register a new input handle
2705 * @handle: handle to register
2707 * This function puts a new input handle onto device's
2708 * and handler's lists so that events can flow through
2709 * it once it is opened using input_open_device().
2711 * This function is supposed to be called from handler's
2714 int input_register_handle(struct input_handle
*handle
)
2716 struct input_handler
*handler
= handle
->handler
;
2717 struct input_dev
*dev
= handle
->dev
;
2720 input_handle_setup_event_handler(handle
);
2722 * We take dev->mutex here to prevent race with
2723 * input_release_device().
2725 error
= mutex_lock_interruptible(&dev
->mutex
);
2730 * Filters go to the head of the list, normal handlers
2733 if (handler
->filter
)
2734 list_add_rcu(&handle
->d_node
, &dev
->h_list
);
2736 list_add_tail_rcu(&handle
->d_node
, &dev
->h_list
);
2738 mutex_unlock(&dev
->mutex
);
2741 * Since we are supposed to be called from ->connect()
2742 * which is mutually exclusive with ->disconnect()
2743 * we can't be racing with input_unregister_handle()
2744 * and so separate lock is not needed here.
2746 list_add_tail_rcu(&handle
->h_node
, &handler
->h_list
);
2749 handler
->start(handle
);
2753 EXPORT_SYMBOL(input_register_handle
);
2756 * input_unregister_handle - unregister an input handle
2757 * @handle: handle to unregister
2759 * This function removes input handle from device's
2760 * and handler's lists.
2762 * This function is supposed to be called from handler's
2763 * disconnect() method.
2765 void input_unregister_handle(struct input_handle
*handle
)
2767 struct input_dev
*dev
= handle
->dev
;
2769 list_del_rcu(&handle
->h_node
);
2772 * Take dev->mutex to prevent race with input_release_device().
2774 mutex_lock(&dev
->mutex
);
2775 list_del_rcu(&handle
->d_node
);
2776 mutex_unlock(&dev
->mutex
);
2780 EXPORT_SYMBOL(input_unregister_handle
);
2783 * input_get_new_minor - allocates a new input minor number
2784 * @legacy_base: beginning or the legacy range to be searched
2785 * @legacy_num: size of legacy range
2786 * @allow_dynamic: whether we can also take ID from the dynamic range
2788 * This function allocates a new device minor for from input major namespace.
2789 * Caller can request legacy minor by specifying @legacy_base and @legacy_num
2790 * parameters and whether ID can be allocated from dynamic range if there are
2791 * no free IDs in legacy range.
2793 int input_get_new_minor(int legacy_base
, unsigned int legacy_num
,
2797 * This function should be called from input handler's ->connect()
2798 * methods, which are serialized with input_mutex, so no additional
2799 * locking is needed here.
2801 if (legacy_base
>= 0) {
2802 int minor
= ida_alloc_range(&input_ida
, legacy_base
,
2803 legacy_base
+ legacy_num
- 1,
2805 if (minor
>= 0 || !allow_dynamic
)
2809 return ida_alloc_range(&input_ida
, INPUT_FIRST_DYNAMIC_DEV
,
2810 INPUT_MAX_CHAR_DEVICES
- 1, GFP_KERNEL
);
2812 EXPORT_SYMBOL(input_get_new_minor
);
2815 * input_free_minor - release previously allocated minor
2816 * @minor: minor to be released
2818 * This function releases previously allocated input minor so that it can be
2821 void input_free_minor(unsigned int minor
)
2823 ida_free(&input_ida
, minor
);
2825 EXPORT_SYMBOL(input_free_minor
);
2827 static int __init
input_init(void)
2831 err
= class_register(&input_class
);
2833 pr_err("unable to register input_dev class\n");
2837 err
= input_proc_init();
2841 err
= register_chrdev_region(MKDEV(INPUT_MAJOR
, 0),
2842 INPUT_MAX_CHAR_DEVICES
, "input");
2844 pr_err("unable to register char major %d", INPUT_MAJOR
);
2850 fail2
: input_proc_exit();
2851 fail1
: class_unregister(&input_class
);
2855 static void __exit
input_exit(void)
2858 unregister_chrdev_region(MKDEV(INPUT_MAJOR
, 0),
2859 INPUT_MAX_CHAR_DEVICES
);
2860 class_unregister(&input_class
);
2863 subsys_initcall(input_init
);
2864 module_exit(input_exit
);