Changes in uspace/lib/usb/src/hidparser.c [4125b7d:7304663] in mainline

File:

• uspace/lib/usb/src/hidparser.c (modified) (57 diffs)

uspace/lib/usb/src/hidparser.c

@@ -39 +39 @@
 #include <mem.h>
 #include <usb/debug.h>
-
-/** */
+#include <assert.h>
+
+/** 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
 
-/** */
-#define USB_HID_NO_ACTION               2
-
-/** */
+/** 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
 
@@ -52 +59 @@
  * 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);
@@ -61 +71 @@
                              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);
-int usb_hid_report_reset_local_items();
+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);
@@ -68 +79 @@
  * Data translation private functions
  */
-int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size);
+uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
 inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
-int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j);
-int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int32_t value);
+int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data);
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value);
 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)
@@ -96 +109 @@
  * @return Error code
  */
-int usb_hid_parser_init(usb_hid_report_parser_t *parser)
-{
-        if(parser == NULL) {
+int usb_hid_report_init(usb_hid_report_t *report)
+{
+        if(report == NULL) {
                 return EINVAL;
         }
 
-        list_initialize(&(parser->input));
-    list_initialize(&(parser->output));
-    list_initialize(&(parser->feature));
-
-        list_initialize(&(parser->stack));
-
-        parser->use_report_id = 0;
+        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; i<report_item->usages_count; i++){
+                usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]);
+        }
+
+        
+        for(i=0; i<report_item->count; 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 & 0xFF00) != 0){
+                                field->usage_page = (usage >> 16);                                      
+                                field->usage = (usage & 0xFF);
+                        }
+                        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.
@@ -119 +275 @@
  * @return Error code.
  */
-int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, 
+int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
     const uint8_t *data, size_t size)
 {
@@ -130 +286 @@
         usb_hid_report_item_t *new_report_item; 
         usb_hid_report_path_t *usage_path;
-        usb_hid_report_path_t *tmp_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_parser_init(parser) != EOK) {
+        if(usb_hid_report_init(report) != EOK) {
                 return EINVAL;
         }
         
-
         /*report item initialization*/
         if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
@@ -159 +315 @@
 
                         if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
-                                return EINVAL; // TODO ERROR CODE
+                                return EINVAL;
                         }
                         
@@ -165 +321 @@
                         item_size = USB_HID_ITEM_SIZE(data[i]);
                         class = USB_HID_ITEM_TAG_CLASS(data[i]);
-
-                        usb_log_debug2(
-                                "i(%zu) data(%X) value(%X): TAG %d, class %u, size %u - ", i,
-                            data[i], usb_hid_report_tag_data_int32(data+i+1,item_size), 
-                            tag, class, item_size);
                         
                         ret = usb_hid_report_parse_tag(tag,class,data+i+1,
                                                        item_size,report_item, usage_path);
-                        usb_log_debug2("ret: %u\n", ret);
                         switch(ret){
                                 case USB_HID_NEW_REPORT_ITEM:
                                         // store report item to report and create the new one
-                                        usb_log_debug("\nNEW REPORT ITEM: %X",ret);
-
-                                        // store current usage path
+                                        // store current collection path
                                         report_item->usage_path = usage_path;
                                         
-                                        // clone path to the new one
-                                        tmp_usage_path = usb_hid_report_path_clone(usage_path);
-
-                                        // swap
-                                        usage_path = tmp_usage_path;
-                                        tmp_usage_path = NULL;
-
                                         usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id);    
                                         if(report_item->id != 0){
-                                                parser->use_report_id = 1;
+                                                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;
-                                                        usb_log_debug(" - INPUT\n");
-                                                        list_append(&(report_item->link), &(parser->input));
                                                         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;
-                                                        usb_log_debug(" - OUTPUT\n");
-                                                                list_append(&(report_item->link), &(parser->output));
 
                                                         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;
-                                                        usb_log_debug(" - FEATURE\n");
-                                                                list_append(&(report_item->link), &(parser->feature));
                                                         break;
                                                 default:
@@ -218 +356 @@
                                                     break;
                                         }
-
-                                        /* clone current state table to the new item */
-                                        if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
-                                                return ENOMEM;
-                                        }                                       
-                                        memcpy(new_report_item,report_item, sizeof(usb_hid_report_item_t));
-                                        link_initialize(&(new_report_item->link));
                                         
+                                        /* 
+                                         * append new fields to the report
+                                         * structure                                     
+                                         */
+                                        usb_hid_report_append_fields(report, report_item);
+
                                         /* reset local items */
