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 "input-compat.h"
28 struct input_handle handle;
29 wait_queue_head_t wait;
30 struct evdev_client *grab;
31 struct list_head client_list;
32 spinlock_t client_lock; /* protects client_list */
38 struct input_event buffer[EVDEV_BUFFER_SIZE];
41 spinlock_t buffer_lock; /* protects access to buffer, head and tail */
42 struct fasync_struct *fasync;
44 struct list_head node;
47 static struct evdev *evdev_table[EVDEV_MINORS];
48 static DEFINE_MUTEX(evdev_table_mutex);
50 static void evdev_pass_event(struct evdev_client *client,
51 struct input_event *event)
54 * Interrupts are disabled, just acquire the lock
56 spin_lock(&client->buffer_lock);
57 client->buffer[client->head++] = *event;
58 client->head &= EVDEV_BUFFER_SIZE - 1;
59 spin_unlock(&client->buffer_lock);
61 kill_fasync(&client->fasync, SIGIO, POLL_IN);
65 * Pass incoming event to all connected clients.
67 static void evdev_event(struct input_handle *handle,
68 unsigned int type, unsigned int code, int value)
70 struct evdev *evdev = handle->private;
71 struct evdev_client *client;
72 struct input_event event;
74 do_gettimeofday(&event.time);
81 client = rcu_dereference(evdev->grab);
83 evdev_pass_event(client, &event);
85 list_for_each_entry_rcu(client, &evdev->client_list, node)
86 evdev_pass_event(client, &event);
90 wake_up_interruptible(&evdev->wait);
93 static int evdev_fasync(int fd, struct file *file, int on)
95 struct evdev_client *client = file->private_data;
97 return fasync_helper(fd, file, on, &client->fasync);
100 static int evdev_flush(struct file *file, fl_owner_t id)
102 struct evdev_client *client = file->private_data;
103 struct evdev *evdev = client->evdev;
106 retval = mutex_lock_interruptible(&evdev->mutex);
113 retval = input_flush_device(&evdev->handle, file);
115 mutex_unlock(&evdev->mutex);
119 static void evdev_free(struct device *dev)
121 struct evdev *evdev = container_of(dev, struct evdev, dev);
123 input_put_device(evdev->handle.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 error = input_grab_device(&evdev->handle);
142 rcu_assign_pointer(evdev->grab, client);
148 static int evdev_ungrab(struct evdev *evdev, struct evdev_client *client)
150 if (evdev->grab != client)
153 rcu_assign_pointer(evdev->grab, NULL);
155 input_release_device(&evdev->handle);
160 static void evdev_attach_client(struct evdev *evdev,
161 struct evdev_client *client)
163 spin_lock(&evdev->client_lock);
164 list_add_tail_rcu(&client->node, &evdev->client_list);
165 spin_unlock(&evdev->client_lock);
169 static void evdev_detach_client(struct evdev *evdev,
170 struct evdev_client *client)
172 spin_lock(&evdev->client_lock);
173 list_del_rcu(&client->node);
174 spin_unlock(&evdev->client_lock);
178 static int evdev_open_device(struct evdev *evdev)
182 retval = mutex_lock_interruptible(&evdev->mutex);
188 else if (!evdev->open++) {
189 retval = input_open_device(&evdev->handle);
194 mutex_unlock(&evdev->mutex);
198 static void evdev_close_device(struct evdev *evdev)
200 mutex_lock(&evdev->mutex);
202 if (evdev->exist && !--evdev->open)
203 input_close_device(&evdev->handle);
205 mutex_unlock(&evdev->mutex);
209 * Wake up users waiting for IO so they can disconnect from
212 static void evdev_hangup(struct evdev *evdev)
214 struct evdev_client *client;
216 spin_lock(&evdev->client_lock);
217 list_for_each_entry(client, &evdev->client_list, node)
218 kill_fasync(&client->fasync, SIGIO, POLL_HUP);
219 spin_unlock(&evdev->client_lock);
221 wake_up_interruptible(&evdev->wait);
224 static int evdev_release(struct inode *inode, struct file *file)
226 struct evdev_client *client = file->private_data;
227 struct evdev *evdev = client->evdev;
229 mutex_lock(&evdev->mutex);
230 if (evdev->grab == client)
231 evdev_ungrab(evdev, client);
232 mutex_unlock(&evdev->mutex);
234 evdev_detach_client(evdev, client);
237 evdev_close_device(evdev);
238 put_device(&evdev->dev);
243 static int evdev_open(struct inode *inode, struct file *file)
246 struct evdev_client *client;
247 int i = iminor(inode) - EVDEV_MINOR_BASE;
250 if (i >= EVDEV_MINORS)
253 error = mutex_lock_interruptible(&evdev_table_mutex);
256 evdev = evdev_table[i];
258 get_device(&evdev->dev);
259 mutex_unlock(&evdev_table_mutex);
264 client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
270 spin_lock_init(&client->buffer_lock);
271 client->evdev = evdev;
272 evdev_attach_client(evdev, client);
274 error = evdev_open_device(evdev);
276 goto err_free_client;
278 file->private_data = client;
282 evdev_detach_client(evdev, client);
285 put_device(&evdev->dev);
289 static ssize_t evdev_write(struct file *file, const char __user *buffer,
290 size_t count, loff_t *ppos)
292 struct evdev_client *client = file->private_data;
293 struct evdev *evdev = client->evdev;
294 struct input_event event;
297 retval = mutex_lock_interruptible(&evdev->mutex);
306 while (retval < count) {
308 if (input_event_from_user(buffer + retval, &event)) {
313 input_inject_event(&evdev->handle,
314 event.type, event.code, event.value);
315 retval += input_event_size();
319 mutex_unlock(&evdev->mutex);
323 static int evdev_fetch_next_event(struct evdev_client *client,
324 struct input_event *event)
328 spin_lock_irq(&client->buffer_lock);
330 have_event = client->head != client->tail;
332 *event = client->buffer[client->tail++];
333 client->tail &= EVDEV_BUFFER_SIZE - 1;
336 spin_unlock_irq(&client->buffer_lock);
341 static ssize_t evdev_read(struct file *file, char __user *buffer,
342 size_t count, loff_t *ppos)
344 struct evdev_client *client = file->private_data;
345 struct evdev *evdev = client->evdev;
346 struct input_event event;
349 if (count < input_event_size())
352 if (client->head == client->tail && evdev->exist &&
353 (file->f_flags & O_NONBLOCK))
356 retval = wait_event_interruptible(evdev->wait,
357 client->head != client->tail || !evdev->exist);
364 while (retval + input_event_size() <= count &&
365 evdev_fetch_next_event(client, &event)) {
367 if (input_event_to_user(buffer + retval, &event))
370 retval += input_event_size();
376 /* No kernel lock - fine */
377 static unsigned int evdev_poll(struct file *file, poll_table *wait)
379 struct evdev_client *client = file->private_data;
380 struct evdev *evdev = client->evdev;
382 poll_wait(file, &evdev->wait, wait);
383 return ((client->head == client->tail) ? 0 : (POLLIN | POLLRDNORM)) |
384 (evdev->exist ? 0 : (POLLHUP | POLLERR));
389 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
390 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
393 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
394 unsigned int maxlen, void __user *p, int compat)
399 len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
403 for (i = 0; i < len / sizeof(compat_long_t); i++)
404 if (copy_to_user((compat_long_t __user *) p + i,
405 (compat_long_t *) bits +
406 i + 1 - ((i % 2) << 1),
407 sizeof(compat_long_t)))
410 len = BITS_TO_LONGS(maxbit) * sizeof(long);
414 if (copy_to_user(p, bits, len))
421 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
422 unsigned int maxlen, void __user *p, int compat)
425 BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t) :
426 BITS_TO_LONGS(maxbit) * sizeof(long);
431 return copy_to_user(p, bits, len) ? -EFAULT : len;
433 #endif /* __BIG_ENDIAN */
437 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
438 unsigned int maxlen, void __user *p, int compat)
440 int len = BITS_TO_LONGS(maxbit) * sizeof(long);
445 return copy_to_user(p, bits, len) ? -EFAULT : len;
448 #endif /* CONFIG_COMPAT */
450 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
457 len = strlen(str) + 1;
461 return copy_to_user(p, str, len) ? -EFAULT : len;
464 #define OLD_KEY_MAX 0x1ff
465 static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user *p, int compat_mode)
467 static unsigned long keymax_warn_time;
471 switch (_IOC_NR(cmd) & EV_MAX) {
473 case 0: bits = dev->evbit; len = EV_MAX; break;
474 case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
475 case EV_REL: bits = dev->relbit; len = REL_MAX; break;
476 case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
477 case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
478 case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
479 case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
480 case EV_FF: bits = dev->ffbit; len = FF_MAX; break;
481 case EV_SW: bits = dev->swbit; len = SW_MAX; break;
482 default: return -EINVAL;
486 * Work around bugs in userspace programs that like to do
487 * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len'
488 * should be in bytes, not in bits.
490 if ((_IOC_NR(cmd) & EV_MAX) == EV_KEY && _IOC_SIZE(cmd) == OLD_KEY_MAX) {
492 if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000))
494 "evdev.c(EVIOCGBIT): Suspicious buffer size %u, "
495 "limiting output to %zu bytes. See "
496 "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n",
498 BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long));
501 return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);
505 static long evdev_do_ioctl(struct file *file, unsigned int cmd,
506 void __user *p, int compat_mode)
508 struct evdev_client *client = file->private_data;
509 struct evdev *evdev = client->evdev;
510 struct input_dev *dev = evdev->handle.dev;
511 struct input_absinfo abs;
512 struct ff_effect effect;
513 int __user *ip = (int __user *)p;
520 return put_user(EV_VERSION, ip);
523 if (copy_to_user(p, &dev->id, sizeof(struct input_id)))
528 if (!test_bit(EV_REP, dev->evbit))
530 if (put_user(dev->rep[REP_DELAY], ip))
532 if (put_user(dev->rep[REP_PERIOD], ip + 1))
537 if (!test_bit(EV_REP, dev->evbit))
541 if (get_user(v, ip + 1))
544 input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u);
545 input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v);
553 error = input_get_keycode(dev, t, &v);
557 if (put_user(v, ip + 1))
563 if (get_user(t, ip) || get_user(v, ip + 1))
566 return input_set_keycode(dev, t, v);
569 return input_ff_erase(dev, (int)(unsigned long) p, file);
572 i = test_bit(EV_FF, dev->evbit) ?
573 dev->ff->max_effects : 0;
580 return evdev_grab(evdev, client);
582 return evdev_ungrab(evdev, client);
586 if (_IOC_TYPE(cmd) != 'E')
589 if (_IOC_DIR(cmd) == _IOC_READ) {
591 if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
592 return handle_eviocgbit(dev, cmd, p, compat_mode);
594 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))
595 return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd),
598 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0)))
599 return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd),
602 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))
603 return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd),
606 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))
607 return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd),
610 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0)))
611 return str_to_user(dev->name, _IOC_SIZE(cmd), p);
613 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0)))
614 return str_to_user(dev->phys, _IOC_SIZE(cmd), p);
616 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0)))
617 return str_to_user(dev->uniq, _IOC_SIZE(cmd), p);
619 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
621 t = _IOC_NR(cmd) & ABS_MAX;
623 abs.value = dev->abs[t];
624 abs.minimum = dev->absmin[t];
625 abs.maximum = dev->absmax[t];
626 abs.fuzz = dev->absfuzz[t];
627 abs.flat = dev->absflat[t];
628 abs.resolution = dev->absres[t];
630 if (copy_to_user(p, &abs, min_t(size_t,
632 sizeof(struct input_absinfo))))
640 if (_IOC_DIR(cmd) == _IOC_WRITE) {
642 if (_IOC_NR(cmd) == _IOC_NR(EVIOCSFF)) {
644 if (input_ff_effect_from_user(p, _IOC_SIZE(cmd), &effect))
647 error = input_ff_upload(dev, &effect, file);
649 if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
655 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
657 t = _IOC_NR(cmd) & ABS_MAX;
659 if (copy_from_user(&abs, p, min_t(size_t,
661 sizeof(struct input_absinfo))))
665 * Take event lock to ensure that we are not
666 * changing device parameters in the middle
669 spin_lock_irq(&dev->event_lock);
671 dev->abs[t] = abs.value;
672 dev->absmin[t] = abs.minimum;
673 dev->absmax[t] = abs.maximum;
674 dev->absfuzz[t] = abs.fuzz;
675 dev->absflat[t] = abs.flat;
676 dev->absres[t] = _IOC_SIZE(cmd) < sizeof(struct input_absinfo) ?
679 spin_unlock_irq(&dev->event_lock);
688 static long evdev_ioctl_handler(struct file *file, unsigned int cmd,
689 void __user *p, int compat_mode)
691 struct evdev_client *client = file->private_data;
692 struct evdev *evdev = client->evdev;
695 retval = mutex_lock_interruptible(&evdev->mutex);
704 retval = evdev_do_ioctl(file, cmd, p, compat_mode);
707 mutex_unlock(&evdev->mutex);
711 static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
713 return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0);
717 static long evdev_ioctl_compat(struct file *file,
718 unsigned int cmd, unsigned long arg)
720 return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1);
724 static const struct file_operations evdev_fops = {
725 .owner = THIS_MODULE,
727 .write = evdev_write,
730 .release = evdev_release,
731 .unlocked_ioctl = evdev_ioctl,
733 .compat_ioctl = evdev_ioctl_compat,
735 .fasync = evdev_fasync,
739 static int evdev_install_chrdev(struct evdev *evdev)
742 * No need to do any locking here as calls to connect and
743 * disconnect are serialized by the input core
745 evdev_table[evdev->minor] = evdev;
749 static void evdev_remove_chrdev(struct evdev *evdev)
752 * Lock evdev table to prevent race with evdev_open()
754 mutex_lock(&evdev_table_mutex);
755 evdev_table[evdev->minor] = NULL;
756 mutex_unlock(&evdev_table_mutex);
760 * Mark device non-existent. This disables writes, ioctls and
761 * prevents new users from opening the device. Already posted
762 * blocking reads will stay, however new ones will fail.
764 static void evdev_mark_dead(struct evdev *evdev)
766 mutex_lock(&evdev->mutex);
768 mutex_unlock(&evdev->mutex);
771 static void evdev_cleanup(struct evdev *evdev)
773 struct input_handle *handle = &evdev->handle;
775 evdev_mark_dead(evdev);
777 evdev_remove_chrdev(evdev);
779 /* evdev is marked dead so no one else accesses evdev->open */
781 input_flush_device(handle, NULL);
782 input_close_device(handle);
787 * Create new evdev device. Note that input core serializes calls
788 * to connect and disconnect so we don't need to lock evdev_table here.
790 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
791 const struct input_device_id *id)
797 for (minor = 0; minor < EVDEV_MINORS; minor++)
798 if (!evdev_table[minor])
801 if (minor == EVDEV_MINORS) {
802 printk(KERN_ERR "evdev: no more free evdev devices\n");
806 evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
810 INIT_LIST_HEAD(&evdev->client_list);
811 spin_lock_init(&evdev->client_lock);
812 mutex_init(&evdev->mutex);
813 init_waitqueue_head(&evdev->wait);
815 dev_set_name(&evdev->dev, "event%d", minor);
817 evdev->minor = minor;
819 evdev->handle.dev = input_get_device(dev);
820 evdev->handle.name = dev_name(&evdev->dev);
821 evdev->handle.handler = handler;
822 evdev->handle.private = evdev;
824 evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
825 evdev->dev.class = &input_class;
826 evdev->dev.parent = &dev->dev;
827 evdev->dev.release = evdev_free;
828 device_initialize(&evdev->dev);
830 error = input_register_handle(&evdev->handle);
834 error = evdev_install_chrdev(evdev);
836 goto err_unregister_handle;
838 error = device_add(&evdev->dev);
840 goto err_cleanup_evdev;
845 evdev_cleanup(evdev);
846 err_unregister_handle:
847 input_unregister_handle(&evdev->handle);
849 put_device(&evdev->dev);
853 static void evdev_disconnect(struct input_handle *handle)
855 struct evdev *evdev = handle->private;
857 device_del(&evdev->dev);
858 evdev_cleanup(evdev);
859 input_unregister_handle(handle);
860 put_device(&evdev->dev);
863 static const struct input_device_id evdev_ids[] = {
864 { .driver_info = 1 }, /* Matches all devices */
865 { }, /* Terminating zero entry */
868 MODULE_DEVICE_TABLE(input, evdev_ids);
870 static struct input_handler evdev_handler = {
871 .event = evdev_event,
872 .connect = evdev_connect,
873 .disconnect = evdev_disconnect,
875 .minor = EVDEV_MINOR_BASE,
877 .id_table = evdev_ids,
880 static int __init evdev_init(void)
882 return input_register_handler(&evdev_handler);
885 static void __exit evdev_exit(void)
887 input_unregister_handler(&evdev_handler);
890 module_init(evdev_init);
891 module_exit(evdev_exit);
893 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
894 MODULE_DESCRIPTION("Input driver event char devices");
895 MODULE_LICENSE("GPL");