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