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/sched.h>
15 #include <linux/smp_lock.h>
16 #include <linux/input.h>
17 #include <linux/module.h>
18 #include <linux/random.h>
19 #include <linux/major.h>
20 #include <linux/proc_fs.h>
21 #include <linux/kobject_uevent.h>
22 #include <linux/interrupt.h>
23 #include <linux/poll.h>
24 #include <linux/device.h>
26 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
27 MODULE_DESCRIPTION("Input core");
28 MODULE_LICENSE("GPL");
30 EXPORT_SYMBOL(input_allocate_device
);
31 EXPORT_SYMBOL(input_register_device
);
32 EXPORT_SYMBOL(input_unregister_device
);
33 EXPORT_SYMBOL(input_register_handler
);
34 EXPORT_SYMBOL(input_unregister_handler
);
35 EXPORT_SYMBOL(input_grab_device
);
36 EXPORT_SYMBOL(input_release_device
);
37 EXPORT_SYMBOL(input_open_device
);
38 EXPORT_SYMBOL(input_close_device
);
39 EXPORT_SYMBOL(input_accept_process
);
40 EXPORT_SYMBOL(input_flush_device
);
41 EXPORT_SYMBOL(input_event
);
42 EXPORT_SYMBOL_GPL(input_class
);
44 #define INPUT_DEVICES 256
46 static LIST_HEAD(input_dev_list
);
47 static LIST_HEAD(input_handler_list
);
49 static struct input_handler
*input_table
[8];
51 void input_event(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int value
)
53 struct input_handle
*handle
;
55 if (type
> EV_MAX
|| !test_bit(type
, dev
->evbit
))
58 add_input_randomness(type
, code
, value
);
65 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
69 if (dev
->sync
) return;
77 if (code
> KEY_MAX
|| !test_bit(code
, dev
->keybit
) || !!test_bit(code
, dev
->key
) == value
)
83 change_bit(code
, dev
->key
);
85 if (test_bit(EV_REP
, dev
->evbit
) && dev
->rep
[REP_PERIOD
] && dev
->rep
[REP_DELAY
] && dev
->timer
.data
&& value
) {
86 dev
->repeat_key
= code
;
87 mod_timer(&dev
->timer
, jiffies
+ msecs_to_jiffies(dev
->rep
[REP_DELAY
]));
94 if (code
> SW_MAX
|| !test_bit(code
, dev
->swbit
) || !!test_bit(code
, dev
->sw
) == value
)
97 change_bit(code
, dev
->sw
);
103 if (code
> ABS_MAX
|| !test_bit(code
, dev
->absbit
))
106 if (dev
->absfuzz
[code
]) {
107 if ((value
> dev
->abs
[code
] - (dev
->absfuzz
[code
] >> 1)) &&
108 (value
< dev
->abs
[code
] + (dev
->absfuzz
[code
] >> 1)))
111 if ((value
> dev
->abs
[code
] - dev
->absfuzz
[code
]) &&
112 (value
< dev
->abs
[code
] + dev
->absfuzz
[code
]))
113 value
= (dev
->abs
[code
] * 3 + value
) >> 2;
115 if ((value
> dev
->abs
[code
] - (dev
->absfuzz
[code
] << 1)) &&
116 (value
< dev
->abs
[code
] + (dev
->absfuzz
[code
] << 1)))
117 value
= (dev
->abs
[code
] + value
) >> 1;
120 if (dev
->abs
[code
] == value
)
123 dev
->abs
[code
] = value
;
128 if (code
> REL_MAX
|| !test_bit(code
, dev
->relbit
) || (value
== 0))
135 if (code
> MSC_MAX
|| !test_bit(code
, dev
->mscbit
))
138 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
144 if (code
> LED_MAX
|| !test_bit(code
, dev
->ledbit
) || !!test_bit(code
, dev
->led
) == value
)
147 change_bit(code
, dev
->led
);
148 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
154 if (code
> SND_MAX
|| !test_bit(code
, dev
->sndbit
))
157 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
163 if (code
> REP_MAX
|| value
< 0 || dev
->rep
[code
] == value
) return;
165 dev
->rep
[code
] = value
;
166 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
171 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
179 dev
->grab
->handler
->event(dev
->grab
, type
, code
, value
);
181 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
183 handle
->handler
->event(handle
, type
, code
, value
);
186 static void input_repeat_key(unsigned long data
)
188 struct input_dev
*dev
= (void *) data
;
190 if (!test_bit(dev
->repeat_key
, dev
->key
))
193 input_event(dev
, EV_KEY
, dev
->repeat_key
, 2);
196 if (dev
->rep
[REP_PERIOD
])
197 mod_timer(&dev
->timer
, jiffies
+ msecs_to_jiffies(dev
->rep
[REP_PERIOD
]));
200 int input_accept_process(struct input_handle
*handle
, struct file
*file
)
202 if (handle
->dev
->accept
)
203 return handle
->dev
->accept(handle
->dev
, file
);
208 int input_grab_device(struct input_handle
*handle
)
210 if (handle
->dev
->grab
)
213 handle
->dev
->grab
= handle
;
217 void input_release_device(struct input_handle
*handle
)
219 if (handle
->dev
->grab
== handle
)
220 handle
->dev
->grab
= NULL
;
223 int input_open_device(struct input_handle
*handle
)
225 struct input_dev
*dev
= handle
->dev
;
228 err
= down_interruptible(&dev
->sem
);
234 if (!dev
->users
++ && dev
->open
)
235 err
= dev
->open(dev
);
245 int input_flush_device(struct input_handle
* handle
, struct file
* file
)
247 if (handle
->dev
->flush
)
248 return handle
->dev
->flush(handle
->dev
, file
);
253 void input_close_device(struct input_handle
*handle
)
255 struct input_dev
*dev
= handle
->dev
;
257 input_release_device(handle
);
261 if (!--dev
->users
&& dev
->close
)
268 static void input_link_handle(struct input_handle
*handle
)
270 list_add_tail(&handle
->d_node
, &handle
->dev
->h_list
);
271 list_add_tail(&handle
->h_node
, &handle
->handler
->h_list
);
274 #define MATCH_BIT(bit, max) \
275 for (i = 0; i < NBITS(max); i++) \
276 if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
278 if (i != NBITS(max)) \
281 static struct input_device_id
*input_match_device(struct input_device_id
*id
, struct input_dev
*dev
)
285 for (; id
->flags
|| id
->driver_info
; id
++) {
287 if (id
->flags
& INPUT_DEVICE_ID_MATCH_BUS
)
288 if (id
->id
.bustype
!= dev
->id
.bustype
)
291 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VENDOR
)
292 if (id
->id
.vendor
!= dev
->id
.vendor
)
295 if (id
->flags
& INPUT_DEVICE_ID_MATCH_PRODUCT
)
296 if (id
->id
.product
!= dev
->id
.product
)
299 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VERSION
)
300 if (id
->id
.version
!= dev
->id
.version
)
303 MATCH_BIT(evbit
, EV_MAX
);
304 MATCH_BIT(keybit
, KEY_MAX
);
305 MATCH_BIT(relbit
, REL_MAX
);
306 MATCH_BIT(absbit
, ABS_MAX
);
307 MATCH_BIT(mscbit
, MSC_MAX
);
308 MATCH_BIT(ledbit
, LED_MAX
);
309 MATCH_BIT(sndbit
, SND_MAX
);
310 MATCH_BIT(ffbit
, FF_MAX
);
311 MATCH_BIT(swbit
, SW_MAX
);
321 * Input hotplugging interface - loading event handlers based on
325 #ifdef CONFIG_HOTPLUG
328 * Input hotplugging invokes what /proc/sys/kernel/hotplug says
329 * (normally /sbin/hotplug) when input devices get added or removed.
331 * This invokes a user mode policy agent, typically helping to load driver
332 * or other modules, configure the device, and more. Drivers can provide
333 * a MODULE_DEVICE_TABLE to help with module loading subtasks.
337 #define SPRINTF_BIT_A(bit, name, max) \
339 envp[i++] = scratch; \
340 scratch += sprintf(scratch, name); \
341 for (j = NBITS(max) - 1; j >= 0; j--) \
342 if (dev->bit[j]) break; \
343 for (; j >= 0; j--) \
344 scratch += sprintf(scratch, "%lx ", dev->bit[j]); \
348 #define SPRINTF_BIT_A2(bit, name, max, ev) \
350 if (test_bit(ev, dev->evbit)) \
351 SPRINTF_BIT_A(bit, name, max); \
354 static void input_call_hotplug(char *verb
, struct input_dev
*dev
)
356 char *argv
[3], **envp
, *buf
, *scratch
;
359 if (!hotplug_path
[0]) {
360 printk(KERN_ERR
"input.c: calling hotplug without a hotplug agent defined\n");
363 if (in_interrupt()) {
364 printk(KERN_ERR
"input.c: calling hotplug from interrupt\n");
367 if (!current
->fs
->root
) {
368 printk(KERN_WARNING
"input.c: calling hotplug without valid filesystem\n");
371 if (!(envp
= (char **) kmalloc(20 * sizeof(char *), GFP_KERNEL
))) {
372 printk(KERN_ERR
"input.c: not enough memory allocating hotplug environment\n");
375 if (!(buf
= kmalloc(1024, GFP_KERNEL
))) {
377 printk(KERN_ERR
"input.c: not enough memory allocating hotplug environment\n");
381 argv
[0] = hotplug_path
;
385 envp
[i
++] = "HOME=/";
386 envp
[i
++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
391 scratch
+= sprintf(scratch
, "ACTION=%s", verb
) + 1;
394 scratch
+= sprintf(scratch
, "PRODUCT=%x/%x/%x/%x",
395 dev
->id
.bustype
, dev
->id
.vendor
, dev
->id
.product
, dev
->id
.version
) + 1;
399 scratch
+= sprintf(scratch
, "NAME=%s", dev
->name
) + 1;
404 scratch
+= sprintf(scratch
, "PHYS=%s", dev
->phys
) + 1;
407 SPRINTF_BIT_A(evbit
, "EV=", EV_MAX
);
408 SPRINTF_BIT_A2(keybit
, "KEY=", KEY_MAX
, EV_KEY
);
409 SPRINTF_BIT_A2(relbit
, "REL=", REL_MAX
, EV_REL
);
410 SPRINTF_BIT_A2(absbit
, "ABS=", ABS_MAX
, EV_ABS
);
411 SPRINTF_BIT_A2(mscbit
, "MSC=", MSC_MAX
, EV_MSC
);
412 SPRINTF_BIT_A2(ledbit
, "LED=", LED_MAX
, EV_LED
);
413 SPRINTF_BIT_A2(sndbit
, "SND=", SND_MAX
, EV_SND
);
414 SPRINTF_BIT_A2(ffbit
, "FF=", FF_MAX
, EV_FF
);
415 SPRINTF_BIT_A2(swbit
, "SW=", SW_MAX
, EV_SW
);
420 printk(KERN_DEBUG
"input.c: calling %s %s [%s %s %s %s %s]\n",
421 argv
[0], argv
[1], envp
[0], envp
[1], envp
[2], envp
[3], envp
[4]);
424 value
= call_usermodehelper(argv
[0], argv
, envp
, 0);
431 printk(KERN_DEBUG
"input.c: hotplug returned %d\n", value
);
437 static int input_print_bitmap(char *buf
, unsigned long *bitmap
, int max
)
442 for (i
= NBITS(max
) - 1; i
> 0; i
--)
447 len
+= sprintf(buf
+ len
, "%lx%s", bitmap
[i
], i
> 0 ? " " : "");
449 len
+= sprintf(buf
+ len
, "\n");
454 #ifdef CONFIG_PROC_FS
456 static struct proc_dir_entry
*proc_bus_input_dir
;
457 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait
);
458 static int input_devices_state
;
460 static inline void input_wakeup_procfs_readers(void)
462 input_devices_state
++;
463 wake_up(&input_devices_poll_wait
);
466 static unsigned int input_devices_poll(struct file
*file
, poll_table
*wait
)
468 int state
= input_devices_state
;
469 poll_wait(file
, &input_devices_poll_wait
, wait
);
470 if (state
!= input_devices_state
)
471 return POLLIN
| POLLRDNORM
;
475 #define SPRINTF_BIT_B(ev, bm) \
477 len += sprintf(buf + len, "B: %s=", #ev); \
478 len += input_print_bitmap(buf + len, \
479 dev->bm##bit, ev##_MAX); \
482 #define SPRINTF_BIT_B2(ev, bm) \
484 if (test_bit(EV_##ev, dev->evbit)) \
485 SPRINTF_BIT_B(ev, bm); \
488 static int input_devices_read(char *buf
, char **start
, off_t pos
, int count
, int *eof
, void *data
)
490 struct input_dev
*dev
;
491 struct input_handle
*handle
;
497 list_for_each_entry(dev
, &input_dev_list
, node
) {
499 path
= dev
->dynalloc
? kobject_get_path(&dev
->cdev
.kobj
, GFP_KERNEL
) : NULL
;
501 len
= sprintf(buf
, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
502 dev
->id
.bustype
, dev
->id
.vendor
, dev
->id
.product
, dev
->id
.version
);
504 len
+= sprintf(buf
+ len
, "N: Name=\"%s\"\n", dev
->name
? dev
->name
: "");
505 len
+= sprintf(buf
+ len
, "P: Phys=%s\n", dev
->phys
? dev
->phys
: "");
506 len
+= sprintf(buf
+ len
, "S: Sysfs=%s\n", path
? path
: "");
507 len
+= sprintf(buf
+ len
, "H: Handlers=");
509 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
510 len
+= sprintf(buf
+ len
, "%s ", handle
->name
);
512 len
+= sprintf(buf
+ len
, "\n");
514 SPRINTF_BIT_B(EV
, ev
);
515 SPRINTF_BIT_B2(KEY
, key
);
516 SPRINTF_BIT_B2(REL
, rel
);
517 SPRINTF_BIT_B2(ABS
, abs
);
518 SPRINTF_BIT_B2(MSC
, msc
);
519 SPRINTF_BIT_B2(LED
, led
);
520 SPRINTF_BIT_B2(SND
, snd
);
521 SPRINTF_BIT_B2(FF
, ff
);
522 SPRINTF_BIT_B2(SW
, sw
);
524 len
+= sprintf(buf
+ len
, "\n");
530 *start
= buf
+ (pos
- (at
- len
));
541 if (&dev
->node
== &input_dev_list
)
544 return (count
> cnt
) ? cnt
: count
;
547 static int input_handlers_read(char *buf
, char **start
, off_t pos
, int count
, int *eof
, void *data
)
549 struct input_handler
*handler
;
552 int len
= 0, cnt
= 0;
555 list_for_each_entry(handler
, &input_handler_list
, node
) {
558 len
= sprintf(buf
, "N: Number=%d Name=%s Minor=%d\n",
559 i
++, handler
->name
, handler
->minor
);
561 len
= sprintf(buf
, "N: Number=%d Name=%s\n",
568 *start
= buf
+ (pos
- (at
- len
));
576 if (&handler
->node
== &input_handler_list
)
579 return (count
> cnt
) ? cnt
: count
;
582 static struct file_operations input_fileops
;
584 static int __init
input_proc_init(void)
586 struct proc_dir_entry
*entry
;
588 proc_bus_input_dir
= proc_mkdir("input", proc_bus
);
589 if (!proc_bus_input_dir
)
592 proc_bus_input_dir
->owner
= THIS_MODULE
;
594 entry
= create_proc_read_entry("devices", 0, proc_bus_input_dir
, input_devices_read
, NULL
);
598 entry
->owner
= THIS_MODULE
;
599 input_fileops
= *entry
->proc_fops
;
600 entry
->proc_fops
= &input_fileops
;
601 entry
->proc_fops
->poll
= input_devices_poll
;
603 entry
= create_proc_read_entry("handlers", 0, proc_bus_input_dir
, input_handlers_read
, NULL
);
607 entry
->owner
= THIS_MODULE
;
611 fail2
: remove_proc_entry("devices", proc_bus_input_dir
);
612 fail1
: remove_proc_entry("input", proc_bus
);
616 static void input_proc_exit(void)
618 remove_proc_entry("devices", proc_bus_input_dir
);
619 remove_proc_entry("handlers", proc_bus_input_dir
);
620 remove_proc_entry("input", proc_bus
);
623 #else /* !CONFIG_PROC_FS */
624 static inline void input_wakeup_procfs_readers(void) { }
625 static inline int input_proc_init(void) { return 0; }
626 static inline void input_proc_exit(void) { }
629 #define INPUT_DEV_STRING_ATTR_SHOW(name) \
630 static ssize_t input_dev_show_##name(struct class_device *dev, char *buf) \
632 struct input_dev *input_dev = to_input_dev(dev); \
635 retval = down_interruptible(&input_dev->sem); \
639 retval = sprintf(buf, "%s\n", input_dev->name ? input_dev->name : ""); \
641 up(&input_dev->sem); \
645 static CLASS_DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL);
647 INPUT_DEV_STRING_ATTR_SHOW(name
);
648 INPUT_DEV_STRING_ATTR_SHOW(phys
);
649 INPUT_DEV_STRING_ATTR_SHOW(uniq
);
651 static struct attribute
*input_dev_attrs
[] = {
652 &class_device_attr_name
.attr
,
653 &class_device_attr_phys
.attr
,
654 &class_device_attr_uniq
.attr
,
658 static struct attribute_group input_dev_group
= {
659 .attrs
= input_dev_attrs
,
662 #define INPUT_DEV_ID_ATTR(name) \
663 static ssize_t input_dev_show_id_##name(struct class_device *dev, char *buf) \
665 struct input_dev *input_dev = to_input_dev(dev); \
666 return sprintf(buf, "%04x\n", input_dev->id.name); \
668 static CLASS_DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL);
670 INPUT_DEV_ID_ATTR(bustype
);
671 INPUT_DEV_ID_ATTR(vendor
);
672 INPUT_DEV_ID_ATTR(product
);
673 INPUT_DEV_ID_ATTR(version
);
675 static struct attribute
*input_dev_id_attrs
[] = {
676 &class_device_attr_bustype
.attr
,
677 &class_device_attr_vendor
.attr
,
678 &class_device_attr_product
.attr
,
679 &class_device_attr_version
.attr
,
683 static struct attribute_group input_dev_id_attr_group
= {
685 .attrs
= input_dev_id_attrs
,
688 #define INPUT_DEV_CAP_ATTR(ev, bm) \
689 static ssize_t input_dev_show_cap_##bm(struct class_device *dev, char *buf) \
691 struct input_dev *input_dev = to_input_dev(dev); \
692 return input_print_bitmap(buf, input_dev->bm##bit, ev##_MAX); \
694 static CLASS_DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL);
696 INPUT_DEV_CAP_ATTR(EV
, ev
);
697 INPUT_DEV_CAP_ATTR(KEY
, key
);
698 INPUT_DEV_CAP_ATTR(REL
, rel
);
699 INPUT_DEV_CAP_ATTR(ABS
, abs
);
700 INPUT_DEV_CAP_ATTR(MSC
, msc
);
701 INPUT_DEV_CAP_ATTR(LED
, led
);
702 INPUT_DEV_CAP_ATTR(SND
, snd
);
703 INPUT_DEV_CAP_ATTR(FF
, ff
);
704 INPUT_DEV_CAP_ATTR(SW
, sw
);
706 static struct attribute
*input_dev_caps_attrs
[] = {
707 &class_device_attr_ev
.attr
,
708 &class_device_attr_key
.attr
,
709 &class_device_attr_rel
.attr
,
710 &class_device_attr_abs
.attr
,
711 &class_device_attr_msc
.attr
,
712 &class_device_attr_led
.attr
,
713 &class_device_attr_snd
.attr
,
714 &class_device_attr_ff
.attr
,
715 &class_device_attr_sw
.attr
,
719 static struct attribute_group input_dev_caps_attr_group
= {
720 .name
= "capabilities",
721 .attrs
= input_dev_caps_attrs
,
724 static void input_dev_release(struct class_device
*class_dev
)
726 struct input_dev
*dev
= to_input_dev(class_dev
);
729 module_put(THIS_MODULE
);
732 struct class input_class
= {
734 .release
= input_dev_release
,
737 struct input_dev
*input_allocate_device(void)
739 struct input_dev
*dev
;
741 dev
= kzalloc(sizeof(struct input_dev
), GFP_KERNEL
);
744 dev
->cdev
.class = &input_class
;
745 class_device_initialize(&dev
->cdev
);
746 INIT_LIST_HEAD(&dev
->h_list
);
747 INIT_LIST_HEAD(&dev
->node
);
753 static void input_register_classdevice(struct input_dev
*dev
)
755 static atomic_t input_no
= ATOMIC_INIT(0);
758 __module_get(THIS_MODULE
);
760 dev
->dev
= dev
->cdev
.dev
;
762 snprintf(dev
->cdev
.class_id
, sizeof(dev
->cdev
.class_id
),
763 "input%ld", (unsigned long) atomic_inc_return(&input_no
) - 1);
765 path
= kobject_get_path(&dev
->cdev
.class->subsys
.kset
.kobj
, GFP_KERNEL
);
766 printk(KERN_INFO
"input: %s/%s as %s\n",
767 dev
->name
? dev
->name
: "Unspecified device",
768 path
? path
: "", dev
->cdev
.class_id
);
771 class_device_add(&dev
->cdev
);
772 sysfs_create_group(&dev
->cdev
.kobj
, &input_dev_group
);
773 sysfs_create_group(&dev
->cdev
.kobj
, &input_dev_id_attr_group
);
774 sysfs_create_group(&dev
->cdev
.kobj
, &input_dev_caps_attr_group
);
777 void input_register_device(struct input_dev
*dev
)
779 struct input_handle
*handle
;
780 struct input_handler
*handler
;
781 struct input_device_id
*id
;
783 set_bit(EV_SYN
, dev
->evbit
);
785 init_MUTEX(&dev
->sem
);
788 * If delay and period are pre-set by the driver, then autorepeating
789 * is handled by the driver itself and we don't do it in input.c.
792 init_timer(&dev
->timer
);
793 if (!dev
->rep
[REP_DELAY
] && !dev
->rep
[REP_PERIOD
]) {
794 dev
->timer
.data
= (long) dev
;
795 dev
->timer
.function
= input_repeat_key
;
796 dev
->rep
[REP_DELAY
] = 250;
797 dev
->rep
[REP_PERIOD
] = 33;
800 INIT_LIST_HEAD(&dev
->h_list
);
801 list_add_tail(&dev
->node
, &input_dev_list
);
804 input_register_classdevice(dev
);
806 list_for_each_entry(handler
, &input_handler_list
, node
)
807 if (!handler
->blacklist
|| !input_match_device(handler
->blacklist
, dev
))
808 if ((id
= input_match_device(handler
->id_table
, dev
)))
809 if ((handle
= handler
->connect(handler
, dev
, id
)))
810 input_link_handle(handle
);
813 #ifdef CONFIG_HOTPLUG
814 input_call_hotplug("add", dev
);
817 input_wakeup_procfs_readers();
820 void input_unregister_device(struct input_dev
*dev
)
822 struct list_head
* node
, * next
;
826 del_timer_sync(&dev
->timer
);
828 list_for_each_safe(node
, next
, &dev
->h_list
) {
829 struct input_handle
* handle
= to_handle(node
);
830 list_del_init(&handle
->d_node
);
831 list_del_init(&handle
->h_node
);
832 handle
->handler
->disconnect(handle
);
835 #ifdef CONFIG_HOTPLUG
836 input_call_hotplug("remove", dev
);
839 list_del_init(&dev
->node
);
842 sysfs_remove_group(&dev
->cdev
.kobj
, &input_dev_caps_attr_group
);
843 sysfs_remove_group(&dev
->cdev
.kobj
, &input_dev_id_attr_group
);
844 class_device_unregister(&dev
->cdev
);
847 input_wakeup_procfs_readers();
850 void input_register_handler(struct input_handler
*handler
)
852 struct input_dev
*dev
;
853 struct input_handle
*handle
;
854 struct input_device_id
*id
;
856 if (!handler
) return;
858 INIT_LIST_HEAD(&handler
->h_list
);
860 if (handler
->fops
!= NULL
)
861 input_table
[handler
->minor
>> 5] = handler
;
863 list_add_tail(&handler
->node
, &input_handler_list
);
865 list_for_each_entry(dev
, &input_dev_list
, node
)
866 if (!handler
->blacklist
|| !input_match_device(handler
->blacklist
, dev
))
867 if ((id
= input_match_device(handler
->id_table
, dev
)))
868 if ((handle
= handler
->connect(handler
, dev
, id
)))
869 input_link_handle(handle
);
871 input_wakeup_procfs_readers();
874 void input_unregister_handler(struct input_handler
*handler
)
876 struct list_head
* node
, * next
;
878 list_for_each_safe(node
, next
, &handler
->h_list
) {
879 struct input_handle
* handle
= to_handle_h(node
);
880 list_del_init(&handle
->h_node
);
881 list_del_init(&handle
->d_node
);
882 handler
->disconnect(handle
);
885 list_del_init(&handler
->node
);
887 if (handler
->fops
!= NULL
)
888 input_table
[handler
->minor
>> 5] = NULL
;
890 input_wakeup_procfs_readers();
893 static int input_open_file(struct inode
*inode
, struct file
*file
)
895 struct input_handler
*handler
= input_table
[iminor(inode
) >> 5];
896 struct file_operations
*old_fops
, *new_fops
= NULL
;
899 /* No load-on-demand here? */
900 if (!handler
|| !(new_fops
= fops_get(handler
->fops
)))
904 * That's _really_ odd. Usually NULL ->open means "nothing special",
905 * not "no device". Oh, well...
907 if (!new_fops
->open
) {
911 old_fops
= file
->f_op
;
912 file
->f_op
= new_fops
;
914 err
= new_fops
->open(inode
, file
);
917 fops_put(file
->f_op
);
918 file
->f_op
= fops_get(old_fops
);
924 static struct file_operations input_fops
= {
925 .owner
= THIS_MODULE
,
926 .open
= input_open_file
,
929 static int __init
input_init(void)
933 err
= class_register(&input_class
);
935 printk(KERN_ERR
"input: unable to register input_dev class\n");
939 err
= input_proc_init();
943 err
= register_chrdev(INPUT_MAJOR
, "input", &input_fops
);
945 printk(KERN_ERR
"input: unable to register char major %d", INPUT_MAJOR
);
951 fail2
: input_proc_exit();
952 fail1
: class_unregister(&input_class
);
956 static void __exit
input_exit(void)
959 unregister_chrdev(INPUT_MAJOR
, "input");
960 class_unregister(&input_class
);
963 subsys_initcall(input_init
);
964 module_exit(input_exit
);