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 32MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); 33MODULE_DESCRIPTION("Input core"); 34MODULE_LICENSE("GPL"); 35 36#define INPUT_MAX_CHAR_DEVICES 1024 37#define INPUT_FIRST_DYNAMIC_DEV 256 38static DEFINE_IDA(input_ida); 39 40static LIST_HEAD(input_dev_list); 41static 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 */ 49static DEFINE_MUTEX(input_mutex); 50 51static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 }; 52 53static 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 64static 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 70static 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 86static 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 97static 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 */ 107static 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 */ 142static 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 189static 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 241static 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 351static 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 394void 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 */ 427void 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} 439EXPORT_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 */ 452void 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} 471EXPORT_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 */ 480void 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} 496EXPORT_SYMBOL(input_alloc_absinfo); 497 498void 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} 516EXPORT_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 */ 531void 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} 553EXPORT_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 */ 563int 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} 583EXPORT_SYMBOL(input_grab_device); 584 585static 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 */ 612void 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} 620EXPORT_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 */ 629int 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} 674EXPORT_SYMBOL(input_open_device); 675 676int 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} 691EXPORT_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 */ 700void 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} 726EXPORT_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 */ 732static 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 */ 752static 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 */ 792int 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} 814EXPORT_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 821static 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 836static 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 864static 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 */ 934int 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} 945EXPORT_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 */ 955int 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} 1002EXPORT_SYMBOL(input_set_keycode); 1003 1004bool 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} 1038EXPORT_SYMBOL(input_match_device_id); 1039 1040static 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 1055static 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 1074static 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 1098static 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 1109static struct proc_dir_entry *proc_bus_input_dir; 1110static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait); 1111static int input_devices_state; 1112 1113static inline void input_wakeup_procfs_readers(void) 1114{ 1115 input_devices_state++; 1116 wake_up(&input_devices_poll_wait); 1117} 1118 1119static __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 1130union input_seq_state { 1131 struct { 1132 unsigned short pos; 1133 bool mutex_acquired; 1134 }; 1135 void *p; 1136}; 1137 1138static 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 1157static 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 1162static 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 1170static 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 1196static 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 1241static 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 1248static int input_proc_devices_open(struct inode *inode, struct file *file) 1249{ 1250 return seq_open(file, &input_devices_seq_ops); 1251} 1252 1253static 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 1261static 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 1281static 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 1289static 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 1304static 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 1311static int input_proc_handlers_open(struct inode *inode, struct file *file) 1312{ 1313 return seq_open(file, &input_handlers_seq_ops); 1314} 1315 1316static 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 1323static 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 1348static 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 */ 1356static inline void input_wakeup_procfs_readers(void) { } 1357static inline int input_proc_init(void) { return 0; } 1358static inline void input_proc_exit(void) { } 1359#endif 1360 1361#define INPUT_DEV_STRING_ATTR_SHOW(name) \ 1362static 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 sysfs_emit(buf, "%s\n", \ 1369 input_dev->name ? input_dev->name : ""); \ 1370} \ 1371static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL) 1372 1373INPUT_DEV_STRING_ATTR_SHOW(name); 1374INPUT_DEV_STRING_ATTR_SHOW(phys); 1375INPUT_DEV_STRING_ATTR_SHOW(uniq); 1376 1377static 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 1390static 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 1425static 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} 1436static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL); 1437 1438static int input_print_bitmap(char *buf, int buf_size, const unsigned long *bitmap, 1439 int max, int add_cr); 1440 1441static 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} 1450static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL); 1451 1452static int input_inhibit_device(struct input_dev *dev); 1453static int input_uninhibit_device(struct input_dev *dev); 1454 1455static 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 sysfs_emit(buf, "%d\n", input_dev->inhibited); 1462} 1463 1464static 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 1486static DEVICE_ATTR_RW(inhibited); 1487 1488static 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 1498static const struct attribute_group input_dev_attr_group = { 1499 .attrs = input_dev_attrs, 1500}; 1501 1502#define INPUT_DEV_ID_ATTR(name) \ 1503static 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 sysfs_emit(buf, "%04x\n", input_dev->id.name); \ 1509} \ 1510static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL) 1511 1512INPUT_DEV_ID_ATTR(bustype); 1513INPUT_DEV_ID_ATTR(vendor); 1514INPUT_DEV_ID_ATTR(product); 1515INPUT_DEV_ID_ATTR(version); 1516 1517static 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 1525static const struct attribute_group input_dev_id_attr_group = { 1526 .name = "id", 1527 .attrs = input_dev_id_attrs, 1528}; 1529 1530static 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) \ 1560static 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} \ 1570static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL) 1571 1572INPUT_DEV_CAP_ATTR(EV, ev); 1573INPUT_DEV_CAP_ATTR(KEY, key); 1574INPUT_DEV_CAP_ATTR(REL, rel); 1575INPUT_DEV_CAP_ATTR(ABS, abs); 1576INPUT_DEV_CAP_ATTR(MSC, msc); 1577INPUT_DEV_CAP_ATTR(LED, led); 1578INPUT_DEV_CAP_ATTR(SND, snd); 1579INPUT_DEV_CAP_ATTR(FF, ff); 1580INPUT_DEV_CAP_ATTR(SW, sw); 1581 1582static 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 1595static const struct attribute_group input_dev_caps_attr_group = { 1596 .name = "capabilities", 1597 .attrs = input_dev_caps_attrs, 1598}; 1599 1600static 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 1608static 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 */ 1626static 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 1644static 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 1683static 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 1739static 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 */ 1761void 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} 1775EXPORT_SYMBOL(input_reset_device); 1776 1777static 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 1800out: 1801 mutex_unlock(&dev->mutex); 1802 return 0; 1803} 1804 1805static 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 1829out: 1830 mutex_unlock(&dev->mutex); 1831 return ret; 1832} 1833 1834static 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 1855static 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 1869static 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 1887static 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 1901static 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 1909static 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 1916static char *input_devnode(const struct device *dev, umode_t *mode) 1917{ 1918 return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev)); 1919} 1920 1921const struct class input_class = { 1922 .name = "input", 1923 .devnode = input_devnode, 1924}; 1925EXPORT_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 */ 1936struct 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} 1960EXPORT_SYMBOL(input_allocate_device); 1961 1962struct input_devres { 1963 struct input_dev *input; 1964}; 1965 1966static 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 1973static 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 */ 2001struct 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} 2025EXPORT_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 */ 2041void 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} 2052EXPORT_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 */ 2068void 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} 2075EXPORT_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 */ 2083ktime_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} 2092EXPORT_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 */ 2103void 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} 2159EXPORT_SYMBOL(input_set_capability); 2160 2161static 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 2201static 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 2213static 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 2235static 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 */ 2250static 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 */ 2281void 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} 2287EXPORT_SYMBOL(input_enable_softrepeat); 2288 2289bool input_device_enabled(struct input_dev *dev) 2290{ 2291 lockdep_assert_held(&dev->mutex); 2292 2293 return !dev->inhibited && dev->users > 0; 2294} 2295EXPORT_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 */ 2320int 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 2409err_device_del: 2410 device_del(&dev->dev); 2411err_free_vals: 2412 kfree(dev->vals); 2413 dev->vals = NULL; 2414err_devres_free: 2415 devres_free(devres); 2416 return error; 2417} 2418EXPORT_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 */ 2427void 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} 2444EXPORT_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 */ 2454int 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} 2475EXPORT_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 */ 2484void 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} 2500EXPORT_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 */ 2514int 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} 2532EXPORT_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 */ 2545int 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} 2583EXPORT_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 */ 2595void 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} 2610EXPORT_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 */ 2623int 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_alloc_range(&input_ida, legacy_base, 2633 legacy_base + legacy_num - 1, 2634 GFP_KERNEL); 2635 if (minor >= 0 || !allow_dynamic) 2636 return minor; 2637 } 2638 2639 return ida_alloc_range(&input_ida, INPUT_FIRST_DYNAMIC_DEV, 2640 INPUT_MAX_CHAR_DEVICES - 1, GFP_KERNEL); 2641} 2642EXPORT_SYMBOL(input_get_new_minor); 2643 2644/** 2645 * input_free_minor - release previously allocated minor 2646 * @minor: minor to be released 2647 * 2648 * This function releases previously allocated input minor so that it can be 2649 * reused later. 2650 */ 2651void input_free_minor(unsigned int minor) 2652{ 2653 ida_free(&input_ida, minor); 2654} 2655EXPORT_SYMBOL(input_free_minor); 2656 2657static int __init input_init(void) 2658{ 2659 int err; 2660 2661 err = class_register(&input_class); 2662 if (err) { 2663 pr_err("unable to register input_dev class\n"); 2664 return err; 2665 } 2666 2667 err = input_proc_init(); 2668 if (err) 2669 goto fail1; 2670 2671 err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0), 2672 INPUT_MAX_CHAR_DEVICES, "input"); 2673 if (err) { 2674 pr_err("unable to register char major %d", INPUT_MAJOR); 2675 goto fail2; 2676 } 2677 2678 return 0; 2679 2680 fail2: input_proc_exit(); 2681 fail1: class_unregister(&input_class); 2682 return err; 2683} 2684 2685static void __exit input_exit(void) 2686{ 2687 input_proc_exit(); 2688 unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0), 2689 INPUT_MAX_CHAR_DEVICES); 2690 class_unregister(&input_class); 2691} 2692 2693subsys_initcall(input_init); 2694module_exit(input_exit); 2695