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 int uinput_create_device(struct uinput_device *udev) 156 { 157 if (!udev->dev->name) { 158 printk(KERN_DEBUG "%s: write device info first\n", UINPUT_NAME); 159 return -EINVAL; 160 } 161 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; 166 167 init_waitqueue_head(&udev->waitq); 168 169 input_register_device(udev->dev); 170 171 set_bit(UIST_CREATED, &udev->state); 172 173 return 0; 174 } 175 176 static int uinput_destroy_device(struct uinput_device *udev) 177 { 178 if (!test_bit(UIST_CREATED, &udev->state)) { 179 printk(KERN_WARNING "%s: create the device first\n", UINPUT_NAME); 180 return -EINVAL; 181 } 182 183 input_unregister_device(udev->dev); 184 185 clear_bit(UIST_CREATED, &udev->state); 186 187 return 0; 188 } 189 190 static int uinput_open(struct inode *inode, struct file *file) 191 { 192 struct uinput_device *newdev; 193 struct input_dev *newinput; 194 195 newdev = kmalloc(sizeof(struct uinput_device), GFP_KERNEL); 196 if (!newdev) 197 goto error; 198 memset(newdev, 0, sizeof(struct uinput_device)); 199 spin_lock_init(&newdev->requests_lock); 200 init_waitqueue_head(&newdev->requests_waitq); 201 202 newinput = kmalloc(sizeof(struct input_dev), GFP_KERNEL); 203 if (!newinput) 204 goto cleanup; 205 memset(newinput, 0, sizeof(struct input_dev)); 206 207 newdev->dev = newinput; 208 209 file->private_data = newdev; 210 211 return 0; 212 cleanup: 213 kfree(newdev); 214 error: 215 return -ENOMEM; 216 } 217 218 static int uinput_validate_absbits(struct input_dev *dev) 219 { 220 unsigned int cnt; 221 int retval = 0; 222 223 for (cnt = 0; cnt < ABS_MAX + 1; cnt++) { 224 if (!test_bit(cnt, dev->absbit)) 225 continue; 226 227 if ((dev->absmax[cnt] <= dev->absmin[cnt])) { 228 printk(KERN_DEBUG 229 "%s: invalid abs[%02x] min:%d max:%d\n", 230 UINPUT_NAME, cnt, 231 dev->absmin[cnt], dev->absmax[cnt]); 232 retval = -EINVAL; 233 break; 234 } 235 236 if (dev->absflat[cnt] > (dev->absmax[cnt] - dev->absmin[cnt])) { 237 printk(KERN_DEBUG 238 "%s: absflat[%02x] out of range: %d " 239 "(min:%d/max:%d)\n", 240 UINPUT_NAME, cnt, dev->absflat[cnt], 241 dev->absmin[cnt], dev->absmax[cnt]); 242 retval = -EINVAL; 243 break; 244 } 245 } 246 return retval; 247 } 248 249 static int uinput_alloc_device(struct file *file, const char __user *buffer, size_t count) 250 { 251 struct uinput_user_dev *user_dev; 252 struct input_dev *dev; 253 struct uinput_device *udev; 254 char *name; 255 int size; 256 int retval; 257 258 retval = count; 259 260 udev = file->private_data; 261 dev = udev->dev; 262 263 user_dev = kmalloc(sizeof(struct uinput_user_dev), GFP_KERNEL); 264 if (!user_dev) { 265 retval = -ENOMEM; 266 goto exit; 267 } 268 269 if (copy_from_user(user_dev, buffer, sizeof(struct uinput_user_dev))) { 270 retval = -EFAULT; 271 goto exit; 272 } 273 274 if (dev->name) 275 kfree(dev->name); 276 277 size = strnlen(user_dev->name, UINPUT_MAX_NAME_SIZE) + 1; 278 dev->name = name = kmalloc(size, GFP_KERNEL); 279 if (!name) { 280 retval = -ENOMEM; 281 goto exit; 282 } 283 strlcpy(name, user_dev->name, size); 284 285 dev->id.bustype = user_dev->id.bustype; 286 dev->id.vendor = user_dev->id.vendor; 287 dev->id.product = user_dev->id.product; 288 dev->id.version = user_dev->id.version; 289 dev->ff_effects_max = user_dev->ff_effects_max; 290 291 size = sizeof(int) * (ABS_MAX + 1); 292 memcpy(dev->absmax, user_dev->absmax, size); 293 memcpy(dev->absmin, user_dev->absmin, size); 294 memcpy(dev->absfuzz, user_dev->absfuzz, size); 295 memcpy(dev->absflat, user_dev->absflat, size); 296 297 /* check if absmin/absmax/absfuzz/absflat are filled as 298 * told in Documentation/input/input-programming.txt */ 299 if (test_bit(EV_ABS, dev->evbit)) { 300 int err = uinput_validate_absbits(dev); 301 if (err < 0) { 302 retval = err; 303 kfree(dev->name); 304 } 305 } 306 307 exit: 308 kfree(user_dev); 309 return retval; 310 } 311 312 static ssize_t uinput_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) 313 { 314 struct uinput_device *udev = file->private_data; 315 316 if (test_bit(UIST_CREATED, &udev->state)) { 317 struct input_event ev; 318 319 if (copy_from_user(&ev, buffer, sizeof(struct input_event))) 320 return -EFAULT; 321 input_event(udev->dev, ev.type, ev.code, ev.value); 322 } else 323 count = uinput_alloc_device(file, buffer, count); 324 325 return count; 326 } 327 328 static ssize_t uinput_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos) 329 { 330 struct uinput_device *udev = file->private_data; 331 int retval = 0; 332 333 if (!test_bit(UIST_CREATED, &udev->state)) 334 return -ENODEV; 335 336 if (udev->head == udev->tail && (file->f_flags & O_NONBLOCK)) 337 return -EAGAIN; 338 339 retval = wait_event_interruptible(udev->waitq, 340 udev->head != udev->tail || !test_bit(UIST_CREATED, &udev->state)); 341 if (retval) 342 return retval; 343 344 if (!test_bit(UIST_CREATED, &udev->state)) 345 return -ENODEV; 346 347 while ((udev->head != udev->tail) && 348 (retval + sizeof(struct input_event) <= count)) { 349 if (copy_to_user(buffer + retval, &udev->buff[udev->tail], sizeof(struct input_event))) 350 return -EFAULT; 351 udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE; 352 retval += sizeof(struct input_event); 353 } 354 355 return retval; 356 } 357 358 static unsigned int uinput_poll(struct file *file, poll_table *wait) 359 { 360 struct uinput_device *udev = file->private_data; 361 362 poll_wait(file, &udev->waitq, wait); 363 364 if (udev->head != udev->tail) 365 return POLLIN | POLLRDNORM; 366 367 return 0; 368 } 369 370 static int uinput_burn_device(struct uinput_device *udev) 371 { 372 if (test_bit(UIST_CREATED, &udev->state)) 373 uinput_destroy_device(udev); 374 375 if (udev->dev->name) 376 kfree(udev->dev->name); 377 if (udev->dev->phys) 378 kfree(udev->dev->phys); 379 380 kfree(udev->dev); 381 kfree(udev); 382 383 return 0; 384 } 385 386 static int uinput_close(struct inode *inode, struct file *file) 387 { 388 uinput_burn_device(file->private_data); 389 return 0; 390 } 391 392 static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 393 { 394 int retval = 0; 395 struct uinput_device *udev; 396 void __user *p = (void __user *)arg; 397 struct uinput_ff_upload ff_up; 398 struct uinput_ff_erase ff_erase; 399 struct uinput_request *req; 400 int length; 401 char *phys; 402 403 udev = file->private_data; 404 405 /* device attributes can not be changed after the device is created */ 406 switch (cmd) { 407 case UI_SET_EVBIT: 408 case UI_SET_KEYBIT: 409 case UI_SET_RELBIT: 410 case UI_SET_ABSBIT: 411 case UI_SET_MSCBIT: 412 case UI_SET_LEDBIT: 413 case UI_SET_SNDBIT: 414 case UI_SET_FFBIT: 415 case UI_SET_PHYS: 416 if (test_bit(UIST_CREATED, &udev->state)) 417 return -EINVAL; 418 } 419 420 switch (cmd) { 421 case UI_DEV_CREATE: 422 retval = uinput_create_device(udev); 423 break; 424 425 case UI_DEV_DESTROY: 426 retval = uinput_destroy_device(udev); 427 break; 428 429 case UI_SET_EVBIT: 430 if (arg > EV_MAX) { 431 retval = -EINVAL; 432 break; 433 } 434 set_bit(arg, udev->dev->evbit); 435 break; 436 437 case UI_SET_KEYBIT: 438 if (arg > KEY_MAX) { 439 retval = -EINVAL; 440 break; 441 } 442 set_bit(arg, udev->dev->keybit); 443 break; 444 445 case UI_SET_RELBIT: 446 if (arg > REL_MAX) { 447 retval = -EINVAL; 448 break; 449 } 450 set_bit(arg, udev->dev->relbit); 451 break; 452 453 case UI_SET_ABSBIT: 454 if (arg > ABS_MAX) { 455 retval = -EINVAL; 456 break; 457 } 458 set_bit(arg, udev->dev->absbit); 459 break; 460 461 case UI_SET_MSCBIT: 462 if (arg > MSC_MAX) { 463 retval = -EINVAL; 464 break; 465 } 466 set_bit(arg, udev->dev->mscbit); 467 break; 468 469 case UI_SET_LEDBIT: 470 if (arg > LED_MAX) { 471 retval = -EINVAL; 472 break; 473 } 474 set_bit(arg, udev->dev->ledbit); 475 break; 476 477 case UI_SET_SNDBIT: 478 if (arg > SND_MAX) { 479 retval = -EINVAL; 480 break; 481 } 482 set_bit(arg, udev->dev->sndbit); 483 break; 484 485 case UI_SET_FFBIT: 486 if (arg > FF_MAX) { 487 retval = -EINVAL; 488 break; 489 } 490 set_bit(arg, udev->dev->ffbit); 491 break; 492 493 case UI_SET_PHYS: 494 length = strnlen_user(p, 1024); 495 if (length <= 0) { 496 retval = -EFAULT; 497 break; 498 } 499 kfree(udev->dev->phys); 500 udev->dev->phys = phys = kmalloc(length, GFP_KERNEL); 501 if (!phys) { 502 retval = -ENOMEM; 503 break; 504 } 505 if (copy_from_user(phys, p, length)) { 506 udev->dev->phys = NULL; 507 kfree(phys); 508 retval = -EFAULT; 509 break; 510 } 511 phys[length - 1] = '\0'; 512 break; 513 514 case UI_BEGIN_FF_UPLOAD: 515 if (copy_from_user(&ff_up, p, sizeof(ff_up))) { 516 retval = -EFAULT; 517 break; 518 } 519 req = uinput_request_find(udev, ff_up.request_id); 520 if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) { 521 retval = -EINVAL; 522 break; 523 } 524 ff_up.retval = 0; 525 memcpy(&ff_up.effect, req->u.effect, sizeof(struct ff_effect)); 526 if (copy_to_user(p, &ff_up, sizeof(ff_up))) { 527 retval = -EFAULT; 528 break; 529 } 530 break; 531 532 case UI_BEGIN_FF_ERASE: 533 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) { 534 retval = -EFAULT; 535 break; 536 } 537 req = uinput_request_find(udev, ff_erase.request_id); 538 if (!(req && req->code == UI_FF_ERASE)) { 539 retval = -EINVAL; 540 break; 541 } 542 ff_erase.retval = 0; 543 ff_erase.effect_id = req->u.effect_id; 544 if (copy_to_user(p, &ff_erase, sizeof(ff_erase))) { 545 retval = -EFAULT; 546 break; 547 } 548 break; 549 550 case UI_END_FF_UPLOAD: 551 if (copy_from_user(&ff_up, p, sizeof(ff_up))) { 552 retval = -EFAULT; 553 break; 554 } 555 req = uinput_request_find(udev, ff_up.request_id); 556 if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) { 557 retval = -EINVAL; 558 break; 559 } 560 req->retval = ff_up.retval; 561 memcpy(req->u.effect, &ff_up.effect, sizeof(struct ff_effect)); 562 uinput_request_done(udev, req); 563 break; 564 565 case UI_END_FF_ERASE: 566 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) { 567 retval = -EFAULT; 568 break; 569 } 570 req = uinput_request_find(udev, ff_erase.request_id); 571 if (!(req && req->code == UI_FF_ERASE)) { 572 retval = -EINVAL; 573 break; 574 } 575 req->retval = ff_erase.retval; 576 uinput_request_done(udev, req); 577 break; 578 579 default: 580 retval = -EINVAL; 581 } 582 return retval; 583 } 584 585 static struct file_operations uinput_fops = { 586 .owner = THIS_MODULE, 587 .open = uinput_open, 588 .release = uinput_close, 589 .read = uinput_read, 590 .write = uinput_write, 591 .poll = uinput_poll, 592 .ioctl = uinput_ioctl, 593 }; 594 595 static struct miscdevice uinput_misc = { 596 .fops = &uinput_fops, 597 .minor = UINPUT_MINOR, 598 .name = UINPUT_NAME, 599 }; 600 601 static int __init uinput_init(void) 602 { 603 return misc_register(&uinput_misc); 604 } 605 606 static void __exit uinput_exit(void) 607 { 608 misc_deregister(&uinput_misc); 609 } 610 611 MODULE_AUTHOR("Aristeu Sergio Rozanski Filho"); 612 MODULE_DESCRIPTION("User level driver support for input subsystem"); 613 MODULE_LICENSE("GPL"); 614 615 module_init(uinput_init); 616 module_exit(uinput_exit); 617 618