SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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(char **envp, int num_envp, int *cur_index,
1071                                    char *buffer, int buffer_size, int *cur_len,
1072                                    const char *name, unsigned long *bitmap, int max)
1073 {
1074         if (*cur_index >= num_envp - 1)
1075                 return -ENOMEM;
1076
1077         envp[*cur_index] = buffer + *cur_len;
1078
1079         *cur_len += snprintf(buffer + *cur_len, max(buffer_size - *cur_len, 0), name);
1080         if (*cur_len >= buffer_size)
1081                 return -ENOMEM;
1082
1083         *cur_len += input_print_bitmap(buffer + *cur_len,
1084                                         max(buffer_size - *cur_len, 0),
1085                                         bitmap, max, 0) + 1;
1086         if (*cur_len > buffer_size)
1087                 return -ENOMEM;
1088
1089         (*cur_index)++;
1090         return 0;
1091 }
1092
1093 static int input_add_uevent_modalias_var(char **envp, int num_envp, int *cur_index,
1094                                          char *buffer, int buffer_size, int *cur_len,
1095                                          struct input_dev *dev)
1096 {
1097         if (*cur_index >= num_envp - 1)
1098                 return -ENOMEM;
1099
1100         envp[*cur_index] = buffer + *cur_len;
1101
1102         *cur_len += snprintf(buffer + *cur_len, max(buffer_size - *cur_len, 0),
1103                              "MODALIAS=");
1104         if (*cur_len >= buffer_size)
1105                 return -ENOMEM;
1106
1107         *cur_len += input_print_modalias(buffer + *cur_len,
1108                                          max(buffer_size - *cur_len, 0),
1109                                          dev, 0) + 1;
1110         if (*cur_len > buffer_size)
1111                 return -ENOMEM;
1112
1113         (*cur_index)++;
1114         return 0;
1115 }
1116
1117 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...)                              \
1118         do {                                                            \
1119                 int err = add_uevent_var(envp, num_envp, &i,            \
1120                                         buffer, buffer_size, &len,      \
1121                                         fmt, val);                      \
1122                 if (err)                                                \
1123                         return err;                                     \
1124         } while (0)
1125
1126 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)                         \
1127         do {                                                            \
1128                 int err = input_add_uevent_bm_var(envp, num_envp, &i,   \
1129                                         buffer, buffer_size, &len,      \
1130                                         name, bm, max);                 \
1131                 if (err)                                                \
1132                         return err;                                     \
1133         } while (0)
1134
1135 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)                             \
1136         do {                                                            \
1137                 int err = input_add_uevent_modalias_var(envp,           \
1138                                         num_envp, &i,                   \
1139                                         buffer, buffer_size, &len,      \
1140                                         dev);                           \
1141                 if (err)                                                \
1142                         return err;                                     \
1143         } while (0)
1144
1145 static int input_dev_uevent(struct device *device, char **envp,
1146                             int num_envp, char *buffer, int buffer_size)
1147 {
1148         struct input_dev *dev = to_input_dev(device);
1149         int i = 0;
1150         int len = 0;
1151
1152         INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1153                                 dev->id.bustype, dev->id.vendor,
1154                                 dev->id.product, dev->id.version);
1155         if (dev->name)
1156                 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1157         if (dev->phys)
1158                 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1159         if (dev->uniq)
1160                 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1161
1162         INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1163         if (test_bit(EV_KEY, dev->evbit))
1164                 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1165         if (test_bit(EV_REL, dev->evbit))
1166                 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1167         if (test_bit(EV_ABS, dev->evbit))
1168                 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1169         if (test_bit(EV_MSC, dev->evbit))
1170                 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1171         if (test_bit(EV_LED, dev->evbit))
1172                 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1173         if (test_bit(EV_SND, dev->evbit))
1174                 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1175         if (test_bit(EV_FF, dev->evbit))
1176                 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1177         if (test_bit(EV_SW, dev->evbit))
1178                 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1179
1180         INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1181
1182         envp[i] = NULL;
1183         return 0;
1184 }
1185
1186 static struct device_type input_dev_type = {
1187         .groups         = input_dev_attr_groups,
1188         .release        = input_dev_release,
1189         .uevent         = input_dev_uevent,
1190 };
1191
1192 struct class input_class = {
1193         .name           = "input",
1194 };
1195 EXPORT_SYMBOL_GPL(input_class);
1196
1197 /**
1198  * input_allocate_device - allocate memory for new input device
1199  *
1200  * Returns prepared struct input_dev or NULL.
1201  *
1202  * NOTE: Use input_free_device() to free devices that have not been
1203  * registered; input_unregister_device() should be used for already
1204  * registered devices.
1205  */
1206 struct input_dev *input_allocate_device(void)
1207 {
1208         struct input_dev *dev;
1209
1210         dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
1211         if (dev) {
1212                 dev->dev.type = &input_dev_type;
1213                 dev->dev.class = &input_class;
1214                 device_initialize(&dev->dev);
1215                 mutex_init(&dev->mutex);
1216                 spin_lock_init(&dev->event_lock);
1217                 INIT_LIST_HEAD(&dev->h_list);
1218                 INIT_LIST_HEAD(&dev->node);
1219
1220                 __module_get(THIS_MODULE);
1221         }
1222
1223         return dev;
1224 }
1225 EXPORT_SYMBOL(input_allocate_device);
1226
1227 /**
1228  * input_free_device - free memory occupied by input_dev structure
1229  * @dev: input device to free
1230  *
1231  * This function should only be used if input_register_device()
1232  * was not called yet or if it failed. Once device was registered
1233  * use input_unregister_device() and memory will be freed once last
1234  * reference to the device is dropped.
1235  *
1236  * Device should be allocated by input_allocate_device().
1237  *
1238  * NOTE: If there are references to the input device then memory
1239  * will not be freed until last reference is dropped.
1240  */
1241 void input_free_device(struct input_dev *dev)
1242 {
1243         if (dev)
1244                 input_put_device(dev);
1245 }
1246 EXPORT_SYMBOL(input_free_device);
1247
1248 /**
1249  * input_set_capability - mark device as capable of a certain event
1250  * @dev: device that is capable of emitting or accepting event
1251  * @type: type of the event (EV_KEY, EV_REL, etc...)
1252  * @code: event code
1253  *
1254  * In addition to setting up corresponding bit in appropriate capability
1255  * bitmap the function also adjusts dev->evbit.
1256  */
1257 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1258 {
1259         switch (type) {
1260         case EV_KEY:
1261                 __set_bit(code, dev->keybit);
1262                 break;
1263
1264         case EV_REL:
1265                 __set_bit(code, dev->relbit);
1266                 break;
1267
1268         case EV_ABS:
1269                 __set_bit(code, dev->absbit);
1270                 break;
1271
1272         case EV_MSC:
1273                 __set_bit(code, dev->mscbit);
1274                 break;
1275
1276         case EV_SW:
1277                 __set_bit(code, dev->swbit);
1278                 break;
1279
1280         case EV_LED:
1281                 __set_bit(code, dev->ledbit);
1282                 break;
1283
1284         case EV_SND:
1285                 __set_bit(code, dev->sndbit);
1286                 break;
1287
1288         case EV_FF:
1289                 __set_bit(code, dev->ffbit);
1290                 break;
1291
1292         default:
1293                 printk(KERN_ERR
1294                         "input_set_capability: unknown type %u (code %u)\n",
1295                         type, code);
1296                 dump_stack();
1297                 return;
1298         }
1299
1300         __set_bit(type, dev->evbit);
1301 }
1302 EXPORT_SYMBOL(input_set_capability);
1303
1304 /**
1305  * input_register_device - register device with input core
1306  * @dev: device to be registered
1307  *
1308  * This function registers device with input core. The device must be
1309  * allocated with input_allocate_device() and all it's capabilities
1310  * set up before registering.
1311  * If function fails the device must be freed with input_free_device().
1312  * Once device has been successfully registered it can be unregistered
1313  * with input_unregister_device(); input_free_device() should not be
1314  * called in this case.
1315  */
1316 int input_register_device(struct input_dev *dev)
1317 {
1318         static atomic_t input_no = ATOMIC_INIT(0);
1319         struct input_handler *handler;
1320         const char *path;
1321         int error;
1322
1323         __set_bit(EV_SYN, dev->evbit);
1324
1325         /*
1326          * If delay and period are pre-set by the driver, then autorepeating
1327          * is handled by the driver itself and we don't do it in input.c.
1328          */
1329
1330         init_timer(&dev->timer);
1331         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
1332                 dev->timer.data = (long) dev;
1333                 dev->timer.function = input_repeat_key;
1334                 dev->rep[REP_DELAY] = 250;
1335                 dev->rep[REP_PERIOD] = 33;
1336         }
1337
1338         if (!dev->getkeycode)
1339                 dev->getkeycode = input_default_getkeycode;
1340
1341         if (!dev->setkeycode)
1342                 dev->setkeycode = input_default_setkeycode;
1343
1344         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
1345                  "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
1346
1347         if (dev->cdev.dev)
1348                 dev->dev.parent = dev->cdev.dev;
1349
1350         error = device_add(&dev->dev);
1351         if (error)
1352                 return error;
1353
1354         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1355         printk(KERN_INFO "input: %s as %s\n",
1356                 dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
1357         kfree(path);
1358
1359         error = mutex_lock_interruptible(&input_mutex);
1360         if (error) {
1361                 device_del(&dev->dev);
1362                 return error;
1363         }
1364
1365         list_add_tail(&dev->node, &input_dev_list);
1366
1367         list_for_each_entry(handler, &input_handler_list, node)
1368                 input_attach_handler(dev, handler);
1369
1370         input_wakeup_procfs_readers();
1371
1372         mutex_unlock(&input_mutex);
1373
1374         return 0;
1375 }
1376 EXPORT_SYMBOL(input_register_device);
1377
1378 /**
1379  * input_unregister_device - unregister previously registered device
1380  * @dev: device to be unregistered
1381  *
1382  * This function unregisters an input device. Once device is unregistered
1383  * the caller should not try to access it as it may get freed at any moment.
1384  */
1385 void input_unregister_device(struct input_dev *dev)
1386 {
1387         struct input_handle *handle, *next;
1388
1389         input_disconnect_device(dev);
1390
1391         mutex_lock(&input_mutex);
1392
1393         list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
1394                 handle->handler->disconnect(handle);
1395         WARN_ON(!list_empty(&dev->h_list));
1396
1397         del_timer_sync(&dev->timer);
1398         list_del_init(&dev->node);
1399
1400         input_wakeup_procfs_readers();
1401
1402         mutex_unlock(&input_mutex);
1403
1404         device_unregister(&dev->dev);
1405 }
1406 EXPORT_SYMBOL(input_unregister_device);
1407
1408 /**
1409  * input_register_handler - register a new input handler
1410  * @handler: handler to be registered
1411  *
1412  * This function registers a new input handler (interface) for input
1413  * devices in the system and attaches it to all input devices that
1414  * are compatible with the handler.
1415  */
1416 int input_register_handler(struct input_handler *handler)
1417 {
1418         struct input_dev *dev;
1419         int retval;
1420
1421         retval = mutex_lock_interruptible(&input_mutex);
1422         if (retval)
1423                 return retval;
1424
1425         INIT_LIST_HEAD(&handler->h_list);
1426
1427         if (handler->fops != NULL) {
1428                 if (input_table[handler->minor >> 5]) {
1429                         retval = -EBUSY;
1430                         goto out;
1431                 }
1432                 input_table[handler->minor >> 5] = handler;
1433         }
1434
1435         list_add_tail(&handler->node, &input_handler_list);
1436
1437         list_for_each_entry(dev, &input_dev_list, node)
1438                 input_attach_handler(dev, handler);
1439
1440         input_wakeup_procfs_readers();
1441
1442  out:
1443         mutex_unlock(&input_mutex);
1444         return retval;
1445 }
1446 EXPORT_SYMBOL(input_register_handler);
1447
1448 /**
1449  * input_unregister_handler - unregisters an input handler
1450  * @handler: handler to be unregistered
1451  *
1452  * This function disconnects a handler from its input devices and
1453  * removes it from lists of known handlers.
1454  */
1455 void input_unregister_handler(struct input_handler *handler)
1456 {
1457         struct input_handle *handle, *next;
1458
1459         mutex_lock(&input_mutex);
1460
1461         list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
1462                 handler->disconnect(handle);
1463         WARN_ON(!list_empty(&handler->h_list));
1464
1465         list_del_init(&handler->node);
1466
1467         if (handler->fops != NULL)
1468                 input_table[handler->minor >> 5] = NULL;
1469
1470         input_wakeup_procfs_readers();
1471
1472         mutex_unlock(&input_mutex);
1473 }
1474 EXPORT_SYMBOL(input_unregister_handler);
1475
1476 /**
1477  * input_register_handle - register a new input handle
1478  * @handle: handle to register
1479  *
1480  * This function puts a new input handle onto device's
1481  * and handler's lists so that events can flow through
1482  * it once it is opened using input_open_device().
1483  *
1484  * This function is supposed to be called from handler's
1485  * connect() method.
1486  */
1487 int input_register_handle(struct input_handle *handle)
1488 {
1489         struct input_handler *handler = handle->handler;
1490         struct input_dev *dev = handle->dev;
1491         int error;
1492
1493         /*
1494          * We take dev->mutex here to prevent race with
1495          * input_release_device().
1496          */
1497         error = mutex_lock_interruptible(&dev->mutex);
1498         if (error)
1499                 return error;
1500         list_add_tail_rcu(&handle->d_node, &dev->h_list);
1501         mutex_unlock(&dev->mutex);
1502         /*
1503          * We don't use synchronize_rcu() here because we rely
1504          * on dev->event_lock to protect read-side critical
1505          * section in input_pass_event().
1506          */
1507         synchronize_sched();
1508
1509         /*
1510          * Since we are supposed to be called from ->connect()
1511          * which is mutually exclusive with ->disconnect()
1512          * we can't be racing with input_unregister_handle()
1513          * and so separate lock is not needed here.
1514          */
1515         list_add_tail(&handle->h_node, &handler->h_list);
1516
1517         if (handler->start)
1518                 handler->start(handle);
1519
1520         return 0;
1521 }
1522 EXPORT_SYMBOL(input_register_handle);
1523
1524 /**
1525  * input_unregister_handle - unregister an input handle
1526  * @handle: handle to unregister
1527  *
1528  * This function removes input handle from device's
1529  * and handler's lists.
1530  *
1531  * This function is supposed to be called from handler's
1532  * disconnect() method.
1533  */
1534 void input_unregister_handle(struct input_handle *handle)
1535 {
1536         struct input_dev *dev = handle->dev;
1537
1538         list_del_init(&handle->h_node);
1539
1540         /*
1541          * Take dev->mutex to prevent race with input_release_device().
1542          */
1543         mutex_lock(&dev->mutex);
1544         list_del_rcu(&handle->d_node);
1545         mutex_unlock(&dev->mutex);
1546         synchronize_sched();
1547 }
1548 EXPORT_SYMBOL(input_unregister_handle);
1549
1550 static int input_open_file(struct inode *inode, struct file *file)
1551 {
1552         struct input_handler *handler = input_table[iminor(inode) >> 5];
1553         const struct file_operations *old_fops, *new_fops = NULL;
1554         int err;
1555
1556         /* No load-on-demand here? */
1557         if (!handler || !(new_fops = fops_get(handler->fops)))
1558                 return -ENODEV;
1559
1560         /*
1561          * That's _really_ odd. Usually NULL ->open means "nothing special",
1562          * not "no device". Oh, well...
1563          */
1564         if (!new_fops->open) {
1565                 fops_put(new_fops);
1566                 return -ENODEV;
1567         }
1568         old_fops = file->f_op;
1569         file->f_op = new_fops;
1570
1571         err = new_fops->open(inode, file);
1572
1573         if (err) {
1574                 fops_put(file->f_op);
1575                 file->f_op = fops_get(old_fops);
1576         }
1577         fops_put(old_fops);
1578         return err;
1579 }
1580
1581 static const struct file_operations input_fops = {
1582         .owner = THIS_MODULE,
1583         .open = input_open_file,
1584 };
1585
1586 static int __init input_init(void)
1587 {
1588         int err;
1589
1590         err = class_register(&input_class);
1591         if (err) {
1592                 printk(KERN_ERR "input: unable to register input_dev class\n");
1593                 return err;
1594         }
1595
1596         err = input_proc_init();
1597         if (err)
1598                 goto fail1;
1599
1600         err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
1601         if (err) {
1602                 printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
1603                 goto fail2;
1604         }
1605
1606         return 0;
1607
1608  fail2: input_proc_exit();
1609  fail1: class_unregister(&input_class);
1610         return err;
1611 }
1612
1613 static void __exit input_exit(void)
1614 {
1615         input_proc_exit();
1616         unregister_chrdev(INPUT_MAJOR, "input");
1617         class_unregister(&input_class);
1618 }
1619
1620 subsys_initcall(input_init);
1621 module_exit(input_exit);