Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision f19f1b71b92e839b0c60df61a9609e8fe1852c53) +++ uspace/lib/usb/Makefile (revision 257108970694dc38dad0bc4b0c8e34c979c8c8e3) @@ -43,5 +43,7 @@ src/dump.c \ src/hidiface.c \ + src/hidpath.c \ src/hidparser.c \ + src/hiddescriptor.c \ src/hub.c \ src/pipepriv.c \ Index: uspace/lib/usb/include/usb/classes/hid_report_items.h =================================================================== --- uspace/lib/usb/include/usb/classes/hid_report_items.h (revision f19f1b71b92e839b0c60df61a9609e8fe1852c53) +++ uspace/lib/usb/include/usb/classes/hid_report_items.h (revision 257108970694dc38dad0bc4b0c8e34c979c8c8e3) @@ -1,4 +1,4 @@ /* - * Copyright (c) 2010 Vojtech Horky + * Copyright (c) 2011 Matej Klonfar * All rights reserved. * @@ -37,4 +37,30 @@ #include + +/** + * Item prefix + */ +#define USB_HID_ITEM_SIZE(data) ((uint8_t)(data & 0x3)) +#define USB_HID_ITEM_TAG(data) ((uint8_t)((data & 0xF0) >> 4)) +#define USB_HID_ITEM_TAG_CLASS(data) ((uint8_t)((data & 0xC) >> 2)) +#define USB_HID_ITEM_IS_LONG(data) (data == 0xFE) + + +/** + * Input/Output/Feature Item flags + */ +/** Constant (1) / Variable (0) */ +#define USB_HID_ITEM_FLAG_CONSTANT(flags) ((flags & 0x1) == 0x1) +/** Variable (1) / Array (0) */ +#define USB_HID_ITEM_FLAG_VARIABLE(flags) ((flags & 0x2) == 0x2) +/** Absolute / Relative*/ +#define USB_HID_ITEM_FLAG_RELATIVE(flags) ((flags & 0x4) == 0x4) +/** Wrap / No Wrap */ +#define USB_HID_ITEM_FLAG_WRAP(flags) ((flags & 0x8) == 0x8) +#define USB_HID_ITEM_FLAG_LINEAR(flags) ((flags & 0x10) == 0x10) +#define USB_HID_ITEM_FLAG_PREFERRED(flags) ((flags & 0x20) == 0x20) +#define USB_HID_ITEM_FLAG_POSITION(flags) ((flags & 0x40) == 0x40) +#define USB_HID_ITEM_FLAG_VOLATILE(flags) ((flags & 0x80) == 0x80) +#define USB_HID_ITEM_FLAG_BUFFERED(flags) ((flags & 0x100) == 0x100) /* MAIN ITEMS */ Index: uspace/lib/usb/include/usb/classes/hidparser.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidparser.h (revision f19f1b71b92e839b0c60df61a9609e8fe1852c53) +++ uspace/lib/usb/include/usb/classes/hidparser.h (revision 257108970694dc38dad0bc4b0c8e34c979c8c8e3) @@ -1,4 +1,4 @@ /* - * Copyright (c) 2010 Vojtech Horky + * Copyright (c) 2011 Matej Klonfar * All rights reserved. * @@ -39,239 +39,7 @@ #include #include - -/** - * Item prefix - */ -#define USB_HID_ITEM_SIZE(data) ((uint8_t)(data & 0x3)) -#define USB_HID_ITEM_TAG(data) ((uint8_t)((data & 0xF0) >> 4)) -#define USB_HID_ITEM_TAG_CLASS(data) ((uint8_t)((data & 0xC) >> 2)) -#define USB_HID_ITEM_IS_LONG(data) (data == 0xFE) - - -/** - * Input/Output/Feature Item flags - */ -/** Constant (1) / Variable (0) */ -#define USB_HID_ITEM_FLAG_CONSTANT(flags) ((flags & 0x1) == 0x1) -/** Variable (1) / Array (0) */ -#define USB_HID_ITEM_FLAG_VARIABLE(flags) ((flags & 0x2) == 0x2) -/** Absolute / Relative*/ -#define USB_HID_ITEM_FLAG_RELATIVE(flags) ((flags & 0x4) == 0x4) -/** Wrap / No Wrap */ -#define USB_HID_ITEM_FLAG_WRAP(flags) ((flags & 0x8) == 0x8) -#define USB_HID_ITEM_FLAG_LINEAR(flags) ((flags & 0x10) == 0x10) -#define USB_HID_ITEM_FLAG_PREFERRED(flags) ((flags & 0x20) == 0x20) -#define USB_HID_ITEM_FLAG_POSITION(flags) ((flags & 0x40) == 0x40) -#define USB_HID_ITEM_FLAG_VOLATILE(flags) ((flags & 0x80) == 0x80) -#define USB_HID_ITEM_FLAG_BUFFERED(flags) ((flags & 0x100) == 0x100) - - -/** - * Description of path of usage pages and usages in report descriptor - */ -#define USB_HID_PATH_COMPARE_STRICT 0 -#define USB_HID_PATH_COMPARE_END 1 -#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 4 -#define USB_HID_PATH_COMPARE_COLLECTION_ONLY 2 /* porovnava jenom cestu z Kolekci */ - - -#define USB_HID_MAX_USAGES 20 - -typedef enum { - USB_HID_REPORT_TYPE_INPUT = 1, - USB_HID_REPORT_TYPE_OUTPUT = 2, - USB_HID_REPORT_TYPE_FEATURE = 3 -} usb_hid_report_type_t; - -/** Collection usage path structure */ -typedef struct { - /** */ - uint32_t usage_page; - /** */ - uint32_t usage; - - uint8_t flags; - /** */ - link_t link; -} usb_hid_report_usage_path_t; - -/** */ -typedef struct { - /** */ - int depth; - uint8_t report_id; - - /** */ - link_t link; /* list */ - - link_t head; /* head of list of usage paths */ - -} usb_hid_report_path_t; - - -typedef struct { - /** */ - int report_count; - link_t reports; /** list of usb_hid_report_description_t */ - - link_t collection_paths; - int collection_paths_count; - - int use_report_ids; - uint8_t last_report_id; - -} usb_hid_report_t; - -typedef struct { - uint8_t report_id; - usb_hid_report_type_t type; - - size_t bit_length; - size_t item_length; - - link_t report_items; /** list of report items (fields) */ - - link_t link; -} usb_hid_report_description_t; - -typedef struct { - - int offset; - size_t size; - - uint16_t usage_page; - uint16_t usage; - - uint8_t item_flags; - usb_hid_report_path_t *collection_path; - - int32_t logical_minimum; - int32_t logical_maximum; - int32_t physical_minimum; - int32_t physical_maximum; - uint32_t usage_minimum; - uint32_t usage_maximum; - uint32_t unit; - uint32_t unit_exponent; - - - int32_t value; - - link_t link; -} usb_hid_report_field_t; - - - -/** - * state table - */ -typedef struct { - /** report id */ - int32_t id; - - /** */ - uint16_t extended_usage_page; - uint32_t usages[USB_HID_MAX_USAGES]; - int usages_count; - - /** */ - uint32_t usage_page; - - /** */ - uint32_t usage_minimum; - /** */ - uint32_t usage_maximum; - /** */ - int32_t logical_minimum; - /** */ - int32_t logical_maximum; - /** */ - int32_t size; - /** */ - int32_t count; - /** */ - size_t offset; - /** */ - int32_t unit_exponent; - /** */ - int32_t unit; - - /** */ - uint32_t string_index; - /** */ - uint32_t string_minimum; - /** */ - uint32_t string_maximum; - /** */ - uint32_t designator_index; - /** */ - uint32_t designator_minimum; - /** */ - uint32_t designator_maximum; - /** */ - int32_t physical_minimum; - /** */ - int32_t physical_maximum; - - /** */ - uint8_t item_flags; - - usb_hid_report_type_t type; - - /** current collection path*/ - usb_hid_report_path_t *usage_path; - /** */ - link_t link; -} usb_hid_report_item_t; - -/** HID parser callbacks for IN items. */ -typedef struct { - /** Callback for keyboard. - * - * @param key_codes Array of pressed key (including modifiers). - * @param count Length of @p key_codes. - * @param arg Custom argument. - */ - void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t report_id, void *arg); -} usb_hid_report_in_callbacks_t; - - -typedef enum { - USB_HID_MOD_LCTRL = 0x01, - USB_HID_MOD_LSHIFT = 0x02, - USB_HID_MOD_LALT = 0x04, - USB_HID_MOD_LGUI = 0x08, - USB_HID_MOD_RCTRL = 0x10, - USB_HID_MOD_RSHIFT = 0x20, - USB_HID_MOD_RALT = 0x40, - USB_HID_MOD_RGUI = 0x80, - USB_HID_MOD_COUNT = 8 -} usb_hid_modifiers_t; - -static const usb_hid_modifiers_t - usb_hid_modifiers_consts[USB_HID_MOD_COUNT] = { - USB_HID_MOD_LCTRL, - USB_HID_MOD_LSHIFT, - USB_HID_MOD_LALT, - USB_HID_MOD_LGUI, - USB_HID_MOD_RCTRL, - USB_HID_MOD_RSHIFT, - USB_HID_MOD_RALT, - USB_HID_MOD_RGUI -}; - -/* - * Descriptor parser functions - */ - -/** */ -int usb_hid_parse_report_descriptor(usb_hid_report_t *report, - const uint8_t *data, size_t size); - -/** */ -void usb_hid_free_report(usb_hid_report_t *report); - -/** */ -void usb_hid_descriptor_print(usb_hid_report_t *report); +#include +#include +#include @@ -280,5 +48,6 @@ */ /** */ -int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, size_t size, uint8_t *report_id); +int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, + size_t size, uint8_t *report_id); /** */ @@ -286,46 +55,10 @@ usb_hid_report_path_t *path, int flags); - - -/* - * usage path functions - */ -/** */ -usb_hid_report_path_t *usb_hid_report_path(void); - -/** */ -void usb_hid_report_path_free(usb_hid_report_path_t *path); - -/** */ -int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path, uint8_t report_id); - -/** */ -int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, int32_t usage_page, int32_t usage); - -/** */ -void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path); - -/** */ -void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path); - -/** */ -void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data); - -/** */ -int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, usb_hid_report_path_t *path, int flags); - -/** */ -usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path); - -usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags, usb_hid_report_type_t type); - -uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type); - - /* * Output report parser functions */ /** Allocates output report buffer*/ -uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id); +uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, + uint8_t report_id); /** Frees output report buffer*/ @@ -336,11 +69,20 @@ usb_hid_report_path_t *path, int flags); -/** Sets data in report structure */ -int usb_hid_report_output_set_data(usb_hid_report_t *report, - usb_hid_report_path_t *path, int flags, - int *data, size_t data_size); +/** Makes the output report buffer by translated given data */ +int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id, + uint8_t *buffer, size_t size); -/** Makes the output report buffer by translated given data */ -int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id, uint8_t *buffer, size_t size); +/** */ +usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, + usb_hid_report_field_t *field, + usb_hid_report_path_t *path, + int flags, + usb_hid_report_type_t type); + +/** */ +uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, + uint8_t report_id, + usb_hid_report_type_t type); + #endif /** Index: uspace/lib/usb/src/hidparser.c =================================================================== --- uspace/lib/usb/src/hidparser.c (revision f19f1b71b92e839b0c60df61a9609e8fe1852c53) +++ uspace/lib/usb/src/hidparser.c (revision 257108970694dc38dad0bc4b0c8e34c979c8c8e3) @@ -1,4 +1,4 @@ /* - * Copyright (c) 2010 Vojtech Horky + * Copyright (c) 2011 Matej Klonfar * All rights reserved. * @@ -41,39 +41,5 @@ #include -/** The new report item flag. Used to determine when the item is completly - * configured and should be added to the report structure - */ -#define USB_HID_NEW_REPORT_ITEM 1 - -/** No special action after the report descriptor tag is processed should be - * done - */ -#define USB_HID_NO_ACTION 2 - -#define USB_HID_RESET_OFFSET 3 - -/** Unknown tag was founded in report descriptor data*/ -#define USB_HID_UNKNOWN_TAG -99 - -/* - * Private descriptor parser functions - */ -int usb_hid_report_init(usb_hid_report_t *report); -int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item); -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); -int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); -int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); -int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); -int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); - -void usb_hid_print_usage_path(usb_hid_report_path_t *path); -void usb_hid_descriptor_print_list(link_t *head); -void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item); -void usb_hid_free_report_list(link_t *head); -usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item); + /* * Data translation private functions @@ -85,6 +51,5 @@ int usb_pow(int a, int b); -#define USB_HID_UINT32_TO_INT32(x, size) ((((x) & (1 << ((size) - 1))) != 0) ? -(~(x - 1) & ((1 << size) - 1)) : (x)) //(-(~((x) - 1))) -#define USB_HID_INT32_TO_UINT32(x, size) (((x) < 0 ) ? ((1 << (size)) + (x)) : (x)) + // TODO: tohle ma bejt asi jinde int usb_pow(int a, int b) @@ -103,702 +68,6 @@ } -/** - * Initialize the report descriptor parser structure - * - * @param parser Report descriptor parser structure - * @return Error code - */ -int usb_hid_report_init(usb_hid_report_t *report) -{ - if(report == NULL) { - return EINVAL; - } - - memset(report, 0, sizeof(usb_hid_report_t)); - list_initialize(&report->reports); - list_initialize(&report->collection_paths); - - report->use_report_ids = 0; - return EOK; -} - -int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item) -{ - usb_hid_report_field_t *field; - int i; - - - /* find or append current collection path to the list */ - link_t *path_it = report->collection_paths.next; - usb_hid_report_path_t *path = NULL; - while(path_it != &report->collection_paths) { - path = list_get_instance(path_it, usb_hid_report_path_t, link); - - if(usb_hid_report_compare_usage_path(path, report_item->usage_path, USB_HID_PATH_COMPARE_STRICT) == EOK){ - break; - } - path_it = path_it->next; - } - if(path_it == &report->collection_paths) { - path = usb_hid_report_path_clone(report_item->usage_path); - list_append(&path->link, &report->collection_paths); - report->collection_paths_count++; - } - - for(i=0; iusages_count; i++){ - usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]); - } - - - for(i=0; icount; i++){ - - field = malloc(sizeof(usb_hid_report_field_t)); - memset(field, 0, sizeof(usb_hid_report_field_t)); - list_initialize(&field->link); - - /* fill the attributes */ - field->collection_path = path; - field->logical_minimum = report_item->logical_minimum; - field->logical_maximum = report_item->logical_maximum; - field->physical_minimum = report_item->physical_minimum; - field->physical_maximum = report_item->physical_maximum; - - field->usage_minimum = report_item->usage_minimum; - field->usage_maximum = report_item->usage_maximum; - if(report_item->extended_usage_page != 0){ - field->usage_page = report_item->extended_usage_page; - } - else { - field->usage_page = report_item->usage_page; - } - - if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) { - uint32_t usage; - if(report_item->type != USB_HID_REPORT_TYPE_INPUT) { - if(i < report_item->usages_count){ - usage = report_item->usages[i]; - } - else { - usage = report_item->usages[report_item->usages_count - 1]; - } - } - else { - if((report_item->count - i - 1) < report_item->usages_count){ - usage = report_item->usages[(report_item->count - i - 1)]; - } - else { - usage = report_item->usages[report_item->usages_count - 1]; - } - } - - - if((usage & 0xFFFF0000) != 0){ - field->usage_page = (usage >> 16); - field->usage = (usage & 0xFFFF); - } - else { - field->usage = usage; - } - - - } - - if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) { - if(report_item->type == USB_HID_REPORT_TYPE_INPUT) { - field->usage = report_item->usage_maximum - i; - } - else { - field->usage = report_item->usage_minimum + i; - } - - } - - field->size = report_item->size; - field->offset = report_item->offset + (i * report_item->size); - if(report_item->id != 0) { - field->offset += 8; - report->use_report_ids = 1; - } - field->item_flags = report_item->item_flags; - - /* find the right report list*/ - usb_hid_report_description_t *report_des; - report_des = usb_hid_report_find_description(report, report_item->id, report_item->type); - if(report_des == NULL){ - report_des = malloc(sizeof(usb_hid_report_description_t)); - memset(report_des, 0, sizeof(usb_hid_report_description_t)); - - report_des->type = report_item->type; - report_des->report_id = report_item->id; - list_initialize (&report_des->link); - list_initialize (&report_des->report_items); - - list_append(&report_des->link, &report->reports); - report->report_count++; - } - - /* append this field to the end of founded report list */ - list_append (&field->link, &report_des->report_items); - - /* update the sizes */ - report_des->bit_length += field->size; - report_des->item_length++; - - } - - - return EOK; -} - -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) -{ - link_t *report_it = report->reports.next; - usb_hid_report_description_t *report_des = NULL; - - while(report_it != &report->reports) { - report_des = list_get_instance(report_it, usb_hid_report_description_t, link); - - if((report_des->report_id == report_id) && (report_des->type == type)){ - return report_des; - } - - report_it = report_it->next; - } - - return NULL; -} - -/** Parse HID report descriptor. - * - * @param parser Opaque HID report parser structure. - * @param data Data describing the report. - * @return Error code. - */ -int usb_hid_parse_report_descriptor(usb_hid_report_t *report, - const uint8_t *data, size_t size) -{ - size_t i=0; - uint8_t tag=0; - uint8_t item_size=0; - int class=0; - int ret; - usb_hid_report_item_t *report_item=0; - usb_hid_report_item_t *new_report_item; - usb_hid_report_path_t *usage_path; - - size_t offset_input=0; - size_t offset_output=0; - size_t offset_feature=0; - - link_t stack; - list_initialize(&stack); - - /* parser structure initialization*/ - if(usb_hid_report_init(report) != EOK) { - return EINVAL; - } - - /*report item initialization*/ - if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){ - return ENOMEM; - } - memset(report_item, 0, sizeof(usb_hid_report_item_t)); - list_initialize(&(report_item->link)); - - /* usage path context initialization */ - if(!(usage_path=usb_hid_report_path())){ - return ENOMEM; - } - - while(i= size){ - return EINVAL; - } - - tag = USB_HID_ITEM_TAG(data[i]); - item_size = USB_HID_ITEM_SIZE(data[i]); - class = USB_HID_ITEM_TAG_CLASS(data[i]); - - ret = usb_hid_report_parse_tag(tag,class,data+i+1, - item_size,report_item, usage_path); - switch(ret){ - case USB_HID_NEW_REPORT_ITEM: - // store report item to report and create the new one - // store current collection path - report_item->usage_path = usage_path; - - usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id); - if(report_item->id != 0){ - report->use_report_ids = 1; - } - - switch(tag) { - case USB_HID_REPORT_TAG_INPUT: - report_item->type = USB_HID_REPORT_TYPE_INPUT; - report_item->offset = offset_input; - offset_input += report_item->count * report_item->size; - break; - case USB_HID_REPORT_TAG_OUTPUT: - report_item->type = USB_HID_REPORT_TYPE_OUTPUT; - report_item->offset = offset_output; - offset_output += report_item->count * report_item->size; - - break; - case USB_HID_REPORT_TAG_FEATURE: - report_item->type = USB_HID_REPORT_TYPE_FEATURE; - report_item->offset = offset_feature; - offset_feature += report_item->count * report_item->size; - break; - default: - usb_log_debug("\tjump over - tag %X\n", tag); - break; - } - - /* - * append new fields to the report - * structure - */ - usb_hid_report_append_fields(report, report_item); - - /* reset local items */ - usb_hid_report_reset_local_items (report_item); - - break; - - case USB_HID_RESET_OFFSET: - offset_input = 0; - offset_output = 0; - offset_feature = 0; - usb_hid_report_path_set_report_id (usage_path, report_item->id); - break; - - case USB_HID_REPORT_TAG_PUSH: - // push current state to stack - new_report_item = usb_hid_report_item_clone(report_item); - usb_hid_report_path_t *tmp_path = usb_hid_report_path_clone(usage_path); - new_report_item->usage_path = tmp_path; - - list_prepend (&new_report_item->link, &stack); - break; - case USB_HID_REPORT_TAG_POP: - // restore current state from stack - if(list_empty (&stack)) { - return EINVAL; - } - free(report_item); - - report_item = list_get_instance(stack.next, usb_hid_report_item_t, link); - - usb_hid_report_usage_path_t *tmp_usage_path; - tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link); - - usb_hid_report_set_last_item(usage_path, tmp_usage_path->usage_page, tmp_usage_path->usage); - - usb_hid_report_path_free(report_item->usage_path); - list_initialize(&report_item->usage_path->link); - list_remove (stack.next); - - break; - - default: - // nothing special to do - break; - } - - /* jump over the processed block */ - i += 1 + USB_HID_ITEM_SIZE(data[i]); - } - else{ - // TBD - i += 3 + USB_HID_ITEM_SIZE(data[i+1]); - } - - - } - - return EOK; -} - - -/** - * Parse one tag of the report descriptor - * - * @param Tag to parse - * @param Report descriptor buffer - * @param Size of data belongs to this tag - * @param Current report item structe - * @return Code of action to be done next - */ -int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) -{ - int ret; - - switch(class){ - case USB_HID_TAG_CLASS_MAIN: - - if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) { - return USB_HID_NEW_REPORT_ITEM; - } - else { - /*TODO process the error */ - return ret; - } - break; - - case USB_HID_TAG_CLASS_GLOBAL: - return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path); - break; - - case USB_HID_TAG_CLASS_LOCAL: - return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path); - break; - default: - return USB_HID_NO_ACTION; - } -} - -/** - * Parse main tags of report descriptor - * - * @param Tag identifier - * @param Data buffer - * @param Length of data buffer - * @param Current state table - * @return Error code - */ - -int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) -{ - switch(tag) - { - case USB_HID_REPORT_TAG_INPUT: - case USB_HID_REPORT_TAG_OUTPUT: - case USB_HID_REPORT_TAG_FEATURE: - report_item->item_flags = *data; - return EOK; - break; - - case USB_HID_REPORT_TAG_COLLECTION: - // TODO usage_path->flags = *data; - usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]); - usb_hid_report_reset_local_items (report_item); - return USB_HID_NO_ACTION; - break; - - case USB_HID_REPORT_TAG_END_COLLECTION: - usb_hid_report_remove_last_item(usage_path); - return USB_HID_NO_ACTION; - break; - default: - return USB_HID_NO_ACTION; - } - - return EOK; -} - -/** - * Parse global tags of report descriptor - * - * @param Tag identifier - * @param Data buffer - * @param Length of data buffer - * @param Current state table - * @return Error code - */ -int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) -{ - // TODO take care about the bit length of data - switch(tag) - { - case USB_HID_REPORT_TAG_USAGE_PAGE: - report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size); - break; - case USB_HID_REPORT_TAG_LOGICAL_MINIMUM: - report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); - break; - case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM: - report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); - break; - case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM: - report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); - break; - case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM: - report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8); - - break; - case USB_HID_REPORT_TAG_UNIT_EXPONENT: - report_item->unit_exponent = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_UNIT: - report_item->unit = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_REPORT_SIZE: - report_item->size = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_REPORT_COUNT: - report_item->count = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_REPORT_ID: - report_item->id = usb_hid_report_tag_data_uint32(data,item_size); - return USB_HID_RESET_OFFSET; - break; - case USB_HID_REPORT_TAG_PUSH: - case USB_HID_REPORT_TAG_POP: - /* - * stack operations are done in top level parsing - * function - */ - return tag; - break; - - default: - return USB_HID_NO_ACTION; - } - - return EOK; -} - -/** - * Parse local tags of report descriptor - * - * @param Tag identifier - * @param Data buffer - * @param Length of data buffer - * @param Current state table - * @return Error code - */ -int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size, - usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) -{ - switch(tag) - { - case USB_HID_REPORT_TAG_USAGE: - report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size); - report_item->usages_count++; - break; - case USB_HID_REPORT_TAG_USAGE_MINIMUM: - if (item_size == 3) { - // usage extended usages - report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; - report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF; - } - else { - report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size); - } - break; - case USB_HID_REPORT_TAG_USAGE_MAXIMUM: - if (item_size == 3) { - // usage extended usages - report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; - report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF; - } - else { - report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size); - } - break; - case USB_HID_REPORT_TAG_DESIGNATOR_INDEX: - report_item->designator_index = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM: - report_item->designator_minimum = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM: - report_item->designator_maximum = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_STRING_INDEX: - report_item->string_index = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_STRING_MINIMUM: - report_item->string_minimum = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_STRING_MAXIMUM: - report_item->string_maximum = usb_hid_report_tag_data_uint32(data,item_size); - break; - case USB_HID_REPORT_TAG_DELIMITER: - //report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size); - //TODO: - // DELIMITER STUFF - break; - - default: - return USB_HID_NO_ACTION; - } - - return EOK; -} - -/** - * Converts raw data to uint32 (thats the maximum length of short item data) - * - * @param Data buffer - * @param Size of buffer - * @return Converted int32 number - */ -uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size) -{ - unsigned int i; - uint32_t result; - - result = 0; - for(i=0; inext; item != head; item = item->next) { - - report_item = list_get_instance(item, usb_hid_report_field_t, link); - - usb_log_debug("\t\tOFFSET: %X\n", report_item->offset); - usb_log_debug("\t\tSIZE: %X\n", report_item->size); - usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum); - usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum); - usb_log_debug("\t\tPHYMIN: %d\n", report_item->physical_minimum); - usb_log_debug("\t\tPHYMAX: %d\n", report_item->physical_maximum); - usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum); - usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum); - - usb_log_debug("\t\tVALUE: %X\n", report_item->value); - usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage); - usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page); - -// usb_log_debug("\n"); - - } - - -} -/** - * Prints content of given report descriptor in human readable format. - * - * @param parser Parsed descriptor to print - * @return void - */ -void usb_hid_descriptor_print(usb_hid_report_t *report) -{ - if(report == NULL) { - return; - } - - link_t *report_it = report->reports.next; - usb_hid_report_description_t *report_des; - - while(report_it != &report->reports) { - report_des = list_get_instance(report_it, usb_hid_report_description_t, link); - usb_log_debug("Report ID: %d\n", report_des->report_id); - usb_log_debug("\tType: %d\n", report_des->type); - usb_log_debug("\tLength: %d\n", report_des->bit_length); - usb_log_debug("\tItems: %d\n", report_des->item_length); - - usb_hid_descriptor_print_list(&report_des->report_items); - - - link_t *path_it = report->collection_paths.next; - while(path_it != &report->collection_paths) { - usb_hid_print_usage_path (list_get_instance(path_it, usb_hid_report_path_t, link)); - path_it = path_it->next; - } - - report_it = report_it->next; - } -} - -/** - * Releases whole linked list of report items - * - * @param head Head of list of report descriptor items (usb_hid_report_item_t) - * @return void - */ -void usb_hid_free_report_list(link_t *head) -{ - return; - - usb_hid_report_item_t *report_item; - link_t *next; - - if(head == NULL || list_empty(head)) { - return; - } - - next = head->next; - while(next != head) { - - report_item = list_get_instance(next, usb_hid_report_item_t, link); - - while(!list_empty(&report_item->usage_path->link)) { - usb_hid_report_remove_last_item(report_item->usage_path); - } - - - next = next->next; - - free(report_item); - } - - return; - -} - -/** Frees the HID report descriptor parser structure - * - * @param parser Opaque HID report parser structure - * @return void - */ -void usb_hid_free_report(usb_hid_report_t *report) -{ - if(report == NULL){ - return; - } - - // free collection paths - usb_hid_report_path_t *path; - while(!list_empty(&report->collection_paths)) { - path = list_get_instance(report->collection_paths.next, usb_hid_report_path_t, link); - usb_hid_report_path_free(path); - } - - // free report items - usb_hid_report_description_t *report_des; - usb_hid_report_field_t *field; - while(!list_empty(&report->reports)) { - report_des = list_get_instance(report->reports.next, usb_hid_report_description_t, link); - list_remove(&report_des->link); - - while(!list_empty(&report_des->report_items)) { - field = list_get_instance(report_des->report_items.next, usb_hid_report_field_t, link); - list_remove(&field->link); - - free(field); - } - - free(report_des); - } - - return; -} + + /** Parse and act upon a HID report. @@ -980,312 +249,4 @@ return ret; } - - -/** - * Appends one item (couple of usage_path and usage) into the usage path - * structure - * - * @param usage_path Usage path structure - * @param usage_page Usage page constant - * @param usage Usage constant - * @return Error code - */ -int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, - int32_t usage_page, int32_t usage) -{ - usb_hid_report_usage_path_t *item; - - if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) { - return ENOMEM; - } - list_initialize(&item->link); - - item->usage = usage; - item->usage_page = usage_page; - item->flags = 0; - - list_append (&item->link, &usage_path->head); - usage_path->depth++; - return EOK; -} - -/** - * Removes last item from the usage path structure - * @param usage_path - * @return void - */ -void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path) -{ - usb_hid_report_usage_path_t *item; - - if(!list_empty(&usage_path->head)){ - item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link); - list_remove(usage_path->head.prev); - usage_path->depth--; - free(item); - } -} - -/** - * Nulls last item of the usage path structure. - * - * @param usage_path - * @return void - */ -void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path) -{ - usb_hid_report_usage_path_t *item; - - if(!list_empty(&usage_path->head)){ - item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link); - memset(item, 0, sizeof(usb_hid_report_usage_path_t)); - } -} - -/** - * Modifies last item of usage path structure by given usage page or usage - * - * @param usage_path Opaque usage path structure - * @param tag Class of currently processed tag (Usage page tag falls into Global - * class but Usage tag into the Local) - * @param data Value of the processed tag - * @return void - */ -void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data) -{ - usb_hid_report_usage_path_t *item; - - if(!list_empty(&usage_path->head)){ - item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link); - - switch(tag) { - case USB_HID_TAG_CLASS_GLOBAL: - item->usage_page = data; - break; - case USB_HID_TAG_CLASS_LOCAL: - item->usage = data; - break; - } - } - -} - - -void usb_hid_print_usage_path(usb_hid_report_path_t *path) -{ - usb_log_debug("USAGE_PATH FOR RId(%d):\n", path->report_id); - usb_log_debug("\tLENGTH: %d\n", path->depth); - - link_t *item = path->head.next; - usb_hid_report_usage_path_t *path_item; - while(item != &path->head) { - - path_item = list_get_instance(item, usb_hid_report_usage_path_t, link); - usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page); - usb_log_debug("\tUSAGE: %X\n", path_item->usage); - usb_log_debug("\tFLAGS: %d\n", path_item->flags); - - item = item->next; - } -} - -/** - * Compares two usage paths structures - * - * If USB_HID_PATH_COMPARE_COLLECTION_ONLY flag is given, the last item in report_path structure is forgotten - * - * @param report_path usage path structure to compare - * @param path usage patrh structure to compare - * @param flags Flags determining the mode of comparison - * @return EOK if both paths are identical, non zero number otherwise - */ -int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, - usb_hid_report_path_t *path, - int flags) -{ - usb_hid_report_usage_path_t *report_item; - usb_hid_report_usage_path_t *path_item; - - link_t *report_link; - link_t *path_link; - - int only_page; - - if(report_path->report_id != path->report_id) { - return 1; - } - - if(path->depth == 0){ - return EOK; - } - - - if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){ - flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY; - } - - switch(flags){ - /* path must be completly identical */ - case USB_HID_PATH_COMPARE_STRICT: - if(report_path->depth != path->depth){ - return 1; - } - - report_link = report_path->head.next; - path_link = path->head.next; - - while((report_link != &report_path->head) && (path_link != &path->head)) { - report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); - path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); - - if((report_item->usage_page != path_item->usage_page) || - ((only_page == 0) && (report_item->usage != path_item->usage))) { - return 1; - } else { - report_link = report_link->next; - path_link = path_link->next; - } - - } - - if(((report_link == &report_path->head) && (path_link == &path->head)) || - (((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) && (path_link = &path->head) && (report_link == report_path->head.prev))) { - return EOK; - } - else { - return 1; - } - break; - - /* compare with only the end of path*/ - case USB_HID_PATH_COMPARE_END: - - if((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) { - report_link = report_path->head.prev->prev; - } - else { - report_link = report_path->head.prev; - } - path_link = path->head.prev; - - if(list_empty(&path->head)){ - return EOK; - } - - while((report_link != &report_path->head) && (path_link != &path->head)) { - report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); - path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); - - if((report_item->usage_page != path_item->usage_page) || - ((only_page == 0) && (report_item->usage != path_item->usage))) { - return 1; - } else { - report_link = report_link->prev; - path_link = path_link->prev; - } - - } - - if(path_link == &path->head) { - return EOK; - } - else { - return 1; - } - - break; - - default: - return EINVAL; - } - - - - -} - -/** - * Allocates and initializes new usage path structure. - * - * @return Initialized usage path structure - */ -usb_hid_report_path_t *usb_hid_report_path(void) -{ - usb_hid_report_path_t *path; - path = malloc(sizeof(usb_hid_report_path_t)); - if(path == NULL){ - return NULL; - } - else { - path->depth = 0; - path->report_id = 0; - list_initialize(&path->link); - list_initialize(&path->head); - return path; - } -} - -/** - * Releases given usage path structure. - * - * @param path usage path structure to release - * @return void - */ -void usb_hid_report_path_free(usb_hid_report_path_t *path) -{ - while(!list_empty(&path->head)){ - usb_hid_report_remove_last_item(path); - } - - list_remove(&path->link); - free(path); -} - - -/** - * Clone content of given usage path to the new one - * - * @param usage_path Usage path structure to clone - * @return New copy of given usage path structure - */ -usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path) -{ - link_t *path_link; - usb_hid_report_usage_path_t *path_item; - usb_hid_report_usage_path_t *new_path_item; - usb_hid_report_path_t *new_usage_path = usb_hid_report_path (); - - if(new_usage_path == NULL){ - return NULL; - } - - new_usage_path->report_id = usage_path->report_id; - - if(list_empty(&usage_path->head)){ - return new_usage_path; - } - - path_link = usage_path->head.next; - while(path_link != &usage_path->head) { - path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); - new_path_item = malloc(sizeof(usb_hid_report_usage_path_t)); - if(new_path_item == NULL) { - return NULL; - } - - list_initialize (&new_path_item->link); - new_path_item->usage_page = path_item->usage_page; - new_path_item->usage = path_item->usage; - new_path_item->flags = path_item->flags; - - list_append(&new_path_item->link, &new_usage_path->head); - new_usage_path->depth++; - - path_link = path_link->next; - } - - return new_usage_path; -} - /*** OUTPUT API **/ @@ -1543,77 +504,4 @@ } -/** - * Sets report id in usage path structure - * - * @param path Usage path structure - * @param report_id Report id to set - * @return Error code - */ -int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id) -{ - if(path == NULL){ - return EINVAL; - } - - path->report_id = report_id; - return EOK; -} - -/** - * - * - * - * - * - */ -int usb_hid_report_output_set_data(usb_hid_report_t *report, - usb_hid_report_path_t *path, int flags, - int *data, size_t data_size) -{ - size_t data_idx = 0; - if(report == NULL){ - return EINVAL; - } - - usb_hid_report_description_t *report_des; - report_des = usb_hid_report_find_description (report, path->report_id, - USB_HID_REPORT_TYPE_OUTPUT); - if(report_des == NULL){ - return EINVAL; - } - - usb_hid_report_field_t *field; - link_t *field_it = report_des->report_items.next; - while(field_it != &report_des->report_items){ - - field = list_get_instance(field_it, usb_hid_report_field_t, link); - if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) { - usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); - if(usb_hid_report_compare_usage_path (field->collection_path, path, - flags) == EOK) { - if(data_idx < data_size) { - if((data[data_idx] >= field->physical_minimum) && (data[data_idx] >= field->physical_minimum)) { - field->value = data[data_idx]; - } - else { - return ERANGE; - } - - data_idx++; - } - else { - field->value = 0; - } - } - usb_hid_report_remove_last_item (field->collection_path); - } - - field_it = field_it->next; - } - - return EOK; -} - - usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item) {