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