Changeset 9e929a0 in mainline

Timestamp:

2011-04-29T14:07:23Z (13 years ago)

Author:

Matus Dekanek <smekideki@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0dea35f, 26f6094

Parents:

152ec79 (diff), f19f1b7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge with development

Location:

uspace

Files:

• drv/usbhid/Makefile (modified) (1 diff)
• drv/usbhid/kbd/conv.c (modified) (1 diff)
• drv/usbhid/kbd/kbddev.c (modified) (17 diffs)
• drv/usbhid/kbd/kbddev.h (modified) (1 diff)
• drv/usbhid/lgtch-ultrax/keymap.c (added)
• drv/usbhid/lgtch-ultrax/keymap.h (added)
• drv/usbhid/lgtch-ultrax/lgtch-ultrax.c (modified) (2 diffs)
• drv/usbhid/lgtch-ultrax/lgtch-ultrax.h (modified) (1 diff)
• drv/usbhid/main.c (modified) (1 diff)
• drv/usbhid/mouse/mousedev.c (modified) (1 diff)
• drv/usbhid/subdrivers.c (modified) (2 diffs)
• drv/usbhid/subdrivers.h (modified) (1 diff)
• drv/usbhid/usbhid.c (modified) (7 diffs)
• drv/usbhid/usbhid.h (modified) (1 diff)
• drv/usbkbd/kbddev.c (modified) (12 diffs)
• drv/usbkbd/kbddev.h (modified) (1 diff)
• lib/usb/include/usb/classes/hid.h (modified) (1 diff)
• lib/usb/include/usb/classes/hidparser.h (modified) (11 diffs)
• lib/usb/include/usb/classes/hidreport.h (modified) (1 diff)
• lib/usb/include/usb/classes/hidut.h (modified) (1 diff)
• lib/usb/src/hidparser.c (modified) (57 diffs)
• lib/usb/src/hidreport.c (modified) (3 diffs)

uspace/drv/usbhid/Makefile

@@ -47 +47 @@
         mouse/mousedev.c \
         lgtch-ultrax/lgtch-ultrax.c \
+        lgtch-ultrax/keymap.c \
         $(STOLEN_LAYOUT_SOURCES)
 

uspace/drv/usbhid/kbd/conv.c

@@ -99 +99 @@
         [0x30] = KC_RBRACKET,
         [0x31] = KC_BACKSLASH,
-        //[0x32] = KC_, // TODO: HASH??? maybe some as 0x31 - backslash
+        //[0x32] = KC_, // TODO: HASH??? maybe same as 0x31 - backslash
+        [0x32] = KC_BACKSLASH,
         [0x33] = KC_SEMICOLON,
         [0x34] = KC_QUOTE,  // same as APOSTROPHE? (')

uspace/drv/usbhid/kbd/kbddev.c

@@ -177 +177 @@
 /*----------------------------------------------------------------------------*/
 
-static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
-    uint8_t report_id, void *arg);
-
-static const usb_hid_report_in_callbacks_t usb_kbd_parser_callbacks = {
-        .keyboard = usb_kbd_process_keycodes
-};
+//static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
+//    uint8_t report_id, void *arg);
+
+//static const usb_hid_report_in_callbacks_t usb_kbd_parser_callbacks = {
+//      .keyboard = usb_kbd_process_keycodes
+//};
 
 /*----------------------------------------------------------------------------*/
@@ -203 +203 @@
 /*----------------------------------------------------------------------------*/
 /** Mapping of USB modifier key codes to generic modifier key codes. */
-static const keycode_t usbhid_modifiers_keycodes[USB_HID_MOD_COUNT] = {
-        KC_LCTRL,         /* USB_HID_MOD_LCTRL */
-        KC_LSHIFT,        /* USB_HID_MOD_LSHIFT */
-        KC_LALT,          /* USB_HID_MOD_LALT */
-        0,                /* USB_HID_MOD_LGUI */
-        KC_RCTRL,         /* USB_HID_MOD_RCTRL */
-        KC_RSHIFT,        /* USB_HID_MOD_RSHIFT */
-        KC_RALT,          /* USB_HID_MOD_RALT */
-        0,                /* USB_HID_MOD_RGUI */
-};
-
-typedef enum usbhid_lock_code {
-        USB_KBD_LOCK_NUM = 0x53,
-        USB_KBD_LOCK_CAPS = 0x39,
-        USB_KBD_LOCK_SCROLL = 0x47,
-        USB_KBD_LOCK_COUNT = 3
-} usbhid_lock_code;
-
-static const usbhid_lock_code usbhid_lock_codes[USB_KBD_LOCK_COUNT] = {
-        USB_KBD_LOCK_NUM,
-        USB_KBD_LOCK_CAPS,
-        USB_KBD_LOCK_SCROLL
-};
+//static const keycode_t usbhid_modifiers_keycodes[USB_HID_MOD_COUNT] = {
+//      KC_LCTRL,         /* USB_HID_MOD_LCTRL */
+//      KC_LSHIFT,        /* USB_HID_MOD_LSHIFT */
+//      KC_LALT,          /* USB_HID_MOD_LALT */
+//      0,                /* USB_HID_MOD_LGUI */
+//      KC_RCTRL,         /* USB_HID_MOD_RCTRL */
+//      KC_RSHIFT,        /* USB_HID_MOD_RSHIFT */
+//      KC_RALT,          /* USB_HID_MOD_RALT */
+//      0,                /* USB_HID_MOD_RGUI */
+//};
+
+//typedef enum usbhid_lock_code {
+//      USB_KBD_LOCK_NUM = 0x53,
+//      USB_KBD_LOCK_CAPS = 0x39,
+//      USB_KBD_LOCK_SCROLL = 0x47,
+//      USB_KBD_LOCK_COUNT = 3
+//} usbhid_lock_code;
+
+//static const usbhid_lock_code usbhid_lock_codes[USB_KBD_LOCK_COUNT] = {
+//      USB_KBD_LOCK_NUM,
+//      USB_KBD_LOCK_CAPS,
+//      USB_KBD_LOCK_SCROLL
+//};
 
 /*----------------------------------------------------------------------------*/
