Changeset 400735e in mainline for uspace/lib

Timestamp:

2011-05-28T14:30:58Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

3fb5a3e

Parents:

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

Message:

Merge development/ changes

Location:

uspace/lib

Files:

• drv/Makefile (modified) (1 diff)
• drv/generic/dev_iface.c (modified) (2 diffs)
• drv/generic/driver.c (modified) (1 diff)
• drv/generic/remote_usbhid.c (modified) (6 diffs)
• drv/include/remote_pci.h (modified) (1 diff)
• drv/include/remote_usb.h (modified) (1 diff)
• drv/include/remote_usbhc.h (modified) (1 diff)
• drv/include/remote_usbhid.h (modified) (1 diff)
• drv/include/usbhid_iface.h (modified) (4 diffs)
• usbdev/src/hub.c (modified) (1 diff)
• usbhid/Makefile (modified) (1 diff)
• usbhid/include/usb/hid/hid_report_items.h (modified) (1 diff)
• usbhid/include/usb/hid/hiddescriptor.h (modified) (3 diffs)
• usbhid/include/usb/hid/hidparser.h (modified) (1 diff)
• usbhid/include/usb/hid/hidpath.h (modified) (3 diffs)
• usbhid/include/usb/hid/hidreport.h (modified) (2 diffs)
• usbhid/include/usb/hid/hidtypes.h (modified) (3 diffs)
• usbhid/include/usb/hid/iface.h (modified) (1 diff)
• usbhid/include/usb/hid/usages/consumer.h (moved) (moved from uspace/drv/uhci-hcd/utils/slab.h ) (2 diffs)
• usbhid/src/consumer.c (added)
• usbhid/src/hiddescriptor.c (modified) (30 diffs)
• usbhid/src/hidiface.c (modified) (4 diffs)
• usbhid/src/hidparser.c (modified) (30 diffs)
• usbhid/src/hidpath.c (modified) (13 diffs)
• usbhid/src/hidreport.c (modified) (2 diffs)

uspace/lib/drv/Makefile

@@ -40 +40 @@
         generic/remote_usb.c \
         generic/remote_pci.c \
-        generic/remote_usbhc.c
+        generic/remote_usbhc.c \
+        generic/remote_usbhid.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/drv/generic/dev_iface.c

@@ -46 +46 @@
 #include "remote_pci.h"
 
+#include <stdio.h>
+
 static iface_dipatch_table_t remote_ifaces = {
         .ifaces = {
@@ -60 +62 @@
 {
         assert(is_valid_iface_idx(idx));
+        
         return remote_ifaces.ifaces[idx];
 }

uspace/lib/drv/generic/driver.c

@@ -405 +405 @@
                                 /* The interface has not such method */
                                 printf("%s: driver_connection_gen error - "
-                                    "invalid interface method.", driver->name);
+                                    "invalid interface method "
+                                    "(index %" PRIun ").\n",
+                                    driver->name, iface_method_idx);
                                 async_answer_0(callid, ENOTSUP);
                                 break;

uspace/lib/drv/generic/remote_usbhid.c

@@ -36 +36 @@
 #include <errno.h>
 #include <assert.h>
+#include <stdio.h>
 
 #include "usbhid_iface.h"
@@ -42 +43 @@
 static void remote_usbhid_get_event_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhid_get_event(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 // static void remote_usbhid_(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 
@@ -47 +50 @@
 static remote_iface_func_ptr_t remote_usbhid_iface_ops [] = {
         remote_usbhid_get_event_length,
-        remote_usbhid_get_event
+        remote_usbhid_get_event,
+        remote_usbhid_get_report_descriptor_length,
+        remote_usbhid_get_report_descriptor
 };
 
@@ -58 +63 @@
 };
 
-usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+//usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
 
 
@@ -64 +69 @@
     ipc_callid_t callid, ipc_call_t *call)
 {
+        printf("remote_usbhid_get_event_length()\n");
+        
         usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
 
         if (!hid_iface->get_event_length) {
-                async_answer_0(callid, ENOTSUP);
-                return;
-        }
-
-        int len = hid_iface->get_event_length(fun);
-        if (len == 0) {
-                len = EEMPTY;
-        }
-        if (len < 0) {
-                async_answer_0(callid, len);
-        } else {
-                async_answer_1(callid, EOK, len);
-        }
+                printf("Get event length not set!\n");
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        size_t len = hid_iface->get_event_length(fun);
+//      if (len == 0) {
+//              len = EEMPTY;
+//      }
+        async_answer_1(callid, EOK, len);
+        
+//      if (len < 0) {
+//              async_answer_0(callid, len);
+//      } else {
+//              async_answer_1(callid, EOK, len);
+//      }
 }
 
@@ -100 +110 @@
                 return;
         }
-        /* Check that length is even number. Truncate otherwise. */
-        if ((len % 2) == 1) {
-                len--;
-        }
+//      /* Check that length is even number. Truncate otherwise. */
+//      if ((len % 2) == 1) {
+//              len--;
+//      }
         if (len == 0) {
                 async_answer_0(data_callid, EINVAL);
                 async_answer_0(callid, EINVAL);
+                return;
         }
 
         int rc;
 
-        size_t items = len / 2;
-        uint16_t *usage_pages_and_usages = malloc(sizeof(uint16_t) * len);
-        if (usage_pages_and_usages == NULL) {
+        uint8_t *data = malloc(len);
+        if (data == NULL) {
                 async_answer_0(data_callid, ENOMEM);
                 async_answer_0(callid, ENOMEM);
-        }
-
-        size_t act_items;
-        int rc = hid_iface->get_event(fun, usage_pages_and_usages,
-            usage_pages_and_usages + items, items, &act_items, flags);
+                return;
+        }
+
+        size_t act_length;
+        int event_nr;
+        rc = hid_iface->get_event(fun, data, len, &act_length, &event_nr, flags);
         if (rc != EOK) {
-                free(usage_pages_and_usages);
+                free(data);
                 async_answer_0(data_callid, rc);
                 async_answer_0(callid, rc);
-        }
-        if (act_items >= items) {
+                return;
+        }
+        if (act_length >= len) {
                 /* This shall not happen. */
                 // FIXME: how about an assert here?
-                act_items = items;
-        }
-
-        async_data_read_finalize(data_callid, usage_pages_and_usages,
-            act_items * 2 * sizeof(uint16_t));
-
-        free(usage_pages_and_usages);
-
+                act_length = len;
+        }
+
+        async_data_read_finalize(data_callid, data, act_length);
+
+        free(data);
+
+        async_answer_1(callid, EOK, event_nr);
+}
+
+void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
+
+        if (!hid_iface->get_report_descriptor_length) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        size_t len = hid_iface->get_report_descriptor_length(fun);
+        async_answer_1(callid, EOK, (sysarg_t) len);
+}
+
+void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
+
+        if (!hid_iface->get_report_descriptor) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        size_t len;
+        ipc_callid_t data_callid;
+        if (!async_data_read_receive(&data_callid, &len)) {
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+
+        if (len == 0) {
+                async_answer_0(data_callid, EINVAL);
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+
+        uint8_t *descriptor = malloc(len);
+        if (descriptor == NULL) {
+                async_answer_0(data_callid, ENOMEM);
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+
+        size_t act_len = 0;
+        int rc = hid_iface->get_report_descriptor(fun, descriptor, len,
+            &act_len);
+        if (act_len > len) {
+                rc = ELIMIT;
+        }
+        if (rc != EOK) {
+                free(descriptor);
+                async_answer_0(data_callid, rc);
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        async_data_read_finalize(data_callid, descriptor, act_len);
         async_answer_0(callid, EOK);
-}
+
+        free(descriptor);
+}
+
+
 
 /**

uspace/lib/drv/include/remote_pci.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_PCI_H_
 
-remote_iface_t remote_pci_iface;
+extern remote_iface_t remote_pci_iface;
 
 #endif

uspace/lib/drv/include/remote_usb.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_USB_H_
 
-remote_iface_t remote_usb_iface;
+extern remote_iface_t remote_usb_iface;
 
 #endif

uspace/lib/drv/include/remote_usbhc.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_USBHC_H_
 
-remote_iface_t remote_usbhc_iface;
+extern remote_iface_t remote_usbhc_iface;
 
 #endif

uspace/lib/drv/include/remote_usbhid.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_USBHID_H_
 
-remote_iface_t remote_usbhid_iface;
+extern remote_iface_t remote_usbhid_iface;
 
 #endif

uspace/lib/drv/include/usbhid_iface.h

@@ -45 +45 @@
          * Parameters: none
          * Answer:
-         * - EOK (expected always as long as device support USB HID interface)
-         * Parameters of the answer:
-         * - number of items
+         * - Size of one report in bytes.
          */
         IPC_M_USBHID_GET_EVENT_LENGTH,
@@ -63 +61 @@
          * It is okay if the client requests less data. Extra data must
          * be truncated by the driver.
+         *
+         * @todo Change this comment.
          */
-        IPC_M_USBHID_GET_EVENT
+        IPC_M_USBHID_GET_EVENT,
+        
+        /** Get the size of the report descriptor from the HID device.
+         *
+         * Parameters:
+         * - none
+         * Answer:
+         * - EOK - method is implemented (expected always)
+         * Parameters of the answer:
+         * - Size of the report in bytes.
+         */
+        IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH,
+        
+        /** Get the report descriptor from the HID device.
+         *
+         * Parameters:
+         * - none
+         * The call is followed by data read expecting the descriptor itself.
+         * Answer:
+         * - EOK - report descriptor returned.
+         */
+        IPC_M_USBHID_GET_REPORT_DESCRIPTOR
 } usbhid_iface_funcs_t;
 
@@ -75 +96 @@
          *
          * @param[in] fun DDF function answering the request.
-         * @return Number of events or error code.
+         * @return Size of the event in bytes.
          */
         size_t (*get_event_length)(ddf_fun_t *fun);
@@ -87 +108 @@
          * @return Error code.
          */
-        int (*get_event)(ddf_fun_t *fun, int32_t *buffer, size_t size,
-            size_t *act_size, unsigned int flags);
+        int (*get_event)(ddf_fun_t *fun, uint8_t *buffer, size_t size,
+            size_t *act_size, int *event_nr, unsigned int flags);
+        
+        /** Get size of the report descriptor in bytes.
+         *
+         * @param[in] fun DDF function answering the request.
+         * @return Size of the report descriptor in bytes.
+         */
+        size_t (*get_report_descriptor_length)(ddf_fun_t *fun);
+        
+        /** Get the report descriptor from the HID device.
+         *
+         * @param[in] fun DDF function answering the request.
+         * @param[out] desc Buffer with the report descriptor.
+         * @param[in] size Size of the allocated @p desc buffer.
+         * @param[out] act_size Actual size of the report descriptor returned.
+         * @return Error code.
+         */
+        int (*get_report_descriptor)(ddf_fun_t *fun, uint8_t *desc, 
+            size_t size, size_t *act_size);
 } usbhid_iface_t;
 

uspace/lib/usbdev/src/hub.c

@@ -331 +331 @@
                 goto leave_release_free_address;
         }
+        
+        usb_hc_connection_close(&hc_conn);
 
         /*

uspace/lib/usbhid/Makefile

@@ -41 +41 @@
         src/hidpath.c \
         src/hidreport.c \
+        src/consumer.c \
         src/hidreq.c
 

uspace/lib/usbhid/include/usb/hid/hid_report_items.h

@@ -27 +27 @@
  */
 
-/** @addtogroup libusbhid
+/** @addtogroup libusb
  * @{
  */
 /** @file
- * @brief USB HID parser.
- */
-#ifndef LIBUSBHID_HID_REPORT_ITEMS_H_
-#define LIBUSBHID_HID_REPORT_ITEMS_H_
+ * @brief USB HID Report descriptor item tags.
+ */
+#ifndef LIBUSB_HID_REPORT_ITEMS_H_
+#define LIBUSB_HID_REPORT_ITEMS_H_
 
 #include <stdint.h>
 
-/**
+/*---------------------------------------------------------------------------*/
+/*
  * Item prefix
  */
+
+/** Returns size of item data in bytes */
 #define USB_HID_ITEM_SIZE(data)         ((uint8_t)(data & 0x3))