-                                        new_report_item->usage_minimum = 0;
-                                        new_report_item->usage_maximum = 0;
-                                        new_report_item->designator_index = 0;
-                                        new_report_item->designator_minimum = 0;
-                                        new_report_item->designator_maximum = 0;
-                                        new_report_item->string_index = 0;
-                                        new_report_item->string_minimum = 0;
-                                        new_report_item->string_maximum = 0;
-
-                                        /* reset usage from current usage path */
-                                        usb_hid_report_usage_path_t *path = list_get_instance(&usage_path->link, usb_hid_report_usage_path_t, link);
-                                        path->usage = 0;
-                                        
-                                        report_item = new_report_item;
-                                                                                
+                                        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);
-                                        list_prepend (&parser->stack, &new_report_item->link);
-                                        
+                                        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 (&parser->stack)) {
+                                        if(list_empty (&stack)) {
                                                 return EINVAL;
                                         }
+                                        free(report_item);
+                                                
+                                        report_item = list_get_instance(stack.next, usb_hid_report_item_t, link);
                                         
-                                        report_item = list_get_instance(&parser->stack, usb_hid_report_item_t, link);
-                                        list_remove (parser->stack.next);
+                                        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;
@@ -279 +422 @@
 }
 
-
-/**
- * Parse input report.
- *
- * @param data Data for report
- * @param size Size of report
- * @param callbacks Callbacks for report actions
- * @param arg Custom arguments
- *
- * @return Error code
- */
-int usb_hid_boot_keyboard_input_report(const uint8_t *data, size_t size,
-        const usb_hid_report_in_callbacks_t *callbacks, void *arg)
-{
-        int i;
-        usb_hid_report_item_t item;
-
-        /* fill item due to the boot protocol report descriptor */
-        // modifier keys are in the first byte
-        uint8_t modifiers = data[0];
-
-        item.offset = 2; /* second byte is reserved */
-        item.size = 8;
-        item.count = 6;
-        item.usage_minimum = 0;
-        item.usage_maximum = 255;
-        item.logical_minimum = 0;
-        item.logical_maximum = 255;
-
-        if (size != 8) {
-                return -1; //ERANGE;
-        }
-
-        uint8_t keys[6];
-        for (i = 0; i < item.count; i++) {
-                keys[i] = data[i + item.offset];
-        }
-
-        callbacks->keyboard(keys, 6, modifiers, arg);
-        return EOK;
-}
-
-/**
- * Makes output report for keyboard boot protocol
- *
- * @param leds
- * @param output Output report data buffer
- * @param size Size of the output buffer
- * @return Error code
- */
-int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size)
-{
-        if(size != 1){
-                return -1;
-        }
-
-        /* used only first five bits, others are only padding*/
-        *data = leds;
-        return EOK;
-}
 
 /**
@@ -401 +484 @@
                         
                 case USB_HID_REPORT_TAG_COLLECTION:
-                        usb_hid_report_path_append_item(usage_path, 0, 0);
-                                                
+                        // 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:
-                        // TODO
-                        // znici posledni uroven ve vsech usage paths
-                        // otazka jestli nema nicit dve, respektive novou posledni vynulovat?
                         usb_hid_report_remove_last_item(usage_path);
                         return USB_HID_NO_ACTION;
@@ -436 +517 @@
         {
                 case USB_HID_REPORT_TAG_USAGE_PAGE:
-                        // zmeni to jenom v poslednim poli aktualni usage path
-                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL,
-                                usb_hid_report_tag_data_int32(data,item_size));
+                        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_report_tag_data_int32(data,item_size);
+                        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_report_tag_data_int32(data,item_size);
+                        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_report_tag_data_int32(data,item_size);
+                        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_report_tag_data_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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;
@@ -475 +560 @@
                         return USB_HID_NO_ACTION;
         }
-        
+
         return EOK;
 }
@@ -494 +579 @@
         {
                 case USB_HID_REPORT_TAG_USAGE:
-                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL,
-                                usb_hid_report_tag_data_int32(data,item_size));
+                        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:
-                        report_item->usage_minimum = usb_hid_report_tag_data_int32(data,item_size);
+                        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:
-                        report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        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_int32(data,item_size);
+                        //report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size);
+                        //TODO: 
+                        //      DELIMITER STUFF
                         break;
                 
@@ -533 +634 @@
 
 /**
- * Converts raw data to int32 (thats the maximum length of short item data)
+ * Converts raw data to uint32 (thats the maximum length of short item data)
  *
  * @param Data buffer
@@ -539 +640 @@
  * @return Converted int32 number
  */
