Index: uspace/drv/usbkbd/kbddev.c
===================================================================
--- uspace/drv/usbkbd/kbddev.c	(revision 96986951e9c75ce6ef72872ed8d1ae86b0ec7591)
+++ uspace/drv/usbkbd/kbddev.c	(revision 175ad13e866672b66c7dbd4eddc9592ae8c46021)
@@ -290,7 +290,6 @@
 	usb_log_debug("Creating output report.\n");
 	
-	int rc = usb_hid_report_output_translate(kbd_dev->parser, 
-	    kbd_dev->led_path, USB_HID_PATH_COMPARE_END, kbd_dev->output_buffer, 
-	    kbd_dev->output_size, kbd_dev->led_data, kbd_dev->led_output_size);
+	int rc = usb_hid_report_output_translate(kbd_dev->parser, 0,
+	    kbd_dev->output_buffer, kbd_dev->output_size);
 	
 	if (rc != EOK) {
@@ -612,6 +611,5 @@
 	usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
 
-	int rc = usb_hid_parse_report(kbd_dev->parser, buffer,
-	    actual_size, path, USB_HID_PATH_COMPARE_STRICT, callbacks, kbd_dev);
+	int rc = usb_hid_parse_report(kbd_dev->parser, buffer, actual_size);
 
 	usb_hid_report_path_free (path);
@@ -657,6 +655,6 @@
 	memset(kbd_dev, 0, sizeof(usb_kbd_t));
 	
-	kbd_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
-	    usb_hid_report_parser_t)));
+	kbd_dev->parser = (usb_hid_report_t *)(malloc(sizeof(
+	    usb_hid_report_t)));
 	if (kbd_dev->parser == NULL) {
 		usb_log_fatal("No memory!\n");
@@ -726,9 +724,9 @@
 	
 	/* Initialize the report parser. */
-	rc = usb_hid_parser_init(kbd_dev->parser);
-	if (rc != EOK) {
-		usb_log_error("Failed to initialize report parser.\n");
-		return rc;
-	}
+	//rc = usb_hid_parser_init(kbd_dev->parser);
+	//if (rc != EOK) {
+	//	usb_log_error("Failed to initialize report parser.\n");
+	//	return rc;
+	//}
 	
 	/* Get the report descriptor and parse it. */
@@ -762,5 +760,5 @@
 	usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
 	kbd_dev->key_count = usb_hid_report_input_length(
-	    kbd_dev->parser, path, USB_HID_PATH_COMPARE_STRICT);
+	    kbd_dev->parser, path, USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
 	usb_hid_report_path_free (path);
 	
@@ -924,5 +922,5 @@
 	// destroy the parser
 	if ((*kbd_dev)->parser != NULL) {
-		usb_hid_free_report_parser((*kbd_dev)->parser);
+		usb_hid_free_report((*kbd_dev)->parser);
 	}
 	
Index: uspace/drv/usbkbd/kbddev.h
===================================================================
--- uspace/drv/usbkbd/kbddev.h	(revision 96986951e9c75ce6ef72872ed8d1ae86b0ec7591)
+++ uspace/drv/usbkbd/kbddev.h	(revision 175ad13e866672b66c7dbd4eddc9592ae8c46021)
@@ -106,5 +106,5 @@
 
 	/** HID Report parser. */
-	usb_hid_report_parser_t *parser;
+	usb_hid_report_t *parser;
 	
 	/** State of the structure (for checking before use). 
Index: uspace/lib/usb/include/usb/classes/hid.h
===================================================================
--- uspace/lib/usb/include/usb/classes/hid.h	(revision 96986951e9c75ce6ef72872ed8d1ae86b0ec7591)
+++ uspace/lib/usb/include/usb/classes/hid.h	(revision 175ad13e866672b66c7dbd4eddc9592ae8c46021)
@@ -50,10 +50,4 @@
 	USB_HIDREQ_SET_PROTOCOL = 11
 } usb_hid_request_t;
-
-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;
 
 typedef enum {
Index: uspace/lib/usb/include/usb/classes/hidparser.h
===================================================================
--- uspace/lib/usb/include/usb/classes/hidparser.h	(revision 96986951e9c75ce6ef72872ed8d1ae86b0ec7591)
+++ uspace/lib/usb/include/usb/classes/hidparser.h	(revision 175ad13e866672b66c7dbd4eddc9592ae8c46021)
@@ -74,10 +74,21 @@
 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY	4
 
-/** */
-typedef struct {
-	/** */
-	int32_t usage_page;
-	/** */	
-	int32_t usage;
+
+#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;
@@ -95,14 +106,76 @@
 } usb_hid_report_path_t;
 
-/**
- * Description of report items
- */
-typedef struct {
-	/** */	
+
+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;
+	
+} 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;
-	/** */	
-	int32_t usage_minimum;
-	/** */	
-	int32_t usage_maximum;
+	
+	/** */
+	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;
@@ -116,6 +189,4 @@
 	size_t offset;
 	/** */	
-	int32_t delimiter;
-	/** */	
 	int32_t unit_exponent;
 	/** */	
@@ -123,15 +194,15 @@
 
 	/** */
-	int32_t string_index;
-	/** */	
-	int32_t string_minimum;
-	/** */	
-	int32_t string_maximum;
-	/** */	
-	int32_t designator_index;
-	/** */	
-	int32_t designator_minimum;
-	/** */	
-	int32_t designator_maximum;
+	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;
@@ -142,26 +213,11 @@
 	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 report parser structure. */
-typedef struct {	
-	/** */	
-	link_t input;
-	/** */	
-	link_t output;
-	/** */	
-	link_t feature;
-	
-	int use_report_id;
-
-	/** */
- 	link_t stack;
-} usb_hid_report_parser_t;	
-
 
 /** HID parser callbacks for IN items. */
@@ -189,13 +245,4 @@
 } usb_hid_modifiers_t;
 
