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