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 #include <asm/io.h> 14 #include <asm/system.h> 15 #include <linux/delay.h> 16 #include <linux/errno.h> 17 #include <linux/joystick.h> 18 #include <linux/input.h> 19 #include <linux/kernel.h> 20 #include <linux/major.h> 21 #include <linux/slab.h> 22 #include <linux/mm.h> 23 #include <linux/miscdevice.h> 24 #include <linux/module.h> 25 #include <linux/poll.h> 26 #include <linux/init.h> 27 #include <linux/device.h> 28 29 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 30 MODULE_DESCRIPTION("Joystick device interfaces"); 31 MODULE_SUPPORTED_DEVICE("input/js"); 32 MODULE_LICENSE("GPL"); 33 34 #define JOYDEV_MINOR_BASE 0 35 #define JOYDEV_MINORS 16 36 #define JOYDEV_BUFFER_SIZE 64 37 38 struct joydev { 39 int exist; 40 int open; 41 int minor; 42 char name[16]; 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 50 struct js_corr corr[ABS_MAX + 1]; 51 struct JS_DATA_SAVE_TYPE glue; 52 int nabs; 53 int nkey; 54 __u16 keymap[KEY_MAX - BTN_MISC + 1]; 55 __u16 keypam[KEY_MAX - BTN_MISC + 1]; 56 __u8 absmap[ABS_MAX + 1]; 57 __u8 abspam[ABS_MAX + 1]; 58 __s16 abs[ABS_MAX + 1]; 59 }; 60 61 struct joydev_client { 62 struct js_event buffer[JOYDEV_BUFFER_SIZE]; 63 int head; 64 int tail; 65 int startup; 66 spinlock_t buffer_lock; /* protects access to buffer, head and tail */ 67 struct fasync_struct *fasync; 68 struct joydev *joydev; 69 struct list_head node; 70 }; 71 72 static struct joydev *joydev_table[JOYDEV_MINORS]; 73 static DEFINE_MUTEX(joydev_table_mutex); 74 75 static int joydev_correct(int value, struct js_corr *corr) 76 { 77 switch (corr->type) { 78 79 case JS_CORR_NONE: 80 break; 81 82 case JS_CORR_BROKEN: 83 value = value > corr->coef[0] ? (value < corr->coef[1] ? 0 : 84 ((corr->coef[3] * (value - corr->coef[1])) >> 14)) : 85 ((corr->coef[2] * (value - corr->coef[0])) >> 14); 86 break; 87 88 default: 89 return 0; 90 } 91 92 return value < -32767 ? -32767 : (value > 32767 ? 32767 : value); 93 } 94 95 static void joydev_pass_event(struct joydev_client *client, 96 struct js_event *event) 97 { 98 struct joydev *joydev = client->joydev; 99 100 /* 101 * IRQs already disabled, just acquire the lock 102 */ 103 spin_lock(&client->buffer_lock); 104 105 client->buffer[client->head] = *event; 106 107 if (client->startup == joydev->nabs + joydev->nkey) { 108 client->head++; 109 client->head &= JOYDEV_BUFFER_SIZE - 1; 110 if (client->tail == client->head) 111 client->startup = 0; 112 } 113 114 spin_unlock(&client->buffer_lock); 115 116 kill_fasync(&client->fasync, SIGIO, POLL_IN); 117 } 118 119 static void joydev_event(struct input_handle *handle, 120 unsigned int type, unsigned int code, int value) 121 { 122 struct joydev *joydev = handle->private; 123 struct joydev_client *client; 124 struct js_event event; 125 126 switch (type) { 127 128 case EV_KEY: 129 if (code < BTN_MISC || value == 2) 130 return; 131 event.type = JS_EVENT_BUTTON; 132 event.number = joydev->keymap[code - BTN_MISC]; 133 event.value = value; 134 break; 135 136 case EV_ABS: 137 event.type = JS_EVENT_AXIS; 138 event.number = joydev->absmap[code]; 139 event.value = joydev_correct(value, 140 &joydev->corr[event.number]); 141 if (event.value == joydev->abs[event.number]) 142 return; 143 joydev->abs[event.number] = event.value; 144 break; 145 146 default: 147 return; 148 } 149 150 event.time = jiffies_to_msecs(jiffies); 151 152 rcu_read_lock(); 153 list_for_each_entry_rcu(client, &joydev->client_list, node) 154 joydev_pass_event(client, &event); 155 rcu_read_unlock(); 156 157 wake_up_interruptible(&joydev->wait); 158 } 159 160 static int joydev_fasync(int fd, struct file *file, int on) 161 { 162 int retval; 163 struct joydev_client *client = file->private_data; 164 165 retval = fasync_helper(fd, file, on, &client->fasync); 166 167 return retval < 0 ? retval : 0; 168 } 169 170 static void joydev_free(struct device *dev) 171 { 172 struct joydev *joydev = container_of(dev, struct joydev, dev); 173 174 input_put_device(joydev->handle.dev); 175 kfree(joydev); 176 } 177 178 static void joydev_attach_client(struct joydev *joydev, 179 struct joydev_client *client) 180 { 181 spin_lock(&joydev->client_lock); 182 list_add_tail_rcu(&client->node, &joydev->client_list); 183 spin_unlock(&joydev->client_lock); 184 synchronize_rcu(); 185 } 186 187 static void joydev_detach_client(struct joydev *joydev, 188 struct joydev_client *client) 189 { 190 spin_lock(&joydev->client_lock); 191 list_del_rcu(&client->node); 192 spin_unlock(&joydev->client_lock); 193 synchronize_rcu(); 194 } 195 196 static int joydev_open_device(struct joydev *joydev) 197 { 198 int retval; 199 200 retval = mutex_lock_interruptible(&joydev->mutex); 201 if (retval) 202 return retval; 203 204 if (!joydev->exist) 205 retval = -ENODEV; 206 else if (!joydev->open++) { 207 retval = input_open_device(&joydev->handle); 208 if (retval) 209 joydev->open--; 210 } 211 212 mutex_unlock(&joydev->mutex); 213 return retval; 214 } 215 216 static void joydev_close_device(struct joydev *joydev) 217 { 218 mutex_lock(&joydev->mutex); 219 220 if (joydev->exist && !--joydev->open) 221 input_close_device(&joydev->handle); 222 223 mutex_unlock(&joydev->mutex); 224 } 225 226 /* 227 * Wake up users waiting for IO so they can disconnect from 228 * dead device. 229 */ 230 static void joydev_hangup(struct joydev *joydev) 231 { 232 struct joydev_client *client; 233 234 spin_lock(&joydev->client_lock); 235 list_for_each_entry(client, &joydev->client_list, node) 236 kill_fasync(&client->fasync, SIGIO, POLL_HUP); 237 spin_unlock(&joydev->client_lock); 238 239 wake_up_interruptible(&joydev->wait); 240 } 241 242 static int joydev_release(struct inode *inode, struct file *file) 243 { 244 struct joydev_client *client = file->private_data; 245 struct joydev *joydev = client->joydev; 246 247 joydev_fasync(-1, file, 0); 248 joydev_detach_client(joydev, client); 249 kfree(client); 250 251 joydev_close_device(joydev); 252 put_device(&joydev->dev); 253 254 return 0; 255 } 256 257 static int joydev_open(struct inode *inode, struct file *file) 258 { 259 struct joydev_client *client; 260 struct joydev *joydev; 261 int i = iminor(inode) - JOYDEV_MINOR_BASE; 262 int error; 263 264 if (i >= JOYDEV_MINORS) 265 return -ENODEV; 266 267 error = mutex_lock_interruptible(&joydev_table_mutex); 268 if (error) 269 return error; 270 joydev = joydev_table[i]; 271 if (joydev) 272 get_device(&joydev->dev); 273 mutex_unlock(&joydev_table_mutex); 274 275 if (!joydev) 276 return -ENODEV; 277 278 client = kzalloc(sizeof(struct joydev_client), GFP_KERNEL); 279 if (!client) { 280 error = -ENOMEM; 281 goto err_put_joydev; 282 } 283 284 spin_lock_init(&client->buffer_lock); 285 client->joydev = joydev; 286 joydev_attach_client(joydev, client); 287 288 error = joydev_open_device(joydev); 289 if (error) 290 goto err_free_client; 291 292 file->private_data = client; 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_ioctl_common(struct joydev *joydev, 461 unsigned int cmd, void __user *argp) 462 { 463 struct input_dev *dev = joydev->handle.dev; 464 int i, j; 465 466 switch (cmd) { 467 468 case JS_SET_CAL: 469 return copy_from_user(&joydev->glue.JS_CORR, argp, 470 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 471 472 case JS_GET_CAL: 473 return copy_to_user(argp, &joydev->glue.JS_CORR, 474 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 475 476 case JS_SET_TIMEOUT: 477 return get_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 478 479 case JS_GET_TIMEOUT: 480 return put_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 481 482 case JSIOCGVERSION: 483 return put_user(JS_VERSION, (__u32 __user *) argp); 484 485 case JSIOCGAXES: 486 return put_user(joydev->nabs, (__u8 __user *) argp); 487 488 case JSIOCGBUTTONS: 489 return put_user(joydev->nkey, (__u8 __user *) argp); 490 491 case JSIOCSCORR: 492 if (copy_from_user(joydev->corr, argp, 493 sizeof(joydev->corr[0]) * joydev->nabs)) 494 return -EFAULT; 495 496 for (i = 0; i < joydev->nabs; i++) { 497 j = joydev->abspam[i]; 498 joydev->abs[i] = joydev_correct(dev->abs[j], 499 &joydev->corr[i]); 500 } 501 return 0; 502 503 case JSIOCGCORR: 504 return copy_to_user(argp, joydev->corr, 505 sizeof(joydev->corr[0]) * joydev->nabs) ? -EFAULT : 0; 506 507 case JSIOCSAXMAP: 508 if (copy_from_user(joydev->abspam, argp, 509 sizeof(__u8) * (ABS_MAX + 1))) 510 return -EFAULT; 511 512 for (i = 0; i < joydev->nabs; i++) { 513 if (joydev->abspam[i] > ABS_MAX) 514 return -EINVAL; 515 joydev->absmap[joydev->abspam[i]] = i; 516 } 517 return 0; 518 519 case JSIOCGAXMAP: 520 return copy_to_user(argp, joydev->abspam, 521 sizeof(__u8) * (ABS_MAX + 1)) ? -EFAULT : 0; 522 523 case JSIOCSBTNMAP: 524 if (copy_from_user(joydev->keypam, argp, 525 sizeof(__u16) * (KEY_MAX - BTN_MISC + 1))) 526 return -EFAULT; 527 528 for (i = 0; i < joydev->nkey; i++) { 529 if (joydev->keypam[i] > KEY_MAX || 530 joydev->keypam[i] < BTN_MISC) 531 return -EINVAL; 532 joydev->keymap[joydev->keypam[i] - BTN_MISC] = i; 533 } 534 535 return 0; 536 537 case JSIOCGBTNMAP: 538 return copy_to_user(argp, joydev->keypam, 539 sizeof(__u16) * (KEY_MAX - BTN_MISC + 1)) ? -EFAULT : 0; 540 541 default: 542 if ((cmd & ~IOCSIZE_MASK) == JSIOCGNAME(0)) { 543 int len; 544 if (!dev->name) 545 return 0; 546 len = strlen(dev->name) + 1; 547 if (len > _IOC_SIZE(cmd)) 548 len = _IOC_SIZE(cmd); 549 if (copy_to_user(argp, dev->name, len)) 550 return -EFAULT; 551 return len; 552 } 553 } 554 return -EINVAL; 555 } 556 557 #ifdef CONFIG_COMPAT 558 static long joydev_compat_ioctl(struct file *file, 559 unsigned int cmd, unsigned long arg) 560 { 561 struct joydev_client *client = file->private_data; 562 struct joydev *joydev = client->joydev; 563 void __user *argp = (void __user *)arg; 564 s32 tmp32; 565 struct JS_DATA_SAVE_TYPE_32 ds32; 566 int retval; 567 568 retval = mutex_lock_interruptible(&joydev->mutex); 569 if (retval) 570 return retval; 571 572 if (!joydev->exist) { 573 retval = -ENODEV; 574 goto out; 575 } 576 577 switch (cmd) { 578 579 case JS_SET_TIMELIMIT: 580 retval = get_user(tmp32, (s32 __user *) arg); 581 if (retval == 0) 582 joydev->glue.JS_TIMELIMIT = tmp32; 583 break; 584 585 case JS_GET_TIMELIMIT: 586 tmp32 = joydev->glue.JS_TIMELIMIT; 587 retval = put_user(tmp32, (s32 __user *) arg); 588 break; 589 590 case JS_SET_ALL: 591 retval = copy_from_user(&ds32, argp, 592 sizeof(ds32)) ? -EFAULT : 0; 593 if (retval == 0) { 594 joydev->glue.JS_TIMEOUT = ds32.JS_TIMEOUT; 595 joydev->glue.BUSY = ds32.BUSY; 596 joydev->glue.JS_EXPIRETIME = ds32.JS_EXPIRETIME; 597 joydev->glue.JS_TIMELIMIT = ds32.JS_TIMELIMIT; 598 joydev->glue.JS_SAVE = ds32.JS_SAVE; 599 joydev->glue.JS_CORR = ds32.JS_CORR; 600 } 601 break; 602 603 case JS_GET_ALL: 604 ds32.JS_TIMEOUT = joydev->glue.JS_TIMEOUT; 605 ds32.BUSY = joydev->glue.BUSY; 606 ds32.JS_EXPIRETIME = joydev->glue.JS_EXPIRETIME; 607 ds32.JS_TIMELIMIT = joydev->glue.JS_TIMELIMIT; 608 ds32.JS_SAVE = joydev->glue.JS_SAVE; 609 ds32.JS_CORR = joydev->glue.JS_CORR; 610 611 retval = copy_to_user(argp, &ds32, sizeof(ds32)) ? -EFAULT : 0; 612 break; 613 614 default: 615 retval = joydev_ioctl_common(joydev, cmd, argp); 616 break; 617 } 618 619 out: 620 mutex_unlock(&joydev->mutex); 621 return retval; 622 } 623 #endif /* CONFIG_COMPAT */ 624 625 static long joydev_ioctl(struct file *file, 626 unsigned int cmd, unsigned long arg) 627 { 628 struct joydev_client *client = file->private_data; 629 struct joydev *joydev = client->joydev; 630 void __user *argp = (void __user *)arg; 631 int retval; 632 633 retval = mutex_lock_interruptible(&joydev->mutex); 634 if (retval) 635 return retval; 636 637 if (!joydev->exist) { 638 retval = -ENODEV; 639 goto out; 640 } 641 642 switch (cmd) { 643 644 case JS_SET_TIMELIMIT: 645 retval = get_user(joydev->glue.JS_TIMELIMIT, 646 (long __user *) arg); 647 break; 648 649 case JS_GET_TIMELIMIT: 650 retval = put_user(joydev->glue.JS_TIMELIMIT, 651 (long __user *) arg); 652 break; 653 654 case JS_SET_ALL: 655 retval = copy_from_user(&joydev->glue, argp, 656 sizeof(joydev->glue)) ? -EFAULT: 0; 657 break; 658 659 case JS_GET_ALL: 660 retval = copy_to_user(argp, &joydev->glue, 661 sizeof(joydev->glue)) ? -EFAULT : 0; 662 break; 663 664 default: 665 retval = joydev_ioctl_common(joydev, cmd, argp); 666 break; 667 } 668 out: 669 mutex_unlock(&joydev->mutex); 670 return retval; 671 } 672 673 static const struct file_operations joydev_fops = { 674 .owner = THIS_MODULE, 675 .read = joydev_read, 676 .poll = joydev_poll, 677 .open = joydev_open, 678 .release = joydev_release, 679 .unlocked_ioctl = joydev_ioctl, 680 #ifdef CONFIG_COMPAT 681 .compat_ioctl = joydev_compat_ioctl, 682 #endif 683 .fasync = joydev_fasync, 684 }; 685 686 static int joydev_install_chrdev(struct joydev *joydev) 687 { 688 joydev_table[joydev->minor] = joydev; 689 return 0; 690 } 691 692 static void joydev_remove_chrdev(struct joydev *joydev) 693 { 694 mutex_lock(&joydev_table_mutex); 695 joydev_table[joydev->minor] = NULL; 696 mutex_unlock(&joydev_table_mutex); 697 } 698 699 /* 700 * Mark device non-existant. This disables writes, ioctls and 701 * prevents new users from opening the device. Already posted 702 * blocking reads will stay, however new ones will fail. 703 */ 704 static void joydev_mark_dead(struct joydev *joydev) 705 { 706 mutex_lock(&joydev->mutex); 707 joydev->exist = 0; 708 mutex_unlock(&joydev->mutex); 709 } 710 711 static void joydev_cleanup(struct joydev *joydev) 712 { 713 struct input_handle *handle = &joydev->handle; 714 715 joydev_mark_dead(joydev); 716 joydev_hangup(joydev); 717 joydev_remove_chrdev(joydev); 718 719 /* joydev is marked dead so noone else accesses joydev->open */ 720 if (joydev->open) 721 input_close_device(handle); 722 } 723 724 static int joydev_connect(struct input_handler *handler, struct input_dev *dev, 725 const struct input_device_id *id) 726 { 727 struct joydev *joydev; 728 int i, j, t, minor; 729 int error; 730 731 for (minor = 0; minor < JOYDEV_MINORS; minor++) 732 if (!joydev_table[minor]) 733 break; 734 735 if (minor == JOYDEV_MINORS) { 736 printk(KERN_ERR "joydev: no more free joydev devices\n"); 737 return -ENFILE; 738 } 739 740 joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL); 741 if (!joydev) 742 return -ENOMEM; 743 744 INIT_LIST_HEAD(&joydev->client_list); 745 spin_lock_init(&joydev->client_lock); 746 mutex_init(&joydev->mutex); 747 init_waitqueue_head(&joydev->wait); 748 749 snprintf(joydev->name, sizeof(joydev->name), "js%d", minor); 750 joydev->exist = 1; 751 joydev->minor = minor; 752 753 joydev->exist = 1; 754 joydev->handle.dev = input_get_device(dev); 755 joydev->handle.name = joydev->name; 756 joydev->handle.handler = handler; 757 joydev->handle.private = joydev; 758 759 for (i = 0; i < ABS_MAX + 1; i++) 760 if (test_bit(i, dev->absbit)) { 761 joydev->absmap[i] = joydev->nabs; 762 joydev->abspam[joydev->nabs] = i; 763 joydev->nabs++; 764 } 765 766 for (i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++) 767 if (test_bit(i + BTN_MISC, dev->keybit)) { 768 joydev->keymap[i] = joydev->nkey; 769 joydev->keypam[joydev->nkey] = i + BTN_MISC; 770 joydev->nkey++; 771 } 772 773 for (i = 0; i < BTN_JOYSTICK - BTN_MISC; i++) 774 if (test_bit(i + BTN_MISC, dev->keybit)) { 775 joydev->keymap[i] = joydev->nkey; 776 joydev->keypam[joydev->nkey] = i + BTN_MISC; 777 joydev->nkey++; 778 } 779 780 for (i = 0; i < joydev->nabs; i++) { 781 j = joydev->abspam[i]; 782 if (dev->absmax[j] == dev->absmin[j]) { 783 joydev->corr[i].type = JS_CORR_NONE; 784 joydev->abs[i] = dev->abs[j]; 785 continue; 786 } 787 joydev->corr[i].type = JS_CORR_BROKEN; 788 joydev->corr[i].prec = dev->absfuzz[j]; 789 joydev->corr[i].coef[0] = 790 (dev->absmax[j] + dev->absmin[j]) / 2 - dev->absflat[j]; 791 joydev->corr[i].coef[1] = 792 (dev->absmax[j] + dev->absmin[j]) / 2 + dev->absflat[j]; 793 794 t = (dev->absmax[j] - dev->absmin[j]) / 2 - 2 * dev->absflat[j]; 795 if (t) { 796 joydev->corr[i].coef[2] = (1 << 29) / t; 797 joydev->corr[i].coef[3] = (1 << 29) / t; 798 799 joydev->abs[i] = joydev_correct(dev->abs[j], 800 joydev->corr + i); 801 } 802 } 803 804 strlcpy(joydev->dev.bus_id, joydev->name, sizeof(joydev->dev.bus_id)); 805 joydev->dev.devt = MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor); 806 joydev->dev.class = &input_class; 807 joydev->dev.parent = &dev->dev; 808 joydev->dev.release = joydev_free; 809 device_initialize(&joydev->dev); 810 811 error = input_register_handle(&joydev->handle); 812 if (error) 813 goto err_free_joydev; 814 815 error = joydev_install_chrdev(joydev); 816 if (error) 817 goto err_unregister_handle; 818 819 error = device_add(&joydev->dev); 820 if (error) 821 goto err_cleanup_joydev; 822 823 return 0; 824 825 err_cleanup_joydev: 826 joydev_cleanup(joydev); 827 err_unregister_handle: 828 input_unregister_handle(&joydev->handle); 829 err_free_joydev: 830 put_device(&joydev->dev); 831 return error; 832 } 833 834 static void joydev_disconnect(struct input_handle *handle) 835 { 836 struct joydev *joydev = handle->private; 837 838 device_del(&joydev->dev); 839 joydev_cleanup(joydev); 840 input_unregister_handle(handle); 841 put_device(&joydev->dev); 842 } 843 844 static const struct input_device_id joydev_blacklist[] = { 845 { 846 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 847 INPUT_DEVICE_ID_MATCH_KEYBIT, 848 .evbit = { BIT_MASK(EV_KEY) }, 849 .keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) }, 850 }, /* Avoid itouchpads, touchscreens and tablets */ 851 { } /* Terminating entry */ 852 }; 853 854 static const struct input_device_id joydev_ids[] = { 855 { 856 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 857 INPUT_DEVICE_ID_MATCH_ABSBIT, 858 .evbit = { BIT_MASK(EV_ABS) }, 859 .absbit = { BIT_MASK(ABS_X) }, 860 }, 861 { 862 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 863 INPUT_DEVICE_ID_MATCH_ABSBIT, 864 .evbit = { BIT_MASK(EV_ABS) }, 865 .absbit = { BIT_MASK(ABS_WHEEL) }, 866 }, 867 { 868 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 869 INPUT_DEVICE_ID_MATCH_ABSBIT, 870 .evbit = { BIT_MASK(EV_ABS) }, 871 .absbit = { BIT_MASK(ABS_THROTTLE) }, 872 }, 873 { } /* Terminating entry */ 874 }; 875 876 MODULE_DEVICE_TABLE(input, joydev_ids); 877 878 static struct input_handler joydev_handler = { 879 .event = joydev_event, 880 .connect = joydev_connect, 881 .disconnect = joydev_disconnect, 882 .fops = &joydev_fops, 883 .minor = JOYDEV_MINOR_BASE, 884 .name = "joydev", 885 .id_table = joydev_ids, 886 .blacklist = joydev_blacklist, 887 }; 888 889 static int __init joydev_init(void) 890 { 891 return input_register_handler(&joydev_handler); 892 } 893 894 static void __exit joydev_exit(void) 895 { 896 input_unregister_handler(&joydev_handler); 897 } 898 899 module_init(joydev_init); 900 module_exit(joydev_exit); 901