2 * Event char devices, giving access to raw input device events.
4 * Copyright (c) 1999-2002 Vojtech Pavlik
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
11 #define EVDEV_MINOR_BASE 64
12 #define EVDEV_MINORS 32
13 #define EVDEV_MIN_BUFFER_SIZE 64U
14 #define EVDEV_BUF_PACKETS 8
16 #include <linux/poll.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/input.h>
22 #include <linux/major.h>
23 #include <linux/device.h>
24 #include "input-compat.h"
29 struct input_handle handle
;
30 wait_queue_head_t wait
;
31 struct evdev_client __rcu
*grab
;
32 struct list_head client_list
;
33 spinlock_t client_lock
; /* protects client_list */
42 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
43 struct fasync_struct
*fasync
;
45 struct list_head node
;
47 struct input_event buffer
[];
50 static struct evdev
*evdev_table
[EVDEV_MINORS
];
51 static DEFINE_MUTEX(evdev_table_mutex
);
53 static void evdev_pass_event(struct evdev_client
*client
,
54 struct input_event
*event
)
57 * Interrupts are disabled, just acquire the lock.
58 * Make sure we don't leave with the client buffer
59 * "empty" by having client->head == client->tail.
61 spin_lock(&client
->buffer_lock
);
63 client
->buffer
[client
->head
++] = *event
;
64 client
->head
&= client
->bufsize
- 1;
65 } while (client
->head
== client
->tail
);
66 spin_unlock(&client
->buffer_lock
);
68 if (event
->type
== EV_SYN
)
69 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
73 * Pass incoming event to all connected clients.
75 static void evdev_event(struct input_handle
*handle
,
76 unsigned int type
, unsigned int code
, int value
)
78 struct evdev
*evdev
= handle
->private;
79 struct evdev_client
*client
;
80 struct input_event event
;
82 do_gettimeofday(&event
.time
);
89 client
= rcu_dereference(evdev
->grab
);
91 evdev_pass_event(client
, &event
);
93 list_for_each_entry_rcu(client
, &evdev
->client_list
, node
)
94 evdev_pass_event(client
, &event
);
98 wake_up_interruptible(&evdev
->wait
);
101 static int evdev_fasync(int fd
, struct file
*file
, int on
)
103 struct evdev_client
*client
= file
->private_data
;
105 return fasync_helper(fd
, file
, on
, &client
->fasync
);
108 static int evdev_flush(struct file
*file
, fl_owner_t id
)
110 struct evdev_client
*client
= file
->private_data
;
111 struct evdev
*evdev
= client
->evdev
;
114 retval
= mutex_lock_interruptible(&evdev
->mutex
);
121 retval
= input_flush_device(&evdev
->handle
, file
);
123 mutex_unlock(&evdev
->mutex
);
127 static void evdev_free(struct device
*dev
)
129 struct evdev
*evdev
= container_of(dev
, struct evdev
, dev
);
131 input_put_device(evdev
->handle
.dev
);
136 * Grabs an event device (along with underlying input device).
137 * This function is called with evdev->mutex taken.
139 static int evdev_grab(struct evdev
*evdev
, struct evdev_client
*client
)
146 error
= input_grab_device(&evdev
->handle
);
150 rcu_assign_pointer(evdev
->grab
, client
);
156 static int evdev_ungrab(struct evdev
*evdev
, struct evdev_client
*client
)
158 if (evdev
->grab
!= client
)
161 rcu_assign_pointer(evdev
->grab
, NULL
);
163 input_release_device(&evdev
->handle
);
168 static void evdev_attach_client(struct evdev
*evdev
,
169 struct evdev_client
*client
)
171 spin_lock(&evdev
->client_lock
);
172 list_add_tail_rcu(&client
->node
, &evdev
->client_list
);
173 spin_unlock(&evdev
->client_lock
);
177 static void evdev_detach_client(struct evdev
*evdev
,
178 struct evdev_client
*client
)
180 spin_lock(&evdev
->client_lock
);
181 list_del_rcu(&client
->node
);
182 spin_unlock(&evdev
->client_lock
);
186 static int evdev_open_device(struct evdev
*evdev
)
190 retval
= mutex_lock_interruptible(&evdev
->mutex
);
196 else if (!evdev
->open
++) {
197 retval
= input_open_device(&evdev
->handle
);
202 mutex_unlock(&evdev
->mutex
);
206 static void evdev_close_device(struct evdev
*evdev
)
208 mutex_lock(&evdev
->mutex
);
210 if (evdev
->exist
&& !--evdev
->open
)
211 input_close_device(&evdev
->handle
);
213 mutex_unlock(&evdev
->mutex
);
217 * Wake up users waiting for IO so they can disconnect from
220 static void evdev_hangup(struct evdev
*evdev
)
222 struct evdev_client
*client
;
224 spin_lock(&evdev
->client_lock
);
225 list_for_each_entry(client
, &evdev
->client_list
, node
)
226 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
227 spin_unlock(&evdev
->client_lock
);
229 wake_up_interruptible(&evdev
->wait
);
232 static int evdev_release(struct inode
*inode
, struct file
*file
)
234 struct evdev_client
*client
= file
->private_data
;
235 struct evdev
*evdev
= client
->evdev
;
237 mutex_lock(&evdev
->mutex
);
238 if (evdev
->grab
== client
)
239 evdev_ungrab(evdev
, client
);
240 mutex_unlock(&evdev
->mutex
);
242 evdev_detach_client(evdev
, client
);
245 evdev_close_device(evdev
);
246 put_device(&evdev
->dev
);
251 static unsigned int evdev_compute_buffer_size(struct input_dev
*dev
)
253 unsigned int n_events
=
254 max(dev
->hint_events_per_packet
* EVDEV_BUF_PACKETS
,
255 EVDEV_MIN_BUFFER_SIZE
);
257 return roundup_pow_of_two(n_events
);
260 static int evdev_open(struct inode
*inode
, struct file
*file
)
263 struct evdev_client
*client
;
264 int i
= iminor(inode
) - EVDEV_MINOR_BASE
;
265 unsigned int bufsize
;
268 if (i
>= EVDEV_MINORS
)
271 error
= mutex_lock_interruptible(&evdev_table_mutex
);
274 evdev
= evdev_table
[i
];
276 get_device(&evdev
->dev
);
277 mutex_unlock(&evdev_table_mutex
);
282 bufsize
= evdev_compute_buffer_size(evdev
->handle
.dev
);
284 client
= kzalloc(sizeof(struct evdev_client
) +
285 bufsize
* sizeof(struct input_event
),
292 client
->bufsize
= bufsize
;
293 spin_lock_init(&client
->buffer_lock
);
294 client
->evdev
= evdev
;
295 evdev_attach_client(evdev
, client
);
297 error
= evdev_open_device(evdev
);
299 goto err_free_client
;
301 file
->private_data
= client
;
302 nonseekable_open(inode
, file
);
307 evdev_detach_client(evdev
, client
);
310 put_device(&evdev
->dev
);
314 static ssize_t
evdev_write(struct file
*file
, const char __user
*buffer
,
315 size_t count
, loff_t
*ppos
)
317 struct evdev_client
*client
= file
->private_data
;
318 struct evdev
*evdev
= client
->evdev
;
319 struct input_event event
;
322 retval
= mutex_lock_interruptible(&evdev
->mutex
);
331 while (retval
< count
) {
333 if (input_event_from_user(buffer
+ retval
, &event
)) {
338 input_inject_event(&evdev
->handle
,
339 event
.type
, event
.code
, event
.value
);
340 retval
+= input_event_size();
344 mutex_unlock(&evdev
->mutex
);
348 static int evdev_fetch_next_event(struct evdev_client
*client
,
349 struct input_event
*event
)
353 spin_lock_irq(&client
->buffer_lock
);
355 have_event
= client
->head
!= client
->tail
;
357 *event
= client
->buffer
[client
->tail
++];
358 client
->tail
&= client
->bufsize
- 1;
361 spin_unlock_irq(&client
->buffer_lock
);
366 static ssize_t
evdev_read(struct file
*file
, char __user
*buffer
,
367 size_t count
, loff_t
*ppos
)
369 struct evdev_client
*client
= file
->private_data
;
370 struct evdev
*evdev
= client
->evdev
;
371 struct input_event event
;
374 if (count
< input_event_size())
377 if (client
->head
== client
->tail
&& evdev
->exist
&&
378 (file
->f_flags
& O_NONBLOCK
))
381 retval
= wait_event_interruptible(evdev
->wait
,
382 client
->head
!= client
->tail
|| !evdev
->exist
);
389 while (retval
+ input_event_size() <= count
&&
390 evdev_fetch_next_event(client
, &event
)) {
392 if (input_event_to_user(buffer
+ retval
, &event
))
395 retval
+= input_event_size();
401 /* No kernel lock - fine */
402 static unsigned int evdev_poll(struct file
*file
, poll_table
*wait
)
404 struct evdev_client
*client
= file
->private_data
;
405 struct evdev
*evdev
= client
->evdev
;
408 poll_wait(file
, &evdev
->wait
, wait
);
410 mask
= evdev
->exist
? POLLOUT
| POLLWRNORM
: POLLHUP
| POLLERR
;
411 if (client
->head
!= client
->tail
)
412 mask
|= POLLIN
| POLLRDNORM
;
419 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
420 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
423 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
424 unsigned int maxlen
, void __user
*p
, int compat
)
429 len
= BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
);
433 for (i
= 0; i
< len
/ sizeof(compat_long_t
); i
++)
434 if (copy_to_user((compat_long_t __user
*) p
+ i
,
435 (compat_long_t
*) bits
+
436 i
+ 1 - ((i
% 2) << 1),
437 sizeof(compat_long_t
)))
440 len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
444 if (copy_to_user(p
, bits
, len
))
451 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
452 unsigned int maxlen
, void __user
*p
, int compat
)
455 BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
) :
456 BITS_TO_LONGS(maxbit
) * sizeof(long);
461 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
463 #endif /* __BIG_ENDIAN */
467 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
468 unsigned int maxlen
, void __user
*p
, int compat
)
470 int len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
475 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
478 #endif /* CONFIG_COMPAT */
480 static int str_to_user(const char *str
, unsigned int maxlen
, void __user
*p
)
487 len
= strlen(str
) + 1;
491 return copy_to_user(p
, str
, len
) ? -EFAULT
: len
;
494 #define OLD_KEY_MAX 0x1ff
495 static int handle_eviocgbit(struct input_dev
*dev
,
496 unsigned int type
, unsigned int size
,
497 void __user
*p
, int compat_mode
)
499 static unsigned long keymax_warn_time
;
505 case 0: bits
= dev
->evbit
; len
= EV_MAX
; break;
506 case EV_KEY
: bits
= dev
->keybit
; len
= KEY_MAX
; break;
507 case EV_REL
: bits
= dev
->relbit
; len
= REL_MAX
; break;
508 case EV_ABS
: bits
= dev
->absbit
; len
= ABS_MAX
; break;
509 case EV_MSC
: bits
= dev
->mscbit
; len
= MSC_MAX
; break;
510 case EV_LED
: bits
= dev
->ledbit
; len
= LED_MAX
; break;
511 case EV_SND
: bits
= dev
->sndbit
; len
= SND_MAX
; break;
512 case EV_FF
: bits
= dev
->ffbit
; len
= FF_MAX
; break;
513 case EV_SW
: bits
= dev
->swbit
; len
= SW_MAX
; break;
514 default: return -EINVAL
;
518 * Work around bugs in userspace programs that like to do
519 * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len'
520 * should be in bytes, not in bits.
522 if (type
== EV_KEY
&& size
== OLD_KEY_MAX
) {
524 if (printk_timed_ratelimit(&keymax_warn_time
, 10 * 1000))
526 "evdev.c(EVIOCGBIT): Suspicious buffer size %u, "
527 "limiting output to %zu bytes. See "
528 "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n",
530 BITS_TO_LONGS(OLD_KEY_MAX
) * sizeof(long));
533 return bits_to_user(bits
, len
, size
, p
, compat_mode
);
537 static int evdev_handle_get_keycode(struct input_dev
*dev
, void __user
*p
)
539 struct input_keymap_entry ke
= {
540 .len
= sizeof(unsigned int),
543 int __user
*ip
= (int __user
*)p
;
547 if (copy_from_user(ke
.scancode
, p
, sizeof(unsigned int)))
550 error
= input_get_keycode(dev
, &ke
);
554 if (put_user(ke
.keycode
, ip
+ 1))
560 static int evdev_handle_get_keycode_v2(struct input_dev
*dev
, void __user
*p
)
562 struct input_keymap_entry ke
;
565 if (copy_from_user(&ke
, p
, sizeof(ke
)))
568 error
= input_get_keycode(dev
, &ke
);
572 if (copy_to_user(p
, &ke
, sizeof(ke
)))
578 static int evdev_handle_set_keycode(struct input_dev
*dev
, void __user
*p
)
580 struct input_keymap_entry ke
= {
581 .len
= sizeof(unsigned int),
584 int __user
*ip
= (int __user
*)p
;
586 if (copy_from_user(ke
.scancode
, p
, sizeof(unsigned int)))
589 if (get_user(ke
.keycode
, ip
+ 1))
592 return input_set_keycode(dev
, &ke
);
595 static int evdev_handle_set_keycode_v2(struct input_dev
*dev
, void __user
*p
)
597 struct input_keymap_entry ke
;
599 if (copy_from_user(&ke
, p
, sizeof(ke
)))
602 if (ke
.len
> sizeof(ke
.scancode
))
605 return input_set_keycode(dev
, &ke
);
608 static long evdev_do_ioctl(struct file
*file
, unsigned int cmd
,
609 void __user
*p
, int compat_mode
)
611 struct evdev_client
*client
= file
->private_data
;
612 struct evdev
*evdev
= client
->evdev
;
613 struct input_dev
*dev
= evdev
->handle
.dev
;
614 struct input_absinfo abs
;
615 struct ff_effect effect
;
616 int __user
*ip
= (int __user
*)p
;
617 unsigned int i
, t
, u
, v
;
621 /* First we check for fixed-length commands */
625 return put_user(EV_VERSION
, ip
);
628 if (copy_to_user(p
, &dev
->id
, sizeof(struct input_id
)))
633 if (!test_bit(EV_REP
, dev
->evbit
))
635 if (put_user(dev
->rep
[REP_DELAY
], ip
))
637 if (put_user(dev
->rep
[REP_PERIOD
], ip
+ 1))
642 if (!test_bit(EV_REP
, dev
->evbit
))
646 if (get_user(v
, ip
+ 1))
649 input_inject_event(&evdev
->handle
, EV_REP
, REP_DELAY
, u
);
650 input_inject_event(&evdev
->handle
, EV_REP
, REP_PERIOD
, v
);
655 return input_ff_erase(dev
, (int)(unsigned long) p
, file
);
658 i
= test_bit(EV_FF
, dev
->evbit
) ?
659 dev
->ff
->max_effects
: 0;
666 return evdev_grab(evdev
, client
);
668 return evdev_ungrab(evdev
, client
);
671 return evdev_handle_get_keycode(dev
, p
);
674 return evdev_handle_set_keycode(dev
, p
);
676 case EVIOCGKEYCODE_V2
:
677 return evdev_handle_get_keycode_v2(dev
, p
);
679 case EVIOCSKEYCODE_V2
:
680 return evdev_handle_set_keycode_v2(dev
, p
);
683 size
= _IOC_SIZE(cmd
);
685 /* Now check variable-length commands */
686 #define EVIOC_MASK_SIZE(nr) ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
687 switch (EVIOC_MASK_SIZE(cmd
)) {
690 return bits_to_user(dev
->key
, KEY_MAX
, size
, p
, compat_mode
);
693 return bits_to_user(dev
->led
, LED_MAX
, size
, p
, compat_mode
);
696 return bits_to_user(dev
->snd
, SND_MAX
, size
, p
, compat_mode
);
699 return bits_to_user(dev
->sw
, SW_MAX
, size
, p
, compat_mode
);
702 return str_to_user(dev
->name
, size
, p
);
705 return str_to_user(dev
->phys
, size
, p
);
708 return str_to_user(dev
->uniq
, size
, p
);
710 case EVIOC_MASK_SIZE(EVIOCSFF
):
711 if (input_ff_effect_from_user(p
, size
, &effect
))
714 error
= input_ff_upload(dev
, &effect
, file
);
716 if (put_user(effect
.id
, &(((struct ff_effect __user
*)p
)->id
)))
722 /* Multi-number variable-length handlers */
723 if (_IOC_TYPE(cmd
) != 'E')
726 if (_IOC_DIR(cmd
) == _IOC_READ
) {
728 if ((_IOC_NR(cmd
) & ~EV_MAX
) == _IOC_NR(EVIOCGBIT(0, 0)))
729 return handle_eviocgbit(dev
,
730 _IOC_NR(cmd
) & EV_MAX
, size
,
733 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCGABS(0))) {
738 t
= _IOC_NR(cmd
) & ABS_MAX
;
739 abs
= dev
->absinfo
[t
];
741 if (copy_to_user(p
, &abs
, min_t(size_t,
742 size
, sizeof(struct input_absinfo
))))
749 if (_IOC_DIR(cmd
) == _IOC_WRITE
) {
751 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCSABS(0))) {
756 t
= _IOC_NR(cmd
) & ABS_MAX
;
758 if (copy_from_user(&abs
, p
, min_t(size_t,
759 size
, sizeof(struct input_absinfo
))))
762 if (size
< sizeof(struct input_absinfo
))
765 /* We can't change number of reserved MT slots */
766 if (t
== ABS_MT_SLOT
)
770 * Take event lock to ensure that we are not
771 * changing device parameters in the middle
774 spin_lock_irq(&dev
->event_lock
);
775 dev
->absinfo
[t
] = abs
;
776 spin_unlock_irq(&dev
->event_lock
);
785 static long evdev_ioctl_handler(struct file
*file
, unsigned int cmd
,
786 void __user
*p
, int compat_mode
)
788 struct evdev_client
*client
= file
->private_data
;
789 struct evdev
*evdev
= client
->evdev
;
792 retval
= mutex_lock_interruptible(&evdev
->mutex
);
801 retval
= evdev_do_ioctl(file
, cmd
, p
, compat_mode
);
804 mutex_unlock(&evdev
->mutex
);
808 static long evdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
810 return evdev_ioctl_handler(file
, cmd
, (void __user
*)arg
, 0);
814 static long evdev_ioctl_compat(struct file
*file
,
815 unsigned int cmd
, unsigned long arg
)
817 return evdev_ioctl_handler(file
, cmd
, compat_ptr(arg
), 1);
821 static const struct file_operations evdev_fops
= {
822 .owner
= THIS_MODULE
,
824 .write
= evdev_write
,
827 .release
= evdev_release
,
828 .unlocked_ioctl
= evdev_ioctl
,
830 .compat_ioctl
= evdev_ioctl_compat
,
832 .fasync
= evdev_fasync
,
833 .flush
= evdev_flush
,
837 static int evdev_install_chrdev(struct evdev
*evdev
)
840 * No need to do any locking here as calls to connect and
841 * disconnect are serialized by the input core
843 evdev_table
[evdev
->minor
] = evdev
;
847 static void evdev_remove_chrdev(struct evdev
*evdev
)
850 * Lock evdev table to prevent race with evdev_open()
852 mutex_lock(&evdev_table_mutex
);
853 evdev_table
[evdev
->minor
] = NULL
;
854 mutex_unlock(&evdev_table_mutex
);
858 * Mark device non-existent. This disables writes, ioctls and
859 * prevents new users from opening the device. Already posted
860 * blocking reads will stay, however new ones will fail.
862 static void evdev_mark_dead(struct evdev
*evdev
)
864 mutex_lock(&evdev
->mutex
);
865 evdev
->exist
= false;
866 mutex_unlock(&evdev
->mutex
);
869 static void evdev_cleanup(struct evdev
*evdev
)
871 struct input_handle
*handle
= &evdev
->handle
;
873 evdev_mark_dead(evdev
);
875 evdev_remove_chrdev(evdev
);
877 /* evdev is marked dead so no one else accesses evdev->open */
879 input_flush_device(handle
, NULL
);
880 input_close_device(handle
);
885 * Create new evdev device. Note that input core serializes calls
886 * to connect and disconnect so we don't need to lock evdev_table here.
888 static int evdev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
889 const struct input_device_id
*id
)
895 for (minor
= 0; minor
< EVDEV_MINORS
; minor
++)
896 if (!evdev_table
[minor
])
899 if (minor
== EVDEV_MINORS
) {
900 printk(KERN_ERR
"evdev: no more free evdev devices\n");
904 evdev
= kzalloc(sizeof(struct evdev
), GFP_KERNEL
);
908 INIT_LIST_HEAD(&evdev
->client_list
);
909 spin_lock_init(&evdev
->client_lock
);
910 mutex_init(&evdev
->mutex
);
911 init_waitqueue_head(&evdev
->wait
);
913 dev_set_name(&evdev
->dev
, "event%d", minor
);
915 evdev
->minor
= minor
;
917 evdev
->handle
.dev
= input_get_device(dev
);
918 evdev
->handle
.name
= dev_name(&evdev
->dev
);
919 evdev
->handle
.handler
= handler
;
920 evdev
->handle
.private = evdev
;
922 evdev
->dev
.devt
= MKDEV(INPUT_MAJOR
, EVDEV_MINOR_BASE
+ minor
);
923 evdev
->dev
.class = &input_class
;
924 evdev
->dev
.parent
= &dev
->dev
;
925 evdev
->dev
.release
= evdev_free
;
926 device_initialize(&evdev
->dev
);
928 error
= input_register_handle(&evdev
->handle
);
932 error
= evdev_install_chrdev(evdev
);
934 goto err_unregister_handle
;
936 error
= device_add(&evdev
->dev
);
938 goto err_cleanup_evdev
;
943 evdev_cleanup(evdev
);
944 err_unregister_handle
:
945 input_unregister_handle(&evdev
->handle
);
947 put_device(&evdev
->dev
);
951 static void evdev_disconnect(struct input_handle
*handle
)
953 struct evdev
*evdev
= handle
->private;
955 device_del(&evdev
->dev
);
956 evdev_cleanup(evdev
);
957 input_unregister_handle(handle
);
958 put_device(&evdev
->dev
);
961 static const struct input_device_id evdev_ids
[] = {
962 { .driver_info
= 1 }, /* Matches all devices */
963 { }, /* Terminating zero entry */
966 MODULE_DEVICE_TABLE(input
, evdev_ids
);
968 static struct input_handler evdev_handler
= {
969 .event
= evdev_event
,
970 .connect
= evdev_connect
,
971 .disconnect
= evdev_disconnect
,
973 .minor
= EVDEV_MINOR_BASE
,
975 .id_table
= evdev_ids
,
978 static int __init
evdev_init(void)
980 return input_register_handler(&evdev_handler
);
983 static void __exit
evdev_exit(void)
985 input_unregister_handler(&evdev_handler
);
988 module_init(evdev_init
);
989 module_exit(evdev_exit
);
991 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
992 MODULE_DESCRIPTION("Input driver event char devices");
993 MODULE_LICENSE("GPL");