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_BUFFER_SIZE 64
15 #include <linux/poll.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/input.h>
20 #include <linux/major.h>
21 #include <linux/device.h>
22 #include <linux/compat.h>
29 struct input_handle handle
;
30 wait_queue_head_t wait
;
32 struct list_head client_list
;
33 spinlock_t client_lock
; /* protects client_list */
39 struct input_event buffer
[EVDEV_BUFFER_SIZE
];
43 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
44 struct fasync_struct
*fasync
;
46 struct list_head node
;
49 static struct evdev
*evdev_table
[EVDEV_MINORS
];
50 static DEFINE_MUTEX(evdev_table_mutex
);
52 static void evdev_pass_event(struct evdev_client
*client
,
53 struct input_event
*event
)
56 * Interrupts are disabled, just acquire the lock
58 spin_lock(&client
->buffer_lock
);
59 client
->buffer
[client
->head
++] = *event
;
60 client
->head
&= EVDEV_BUFFER_SIZE
- 1;
61 spin_unlock(&client
->buffer_lock
);
63 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
67 * Pass incoming event to all connected clients.
69 static void evdev_event(struct input_handle
*handle
,
70 unsigned int type
, unsigned int code
, int value
)
72 struct evdev
*evdev
= handle
->private;
73 struct evdev_client
*client
;
74 struct input_event event
;
76 do_gettimeofday(&event
.time
);
83 list_for_each_entry_rcu(client
, &evdev
->client_list
, node
)
84 evdev_pass_event(client
, &event
);
88 wake_up_interruptible(&evdev
->wait
);
91 static int evdev_fasync(int fd
, struct file
*file
, int on
)
93 struct evdev_client
*client
= file
->private_data
;
96 retval
= fasync_helper(fd
, file
, on
, &client
->fasync
);
98 return retval
< 0 ? retval
: 0;
101 static int evdev_flush(struct file
*file
, fl_owner_t id
)
103 struct evdev_client
*client
= file
->private_data
;
104 struct evdev
*evdev
= client
->evdev
;
107 retval
= mutex_lock_interruptible(&evdev
->mutex
);
114 retval
= input_flush_device(&evdev
->handle
, file
);
116 mutex_unlock(&evdev
->mutex
);
120 static void evdev_free(struct device
*dev
)
122 struct evdev
*evdev
= container_of(dev
, struct evdev
, dev
);
128 * Grabs an event device (along with underlying input device).
129 * This function is called with evdev->mutex taken.
131 static int evdev_grab(struct evdev
*evdev
, struct evdev_client
*client
)
138 if (!evdev
->grab
++) {
139 error
= input_grab_device(&evdev
->handle
);
149 static int evdev_ungrab(struct evdev
*evdev
, struct evdev_client
*client
)
154 if (!--evdev
->grab
&& evdev
->exist
)
155 input_release_device(&evdev
->handle
);
161 static void evdev_attach_client(struct evdev
*evdev
,
162 struct evdev_client
*client
)
164 spin_lock(&evdev
->client_lock
);
165 list_add_tail_rcu(&client
->node
, &evdev
->client_list
);
166 spin_unlock(&evdev
->client_lock
);
170 static void evdev_detach_client(struct evdev
*evdev
,
171 struct evdev_client
*client
)
173 spin_lock(&evdev
->client_lock
);
174 list_del_rcu(&client
->node
);
175 spin_unlock(&evdev
->client_lock
);
179 static int evdev_open_device(struct evdev
*evdev
)
183 retval
= mutex_lock_interruptible(&evdev
->mutex
);
189 else if (!evdev
->open
++) {
190 retval
= input_open_device(&evdev
->handle
);
195 mutex_unlock(&evdev
->mutex
);
199 static void evdev_close_device(struct evdev
*evdev
)
201 mutex_lock(&evdev
->mutex
);
203 if (evdev
->exist
&& !--evdev
->open
)
204 input_close_device(&evdev
->handle
);
206 mutex_unlock(&evdev
->mutex
);
210 * Wake up users waiting for IO so they can disconnect from
213 static void evdev_hangup(struct evdev
*evdev
)
215 struct evdev_client
*client
;
217 spin_lock(&evdev
->client_lock
);
218 list_for_each_entry(client
, &evdev
->client_list
, node
)
219 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
220 spin_unlock(&evdev
->client_lock
);
222 wake_up_interruptible(&evdev
->wait
);
225 static int evdev_release(struct inode
*inode
, struct file
*file
)
227 struct evdev_client
*client
= file
->private_data
;
228 struct evdev
*evdev
= client
->evdev
;
230 mutex_lock(&evdev
->mutex
);
232 evdev_ungrab(evdev
, client
);
233 mutex_unlock(&evdev
->mutex
);
235 evdev_fasync(-1, file
, 0);
236 evdev_detach_client(evdev
, client
);
239 evdev_close_device(evdev
);
240 put_device(&evdev
->dev
);
245 static int evdev_open(struct inode
*inode
, struct file
*file
)
248 struct evdev_client
*client
;
249 int i
= iminor(inode
) - EVDEV_MINOR_BASE
;
252 if (i
>= EVDEV_MINORS
)
255 error
= mutex_lock_interruptible(&evdev_table_mutex
);
258 evdev
= evdev_table
[i
];
260 get_device(&evdev
->dev
);
261 mutex_unlock(&evdev_table_mutex
);
266 client
= kzalloc(sizeof(struct evdev_client
), GFP_KERNEL
);
272 spin_lock_init(&client
->buffer_lock
);
273 client
->evdev
= evdev
;
274 evdev_attach_client(evdev
, client
);
276 error
= evdev_open_device(evdev
);
278 goto err_free_client
;
280 file
->private_data
= client
;
284 evdev_detach_client(evdev
, client
);
287 put_device(&evdev
->dev
);
293 struct input_event_compat
{
294 struct compat_timeval time
;
300 /* Note to the author of this code: did it ever occur to
301 you why the ifdefs are needed? Think about it again. -AK */
303 # define COMPAT_TEST is_compat_task()
304 #elif defined(CONFIG_IA64)
305 # define COMPAT_TEST IS_IA32_PROCESS(task_pt_regs(current))
306 #elif defined(CONFIG_S390)
307 # define COMPAT_TEST test_thread_flag(TIF_31BIT)
308 #elif defined(CONFIG_MIPS)
309 # define COMPAT_TEST test_thread_flag(TIF_32BIT_ADDR)
311 # define COMPAT_TEST test_thread_flag(TIF_32BIT)
314 static inline size_t evdev_event_size(void)
317 sizeof(struct input_event_compat
) : sizeof(struct input_event
);
320 static int evdev_event_from_user(const char __user
*buffer
,
321 struct input_event
*event
)
324 struct input_event_compat compat_event
;
326 if (copy_from_user(&compat_event
, buffer
,
327 sizeof(struct input_event_compat
)))
330 event
->time
.tv_sec
= compat_event
.time
.tv_sec
;
331 event
->time
.tv_usec
= compat_event
.time
.tv_usec
;
332 event
->type
= compat_event
.type
;
333 event
->code
= compat_event
.code
;
334 event
->value
= compat_event
.value
;
337 if (copy_from_user(event
, buffer
, sizeof(struct input_event
)))
344 static int evdev_event_to_user(char __user
*buffer
,
345 const struct input_event
*event
)
348 struct input_event_compat compat_event
;
350 compat_event
.time
.tv_sec
= event
->time
.tv_sec
;
351 compat_event
.time
.tv_usec
= event
->time
.tv_usec
;
352 compat_event
.type
= event
->type
;
353 compat_event
.code
= event
->code
;
354 compat_event
.value
= event
->value
;
356 if (copy_to_user(buffer
, &compat_event
,
357 sizeof(struct input_event_compat
)))
361 if (copy_to_user(buffer
, event
, sizeof(struct input_event
)))
370 static inline size_t evdev_event_size(void)
372 return sizeof(struct input_event
);
375 static int evdev_event_from_user(const char __user
*buffer
,
376 struct input_event
*event
)
378 if (copy_from_user(event
, buffer
, sizeof(struct input_event
)))
384 static int evdev_event_to_user(char __user
*buffer
,
385 const struct input_event
*event
)
387 if (copy_to_user(buffer
, event
, sizeof(struct input_event
)))
393 #endif /* CONFIG_COMPAT */
395 static ssize_t
evdev_write(struct file
*file
, const char __user
*buffer
,
396 size_t count
, loff_t
*ppos
)
398 struct evdev_client
*client
= file
->private_data
;
399 struct evdev
*evdev
= client
->evdev
;
400 struct input_event event
;
403 retval
= mutex_lock_interruptible(&evdev
->mutex
);
412 while (retval
< count
) {
414 if (evdev_event_from_user(buffer
+ retval
, &event
)) {
419 input_inject_event(&evdev
->handle
,
420 event
.type
, event
.code
, event
.value
);
421 retval
+= evdev_event_size();
425 mutex_unlock(&evdev
->mutex
);
429 static int evdev_fetch_next_event(struct evdev_client
*client
,
430 struct input_event
*event
)
434 spin_lock_irq(&client
->buffer_lock
);
436 have_event
= client
->head
!= client
->tail
;
438 *event
= client
->buffer
[client
->tail
++];
439 client
->tail
&= EVDEV_BUFFER_SIZE
- 1;
442 spin_unlock_irq(&client
->buffer_lock
);
447 static ssize_t
evdev_read(struct file
*file
, char __user
*buffer
,
448 size_t count
, loff_t
*ppos
)
450 struct evdev_client
*client
= file
->private_data
;
451 struct evdev
*evdev
= client
->evdev
;
452 struct input_event event
;
455 if (count
< evdev_event_size())
458 if (client
->head
== client
->tail
&& evdev
->exist
&&
459 (file
->f_flags
& O_NONBLOCK
))
462 retval
= wait_event_interruptible(evdev
->wait
,
463 client
->head
!= client
->tail
|| !evdev
->exist
);
470 while (retval
+ evdev_event_size() <= count
&&
471 evdev_fetch_next_event(client
, &event
)) {
473 if (evdev_event_to_user(buffer
+ retval
, &event
))
476 retval
+= evdev_event_size();
482 /* No kernel lock - fine */
483 static unsigned int evdev_poll(struct file
*file
, poll_table
*wait
)
485 struct evdev_client
*client
= file
->private_data
;
486 struct evdev
*evdev
= client
->evdev
;
488 poll_wait(file
, &evdev
->wait
, wait
);
489 return ((client
->head
== client
->tail
) ? 0 : (POLLIN
| POLLRDNORM
)) |
490 (evdev
->exist
? 0 : (POLLHUP
| POLLERR
));
495 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
496 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
499 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
500 unsigned int maxlen
, void __user
*p
, int compat
)
505 len
= BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
);
509 for (i
= 0; i
< len
/ sizeof(compat_long_t
); i
++)
510 if (copy_to_user((compat_long_t __user
*) p
+ i
,
511 (compat_long_t
*) bits
+
512 i
+ 1 - ((i
% 2) << 1),
513 sizeof(compat_long_t
)))
516 len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
520 if (copy_to_user(p
, bits
, len
))
527 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
528 unsigned int maxlen
, void __user
*p
, int compat
)
531 BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
) :
532 BITS_TO_LONGS(maxbit
) * sizeof(long);
537 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
539 #endif /* __BIG_ENDIAN */
543 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
544 unsigned int maxlen
, void __user
*p
, int compat
)
546 int len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
551 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
554 #endif /* CONFIG_COMPAT */
556 static int str_to_user(const char *str
, unsigned int maxlen
, void __user
*p
)
563 len
= strlen(str
) + 1;
567 return copy_to_user(p
, str
, len
) ? -EFAULT
: len
;
570 static long evdev_do_ioctl(struct file
*file
, unsigned int cmd
,
571 void __user
*p
, int compat_mode
)
573 struct evdev_client
*client
= file
->private_data
;
574 struct evdev
*evdev
= client
->evdev
;
575 struct input_dev
*dev
= evdev
->handle
.dev
;
576 struct input_absinfo abs
;
577 struct ff_effect effect
;
578 int __user
*ip
= (int __user
*)p
;
585 return put_user(EV_VERSION
, ip
);
588 if (copy_to_user(p
, &dev
->id
, sizeof(struct input_id
)))
593 if (!test_bit(EV_REP
, dev
->evbit
))
595 if (put_user(dev
->rep
[REP_DELAY
], ip
))
597 if (put_user(dev
->rep
[REP_PERIOD
], ip
+ 1))
602 if (!test_bit(EV_REP
, dev
->evbit
))
606 if (get_user(v
, ip
+ 1))
609 input_inject_event(&evdev
->handle
, EV_REP
, REP_DELAY
, u
);
610 input_inject_event(&evdev
->handle
, EV_REP
, REP_PERIOD
, v
);
618 error
= dev
->getkeycode(dev
, t
, &v
);
622 if (put_user(v
, ip
+ 1))
628 if (get_user(t
, ip
) || get_user(v
, ip
+ 1))
631 return dev
->setkeycode(dev
, t
, v
);
634 if (copy_from_user(&effect
, p
, sizeof(effect
)))
637 error
= input_ff_upload(dev
, &effect
, file
);
639 if (put_user(effect
.id
, &(((struct ff_effect __user
*)p
)->id
)))
645 return input_ff_erase(dev
, (int)(unsigned long) p
, file
);
648 i
= test_bit(EV_FF
, dev
->evbit
) ?
649 dev
->ff
->max_effects
: 0;
656 return evdev_grab(evdev
, client
);
658 return evdev_ungrab(evdev
, client
);
662 if (_IOC_TYPE(cmd
) != 'E')
665 if (_IOC_DIR(cmd
) == _IOC_READ
) {
667 if ((_IOC_NR(cmd
) & ~EV_MAX
) == _IOC_NR(EVIOCGBIT(0, 0))) {
672 switch (_IOC_NR(cmd
) & EV_MAX
) {
674 case 0: bits
= dev
->evbit
; len
= EV_MAX
; break;
675 case EV_KEY
: bits
= dev
->keybit
; len
= KEY_MAX
; break;
676 case EV_REL
: bits
= dev
->relbit
; len
= REL_MAX
; break;
677 case EV_ABS
: bits
= dev
->absbit
; len
= ABS_MAX
; break;
678 case EV_MSC
: bits
= dev
->mscbit
; len
= MSC_MAX
; break;
679 case EV_LED
: bits
= dev
->ledbit
; len
= LED_MAX
; break;
680 case EV_SND
: bits
= dev
->sndbit
; len
= SND_MAX
; break;
681 case EV_FF
: bits
= dev
->ffbit
; len
= FF_MAX
; break;
682 case EV_SW
: bits
= dev
->swbit
; len
= SW_MAX
; break;
683 default: return -EINVAL
;
685 return bits_to_user(bits
, len
, _IOC_SIZE(cmd
), p
, compat_mode
);
688 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGKEY(0)))
689 return bits_to_user(dev
->key
, KEY_MAX
, _IOC_SIZE(cmd
),
692 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGLED(0)))
693 return bits_to_user(dev
->led
, LED_MAX
, _IOC_SIZE(cmd
),
696 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGSND(0)))
697 return bits_to_user(dev
->snd
, SND_MAX
, _IOC_SIZE(cmd
),
700 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGSW(0)))
701 return bits_to_user(dev
->sw
, SW_MAX
, _IOC_SIZE(cmd
),
704 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGNAME(0)))
705 return str_to_user(dev
->name
, _IOC_SIZE(cmd
), p
);
707 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGPHYS(0)))
708 return str_to_user(dev
->phys
, _IOC_SIZE(cmd
), p
);
710 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGUNIQ(0)))
711 return str_to_user(dev
->uniq
, _IOC_SIZE(cmd
), p
);
713 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCGABS(0))) {
715 t
= _IOC_NR(cmd
) & ABS_MAX
;
717 abs
.value
= dev
->abs
[t
];
718 abs
.minimum
= dev
->absmin
[t
];
719 abs
.maximum
= dev
->absmax
[t
];
720 abs
.fuzz
= dev
->absfuzz
[t
];
721 abs
.flat
= dev
->absflat
[t
];
723 if (copy_to_user(p
, &abs
, sizeof(struct input_absinfo
)))
731 if (_IOC_DIR(cmd
) == _IOC_WRITE
) {
733 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCSABS(0))) {
735 t
= _IOC_NR(cmd
) & ABS_MAX
;
737 if (copy_from_user(&abs
, p
,
738 sizeof(struct input_absinfo
)))
742 * Take event lock to ensure that we are not
743 * changing device parameters in the middle
746 spin_lock_irq(&dev
->event_lock
);
748 dev
->abs
[t
] = abs
.value
;
749 dev
->absmin
[t
] = abs
.minimum
;
750 dev
->absmax
[t
] = abs
.maximum
;
751 dev
->absfuzz
[t
] = abs
.fuzz
;
752 dev
->absflat
[t
] = abs
.flat
;
754 spin_unlock_irq(&dev
->event_lock
);
763 static long evdev_ioctl_handler(struct file
*file
, unsigned int cmd
,
764 void __user
*p
, int compat_mode
)
766 struct evdev_client
*client
= file
->private_data
;
767 struct evdev
*evdev
= client
->evdev
;
770 retval
= mutex_lock_interruptible(&evdev
->mutex
);
779 retval
= evdev_do_ioctl(file
, cmd
, p
, compat_mode
);
782 mutex_unlock(&evdev
->mutex
);
786 static long evdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
788 return evdev_ioctl_handler(file
, cmd
, (void __user
*)arg
, 0);
792 static long evdev_ioctl_compat(struct file
*file
,
793 unsigned int cmd
, unsigned long arg
)
795 return evdev_ioctl_handler(file
, cmd
, compat_ptr(arg
), 1);
799 static const struct file_operations evdev_fops
= {
800 .owner
= THIS_MODULE
,
802 .write
= evdev_write
,
805 .release
= evdev_release
,
806 .unlocked_ioctl
= evdev_ioctl
,
808 .compat_ioctl
= evdev_ioctl_compat
,
810 .fasync
= evdev_fasync
,
814 static int evdev_install_chrdev(struct evdev
*evdev
)
817 * No need to do any locking here as calls to connect and
818 * disconnect are serialized by the input core
820 evdev_table
[evdev
->minor
] = evdev
;
824 static void evdev_remove_chrdev(struct evdev
*evdev
)
827 * Lock evdev table to prevent race with evdev_open()
829 mutex_lock(&evdev_table_mutex
);
830 evdev_table
[evdev
->minor
] = NULL
;
831 mutex_unlock(&evdev_table_mutex
);
835 * Mark device non-existent. This disables writes, ioctls and
836 * prevents new users from opening the device. Already posted
837 * blocking reads will stay, however new ones will fail.
839 static void evdev_mark_dead(struct evdev
*evdev
)
841 mutex_lock(&evdev
->mutex
);
843 mutex_unlock(&evdev
->mutex
);
846 static void evdev_cleanup(struct evdev
*evdev
)
848 struct input_handle
*handle
= &evdev
->handle
;
850 evdev_mark_dead(evdev
);
852 evdev_remove_chrdev(evdev
);
854 /* evdev is marked dead so no one else accesses evdev->open */
856 input_flush_device(handle
, NULL
);
857 input_close_device(handle
);
862 * Create new evdev device. Note that input core serializes calls
863 * to connect and disconnect so we don't need to lock evdev_table here.
865 static int evdev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
866 const struct input_device_id
*id
)
872 for (minor
= 0; minor
< EVDEV_MINORS
; minor
++)
873 if (!evdev_table
[minor
])
876 if (minor
== EVDEV_MINORS
) {
877 printk(KERN_ERR
"evdev: no more free evdev devices\n");
881 evdev
= kzalloc(sizeof(struct evdev
), GFP_KERNEL
);
885 INIT_LIST_HEAD(&evdev
->client_list
);
886 spin_lock_init(&evdev
->client_lock
);
887 mutex_init(&evdev
->mutex
);
888 init_waitqueue_head(&evdev
->wait
);
890 snprintf(evdev
->name
, sizeof(evdev
->name
), "event%d", minor
);
892 evdev
->minor
= minor
;
894 evdev
->handle
.dev
= dev
;
895 evdev
->handle
.name
= evdev
->name
;
896 evdev
->handle
.handler
= handler
;
897 evdev
->handle
.private = evdev
;
899 strlcpy(evdev
->dev
.bus_id
, evdev
->name
, sizeof(evdev
->dev
.bus_id
));
900 evdev
->dev
.devt
= MKDEV(INPUT_MAJOR
, EVDEV_MINOR_BASE
+ minor
);
901 evdev
->dev
.class = &input_class
;
902 evdev
->dev
.parent
= &dev
->dev
;
903 evdev
->dev
.release
= evdev_free
;
904 device_initialize(&evdev
->dev
);
906 error
= input_register_handle(&evdev
->handle
);
910 error
= evdev_install_chrdev(evdev
);
912 goto err_unregister_handle
;
914 error
= device_add(&evdev
->dev
);
916 goto err_cleanup_evdev
;
921 evdev_cleanup(evdev
);
922 err_unregister_handle
:
923 input_unregister_handle(&evdev
->handle
);
925 put_device(&evdev
->dev
);
929 static void evdev_disconnect(struct input_handle
*handle
)
931 struct evdev
*evdev
= handle
->private;
933 device_del(&evdev
->dev
);
934 evdev_cleanup(evdev
);
935 input_unregister_handle(handle
);
936 put_device(&evdev
->dev
);
939 static const struct input_device_id evdev_ids
[] = {
940 { .driver_info
= 1 }, /* Matches all devices */
941 { }, /* Terminating zero entry */
944 MODULE_DEVICE_TABLE(input
, evdev_ids
);
946 static struct input_handler evdev_handler
= {
947 .event
= evdev_event
,
948 .connect
= evdev_connect
,
949 .disconnect
= evdev_disconnect
,
951 .minor
= EVDEV_MINOR_BASE
,
953 .id_table
= evdev_ids
,
956 static int __init
evdev_init(void)
958 return input_register_handler(&evdev_handler
);
961 static void __exit
evdev_exit(void)
963 input_unregister_handler(&evdev_handler
);
966 module_init(evdev_init
);
967 module_exit(evdev_exit
);
969 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
970 MODULE_DESCRIPTION("Input driver event char devices");
971 MODULE_LICENSE("GPL");