Changes in / [308a5d5:564a2b3] in mainline

Location:

uspace

Files:

• drv/usbhid/kbd/conv.c (modified) (1 diff)
• drv/usbhid/kbd/kbddev.c (modified) (14 diffs)
• drv/usbhid/kbd/kbddev.h (modified) (1 diff)
• drv/usbhid/lgtch-ultrax/lgtch-ultrax.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) (8 diffs)
• lib/usb/include/usb/classes/hidreport.h (modified) (1 diff)
• lib/usb/src/hidparser.c (modified) (57 diffs)
• lib/usb/src/hidreport.c (modified) (3 diffs)

uspace/drv/usbhid/kbd/conv.c

@@ -99 +99 @@
         [0x30] = KC_RBRACKET,
         [0x31] = KC_BACKSLASH,
-        //[0x32] = KC_, // TODO: HASH??? maybe same as 0x31 - backslash
-        [0x32] = KC_BACKSLASH,
+        //[0x32] = KC_, // TODO: HASH??? maybe some as 0x31 - 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
+};
 
 /*----------------------------------------------------------------------------*/
@@ -299 +299 @@
                 return;
         }
-                
+        
+        unsigned i = 0;
+        
         /* Reset the LED data. */
         memset(kbd_dev->led_data, 0, kbd_dev->led_output_size * sizeof(int32_t));