-int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size)
+uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size)
 {
         unsigned int i;
-        int32_t result;
+        uint32_t result;
 
         result = 0;
@@ -552 +653 @@
 }
 
-
-
 /**
  * Prints content of given list of report items.
@@ -562 +661 @@
 void usb_hid_descriptor_print_list(link_t *head)
 {
-        usb_hid_report_item_t *report_item;
-        usb_hid_report_usage_path_t *path_item;
-        link_t *path;
+        usb_hid_report_field_t *report_item;
         link_t *item;
-        
+
+
         if(head == NULL || list_empty(head)) {
             usb_log_debug("\tempty\n");
@@ -574 +672 @@
         for(item = head->next; item != head; item = item->next) {
                 
-                report_item = list_get_instance(item, usb_hid_report_item_t, link);
-
-                usb_log_debug("\tOFFSET: %zX\n", report_item->offset);
-                usb_log_debug("\tCOUNT: %X\n", report_item->count);
-                usb_log_debug("\tSIZE: %X\n", report_item->size);
-                usb_log_debug("\tCONSTANT/VAR: %X\n", USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags));
-                usb_log_debug("\tVARIABLE/ARRAY: %X\n", USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags));
-                usb_log_debug("\tUSAGE PATH:\n");
-
-                path = report_item->usage_path->link.next;
-                while(path != &report_item->usage_path->link)   {
-                        path_item = list_get_instance(path, usb_hid_report_usage_path_t, link);
-                        usb_log_debug("\t\tUSAGE PAGE: %X, USAGE: %X\n", path_item->usage_page, path_item->usage);
-                        path = path->next;
-                }
-                                
-                usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum);
-                usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum);          
-                usb_log_debug("\tPHYMIN: %X\n", report_item->physical_minimum);         
-                usb_log_debug("\tPHYMAX: %X\n", report_item->physical_maximum);                         
-                usb_log_debug("\tUSAGEMIN: %X\n", report_item->usage_minimum);
-                usb_log_debug("\tUSAGEMAX: %X\n", report_item->usage_maximum);
-                
-                usb_log_debug("\n");            
+                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");            
 
         }
@@ -609 +699 @@
  * @return void
  */
