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 pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #define EVDEV_MINOR_BASE 64
14 #define EVDEV_MINORS 32
15 #define EVDEV_MIN_BUFFER_SIZE 64U
16 #define EVDEV_BUF_PACKETS 8
18 #include <linux/poll.h>
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <linux/vmalloc.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/input/mt.h>
26 #include <linux/major.h>
27 #include <linux/device.h>
28 #include <linux/cdev.h>
29 #include "input-compat.h"
31 enum evdev_clock_type
{
40 struct input_handle handle
;
41 wait_queue_head_t wait
;
42 struct evdev_client __rcu
*grab
;
43 struct list_head client_list
;
44 spinlock_t client_lock
; /* protects client_list */
54 unsigned int packet_head
; /* [future] position of the first element of next packet */
55 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
56 struct fasync_struct
*fasync
;
58 struct list_head node
;
62 struct input_event buffer
[];
65 /* flush queued events of type @type, caller must hold client->buffer_lock */
66 static void __evdev_flush_queue(struct evdev_client
*client
, unsigned int type
)
68 unsigned int i
, head
, num
;
69 unsigned int mask
= client
->bufsize
- 1;
71 struct input_event
*ev
;
73 BUG_ON(type
== EV_SYN
);
76 client
->packet_head
= client
->tail
;
78 /* init to 1 so a leading SYN_REPORT will not be dropped */
81 for (i
= client
->tail
; i
!= client
->head
; i
= (i
+ 1) & mask
) {
82 ev
= &client
->buffer
[i
];
83 is_report
= ev
->type
== EV_SYN
&& ev
->code
== SYN_REPORT
;
85 if (ev
->type
== type
) {
86 /* drop matched entry */
88 } else if (is_report
&& !num
) {
89 /* drop empty SYN_REPORT groups */
91 } else if (head
!= i
) {
92 /* move entry to fill the gap */
93 client
->buffer
[head
].time
= ev
->time
;
94 client
->buffer
[head
].type
= ev
->type
;
95 client
->buffer
[head
].code
= ev
->code
;
96 client
->buffer
[head
].value
= ev
->value
;
100 head
= (head
+ 1) & mask
;
104 client
->packet_head
= head
;
111 static void __evdev_queue_syn_dropped(struct evdev_client
*client
)
113 struct input_event ev
;
116 time
= client
->clk_type
== EV_CLK_REAL
?
118 client
->clk_type
== EV_CLK_MONO
?
120 ktime_get_boottime();
122 ev
.time
= ktime_to_timeval(time
);
124 ev
.code
= SYN_DROPPED
;
127 client
->buffer
[client
->head
++] = ev
;
128 client
->head
&= client
->bufsize
- 1;
130 if (unlikely(client
->head
== client
->tail
)) {
131 /* drop queue but keep our SYN_DROPPED event */
132 client
->tail
= (client
->head
- 1) & (client
->bufsize
- 1);
133 client
->packet_head
= client
->tail
;
137 static void evdev_queue_syn_dropped(struct evdev_client
*client
)
141 spin_lock_irqsave(&client
->buffer_lock
, flags
);
142 __evdev_queue_syn_dropped(client
);
143 spin_unlock_irqrestore(&client
->buffer_lock
, flags
);
146 static int evdev_set_clk_type(struct evdev_client
*client
, unsigned int clkid
)
150 if (client
->clk_type
== clkid
)
156 client
->clk_type
= EV_CLK_REAL
;
158 case CLOCK_MONOTONIC
:
159 client
->clk_type
= EV_CLK_MONO
;
162 client
->clk_type
= EV_CLK_BOOT
;
169 * Flush pending events and queue SYN_DROPPED event,
170 * but only if the queue is not empty.
172 spin_lock_irqsave(&client
->buffer_lock
, flags
);
174 if (client
->head
!= client
->tail
) {
175 client
->packet_head
= client
->head
= client
->tail
;
176 __evdev_queue_syn_dropped(client
);
179 spin_unlock_irqrestore(&client
->buffer_lock
, flags
);
184 static void __pass_event(struct evdev_client
*client
,
185 const struct input_event
*event
)
187 client
->buffer
[client
->head
++] = *event
;
188 client
->head
&= client
->bufsize
- 1;
190 if (unlikely(client
->head
== client
->tail
)) {
192 * This effectively "drops" all unconsumed events, leaving
193 * EV_SYN/SYN_DROPPED plus the newest event in the queue.
195 client
->tail
= (client
->head
- 2) & (client
->bufsize
- 1);
197 client
->buffer
[client
->tail
].time
= event
->time
;
198 client
->buffer
[client
->tail
].type
= EV_SYN
;
199 client
->buffer
[client
->tail
].code
= SYN_DROPPED
;
200 client
->buffer
[client
->tail
].value
= 0;
202 client
->packet_head
= client
->tail
;
205 if (event
->type
== EV_SYN
&& event
->code
== SYN_REPORT
) {
206 client
->packet_head
= client
->head
;
207 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
211 static void evdev_pass_values(struct evdev_client
*client
,
212 const struct input_value
*vals
, unsigned int count
,
215 struct evdev
*evdev
= client
->evdev
;
216 const struct input_value
*v
;
217 struct input_event event
;
223 event
.time
= ktime_to_timeval(ev_time
[client
->clk_type
]);
225 /* Interrupts are disabled, just acquire the lock. */
226 spin_lock(&client
->buffer_lock
);
228 for (v
= vals
; v
!= vals
+ count
; v
++) {
229 event
.type
= v
->type
;
230 event
.code
= v
->code
;
231 event
.value
= v
->value
;
232 __pass_event(client
, &event
);
233 if (v
->type
== EV_SYN
&& v
->code
== SYN_REPORT
)
237 spin_unlock(&client
->buffer_lock
);
240 wake_up_interruptible(&evdev
->wait
);
244 * Pass incoming events to all connected clients.
246 static void evdev_events(struct input_handle
*handle
,
247 const struct input_value
*vals
, unsigned int count
)
249 struct evdev
*evdev
= handle
->private;
250 struct evdev_client
*client
;
251 ktime_t ev_time
[EV_CLK_MAX
];
253 ev_time
[EV_CLK_MONO
] = ktime_get();
254 ev_time
[EV_CLK_REAL
] = ktime_mono_to_real(ev_time
[EV_CLK_MONO
]);
255 ev_time
[EV_CLK_BOOT
] = ktime_mono_to_any(ev_time
[EV_CLK_MONO
],
260 client
= rcu_dereference(evdev
->grab
);
263 evdev_pass_values(client
, vals
, count
, ev_time
);
265 list_for_each_entry_rcu(client
, &evdev
->client_list
, node
)
266 evdev_pass_values(client
, vals
, count
, ev_time
);
272 * Pass incoming event to all connected clients.
274 static void evdev_event(struct input_handle
*handle
,
275 unsigned int type
, unsigned int code
, int value
)
277 struct input_value vals
[] = { { type
, code
, value
} };
279 evdev_events(handle
, vals
, 1);
282 static int evdev_fasync(int fd
, struct file
*file
, int on
)
284 struct evdev_client
*client
= file
->private_data
;
286 return fasync_helper(fd
, file
, on
, &client
->fasync
);
289 static int evdev_flush(struct file
*file
, fl_owner_t id
)
291 struct evdev_client
*client
= file
->private_data
;
292 struct evdev
*evdev
= client
->evdev
;
294 mutex_lock(&evdev
->mutex
);
296 if (evdev
->exist
&& !client
->revoked
)
297 input_flush_device(&evdev
->handle
, file
);
299 mutex_unlock(&evdev
->mutex
);
303 static void evdev_free(struct device
*dev
)
305 struct evdev
*evdev
= container_of(dev
, struct evdev
, dev
);
307 input_put_device(evdev
->handle
.dev
);
312 * Grabs an event device (along with underlying input device).
313 * This function is called with evdev->mutex taken.
315 static int evdev_grab(struct evdev
*evdev
, struct evdev_client
*client
)
322 error
= input_grab_device(&evdev
->handle
);
326 rcu_assign_pointer(evdev
->grab
, client
);
331 static int evdev_ungrab(struct evdev
*evdev
, struct evdev_client
*client
)
333 struct evdev_client
*grab
= rcu_dereference_protected(evdev
->grab
,
334 lockdep_is_held(&evdev
->mutex
));
339 rcu_assign_pointer(evdev
->grab
, NULL
);
341 input_release_device(&evdev
->handle
);
346 static void evdev_attach_client(struct evdev
*evdev
,
347 struct evdev_client
*client
)
349 spin_lock(&evdev
->client_lock
);
350 list_add_tail_rcu(&client
->node
, &evdev
->client_list
);
351 spin_unlock(&evdev
->client_lock
);
354 static void evdev_detach_client(struct evdev
*evdev
,
355 struct evdev_client
*client
)
357 spin_lock(&evdev
->client_lock
);
358 list_del_rcu(&client
->node
);
359 spin_unlock(&evdev
->client_lock
);
363 static int evdev_open_device(struct evdev
*evdev
)
367 retval
= mutex_lock_interruptible(&evdev
->mutex
);
373 else if (!evdev
->open
++) {
374 retval
= input_open_device(&evdev
->handle
);
379 mutex_unlock(&evdev
->mutex
);
383 static void evdev_close_device(struct evdev
*evdev
)
385 mutex_lock(&evdev
->mutex
);
387 if (evdev
->exist
&& !--evdev
->open
)
388 input_close_device(&evdev
->handle
);
390 mutex_unlock(&evdev
->mutex
);
394 * Wake up users waiting for IO so they can disconnect from
397 static void evdev_hangup(struct evdev
*evdev
)
399 struct evdev_client
*client
;
401 spin_lock(&evdev
->client_lock
);
402 list_for_each_entry(client
, &evdev
->client_list
, node
)
403 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
404 spin_unlock(&evdev
->client_lock
);
406 wake_up_interruptible(&evdev
->wait
);
409 static int evdev_release(struct inode
*inode
, struct file
*file
)
411 struct evdev_client
*client
= file
->private_data
;
412 struct evdev
*evdev
= client
->evdev
;
414 mutex_lock(&evdev
->mutex
);
415 evdev_ungrab(evdev
, client
);
416 mutex_unlock(&evdev
->mutex
);
418 evdev_detach_client(evdev
, client
);
422 evdev_close_device(evdev
);
427 static unsigned int evdev_compute_buffer_size(struct input_dev
*dev
)
429 unsigned int n_events
=
430 max(dev
->hint_events_per_packet
* EVDEV_BUF_PACKETS
,
431 EVDEV_MIN_BUFFER_SIZE
);
433 return roundup_pow_of_two(n_events
);
436 static int evdev_open(struct inode
*inode
, struct file
*file
)
438 struct evdev
*evdev
= container_of(inode
->i_cdev
, struct evdev
, cdev
);
439 unsigned int bufsize
= evdev_compute_buffer_size(evdev
->handle
.dev
);
440 unsigned int size
= sizeof(struct evdev_client
) +
441 bufsize
* sizeof(struct input_event
);
442 struct evdev_client
*client
;
445 client
= kzalloc(size
, GFP_KERNEL
| __GFP_NOWARN
);
447 client
= vzalloc(size
);
451 client
->bufsize
= bufsize
;
452 spin_lock_init(&client
->buffer_lock
);
453 client
->evdev
= evdev
;
454 evdev_attach_client(evdev
, client
);
456 error
= evdev_open_device(evdev
);
458 goto err_free_client
;
460 file
->private_data
= client
;
461 nonseekable_open(inode
, file
);
466 evdev_detach_client(evdev
, client
);
471 static ssize_t
evdev_write(struct file
*file
, const char __user
*buffer
,
472 size_t count
, loff_t
*ppos
)
474 struct evdev_client
*client
= file
->private_data
;
475 struct evdev
*evdev
= client
->evdev
;
476 struct input_event event
;
479 if (count
!= 0 && count
< input_event_size())
482 retval
= mutex_lock_interruptible(&evdev
->mutex
);
486 if (!evdev
->exist
|| client
->revoked
) {
491 while (retval
+ input_event_size() <= count
) {
493 if (input_event_from_user(buffer
+ retval
, &event
)) {
497 retval
+= input_event_size();
499 input_inject_event(&evdev
->handle
,
500 event
.type
, event
.code
, event
.value
);
504 mutex_unlock(&evdev
->mutex
);
508 static int evdev_fetch_next_event(struct evdev_client
*client
,
509 struct input_event
*event
)
513 spin_lock_irq(&client
->buffer_lock
);
515 have_event
= client
->packet_head
!= client
->tail
;
517 *event
= client
->buffer
[client
->tail
++];
518 client
->tail
&= client
->bufsize
- 1;
521 spin_unlock_irq(&client
->buffer_lock
);
526 static ssize_t
evdev_read(struct file
*file
, char __user
*buffer
,
527 size_t count
, loff_t
*ppos
)
529 struct evdev_client
*client
= file
->private_data
;
530 struct evdev
*evdev
= client
->evdev
;
531 struct input_event event
;
535 if (count
!= 0 && count
< input_event_size())
539 if (!evdev
->exist
|| client
->revoked
)
542 if (client
->packet_head
== client
->tail
&&
543 (file
->f_flags
& O_NONBLOCK
))
547 * count == 0 is special - no IO is done but we check
548 * for error conditions (see above).
553 while (read
+ input_event_size() <= count
&&
554 evdev_fetch_next_event(client
, &event
)) {
556 if (input_event_to_user(buffer
+ read
, &event
))
559 read
+= input_event_size();
565 if (!(file
->f_flags
& O_NONBLOCK
)) {
566 error
= wait_event_interruptible(evdev
->wait
,
567 client
->packet_head
!= client
->tail
||
568 !evdev
->exist
|| client
->revoked
);
577 /* No kernel lock - fine */
578 static unsigned int evdev_poll(struct file
*file
, poll_table
*wait
)
580 struct evdev_client
*client
= file
->private_data
;
581 struct evdev
*evdev
= client
->evdev
;
584 poll_wait(file
, &evdev
->wait
, wait
);
586 if (evdev
->exist
&& !client
->revoked
)
587 mask
= POLLOUT
| POLLWRNORM
;
589 mask
= POLLHUP
| POLLERR
;
591 if (client
->packet_head
!= client
->tail
)
592 mask
|= POLLIN
| POLLRDNORM
;
599 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
600 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
603 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
604 unsigned int maxlen
, void __user
*p
, int compat
)
609 len
= BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
);
613 for (i
= 0; i
< len
/ sizeof(compat_long_t
); i
++)
614 if (copy_to_user((compat_long_t __user
*) p
+ i
,
615 (compat_long_t
*) bits
+
616 i
+ 1 - ((i
% 2) << 1),
617 sizeof(compat_long_t
)))
620 len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
624 if (copy_to_user(p
, bits
, len
))
631 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
632 unsigned int maxlen
, void __user
*p
, int compat
)
635 BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
) :
636 BITS_TO_LONGS(maxbit
) * sizeof(long);
641 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
643 #endif /* __BIG_ENDIAN */
647 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
648 unsigned int maxlen
, void __user
*p
, int compat
)
650 int len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
655 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
658 #endif /* CONFIG_COMPAT */
660 static int str_to_user(const char *str
, unsigned int maxlen
, void __user
*p
)
667 len
= strlen(str
) + 1;
671 return copy_to_user(p
, str
, len
) ? -EFAULT
: len
;
674 static int handle_eviocgbit(struct input_dev
*dev
,
675 unsigned int type
, unsigned int size
,
676 void __user
*p
, int compat_mode
)
683 case 0: bits
= dev
->evbit
; len
= EV_MAX
; break;
684 case EV_KEY
: bits
= dev
->keybit
; len
= KEY_MAX
; break;
685 case EV_REL
: bits
= dev
->relbit
; len
= REL_MAX
; break;
686 case EV_ABS
: bits
= dev
->absbit
; len
= ABS_MAX
; break;
687 case EV_MSC
: bits
= dev
->mscbit
; len
= MSC_MAX
; break;
688 case EV_LED
: bits
= dev
->ledbit
; len
= LED_MAX
; break;
689 case EV_SND
: bits
= dev
->sndbit
; len
= SND_MAX
; break;
690 case EV_FF
: bits
= dev
->ffbit
; len
= FF_MAX
; break;
691 case EV_SW
: bits
= dev
->swbit
; len
= SW_MAX
; break;
692 default: return -EINVAL
;
695 return bits_to_user(bits
, len
, size
, p
, compat_mode
);
698 static int evdev_handle_get_keycode(struct input_dev
*dev
, void __user
*p
)
700 struct input_keymap_entry ke
= {
701 .len
= sizeof(unsigned int),
704 int __user
*ip
= (int __user
*)p
;
708 if (copy_from_user(ke
.scancode
, p
, sizeof(unsigned int)))
711 error
= input_get_keycode(dev
, &ke
);
715 if (put_user(ke
.keycode
, ip
+ 1))
721 static int evdev_handle_get_keycode_v2(struct input_dev
*dev
, void __user
*p
)
723 struct input_keymap_entry ke
;
726 if (copy_from_user(&ke
, p
, sizeof(ke
)))
729 error
= input_get_keycode(dev
, &ke
);
733 if (copy_to_user(p
, &ke
, sizeof(ke
)))
739 static int evdev_handle_set_keycode(struct input_dev
*dev
, void __user
*p
)
741 struct input_keymap_entry ke
= {
742 .len
= sizeof(unsigned int),
745 int __user
*ip
= (int __user
*)p
;
747 if (copy_from_user(ke
.scancode
, p
, sizeof(unsigned int)))
750 if (get_user(ke
.keycode
, ip
+ 1))
753 return input_set_keycode(dev
, &ke
);
756 static int evdev_handle_set_keycode_v2(struct input_dev
*dev
, void __user
*p
)
758 struct input_keymap_entry ke
;
760 if (copy_from_user(&ke
, p
, sizeof(ke
)))
763 if (ke
.len
> sizeof(ke
.scancode
))
766 return input_set_keycode(dev
, &ke
);
770 * If we transfer state to the user, we should flush all pending events
771 * of the same type from the client's queue. Otherwise, they might end up
772 * with duplicate events, which can screw up client's state tracking.
773 * If bits_to_user fails after flushing the queue, we queue a SYN_DROPPED
774 * event so user-space will notice missing events.
777 * We need to take event_lock before buffer_lock to avoid dead-locks. But we
778 * need the even_lock only to guarantee consistent state. We can safely release
779 * it while flushing the queue. This allows input-core to handle filters while
780 * we flush the queue.
782 static int evdev_handle_get_val(struct evdev_client
*client
,
783 struct input_dev
*dev
, unsigned int type
,
784 unsigned long *bits
, unsigned int maxbit
,
785 unsigned int maxlen
, void __user
*p
,
792 len
= BITS_TO_LONGS(maxbit
) * sizeof(unsigned long);
793 mem
= kmalloc(len
, GFP_KERNEL
);
797 spin_lock_irq(&dev
->event_lock
);
798 spin_lock(&client
->buffer_lock
);
800 memcpy(mem
, bits
, len
);
802 spin_unlock(&dev
->event_lock
);
804 __evdev_flush_queue(client
, type
);
806 spin_unlock_irq(&client
->buffer_lock
);
808 ret
= bits_to_user(mem
, maxbit
, maxlen
, p
, compat
);
810 evdev_queue_syn_dropped(client
);
817 static int evdev_handle_mt_request(struct input_dev
*dev
,
821 const struct input_mt
*mt
= dev
->mt
;
826 if (get_user(code
, &ip
[0]))
828 if (!mt
|| !input_is_mt_value(code
))
831 max_slots
= (size
- sizeof(__u32
)) / sizeof(__s32
);
832 for (i
= 0; i
< mt
->num_slots
&& i
< max_slots
; i
++) {
833 int value
= input_mt_get_value(&mt
->slots
[i
], code
);
834 if (put_user(value
, &ip
[1 + i
]))
841 static int evdev_revoke(struct evdev
*evdev
, struct evdev_client
*client
,
844 client
->revoked
= true;
845 evdev_ungrab(evdev
, client
);
846 input_flush_device(&evdev
->handle
, file
);
847 wake_up_interruptible(&evdev
->wait
);
852 static long evdev_do_ioctl(struct file
*file
, unsigned int cmd
,
853 void __user
*p
, int compat_mode
)
855 struct evdev_client
*client
= file
->private_data
;
856 struct evdev
*evdev
= client
->evdev
;
857 struct input_dev
*dev
= evdev
->handle
.dev
;
858 struct input_absinfo abs
;
859 struct ff_effect effect
;
860 int __user
*ip
= (int __user
*)p
;
861 unsigned int i
, t
, u
, v
;
865 /* First we check for fixed-length commands */
869 return put_user(EV_VERSION
, ip
);
872 if (copy_to_user(p
, &dev
->id
, sizeof(struct input_id
)))
877 if (!test_bit(EV_REP
, dev
->evbit
))
879 if (put_user(dev
->rep
[REP_DELAY
], ip
))
881 if (put_user(dev
->rep
[REP_PERIOD
], ip
+ 1))
886 if (!test_bit(EV_REP
, dev
->evbit
))
890 if (get_user(v
, ip
+ 1))
893 input_inject_event(&evdev
->handle
, EV_REP
, REP_DELAY
, u
);
894 input_inject_event(&evdev
->handle
, EV_REP
, REP_PERIOD
, v
);
899 return input_ff_erase(dev
, (int)(unsigned long) p
, file
);
902 i
= test_bit(EV_FF
, dev
->evbit
) ?
903 dev
->ff
->max_effects
: 0;
910 return evdev_grab(evdev
, client
);
912 return evdev_ungrab(evdev
, client
);
918 return evdev_revoke(evdev
, client
, file
);
921 if (copy_from_user(&i
, p
, sizeof(unsigned int)))
924 return evdev_set_clk_type(client
, i
);
927 return evdev_handle_get_keycode(dev
, p
);
930 return evdev_handle_set_keycode(dev
, p
);
932 case EVIOCGKEYCODE_V2
:
933 return evdev_handle_get_keycode_v2(dev
, p
);
935 case EVIOCSKEYCODE_V2
:
936 return evdev_handle_set_keycode_v2(dev
, p
);
939 size
= _IOC_SIZE(cmd
);
941 /* Now check variable-length commands */
942 #define EVIOC_MASK_SIZE(nr) ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
943 switch (EVIOC_MASK_SIZE(cmd
)) {
946 return bits_to_user(dev
->propbit
, INPUT_PROP_MAX
,
947 size
, p
, compat_mode
);
949 case EVIOCGMTSLOTS(0):
950 return evdev_handle_mt_request(dev
, size
, ip
);
953 return evdev_handle_get_val(client
, dev
, EV_KEY
, dev
->key
,
954 KEY_MAX
, size
, p
, compat_mode
);
957 return evdev_handle_get_val(client
, dev
, EV_LED
, dev
->led
,
958 LED_MAX
, size
, p
, compat_mode
);
961 return evdev_handle_get_val(client
, dev
, EV_SND
, dev
->snd
,
962 SND_MAX
, size
, p
, compat_mode
);
965 return evdev_handle_get_val(client
, dev
, EV_SW
, dev
->sw
,
966 SW_MAX
, size
, p
, compat_mode
);
969 return str_to_user(dev
->name
, size
, p
);
972 return str_to_user(dev
->phys
, size
, p
);
975 return str_to_user(dev
->uniq
, size
, p
);
977 case EVIOC_MASK_SIZE(EVIOCSFF
):
978 if (input_ff_effect_from_user(p
, size
, &effect
))
981 error
= input_ff_upload(dev
, &effect
, file
);
985 if (put_user(effect
.id
, &(((struct ff_effect __user
*)p
)->id
)))
991 /* Multi-number variable-length handlers */
992 if (_IOC_TYPE(cmd
) != 'E')
995 if (_IOC_DIR(cmd
) == _IOC_READ
) {
997 if ((_IOC_NR(cmd
) & ~EV_MAX
) == _IOC_NR(EVIOCGBIT(0, 0)))
998 return handle_eviocgbit(dev
,
999 _IOC_NR(cmd
) & EV_MAX
, size
,
1002 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCGABS(0))) {
1007 t
= _IOC_NR(cmd
) & ABS_MAX
;
1008 abs
= dev
->absinfo
[t
];
1010 if (copy_to_user(p
, &abs
, min_t(size_t,
1011 size
, sizeof(struct input_absinfo
))))
1018 if (_IOC_DIR(cmd
) == _IOC_WRITE
) {
1020 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCSABS(0))) {
1025 t
= _IOC_NR(cmd
) & ABS_MAX
;
1027 if (copy_from_user(&abs
, p
, min_t(size_t,
1028 size
, sizeof(struct input_absinfo
))))
1031 if (size
< sizeof(struct input_absinfo
))
1034 /* We can't change number of reserved MT slots */
1035 if (t
== ABS_MT_SLOT
)
1039 * Take event lock to ensure that we are not
1040 * changing device parameters in the middle
1043 spin_lock_irq(&dev
->event_lock
);
1044 dev
->absinfo
[t
] = abs
;
1045 spin_unlock_irq(&dev
->event_lock
);
1054 static long evdev_ioctl_handler(struct file
*file
, unsigned int cmd
,
1055 void __user
*p
, int compat_mode
)
1057 struct evdev_client
*client
= file
->private_data
;
1058 struct evdev
*evdev
= client
->evdev
;
1061 retval
= mutex_lock_interruptible(&evdev
->mutex
);
1065 if (!evdev
->exist
|| client
->revoked
) {
1070 retval
= evdev_do_ioctl(file
, cmd
, p
, compat_mode
);
1073 mutex_unlock(&evdev
->mutex
);
1077 static long evdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1079 return evdev_ioctl_handler(file
, cmd
, (void __user
*)arg
, 0);
1082 #ifdef CONFIG_COMPAT
1083 static long evdev_ioctl_compat(struct file
*file
,
1084 unsigned int cmd
, unsigned long arg
)
1086 return evdev_ioctl_handler(file
, cmd
, compat_ptr(arg
), 1);
1090 static const struct file_operations evdev_fops
= {
1091 .owner
= THIS_MODULE
,
1093 .write
= evdev_write
,
1096 .release
= evdev_release
,
1097 .unlocked_ioctl
= evdev_ioctl
,
1098 #ifdef CONFIG_COMPAT
1099 .compat_ioctl
= evdev_ioctl_compat
,
1101 .fasync
= evdev_fasync
,
1102 .flush
= evdev_flush
,
1103 .llseek
= no_llseek
,
1107 * Mark device non-existent. This disables writes, ioctls and
1108 * prevents new users from opening the device. Already posted
1109 * blocking reads will stay, however new ones will fail.
1111 static void evdev_mark_dead(struct evdev
*evdev
)
1113 mutex_lock(&evdev
->mutex
);
1114 evdev
->exist
= false;
1115 mutex_unlock(&evdev
->mutex
);
1118 static void evdev_cleanup(struct evdev
*evdev
)
1120 struct input_handle
*handle
= &evdev
->handle
;
1122 evdev_mark_dead(evdev
);
1123 evdev_hangup(evdev
);
1125 cdev_del(&evdev
->cdev
);
1127 /* evdev is marked dead so no one else accesses evdev->open */
1129 input_flush_device(handle
, NULL
);
1130 input_close_device(handle
);
1135 * Create new evdev device. Note that input core serializes calls
1136 * to connect and disconnect.
1138 static int evdev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
1139 const struct input_device_id
*id
)
1141 struct evdev
*evdev
;
1146 minor
= input_get_new_minor(EVDEV_MINOR_BASE
, EVDEV_MINORS
, true);
1149 pr_err("failed to reserve new minor: %d\n", error
);
1153 evdev
= kzalloc(sizeof(struct evdev
), GFP_KERNEL
);
1156 goto err_free_minor
;
1159 INIT_LIST_HEAD(&evdev
->client_list
);
1160 spin_lock_init(&evdev
->client_lock
);
1161 mutex_init(&evdev
->mutex
);
1162 init_waitqueue_head(&evdev
->wait
);
1163 evdev
->exist
= true;
1166 /* Normalize device number if it falls into legacy range */
1167 if (dev_no
< EVDEV_MINOR_BASE
+ EVDEV_MINORS
)
1168 dev_no
-= EVDEV_MINOR_BASE
;
1169 dev_set_name(&evdev
->dev
, "event%d", dev_no
);
1171 evdev
->handle
.dev
= input_get_device(dev
);
1172 evdev
->handle
.name
= dev_name(&evdev
->dev
);
1173 evdev
->handle
.handler
= handler
;
1174 evdev
->handle
.private = evdev
;
1176 evdev
->dev
.devt
= MKDEV(INPUT_MAJOR
, minor
);
1177 evdev
->dev
.class = &input_class
;
1178 evdev
->dev
.parent
= &dev
->dev
;
1179 evdev
->dev
.release
= evdev_free
;
1180 device_initialize(&evdev
->dev
);
1182 error
= input_register_handle(&evdev
->handle
);
1184 goto err_free_evdev
;
1186 cdev_init(&evdev
->cdev
, &evdev_fops
);
1187 evdev
->cdev
.kobj
.parent
= &evdev
->dev
.kobj
;
1188 error
= cdev_add(&evdev
->cdev
, evdev
->dev
.devt
, 1);
1190 goto err_unregister_handle
;
1192 error
= device_add(&evdev
->dev
);
1194 goto err_cleanup_evdev
;
1199 evdev_cleanup(evdev
);
1200 err_unregister_handle
:
1201 input_unregister_handle(&evdev
->handle
);
1203 put_device(&evdev
->dev
);
1205 input_free_minor(minor
);
1209 static void evdev_disconnect(struct input_handle
*handle
)
1211 struct evdev
*evdev
= handle
->private;
1213 device_del(&evdev
->dev
);
1214 evdev_cleanup(evdev
);
1215 input_free_minor(MINOR(evdev
->dev
.devt
));
1216 input_unregister_handle(handle
);
1217 put_device(&evdev
->dev
);
1220 static const struct input_device_id evdev_ids
[] = {
1221 { .driver_info
= 1 }, /* Matches all devices */
1222 { }, /* Terminating zero entry */
1225 MODULE_DEVICE_TABLE(input
, evdev_ids
);
1227 static struct input_handler evdev_handler
= {
1228 .event
= evdev_event
,
1229 .events
= evdev_events
,
1230 .connect
= evdev_connect
,
1231 .disconnect
= evdev_disconnect
,
1232 .legacy_minors
= true,
1233 .minor
= EVDEV_MINOR_BASE
,
1235 .id_table
= evdev_ids
,
1238 static int __init
evdev_init(void)
1240 return input_register_handler(&evdev_handler
);
1243 static void __exit
evdev_exit(void)
1245 input_unregister_handler(&evdev_handler
);
1248 module_init(evdev_init
);
1249 module_exit(evdev_exit
);
1251 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
1252 MODULE_DESCRIPTION("Input driver event char devices");
1253 MODULE_LICENSE("GPL");