-        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 ((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);
         
         if (rc != EOK) {
@@ -492 +485 @@
  */
 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;
@@ -506 +499 @@
          */
         i = 0;
-        while (i < kbd_dev->key_count && kbd_dev->keys[i] != ERROR_ROLLOVER) {
+        while (i < count && key_codes[i] != ERROR_ROLLOVER) {
                 ++i;
         }
-        if (i != kbd_dev->key_count) {
+        if (i != 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 < kbd_dev->key_count; ++j) {
+        for (j = 0; j < count; ++j) {
                 // try to find the old key in the new key list
                 i = 0;
                 while (i < kbd_dev->key_count
-                    && kbd_dev->keys[i] != kbd_dev->keys_old[j]) {
+                    && key_codes[i] != kbd_dev->keys[j]) {
                         ++i;
                 }
                 
-                if (i == kbd_dev->key_count) {
+                if (i == count) {
                         // not found, i.e. the key was released
-                        key = usbhid_parse_scancode(kbd_dev->keys_old[j]);
+                        key = usbhid_parse_scancode(kbd_dev->keys[j]);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_stop(kbd_dev, key);
@@ -545 +541 @@
                 // try to find the new key in the old key list
                 j = 0;
-                while (j < kbd_dev->key_count 
-                    && kbd_dev->keys_old[j] != kbd_dev->keys[i]) { 
+                while (j < count && kbd_dev->keys[j] != key_codes[i]) { 
                         ++j;
                 }
                 
-                if (j == kbd_dev->key_count) {
+                if (j == count) {
                         // not found, i.e. new key pressed
-                        key = usbhid_parse_scancode(kbd_dev->keys[i]);
+                        key = usbhid_parse_scancode(key_codes[i]);
                         usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
-                            kbd_dev->keys[i]);
-                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
+                            key_codes[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);
@@ -564 +560 @@
         }
         
-//      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");
+        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));
 }
 
@@ -605 +585 @@
  * @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);
+}
 
 /*----------------------------------------------------------------------------*/
@@ -658 +638 @@
                                  uint8_t *buffer, size_t actual_size)
 {
-        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;
+        assert(hid_dev->parser != NULL);
 
         usb_log_debug("Calling usb_hid_parse_report() with "
@@ -672 +648 @@
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
         //usb_hid_report_path_set_report_id(path, 0);
-
-        uint8_t report_id;
-        int rc = usb_hid_parse_report(hid_dev->report, buffer, actual_size, 
-            &report_id);
+        
+        int rc = usb_hid_parse_report(hid_dev->parser, buffer,
+            actual_size, path, 
+            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+            &usb_kbd_parser_callbacks, hid_dev);
+
+        usb_hid_report_path_free(path);
         
         if (rc != EOK) {
-                usb_log_warning("Error in usb_hid_parse_report():"
+                usb_log_warning("Error in usb_hid_boot_keyboard_input_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_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);
-        
-        usb_kbd_check_key_changes(hid_dev, kbd_dev);
 }
 
@@ -814 +747 @@
         
         kbd_dev->key_count = usb_hid_report_input_length(
-            hid_dev->report, path, 
+            hid_dev->parser, path, 
             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
         usb_hid_report_path_free(path);
@@ -820 +753 @@
         usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
         
-        kbd_dev->keys = (int32_t *)calloc(kbd_dev->key_count, sizeof(int32_t));
+        kbd_dev->keys = (uint8_t *)calloc(kbd_dev->key_count, sizeof(uint8_t));
         
         if (kbd_dev->keys == NULL) {
@@ -828 +761 @@
         }
         
-        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->report, 
-            &kbd_dev->output_size, 0);
-        if (kbd_dev->output_buffer == NULL) {
+        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) {
                 usb_log_warning("Error creating output report buffer.\n");
                 free(kbd_dev->keys);
-                return ENOMEM;  /* TODO: other error code */
+                free(kbd_dev);
+                return ENOMEM;
         }
         
@@ -856 +780 @@
             kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
         
-        kbd_dev->led_output_size = usb_hid_report_output_size(hid_dev->report, 
+        kbd_dev->led_output_size = usb_hid_report_output_size(hid_dev->parser, 
             kbd_dev->led_path, 
             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
@@ -1013 +937 @@
 int usb_kbd_set_boot_protocol(usb_hid_dev_t *hid_dev)
 {
-        int rc = usb_hid_parse_report_descriptor(hid_dev->report, 
+        int rc = usb_hid_parse_report_descriptor(hid_dev->parser, 
             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). */
-        int32_t *keys;
+        uint8_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

@@ -81 +81 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, 0xc, 0);
-
-        uint8_t report_id;
+        usb_hid_report_path_set_report_id(path, 1);
         
-        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_REPORT_TYPE_INPUT);
-        
-        while (field != NULL) {
-                usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n", field->value, 
-                    field->usage);
-        }
-        
+        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);
 
         usb_hid_report_path_free(path);
         
         if (rc != EOK) {
-                usb_log_warning(NAME "Error in usb_hid_boot_keyboard_input_report():"
+                usb_log_warning("Error in usb_hid_boot_keyboard_input_report():"
                     "%s\n", str_error(rc));
         }

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->report, 
+        int rc = usb_hid_parse_report_descriptor(hid_dev->parser, 
             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,
-                -1,
-                -1,
+                0,
+                0,
                 {
                         .init = usb_kbd_init,
@@ -79 +79 @@
                 }
         },
-        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}}
+        {NULL, -1, 0, 0, 0, {NULL, NULL, NULL, NULL}}
 };
 

uspace/drv/usbhid/subdrivers.h

@@ -56 +56 @@
         int report_id;
         int compare;
-        int vendor_id;
-        int product_id;
+        uint16_t vendor_id;
+        uint16_t 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)
 {
-        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);
+        return false;
 }
 
@@ -198 +192 @@
         }
         
-        assert(hid_dev->report != NULL);
+        assert(hid_dev->parser != NULL);
         
         usb_log_debug("Compare flags: %d\n", mapping->compare);
-        size_t size = usb_hid_report_input_length(hid_dev->report, usage_path, 
+        size_t size = usb_hid_report_input_length(hid_dev->parser, usage_path, 
             mapping->compare);
         usb_log_debug("Size of the input report: %zuB\n", size);
@@ -257 +251 @@
         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 %d\n",
+                if (mapping->vendor_id != 0 && mapping->product_id == 0) {
+                        usb_log_warning("Missing Product ID for Vendor ID %u\n",
                             mapping->vendor_id);
                         return EINVAL;
                 }
-                if (mapping->product_id >= 0 && mapping->vendor_id < 0) {
-                        usb_log_warning("Missing Vendor ID for Product ID %d\n",
+                if (mapping->product_id != 0 && mapping->vendor_id == 0) {
+                        usb_log_warning("Missing Vendor ID for Product ID %u\n",
                             mapping->product_id);
                         return EINVAL;
@@ -273 +267 @@
                 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,
@@ -347 +341 @@
         }
         
-        hid_dev->report = (usb_hid_report_t *)(malloc(sizeof(
-            usb_hid_report_t)));
-        if (hid_dev->report == NULL) {
+        hid_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
+            usb_hid_report_parser_t)));
+        if (hid_dev->parser == NULL) {
                 usb_log_fatal("No memory!\n");
                 free(hid_dev);
@@ -388 +382 @@
                 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->report);
+            hid_dev->parser);
         
         bool fallback = false;
@@ -589 +591 @@
 
         // destroy the parser
-        if ((*hid_dev)->report != NULL) {
-                usb_hid_free_report((*hid_dev)->report);
+        if ((*hid_dev)->parser != NULL) {
+                usb_hid_free_report_parser((*hid_dev)->parser);
         }
 

uspace/drv/usbhid/usbhid.h

@@ -91 +91 @@
         
         /** HID Report parser. */
-        usb_hid_report_t *report;
+        usb_hid_report_parser_t *parser;
         
         /** 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
-        //0xB4,      //   Pop
-        0x75, 0x08,  //   Report Size (1),
-        0x95, 0x01,  //   Report Count (8),       
+        0x95, 0x01,  //   Report Count (1),
+        0x75, 0x08,  //   Report Size (8),
         0x81, 0x01,  //   Input (Constant),                   ; Reserved byte
         0x95, 0x05,  //   Report Count (5),
@@ -271 +268 @@
                 return;
         }
-
+        
         unsigned i = 0;
         
@@ -293 +290 @@
         
         usb_log_debug("Creating output report.\n");
-
-        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);
+        
+        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);
         
         if (rc != EOK) {
@@ -566 +563 @@
         assert(kbd_dev != NULL);
 
-        usb_log_debug("Got keys from parser (report id: %d): %s\n", report_id, 
-            usb_debug_str_buffer(key_codes, count, 0));
+        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) {
@@ -617 +614 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
-
-        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_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);
 
         usb_hid_report_path_free (path);
@@ -664 +663 @@
         memset(kbd_dev, 0, sizeof(usb_kbd_t));
         
-        kbd_dev->parser = (usb_hid_report_t *)(malloc(sizeof(
-            usb_hid_report_t)));
+        kbd_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
+            usb_hid_report_parser_t)));
         if (kbd_dev->parser == NULL) {
                 usb_log_fatal("No memory!\n");
@@ -733 +732 @@
         
         /* 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. */
@@ -772 +771 @@
         
         kbd_dev->key_count = usb_hid_report_input_length(
-            kbd_dev->parser, path, USB_HID_PATH_COMPARE_END);
+            kbd_dev->parser, path, 
+            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
         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, 0x00);
-        if (kbd_dev->output_buffer == NULL) {
+            &kbd_dev->output_size);
+        if (kbd_dev->output_buffer == NULL && kbd_dev->output_size != 0) {
                 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, 
@@ -850 +849 @@
          * 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, 
@@ -935 +934 @@
         // destroy the parser
         if ((*kbd_dev)->parser != NULL) {
-                usb_hid_free_report((*kbd_dev)->parser);
+                usb_hid_free_report_parser((*kbd_dev)->parser);
         }
         

uspace/drv/usbkbd/kbddev.h

@@ -106 +106 @@
 
         /** HID Report parser. */
-        usb_hid_report_t *parser;
+        usb_hid_report_parser_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
-#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;
+        int32_t usage_page;
+        /** */  
+        int32_t usage;
         /** */
         link_t link;
@@ -103 +91 @@
         
         /** */  
-        link_t link; /* list */
-
-        link_t head; /* head of list of usage paths */
+        link_t link;
 
 } usb_hid_report_path_t;
 
-
+/**
+ * Description of report items
+ */
 typedef struct {
+        /** */  
+        int32_t id;
+        /** */  
+        int32_t usage_minimum;
+        /** */  
+        int32_t usage_maximum;
+        /** */  
+        int32_t logical_minimum;
+        /** */  
+        int32_t logical_maximum;
+        /** */  
+        int32_t size;
+        /** */  
+        int32_t count;
+        /** */  
+        size_t offset;
+        /** */  
+        int32_t delimiter;
+        /** */  
+        int32_t unit_exponent;
+        /** */  
+        int32_t unit;
+
         /** */
-        int report_count;
-        link_t reports;         /** list of usb_hid_report_description_t */
-
-        link_t collection_paths;
-        int collection_paths_count;
-
-        int use_report_ids;
-        uint8_t last_report_id;
-        
-} usb_hid_report_t;
-
-typedef struct {
-        uint8_t report_id;
-        usb_hid_report_type_t type;
-
-        size_t bit_length;
-        size_t item_length;
-        
-        link_t report_items;    /** list of report items (fields) */
-
-        link_t link;
-} usb_hid_report_description_t;
-
-typedef struct {
-
-        int offset;
-        size_t size;
-
-        uint16_t usage_page;
-        uint16_t usage;
-
+        int32_t string_index;
+        /** */  
+        int32_t string_minimum;
+        /** */  
+        int32_t string_maximum;
+        /** */  
+        int32_t designator_index;
+        /** */  
+        int32_t designator_minimum;
+        /** */  
+        int32_t designator_maximum;
+        /** */  
+        int32_t physical_minimum;
+        /** */  
+        int32_t physical_maximum;
+
+        /** */  
         uint8_t item_flags;
-        usb_hid_report_path_t *collection_path;
-
-        int32_t logical_minimum;
-        int32_t logical_maximum;
-        int32_t physical_minimum;
-        int32_t physical_maximum;
-        uint32_t usage_minimum;
-        uint32_t usage_maximum;
-        uint32_t unit;
-        uint32_t unit_exponent;
-        
-
-        int32_t value;
-
-        link_t link;
-} usb_hid_report_field_t;
-
-
-
-/**
- * state table
- */
-typedef struct {
-        /** report id */        
-        int32_t id;
-        
-        /** */
-        uint16_t extended_usage_page;
-        uint32_t usages[USB_HID_MAX_USAGES];
-        int usages_count;
-
-        /** */
-        uint32_t usage_page;
-
-        /** */  
-        uint32_t usage_minimum;
-        /** */  
-        uint32_t usage_maximum;
-        /** */  
-        int32_t logical_minimum;
-        /** */  
-        int32_t logical_maximum;
-        /** */  
-        int32_t size;
-        /** */  
-        int32_t count;
-        /** */  
-        size_t offset;
-        /** */  
-        int32_t unit_exponent;
-        /** */  
-        int32_t unit;
-
-        /** */
-        uint32_t string_index;
-        /** */  
-        uint32_t string_minimum;
-        /** */  
-        uint32_t string_maximum;
-        /** */  
-        uint32_t designator_index;
-        /** */  
-        uint32_t designator_minimum;
-        /** */  
-        uint32_t designator_maximum;
-        /** */  
-        int32_t physical_minimum;
-        /** */  
-        int32_t physical_maximum;
-
-        /** */  
-        uint8_t item_flags;
-
-        usb_hid_report_type_t type;
-
-        /** current collection path*/   
+
+        /** */  
         usb_hid_report_path_t *usage_path;
         /** */  
         link_t link;
 } usb_hid_report_item_t;
+
+
+/** HID 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. */
@@ -249 +189 @@
 } 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] = {
@@ -261 +210 @@
 };
 