-void usb_hid_descriptor_print(usb_hid_report_parser_t *parser)
-{
-        if(parser == NULL) {
+void usb_hid_descriptor_print(usb_hid_report_t *report)
+{
+        if(report == NULL) {
                 return;
         }
-        
-        usb_log_debug("INPUT:\n");
-        usb_hid_descriptor_print_list(&parser->input);
-        
-        usb_log_debug("OUTPUT: \n");
-        usb_hid_descriptor_print_list(&parser->output);
-        
-        usb_log_debug("FEATURE:\n");    
-        usb_hid_descriptor_print_list(&parser->feature);
-
+
+        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;
+        }
 }
 
@@ -667 +769 @@
  * @return void
  */
-void usb_hid_free_report_parser(usb_hid_report_parser_t *parser)
-{
-        if(parser == NULL){
+void usb_hid_free_report(usb_hid_report_t *report)
+{
+        if(report == NULL){
                 return;
         }
 
-        parser->use_report_id = 0;
-
-        usb_hid_free_report_list(&parser->input);
-        usb_hid_free_report_list(&parser->output);
-        usb_hid_free_report_list(&parser->feature);
-
+        // 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;
 }
@@ -688 +808 @@
  * @param parser Opaque HID report parser structure.
  * @param data Data for the report.
- * @param callbacks Callbacks for report actions.
- * @param arg Custom argument (passed through to the callbacks).
  * @return Error code.
  */ 
-int usb_hid_parse_report(const usb_hid_report_parser_t *parser,  
-    const uint8_t *data, size_t size,
-    usb_hid_report_path_t *path, int flags,
-    const usb_hid_report_in_callbacks_t *callbacks, void *arg)
+int usb_hid_parse_report(const usb_hid_report_t *report,  
+    const uint8_t *data, size_t size, uint8_t *report_id)
 {
         link_t *list_item;
-        usb_hid_report_item_t *item;
-        uint8_t *keys;
-        uint8_t item_value;
-        size_t key_count=0;
-        size_t i=0;
-        size_t j=0;
-        uint8_t report_id = 0;
-
-        if(parser == NULL) {
+        usb_hid_report_field_t *item;
+
+        usb_hid_report_description_t *report_des;
+        usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
+
+        if(report == NULL) {
                 return EINVAL;
         }
-        
-        /* get the size of result array */
-        key_count = usb_hid_report_input_length(parser, path, flags);
-
-        if(!(keys = malloc(sizeof(uint8_t) * key_count))){
-                return ENOMEM;
-        }
-
-        if(parser->use_report_id != 0) {
-                report_id = data[0];
-                usb_hid_report_path_set_report_id(path, report_id);
-        }
+
+        if(report->use_report_ids != 0) {
+                *report_id = data[0];
+        }       
+        else {
+                *report_id = 0;
+        }
+
+
+        report_des = usb_hid_report_find_description(report, *report_id, type);
 
         /* read data */
-        list_item = parser->input.next;    
-        while(list_item != &(parser->input)) {
-
-                item = list_get_instance(list_item, usb_hid_report_item_t, link);
-
-                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 
-                   (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) {
-                        for(j=0; j<(size_t)(item->count); j++) {
-                                if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) ||
-                                   ((item->usage_minimum == 0) && (item->usage_maximum == 0))) {
-                                        // variable item
-                                        keys[i++] = usb_hid_translate_data(item, data,j);
-                                }
-                                else {
-                                        // bitmapa
-                                        if((item_value = usb_hid_translate_data(item, data, j)) != 0) {
-                                                keys[i++] = (item->count - 1 - j) + item->usage_minimum;
-                                        }
-                                        else {
-                                                keys[i++] = 0;
-                                        }
-                                }
-                        }
+        list_item = report_des->report_items.next;         
+        while(list_item != &(report_des->report_items)) {
+
+                item = list_get_instance(list_item, usb_hid_report_field_t, link);
+
+                if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
+                        
+                        if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
+
+                                // array
+                                item->value = usb_hid_translate_data(item, data);
+                            item->usage = (item->value - item->physical_minimum) + item->usage_minimum;
+                        }
+                        else {
+                                // variable item
+                                item->value = usb_hid_translate_data(item, data);                               
+                        }                               
                 }
                 list_item = list_item->next;
         }
-
-        callbacks->keyboard(keys, key_count, report_id, arg);
            
-        free(keys);     
         return EOK;
         
@@ -758 +860 @@
 
 /**
- * Translate data from the report as specified in report descriptor
+ * Translate data from the report as specified in report descriptor item
  *
  * @param item Report descriptor item with definition of translation
@@ -765 +867 @@
  * @return Translated data
  */
-int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j)
+int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data)
 {
         int resolution;
@@ -771 +873 @@
         int part_size;
         
-        int32_t value;
+        int32_t value=0;
         int32_t mask;
         const uint8_t *foo;
 
-        // now only common numbers llowed
+        // now only shot tags are allowed
         if(item->size > 32) {
                 return 0;
         }
 
-        if((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
+        if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
                 item->physical_minimum = item->logical_minimum;
-                item->physical_maximum = item->logical_maximum;         
-        }
+                item->physical_maximum = item->logical_maximum;                 
+        }
+        
 
         if(item->physical_maximum == item->physical_minimum){
@@ -794 +897 @@
         }
 
-        offset = item->offset + (j * item->size);
-        if(item->id != 0) {
-                offset += 8;
-                usb_log_debug("MOVED OFFSET BY 1Byte, REPORT_ID(%d)\n", item->id);
-        }
-        
+        offset = item->offset;
         // FIXME
-        if((offset/8) != ((offset+item->size)/8)) {
-                usb_log_debug2("offset %d\n", offset);
+        if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
                 
                 part_size = ((offset+item->size)%8);
-                usb_log_debug2("part size %d\n",part_size);
-
-                // the higher one
-                foo = data+(offset/8);
-                mask =  ((1 << (item->size-part_size))-1);
-                value = (*foo & mask) << part_size;
-
-                usb_log_debug2("hfoo %x\n", *foo);
-                usb_log_debug2("hmaska %x\n",  mask);
-                usb_log_debug2("hval %d\n", value);             
-
-                // the lower one
-                foo = data+((offset+item->size)/8);
-                mask =  ((1 << part_size)-1) << (8-part_size);
-                value += ((*foo & mask) >> (8-part_size));
-
-                usb_log_debug2("lfoo %x\n", *foo);
-                usb_log_debug2("lmaska %x\n",  mask);
-                usb_log_debug2("lval %d\n", ((*foo & mask) >> (8-(item->size-part_size))));             
-                usb_log_debug2("val %d\n", value);
-                
-                
+
+                size_t i=0;
+                for(i=(size_t)(offset/8); i<=(size_t)(offset+item->size-1)/8; i++){
+                        if(i == (size_t)(offset/8)) {
+                                // the higher one
+                                foo = data + i;
+                                mask =  ((1 << (item->size-part_size))-1);
+                                value = (*foo & mask) << part_size;
+                        }
+                        else if(i == ((offset+item->size-1)/8)){
+                                // the lower one
+                                foo = data + i;
+                                mask =  ((1 << part_size)-1) << (8-part_size);
+                                value += ((*foo & mask) >> (8-part_size));
+                        }
+                        else {
+                                value = value << 8;
+                                value += *(data + 1);
+                        }
+                }
         }
         else {          
@@ -832 +927 @@
                 mask =  ((1 << item->size)-1) << (8-((offset%8)+item->size));
                 value = (*foo & mask) >> (8-((offset%8)+item->size));
-
-                usb_log_debug2("offset %d\n", offset);
-        
-                usb_log_debug2("foo %x\n", *foo);
-                usb_log_debug2("maska %x\n",  mask);
-                usb_log_debug2("val %d\n", value);                              
-        }
-
-        usb_log_debug2("---\n\n"); 
+        }
+
+        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
+                value = USB_HID_UINT32_TO_INT32(value, item->size);
+        }
 
         return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum);