-//typedef enum {
-//	USB_HID_LED_NUM_LOCK = 0x1,
-//	USB_HID_LED_CAPS_LOCK = 0x2,
-//	USB_HID_LED_SCROLL_LOCK = 0x4,
-//	USB_HID_LED_COMPOSE = 0x8,
-//	USB_HID_LED_KANA = 0x10,
-//	USB_HID_LED_COUNT = 5
-//} usb_hid_led_t;
-
 static const usb_hid_modifiers_t 
     usb_hid_modifiers_consts[USB_HID_MOD_COUNT] = {
@@ -210,33 +257,17 @@
 };
 
-//static const usb_hid_led_t usb_hid_led_consts[USB_HID_LED_COUNT] = {
-//	USB_HID_LED_NUM_LOCK,
-//	USB_HID_LED_CAPS_LOCK,
-//	USB_HID_LED_SCROLL_LOCK,
-//	USB_HID_LED_COMPOSE,
-//	USB_HID_LED_KANA
-//};
-
-//#define USB_HID_BOOT_KEYBOARD_NUM_LOCK		0x01
-//#define USB_HID_BOOT_KEYBOARD_CAPS_LOCK		0x02
-//#define USB_HID_BOOT_KEYBOARD_SCROLL_LOCK	0x04
-//#define USB_HID_BOOT_KEYBOARD_COMPOSE		0x08
-//#define USB_HID_BOOT_KEYBOARD_KANA			0x10
-
 /*
  * Descriptor parser functions
  */
-/** */
-int usb_hid_parser_init(usb_hid_report_parser_t *parser);
-
-/** */
-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);
 
 /** */
-void usb_hid_free_report_parser(usb_hid_report_parser_t *parser);
-
-/** */
-void usb_hid_descriptor_print(usb_hid_report_parser_t *parser);
+void usb_hid_free_report(usb_hid_report_t *report);
+
+/** */
+void usb_hid_descriptor_print(usb_hid_report_t *report);
 
 
@@ -245,11 +276,8 @@
  */
 /** */