@@ -299 +299 @@
                 return;
         }
-        
-        unsigned i = 0;
-        
+                
         /* Reset the LED data. */
         memset(kbd_dev->led_data, 0, kbd_dev->led_output_size * sizeof(int32_t));
-        
-        if ((kbd_dev->mods & KM_NUM_LOCK) && (i < kbd_dev->led_output_size)) {
-                kbd_dev->led_data[i++] = USB_HID_LED_NUM_LOCK;
-        }
-        
-        if ((kbd_dev->mods & KM_CAPS_LOCK) && (i < kbd_dev->led_output_size)) {
-                kbd_dev->led_data[i++] = USB_HID_LED_CAPS_LOCK;
-        }
-        
-        if ((kbd_dev->mods & KM_SCROLL_LOCK) 
-            && (i < kbd_dev->led_output_size)) {
-                kbd_dev->led_data[i++] = USB_HID_LED_SCROLL_LOCK;
-        }
-
-        // TODO: COMPOSE and KANA
-        
-        usb_log_debug("Creating output report.\n");
-        
-        int rc = usb_hid_report_output_translate(hid_dev->parser, 
-            kbd_dev->led_path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            kbd_dev->output_buffer, 
-            kbd_dev->output_size, kbd_dev->led_data, kbd_dev->led_output_size);
+        usb_log_debug("Creating output report:\n");
+
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
+            hid_dev->report, NULL, kbd_dev->led_path, 
+            USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY | USB_HID_PATH_COMPARE_END,
+            USB_HID_REPORT_TYPE_OUTPUT);
+        
+        while (field != NULL) {
+
+                if ((field->usage == USB_HID_LED_NUM_LOCK) 
+                    && (kbd_dev->mods & KM_NUM_LOCK)){
+                        field->value = 1;
+                }
+
+                if ((field->usage == USB_HID_LED_CAPS_LOCK) 
+                    && (kbd_dev->mods & KM_CAPS_LOCK)){
+                        field->value = 1;
+                }
+
+                if ((field->usage == USB_HID_LED_SCROLL_LOCK) 
+                    && (kbd_dev->mods & KM_SCROLL_LOCK)){
+                        field->value = 1;
+                }
+                
+                field = usb_hid_report_get_sibling(hid_dev->report, field,
+                    kbd_dev->led_path, USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 
+                    | USB_HID_PATH_COMPARE_END, USB_HID_REPORT_TYPE_OUTPUT);
+        }
+        
+        // TODO: what about the Report ID?
+        int rc = usb_hid_report_output_translate(hid_dev->report, 0,
+            kbd_dev->output_buffer, kbd_dev->output_size);
         
         if (rc != EOK) {
@@ -485 +492 @@
  */
 static void usb_kbd_check_key_changes(usb_hid_dev_t *hid_dev, 
-    usb_kbd_t *kbd_dev, const uint8_t *key_codes, size_t count)
+    usb_kbd_t *kbd_dev/*, const uint8_t *key_codes, size_t count*/)
 {
         unsigned int key;
@@ -499 +506 @@
          */
         i = 0;
-        while (i < count && key_codes[i] != ERROR_ROLLOVER) {
+        while (i < kbd_dev->key_count && kbd_dev->keys[i] != ERROR_ROLLOVER) {
                 ++i;
         }
-        if (i != count) {
+        if (i != kbd_dev->key_count) {
                 usb_log_debug("Phantom state occured.\n");
                 // phantom state, do nothing
                 return;
         }
-        
-        /* TODO: quite dummy right now, think of better implementation */
-        assert(count == kbd_dev->key_count);
         
         /*
          * 1) Key releases
          */
-        for (j = 0; j < count; ++j) {
+        for (j = 0; j < kbd_dev->key_count; ++j) {
                 // try to find the old key in the new key list
                 i = 0;
                 while (i < kbd_dev->key_count
-                    && key_codes[i] != kbd_dev->keys[j]) {
+                    && kbd_dev->keys[i] != kbd_dev->keys_old[j]) {
                         ++i;
                 }
                 
-                if (i == count) {
+                if (i == kbd_dev->key_count) {
                         // not found, i.e. the key was released
-                        key = usbhid_parse_scancode(kbd_dev->keys[j]);
+                        key = usbhid_parse_scancode(kbd_dev->keys_old[j]);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_stop(kbd_dev, key);
@@ -541 +545 @@
                 // try to find the new key in the old key list
                 j = 0;
-                while (j < count && kbd_dev->keys[j] != key_codes[i]) { 
+                while (j < kbd_dev->key_count 
+                    && kbd_dev->keys_old[j] != kbd_dev->keys[i]) { 
                         ++j;
                 }
                 
-                if (j == count) {
+                if (j == kbd_dev->key_count) {
                         // not found, i.e. new key pressed
-                        key = usbhid_parse_scancode(key_codes[i]);
+                        key = usbhid_parse_scancode(kbd_dev->keys[i]);
                         usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
-                            key_codes[i]);
-                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, 
-                            key);
+                            kbd_dev->keys[i]);
+                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_start(kbd_dev, key);
@@ -560 +564 @@
         }
         
-        memcpy(kbd_dev->keys, key_codes, count);
-
-        usb_log_debug("New stored keycodes: %s\n", 
-            usb_debug_str_buffer(kbd_dev->keys, kbd_dev->key_count, 0));
+//      usb_log_debug("Old keys: ");
+//      for (i = 0; i < kbd_dev->key_count; ++i) {
+//              usb_log_debug("%d ", kbd_dev->keys_old[i]);
+//      }
+//      usb_log_debug("\n");
+        
+        
+//      usb_log_debug("New keys: ");
+//      for (i = 0; i < kbd_dev->key_count; ++i) {
+//              usb_log_debug("%d ", kbd_dev->keys[i]);
+//      }
+//      usb_log_debug("\n");
+        
+        memcpy(kbd_dev->keys_old, kbd_dev->keys, kbd_dev->key_count * 4);
+        
+        usb_log_debug2("New stored keys: ");
+        for (i = 0; i < kbd_dev->key_count; ++i) {
+                usb_log_debug2("%d ", kbd_dev->keys_old[i]);
+        }
+        usb_log_debug2("\n");
 }
 
@@ -585 +605 @@
  * @sa usb_kbd_check_key_changes(), usb_kbd_check_modifier_changes()
  */
-static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
-    uint8_t report_id, void *arg)
-{
-        if (arg == NULL) {
-                usb_log_warning("Missing argument in callback "
-                    "usbhid_process_keycodes().\n");
-                return;
-        }
-        
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
-        
-        if (hid_dev->data == NULL) {
-                usb_log_warning("Missing KBD device structure in callback.\n");
-                return;
-        }
-        
-        usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
-
-        usb_log_debug("Got keys from parser (report id: %u): %s\n", 
-            report_id, usb_debug_str_buffer(key_codes, count, 0));
-        
-        if (count != kbd_dev->key_count) {
-                usb_log_warning("Number of received keycodes (%zu) differs from"
-                    " expected (%zu).\n", count, kbd_dev->key_count);
-                return;
-        }
-        
-        ///usb_kbd_check_modifier_changes(kbd_dev, key_codes, count);
-        usb_kbd_check_key_changes(hid_dev, kbd_dev, key_codes, count);
-}
+//static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
+//    uint8_t report_id, void *arg)
+//{
+//      if (arg == NULL) {
+//              usb_log_warning("Missing argument in callback "
+//                  "usbhid_process_keycodes().\n");
+//              return;
+//      }
+        
+//      usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
+        
+//      if (hid_dev->data == NULL) {
+//              usb_log_warning("Missing KBD device structure in callback.\n");
+//              return;
+//      }
+        
+//      usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
+
+//      usb_log_debug("Got keys from parser (report id: %u): %s\n", 
+//          report_id, usb_debug_str_buffer(key_codes, count, 0));
+        
+//      if (count != kbd_dev->key_count) {
+//              usb_log_warning("Number of received keycodes (%zu) differs from"
+//                  " expected (%zu).\n", count, kbd_dev->key_count);
+//              return;
+//      }
+        
+//      ///usb_kbd_check_modifier_changes(kbd_dev, key_codes, count);
+//      usb_kbd_check_key_changes(hid_dev, kbd_dev, key_codes, count);
+//}
 
 /*----------------------------------------------------------------------------*/
@@ -638 +658 @@
                                  uint8_t *buffer, size_t actual_size)
 {
-        assert(hid_dev->parser != NULL);
+        assert(hid_dev->report != NULL);
+        assert(hid_dev != NULL);
+        assert(hid_dev->data != NULL);
+        
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
 
         usb_log_debug("Calling usb_hid_parse_report() with "
@@ -648 +672 @@
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
         //usb_hid_report_path_set_report_id(path, 0);
-        
-        int rc = usb_hid_parse_report(hid_dev->parser, buffer,
-            actual_size, path, 
+
+        uint8_t report_id;
+        int rc = usb_hid_parse_report(hid_dev->report, buffer, actual_size, 
+            &report_id);
+        
+        if (rc != EOK) {
+                usb_log_warning("Error in usb_hid_parse_report():"
+                    "%s\n", str_error(rc));
+        }
+        
+        usb_hid_report_path_set_report_id (path, report_id);
+        
+        // fill in the currently pressed keys
+        
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
+            hid_dev->report, NULL, path, 
             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            &usb_kbd_parser_callbacks, hid_dev);
-
+            USB_HID_REPORT_TYPE_INPUT);
+        unsigned i = 0;
+        
+        while (field != NULL) {
+                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)\n", 
+                    field, field->value, field->usage);
+                
+                assert(i < kbd_dev->key_count);
+//              if (i == kbd_dev->key_count) {
+//                      break;
+//              }
+                
+                // save the key usage
+                /* TODO: maybe it's not good to save value, nor usage
+                 *       as the value may be e.g. 1 for LEDs and usage may be
+                 *       value of the LED. On the other hand, in case of normal
+                 *       keys, the usage is more important and we must check
+                 *       that. One possible solution: distinguish between those
+                 *       two parts of the Report somehow.
+                 */
+                if (field->value != 0) {
+                        kbd_dev->keys[i] = field->usage;
+                }
+                else {
+                        kbd_dev->keys[i] = 0;
+                }
+                usb_log_debug2("Saved %u. key usage %d\n", i, kbd_dev->keys[i]);
+                
+                ++i;
+                field = usb_hid_report_get_sibling(hid_dev->report, field, path, 
+                    USB_HID_PATH_COMPARE_END 
+                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+                    USB_HID_REPORT_TYPE_INPUT);
+        }
+        
         usb_hid_report_path_free(path);
         
-        if (rc != EOK) {
-                usb_log_warning("Error in usb_hid_boot_keyboard_input_report():"
-                    "%s\n", str_error(rc));
-        }
+        usb_kbd_check_key_changes(hid_dev, kbd_dev);
 }
 
@@ -747 +814 @@
         
         kbd_dev->key_count = usb_hid_report_input_length(
-            hid_dev->parser, path, 
+            hid_dev->report, path, 
             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
         usb_hid_report_path_free(path);
@@ -753 +820 @@
         usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
         
-        kbd_dev->keys = (uint8_t *)calloc(kbd_dev->key_count, sizeof(uint8_t));
+        kbd_dev->keys = (int32_t *)calloc(kbd_dev->key_count, sizeof(int32_t));
         
         if (kbd_dev->keys == NULL) {
@@ -761 +828 @@
         }
         
+        kbd_dev->keys_old = 
+                (int32_t *)calloc(kbd_dev->key_count, sizeof(int32_t));
+        
+        if (kbd_dev->keys_old == NULL) {
+                usb_log_fatal("No memory!\n");
+                free(kbd_dev->keys);
+                free(kbd_dev);
+                return ENOMEM;
+        }
+        
         /*
          * Output report
          */
         kbd_dev->output_size = 0;
-        kbd_dev->output_buffer = usb_hid_report_output(hid_dev->parser, 
-            &kbd_dev->output_size);
-        if (kbd_dev->output_buffer == NULL && kbd_dev->output_size != 0) {
+        kbd_dev->output_buffer = usb_hid_report_output(hid_dev->report, 
+            &kbd_dev->output_size, 0);
+        if (kbd_dev->output_buffer == NULL) {
                 usb_log_warning("Error creating output report buffer.\n");
                 free(kbd_dev->keys);
-                free(kbd_dev);
-                return ENOMEM;
+                return ENOMEM;  /* TODO: other error code */
         }
         
@@ -780 +856 @@
             kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
         
-        kbd_dev->led_output_size = usb_hid_report_output_size(hid_dev->parser, 
+        kbd_dev->led_output_size = usb_hid_report_output_size(hid_dev->report, 
             kbd_dev->led_path, 
             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
@@ -908 +984 @@
         }
         
-        // free the output buffer
-        usb_hid_report_output_free((*kbd_dev)->output_buffer);
+        // free all buffers
+        if ((*kbd_dev)->keys != NULL) {
+                free((*kbd_dev)->keys);
+        }
+        if ((*kbd_dev)->keys_old != NULL) {
+                free((*kbd_dev)->keys_old);
+        }
+        if ((*kbd_dev)->led_data != NULL) {
+                free((*kbd_dev)->led_data);
+        }
+        if ((*kbd_dev)->output_buffer != NULL) {
+                free((*kbd_dev)->output_buffer);
+        }
+        if ((*kbd_dev)->led_path != NULL) {
+                usb_hid_report_path_free((*kbd_dev)->led_path);
+        }
+        if ((*kbd_dev)->output_buffer != NULL) {
+                usb_hid_report_output_free((*kbd_dev)->output_buffer);
+        }
 
         free(*kbd_dev);
@@ -929 +1022 @@
                 } else {
                         usb_kbd_free(&kbd_dev);
+                        hid_dev->data = NULL;
                 }
         }
@@ -937 +1031 @@
 int usb_kbd_set_boot_protocol(usb_hid_dev_t *hid_dev)
 {
-        int rc = usb_hid_parse_report_descriptor(hid_dev->parser, 
+        int rc = usb_hid_parse_report_descriptor(hid_dev->report, 
             USB_KBD_BOOT_REPORT_DESCRIPTOR, 
             USB_KBD_BOOT_REPORT_DESCRIPTOR_SIZE);

uspace/drv/usbhid/kbd/kbddev.h

@@ -65 +65 @@
  */
 typedef struct usb_kbd_t {
+        /** Previously pressed keys (not translated to key codes). */
+        int32_t *keys_old;
         /** Currently pressed keys (not translated to key codes). */
-        uint8_t *keys;
+        int32_t *keys;
         /** Count of stored keys (i.e. number of keys in the report). */
         size_t key_count;

uspace/drv/usbhid/lgtch-ultrax/lgtch-ultrax.c

@@ -38 +38 @@
 #include "lgtch-ultrax.h"
 #include "../usbhid.h"
+#include "keymap.h"
 
 #include <usb/classes/hidparser.h>
 #include <usb/debug.h>
+#include <usb/classes/hidut.h>
+
 #include <errno.h>
 #include <str_error.h>
 
+#include <ipc/kbd.h>
+#include <io/console.h>
+
 #define NAME "lgtch-ultrax"
 
-/*----------------------------------------------------------------------------*/
-
-static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
-    uint8_t report_id, void *arg);
-
-static const usb_hid_report_in_callbacks_t usb_lgtch_parser_callbacks = {
-        .keyboard = usb_lgtch_process_keycodes
+typedef enum usb_lgtch_flags {
+        USB_LGTCH_STATUS_UNINITIALIZED = 0,
+        USB_LGTCH_STATUS_INITIALIZED = 1,
+        USB_LGTCH_STATUS_TO_DESTROY = -1
+} usb_lgtch_flags;
+
+
+/*----------------------------------------------------------------------------*/
+/** 
+ * Default handler for IPC methods not handled by DDF.
+ *
+ * Currently recognizes only one method (IPC_M_CONNECT_TO_ME), in which case it
+ * assumes the caller is the console and thus it stores IPC phone to it for 
+ * later use by the driver to notify about key events.
+ *
+ * @param fun Device function handling the call.
+ * @param icallid Call id.
+ * @param icall Call data.
+ */
+static void default_connection_handler(ddf_fun_t *fun,
+    ipc_callid_t icallid, ipc_call_t *icall)
+{
+        usb_log_debug(NAME " default_connection_handler()\n");
+        
+        sysarg_t method = IPC_GET_IMETHOD(*icall);
+        
+        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        
+        if (hid_dev == NULL || hid_dev->data == NULL) {
+                async_answer_0(icallid, EINVAL);
+                return;
+        }
+        
+        assert(hid_dev != NULL);
+        assert(hid_dev->data != NULL);
+        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)hid_dev->data;
+
+        if (method == IPC_M_CONNECT_TO_ME) {
+                int callback = IPC_GET_ARG5(*icall);
+
+                if (lgtch_dev->console_phone != -1) {
+                        async_answer_0(icallid, ELIMIT);
+                        return;
+                }
+
+                lgtch_dev->console_phone = callback;
+                usb_log_debug(NAME " Saved phone to console: %d\n", callback);
+                async_answer_0(icallid, EOK);
+                return;
+        }
+        
+        async_answer_0(icallid, EINVAL);
+}
+
+/*----------------------------------------------------------------------------*/
+
+static ddf_dev_ops_t lgtch_ultrax_ops = {
+        .default_handler = default_connection_handler
 };
 
 /*----------------------------------------------------------------------------*/
 
-static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
-    uint8_t report_id, void *arg)
-{
-        // TODO: checks
-        
-        usb_log_debug(NAME " Got keys from parser (report id: %u): %s\n", 
-            report_id, usb_debug_str_buffer(key_codes, count, 0));
+//static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
+//    uint8_t report_id, void *arg);
+
+//static const usb_hid_report_in_callbacks_t usb_lgtch_parser_callbacks = {
+//      .keyboard = usb_lgtch_process_keycodes
+//};
+
+///*----------------------------------------------------------------------------*/
+
+//static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
+//    uint8_t report_id, void *arg)
+//{
+//      // TODO: checks
+        
+//      usb_log_debug(NAME " Got keys from parser (report id: %u): %s\n", 
+//          report_id, usb_debug_str_buffer(key_codes, count, 0));
+//}
+
+/*----------------------------------------------------------------------------*/
+/**
+ * Processes key events.
+ *
+ * @note This function was copied from AT keyboard driver and modified to suit
+ *       USB keyboard.
+ *
+ * @note Lock keys are not sent to the console, as they are completely handled
+ *       in the driver. It may, however, be required later that the driver
+ *       sends also these keys to application (otherwise it cannot use those
+ *       keys at all).
+ * 
+ * @param hid_dev 
+ * @param lgtch_dev 
+ * @param type Type of the event (press / release). Recognized values: 
+ *             KEY_PRESS, KEY_RELEASE
+ * @param key Key code of the key according to HID Usage Tables.
+ */
+static void usb_lgtch_push_ev(usb_hid_dev_t *hid_dev, int type, 
+    unsigned int key)
+{
+        assert(hid_dev != NULL);
+        assert(hid_dev->data != NULL);
+        
+        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)hid_dev->data;
+        
+        console_event_t ev;
+        
+        ev.type = type;
+        ev.key = key;
+        ev.mods = 0;
+
+        ev.c = 0;
+
+        usb_log_debug2(NAME " Sending key %d to the console\n", ev.key);
+        if (lgtch_dev->console_phone < 0) {
+                usb_log_warning(
+                    "Connection to console not ready, key discarded.\n");
+                return;
+        }
+        
+        async_msg_4(lgtch_dev->console_phone, KBD_EVENT, ev.type, ev.key, 
+            ev.mods, ev.c);
+}
+
+/*----------------------------------------------------------------------------*/
+
+static void usb_lgtch_free(usb_lgtch_ultrax_t **lgtch_dev)
+{
+        if (lgtch_dev == NULL || *lgtch_dev == NULL) {
+                return;
+        }
+        
+        // hangup phone to the console
+        async_hangup((*lgtch_dev)->console_phone);
+        
+//      if ((*lgtch_dev)->repeat_mtx != NULL) {
+//              /* TODO: replace by some check and wait */
+//              assert(!fibril_mutex_is_locked((*lgtch_dev)->repeat_mtx));
+//              free((*lgtch_dev)->repeat_mtx);
+//      }
+        
+        // free all buffers
+        if ((*lgtch_dev)->keys != NULL) {
+                free((*lgtch_dev)->keys);
+        }
+        if ((*lgtch_dev)->keys_old != NULL) {
+                free((*lgtch_dev)->keys_old);
+        }
+
+        free(*lgtch_dev);
+        *lgtch_dev = NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_lgtch_init(struct usb_hid_dev *hid_dev)
+{
+        if (hid_dev == NULL || hid_dev->usb_dev == NULL) {
+                return EINVAL; /*! @todo Other return code? */
+        }
+        
+        usb_log_debug(NAME " Initializing HID/lgtch_ultrax structure...\n");
+        
+        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)malloc(
+            sizeof(usb_lgtch_ultrax_t));
+        if (lgtch_dev == NULL) {
+                return ENOMEM;
+        }
+        
+        lgtch_dev->console_phone = -1;
+        
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
+        
+        usb_hid_report_path_set_report_id(path, 1);
+        
+        lgtch_dev->key_count = usb_hid_report_input_length(
+            hid_dev->report, path, 
+            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
+        usb_hid_report_path_free(path);
+        
+        usb_log_debug(NAME " Size of the input report: %zu\n", 
+            lgtch_dev->key_count);
+        
+        lgtch_dev->keys = (int32_t *)calloc(lgtch_dev->key_count, 
+            sizeof(int32_t));
+        
+        if (lgtch_dev->keys == NULL) {
+                usb_log_fatal("No memory!\n");
+                free(lgtch_dev);
+                return ENOMEM;
+        }
+        
+        lgtch_dev->keys_old = 
+                (int32_t *)calloc(lgtch_dev->key_count, sizeof(int32_t));
+        
+        if (lgtch_dev->keys_old == NULL) {
+                usb_log_fatal("No memory!\n");
+                free(lgtch_dev->keys);
+                free(lgtch_dev);
+                return ENOMEM;
+        }
+        
+        /*! @todo Autorepeat */
+        
+        // save the KBD device structure into the HID device structure
+        hid_dev->data = lgtch_dev;
+        
+        /* Create the function exposed under /dev/devices. */
+        ddf_fun_t *fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed, 
+            NAME);
+        if (fun == NULL) {
+                usb_log_error("Could not create DDF function node.\n");
+                return ENOMEM;
+        }
+        
+        lgtch_dev->initialized = USB_LGTCH_STATUS_INITIALIZED;
+        usb_log_debug(NAME " HID/lgtch_ultrax device structure initialized.\n");
+        
+        /*
+         * Store the initialized HID device and HID ops
+         * to the DDF function.
+         */
+        fun->ops = &lgtch_ultrax_ops;
+        fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+        
+        /*
+         * 1) subdriver vytvori vlastnu ddf_fun, vlastne ddf_dev_ops, ktore da
+         *    do nej.
+         * 2) do tych ops do .interfaces[DEV_IFACE_USBHID (asi)] priradi 
+         *    vyplnenu strukturu usbhid_iface_t.
+         * 3) klientska aplikacia - musi si rucne vytvorit telefon
+         *    (devman_device_connect() - cesta k zariadeniu (/hw/pci0/...) az 
+         *    k tej fcii.
+         *    pouzit usb/classes/hid/iface.h - prvy int je telefon
+         */
+
+        int rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                usb_log_error("Could not bind DDF function: %s.\n",
+                    str_error(rc));
+                // TODO: Can / should I destroy the DDF function?
+                ddf_fun_destroy(fun);
+                usb_lgtch_free(&lgtch_dev);
+                return rc;
+        }
+        
+        rc = ddf_fun_add_to_class(fun, "keyboard");
+        if (rc != EOK) {
+                usb_log_error(
+                    "Could not add DDF function to class 'keyboard': %s.\n",
+                    str_error(rc));
+                // TODO: Can / should I destroy the DDF function?
+                ddf_fun_destroy(fun);
+                usb_lgtch_free(&lgtch_dev);
+                return rc;
+        }
+        
+        usb_log_debug(NAME " HID/lgtch_ultrax structure initialized.\n");
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+void usb_lgtch_deinit(struct usb_hid_dev *hid_dev)
+{
+        if (hid_dev == NULL) {
+                return;
+        }
+        
+        if (hid_dev->data != NULL) {
+                usb_lgtch_ultrax_t *lgtch_dev = 
+                    (usb_lgtch_ultrax_t *)hid_dev->data;
+//              if (usb_kbd_is_initialized(kbd_dev)) {
+//                      usb_kbd_mark_unusable(kbd_dev);
+//              } else {
+                        usb_lgtch_free(&lgtch_dev);
+                        hid_dev->data = NULL;
+//              }
+        }
 }
 
@@ -81 +351 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, 0xc, 0);
-        usb_hid_report_path_set_report_id(path, 1);
-        
-        int rc = usb_hid_parse_report(hid_dev->parser, buffer,
-            buffer_size, path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            &usb_lgtch_parser_callbacks, hid_dev);
+
+        uint8_t report_id;
+        
+        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size, 
+            &report_id);
+        usb_hid_report_path_set_report_id(path, report_id);
+
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
+            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END 
+            | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+            USB_HID_REPORT_TYPE_INPUT);
+        
+        unsigned int key;
+        
+        /*! @todo Is this iterating OK if done multiple times? 
+         *  @todo The parsing is not OK
+         */
+        while (field != NULL) {
+                usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n", field->value, 
+                    field->usage);
+                
+                key = usb_lgtch_map_usage(field->usage);
+                usb_lgtch_push_ev(hid_dev, KEY_PRESS, key);
+                
+                field = usb_hid_report_get_sibling(
+                    hid_dev->report, field, path, USB_HID_PATH_COMPARE_END
+                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+                    USB_HID_REPORT_TYPE_INPUT);
+        }       
 
         usb_hid_report_path_free(path);
         
         if (rc != EOK) {
-                usb_log_warning("Error in usb_hid_boot_keyboard_input_report():"
+                usb_log_warning(NAME "Error in usb_hid_boot_keyboard_input_report():"
                     "%s\n", str_error(rc));
         }

uspace/drv/usbhid/lgtch-ultrax/lgtch-ultrax.h

@@ -40 +40 @@
 
 struct usb_hid_dev;
-//struct usb_hid_subdriver_mapping;
+
+/*----------------------------------------------------------------------------*/
+/**
+ * USB/HID keyboard device type.
+ *
+ * Holds a reference to generic USB/HID device structure and keyboard-specific
+ * data, such as currently pressed keys, modifiers and lock keys.
+ *
+ * Also holds a IPC phone to the console (since there is now no other way to 
+ * communicate with it).
+ *
+ * @note Storing active lock keys in this structure results in their setting
+ *       being device-specific.
+ */
+typedef struct usb_lgtch_ultrax_t {
+        /** Previously pressed keys (not translated to key codes). */
+        int32_t *keys_old;
+        /** Currently pressed keys (not translated to key codes). */
+        int32_t *keys;
+        /** Count of stored keys (i.e. number of keys in the report). */
+        size_t key_count;
+        
+        /** IPC phone to the console device (for sending key events). */
+        int console_phone;
+
+        /** Information for auto-repeat of keys. */
+//      usb_kbd_repeat_t repeat;
+        
+        /** Mutex for accessing the information about auto-repeat. */
+//      fibril_mutex_t *repeat_mtx;
+
+        /** State of the structure (for checking before use). 
+         * 
+         * 0 - not initialized
+         * 1 - initialized
+         * -1 - ready for destroying
+         */
+        int initialized;
+} usb_lgtch_ultrax_t;
 
 /*----------------------------------------------------------------------------*/
 
-//extern struct usb_hid_subdriver_mapping usb_lgtch_mapping;
+int usb_lgtch_init(struct usb_hid_dev *hid_dev);
 
-/*----------------------------------------------------------------------------*/
-
-//int usb_lgtch_init(struct usb_hid_dev *hid_dev);
+void usb_lgtch_deinit(struct usb_hid_dev *hid_dev);
 
 bool usb_lgtch_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,

uspace/drv/usbhid/main.c

@@ -114 +114 @@
         hid_fun->ops = &hid_dev->ops;
         hid_fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+        
+        /*
+         * 1) subdriver vytvori vlastnu ddf_fun, vlastne ddf_dev_ops, ktore da
+         *    do nej.
+         * 2) do tych ops do .interfaces[DEV_IFACE_USBHID (asi)] priradi 
+         *    vyplnenu strukturu usbhid_iface_t.
+         * 3) klientska aplikacia - musi si rucne vytvorit telefon
+         *    (devman_device_connect() - cesta k zariadeniu (/hw/pci0/...) az 
+         *    k tej fcii.
+         *    pouzit usb/classes/hid/iface.h - prvy int je telefon
+         */
 
         rc = ddf_fun_bind(hid_fun);

uspace/drv/usbhid/mouse/mousedev.c

@@ -296 +296 @@
 int usb_mouse_set_boot_protocol(usb_hid_dev_t *hid_dev)
 {
-        int rc = usb_hid_parse_report_descriptor(hid_dev->parser, 
+        int rc = usb_hid_parse_report_descriptor(hid_dev->report, 
             USB_MOUSE_BOOT_REPORT_DESCRIPTOR, 
             USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE);

uspace/drv/usbhid/subdrivers.c

@@ -55 +55 @@
                 USB_HID_PATH_COMPARE_END 
                 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
-                0,
-                0,
+                -1,
+                -1,
                 {
                         .init = usb_kbd_init,
@@ -73 +73 @@
                 0xc30e,
                 {
-                        .init = NULL,
-                        .deinit = NULL,
+                        .init = usb_lgtch_init,
+                        .deinit = usb_lgtch_deinit,
                         .poll = usb_lgtch_polling_callback,
                         .poll_end = NULL
                 }
         },
-        {NULL, -1, 0, 0, 0, {NULL, NULL, NULL, NULL}}
+        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}}
 };
 