+
+/** Returns item tag */
 #define USB_HID_ITEM_TAG(data)          ((uint8_t)((data & 0xF0) >> 4))
+
+/** Returns class of item tag */
 #define USB_HID_ITEM_TAG_CLASS(data)    ((uint8_t)((data & 0xC) >> 2))
+
+/** Returns if the item is the short item or long item. Long items are not
+ * supported. */
 #define USB_HID_ITEM_IS_LONG(data)      (data == 0xFE)
 
-
-/**
+/*---------------------------------------------------------------------------*/
+/*
  * Extended usage macros
  */
+
+/** Recognizes if the given usage is extended (contains also usage page).  */
 #define USB_HID_IS_EXTENDED_USAGE(usage)        ((usage & 0xFFFF0000) != 0)
+
+/** Cuts usage page of the extended usage. */
 #define USB_HID_EXTENDED_USAGE_PAGE(usage)      ((usage & 0xFFFF0000) >> 16)
+
+/** Cuts usage of the extended usage */
 #define USB_HID_EXTENDED_USAGE(usage)           (usage & 0xFFFF)
 
-/**
+/*---------------------------------------------------------------------------*/
+/*
  * Input/Output/Feature Item flags
  */
-/** Constant (1) / Variable (0) */
+/** 
+ * Indicates whether the item is data (0) or a constant (1) value. Data
+ * indicates the item is defining report fields that contain modifiable device
+ * data. Constant indicates the item is a static read-only field in a report
+ * and cannot be modified (written) by the host.
+ */
 #define USB_HID_ITEM_FLAG_CONSTANT(flags)       ((flags & 0x1) == 0x1)
-/** Variable (1) / Array (0) */
+
+/**
+ * Indicates whether the item creates variable (1) or array (0) data fields in
+ * reports. 
+ */
 #define USB_HID_ITEM_FLAG_VARIABLE(flags)       ((flags & 0x2) == 0x2)
-/** Absolute / Relative*/
+
+/**
+ * Indicates whether the data is absolute (0) (based on a fixed origin) or
+ * relative (1) (indicating the change in value from the last report). Mouse
+ * devices usually provide relative data, while tablets usually provide
+ * absolute data.
+ */
 #define USB_HID_ITEM_FLAG_RELATIVE(flags)       ((flags & 0x4) == 0x4)
-/** Wrap / No Wrap */
+
+/** Indicates whether the data “rolls over” when reaching either the extreme
+ * high or low value. For example, a dial that can spin freely 360 degrees
+ * might output values from 0 to 10. If Wrap is indicated, the next value
+ * reported after passing the 10 position in the increasing direction would be
+ * 0.
+ */
 #define USB_HID_ITEM_FLAG_WRAP(flags)           ((flags & 0x8) == 0x8)
+
+/**
+ * Indicates whether the raw data from the device has been processed in some
+ * way, and no longer represents a linear relationship between what is
+ * measured and the data that is reported.
+ */
 #define USB_HID_ITEM_FLAG_LINEAR(flags)         ((flags & 0x10) == 0x10)
+
+/**
+ * Indicates whether the control has a preferred state to which it will return
+ * when the user is not physically interacting with the control. Push buttons
+ * (as opposed to toggle buttons) and self- centering joysticks are examples.
+ */
 #define USB_HID_ITEM_FLAG_PREFERRED(flags)      ((flags & 0x20) == 0x20)
+
+/**
+ * Indicates whether the control has a state in which it is not sending
+ * meaningful data. One possible use of the null state is for controls that
+ * require the user to physically interact with the control in order for it to
+ * report useful data.
+ */
 #define USB_HID_ITEM_FLAG_POSITION(flags)       ((flags & 0x40) == 0x40)
+
+/**
+ * Indicates whether the Feature or Output control's value should be changed
+ * by the host or not.  Volatile output can change with or without host
+ * interaction. To avoid synchronization problems, volatile controls should be
+ * relative whenever possible.
+ */
 #define USB_HID_ITEM_FLAG_VOLATILE(flags)       ((flags & 0x80) == 0x80)
+
+/**
+ * Indicates that the control emits a fixed-size stream of bytes. The contents
+ * of the data field are determined by the application. The contents of the
+ * buffer are not interpreted as a single numeric quantity. Report data
+ * defined by a Buffered Bytes item must be aligned on an 8-bit boundary.
+ */
 #define USB_HID_ITEM_FLAG_BUFFERED(flags)       ((flags & 0x100) == 0x100)
 
+/*---------------------------------------------------------------------------*/
+
 /* MAIN ITEMS */
-#define USB_HID_TAG_CLASS_MAIN                          0x0
-#define USB_HID_REPORT_TAG_INPUT                        0x8
-#define USB_HID_REPORT_TAG_OUTPUT                       0x9
-#define USB_HID_REPORT_TAG_FEATURE                      0xB
+
+/**
+ * Main items are used to either define or group certain types of data fields
+ * within a Report descriptor.
+ */
+#define USB_HID_TAG_CLASS_MAIN                  0x0
+
+/**
+ * An Input item describes information about the data provided by one or more
+ * physical controls. An application can use this information to interpret the
+ * data provided by the device. All data fields defined in a single item share
+ * an identical data format.
+ */
+#define USB_HID_REPORT_TAG_INPUT                0x8
+
+/**
+ * The Output item is used to define an output data field in a report. This
+ * item is similar to an Input item except it describes data sent to the
+ * device—for example, LED states.
+ */
+#define USB_HID_REPORT_TAG_OUTPUT               0x9
+
+/**
+ * Feature items describe device configuration information that can be sent to
+ * the device.
+ */
+#define USB_HID_REPORT_TAG_FEATURE              0xB
+
+/**
+ * A Collection item identifies a relationship between two or more data
+ * (Input, Output, or Feature.) 
+ */
 #define USB_HID_REPORT_TAG_COLLECTION           0xA
+
+/**
+ * While the Collection item opens a collection of data, the End Collection
+ * item closes a collection.
+ */
 #define USB_HID_REPORT_TAG_END_COLLECTION       0xC
 
+/*---------------------------------------------------------------------------*/
+
 /* GLOBAL ITEMS */
-#define USB_HID_TAG_CLASS_GLOBAL                        0x1
+
+/**
+ * Global items describe rather than define data from a control.
+ */
+#define USB_HID_TAG_CLASS_GLOBAL                0x1
+
+/**
+ * Unsigned integer specifying the current Usage Page. Since a usage are 32
+ * bit values, Usage Page items can be used to conserve space in a report
+ * descriptor by setting the high order 16 bits of a subsequent usages. Any
+ * usage that follows which is defines 16 bits or less is interpreted as a
+ * Usage ID and concatenated with the Usage Page to form a 32 bit Usage.
+ */
 #define USB_HID_REPORT_TAG_USAGE_PAGE           0x0
+
+/** 
+ * Extent value in logical units. This is the minimum value that a variable
+ * or array item will report. For example, a mouse reporting x position values
+ * from 0 to 128 would have a Logical Minimum of 0 and a Logical Maximum of
+ * 128.
+ */
 #define USB_HID_REPORT_TAG_LOGICAL_MINIMUM      0x1
+
+/** 
+ * Extent value in logical units. This is the maximum value that a variable
+ * or array item will report.
+ */
 #define USB_HID_REPORT_TAG_LOGICAL_MAXIMUM      0x2
-#define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM 0x3
-#define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM 0x4
+
+/** 
+ * Minimum value for the physical extent of a variable item. This represents
+ * the Logical Minimum with units applied to it.
+ */
+#define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM     0x3
+
+/** 
+ * Maximum value for the physical extent of a variable item.
+ */
+#define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM     0x4
+
+/** 
+ * Value of the unit exponent in base 10. See the table later in this section
+ * for more information.
+ */
 #define USB_HID_REPORT_TAG_UNIT_EXPONENT        0x5
-#define USB_HID_REPORT_TAG_UNIT                         0x6
+
+/** 
+ * Unit values.
+ */
+#define USB_HID_REPORT_TAG_UNIT                 0x6
+
+/** 
+ * Unsigned integer specifying the size of the report fields in bits. This
+ * allows the parser to build an item map for the report handler to use.
+ */
 #define USB_HID_REPORT_TAG_REPORT_SIZE          0x7
+
+/** 
+ * Unsigned value that specifies the Report ID. If a Report ID tag is used
+ * anywhere in Report descriptor, all data reports for the device are preceded
+ * by a single byte ID field. All items succeeding the first Report ID tag but
+ * preceding a second Report ID tag are included in a report prefixed by a
+ * 1-byte ID. All items succeeding the second but preceding a third Report ID
+ * tag are included in a second report prefixed by a second ID, and so on.
+ */
 #define USB_HID_REPORT_TAG_REPORT_ID            0x8
+
+/** 
+ * Unsigned integer specifying the number of data fields for the item;
+ * determines how many fields are included in the report for this particular
+ * item (and consequently how many bits are added to the report).
+ */
 #define USB_HID_REPORT_TAG_REPORT_COUNT         0x9
-#define USB_HID_REPORT_TAG_PUSH                         0xA
-#define USB_HID_REPORT_TAG_POP                          0xB
-
+
+/** 
+ * Places a copy of the global item state table on the stack.
+ */
+#define USB_HID_REPORT_TAG_PUSH                 0xA
+
+/** 
+ * Replaces the item state table with the top structure from the stack.
+ */
+#define USB_HID_REPORT_TAG_POP                  0xB
+
+/*---------------------------------------------------------------------------*/
 
 /* LOCAL ITEMS */
-#define USB_HID_TAG_CLASS_LOCAL                                 0x2
-#define USB_HID_REPORT_TAG_USAGE                                0x0
-#define USB_HID_REPORT_TAG_USAGE_MINIMUM                0x1
-#define USB_HID_REPORT_TAG_USAGE_MAXIMUM                0x2
-#define USB_HID_REPORT_TAG_DESIGNATOR_INDEX             0x3
+
+/**
+ * Local item tags define characteristics of controls. These items do not
+ * carry over to the next Main item. If a Main item defines more than one
+ * control, it may be preceded by several similar Local item tags. For
+ * example, an Input item may have several Usage tags associated with it, one
+ * for each control.
+ */
+#define USB_HID_TAG_CLASS_LOCAL                 0x2
+
+/**
+ * Usage index for an item usage; represents a suggested usage for the item or
+ * collection. In the case where an item represents multiple controls, a Usage
+ * tag may suggest a usage for every variable or element in an array.
+ */
+#define USB_HID_REPORT_TAG_USAGE                0x0
+
+/**
+ * Defines the starting usage associated with an array or bitmap.
+ */
+#define USB_HID_REPORT_TAG_USAGE_MINIMUM        0x1
+
+/**
+ * Defines the ending usage associated with an array or bitmap.
+ */
+#define USB_HID_REPORT_TAG_USAGE_MAXIMUM        0x2
+
+/**
+ * Determines the body part used for a control. Index points to a designator
+ * in the Physical descriptor.
+ */
+#define USB_HID_REPORT_TAG_DESIGNATOR_INDEX     0x3
+
+/**
+ * Defines the index of the starting designator associated with an array or
+ * bitmap.
+ */
 #define USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM   0x4
+
+/**
+ * Defines the index of the ending designator associated with an array or
+ * bitmap.
+ */
 #define USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM   0x5
-#define USB_HID_REPORT_TAG_STRING_INDEX                 0x7
-#define USB_HID_REPORT_TAG_STRING_MINIMUM               0x8
-#define USB_HID_REPORT_TAG_STRING_MAXIMUM               0x9
-#define USB_HID_REPORT_TAG_DELIMITER                    0xA
+
+/**
+ * String index for a String descriptor; allows a string to be associated with
+ * a particular item or control.
+ */
+#define USB_HID_REPORT_TAG_STRING_INDEX         0x7
+
+/**
+ * Specifies the first string index when assigning a group of sequential
+ * strings to controls in an array or bitmap.
+ */
+#define USB_HID_REPORT_TAG_STRING_MINIMUM       0x8
+
+/**
+ * Specifies the last string index when assigning a group of sequential
+ * strings to controls in an array or bitmap.
+ */
+#define USB_HID_REPORT_TAG_STRING_MAXIMUM       0x9
+
+/**
+ * Defines the beginning or end of a set of local items (1 = open set, 0 =
+ * close set).
+ *
+ * Usages other than the first (most preferred) usage defined are not
+ * accessible by system software.
+ */
+#define USB_HID_REPORT_TAG_DELIMITER            0xA
+
+/*---------------------------------------------------------------------------*/
 
 #endif

