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/types.h>
  15 #include <linux/input.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/random.h>
  19 #include <linux/major.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/sched.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/poll.h>
  24 #include <linux/device.h>
  25 #include <linux/mutex.h>
  26 #include <linux/rcupdate.h>
  27 #include "input-compat.h"
  28
  29 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  30 MODULE_DESCRIPTION("Input core");
  31 MODULE_LICENSE("GPL");
  32
  33 #define INPUT_DEVICES   256
  34
  35 static LIST_HEAD(input_dev_list);
  36 static LIST_HEAD(input_handler_list);
  37
  38 /*
  39  * input_mutex protects access to both input_dev_list and input_handler_list.
  40  * This also causes input_[un]register_device and input_[un]register_handler
  41  * be mutually exclusive which simplifies locking in drivers implementing
  42  * input handlers.
  43  */
  44 static DEFINE_MUTEX(input_mutex);
  45
  46 static struct input_handler *input_table[8];
  47
  48 static inline int is_event_supported(unsigned int code,
  49                                      unsigned long *bm, unsigned int max)
  50 {
  51         return code <= max && test_bit(code, bm);
  52 }
  53
  54 static int input_defuzz_abs_event(int value, int old_val, int fuzz)
  55 {
  56         if (fuzz) {
  57                 if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
  58                         return old_val;
  59
  60                 if (value > old_val - fuzz && value < old_val + fuzz)
  61                         return (old_val * 3 + value) / 4;
  62
  63                 if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
  64                         return (old_val + value) / 2;
  65         }
  66
  67         return value;
  68 }
  69
  70 /*
  71  * Pass event first through all filters and then, if event has not been
  72  * filtered out, through all open handles. This function is called with
  73  * dev->event_lock held and interrupts disabled.
  74  */
  75 static void input_pass_event(struct input_dev *dev,
  76                              struct input_handler *src_handler,
  77                              unsigned int type, unsigned int code, int value)
  78 {
  79         struct input_handler *handler;
  80         struct input_handle *handle;
  81
  82         rcu_read_lock();
  83
  84         handle = rcu_dereference(dev->grab);
  85         if (handle)
  86                 handle->handler->event(handle, type, code, value);
  87         else {
  88                 bool filtered = false;
  89
  90                 list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
  91                         if (!handle->open)
  92                                 continue;
  93
  94                         handler = handle->handler;
  95
  96                         /*
  97                          * If this is the handler that injected this
  98                          * particular event we want to skip it to avoid
  99                          * filters firing again and again.
 100                          */
 101                         if (handler == src_handler)
 102                                 continue;
 103
 104                         if (!handler->filter) {
 105                                 if (filtered)
 106                                         break;
 107
 108                                 handler->event(handle, type, code, value);
 109
 110                         } else if (handler->filter(handle, type, code, value))
 111                                 filtered = true;
 112                 }
 113         }
 114
 115         rcu_read_unlock();
 116 }
 117
 118 /*
 119  * Generate software autorepeat event. Note that we take
 120  * dev->event_lock here to avoid racing with input_event
 121  * which may cause keys get "stuck".
 122  */
 123 static void input_repeat_key(unsigned long data)
 124 {
 125         struct input_dev *dev = (void *) data;
 126         unsigned long flags;
 127
 128         spin_lock_irqsave(&dev->event_lock, flags);
 129
 130         if (test_bit(dev->repeat_key, dev->key) &&
 131             is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
 132
 133                 input_pass_event(dev, NULL, EV_KEY, dev->repeat_key, 2);
 134
 135                 if (dev->sync) {
 136                         /*
 137                          * Only send SYN_REPORT if we are not in a middle
 138                          * of driver parsing a new hardware packet.
 139                          * Otherwise assume that the driver will send
 140                          * SYN_REPORT once it's done.
 141                          */
 142                         input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
 143                 }
 144
 145                 if (dev->rep[REP_PERIOD])
 146                         mod_timer(&dev->timer, jiffies +
 147                                         msecs_to_jiffies(dev->rep[REP_PERIOD]));
 148         }
 149
 150         spin_unlock_irqrestore(&dev->event_lock, flags);
 151 }
 152
 153 static void input_start_autorepeat(struct input_dev *dev, int code)
 154 {
 155         if (test_bit(EV_REP, dev->evbit) &&
 156             dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
 157             dev->timer.data) {
 158                 dev->repeat_key = code;
 159                 mod_timer(&dev->timer,
 160                           jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
 161         }
 162 }
 163
 164 static void input_stop_autorepeat(struct input_dev *dev)
 165 {
 166         del_timer(&dev->timer);
 167 }
 168
 169 #define INPUT_IGNORE_EVENT      0
 170 #define INPUT_PASS_TO_HANDLERS  1
 171 #define INPUT_PASS_TO_DEVICE    2
 172 #define INPUT_PASS_TO_ALL       (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
 173
 174 static int input_handle_abs_event(struct input_dev *dev,
 175                                   struct input_handler *src_handler,
 176                                   unsigned int code, int *pval)
 177 {
 178         bool is_mt_event;
 179         int *pold;
 180
 181         if (code == ABS_MT_SLOT) {
 182                 /*
 183                  * "Stage" the event; we'll flush it later, when we
 184                  * get actual touch data.
 185                  */
 186                 if (*pval >= 0 && *pval < dev->mtsize)
 187                         dev->slot = *pval;
 188
 189                 return INPUT_IGNORE_EVENT;
 190         }
 191
 192         is_mt_event = code >= ABS_MT_FIRST && code <= ABS_MT_LAST;
 193
 194         if (!is_mt_event) {
 195                 pold = &dev->absinfo[code].value;
 196         } else if (dev->mt) {
 197                 struct input_mt_slot *mtslot = &dev->mt[dev->slot];
 198                 pold = &mtslot->abs[code - ABS_MT_FIRST];
 199         } else {
 200                 /*
 201                  * Bypass filtering for multi-touch events when
 202                  * not employing slots.
 203                  */
 204                 pold = NULL;
 205         }
 206
 207         if (pold) {
 208                 *pval = input_defuzz_abs_event(*pval, *pold,
 209                                                 dev->absinfo[code].fuzz);
 210                 if (*pold == *pval)
 211                         return INPUT_IGNORE_EVENT;
 212
 213                 *pold = *pval;
 214         }
 215
 216         /* Flush pending "slot" event */
 217         if (is_mt_event && dev->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
 218                 input_abs_set_val(dev, ABS_MT_SLOT, dev->slot);
 219                 input_pass_event(dev, src_handler,
 220                                  EV_ABS, ABS_MT_SLOT, dev->slot);
 221         }
 222
 223         return INPUT_PASS_TO_HANDLERS;
 224 }
 225
 226 static void input_handle_event(struct input_dev *dev,
 227                                struct input_handler *src_handler,
 228                                unsigned int type, unsigned int code, int value)
 229 {
 230         int disposition = INPUT_IGNORE_EVENT;
 231
 232         switch (type) {
 233
 234         case EV_SYN:
 235                 switch (code) {
 236                 case SYN_CONFIG:
 237                         disposition = INPUT_PASS_TO_ALL;
 238                         break;
 239
 240                 case SYN_REPORT:
 241                         if (!dev->sync) {
 242                                 dev->sync = true;
 243                                 disposition = INPUT_PASS_TO_HANDLERS;
 244                         }
 245                         break;
 246                 case SYN_MT_REPORT:
 247                         dev->sync = false;
 248                         disposition = INPUT_PASS_TO_HANDLERS;
 249                         break;
 250                 }
 251                 break;
 252
 253         case EV_KEY:
 254                 if (is_event_supported(code, dev->keybit, KEY_MAX) &&
 255                     !!test_bit(code, dev->key) != value) {
 256
 257                         if (value != 2) {
 258                                 __change_bit(code, dev->key);
 259                                 if (value)
 260                                         input_start_autorepeat(dev, code);
 261                                 else
 262                                         input_stop_autorepeat(dev);
 263                         }
 264
 265                         disposition = INPUT_PASS_TO_HANDLERS;
 266                 }
 267                 break;
 268
 269         case EV_SW:
 270                 if (is_event_supported(code, dev->swbit, SW_MAX) &&
 271                     !!test_bit(code, dev->sw) != value) {
 272
 273                         __change_bit(code, dev->sw);
 274                         disposition = INPUT_PASS_TO_HANDLERS;
 275                 }
 276                 break;
 277
 278         case EV_ABS:
 279                 if (is_event_supported(code, dev->absbit, ABS_MAX))
 280                         disposition = input_handle_abs_event(dev, src_handler,
 281                                                              code, &value);
 282
 283                 break;
 284
 285         case EV_REL:
 286                 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
 287                         disposition = INPUT_PASS_TO_HANDLERS;
 288
 289                 break;
 290
 291         case EV_MSC:
 292                 if (is_event_supported(code, dev->mscbit, MSC_MAX))
 293                         disposition = INPUT_PASS_TO_ALL;
 294
 295                 break;
 296
 297         case EV_LED:
 298                 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
 299                     !!test_bit(code, dev->led) != value) {
 300
 301                         __change_bit(code, dev->led);
 302                         disposition = INPUT_PASS_TO_ALL;
 303                 }
 304                 break;
 305
 306         case EV_SND:
 307                 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
 308
 309                         if (!!test_bit(code, dev->snd) != !!value)
 310                                 __change_bit(code, dev->snd);
 311                         disposition = INPUT_PASS_TO_ALL;
 312                 }
 313                 break;
 314
 315         case EV_REP:
 316                 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
 317                         dev->rep[code] = value;
 318                         disposition = INPUT_PASS_TO_ALL;
 319                 }
 320                 break;
 321
 322         case EV_FF:
 323                 if (value >= 0)
 324                         disposition = INPUT_PASS_TO_ALL;
 325                 break;
 326
 327         case EV_PWR:
 328                 disposition = INPUT_PASS_TO_ALL;
 329                 break;
 330         }
 331
 332         if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
 333                 dev->sync = false;
 334
 335         if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
 336                 dev->event(dev, type, code, value);
 337
 338         if (disposition & INPUT_PASS_TO_HANDLERS)
 339                 input_pass_event(dev, src_handler, type, code, value);
 340 }
 341
 342 /**
 343  * input_event() - report new input event
 344  * @dev: device that generated the event
 345  * @type: type of the event
 346  * @code: event code
 347  * @value: value of the event
 348  *
 349  * This function should be used by drivers implementing various input
 350  * devices to report input events. See also input_inject_event().
 351  *
 352  * NOTE: input_event() may be safely used right after input device was
 353  * allocated with input_allocate_device(), even before it is registered
 354  * with input_register_device(), but the event will not reach any of the
 355  * input handlers. Such early invocation of input_event() may be used
 356  * to 'seed' initial state of a switch or initial position of absolute
 357  * axis, etc.
 358  */
 359 void input_event(struct input_dev *dev,
 360                  unsigned int type, unsigned int code, int value)
 361 {
 362         unsigned long flags;
 363
 364         if (is_event_supported(type, dev->evbit, EV_MAX)) {
 365
 366                 spin_lock_irqsave(&dev->event_lock, flags);
 367                 add_input_randomness(type, code, value);
 368                 input_handle_event(dev, NULL, type, code, value);
 369                 spin_unlock_irqrestore(&dev->event_lock, flags);
 370         }
 371 }
 372 EXPORT_SYMBOL(input_event);
 373
 374 /**
 375  * input_inject_event() - send input event from input handler
 376  * @handle: input handle to send event through
 377  * @type: type of the event
 378  * @code: event code
 379  * @value: value of the event
 380  *
 381  * Similar to input_event() but will ignore event if device is
 382  * "grabbed" and handle injecting event is not the one that owns
 383  * the device.
 384  */
 385 void input_inject_event(struct input_handle *handle,
 386                         unsigned int type, unsigned int code, int value)
 387 {
 388         struct input_dev *dev = handle->dev;
 389         struct input_handle *grab;
 390         unsigned long flags;
 391
 392         if (is_event_supported(type, dev->evbit, EV_MAX)) {
 393                 spin_lock_irqsave(&dev->event_lock, flags);
 394
 395                 rcu_read_lock();
 396                 grab = rcu_dereference(dev->grab);
 397                 if (!grab || grab == handle)
 398                         input_handle_event(dev, handle->handler,
 399                                            type, code, value);
 400                 rcu_read_unlock();
 401
 402                 spin_unlock_irqrestore(&dev->event_lock, flags);
 403         }
 404 }
 405 EXPORT_SYMBOL(input_inject_event);
 406
 407 /**
 408  * input_alloc_absinfo - allocates array of input_absinfo structs
 409  * @dev: the input device emitting absolute events
 410  *
 411  * If the absinfo struct the caller asked for is already allocated, this
 412  * functions will not do anything.
 413  */
 414 void input_alloc_absinfo(struct input_dev *dev)
 415 {
 416         if (!dev->absinfo)
 417                 dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
 418                                         GFP_KERNEL);
 419
 420         WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
 421 }
 422 EXPORT_SYMBOL(input_alloc_absinfo);
 423
 424 void input_set_abs_params(struct input_dev *dev, unsigned int axis,
 425                           int min, int max, int fuzz, int flat)
 426 {
 427         struct input_absinfo *absinfo;
 428
 429         input_alloc_absinfo(dev);
 430         if (!dev->absinfo)
 431                 return;
 432
 433         absinfo = &dev->absinfo[axis];
 434         absinfo->minimum = min;
 435         absinfo->maximum = max;
 436         absinfo->fuzz = fuzz;
 437         absinfo->flat = flat;
 438
 439         dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
 440 }
 441 EXPORT_SYMBOL(input_set_abs_params);
 442
 443
 444 /**
 445  * input_grab_device - grabs device for exclusive use
 446  * @handle: input handle that wants to own the device
 447  *
 448  * When a device is grabbed by an input handle all events generated by
 449  * the device are delivered only to this handle. Also events injected
 450  * by other input handles are ignored while device is grabbed.
 451  */
 452 int input_grab_device(struct input_handle *handle)
 453 {
 454         struct input_dev *dev = handle->dev;
 455         int retval;
 456
 457         retval = mutex_lock_interruptible(&dev->mutex);
 458         if (retval)
 459                 return retval;
 460
 461         if (dev->grab) {
 462                 retval = -EBUSY;
 463                 goto out;
 464         }
 465
 466         rcu_assign_pointer(dev->grab, handle);
 467         synchronize_rcu();
 468
 469  out:
 470         mutex_unlock(&dev->mutex);
 471         return retval;
 472 }
 473 EXPORT_SYMBOL(input_grab_device);
 474
 475 static void __input_release_device(struct input_handle *handle)
 476 {
 477         struct input_dev *dev = handle->dev;
 478
 479         if (dev->grab == handle) {
 480                 rcu_assign_pointer(dev->grab, NULL);
 481                 /* Make sure input_pass_event() notices that grab is gone */
 482                 synchronize_rcu();
 483
 484                 list_for_each_entry(handle, &dev->h_list, d_node)
 485                         if (handle->open && handle->handler->start)
 486                                 handle->handler->start(handle);
 487         }
 488 }
 489
 490 /**
 491  * input_release_device - release previously grabbed device
 492  * @handle: input handle that owns the device
 493  *
 494  * Releases previously grabbed device so that other input handles can
 495  * start receiving input events. Upon release all handlers attached
 496  * to the device have their start() method called so they have a change
 497  * to synchronize device state with the rest of the system.
 498  */
 499 void input_release_device(struct input_handle *handle)
 500 {
 501         struct input_dev *dev = handle->dev;
 502
 503         mutex_lock(&dev->mutex);
 504         __input_release_device(handle);
 505         mutex_unlock(&dev->mutex);
 506 }
 507 EXPORT_SYMBOL(input_release_device);
 508
 509 /**
 510  * input_open_device - open input device
 511  * @handle: handle through which device is being accessed
 512  *
 513  * This function should be called by input handlers when they
 514  * want to start receive events from given input device.
 515  */
 516 int input_open_device(struct input_handle *handle)
 517 {
 518         struct input_dev *dev = handle->dev;
 519         int retval;
 520
 521         retval = mutex_lock_interruptible(&dev->mutex);
 522         if (retval)
 523                 return retval;
 524
 525         if (dev->going_away) {
 526                 retval = -ENODEV;
 527                 goto out;
 528         }
 529
 530         handle->open++;
 531
 532         if (!dev->users++ && dev->open)
 533                 retval = dev->open(dev);
 534
 535         if (retval) {
 536                 dev->users--;
 537                 if (!--handle->open) {
 538                         /*
 539                          * Make sure we are not delivering any more events
 540                          * through this handle
 541                          */
 542                         synchronize_rcu();
 543                 }
 544         }
 545
 546  out:
 547         mutex_unlock(&dev->mutex);
 548         return retval;
 549 }
 550 EXPORT_SYMBOL(input_open_device);
 551
 552 int input_flush_device(struct input_handle *handle, struct file *file)
 553 {
 554         struct input_dev *dev = handle->dev;
 555         int retval;
 556
 557         retval = mutex_lock_interruptible(&dev->mutex);
 558         if (retval)
 559                 return retval;
 560
 561         if (dev->flush)
 562                 retval = dev->flush(dev, file);
 563
 564         mutex_unlock(&dev->mutex);
 565         return retval;
 566 }
 567 EXPORT_SYMBOL(input_flush_device);
 568
 569 /**
 570  * input_close_device - close input device
 571  * @handle: handle through which device is being accessed
 572  *
 573  * This function should be called by input handlers when they
 574  * want to stop receive events from given input device.
 575  */
 576 void input_close_device(struct input_handle *handle)
 577 {
 578         struct input_dev *dev = handle->dev;
 579
 580         mutex_lock(&dev->mutex);
 581
 582         __input_release_device(handle);
 583
 584         if (!--dev->users && dev->close)
 585                 dev->close(dev);
 586
 587         if (!--handle->open) {
 588                 /*
 589                  * synchronize_rcu() makes sure that input_pass_event()
 590                  * completed and that no more input events are delivered
 591                  * through this handle
 592                  */
 593                 synchronize_rcu();
 594         }
 595
 596         mutex_unlock(&dev->mutex);
 597 }
 598 EXPORT_SYMBOL(input_close_device);
 599
 600 /*
 601  * Simulate keyup events for all keys that are marked as pressed.
 602  * The function must be called with dev->event_lock held.
 603  */
 604 static void input_dev_release_keys(struct input_dev *dev)
 605 {
 606         int code;
 607
 608         if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
 609                 for (code = 0; code <= KEY_MAX; code++) {
 610                         if (is_event_supported(code, dev->keybit, KEY_MAX) &&
 611                             __test_and_clear_bit(code, dev->key)) {
 612                                 input_pass_event(dev, NULL, EV_KEY, code, 0);
 613                         }
 614                 }
 615                 input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
 616         }
 617 }
 618
 619 /*
 620  * Prepare device for unregistering
 621  */
 622 static void input_disconnect_device(struct input_dev *dev)
 623 {
 624         struct input_handle *handle;
 625
 626         /*
 627          * Mark device as going away. Note that we take dev->mutex here
 628          * not to protect access to dev->going_away but rather to ensure
 629          * that there are no threads in the middle of input_open_device()
 630          */
 631         mutex_lock(&dev->mutex);
 632         dev->going_away = true;
 633         mutex_unlock(&dev->mutex);
 634
 635         spin_lock_irq(&dev->event_lock);
 636
 637         /*
 638          * Simulate keyup events for all pressed keys so that handlers
 639          * are not left with "stuck" keys. The driver may continue
 640          * generate events even after we done here but they will not
 641          * reach any handlers.
 642          */
 643         input_dev_release_keys(dev);
 644
 645         list_for_each_entry(handle, &dev->h_list, d_node)
 646                 handle->open = 0;
 647
 648         spin_unlock_irq(&dev->event_lock);
 649 }
 650
 651 /**
 652  * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
 653  * @ke: keymap entry containing scancode to be converted.
 654  * @scancode: pointer to the location where converted scancode should
 655  *      be stored.
 656  *
 657  * This function is used to convert scancode stored in &struct keymap_entry
 658  * into scalar form understood by legacy keymap handling methods. These
 659  * methods expect scancodes to be represented as 'unsigned int'.
 660  */
 661 int input_scancode_to_scalar(const struct input_keymap_entry *ke,
 662                              unsigned int *scancode)
 663 {
 664         switch (ke->len) {
 665         case 1:
 666                 *scancode = *((u8 *)ke->scancode);
 667                 break;
 668
 669         case 2:
 670                 *scancode = *((u16 *)ke->scancode);
 671                 break;
 672
 673         case 4:
 674                 *scancode = *((u32 *)ke->scancode);
 675                 break;
 676
 677         default:
 678                 return -EINVAL;
 679         }
 680
 681         return 0;
 682 }
 683 EXPORT_SYMBOL(input_scancode_to_scalar);
 684
 685 /*
 686  * Those routines handle the default case where no [gs]etkeycode() is
 687  * defined. In this case, an array indexed by the scancode is used.
 688  */
 689
 690 static unsigned int input_fetch_keycode(struct input_dev *dev,
 691                                         unsigned int index)
 692 {
 693         switch (dev->keycodesize) {
 694         case 1:
 695                 return ((u8 *)dev->keycode)[index];
 696
 697         case 2:
 698                 return ((u16 *)dev->keycode)[index];
 699
 700         default:
 701                 return ((u32 *)dev->keycode)[index];
 702         }
 703 }
 704
 705 static int input_default_getkeycode(struct input_dev *dev,
 706                                     struct input_keymap_entry *ke)
 707 {
 708         unsigned int index;
 709         int error;
 710
 711         if (!dev->keycodesize)
 712                 return -EINVAL;
 713
 714         if (ke->flags & INPUT_KEYMAP_BY_INDEX)
 715                 index = ke->index;
 716         else {
 717                 error = input_scancode_to_scalar(ke, &index);
 718                 if (error)
 719                         return error;
 720         }
 721
 722         if (index >= dev->keycodemax)
 723                 return -EINVAL;
 724
 725         ke->keycode = input_fetch_keycode(dev, index);
 726         ke->index = index;
 727         ke->len = sizeof(index);
 728         memcpy(ke->scancode, &index, sizeof(index));
 729
 730         return 0;
 731 }
 732
 733 static int input_default_setkeycode(struct input_dev *dev,
 734                                     const struct input_keymap_entry *ke,
 735                                     unsigned int *old_keycode)
 736 {
 737         unsigned int index;
 738         int error;
 739         int i;
 740
 741         if (!dev->keycodesize)
 742                 return -EINVAL;
 743
 744         if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
 745                 index = ke->index;
 746         } else {
 747                 error = input_scancode_to_scalar(ke, &index);
 748                 if (error)
 749                         return error;
 750         }
 751
 752         if (index >= dev->keycodemax)
 753                 return -EINVAL;
 754
 755         if (dev->keycodesize < sizeof(dev->keycode) &&
 756                         (ke->keycode >> (dev->keycodesize * 8)))
 757                 return -EINVAL;
 758
 759         switch (dev->keycodesize) {
 760                 case 1: {
 761                         u8 *k = (u8 *)dev->keycode;
 762                         *old_keycode = k[index];
 763                         k[index] = ke->keycode;
 764                         break;
 765                 }
 766                 case 2: {
 767                         u16 *k = (u16 *)dev->keycode;
 768                         *old_keycode = k[index];
 769                         k[index] = ke->keycode;
 770                         break;
 771                 }
 772                 default: {
 773                         u32 *k = (u32 *)dev->keycode;
 774                         *old_keycode = k[index];
 775                         k[index] = ke->keycode;
 776                         break;
 777                 }
 778         }
 779
 780         __clear_bit(*old_keycode, dev->keybit);
 781         __set_bit(ke->keycode, dev->keybit);
 782
 783         for (i = 0; i < dev->keycodemax; i++) {
 784                 if (input_fetch_keycode(dev, i) == *old_keycode) {
 785                         __set_bit(*old_keycode, dev->keybit);
 786                         break; /* Setting the bit twice is useless, so break */
 787                 }
 788         }
 789
 790         return 0;
 791 }
 792
 793 /**
 794  * input_get_keycode - retrieve keycode currently mapped to a given scancode
 795  * @dev: input device which keymap is being queried
 796  * @ke: keymap entry
 797  *
 798  * This function should be called by anyone interested in retrieving current
 799  * keymap. Presently evdev handlers use it.
 800  */
 801 int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
 802 {
 803         unsigned long flags;
 804         int retval;
 805
 806         spin_lock_irqsave(&dev->event_lock, flags);
 807
 808         if (dev->getkeycode) {
 809                 /*
 810                  * Support for legacy drivers, that don't implement the new
 811                  * ioctls
 812                  */
 813                 u32 scancode = ke->index;
 814
 815                 memcpy(ke->scancode, &scancode, sizeof(scancode));
 816                 ke->len = sizeof(scancode);
 817                 retval = dev->getkeycode(dev, scancode, &ke->keycode);
 818         } else {
 819                 retval = dev->getkeycode_new(dev, ke);
 820         }
 821
 822         spin_unlock_irqrestore(&dev->event_lock, flags);
 823         return retval;
 824 }
 825 EXPORT_SYMBOL(input_get_keycode);
 826
 827 /**
 828  * input_set_keycode - attribute a keycode to a given scancode
 829  * @dev: input device which keymap is being updated
 830  * @ke: new keymap entry
 831  *
 832  * This function should be called by anyone needing to update current
 833  * keymap. Presently keyboard and evdev handlers use it.
 834  */
 835 int input_set_keycode(struct input_dev *dev,
 836                       const struct input_keymap_entry *ke)
 837 {
 838         unsigned long flags;
 839         unsigned int old_keycode;
 840         int retval;
 841
 842         if (ke->keycode > KEY_MAX)
 843                 return -EINVAL;
 844
 845         spin_lock_irqsave(&dev->event_lock, flags);
 846
 847         if (dev->setkeycode) {
 848                 /*
 849                  * Support for legacy drivers, that don't implement the new
 850                  * ioctls
 851                  */
 852                 unsigned int scancode;
 853
 854                 retval = input_scancode_to_scalar(ke, &scancode);
 855                 if (retval)
 856                         goto out;
 857
 858                 /*
 859                  * We need to know the old scancode, in order to generate a
 860                  * keyup effect, if the set operation happens successfully
 861                  */
 862                 if (!dev->getkeycode) {
 863                         retval = -EINVAL;
 864                         goto out;
 865                 }
 866
 867                 retval = dev->getkeycode(dev, scancode, &old_keycode);
 868                 if (retval)
 869                         goto out;
 870
 871                 retval = dev->setkeycode(dev, scancode, ke->keycode);
 872         } else {
 873                 retval = dev->setkeycode_new(dev, ke, &old_keycode);
 874         }
 875
 876         if (retval)
 877                 goto out;
 878
 879         /* Make sure KEY_RESERVED did not get enabled. */
 880         __clear_bit(KEY_RESERVED, dev->keybit);
 881
 882         /*
 883          * Simulate keyup event if keycode is not present
 884          * in the keymap anymore
 885          */
 886         if (test_bit(EV_KEY, dev->evbit) &&
 887             !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
 888             __test_and_clear_bit(old_keycode, dev->key)) {
 889
 890                 input_pass_event(dev, NULL, EV_KEY, old_keycode, 0);
 891                 if (dev->sync)
 892                         input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
 893         }
 894
 895  out:
 896         spin_unlock_irqrestore(&dev->event_lock, flags);
 897
 898         return retval;
 899 }
 900 EXPORT_SYMBOL(input_set_keycode);
 901
 902 #define MATCH_BIT(bit, max) \
 903                 for (i = 0; i < BITS_TO_LONGS(max); i++) \
 904                         if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
 905                                 break; \
 906                 if (i != BITS_TO_LONGS(max)) \
 907                         continue;
 908
 909 static const struct input_device_id *input_match_device(struct input_handler *handler,
 910                                                         struct input_dev *dev)
 911 {
 912         const struct input_device_id *id;
 913         int i;
 914
 915         for (id = handler->id_table; id->flags || id->driver_info; id++) {
 916
 917                 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
 918                         if (id->bustype != dev->id.bustype)
 919                                 continue;
 920
 921                 if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
 922                         if (id->vendor != dev->id.vendor)
 923                                 continue;
 924
 925                 if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
 926                         if (id->product != dev->id.product)
 927                                 continue;
 928
 929                 if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
 930                         if (id->version != dev->id.version)
 931                                 continue;
 932
 933                 MATCH_BIT(evbit,  EV_MAX);
 934                 MATCH_BIT(keybit, KEY_MAX);
 935                 MATCH_BIT(relbit, REL_MAX);
 936                 MATCH_BIT(absbit, ABS_MAX);
 937                 MATCH_BIT(mscbit, MSC_MAX);
 938                 MATCH_BIT(ledbit, LED_MAX);
 939                 MATCH_BIT(sndbit, SND_MAX);
 940                 MATCH_BIT(ffbit,  FF_MAX);
 941                 MATCH_BIT(swbit,  SW_MAX);
 942
 943                 if (!handler->match || handler->match(handler, dev))
 944                         return id;
 945         }
 946
 947         return NULL;
 948 }
 949
 950 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
 951 {
 952         const struct input_device_id *id;
 953         int error;
 954
 955         id = input_match_device(handler, dev);
 956         if (!id)
 957                 return -ENODEV;
 958
 959         error = handler->connect(handler, dev, id);
 960         if (error && error != -ENODEV)
 961                 printk(KERN_ERR
 962                         "input: failed to attach handler %s to device %s, "
 963                         "error: %d\n",
 964                         handler->name, kobject_name(&dev->dev.kobj), error);
 965
 966         return error;
 967 }
 968
 969 #ifdef CONFIG_COMPAT
 970
 971 static int input_bits_to_string(char *buf, int buf_size,
 972                                 unsigned long bits, bool skip_empty)
 973 {
 974         int len = 0;
 975
 976         if (INPUT_COMPAT_TEST) {
 977                 u32 dword = bits >> 32;
 978                 if (dword || !skip_empty)
 979                         len += snprintf(buf, buf_size, "%x ", dword);
 980
 981                 dword = bits & 0xffffffffUL;
 982                 if (dword || !skip_empty || len)
 983                         len += snprintf(buf + len, max(buf_size - len, 0),
 984                                         "%x", dword);
 985         } else {
 986                 if (bits || !skip_empty)
 987                         len += snprintf(buf, buf_size, "%lx", bits);
 988         }
 989
 990         return len;
 991 }
 992
 993 #else /* !CONFIG_COMPAT */
 994
 995 static int input_bits_to_string(char *buf, int buf_size,
 996                                 unsigned long bits, bool skip_empty)
 997 {
 998         return bits || !skip_empty ?
 999                 snprintf(buf, buf_size, "%lx", bits) : 0;
1000 }
1001
1002 #endif
1003
1004 #ifdef CONFIG_PROC_FS
1005
1006 static struct proc_dir_entry *proc_bus_input_dir;
1007 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
1008 static int input_devices_state;
1009
1010 static inline void input_wakeup_procfs_readers(void)
1011 {
1012         input_devices_state++;
1013         wake_up(&input_devices_poll_wait);
1014 }
1015
1016 static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
1017 {
1018         poll_wait(file, &input_devices_poll_wait, wait);
1019         if (file->f_version != input_devices_state) {
1020                 file->f_version = input_devices_state;
1021                 return POLLIN | POLLRDNORM;
1022         }
1023
1024         return 0;
1025 }
1026
1027 union input_seq_state {
1028         struct {
1029                 unsigned short pos;
1030                 bool mutex_acquired;
1031         };
1032         void *p;
1033 };
1034
1035 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
1036 {
1037         union input_seq_state *state = (union input_seq_state *)&seq->private;
1038         int error;
1039
1040         /* We need to fit into seq->private pointer */
1041         BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1042
1043         error = mutex_lock_interruptible(&input_mutex);
1044         if (error) {
1045                 state->mutex_acquired = false;
1046                 return ERR_PTR(error);
1047         }
1048
1049         state->mutex_acquired = true;
1050
1051         return seq_list_start(&input_dev_list, *pos);
1052 }
1053
1054 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1055 {
1056         return seq_list_next(v, &input_dev_list, pos);
1057 }
1058
1059 static void input_seq_stop(struct seq_file *seq, void *v)
1060 {
1061         union input_seq_state *state = (union input_seq_state *)&seq->private;
1062
1063         if (state->mutex_acquired)
1064                 mutex_unlock(&input_mutex);
1065 }
1066
1067 static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
1068                                    unsigned long *bitmap, int max)
1069 {
1070         int i;
1071         bool skip_empty = true;
1072         char buf[18];
1073
1074         seq_printf(seq, "B: %s=", name);
1075
1076         for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1077                 if (input_bits_to_string(buf, sizeof(buf),
1078                                          bitmap[i], skip_empty)) {
1079                         skip_empty = false;
1080                         seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
1081                 }
1082         }
1083
1084         /*
1085          * If no output was produced print a single 0.
1086          */
1087         if (skip_empty)
1088                 seq_puts(seq, "0");
1089
1090         seq_putc(seq, '\n');
1091 }
1092
1093 static int input_devices_seq_show(struct seq_file *seq, void *v)
1094 {
1095         struct input_dev *dev = container_of(v, struct input_dev, node);
1096         const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1097         struct input_handle *handle;
1098
1099         seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1100                    dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
1101
1102         seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1103         seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1104         seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
1105         seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1106         seq_printf(seq, "H: Handlers=");
1107
1108         list_for_each_entry(handle, &dev->h_list, d_node)
1109                 seq_printf(seq, "%s ", handle->name);
1110         seq_putc(seq, '\n');
1111
1112         input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1113         if (test_bit(EV_KEY, dev->evbit))
1114                 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1115         if (test_bit(EV_REL, dev->evbit))
1116                 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1117         if (test_bit(EV_ABS, dev->evbit))
1118                 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1119         if (test_bit(EV_MSC, dev->evbit))
1120                 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1121         if (test_bit(EV_LED, dev->evbit))
1122                 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1123         if (test_bit(EV_SND, dev->evbit))
1124                 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1125         if (test_bit(EV_FF, dev->evbit))
1126                 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1127         if (test_bit(EV_SW, dev->evbit))
1128                 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
1129
1130         seq_putc(seq, '\n');
1131
1132         kfree(path);
1133         return 0;
1134 }
1135
1136 static const struct seq_operations input_devices_seq_ops = {
1137         .start  = input_devices_seq_start,
1138         .next   = input_devices_seq_next,
1139         .stop   = input_seq_stop,
1140         .show   = input_devices_seq_show,
1141 };
1142
1143 static int input_proc_devices_open(struct inode *inode, struct file *file)
1144 {
1145         return seq_open(file, &input_devices_seq_ops);
1146 }
1147
1148 static const struct file_operations input_devices_fileops = {
1149         .owner          = THIS_MODULE,
1150         .open           = input_proc_devices_open,
1151         .poll           = input_proc_devices_poll,
1152         .read           = seq_read,
1153         .llseek         = seq_lseek,
1154         .release        = seq_release,
1155 };
1156
1157 static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1158 {
1159         union input_seq_state *state = (union input_seq_state *)&seq->private;
1160         int error;
1161
1162         /* We need to fit into seq->private pointer */
1163         BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1164
1165         error = mutex_lock_interruptible(&input_mutex);
1166         if (error) {
1167                 state->mutex_acquired = false;
1168                 return ERR_PTR(error);
1169         }
1170
1171         state->mutex_acquired = true;
1172         state->pos = *pos;
1173
1174         return seq_list_start(&input_handler_list, *pos);
1175 }
1176
1177 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1178 {
1179         union input_seq_state *state = (union input_seq_state *)&seq->private;
1180
1181         state->pos = *pos + 1;
1182         return seq_list_next(v, &input_handler_list, pos);
1183 }
1184
1185 static int input_handlers_seq_show(struct seq_file *seq, void *v)
1186 {
1187         struct input_handler *handler = container_of(v, struct input_handler, node);
1188         union input_seq_state *state = (union input_seq_state *)&seq->private;
1189
1190         seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
1191         if (handler->filter)
1192                 seq_puts(seq, " (filter)");
1193         if (handler->fops)
1194                 seq_printf(seq, " Minor=%d", handler->minor);
1195         seq_putc(seq, '\n');
1196
1197         return 0;
1198 }
1199
1200 static const struct seq_operations input_handlers_seq_ops = {
1201         .start  = input_handlers_seq_start,
1202         .next   = input_handlers_seq_next,
1203         .stop   = input_seq_stop,
1204         .show   = input_handlers_seq_show,
1205 };
1206
1207 static int input_proc_handlers_open(struct inode *inode, struct file *file)
1208 {
1209         return seq_open(file, &input_handlers_seq_ops);
1210 }
1211
1212 static const struct file_operations input_handlers_fileops = {
1213         .owner          = THIS_MODULE,
1214         .open           = input_proc_handlers_open,
1215         .read           = seq_read,
1216         .llseek         = seq_lseek,
1217         .release        = seq_release,
1218 };
1219
1220 static int __init input_proc_init(void)
1221 {
1222         struct proc_dir_entry *entry;
1223
1224         proc_bus_input_dir = proc_mkdir("bus/input", NULL);
1225         if (!proc_bus_input_dir)
1226                 return -ENOMEM;
1227
1228         entry = proc_create("devices", 0, proc_bus_input_dir,
1229                             &input_devices_fileops);
1230         if (!entry)
1231                 goto fail1;
1232
1233         entry = proc_create("handlers", 0, proc_bus_input_dir,
1234                             &input_handlers_fileops);
1235         if (!entry)
1236                 goto fail2;
1237
1238         return 0;
1239
1240  fail2: remove_proc_entry("devices", proc_bus_input_dir);
1241  fail1: remove_proc_entry("bus/input", NULL);
1242         return -ENOMEM;
1243 }
1244
1245 static void input_proc_exit(void)
1246 {
1247         remove_proc_entry("devices", proc_bus_input_dir);
1248         remove_proc_entry("handlers", proc_bus_input_dir);
1249         remove_proc_entry("bus/input", NULL);
1250 }
1251
1252 #else /* !CONFIG_PROC_FS */
1253 static inline void input_wakeup_procfs_readers(void) { }
1254 static inline int input_proc_init(void) { return 0; }
1255 static inline void input_proc_exit(void) { }
1256 #endif
1257
1258 #define INPUT_DEV_STRING_ATTR_SHOW(name)                                \
1259 static ssize_t input_dev_show_##name(struct device *dev,                \
1260                                      struct device_attribute *attr,     \
1261                                      char *buf)                         \
1262 {                                                                       \
1263         struct input_dev *input_dev = to_input_dev(dev);                \
1264                                                                         \
1265         return scnprintf(buf, PAGE_SIZE, "%s\n",                        \
1266                          input_dev->name ? input_dev->name : "");       \
1267 }                                                                       \
1268 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1269
1270 INPUT_DEV_STRING_ATTR_SHOW(name);
1271 INPUT_DEV_STRING_ATTR_SHOW(phys);
1272 INPUT_DEV_STRING_ATTR_SHOW(uniq);
1273
1274 static int input_print_modalias_bits(char *buf, int size,
1275                                      char name, unsigned long *bm,
1276                                      unsigned int min_bit, unsigned int max_bit)
1277 {
1278         int len = 0, i;
1279
1280         len += snprintf(buf, max(size, 0), "%c", name);
1281         for (i = min_bit; i < max_bit; i++)
1282                 if (bm[BIT_WORD(i)] & BIT_MASK(i))
1283                         len += snprintf(buf + len, max(size - len, 0), "%X,", i);
1284         return len;
1285 }
1286
1287 static int input_print_modalias(char *buf, int size, struct input_dev *id,
1288                                 int add_cr)
1289 {
1290         int len;
1291
1292         len = snprintf(buf, max(size, 0),
1293                        "input:b%04Xv%04Xp%04Xe%04X-",
1294                        id->id.bustype, id->id.vendor,
1295                        id->id.product, id->id.version);
1296
1297         len += input_print_modalias_bits(buf + len, size - len,
1298                                 'e', id->evbit, 0, EV_MAX);
1299         len += input_print_modalias_bits(buf + len, size - len,
1300                                 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1301         len += input_print_modalias_bits(buf + len, size - len,
1302                                 'r', id->relbit, 0, REL_MAX);
1303         len += input_print_modalias_bits(buf + len, size - len,
1304                                 'a', id->absbit, 0, ABS_MAX);
1305         len += input_print_modalias_bits(buf + len, size - len,
1306                                 'm', id->mscbit, 0, MSC_MAX);
1307         len += input_print_modalias_bits(buf + len, size - len,
1308                                 'l', id->ledbit, 0, LED_MAX);
1309         len += input_print_modalias_bits(buf + len, size - len,
1310                                 's', id->sndbit, 0, SND_MAX);
1311         len += input_print_modalias_bits(buf + len, size - len,
1312                                 'f', id->ffbit, 0, FF_MAX);
1313         len += input_print_modalias_bits(buf + len, size - len,
1314                                 'w', id->swbit, 0, SW_MAX);
1315
1316         if (add_cr)
1317                 len += snprintf(buf + len, max(size - len, 0), "\n");
1318
1319         return len;
1320 }
1321
1322 static ssize_t input_dev_show_modalias(struct device *dev,
1323                                        struct device_attribute *attr,
1324                                        char *buf)
1325 {
1326         struct input_dev *id = to_input_dev(dev);
1327         ssize_t len;
1328
1329         len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1330
1331         return min_t(int, len, PAGE_SIZE);
1332 }
1333 static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1334
1335 static struct attribute *input_dev_attrs[] = {
1336         &dev_attr_name.attr,
1337         &dev_attr_phys.attr,
1338         &dev_attr_uniq.attr,
1339         &dev_attr_modalias.attr,
1340         NULL
1341 };
1342
1343 static struct attribute_group input_dev_attr_group = {
1344         .attrs  = input_dev_attrs,
1345 };
1346
1347 #define INPUT_DEV_ID_ATTR(name)                                         \
1348 static ssize_t input_dev_show_id_##name(struct device *dev,             \
1349                                         struct device_attribute *attr,  \
1350                                         char *buf)                      \
1351 {                                                                       \
1352         struct input_dev *input_dev = to_input_dev(dev);                \
1353         return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1354 }                                                                       \
1355 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1356
1357 INPUT_DEV_ID_ATTR(bustype);
1358 INPUT_DEV_ID_ATTR(vendor);
1359 INPUT_DEV_ID_ATTR(product);
1360 INPUT_DEV_ID_ATTR(version);
1361
1362 static struct attribute *input_dev_id_attrs[] = {
1363         &dev_attr_bustype.attr,
1364         &dev_attr_vendor.attr,
1365         &dev_attr_product.attr,
1366         &dev_attr_version.attr,
1367         NULL
1368 };
1369
1370 static struct attribute_group input_dev_id_attr_group = {
1371         .name   = "id",
1372         .attrs  = input_dev_id_attrs,
1373 };
1374
1375 static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1376                               int max, int add_cr)
1377 {
1378         int i;
1379         int len = 0;
1380         bool skip_empty = true;
1381
1382         for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1383                 len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1384                                             bitmap[i], skip_empty);
1385                 if (len) {
1386                         skip_empty = false;
1387                         if (i > 0)
1388                                 len += snprintf(buf + len, max(buf_size - len, 0), " ");
1389                 }
1390         }
1391
1392         /*
1393          * If no output was produced print a single 0.
1394          */
1395         if (len == 0)
1396                 len = snprintf(buf, buf_size, "%d", 0);
1397
1398         if (add_cr)
1399                 len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1400
1401         return len;
1402 }
1403
1404 #define INPUT_DEV_CAP_ATTR(ev, bm)                                      \
1405 static ssize_t input_dev_show_cap_##bm(struct device *dev,              \
1406                                        struct device_attribute *attr,   \
1407                                        char *buf)                       \
1408 {                                                                       \
1409         struct input_dev *input_dev = to_input_dev(dev);                \
1410         int len = input_print_bitmap(buf, PAGE_SIZE,                    \
1411                                      input_dev->bm##bit, ev##_MAX,      \
1412                                      true);                             \
1413         return min_t(int, len, PAGE_SIZE);                              \
1414 }                                                                       \
1415 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1416
1417 INPUT_DEV_CAP_ATTR(EV, ev);
1418 INPUT_DEV_CAP_ATTR(KEY, key);
1419 INPUT_DEV_CAP_ATTR(REL, rel);
1420 INPUT_DEV_CAP_ATTR(ABS, abs);
1421 INPUT_DEV_CAP_ATTR(MSC, msc);
1422 INPUT_DEV_CAP_ATTR(LED, led);
1423 INPUT_DEV_CAP_ATTR(SND, snd);
1424 INPUT_DEV_CAP_ATTR(FF, ff);
1425 INPUT_DEV_CAP_ATTR(SW, sw);
1426
1427 static struct attribute *input_dev_caps_attrs[] = {
1428         &dev_attr_ev.attr,
1429         &dev_attr_key.attr,
1430         &dev_attr_rel.attr,
1431         &dev_attr_abs.attr,
1432         &dev_attr_msc.attr,
1433         &dev_attr_led.attr,
1434         &dev_attr_snd.attr,
1435         &dev_attr_ff.attr,
1436         &dev_attr_sw.attr,
1437         NULL
1438 };
1439
1440 static struct attribute_group input_dev_caps_attr_group = {
1441         .name   = "capabilities",
1442         .attrs  = input_dev_caps_attrs,
1443 };
1444
1445 static const struct attribute_group *input_dev_attr_groups[] = {
1446         &input_dev_attr_group,
1447         &input_dev_id_attr_group,
1448         &input_dev_caps_attr_group,
1449         NULL
1450 };
1451
1452 static void input_dev_release(struct device *device)
1453 {
1454         struct input_dev *dev = to_input_dev(device);
1455
1456         input_ff_destroy(dev);
1457         input_mt_destroy_slots(dev);
1458         kfree(dev->absinfo);
1459         kfree(dev);
1460
1461         module_put(THIS_MODULE);
1462 }
1463
1464 /*
1465  * Input uevent interface - loading event handlers based on
1466  * device bitfields.
1467  */
1468 static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1469                                    const char *name, unsigned long *bitmap, int max)
1470 {
1471         int len;
1472
1473         if (add_uevent_var(env, "%s=", name))
1474                 return -ENOMEM;
1475
1476         len = input_print_bitmap(&env->buf[env->buflen - 1],
1477                                  sizeof(env->buf) - env->buflen,
1478                                  bitmap, max, false);
1479         if (len >= (sizeof(env->buf) - env->buflen))
1480                 return -ENOMEM;
1481
1482         env->buflen += len;
1483         return 0;
1484 }
1485
1486 static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1487                                          struct input_dev *dev)
1488 {
1489         int len;
1490
1491         if (add_uevent_var(env, "MODALIAS="))
1492                 return -ENOMEM;
1493
1494         len = input_print_modalias(&env->buf[env->buflen - 1],
1495                                    sizeof(env->buf) - env->buflen,
1496                                    dev, 0);
1497         if (len >= (sizeof(env->buf) - env->buflen))
1498                 return -ENOMEM;
1499
1500         env->buflen += len;
1501         return 0;
1502 }
1503
1504 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...)                              \
1505         do {                                                            \
1506                 int err = add_uevent_var(env, fmt, val);                \
1507                 if (err)                                                \
1508                         return err;                                     \
1509         } while (0)
1510
1511 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)                         \
1512         do {                                                            \
1513                 int err = input_add_uevent_bm_var(env, name, bm, max);  \
1514                 if (err)                                                \
1515                         return err;                                     \
1516         } while (0)
1517
1518 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)                             \
1519         do {                                                            \
1520                 int err = input_add_uevent_modalias_var(env, dev);      \
1521                 if (err)                                                \
1522                         return err;                                     \
1523         } while (0)
1524
1525 static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1526 {
1527         struct input_dev *dev = to_input_dev(device);
1528
1529         INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1530                                 dev->id.bustype, dev->id.vendor,
1531                                 dev->id.product, dev->id.version);
1532         if (dev->name)
1533                 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1534         if (dev->phys)
1535                 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1536         if (dev->uniq)
1537                 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1538
1539         INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1540         if (test_bit(EV_KEY, dev->evbit))
1541                 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1542         if (test_bit(EV_REL, dev->evbit))
1543                 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1544         if (test_bit(EV_ABS, dev->evbit))
1545                 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1546         if (test_bit(EV_MSC, dev->evbit))
1547                 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1548         if (test_bit(EV_LED, dev->evbit))
1549                 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1550         if (test_bit(EV_SND, dev->evbit))
1551                 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1552         if (test_bit(EV_FF, dev->evbit))
1553                 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1554         if (test_bit(EV_SW, dev->evbit))
1555                 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1556
1557         INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1558
1559         return 0;
1560 }
1561
1562 #define INPUT_DO_TOGGLE(dev, type, bits, on)                            \
1563         do {                                                            \
1564                 int i;                                                  \
1565                 bool active;                                            \
1566                                                                         \
1567                 if (!test_bit(EV_##type, dev->evbit))                   \
1568                         break;                                          \
1569                                                                         \
1570                 for (i = 0; i < type##_MAX; i++) {                      \
1571                         if (!test_bit(i, dev->bits##bit))               \
1572                                 continue;                               \
1573                                                                         \
1574                         active = test_bit(i, dev->bits);                \
1575                         if (!active && !on)                             \
1576                                 continue;                               \
1577                                                                         \
1578                         dev->event(dev, EV_##type, i, on ? active : 0); \
1579                 }                                                       \
1580         } while (0)
1581
1582 static void input_dev_toggle(struct input_dev *dev, bool activate)
1583 {
1584         if (!dev->event)
1585                 return;
1586
1587         INPUT_DO_TOGGLE(dev, LED, led, activate);
1588         INPUT_DO_TOGGLE(dev, SND, snd, activate);
1589
1590         if (activate && test_bit(EV_REP, dev->evbit)) {
1591                 dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1592                 dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1593         }
1594 }
1595
1596 /**
1597  * input_reset_device() - reset/restore the state of input device
1598  * @dev: input device whose state needs to be reset
1599  *
1600  * This function tries to reset the state of an opened input device and
1601  * bring internal state and state if the hardware in sync with each other.
1602  * We mark all keys as released, restore LED state, repeat rate, etc.
1603  */
1604 void input_reset_device(struct input_dev *dev)
1605 {
1606         mutex_lock(&dev->mutex);
1607
1608         if (dev->users) {
1609                 input_dev_toggle(dev, true);
1610
1611                 /*
1612                  * Keys that have been pressed at suspend time are unlikely
1613                  * to be still pressed when we resume.
1614                  */
1615                 spin_lock_irq(&dev->event_lock);
1616                 input_dev_release_keys(dev);
1617                 spin_unlock_irq(&dev->event_lock);
1618         }
1619
1620         mutex_unlock(&dev->mutex);
1621 }
1622 EXPORT_SYMBOL(input_reset_device);
1623
1624 #ifdef CONFIG_PM
1625 static int input_dev_suspend(struct device *dev)
1626 {
1627         struct input_dev *input_dev = to_input_dev(dev);
1628
1629         mutex_lock(&input_dev->mutex);
1630
1631         if (input_dev->users)
1632                 input_dev_toggle(input_dev, false);
1633
1634         mutex_unlock(&input_dev->mutex);
1635
1636         return 0;
1637 }
1638
1639 static int input_dev_resume(struct device *dev)
1640 {
1641         struct input_dev *input_dev = to_input_dev(dev);
1642
1643         input_reset_device(input_dev);
1644
1645         return 0;
1646 }
1647
1648 static const struct dev_pm_ops input_dev_pm_ops = {
1649         .suspend        = input_dev_suspend,
1650         .resume         = input_dev_resume,
1651         .poweroff       = input_dev_suspend,
1652         .restore        = input_dev_resume,
1653 };
1654 #endif /* CONFIG_PM */
1655
1656 static struct device_type input_dev_type = {
1657         .groups         = input_dev_attr_groups,
1658         .release        = input_dev_release,
1659         .uevent         = input_dev_uevent,
1660 #ifdef CONFIG_PM
1661         .pm             = &input_dev_pm_ops,
1662 #endif
1663 };
1664
1665 static char *input_devnode(struct device *dev, mode_t *mode)
1666 {
1667         return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1668 }
1669
1670 struct class input_class = {
1671         .name           = "input",
1672         .devnode        = input_devnode,
1673 };
1674 EXPORT_SYMBOL_GPL(input_class);
1675
1676 /**
1677  * input_allocate_device - allocate memory for new input device
1678  *
1679  * Returns prepared struct input_dev or NULL.
1680  *
1681  * NOTE: Use input_free_device() to free devices that have not been
1682  * registered; input_unregister_device() should be used for already
1683  * registered devices.
1684  */
1685 struct input_dev *input_allocate_device(void)
1686 {
1687         struct input_dev *dev;
1688
1689         dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
1690         if (dev) {
1691                 dev->dev.type = &input_dev_type;
1692                 dev->dev.class = &input_class;
1693                 device_initialize(&dev->dev);
1694                 mutex_init(&dev->mutex);
1695                 spin_lock_init(&dev->event_lock);
1696                 INIT_LIST_HEAD(&dev->h_list);
1697                 INIT_LIST_HEAD(&dev->node);
1698
1699                 __module_get(THIS_MODULE);
1700         }
1701
1702         return dev;
1703 }
1704 EXPORT_SYMBOL(input_allocate_device);
1705
1706 /**
1707  * input_free_device - free memory occupied by input_dev structure
1708  * @dev: input device to free
1709  *
1710  * This function should only be used if input_register_device()
1711  * was not called yet or if it failed. Once device was registered
1712  * use input_unregister_device() and memory will be freed once last
1713  * reference to the device is dropped.
1714  *
1715  * Device should be allocated by input_allocate_device().
1716  *
1717  * NOTE: If there are references to the input device then memory
1718  * will not be freed until last reference is dropped.
1719  */
1720 void input_free_device(struct input_dev *dev)
1721 {
1722         if (dev)
1723                 input_put_device(dev);
1724 }
1725 EXPORT_SYMBOL(input_free_device);
1726
1727 /**
1728  * input_mt_create_slots() - create MT input slots
1729  * @dev: input device supporting MT events and finger tracking
1730  * @num_slots: number of slots used by the device
1731  *
1732  * This function allocates all necessary memory for MT slot handling in the
1733  * input device, and adds ABS_MT_SLOT to the device capabilities. All slots
1734  * are initially marked as unused by setting ABS_MT_TRACKING_ID to -1.
1735  */
1736 int input_mt_create_slots(struct input_dev *dev, unsigned int num_slots)
1737 {
1738         int i;
1739
1740         if (!num_slots)
1741                 return 0;
1742
1743         dev->mt = kcalloc(num_slots, sizeof(struct input_mt_slot), GFP_KERNEL);
1744         if (!dev->mt)
1745                 return -ENOMEM;
1746
1747         dev->mtsize = num_slots;
1748         input_set_abs_params(dev, ABS_MT_SLOT, 0, num_slots - 1, 0, 0);
1749
1750         /* Mark slots as 'unused' */
1751         for (i = 0; i < num_slots; i++)
1752                 dev->mt[i].abs[ABS_MT_TRACKING_ID - ABS_MT_FIRST] = -1;
1753
1754         return 0;
1755 }
1756 EXPORT_SYMBOL(input_mt_create_slots);
1757
1758 /**
1759  * input_mt_destroy_slots() - frees the MT slots of the input device
1760  * @dev: input device with allocated MT slots
1761  *
1762  * This function is only needed in error path as the input core will
1763  * automatically free the MT slots when the device is destroyed.
1764  */
1765 void input_mt_destroy_slots(struct input_dev *dev)
1766 {
1767         kfree(dev->mt);
1768         dev->mt = NULL;
1769         dev->mtsize = 0;
1770 }
1771 EXPORT_SYMBOL(input_mt_destroy_slots);
1772
1773 /**
1774  * input_set_capability - mark device as capable of a certain event
1775  * @dev: device that is capable of emitting or accepting event
1776  * @type: type of the event (EV_KEY, EV_REL, etc...)
1777  * @code: event code
1778  *
1779  * In addition to setting up corresponding bit in appropriate capability
1780  * bitmap the function also adjusts dev->evbit.
1781  */
1782 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1783 {
1784         switch (type) {
1785         case EV_KEY:
1786                 __set_bit(code, dev->keybit);
1787                 break;
1788
1789         case EV_REL:
1790                 __set_bit(code, dev->relbit);
1791                 break;
1792
1793         case EV_ABS:
1794                 __set_bit(code, dev->absbit);
1795                 break;
1796
1797         case EV_MSC:
1798                 __set_bit(code, dev->mscbit);
1799                 break;
1800
1801         case EV_SW:
1802                 __set_bit(code, dev->swbit);
1803                 break;
1804
1805         case EV_LED:
1806                 __set_bit(code, dev->ledbit);
1807                 break;
1808
1809         case EV_SND:
1810                 __set_bit(code, dev->sndbit);
1811                 break;
1812
1813         case EV_FF:
1814                 __set_bit(code, dev->ffbit);
1815                 break;
1816
1817         case EV_PWR:
1818                 /* do nothing */
1819                 break;
1820
1821         default:
1822                 printk(KERN_ERR
1823                         "input_set_capability: unknown type %u (code %u)\n",
1824                         type, code);
1825                 dump_stack();
1826                 return;
1827         }
1828
1829         __set_bit(type, dev->evbit);
1830 }
1831 EXPORT_SYMBOL(input_set_capability);
1832
1833 #define INPUT_CLEANSE_BITMASK(dev, type, bits)                          \
1834         do {                                                            \
1835                 if (!test_bit(EV_##type, dev->evbit))                   \
1836                         memset(dev->bits##bit, 0,                       \
1837                                 sizeof(dev->bits##bit));                \
1838         } while (0)
1839
1840 static void input_cleanse_bitmasks(struct input_dev *dev)
1841 {
1842         INPUT_CLEANSE_BITMASK(dev, KEY, key);
1843         INPUT_CLEANSE_BITMASK(dev, REL, rel);
1844         INPUT_CLEANSE_BITMASK(dev, ABS, abs);
1845         INPUT_CLEANSE_BITMASK(dev, MSC, msc);
1846         INPUT_CLEANSE_BITMASK(dev, LED, led);
1847         INPUT_CLEANSE_BITMASK(dev, SND, snd);
1848         INPUT_CLEANSE_BITMASK(dev, FF, ff);
1849         INPUT_CLEANSE_BITMASK(dev, SW, sw);
1850 }
1851
1852 /**
1853  * input_register_device - register device with input core
1854  * @dev: device to be registered
1855  *
1856  * This function registers device with input core. The device must be
1857  * allocated with input_allocate_device() and all it's capabilities
1858  * set up before registering.
1859  * If function fails the device must be freed with input_free_device().
1860  * Once device has been successfully registered it can be unregistered
1861  * with input_unregister_device(); input_free_device() should not be
1862  * called in this case.
1863  */
1864 int input_register_device(struct input_dev *dev)
1865 {
1866         static atomic_t input_no = ATOMIC_INIT(0);
1867         struct input_handler *handler;
1868         const char *path;
1869         int error;
1870
1871         /* Every input device generates EV_SYN/SYN_REPORT events. */
1872         __set_bit(EV_SYN, dev->evbit);
1873
1874         /* KEY_RESERVED is not supposed to be transmitted to userspace. */
1875         __clear_bit(KEY_RESERVED, dev->keybit);
1876
1877         /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
1878         input_cleanse_bitmasks(dev);
1879
1880         /*
1881          * If delay and period are pre-set by the driver, then autorepeating
1882          * is handled by the driver itself and we don't do it in input.c.
1883          */
1884         init_timer(&dev->timer);
1885         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
1886                 dev->timer.data = (long) dev;
1887                 dev->timer.function = input_repeat_key;
1888                 dev->rep[REP_DELAY] = 250;
1889                 dev->rep[REP_PERIOD] = 33;
1890         }
1891
1892         if (!dev->getkeycode && !dev->getkeycode_new)
1893                 dev->getkeycode_new = input_default_getkeycode;
1894
1895         if (!dev->setkeycode && !dev->setkeycode_new)
1896                 dev->setkeycode_new = input_default_setkeycode;
1897
1898         dev_set_name(&dev->dev, "input%ld",
1899                      (unsigned long) atomic_inc_return(&input_no) - 1);
1900
1901         error = device_add(&dev->dev);
1902         if (error)
1903                 return error;
1904
1905         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1906         printk(KERN_INFO "input: %s as %s\n",
1907                 dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
1908         kfree(path);
1909
1910         error = mutex_lock_interruptible(&input_mutex);
1911         if (error) {
1912                 device_del(&dev->dev);
1913                 return error;
1914         }
1915
1916         list_add_tail(&dev->node, &input_dev_list);
1917
1918         list_for_each_entry(handler, &input_handler_list, node)
1919                 input_attach_handler(dev, handler);
1920
1921         input_wakeup_procfs_readers();
1922
1923         mutex_unlock(&input_mutex);
1924
1925         return 0;
1926 }
1927 EXPORT_SYMBOL(input_register_device);
1928
1929 /**
1930  * input_unregister_device - unregister previously registered device
1931  * @dev: device to be unregistered
1932  *
1933  * This function unregisters an input device. Once device is unregistered
1934  * the caller should not try to access it as it may get freed at any moment.
1935  */
1936 void input_unregister_device(struct input_dev *dev)
1937 {
1938         struct input_handle *handle, *next;
1939
1940         input_disconnect_device(dev);
1941
1942         mutex_lock(&input_mutex);
1943
1944         list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
1945                 handle->handler->disconnect(handle);
1946         WARN_ON(!list_empty(&dev->h_list));
1947
1948         del_timer_sync(&dev->timer);
1949         list_del_init(&dev->node);
1950
1951         input_wakeup_procfs_readers();
1952
1953         mutex_unlock(&input_mutex);
1954
1955         device_unregister(&dev->dev);
1956 }
1957 EXPORT_SYMBOL(input_unregister_device);
1958
1959 /**
1960  * input_register_handler - register a new input handler
1961  * @handler: handler to be registered
1962  *
1963  * This function registers a new input handler (interface) for input
1964  * devices in the system and attaches it to all input devices that
1965  * are compatible with the handler.
1966  */
1967 int input_register_handler(struct input_handler *handler)
1968 {
1969         struct input_dev *dev;
1970         int retval;
1971
1972         retval = mutex_lock_interruptible(&input_mutex);
1973         if (retval)
1974                 return retval;
1975
1976         INIT_LIST_HEAD(&handler->h_list);
1977
1978         if (handler->fops != NULL) {
1979                 if (input_table[handler->minor >> 5]) {
1980                         retval = -EBUSY;
1981                         goto out;
1982                 }
1983                 input_table[handler->minor >> 5] = handler;
1984         }
1985
1986         list_add_tail(&handler->node, &input_handler_list);
1987
1988         list_for_each_entry(dev, &input_dev_list, node)
1989                 input_attach_handler(dev, handler);
1990
1991         input_wakeup_procfs_readers();
1992
1993  out:
1994         mutex_unlock(&input_mutex);
1995         return retval;
1996 }
1997 EXPORT_SYMBOL(input_register_handler);
1998
1999 /**
2000  * input_unregister_handler - unregisters an input handler
2001  * @handler: handler to be unregistered
2002  *
2003  * This function disconnects a handler from its input devices and
2004  * removes it from lists of known handlers.
2005  */
2006 void input_unregister_handler(struct input_handler *handler)
2007 {
2008         struct input_handle *handle, *next;
2009
2010         mutex_lock(&input_mutex);
2011
2012         list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
2013                 handler->disconnect(handle);
2014         WARN_ON(!list_empty(&handler->h_list));
2015
2016         list_del_init(&handler->node);
2017
2018         if (handler->fops != NULL)
2019                 input_table[handler->minor >> 5] = NULL;
2020
2021         input_wakeup_procfs_readers();
2022
2023         mutex_unlock(&input_mutex);
2024 }
2025 EXPORT_SYMBOL(input_unregister_handler);
2026
2027 /**
2028  * input_handler_for_each_handle - handle iterator
2029  * @handler: input handler to iterate
2030  * @data: data for the callback
2031  * @fn: function to be called for each handle
2032  *
2033  * Iterate over @bus's list of devices, and call @fn for each, passing
2034  * it @data and stop when @fn returns a non-zero value. The function is
2035  * using RCU to traverse the list and therefore may be usind in atonic
2036  * contexts. The @fn callback is invoked from RCU critical section and
2037  * thus must not sleep.
2038  */
2039 int input_handler_for_each_handle(struct input_handler *handler, void *data,
2040                                   int (*fn)(struct input_handle *, void *))
2041 {
2042         struct input_handle *handle;
2043         int retval = 0;
2044
2045         rcu_read_lock();
2046
2047         list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2048                 retval = fn(handle, data);
2049                 if (retval)
2050                         break;
2051         }
2052
2053         rcu_read_unlock();
2054
2055         return retval;
2056 }
2057 EXPORT_SYMBOL(input_handler_for_each_handle);
2058
2059 /**
2060  * input_register_handle - register a new input handle
2061  * @handle: handle to register
2062  *
2063  * This function puts a new input handle onto device's
2064  * and handler's lists so that events can flow through
2065  * it once it is opened using input_open_device().
2066  *
2067  * This function is supposed to be called from handler's
2068  * connect() method.
2069  */
2070 int input_register_handle(struct input_handle *handle)
2071 {
2072         struct input_handler *handler = handle->handler;
2073         struct input_dev *dev = handle->dev;
2074         int error;
2075
2076         /*
2077          * We take dev->mutex here to prevent race with
2078          * input_release_device().
2079          */
2080         error = mutex_lock_interruptible(&dev->mutex);
2081         if (error)
2082                 return error;
2083
2084         /*
2085          * Filters go to the head of the list, normal handlers
2086          * to the tail.
2087          */
2088         if (handler->filter)
2089                 list_add_rcu(&handle->d_node, &dev->h_list);
2090         else
2091                 list_add_tail_rcu(&handle->d_node, &dev->h_list);
2092
2093         mutex_unlock(&dev->mutex);
2094
2095         /*
2096          * Since we are supposed to be called from ->connect()
2097          * which is mutually exclusive with ->disconnect()
2098          * we can't be racing with input_unregister_handle()
2099          * and so separate lock is not needed here.
2100          */
2101         list_add_tail_rcu(&handle->h_node, &handler->h_list);
2102
2103         if (handler->start)
2104                 handler->start(handle);
2105
2106         return 0;
2107 }
2108 EXPORT_SYMBOL(input_register_handle);
2109
2110 /**
2111  * input_unregister_handle - unregister an input handle
2112  * @handle: handle to unregister
2113  *
2114  * This function removes input handle from device's
2115  * and handler's lists.
2116  *
2117  * This function is supposed to be called from handler's
2118  * disconnect() method.
2119  */
2120 void input_unregister_handle(struct input_handle *handle)
2121 {
2122         struct input_dev *dev = handle->dev;
2123
2124         list_del_rcu(&handle->h_node);
2125
2126         /*
2127          * Take dev->mutex to prevent race with input_release_device().
2128          */
2129         mutex_lock(&dev->mutex);
2130         list_del_rcu(&handle->d_node);
2131         mutex_unlock(&dev->mutex);
2132
2133         synchronize_rcu();
2134 }
2135 EXPORT_SYMBOL(input_unregister_handle);
2136
2137 static int input_open_file(struct inode *inode, struct file *file)
2138 {
2139         struct input_handler *handler;
2140         const struct file_operations *old_fops, *new_fops = NULL;
2141         int err;
2142
2143         err = mutex_lock_interruptible(&input_mutex);
2144         if (err)
2145                 return err;
2146
2147         /* No load-on-demand here? */
2148         handler = input_table[iminor(inode) >> 5];
2149         if (handler)
2150                 new_fops = fops_get(handler->fops);
2151
2152         mutex_unlock(&input_mutex);
2153
2154         /*
2155          * That's _really_ odd. Usually NULL ->open means "nothing special",
2156          * not "no device". Oh, well...
2157          */
2158         if (!new_fops || !new_fops->open) {
2159                 fops_put(new_fops);
2160                 err = -ENODEV;
2161                 goto out;
2162         }
2163
2164         old_fops = file->f_op;
2165         file->f_op = new_fops;
2166
2167         err = new_fops->open(inode, file);
2168         if (err) {
2169                 fops_put(file->f_op);
2170                 file->f_op = fops_get(old_fops);
2171         }
2172         fops_put(old_fops);
2173 out:
2174         return err;
2175 }
2176
2177 static const struct file_operations input_fops = {
2178         .owner = THIS_MODULE,
2179         .open = input_open_file,
2180         .llseek = noop_llseek,
2181 };
2182
2183 static int __init input_init(void)
2184 {
2185         int err;
2186
2187         err = class_register(&input_class);
2188         if (err) {
2189                 printk(KERN_ERR "input: unable to register input_dev class\n");
2190                 return err;
2191         }
2192
2193         err = input_proc_init();
2194         if (err)
2195                 goto fail1;
2196
2197         err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
2198         if (err) {
2199                 printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
2200                 goto fail2;
2201         }
2202
2203         return 0;
2204
2205  fail2: input_proc_exit();
2206  fail1: class_unregister(&input_class);
2207         return err;
2208 }
2209
2210 static void __exit input_exit(void)
2211 {
2212         input_proc_exit();
2213         unregister_chrdev(INPUT_MAJOR, "input");
2214         class_unregister(&input_class);
2215 }
2216
2217 subsys_initcall(input_init);
2218 module_exit(input_exit);