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