1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * HID support for Linux 4 * 5 * Copyright (c) 1999 Andreas Gal 6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 8 * Copyright (c) 2006-2012 Jiri Kosina 9 */ 10 11/* 12 */ 13 14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 16#include <linux/module.h> 17#include <linux/slab.h> 18#include <linux/init.h> 19#include <linux/kernel.h> 20#include <linux/list.h> 21#include <linux/mm.h> 22#include <linux/spinlock.h> 23#include <asm/unaligned.h> 24#include <asm/byteorder.h> 25#include <linux/input.h> 26#include <linux/wait.h> 27#include <linux/vmalloc.h> 28#include <linux/sched.h> 29#include <linux/semaphore.h> 30 31#include <linux/hid.h> 32#include <linux/hiddev.h> 33#include <linux/hid-debug.h> 34#include <linux/hidraw.h> 35 36#include "hid-ids.h" 37 38/* 39 * Version Information 40 */ 41 42#define DRIVER_DESC "HID core driver" 43 44int hid_debug = 0; 45module_param_named(debug, hid_debug, int, 0600); 46MODULE_PARM_DESC(debug, "toggle HID debugging messages"); 47EXPORT_SYMBOL_GPL(hid_debug); 48 49static int hid_ignore_special_drivers = 0; 50module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600); 51MODULE_PARM_DESC(ignore_special_drivers, "Ignore any special drivers and handle all devices by generic driver"); 52 53/* 54 * Register a new report for a device. 55 */ 56 57struct hid_report *hid_register_report(struct hid_device *device, 58 unsigned int type, unsigned int id, 59 unsigned int application) 60{ 61 struct hid_report_enum *report_enum = device->report_enum + type; 62 struct hid_report *report; 63 64 if (id >= HID_MAX_IDS) 65 return NULL; 66 if (report_enum->report_id_hash[id]) 67 return report_enum->report_id_hash[id]; 68 69 report = kzalloc(sizeof(struct hid_report), GFP_KERNEL); 70 if (!report) 71 return NULL; 72 73 if (id != 0) 74 report_enum->numbered = 1; 75 76 report->id = id; 77 report->type = type; 78 report->size = 0; 79 report->device = device; 80 report->application = application; 81 report_enum->report_id_hash[id] = report; 82 83 list_add_tail(&report->list, &report_enum->report_list); 84 85 return report; 86} 87EXPORT_SYMBOL_GPL(hid_register_report); 88 89/* 90 * Register a new field for this report. 91 */ 92 93static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages) 94{ 95 struct hid_field *field; 96 97 if (report->maxfield == HID_MAX_FIELDS) { 98 hid_err(report->device, "too many fields in report\n"); 99 return NULL; 100 } 101 102 field = kzalloc((sizeof(struct hid_field) + 103 usages * sizeof(struct hid_usage) + 104 usages * sizeof(unsigned)), GFP_KERNEL); 105 if (!field) 106 return NULL; 107 108 field->index = report->maxfield++; 109 report->field[field->index] = field; 110 field->usage = (struct hid_usage *)(field + 1); 111 field->value = (s32 *)(field->usage + usages); 112 field->report = report; 113 114 return field; 115} 116 117/* 118 * Open a collection. The type/usage is pushed on the stack. 119 */ 120 121static int open_collection(struct hid_parser *parser, unsigned type) 122{ 123 struct hid_collection *collection; 124 unsigned usage; 125 int collection_index; 126 127 usage = parser->local.usage[0]; 128 129 if (parser->collection_stack_ptr == parser->collection_stack_size) { 130 unsigned int *collection_stack; 131 unsigned int new_size = parser->collection_stack_size + 132 HID_COLLECTION_STACK_SIZE; 133 134 collection_stack = krealloc(parser->collection_stack, 135 new_size * sizeof(unsigned int), 136 GFP_KERNEL); 137 if (!collection_stack) 138 return -ENOMEM; 139 140 parser->collection_stack = collection_stack; 141 parser->collection_stack_size = new_size; 142 } 143 144 if (parser->device->maxcollection == parser->device->collection_size) { 145 collection = kmalloc( 146 array3_size(sizeof(struct hid_collection), 147 parser->device->collection_size, 148 2), 149 GFP_KERNEL); 150 if (collection == NULL) { 151 hid_err(parser->device, "failed to reallocate collection array\n"); 152 return -ENOMEM; 153 } 154 memcpy(collection, parser->device->collection, 155 sizeof(struct hid_collection) * 156 parser->device->collection_size); 157 memset(collection + parser->device->collection_size, 0, 158 sizeof(struct hid_collection) * 159 parser->device->collection_size); 160 kfree(parser->device->collection); 161 parser->device->collection = collection; 162 parser->device->collection_size *= 2; 163 } 164 165 parser->collection_stack[parser->collection_stack_ptr++] = 166 parser->device->maxcollection; 167 168 collection_index = parser->device->maxcollection++; 169 collection = parser->device->collection + collection_index; 170 collection->type = type; 171 collection->usage = usage; 172 collection->level = parser->collection_stack_ptr - 1; 173 collection->parent_idx = (collection->level == 0) ? -1 : 174 parser->collection_stack[collection->level - 1]; 175 176 if (type == HID_COLLECTION_APPLICATION) 177 parser->device->maxapplication++; 178 179 return 0; 180} 181 182/* 183 * Close a collection. 184 */ 185 186static int close_collection(struct hid_parser *parser) 187{ 188 if (!parser->collection_stack_ptr) { 189 hid_err(parser->device, "collection stack underflow\n"); 190 return -EINVAL; 191 } 192 parser->collection_stack_ptr--; 193 return 0; 194} 195 196/* 197 * Climb up the stack, search for the specified collection type 198 * and return the usage. 199 */ 200 201static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type) 202{ 203 struct hid_collection *collection = parser->device->collection; 204 int n; 205 206 for (n = parser->collection_stack_ptr - 1; n >= 0; n--) { 207 unsigned index = parser->collection_stack[n]; 208 if (collection[index].type == type) 209 return collection[index].usage; 210 } 211 return 0; /* we know nothing about this usage type */ 212} 213 214/* 215 * Concatenate usage which defines 16 bits or less with the 216 * currently defined usage page to form a 32 bit usage 217 */ 218 219static void complete_usage(struct hid_parser *parser, unsigned int index) 220{ 221 parser->local.usage[index] &= 0xFFFF; 222 parser->local.usage[index] |= 223 (parser->global.usage_page & 0xFFFF) << 16; 224} 225 226/* 227 * Add a usage to the temporary parser table. 228 */ 229 230static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size) 231{ 232 if (parser->local.usage_index >= HID_MAX_USAGES) { 233 hid_err(parser->device, "usage index exceeded\n"); 234 return -1; 235 } 236 parser->local.usage[parser->local.usage_index] = usage; 237 238 /* 239 * If Usage item only includes usage id, concatenate it with 240 * currently defined usage page 241 */ 242 if (size <= 2) 243 complete_usage(parser, parser->local.usage_index); 244 245 parser->local.usage_size[parser->local.usage_index] = size; 246 parser->local.collection_index[parser->local.usage_index] = 247 parser->collection_stack_ptr ? 248 parser->collection_stack[parser->collection_stack_ptr - 1] : 0; 249 parser->local.usage_index++; 250 return 0; 251} 252 253/* 254 * Register a new field for this report. 255 */ 256 257static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags) 258{ 259 struct hid_report *report; 260 struct hid_field *field; 261 unsigned int max_buffer_size = HID_MAX_BUFFER_SIZE; 262 unsigned int usages; 263 unsigned int offset; 264 unsigned int i; 265 unsigned int application; 266 267 application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION); 268 269 report = hid_register_report(parser->device, report_type, 270 parser->global.report_id, application); 271 if (!report) { 272 hid_err(parser->device, "hid_register_report failed\n"); 273 return -1; 274 } 275 276 /* Handle both signed and unsigned cases properly */ 277 if ((parser->global.logical_minimum < 0 && 278 parser->global.logical_maximum < 279 parser->global.logical_minimum) || 280 (parser->global.logical_minimum >= 0 && 281 (__u32)parser->global.logical_maximum < 282 (__u32)parser->global.logical_minimum)) { 283 dbg_hid("logical range invalid 0x%x 0x%x\n", 284 parser->global.logical_minimum, 285 parser->global.logical_maximum); 286 return -1; 287 } 288 289 offset = report->size; 290 report->size += parser->global.report_size * parser->global.report_count; 291 292 if (parser->device->ll_driver->max_buffer_size) 293 max_buffer_size = parser->device->ll_driver->max_buffer_size; 294 295 /* Total size check: Allow for possible report index byte */ 296 if (report->size > (max_buffer_size - 1) << 3) { 297 hid_err(parser->device, "report is too long\n"); 298 return -1; 299 } 300 301 if (!parser->local.usage_index) /* Ignore padding fields */ 302 return 0; 303 304 usages = max_t(unsigned, parser->local.usage_index, 305 parser->global.report_count); 306 307 field = hid_register_field(report, usages); 308 if (!field) 309 return 0; 310 311 field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL); 312 field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL); 313 field->application = application; 314 315 for (i = 0; i < usages; i++) { 316 unsigned j = i; 317 /* Duplicate the last usage we parsed if we have excess values */ 318 if (i >= parser->local.usage_index) 319 j = parser->local.usage_index - 1; 320 field->usage[i].hid = parser->local.usage[j]; 321 field->usage[i].collection_index = 322 parser->local.collection_index[j]; 323 field->usage[i].usage_index = i; 324 field->usage[i].resolution_multiplier = 1; 325 } 326 327 field->maxusage = usages; 328 field->flags = flags; 329 field->report_offset = offset; 330 field->report_type = report_type; 331 field->report_size = parser->global.report_size; 332 field->report_count = parser->global.report_count; 333 field->logical_minimum = parser->global.logical_minimum; 334 field->logical_maximum = parser->global.logical_maximum; 335 field->physical_minimum = parser->global.physical_minimum; 336 field->physical_maximum = parser->global.physical_maximum; 337 field->unit_exponent = parser->global.unit_exponent; 338 field->unit = parser->global.unit; 339 340 return 0; 341} 342 343/* 344 * Read data value from item. 345 */ 346 347static u32 item_udata(struct hid_item *item) 348{ 349 switch (item->size) { 350 case 1: return item->data.u8; 351 case 2: return item->data.u16; 352 case 4: return item->data.u32; 353 } 354 return 0; 355} 356 357static s32 item_sdata(struct hid_item *item) 358{ 359 switch (item->size) { 360 case 1: return item->data.s8; 361 case 2: return item->data.s16; 362 case 4: return item->data.s32; 363 } 364 return 0; 365} 366 367/* 368 * Process a global item. 369 */ 370 371static int hid_parser_global(struct hid_parser *parser, struct hid_item *item) 372{ 373 __s32 raw_value; 374 switch (item->tag) { 375 case HID_GLOBAL_ITEM_TAG_PUSH: 376 377 if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) { 378 hid_err(parser->device, "global environment stack overflow\n"); 379 return -1; 380 } 381 382 memcpy(parser->global_stack + parser->global_stack_ptr++, 383 &parser->global, sizeof(struct hid_global)); 384 return 0; 385 386 case HID_GLOBAL_ITEM_TAG_POP: 387 388 if (!parser->global_stack_ptr) { 389 hid_err(parser->device, "global environment stack underflow\n"); 390 return -1; 391 } 392 393 memcpy(&parser->global, parser->global_stack + 394 --parser->global_stack_ptr, sizeof(struct hid_global)); 395 return 0; 396 397 case HID_GLOBAL_ITEM_TAG_USAGE_PAGE: 398 parser->global.usage_page = item_udata(item); 399 return 0; 400 401 case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM: 402 parser->global.logical_minimum = item_sdata(item); 403 return 0; 404 405 case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM: 406 if (parser->global.logical_minimum < 0) 407 parser->global.logical_maximum = item_sdata(item); 408 else 409 parser->global.logical_maximum = item_udata(item); 410 return 0; 411 412 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM: 413 parser->global.physical_minimum = item_sdata(item); 414 return 0; 415 416 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM: 417 if (parser->global.physical_minimum < 0) 418 parser->global.physical_maximum = item_sdata(item); 419 else 420 parser->global.physical_maximum = item_udata(item); 421 return 0; 422 423 case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT: 424 /* Many devices provide unit exponent as a two's complement 425 * nibble due to the common misunderstanding of HID 426 * specification 1.11, 6.2.2.7 Global Items. Attempt to handle 427 * both this and the standard encoding. */ 428 raw_value = item_sdata(item); 429 if (!(raw_value & 0xfffffff0)) 430 parser->global.unit_exponent = hid_snto32(raw_value, 4); 431 else 432 parser->global.unit_exponent = raw_value; 433 return 0; 434 435 case HID_GLOBAL_ITEM_TAG_UNIT: 436 parser->global.unit = item_udata(item); 437 return 0; 438 439 case HID_GLOBAL_ITEM_TAG_REPORT_SIZE: 440 parser->global.report_size = item_udata(item); 441 if (parser->global.report_size > 256) { 442 hid_err(parser->device, "invalid report_size %d\n", 443 parser->global.report_size); 444 return -1; 445 } 446 return 0; 447 448 case HID_GLOBAL_ITEM_TAG_REPORT_COUNT: 449 parser->global.report_count = item_udata(item); 450 if (parser->global.report_count > HID_MAX_USAGES) { 451 hid_err(parser->device, "invalid report_count %d\n", 452 parser->global.report_count); 453 return -1; 454 } 455 return 0; 456 457 case HID_GLOBAL_ITEM_TAG_REPORT_ID: 458 parser->global.report_id = item_udata(item); 459 if (parser->global.report_id == 0 || 460 parser->global.report_id >= HID_MAX_IDS) { 461 hid_err(parser->device, "report_id %u is invalid\n", 462 parser->global.report_id); 463 return -1; 464 } 465 return 0; 466 467 default: 468 hid_err(parser->device, "unknown global tag 0x%x\n", item->tag); 469 return -1; 470 } 471} 472 473/* 474 * Process a local item. 475 */ 476 477static int hid_parser_local(struct hid_parser *parser, struct hid_item *item) 478{ 479 __u32 data; 480 unsigned n; 481 __u32 count; 482 483 data = item_udata(item); 484 485 switch (item->tag) { 486 case HID_LOCAL_ITEM_TAG_DELIMITER: 487 488 if (data) { 489 /* 490 * We treat items before the first delimiter 491 * as global to all usage sets (branch 0). 492 * In the moment we process only these global 493 * items and the first delimiter set. 494 */ 495 if (parser->local.delimiter_depth != 0) { 496 hid_err(parser->device, "nested delimiters\n"); 497 return -1; 498 } 499 parser->local.delimiter_depth++; 500 parser->local.delimiter_branch++; 501 } else { 502 if (parser->local.delimiter_depth < 1) { 503 hid_err(parser->device, "bogus close delimiter\n"); 504 return -1; 505 } 506 parser->local.delimiter_depth--; 507 } 508 return 0; 509 510 case HID_LOCAL_ITEM_TAG_USAGE: 511 512 if (parser->local.delimiter_branch > 1) { 513 dbg_hid("alternative usage ignored\n"); 514 return 0; 515 } 516 517 return hid_add_usage(parser, data, item->size); 518 519 case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM: 520 521 if (parser->local.delimiter_branch > 1) { 522 dbg_hid("alternative usage ignored\n"); 523 return 0; 524 } 525 526 parser->local.usage_minimum = data; 527 return 0; 528 529 case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM: 530 531 if (parser->local.delimiter_branch > 1) { 532 dbg_hid("alternative usage ignored\n"); 533 return 0; 534 } 535 536 count = data - parser->local.usage_minimum; 537 if (count + parser->local.usage_index >= HID_MAX_USAGES) { 538 /* 539 * We do not warn if the name is not set, we are 540 * actually pre-scanning the device. 541 */ 542 if (dev_name(&parser->device->dev)) 543 hid_warn(parser->device, 544 "ignoring exceeding usage max\n"); 545 data = HID_MAX_USAGES - parser->local.usage_index + 546 parser->local.usage_minimum - 1; 547 if (data <= 0) { 548 hid_err(parser->device, 549 "no more usage index available\n"); 550 return -1; 551 } 552 } 553 554 for (n = parser->local.usage_minimum; n <= data; n++) 555 if (hid_add_usage(parser, n, item->size)) { 556 dbg_hid("hid_add_usage failed\n"); 557 return -1; 558 } 559 return 0; 560 561 default: 562 563 dbg_hid("unknown local item tag 0x%x\n", item->tag); 564 return 0; 565 } 566 return 0; 567} 568 569/* 570 * Concatenate Usage Pages into Usages where relevant: 571 * As per specification, 6.2.2.8: "When the parser encounters a main item it 572 * concatenates the last declared Usage Page with a Usage to form a complete 573 * usage value." 574 */ 575 576static void hid_concatenate_last_usage_page(struct hid_parser *parser) 577{ 578 int i; 579 unsigned int usage_page; 580 unsigned int current_page; 581 582 if (!parser->local.usage_index) 583 return; 584 585 usage_page = parser->global.usage_page; 586 587 /* 588 * Concatenate usage page again only if last declared Usage Page 589 * has not been already used in previous usages concatenation 590 */ 591 for (i = parser->local.usage_index - 1; i >= 0; i--) { 592 if (parser->local.usage_size[i] > 2) 593 /* Ignore extended usages */ 594 continue; 595 596 current_page = parser->local.usage[i] >> 16; 597 if (current_page == usage_page) 598 break; 599 600 complete_usage(parser, i); 601 } 602} 603 604/* 605 * Process a main item. 606 */ 607 608static int hid_parser_main(struct hid_parser *parser, struct hid_item *item) 609{ 610 __u32 data; 611 int ret; 612 613 hid_concatenate_last_usage_page(parser); 614 615 data = item_udata(item); 616 617 switch (item->tag) { 618 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION: 619 ret = open_collection(parser, data & 0xff); 620 break; 621 case HID_MAIN_ITEM_TAG_END_COLLECTION: 622 ret = close_collection(parser); 623 break; 624 case HID_MAIN_ITEM_TAG_INPUT: 625 ret = hid_add_field(parser, HID_INPUT_REPORT, data); 626 break; 627 case HID_MAIN_ITEM_TAG_OUTPUT: 628 ret = hid_add_field(parser, HID_OUTPUT_REPORT, data); 629 break; 630 case HID_MAIN_ITEM_TAG_FEATURE: 631 ret = hid_add_field(parser, HID_FEATURE_REPORT, data); 632 break; 633 default: 634 hid_warn(parser->device, "unknown main item tag 0x%x\n", item->tag); 635 ret = 0; 636 } 637 638 memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */ 639 640 return ret; 641} 642 643/* 644 * Process a reserved item. 645 */ 646 647static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item) 648{ 649 dbg_hid("reserved item type, tag 0x%x\n", item->tag); 650 return 0; 651} 652 653/* 654 * Free a report and all registered fields. The field->usage and 655 * field->value table's are allocated behind the field, so we need 656 * only to free(field) itself. 657 */ 658 659static void hid_free_report(struct hid_report *report) 660{ 661 unsigned n; 662 663 for (n = 0; n < report->maxfield; n++) 664 kfree(report->field[n]); 665 kfree(report); 666} 667 668/* 669 * Close report. This function returns the device 670 * state to the point prior to hid_open_report(). 671 */ 672static void hid_close_report(struct hid_device *device) 673{ 674 unsigned i, j; 675 676 for (i = 0; i < HID_REPORT_TYPES; i++) { 677 struct hid_report_enum *report_enum = device->report_enum + i; 678 679 for (j = 0; j < HID_MAX_IDS; j++) { 680 struct hid_report *report = report_enum->report_id_hash[j]; 681 if (report) 682 hid_free_report(report); 683 } 684 memset(report_enum, 0, sizeof(*report_enum)); 685 INIT_LIST_HEAD(&report_enum->report_list); 686 } 687 688 kfree(device->rdesc); 689 device->rdesc = NULL; 690 device->rsize = 0; 691 692 kfree(device->collection); 693 device->collection = NULL; 694 device->collection_size = 0; 695 device->maxcollection = 0; 696 device->maxapplication = 0; 697 698 device->status &= ~HID_STAT_PARSED; 699} 700 701/* 702 * Free a device structure, all reports, and all fields. 703 */ 704 705void hiddev_free(struct kref *ref) 706{ 707 struct hid_device *hid = container_of(ref, struct hid_device, ref); 708 709 hid_close_report(hid); 710 kfree(hid->dev_rdesc); 711 kfree(hid); 712} 713 714static void hid_device_release(struct device *dev) 715{ 716 struct hid_device *hid = to_hid_device(dev); 717 718 kref_put(&hid->ref, hiddev_free); 719} 720 721/* 722 * Fetch a report description item from the data stream. We support long 723 * items, though they are not used yet. 724 */ 725 726static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item) 727{ 728 u8 b; 729 730 if ((end - start) <= 0) 731 return NULL; 732 733 b = *start++; 734 735 item->type = (b >> 2) & 3; 736 item->tag = (b >> 4) & 15; 737 738 if (item->tag == HID_ITEM_TAG_LONG) { 739 740 item->format = HID_ITEM_FORMAT_LONG; 741 742 if ((end - start) < 2) 743 return NULL; 744 745 item->size = *start++; 746 item->tag = *start++; 747 748 if ((end - start) < item->size) 749 return NULL; 750 751 item->data.longdata = start; 752 start += item->size; 753 return start; 754 } 755 756 item->format = HID_ITEM_FORMAT_SHORT; 757 item->size = b & 3; 758 759 switch (item->size) { 760 case 0: 761 return start; 762 763 case 1: 764 if ((end - start) < 1) 765 return NULL; 766 item->data.u8 = *start++; 767 return start; 768 769 case 2: 770 if ((end - start) < 2) 771 return NULL; 772 item->data.u16 = get_unaligned_le16(start); 773 start = (__u8 *)((__le16 *)start + 1); 774 return start; 775 776 case 3: 777 item->size++; 778 if ((end - start) < 4) 779 return NULL; 780 item->data.u32 = get_unaligned_le32(start); 781 start = (__u8 *)((__le32 *)start + 1); 782 return start; 783 } 784 785 return NULL; 786} 787 788static void hid_scan_input_usage(struct hid_parser *parser, u32 usage) 789{ 790 struct hid_device *hid = parser->device; 791 792 if (usage == HID_DG_CONTACTID) 793 hid->group = HID_GROUP_MULTITOUCH; 794} 795 796static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage) 797{ 798 if (usage == 0xff0000c5 && parser->global.report_count == 256 && 799 parser->global.report_size == 8) 800 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8; 801 802 if (usage == 0xff0000c6 && parser->global.report_count == 1 && 803 parser->global.report_size == 8) 804 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8; 805} 806 807static void hid_scan_collection(struct hid_parser *parser, unsigned type) 808{ 809 struct hid_device *hid = parser->device; 810 int i; 811 812 if (((parser->global.usage_page << 16) == HID_UP_SENSOR) && 813 type == HID_COLLECTION_PHYSICAL) 814 hid->group = HID_GROUP_SENSOR_HUB; 815 816 if (hid->vendor == USB_VENDOR_ID_MICROSOFT && 817 hid->product == USB_DEVICE_ID_MS_POWER_COVER && 818 hid->group == HID_GROUP_MULTITOUCH) 819 hid->group = HID_GROUP_GENERIC; 820 821 if ((parser->global.usage_page << 16) == HID_UP_GENDESK) 822 for (i = 0; i < parser->local.usage_index; i++) 823 if (parser->local.usage[i] == HID_GD_POINTER) 824 parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER; 825 826 if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR) 827 parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC; 828 829 if ((parser->global.usage_page << 16) == HID_UP_GOOGLEVENDOR) 830 for (i = 0; i < parser->local.usage_index; i++) 831 if (parser->local.usage[i] == 832 (HID_UP_GOOGLEVENDOR | 0x0001)) 833 parser->device->group = 834 HID_GROUP_VIVALDI; 835} 836 837static int hid_scan_main(struct hid_parser *parser, struct hid_item *item) 838{ 839 __u32 data; 840 int i; 841 842 hid_concatenate_last_usage_page(parser); 843 844 data = item_udata(item); 845 846 switch (item->tag) { 847 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION: 848 hid_scan_collection(parser, data & 0xff); 849 break; 850 case HID_MAIN_ITEM_TAG_END_COLLECTION: 851 break; 852 case HID_MAIN_ITEM_TAG_INPUT: 853 /* ignore constant inputs, they will be ignored by hid-input */ 854 if (data & HID_MAIN_ITEM_CONSTANT) 855 break; 856 for (i = 0; i < parser->local.usage_index; i++) 857 hid_scan_input_usage(parser, parser->local.usage[i]); 858 break; 859 case HID_MAIN_ITEM_TAG_OUTPUT: 860 break; 861 case HID_MAIN_ITEM_TAG_FEATURE: 862 for (i = 0; i < parser->local.usage_index; i++) 863 hid_scan_feature_usage(parser, parser->local.usage[i]); 864 break; 865 } 866 867 /* Reset the local parser environment */ 868 memset(&parser->local, 0, sizeof(parser->local)); 869 870 return 0; 871} 872 873/* 874 * Scan a report descriptor before the device is added to the bus. 875 * Sets device groups and other properties that determine what driver 876 * to load. 877 */ 878static int hid_scan_report(struct hid_device *hid) 879{ 880 struct hid_parser *parser; 881 struct hid_item item; 882 __u8 *start = hid->dev_rdesc; 883 __u8 *end = start + hid->dev_rsize; 884 static int (*dispatch_type[])(struct hid_parser *parser, 885 struct hid_item *item) = { 886 hid_scan_main, 887 hid_parser_global, 888 hid_parser_local, 889 hid_parser_reserved 890 }; 891 892 parser = vzalloc(sizeof(struct hid_parser)); 893 if (!parser) 894 return -ENOMEM; 895 896 parser->device = hid; 897 hid->group = HID_GROUP_GENERIC; 898 899 /* 900 * The parsing is simpler than the one in hid_open_report() as we should 901 * be robust against hid errors. Those errors will be raised by 902 * hid_open_report() anyway. 903 */ 904 while ((start = fetch_item(start, end, &item)) != NULL) 905 dispatch_type[item.type](parser, &item); 906 907 /* 908 * Handle special flags set during scanning. 909 */ 910 if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) && 911 (hid->group == HID_GROUP_MULTITOUCH)) 912 hid->group = HID_GROUP_MULTITOUCH_WIN_8; 913 914 /* 915 * Vendor specific handlings 916 */ 917 switch (hid->vendor) { 918 case USB_VENDOR_ID_WACOM: 919 hid->group = HID_GROUP_WACOM; 920 break; 921 case USB_VENDOR_ID_SYNAPTICS: 922 if (hid->group == HID_GROUP_GENERIC) 923 if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC) 924 && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER)) 925 /* 926 * hid-rmi should take care of them, 927 * not hid-generic 928 */ 929 hid->group = HID_GROUP_RMI; 930 break; 931 } 932 933 kfree(parser->collection_stack); 934 vfree(parser); 935 return 0; 936} 937 938/** 939 * hid_parse_report - parse device report 940 * 941 * @hid: hid device 942 * @start: report start 943 * @size: report size 944 * 945 * Allocate the device report as read by the bus driver. This function should 946 * only be called from parse() in ll drivers. 947 */ 948int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size) 949{ 950 hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL); 951 if (!hid->dev_rdesc) 952 return -ENOMEM; 953 hid->dev_rsize = size; 954 return 0; 955} 956EXPORT_SYMBOL_GPL(hid_parse_report); 957 958static const char * const hid_report_names[] = { 959 "HID_INPUT_REPORT", 960 "HID_OUTPUT_REPORT", 961 "HID_FEATURE_REPORT", 962}; 963/** 964 * hid_validate_values - validate existing device report's value indexes 965 * 966 * @hid: hid device 967 * @type: which report type to examine 968 * @id: which report ID to examine (0 for first) 969 * @field_index: which report field to examine 970 * @report_counts: expected number of values 971 * 972 * Validate the number of values in a given field of a given report, after 973 * parsing. 974 */ 975struct hid_report *hid_validate_values(struct hid_device *hid, 976 unsigned int type, unsigned int id, 977 unsigned int field_index, 978 unsigned int report_counts) 979{ 980 struct hid_report *report; 981 982 if (type > HID_FEATURE_REPORT) { 983 hid_err(hid, "invalid HID report type %u\n", type); 984 return NULL; 985 } 986 987 if (id >= HID_MAX_IDS) { 988 hid_err(hid, "invalid HID report id %u\n", id); 989 return NULL; 990 } 991 992 /* 993 * Explicitly not using hid_get_report() here since it depends on 994 * ->numbered being checked, which may not always be the case when 995 * drivers go to access report values. 996 */ 997 if (id == 0) { 998 /* 999 * Validating on id 0 means we should examine the first 1000 * report in the list. 1001 */ 1002 report = list_first_entry_or_null( 1003 &hid->report_enum[type].report_list, 1004 struct hid_report, list); 1005 } else { 1006 report = hid->report_enum[type].report_id_hash[id]; 1007 } 1008 if (!report) { 1009 hid_err(hid, "missing %s %u\n", hid_report_names[type], id); 1010 return NULL; 1011 } 1012 if (report->maxfield <= field_index) { 1013 hid_err(hid, "not enough fields in %s %u\n", 1014 hid_report_names[type], id); 1015 return NULL; 1016 } 1017 if (report->field[field_index]->report_count < report_counts) { 1018 hid_err(hid, "not enough values in %s %u field %u\n", 1019 hid_report_names[type], id, field_index); 1020 return NULL; 1021 } 1022 return report; 1023} 1024EXPORT_SYMBOL_GPL(hid_validate_values); 1025 1026static int hid_calculate_multiplier(struct hid_device *hid, 1027 struct hid_field *multiplier) 1028{ 1029 int m; 1030 __s32 v = *multiplier->value; 1031 __s32 lmin = multiplier->logical_minimum; 1032 __s32 lmax = multiplier->logical_maximum; 1033 __s32 pmin = multiplier->physical_minimum; 1034 __s32 pmax = multiplier->physical_maximum; 1035 1036 /* 1037 * "Because OS implementations will generally divide the control's 1038 * reported count by the Effective Resolution Multiplier, designers 1039 * should take care not to establish a potential Effective 1040 * Resolution Multiplier of zero." 1041 * HID Usage Table, v1.12, Section 4.3.1, p31 1042 */ 1043 if (lmax - lmin == 0) 1044 return 1; 1045 /* 1046 * Handling the unit exponent is left as an exercise to whoever 1047 * finds a device where that exponent is not 0. 1048 */ 1049 m = ((v - lmin)/(lmax - lmin) * (pmax - pmin) + pmin); 1050 if (unlikely(multiplier->unit_exponent != 0)) { 1051 hid_warn(hid, 1052 "unsupported Resolution Multiplier unit exponent %d\n", 1053 multiplier->unit_exponent); 1054 } 1055 1056 /* There are no devices with an effective multiplier > 255 */ 1057 if (unlikely(m == 0 || m > 255 || m < -255)) { 1058 hid_warn(hid, "unsupported Resolution Multiplier %d\n", m); 1059 m = 1; 1060 } 1061 1062 return m; 1063} 1064 1065static void hid_apply_multiplier_to_field(struct hid_device *hid, 1066 struct hid_field *field, 1067 struct hid_collection *multiplier_collection, 1068 int effective_multiplier) 1069{ 1070 struct hid_collection *collection; 1071 struct hid_usage *usage; 1072 int i; 1073 1074 /* 1075 * If multiplier_collection is NULL, the multiplier applies 1076 * to all fields in the report. 1077 * Otherwise, it is the Logical Collection the multiplier applies to 1078 * but our field may be in a subcollection of that collection. 1079 */ 1080 for (i = 0; i < field->maxusage; i++) { 1081 usage = &field->usage[i]; 1082 1083 collection = &hid->collection[usage->collection_index]; 1084 while (collection->parent_idx != -1 && 1085 collection != multiplier_collection) 1086 collection = &hid->collection[collection->parent_idx]; 1087 1088 if (collection->parent_idx != -1 || 1089 multiplier_collection == NULL) 1090 usage->resolution_multiplier = effective_multiplier; 1091 1092 } 1093} 1094 1095static void hid_apply_multiplier(struct hid_device *hid, 1096 struct hid_field *multiplier) 1097{ 1098 struct hid_report_enum *rep_enum; 1099 struct hid_report *rep; 1100 struct hid_field *field; 1101 struct hid_collection *multiplier_collection; 1102 int effective_multiplier; 1103 int i; 1104 1105 /* 1106 * "The Resolution Multiplier control must be contained in the same 1107 * Logical Collection as the control(s) to which it is to be applied. 1108 * If no Resolution Multiplier is defined, then the Resolution 1109 * Multiplier defaults to 1. If more than one control exists in a 1110 * Logical Collection, the Resolution Multiplier is associated with 1111 * all controls in the collection. If no Logical Collection is 1112 * defined, the Resolution Multiplier is associated with all 1113 * controls in the report." 1114 * HID Usage Table, v1.12, Section 4.3.1, p30 1115 * 1116 * Thus, search from the current collection upwards until we find a 1117 * logical collection. Then search all fields for that same parent 1118 * collection. Those are the fields the multiplier applies to. 1119 * 1120 * If we have more than one multiplier, it will overwrite the 1121 * applicable fields later. 1122 */ 1123 multiplier_collection = &hid->collection[multiplier->usage->collection_index]; 1124 while (multiplier_collection->parent_idx != -1 && 1125 multiplier_collection->type != HID_COLLECTION_LOGICAL) 1126 multiplier_collection = &hid->collection[multiplier_collection->parent_idx]; 1127 1128 effective_multiplier = hid_calculate_multiplier(hid, multiplier); 1129 1130 rep_enum = &hid->report_enum[HID_INPUT_REPORT]; 1131 list_for_each_entry(rep, &rep_enum->report_list, list) { 1132 for (i = 0; i < rep->maxfield; i++) { 1133 field = rep->field[i]; 1134 hid_apply_multiplier_to_field(hid, field, 1135 multiplier_collection, 1136 effective_multiplier); 1137 } 1138 } 1139} 1140 1141/* 1142 * hid_setup_resolution_multiplier - set up all resolution multipliers 1143 * 1144 * @device: hid device 1145 * 1146 * Search for all Resolution Multiplier Feature Reports and apply their 1147 * value to all matching Input items. This only updates the internal struct 1148 * fields. 1149 * 1150 * The Resolution Multiplier is applied by the hardware. If the multiplier 1151 * is anything other than 1, the hardware will send pre-multiplied events 1152 * so that the same physical interaction generates an accumulated 1153 * accumulated_value = value * * multiplier 1154 * This may be achieved by sending 1155 * - "value * multiplier" for each event, or 1156 * - "value" but "multiplier" times as frequently, or 1157 * - a combination of the above 1158 * The only guarantee is that the same physical interaction always generates 1159 * an accumulated 'value * multiplier'. 1160 * 1161 * This function must be called before any event processing and after 1162 * any SetRequest to the Resolution Multiplier. 1163 */ 1164void hid_setup_resolution_multiplier(struct hid_device *hid) 1165{ 1166 struct hid_report_enum *rep_enum; 1167 struct hid_report *rep; 1168 struct hid_usage *usage; 1169 int i, j; 1170 1171 rep_enum = &hid->report_enum[HID_FEATURE_REPORT]; 1172 list_for_each_entry(rep, &rep_enum->report_list, list) { 1173 for (i = 0; i < rep->maxfield; i++) { 1174 /* Ignore if report count is out of bounds. */ 1175 if (rep->field[i]->report_count < 1) 1176 continue; 1177 1178 for (j = 0; j < rep->field[i]->maxusage; j++) { 1179 usage = &rep->field[i]->usage[j]; 1180 if (usage->hid == HID_GD_RESOLUTION_MULTIPLIER) 1181 hid_apply_multiplier(hid, 1182 rep->field[i]); 1183 } 1184 } 1185 } 1186} 1187EXPORT_SYMBOL_GPL(hid_setup_resolution_multiplier); 1188 1189/** 1190 * hid_open_report - open a driver-specific device report 1191 * 1192 * @device: hid device 1193 * 1194 * Parse a report description into a hid_device structure. Reports are 1195 * enumerated, fields are attached to these reports. 1196 * 0 returned on success, otherwise nonzero error value. 1197 * 1198 * This function (or the equivalent hid_parse() macro) should only be 1199 * called from probe() in drivers, before starting the device. 1200 */ 1201int hid_open_report(struct hid_device *device) 1202{ 1203 struct hid_parser *parser; 1204 struct hid_item item; 1205 unsigned int size; 1206 __u8 *start; 1207 __u8 *buf; 1208 __u8 *end; 1209 __u8 *next; 1210 int ret; 1211 int i; 1212 static int (*dispatch_type[])(struct hid_parser *parser, 1213 struct hid_item *item) = { 1214 hid_parser_main, 1215 hid_parser_global, 1216 hid_parser_local, 1217 hid_parser_reserved 1218 }; 1219 1220 if (WARN_ON(device->status & HID_STAT_PARSED)) 1221 return -EBUSY; 1222 1223 start = device->dev_rdesc; 1224 if (WARN_ON(!start)) 1225 return -ENODEV; 1226 size = device->dev_rsize; 1227 1228 buf = kmemdup(start, size, GFP_KERNEL); 1229 if (buf == NULL) 1230 return -ENOMEM; 1231 1232 if (device->driver->report_fixup) 1233 start = device->driver->report_fixup(device, buf, &size); 1234 else 1235 start = buf; 1236 1237 start = kmemdup(start, size, GFP_KERNEL); 1238 kfree(buf); 1239 if (start == NULL) 1240 return -ENOMEM; 1241 1242 device->rdesc = start; 1243 device->rsize = size; 1244 1245 parser = vzalloc(sizeof(struct hid_parser)); 1246 if (!parser) { 1247 ret = -ENOMEM; 1248 goto alloc_err; 1249 } 1250 1251 parser->device = device; 1252 1253 end = start + size; 1254 1255 device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS, 1256 sizeof(struct hid_collection), GFP_KERNEL); 1257 if (!device->collection) { 1258 ret = -ENOMEM; 1259 goto err; 1260 } 1261 device->collection_size = HID_DEFAULT_NUM_COLLECTIONS; 1262 for (i = 0; i < HID_DEFAULT_NUM_COLLECTIONS; i++) 1263 device->collection[i].parent_idx = -1; 1264 1265 ret = -EINVAL; 1266 while ((next = fetch_item(start, end, &item)) != NULL) { 1267 start = next; 1268 1269 if (item.format != HID_ITEM_FORMAT_SHORT) { 1270 hid_err(device, "unexpected long global item\n"); 1271 goto err; 1272 } 1273 1274 if (dispatch_type[item.type](parser, &item)) { 1275 hid_err(device, "item %u %u %u %u parsing failed\n", 1276 item.format, (unsigned)item.size, 1277 (unsigned)item.type, (unsigned)item.tag); 1278 goto err; 1279 } 1280 1281 if (start == end) { 1282 if (parser->collection_stack_ptr) { 1283 hid_err(device, "unbalanced collection at end of report description\n"); 1284 goto err; 1285 } 1286 if (parser->local.delimiter_depth) { 1287 hid_err(device, "unbalanced delimiter at end of report description\n"); 1288 goto err; 1289 } 1290 1291 /* 1292 * fetch initial values in case the device's 1293 * default multiplier isn't the recommended 1 1294 */ 1295 hid_setup_resolution_multiplier(device); 1296 1297 kfree(parser->collection_stack); 1298 vfree(parser); 1299 device->status |= HID_STAT_PARSED; 1300 1301 return 0; 1302 } 1303 } 1304 1305 hid_err(device, "item fetching failed at offset %u/%u\n", 1306 size - (unsigned int)(end - start), size); 1307err: 1308 kfree(parser->collection_stack); 1309alloc_err: 1310 vfree(parser); 1311 hid_close_report(device); 1312 return ret; 1313} 1314EXPORT_SYMBOL_GPL(hid_open_report); 1315 1316/* 1317 * Convert a signed n-bit integer to signed 32-bit integer. Common 1318 * cases are done through the compiler, the screwed things has to be 1319 * done by hand. 1320 */ 1321 1322static s32 snto32(__u32 value, unsigned n) 1323{ 1324 if (!value || !n) 1325 return 0; 1326 1327 if (n > 32) 1328 n = 32; 1329 1330 switch (n) { 1331 case 8: return ((__s8)value); 1332 case 16: return ((__s16)value); 1333 case 32: return ((__s32)value); 1334 } 1335 return value & (1 << (n - 1)) ? value | (~0U << n) : value; 1336} 1337 1338s32 hid_snto32(__u32 value, unsigned n) 1339{ 1340 return snto32(value, n); 1341} 1342EXPORT_SYMBOL_GPL(hid_snto32); 1343 1344/* 1345 * Convert a signed 32-bit integer to a signed n-bit integer. 1346 */ 1347 1348static u32 s32ton(__s32 value, unsigned n) 1349{ 1350 s32 a = value >> (n - 1); 1351 if (a && a != -1) 1352 return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1; 1353 return value & ((1 << n) - 1); 1354} 1355 1356/* 1357 * Extract/implement a data field from/to a little endian report (bit array). 1358 * 1359 * Code sort-of follows HID spec: 1360 * http://www.usb.org/developers/hidpage/HID1_11.pdf 1361 * 1362 * While the USB HID spec allows unlimited length bit fields in "report 1363 * descriptors", most devices never use more than 16 bits. 1364 * One model of UPS is claimed to report "LINEV" as a 32-bit field. 1365 * Search linux-kernel and linux-usb-devel archives for "hid-core extract". 1366 */ 1367 1368static u32 __extract(u8 *report, unsigned offset, int n) 1369{ 1370 unsigned int idx = offset / 8; 1371 unsigned int bit_nr = 0; 1372 unsigned int bit_shift = offset % 8; 1373 int bits_to_copy = 8 - bit_shift; 1374 u32 value = 0; 1375 u32 mask = n < 32 ? (1U << n) - 1 : ~0U; 1376 1377 while (n > 0) { 1378 value |= ((u32)report[idx] >> bit_shift) << bit_nr; 1379 n -= bits_to_copy; 1380 bit_nr += bits_to_copy; 1381 bits_to_copy = 8; 1382 bit_shift = 0; 1383 idx++; 1384 } 1385 1386 return value & mask; 1387} 1388 1389u32 hid_field_extract(const struct hid_device *hid, u8 *report, 1390 unsigned offset, unsigned n) 1391{ 1392 if (n > 32) { 1393 hid_warn_once(hid, "%s() called with n (%d) > 32! (%s)\n", 1394 __func__, n, current->comm); 1395 n = 32; 1396 } 1397 1398 return __extract(report, offset, n); 1399} 1400EXPORT_SYMBOL_GPL(hid_field_extract); 1401 1402/* 1403 * "implement" : set bits in a little endian bit stream. 1404 * Same concepts as "extract" (see comments above). 1405 * The data mangled in the bit stream remains in little endian 1406 * order the whole time. It make more sense to talk about 1407 * endianness of register values by considering a register 1408 * a "cached" copy of the little endian bit stream. 1409 */ 1410 1411static void __implement(u8 *report, unsigned offset, int n, u32 value) 1412{ 1413 unsigned int idx = offset / 8; 1414 unsigned int bit_shift = offset % 8; 1415 int bits_to_set = 8 - bit_shift; 1416 1417 while (n - bits_to_set >= 0) { 1418 report[idx] &= ~(0xff << bit_shift); 1419 report[idx] |= value << bit_shift; 1420 value >>= bits_to_set; 1421 n -= bits_to_set; 1422 bits_to_set = 8; 1423 bit_shift = 0; 1424 idx++; 1425 } 1426 1427 /* last nibble */ 1428 if (n) { 1429 u8 bit_mask = ((1U << n) - 1); 1430 report[idx] &= ~(bit_mask << bit_shift); 1431 report[idx] |= value << bit_shift; 1432 } 1433} 1434 1435static void implement(const struct hid_device *hid, u8 *report, 1436 unsigned offset, unsigned n, u32 value) 1437{ 1438 if (unlikely(n > 32)) { 1439 hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n", 1440 __func__, n, current->comm); 1441 n = 32; 1442 } else if (n < 32) { 1443 u32 m = (1U << n) - 1; 1444 1445 if (unlikely(value > m)) { 1446 hid_warn(hid, 1447 "%s() called with too large value %d (n: %d)! (%s)\n", 1448 __func__, value, n, current->comm); 1449 value &= m; 1450 } 1451 } 1452 1453 __implement(report, offset, n, value); 1454} 1455 1456/* 1457 * Search an array for a value. 1458 */ 1459 1460static int search(__s32 *array, __s32 value, unsigned n) 1461{ 1462 while (n--) { 1463 if (*array++ == value) 1464 return 0; 1465 } 1466 return -1; 1467} 1468 1469/** 1470 * hid_match_report - check if driver's raw_event should be called 1471 * 1472 * @hid: hid device 1473 * @report: hid report to match against 1474 * 1475 * compare hid->driver->report_table->report_type to report->type 1476 */ 1477static int hid_match_report(struct hid_device *hid, struct hid_report *report) 1478{ 1479 const struct hid_report_id *id = hid->driver->report_table; 1480 1481 if (!id) /* NULL means all */ 1482 return 1; 1483 1484 for (; id->report_type != HID_TERMINATOR; id++) 1485 if (id->report_type == HID_ANY_ID || 1486 id->report_type == report->type) 1487 return 1; 1488 return 0; 1489} 1490 1491/** 1492 * hid_match_usage - check if driver's event should be called 1493 * 1494 * @hid: hid device 1495 * @usage: usage to match against 1496 * 1497 * compare hid->driver->usage_table->usage_{type,code} to 1498 * usage->usage_{type,code} 1499 */ 1500static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage) 1501{ 1502 const struct hid_usage_id *id = hid->driver->usage_table; 1503 1504 if (!id) /* NULL means all */ 1505 return 1; 1506 1507 for (; id->usage_type != HID_ANY_ID - 1; id++) 1508 if ((id->usage_hid == HID_ANY_ID || 1509 id->usage_hid == usage->hid) && 1510 (id->usage_type == HID_ANY_ID || 1511 id->usage_type == usage->type) && 1512 (id->usage_code == HID_ANY_ID || 1513 id->usage_code == usage->code)) 1514 return 1; 1515 return 0; 1516} 1517 1518static void hid_process_event(struct hid_device *hid, struct hid_field *field, 1519 struct hid_usage *usage, __s32 value, int interrupt) 1520{ 1521 struct hid_driver *hdrv = hid->driver; 1522 int ret; 1523 1524 if (!list_empty(&hid->debug_list)) 1525 hid_dump_input(hid, usage, value); 1526 1527 if (hdrv && hdrv->event && hid_match_usage(hid, usage)) { 1528 ret = hdrv->event(hid, field, usage, value); 1529 if (ret != 0) { 1530 if (ret < 0) 1531 hid_err(hid, "%s's event failed with %d\n", 1532 hdrv->name, ret); 1533 return; 1534 } 1535 } 1536 1537 if (hid->claimed & HID_CLAIMED_INPUT) 1538 hidinput_hid_event(hid, field, usage, value); 1539 if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event) 1540 hid->hiddev_hid_event(hid, field, usage, value); 1541} 1542 1543/* 1544 * Analyse a received field, and fetch the data from it. The field 1545 * content is stored for next report processing (we do differential 1546 * reporting to the layer). 1547 */ 1548 1549static void hid_input_field(struct hid_device *hid, struct hid_field *field, 1550 __u8 *data, int interrupt) 1551{ 1552 unsigned n; 1553 unsigned count = field->report_count; 1554 unsigned offset = field->report_offset; 1555 unsigned size = field->report_size; 1556 __s32 min = field->logical_minimum; 1557 __s32 max = field->logical_maximum; 1558 __s32 *value; 1559 1560 value = kmalloc_array(count, sizeof(__s32), GFP_ATOMIC); 1561 if (!value) 1562 return; 1563 1564 for (n = 0; n < count; n++) { 1565 1566 value[n] = min < 0 ? 1567 snto32(hid_field_extract(hid, data, offset + n * size, 1568 size), size) : 1569 hid_field_extract(hid, data, offset + n * size, size); 1570 1571 /* Ignore report if ErrorRollOver */ 1572 if (!(field->flags & HID_MAIN_ITEM_VARIABLE) && 1573 value[n] >= min && value[n] <= max && 1574 value[n] - min < field->maxusage && 1575 field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1) 1576 goto exit; 1577 } 1578 1579 for (n = 0; n < count; n++) { 1580 1581 if (HID_MAIN_ITEM_VARIABLE & field->flags) { 1582 hid_process_event(hid, field, &field->usage[n], value[n], interrupt); 1583 continue; 1584 } 1585 1586 if (field->value[n] >= min && field->value[n] <= max 1587 && field->value[n] - min < field->maxusage 1588 && field->usage[field->value[n] - min].hid 1589 && search(value, field->value[n], count)) 1590 hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt); 1591 1592 if (value[n] >= min && value[n] <= max 1593 && value[n] - min < field->maxusage 1594 && field->usage[value[n] - min].hid 1595 && search(field->value, value[n], count)) 1596 hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt); 1597 } 1598 1599 memcpy(field->value, value, count * sizeof(__s32)); 1600exit: 1601 kfree(value); 1602} 1603 1604/* 1605 * Output the field into the report. 1606 */ 1607 1608static void hid_output_field(const struct hid_device *hid, 1609 struct hid_field *field, __u8 *data) 1610{ 1611 unsigned count = field->report_count; 1612 unsigned offset = field->report_offset; 1613 unsigned size = field->report_size; 1614 unsigned n; 1615 1616 for (n = 0; n < count; n++) { 1617 if (field->logical_minimum < 0) /* signed values */ 1618 implement(hid, data, offset + n * size, size, 1619 s32ton(field->value[n], size)); 1620 else /* unsigned values */ 1621 implement(hid, data, offset + n * size, size, 1622 field->value[n]); 1623 } 1624} 1625 1626/* 1627 * Compute the size of a report. 1628 */ 1629static size_t hid_compute_report_size(struct hid_report *report) 1630{ 1631 if (report->size) 1632 return ((report->size - 1) >> 3) + 1; 1633 1634 return 0; 1635} 1636 1637/* 1638 * Create a report. 'data' has to be allocated using 1639 * hid_alloc_report_buf() so that it has proper size. 1640 */ 1641 1642void hid_output_report(struct hid_report *report, __u8 *data) 1643{ 1644 unsigned n; 1645 1646 if (report->id > 0) 1647 *data++ = report->id; 1648 1649 memset(data, 0, hid_compute_report_size(report)); 1650 for (n = 0; n < report->maxfield; n++) 1651 hid_output_field(report->device, report->field[n], data); 1652} 1653EXPORT_SYMBOL_GPL(hid_output_report); 1654 1655/* 1656 * Allocator for buffer that is going to be passed to hid_output_report() 1657 */ 1658u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags) 1659{ 1660 /* 1661 * 7 extra bytes are necessary to achieve proper functionality 1662 * of implement() working on 8 byte chunks 1663 */ 1664 1665 u32 len = hid_report_len(report) + 7; 1666 1667 return kmalloc(len, flags); 1668} 1669EXPORT_SYMBOL_GPL(hid_alloc_report_buf); 1670 1671/* 1672 * Set a field value. The report this field belongs to has to be 1673 * created and transferred to the device, to set this value in the 1674 * device. 1675 */ 1676 1677int hid_set_field(struct hid_field *field, unsigned offset, __s32 value) 1678{ 1679 unsigned size; 1680 1681 if (!field) 1682 return -1; 1683 1684 size = field->report_size; 1685 1686 hid_dump_input(field->report->device, field->usage + offset, value); 1687 1688 if (offset >= field->report_count) { 1689 hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n", 1690 offset, field->report_count); 1691 return -1; 1692 } 1693 if (field->logical_minimum < 0) { 1694 if (value != snto32(s32ton(value, size), size)) { 1695 hid_err(field->report->device, "value %d is out of range\n", value); 1696 return -1; 1697 } 1698 } 1699 field->value[offset] = value; 1700 return 0; 1701} 1702EXPORT_SYMBOL_GPL(hid_set_field); 1703 1704static struct hid_report *hid_get_report(struct hid_report_enum *report_enum, 1705 const u8 *data) 1706{ 1707 struct hid_report *report; 1708 unsigned int n = 0; /* Normally report number is 0 */ 1709 1710 /* Device uses numbered reports, data[0] is report number */ 1711 if (report_enum->numbered) 1712 n = *data; 1713 1714 report = report_enum->report_id_hash[n]; 1715 if (report == NULL) 1716 dbg_hid("undefined report_id %u received\n", n); 1717 1718 return report; 1719} 1720 1721/* 1722 * Implement a generic .request() callback, using .raw_request() 1723 * DO NOT USE in hid drivers directly, but through hid_hw_request instead. 1724 */ 1725int __hid_request(struct hid_device *hid, struct hid_report *report, 1726 int reqtype) 1727{ 1728 char *buf; 1729 int ret; 1730 u32 len; 1731 1732 buf = hid_alloc_report_buf(report, GFP_KERNEL); 1733 if (!buf) 1734 return -ENOMEM; 1735 1736 len = hid_report_len(report); 1737 1738 if (reqtype == HID_REQ_SET_REPORT) 1739 hid_output_report(report, buf); 1740 1741 ret = hid->ll_driver->raw_request(hid, report->id, buf, len, 1742 report->type, reqtype); 1743 if (ret < 0) { 1744 dbg_hid("unable to complete request: %d\n", ret); 1745 goto out; 1746 } 1747 1748 if (reqtype == HID_REQ_GET_REPORT) 1749 hid_input_report(hid, report->type, buf, ret, 0); 1750 1751 ret = 0; 1752 1753out: 1754 kfree(buf); 1755 return ret; 1756} 1757EXPORT_SYMBOL_GPL(__hid_request); 1758 1759int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size, 1760 int interrupt) 1761{ 1762 struct hid_report_enum *report_enum = hid->report_enum + type; 1763 struct hid_report *report; 1764 struct hid_driver *hdrv; 1765 int max_buffer_size = HID_MAX_BUFFER_SIZE; 1766 unsigned int a; 1767 u32 rsize, csize = size; 1768 u8 *cdata = data; 1769 int ret = 0; 1770 1771 report = hid_get_report(report_enum, data); 1772 if (!report) 1773 goto out; 1774 1775 if (report_enum->numbered) { 1776 cdata++; 1777 csize--; 1778 } 1779 1780 rsize = hid_compute_report_size(report); 1781 1782 if (hid->ll_driver->max_buffer_size) 1783 max_buffer_size = hid->ll_driver->max_buffer_size; 1784 1785 if (report_enum->numbered && rsize >= max_buffer_size) 1786 rsize = max_buffer_size - 1; 1787 else if (rsize > max_buffer_size) 1788 rsize = max_buffer_size; 1789 1790 if (csize < rsize) { 1791 dbg_hid("report %d is too short, (%d < %d)\n", report->id, 1792 csize, rsize); 1793 memset(cdata + csize, 0, rsize - csize); 1794 } 1795 1796 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event) 1797 hid->hiddev_report_event(hid, report); 1798 if (hid->claimed & HID_CLAIMED_HIDRAW) { 1799 ret = hidraw_report_event(hid, data, size); 1800 if (ret) 1801 goto out; 1802 } 1803 1804 if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) { 1805 for (a = 0; a < report->maxfield; a++) 1806 hid_input_field(hid, report->field[a], cdata, interrupt); 1807 hdrv = hid->driver; 1808 if (hdrv && hdrv->report) 1809 hdrv->report(hid, report); 1810 } 1811 1812 if (hid->claimed & HID_CLAIMED_INPUT) 1813 hidinput_report_event(hid, report); 1814out: 1815 return ret; 1816} 1817EXPORT_SYMBOL_GPL(hid_report_raw_event); 1818 1819/** 1820 * hid_input_report - report data from lower layer (usb, bt...) 1821 * 1822 * @hid: hid device 1823 * @type: HID report type (HID_*_REPORT) 1824 * @data: report contents 1825 * @size: size of data parameter 1826 * @interrupt: distinguish between interrupt and control transfers 1827 * 1828 * This is data entry for lower layers. 1829 */ 1830int hid_input_report(struct hid_device *hid, int type, u8 *data, u32 size, int interrupt) 1831{ 1832 struct hid_report_enum *report_enum; 1833 struct hid_driver *hdrv; 1834 struct hid_report *report; 1835 int ret = 0; 1836 1837 if (!hid) 1838 return -ENODEV; 1839 1840 if (down_trylock(&hid->driver_input_lock)) 1841 return -EBUSY; 1842 1843 if (!hid->driver) { 1844 ret = -ENODEV; 1845 goto unlock; 1846 } 1847 report_enum = hid->report_enum + type; 1848 hdrv = hid->driver; 1849 1850 if (!size) { 1851 dbg_hid("empty report\n"); 1852 ret = -1; 1853 goto unlock; 1854 } 1855 1856 /* Avoid unnecessary overhead if debugfs is disabled */ 1857 if (!list_empty(&hid->debug_list)) 1858 hid_dump_report(hid, type, data, size); 1859 1860 report = hid_get_report(report_enum, data); 1861 1862 if (!report) { 1863 ret = -1; 1864 goto unlock; 1865 } 1866 1867 if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) { 1868 ret = hdrv->raw_event(hid, report, data, size); 1869 if (ret < 0) 1870 goto unlock; 1871 } 1872 1873 ret = hid_report_raw_event(hid, type, data, size, interrupt); 1874 1875unlock: 1876 up(&hid->driver_input_lock); 1877 return ret; 1878} 1879EXPORT_SYMBOL_GPL(hid_input_report); 1880 1881bool hid_match_one_id(const struct hid_device *hdev, 1882 const struct hid_device_id *id) 1883{ 1884 return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) && 1885 (id->group == HID_GROUP_ANY || id->group == hdev->group) && 1886 (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) && 1887 (id->product == HID_ANY_ID || id->product == hdev->product); 1888} 1889 1890const struct hid_device_id *hid_match_id(const struct hid_device *hdev, 1891 const struct hid_device_id *id) 1892{ 1893 for (; id->bus; id++) 1894 if (hid_match_one_id(hdev, id)) 1895 return id; 1896 1897 return NULL; 1898} 1899 1900static const struct hid_device_id hid_hiddev_list[] = { 1901 { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) }, 1902 { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) }, 1903 { } 1904}; 1905 1906static bool hid_hiddev(struct hid_device *hdev) 1907{ 1908 return !!hid_match_id(hdev, hid_hiddev_list); 1909} 1910 1911 1912static ssize_t 1913read_report_descriptor(struct file *filp, struct kobject *kobj, 1914 struct bin_attribute *attr, 1915 char *buf, loff_t off, size_t count) 1916{ 1917 struct device *dev = kobj_to_dev(kobj); 1918 struct hid_device *hdev = to_hid_device(dev); 1919 1920 if (off >= hdev->rsize) 1921 return 0; 1922 1923 if (off + count > hdev->rsize) 1924 count = hdev->rsize - off; 1925 1926 memcpy(buf, hdev->rdesc + off, count); 1927 1928 return count; 1929} 1930 1931static ssize_t 1932show_country(struct device *dev, struct device_attribute *attr, 1933 char *buf) 1934{ 1935 struct hid_device *hdev = to_hid_device(dev); 1936 1937 return sprintf(buf, "%02x\n", hdev->country & 0xff); 1938} 1939 1940static struct bin_attribute dev_bin_attr_report_desc = { 1941 .attr = { .name = "report_descriptor", .mode = 0444 }, 1942 .read = read_report_descriptor, 1943 .size = HID_MAX_DESCRIPTOR_SIZE, 1944}; 1945 1946static const struct device_attribute dev_attr_country = { 1947 .attr = { .name = "country", .mode = 0444 }, 1948 .show = show_country, 1949}; 1950 1951int hid_connect(struct hid_device *hdev, unsigned int connect_mask) 1952{ 1953 static const char *types[] = { "Device", "Pointer", "Mouse", "Device", 1954 "Joystick", "Gamepad", "Keyboard", "Keypad", 1955 "Multi-Axis Controller" 1956 }; 1957 const char *type, *bus; 1958 char buf[64] = ""; 1959 unsigned int i; 1960 int len; 1961 int ret; 1962 1963 if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE) 1964 connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV); 1965 if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE) 1966 connect_mask |= HID_CONNECT_HIDINPUT_FORCE; 1967 if (hdev->bus != BUS_USB) 1968 connect_mask &= ~HID_CONNECT_HIDDEV; 1969 if (hid_hiddev(hdev)) 1970 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 1971 1972 if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev, 1973 connect_mask & HID_CONNECT_HIDINPUT_FORCE)) 1974 hdev->claimed |= HID_CLAIMED_INPUT; 1975 1976 if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect && 1977 !hdev->hiddev_connect(hdev, 1978 connect_mask & HID_CONNECT_HIDDEV_FORCE)) 1979 hdev->claimed |= HID_CLAIMED_HIDDEV; 1980 if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev)) 1981 hdev->claimed |= HID_CLAIMED_HIDRAW; 1982 1983 if (connect_mask & HID_CONNECT_DRIVER) 1984 hdev->claimed |= HID_CLAIMED_DRIVER; 1985 1986 /* Drivers with the ->raw_event callback set are not required to connect 1987 * to any other listener. */ 1988 if (!hdev->claimed && !hdev->driver->raw_event) { 1989 hid_err(hdev, "device has no listeners, quitting\n"); 1990 return -ENODEV; 1991 } 1992 1993 if ((hdev->claimed & HID_CLAIMED_INPUT) && 1994 (connect_mask & HID_CONNECT_FF) && hdev->ff_init) 1995 hdev->ff_init(hdev); 1996 1997 len = 0; 1998 if (hdev->claimed & HID_CLAIMED_INPUT) 1999 len += sprintf(buf + len, "input"); 2000 if (hdev->claimed & HID_CLAIMED_HIDDEV) 2001 len += sprintf(buf + len, "%shiddev%d", len ? "," : "", 2002 ((struct hiddev *)hdev->hiddev)->minor); 2003 if (hdev->claimed & HID_CLAIMED_HIDRAW) 2004 len += sprintf(buf + len, "%shidraw%d", len ? "," : "", 2005 ((struct hidraw *)hdev->hidraw)->minor); 2006 2007 type = "Device"; 2008 for (i = 0; i < hdev->maxcollection; i++) { 2009 struct hid_collection *col = &hdev->collection[i]; 2010 if (col->type == HID_COLLECTION_APPLICATION && 2011 (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK && 2012 (col->usage & 0xffff) < ARRAY_SIZE(types)) { 2013 type = types[col->usage & 0xffff]; 2014 break; 2015 } 2016 } 2017 2018 switch (hdev->bus) { 2019 case BUS_USB: 2020 bus = "USB"; 2021 break; 2022 case BUS_BLUETOOTH: 2023 bus = "BLUETOOTH"; 2024 break; 2025 case BUS_I2C: 2026 bus = "I2C"; 2027 break; 2028 case BUS_VIRTUAL: 2029 bus = "VIRTUAL"; 2030 break; 2031 default: 2032 bus = "<UNKNOWN>"; 2033 } 2034 2035 ret = device_create_file(&hdev->dev, &dev_attr_country); 2036 if (ret) 2037 hid_warn(hdev, 2038 "can't create sysfs country code attribute err: %d\n", ret); 2039 2040 hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n", 2041 buf, bus, hdev->version >> 8, hdev->version & 0xff, 2042 type, hdev->name, hdev->phys); 2043 2044 return 0; 2045} 2046EXPORT_SYMBOL_GPL(hid_connect); 2047 2048void hid_disconnect(struct hid_device *hdev) 2049{ 2050 device_remove_file(&hdev->dev, &dev_attr_country); 2051 if (hdev->claimed & HID_CLAIMED_INPUT) 2052 hidinput_disconnect(hdev); 2053 if (hdev->claimed & HID_CLAIMED_HIDDEV) 2054 hdev->hiddev_disconnect(hdev); 2055 if (hdev->claimed & HID_CLAIMED_HIDRAW) 2056 hidraw_disconnect(hdev); 2057 hdev->claimed = 0; 2058} 2059EXPORT_SYMBOL_GPL(hid_disconnect); 2060 2061/** 2062 * hid_hw_start - start underlying HW 2063 * @hdev: hid device 2064 * @connect_mask: which outputs to connect, see HID_CONNECT_* 2065 * 2066 * Call this in probe function *after* hid_parse. This will setup HW 2067 * buffers and start the device (if not defeirred to device open). 2068 * hid_hw_stop must be called if this was successful. 2069 */ 2070int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask) 2071{ 2072 int error; 2073 2074 error = hdev->ll_driver->start(hdev); 2075 if (error) 2076 return error; 2077 2078 if (connect_mask) { 2079 error = hid_connect(hdev, connect_mask); 2080 if (error) { 2081 hdev->ll_driver->stop(hdev); 2082 return error; 2083 } 2084 } 2085 2086 return 0; 2087} 2088EXPORT_SYMBOL_GPL(hid_hw_start); 2089 2090/** 2091 * hid_hw_stop - stop underlying HW 2092 * @hdev: hid device 2093 * 2094 * This is usually called from remove function or from probe when something 2095 * failed and hid_hw_start was called already. 2096 */ 2097void hid_hw_stop(struct hid_device *hdev) 2098{ 2099 hid_disconnect(hdev); 2100 hdev->ll_driver->stop(hdev); 2101} 2102EXPORT_SYMBOL_GPL(hid_hw_stop); 2103 2104/** 2105 * hid_hw_open - signal underlying HW to start delivering events 2106 * @hdev: hid device 2107 * 2108 * Tell underlying HW to start delivering events from the device. 2109 * This function should be called sometime after successful call 2110 * to hid_hw_start(). 2111 */ 2112int hid_hw_open(struct hid_device *hdev) 2113{ 2114 int ret; 2115 2116 ret = mutex_lock_killable(&hdev->ll_open_lock); 2117 if (ret) 2118 return ret; 2119 2120 if (!hdev->ll_open_count++) { 2121 ret = hdev->ll_driver->open(hdev); 2122 if (ret) 2123 hdev->ll_open_count--; 2124 } 2125 2126 mutex_unlock(&hdev->ll_open_lock); 2127 return ret; 2128} 2129EXPORT_SYMBOL_GPL(hid_hw_open); 2130 2131/** 2132 * hid_hw_close - signal underlaying HW to stop delivering events 2133 * 2134 * @hdev: hid device 2135 * 2136 * This function indicates that we are not interested in the events 2137 * from this device anymore. Delivery of events may or may not stop, 2138 * depending on the number of users still outstanding. 2139 */ 2140void hid_hw_close(struct hid_device *hdev) 2141{ 2142 mutex_lock(&hdev->ll_open_lock); 2143 if (!--hdev->ll_open_count) 2144 hdev->ll_driver->close(hdev); 2145 mutex_unlock(&hdev->ll_open_lock); 2146} 2147EXPORT_SYMBOL_GPL(hid_hw_close); 2148 2149struct hid_dynid { 2150 struct list_head list; 2151 struct hid_device_id id; 2152}; 2153 2154/** 2155 * store_new_id - add a new HID device ID to this driver and re-probe devices 2156 * @drv: target device driver 2157 * @buf: buffer for scanning device ID data 2158 * @count: input size 2159 * 2160 * Adds a new dynamic hid device ID to this driver, 2161 * and causes the driver to probe for all devices again. 2162 */ 2163static ssize_t new_id_store(struct device_driver *drv, const char *buf, 2164 size_t count) 2165{ 2166 struct hid_driver *hdrv = to_hid_driver(drv); 2167 struct hid_dynid *dynid; 2168 __u32 bus, vendor, product; 2169 unsigned long driver_data = 0; 2170 int ret; 2171 2172 ret = sscanf(buf, "%x %x %x %lx", 2173 &bus, &vendor, &product, &driver_data); 2174 if (ret < 3) 2175 return -EINVAL; 2176 2177 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); 2178 if (!dynid) 2179 return -ENOMEM; 2180 2181 dynid->id.bus = bus; 2182 dynid->id.group = HID_GROUP_ANY; 2183 dynid->id.vendor = vendor; 2184 dynid->id.product = product; 2185 dynid->id.driver_data = driver_data; 2186 2187 spin_lock(&hdrv->dyn_lock); 2188 list_add_tail(&dynid->list, &hdrv->dyn_list); 2189 spin_unlock(&hdrv->dyn_lock); 2190 2191 ret = driver_attach(&hdrv->driver); 2192 2193 return ret ? : count; 2194} 2195static DRIVER_ATTR_WO(new_id); 2196 2197static struct attribute *hid_drv_attrs[] = { 2198 &driver_attr_new_id.attr, 2199 NULL, 2200}; 2201ATTRIBUTE_GROUPS(hid_drv); 2202 2203static void hid_free_dynids(struct hid_driver *hdrv) 2204{ 2205 struct hid_dynid *dynid, *n; 2206 2207 spin_lock(&hdrv->dyn_lock); 2208 list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) { 2209 list_del(&dynid->list); 2210 kfree(dynid); 2211 } 2212 spin_unlock(&hdrv->dyn_lock); 2213} 2214 2215const struct hid_device_id *hid_match_device(struct hid_device *hdev, 2216 struct hid_driver *hdrv) 2217{ 2218 struct hid_dynid *dynid; 2219 2220 spin_lock(&hdrv->dyn_lock); 2221 list_for_each_entry(dynid, &hdrv->dyn_list, list) { 2222 if (hid_match_one_id(hdev, &dynid->id)) { 2223 spin_unlock(&hdrv->dyn_lock); 2224 return &dynid->id; 2225 } 2226 } 2227 spin_unlock(&hdrv->dyn_lock); 2228 2229 return hid_match_id(hdev, hdrv->id_table); 2230} 2231EXPORT_SYMBOL_GPL(hid_match_device); 2232 2233static int hid_bus_match(struct device *dev, struct device_driver *drv) 2234{ 2235 struct hid_driver *hdrv = to_hid_driver(drv); 2236 struct hid_device *hdev = to_hid_device(dev); 2237 2238 return hid_match_device(hdev, hdrv) != NULL; 2239} 2240 2241/** 2242 * hid_compare_device_paths - check if both devices share the same path 2243 * @hdev_a: hid device 2244 * @hdev_b: hid device 2245 * @separator: char to use as separator 2246 * 2247 * Check if two devices share the same path up to the last occurrence of 2248 * the separator char. Both paths must exist (i.e., zero-length paths 2249 * don't match). 2250 */ 2251bool hid_compare_device_paths(struct hid_device *hdev_a, 2252 struct hid_device *hdev_b, char separator) 2253{ 2254 int n1 = strrchr(hdev_a->phys, separator) - hdev_a->phys; 2255 int n2 = strrchr(hdev_b->phys, separator) - hdev_b->phys; 2256 2257 if (n1 != n2 || n1 <= 0 || n2 <= 0) 2258 return false; 2259 2260 return !strncmp(hdev_a->phys, hdev_b->phys, n1); 2261} 2262EXPORT_SYMBOL_GPL(hid_compare_device_paths); 2263 2264static int hid_device_probe(struct device *dev) 2265{ 2266 struct hid_driver *hdrv = to_hid_driver(dev->driver); 2267 struct hid_device *hdev = to_hid_device(dev); 2268 const struct hid_device_id *id; 2269 int ret = 0; 2270 2271 if (down_interruptible(&hdev->driver_input_lock)) { 2272 ret = -EINTR; 2273 goto end; 2274 } 2275 hdev->io_started = false; 2276 2277 clear_bit(ffs(HID_STAT_REPROBED), &hdev->status); 2278 2279 if (!hdev->driver) { 2280 id = hid_match_device(hdev, hdrv); 2281 if (id == NULL) { 2282 ret = -ENODEV; 2283 goto unlock; 2284 } 2285 2286 if (hdrv->match) { 2287 if (!hdrv->match(hdev, hid_ignore_special_drivers)) { 2288 ret = -ENODEV; 2289 goto unlock; 2290 } 2291 } else { 2292 /* 2293 * hid-generic implements .match(), so if 2294 * hid_ignore_special_drivers is set, we can safely 2295 * return. 2296 */ 2297 if (hid_ignore_special_drivers) { 2298 ret = -ENODEV; 2299 goto unlock; 2300 } 2301 } 2302 2303 /* reset the quirks that has been previously set */ 2304 hdev->quirks = hid_lookup_quirk(hdev); 2305 hdev->driver = hdrv; 2306 if (hdrv->probe) { 2307 ret = hdrv->probe(hdev, id); 2308 } else { /* default probe */ 2309 ret = hid_open_report(hdev); 2310 if (!ret) 2311 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 2312 } 2313 if (ret) { 2314 hid_close_report(hdev); 2315 hdev->driver = NULL; 2316 } 2317 } 2318unlock: 2319 if (!hdev->io_started) 2320 up(&hdev->driver_input_lock); 2321end: 2322 return ret; 2323} 2324 2325static int hid_device_remove(struct device *dev) 2326{ 2327 struct hid_device *hdev = to_hid_device(dev); 2328 struct hid_driver *hdrv; 2329 2330 down(&hdev->driver_input_lock); 2331 hdev->io_started = false; 2332 2333 hdrv = hdev->driver; 2334 if (hdrv) { 2335 if (hdrv->remove) 2336 hdrv->remove(hdev); 2337 else /* default remove */ 2338 hid_hw_stop(hdev); 2339 hid_close_report(hdev); 2340 hdev->driver = NULL; 2341 } 2342 2343 if (!hdev->io_started) 2344 up(&hdev->driver_input_lock); 2345 2346 return 0; 2347} 2348 2349static ssize_t modalias_show(struct device *dev, struct device_attribute *a, 2350 char *buf) 2351{ 2352 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 2353 2354 return scnprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n", 2355 hdev->bus, hdev->group, hdev->vendor, hdev->product); 2356} 2357static DEVICE_ATTR_RO(modalias); 2358 2359static struct attribute *hid_dev_attrs[] = { 2360 &dev_attr_modalias.attr, 2361 NULL, 2362}; 2363static struct bin_attribute *hid_dev_bin_attrs[] = { 2364 &dev_bin_attr_report_desc, 2365 NULL 2366}; 2367static const struct attribute_group hid_dev_group = { 2368 .attrs = hid_dev_attrs, 2369 .bin_attrs = hid_dev_bin_attrs, 2370}; 2371__ATTRIBUTE_GROUPS(hid_dev); 2372 2373static int hid_uevent(struct device *dev, struct kobj_uevent_env *env) 2374{ 2375 struct hid_device *hdev = to_hid_device(dev); 2376 2377 if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X", 2378 hdev->bus, hdev->vendor, hdev->product)) 2379 return -ENOMEM; 2380 2381 if (add_uevent_var(env, "HID_NAME=%s", hdev->name)) 2382 return -ENOMEM; 2383 2384 if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys)) 2385 return -ENOMEM; 2386 2387 if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq)) 2388 return -ENOMEM; 2389 2390 if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X", 2391 hdev->bus, hdev->group, hdev->vendor, hdev->product)) 2392 return -ENOMEM; 2393 2394 return 0; 2395} 2396 2397struct bus_type hid_bus_type = { 2398 .name = "hid", 2399 .dev_groups = hid_dev_groups, 2400 .drv_groups = hid_drv_groups, 2401 .match = hid_bus_match, 2402 .probe = hid_device_probe, 2403 .remove = hid_device_remove, 2404 .uevent = hid_uevent, 2405}; 2406EXPORT_SYMBOL(hid_bus_type); 2407 2408int hid_add_device(struct hid_device *hdev) 2409{ 2410 static atomic_t id = ATOMIC_INIT(0); 2411 int ret; 2412 2413 if (WARN_ON(hdev->status & HID_STAT_ADDED)) 2414 return -EBUSY; 2415 2416 hdev->quirks = hid_lookup_quirk(hdev); 2417 2418 /* we need to kill them here, otherwise they will stay allocated to 2419 * wait for coming driver */ 2420 if (hid_ignore(hdev)) 2421 return -ENODEV; 2422 2423 /* 2424 * Check for the mandatory transport channel. 2425 */ 2426 if (!hdev->ll_driver->raw_request) { 2427 hid_err(hdev, "transport driver missing .raw_request()\n"); 2428 return -EINVAL; 2429 } 2430 2431 /* 2432 * Read the device report descriptor once and use as template 2433 * for the driver-specific modifications. 2434 */ 2435 ret = hdev->ll_driver->parse(hdev); 2436 if (ret) 2437 return ret; 2438 if (!hdev->dev_rdesc) 2439 return -ENODEV; 2440 2441 /* 2442 * Scan generic devices for group information 2443 */ 2444 if (hid_ignore_special_drivers) { 2445 hdev->group = HID_GROUP_GENERIC; 2446 } else if (!hdev->group && 2447 !(hdev->quirks & HID_QUIRK_HAVE_SPECIAL_DRIVER)) { 2448 ret = hid_scan_report(hdev); 2449 if (ret) 2450 hid_warn(hdev, "bad device descriptor (%d)\n", ret); 2451 } 2452 2453 hdev->id = atomic_inc_return(&id); 2454 2455 /* XXX hack, any other cleaner solution after the driver core 2456 * is converted to allow more than 20 bytes as the device name? */ 2457 dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus, 2458 hdev->vendor, hdev->product, hdev->id); 2459 2460 hid_debug_register(hdev, dev_name(&hdev->dev)); 2461 ret = device_add(&hdev->dev); 2462 if (!ret) 2463 hdev->status |= HID_STAT_ADDED; 2464 else 2465 hid_debug_unregister(hdev); 2466 2467 return ret; 2468} 2469EXPORT_SYMBOL_GPL(hid_add_device); 2470 2471/** 2472 * hid_allocate_device - allocate new hid device descriptor 2473 * 2474 * Allocate and initialize hid device, so that hid_destroy_device might be 2475 * used to free it. 2476 * 2477 * New hid_device pointer is returned on success, otherwise ERR_PTR encoded 2478 * error value. 2479 */ 2480struct hid_device *hid_allocate_device(void) 2481{ 2482 struct hid_device *hdev; 2483 int ret = -ENOMEM; 2484 2485 hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 2486 if (hdev == NULL) 2487 return ERR_PTR(ret); 2488 2489 device_initialize(&hdev->dev); 2490 hdev->dev.release = hid_device_release; 2491 hdev->dev.bus = &hid_bus_type; 2492 device_enable_async_suspend(&hdev->dev); 2493 2494 hid_close_report(hdev); 2495 2496 init_waitqueue_head(&hdev->debug_wait); 2497 INIT_LIST_HEAD(&hdev->debug_list); 2498 spin_lock_init(&hdev->debug_list_lock); 2499 sema_init(&hdev->driver_input_lock, 1); 2500 mutex_init(&hdev->ll_open_lock); 2501 kref_init(&hdev->ref); 2502 2503 return hdev; 2504} 2505EXPORT_SYMBOL_GPL(hid_allocate_device); 2506 2507static void hid_remove_device(struct hid_device *hdev) 2508{ 2509 if (hdev->status & HID_STAT_ADDED) { 2510 device_del(&hdev->dev); 2511 hid_debug_unregister(hdev); 2512 hdev->status &= ~HID_STAT_ADDED; 2513 } 2514 kfree(hdev->dev_rdesc); 2515 hdev->dev_rdesc = NULL; 2516 hdev->dev_rsize = 0; 2517} 2518 2519/** 2520 * hid_destroy_device - free previously allocated device 2521 * 2522 * @hdev: hid device 2523 * 2524 * If you allocate hid_device through hid_allocate_device, you should ever 2525 * free by this function. 2526 */ 2527void hid_destroy_device(struct hid_device *hdev) 2528{ 2529 hid_remove_device(hdev); 2530 put_device(&hdev->dev); 2531} 2532EXPORT_SYMBOL_GPL(hid_destroy_device); 2533 2534 2535static int __hid_bus_reprobe_drivers(struct device *dev, void *data) 2536{ 2537 struct hid_driver *hdrv = data; 2538 struct hid_device *hdev = to_hid_device(dev); 2539 2540 if (hdev->driver == hdrv && 2541 !hdrv->match(hdev, hid_ignore_special_drivers) && 2542 !test_and_set_bit(ffs(HID_STAT_REPROBED), &hdev->status)) 2543 return device_reprobe(dev); 2544 2545 return 0; 2546} 2547 2548static int __hid_bus_driver_added(struct device_driver *drv, void *data) 2549{ 2550 struct hid_driver *hdrv = to_hid_driver(drv); 2551 2552 if (hdrv->match) { 2553 bus_for_each_dev(&hid_bus_type, NULL, hdrv, 2554 __hid_bus_reprobe_drivers); 2555 } 2556 2557 return 0; 2558} 2559 2560static int __bus_removed_driver(struct device_driver *drv, void *data) 2561{ 2562 return bus_rescan_devices(&hid_bus_type); 2563} 2564 2565int __hid_register_driver(struct hid_driver *hdrv, struct module *owner, 2566 const char *mod_name) 2567{ 2568 int ret; 2569 2570 hdrv->driver.name = hdrv->name; 2571 hdrv->driver.bus = &hid_bus_type; 2572 hdrv->driver.owner = owner; 2573 hdrv->driver.mod_name = mod_name; 2574 2575 INIT_LIST_HEAD(&hdrv->dyn_list); 2576 spin_lock_init(&hdrv->dyn_lock); 2577 2578 ret = driver_register(&hdrv->driver); 2579 2580 if (ret == 0) 2581 bus_for_each_drv(&hid_bus_type, NULL, NULL, 2582 __hid_bus_driver_added); 2583 2584 return ret; 2585} 2586EXPORT_SYMBOL_GPL(__hid_register_driver); 2587 2588void hid_unregister_driver(struct hid_driver *hdrv) 2589{ 2590 driver_unregister(&hdrv->driver); 2591 hid_free_dynids(hdrv); 2592 2593 bus_for_each_drv(&hid_bus_type, NULL, hdrv, __bus_removed_driver); 2594} 2595EXPORT_SYMBOL_GPL(hid_unregister_driver); 2596 2597int hid_check_keys_pressed(struct hid_device *hid) 2598{ 2599 struct hid_input *hidinput; 2600 int i; 2601 2602 if (!(hid->claimed & HID_CLAIMED_INPUT)) 2603 return 0; 2604 2605 list_for_each_entry(hidinput, &hid->inputs, list) { 2606 for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++) 2607 if (hidinput->input->key[i]) 2608 return 1; 2609 } 2610 2611 return 0; 2612} 2613 2614EXPORT_SYMBOL_GPL(hid_check_keys_pressed); 2615 2616static int __init hid_init(void) 2617{ 2618 int ret; 2619 2620 if (hid_debug) 2621 pr_warn("hid_debug is now used solely for parser and driver debugging.\n" 2622 "debugfs is now used for inspecting the device (report descriptor, reports)\n"); 2623 2624 ret = bus_register(&hid_bus_type); 2625 if (ret) { 2626 pr_err("can't register hid bus\n"); 2627 goto err; 2628 } 2629 2630 ret = hidraw_init(); 2631 if (ret) 2632 goto err_bus; 2633 2634 hid_debug_init(); 2635 2636 return 0; 2637err_bus: 2638 bus_unregister(&hid_bus_type); 2639err: 2640 return ret; 2641} 2642 2643static void __exit hid_exit(void) 2644{ 2645 hid_debug_exit(); 2646 hidraw_exit(); 2647 bus_unregister(&hid_bus_type); 2648 hid_quirks_exit(HID_BUS_ANY); 2649} 2650 2651module_init(hid_init); 2652module_exit(hid_exit); 2653 2654MODULE_AUTHOR("Andreas Gal"); 2655MODULE_AUTHOR("Vojtech Pavlik"); 2656MODULE_AUTHOR("Jiri Kosina"); 2657MODULE_LICENSE("GPL"); 2658