uspace/lib/usbhid/include/usb/hid/hiddescriptor.h

@@ -27 +27 @@
  */
 
-/** @addtogroup libusbhid
+/** @addtogroup libusb
  * @{
  */
@@ -33 +33 @@
  * USB HID report descriptor and report data parser
  */
-#ifndef LIBUSBHID_HIDDESCRIPTOR_H_
-#define LIBUSBHID_HIDDESCRIPTOR_H_
+#ifndef LIBUSB_HIDDESCRIPTOR_H_
+#define LIBUSB_HIDDESCRIPTOR_H_
 
 #include <stdint.h>
@@ -42 +42 @@
 #include <usb/hid/hidtypes.h>
 
+int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
+                const uint8_t *data, size_t size);
 
-/*
- * Descriptor parser functions
- */
-
-/** */
-int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
-                                    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);
 
+int usb_hid_report_init(usb_hid_report_t *report);
 
-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);
+int usb_hid_report_append_fields(usb_hid_report_t *report,
+                usb_hid_report_item_t *report_item);
 
-usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type);
-int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
-int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
-int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
-int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
+usb_hid_report_description_t * usb_hid_report_find_description(
+                const usb_hid_report_t *report, uint8_t report_id,
+                usb_hid_report_type_t type);
+
+int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
+                size_t item_size, usb_hid_report_item_t *report_item,
+                usb_hid_report_path_t *usage_path);
+
+int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, 
+                size_t item_size, usb_hid_report_item_t *report_item,
+                usb_hid_report_path_t *usage_path);
+
+int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, 
+                size_t item_size, usb_hid_report_item_t *report_item,
+                usb_hid_report_path_t *usage_path);
+
+int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, 
+                size_t item_size, usb_hid_report_item_t *report_item,
+                usb_hid_report_path_t *usage_path);
 
 void usb_hid_descriptor_print_list(link_t *head);
+
 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
+
 void usb_hid_free_report_list(link_t *head);
-usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
+
+usb_hid_report_item_t *usb_hid_report_item_clone(
+                const usb_hid_report_item_t *item);
+
 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
 
-usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path);
+usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t*report,
+                usb_hid_report_path_t *cmp_path);
+
+
 #endif
 /**

uspace/lib/usbhid/include/usb/hid/hidparser.h

@@ -47 +47 @@
  * Input report parser functions
  */
-/** */
-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_t *report, const uint8_t *data,
+                size_t size, uint8_t *report_id);
 
 /*
  * Output report parser functions
  */
-/** Allocates output report buffer*/
 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, 
-                               uint8_t report_id);
+                uint8_t report_id);
 
-/** Frees output report buffer*/
 void usb_hid_report_output_free(uint8_t *output);
 
-/** Returns size of report in items */
-size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id, 
-                           usb_hid_report_type_t type);
+size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
+                usb_hid_report_type_t type);
 
-/** 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);
+size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
+                usb_hid_report_type_t type);
 
-/** */
-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);
+int usb_hid_report_output_translate(usb_hid_report_t *report, 
+                uint8_t report_id, uint8_t *buffer, size_t size);
+
+
+/*
+ * Report descriptor structure observing functions
+ */
+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_get_next_report_id(usb_hid_report_t *report, 
+                uint8_t report_id, usb_hid_report_type_t type);
 
 #endif

uspace/lib/usbhid/include/usb/hid/hidpath.h

@@ -27 +27 @@
  */
 
-/** @addtogroup libusbhid
+/** @addtogroup libusb
  * @{
  */
@@ -33 +33 @@
  * USB HID report descriptor and report data parser
  */
-#ifndef LIBUSBHID_HIDPATH_H_
-#define LIBUSBHID_HIDPATH_H_
+#ifndef LIBUSB_HIDPATH_H_
+#define LIBUSB_HIDPATH_H_
 
 #include <usb/hid/hidparser.h>
@@ -40 +40 @@
 #include <adt/list.h>
 
+
+/*---------------------------------------------------------------------------*/
+/*
+ * Flags of usage paths comparison modes.
+ *
+ */
+/** Wanted usage path must be exactly the same as the searched one.  This
+ * option cannot be combined with the others. 
+ */
+#define USB_HID_PATH_COMPARE_STRICT             0
+
 /**
- * Description of path of usage pages and usages in report descriptor
+ * Wanted usage path must be the suffix in the searched one.
  */
-/** Wanted usage path must be exactly the same as the searched one */
-#define USB_HID_PATH_COMPARE_STRICT             0
-/** Wanted usage path must be the suffix in the searched one */
 #define USB_HID_PATH_COMPARE_END                1
-/** */
+
+/** 
+ * Only usage page are compared along the usage path.  This option can be
+ * combined with others. 
+ */
 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    2
-/** Searched usage page must be prefix of the other one */
+
+/** 
+ * Searched usage page must be prefix of the other one.
+ */
 #define USB_HID_PATH_COMPARE_BEGIN              4
-/** Searched couple of usage page and usage can be anywhere in usage path */
+
+/** 
+ * Searched couple of usage page and usage can be anywhere in usage path.
+ * This option is deprecated.
+ */
 #define USB_HID_PATH_COMPARE_ANYWHERE           8
 
-
-/** Collection usage path structure */
+/*----------------------------------------------------------------------------*/
+/** 
+ * Item of usage path structure. Last item of linked list describes one item
+ * in report, the others describe superior Collection tags. Usage and Usage
+ * page of report item can be changed due to data in report. 
+ */
 typedef struct {
-        /** */
+        /** Usage page of report item. Zero when usage page can be changed. */
         uint32_t usage_page;
-        /** */  
+        /** Usage of report item. Zero when usage can be changed. */    
         uint32_t usage;
 
+        /** Attribute of Collection tag in report descriptor*/
         uint8_t flags;
-        /** */
+
+        /** Linked list structure*/
         link_t link;
 } usb_hid_report_usage_path_t;
 
-/** */
+
+/*---------------------------------------------------------------------------*/
+/** 
+ * USB HID usage path structure.
+ * */
 typedef struct {
-        /** */  
+        /** Length of usage path */     
         int depth;      
+
+        /** Report id. Zero is reserved and means that report id is not used.
+         * */
         uint8_t report_id;
         
-        /** */  
+        /** Linked list structure. */   
         link_t link; /* list */
 
-        link_t head; /* head of list of usage paths */
+        /** Head of the list of usage path items. */
+        link_t head;
 
 } usb_hid_report_path_t;
 
-/** */
+/*---------------------------------------------------------------------------*/
 usb_hid_report_path_t *usb_hid_report_path(void);
 
-/** */
 void usb_hid_report_path_free(usb_hid_report_path_t *path);
 
-/** */
-int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path, 
-                                      uint8_t report_id);
+int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path,
+                uint8_t report_id);
 
-/** */
 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 
-                                    int32_t usage_page, int32_t usage);
+                int32_t usage_page, int32_t usage);
 
-/** */
 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path);
 
-/** */
 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path);
 
-/** */
 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, 
-                                  int32_t tag, int32_t data);
+                int32_t tag, int32_t data);
 
-/** */
-int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 
-                                      usb_hid_report_path_t *path, int flags);
+int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path,
+                usb_hid_report_path_t *path, int flags);
 
-/** */
-usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path);
+usb_hid_report_path_t *usb_hid_report_path_clone(
+                usb_hid_report_path_t *usage_path);
 
 void usb_hid_print_usage_path(usb_hid_report_path_t *path);

uspace/lib/usbhid/include/usb/hid/hidreport.h

@@ -44 +44 @@
  * report parser.
  *
- * \param dev USB device representing a HID device.
- * \param parser HID Report parser.
+ * \param[in] dev USB device representing a HID device.
+ * \param[in/out] parser HID Report parser.
+ * \param[out] report_desc Place to save report descriptor into.
+ * \param[out] report_size
  *
  * \retval EOK if successful.
@@ -57 +59 @@
  */
 int usb_hid_process_report_descriptor(usb_device_t *dev, 
-    usb_hid_report_t *report);
+    usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size);
 
 #endif /* LIBUSB_HIDREPORT_H_ */

uspace/lib/usbhid/include/usb/hid/hidtypes.h

@@ -27 +27 @@
  */
 
-/** @addtogroup libusbhid
+/** @addtogroup libusb
  * @{
  */
 /** @file
- * USB HID report descriptor and report data parser
- */
-#ifndef LIBUSBHID_HIDTYPES_H_
-#define LIBUSBHID_HIDTYPES_H_
+ * Basic data structures for USB HID Report descriptor and report parser.
+ */
+#ifndef LIBUSB_HIDTYPES_H_
+#define LIBUSB_HIDTYPES_H_
 
 #include <stdint.h>
 #include <adt/list.h>
 
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Maximum amount of specified usages for one report item
+ */
 #define USB_HID_MAX_USAGES      0xffff
 
-#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))
-
-
+/**
+ * Converts integer from unsigned two's complement format format to signed
+ * one.
+ *
+ * @param x Number to convert
+ * @param size Length of the unsigned number in bites
+ * @return signed int
+ */
+#define USB_HID_UINT32_TO_INT32(x, size)        \
+        ((((x) & (1 << ((size) - 1))) != 0) ?   \
+         -(~((x) - 1) & ((1 << size) - 1)) : (x))
+
+/**
+ * Convert integer from signed format to unsigned. If number is negative the
+ * two's complement format is used.
+ *
+ * @param x Number to convert
+ * @param size Length of result number in bites
+ * @return unsigned int
+ */
+#define USB_HID_INT32_TO_UINT32(x, size)        \
+        (((x) < 0 ) ? ((1 << (size)) + (x)) : (x))
+
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Enum of report types
+ */
 typedef enum {
+        /** Input report. Data are sent from device to system */
         USB_HID_REPORT_TYPE_INPUT = 1,
+
+        /** Output report. Data are sent from system to device */
         USB_HID_REPORT_TYPE_OUTPUT = 2,
+
+        /** Feature report. Describes device configuration information that
+         * can be sent to the device */
         USB_HID_REPORT_TYPE_FEATURE = 3
 } usb_hid_report_type_t;
 
-
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Description of all reports described in one report descriptor.
+ */
 typedef struct {
-        /** */
+        /** Count of available reports. */
         int report_count;
-        link_t reports;         /** list of usb_hid_report_description_t */
-
+
+        /** Head of linked list of description of reports. */
+        link_t reports;
+
+        /** Head of linked list of all used usage/collection paths. */
         link_t collection_paths;
+
+        /** Length of list of usage paths. */
         int collection_paths_count;
 
+        /** Flag whether report ids are used. */
         int use_report_ids;
+
+        /** Report id of last parsed report. */
         uint8_t last_report_id;
         
 } usb_hid_report_t;
-
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Description of one concrete report
+ */
 typedef struct {
+        /** Report id. Zero when no report id is used. */
         uint8_t report_id;
+
+        /** Type of report */
         usb_hid_report_type_t type;
 
+        /** Bit length of the report */
         size_t bit_length;
+
+        /** Number of items in report */
         size_t item_length;
         
-        link_t report_items;    /** list of report items (fields) */
-
+        /** Linked list of report items in report */
+        link_t report_items;
+
+        /** Linked list of descriptions. */
         link_t link;
 } usb_hid_report_description_t;
-
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Description of one field/item in report 
+ */
 typedef struct {
-
+        /** Bit offset of the field */
         int offset;
+
+        /** Bit size of the field */
         size_t size;
 
+        /** Usage page. Zero when usage page can be changed. */
         uint16_t usage_page;
+
+        /** Usage. Zero when usage can be changed. */
         uint16_t usage;
 
+        /** Item's attributes */
         uint8_t item_flags;
+
+        /** Usage/Collection path of the field. */
         usb_hid_report_path_t *collection_path;
 
+        /** 
+         * The lowest valid logical value (value with the device operates)
+         */
         int32_t logical_minimum;
+
+        /**
+         * The greatest valid logical value
+         */
         int32_t logical_maximum;
+
+        /**
+         * The lowest valid physical value (value with the system operates)
+         */
         int32_t physical_minimum;
+
+        /** The greatest valid physical value */
         int32_t physical_maximum;
+
+        /** The lowest valid usage index */
         int32_t usage_minimum;
+
+        /** The greatest valid usage index */
         int32_t usage_maximum;
+        
+        /** Unit of the value */
         uint32_t unit;
+
+        /** Unit exponent */
         uint32_t unit_exponent;
 
+        /** Array of possible usages */
         uint32_t *usages;
+
+        /** Size of the array of usages */
         size_t usages_count;
 
+        /** Parsed value */
         int32_t value;
 
+        /** List to another report items */
         link_t link;
 } usb_hid_report_field_t;
 
