1 /* 2 * Joystick device driver for the input driver suite. 3 * 4 * Copyright (c) 1999-2002 Vojtech Pavlik 5 * Copyright (c) 1999 Colin Van Dyke 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 */ 12 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15 #include <asm/io.h> 16 #include <linux/delay.h> 17 #include <linux/errno.h> 18 #include <linux/joystick.h> 19 #include <linux/input.h> 20 #include <linux/kernel.h> 21 #include <linux/major.h> 22 #include <linux/sched.h> 23 #include <linux/slab.h> 24 #include <linux/mm.h> 25 #include <linux/module.h> 26 #include <linux/poll.h> 27 #include <linux/init.h> 28 #include <linux/device.h> 29 #include <linux/cdev.h> 30 31 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 32 MODULE_DESCRIPTION("Joystick device interfaces"); 33 MODULE_SUPPORTED_DEVICE("input/js"); 34 MODULE_LICENSE("GPL"); 35 36 #define JOYDEV_MINOR_BASE 0 37 #define JOYDEV_MINORS 16 38 #define JOYDEV_BUFFER_SIZE 64 39 40 struct joydev { 41 int open; 42 struct input_handle handle; 43 wait_queue_head_t wait; 44 struct list_head client_list; 45 spinlock_t client_lock; /* protects client_list */ 46 struct mutex mutex; 47 struct device dev; 48 struct cdev cdev; 49 bool exist; 50 51 struct js_corr corr[ABS_CNT]; 52 struct JS_DATA_SAVE_TYPE glue; 53 int nabs; 54 int nkey; 55 __u16 keymap[KEY_MAX - BTN_MISC + 1]; 56 __u16 keypam[KEY_MAX - BTN_MISC + 1]; 57 __u8 absmap[ABS_CNT]; 58 __u8 abspam[ABS_CNT]; 59 __s16 abs[ABS_CNT]; 60 }; 61 62 struct joydev_client { 63 struct js_event buffer[JOYDEV_BUFFER_SIZE]; 64 int head; 65 int tail; 66 int startup; 67 spinlock_t buffer_lock; /* protects access to buffer, head and tail */ 68 struct fasync_struct *fasync; 69 struct joydev *joydev; 70 struct list_head node; 71 }; 72 73 static int joydev_correct(int value, struct js_corr *corr) 74 { 75 switch (corr->type) { 76 77 case JS_CORR_NONE: 78 break; 79 80 case JS_CORR_BROKEN: 81 value = value > corr->coef[0] ? (value < corr->coef[1] ? 0 : 82 ((corr->coef[3] * (value - corr->coef[1])) >> 14)) : 83 ((corr->coef[2] * (value - corr->coef[0])) >> 14); 84 break; 85 86 default: 87 return 0; 88 } 89 90 return value < -32767 ? -32767 : (value > 32767 ? 32767 : value); 91 } 92 93 static void joydev_pass_event(struct joydev_client *client, 94 struct js_event *event) 95 { 96 struct joydev *joydev = client->joydev; 97 98 /* 99 * IRQs already disabled, just acquire the lock 100 */ 101 spin_lock(&client->buffer_lock); 102 103 client->buffer[client->head] = *event; 104 105 if (client->startup == joydev->nabs + joydev->nkey) { 106 client->head++; 107 client->head &= JOYDEV_BUFFER_SIZE - 1; 108 if (client->tail == client->head) 109 client->startup = 0; 110 } 111 112 spin_unlock(&client->buffer_lock); 113 114 kill_fasync(&client->fasync, SIGIO, POLL_IN); 115 } 116 117 static void joydev_event(struct input_handle *handle, 118 unsigned int type, unsigned int code, int value) 119 { 120 struct joydev *joydev = handle->private; 121 struct joydev_client *client; 122 struct js_event event; 123 124 switch (type) { 125 126 case EV_KEY: 127 if (code < BTN_MISC || value == 2) 128 return; 129 event.type = JS_EVENT_BUTTON; 130 event.number = joydev->keymap[code - BTN_MISC]; 131 event.value = value; 132 break; 133 134 case EV_ABS: 135 event.type = JS_EVENT_AXIS; 136 event.number = joydev->absmap[code]; 137 event.value = joydev_correct(value, 138 &joydev->corr[event.number]); 139 if (event.value == joydev->abs[event.number]) 140 return; 141 joydev->abs[event.number] = event.value; 142 break; 143 144 default: 145 return; 146 } 147 148 event.time = jiffies_to_msecs(jiffies); 149 150 rcu_read_lock(); 151 list_for_each_entry_rcu(client, &joydev->client_list, node) 152 joydev_pass_event(client, &event); 153 rcu_read_unlock(); 154 155 wake_up_interruptible(&joydev->wait); 156 } 157 158 static int joydev_fasync(int fd, struct file *file, int on) 159 { 160 struct joydev_client *client = file->private_data; 161 162 return fasync_helper(fd, file, on, &client->fasync); 163 } 164 165 static void joydev_free(struct device *dev) 166 { 167 struct joydev *joydev = container_of(dev, struct joydev, dev); 168 169 input_put_device(joydev->handle.dev); 170 kfree(joydev); 171 } 172 173 static void joydev_attach_client(struct joydev *joydev, 174 struct joydev_client *client) 175 { 176 spin_lock(&joydev->client_lock); 177 list_add_tail_rcu(&client->node, &joydev->client_list); 178 spin_unlock(&joydev->client_lock); 179 } 180 181 static void joydev_detach_client(struct joydev *joydev, 182 struct joydev_client *client) 183 { 184 spin_lock(&joydev->client_lock); 185 list_del_rcu(&client->node); 186 spin_unlock(&joydev->client_lock); 187 synchronize_rcu(); 188 } 189 190 static int joydev_open_device(struct joydev *joydev) 191 { 192 int retval; 193 194 retval = mutex_lock_interruptible(&joydev->mutex); 195 if (retval) 196 return retval; 197 198 if (!joydev->exist) 199 retval = -ENODEV; 200 else if (!joydev->open++) { 201 retval = input_open_device(&joydev->handle); 202 if (retval) 203 joydev->open--; 204 } 205 206 mutex_unlock(&joydev->mutex); 207 return retval; 208 } 209 210 static void joydev_close_device(struct joydev *joydev) 211 { 212 mutex_lock(&joydev->mutex); 213 214 if (joydev->exist && !--joydev->open) 215 input_close_device(&joydev->handle); 216 217 mutex_unlock(&joydev->mutex); 218 } 219 220 /* 221 * Wake up users waiting for IO so they can disconnect from 222 * dead device. 223 */ 224 static void joydev_hangup(struct joydev *joydev) 225 { 226 struct joydev_client *client; 227 228 spin_lock(&joydev->client_lock); 229 list_for_each_entry(client, &joydev->client_list, node) 230 kill_fasync(&client->fasync, SIGIO, POLL_HUP); 231 spin_unlock(&joydev->client_lock); 232 233 wake_up_interruptible(&joydev->wait); 234 } 235 236 static int joydev_release(struct inode *inode, struct file *file) 237 { 238 struct joydev_client *client = file->private_data; 239 struct joydev *joydev = client->joydev; 240 241 joydev_detach_client(joydev, client); 242 kfree(client); 243 244 joydev_close_device(joydev); 245 246 return 0; 247 } 248 249 static int joydev_open(struct inode *inode, struct file *file) 250 { 251 struct joydev *joydev = 252 container_of(inode->i_cdev, struct joydev, cdev); 253 struct joydev_client *client; 254 int error; 255 256 client = kzalloc(sizeof(struct joydev_client), GFP_KERNEL); 257 if (!client) 258 return -ENOMEM; 259 260 spin_lock_init(&client->buffer_lock); 261 client->joydev = joydev; 262 joydev_attach_client(joydev, client); 263 264 error = joydev_open_device(joydev); 265 if (error) 266 goto err_free_client; 267 268 file->private_data = client; 269 nonseekable_open(inode, file); 270 271 return 0; 272 273 err_free_client: 274 joydev_detach_client(joydev, client); 275 kfree(client); 276 return error; 277 } 278 279 static int joydev_generate_startup_event(struct joydev_client *client, 280 struct input_dev *input, 281 struct js_event *event) 282 { 283 struct joydev *joydev = client->joydev; 284 int have_event; 285 286 spin_lock_irq(&client->buffer_lock); 287 288 have_event = client->startup < joydev->nabs + joydev->nkey; 289 290 if (have_event) { 291 292 event->time = jiffies_to_msecs(jiffies); 293 if (client->startup < joydev->nkey) { 294 event->type = JS_EVENT_BUTTON | JS_EVENT_INIT; 295 event->number = client->startup; 296 event->value = !!test_bit(joydev->keypam[event->number], 297 input->key); 298 } else { 299 event->type = JS_EVENT_AXIS | JS_EVENT_INIT; 300 event->number = client->startup - joydev->nkey; 301 event->value = joydev->abs[event->number]; 302 } 303 client->startup++; 304 } 305 306 spin_unlock_irq(&client->buffer_lock); 307 308 return have_event; 309 } 310 311 static int joydev_fetch_next_event(struct joydev_client *client, 312 struct js_event *event) 313 { 314 int have_event; 315 316 spin_lock_irq(&client->buffer_lock); 317 318 have_event = client->head != client->tail; 319 if (have_event) { 320 *event = client->buffer[client->tail++]; 321 client->tail &= JOYDEV_BUFFER_SIZE - 1; 322 } 323 324 spin_unlock_irq(&client->buffer_lock); 325 326 return have_event; 327 } 328 329 /* 330 * Old joystick interface 331 */ 332 static ssize_t joydev_0x_read(struct joydev_client *client, 333 struct input_dev *input, 334 char __user *buf) 335 { 336 struct joydev *joydev = client->joydev; 337 struct JS_DATA_TYPE data; 338 int i; 339 340 spin_lock_irq(&input->event_lock); 341 342 /* 343 * Get device state 344 */ 345 for (data.buttons = i = 0; i < 32 && i < joydev->nkey; i++) 346 data.buttons |= 347 test_bit(joydev->keypam[i], input->key) ? (1 << i) : 0; 348 data.x = (joydev->abs[0] / 256 + 128) >> joydev->glue.JS_CORR.x; 349 data.y = (joydev->abs[1] / 256 + 128) >> joydev->glue.JS_CORR.y; 350 351 /* 352 * Reset reader's event queue 353 */ 354 spin_lock(&client->buffer_lock); 355 client->startup = 0; 356 client->tail = client->head; 357 spin_unlock(&client->buffer_lock); 358 359 spin_unlock_irq(&input->event_lock); 360 361 if (copy_to_user(buf, &data, sizeof(struct JS_DATA_TYPE))) 362 return -EFAULT; 363 364 return sizeof(struct JS_DATA_TYPE); 365 } 366 367 static inline int joydev_data_pending(struct joydev_client *client) 368 { 369 struct joydev *joydev = client->joydev; 370 371 return client->startup < joydev->nabs + joydev->nkey || 372 client->head != client->tail; 373 } 374 375 static ssize_t joydev_read(struct file *file, char __user *buf, 376 size_t count, loff_t *ppos) 377 { 378 struct joydev_client *client = file->private_data; 379 struct joydev *joydev = client->joydev; 380 struct input_dev *input = joydev->handle.dev; 381 struct js_event event; 382 int retval; 383 384 if (!joydev->exist) 385 return -ENODEV; 386 387 if (count < sizeof(struct js_event)) 388 return -EINVAL; 389 390 if (count == sizeof(struct JS_DATA_TYPE)) 391 return joydev_0x_read(client, input, buf); 392 393 if (!joydev_data_pending(client) && (file->f_flags & O_NONBLOCK)) 394 return -EAGAIN; 395 396 retval = wait_event_interruptible(joydev->wait, 397 !joydev->exist || joydev_data_pending(client)); 398 if (retval) 399 return retval; 400 401 if (!joydev->exist) 402 return -ENODEV; 403 404 while (retval + sizeof(struct js_event) <= count && 405 joydev_generate_startup_event(client, input, &event)) { 406 407 if (copy_to_user(buf + retval, &event, sizeof(struct js_event))) 408 return -EFAULT; 409 410 retval += sizeof(struct js_event); 411 } 412 413 while (retval + sizeof(struct js_event) <= count && 414 joydev_fetch_next_event(client, &event)) { 415 416 if (copy_to_user(buf + retval, &event, sizeof(struct js_event))) 417 return -EFAULT; 418 419 retval += sizeof(struct js_event); 420 } 421 422 return retval; 423 } 424 425 /* No kernel lock - fine */ 426 static unsigned int joydev_poll(struct file *file, poll_table *wait) 427 { 428 struct joydev_client *client = file->private_data; 429 struct joydev *joydev = client->joydev; 430 431 poll_wait(file, &joydev->wait, wait); 432 return (joydev_data_pending(client) ? (POLLIN | POLLRDNORM) : 0) | 433 (joydev->exist ? 0 : (POLLHUP | POLLERR)); 434 } 435 436 static int joydev_handle_JSIOCSAXMAP(struct joydev *joydev, 437 void __user *argp, size_t len) 438 { 439 __u8 *abspam; 440 int i; 441 int retval = 0; 442 443 len = min(len, sizeof(joydev->abspam)); 444 445 /* Validate the map. */ 446 abspam = memdup_user(argp, len); 447 if (IS_ERR(abspam)) 448 return PTR_ERR(abspam); 449 450 for (i = 0; i < joydev->nabs; i++) { 451 if (abspam[i] > ABS_MAX) { 452 retval = -EINVAL; 453 goto out; 454 } 455 } 456 457 memcpy(joydev->abspam, abspam, len); 458 459 for (i = 0; i < joydev->nabs; i++) 460 joydev->absmap[joydev->abspam[i]] = i; 461 462 out: 463 kfree(abspam); 464 return retval; 465 } 466 467 static int joydev_handle_JSIOCSBTNMAP(struct joydev *joydev, 468 void __user *argp, size_t len) 469 { 470 __u16 *keypam; 471 int i; 472 int retval = 0; 473 474 len = min(len, sizeof(joydev->keypam)); 475 476 /* Validate the map. */ 477 keypam = memdup_user(argp, len); 478 if (IS_ERR(keypam)) 479 return PTR_ERR(keypam); 480 481 for (i = 0; i < joydev->nkey; i++) { 482 if (keypam[i] > KEY_MAX || keypam[i] < BTN_MISC) { 483 retval = -EINVAL; 484 goto out; 485 } 486 } 487 488 memcpy(joydev->keypam, keypam, len); 489 490 for (i = 0; i < joydev->nkey; i++) 491 joydev->keymap[keypam[i] - BTN_MISC] = i; 492 493 out: 494 kfree(keypam); 495 return retval; 496 } 497 498 499 static int joydev_ioctl_common(struct joydev *joydev, 500 unsigned int cmd, void __user *argp) 501 { 502 struct input_dev *dev = joydev->handle.dev; 503 size_t len; 504 int i; 505 const char *name; 506 507 /* Process fixed-sized commands. */ 508 switch (cmd) { 509 510 case JS_SET_CAL: 511 return copy_from_user(&joydev->glue.JS_CORR, argp, 512 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 513 514 case JS_GET_CAL: 515 return copy_to_user(argp, &joydev->glue.JS_CORR, 516 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 517 518 case JS_SET_TIMEOUT: 519 return get_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 520 521 case JS_GET_TIMEOUT: 522 return put_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 523 524 case JSIOCGVERSION: 525 return put_user(JS_VERSION, (__u32 __user *) argp); 526 527 case JSIOCGAXES: 528 return put_user(joydev->nabs, (__u8 __user *) argp); 529 530 case JSIOCGBUTTONS: 531 return put_user(joydev->nkey, (__u8 __user *) argp); 532 533 case JSIOCSCORR: 534 if (copy_from_user(joydev->corr, argp, 535 sizeof(joydev->corr[0]) * joydev->nabs)) 536 return -EFAULT; 537 538 for (i = 0; i < joydev->nabs; i++) { 539 int val = input_abs_get_val(dev, joydev->abspam[i]); 540 joydev->abs[i] = joydev_correct(val, &joydev->corr[i]); 541 } 542 return 0; 543 544 case JSIOCGCORR: 545 return copy_to_user(argp, joydev->corr, 546 sizeof(joydev->corr[0]) * joydev->nabs) ? -EFAULT : 0; 547 548 } 549 550 /* 551 * Process variable-sized commands (the axis and button map commands 552 * are considered variable-sized to decouple them from the values of 553 * ABS_MAX and KEY_MAX). 554 */ 555 switch (cmd & ~IOCSIZE_MASK) { 556 557 case (JSIOCSAXMAP & ~IOCSIZE_MASK): 558 return joydev_handle_JSIOCSAXMAP(joydev, argp, _IOC_SIZE(cmd)); 559 560 case (JSIOCGAXMAP & ~IOCSIZE_MASK): 561 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->abspam)); 562 return copy_to_user(argp, joydev->abspam, len) ? -EFAULT : len; 563 564 case (JSIOCSBTNMAP & ~IOCSIZE_MASK): 565 return joydev_handle_JSIOCSBTNMAP(joydev, argp, _IOC_SIZE(cmd)); 566 567 case (JSIOCGBTNMAP & ~IOCSIZE_MASK): 568 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->keypam)); 569 return copy_to_user(argp, joydev->keypam, len) ? -EFAULT : len; 570 571 case JSIOCGNAME(0): 572 name = dev->name; 573 if (!name) 574 return 0; 575 576 len = min_t(size_t, _IOC_SIZE(cmd), strlen(name) + 1); 577 return copy_to_user(argp, name, len) ? -EFAULT : len; 578 } 579 580 return -EINVAL; 581 } 582 583 #ifdef CONFIG_COMPAT 584 static long joydev_compat_ioctl(struct file *file, 585 unsigned int cmd, unsigned long arg) 586 { 587 struct joydev_client *client = file->private_data; 588 struct joydev *joydev = client->joydev; 589 void __user *argp = (void __user *)arg; 590 s32 tmp32; 591 struct JS_DATA_SAVE_TYPE_32 ds32; 592 int retval; 593 594 retval = mutex_lock_interruptible(&joydev->mutex); 595 if (retval) 596 return retval; 597 598 if (!joydev->exist) { 599 retval = -ENODEV; 600 goto out; 601 } 602 603 switch (cmd) { 604 605 case JS_SET_TIMELIMIT: 606 retval = get_user(tmp32, (s32 __user *) arg); 607 if (retval == 0) 608 joydev->glue.JS_TIMELIMIT = tmp32; 609 break; 610 611 case JS_GET_TIMELIMIT: 612 tmp32 = joydev->glue.JS_TIMELIMIT; 613 retval = put_user(tmp32, (s32 __user *) arg); 614 break; 615 616 case JS_SET_ALL: 617 retval = copy_from_user(&ds32, argp, 618 sizeof(ds32)) ? -EFAULT : 0; 619 if (retval == 0) { 620 joydev->glue.JS_TIMEOUT = ds32.JS_TIMEOUT; 621 joydev->glue.BUSY = ds32.BUSY; 622 joydev->glue.JS_EXPIRETIME = ds32.JS_EXPIRETIME; 623 joydev->glue.JS_TIMELIMIT = ds32.JS_TIMELIMIT; 624 joydev->glue.JS_SAVE = ds32.JS_SAVE; 625 joydev->glue.JS_CORR = ds32.JS_CORR; 626 } 627 break; 628 629 case JS_GET_ALL: 630 ds32.JS_TIMEOUT = joydev->glue.JS_TIMEOUT; 631 ds32.BUSY = joydev->glue.BUSY; 632 ds32.JS_EXPIRETIME = joydev->glue.JS_EXPIRETIME; 633 ds32.JS_TIMELIMIT = joydev->glue.JS_TIMELIMIT; 634 ds32.JS_SAVE = joydev->glue.JS_SAVE; 635 ds32.JS_CORR = joydev->glue.JS_CORR; 636 637 retval = copy_to_user(argp, &ds32, sizeof(ds32)) ? -EFAULT : 0; 638 break; 639 640 default: 641 retval = joydev_ioctl_common(joydev, cmd, argp); 642 break; 643 } 644 645 out: 646 mutex_unlock(&joydev->mutex); 647 return retval; 648 } 649 #endif /* CONFIG_COMPAT */ 650 651 static long joydev_ioctl(struct file *file, 652 unsigned int cmd, unsigned long arg) 653 { 654 struct joydev_client *client = file->private_data; 655 struct joydev *joydev = client->joydev; 656 void __user *argp = (void __user *)arg; 657 int retval; 658 659 retval = mutex_lock_interruptible(&joydev->mutex); 660 if (retval) 661 return retval; 662 663 if (!joydev->exist) { 664 retval = -ENODEV; 665 goto out; 666 } 667 668 switch (cmd) { 669 670 case JS_SET_TIMELIMIT: 671 retval = get_user(joydev->glue.JS_TIMELIMIT, 672 (long __user *) arg); 673 break; 674 675 case JS_GET_TIMELIMIT: 676 retval = put_user(joydev->glue.JS_TIMELIMIT, 677 (long __user *) arg); 678 break; 679 680 case JS_SET_ALL: 681 retval = copy_from_user(&joydev->glue, argp, 682 sizeof(joydev->glue)) ? -EFAULT : 0; 683 break; 684 685 case JS_GET_ALL: 686 retval = copy_to_user(argp, &joydev->glue, 687 sizeof(joydev->glue)) ? -EFAULT : 0; 688 break; 689 690 default: 691 retval = joydev_ioctl_common(joydev, cmd, argp); 692 break; 693 } 694 out: 695 mutex_unlock(&joydev->mutex); 696 return retval; 697 } 698 699 static const struct file_operations joydev_fops = { 700 .owner = THIS_MODULE, 701 .read = joydev_read, 702 .poll = joydev_poll, 703 .open = joydev_open, 704 .release = joydev_release, 705 .unlocked_ioctl = joydev_ioctl, 706 #ifdef CONFIG_COMPAT 707 .compat_ioctl = joydev_compat_ioctl, 708 #endif 709 .fasync = joydev_fasync, 710 .llseek = no_llseek, 711 }; 712 713 /* 714 * Mark device non-existent. This disables writes, ioctls and 715 * prevents new users from opening the device. Already posted 716 * blocking reads will stay, however new ones will fail. 717 */ 718 static void joydev_mark_dead(struct joydev *joydev) 719 { 720 mutex_lock(&joydev->mutex); 721 joydev->exist = false; 722 mutex_unlock(&joydev->mutex); 723 } 724 725 static void joydev_cleanup(struct joydev *joydev) 726 { 727 struct input_handle *handle = &joydev->handle; 728 729 joydev_mark_dead(joydev); 730 joydev_hangup(joydev); 731 732 cdev_del(&joydev->cdev); 733 734 /* joydev is marked dead so no one else accesses joydev->open */ 735 if (joydev->open) 736 input_close_device(handle); 737 } 738 739 static bool joydev_dev_is_absolute_mouse(struct input_dev *dev) 740 { 741 DECLARE_BITMAP(jd_scratch, KEY_CNT); 742 743 BUILD_BUG_ON(ABS_CNT > KEY_CNT || EV_CNT > KEY_CNT); 744 745 /* 746 * Virtualization (VMware, etc) and remote management (HP 747 * ILO2) solutions use absolute coordinates for their virtual 748 * pointing devices so that there is one-to-one relationship 749 * between pointer position on the host screen and virtual 750 * guest screen, and so their mice use ABS_X, ABS_Y and 3 751 * primary button events. This clashes with what joydev 752 * considers to be joysticks (a device with at minimum ABS_X 753 * axis). 754 * 755 * Here we are trying to separate absolute mice from 756 * joysticks. A device is, for joystick detection purposes, 757 * considered to be an absolute mouse if the following is 758 * true: 759 * 760 * 1) Event types are exactly EV_ABS, EV_KEY and EV_SYN. 761 * 2) Absolute events are exactly ABS_X and ABS_Y. 762 * 3) Keys are exactly BTN_LEFT, BTN_RIGHT and BTN_MIDDLE. 763 * 4) Device is not on "Amiga" bus. 764 */ 765 766 bitmap_zero(jd_scratch, EV_CNT); 767 __set_bit(EV_ABS, jd_scratch); 768 __set_bit(EV_KEY, jd_scratch); 769 __set_bit(EV_SYN, jd_scratch); 770 if (!bitmap_equal(jd_scratch, dev->evbit, EV_CNT)) 771 return false; 772 773 bitmap_zero(jd_scratch, ABS_CNT); 774 __set_bit(ABS_X, jd_scratch); 775 __set_bit(ABS_Y, jd_scratch); 776 if (!bitmap_equal(dev->absbit, jd_scratch, ABS_CNT)) 777 return false; 778 779 bitmap_zero(jd_scratch, KEY_CNT); 780 __set_bit(BTN_LEFT, jd_scratch); 781 __set_bit(BTN_RIGHT, jd_scratch); 782 __set_bit(BTN_MIDDLE, jd_scratch); 783 784 if (!bitmap_equal(dev->keybit, jd_scratch, KEY_CNT)) 785 return false; 786 787 /* 788 * Amiga joystick (amijoy) historically uses left/middle/right 789 * button events. 790 */ 791 if (dev->id.bustype == BUS_AMIGA) 792 return false; 793 794 return true; 795 } 796 797 static bool joydev_match(struct input_handler *handler, struct input_dev *dev) 798 { 799 /* Avoid touchpads and touchscreens */ 800 if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_TOUCH, dev->keybit)) 801 return false; 802 803 /* Avoid tablets, digitisers and similar devices */ 804 if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_DIGI, dev->keybit)) 805 return false; 806 807 /* Avoid absolute mice */ 808 if (joydev_dev_is_absolute_mouse(dev)) 809 return false; 810 811 return true; 812 } 813 814 static int joydev_connect(struct input_handler *handler, struct input_dev *dev, 815 const struct input_device_id *id) 816 { 817 struct joydev *joydev; 818 int i, j, t, minor, dev_no; 819 int error; 820 821 minor = input_get_new_minor(JOYDEV_MINOR_BASE, JOYDEV_MINORS, true); 822 if (minor < 0) { 823 error = minor; 824 pr_err("failed to reserve new minor: %d\n", error); 825 return error; 826 } 827 828 joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL); 829 if (!joydev) { 830 error = -ENOMEM; 831 goto err_free_minor; 832 } 833 834 INIT_LIST_HEAD(&joydev->client_list); 835 spin_lock_init(&joydev->client_lock); 836 mutex_init(&joydev->mutex); 837 init_waitqueue_head(&joydev->wait); 838 joydev->exist = true; 839 840 dev_no = minor; 841 /* Normalize device number if it falls into legacy range */ 842 if (dev_no < JOYDEV_MINOR_BASE + JOYDEV_MINORS) 843 dev_no -= JOYDEV_MINOR_BASE; 844 dev_set_name(&joydev->dev, "js%d", dev_no); 845 846 joydev->handle.dev = input_get_device(dev); 847 joydev->handle.name = dev_name(&joydev->dev); 848 joydev->handle.handler = handler; 849 joydev->handle.private = joydev; 850 851 for_each_set_bit(i, dev->absbit, ABS_CNT) { 852 joydev->absmap[i] = joydev->nabs; 853 joydev->abspam[joydev->nabs] = i; 854 joydev->nabs++; 855 } 856 857 for (i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++) 858 if (test_bit(i + BTN_MISC, dev->keybit)) { 859 joydev->keymap[i] = joydev->nkey; 860 joydev->keypam[joydev->nkey] = i + BTN_MISC; 861 joydev->nkey++; 862 } 863 864 for (i = 0; i < BTN_JOYSTICK - BTN_MISC; i++) 865 if (test_bit(i + BTN_MISC, dev->keybit)) { 866 joydev->keymap[i] = joydev->nkey; 867 joydev->keypam[joydev->nkey] = i + BTN_MISC; 868 joydev->nkey++; 869 } 870 871 for (i = 0; i < joydev->nabs; i++) { 872 j = joydev->abspam[i]; 873 if (input_abs_get_max(dev, j) == input_abs_get_min(dev, j)) { 874 joydev->corr[i].type = JS_CORR_NONE; 875 joydev->abs[i] = input_abs_get_val(dev, j); 876 continue; 877 } 878 joydev->corr[i].type = JS_CORR_BROKEN; 879 joydev->corr[i].prec = input_abs_get_fuzz(dev, j); 880 881 t = (input_abs_get_max(dev, j) + input_abs_get_min(dev, j)) / 2; 882 joydev->corr[i].coef[0] = t - input_abs_get_flat(dev, j); 883 joydev->corr[i].coef[1] = t + input_abs_get_flat(dev, j); 884 885 t = (input_abs_get_max(dev, j) - input_abs_get_min(dev, j)) / 2 886 - 2 * input_abs_get_flat(dev, j); 887 if (t) { 888 joydev->corr[i].coef[2] = (1 << 29) / t; 889 joydev->corr[i].coef[3] = (1 << 29) / t; 890 891 joydev->abs[i] = 892 joydev_correct(input_abs_get_val(dev, j), 893 joydev->corr + i); 894 } 895 } 896 897 joydev->dev.devt = MKDEV(INPUT_MAJOR, minor); 898 joydev->dev.class = &input_class; 899 joydev->dev.parent = &dev->dev; 900 joydev->dev.release = joydev_free; 901 device_initialize(&joydev->dev); 902 903 error = input_register_handle(&joydev->handle); 904 if (error) 905 goto err_free_joydev; 906 907 cdev_init(&joydev->cdev, &joydev_fops); 908 joydev->cdev.kobj.parent = &joydev->dev.kobj; 909 error = cdev_add(&joydev->cdev, joydev->dev.devt, 1); 910 if (error) 911 goto err_unregister_handle; 912 913 error = device_add(&joydev->dev); 914 if (error) 915 goto err_cleanup_joydev; 916 917 return 0; 918 919 err_cleanup_joydev: 920 joydev_cleanup(joydev); 921 err_unregister_handle: 922 input_unregister_handle(&joydev->handle); 923 err_free_joydev: 924 put_device(&joydev->dev); 925 err_free_minor: 926 input_free_minor(minor); 927 return error; 928 } 929 930 static void joydev_disconnect(struct input_handle *handle) 931 { 932 struct joydev *joydev = handle->private; 933 934 device_del(&joydev->dev); 935 joydev_cleanup(joydev); 936 input_free_minor(MINOR(joydev->dev.devt)); 937 input_unregister_handle(handle); 938 put_device(&joydev->dev); 939 } 940 941 static const struct input_device_id joydev_ids[] = { 942 { 943 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 944 INPUT_DEVICE_ID_MATCH_ABSBIT, 945 .evbit = { BIT_MASK(EV_ABS) }, 946 .absbit = { BIT_MASK(ABS_X) }, 947 }, 948 { 949 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 950 INPUT_DEVICE_ID_MATCH_ABSBIT, 951 .evbit = { BIT_MASK(EV_ABS) }, 952 .absbit = { BIT_MASK(ABS_Z) }, 953 }, 954 { 955 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 956 INPUT_DEVICE_ID_MATCH_ABSBIT, 957 .evbit = { BIT_MASK(EV_ABS) }, 958 .absbit = { BIT_MASK(ABS_WHEEL) }, 959 }, 960 { 961 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 962 INPUT_DEVICE_ID_MATCH_ABSBIT, 963 .evbit = { BIT_MASK(EV_ABS) }, 964 .absbit = { BIT_MASK(ABS_THROTTLE) }, 965 }, 966 { 967 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 968 INPUT_DEVICE_ID_MATCH_KEYBIT, 969 .evbit = { BIT_MASK(EV_KEY) }, 970 .keybit = {[BIT_WORD(BTN_JOYSTICK)] = BIT_MASK(BTN_JOYSTICK) }, 971 }, 972 { 973 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 974 INPUT_DEVICE_ID_MATCH_KEYBIT, 975 .evbit = { BIT_MASK(EV_KEY) }, 976 .keybit = { [BIT_WORD(BTN_GAMEPAD)] = BIT_MASK(BTN_GAMEPAD) }, 977 }, 978 { 979 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 980 INPUT_DEVICE_ID_MATCH_KEYBIT, 981 .evbit = { BIT_MASK(EV_KEY) }, 982 .keybit = { [BIT_WORD(BTN_TRIGGER_HAPPY)] = BIT_MASK(BTN_TRIGGER_HAPPY) }, 983 }, 984 { } /* Terminating entry */ 985 }; 986 987 MODULE_DEVICE_TABLE(input, joydev_ids); 988 989 static struct input_handler joydev_handler = { 990 .event = joydev_event, 991 .match = joydev_match, 992 .connect = joydev_connect, 993 .disconnect = joydev_disconnect, 994 .legacy_minors = true, 995 .minor = JOYDEV_MINOR_BASE, 996 .name = "joydev", 997 .id_table = joydev_ids, 998 }; 999 1000 static int __init joydev_init(void) 1001 { 1002 return input_register_handler(&joydev_handler); 1003 } 1004 1005 static void __exit joydev_exit(void) 1006 { 1007 input_unregister_handler(&joydev_handler); 1008 } 1009 1010 module_init(joydev_init); 1011 module_exit(joydev_exit); 1012