-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);
-
-/** */
-size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
+int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, size_t size);
+
+/** */
+size_t usb_hid_report_input_length(const usb_hid_report_t *report,
 	usb_hid_report_path_t *path, int flags);
 
@@ -291,5 +319,5 @@
  */
 /** Allocates output report buffer*/
-uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, 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*/
@@ -297,12 +325,14 @@
 
 /** Returns size of output for given usage path */
-size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser,
+size_t usb_hid_report_output_size(usb_hid_report_t *report,
                                   usb_hid_report_path_t *path, int flags);
 
-/** Updates the output report buffer by translated given data */
-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);
+/** 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);
 #endif
 /**
Index: uspace/lib/usb/include/usb/classes/hidreport.h
===================================================================
--- uspace/lib/usb/include/usb/classes/hidreport.h	(revision 96986951e9c75ce6ef72872ed8d1ae86b0ec7591)
+++ uspace/lib/usb/include/usb/classes/hidreport.h	(revision 175ad13e866672b66c7dbd4eddc9592ae8c46021)
@@ -57,5 +57,5 @@
  */
 int usb_hid_process_report_descriptor(usb_device_t *dev, 
-    usb_hid_report_parser_t *parser);
+    usb_hid_report_t *report);
 
 #endif /* LIBUSB_HIDREPORT_H_ */
Index: uspace/lib/usb/src/hidparser.c
===================================================================
--- uspace/lib/usb/src/hidparser.c	(revision 96986951e9c75ce6ef72872ed8d1ae86b0ec7591)
+++ uspace/lib/usb/src/hidparser.c	(revision 175ad13e866672b66c7dbd4eddc9592ae8c46021)
@@ -50,4 +50,6 @@
 #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
@@ -56,4 +58,7 @@
  * 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);
@@ -65,4 +70,5 @@
                              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();
@@ -74,6 +80,6 @@
 int32_t usb_hid_report_tag_data_int32(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(const usb_hid_report_parser_t *parser, 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, size_t j);
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value);
 int usb_pow(int a, int b);
 
@@ -100,20 +106,146 @@
  * @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);			