@@ -847 +938 @@
 
 /**
- *
- *
- * @param parser
- * @param path
- * @param flags
- * @return
- */
-size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
+ * Returns number of items in input report which are accessible by given usage path
+ *
+ * @param parser Opaque report descriptor structure
+ * @param path Usage path specification
+ * @param flags Usage path comparison flags
+ * @return Number of items in input report
+ */
+size_t usb_hid_report_input_length(const usb_hid_report_t *report,
         usb_hid_report_path_t *path, int flags)
 {       
+        
         size_t ret = 0;
-        link_t *item;
-        usb_hid_report_item_t *report_item;
-
-        if(parser == NULL) {
+
+        if(report == NULL) {
                 return 0;
         }
-        
-        item = parser->input.next;
-        while(&parser->input != item) {
-                report_item = list_get_instance(item, usb_hid_report_item_t, link);
-                if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) &&
-                   (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) {
-                        ret += report_item->count;
-                }
-
-                item = item->next;
-        } 
+
+        usb_hid_report_description_t *report_des;
+        report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_INPUT);
+        if(report_des == NULL) {
+                return 0;
+        }
+
+        link_t *field_it = report_des->report_items.next;
+        usb_hid_report_field_t *field;
+        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) {
+                                ret++;
+                        }
+                        usb_hid_report_remove_last_item (field->collection_path);
+                }
+                
+                field_it = field_it->next;
+        }
 
         return ret;
-}
-
-
-/**
- * 
- * @param usage_path
- * @param usage_page
- * @param usage
- * @return
+        }
+
+
+/**
+ * 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, 
@@ -899 +1003 @@
         item->usage = usage;
         item->usage_page = usage_page;
-        
-        usb_log_debug("Appending usage %d, usage page %d\n", usage, usage_page);
-        
-        list_append (&usage_path->link, &item->link);
+        item->flags = 0;
+        
+        list_append (&item->link, &usage_path->head);
         usage_path->depth++;
         return EOK;
@@ -908 +1011 @@
 
 /**
- *
- * @param usage_path
- * @return
+ * 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)
@@ -916 +1019 @@
         usb_hid_report_usage_path_t *item;
         
-        if(!list_empty(&usage_path->link)){
-                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);             
-                list_remove(usage_path->link.prev);
+        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);
@@ -925 +1028 @@
 
 /**
+ * Nulls last item of the usage path structure.
  *
  * @param usage_path
- * @return
+ * @return void
  */
 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path)
@@ -933 +1037 @@
         usb_hid_report_usage_path_t *item;
         
-        if(!list_empty(&usage_path->link)){     
-                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
+        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));
         }
@@ -940 +1044 @@
 
 /**
- *
- * @param usage_path
- * @param tag
- * @param data
- * @return
+ * 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)
@@ -950 +1056 @@
         usb_hid_report_usage_path_t *item;
         
-        if(!list_empty(&usage_path->link)){     
-                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
+        if(!list_empty(&usage_path->head)){     
+                item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
 
                 switch(tag) {
@@ -965 +1071 @@
 }
 
-/**
- * 
- *
- * @param report_path
- * @param path
- * @param flags
- * @return
+
+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, 
@@ -1005 +1132 @@
                                 }
 
-                                report_link = report_path->link.next;
-                                path_link = path->link.next;
+                                report_link = report_path->head.next;
+                                path_link = path->head.next;
                         
-                                while((report_link != &report_path->link) && (path_link != &path->link)) {
+                                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);            
@@ -1022 +1149 @@
                                 }
 
-                                if((report_link == &report_path->link) && (path_link == &path->link)) {
+                                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;
                                 }
@@ -1032 +1160 @@
                 /* compare with only the end of path*/
                 case USB_HID_PATH_COMPARE_END:
