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.2 16/10/2004 (Micah Dowty <micah@navi.cx>)
24 * - added force feedback support
27 * - first public version
29 #include <linux/poll.h>
30 #include <linux/slab.h>
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/input.h>
34 #include <linux/smp_lock.h>
36 #include <linux/miscdevice.h>
37 #include <linux/uinput.h>
39 static int uinput_dev_event(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int value
)
41 struct uinput_device
*udev
;
45 udev
->buff
[udev
->head
].type
= type
;
46 udev
->buff
[udev
->head
].code
= code
;
47 udev
->buff
[udev
->head
].value
= value
;
48 do_gettimeofday(&udev
->buff
[udev
->head
].time
);
49 udev
->head
= (udev
->head
+ 1) % UINPUT_BUFFER_SIZE
;
51 wake_up_interruptible(&udev
->waitq
);
56 static int uinput_request_alloc_id(struct uinput_device
*udev
, struct uinput_request
*request
)
58 /* Atomically allocate an ID for the given request. Returns 0 on success. */
62 spin_lock(&udev
->requests_lock
);
64 for (id
= 0; id
< UINPUT_NUM_REQUESTS
; id
++)
65 if (!udev
->requests
[id
]) {
67 udev
->requests
[id
] = request
;
72 spin_unlock(&udev
->requests_lock
);
76 static struct uinput_request
* uinput_request_find(struct uinput_device
*udev
, int id
)
78 /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
79 if (id
>= UINPUT_NUM_REQUESTS
|| id
< 0)
81 return udev
->requests
[id
];
84 static inline int uinput_request_reserve_slot(struct uinput_device
*udev
, struct uinput_request
*request
)
86 /* Allocate slot. If none are available right away, wait. */
87 return wait_event_interruptible(udev
->requests_waitq
,
88 !uinput_request_alloc_id(udev
, request
));
91 static void uinput_request_done(struct uinput_device
*udev
, struct uinput_request
*request
)
93 /* Mark slot as available */
94 udev
->requests
[request
->id
] = NULL
;
95 wake_up_interruptible(&udev
->requests_waitq
);
97 complete(&request
->done
);
100 static int uinput_request_submit(struct input_dev
*dev
, struct uinput_request
*request
)
104 /* Tell our userspace app about this new request by queueing an input event */
105 uinput_dev_event(dev
, EV_UINPUT
, request
->code
, request
->id
);
107 /* Wait for the request to complete */
108 retval
= wait_for_completion_interruptible(&request
->done
);
110 retval
= request
->retval
;
115 static int uinput_dev_upload_effect(struct input_dev
*dev
, struct ff_effect
*effect
)
117 struct uinput_request request
;
120 if (!test_bit(EV_FF
, dev
->evbit
))
124 init_completion(&request
.done
);
125 request
.code
= UI_FF_UPLOAD
;
126 request
.u
.effect
= effect
;
128 retval
= uinput_request_reserve_slot(dev
->private, &request
);
130 retval
= uinput_request_submit(dev
, &request
);
135 static int uinput_dev_erase_effect(struct input_dev
*dev
, int effect_id
)
137 struct uinput_request request
;
140 if (!test_bit(EV_FF
, dev
->evbit
))
144 init_completion(&request
.done
);
145 request
.code
= UI_FF_ERASE
;
146 request
.u
.effect_id
= effect_id
;
148 retval
= uinput_request_reserve_slot(dev
->private, &request
);
150 retval
= uinput_request_submit(dev
, &request
);
155 static int uinput_create_device(struct uinput_device
*udev
)
157 if (!udev
->dev
->name
) {
158 printk(KERN_DEBUG
"%s: write device info first\n", UINPUT_NAME
);
162 udev
->dev
->event
= uinput_dev_event
;
163 udev
->dev
->upload_effect
= uinput_dev_upload_effect
;
164 udev
->dev
->erase_effect
= uinput_dev_erase_effect
;
165 udev
->dev
->private = udev
;
167 init_waitqueue_head(&udev
->waitq
);
169 input_register_device(udev
->dev
);
171 set_bit(UIST_CREATED
, &udev
->state
);
176 static int uinput_destroy_device(struct uinput_device
*udev
)
178 if (!test_bit(UIST_CREATED
, &udev
->state
)) {
179 printk(KERN_WARNING
"%s: create the device first\n", UINPUT_NAME
);
183 input_unregister_device(udev
->dev
);
185 clear_bit(UIST_CREATED
, &udev
->state
);
190 static int uinput_open(struct inode
*inode
, struct file
*file
)
192 struct uinput_device
*newdev
;
193 struct input_dev
*newinput
;
195 newdev
= kmalloc(sizeof(struct uinput_device
), GFP_KERNEL
);
198 memset(newdev
, 0, sizeof(struct uinput_device
));
199 spin_lock_init(&newdev
->requests_lock
);
200 init_waitqueue_head(&newdev
->requests_waitq
);
202 newinput
= kmalloc(sizeof(struct input_dev
), GFP_KERNEL
);
205 memset(newinput
, 0, sizeof(struct input_dev
));
207 newdev
->dev
= newinput
;
209 file
->private_data
= newdev
;
218 static int uinput_validate_absbits(struct input_dev
*dev
)
223 for (cnt
= 0; cnt
< ABS_MAX
+ 1; cnt
++) {
224 if (!test_bit(cnt
, dev
->absbit
))
227 if ((dev
->absmax
[cnt
] <= dev
->absmin
[cnt
])) {
229 "%s: invalid abs[%02x] min:%d max:%d\n",
231 dev
->absmin
[cnt
], dev
->absmax
[cnt
]);
236 if (dev
->absflat
[cnt
] > (dev
->absmax
[cnt
] - dev
->absmin
[cnt
])) {
238 "%s: absflat[%02x] out of range: %d "
240 UINPUT_NAME
, cnt
, dev
->absflat
[cnt
],
241 dev
->absmin
[cnt
], dev
->absmax
[cnt
]);
249 static int uinput_alloc_device(struct file
*file
, const char __user
*buffer
, size_t count
)
251 struct uinput_user_dev
*user_dev
;
252 struct input_dev
*dev
;
253 struct uinput_device
*udev
;
260 udev
= file
->private_data
;
263 user_dev
= kmalloc(sizeof(struct uinput_user_dev
), GFP_KERNEL
);
269 if (copy_from_user(user_dev
, buffer
, sizeof(struct uinput_user_dev
))) {
276 size
= strnlen(user_dev
->name
, UINPUT_MAX_NAME_SIZE
) + 1;
277 dev
->name
= name
= kmalloc(size
, GFP_KERNEL
);
282 strlcpy(name
, user_dev
->name
, size
);
284 dev
->id
.bustype
= user_dev
->id
.bustype
;
285 dev
->id
.vendor
= user_dev
->id
.vendor
;
286 dev
->id
.product
= user_dev
->id
.product
;
287 dev
->id
.version
= user_dev
->id
.version
;
288 dev
->ff_effects_max
= user_dev
->ff_effects_max
;
290 size
= sizeof(int) * (ABS_MAX
+ 1);
291 memcpy(dev
->absmax
, user_dev
->absmax
, size
);
292 memcpy(dev
->absmin
, user_dev
->absmin
, size
);
293 memcpy(dev
->absfuzz
, user_dev
->absfuzz
, size
);
294 memcpy(dev
->absflat
, user_dev
->absflat
, size
);
296 /* check if absmin/absmax/absfuzz/absflat are filled as
297 * told in Documentation/input/input-programming.txt */
298 if (test_bit(EV_ABS
, dev
->evbit
)) {
299 int err
= uinput_validate_absbits(dev
);
311 static ssize_t
uinput_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
313 struct uinput_device
*udev
= file
->private_data
;
315 if (test_bit(UIST_CREATED
, &udev
->state
)) {
316 struct input_event ev
;
318 if (copy_from_user(&ev
, buffer
, sizeof(struct input_event
)))
320 input_event(udev
->dev
, ev
.type
, ev
.code
, ev
.value
);
322 count
= uinput_alloc_device(file
, buffer
, count
);
327 static ssize_t
uinput_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
329 struct uinput_device
*udev
= file
->private_data
;
332 if (!test_bit(UIST_CREATED
, &udev
->state
))
335 if (udev
->head
== udev
->tail
&& (file
->f_flags
& O_NONBLOCK
))
338 retval
= wait_event_interruptible(udev
->waitq
,
339 udev
->head
!= udev
->tail
|| !test_bit(UIST_CREATED
, &udev
->state
));
343 if (!test_bit(UIST_CREATED
, &udev
->state
))
346 while ((udev
->head
!= udev
->tail
) &&
347 (retval
+ sizeof(struct input_event
) <= count
)) {
348 if (copy_to_user(buffer
+ retval
, &udev
->buff
[udev
->tail
], sizeof(struct input_event
)))
350 udev
->tail
= (udev
->tail
+ 1) % UINPUT_BUFFER_SIZE
;
351 retval
+= sizeof(struct input_event
);
357 static unsigned int uinput_poll(struct file
*file
, poll_table
*wait
)
359 struct uinput_device
*udev
= file
->private_data
;
361 poll_wait(file
, &udev
->waitq
, wait
);
363 if (udev
->head
!= udev
->tail
)
364 return POLLIN
| POLLRDNORM
;
369 static int uinput_burn_device(struct uinput_device
*udev
)
371 if (test_bit(UIST_CREATED
, &udev
->state
))
372 uinput_destroy_device(udev
);
374 kfree(udev
->dev
->name
);
375 kfree(udev
->dev
->phys
);
382 static int uinput_close(struct inode
*inode
, struct file
*file
)
384 uinput_burn_device(file
->private_data
);
388 static int uinput_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
391 struct uinput_device
*udev
;
392 void __user
*p
= (void __user
*)arg
;
393 struct uinput_ff_upload ff_up
;
394 struct uinput_ff_erase ff_erase
;
395 struct uinput_request
*req
;
399 udev
= file
->private_data
;
401 /* device attributes can not be changed after the device is created */
412 if (test_bit(UIST_CREATED
, &udev
->state
))
418 retval
= uinput_create_device(udev
);
422 retval
= uinput_destroy_device(udev
);
430 set_bit(arg
, udev
->dev
->evbit
);
438 set_bit(arg
, udev
->dev
->keybit
);
446 set_bit(arg
, udev
->dev
->relbit
);
454 set_bit(arg
, udev
->dev
->absbit
);
462 set_bit(arg
, udev
->dev
->mscbit
);
470 set_bit(arg
, udev
->dev
->ledbit
);
478 set_bit(arg
, udev
->dev
->sndbit
);
486 set_bit(arg
, udev
->dev
->ffbit
);
490 length
= strnlen_user(p
, 1024);
495 kfree(udev
->dev
->phys
);
496 udev
->dev
->phys
= phys
= kmalloc(length
, GFP_KERNEL
);
501 if (copy_from_user(phys
, p
, length
)) {
502 udev
->dev
->phys
= NULL
;
507 phys
[length
- 1] = '\0';
510 case UI_BEGIN_FF_UPLOAD
:
511 if (copy_from_user(&ff_up
, p
, sizeof(ff_up
))) {
515 req
= uinput_request_find(udev
, ff_up
.request_id
);
516 if (!(req
&& req
->code
== UI_FF_UPLOAD
&& req
->u
.effect
)) {
521 memcpy(&ff_up
.effect
, req
->u
.effect
, sizeof(struct ff_effect
));
522 if (copy_to_user(p
, &ff_up
, sizeof(ff_up
))) {
528 case UI_BEGIN_FF_ERASE
:
529 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
533 req
= uinput_request_find(udev
, ff_erase
.request_id
);
534 if (!(req
&& req
->code
== UI_FF_ERASE
)) {
539 ff_erase
.effect_id
= req
->u
.effect_id
;
540 if (copy_to_user(p
, &ff_erase
, sizeof(ff_erase
))) {
546 case UI_END_FF_UPLOAD
:
547 if (copy_from_user(&ff_up
, p
, sizeof(ff_up
))) {
551 req
= uinput_request_find(udev
, ff_up
.request_id
);
552 if (!(req
&& req
->code
== UI_FF_UPLOAD
&& req
->u
.effect
)) {
556 req
->retval
= ff_up
.retval
;
557 memcpy(req
->u
.effect
, &ff_up
.effect
, sizeof(struct ff_effect
));
558 uinput_request_done(udev
, req
);
561 case UI_END_FF_ERASE
:
562 if (copy_from_user(&ff_erase
, p
, sizeof(ff_erase
))) {
566 req
= uinput_request_find(udev
, ff_erase
.request_id
);
567 if (!(req
&& req
->code
== UI_FF_ERASE
)) {
571 req
->retval
= ff_erase
.retval
;
572 uinput_request_done(udev
, req
);
581 static struct file_operations uinput_fops
= {
582 .owner
= THIS_MODULE
,
584 .release
= uinput_close
,
586 .write
= uinput_write
,
588 .ioctl
= uinput_ioctl
,
591 static struct miscdevice uinput_misc
= {
592 .fops
= &uinput_fops
,
593 .minor
= UINPUT_MINOR
,
597 static int __init
uinput_init(void)
599 return misc_register(&uinput_misc
);
602 static void __exit
uinput_exit(void)
604 misc_deregister(&uinput_misc
);
607 MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
608 MODULE_DESCRIPTION("User level driver support for input subsystem");
609 MODULE_LICENSE("GPL");
611 module_init(uinput_init
);
612 module_exit(uinput_exit
);