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 <vojtech@ucw.cz>"); 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 return PTR_ERR(abspam); 450 451 for (i = 0; i < joydev->nabs; i++) { 452 if (abspam[i] > ABS_MAX) { 453 retval = -EINVAL; 454 goto out; 455 } 456 } 457 458 memcpy(joydev->abspam, abspam, len); 459 460 for (i = 0; i < joydev->nabs; i++) 461 joydev->absmap[joydev->abspam[i]] = i; 462 463 out: 464 kfree(abspam); 465 return retval; 466 } 467 468 static int joydev_handle_JSIOCSBTNMAP(struct joydev *joydev, 469 void __user *argp, size_t len) 470 { 471 __u16 *keypam; 472 int i; 473 int retval = 0; 474 475 len = min(len, sizeof(joydev->keypam)); 476 477 /* Validate the map. */ 478 keypam = memdup_user(argp, len); 479 if (IS_ERR(keypam)) 480 return PTR_ERR(keypam); 481 482 for (i = 0; i < joydev->nkey; i++) { 483 if (keypam[i] > KEY_MAX || keypam[i] < BTN_MISC) { 484 retval = -EINVAL; 485 goto out; 486 } 487 } 488 489 memcpy(joydev->keypam, keypam, len); 490 491 for (i = 0; i < joydev->nkey; i++) 492 joydev->keymap[keypam[i] - BTN_MISC] = i; 493 494 out: 495 kfree(keypam); 496 return retval; 497 } 498 499 500 static int joydev_ioctl_common(struct joydev *joydev, 501 unsigned int cmd, void __user *argp) 502 { 503 struct input_dev *dev = joydev->handle.dev; 504 size_t len; 505 int i; 506 const char *name; 507 508 /* Process fixed-sized commands. */ 509 switch (cmd) { 510 511 case JS_SET_CAL: 512 return copy_from_user(&joydev->glue.JS_CORR, argp, 513 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 514 515 case JS_GET_CAL: 516 return copy_to_user(argp, &joydev->glue.JS_CORR, 517 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 518 519 case JS_SET_TIMEOUT: 520 return get_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 521 522 case JS_GET_TIMEOUT: 523 return put_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 524 525 case JSIOCGVERSION: 526 return put_user(JS_VERSION, (__u32 __user *) argp); 527 528 case JSIOCGAXES: 529 return put_user(joydev->nabs, (__u8 __user *) argp); 530 531 case JSIOCGBUTTONS: 532 return put_user(joydev->nkey, (__u8 __user *) argp); 533 534 case JSIOCSCORR: 535 if (copy_from_user(joydev->corr, argp, 536 sizeof(joydev->corr[0]) * joydev->nabs)) 537 return -EFAULT; 538 539 for (i = 0; i < joydev->nabs; i++) { 540 int val = input_abs_get_val(dev, joydev->abspam[i]); 541 joydev->abs[i] = joydev_correct(val, &joydev->corr[i]); 542 } 543 return 0; 544 545 case JSIOCGCORR: 546 return copy_to_user(argp, joydev->corr, 547 sizeof(joydev->corr[0]) * joydev->nabs) ? -EFAULT : 0; 548 549 } 550 551 /* 552 * Process variable-sized commands (the axis and button map commands 553 * are considered variable-sized to decouple them from the values of 554 * ABS_MAX and KEY_MAX). 555 */ 556 switch (cmd & ~IOCSIZE_MASK) { 557 558 case (JSIOCSAXMAP & ~IOCSIZE_MASK): 559 return joydev_handle_JSIOCSAXMAP(joydev, argp, _IOC_SIZE(cmd)); 560 561 case (JSIOCGAXMAP & ~IOCSIZE_MASK): 562 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->abspam)); 563 return copy_to_user(argp, joydev->abspam, len) ? -EFAULT : len; 564 565 case (JSIOCSBTNMAP & ~IOCSIZE_MASK): 566 return joydev_handle_JSIOCSBTNMAP(joydev, argp, _IOC_SIZE(cmd)); 567 568 case (JSIOCGBTNMAP & ~IOCSIZE_MASK): 569 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->keypam)); 570 return copy_to_user(argp, joydev->keypam, len) ? -EFAULT : len; 571 572 case JSIOCGNAME(0): 573 name = dev->name; 574 if (!name) 575 return 0; 576 577 len = min_t(size_t, _IOC_SIZE(cmd), strlen(name) + 1); 578 return copy_to_user(argp, name, len) ? -EFAULT : len; 579 } 580 581 return -EINVAL; 582 } 583 584 #ifdef CONFIG_COMPAT 585 static long joydev_compat_ioctl(struct file *file, 586 unsigned int cmd, unsigned long arg) 587 { 588 struct joydev_client *client = file->private_data; 589 struct joydev *joydev = client->joydev; 590 void __user *argp = (void __user *)arg; 591 s32 tmp32; 592 struct JS_DATA_SAVE_TYPE_32 ds32; 593 int retval; 594 595 retval = mutex_lock_interruptible(&joydev->mutex); 596 if (retval) 597 return retval; 598 599 if (!joydev->exist) { 600 retval = -ENODEV; 601 goto out; 602 } 603 604 switch (cmd) { 605 606 case JS_SET_TIMELIMIT: 607 retval = get_user(tmp32, (s32 __user *) arg); 608 if (retval == 0) 609 joydev->glue.JS_TIMELIMIT = tmp32; 610 break; 611 612 case JS_GET_TIMELIMIT: 613 tmp32 = joydev->glue.JS_TIMELIMIT; 614 retval = put_user(tmp32, (s32 __user *) arg); 615 break; 616 617 case JS_SET_ALL: 618 retval = copy_from_user(&ds32, argp, 619 sizeof(ds32)) ? -EFAULT : 0; 620 if (retval == 0) { 621 joydev->glue.JS_TIMEOUT = ds32.JS_TIMEOUT; 622 joydev->glue.BUSY = ds32.BUSY; 623 joydev->glue.JS_EXPIRETIME = ds32.JS_EXPIRETIME; 624 joydev->glue.JS_TIMELIMIT = ds32.JS_TIMELIMIT; 625 joydev->glue.JS_SAVE = ds32.JS_SAVE; 626 joydev->glue.JS_CORR = ds32.JS_CORR; 627 } 628 break; 629 630 case JS_GET_ALL: 631 ds32.JS_TIMEOUT = joydev->glue.JS_TIMEOUT; 632 ds32.BUSY = joydev->glue.BUSY; 633 ds32.JS_EXPIRETIME = joydev->glue.JS_EXPIRETIME; 634 ds32.JS_TIMELIMIT = joydev->glue.JS_TIMELIMIT; 635 ds32.JS_SAVE = joydev->glue.JS_SAVE; 636 ds32.JS_CORR = joydev->glue.JS_CORR; 637 638 retval = copy_to_user(argp, &ds32, sizeof(ds32)) ? -EFAULT : 0; 639 break; 640 641 default: 642 retval = joydev_ioctl_common(joydev, cmd, argp); 643 break; 644 } 645 646 out: 647 mutex_unlock(&joydev->mutex); 648 return retval; 649 } 650 #endif /* CONFIG_COMPAT */ 651 652 static long joydev_ioctl(struct file *file, 653 unsigned int cmd, unsigned long arg) 654 { 655 struct joydev_client *client = file->private_data; 656 struct joydev *joydev = client->joydev; 657 void __user *argp = (void __user *)arg; 658 int retval; 659 660 retval = mutex_lock_interruptible(&joydev->mutex); 661 if (retval) 662 return retval; 663 664 if (!joydev->exist) { 665 retval = -ENODEV; 666 goto out; 667 } 668 669 switch (cmd) { 670 671 case JS_SET_TIMELIMIT: 672 retval = get_user(joydev->glue.JS_TIMELIMIT, 673 (long __user *) arg); 674 break; 675 676 case JS_GET_TIMELIMIT: 677 retval = put_user(joydev->glue.JS_TIMELIMIT, 678 (long __user *) arg); 679 break; 680 681 case JS_SET_ALL: 682 retval = copy_from_user(&joydev->glue, argp, 683 sizeof(joydev->glue)) ? -EFAULT : 0; 684 break; 685 686 case JS_GET_ALL: 687 retval = copy_to_user(argp, &joydev->glue, 688 sizeof(joydev->glue)) ? -EFAULT : 0; 689 break; 690 691 default: 692 retval = joydev_ioctl_common(joydev, cmd, argp); 693 break; 694 } 695 out: 696 mutex_unlock(&joydev->mutex); 697 return retval; 698 } 699 700 static const struct file_operations joydev_fops = { 701 .owner = THIS_MODULE, 702 .read = joydev_read, 703 .poll = joydev_poll, 704 .open = joydev_open, 705 .release = joydev_release, 706 .unlocked_ioctl = joydev_ioctl, 707 #ifdef CONFIG_COMPAT 708 .compat_ioctl = joydev_compat_ioctl, 709 #endif 710 .fasync = joydev_fasync, 711 .llseek = no_llseek, 712 }; 713 714 /* 715 * Mark device non-existent. This disables writes, ioctls and 716 * prevents new users from opening the device. Already posted 717 * blocking reads will stay, however new ones will fail. 718 */ 719 static void joydev_mark_dead(struct joydev *joydev) 720 { 721 mutex_lock(&joydev->mutex); 722 joydev->exist = false; 723 mutex_unlock(&joydev->mutex); 724 } 725 726 static void joydev_cleanup(struct joydev *joydev) 727 { 728 struct input_handle *handle = &joydev->handle; 729 730 joydev_mark_dead(joydev); 731 joydev_hangup(joydev); 732 733 cdev_del(&joydev->cdev); 734 735 /* joydev is marked dead so no one else accesses joydev->open */ 736 if (joydev->open) 737 input_close_device(handle); 738 } 739 740 static bool joydev_dev_is_absolute_mouse(struct input_dev *dev) 741 { 742 DECLARE_BITMAP(jd_scratch, KEY_CNT); 743 744 BUILD_BUG_ON(ABS_CNT > KEY_CNT || EV_CNT > KEY_CNT); 745 746 /* 747 * Virtualization (VMware, etc) and remote management (HP 748 * ILO2) solutions use absolute coordinates for their virtual 749 * pointing devices so that there is one-to-one relationship 750 * between pointer position on the host screen and virtual 751 * guest screen, and so their mice use ABS_X, ABS_Y and 3 752 * primary button events. This clashes with what joydev 753 * considers to be joysticks (a device with at minimum ABS_X 754 * axis). 755 * 756 * Here we are trying to separate absolute mice from 757 * joysticks. A device is, for joystick detection purposes, 758 * considered to be an absolute mouse if the following is 759 * true: 760 * 761 * 1) Event types are exactly EV_ABS, EV_KEY and EV_SYN. 762 * 2) Absolute events are exactly ABS_X and ABS_Y. 763 * 3) Keys are exactly BTN_LEFT, BTN_RIGHT and BTN_MIDDLE. 764 * 4) Device is not on "Amiga" bus. 765 */ 766 767 bitmap_zero(jd_scratch, EV_CNT); 768 __set_bit(EV_ABS, jd_scratch); 769 __set_bit(EV_KEY, jd_scratch); 770 __set_bit(EV_SYN, jd_scratch); 771 if (!bitmap_equal(jd_scratch, dev->evbit, EV_CNT)) 772 return false; 773 774 bitmap_zero(jd_scratch, ABS_CNT); 775 __set_bit(ABS_X, jd_scratch); 776 __set_bit(ABS_Y, jd_scratch); 777 if (!bitmap_equal(dev->absbit, jd_scratch, ABS_CNT)) 778 return false; 779 780 bitmap_zero(jd_scratch, KEY_CNT); 781 __set_bit(BTN_LEFT, jd_scratch); 782 __set_bit(BTN_RIGHT, jd_scratch); 783 __set_bit(BTN_MIDDLE, jd_scratch); 784 785 if (!bitmap_equal(dev->keybit, jd_scratch, KEY_CNT)) 786 return false; 787 788 /* 789 * Amiga joystick (amijoy) historically uses left/middle/right 790 * button events. 791 */ 792 if (dev->id.bustype == BUS_AMIGA) 793 return false; 794 795 return true; 796 } 797 798 static bool joydev_match(struct input_handler *handler, struct input_dev *dev) 799 { 800 /* Avoid touchpads and touchscreens */ 801 if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_TOUCH, dev->keybit)) 802 return false; 803 804 /* Avoid tablets, digitisers and similar devices */ 805 if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_DIGI, dev->keybit)) 806 return false; 807 808 /* Avoid absolute mice */ 809 if (joydev_dev_is_absolute_mouse(dev)) 810 return false; 811 812 return true; 813 } 814 815 static int joydev_connect(struct input_handler *handler, struct input_dev *dev, 816 const struct input_device_id *id) 817 { 818 struct joydev *joydev; 819 int i, j, t, minor, dev_no; 820 int error; 821 822 minor = input_get_new_minor(JOYDEV_MINOR_BASE, JOYDEV_MINORS, true); 823 if (minor < 0) { 824 error = minor; 825 pr_err("failed to reserve new minor: %d\n", error); 826 return error; 827 } 828 829 joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL); 830 if (!joydev) { 831 error = -ENOMEM; 832 goto err_free_minor; 833 } 834 835 INIT_LIST_HEAD(&joydev->client_list); 836 spin_lock_init(&joydev->client_lock); 837 mutex_init(&joydev->mutex); 838 init_waitqueue_head(&joydev->wait); 839 joydev->exist = true; 840 841 dev_no = minor; 842 /* Normalize device number if it falls into legacy range */ 843 if (dev_no < JOYDEV_MINOR_BASE + JOYDEV_MINORS) 844 dev_no -= JOYDEV_MINOR_BASE; 845 dev_set_name(&joydev->dev, "js%d", dev_no); 846 847 joydev->handle.dev = input_get_device(dev); 848 joydev->handle.name = dev_name(&joydev->dev); 849 joydev->handle.handler = handler; 850 joydev->handle.private = joydev; 851 852 for_each_set_bit(i, dev->absbit, ABS_CNT) { 853 joydev->absmap[i] = joydev->nabs; 854 joydev->abspam[joydev->nabs] = i; 855 joydev->nabs++; 856 } 857 858 for (i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++) 859 if (test_bit(i + BTN_MISC, dev->keybit)) { 860 joydev->keymap[i] = joydev->nkey; 861 joydev->keypam[joydev->nkey] = i + BTN_MISC; 862 joydev->nkey++; 863 } 864 865 for (i = 0; i < BTN_JOYSTICK - BTN_MISC; i++) 866 if (test_bit(i + BTN_MISC, dev->keybit)) { 867 joydev->keymap[i] = joydev->nkey; 868 joydev->keypam[joydev->nkey] = i + BTN_MISC; 869 joydev->nkey++; 870 } 871 872 for (i = 0; i < joydev->nabs; i++) { 873 j = joydev->abspam[i]; 874 if (input_abs_get_max(dev, j) == input_abs_get_min(dev, j)) { 875 joydev->corr[i].type = JS_CORR_NONE; 876 joydev->abs[i] = input_abs_get_val(dev, j); 877 continue; 878 } 879 joydev->corr[i].type = JS_CORR_BROKEN; 880 joydev->corr[i].prec = input_abs_get_fuzz(dev, j); 881 882 t = (input_abs_get_max(dev, j) + input_abs_get_min(dev, j)) / 2; 883 joydev->corr[i].coef[0] = t - input_abs_get_flat(dev, j); 884 joydev->corr[i].coef[1] = t + input_abs_get_flat(dev, j); 885 886 t = (input_abs_get_max(dev, j) - input_abs_get_min(dev, j)) / 2 887 - 2 * input_abs_get_flat(dev, j); 888 if (t) { 889 joydev->corr[i].coef[2] = (1 << 29) / t; 890 joydev->corr[i].coef[3] = (1 << 29) / t; 891 892 joydev->abs[i] = 893 joydev_correct(input_abs_get_val(dev, j), 894 joydev->corr + i); 895 } 896 } 897 898 joydev->dev.devt = MKDEV(INPUT_MAJOR, minor); 899 joydev->dev.class = &input_class; 900 joydev->dev.parent = &dev->dev; 901 joydev->dev.release = joydev_free; 902 device_initialize(&joydev->dev); 903 904 error = input_register_handle(&joydev->handle); 905 if (error) 906 goto err_free_joydev; 907 908 cdev_init(&joydev->cdev, &joydev_fops); 909 joydev->cdev.kobj.parent = &joydev->dev.kobj; 910 error = cdev_add(&joydev->cdev, joydev->dev.devt, 1); 911 if (error) 912 goto err_unregister_handle; 913 914 error = device_add(&joydev->dev); 915 if (error) 916 goto err_cleanup_joydev; 917 918 return 0; 919 920 err_cleanup_joydev: 921 joydev_cleanup(joydev); 922 err_unregister_handle: 923 input_unregister_handle(&joydev->handle); 924 err_free_joydev: 925 put_device(&joydev->dev); 926 err_free_minor: 927 input_free_minor(minor); 928 return error; 929 } 930 931 static void joydev_disconnect(struct input_handle *handle) 932 { 933 struct joydev *joydev = handle->private; 934 935 device_del(&joydev->dev); 936 joydev_cleanup(joydev); 937 input_free_minor(MINOR(joydev->dev.devt)); 938 input_unregister_handle(handle); 939 put_device(&joydev->dev); 940 } 941 942 static const struct input_device_id joydev_ids[] = { 943 { 944 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 945 INPUT_DEVICE_ID_MATCH_ABSBIT, 946 .evbit = { BIT_MASK(EV_ABS) }, 947 .absbit = { BIT_MASK(ABS_X) }, 948 }, 949 { 950 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 951 INPUT_DEVICE_ID_MATCH_ABSBIT, 952 .evbit = { BIT_MASK(EV_ABS) }, 953 .absbit = { BIT_MASK(ABS_WHEEL) }, 954 }, 955 { 956 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 957 INPUT_DEVICE_ID_MATCH_ABSBIT, 958 .evbit = { BIT_MASK(EV_ABS) }, 959 .absbit = { BIT_MASK(ABS_THROTTLE) }, 960 }, 961 { 962 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 963 INPUT_DEVICE_ID_MATCH_KEYBIT, 964 .evbit = { BIT_MASK(EV_KEY) }, 965 .keybit = {[BIT_WORD(BTN_JOYSTICK)] = BIT_MASK(BTN_JOYSTICK) }, 966 }, 967 { 968 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 969 INPUT_DEVICE_ID_MATCH_KEYBIT, 970 .evbit = { BIT_MASK(EV_KEY) }, 971 .keybit = { [BIT_WORD(BTN_GAMEPAD)] = BIT_MASK(BTN_GAMEPAD) }, 972 }, 973 { 974 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 975 INPUT_DEVICE_ID_MATCH_KEYBIT, 976 .evbit = { BIT_MASK(EV_KEY) }, 977 .keybit = { [BIT_WORD(BTN_TRIGGER_HAPPY)] = BIT_MASK(BTN_TRIGGER_HAPPY) }, 978 }, 979 { } /* Terminating entry */ 980 }; 981 982 MODULE_DEVICE_TABLE(input, joydev_ids); 983 984 static struct input_handler joydev_handler = { 985 .event = joydev_event, 986 .match = joydev_match, 987 .connect = joydev_connect, 988 .disconnect = joydev_disconnect, 989 .legacy_minors = true, 990 .minor = JOYDEV_MINOR_BASE, 991 .name = "joydev", 992 .id_table = joydev_ids, 993 }; 994 995 static int __init joydev_init(void) 996 { 997 return input_register_handler(&joydev_handler); 998 } 999 1000 static void __exit joydev_exit(void) 1001 { 1002 input_unregister_handler(&joydev_handler); 1003 } 1004 1005 module_init(joydev_init); 1006 module_exit(joydev_exit); 1007