Changeset f3b39b4 in mainline for uspace/lib/usbhid/src/hiddescriptor.c
- Timestamp:
- 2011-05-26T20:43:26Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- d861c22
- Parents:
- 14e1bcc
- File:
-
- 1 edited
-
uspace/lib/usbhid/src/hiddescriptor.c (modified) (31 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/usbhid/src/hiddescriptor.c
r14e1bcc rf3b39b4 41 41 #include <assert.h> 42 42 43 43 /*---------------------------------------------------------------------------*/ 44 /* 45 * Constants defining current parsing mode for correct parsing of the set of 46 * local tags (usage) enclosed in delimter tags. 47 */ 48 /** 49 * Second delimiter tag was read. The set of local items (usage) ended. 50 */ 44 51 #define OUTSIDE_DELIMITER_SET 0 52 53 /** 54 * First delimiter tag was read. The set of local items (usage) started. 55 */ 45 56 #define START_DELIMITER_SET 1 57 58 /** 59 * Parser is in the set of local items. 60 */ 46 61 #define INSIDE_DELIMITER_SET 2 62 63 /*---------------------------------------------------------------------------*/ 47 64 48 65 /** The new report item flag. Used to determine when the item is completly … … 61 78 #define USB_HID_UNKNOWN_TAG -99 62 79 63 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) 64 { 65 /* find or append current collection path to the list */ 66 //link_t *path_it = report->collection_paths.next; 80 /*---------------------------------------------------------------------------*/ 81 /** 82 * Checks if given collection path is already present in report structure and 83 * inserts it if not. 84 * 85 * @param report Report structure 86 * @param cmp_path The collection path 87 * @return Pointer to the result collection path in report structure. 88 * @retval NULL If some error occurs 89 */ 90 usb_hid_report_path_t *usb_hid_report_path_try_insert( 91 usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) { 92 67 93 link_t *path_it = report->collection_paths.prev->next; 68 94 usb_hid_report_path_t *path = NULL; 69 95 96 if((report == NULL) || (cmp_path == NULL)) { 97 return NULL; 98 } 70 99 71 100 while(path_it != &report->collection_paths) { 72 path = list_get_instance(path_it, usb_hid_report_path_t, link); 73 74 if(usb_hid_report_compare_usage_path(path, cmp_path, USB_HID_PATH_COMPARE_STRICT) == EOK){ 101 path = list_get_instance(path_it, usb_hid_report_path_t, 102 link); 103 104 if(usb_hid_report_compare_usage_path(path, cmp_path, 105 USB_HID_PATH_COMPARE_STRICT) == EOK){ 75 106 break; 76 107 } … … 78 109 } 79 110 if(path_it == &report->collection_paths) { 80 path = usb_hid_report_path_clone(cmp_path); 111 path = usb_hid_report_path_clone(cmp_path); 112 if(path == NULL) { 113 return NULL; 114 } 81 115 list_append(&path->link, &report->collection_paths); 82 116 report->collection_paths_count++; … … 85 119 } 86 120 else { 87 return list_get_instance(path_it, usb_hid_report_path_t, link); 88 } 89 } 90 121 return list_get_instance(path_it, usb_hid_report_path_t, 122 link); 123 } 124 } 125 126 /*---------------------------------------------------------------------------*/ 91 127 /** 92 128 * Initialize the report descriptor parser structure … … 94 130 * @param parser Report descriptor parser structure 95 131 * @return Error code 132 * @retval EINVAL If no report structure was given 133 * @retval EOK If report structure was successfully initialized 96 134 */ 97 135 int usb_hid_report_init(usb_hid_report_t *report) … … 109 147 } 110 148 111 112 /* 113 * 114 * 115 */ 116 int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item) 117 { 149 /*---------------------------------------------------------------------------*/ 150 151 /** 152 * 153 * 154 * @param report Report structure in which the new report items should be 155 * stored 156 * @param report_item Current report descriptor's parsing state table 157 * @return Error code 158 * @retval EOK If all fields were successfully append to report 159 * @retval EINVAL If invalid parameters (NULL) was given 160 * @retval ENOMEM If there is no memmory to store new report description 161 * 162 */ 163 int usb_hid_report_append_fields(usb_hid_report_t *report, 164 usb_hid_report_item_t *report_item) { 165 118 166 usb_hid_report_field_t *field; 119 167 int i; … … 121 169 uint32_t *usages; 122 170 int usages_used=0; 171 172 if((report == NULL) || (report_item == NULL)) { 173 return EINVAL; 174 } 175 123 176 if(report_item->usages_count > 0){ 124 177 usages = malloc(sizeof(int32_t) * report_item->usages_count); 125 memcpy(usages, report_item->usages, sizeof(int32_t) * report_item->usages_count); 178 memcpy(usages, report_item->usages, sizeof(int32_t) * 179 report_item->usages_count); 126 180 } 127 181 else { … … 144 198 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){ 145 199 /* 146 Store usage array. The Correct Usage Page and Usage is depending147 200 Store usage array. The Correct Usage Page and Usage is 201 depending on data in report and will be filled later 148 202 */ 149 203 field->usage = 0; … … 162 216 } 163 217 else { 164 usage = report_item->usages[report_item->usages_count - 1]; 218 usage = report_item->usages[ 219 report_item->usages_count- 1]; 165 220 } 166 221 167 222 if(USB_HID_IS_EXTENDED_USAGE(usage)){ 168 223 field->usage = USB_HID_EXTENDED_USAGE(usage); 169 field->usage_page = USB_HID_EXTENDED_USAGE_PAGE(usage); 224 field->usage_page = 225 USB_HID_EXTENDED_USAGE_PAGE(usage); 170 226 } 171 227 else { … … 176 232 } 177 233 178 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL, field->usage_page); 179 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL, field->usage); 180 181 field->collection_path = usb_hid_report_path_try_insert(report, path); 234 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL, 235 field->usage_page); 236 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL, 237 field->usage); 238 239 field->collection_path = 240 usb_hid_report_path_try_insert(report, path); 182 241 183 242 field->size = report_item->size; 184 243 185 size_t offset_byte = (report_item->offset + (i * report_item->size)) / 8; 186 size_t offset_bit = 8 - ((report_item->offset + (i * report_item->size)) % 8) - report_item->size; 244 size_t offset_byte = (report_item->offset + (i * 245 report_item->size)) / 8; 246 247 size_t offset_bit = 8 - ((report_item->offset + (i * 248 report_item->size)) % 8) - report_item->size; 187 249 188 250 field->offset = 8 * offset_byte + offset_bit; … … 195 257 /* find the right report list*/ 196 258 usb_hid_report_description_t *report_des; 197 report_des = usb_hid_report_find_description(report, report_item->id, report_item->type); 259 report_des = usb_hid_report_find_description(report, 260 report_item->id, report_item->type); 261 198 262 if(report_des == NULL){ 199 report_des = malloc(sizeof(usb_hid_report_description_t)); 200 memset(report_des, 0, sizeof(usb_hid_report_description_t)); 263 report_des = malloc( 264 sizeof(usb_hid_report_description_t)); 265 if(report_des == NULL) { 266 return ENOMEM; 267 } 268 269 memset(report_des, 0, 270 sizeof(usb_hid_report_description_t)); 201 271 202 272 report_des->type = report_item->type; … … 225 295 return EOK; 226 296 } 227 228 usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type) 229 { 297 /*---------------------------------------------------------------------------*/ 298 /** 299 * Finds description of report with given report_id and of given type in 300 * opaque report structure. 301 * 302 * @param report Opaque structure containing the parsed report descriptor 303 * @param report_id ReportId of report we are searching 304 * @param type Type of report we are searching 305 * @return Pointer to the particular report description 306 * @retval NULL If no description is founded 307 */ 308 usb_hid_report_description_t * usb_hid_report_find_description( 309 const usb_hid_report_t *report, uint8_t report_id, 310 usb_hid_report_type_t type) { 311 230 312 link_t *report_it = report->reports.next; 231 313 usb_hid_report_description_t *report_des = NULL; 232 314 233 315 while(report_it != &report->reports) { 234 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 235 236 if((report_des->report_id == report_id) && (report_des->type == type)){ 316 report_des = list_get_instance(report_it, 317 usb_hid_report_description_t, link); 318 319 if((report_des->report_id == report_id) && 320 (report_des->type == type)) { 237 321 return report_des; 238 322 } … … 243 327 return NULL; 244 328 } 329 /*---------------------------------------------------------------------------*/ 245 330 246 331 /** Parse HID report descriptor. … … 249 334 * @param data Data describing the report. 250 335 * @return Error code. 336 * @retval ENOMEM If no more memmory is available 337 * @retval EINVAL If invalid data are founded 338 * @retval EOK If report descriptor is successfully parsed 251 339 */ 252 340 int usb_hid_parse_report_descriptor(usb_hid_report_t *report, … … 299 387 300 388 ret = usb_hid_report_parse_tag(tag,class,data+i+1, 301 item_size,report_item, usage_path); 389 item_size,report_item, usage_path); 390 302 391 switch(ret){ 303 case USB_HID_NEW_REPORT_ITEM: 304 // store report item to report and create the new one 305 // store current collection path 306 report_item->usage_path = usage_path; 392 case USB_HID_NEW_REPORT_ITEM: 393 /* store report item to report and create the 394 * new one store current collection path 395 */ 396 report_item->usage_path = usage_path; 307 397 308 usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id); 309 if(report_item->id != 0){ 310 report->use_report_ids = 1; 311 } 398 usb_hid_report_path_set_report_id( 399 report_item->usage_path, report_item->id); 400 401 if(report_item->id != 0){ 402 report->use_report_ids = 1; 403 } 312 404 313 switch(tag) { 314 case USB_HID_REPORT_TAG_INPUT: 315 report_item->type = USB_HID_REPORT_TYPE_INPUT; 316 report_item->offset = offset_input; 317 offset_input += report_item->count * report_item->size; 318 break; 319 case USB_HID_REPORT_TAG_OUTPUT: 320 report_item->type = USB_HID_REPORT_TYPE_OUTPUT; 321 report_item->offset = offset_output; 322 offset_output += report_item->count * report_item->size; 323 324 break; 325 case USB_HID_REPORT_TAG_FEATURE: 326 report_item->type = USB_HID_REPORT_TYPE_FEATURE; 327 report_item->offset = offset_feature; 328 offset_feature += report_item->count * report_item->size; 329 break; 330 default: 331 usb_log_debug("\tjump over - tag %X\n", tag); 332 break; 333 } 405 switch(tag) { 406 case USB_HID_REPORT_TAG_INPUT: 407 report_item->type = 408 USB_HID_REPORT_TYPE_INPUT; 409 410 report_item->offset = offset_input; 411 offset_input += report_item->count * 412 report_item->size; 413 break; 414 415 case USB_HID_REPORT_TAG_OUTPUT: 416 report_item->type = 417 USB_HID_REPORT_TYPE_OUTPUT; 334 418 335 /* 336 * append new fields to the report 337 * structure 338 */ 339 usb_hid_report_append_fields(report, report_item); 340 341 /* reset local items */ 342 usb_hid_report_reset_local_items (report_item); 343 419 report_item->offset = offset_output; 420 offset_output += report_item->count * 421 report_item->size; 344 422 break; 345 346 case USB_HID_RESET_OFFSET: 347 offset_input = 0; 348 offset_output = 0; 349 offset_feature = 0; 350 usb_hid_report_path_set_report_id (usage_path, report_item->id); 423 424 case USB_HID_REPORT_TAG_FEATURE: 425 report_item->type = 426 USB_HID_REPORT_TYPE_FEATURE; 427 428 report_item->offset = offset_feature; 429 offset_feature += report_item->count * 430 report_item->size; 351 431 break; 352 353 case USB_HID_REPORT_TAG_PUSH: 354 // push current state to stack 355 new_report_item = usb_hid_report_item_clone(report_item); 356 usb_hid_report_path_t *tmp_path = usb_hid_report_path_clone(usage_path); 357 new_report_item->usage_path = tmp_path; 358 359 list_prepend (&new_report_item->link, &stack); 360 break; 361 case USB_HID_REPORT_TAG_POP: 362 // restore current state from stack 363 if(list_empty (&stack)) { 364 return EINVAL; 365 } 366 free(report_item); 432 433 default: 434 usb_log_debug2( 435 "\tjump over - tag %X\n", tag); 436 break; 437 } 438 439 /* 440 * append new fields to the report structure 441 */ 442 usb_hid_report_append_fields(report, 443 report_item); 444 445 /* reset local items */ 446 usb_hid_report_reset_local_items (report_item); 447 break; 448 449 case USB_HID_RESET_OFFSET: 450 offset_input = 0; 451 offset_output = 0; 452 offset_feature = 0; 453 usb_hid_report_path_set_report_id (usage_path, 454 report_item->id); 455 break; 456 457 case USB_HID_REPORT_TAG_PUSH: 458 // push current state to stack 459 new_report_item = usb_hid_report_item_clone( 460 report_item); 461 462 usb_hid_report_path_t *tmp_path = 463 usb_hid_report_path_clone(usage_path); 464 465 new_report_item->usage_path = tmp_path; 466 467 list_prepend (&new_report_item->link, &stack); 468 break; 469 case USB_HID_REPORT_TAG_POP: 470 // restore current state from stack 471 if(list_empty (&stack)) { 472 return EINVAL; 473 } 474 free(report_item); 367 475 368 report_item = list_get_instance(stack.next, usb_hid_report_item_t, link); 476 report_item = list_get_instance(stack.next, 477 usb_hid_report_item_t, link); 369 478 370 usb_hid_report_usage_path_t *tmp_usage_path; 371 tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link); 479 usb_hid_report_usage_path_t *tmp_usage_path; 480 tmp_usage_path = list_get_instance( 481 report_item->usage_path->link.prev, 482 usb_hid_report_usage_path_t, link); 372 483 373 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page); 374 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage); 375 376 usb_hid_report_path_free(report_item->usage_path); 377 list_initialize(&report_item->usage_path->link); 378 list_remove (stack.next); 484 usb_hid_report_set_last_item(usage_path, 485 USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page); 486 487 usb_hid_report_set_last_item(usage_path, 488 USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage); 489 490 usb_hid_report_path_free(report_item->usage_path); 491 list_initialize(&report_item->usage_path->link); 492 list_remove (stack.next); 379 493 380 494 break; 381 495 382 383 384 496 default: 497 // nothing special to do 498 break; 385 499 } 386 500 … … 399 513 } 400 514 515 /*---------------------------------------------------------------------------*/ 401 516 402 517 /** … … 409 524 * @return Code of action to be done next 410 525 */ 411 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, 412 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 413 { 526 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, 527 size_t item_size, usb_hid_report_item_t *report_item, 528 usb_hid_report_path_t *usage_path) { 529 414 530 int ret; 415 531 416 532 switch(class){ 417 case USB_HID_TAG_CLASS_MAIN: 418 419 if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) { 420 return USB_HID_NEW_REPORT_ITEM; 421 } 422 else { 423 /*TODO process the error */ 424 return ret; 425 } 426 break; 427 428 case USB_HID_TAG_CLASS_GLOBAL: 429 return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path); 430 break; 431 432 case USB_HID_TAG_CLASS_LOCAL: 433 return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path); 434 break; 435 default: 436 return USB_HID_NO_ACTION; 533 case USB_HID_TAG_CLASS_MAIN: 534 535 if((ret=usb_hid_report_parse_main_tag(tag, data, item_size, 536 report_item, usage_path)) == EOK) { 537 538 return USB_HID_NEW_REPORT_ITEM; 539 } 540 else { 541 return ret; 542 } 543 break; 544 545 case USB_HID_TAG_CLASS_GLOBAL: 546 return usb_hid_report_parse_global_tag(tag, data, item_size, 547 report_item, usage_path); 548 break; 549 550 case USB_HID_TAG_CLASS_LOCAL: 551 return usb_hid_report_parse_local_tag(tag, data, item_size, 552 report_item, usage_path); 553 break; 554 555 default: 556 return USB_HID_NO_ACTION; 437 557 } 438 558 } … … 448 568 */ 449 569 450 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size, 451 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 570 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, 571 size_t item_size, usb_hid_report_item_t *report_item, 572 usb_hid_report_path_t *usage_path) 452 573 { 453 574 usb_hid_report_usage_path_t *path_item; … … 455 576 switch(tag) 456 577 { 457 458 459 460 461 462 578 case USB_HID_REPORT_TAG_INPUT: 579 case USB_HID_REPORT_TAG_OUTPUT: 580 case USB_HID_REPORT_TAG_FEATURE: 581 report_item->item_flags = *data; 582 return EOK; 583 break; 463 584 464 case USB_HID_REPORT_TAG_COLLECTION: 465 466 // store collection atributes 467 path_item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link); 468 path_item->flags = *data; 585 case USB_HID_REPORT_TAG_COLLECTION: 586 587 /* store collection atributes */ 588 path_item = list_get_instance(usage_path->head.prev, 589 usb_hid_report_usage_path_t, link); 590 path_item->flags = *data; 469 591 470 // set last item 471 usb_hid_report_set_last_item(usage_path, 472 USB_HID_TAG_CLASS_GLOBAL, 473 USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[report_item->usages_count-1])); 474 usb_hid_report_set_last_item(usage_path, 475 USB_HID_TAG_CLASS_LOCAL, 476 USB_HID_EXTENDED_USAGE(report_item->usages[report_item->usages_count-1])); 592 /* set last item */ 593 usb_hid_report_set_last_item(usage_path, 594 USB_HID_TAG_CLASS_GLOBAL, 595 USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[ 596 report_item->usages_count-1])); 597 598 usb_hid_report_set_last_item(usage_path, 599 USB_HID_TAG_CLASS_LOCAL, 600 USB_HID_EXTENDED_USAGE(report_item->usages[ 601 report_item->usages_count-1])); 477 602 478 // append the new one which will be set by common 479 // usage/usage page 480 usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]); 481 usb_hid_report_reset_local_items (report_item); 482 return USB_HID_NO_ACTION; 483 break; 603 /* append the new one which will be set by common usage/usage 604 * page */ 605 usb_hid_report_path_append_item(usage_path, 606 report_item->usage_page, 607 report_item->usages[report_item->usages_count-1]); 608 609 usb_hid_report_reset_local_items (report_item); 610 return USB_HID_NO_ACTION; 611 break; 484 612 485 case USB_HID_REPORT_TAG_END_COLLECTION: 486 usb_hid_report_remove_last_item(usage_path); 487 return USB_HID_NO_ACTION; 488 break; 489 default: 490 return USB_HID_NO_ACTION; 613 case USB_HID_REPORT_TAG_END_COLLECTION: 614 usb_hid_report_remove_last_item(usage_path); 615 return USB_HID_NO_ACTION; 616 break; 617 618 default: 619 return USB_HID_NO_ACTION; 491 620 } 492 621 … … 503 632 * @return Error code 504 633 */ 505 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,506 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 507 { 508 // TODO take care about the bit length of data634 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, 635 size_t item_size, usb_hid_report_item_t *report_item, 636 usb_hid_report_path_t *usage_path) { 637 509 638 switch(tag) 510 639 { 511 case USB_HID_REPORT_TAG_USAGE_PAGE: 512 report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size); 513 break; 514 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM: 515 report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); 516 break; 517 case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM: 518 report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); 519 break; 520 case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM: 521 report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); 522 break; 523 case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM: 524 report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); 525 526 break; 527 case USB_HID_REPORT_TAG_UNIT_EXPONENT: 528 report_item->unit_exponent = usb_hid_report_tag_data_uint32(data,item_size); 529 break; 530 case USB_HID_REPORT_TAG_UNIT: 531 report_item->unit = usb_hid_report_tag_data_uint32(data,item_size); 532 break; 533 case USB_HID_REPORT_TAG_REPORT_SIZE: 534 report_item->size = usb_hid_report_tag_data_uint32(data,item_size); 535 break; 536 case USB_HID_REPORT_TAG_REPORT_COUNT: 537 report_item->count = usb_hid_report_tag_data_uint32(data,item_size); 538 break; 539 case USB_HID_REPORT_TAG_REPORT_ID: 540 report_item->id = usb_hid_report_tag_data_uint32(data,item_size); 541 return USB_HID_RESET_OFFSET; 542 break; 543 case USB_HID_REPORT_TAG_PUSH: 544 case USB_HID_REPORT_TAG_POP: 545 /* 546 * stack operations are done in top level parsing 547 * function 548 */ 549 return tag; 550 break; 640 case USB_HID_REPORT_TAG_USAGE_PAGE: 641 report_item->usage_page = 642 usb_hid_report_tag_data_uint32(data, item_size); 643 break; 644 645 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM: 646 report_item->logical_minimum = USB_HID_UINT32_TO_INT32( 647 usb_hid_report_tag_data_uint32(data,item_size), 648 item_size * 8); 649 break; 650 651 case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM: 652 report_item->logical_maximum = USB_HID_UINT32_TO_INT32( 653 usb_hid_report_tag_data_uint32(data,item_size), 654 item_size * 8); 655 break; 656 657 case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM: 658 report_item->physical_minimum = USB_HID_UINT32_TO_INT32( 659 usb_hid_report_tag_data_uint32(data,item_size), 660 item_size * 8); 661 break; 662 663 case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM: 664 report_item->physical_maximum = USB_HID_UINT32_TO_INT32( 665 usb_hid_report_tag_data_uint32(data,item_size), 666 item_size * 8); 667 break; 668 669 case USB_HID_REPORT_TAG_UNIT_EXPONENT: 670 report_item->unit_exponent = usb_hid_report_tag_data_uint32( 671 data,item_size); 672 break; 673 674 case USB_HID_REPORT_TAG_UNIT: 675 report_item->unit = usb_hid_report_tag_data_uint32( 676 data,item_size); 677 break; 678 679 case USB_HID_REPORT_TAG_REPORT_SIZE: 680 report_item->size = usb_hid_report_tag_data_uint32( 681 data,item_size); 682 break; 683 684 case USB_HID_REPORT_TAG_REPORT_COUNT: 685 report_item->count = usb_hid_report_tag_data_uint32( 686 data,item_size); 687 break; 688 689 case USB_HID_REPORT_TAG_REPORT_ID: 690 report_item->id = usb_hid_report_tag_data_uint32(data, 691 item_size); 692 return USB_HID_RESET_OFFSET; 693 break; 694 695 case USB_HID_REPORT_TAG_PUSH: 696 case USB_HID_REPORT_TAG_POP: 697 /* 698 * stack operations are done in top level parsing 699 * function 700 */ 701 return tag; 702 break; 551 703 552 553 704 default: 705 return USB_HID_NO_ACTION; 554 706 } 555 707 … … 566 718 * @return Error code 567 719 */ 568 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size, 569 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 720 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, 721 size_t item_size, usb_hid_report_item_t *report_item, 722 usb_hid_report_path_t *usage_path) 570 723 { 571 724 int32_t extended_usage; 572 725 573 726 switch(tag) { 574 case USB_HID_REPORT_TAG_USAGE: 575 switch(report_item->in_delimiter) { 576 case INSIDE_DELIMITER_SET: 577 // nothing to do 578 break; 579 case START_DELIMITER_SET: 580 report_item->in_delimiter = INSIDE_DELIMITER_SET; 581 case OUTSIDE_DELIMITER_SET: 582 extended_usage = ((report_item->usage_page) << 16); 583 extended_usage += usb_hid_report_tag_data_uint32(data,item_size); 584 report_item->usages[report_item->usages_count] = extended_usage; 585 report_item->usages_count++; 586 break; 727 case USB_HID_REPORT_TAG_USAGE: 728 switch(report_item->in_delimiter) { 729 case INSIDE_DELIMITER_SET: 730 /* nothing to do 731 * we catch only the first one 732 */ 733 break; 734 735 case START_DELIMITER_SET: 736 report_item->in_delimiter = INSIDE_DELIMITER_SET; 737 case OUTSIDE_DELIMITER_SET: 738 extended_usage = ((report_item->usage_page) << 16); 739 extended_usage += usb_hid_report_tag_data_uint32( 740 data,item_size); 741 742 report_item->usages[report_item->usages_count] = 743 extended_usage; 744 745 report_item->usages_count++; 746 break; 747 } 748 break; 749 750 case USB_HID_REPORT_TAG_USAGE_MINIMUM: 751 if (item_size == 3) { 752 // usage extended usages 753 report_item->extended_usage_page = 754 USB_HID_EXTENDED_USAGE_PAGE( 755 usb_hid_report_tag_data_uint32(data,item_size)); 756 757 758 report_item->usage_minimum = 759 USB_HID_EXTENDED_USAGE( 760 usb_hid_report_tag_data_uint32(data,item_size)); 761 } 762 else { 763 report_item->usage_minimum = 764 usb_hid_report_tag_data_uint32(data,item_size); 765 } 766 break; 767 768 case USB_HID_REPORT_TAG_USAGE_MAXIMUM: 769 if (item_size == 3) { 770 if(report_item->extended_usage_page != 771 USB_HID_EXTENDED_USAGE_PAGE( 772 usb_hid_report_tag_data_uint32(data,item_size))) { 773 774 return EINVAL; 587 775 } 588 break; 589 case USB_HID_REPORT_TAG_USAGE_MINIMUM: 590 if (item_size == 3) { 591 // usage extended usages 592 report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 593 report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF; 776 777 // usage extended usages 778 report_item->extended_usage_page = 779 USB_HID_EXTENDED_USAGE_PAGE( 780 usb_hid_report_tag_data_uint32(data,item_size)); 781 782 report_item->usage_maximum = 783 USB_HID_EXTENDED_USAGE( 784 usb_hid_report_tag_data_uint32(data,item_size)); 785 } 786 else { 787 report_item->usage_maximum = 788 usb_hid_report_tag_data_uint32(data,item_size); 789 } 790 791 // vlozit zaznamy do pole usages 792 int32_t i; 793 for(i = report_item->usage_minimum; 794 i <= report_item->usage_maximum; i++) { 795 796 if(report_item->extended_usage_page) { 797 report_item->usages[report_item->usages_count++] = 798 (report_item->extended_usage_page << 16) + i; 594 799 } 595 else { 596 report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size); 800 else { 801 report_item->usages[report_item->usages_count++] = 802 (report_item->usage_page << 16) + i; 597 803 } 598 break; 599 case USB_HID_REPORT_TAG_USAGE_MAXIMUM: 600 if (item_size == 3) { 601 602 if(report_item->extended_usage_page != ((usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16)) { 603 return EINVAL; 604 } 605 606 // usage extended usages 607 report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 608 report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF; 609 } 610 else { 611 report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size); 612 } 613 614 // vlozit zaznamy do pole usages 615 int32_t i; 616 for(i=report_item->usage_minimum; i<=report_item->usage_maximum; i++) { 617 if(report_item->extended_usage_page) { 618 report_item->usages[report_item->usages_count++] = (report_item->extended_usage_page << 16) + i; 619 } 620 else { 621 622 report_item->usages[report_item->usages_count++] = (report_item->usage_page << 16) + i; 623 } 624 } 625 report_item->extended_usage_page = 0; 804 } 805 report_item->extended_usage_page = 0; 626 806 627 break; 628 case USB_HID_REPORT_TAG_DESIGNATOR_INDEX: 629 report_item->designator_index = usb_hid_report_tag_data_uint32(data,item_size); 630 break; 631 case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM: 632 report_item->designator_minimum = usb_hid_report_tag_data_uint32(data,item_size); 633 break; 634 case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM: 635 report_item->designator_maximum = usb_hid_report_tag_data_uint32(data,item_size); 636 break; 637 case USB_HID_REPORT_TAG_STRING_INDEX: 638 report_item->string_index = usb_hid_report_tag_data_uint32(data,item_size); 639 break; 640 case USB_HID_REPORT_TAG_STRING_MINIMUM: 641 report_item->string_minimum = usb_hid_report_tag_data_uint32(data,item_size); 642 break; 643 case USB_HID_REPORT_TAG_STRING_MAXIMUM: 644 report_item->string_maximum = usb_hid_report_tag_data_uint32(data,item_size); 645 break; 646 case USB_HID_REPORT_TAG_DELIMITER: 647 report_item->in_delimiter = usb_hid_report_tag_data_uint32(data,item_size); 648 break; 649 650 default: 651 return USB_HID_NO_ACTION; 807 break; 808 809 case USB_HID_REPORT_TAG_DESIGNATOR_INDEX: 810 report_item->designator_index = 811 usb_hid_report_tag_data_uint32(data,item_size); 812 break; 813 814 case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM: 815 report_item->designator_minimum = 816 usb_hid_report_tag_data_uint32(data,item_size); 817 break; 818 819 case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM: 820 report_item->designator_maximum = 821 usb_hid_report_tag_data_uint32(data,item_size); 822 break; 823 824 case USB_HID_REPORT_TAG_STRING_INDEX: 825 report_item->string_index = 826 usb_hid_report_tag_data_uint32(data,item_size); 827 break; 828 829 case USB_HID_REPORT_TAG_STRING_MINIMUM: 830 report_item->string_minimum = 831 usb_hid_report_tag_data_uint32(data,item_size); 832 break; 833 834 case USB_HID_REPORT_TAG_STRING_MAXIMUM: 835 report_item->string_maximum = 836 usb_hid_report_tag_data_uint32(data,item_size); 837 break; 838 839 case USB_HID_REPORT_TAG_DELIMITER: 840 report_item->in_delimiter = 841 usb_hid_report_tag_data_uint32(data,item_size); 842 break; 843 844 default: 845 return USB_HID_NO_ACTION; 652 846 } 653 847 654 848 return EOK; 655 849 } 850 /*---------------------------------------------------------------------------*/ 656 851 657 852 /** … … 674 869 return result; 675 870 } 871 /*---------------------------------------------------------------------------*/ 676 872 677 873 /** … … 694 890 for(item = head->next; item != head; item = item->next) { 695 891 696 report_item = list_get_instance(item, usb_hid_report_field_t, link); 892 report_item = list_get_instance(item, usb_hid_report_field_t, 893 link); 697 894 698 895 usb_log_debug("\t\tOFFSET: %X\n", report_item->offset); 699 usb_log_debug("\t\tSIZE: %zu\n", report_item->size); 700 usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum); 701 usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum); 702 usb_log_debug("\t\tPHYMIN: %d\n", report_item->physical_minimum); 703 usb_log_debug("\t\tPHYMAX: %d\n", report_item->physical_maximum); 704 usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum); 705 usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum); 706 usb_log_debug("\t\tUSAGES COUNT: %zu\n", report_item->usages_count); 896 usb_log_debug("\t\tSIZE: %zu\n", report_item->size); 897 usb_log_debug("\t\tLOGMIN: %d\n", 898 report_item->logical_minimum); 899 usb_log_debug("\t\tLOGMAX: %d\n", 900 report_item->logical_maximum); 901 usb_log_debug("\t\tPHYMIN: %d\n", 902 report_item->physical_minimum); 903 usb_log_debug("\t\tPHYMAX: %d\n", 904 report_item->physical_maximum); 905 usb_log_debug("\t\ttUSAGEMIN: %X\n", 906 report_item->usage_minimum); 907 usb_log_debug("\t\tUSAGEMAX: %X\n", 908 report_item->usage_maximum); 909 usb_log_debug("\t\tUSAGES COUNT: %zu\n", 910 report_item->usages_count); 707 911 708 912 usb_log_debug("\t\tVALUE: %X\n", report_item->value); … … 716 920 } 717 921 718 719 } 922 } 923 /*---------------------------------------------------------------------------*/ 924 720 925 /** 721 926 * Prints content of given report descriptor in human readable format. … … 734 939 735 940 while(report_it != &report->reports) { 736 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 941 report_des = list_get_instance(report_it, 942 usb_hid_report_description_t, link); 737 943 usb_log_debug("Report ID: %d\n", report_des->report_id); 738 944 usb_log_debug("\tType: %d\n", report_des->type); … … 742 948 usb_hid_descriptor_print_list(&report_des->report_items); 743 949 744 /*745 link_t *path_it = report->collection_paths.next;746 while(path_it != &report->collection_paths) {747 usb_hid_print_usage_path (list_get_instance(path_it, usb_hid_report_path_t, link));748 path_it = path_it->next;749 }750 */751 950 report_it = report_it->next; 752 951 } 753 952 } 953 /*---------------------------------------------------------------------------*/ 754 954 755 955 /** … … 776 976 777 977 while(!list_empty(&report_item->usage_path->link)) { 778 978 usb_hid_report_remove_last_item(report_item->usage_path); 779 979 } 780 980 … … 788 988 789 989 } 990 /*---------------------------------------------------------------------------*/ 790 991 791 992 /** Frees the HID report descriptor parser structure … … 803 1004 usb_hid_report_path_t *path; 804 1005 while(!list_empty(&report->collection_paths)) { 805 path = list_get_instance(report->collection_paths.next, usb_hid_report_path_t, link); 1006 path = list_get_instance(report->collection_paths.next, 1007 usb_hid_report_path_t, link); 1008 806 1009 usb_hid_report_path_free(path); 807 1010 } … … 811 1014 usb_hid_report_field_t *field; 812 1015 while(!list_empty(&report->reports)) { 813 report_des = list_get_instance(report->reports.next, usb_hid_report_description_t, link); 1016 report_des = list_get_instance(report->reports.next, 1017 usb_hid_report_description_t, link); 1018 814 1019 list_remove(&report_des->link); 815 1020 816 1021 while(!list_empty(&report_des->report_items)) { 817 field = list_get_instance(report_des->report_items.next, usb_hid_report_field_t, link); 1022 field = list_get_instance( 1023 report_des->report_items.next, 1024 usb_hid_report_field_t, link); 1025 818 1026 list_remove(&field->link); 819 1027 … … 826 1034 return; 827 1035 } 1036 /*---------------------------------------------------------------------------*/ 828 1037 829 1038 /**
Note:
See TracChangeset
for help on using the changeset viewer.
