drivers/input/evdev.c

   1 /*
   2  * Event char devices, giving access to raw input device events.
   3  *
   4  * Copyright (c) 1999-2002 Vojtech Pavlik
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  */
  10
  11 #define EVDEV_MINOR_BASE        64
  12 #define EVDEV_MINORS            32
  13 #define EVDEV_BUFFER_SIZE       64
  14
  15 #include <linux/poll.h>
  16 #include <linux/slab.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/input.h>
  20 #include <linux/major.h>
  21 #include <linux/device.h>
  22 #include <linux/compat.h>
  23
  24 struct evdev {
  25         int exist;
  26         int open;
  27         int minor;
  28         char name[16];
  29         struct input_handle handle;
  30         wait_queue_head_t wait;
  31         struct evdev_client *grab;
  32         struct list_head client_list;
  33         struct device dev;
  34 };
  35
  36 struct evdev_client {
  37         struct input_event buffer[EVDEV_BUFFER_SIZE];
  38         int head;
  39         int tail;
  40         struct fasync_struct *fasync;
  41         struct evdev *evdev;
  42         struct list_head node;
  43 };
  44
  45 static struct evdev *evdev_table[EVDEV_MINORS];
  46
  47 static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
  48 {
  49         struct evdev *evdev = handle->private;
  50         struct evdev_client *client;
  51
  52         if (evdev->grab) {
  53                 client = evdev->grab;
  54
  55                 do_gettimeofday(&client->buffer[client->head].time);
  56                 client->buffer[client->head].type = type;
  57                 client->buffer[client->head].code = code;
  58                 client->buffer[client->head].value = value;
  59                 client->head = (client->head + 1) & (EVDEV_BUFFER_SIZE - 1);
  60
  61                 kill_fasync(&client->fasync, SIGIO, POLL_IN);
  62         } else
  63                 list_for_each_entry(client, &evdev->client_list, node) {
  64
  65                         do_gettimeofday(&client->buffer[client->head].time);
  66                         client->buffer[client->head].type = type;
  67                         client->buffer[client->head].code = code;
  68                         client->buffer[client->head].value = value;
  69                         client->head = (client->head + 1) & (EVDEV_BUFFER_SIZE - 1);
  70
  71                         kill_fasync(&client->fasync, SIGIO, POLL_IN);
  72                 }
  73
  74         wake_up_interruptible(&evdev->wait);
  75 }
  76
  77 static int evdev_fasync(int fd, struct file *file, int on)
  78 {
  79         struct evdev_client *client = file->private_data;
  80         int retval;
  81
  82         retval = fasync_helper(fd, file, on, &client->fasync);
  83
  84         return retval < 0 ? retval : 0;
  85 }
  86
  87 static int evdev_flush(struct file *file, fl_owner_t id)
  88 {
  89         struct evdev_client *client = file->private_data;
  90         struct evdev *evdev = client->evdev;
  91
  92         if (!evdev->exist)
  93                 return -ENODEV;
  94
  95         return input_flush_device(&evdev->handle, file);
  96 }
  97
  98 static void evdev_free(struct device *dev)
  99 {
 100         struct evdev *evdev = container_of(dev, struct evdev, dev);
 101
 102         evdev_table[evdev->minor] = NULL;
 103         kfree(evdev);
 104 }
 105
 106 static int evdev_release(struct inode *inode, struct file *file)
 107 {
 108         struct evdev_client *client = file->private_data;
 109         struct evdev *evdev = client->evdev;
 110
 111         if (evdev->grab == client) {
 112                 input_release_device(&evdev->handle);
 113                 evdev->grab = NULL;
 114         }
 115
 116         evdev_fasync(-1, file, 0);
 117         list_del(&client->node);
 118         kfree(client);
 119
 120         if (!--evdev->open && evdev->exist)
 121                 input_close_device(&evdev->handle);
 122
 123         put_device(&evdev->dev);
 124
 125         return 0;
 126 }
 127
 128 static int evdev_open(struct inode *inode, struct file *file)
 129 {
 130         struct evdev_client *client;
 131         struct evdev *evdev;
 132         int i = iminor(inode) - EVDEV_MINOR_BASE;
 133         int error;
 134
 135         if (i >= EVDEV_MINORS)
 136                 return -ENODEV;
 137
 138         evdev = evdev_table[i];
 139
 140         if (!evdev || !evdev->exist)
 141                 return -ENODEV;
 142
 143         get_device(&evdev->dev);
 144
 145         client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
 146         if (!client) {
 147                 error = -ENOMEM;
 148                 goto err_put_evdev;
 149         }
 150
 151         client->evdev = evdev;
 152         list_add_tail(&client->node, &evdev->client_list);
 153
 154         if (!evdev->open++ && evdev->exist) {
 155                 error = input_open_device(&evdev->handle);
 156                 if (error)
 157                         goto err_free_client;
 158         }
 159
 160         file->private_data = client;
 161         return 0;
 162
 163  err_free_client:
 164         list_del(&client->node);
 165         kfree(client);
 166  err_put_evdev:
 167         put_device(&evdev->dev);
 168         return error;
 169 }
 170
 171 #ifdef CONFIG_COMPAT
 172
 173 struct input_event_compat {
 174         struct compat_timeval time;
 175         __u16 type;
 176         __u16 code;
 177         __s32 value;
 178 };
 179
 180 /* Note to the author of this code: did it ever occur to
 181    you why the ifdefs are needed? Think about it again. -AK */
 182 #ifdef CONFIG_X86_64
 183 #  define COMPAT_TEST is_compat_task()
 184 #elif defined(CONFIG_IA64)
 185 #  define COMPAT_TEST IS_IA32_PROCESS(task_pt_regs(current))
 186 #elif defined(CONFIG_S390)
 187 #  define COMPAT_TEST test_thread_flag(TIF_31BIT)
 188 #elif defined(CONFIG_MIPS)
 189 #  define COMPAT_TEST test_thread_flag(TIF_32BIT_ADDR)
 190 #else
 191 #  define COMPAT_TEST test_thread_flag(TIF_32BIT)
 192 #endif
 193
 194 static inline size_t evdev_event_size(void)
 195 {
 196         return COMPAT_TEST ?
 197                 sizeof(struct input_event_compat) : sizeof(struct input_event);
 198 }
 199
 200 static int evdev_event_from_user(const char __user *buffer, struct input_event *event)
 201 {
 202         if (COMPAT_TEST) {
 203                 struct input_event_compat compat_event;
 204
 205                 if (copy_from_user(&compat_event, buffer, sizeof(struct input_event_compat)))
 206                         return -EFAULT;
 207
 208                 event->time.tv_sec = compat_event.time.tv_sec;
 209                 event->time.tv_usec = compat_event.time.tv_usec;
 210                 event->type = compat_event.type;
 211                 event->code = compat_event.code;
 212                 event->value = compat_event.value;
 213
 214         } else {
 215                 if (copy_from_user(event, buffer, sizeof(struct input_event)))
 216                         return -EFAULT;
 217         }
 218
 219         return 0;
 220 }
 221
 222 static int evdev_event_to_user(char __user *buffer, const struct input_event *event)
 223 {
 224         if (COMPAT_TEST) {
 225                 struct input_event_compat compat_event;
 226
 227                 compat_event.time.tv_sec = event->time.tv_sec;
 228                 compat_event.time.tv_usec = event->time.tv_usec;
 229                 compat_event.type = event->type;
 230                 compat_event.code = event->code;
 231                 compat_event.value = event->value;
 232
 233                 if (copy_to_user(buffer, &compat_event, sizeof(struct input_event_compat)))
 234                         return -EFAULT;
 235
 236         } else {
 237                 if (copy_to_user(buffer, event, sizeof(struct input_event)))
 238                         return -EFAULT;
 239         }
 240
 241         return 0;
 242 }
 243
 244 #else
 245
 246 static inline size_t evdev_event_size(void)
 247 {
 248         return sizeof(struct input_event);
 249 }
 250
 251 static int evdev_event_from_user(const char __user *buffer, struct input_event *event)
 252 {
 253         if (copy_from_user(event, buffer, sizeof(struct input_event)))
 254                 return -EFAULT;
 255
 256         return 0;
 257 }
 258
 259 static int evdev_event_to_user(char __user *buffer, const struct input_event *event)
 260 {
 261         if (copy_to_user(buffer, event, sizeof(struct input_event)))
 262                 return -EFAULT;
 263
 264         return 0;
 265 }
 266
 267 #endif /* CONFIG_COMPAT */
 268
 269 static ssize_t evdev_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 270 {
 271         struct evdev_client *client = file->private_data;
 272         struct evdev *evdev = client->evdev;
 273         struct input_event event;
 274         int retval = 0;
 275
 276         if (!evdev->exist)
 277                 return -ENODEV;
 278
 279         while (retval < count) {
 280
 281                 if (evdev_event_from_user(buffer + retval, &event))
 282                         return -EFAULT;
 283                 input_inject_event(&evdev->handle, event.type, event.code, event.value);
 284                 retval += evdev_event_size();
 285         }
 286
 287         return retval;
 288 }
 289
 290 static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 291 {
 292         struct evdev_client *client = file->private_data;
 293         struct evdev *evdev = client->evdev;
 294         int retval;
 295
 296         if (count < evdev_event_size())
 297                 return -EINVAL;
 298
 299         if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK))
 300                 return -EAGAIN;
 301
 302         retval = wait_event_interruptible(evdev->wait,
 303                 client->head != client->tail || !evdev->exist);
 304         if (retval)
 305                 return retval;
 306
 307         if (!evdev->exist)
 308                 return -ENODEV;
 309
 310         while (client->head != client->tail && retval + evdev_event_size() <= count) {
 311
 312                 struct input_event *event = (struct input_event *) client->buffer + client->tail;
 313
 314                 if (evdev_event_to_user(buffer + retval, event))
 315                         return -EFAULT;
 316
 317                 client->tail = (client->tail + 1) & (EVDEV_BUFFER_SIZE - 1);
 318                 retval += evdev_event_size();
 319         }
 320
 321         return retval;
 322 }
 323
 324 /* No kernel lock - fine */
 325 static unsigned int evdev_poll(struct file *file, poll_table *wait)
 326 {
 327         struct evdev_client *client = file->private_data;
 328         struct evdev *evdev = client->evdev;
 329
 330         poll_wait(file, &evdev->wait, wait);
 331         return ((client->head == client->tail) ? 0 : (POLLIN | POLLRDNORM)) |
 332                 (evdev->exist ? 0 : (POLLHUP | POLLERR));
 333 }
 334
 335 #ifdef CONFIG_COMPAT
 336
 337 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
 338 #define NBITS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
 339
 340 #ifdef __BIG_ENDIAN
 341 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 342                         unsigned int maxlen, void __user *p, int compat)
 343 {
 344         int len, i;
 345
 346         if (compat) {
 347                 len = NBITS_COMPAT(maxbit) * sizeof(compat_long_t);
 348                 if (len > maxlen)
 349                         len = maxlen;
 350
 351                 for (i = 0; i < len / sizeof(compat_long_t); i++)
 352                         if (copy_to_user((compat_long_t __user *) p + i,
 353                                          (compat_long_t *) bits +
 354                                                 i + 1 - ((i % 2) << 1),
 355                                          sizeof(compat_long_t)))
 356                                 return -EFAULT;
 357         } else {
 358                 len = NBITS(maxbit) * sizeof(long);
 359                 if (len > maxlen)
 360                         len = maxlen;
 361
 362                 if (copy_to_user(p, bits, len))
 363                         return -EFAULT;
 364         }
 365
 366         return len;
 367 }
 368 #else
 369 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 370                         unsigned int maxlen, void __user *p, int compat)
 371 {
 372         int len = compat ?
 373                         NBITS_COMPAT(maxbit) * sizeof(compat_long_t) :
 374                         NBITS(maxbit) * sizeof(long);
 375
 376         if (len > maxlen)
 377                 len = maxlen;
 378
 379         return copy_to_user(p, bits, len) ? -EFAULT : len;
 380 }
 381 #endif /* __BIG_ENDIAN */
 382
 383 #else
 384
 385 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 386                         unsigned int maxlen, void __user *p, int compat)
 387 {
 388         int len = NBITS(maxbit) * sizeof(long);
 389
 390         if (len > maxlen)
 391                 len = maxlen;
 392
 393         return copy_to_user(p, bits, len) ? -EFAULT : len;
 394 }
 395
 396 #endif /* CONFIG_COMPAT */
 397
 398 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 399 {
 400         int len;
 401
 402         if (!str)
 403                 return -ENOENT;
 404
 405         len = strlen(str) + 1;
 406         if (len > maxlen)
 407                 len = maxlen;
 408
 409         return copy_to_user(p, str, len) ? -EFAULT : len;
 410 }
 411
 412 static long evdev_ioctl_handler(struct file *file, unsigned int cmd,
 413                                 void __user *p, int compat_mode)
 414 {
 415         struct evdev_client *client = file->private_data;
 416         struct evdev *evdev = client->evdev;
 417         struct input_dev *dev = evdev->handle.dev;
 418         struct input_absinfo abs;
 419         struct ff_effect effect;
 420         int __user *ip = (int __user *)p;
 421         int i, t, u, v;
 422         int error;
 423
 424         if (!evdev->exist)
 425                 return -ENODEV;
 426
 427         switch (cmd) {
 428
 429                 case EVIOCGVERSION:
 430                         return put_user(EV_VERSION, ip);
 431
 432                 case EVIOCGID:
 433                         if (copy_to_user(p, &dev->id, sizeof(struct input_id)))
 434                                 return -EFAULT;
 435                         return 0;
 436
 437                 case EVIOCGREP:
 438                         if (!test_bit(EV_REP, dev->evbit))
 439                                 return -ENOSYS;
 440                         if (put_user(dev->rep[REP_DELAY], ip))
 441                                 return -EFAULT;
 442                         if (put_user(dev->rep[REP_PERIOD], ip + 1))
 443                                 return -EFAULT;
 444                         return 0;
 445
 446                 case EVIOCSREP:
 447                         if (!test_bit(EV_REP, dev->evbit))
 448                                 return -ENOSYS;
 449                         if (get_user(u, ip))
 450                                 return -EFAULT;
 451                         if (get_user(v, ip + 1))
 452                                 return -EFAULT;
 453
 454                         input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u);
 455                         input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v);
 456
 457                         return 0;
 458
 459                 case EVIOCGKEYCODE:
 460                         if (get_user(t, ip))
 461                                 return -EFAULT;
 462
 463                         error = dev->getkeycode(dev, t, &v);
 464                         if (error)
 465                                 return error;
 466
 467                         if (put_user(v, ip + 1))
 468                                 return -EFAULT;
 469
 470                         return 0;
 471
 472                 case EVIOCSKEYCODE:
 473                         if (get_user(t, ip) || get_user(v, ip + 1))
 474                                 return -EFAULT;
 475
 476                         return dev->setkeycode(dev, t, v);
 477
 478                 case EVIOCSFF:
 479                         if (copy_from_user(&effect, p, sizeof(effect)))
 480                                 return -EFAULT;
 481
 482                         error = input_ff_upload(dev, &effect, file);
 483
 484                         if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
 485                                 return -EFAULT;
 486
 487                         return error;
 488
 489                 case EVIOCRMFF:
 490                         return input_ff_erase(dev, (int)(unsigned long) p, file);
 491
 492                 case EVIOCGEFFECTS:
 493                         i = test_bit(EV_FF, dev->evbit) ? dev->ff->max_effects : 0;
 494                         if (put_user(i, ip))
 495                                 return -EFAULT;
 496                         return 0;
 497
 498                 case EVIOCGRAB:
 499                         if (p) {
 500                                 if (evdev->grab)
 501                                         return -EBUSY;
 502                                 if (input_grab_device(&evdev->handle))
 503                                         return -EBUSY;
 504                                 evdev->grab = client;
 505                                 return 0;
 506                         } else {
 507                                 if (evdev->grab != client)
 508                                         return -EINVAL;
 509                                 input_release_device(&evdev->handle);
 510                                 evdev->grab = NULL;
 511                                 return 0;
 512                         }
 513
 514                 default:
 515
 516                         if (_IOC_TYPE(cmd) != 'E')
 517                                 return -EINVAL;
 518
 519                         if (_IOC_DIR(cmd) == _IOC_READ) {
 520
 521                                 if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {
 522
 523                                         unsigned long *bits;
 524                                         int len;
 525
 526                                         switch (_IOC_NR(cmd) & EV_MAX) {
 527                                                 case      0: bits = dev->evbit;  len = EV_MAX;  break;
 528                                                 case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
 529                                                 case EV_REL: bits = dev->relbit; len = REL_MAX; break;
 530                                                 case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
 531                                                 case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
 532                                                 case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
 533                                                 case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
 534                                                 case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
 535                                                 case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;
 536                                                 default: return -EINVAL;
 537                                         }
 538                                         return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);
 539                                 }
 540
 541                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))
 542                                         return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd),
 543                                                             p, compat_mode);
 544
 545                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0)))
 546                                         return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd),
 547                                                             p, compat_mode);
 548
 549                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))
 550                                         return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd),
 551                                                             p, compat_mode);
 552
 553                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))
 554                                         return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd),
 555                                                             p, compat_mode);
 556
 557                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0)))
 558                                         return str_to_user(dev->name, _IOC_SIZE(cmd), p);
 559
 560                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0)))
 561                                         return str_to_user(dev->phys, _IOC_SIZE(cmd), p);
 562
 563                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0)))
 564                                         return str_to_user(dev->uniq, _IOC_SIZE(cmd), p);
 565
 566                                 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
 567
 568                                         t = _IOC_NR(cmd) & ABS_MAX;
 569
 570                                         abs.value = dev->abs[t];
 571                                         abs.minimum = dev->absmin[t];
 572                                         abs.maximum = dev->absmax[t];
 573                                         abs.fuzz = dev->absfuzz[t];
 574                                         abs.flat = dev->absflat[t];
 575
 576                                         if (copy_to_user(p, &abs, sizeof(struct input_absinfo)))
 577                                                 return -EFAULT;
 578
 579                                         return 0;
 580                                 }
 581
 582                         }
 583
 584                         if (_IOC_DIR(cmd) == _IOC_WRITE) {
 585
 586                                 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
 587
 588                                         t = _IOC_NR(cmd) & ABS_MAX;
 589
 590                                         if (copy_from_user(&abs, p, sizeof(struct input_absinfo)))
 591                                                 return -EFAULT;
 592
 593                                         dev->abs[t] = abs.value;
 594                                         dev->absmin[t] = abs.minimum;
 595                                         dev->absmax[t] = abs.maximum;
 596                                         dev->absfuzz[t] = abs.fuzz;
 597                                         dev->absflat[t] = abs.flat;
 598
 599                                         return 0;
 600                                 }
 601                         }
 602         }
 603         return -EINVAL;
 604 }
 605
 606 static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 607 {
 608         return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0);
 609 }
 610
 611 #ifdef CONFIG_COMPAT
 612 static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
 613 {
 614         return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1);
 615 }
 616 #endif
 617
 618 static const struct file_operations evdev_fops = {
 619         .owner =        THIS_MODULE,
 620         .read =         evdev_read,
 621         .write =        evdev_write,
 622         .poll =         evdev_poll,
 623         .open =         evdev_open,
 624         .release =      evdev_release,
 625         .unlocked_ioctl = evdev_ioctl,
 626 #ifdef CONFIG_COMPAT
 627         .compat_ioctl = evdev_ioctl_compat,
 628 #endif
 629         .fasync =       evdev_fasync,
 630         .flush =        evdev_flush
 631 };
 632
 633 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
 634                          const struct input_device_id *id)
 635 {
 636         struct evdev *evdev;
 637         int minor;
 638         int error;
 639
 640         for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);
 641         if (minor == EVDEV_MINORS) {
 642                 printk(KERN_ERR "evdev: no more free evdev devices\n");
 643                 return -ENFILE;
 644         }
 645
 646         evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
 647         if (!evdev)
 648                 return -ENOMEM;
 649
 650         INIT_LIST_HEAD(&evdev->client_list);
 651         init_waitqueue_head(&evdev->wait);
 652
 653         evdev->exist = 1;
 654         evdev->minor = minor;
 655         evdev->handle.dev = dev;
 656         evdev->handle.name = evdev->name;
 657         evdev->handle.handler = handler;
 658         evdev->handle.private = evdev;
 659         snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);
 660
 661         snprintf(evdev->dev.bus_id, sizeof(evdev->dev.bus_id),
 662                  "event%d", minor);
 663         evdev->dev.class = &input_class;
 664         evdev->dev.parent = &dev->dev;
 665         evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
 666         evdev->dev.release = evdev_free;
 667         device_initialize(&evdev->dev);
 668
 669         evdev_table[minor] = evdev;
 670
 671         error = device_add(&evdev->dev);
 672         if (error)
 673                 goto err_free_evdev;
 674
 675         error = input_register_handle(&evdev->handle);
 676         if (error)
 677                 goto err_delete_evdev;
 678
 679         return 0;
 680
 681  err_delete_evdev:
 682         device_del(&evdev->dev);
 683  err_free_evdev:
 684         put_device(&evdev->dev);
 685         return error;
 686 }
 687
 688 static void evdev_disconnect(struct input_handle *handle)
 689 {
 690         struct evdev *evdev = handle->private;
 691         struct evdev_client *client;
 692
 693         input_unregister_handle(handle);
 694         device_del(&evdev->dev);
 695
 696         evdev->exist = 0;
 697
 698         if (evdev->open) {
 699                 input_flush_device(handle, NULL);
 700                 input_close_device(handle);
 701                 list_for_each_entry(client, &evdev->client_list, node)
 702                         kill_fasync(&client->fasync, SIGIO, POLL_HUP);
 703                 wake_up_interruptible(&evdev->wait);
 704         }
 705
 706         put_device(&evdev->dev);
 707 }
 708
 709 static const struct input_device_id evdev_ids[] = {
 710         { .driver_info = 1 },   /* Matches all devices */
 711         { },                    /* Terminating zero entry */
 712 };
 713
 714 MODULE_DEVICE_TABLE(input, evdev_ids);
 715
 716 static struct input_handler evdev_handler = {
 717         .event =        evdev_event,
 718         .connect =      evdev_connect,
 719         .disconnect =   evdev_disconnect,
 720         .fops =         &evdev_fops,
 721         .minor =        EVDEV_MINOR_BASE,
 722         .name =         "evdev",
 723         .id_table =     evdev_ids,
 724 };
 725
 726 static int __init evdev_init(void)
 727 {
 728         return input_register_handler(&evdev_handler);
 729 }
 730
 731 static void __exit evdev_exit(void)
 732 {
 733         input_unregister_handler(&evdev_handler);
 734 }
 735
 736 module_init(evdev_init);
 737 module_exit(evdev_exit);
 738
 739 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 740 MODULE_DESCRIPTION("Input driver event char devices");
 741 MODULE_LICENSE("GPL");