Index: uspace/lib/usb/src/hidparser.c
===================================================================
--- uspace/lib/usb/src/hidparser.c	(revision 28d7185e1cfc330931535edf4f6fa0bc723c3a92)
+++ uspace/lib/usb/src/hidparser.c	(revision e67399ef1606651d887b3ccc2c7ddfd81c02f364)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2011 Matej Klonfar
  * All rights reserved.
  *
@@ -41,39 +41,5 @@
 #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
-
-/** No special action after the report descriptor tag is processed should be
- * done
- */
-#define USB_HID_NO_ACTION	2
-
-#define USB_HID_RESET_OFFSET	3
-
-/** Unknown tag was founded in report descriptor data*/
-#define USB_HID_UNKNOWN_TAG		-99
-
-/*
- * Private descriptor parser functions
- */
-int usb_hid_report_init(usb_hid_report_t *report);
-int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item);
-usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type);
-int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
-int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
-int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
-int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
-
-void usb_hid_print_usage_path(usb_hid_report_path_t *path);
-void usb_hid_descriptor_print_list(link_t *head);
-void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
-void usb_hid_free_report_list(link_t *head);
-usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
+
 /*
  * Data translation private functions
@@ -85,6 +51,5 @@
 int usb_pow(int a, int b);
 
-#define USB_HID_UINT32_TO_INT32(x, size)	((((x) & (1 << ((size) - 1))) != 0) ? -(~(x - 1) & ((1 << size) - 1)) : (x)) //(-(~((x) - 1)))
-#define USB_HID_INT32_TO_UINT32(x, size)	(((x) < 0 ) ? ((1 << (size)) + (x)) : (x))
+
 // TODO: tohle ma bejt asi jinde
 int usb_pow(int a, int b)
@@ -103,702 +68,6 @@
 }
 
-/**
- * Initialize the report descriptor parser structure
- *
- * @param parser Report descriptor parser structure
- * @return Error code
- */
-int usb_hid_report_init(usb_hid_report_t *report)
-{
-	if(report == NULL) {
-		return EINVAL;
-	}
-
-	memset(report, 0, sizeof(usb_hid_report_t));
-	list_initialize(&report->reports);
-	list_initialize(&report->collection_paths);
-
-	report->use_report_ids = 0;
-    return EOK;   
-}
-
-int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item)
-{
-	usb_hid_report_field_t *field;
-	int i;
-
-
-	/* find or append current collection path to the list */
-	link_t *path_it = report->collection_paths.next;
-	usb_hid_report_path_t *path = NULL;
-	while(path_it != &report->collection_paths) {
-		path = list_get_instance(path_it, usb_hid_report_path_t, link);
-		
-		if(usb_hid_report_compare_usage_path(path, report_item->usage_path, USB_HID_PATH_COMPARE_STRICT) == EOK){
-			break;
-		}			
-		path_it = path_it->next;
-	}
-	if(path_it == &report->collection_paths) {
-		path = usb_hid_report_path_clone(report_item->usage_path);			
-		list_append(&path->link, &report->collection_paths);					
-		report->collection_paths_count++;
-	}
-
-	for(i=0; 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 & 0xFFFF0000) != 0){
-				field->usage_page = (usage >> 16);					
-				field->usage = (usage & 0xFFFF);
-			}
-			else {
-				field->usage = usage;
-			}
-
-			
-		}	
-
-		if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {
-			if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
-				field->usage = report_item->usage_maximum - i;
-			}
-			else {
-				field->usage = report_item->usage_minimum + i;					
-			}
-
-		}
-		
-		field->size = report_item->size;
-		field->offset = report_item->offset + (i * report_item->size);
-		if(report_item->id != 0) {
-			field->offset += 8;
-			report->use_report_ids = 1;
-		}
-		field->item_flags = report_item->item_flags;
-
-		/* find the right report list*/
-		usb_hid_report_description_t *report_des;
-		report_des = usb_hid_report_find_description(report, report_item->id, report_item->type);
-		if(report_des == NULL){
-			report_des = malloc(sizeof(usb_hid_report_description_t));
-			memset(report_des, 0, sizeof(usb_hid_report_description_t));
-
-			report_des->type = report_item->type;
-			report_des->report_id = report_item->id;
-			list_initialize (&report_des->link);
-			list_initialize (&report_des->report_items);
-
-			list_append(&report_des->link, &report->reports);
-			report->report_count++;
-		}
-
-		/* append this field to the end of founded report list */
-		list_append (&field->link, &report_des->report_items);
-		
-		/* update the sizes */
-		report_des->bit_length += field->size;
-		report_des->item_length++;
-
-	}
-
-
-	return EOK;
-}
-
-usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
-{
-	link_t *report_it = report->reports.next;
-	usb_hid_report_description_t *report_des = NULL;
-	
-	while(report_it != &report->reports) {
-		report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
-
-		if((report_des->report_id == report_id) && (report_des->type == type)){
-			return report_des;
-		}
-		
-		report_it = report_it->next;
-	}
-
-	return NULL;
-}
-
-/** Parse HID report descriptor.
- *
- * @param parser Opaque HID report parser structure.
- * @param data Data describing the report.
- * @return Error code.
- */
-int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
-    const uint8_t *data, size_t size)
-{
-	size_t i=0;
-	uint8_t tag=0;
-	uint8_t item_size=0;
-	int class=0;
-	int ret;
-	usb_hid_report_item_t *report_item=0;
-	usb_hid_report_item_t *new_report_item;	
-	usb_hid_report_path_t *usage_path;
-
-	size_t offset_input=0;
-	size_t offset_output=0;
-	size_t offset_feature=0;
-
-	link_t stack;
-	list_initialize(&stack);	
-
-	/* parser structure initialization*/
-	if(usb_hid_report_init(report) != EOK) {
-		return EINVAL;
-	}
-	
-	/*report item initialization*/
-	if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
-		return ENOMEM;
-	}
-	memset(report_item, 0, sizeof(usb_hid_report_item_t));
-	list_initialize(&(report_item->link));	
-
-	/* usage path context initialization */
-	if(!(usage_path=usb_hid_report_path())){
-		return ENOMEM;
-	}
-	
-	while(i<size){	
-		if(!USB_HID_ITEM_IS_LONG(data[i])){
-
-			if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
-				return EINVAL;
-			}
-			
-			tag = USB_HID_ITEM_TAG(data[i]);
-			item_size = USB_HID_ITEM_SIZE(data[i]);
-			class = USB_HID_ITEM_TAG_CLASS(data[i]);
-			
-			ret = usb_hid_report_parse_tag(tag,class,data+i+1,
-			                               item_size,report_item, usage_path);
-			switch(ret){
-				case USB_HID_NEW_REPORT_ITEM:
-					// store report item to report and create the new one
-					// store current collection path
-					report_item->usage_path = usage_path;
-					
-					usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id);	
-					if(report_item->id != 0){
-						report->use_report_ids = 1;
-					}
-					
-					switch(tag) {
-						case USB_HID_REPORT_TAG_INPUT:
-							report_item->type = USB_HID_REPORT_TYPE_INPUT;
-							report_item->offset = offset_input;
-							offset_input += report_item->count * report_item->size;
-							break;
-						case USB_HID_REPORT_TAG_OUTPUT:
-							report_item->type = USB_HID_REPORT_TYPE_OUTPUT;
-							report_item->offset = offset_output;
-							offset_output += report_item->count * report_item->size;
-
-							break;
-						case USB_HID_REPORT_TAG_FEATURE:
-							report_item->type = USB_HID_REPORT_TYPE_FEATURE;
-							report_item->offset = offset_feature;
-							offset_feature += report_item->count * report_item->size;
-							break;
-						default:
-						    usb_log_debug("\tjump over - tag %X\n", tag);
-						    break;
-					}
-					
-					/* 
-					 * append new fields to the report
-					 * structure 					 
-					 */
-					usb_hid_report_append_fields(report, report_item);
-
-					/* reset local items */
-					usb_hid_report_reset_local_items (report_item);
-
-					break;
-
-				case USB_HID_RESET_OFFSET:
-					offset_input = 0;
-					offset_output = 0;
-					offset_feature = 0;
-					usb_hid_report_path_set_report_id (usage_path, report_item->id);
-					break;
-
-				case USB_HID_REPORT_TAG_PUSH:
-					// push current state to stack
-					new_report_item = usb_hid_report_item_clone(report_item);
-					usb_hid_report_path_t *tmp_path = usb_hid_report_path_clone(usage_path);
-					new_report_item->usage_path = tmp_path; 
-
-					list_prepend (&new_report_item->link, &stack);
-					break;
-				case USB_HID_REPORT_TAG_POP:
-					// restore current state from stack
-					if(list_empty (&stack)) {
-						return EINVAL;
-					}
-					free(report_item);
-						
-					report_item = list_get_instance(stack.next, usb_hid_report_item_t, link);
-					
-					usb_hid_report_usage_path_t *tmp_usage_path;
-					tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link);
-					
-					usb_hid_report_set_last_item(usage_path, tmp_usage_path->usage_page, tmp_usage_path->usage);
-
-					usb_hid_report_path_free(report_item->usage_path);
-					list_initialize(&report_item->usage_path->link);
-					list_remove (stack.next);
-					
-					break;
-					
-				default:
-					// nothing special to do					
-					break;
-			}
-
-			/* jump over the processed block */
-			i += 1 + USB_HID_ITEM_SIZE(data[i]);
-		}
-		else{
-			// TBD
-			i += 3 + USB_HID_ITEM_SIZE(data[i+1]);
-		}
-		
-
-	}
-	
-	return EOK;
-}
-
-
-/**
- * Parse one tag of the report descriptor
- *
- * @param Tag to parse
- * @param Report descriptor buffer
- * @param Size of data belongs to this tag
- * @param Current report item structe
- * @return Code of action to be done next
- */
-int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
-{	
-	int ret;
-	
-	switch(class){
-		case USB_HID_TAG_CLASS_MAIN:
-
-			if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) {
-				return USB_HID_NEW_REPORT_ITEM;
-			}
-			else {
-				/*TODO process the error */
-				return ret;
-			   }
-			break;
-
-		case USB_HID_TAG_CLASS_GLOBAL:	
-			return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path);
-			break;
-
-		case USB_HID_TAG_CLASS_LOCAL:			
-			return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path);
-			break;
-		default:
-			return USB_HID_NO_ACTION;
-	}
-}
-
-/**
- * Parse main tags of report descriptor
- *
- * @param Tag identifier
- * @param Data buffer
- * @param Length of data buffer
- * @param Current state table
- * @return Error code
- */
-
-int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
-{		
-	switch(tag)
-	{
-		case USB_HID_REPORT_TAG_INPUT:
-		case USB_HID_REPORT_TAG_OUTPUT:
-		case USB_HID_REPORT_TAG_FEATURE:
-			report_item->item_flags = *data;			
-			return EOK;			
-			break;
-			
-		case USB_HID_REPORT_TAG_COLLECTION:
-			// TODO usage_path->flags = *data;
-			usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]);						
-			usb_hid_report_reset_local_items (report_item);
-			return USB_HID_NO_ACTION;
-			break;
-			
-		case USB_HID_REPORT_TAG_END_COLLECTION:
-			usb_hid_report_remove_last_item(usage_path);
-			return USB_HID_NO_ACTION;
-			break;
-		default:
-			return USB_HID_NO_ACTION;
-	}
-
-	return EOK;
-}
-
-/**
- * Parse global tags of report descriptor
- *
- * @param Tag identifier
- * @param Data buffer
- * @param Length of data buffer
- * @param Current state table
- * @return Error code
- */
-int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
-{
-	// TODO take care about the bit length of data
-	switch(tag)
-	{
-		case USB_HID_REPORT_TAG_USAGE_PAGE:
-			report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size);
-			break;
-		case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
-			report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-			break;
-		case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
-			report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-			break;
-		case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
-			report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-			break;			
-		case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
-			report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-
-			break;
-		case USB_HID_REPORT_TAG_UNIT_EXPONENT:
-			report_item->unit_exponent = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_UNIT:
-			report_item->unit = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_REPORT_SIZE:
-			report_item->size = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_REPORT_COUNT:
-			report_item->count = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_REPORT_ID:
-			report_item->id = usb_hid_report_tag_data_uint32(data,item_size);
-			return USB_HID_RESET_OFFSET;
-			break;
-		case USB_HID_REPORT_TAG_PUSH:
-		case USB_HID_REPORT_TAG_POP:
-			/* 
-			 * stack operations are done in top level parsing
-			 * function
-			 */
-			return tag;
-			break;
-			
-		default:
-			return USB_HID_NO_ACTION;
-	}
-
-	return EOK;
-}
-
-/**
- * Parse local tags of report descriptor
- *
- * @param Tag identifier
- * @param Data buffer
- * @param Length of data buffer
- * @param Current state table
- * @return Error code
- */
-int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
-{
-	switch(tag)
-	{
-		case USB_HID_REPORT_TAG_USAGE:
-			report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);
-			report_item->usages_count++;
-			break;
-		case USB_HID_REPORT_TAG_USAGE_MINIMUM:
-			if (item_size == 3) {
-				// usage extended usages
-				report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 
-				report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
-			}
-			else {
-				report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size);
-			}
-			break;
-		case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
-			if (item_size == 3) {
-				// usage extended usages
-				report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 
-				report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
-			}
-			else {
-				report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size);
-			}
-			break;
-		case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
-			report_item->designator_index = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
-			report_item->designator_minimum = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
-			report_item->designator_maximum = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_STRING_INDEX:
-			report_item->string_index = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_STRING_MINIMUM:
-			report_item->string_minimum = usb_hid_report_tag_data_uint32(data,item_size);
-			break;
-		case USB_HID_REPORT_TAG_STRING_MAXIMUM:
-			report_item->string_maximum = usb_hid_report_tag_data_uint32(data,item_size);
-			break;			
-		case USB_HID_REPORT_TAG_DELIMITER:
-			//report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size);
-			//TODO: 
-			//	DELIMITER STUFF
-			break;
-		
-		default:
-			return USB_HID_NO_ACTION;
-	}
-	
-	return EOK;
-}
-
-/**
- * Converts raw data to uint32 (thats the maximum length of short item data)
- *
- * @param Data buffer
- * @param Size of buffer
- * @return Converted int32 number
- */
-uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size)
-{
-	unsigned int i;
-	uint32_t result;
-
-	result = 0;
-	for(i=0; i<size; i++) {
-		result = (result | (data[i]) << (i*8));
-	}
-
-	return result;
-}
-
-/**
- * Prints content of given list of report items.
- *
- * @param List of report items (usb_hid_report_item_t)
- * @return void
- */
-void usb_hid_descriptor_print_list(link_t *head)
-{
-	usb_hid_report_field_t *report_item;
-	link_t *item;
-
-
-	if(head == NULL || list_empty(head)) {
-	    usb_log_debug("\tempty\n");
-	    return;
-	}
-        
-	for(item = head->next; item != head; item = item->next) {
-                
-		report_item = list_get_instance(item, usb_hid_report_field_t, link);
-
-		usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
-		usb_log_debug("\t\tSIZE: %X\n", report_item->size);				
-		usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum);
-		usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum);		
-		usb_log_debug("\t\tPHYMIN: %d\n", report_item->physical_minimum);		
-		usb_log_debug("\t\tPHYMAX: %d\n", report_item->physical_maximum);				
-		usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum);
-		usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum);
-
-		usb_log_debug("\t\tVALUE: %X\n", report_item->value);
-		usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
-		usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
-						
-//		usb_log_debug("\n");		
-
-	}
-
-
-}
-/**
- * Prints content of given report descriptor in human readable format.
- *
- * @param parser Parsed descriptor to print
- * @return void
- */
-void usb_hid_descriptor_print(usb_hid_report_t *report)
-{
-	if(report == NULL) {
-		return;
-	}
-
-	link_t *report_it = report->reports.next;
-	usb_hid_report_description_t *report_des;
-
-	while(report_it != &report->reports) {
-		report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
-		usb_log_debug("Report ID: %d\n", report_des->report_id);
-		usb_log_debug("\tType: %d\n", report_des->type);
-		usb_log_debug("\tLength: %d\n", report_des->bit_length);		
-		usb_log_debug("\tItems: %d\n", report_des->item_length);		
-
-		usb_hid_descriptor_print_list(&report_des->report_items);
-
-
-		link_t *path_it = report->collection_paths.next;
-		while(path_it != &report->collection_paths) {
-			usb_hid_print_usage_path (list_get_instance(path_it, usb_hid_report_path_t, link));
-			path_it = path_it->next;
-		}
-		
-		report_it = report_it->next;
-	}
-}
-
-/**
- * Releases whole linked list of report items
- *
- * @param head Head of list of report descriptor items (usb_hid_report_item_t)
- * @return void
- */
-void usb_hid_free_report_list(link_t *head)
-{
-	return; 
-	
-	usb_hid_report_item_t *report_item;
-	link_t *next;
-	
-	if(head == NULL || list_empty(head)) {		
-	    return;
-	}
-	
-	next = head->next;
-	while(next != head) {
-	
-	    report_item = list_get_instance(next, usb_hid_report_item_t, link);
-
-		while(!list_empty(&report_item->usage_path->link)) {
-			usb_hid_report_remove_last_item(report_item->usage_path);
-		}
-
-		
-	    next = next->next;
-	    
-	    free(report_item);
-	}
-	
-	return;
-	
-}
-
-/** Frees the HID report descriptor parser structure 
- *
- * @param parser Opaque HID report parser structure
- * @return void
- */
-void usb_hid_free_report(usb_hid_report_t *report)
-{
-	if(report == NULL){
-		return;
-	}
-
-	// free collection paths
-	usb_hid_report_path_t *path;
-	while(!list_empty(&report->collection_paths)) {
-		path = list_get_instance(report->collection_paths.next, usb_hid_report_path_t, link);
-		usb_hid_report_path_free(path);		
-	}
-	
-	// free report items
-	usb_hid_report_description_t *report_des;
-	usb_hid_report_field_t *field;
-	while(!list_empty(&report->reports)) {
-		report_des = list_get_instance(report->reports.next, usb_hid_report_description_t, link);
-		list_remove(&report_des->link);
-		
-		while(!list_empty(&report_des->report_items)) {
-			field = list_get_instance(report_des->report_items.next, usb_hid_report_field_t, link);
-			list_remove(&field->link);
-
-			free(field);
-		}
-		
-		free(report_des);
-	}
-	
-	return;
-}
+
+
 
 /** Parse and act upon a HID report.
@@ -980,312 +249,4 @@
 	return ret;
 	}
-
-
-/**
- * Appends one item (couple of usage_path and usage) into the usage path
- * structure
- *
- * @param usage_path Usage path structure
- * @param usage_page Usage page constant
- * @param usage Usage constant
- * @return Error code
- */
-int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 
-                                    int32_t usage_page, int32_t usage)
-{	
-	usb_hid_report_usage_path_t *item;
-
-	if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) {
-		return ENOMEM;
-	}
-	list_initialize(&item->link);
-
-	item->usage = usage;
-	item->usage_page = usage_page;
-	item->flags = 0;
-	
-	list_append (&item->link, &usage_path->head);
-	usage_path->depth++;
-	return EOK;
-}
-
-/**
- * Removes last item from the usage path structure
- * @param usage_path 
- * @return void
- */
-void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path)
-{
-	usb_hid_report_usage_path_t *item;
-	
-	if(!list_empty(&usage_path->head)){
-		item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);		
-		list_remove(usage_path->head.prev);
-		usage_path->depth--;
-		free(item);
-	}
-}
-
-/**
- * Nulls last item of the usage path structure.
- *
- * @param usage_path
- * @return void
- */
-void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path)
-{
-	usb_hid_report_usage_path_t *item;
-	
-	if(!list_empty(&usage_path->head)){	
-		item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
-		memset(item, 0, sizeof(usb_hid_report_usage_path_t));
-	}
-}
-
-/**
- * Modifies last item of usage path structure by given usage page or usage
- *
- * @param usage_path Opaque usage path structure
- * @param tag Class of currently processed tag (Usage page tag falls into Global
- * class but Usage tag into the Local)
- * @param data Value of the processed tag
- * @return void
- */
-void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data)
-{
-	usb_hid_report_usage_path_t *item;
-	
-	if(!list_empty(&usage_path->head)){	
-		item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
-
-		switch(tag) {
-			case USB_HID_TAG_CLASS_GLOBAL:
-				item->usage_page = data;
-				break;
-			case USB_HID_TAG_CLASS_LOCAL:
-				item->usage = data;
-				break;
-		}
-	}
-	
-}
-
-
-void usb_hid_print_usage_path(usb_hid_report_path_t *path)
-{
-	usb_log_debug("USAGE_PATH FOR RId(%d):\n", path->report_id);
-	usb_log_debug("\tLENGTH: %d\n", path->depth);
-
-	link_t *item = path->head.next;
-	usb_hid_report_usage_path_t *path_item;
-	while(item != &path->head) {
-
-		path_item = list_get_instance(item, usb_hid_report_usage_path_t, link);
-		usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
-		usb_log_debug("\tUSAGE: %X\n", path_item->usage);
-		usb_log_debug("\tFLAGS: %d\n", path_item->flags);		
-		
-		item = item->next;
-	}
-}
-
-/**
- * Compares two usage paths structures
- *
- * If USB_HID_PATH_COMPARE_COLLECTION_ONLY flag is given, the last item in report_path structure is forgotten
- *
- * @param report_path usage path structure to compare
- * @param path usage patrh structure to compare
- * @param flags Flags determining the mode of comparison
- * @return EOK if both paths are identical, non zero number otherwise
- */
-int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 
-                                      usb_hid_report_path_t *path,
-                                      int flags)
-{
-	usb_hid_report_usage_path_t *report_item;
-	usb_hid_report_usage_path_t *path_item;
-
-	link_t *report_link;
-	link_t *path_link;
-
-	int only_page;
-
-	if(report_path->report_id != path->report_id) {
-		return 1;
-	}
-
-	if(path->depth == 0){
-		return EOK;
-	}
-
-
-	if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){
-		flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY;
-	}
-	
-	switch(flags){
-		/* path must be completly identical */
-		case USB_HID_PATH_COMPARE_STRICT:
-				if(report_path->depth != path->depth){
-					return 1;
-				}
-
-				report_link = report_path->head.next;
-				path_link = path->head.next;
-			
-				while((report_link != &report_path->head) && (path_link != &path->head)) {
-					report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
-					path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);		
-
-					if((report_item->usage_page != path_item->usage_page) || 
-					   ((only_page == 0) && (report_item->usage != path_item->usage))) {
-						   return 1;
-					} else {
-						report_link = report_link->next;
-						path_link = path_link->next;			
-					}
-			
-				}
-
-				if(((report_link == &report_path->head) && (path_link == &path->head)) || 
-				   (((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) && (path_link = &path->head) && (report_link == report_path->head.prev))) {
-					return EOK;
-				}
-				else {
-					return 1;
-				}						
-			break;
-
-		/* compare with only the end of path*/
-		case USB_HID_PATH_COMPARE_END:
-
-				if((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) {
-					report_link = report_path->head.prev->prev;
-				}
-				else {
-					report_link = report_path->head.prev;
-				}
-				path_link = path->head.prev;
-
-				if(list_empty(&path->head)){
-					return EOK;
-				}
-			
-				while((report_link != &report_path->head) && (path_link != &path->head)) {
-					report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
-					path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);		
-
-					if((report_item->usage_page != path_item->usage_page) || 
-					   ((only_page == 0) && (report_item->usage != path_item->usage))) {
-						   return 1;
-					} else {
-						report_link = report_link->prev;
-						path_link = path_link->prev;			
-					}
-			
-				}
-
-				if(path_link == &path->head) {
-					return EOK;
-				}
-				else {
-					return 1;
-				}						
-			
-			break;
-
-		default:
-			return EINVAL;
-	}
-	
-	
-	
-	
-}
-
-/**
- * Allocates and initializes new usage path structure.
- *
- * @return Initialized usage path structure
- */
-usb_hid_report_path_t *usb_hid_report_path(void)
-{
-	usb_hid_report_path_t *path;
-	path = malloc(sizeof(usb_hid_report_path_t));
-	if(path == NULL){
-		return NULL;
-	}
-	else {
-		path->depth = 0;
-		path->report_id = 0;
-		list_initialize(&path->link);
-		list_initialize(&path->head);
-		return path;
-	}
-}
-
-/**
- * Releases given usage path structure.
- *
- * @param path usage path structure to release
- * @return void
- */
-void usb_hid_report_path_free(usb_hid_report_path_t *path)
-{
-	while(!list_empty(&path->head)){
-		usb_hid_report_remove_last_item(path);
-	}
-
-	list_remove(&path->link);
-	free(path);
-}
-
-
-/**
- * Clone content of given usage path to the new one
- *
- * @param usage_path Usage path structure to clone
- * @return New copy of given usage path structure
- */
-usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path)
-{
-	link_t *path_link;
-	usb_hid_report_usage_path_t *path_item;
-	usb_hid_report_usage_path_t *new_path_item;
-	usb_hid_report_path_t *new_usage_path = usb_hid_report_path ();
-
-	if(new_usage_path == NULL){
-		return NULL;
-	}
-
-	new_usage_path->report_id = usage_path->report_id;
-	
-	if(list_empty(&usage_path->head)){
-		return new_usage_path;
-	}
-
-	path_link = usage_path->head.next;
-	while(path_link != &usage_path->head) {
-		path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
-		new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
-		if(new_path_item == NULL) {
-			return NULL;
-		}
-		
-		list_initialize (&new_path_item->link);		
-		new_path_item->usage_page = path_item->usage_page;
-		new_path_item->usage = path_item->usage;		
-		new_path_item->flags = path_item->flags;		
-		
-		list_append(&new_path_item->link, &new_usage_path->head);
-		new_usage_path->depth++;
-
-		path_link = path_link->next;
-	}
-
-	return new_usage_path;
-}
-
 
 /*** OUTPUT API **/
