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 struct input_handle handle; 43 wait_queue_head_t wait; 44 struct list_head client_list; 45 spinlock_t client_lock; /* protects client_list */ 46 struct mutex mutex; 47 struct device dev; 48 49 struct js_corr corr[ABS_MAX + 1]; 50 struct JS_DATA_SAVE_TYPE glue; 51 int nabs; 52 int nkey; 53 __u16 keymap[KEY_MAX - BTN_MISC + 1]; 54 __u16 keypam[KEY_MAX - BTN_MISC + 1]; 55 __u8 absmap[ABS_MAX + 1]; 56 __u8 abspam[ABS_MAX + 1]; 57 __s16 abs[ABS_MAX + 1]; 58 }; 59 60 struct joydev_client { 61 struct js_event buffer[JOYDEV_BUFFER_SIZE]; 62 int head; 63 int tail; 64 int startup; 65 spinlock_t buffer_lock; /* protects access to buffer, head and tail */ 66 struct fasync_struct *fasync; 67 struct joydev *joydev; 68 struct list_head node; 69 }; 70 71 static struct joydev *joydev_table[JOYDEV_MINORS]; 72 static DEFINE_MUTEX(joydev_table_mutex); 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 synchronize_rcu(); 181 } 182 183 static void joydev_detach_client(struct joydev *joydev, 184 struct joydev_client *client) 185 { 186 spin_lock(&joydev->client_lock); 187 list_del_rcu(&client->node); 188 spin_unlock(&joydev->client_lock); 189 synchronize_rcu(); 190 } 191 192 static int joydev_open_device(struct joydev *joydev) 193 { 194 int retval; 195 196 retval = mutex_lock_interruptible(&joydev->mutex); 197 if (retval) 198 return retval; 199 200 if (!joydev->exist) 201 retval = -ENODEV; 202 else if (!joydev->open++) { 203 retval = input_open_device(&joydev->handle); 204 if (retval) 205 joydev->open--; 206 } 207 208 mutex_unlock(&joydev->mutex); 209 return retval; 210 } 211 212 static void joydev_close_device(struct joydev *joydev) 213 { 214 mutex_lock(&joydev->mutex); 215 216 if (joydev->exist && !--joydev->open) 217 input_close_device(&joydev->handle); 218 219 mutex_unlock(&joydev->mutex); 220 } 221 222 /* 223 * Wake up users waiting for IO so they can disconnect from 224 * dead device. 225 */ 226 static void joydev_hangup(struct joydev *joydev) 227 { 228 struct joydev_client *client; 229 230 spin_lock(&joydev->client_lock); 231 list_for_each_entry(client, &joydev->client_list, node) 232 kill_fasync(&client->fasync, SIGIO, POLL_HUP); 233 spin_unlock(&joydev->client_lock); 234 235 wake_up_interruptible(&joydev->wait); 236 } 237 238 static int joydev_release(struct inode *inode, struct file *file) 239 { 240 struct joydev_client *client = file->private_data; 241 struct joydev *joydev = client->joydev; 242 243 joydev_detach_client(joydev, client); 244 kfree(client); 245 246 joydev_close_device(joydev); 247 put_device(&joydev->dev); 248 249 return 0; 250 } 251 252 static int joydev_open(struct inode *inode, struct file *file) 253 { 254 struct joydev_client *client; 255 struct joydev *joydev; 256 int i = iminor(inode) - JOYDEV_MINOR_BASE; 257 int error; 258 259 if (i >= JOYDEV_MINORS) 260 return -ENODEV; 261 262 error = mutex_lock_interruptible(&joydev_table_mutex); 263 if (error) 264 return error; 265 joydev = joydev_table[i]; 266 if (joydev) 267 get_device(&joydev->dev); 268 mutex_unlock(&joydev_table_mutex); 269 270 if (!joydev) 271 return -ENODEV; 272 273 client = kzalloc(sizeof(struct joydev_client), GFP_KERNEL); 274 if (!client) { 275 error = -ENOMEM; 276 goto err_put_joydev; 277 } 278 279 spin_lock_init(&client->buffer_lock); 280 client->joydev = joydev; 281 joydev_attach_client(joydev, client); 282 283 error = joydev_open_device(joydev); 284 if (error) 285 goto err_free_client; 286 287 file->private_data = client; 288 return 0; 289 290 err_free_client: 291 joydev_detach_client(joydev, client); 292 kfree(client); 293 err_put_joydev: 294 put_device(&joydev->dev); 295 return error; 296 } 297 298 static int joydev_generate_startup_event(struct joydev_client *client, 299 struct input_dev *input, 300 struct js_event *event) 301 { 302 struct joydev *joydev = client->joydev; 303 int have_event; 304 305 spin_lock_irq(&client->buffer_lock); 306 307 have_event = client->startup < joydev->nabs + joydev->nkey; 308 309 if (have_event) { 310 311 event->time = jiffies_to_msecs(jiffies); 312 if (client->startup < joydev->nkey) { 313 event->type = JS_EVENT_BUTTON | JS_EVENT_INIT; 314 event->number = client->startup; 315 event->value = !!test_bit(joydev->keypam[event->number], 316 input->key); 317 } else { 318 event->type = JS_EVENT_AXIS | JS_EVENT_INIT; 319 event->number = client->startup - joydev->nkey; 320 event->value = joydev->abs[event->number]; 321 } 322 client->startup++; 323 } 324 325 spin_unlock_irq(&client->buffer_lock); 326 327 return have_event; 328 } 329 330 static int joydev_fetch_next_event(struct joydev_client *client, 331 struct js_event *event) 332 { 333 int have_event; 334 335 spin_lock_irq(&client->buffer_lock); 336 337 have_event = client->head != client->tail; 338 if (have_event) { 339 *event = client->buffer[client->tail++]; 340 client->tail &= JOYDEV_BUFFER_SIZE - 1; 341 } 342 343 spin_unlock_irq(&client->buffer_lock); 344 345 return have_event; 346 } 347 348 /* 349 * Old joystick interface 350 */ 351 static ssize_t joydev_0x_read(struct joydev_client *client, 352 struct input_dev *input, 353 char __user *buf) 354 { 355 struct joydev *joydev = client->joydev; 356 struct JS_DATA_TYPE data; 357 int i; 358 359 spin_lock_irq(&input->event_lock); 360 361 /* 362 * Get device state 363 */ 364 for (data.buttons = i = 0; i < 32 && i < joydev->nkey; i++) 365 data.buttons |= 366 test_bit(joydev->keypam[i], input->key) ? (1 << i) : 0; 367 data.x = (joydev->abs[0] / 256 + 128) >> joydev->glue.JS_CORR.x; 368 data.y = (joydev->abs[1] / 256 + 128) >> joydev->glue.JS_CORR.y; 369 370 /* 371 * Reset reader's event queue 372 */ 373 spin_lock(&client->buffer_lock); 374 client->startup = 0; 375 client->tail = client->head; 376 spin_unlock(&client->buffer_lock); 377 378 spin_unlock_irq(&input->event_lock); 379 380 if (copy_to_user(buf, &data, sizeof(struct JS_DATA_TYPE))) 381 return -EFAULT; 382 383 return sizeof(struct JS_DATA_TYPE); 384 } 385 386 static inline int joydev_data_pending(struct joydev_client *client) 387 { 388 struct joydev *joydev = client->joydev; 389 390 return client->startup < joydev->nabs + joydev->nkey || 391 client->head != client->tail; 392 } 393 394 static ssize_t joydev_read(struct file *file, char __user *buf, 395 size_t count, loff_t *ppos) 396 { 397 struct joydev_client *client = file->private_data; 398 struct joydev *joydev = client->joydev; 399 struct input_dev *input = joydev->handle.dev; 400 struct js_event event; 401 int retval; 402 403 if (!joydev->exist) 404 return -ENODEV; 405 406 if (count < sizeof(struct js_event)) 407 return -EINVAL; 408 409 if (count == sizeof(struct JS_DATA_TYPE)) 410 return joydev_0x_read(client, input, buf); 411 412 if (!joydev_data_pending(client) && (file->f_flags & O_NONBLOCK)) 413 return -EAGAIN; 414 415 retval = wait_event_interruptible(joydev->wait, 416 !joydev->exist || joydev_data_pending(client)); 417 if (retval) 418 return retval; 419 420 if (!joydev->exist) 421 return -ENODEV; 422 423 while (retval + sizeof(struct js_event) <= count && 424 joydev_generate_startup_event(client, input, &event)) { 425 426 if (copy_to_user(buf + retval, &event, sizeof(struct js_event))) 427 return -EFAULT; 428 429 retval += sizeof(struct js_event); 430 } 431 432 while (retval + sizeof(struct js_event) <= count && 433 joydev_fetch_next_event(client, &event)) { 434 435 if (copy_to_user(buf + retval, &event, sizeof(struct js_event))) 436 return -EFAULT; 437 438 retval += sizeof(struct js_event); 439 } 440 441 return retval; 442 } 443 444 /* No kernel lock - fine */ 445 static unsigned int joydev_poll(struct file *file, poll_table *wait) 446 { 447 struct joydev_client *client = file->private_data; 448 struct joydev *joydev = client->joydev; 449 450 poll_wait(file, &joydev->wait, wait); 451 return (joydev_data_pending(client) ? (POLLIN | POLLRDNORM) : 0) | 452 (joydev->exist ? 0 : (POLLHUP | POLLERR)); 453 } 454 455 static int joydev_ioctl_common(struct joydev *joydev, 456 unsigned int cmd, void __user *argp) 457 { 458 struct input_dev *dev = joydev->handle.dev; 459 int i, j; 460 461 switch (cmd) { 462 463 case JS_SET_CAL: 464 return copy_from_user(&joydev->glue.JS_CORR, argp, 465 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 466 467 case JS_GET_CAL: 468 return copy_to_user(argp, &joydev->glue.JS_CORR, 469 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0; 470 471 case JS_SET_TIMEOUT: 472 return get_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 473 474 case JS_GET_TIMEOUT: 475 return put_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp); 476 477 case JSIOCGVERSION: 478 return put_user(JS_VERSION, (__u32 __user *) argp); 479 480 case JSIOCGAXES: 481 return put_user(joydev->nabs, (__u8 __user *) argp); 482 483 case JSIOCGBUTTONS: 484 return put_user(joydev->nkey, (__u8 __user *) argp); 485 486 case JSIOCSCORR: 487 if (copy_from_user(joydev->corr, argp, 488 sizeof(joydev->corr[0]) * joydev->nabs)) 489 return -EFAULT; 490 491 for (i = 0; i < joydev->nabs; i++) { 492 j = joydev->abspam[i]; 493 joydev->abs[i] = joydev_correct(dev->abs[j], 494 &joydev->corr[i]); 495 } 496 return 0; 497 498 case JSIOCGCORR: 499 return copy_to_user(argp, joydev->corr, 500 sizeof(joydev->corr[0]) * joydev->nabs) ? -EFAULT : 0; 501 502 case JSIOCSAXMAP: 503 if (copy_from_user(joydev->abspam, argp, 504 sizeof(__u8) * (ABS_MAX + 1))) 505 return -EFAULT; 506 507 for (i = 0; i < joydev->nabs; i++) { 508 if (joydev->abspam[i] > ABS_MAX) 509 return -EINVAL; 510 joydev->absmap[joydev->abspam[i]] = i; 511 } 512 return 0; 513 514 case JSIOCGAXMAP: 515 return copy_to_user(argp, joydev->abspam, 516 sizeof(__u8) * (ABS_MAX + 1)) ? -EFAULT : 0; 517 518 case JSIOCSBTNMAP: 519 if (copy_from_user(joydev->keypam, argp, 520 sizeof(__u16) * (KEY_MAX - BTN_MISC + 1))) 521 return -EFAULT; 522 523 for (i = 0; i < joydev->nkey; i++) { 524 if (joydev->keypam[i] > KEY_MAX || 525 joydev->keypam[i] < BTN_MISC) 526 return -EINVAL; 527 joydev->keymap[joydev->keypam[i] - BTN_MISC] = i; 528 } 529 530 return 0; 531 532 case JSIOCGBTNMAP: 533 return copy_to_user(argp, joydev->keypam, 534 sizeof(__u16) * (KEY_MAX - BTN_MISC + 1)) ? -EFAULT : 0; 535 536 default: 537 if ((cmd & ~IOCSIZE_MASK) == JSIOCGNAME(0)) { 538 int len; 539 const char *name = dev->name; 540 541 if (!name) 542 return 0; 543 len = strlen(name) + 1; 544 if (len > _IOC_SIZE(cmd)) 545 len = _IOC_SIZE(cmd); 546 if (copy_to_user(argp, name, len)) 547 return -EFAULT; 548 return len; 549 } 550 } 551 return -EINVAL; 552 } 553 554 #ifdef CONFIG_COMPAT 555 static long joydev_compat_ioctl(struct file *file, 556 unsigned int cmd, unsigned long arg) 557 { 558 struct joydev_client *client = file->private_data; 559 struct joydev *joydev = client->joydev; 560 void __user *argp = (void __user *)arg; 561 s32 tmp32; 562 struct JS_DATA_SAVE_TYPE_32 ds32; 563 int retval; 564 565 retval = mutex_lock_interruptible(&joydev->mutex); 566 if (retval) 567 return retval; 568 569 if (!joydev->exist) { 570 retval = -ENODEV; 571 goto out; 572 } 573 574 switch (cmd) { 575 576 case JS_SET_TIMELIMIT: 577 retval = get_user(tmp32, (s32 __user *) arg); 578 if (retval == 0) 579 joydev->glue.JS_TIMELIMIT = tmp32; 580 break; 581 582 case JS_GET_TIMELIMIT: 583 tmp32 = joydev->glue.JS_TIMELIMIT; 584 retval = put_user(tmp32, (s32 __user *) arg); 585 break; 586 587 case JS_SET_ALL: 588 retval = copy_from_user(&ds32, argp, 589 sizeof(ds32)) ? -EFAULT : 0; 590 if (retval == 0) { 591 joydev->glue.JS_TIMEOUT = ds32.JS_TIMEOUT; 592 joydev->glue.BUSY = ds32.BUSY; 593 joydev->glue.JS_EXPIRETIME = ds32.JS_EXPIRETIME; 594 joydev->glue.JS_TIMELIMIT = ds32.JS_TIMELIMIT; 595 joydev->glue.JS_SAVE = ds32.JS_SAVE; 596 joydev->glue.JS_CORR = ds32.JS_CORR; 597 } 598 break; 599 600 case JS_GET_ALL: 601 ds32.JS_TIMEOUT = joydev->glue.JS_TIMEOUT; 602 ds32.BUSY = joydev->glue.BUSY; 603 ds32.JS_EXPIRETIME = joydev->glue.JS_EXPIRETIME; 604 ds32.JS_TIMELIMIT = joydev->glue.JS_TIMELIMIT; 605 ds32.JS_SAVE = joydev->glue.JS_SAVE; 606 ds32.JS_CORR = joydev->glue.JS_CORR; 607 608 retval = copy_to_user(argp, &ds32, sizeof(ds32)) ? -EFAULT : 0; 609 break; 610 611 default: 612 retval = joydev_ioctl_common(joydev, cmd, argp); 613 break; 614 } 615 616 out: 617 mutex_unlock(&joydev->mutex); 618 return retval; 619 } 620 #endif /* CONFIG_COMPAT */ 621 622 static long joydev_ioctl(struct file *file, 623 unsigned int cmd, unsigned long arg) 624 { 625 struct joydev_client *client = file->private_data; 626 struct joydev *joydev = client->joydev; 627 void __user *argp = (void __user *)arg; 628 int retval; 629 630 retval = mutex_lock_interruptible(&joydev->mutex); 631 if (retval) 632 return retval; 633 634 if (!joydev->exist) { 635 retval = -ENODEV; 636 goto out; 637 } 638 639 switch (cmd) { 640 641 case JS_SET_TIMELIMIT: 642 retval = get_user(joydev->glue.JS_TIMELIMIT, 643 (long __user *) arg); 644 break; 645 646 case JS_GET_TIMELIMIT: 647 retval = put_user(joydev->glue.JS_TIMELIMIT, 648 (long __user *) arg); 649 break; 650 651 case JS_SET_ALL: 652 retval = copy_from_user(&joydev->glue, argp, 653 sizeof(joydev->glue)) ? -EFAULT: 0; 654 break; 655 656 case JS_GET_ALL: 657 retval = copy_to_user(argp, &joydev->glue, 658 sizeof(joydev->glue)) ? -EFAULT : 0; 659 break; 660 661 default: 662 retval = joydev_ioctl_common(joydev, cmd, argp); 663 break; 664 } 665 out: 666 mutex_unlock(&joydev->mutex); 667 return retval; 668 } 669 670 static const struct file_operations joydev_fops = { 671 .owner = THIS_MODULE, 672 .read = joydev_read, 673 .poll = joydev_poll, 674 .open = joydev_open, 675 .release = joydev_release, 676 .unlocked_ioctl = joydev_ioctl, 677 #ifdef CONFIG_COMPAT 678 .compat_ioctl = joydev_compat_ioctl, 679 #endif 680 .fasync = joydev_fasync, 681 }; 682 683 static int joydev_install_chrdev(struct joydev *joydev) 684 { 685 joydev_table[joydev->minor] = joydev; 686 return 0; 687 } 688 689 static void joydev_remove_chrdev(struct joydev *joydev) 690 { 691 mutex_lock(&joydev_table_mutex); 692 joydev_table[joydev->minor] = NULL; 693 mutex_unlock(&joydev_table_mutex); 694 } 695 696 /* 697 * Mark device non-existant. This disables writes, ioctls and 698 * prevents new users from opening the device. Already posted 699 * blocking reads will stay, however new ones will fail. 700 */ 701 static void joydev_mark_dead(struct joydev *joydev) 702 { 703 mutex_lock(&joydev->mutex); 704 joydev->exist = 0; 705 mutex_unlock(&joydev->mutex); 706 } 707 708 static void joydev_cleanup(struct joydev *joydev) 709 { 710 struct input_handle *handle = &joydev->handle; 711 712 joydev_mark_dead(joydev); 713 joydev_hangup(joydev); 714 joydev_remove_chrdev(joydev); 715 716 /* joydev is marked dead so noone else accesses joydev->open */ 717 if (joydev->open) 718 input_close_device(handle); 719 } 720 721 static int joydev_connect(struct input_handler *handler, struct input_dev *dev, 722 const struct input_device_id *id) 723 { 724 struct joydev *joydev; 725 int i, j, t, minor; 726 int error; 727 728 for (minor = 0; minor < JOYDEV_MINORS; minor++) 729 if (!joydev_table[minor]) 730 break; 731 732 if (minor == JOYDEV_MINORS) { 733 printk(KERN_ERR "joydev: no more free joydev devices\n"); 734 return -ENFILE; 735 } 736 737 joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL); 738 if (!joydev) 739 return -ENOMEM; 740 741 INIT_LIST_HEAD(&joydev->client_list); 742 spin_lock_init(&joydev->client_lock); 743 mutex_init(&joydev->mutex); 744 init_waitqueue_head(&joydev->wait); 745 746 dev_set_name(&joydev->dev, "js%d", minor); 747 joydev->exist = 1; 748 joydev->minor = minor; 749 750 joydev->exist = 1; 751 joydev->handle.dev = input_get_device(dev); 752 joydev->handle.name = dev_name(&joydev->dev); 753 joydev->handle.handler = handler; 754 joydev->handle.private = joydev; 755 756 for (i = 0; i < ABS_MAX + 1; i++) 757 if (test_bit(i, dev->absbit)) { 758 joydev->absmap[i] = joydev->nabs; 759 joydev->abspam[joydev->nabs] = i; 760 joydev->nabs++; 761 } 762 763 for (i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++) 764 if (test_bit(i + BTN_MISC, dev->keybit)) { 765 joydev->keymap[i] = joydev->nkey; 766 joydev->keypam[joydev->nkey] = i + BTN_MISC; 767 joydev->nkey++; 768 } 769 770 for (i = 0; i < BTN_JOYSTICK - BTN_MISC; i++) 771 if (test_bit(i + BTN_MISC, dev->keybit)) { 772 joydev->keymap[i] = joydev->nkey; 773 joydev->keypam[joydev->nkey] = i + BTN_MISC; 774 joydev->nkey++; 775 } 776 777 for (i = 0; i < joydev->nabs; i++) { 778 j = joydev->abspam[i]; 779 if (dev->absmax[j] == dev->absmin[j]) { 780 joydev->corr[i].type = JS_CORR_NONE; 781 joydev->abs[i] = dev->abs[j]; 782 continue; 783 } 784 joydev->corr[i].type = JS_CORR_BROKEN; 785 joydev->corr[i].prec = dev->absfuzz[j]; 786 joydev->corr[i].coef[0] = 787 (dev->absmax[j] + dev->absmin[j]) / 2 - dev->absflat[j]; 788 joydev->corr[i].coef[1] = 789 (dev->absmax[j] + dev->absmin[j]) / 2 + dev->absflat[j]; 790 791 t = (dev->absmax[j] - dev->absmin[j]) / 2 - 2 * dev->absflat[j]; 792 if (t) { 793 joydev->corr[i].coef[2] = (1 << 29) / t; 794 joydev->corr[i].coef[3] = (1 << 29) / t; 795 796 joydev->abs[i] = joydev_correct(dev->abs[j], 797 joydev->corr + i); 798 } 799 } 800 801 joydev->dev.devt = MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor); 802 joydev->dev.class = &input_class; 803 joydev->dev.parent = &dev->dev; 804 joydev->dev.release = joydev_free; 805 device_initialize(&joydev->dev); 806 807 error = input_register_handle(&joydev->handle); 808 if (error) 809 goto err_free_joydev; 810 811 error = joydev_install_chrdev(joydev); 812 if (error) 813 goto err_unregister_handle; 814 815 error = device_add(&joydev->dev); 816 if (error) 817 goto err_cleanup_joydev; 818 819 return 0; 820 821 err_cleanup_joydev: 822 joydev_cleanup(joydev); 823 err_unregister_handle: 824 input_unregister_handle(&joydev->handle); 825 err_free_joydev: 826 put_device(&joydev->dev); 827 return error; 828 } 829 830 static void joydev_disconnect(struct input_handle *handle) 831 { 832 struct joydev *joydev = handle->private; 833 834 device_del(&joydev->dev); 835 joydev_cleanup(joydev); 836 input_unregister_handle(handle); 837 put_device(&joydev->dev); 838 } 839 840 static const struct input_device_id joydev_blacklist[] = { 841 { 842 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 843 INPUT_DEVICE_ID_MATCH_KEYBIT, 844 .evbit = { BIT_MASK(EV_KEY) }, 845 .keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) }, 846 }, /* Avoid itouchpads and touchscreens */ 847 { 848 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 849 INPUT_DEVICE_ID_MATCH_KEYBIT, 850 .evbit = { BIT_MASK(EV_KEY) }, 851 .keybit = { [BIT_WORD(BTN_DIGI)] = BIT_MASK(BTN_DIGI) }, 852 }, /* Avoid tablets, digitisers and similar devices */ 853 { } /* Terminating entry */ 854 }; 855 856 static const struct input_device_id joydev_ids[] = { 857 { 858 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 859 INPUT_DEVICE_ID_MATCH_ABSBIT, 860 .evbit = { BIT_MASK(EV_ABS) }, 861 .absbit = { BIT_MASK(ABS_X) }, 862 }, 863 { 864 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 865 INPUT_DEVICE_ID_MATCH_ABSBIT, 866 .evbit = { BIT_MASK(EV_ABS) }, 867 .absbit = { BIT_MASK(ABS_WHEEL) }, 868 }, 869 { 870 .flags = INPUT_DEVICE_ID_MATCH_EVBIT | 871 INPUT_DEVICE_ID_MATCH_ABSBIT, 872 .evbit = { BIT_MASK(EV_ABS) }, 873 .absbit = { BIT_MASK(ABS_THROTTLE) }, 874 }, 875 { } /* Terminating entry */ 876 }; 877 878 MODULE_DEVICE_TABLE(input, joydev_ids); 879 880 static struct input_handler joydev_handler = { 881 .event = joydev_event, 882 .connect = joydev_connect, 883 .disconnect = joydev_disconnect, 884 .fops = &joydev_fops, 885 .minor = JOYDEV_MINOR_BASE, 886 .name = "joydev", 887 .id_table = joydev_ids, 888 .blacklist = joydev_blacklist, 889 }; 890 891 static int __init joydev_init(void) 892 { 893 return input_register_handler(&joydev_handler); 894 } 895 896 static void __exit joydev_exit(void) 897 { 898 input_unregister_handler(&joydev_handler); 899 } 900 901 module_init(joydev_init); 902 module_exit(joydev_exit); 903