2 * User level driver support for input subsystem
4 * Heavily based on evdev.c by Vojtech Pavlik
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * Author: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
23 * 0.4 01/09/2014 (Benjamin Tissoires <benjamin.tissoires@redhat.com>)
24 * - add UI_GET_SYSNAME ioctl
25 * 0.3 09/04/2006 (Anssi Hannula <anssi.hannula@gmail.com>)
26 * - updated ff support for the changes in kernel interface
27 * - added MODULE_VERSION
28 * 0.2 16/10/2004 (Micah Dowty <micah@navi.cx>)
29 * - added force feedback support
32 * - first public version
34 #include <uapi/linux/uinput.h>
35 #include <linux/poll.h>
36 #include <linux/sched.h>
37 #include <linux/slab.h>
38 #include <linux/module.h>
39 #include <linux/init.h>
41 #include <linux/miscdevice.h>
42 #include <linux/overflow.h>
43 #include <linux/input/mt.h>
44 #include "../input-compat.h"
46 #define UINPUT_NAME "uinput"
47 #define UINPUT_BUFFER_SIZE 16
48 #define UINPUT_NUM_REQUESTS 16
50 enum uinput_state
{ UIST_NEW_DEVICE
, UIST_SETUP_COMPLETE
, UIST_CREATED
};
52 struct uinput_request
{
54 unsigned int code
; /* UI_FF_UPLOAD, UI_FF_ERASE */
57 struct completion done
;
60 unsigned int effect_id
;
62 struct ff_effect
*effect
;
63 struct ff_effect
*old
;
68 struct uinput_device
{
69 struct input_dev
*dev
;
71 enum uinput_state state
;
72 wait_queue_head_t waitq
;
76 struct input_event buff
[UINPUT_BUFFER_SIZE
];
77 unsigned int ff_effects_max
;
79 struct uinput_request
*requests
[UINPUT_NUM_REQUESTS
];
80 wait_queue_head_t requests_waitq
;
81 spinlock_t requests_lock
;
84 static int uinput_dev_event(struct input_dev
*dev
,
85 unsigned int type
, unsigned int code
, int value
)
87 struct uinput_device
*udev
= input_get_drvdata(dev
);
90 udev
->buff
[udev
->head
].type
= type
;
91 udev
->buff
[udev
->head
].code
= code
;
92 udev
->buff
[udev
->head
].value
= value
;
94 udev
->buff
[udev
->head
].input_event_sec
= ts
.tv_sec
;
95 udev
->buff
[udev
->head
].input_event_usec
= ts
.tv_nsec
/ NSEC_PER_USEC
;
96 udev
->head
= (udev
->head
+ 1) % UINPUT_BUFFER_SIZE
;
98 wake_up_interruptible(&udev
->waitq
);
103 /* Atomically allocate an ID for the given request. Returns 0 on success. */
104 static bool uinput_request_alloc_id(struct uinput_device
*udev
,
105 struct uinput_request
*request
)
108 bool reserved
= false;
110 spin_lock(&udev
->requests_lock
);
112 for (id
= 0; id
< UINPUT_NUM_REQUESTS
; id
++) {
113 if (!udev
->requests
[id
]) {
115 udev
->requests
[id
] = request
;
121 spin_unlock(&udev
->requests_lock
);
125 static struct uinput_request
*uinput_request_find(struct uinput_device
*udev
,
128 /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
129 if (id
>= UINPUT_NUM_REQUESTS
)
132 return udev
->requests
[id
];
135 static int uinput_request_reserve_slot(struct uinput_device
*udev
,
136 struct uinput_request
*request
)
138 /* Allocate slot. If none are available right away, wait. */
139 return wait_event_interruptible(udev
->requests_waitq
,
140 uinput_request_alloc_id(udev
, request
));
143 static void uinput_request_release_slot(struct uinput_device
*udev
,
146 /* Mark slot as available */
147 spin_lock(&udev
->requests_lock
);
148 udev
->requests
[id
] = NULL
;
149 spin_unlock(&udev
->requests_lock
);
151 wake_up(&udev
->requests_waitq
);
154 static int uinput_request_send(struct uinput_device
*udev
,
155 struct uinput_request
*request
)
159 retval
= mutex_lock_interruptible(&udev
->mutex
);
163 if (udev
->state
!= UIST_CREATED
) {
168 init_completion(&request
->done
);
171 * Tell our userspace application about this new request
172 * by queueing an input event.
174 uinput_dev_event(udev
->dev
, EV_UINPUT
, request
->code
, request
->id
);
177 mutex_unlock(&udev
->mutex
);
181 static int uinput_request_submit(struct uinput_device
*udev
,
182 struct uinput_request
*request
)
186 retval
= uinput_request_reserve_slot(udev
, request
);
190 retval
= uinput_request_send(udev
, request
);
194 if (!wait_for_completion_timeout(&request
->done
, 30 * HZ
)) {
199 retval
= request
->retval
;
202 uinput_request_release_slot(udev
, request
->id
);
207 * Fail all outstanding requests so handlers don't wait for the userspace
208 * to finish processing them.
210 static void uinput_flush_requests(struct uinput_device
*udev
)
212 struct uinput_request
*request
;
215 spin_lock(&udev
->requests_lock
);
217 for (i
= 0; i
< UINPUT_NUM_REQUESTS
; i
++) {
218 request
= udev
->requests
[i
];
220 request
->retval
= -ENODEV
;
221 complete(&request
->done
);
225 spin_unlock(&udev
->requests_lock
);
228 static void uinput_dev_set_gain(struct input_dev
*dev
, u16 gain
)
230 uinput_dev_event(dev
, EV_FF
, FF_GAIN
, gain
);
233 static void uinput_dev_set_autocenter(struct input_dev
*dev
, u16 magnitude
)
235 uinput_dev_event(dev
, EV_FF
, FF_AUTOCENTER
, magnitude
);
238 static int uinput_dev_playback(struct input_dev
*dev
, int effect_id
, int value
)
240 return uinput_dev_event(dev
, EV_FF
, effect_id
, value
);
243 static int uinput_dev_upload_effect(struct input_dev
*dev
,
244 struct ff_effect
*effect
,
245 struct ff_effect
*old
)
247 struct uinput_device
*udev
= input_get_drvdata(dev
);
248 struct uinput_request request
;
251 * uinput driver does not currently support periodic effects with
252 * custom waveform since it does not have a way to pass buffer of
253 * samples (custom_data) to userspace. If ever there is a device
254 * supporting custom waveforms we would need to define an additional
255 * ioctl (UI_UPLOAD_SAMPLES) but for now we just bail out.
257 if (effect
->type
== FF_PERIODIC
&&
258 effect
->u
.periodic
.waveform
== FF_CUSTOM
)
261 request
.code
= UI_FF_UPLOAD
;
262 request
.u
.upload
.effect
= effect
;
263 request
.u
.upload
.old
= old
;
265 return uinput_request_submit(udev
, &request
);
268 static int uinput_dev_erase_effect(struct input_dev
*dev
, int effect_id
)
270 struct uinput_device
*udev
= input_get_drvdata(dev
);
271 struct uinput_request request
;
273 if (!test_bit(EV_FF
, dev
->evbit
))
276 request
.code
= UI_FF_ERASE
;
277 request
.u
.effect_id
= effect_id
;
279 return uinput_request_submit(udev
, &request
);
282 static int uinput_dev_flush(struct input_dev
*dev
, struct file
*file
)
285 * If we are called with file == NULL that means we are tearing
286 * down the device, and therefore we can not handle FF erase
287 * requests: either we are handling UI_DEV_DESTROY (and holding
288 * the udev->mutex), or the file descriptor is closed and there is
289 * nobody on the other side anymore.
291 return file
? input_ff_flush(dev
, file
) : 0;
294 static void uinput_destroy_device(struct uinput_device
*udev
)
296 const char *name
, *phys
;
297 struct input_dev
*dev
= udev
->dev
;
298 enum uinput_state old_state
= udev
->state
;
300 udev
->state
= UIST_NEW_DEVICE
;
305 if (old_state
== UIST_CREATED
) {
306 uinput_flush_requests(udev
);
307 input_unregister_device(dev
);
309 input_free_device(dev
);
317 static int uinput_create_device(struct uinput_device
*udev
)
319 struct input_dev
*dev
= udev
->dev
;
322 if (udev
->state
!= UIST_SETUP_COMPLETE
) {
323 printk(KERN_DEBUG
"%s: write device info first\n", UINPUT_NAME
);
327 if (test_bit(EV_ABS
, dev
->evbit
)) {
328 input_alloc_absinfo(dev
);
334 if (test_bit(ABS_MT_SLOT
, dev
->absbit
)) {
335 nslot
= input_abs_get_max(dev
, ABS_MT_SLOT
) + 1;
336 error
= input_mt_init_slots(dev
, nslot
, 0);
339 } else if (test_bit(ABS_MT_POSITION_X
, dev
->absbit
)) {
340 input_set_events_per_packet(dev
, 60);
344 if (test_bit(EV_FF
, dev
->evbit
) && !udev
->ff_effects_max
) {
345 printk(KERN_DEBUG
"%s: ff_effects_max should be non-zero when FF_BIT is set\n",
351 if (udev
->ff_effects_max
) {
352 error
= input_ff_create(dev
, udev
->ff_effects_max
);
356 dev
->ff
->upload
= uinput_dev_upload_effect
;
357 dev
->ff
->erase
= uinput_dev_erase_effect
;
358 dev
->ff
->playback
= uinput_dev_playback
;
359 dev
->ff
->set_gain
= uinput_dev_set_gain
;
360 dev
->ff
->set_autocenter
= uinput_dev_set_autocenter
;
362 * The standard input_ff_flush() implementation does
363 * not quite work for uinput as we can't reasonably
364 * handle FF requests during device teardown.
366 dev
->flush
= uinput_dev_flush
;
369 dev
->event
= uinput_dev_event
;
371 input_set_drvdata(udev
->dev
, udev
);
373 error
= input_register_device(udev
->dev
);
377 udev
->state
= UIST_CREATED
;
381 fail2
: input_ff_destroy(dev
);
382 fail1
: uinput_destroy_device(udev
);
386 static int uinput_open(struct inode
*inode
, struct file
*file
)
388 struct uinput_device
*newdev
;
390 newdev
= kzalloc(sizeof(struct uinput_device
), GFP_KERNEL
);
394 mutex_init(&newdev
->mutex
);
395 spin_lock_init(&newdev
->requests_lock
);
396 init_waitqueue_head(&newdev
->requests_waitq
);
397 init_waitqueue_head(&newdev
->waitq
);
398 newdev
->state
= UIST_NEW_DEVICE
;
400 file
->private_data
= newdev
;
401 nonseekable_open(inode
, file
);
406 static int uinput_validate_absinfo(struct input_dev
*dev
, unsigned int code
,
407 const struct input_absinfo
*abs
)
414 if ((min
!= 0 || max
!= 0) && max
< min
) {
416 "%s: invalid abs[%02x] min:%d max:%d\n",
417 UINPUT_NAME
, code
, min
, max
);
421 if (!check_sub_overflow(max
, min
, &range
) && abs
->flat
> range
) {
423 "%s: abs_flat #%02x out of range: %d (min:%d/max:%d)\n",
424 UINPUT_NAME
, code
, abs
->flat
, min
, max
);
431 static int uinput_validate_absbits(struct input_dev
*dev
)
436 if (!test_bit(EV_ABS
, dev
->evbit
))
440 * Check if absmin/absmax/absfuzz/absflat are sane.
443 for_each_set_bit(cnt
, dev
->absbit
, ABS_CNT
) {
447 error
= uinput_validate_absinfo(dev
, cnt
, &dev
->absinfo
[cnt
]);
455 static int uinput_dev_setup(struct uinput_device
*udev
,
456 struct uinput_setup __user
*arg
)
458 struct uinput_setup setup
;
459 struct input_dev
*dev
;
461 if (udev
->state
== UIST_CREATED
)
464 if (copy_from_user(&setup
, arg
, sizeof(setup
)))
472 udev
->ff_effects_max
= setup
.ff_effects_max
;
475 dev
->name
= kstrndup(setup
.name
, UINPUT_MAX_NAME_SIZE
, GFP_KERNEL
);
479 udev
->state
= UIST_SETUP_COMPLETE
;
483 static int uinput_abs_setup(struct uinput_device
*udev
,
484 struct uinput_setup __user
*arg
, size_t size
)
486 struct uinput_abs_setup setup
= {};
487 struct input_dev
*dev
;
490 if (size
> sizeof(setup
))
493 if (udev
->state
== UIST_CREATED
)
496 if (copy_from_user(&setup
, arg
, size
))
499 if (setup
.code
> ABS_MAX
)
504 error
= uinput_validate_absinfo(dev
, setup
.code
, &setup
.absinfo
);
508 input_alloc_absinfo(dev
);
512 set_bit(setup
.code
, dev
->absbit
);
513 dev
->absinfo
[setup
.code
] = setup
.absinfo
;
517 /* legacy setup via write() */
518 static int uinput_setup_device_legacy(struct uinput_device
*udev
,
519 const char __user
*buffer
, size_t count
)
521 struct uinput_user_dev
*user_dev
;
522 struct input_dev
*dev
;
526 if (count
!= sizeof(struct uinput_user_dev
))
530 udev
->dev
= input_allocate_device();
537 user_dev
= memdup_user(buffer
, sizeof(struct uinput_user_dev
));
538 if (IS_ERR(user_dev
))
539 return PTR_ERR(user_dev
);
541 udev
->ff_effects_max
= user_dev
->ff_effects_max
;
543 /* Ensure name is filled in */
544 if (!user_dev
->name
[0]) {
550 dev
->name
= kstrndup(user_dev
->name
, UINPUT_MAX_NAME_SIZE
,
557 dev
->id
.bustype
= user_dev
->id
.bustype
;
558 dev
->id
.vendor
= user_dev
->id
.vendor
;
559 dev
->id
.product
= user_dev
->id
.product
;
560 dev
->id
.version
= user_dev
->id
.version
;
562 for (i
= 0; i
< ABS_CNT
; i
++) {
563 input_abs_set_max(dev
, i
, user_dev
->absmax
[i
]);
564 input_abs_set_min(dev
, i
, user_dev
->absmin
[i
]);
565 input_abs_set_fuzz(dev
, i
, user_dev
->absfuzz
[i
]);
566 input_abs_set_flat(dev
, i
, user_dev
->absflat
[i
]);
569 retval
= uinput_validate_absbits(dev
);
573 udev
->state
= UIST_SETUP_COMPLETE
;
581 static ssize_t
uinput_inject_events(struct uinput_device
*udev
,
582 const char __user
*buffer
, size_t count
)
584 struct input_event ev
;
587 if (count
!= 0 && count
< input_event_size())
590 while (bytes
+ input_event_size() <= count
) {
592 * Note that even if some events were fetched successfully
593 * we are still going to return EFAULT instead of partial
594 * count to let userspace know that it got it's buffers
597 if (input_event_from_user(buffer
+ bytes
, &ev
))
600 input_event(udev
->dev
, ev
.type
, ev
.code
, ev
.value
);
601 bytes
+= input_event_size();
608 static ssize_t
uinput_write(struct file
*file
, const char __user
*buffer
,
609 size_t count
, loff_t
*ppos
)
611 struct uinput_device
*udev
= file
->private_data
;
617 retval
= mutex_lock_interruptible(&udev
->mutex
);
621 retval
= udev
->state
== UIST_CREATED
?
622 uinput_inject_events(udev
, buffer
, count
) :
623 uinput_setup_device_legacy(udev
, buffer
, count
);
625 mutex_unlock(&udev
->mutex
);
630 static bool uinput_fetch_next_event(struct uinput_device
*udev
,
631 struct input_event
*event
)
635 spin_lock_irq(&udev
->dev
->event_lock
);
637 have_event
= udev
->head
!= udev
->tail
;
639 *event
= udev
->buff
[udev
->tail
];
640 udev
->tail
= (udev
->tail
+ 1) % UINPUT_BUFFER_SIZE
;
643 spin_unlock_irq(&udev
->dev
->event_lock
);
648 static ssize_t
uinput_events_to_user(struct uinput_device
*udev
,
649 char __user
*buffer
, size_t count
)
651 struct input_event event
;
654 while (read
+ input_event_size() <= count
&&
655 uinput_fetch_next_event(udev
, &event
)) {
657 if (input_event_to_user(buffer
+ read
, &event
))
660 read
+= input_event_size();
666 static ssize_t
uinput_read(struct file
*file
, char __user
*buffer
,
667 size_t count
, loff_t
*ppos
)
669 struct uinput_device
*udev
= file
->private_data
;
672 if (count
!= 0 && count
< input_event_size())
676 retval
= mutex_lock_interruptible(&udev
->mutex
);
680 if (udev
->state
!= UIST_CREATED
)
682 else if (udev
->head
== udev
->tail
&&
683 (file
->f_flags
& O_NONBLOCK
))
686 retval
= uinput_events_to_user(udev
, buffer
, count
);
688 mutex_unlock(&udev
->mutex
);
690 if (retval
|| count
== 0)
693 if (!(file
->f_flags
& O_NONBLOCK
))
694 retval
= wait_event_interruptible(udev
->waitq
,
695 udev
->head
!= udev
->tail
||
696 udev
->state
!= UIST_CREATED
);
697 } while (retval
== 0);
702 static __poll_t
uinput_poll(struct file
*file
, poll_table
*wait
)
704 struct uinput_device
*udev
= file
->private_data
;
706 poll_wait(file
, &udev
->waitq
, wait
);
708 if (udev
->head
!= udev
->tail
)
709 return EPOLLIN
| EPOLLRDNORM
;
714 static int uinput_release(struct inode
*inode
, struct file
*file
)
716 struct uinput_device
*udev
= file
->private_data
;
718 uinput_destroy_device(udev
);
725 struct uinput_ff_upload_compat
{
728 struct ff_effect_compat effect
;
729 struct ff_effect_compat old
;
732 static int uinput_ff_upload_to_user(char __user
*buffer
,
733 const struct uinput_ff_upload
*ff_up
)
735 if (in_compat_syscall()) {
736 struct uinput_ff_upload_compat ff_up_compat
;
738 ff_up_compat
.request_id
= ff_up
->request_id
;
739 ff_up_compat
.retval
= ff_up
->retval
;
741 * It so happens that the pointer that gives us the trouble
742 * is the last field in the structure. Since we don't support
743 * custom waveforms in uinput anyway we can just copy the whole
744 * thing (to the compat size) and ignore the pointer.
746 memcpy(&ff_up_compat
.effect
, &ff_up
->effect
,
747 sizeof(struct ff_effect_compat
));
748 memcpy(&ff_up_compat
.old
, &ff_up
->old
,
749 sizeof(struct ff_effect_compat
));
751 if (copy_to_user(buffer
, &ff_up_compat
,
752 sizeof(struct uinput_ff_upload_compat
)))
755 if (copy_to_user(buffer
, ff_up
,
756 sizeof(struct uinput_ff_upload
)))
763 static int uinput_ff_upload_from_user(const char __user
*buffer
,
764 struct uinput_ff_upload
*ff_up
)
766 if (in_compat_syscall()) {
767 struct uinput_ff_upload_compat ff_up_compat
;
769 if (copy_from_user(&ff_up_compat
, buffer
,
770 sizeof(struct uinput_ff_upload_compat
)))
773 ff_up
->request_id
= ff_up_compat
.request_id
;
774 ff_up
->retval
= ff_up_compat
.retval
;
775 memcpy(&ff_up
->effect
, &ff_up_compat
.effect
,
776 sizeof(struct ff_effect_compat
));
777 memcpy(&ff_up
->old
, &ff_up_compat
.old
,
778 sizeof(struct ff_effect_compat
));
781 if (copy_from_user(ff_up
, buffer
,
782 sizeof(struct uinput_ff_upload
)))
791 static int uinput_ff_upload_to_user(char __user
*buffer
,
792 const struct uinput_ff_upload
*ff_up
)
794 if (copy_to_user(buffer
, ff_up
, sizeof(struct uinput_ff_upload
)))
800 static int uinput_ff_upload_from_user(const char __user
*buffer
,
801 struct uinput_ff_upload
*ff_up
)
803 if (copy_from_user(ff_up
, buffer
, sizeof(struct uinput_ff_upload
)))
811 #define uinput_set_bit(_arg, _bit, _max) \
814 if (udev->state == UIST_CREATED) \
816 else if ((_arg) > (_max)) \
818 else set_bit((_arg), udev->dev->_bit); \
822 static int uinput_str_to_user(void __user
*dest
, const char *str
,
825 char __user
*p
= dest
;
834 len
= strlen(str
) + 1;
838 ret
= copy_to_user(p
, str
, len
);
842 /* force terminating '\0' */
843 ret
= put_user(0, p
+ len
- 1);
844 return ret
? -EFAULT
: len
;
847 static long uinput_ioctl_handler(struct file
*file
, unsigned int cmd
,
848 unsigned long arg
, void __user
*p
)
851 struct uinput_device
*udev
= file
->private_data
;
852 struct uinput_ff_upload ff_up
;
853 struct uinput_ff_erase ff_erase
;
854 struct uinput_request
*req
;
859 retval
= mutex_lock_interruptible(&udev
->mutex
);
864 udev
->dev
= input_allocate_device();
873 if (put_user(UINPUT_VERSION
, (unsigned int __user
*)p
))
878 retval
= uinput_create_device(udev
);
882 uinput_destroy_device(udev
);
886 retval
= uinput_dev_setup(udev
, p
);
889 /* UI_ABS_SETUP is handled in the variable size ioctls */
892 retval
= uinput_set_bit(arg
, evbit
, EV_MAX
);
896 retval
= uinput_set_bit(arg
, keybit
, KEY_MAX
);
900 retval
= uinput_set_bit(arg
, relbit
, REL_MAX
);
904 retval
= uinput_set_bit(arg
, absbit
, ABS_MAX
);
908 retval
= uinput_set_bit(arg
, mscbit
, MSC_MAX
);
912 retval
= uinput_set_bit(arg
, ledbit
, LED_MAX
);
916 retval
= uinput_set_bit(arg
, sndbit
, SND_MAX
);
920 retval
= uinput_set_bit(arg
, ffbit
, FF_MAX
);
924 retval
= uinput_set_bit(arg
, swbit
, SW_MAX
);
928 retval
= uinput_set_bit(arg
, propbit
, INPUT_PROP_MAX
);
932 if (udev
->state
== UIST_CREATED
) {
937 phys
= strndup_user(p
, 1024);
939 retval
= PTR_ERR(phys
);
943 kfree(udev
->dev
->phys
);
944 udev
->dev
->phys
= phys
;
947 case UI_BEGIN_FF_UPLOAD
:
948 retval
= uinput_ff_upload_from_user(p
, &ff_up
);
952 req
= uinput_request_find(udev
, ff_up
.request_id
);
953 if (!req
|| req
->code
!= UI_FF_UPLOAD
||
954 !req
->u
.upload
.effect
) {
960 ff_up
.effect
= *req
->u
.upload
.effect
;
961 if (req
->u
.upload
.old
)
962 ff_up
.old
= *req
->u
.upload
.old
;
964 memset(&ff_up
.old
, 0, sizeof(struct ff_effect
));
966 retval
= uinput_ff_upload_to_user(p
, &ff_up
);
969 case UI_BEGIN_FF_ERASE
:
970 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
975 req
= uinput_request_find(udev
, ff_erase
.request_id
);
976 if (!req
|| req
->code
!= UI_FF_ERASE
) {
982 ff_erase
.effect_id
= req
->u
.effect_id
;
983 if (copy_to_user(p
, &ff_erase
, sizeof(ff_erase
))) {
990 case UI_END_FF_UPLOAD
:
991 retval
= uinput_ff_upload_from_user(p
, &ff_up
);
995 req
= uinput_request_find(udev
, ff_up
.request_id
);
996 if (!req
|| req
->code
!= UI_FF_UPLOAD
||
997 !req
->u
.upload
.effect
) {
1002 req
->retval
= ff_up
.retval
;
1003 complete(&req
->done
);
1006 case UI_END_FF_ERASE
:
1007 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
1012 req
= uinput_request_find(udev
, ff_erase
.request_id
);
1013 if (!req
|| req
->code
!= UI_FF_ERASE
) {
1018 req
->retval
= ff_erase
.retval
;
1019 complete(&req
->done
);
1023 size
= _IOC_SIZE(cmd
);
1025 /* Now check variable-length commands */
1026 switch (cmd
& ~IOCSIZE_MASK
) {
1027 case UI_GET_SYSNAME(0):
1028 if (udev
->state
!= UIST_CREATED
) {
1032 name
= dev_name(&udev
->dev
->dev
);
1033 retval
= uinput_str_to_user(p
, name
, size
);
1036 case UI_ABS_SETUP
& ~IOCSIZE_MASK
:
1037 retval
= uinput_abs_setup(udev
, p
, size
);
1043 mutex_unlock(&udev
->mutex
);
1047 static long uinput_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1049 return uinput_ioctl_handler(file
, cmd
, arg
, (void __user
*)arg
);
1052 #ifdef CONFIG_COMPAT
1054 #define UI_SET_PHYS_COMPAT _IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t)
1056 static long uinput_compat_ioctl(struct file
*file
,
1057 unsigned int cmd
, unsigned long arg
)
1059 if (cmd
== UI_SET_PHYS_COMPAT
)
1062 return uinput_ioctl_handler(file
, cmd
, arg
, compat_ptr(arg
));
1066 static const struct file_operations uinput_fops
= {
1067 .owner
= THIS_MODULE
,
1068 .open
= uinput_open
,
1069 .release
= uinput_release
,
1070 .read
= uinput_read
,
1071 .write
= uinput_write
,
1072 .poll
= uinput_poll
,
1073 .unlocked_ioctl
= uinput_ioctl
,
1074 #ifdef CONFIG_COMPAT
1075 .compat_ioctl
= uinput_compat_ioctl
,
1077 .llseek
= no_llseek
,
1080 static struct miscdevice uinput_misc
= {
1081 .fops
= &uinput_fops
,
1082 .minor
= UINPUT_MINOR
,
1083 .name
= UINPUT_NAME
,
1085 module_misc_device(uinput_misc
);
1087 MODULE_ALIAS_MISCDEV(UINPUT_MINOR
);
1088 MODULE_ALIAS("devname:" UINPUT_NAME
);
1090 MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
1091 MODULE_DESCRIPTION("User level driver support for input subsystem");
1092 MODULE_LICENSE("GPL");