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