-                                report_link = report_path->link.prev;
-                                path_link = path->link.prev;
-
-                                if(list_empty(&path->link)){
+
+                                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->link) && (path_link != &path->link)) {
+                                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);            
@@ -1053 +1187 @@
                                 }
 
-                                if(path_link == &path->link) {
+                                if(path_link == &path->head) {
                                         return EOK;
                                 }
@@ -1072 +1206 @@
 
 /**
- *
- * @return
+ * Allocates and initializes new usage path structure.
+ *
+ * @return Initialized usage path structure
  */
 usb_hid_report_path_t *usb_hid_report_path(void)
@@ -1079 +1214 @@
         usb_hid_report_path_t *path;
         path = malloc(sizeof(usb_hid_report_path_t));
-        if(!path){
+        if(path == NULL){
                 return NULL;
         }
@@ -1086 +1221 @@
                 path->report_id = 0;
                 list_initialize(&path->link);
+                list_initialize(&path->head);
                 return path;
         }
@@ -1091 +1227 @@
 
 /**
- *
- * @param 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->link)){
+        while(!list_empty(&path->head)){
                 usb_hid_report_remove_last_item(path);
         }
+
+        list_remove(&path->link);
+        free(path);
 }
 
@@ -1106 +1246 @@
  * Clone content of given usage path to the new one
  *
- * @param usage_path
- * @return
+ * @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;
-        link_t *path_link;
+        usb_hid_report_usage_path_t *new_path_item;
         usb_hid_report_path_t *new_usage_path = usb_hid_report_path ();
 
@@ -1118 +1259 @@
                 return NULL;
         }
-        
-        if(list_empty(&usage_path->link)){
+
+        new_usage_path->report_id = usage_path->report_id;
+        
+        if(list_empty(&usage_path->head)){
                 return new_usage_path;
         }
 
-        path_link = usage_path->link.next;
-        while(path_link != &usage_path->link) {
+        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);
-                usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage);
+                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;
@@ -1137 +1291 @@
 /*** OUTPUT API **/
 
-/** Allocates output report buffer
- *
- * @param parser
- * @param size
- * @return
- */
-uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size)
-{
-        if(parser == NULL) {
+/** 
+ * Allocates output report buffer for output report
+ *
+ * @param parser Report parsed structure
+ * @param size Size of returned buffer
+ * @param report_id Report id of created output report
+ * @return Returns allocated output buffer for specified output
+ */
+uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id)
+{
+        if(report == NULL) {
                 *size = 0;
                 return NULL;
         }
-        
-        // read the last output report item
-        usb_hid_report_item_t *last;
-        link_t *link;
-
-        link = parser->output.prev;
-        if(link != &parser->output) {
-                last = list_get_instance(link, usb_hid_report_item_t, link);
-                *size = (last->offset + (last->size * last->count)) / 8;
-
-                uint8_t *buffer = malloc(sizeof(uint8_t) * (*size));
-                memset(buffer, 0, sizeof(uint8_t) * (*size));
-                usb_log_debug("output buffer: %s\n", usb_debug_str_buffer(buffer, *size, 0));
-
-                return buffer;
+
+        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 == USB_HID_REPORT_TYPE_OUTPUT)){
+                        break;
+                }
+
+                report_it = report_it->next;
+        }
+
+        if(report_des == NULL){
+                *size = 0;
+                return NULL;
         }
         else {
-                *size = 0;              
-                return NULL;
+                *size = (report_des->bit_length + (8 - 1))/8;
+                uint8_t *ret = malloc((*size) * sizeof(uint8_t));
+                memset(ret, 0, (*size) * sizeof(uint8_t));
+                return ret;
         }
 }
@@ -1175 +1333 @@
  *
  * @param output Output report buffer
- * @return
+ * @return void
  */
 void usb_hid_report_output_free(uint8_t *output)