+//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_parse_report_descriptor(usb_hid_report_t *report, 
+/** */
+int usb_hid_parser_init(usb_hid_report_parser_t *parser);
+
+/** */
+int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, 
     const uint8_t *data, size_t size);
 
 /** */
-void usb_hid_free_report(usb_hid_report_t *report);
-
-/** */
-void usb_hid_descriptor_print(usb_hid_report_t *report);
+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);
 
 
@@ -280 +255 @@
  */
 /** */
-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,
+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,
         usb_hid_report_path_t *path, int flags);
 
@@ -318 +296 @@
 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);
-
 
 /*
@@ -327 +301 @@
  */
 /** Allocates output report buffer*/
-uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id);
+uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size);
 
 /** Frees output report buffer*/
@@ -333 +307 @@
 
 /** Returns size of output for given usage path */
-size_t usb_hid_report_output_size(usb_hid_report_t *report,
+size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser,
                                   usb_hid_report_path_t *path, int flags);
 
-/** Sets data in report structure */
-int usb_hid_report_output_set_data(usb_hid_report_t *report, 
-                                   usb_hid_report_path_t *path, int flags, 
-                                  int *data, size_t data_size);
-
-/** Makes the output report buffer by translated given data */
-int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id, uint8_t *buffer, size_t size);
+/** 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);
 #endif
 /**

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

@@ -57 +57 @@
  */
 int usb_hid_process_report_descriptor(usb_device_t *dev, 
-    usb_hid_report_t *report);
+    usb_hid_report_parser_t *parser);
 
 #endif /* LIBUSB_HIDREPORT_H_ */

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
 
