projects / deliverable / linux.git / blob
? search:


4702ade804ac9ef5c73876a5e2acbc4e648e8797
[deliverable/linux.git] / drivers / input / misc / uinput.c
1 /*
2 * User level driver support for input subsystem
3 *
4 * Heavily based on evdev.c by Vojtech Pavlik
5 *
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.
10 *
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.
15 *
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
19 *
20 * Author: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
21 *
22 * Changes/Revisions:
23 * 0.2 16/10/2004 (Micah Dowty <micah@navi.cx>)
24 * - added force feedback support
25 * - added UI_SET_PHYS
26 * 0.1 20/06/2002
27 * - first public version
28 */
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>
35 #include <linux/fs.h>
36 #include <linux/miscdevice.h>
37 #include <linux/uinput.h>
38
39 static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
40 {
41 struct uinput_device *udev;
42
43 udev = dev->private;
44
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;
50
51 wake_up_interruptible(&udev->waitq);
52
53 return 0;
54 }
55
56 static int uinput_request_alloc_id(struct uinput_device *udev, struct uinput_request *request)
57 {
58 /* Atomically allocate an ID for the given request. Returns 0 on success. */
59 int id;
60 int err = -1;
61
62 spin_lock(&udev->requests_lock);
63
64 for (id = 0; id < UINPUT_NUM_REQUESTS; id++)
65 if (!udev->requests[id]) {
66 request->id = id;
67 udev->requests[id] = request;
68 err = 0;
69 break;
70 }
71
72 spin_unlock(&udev->requests_lock);
73 return err;
74 }
75
76 static struct uinput_request* uinput_request_find(struct uinput_device *udev, int id)
77 {
78 /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
79 if (id >= UINPUT_NUM_REQUESTS || id < 0)
80 return NULL;
81 return udev->requests[id];
82 }
83
84 static inline int uinput_request_reserve_slot(struct uinput_device *udev, struct uinput_request *request)
85 {
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));
89 }
90
91 static void uinput_request_done(struct uinput_device *udev, struct uinput_request *request)
92 {
93 /* Mark slot as available */
94 udev->requests[request->id] = NULL;
95 wake_up_interruptible(&udev->requests_waitq);
96
97 complete(&request->done);
98 }
99
100 static int uinput_request_submit(struct input_dev *dev, struct uinput_request *request)
101 {
102 int retval;
103
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);
106
107 /* Wait for the request to complete */
108 retval = wait_for_completion_interruptible(&request->done);
109 if (!retval)
110 retval = request->retval;
111
112 return retval;
113 }
114
115 static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *effect)
116 {
117 struct uinput_request request;
118 int retval;
119
120 if (!test_bit(EV_FF, dev->evbit))
121 return -ENOSYS;
122
123 request.id = -1;
124 init_completion(&request.done);
125 request.code = UI_FF_UPLOAD;
126 request.u.effect = effect;
127
128 retval = uinput_request_reserve_slot(dev->private, &request);
129 if (!retval)
130 retval = uinput_request_submit(dev, &request);
131
132 return retval;
133 }
134
135 static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id)
136 {
137 struct uinput_request request;
138 int retval;
139
140 if (!test_bit(EV_FF, dev->evbit))
141 return -ENOSYS;
142
143 request.id = -1;
144 init_completion(&request.done);
145 request.code = UI_FF_ERASE;
146 request.u.effect_id = effect_id;
147
148 retval = uinput_request_reserve_slot(dev->private, &request);
149 if (!retval)
150 retval = uinput_request_submit(dev, &request);
151
152 return retval;
153 }
154
155 static void uinput_destroy_device(struct uinput_device *udev)
156 {
157 const char *name, *phys;
158
159 if (udev->dev) {
160 name = udev->dev->name;
161 phys = udev->dev->phys;
162 if (udev->state == UIST_CREATED)
163 input_unregister_device(udev->dev);
164 else
165 input_free_device(udev->dev);
166 kfree(name);
167 kfree(phys);
168 udev->dev = NULL;
169 }
170
171 udev->state = UIST_NEW_DEVICE;
172 }
173
174 static int uinput_create_device(struct uinput_device *udev)
175 {
176 int error;
177
178 if (udev->state != UIST_SETUP_COMPLETE) {
179 printk(KERN_DEBUG "%s: write device info first\n", UINPUT_NAME);
180 return -EINVAL;
181 }
182
183 error = input_register_device(udev->dev);
184 if (error) {
185 uinput_destroy_device(udev);
186 return error;
187 }
188
189 udev->state = UIST_CREATED;
190
191 return 0;
192 }
193
194 static int uinput_open(struct inode *inode, struct file *file)
195 {
196 struct uinput_device *newdev;
197
198 newdev = kzalloc(sizeof(struct uinput_device), GFP_KERNEL);
199 if (!newdev)
200 return -ENOMEM;
201
202 init_MUTEX(&newdev->sem);
203 spin_lock_init(&newdev->requests_lock);
204 init_waitqueue_head(&newdev->requests_waitq);
205 init_waitqueue_head(&newdev->waitq);
206 newdev->state = UIST_NEW_DEVICE;
207
208 file->private_data = newdev;
209
210 return 0;
211 }
212
213 static int uinput_validate_absbits(struct input_dev *dev)
214 {
215 unsigned int cnt;
216 int retval = 0;
217
218 for (cnt = 0; cnt < ABS_MAX + 1; cnt++) {
219 if (!test_bit(cnt, dev->absbit))
220 continue;
221
222 if ((dev->absmax[cnt] <= dev->absmin[cnt])) {
223 printk(KERN_DEBUG
224 "%s: invalid abs[%02x] min:%d max:%d\n",
225 UINPUT_NAME, cnt,
226 dev->absmin[cnt], dev->absmax[cnt]);
227 retval = -EINVAL;
228 break;
229 }
230
231 if (dev->absflat[cnt] > (dev->absmax[cnt] - dev->absmin[cnt])) {
232 printk(KERN_DEBUG
233 "%s: absflat[%02x] out of range: %d "
234 "(min:%d/max:%d)\n",
235 UINPUT_NAME, cnt, dev->absflat[cnt],
236 dev->absmin[cnt], dev->absmax[cnt]);
237 retval = -EINVAL;
238 break;
239 }
240 }
241 return retval;
242 }
243
244 static int uinput_allocate_device(struct uinput_device *udev)
245 {
246 udev->dev = input_allocate_device();
247 if (!udev->dev)
248 return -ENOMEM;
249
250 udev->dev->event = uinput_dev_event;
251 udev->dev->upload_effect = uinput_dev_upload_effect;
252 udev->dev->erase_effect = uinput_dev_erase_effect;
253 udev->dev->private = udev;
254
255 return 0;
256 }
257
258 static int uinput_setup_device(struct uinput_device *udev, const char __user *buffer, size_t count)
259 {
260 struct uinput_user_dev *user_dev;
261 struct input_dev *dev;
262 char *name;
263 int size;
264 int retval;
265
266 if (count != sizeof(struct uinput_user_dev))
267 return -EINVAL;
268
269 if (!udev->dev) {
270 retval = uinput_allocate_device(udev);
271 if (retval)
272 return retval;
273 }
274
275 dev = udev->dev;
276
277 user_dev = kmalloc(sizeof(struct uinput_user_dev), GFP_KERNEL);
278 if (!user_dev)
279 return -ENOMEM;
280
281 if (copy_from_user(user_dev, buffer, sizeof(struct uinput_user_dev))) {
282 retval = -EFAULT;
283 goto exit;
284 }
285
286 size = strnlen(user_dev->name, UINPUT_MAX_NAME_SIZE) + 1;
287 if (!size) {
288 retval = -EINVAL;
289 goto exit;
290 }
291
292 kfree(dev->name);
293 dev->name = name = kmalloc(size, GFP_KERNEL);
294 if (!name) {
295 retval = -ENOMEM;
296 goto exit;
297 }
298 strlcpy(name, user_dev->name, size);
299
300 dev->id.bustype = user_dev->id.bustype;
301 dev->id.vendor = user_dev->id.vendor;
302 dev->id.product = user_dev->id.product;
303 dev->id.version = user_dev->id.version;
304 dev->ff_effects_max = user_dev->ff_effects_max;
305
306 size = sizeof(int) * (ABS_MAX + 1);
307 memcpy(dev->absmax, user_dev->absmax, size);
308 memcpy(dev->absmin, user_dev->absmin, size);
309 memcpy(dev->absfuzz, user_dev->absfuzz, size);
310 memcpy(dev->absflat, user_dev->absflat, size);
311
312 /* check if absmin/absmax/absfuzz/absflat are filled as
313 * told in Documentation/input/input-programming.txt */
314 if (test_bit(EV_ABS, dev->evbit)) {
315 retval = uinput_validate_absbits(dev);
316 if (retval < 0)
317 goto exit;
318 }
319
320 udev->state = UIST_SETUP_COMPLETE;
321 retval = count;
322
323 exit:
324 kfree(user_dev);
325 return retval;
326 }
327
328 static inline ssize_t uinput_inject_event(struct uinput_device *udev, const char __user *buffer, size_t count)
329 {
330 struct input_event ev;
331
332 if (count != sizeof(struct input_event))
333 return -EINVAL;
334
335 if (copy_from_user(&ev, buffer, sizeof(struct input_event)))
336 return -EFAULT;
337
338 input_event(udev->dev, ev.type, ev.code, ev.value);
339
340 return sizeof(struct input_event);
341 }
342
343 static ssize_t uinput_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
344 {
345 struct uinput_device *udev = file->private_data;
346 int retval;
347
348 retval = down_interruptible(&udev->sem);
349 if (retval)
350 return retval;
351
352 retval = udev->state == UIST_CREATED ?
353 uinput_inject_event(udev, buffer, count) :
354 uinput_setup_device(udev, buffer, count);
355
356 up(&udev->sem);
357
358 return retval;
359 }
360
361 static ssize_t uinput_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
362 {
363 struct uinput_device *udev = file->private_data;
364 int retval = 0;
365
366 if (udev->state != UIST_CREATED)
367 return -ENODEV;
368
369 if (udev->head == udev->tail && (file->f_flags & O_NONBLOCK))
370 return -EAGAIN;
371
372 retval = wait_event_interruptible(udev->waitq,
373 udev->head != udev->tail || udev->state != UIST_CREATED);
374 if (retval)
375 return retval;
376
377 retval = down_interruptible(&udev->sem);
378 if (retval)
379 return retval;
380
381 if (udev->state != UIST_CREATED) {
382 retval = -ENODEV;
383 goto out;
384 }
385
386 while (udev->head != udev->tail && retval + sizeof(struct input_event) <= count) {
387 if (copy_to_user(buffer + retval, &udev->buff[udev->tail], sizeof(struct input_event))) {
388 retval = -EFAULT;
389 goto out;
390 }
391 udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
392 retval += sizeof(struct input_event);
393 }
394
395 out:
396 up(&udev->sem);
397
398 return retval;
399 }
400
401 static unsigned int uinput_poll(struct file *file, poll_table *wait)
402 {
403 struct uinput_device *udev = file->private_data;
404
405 poll_wait(file, &udev->waitq, wait);
406
407 if (udev->head != udev->tail)
408 return POLLIN | POLLRDNORM;
409
410 return 0;
411 }
412
413 static int uinput_release(struct inode *inode, struct file *file)
414 {
415 struct uinput_device *udev = file->private_data;
416
417 uinput_destroy_device(udev);
418 kfree(udev);
419
420 return 0;
421 }
422
423 #define uinput_set_bit(_arg, _bit, _max) \
424 ({ \
425 int __ret = 0; \
426 if (udev->state == UIST_CREATED) \
427 __ret = -EINVAL; \
428 else if ((_arg) > (_max)) \
429 __ret = -EINVAL; \
430 else set_bit((_arg), udev->dev->_bit); \
431 __ret; \
432 })
433
434 static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
435 {
436 int retval;
437 struct uinput_device *udev;
438 void __user *p = (void __user *)arg;
439 struct uinput_ff_upload ff_up;
440 struct uinput_ff_erase ff_erase;
441 struct uinput_request *req;
442 int length;
443 char *phys;
444
445 udev = file->private_data;
446
447 retval = down_interruptible(&udev->sem);
448 if (retval)
449 return retval;
450
451 if (!udev->dev) {
452 retval = uinput_allocate_device(udev);
453 if (retval)
454 goto out;
455 }
456
457 switch (cmd) {
458 case UI_DEV_CREATE:
459 retval = uinput_create_device(udev);
460 break;
461
462 case UI_DEV_DESTROY:
463 uinput_destroy_device(udev);
464 break;
465
466 case UI_SET_EVBIT:
467 retval = uinput_set_bit(arg, evbit, EV_MAX);
468 break;
469
470 case UI_SET_KEYBIT:
471 retval = uinput_set_bit(arg, keybit, KEY_MAX);
472 break;
473
474 case UI_SET_RELBIT:
475 retval = uinput_set_bit(arg, relbit, REL_MAX);
476 break;
477
478 case UI_SET_ABSBIT:
479 retval = uinput_set_bit(arg, absbit, ABS_MAX);
480 break;
481
482 case UI_SET_MSCBIT:
483 retval = uinput_set_bit(arg, mscbit, MSC_MAX);
484 break;
485
486 case UI_SET_LEDBIT:
487 retval = uinput_set_bit(arg, ledbit, LED_MAX);
488 break;
489
490 case UI_SET_SNDBIT:
491 retval = uinput_set_bit(arg, sndbit, SND_MAX);
492 break;
493
494 case UI_SET_FFBIT:
495 retval = uinput_set_bit(arg, ffbit, FF_MAX);
496 break;
497
498 case UI_SET_SWBIT:
499 retval = uinput_set_bit(arg, swbit, SW_MAX);
500 break;
501
502 case UI_SET_PHYS:
503 if (udev->state == UIST_CREATED) {
504 retval = -EINVAL;
505 goto out;
506 }
507 length = strnlen_user(p, 1024);
508 if (length <= 0) {
509 retval = -EFAULT;
510 break;
511 }
512 kfree(udev->dev->phys);
513 udev->dev->phys = phys = kmalloc(length, GFP_KERNEL);
514 if (!phys) {
515 retval = -ENOMEM;
516 break;
517 }
518 if (copy_from_user(phys, p, length)) {
519 udev->dev->phys = NULL;
520 kfree(phys);
521 retval = -EFAULT;
522 break;
523 }
524 phys[length - 1] = '\0';
525 break;
526
527 case UI_BEGIN_FF_UPLOAD:
528 if (copy_from_user(&ff_up, p, sizeof(ff_up))) {
529 retval = -EFAULT;
530 break;
531 }
532 req = uinput_request_find(udev, ff_up.request_id);
533 if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) {
534 retval = -EINVAL;
535 break;
536 }
537 ff_up.retval = 0;
538 memcpy(&ff_up.effect, req->u.effect, sizeof(struct ff_effect));
539 if (copy_to_user(p, &ff_up, sizeof(ff_up))) {
540 retval = -EFAULT;
541 break;
542 }
543 break;
544
545 case UI_BEGIN_FF_ERASE:
546 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
547 retval = -EFAULT;
548 break;
549 }
550 req = uinput_request_find(udev, ff_erase.request_id);
551 if (!(req && req->code == UI_FF_ERASE)) {
552 retval = -EINVAL;
553 break;
554 }
555 ff_erase.retval = 0;
556 ff_erase.effect_id = req->u.effect_id;
557 if (copy_to_user(p, &ff_erase, sizeof(ff_erase))) {
558 retval = -EFAULT;
559 break;
560 }
561 break;
562
563 case UI_END_FF_UPLOAD:
564 if (copy_from_user(&ff_up, p, sizeof(ff_up))) {
565 retval = -EFAULT;
566 break;
567 }
568 req = uinput_request_find(udev, ff_up.request_id);
569 if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) {
570 retval = -EINVAL;
571 break;
572 }
573 req->retval = ff_up.retval;
574 memcpy(req->u.effect, &ff_up.effect, sizeof(struct ff_effect));
575 uinput_request_done(udev, req);
576 break;
577
578 case UI_END_FF_ERASE:
579 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
580 retval = -EFAULT;
581 break;
582 }
583 req = uinput_request_find(udev, ff_erase.request_id);
584 if (!(req && req->code == UI_FF_ERASE)) {
585 retval = -EINVAL;
586 break;
587 }
588 req->retval = ff_erase.retval;
589 uinput_request_done(udev, req);
590 break;
591
592 default:
593 retval = -EINVAL;
594 }
595
596 out:
597 up(&udev->sem);
598 return retval;
599 }
600
601 static struct file_operations uinput_fops = {
602 .owner = THIS_MODULE,
603 .open = uinput_open,
604 .release = uinput_release,
605 .read = uinput_read,
606 .write = uinput_write,
607 .poll = uinput_poll,
608 .unlocked_ioctl = uinput_ioctl,
609 };
610
611 static struct miscdevice uinput_misc = {
612 .fops = &uinput_fops,
613 .minor = UINPUT_MINOR,
614 .name = UINPUT_NAME,
615 };
616
617 static int __init uinput_init(void)
618 {
619 return misc_register(&uinput_misc);
620 }
621
622 static void __exit uinput_exit(void)
623 {
624 misc_deregister(&uinput_misc);
625 }
626
627 MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
628 MODULE_DESCRIPTION("User level driver support for input subsystem");
629 MODULE_LICENSE("GPL");
630
631 module_init(uinput_init);
632 module_exit(uinput_exit);
633
Linux kernel - Deliverables
This page took 0.042545 seconds and 4 git commands to generate.