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 #define OLD_KEY_MAX 0x1ff 651 static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user *p, int compat_mode) 652 { 653 static unsigned long keymax_warn_time; 654 unsigned long *bits; 655 int len; 656 657 switch (_IOC_NR(cmd) & EV_MAX) { 658 659 case 0: bits = dev->evbit; len = EV_MAX; break; 660 case EV_KEY: bits = dev->keybit; len = KEY_MAX; break; 661 case EV_REL: bits = dev->relbit; len = REL_MAX; break; 662 case EV_ABS: bits = dev->absbit; len = ABS_MAX; break; 663 case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break; 664 case EV_LED: bits = dev->ledbit; len = LED_MAX; break; 665 case EV_SND: bits = dev->sndbit; len = SND_MAX; break; 666 case EV_FF: bits = dev->ffbit; len = FF_MAX; break; 667 case EV_SW: bits = dev->swbit; len = SW_MAX; break; 668 default: return -EINVAL; 669 } 670 671 /* 672 * Work around bugs in userspace programs that like to do 673 * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len' 674 * should be in bytes, not in bits. 675 */ 676 if ((_IOC_NR(cmd) & EV_MAX) == EV_KEY && _IOC_SIZE(cmd) == OLD_KEY_MAX) { 677 len = OLD_KEY_MAX; 678 if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000)) 679 printk(KERN_WARNING 680 "evdev.c(EVIOCGBIT): Suspicious buffer size %u, " 681 "limiting output to %zu bytes. See " 682 "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n", 683 OLD_KEY_MAX, 684 BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long)); 685 } 686 687 return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode); 688 } 689 #undef OLD_KEY_MAX 690 691 static long evdev_do_ioctl(struct file *file, unsigned int cmd, 692 void __user *p, int compat_mode) 693 { 694 struct evdev_client *client = file->private_data; 695 struct evdev *evdev = client->evdev; 696 struct input_dev *dev = evdev->handle.dev; 697 struct input_absinfo abs; 698 struct ff_effect effect; 699 int __user *ip = (int __user *)p; 700 int i, t, u, v; 701 int error; 702 703 switch (cmd) { 704 705 case EVIOCGVERSION: 706 return put_user(EV_VERSION, ip); 707 708 case EVIOCGID: 709 if (copy_to_user(p, &dev->id, sizeof(struct input_id))) 710 return -EFAULT; 711 return 0; 712 713 case EVIOCGREP: 714 if (!test_bit(EV_REP, dev->evbit)) 715 return -ENOSYS; 716 if (put_user(dev->rep[REP_DELAY], ip)) 717 return -EFAULT; 718 if (put_user(dev->rep[REP_PERIOD], ip + 1)) 719 return -EFAULT; 720 return 0; 721 722 case EVIOCSREP: 723 if (!test_bit(EV_REP, dev->evbit)) 724 return -ENOSYS; 725 if (get_user(u, ip)) 726 return -EFAULT; 727 if (get_user(v, ip + 1)) 728 return -EFAULT; 729 730 input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u); 731 input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v); 732 733 return 0; 734 735 case EVIOCGKEYCODE: 736 if (get_user(t, ip)) 737 return -EFAULT; 738 739 error = input_get_keycode(dev, t, &v); 740 if (error) 741 return error; 742 743 if (put_user(v, ip + 1)) 744 return -EFAULT; 745 746 return 0; 747 748 case EVIOCSKEYCODE: 749 if (get_user(t, ip) || get_user(v, ip + 1)) 750 return -EFAULT; 751 752 return input_set_keycode(dev, t, v); 753 754 case EVIOCRMFF: 755 return input_ff_erase(dev, (int)(unsigned long) p, file); 756 757 case EVIOCGEFFECTS: 758 i = test_bit(EV_FF, dev->evbit) ? 759 dev->ff->max_effects : 0; 760 if (put_user(i, ip)) 761 return -EFAULT; 762 return 0; 763 764 case EVIOCGRAB: 765 if (p) 766 return evdev_grab(evdev, client); 767 else 768 return evdev_ungrab(evdev, client); 769 770 default: 771 772 if (_IOC_TYPE(cmd) != 'E') 773 return -EINVAL; 774 775 if (_IOC_DIR(cmd) == _IOC_READ) { 776 777 if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0))) 778 return handle_eviocgbit(dev, cmd, p, compat_mode); 779 780 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) 781 return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd), 782 p, compat_mode); 783 784 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) 785 return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd), 786 p, compat_mode); 787 788 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) 789 return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd), 790 p, compat_mode); 791 792 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0))) 793 return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd), 794 p, compat_mode); 795 796 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) 797 return str_to_user(dev->name, _IOC_SIZE(cmd), p); 798 799 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) 800 return str_to_user(dev->phys, _IOC_SIZE(cmd), p); 801 802 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) 803 return str_to_user(dev->uniq, _IOC_SIZE(cmd), p); 804 805 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) { 806 807 t = _IOC_NR(cmd) & ABS_MAX; 808 809 abs.value = dev->abs[t]; 810 abs.minimum = dev->absmin[t]; 811 abs.maximum = dev->absmax[t]; 812 abs.fuzz = dev->absfuzz[t]; 813 abs.flat = dev->absflat[t]; 814 815 if (copy_to_user(p, &abs, sizeof(struct input_absinfo))) 816 return -EFAULT; 817 818 return 0; 819 } 820 821 } 822 823 if (_IOC_DIR(cmd) == _IOC_WRITE) { 824 825 if (_IOC_NR(cmd) == _IOC_NR(EVIOCSFF)) { 826 827 if (evdev_ff_effect_from_user(p, _IOC_SIZE(cmd), &effect)) 828 return -EFAULT; 829 830 error = input_ff_upload(dev, &effect, file); 831 832 if (put_user(effect.id, &(((struct ff_effect __user *)p)->id))) 833 return -EFAULT; 834 835 return error; 836 } 837 838 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) { 839 840 t = _IOC_NR(cmd) & ABS_MAX; 841 842 if (copy_from_user(&abs, p, 843 sizeof(struct input_absinfo))) 844 return -EFAULT; 845 846 /* 847 * Take event lock to ensure that we are not 848 * changing device parameters in the middle 849 * of event. 850 */ 851 spin_lock_irq(&dev->event_lock); 852 853 dev->abs[t] = abs.value; 854 dev->absmin[t] = abs.minimum; 855 dev->absmax[t] = abs.maximum; 856 dev->absfuzz[t] = abs.fuzz; 857 dev->absflat[t] = abs.flat; 858 859 spin_unlock_irq(&dev->event_lock); 860 861 return 0; 862 } 863 } 864 } 865 return -EINVAL; 866 } 867 868 static long evdev_ioctl_handler(struct file *file, unsigned int cmd, 869 void __user *p, int compat_mode) 870 { 871 struct evdev_client *client = file->private_data; 872 struct evdev *evdev = client->evdev; 873 int retval; 874 875 retval = mutex_lock_interruptible(&evdev->mutex); 876 if (retval) 877 return retval; 878 879 if (!evdev->exist) { 880 retval = -ENODEV; 881 goto out; 882 } 883 884 retval = evdev_do_ioctl(file, cmd, p, compat_mode); 885 886 out: 887 mutex_unlock(&evdev->mutex); 888 return retval; 889 } 890 891 static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 892 { 893 return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0); 894 } 895 896 #ifdef CONFIG_COMPAT 897 static long evdev_ioctl_compat(struct file *file, 898 unsigned int cmd, unsigned long arg) 899 { 900 return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1); 901 } 902 #endif 903 904 static const struct file_operations evdev_fops = { 905 .owner = THIS_MODULE, 906 .read = evdev_read, 907 .write = evdev_write, 908 .poll = evdev_poll, 909 .open = evdev_open, 910 .release = evdev_release, 911 .unlocked_ioctl = evdev_ioctl, 912 #ifdef CONFIG_COMPAT 913 .compat_ioctl = evdev_ioctl_compat, 914 #endif 915 .fasync = evdev_fasync, 916 .flush = evdev_flush 917 }; 918 919 static int evdev_install_chrdev(struct evdev *evdev) 920 { 921 /* 922 * No need to do any locking here as calls to connect and 923 * disconnect are serialized by the input core 924 */ 925 evdev_table[evdev->minor] = evdev; 926 return 0; 927 } 928 929 static void evdev_remove_chrdev(struct evdev *evdev) 930 { 931 /* 932 * Lock evdev table to prevent race with evdev_open() 933 */ 934 mutex_lock(&evdev_table_mutex); 935 evdev_table[evdev->minor] = NULL; 936 mutex_unlock(&evdev_table_mutex); 937 } 938 939 /* 940 * Mark device non-existent. This disables writes, ioctls and 941 * prevents new users from opening the device. Already posted 942 * blocking reads will stay, however new ones will fail. 943 */ 944 static void evdev_mark_dead(struct evdev *evdev) 945 { 946 mutex_lock(&evdev->mutex); 947 evdev->exist = 0; 948 mutex_unlock(&evdev->mutex); 949 } 950 951 static void evdev_cleanup(struct evdev *evdev) 952 { 953 struct input_handle *handle = &evdev->handle; 954 955 evdev_mark_dead(evdev); 956 evdev_hangup(evdev); 957 evdev_remove_chrdev(evdev); 958 959 /* evdev is marked dead so no one else accesses evdev->open */ 960 if (evdev->open) { 961 input_flush_device(handle, NULL); 962 input_close_device(handle); 963 } 964 } 965 966 /* 967 * Create new evdev device. Note that input core serializes calls 968 * to connect and disconnect so we don't need to lock evdev_table here. 969 */ 970 static int evdev_connect(struct input_handler *handler, struct input_dev *dev, 971 const struct input_device_id *id) 972 { 973 struct evdev *evdev; 974 int minor; 975 int error; 976 977 for (minor = 0; minor < EVDEV_MINORS; minor++) 978 if (!evdev_table[minor]) 979 break; 980 981 if (minor == EVDEV_MINORS) { 982 printk(KERN_ERR "evdev: no more free evdev devices\n"); 983 return -ENFILE; 984 } 985 986 evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 987 if (!evdev) 988 return -ENOMEM; 989 990 INIT_LIST_HEAD(&evdev->client_list); 991 spin_lock_init(&evdev->client_lock); 992 mutex_init(&evdev->mutex); 993 init_waitqueue_head(&evdev->wait); 994 995 snprintf(evdev->name, sizeof(evdev->name), "event%d", minor); 996 evdev->exist = 1; 997 evdev->minor = minor; 998 999 evdev->handle.dev = input_get_device(dev); 1000 evdev->handle.name = evdev->name; 1001 evdev->handle.handler = handler; 1002 evdev->handle.private = evdev; 1003 1004 strlcpy(evdev->dev.bus_id, evdev->name, sizeof(evdev->dev.bus_id)); 1005 evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor); 1006 evdev->dev.class = &input_class; 1007 evdev->dev.parent = &dev->dev; 1008 evdev->dev.release = evdev_free; 1009 device_initialize(&evdev->dev); 1010 1011 error = input_register_handle(&evdev->handle); 1012 if (error) 1013 goto err_free_evdev; 1014 1015 error = evdev_install_chrdev(evdev); 1016 if (error) 1017 goto err_unregister_handle; 1018 1019 error = device_add(&evdev->dev); 1020 if (error) 1021 goto err_cleanup_evdev; 1022 1023 return 0; 1024 1025 err_cleanup_evdev: 1026 evdev_cleanup(evdev); 1027 err_unregister_handle: 1028 input_unregister_handle(&evdev->handle); 1029 err_free_evdev: 1030 put_device(&evdev->dev); 1031 return error; 1032 } 1033 1034 static void evdev_disconnect(struct input_handle *handle) 1035 { 1036 struct evdev *evdev = handle->private; 1037 1038 device_del(&evdev->dev); 1039 evdev_cleanup(evdev); 1040 input_unregister_handle(handle); 1041 put_device(&evdev->dev); 1042 } 1043 1044 static const struct input_device_id evdev_ids[] = { 1045 { .driver_info = 1 }, /* Matches all devices */ 1046 { }, /* Terminating zero entry */ 1047 }; 1048 1049 MODULE_DEVICE_TABLE(input, evdev_ids); 1050 1051 static struct input_handler evdev_handler = { 1052 .event = evdev_event, 1053 .connect = evdev_connect, 1054 .disconnect = evdev_disconnect, 1055 .fops = &evdev_fops, 1056 .minor = EVDEV_MINOR_BASE, 1057 .name = "evdev", 1058 .id_table = evdev_ids, 1059 }; 1060 1061 static int __init evdev_init(void) 1062 { 1063 return input_register_handler(&evdev_handler); 1064 } 1065 1066 static void __exit evdev_exit(void) 1067 { 1068 input_unregister_handler(&evdev_handler); 1069 } 1070 1071 module_init(evdev_init); 1072 module_exit(evdev_exit); 1073 1074 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 1075 MODULE_DESCRIPTION("Input driver event char devices"); 1076 MODULE_LICENSE("GPL"); 1077