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