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 <linux/wakelock.h>
30 #include "input-compat.h"
34 struct input_handle handle
;
35 wait_queue_head_t wait
;
36 struct evdev_client __rcu
*grab
;
37 struct list_head client_list
;
38 spinlock_t client_lock
; /* protects client_list */
48 unsigned int packet_head
; /* [future] position of the first element of next packet */
49 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
50 struct wake_lock wake_lock
;
53 struct fasync_struct
*fasync
;
55 struct list_head node
;
58 struct input_event buffer
[];
61 static void __pass_event(struct evdev_client
*client
,
62 const struct input_event
*event
)
64 client
->buffer
[client
->head
++] = *event
;
65 client
->head
&= client
->bufsize
- 1;
67 if (unlikely(client
->head
== client
->tail
)) {
69 * This effectively "drops" all unconsumed events, leaving
70 * EV_SYN/SYN_DROPPED plus the newest event in the queue.
72 client
->tail
= (client
->head
- 2) & (client
->bufsize
- 1);
74 client
->buffer
[client
->tail
].time
= event
->time
;
75 client
->buffer
[client
->tail
].type
= EV_SYN
;
76 client
->buffer
[client
->tail
].code
= SYN_DROPPED
;
77 client
->buffer
[client
->tail
].value
= 0;
79 client
->packet_head
= client
->tail
;
80 if (client
->use_wake_lock
)
81 wake_unlock(&client
->wake_lock
);
84 if (event
->type
== EV_SYN
&& event
->code
== SYN_REPORT
) {
85 client
->packet_head
= client
->head
;
86 if (client
->use_wake_lock
)
87 wake_lock(&client
->wake_lock
);
88 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
92 /** M: MET driver milestone. @{ */
95 #define CREATE_TRACE_POINTS
96 #include <linux/met_ftrace_touch.h>
98 noinline
void MET_touch(struct input_event
* event
)
100 switch (event
->type
) {
102 if (ABS_MT_POSITION_X
== event
->code
) {
103 trace_MET_touch("EV_ABS", event
->time
.tv_sec
, event
->time
.tv_usec
,"X", event
->value
);
104 } else if (ABS_MT_POSITION_Y
== event
->code
) {
105 trace_MET_touch("EV_ABS", event
->time
.tv_sec
, event
->time
.tv_usec
,"Y", event
->value
);
109 if (BTN_TOUCH
== event
->code
) {
110 trace_MET_touch("EV_KEY", event
->time
.tv_sec
, event
->time
.tv_usec
,"BTN_TOUCH", event
->value
);
118 static void evdev_pass_values(struct evdev_client
*client
,
119 const struct input_value
*vals
, unsigned int count
,
120 ktime_t mono
, ktime_t real
)
122 struct evdev
*evdev
= client
->evdev
;
123 const struct input_value
*v
;
124 struct input_event event
;
127 event
.time
= ktime_to_timeval(client
->clkid
== CLOCK_MONOTONIC
?
130 /* Interrupts are disabled, just acquire the lock. */
131 spin_lock(&client
->buffer_lock
);
133 for (v
= vals
; v
!= vals
+ count
; v
++) {
134 event
.type
= v
->type
;
135 event
.code
= v
->code
;
136 event
.value
= v
->value
;
137 __pass_event(client
, &event
);
138 /** M: MET driver milestone. @{ */
143 if (v
->type
== EV_SYN
&& v
->code
== SYN_REPORT
)
147 spin_unlock(&client
->buffer_lock
);
150 wake_up_interruptible(&evdev
->wait
);
154 * Pass incoming events to all connected clients.
156 static void evdev_events(struct input_handle
*handle
,
157 const struct input_value
*vals
, unsigned int count
)
159 struct evdev
*evdev
= handle
->private;
160 struct evdev_client
*client
;
161 ktime_t time_mono
, time_real
;
163 time_mono
= ktime_get();
164 time_real
= ktime_sub(time_mono
, ktime_get_monotonic_offset());
168 client
= rcu_dereference(evdev
->grab
);
171 evdev_pass_values(client
, vals
, count
, time_mono
, time_real
);
173 list_for_each_entry_rcu(client
, &evdev
->client_list
, node
)
174 evdev_pass_values(client
, vals
, count
,
175 time_mono
, time_real
);
181 * Pass incoming event to all connected clients.
183 static void evdev_event(struct input_handle
*handle
,
184 unsigned int type
, unsigned int code
, int value
)
186 struct input_value vals
[] = { { type
, code
, value
} };
188 evdev_events(handle
, vals
, 1);
191 static int evdev_fasync(int fd
, struct file
*file
, int on
)
193 struct evdev_client
*client
= file
->private_data
;
195 return fasync_helper(fd
, file
, on
, &client
->fasync
);
198 static int evdev_flush(struct file
*file
, fl_owner_t id
)
200 struct evdev_client
*client
= file
->private_data
;
201 struct evdev
*evdev
= client
->evdev
;
204 retval
= mutex_lock_interruptible(&evdev
->mutex
);
211 retval
= input_flush_device(&evdev
->handle
, file
);
213 mutex_unlock(&evdev
->mutex
);
217 static void evdev_free(struct device
*dev
)
219 struct evdev
*evdev
= container_of(dev
, struct evdev
, dev
);
221 input_put_device(evdev
->handle
.dev
);
226 * Grabs an event device (along with underlying input device).
227 * This function is called with evdev->mutex taken.
229 static int evdev_grab(struct evdev
*evdev
, struct evdev_client
*client
)
236 error
= input_grab_device(&evdev
->handle
);
240 rcu_assign_pointer(evdev
->grab
, client
);
245 static int evdev_ungrab(struct evdev
*evdev
, struct evdev_client
*client
)
247 struct evdev_client
*grab
= rcu_dereference_protected(evdev
->grab
,
248 lockdep_is_held(&evdev
->mutex
));
253 rcu_assign_pointer(evdev
->grab
, NULL
);
255 input_release_device(&evdev
->handle
);
260 static void evdev_attach_client(struct evdev
*evdev
,
261 struct evdev_client
*client
)
263 spin_lock(&evdev
->client_lock
);
264 list_add_tail_rcu(&client
->node
, &evdev
->client_list
);
265 spin_unlock(&evdev
->client_lock
);
268 static void evdev_detach_client(struct evdev
*evdev
,
269 struct evdev_client
*client
)
271 spin_lock(&evdev
->client_lock
);
272 list_del_rcu(&client
->node
);
273 spin_unlock(&evdev
->client_lock
);
277 static int evdev_open_device(struct evdev
*evdev
)
281 retval
= mutex_lock_interruptible(&evdev
->mutex
);
287 else if (!evdev
->open
++) {
288 retval
= input_open_device(&evdev
->handle
);
293 mutex_unlock(&evdev
->mutex
);
297 static void evdev_close_device(struct evdev
*evdev
)
299 mutex_lock(&evdev
->mutex
);
301 if (evdev
->exist
&& !--evdev
->open
)
302 input_close_device(&evdev
->handle
);
304 mutex_unlock(&evdev
->mutex
);
308 * Wake up users waiting for IO so they can disconnect from
311 static void evdev_hangup(struct evdev
*evdev
)
313 struct evdev_client
*client
;
315 spin_lock(&evdev
->client_lock
);
316 list_for_each_entry(client
, &evdev
->client_list
, node
)
317 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
318 spin_unlock(&evdev
->client_lock
);
320 wake_up_interruptible(&evdev
->wait
);
323 static int evdev_release(struct inode
*inode
, struct file
*file
)
325 struct evdev_client
*client
= file
->private_data
;
326 struct evdev
*evdev
= client
->evdev
;
328 mutex_lock(&evdev
->mutex
);
329 evdev_ungrab(evdev
, client
);
330 mutex_unlock(&evdev
->mutex
);
332 evdev_detach_client(evdev
, client
);
333 if (client
->use_wake_lock
)
334 wake_lock_destroy(&client
->wake_lock
);
336 if (is_vmalloc_addr(client
))
341 evdev_close_device(evdev
);
346 static unsigned int evdev_compute_buffer_size(struct input_dev
*dev
)
348 unsigned int n_events
=
349 max(dev
->hint_events_per_packet
* EVDEV_BUF_PACKETS
,
350 EVDEV_MIN_BUFFER_SIZE
);
352 return roundup_pow_of_two(n_events
);
355 static int evdev_open(struct inode
*inode
, struct file
*file
)
357 struct evdev
*evdev
= container_of(inode
->i_cdev
, struct evdev
, cdev
);
358 unsigned int bufsize
= evdev_compute_buffer_size(evdev
->handle
.dev
);
359 unsigned int size
= sizeof(struct evdev_client
) +
360 bufsize
* sizeof(struct input_event
);
361 struct evdev_client
*client
;
364 client
= kzalloc(size
, GFP_KERNEL
| __GFP_NOWARN
);
366 client
= vzalloc(size
);
370 client
->bufsize
= bufsize
;
371 spin_lock_init(&client
->buffer_lock
);
372 snprintf(client
->name
, sizeof(client
->name
), "%s-%d",
373 dev_name(&evdev
->dev
), task_tgid_vnr(current
));
374 client
->evdev
= evdev
;
375 evdev_attach_client(evdev
, client
);
377 error
= evdev_open_device(evdev
);
379 goto err_free_client
;
381 file
->private_data
= client
;
382 nonseekable_open(inode
, file
);
387 evdev_detach_client(evdev
, client
);
392 static ssize_t
evdev_write(struct file
*file
, const char __user
*buffer
,
393 size_t count
, loff_t
*ppos
)
395 struct evdev_client
*client
= file
->private_data
;
396 struct evdev
*evdev
= client
->evdev
;
397 struct input_event event
;
400 if (count
!= 0 && count
< input_event_size())
403 retval
= mutex_lock_interruptible(&evdev
->mutex
);
412 while (retval
+ input_event_size() <= count
) {
414 if (input_event_from_user(buffer
+ retval
, &event
)) {
418 retval
+= input_event_size();
420 input_inject_event(&evdev
->handle
,
421 event
.type
, event
.code
, event
.value
);
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
->packet_head
!= client
->tail
;
438 *event
= client
->buffer
[client
->tail
++];
439 client
->tail
&= client
->bufsize
- 1;
440 if (client
->use_wake_lock
&&
441 client
->packet_head
== client
->tail
)
442 wake_unlock(&client
->wake_lock
);
445 spin_unlock_irq(&client
->buffer_lock
);
450 static ssize_t
evdev_read(struct file
*file
, char __user
*buffer
,
451 size_t count
, loff_t
*ppos
)
453 struct evdev_client
*client
= file
->private_data
;
454 struct evdev
*evdev
= client
->evdev
;
455 struct input_event event
;
459 if (count
!= 0 && count
< input_event_size())
466 if (client
->packet_head
== client
->tail
&&
467 (file
->f_flags
& O_NONBLOCK
))
471 * count == 0 is special - no IO is done but we check
472 * for error conditions (see above).
477 while (read
+ input_event_size() <= count
&&
478 evdev_fetch_next_event(client
, &event
)) {
480 if (input_event_to_user(buffer
+ read
, &event
))
483 read
+= input_event_size();
489 if (!(file
->f_flags
& O_NONBLOCK
)) {
490 error
= wait_event_interruptible(evdev
->wait
,
491 client
->packet_head
!= client
->tail
||
501 /* No kernel lock - fine */
502 static unsigned int evdev_poll(struct file
*file
, poll_table
*wait
)
504 struct evdev_client
*client
= file
->private_data
;
505 struct evdev
*evdev
= client
->evdev
;
508 poll_wait(file
, &evdev
->wait
, wait
);
510 mask
= evdev
->exist
? POLLOUT
| POLLWRNORM
: POLLHUP
| POLLERR
;
511 if (client
->packet_head
!= client
->tail
)
512 mask
|= POLLIN
| POLLRDNORM
;
519 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
520 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
523 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
524 unsigned int maxlen
, void __user
*p
, int compat
)
529 len
= BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
);
533 for (i
= 0; i
< len
/ sizeof(compat_long_t
); i
++)
534 if (copy_to_user((compat_long_t __user
*) p
+ i
,
535 (compat_long_t
*) bits
+
536 i
+ 1 - ((i
% 2) << 1),
537 sizeof(compat_long_t
)))
540 len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
544 if (copy_to_user(p
, bits
, len
))
551 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
552 unsigned int maxlen
, void __user
*p
, int compat
)
555 BITS_TO_LONGS_COMPAT(maxbit
) * sizeof(compat_long_t
) :
556 BITS_TO_LONGS(maxbit
) * sizeof(long);
561 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
563 #endif /* __BIG_ENDIAN */
567 static int bits_to_user(unsigned long *bits
, unsigned int maxbit
,
568 unsigned int maxlen
, void __user
*p
, int compat
)
570 int len
= BITS_TO_LONGS(maxbit
) * sizeof(long);
575 return copy_to_user(p
, bits
, len
) ? -EFAULT
: len
;
578 #endif /* CONFIG_COMPAT */
580 static int str_to_user(const char *str
, unsigned int maxlen
, void __user
*p
)
587 len
= strlen(str
) + 1;
591 return copy_to_user(p
, str
, len
) ? -EFAULT
: len
;
594 #define OLD_KEY_MAX 0x1ff
595 static int handle_eviocgbit(struct input_dev
*dev
,
596 unsigned int type
, unsigned int size
,
597 void __user
*p
, int compat_mode
)
599 static unsigned long keymax_warn_time
;
605 case 0: bits
= dev
->evbit
; len
= EV_MAX
; break;
606 case EV_KEY
: bits
= dev
->keybit
; len
= KEY_MAX
; break;
607 case EV_REL
: bits
= dev
->relbit
; len
= REL_MAX
; break;
608 case EV_ABS
: bits
= dev
->absbit
; len
= ABS_MAX
; break;
609 case EV_MSC
: bits
= dev
->mscbit
; len
= MSC_MAX
; break;
610 case EV_LED
: bits
= dev
->ledbit
; len
= LED_MAX
; break;
611 case EV_SND
: bits
= dev
->sndbit
; len
= SND_MAX
; break;
612 case EV_FF
: bits
= dev
->ffbit
; len
= FF_MAX
; break;
613 case EV_SW
: bits
= dev
->swbit
; len
= SW_MAX
; break;
614 default: return -EINVAL
;
618 * Work around bugs in userspace programs that like to do
619 * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len'
620 * should be in bytes, not in bits.
622 if (type
== EV_KEY
&& size
== OLD_KEY_MAX
) {
624 if (printk_timed_ratelimit(&keymax_warn_time
, 10 * 1000))
625 pr_warning("(EVIOCGBIT): Suspicious buffer size %u, "
626 "limiting output to %zu bytes. See "
627 "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n",
629 BITS_TO_LONGS(OLD_KEY_MAX
) * sizeof(long));
632 return bits_to_user(bits
, len
, size
, p
, compat_mode
);
636 static int evdev_handle_get_keycode(struct input_dev
*dev
, void __user
*p
)
638 struct input_keymap_entry ke
= {
639 .len
= sizeof(unsigned int),
642 int __user
*ip
= (int __user
*)p
;
646 if (copy_from_user(ke
.scancode
, p
, sizeof(unsigned int)))
649 error
= input_get_keycode(dev
, &ke
);
653 if (put_user(ke
.keycode
, ip
+ 1))
659 static int evdev_handle_get_keycode_v2(struct input_dev
*dev
, void __user
*p
)
661 struct input_keymap_entry ke
;
664 if (copy_from_user(&ke
, p
, sizeof(ke
)))
667 error
= input_get_keycode(dev
, &ke
);
671 if (copy_to_user(p
, &ke
, sizeof(ke
)))
677 static int evdev_handle_set_keycode(struct input_dev
*dev
, void __user
*p
)
679 struct input_keymap_entry ke
= {
680 .len
= sizeof(unsigned int),
683 int __user
*ip
= (int __user
*)p
;
685 if (copy_from_user(ke
.scancode
, p
, sizeof(unsigned int)))
688 if (get_user(ke
.keycode
, ip
+ 1))
691 return input_set_keycode(dev
, &ke
);
694 static int evdev_handle_set_keycode_v2(struct input_dev
*dev
, void __user
*p
)
696 struct input_keymap_entry ke
;
698 if (copy_from_user(&ke
, p
, sizeof(ke
)))
701 if (ke
.len
> sizeof(ke
.scancode
))
704 return input_set_keycode(dev
, &ke
);
707 static int evdev_handle_mt_request(struct input_dev
*dev
,
711 const struct input_mt
*mt
= dev
->mt
;
716 if (get_user(code
, &ip
[0]))
718 if (!mt
|| !input_is_mt_value(code
))
721 max_slots
= (size
- sizeof(__u32
)) / sizeof(__s32
);
722 for (i
= 0; i
< mt
->num_slots
&& i
< max_slots
; i
++) {
723 int value
= input_mt_get_value(&mt
->slots
[i
], code
);
724 if (put_user(value
, &ip
[1 + i
]))
731 static int evdev_enable_suspend_block(struct evdev
*evdev
,
732 struct evdev_client
*client
)
734 if (client
->use_wake_lock
)
737 spin_lock_irq(&client
->buffer_lock
);
738 wake_lock_init(&client
->wake_lock
, WAKE_LOCK_SUSPEND
, client
->name
);
739 client
->use_wake_lock
= true;
740 if (client
->packet_head
!= client
->tail
)
741 wake_lock(&client
->wake_lock
);
742 spin_unlock_irq(&client
->buffer_lock
);
746 static int evdev_disable_suspend_block(struct evdev
*evdev
,
747 struct evdev_client
*client
)
749 if (!client
->use_wake_lock
)
752 spin_lock_irq(&client
->buffer_lock
);
753 client
->use_wake_lock
= false;
754 wake_lock_destroy(&client
->wake_lock
);
755 spin_unlock_irq(&client
->buffer_lock
);
760 static long evdev_do_ioctl(struct file
*file
, unsigned int cmd
,
761 void __user
*p
, int compat_mode
)
763 struct evdev_client
*client
= file
->private_data
;
764 struct evdev
*evdev
= client
->evdev
;
765 struct input_dev
*dev
= evdev
->handle
.dev
;
766 struct input_absinfo abs
;
767 struct ff_effect effect
;
768 int __user
*ip
= (int __user
*)p
;
769 unsigned int i
, t
, u
, v
;
773 /* First we check for fixed-length commands */
777 return put_user(EV_VERSION
, ip
);
780 if (copy_to_user(p
, &dev
->id
, sizeof(struct input_id
)))
785 if (!test_bit(EV_REP
, dev
->evbit
))
787 if (put_user(dev
->rep
[REP_DELAY
], ip
))
789 if (put_user(dev
->rep
[REP_PERIOD
], ip
+ 1))
794 if (!test_bit(EV_REP
, dev
->evbit
))
798 if (get_user(v
, ip
+ 1))
801 input_inject_event(&evdev
->handle
, EV_REP
, REP_DELAY
, u
);
802 input_inject_event(&evdev
->handle
, EV_REP
, REP_PERIOD
, v
);
807 return input_ff_erase(dev
, (int)(unsigned long) p
, file
);
810 i
= test_bit(EV_FF
, dev
->evbit
) ?
811 dev
->ff
->max_effects
: 0;
818 return evdev_grab(evdev
, client
);
820 return evdev_ungrab(evdev
, client
);
823 if (copy_from_user(&i
, p
, sizeof(unsigned int)))
825 if (i
!= CLOCK_MONOTONIC
&& i
!= CLOCK_REALTIME
)
831 return evdev_handle_get_keycode(dev
, p
);
834 return evdev_handle_set_keycode(dev
, p
);
836 case EVIOCGKEYCODE_V2
:
837 return evdev_handle_get_keycode_v2(dev
, p
);
839 case EVIOCSKEYCODE_V2
:
840 return evdev_handle_set_keycode_v2(dev
, p
);
842 case EVIOCGSUSPENDBLOCK
:
843 return put_user(client
->use_wake_lock
, ip
);
845 case EVIOCSSUSPENDBLOCK
:
847 return evdev_enable_suspend_block(evdev
, client
);
849 return evdev_disable_suspend_block(evdev
, client
);
852 size
= _IOC_SIZE(cmd
);
854 /* Now check variable-length commands */
855 #define EVIOC_MASK_SIZE(nr) ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
856 switch (EVIOC_MASK_SIZE(cmd
)) {
859 return bits_to_user(dev
->propbit
, INPUT_PROP_MAX
,
860 size
, p
, compat_mode
);
862 case EVIOCGMTSLOTS(0):
863 return evdev_handle_mt_request(dev
, size
, ip
);
866 return bits_to_user(dev
->key
, KEY_MAX
, size
, p
, compat_mode
);
869 return bits_to_user(dev
->led
, LED_MAX
, size
, p
, compat_mode
);
872 return bits_to_user(dev
->snd
, SND_MAX
, size
, p
, compat_mode
);
875 return bits_to_user(dev
->sw
, SW_MAX
, size
, p
, compat_mode
);
878 return str_to_user(dev
->name
, size
, p
);
881 return str_to_user(dev
->phys
, size
, p
);
884 return str_to_user(dev
->uniq
, size
, p
);
886 case EVIOC_MASK_SIZE(EVIOCSFF
):
887 if (input_ff_effect_from_user(p
, size
, &effect
))
890 error
= input_ff_upload(dev
, &effect
, file
);
892 if (put_user(effect
.id
, &(((struct ff_effect __user
*)p
)->id
)))
898 /* Multi-number variable-length handlers */
899 if (_IOC_TYPE(cmd
) != 'E')
902 if (_IOC_DIR(cmd
) == _IOC_READ
) {
904 if ((_IOC_NR(cmd
) & ~EV_MAX
) == _IOC_NR(EVIOCGBIT(0, 0)))
905 return handle_eviocgbit(dev
,
906 _IOC_NR(cmd
) & EV_MAX
, size
,
909 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCGABS(0))) {
914 t
= _IOC_NR(cmd
) & ABS_MAX
;
915 abs
= dev
->absinfo
[t
];
917 if (copy_to_user(p
, &abs
, min_t(size_t,
918 size
, sizeof(struct input_absinfo
))))
925 if (_IOC_DIR(cmd
) == _IOC_WRITE
) {
927 if ((_IOC_NR(cmd
) & ~ABS_MAX
) == _IOC_NR(EVIOCSABS(0))) {
932 t
= _IOC_NR(cmd
) & ABS_MAX
;
934 if (copy_from_user(&abs
, p
, min_t(size_t,
935 size
, sizeof(struct input_absinfo
))))
938 if (size
< sizeof(struct input_absinfo
))
941 /* We can't change number of reserved MT slots */
942 if (t
== ABS_MT_SLOT
)
946 * Take event lock to ensure that we are not
947 * changing device parameters in the middle
950 spin_lock_irq(&dev
->event_lock
);
951 dev
->absinfo
[t
] = abs
;
952 spin_unlock_irq(&dev
->event_lock
);
961 static long evdev_ioctl_handler(struct file
*file
, unsigned int cmd
,
962 void __user
*p
, int compat_mode
)
964 struct evdev_client
*client
= file
->private_data
;
965 struct evdev
*evdev
= client
->evdev
;
968 retval
= mutex_lock_interruptible(&evdev
->mutex
);
977 retval
= evdev_do_ioctl(file
, cmd
, p
, compat_mode
);
980 mutex_unlock(&evdev
->mutex
);
984 static long evdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
986 return evdev_ioctl_handler(file
, cmd
, (void __user
*)arg
, 0);
990 static long evdev_ioctl_compat(struct file
*file
,
991 unsigned int cmd
, unsigned long arg
)
993 return evdev_ioctl_handler(file
, cmd
, compat_ptr(arg
), 1);
997 static const struct file_operations evdev_fops
= {
998 .owner
= THIS_MODULE
,
1000 .write
= evdev_write
,
1003 .release
= evdev_release
,
1004 .unlocked_ioctl
= evdev_ioctl
,
1005 #ifdef CONFIG_COMPAT
1006 .compat_ioctl
= evdev_ioctl_compat
,
1008 .fasync
= evdev_fasync
,
1009 .flush
= evdev_flush
,
1010 .llseek
= no_llseek
,
1014 * Mark device non-existent. This disables writes, ioctls and
1015 * prevents new users from opening the device. Already posted
1016 * blocking reads will stay, however new ones will fail.
1018 static void evdev_mark_dead(struct evdev
*evdev
)
1020 mutex_lock(&evdev
->mutex
);
1021 evdev
->exist
= false;
1022 mutex_unlock(&evdev
->mutex
);
1025 static void evdev_cleanup(struct evdev
*evdev
)
1027 struct input_handle
*handle
= &evdev
->handle
;
1029 evdev_mark_dead(evdev
);
1030 evdev_hangup(evdev
);
1032 cdev_del(&evdev
->cdev
);
1034 /* evdev is marked dead so no one else accesses evdev->open */
1036 input_flush_device(handle
, NULL
);
1037 input_close_device(handle
);
1042 * Create new evdev device. Note that input core serializes calls
1043 * to connect and disconnect.
1045 static int evdev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
1046 const struct input_device_id
*id
)
1048 struct evdev
*evdev
;
1053 minor
= input_get_new_minor(EVDEV_MINOR_BASE
, EVDEV_MINORS
, true);
1056 pr_err("failed to reserve new minor: %d\n", error
);
1060 evdev
= kzalloc(sizeof(struct evdev
), GFP_KERNEL
);
1063 goto err_free_minor
;
1066 INIT_LIST_HEAD(&evdev
->client_list
);
1067 spin_lock_init(&evdev
->client_lock
);
1068 mutex_init(&evdev
->mutex
);
1069 init_waitqueue_head(&evdev
->wait
);
1070 evdev
->exist
= true;
1073 /* Normalize device number if it falls into legacy range */
1074 if (dev_no
< EVDEV_MINOR_BASE
+ EVDEV_MINORS
)
1075 dev_no
-= EVDEV_MINOR_BASE
;
1076 dev_set_name(&evdev
->dev
, "event%d", dev_no
);
1078 evdev
->handle
.dev
= input_get_device(dev
);
1079 evdev
->handle
.name
= dev_name(&evdev
->dev
);
1080 evdev
->handle
.handler
= handler
;
1081 evdev
->handle
.private = evdev
;
1083 evdev
->dev
.devt
= MKDEV(INPUT_MAJOR
, minor
);
1084 evdev
->dev
.class = &input_class
;
1085 evdev
->dev
.parent
= &dev
->dev
;
1086 evdev
->dev
.release
= evdev_free
;
1087 device_initialize(&evdev
->dev
);
1089 error
= input_register_handle(&evdev
->handle
);
1091 goto err_free_evdev
;
1093 cdev_init(&evdev
->cdev
, &evdev_fops
);
1094 evdev
->cdev
.kobj
.parent
= &evdev
->dev
.kobj
;
1095 error
= cdev_add(&evdev
->cdev
, evdev
->dev
.devt
, 1);
1097 goto err_unregister_handle
;
1099 error
= device_add(&evdev
->dev
);
1101 goto err_cleanup_evdev
;
1106 evdev_cleanup(evdev
);
1107 err_unregister_handle
:
1108 input_unregister_handle(&evdev
->handle
);
1110 put_device(&evdev
->dev
);
1112 input_free_minor(minor
);
1116 static void evdev_disconnect(struct input_handle
*handle
)
1118 struct evdev
*evdev
= handle
->private;
1120 device_del(&evdev
->dev
);
1121 evdev_cleanup(evdev
);
1122 input_free_minor(MINOR(evdev
->dev
.devt
));
1123 input_unregister_handle(handle
);
1124 put_device(&evdev
->dev
);
1127 static const struct input_device_id evdev_ids
[] = {
1128 { .driver_info
= 1 }, /* Matches all devices */
1129 { }, /* Terminating zero entry */
1132 MODULE_DEVICE_TABLE(input
, evdev_ids
);
1134 static struct input_handler evdev_handler
= {
1135 .event
= evdev_event
,
1136 .events
= evdev_events
,
1137 .connect
= evdev_connect
,
1138 .disconnect
= evdev_disconnect
,
1139 .legacy_minors
= true,
1140 .minor
= EVDEV_MINOR_BASE
,
1142 .id_table
= evdev_ids
,
1145 static int __init
evdev_init(void)
1147 return input_register_handler(&evdev_handler
);
1150 static void __exit
evdev_exit(void)
1152 input_unregister_handler(&evdev_handler
);
1155 module_init(evdev_init
);
1156 module_exit(evdev_exit
);
1158 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
1159 MODULE_DESCRIPTION("Input driver event char devices");
1160 MODULE_LICENSE("GPL");