-
-
-/**
- * state table
+/*---------------------------------------------------------------------------*/
+
+/**
+ * State table for report descriptor parsing
  */
 typedef struct {
@@ -114 +211 @@
         int32_t id;
         
-        /** */
+        /** Extended usage page */
         uint16_t extended_usage_page;
+
+        /** Array of usages specified for this item */
         uint32_t usages[USB_HID_MAX_USAGES];
+        
+        /** Length of usages array */
         int usages_count;
 
-        /** */
+        /** Usage page*/
         uint32_t usage_page;
 
-        /** */  
+        /** Minimum valid usage index */        
         int32_t usage_minimum;
-        /** */  
+        
+        /** Maximum valid usage index */        
         int32_t usage_maximum;
-        /** */  
+        
+        /** Minimum valid logical value */      
         int32_t logical_minimum;
-        /** */  
+        
+        /** Maximum valid logical value */      
         int32_t logical_maximum;
-        /** */  
+
+        /** Length of the items in bits*/       
         int32_t size;
-        /** */  
+
+        /** COunt of items*/    
         int32_t count;
-        /** */  
+
+        /**  Bit offset of the item in report */        
         size_t offset;
-        /** */  
+
+        /** Unit exponent */    
         int32_t unit_exponent;
-        /** */  
+        /** Unit of the value */        
         int32_t unit;
 
-        /** */
+        /** String index */
         uint32_t string_index;
-        /** */  
+
+        /** Minimum valid string index */       
         uint32_t string_minimum;
-        /** */  
+
+        /** Maximum valid string index */       
         uint32_t string_maximum;
-        /** */  
+
+        /** The designator index */     
         uint32_t designator_index;
-        /** */  
+
+        /** Minimum valid designator value*/    
         uint32_t designator_minimum;
-        /** */  
+
+        /** Maximum valid designator value*/    
         uint32_t designator_maximum;
-        /** */  
+
+        /** Minimal valid physical value*/      
         int32_t physical_minimum;
-        /** */  
+
+        /** Maximal valid physical value */     
         int32_t physical_maximum;
 
-        /** */  
+        /** Items attributes*/  
         uint8_t item_flags;
 
+        /** Report type */
         usb_hid_report_type_t type;
 
         /** current collection path*/   
         usb_hid_report_path_t *usage_path;
-        /** */  
+
+        /** Unused*/    
         link_t link;
 
         int in_delimiter;
 } usb_hid_report_item_t;
-
-/** HID parser callbacks for IN items. */
-typedef struct {
-        /** Callback for keyboard.
-         *
-         * @param key_codes Array of pressed key (including modifiers).
-         * @param count Length of @p key_codes.
-         * @param arg Custom argument.
-         */
-        void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t report_id, void *arg);
-} usb_hid_report_in_callbacks_t;
-
-
+/*---------------------------------------------------------------------------*/
+/**
+ * Enum of the keyboard modifiers 
+ */
 typedef enum {
         USB_HID_MOD_LCTRL = 0x01,
@@ -206 +314 @@
         USB_HID_MOD_RGUI
 };
+/*---------------------------------------------------------------------------*/
+
 
 #endif

uspace/lib/usbhid/include/usb/hid/iface.h

@@ -38 +38 @@
 #include <sys/types.h>
 
-int usbhid_dev_get_event_length(int);
-int usbhid_dev_get_event(int, uint16_t *, uint16_t *, size_t, size_t *,
+int usbhid_dev_get_event_length(int, size_t *);
+int usbhid_dev_get_event(int, uint8_t *, size_t, size_t *, int *,
     unsigned int);
+int usbhid_dev_get_report_descriptor_length(int, size_t *);
+int usbhid_dev_get_report_descriptor(int, uint8_t *, size_t, size_t *);
 
 #endif

uspace/lib/usbhid/include/usb/hid/usages/consumer.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2011 Lubos Slovak
  * All rights reserved.
  *
@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup drvusbuhcihc
+
+/** @addtogroup libusbhid
  * @{
  */
 /** @file
- * @brief UHCI driver
+ * USB multimedia key usage to string mapping.
  */
-#ifndef DRV_UHCI_UTILS_SLAB_H
-#define DRV_UHCI_UTILS_SLAB_H
 
-#include <bool.h>
+#ifndef LIBUSBHID_CONSUMER_H_
+#define LIBUSBHID_CONSUMER_H_
 
-#define SLAB_ELEMENT_SIZE 1024
+const char *usbhid_multimedia_usage_to_str(int usage);
 
-void * slab_malloc_g(void);
+#endif /* LIBUSBHID_CONSUMER_H_ */
 
-void slab_free_g(void *addr);
-
-bool slab_in_range_g(void *addr);
-
-#endif
 /**
  * @}

uspace/lib/usbhid/src/hiddescriptor.c

@@ -41 +41 @@
 #include <assert.h>
 
-
+/*---------------------------------------------------------------------------*/
+/*
+ * Constants defining current parsing mode for correct parsing of the set of
+ * local tags (usage) enclosed in delimter tags.
+ */
+/**
+ * Second delimiter tag was read. The set of local items (usage) ended.
+ */
 #define OUTSIDE_DELIMITER_SET   0
+
+/**
+ * First delimiter tag was read. The set of local items (usage) started.
+ */
 #define START_DELIMITER_SET     1
+
+/**
+ * Parser is in the set of local items.
+ */
 #define INSIDE_DELIMITER_SET    2
+
+/*---------------------------------------------------------------------------*/
         
 /** The new report item flag. Used to determine when the item is completly
@@ -61 +78 @@
 #define USB_HID_UNKNOWN_TAG             -99
 
-usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path)
-{
-        /* find or append current collection path to the list */
-        //link_t *path_it = report->collection_paths.next;
+/*---------------------------------------------------------------------------*/
+/**
+ * Checks if given collection path is already present in report structure and
+ * inserts it if not.
+ *
+ * @param report Report structure 
+ * @param cmp_path The collection path 
+ * @return Pointer to the result collection path in report structure.
+ * @retval NULL If some error occurs
+ */
+usb_hid_report_path_t *usb_hid_report_path_try_insert(
+                usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) {
+        
         link_t *path_it = report->collection_paths.prev->next;
         usb_hid_report_path_t *path = NULL;
         
+        if((report == NULL) || (cmp_path == NULL)) {
+                return 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, cmp_path, USB_HID_PATH_COMPARE_STRICT) == EOK){
+                path = list_get_instance(path_it, usb_hid_report_path_t,
+                                link);
+                
+                if(usb_hid_report_compare_usage_path(path, cmp_path,
+                                        USB_HID_PATH_COMPARE_STRICT) == EOK){
                         break;
                 }                       
@@ -78 +109 @@
         }
         if(path_it == &report->collection_paths) {
-                path = usb_hid_report_path_clone(cmp_path);                     
+                path = usb_hid_report_path_clone(cmp_path);
+                if(path == NULL) {
+                        return NULL;
+                }
                 list_append(&path->link, &report->collection_paths);                                    
                 report->collection_paths_count++;
@@ -85 +119 @@
         }
         else {
-                return list_get_instance(path_it, usb_hid_report_path_t, link);
-        }
-}
-
+                return list_get_instance(path_it, usb_hid_report_path_t,
+                                link); 
+        }
+}
+
+/*---------------------------------------------------------------------------*/
 /**
  * Initialize the report descriptor parser structure
@@ -94 +130 @@
  * @param parser Report descriptor parser structure
  * @return Error code
+ * @retval EINVAL If no report structure was given
+ * @retval EOK If report structure was successfully initialized
  */
 int usb_hid_report_init(usb_hid_report_t *report)
@@ -109 +147 @@
 }
 
-
-/*
- *
- *
- */
-int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item)
-{
+/*---------------------------------------------------------------------------*/
+
+/**
+ *
+ *
+ * @param report Report structure in which the new report items should be
+ *               stored
+ * @param report_item Current report descriptor's parsing state table 
+ * @return Error code
+ * @retval EOK If all fields were successfully append to report
+ * @retval EINVAL If invalid parameters (NULL) was given
+ * @retval ENOMEM If there is no memmory to store new report description
+ *
+ */
+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;
@@ -121 +169 @@
         uint32_t *usages;
         int usages_used=0;
+
+        if((report == NULL) || (report_item == NULL)) {
+                return EINVAL;
+        }
+
         if(report_item->usages_count > 0){
                 usages = malloc(sizeof(int32_t) * report_item->usages_count);
-                memcpy(usages, report_item->usages, sizeof(int32_t) * report_item->usages_count);
+                memcpy(usages, report_item->usages, sizeof(int32_t) *
+                                report_item->usages_count); 
         }
         else {
@@ -144 +198 @@
                 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){
                         /* 
-                                Store usage array. The Correct Usage Page and Usage is depending 
-                                on data in report and will be filled later
+                        Store usage array. The Correct Usage Page and Usage is
+                        depending on data in report and will be filled later
                         */
                         field->usage = 0;
@@ -162 +216 @@
                         }
                         else {
-                                usage = report_item->usages[report_item->usages_count - 1];
+                                usage = report_item->usages[
+                                        report_item->usages_count- 1]; 
                         }
 
                         if(USB_HID_IS_EXTENDED_USAGE(usage)){
                                 field->usage = USB_HID_EXTENDED_USAGE(usage);
-                                field->usage_page = USB_HID_EXTENDED_USAGE_PAGE(usage);
+                                field->usage_page = 
+                                        USB_HID_EXTENDED_USAGE_PAGE(usage);
                         }
                         else {
@@ -176 +232 @@
                 }
                 
-                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL, field->usage_page);
-                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL, field->usage);
-
-                field->collection_path = usb_hid_report_path_try_insert(report, path);
+                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL,
+                                field->usage_page);
+                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL,
+                                field->usage);
+
+                field->collection_path =
+                        usb_hid_report_path_try_insert(report, path);
 
                 field->size = report_item->size;
                 
-                size_t offset_byte = (report_item->offset + (i * report_item->size)) / 8;
-                size_t offset_bit = 8 - ((report_item->offset + (i * report_item->size)) % 8) - report_item->size;
+                size_t offset_byte = (report_item->offset + (i *
+                        report_item->size)) / 8; 
+
+                size_t offset_bit = 8 - ((report_item->offset + (i *
+                        report_item->size)) % 8) - report_item->size;
 
                 field->offset = 8 * offset_byte + offset_bit;
@@ -195 +257 @@
                 /* 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);
+                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 = malloc(
+                                sizeof(usb_hid_report_description_t));
+                        if(report_des == NULL) {
+                                return ENOMEM;
+                        }
+
+                        memset(report_des, 0,
+                                sizeof(usb_hid_report_description_t));
 
                         report_des->type = report_item->type;
                         report_des->report_id = report_item->id;
+                        if(report_des->report_id != 0) {
+                                /* set up the bit length by report_id field */
+                                report_des->bit_length = 8;
+                        }
+
                         list_initialize (&report_des->link);
                         list_initialize (&report_des->report_items);
@@ -225 +300 @@
         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)
-{
+/*---------------------------------------------------------------------------*/
+/**
+ * Finds description of report with given report_id and of given type in
+ * opaque report structure.
+ *
+ * @param report Opaque structure containing the parsed report descriptor
+ * @param report_id ReportId of report we are searching
+ * @param type Type of report we are searching
+ * @return Pointer to the particular report description
+ * @retval NULL If no description is founded
+ */
+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)){
+                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;
                 }
@@ -243 +332 @@
         return NULL;
 }