@@ -1543,77 +504,4 @@
 }
 
-/**
- * Sets report id in usage path structure
- *
- * @param path Usage path structure
- * @param report_id Report id to set
- * @return Error code
- */
-int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
-{
-	if(path == NULL){
-		return EINVAL;
-	}
-
-	path->report_id = report_id;
-	return EOK;
-}
-
-/**
- *
- *
- *
- *
- *
- */
-int usb_hid_report_output_set_data(usb_hid_report_t *report, 
-                                   usb_hid_report_path_t *path, int flags, 
-                                  int *data, size_t data_size)
-{
-	size_t data_idx = 0;
-	if(report == NULL){
-		return EINVAL;
-	}
-
-	usb_hid_report_description_t *report_des;
-	report_des = usb_hid_report_find_description (report, path->report_id, 
-	                                              USB_HID_REPORT_TYPE_OUTPUT);
-	if(report_des == NULL){
-		return EINVAL;
-	}
-
-	usb_hid_report_field_t *field;
-	link_t *field_it = report_des->report_items.next;	
-	while(field_it != &report_des->report_items){
-
-		field = list_get_instance(field_it, usb_hid_report_field_t, link);		
-		if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
-			usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
-			if(usb_hid_report_compare_usage_path (field->collection_path, path, 
-		                                      flags) == EOK) {
-				if(data_idx < data_size) {
-					if((data[data_idx] >= field->physical_minimum) && (data[data_idx] >= field->physical_minimum)) {
-						field->value = data[data_idx];
-					}
-					else {
-						return ERANGE;
-					}
-
-					data_idx++;
-				}
-				else {
-					field->value = 0;
-				}
-			}
-			usb_hid_report_remove_last_item (field->collection_path);
-		}
-		
-		field_it = field_it->next;
-	}
-
-	return EOK;
-}
-
-
 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
 {
