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.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 30 * - added UI_SET_PHYS 31 * 0.1 20/06/2002 32 * - first public version 33 */ 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> 39#include <linux/fs.h> 40#include <linux/miscdevice.h> 41#include <linux/uinput.h> 42#include <linux/input/mt.h> 43#include "../input-compat.h" 44 45static int uinput_dev_event(struct input_dev *dev, 46 unsigned int type, unsigned int code, int value) 47{ 48 struct uinput_device *udev = input_get_drvdata(dev); 49 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; 55 56 wake_up_interruptible(&udev->waitq); 57 58 return 0; 59} 60 61/* Atomically allocate an ID for the given request. Returns 0 on success. */ 62static bool uinput_request_alloc_id(struct uinput_device *udev, 63 struct uinput_request *request) 64{ 65 unsigned int id; 66 bool reserved = false; 67 68 spin_lock(&udev->requests_lock); 69 70 for (id = 0; id < UINPUT_NUM_REQUESTS; id++) { 71 if (!udev->requests[id]) { 72 request->id = id; 73 udev->requests[id] = request; 74 reserved = true; 75 break; 76 } 77 } 78 79 spin_unlock(&udev->requests_lock); 80 return reserved; 81} 82 83static struct uinput_request *uinput_request_find(struct uinput_device *udev, 84 unsigned int id) 85{ 86 /* Find an input request, by ID. Returns NULL if the ID isn't valid. */ 87 if (id >= UINPUT_NUM_REQUESTS) 88 return NULL; 89 90 return udev->requests[id]; 91} 92 93static int uinput_request_reserve_slot(struct uinput_device *udev, 94 struct uinput_request *request) 95{ 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)); 99} 100 101static void uinput_request_done(struct uinput_device *udev, 102 struct uinput_request *request) 103{ 104 /* Mark slot as available */ 105 udev->requests[request->id] = NULL; 106 wake_up(&udev->requests_waitq); 107 108 complete(&request->done); 109} 110 111static int uinput_request_send(struct uinput_device *udev, 112 struct uinput_request *request) 113{ 114 int retval; 115 116 retval = mutex_lock_interruptible(&udev->mutex); 117 if (retval) 118 return retval; 119 120 if (udev->state != UIST_CREATED) { 121 retval = -ENODEV; 122 goto out; 123 } 124 125 init_completion(&request->done); 126 127 /* 128 * Tell our userspace application about this new request 129 * by queueing an input event. 130 */ 131 uinput_dev_event(udev->dev, EV_UINPUT, request->code, request->id); 132 133 out: 134 mutex_unlock(&udev->mutex); 135 return retval; 136} 137 138static int uinput_request_submit(struct uinput_device *udev, 139 struct uinput_request *request) 140{ 141 int error; 142 143 error = uinput_request_reserve_slot(udev, request); 144 if (error) 145 return error; 146 147 error = uinput_request_send(udev, request); 148 if (error) { 149 uinput_request_done(udev, request); 150 return error; 151 } 152 153 wait_for_completion(&request->done); 154 return request->retval; 155} 156 157/* 158 * Fail all outstanding requests so handlers don't wait for the userspace 159 * to finish processing them. 160 */ 161static void uinput_flush_requests(struct uinput_device *udev) 162{ 163 struct uinput_request *request; 164 int i; 165 166 spin_lock(&udev->requests_lock); 167 168 for (i = 0; i < UINPUT_NUM_REQUESTS; i++) { 169 request = udev->requests[i]; 170 if (request) { 171 request->retval = -ENODEV; 172 uinput_request_done(udev, request); 173 } 174 } 175 176 spin_unlock(&udev->requests_lock); 177} 178 179static void uinput_dev_set_gain(struct input_dev *dev, u16 gain) 180{ 181 uinput_dev_event(dev, EV_FF, FF_GAIN, gain); 182} 183 184static void uinput_dev_set_autocenter(struct input_dev *dev, u16 magnitude) 185{ 186 uinput_dev_event(dev, EV_FF, FF_AUTOCENTER, magnitude); 187} 188 189static int uinput_dev_playback(struct input_dev *dev, int effect_id, int value) 190{ 191 return uinput_dev_event(dev, EV_FF, effect_id, value); 192} 193 194static int uinput_dev_upload_effect(struct input_dev *dev, 195 struct ff_effect *effect, 196 struct ff_effect *old) 197{ 198 struct uinput_device *udev = input_get_drvdata(dev); 199 struct uinput_request request; 200 201 /* 202 * uinput driver does not currently support periodic effects with 203 * custom waveform since it does not have a way to pass buffer of 204 * samples (custom_data) to userspace. If ever there is a device 205 * supporting custom waveforms we would need to define an additional 206 * ioctl (UI_UPLOAD_SAMPLES) but for now we just bail out. 207 */ 208 if (effect->type == FF_PERIODIC && 209 effect->u.periodic.waveform == FF_CUSTOM) 210 return -EINVAL; 211 212 request.code = UI_FF_UPLOAD; 213 request.u.upload.effect = effect; 214 request.u.upload.old = old; 215 216 return uinput_request_submit(udev, &request); 217} 218 219static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id) 220{ 221 struct uinput_device *udev = input_get_drvdata(dev); 222 struct uinput_request request; 223 224 if (!test_bit(EV_FF, dev->evbit)) 225 return -ENOSYS; 226 227 request.code = UI_FF_ERASE; 228 request.u.effect_id = effect_id; 229 230 return uinput_request_submit(udev, &request); 231} 232 233static void uinput_destroy_device(struct uinput_device *udev) 234{ 235 const char *name, *phys; 236 struct input_dev *dev = udev->dev; 237 enum uinput_state old_state = udev->state; 238 239 udev->state = UIST_NEW_DEVICE; 240 241 if (dev) { 242 name = dev->name; 243 phys = dev->phys; 244 if (old_state == UIST_CREATED) { 245 uinput_flush_requests(udev); 246 input_unregister_device(dev); 247 } else { 248 input_free_device(dev); 249 } 250 kfree(name); 251 kfree(phys); 252 udev->dev = NULL; 253 } 254} 255 256static int uinput_create_device(struct uinput_device *udev) 257{ 258 struct input_dev *dev = udev->dev; 259 int error; 260 261 if (udev->state != UIST_SETUP_COMPLETE) { 262 printk(KERN_DEBUG "%s: write device info first\n", UINPUT_NAME); 263 return -EINVAL; 264 } 265 266 if (udev->ff_effects_max) { 267 error = input_ff_create(dev, udev->ff_effects_max); 268 if (error) 269 goto fail1; 270 271 dev->ff->upload = uinput_dev_upload_effect; 272 dev->ff->erase = uinput_dev_erase_effect; 273 dev->ff->playback = uinput_dev_playback; 274 dev->ff->set_gain = uinput_dev_set_gain; 275 dev->ff->set_autocenter = uinput_dev_set_autocenter; 276 } 277 278 error = input_register_device(udev->dev); 279 if (error) 280 goto fail2; 281 282 udev->state = UIST_CREATED; 283 284 return 0; 285 286 fail2: input_ff_destroy(dev); 287 fail1: uinput_destroy_device(udev); 288 return error; 289} 290 291static int uinput_open(struct inode *inode, struct file *file) 292{ 293 struct uinput_device *newdev; 294 295 newdev = kzalloc(sizeof(struct uinput_device), GFP_KERNEL); 296 if (!newdev) 297 return -ENOMEM; 298 299 mutex_init(&newdev->mutex); 300 spin_lock_init(&newdev->requests_lock); 301 init_waitqueue_head(&newdev->requests_waitq); 302 init_waitqueue_head(&newdev->waitq); 303 newdev->state = UIST_NEW_DEVICE; 304 305 file->private_data = newdev; 306 nonseekable_open(inode, file); 307 308 return 0; 309} 310 311static int uinput_validate_absbits(struct input_dev *dev) 312{ 313 unsigned int cnt; 314 int nslot; 315 316 if (!test_bit(EV_ABS, dev->evbit)) 317 return 0; 318 319 /* 320 * Check if absmin/absmax/absfuzz/absflat are sane. 321 */ 322 323 for (cnt = 0; cnt < ABS_CNT; cnt++) { 324 int min, max; 325 if (!test_bit(cnt, dev->absbit)) 326 continue; 327 328 min = input_abs_get_min(dev, cnt); 329 max = input_abs_get_max(dev, cnt); 330 331 if ((min != 0 || max != 0) && max <= min) { 332 printk(KERN_DEBUG 333 "%s: invalid abs[%02x] min:%d max:%d\n", 334 UINPUT_NAME, cnt, 335 input_abs_get_min(dev, cnt), 336 input_abs_get_max(dev, cnt)); 337 return -EINVAL; 338 } 339 340 if (input_abs_get_flat(dev, cnt) > 341 input_abs_get_max(dev, cnt) - input_abs_get_min(dev, cnt)) { 342 printk(KERN_DEBUG 343 "%s: abs_flat #%02x out of range: %d " 344 "(min:%d/max:%d)\n", 345 UINPUT_NAME, cnt, 346 input_abs_get_flat(dev, cnt), 347 input_abs_get_min(dev, cnt), 348 input_abs_get_max(dev, cnt)); 349 return -EINVAL; 350 } 351 } 352 353 if (test_bit(ABS_MT_SLOT, dev->absbit)) { 354 nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1; 355 input_mt_init_slots(dev, nslot, 0); 356 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) { 357 input_set_events_per_packet(dev, 60); 358 } 359 360 return 0; 361} 362 363static int uinput_allocate_device(struct uinput_device *udev) 364{ 365 udev->dev = input_allocate_device(); 366 if (!udev->dev) 367 return -ENOMEM; 368 369 udev->dev->event = uinput_dev_event; 370 input_set_drvdata(udev->dev, udev); 371 372 return 0; 373} 374 375static int uinput_setup_device(struct uinput_device *udev, 376 const char __user *buffer, size_t count) 377{ 378 struct uinput_user_dev *user_dev; 379 struct input_dev *dev; 380 int i; 381 int retval; 382 383 if (count != sizeof(struct uinput_user_dev)) 384 return -EINVAL; 385 386 if (!udev->dev) { 387 retval = uinput_allocate_device(udev); 388 if (retval) 389 return retval; 390 } 391 392 dev = udev->dev; 393 394 user_dev = memdup_user(buffer, sizeof(struct uinput_user_dev)); 395 if (IS_ERR(user_dev)) 396 return PTR_ERR(user_dev); 397 398 udev->ff_effects_max = user_dev->ff_effects_max; 399 400 /* Ensure name is filled in */ 401 if (!user_dev->name[0]) { 402 retval = -EINVAL; 403 goto exit; 404 } 405 406 kfree(dev->name); 407 dev->name = kstrndup(user_dev->name, UINPUT_MAX_NAME_SIZE, 408 GFP_KERNEL); 409 if (!dev->name) { 410 retval = -ENOMEM; 411 goto exit; 412 } 413 414 dev->id.bustype = user_dev->id.bustype; 415 dev->id.vendor = user_dev->id.vendor; 416 dev->id.product = user_dev->id.product; 417 dev->id.version = user_dev->id.version; 418 419 for (i = 0; i < ABS_CNT; i++) { 420 input_abs_set_max(dev, i, user_dev->absmax[i]); 421 input_abs_set_min(dev, i, user_dev->absmin[i]); 422 input_abs_set_fuzz(dev, i, user_dev->absfuzz[i]); 423 input_abs_set_flat(dev, i, user_dev->absflat[i]); 424 } 425 426 retval = uinput_validate_absbits(dev); 427 if (retval < 0) 428 goto exit; 429 430 udev->state = UIST_SETUP_COMPLETE; 431 retval = count; 432 433 exit: 434 kfree(user_dev); 435 return retval; 436} 437 438static ssize_t uinput_inject_events(struct uinput_device *udev, 439 const char __user *buffer, size_t count) 440{ 441 struct input_event ev; 442 size_t bytes = 0; 443 444 if (count != 0 && count < input_event_size()) 445 return -EINVAL; 446 447 while (bytes + input_event_size() <= count) { 448 /* 449 * Note that even if some events were fetched successfully 450 * we are still going to return EFAULT instead of partial 451 * count to let userspace know that it got it's buffers 452 * all wrong. 453 */ 454 if (input_event_from_user(buffer + bytes, &ev)) 455 return -EFAULT; 456 457 input_event(udev->dev, ev.type, ev.code, ev.value); 458 bytes += input_event_size(); 459 } 460 461 return bytes; 462} 463 464static ssize_t uinput_write(struct file *file, const char __user *buffer, 465 size_t count, loff_t *ppos) 466{ 467 struct uinput_device *udev = file->private_data; 468 int retval; 469 470 if (count == 0) 471 return 0; 472 473 retval = mutex_lock_interruptible(&udev->mutex); 474 if (retval) 475 return retval; 476 477 retval = udev->state == UIST_CREATED ? 478 uinput_inject_events(udev, buffer, count) : 479 uinput_setup_device(udev, buffer, count); 480 481 mutex_unlock(&udev->mutex); 482 483 return retval; 484} 485 486static bool uinput_fetch_next_event(struct uinput_device *udev, 487 struct input_event *event) 488{ 489 bool have_event; 490 491 spin_lock_irq(&udev->dev->event_lock); 492 493 have_event = udev->head != udev->tail; 494 if (have_event) { 495 *event = udev->buff[udev->tail]; 496 udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE; 497 } 498 499 spin_unlock_irq(&udev->dev->event_lock); 500 501 return have_event; 502} 503 504static ssize_t uinput_events_to_user(struct uinput_device *udev, 505 char __user *buffer, size_t count) 506{ 507 struct input_event event; 508 size_t read = 0; 509 510 while (read + input_event_size() <= count && 511 uinput_fetch_next_event(udev, &event)) { 512 513 if (input_event_to_user(buffer + read, &event)) 514 return -EFAULT; 515 516 read += input_event_size(); 517 } 518 519 return read; 520} 521 522static ssize_t uinput_read(struct file *file, char __user *buffer, 523 size_t count, loff_t *ppos) 524{ 525 struct uinput_device *udev = file->private_data; 526 ssize_t retval; 527 528 if (count != 0 && count < input_event_size()) 529 return -EINVAL; 530 531 do { 532 retval = mutex_lock_interruptible(&udev->mutex); 533 if (retval) 534 return retval; 535 536 if (udev->state != UIST_CREATED) 537 retval = -ENODEV; 538 else if (udev->head == udev->tail && 539 (file->f_flags & O_NONBLOCK)) 540 retval = -EAGAIN; 541 else 542 retval = uinput_events_to_user(udev, buffer, count); 543 544 mutex_unlock(&udev->mutex); 545 546 if (retval || count == 0) 547 break; 548 549 if (!(file->f_flags & O_NONBLOCK)) 550 retval = wait_event_interruptible(udev->waitq, 551 udev->head != udev->tail || 552 udev->state != UIST_CREATED); 553 } while (retval == 0); 554 555 return retval; 556} 557 558static unsigned int uinput_poll(struct file *file, poll_table *wait) 559{ 560 struct uinput_device *udev = file->private_data; 561 562 poll_wait(file, &udev->waitq, wait); 563 564 if (udev->head != udev->tail) 565 return POLLIN | POLLRDNORM; 566 567 return 0; 568} 569 570static int uinput_release(struct inode *inode, struct file *file) 571{ 572 struct uinput_device *udev = file->private_data; 573 574 uinput_destroy_device(udev); 575 kfree(udev); 576 577 return 0; 578} 579 580#ifdef CONFIG_COMPAT 581struct uinput_ff_upload_compat { 582 __u32 request_id; 583 __s32 retval; 584 struct ff_effect_compat effect; 585 struct ff_effect_compat old; 586}; 587 588static int uinput_ff_upload_to_user(char __user *buffer, 589 const struct uinput_ff_upload *ff_up) 590{ 591 if (INPUT_COMPAT_TEST) { 592 struct uinput_ff_upload_compat ff_up_compat; 593 594 ff_up_compat.request_id = ff_up->request_id; 595 ff_up_compat.retval = ff_up->retval; 596 /* 597 * It so happens that the pointer that gives us the trouble 598 * is the last field in the structure. Since we don't support 599 * custom waveforms in uinput anyway we can just copy the whole 600 * thing (to the compat size) and ignore the pointer. 601 */ 602 memcpy(&ff_up_compat.effect, &ff_up->effect, 603 sizeof(struct ff_effect_compat)); 604 memcpy(&ff_up_compat.old, &ff_up->old, 605 sizeof(struct ff_effect_compat)); 606 607 if (copy_to_user(buffer, &ff_up_compat, 608 sizeof(struct uinput_ff_upload_compat))) 609 return -EFAULT; 610 } else { 611 if (copy_to_user(buffer, ff_up, 612 sizeof(struct uinput_ff_upload))) 613 return -EFAULT; 614 } 615 616 return 0; 617} 618 619static int uinput_ff_upload_from_user(const char __user *buffer, 620 struct uinput_ff_upload *ff_up) 621{ 622 if (INPUT_COMPAT_TEST) { 623 struct uinput_ff_upload_compat ff_up_compat; 624 625 if (copy_from_user(&ff_up_compat, buffer, 626 sizeof(struct uinput_ff_upload_compat))) 627 return -EFAULT; 628 629 ff_up->request_id = ff_up_compat.request_id; 630 ff_up->retval = ff_up_compat.retval; 631 memcpy(&ff_up->effect, &ff_up_compat.effect, 632 sizeof(struct ff_effect_compat)); 633 memcpy(&ff_up->old, &ff_up_compat.old, 634 sizeof(struct ff_effect_compat)); 635 636 } else { 637 if (copy_from_user(ff_up, buffer, 638 sizeof(struct uinput_ff_upload))) 639 return -EFAULT; 640 } 641 642 return 0; 643} 644 645#else 646 647static int uinput_ff_upload_to_user(char __user *buffer, 648 const struct uinput_ff_upload *ff_up) 649{ 650 if (copy_to_user(buffer, ff_up, sizeof(struct uinput_ff_upload))) 651 return -EFAULT; 652 653 return 0; 654} 655 656static int uinput_ff_upload_from_user(const char __user *buffer, 657 struct uinput_ff_upload *ff_up) 658{ 659 if (copy_from_user(ff_up, buffer, sizeof(struct uinput_ff_upload))) 660 return -EFAULT; 661 662 return 0; 663} 664 665#endif 666 667#define uinput_set_bit(_arg, _bit, _max) \ 668({ \ 669 int __ret = 0; \ 670 if (udev->state == UIST_CREATED) \ 671 __ret = -EINVAL; \ 672 else if ((_arg) > (_max)) \ 673 __ret = -EINVAL; \ 674 else set_bit((_arg), udev->dev->_bit); \ 675 __ret; \ 676}) 677 678static int uinput_str_to_user(void __user *dest, const char *str, 679 unsigned int maxlen) 680{ 681 char __user *p = dest; 682 int len, ret; 683 684 if (!str) 685 return -ENOENT; 686 687 if (maxlen == 0) 688 return -EINVAL; 689 690 len = strlen(str) + 1; 691 if (len > maxlen) 692 len = maxlen; 693 694 ret = copy_to_user(p, str, len); 695 if (ret) 696 return -EFAULT; 697 698 /* force terminating '\0' */ 699 ret = put_user(0, p + len - 1); 700 return ret ? -EFAULT : len; 701} 702 703static long uinput_ioctl_handler(struct file *file, unsigned int cmd, 704 unsigned long arg, void __user *p) 705{ 706 int retval; 707 struct uinput_device *udev = file->private_data; 708 struct uinput_ff_upload ff_up; 709 struct uinput_ff_erase ff_erase; 710 struct uinput_request *req; 711 char *phys; 712 const char *name; 713 unsigned int size; 714 715 retval = mutex_lock_interruptible(&udev->mutex); 716 if (retval) 717 return retval; 718 719 if (!udev->dev) { 720 retval = uinput_allocate_device(udev); 721 if (retval) 722 goto out; 723 } 724 725 switch (cmd) { 726 case UI_GET_VERSION: 727 if (put_user(UINPUT_VERSION, 728 (unsigned int __user *)p)) 729 retval = -EFAULT; 730 goto out; 731 732 case UI_DEV_CREATE: 733 retval = uinput_create_device(udev); 734 goto out; 735 736 case UI_DEV_DESTROY: 737 uinput_destroy_device(udev); 738 goto out; 739 740 case UI_SET_EVBIT: 741 retval = uinput_set_bit(arg, evbit, EV_MAX); 742 goto out; 743 744 case UI_SET_KEYBIT: 745 retval = uinput_set_bit(arg, keybit, KEY_MAX); 746 goto out; 747 748 case UI_SET_RELBIT: 749 retval = uinput_set_bit(arg, relbit, REL_MAX); 750 goto out; 751 752 case UI_SET_ABSBIT: 753 retval = uinput_set_bit(arg, absbit, ABS_MAX); 754 goto out; 755 756 case UI_SET_MSCBIT: 757 retval = uinput_set_bit(arg, mscbit, MSC_MAX); 758 goto out; 759 760 case UI_SET_LEDBIT: 761 retval = uinput_set_bit(arg, ledbit, LED_MAX); 762 goto out; 763 764 case UI_SET_SNDBIT: 765 retval = uinput_set_bit(arg, sndbit, SND_MAX); 766 goto out; 767 768 case UI_SET_FFBIT: 769 retval = uinput_set_bit(arg, ffbit, FF_MAX); 770 goto out; 771 772 case UI_SET_SWBIT: 773 retval = uinput_set_bit(arg, swbit, SW_MAX); 774 goto out; 775 776 case UI_SET_PROPBIT: 777 retval = uinput_set_bit(arg, propbit, INPUT_PROP_MAX); 778 goto out; 779 780 case UI_SET_PHYS: 781 if (udev->state == UIST_CREATED) { 782 retval = -EINVAL; 783 goto out; 784 } 785 786 phys = strndup_user(p, 1024); 787 if (IS_ERR(phys)) { 788 retval = PTR_ERR(phys); 789 goto out; 790 } 791 792 kfree(udev->dev->phys); 793 udev->dev->phys = phys; 794 goto out; 795 796 case UI_BEGIN_FF_UPLOAD: 797 retval = uinput_ff_upload_from_user(p, &ff_up); 798 if (retval) 799 goto out; 800 801 req = uinput_request_find(udev, ff_up.request_id); 802 if (!req || req->code != UI_FF_UPLOAD || 803 !req->u.upload.effect) { 804 retval = -EINVAL; 805 goto out; 806 } 807 808 ff_up.retval = 0; 809 ff_up.effect = *req->u.upload.effect; 810 if (req->u.upload.old) 811 ff_up.old = *req->u.upload.old; 812 else 813 memset(&ff_up.old, 0, sizeof(struct ff_effect)); 814 815 retval = uinput_ff_upload_to_user(p, &ff_up); 816 goto out; 817 818 case UI_BEGIN_FF_ERASE: 819 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) { 820 retval = -EFAULT; 821 goto out; 822 } 823 824 req = uinput_request_find(udev, ff_erase.request_id); 825 if (!req || req->code != UI_FF_ERASE) { 826 retval = -EINVAL; 827 goto out; 828 } 829 830 ff_erase.retval = 0; 831 ff_erase.effect_id = req->u.effect_id; 832 if (copy_to_user(p, &ff_erase, sizeof(ff_erase))) { 833 retval = -EFAULT; 834 goto out; 835 } 836 837 goto out; 838 839 case UI_END_FF_UPLOAD: 840 retval = uinput_ff_upload_from_user(p, &ff_up); 841 if (retval) 842 goto out; 843 844 req = uinput_request_find(udev, ff_up.request_id); 845 if (!req || req->code != UI_FF_UPLOAD || 846 !req->u.upload.effect) { 847 retval = -EINVAL; 848 goto out; 849 } 850 851 req->retval = ff_up.retval; 852 uinput_request_done(udev, req); 853 goto out; 854 855 case UI_END_FF_ERASE: 856 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) { 857 retval = -EFAULT; 858 goto out; 859 } 860 861 req = uinput_request_find(udev, ff_erase.request_id); 862 if (!req || req->code != UI_FF_ERASE) { 863 retval = -EINVAL; 864 goto out; 865 } 866 867 req->retval = ff_erase.retval; 868 uinput_request_done(udev, req); 869 goto out; 870 } 871 872 size = _IOC_SIZE(cmd); 873 874 /* Now check variable-length commands */ 875 switch (cmd & ~IOCSIZE_MASK) { 876 case UI_GET_SYSNAME(0): 877 if (udev->state != UIST_CREATED) { 878 retval = -ENOENT; 879 goto out; 880 } 881 name = dev_name(&udev->dev->dev); 882 retval = uinput_str_to_user(p, name, size); 883 goto out; 884 } 885 886 retval = -EINVAL; 887 out: 888 mutex_unlock(&udev->mutex); 889 return retval; 890} 891 892static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 893{ 894 return uinput_ioctl_handler(file, cmd, arg, (void __user *)arg); 895} 896 897#ifdef CONFIG_COMPAT 898static long uinput_compat_ioctl(struct file *file, 899 unsigned int cmd, unsigned long arg) 900{ 901 return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg)); 902} 903#endif 904 905static const struct file_operations uinput_fops = { 906 .owner = THIS_MODULE, 907 .open = uinput_open, 908 .release = uinput_release, 909 .read = uinput_read, 910 .write = uinput_write, 911 .poll = uinput_poll, 912 .unlocked_ioctl = uinput_ioctl, 913#ifdef CONFIG_COMPAT 914 .compat_ioctl = uinput_compat_ioctl, 915#endif 916 .llseek = no_llseek, 917}; 918 919static struct miscdevice uinput_misc = { 920 .fops = &uinput_fops, 921 .minor = UINPUT_MINOR, 922 .name = UINPUT_NAME, 923}; 924MODULE_ALIAS_MISCDEV(UINPUT_MINOR); 925MODULE_ALIAS("devname:" UINPUT_NAME); 926 927static int __init uinput_init(void) 928{ 929 return misc_register(&uinput_misc); 930} 931 932static void __exit uinput_exit(void) 933{ 934 misc_deregister(&uinput_misc); 935} 936 937MODULE_AUTHOR("Aristeu Sergio Rozanski Filho"); 938MODULE_DESCRIPTION("User level driver support for input subsystem"); 939MODULE_LICENSE("GPL"); 940MODULE_VERSION("0.3"); 941 942module_init(uinput_init); 943module_exit(uinput_exit); 944