+/*---------------------------------------------------------------------------*/
 
 /** Parse HID report descriptor.
@@ -249 +339 @@
  * @param data Data describing the report.
  * @return Error code.
+ * @retval ENOMEM If no more memmory is available
+ * @retval EINVAL If invalid data are founded
+ * @retval EOK If report descriptor is successfully parsed
  */
 int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
@@ -299 +392 @@
                         
                         ret = usb_hid_report_parse_tag(tag,class,data+i+1,
-                                                       item_size,report_item, usage_path);
+                                item_size,report_item, usage_path);
+
                         switch(ret){
-                                case USB_HID_NEW_REPORT_ITEM:
-                                        // store report item to report and create the new one
-                                        // store current collection path
-                                        report_item->usage_path = usage_path;
+                        case USB_HID_NEW_REPORT_ITEM:
+                                /* store report item to report and create the
+                                 * new one store current collection path
+                                 */
+                                report_item->usage_path = usage_path;
                                         
-                                        usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id);    
-                                        if(report_item->id != 0){
-                                                report->use_report_ids = 1;
-                                        }
+                                usb_hid_report_path_set_report_id(
+                                     report_item->usage_path, report_item->id);
+                                
+                                if(report_item->id != 0){
+                                        report->use_report_ids = 1;
+                                }
                                         
-                                        switch(tag) {
-                                                case USB_HID_REPORT_TAG_INPUT:
-                                                        report_item->type = USB_HID_REPORT_TYPE_INPUT;
-                                                        report_item->offset = offset_input;
-                                                        offset_input += report_item->count * report_item->size;
-                                                        break;
-                                                case USB_HID_REPORT_TAG_OUTPUT:
-                                                        report_item->type = USB_HID_REPORT_TYPE_OUTPUT;
-                                                        report_item->offset = offset_output;
-                                                        offset_output += report_item->count * report_item->size;
-
-                                                        break;
-                                                case USB_HID_REPORT_TAG_FEATURE:
-                                                        report_item->type = USB_HID_REPORT_TYPE_FEATURE;
-                                                        report_item->offset = offset_feature;
-                                                        offset_feature += report_item->count * report_item->size;
-                                                        break;
-                                                default:
-                                                    usb_log_debug("\tjump over - tag %X\n", tag);
-                                                    break;
-                                        }
+                                switch(tag) {
+                                case USB_HID_REPORT_TAG_INPUT:
+                                        report_item->type = 
+                                            USB_HID_REPORT_TYPE_INPUT;
+
+                                        report_item->offset = offset_input;
+                                        offset_input += report_item->count * 
+                                            report_item->size;
+                                        break;
+        
+                                case USB_HID_REPORT_TAG_OUTPUT:
+                                        report_item->type = 
+                                            USB_HID_REPORT_TYPE_OUTPUT;
                                         
-                                        /* 
-                                         * 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);
-
+                                        report_item->offset = offset_output;
+                                        offset_output += report_item->count * 
+                                            report_item->size;
                                         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);
+        
+                                case USB_HID_REPORT_TAG_FEATURE:
+                                        report_item->type = 
+                                            USB_HID_REPORT_TYPE_FEATURE;
+
+                                        report_item->offset = offset_feature;
+                                        offset_feature += report_item->count * 
+                                                report_item->size;
                                         break;
-
-                                case USB_HID_REPORT_TAG_PUSH:
-                                        // push current state to stack
-                                        new_report_item = usb_hid_report_item_clone(report_item);
-                                        usb_hid_report_path_t *tmp_path = usb_hid_report_path_clone(usage_path);
-                                        new_report_item->usage_path = tmp_path; 
-
-                                        list_prepend (&new_report_item->link, &stack);
-                                        break;
-                                case USB_HID_REPORT_TAG_POP:
-                                        // restore current state from stack
-                                        if(list_empty (&stack)) {
-                                                return EINVAL;
-                                        }
-                                        free(report_item);
+        
+                                default:
+                                        usb_log_debug2(
+                                            "\tjump over - tag %X\n", tag);
+                                        break;
+                                }
+                                        
+                                /* 
+                                 * append new fields to the report structure                                     
+                                 */
+                                usb_hid_report_append_fields(report, 
+                                    report_item);
+
+                                /* reset local items */
+                                usb_hid_report_reset_local_items (report_item);
+                                break;
+
+                        case USB_HID_RESET_OFFSET:
+                                offset_input = 0;
+                                offset_output = 0;
+                                offset_feature = 0;
+                                usb_hid_report_path_set_report_id (usage_path, 
+                                    report_item->id);
+                                break;
+
+                        case USB_HID_REPORT_TAG_PUSH:
+                                // push current state to stack
+                                new_report_item = usb_hid_report_item_clone(
+                                    report_item);
+                                
+                                usb_hid_report_path_t *tmp_path = 
+                                    usb_hid_report_path_clone(usage_path);
+
+                                new_report_item->usage_path = tmp_path; 
+
+                                list_prepend (&new_report_item->link, &stack);
+                                break;
+                        case USB_HID_REPORT_TAG_POP:
+                                // restore current state from stack
+                                if(list_empty (&stack)) {
+                                        return EINVAL;
+                                }
+                                free(report_item);
                                                 
-                                        report_item = list_get_instance(stack.next, usb_hid_report_item_t, link);
+                                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_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, USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
-                                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
-
-                                        usb_hid_report_path_free(report_item->usage_path);
-                                        list_initialize(&report_item->usage_path->link);
-                                        list_remove (stack.next);
+                                usb_hid_report_set_last_item(usage_path, 
+                                    USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
+                                
+                                usb_hid_report_set_last_item(usage_path, 
+                                    USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
+
+                                usb_hid_report_path_free(report_item->usage_path);
+                                list_initialize(&report_item->usage_path->link);
+                                list_remove (stack.next);
                                         
-                                        break;
+                                break;
                                         
-                                default:
-                                        // nothing special to do                                        
-                                        break;
+                        default:
+                                // nothing special to do                                        
+                                break;
                         }
 
@@ -399 +518 @@
 }
 
+/*---------------------------------------------------------------------------*/
 
 /**
@@ -409 +529 @@
  * @return Code of action to be done next
  */
-int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
-{       
+int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
+        size_t item_size, usb_hid_report_item_t *report_item,
+        usb_hid_report_path_t *usage_path) {    
+        
         int ret;
         
         switch(class){
-                case USB_HID_TAG_CLASS_MAIN:
-
-                        if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) {
-                                return USB_HID_NEW_REPORT_ITEM;
-                        }
-                        else {
-                                /*TODO process the error */
-                                return ret;
-                           }
-                        break;
-
-                case USB_HID_TAG_CLASS_GLOBAL:  
-                        return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path);
-                        break;
-
-                case USB_HID_TAG_CLASS_LOCAL:                   
-                        return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path);
-                        break;
-                default:
-                        return USB_HID_NO_ACTION;
+        case USB_HID_TAG_CLASS_MAIN:
+
+                if((ret=usb_hid_report_parse_main_tag(tag, data, item_size,
+                        report_item, usage_path)) == EOK) {
+
+                        return USB_HID_NEW_REPORT_ITEM;
+                }
+                else {
+                        return ret;
+                }
+                break;
+
+        case USB_HID_TAG_CLASS_GLOBAL:  
+                return usb_hid_report_parse_global_tag(tag, data, item_size,
+                        report_item, usage_path);
+                break;
+
+        case USB_HID_TAG_CLASS_LOCAL:                   
+                return usb_hid_report_parse_local_tag(tag, data, item_size,
+                        report_item, usage_path);
+                break;
+        
+        default:
+                return USB_HID_NO_ACTION;
         }
 }
@@ -448 +573 @@
  */
 
-int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
+int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, 
+        size_t item_size, usb_hid_report_item_t *report_item,
+        usb_hid_report_path_t *usage_path)
 {
         usb_hid_report_usage_path_t *path_item;
@@ -455 +581 @@
         switch(tag)
         {
-                case USB_HID_REPORT_TAG_INPUT:
-                case USB_HID_REPORT_TAG_OUTPUT:
-                case USB_HID_REPORT_TAG_FEATURE:
-                        report_item->item_flags = *data;                        
-                        return EOK;                     
-                        break;
+        case USB_HID_REPORT_TAG_INPUT:
+        case USB_HID_REPORT_TAG_OUTPUT:
+        case USB_HID_REPORT_TAG_FEATURE:
+                report_item->item_flags = *data;                        
+                return EOK;                     
+                break;
                         
-                case USB_HID_REPORT_TAG_COLLECTION:
-
-                        // store collection atributes
-                        path_item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
-                        path_item->flags = *data;       
+        case USB_HID_REPORT_TAG_COLLECTION:
+
+                /* store collection atributes */
+                path_item = list_get_instance(usage_path->head.prev, 
+                        usb_hid_report_usage_path_t, link);
+                path_item->flags = *data;       
                         
-                        // set last item
-                        usb_hid_report_set_last_item(usage_path, 
-                                                     USB_HID_TAG_CLASS_GLOBAL, 
-                                                     USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[report_item->usages_count-1]));
-                        usb_hid_report_set_last_item(usage_path, 
-                                                     USB_HID_TAG_CLASS_LOCAL, 
-                                                     USB_HID_EXTENDED_USAGE(report_item->usages[report_item->usages_count-1]));
+                /* set last item */
+                usb_hid_report_set_last_item(usage_path, 
+                        USB_HID_TAG_CLASS_GLOBAL, 
+                        USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[
+                                report_item->usages_count-1]));
+
+                usb_hid_report_set_last_item(usage_path, 
+                        USB_HID_TAG_CLASS_LOCAL, 
+                        USB_HID_EXTENDED_USAGE(report_item->usages[
+                                report_item->usages_count-1]));
                         
-                        // append the new one which will be set by common
-                        // usage/usage page
-                        usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]); 
-                        usb_hid_report_reset_local_items (report_item);
-                        return USB_HID_NO_ACTION;
-                        break;
+                /* append the new one which will be set by common usage/usage
+                 * page */
+                usb_hid_report_path_append_item(usage_path, 
+                        report_item->usage_page, 
+                        report_item->usages[report_item->usages_count-1]);
+
+                usb_hid_report_reset_local_items (report_item);
+                return USB_HID_NO_ACTION;
+                break;
                         
-                case USB_HID_REPORT_TAG_END_COLLECTION:
-                        usb_hid_report_remove_last_item(usage_path);
-                        return USB_HID_NO_ACTION;
-                        break;
-                default:
-                        return USB_HID_NO_ACTION;
+        case USB_HID_REPORT_TAG_END_COLLECTION:
+                usb_hid_report_remove_last_item(usage_path);
+                return USB_HID_NO_ACTION;
+                break;
+
+        default:
+                return USB_HID_NO_ACTION;
         }
 
@@ -503 +637 @@
  * @return Error code
  */