@@ -1187 +1345 @@
 /** Returns size of output for given usage path 
  *
- * @param parser
- * @param path
- * @param flags
- * @return
- */
-size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser,
+ * @param parser Opaque report parser structure
+ * @param path Usage path specified which items will be thought for the output
+ * @param flags Flags of usage path structure comparison
+ * @return Number of items matching the given usage path
+ */
+size_t usb_hid_report_output_size(usb_hid_report_t *report,
                                   usb_hid_report_path_t *path, int flags)
 {
-        size_t ret = 0;
-        link_t *item;
-        usb_hid_report_item_t *report_item;
-
-        if(parser == NULL) {
+        size_t ret = 0; 
+        usb_hid_report_description_t *report_des;
+
+        if(report == NULL) {
                 return 0;
         }
 
-        item = parser->output.next;
-        while(&parser->output != item) {
-                report_item = list_get_instance(item, usb_hid_report_item_t, link);
-                if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) &&
-                   (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) {
-                        ret += report_item->count;
-                }
-
-                item = item->next;
-        } 
+        report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_OUTPUT);
+        if(report_des == NULL){
+                return 0;
+        }
+        
+        link_t *field_it = report_des->report_items.next;
+        usb_hid_report_field_t *field;
+        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) {
+                                ret++;
+                        }
+                        usb_hid_report_remove_last_item (field->collection_path);
+                }
+                
+                field_it = field_it->next;
+        }
 
         return ret;
@@ -1218 +1385 @@
 }
 
-/** Updates the output report buffer by translated given data 
- *
- * @param parser
- * @param path
- * @param flags
- * @param buffer
- * @param size
- * @param data
- * @param data_size
- * @return
- */
-int usb_hid_report_output_translate(usb_hid_report_parser_t *parser,
-                                    usb_hid_report_path_t *path, int flags,
-                                    uint8_t *buffer, size_t size,
-                                    int32_t *data, size_t data_size)
-{
-        usb_hid_report_item_t *report_item;
+/** Makes the output report buffer for data given in the report structure
+ *
+ * @param parser Opaque report parser structure
+ * @param path Usage path specifing which parts of output will be set
+ * @param flags Usage path structure comparison flags
+ * @param buffer Output buffer
+ * @param size Size of output buffer
+ * @return Error code
+ */
+int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,
+                                    uint8_t *buffer, size_t size)
+{
         link_t *item;   
-        size_t idx=0;
-        int i=0;
         int32_t value=0;
         int offset;
         int length;
         int32_t tmp_value;
-        size_t offset_prefix = 0;
-        
-        if(parser == NULL) {
+        
+        if(report == NULL) {
                 return EINVAL;
         }
 
-        if(parser->use_report_id != 0) {
-                buffer[0] = path->report_id;
-                offset_prefix = 8;
+        if(report->use_report_ids != 0) {
+                buffer[0] = report_id;          
         }
 
         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
-        usb_log_debug("OUTPUT DATA[0]: %d, DATA[1]: %d, DATA[2]: %d\n", data[0], data[1], data[2]);
-
-        item = parser->output.next;     
-        while(item != &parser->output) {
-                report_item = list_get_instance(item, usb_hid_report_item_t, link);
-
-                for(i=0; i<report_item->count; i++) {
-
-                        if(idx >= data_size) {
-                                break;
-                        }
-
-                        if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) ||
-                                ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
+        
+        usb_hid_report_description_t *report_des;
+        report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT);
+        if(report_des == NULL){
+                return EINVAL;
+        }
+
+        usb_hid_report_field_t *report_item;    
+        item = report_des->report_items.next;   
+        while(item != &report_des->report_items) {
+                report_item = list_get_instance(item, usb_hid_report_field_t, link);
+
+                        if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
                                         
-//                              // variable item
-                                value = usb_hid_translate_data_reverse(report_item, data[idx++]);
-                                offset = report_item->offset + (i * report_item->size) + offset_prefix;
+                                // array
+                                value = usb_hid_translate_data_reverse(report_item, report_item->value);
+                                offset = report_item->offset;
                                 length = report_item->size;
                         }
                         else {
-                                //bitmap
-                                value += usb_hid_translate_data_reverse(report_item, data[idx++]);
-                                offset = report_item->offset + offset_prefix;
-                                length = report_item->size * report_item->count;
+                                // variable item
+                                value  = usb_hid_translate_data_reverse(report_item, report_item->value);
+                                offset = report_item->offset;
+                                length = report_item->size;
                         }
 
@@ -1297 +1454 @@
                         }
                         else {
-                                // je to ve dvou!! FIXME: melo by to umet delsi jak 2
-
-                                // konec prvniho -- dolni x bitu
-                                tmp_value = value;
-                                tmp_value = tmp_value & ((1 << (8-(offset%8)))-1);                              
-                                tmp_value = tmp_value << (offset%8);
-
+                                int i = 0;
                                 uint8_t mask = 0;
-                                mask = ~(((1 << (8-(offset%8)))-1) << (offset%8));
-                                buffer[offset/8] = (buffer[offset/8] & mask) | tmp_value;
-
-                                // a ted druhej -- hornich length-x bitu
-                                value = value >> (8 - (offset % 8));
-                                value = value & ((1 << (length - (8 - (offset % 8)))) - 1);
+                                for(i = (offset/8); i <= ((offset+length-1)/8); i++) {
+                                        if(i == (offset/8)) {
+                                                tmp_value = value;
+                                                tmp_value = tmp_value & ((1 << (8-(offset%8)))-1);                              
+                                                tmp_value = tmp_value << (offset%8);
+        
+                                                mask = ~(((1 << (8-(offset%8)))-1) << (offset%8));
+                                                buffer[i] = (buffer[i] & mask) | tmp_value;                     
+                                        }
+                                        else if (i == ((offset + length -1)/8)) {
+                                                
+                                                value = value >> (length - ((offset + length) % 8));
+                                                value = value & ((1 << (length - ((offset + length) % 8))) - 1);
                                 
-                                mask = ((1 << (length - (8 - (offset % 8)))) - 1);
-                                buffer[(offset+length-1)/8] = (buffer[(offset+length-1)/8] & mask) | value;
-                        }
-
-                }
-
+                                                mask = (1 << (length - ((offset + length) % 8))) - 1;
+                                                buffer[i] = (buffer[i] & mask) | value;
+                                        }
+                                        else {
+                                                buffer[i] = value & (0xFF << i);
+                                        }
+                                }
+                        }
+
+
+                // reset value
+                report_item->value = 0;
+                
                 item = item->next;
         }