-/** 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_NO_ACTION               2
+
+/** */
 #define USB_HID_UNKNOWN_TAG             -99
 
@@ -59 +52 @@
  * 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);
@@ -71 +61 @@
                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
 
-void usb_hid_print_usage_path(usb_hid_report_path_t *path);
 void usb_hid_descriptor_print_list(link_t *head);
-void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
+int usb_hid_report_reset_local_items();
 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);
@@ -79 +68 @@
  * Data translation private functions
  */
-uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
+int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size);
 inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
-int usb_hid_translate_data(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_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_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)
@@ -109 +96 @@
  * @return Error code
  */
-int usb_hid_report_init(usb_hid_report_t *report)
-{
-        if(report == NULL) {
+int usb_hid_parser_init(usb_hid_report_parser_t *parser)
+{
+        if(parser == NULL) {
                 return EINVAL;
         }
 
-        memset(report, 0, sizeof(usb_hid_report_t));
-        list_initialize(&report->reports);
-        list_initialize(&report->collection_paths);
-
-        report->use_report_ids = 0;
+        list_initialize(&(parser->input));
+    list_initialize(&(parser->output));
+    list_initialize(&(parser->feature));
+
+        list_initialize(&(parser->stack));
+
+        parser->use_report_id = 0;
     return EOK;   
 }
 
-int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item)
-{
-        usb_hid_report_field_t *field;
-        int i;
-
-
-        /* find or append current collection path to the list */
-        link_t *path_it = report->collection_paths.next;
-        usb_hid_report_path_t *path = NULL;
-        while(path_it != &report->collection_paths) {
-                path = list_get_instance(path_it, usb_hid_report_path_t, link);
-                
-                if(usb_hid_report_compare_usage_path(path, report_item->usage_path, USB_HID_PATH_COMPARE_STRICT) == EOK){
-                        break;
-                }                       
-                path_it = path_it->next;
-        }
-        if(path_it == &report->collection_paths) {
-                path = usb_hid_report_path_clone(report_item->usage_path);                      
-                list_append(&path->link, &report->collection_paths);                                    
-                report->collection_paths_count++;
-        }
-
-        for(i=0; i<report_item->usages_count; i++){
-                usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]);
-        }
-
-        
-        for(i=0; i<report_item->count; i++){
-
-                field = malloc(sizeof(usb_hid_report_field_t));
-                memset(field, 0, sizeof(usb_hid_report_field_t));
-                list_initialize(&field->link);
-
-                /* fill the attributes */               
-                field->collection_path = path;
-                field->logical_minimum = report_item->logical_minimum;
-                field->logical_maximum = report_item->logical_maximum;
-                field->physical_minimum = report_item->physical_minimum;
-                field->physical_maximum = report_item->physical_maximum;
-
-                field->usage_minimum = report_item->usage_minimum;
-                field->usage_maximum = report_item->usage_maximum;
-                if(report_item->extended_usage_page != 0){
-                        field->usage_page = report_item->extended_usage_page;
-                }
-                else {
-                        field->usage_page = report_item->usage_page;
-                }
-
-                if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
-                        uint32_t usage;
-                        if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
-                                if(i < report_item->usages_count){
-                                        usage = report_item->usages[i];
-                                }
-                                else {
-                                        usage = report_item->usages[report_item->usages_count - 1];
-                                }
-                        }
-                        else {
-                                if((report_item->count - i - 1) < report_item->usages_count){
-                                        usage = report_item->usages[(report_item->count - i - 1)];
-                                }
-                                else {
-                                        usage = report_item->usages[report_item->usages_count - 1];
-                                }
-                        }
-
-                                                
-                        if((usage & 0xFF00) != 0){
-                                field->usage_page = (usage >> 16);                                      
-                                field->usage = (usage & 0xFF);
-                        }
-                        else {
-                                field->usage = usage;
-                        }
-
-                        
-                }       
-
-                if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {
-                        if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
-                                field->usage = report_item->usage_maximum - i;
-                        }
-                        else {
-                                field->usage = report_item->usage_minimum + i;                                  
-                        }
-
-                }
-                
-                field->size = report_item->size;
-                field->offset = report_item->offset + (i * report_item->size);
-                if(report_item->id != 0) {
-                        field->offset += 8;
-                        report->use_report_ids = 1;
-                }
-                field->item_flags = report_item->item_flags;
-
-                /* find the right report list*/
-                usb_hid_report_description_t *report_des;
-                report_des = usb_hid_report_find_description(report, report_item->id, report_item->type);
-                if(report_des == NULL){
-                        report_des = malloc(sizeof(usb_hid_report_description_t));
-                        memset(report_des, 0, sizeof(usb_hid_report_description_t));
-
-                        report_des->type = report_item->type;
-                        report_des->report_id = report_item->id;
-                        list_initialize (&report_des->link);
-                        list_initialize (&report_des->report_items);
-
-                        list_append(&report_des->link, &report->reports);
-                        report->report_count++;
-                }
-
-                /* append this field to the end of founded report list */
-                list_append (&field->link, &report_des->report_items);
-                
-                /* update the sizes */
-                report_des->bit_length += field->size;
-                report_des->item_length++;
-
-        }
-
-
-        return EOK;
-}
-
-usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
-{
-        link_t *report_it = report->reports.next;
-        usb_hid_report_description_t *report_des = NULL;
-        
-        while(report_it != &report->reports) {
-                report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
-
-                if((report_des->report_id == report_id) && (report_des->type == type)){
-                        return report_des;
-                }
-                
-                report_it = report_it->next;
-        }
-
-        return NULL;
-}
 
 /** Parse HID report descriptor.
@@ -275 +119 @@
  * @return Error code.
  */
