drivers/input/input.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * The input core
   4  *
   5  * Copyright (c) 1999-2002 Vojtech Pavlik
   6  */
   7
   8
   9 #define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
  10
  11 #include <linux/init.h>
  12 #include <linux/types.h>
  13 #include <linux/idr.h>
  14 #include <linux/input/mt.h>
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17 #include <linux/random.h>
  18 #include <linux/major.h>
  19 #include <linux/proc_fs.h>
  20 #include <linux/sched.h>
  21 #include <linux/seq_file.h>
  22 #include <linux/pm.h>
  23 #include <linux/poll.h>
  24 #include <linux/device.h>
  25 #include <linux/kstrtox.h>
  26 #include <linux/mutex.h>
  27 #include <linux/rcupdate.h>
  28 #include "input-compat.h"
  29 #include "input-core-private.h"
  30 #include "input-poller.h"
  31
  32 MODULE_AUTHOR("Vojtech Pavlik <[email protected]>");
  33 MODULE_DESCRIPTION("Input core");
  34 MODULE_LICENSE("GPL");
  35
  36 #define INPUT_MAX_CHAR_DEVICES          1024
  37 #define INPUT_FIRST_DYNAMIC_DEV         256
  38 static DEFINE_IDA(input_ida);
  39
  40 static LIST_HEAD(input_dev_list);
  41 static LIST_HEAD(input_handler_list);
  42
  43 /*
  44  * input_mutex protects access to both input_dev_list and input_handler_list.
  45  * This also causes input_[un]register_device and input_[un]register_handler
  46  * be mutually exclusive which simplifies locking in drivers implementing
  47  * input handlers.
  48  */
  49 static DEFINE_MUTEX(input_mutex);
  50
  51 static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 };
  52
  53 static const unsigned int input_max_code[EV_CNT] = {
  54         [EV_KEY] = KEY_MAX,
  55         [EV_REL] = REL_MAX,
  56         [EV_ABS] = ABS_MAX,
  57         [EV_MSC] = MSC_MAX,
  58         [EV_SW] = SW_MAX,
  59         [EV_LED] = LED_MAX,
  60         [EV_SND] = SND_MAX,
  61         [EV_FF] = FF_MAX,
  62 };
  63
  64 static inline int is_event_supported(unsigned int code,
  65                                      unsigned long *bm, unsigned int max)
  66 {
  67         return code <= max && test_bit(code, bm);
  68 }
  69
  70 static int input_defuzz_abs_event(int value, int old_val, int fuzz)
  71 {
  72         if (fuzz) {
  73                 if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
  74                         return old_val;
  75
  76                 if (value > old_val - fuzz && value < old_val + fuzz)
  77                         return (old_val * 3 + value) / 4;
  78
  79                 if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
  80                         return (old_val + value) / 2;
  81         }
  82
  83         return value;
  84 }
  85
  86 static void input_start_autorepeat(struct input_dev *dev, int code)
  87 {
  88         if (test_bit(EV_REP, dev->evbit) &&
  89             dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
  90             dev->timer.function) {
  91                 dev->repeat_key = code;
  92                 mod_timer(&dev->timer,
  93                           jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
  94         }
  95 }
  96
  97 static void input_stop_autorepeat(struct input_dev *dev)
  98 {
  99         del_timer(&dev->timer);
 100 }
 101
 102 /*
 103  * Pass values first through all filters and then, if event has not been
 104  * filtered out, through all open handles. This order is achieved by placing
 105  * filters at the head of the list of handles attached to the device, and
 106  * placing regular handles at the tail of the list.
 107  *
 108  * This function is called with dev->event_lock held and interrupts disabled.
 109  */
 110 static void input_pass_values(struct input_dev *dev,
 111                               struct input_value *vals, unsigned int count)
 112 {
 113         struct input_handle *handle;
 114         struct input_value *v;
 115
 116         lockdep_assert_held(&dev->event_lock);
 117
 118         rcu_read_lock();
 119
 120         handle = rcu_dereference(dev->grab);
 121         if (handle) {
 122                 count = handle->handle_events(handle, vals, count);
 123         } else {
 124                 list_for_each_entry_rcu(handle, &dev->h_list, d_node)
 125                         if (handle->open) {
 126                                 count = handle->handle_events(handle, vals,
 127                                                               count);
 128                                 if (!count)
 129                                         break;
 130                         }
 131         }
 132
 133         rcu_read_unlock();
 134
 135         /* trigger auto repeat for key events */
 136         if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
 137                 for (v = vals; v != vals + count; v++) {
 138                         if (v->type == EV_KEY && v->value != 2) {
 139                                 if (v->value)
 140                                         input_start_autorepeat(dev, v->code);
 141                                 else
 142                                         input_stop_autorepeat(dev);
 143                         }
 144                 }
 145         }
 146 }
 147
 148 #define INPUT_IGNORE_EVENT      0
 149 #define INPUT_PASS_TO_HANDLERS  1
 150 #define INPUT_PASS_TO_DEVICE    2
 151 #define INPUT_SLOT              4
 152 #define INPUT_FLUSH             8
 153 #define INPUT_PASS_TO_ALL       (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
 154
 155 static int input_handle_abs_event(struct input_dev *dev,
 156                                   unsigned int code, int *pval)
 157 {
 158         struct input_mt *mt = dev->mt;
 159         bool is_new_slot = false;
 160         bool is_mt_event;
 161         int *pold;
 162
 163         if (code == ABS_MT_SLOT) {
 164                 /*
 165                  * "Stage" the event; we'll flush it later, when we
 166                  * get actual touch data.
 167                  */
 168                 if (mt && *pval >= 0 && *pval < mt->num_slots)
 169                         mt->slot = *pval;
 170
 171                 return INPUT_IGNORE_EVENT;
 172         }
 173
 174         is_mt_event = input_is_mt_value(code);
 175
 176         if (!is_mt_event) {
 177                 pold = &dev->absinfo[code].value;
 178         } else if (mt) {
 179                 pold = &mt->slots[mt->slot].abs[code - ABS_MT_FIRST];
 180                 is_new_slot = mt->slot != dev->absinfo[ABS_MT_SLOT].value;
 181         } else {
 182                 /*
 183                  * Bypass filtering for multi-touch events when
 184                  * not employing slots.
 185                  */
 186                 pold = NULL;
 187         }
 188
 189         if (pold) {
 190                 *pval = input_defuzz_abs_event(*pval, *pold,
 191                                                 dev->absinfo[code].fuzz);
 192                 if (*pold == *pval)
 193                         return INPUT_IGNORE_EVENT;
 194
 195                 *pold = *pval;
 196         }
 197
 198         /* Flush pending "slot" event */
 199         if (is_new_slot) {
 200                 dev->absinfo[ABS_MT_SLOT].value = mt->slot;
 201                 return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
 202         }
 203
 204         return INPUT_PASS_TO_HANDLERS;
 205 }
 206
 207 static int input_get_disposition(struct input_dev *dev,
 208                           unsigned int type, unsigned int code, int *pval)
 209 {
 210         int disposition = INPUT_IGNORE_EVENT;
 211         int value = *pval;
 212
 213         /* filter-out events from inhibited devices */
 214         if (dev->inhibited)
 215                 return INPUT_IGNORE_EVENT;
 216
 217         switch (type) {
 218
 219         case EV_SYN:
 220                 switch (code) {
 221                 case SYN_CONFIG:
 222                         disposition = INPUT_PASS_TO_ALL;
 223                         break;
 224
 225                 case SYN_REPORT:
 226                         disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
 227                         break;
 228                 case SYN_MT_REPORT:
 229                         disposition = INPUT_PASS_TO_HANDLERS;
 230                         break;
 231                 }
 232                 break;
 233
 234         case EV_KEY:
 235                 if (is_event_supported(code, dev->keybit, KEY_MAX)) {
 236
 237                         /* auto-repeat bypasses state updates */
 238                         if (value == 2) {
 239                                 disposition = INPUT_PASS_TO_HANDLERS;
 240                                 break;
 241                         }
 242
 243                         if (!!test_bit(code, dev->key) != !!value) {
 244
 245                                 __change_bit(code, dev->key);
 246                                 disposition = INPUT_PASS_TO_HANDLERS;
 247                         }
 248                 }
 249                 break;
 250
 251         case EV_SW:
 252                 if (is_event_supported(code, dev->swbit, SW_MAX) &&
 253                     !!test_bit(code, dev->sw) != !!value) {
 254
 255                         __change_bit(code, dev->sw);
 256                         disposition = INPUT_PASS_TO_HANDLERS;
 257                 }
 258                 break;
 259
 260         case EV_ABS:
 261                 if (is_event_supported(code, dev->absbit, ABS_MAX))
 262                         disposition = input_handle_abs_event(dev, code, &value);
 263
 264                 break;
 265
 266         case EV_REL:
 267                 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
 268                         disposition = INPUT_PASS_TO_HANDLERS;
 269
 270                 break;
 271
 272         case EV_MSC:
 273                 if (is_event_supported(code, dev->mscbit, MSC_MAX))
 274                         disposition = INPUT_PASS_TO_ALL;
 275
 276                 break;
 277
 278         case EV_LED:
 279                 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
 280                     !!test_bit(code, dev->led) != !!value) {
 281
 282                         __change_bit(code, dev->led);
 283                         disposition = INPUT_PASS_TO_ALL;
 284                 }
 285                 break;
 286
 287         case EV_SND:
 288                 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
 289
 290                         if (!!test_bit(code, dev->snd) != !!value)
 291                                 __change_bit(code, dev->snd);
 292                         disposition = INPUT_PASS_TO_ALL;
 293                 }
 294                 break;
 295
 296         case EV_REP:
 297                 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
 298                         dev->rep[code] = value;
 299                         disposition = INPUT_PASS_TO_ALL;
 300                 }
 301                 break;
 302
 303         case EV_FF:
 304                 if (value >= 0)
 305                         disposition = INPUT_PASS_TO_ALL;
 306                 break;
 307
 308         case EV_PWR:
 309                 disposition = INPUT_PASS_TO_ALL;
 310                 break;
 311         }
 312
 313         *pval = value;
 314         return disposition;
 315 }
 316
 317 static void input_event_dispose(struct input_dev *dev, int disposition,
 318                                 unsigned int type, unsigned int code, int value)
 319 {
 320         if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
 321                 dev->event(dev, type, code, value);
 322
 323         if (disposition & INPUT_PASS_TO_HANDLERS) {
 324                 struct input_value *v;
 325
 326                 if (disposition & INPUT_SLOT) {
 327                         v = &dev->vals[dev->num_vals++];
 328                         v->type = EV_ABS;
 329                         v->code = ABS_MT_SLOT;
 330                         v->value = dev->mt->slot;
 331                 }
 332
 333                 v = &dev->vals[dev->num_vals++];
 334                 v->type = type;
 335                 v->code = code;
 336                 v->value = value;
 337         }
 338
 339         if (disposition & INPUT_FLUSH) {
 340                 if (dev->num_vals >= 2)
 341                         input_pass_values(dev, dev->vals, dev->num_vals);
 342                 dev->num_vals = 0;
 343                 /*
 344                  * Reset the timestamp on flush so we won't end up
 345                  * with a stale one. Note we only need to reset the
 346                  * monolithic one as we use its presence when deciding
 347                  * whether to generate a synthetic timestamp.
 348                  */
 349                 dev->timestamp[INPUT_CLK_MONO] = ktime_set(0, 0);
 350         } else if (dev->num_vals >= dev->max_vals - 2) {
 351                 dev->vals[dev->num_vals++] = input_value_sync;
 352                 input_pass_values(dev, dev->vals, dev->num_vals);
 353                 dev->num_vals = 0;
 354         }
 355 }
 356
 357 void input_handle_event(struct input_dev *dev,
 358                         unsigned int type, unsigned int code, int value)
 359 {
 360         int disposition;
 361
 362         lockdep_assert_held(&dev->event_lock);
 363
 364         disposition = input_get_disposition(dev, type, code, &value);
 365         if (disposition != INPUT_IGNORE_EVENT) {
 366                 if (type != EV_SYN)
 367                         add_input_randomness(type, code, value);
 368
 369                 input_event_dispose(dev, disposition, type, code, value);
 370         }
 371 }
 372
 373 /**
 374  * input_event() - report new input event
 375  * @dev: device that generated the event
 376  * @type: type of the event
 377  * @code: event code
 378  * @value: value of the event
 379  *
 380  * This function should be used by drivers implementing various input
 381  * devices to report input events. See also input_inject_event().
 382  *
 383  * NOTE: input_event() may be safely used right after input device was
 384  * allocated with input_allocate_device(), even before it is registered
 385  * with input_register_device(), but the event will not reach any of the
 386  * input handlers. Such early invocation of input_event() may be used
 387  * to 'seed' initial state of a switch or initial position of absolute
 388  * axis, etc.
 389  */
 390 void input_event(struct input_dev *dev,
 391                  unsigned int type, unsigned int code, int value)
 392 {
 393         unsigned long flags;
 394
 395         if (is_event_supported(type, dev->evbit, EV_MAX)) {
 396
 397                 spin_lock_irqsave(&dev->event_lock, flags);
 398                 input_handle_event(dev, type, code, value);
 399                 spin_unlock_irqrestore(&dev->event_lock, flags);
 400         }
 401 }
 402 EXPORT_SYMBOL(input_event);
 403
 404 /**
 405  * input_inject_event() - send input event from input handler
 406  * @handle: input handle to send event through
 407  * @type: type of the event
 408  * @code: event code
 409  * @value: value of the event
 410  *
 411  * Similar to input_event() but will ignore event if device is
 412  * "grabbed" and handle injecting event is not the one that owns
 413  * the device.
 414  */
 415 void input_inject_event(struct input_handle *handle,
 416                         unsigned int type, unsigned int code, int value)
 417 {
 418         struct input_dev *dev = handle->dev;
 419         struct input_handle *grab;
 420         unsigned long flags;
 421
 422         if (is_event_supported(type, dev->evbit, EV_MAX)) {
 423                 spin_lock_irqsave(&dev->event_lock, flags);
 424
 425                 rcu_read_lock();
 426                 grab = rcu_dereference(dev->grab);
 427                 if (!grab || grab == handle)
 428                         input_handle_event(dev, type, code, value);
 429                 rcu_read_unlock();
 430
 431                 spin_unlock_irqrestore(&dev->event_lock, flags);
 432         }
 433 }
 434 EXPORT_SYMBOL(input_inject_event);
 435
 436 /**
 437  * input_alloc_absinfo - allocates array of input_absinfo structs
 438  * @dev: the input device emitting absolute events
 439  *
 440  * If the absinfo struct the caller asked for is already allocated, this
 441  * functions will not do anything.
 442  */
 443 void input_alloc_absinfo(struct input_dev *dev)
 444 {
 445         if (dev->absinfo)
 446                 return;
 447
 448         dev->absinfo = kcalloc(ABS_CNT, sizeof(*dev->absinfo), GFP_KERNEL);
 449         if (!dev->absinfo) {
 450                 dev_err(dev->dev.parent ?: &dev->dev,
 451                         "%s: unable to allocate memory\n", __func__);
 452                 /*
 453                  * We will handle this allocation failure in
 454                  * input_register_device() when we refuse to register input
 455                  * device with ABS bits but without absinfo.
 456                  */
 457         }
 458 }
 459 EXPORT_SYMBOL(input_alloc_absinfo);
 460
 461 void input_set_abs_params(struct input_dev *dev, unsigned int axis,
 462                           int min, int max, int fuzz, int flat)
 463 {
 464         struct input_absinfo *absinfo;
 465
 466         __set_bit(EV_ABS, dev->evbit);
 467         __set_bit(axis, dev->absbit);
 468
 469         input_alloc_absinfo(dev);
 470         if (!dev->absinfo)
 471                 return;
 472
 473         absinfo = &dev->absinfo[axis];
 474         absinfo->minimum = min;
 475         absinfo->maximum = max;
 476         absinfo->fuzz = fuzz;
 477         absinfo->flat = flat;
 478 }
 479 EXPORT_SYMBOL(input_set_abs_params);
 480
 481 /**
 482  * input_copy_abs - Copy absinfo from one input_dev to another
 483  * @dst: Destination input device to copy the abs settings to
 484  * @dst_axis: ABS_* value selecting the destination axis
 485  * @src: Source input device to copy the abs settings from
 486  * @src_axis: ABS_* value selecting the source axis
 487  *
 488  * Set absinfo for the selected destination axis by copying it from
 489  * the specified source input device's source axis.
 490  * This is useful to e.g. setup a pen/stylus input-device for combined
 491  * touchscreen/pen hardware where the pen uses the same coordinates as
 492  * the touchscreen.
 493  */
 494 void input_copy_abs(struct input_dev *dst, unsigned int dst_axis,
 495                     const struct input_dev *src, unsigned int src_axis)
 496 {
 497         /* src must have EV_ABS and src_axis set */
 498         if (WARN_ON(!(test_bit(EV_ABS, src->evbit) &&
 499                       test_bit(src_axis, src->absbit))))
 500                 return;
 501
 502         /*
 503          * input_alloc_absinfo() may have failed for the source. Our caller is
 504          * expected to catch this when registering the input devices, which may
 505          * happen after the input_copy_abs() call.
 506          */
 507         if (!src->absinfo)
 508                 return;
 509
 510         input_set_capability(dst, EV_ABS, dst_axis);
 511         if (!dst->absinfo)
 512                 return;
 513
 514         dst->absinfo[dst_axis] = src->absinfo[src_axis];
 515 }
 516 EXPORT_SYMBOL(input_copy_abs);
 517
 518 /**
 519  * input_grab_device - grabs device for exclusive use
 520  * @handle: input handle that wants to own the device
 521  *
 522  * When a device is grabbed by an input handle all events generated by
 523  * the device are delivered only to this handle. Also events injected
 524  * by other input handles are ignored while device is grabbed.
 525  */
 526 int input_grab_device(struct input_handle *handle)
 527 {
 528         struct input_dev *dev = handle->dev;
 529         int retval;
 530
 531         retval = mutex_lock_interruptible(&dev->mutex);
 532         if (retval)
 533                 return retval;
 534
 535         if (dev->grab) {
 536                 retval = -EBUSY;
 537                 goto out;
 538         }
 539
 540         rcu_assign_pointer(dev->grab, handle);
 541
 542  out:
 543         mutex_unlock(&dev->mutex);
 544         return retval;
 545 }
 546 EXPORT_SYMBOL(input_grab_device);
 547
 548 static void __input_release_device(struct input_handle *handle)
 549 {
 550         struct input_dev *dev = handle->dev;
 551         struct input_handle *grabber;
 552
 553         grabber = rcu_dereference_protected(dev->grab,
 554                                             lockdep_is_held(&dev->mutex));
 555         if (grabber == handle) {
 556                 rcu_assign_pointer(dev->grab, NULL);
 557                 /* Make sure input_pass_values() notices that grab is gone */
 558                 synchronize_rcu();
 559
 560                 list_for_each_entry(handle, &dev->h_list, d_node)
 561                         if (handle->open && handle->handler->start)
 562                                 handle->handler->start(handle);
 563         }
 564 }
 565
 566 /**
 567  * input_release_device - release previously grabbed device
 568  * @handle: input handle that owns the device
 569  *
 570  * Releases previously grabbed device so that other input handles can
 571  * start receiving input events. Upon release all handlers attached
 572  * to the device have their start() method called so they have a change
 573  * to synchronize device state with the rest of the system.
 574  */
 575 void input_release_device(struct input_handle *handle)
 576 {
 577         struct input_dev *dev = handle->dev;
 578
 579         mutex_lock(&dev->mutex);
 580         __input_release_device(handle);
 581         mutex_unlock(&dev->mutex);
 582 }
 583 EXPORT_SYMBOL(input_release_device);
 584
 585 /**
 586  * input_open_device - open input device
 587  * @handle: handle through which device is being accessed
 588  *
 589  * This function should be called by input handlers when they
 590  * want to start receive events from given input device.
 591  */
 592 int input_open_device(struct input_handle *handle)
 593 {
 594         struct input_dev *dev = handle->dev;
 595         int retval;
 596
 597         retval = mutex_lock_interruptible(&dev->mutex);
 598         if (retval)
 599                 return retval;
 600
 601         if (dev->going_away) {
 602                 retval = -ENODEV;
 603                 goto out;
 604         }
 605
 606         handle->open++;
 607
 608         if (handle->handler->passive_observer)
 609                 goto out;
 610
 611         if (dev->users++ || dev->inhibited) {
 612                 /*
 613                  * Device is already opened and/or inhibited,
 614                  * so we can exit immediately and report success.
 615                  */
 616                 goto out;
 617         }
 618
 619         if (dev->open) {
 620                 retval = dev->open(dev);
 621                 if (retval) {
 622                         dev->users--;
 623                         handle->open--;
 624                         /*
 625                          * Make sure we are not delivering any more events
 626                          * through this handle
 627                          */
 628                         synchronize_rcu();
 629                         goto out;
 630                 }
 631         }
 632
 633         if (dev->poller)
 634                 input_dev_poller_start(dev->poller);
 635
 636  out:
 637         mutex_unlock(&dev->mutex);
 638         return retval;
 639 }
 640 EXPORT_SYMBOL(input_open_device);
 641
 642 int input_flush_device(struct input_handle *handle, struct file *file)
 643 {
 644         struct input_dev *dev = handle->dev;
 645         int retval;
 646
 647         retval = mutex_lock_interruptible(&dev->mutex);
 648         if (retval)
 649                 return retval;
 650
 651         if (dev->flush)
 652                 retval = dev->flush(dev, file);
 653
 654         mutex_unlock(&dev->mutex);
 655         return retval;
 656 }
 657 EXPORT_SYMBOL(input_flush_device);
 658
 659 /**
 660  * input_close_device - close input device
 661  * @handle: handle through which device is being accessed
 662  *
 663  * This function should be called by input handlers when they
 664  * want to stop receive events from given input device.
 665  */
 666 void input_close_device(struct input_handle *handle)
 667 {
 668         struct input_dev *dev = handle->dev;
 669
 670         mutex_lock(&dev->mutex);
 671
 672         __input_release_device(handle);
 673
 674         if (!handle->handler->passive_observer) {
 675                 if (!--dev->users && !dev->inhibited) {
 676                         if (dev->poller)
 677                                 input_dev_poller_stop(dev->poller);
 678                         if (dev->close)
 679                                 dev->close(dev);
 680                 }
 681         }
 682
 683         if (!--handle->open) {
 684                 /*
 685                  * synchronize_rcu() makes sure that input_pass_values()
 686                  * completed and that no more input events are delivered
 687                  * through this handle
 688                  */
 689                 synchronize_rcu();
 690         }
 691
 692         mutex_unlock(&dev->mutex);
 693 }
 694 EXPORT_SYMBOL(input_close_device);
 695
 696 /*
 697  * Simulate keyup events for all keys that are marked as pressed.
 698  * The function must be called with dev->event_lock held.
 699  */
 700 static bool input_dev_release_keys(struct input_dev *dev)
 701 {
 702         bool need_sync = false;
 703         int code;
 704
 705         lockdep_assert_held(&dev->event_lock);
 706
 707         if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
 708                 for_each_set_bit(code, dev->key, KEY_CNT) {
 709                         input_handle_event(dev, EV_KEY, code, 0);
 710                         need_sync = true;
 711                 }
 712         }
 713
 714         return need_sync;
 715 }
 716
 717 /*
 718  * Prepare device for unregistering
 719  */
 720 static void input_disconnect_device(struct input_dev *dev)
 721 {
 722         struct input_handle *handle;
 723
 724         /*
 725          * Mark device as going away. Note that we take dev->mutex here
 726          * not to protect access to dev->going_away but rather to ensure
 727          * that there are no threads in the middle of input_open_device()
 728          */
 729         mutex_lock(&dev->mutex);
 730         dev->going_away = true;
 731         mutex_unlock(&dev->mutex);
 732
 733         spin_lock_irq(&dev->event_lock);
 734
 735         /*
 736          * Simulate keyup events for all pressed keys so that handlers
 737          * are not left with "stuck" keys. The driver may continue
 738          * generate events even after we done here but they will not
 739          * reach any handlers.
 740          */
 741         if (input_dev_release_keys(dev))
 742                 input_handle_event(dev, EV_SYN, SYN_REPORT, 1);
 743
 744         list_for_each_entry(handle, &dev->h_list, d_node)
 745                 handle->open = 0;
 746
 747         spin_unlock_irq(&dev->event_lock);
 748 }
 749
 750 /**
 751  * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
 752  * @ke: keymap entry containing scancode to be converted.
 753  * @scancode: pointer to the location where converted scancode should
 754  *      be stored.
 755  *
 756  * This function is used to convert scancode stored in &struct keymap_entry
 757  * into scalar form understood by legacy keymap handling methods. These
 758  * methods expect scancodes to be represented as 'unsigned int'.
 759  */
 760 int input_scancode_to_scalar(const struct input_keymap_entry *ke,
 761                              unsigned int *scancode)
 762 {
 763         switch (ke->len) {
 764         case 1:
 765                 *scancode = *((u8 *)ke->scancode);
 766                 break;
 767
 768         case 2:
 769                 *scancode = *((u16 *)ke->scancode);
 770                 break;
 771
 772         case 4:
 773                 *scancode = *((u32 *)ke->scancode);
 774                 break;
 775
 776         default:
 777                 return -EINVAL;
 778         }
 779
 780         return 0;
 781 }
 782 EXPORT_SYMBOL(input_scancode_to_scalar);
 783
 784 /*
 785  * Those routines handle the default case where no [gs]etkeycode() is
 786  * defined. In this case, an array indexed by the scancode is used.
 787  */
 788
 789 static unsigned int input_fetch_keycode(struct input_dev *dev,
 790                                         unsigned int index)
 791 {
 792         switch (dev->keycodesize) {
 793         case 1:
 794                 return ((u8 *)dev->keycode)[index];
 795
 796         case 2:
 797                 return ((u16 *)dev->keycode)[index];
 798
 799         default:
 800                 return ((u32 *)dev->keycode)[index];
 801         }
 802 }
 803
 804 static int input_default_getkeycode(struct input_dev *dev,
 805                                     struct input_keymap_entry *ke)
 806 {
 807         unsigned int index;
 808         int error;
 809
 810         if (!dev->keycodesize)
 811                 return -EINVAL;
 812
 813         if (ke->flags & INPUT_KEYMAP_BY_INDEX)
 814                 index = ke->index;
 815         else {
 816                 error = input_scancode_to_scalar(ke, &index);
 817                 if (error)
 818                         return error;
 819         }
 820
 821         if (index >= dev->keycodemax)
 822                 return -EINVAL;
 823
 824         ke->keycode = input_fetch_keycode(dev, index);
 825         ke->index = index;
 826         ke->len = sizeof(index);
 827         memcpy(ke->scancode, &index, sizeof(index));
 828
 829         return 0;
 830 }
 831
 832 static int input_default_setkeycode(struct input_dev *dev,
 833                                     const struct input_keymap_entry *ke,
 834                                     unsigned int *old_keycode)
 835 {
 836         unsigned int index;
 837         int error;
 838         int i;
 839
 840         if (!dev->keycodesize)
 841                 return -EINVAL;
 842
 843         if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
 844                 index = ke->index;
 845         } else {
 846                 error = input_scancode_to_scalar(ke, &index);
 847                 if (error)
 848                         return error;
 849         }
 850
 851         if (index >= dev->keycodemax)
 852                 return -EINVAL;
 853
 854         if (dev->keycodesize < sizeof(ke->keycode) &&
 855                         (ke->keycode >> (dev->keycodesize * 8)))
 856                 return -EINVAL;
 857
 858         switch (dev->keycodesize) {
 859                 case 1: {
 860                         u8 *k = (u8 *)dev->keycode;
 861                         *old_keycode = k[index];
 862                         k[index] = ke->keycode;
 863                         break;
 864                 }
 865                 case 2: {
 866                         u16 *k = (u16 *)dev->keycode;
 867                         *old_keycode = k[index];
 868                         k[index] = ke->keycode;
 869                         break;
 870                 }
 871                 default: {
 872                         u32 *k = (u32 *)dev->keycode;
 873                         *old_keycode = k[index];
 874                         k[index] = ke->keycode;
 875                         break;
 876                 }
 877         }
 878
 879         if (*old_keycode <= KEY_MAX) {
 880                 __clear_bit(*old_keycode, dev->keybit);
 881                 for (i = 0; i < dev->keycodemax; i++) {
 882                         if (input_fetch_keycode(dev, i) == *old_keycode) {
 883                                 __set_bit(*old_keycode, dev->keybit);
 884                                 /* Setting the bit twice is useless, so break */
 885                                 break;
 886                         }
 887                 }
 888         }
 889
 890         __set_bit(ke->keycode, dev->keybit);
 891         return 0;
 892 }
 893
 894 /**
 895  * input_get_keycode - retrieve keycode currently mapped to a given scancode
 896  * @dev: input device which keymap is being queried
 897  * @ke: keymap entry
 898  *
 899  * This function should be called by anyone interested in retrieving current
 900  * keymap. Presently evdev handlers use it.
 901  */
 902 int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
 903 {
 904         unsigned long flags;
 905         int retval;
 906
 907         spin_lock_irqsave(&dev->event_lock, flags);
 908         retval = dev->getkeycode(dev, ke);
 909         spin_unlock_irqrestore(&dev->event_lock, flags);
 910
 911         return retval;
 912 }
 913 EXPORT_SYMBOL(input_get_keycode);
 914
 915 /**
 916  * input_set_keycode - attribute a keycode to a given scancode
 917  * @dev: input device which keymap is being updated
 918  * @ke: new keymap entry
 919  *
 920  * This function should be called by anyone needing to update current
 921  * keymap. Presently keyboard and evdev handlers use it.
 922  */
 923 int input_set_keycode(struct input_dev *dev,
 924                       const struct input_keymap_entry *ke)
 925 {
 926         unsigned long flags;
 927         unsigned int old_keycode;
 928         int retval;
 929
 930         if (ke->keycode > KEY_MAX)
 931                 return -EINVAL;
 932
 933         spin_lock_irqsave(&dev->event_lock, flags);
 934
 935         retval = dev->setkeycode(dev, ke, &old_keycode);
 936         if (retval)
 937                 goto out;
 938
 939         /* Make sure KEY_RESERVED did not get enabled. */
 940         __clear_bit(KEY_RESERVED, dev->keybit);
 941
 942         /*
 943          * Simulate keyup event if keycode is not present
 944          * in the keymap anymore
 945          */
 946         if (old_keycode > KEY_MAX) {
 947                 dev_warn(dev->dev.parent ?: &dev->dev,
 948                          "%s: got too big old keycode %#x\n",
 949                          __func__, old_keycode);
 950         } else if (test_bit(EV_KEY, dev->evbit) &&
 951                    !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
 952                    __test_and_clear_bit(old_keycode, dev->key)) {
 953                 /*
 954                  * We have to use input_event_dispose() here directly instead
 955                  * of input_handle_event() because the key we want to release
 956                  * here is considered no longer supported by the device and
 957                  * input_handle_event() will ignore it.
 958                  */
 959                 input_event_dispose(dev, INPUT_PASS_TO_HANDLERS,
 960                                     EV_KEY, old_keycode, 0);
 961                 input_event_dispose(dev, INPUT_PASS_TO_HANDLERS | INPUT_FLUSH,
 962                                     EV_SYN, SYN_REPORT, 1);
 963         }
 964
 965  out:
 966         spin_unlock_irqrestore(&dev->event_lock, flags);
 967
 968         return retval;
 969 }
 970 EXPORT_SYMBOL(input_set_keycode);
 971
 972 bool input_match_device_id(const struct input_dev *dev,
 973                            const struct input_device_id *id)
 974 {
 975         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
 976                 if (id->bustype != dev->id.bustype)
 977                         return false;
 978
 979         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
 980                 if (id->vendor != dev->id.vendor)
 981                         return false;
 982
 983         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
 984                 if (id->product != dev->id.product)
 985                         return false;
 986
 987         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
 988                 if (id->version != dev->id.version)
 989                         return false;
 990
 991         if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX) ||
 992             !bitmap_subset(id->keybit, dev->keybit, KEY_MAX) ||
 993             !bitmap_subset(id->relbit, dev->relbit, REL_MAX) ||
 994             !bitmap_subset(id->absbit, dev->absbit, ABS_MAX) ||
 995             !bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX) ||
 996             !bitmap_subset(id->ledbit, dev->ledbit, LED_MAX) ||
 997             !bitmap_subset(id->sndbit, dev->sndbit, SND_MAX) ||
 998             !bitmap_subset(id->ffbit, dev->ffbit, FF_MAX) ||
 999             !bitmap_subset(id->swbit, dev->swbit, SW_MAX) ||
