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 <linux/poll.h>
35 #include <linux/sched.h>
36 #include <linux/slab.h>
37 #include <linux/module.h>
38 #include <linux/init.h>
40 #include <linux/miscdevice.h>
41 #include <linux/uinput.h>
42 #include <linux/input/mt.h>
43 #include "../input-compat.h"
45 static int uinput_dev_event(struct input_dev
*dev
,
46 unsigned int type
, unsigned int code
, int value
)
48 struct uinput_device
*udev
= input_get_drvdata(dev
);
50 udev
->buff
[udev
->head
].type
= type
;
51 udev
->buff
[udev
->head
].code
= code
;
52 udev
->buff
[udev
->head
].value
= value
;
53 do_gettimeofday(&udev
->buff
[udev
->head
].time
);
54 udev
->head
= (udev
->head
+ 1) % UINPUT_BUFFER_SIZE
;
56 wake_up_interruptible(&udev
->waitq
);
61 /* Atomically allocate an ID for the given request. Returns 0 on success. */
62 static bool uinput_request_alloc_id(struct uinput_device
*udev
,
63 struct uinput_request
*request
)
66 bool reserved
= false;
68 spin_lock(&udev
->requests_lock
);
70 for (id
= 0; id
< UINPUT_NUM_REQUESTS
; id
++) {
71 if (!udev
->requests
[id
]) {
73 udev
->requests
[id
] = request
;
79 spin_unlock(&udev
->requests_lock
);
83 static struct uinput_request
*uinput_request_find(struct uinput_device
*udev
,
86 /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
87 if (id
>= UINPUT_NUM_REQUESTS
)
90 return udev
->requests
[id
];
93 static int uinput_request_reserve_slot(struct uinput_device
*udev
,
94 struct uinput_request
*request
)
96 /* Allocate slot. If none are available right away, wait. */
97 return wait_event_interruptible(udev
->requests_waitq
,
98 uinput_request_alloc_id(udev
, request
));
101 static void uinput_request_release_slot(struct uinput_device
*udev
,
104 /* Mark slot as available */
105 spin_lock(&udev
->requests_lock
);
106 udev
->requests
[id
] = NULL
;
107 spin_unlock(&udev
->requests_lock
);
109 wake_up(&udev
->requests_waitq
);
112 static int uinput_request_send(struct uinput_device
*udev
,
113 struct uinput_request
*request
)
117 retval
= mutex_lock_interruptible(&udev
->mutex
);
121 if (udev
->state
!= UIST_CREATED
) {
126 init_completion(&request
->done
);
129 * Tell our userspace application about this new request
130 * by queueing an input event.
132 uinput_dev_event(udev
->dev
, EV_UINPUT
, request
->code
, request
->id
);
135 mutex_unlock(&udev
->mutex
);
139 static int uinput_request_submit(struct uinput_device
*udev
,
140 struct uinput_request
*request
)
144 retval
= uinput_request_reserve_slot(udev
, request
);
148 retval
= uinput_request_send(udev
, request
);
152 wait_for_completion(&request
->done
);
153 retval
= request
->retval
;
156 uinput_request_release_slot(udev
, request
->id
);
161 * Fail all outstanding requests so handlers don't wait for the userspace
162 * to finish processing them.
164 static void uinput_flush_requests(struct uinput_device
*udev
)
166 struct uinput_request
*request
;
169 spin_lock(&udev
->requests_lock
);
171 for (i
= 0; i
< UINPUT_NUM_REQUESTS
; i
++) {
172 request
= udev
->requests
[i
];
174 request
->retval
= -ENODEV
;
175 complete(&request
->done
);
179 spin_unlock(&udev
->requests_lock
);
182 static void uinput_dev_set_gain(struct input_dev
*dev
, u16 gain
)
184 uinput_dev_event(dev
, EV_FF
, FF_GAIN
, gain
);
187 static void uinput_dev_set_autocenter(struct input_dev
*dev
, u16 magnitude
)
189 uinput_dev_event(dev
, EV_FF
, FF_AUTOCENTER
, magnitude
);
192 static int uinput_dev_playback(struct input_dev
*dev
, int effect_id
, int value
)
194 return uinput_dev_event(dev
, EV_FF
, effect_id
, value
);
197 static int uinput_dev_upload_effect(struct input_dev
*dev
,
198 struct ff_effect
*effect
,
199 struct ff_effect
*old
)
201 struct uinput_device
*udev
= input_get_drvdata(dev
);
202 struct uinput_request request
;
205 * uinput driver does not currently support periodic effects with
206 * custom waveform since it does not have a way to pass buffer of
207 * samples (custom_data) to userspace. If ever there is a device
208 * supporting custom waveforms we would need to define an additional
209 * ioctl (UI_UPLOAD_SAMPLES) but for now we just bail out.
211 if (effect
->type
== FF_PERIODIC
&&
212 effect
->u
.periodic
.waveform
== FF_CUSTOM
)
215 request
.code
= UI_FF_UPLOAD
;
216 request
.u
.upload
.effect
= effect
;
217 request
.u
.upload
.old
= old
;
219 return uinput_request_submit(udev
, &request
);
222 static int uinput_dev_erase_effect(struct input_dev
*dev
, int effect_id
)
224 struct uinput_device
*udev
= input_get_drvdata(dev
);
225 struct uinput_request request
;
227 if (!test_bit(EV_FF
, dev
->evbit
))
230 request
.code
= UI_FF_ERASE
;
231 request
.u
.effect_id
= effect_id
;
233 return uinput_request_submit(udev
, &request
);
236 static int uinput_dev_flush(struct input_dev
*dev
, struct file
*file
)
239 * If we are called with file == NULL that means we are tearing
240 * down the device, and therefore we can not handle FF erase
241 * requests: either we are handling UI_DEV_DESTROY (and holding
242 * the udev->mutex), or the file descriptor is closed and there is
243 * nobody on the other side anymore.
245 return file
? input_ff_flush(dev
, file
) : 0;
248 static void uinput_destroy_device(struct uinput_device
*udev
)
250 const char *name
, *phys
;
251 struct input_dev
*dev
= udev
->dev
;
252 enum uinput_state old_state
= udev
->state
;
254 udev
->state
= UIST_NEW_DEVICE
;
259 if (old_state
== UIST_CREATED
) {
260 uinput_flush_requests(udev
);
261 input_unregister_device(dev
);
263 input_free_device(dev
);
271 static int uinput_create_device(struct uinput_device
*udev
)
273 struct input_dev
*dev
= udev
->dev
;
276 if (udev
->state
!= UIST_SETUP_COMPLETE
) {
277 printk(KERN_DEBUG
"%s: write device info first\n", UINPUT_NAME
);
281 if (test_bit(EV_ABS
, dev
->evbit
)) {
282 input_alloc_absinfo(dev
);
288 if (test_bit(ABS_MT_SLOT
, dev
->absbit
)) {
289 nslot
= input_abs_get_max(dev
, ABS_MT_SLOT
) + 1;
290 error
= input_mt_init_slots(dev
, nslot
, 0);
293 } else if (test_bit(ABS_MT_POSITION_X
, dev
->absbit
)) {
294 input_set_events_per_packet(dev
, 60);
298 if (test_bit(EV_FF
, dev
->evbit
) && !udev
->ff_effects_max
) {
299 printk(KERN_DEBUG
"%s: ff_effects_max should be non-zero when FF_BIT is set\n",
305 if (udev
->ff_effects_max
) {
306 error
= input_ff_create(dev
, udev
->ff_effects_max
);
310 dev
->ff
->upload
= uinput_dev_upload_effect
;
311 dev
->ff
->erase
= uinput_dev_erase_effect
;
312 dev
->ff
->playback
= uinput_dev_playback
;
313 dev
->ff
->set_gain
= uinput_dev_set_gain
;
314 dev
->ff
->set_autocenter
= uinput_dev_set_autocenter
;
316 * The standard input_ff_flush() implementation does
317 * not quite work for uinput as we can't reasonably
318 * handle FF requests during device teardown.
320 dev
->flush
= uinput_dev_flush
;
323 error
= input_register_device(udev
->dev
);
327 udev
->state
= UIST_CREATED
;
331 fail2
: input_ff_destroy(dev
);
332 fail1
: uinput_destroy_device(udev
);
336 static int uinput_open(struct inode
*inode
, struct file
*file
)
338 struct uinput_device
*newdev
;
340 newdev
= kzalloc(sizeof(struct uinput_device
), GFP_KERNEL
);
344 mutex_init(&newdev
->mutex
);
345 spin_lock_init(&newdev
->requests_lock
);
346 init_waitqueue_head(&newdev
->requests_waitq
);
347 init_waitqueue_head(&newdev
->waitq
);
348 newdev
->state
= UIST_NEW_DEVICE
;
350 file
->private_data
= newdev
;
351 nonseekable_open(inode
, file
);
356 static int uinput_validate_absinfo(struct input_dev
*dev
, unsigned int code
,
357 const struct input_absinfo
*abs
)
364 if ((min
!= 0 || max
!= 0) && max
<= min
) {
366 "%s: invalid abs[%02x] min:%d max:%d\n",
367 UINPUT_NAME
, code
, min
, max
);
371 if (abs
->flat
> max
- min
) {
373 "%s: abs_flat #%02x out of range: %d (min:%d/max:%d)\n",
374 UINPUT_NAME
, code
, abs
->flat
, min
, max
);
381 static int uinput_validate_absbits(struct input_dev
*dev
)
386 if (!test_bit(EV_ABS
, dev
->evbit
))
390 * Check if absmin/absmax/absfuzz/absflat are sane.
393 for_each_set_bit(cnt
, dev
->absbit
, ABS_CNT
) {
397 error
= uinput_validate_absinfo(dev
, cnt
, &dev
->absinfo
[cnt
]);
405 static int uinput_allocate_device(struct uinput_device
*udev
)
407 udev
->dev
= input_allocate_device();
411 udev
->dev
->event
= uinput_dev_event
;
412 input_set_drvdata(udev
->dev
, udev
);
417 static int uinput_dev_setup(struct uinput_device
*udev
,
418 struct uinput_setup __user
*arg
)
420 struct uinput_setup setup
;
421 struct input_dev
*dev
;
423 if (udev
->state
== UIST_CREATED
)
426 if (copy_from_user(&setup
, arg
, sizeof(setup
)))
434 udev
->ff_effects_max
= setup
.ff_effects_max
;
437 dev
->name
= kstrndup(setup
.name
, UINPUT_MAX_NAME_SIZE
, GFP_KERNEL
);
441 udev
->state
= UIST_SETUP_COMPLETE
;
445 static int uinput_abs_setup(struct uinput_device
*udev
,
446 struct uinput_setup __user
*arg
, size_t size
)
448 struct uinput_abs_setup setup
= {};
449 struct input_dev
*dev
;
452 if (size
> sizeof(setup
))
455 if (udev
->state
== UIST_CREATED
)
458 if (copy_from_user(&setup
, arg
, size
))
461 if (setup
.code
> ABS_MAX
)
466 error
= uinput_validate_absinfo(dev
, setup
.code
, &setup
.absinfo
);
470 input_alloc_absinfo(dev
);
474 set_bit(setup
.code
, dev
->absbit
);
475 dev
->absinfo
[setup
.code
] = setup
.absinfo
;
479 /* legacy setup via write() */
480 static int uinput_setup_device_legacy(struct uinput_device
*udev
,
481 const char __user
*buffer
, size_t count
)
483 struct uinput_user_dev
*user_dev
;
484 struct input_dev
*dev
;
488 if (count
!= sizeof(struct uinput_user_dev
))
492 retval
= uinput_allocate_device(udev
);
499 user_dev
= memdup_user(buffer
, sizeof(struct uinput_user_dev
));
500 if (IS_ERR(user_dev
))
501 return PTR_ERR(user_dev
);
503 udev
->ff_effects_max
= user_dev
->ff_effects_max
;
505 /* Ensure name is filled in */
506 if (!user_dev
->name
[0]) {
512 dev
->name
= kstrndup(user_dev
->name
, UINPUT_MAX_NAME_SIZE
,
519 dev
->id
.bustype
= user_dev
->id
.bustype
;
520 dev
->id
.vendor
= user_dev
->id
.vendor
;
521 dev
->id
.product
= user_dev
->id
.product
;
522 dev
->id
.version
= user_dev
->id
.version
;
524 for (i
= 0; i
< ABS_CNT
; i
++) {
525 input_abs_set_max(dev
, i
, user_dev
->absmax
[i
]);
526 input_abs_set_min(dev
, i
, user_dev
->absmin
[i
]);
527 input_abs_set_fuzz(dev
, i
, user_dev
->absfuzz
[i
]);
528 input_abs_set_flat(dev
, i
, user_dev
->absflat
[i
]);
531 retval
= uinput_validate_absbits(dev
);
535 udev
->state
= UIST_SETUP_COMPLETE
;
543 static ssize_t
uinput_inject_events(struct uinput_device
*udev
,
544 const char __user
*buffer
, size_t count
)
546 struct input_event ev
;
549 if (count
!= 0 && count
< input_event_size())
552 while (bytes
+ input_event_size() <= count
) {
554 * Note that even if some events were fetched successfully
555 * we are still going to return EFAULT instead of partial
556 * count to let userspace know that it got it's buffers
559 if (input_event_from_user(buffer
+ bytes
, &ev
))
562 input_event(udev
->dev
, ev
.type
, ev
.code
, ev
.value
);
563 bytes
+= input_event_size();
569 static ssize_t
uinput_write(struct file
*file
, const char __user
*buffer
,
570 size_t count
, loff_t
*ppos
)
572 struct uinput_device
*udev
= file
->private_data
;
578 retval
= mutex_lock_interruptible(&udev
->mutex
);
582 retval
= udev
->state
== UIST_CREATED
?
583 uinput_inject_events(udev
, buffer
, count
) :
584 uinput_setup_device_legacy(udev
, buffer
, count
);
586 mutex_unlock(&udev
->mutex
);
591 static bool uinput_fetch_next_event(struct uinput_device
*udev
,
592 struct input_event
*event
)
596 spin_lock_irq(&udev
->dev
->event_lock
);
598 have_event
= udev
->head
!= udev
->tail
;
600 *event
= udev
->buff
[udev
->tail
];
601 udev
->tail
= (udev
->tail
+ 1) % UINPUT_BUFFER_SIZE
;
604 spin_unlock_irq(&udev
->dev
->event_lock
);
609 static ssize_t
uinput_events_to_user(struct uinput_device
*udev
,
610 char __user
*buffer
, size_t count
)
612 struct input_event event
;
615 while (read
+ input_event_size() <= count
&&
616 uinput_fetch_next_event(udev
, &event
)) {
618 if (input_event_to_user(buffer
+ read
, &event
))
621 read
+= input_event_size();
627 static ssize_t
uinput_read(struct file
*file
, char __user
*buffer
,
628 size_t count
, loff_t
*ppos
)
630 struct uinput_device
*udev
= file
->private_data
;
633 if (count
!= 0 && count
< input_event_size())
637 retval
= mutex_lock_interruptible(&udev
->mutex
);
641 if (udev
->state
!= UIST_CREATED
)
643 else if (udev
->head
== udev
->tail
&&
644 (file
->f_flags
& O_NONBLOCK
))
647 retval
= uinput_events_to_user(udev
, buffer
, count
);
649 mutex_unlock(&udev
->mutex
);
651 if (retval
|| count
== 0)
654 if (!(file
->f_flags
& O_NONBLOCK
))
655 retval
= wait_event_interruptible(udev
->waitq
,
656 udev
->head
!= udev
->tail
||
657 udev
->state
!= UIST_CREATED
);
658 } while (retval
== 0);
663 static unsigned int uinput_poll(struct file
*file
, poll_table
*wait
)
665 struct uinput_device
*udev
= file
->private_data
;
667 poll_wait(file
, &udev
->waitq
, wait
);
669 if (udev
->head
!= udev
->tail
)
670 return POLLIN
| POLLRDNORM
;
675 static int uinput_release(struct inode
*inode
, struct file
*file
)
677 struct uinput_device
*udev
= file
->private_data
;
679 uinput_destroy_device(udev
);
686 struct uinput_ff_upload_compat
{
689 struct ff_effect_compat effect
;
690 struct ff_effect_compat old
;
693 static int uinput_ff_upload_to_user(char __user
*buffer
,
694 const struct uinput_ff_upload
*ff_up
)
696 if (in_compat_syscall()) {
697 struct uinput_ff_upload_compat ff_up_compat
;
699 ff_up_compat
.request_id
= ff_up
->request_id
;
700 ff_up_compat
.retval
= ff_up
->retval
;
702 * It so happens that the pointer that gives us the trouble
703 * is the last field in the structure. Since we don't support
704 * custom waveforms in uinput anyway we can just copy the whole
705 * thing (to the compat size) and ignore the pointer.
707 memcpy(&ff_up_compat
.effect
, &ff_up
->effect
,
708 sizeof(struct ff_effect_compat
));
709 memcpy(&ff_up_compat
.old
, &ff_up
->old
,
710 sizeof(struct ff_effect_compat
));
712 if (copy_to_user(buffer
, &ff_up_compat
,
713 sizeof(struct uinput_ff_upload_compat
)))
716 if (copy_to_user(buffer
, ff_up
,
717 sizeof(struct uinput_ff_upload
)))
724 static int uinput_ff_upload_from_user(const char __user
*buffer
,
725 struct uinput_ff_upload
*ff_up
)
727 if (in_compat_syscall()) {
728 struct uinput_ff_upload_compat ff_up_compat
;
730 if (copy_from_user(&ff_up_compat
, buffer
,
731 sizeof(struct uinput_ff_upload_compat
)))
734 ff_up
->request_id
= ff_up_compat
.request_id
;
735 ff_up
->retval
= ff_up_compat
.retval
;
736 memcpy(&ff_up
->effect
, &ff_up_compat
.effect
,
737 sizeof(struct ff_effect_compat
));
738 memcpy(&ff_up
->old
, &ff_up_compat
.old
,
739 sizeof(struct ff_effect_compat
));
742 if (copy_from_user(ff_up
, buffer
,
743 sizeof(struct uinput_ff_upload
)))
752 static int uinput_ff_upload_to_user(char __user
*buffer
,
753 const struct uinput_ff_upload
*ff_up
)
755 if (copy_to_user(buffer
, ff_up
, sizeof(struct uinput_ff_upload
)))
761 static int uinput_ff_upload_from_user(const char __user
*buffer
,
762 struct uinput_ff_upload
*ff_up
)
764 if (copy_from_user(ff_up
, buffer
, sizeof(struct uinput_ff_upload
)))
772 #define uinput_set_bit(_arg, _bit, _max) \
775 if (udev->state == UIST_CREATED) \
777 else if ((_arg) > (_max)) \
779 else set_bit((_arg), udev->dev->_bit); \
783 static int uinput_str_to_user(void __user
*dest
, const char *str
,
786 char __user
*p
= dest
;
795 len
= strlen(str
) + 1;
799 ret
= copy_to_user(p
, str
, len
);
803 /* force terminating '\0' */
804 ret
= put_user(0, p
+ len
- 1);
805 return ret
? -EFAULT
: len
;
808 static long uinput_ioctl_handler(struct file
*file
, unsigned int cmd
,
809 unsigned long arg
, void __user
*p
)
812 struct uinput_device
*udev
= file
->private_data
;
813 struct uinput_ff_upload ff_up
;
814 struct uinput_ff_erase ff_erase
;
815 struct uinput_request
*req
;
820 retval
= mutex_lock_interruptible(&udev
->mutex
);
825 retval
= uinput_allocate_device(udev
);
832 if (put_user(UINPUT_VERSION
,
833 (unsigned int __user
*)p
))
838 retval
= uinput_create_device(udev
);
842 uinput_destroy_device(udev
);
846 retval
= uinput_dev_setup(udev
, p
);
849 /* UI_ABS_SETUP is handled in the variable size ioctls */
852 retval
= uinput_set_bit(arg
, evbit
, EV_MAX
);
856 retval
= uinput_set_bit(arg
, keybit
, KEY_MAX
);
860 retval
= uinput_set_bit(arg
, relbit
, REL_MAX
);
864 retval
= uinput_set_bit(arg
, absbit
, ABS_MAX
);
868 retval
= uinput_set_bit(arg
, mscbit
, MSC_MAX
);
872 retval
= uinput_set_bit(arg
, ledbit
, LED_MAX
);
876 retval
= uinput_set_bit(arg
, sndbit
, SND_MAX
);
880 retval
= uinput_set_bit(arg
, ffbit
, FF_MAX
);
884 retval
= uinput_set_bit(arg
, swbit
, SW_MAX
);
888 retval
= uinput_set_bit(arg
, propbit
, INPUT_PROP_MAX
);
892 if (udev
->state
== UIST_CREATED
) {
897 phys
= strndup_user(p
, 1024);
899 retval
= PTR_ERR(phys
);
903 kfree(udev
->dev
->phys
);
904 udev
->dev
->phys
= phys
;
907 case UI_BEGIN_FF_UPLOAD
:
908 retval
= uinput_ff_upload_from_user(p
, &ff_up
);
912 req
= uinput_request_find(udev
, ff_up
.request_id
);
913 if (!req
|| req
->code
!= UI_FF_UPLOAD
||
914 !req
->u
.upload
.effect
) {
920 ff_up
.effect
= *req
->u
.upload
.effect
;
921 if (req
->u
.upload
.old
)
922 ff_up
.old
= *req
->u
.upload
.old
;
924 memset(&ff_up
.old
, 0, sizeof(struct ff_effect
));
926 retval
= uinput_ff_upload_to_user(p
, &ff_up
);
929 case UI_BEGIN_FF_ERASE
:
930 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
935 req
= uinput_request_find(udev
, ff_erase
.request_id
);
936 if (!req
|| req
->code
!= UI_FF_ERASE
) {
942 ff_erase
.effect_id
= req
->u
.effect_id
;
943 if (copy_to_user(p
, &ff_erase
, sizeof(ff_erase
))) {
950 case UI_END_FF_UPLOAD
:
951 retval
= uinput_ff_upload_from_user(p
, &ff_up
);
955 req
= uinput_request_find(udev
, ff_up
.request_id
);
956 if (!req
|| req
->code
!= UI_FF_UPLOAD
||
957 !req
->u
.upload
.effect
) {
962 req
->retval
= ff_up
.retval
;
963 complete(&req
->done
);
966 case UI_END_FF_ERASE
:
967 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
972 req
= uinput_request_find(udev
, ff_erase
.request_id
);
973 if (!req
|| req
->code
!= UI_FF_ERASE
) {
978 req
->retval
= ff_erase
.retval
;
979 complete(&req
->done
);
983 size
= _IOC_SIZE(cmd
);
985 /* Now check variable-length commands */
986 switch (cmd
& ~IOCSIZE_MASK
) {
987 case UI_GET_SYSNAME(0):
988 if (udev
->state
!= UIST_CREATED
) {
992 name
= dev_name(&udev
->dev
->dev
);
993 retval
= uinput_str_to_user(p
, name
, size
);
996 case UI_ABS_SETUP
& ~IOCSIZE_MASK
:
997 retval
= uinput_abs_setup(udev
, p
, size
);
1003 mutex_unlock(&udev
->mutex
);
1007 static long uinput_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1009 return uinput_ioctl_handler(file
, cmd
, arg
, (void __user
*)arg
);
1012 #ifdef CONFIG_COMPAT
1014 #define UI_SET_PHYS_COMPAT _IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t)
1016 static long uinput_compat_ioctl(struct file
*file
,
1017 unsigned int cmd
, unsigned long arg
)
1019 if (cmd
== UI_SET_PHYS_COMPAT
)
1022 return uinput_ioctl_handler(file
, cmd
, arg
, compat_ptr(arg
));
1026 static const struct file_operations uinput_fops
= {
1027 .owner
= THIS_MODULE
,
1028 .open
= uinput_open
,
1029 .release
= uinput_release
,
1030 .read
= uinput_read
,
1031 .write
= uinput_write
,
1032 .poll
= uinput_poll
,
1033 .unlocked_ioctl
= uinput_ioctl
,
1034 #ifdef CONFIG_COMPAT
1035 .compat_ioctl
= uinput_compat_ioctl
,
1037 .llseek
= no_llseek
,
1040 static struct miscdevice uinput_misc
= {
1041 .fops
= &uinput_fops
,
1042 .minor
= UINPUT_MINOR
,
1043 .name
= UINPUT_NAME
,
1045 module_misc_device(uinput_misc
);
1047 MODULE_ALIAS_MISCDEV(UINPUT_MINOR
);
1048 MODULE_ALIAS("devname:" UINPUT_NAME
);
1050 MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
1051 MODULE_DESCRIPTION("User level driver support for input subsystem");
1052 MODULE_LICENSE("GPL");
1053 MODULE_VERSION("0.3");