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_detach_client(evdev, client); 239 kfree(client); 240 241 evdev_close_device(evdev); 242 put_device(&evdev->dev); 243 244 return 0; 245 } 246 247 static int evdev_open(struct inode *inode, struct file *file) 248 { 249 struct evdev *evdev; 250 struct evdev_client *client; 251 int i = iminor(inode) - EVDEV_MINOR_BASE; 252 int error; 253 254 if (i >= EVDEV_MINORS) 255 return -ENODEV; 256 257 error = mutex_lock_interruptible(&evdev_table_mutex); 258 if (error) 259 return error; 260 evdev = evdev_table[i]; 261 if (evdev) 262 get_device(&evdev->dev); 263 mutex_unlock(&evdev_table_mutex); 264 265 if (!evdev) 266 return -ENODEV; 267 268 client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL); 269 if (!client) { 270 error = -ENOMEM; 271 goto err_put_evdev; 272 } 273 274 spin_lock_init(&client->buffer_lock); 275 client->evdev = evdev; 276 evdev_attach_client(evdev, client); 277 278 error = evdev_open_device(evdev); 279 if (error) 280 goto err_free_client; 281 282 file->private_data = client; 283 return 0; 284 285 err_free_client: 286 evdev_detach_client(evdev, client); 287 kfree(client); 288 err_put_evdev: 289 put_device(&evdev->dev); 290 return error; 291 } 292 293 #ifdef CONFIG_COMPAT 294 295 struct input_event_compat { 296 struct compat_timeval time; 297 __u16 type; 298 __u16 code; 299 __s32 value; 300 }; 301 302 struct ff_periodic_effect_compat { 303 __u16 waveform; 304 __u16 period; 305 __s16 magnitude; 306 __s16 offset; 307 __u16 phase; 308 309 struct ff_envelope envelope; 310 311 __u32 custom_len; 312 compat_uptr_t custom_data; 313 }; 314 315 struct ff_effect_compat { 316 __u16 type; 317 __s16 id; 318 __u16 direction; 319 struct ff_trigger trigger; 320 struct ff_replay replay; 321 322 union { 323 struct ff_constant_effect constant; 324 struct ff_ramp_effect ramp; 325 struct ff_periodic_effect_compat periodic; 326 struct ff_condition_effect condition[2]; /* One for each axis */ 327 struct ff_rumble_effect rumble; 328 } u; 329 }; 330 331 /* Note to the author of this code: did it ever occur to 332 you why the ifdefs are needed? Think about it again. -AK */ 333 #ifdef CONFIG_X86_64 334 # define COMPAT_TEST is_compat_task() 335 #elif defined(CONFIG_IA64) 336 # define COMPAT_TEST IS_IA32_PROCESS(task_pt_regs(current)) 337 #elif defined(CONFIG_S390) 338 # define COMPAT_TEST test_thread_flag(TIF_31BIT) 339 #elif defined(CONFIG_MIPS) 340 # define COMPAT_TEST test_thread_flag(TIF_32BIT_ADDR) 341 #else 342 # define COMPAT_TEST test_thread_flag(TIF_32BIT) 343 #endif 344 345 static inline size_t evdev_event_size(void) 346 { 347 return COMPAT_TEST ? 348 sizeof(struct input_event_compat) : sizeof(struct input_event); 349 } 350 351 static int evdev_event_from_user(const char __user *buffer, 352 struct input_event *event) 353 { 354 if (COMPAT_TEST) { 355 struct input_event_compat compat_event; 356 357 if (copy_from_user(&compat_event, buffer, 358 sizeof(struct input_event_compat))) 359 return -EFAULT; 360 361 event->time.tv_sec = compat_event.time.tv_sec; 362 event->time.tv_usec = compat_event.time.tv_usec; 363 event->type = compat_event.type; 364 event->code = compat_event.code; 365 event->value = compat_event.value; 366 367 } else { 368 if (copy_from_user(event, buffer, sizeof(struct input_event))) 369 return -EFAULT; 370 } 371 372 return 0; 373 } 374 375 static int evdev_event_to_user(char __user *buffer, 376 const struct input_event *event) 377 { 378 if (COMPAT_TEST) { 379 struct input_event_compat compat_event; 380 381 compat_event.time.tv_sec = event->time.tv_sec; 382 compat_event.time.tv_usec = event->time.tv_usec; 383 compat_event.type = event->type; 384 compat_event.code = event->code; 385 compat_event.value = event->value; 386 387 if (copy_to_user(buffer, &compat_event, 388 sizeof(struct input_event_compat))) 389 return -EFAULT; 390 391 } else { 392 if (copy_to_user(buffer, event, sizeof(struct input_event))) 393 return -EFAULT; 394 } 395 396 return 0; 397 } 398 399 static int evdev_ff_effect_from_user(const char __user *buffer, size_t size, 400 struct ff_effect *effect) 401 { 402 if (COMPAT_TEST) { 403 struct ff_effect_compat *compat_effect; 404 405 if (size != sizeof(struct ff_effect_compat)) 406 return -EINVAL; 407 408 /* 409 * It so happens that the pointer which needs to be changed 410 * is the last field in the structure, so we can copy the 411 * whole thing and replace just the pointer. 412 */ 413 414 compat_effect = (struct ff_effect_compat *)effect; 415 416 if (copy_from_user(compat_effect, buffer, 417 sizeof(struct ff_effect_compat))) 418 return -EFAULT; 419 420 if (compat_effect->type == FF_PERIODIC && 421 compat_effect->u.periodic.waveform == FF_CUSTOM) 422 effect->u.periodic.custom_data = 423 compat_ptr(compat_effect->u.periodic.custom_data); 424 } else { 425 if (size != sizeof(struct ff_effect)) 426 return -EINVAL; 427 428 if (copy_from_user(effect, buffer, sizeof(struct ff_effect))) 429 return -EFAULT; 430 } 431 432 return 0; 433 } 434 435 #else 436 437 static inline size_t evdev_event_size(void) 438 { 439 return sizeof(struct input_event); 440 } 441 442 static int evdev_event_from_user(const char __user *buffer, 443 struct input_event *event) 444 { 445 if (copy_from_user(event, buffer, sizeof(struct input_event))) 446 return -EFAULT; 447 448 return 0; 449 } 450 451 static int evdev_event_to_user(char __user *buffer, 452 const struct input_event *event) 453 { 454 if (copy_to_user(buffer, event, sizeof(struct input_event))) 455 return -EFAULT; 456 457 return 0; 458 } 459 460 static int evdev_ff_effect_from_user(const char __user *buffer, size_t size, 461 struct ff_effect *effect) 462 { 463 if (size != sizeof(struct ff_effect)) 464 return -EINVAL; 465 466 if (copy_from_user(effect, buffer, sizeof(struct ff_effect))) 467 return -EFAULT; 468 469 return 0; 470 } 471 472 #endif /* CONFIG_COMPAT */ 473 474 static ssize_t evdev_write(struct file *file, const char __user *buffer, 475 size_t count, loff_t *ppos) 476 { 477 struct evdev_client *client = file->private_data; 478 struct evdev *evdev = client->evdev; 479 struct input_event event; 480 int retval; 481 482 retval = mutex_lock_interruptible(&evdev->mutex); 483 if (retval) 484 return retval; 485 486 if (!evdev->exist) { 487 retval = -ENODEV; 488 goto out; 489 } 490 491 while (retval < count) { 492 493 if (evdev_event_from_user(buffer + retval, &event)) { 494 retval = -EFAULT; 495 goto out; 496 } 497 498 input_inject_event(&evdev->handle, 499 event.type, event.code, event.value); 500 retval += evdev_event_size(); 501 } 502 503 out: 504 mutex_unlock(&evdev->mutex); 505 return retval; 506 } 507 508 static int evdev_fetch_next_event(struct evdev_client *client, 509 struct input_event *event) 510 { 511 int have_event; 512 513 spin_lock_irq(&client->buffer_lock); 514 515 have_event = client->head != client->tail; 516 if (have_event) { 517 *event = client->buffer[client->tail++]; 518 client->tail &= EVDEV_BUFFER_SIZE - 1; 519 } 520 521 spin_unlock_irq(&client->buffer_lock); 522 523 return have_event; 524 } 525 526 static ssize_t evdev_read(struct file *file, char __user *buffer, 527 size_t count, loff_t *ppos) 528 { 529 struct evdev_client *client = file->private_data; 530 struct evdev *evdev = client->evdev; 531 struct input_event event; 532 int retval; 533 534 if (count < evdev_event_size()) 535 return -EINVAL; 536 537 if (client->head == client->tail && evdev->exist && 538 (file->f_flags & O_NONBLOCK)) 539 return -EAGAIN; 540 541 retval = wait_event_interruptible(evdev->wait, 542 client->head != client->tail || !evdev->exist); 543 if (retval) 544 return retval; 545 546 if (!evdev->exist) 547 return -ENODEV; 548 549 while (retval + evdev_event_size() <= count && 550 evdev_fetch_next_event(client, &event)) { 551 552 if (evdev_event_to_user(buffer + retval, &event)) 553 return -EFAULT; 554 555 retval += evdev_event_size(); 556 } 557 558 return retval; 559 } 560 561 /* No kernel lock - fine */ 562 static unsigned int evdev_poll(struct file *file, poll_table *wait) 563 { 564 struct evdev_client *client = file->private_data; 565 struct evdev *evdev = client->evdev; 566 567 poll_wait(file, &evdev->wait, wait); 568 return ((client->head == client->tail) ? 0 : (POLLIN | POLLRDNORM)) | 569 (evdev->exist ? 0 : (POLLHUP | POLLERR)); 570 } 571 572 #ifdef CONFIG_COMPAT 573 574 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8) 575 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1) 576 577 #ifdef __BIG_ENDIAN 578 static int bits_to_user(unsigned long *bits, unsigned int maxbit, 579 unsigned int maxlen, void __user *p, int compat) 580 { 581 int len, i; 582 583 if (compat) { 584 len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t); 585 if (len > maxlen) 586 len = maxlen; 587 588 for (i = 0; i < len / sizeof(compat_long_t); i++) 589 if (copy_to_user((compat_long_t __user *) p + i, 590 (compat_long_t *) bits + 591 i + 1 - ((i % 2) << 1), 592 sizeof(compat_long_t))) 593 return -EFAULT; 594 } else { 595 len = BITS_TO_LONGS(maxbit) * sizeof(long); 596 if (len > maxlen) 597 len = maxlen; 598 599 if (copy_to_user(p, bits, len)) 600 return -EFAULT; 601 } 602 603 return len; 604 } 605 #else 606 static int bits_to_user(unsigned long *bits, unsigned int maxbit, 607 unsigned int maxlen, void __user *p, int compat) 608 { 609 int len = compat ? 610 BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t) : 611 BITS_TO_LONGS(maxbit) * sizeof(long); 612 613 if (len > maxlen) 614 len = maxlen; 615 616 return copy_to_user(p, bits, len) ? -EFAULT : len; 617 } 618 #endif /* __BIG_ENDIAN */ 619 620 #else 621 622 static int bits_to_user(unsigned long *bits, unsigned int maxbit, 623 unsigned int maxlen, void __user *p, int compat) 624 { 625 int len = BITS_TO_LONGS(maxbit) * sizeof(long); 626 627 if (len > maxlen) 628 len = maxlen; 629 630 return copy_to_user(p, bits, len) ? -EFAULT : len; 631 } 632 633 #endif /* CONFIG_COMPAT */ 634 635 static int str_to_user(const char *str, unsigned int maxlen, void __user *p) 636 { 637 int len; 638 639 if (!str) 640 return -ENOENT; 641 642 len = strlen(str) + 1; 643 if (len > maxlen) 644 len = maxlen; 645 646 return copy_to_user(p, str, len) ? -EFAULT : len; 647 } 648 649 #define OLD_KEY_MAX 0x1ff 650 static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user *p, int compat_mode) 651 { 652 static unsigned long keymax_warn_time; 653 unsigned long *bits; 654 int len; 655 656 switch (_IOC_NR(cmd) & EV_MAX) { 657 658 case 0: bits = dev->evbit; len = EV_MAX; break; 659 case EV_KEY: bits = dev->keybit; len = KEY_MAX; break; 660 case EV_REL: bits = dev->relbit; len = REL_MAX; break; 661 case EV_ABS: bits = dev->absbit; len = ABS_MAX; break; 662 case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break; 663 case EV_LED: bits = dev->ledbit; len = LED_MAX; break; 664 case EV_SND: bits = dev->sndbit; len = SND_MAX; break; 665 case EV_FF: bits = dev->ffbit; len = FF_MAX; break; 666 case EV_SW: bits = dev->swbit; len = SW_MAX; break; 667 default: return -EINVAL; 668 } 669 670 /* 671 * Work around bugs in userspace programs that like to do 672 * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len' 673 * should be in bytes, not in bits. 674 */ 675 if ((_IOC_NR(cmd) & EV_MAX) == EV_KEY && _IOC_SIZE(cmd) == OLD_KEY_MAX) { 676 len = OLD_KEY_MAX; 677 if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000)) 678 printk(KERN_WARNING 679 "evdev.c(EVIOCGBIT): Suspicious buffer size %u, " 680 "limiting output to %zu bytes. See " 681 "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n", 682 OLD_KEY_MAX, 683 BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long)); 684 } 685 686 return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode); 687 } 688 #undef OLD_KEY_MAX 689 690 static long evdev_do_ioctl(struct file *file, unsigned int cmd, 691 void __user *p, int compat_mode) 692 { 693 struct evdev_client *client = file->private_data; 694 struct evdev *evdev = client->evdev; 695 struct input_dev *dev = evdev->handle.dev; 696 struct input_absinfo abs; 697 struct ff_effect effect; 698 int __user *ip = (int __user *)p; 699 int i, t, u, v; 700 int error; 701 702 switch (cmd) { 703 704 case EVIOCGVERSION: 705 return put_user(EV_VERSION, ip); 706 707 case EVIOCGID: 708 if (copy_to_user(p, &dev->id, sizeof(struct input_id))) 709 return -EFAULT; 710 return 0; 711 712 case EVIOCGREP: 713 if (!test_bit(EV_REP, dev->evbit)) 714 return -ENOSYS; 715 if (put_user(dev->rep[REP_DELAY], ip)) 716 return -EFAULT; 717 if (put_user(dev->rep[REP_PERIOD], ip + 1)) 718 return -EFAULT; 719 return 0; 720 721 case EVIOCSREP: 722 if (!test_bit(EV_REP, dev->evbit)) 723 return -ENOSYS; 724 if (get_user(u, ip)) 725 return -EFAULT; 726 if (get_user(v, ip + 1)) 727 return -EFAULT; 728 729 input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u); 730 input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v); 731 732 return 0; 733 734 case EVIOCGKEYCODE: 735 if (get_user(t, ip)) 736 return -EFAULT; 737 738 error = input_get_keycode(dev, t, &v); 739 if (error) 740 return error; 741 742 if (put_user(v, ip + 1)) 743 return -EFAULT; 744 745 return 0; 746 747 case EVIOCSKEYCODE: 748 if (get_user(t, ip) || get_user(v, ip + 1)) 749 return -EFAULT; 750 751 return input_set_keycode(dev, t, v); 752 753 case EVIOCRMFF: 754 return input_ff_erase(dev, (int)(unsigned long) p, file); 755 756 case EVIOCGEFFECTS: 757 i = test_bit(EV_FF, dev->evbit) ? 758 dev->ff->max_effects : 0; 759 if (put_user(i, ip)) 760 return -EFAULT; 761 return 0; 762 763 case EVIOCGRAB: 764 if (p) 765 return evdev_grab(evdev, client); 766 else 767 return evdev_ungrab(evdev, client); 768 769 default: 770 771 if (_IOC_TYPE(cmd) != 'E') 772 return -EINVAL; 773 774 if (_IOC_DIR(cmd) == _IOC_READ) { 775 776 if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0))) 777 return handle_eviocgbit(dev, cmd, p, compat_mode); 778 779 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) 780 return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd), 781 p, compat_mode); 782 783 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) 784 return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd), 785 p, compat_mode); 786 787 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) 788 return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd), 789 p, compat_mode); 790 791 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0))) 792 return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd), 793 p, compat_mode); 794 795 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) 796 return str_to_user(dev->name, _IOC_SIZE(cmd), p); 797 798 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) 799 return str_to_user(dev->phys, _IOC_SIZE(cmd), p); 800 801 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) 802 return str_to_user(dev->uniq, _IOC_SIZE(cmd), p); 803 804 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) { 805 806 t = _IOC_NR(cmd) & ABS_MAX; 807 808 abs.value = dev->abs[t]; 809 abs.minimum = dev->absmin[t]; 810 abs.maximum = dev->absmax[t]; 811 abs.fuzz = dev->absfuzz[t]; 812 abs.flat = dev->absflat[t]; 813 814 if (copy_to_user(p, &abs, sizeof(struct input_absinfo))) 815 return -EFAULT; 816 817 return 0; 818 } 819 820 } 821 822 if (_IOC_DIR(cmd) == _IOC_WRITE) { 823 824 if (_IOC_NR(cmd) == _IOC_NR(EVIOCSFF)) { 825 826 if (evdev_ff_effect_from_user(p, _IOC_SIZE(cmd), &effect)) 827 return -EFAULT; 828 829 error = input_ff_upload(dev, &effect, file); 830 831 if (put_user(effect.id, &(((struct ff_effect __user *)p)->id))) 832 return -EFAULT; 833 834 return error; 835 } 836 837 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) { 838 839 t = _IOC_NR(cmd) & ABS_MAX; 840 841 if (copy_from_user(&abs, p, 842 sizeof(struct input_absinfo))) 843 return -EFAULT; 844 845 /* 846 * Take event lock to ensure that we are not 847 * changing device parameters in the middle 848 * of event. 849 */ 850 spin_lock_irq(&dev->event_lock); 851 852 dev->abs[t] = abs.value; 853 dev->absmin[t] = abs.minimum; 854 dev->absmax[t] = abs.maximum; 855 dev->absfuzz[t] = abs.fuzz; 856 dev->absflat[t] = abs.flat; 857 858 spin_unlock_irq(&dev->event_lock); 859 860 return 0; 861 } 862 } 863 } 864 return -EINVAL; 865 } 866 867 static long evdev_ioctl_handler(struct file *file, unsigned int cmd, 868 void __user *p, int compat_mode) 869 { 870 struct evdev_client *client = file->private_data; 871 struct evdev *evdev = client->evdev; 872 int retval; 873 874 retval = mutex_lock_interruptible(&evdev->mutex); 875 if (retval) 876 return retval; 877 878 if (!evdev->exist) { 879 retval = -ENODEV; 880 goto out; 881 } 882 883 retval = evdev_do_ioctl(file, cmd, p, compat_mode); 884 885 out: 886 mutex_unlock(&evdev->mutex); 887 return retval; 888 } 889 890 static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 891 { 892 return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0); 893 } 894 895 #ifdef CONFIG_COMPAT 896 static long evdev_ioctl_compat(struct file *file, 897 unsigned int cmd, unsigned long arg) 898 { 899 return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1); 900 } 901 #endif 902 903 static const struct file_operations evdev_fops = { 904 .owner = THIS_MODULE, 905 .read = evdev_read, 906 .write = evdev_write, 907 .poll = evdev_poll, 908 .open = evdev_open, 909 .release = evdev_release, 910 .unlocked_ioctl = evdev_ioctl, 911 #ifdef CONFIG_COMPAT 912 .compat_ioctl = evdev_ioctl_compat, 913 #endif 914 .fasync = evdev_fasync, 915 .flush = evdev_flush 916 }; 917 918 static int evdev_install_chrdev(struct evdev *evdev) 919 { 920 /* 921 * No need to do any locking here as calls to connect and 922 * disconnect are serialized by the input core 923 */ 924 evdev_table[evdev->minor] = evdev; 925 return 0; 926 } 927 928 static void evdev_remove_chrdev(struct evdev *evdev) 929 { 930 /* 931 * Lock evdev table to prevent race with evdev_open() 932 */ 933 mutex_lock(&evdev_table_mutex); 934 evdev_table[evdev->minor] = NULL; 935 mutex_unlock(&evdev_table_mutex); 936 } 937 938 /* 939 * Mark device non-existent. This disables writes, ioctls and 940 * prevents new users from opening the device. Already posted 941 * blocking reads will stay, however new ones will fail. 942 */ 943 static void evdev_mark_dead(struct evdev *evdev) 944 { 945 mutex_lock(&evdev->mutex); 946 evdev->exist = 0; 947 mutex_unlock(&evdev->mutex); 948 } 949 950 static void evdev_cleanup(struct evdev *evdev) 951 { 952 struct input_handle *handle = &evdev->handle; 953 954 evdev_mark_dead(evdev); 955 evdev_hangup(evdev); 956 evdev_remove_chrdev(evdev); 957 958 /* evdev is marked dead so no one else accesses evdev->open */ 959 if (evdev->open) { 960 input_flush_device(handle, NULL); 961 input_close_device(handle); 962 } 963 } 964 965 /* 966 * Create new evdev device. Note that input core serializes calls 967 * to connect and disconnect so we don't need to lock evdev_table here. 968 */ 969 static int evdev_connect(struct input_handler *handler, struct input_dev *dev, 970 const struct input_device_id *id) 971 { 972 struct evdev *evdev; 973 int minor; 974 int error; 975 976 for (minor = 0; minor < EVDEV_MINORS; minor++) 977 if (!evdev_table[minor]) 978 break; 979 980 if (minor == EVDEV_MINORS) { 981 printk(KERN_ERR "evdev: no more free evdev devices\n"); 982 return -ENFILE; 983 } 984 985 evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 986 if (!evdev) 987 return -ENOMEM; 988 989 INIT_LIST_HEAD(&evdev->client_list); 990 spin_lock_init(&evdev->client_lock); 991 mutex_init(&evdev->mutex); 992 init_waitqueue_head(&evdev->wait); 993 994 snprintf(evdev->name, sizeof(evdev->name), "event%d", minor); 995 evdev->exist = 1; 996 evdev->minor = minor; 997 998 evdev->handle.dev = input_get_device(dev); 999 evdev->handle.name = evdev->name; 1000 evdev->handle.handler = handler; 1001 evdev->handle.private = evdev; 1002 1003 strlcpy(evdev->dev.bus_id, evdev->name, sizeof(evdev->dev.bus_id)); 1004 evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor); 1005 evdev->dev.class = &input_class; 1006 evdev->dev.parent = &dev->dev; 1007 evdev->dev.release = evdev_free; 1008 device_initialize(&evdev->dev); 1009 1010 error = input_register_handle(&evdev->handle); 1011 if (error) 1012 goto err_free_evdev; 1013 1014 error = evdev_install_chrdev(evdev); 1015 if (error) 1016 goto err_unregister_handle; 1017 1018 error = device_add(&evdev->dev); 1019 if (error) 1020 goto err_cleanup_evdev; 1021 1022 return 0; 1023 1024 err_cleanup_evdev: 1025 evdev_cleanup(evdev); 1026 err_unregister_handle: 1027 input_unregister_handle(&evdev->handle); 1028 err_free_evdev: 1029 put_device(&evdev->dev); 1030 return error; 1031 } 1032 1033 static void evdev_disconnect(struct input_handle *handle) 1034 { 1035 struct evdev *evdev = handle->private; 1036 1037 device_del(&evdev->dev); 1038 evdev_cleanup(evdev); 1039 input_unregister_handle(handle); 1040 put_device(&evdev->dev); 1041 } 1042 1043 static const struct input_device_id evdev_ids[] = { 1044 { .driver_info = 1 }, /* Matches all devices */ 1045 { }, /* Terminating zero entry */ 1046 }; 1047 1048 MODULE_DEVICE_TABLE(input, evdev_ids); 1049 1050 static struct input_handler evdev_handler = { 1051 .event = evdev_event, 1052 .connect = evdev_connect, 1053 .disconnect = evdev_disconnect, 1054 .fops = &evdev_fops, 1055 .minor = EVDEV_MINOR_BASE, 1056 .name = "evdev", 1057 .id_table = evdev_ids, 1058 }; 1059 1060 static int __init evdev_init(void) 1061 { 1062 return input_register_handler(&evdev_handler); 1063 } 1064 1065 static void __exit evdev_exit(void) 1066 { 1067 input_unregister_handler(&evdev_handler); 1068 } 1069 1070 module_init(evdev_init); 1071 module_exit(evdev_exit); 1072 1073 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 1074 MODULE_DESCRIPTION("Input driver event char devices"); 1075 MODULE_LICENSE("GPL"); 1076