-int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
-{
-        // TODO take care about the bit length of data
+int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, 
+        size_t item_size, usb_hid_report_item_t *report_item, 
+        usb_hid_report_path_t *usage_path) { 
+        
         switch(tag)
         {
-                case USB_HID_REPORT_TAG_USAGE_PAGE:
-                        report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size);
-                        break;
-                case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
-                        report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-                        break;
-                case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
-                        report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-                        break;
-                case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
-                        report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-                        break;                  
-                case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
-                        report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
-
-                        break;
-                case USB_HID_REPORT_TAG_UNIT_EXPONENT:
-                        report_item->unit_exponent = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_UNIT:
-                        report_item->unit = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_REPORT_SIZE:
-                        report_item->size = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_REPORT_COUNT:
-                        report_item->count = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_REPORT_ID:
-                        report_item->id = usb_hid_report_tag_data_uint32(data,item_size);
-                        return USB_HID_RESET_OFFSET;
-                        break;
-                case USB_HID_REPORT_TAG_PUSH:
-                case USB_HID_REPORT_TAG_POP:
-                        /* 
-                         * stack operations are done in top level parsing
-                         * function
-                         */
-                        return tag;
-                        break;
+        case USB_HID_REPORT_TAG_USAGE_PAGE:
+                report_item->usage_page = 
+                        usb_hid_report_tag_data_uint32(data, item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
+                report_item->logical_minimum = USB_HID_UINT32_TO_INT32(
+                        usb_hid_report_tag_data_uint32(data,item_size),
+                        item_size * 8);
+                break;
+
+        case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
+                report_item->logical_maximum = USB_HID_UINT32_TO_INT32(
+                        usb_hid_report_tag_data_uint32(data,item_size), 
+                        item_size * 8);
+                break;
+
+        case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
+                report_item->physical_minimum = USB_HID_UINT32_TO_INT32(
+                        usb_hid_report_tag_data_uint32(data,item_size), 
+                        item_size * 8);
+                break;                  
+
+        case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
+                report_item->physical_maximum = USB_HID_UINT32_TO_INT32(
+                        usb_hid_report_tag_data_uint32(data,item_size), 
+                        item_size * 8);
+                break;
+
+        case USB_HID_REPORT_TAG_UNIT_EXPONENT:
+                report_item->unit_exponent = usb_hid_report_tag_data_uint32(
+                        data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_UNIT:
+                report_item->unit = usb_hid_report_tag_data_uint32(
+                        data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_REPORT_SIZE:
+                report_item->size = usb_hid_report_tag_data_uint32(
+                        data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_REPORT_COUNT:
+                report_item->count = usb_hid_report_tag_data_uint32(
+                        data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_REPORT_ID:
+                report_item->id = usb_hid_report_tag_data_uint32(data, 
+                        item_size);
+                return USB_HID_RESET_OFFSET;
+                break;
+        
+        case USB_HID_REPORT_TAG_PUSH:
+        case USB_HID_REPORT_TAG_POP:
+                /* 
+                 * stack operations are done in top level parsing
+                 * function
+                 */
+                return tag;
+                break;
                         
-                default:
-                        return USB_HID_NO_ACTION;
+        default:
+                return USB_HID_NO_ACTION;
         }
 
@@ -566 +723 @@
  * @return Error code
  */
-int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
+int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, 
+        size_t item_size, usb_hid_report_item_t *report_item, 
+        usb_hid_report_path_t *usage_path)
 {
         int32_t extended_usage;
         
         switch(tag) {
-                case USB_HID_REPORT_TAG_USAGE:
-                        switch(report_item->in_delimiter) {
-                                case INSIDE_DELIMITER_SET:
-                                        // nothing to do
-                                        break;
-                                case START_DELIMITER_SET:
-                                        report_item->in_delimiter = INSIDE_DELIMITER_SET;
-                                case OUTSIDE_DELIMITER_SET:
-                                        extended_usage = ((report_item->usage_page) << 16);
-                                        extended_usage += usb_hid_report_tag_data_uint32(data,item_size);
-                                        report_item->usages[report_item->usages_count] = extended_usage;
-                                        report_item->usages_count++;
-                                        break;
+        case USB_HID_REPORT_TAG_USAGE:
+                switch(report_item->in_delimiter) {
+                case INSIDE_DELIMITER_SET:
+                        /* nothing to do
+                         * we catch only the first one
+                         */
+                        break;
+        
+                case START_DELIMITER_SET:
+                        report_item->in_delimiter = INSIDE_DELIMITER_SET;
+                case OUTSIDE_DELIMITER_SET:
+                        extended_usage = ((report_item->usage_page) << 16);
+                        extended_usage += usb_hid_report_tag_data_uint32(
+                                data,item_size);
+
+                        report_item->usages[report_item->usages_count] = 
+                                extended_usage;
+
+                        report_item->usages_count++;
+                        break;
+                }
+                break;
+                
+        case USB_HID_REPORT_TAG_USAGE_MINIMUM:                  
+                if (item_size == 3) {
+                        // usage extended usages
+                        report_item->extended_usage_page = 
+                            USB_HID_EXTENDED_USAGE_PAGE(
+                            usb_hid_report_tag_data_uint32(data,item_size));
+                           
+
+                        report_item->usage_minimum = 
+                            USB_HID_EXTENDED_USAGE(
+                            usb_hid_report_tag_data_uint32(data,item_size));
+                }
+                else {
+                        report_item->usage_minimum = 
+                            usb_hid_report_tag_data_uint32(data,item_size);
+                }
+                break;
+        
+        case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
+                if (item_size == 3) {
+                        if(report_item->extended_usage_page != 
+                            USB_HID_EXTENDED_USAGE_PAGE(        
+                            usb_hid_report_tag_data_uint32(data,item_size))) {
+                                
+                                return EINVAL;
                         }
-                        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;
+                                
+                        // usage extended usages
+                        report_item->extended_usage_page = 
+                                USB_HID_EXTENDED_USAGE_PAGE(
+                                usb_hid_report_tag_data_uint32(data,item_size));
+
+                        report_item->usage_maximum = 
+                                USB_HID_EXTENDED_USAGE(
+                                usb_hid_report_tag_data_uint32(data,item_size));
+                }
+                else {
+                        report_item->usage_maximum = 
+                                usb_hid_report_tag_data_uint32(data,item_size);
+                }
+
+                // vlozit zaznamy do pole usages
+                int32_t i;
+                for(i = report_item->usage_minimum; 
+                    i <= report_item->usage_maximum; i++) {
+
+                        if(report_item->extended_usage_page) {
+                            report_item->usages[report_item->usages_count++] = 
+                                (report_item->extended_usage_page << 16) + i;
                         }
-                        else {
-                                report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size);
+                        else {                  
+                            report_item->usages[report_item->usages_count++] = 
+                                (report_item->usage_page << 16) + i;
                         }
-                        break;
-                case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
-                        if (item_size == 3) {
-
-                                if(report_item->extended_usage_page != ((usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16)) {
-                                        return EINVAL;
-                                }
-                                
-                                // 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);
-                        }
-
-                        // vlozit zaznamy do pole usages
-                        int32_t i;
-                        for(i=report_item->usage_minimum; i<=report_item->usage_maximum; i++) {
-                                if(report_item->extended_usage_page) {
-                                        report_item->usages[report_item->usages_count++] = (report_item->extended_usage_page << 16) + i;
-                                }
-                                else {
-                                        
-                                        report_item->usages[report_item->usages_count++] = (report_item->usage_page << 16) + i;
-                                }
-                        }
-                        report_item->extended_usage_page = 0;
+                }
+                report_item->extended_usage_page = 0;
                         
-                        break;
-                case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
-                        report_item->designator_index = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
-                        report_item->designator_minimum = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
-                        report_item->designator_maximum = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_STRING_INDEX:
-                        report_item->string_index = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_STRING_MINIMUM:
-                        report_item->string_minimum = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-                case USB_HID_REPORT_TAG_STRING_MAXIMUM:
-                        report_item->string_maximum = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;                  
-                case USB_HID_REPORT_TAG_DELIMITER:
-                        report_item->in_delimiter = usb_hid_report_tag_data_uint32(data,item_size);
-                        break;
-
-                default:
-                        return USB_HID_NO_ACTION;
+                break;
+                
+        case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
+                report_item->designator_index = 
+                        usb_hid_report_tag_data_uint32(data,item_size);
+                break;
+        
+        case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
+                report_item->designator_minimum = 
+                        usb_hid_report_tag_data_uint32(data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
+                report_item->designator_maximum = 
+                        usb_hid_report_tag_data_uint32(data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_STRING_INDEX:
+                report_item->string_index = 
+                        usb_hid_report_tag_data_uint32(data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_STRING_MINIMUM:
+                report_item->string_minimum = 
+                        usb_hid_report_tag_data_uint32(data,item_size);
+                break;
+
+        case USB_HID_REPORT_TAG_STRING_MAXIMUM:
+                report_item->string_maximum = 
+                        usb_hid_report_tag_data_uint32(data,item_size);
+                break;                  
+
+        case USB_HID_REPORT_TAG_DELIMITER:
+                report_item->in_delimiter = 
+                        usb_hid_report_tag_data_uint32(data,item_size);
+                break;
+
+        default:
+                return USB_HID_NO_ACTION;
         }
 
         return EOK;
 }
+/*---------------------------------------------------------------------------*/
 
 /**
@@ -674 +874 @@
         return result;
 }
+/*---------------------------------------------------------------------------*/
 
 /**
@@ -694 +895 @@
         for(item = head->next; item != head; item = item->next) {
                 
-                report_item = list_get_instance(item, usb_hid_report_field_t, link);
+                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: %zu\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\tUSAGES COUNT: %zu\n", report_item->usages_count);
+                usb_log_debug("\t\tSIZE: %zu\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\tUSAGES COUNT: %zu\n", 
+                        report_item->usages_count);
 
                 usb_log_debug("\t\tVALUE: %X\n", report_item->value);
@@ -716 +925 @@
         }
 
-
-}
+}
+/*---------------------------------------------------------------------------*/
+
 /**
  * Prints content of given report descriptor in human readable format.
@@ -734 +944 @@
 
         while(report_it != &report->reports) {
-                report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
+                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: %zu\n", report_des->bit_length);               
+                usb_log_debug("\tB Size: %zu\n",
+                        usb_hid_report_byte_size(report, 
+                                report_des->report_id, 
+                                report_des->type));
                 usb_log_debug("\tItems: %zu\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;
         }
 }
+/*---------------------------------------------------------------------------*/
 
 /**
@@ -776 +985 @@
 
                 while(!list_empty(&report_item->usage_path->link)) {
-                        usb_hid_report_remove_last_item(report_item->usage_path);
+                    usb_hid_report_remove_last_item(report_item->usage_path);
                 }
 
@@ -788 +997 @@
         
 }
+/*---------------------------------------------------------------------------*/
 
 /** Frees the HID report descriptor parser structure 
@@ -803 +1013 @@
         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);
+                path = list_get_instance(report->collection_paths.next, 
+                                usb_hid_report_path_t, link);
+
                 usb_hid_report_path_free(path);         
         }
@@ -811 +1023 @@
         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);
+                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);
+                        field = list_get_instance(
+                                report_des->report_items.next, 
+                                usb_hid_report_field_t, link);
+
                         list_remove(&field->link);
 
@@ -826 +1043 @@
         return;
 }
+/*---------------------------------------------------------------------------*/
 
 /**

uspace/lib/usbhid/src/hidiface.c

@@ -46 +46 @@
  * @return Number of usages returned or negative error code.
  */
-int usbhid_dev_get_event_length(int dev_phone)
+int usbhid_dev_get_event_length(int dev_phone, size_t *size)
 {
         if (dev_phone < 0) {
@@ -56 +56 @@
             IPC_M_USBHID_GET_EVENT_LENGTH, &len);
         if (rc == EOK) {
-                return (int) len;
-        } else {
-                return rc;
-        }
+                if (size != NULL) {
+                        *size = (size_t) len;
+                }
+        }
+        
+        return rc;
 }
 
@@ -74 +76 @@
  * @return Error code.
  */
-int usbhid_dev_get_event(int dev_phone, uint16_t *usage_pages, uint16_t *usages,
-    size_t usage_count, size_t *actual_usage_count, unsigned int flags)
-{
-        if (dev_phone < 0) {
-                return EINVAL;
-        }
-        if ((usage_pages == NULL) || (usages == NULL)) {
-                return ENOMEM;
-        }
-        if (usage_count == 0) {
-                return EINVAL;
-        }
-
-        size_t buffer_size = sizeof(uint16_t) * usage_count * 2;
-        uint16_t *buffer = malloc(buffer_size);
+int usbhid_dev_get_event(int dev_phone, uint8_t *buf, 
+    size_t size, size_t *actual_size, int *event_nr, unsigned int flags)
+{
+        if (dev_phone < 0) {
+                return EINVAL;
+        }
+        if ((buf == NULL)) {
+                return ENOMEM;
+        }
+        if (size == 0) {
+                return EINVAL;
+        }
+        
+//      if (size == 0) {
+//              return EOK;
+//      }
+
+        size_t buffer_size =  size;
+        uint8_t *buffer = malloc(buffer_size);
         if (buffer == NULL) {
                 return ENOMEM;
         }
 
+        ipc_call_t opening_request_call;
         aid_t opening_request = async_send_2(dev_phone,
             DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT,
-            flags, NULL);
+            flags, &opening_request_call);
         if (opening_request == 0) {
                 free(buffer);
@@ -128 +135 @@
         }
 
-        size_t actual_size = IPC_GET_ARG2(data_request_call);
-        size_t items = actual_size / 2;
+        size_t act_size = IPC_GET_ARG2(data_request_call);
 
         /* Copy the individual items. */
-        memcpy(usage_pages, buffer, items * sizeof(uint16_t));
-        memcpy(usages, buffer + items, items * sizeof(uint16_t));
-
-        if (actual_usage_count != NULL) {
-                *actual_usage_count = items;
+        memcpy(buf, buffer, act_size);
+//      memcpy(usages, buffer + items, items * sizeof(int32_t));
+
+        if (actual_size != NULL) {
+                *actual_size = act_size;
+        }
+        
+        if (event_nr != NULL) {
+                *event_nr = IPC_GET_ARG1(opening_request_call);
+        }
+
+        return EOK;
+}
+
+
+int usbhid_dev_get_report_descriptor_length(int dev_phone, size_t *size)
+{
+        if (dev_phone < 0) {
+                return EINVAL;
+        }
+
+        sysarg_t arg_size;
+        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(USBHID_DEV_IFACE),
+            IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size);
+        if (rc == EOK) {
+                if (size != NULL) {
+                        *size = (size_t) arg_size;
+                }
+        }
+        return rc;
+}
+
+int usbhid_dev_get_report_descriptor(int dev_phone, uint8_t *buf, size_t size, 
+    size_t *actual_size)
+{
+        if (dev_phone < 0) {
+                return EINVAL;
+        }
+        if ((buf == NULL)) {
+                return ENOMEM;
+        }
+        if (size == 0) {
+                return EINVAL;
+        }
+
+        aid_t opening_request = async_send_1(dev_phone,
+            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR,
+            NULL);
+        if (opening_request == 0) {
+                return ENOMEM;
+        }
+
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(dev_phone, buf, size,
+            &data_request_call);
+        if (data_request == 0) {
+                async_wait_for(opening_request, NULL);
+                return ENOMEM;
+        }
+
+        sysarg_t data_request_rc;
+        sysarg_t opening_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        async_wait_for(opening_request, &opening_request_rc);
+
+        if (data_request_rc != EOK) {
+                /* Prefer return code of the opening request. */
+                if (opening_request_rc != EOK) {
+                        return (int) opening_request_rc;
+                } else {
+                        return (int) data_request_rc;
+                }
+        }
+
+        if (opening_request_rc != EOK) {
+                return (int) opening_request_rc;
+        }
+
+        size_t act_size = IPC_GET_ARG2(data_request_call);
+
+        if (actual_size != NULL) {
+                *actual_size = act_size;
         }
 

uspace/lib/usbhid/src/hidparser.c

@@ -31 +31 @@
  */
 /** @file
- * HID report descriptor and report data parser implementation.
+ * USB HID report data parser implementation.
  */
 #include <usb/hid/hidparser.h>
@@ -41 +41 @@
 #include <assert.h>
 
-
+/*---------------------------------------------------------------------------*/
 /*
  * Data translation private functions
  */
 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
-//inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
+
 int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data);
-uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value);
+
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 
+        int32_t value);
+
 int usb_pow(int a, int b);
 
+/*---------------------------------------------------------------------------*/
 
 // TODO: tohle ma bejt asi jinde
@@ -56 +60 @@
 {
         switch(b) {
-                case 0:
-                        return 1;
-                        break;
-                case 1:
-                        return a;
-                        break;
-                default:
-                        return a * usb_pow(a, b-1);
-                        break;
-        }
-}
-
+        case 0:
+                return 1;
+                break;
+        case 1:
+                return a;
+                break;
+        default:
+                return a * usb_pow(a, b-1);
+                break;
+        }
+}
+/*---------------------------------------------------------------------------*/
 
 /** Returns size of report of specified report id and type in items
@@ -94 +98 @@
 }
 
+/** Returns size of report of specified report id and type in bytes
+ *
+ * @param parser Opaque report parser structure
+ * @param report_id 
+ * @param type
+ * @return Number of items in specified report
+ */
+size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, 
+                           usb_hid_report_type_t type)
+{
+        usb_hid_report_description_t *report_des;
+
+        if(report == NULL) {
+                return 0;
+        }
+
+        report_des = usb_hid_report_find_description (report, report_id, type);
+        if(report_des == NULL){
+                return 0;
+        }
+        else {
+                return ((report_des->bit_length + 7) / 8) ;
+        }
+}
+/*---------------------------------------------------------------------------*/
 
 /** Parse and act upon a HID report.
@@ -103 +132 @@
  * @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_t *report, const uint8_t *data, 
+        size_t size, uint8_t *report_id)
 {
         link_t *list_item;
@@ -125 +154 @@
 
         report_des = usb_hid_report_find_description(report, *report_id, type);
+        if(report_des == NULL) {
+                return EINVAL;
+        }
 
         /* read data */
@@ -130 +162 @@
         while(list_item != &(report_des->report_items)) {
 
-                item = list_get_instance(list_item, usb_hid_report_field_t, link);
+                item = list_get_instance(list_item, usb_hid_report_field_t, 
+                                link);
 
                 if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
@@ -137 +170 @@
 
                                 // array
-                                item->value = usb_hid_translate_data(item, data);
+                                item->value = 
+                                        usb_hid_translate_data(item, data);
                 
-                                item->usage = USB_HID_EXTENDED_USAGE(item->usages[item->value - item->physical_minimum]);
-                                item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(item->usages[item->value - item->physical_minimum]);                             
+                                item->usage = USB_HID_EXTENDED_USAGE(
+                                    item->usages[item->value - item->physical_minimum]);
+
+                                item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(
+                                    item->usages[item->value - item->physical_minimum]);
 
                                 usb_hid_report_set_last_item (item->collection_path, 
-                                                              USB_HID_TAG_CLASS_GLOBAL,
-                                                              item->usage_page);
+                                    USB_HID_TAG_CLASS_GLOBAL, item->usage_page);
+
                                 usb_hid_report_set_last_item (item->collection_path, 
-                                                              USB_HID_TAG_CLASS_LOCAL,
-                                                              item->usage);
+                                    USB_HID_TAG_CLASS_LOCAL, item->usage);
                                 
                         }
@@ -162 +198 @@
 }
 
