drivers/input/joydev.c

   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_handle_JSIOCSAXMAP(struct joydev *joydev,
 456                                      void __user *argp, size_t len)
 457 {
 458         __u8 *abspam;
 459         int i;
 460         int retval = 0;
 461
 462         len = min(len, sizeof(joydev->abspam));
 463
 464         /* Validate the map. */
 465         abspam = kmalloc(len, GFP_KERNEL);
 466         if (!abspam)
 467                 return -ENOMEM;
 468
 469         if (copy_from_user(abspam, argp, len)) {
 470                 retval = -EFAULT;
 471                 goto out;
 472         }
 473
 474         for (i = 0; i < joydev->nabs; i++) {
 475                 if (abspam[i] > ABS_MAX) {
 476                         retval = -EINVAL;
 477                         goto out;
 478                 }
 479         }
 480
 481         memcpy(joydev->abspam, abspam, len);
 482
 483  out:
 484         kfree(abspam);
 485         return retval;
 486 }
 487
 488 static int joydev_handle_JSIOCSBTNMAP(struct joydev *joydev,
 489                                       void __user *argp, size_t len)
 490 {
 491         __u16 *keypam;
 492         int i;
 493         int retval = 0;
 494
 495         len = min(len, sizeof(joydev->keypam));
 496
 497         /* Validate the map. */
 498         keypam = kmalloc(len, GFP_KERNEL);
 499         if (!keypam)
 500                 return -ENOMEM;
 501
 502         if (copy_from_user(keypam, argp, len)) {
 503                 retval = -EFAULT;
 504                 goto out;
 505         }
 506
 507         for (i = 0; i < joydev->nkey; i++) {
 508                 if (keypam[i] > KEY_MAX || keypam[i] < BTN_MISC) {
 509                         retval = -EINVAL;
 510                         goto out;
 511                 }
 512         }
 513
 514         memcpy(joydev->keypam, keypam, len);
 515
 516         for (i = 0; i < joydev->nkey; i++)
 517                 joydev->keymap[keypam[i] - BTN_MISC] = i;
 518
 519  out:
 520         kfree(keypam);
 521         return retval;
 522 }
 523
 524
 525 static int joydev_ioctl_common(struct joydev *joydev,
 526                                 unsigned int cmd, void __user *argp)
 527 {
 528         struct input_dev *dev = joydev->handle.dev;
 529         size_t len;
 530         int i, j;
 531         const char *name;
 532
 533         /* Process fixed-sized commands. */
 534         switch (cmd) {
 535
 536         case JS_SET_CAL:
 537                 return copy_from_user(&joydev->glue.JS_CORR, argp,
 538                                 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0;
 539
 540         case JS_GET_CAL:
 541                 return copy_to_user(argp, &joydev->glue.JS_CORR,
 542                                 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0;
 543
 544         case JS_SET_TIMEOUT:
 545                 return get_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp);
 546
 547         case JS_GET_TIMEOUT:
 548                 return put_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp);
 549
 550         case JSIOCGVERSION:
 551                 return put_user(JS_VERSION, (__u32 __user *) argp);
 552
 553         case JSIOCGAXES:
 554                 return put_user(joydev->nabs, (__u8 __user *) argp);
 555
 556         case JSIOCGBUTTONS:
 557                 return put_user(joydev->nkey, (__u8 __user *) argp);
 558
 559         case JSIOCSCORR:
 560                 if (copy_from_user(joydev->corr, argp,
 561                               sizeof(joydev->corr[0]) * joydev->nabs))
 562                     return -EFAULT;
 563
 564                 for (i = 0; i < joydev->nabs; i++) {
 565                         j = joydev->abspam[i];
 566                         joydev->abs[i] = joydev_correct(dev->abs[j],
 567                                                         &joydev->corr[i]);
 568                 }
 569                 return 0;
 570
 571         case JSIOCGCORR:
 572                 return copy_to_user(argp, joydev->corr,
 573                         sizeof(joydev->corr[0]) * joydev->nabs) ? -EFAULT : 0;
 574
 575         }
 576
 577         /*
 578          * Process variable-sized commands (the axis and button map commands
 579          * are considered variable-sized to decouple them from the values of
 580          * ABS_MAX and KEY_MAX).
 581          */
 582         switch (cmd & ~IOCSIZE_MASK) {
 583
 584         case (JSIOCSAXMAP & ~IOCSIZE_MASK):
 585                 return joydev_handle_JSIOCSAXMAP(joydev, argp, _IOC_SIZE(cmd));
 586
 587         case (JSIOCGAXMAP & ~IOCSIZE_MASK):
 588                 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->abspam));
 589                 return copy_to_user(argp, joydev->abspam, len) ? -EFAULT : len;
 590
 591         case (JSIOCSBTNMAP & ~IOCSIZE_MASK):
 592                 return joydev_handle_JSIOCSBTNMAP(joydev, argp, _IOC_SIZE(cmd));
 593
 594         case (JSIOCGBTNMAP & ~IOCSIZE_MASK):
 595                 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->keypam));
 596                 return copy_to_user(argp, joydev->keypam, len) ? -EFAULT : len;
 597
 598         case JSIOCGNAME(0):
 599                 name = dev->name;
 600                 if (!name)
 601                         return 0;
 602
 603                 len = min_t(size_t, _IOC_SIZE(cmd), strlen(name) + 1);
 604                 return copy_to_user(argp, name, len) ? -EFAULT : len;
 605         }
 606
 607         return -EINVAL;
 608 }
 609
 610 #ifdef CONFIG_COMPAT
 611 static long joydev_compat_ioctl(struct file *file,
 612                                 unsigned int cmd, unsigned long arg)
 613 {
 614         struct joydev_client *client = file->private_data;
 615         struct joydev *joydev = client->joydev;
 616         void __user *argp = (void __user *)arg;
 617         s32 tmp32;
 618         struct JS_DATA_SAVE_TYPE_32 ds32;
 619         int retval;
 620
 621         retval = mutex_lock_interruptible(&joydev->mutex);
 622         if (retval)
 623                 return retval;
 624
 625         if (!joydev->exist) {
 626                 retval = -ENODEV;
 627                 goto out;
 628         }
 629
 630         switch (cmd) {
 631
 632         case JS_SET_TIMELIMIT:
 633                 retval = get_user(tmp32, (s32 __user *) arg);
 634                 if (retval == 0)
 635                         joydev->glue.JS_TIMELIMIT = tmp32;
 636                 break;
 637
 638         case JS_GET_TIMELIMIT:
 639                 tmp32 = joydev->glue.JS_TIMELIMIT;
 640                 retval = put_user(tmp32, (s32 __user *) arg);
 641                 break;
 642
 643         case JS_SET_ALL:
 644                 retval = copy_from_user(&ds32, argp,
 645                                         sizeof(ds32)) ? -EFAULT : 0;
 646                 if (retval == 0) {
 647                         joydev->glue.JS_TIMEOUT    = ds32.JS_TIMEOUT;
 648                         joydev->glue.BUSY          = ds32.BUSY;
 649                         joydev->glue.JS_EXPIRETIME = ds32.JS_EXPIRETIME;
 650                         joydev->glue.JS_TIMELIMIT  = ds32.JS_TIMELIMIT;
 651                         joydev->glue.JS_SAVE       = ds32.JS_SAVE;
 652                         joydev->glue.JS_CORR       = ds32.JS_CORR;
 653                 }
 654                 break;
 655
 656         case JS_GET_ALL:
 657                 ds32.JS_TIMEOUT    = joydev->glue.JS_TIMEOUT;
 658                 ds32.BUSY          = joydev->glue.BUSY;
 659                 ds32.JS_EXPIRETIME = joydev->glue.JS_EXPIRETIME;
 660                 ds32.JS_TIMELIMIT  = joydev->glue.JS_TIMELIMIT;
 661                 ds32.JS_SAVE       = joydev->glue.JS_SAVE;
 662                 ds32.JS_CORR       = joydev->glue.JS_CORR;
 663
 664                 retval = copy_to_user(argp, &ds32, sizeof(ds32)) ? -EFAULT : 0;
 665                 break;
 666
 667         default:
 668                 retval = joydev_ioctl_common(joydev, cmd, argp);
 669                 break;
 670         }
 671
 672  out:
 673         mutex_unlock(&joydev->mutex);
 674         return retval;
 675 }
 676 #endif /* CONFIG_COMPAT */
 677
 678 static long joydev_ioctl(struct file *file,
 679                          unsigned int cmd, unsigned long arg)
 680 {
 681         struct joydev_client *client = file->private_data;
 682         struct joydev *joydev = client->joydev;
 683         void __user *argp = (void __user *)arg;
 684         int retval;
 685
 686         retval = mutex_lock_interruptible(&joydev->mutex);
 687         if (retval)
 688                 return retval;
 689
 690         if (!joydev->exist) {
 691                 retval = -ENODEV;
 692                 goto out;
 693         }
 694
 695         switch (cmd) {
 696
 697         case JS_SET_TIMELIMIT:
 698                 retval = get_user(joydev->glue.JS_TIMELIMIT,
 699                                   (long __user *) arg);
 700                 break;
 701
 702         case JS_GET_TIMELIMIT:
 703                 retval = put_user(joydev->glue.JS_TIMELIMIT,
 704                                   (long __user *) arg);
 705                 break;
 706
 707         case JS_SET_ALL:
 708                 retval = copy_from_user(&joydev->glue, argp,
 709                                         sizeof(joydev->glue)) ? -EFAULT: 0;
 710                 break;
 711
 712         case JS_GET_ALL:
 713                 retval = copy_to_user(argp, &joydev->glue,
 714                                       sizeof(joydev->glue)) ? -EFAULT : 0;
 715                 break;
 716
 717         default:
 718                 retval = joydev_ioctl_common(joydev, cmd, argp);
 719                 break;
 720         }
 721  out:
 722         mutex_unlock(&joydev->mutex);
 723         return retval;
 724 }
 725
 726 static const struct file_operations joydev_fops = {
 727         .owner          = THIS_MODULE,
 728         .read           = joydev_read,
 729         .poll           = joydev_poll,
 730         .open           = joydev_open,
 731         .release        = joydev_release,
 732         .unlocked_ioctl = joydev_ioctl,
 733 #ifdef CONFIG_COMPAT
 734         .compat_ioctl   = joydev_compat_ioctl,
 735 #endif
 736         .fasync         = joydev_fasync,
 737 };
 738
 739 static int joydev_install_chrdev(struct joydev *joydev)
 740 {
 741         joydev_table[joydev->minor] = joydev;
 742         return 0;
 743 }
 744
 745 static void joydev_remove_chrdev(struct joydev *joydev)
 746 {
 747         mutex_lock(&joydev_table_mutex);
 748         joydev_table[joydev->minor] = NULL;
 749         mutex_unlock(&joydev_table_mutex);
 750 }
 751
 752 /*
 753  * Mark device non-existant. This disables writes, ioctls and
 754  * prevents new users from opening the device. Already posted
 755  * blocking reads will stay, however new ones will fail.
 756  */
 757 static void joydev_mark_dead(struct joydev *joydev)
 758 {
 759         mutex_lock(&joydev->mutex);
 760         joydev->exist = 0;
 761         mutex_unlock(&joydev->mutex);
 762 }
 763
 764 static void joydev_cleanup(struct joydev *joydev)
 765 {
 766         struct input_handle *handle = &joydev->handle;
 767
 768         joydev_mark_dead(joydev);
 769         joydev_hangup(joydev);
 770         joydev_remove_chrdev(joydev);
 771
 772         /* joydev is marked dead so noone else accesses joydev->open */
 773         if (joydev->open)
 774                 input_close_device(handle);
 775 }
 776
 777 static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
 778                           const struct input_device_id *id)
 779 {
 780         struct joydev *joydev;
 781         int i, j, t, minor;
 782         int error;
 783
 784         for (minor = 0; minor < JOYDEV_MINORS; minor++)
 785                 if (!joydev_table[minor])
 786                         break;
 787
 788         if (minor == JOYDEV_MINORS) {
 789                 printk(KERN_ERR "joydev: no more free joydev devices\n");
 790                 return -ENFILE;
 791         }
 792
 793         joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL);
 794         if (!joydev)
 795                 return -ENOMEM;
 796
 797         INIT_LIST_HEAD(&joydev->client_list);
 798         spin_lock_init(&joydev->client_lock);
 799         mutex_init(&joydev->mutex);
 800         init_waitqueue_head(&joydev->wait);
 801
 802         dev_set_name(&joydev->dev, "js%d", minor);
 803         joydev->exist = 1;
 804         joydev->minor = minor;
 805
 806         joydev->exist = 1;
 807         joydev->handle.dev = input_get_device(dev);
 808         joydev->handle.name = dev_name(&joydev->dev);
 809         joydev->handle.handler = handler;
 810         joydev->handle.private = joydev;
 811
 812         for (i = 0; i < ABS_MAX + 1; i++)
 813                 if (test_bit(i, dev->absbit)) {
 814                         joydev->absmap[i] = joydev->nabs;
 815                         joydev->abspam[joydev->nabs] = i;
 816                         joydev->nabs++;
 817                 }
 818
 819         for (i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++)
 820                 if (test_bit(i + BTN_MISC, dev->keybit)) {
 821                         joydev->keymap[i] = joydev->nkey;
 822                         joydev->keypam[joydev->nkey] = i + BTN_MISC;
 823                         joydev->nkey++;
 824                 }
 825
 826         for (i = 0; i < BTN_JOYSTICK - BTN_MISC; i++)
 827                 if (test_bit(i + BTN_MISC, dev->keybit)) {
 828                         joydev->keymap[i] = joydev->nkey;
 829                         joydev->keypam[joydev->nkey] = i + BTN_MISC;
 830                         joydev->nkey++;
 831                 }
 832
 833         for (i = 0; i < joydev->nabs; i++) {
 834                 j = joydev->abspam[i];
 835                 if (dev->absmax[j] == dev->absmin[j]) {
 836                         joydev->corr[i].type = JS_CORR_NONE;
 837                         joydev->abs[i] = dev->abs[j];
 838                         continue;
 839                 }
 840                 joydev->corr[i].type = JS_CORR_BROKEN;
 841                 joydev->corr[i].prec = dev->absfuzz[j];
 842                 joydev->corr[i].coef[0] =
 843                         (dev->absmax[j] + dev->absmin[j]) / 2 - dev->absflat[j];
 844                 joydev->corr[i].coef[1] =
 845                         (dev->absmax[j] + dev->absmin[j]) / 2 + dev->absflat[j];
 846
 847                 t = (dev->absmax[j] - dev->absmin[j]) / 2 - 2 * dev->absflat[j];
 848                 if (t) {
 849                         joydev->corr[i].coef[2] = (1 << 29) / t;
 850                         joydev->corr[i].coef[3] = (1 << 29) / t;
 851
 852                         joydev->abs[i] = joydev_correct(dev->abs[j],
 853                                                         joydev->corr + i);
 854                 }
 855         }
 856
 857         joydev->dev.devt = MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor);
 858         joydev->dev.class = &input_class;
 859         joydev->dev.parent = &dev->dev;
 860         joydev->dev.release = joydev_free;
 861         device_initialize(&joydev->dev);
 862
 863         error = input_register_handle(&joydev->handle);
 864         if (error)
 865                 goto err_free_joydev;
 866
 867         error = joydev_install_chrdev(joydev);
 868         if (error)
 869                 goto err_unregister_handle;
 870
 871         error = device_add(&joydev->dev);
 872         if (error)
 873                 goto err_cleanup_joydev;
 874
 875         return 0;
 876
 877  err_cleanup_joydev:
 878         joydev_cleanup(joydev);
 879  err_unregister_handle:
 880         input_unregister_handle(&joydev->handle);
 881  err_free_joydev:
 882         put_device(&joydev->dev);
 883         return error;
 884 }
 885
 886 static void joydev_disconnect(struct input_handle *handle)
 887 {
 888         struct joydev *joydev = handle->private;
 889
 890         device_del(&joydev->dev);
 891         joydev_cleanup(joydev);
 892         input_unregister_handle(handle);
 893         put_device(&joydev->dev);
 894 }
 895
 896 static const struct input_device_id joydev_blacklist[] = {
 897         {
 898                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
 899                                 INPUT_DEVICE_ID_MATCH_KEYBIT,
 900                 .evbit = { BIT_MASK(EV_KEY) },
 901                 .keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) },
 902         },      /* Avoid itouchpads and touchscreens */
 903         {
 904                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
 905                                 INPUT_DEVICE_ID_MATCH_KEYBIT,
 906                 .evbit = { BIT_MASK(EV_KEY) },
 907                 .keybit = { [BIT_WORD(BTN_DIGI)] = BIT_MASK(BTN_DIGI) },
 908         },      /* Avoid tablets, digitisers and similar devices */
 909         { }     /* Terminating entry */
 910 };
 911
 912 static const struct input_device_id joydev_ids[] = {
 913         {
 914                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
 915                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
 916                 .evbit = { BIT_MASK(EV_ABS) },
 917                 .absbit = { BIT_MASK(ABS_X) },
 918         },
 919         {
 920                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
 921                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
 922                 .evbit = { BIT_MASK(EV_ABS) },
 923                 .absbit = { BIT_MASK(ABS_WHEEL) },
 924         },
 925         {
 926                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
 927                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
 928                 .evbit = { BIT_MASK(EV_ABS) },
 929                 .absbit = { BIT_MASK(ABS_THROTTLE) },
 930         },
 931         { }     /* Terminating entry */
 932 };
 933
 934 MODULE_DEVICE_TABLE(input, joydev_ids);
 935
 936 static struct input_handler joydev_handler = {
 937         .event          = joydev_event,
 938         .connect        = joydev_connect,
 939         .disconnect     = joydev_disconnect,
 940         .fops           = &joydev_fops,
 941         .minor          = JOYDEV_MINOR_BASE,
 942         .name           = "joydev",
 943         .id_table       = joydev_ids,
 944         .blacklist      = joydev_blacklist,
 945 };
 946
 947 static int __init joydev_init(void)
 948 {
 949         return input_register_handler(&joydev_handler);
 950 }
 951
 952 static void __exit joydev_exit(void)
 953 {
 954         input_unregister_handler(&joydev_handler);
 955 }
 956
 957 module_init(joydev_init);
 958 module_exit(joydev_exit);