4 * Copyright (c) 1999-2002 Vojtech Pavlik
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.
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 <linux/smp_lock.h>
28 #include "input-compat.h"
30 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
31 MODULE_DESCRIPTION("Input core");
32 MODULE_LICENSE("GPL");
34 #define INPUT_DEVICES 256
37 * EV_ABS events which should not be cached are listed here.
39 static unsigned int input_abs_bypass_init_data
[] __initdata
= {
53 static unsigned long input_abs_bypass
[BITS_TO_LONGS(ABS_CNT
)];
55 static LIST_HEAD(input_dev_list
);
56 static LIST_HEAD(input_handler_list
);
59 * input_mutex protects access to both input_dev_list and input_handler_list.
60 * This also causes input_[un]register_device and input_[un]register_handler
61 * be mutually exclusive which simplifies locking in drivers implementing
64 static DEFINE_MUTEX(input_mutex
);
66 static struct input_handler
*input_table
[8];
68 static inline int is_event_supported(unsigned int code
,
69 unsigned long *bm
, unsigned int max
)
71 return code
<= max
&& test_bit(code
, bm
);
74 static int input_defuzz_abs_event(int value
, int old_val
, int fuzz
)
77 if (value
> old_val
- fuzz
/ 2 && value
< old_val
+ fuzz
/ 2)
80 if (value
> old_val
- fuzz
&& value
< old_val
+ fuzz
)
81 return (old_val
* 3 + value
) / 4;
83 if (value
> old_val
- fuzz
* 2 && value
< old_val
+ fuzz
* 2)
84 return (old_val
+ value
) / 2;
91 * Pass event first through all filters and then, if event has not been
92 * filtered out, through all open handles. This function is called with
93 * dev->event_lock held and interrupts disabled.
95 static void input_pass_event(struct input_dev
*dev
,
96 unsigned int type
, unsigned int code
, int value
)
98 struct input_handler
*handler
;
99 struct input_handle
*handle
;
103 handle
= rcu_dereference(dev
->grab
);
105 handle
->handler
->event(handle
, type
, code
, value
);
107 bool filtered
= false;
109 list_for_each_entry_rcu(handle
, &dev
->h_list
, d_node
) {
113 handler
= handle
->handler
;
114 if (!handler
->filter
) {
118 handler
->event(handle
, type
, code
, value
);
120 } else if (handler
->filter(handle
, type
, code
, value
))
129 * Generate software autorepeat event. Note that we take
130 * dev->event_lock here to avoid racing with input_event
131 * which may cause keys get "stuck".
133 static void input_repeat_key(unsigned long data
)
135 struct input_dev
*dev
= (void *) data
;
138 spin_lock_irqsave(&dev
->event_lock
, flags
);
140 if (test_bit(dev
->repeat_key
, dev
->key
) &&
141 is_event_supported(dev
->repeat_key
, dev
->keybit
, KEY_MAX
)) {
143 input_pass_event(dev
, EV_KEY
, dev
->repeat_key
, 2);
147 * Only send SYN_REPORT if we are not in a middle
148 * of driver parsing a new hardware packet.
149 * Otherwise assume that the driver will send
150 * SYN_REPORT once it's done.
152 input_pass_event(dev
, EV_SYN
, SYN_REPORT
, 1);
155 if (dev
->rep
[REP_PERIOD
])
156 mod_timer(&dev
->timer
, jiffies
+
157 msecs_to_jiffies(dev
->rep
[REP_PERIOD
]));
160 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
163 static void input_start_autorepeat(struct input_dev
*dev
, int code
)
165 if (test_bit(EV_REP
, dev
->evbit
) &&
166 dev
->rep
[REP_PERIOD
] && dev
->rep
[REP_DELAY
] &&
168 dev
->repeat_key
= code
;
169 mod_timer(&dev
->timer
,
170 jiffies
+ msecs_to_jiffies(dev
->rep
[REP_DELAY
]));
174 static void input_stop_autorepeat(struct input_dev
*dev
)
176 del_timer(&dev
->timer
);
179 #define INPUT_IGNORE_EVENT 0
180 #define INPUT_PASS_TO_HANDLERS 1
181 #define INPUT_PASS_TO_DEVICE 2
182 #define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
184 static void input_handle_event(struct input_dev
*dev
,
185 unsigned int type
, unsigned int code
, int value
)
187 int disposition
= INPUT_IGNORE_EVENT
;
194 disposition
= INPUT_PASS_TO_ALL
;
200 disposition
= INPUT_PASS_TO_HANDLERS
;
205 disposition
= INPUT_PASS_TO_HANDLERS
;
211 if (is_event_supported(code
, dev
->keybit
, KEY_MAX
) &&
212 !!test_bit(code
, dev
->key
) != value
) {
215 __change_bit(code
, dev
->key
);
217 input_start_autorepeat(dev
, code
);
219 input_stop_autorepeat(dev
);
222 disposition
= INPUT_PASS_TO_HANDLERS
;
227 if (is_event_supported(code
, dev
->swbit
, SW_MAX
) &&
228 !!test_bit(code
, dev
->sw
) != value
) {
230 __change_bit(code
, dev
->sw
);
231 disposition
= INPUT_PASS_TO_HANDLERS
;
236 if (is_event_supported(code
, dev
->absbit
, ABS_MAX
)) {
238 if (test_bit(code
, input_abs_bypass
)) {
239 disposition
= INPUT_PASS_TO_HANDLERS
;
243 value
= input_defuzz_abs_event(value
,
244 dev
->abs
[code
], dev
->absfuzz
[code
]);
246 if (dev
->abs
[code
] != value
) {
247 dev
->abs
[code
] = value
;
248 disposition
= INPUT_PASS_TO_HANDLERS
;
254 if (is_event_supported(code
, dev
->relbit
, REL_MAX
) && value
)
255 disposition
= INPUT_PASS_TO_HANDLERS
;
260 if (is_event_supported(code
, dev
->mscbit
, MSC_MAX
))
261 disposition
= INPUT_PASS_TO_ALL
;
266 if (is_event_supported(code
, dev
->ledbit
, LED_MAX
) &&
267 !!test_bit(code
, dev
->led
) != value
) {
269 __change_bit(code
, dev
->led
);
270 disposition
= INPUT_PASS_TO_ALL
;
275 if (is_event_supported(code
, dev
->sndbit
, SND_MAX
)) {
277 if (!!test_bit(code
, dev
->snd
) != !!value
)
278 __change_bit(code
, dev
->snd
);
279 disposition
= INPUT_PASS_TO_ALL
;
284 if (code
<= REP_MAX
&& value
>= 0 && dev
->rep
[code
] != value
) {
285 dev
->rep
[code
] = value
;
286 disposition
= INPUT_PASS_TO_ALL
;
292 disposition
= INPUT_PASS_TO_ALL
;
296 disposition
= INPUT_PASS_TO_ALL
;
300 if (disposition
!= INPUT_IGNORE_EVENT
&& type
!= EV_SYN
)
303 if ((disposition
& INPUT_PASS_TO_DEVICE
) && dev
->event
)
304 dev
->event(dev
, type
, code
, value
);
306 if (disposition
& INPUT_PASS_TO_HANDLERS
)
307 input_pass_event(dev
, type
, code
, value
);
311 * input_event() - report new input event
312 * @dev: device that generated the event
313 * @type: type of the event
315 * @value: value of the event
317 * This function should be used by drivers implementing various input
318 * devices to report input events. See also input_inject_event().
320 * NOTE: input_event() may be safely used right after input device was
321 * allocated with input_allocate_device(), even before it is registered
322 * with input_register_device(), but the event will not reach any of the
323 * input handlers. Such early invocation of input_event() may be used
324 * to 'seed' initial state of a switch or initial position of absolute
327 void input_event(struct input_dev
*dev
,
328 unsigned int type
, unsigned int code
, int value
)
332 if (is_event_supported(type
, dev
->evbit
, EV_MAX
)) {
334 spin_lock_irqsave(&dev
->event_lock
, flags
);
335 add_input_randomness(type
, code
, value
);
336 input_handle_event(dev
, type
, code
, value
);
337 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
340 EXPORT_SYMBOL(input_event
);
343 * input_inject_event() - send input event from input handler
344 * @handle: input handle to send event through
345 * @type: type of the event
347 * @value: value of the event
349 * Similar to input_event() but will ignore event if device is
350 * "grabbed" and handle injecting event is not the one that owns
353 void input_inject_event(struct input_handle
*handle
,
354 unsigned int type
, unsigned int code
, int value
)
356 struct input_dev
*dev
= handle
->dev
;
357 struct input_handle
*grab
;
360 if (is_event_supported(type
, dev
->evbit
, EV_MAX
)) {
361 spin_lock_irqsave(&dev
->event_lock
, flags
);
364 grab
= rcu_dereference(dev
->grab
);
365 if (!grab
|| grab
== handle
)
366 input_handle_event(dev
, type
, code
, value
);
369 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
372 EXPORT_SYMBOL(input_inject_event
);
375 * input_grab_device - grabs device for exclusive use
376 * @handle: input handle that wants to own the device
378 * When a device is grabbed by an input handle all events generated by
379 * the device are delivered only to this handle. Also events injected
380 * by other input handles are ignored while device is grabbed.
382 int input_grab_device(struct input_handle
*handle
)
384 struct input_dev
*dev
= handle
->dev
;
387 retval
= mutex_lock_interruptible(&dev
->mutex
);
396 rcu_assign_pointer(dev
->grab
, handle
);
400 mutex_unlock(&dev
->mutex
);
403 EXPORT_SYMBOL(input_grab_device
);
405 static void __input_release_device(struct input_handle
*handle
)
407 struct input_dev
*dev
= handle
->dev
;
409 if (dev
->grab
== handle
) {
410 rcu_assign_pointer(dev
->grab
, NULL
);
411 /* Make sure input_pass_event() notices that grab is gone */
414 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
415 if (handle
->open
&& handle
->handler
->start
)
416 handle
->handler
->start(handle
);
421 * input_release_device - release previously grabbed device
422 * @handle: input handle that owns the device
424 * Releases previously grabbed device so that other input handles can
425 * start receiving input events. Upon release all handlers attached
426 * to the device have their start() method called so they have a change
427 * to synchronize device state with the rest of the system.
429 void input_release_device(struct input_handle
*handle
)
431 struct input_dev
*dev
= handle
->dev
;
433 mutex_lock(&dev
->mutex
);
434 __input_release_device(handle
);
435 mutex_unlock(&dev
->mutex
);
437 EXPORT_SYMBOL(input_release_device
);
440 * input_open_device - open input device
441 * @handle: handle through which device is being accessed
443 * This function should be called by input handlers when they
444 * want to start receive events from given input device.
446 int input_open_device(struct input_handle
*handle
)
448 struct input_dev
*dev
= handle
->dev
;
451 retval
= mutex_lock_interruptible(&dev
->mutex
);
455 if (dev
->going_away
) {
462 if (!dev
->users
++ && dev
->open
)
463 retval
= dev
->open(dev
);
467 if (!--handle
->open
) {
469 * Make sure we are not delivering any more events
470 * through this handle
477 mutex_unlock(&dev
->mutex
);
480 EXPORT_SYMBOL(input_open_device
);
482 int input_flush_device(struct input_handle
*handle
, struct file
*file
)
484 struct input_dev
*dev
= handle
->dev
;
487 retval
= mutex_lock_interruptible(&dev
->mutex
);
492 retval
= dev
->flush(dev
, file
);
494 mutex_unlock(&dev
->mutex
);
497 EXPORT_SYMBOL(input_flush_device
);
500 * input_close_device - close input device
501 * @handle: handle through which device is being accessed
503 * This function should be called by input handlers when they
504 * want to stop receive events from given input device.
506 void input_close_device(struct input_handle
*handle
)
508 struct input_dev
*dev
= handle
->dev
;
510 mutex_lock(&dev
->mutex
);
512 __input_release_device(handle
);
514 if (!--dev
->users
&& dev
->close
)
517 if (!--handle
->open
) {
519 * synchronize_rcu() makes sure that input_pass_event()
520 * completed and that no more input events are delivered
521 * through this handle
526 mutex_unlock(&dev
->mutex
);
528 EXPORT_SYMBOL(input_close_device
);
531 * Prepare device for unregistering
533 static void input_disconnect_device(struct input_dev
*dev
)
535 struct input_handle
*handle
;
539 * Mark device as going away. Note that we take dev->mutex here
540 * not to protect access to dev->going_away but rather to ensure
541 * that there are no threads in the middle of input_open_device()
543 mutex_lock(&dev
->mutex
);
544 dev
->going_away
= true;
545 mutex_unlock(&dev
->mutex
);
547 spin_lock_irq(&dev
->event_lock
);
550 * Simulate keyup events for all pressed keys so that handlers
551 * are not left with "stuck" keys. The driver may continue
552 * generate events even after we done here but they will not
553 * reach any handlers.
555 if (is_event_supported(EV_KEY
, dev
->evbit
, EV_MAX
)) {
556 for (code
= 0; code
<= KEY_MAX
; code
++) {
557 if (is_event_supported(code
, dev
->keybit
, KEY_MAX
) &&
558 __test_and_clear_bit(code
, dev
->key
)) {
559 input_pass_event(dev
, EV_KEY
, code
, 0);
562 input_pass_event(dev
, EV_SYN
, SYN_REPORT
, 1);
565 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
568 spin_unlock_irq(&dev
->event_lock
);
571 static int input_fetch_keycode(struct input_dev
*dev
, int scancode
)
573 switch (dev
->keycodesize
) {
575 return ((u8
*)dev
->keycode
)[scancode
];
578 return ((u16
*)dev
->keycode
)[scancode
];
581 return ((u32
*)dev
->keycode
)[scancode
];
585 static int input_default_getkeycode(struct input_dev
*dev
,
586 unsigned int scancode
,
587 unsigned int *keycode
)
589 if (!dev
->keycodesize
)
592 if (scancode
>= dev
->keycodemax
)
595 *keycode
= input_fetch_keycode(dev
, scancode
);
600 static int input_default_setkeycode(struct input_dev
*dev
,
601 unsigned int scancode
,
602 unsigned int keycode
)
607 if (scancode
>= dev
->keycodemax
)
610 if (!dev
->keycodesize
)
613 if (dev
->keycodesize
< sizeof(keycode
) && (keycode
>> (dev
->keycodesize
* 8)))
616 switch (dev
->keycodesize
) {
618 u8
*k
= (u8
*)dev
->keycode
;
619 old_keycode
= k
[scancode
];
620 k
[scancode
] = keycode
;
624 u16
*k
= (u16
*)dev
->keycode
;
625 old_keycode
= k
[scancode
];
626 k
[scancode
] = keycode
;
630 u32
*k
= (u32
*)dev
->keycode
;
631 old_keycode
= k
[scancode
];
632 k
[scancode
] = keycode
;
637 __clear_bit(old_keycode
, dev
->keybit
);
638 __set_bit(keycode
, dev
->keybit
);
640 for (i
= 0; i
< dev
->keycodemax
; i
++) {
641 if (input_fetch_keycode(dev
, i
) == old_keycode
) {
642 __set_bit(old_keycode
, dev
->keybit
);
643 break; /* Setting the bit twice is useless, so break */
651 * input_get_keycode - retrieve keycode currently mapped to a given scancode
652 * @dev: input device which keymap is being queried
653 * @scancode: scancode (or its equivalent for device in question) for which
657 * This function should be called by anyone interested in retrieving current
658 * keymap. Presently keyboard and evdev handlers use it.
660 int input_get_keycode(struct input_dev
*dev
,
661 unsigned int scancode
, unsigned int *keycode
)
663 return dev
->getkeycode(dev
, scancode
, keycode
);
665 EXPORT_SYMBOL(input_get_keycode
);
668 * input_get_keycode - assign new keycode to a given scancode
669 * @dev: input device which keymap is being updated
670 * @scancode: scancode (or its equivalent for device in question)
671 * @keycode: new keycode to be assigned to the scancode
673 * This function should be called by anyone needing to update current
674 * keymap. Presently keyboard and evdev handlers use it.
676 int input_set_keycode(struct input_dev
*dev
,
677 unsigned int scancode
, unsigned int keycode
)
683 if (keycode
> KEY_MAX
)
686 spin_lock_irqsave(&dev
->event_lock
, flags
);
688 retval
= dev
->getkeycode(dev
, scancode
, &old_keycode
);
692 retval
= dev
->setkeycode(dev
, scancode
, keycode
);
696 /* Make sure KEY_RESERVED did not get enabled. */
697 __clear_bit(KEY_RESERVED
, dev
->keybit
);
700 * Simulate keyup event if keycode is not present
701 * in the keymap anymore
703 if (test_bit(EV_KEY
, dev
->evbit
) &&
704 !is_event_supported(old_keycode
, dev
->keybit
, KEY_MAX
) &&
705 __test_and_clear_bit(old_keycode
, dev
->key
)) {
707 input_pass_event(dev
, EV_KEY
, old_keycode
, 0);
709 input_pass_event(dev
, EV_SYN
, SYN_REPORT
, 1);
713 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
717 EXPORT_SYMBOL(input_set_keycode
);
719 #define MATCH_BIT(bit, max) \
720 for (i = 0; i < BITS_TO_LONGS(max); i++) \
721 if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
723 if (i != BITS_TO_LONGS(max)) \
726 static const struct input_device_id
*input_match_device(struct input_handler
*handler
,
727 struct input_dev
*dev
)
729 const struct input_device_id
*id
;
732 for (id
= handler
->id_table
; id
->flags
|| id
->driver_info
; id
++) {
734 if (id
->flags
& INPUT_DEVICE_ID_MATCH_BUS
)
735 if (id
->bustype
!= dev
->id
.bustype
)
738 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VENDOR
)
739 if (id
->vendor
!= dev
->id
.vendor
)
742 if (id
->flags
& INPUT_DEVICE_ID_MATCH_PRODUCT
)
743 if (id
->product
!= dev
->id
.product
)
746 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VERSION
)
747 if (id
->version
!= dev
->id
.version
)
750 MATCH_BIT(evbit
, EV_MAX
);
751 MATCH_BIT(keybit
, KEY_MAX
);
752 MATCH_BIT(relbit
, REL_MAX
);
753 MATCH_BIT(absbit
, ABS_MAX
);
754 MATCH_BIT(mscbit
, MSC_MAX
);
755 MATCH_BIT(ledbit
, LED_MAX
);
756 MATCH_BIT(sndbit
, SND_MAX
);
757 MATCH_BIT(ffbit
, FF_MAX
);
758 MATCH_BIT(swbit
, SW_MAX
);
760 if (!handler
->match
|| handler
->match(handler
, dev
))
767 static int input_attach_handler(struct input_dev
*dev
, struct input_handler
*handler
)
769 const struct input_device_id
*id
;
772 id
= input_match_device(handler
, dev
);
776 error
= handler
->connect(handler
, dev
, id
);
777 if (error
&& error
!= -ENODEV
)
779 "input: failed to attach handler %s to device %s, "
781 handler
->name
, kobject_name(&dev
->dev
.kobj
), error
);
788 static int input_bits_to_string(char *buf
, int buf_size
,
789 unsigned long bits
, bool skip_empty
)
793 if (INPUT_COMPAT_TEST
) {
794 u32 dword
= bits
>> 32;
795 if (dword
|| !skip_empty
)
796 len
+= snprintf(buf
, buf_size
, "%x ", dword
);
798 dword
= bits
& 0xffffffffUL
;
799 if (dword
|| !skip_empty
|| len
)
800 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0),
803 if (bits
|| !skip_empty
)
804 len
+= snprintf(buf
, buf_size
, "%lx", bits
);
810 #else /* !CONFIG_COMPAT */
812 static int input_bits_to_string(char *buf
, int buf_size
,
813 unsigned long bits
, bool skip_empty
)
815 return bits
|| !skip_empty
?
816 snprintf(buf
, buf_size
, "%lx", bits
) : 0;
821 #ifdef CONFIG_PROC_FS
823 static struct proc_dir_entry
*proc_bus_input_dir
;
824 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait
);
825 static int input_devices_state
;
827 static inline void input_wakeup_procfs_readers(void)
829 input_devices_state
++;
830 wake_up(&input_devices_poll_wait
);
833 static unsigned int input_proc_devices_poll(struct file
*file
, poll_table
*wait
)
835 poll_wait(file
, &input_devices_poll_wait
, wait
);
836 if (file
->f_version
!= input_devices_state
) {
837 file
->f_version
= input_devices_state
;
838 return POLLIN
| POLLRDNORM
;
844 union input_seq_state
{
852 static void *input_devices_seq_start(struct seq_file
*seq
, loff_t
*pos
)
854 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
857 /* We need to fit into seq->private pointer */
858 BUILD_BUG_ON(sizeof(union input_seq_state
) != sizeof(seq
->private));
860 error
= mutex_lock_interruptible(&input_mutex
);
862 state
->mutex_acquired
= false;
863 return ERR_PTR(error
);
866 state
->mutex_acquired
= true;
868 return seq_list_start(&input_dev_list
, *pos
);
871 static void *input_devices_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
873 return seq_list_next(v
, &input_dev_list
, pos
);
876 static void input_seq_stop(struct seq_file
*seq
, void *v
)
878 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
880 if (state
->mutex_acquired
)
881 mutex_unlock(&input_mutex
);
884 static void input_seq_print_bitmap(struct seq_file
*seq
, const char *name
,
885 unsigned long *bitmap
, int max
)
888 bool skip_empty
= true;
891 seq_printf(seq
, "B: %s=", name
);
893 for (i
= BITS_TO_LONGS(max
) - 1; i
>= 0; i
--) {
894 if (input_bits_to_string(buf
, sizeof(buf
),
895 bitmap
[i
], skip_empty
)) {
897 seq_printf(seq
, "%s%s", buf
, i
> 0 ? " " : "");
902 * If no output was produced print a single 0.
910 static int input_devices_seq_show(struct seq_file
*seq
, void *v
)
912 struct input_dev
*dev
= container_of(v
, struct input_dev
, node
);
913 const char *path
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
914 struct input_handle
*handle
;
916 seq_printf(seq
, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
917 dev
->id
.bustype
, dev
->id
.vendor
, dev
->id
.product
, dev
->id
.version
);
919 seq_printf(seq
, "N: Name=\"%s\"\n", dev
->name
? dev
->name
: "");
920 seq_printf(seq
, "P: Phys=%s\n", dev
->phys
? dev
->phys
: "");
921 seq_printf(seq
, "S: Sysfs=%s\n", path
? path
: "");
922 seq_printf(seq
, "U: Uniq=%s\n", dev
->uniq
? dev
->uniq
: "");
923 seq_printf(seq
, "H: Handlers=");
925 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
926 seq_printf(seq
, "%s ", handle
->name
);
929 input_seq_print_bitmap(seq
, "EV", dev
->evbit
, EV_MAX
);
930 if (test_bit(EV_KEY
, dev
->evbit
))
931 input_seq_print_bitmap(seq
, "KEY", dev
->keybit
, KEY_MAX
);
932 if (test_bit(EV_REL
, dev
->evbit
))
933 input_seq_print_bitmap(seq
, "REL", dev
->relbit
, REL_MAX
);
934 if (test_bit(EV_ABS
, dev
->evbit
))
935 input_seq_print_bitmap(seq
, "ABS", dev
->absbit
, ABS_MAX
);
936 if (test_bit(EV_MSC
, dev
->evbit
))
937 input_seq_print_bitmap(seq
, "MSC", dev
->mscbit
, MSC_MAX
);
938 if (test_bit(EV_LED
, dev
->evbit
))
939 input_seq_print_bitmap(seq
, "LED", dev
->ledbit
, LED_MAX
);
940 if (test_bit(EV_SND
, dev
->evbit
))
941 input_seq_print_bitmap(seq
, "SND", dev
->sndbit
, SND_MAX
);
942 if (test_bit(EV_FF
, dev
->evbit
))
943 input_seq_print_bitmap(seq
, "FF", dev
->ffbit
, FF_MAX
);
944 if (test_bit(EV_SW
, dev
->evbit
))
945 input_seq_print_bitmap(seq
, "SW", dev
->swbit
, SW_MAX
);
953 static const struct seq_operations input_devices_seq_ops
= {
954 .start
= input_devices_seq_start
,
955 .next
= input_devices_seq_next
,
956 .stop
= input_seq_stop
,
957 .show
= input_devices_seq_show
,
960 static int input_proc_devices_open(struct inode
*inode
, struct file
*file
)
962 return seq_open(file
, &input_devices_seq_ops
);
965 static const struct file_operations input_devices_fileops
= {
966 .owner
= THIS_MODULE
,
967 .open
= input_proc_devices_open
,
968 .poll
= input_proc_devices_poll
,
971 .release
= seq_release
,
974 static void *input_handlers_seq_start(struct seq_file
*seq
, loff_t
*pos
)
976 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
979 /* We need to fit into seq->private pointer */
980 BUILD_BUG_ON(sizeof(union input_seq_state
) != sizeof(seq
->private));
982 error
= mutex_lock_interruptible(&input_mutex
);
984 state
->mutex_acquired
= false;
985 return ERR_PTR(error
);
988 state
->mutex_acquired
= true;
991 return seq_list_start(&input_handler_list
, *pos
);
994 static void *input_handlers_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
996 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
998 state
->pos
= *pos
+ 1;
999 return seq_list_next(v
, &input_handler_list
, pos
);
1002 static int input_handlers_seq_show(struct seq_file
*seq
, void *v
)
1004 struct input_handler
*handler
= container_of(v
, struct input_handler
, node
);
1005 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
1007 seq_printf(seq
, "N: Number=%u Name=%s", state
->pos
, handler
->name
);
1008 if (handler
->filter
)
1009 seq_puts(seq
, " (filter)");
1011 seq_printf(seq
, " Minor=%d", handler
->minor
);
1012 seq_putc(seq
, '\n');
1017 static const struct seq_operations input_handlers_seq_ops
= {
1018 .start
= input_handlers_seq_start
,
1019 .next
= input_handlers_seq_next
,
1020 .stop
= input_seq_stop
,
1021 .show
= input_handlers_seq_show
,
1024 static int input_proc_handlers_open(struct inode
*inode
, struct file
*file
)
1026 return seq_open(file
, &input_handlers_seq_ops
);
1029 static const struct file_operations input_handlers_fileops
= {
1030 .owner
= THIS_MODULE
,
1031 .open
= input_proc_handlers_open
,
1033 .llseek
= seq_lseek
,
1034 .release
= seq_release
,
1037 static int __init
input_proc_init(void)
1039 struct proc_dir_entry
*entry
;
1041 proc_bus_input_dir
= proc_mkdir("bus/input", NULL
);
1042 if (!proc_bus_input_dir
)
1045 entry
= proc_create("devices", 0, proc_bus_input_dir
,
1046 &input_devices_fileops
);
1050 entry
= proc_create("handlers", 0, proc_bus_input_dir
,
1051 &input_handlers_fileops
);
1057 fail2
: remove_proc_entry("devices", proc_bus_input_dir
);
1058 fail1
: remove_proc_entry("bus/input", NULL
);
1062 static void input_proc_exit(void)
1064 remove_proc_entry("devices", proc_bus_input_dir
);
1065 remove_proc_entry("handlers", proc_bus_input_dir
);
1066 remove_proc_entry("bus/input", NULL
);
1069 #else /* !CONFIG_PROC_FS */
1070 static inline void input_wakeup_procfs_readers(void) { }
1071 static inline int input_proc_init(void) { return 0; }
1072 static inline void input_proc_exit(void) { }
1075 #define INPUT_DEV_STRING_ATTR_SHOW(name) \
1076 static ssize_t input_dev_show_##name(struct device *dev, \
1077 struct device_attribute *attr, \
1080 struct input_dev *input_dev = to_input_dev(dev); \
1082 return scnprintf(buf, PAGE_SIZE, "%s\n", \
1083 input_dev->name ? input_dev->name : ""); \
1085 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1087 INPUT_DEV_STRING_ATTR_SHOW(name
);
1088 INPUT_DEV_STRING_ATTR_SHOW(phys
);
1089 INPUT_DEV_STRING_ATTR_SHOW(uniq
);
1091 static int input_print_modalias_bits(char *buf
, int size
,
1092 char name
, unsigned long *bm
,
1093 unsigned int min_bit
, unsigned int max_bit
)
1097 len
+= snprintf(buf
, max(size
, 0), "%c", name
);
1098 for (i
= min_bit
; i
< max_bit
; i
++)
1099 if (bm
[BIT_WORD(i
)] & BIT_MASK(i
))
1100 len
+= snprintf(buf
+ len
, max(size
- len
, 0), "%X,", i
);
1104 static int input_print_modalias(char *buf
, int size
, struct input_dev
*id
,
1109 len
= snprintf(buf
, max(size
, 0),
1110 "input:b%04Xv%04Xp%04Xe%04X-",
1111 id
->id
.bustype
, id
->id
.vendor
,
1112 id
->id
.product
, id
->id
.version
);
1114 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1115 'e', id
->evbit
, 0, EV_MAX
);
1116 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1117 'k', id
->keybit
, KEY_MIN_INTERESTING
, KEY_MAX
);
1118 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1119 'r', id
->relbit
, 0, REL_MAX
);
1120 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1121 'a', id
->absbit
, 0, ABS_MAX
);
1122 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1123 'm', id
->mscbit
, 0, MSC_MAX
);
1124 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1125 'l', id
->ledbit
, 0, LED_MAX
);
1126 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1127 's', id
->sndbit
, 0, SND_MAX
);
1128 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1129 'f', id
->ffbit
, 0, FF_MAX
);
1130 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1131 'w', id
->swbit
, 0, SW_MAX
);
1134 len
+= snprintf(buf
+ len
, max(size
- len
, 0), "\n");
1139 static ssize_t
input_dev_show_modalias(struct device
*dev
,
1140 struct device_attribute
*attr
,
1143 struct input_dev
*id
= to_input_dev(dev
);
1146 len
= input_print_modalias(buf
, PAGE_SIZE
, id
, 1);
1148 return min_t(int, len
, PAGE_SIZE
);
1150 static DEVICE_ATTR(modalias
, S_IRUGO
, input_dev_show_modalias
, NULL
);
1152 static struct attribute
*input_dev_attrs
[] = {
1153 &dev_attr_name
.attr
,
1154 &dev_attr_phys
.attr
,
1155 &dev_attr_uniq
.attr
,
1156 &dev_attr_modalias
.attr
,
1160 static struct attribute_group input_dev_attr_group
= {
1161 .attrs
= input_dev_attrs
,
1164 #define INPUT_DEV_ID_ATTR(name) \
1165 static ssize_t input_dev_show_id_##name(struct device *dev, \
1166 struct device_attribute *attr, \
1169 struct input_dev *input_dev = to_input_dev(dev); \
1170 return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1172 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1174 INPUT_DEV_ID_ATTR(bustype
);
1175 INPUT_DEV_ID_ATTR(vendor
);
1176 INPUT_DEV_ID_ATTR(product
);
1177 INPUT_DEV_ID_ATTR(version
);
1179 static struct attribute
*input_dev_id_attrs
[] = {
1180 &dev_attr_bustype
.attr
,
1181 &dev_attr_vendor
.attr
,
1182 &dev_attr_product
.attr
,
1183 &dev_attr_version
.attr
,
1187 static struct attribute_group input_dev_id_attr_group
= {
1189 .attrs
= input_dev_id_attrs
,
1192 static int input_print_bitmap(char *buf
, int buf_size
, unsigned long *bitmap
,
1193 int max
, int add_cr
)
1197 bool skip_empty
= true;
1199 for (i
= BITS_TO_LONGS(max
) - 1; i
>= 0; i
--) {
1200 len
+= input_bits_to_string(buf
+ len
, max(buf_size
- len
, 0),
1201 bitmap
[i
], skip_empty
);
1205 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0), " ");
1210 * If no output was produced print a single 0.
1213 len
= snprintf(buf
, buf_size
, "%d", 0);
1216 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0), "\n");
1221 #define INPUT_DEV_CAP_ATTR(ev, bm) \
1222 static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1223 struct device_attribute *attr, \
1226 struct input_dev *input_dev = to_input_dev(dev); \
1227 int len = input_print_bitmap(buf, PAGE_SIZE, \
1228 input_dev->bm##bit, ev##_MAX, \
1230 return min_t(int, len, PAGE_SIZE); \
1232 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1234 INPUT_DEV_CAP_ATTR(EV
, ev
);
1235 INPUT_DEV_CAP_ATTR(KEY
, key
);
1236 INPUT_DEV_CAP_ATTR(REL
, rel
);
1237 INPUT_DEV_CAP_ATTR(ABS
, abs
);
1238 INPUT_DEV_CAP_ATTR(MSC
, msc
);
1239 INPUT_DEV_CAP_ATTR(LED
, led
);
1240 INPUT_DEV_CAP_ATTR(SND
, snd
);
1241 INPUT_DEV_CAP_ATTR(FF
, ff
);
1242 INPUT_DEV_CAP_ATTR(SW
, sw
);
1244 static struct attribute
*input_dev_caps_attrs
[] = {
1257 static struct attribute_group input_dev_caps_attr_group
= {
1258 .name
= "capabilities",
1259 .attrs
= input_dev_caps_attrs
,
1262 static const struct attribute_group
*input_dev_attr_groups
[] = {
1263 &input_dev_attr_group
,
1264 &input_dev_id_attr_group
,
1265 &input_dev_caps_attr_group
,
1269 static void input_dev_release(struct device
*device
)
1271 struct input_dev
*dev
= to_input_dev(device
);
1273 input_ff_destroy(dev
);
1276 module_put(THIS_MODULE
);
1280 * Input uevent interface - loading event handlers based on
1283 static int input_add_uevent_bm_var(struct kobj_uevent_env
*env
,
1284 const char *name
, unsigned long *bitmap
, int max
)
1288 if (add_uevent_var(env
, "%s=", name
))
1291 len
= input_print_bitmap(&env
->buf
[env
->buflen
- 1],
1292 sizeof(env
->buf
) - env
->buflen
,
1293 bitmap
, max
, false);
1294 if (len
>= (sizeof(env
->buf
) - env
->buflen
))
1301 static int input_add_uevent_modalias_var(struct kobj_uevent_env
*env
,
1302 struct input_dev
*dev
)
1306 if (add_uevent_var(env
, "MODALIAS="))
1309 len
= input_print_modalias(&env
->buf
[env
->buflen
- 1],
1310 sizeof(env
->buf
) - env
->buflen
,
1312 if (len
>= (sizeof(env
->buf
) - env
->buflen
))
1319 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
1321 int err = add_uevent_var(env, fmt, val); \
1326 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
1328 int err = input_add_uevent_bm_var(env, name, bm, max); \
1333 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1335 int err = input_add_uevent_modalias_var(env, dev); \
1340 static int input_dev_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
1342 struct input_dev
*dev
= to_input_dev(device
);
1344 INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1345 dev
->id
.bustype
, dev
->id
.vendor
,
1346 dev
->id
.product
, dev
->id
.version
);
1348 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev
->name
);
1350 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev
->phys
);
1352 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev
->uniq
);
1354 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev
->evbit
, EV_MAX
);
1355 if (test_bit(EV_KEY
, dev
->evbit
))
1356 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev
->keybit
, KEY_MAX
);
1357 if (test_bit(EV_REL
, dev
->evbit
))
1358 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev
->relbit
, REL_MAX
);
1359 if (test_bit(EV_ABS
, dev
->evbit
))
1360 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev
->absbit
, ABS_MAX
);
1361 if (test_bit(EV_MSC
, dev
->evbit
))
1362 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev
->mscbit
, MSC_MAX
);
1363 if (test_bit(EV_LED
, dev
->evbit
))
1364 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev
->ledbit
, LED_MAX
);
1365 if (test_bit(EV_SND
, dev
->evbit
))
1366 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev
->sndbit
, SND_MAX
);
1367 if (test_bit(EV_FF
, dev
->evbit
))
1368 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev
->ffbit
, FF_MAX
);
1369 if (test_bit(EV_SW
, dev
->evbit
))
1370 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev
->swbit
, SW_MAX
);
1372 INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev
);
1377 #define INPUT_DO_TOGGLE(dev, type, bits, on) \
1382 if (!test_bit(EV_##type, dev->evbit)) \
1385 for (i = 0; i < type##_MAX; i++) { \
1386 if (!test_bit(i, dev->bits##bit)) \
1389 active = test_bit(i, dev->bits); \
1390 if (!active && !on) \
1393 dev->event(dev, EV_##type, i, on ? active : 0); \
1398 static void input_dev_reset(struct input_dev
*dev
, bool activate
)
1403 INPUT_DO_TOGGLE(dev
, LED
, led
, activate
);
1404 INPUT_DO_TOGGLE(dev
, SND
, snd
, activate
);
1406 if (activate
&& test_bit(EV_REP
, dev
->evbit
)) {
1407 dev
->event(dev
, EV_REP
, REP_PERIOD
, dev
->rep
[REP_PERIOD
]);
1408 dev
->event(dev
, EV_REP
, REP_DELAY
, dev
->rep
[REP_DELAY
]);
1412 static int input_dev_suspend(struct device
*dev
)
1414 struct input_dev
*input_dev
= to_input_dev(dev
);
1416 mutex_lock(&input_dev
->mutex
);
1417 input_dev_reset(input_dev
, false);
1418 mutex_unlock(&input_dev
->mutex
);
1423 static int input_dev_resume(struct device
*dev
)
1425 struct input_dev
*input_dev
= to_input_dev(dev
);
1427 mutex_lock(&input_dev
->mutex
);
1428 input_dev_reset(input_dev
, true);
1429 mutex_unlock(&input_dev
->mutex
);
1434 static const struct dev_pm_ops input_dev_pm_ops
= {
1435 .suspend
= input_dev_suspend
,
1436 .resume
= input_dev_resume
,
1437 .poweroff
= input_dev_suspend
,
1438 .restore
= input_dev_resume
,
1440 #endif /* CONFIG_PM */
1442 static struct device_type input_dev_type
= {
1443 .groups
= input_dev_attr_groups
,
1444 .release
= input_dev_release
,
1445 .uevent
= input_dev_uevent
,
1447 .pm
= &input_dev_pm_ops
,
1451 static char *input_devnode(struct device
*dev
, mode_t
*mode
)
1453 return kasprintf(GFP_KERNEL
, "input/%s", dev_name(dev
));
1456 struct class input_class
= {
1458 .devnode
= input_devnode
,
1460 EXPORT_SYMBOL_GPL(input_class
);
1463 * input_allocate_device - allocate memory for new input device
1465 * Returns prepared struct input_dev or NULL.
1467 * NOTE: Use input_free_device() to free devices that have not been
1468 * registered; input_unregister_device() should be used for already
1469 * registered devices.
1471 struct input_dev
*input_allocate_device(void)
1473 struct input_dev
*dev
;
1475 dev
= kzalloc(sizeof(struct input_dev
), GFP_KERNEL
);
1477 dev
->dev
.type
= &input_dev_type
;
1478 dev
->dev
.class = &input_class
;
1479 device_initialize(&dev
->dev
);
1480 mutex_init(&dev
->mutex
);
1481 spin_lock_init(&dev
->event_lock
);
1482 INIT_LIST_HEAD(&dev
->h_list
);
1483 INIT_LIST_HEAD(&dev
->node
);
1485 __module_get(THIS_MODULE
);
1490 EXPORT_SYMBOL(input_allocate_device
);
1493 * input_free_device - free memory occupied by input_dev structure
1494 * @dev: input device to free
1496 * This function should only be used if input_register_device()
1497 * was not called yet or if it failed. Once device was registered
1498 * use input_unregister_device() and memory will be freed once last
1499 * reference to the device is dropped.
1501 * Device should be allocated by input_allocate_device().
1503 * NOTE: If there are references to the input device then memory
1504 * will not be freed until last reference is dropped.
1506 void input_free_device(struct input_dev
*dev
)
1509 input_put_device(dev
);
1511 EXPORT_SYMBOL(input_free_device
);
1514 * input_set_capability - mark device as capable of a certain event
1515 * @dev: device that is capable of emitting or accepting event
1516 * @type: type of the event (EV_KEY, EV_REL, etc...)
1519 * In addition to setting up corresponding bit in appropriate capability
1520 * bitmap the function also adjusts dev->evbit.
1522 void input_set_capability(struct input_dev
*dev
, unsigned int type
, unsigned int code
)
1526 __set_bit(code
, dev
->keybit
);
1530 __set_bit(code
, dev
->relbit
);
1534 __set_bit(code
, dev
->absbit
);
1538 __set_bit(code
, dev
->mscbit
);
1542 __set_bit(code
, dev
->swbit
);
1546 __set_bit(code
, dev
->ledbit
);
1550 __set_bit(code
, dev
->sndbit
);
1554 __set_bit(code
, dev
->ffbit
);
1563 "input_set_capability: unknown type %u (code %u)\n",
1569 __set_bit(type
, dev
->evbit
);
1571 EXPORT_SYMBOL(input_set_capability
);
1573 #define INPUT_CLEANSE_BITMASK(dev, type, bits) \
1575 if (!test_bit(EV_##type, dev->evbit)) \
1576 memset(dev->bits##bit, 0, \
1577 sizeof(dev->bits##bit)); \
1580 static void input_cleanse_bitmasks(struct input_dev
*dev
)
1582 INPUT_CLEANSE_BITMASK(dev
, KEY
, key
);
1583 INPUT_CLEANSE_BITMASK(dev
, REL
, rel
);
1584 INPUT_CLEANSE_BITMASK(dev
, ABS
, abs
);
1585 INPUT_CLEANSE_BITMASK(dev
, MSC
, msc
);
1586 INPUT_CLEANSE_BITMASK(dev
, LED
, led
);
1587 INPUT_CLEANSE_BITMASK(dev
, SND
, snd
);
1588 INPUT_CLEANSE_BITMASK(dev
, FF
, ff
);
1589 INPUT_CLEANSE_BITMASK(dev
, SW
, sw
);
1593 * input_register_device - register device with input core
1594 * @dev: device to be registered
1596 * This function registers device with input core. The device must be
1597 * allocated with input_allocate_device() and all it's capabilities
1598 * set up before registering.
1599 * If function fails the device must be freed with input_free_device().
1600 * Once device has been successfully registered it can be unregistered
1601 * with input_unregister_device(); input_free_device() should not be
1602 * called in this case.
1604 int input_register_device(struct input_dev
*dev
)
1606 static atomic_t input_no
= ATOMIC_INIT(0);
1607 struct input_handler
*handler
;
1611 /* Every input device generates EV_SYN/SYN_REPORT events. */
1612 __set_bit(EV_SYN
, dev
->evbit
);
1614 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
1615 __clear_bit(KEY_RESERVED
, dev
->keybit
);
1617 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
1618 input_cleanse_bitmasks(dev
);
1621 * If delay and period are pre-set by the driver, then autorepeating
1622 * is handled by the driver itself and we don't do it in input.c.
1624 init_timer(&dev
->timer
);
1625 if (!dev
->rep
[REP_DELAY
] && !dev
->rep
[REP_PERIOD
]) {
1626 dev
->timer
.data
= (long) dev
;
1627 dev
->timer
.function
= input_repeat_key
;
1628 dev
->rep
[REP_DELAY
] = 250;
1629 dev
->rep
[REP_PERIOD
] = 33;
1632 if (!dev
->getkeycode
)
1633 dev
->getkeycode
= input_default_getkeycode
;
1635 if (!dev
->setkeycode
)
1636 dev
->setkeycode
= input_default_setkeycode
;
1638 dev_set_name(&dev
->dev
, "input%ld",
1639 (unsigned long) atomic_inc_return(&input_no
) - 1);
1641 error
= device_add(&dev
->dev
);
1645 path
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
1646 printk(KERN_INFO
"input: %s as %s\n",
1647 dev
->name
? dev
->name
: "Unspecified device", path
? path
: "N/A");
1650 error
= mutex_lock_interruptible(&input_mutex
);
1652 device_del(&dev
->dev
);
1656 list_add_tail(&dev
->node
, &input_dev_list
);
1658 list_for_each_entry(handler
, &input_handler_list
, node
)
1659 input_attach_handler(dev
, handler
);
1661 input_wakeup_procfs_readers();
1663 mutex_unlock(&input_mutex
);
1667 EXPORT_SYMBOL(input_register_device
);
1670 * input_unregister_device - unregister previously registered device
1671 * @dev: device to be unregistered
1673 * This function unregisters an input device. Once device is unregistered
1674 * the caller should not try to access it as it may get freed at any moment.
1676 void input_unregister_device(struct input_dev
*dev
)
1678 struct input_handle
*handle
, *next
;
1680 input_disconnect_device(dev
);
1682 mutex_lock(&input_mutex
);
1684 list_for_each_entry_safe(handle
, next
, &dev
->h_list
, d_node
)
1685 handle
->handler
->disconnect(handle
);
1686 WARN_ON(!list_empty(&dev
->h_list
));
1688 del_timer_sync(&dev
->timer
);
1689 list_del_init(&dev
->node
);
1691 input_wakeup_procfs_readers();
1693 mutex_unlock(&input_mutex
);
1695 device_unregister(&dev
->dev
);
1697 EXPORT_SYMBOL(input_unregister_device
);
1700 * input_register_handler - register a new input handler
1701 * @handler: handler to be registered
1703 * This function registers a new input handler (interface) for input
1704 * devices in the system and attaches it to all input devices that
1705 * are compatible with the handler.
1707 int input_register_handler(struct input_handler
*handler
)
1709 struct input_dev
*dev
;
1712 retval
= mutex_lock_interruptible(&input_mutex
);
1716 INIT_LIST_HEAD(&handler
->h_list
);
1718 if (handler
->fops
!= NULL
) {
1719 if (input_table
[handler
->minor
>> 5]) {
1723 input_table
[handler
->minor
>> 5] = handler
;
1726 list_add_tail(&handler
->node
, &input_handler_list
);
1728 list_for_each_entry(dev
, &input_dev_list
, node
)
1729 input_attach_handler(dev
, handler
);
1731 input_wakeup_procfs_readers();
1734 mutex_unlock(&input_mutex
);
1737 EXPORT_SYMBOL(input_register_handler
);
1740 * input_unregister_handler - unregisters an input handler
1741 * @handler: handler to be unregistered
1743 * This function disconnects a handler from its input devices and
1744 * removes it from lists of known handlers.
1746 void input_unregister_handler(struct input_handler
*handler
)
1748 struct input_handle
*handle
, *next
;
1750 mutex_lock(&input_mutex
);
1752 list_for_each_entry_safe(handle
, next
, &handler
->h_list
, h_node
)
1753 handler
->disconnect(handle
);
1754 WARN_ON(!list_empty(&handler
->h_list
));
1756 list_del_init(&handler
->node
);
1758 if (handler
->fops
!= NULL
)
1759 input_table
[handler
->minor
>> 5] = NULL
;
1761 input_wakeup_procfs_readers();
1763 mutex_unlock(&input_mutex
);
1765 EXPORT_SYMBOL(input_unregister_handler
);
1768 * input_handler_for_each_handle - handle iterator
1769 * @handler: input handler to iterate
1770 * @data: data for the callback
1771 * @fn: function to be called for each handle
1773 * Iterate over @bus's list of devices, and call @fn for each, passing
1774 * it @data and stop when @fn returns a non-zero value. The function is
1775 * using RCU to traverse the list and therefore may be usind in atonic
1776 * contexts. The @fn callback is invoked from RCU critical section and
1777 * thus must not sleep.
1779 int input_handler_for_each_handle(struct input_handler
*handler
, void *data
,
1780 int (*fn
)(struct input_handle
*, void *))
1782 struct input_handle
*handle
;
1787 list_for_each_entry_rcu(handle
, &handler
->h_list
, h_node
) {
1788 retval
= fn(handle
, data
);
1797 EXPORT_SYMBOL(input_handler_for_each_handle
);
1800 * input_register_handle - register a new input handle
1801 * @handle: handle to register
1803 * This function puts a new input handle onto device's
1804 * and handler's lists so that events can flow through
1805 * it once it is opened using input_open_device().
1807 * This function is supposed to be called from handler's
1810 int input_register_handle(struct input_handle
*handle
)
1812 struct input_handler
*handler
= handle
->handler
;
1813 struct input_dev
*dev
= handle
->dev
;
1817 * We take dev->mutex here to prevent race with
1818 * input_release_device().
1820 error
= mutex_lock_interruptible(&dev
->mutex
);
1825 * Filters go to the head of the list, normal handlers
1828 if (handler
->filter
)
1829 list_add_rcu(&handle
->d_node
, &dev
->h_list
);
1831 list_add_tail_rcu(&handle
->d_node
, &dev
->h_list
);
1833 mutex_unlock(&dev
->mutex
);
1836 * Since we are supposed to be called from ->connect()
1837 * which is mutually exclusive with ->disconnect()
1838 * we can't be racing with input_unregister_handle()
1839 * and so separate lock is not needed here.
1841 list_add_tail_rcu(&handle
->h_node
, &handler
->h_list
);
1844 handler
->start(handle
);
1848 EXPORT_SYMBOL(input_register_handle
);
1851 * input_unregister_handle - unregister an input handle
1852 * @handle: handle to unregister
1854 * This function removes input handle from device's
1855 * and handler's lists.
1857 * This function is supposed to be called from handler's
1858 * disconnect() method.
1860 void input_unregister_handle(struct input_handle
*handle
)
1862 struct input_dev
*dev
= handle
->dev
;
1864 list_del_rcu(&handle
->h_node
);
1867 * Take dev->mutex to prevent race with input_release_device().
1869 mutex_lock(&dev
->mutex
);
1870 list_del_rcu(&handle
->d_node
);
1871 mutex_unlock(&dev
->mutex
);
1875 EXPORT_SYMBOL(input_unregister_handle
);
1877 static int input_open_file(struct inode
*inode
, struct file
*file
)
1879 struct input_handler
*handler
;
1880 const struct file_operations
*old_fops
, *new_fops
= NULL
;
1883 err
= mutex_lock_interruptible(&input_mutex
);
1887 /* No load-on-demand here? */
1888 handler
= input_table
[iminor(inode
) >> 5];
1890 new_fops
= fops_get(handler
->fops
);
1892 mutex_unlock(&input_mutex
);
1895 * That's _really_ odd. Usually NULL ->open means "nothing special",
1896 * not "no device". Oh, well...
1898 if (!new_fops
|| !new_fops
->open
) {
1904 old_fops
= file
->f_op
;
1905 file
->f_op
= new_fops
;
1907 err
= new_fops
->open(inode
, file
);
1909 fops_put(file
->f_op
);
1910 file
->f_op
= fops_get(old_fops
);
1917 static const struct file_operations input_fops
= {
1918 .owner
= THIS_MODULE
,
1919 .open
= input_open_file
,
1922 static void __init
input_init_abs_bypass(void)
1924 const unsigned int *p
;
1926 for (p
= input_abs_bypass_init_data
; *p
; p
++)
1927 input_abs_bypass
[BIT_WORD(*p
)] |= BIT_MASK(*p
);
1930 static int __init
input_init(void)
1934 input_init_abs_bypass();
1936 err
= class_register(&input_class
);
1938 printk(KERN_ERR
"input: unable to register input_dev class\n");
1942 err
= input_proc_init();
1946 err
= register_chrdev(INPUT_MAJOR
, "input", &input_fops
);
1948 printk(KERN_ERR
"input: unable to register char major %d", INPUT_MAJOR
);
1954 fail2
: input_proc_exit();
1955 fail1
: class_unregister(&input_class
);
1959 static void __exit
input_exit(void)
1962 unregister_chrdev(INPUT_MAJOR
, "input");
1963 class_unregister(&input_class
);
1966 subsys_initcall(input_init
);
1967 module_exit(input_exit
);