+
+		usb_log_debug("PUVODNI: \n");
+		usb_hid_print_usage_path (report_item->usage_path);
+		usb_log_debug("KLON - path: \n");
+		usb_hid_print_usage_path (path);		
+		usb_log_debug("KLON - clone: \n");
+		usb_hid_print_usage_path (usb_hid_report_path_clone(report_item->usage_path));		
+
+		list_append(&path->link, &report->collection_paths);			
+
+		// PROC SE KRUVA VLOZI NESMYSLY??
+		usb_log_debug("VLOZENO: \n");
+		usb_hid_print_usage_path (list_get_instance(report->collection_paths.prev, usb_hid_report_path_t, link));
+		usb_log_debug("\n");
+		report->collection_paths_count++;
+	}
+
+	
+	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))) {
+			if(i < report_item->usages_count){
+				if((report_item->usages[i] & 0xFF00) > 0){
+					field->usage_page = (report_item->usages[i] >> 16);					
+					field->usage = (report_item->usages[i] & 0xFF);
+				}
+				else {
+					field->usage = report_item->usages[i];
+				}
+			}
+			else {
+				field->usage = report_item->usages[report_item->usages_count - 1];
+			}
+		}		
+		
+		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)){
+			break;
+		}
+		report_it = report_it->next;
+	}
+	if(report_it ==&report->reports){
+		return NULL;
+	}
+
+	return report_des;
+}
 
 /** Parse HID report descriptor.
@@ -123,5 +255,5 @@
  * @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)
 {
@@ -134,17 +266,17 @@
 	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)))){
@@ -163,5 +295,5 @@
 
 			if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
-				return EINVAL; // TODO ERROR CODE
+				return EINVAL;
 			}
 			
@@ -169,52 +301,34 @@
 			item_size = USB_HID_ITEM_SIZE(data[i]);
 			class = USB_HID_ITEM_TAG_CLASS(data[i]);
-
-			usb_log_debug2(
-				"i(%u) data(%X) value(%X): TAG %u, 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:
@@ -222,32 +336,42 @@
 						    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_log_debug("PRED: \n");
+					if(report->collection_paths.next == &report->collection_paths) {
+						usb_log_debug("PRAZDNY\n");
+					}
+					else {
+						usb_hid_print_usage_path (list_get_instance(report->collection_paths.prev,usb_hid_report_path_t, link));
+					}
+					usb_log_debug("-----------\n");
+					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;
-
-					/* set the report id */
-					new_report_item->id = report_item->id;
-
-					/* 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;
-										
+					while(report_item->usages_count > 0){
+						report_item->usages[--(report_item->usages_count)] = 0;
+					}
+
+					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;
+
 					break;
+
+				case USB_HID_RESET_OFFSET:
+					offset_input = 0;
+					offset_output = 0;
+					offset_feature = 0;
+					break;
+
 				case USB_HID_REPORT_TAG_PUSH:
 					// push current state to stack
@@ -256,14 +380,14 @@
 					new_report_item->usage_path = tmp_path; 
 
-					list_prepend (&new_report_item->link, &parser->stack);
+					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(parser->stack.next, usb_hid_report_item_t, link);
+					report_item = list_get_instance(stack.next, usb_hid_report_item_t, link);
 					
 					usb_hid_report_usage_path_t *tmp_usage_path;
@@ -274,5 +398,5 @@
 					usb_hid_report_path_free(report_item->usage_path);
 					list_initialize(&report_item->usage_path->link);
-					list_remove (parser->stack.next);
+					list_remove (stack.next);
 					
 					break;
@@ -359,13 +483,10 @@
 			
 		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]);						
 			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;
@@ -394,7 +515,5 @@
 	{
 		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_int32(data, item_size);
 			break;
 		case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
@@ -424,8 +543,12 @@
 		case USB_HID_REPORT_TAG_REPORT_ID:
 			report_item->id = usb_hid_report_tag_data_int32(data,item_size);
+			return USB_HID_RESET_OFFSET;
 			break;
 		case USB_HID_REPORT_TAG_PUSH:
 		case USB_HID_REPORT_TAG_POP:
-			usb_log_debug("PUSH/POP processed\n");
+			/* 
+			 * stack operations are done in top level parsing
+			 * function
+			 */
 			return tag;
 			break;
@@ -453,12 +576,25 @@
 	{
 		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_int32(data,item_size);
 			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_int32(data,item_size) & 0xFF00) >> 16; 
+				report_item->usage_minimum = usb_hid_report_tag_data_int32(data,item_size) & 0xFF;
+			}
+			else {
+				report_item->usage_minimum = usb_hid_report_tag_data_int32(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_int32(data,item_size) & 0xFF00) >> 16; 
+				report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size) & 0xFF;
+			}
+			else {
+				report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size);
+			}
 			break;
 		case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
@@ -481,5 +617,7 @@
 			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_int32(data,item_size);
+			//TODO: 
+			//	DELIMITER STUFF
 			break;
 		
@@ -521,9 +659,8 @@
 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");
@@ -533,27 +670,18 @@
 	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: %X\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);
-		
+		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: %X\n", report_item->logical_minimum);
+		usb_log_debug("\t\tLOGMAX: %X\n", report_item->logical_maximum);		
+		usb_log_debug("\t\tPHYMIN: %X\n", report_item->physical_minimum);		
+		usb_log_debug("\t\tPHYMAX: %X\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\ttUSAGE: %X\n", report_item->usage);
+		usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
+						
 		usb_log_debug("\n");		
 
@@ -568,19 +696,31 @@
  * @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;
+	}
 }
 
@@ -626,16 +766,34 @@
  * @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);
-	usb_hid_free_report_list(&parser->stack);
+	// 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;
 }
