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