Pileus Git - ~andy/linux/blob - drivers/input/input.c

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