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