uspace/drv/usbhid/subdrivers.h

@@ -56 +56 @@
         int report_id;
         int compare;
-        uint16_t vendor_id;
-        uint16_t product_id;
+        int vendor_id;
+        int product_id;
         usb_hid_subdriver_t subdriver;
 } usb_hid_subdriver_mapping_t;

uspace/drv/usbhid/usbhid.c

@@ -158 +158 @@
     const usb_hid_subdriver_mapping_t *mapping)
 {
-        return false;
+        assert(hid_dev != NULL);
+        assert(hid_dev->usb_dev != NULL);
+        
+        return (hid_dev->usb_dev->descriptors.device.vendor_id 
+            == mapping->vendor_id
+            && hid_dev->usb_dev->descriptors.device.product_id 
+            == mapping->product_id);
 }
 
@@ -192 +198 @@
         }
         
-        assert(hid_dev->parser != NULL);
+        assert(hid_dev->report != NULL);
         
         usb_log_debug("Compare flags: %d\n", mapping->compare);
-        size_t size = usb_hid_report_input_length(hid_dev->parser, usage_path, 
+        size_t size = usb_hid_report_input_length(hid_dev->report, usage_path, 
             mapping->compare);
         usb_log_debug("Size of the input report: %zuB\n", size);
@@ -251 +257 @@
         while (count < USB_HID_MAX_SUBDRIVERS &&
             (mapping->usage_path != NULL
-            || mapping->vendor_id != 0 || mapping->product_id != 0)) {
+            || mapping->vendor_id >= 0 || mapping->product_id >= 0)) {
                 // check the vendor & product ID
-                if (mapping->vendor_id != 0 && mapping->product_id == 0) {
-                        usb_log_warning("Missing Product ID for Vendor ID %u\n",
+                if (mapping->vendor_id >= 0 && mapping->product_id < 0) {
+                        usb_log_warning("Missing Product ID for Vendor ID %d\n",
                             mapping->vendor_id);
                         return EINVAL;
                 }
-                if (mapping->product_id != 0 && mapping->vendor_id == 0) {
-                        usb_log_warning("Missing Vendor ID for Product ID %u\n",
+                if (mapping->product_id >= 0 && mapping->vendor_id < 0) {
+                        usb_log_warning("Missing Vendor ID for Product ID %d\n",
                             mapping->product_id);
                         return EINVAL;
@@ -267 +273 @@
                 matched = false;
                 
-                if (mapping->vendor_id != 0) {
-                        assert(mapping->product_id != 0);
+                if (mapping->vendor_id >= 0) {
+                        assert(mapping->product_id >= 0);
                         usb_log_debug("Comparing device against vendor ID %u"
                             " and product ID %u.\n", mapping->vendor_id,
@@ -341 +347 @@
         }
         
-        hid_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
-            usb_hid_report_parser_t)));
-        if (hid_dev->parser == NULL) {
+        hid_dev->report = (usb_hid_report_t *)(malloc(sizeof(
+            usb_hid_report_t)));
+        if (hid_dev->report == NULL) {
                 usb_log_fatal("No memory!\n");
                 free(hid_dev);
@@ -382 +388 @@
                 return rc;
         }
-        
-        /* Initialize the report parser. */
-        rc = usb_hid_parser_init(hid_dev->parser);
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize report parser.\n");
-                //usb_hid_free(&hid_dev);
-                return rc;
-        }
-        
+                
         /* Get the report descriptor and parse it. */
         rc = usb_hid_process_report_descriptor(hid_dev->usb_dev, 
-            hid_dev->parser);
+            hid_dev->report);
         
         bool fallback = false;
@@ -591 +589 @@
 
         // destroy the parser
-        if ((*hid_dev)->parser != NULL) {
-                usb_hid_free_report_parser((*hid_dev)->parser);
+        if ((*hid_dev)->report != NULL) {
+                usb_hid_free_report((*hid_dev)->report);
         }
 

uspace/drv/usbhid/usbhid.h

@@ -91 +91 @@
         
         /** HID Report parser. */
-        usb_hid_report_parser_t *parser;
+        usb_hid_report_t *report;
         
         /** Arbitrary data (e.g. a special structure for handling keyboard). */

uspace/drv/usbkbd/kbddev.c

@@ -128 +128 @@
         0x15, 0x00,  //   Logical Minimum (0),
         0x25, 0x01,  //   Logical Maximum (1),
+        //0x85, 0x00,  //   Report ID,
+        //0xA4,      //   Push
         0x81, 0x02,  //   Input (Data, Variable, Absolute),   ; Modifier byte
-        0x95, 0x01,  //   Report Count (1),
-        0x75, 0x08,  //   Report Size (8),
+        //0xB4,      //   Pop
+        0x75, 0x08,  //   Report Size (1),
+        0x95, 0x01,  //   Report Count (8),       
         0x81, 0x01,  //   Input (Constant),                   ; Reserved byte
         0x95, 0x05,  //   Report Count (5),
@@ -268 +271 @@
                 return;
         }
-        
+
         unsigned i = 0;
         
@@ -290 +293 @@
         
         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 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            kbd_dev->output_buffer, 
-            kbd_dev->output_size, kbd_dev->led_data, kbd_dev->led_output_size);
+
+        usb_hid_report_output_set_data(kbd_dev->parser, kbd_dev->led_path, 
+                                       USB_HID_PATH_COMPARE_END , 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) {
@@ -563 +566 @@
         assert(kbd_dev != NULL);
 
-        usb_log_debug("Got keys from parser (report id: %u): %s\n", 
-            report_id, usb_debug_str_buffer(key_codes, count, 0));
+        usb_log_debug("Got keys from parser (report id: %d): %s\n", report_id, 
+            usb_debug_str_buffer(key_codes, count, 0));
         
         if (count != kbd_dev->key_count) {
@@ -614 +617 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
-        usb_hid_report_path_set_report_id(path, 0);
-        
-        int rc = usb_hid_parse_report(kbd_dev->parser, buffer,
-            actual_size, path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            callbacks, kbd_dev);
+
+        uint8_t report_id;
+        int rc = usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, &report_id);
+        usb_hid_descriptor_print (kbd_dev->parser);
 
         usb_hid_report_path_free (path);
@@ -663 +664 @@
         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");
@@ -732 +733 @@
         
         /* 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. */
@@ -771 +772 @@
         
         kbd_dev->key_count = usb_hid_report_input_length(
-            kbd_dev->parser, path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
+            kbd_dev->parser, path, USB_HID_PATH_COMPARE_END);
         usb_hid_report_path_free (path);
         
@@ -789 +789 @@
         kbd_dev->output_size = 0;
         kbd_dev->output_buffer = usb_hid_report_output(kbd_dev->parser, 
-            &kbd_dev->output_size);
-        if (kbd_dev->output_buffer == NULL && kbd_dev->output_size != 0) {
+            &kbd_dev->output_size, 0x00);
+        if (kbd_dev->output_buffer == NULL) {
                 usb_log_warning("Error creating output report buffer.\n");
                 free(kbd_dev->keys);
@@ -801 +801 @@
         usb_hid_report_path_append_item(
             kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
+        usb_hid_report_path_set_report_id(kbd_dev->led_path, 0x00);
         
         kbd_dev->led_output_size = usb_hid_report_output_size(kbd_dev->parser, 
@@ -849 +850 @@
          * Set Idle rate
          */
-        usb_kbd_set_led(kbd_dev);
+        usb_kbd_set_led(kbd_dev);       
         
         usbhid_req_set_idle(&kbd_dev->usb_dev->ctrl_pipe, 
@@ -934 +935 @@
         // destroy the parser
         if ((*kbd_dev)->parser != NULL) {
-                usb_hid_free_report_parser((*kbd_dev)->parser);
+                usb_hid_free_report((*kbd_dev)->parser);
         }
         

uspace/drv/usbkbd/kbddev.h

@@ -106 +106 @@
 
         /** HID Report parser. */
-        usb_hid_report_parser_t *parser;
+        usb_hid_report_t *parser;
         
         /** State of the structure (for checking before use). 

uspace/lib/usb/include/usb/classes/hid.h

@@ -50 +50 @@
         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 {

uspace/lib/usb/include/usb/classes/hidparser.h

@@ -73 +73 @@
 #define USB_HID_PATH_COMPARE_END                                1
 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    4
-
-/** */
-typedef struct {
-        /** */
-        int32_t usage_page;
-        /** */  
-        int32_t usage;
+#define USB_HID_PATH_COMPARE_COLLECTION_ONLY    2 /* porovnava jenom cestu z Kolekci */
+
+
+#define USB_HID_MAX_USAGES      20
+
+typedef enum {
+        USB_HID_REPORT_TYPE_INPUT = 1,
+        USB_HID_REPORT_TYPE_OUTPUT = 2,
+        USB_HID_REPORT_TYPE_FEATURE = 3
+} usb_hid_report_type_t;
+
+/** Collection usage path structure */
+typedef struct {
+        /** */
+        uint32_t usage_page;
+        /** */  
+        uint32_t usage;
+
+        uint8_t flags;
         /** */
         link_t link;
@@ -91 +103 @@
         
         /** */  
+        link_t link; /* list */
+
+        link_t head; /* head of list of usage paths */
+
+} usb_hid_report_path_t;
+
+
+typedef struct {
+        /** */
+        int report_count;
+        link_t reports;         /** list of usb_hid_report_description_t */
+
+        link_t collection_paths;
+        int collection_paths_count;
+
+        int use_report_ids;
+        uint8_t last_report_id;
+        
+} usb_hid_report_t;
+
+typedef struct {
+        uint8_t report_id;
+        usb_hid_report_type_t type;
+
+        size_t bit_length;
+        size_t item_length;
+        
+        link_t report_items;    /** list of report items (fields) */
+
         link_t link;
-
-} usb_hid_report_path_t;
-
-/**
- * Description of report items
- */
-typedef struct {
-        /** */  
+} 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 +193 @@
         size_t offset;
         /** */  
-        int32_t delimiter;
-        /** */  
         int32_t unit_exponent;
         /** */  
@@ -123 +198 @@
 
         /** */
-        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 +217 @@
         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 +249 @@
 } 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 +261 @@
 };
 
-//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);
-
-/*
- * Boot protocol functions
- */
-/** */
-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 usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size);
+void usb_hid_free_report(usb_hid_report_t *report);
+
+/** */
+void usb_hid_descriptor_print(usb_hid_report_t *report);
 
 
@@ -255 +280 @@
  */
 /** */
-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, uint8_t *report_id);
+
+/** */
+size_t usb_hid_report_input_length(const usb_hid_report_t *report,
         usb_hid_report_path_t *path, int flags);
 
@@ -296 +318 @@
 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path);
 
+usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags, usb_hid_report_type_t type);
+
+uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type);
+
 
 /*
@@ -301 +327 @@
  */
 /** Allocates output report buffer*/
-uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size);
+uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id);
 
 /** Frees output report buffer*/
@@ -307 +333 @@
 
 /** 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
 /**

uspace/lib/usb/include/usb/classes/hidreport.h

@@ -57 +57 @@
  */
 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_ */

uspace/lib/usb/include/usb/classes/hidut.h

@@ -46 +46 @@
         USB_HIDUT_PAGE_KEYBOARD = 7,
         USB_HIDUT_PAGE_LED = 8,
-        USB_HIDUT_PAGE_BUTTON = 9
-        /* USB_HIDUT_PAGE_ = , */
+        USB_HIDUT_PAGE_BUTTON = 9,
+        USB_HIDUT_PAGE_ORDINAL = 0x0a,
+        USB_HIDUT_PAGE_TELEPHONY_DEVICE = 0x0b,
+        USB_HIDUT_PAGE_CONSUMER = 0x0c
 } usb_hidut_usage_page_t;
 

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 & 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.
@@ -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;
+}
 /**
  * @}

uspace/lib/usb/src/hidreport.c

@@ -164 +164 @@
 
 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");
@@ -189 +189 @@
         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",
@@ -197 +197 @@
         }
         
-        usb_hid_descriptor_print(parser);
+        usb_hid_descriptor_print(report);
         free(report_desc);