1000             !bitmap_subset(id->propbit, dev->propbit, INPUT_PROP_MAX)) {
1001                 return false;
1002         }
1003
1004         return true;
1005 }
1006 EXPORT_SYMBOL(input_match_device_id);
1007
1008 static const struct input_device_id *input_match_device(struct input_handler *handler,
1009                                                         struct input_dev *dev)
1010 {
1011         const struct input_device_id *id;
1012
1013         for (id = handler->id_table; id->flags || id->driver_info; id++) {
1014                 if (input_match_device_id(dev, id) &&
1015                     (!handler->match || handler->match(handler, dev))) {
1016                         return id;
1017                 }
1018         }
1019
1020         return NULL;
1021 }
1022
1023 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
1024 {
1025         const struct input_device_id *id;
1026         int error;
1027
1028         id = input_match_device(handler, dev);
1029         if (!id)
1030                 return -ENODEV;
1031
1032         error = handler->connect(handler, dev, id);
1033         if (error && error != -ENODEV)
1034                 pr_err("failed to attach handler %s to device %s, error: %d\n",
1035                        handler->name, kobject_name(&dev->dev.kobj), error);
1036
1037         return error;
1038 }
1039
1040 #ifdef CONFIG_COMPAT
1041
1042 static int input_bits_to_string(char *buf, int buf_size,
1043                                 unsigned long bits, bool skip_empty)
1044 {
1045         int len = 0;
1046
1047         if (in_compat_syscall()) {
1048                 u32 dword = bits >> 32;
1049                 if (dword || !skip_empty)
1050                         len += snprintf(buf, buf_size, "%x ", dword);
1051
1052                 dword = bits & 0xffffffffUL;
1053                 if (dword || !skip_empty || len)
1054                         len += snprintf(buf + len, max(buf_size - len, 0),
1055                                         "%x", dword);
1056         } else {
1057                 if (bits || !skip_empty)
1058                         len += snprintf(buf, buf_size, "%lx", bits);
1059         }
1060
1061         return len;
1062 }
1063
1064 #else /* !CONFIG_COMPAT */
1065
1066 static int input_bits_to_string(char *buf, int buf_size,
1067                                 unsigned long bits, bool skip_empty)
1068 {
1069         return bits || !skip_empty ?
1070                 snprintf(buf, buf_size, "%lx", bits) : 0;
1071 }
1072
1073 #endif
1074
1075 #ifdef CONFIG_PROC_FS
1076
1077 static struct proc_dir_entry *proc_bus_input_dir;
1078 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
1079 static int input_devices_state;
1080
1081 static inline void input_wakeup_procfs_readers(void)
1082 {
1083         input_devices_state++;
1084         wake_up(&input_devices_poll_wait);
1085 }
1086
1087 struct input_seq_state {
1088         unsigned short pos;
1089         bool mutex_acquired;
1090         int input_devices_state;
1091 };
1092
1093 static __poll_t input_proc_devices_poll(struct file *file, poll_table *wait)
1094 {
1095         struct seq_file *seq = file->private_data;
1096         struct input_seq_state *state = seq->private;
1097
1098         poll_wait(file, &input_devices_poll_wait, wait);
1099         if (state->input_devices_state != input_devices_state) {
1100                 state->input_devices_state = input_devices_state;
1101                 return EPOLLIN | EPOLLRDNORM;
1102         }
1103
1104         return 0;
1105 }
1106
1107 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
1108 {
1109         struct input_seq_state *state = seq->private;
1110         int error;
1111
1112         error = mutex_lock_interruptible(&input_mutex);
1113         if (error) {
1114                 state->mutex_acquired = false;
1115                 return ERR_PTR(error);
1116         }
1117
1118         state->mutex_acquired = true;
1119
1120         return seq_list_start(&input_dev_list, *pos);
1121 }
1122
1123 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1124 {
1125         return seq_list_next(v, &input_dev_list, pos);
1126 }
1127
1128 static void input_seq_stop(struct seq_file *seq, void *v)
1129 {
1130         struct input_seq_state *state = seq->private;
1131
1132         if (state->mutex_acquired)
1133                 mutex_unlock(&input_mutex);
1134 }
1135
1136 static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
1137                                    unsigned long *bitmap, int max)
1138 {
1139         int i;
1140         bool skip_empty = true;
1141         char buf[18];
1142
1143         seq_printf(seq, "B: %s=", name);
1144
1145         for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1146                 if (input_bits_to_string(buf, sizeof(buf),
1147                                          bitmap[i], skip_empty)) {
1148                         skip_empty = false;
1149                         seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
1150                 }
1151         }
1152
1153         /*
1154          * If no output was produced print a single 0.
1155          */
1156         if (skip_empty)
1157                 seq_putc(seq, '0');
1158
1159         seq_putc(seq, '\n');
1160 }
1161
1162 static int input_devices_seq_show(struct seq_file *seq, void *v)
1163 {
1164         struct input_dev *dev = container_of(v, struct input_dev, node);
1165         const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1166         struct input_handle *handle;
1167
1168         seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1169                    dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
1170
1171         seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1172         seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1173         seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
1174         seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1175         seq_puts(seq, "H: Handlers=");
1176
1177         list_for_each_entry(handle, &dev->h_list, d_node)
1178                 seq_printf(seq, "%s ", handle->name);
1179         seq_putc(seq, '\n');
1180
1181         input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);
1182
1183         input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1184         if (test_bit(EV_KEY, dev->evbit))
1185                 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1186         if (test_bit(EV_REL, dev->evbit))
1187                 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1188         if (test_bit(EV_ABS, dev->evbit))
1189                 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1190         if (test_bit(EV_MSC, dev->evbit))
1191                 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1192         if (test_bit(EV_LED, dev->evbit))
1193                 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1194         if (test_bit(EV_SND, dev->evbit))
1195                 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1196         if (test_bit(EV_FF, dev->evbit))
1197                 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1198         if (test_bit(EV_SW, dev->evbit))
1199                 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
1200
1201         seq_putc(seq, '\n');
1202
1203         kfree(path);
1204         return 0;
1205 }
1206
1207 static const struct seq_operations input_devices_seq_ops = {
1208         .start  = input_devices_seq_start,
1209         .next   = input_devices_seq_next,
1210         .stop   = input_seq_stop,
1211         .show   = input_devices_seq_show,
1212 };
1213
1214 static int input_proc_devices_open(struct inode *inode, struct file *file)
1215 {
1216         return seq_open_private(file, &input_devices_seq_ops,
1217                                 sizeof(struct input_seq_state));
1218 }
1219
1220 static const struct proc_ops input_devices_proc_ops = {
1221         .proc_open      = input_proc_devices_open,
1222         .proc_poll      = input_proc_devices_poll,
1223         .proc_read      = seq_read,
1224         .proc_lseek     = seq_lseek,
1225         .proc_release   = seq_release_private,
1226 };
1227
1228 static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1229 {
1230         struct input_seq_state *state = seq->private;
1231         int error;
1232
1233         error = mutex_lock_interruptible(&input_mutex);
1234         if (error) {
1235                 state->mutex_acquired = false;
1236                 return ERR_PTR(error);
1237         }
1238
1239         state->mutex_acquired = true;
1240         state->pos = *pos;
1241
1242         return seq_list_start(&input_handler_list, *pos);
1243 }
1244
1245 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1246 {
1247         struct input_seq_state *state = seq->private;
1248
1249         state->pos = *pos + 1;
1250         return seq_list_next(v, &input_handler_list, pos);
1251 }
1252
1253 static int input_handlers_seq_show(struct seq_file *seq, void *v)
1254 {
1255         struct input_handler *handler = container_of(v, struct input_handler, node);
1256         struct input_seq_state *state = seq->private;
1257
1258         seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
1259         if (handler->filter)
1260                 seq_puts(seq, " (filter)");
1261         if (handler->legacy_minors)
1262                 seq_printf(seq, " Minor=%d", handler->minor);
1263         seq_putc(seq, '\n');
1264
1265         return 0;
1266 }
1267
1268 static const struct seq_operations input_handlers_seq_ops = {
1269         .start  = input_handlers_seq_start,
1270         .next   = input_handlers_seq_next,
1271         .stop   = input_seq_stop,
1272         .show   = input_handlers_seq_show,
1273 };
1274
1275 static int input_proc_handlers_open(struct inode *inode, struct file *file)
1276 {
1277         return seq_open_private(file, &input_handlers_seq_ops,
1278                                 sizeof(struct input_seq_state));
1279 }
1280
1281 static const struct proc_ops input_handlers_proc_ops = {
1282         .proc_open      = input_proc_handlers_open,
1283         .proc_read      = seq_read,
1284         .proc_lseek     = seq_lseek,
1285         .proc_release   = seq_release_private,
1286 };
1287
1288 static int __init input_proc_init(void)
1289 {
1290         struct proc_dir_entry *entry;
1291
1292         proc_bus_input_dir = proc_mkdir("bus/input", NULL);
1293         if (!proc_bus_input_dir)
1294                 return -ENOMEM;
1295
1296         entry = proc_create("devices", 0, proc_bus_input_dir,
1297                             &input_devices_proc_ops);
1298         if (!entry)
1299                 goto fail1;
1300
1301         entry = proc_create("handlers", 0, proc_bus_input_dir,
1302                             &input_handlers_proc_ops);
1303         if (!entry)
1304                 goto fail2;
1305
1306         return 0;
1307
1308  fail2: remove_proc_entry("devices", proc_bus_input_dir);
1309  fail1: remove_proc_entry("bus/input", NULL);
1310         return -ENOMEM;
1311 }
1312
1313 static void input_proc_exit(void)
1314 {
1315         remove_proc_entry("devices", proc_bus_input_dir);
1316         remove_proc_entry("handlers", proc_bus_input_dir);
1317         remove_proc_entry("bus/input", NULL);
1318 }
1319
1320 #else /* !CONFIG_PROC_FS */
1321 static inline void input_wakeup_procfs_readers(void) { }
1322 static inline int input_proc_init(void) { return 0; }
1323 static inline void input_proc_exit(void) { }
1324 #endif
1325
1326 #define INPUT_DEV_STRING_ATTR_SHOW(name)                                \
1327 static ssize_t input_dev_show_##name(struct device *dev,                \
1328                                      struct device_attribute *attr,     \
1329                                      char *buf)                         \
1330 {                                                                       \
1331         struct input_dev *input_dev = to_input_dev(dev);                \
1332                                                                         \
1333         return sysfs_emit(buf, "%s\n",                                  \
1334                           input_dev->name ? input_dev->name : "");      \
1335 }                                                                       \
1336 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1337
1338 INPUT_DEV_STRING_ATTR_SHOW(name);
1339 INPUT_DEV_STRING_ATTR_SHOW(phys);
1340 INPUT_DEV_STRING_ATTR_SHOW(uniq);
1341
1342 static int input_print_modalias_bits(char *buf, int size,
1343                                      char name, const unsigned long *bm,
1344                                      unsigned int min_bit, unsigned int max_bit)
1345 {
1346         int bit = min_bit;
1347         int len = 0;
1348
1349         len += snprintf(buf, max(size, 0), "%c", name);
1350         for_each_set_bit_from(bit, bm, max_bit)
1351                 len += snprintf(buf + len, max(size - len, 0), "%X,", bit);
1352         return len;
1353 }
1354
1355 static int input_print_modalias_parts(char *buf, int size, int full_len,
1356                                       const struct input_dev *id)
1357 {
1358         int len, klen, remainder, space;
1359
1360         len = snprintf(buf, max(size, 0),
1361                        "input:b%04Xv%04Xp%04Xe%04X-",
1362                        id->id.bustype, id->id.vendor,
1363                        id->id.product, id->id.version);
1364
1365         len += input_print_modalias_bits(buf + len, size - len,
1366                                 'e', id->evbit, 0, EV_MAX);
1367
1368         /*
1369          * Calculate the remaining space in the buffer making sure we
1370          * have place for the terminating 0.
1371          */
1372         space = max(size - (len + 1), 0);
1373
1374         klen = input_print_modalias_bits(buf + len, size - len,
1375                                 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1376         len += klen;
1377
1378         /*
1379          * If we have more data than we can fit in the buffer, check
1380          * if we can trim key data to fit in the rest. We will indicate
1381          * that key data is incomplete by adding "+" sign at the end, like
1382          * this: * "k1,2,3,45,+,".
1383          *
1384          * Note that we shortest key info (if present) is "k+," so we
1385          * can only try to trim if key data is longer than that.
1386          */
1387         if (full_len && size < full_len + 1 && klen > 3) {
1388                 remainder = full_len - len;
1389                 /*
1390                  * We can only trim if we have space for the remainder
1391                  * and also for at least "k+," which is 3 more characters.
1392                  */
1393                 if (remainder <= space - 3) {
1394                         /*
1395                          * We are guaranteed to have 'k' in the buffer, so
1396                          * we need at least 3 additional bytes for storing
1397                          * "+," in addition to the remainder.
1398                          */
1399                         for (int i = size - 1 - remainder - 3; i >= 0; i--) {
1400                                 if (buf[i] == 'k' || buf[i] == ',') {
1401                                         strcpy(buf + i + 1, "+,");
1402                                         len = i + 3; /* Not counting '\0' */
1403                                         break;
1404                                 }
1405                         }
1406                 }
1407         }
1408
1409         len += input_print_modalias_bits(buf + len, size - len,
1410                                 'r', id->relbit, 0, REL_MAX);
1411         len += input_print_modalias_bits(buf + len, size - len,
1412                                 'a', id->absbit, 0, ABS_MAX);
1413         len += input_print_modalias_bits(buf + len, size - len,
1414                                 'm', id->mscbit, 0, MSC_MAX);
1415         len += input_print_modalias_bits(buf + len, size - len,
1416                                 'l', id->ledbit, 0, LED_MAX);
1417         len += input_print_modalias_bits(buf + len, size - len,
1418                                 's', id->sndbit, 0, SND_MAX);
1419         len += input_print_modalias_bits(buf + len, size - len,
1420                                 'f', id->ffbit, 0, FF_MAX);
1421         len += input_print_modalias_bits(buf + len, size - len,
1422                                 'w', id->swbit, 0, SW_MAX);
1423
1424         return len;
1425 }
1426
1427 static int input_print_modalias(char *buf, int size, const struct input_dev *id)
1428 {
1429         int full_len;
1430
1431         /*
1432          * Printing is done in 2 passes: first one figures out total length
1433          * needed for the modalias string, second one will try to trim key
1434          * data in case when buffer is too small for the entire modalias.
1435          * If the buffer is too small regardless, it will fill as much as it
1436          * can (without trimming key data) into the buffer and leave it to
1437          * the caller to figure out what to do with the result.
1438          */
1439         full_len = input_print_modalias_parts(NULL, 0, 0, id);
1440         return input_print_modalias_parts(buf, size, full_len, id);
1441 }
1442
1443 static ssize_t input_dev_show_modalias(struct device *dev,
1444                                        struct device_attribute *attr,
1445                                        char *buf)
1446 {
1447         struct input_dev *id = to_input_dev(dev);
1448         ssize_t len;
1449
1450         len = input_print_modalias(buf, PAGE_SIZE, id);
1451         if (len < PAGE_SIZE - 2)
1452                 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1453
1454         return min_t(int, len, PAGE_SIZE);
1455 }
1456 static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1457
1458 static int input_print_bitmap(char *buf, int buf_size, const unsigned long *bitmap,
1459                               int max, int add_cr);
1460
1461 static ssize_t input_dev_show_properties(struct device *dev,
1462                                          struct device_attribute *attr,
1463                                          char *buf)
1464 {
1465         struct input_dev *input_dev = to_input_dev(dev);
1466         int len = input_print_bitmap(buf, PAGE_SIZE, input_dev->propbit,
1467                                      INPUT_PROP_MAX, true);
1468         return min_t(int, len, PAGE_SIZE);
1469 }
1470 static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL);
1471
1472 static int input_inhibit_device(struct input_dev *dev);
1473 static int input_uninhibit_device(struct input_dev *dev);
1474
1475 static ssize_t inhibited_show(struct device *dev,
1476                               struct device_attribute *attr,
1477                               char *buf)
1478 {
1479         struct input_dev *input_dev = to_input_dev(dev);
1480
1481         return sysfs_emit(buf, "%d\n", input_dev->inhibited);
1482 }
1483
1484 static ssize_t inhibited_store(struct device *dev,
1485                                struct device_attribute *attr, const char *buf,
1486                                size_t len)
1487 {
1488         struct input_dev *input_dev = to_input_dev(dev);
1489         ssize_t rv;
1490         bool inhibited;
1491
1492         if (kstrtobool(buf, &inhibited))
1493                 return -EINVAL;
1494
1495         if (inhibited)
1496                 rv = input_inhibit_device(input_dev);
1497         else
1498                 rv = input_uninhibit_device(input_dev);
1499
1500         if (rv != 0)
1501                 return rv;
1502
1503         return len;
1504 }
1505
1506 static DEVICE_ATTR_RW(inhibited);
1507
1508 static struct attribute *input_dev_attrs[] = {
1509         &dev_attr_name.attr,
1510         &dev_attr_phys.attr,
1511         &dev_attr_uniq.attr,
1512         &dev_attr_modalias.attr,
1513         &dev_attr_properties.attr,
1514         &dev_attr_inhibited.attr,
1515         NULL
1516 };
1517
1518 static const struct attribute_group input_dev_attr_group = {
1519         .attrs  = input_dev_attrs,
1520 };
1521
1522 #define INPUT_DEV_ID_ATTR(name)                                         \
1523 static ssize_t input_dev_show_id_##name(struct device *dev,             \
1524                                         struct device_attribute *attr,  \
1525                                         char *buf)                      \
1526 {                                                                       \
1527         struct input_dev *input_dev = to_input_dev(dev);                \
1528         return sysfs_emit(buf, "%04x\n", input_dev->id.name);           \
1529 }                                                                       \
1530 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1531
1532 INPUT_DEV_ID_ATTR(bustype);
1533 INPUT_DEV_ID_ATTR(vendor);
1534 INPUT_DEV_ID_ATTR(product);
1535 INPUT_DEV_ID_ATTR(version);
1536
1537 static struct attribute *input_dev_id_attrs[] = {
1538         &dev_attr_bustype.attr,
1539         &dev_attr_vendor.attr,
1540         &dev_attr_product.attr,
1541         &dev_attr_version.attr,
1542         NULL
1543 };
1544
1545 static const struct attribute_group input_dev_id_attr_group = {
1546         .name   = "id",
1547         .attrs  = input_dev_id_attrs,
1548 };
1549
1550 static int input_print_bitmap(char *buf, int buf_size, const unsigned long *bitmap,
1551                               int max, int add_cr)
1552 {
1553         int i;
1554         int len = 0;
1555         bool skip_empty = true;
1556
1557         for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1558                 len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1559                                             bitmap[i], skip_empty);
1560                 if (len) {
1561                         skip_empty = false;
1562                         if (i > 0)
1563                                 len += snprintf(buf + len, max(buf_size - len, 0), " ");
1564                 }
1565         }
1566
1567         /*
1568          * If no output was produced print a single 0.
1569          */
1570         if (len == 0)
1571                 len = snprintf(buf, buf_size, "%d", 0);
1572
1573         if (add_cr)
1574                 len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1575
1576         return len;
1577 }
1578
1579 #define INPUT_DEV_CAP_ATTR(ev, bm)                                      \
1580 static ssize_t input_dev_show_cap_##bm(struct device *dev,              \
1581                                        struct device_attribute *attr,   \
1582                                        char *buf)                       \
1583 {                                                                       \
1584         struct input_dev *input_dev = to_input_dev(dev);                \
1585         int len = input_print_bitmap(buf, PAGE_SIZE,                    \
1586                                      input_dev->bm##bit, ev##_MAX,      \
1587                                      true);                             \
1588         return min_t(int, len, PAGE_SIZE);                              \
1589 }                                                                       \
1590 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1591
1592 INPUT_DEV_CAP_ATTR(EV, ev);
1593 INPUT_DEV_CAP_ATTR(KEY, key);
1594 INPUT_DEV_CAP_ATTR(REL, rel);
1595 INPUT_DEV_CAP_ATTR(ABS, abs);
1596 INPUT_DEV_CAP_ATTR(MSC, msc);
1597 INPUT_DEV_CAP_ATTR(LED, led);
1598 INPUT_DEV_CAP_ATTR(SND, snd);
1599 INPUT_DEV_CAP_ATTR(FF, ff);
1600 INPUT_DEV_CAP_ATTR(SW, sw);
1601
1602 static struct attribute *input_dev_caps_attrs[] = {
1603         &dev_attr_ev.attr,
1604         &dev_attr_key.attr,
1605         &dev_attr_rel.attr,
1606         &dev_attr_abs.attr,
1607         &dev_attr_msc.attr,
1608         &dev_attr_led.attr,
1609         &dev_attr_snd.attr,
1610         &dev_attr_ff.attr,
1611         &dev_attr_sw.attr,
1612         NULL
1613 };
1614
1615 static const struct attribute_group input_dev_caps_attr_group = {
1616         .name   = "capabilities",
1617         .attrs  = input_dev_caps_attrs,
1618 };
1619
1620 static const struct attribute_group *input_dev_attr_groups[] = {
1621         &input_dev_attr_group,
1622         &input_dev_id_attr_group,
1623         &input_dev_caps_attr_group,
1624         &input_poller_attribute_group,
1625         NULL
1626 };
1627
1628 static void input_dev_release(struct device *device)
1629 {
1630         struct input_dev *dev = to_input_dev(device);
1631
1632         input_ff_destroy(dev);
1633         input_mt_destroy_slots(dev);
1634         kfree(dev->poller);
1635         kfree(dev->absinfo);
1636         kfree(dev->vals);
1637         kfree(dev);
1638
1639         module_put(THIS_MODULE);
1640 }
1641
1642 /*
1643  * Input uevent interface - loading event handlers based on
1644  * device bitfields.
1645  */
1646 static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1647                                    const char *name, const unsigned long *bitmap, int max)
1648 {
1649         int len;
1650
1651         if (add_uevent_var(env, "%s", name))
1652                 return -ENOMEM;
1653
1654         len = input_print_bitmap(&env->buf[env->buflen - 1],
1655                                  sizeof(env->buf) - env->buflen,
1656                                  bitmap, max, false);
1657         if (len >= (sizeof(env->buf) - env->buflen))
1658                 return -ENOMEM;
1659
1660         env->buflen += len;
1661         return 0;
1662 }
1663
1664 /*
1665  * This is a pretty gross hack. When building uevent data the driver core
1666  * may try adding more environment variables to kobj_uevent_env without
1667  * telling us, so we have no idea how much of the buffer we can use to
1668  * avoid overflows/-ENOMEM elsewhere. To work around this let's artificially
1669  * reduce amount of memory we will use for the modalias environment variable.
1670  *
1671  * The potential additions are:
1672  *
1673  * SEQNUM=18446744073709551615 - (%llu - 28 bytes)
1674  * HOME=/ (6 bytes)
1675  * PATH=/sbin:/bin:/usr/sbin:/usr/bin (34 bytes)
1676  *
1677  * 68 bytes total. Allow extra buffer - 96 bytes
1678  */
1679 #define UEVENT_ENV_EXTRA_LEN    96
1680
1681 static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1682                                          const struct input_dev *dev)
1683 {
1684         int len;
1685
1686         if (add_uevent_var(env, "MODALIAS="))
1687                 return -ENOMEM;
1688
1689         len = input_print_modalias(&env->buf[env->buflen - 1],
1690                                    (int)sizeof(env->buf) - env->buflen -
1691                                         UEVENT_ENV_EXTRA_LEN,
1692                                    dev);
1693         if (len >= ((int)sizeof(env->buf) - env->buflen -
1694                                         UEVENT_ENV_EXTRA_LEN))
1695                 return -ENOMEM;
1696
1697         env->buflen += len;
1698         return 0;
1699 }
1700
1701 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...)                              \
1702         do {                                                            \
1703                 int err = add_uevent_var(env, fmt, val);                \
1704                 if (err)                                                \
1705                         return err;                                     \
1706         } while (0)
1707
1708 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)                         \
1709         do {                                                            \
1710                 int err = input_add_uevent_bm_var(env, name, bm, max);  \
1711                 if (err)                                                \
1712                         return err;                                     \
1713         } while (0)
1714
1715 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)                             \
1716         do {                                                            \
1717                 int err = input_add_uevent_modalias_var(env, dev);      \
1718                 if (err)                                                \
1719                         return err;                                     \
1720         } while (0)
1721
1722 static int input_dev_uevent(const struct device *device, struct kobj_uevent_env *env)
1723 {
1724         const struct input_dev *dev = to_input_dev(device);
1725
1726         INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1727                                 dev->id.bustype, dev->id.vendor,
1728                                 dev->id.product, dev->id.version);
1729         if (dev->name)
1730                 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1731         if (dev->phys)
1732                 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1733         if (dev->uniq)
1734                 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1735
1736         INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
1737
1738         INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1739         if (test_bit(EV_KEY, dev->evbit))
1740                 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1741         if (test_bit(EV_REL, dev->evbit))
1742                 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1743         if (test_bit(EV_ABS, dev->evbit))
1744                 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1745         if (test_bit(EV_MSC, dev->evbit))
1746                 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1747         if (test_bit(EV_LED, dev->evbit))
1748                 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1749         if (test_bit(EV_SND, dev->evbit))
1750                 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1751         if (test_bit(EV_FF, dev->evbit))
1752                 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1753         if (test_bit(EV_SW, dev->evbit))
1754                 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1755
1756         INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1757
1758         return 0;
1759 }
1760
1761 #define INPUT_DO_TOGGLE(dev, type, bits, on)                            \
1762         do {                                                            \
1763                 int i;                                                  \
1764                 bool active;                                            \
1765                                                                         \
1766                 if (!test_bit(EV_##type, dev->evbit))                   \
1767                         break;                                          \
1768                                                                         \
1769                 for_each_set_bit(i, dev->bits##bit, type##_CNT) {       \
1770                         active = test_bit(i, dev->bits);                \
1771                         if (!active && !on)                             \
1772                                 continue;                               \
1773                                                                         \
1774                         dev->event(dev, EV_##type, i, on ? active : 0); \
1775                 }                                                       \
1776         } while (0)
1777
1778 static void input_dev_toggle(struct input_dev *dev, bool activate)
1779 {
1780         if (!dev->event)
1781                 return;
1782
1783         INPUT_DO_TOGGLE(dev, LED, led, activate);
1784         INPUT_DO_TOGGLE(dev, SND, snd, activate);
1785
1786         if (activate && test_bit(EV_REP, dev->evbit)) {
1787                 dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1788                 dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1789         }
1790 }
1791
1792 /**
1793  * input_reset_device() - reset/restore the state of input device
1794  * @dev: input device whose state needs to be reset
1795  *
1796  * This function tries to reset the state of an opened input device and
1797  * bring internal state and state if the hardware in sync with each other.
1798  * We mark all keys as released, restore LED state, repeat rate, etc.
1799  */
1800 void input_reset_device(struct input_dev *dev)
1801 {
1802         unsigned long flags;
1803
1804         mutex_lock(&dev->mutex);
1805         spin_lock_irqsave(&dev->event_lock, flags);
1806
1807         input_dev_toggle(dev, true);
1808         if (input_dev_release_keys(dev))
1809                 input_handle_event(dev, EV_SYN, SYN_REPORT, 1);
1810
1811         spin_unlock_irqrestore(&dev->event_lock, flags);
1812         mutex_unlock(&dev->mutex);
1813 }
1814 EXPORT_SYMBOL(input_reset_device);
1815
1816 static int input_inhibit_device(struct input_dev *dev)
1817 {
1818         mutex_lock(&dev->mutex);
1819
1820         if (dev->inhibited)
1821                 goto out;
1822
1823         if (dev->users) {
1824                 if (dev->close)
1825                         dev->close(dev);
1826                 if (dev->poller)
1827                         input_dev_poller_stop(dev->poller);
1828         }
1829
1830         spin_lock_irq(&dev->event_lock);
1831         input_mt_release_slots(dev);
1832         input_dev_release_keys(dev);
1833         input_handle_event(dev, EV_SYN, SYN_REPORT, 1);
1834         input_dev_toggle(dev, false);
1835         spin_unlock_irq(&dev->event_lock);
1836
1837         dev->inhibited = true;
1838
1839 out:
1840         mutex_unlock(&dev->mutex);
1841         return 0;
1842 }
1843
1844 static int input_uninhibit_device(struct input_dev *dev)
1845 {
1846         int ret = 0;
1847
1848         mutex_lock(&dev->mutex);
1849
1850         if (!dev->inhibited)
1851                 goto out;
1852
1853         if (dev->users) {
1854                 if (dev->open) {
1855                         ret = dev->open(dev);
1856                         if (ret)
1857                                 goto out;
1858                 }
1859                 if (dev->poller)
1860                         input_dev_poller_start(dev->poller);
1861         }
1862
1863         dev->inhibited = false;
1864         spin_lock_irq(&dev->event_lock);
1865         input_dev_toggle(dev, true);
1866         spin_unlock_irq(&dev->event_lock);
1867
1868 out:
1869         mutex_unlock(&dev->mutex);
1870         return ret;
1871 }
1872
1873 static int input_dev_suspend(struct device *dev)
1874 {
1875         struct input_dev *input_dev = to_input_dev(dev);
1876
1877         spin_lock_irq(&input_dev->event_lock);
1878
1879         /*
1880          * Keys that are pressed now are unlikely to be
1881          * still pressed when we resume.
1882          */
1883         if (input_dev_release_keys(input_dev))
1884                 input_handle_event(input_dev, EV_SYN, SYN_REPORT, 1);
1885
1886         /* Turn off LEDs and sounds, if any are active. */
1887         input_dev_toggle(input_dev, false);
1888
1889         spin_unlock_irq(&input_dev->event_lock);
1890
1891         return 0;
1892 }
1893
1894 static int input_dev_resume(struct device *dev)
1895 {
1896         struct input_dev *input_dev = to_input_dev(dev);
1897
1898         spin_lock_irq(&input_dev->event_lock);
1899
1900         /* Restore state of LEDs and sounds, if any were active. */
1901         input_dev_toggle(input_dev, true);
1902
1903         spin_unlock_irq(&input_dev->event_lock);
1904
1905         return 0;
1906 }
1907
1908 static int input_dev_freeze(struct device *dev)
1909 {
1910         struct input_dev *input_dev = to_input_dev(dev);
1911
1912         spin_lock_irq(&input_dev->event_lock);
1913
1914         /*
1915          * Keys that are pressed now are unlikely to be
1916          * still pressed when we resume.
1917          */
1918         if (input_dev_release_keys(input_dev))
1919                 input_handle_event(input_dev, EV_SYN, SYN_REPORT, 1);
1920
1921         spin_unlock_irq(&input_dev->event_lock);
1922
1923         return 0;
1924 }
1925
1926 static int input_dev_poweroff(struct device *dev)
1927 {
1928         struct input_dev *input_dev = to_input_dev(dev);
1929
1930         spin_lock_irq(&input_dev->event_lock);
1931
1932         /* Turn off LEDs and sounds, if any are active. */
1933         input_dev_toggle(input_dev, false);
1934
1935         spin_unlock_irq(&input_dev->event_lock);
1936
1937         return 0;
1938 }
1939
1940 static const struct dev_pm_ops input_dev_pm_ops = {
1941         .suspend        = input_dev_suspend,
1942         .resume         = input_dev_resume,
1943         .freeze         = input_dev_freeze,
1944         .poweroff       = input_dev_poweroff,
1945         .restore        = input_dev_resume,
1946 };
1947
1948 static const struct device_type input_dev_type = {
1949         .groups         = input_dev_attr_groups,
1950         .release        = input_dev_release,
1951         .uevent         = input_dev_uevent,
1952         .pm             = pm_sleep_ptr(&input_dev_pm_ops),
1953 };
1954
1955 static char *input_devnode(const struct device *dev, umode_t *mode)
1956 {
1957         return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1958 }
1959
1960 const struct class input_class = {
1961         .name           = "input",
1962         .devnode        = input_devnode,
1963 };
1964 EXPORT_SYMBOL_GPL(input_class);
1965
1966 /**
1967  * input_allocate_device - allocate memory for new input device
1968  *
1969  * Returns prepared struct input_dev or %NULL.
1970  *
1971  * NOTE: Use input_free_device() to free devices that have not been
1972  * registered; input_unregister_device() should be used for already
1973  * registered devices.
1974  */
1975 struct input_dev *input_allocate_device(void)
1976 {
1977         static atomic_t input_no = ATOMIC_INIT(-1);
1978         struct input_dev *dev;
1979
1980         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1981         if (!dev)
1982                 return NULL;
1983
1984         /*
1985          * Start with space for SYN_REPORT + 7 EV_KEY/EV_MSC events + 2 spare,
1986          * see input_estimate_events_per_packet(). We will tune the number
1987          * when we register the device.
1988          */
1989         dev->max_vals = 10;
1990         dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
1991         if (!dev->vals) {
1992                 kfree(dev);
1993                 return NULL;
1994         }
1995
1996         mutex_init(&dev->mutex);
1997         spin_lock_init(&dev->event_lock);
1998         timer_setup(&dev->timer, NULL, 0);
1999         INIT_LIST_HEAD(&dev->h_list);
2000         INIT_LIST_HEAD(&dev->node);
2001
2002         dev->dev.type = &input_dev_type;
2003         dev->dev.class = &input_class;
2004         device_initialize(&dev->dev);
2005         /*
2006          * From this point on we can no longer simply "kfree(dev)", we need
2007          * to use input_free_device() so that device core properly frees its
2008          * resources associated with the input device.
2009          */
2010
2011         dev_set_name(&dev->dev, "input%lu",
2012                      (unsigned long)atomic_inc_return(&input_no));
2013
2014         __module_get(THIS_MODULE);
2015
2016         return dev;
2017 }
2018 EXPORT_SYMBOL(input_allocate_device);
2019
2020 struct input_devres {
2021         struct input_dev *input;
2022 };
2023
2024 static int devm_input_device_match(struct device *dev, void *res, void *data)
2025 {
2026         struct input_devres *devres = res;
2027
2028         return devres->input == data;
2029 }
2030
2031 static void devm_input_device_release(struct device *dev, void *res)
2032 {
2033         struct input_devres *devres = res;
2034         struct input_dev *input = devres->input;
2035
2036         dev_dbg(dev, "%s: dropping reference to %s\n",
2037                 __func__, dev_name(&input->dev));
2038         input_put_device(input);
2039 }
2040
2041 /**
2042  * devm_input_allocate_device - allocate managed input device
2043  * @dev: device owning the input device being created
2044  *
2045  * Returns prepared struct input_dev or %NULL.
2046  *
2047  * Managed input devices do not need to be explicitly unregistered or
2048  * freed as it will be done automatically when owner device unbinds from
2049  * its driver (or binding fails). Once managed input device is allocated,
2050  * it is ready to be set up and registered in the same fashion as regular
2051  * input device. There are no special devm_input_device_[un]register()
2052  * variants, regular ones work with both managed and unmanaged devices,
2053  * should you need them. In most cases however, managed input device need
2054  * not be explicitly unregistered or freed.
2055  *
2056  * NOTE: the owner device is set up as parent of input device and users
2057  * should not override it.
2058  */
2059 struct input_dev *devm_input_allocate_device(struct device *dev)
2060 {
2061         struct input_dev *input;
2062         struct input_devres *devres;
2063
2064         devres = devres_alloc(devm_input_device_release,
2065                               sizeof(*devres), GFP_KERNEL);
2066         if (!devres)
2067                 return NULL;
2068
2069         input = input_allocate_device();
2070         if (!input) {
2071                 devres_free(devres);
2072                 return NULL;
2073         }
2074
2075         input->dev.parent = dev;
2076         input->devres_managed = true;
2077
2078         devres->input = input;
2079         devres_add(dev, devres);
2080
2081         return input;
2082 }
2083 EXPORT_SYMBOL(devm_input_allocate_device);
2084
2085 /**
2086  * input_free_device - free memory occupied by input_dev structure
2087  * @dev: input device to free
2088  *
2089  * This function should only be used if input_register_device()
2090  * was not called yet or if it failed. Once device was registered
2091  * use input_unregister_device() and memory will be freed once last
2092  * reference to the device is dropped.
2093  *
2094  * Device should be allocated by input_allocate_device().
2095  *
2096  * NOTE: If there are references to the input device then memory
2097  * will not be freed until last reference is dropped.
2098  */
2099 void input_free_device(struct input_dev *dev)
2100 {
2101         if (dev) {
2102                 if (dev->devres_managed)
2103                         WARN_ON(devres_destroy(dev->dev.parent,
2104                                                 devm_input_device_release,
2105                                                 devm_input_device_match,
2106                                                 dev));
2107                 input_put_device(dev);
2108         }
2109 }
2110 EXPORT_SYMBOL(input_free_device);
2111
2112 /**
2113  * input_set_timestamp - set timestamp for input events
2114  * @dev: input device to set timestamp for
2115  * @timestamp: the time at which the event has occurred
2116  *   in CLOCK_MONOTONIC
2117  *
2118  * This function is intended to provide to the input system a more
2119  * accurate time of when an event actually occurred. The driver should
2120  * call this function as soon as a timestamp is acquired ensuring
2121  * clock conversions in input_set_timestamp are done correctly.
2122  *
2123  * The system entering suspend state between timestamp acquisition and
2124  * calling input_set_timestamp can result in inaccurate conversions.
2125  */
2126 void input_set_timestamp(struct input_dev *dev, ktime_t timestamp)
2127 {
2128         dev->timestamp[INPUT_CLK_MONO] = timestamp;
2129         dev->timestamp[INPUT_CLK_REAL] = ktime_mono_to_real(timestamp);
2130         dev->timestamp[INPUT_CLK_BOOT] = ktime_mono_to_any(timestamp,
2131                                                            TK_OFFS_BOOT);
2132 }
2133 EXPORT_SYMBOL(input_set_timestamp);
2134
2135 /**
2136  * input_get_timestamp - get timestamp for input events
2137  * @dev: input device to get timestamp from
2138  *
2139  * A valid timestamp is a timestamp of non-zero value.
2140  */
2141 ktime_t *input_get_timestamp(struct input_dev *dev)
2142 {
2143         const ktime_t invalid_timestamp = ktime_set(0, 0);
2144
2145         if (!ktime_compare(dev->timestamp[INPUT_CLK_MONO], invalid_timestamp))
2146                 input_set_timestamp(dev, ktime_get());
2147
2148         return dev->timestamp;
2149 }
2150 EXPORT_SYMBOL(input_get_timestamp);
2151
2152 /**
2153  * input_set_capability - mark device as capable of a certain event
2154  * @dev: device that is capable of emitting or accepting event
2155  * @type: type of the event (EV_KEY, EV_REL, etc...)
2156  * @code: event code
2157  *
2158  * In addition to setting up corresponding bit in appropriate capability
2159  * bitmap the function also adjusts dev->evbit.
2160  */
2161 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
2162 {
2163         if (type < EV_CNT && input_max_code[type] &&
2164             code > input_max_code[type]) {
2165                 pr_err("%s: invalid code %u for type %u\n", __func__, code,
2166                        type);
2167                 dump_stack();
2168                 return;
2169         }
2170
2171         switch (type) {
2172         case EV_KEY:
2173                 __set_bit(code, dev->keybit);
2174                 break;
2175
2176         case EV_REL:
2177                 __set_bit(code, dev->relbit);
2178                 break;
2179
2180         case EV_ABS:
2181                 input_alloc_absinfo(dev);
2182                 __set_bit(code, dev->absbit);
2183                 break;
2184
2185         case EV_MSC:
2186                 __set_bit(code, dev->mscbit);
2187                 break;
2188
2189         case EV_SW:
2190                 __set_bit(code, dev->swbit);
2191                 break;
2192
2193         case EV_LED:
2194                 __set_bit(code, dev->ledbit);
2195                 break;
2196
2197         case EV_SND:
2198                 __set_bit(code, dev->sndbit);
2199                 break;
2200
2201         case EV_FF:
2202                 __set_bit(code, dev->ffbit);
2203                 break;
2204
2205         case EV_PWR:
2206                 /* do nothing */
2207                 break;
2208
2209         default:
2210                 pr_err("%s: unknown type %u (code %u)\n", __func__, type, code);
2211                 dump_stack();
2212                 return;
2213         }
2214
2215         __set_bit(type, dev->evbit);
2216 }
2217 EXPORT_SYMBOL(input_set_capability);
2218
2219 static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
2220 {
2221         int mt_slots;
2222         int i;
2223         unsigned int events;
2224
2225         if (dev->mt) {
2226                 mt_slots = dev->mt->num_slots;
2227         } else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
2228                 mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
2229                            dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1;
2230                 mt_slots = clamp(mt_slots, 2, 32);
2231         } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
2232                 mt_slots = 2;
2233         } else {
2234                 mt_slots = 0;
2235         }
2236
2237         events = mt_slots + 1; /* count SYN_MT_REPORT and SYN_REPORT */
2238
2239         if (test_bit(EV_ABS, dev->evbit))
2240                 for_each_set_bit(i, dev->absbit, ABS_CNT)
2241                         events += input_is_mt_axis(i) ? mt_slots : 1;
2242
2243         if (test_bit(EV_REL, dev->evbit))
2244                 events += bitmap_weight(dev->relbit, REL_CNT);
2245
2246         /* Make room for KEY and MSC events */
2247         events += 7;
2248
2249         return events;
2250 }
2251
2252 #define INPUT_CLEANSE_BITMASK(dev, type, bits)                          \
2253         do {                                                            \
2254                 if (!test_bit(EV_##type, dev->evbit))                   \
2255                         memset(dev->bits##bit, 0,                       \
2256                                 sizeof(dev->bits##bit));                \
2257         } while (0)
2258
2259 static void input_cleanse_bitmasks(struct input_dev *dev)
2260 {
2261         INPUT_CLEANSE_BITMASK(dev, KEY, key);
2262         INPUT_CLEANSE_BITMASK(dev, REL, rel);
2263         INPUT_CLEANSE_BITMASK(dev, ABS, abs);
2264         INPUT_CLEANSE_BITMASK(dev, MSC, msc);
2265         INPUT_CLEANSE_BITMASK(dev, LED, led);
2266         INPUT_CLEANSE_BITMASK(dev, SND, snd);
2267         INPUT_CLEANSE_BITMASK(dev, FF, ff);
2268         INPUT_CLEANSE_BITMASK(dev, SW, sw);
2269 }
2270
2271 static void __input_unregister_device(struct input_dev *dev)
2272 {
2273         struct input_handle *handle, *next;
2274
2275         input_disconnect_device(dev);
2276
2277         mutex_lock(&input_mutex);
2278
2279         list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
2280                 handle->handler->disconnect(handle);
2281         WARN_ON(!list_empty(&dev->h_list));
2282
2283         del_timer_sync(&dev->timer);
2284         list_del_init(&dev->node);
2285
2286         input_wakeup_procfs_readers();
2287
2288         mutex_unlock(&input_mutex);
2289
2290         device_del(&dev->dev);
2291 }
2292
2293 static void devm_input_device_unregister(struct device *dev, void *res)
2294 {
2295         struct input_devres *devres = res;
2296         struct input_dev *input = devres->input;
2297
2298         dev_dbg(dev, "%s: unregistering device %s\n",
2299                 __func__, dev_name(&input->dev));
2300         __input_unregister_device(input);
2301 }
2302
2303 /*
2304  * Generate software autorepeat event. Note that we take
2305  * dev->event_lock here to avoid racing with input_event
2306  * which may cause keys get "stuck".
2307  */
2308 static void input_repeat_key(struct timer_list *t)
2309 {
2310         struct input_dev *dev = from_timer(dev, t, timer);
2311         unsigned long flags;
2312
2313         spin_lock_irqsave(&dev->event_lock, flags);
2314
2315         if (!dev->inhibited &&
2316             test_bit(dev->repeat_key, dev->key) &&
2317             is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
2318
2319                 input_set_timestamp(dev, ktime_get());
2320                 input_handle_event(dev, EV_KEY, dev->repeat_key, 2);
2321                 input_handle_event(dev, EV_SYN, SYN_REPORT, 1);
2322
2323                 if (dev->rep[REP_PERIOD])
2324                         mod_timer(&dev->timer, jiffies +
2325                                         msecs_to_jiffies(dev->rep[REP_PERIOD]));
2326         }
2327
2328         spin_unlock_irqrestore(&dev->event_lock, flags);
2329 }
2330
2331 /**
2332  * input_enable_softrepeat - enable software autorepeat
2333  * @dev: input device
2334  * @delay: repeat delay
2335  * @period: repeat period
2336  *
2337  * Enable software autorepeat on the input device.
2338  */
2339 void input_enable_softrepeat(struct input_dev *dev, int delay, int period)
2340 {
2341         dev->timer.function = input_repeat_key;
2342         dev->rep[REP_DELAY] = delay;
2343         dev->rep[REP_PERIOD] = period;
2344 }
2345 EXPORT_SYMBOL(input_enable_softrepeat);
2346
2347 bool input_device_enabled(struct input_dev *dev)
2348 {
2349         lockdep_assert_held(&dev->mutex);
2350
2351         return !dev->inhibited && dev->users > 0;
2352 }
2353 EXPORT_SYMBOL_GPL(input_device_enabled);
2354
2355 static int input_device_tune_vals(struct input_dev *dev)
2356 {
2357         struct input_value *vals;
2358         unsigned int packet_size;
2359         unsigned int max_vals;
2360
2361         packet_size = input_estimate_events_per_packet(dev);
2362         if (dev->hint_events_per_packet < packet_size)
2363                 dev->hint_events_per_packet = packet_size;
2364
2365         max_vals = dev->hint_events_per_packet + 2;
2366         if (dev->max_vals >= max_vals)
2367                 return 0;
2368
2369         vals = kcalloc(max_vals, sizeof(*vals), GFP_KERNEL);
2370         if (!vals)
2371                 return -ENOMEM;
2372
2373         spin_lock_irq(&dev->event_lock);
2374         dev->max_vals = max_vals;
2375         swap(dev->vals, vals);
2376         spin_unlock_irq(&dev->event_lock);
2377
2378         /* Because of swap() above, this frees the old vals memory */
2379         kfree(vals);
2380
2381         return 0;
2382 }
2383
2384 /**
2385  * input_register_device - register device with input core
2386  * @dev: device to be registered
2387  *
2388  * This function registers device with input core. The device must be
2389  * allocated with input_allocate_device() and all it's capabilities
2390  * set up before registering.
2391  * If function fails the device must be freed with input_free_device().
2392  * Once device has been successfully registered it can be unregistered
2393  * with input_unregister_device(); input_free_device() should not be
2394  * called in this case.
2395  *
2396  * Note that this function is also used to register managed input devices
2397  * (ones allocated with devm_input_allocate_device()). Such managed input
2398  * devices need not be explicitly unregistered or freed, their tear down
2399  * is controlled by the devres infrastructure. It is also worth noting
2400  * that tear down of managed input devices is internally a 2-step process:
2401  * registered managed input device is first unregistered, but stays in
2402  * memory and can still handle input_event() calls (although events will
2403  * not be delivered anywhere). The freeing of managed input device will
2404  * happen later, when devres stack is unwound to the point where device
2405  * allocation was made.
2406  */
2407 int input_register_device(struct input_dev *dev)
2408 {
2409         struct input_devres *devres = NULL;
2410         struct input_handler *handler;
2411         const char *path;
2412         int error;
2413
2414         if (test_bit(EV_ABS, dev->evbit) && !dev->absinfo) {
2415                 dev_err(&dev->dev,
2416                         "Absolute device without dev->absinfo, refusing to register\n");
2417                 return -EINVAL;
2418         }
2419
2420         if (dev->devres_managed) {
2421                 devres = devres_alloc(devm_input_device_unregister,
2422                                       sizeof(*devres), GFP_KERNEL);
2423                 if (!devres)
2424                         return -ENOMEM;
2425
2426                 devres->input = dev;
2427         }
2428
2429         /* Every input device generates EV_SYN/SYN_REPORT events. */
2430         __set_bit(EV_SYN, dev->evbit);
2431
2432         /* KEY_RESERVED is not supposed to be transmitted to userspace. */
2433         __clear_bit(KEY_RESERVED, dev->keybit);
2434
2435         /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2436         input_cleanse_bitmasks(dev);
2437
2438         error = input_device_tune_vals(dev);
2439         if (error)
2440                 goto err_devres_free;
2441
2442         /*
2443          * If delay and period are pre-set by the driver, then autorepeating
2444          * is handled by the driver itself and we don't do it in input.c.
2445          */
2446         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
2447                 input_enable_softrepeat(dev, 250, 33);
2448
2449         if (!dev->getkeycode)
2450                 dev->getkeycode = input_default_getkeycode;
2451
2452         if (!dev->setkeycode)
2453                 dev->setkeycode = input_default_setkeycode;
2454
2455         if (dev->poller)
2456                 input_dev_poller_finalize(dev->poller);
2457
2458         error = device_add(&dev->dev);
2459         if (error)
2460                 goto err_devres_free;
2461
2462         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
2463         pr_info("%s as %s\n",
2464                 dev->name ? dev->name : "Unspecified device",
2465                 path ? path : "N/A");
2466         kfree(path);
2467
2468         error = mutex_lock_interruptible(&input_mutex);
2469         if (error)
2470                 goto err_device_del;
2471
2472         list_add_tail(&dev->node, &input_dev_list);
2473
2474         list_for_each_entry(handler, &input_handler_list, node)
2475                 input_attach_handler(dev, handler);
2476
2477         input_wakeup_procfs_readers();
2478
2479         mutex_unlock(&input_mutex);
2480
2481         if (dev->devres_managed) {
2482                 dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
2483                         __func__, dev_name(&dev->dev));
2484                 devres_add(dev->dev.parent, devres);
2485         }
2486         return 0;
2487
2488 err_device_del:
2489         device_del(&dev->dev);
2490 err_devres_free:
2491         devres_free(devres);
2492         return error;
2493 }
2494 EXPORT_SYMBOL(input_register_device);
2495
2496 /**
2497  * input_unregister_device - unregister previously registered device
2498  * @dev: device to be unregistered
2499  *
2500  * This function unregisters an input device. Once device is unregistered
2501  * the caller should not try to access it as it may get freed at any moment.
2502  */
2503 void input_unregister_device(struct input_dev *dev)
2504 {
2505         if (dev->devres_managed) {
2506                 WARN_ON(devres_destroy(dev->dev.parent,
2507                                         devm_input_device_unregister,
2508                                         devm_input_device_match,
2509                                         dev));
2510                 __input_unregister_device(dev);
2511                 /*
2512                  * We do not do input_put_device() here because it will be done
2513                  * when 2nd devres fires up.
2514                  */
2515         } else {
2516                 __input_unregister_device(dev);
2517                 input_put_device(dev);
2518         }
2519 }
2520 EXPORT_SYMBOL(input_unregister_device);
2521
2522 static int input_handler_check_methods(const struct input_handler *handler)
2523 {
2524         int count = 0;
2525
2526         if (handler->filter)
2527                 count++;
2528         if (handler->events)
2529                 count++;
2530         if (handler->event)
2531                 count++;
2532
2533         if (count > 1) {
2534                 pr_err("%s: only one event processing method can be defined (%s)\n",
2535                        __func__, handler->name);
2536                 return -EINVAL;
2537         }
2538
2539         return 0;
2540 }
2541
2542 /**
2543  * input_register_handler - register a new input handler
2544  * @handler: handler to be registered
2545  *
2546  * This function registers a new input handler (interface) for input
2547  * devices in the system and attaches it to all input devices that
2548  * are compatible with the handler.
2549  */
2550 int input_register_handler(struct input_handler *handler)
2551 {
2552         struct input_dev *dev;
2553         int error;
2554
2555         error = input_handler_check_methods(handler);
2556         if (error)
2557                 return error;
2558
2559         INIT_LIST_HEAD(&handler->h_list);
2560
2561         error = mutex_lock_interruptible(&input_mutex);
2562         if (error)
2563                 return error;
2564
2565         list_add_tail(&handler->node, &input_handler_list);
2566
2567         list_for_each_entry(dev, &input_dev_list, node)
2568                 input_attach_handler(dev, handler);
2569
2570         input_wakeup_procfs_readers();
2571
2572         mutex_unlock(&input_mutex);
2573         return 0;
2574 }
2575 EXPORT_SYMBOL(input_register_handler);
2576
2577 /**
2578  * input_unregister_handler - unregisters an input handler
2579  * @handler: handler to be unregistered
2580  *
2581  * This function disconnects a handler from its input devices and
2582  * removes it from lists of known handlers.
2583  */
2584 void input_unregister_handler(struct input_handler *handler)
2585 {
2586         struct input_handle *handle, *next;
2587
2588         mutex_lock(&input_mutex);
2589
2590         list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
2591                 handler->disconnect(handle);
2592         WARN_ON(!list_empty(&handler->h_list));
2593
2594         list_del_init(&handler->node);
2595
2596         input_wakeup_procfs_readers();
2597
2598         mutex_unlock(&input_mutex);
2599 }
2600 EXPORT_SYMBOL(input_unregister_handler);
2601
2602 /**
2603  * input_handler_for_each_handle - handle iterator
2604  * @handler: input handler to iterate
2605  * @data: data for the callback
2606  * @fn: function to be called for each handle
2607  *
2608  * Iterate over @bus's list of devices, and call @fn for each, passing
2609  * it @data and stop when @fn returns a non-zero value. The function is
2610  * using RCU to traverse the list and therefore may be using in atomic
2611  * contexts. The @fn callback is invoked from RCU critical section and
2612  * thus must not sleep.
2613  */
2614 int input_handler_for_each_handle(struct input_handler *handler, void *data,
2615                                   int (*fn)(struct input_handle *, void *))
2616 {
2617         struct input_handle *handle;
2618         int retval = 0;
2619
2620         rcu_read_lock();
2621
2622         list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2623                 retval = fn(handle, data);
2624                 if (retval)
2625                         break;
2626         }
2627
2628         rcu_read_unlock();
2629
2630         return retval;
2631 }
2632 EXPORT_SYMBOL(input_handler_for_each_handle);
2633
2634 /*
2635  * An implementation of input_handle's handle_events() method that simply
2636  * invokes handler->event() method for each event one by one.
2637  */
2638 static unsigned int input_handle_events_default(struct input_handle *handle,
2639                                                 struct input_value *vals,
2640                                                 unsigned int count)
2641 {
2642         struct input_handler *handler = handle->handler;
2643         struct input_value *v;
2644
2645         for (v = vals; v != vals + count; v++)
2646                 handler->event(handle, v->type, v->code, v->value);
2647
2648         return count;
2649 }
2650
2651 /*
2652  * An implementation of input_handle's handle_events() method that invokes
2653  * handler->filter() method for each event one by one and removes events
2654  * that were filtered out from the "vals" array.
2655  */
2656 static unsigned int input_handle_events_filter(struct input_handle *handle,
2657                                                struct input_value *vals,
2658                                                unsigned int count)
2659 {
2660         struct input_handler *handler = handle->handler;
2661         struct input_value *end = vals;
2662         struct input_value *v;
2663
2664         for (v = vals; v != vals + count; v++) {
2665                 if (handler->filter(handle, v->type, v->code, v->value))
2666                         continue;
2667                 if (end != v)
2668                         *end = *v;
2669                 end++;
2670         }
2671
2672         return end - vals;
2673 }
2674
2675 /*
2676  * An implementation of input_handle's handle_events() method that does nothing.
2677  */
2678 static unsigned int input_handle_events_null(struct input_handle *handle,
2679                                              struct input_value *vals,
2680                                              unsigned int count)
2681 {
2682         return count;
2683 }
2684
2685 /*
2686  * Sets up appropriate handle->event_handler based on the input_handler
2687  * associated with the handle.
2688  */
2689 static void input_handle_setup_event_handler(struct input_handle *handle)
2690 {
2691         struct input_handler *handler = handle->handler;
2692
2693         if (handler->filter)
2694                 handle->handle_events = input_handle_events_filter;
2695         else if (handler->event)
2696                 handle->handle_events = input_handle_events_default;
2697         else if (handler->events)
2698                 handle->handle_events = handler->events;
2699         else
2700                 handle->handle_events = input_handle_events_null;
2701 }
2702
2703 /**
2704  * input_register_handle - register a new input handle
2705  * @handle: handle to register
2706  *
2707  * This function puts a new input handle onto device's
2708  * and handler's lists so that events can flow through
2709  * it once it is opened using input_open_device().
2710  *
2711  * This function is supposed to be called from handler's
2712  * connect() method.
2713  */
2714 int input_register_handle(struct input_handle *handle)
2715 {
2716         struct input_handler *handler = handle->handler;
2717         struct input_dev *dev = handle->dev;
2718         int error;
2719
2720         input_handle_setup_event_handler(handle);
2721         /*
2722          * We take dev->mutex here to prevent race with
2723          * input_release_device().
2724          */
2725         error = mutex_lock_interruptible(&dev->mutex);
2726         if (error)
2727                 return error;
2728
2729         /*
2730          * Filters go to the head of the list, normal handlers
2731          * to the tail.
2732          */
2733         if (handler->filter)
2734                 list_add_rcu(&handle->d_node, &dev->h_list);
2735         else
2736                 list_add_tail_rcu(&handle->d_node, &dev->h_list);
2737
2738         mutex_unlock(&dev->mutex);
2739
2740         /*
2741          * Since we are supposed to be called from ->connect()
2742          * which is mutually exclusive with ->disconnect()
2743          * we can't be racing with input_unregister_handle()
2744          * and so separate lock is not needed here.
2745          */
2746         list_add_tail_rcu(&handle->h_node, &handler->h_list);
2747
2748         if (handler->start)
2749                 handler->start(handle);
2750
2751         return 0;
2752 }
2753 EXPORT_SYMBOL(input_register_handle);
2754
2755 /**
2756  * input_unregister_handle - unregister an input handle
2757  * @handle: handle to unregister
2758  *
2759  * This function removes input handle from device's
2760  * and handler's lists.
2761  *
2762  * This function is supposed to be called from handler's
2763  * disconnect() method.
2764  */
2765 void input_unregister_handle(struct input_handle *handle)
2766 {
2767         struct input_dev *dev = handle->dev;
2768
2769         list_del_rcu(&handle->h_node);
2770
2771         /*
2772          * Take dev->mutex to prevent race with input_release_device().
2773          */
2774         mutex_lock(&dev->mutex);
2775         list_del_rcu(&handle->d_node);
2776         mutex_unlock(&dev->mutex);
2777
2778         synchronize_rcu();
2779 }
2780 EXPORT_SYMBOL(input_unregister_handle);
2781
2782 /**
2783  * input_get_new_minor - allocates a new input minor number
2784  * @legacy_base: beginning or the legacy range to be searched
2785  * @legacy_num: size of legacy range
2786  * @allow_dynamic: whether we can also take ID from the dynamic range
2787  *
2788  * This function allocates a new device minor for from input major namespace.
2789  * Caller can request legacy minor by specifying @legacy_base and @legacy_num
2790  * parameters and whether ID can be allocated from dynamic range if there are
2791  * no free IDs in legacy range.
2792  */
2793 int input_get_new_minor(int legacy_base, unsigned int legacy_num,
2794                         bool allow_dynamic)
2795 {
2796         /*
2797          * This function should be called from input handler's ->connect()
2798          * methods, which are serialized with input_mutex, so no additional
2799          * locking is needed here.
2800          */
2801         if (legacy_base >= 0) {
2802                 int minor = ida_alloc_range(&input_ida, legacy_base,
2803                                             legacy_base + legacy_num - 1,
2804                                             GFP_KERNEL);
2805                 if (minor >= 0 || !allow_dynamic)
2806                         return minor;
2807         }
2808
2809         return ida_alloc_range(&input_ida, INPUT_FIRST_DYNAMIC_DEV,
2810                                INPUT_MAX_CHAR_DEVICES - 1, GFP_KERNEL);
2811 }
2812 EXPORT_SYMBOL(input_get_new_minor);
2813
2814 /**
2815  * input_free_minor - release previously allocated minor
2816  * @minor: minor to be released
2817  *
2818  * This function releases previously allocated input minor so that it can be
2819  * reused later.
2820  */
2821 void input_free_minor(unsigned int minor)
2822 {
2823         ida_free(&input_ida, minor);
2824 }
2825 EXPORT_SYMBOL(input_free_minor);
2826
2827 static int __init input_init(void)
2828 {
2829         int err;
2830
2831         err = class_register(&input_class);
2832         if (err) {
2833                 pr_err("unable to register input_dev class\n");
2834                 return err;
2835         }
2836
2837         err = input_proc_init();
2838         if (err)
2839                 goto fail1;
2840
2841         err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2842                                      INPUT_MAX_CHAR_DEVICES, "input");
2843         if (err) {
2844                 pr_err("unable to register char major %d", INPUT_MAJOR);
2845                 goto fail2;
2846         }
2847
2848         return 0;
2849
2850  fail2: input_proc_exit();
2851  fail1: class_unregister(&input_class);
2852         return err;
2853 }
2854
2855 static void __exit input_exit(void)
2856 {
2857         input_proc_exit();
2858         unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2859                                  INPUT_MAX_CHAR_DEVICES);
2860         class_unregister(&input_class);
2861 }
2862
2863 subsys_initcall(input_init);
2864 module_exit(input_exit);