drivers/input/input.c

   1 /*
   2  * The input core
   3  *
   4  * Copyright (c) 1999-2002 Vojtech Pavlik
   5  */
   6
   7 /*
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License version 2 as published by
  10  * the Free Software Foundation.
  11  */
  12
  13 #include <linux/init.h>
  14 #include <linux/input.h>
  15 #include <linux/module.h>
  16 #include <linux/random.h>
  17 #include <linux/major.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/poll.h>
  21 #include <linux/device.h>
  22 #include <linux/mutex.h>
  23 #include <linux/rcupdate.h>
  24
  25 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  26 MODULE_DESCRIPTION("Input core");
  27 MODULE_LICENSE("GPL");
  28
  29 #define INPUT_DEVICES   256
  30
  31 static LIST_HEAD(input_dev_list);
  32 static LIST_HEAD(input_handler_list);
  33
  34 /*
  35  * input_mutex protects access to both input_dev_list and input_handler_list.
  36  * This also causes input_[un]register_device and input_[un]register_handler
  37  * be mutually exclusive which simplifies locking in drivers implementing
  38  * input handlers.
  39  */
  40 static DEFINE_MUTEX(input_mutex);
  41
  42 static struct input_handler *input_table[8];
  43
  44 static inline int is_event_supported(unsigned int code,
  45                                      unsigned long *bm, unsigned int max)
  46 {
  47         return code <= max && test_bit(code, bm);
  48 }
  49
  50 static int input_defuzz_abs_event(int value, int old_val, int fuzz)
  51 {
  52         if (fuzz) {
  53                 if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
  54                         return old_val;
  55
  56                 if (value > old_val - fuzz && value < old_val + fuzz)
  57                         return (old_val * 3 + value) / 4;
  58
  59                 if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
  60                         return (old_val + value) / 2;
  61         }
  62
  63         return value;
  64 }
  65
  66 /*
  67  * Pass event through all open handles. This function is called with
  68  * dev->event_lock held and interrupts disabled. Because of that we
  69  * do not need to use rcu_read_lock() here although we are using RCU
  70  * to access handle list. Note that because of that write-side uses
  71  * synchronize_sched() instead of synchronize_ru().
  72  */
  73 static void input_pass_event(struct input_dev *dev,
  74                              unsigned int type, unsigned int code, int value)
  75 {
  76         struct input_handle *handle = rcu_dereference(dev->grab);
  77
  78         if (handle)
  79                 handle->handler->event(handle, type, code, value);
  80         else
  81                 list_for_each_entry_rcu(handle, &dev->h_list, d_node)
  82                         if (handle->open)
  83                                 handle->handler->event(handle,
  84                                                         type, code, value);
  85 }
  86
  87 /*
  88  * Generate software autorepeat event. Note that we take
  89  * dev->event_lock here to avoid racing with input_event
  90  * which may cause keys get "stuck".
  91  */
  92 static void input_repeat_key(unsigned long data)
  93 {
  94         struct input_dev *dev = (void *) data;
  95         unsigned long flags;
  96
  97         spin_lock_irqsave(&dev->event_lock, flags);
  98
  99         if (test_bit(dev->repeat_key, dev->key) &&
 100             is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
 101
 102                 input_pass_event(dev, EV_KEY, dev->repeat_key, 2);
 103
 104                 if (dev->sync) {
 105                         /*
 106                          * Only send SYN_REPORT if we are not in a middle
 107                          * of driver parsing a new hardware packet.
 108                          * Otherwise assume that the driver will send
 109                          * SYN_REPORT once it's done.
 110                          */
 111                         input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
 112                 }
 113
 114                 if (dev->rep[REP_PERIOD])
 115                         mod_timer(&dev->timer, jiffies +
 116                                         msecs_to_jiffies(dev->rep[REP_PERIOD]));
 117         }
 118
 119         spin_unlock_irqrestore(&dev->event_lock, flags);
 120 }
 121
 122 static void input_start_autorepeat(struct input_dev *dev, int code)
 123 {
 124         if (test_bit(EV_REP, dev->evbit) &&
 125             dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
 126             dev->timer.data) {
 127                 dev->repeat_key = code;
 128                 mod_timer(&dev->timer,
 129                           jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
 130         }
 131 }
 132
 133 #define INPUT_IGNORE_EVENT      0
 134 #define INPUT_PASS_TO_HANDLERS  1
 135 #define INPUT_PASS_TO_DEVICE    2
 136 #define INPUT_PASS_TO_ALL       (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
 137
 138 static void input_handle_event(struct input_dev *dev,
 139                                unsigned int type, unsigned int code, int value)
 140 {
 141         int disposition = INPUT_IGNORE_EVENT;
 142
 143         switch (type) {
 144
 145         case EV_SYN:
 146                 switch (code) {
 147                 case SYN_CONFIG:
 148                         disposition = INPUT_PASS_TO_ALL;
 149                         break;
 150
 151                 case SYN_REPORT:
 152                         if (!dev->sync) {
 153                                 dev->sync = 1;
 154                                 disposition = INPUT_PASS_TO_HANDLERS;
 155                         }
 156                         break;
 157                 }
 158                 break;
 159
 160         case EV_KEY:
 161                 if (is_event_supported(code, dev->keybit, KEY_MAX) &&
 162                     !!test_bit(code, dev->key) != value) {
 163
 164                         if (value != 2) {
 165                                 __change_bit(code, dev->key);
 166                                 if (value)
 167                                         input_start_autorepeat(dev, code);
 168                         }
 169
 170                         disposition = INPUT_PASS_TO_HANDLERS;
 171                 }
 172                 break;
 173
 174         case EV_SW:
 175                 if (is_event_supported(code, dev->swbit, SW_MAX) &&
 176                     !!test_bit(code, dev->sw) != value) {
 177
 178                         __change_bit(code, dev->sw);
 179                         disposition = INPUT_PASS_TO_HANDLERS;
 180                 }
 181                 break;
 182
 183         case EV_ABS:
 184                 if (is_event_supported(code, dev->absbit, ABS_MAX)) {
 185
 186                         value = input_defuzz_abs_event(value,
 187                                         dev->abs[code], dev->absfuzz[code]);
 188
 189                         if (dev->abs[code] != value) {
 190                                 dev->abs[code] = value;
 191                                 disposition = INPUT_PASS_TO_HANDLERS;
 192                         }
 193                 }
 194                 break;
 195
 196         case EV_REL:
 197                 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
 198                         disposition = INPUT_PASS_TO_HANDLERS;
 199
 200                 break;
 201
 202         case EV_MSC:
 203                 if (is_event_supported(code, dev->mscbit, MSC_MAX))
 204                         disposition = INPUT_PASS_TO_ALL;
 205
 206                 break;
 207
 208         case EV_LED:
 209                 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
 210                     !!test_bit(code, dev->led) != value) {
 211
 212                         __change_bit(code, dev->led);
 213                         disposition = INPUT_PASS_TO_ALL;
 214                 }
 215                 break;
 216
 217         case EV_SND:
 218                 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
 219
 220                         if (!!test_bit(code, dev->snd) != !!value)
 221                                 __change_bit(code, dev->snd);
 222                         disposition = INPUT_PASS_TO_ALL;
 223                 }
 224                 break;
 225
 226         case EV_REP:
 227                 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
 228                         dev->rep[code] = value;
 229                         disposition = INPUT_PASS_TO_ALL;
 230                 }
 231                 break;
 232
 233         case EV_FF:
 234                 if (value >= 0)
 235                         disposition = INPUT_PASS_TO_ALL;
 236                 break;
 237         }
 238
 239         if (type != EV_SYN)
 240                 dev->sync = 0;
 241
 242         if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
 243                 dev->event(dev, type, code, value);
 244
 245         if (disposition & INPUT_PASS_TO_HANDLERS)
 246                 input_pass_event(dev, type, code, value);
 247 }
 248
 249 /**
 250  * input_event() - report new input event
 251  * @dev: device that generated the event
 252  * @type: type of the event
 253  * @code: event code
 254  * @value: value of the event
 255  *
 256  * This function should be used by drivers implementing various input
 257  * devices. See also input_inject_event().
 258  */
 259
 260 void input_event(struct input_dev *dev,
 261                  unsigned int type, unsigned int code, int value)
 262 {
 263         unsigned long flags;
 264
 265         if (is_event_supported(type, dev->evbit, EV_MAX)) {
 266
 267                 spin_lock_irqsave(&dev->event_lock, flags);
 268                 add_input_randomness(type, code, value);
 269                 input_handle_event(dev, type, code, value);
 270                 spin_unlock_irqrestore(&dev->event_lock, flags);
 271         }
 272 }
 273 EXPORT_SYMBOL(input_event);
 274
 275 /**
 276  * input_inject_event() - send input event from input handler
 277  * @handle: input handle to send event through
 278  * @type: type of the event
 279  * @code: event code
 280  * @value: value of the event
 281  *
 282  * Similar to input_event() but will ignore event if device is
 283  * "grabbed" and handle injecting event is not the one that owns
 284  * the device.
 285  */
 286 void input_inject_event(struct input_handle *handle,
 287                         unsigned int type, unsigned int code, int value)
 288 {
 289         struct input_dev *dev = handle->dev;
 290         struct input_handle *grab;
 291         unsigned long flags;
 292
 293         if (is_event_supported(type, dev->evbit, EV_MAX)) {
 294                 spin_lock_irqsave(&dev->event_lock, flags);
 295
 296                 grab = rcu_dereference(dev->grab);
 297                 if (!grab || grab == handle)
 298                         input_handle_event(dev, type, code, value);
 299
 300                 spin_unlock_irqrestore(&dev->event_lock, flags);
 301         }
 302 }
 303 EXPORT_SYMBOL(input_inject_event);
 304
 305 /**
 306  * input_grab_device - grabs device for exclusive use
 307  * @handle: input handle that wants to own the device
 308  *
 309  * When a device is grabbed by an input handle all events generated by
 310  * the device are delivered only to this handle. Also events injected
 311  * by other input handles are ignored while device is grabbed.
 312  */
 313 int input_grab_device(struct input_handle *handle)
 314 {
 315         struct input_dev *dev = handle->dev;
 316         int retval;
 317
 318         retval = mutex_lock_interruptible(&dev->mutex);
 319         if (retval)
 320                 return retval;
 321
 322         if (dev->grab) {
 323                 retval = -EBUSY;
 324                 goto out;
 325         }
 326
 327         rcu_assign_pointer(dev->grab, handle);
 328         /*
 329          * Not using synchronize_rcu() because read-side is protected
 330          * by a spinlock with interrupts off instead of rcu_read_lock().
 331          */
 332         synchronize_sched();
 333
 334  out:
 335         mutex_unlock(&dev->mutex);
 336         return retval;
 337 }
 338 EXPORT_SYMBOL(input_grab_device);
 339
 340 static void __input_release_device(struct input_handle *handle)
 341 {
 342         struct input_dev *dev = handle->dev;
 343
 344         if (dev->grab == handle) {
 345                 rcu_assign_pointer(dev->grab, NULL);
 346                 /* Make sure input_pass_event() notices that grab is gone */
 347                 synchronize_sched();
 348
 349                 list_for_each_entry(handle, &dev->h_list, d_node)
 350                         if (handle->open && handle->handler->start)
 351                                 handle->handler->start(handle);
 352         }
 353 }
 354
 355 /**
 356  * input_release_device - release previously grabbed device
 357  * @handle: input handle that owns the device
 358  *
 359  * Releases previously grabbed device so that other input handles can
 360  * start receiving input events. Upon release all handlers attached
 361  * to the device have their start() method called so they have a change
 362  * to synchronize device state with the rest of the system.
 363  */
 364 void input_release_device(struct input_handle *handle)
 365 {
 366         struct input_dev *dev = handle->dev;
 367
 368         mutex_lock(&dev->mutex);
 369         __input_release_device(handle);
 370         mutex_unlock(&dev->mutex);
 371 }
 372 EXPORT_SYMBOL(input_release_device);
 373
 374 /**
 375  * input_open_device - open input device
 376  * @handle: handle through which device is being accessed
 377  *
 378  * This function should be called by input handlers when they
 379  * want to start receive events from given input device.
 380  */
 381 int input_open_device(struct input_handle *handle)
 382 {
 383         struct input_dev *dev = handle->dev;
 384         int retval;
 385
 386         retval = mutex_lock_interruptible(&dev->mutex);
 387         if (retval)
 388                 return retval;
 389
 390         if (dev->going_away) {
 391                 retval = -ENODEV;
 392                 goto out;
 393         }
 394
 395         handle->open++;
 396
 397         if (!dev->users++ && dev->open)
 398                 retval = dev->open(dev);
 399
 400         if (retval) {
 401                 dev->users--;
 402                 if (!--handle->open) {
 403                         /*
 404                          * Make sure we are not delivering any more events
 405                          * through this handle
 406                          */
 407                         synchronize_sched();
 408                 }
 409         }
 410
 411  out:
 412         mutex_unlock(&dev->mutex);
 413         return retval;
 414 }
 415 EXPORT_SYMBOL(input_open_device);
 416
 417 int input_flush_device(struct input_handle *handle, struct file *file)
 418 {
 419         struct input_dev *dev = handle->dev;
 420         int retval;
 421
 422         retval = mutex_lock_interruptible(&dev->mutex);
 423         if (retval)
 424                 return retval;
 425
 426         if (dev->flush)
 427                 retval = dev->flush(dev, file);
 428
 429         mutex_unlock(&dev->mutex);
 430         return retval;
 431 }
 432 EXPORT_SYMBOL(input_flush_device);
 433
 434 /**
 435  * input_close_device - close input device
 436  * @handle: handle through which device is being accessed
 437  *
 438  * This function should be called by input handlers when they
 439  * want to stop receive events from given input device.
 440  */
 441 void input_close_device(struct input_handle *handle)
 442 {
 443         struct input_dev *dev = handle->dev;
 444
 445         mutex_lock(&dev->mutex);
 446
 447         __input_release_device(handle);
 448
 449         if (!--dev->users && dev->close)
 450                 dev->close(dev);
 451
 452         if (!--handle->open) {
 453                 /*
 454                  * synchronize_sched() makes sure that input_pass_event()
 455                  * completed and that no more input events are delivered
 456                  * through this handle
 457                  */
 458                 synchronize_sched();
 459         }
 460
 461         mutex_unlock(&dev->mutex);
 462 }
 463 EXPORT_SYMBOL(input_close_device);
 464
 465 /*
 466  * Prepare device for unregistering
 467  */
 468 static void input_disconnect_device(struct input_dev *dev)
 469 {
 470         struct input_handle *handle;
 471         int code;
 472
 473         /*
 474          * Mark device as going away. Note that we take dev->mutex here
 475          * not to protect access to dev->going_away but rather to ensure
 476          * that there are no threads in the middle of input_open_device()
 477          */
 478         mutex_lock(&dev->mutex);
 479         dev->going_away = 1;
 480         mutex_unlock(&dev->mutex);
 481
 482         spin_lock_irq(&dev->event_lock);
 483
 484         /*
 485          * Simulate keyup events for all pressed keys so that handlers
 486          * are not left with "stuck" keys. The driver may continue
 487          * generate events even after we done here but they will not
 488          * reach any handlers.
 489          */
 490         if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
 491                 for (code = 0; code <= KEY_MAX; code++) {
 492                         if (is_event_supported(code, dev->keybit, KEY_MAX) &&
 493                             test_bit(code, dev->key)) {
 494                                 input_pass_event(dev, EV_KEY, code, 0);
 495                         }
 496                 }
 497                 input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
 498         }
 499
 500         list_for_each_entry(handle, &dev->h_list, d_node)
 501                 handle->open = 0;
 502
 503         spin_unlock_irq(&dev->event_lock);
 504 }
 505
 506 static int input_fetch_keycode(struct input_dev *dev, int scancode)
 507 {
 508         switch (dev->keycodesize) {
 509                 case 1:
 510                         return ((u8 *)dev->keycode)[scancode];
 511
 512                 case 2:
 513                         return ((u16 *)dev->keycode)[scancode];
 514
 515                 default:
 516                         return ((u32 *)dev->keycode)[scancode];
 517         }
 518 }
 519
 520 static int input_default_getkeycode(struct input_dev *dev,
 521                                     int scancode, int *keycode)
 522 {
 523         if (!dev->keycodesize)
 524                 return -EINVAL;
 525
 526         if (scancode < 0 || scancode >= dev->keycodemax)
 527                 return -EINVAL;
 528
 529         *keycode = input_fetch_keycode(dev, scancode);
 530
 531         return 0;
 532 }
 533
 534 static int input_default_setkeycode(struct input_dev *dev,
 535                                     int scancode, int keycode)
 536 {
 537         int old_keycode;
 538         int i;
 539
 540         if (scancode < 0 || scancode >= dev->keycodemax)
 541                 return -EINVAL;
 542
 543         if (keycode < 0 || keycode > KEY_MAX)
 544                 return -EINVAL;
 545
 546         if (!dev->keycodesize)
 547                 return -EINVAL;
 548
 549         if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
 550                 return -EINVAL;
 551
 552         switch (dev->keycodesize) {
 553                 case 1: {
 554                         u8 *k = (u8 *)dev->keycode;
 555                         old_keycode = k[scancode];
 556                         k[scancode] = keycode;
 557                         break;
 558                 }
 559                 case 2: {
 560                         u16 *k = (u16 *)dev->keycode;
 561                         old_keycode = k[scancode];
 562                         k[scancode] = keycode;
 563                         break;
 564                 }
 565                 default: {
 566                         u32 *k = (u32 *)dev->keycode;
 567                         old_keycode = k[scancode];
 568                         k[scancode] = keycode;
 569                         break;
 570                 }
 571         }
 572
 573         clear_bit(old_keycode, dev->keybit);
 574         set_bit(keycode, dev->keybit);
 575
 576         for (i = 0; i < dev->keycodemax; i++) {
 577                 if (input_fetch_keycode(dev, i) == old_keycode) {
 578                         set_bit(old_keycode, dev->keybit);
 579                         break; /* Setting the bit twice is useless, so break */
 580                 }
 581         }
 582
 583         return 0;
 584 }
 585
 586
 587 #define MATCH_BIT(bit, max) \
 588                 for (i = 0; i < NBITS(max); i++) \
 589                         if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
 590                                 break; \
 591                 if (i != NBITS(max)) \
 592                         continue;
 593
 594 static const struct input_device_id *input_match_device(const struct input_device_id *id,
 595                                                         struct input_dev *dev)
 596 {
 597         int i;
 598
 599         for (; id->flags || id->driver_info; id++) {
 600
 601                 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
 602                         if (id->bustype != dev->id.bustype)
 603                                 continue;
 604
 605                 if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
 606                         if (id->vendor != dev->id.vendor)
 607                                 continue;
 608
 609                 if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
 610                         if (id->product != dev->id.product)
 611                                 continue;
 612
 613                 if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
 614                         if (id->version != dev->id.version)
 615                                 continue;
 616
 617                 MATCH_BIT(evbit,  EV_MAX);
 618                 MATCH_BIT(keybit, KEY_MAX);
 619                 MATCH_BIT(relbit, REL_MAX);
 620                 MATCH_BIT(absbit, ABS_MAX);
 621                 MATCH_BIT(mscbit, MSC_MAX);
 622                 MATCH_BIT(ledbit, LED_MAX);
 623                 MATCH_BIT(sndbit, SND_MAX);
 624                 MATCH_BIT(ffbit,  FF_MAX);
 625                 MATCH_BIT(swbit,  SW_MAX);
 626
 627                 return id;
 628         }
 629
 630         return NULL;
 631 }
 632
 633 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
 634 {
 635         const struct input_device_id *id;
 636         int error;
 637
 638         if (handler->blacklist && input_match_device(handler->blacklist, dev))
 639                 return -ENODEV;
 640
 641         id = input_match_device(handler->id_table, dev);
 642         if (!id)
 643                 return -ENODEV;
 644
 645         error = handler->connect(handler, dev, id);
 646         if (error && error != -ENODEV)
 647                 printk(KERN_ERR
 648                         "input: failed to attach handler %s to device %s, "
 649                         "error: %d\n",
 650                         handler->name, kobject_name(&dev->dev.kobj), error);
 651
 652         return error;
 653 }
 654
 655
 656 #ifdef CONFIG_PROC_FS
 657
 658 static struct proc_dir_entry *proc_bus_input_dir;
 659 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
 660 static int input_devices_state;
 661
 662 static inline void input_wakeup_procfs_readers(void)
 663 {
 664         input_devices_state++;
 665         wake_up(&input_devices_poll_wait);
 666 }
 667
 668 static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
 669 {
 670         int state = input_devices_state;
 671
 672         poll_wait(file, &input_devices_poll_wait, wait);
 673         if (state != input_devices_state)
 674                 return POLLIN | POLLRDNORM;
 675
 676         return 0;
 677 }
 678
 679 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
 680 {
 681         if (mutex_lock_interruptible(&input_mutex))
 682                 return NULL;
 683
 684         return seq_list_start(&input_dev_list, *pos);
 685 }
 686
 687 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 688 {
 689         return seq_list_next(v, &input_dev_list, pos);
 690 }
 691
 692 static void input_devices_seq_stop(struct seq_file *seq, void *v)
 693 {
 694         mutex_unlock(&input_mutex);
 695 }
 696
 697 static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
 698                                    unsigned long *bitmap, int max)
 699 {
 700         int i;
 701
 702         for (i = NBITS(max) - 1; i > 0; i--)
 703                 if (bitmap[i])
 704                         break;
 705
 706         seq_printf(seq, "B: %s=", name);
 707         for (; i >= 0; i--)
 708                 seq_printf(seq, "%lx%s", bitmap[i], i > 0 ? " " : "");
 709         seq_putc(seq, '\n');
 710 }
 711
 712 static int input_devices_seq_show(struct seq_file *seq, void *v)
 713 {
 714         struct input_dev *dev = container_of(v, struct input_dev, node);
 715         const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
 716         struct input_handle *handle;
 717
 718         seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
 719                    dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
 720
 721         seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
 722         seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
 723         seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
 724         seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
 725         seq_printf(seq, "H: Handlers=");
 726
 727         list_for_each_entry(handle, &dev->h_list, d_node)
 728                 seq_printf(seq, "%s ", handle->name);
 729         seq_putc(seq, '\n');
 730
 731         input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
 732         if (test_bit(EV_KEY, dev->evbit))
 733                 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
 734         if (test_bit(EV_REL, dev->evbit))
 735                 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
 736         if (test_bit(EV_ABS, dev->evbit))
 737                 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
 738         if (test_bit(EV_MSC, dev->evbit))
 739                 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
 740         if (test_bit(EV_LED, dev->evbit))
 741                 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
 742         if (test_bit(EV_SND, dev->evbit))
 743                 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
 744         if (test_bit(EV_FF, dev->evbit))
 745                 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
 746         if (test_bit(EV_SW, dev->evbit))
 747                 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
 748
 749         seq_putc(seq, '\n');
 750
 751         kfree(path);
 752         return 0;
 753 }
 754
 755 static struct seq_operations input_devices_seq_ops = {
 756         .start  = input_devices_seq_start,
 757         .next   = input_devices_seq_next,
 758         .stop   = input_devices_seq_stop,
 759         .show   = input_devices_seq_show,
 760 };
 761
 762 static int input_proc_devices_open(struct inode *inode, struct file *file)
 763 {
 764         return seq_open(file, &input_devices_seq_ops);
 765 }
 766
 767 static const struct file_operations input_devices_fileops = {
 768         .owner          = THIS_MODULE,
 769         .open           = input_proc_devices_open,
 770         .poll           = input_proc_devices_poll,
 771         .read           = seq_read,
 772         .llseek         = seq_lseek,
 773         .release        = seq_release,
 774 };
 775
 776 static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
 777 {
 778         if (mutex_lock_interruptible(&input_mutex))
 779                 return NULL;
 780
 781         seq->private = (void *)(unsigned long)*pos;
 782         return seq_list_start(&input_handler_list, *pos);
 783 }
 784
 785 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 786 {
 787         seq->private = (void *)(unsigned long)(*pos + 1);
 788         return seq_list_next(v, &input_handler_list, pos);
 789 }
 790
 791 static void input_handlers_seq_stop(struct seq_file *seq, void *v)
 792 {
 793         mutex_unlock(&input_mutex);
 794 }
 795
 796 static int input_handlers_seq_show(struct seq_file *seq, void *v)
 797 {
 798         struct input_handler *handler = container_of(v, struct input_handler, node);
 799
 800         seq_printf(seq, "N: Number=%ld Name=%s",
 801                    (unsigned long)seq->private, handler->name);
 802         if (handler->fops)
 803                 seq_printf(seq, " Minor=%d", handler->minor);
 804         seq_putc(seq, '\n');
 805
 806         return 0;
 807 }
 808 static struct seq_operations input_handlers_seq_ops = {
 809         .start  = input_handlers_seq_start,
 810         .next   = input_handlers_seq_next,
 811         .stop   = input_handlers_seq_stop,
 812         .show   = input_handlers_seq_show,
 813 };
 814
 815 static int input_proc_handlers_open(struct inode *inode, struct file *file)
 816 {
 817         return seq_open(file, &input_handlers_seq_ops);
 818 }
 819
 820 static const struct file_operations input_handlers_fileops = {
 821         .owner          = THIS_MODULE,
 822         .open           = input_proc_handlers_open,
 823         .read           = seq_read,
 824         .llseek         = seq_lseek,
 825         .release        = seq_release,
 826 };
 827
 828 static int __init input_proc_init(void)
 829 {
 830         struct proc_dir_entry *entry;
 831
 832         proc_bus_input_dir = proc_mkdir("input", proc_bus);
 833         if (!proc_bus_input_dir)
 834                 return -ENOMEM;
 835
 836         proc_bus_input_dir->owner = THIS_MODULE;
 837
 838         entry = create_proc_entry("devices", 0, proc_bus_input_dir);
 839         if (!entry)
 840                 goto fail1;
 841
 842         entry->owner = THIS_MODULE;
 843         entry->proc_fops = &input_devices_fileops;
 844
 845         entry = create_proc_entry("handlers", 0, proc_bus_input_dir);
 846         if (!entry)
 847                 goto fail2;
 848
 849         entry->owner = THIS_MODULE;
 850         entry->proc_fops = &input_handlers_fileops;
 851
 852         return 0;
 853
 854  fail2: remove_proc_entry("devices", proc_bus_input_dir);
 855  fail1: remove_proc_entry("input", proc_bus);
 856         return -ENOMEM;
 857 }
 858
 859 static void input_proc_exit(void)
 860 {
 861         remove_proc_entry("devices", proc_bus_input_dir);
 862         remove_proc_entry("handlers", proc_bus_input_dir);
 863         remove_proc_entry("input", proc_bus);
 864 }
 865
 866 #else /* !CONFIG_PROC_FS */
 867 static inline void input_wakeup_procfs_readers(void) { }
 868 static inline int input_proc_init(void) { return 0; }
 869 static inline void input_proc_exit(void) { }
 870 #endif
 871
 872 #define INPUT_DEV_STRING_ATTR_SHOW(name)                                \
 873 static ssize_t input_dev_show_##name(struct device *dev,                \
 874                                      struct device_attribute *attr,     \
 875                                      char *buf)                         \
 876 {                                                                       \
 877         struct input_dev *input_dev = to_input_dev(dev);                \
 878                                                                         \
 879         return scnprintf(buf, PAGE_SIZE, "%s\n",                        \
 880                          input_dev->name ? input_dev->name : "");       \
 881 }                                                                       \
 882 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
 883
 884 INPUT_DEV_STRING_ATTR_SHOW(name);
 885 INPUT_DEV_STRING_ATTR_SHOW(phys);
 886 INPUT_DEV_STRING_ATTR_SHOW(uniq);
 887
 888 static int input_print_modalias_bits(char *buf, int size,
 889                                      char name, unsigned long *bm,
 890                                      unsigned int min_bit, unsigned int max_bit)
 891 {
 892         int len = 0, i;
 893
 894         len += snprintf(buf, max(size, 0), "%c", name);
 895         for (i = min_bit; i < max_bit; i++)
 896                 if (bm[LONG(i)] & BIT(i))
 897                         len += snprintf(buf + len, max(size - len, 0), "%X,", i);
 898         return len;
 899 }
 900
 901 static int input_print_modalias(char *buf, int size, struct input_dev *id,
 902                                 int add_cr)
 903 {
 904         int len;
 905
 906         len = snprintf(buf, max(size, 0),
 907                        "input:b%04Xv%04Xp%04Xe%04X-",
 908                        id->id.bustype, id->id.vendor,
 909                        id->id.product, id->id.version);
 910
 911         len += input_print_modalias_bits(buf + len, size - len,
 912                                 'e', id->evbit, 0, EV_MAX);
 913         len += input_print_modalias_bits(buf + len, size - len,
 914                                 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
 915         len += input_print_modalias_bits(buf + len, size - len,
 916                                 'r', id->relbit, 0, REL_MAX);
 917         len += input_print_modalias_bits(buf + len, size - len,
 918                                 'a', id->absbit, 0, ABS_MAX);
 919         len += input_print_modalias_bits(buf + len, size - len,
 920                                 'm', id->mscbit, 0, MSC_MAX);
 921         len += input_print_modalias_bits(buf + len, size - len,
 922                                 'l', id->ledbit, 0, LED_MAX);
 923         len += input_print_modalias_bits(buf + len, size - len,
 924                                 's', id->sndbit, 0, SND_MAX);
 925         len += input_print_modalias_bits(buf + len, size - len,
 926                                 'f', id->ffbit, 0, FF_MAX);
 927         len += input_print_modalias_bits(buf + len, size - len,
 928                                 'w', id->swbit, 0, SW_MAX);
 929
 930         if (add_cr)
 931                 len += snprintf(buf + len, max(size - len, 0), "\n");
 932
 933         return len;
 934 }
 935
 936 static ssize_t input_dev_show_modalias(struct device *dev,
 937                                        struct device_attribute *attr,
 938                                        char *buf)
 939 {
 940         struct input_dev *id = to_input_dev(dev);
 941         ssize_t len;
 942
 943         len = input_print_modalias(buf, PAGE_SIZE, id, 1);
 944
 945         return min_t(int, len, PAGE_SIZE);
 946 }
 947 static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
 948
 949 static struct attribute *input_dev_attrs[] = {
 950         &dev_attr_name.attr,
 951         &dev_attr_phys.attr,
 952         &dev_attr_uniq.attr,
 953         &dev_attr_modalias.attr,
 954         NULL
 955 };
 956
 957 static struct attribute_group input_dev_attr_group = {
 958         .attrs  = input_dev_attrs,
 959 };
 960
 961 #define INPUT_DEV_ID_ATTR(name)                                         \
 962 static ssize_t input_dev_show_id_##name(struct device *dev,             \
 963                                         struct device_attribute *attr,  \
 964                                         char *buf)                      \
 965 {                                                                       \
 966         struct input_dev *input_dev = to_input_dev(dev);                \
 967         return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
 968 }                                                                       \
 969 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
 970
 971 INPUT_DEV_ID_ATTR(bustype);
 972 INPUT_DEV_ID_ATTR(vendor);
 973 INPUT_DEV_ID_ATTR(product);
 974 INPUT_DEV_ID_ATTR(version);
 975
 976 static struct attribute *input_dev_id_attrs[] = {
 977         &dev_attr_bustype.attr,
 978         &dev_attr_vendor.attr,
 979         &dev_attr_product.attr,
 980         &dev_attr_version.attr,
 981         NULL
 982 };
 983
 984 static struct attribute_group input_dev_id_attr_group = {
 985         .name   = "id",
 986         .attrs  = input_dev_id_attrs,
 987 };
 988
 989 static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
 990                               int max, int add_cr)
 991 {
 992         int i;
 993         int len = 0;
 994
 995         for (i = NBITS(max) - 1; i > 0; i--)
 996                 if (bitmap[i])
 997                         break;
 998
 999         for (; i >= 0; i--)
1000                 len += snprintf(buf + len, max(buf_size - len, 0),
1001                                 "%lx%s", bitmap[i], i > 0 ? " " : "");
1002
1003         if (add_cr)
1004                 len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1005
1006         return len;
1007 }
1008
1009 #define INPUT_DEV_CAP_ATTR(ev, bm)                                      \
1010 static ssize_t input_dev_show_cap_##bm(struct device *dev,              \
1011                                        struct device_attribute *attr,   \
1012                                        char *buf)                       \
1013 {                                                                       \
1014         struct input_dev *input_dev = to_input_dev(dev);                \
1015         int len = input_print_bitmap(buf, PAGE_SIZE,                    \
1016                                      input_dev->bm##bit, ev##_MAX, 1);  \
1017         return min_t(int, len, PAGE_SIZE);                              \
1018 }                                                                       \
1019 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1020
1021 INPUT_DEV_CAP_ATTR(EV, ev);
1022 INPUT_DEV_CAP_ATTR(KEY, key);
1023 INPUT_DEV_CAP_ATTR(REL, rel);
1024 INPUT_DEV_CAP_ATTR(ABS, abs);
1025 INPUT_DEV_CAP_ATTR(MSC, msc);
1026 INPUT_DEV_CAP_ATTR(LED, led);
1027 INPUT_DEV_CAP_ATTR(SND, snd);
1028 INPUT_DEV_CAP_ATTR(FF, ff);
1029 INPUT_DEV_CAP_ATTR(SW, sw);
1030
1031 static struct attribute *input_dev_caps_attrs[] = {
1032         &dev_attr_ev.attr,
1033         &dev_attr_key.attr,
1034         &dev_attr_rel.attr,
1035         &dev_attr_abs.attr,
1036         &dev_attr_msc.attr,
1037         &dev_attr_led.attr,
1038         &dev_attr_snd.attr,
1039         &dev_attr_ff.attr,
1040         &dev_attr_sw.attr,
1041         NULL
1042 };
1043
1044 static struct attribute_group input_dev_caps_attr_group = {
1045         .name   = "capabilities",
1046         .attrs  = input_dev_caps_attrs,
1047 };
1048
1049 static struct attribute_group *input_dev_attr_groups[] = {
1050         &input_dev_attr_group,
1051         &input_dev_id_attr_group,
1052         &input_dev_caps_attr_group,
1053         NULL
1054 };
1055
1056 static void input_dev_release(struct device *device)
1057 {
1058         struct input_dev *dev = to_input_dev(device);
1059
1060         input_ff_destroy(dev);
1061         kfree(dev);
1062
1063         module_put(THIS_MODULE);
1064 }
1065
1066 /*
1067  * Input uevent interface - loading event handlers based on
1068  * device bitfields.
1069  */
1070 static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1071                                    const char *name, unsigned long *bitmap, int max)
1072 {
1073         int len;
1074
1075         if (add_uevent_var(env, "%s=", name))
1076                 return -ENOMEM;
1077
1078         len = input_print_bitmap(&env->buf[env->buflen - 1],
1079                                  sizeof(env->buf) - env->buflen,
1080                                  bitmap, max, 0);
1081         if (len >= (sizeof(env->buf) - env->buflen))
1082                 return -ENOMEM;
1083
1084         env->buflen += len;
1085         return 0;
1086 }
1087
1088 static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1089                                          struct input_dev *dev)
1090 {
1091         int len;
1092
1093         if (add_uevent_var(env, "MODALIAS="))
1094                 return -ENOMEM;
1095
1096         len = input_print_modalias(&env->buf[env->buflen - 1],
1097                                    sizeof(env->buf) - env->buflen,
1098                                    dev, 0);
1099         if (len >= (sizeof(env->buf) - env->buflen))
1100                 return -ENOMEM;
1101
1102         env->buflen += len;
1103         return 0;
1104 }
1105
1106 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...)                              \
1107         do {                                                            \
1108                 int err = add_uevent_var(env, fmt, val);                \
1109                 if (err)                                                \
1110                         return err;                                     \
1111         } while (0)
1112
1113 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)                         \
1114         do {                                                            \
1115                 int err = input_add_uevent_bm_var(env, name, bm, max);  \
1116                 if (err)                                                \
1117                         return err;                                     \
1118         } while (0)
1119
1120 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)                             \
1121         do {                                                            \
1122                 int err = input_add_uevent_modalias_var(env, dev);      \
1123                 if (err)                                                \
1124                         return err;                                     \
1125         } while (0)
1126
1127 static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1128 {
1129         struct input_dev *dev = to_input_dev(device);
1130
1131         INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1132                                 dev->id.bustype, dev->id.vendor,
1133                                 dev->id.product, dev->id.version);
1134         if (dev->name)
1135                 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1136         if (dev->phys)
1137                 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1138         if (dev->uniq)
1139                 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1140
1141         INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1142         if (test_bit(EV_KEY, dev->evbit))
1143                 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1144         if (test_bit(EV_REL, dev->evbit))
1145                 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1146         if (test_bit(EV_ABS, dev->evbit))
1147                 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1148         if (test_bit(EV_MSC, dev->evbit))
1149                 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1150         if (test_bit(EV_LED, dev->evbit))
1151                 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1152         if (test_bit(EV_SND, dev->evbit))
1153                 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1154         if (test_bit(EV_FF, dev->evbit))
1155                 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1156         if (test_bit(EV_SW, dev->evbit))
1157                 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1158
1159         INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1160
1161         return 0;
1162 }
1163
1164 static struct device_type input_dev_type = {
1165         .groups         = input_dev_attr_groups,
1166         .release        = input_dev_release,
1167         .uevent         = input_dev_uevent,
1168 };
1169
1170 struct class input_class = {
1171         .name           = "input",
1172 };
1173 EXPORT_SYMBOL_GPL(input_class);
1174
1175 /**
1176  * input_allocate_device - allocate memory for new input device
1177  *
1178  * Returns prepared struct input_dev or NULL.
1179  *
1180  * NOTE: Use input_free_device() to free devices that have not been
1181  * registered; input_unregister_device() should be used for already
1182  * registered devices.
1183  */
1184 struct input_dev *input_allocate_device(void)
1185 {
1186         struct input_dev *dev;
1187
1188         dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
1189         if (dev) {
1190                 dev->dev.type = &input_dev_type;
1191                 dev->dev.class = &input_class;
1192                 device_initialize(&dev->dev);
1193                 mutex_init(&dev->mutex);
1194                 spin_lock_init(&dev->event_lock);
1195                 INIT_LIST_HEAD(&dev->h_list);
1196                 INIT_LIST_HEAD(&dev->node);
1197
1198                 __module_get(THIS_MODULE);
1199         }
1200
1201         return dev;
1202 }
1203 EXPORT_SYMBOL(input_allocate_device);
1204
1205 /**
1206  * input_free_device - free memory occupied by input_dev structure
1207  * @dev: input device to free
1208  *
1209  * This function should only be used if input_register_device()
1210  * was not called yet or if it failed. Once device was registered
1211  * use input_unregister_device() and memory will be freed once last
1212  * reference to the device is dropped.
1213  *
1214  * Device should be allocated by input_allocate_device().
1215  *
1216  * NOTE: If there are references to the input device then memory
1217  * will not be freed until last reference is dropped.
1218  */
1219 void input_free_device(struct input_dev *dev)
1220 {
1221         if (dev)
1222                 input_put_device(dev);
1223 }
1224 EXPORT_SYMBOL(input_free_device);
1225
1226 /**
1227  * input_set_capability - mark device as capable of a certain event
1228  * @dev: device that is capable of emitting or accepting event
1229  * @type: type of the event (EV_KEY, EV_REL, etc...)
1230  * @code: event code
1231  *
1232  * In addition to setting up corresponding bit in appropriate capability
1233  * bitmap the function also adjusts dev->evbit.
1234  */
1235 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1236 {
1237         switch (type) {
1238         case EV_KEY:
1239                 __set_bit(code, dev->keybit);
1240                 break;
1241
1242         case EV_REL:
1243                 __set_bit(code, dev->relbit);
1244                 break;
1245
1246         case EV_ABS:
1247                 __set_bit(code, dev->absbit);
1248                 break;
1249
1250         case EV_MSC:
1251                 __set_bit(code, dev->mscbit);
1252                 break;
1253
1254         case EV_SW:
1255                 __set_bit(code, dev->swbit);
1256                 break;
1257
1258         case EV_LED:
1259                 __set_bit(code, dev->ledbit);
1260                 break;
1261
1262         case EV_SND:
1263                 __set_bit(code, dev->sndbit);
1264                 break;
1265
1266         case EV_FF:
1267                 __set_bit(code, dev->ffbit);
1268                 break;
1269
1270         default:
1271                 printk(KERN_ERR
1272                         "input_set_capability: unknown type %u (code %u)\n",
1273                         type, code);
1274                 dump_stack();
1275                 return;
1276         }
1277
1278         __set_bit(type, dev->evbit);
1279 }
1280 EXPORT_SYMBOL(input_set_capability);
1281
1282 /**
1283  * input_register_device - register device with input core
1284  * @dev: device to be registered
1285  *
1286  * This function registers device with input core. The device must be
1287  * allocated with input_allocate_device() and all it's capabilities
1288  * set up before registering.
1289  * If function fails the device must be freed with input_free_device().
1290  * Once device has been successfully registered it can be unregistered
1291  * with input_unregister_device(); input_free_device() should not be
1292  * called in this case.
1293  */
1294 int input_register_device(struct input_dev *dev)
1295 {
1296         static atomic_t input_no = ATOMIC_INIT(0);
1297         struct input_handler *handler;
1298         const char *path;
1299         int error;
1300
1301         __set_bit(EV_SYN, dev->evbit);
1302
1303         /*
1304          * If delay and period are pre-set by the driver, then autorepeating
1305          * is handled by the driver itself and we don't do it in input.c.
1306          */
1307
1308         init_timer(&dev->timer);
1309         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
1310                 dev->timer.data = (long) dev;
1311                 dev->timer.function = input_repeat_key;
1312                 dev->rep[REP_DELAY] = 250;
1313                 dev->rep[REP_PERIOD] = 33;
1314         }
1315
1316         if (!dev->getkeycode)
1317                 dev->getkeycode = input_default_getkeycode;
1318
1319         if (!dev->setkeycode)
1320                 dev->setkeycode = input_default_setkeycode;
1321
1322         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
1323                  "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
1324
1325         if (dev->cdev.dev)
1326                 dev->dev.parent = dev->cdev.dev;
1327
1328         error = device_add(&dev->dev);
1329         if (error)
1330                 return error;
1331
1332         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1333         printk(KERN_INFO "input: %s as %s\n",
1334                 dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
1335         kfree(path);
1336
1337         error = mutex_lock_interruptible(&input_mutex);
1338         if (error) {
1339                 device_del(&dev->dev);
1340                 return error;
1341         }
1342
1343         list_add_tail(&dev->node, &input_dev_list);
1344
1345         list_for_each_entry(handler, &input_handler_list, node)
1346                 input_attach_handler(dev, handler);
1347
1348         input_wakeup_procfs_readers();
1349
1350         mutex_unlock(&input_mutex);
1351
1352         return 0;
1353 }
1354 EXPORT_SYMBOL(input_register_device);
1355
1356 /**
1357  * input_unregister_device - unregister previously registered device
1358  * @dev: device to be unregistered
1359  *
1360  * This function unregisters an input device. Once device is unregistered
1361  * the caller should not try to access it as it may get freed at any moment.
1362  */
1363 void input_unregister_device(struct input_dev *dev)
1364 {
1365         struct input_handle *handle, *next;
1366
1367         input_disconnect_device(dev);
1368
1369         mutex_lock(&input_mutex);
1370
1371         list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
1372                 handle->handler->disconnect(handle);
1373         WARN_ON(!list_empty(&dev->h_list));
1374
1375         del_timer_sync(&dev->timer);
1376         list_del_init(&dev->node);
1377
1378         input_wakeup_procfs_readers();
1379
1380         mutex_unlock(&input_mutex);
1381
1382         device_unregister(&dev->dev);
1383 }
1384 EXPORT_SYMBOL(input_unregister_device);
1385
1386 /**
1387  * input_register_handler - register a new input handler
1388  * @handler: handler to be registered
1389  *
1390  * This function registers a new input handler (interface) for input
1391  * devices in the system and attaches it to all input devices that
1392  * are compatible with the handler.
1393  */
1394 int input_register_handler(struct input_handler *handler)
1395 {
1396         struct input_dev *dev;
1397         int retval;
1398
1399         retval = mutex_lock_interruptible(&input_mutex);
1400         if (retval)
1401                 return retval;
1402
1403         INIT_LIST_HEAD(&handler->h_list);
1404
1405         if (handler->fops != NULL) {
1406                 if (input_table[handler->minor >> 5]) {
1407                         retval = -EBUSY;
1408                         goto out;
1409                 }
1410                 input_table[handler->minor >> 5] = handler;
1411         }
1412
1413         list_add_tail(&handler->node, &input_handler_list);
1414
1415         list_for_each_entry(dev, &input_dev_list, node)
1416                 input_attach_handler(dev, handler);
1417
1418         input_wakeup_procfs_readers();
1419
1420  out:
1421         mutex_unlock(&input_mutex);
1422         return retval;
1423 }
1424 EXPORT_SYMBOL(input_register_handler);
1425
1426 /**
1427  * input_unregister_handler - unregisters an input handler
1428  * @handler: handler to be unregistered
1429  *
1430  * This function disconnects a handler from its input devices and
1431  * removes it from lists of known handlers.
1432  */
1433 void input_unregister_handler(struct input_handler *handler)
1434 {
1435         struct input_handle *handle, *next;
1436
1437         mutex_lock(&input_mutex);
1438
1439         list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
1440                 handler->disconnect(handle);
1441         WARN_ON(!list_empty(&handler->h_list));
1442
1443         list_del_init(&handler->node);
1444
1445         if (handler->fops != NULL)
1446                 input_table[handler->minor >> 5] = NULL;
1447
1448         input_wakeup_procfs_readers();
1449
1450         mutex_unlock(&input_mutex);
1451 }
1452 EXPORT_SYMBOL(input_unregister_handler);
1453
1454 /**
1455  * input_register_handle - register a new input handle
1456  * @handle: handle to register
1457  *
1458  * This function puts a new input handle onto device's
1459  * and handler's lists so that events can flow through
1460  * it once it is opened using input_open_device().
1461  *
1462  * This function is supposed to be called from handler's
1463  * connect() method.
1464  */
1465 int input_register_handle(struct input_handle *handle)
1466 {
1467         struct input_handler *handler = handle->handler;
1468         struct input_dev *dev = handle->dev;
1469         int error;
1470
1471         /*
1472          * We take dev->mutex here to prevent race with
1473          * input_release_device().
1474          */
1475         error = mutex_lock_interruptible(&dev->mutex);
1476         if (error)
1477                 return error;
1478         list_add_tail_rcu(&handle->d_node, &dev->h_list);
1479         mutex_unlock(&dev->mutex);
1480         /*
1481          * We don't use synchronize_rcu() here because we rely
1482          * on dev->event_lock to protect read-side critical
1483          * section in input_pass_event().
1484          */
1485         synchronize_sched();
1486
1487         /*
1488          * Since we are supposed to be called from ->connect()
1489          * which is mutually exclusive with ->disconnect()
1490          * we can't be racing with input_unregister_handle()
1491          * and so separate lock is not needed here.
1492          */
1493         list_add_tail(&handle->h_node, &handler->h_list);
1494
1495         if (handler->start)
1496                 handler->start(handle);
1497
1498         return 0;
1499 }
1500 EXPORT_SYMBOL(input_register_handle);
1501
1502 /**
1503  * input_unregister_handle - unregister an input handle
1504  * @handle: handle to unregister
1505  *
1506  * This function removes input handle from device's
1507  * and handler's lists.
1508  *
1509  * This function is supposed to be called from handler's
1510  * disconnect() method.
1511  */
1512 void input_unregister_handle(struct input_handle *handle)
1513 {
1514         struct input_dev *dev = handle->dev;
1515
1516         list_del_init(&handle->h_node);
1517
1518         /*
1519          * Take dev->mutex to prevent race with input_release_device().
1520          */
1521         mutex_lock(&dev->mutex);
1522         list_del_rcu(&handle->d_node);
1523         mutex_unlock(&dev->mutex);
1524         synchronize_sched();
1525 }
1526 EXPORT_SYMBOL(input_unregister_handle);
1527
1528 static int input_open_file(struct inode *inode, struct file *file)
1529 {
1530         struct input_handler *handler = input_table[iminor(inode) >> 5];
1531         const struct file_operations *old_fops, *new_fops = NULL;
1532         int err;
1533
1534         /* No load-on-demand here? */
1535         if (!handler || !(new_fops = fops_get(handler->fops)))
1536                 return -ENODEV;
1537
1538         /*
1539          * That's _really_ odd. Usually NULL ->open means "nothing special",
1540          * not "no device". Oh, well...
1541          */
1542         if (!new_fops->open) {
1543                 fops_put(new_fops);
1544                 return -ENODEV;
1545         }
1546         old_fops = file->f_op;
1547         file->f_op = new_fops;
1548
1549         err = new_fops->open(inode, file);
1550
1551         if (err) {
1552                 fops_put(file->f_op);
1553                 file->f_op = fops_get(old_fops);
1554         }
1555         fops_put(old_fops);
1556         return err;
1557 }
1558
1559 static const struct file_operations input_fops = {
1560         .owner = THIS_MODULE,
1561         .open = input_open_file,
1562 };
1563
1564 static int __init input_init(void)
1565 {
1566         int err;
1567
1568         err = class_register(&input_class);
1569         if (err) {
1570                 printk(KERN_ERR "input: unable to register input_dev class\n");
1571                 return err;
1572         }
1573
1574         err = input_proc_init();
1575         if (err)
1576                 goto fail1;
1577
1578         err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
1579         if (err) {
1580                 printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
1581                 goto fail2;
1582         }
1583
1584         return 0;
1585
1586  fail2: input_proc_exit();
1587  fail1: class_unregister(&input_class);
1588         return err;
1589 }
1590
1591 static void __exit input_exit(void)
1592 {
1593         input_proc_exit();
1594         unregister_chrdev(INPUT_MAJOR, "input");
1595         class_unregister(&input_class);
1596 }
1597
1598 subsys_initcall(input_init);
1599 module_exit(input_exit);