-int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
+int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, 
     const uint8_t *data, size_t size)
 {
@@ -286 +130 @@
         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_report_init(report) != EOK) {
+        if(usb_hid_parser_init(parser) != EOK) {
                 return EINVAL;
         }
         
+
         /*report item initialization*/
         if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
@@ -315 +159 @@
 
                         if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
-                                return EINVAL;
+                                return EINVAL; // TODO ERROR CODE
                         }
                         
@@ -321 +165 @@
                         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
-                                        // store current collection path
+                                        usb_log_debug("\nNEW REPORT ITEM: %X",ret);
+
+                                        // store current usage 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){
-                                                report->use_report_ids = 1;
+                                                parser->use_report_id = 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:
@@ -356 +218 @@
                                                     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 */
-                                        usb_hid_report_reset_local_items (report_item);
-
+                                        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;
+                                                                                
                                         break;
-
-                                case USB_HID_RESET_OFFSET:
-                                        offset_input = 0;
-                                        offset_output = 0;
-                                        offset_feature = 0;
-                                        usb_hid_report_path_set_report_id (usage_path, report_item->id);
-                                        break;
-
                                 case USB_HID_REPORT_TAG_PUSH:
                                         // push current state to stack
                                         new_report_item = usb_hid_report_item_clone(report_item);
-                                        usb_hid_report_path_t *tmp_path = usb_hid_report_path_clone(usage_path);
-                                        new_report_item->usage_path = tmp_path; 
-
-                                        list_prepend (&new_report_item->link, &stack);
+                                        list_prepend (&parser->stack, &new_report_item->link);
+                                        
                                         break;
                                 case USB_HID_REPORT_TAG_POP:
                                         // restore current state from stack
-                                        if(list_empty (&stack)) {
+                                        if(list_empty (&parser->stack)) {
                                                 return EINVAL;
                                         }
-                                        free(report_item);
-                                                
-                                        report_item = list_get_instance(stack.next, usb_hid_report_item_t, link);
                                         
-                                        usb_hid_report_usage_path_t *tmp_usage_path;
-                                        tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link);
-                                        
-                                        usb_hid_report_set_last_item(usage_path, tmp_usage_path->usage_page, tmp_usage_path->usage);
-
-                                        usb_hid_report_path_free(report_item->usage_path);
-                                        list_initialize(&report_item->usage_path->link);
-                                        list_remove (stack.next);
+                                        report_item = list_get_instance(&parser->stack, usb_hid_report_item_t, link);
+                                        list_remove (parser->stack.next);
                                         
                                         break;
@@ -422 +279 @@
 }
 
+
+/**
+ * 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;
+}
 
 /**
@@ -484 +401 @@
                         
                 case USB_HID_REPORT_TAG_COLLECTION:
-                        // TODO usage_path->flags = *data;
-                        usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]);                                         
-                        usb_hid_report_reset_local_items (report_item);
+                        usb_hid_report_path_append_item(usage_path, 0, 0);
+                                                
                         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;
@@ -517 +436 @@
         {
                 case USB_HID_REPORT_TAG_USAGE_PAGE:
-                        report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size);
+                        // 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));
                         break;
                 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
-                        report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
+                        report_item->logical_minimum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
-                        report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
+                        report_item->logical_maximum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
-                        report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
+                        report_item->physical_minimum = usb_hid_report_tag_data_int32(data,item_size);
                         break;                  
                 case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
-                        report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-
+                        report_item->physical_maximum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_UNIT_EXPONENT:
-                        report_item->unit_exponent = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->unit_exponent = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_UNIT:
-                        report_item->unit = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->unit = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_REPORT_SIZE:
-                        report_item->size = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->size = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_REPORT_COUNT:
-                        report_item->count = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->count = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_REPORT_ID:
-                        report_item->id = usb_hid_report_tag_data_uint32(data,item_size);
-                        return USB_HID_RESET_OFFSET;
+                        report_item->id = usb_hid_report_tag_data_int32(data,item_size);
                         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;
@@ -560 +475 @@
                         return USB_HID_NO_ACTION;
         }
-
+        
         return EOK;
 }
@@ -579 +494 @@
         {
                 case USB_HID_REPORT_TAG_USAGE:
-                        report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);
-                        report_item->usages_count++;
+                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL,
+                                usb_hid_report_tag_data_int32(data,item_size));
                         break;
                 case USB_HID_REPORT_TAG_USAGE_MINIMUM:
-                        if (item_size == 3) {
-                                // usage extended usages
-                                report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 
-                                report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
-                        }
-                        else {
-                                report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size);
-                        }
+                        report_item->usage_minimum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
-                        if (item_size == 3) {
-                                // usage extended usages
-                                report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16; 
-                                report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
-                        }
-                        else {
-                                report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size);
-                        }
+                        report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
-                        report_item->designator_index = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->designator_index = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
-                        report_item->designator_minimum = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->designator_minimum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
-                        report_item->designator_maximum = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->designator_maximum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_STRING_INDEX:
-                        report_item->string_index = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->string_index = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_STRING_MINIMUM:
-                        report_item->string_minimum = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->string_minimum = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 case USB_HID_REPORT_TAG_STRING_MAXIMUM:
-                        report_item->string_maximum = usb_hid_report_tag_data_uint32(data,item_size);
+                        report_item->string_maximum = usb_hid_report_tag_data_int32(data,item_size);
                         break;                  
                 case USB_HID_REPORT_TAG_DELIMITER:
-                        //report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size);
-                        //TODO: 
-                        //      DELIMITER STUFF
+                        report_item->delimiter = usb_hid_report_tag_data_int32(data,item_size);
                         break;
                 
@@ -634 +533 @@
 
 /**
- * Converts raw data to uint32 (thats the maximum length of short item data)
+ * Converts raw data to int32 (thats the maximum length of short item data)
  *
  * @param Data buffer
@@ -640 +539 @@
  * @return Converted int32 number
  */
-uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size)
+int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size)
 {
         unsigned int i;
-        uint32_t result;
+        int32_t result;
 
         result = 0;
@@ -653 +552 @@
 }
 
+
+
 /**
  * Prints content of given list of report items.
@@ -661 +562 @@
 void usb_hid_descriptor_print_list(link_t *head)
 {
-        usb_hid_report_field_t *report_item;
+        usb_hid_report_item_t *report_item;
+        usb_hid_report_usage_path_t *path_item;
+        link_t *path;
         link_t *item;
-
-
+        
         if(head == NULL || list_empty(head)) {
             usb_log_debug("\tempty\n");
@@ -672 +574 @@
         for(item = head->next; item != head; item = item->next) {
                 
-                report_item = list_get_instance(item, usb_hid_report_field_t, link);
-
-                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
-                usb_log_debug("\t\tSIZE: %X\n", report_item->size);                             
-                usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum);
-                usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum);                
-                usb_log_debug("\t\tPHYMIN: %d\n", report_item->physical_minimum);               
-                usb_log_debug("\t\tPHYMAX: %d\n", report_item->physical_maximum);                               
-                usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum);
-                usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum);
-
-                usb_log_debug("\t\tVALUE: %X\n", report_item->value);
-                usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
-                usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
-                                                
-//              usb_log_debug("\n");            
+                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");            
 
         }
@@ -699 +609 @@
  * @return void
  */
-void usb_hid_descriptor_print(usb_hid_report_t *report)
-{
-        if(report == NULL) {
+void usb_hid_descriptor_print(usb_hid_report_parser_t *parser)
+{
+        if(parser == NULL) {
                 return;
         }
-
-        link_t *report_it = report->reports.next;
-        usb_hid_report_description_t *report_des;
-
-        while(report_it != &report->reports) {
-                report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
-                usb_log_debug("Report ID: %d\n", report_des->report_id);
-                usb_log_debug("\tType: %d\n", report_des->type);
-                usb_log_debug("\tLength: %d\n", report_des->bit_length);                
-                usb_log_debug("\tItems: %d\n", report_des->item_length);                
-
-                usb_hid_descriptor_print_list(&report_des->report_items);
-
-
-                link_t *path_it = report->collection_paths.next;
-                while(path_it != &report->collection_paths) {
-                        usb_hid_print_usage_path (list_get_instance(path_it, usb_hid_report_path_t, link));
-                        path_it = path_it->next;
-                }
-                
-                report_it = report_it->next;
-        }
+        
+        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);
+
 }
 
@@ -769 +667 @@
  * @return void
  */
-void usb_hid_free_report(usb_hid_report_t *report)
-{
-        if(report == NULL){
+void usb_hid_free_report_parser(usb_hid_report_parser_t *parser)
+{
+        if(parser == NULL){
                 return;
         }
 
-        // free collection paths
-        usb_hid_report_path_t *path;
-        while(!list_empty(&report->collection_paths)) {
-                path = list_get_instance(report->collection_paths.next, usb_hid_report_path_t, link);
-                usb_hid_report_path_free(path);         
-        }
-        
-        // free report items
-        usb_hid_report_description_t *report_des;
-        usb_hid_report_field_t *field;
-        while(!list_empty(&report->reports)) {
-                report_des = list_get_instance(report->reports.next, usb_hid_report_description_t, link);
-                list_remove(&report_des->link);
-                
-                while(!list_empty(&report_des->report_items)) {
-                        field = list_get_instance(report_des->report_items.next, usb_hid_report_field_t, link);
-                        list_remove(&field->link);
-
-                        free(field);
-                }
-                
-                free(report_des);
-        }
-        
+        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);
+
         return;
 }
@@ -808 +688 @@
  * @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_t *report,  
-    const uint8_t *data, size_t size, uint8_t *report_id)
+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)
 {
         link_t *list_item;
-        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) {
+        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) {
                 return EINVAL;
         }
-
-        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);
+        
+        /* 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);
+        }
 
         /* read data */
-        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;
+        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;
+                                        }
+                                }
                         }
-                        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;
         
@@ -860 +758 @@
 
 /**
- * Translate data from the report as specified in report descriptor item
+ * Translate data from the report as specified in report descriptor
  *
  * @param item Report descriptor item with definition of translation
@@ -867 +765 @@
  * @return Translated data
  */
-int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data)
+int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j)
 {
         int resolution;
@@ -873 +771 @@
         int part_size;
         
-        int32_t value=0;
+        int32_t value;
         int32_t mask;
         const uint8_t *foo;
 
-        // now only shot tags are allowed
+        // now only common numbers llowed
         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){
@@ -897 +794 @@
         }
 
-        offset = item->offset;
+        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);
+        }
+        
         // FIXME
-        if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
+        if((offset/8) != ((offset+item->size)/8)) {
+                usb_log_debug2("offset %d\n", offset);
                 
                 part_size = ((offset+item->size)%8);
-
-                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);
-                        }
-                }
+                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);
+                
+                
         }
         else {          
@@ -927 +832 @@
                 mask =  ((1 << item->size)-1) << (8-((offset%8)+item->size));
                 value = (*foo & mask) >> (8-((offset%8)+item->size));
-        }
-
-        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
-                value = USB_HID_UINT32_TO_INT32(value, 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"); 
 
         return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum);
