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