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