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