@@ -938 +847 @@
 
 /**
- * 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,
+ *
+ *
+ * @param parser
+ * @param path
+ * @param flags
+ * @return
+ */
+size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
         usb_hid_report_path_t *path, int flags)
 {       
-        
         size_t ret = 0;
-
-        if(report == NULL) {
+        link_t *item;
+        usb_hid_report_item_t *report_item;
+
+        if(parser == NULL) {
                 return 0;
         }
-
-        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);
+        
+        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;
                 }
-                
-                field_it = field_it->next;
-        }
+
+                item = item->next;
+        } 
 
         return ret;
-        }
-
-
-/**
- * Appends one item (couple of usage_path and usage) into the usage path
- * structure
- *
- * @param usage_path Usage path structure
- * @param usage_page Usage page constant
- * @param usage Usage constant
- * @return Error code
+}
+
+
+/**
+ * 
+ * @param usage_path
+ * @param usage_page
+ * @param usage
+ * @return
  */
 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 
@@ -1003 +899 @@
         item->usage = usage;
         item->usage_page = usage_page;
-        item->flags = 0;
-        
-        list_append (&item->link, &usage_path->head);
+        
+        usb_log_debug("Appending usage %d, usage page %d\n", usage, usage_page);
+        
+        list_append (&usage_path->link, &item->link);
         usage_path->depth++;
         return EOK;
@@ -1011 +908 @@
 
 /**
- * Removes last item from the usage path structure
- * @param usage_path 
- * @return void
+ *
+ * @param usage_path
+ * @return
  */
 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path)
@@ -1019 +916 @@
         usb_hid_report_usage_path_t *item;
         
-        if(!list_empty(&usage_path->head)){
-                item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);             
-                list_remove(usage_path->head.prev);
+        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);
                 usage_path->depth--;
                 free(item);
@@ -1028 +925 @@
 
 /**
- * Nulls last item of the usage path structure.
  *
  * @param usage_path
- * @return void
+ * @return
  */
 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path)
@@ -1037 +933 @@
         usb_hid_report_usage_path_t *item;
         
-        if(!list_empty(&usage_path->head)){     
-                item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
+        if(!list_empty(&usage_path->link)){     
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
                 memset(item, 0, sizeof(usb_hid_report_usage_path_t));
         }
@@ -1044 +940 @@
 
 /**
- * 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
+ *
+ * @param usage_path
+ * @param tag
+ * @param data
+ * @return
  */
 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data)
@@ -1056 +950 @@
         usb_hid_report_usage_path_t *item;
         
