1 /* 2 * Event char devices, giving access to raw input device events. 3 * 4 * Copyright (c) 1999-2002 Vojtech Pavlik 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 as published by 8 * the Free Software Foundation. 9 */ 10 11 #define EVDEV_MINOR_BASE 64 12 #define EVDEV_MINORS 32 13 #define EVDEV_BUFFER_SIZE 64 14 15 #include <linux/poll.h> 16 #include <linux/slab.h> 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/input.h> 20 #include <linux/major.h> 21 #include <linux/device.h> 22 #include <linux/compat.h> 23 24 struct evdev { 25 int exist; 26 int open; 27 int minor; 28 char name[16]; 29 struct input_handle handle; 30 wait_queue_head_t wait; 31 struct evdev_client *grab; 32 struct list_head client_list; 33 spinlock_t client_lock; /* protects client_list */ 34 struct mutex mutex; 35 struct device dev; 36 }; 37 38 struct evdev_client { 39 struct input_event buffer[EVDEV_BUFFER_SIZE]; 40 int head; 41 int tail; 42 spinlock_t buffer_lock; /* protects access to buffer, head and tail */ 43 struct fasync_struct *fasync; 44 struct evdev *evdev; 45 struct list_head node; 46 }; 47 48 static struct evdev *evdev_table[EVDEV_MINORS]; 49 static DEFINE_MUTEX(evdev_table_mutex); 50 51 static void evdev_pass_event(struct evdev_client *client, 52 struct input_event *event) 53 { 54 /* 55 * Interrupts are disabled, just acquire the lock 56 */ 57 spin_lock(&client->buffer_lock); 58 client->buffer[client->head++] = *event; 59 client->head &= EVDEV_BUFFER_SIZE - 1; 60 spin_unlock(&client->buffer_lock); 61 62 kill_fasync(&client->fasync, SIGIO, POLL_IN); 63 } 64 65 /* 66 * Pass incoming event to all connected clients. 67 */ 68 static void evdev_event(struct input_handle *handle, 69 unsigned int type, unsigned int code, int value) 70 { 71 struct evdev *evdev = handle->private; 72 struct evdev_client *client; 73 struct input_event event; 74 75 do_gettimeofday(&event.time); 76 event.type = type; 77 event.code = code; 78 event.value = value; 79 80 rcu_read_lock(); 81 82 client = rcu_dereference(evdev->grab); 83 if (client) 84 evdev_pass_event(client, &event); 85 else 86 list_for_each_entry_rcu(client, &evdev->client_list, node) 87 evdev_pass_event(client, &event); 88 89 rcu_read_unlock(); 90 91 wake_up_interruptible(&evdev->wait); 92 } 93 94 static int evdev_fasync(int fd, struct file *file, int on) 95 { 96 struct evdev_client *client = file->private_data; 97 int retval; 98 99 retval = fasync_helper(fd, file, on, &client->fasync); 100 101 return retval < 0 ? retval : 0; 102 } 103 104 static int evdev_flush(struct file *file, fl_owner_t id) 105 { 106 struct evdev_client *client = file->private_data; 107 struct evdev *evdev = client->evdev; 108 int retval; 109 110 retval = mutex_lock_interruptible(&evdev->mutex); 111 if (retval) 112 return retval; 113 114 if (!evdev->exist) 115 retval = -ENODEV; 116 else 117 retval = input_flush_device(&evdev->handle, file); 118 119 mutex_unlock(&evdev->mutex); 120 return retval; 121 } 122 123 static void evdev_free(struct device *dev) 124 { 125 struct evdev *evdev = container_of(dev, struct evdev, dev); 126 127 input_put_device(evdev->handle.dev); 128 kfree(evdev); 129 } 130 131 /* 132 * Grabs an event device (along with underlying input device). 133 * This function is called with evdev->mutex taken. 134 */ 135 static int evdev_grab(struct evdev *evdev, struct evdev_client *client) 136 { 137 int error; 138 139 if (evdev->grab) 140 return -EBUSY; 141 142 error = input_grab_device(&evdev->handle); 143 if (error) 144 return error; 145 146 rcu_assign_pointer(evdev->grab, client); 147 synchronize_rcu(); 148 149 return 0; 150 } 151 152 static int evdev_ungrab(struct evdev *evdev, struct evdev_client *client) 153 { 154 if (evdev->grab != client) 155 return -EINVAL; 156 157 rcu_assign_pointer(evdev->grab, NULL); 158 synchronize_rcu(); 159 input_release_device(&evdev->handle); 160 161 return 0; 162 } 163 164 static void evdev_attach_client(struct evdev *evdev, 165 struct evdev_client *client) 166 { 167 spin_lock(&evdev->client_lock); 168 list_add_tail_rcu(&client->node, &evdev->client_list); 169 spin_unlock(&evdev->client_lock); 170 synchronize_rcu(); 171 } 172 173 static void evdev_detach_client(struct evdev *evdev, 174 struct evdev_client *client) 175 { 176 spin_lock(&evdev->client_lock); 177 list_del_rcu(&client->node); 178 spin_unlock(&evdev->client_lock); 179 synchronize_rcu(); 180 } 181 182 static int evdev_open_device(struct evdev *evdev) 183 { 184 int retval; 185 186 retval = mutex_lock_interruptible(&evdev->mutex); 187 if (retval) 188 return retval; 189 190 if (!evdev->exist) 191 retval = -ENODEV; 192 else if (!evdev->open++) { 193 retval = input_open_device(&evdev->handle); 194 if (retval) 195 evdev->open--; 196 } 197 198 mutex_unlock(&evdev->mutex); 199 return retval; 200 } 201 202 static void evdev_close_device(struct evdev *evdev) 203 { 204 mutex_lock(&evdev->mutex); 205 206 if (evdev->exist && !--evdev->open) 207 input_close_device(&evdev->handle); 208 209 mutex_unlock(&evdev->mutex); 210 } 211 212 /* 213 * Wake up users waiting for IO so they can disconnect from 214 * dead device. 215 */ 216 static void evdev_hangup(struct evdev *evdev) 217 { 218 struct evdev_client *client; 219 220 spin_lock(&evdev->client_lock); 221 list_for_each_entry(client, &evdev->client_list, node) 222 kill_fasync(&client->fasync, SIGIO, POLL_HUP); 223 spin_unlock(&evdev->client_lock); 224 225 wake_up_interruptible(&evdev->wait); 226 } 227 228 static int evdev_release(struct inode *inode, struct file *file) 229 { 230 struct evdev_client *client = file->private_data; 231 struct evdev *evdev = client->evdev; 232 233 mutex_lock(&evdev->mutex); 234 if (evdev->grab == client) 235 evdev_ungrab(evdev, client); 236 mutex_unlock(&evdev->mutex); 237 238 evdev_fasync(-1, file, 0); 239 evdev_detach_client(evdev, client); 240 kfree(client); 241 242 evdev_close_device(evdev); 243 put_device(&evdev->dev); 244 245 return 0; 246 } 247 248 static int evdev_open(struct inode *inode, struct file *file) 249 { 250 struct evdev *evdev; 251 struct evdev_client *client; 252 int i = iminor(inode) - EVDEV_MINOR_BASE; 253 int error; 254 255 if (i >= EVDEV_MINORS) 256 return -ENODEV; 257 258 error = mutex_lock_interruptible(&evdev_table_mutex); 259 if (error) 260 return error; 261 evdev = evdev_table[i]; 262 if (evdev) 263 get_device(&evdev->dev); 264 mutex_unlock(&evdev_table_mutex); 265 266 if (!evdev) 267 return -ENODEV; 268 269 client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL); 270 if (!client) { 271 error = -ENOMEM; 272 goto err_put_evdev; 273 } 274 275 spin_lock_init(&client->buffer_lock); 276 client->evdev = evdev; 277 evdev_attach_client(evdev, client); 278 279 error = evdev_open_device(evdev); 280 if (error) 281 goto err_free_client; 282 283 file->private_data = client; 284 return 0; 285 286 err_free_client: 287 evdev_detach_client(evdev, client); 288 kfree(client); 289 err_put_evdev: 290 put_device(&evdev->dev); 291 return error; 292 } 293 294 #ifdef CONFIG_COMPAT 295 296 struct input_event_compat { 297 struct compat_timeval time; 298 __u16 type; 299 __u16 code; 300 __s32 value; 301 }; 302 303 struct ff_periodic_effect_compat { 304 __u16 waveform; 305 __u16 period; 306 __s16 magnitude; 307 __s16 offset; 308 __u16 phase; 309 310 struct ff_envelope envelope; 311 312 __u32 custom_len; 313 compat_uptr_t custom_data; 314 }; 315 316 struct ff_effect_compat { 317 __u16 type; 318 __s16 id; 319 __u16 direction; 320 struct ff_trigger trigger; 321 struct ff_replay replay; 322 323 union { 324 struct ff_constant_effect constant; 325 struct ff_ramp_effect ramp; 326 struct ff_periodic_effect_compat periodic; 327 struct ff_condition_effect condition[2]; /* One for each axis */ 328 struct ff_rumble_effect rumble; 329 } u; 330 }; 331 332 /* Note to the author of this code: did it ever occur to 333 you why the ifdefs are needed? Think about it again. -AK */ 334 #ifdef CONFIG_X86_64 335 # define COMPAT_TEST is_compat_task() 336 #elif defined(CONFIG_IA64) 337 # define COMPAT_TEST IS_IA32_PROCESS(task_pt_regs(current)) 338 #elif defined(CONFIG_S390) 339 # define COMPAT_TEST test_thread_flag(TIF_31BIT) 340 #elif defined(CONFIG_MIPS) 341 # define COMPAT_TEST test_thread_flag(TIF_32BIT_ADDR) 342 #else 343 # define COMPAT_TEST test_thread_flag(TIF_32BIT) 344 #endif 345 346 static inline size_t evdev_event_size(void) 347 { 348 return COMPAT_TEST ? 349 sizeof(struct input_event_compat) : sizeof(struct input_event); 350 } 351 352 static int evdev_event_from_user(const char __user *buffer, 353 struct input_event *event) 354 { 355 if (COMPAT_TEST) { 356 struct input_event_compat compat_event; 357 358 if (copy_from_user(&compat_event, buffer, 359 sizeof(struct input_event_compat))) 360 return -EFAULT; 361 362 event->time.tv_sec = compat_event.time.tv_sec; 363 event->time.tv_usec = compat_event.time.tv_usec; 364 event->type = compat_event.type; 365 event->code = compat_event.code; 366 event->value = compat_event.value; 367 368 } else { 369 if (copy_from_user(event, buffer, sizeof(struct input_event))) 370 return -EFAULT; 371 } 372 373 return 0; 374 } 375 376 static int evdev_event_to_user(char __user *buffer, 377 const struct input_event *event) 378 { 379 if (COMPAT_TEST) { 380 struct input_event_compat compat_event; 381 382 compat_event.time.tv_sec = event->time.tv_sec; 383 compat_event.time.tv_usec = event->time.tv_usec; 384 compat_event.type = event->type; 385 compat_event.code = event->code; 386 compat_event.value = event->value; 387 388 if (copy_to_user(buffer, &compat_event, 389 sizeof(struct input_event_compat))) 390 return -EFAULT; 391 392 } else { 393 if (copy_to_user(buffer, event, sizeof(struct input_event))) 394 return -EFAULT; 395 } 396 397 return 0; 398 } 399 400 static int evdev_ff_effect_from_user(const char __user *buffer, size_t size, 401 struct ff_effect *effect) 402 { 403 if (COMPAT_TEST) { 404 struct ff_effect_compat *compat_effect; 405 406 if (size != sizeof(struct ff_effect_compat)) 407 return -EINVAL; 408 409 /* 410 * It so happens that the pointer which needs to be changed 411 * is the last field in the structure, so we can copy the 412 * whole thing and replace just the pointer. 413 */ 414 415 compat_effect = (struct ff_effect_compat *)effect; 416 417 if (copy_from_user(compat_effect, buffer, 418 sizeof(struct ff_effect_compat))) 419 return -EFAULT; 420 421 if (compat_effect->type == FF_PERIODIC && 422 compat_effect->u.periodic.waveform == FF_CUSTOM) 423 effect->u.periodic.custom_data = 424 compat_ptr(compat_effect->u.periodic.custom_data); 425 } else { 426 if (size != sizeof(struct ff_effect)) 427 return -EINVAL; 428 429 if (copy_from_user(effect, buffer, sizeof(struct ff_effect))) 430 return -EFAULT; 431 } 432 433 return 0; 434 } 435 436 #else 437 438 static inline size_t evdev_event_size(void) 439 { 440 return sizeof(struct input_event); 441 } 442 443 static int evdev_event_from_user(const char __user *buffer, 444 struct input_event *event) 445 { 446 if (copy_from_user(event, buffer, sizeof(struct input_event))) 447 return -EFAULT; 448 449 return 0; 450 } 451 452 static int evdev_event_to_user(char __user *buffer, 453 const struct input_event *event) 454 { 455 if (copy_to_user(buffer, event, sizeof(struct input_event))) 456 return -EFAULT; 457 458 return 0; 459 } 460 461 static int evdev_ff_effect_from_user(const char __user *buffer, size_t size, 462 struct ff_effect *effect) 463 { 464 if (size != sizeof(struct ff_effect)) 465 return -EINVAL; 466 467 if (copy_from_user(effect, buffer, sizeof(struct ff_effect))) 468 return -EFAULT; 469 470 return 0; 471 } 472 473 #endif /* CONFIG_COMPAT */ 474 475 static ssize_t evdev_write(struct file *file, const char __user *buffer, 476 size_t count, loff_t *ppos) 477 { 478 struct evdev_client *client = file->private_data; 479 struct evdev *evdev = client->evdev; 480 struct input_event event; 481 int retval; 482 483 retval = mutex_lock_interruptible(&evdev->mutex); 484 if (retval) 485 return retval; 486 487 if (!evdev->exist) { 488 retval = -ENODEV; 489 goto out; 490 } 491 492 while (retval < count) { 493 494 if (evdev_event_from_user(buffer + retval, &event)) { 495 retval = -EFAULT; 496 goto out; 497 } 498 499 input_inject_event(&evdev->handle, 500 event.type, event.code, event.value); 501 retval += evdev_event_size(); 502 } 503 504 out: 505 mutex_unlock(&evdev->mutex); 506 return retval; 507 } 508 509 static int evdev_fetch_next_event(struct evdev_client *client, 510 struct input_event *event) 511 { 512 int have_event; 513 514 spin_lock_irq(&client->buffer_lock); 515 516 have_event = client->head != client->tail; 517 if (have_event) { 518 *event = client->buffer[client->tail++]; 519 client->tail &= EVDEV_BUFFER_SIZE - 1; 520 } 521 522 spin_unlock_irq(&client->buffer_lock); 523 524 return have_event; 525 } 526 527 static ssize_t evdev_read(struct file *file, char __user *buffer, 528 size_t count, loff_t *ppos) 529 { 530 struct evdev_client *client = file->private_data; 531 struct evdev *evdev = client->evdev; 532 struct input_event event; 533 int retval; 534 535 if (count < evdev_event_size()) 536 return -EINVAL; 537 538 if (client->head == client->tail && evdev->exist && 539 (file->f_flags & O_NONBLOCK)) 540 return -EAGAIN; 541 542 retval = wait_event_interruptible(evdev->wait, 543 client->head != client->tail || !evdev->exist); 544 if (retval) 545 return retval; 546 547 if (!evdev->exist) 548 return -ENODEV; 549 550 while (retval + evdev_event_size() <= count && 551 evdev_fetch_next_event(client, &event)) { 552 553 if (evdev_event_to_user(buffer + retval, &event)) 554 return -EFAULT; 555 556 retval += evdev_event_size(); 557 } 558 559 return retval; 560 } 561 562 /* No kernel lock - fine */ 563 static unsigned int evdev_poll(struct file *file, poll_table *wait) 564 { 565 struct evdev_client *client = file->private_data; 566 struct evdev *evdev = client->evdev; 567 568 poll_wait(file, &evdev->wait, wait); 569 return ((client->head == client->tail) ? 0 : (POLLIN | POLLRDNORM)) | 570 (evdev->exist ? 0 : (POLLHUP | POLLERR)); 571 } 572 573 #ifdef CONFIG_COMPAT 574 575 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8) 576 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1) 577 578 #ifdef __BIG_ENDIAN 579 static int bits_to_user(unsigned long *bits, unsigned int maxbit, 580 unsigned int maxlen, void __user *p, int compat) 581 { 582 int len, i; 583 584 if (compat) { 585 len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t); 586 if (len > maxlen) 587 len = maxlen; 588 589 for (i = 0; i < len / sizeof(compat_long_t); i++) 590 if (copy_to_user((compat_long_t __user *) p + i, 591 (compat_long_t *) bits + 592 i + 1 - ((i % 2) << 1), 593 sizeof(compat_long_t))) 594 return -EFAULT; 595 } else { 596 len = BITS_TO_LONGS(maxbit) * sizeof(long); 597 if (len > maxlen) 598 len = maxlen; 599 600 if (copy_to_user(p, bits, len)) 601 return -EFAULT; 602 } 603 604 return len; 605 } 606 #else 607 static int bits_to_user(unsigned long *bits, unsigned int maxbit, 608 unsigned int maxlen, void __user *p, int compat) 609 { 610 int len = compat ? 611 BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t) : 612 BITS_TO_LONGS(maxbit) * sizeof(long); 613 614 if (len > maxlen) 615 len = maxlen; 616 617 return copy_to_user(p, bits, len) ? -EFAULT : len; 618 } 619 #endif /* __BIG_ENDIAN */ 620 621 #else 622 623 static int bits_to_user(unsigned long *bits, unsigned int maxbit, 624 unsigned int maxlen, void __user *p, int compat) 625 { 626 int len = BITS_TO_LONGS(maxbit) * sizeof(long); 627 628 if (len > maxlen) 629 len = maxlen; 630 631 return copy_to_user(p, bits, len) ? -EFAULT : len; 632 } 633 634 #endif /* CONFIG_COMPAT */ 635 636 static int str_to_user(const char *str, unsigned int maxlen, void __user *p) 637 { 638 int len; 639 640 if (!str) 641 return -ENOENT; 642 643 len = strlen(str) + 1; 644 if (len > maxlen) 645 len = maxlen; 646 647 return copy_to_user(p, str, len) ? -EFAULT : len; 648 } 649 650 static long evdev_do_ioctl(struct file *file, unsigned int cmd, 651 void __user *p, int compat_mode) 652 { 653 struct evdev_client *client = file->private_data; 654 struct evdev *evdev = client->evdev; 655 struct input_dev *dev = evdev->handle.dev; 656 struct input_absinfo abs; 657 struct ff_effect effect; 658 int __user *ip = (int __user *)p; 659 int i, t, u, v; 660 int error; 661 662 switch (cmd) { 663 664 case EVIOCGVERSION: 665 return put_user(EV_VERSION, ip); 666 667 case EVIOCGID: 668 if (copy_to_user(p, &dev->id, sizeof(struct input_id))) 669 return -EFAULT; 670 return 0; 671 672 case EVIOCGREP: 673 if (!test_bit(EV_REP, dev->evbit)) 674 return -ENOSYS; 675 if (put_user(dev->rep[REP_DELAY], ip)) 676 return -EFAULT; 677 if (put_user(dev->rep[REP_PERIOD], ip + 1)) 678 return -EFAULT; 679 return 0; 680 681 case EVIOCSREP: 682 if (!test_bit(EV_REP, dev->evbit)) 683 return -ENOSYS; 684 if (get_user(u, ip)) 685 return -EFAULT; 686 if (get_user(v, ip + 1)) 687 return -EFAULT; 688 689 input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u); 690 input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v); 691 692 return 0; 693 694 case EVIOCGKEYCODE: 695 if (get_user(t, ip)) 696 return -EFAULT; 697 698 error = input_get_keycode(dev, t, &v); 699 if (error) 700 return error; 701 702 if (put_user(v, ip + 1)) 703 return -EFAULT; 704 705 return 0; 706 707 case EVIOCSKEYCODE: 708 if (get_user(t, ip) || get_user(v, ip + 1)) 709 return -EFAULT; 710 711 return input_set_keycode(dev, t, v); 712 713 case EVIOCRMFF: 714 return input_ff_erase(dev, (int)(unsigned long) p, file); 715 716 case EVIOCGEFFECTS: 717 i = test_bit(EV_FF, dev->evbit) ? 718 dev->ff->max_effects : 0; 719 if (put_user(i, ip)) 720 return -EFAULT; 721 return 0; 722 723 case EVIOCGRAB: 724 if (p) 725 return evdev_grab(evdev, client); 726 else 727 return evdev_ungrab(evdev, client); 728 729 default: 730 731 if (_IOC_TYPE(cmd) != 'E') 732 return -EINVAL; 733 734 if (_IOC_DIR(cmd) == _IOC_READ) { 735 736 if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0))) { 737 738 unsigned long *bits; 739 int len; 740 741 switch (_IOC_NR(cmd) & EV_MAX) { 742 743 case 0: bits = dev->evbit; len = EV_MAX; break; 744 case EV_KEY: bits = dev->keybit; len = KEY_MAX; break; 745 case EV_REL: bits = dev->relbit; len = REL_MAX; break; 746 case EV_ABS: bits = dev->absbit; len = ABS_MAX; break; 747 case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break; 748 case EV_LED: bits = dev->ledbit; len = LED_MAX; break; 749 case EV_SND: bits = dev->sndbit; len = SND_MAX; break; 750 case EV_FF: bits = dev->ffbit; len = FF_MAX; break; 751 case EV_SW: bits = dev->swbit; len = SW_MAX; break; 752 default: return -EINVAL; 753 } 754 return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode); 755 } 756 757 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) 758 return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd), 759 p, compat_mode); 760 761 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) 762 return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd), 763 p, compat_mode); 764 765 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) 766 return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd), 767 p, compat_mode); 768 769 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0))) 770 return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd), 771 p, compat_mode); 772 773 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) 774 return str_to_user(dev->name, _IOC_SIZE(cmd), p); 775 776 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) 777 return str_to_user(dev->phys, _IOC_SIZE(cmd), p); 778 779 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) 780 return str_to_user(dev->uniq, _IOC_SIZE(cmd), p); 781 782 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) { 783 784 t = _IOC_NR(cmd) & ABS_MAX; 785 786 abs.value = dev->abs[t]; 787 abs.minimum = dev->absmin[t]; 788 abs.maximum = dev->absmax[t]; 789 abs.fuzz = dev->absfuzz[t]; 790 abs.flat = dev->absflat[t]; 791 792 if (copy_to_user(p, &abs, sizeof(struct input_absinfo))) 793 return -EFAULT; 794 795 return 0; 796 } 797 798 } 799 800 if (_IOC_DIR(cmd) == _IOC_WRITE) { 801 802 if (_IOC_NR(cmd) == _IOC_NR(EVIOCSFF)) { 803 804 if (evdev_ff_effect_from_user(p, _IOC_SIZE(cmd), &effect)) 805 return -EFAULT; 806 807 error = input_ff_upload(dev, &effect, file); 808 809 if (put_user(effect.id, &(((struct ff_effect __user *)p)->id))) 810 return -EFAULT; 811 812 return error; 813 } 814 815 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) { 816 817 t = _IOC_NR(cmd) & ABS_MAX; 818 819 if (copy_from_user(&abs, p, 820 sizeof(struct input_absinfo))) 821 return -EFAULT; 822 823 /* 824 * Take event lock to ensure that we are not 825 * changing device parameters in the middle 826 * of event. 827 */ 828 spin_lock_irq(&dev->event_lock); 829 830 dev->abs[t] = abs.value; 831 dev->absmin[t] = abs.minimum; 832 dev->absmax[t] = abs.maximum; 833 dev->absfuzz[t] = abs.fuzz; 834 dev->absflat[t] = abs.flat; 835 836 spin_unlock_irq(&dev->event_lock); 837 838 return 0; 839 } 840 } 841 } 842 return -EINVAL; 843 } 844 845 static long evdev_ioctl_handler(struct file *file, unsigned int cmd, 846 void __user *p, int compat_mode) 847 { 848 struct evdev_client *client = file->private_data; 849 struct evdev *evdev = client->evdev; 850 int retval; 851 852 retval = mutex_lock_interruptible(&evdev->mutex); 853 if (retval) 854 return retval; 855 856 if (!evdev->exist) { 857 retval = -ENODEV; 858 goto out; 859 } 860 861 retval = evdev_do_ioctl(file, cmd, p, compat_mode); 862 863 out: 864 mutex_unlock(&evdev->mutex); 865 return retval; 866 } 867 868 static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 869 { 870 return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0); 871 } 872 873 #ifdef CONFIG_COMPAT 874 static long evdev_ioctl_compat(struct file *file, 875 unsigned int cmd, unsigned long arg) 876 { 877 return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1); 878 } 879 #endif 880 881 static const struct file_operations evdev_fops = { 882 .owner = THIS_MODULE, 883 .read = evdev_read, 884 .write = evdev_write, 885 .poll = evdev_poll, 886 .open = evdev_open, 887 .release = evdev_release, 888 .unlocked_ioctl = evdev_ioctl, 889 #ifdef CONFIG_COMPAT 890 .compat_ioctl = evdev_ioctl_compat, 891 #endif 892 .fasync = evdev_fasync, 893 .flush = evdev_flush 894 }; 895 896 static int evdev_install_chrdev(struct evdev *evdev) 897 { 898 /* 899 * No need to do any locking here as calls to connect and 900 * disconnect are serialized by the input core 901 */ 902 evdev_table[evdev->minor] = evdev; 903 return 0; 904 } 905 906 static void evdev_remove_chrdev(struct evdev *evdev) 907 { 908 /* 909 * Lock evdev table to prevent race with evdev_open() 910 */ 911 mutex_lock(&evdev_table_mutex); 912 evdev_table[evdev->minor] = NULL; 913 mutex_unlock(&evdev_table_mutex); 914 } 915 916 /* 917 * Mark device non-existent. This disables writes, ioctls and 918 * prevents new users from opening the device. Already posted 919 * blocking reads will stay, however new ones will fail. 920 */ 921 static void evdev_mark_dead(struct evdev *evdev) 922 { 923 mutex_lock(&evdev->mutex); 924 evdev->exist = 0; 925 mutex_unlock(&evdev->mutex); 926 } 927 928 static void evdev_cleanup(struct evdev *evdev) 929 { 930 struct input_handle *handle = &evdev->handle; 931 932 evdev_mark_dead(evdev); 933 evdev_hangup(evdev); 934 evdev_remove_chrdev(evdev); 935 936 /* evdev is marked dead so no one else accesses evdev->open */ 937 if (evdev->open) { 938 input_flush_device(handle, NULL); 939 input_close_device(handle); 940 } 941 } 942 943 /* 944 * Create new evdev device. Note that input core serializes calls 945 * to connect and disconnect so we don't need to lock evdev_table here. 946 */ 947 static int evdev_connect(struct input_handler *handler, struct input_dev *dev, 948 const struct input_device_id *id) 949 { 950 struct evdev *evdev; 951 int minor; 952 int error; 953 954 for (minor = 0; minor < EVDEV_MINORS; minor++) 955 if (!evdev_table[minor]) 956 break; 957 958 if (minor == EVDEV_MINORS) { 959 printk(KERN_ERR "evdev: no more free evdev devices\n"); 960 return -ENFILE; 961 } 962 963 evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 964 if (!evdev) 965 return -ENOMEM; 966 967 INIT_LIST_HEAD(&evdev->client_list); 968 spin_lock_init(&evdev->client_lock); 969 mutex_init(&evdev->mutex); 970 init_waitqueue_head(&evdev->wait); 971 972 snprintf(evdev->name, sizeof(evdev->name), "event%d", minor); 973 evdev->exist = 1; 974 evdev->minor = minor; 975 976 evdev->handle.dev = input_get_device(dev); 977 evdev->handle.name = evdev->name; 978 evdev->handle.handler = handler; 979 evdev->handle.private = evdev; 980 981 strlcpy(evdev->dev.bus_id, evdev->name, sizeof(evdev->dev.bus_id)); 982 evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor); 983 evdev->dev.class = &input_class; 984 evdev->dev.parent = &dev->dev; 985 evdev->dev.release = evdev_free; 986 device_initialize(&evdev->dev); 987 988 error = input_register_handle(&evdev->handle); 989 if (error) 990 goto err_free_evdev; 991 992 error = evdev_install_chrdev(evdev); 993 if (error) 994 goto err_unregister_handle; 995 996 error = device_add(&evdev->dev); 997 if (error) 998 goto err_cleanup_evdev; 999 1000 return 0; 1001 1002 err_cleanup_evdev: 1003 evdev_cleanup(evdev); 1004 err_unregister_handle: 1005 input_unregister_handle(&evdev->handle); 1006 err_free_evdev: 1007 put_device(&evdev->dev); 1008 return error; 1009 } 1010 1011 static void evdev_disconnect(struct input_handle *handle) 1012 { 1013 struct evdev *evdev = handle->private; 1014 1015 device_del(&evdev->dev); 1016 evdev_cleanup(evdev); 1017 input_unregister_handle(handle); 1018 put_device(&evdev->dev); 1019 } 1020 1021 static const struct input_device_id evdev_ids[] = { 1022 { .driver_info = 1 }, /* Matches all devices */ 1023 { }, /* Terminating zero entry */ 1024 }; 1025 1026 MODULE_DEVICE_TABLE(input, evdev_ids); 1027 1028 static struct input_handler evdev_handler = { 1029 .event = evdev_event, 1030 .connect = evdev_connect, 1031 .disconnect = evdev_disconnect, 1032 .fops = &evdev_fops, 1033 .minor = EVDEV_MINOR_BASE, 1034 .name = "evdev", 1035 .id_table = evdev_ids, 1036 }; 1037 1038 static int __init evdev_init(void) 1039 { 1040 return input_register_handler(&evdev_handler); 1041 } 1042 1043 static void __exit evdev_exit(void) 1044 { 1045 input_unregister_handler(&evdev_handler); 1046 } 1047 1048 module_init(evdev_init); 1049 module_exit(evdev_exit); 1050 1051 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 1052 MODULE_DESCRIPTION("Input driver event char devices"); 1053 MODULE_LICENSE("GPL"); 1054