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