-        if(!list_empty(&usage_path->head)){     
-                item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
+        if(!list_empty(&usage_path->link)){     
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
 
                 switch(tag) {
@@ -1071 +965 @@
 }
 
-
-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
+/**
+ * 
+ *
+ * @param report_path
+ * @param path
+ * @param flags
+ * @return
  */
 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 
@@ -1132 +1005 @@
                                 }
 
-                                report_link = report_path->head.next;
-                                path_link = path->head.next;
+                                report_link = report_path->link.next;
+                                path_link = path->link.next;
                         
-                                while((report_link != &report_path->head) && (path_link != &path->head)) {
+                                while((report_link != &report_path->link) && (path_link != &path->link)) {
                                         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);            
@@ -1149 +1022 @@
                                 }
 
-                                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))) {
+                                if((report_link == &report_path->link) && (path_link == &path->link)) {
                                         return EOK;
                                 }
@@ -1160 +1032 @@
                 /* compare with only the end of path*/
                 case USB_HID_PATH_COMPARE_END:
-
-                                if((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) {
-                                        report_link = report_path->head.prev->prev;
-                                }
-                                else {
-                                        report_link = report_path->head.prev;
-                                }
-                                path_link = path->head.prev;
-
-                                if(list_empty(&path->head)){
+                                report_link = report_path->link.prev;
+                                path_link = path->link.prev;
+
+                                if(list_empty(&path->link)){
                                         return EOK;
                                 }
                         
-                                while((report_link != &report_path->head) && (path_link != &path->head)) {
+                                while((report_link != &report_path->link) && (path_link != &path->link)) {
                                         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);            
@@ -1187 +1053 @@
                                 }
 
-                                if(path_link == &path->head) {
+                                if(path_link == &path->link) {
                                         return EOK;
                                 }
@@ -1206 +1072 @@
 
 /**
- * Allocates and initializes new usage path structure.
- *
- * @return Initialized usage path structure
+ *
+ * @return
  */
 usb_hid_report_path_t *usb_hid_report_path(void)
@@ -1214 +1079 @@
         usb_hid_report_path_t *path;
         path = malloc(sizeof(usb_hid_report_path_t));
-        if(path == NULL){
+        if(!path){
                 return NULL;
         }
@@ -1221 +1086 @@
                 path->report_id = 0;
                 list_initialize(&path->link);
-                list_initialize(&path->head);
                 return path;
         }
@@ -1227 +1091 @@
 
 /**
- * Releases given usage path structure.
- *
- * @param path usage path structure to release
+ *
+ * @param path
  * @return void
  */
 void usb_hid_report_path_free(usb_hid_report_path_t *path)
 {
-        while(!list_empty(&path->head)){
+        while(!list_empty(&path->link)){
                 usb_hid_report_remove_last_item(path);
         }
-
-        list_remove(&path->link);
-        free(path);
 }
 
@@ -1246 +1106 @@
  * Clone content of given usage path to the new one
  *
- * @param usage_path Usage path structure to clone
- * @return New copy of given usage path structure
+ * @param usage_path
+ * @return
  */
 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path)
 {
+        usb_hid_report_usage_path_t *path_item;
         link_t *path_link;
-        usb_hid_report_usage_path_t *path_item;
-        usb_hid_report_usage_path_t *new_path_item;
         usb_hid_report_path_t *new_usage_path = usb_hid_report_path ();
 
@@ -1259 +1118 @@
                 return NULL;
         }
-
-        new_usage_path->report_id = usage_path->report_id;
-        
-        if(list_empty(&usage_path->head)){
+        
+        if(list_empty(&usage_path->link)){
                 return new_usage_path;
         }
 
-        path_link = usage_path->head.next;
-        while(path_link != &usage_path->head) {
+        path_link = usage_path->link.next;
+        while(path_link != &usage_path->link) {
                 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
-                new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
-                if(new_path_item == NULL) {
-                        return NULL;
-                }
-                
-                list_initialize (&new_path_item->link);         
-                new_path_item->usage_page = path_item->usage_page;
-                new_path_item->usage = path_item->usage;                
-                new_path_item->flags = path_item->flags;                
-                
-                list_append(&new_path_item->link, &new_usage_path->head);
-                new_usage_path->depth++;
+                usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage);
 
                 path_link = path_link->next;
@@ -1291 +1137 @@
 /*** OUTPUT API **/
 
-/** 
- * 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) {
+/** 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) {
                 *size = 0;
                 return NULL;
         }
-
-        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;
+        
+        // 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;
+        }
+        else {
+                *size = 0;              
                 return NULL;
         }
-        else {
-                *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;
-        }
 }
 
@@ -1333 +1175 @@
  *
  * @param output Output report buffer
- * @return void
+ * @return
  */
 void usb_hid_report_output_free(uint8_t *output)
@@ -1345 +1187 @@
 /** Returns size of output for given usage path 
  *
- * @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,
+ * @param parser
+ * @param path
+ * @param flags
+ * @return
+ */
+size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser,
                                   usb_hid_report_path_t *path, int flags)
 {
-        size_t ret = 0; 
-        usb_hid_report_description_t *report_des;
-
-        if(report == NULL) {
+        size_t ret = 0;
+        link_t *item;
+        usb_hid_report_item_t *report_item;
+
+        if(parser == NULL) {
                 return 0;
         }
 
-        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);
+        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;
                 }
-                
-                field_it = field_it->next;
-        }
+
+                item = item->next;
+        } 
 
         return ret;
@@ -1385 +1218 @@
 }
 
-/** 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)
-{
+/** 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;
         link_t *item;   
+        size_t idx=0;
+        int i=0;
         int32_t value=0;
         int offset;
         int length;
         int32_t tmp_value;
-        
-        if(report == NULL) {
+        size_t offset_prefix = 0;
+        
+        if(parser == NULL) {
                 return EINVAL;
         }
 
-        if(report->use_report_ids != 0) {
-                buffer[0] = report_id;          
+        if(parser->use_report_id != 0) {
+                buffer[0] = path->report_id;
+                offset_prefix = 8;
         }
 
         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 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) {
+        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))) {
                                         
-                                // array
-                                value = usb_hid_translate_data_reverse(report_item, report_item->value);
-                                offset = report_item->offset;
+//                              // variable item
+                                value = usb_hid_translate_data_reverse(report_item, data[idx++]);
+                                offset = report_item->offset + (i * report_item->size) + offset_prefix;
                                 length = report_item->size;
                         }
                         else {
-                                // variable item
-                                value  = usb_hid_translate_data_reverse(report_item, report_item->value);
-                                offset = report_item->offset;
-                                length = report_item->size;
+                                //bitmap
+                                value += usb_hid_translate_data_reverse(report_item, data[idx++]);
+                                offset = report_item->offset + offset_prefix;
+                                length = report_item->size * report_item->count;
                         }
 
@@ -1454 +1297 @@
                         }
                         else {
-                                int i = 0;
+                                // 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);
+
                                 uint8_t mask = 0;
-                                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 << (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);
                                 
-                                                mask = (1 << (length - ((offset + length) % 8))) - 1;
-                                                buffer[i] = (buffer[i] & mask) | value;
-                                        }
-                                        else {
-                                                buffer[i] = value & (0xFF << i);
-                                        }
-                                }
+                                mask = ((1 << (length - (8 - (offset % 8)))) - 1);
+                                buffer[(offset+length-1)/8] = (buffer[(offset+length-1)/8] & mask) | value;
                         }
 
-
-                // reset value
-                report_item->value = 0;
-                
+                }
+
                 item = item->next;
         }
-        
+
         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
 
@@ -1492 +1327 @@
 
 /**
- * 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)
+ *
+ * @param item
+ * @param value
+ * @return
+ */
+int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int value)
 {
         int ret=0;
@@ -1506 +1341 @@
         }
 
-        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;
@@ -1537 +1371 @@
         }
 
-        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
- */
+
+        return ret;
+}
+
+
 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
 {
@@ -1557 +1383 @@
 
         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;
 }
@@ -1629 +1400 @@
 }
 
-
-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_t *report)
+    usb_hid_report_parser_t *parser)
 {
-        if (dev == NULL || report == NULL) {
+        if (dev == NULL || parser == 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(report, report_desc, report_size);
+        rc = usb_hid_parse_report_descriptor(parser, report_desc, report_size);
         if (rc != EOK) {
                 usb_log_error("Problem parsing Report descriptor: %s.\n",
@@ -197 +197 @@
         }
         
-        usb_hid_descriptor_print(report);
+        usb_hid_descriptor_print(parser);
         free(report_desc);