Changes in uspace/lib/usb/src/hidparser.c [28d7185:4125b7d] in mainline
- File:
-
- 1 edited
-
uspace/lib/usb/src/hidparser.c (modified) (57 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/usb/src/hidparser.c
r28d7185 r4125b7d 39 39 #include <mem.h> 40 40 #include <usb/debug.h> 41 #include <assert.h> 42 43 /** The new report item flag. Used to determine when the item is completly 44 * configured and should be added to the report structure 45 */ 41 42 /** */ 46 43 #define USB_HID_NEW_REPORT_ITEM 1 47 44 48 /** No special action after the report descriptor tag is processed should be 49 * done 50 */ 51 #define USB_HID_NO_ACTION 2 52 53 #define USB_HID_RESET_OFFSET 3 54 55 /** Unknown tag was founded in report descriptor data*/ 45 /** */ 46 #define USB_HID_NO_ACTION 2 47 48 /** */ 56 49 #define USB_HID_UNKNOWN_TAG -99 57 50 … … 59 52 * Private descriptor parser functions 60 53 */ 61 int usb_hid_report_init(usb_hid_report_t *report);62 int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item);63 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);64 54 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, 65 55 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); … … 71 61 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 72 62 73 void usb_hid_print_usage_path(usb_hid_report_path_t *path);74 63 void usb_hid_descriptor_print_list(link_t *head); 75 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);64 int usb_hid_report_reset_local_items(); 76 65 void usb_hid_free_report_list(link_t *head); 77 66 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item); … … 79 68 * Data translation private functions 80 69 */ 81 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);70 int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size); 82 71 inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset); 83 int usb_hid_translate_data(usb_hid_report_ field_t *item, const uint8_t *data);84 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value);72 int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j); 73 int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int32_t value); 85 74 int usb_pow(int a, int b); 86 75 87 #define USB_HID_UINT32_TO_INT32(x, size) ((((x) & (1 << ((size) - 1))) != 0) ? -(~(x - 1) & ((1 << size) - 1)) : (x)) //(-(~((x) - 1)))88 #define USB_HID_INT32_TO_UINT32(x, size) (((x) < 0 ) ? ((1 << (size)) + (x)) : (x))89 76 // TODO: tohle ma bejt asi jinde 90 77 int usb_pow(int a, int b) … … 109 96 * @return Error code 110 97 */ 111 int usb_hid_ report_init(usb_hid_report_t *report)112 { 113 if( report== NULL) {98 int usb_hid_parser_init(usb_hid_report_parser_t *parser) 99 { 100 if(parser == NULL) { 114 101 return EINVAL; 115 102 } 116 103 117 memset(report, 0, sizeof(usb_hid_report_t)); 118 list_initialize(&report->reports); 119 list_initialize(&report->collection_paths); 120 121 report->use_report_ids = 0; 104 list_initialize(&(parser->input)); 105 list_initialize(&(parser->output)); 106 list_initialize(&(parser->feature)); 107 108 list_initialize(&(parser->stack)); 109 110 parser->use_report_id = 0; 122 111 return EOK; 123 112 } 124 113 125 int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item)126 {127 usb_hid_report_field_t *field;128 int i;129 130 131 /* find or append current collection path to the list */132 link_t *path_it = report->collection_paths.next;133 usb_hid_report_path_t *path = NULL;134 while(path_it != &report->collection_paths) {135 path = list_get_instance(path_it, usb_hid_report_path_t, link);136 137 if(usb_hid_report_compare_usage_path(path, report_item->usage_path, USB_HID_PATH_COMPARE_STRICT) == EOK){138 break;139 }140 path_it = path_it->next;141 }142 if(path_it == &report->collection_paths) {143 path = usb_hid_report_path_clone(report_item->usage_path);144 list_append(&path->link, &report->collection_paths);145 report->collection_paths_count++;146 }147 148 for(i=0; i<report_item->usages_count; i++){149 usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]);150 }151 152 153 for(i=0; i<report_item->count; i++){154 155 field = malloc(sizeof(usb_hid_report_field_t));156 memset(field, 0, sizeof(usb_hid_report_field_t));157 list_initialize(&field->link);158 159 /* fill the attributes */160 field->collection_path = path;161 field->logical_minimum = report_item->logical_minimum;162 field->logical_maximum = report_item->logical_maximum;163 field->physical_minimum = report_item->physical_minimum;164 field->physical_maximum = report_item->physical_maximum;165 166 field->usage_minimum = report_item->usage_minimum;167 field->usage_maximum = report_item->usage_maximum;168 if(report_item->extended_usage_page != 0){169 field->usage_page = report_item->extended_usage_page;170 }171 else {172 field->usage_page = report_item->usage_page;173 }174 175 if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {176 uint32_t usage;177 if(report_item->type != USB_HID_REPORT_TYPE_INPUT) {178 if(i < report_item->usages_count){179 usage = report_item->usages[i];180 }181 else {182 usage = report_item->usages[report_item->usages_count - 1];183 }184 }185 else {186 if((report_item->count - i - 1) < report_item->usages_count){187 usage = report_item->usages[(report_item->count - i - 1)];188 }189 else {190 usage = report_item->usages[report_item->usages_count - 1];191 }192 }193 194 195 if((usage & 0xFFFF0000) != 0){196 field->usage_page = (usage >> 16);197 field->usage = (usage & 0xFFFF);198 }199 else {200 field->usage = usage;201 }202 203 204 }205 206 if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {207 if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {208 field->usage = report_item->usage_maximum - i;209 }210 else {211 field->usage = report_item->usage_minimum + i;212 }213 214 }215 216 field->size = report_item->size;217 field->offset = report_item->offset + (i * report_item->size);218 if(report_item->id != 0) {219 field->offset += 8;220 report->use_report_ids = 1;221 }222 field->item_flags = report_item->item_flags;223 224 /* find the right report list*/225 usb_hid_report_description_t *report_des;226 report_des = usb_hid_report_find_description(report, report_item->id, report_item->type);227 if(report_des == NULL){228 report_des = malloc(sizeof(usb_hid_report_description_t));229 memset(report_des, 0, sizeof(usb_hid_report_description_t));230 231 report_des->type = report_item->type;232 report_des->report_id = report_item->id;233 list_initialize (&report_des->link);234 list_initialize (&report_des->report_items);235 236 list_append(&report_des->link, &report->reports);237 report->report_count++;238 }239 240 /* append this field to the end of founded report list */241 list_append (&field->link, &report_des->report_items);242 243 /* update the sizes */244 report_des->bit_length += field->size;245 report_des->item_length++;246 247 }248 249 250 return EOK;251 }252 253 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)254 {255 link_t *report_it = report->reports.next;256 usb_hid_report_description_t *report_des = NULL;257 258 while(report_it != &report->reports) {259 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);260 261 if((report_des->report_id == report_id) && (report_des->type == type)){262 return report_des;263 }264 265 report_it = report_it->next;266 }267 268 return NULL;269 }270 114 271 115 /** Parse HID report descriptor. … … 275 119 * @return Error code. 276 120 */ 277 int usb_hid_parse_report_descriptor(usb_hid_report_ t *report,121 int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, 278 122 const uint8_t *data, size_t size) 279 123 { … … 286 130 usb_hid_report_item_t *new_report_item; 287 131 usb_hid_report_path_t *usage_path; 132 usb_hid_report_path_t *tmp_usage_path; 288 133 289 134 size_t offset_input=0; 290 135 size_t offset_output=0; 291 136 size_t offset_feature=0; 292 293 link_t stack; 294 list_initialize(&stack); 137 295 138 296 139 /* parser structure initialization*/ 297 if(usb_hid_ report_init(report) != EOK) {140 if(usb_hid_parser_init(parser) != EOK) { 298 141 return EINVAL; 299 142 } 300 143 144 301 145 /*report item initialization*/ 302 146 if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){ … … 315 159 316 160 if((i+USB_HID_ITEM_SIZE(data[i]))>= size){ 317 return EINVAL; 161 return EINVAL; // TODO ERROR CODE 318 162 } 319 163 … … 321 165 item_size = USB_HID_ITEM_SIZE(data[i]); 322 166 class = USB_HID_ITEM_TAG_CLASS(data[i]); 167 168 usb_log_debug2( 169 "i(%zu) data(%X) value(%X): TAG %d, class %u, size %u - ", i, 170 data[i], usb_hid_report_tag_data_int32(data+i+1,item_size), 171 tag, class, item_size); 323 172 324 173 ret = usb_hid_report_parse_tag(tag,class,data+i+1, 325 174 item_size,report_item, usage_path); 175 usb_log_debug2("ret: %u\n", ret); 326 176 switch(ret){ 327 177 case USB_HID_NEW_REPORT_ITEM: 328 178 // store report item to report and create the new one 329 // store current collection path 179 usb_log_debug("\nNEW REPORT ITEM: %X",ret); 180 181 // store current usage path 330 182 report_item->usage_path = usage_path; 331 183 184 // clone path to the new one 185 tmp_usage_path = usb_hid_report_path_clone(usage_path); 186 187 // swap 188 usage_path = tmp_usage_path; 189 tmp_usage_path = NULL; 190 332 191 usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id); 333 192 if(report_item->id != 0){ 334 report->use_report_ids= 1;193 parser->use_report_id = 1; 335 194 } 336 195 337 196 switch(tag) { 338 197 case USB_HID_REPORT_TAG_INPUT: 339 report_item->type = USB_HID_REPORT_TYPE_INPUT;340 198 report_item->offset = offset_input; 341 199 offset_input += report_item->count * report_item->size; 200 usb_log_debug(" - INPUT\n"); 201 list_append(&(report_item->link), &(parser->input)); 342 202 break; 343 203 case USB_HID_REPORT_TAG_OUTPUT: 344 report_item->type = USB_HID_REPORT_TYPE_OUTPUT;345 204 report_item->offset = offset_output; 346 205 offset_output += report_item->count * report_item->size; 206 usb_log_debug(" - OUTPUT\n"); 207 list_append(&(report_item->link), &(parser->output)); 347 208 348 209 break; 349 210 case USB_HID_REPORT_TAG_FEATURE: 350 report_item->type = USB_HID_REPORT_TYPE_FEATURE;351 211 report_item->offset = offset_feature; 352 212 offset_feature += report_item->count * report_item->size; 213 usb_log_debug(" - FEATURE\n"); 214 list_append(&(report_item->link), &(parser->feature)); 353 215 break; 354 216 default: … … 356 218 break; 357 219 } 220 221 /* clone current state table to the new item */ 222 if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) { 223 return ENOMEM; 224 } 225 memcpy(new_report_item,report_item, sizeof(usb_hid_report_item_t)); 226 link_initialize(&(new_report_item->link)); 358 227 359 /*360 * append new fields to the report361 * structure362 */363 usb_hid_report_append_fields(report, report_item);364 365 228 /* reset local items */ 366 usb_hid_report_reset_local_items (report_item); 367 229 new_report_item->usage_minimum = 0; 230 new_report_item->usage_maximum = 0; 231 new_report_item->designator_index = 0; 232 new_report_item->designator_minimum = 0; 233 new_report_item->designator_maximum = 0; 234 new_report_item->string_index = 0; 235 new_report_item->string_minimum = 0; 236 new_report_item->string_maximum = 0; 237 238 /* reset usage from current usage path */ 239 usb_hid_report_usage_path_t *path = list_get_instance(&usage_path->link, usb_hid_report_usage_path_t, link); 240 path->usage = 0; 241 242 report_item = new_report_item; 243 368 244 break; 369 370 case USB_HID_RESET_OFFSET:371 offset_input = 0;372 offset_output = 0;373 offset_feature = 0;374 usb_hid_report_path_set_report_id (usage_path, report_item->id);375 break;376 377 245 case USB_HID_REPORT_TAG_PUSH: 378 246 // push current state to stack 379 247 new_report_item = usb_hid_report_item_clone(report_item); 380 usb_hid_report_path_t *tmp_path = usb_hid_report_path_clone(usage_path); 381 new_report_item->usage_path = tmp_path; 382 383 list_prepend (&new_report_item->link, &stack); 248 list_prepend (&parser->stack, &new_report_item->link); 249 384 250 break; 385 251 case USB_HID_REPORT_TAG_POP: 386 252 // restore current state from stack 387 if(list_empty (& stack)) {253 if(list_empty (&parser->stack)) { 388 254 return EINVAL; 389 255 } 390 free(report_item);391 392 report_item = list_get_instance(stack.next, usb_hid_report_item_t, link);393 256 394 usb_hid_report_usage_path_t *tmp_usage_path; 395 tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link); 396 397 usb_hid_report_set_last_item(usage_path, tmp_usage_path->usage_page, tmp_usage_path->usage); 398 399 usb_hid_report_path_free(report_item->usage_path); 400 list_initialize(&report_item->usage_path->link); 401 list_remove (stack.next); 257 report_item = list_get_instance(&parser->stack, usb_hid_report_item_t, link); 258 list_remove (parser->stack.next); 402 259 403 260 break; … … 422 279 } 423 280 281 282 /** 283 * Parse input report. 284 * 285 * @param data Data for report 286 * @param size Size of report 287 * @param callbacks Callbacks for report actions 288 * @param arg Custom arguments 289 * 290 * @return Error code 291 */ 292 int usb_hid_boot_keyboard_input_report(const uint8_t *data, size_t size, 293 const usb_hid_report_in_callbacks_t *callbacks, void *arg) 294 { 295 int i; 296 usb_hid_report_item_t item; 297 298 /* fill item due to the boot protocol report descriptor */ 299 // modifier keys are in the first byte 300 uint8_t modifiers = data[0]; 301 302 item.offset = 2; /* second byte is reserved */ 303 item.size = 8; 304 item.count = 6; 305 item.usage_minimum = 0; 306 item.usage_maximum = 255; 307 item.logical_minimum = 0; 308 item.logical_maximum = 255; 309 310 if (size != 8) { 311 return -1; //ERANGE; 312 } 313 314 uint8_t keys[6]; 315 for (i = 0; i < item.count; i++) { 316 keys[i] = data[i + item.offset]; 317 } 318 319 callbacks->keyboard(keys, 6, modifiers, arg); 320 return EOK; 321 } 322 323 /** 324 * Makes output report for keyboard boot protocol 325 * 326 * @param leds 327 * @param output Output report data buffer 328 * @param size Size of the output buffer 329 * @return Error code 330 */ 331 int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size) 332 { 333 if(size != 1){ 334 return -1; 335 } 336 337 /* used only first five bits, others are only padding*/ 338 *data = leds; 339 return EOK; 340 } 424 341 425 342 /** … … 484 401 485 402 case USB_HID_REPORT_TAG_COLLECTION: 486 // TODO usage_path->flags = *data; 487 usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]); 488 usb_hid_report_reset_local_items (report_item); 403 usb_hid_report_path_append_item(usage_path, 0, 0); 404 489 405 return USB_HID_NO_ACTION; 490 406 break; 491 407 492 408 case USB_HID_REPORT_TAG_END_COLLECTION: 409 // TODO 410 // znici posledni uroven ve vsech usage paths 411 // otazka jestli nema nicit dve, respektive novou posledni vynulovat? 493 412 usb_hid_report_remove_last_item(usage_path); 494 413 return USB_HID_NO_ACTION; … … 517 436 { 518 437 case USB_HID_REPORT_TAG_USAGE_PAGE: 519 report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size); 438 // zmeni to jenom v poslednim poli aktualni usage path 439 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, 440 usb_hid_report_tag_data_int32(data,item_size)); 520 441 break; 521 442 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM: 522 report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);443 report_item->logical_minimum = usb_hid_report_tag_data_int32(data,item_size); 523 444 break; 524 445 case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM: 525 report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);446 report_item->logical_maximum = usb_hid_report_tag_data_int32(data,item_size); 526 447 break; 527 448 case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM: 528 report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);449 report_item->physical_minimum = usb_hid_report_tag_data_int32(data,item_size); 529 450 break; 530 451 case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM: 531 report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); 532 452 report_item->physical_maximum = usb_hid_report_tag_data_int32(data,item_size); 533 453 break; 534 454 case USB_HID_REPORT_TAG_UNIT_EXPONENT: 535 report_item->unit_exponent = usb_hid_report_tag_data_ uint32(data,item_size);455 report_item->unit_exponent = usb_hid_report_tag_data_int32(data,item_size); 536 456 break; 537 457 case USB_HID_REPORT_TAG_UNIT: 538 report_item->unit = usb_hid_report_tag_data_ uint32(data,item_size);458 report_item->unit = usb_hid_report_tag_data_int32(data,item_size); 539 459 break; 540 460 case USB_HID_REPORT_TAG_REPORT_SIZE: 541 report_item->size = usb_hid_report_tag_data_ uint32(data,item_size);461 report_item->size = usb_hid_report_tag_data_int32(data,item_size); 542 462 break; 543 463 case USB_HID_REPORT_TAG_REPORT_COUNT: 544 report_item->count = usb_hid_report_tag_data_ uint32(data,item_size);464 report_item->count = usb_hid_report_tag_data_int32(data,item_size); 545 465 break; 546 466 case USB_HID_REPORT_TAG_REPORT_ID: 547 report_item->id = usb_hid_report_tag_data_uint32(data,item_size); 548 return USB_HID_RESET_OFFSET; 467 report_item->id = usb_hid_report_tag_data_int32(data,item_size); 549 468 break; 550 469 case USB_HID_REPORT_TAG_PUSH: 551 470 case USB_HID_REPORT_TAG_POP: 552 /*553 * stack operations are done in top level parsing554 * function555 */556 471 return tag; 557 472 break; … … 560 475 return USB_HID_NO_ACTION; 561 476 } 562 477 563 478 return EOK; 564 479 } … … 579 494 { 580 495 case USB_HID_REPORT_TAG_USAGE: 581 report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);582 report_item->usages_count++;496 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, 497 usb_hid_report_tag_data_int32(data,item_size)); 583 498 break; 584 499 case USB_HID_REPORT_TAG_USAGE_MINIMUM: 585 if (item_size == 3) { 586 // usage extended usages 587 report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 588 report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF; 589 } 590 else { 591 report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size); 592 } 500 report_item->usage_minimum = usb_hid_report_tag_data_int32(data,item_size); 593 501 break; 594 502 case USB_HID_REPORT_TAG_USAGE_MAXIMUM: 595 if (item_size == 3) { 596 // usage extended usages 597 report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 598 report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF; 599 } 600 else { 601 report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size); 602 } 503 report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size); 603 504 break; 604 505 case USB_HID_REPORT_TAG_DESIGNATOR_INDEX: 605 report_item->designator_index = usb_hid_report_tag_data_ uint32(data,item_size);506 report_item->designator_index = usb_hid_report_tag_data_int32(data,item_size); 606 507 break; 607 508 case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM: 608 report_item->designator_minimum = usb_hid_report_tag_data_ uint32(data,item_size);509 report_item->designator_minimum = usb_hid_report_tag_data_int32(data,item_size); 609 510 break; 610 511 case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM: 611 report_item->designator_maximum = usb_hid_report_tag_data_ uint32(data,item_size);512 report_item->designator_maximum = usb_hid_report_tag_data_int32(data,item_size); 612 513 break; 613 514 case USB_HID_REPORT_TAG_STRING_INDEX: 614 report_item->string_index = usb_hid_report_tag_data_ uint32(data,item_size);515 report_item->string_index = usb_hid_report_tag_data_int32(data,item_size); 615 516 break; 616 517 case USB_HID_REPORT_TAG_STRING_MINIMUM: 617 report_item->string_minimum = usb_hid_report_tag_data_ uint32(data,item_size);518 report_item->string_minimum = usb_hid_report_tag_data_int32(data,item_size); 618 519 break; 619 520 case USB_HID_REPORT_TAG_STRING_MAXIMUM: 620 report_item->string_maximum = usb_hid_report_tag_data_ uint32(data,item_size);521 report_item->string_maximum = usb_hid_report_tag_data_int32(data,item_size); 621 522 break; 622 523 case USB_HID_REPORT_TAG_DELIMITER: 623 //report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size); 624 //TODO: 625 // DELIMITER STUFF 524 report_item->delimiter = usb_hid_report_tag_data_int32(data,item_size); 626 525 break; 627 526 … … 634 533 635 534 /** 636 * Converts raw data to uint32 (thats the maximum length of short item data)535 * Converts raw data to int32 (thats the maximum length of short item data) 637 536 * 638 537 * @param Data buffer … … 640 539 * @return Converted int32 number 641 540 */ 642 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size)541 int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size) 643 542 { 644 543 unsigned int i; 645 uint32_t result;544 int32_t result; 646 545 647 546 result = 0; … … 653 552 } 654 553 554 555 655 556 /** 656 557 * Prints content of given list of report items. … … 661 562 void usb_hid_descriptor_print_list(link_t *head) 662 563 { 663 usb_hid_report_field_t *report_item; 564 usb_hid_report_item_t *report_item; 565 usb_hid_report_usage_path_t *path_item; 566 link_t *path; 664 567 link_t *item; 665 666 568 667 569 if(head == NULL || list_empty(head)) { 668 570 usb_log_debug("\tempty\n"); … … 672 574 for(item = head->next; item != head; item = item->next) { 673 575 674 report_item = list_get_instance(item, usb_hid_report_field_t, link); 675 676 usb_log_debug("\t\tOFFSET: %X\n", report_item->offset); 677 usb_log_debug("\t\tSIZE: %X\n", report_item->size); 678 usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum); 679 usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum); 680 usb_log_debug("\t\tPHYMIN: %d\n", report_item->physical_minimum); 681 usb_log_debug("\t\tPHYMAX: %d\n", report_item->physical_maximum); 682 usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum); 683 usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum); 684 685 usb_log_debug("\t\tVALUE: %X\n", report_item->value); 686 usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage); 687 usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page); 688 689 // usb_log_debug("\n"); 576 report_item = list_get_instance(item, usb_hid_report_item_t, link); 577 578 usb_log_debug("\tOFFSET: %zX\n", report_item->offset); 579 usb_log_debug("\tCOUNT: %X\n", report_item->count); 580 usb_log_debug("\tSIZE: %X\n", report_item->size); 581 usb_log_debug("\tCONSTANT/VAR: %X\n", USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags)); 582 usb_log_debug("\tVARIABLE/ARRAY: %X\n", USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags)); 583 usb_log_debug("\tUSAGE PATH:\n"); 584 585 path = report_item->usage_path->link.next; 586 while(path != &report_item->usage_path->link) { 587 path_item = list_get_instance(path, usb_hid_report_usage_path_t, link); 588 usb_log_debug("\t\tUSAGE PAGE: %X, USAGE: %X\n", path_item->usage_page, path_item->usage); 589 path = path->next; 590 } 591 592 usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum); 593 usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum); 594 usb_log_debug("\tPHYMIN: %X\n", report_item->physical_minimum); 595 usb_log_debug("\tPHYMAX: %X\n", report_item->physical_maximum); 596 usb_log_debug("\tUSAGEMIN: %X\n", report_item->usage_minimum); 597 usb_log_debug("\tUSAGEMAX: %X\n", report_item->usage_maximum); 598 599 usb_log_debug("\n"); 690 600 691 601 } … … 699 609 * @return void 700 610 */ 701 void usb_hid_descriptor_print(usb_hid_report_ t *report)702 { 703 if( report== NULL) {611 void usb_hid_descriptor_print(usb_hid_report_parser_t *parser) 612 { 613 if(parser == NULL) { 704 614 return; 705 615 } 706 707 link_t *report_it = report->reports.next; 708 usb_hid_report_description_t *report_des; 709 710 while(report_it != &report->reports) { 711 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 712 usb_log_debug("Report ID: %d\n", report_des->report_id); 713 usb_log_debug("\tType: %d\n", report_des->type); 714 usb_log_debug("\tLength: %d\n", report_des->bit_length); 715 usb_log_debug("\tItems: %d\n", report_des->item_length); 716 717 usb_hid_descriptor_print_list(&report_des->report_items); 718 719 720 link_t *path_it = report->collection_paths.next; 721 while(path_it != &report->collection_paths) { 722 usb_hid_print_usage_path (list_get_instance(path_it, usb_hid_report_path_t, link)); 723 path_it = path_it->next; 724 } 725 726 report_it = report_it->next; 727 } 616 617 usb_log_debug("INPUT:\n"); 618 usb_hid_descriptor_print_list(&parser->input); 619 620 usb_log_debug("OUTPUT: \n"); 621 usb_hid_descriptor_print_list(&parser->output); 622 623 usb_log_debug("FEATURE:\n"); 624 usb_hid_descriptor_print_list(&parser->feature); 625 728 626 } 729 627 … … 769 667 * @return void 770 668 */ 771 void usb_hid_free_report (usb_hid_report_t *report)772 { 773 if( report== NULL){669 void usb_hid_free_report_parser(usb_hid_report_parser_t *parser) 670 { 671 if(parser == NULL){ 774 672 return; 775 673 } 776 674 777 // free collection paths 778 usb_hid_report_path_t *path; 779 while(!list_empty(&report->collection_paths)) { 780 path = list_get_instance(report->collection_paths.next, usb_hid_report_path_t, link); 781 usb_hid_report_path_free(path); 782 } 783 784 // free report items 785 usb_hid_report_description_t *report_des; 786 usb_hid_report_field_t *field; 787 while(!list_empty(&report->reports)) { 788 report_des = list_get_instance(report->reports.next, usb_hid_report_description_t, link); 789 list_remove(&report_des->link); 790 791 while(!list_empty(&report_des->report_items)) { 792 field = list_get_instance(report_des->report_items.next, usb_hid_report_field_t, link); 793 list_remove(&field->link); 794 795 free(field); 796 } 797 798 free(report_des); 799 } 800 675 parser->use_report_id = 0; 676 677 usb_hid_free_report_list(&parser->input); 678 usb_hid_free_report_list(&parser->output); 679 usb_hid_free_report_list(&parser->feature); 680 801 681 return; 802 682 } … … 808 688 * @param parser Opaque HID report parser structure. 809 689 * @param data Data for the report. 690 * @param callbacks Callbacks for report actions. 691 * @param arg Custom argument (passed through to the callbacks). 810 692 * @return Error code. 811 693 */ 812 int usb_hid_parse_report(const usb_hid_report_t *report, 813 const uint8_t *data, size_t size, uint8_t *report_id) 694 int usb_hid_parse_report(const usb_hid_report_parser_t *parser, 695 const uint8_t *data, size_t size, 696 usb_hid_report_path_t *path, int flags, 697 const usb_hid_report_in_callbacks_t *callbacks, void *arg) 814 698 { 815 699 link_t *list_item; 816 usb_hid_report_field_t *item; 817 818 usb_hid_report_description_t *report_des; 819 usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT; 820 821 if(report == NULL) { 700 usb_hid_report_item_t *item; 701 uint8_t *keys; 702 uint8_t item_value; 703 size_t key_count=0; 704 size_t i=0; 705 size_t j=0; 706 uint8_t report_id = 0; 707 708 if(parser == NULL) { 822 709 return EINVAL; 823 710 } 824 825 if(report->use_report_ids != 0) { 826 *report_id = data[0]; 827 } 828 else { 829 *report_id = 0; 830 } 831 832 833 report_des = usb_hid_report_find_description(report, *report_id, type); 711 712 /* get the size of result array */ 713 key_count = usb_hid_report_input_length(parser, path, flags); 714 715 if(!(keys = malloc(sizeof(uint8_t) * key_count))){ 716 return ENOMEM; 717 } 718 719 if(parser->use_report_id != 0) { 720 report_id = data[0]; 721 usb_hid_report_path_set_report_id(path, report_id); 722 } 834 723 835 724 /* read data */ 836 list_item = report_des->report_items.next; 837 while(list_item != &(report_des->report_items)) { 838 839 item = list_get_instance(list_item, usb_hid_report_field_t, link); 840 841 if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) { 842 843 if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) { 844 845 // array 846 item->value = usb_hid_translate_data(item, data); 847 item->usage = (item->value - item->physical_minimum) + item->usage_minimum; 725 list_item = parser->input.next; 726 while(list_item != &(parser->input)) { 727 728 item = list_get_instance(list_item, usb_hid_report_item_t, link); 729 730 if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 731 (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) { 732 for(j=0; j<(size_t)(item->count); j++) { 733 if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) || 734 ((item->usage_minimum == 0) && (item->usage_maximum == 0))) { 735 // variable item 736 keys[i++] = usb_hid_translate_data(item, data,j); 737 } 738 else { 739 // bitmapa 740 if((item_value = usb_hid_translate_data(item, data, j)) != 0) { 741 keys[i++] = (item->count - 1 - j) + item->usage_minimum; 742 } 743 else { 744 keys[i++] = 0; 745 } 746 } 848 747 } 849 else {850 // variable item851 item->value = usb_hid_translate_data(item, data);852 }853 748 } 854 749 list_item = list_item->next; 855 750 } 751 752 callbacks->keyboard(keys, key_count, report_id, arg); 856 753 754 free(keys); 857 755 return EOK; 858 756 … … 860 758 861 759 /** 862 * Translate data from the report as specified in report descriptor item760 * Translate data from the report as specified in report descriptor 863 761 * 864 762 * @param item Report descriptor item with definition of translation … … 867 765 * @return Translated data 868 766 */ 869 int usb_hid_translate_data(usb_hid_report_ field_t *item, const uint8_t *data)767 int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j) 870 768 { 871 769 int resolution; … … 873 771 int part_size; 874 772 875 int32_t value =0;773 int32_t value; 876 774 int32_t mask; 877 775 const uint8_t *foo; 878 776 879 // now only shot tags are allowed777 // now only common numbers llowed 880 778 if(item->size > 32) { 881 779 return 0; 882 780 } 883 781 884 if((item->physical_minimum == 0) && (item->physical_maximum == 0)) {782 if((item->physical_minimum == 0) && (item->physical_maximum == 0)) { 885 783 item->physical_minimum = item->logical_minimum; 886 item->physical_maximum = item->logical_maximum; 887 } 888 784 item->physical_maximum = item->logical_maximum; 785 } 889 786 890 787 if(item->physical_maximum == item->physical_minimum){ … … 897 794 } 898 795 899 offset = item->offset; 796 offset = item->offset + (j * item->size); 797 if(item->id != 0) { 798 offset += 8; 799 usb_log_debug("MOVED OFFSET BY 1Byte, REPORT_ID(%d)\n", item->id); 800 } 801 900 802 // FIXME 901 if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) { 803 if((offset/8) != ((offset+item->size)/8)) { 804 usb_log_debug2("offset %d\n", offset); 902 805 903 806 part_size = ((offset+item->size)%8); 904 905 size_t i=0; 906 for(i=(size_t)(offset/8); i<=(size_t)(offset+item->size-1)/8; i++){ 907 if(i == (size_t)(offset/8)) { 908 // the higher one 909 foo = data + i; 910 mask = ((1 << (item->size-part_size))-1); 911 value = (*foo & mask) << part_size; 912 } 913 else if(i == ((offset+item->size-1)/8)){ 914 // the lower one 915 foo = data + i; 916 mask = ((1 << part_size)-1) << (8-part_size); 917 value += ((*foo & mask) >> (8-part_size)); 918 } 919 else { 920 value = value << 8; 921 value += *(data + 1); 922 } 923 } 807 usb_log_debug2("part size %d\n",part_size); 808 809 // the higher one 810 foo = data+(offset/8); 811 mask = ((1 << (item->size-part_size))-1); 812 value = (*foo & mask) << part_size; 813 814 usb_log_debug2("hfoo %x\n", *foo); 815 usb_log_debug2("hmaska %x\n", mask); 816 usb_log_debug2("hval %d\n", value); 817 818 // the lower one 819 foo = data+((offset+item->size)/8); 820 mask = ((1 << part_size)-1) << (8-part_size); 821 value += ((*foo & mask) >> (8-part_size)); 822 823 usb_log_debug2("lfoo %x\n", *foo); 824 usb_log_debug2("lmaska %x\n", mask); 825 usb_log_debug2("lval %d\n", ((*foo & mask) >> (8-(item->size-part_size)))); 826 usb_log_debug2("val %d\n", value); 827 828 924 829 } 925 830 else { … … 927 832 mask = ((1 << item->size)-1) << (8-((offset%8)+item->size)); 928 833 value = (*foo & mask) >> (8-((offset%8)+item->size)); 929 } 930 931 if((item->logical_minimum < 0) || (item->logical_maximum < 0)){ 932 value = USB_HID_UINT32_TO_INT32(value, item->size); 933 } 834 835 usb_log_debug2("offset %d\n", offset); 836 837 usb_log_debug2("foo %x\n", *foo); 838 usb_log_debug2("maska %x\n", mask); 839 usb_log_debug2("val %d\n", value); 840 } 841 842 usb_log_debug2("---\n\n"); 934 843 935 844 return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum); … … 938 847 939 848 /** 940 * Returns number of items in input report which are accessible by given usage path941 * 942 * @param parser Opaque report descriptor structure943 * @param path Usage path specification944 * @param flags Usage path comparison flags945 * @return Number of items in input report946 */ 947 size_t usb_hid_report_input_length(const usb_hid_report_ t *report,849 * 850 * 851 * @param parser 852 * @param path 853 * @param flags 854 * @return 855 */ 856 size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser, 948 857 usb_hid_report_path_t *path, int flags) 949 858 { 950 951 859 size_t ret = 0; 952 953 if(report == NULL) { 860 link_t *item; 861 usb_hid_report_item_t *report_item; 862 863 if(parser == NULL) { 954 864 return 0; 955 865 } 956 957 usb_hid_report_description_t *report_des; 958 report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_INPUT); 959 if(report_des == NULL) { 960 return 0; 961 } 962 963 link_t *field_it = report_des->report_items.next; 964 usb_hid_report_field_t *field; 965 while(field_it != &report_des->report_items) { 966 967 field = list_get_instance(field_it, usb_hid_report_field_t, link); 968 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) { 969 970 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); 971 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) { 972 ret++; 973 } 974 usb_hid_report_remove_last_item (field->collection_path); 866 867 item = parser->input.next; 868 while(&parser->input != item) { 869 report_item = list_get_instance(item, usb_hid_report_item_t, link); 870 if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) && 871 (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) { 872 ret += report_item->count; 975 873 } 976 977 field_it = field_it->next;978 } 874 875 item = item->next; 876 } 979 877 980 878 return ret; 981 } 982 983 984 /** 985 * Appends one item (couple of usage_path and usage) into the usage path 986 * structure 987 * 988 * @param usage_path Usage path structure 989 * @param usage_page Usage page constant 990 * @param usage Usage constant 991 * @return Error code 879 } 880 881 882 /** 883 * 884 * @param usage_path 885 * @param usage_page 886 * @param usage 887 * @return 992 888 */ 993 889 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, … … 1003 899 item->usage = usage; 1004 900 item->usage_page = usage_page; 1005 item->flags = 0; 1006 1007 list_append (&item->link, &usage_path->head); 901 902 usb_log_debug("Appending usage %d, usage page %d\n", usage, usage_page); 903 904 list_append (&usage_path->link, &item->link); 1008 905 usage_path->depth++; 1009 906 return EOK; … … 1011 908 1012 909 /** 1013 * Removes last item from the usage path structure1014 * @param usage_path 1015 * @return void910 * 911 * @param usage_path 912 * @return 1016 913 */ 1017 914 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path) … … 1019 916 usb_hid_report_usage_path_t *item; 1020 917 1021 if(!list_empty(&usage_path-> head)){1022 item = list_get_instance(usage_path-> head.prev, usb_hid_report_usage_path_t, link);1023 list_remove(usage_path-> head.prev);918 if(!list_empty(&usage_path->link)){ 919 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); 920 list_remove(usage_path->link.prev); 1024 921 usage_path->depth--; 1025 922 free(item); … … 1028 925 1029 926 /** 1030 * Nulls last item of the usage path structure.1031 927 * 1032 928 * @param usage_path 1033 * @return void929 * @return 1034 930 */ 1035 931 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path) … … 1037 933 usb_hid_report_usage_path_t *item; 1038 934 1039 if(!list_empty(&usage_path-> head)){1040 item = list_get_instance(usage_path-> head.prev, usb_hid_report_usage_path_t, link);935 if(!list_empty(&usage_path->link)){ 936 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); 1041 937 memset(item, 0, sizeof(usb_hid_report_usage_path_t)); 1042 938 } … … 1044 940 1045 941 /** 1046 * Modifies last item of usage path structure by given usage page or usage 1047 * 1048 * @param usage_path Opaque usage path structure 1049 * @param tag Class of currently processed tag (Usage page tag falls into Global 1050 * class but Usage tag into the Local) 1051 * @param data Value of the processed tag 1052 * @return void 942 * 943 * @param usage_path 944 * @param tag 945 * @param data 946 * @return 1053 947 */ 1054 948 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data) … … 1056 950 usb_hid_report_usage_path_t *item; 1057 951 1058 if(!list_empty(&usage_path-> head)){1059 item = list_get_instance(usage_path-> head.prev, usb_hid_report_usage_path_t, link);952 if(!list_empty(&usage_path->link)){ 953 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); 1060 954 1061 955 switch(tag) { … … 1071 965 } 1072 966 1073 1074 void usb_hid_print_usage_path(usb_hid_report_path_t *path) 1075 { 1076 usb_log_debug("USAGE_PATH FOR RId(%d):\n", path->report_id); 1077 usb_log_debug("\tLENGTH: %d\n", path->depth); 1078 1079 link_t *item = path->head.next; 1080 usb_hid_report_usage_path_t *path_item; 1081 while(item != &path->head) { 1082 1083 path_item = list_get_instance(item, usb_hid_report_usage_path_t, link); 1084 usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page); 1085 usb_log_debug("\tUSAGE: %X\n", path_item->usage); 1086 usb_log_debug("\tFLAGS: %d\n", path_item->flags); 1087 1088 item = item->next; 1089 } 1090 } 1091 1092 /** 1093 * Compares two usage paths structures 1094 * 1095 * If USB_HID_PATH_COMPARE_COLLECTION_ONLY flag is given, the last item in report_path structure is forgotten 1096 * 1097 * @param report_path usage path structure to compare 1098 * @param path usage patrh structure to compare 1099 * @param flags Flags determining the mode of comparison 1100 * @return EOK if both paths are identical, non zero number otherwise 967 /** 968 * 969 * 970 * @param report_path 971 * @param path 972 * @param flags 973 * @return 1101 974 */ 1102 975 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, … … 1132 1005 } 1133 1006 1134 report_link = report_path-> head.next;1135 path_link = path-> head.next;1007 report_link = report_path->link.next; 1008 path_link = path->link.next; 1136 1009 1137 while((report_link != &report_path-> head) && (path_link != &path->head)) {1010 while((report_link != &report_path->link) && (path_link != &path->link)) { 1138 1011 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); 1139 1012 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); … … 1149 1022 } 1150 1023 1151 if(((report_link == &report_path->head) && (path_link == &path->head)) || 1152 (((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) && (path_link = &path->head) && (report_link == report_path->head.prev))) { 1024 if((report_link == &report_path->link) && (path_link == &path->link)) { 1153 1025 return EOK; 1154 1026 } … … 1160 1032 /* compare with only the end of path*/ 1161 1033 case USB_HID_PATH_COMPARE_END: 1162 1163 if((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) { 1164 report_link = report_path->head.prev->prev; 1165 } 1166 else { 1167 report_link = report_path->head.prev; 1168 } 1169 path_link = path->head.prev; 1170 1171 if(list_empty(&path->head)){ 1034 report_link = report_path->link.prev; 1035 path_link = path->link.prev; 1036 1037 if(list_empty(&path->link)){ 1172 1038 return EOK; 1173 1039 } 1174 1040 1175 while((report_link != &report_path-> head) && (path_link != &path->head)) {1041 while((report_link != &report_path->link) && (path_link != &path->link)) { 1176 1042 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); 1177 1043 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); … … 1187 1053 } 1188 1054 1189 if(path_link == &path-> head) {1055 if(path_link == &path->link) { 1190 1056 return EOK; 1191 1057 } … … 1206 1072 1207 1073 /** 1208 * Allocates and initializes new usage path structure. 1209 * 1210 * @return Initialized usage path structure 1074 * 1075 * @return 1211 1076 */ 1212 1077 usb_hid_report_path_t *usb_hid_report_path(void) … … 1214 1079 usb_hid_report_path_t *path; 1215 1080 path = malloc(sizeof(usb_hid_report_path_t)); 1216 if( path == NULL){1081 if(!path){ 1217 1082 return NULL; 1218 1083 } … … 1221 1086 path->report_id = 0; 1222 1087 list_initialize(&path->link); 1223 list_initialize(&path->head);1224 1088 return path; 1225 1089 } … … 1227 1091 1228 1092 /** 1229 * Releases given usage path structure. 1230 * 1231 * @param path usage path structure to release 1093 * 1094 * @param path 1232 1095 * @return void 1233 1096 */ 1234 1097 void usb_hid_report_path_free(usb_hid_report_path_t *path) 1235 1098 { 1236 while(!list_empty(&path-> head)){1099 while(!list_empty(&path->link)){ 1237 1100 usb_hid_report_remove_last_item(path); 1238 1101 } 1239 1240 list_remove(&path->link);1241 free(path);1242 1102 } 1243 1103 … … 1246 1106 * Clone content of given usage path to the new one 1247 1107 * 1248 * @param usage_path Usage path structure to clone1249 * @return New copy of given usage path structure1108 * @param usage_path 1109 * @return 1250 1110 */ 1251 1111 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path) 1252 1112 { 1113 usb_hid_report_usage_path_t *path_item; 1253 1114 link_t *path_link; 1254 usb_hid_report_usage_path_t *path_item;1255 usb_hid_report_usage_path_t *new_path_item;1256 1115 usb_hid_report_path_t *new_usage_path = usb_hid_report_path (); 1257 1116 … … 1259 1118 return NULL; 1260 1119 } 1261 1262 new_usage_path->report_id = usage_path->report_id; 1263 1264 if(list_empty(&usage_path->head)){ 1120 1121 if(list_empty(&usage_path->link)){ 1265 1122 return new_usage_path; 1266 1123 } 1267 1124 1268 path_link = usage_path-> head.next;1269 while(path_link != &usage_path-> head) {1125 path_link = usage_path->link.next; 1126 while(path_link != &usage_path->link) { 1270 1127 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); 1271 new_path_item = malloc(sizeof(usb_hid_report_usage_path_t)); 1272 if(new_path_item == NULL) { 1273 return NULL; 1274 } 1275 1276 list_initialize (&new_path_item->link); 1277 new_path_item->usage_page = path_item->usage_page; 1278 new_path_item->usage = path_item->usage; 1279 new_path_item->flags = path_item->flags; 1280 1281 list_append(&new_path_item->link, &new_usage_path->head); 1282 new_usage_path->depth++; 1128 usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage); 1283 1129 1284 1130 path_link = path_link->next; … … 1291 1137 /*** OUTPUT API **/ 1292 1138 1293 /** 1294 * Allocates output report buffer for output report 1295 * 1296 * @param parser Report parsed structure 1297 * @param size Size of returned buffer 1298 * @param report_id Report id of created output report 1299 * @return Returns allocated output buffer for specified output 1300 */ 1301 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id) 1302 { 1303 if(report == NULL) { 1139 /** Allocates output report buffer 1140 * 1141 * @param parser 1142 * @param size 1143 * @return 1144 */ 1145 uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size) 1146 { 1147 if(parser == NULL) { 1304 1148 *size = 0; 1305 1149 return NULL; 1306 1150 } 1307 1308 link_t *report_it = report->reports.next; 1309 usb_hid_report_description_t *report_des = NULL; 1310 while(report_it != &report->reports) { 1311 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 1312 if((report_des->report_id == report_id) && (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){ 1313 break; 1314 } 1315 1316 report_it = report_it->next; 1317 } 1318 1319 if(report_des == NULL){ 1320 *size = 0; 1151 1152 // read the last output report item 1153 usb_hid_report_item_t *last; 1154 link_t *link; 1155 1156 link = parser->output.prev; 1157 if(link != &parser->output) { 1158 last = list_get_instance(link, usb_hid_report_item_t, link); 1159 *size = (last->offset + (last->size * last->count)) / 8; 1160 1161 uint8_t *buffer = malloc(sizeof(uint8_t) * (*size)); 1162 memset(buffer, 0, sizeof(uint8_t) * (*size)); 1163 usb_log_debug("output buffer: %s\n", usb_debug_str_buffer(buffer, *size, 0)); 1164 1165 return buffer; 1166 } 1167 else { 1168 *size = 0; 1321 1169 return NULL; 1322 1170 } 1323 else {1324 *size = (report_des->bit_length + (8 - 1))/8;1325 uint8_t *ret = malloc((*size) * sizeof(uint8_t));1326 memset(ret, 0, (*size) * sizeof(uint8_t));1327 return ret;1328 }1329 1171 } 1330 1172 … … 1333 1175 * 1334 1176 * @param output Output report buffer 1335 * @return void1177 * @return 1336 1178 */ 1337 1179 void usb_hid_report_output_free(uint8_t *output) … … 1345 1187 /** Returns size of output for given usage path 1346 1188 * 1347 * @param parser Opaque report parser structure1348 * @param path Usage path specified which items will be thought for the output1349 * @param flags Flags of usage path structure comparison1350 * @return Number of items matching the given usage path1351 */ 1352 size_t usb_hid_report_output_size(usb_hid_report_ t *report,1189 * @param parser 1190 * @param path 1191 * @param flags 1192 * @return 1193 */ 1194 size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser, 1353 1195 usb_hid_report_path_t *path, int flags) 1354 1196 { 1355 size_t ret = 0; 1356 usb_hid_report_description_t *report_des; 1357 1358 if(report == NULL) { 1197 size_t ret = 0; 1198 link_t *item; 1199 usb_hid_report_item_t *report_item; 1200 1201 if(parser == NULL) { 1359 1202 return 0; 1360 1203 } 1361 1204 1362 report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_OUTPUT); 1363 if(report_des == NULL){ 1364 return 0; 1365 } 1366 1367 link_t *field_it = report_des->report_items.next; 1368 usb_hid_report_field_t *field; 1369 while(field_it != &report_des->report_items) { 1370 1371 field = list_get_instance(field_it, usb_hid_report_field_t, link); 1372 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0){ 1373 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); 1374 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) { 1375 ret++; 1376 } 1377 usb_hid_report_remove_last_item (field->collection_path); 1205 item = parser->output.next; 1206 while(&parser->output != item) { 1207 report_item = list_get_instance(item, usb_hid_report_item_t, link); 1208 if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) && 1209 (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) { 1210 ret += report_item->count; 1378 1211 } 1379 1380 field_it = field_it->next;1381 } 1212 1213 item = item->next; 1214 } 1382 1215 1383 1216 return ret; … … 1385 1218 } 1386 1219 1387 /** Makes the output report buffer for data given in the report structure 1388 * 1389 * @param parser Opaque report parser structure 1390 * @param path Usage path specifing which parts of output will be set 1391 * @param flags Usage path structure comparison flags 1392 * @param buffer Output buffer 1393 * @param size Size of output buffer 1394 * @return Error code 1395 */ 1396 int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id, 1397 uint8_t *buffer, size_t size) 1398 { 1220 /** Updates the output report buffer by translated given data 1221 * 1222 * @param parser 1223 * @param path 1224 * @param flags 1225 * @param buffer 1226 * @param size 1227 * @param data 1228 * @param data_size 1229 * @return 1230 */ 1231 int usb_hid_report_output_translate(usb_hid_report_parser_t *parser, 1232 usb_hid_report_path_t *path, int flags, 1233 uint8_t *buffer, size_t size, 1234 int32_t *data, size_t data_size) 1235 { 1236 usb_hid_report_item_t *report_item; 1399 1237 link_t *item; 1238 size_t idx=0; 1239 int i=0; 1400 1240 int32_t value=0; 1401 1241 int offset; 1402 1242 int length; 1403 1243 int32_t tmp_value; 1404 1405 if(report == NULL) { 1244 size_t offset_prefix = 0; 1245 1246 if(parser == NULL) { 1406 1247 return EINVAL; 1407 1248 } 1408 1249 1409 if(report->use_report_ids != 0) { 1410 buffer[0] = report_id; 1250 if(parser->use_report_id != 0) { 1251 buffer[0] = path->report_id; 1252 offset_prefix = 8; 1411 1253 } 1412 1254 1413 1255 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); 1414 1415 usb_hid_report_description_t *report_des; 1416 report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT); 1417 if(report_des == NULL){ 1418 return EINVAL; 1419 } 1420 1421 usb_hid_report_field_t *report_item; 1422 item = report_des->report_items.next; 1423 while(item != &report_des->report_items) { 1424 report_item = list_get_instance(item, usb_hid_report_field_t, link); 1425 1426 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) { 1256 usb_log_debug("OUTPUT DATA[0]: %d, DATA[1]: %d, DATA[2]: %d\n", data[0], data[1], data[2]); 1257 1258 item = parser->output.next; 1259 while(item != &parser->output) { 1260 report_item = list_get_instance(item, usb_hid_report_item_t, link); 1261 1262 for(i=0; i<report_item->count; i++) { 1263 1264 if(idx >= data_size) { 1265 break; 1266 } 1267 1268 if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) || 1269 ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) { 1427 1270 1428 // array 1429 value = usb_hid_translate_data_reverse(report_item, report_item->value);1430 offset = report_item->offset ;1271 // // variable item 1272 value = usb_hid_translate_data_reverse(report_item, data[idx++]); 1273 offset = report_item->offset + (i * report_item->size) + offset_prefix; 1431 1274 length = report_item->size; 1432 1275 } 1433 1276 else { 1434 // variable item1435 value = usb_hid_translate_data_reverse(report_item, report_item->value);1436 offset = report_item->offset ;1437 length = report_item->size ;1277 //bitmap 1278 value += usb_hid_translate_data_reverse(report_item, data[idx++]); 1279 offset = report_item->offset + offset_prefix; 1280 length = report_item->size * report_item->count; 1438 1281 } 1439 1282 … … 1454 1297 } 1455 1298 else { 1456 int i = 0; 1299 // je to ve dvou!! FIXME: melo by to umet delsi jak 2 1300 1301 // konec prvniho -- dolni x bitu 1302 tmp_value = value; 1303 tmp_value = tmp_value & ((1 << (8-(offset%8)))-1); 1304 tmp_value = tmp_value << (offset%8); 1305 1457 1306 uint8_t mask = 0; 1458 for(i = (offset/8); i <= ((offset+length-1)/8); i++) { 1459 if(i == (offset/8)) { 1460 tmp_value = value; 1461 tmp_value = tmp_value & ((1 << (8-(offset%8)))-1); 1462 tmp_value = tmp_value << (offset%8); 1463 1464 mask = ~(((1 << (8-(offset%8)))-1) << (offset%8)); 1465 buffer[i] = (buffer[i] & mask) | tmp_value; 1466 } 1467 else if (i == ((offset + length -1)/8)) { 1468 1469 value = value >> (length - ((offset + length) % 8)); 1470 value = value & ((1 << (length - ((offset + length) % 8))) - 1); 1307 mask = ~(((1 << (8-(offset%8)))-1) << (offset%8)); 1308 buffer[offset/8] = (buffer[offset/8] & mask) | tmp_value; 1309 1310 // a ted druhej -- hornich length-x bitu 1311 value = value >> (8 - (offset % 8)); 1312 value = value & ((1 << (length - (8 - (offset % 8)))) - 1); 1471 1313 1472 mask = (1 << (length - ((offset + length) % 8))) - 1; 1473 buffer[i] = (buffer[i] & mask) | value; 1474 } 1475 else { 1476 buffer[i] = value & (0xFF << i); 1477 } 1478 } 1314 mask = ((1 << (length - (8 - (offset % 8)))) - 1); 1315 buffer[(offset+length-1)/8] = (buffer[(offset+length-1)/8] & mask) | value; 1479 1316 } 1480 1317 1481 1482 // reset value 1483 report_item->value = 0; 1484 1318 } 1319 1485 1320 item = item->next; 1486 1321 } 1487 1322 1488 1323 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); 1489 1324 … … 1492 1327 1493 1328 /** 1494 * Translate given data for putting them into the outoput report1495 * @param item Report item structure1496 * @param value Value to translate1497 * @return ranslated value1498 */ 1499 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value)1329 * 1330 * @param item 1331 * @param value 1332 * @return 1333 */ 1334 int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int value) 1500 1335 { 1501 1336 int ret=0; … … 1506 1341 } 1507 1342 1508 if((item->physical_minimum == 0) && (item->physical_maximum == 0)){1509 item->physical_minimum = item->logical_minimum;1510 item->physical_maximum = item->logical_maximum;1511 }1512 1513 1514 1343 if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) { 1515 1344 1516 1345 // variable item 1346 if((item->physical_minimum == 0) && (item->physical_maximum == 0)) { 1347 item->physical_minimum = item->logical_minimum; 1348 item->physical_maximum = item->logical_maximum; 1349 } 1350 1517 1351 if(item->physical_maximum == item->physical_minimum){ 1518 1352 resolution = 1; … … 1537 1371 } 1538 1372 1539 if((item->logical_minimum < 0) || (item->logical_maximum < 0)){ 1540 return USB_HID_INT32_TO_UINT32(ret, item->size); 1541 } 1542 return (int32_t)ret; 1543 } 1544 1545 /** 1546 * Sets report id in usage path structure 1547 * 1548 * @param path Usage path structure 1549 * @param report_id Report id to set 1550 * @return Error code 1551 */ 1373 1374 return ret; 1375 } 1376 1377 1552 1378 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id) 1553 1379 { … … 1557 1383 1558 1384 path->report_id = report_id; 1559 return EOK;1560 }1561 1562 /**1563 *1564 *1565 *1566 *1567 *1568 */1569 int usb_hid_report_output_set_data(usb_hid_report_t *report,1570 usb_hid_report_path_t *path, int flags,1571 int *data, size_t data_size)1572 {1573 size_t data_idx = 0;1574 if(report == NULL){1575 return EINVAL;1576 }1577 1578 usb_hid_report_description_t *report_des;1579 report_des = usb_hid_report_find_description (report, path->report_id,1580 USB_HID_REPORT_TYPE_OUTPUT);1581 if(report_des == NULL){1582 return EINVAL;1583 }1584 1585 usb_hid_report_field_t *field;1586 link_t *field_it = report_des->report_items.next;1587 while(field_it != &report_des->report_items){1588 1589 field = list_get_instance(field_it, usb_hid_report_field_t, link);1590 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {1591 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);1592 if(usb_hid_report_compare_usage_path (field->collection_path, path,1593 flags) == EOK) {1594 if(data_idx < data_size) {1595 if((data[data_idx] >= field->physical_minimum) && (data[data_idx] >= field->physical_minimum)) {1596 field->value = data[data_idx];1597 }1598 else {1599 return ERANGE;1600 }1601 1602 data_idx++;1603 }1604 else {1605 field->value = 0;1606 }1607 }1608 usb_hid_report_remove_last_item (field->collection_path);1609 }1610 1611 field_it = field_it->next;1612 }1613 1614 1385 return EOK; 1615 1386 } … … 1629 1400 } 1630 1401 1631 1632 usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,1633 usb_hid_report_field_t *field,1634 usb_hid_report_path_t *path, int flags,1635 usb_hid_report_type_t type)1636 {1637 usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type);1638 link_t *field_it;1639 1640 if(report_des == NULL){1641 return NULL;1642 }1643 1644 if(field == NULL){1645 // vezmu prvni co mathuje podle path!!1646 field_it = report_des->report_items.next;1647 }1648 else {1649 field_it = field->link.next;1650 }1651 1652 while(field_it != &report_des->report_items) {1653 field = list_get_instance(field_it, usb_hid_report_field_t, link);1654 1655 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {1656 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);1657 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){1658 usb_hid_report_remove_last_item (field->collection_path);1659 return field;1660 }1661 usb_hid_report_remove_last_item (field->collection_path);1662 }1663 field_it = field_it->next;1664 }1665 1666 return NULL;1667 }1668 1669 uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)1670 {1671 if(report == NULL){1672 return 0;1673 }1674 1675 usb_hid_report_description_t *report_des;1676 link_t *report_it;1677 1678 if(report_id == 0) {1679 report_it = usb_hid_report_find_description (report, report_id, type)->link.next;1680 }1681 else {1682 report_it = report->reports.next;1683 }1684 1685 while(report_it != &report->reports) {1686 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);1687 if(report_des->type == type){1688 return report_des->report_id;1689 }1690 }1691 1692 return 0;1693 }1694 1695 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)1696 {1697 if(report_item == NULL) {1698 return;1699 }1700 1701 report_item->usages_count = 0;1702 memset(report_item->usages, 0, USB_HID_MAX_USAGES);1703 1704 report_item->extended_usage_page = 0;1705 report_item->usage_minimum = 0;1706 report_item->usage_maximum = 0;1707 report_item->designator_index = 0;1708 report_item->designator_minimum = 0;1709 report_item->designator_maximum = 0;1710 report_item->string_index = 0;1711 report_item->string_minimum = 0;1712 report_item->string_maximum = 0;1713 1714 return;1715 }1716 1402 /** 1717 1403 * @}
Note:
See TracChangeset
for help on using the changeset viewer.
