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/interrupt.h>
22 #include <linux/poll.h>
23 #include <linux/device.h>
25 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
26 MODULE_DESCRIPTION("Input core");
27 MODULE_LICENSE("GPL");
29 EXPORT_SYMBOL(input_allocate_device
);
30 EXPORT_SYMBOL(input_register_device
);
31 EXPORT_SYMBOL(input_unregister_device
);
32 EXPORT_SYMBOL(input_register_handler
);
33 EXPORT_SYMBOL(input_unregister_handler
);
34 EXPORT_SYMBOL(input_grab_device
);
35 EXPORT_SYMBOL(input_release_device
);
36 EXPORT_SYMBOL(input_open_device
);
37 EXPORT_SYMBOL(input_close_device
);
38 EXPORT_SYMBOL(input_accept_process
);
39 EXPORT_SYMBOL(input_flush_device
);
40 EXPORT_SYMBOL(input_event
);
41 EXPORT_SYMBOL_GPL(input_class
);
43 #define INPUT_DEVICES 256
45 static LIST_HEAD(input_dev_list
);
46 static LIST_HEAD(input_handler_list
);
48 static struct input_handler
*input_table
[8];
50 void input_event(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int value
)
52 struct input_handle
*handle
;
54 if (type
> EV_MAX
|| !test_bit(type
, dev
->evbit
))
57 add_input_randomness(type
, code
, value
);
64 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
68 if (dev
->sync
) return;
76 if (code
> KEY_MAX
|| !test_bit(code
, dev
->keybit
) || !!test_bit(code
, dev
->key
) == value
)
82 change_bit(code
, dev
->key
);
84 if (test_bit(EV_REP
, dev
->evbit
) && dev
->rep
[REP_PERIOD
] && dev
->rep
[REP_DELAY
] && dev
->timer
.data
&& value
) {
85 dev
->repeat_key
= code
;
86 mod_timer(&dev
->timer
, jiffies
+ msecs_to_jiffies(dev
->rep
[REP_DELAY
]));
93 if (code
> SW_MAX
|| !test_bit(code
, dev
->swbit
) || !!test_bit(code
, dev
->sw
) == value
)
96 change_bit(code
, dev
->sw
);
102 if (code
> ABS_MAX
|| !test_bit(code
, dev
->absbit
))
105 if (dev
->absfuzz
[code
]) {
106 if ((value
> dev
->abs
[code
] - (dev
->absfuzz
[code
] >> 1)) &&
107 (value
< dev
->abs
[code
] + (dev
->absfuzz
[code
] >> 1)))
110 if ((value
> dev
->abs
[code
] - dev
->absfuzz
[code
]) &&
111 (value
< dev
->abs
[code
] + dev
->absfuzz
[code
]))
112 value
= (dev
->abs
[code
] * 3 + value
) >> 2;
114 if ((value
> dev
->abs
[code
] - (dev
->absfuzz
[code
] << 1)) &&
115 (value
< dev
->abs
[code
] + (dev
->absfuzz
[code
] << 1)))
116 value
= (dev
->abs
[code
] + value
) >> 1;
119 if (dev
->abs
[code
] == value
)
122 dev
->abs
[code
] = value
;
127 if (code
> REL_MAX
|| !test_bit(code
, dev
->relbit
) || (value
== 0))
134 if (code
> MSC_MAX
|| !test_bit(code
, dev
->mscbit
))
137 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
143 if (code
> LED_MAX
|| !test_bit(code
, dev
->ledbit
) || !!test_bit(code
, dev
->led
) == value
)
146 change_bit(code
, dev
->led
);
147 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
153 if (code
> SND_MAX
|| !test_bit(code
, dev
->sndbit
))
156 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
162 if (code
> REP_MAX
|| value
< 0 || dev
->rep
[code
] == value
) return;
164 dev
->rep
[code
] = value
;
165 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
170 if (dev
->event
) dev
->event(dev
, type
, code
, value
);
178 dev
->grab
->handler
->event(dev
->grab
, type
, code
, value
);
180 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
182 handle
->handler
->event(handle
, type
, code
, value
);
185 static void input_repeat_key(unsigned long data
)
187 struct input_dev
*dev
= (void *) data
;
189 if (!test_bit(dev
->repeat_key
, dev
->key
))
192 input_event(dev
, EV_KEY
, dev
->repeat_key
, 2);
195 if (dev
->rep
[REP_PERIOD
])
196 mod_timer(&dev
->timer
, jiffies
+ msecs_to_jiffies(dev
->rep
[REP_PERIOD
]));
199 int input_accept_process(struct input_handle
*handle
, struct file
*file
)
201 if (handle
->dev
->accept
)
202 return handle
->dev
->accept(handle
->dev
, file
);
207 int input_grab_device(struct input_handle
*handle
)
209 if (handle
->dev
->grab
)
212 handle
->dev
->grab
= handle
;
216 void input_release_device(struct input_handle
*handle
)
218 if (handle
->dev
->grab
== handle
)
219 handle
->dev
->grab
= NULL
;
222 int input_open_device(struct input_handle
*handle
)
224 struct input_dev
*dev
= handle
->dev
;
227 err
= down_interruptible(&dev
->sem
);
233 if (!dev
->users
++ && dev
->open
)
234 err
= dev
->open(dev
);
244 int input_flush_device(struct input_handle
* handle
, struct file
* file
)
246 if (handle
->dev
->flush
)
247 return handle
->dev
->flush(handle
->dev
, file
);
252 void input_close_device(struct input_handle
*handle
)
254 struct input_dev
*dev
= handle
->dev
;
256 input_release_device(handle
);
260 if (!--dev
->users
&& dev
->close
)
267 static void input_link_handle(struct input_handle
*handle
)
269 list_add_tail(&handle
->d_node
, &handle
->dev
->h_list
);
270 list_add_tail(&handle
->h_node
, &handle
->handler
->h_list
);
273 #define MATCH_BIT(bit, max) \
274 for (i = 0; i < NBITS(max); i++) \
275 if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
277 if (i != NBITS(max)) \
280 static struct input_device_id
*input_match_device(struct input_device_id
*id
, struct input_dev
*dev
)
284 for (; id
->flags
|| id
->driver_info
; id
++) {
286 if (id
->flags
& INPUT_DEVICE_ID_MATCH_BUS
)
287 if (id
->id
.bustype
!= dev
->id
.bustype
)
290 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VENDOR
)
291 if (id
->id
.vendor
!= dev
->id
.vendor
)
294 if (id
->flags
& INPUT_DEVICE_ID_MATCH_PRODUCT
)
295 if (id
->id
.product
!= dev
->id
.product
)
298 if (id
->flags
& INPUT_DEVICE_ID_MATCH_VERSION
)
299 if (id
->id
.version
!= dev
->id
.version
)
302 MATCH_BIT(evbit
, EV_MAX
);
303 MATCH_BIT(keybit
, KEY_MAX
);
304 MATCH_BIT(relbit
, REL_MAX
);
305 MATCH_BIT(absbit
, ABS_MAX
);
306 MATCH_BIT(mscbit
, MSC_MAX
);
307 MATCH_BIT(ledbit
, LED_MAX
);
308 MATCH_BIT(sndbit
, SND_MAX
);
309 MATCH_BIT(ffbit
, FF_MAX
);
310 MATCH_BIT(swbit
, SW_MAX
);
318 static int input_print_bitmap(char *buf
, int buf_size
, unsigned long *bitmap
, int max
)
323 for (i
= NBITS(max
) - 1; i
> 0; i
--)
328 len
+= snprintf(buf
+ len
, max(buf_size
- len
, 0),
329 "%lx%s", bitmap
[i
], i
> 0 ? " " : "");
333 #ifdef CONFIG_PROC_FS
335 static struct proc_dir_entry
*proc_bus_input_dir
;
336 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait
);
337 static int input_devices_state
;
339 static inline void input_wakeup_procfs_readers(void)
341 input_devices_state
++;
342 wake_up(&input_devices_poll_wait
);
345 static unsigned int input_devices_poll(struct file
*file
, poll_table
*wait
)
347 int state
= input_devices_state
;
348 poll_wait(file
, &input_devices_poll_wait
, wait
);
349 if (state
!= input_devices_state
)
350 return POLLIN
| POLLRDNORM
;
354 #define SPRINTF_BIT(ev, bm) \
356 len += sprintf(buf + len, "B: %s=", #ev); \
357 len += input_print_bitmap(buf + len, INT_MAX, \
358 dev->bm##bit, ev##_MAX); \
359 len += sprintf(buf + len, "\n"); \
362 #define TEST_AND_SPRINTF_BIT(ev, bm) \
364 if (test_bit(EV_##ev, dev->evbit)) \
365 SPRINTF_BIT(ev, bm); \
368 static int input_devices_read(char *buf
, char **start
, off_t pos
, int count
, int *eof
, void *data
)
370 struct input_dev
*dev
;
371 struct input_handle
*handle
;
377 list_for_each_entry(dev
, &input_dev_list
, node
) {
379 path
= kobject_get_path(&dev
->cdev
.kobj
, GFP_KERNEL
);
381 len
= sprintf(buf
, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
382 dev
->id
.bustype
, dev
->id
.vendor
, dev
->id
.product
, dev
->id
.version
);
384 len
+= sprintf(buf
+ len
, "N: Name=\"%s\"\n", dev
->name
? dev
->name
: "");
385 len
+= sprintf(buf
+ len
, "P: Phys=%s\n", dev
->phys
? dev
->phys
: "");
386 len
+= sprintf(buf
+ len
, "S: Sysfs=%s\n", path
? path
: "");
387 len
+= sprintf(buf
+ len
, "H: Handlers=");
389 list_for_each_entry(handle
, &dev
->h_list
, d_node
)
390 len
+= sprintf(buf
+ len
, "%s ", handle
->name
);
392 len
+= sprintf(buf
+ len
, "\n");
395 TEST_AND_SPRINTF_BIT(KEY
, key
);
396 TEST_AND_SPRINTF_BIT(REL
, rel
);
397 TEST_AND_SPRINTF_BIT(ABS
, abs
);
398 TEST_AND_SPRINTF_BIT(MSC
, msc
);
399 TEST_AND_SPRINTF_BIT(LED
, led
);
400 TEST_AND_SPRINTF_BIT(SND
, snd
);
401 TEST_AND_SPRINTF_BIT(FF
, ff
);
402 TEST_AND_SPRINTF_BIT(SW
, sw
);
404 len
+= sprintf(buf
+ len
, "\n");
410 *start
= buf
+ (pos
- (at
- len
));
421 if (&dev
->node
== &input_dev_list
)
424 return (count
> cnt
) ? cnt
: count
;
427 static int input_handlers_read(char *buf
, char **start
, off_t pos
, int count
, int *eof
, void *data
)
429 struct input_handler
*handler
;
432 int len
= 0, cnt
= 0;
435 list_for_each_entry(handler
, &input_handler_list
, node
) {
438 len
= sprintf(buf
, "N: Number=%d Name=%s Minor=%d\n",
439 i
++, handler
->name
, handler
->minor
);
441 len
= sprintf(buf
, "N: Number=%d Name=%s\n",
448 *start
= buf
+ (pos
- (at
- len
));
456 if (&handler
->node
== &input_handler_list
)
459 return (count
> cnt
) ? cnt
: count
;
462 static struct file_operations input_fileops
;
464 static int __init
input_proc_init(void)
466 struct proc_dir_entry
*entry
;
468 proc_bus_input_dir
= proc_mkdir("input", proc_bus
);
469 if (!proc_bus_input_dir
)
472 proc_bus_input_dir
->owner
= THIS_MODULE
;
474 entry
= create_proc_read_entry("devices", 0, proc_bus_input_dir
, input_devices_read
, NULL
);
478 entry
->owner
= THIS_MODULE
;
479 input_fileops
= *entry
->proc_fops
;
480 entry
->proc_fops
= &input_fileops
;
481 entry
->proc_fops
->poll
= input_devices_poll
;
483 entry
= create_proc_read_entry("handlers", 0, proc_bus_input_dir
, input_handlers_read
, NULL
);
487 entry
->owner
= THIS_MODULE
;
491 fail2
: remove_proc_entry("devices", proc_bus_input_dir
);
492 fail1
: remove_proc_entry("input", proc_bus
);
496 static void input_proc_exit(void)
498 remove_proc_entry("devices", proc_bus_input_dir
);
499 remove_proc_entry("handlers", proc_bus_input_dir
);
500 remove_proc_entry("input", proc_bus
);
503 #else /* !CONFIG_PROC_FS */
504 static inline void input_wakeup_procfs_readers(void) { }
505 static inline int input_proc_init(void) { return 0; }
506 static inline void input_proc_exit(void) { }
509 #define INPUT_DEV_STRING_ATTR_SHOW(name) \
510 static ssize_t input_dev_show_##name(struct class_device *dev, char *buf) \
512 struct input_dev *input_dev = to_input_dev(dev); \
515 retval = down_interruptible(&input_dev->sem); \
519 retval = sprintf(buf, "%s\n", input_dev->name ? input_dev->name : ""); \
521 up(&input_dev->sem); \
525 static CLASS_DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL);
527 INPUT_DEV_STRING_ATTR_SHOW(name
);
528 INPUT_DEV_STRING_ATTR_SHOW(phys
);
529 INPUT_DEV_STRING_ATTR_SHOW(uniq
);
531 static struct attribute
*input_dev_attrs
[] = {
532 &class_device_attr_name
.attr
,
533 &class_device_attr_phys
.attr
,
534 &class_device_attr_uniq
.attr
,
538 static struct attribute_group input_dev_attr_group
= {
539 .attrs
= input_dev_attrs
,
542 #define INPUT_DEV_ID_ATTR(name) \
543 static ssize_t input_dev_show_id_##name(struct class_device *dev, char *buf) \
545 struct input_dev *input_dev = to_input_dev(dev); \
546 return sprintf(buf, "%04x\n", input_dev->id.name); \
548 static CLASS_DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL);
550 INPUT_DEV_ID_ATTR(bustype
);
551 INPUT_DEV_ID_ATTR(vendor
);
552 INPUT_DEV_ID_ATTR(product
);
553 INPUT_DEV_ID_ATTR(version
);
555 static struct attribute
*input_dev_id_attrs
[] = {
556 &class_device_attr_bustype
.attr
,
557 &class_device_attr_vendor
.attr
,
558 &class_device_attr_product
.attr
,
559 &class_device_attr_version
.attr
,
563 static struct attribute_group input_dev_id_attr_group
= {
565 .attrs
= input_dev_id_attrs
,
568 #define INPUT_DEV_CAP_ATTR(ev, bm) \
569 static ssize_t input_dev_show_cap_##bm(struct class_device *dev, char *buf) \
571 struct input_dev *input_dev = to_input_dev(dev); \
572 return input_print_bitmap(buf, PAGE_SIZE, input_dev->bm##bit, ev##_MAX);\
574 static CLASS_DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL);
576 INPUT_DEV_CAP_ATTR(EV
, ev
);
577 INPUT_DEV_CAP_ATTR(KEY
, key
);
578 INPUT_DEV_CAP_ATTR(REL
, rel
);
579 INPUT_DEV_CAP_ATTR(ABS
, abs
);
580 INPUT_DEV_CAP_ATTR(MSC
, msc
);
581 INPUT_DEV_CAP_ATTR(LED
, led
);
582 INPUT_DEV_CAP_ATTR(SND
, snd
);
583 INPUT_DEV_CAP_ATTR(FF
, ff
);
584 INPUT_DEV_CAP_ATTR(SW
, sw
);
586 static struct attribute
*input_dev_caps_attrs
[] = {
587 &class_device_attr_ev
.attr
,
588 &class_device_attr_key
.attr
,
589 &class_device_attr_rel
.attr
,
590 &class_device_attr_abs
.attr
,
591 &class_device_attr_msc
.attr
,
592 &class_device_attr_led
.attr
,
593 &class_device_attr_snd
.attr
,
594 &class_device_attr_ff
.attr
,
595 &class_device_attr_sw
.attr
,
599 static struct attribute_group input_dev_caps_attr_group
= {
600 .name
= "capabilities",
601 .attrs
= input_dev_caps_attrs
,
604 static void input_dev_release(struct class_device
*class_dev
)
606 struct input_dev
*dev
= to_input_dev(class_dev
);
609 module_put(THIS_MODULE
);
613 * Input hotplugging interface - loading event handlers based on
616 static int input_add_hotplug_bm_var(char **envp
, int num_envp
, int *cur_index
,
617 char *buffer
, int buffer_size
, int *cur_len
,
618 const char *name
, unsigned long *bitmap
, int max
)
620 if (*cur_index
>= num_envp
- 1)
623 envp
[*cur_index
] = buffer
+ *cur_len
;
625 *cur_len
+= snprintf(buffer
+ *cur_len
, max(buffer_size
- *cur_len
, 0), name
);
626 if (*cur_len
> buffer_size
)
629 *cur_len
+= input_print_bitmap(buffer
+ *cur_len
,
630 max(buffer_size
- *cur_len
, 0),
632 if (*cur_len
> buffer_size
)
639 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
641 int err = add_hotplug_env_var(envp, num_envp, &i, \
642 buffer, buffer_size, &len, \
648 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
650 int err = input_add_hotplug_bm_var(envp, num_envp, &i, \
651 buffer, buffer_size, &len, \
657 static int input_dev_hotplug(struct class_device
*cdev
, char **envp
,
658 int num_envp
, char *buffer
, int buffer_size
)
660 struct input_dev
*dev
= to_input_dev(cdev
);
664 INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
665 dev
->id
.bustype
, dev
->id
.vendor
,
666 dev
->id
.product
, dev
->id
.version
);
668 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev
->name
);
670 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev
->phys
);
672 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev
->uniq
);
674 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev
->evbit
, EV_MAX
);
675 if (test_bit(EV_KEY
, dev
->evbit
))
676 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev
->keybit
, KEY_MAX
);
677 if (test_bit(EV_REL
, dev
->evbit
))
678 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev
->relbit
, REL_MAX
);
679 if (test_bit(EV_ABS
, dev
->evbit
))
680 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev
->absbit
, ABS_MAX
);
681 if (test_bit(EV_MSC
, dev
->evbit
))
682 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev
->mscbit
, MSC_MAX
);
683 if (test_bit(EV_LED
, dev
->evbit
))
684 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev
->ledbit
, LED_MAX
);
685 if (test_bit(EV_SND
, dev
->evbit
))
686 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev
->sndbit
, SND_MAX
);
687 if (test_bit(EV_FF
, dev
->evbit
))
688 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev
->ffbit
, FF_MAX
);
689 if (test_bit(EV_SW
, dev
->evbit
))
690 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev
->swbit
, SW_MAX
);
697 struct class input_class
= {
699 .release
= input_dev_release
,
700 .hotplug
= input_dev_hotplug
,
703 struct input_dev
*input_allocate_device(void)
705 struct input_dev
*dev
;
707 dev
= kzalloc(sizeof(struct input_dev
), GFP_KERNEL
);
710 dev
->cdev
.class = &input_class
;
711 class_device_initialize(&dev
->cdev
);
712 INIT_LIST_HEAD(&dev
->h_list
);
713 INIT_LIST_HEAD(&dev
->node
);
719 int input_register_device(struct input_dev
*dev
)
721 static atomic_t input_no
= ATOMIC_INIT(0);
722 struct input_handle
*handle
;
723 struct input_handler
*handler
;
724 struct input_device_id
*id
;
728 if (!dev
->dynalloc
) {
729 printk(KERN_WARNING
"input: device %s is statically allocated, will not register\n"
730 "Please convert to input_allocate_device() or contact dtor_core@ameritech.net\n",
731 dev
->name
? dev
->name
: "<Unknown>");
735 init_MUTEX(&dev
->sem
);
736 set_bit(EV_SYN
, dev
->evbit
);
739 * If delay and period are pre-set by the driver, then autorepeating
740 * is handled by the driver itself and we don't do it in input.c.
743 init_timer(&dev
->timer
);
744 if (!dev
->rep
[REP_DELAY
] && !dev
->rep
[REP_PERIOD
]) {
745 dev
->timer
.data
= (long) dev
;
746 dev
->timer
.function
= input_repeat_key
;
747 dev
->rep
[REP_DELAY
] = 250;
748 dev
->rep
[REP_PERIOD
] = 33;
751 INIT_LIST_HEAD(&dev
->h_list
);
752 list_add_tail(&dev
->node
, &input_dev_list
);
754 dev
->cdev
.class = &input_class
;
755 snprintf(dev
->cdev
.class_id
, sizeof(dev
->cdev
.class_id
),
756 "input%ld", (unsigned long) atomic_inc_return(&input_no
) - 1);
758 error
= class_device_add(&dev
->cdev
);
762 error
= sysfs_create_group(&dev
->cdev
.kobj
, &input_dev_attr_group
);
766 error
= sysfs_create_group(&dev
->cdev
.kobj
, &input_dev_id_attr_group
);
770 error
= sysfs_create_group(&dev
->cdev
.kobj
, &input_dev_caps_attr_group
);
774 __module_get(THIS_MODULE
);
776 path
= kobject_get_path(&dev
->cdev
.kobj
, GFP_KERNEL
);
777 printk(KERN_INFO
"input: %s as %s\n",
778 dev
->name
? dev
->name
: "Unspecified device", path
? path
: "N/A");
781 list_for_each_entry(handler
, &input_handler_list
, node
)
782 if (!handler
->blacklist
|| !input_match_device(handler
->blacklist
, dev
))
783 if ((id
= input_match_device(handler
->id_table
, dev
)))
784 if ((handle
= handler
->connect(handler
, dev
, id
)))
785 input_link_handle(handle
);
787 input_wakeup_procfs_readers();
791 fail3
: sysfs_remove_group(&dev
->cdev
.kobj
, &input_dev_id_attr_group
);
792 fail2
: sysfs_remove_group(&dev
->cdev
.kobj
, &input_dev_attr_group
);
793 fail1
: class_device_del(&dev
->cdev
);
797 void input_unregister_device(struct input_dev
*dev
)
799 struct list_head
* node
, * next
;
803 del_timer_sync(&dev
->timer
);
805 list_for_each_safe(node
, next
, &dev
->h_list
) {
806 struct input_handle
* handle
= to_handle(node
);
807 list_del_init(&handle
->d_node
);
808 list_del_init(&handle
->h_node
);
809 handle
->handler
->disconnect(handle
);
812 list_del_init(&dev
->node
);
814 sysfs_remove_group(&dev
->cdev
.kobj
, &input_dev_caps_attr_group
);
815 sysfs_remove_group(&dev
->cdev
.kobj
, &input_dev_id_attr_group
);
816 sysfs_remove_group(&dev
->cdev
.kobj
, &input_dev_attr_group
);
817 class_device_unregister(&dev
->cdev
);
819 input_wakeup_procfs_readers();
822 void input_register_handler(struct input_handler
*handler
)
824 struct input_dev
*dev
;
825 struct input_handle
*handle
;
826 struct input_device_id
*id
;
828 if (!handler
) return;
830 INIT_LIST_HEAD(&handler
->h_list
);
832 if (handler
->fops
!= NULL
)
833 input_table
[handler
->minor
>> 5] = handler
;
835 list_add_tail(&handler
->node
, &input_handler_list
);
837 list_for_each_entry(dev
, &input_dev_list
, node
)
838 if (!handler
->blacklist
|| !input_match_device(handler
->blacklist
, dev
))
839 if ((id
= input_match_device(handler
->id_table
, dev
)))
840 if ((handle
= handler
->connect(handler
, dev
, id
)))
841 input_link_handle(handle
);
843 input_wakeup_procfs_readers();
846 void input_unregister_handler(struct input_handler
*handler
)
848 struct list_head
* node
, * next
;
850 list_for_each_safe(node
, next
, &handler
->h_list
) {
851 struct input_handle
* handle
= to_handle_h(node
);
852 list_del_init(&handle
->h_node
);
853 list_del_init(&handle
->d_node
);
854 handler
->disconnect(handle
);
857 list_del_init(&handler
->node
);
859 if (handler
->fops
!= NULL
)
860 input_table
[handler
->minor
>> 5] = NULL
;
862 input_wakeup_procfs_readers();
865 static int input_open_file(struct inode
*inode
, struct file
*file
)
867 struct input_handler
*handler
= input_table
[iminor(inode
) >> 5];
868 struct file_operations
*old_fops
, *new_fops
= NULL
;
871 /* No load-on-demand here? */
872 if (!handler
|| !(new_fops
= fops_get(handler
->fops
)))
876 * That's _really_ odd. Usually NULL ->open means "nothing special",
877 * not "no device". Oh, well...
879 if (!new_fops
->open
) {
883 old_fops
= file
->f_op
;
884 file
->f_op
= new_fops
;
886 err
= new_fops
->open(inode
, file
);
889 fops_put(file
->f_op
);
890 file
->f_op
= fops_get(old_fops
);
896 static struct file_operations input_fops
= {
897 .owner
= THIS_MODULE
,
898 .open
= input_open_file
,
901 static int __init
input_init(void)
905 err
= class_register(&input_class
);
907 printk(KERN_ERR
"input: unable to register input_dev class\n");
911 err
= input_proc_init();
915 err
= register_chrdev(INPUT_MAJOR
, "input", &input_fops
);
917 printk(KERN_ERR
"input: unable to register char major %d", INPUT_MAJOR
);
923 fail2
: input_proc_exit();
924 fail1
: class_unregister(&input_class
);
928 static void __exit
input_exit(void)
931 unregister_chrdev(INPUT_MAJOR
, "input");
932 class_unregister(&input_class
);
935 subsys_initcall(input_init
);
936 module_exit(input_exit
);