-
+        
         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
 
@@ -1327 +1492 @@
 
 /**
- *
- * @param item
- * @param value
- * @return
- */
-int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int value)
+ * Translate given data for putting them into the outoput report
+ * @param item Report item structure
+ * @param value Value to translate
+ * @return ranslated value
+ */
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value)
 {
         int ret=0;
@@ -1341 +1506 @@
         }
 
+        if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
+                item->physical_minimum = item->logical_minimum;
+                item->physical_maximum = item->logical_maximum;                 
+        }
+        
+
         if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) {
 
                 // variable item
-                if((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
-                        item->physical_minimum = item->logical_minimum;
-                        item->physical_maximum = item->logical_maximum;
-                }
-
                 if(item->physical_maximum == item->physical_minimum){
                     resolution = 1;
@@ -1371 +1537 @@
         }
 
-
-        return ret;
-}
-
-
+        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
+                return USB_HID_INT32_TO_UINT32(ret, item->size);
+        }
+        return (int32_t)ret;
+}
+
+/**
+ * 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)
 {
@@ -1383 +1557 @@
 
         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;
 }
@@ -1400 +1629 @@
 }
 
+
+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)
+{
+        usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type);
+        link_t *field_it;
+        
+        if(report_des == NULL){
+                return NULL;
+        }
+
+        if(field == NULL){
+                // vezmu prvni co mathuje podle path!!
+                field_it = report_des->report_items.next;
+        }
+        else {
+                field_it = field->link.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){
+                                usb_hid_report_remove_last_item (field->collection_path);
+                                return field;
+                        }
+                        usb_hid_report_remove_last_item (field->collection_path);
+                }
+                field_it = field_it->next;
+        }
+
+        return NULL;
+}
+
+uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
+{
+        if(report == NULL){
+                return 0;
+        }
+
+        usb_hid_report_description_t *report_des;
+        link_t *report_it;
+        
+        if(report_id == 0) {
+                report_it = usb_hid_report_find_description (report, report_id, type)->link.next;               
+        }
+        else {
+                report_it = report->reports.next;
+        }
+
+        while(report_it != &report->reports) {
+                report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
+                if(report_des->type == type){
+                        return report_des->report_id;
+                }
+        }
+
+        return 0;
+}
+
+void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
+{
+        if(report_item == NULL) {
+                return;
+        }
+        
+        report_item->usages_count = 0;
+        memset(report_item->usages, 0, USB_HID_MAX_USAGES);
+        
+        report_item->extended_usage_page = 0;
+        report_item->usage_minimum = 0;
+        report_item->usage_maximum = 0;
+        report_item->designator_index = 0;
+        report_item->designator_minimum = 0;
+        report_item->designator_maximum = 0;
+        report_item->string_index = 0;
+        report_item->string_minimum = 0;
+        report_item->string_maximum = 0;
+
+        return;
+}
 /**
  * @}