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/smp_lock.h>
22 #include <linux/device.h>
23 #include <linux/compat.h>
30 struct input_handle handle
;
31 wait_queue_head_t wait
;
32 struct evdev_client
*grab
;
33 struct list_head client_list
;
37 struct input_event buffer
[EVDEV_BUFFER_SIZE
];
40 struct fasync_struct
*fasync
;
42 struct list_head node
;
45 static struct evdev
*evdev_table
[EVDEV_MINORS
];
47 static void evdev_event(struct input_handle
*handle
, unsigned int type
, unsigned int code
, int value
)
49 struct evdev
*evdev
= handle
->private;
50 struct evdev_client
*client
;
55 do_gettimeofday(&client
->buffer
[client
->head
].time
);
56 client
->buffer
[client
->head
].type
= type
;
57 client
->buffer
[client
->head
].code
= code
;
58 client
->buffer
[client
->head
].value
= value
;
59 client
->head
= (client
->head
+ 1) & (EVDEV_BUFFER_SIZE
- 1);
61 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
63 list_for_each_entry(client
, &evdev
->client_list
, node
) {
65 do_gettimeofday(&client
->buffer
[client
->head
].time
);
66 client
->buffer
[client
->head
].type
= type
;
67 client
->buffer
[client
->head
].code
= code
;
68 client
->buffer
[client
->head
].value
= value
;
69 client
->head
= (client
->head
+ 1) & (EVDEV_BUFFER_SIZE
- 1);
71 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
74 wake_up_interruptible(&evdev
->wait
);
77 static int evdev_fasync(int fd
, struct file
*file
, int on
)
79 struct evdev_client
*client
= file
->private_data
;
82 retval
= fasync_helper(fd
, file
, on
, &client
->fasync
);
84 return retval
< 0 ? retval
: 0;
87 static int evdev_flush(struct file
*file
, fl_owner_t id
)
89 struct evdev_client
*client
= file
->private_data
;
90 struct evdev
*evdev
= client
->evdev
;
95 return input_flush_device(&evdev
->handle
, file
);
98 static void evdev_free(struct evdev
*evdev
)
100 evdev_table
[evdev
->minor
] = NULL
;
104 static int evdev_release(struct inode
*inode
, struct file
*file
)
106 struct evdev_client
*client
= file
->private_data
;
107 struct evdev
*evdev
= client
->evdev
;
109 if (evdev
->grab
== client
) {
110 input_release_device(&evdev
->handle
);
114 evdev_fasync(-1, file
, 0);
115 list_del(&client
->node
);
118 if (!--evdev
->open
) {
120 input_close_device(&evdev
->handle
);
128 static int evdev_open(struct inode
*inode
, struct file
*file
)
130 struct evdev_client
*client
;
132 int i
= iminor(inode
) - EVDEV_MINOR_BASE
;
135 if (i
>= EVDEV_MINORS
)
138 evdev
= evdev_table
[i
];
140 if (!evdev
|| !evdev
->exist
)
143 client
= kzalloc(sizeof(struct evdev_client
), GFP_KERNEL
);
147 client
->evdev
= evdev
;
148 list_add_tail(&client
->node
, &evdev
->client_list
);
150 if (!evdev
->open
++ && evdev
->exist
) {
151 error
= input_open_device(&evdev
->handle
);
153 list_del(&client
->node
);
159 file
->private_data
= client
;
165 struct input_event_compat
{
166 struct compat_timeval time
;
172 /* Note to the author of this code: did it ever occur to
173 you why the ifdefs are needed? Think about it again. -AK */
175 # define COMPAT_TEST is_compat_task()
176 #elif defined(CONFIG_IA64)
177 # define COMPAT_TEST IS_IA32_PROCESS(task_pt_regs(current))
178 #elif defined(CONFIG_S390)
179 # define COMPAT_TEST test_thread_flag(TIF_31BIT)
180 #elif defined(CONFIG_MIPS)
181 # define COMPAT_TEST (current->thread.mflags & MF_32BIT_ADDR)
183 # define COMPAT_TEST test_thread_flag(TIF_32BIT)
186 static inline size_t evdev_event_size(void)
189 sizeof(struct input_event_compat
) : sizeof(struct input_event
);
192 static int evdev_event_from_user(const char __user
*buffer
, struct input_event
*event
)
195 struct input_event_compat compat_event
;
197 if (copy_from_user(&compat_event
, buffer
, sizeof(struct input_event_compat
)))
200 event
->time
.tv_sec
= compat_event
.time
.tv_sec
;
201 event
->time
.tv_usec
= compat_event
.time
.tv_usec
;
202 event
->type
= compat_event
.type
;
203 event
->code
= compat_event
.code
;
204 event
->value
= compat_event
.value
;
207 if (copy_from_user(event
, buffer
, sizeof(struct input_event
)))
214 static int evdev_event_to_user(char __user
*buffer
, const struct input_event
*event
)
217 struct input_event_compat compat_event
;
219 compat_event
.time
.tv_sec
= event
->time
.tv_sec
;
220 compat_event
.time
.tv_usec
= event
->time
.tv_usec
;
221 compat_event
.type
= event
->type
;
222 compat_event
.code
= event
->code
;
223 compat_event
.value
= event
->value
;
225 if (copy_to_user(buffer
, &compat_event
, sizeof(struct input_event_compat
)))
229 if (copy_to_user(buffer
, event
, sizeof(struct input_event
)))
238 static inline size_t evdev_event_size(void)
240 return sizeof(struct input_event
);
243 static int evdev_event_from_user(const char __user
*buffer
, struct input_event
*event
)
245 if (copy_from_user(event
, buffer
, sizeof(struct input_event
)))
251 static int evdev_event_to_user(char __user
*buffer
, const struct input_event
*event
)
253 if (copy_to_user(buffer
, event
, sizeof(struct input_event
)))
259 #endif /* CONFIG_COMPAT */
261 static ssize_t
evdev_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
263 struct evdev_client
*client
= file
->private_data
;
264 struct evdev
*evdev
= client
->evdev
;
265 struct input_event event
;
271 while (retval
< count
) {
273 if (evdev_event_from_user(buffer
+ retval
, &event
))
275 input_inject_event(&evdev
->handle
, event
.type
, event
.code
, event
.value
);
276 retval
+= evdev_event_size();
282 static ssize_t
evdev_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
284 struct evdev_client
*client
= file
->private_data
;
285 struct evdev
*evdev
= client
->evdev
;
288 if (count
< evdev_event_size())
291 if (client
->head
== client
->tail
&& evdev
->exist
&& (file
->f_flags
& O_NONBLOCK
))
294 retval
= wait_event_interruptible(evdev
->wait
,
295 client
->head
!= client
->tail
|| !evdev
->exist
);
302 while (client
->head
!= client
->tail
&& retval
+ evdev_event_size() <= count
) {
304 struct input_event
*event
= (struct input_event
*) client
->buffer
+ client
->tail
;
306 if (evdev_event_to_user(buffer
+ retval
, event
))
309 client
->tail
= (client
->tail
+ 1) & (EVDEV_BUFFER_SIZE
- 1);
310 retval
+= evdev_event_size();
316 /* No kernel lock - fine */
317 static unsigned int evdev_poll(struct file
*file
, poll_table
*wait
)
319 struct evdev_client
*client
= file
->private_data
;
320 struct evdev
*evdev
= client
->evdev
;
322 poll_wait(file
, &evdev
->wait
, wait
);
323 return ((client
->head
== client
->tail
) ? 0 : (POLLIN
| POLLRDNORM
)) |
324 (evdev
->exist
? 0 : (POLLHUP
| POLLERR
));
329 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
330 #define NBITS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
333 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
334 unsigned int maxlen
, void __user
*p
, int compat
)
339 len
= NBITS_COMPAT(maxbit
) * sizeof(compat_long_t
);
343 for (i
= 0; i
< len
/ sizeof(compat_long_t
); i
++)
344 if (copy_to_user((compat_long_t __user
*) p
+ i
,
345 (compat_long_t
*) bits
+
346 i
+ 1 - ((i
% 2) << 1),
347 sizeof(compat_long_t
)))
350 len
= NBITS(maxbit
) * sizeof(long);
354 if (copy_to_user(p
, bits
, len
))
361 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
362 unsigned int maxlen
, void __user
*p
, int compat
)
365 NBITS_COMPAT(maxbit
) * sizeof(compat_long_t
) :
366 NBITS(maxbit
) * sizeof(long);
371 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
373 #endif /* __BIG_ENDIAN */
377 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
378 unsigned int maxlen
, void __user
*p
, int compat
)
380 int len
= NBITS(maxbit
) * sizeof(long);
385 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
388 #endif /* CONFIG_COMPAT */
390 static int str_to_user(const char *str
, unsigned int maxlen
, void __user
*p
)
397 len
= strlen(str
) + 1;
401 return copy_to_user(p
, str
, len
) ? -EFAULT
: len
;
404 static long evdev_ioctl_handler(struct file
*file
, unsigned int cmd
,
405 void __user
*p
, int compat_mode
)
407 struct evdev_client
*client
= file
->private_data
;
408 struct evdev
*evdev
= client
->evdev
;
409 struct input_dev
*dev
= evdev
->handle
.dev
;
410 struct input_absinfo abs
;
411 struct ff_effect effect
;
412 int __user
*ip
= (int __user
*)p
;
422 return put_user(EV_VERSION
, ip
);
425 if (copy_to_user(p
, &dev
->id
, sizeof(struct input_id
)))
430 if (!test_bit(EV_REP
, dev
->evbit
))
432 if (put_user(dev
->rep
[REP_DELAY
], ip
))
434 if (put_user(dev
->rep
[REP_PERIOD
], ip
+ 1))
439 if (!test_bit(EV_REP
, dev
->evbit
))
443 if (get_user(v
, ip
+ 1))
446 input_inject_event(&evdev
->handle
, EV_REP
, REP_DELAY
, u
);
447 input_inject_event(&evdev
->handle
, EV_REP
, REP_PERIOD
, v
);
455 error
= dev
->getkeycode(dev
, t
, &v
);
459 if (put_user(v
, ip
+ 1))
465 if (get_user(t
, ip
) || get_user(v
, ip
+ 1))
468 return dev
->setkeycode(dev
, t
, v
);
471 if (copy_from_user(&effect
, p
, sizeof(effect
)))
474 error
= input_ff_upload(dev
, &effect
, file
);
476 if (put_user(effect
.id
, &(((struct ff_effect __user
*)p
)->id
)))
482 return input_ff_erase(dev
, (int)(unsigned long) p
, file
);
485 i
= test_bit(EV_FF
, dev
->evbit
) ? dev
->ff
->max_effects
: 0;
494 if (input_grab_device(&evdev
->handle
))
496 evdev
->grab
= client
;
499 if (evdev
->grab
!= client
)
501 input_release_device(&evdev
->handle
);
508 if (_IOC_TYPE(cmd
) != 'E')
511 if (_IOC_DIR(cmd
) == _IOC_READ
) {
513 if ((_IOC_NR(cmd
) & ~EV_MAX
) == _IOC_NR(EVIOCGBIT(0,0))) {
518 switch (_IOC_NR(cmd
) & EV_MAX
) {
519 case 0: bits
= dev
->evbit
; len
= EV_MAX
; break;
520 case EV_KEY
: bits
= dev
->keybit
; len
= KEY_MAX
; break;
521 case EV_REL
: bits
= dev
->relbit
; len
= REL_MAX
; break;
522 case EV_ABS
: bits
= dev
->absbit
; len
= ABS_MAX
; break;
523 case EV_MSC
: bits
= dev
->mscbit
; len
= MSC_MAX
; break;
524 case EV_LED
: bits
= dev
->ledbit
; len
= LED_MAX
; break;
525 case EV_SND
: bits
= dev
->sndbit
; len
= SND_MAX
; break;
526 case EV_FF
: bits
= dev
->ffbit
; len
= FF_MAX
; break;
527 case EV_SW
: bits
= dev
->swbit
; len
= SW_MAX
; break;
528 default: return -EINVAL
;
530 return bits_to_user(bits
, len
, _IOC_SIZE(cmd
), p
, compat_mode
);
533 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGKEY(0)))
534 return bits_to_user(dev
->key
, KEY_MAX
, _IOC_SIZE(cmd
),
537 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGLED(0)))
538 return bits_to_user(dev
->led
, LED_MAX
, _IOC_SIZE(cmd
),
541 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGSND(0)))
542 return bits_to_user(dev
->snd
, SND_MAX
, _IOC_SIZE(cmd
),
545 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGSW(0)))
546 return bits_to_user(dev
->sw
, SW_MAX
, _IOC_SIZE(cmd
),
549 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGNAME(0)))
550 return str_to_user(dev
->name
, _IOC_SIZE(cmd
), p
);
552 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGPHYS(0)))
553 return str_to_user(dev
->phys
, _IOC_SIZE(cmd
), p
);
555 if (_IOC_NR(cmd
) == _IOC_NR(EVIOCGUNIQ(0)))
556 return str_to_user(dev
->uniq
, _IOC_SIZE(cmd
), p
);
558 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCGABS(0))) {
560 int t
= _IOC_NR(cmd
) & ABS_MAX
;
562 abs
.value
= dev
->abs
[t
];
563 abs
.minimum
= dev
->absmin
[t
];
564 abs
.maximum
= dev
->absmax
[t
];
565 abs
.fuzz
= dev
->absfuzz
[t
];
566 abs
.flat
= dev
->absflat
[t
];
568 if (copy_to_user(p
, &abs
, sizeof(struct input_absinfo
)))
576 if (_IOC_DIR(cmd
) == _IOC_WRITE
) {
578 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCSABS(0))) {
580 int t
= _IOC_NR(cmd
) & ABS_MAX
;
582 if (copy_from_user(&abs
, p
, sizeof(struct input_absinfo
)))
585 dev
->abs
[t
] = abs
.value
;
586 dev
->absmin
[t
] = abs
.minimum
;
587 dev
->absmax
[t
] = abs
.maximum
;
588 dev
->absfuzz
[t
] = abs
.fuzz
;
589 dev
->absflat
[t
] = abs
.flat
;
598 static long evdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
600 return evdev_ioctl_handler(file
, cmd
, (void __user
*)arg
, 0);
604 static long evdev_ioctl_compat(struct file
*file
, unsigned int cmd
, unsigned long arg
)
606 return evdev_ioctl_handler(file
, cmd
, compat_ptr(arg
), 1);
610 static const struct file_operations evdev_fops
= {
611 .owner
= THIS_MODULE
,
613 .write
= evdev_write
,
616 .release
= evdev_release
,
617 .unlocked_ioctl
= evdev_ioctl
,
619 .compat_ioctl
= evdev_ioctl_compat
,
621 .fasync
= evdev_fasync
,
625 static int evdev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
626 const struct input_device_id
*id
)
629 struct class_device
*cdev
;
634 for (minor
= 0; minor
< EVDEV_MINORS
&& evdev_table
[minor
]; minor
++);
635 if (minor
== EVDEV_MINORS
) {
636 printk(KERN_ERR
"evdev: no more free evdev devices\n");
640 evdev
= kzalloc(sizeof(struct evdev
), GFP_KERNEL
);
644 INIT_LIST_HEAD(&evdev
->client_list
);
645 init_waitqueue_head(&evdev
->wait
);
648 evdev
->minor
= minor
;
649 evdev
->handle
.dev
= dev
;
650 evdev
->handle
.name
= evdev
->name
;
651 evdev
->handle
.handler
= handler
;
652 evdev
->handle
.private = evdev
;
653 sprintf(evdev
->name
, "event%d", minor
);
655 evdev_table
[minor
] = evdev
;
657 devt
= MKDEV(INPUT_MAJOR
, EVDEV_MINOR_BASE
+ minor
),
659 cdev
= class_device_create(&input_class
, &dev
->cdev
, devt
,
660 dev
->cdev
.dev
, evdev
->name
);
662 error
= PTR_ERR(cdev
);
666 /* temporary symlink to keep userspace happy */
667 error
= sysfs_create_link(&input_class
.subsys
.kobj
,
668 &cdev
->kobj
, evdev
->name
);
670 goto err_cdev_destroy
;
672 error
= input_register_handle(&evdev
->handle
);
674 goto err_remove_link
;
679 sysfs_remove_link(&input_class
.subsys
.kobj
, evdev
->name
);
681 class_device_destroy(&input_class
, devt
);
684 evdev_table
[minor
] = NULL
;
688 static void evdev_disconnect(struct input_handle
*handle
)
690 struct evdev
*evdev
= handle
->private;
691 struct evdev_client
*client
;
693 input_unregister_handle(handle
);
695 sysfs_remove_link(&input_class
.subsys
.kobj
, evdev
->name
);
696 class_device_destroy(&input_class
,
697 MKDEV(INPUT_MAJOR
, EVDEV_MINOR_BASE
+ evdev
->minor
));
701 input_flush_device(handle
, NULL
);
702 input_close_device(handle
);
703 wake_up_interruptible(&evdev
->wait
);
704 list_for_each_entry(client
, &evdev
->client_list
, node
)
705 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
710 static const struct input_device_id evdev_ids
[] = {
711 { .driver_info
= 1 }, /* Matches all devices */
712 { }, /* Terminating zero entry */
715 MODULE_DEVICE_TABLE(input
, evdev_ids
);
717 static struct input_handler evdev_handler
= {
718 .event
= evdev_event
,
719 .connect
= evdev_connect
,
720 .disconnect
= evdev_disconnect
,
722 .minor
= EVDEV_MINOR_BASE
,
724 .id_table
= evdev_ids
,
727 static int __init
evdev_init(void)
729 return input_register_handler(&evdev_handler
);
732 static void __exit
evdev_exit(void)
734 input_unregister_handler(&evdev_handler
);
737 module_init(evdev_init
);
738 module_exit(evdev_exit
);
740 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
741 MODULE_DESCRIPTION("Input driver event char devices");
742 MODULE_LICENSE("GPL");