Changes in uspace/lib/usbhid/src/hidparser.c [5f9b81af:160b75e] in mainline
- File:
-
- 1 edited
-
uspace/lib/usbhid/src/hidparser.c (modified) (25 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/usbhid/src/hidparser.c
r5f9b81af r160b75e 31 31 */ 32 32 /** @file 33 * USB HIDreport data parser implementation.33 * HID report descriptor and report data parser implementation. 34 34 */ 35 35 #include <usb/hid/hidparser.h> … … 41 41 #include <assert.h> 42 42 43 /*---------------------------------------------------------------------------*/ 43 44 44 /* 45 45 * Data translation private functions 46 46 */ 47 47 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size); 48 48 //inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset); 49 49 int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data); 50 51 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 52 int32_t value); 53 50 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value); 54 51 int usb_pow(int a, int b); 55 52 56 /*---------------------------------------------------------------------------*/57 53 58 54 // TODO: tohle ma bejt asi jinde … … 60 56 { 61 57 switch(b) { 62 case 0: 63 return 1; 64 break; 65 case 1: 66 return a; 67 break; 68 default: 69 return a * usb_pow(a, b-1); 70 break; 71 } 72 } 73 /*---------------------------------------------------------------------------*/ 74 75 /** Returns size of report of specified report id and type in items 76 * 77 * @param parser Opaque report parser structure 78 * @param report_id 79 * @param type 80 * @return Number of items in specified report 81 */ 82 size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id, 83 usb_hid_report_type_t type) 84 { 85 usb_hid_report_description_t *report_des; 86 87 if(report == NULL) { 88 return 0; 89 } 90 91 report_des = usb_hid_report_find_description (report, report_id, type); 92 if(report_des == NULL){ 93 return 0; 94 } 95 else { 96 return report_des->item_length; 97 } 98 } 99 100 /** Returns size of report of specified report id and type in bytes 101 * 102 * @param parser Opaque report parser structure 103 * @param report_id 104 * @param type 105 * @return Number of items in specified report 106 */ 107 size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, 108 usb_hid_report_type_t type) 109 { 110 usb_hid_report_description_t *report_des; 111 112 if(report == NULL) { 113 return 0; 114 } 115 116 report_des = usb_hid_report_find_description (report, report_id, type); 117 if(report_des == NULL){ 118 return 0; 119 } 120 else { 121 return (report_des->bit_length + 7) / 8; 122 } 123 } 124 /*---------------------------------------------------------------------------*/ 58 case 0: 59 return 1; 60 break; 61 case 1: 62 return a; 63 break; 64 default: 65 return a * usb_pow(a, b-1); 66 break; 67 } 68 } 69 70 71 125 72 126 73 /** Parse and act upon a HID report. … … 132 79 * @return Error code. 133 80 */ 134 int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,135 81 int usb_hid_parse_report(const usb_hid_report_t *report, 82 const uint8_t *data, size_t size, uint8_t *report_id) 136 83 { 137 84 link_t *list_item; … … 140 87 usb_hid_report_description_t *report_des; 141 88 usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT; 142 89 143 90 if(report == NULL) { 144 91 return EINVAL; … … 167 114 // array 168 115 item->value = usb_hid_translate_data(item, data); 169 170 item->usage = USB_HID_EXTENDED_USAGE( 171 item->usages[item->value - item->physical_minimum]); 172 item->usage_page = USB_HID_EXTENDED_USAGE_PAGE( 173 item->usages[item->value - item->physical_minimum]); 174 175 usb_hid_report_set_last_item (item->collection_path, 176 USB_HID_TAG_CLASS_GLOBAL, item->usage_page); 177 usb_hid_report_set_last_item (item->collection_path, 178 USB_HID_TAG_CLASS_LOCAL, item->usage); 179 116 item->usage = (item->value - item->physical_minimum) + item->usage_minimum; 180 117 } 181 118 else { … … 186 123 list_item = list_item->next; 187 124 } 188 125 189 126 return EOK; 190 127 191 128 } 192 129 193 /*---------------------------------------------------------------------------*/194 130 /** 195 131 * Translate data from the report as specified in report descriptor item … … 197 133 * @param item Report descriptor item with definition of translation 198 134 * @param data Data to translate 135 * @param j Index of processed field in report descriptor item 199 136 * @return Translated data 200 137 */ … … 269 206 } 270 207 271 /*---------------------------------------------------------------------------*/ 272 /* OUTPUT API */ 208 /** 209 * Returns number of items in input report which are accessible by given usage path 210 * 211 * @param parser Opaque report descriptor structure 212 * @param path Usage path specification 213 * @param flags Usage path comparison flags 214 * @return Number of items in input report 215 */ 216 size_t usb_hid_report_input_length(const usb_hid_report_t *report, 217 usb_hid_report_path_t *path, int flags) 218 { 219 220 size_t ret = 0; 221 222 if(report == NULL) { 223 return 0; 224 } 225 226 usb_hid_report_description_t *report_des; 227 report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_INPUT); 228 if(report_des == NULL) { 229 return 0; 230 } 231 232 link_t *field_it = report_des->report_items.next; 233 usb_hid_report_field_t *field; 234 while(field_it != &report_des->report_items) { 235 236 field = list_get_instance(field_it, usb_hid_report_field_t, link); 237 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) { 238 239 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); 240 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) { 241 ret++; 242 } 243 usb_hid_report_remove_last_item (field->collection_path); 244 } 245 246 field_it = field_it->next; 247 } 248 249 return ret; 250 } 251 252 /*** OUTPUT API **/ 273 253 274 254 /** … … 280 260 * @return Returns allocated output buffer for specified output 281 261 */ 282 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, 283 uint8_t report_id) 262 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id) 284 263 { 285 264 if(report == NULL) { … … 291 270 usb_hid_report_description_t *report_des = NULL; 292 271 while(report_it != &report->reports) { 293 report_des = list_get_instance(report_it, 294 usb_hid_report_description_t, link); 295 296 if((report_des->report_id == report_id) && 297 (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){ 272 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 273 if((report_des->report_id == report_id) && (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){ 298 274 break; 299 275 } … … 326 302 free (output); 327 303 } 304 } 305 306 /** Returns size of output for given usage path 307 * 308 * @param parser Opaque report parser structure 309 * @param path Usage path specified which items will be thought for the output 310 * @param flags Flags of usage path structure comparison 311 * @return Number of items matching the given usage path 312 */ 313 size_t usb_hid_report_output_size(usb_hid_report_t *report, 314 usb_hid_report_path_t *path, int flags) 315 { 316 size_t ret = 0; 317 usb_hid_report_description_t *report_des; 318 319 if(report == NULL) { 320 return 0; 321 } 322 323 report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_OUTPUT); 324 if(report_des == NULL){ 325 return 0; 326 } 327 328 link_t *field_it = report_des->report_items.next; 329 usb_hid_report_field_t *field; 330 while(field_it != &report_des->report_items) { 331 332 field = list_get_instance(field_it, usb_hid_report_field_t, link); 333 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0){ 334 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); 335 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) { 336 ret++; 337 } 338 usb_hid_report_remove_last_item (field->collection_path); 339 } 340 341 field_it = field_it->next; 342 } 343 344 return ret; 345 328 346 } 329 347 … … 337 355 * @return Error code 338 356 */ 339 int usb_hid_report_output_translate(usb_hid_report_t *report, 340 uint8_t report_id,uint8_t *buffer, size_t size)357 int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id, 358 uint8_t *buffer, size_t size) 341 359 { 342 360 link_t *item; … … 354 372 } 355 373 374 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); 375 356 376 usb_hid_report_description_t *report_des; 357 report_des = usb_hid_report_find_description (report, report_id, 358 USB_HID_REPORT_TYPE_OUTPUT); 359 377 report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT); 360 378 if(report_des == NULL){ 361 379 return EINVAL; … … 367 385 report_item = list_get_instance(item, usb_hid_report_field_t, link); 368 386 369 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {387 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) { 370 388 371 // array 372 value = usb_hid_translate_data_reverse(report_item, 373 report_item->value); 374 375 offset = report_item->offset; 376 length = report_item->size; 377 } 378 else { 379 // variable item 380 value = usb_hid_translate_data_reverse(report_item, 381 report_item->value); 382 383 offset = report_item->offset; 384 length = report_item->size; 385 } 386 387 usb_log_debug("\ttranslated value: %x\n", value); 388 389 if((offset/8) == ((offset+length-1)/8)) { 390 // je to v jednom bytu 391 if(((size_t)(offset/8) >= size) || 392 ((size_t)(offset+length-1)/8) >= size) { 393 break; // TODO ErrorCode 394 } 395 size_t shift = 8 - offset%8 - length; 396 value = value << shift; 397 value = value & (((1 << length)-1) << shift); 389 // array 390 value = usb_hid_translate_data_reverse(report_item, report_item->value); 391 offset = report_item->offset; 392 length = report_item->size; 393 } 394 else { 395 // variable item 396 value = usb_hid_translate_data_reverse(report_item, report_item->value); 397 offset = report_item->offset; 398 length = report_item->size; 399 } 400 401 if((offset/8) == ((offset+length-1)/8)) { 402 // je to v jednom bytu 403 if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) { 404 break; // TODO ErrorCode 405 } 406 407 size_t shift = 8 - offset%8 - length; 408 409 value = value << shift; 410 value = value & (((1 << length)-1) << shift); 398 411 399 uint8_t mask = 0; 400 mask = 0xff - (((1 << length) - 1) << shift); 401 buffer[offset/8] = (buffer[offset/8] & mask) | value; 402 } 403 else { 404 int i = 0; 405 uint8_t mask = 0; 406 for(i = (offset/8); i <= ((offset+length-1)/8); i++) { 407 if(i == (offset/8)) { 408 tmp_value = value; 409 tmp_value = tmp_value & ((1 << (8-(offset%8)))-1); 410 tmp_value = tmp_value << (offset%8); 411 412 mask = ~(((1 << (8-(offset%8)))-1) << (offset%8)); 413 buffer[i] = (buffer[i] & mask) | tmp_value; 412 uint8_t mask = 0; 413 mask = 0xff - (((1 << length) - 1) << shift); 414 buffer[offset/8] = (buffer[offset/8] & mask) | value; 415 } 416 else { 417 int i = 0; 418 uint8_t mask = 0; 419 for(i = (offset/8); i <= ((offset+length-1)/8); i++) { 420 if(i == (offset/8)) { 421 tmp_value = value; 422 tmp_value = tmp_value & ((1 << (8-(offset%8)))-1); 423 tmp_value = tmp_value << (offset%8); 424 425 mask = ~(((1 << (8-(offset%8)))-1) << (offset%8)); 426 buffer[i] = (buffer[i] & mask) | tmp_value; 427 } 428 else if (i == ((offset + length -1)/8)) { 429 430 value = value >> (length - ((offset + length) % 8)); 431 value = value & ((1 << (length - ((offset + length) % 8))) - 1); 432 433 mask = (1 << (length - ((offset + length) % 8))) - 1; 434 buffer[i] = (buffer[i] & mask) | value; 435 } 436 else { 437 buffer[i] = value & (0xFF << i); 438 } 414 439 } 415 else if (i == ((offset + length -1)/8)) { 416 417 value = value >> (length - ((offset + length) % 8)); 418 value = value & 419 ((1 << (length - ((offset + length) % 8))) - 1); 420 421 mask = (1 << (length - ((offset + length) % 8))) - 1; 422 buffer[i] = (buffer[i] & mask) | value; 423 } 424 else { 425 buffer[i] = value & (0xFF << i); 426 } 427 } 428 } 440 } 441 429 442 430 443 // reset value … … 434 447 } 435 448 449 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); 450 436 451 return EOK; 437 452 } 438 453 439 /*---------------------------------------------------------------------------*/440 454 /** 441 455 * Translate given data for putting them into the outoput report … … 444 458 * @return ranslated value 445 459 */ 446 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 447 int value) 460 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value) 448 461 { 449 462 int ret=0; … … 459 472 } 460 473 461 // variable item 462 if(item->physical_maximum == item->physical_minimum){ 463 resolution = 1; 474 475 if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) { 476 477 // variable item 478 if(item->physical_maximum == item->physical_minimum){ 479 resolution = 1; 480 } 481 else { 482 resolution = (item->logical_maximum - item->logical_minimum) / 483 ((item->physical_maximum - item->physical_minimum) * 484 (usb_pow(10,(item->unit_exponent)))); 485 } 486 487 ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum; 464 488 } 465 489 else { 466 resolution = (item->logical_maximum - item->logical_minimum) / 467 ((item->physical_maximum - item->physical_minimum) * 468 (usb_pow(10,(item->unit_exponent)))); 469 } 470 471 ret = ((value - item->physical_minimum) * resolution) + 472 item->logical_minimum; 473 474 usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), \ 475 ret(%x)\n", value, resolution, item->physical_minimum, 476 item->logical_minimum, ret); 477 490 // bitmapa 491 if(value == 0) { 492 ret = 0; 493 } 494 else { 495 size_t bitmap_idx = (value - item->usage_minimum); 496 ret = 1 << bitmap_idx; 497 } 498 } 499 478 500 if((item->logical_minimum < 0) || (item->logical_maximum < 0)){ 479 501 return USB_HID_INT32_TO_UINT32(ret, item->size); 480 502 } 481 return (int32_t)0 + ret; 482 } 483 484 /*---------------------------------------------------------------------------*/ 485 /** 486 * Clones given state table 487 * 488 * @param item State table to clone 489 * @return Pointer to the cloned item 490 */ 491 usb_hid_report_item_t *usb_hid_report_item_clone( 492 const usb_hid_report_item_t *item) 503 return (int32_t)ret; 504 } 505 506 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item) 493 507 { 494 508 usb_hid_report_item_t *new_report_item; … … 503 517 } 504 518 505 /*---------------------------------------------------------------------------*/ 506 /** 507 * Function for sequence walking through the report. Returns next field in the 508 * report or the first one when no field is given. 509 * 510 * @param report Searched report structure 511 * @param field Current field. If NULL is given, the first one in the report 512 * is returned. Otherwise the next one i nthe list is returned. 513 * @param path Usage path specifying which fields wa are interested in. 514 * @param flags Flags defining mode of usage paths comparison 515 * @param type Type of report we search. 516 * @retval NULL if no field is founded 517 * @retval Pointer to the founded report structure when founded 518 */ 519 519 520 usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, 520 usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags, 521 usb_hid_report_type_t type) 522 { 523 usb_hid_report_description_t *report_des = usb_hid_report_find_description( 524 report, path->report_id, type); 525 521 usb_hid_report_field_t *field, 522 usb_hid_report_path_t *path, int flags, 523 usb_hid_report_type_t type) 524 { 525 usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type); 526 526 link_t *field_it; 527 527 … … 531 531 532 532 if(field == NULL){ 533 // vezmu prvni co mathuje podle path!! 533 534 field_it = report_des->report_items.next; 534 535 } … … 541 542 542 543 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) { 543 usb_hid_report_path_append_item (field->collection_path, 544 field->usage_page, field->usage); 545 546 if(usb_hid_report_compare_usage_path(field->collection_path, path, 547 flags) == EOK){ 548 549 usb_hid_report_remove_last_item(field->collection_path); 544 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); 545 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){ 546 usb_hid_report_remove_last_item (field->collection_path); 550 547 return field; 551 548 } … … 558 555 } 559 556 560 /*---------------------------------------------------------------------------*/ 561 /** 562 * Returns next report_id of report of specified type. If zero is given than 563 * first report_id of specified type is returned (0 is not legal value for 564 * repotr_id) 565 * 566 * @param report_id Current report_id, 0 if there is no current report_id 567 * @param type Type of searched report 568 * @param report Report structure inwhich we search 569 * @retval 0 if report structure is null or there is no specified report 570 * @retval report_id otherwise 571 */ 572 uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, 573 uint8_t report_id, usb_hid_report_type_t type) 557 uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type) 574 558 { 575 559 if(report == NULL){ … … 580 564 link_t *report_it; 581 565 582 if(report_id > 0) { 583 report_it = usb_hid_report_find_description(report, report_id, 584 type)->link.next; 566 if(report_id == 0) { 567 report_it = usb_hid_report_find_description (report, report_id, type)->link.next; 585 568 } 586 569 else { … … 589 572 590 573 while(report_it != &report->reports) { 591 report_des = list_get_instance(report_it, 592 usb_hid_report_description_t, link); 593 574 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 594 575 if(report_des->type == type){ 595 576 return report_des->report_id; … … 600 581 } 601 582 602 /*---------------------------------------------------------------------------*/603 /**604 * Reset all local items in given state table605 *606 * @param report_item State table containing current state of report607 * descriptor parsing608 *609 * @return void610 */611 583 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item) 612 584 {
Note:
See TracChangeset
for help on using the changeset viewer.