+/*---------------------------------------------------------------------------*/
 /**
  * Translate data from the report as specified in report descriptor item
@@ -167 +204 @@
  * @param item Report descriptor item with definition of translation
  * @param data Data to translate
- * @param j Index of processed field in report descriptor item
  * @return Translated data
  */
@@ -236 +272 @@
         }
 
-        return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum);
-        
-}
-
-/*** OUTPUT API **/
+        return (int)(((value - item->logical_minimum) / resolution) + 
+                item->physical_minimum);
+        
+}
+
+/*---------------------------------------------------------------------------*/
+/* OUTPUT API */
 
 /** 
@@ -250 +288 @@
  * @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)
+uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, 
+        uint8_t report_id)
 {
         if(report == NULL) {
@@ -260 +299 @@
         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)){
+                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;
                 }
@@ -303 +345 @@
  * @return Error code
  */
-int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,
-                                    uint8_t *buffer, size_t size)
+int usb_hid_report_output_translate(usb_hid_report_t *report, 
+        uint8_t report_id, uint8_t *buffer, size_t size)
 {
         link_t *item;   
@@ -320 +362 @@
         }
 
-        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);
+        report_des = usb_hid_report_find_description (report, report_id, 
+                USB_HID_REPORT_TYPE_OUTPUT);
+        
         if(report_des == NULL){
                 return EINVAL;
@@ -333 +375 @@
                 report_item = list_get_instance(item, usb_hid_report_field_t, link);
 
-                usb_log_debug("OUTPUT ITEM usage(%x), value(%x)\n", report_item->usage, report_item->value);
-                
                 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
                                         
                         // array
-                        value = usb_hid_translate_data_reverse(report_item, report_item->value);
+                        value = usb_hid_translate_data_reverse(report_item, 
+                                report_item->value);
+
                         offset = report_item->offset;
                         length = report_item->size;
@@ -344 +386 @@
                 else {
                         // variable item
-                        value  = usb_hid_translate_data_reverse(report_item, report_item->value);
+                        value  = usb_hid_translate_data_reverse(report_item, 
+                                report_item->value);
+
                         offset = report_item->offset;
                         length = report_item->size;
@@ -353 +397 @@
                 if((offset/8) == ((offset+length-1)/8)) {
                         // je to v jednom bytu
-                        if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) {
+                        if(((size_t)(offset/8) >= size) || 
+                                ((size_t)(offset+length-1)/8) >= size) {
                                 break; // TODO ErrorCode
                         }
@@ -370 +415 @@
                                 if(i == (offset/8)) {
                                         tmp_value = value;
-                                        tmp_value = tmp_value & ((1 << (8-(offset%8)))-1);                              
+                                        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;                     
+                                        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);
+                                        value = value >> (length - 
+                                                ((offset + length) % 8));
+
+                                        value = value & ((1 << (length - 
+                                                ((offset + length) % 8))) - 1);
                                 
-                                        mask = (1 << (length - ((offset + length) % 8))) - 1;
+                                        mask = (1 << (length - 
+                                                ((offset + length) % 8))) - 1;
+
                                         buffer[i] = (buffer[i] & mask) | value;
                                 }
@@ -396 +451 @@
         }
         
-        usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
-
         return EOK;
 }
 
+/*---------------------------------------------------------------------------*/
 /**
  * Translate given data for putting them into the outoput report
@@ -407 +461 @@
  * @return ranslated value
  */
-uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value)
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 
+        int value)
 {
         int ret=0;
@@ -431 +486 @@
         }
 
-        ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum;
-        usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), ret(%x)\n", value, resolution, item->physical_minimum, item->logical_minimum, ret);
+        ret = ((value - item->physical_minimum) * resolution) + 
+                item->logical_minimum;
+
+        usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), \
+                ret(%x)\n", value, resolution, item->physical_minimum, 
+                item->logical_minimum, ret);
         
         if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
@@ -440 +499 @@
 }
 
-usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
+/*---------------------------------------------------------------------------*/
+/**
+ * Clones given state table
+ *
+ * @param item State table to clone
+ * @return Pointer to the cloned item
+ */
+usb_hid_report_item_t *usb_hid_report_item_clone(
+        const usb_hid_report_item_t *item)
 {
         usb_hid_report_item_t *new_report_item;
@@ -453 +520 @@
 }
 
-
+/*---------------------------------------------------------------------------*/
+/**
+ * Function for sequence walking through the report. Returns next field in the
+ * report or the first one when no field is given.
+ *
+ * @param report Searched report structure
+ * @param field Current field. If NULL is given, the first one in the report
+ * is returned. Otherwise the next one i nthe list is returned.
+ * @param path Usage path specifying which fields wa are interested in. 
+ * @param flags Flags defining mode of usage paths comparison
+ * @param type Type of report we search.
+ * @retval NULL if no field is founded
+ * @retval Pointer to the founded report structure when founded
+ */
 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);
+        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;
         
@@ -467 +548 @@
 
         if(field == NULL){
-                // vezmu prvni co mathuje podle path!!
                 field_it = report_des->report_items.next;
         }
@@ -475 +555 @@
 
         while(field_it != &report_des->report_items) {
-                field = list_get_instance(field_it, usb_hid_report_field_t, link);
+                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);
+                        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);
+                        usb_hid_report_remove_last_item (
+                                field->collection_path);
                 }
                 field_it = field_it->next;
@@ -491 +580 @@
 }
 
-uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
+/*---------------------------------------------------------------------------*/
+/**
+ * Returns next report_id of report of specified type. If zero is given than
+ * first report_id of specified type is returned (0 is not legal value for
+ * repotr_id)
+ *
+ * @param report_id Current report_id, 0 if there is no current report_id
+ * @param type Type of searched report
+ * @param report Report structure inwhich we search
+ * @retval 0 if report structure is null or there is no specified report
+ * @retval report_id otherwise
+ */
+uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, 
+        uint8_t report_id, usb_hid_report_type_t type)
 {
         if(report == NULL){
@@ -500 +602 @@
         link_t *report_it;
         
-        if(report_id == 0) {
-                report_it = usb_hid_report_find_description (report, report_id, type)->link.next;               
+        if(report_id > 0) {
+                report_it = usb_hid_report_find_description(report, report_id, 
+                        type)->link.next;               
         }
         else {
@@ -508 +611 @@
 
         while(report_it != &report->reports) {
-                report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
+                report_des = list_get_instance(report_it, 
+                        usb_hid_report_description_t, link);
+
                 if(report_des->type == type){
                         return report_des->report_id;
@@ -517 +622 @@
 }
 
+/*---------------------------------------------------------------------------*/
+/**
+ * Reset all local items in given state table
+ *
+ * @param report_item State table containing current state of report
+ * descriptor parsing
+ *
+ * @return void
+ */
 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
 {

uspace/lib/usbhid/src/hidpath.c

@@ -41 +41 @@
 #include <assert.h>
 
-
-#define USB_HID_SAME_USAGE(usage1, usage2)      ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0))
-#define USB_HID_SAME_USAGE_PAGE(page1, page2)   ((page1 == page2) || (page1 == 0) || (page2 == 0))
-
+/*---------------------------------------------------------------------------*/
+/**
+ * Compares two usages if they are same or not or one of the usages is not
+ * set.
+ *
+ * @param usage1
+ * @param usage2
+ * @return boolean
+ */
+#define USB_HID_SAME_USAGE(usage1, usage2)              \
+        ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0))
+
+/**
+ * Compares two usage pages if they are same or not or one of them is not set.
+ *
+ * @param page1
+ * @param page2
+ * @return boolean
+ */
+#define USB_HID_SAME_USAGE_PAGE(page1, page2)   \
+        ((page1 == page2) || (page1 == 0) || (page2 == 0))
+
+/*---------------------------------------------------------------------------*/
 /**
  * Appends one item (couple of usage_path and usage) into the usage path
@@ -73 +92 @@
 }
 
+/*---------------------------------------------------------------------------*/
 /**
  * Removes last item from the usage path structure
@@ -91 +111 @@
 }
 
+/*---------------------------------------------------------------------------*/
 /**
  * Nulls last item of the usage path structure.
@@ -102 +123 @@
         
         if(!list_empty(&usage_path->head)){     
-                item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
+                item = list_get_instance(usage_path->head.prev, 
+                        usb_hid_report_usage_path_t, link);
+
                 memset(item, 0, sizeof(usb_hid_report_usage_path_t));
         }
 }
 
+/*---------------------------------------------------------------------------*/
 /**
  * Modifies last item of usage path structure by given usage page or usage
@@ -137 +161 @@
 }
 
-
+/*---------------------------------------------------------------------------*/
+/**
+ *
+ *
+ *
+ *
+ */
 void usb_hid_print_usage_path(usb_hid_report_path_t *path)
 {
@@ -147 +177 @@
         while(item != &path->head) {
 
-                path_item = list_get_instance(item, usb_hid_report_usage_path_t, link);
+                path_item = list_get_instance(item, usb_hid_report_usage_path_t, 
+                        link);
+
                 usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
                 usb_log_debug("\tUSAGE: %X\n", path_item->usage);
                 usb_log_debug("\tFLAGS: %d\n", path_item->flags);               
                 
-                item = item->next;
-        }
-}
-
+        item = item->next;
+        }
+}
+
+/*---------------------------------------------------------------------------*/
 /**
  * Compares two usage paths structures
@@ -192 +225 @@
         
         switch(flags){
-                /* path is somewhere in report_path */
-                case USB_HID_PATH_COMPARE_ANYWHERE:
-                        if(path->depth != 1){
-                                return 1;
-                        }
-
-                        // projit skrz cestu a kdyz nekde sedi tak vratim EOK
-                        // dojduli az za konec tak nnesedi
-                        report_link = report_path->head.next;
-                        path_link = path->head.next;
-                        path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
-
-                        while(report_link != &report_path->head) {
-                                report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
-                                if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page)){
-                                        if(only_page == 0){
-                                                if(USB_HID_SAME_USAGE(report_item->usage, path_item->usage)) {
-                                                        return EOK;
-                                                }
-                                        }
-                                        else {
+        /* path is somewhere in report_path */
+        case USB_HID_PATH_COMPARE_ANYWHERE:
+                if(path->depth != 1){
+                        return 1;
+                }
+
+                report_link = report_path->head.next;
+                path_link = path->head.next;
+                path_item = list_get_instance(path_link, 
+                        usb_hid_report_usage_path_t, link);
+
+                while(report_link != &report_path->head) {
+                        report_item = list_get_instance(report_link, 
+                                usb_hid_report_usage_path_t, link);
+                                
+                        if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 
+                                path_item->usage_page)){
+                                        
+                                if(only_page == 0){
+                                        if(USB_HID_SAME_USAGE(
+                                                report_item->usage,
+                                                path_item->usage)) {
+                                                        
                                                 return EOK;
                                         }
                                 }
-
+                                else {
+                                        return EOK;
+                                }
+                        }
+
+                        report_link = report_link->next;
+                }
+
+                return 1;
+                break;
+
+        /* the paths must be identical */
+        case USB_HID_PATH_COMPARE_STRICT:
+                if(report_path->depth != path->depth){
+                        return 1;
+                }
+                
+        /* path is prefix of the report_path */
+        case USB_HID_PATH_COMPARE_BEGIN:
+        
+                report_link = report_path->head.next;
+                path_link = path->head.next;
+                        
+                while((report_link != &report_path->head) && 
+                      (path_link != &path->head)) {
+                                          
+                        report_item = list_get_instance(report_link, 
+                                usb_hid_report_usage_path_t, link);
+                                          
+                        path_item = list_get_instance(path_link,
+                                usb_hid_report_usage_path_t, link);
+
+                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 
+                                path_item->usage_page) || ((only_page == 0) && 
+                            !USB_HID_SAME_USAGE(report_item->usage, 
+                                path_item->usage))) {
+                        
+                                return 1;
+                        } 
+                        else {
                                 report_link = report_link->next;
+                                path_link = path_link->next;                    
                         }
-
-                        return 1;
-                        break;
-                /* the paths must be identical */
-                case USB_HID_PATH_COMPARE_STRICT:
-                                if(report_path->depth != path->depth){
-                                        return 1;
-                                }
-                
-                /* path is prefix of the report_path */
-                case USB_HID_PATH_COMPARE_BEGIN:
-        
-                                report_link = report_path->head.next;
-                                path_link = path->head.next;
-                        
-                                while((report_link != &report_path->head) && 
-                                      (path_link != &path->head)) {
-                                                  
-                                        report_item = list_get_instance(report_link, 
-                                                                        usb_hid_report_usage_path_t, 
-                                                                        link);
-                                                  
-                                        path_item = list_get_instance(path_link, 
-                                                                      usb_hid_report_usage_path_t, 
-                                                                      link);            
-
-                                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page) || 
-                                           ((only_page == 0) && 
-                                            !USB_HID_SAME_USAGE(report_item->usage, path_item->usage))) {
-                                                        
-                                                   return 1;
-                                        } else {
-                                                report_link = report_link->next;
-                                                path_link = path_link->next;                    
-                                        }
                         
                                 }
 
-                                if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) || 
-                                   ((report_link == &report_path->head) && (path_link == &path->head))) {
-                                        return EOK;
-                                }
-                                else {
+                if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && 
+                        (path_link == &path->head)) || 
+                   ((report_link == &report_path->head) && 
+                        (path_link == &path->head))) {
+                                
+                        return EOK;
+                }
+                else {
+                        return 1;
+                }                                               
+                break;
+
+        /* path is suffix of report_path */
+        case USB_HID_PATH_COMPARE_END:
+
+                report_link = report_path->head.prev;
+                path_link = path->head.prev;
+
+                if(list_empty(&path->head)){
+                        return EOK;
+                }
+                        
+                while((report_link != &report_path->head) && 
+                      (path_link != &path->head)) {
+                                                  
+                        report_item = list_get_instance(report_link, 
+                                usb_hid_report_usage_path_t, link);
+
+                        path_item = list_get_instance(path_link, 
+                                usb_hid_report_usage_path_t, link);             
+                                                  
+                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 
+                                path_item->usage_page) || ((only_page == 0) && 
+                            !USB_HID_SAME_USAGE(report_item->usage, 
+                                path_item->usage))) {
+                                                
                                         return 1;
-                                }                                               
-                        break;
-
-                /* path is suffix of report_path */
-                case USB_HID_PATH_COMPARE_END:
-
-                                report_link = report_path->head.prev;
-                                path_link = path->head.prev;
-
-                                if(list_empty(&path->head)){
-                                        return EOK;
-                                }
+                        } else {
+                                report_link = report_link->prev;
+                                path_link = path_link->prev;                    
+                        }
+
+                }
+
+                if(path_link == &path->head) {
+                        return EOK;
+                }
+                else {
+                        return 1;
+                }                                               
                         
-                                while((report_link != &report_path->head) && 
-                                      (path_link != &path->head)) {
-                                                  
-                                        report_item = list_get_instance(report_link, 
-                                                                        usb_hid_report_usage_path_t, 
-                                                                        link);
-                                        path_item = list_get_instance(path_link, 
-                                                                      usb_hid_report_usage_path_t, 
-                                                                      link);            
-                                                  
-                                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page) || 
-                                           ((only_page == 0) && 
-                                            !USB_HID_SAME_USAGE(report_item->usage, path_item->usage))) {
-                                                        return 1;
-                                        } else {
-                                                report_link = report_link->prev;
-                                                path_link = path_link->prev;                    
-                                        }
-                        
-                                }
-
-                                if(path_link == &path->head) {
-                                        return EOK;
-                                }
-                                else {
-                                        return 1;
-                                }                                               
-                        
-                        break;
-
-                default:
-                        return EINVAL;
-        }
-}
-
+                break;
+
+        default:
+                return EINVAL;
+        }
+}
+
+/*---------------------------------------------------------------------------*/
 /**
  * Allocates and initializes new usage path structure.
@@ -332 +377 @@
 }
 
+/*---------------------------------------------------------------------------*/
 /**
  * Releases given usage path structure.
@@ -348 +394 @@
 }
 
-
+/*---------------------------------------------------------------------------*/
 /**
  * Clone content of given usage path to the new one
@@ -355 +401 @@
  * @return New copy of given usage path structure
  */
-usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path)
+usb_hid_report_path_t *usb_hid_report_path_clone(
+        usb_hid_report_path_t *usage_path)
 {
         link_t *path_link;
@@ -374 +421 @@
         path_link = usage_path->head.next;
         while(path_link != &usage_path->head) {
-                path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, 
-                                              link);
+                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) {
@@ -395 +443 @@
 }
 
-
+/*---------------------------------------------------------------------------*/
 /**
  * Sets report id in usage path structure
@@ -403 +451 @@
  * @return Error code
  */
-int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
+int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, 
+        uint8_t report_id)
 {
         if(path == NULL){

uspace/lib/usbhid/src/hidreport.c

@@ -164 +164 @@
 
 int usb_hid_process_report_descriptor(usb_device_t *dev, 
-    usb_hid_report_t *report)
+    usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size)
 {
         if (dev == NULL || report == NULL) {
@@ -172 +172 @@
         }
         
-        uint8_t *report_desc = NULL;
-        size_t report_size;
-        
-        int rc = usb_hid_get_report_descriptor(dev, &report_desc, 
-            &report_size);
+//      uint8_t *report_desc = NULL;
+//      size_t report_size;
+        
+        int rc = usb_hid_get_report_descriptor(dev, report_desc, report_size);
         
         if (rc != EOK) {
                 usb_log_error("Problem with getting Report descriptor: %s.\n",
                     str_error(rc));
-                if (report_desc != NULL) {
-                        free(report_desc);
+                if (*report_desc != NULL) {
+                        free(*report_desc);
+                        *report_desc = NULL;
                 }
                 return rc;
         }
         
-        assert(report_desc != NULL);
-        
-        rc = usb_hid_parse_report_descriptor(report, report_desc, report_size);
+        assert(*report_desc != NULL);
+        
+        rc = usb_hid_parse_report_descriptor(report, *report_desc, *report_size);
         if (rc != EOK) {
                 usb_log_error("Problem parsing Report descriptor: %s.\n",
                     str_error(rc));
-                free(report_desc);
+                free(*report_desc);
+                *report_desc = NULL;
                 return rc;
         }
         
         usb_hid_descriptor_print(report);
-        free(report_desc);
         
         return EOK;