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.3 09/04/2006 (Anssi Hannula <anssi.hannula@gmail.com>)
24 * - updated ff support for the changes in kernel interface
25 * - added MODULE_VERSION
26 * 0.2 16/10/2004 (Micah Dowty <micah@navi.cx>)
27 * - added force feedback support
30 * - first public version
32 #include <linux/poll.h>
33 #include <linux/sched.h>
34 #include <linux/slab.h>
35 #include <linux/module.h>
36 #include <linux/init.h>
38 #include <linux/miscdevice.h>
39 #include <linux/uinput.h>
40 #include <linux/input/mt.h>
41 #include "../input-compat.h"
43 static int uinput_dev_event(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int value
)
45 struct uinput_device
*udev
= input_get_drvdata(dev
);
47 udev
->buff
[udev
->head
].type
= type
;
48 udev
->buff
[udev
->head
].code
= code
;
49 udev
->buff
[udev
->head
].value
= value
;
50 do_gettimeofday(&udev
->buff
[udev
->head
].time
);
51 udev
->head
= (udev
->head
+ 1) % UINPUT_BUFFER_SIZE
;
53 wake_up_interruptible(&udev
->waitq
);
58 /* Atomically allocate an ID for the given request. Returns 0 on success. */
59 static int uinput_request_alloc_id(struct uinput_device
*udev
, struct uinput_request
*request
)
64 spin_lock(&udev
->requests_lock
);
66 for (id
= 0; id
< UINPUT_NUM_REQUESTS
; id
++) {
67 if (!udev
->requests
[id
]) {
69 udev
->requests
[id
] = request
;
75 spin_unlock(&udev
->requests_lock
);
79 static struct uinput_request
*uinput_request_find(struct uinput_device
*udev
, int id
)
81 /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
82 if (id
>= UINPUT_NUM_REQUESTS
|| id
< 0)
85 return udev
->requests
[id
];
88 static inline int uinput_request_reserve_slot(struct uinput_device
*udev
, struct uinput_request
*request
)
90 /* Allocate slot. If none are available right away, wait. */
91 return wait_event_interruptible(udev
->requests_waitq
,
92 !uinput_request_alloc_id(udev
, request
));
95 static void uinput_request_done(struct uinput_device
*udev
, struct uinput_request
*request
)
97 /* Mark slot as available */
98 udev
->requests
[request
->id
] = NULL
;
99 wake_up(&udev
->requests_waitq
);
101 complete(&request
->done
);
104 static int uinput_request_submit(struct uinput_device
*udev
, struct uinput_request
*request
)
108 retval
= uinput_request_reserve_slot(udev
, request
);
112 retval
= mutex_lock_interruptible(&udev
->mutex
);
116 if (udev
->state
!= UIST_CREATED
) {
121 /* Tell our userspace app about this new request by queueing an input event */
122 uinput_dev_event(udev
->dev
, EV_UINPUT
, request
->code
, request
->id
);
125 mutex_unlock(&udev
->mutex
);
130 * Fail all ouitstanding requests so handlers don't wait for the userspace
131 * to finish processing them.
133 static void uinput_flush_requests(struct uinput_device
*udev
)
135 struct uinput_request
*request
;
138 spin_lock(&udev
->requests_lock
);
140 for (i
= 0; i
< UINPUT_NUM_REQUESTS
; i
++) {
141 request
= udev
->requests
[i
];
143 request
->retval
= -ENODEV
;
144 uinput_request_done(udev
, request
);
148 spin_unlock(&udev
->requests_lock
);
151 static void uinput_dev_set_gain(struct input_dev
*dev
, u16 gain
)
153 uinput_dev_event(dev
, EV_FF
, FF_GAIN
, gain
);
156 static void uinput_dev_set_autocenter(struct input_dev
*dev
, u16 magnitude
)
158 uinput_dev_event(dev
, EV_FF
, FF_AUTOCENTER
, magnitude
);
161 static int uinput_dev_playback(struct input_dev
*dev
, int effect_id
, int value
)
163 return uinput_dev_event(dev
, EV_FF
, effect_id
, value
);
166 static int uinput_dev_upload_effect(struct input_dev
*dev
, struct ff_effect
*effect
, struct ff_effect
*old
)
168 struct uinput_device
*udev
= input_get_drvdata(dev
);
169 struct uinput_request request
;
173 * uinput driver does not currently support periodic effects with
174 * custom waveform since it does not have a way to pass buffer of
175 * samples (custom_data) to userspace. If ever there is a device
176 * supporting custom waveforms we would need to define an additional
177 * ioctl (UI_UPLOAD_SAMPLES) but for now we just bail out.
179 if (effect
->type
== FF_PERIODIC
&&
180 effect
->u
.periodic
.waveform
== FF_CUSTOM
)
184 init_completion(&request
.done
);
185 request
.code
= UI_FF_UPLOAD
;
186 request
.u
.upload
.effect
= effect
;
187 request
.u
.upload
.old
= old
;
189 retval
= uinput_request_submit(udev
, &request
);
191 wait_for_completion(&request
.done
);
192 retval
= request
.retval
;
198 static int uinput_dev_erase_effect(struct input_dev
*dev
, int effect_id
)
200 struct uinput_device
*udev
= input_get_drvdata(dev
);
201 struct uinput_request request
;
204 if (!test_bit(EV_FF
, dev
->evbit
))
208 init_completion(&request
.done
);
209 request
.code
= UI_FF_ERASE
;
210 request
.u
.effect_id
= effect_id
;
212 retval
= uinput_request_submit(udev
, &request
);
214 wait_for_completion(&request
.done
);
215 retval
= request
.retval
;
221 static void uinput_destroy_device(struct uinput_device
*udev
)
223 const char *name
, *phys
;
224 struct input_dev
*dev
= udev
->dev
;
225 enum uinput_state old_state
= udev
->state
;
227 udev
->state
= UIST_NEW_DEVICE
;
232 if (old_state
== UIST_CREATED
) {
233 uinput_flush_requests(udev
);
234 input_unregister_device(dev
);
236 input_free_device(dev
);
244 static int uinput_create_device(struct uinput_device
*udev
)
246 struct input_dev
*dev
= udev
->dev
;
249 if (udev
->state
!= UIST_SETUP_COMPLETE
) {
250 printk(KERN_DEBUG
"%s: write device info first\n", UINPUT_NAME
);
254 if (udev
->ff_effects_max
) {
255 error
= input_ff_create(dev
, udev
->ff_effects_max
);
259 dev
->ff
->upload
= uinput_dev_upload_effect
;
260 dev
->ff
->erase
= uinput_dev_erase_effect
;
261 dev
->ff
->playback
= uinput_dev_playback
;
262 dev
->ff
->set_gain
= uinput_dev_set_gain
;
263 dev
->ff
->set_autocenter
= uinput_dev_set_autocenter
;
266 error
= input_register_device(udev
->dev
);
270 udev
->state
= UIST_CREATED
;
274 fail2
: input_ff_destroy(dev
);
275 fail1
: uinput_destroy_device(udev
);
279 static int uinput_open(struct inode
*inode
, struct file
*file
)
281 struct uinput_device
*newdev
;
283 newdev
= kzalloc(sizeof(struct uinput_device
), GFP_KERNEL
);
287 mutex_init(&newdev
->mutex
);
288 spin_lock_init(&newdev
->requests_lock
);
289 init_waitqueue_head(&newdev
->requests_waitq
);
290 init_waitqueue_head(&newdev
->waitq
);
291 newdev
->state
= UIST_NEW_DEVICE
;
293 file
->private_data
= newdev
;
294 nonseekable_open(inode
, file
);
299 static int uinput_validate_absbits(struct input_dev
*dev
)
304 for (cnt
= 0; cnt
< ABS_CNT
; cnt
++) {
305 if (!test_bit(cnt
, dev
->absbit
))
308 if (input_abs_get_max(dev
, cnt
) <= input_abs_get_min(dev
, cnt
)) {
310 "%s: invalid abs[%02x] min:%d max:%d\n",
312 input_abs_get_min(dev
, cnt
),
313 input_abs_get_max(dev
, cnt
));
318 if (input_abs_get_flat(dev
, cnt
) >
319 input_abs_get_max(dev
, cnt
) - input_abs_get_min(dev
, cnt
)) {
321 "%s: abs_flat #%02x out of range: %d "
324 input_abs_get_flat(dev
, cnt
),
325 input_abs_get_min(dev
, cnt
),
326 input_abs_get_max(dev
, cnt
));
334 static int uinput_allocate_device(struct uinput_device
*udev
)
336 udev
->dev
= input_allocate_device();
340 udev
->dev
->event
= uinput_dev_event
;
341 input_set_drvdata(udev
->dev
, udev
);
346 static int uinput_setup_device(struct uinput_device
*udev
, const char __user
*buffer
, size_t count
)
348 struct uinput_user_dev
*user_dev
;
349 struct input_dev
*dev
;
354 if (count
!= sizeof(struct uinput_user_dev
))
358 retval
= uinput_allocate_device(udev
);
365 user_dev
= kmalloc(sizeof(struct uinput_user_dev
), GFP_KERNEL
);
369 if (copy_from_user(user_dev
, buffer
, sizeof(struct uinput_user_dev
))) {
374 udev
->ff_effects_max
= user_dev
->ff_effects_max
;
376 size
= strnlen(user_dev
->name
, UINPUT_MAX_NAME_SIZE
) + 1;
383 dev
->name
= name
= kmalloc(size
, GFP_KERNEL
);
388 strlcpy(name
, user_dev
->name
, size
);
390 dev
->id
.bustype
= user_dev
->id
.bustype
;
391 dev
->id
.vendor
= user_dev
->id
.vendor
;
392 dev
->id
.product
= user_dev
->id
.product
;
393 dev
->id
.version
= user_dev
->id
.version
;
395 for (i
= 0; i
< ABS_CNT
; i
++) {
396 input_abs_set_max(dev
, i
, user_dev
->absmax
[i
]);
397 input_abs_set_min(dev
, i
, user_dev
->absmin
[i
]);
398 input_abs_set_fuzz(dev
, i
, user_dev
->absfuzz
[i
]);
399 input_abs_set_flat(dev
, i
, user_dev
->absflat
[i
]);
402 /* check if absmin/absmax/absfuzz/absflat are filled as
403 * told in Documentation/input/input-programming.txt */
404 if (test_bit(EV_ABS
, dev
->evbit
)) {
405 retval
= uinput_validate_absbits(dev
);
408 if (test_bit(ABS_MT_SLOT
, dev
->absbit
)) {
409 int nslot
= input_abs_get_max(dev
, ABS_MT_SLOT
) + 1;
410 input_mt_create_slots(dev
, nslot
);
411 input_set_events_per_packet(dev
, 6 * nslot
);
412 } else if (test_bit(ABS_MT_POSITION_X
, dev
->absbit
)) {
413 input_set_events_per_packet(dev
, 60);
417 udev
->state
= UIST_SETUP_COMPLETE
;
425 static inline ssize_t
uinput_inject_event(struct uinput_device
*udev
, const char __user
*buffer
, size_t count
)
427 struct input_event ev
;
429 if (count
< input_event_size())
432 if (input_event_from_user(buffer
, &ev
))
435 input_event(udev
->dev
, ev
.type
, ev
.code
, ev
.value
);
437 return input_event_size();
440 static ssize_t
uinput_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
442 struct uinput_device
*udev
= file
->private_data
;
445 retval
= mutex_lock_interruptible(&udev
->mutex
);
449 retval
= udev
->state
== UIST_CREATED
?
450 uinput_inject_event(udev
, buffer
, count
) :
451 uinput_setup_device(udev
, buffer
, count
);
453 mutex_unlock(&udev
->mutex
);
458 static ssize_t
uinput_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
460 struct uinput_device
*udev
= file
->private_data
;
463 if (udev
->state
!= UIST_CREATED
)
466 if (udev
->head
== udev
->tail
&& (file
->f_flags
& O_NONBLOCK
))
469 retval
= wait_event_interruptible(udev
->waitq
,
470 udev
->head
!= udev
->tail
|| udev
->state
!= UIST_CREATED
);
474 retval
= mutex_lock_interruptible(&udev
->mutex
);
478 if (udev
->state
!= UIST_CREATED
) {
483 while (udev
->head
!= udev
->tail
&& retval
+ input_event_size() <= count
) {
484 if (input_event_to_user(buffer
+ retval
, &udev
->buff
[udev
->tail
])) {
488 udev
->tail
= (udev
->tail
+ 1) % UINPUT_BUFFER_SIZE
;
489 retval
+= input_event_size();
493 mutex_unlock(&udev
->mutex
);
498 static unsigned int uinput_poll(struct file
*file
, poll_table
*wait
)
500 struct uinput_device
*udev
= file
->private_data
;
502 poll_wait(file
, &udev
->waitq
, wait
);
504 if (udev
->head
!= udev
->tail
)
505 return POLLIN
| POLLRDNORM
;
510 static int uinput_release(struct inode
*inode
, struct file
*file
)
512 struct uinput_device
*udev
= file
->private_data
;
514 uinput_destroy_device(udev
);
521 struct uinput_ff_upload_compat
{
524 struct ff_effect_compat effect
;
525 struct ff_effect_compat old
;
528 static int uinput_ff_upload_to_user(char __user
*buffer
,
529 const struct uinput_ff_upload
*ff_up
)
531 if (INPUT_COMPAT_TEST
) {
532 struct uinput_ff_upload_compat ff_up_compat
;
534 ff_up_compat
.request_id
= ff_up
->request_id
;
535 ff_up_compat
.retval
= ff_up
->retval
;
537 * It so happens that the pointer that gives us the trouble
538 * is the last field in the structure. Since we don't support
539 * custom waveforms in uinput anyway we can just copy the whole
540 * thing (to the compat size) and ignore the pointer.
542 memcpy(&ff_up_compat
.effect
, &ff_up
->effect
,
543 sizeof(struct ff_effect_compat
));
544 memcpy(&ff_up_compat
.old
, &ff_up
->old
,
545 sizeof(struct ff_effect_compat
));
547 if (copy_to_user(buffer
, &ff_up_compat
,
548 sizeof(struct uinput_ff_upload_compat
)))
551 if (copy_to_user(buffer
, ff_up
,
552 sizeof(struct uinput_ff_upload
)))
559 static int uinput_ff_upload_from_user(const char __user
*buffer
,
560 struct uinput_ff_upload
*ff_up
)
562 if (INPUT_COMPAT_TEST
) {
563 struct uinput_ff_upload_compat ff_up_compat
;
565 if (copy_from_user(&ff_up_compat
, buffer
,
566 sizeof(struct uinput_ff_upload_compat
)))
569 ff_up
->request_id
= ff_up_compat
.request_id
;
570 ff_up
->retval
= ff_up_compat
.retval
;
571 memcpy(&ff_up
->effect
, &ff_up_compat
.effect
,
572 sizeof(struct ff_effect_compat
));
573 memcpy(&ff_up
->old
, &ff_up_compat
.old
,
574 sizeof(struct ff_effect_compat
));
577 if (copy_from_user(ff_up
, buffer
,
578 sizeof(struct uinput_ff_upload
)))
587 static int uinput_ff_upload_to_user(char __user
*buffer
,
588 const struct uinput_ff_upload
*ff_up
)
590 if (copy_to_user(buffer
, ff_up
, sizeof(struct uinput_ff_upload
)))
596 static int uinput_ff_upload_from_user(const char __user
*buffer
,
597 struct uinput_ff_upload
*ff_up
)
599 if (copy_from_user(ff_up
, buffer
, sizeof(struct uinput_ff_upload
)))
607 #define uinput_set_bit(_arg, _bit, _max) \
610 if (udev->state == UIST_CREATED) \
612 else if ((_arg) > (_max)) \
614 else set_bit((_arg), udev->dev->_bit); \
618 static long uinput_ioctl_handler(struct file
*file
, unsigned int cmd
,
619 unsigned long arg
, void __user
*p
)
622 struct uinput_device
*udev
= file
->private_data
;
623 struct uinput_ff_upload ff_up
;
624 struct uinput_ff_erase ff_erase
;
625 struct uinput_request
*req
;
629 retval
= mutex_lock_interruptible(&udev
->mutex
);
634 retval
= uinput_allocate_device(udev
);
641 retval
= uinput_create_device(udev
);
645 uinput_destroy_device(udev
);
649 retval
= uinput_set_bit(arg
, evbit
, EV_MAX
);
653 retval
= uinput_set_bit(arg
, keybit
, KEY_MAX
);
657 retval
= uinput_set_bit(arg
, relbit
, REL_MAX
);
661 retval
= uinput_set_bit(arg
, absbit
, ABS_MAX
);
665 retval
= uinput_set_bit(arg
, mscbit
, MSC_MAX
);
669 retval
= uinput_set_bit(arg
, ledbit
, LED_MAX
);
673 retval
= uinput_set_bit(arg
, sndbit
, SND_MAX
);
677 retval
= uinput_set_bit(arg
, ffbit
, FF_MAX
);
681 retval
= uinput_set_bit(arg
, swbit
, SW_MAX
);
685 if (udev
->state
== UIST_CREATED
) {
689 length
= strnlen_user(p
, 1024);
694 kfree(udev
->dev
->phys
);
695 udev
->dev
->phys
= phys
= kmalloc(length
, GFP_KERNEL
);
700 if (copy_from_user(phys
, p
, length
)) {
701 udev
->dev
->phys
= NULL
;
706 phys
[length
- 1] = '\0';
709 case UI_BEGIN_FF_UPLOAD
:
710 retval
= uinput_ff_upload_from_user(p
, &ff_up
);
714 req
= uinput_request_find(udev
, ff_up
.request_id
);
715 if (!req
|| req
->code
!= UI_FF_UPLOAD
|| !req
->u
.upload
.effect
) {
721 ff_up
.effect
= *req
->u
.upload
.effect
;
722 if (req
->u
.upload
.old
)
723 ff_up
.old
= *req
->u
.upload
.old
;
725 memset(&ff_up
.old
, 0, sizeof(struct ff_effect
));
727 retval
= uinput_ff_upload_to_user(p
, &ff_up
);
730 case UI_BEGIN_FF_ERASE
:
731 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
736 req
= uinput_request_find(udev
, ff_erase
.request_id
);
737 if (!req
|| req
->code
!= UI_FF_ERASE
) {
743 ff_erase
.effect_id
= req
->u
.effect_id
;
744 if (copy_to_user(p
, &ff_erase
, sizeof(ff_erase
))) {
751 case UI_END_FF_UPLOAD
:
752 retval
= uinput_ff_upload_from_user(p
, &ff_up
);
756 req
= uinput_request_find(udev
, ff_up
.request_id
);
757 if (!req
|| req
->code
!= UI_FF_UPLOAD
||
758 !req
->u
.upload
.effect
) {
763 req
->retval
= ff_up
.retval
;
764 uinput_request_done(udev
, req
);
767 case UI_END_FF_ERASE
:
768 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
773 req
= uinput_request_find(udev
, ff_erase
.request_id
);
774 if (!req
|| req
->code
!= UI_FF_ERASE
) {
779 req
->retval
= ff_erase
.retval
;
780 uinput_request_done(udev
, req
);
788 mutex_unlock(&udev
->mutex
);
792 static long uinput_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
794 return uinput_ioctl_handler(file
, cmd
, arg
, (void __user
*)arg
);
798 static long uinput_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
800 return uinput_ioctl_handler(file
, cmd
, arg
, compat_ptr(arg
));
804 static const struct file_operations uinput_fops
= {
805 .owner
= THIS_MODULE
,
807 .release
= uinput_release
,
809 .write
= uinput_write
,
811 .unlocked_ioctl
= uinput_ioctl
,
813 .compat_ioctl
= uinput_compat_ioctl
,
818 static struct miscdevice uinput_misc
= {
819 .fops
= &uinput_fops
,
820 .minor
= UINPUT_MINOR
,
823 MODULE_ALIAS_MISCDEV(UINPUT_MINOR
);
824 MODULE_ALIAS("devname:" UINPUT_NAME
);
826 static int __init
uinput_init(void)
828 return misc_register(&uinput_misc
);
831 static void __exit
uinput_exit(void)
833 misc_deregister(&uinput_misc
);
836 MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
837 MODULE_DESCRIPTION("User level driver support for input subsystem");
838 MODULE_LICENSE("GPL");
839 MODULE_VERSION("0.3");
841 module_init(uinput_init
);
842 module_exit(uinput_exit
);