@@ -647,70 +805,54 @@
  * @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)
 {
 	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;
+	usb_hid_report_field_t *item;
+
 	uint8_t report_id = 0;
-
-	if(parser == NULL) {
+	usb_hid_report_description_t *report_des;
+	usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
+
+	if(report == NULL) {
 		return EINVAL;
 	}
 
-	if(parser->use_report_id != 0) {
+	if(report->use_report_ids != 0) {
 		report_id = data[0];
-		usb_hid_report_path_set_report_id(path, report_id);
-	}
-
-
-	/* 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;
-	}
+	}
+
+	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(parser, item, data,j);
+	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)) {
+			
+			if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) ||
+			   ((item->usage_minimum == 0) && (item->usage_maximum == 0))) {
+
+				// variable item
+				item->value = usb_hid_translate_data(item, data,0);
+
+				// array item ???
+				if(!((item->usage_minimum == 0) && (item->usage_maximum == 0))) {
+					item->usage = item->value + item->usage_minimum;
 				}
-				else {
-					// bitmapa
-					if((item_value = usb_hid_translate_data(parser, item, data, j)) != 0) {
-						keys[i++] = (item->count - 1 - j) + item->usage_minimum;
-					}
-					else {
-						keys[i++] = 0;
-					}
-				}
-			}
+			}
+			else {
+				// bitmapa
+				// TODO: overit jestli vraci hodnoty podle phy min/max 
+				item->value = usb_hid_translate_data(item, data, 0);
+			}			
 		}
 		list_item = list_item->next;
 	}
-
-	callbacks->keyboard(keys, key_count, report_id, arg);
 	   
-	free(keys);	
 	return EOK;
 	
@@ -725,5 +867,5 @@
  * @return Translated data
  */
-int usb_hid_translate_data(const usb_hid_report_parser_t *parser, 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, size_t j)
 {
 	int resolution;
@@ -731,5 +873,5 @@
 	int part_size;
 	
-	int32_t value;
+	int32_t value=0;
 	int32_t mask;
 	const uint8_t *foo;
@@ -755,35 +897,29 @@
 
 	offset = item->offset + (j * item->size);
-	if(parser->use_report_id != 0) {
-		offset += 8;
-	}
 	
 	// 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 {		
@@ -791,13 +927,13 @@
 		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 = (int32_t)value;
+	}
+	else {
+		value = (uint32_t)value;
+	}
+
 
 	return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum);
@@ -813,28 +949,36 @@
  * @return Number of items in input report
  */
-size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
+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) {
+			if(usb_hid_report_compare_usage_path (path, field->collection_path, flags) == EOK) {
+				ret++;
+			}
+		}
+		
+		field_it = field_it->next;
+	}
 
 	return ret;
-}
+	}
 
 
@@ -860,6 +1004,7 @@
 	item->usage = usage;
 	item->usage_page = usage_page;
-	
-	list_append (&usage_path->link, &item->link);
+	item->flags = 0;
+	
+	list_append (&item->link, &usage_path->link);
 	usage_path->depth++;
 	return EOK;
@@ -927,4 +1072,23 @@
 }
 
+
+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->link.next;
+	usb_hid_report_usage_path_t *path_item;
+	while(item != &path->link) {
+
+		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
@@ -955,4 +1119,8 @@
 	}
 
+	//usb_log_debug("---------- PATH COMPARISON ----------\n\n");
+	//usb_hid_print_usage_path(report_path);
+	//usb_hid_print_usage_path(path);
+	
 
 	if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){
@@ -1042,5 +1210,5 @@
 	usb_hid_report_path_t *path;
 	path = malloc(sizeof(usb_hid_report_path_t));
-	if(!path){
+	if(path == NULL){
 		return NULL;
 	}
@@ -1064,4 +1232,7 @@
 		usb_hid_report_remove_last_item(path);
 	}
+
+	list_remove(&path->link);
+	free(path);
 }
 
@@ -1075,6 +1246,7 @@
 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 ();
 
@@ -1090,5 +1262,16 @@
 	while(path_link != &usage_path->link) {
 		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->link);
+		new_usage_path->depth++;
 
 		path_link = path_link->next;
@@ -1109,47 +1292,31 @@
  * @return Returns allocated output buffer for specified output
  */
-uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size, uint8_t report_id)
-{
-	if(parser == NULL) {
+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;
-	while((link != &parser->output)){
-		last = list_get_instance(link, usb_hid_report_item_t, link);
-
-		usb_log_debug("pro id: %d, posledni %d\n", report_id, last->id);
-		if(last->id == report_id){
-			break;
-		} 
-		else {
-			link =  link->prev;
-		}
-	}
-
-	
-
-	if(link != &parser->output) {
-		last = list_get_instance(link, usb_hid_report_item_t, link);
-		*size = (last->offset + (last->size * last->count)) / 8;
-
-		if(parser->use_report_id != 0) {
-			*size += 1;
-		}
-
-		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;
 	}
 }
@@ -1176,24 +1343,30 @@
  * @return Number of items matching the given usage path
  */
-size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser,
+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);
+		// TODO: bacha na porovnani - posledni prvek v ceste uz jsou usage/page z inputu a ne kolekce!!!
+		if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) {
+			ret++;
+		}
+		
+		field_it = field_it->next;
 	}
 
@@ -1202,5 +1375,5 @@
 }
 
-/** Updates the output report buffer by given data 
+/** Makes the output report buffer for data given in the report structure
  *
  * @param parser Opaque report parser structure
@@ -1209,58 +1382,49 @@
  * @param buffer Output buffer
  * @param size Size of output buffer
- * @param data Data buffer
- * @param data_size Size of data buffer
  * @return Error code
  */
-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;
+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;
-			}
+
+	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) ||
 				((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
 					
-//				// variable item
-				value = usb_hid_translate_data_reverse(report_item, data[idx++]);
-				offset = report_item->offset + (i * report_item->size) + offset_prefix;
+				// variable item
+				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;
+				value += usb_hid_translate_data_reverse(report_item, report_item->value);
+				offset = report_item->offset;
+				length = report_item->size;
 			}
 
@@ -1281,24 +1445,29 @@
 			}
 			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);
+					}
+				}
+			}
+
 
 		item = item->next;
@@ -1316,5 +1485,5 @@
  * @return ranslated value
  */
-int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int value)
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value)
 {
 	int ret=0;
@@ -1356,5 +1525,5 @@
 
 
-	return ret;
+	return (uint32_t)ret;
 }
 
@@ -1395,4 +1564,52 @@
 }
 
+
+/**
+ *
+ *
+ *
+ *
+ *
+ */
+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) {
+			if(usb_hid_report_compare_usage_path (path, field->collection_path, 
+		                                      flags) == EOK) {
+
+				if(data_idx < data_size) {
+					field->value = data[data_idx++];
+				}
+				else {
+					field->value = 0;
+				}
+			}
+		}
+		
+		field_it = field_it->next;
+	}
+
+	return EOK;
+}
+
 /**
  * @}
Index: uspace/lib/usb/src/hidreport.c
===================================================================
--- uspace/lib/usb/src/hidreport.c	(revision 96986951e9c75ce6ef72872ed8d1ae86b0ec7591)
+++ uspace/lib/usb/src/hidreport.c	(revision 175ad13e866672b66c7dbd4eddc9592ae8c46021)
@@ -185,7 +185,7 @@
 
 int usb_hid_process_report_descriptor(usb_device_t *dev, 
-    usb_hid_report_parser_t *parser)
+    usb_hid_report_t *report)
 {
-	if (dev == NULL || parser == NULL) {
+	if (dev == NULL || report == NULL) {
 		usb_log_error("Failed to process Report descriptor: wrong "
 		    "parameters given.\n");
@@ -210,5 +210,5 @@
 	assert(report_desc != NULL);
 	
-	rc = usb_hid_parse_report_descriptor(parser, report_desc, report_size);
+	rc = usb_hid_parse_report_descriptor(report, report_desc, report_size);
 	if (rc != EOK) {
 		usb_log_error("Problem parsing Report descriptor: %s.\n",
@@ -218,5 +218,5 @@
 	}
 	
-	usb_hid_descriptor_print(parser);
+	usb_hid_descriptor_print(report);
 	free(report_desc);