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 * Simulate keyup events for all keys that are marked as pressed.
532 * The function must be called with dev->event_lock held.
534 static void input_dev_release_keys(struct input_dev
*dev
)
538 if (is_event_supported(EV_KEY
, dev
->evbit
, EV_MAX
)) {
539 for (code
= 0; code
<= KEY_MAX
; code
++) {
540 if (is_event_supported(code
, dev
->keybit
, KEY_MAX
) &&
541 __test_and_clear_bit(code
, dev
->key
)) {
542 input_pass_event(dev
, EV_KEY
, code
, 0);
545 input_pass_event(dev
, EV_SYN
, SYN_REPORT
, 1);
550 * Prepare device for unregistering
552 static void input_disconnect_device(struct input_dev
*dev
)
554 struct input_handle
*handle
;
557 * Mark device as going away. Note that we take dev->mutex here
558 * not to protect access to dev->going_away but rather to ensure
559 * that there are no threads in the middle of input_open_device()
561 mutex_lock(&dev
->mutex
);
562 dev
->going_away
= true;
563 mutex_unlock(&dev
->mutex
);
565 spin_lock_irq(&dev
->event_lock
);
568 * Simulate keyup events for all pressed keys so that handlers
569 * are not left with "stuck" keys. The driver may continue
570 * generate events even after we done here but they will not
571 * reach any handlers.
573 input_dev_release_keys(dev
);
575 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
578 spin_unlock_irq(&dev
->event_lock
);
581 static int input_fetch_keycode(struct input_dev
*dev
, int scancode
)
583 switch (dev
->keycodesize
) {
585 return ((u8
*)dev
->keycode
)[scancode
];
588 return ((u16
*)dev
->keycode
)[scancode
];
591 return ((u32
*)dev
->keycode
)[scancode
];
595 static int input_default_getkeycode(struct input_dev
*dev
,
596 unsigned int scancode
,
597 unsigned int *keycode
)
599 if (!dev
->keycodesize
)
602 if (scancode
>= dev
->keycodemax
)
605 *keycode
= input_fetch_keycode(dev
, scancode
);
610 static int input_default_setkeycode(struct input_dev
*dev
,
611 unsigned int scancode
,
612 unsigned int keycode
)
617 if (scancode
>= dev
->keycodemax
)
620 if (!dev
->keycodesize
)
623 if (dev
->keycodesize
< sizeof(keycode
) && (keycode
>> (dev
->keycodesize
* 8)))
626 switch (dev
->keycodesize
) {
628 u8
*k
= (u8
*)dev
->keycode
;
629 old_keycode
= k
[scancode
];
630 k
[scancode
] = keycode
;
634 u16
*k
= (u16
*)dev
->keycode
;
635 old_keycode
= k
[scancode
];
636 k
[scancode
] = keycode
;
640 u32
*k
= (u32
*)dev
->keycode
;
641 old_keycode
= k
[scancode
];
642 k
[scancode
] = keycode
;
647 __clear_bit(old_keycode
, dev
->keybit
);
648 __set_bit(keycode
, dev
->keybit
);
650 for (i
= 0; i
< dev
->keycodemax
; i
++) {
651 if (input_fetch_keycode(dev
, i
) == old_keycode
) {
652 __set_bit(old_keycode
, dev
->keybit
);
653 break; /* Setting the bit twice is useless, so break */
661 * input_get_keycode - retrieve keycode currently mapped to a given scancode
662 * @dev: input device which keymap is being queried
663 * @scancode: scancode (or its equivalent for device in question) for which
667 * This function should be called by anyone interested in retrieving current
668 * keymap. Presently keyboard and evdev handlers use it.
670 int input_get_keycode(struct input_dev
*dev
,
671 unsigned int scancode
, unsigned int *keycode
)
676 spin_lock_irqsave(&dev
->event_lock
, flags
);
677 retval
= dev
->getkeycode(dev
, scancode
, keycode
);
678 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
682 EXPORT_SYMBOL(input_get_keycode
);
685 * input_get_keycode - assign new keycode to a given scancode
686 * @dev: input device which keymap is being updated
687 * @scancode: scancode (or its equivalent for device in question)
688 * @keycode: new keycode to be assigned to the scancode
690 * This function should be called by anyone needing to update current
691 * keymap. Presently keyboard and evdev handlers use it.
693 int input_set_keycode(struct input_dev
*dev
,
694 unsigned int scancode
, unsigned int keycode
)
697 unsigned int old_keycode
;
700 if (keycode
> KEY_MAX
)
703 spin_lock_irqsave(&dev
->event_lock
, flags
);
705 retval
= dev
->getkeycode(dev
, scancode
, &old_keycode
);
709 retval
= dev
->setkeycode(dev
, scancode
, keycode
);
713 /* Make sure KEY_RESERVED did not get enabled. */
714 __clear_bit(KEY_RESERVED
, dev
->keybit
);
717 * Simulate keyup event if keycode is not present
718 * in the keymap anymore
720 if (test_bit(EV_KEY
, dev
->evbit
) &&
721 !is_event_supported(old_keycode
, dev
->keybit
, KEY_MAX
) &&
722 __test_and_clear_bit(old_keycode
, dev
->key
)) {
724 input_pass_event(dev
, EV_KEY
, old_keycode
, 0);
726 input_pass_event(dev
, EV_SYN
, SYN_REPORT
, 1);
730 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
734 EXPORT_SYMBOL(input_set_keycode
);
736 #define MATCH_BIT(bit, max) \
737 for (i = 0; i < BITS_TO_LONGS(max); i++) \
738 if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
740 if (i != BITS_TO_LONGS(max)) \
743 static const struct input_device_id
*input_match_device(struct input_handler
*handler
,
744 struct input_dev
*dev
)
746 const struct input_device_id
*id
;
749 for (id
= handler
->id_table
; id
->flags
|| id
->driver_info
; id
++) {
751 if (id
->flags
& INPUT_DEVICE_ID_MATCH_BUS
)
752 if (id
->bustype
!= dev
->id
.bustype
)
755 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VENDOR
)
756 if (id
->vendor
!= dev
->id
.vendor
)
759 if (id
->flags
& INPUT_DEVICE_ID_MATCH_PRODUCT
)
760 if (id
->product
!= dev
->id
.product
)
763 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VERSION
)
764 if (id
->version
!= dev
->id
.version
)
767 MATCH_BIT(evbit
, EV_MAX
);
768 MATCH_BIT(keybit
, KEY_MAX
);
769 MATCH_BIT(relbit
, REL_MAX
);
770 MATCH_BIT(absbit
, ABS_MAX
);
771 MATCH_BIT(mscbit
, MSC_MAX
);
772 MATCH_BIT(ledbit
, LED_MAX
);
773 MATCH_BIT(sndbit
, SND_MAX
);
774 MATCH_BIT(ffbit
, FF_MAX
);
775 MATCH_BIT(swbit
, SW_MAX
);
777 if (!handler
->match
|| handler
->match(handler
, dev
))
784 static int input_attach_handler(struct input_dev
*dev
, struct input_handler
*handler
)
786 const struct input_device_id
*id
;
789 id
= input_match_device(handler
, dev
);
793 error
= handler
->connect(handler
, dev
, id
);
794 if (error
&& error
!= -ENODEV
)
796 "input: failed to attach handler %s to device %s, "
798 handler
->name
, kobject_name(&dev
->dev
.kobj
), error
);
805 static int input_bits_to_string(char *buf
, int buf_size
,
806 unsigned long bits
, bool skip_empty
)
810 if (INPUT_COMPAT_TEST
) {
811 u32 dword
= bits
>> 32;
812 if (dword
|| !skip_empty
)
813 len
+= snprintf(buf
, buf_size
, "%x ", dword
);
815 dword
= bits
& 0xffffffffUL
;
816 if (dword
|| !skip_empty
|| len
)
817 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0),
820 if (bits
|| !skip_empty
)
821 len
+= snprintf(buf
, buf_size
, "%lx", bits
);
827 #else /* !CONFIG_COMPAT */
829 static int input_bits_to_string(char *buf
, int buf_size
,
830 unsigned long bits
, bool skip_empty
)
832 return bits
|| !skip_empty
?
833 snprintf(buf
, buf_size
, "%lx", bits
) : 0;
838 #ifdef CONFIG_PROC_FS
840 static struct proc_dir_entry
*proc_bus_input_dir
;
841 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait
);
842 static int input_devices_state
;
844 static inline void input_wakeup_procfs_readers(void)
846 input_devices_state
++;
847 wake_up(&input_devices_poll_wait
);
850 static unsigned int input_proc_devices_poll(struct file
*file
, poll_table
*wait
)
852 poll_wait(file
, &input_devices_poll_wait
, wait
);
853 if (file
->f_version
!= input_devices_state
) {
854 file
->f_version
= input_devices_state
;
855 return POLLIN
| POLLRDNORM
;
861 union input_seq_state
{
869 static void *input_devices_seq_start(struct seq_file
*seq
, loff_t
*pos
)
871 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
874 /* We need to fit into seq->private pointer */
875 BUILD_BUG_ON(sizeof(union input_seq_state
) != sizeof(seq
->private));
877 error
= mutex_lock_interruptible(&input_mutex
);
879 state
->mutex_acquired
= false;
880 return ERR_PTR(error
);
883 state
->mutex_acquired
= true;
885 return seq_list_start(&input_dev_list
, *pos
);
888 static void *input_devices_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
890 return seq_list_next(v
, &input_dev_list
, pos
);
893 static void input_seq_stop(struct seq_file
*seq
, void *v
)
895 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
897 if (state
->mutex_acquired
)
898 mutex_unlock(&input_mutex
);
901 static void input_seq_print_bitmap(struct seq_file
*seq
, const char *name
,
902 unsigned long *bitmap
, int max
)
905 bool skip_empty
= true;
908 seq_printf(seq
, "B: %s=", name
);
910 for (i
= BITS_TO_LONGS(max
) - 1; i
>= 0; i
--) {
911 if (input_bits_to_string(buf
, sizeof(buf
),
912 bitmap
[i
], skip_empty
)) {
914 seq_printf(seq
, "%s%s", buf
, i
> 0 ? " " : "");
919 * If no output was produced print a single 0.
927 static int input_devices_seq_show(struct seq_file
*seq
, void *v
)
929 struct input_dev
*dev
= container_of(v
, struct input_dev
, node
);
930 const char *path
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
931 struct input_handle
*handle
;
933 seq_printf(seq
, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
934 dev
->id
.bustype
, dev
->id
.vendor
, dev
->id
.product
, dev
->id
.version
);
936 seq_printf(seq
, "N: Name=\"%s\"\n", dev
->name
? dev
->name
: "");
937 seq_printf(seq
, "P: Phys=%s\n", dev
->phys
? dev
->phys
: "");
938 seq_printf(seq
, "S: Sysfs=%s\n", path
? path
: "");
939 seq_printf(seq
, "U: Uniq=%s\n", dev
->uniq
? dev
->uniq
: "");
940 seq_printf(seq
, "H: Handlers=");
942 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
943 seq_printf(seq
, "%s ", handle
->name
);
946 input_seq_print_bitmap(seq
, "EV", dev
->evbit
, EV_MAX
);
947 if (test_bit(EV_KEY
, dev
->evbit
))
948 input_seq_print_bitmap(seq
, "KEY", dev
->keybit
, KEY_MAX
);
949 if (test_bit(EV_REL
, dev
->evbit
))
950 input_seq_print_bitmap(seq
, "REL", dev
->relbit
, REL_MAX
);
951 if (test_bit(EV_ABS
, dev
->evbit
))
952 input_seq_print_bitmap(seq
, "ABS", dev
->absbit
, ABS_MAX
);
953 if (test_bit(EV_MSC
, dev
->evbit
))
954 input_seq_print_bitmap(seq
, "MSC", dev
->mscbit
, MSC_MAX
);
955 if (test_bit(EV_LED
, dev
->evbit
))
956 input_seq_print_bitmap(seq
, "LED", dev
->ledbit
, LED_MAX
);
957 if (test_bit(EV_SND
, dev
->evbit
))
958 input_seq_print_bitmap(seq
, "SND", dev
->sndbit
, SND_MAX
);
959 if (test_bit(EV_FF
, dev
->evbit
))
960 input_seq_print_bitmap(seq
, "FF", dev
->ffbit
, FF_MAX
);
961 if (test_bit(EV_SW
, dev
->evbit
))
962 input_seq_print_bitmap(seq
, "SW", dev
->swbit
, SW_MAX
);
970 static const struct seq_operations input_devices_seq_ops
= {
971 .start
= input_devices_seq_start
,
972 .next
= input_devices_seq_next
,
973 .stop
= input_seq_stop
,
974 .show
= input_devices_seq_show
,
977 static int input_proc_devices_open(struct inode
*inode
, struct file
*file
)
979 return seq_open(file
, &input_devices_seq_ops
);
982 static const struct file_operations input_devices_fileops
= {
983 .owner
= THIS_MODULE
,
984 .open
= input_proc_devices_open
,
985 .poll
= input_proc_devices_poll
,
988 .release
= seq_release
,
991 static void *input_handlers_seq_start(struct seq_file
*seq
, loff_t
*pos
)
993 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
996 /* We need to fit into seq->private pointer */
997 BUILD_BUG_ON(sizeof(union input_seq_state
) != sizeof(seq
->private));
999 error
= mutex_lock_interruptible(&input_mutex
);
1001 state
->mutex_acquired
= false;
1002 return ERR_PTR(error
);
1005 state
->mutex_acquired
= true;
1008 return seq_list_start(&input_handler_list
, *pos
);
1011 static void *input_handlers_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1013 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
1015 state
->pos
= *pos
+ 1;
1016 return seq_list_next(v
, &input_handler_list
, pos
);
1019 static int input_handlers_seq_show(struct seq_file
*seq
, void *v
)
1021 struct input_handler
*handler
= container_of(v
, struct input_handler
, node
);
1022 union input_seq_state
*state
= (union input_seq_state
*)&seq
->private;
1024 seq_printf(seq
, "N: Number=%u Name=%s", state
->pos
, handler
->name
);
1025 if (handler
->filter
)
1026 seq_puts(seq
, " (filter)");
1028 seq_printf(seq
, " Minor=%d", handler
->minor
);
1029 seq_putc(seq
, '\n');
1034 static const struct seq_operations input_handlers_seq_ops
= {
1035 .start
= input_handlers_seq_start
,
1036 .next
= input_handlers_seq_next
,
1037 .stop
= input_seq_stop
,
1038 .show
= input_handlers_seq_show
,
1041 static int input_proc_handlers_open(struct inode
*inode
, struct file
*file
)
1043 return seq_open(file
, &input_handlers_seq_ops
);
1046 static const struct file_operations input_handlers_fileops
= {
1047 .owner
= THIS_MODULE
,
1048 .open
= input_proc_handlers_open
,
1050 .llseek
= seq_lseek
,
1051 .release
= seq_release
,
1054 static int __init
input_proc_init(void)
1056 struct proc_dir_entry
*entry
;
1058 proc_bus_input_dir
= proc_mkdir("bus/input", NULL
);
1059 if (!proc_bus_input_dir
)
1062 entry
= proc_create("devices", 0, proc_bus_input_dir
,
1063 &input_devices_fileops
);
1067 entry
= proc_create("handlers", 0, proc_bus_input_dir
,
1068 &input_handlers_fileops
);
1074 fail2
: remove_proc_entry("devices", proc_bus_input_dir
);
1075 fail1
: remove_proc_entry("bus/input", NULL
);
1079 static void input_proc_exit(void)
1081 remove_proc_entry("devices", proc_bus_input_dir
);
1082 remove_proc_entry("handlers", proc_bus_input_dir
);
1083 remove_proc_entry("bus/input", NULL
);
1086 #else /* !CONFIG_PROC_FS */
1087 static inline void input_wakeup_procfs_readers(void) { }
1088 static inline int input_proc_init(void) { return 0; }
1089 static inline void input_proc_exit(void) { }
1092 #define INPUT_DEV_STRING_ATTR_SHOW(name) \
1093 static ssize_t input_dev_show_##name(struct device *dev, \
1094 struct device_attribute *attr, \
1097 struct input_dev *input_dev = to_input_dev(dev); \
1099 return scnprintf(buf, PAGE_SIZE, "%s\n", \
1100 input_dev->name ? input_dev->name : ""); \
1102 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1104 INPUT_DEV_STRING_ATTR_SHOW(name
);
1105 INPUT_DEV_STRING_ATTR_SHOW(phys
);
1106 INPUT_DEV_STRING_ATTR_SHOW(uniq
);
1108 static int input_print_modalias_bits(char *buf
, int size
,
1109 char name
, unsigned long *bm
,
1110 unsigned int min_bit
, unsigned int max_bit
)
1114 len
+= snprintf(buf
, max(size
, 0), "%c", name
);
1115 for (i
= min_bit
; i
< max_bit
; i
++)
1116 if (bm
[BIT_WORD(i
)] & BIT_MASK(i
))
1117 len
+= snprintf(buf
+ len
, max(size
- len
, 0), "%X,", i
);
1121 static int input_print_modalias(char *buf
, int size
, struct input_dev
*id
,
1126 len
= snprintf(buf
, max(size
, 0),
1127 "input:b%04Xv%04Xp%04Xe%04X-",
1128 id
->id
.bustype
, id
->id
.vendor
,
1129 id
->id
.product
, id
->id
.version
);
1131 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1132 'e', id
->evbit
, 0, EV_MAX
);
1133 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1134 'k', id
->keybit
, KEY_MIN_INTERESTING
, KEY_MAX
);
1135 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1136 'r', id
->relbit
, 0, REL_MAX
);
1137 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1138 'a', id
->absbit
, 0, ABS_MAX
);
1139 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1140 'm', id
->mscbit
, 0, MSC_MAX
);
1141 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1142 'l', id
->ledbit
, 0, LED_MAX
);
1143 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1144 's', id
->sndbit
, 0, SND_MAX
);
1145 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1146 'f', id
->ffbit
, 0, FF_MAX
);
1147 len
+= input_print_modalias_bits(buf
+ len
, size
- len
,
1148 'w', id
->swbit
, 0, SW_MAX
);
1151 len
+= snprintf(buf
+ len
, max(size
- len
, 0), "\n");
1156 static ssize_t
input_dev_show_modalias(struct device
*dev
,
1157 struct device_attribute
*attr
,
1160 struct input_dev
*id
= to_input_dev(dev
);
1163 len
= input_print_modalias(buf
, PAGE_SIZE
, id
, 1);
1165 return min_t(int, len
, PAGE_SIZE
);
1167 static DEVICE_ATTR(modalias
, S_IRUGO
, input_dev_show_modalias
, NULL
);
1169 static struct attribute
*input_dev_attrs
[] = {
1170 &dev_attr_name
.attr
,
1171 &dev_attr_phys
.attr
,
1172 &dev_attr_uniq
.attr
,
1173 &dev_attr_modalias
.attr
,
1177 static struct attribute_group input_dev_attr_group
= {
1178 .attrs
= input_dev_attrs
,
1181 #define INPUT_DEV_ID_ATTR(name) \
1182 static ssize_t input_dev_show_id_##name(struct device *dev, \
1183 struct device_attribute *attr, \
1186 struct input_dev *input_dev = to_input_dev(dev); \
1187 return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1189 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1191 INPUT_DEV_ID_ATTR(bustype
);
1192 INPUT_DEV_ID_ATTR(vendor
);
1193 INPUT_DEV_ID_ATTR(product
);
1194 INPUT_DEV_ID_ATTR(version
);
1196 static struct attribute
*input_dev_id_attrs
[] = {
1197 &dev_attr_bustype
.attr
,
1198 &dev_attr_vendor
.attr
,
1199 &dev_attr_product
.attr
,
1200 &dev_attr_version
.attr
,
1204 static struct attribute_group input_dev_id_attr_group
= {
1206 .attrs
= input_dev_id_attrs
,
1209 static int input_print_bitmap(char *buf
, int buf_size
, unsigned long *bitmap
,
1210 int max
, int add_cr
)
1214 bool skip_empty
= true;
1216 for (i
= BITS_TO_LONGS(max
) - 1; i
>= 0; i
--) {
1217 len
+= input_bits_to_string(buf
+ len
, max(buf_size
- len
, 0),
1218 bitmap
[i
], skip_empty
);
1222 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0), " ");
1227 * If no output was produced print a single 0.
1230 len
= snprintf(buf
, buf_size
, "%d", 0);
1233 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0), "\n");
1238 #define INPUT_DEV_CAP_ATTR(ev, bm) \
1239 static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1240 struct device_attribute *attr, \
1243 struct input_dev *input_dev = to_input_dev(dev); \
1244 int len = input_print_bitmap(buf, PAGE_SIZE, \
1245 input_dev->bm##bit, ev##_MAX, \
1247 return min_t(int, len, PAGE_SIZE); \
1249 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1251 INPUT_DEV_CAP_ATTR(EV
, ev
);
1252 INPUT_DEV_CAP_ATTR(KEY
, key
);
1253 INPUT_DEV_CAP_ATTR(REL
, rel
);
1254 INPUT_DEV_CAP_ATTR(ABS
, abs
);
1255 INPUT_DEV_CAP_ATTR(MSC
, msc
);
1256 INPUT_DEV_CAP_ATTR(LED
, led
);
1257 INPUT_DEV_CAP_ATTR(SND
, snd
);
1258 INPUT_DEV_CAP_ATTR(FF
, ff
);
1259 INPUT_DEV_CAP_ATTR(SW
, sw
);
1261 static struct attribute
*input_dev_caps_attrs
[] = {
1274 static struct attribute_group input_dev_caps_attr_group
= {
1275 .name
= "capabilities",
1276 .attrs
= input_dev_caps_attrs
,
1279 static const struct attribute_group
*input_dev_attr_groups
[] = {
1280 &input_dev_attr_group
,
1281 &input_dev_id_attr_group
,
1282 &input_dev_caps_attr_group
,
1286 static void input_dev_release(struct device
*device
)
1288 struct input_dev
*dev
= to_input_dev(device
);
1290 input_ff_destroy(dev
);
1293 module_put(THIS_MODULE
);
1297 * Input uevent interface - loading event handlers based on
1300 static int input_add_uevent_bm_var(struct kobj_uevent_env
*env
,
1301 const char *name
, unsigned long *bitmap
, int max
)
1305 if (add_uevent_var(env
, "%s=", name
))
1308 len
= input_print_bitmap(&env
->buf
[env
->buflen
- 1],
1309 sizeof(env
->buf
) - env
->buflen
,
1310 bitmap
, max
, false);
1311 if (len
>= (sizeof(env
->buf
) - env
->buflen
))
1318 static int input_add_uevent_modalias_var(struct kobj_uevent_env
*env
,
1319 struct input_dev
*dev
)
1323 if (add_uevent_var(env
, "MODALIAS="))
1326 len
= input_print_modalias(&env
->buf
[env
->buflen
- 1],
1327 sizeof(env
->buf
) - env
->buflen
,
1329 if (len
>= (sizeof(env
->buf
) - env
->buflen
))
1336 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
1338 int err = add_uevent_var(env, fmt, val); \
1343 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
1345 int err = input_add_uevent_bm_var(env, name, bm, max); \
1350 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1352 int err = input_add_uevent_modalias_var(env, dev); \
1357 static int input_dev_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
1359 struct input_dev
*dev
= to_input_dev(device
);
1361 INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1362 dev
->id
.bustype
, dev
->id
.vendor
,
1363 dev
->id
.product
, dev
->id
.version
);
1365 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev
->name
);
1367 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev
->phys
);
1369 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev
->uniq
);
1371 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev
->evbit
, EV_MAX
);
1372 if (test_bit(EV_KEY
, dev
->evbit
))
1373 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev
->keybit
, KEY_MAX
);
1374 if (test_bit(EV_REL
, dev
->evbit
))
1375 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev
->relbit
, REL_MAX
);
1376 if (test_bit(EV_ABS
, dev
->evbit
))
1377 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev
->absbit
, ABS_MAX
);
1378 if (test_bit(EV_MSC
, dev
->evbit
))
1379 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev
->mscbit
, MSC_MAX
);
1380 if (test_bit(EV_LED
, dev
->evbit
))
1381 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev
->ledbit
, LED_MAX
);
1382 if (test_bit(EV_SND
, dev
->evbit
))
1383 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev
->sndbit
, SND_MAX
);
1384 if (test_bit(EV_FF
, dev
->evbit
))
1385 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev
->ffbit
, FF_MAX
);
1386 if (test_bit(EV_SW
, dev
->evbit
))
1387 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev
->swbit
, SW_MAX
);
1389 INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev
);
1394 #define INPUT_DO_TOGGLE(dev, type, bits, on) \
1399 if (!test_bit(EV_##type, dev->evbit)) \
1402 for (i = 0; i < type##_MAX; i++) { \
1403 if (!test_bit(i, dev->bits##bit)) \
1406 active = test_bit(i, dev->bits); \
1407 if (!active && !on) \
1410 dev->event(dev, EV_##type, i, on ? active : 0); \
1415 static void input_dev_reset(struct input_dev
*dev
, bool activate
)
1420 INPUT_DO_TOGGLE(dev
, LED
, led
, activate
);
1421 INPUT_DO_TOGGLE(dev
, SND
, snd
, activate
);
1423 if (activate
&& test_bit(EV_REP
, dev
->evbit
)) {
1424 dev
->event(dev
, EV_REP
, REP_PERIOD
, dev
->rep
[REP_PERIOD
]);
1425 dev
->event(dev
, EV_REP
, REP_DELAY
, dev
->rep
[REP_DELAY
]);
1429 static int input_dev_suspend(struct device
*dev
)
1431 struct input_dev
*input_dev
= to_input_dev(dev
);
1433 mutex_lock(&input_dev
->mutex
);
1434 input_dev_reset(input_dev
, false);
1435 mutex_unlock(&input_dev
->mutex
);
1440 static int input_dev_resume(struct device
*dev
)
1442 struct input_dev
*input_dev
= to_input_dev(dev
);
1444 mutex_lock(&input_dev
->mutex
);
1445 input_dev_reset(input_dev
, true);
1448 * Keys that have been pressed at suspend time are unlikely
1449 * to be still pressed when we resume.
1451 spin_lock_irq(&input_dev
->event_lock
);
1452 input_dev_release_keys(input_dev
);
1453 spin_unlock_irq(&input_dev
->event_lock
);
1455 mutex_unlock(&input_dev
->mutex
);
1460 static const struct dev_pm_ops input_dev_pm_ops
= {
1461 .suspend
= input_dev_suspend
,
1462 .resume
= input_dev_resume
,
1463 .poweroff
= input_dev_suspend
,
1464 .restore
= input_dev_resume
,
1466 #endif /* CONFIG_PM */
1468 static struct device_type input_dev_type
= {
1469 .groups
= input_dev_attr_groups
,
1470 .release
= input_dev_release
,
1471 .uevent
= input_dev_uevent
,
1473 .pm
= &input_dev_pm_ops
,
1477 static char *input_devnode(struct device
*dev
, mode_t
*mode
)
1479 return kasprintf(GFP_KERNEL
, "input/%s", dev_name(dev
));
1482 struct class input_class
= {
1484 .devnode
= input_devnode
,
1486 EXPORT_SYMBOL_GPL(input_class
);
1489 * input_allocate_device - allocate memory for new input device
1491 * Returns prepared struct input_dev or NULL.
1493 * NOTE: Use input_free_device() to free devices that have not been
1494 * registered; input_unregister_device() should be used for already
1495 * registered devices.
1497 struct input_dev
*input_allocate_device(void)
1499 struct input_dev
*dev
;
1501 dev
= kzalloc(sizeof(struct input_dev
), GFP_KERNEL
);
1503 dev
->dev
.type
= &input_dev_type
;
1504 dev
->dev
.class = &input_class
;
1505 device_initialize(&dev
->dev
);
1506 mutex_init(&dev
->mutex
);
1507 spin_lock_init(&dev
->event_lock
);
1508 INIT_LIST_HEAD(&dev
->h_list
);
1509 INIT_LIST_HEAD(&dev
->node
);
1511 __module_get(THIS_MODULE
);
1516 EXPORT_SYMBOL(input_allocate_device
);
1519 * input_free_device - free memory occupied by input_dev structure
1520 * @dev: input device to free
1522 * This function should only be used if input_register_device()
1523 * was not called yet or if it failed. Once device was registered
1524 * use input_unregister_device() and memory will be freed once last
1525 * reference to the device is dropped.
1527 * Device should be allocated by input_allocate_device().
1529 * NOTE: If there are references to the input device then memory
1530 * will not be freed until last reference is dropped.
1532 void input_free_device(struct input_dev
*dev
)
1535 input_put_device(dev
);
1537 EXPORT_SYMBOL(input_free_device
);
1540 * input_set_capability - mark device as capable of a certain event
1541 * @dev: device that is capable of emitting or accepting event
1542 * @type: type of the event (EV_KEY, EV_REL, etc...)
1545 * In addition to setting up corresponding bit in appropriate capability
1546 * bitmap the function also adjusts dev->evbit.
1548 void input_set_capability(struct input_dev
*dev
, unsigned int type
, unsigned int code
)
1552 __set_bit(code
, dev
->keybit
);
1556 __set_bit(code
, dev
->relbit
);
1560 __set_bit(code
, dev
->absbit
);
1564 __set_bit(code
, dev
->mscbit
);
1568 __set_bit(code
, dev
->swbit
);
1572 __set_bit(code
, dev
->ledbit
);
1576 __set_bit(code
, dev
->sndbit
);
1580 __set_bit(code
, dev
->ffbit
);
1589 "input_set_capability: unknown type %u (code %u)\n",
1595 __set_bit(type
, dev
->evbit
);
1597 EXPORT_SYMBOL(input_set_capability
);
1599 #define INPUT_CLEANSE_BITMASK(dev, type, bits) \
1601 if (!test_bit(EV_##type, dev->evbit)) \
1602 memset(dev->bits##bit, 0, \
1603 sizeof(dev->bits##bit)); \
1606 static void input_cleanse_bitmasks(struct input_dev
*dev
)
1608 INPUT_CLEANSE_BITMASK(dev
, KEY
, key
);
1609 INPUT_CLEANSE_BITMASK(dev
, REL
, rel
);
1610 INPUT_CLEANSE_BITMASK(dev
, ABS
, abs
);
1611 INPUT_CLEANSE_BITMASK(dev
, MSC
, msc
);
1612 INPUT_CLEANSE_BITMASK(dev
, LED
, led
);
1613 INPUT_CLEANSE_BITMASK(dev
, SND
, snd
);
1614 INPUT_CLEANSE_BITMASK(dev
, FF
, ff
);
1615 INPUT_CLEANSE_BITMASK(dev
, SW
, sw
);
1619 * input_register_device - register device with input core
1620 * @dev: device to be registered
1622 * This function registers device with input core. The device must be
1623 * allocated with input_allocate_device() and all it's capabilities
1624 * set up before registering.
1625 * If function fails the device must be freed with input_free_device().
1626 * Once device has been successfully registered it can be unregistered
1627 * with input_unregister_device(); input_free_device() should not be
1628 * called in this case.
1630 int input_register_device(struct input_dev
*dev
)
1632 static atomic_t input_no
= ATOMIC_INIT(0);
1633 struct input_handler
*handler
;
1637 /* Every input device generates EV_SYN/SYN_REPORT events. */
1638 __set_bit(EV_SYN
, dev
->evbit
);
1640 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
1641 __clear_bit(KEY_RESERVED
, dev
->keybit
);
1643 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
1644 input_cleanse_bitmasks(dev
);
1647 * If delay and period are pre-set by the driver, then autorepeating
1648 * is handled by the driver itself and we don't do it in input.c.
1650 init_timer(&dev
->timer
);
1651 if (!dev
->rep
[REP_DELAY
] && !dev
->rep
[REP_PERIOD
]) {
1652 dev
->timer
.data
= (long) dev
;
1653 dev
->timer
.function
= input_repeat_key
;
1654 dev
->rep
[REP_DELAY
] = 250;
1655 dev
->rep
[REP_PERIOD
] = 33;
1658 if (!dev
->getkeycode
)
1659 dev
->getkeycode
= input_default_getkeycode
;
1661 if (!dev
->setkeycode
)
1662 dev
->setkeycode
= input_default_setkeycode
;
1664 dev_set_name(&dev
->dev
, "input%ld",
1665 (unsigned long) atomic_inc_return(&input_no
) - 1);
1667 error
= device_add(&dev
->dev
);
1671 path
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
1672 printk(KERN_INFO
"input: %s as %s\n",
1673 dev
->name
? dev
->name
: "Unspecified device", path
? path
: "N/A");
1676 error
= mutex_lock_interruptible(&input_mutex
);
1678 device_del(&dev
->dev
);
1682 list_add_tail(&dev
->node
, &input_dev_list
);
1684 list_for_each_entry(handler
, &input_handler_list
, node
)
1685 input_attach_handler(dev
, handler
);
1687 input_wakeup_procfs_readers();
1689 mutex_unlock(&input_mutex
);
1693 EXPORT_SYMBOL(input_register_device
);
1696 * input_unregister_device - unregister previously registered device
1697 * @dev: device to be unregistered
1699 * This function unregisters an input device. Once device is unregistered
1700 * the caller should not try to access it as it may get freed at any moment.
1702 void input_unregister_device(struct input_dev
*dev
)
1704 struct input_handle
*handle
, *next
;
1706 input_disconnect_device(dev
);
1708 mutex_lock(&input_mutex
);
1710 list_for_each_entry_safe(handle
, next
, &dev
->h_list
, d_node
)
1711 handle
->handler
->disconnect(handle
);
1712 WARN_ON(!list_empty(&dev
->h_list
));
1714 del_timer_sync(&dev
->timer
);
1715 list_del_init(&dev
->node
);
1717 input_wakeup_procfs_readers();
1719 mutex_unlock(&input_mutex
);
1721 device_unregister(&dev
->dev
);
1723 EXPORT_SYMBOL(input_unregister_device
);
1726 * input_register_handler - register a new input handler
1727 * @handler: handler to be registered
1729 * This function registers a new input handler (interface) for input
1730 * devices in the system and attaches it to all input devices that
1731 * are compatible with the handler.
1733 int input_register_handler(struct input_handler
*handler
)
1735 struct input_dev
*dev
;
1738 retval
= mutex_lock_interruptible(&input_mutex
);
1742 INIT_LIST_HEAD(&handler
->h_list
);
1744 if (handler
->fops
!= NULL
) {
1745 if (input_table
[handler
->minor
>> 5]) {
1749 input_table
[handler
->minor
>> 5] = handler
;
1752 list_add_tail(&handler
->node
, &input_handler_list
);
1754 list_for_each_entry(dev
, &input_dev_list
, node
)
1755 input_attach_handler(dev
, handler
);
1757 input_wakeup_procfs_readers();
1760 mutex_unlock(&input_mutex
);
1763 EXPORT_SYMBOL(input_register_handler
);
1766 * input_unregister_handler - unregisters an input handler
1767 * @handler: handler to be unregistered
1769 * This function disconnects a handler from its input devices and
1770 * removes it from lists of known handlers.
1772 void input_unregister_handler(struct input_handler
*handler
)
1774 struct input_handle
*handle
, *next
;
1776 mutex_lock(&input_mutex
);
1778 list_for_each_entry_safe(handle
, next
, &handler
->h_list
, h_node
)
1779 handler
->disconnect(handle
);
1780 WARN_ON(!list_empty(&handler
->h_list
));
1782 list_del_init(&handler
->node
);
1784 if (handler
->fops
!= NULL
)
1785 input_table
[handler
->minor
>> 5] = NULL
;
1787 input_wakeup_procfs_readers();
1789 mutex_unlock(&input_mutex
);
1791 EXPORT_SYMBOL(input_unregister_handler
);
1794 * input_handler_for_each_handle - handle iterator
1795 * @handler: input handler to iterate
1796 * @data: data for the callback
1797 * @fn: function to be called for each handle
1799 * Iterate over @bus's list of devices, and call @fn for each, passing
1800 * it @data and stop when @fn returns a non-zero value. The function is
1801 * using RCU to traverse the list and therefore may be usind in atonic
1802 * contexts. The @fn callback is invoked from RCU critical section and
1803 * thus must not sleep.
1805 int input_handler_for_each_handle(struct input_handler
*handler
, void *data
,
1806 int (*fn
)(struct input_handle
*, void *))
1808 struct input_handle
*handle
;
1813 list_for_each_entry_rcu(handle
, &handler
->h_list
, h_node
) {
1814 retval
= fn(handle
, data
);
1823 EXPORT_SYMBOL(input_handler_for_each_handle
);
1826 * input_register_handle - register a new input handle
1827 * @handle: handle to register
1829 * This function puts a new input handle onto device's
1830 * and handler's lists so that events can flow through
1831 * it once it is opened using input_open_device().
1833 * This function is supposed to be called from handler's
1836 int input_register_handle(struct input_handle
*handle
)
1838 struct input_handler
*handler
= handle
->handler
;
1839 struct input_dev
*dev
= handle
->dev
;
1843 * We take dev->mutex here to prevent race with
1844 * input_release_device().
1846 error
= mutex_lock_interruptible(&dev
->mutex
);
1851 * Filters go to the head of the list, normal handlers
1854 if (handler
->filter
)
1855 list_add_rcu(&handle
->d_node
, &dev
->h_list
);
1857 list_add_tail_rcu(&handle
->d_node
, &dev
->h_list
);
1859 mutex_unlock(&dev
->mutex
);
1862 * Since we are supposed to be called from ->connect()
1863 * which is mutually exclusive with ->disconnect()
1864 * we can't be racing with input_unregister_handle()
1865 * and so separate lock is not needed here.
1867 list_add_tail_rcu(&handle
->h_node
, &handler
->h_list
);
1870 handler
->start(handle
);
1874 EXPORT_SYMBOL(input_register_handle
);
1877 * input_unregister_handle - unregister an input handle
1878 * @handle: handle to unregister
1880 * This function removes input handle from device's
1881 * and handler's lists.
1883 * This function is supposed to be called from handler's
1884 * disconnect() method.
1886 void input_unregister_handle(struct input_handle
*handle
)
1888 struct input_dev
*dev
= handle
->dev
;
1890 list_del_rcu(&handle
->h_node
);
1893 * Take dev->mutex to prevent race with input_release_device().
1895 mutex_lock(&dev
->mutex
);
1896 list_del_rcu(&handle
->d_node
);
1897 mutex_unlock(&dev
->mutex
);
1901 EXPORT_SYMBOL(input_unregister_handle
);
1903 static int input_open_file(struct inode
*inode
, struct file
*file
)
1905 struct input_handler
*handler
;
1906 const struct file_operations
*old_fops
, *new_fops
= NULL
;
1909 err
= mutex_lock_interruptible(&input_mutex
);
1913 /* No load-on-demand here? */
1914 handler
= input_table
[iminor(inode
) >> 5];
1916 new_fops
= fops_get(handler
->fops
);
1918 mutex_unlock(&input_mutex
);
1921 * That's _really_ odd. Usually NULL ->open means "nothing special",
1922 * not "no device". Oh, well...
1924 if (!new_fops
|| !new_fops
->open
) {
1930 old_fops
= file
->f_op
;
1931 file
->f_op
= new_fops
;
1933 err
= new_fops
->open(inode
, file
);
1935 fops_put(file
->f_op
);
1936 file
->f_op
= fops_get(old_fops
);
1943 static const struct file_operations input_fops
= {
1944 .owner
= THIS_MODULE
,
1945 .open
= input_open_file
,
1948 static void __init
input_init_abs_bypass(void)
1950 const unsigned int *p
;
1952 for (p
= input_abs_bypass_init_data
; *p
; p
++)
1953 input_abs_bypass
[BIT_WORD(*p
)] |= BIT_MASK(*p
);
1956 static int __init
input_init(void)
1960 input_init_abs_bypass();
1962 err
= class_register(&input_class
);
1964 printk(KERN_ERR
"input: unable to register input_dev class\n");
1968 err
= input_proc_init();
1972 err
= register_chrdev(INPUT_MAJOR
, "input", &input_fops
);
1974 printk(KERN_ERR
"input: unable to register char major %d", INPUT_MAJOR
);
1980 fail2
: input_proc_exit();
1981 fail1
: class_unregister(&input_class
);
1985 static void __exit
input_exit(void)
1988 unregister_chrdev(INPUT_MAJOR
, "input");
1989 class_unregister(&input_class
);
1992 subsys_initcall(input_init
);
1993 module_exit(input_exit
);