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