Changeset 400735e in mainline

Timestamp:

2011-05-28T14:30:58Z (13 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

Files:

• HelenOS.config (modified) (2 diffs)
• uspace/app/mkbd/Makefile (modified) (1 diff)
• uspace/app/mkbd/main.c (modified) (5 diffs)
• uspace/drv/ohci/hc.c (modified) (2 diffs)
• uspace/drv/ohci/root_hub.c (modified) (12 diffs)
• uspace/drv/uhci-hcd/Makefile (modified) (1 diff)
• uspace/drv/uhci-hcd/batch.h (modified) (1 diff)
• uspace/drv/uhci-hcd/hc.c (modified) (6 diffs)
• uspace/drv/uhci-hcd/hc.h (modified) (2 diffs)
• uspace/drv/uhci-hcd/iface.c (modified) (11 diffs)
• uspace/drv/uhci-hcd/pci.c (modified) (8 diffs)
• uspace/drv/uhci-hcd/pci.h (modified) (1 diff)
• uspace/drv/uhci-hcd/root_hub.c (modified) (1 diff)
• uspace/drv/uhci-hcd/root_hub.h (modified) (1 diff)
• uspace/drv/uhci-hcd/transfer_list.c (modified) (6 diffs)
• uspace/drv/uhci-hcd/transfer_list.h (modified) (1 diff)
• uspace/drv/uhci-hcd/uhci.c (modified) (5 diffs)
• uspace/drv/uhci-hcd/uhci.h (modified) (1 diff)
• uspace/drv/uhci-hcd/utils/malloc32.h (modified) (5 diffs)
• uspace/drv/uhci-hcd/utils/slab.c (deleted)
• uspace/drv/uhci-rhd/main.c (modified) (4 diffs)
• uspace/drv/uhci-rhd/port.c (modified) (12 diffs)
• uspace/drv/uhci-rhd/port.h (modified) (1 diff)
• uspace/drv/usbhid/generic/hiddev.c (modified) (10 diffs)
• uspace/drv/usbhid/kbd/kbddev.c (modified) (1 diff)
• uspace/drv/usbhid/mouse/mousedev.c (modified) (1 diff)
• uspace/drv/usbhid/multimedia/keymap.c (modified) (2 diffs)
• uspace/drv/usbhid/multimedia/keymap.h (modified) (1 diff)
• uspace/drv/usbhid/multimedia/multimedia.c (modified) (6 diffs)
• uspace/drv/usbhid/subdrivers.c (modified) (4 diffs)
• uspace/drv/usbhid/usbhid.c (modified) (9 diffs)
• uspace/drv/usbhid/usbhid.h (modified) (2 diffs)
• uspace/drv/usbhub/usbhub.c (modified) (6 diffs)
• uspace/lib/drv/Makefile (modified) (1 diff)
• uspace/lib/drv/generic/dev_iface.c (modified) (2 diffs)
• uspace/lib/drv/generic/driver.c (modified) (1 diff)
• uspace/lib/drv/generic/remote_usbhid.c (modified) (6 diffs)
• uspace/lib/drv/include/remote_pci.h (modified) (1 diff)
• uspace/lib/drv/include/remote_usb.h (modified) (1 diff)
• uspace/lib/drv/include/remote_usbhc.h (modified) (1 diff)
• uspace/lib/drv/include/remote_usbhid.h (modified) (1 diff)
• uspace/lib/drv/include/usbhid_iface.h (modified) (4 diffs)
• uspace/lib/usbdev/src/hub.c (modified) (1 diff)
• uspace/lib/usbhid/Makefile (modified) (1 diff)
• uspace/lib/usbhid/include/usb/hid/hid_report_items.h (modified) (1 diff)
• uspace/lib/usbhid/include/usb/hid/hiddescriptor.h (modified) (3 diffs)
• uspace/lib/usbhid/include/usb/hid/hidparser.h (modified) (1 diff)
• uspace/lib/usbhid/include/usb/hid/hidpath.h (modified) (3 diffs)
• uspace/lib/usbhid/include/usb/hid/hidreport.h (modified) (2 diffs)
• uspace/lib/usbhid/include/usb/hid/hidtypes.h (modified) (3 diffs)
• uspace/lib/usbhid/include/usb/hid/iface.h (modified) (1 diff)
• uspace/lib/usbhid/include/usb/hid/usages/consumer.h (moved) (moved from uspace/drv/uhci-hcd/utils/slab.h ) (2 diffs)
• uspace/lib/usbhid/src/consumer.c (added)
• uspace/lib/usbhid/src/hiddescriptor.c (modified) (30 diffs)
• uspace/lib/usbhid/src/hidiface.c (modified) (4 diffs)
• uspace/lib/usbhid/src/hidparser.c (modified) (30 diffs)
• uspace/lib/usbhid/src/hidpath.c (modified) (13 diffs)
• uspace/lib/usbhid/src/hidreport.c (modified) (2 diffs)

HelenOS.config

@@ -570 +570 @@
 
 % USB release build (less logging)
-! CONFIG_USB_RELEASE_BUILD (n/y)
+! CONFIG_USB_RELEASE_BUILD (y/n)
 
 % Start virtual USB host controller
@@ -576 +576 @@
 
 % Polling UHCI & OHCI (no interrupts)
-! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
+! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (n/y)
 
 % Run devman in kconsole (not recommended)

uspace/app/mkbd/Makefile

@@ -31 +31 @@
 
 LIBS = \
+        $(LIBUSBHID_PREFIX)/libusbhid.a \
         $(LIBUSBDEV_PREFIX)/libusbdev.a \
         $(LIBUSB_PREFIX)/libusb.a \
-        $(LIBDRV_PREFIX)/libdrv.a
+        $(LIBDRV_PREFIX)/libdrv.a 
 EXTRA_CFLAGS = \
         -I$(LIBUSB_PREFIX)/include \
         -I$(LIBUSBDEV_PREFIX)/include \
-        -I$(LIBDRV_PREFIX)/include
+        -I$(LIBDRV_PREFIX)/include \
+        -I$(LIBUSBHID_PREFIX)/include 
 
 SOURCES = \

uspace/app/mkbd/main.c

@@ -45 +45 @@
 #include <devmap.h>
 #include <usb/dev/hub.h>
-#include <usb/hc.h>
+//#include <usb/host.h>
+//#include <usb/driver.h>
+#include <usb/hid/iface.h>
 #include <usb/dev/pipes.h>
+#include <async.h>
+#include <usb/hid/usages/core.h>
+#include <usb/hid/hidparser.h>
+#include <usb/hid/hiddescriptor.h>
+#include <usb/hid/usages/consumer.h>
+#include <assert.h>
 
 #define NAME "mkbd"
@@ -52 +60 @@
 static int dev_phone = -1;
 
-//static void print_found_hc(size_t class_index, const char *path)
-//{
-//      // printf(NAME ": host controller %zu is `%s'.\n", class_index, path);
-//      printf("Bus %02zu: %s\n", class_index, path);
-//}
-//static void print_found_dev(usb_address_t addr, const char *path)
-//{
-//      // printf(NAME ":     device with address %d is `%s'.\n", addr, path);
-//      printf("  Device %02d: %s\n", addr, path);
-//}
-
-//static void print_hc_devices(devman_handle_t hc_handle)
-//{
-//      int rc;
-//      usb_hc_connection_t conn;
-
-//      usb_hc_connection_initialize(&conn, hc_handle);
-//      rc = usb_hc_connection_open(&conn);
-//      if (rc != EOK) {
-//              printf(NAME ": failed to connect to HC: %s.\n",
-//                  str_error(rc));
-//              return;
+static int initialize_report_parser(int dev_phone, usb_hid_report_t **report)
+{
+        *report = (usb_hid_report_t *)malloc(sizeof(usb_hid_report_t));
+        if (*report == NULL) {
+                return ENOMEM;
+        }
+        
+        int rc = usb_hid_report_init(*report);
+        if (rc != EOK) {
+                usb_hid_free_report(*report);
+                *report = NULL;
+                printf("usb_hid_report_init() failed.\n");
+                return rc;
+        }
+        
+        // get the report descriptor length from the device
+        size_t report_desc_size;
+        rc = usbhid_dev_get_report_descriptor_length(
+            dev_phone, &report_desc_size);
+        if (rc != EOK) {
+                usb_hid_free_report(*report);
+                *report = NULL;
+                printf("usbhid_dev_get_report_descriptor_length() failed.\n");
+                return rc;
+        }
+        
+        if (report_desc_size == 0) {
+                usb_hid_free_report(*report);
+                *report = NULL;
+                printf("usbhid_dev_get_report_descriptor_length() returned 0.\n");
+                return EINVAL;  // TODO: other error code?
+        }
+        
+        uint8_t *desc = (uint8_t *)malloc(report_desc_size);
+        if (desc == NULL) {
+                usb_hid_free_report(*report);
+                *report = NULL;
+                return ENOMEM;
+        }
+        
+        // get the report descriptor from the device
+        size_t actual_size;
+        rc = usbhid_dev_get_report_descriptor(dev_phone, desc, report_desc_size,
+            &actual_size);
+        if (rc != EOK) {
+                usb_hid_free_report(*report);
+                *report = NULL;
+                free(desc);
+                printf("usbhid_dev_get_report_descriptor() failed.\n");
+                return rc;
+        }
+        
+        if (actual_size != report_desc_size) {
+                usb_hid_free_report(*report);
+                *report = NULL;
+                free(desc);
+                printf("usbhid_dev_get_report_descriptor() returned wrong size:"
+                    " %zu, expected: %zu.\n", actual_size, report_desc_size);
+                return EINVAL;  // TODO: other error code?
+        }
+        
+        // initialize the report parser
+        
+        rc = usb_hid_parse_report_descriptor(*report, desc, report_desc_size);
+        free(desc);
+        
+        if (rc != EOK) {
+                free(desc);
+                printf("usb_hid_parse_report_descriptor() failed.\n");
+                return rc;
+        }
+        
+        return EOK;
+}
+
+static void print_key(uint8_t *buffer, size_t size, usb_hid_report_t *report)
+{
+        assert(buffer != NULL);
+        assert(report != NULL);
+        
+//      printf("Calling usb_hid_parse_report() with size %zu and "
+//          "buffer: \n", size);
+//      for (size_t i = 0; i < size; ++i) {
+//              printf(" %X ", buffer[i]);
 //      }
-//      usb_address_t addr;
-//      for (addr = 1; addr < 5; addr++) {
-//              devman_handle_t dev_handle;
-//              rc = usb_hc_get_handle_by_address(&conn, addr, &dev_handle);
-//              if (rc != EOK) {
-//                      continue;
-//              }
-//              char path[MAX_PATH_LENGTH];
-//              rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
-//              if (rc != EOK) {
-//                      continue;
-//              }
-//              print_found_dev(addr, path);
-//      }
-//      usb_hc_connection_close(&conn);
-//}
-
-static bool try_parse_class_and_address(const char *path,
-    devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
-{
-        size_t class_index;
-        size_t address;
-        int rc;
-        char *ptr;
-
-        rc = str_size_t(path, &ptr, 10, false, &class_index);
-        if (rc != EOK) {
-                return false;
-        }
-        if ((*ptr == ':') || (*ptr == '.')) {
-                ptr++;
-        } else {
-                return false;
-        }
-        rc = str_size_t(ptr, NULL, 10, true, &address);
-        if (rc != EOK) {
-                return false;
-        }
-        rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle);
-        if (rc != EOK) {
-                return false;
-        }
-        if (out_device_address != NULL) {
-                *out_device_address = (usb_address_t) address;
-        }
-        return true;
+//      printf("\n");
+        
+        uint8_t report_id;
+        int rc = usb_hid_parse_report(report, buffer, size, &report_id);
+        if (rc != EOK) {
+//              printf("Error parsing report: %s\n", str_error(rc));
+                return;
+        }
+        
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        if (path == NULL) {
+                return;
+        }
+        
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
+        
+        usb_hid_report_path_set_report_id(path, report_id);
+
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
+            report, NULL, path, USB_HID_PATH_COMPARE_END 
+            | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+            USB_HID_REPORT_TYPE_INPUT);
+        
+//      printf("Field: %p\n", field);
+        
+        while (field != NULL) {
+//              printf("Field usage: %u, field value: %d\n", field->usage, 
+//                  field->value);
+                if (field->value != 0) {
+                        const char *key_str = 
+                            usbhid_multimedia_usage_to_str(field->usage);
+                        printf("Pressed key: %s\n", key_str);
+                }
+                
+                field = usb_hid_report_get_sibling(
+                    report, field, path, USB_HID_PATH_COMPARE_END
+                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+                    USB_HID_REPORT_TYPE_INPUT);
+//              printf("Next field: %p\n", field);
+        }
+        
+        usb_hid_report_path_free(path);
 }
 
-static bool resolve_hc_handle_and_dev_addr(const char *devpath,
-    devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
-{
-        int rc;
-
-        /* Hack for QEMU to save-up on typing ;-). */
-        if (str_cmp(devpath, "qemu") == 0) {
-                devpath = "/hw/pci0/00:01.2/uhci-rh/usb00_a1";
-        }
-
-        /* Hack for virtual keyboard. */
-        if (str_cmp(devpath, "virt") == 0) {
-                devpath = "/virt/usbhc/usb00_a1/usb00_a2";
-        }
-
-        if (try_parse_class_and_address(devpath,
-            out_hc_handle, out_device_address)) {
-                return true;
-        }
-
-        char *path = str_dup(devpath);
-        if (path == NULL) {
-                return ENOMEM;
-        }
-
-        devman_handle_t hc = 0;
-        bool hc_found = false;
-        usb_address_t addr = 0;
-        bool addr_found = false;
-
-        /* Remove suffixes and hope that we will encounter device node. */
-        while (str_length(path) > 0) {
-                /* Get device handle first. */
-                devman_handle_t dev_handle;
-                rc = devman_device_get_handle(path, &dev_handle, 0);
-                if (rc != EOK) {
-                        free(path);
-                        return false;
-                }
-
-                /* Try to find its host controller. */
-                if (!hc_found) {
-                        rc = usb_hc_find(dev_handle, &hc);
-                        if (rc == EOK) {
-                                hc_found = true;
-                        }
-                }
-                /* Try to get its address. */
-                if (!addr_found) {
-                        addr = usb_hc_get_address_by_handle(dev_handle);
-                        if (addr >= 0) {
-                                addr_found = true;
-                        }
-                }
-
-                /* Speed-up. */
-                if (hc_found && addr_found) {
-                        break;
-                }
-
-                /* Remove the last suffix. */
-                char *slash_pos = str_rchr(path, '/');
-                if (slash_pos != NULL) {
-                        *slash_pos = 0;
-                }
-        }
-
-        free(path);
-
-        if (hc_found && addr_found) {
-                if (out_hc_handle != NULL) {
-                        *out_hc_handle = hc;
-                }
-                if (out_device_address != NULL) {
-                        *out_device_address = addr;
-                }
-                return true;
-        } else {
-                return false;
-        }
-}
+#define MAX_PATH_LENGTH 1024
 
 static void print_usage(char *app_name)
@@ -209 +195 @@
 #define _INDENT "      "
 
-        printf(NAME ": Print out what multimedia keys were pressed.\n\n");
-        printf("Usage: %s device\n", app_name);
-        printf(_INDENT "The device is a devman path to the device.\n");
+       printf(NAME ": Print out what multimedia keys were pressed.\n\n");
+       printf("Usage: %s device\n", app_name);
+       printf(_INDENT "The device is a devman path to the device.\n");
 
 #undef _OPTION
@@ -219 +205 @@
 int main(int argc, char *argv[])
 {
+        int act_event = -1;
         
         if (argc <= 1) {
@@ -226 +213 @@
         
         char *devpath = argv[1];
-
-        /* The initialization is here only to make compiler happy. */
-        devman_handle_t hc_handle = 0;
-        usb_address_t dev_addr = 0;
-        bool found = resolve_hc_handle_and_dev_addr(devpath,
-            &hc_handle, &dev_addr);
-        if (!found) {
-                fprintf(stderr, NAME ": device `%s' not found "
-                    "or not of USB kind. Exiting.\n", devpath);
-                return -1;
-        }
+        //const char *devpath = "/hw/pci0/00:06.0/ohci-rh/usb00_a2/HID1/hid";
         
         int rc;
-        usb_hc_connection_t conn;
-
-        usb_hc_connection_initialize(&conn, hc_handle);
-        rc = usb_hc_connection_open(&conn);
-        if (rc != EOK) {
-                printf(NAME ": failed to connect to HC: %s.\n",
+        
+        devman_handle_t dev_handle = 0;
+        rc = devman_device_get_handle(devpath, &dev_handle, 0);
+        if (rc != EOK) {
+                printf("Failed to get handle from devman: %s.\n",
                     str_error(rc));
-                return -1;
-        }
-        usb_address_t addr = 0;
-
-        devman_handle_t dev_handle;
-        rc = usb_hc_get_handle_by_address(&conn, addr, &dev_handle);
-        if (rc != EOK) {
-                printf(NAME ": failed getting handle to the device: %s.\n",
-                       str_error(rc));
-                return -1;
-        }
-
-        usb_hc_connection_close(&conn);
+                return rc;
+        }
         
         rc = devman_device_connect(dev_handle, 0);
         if (rc < 0) {
-                printf(NAME ": failed to connect to the device: %s.\n",
-                       str_error(rc));
-                return -1;
+                printf(NAME ": failed to connect to the device (handle %"
+                       PRIun "): %s.\n", dev_handle, str_error(rc));
+                return rc;
         }
         
         dev_phone = rc;
-        printf("Got phone to the device: %d\n", dev_phone);
-        
-        
-//      size_t class_index = 0;
-//      size_t failed_attempts = 0;
-
-//      while (failed_attempts < MAX_FAILED_ATTEMPTS) {
-//              class_index++;
-//              devman_handle_t hc_handle = 0;
-//              int rc = usb_ddf_get_hc_handle_by_class(class_index, &hc_handle);
-//              if (rc != EOK) {
-//                      failed_attempts++;
-//                      continue;
-//              }
-//              char path[MAX_PATH_LENGTH];
-//              rc = devman_get_device_path(hc_handle, path, MAX_PATH_LENGTH);
-//              if (rc != EOK) {
-//                      continue;
-//              }
-//              print_found_hc(class_index, path);
-//              print_hc_devices(hc_handle);
-//      }
+//      printf("Got phone to the device: %d\n", dev_phone);
+        
+        char path[MAX_PATH_LENGTH];
+        rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
+        if (rc != EOK) {
+                return ENOMEM;
+        }
+        
+        printf("Device path: %s\n", path);
+        
+        
+        usb_hid_report_t *report = NULL;
+        rc = initialize_report_parser(dev_phone, &report);
+        if (rc != EOK) {
+                printf("Failed to initialize report parser: %s\n",
+                    str_error(rc));
+                return rc;
+        }
+        
+        assert(report != NULL);
+        
+        size_t size;
+        rc = usbhid_dev_get_event_length(dev_phone, &size);
+        if (rc != EOK) {
+                printf("Failed to get event length: %s.\n", str_error(rc));
+                return rc;
+        }
+        
+//      printf("Event length: %zu\n", size);
+        uint8_t *event = (uint8_t *)malloc(size);
+        if (event == NULL) {
+                // hangup phone?
+                return ENOMEM;
+        }
+        
+//      printf("Event length: %zu\n", size);
+        
+        size_t actual_size;
+        int event_nr;
+        
+        while (1) {
+                // get event from the driver
+//              printf("Getting event from the driver.\n");
+                
+                /** @todo Try blocking call. */
+                rc = usbhid_dev_get_event(dev_phone, event, size, &actual_size, 
+                    &event_nr, 0);
+                if (rc != EOK) {
+                        // hangup phone?
+                        printf("Error in getting event from the HID driver:"
+                            "%s.\n", str_error(rc));
+                        break;
+                }
+                
+//              printf("Got buffer: %p, size: %zu, max size: %zu\n", event, 
+//                  actual_size, size);
+                
+//              printf("Event number: %d, my actual event: %d\n", event_nr, 
+//                  act_event);
+                if (event_nr > act_event) {
+                        print_key(event, size, report);
+                        act_event = event_nr;
+                }
+                
+                async_usleep(10000);
+        }
         
         return 0;

uspace/drv/ohci/hc.c

@@ -343 +343 @@
 {
         assert(instance);
-        usb_log_debug("OHCI(%p) interrupt: %x.\n", instance, status);
         if ((status & ~I_SF) == 0) /* ignore sof status */
                 return;
+        usb_log_debug2("OHCI(%p) interrupt: %x.\n", instance, status);
         if (status & I_RHSC)
                 rh_interrupt(&instance->rh);
@@ -565 +565 @@
         bzero(&instance->rh, sizeof(instance->rh));
         /* Init queues */
-        hc_init_transfer_lists(instance);
+        const int ret = hc_init_transfer_lists(instance);
+        if (ret != EOK) {
+                return ret;
+        }
 
         /*Init HCCA */

uspace/drv/ohci/root_hub.c

@@ -61 +61 @@
         .vendor_id = 0x16db,
         .product_id = 0x0001,
-        /// \TODO these values migt be different
         .str_serial_number = 0,
         .usb_spec_version = 0x110,
@@ -119 +118 @@
 static const uint32_t hub_clear_feature_by_writing_one_mask =
    RHS_CLEAR_PORT_POWER;
-   // 1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
 
 /**
@@ -127 +125 @@
     RHS_LPSC_FLAG |
     RHS_OCIC_FLAG;
-    //(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
-    //(1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
 
 /**
@@ -135 +131 @@
 static const uint32_t hub_set_feature_direct_mask =
     RHS_SET_PORT_POWER;
-    //(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
 
 /**
@@ -160 +155 @@
     RHPS_PRSC_FLAG;
 
-/*
-
-    (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
-    (1 << USB_HUB_FEATURE_PORT_SUSPEND) |
-    (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) |
-    (1 << USB_HUB_FEATURE_PORT_POWER) |
-    (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) |
-    (1 << USB_HUB_FEATURE_C_PORT_ENABLE) |
-    (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) |
-    (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
-    (1 << USB_HUB_FEATURE_C_PORT_RESET);
- */
 //note that USB_HUB_FEATURE_PORT_POWER bit is translated into
 //USB_HUB_FEATURE_PORT_LOW_SPEED for port set feature request
@@ -179 +162 @@
  */
 static const uint32_t port_status_change_mask = RHPS_CHANGE_WC_MASK;
-/*    (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) |
-    (1 << USB_HUB_FEATURE_C_PORT_ENABLE) |
-    (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
-    (1 << USB_HUB_FEATURE_C_PORT_RESET) |
-    (1 << USB_HUB_FEATURE_C_PORT_SUSPEND);
-*/
 
 static int create_serialized_hub_descriptor(rh_t *instance);
@@ -420 +397 @@
  * create answer to port status_request
  *
- * Copy content of corresponding port status register to answer buffer.
+ * Copy content of corresponding port status register to answer buffer. The
+ * format of the port status register and port status data is the same (
+ * see OHCI root hub and USB hub documentation).
  *
  * @param instance root hub instance
@@ -431 +410 @@
         if (port < 1 || port > instance->port_count)
                 return EINVAL;
-        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
-        uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
+        uint32_t data = instance->registers->rh_port_status[port - 1];
+        memcpy(request->data_buffer,&data,4);
 #if 0
         int i;
@@ -450 +429 @@
  * create answer to port status_request
  *
- * Copy content of hub status register to answer buffer.
+ * This copies flags in hub status register into the buffer. The format of the
+ * status register and status message is the same, according to USB hub
+ * specification and OHCI root hub specification.
  *
  * @param instance root hub instance
@@ -458 +439 @@
 static int process_get_hub_status_request(rh_t *instance,
     usb_transfer_batch_t * request) {
-        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
+        //uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
         //bits, 0,1,16,17
         uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
-        uint32_buffer[0] = mask & instance->registers->rh_status;
+        uint32_t data = mask & instance->registers->rh_status;
+        //uint32_buffer[0] = mask & instance->registers->rh_status;
+        memcpy(request->data_buffer,&data,4);
 
         return EOK;
@@ -516 +499 @@
             | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
         bzero(bitmap, instance->interrupt_mask_size);
-        if (instance->registers->rh_status & mask) {
+        if ((instance->registers->rh_status & mask) !=0 ) {
                 bitmap[0] = 1;
         }
@@ -522 +505 @@
         mask = port_status_change_mask;
         for (port = 1; port <= instance->port_count; ++port) {
-                if (mask & instance->registers->rh_port_status[port - 1]) {
+                if ((mask & instance->registers->rh_port_status[port - 1]) != 0) {
 
                         bitmap[(port) / 8] += 1 << (port % 8);

uspace/drv/uhci-hcd/Makefile

@@ -48 +48 @@
         root_hub.c \
         hw_struct/transfer_descriptor.c \
-        utils/slab.c \
         pci.c \
         batch.c

uspace/drv/uhci-hcd/batch.h

@@ -35 +35 @@
 #define DRV_UHCI_BATCH_H
 
-#include <usbhc_iface.h>
-#include <usb/usb.h>
-#include <usb/host/device_keeper.h>
-#include <usb/host/endpoint.h>
 #include <usb/host/batch.h>
 

uspace/drv/uhci-hcd/hc.c

@@ -39 +39 @@
 #include <usb/debug.h>
 #include <usb/usb.h>
-#include <usb/ddfiface.h>
-#include <usb_iface.h>
 
 #include "hc.h"
@@ -85 +83 @@
         /* allow access to hc control registers */
         regs_t *io;
-        ret = pio_enable(regs, reg_size, (void**)&io);
+        ret = pio_enable(regs, reg_size, (void **)&io);
         CHECK_RET_RETURN(ret,
             "Failed(%d) to gain access to registers at %p: %s.\n",
@@ -143 +141 @@
         }
 
-        uint16_t status = pio_read_16(&registers->usbcmd);
+        const uint16_t status = pio_read_16(&registers->usbcmd);
         if (status != 0)
                 usb_log_warning("Previous command value: %x.\n", status);
@@ -212 +210 @@
         /* Init USB frame list page*/
         instance->frame_list = get_page();
-        ret = instance ? EOK : ENOMEM;
+        ret = instance->frame_list ? EOK : ENOMEM;
         CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
         usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
@@ -277 +275 @@
                 &instance->transfers_control_slow);
 
-        /*FSBR*/
+        /*FSBR, This feature is not needed (adds no benefit) and is supposedly
+         * buggy on certain hw, enable at your own risk. */
 #ifdef FSBR
         transfer_list_set_next(&instance->transfers_bulk_full,
@@ -428 +427 @@
                 }
 
-                uintptr_t frame_list =
+                const uintptr_t frame_list =
                     pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
                 if (frame_list != addr_to_phys(instance->frame_list)) {

uspace/drv/uhci-hcd/hc.h

@@ -37 +37 @@
 
 #include <fibril.h>
-#include <fibril_synch.h>
-#include <adt/list.h>
 #include <ddi.h>
 
-#include <usbhc_iface.h>
 #include <usb/host/device_keeper.h>
 #include <usb/host/usb_endpoint_manager.h>
+#include <usb/host/batch.h>
 
-#include "batch.h"
 #include "transfer_list.h"
 
@@ -154 +151 @@
  */
 static inline hc_t * fun_to_hc(ddf_fun_t *fun)
-        { return (hc_t*)fun->driver_data; }
+{
+        assert(fun);
+        return fun->driver_data;
+}
 #endif
 /**

uspace/drv/uhci-hcd/iface.c

@@ -39 +39 @@
 
 #include "iface.h"
+#include "batch.h"
 #include "hc.h"
 
@@ -122 +123 @@
         return EOK;
 }
-
+/*----------------------------------------------------------------------------*/
 /** Find device handle by address interface function.
  *
@@ -136 +137 @@
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
-        bool found =
+        const bool found =
             usb_device_keeper_find_by_address(&hc->manager, address, handle);
         return found ? EOK : ENOENT;
 }
-
 /*----------------------------------------------------------------------------*/
 /** Release address interface function
@@ -164 +164 @@
     size_t max_packet_size, unsigned int interval)
 {
+        assert(fun);
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
@@ -183 +184 @@
     usb_endpoint_t endpoint, usb_direction_t direction)
 {
+        assert(fun);
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
@@ -211 +213 @@
         if (ret != EOK)
                 return ret;
+        assert(batch);
+        assert(hc);
         batch_interrupt_out(batch);
         ret = hc_schedule(hc, batch);
@@ -239 +243 @@
         if (ret != EOK)
                 return ret;
+        assert(batch);
+        assert(hc);
         batch_interrupt_in(batch);
         ret = hc_schedule(hc, batch);
@@ -267 +273 @@
         if (ret != EOK)
                 return ret;
+        assert(batch);
+        assert(hc);
         batch_bulk_out(batch);
         ret = hc_schedule(hc, batch);
@@ -295 +303 @@
         if (ret != EOK)
                 return ret;
+        assert(batch);
+        assert(hc);
         batch_bulk_in(batch);
         ret = hc_schedule(hc, batch);
@@ -327 +337 @@
         if (ret != EOK)
                 return ret;
+        assert(batch);
+        assert(hc);
         usb_endpoint_manager_reset_if_need(&hc->ep_manager, target, setup_data);
         batch_control_write(batch);
@@ -360 +372 @@
         if (ret != EOK)
                 return ret;
+        assert(batch);
+        assert(hc);
         batch_control_read(batch);
         ret = hc_schedule(hc, batch);

uspace/drv/uhci-hcd/pci.c

@@ -52 +52 @@
  * @return Error code.
  */
-int pci_get_my_registers(ddf_dev_t *dev,
+int pci_get_my_registers(const ddf_dev_t *dev,
     uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
 {
-        assert(dev != NULL);
+        assert(dev);
+        assert(io_reg_address);
+        assert(io_reg_size);
+        assert(irq_no);
 
         int parent_phone =
@@ -66 +69 @@
         int rc = hw_res_get_resource_list(parent_phone, &hw_resources);
         if (rc != EOK) {
-                goto leave;
+                async_hangup(parent_phone);
+                return rc;
         }
 
@@ -78 +82 @@
         size_t i;
         for (i = 0; i < hw_resources.count; i++) {
-                hw_resource_t *res = &hw_resources.resources[i];
+                const hw_resource_t *res = &hw_resources.resources[i];
                 switch (res->type)
                 {
@@ -99 +103 @@
                 }
         }
+        async_hangup(parent_phone);
 
-        if (!io_found || !irq_found) {
-                rc = ENOENT;
-                goto leave;
-        }
+        if (!io_found || !irq_found)
+                return ENOENT;
 
         *io_reg_address = io_address;
@@ -109 +112 @@
         *irq_no = irq;
 
-        rc = EOK;
-leave:
-        async_hangup(parent_phone);
-        return rc;
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -120 +120 @@
  * @return Error code.
  */
-int pci_enable_interrupts(ddf_dev_t *device)
+int pci_enable_interrupts(const ddf_dev_t *device)
 {
-        int parent_phone = devman_parent_device_connect(device->handle,
-            IPC_FLAG_BLOCKING);
-        bool enabled = hw_res_enable_interrupt(parent_phone);
+        const int parent_phone =
+            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
+        if (parent_phone < 0) {
+                return parent_phone;
+        }
+        const bool enabled = hw_res_enable_interrupt(parent_phone);
         async_hangup(parent_phone);
         return enabled ? EOK : EIO;
@@ -134 +137 @@
  * @return Error code.
  */
-int pci_disable_legacy(ddf_dev_t *device)
+int pci_disable_legacy(const ddf_dev_t *device)
 {
         assert(device);
-        int parent_phone =
+        const int parent_phone =
             devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
@@ -145 +148 @@
         /* See UHCI design guide for these values p.45,
          * write all WC bits in USB legacy register */
-        sysarg_t address = 0xc0;
-        sysarg_t value = 0xaf00;
+        const sysarg_t address = 0xc0;
+        const sysarg_t value = 0xaf00;
 
-        int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
+        const int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
             IPC_M_CONFIG_SPACE_WRITE_16, address, value);
         async_hangup(parent_phone);

uspace/drv/uhci-hcd/pci.h

@@ -38 +38 @@
 #include <ddf/driver.h>
 
-int pci_get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
-int pci_enable_interrupts(ddf_dev_t *);
-int pci_disable_legacy(ddf_dev_t *);
+int pci_get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
+int pci_enable_interrupts(const ddf_dev_t *);
+int pci_disable_legacy(const ddf_dev_t *);
 
 #endif

uspace/drv/uhci-hcd/root_hub.c

@@ -60 +60 @@
                 return ret;
         }
+        assert(match_str);
 
         ret = ddf_fun_add_match_id(fun, match_str, 100);

uspace/drv/uhci-hcd/root_hub.h

@@ -43 +43 @@
         /** List of resources available to the root hub. */
         hw_resource_list_t resource_list;
-        /** The only resource in the above list */
+        /** The only resource in the RH resource list */
         hw_resource_t io_regs;
 } rh_t;

uspace/drv/uhci-hcd/transfer_list.c

@@ -36 +36 @@
 #include <arch/barrier.h>
 
+
 #include "transfer_list.h"
+#include "batch.h"
 
 static void transfer_list_remove_batch(
@@ -58 +60 @@
                 return ENOMEM;
         }
-        uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
+        const uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
         usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).\n",
             name, instance->queue_head, queue_head_pa);
@@ -90 +92 @@
 {
         assert(instance);
+        assert(instance->queue_head);
         assert(next);
-        if (!instance->queue_head)
-                return;
         /* Set queue_head.next to point to the follower */
         qh_set_next_qh(instance->queue_head, next->queue_head);
@@ -137 +138 @@
         write_barrier();
 
-        /* Add to the driver list */
+        /* Add to the driver's list */
         list_append(&batch->link, &instance->batch_list);
 
@@ -160 +161 @@
         link_t *current = instance->batch_list.next;
         while (current != &instance->batch_list) {
-                link_t *next = current->next;
+                link_t * const next = current->next;
                 usb_transfer_batch_t *batch =
                     usb_transfer_batch_from_link(current);
@@ -182 +183 @@
         fibril_mutex_lock(&instance->guard);
         while (!list_empty(&instance->batch_list)) {
-                link_t *current = instance->batch_list.next;
+                link_t * const current = instance->batch_list.next;
                 usb_transfer_batch_t *batch =
                     usb_transfer_batch_from_link(current);

uspace/drv/uhci-hcd/transfer_list.h

@@ -36 +36 @@
 
 #include <fibril_synch.h>
+#include <usb/host/batch.h>
 
-#include "batch.h"
 #include "hw_struct/queue_head.h"
 

uspace/drv/uhci-hcd/uhci.c

@@ -61 +61 @@
 } uhci_t;
 
-static inline uhci_t * dev_to_uhci(ddf_dev_t *dev)
+static inline uhci_t * dev_to_uhci(const ddf_dev_t *dev)
 {
         assert(dev);
@@ -77 +77 @@
 {
         assert(dev);
-        hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
-        uint16_t status = IPC_GET_ARG1(*call);
+        uhci_t *uhci = dev_to_uhci(dev);
+        hc_t *hc = &uhci->hc;
+        const uint16_t status = IPC_GET_ARG1(*call);
         assert(hc);
         hc_interrupt(hc, status);
 }
+/*----------------------------------------------------------------------------*/
+/** Operations supported by the HC driver */
+static ddf_dev_ops_t hc_ops = {
+        .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
+};
 /*----------------------------------------------------------------------------*/
 /** Get address of the device identified by handle.
@@ -113 +119 @@
  * @return Error code.
  */
-static int usb_iface_get_hc_handle(
-    ddf_fun_t *fun, devman_handle_t *handle)
+static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
 {
         assert(fun);
@@ -131 +136 @@
 };
 /*----------------------------------------------------------------------------*/
-/** Operations supported by the HC driver */
-static ddf_dev_ops_t hc_ops = {
-        .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
-};
-/*----------------------------------------------------------------------------*/
 /** Get root hub hw resources (I/O registers).
  *
@@ -144 +144 @@
 {
         assert(fun);
-        return &((rh_t*)fun->driver_data)->resource_list;
+        rh_t *rh = fun->driver_data;
+        assert(rh);
+        return &rh->resource_list;
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci-hcd/uhci.h

@@ -35 +35 @@
 #ifndef DRV_UHCI_UHCI_H
 #define DRV_UHCI_UHCI_H
-#include <ddi.h>
 #include <ddf/driver.h>
 

uspace/drv/uhci-hcd/utils/malloc32.h

@@ -41 +41 @@
 #include <as.h>
 
-#include "slab.h"
-
 #define UHCI_STRCUTURES_ALIGNMENT 16
 #define UHCI_REQUIRED_PAGE_SIZE 4096
@@ -59 +57 @@
         uintptr_t result;
         const int ret = as_get_physical_mapping(addr, &result);
-        assert(ret == EOK);
-
         if (ret != EOK)
                 return 0;
@@ -72 +68 @@
  */
 static inline void * malloc32(size_t size) {
-        if (size <= SLAB_ELEMENT_SIZE)
-                return slab_malloc_g();
-        usb_log_warning("Requested %zu bytes, current allocator can't handle "
-            "that amount, pray that the standard malloc will suffice.", size);
-        return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
+        /* This works only when the host has less than 4GB of memory as
+         * physical address needs to fit into 32 bits */
+
+        /* If we need more than one page there is no guarantee that the
+         * memory will be continuous */
+        if (size > PAGE_SIZE)
+                return NULL;
+        /* Calculate alignment to make sure the block won't cross page
+         * boundary */
+        size_t alignment = UHCI_STRCUTURES_ALIGNMENT;
+        while (alignment < size)
+                alignment *= 2;
+        return memalign(alignment, size);
 }
 /*----------------------------------------------------------------------------*/
@@ -86 +90 @@
         if (!addr)
                 return;
-        if (slab_in_range_g(addr))
-                return slab_free_g(addr);
         free(addr);
 }
@@ -98 +100 @@
 {
         void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
-        assert(free_address); /* TODO: remove this assert */
         if (free_address == 0)
                 return NULL;

uspace/drv/uhci-rhd/main.c

@@ -37 +37 @@
 #include <errno.h>
 #include <str_error.h>
+
 #include <usb_iface.h>
 #include <usb/ddfiface.h>
@@ -45 +46 @@
 #define NAME "uhci-rhd"
 
-static int hc_get_my_registers(ddf_dev_t *dev,
+static int hc_get_my_registers(const ddf_dev_t *dev,
     uintptr_t *io_reg_address, size_t *io_reg_size);
 /*----------------------------------------------------------------------------*/
@@ -130 +131 @@
  */
 int hc_get_my_registers(
-    ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
+    const ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
 {
-        assert(dev != NULL);
+        assert(dev);
 
-        int parent_phone = devman_parent_device_connect(dev->handle,
+        const int parent_phone = devman_parent_device_connect(dev->handle,
             IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
@@ -141 +142 @@
 
         hw_resource_list_t hw_resources;
-        int ret = hw_res_get_resource_list(parent_phone, &hw_resources);
+        const int ret = hw_res_get_resource_list(parent_phone, &hw_resources);
         if (ret != EOK) {
                 async_hangup(parent_phone);

uspace/drv/uhci-rhd/port.c

@@ -36 +36 @@
 #include <errno.h>
 #include <str_error.h>
-#include <time.h>
 #include <async.h>
 
@@ -82 +81 @@
  * @param[in] number Port number.
  * @param[in] usec Polling interval.
- * @param[in] rh Pointer to ddf instance fo the root hub driver.
+ * @param[in] rh Pointer to ddf instance of the root hub driver.
  * @return Error code.
  *
@@ -91 +90 @@
 {
         assert(port);
-        asprintf(&port->id_string, "Port (%p - %u)", port, number);
-        if (port->id_string == NULL) {
+        char *id_string;
+        asprintf(&id_string, "Port (%p - %u)", port, number);
+        if (id_string == NULL) {
                 return ENOMEM;
         }
 
+        port->id_string = id_string;
         port->address = address;
         port->number = number;
@@ -105 +106 @@
             usb_hc_connection_initialize_from_device(&port->hc_connection, rh);
         if (ret != EOK) {
-                usb_log_error("Failed to initialize connection to HC.");
+                usb_log_error("%s: failed to initialize connection to HC.",
+                    port->id_string);
+                free(id_string);
                 return ret;
         }
@@ -113 +116 @@
                 usb_log_error("%s: failed to create polling fibril.",
                     port->id_string);
+                free(id_string);
                 return ENOMEM;
         }
@@ -132 +136 @@
         assert(port);
         free(port->id_string);
-        /* TODO: Kill fibril here */
+        // TODO: Kill fibril here
         return;
 }
@@ -150 +154 @@
 
                 /* Read register value */
-                port_status_t port_status = uhci_port_read_status(instance);
+                const port_status_t port_status =
+                    uhci_port_read_status(instance);
 
                 /* Print the value if it's interesting */
@@ -161 +166 @@
                 usb_log_debug("%s: Connected change detected: %x.\n",
                     instance->id_string, port_status);
-
-                int rc =
-                    usb_hc_connection_open(&instance->hc_connection);
-                if (rc != EOK) {
-                        usb_log_error("%s: Failed to connect to HC.",
-                            instance->id_string);
-                        continue;
-                }
 
                 /* Remove any old device */
@@ -175 +172 @@
                             instance->id_string);
                         uhci_port_remove_device(instance);
+                }
+
+                int ret =
+                    usb_hc_connection_open(&instance->hc_connection);
+                if (ret != EOK) {
+                        usb_log_error("%s: Failed to connect to HC.",
+                            instance->id_string);
+                        continue;
                 }
 
@@ -190 +195 @@
                 }
 
-                rc = usb_hc_connection_close(&instance->hc_connection);
-                if (rc != EOK) {
+                ret = usb_hc_connection_close(&instance->hc_connection);
+                if (ret != EOK) {
                         usb_log_error("%s: Failed to disconnect.",
                             instance->id_string);
@@ -209 +214 @@
 int uhci_port_reset_enable(int portno, void *arg)
 {
-        uhci_port_t *port = (uhci_port_t *) arg;
+        uhci_port_t *port = arg;
+        assert(port);
 
         usb_log_debug2("%s: new_device_enable_port.\n", port->id_string);
@@ -283 +289 @@
         usb_log_error("%s: Don't know how to remove device %" PRIun ".\n",
             port->id_string, port->attached_device);
+        port->attached_device = 0;
         return ENOTSUP;
 }

uspace/drv/uhci-rhd/port.h

@@ -57 +57 @@
 typedef struct uhci_port
 {
-        char *id_string;
+        const char *id_string;
         port_status_t *address;
         unsigned number;

uspace/drv/usbhid/generic/hiddev.c

@@ -62 +62 @@
 static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun);
 
-static int usb_generic_hid_get_event(ddf_fun_t *fun, int32_t *buffer, 
-    size_t size, size_t *act_size, unsigned int flags);
+static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer, 
+    size_t size, size_t *act_size, int *event_nr, unsigned int flags);
 
 static int usb_generic_hid_client_connected(ddf_fun_t *fun);
+
+static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun);
+
+static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc, 
+    size_t size, size_t *actual_size);
 
 /*----------------------------------------------------------------------------*/
@@ -71 +76 @@
 static usbhid_iface_t usb_generic_iface = {
         .get_event = usb_generic_hid_get_event,
-        .get_event_length = usb_generic_hid_get_event_length
+        .get_event_length = usb_generic_hid_get_event_length,
+        .get_report_descriptor_length = usb_generic_get_report_descriptor_length,
+        .get_report_descriptor = usb_generic_get_report_descriptor
 };
 
@@ -83 +90 @@
 static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun)
 {
-        if (fun == NULL || fun->driver_data) {
+        usb_log_debug2("Generic HID: Get event length (fun: %p, "
+            "fun->driver_data: %p.\n", fun, fun->driver_data);
+        
+        if (fun == NULL || fun->driver_data == NULL) {
                 return 0;
         }
@@ -89 +99 @@
         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
         
-        return hid_dev->input_report_size;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static int usb_generic_hid_get_event(ddf_fun_t *fun, int32_t *buffer, 
-    size_t size, size_t *act_size, unsigned int flags)
-{
-        if (fun == NULL || fun->driver_data) {
+        usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
+            hid_dev, hid_dev->max_input_report_size);
+        
+        return hid_dev->max_input_report_size;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer, 
+    size_t size, size_t *act_size, int *event_nr, unsigned int flags)
+{
+        usb_log_debug2("Generic HID: Get event.\n");
+        
+        if (fun == NULL || fun->driver_data == NULL || buffer == NULL
+            || act_size == NULL || event_nr == NULL) {
+                usb_log_debug("No function");
                 return EINVAL;
         }
@@ -104 +121 @@
         
         if (hid_dev->input_report_size > size) {
+                usb_log_debug("input_report_size > size (%zu, %zu)\n", 
+                    hid_dev->input_report_size, size);
                 return EINVAL;  // TODO: other error code
         }
         
         /*! @todo This should probably be atomic. */
-        if (usb_hid_report_ready()) {
-                memcpy(buffer, hid_dev->input_report, 
-                    hid_dev->input_report_size);
-                *act_size = hid_dev->input_report_size;
-                usb_hid_report_received();
-        }
+//      if (usb_hid_report_ready()) {
+//              usb_log_debug2("Report ready, size: %zu\n", 
+//                  hid_dev->input_report_size);
+                
+//              usb_hid_report_received();
+//      } else {
+//              memset(buffer, 0, hid_dev->input_report_size);
+//      }
+        memcpy(buffer, hid_dev->input_report, 
+            hid_dev->input_report_size);
+        *act_size = hid_dev->input_report_size;
+        *event_nr = usb_hid_report_number(hid_dev);
         
         // clear the buffer so that it will not be received twice
@@ -120 +145 @@
         // note that we already received this report
 //      report_received = true;
+        usb_log_debug2("OK\n");
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun)
+{
+        usb_log_debug("Generic HID: Get report descriptor length.\n");
+        
+        if (fun == NULL || fun->driver_data == NULL) {
+                usb_log_debug("No function");
+                return EINVAL;
+        }
+        
+        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        
+        usb_log_debug2("hid_dev->report_desc_size = %zu\n", 
+            hid_dev->report_desc_size);
+        
+        return hid_dev->report_desc_size;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc, 
+    size_t size, size_t *actual_size)
+{
+        usb_log_debug2("Generic HID: Get report descriptor.\n");
+        
+        if (fun == NULL || fun->driver_data == NULL) {
+                usb_log_debug("No function");
+                return EINVAL;
+        }
+        
+        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        
+        if (hid_dev->report_desc_size > size) {
+                return EINVAL;  // TODO: other error code
+        }
+        
+        memcpy(desc, hid_dev->report_desc, hid_dev->report_desc_size);
+        *actual_size = hid_dev->report_desc_size;
         
         return EOK;
@@ -128 +197 @@
 static int usb_generic_hid_client_connected(ddf_fun_t *fun)
 {
-        usb_hid_report_received();
+        usb_log_debug("Generic HID: Client connected.\n");
         return EOK;
 }
@@ -145 +214 @@
                 return ENOMEM;
         }
+        
+        fun->ops = &usb_generic_hid_ops;
+        fun->driver_data = hid_dev;
 
         int rc = ddf_fun_bind(fun);
@@ -154 +226 @@
         }
         
-        fun->ops = &usb_generic_hid_ops;
-        fun->driver_data = hid_dev;
+        usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
         
         return EOK;
@@ -176 +247 @@
     uint8_t *buffer, size_t buffer_size)
 {
-        usb_log_debug("usb_hid_polling_callback(%p, %p, %zu)\n",
+        usb_log_debug2("usb_hid_polling_callback(%p, %p, %zu)\n",
             hid_dev, buffer, buffer_size);
         usb_debug_str_buffer(buffer, buffer_size, 0);

uspace/drv/usbhid/kbd/kbddev.c

@@ -798 +798 @@
         }
         
+        usb_log_debug("%s function created. Handle: %" PRIun "\n",
+            HID_KBD_FUN_NAME, fun->handle);
+        
         usb_log_debug("Adding DDF function to class %s...\n", 
             HID_KBD_CLASS_NAME);

uspace/drv/usbhid/mouse/mousedev.c

@@ -234 +234 @@
         
         if (mouse_dev->mouse_phone < 0) {
-                usb_log_error(NAME " No console phone.\n");
-                return false;   // ??
+                usb_log_warning(NAME " No console phone.\n");
+                return true;
         }
 

uspace/drv/usbhid/multimedia/keymap.c

@@ -48 +48 @@
  */
 static int usb_hid_keymap_consumer[0x29c] = {
-        [0xf] = KC_F1, /* Just for testing purposes */
-        [0x5] = KC_F2, /* Just for testing purposes */
-        [0x8] = KC_F3, /* Just for testing purposes */
-        [0x6] = KC_F4, /* Just for testing purposes */
-        [0x7] = KC_F5, /* Just for testing purposes */
-        [0xc] = KC_F6, /* Just for testing purposes */
-        
         [0xb5] = 0,       /* Scan Next Track */
         [0xb6] = 0,       /* Scan Previous Track */
         [0xb7] = 0,       /* Stop */
         [0xb8] = 0,       /* Eject */
-        [0xcd] = KC_F2,   /* Play/Pause */
-        [0xe2] = KC_F3,   /* Mute */
-        [0xe9] = KC_F5,   /* Volume Increment */
-        [0xea] = KC_F4,   /* Volume Decrement */
-        [0x183] = 0,      /* AL Consumer Control Configuration */
+        [0xcd] = 0/*KC_F2*/,   /* Play/Pause */
+        [0xe2] = 0/*KC_F3*/,   /* Mute */
+        [0xe9] = 0/*KC_F5*/,   /* Volume Increment */
+        [0xea] = 0/*KC_F4*/,   /* Volume Decrement */
+        [0x183] = 0/*KC_F1*/,      /* AL Consumer Control Configuration */
         [0x18a] = 0,      /* AL Email Reader */
         [0x192] = 0,      /* AL Calculator */
         [0x221] = 0,      /* AC Search */
-        [0x223] = 0,      /* AC Home */
+        [0x223] = 0/*KC_F6*/,      /* AC Home */
         [0x224] = 0,      /* AC Back */
         [0x225] = 0,      /* AC Forward */
         [0x226] = 0,      /* AC Stop */
-        [0x227] = KC_F1,  /* AC Refresh */
-        [0x22a] = KC_F6   /* AC Bookmarks */
-};
-
-static const char *usb_hid_consumer_usage_str[0x29d] = {
-        [0x01] = "Consumer Control",
-        [0x02] = "Numeric Key Pad",
-        [0x03] = "Programmable Buttons",
-        [0x04] = "Microphone",
-        [0x05] = "Headphone",
-        [0x06] = "Graphic Equalizer",
-        [0x07] = "Reserved",
-        [0x08] = "Reserved",
-        [0x09] = "Reserved",
-        [0x0a] = "Reserved",
-        [0x0b] = "Reserved",
-        [0x0c] = "Reserved",
-        [0x0d] = "Reserved",
-        [0x0e] = "Reserved",
-        [0x0f] = "Reserved",
-        [0x10] = "Reserved",
-        [0x11] = "Reserved",
-        [0x12] = "Reserved",
-        [0x13] = "Reserved",
-        [0x14] = "Reserved",
-        [0x15] = "Reserved",
-        [0x16] = "Reserved",
-        [0x17] = "Reserved",
-        [0x18] = "Reserved",
-        [0x19] = "Reserved",
-        [0x1a] = "Reserved",
-        [0x1b] = "Reserved",
-        [0x1c] = "Reserved",
-        [0x1d] = "Reserved",
-        [0x1e] = "Reserved",
-        [0x1f] = "Reserved",
-        [0x20] = "+10",
-        [0x21] = "+100",
-        [0x22] = "AM/PM",
-        [0x23] = "Reserved",
-        [0x24] = "Reserved",
-        [0x25] = "Reserved",
-        [0x26] = "Reserved",
-        [0x27] = "Reserved",
-        [0x28] = "Reserved",
-        [0x29] = "Reserved",
-        [0x2a] = "Reserved",
-        [0x2b] = "Reserved",
-        [0x2c] = "Reserved",
-        [0x2d] = "Reserved",
-        [0x2e] = "Reserved",
-        [0x2f] = "Reserved",
-        [0x30] = "Reserved",
-        [0x31] = "Reserved",
-        [0x32] = "Reserved",
-        [0x33] = "Reserved",
-        [0x34] = "Reserved",
-        [0x35] = "Reserved",
-        [0x36] = "Reserved",
-        [0x37] = "Reserved",
-        [0x38] = "Reserved",
-        [0x39] = "Reserved",
-        [0x3a] = "Reserved",
-        [0x3b] = "Reserved",
-        [0x3c] = "Reserved",
-        [0x3d] = "Reserved",
-        [0x3e] = "Reserved",
-        [0x3f] = "Reserved",
-        [0x40] = "Menu",
-        [0x41] = "Menu Pick",
-        [0x42] = "Menu Up",
-        [0x43] = "Menu Down",
-        [0x44] = "Menu Left",
-        [0x45] = "Menu Right",
-        [0x46] = "Menu Escape",
-        [0x47] = "Menu Value Increase",
-        [0x48] = "Menu Value Decrease",
-        [0x49] = "Reserved",
-        [0x4a] = "Reserved",
-        [0x4b] = "Reserved",
-        [0x4c] = "Reserved",
-        [0x4d] = "Reserved",
-        [0x4e] = "Reserved",
-        [0x4f] = "Reserved",
-        [0x50] = "Reserved",
-        [0x51] = "Reserved",
-        [0x52] = "Reserved",
-        [0x53] = "Reserved",
-        [0x54] = "Reserved",
-        [0x55] = "Reserved",
-        [0x56] = "Reserved",
-        [0x57] = "Reserved",
-        [0x58] = "Reserved",
-        [0x59] = "Reserved",
-        [0x5a] = "Reserved",
-        [0x5b] = "Reserved",
-        [0x5c] = "Reserved",
-        [0x5d] = "Reserved",
-        [0x5e] = "Reserved",
-        [0x5f] = "Reserved",
-        [0x60] = "Data On Screen",
-        [0x61] = "Closed Caption",
-        [0x62] = "Closed Caption Select",
-        [0x63] = "VCR/TV",
-        [0x64] = "Broadcast Mode",
-        [0x65] = "Snapshot",
-        [0x66] = "Still",
-        [0x67] = "Reserved",
-        [0x68] = "Reserved",
-        [0x69] = "Reserved",
-        [0x6a] = "Reserved",
-        [0x6b] = "Reserved",
-        [0x6c] = "Reserved",
-        [0x6d] = "Reserved",
-        [0x6e] = "Reserved",
-        [0x6f] = "Reserved",
-        [0x70] = "Reserved",
-        [0x71] = "Reserved",
-        [0x72] = "Reserved",
-        [0x73] = "Reserved",
-        [0x74] = "Reserved",
-        [0x75] = "Reserved",
-        [0x76] = "Reserved",
-        [0x77] = "Reserved",
-        [0x78] = "Reserved",
-        [0x79] = "Reserved",
-        [0x7a] = "Reserved",
-        [0x7b] = "Reserved",
-        [0x7c] = "Reserved",
-        [0x7d] = "Reserved",
-        [0x7e] = "Reserved",
-        [0x7f] = "Reserved",
-        [0x80] = "Selection",
-        [0x81] = "Assign Selection",
-        [0x82] = "Mode Step",
-        [0x83] = "Recall Last",
-        [0x84] = "Enter Channel",
-        [0x85] = "Order Movie",
-        [0x86] = "Channel",
-        [0x87] = "Media Selection",
-        [0x88] = "Media Select Computer",
-        [0x89] = "Media Select TV",
-        [0x8a] = "Media Select WWW",
-        [0x8b] = "Media Select DVD",
-        [0x8c] = "Media Select Telephone",
-        [0x8d] = "Media Select Program Guide",
-        [0x8e] = "Media Select Video Phone",
-        [0x8f] = "Media Select Games",
-        [0x90] = "Media Select Messages",
-        [0x91] = "Media Select CD",
-        [0x92] = "Media Select VCR",
-        [0x93] = "Media Select Tuner",
-        [0x94] = "Quit",
-        [0x95] = "Help",
-        [0x96] = "Media Select Tape",
-        [0x97] = "Media Select Cable",
-        [0x98] = "Media Select Satellite",
-        [0x99] = "Media Select Security",
-        [0x9a] = "Media Select Home",
-        [0x9b] = "Media Select Call",
-        [0x9c] = "Channel Increment",
-        [0x9d] = "Channel Decrement",
-        [0x9e] = "Media Select SAP",
-        [0x9f] = "Reserved",
-        [0xa0] = "VCR Plus",
-        [0xa1] = "Once",
-        [0xa2] = "Daily",
-        [0xa3] = "Weekly",
-        [0xa4] = "Monthly",
-        [0xa5] = "Reserved",
-        [0xa6] = "Reserved",
-        [0xa7] = "Reserved",
-        [0xa8] = "Reserved",
-        [0xa9] = "Reserved",
-        [0xaa] = "Reserved",
-        [0xab] = "Reserved",
-        [0xac] = "Reserved",
-        [0xad] = "Reserved",
-        [0xae] = "Reserved",
-        [0xaf] = "Reserved",
-        [0xb0] = "Play",
-        [0xb1] = "Pause",
-        [0xb2] = "Record",
-        [0xb3] = "Fast Forward",
-        [0xb4] = "Rewind",
-        [0xb5] = "Scan Next Track",
-        [0xb6] = "Scan Previous Trac",
-        [0xb7] = "Stop",
-        [0xb8] = "Eject",
-        [0xb9] = "Random Play",
-        [0xba] = "Select Disc",
-        [0xbb] = "Enter Disc",
-        [0xbc] = "Repeat",
-        [0xbd] = "Tracking",
-        [0xbe] = "Track Normal",
-        [0xbf] = "Slow Tracking",
-        [0xc0] = "Frame Forward",
-        [0xc1] = "Frame Back",
-        [0xc2] = "Mark",
-        [0xc3] = "Clear Mark",
-        [0xc4] = "Repeat From Mark",
-        [0xc5] = "Return to Mark",
-        [0xc6] = "Search Mark Forward",
-        [0xc7] = "Search Mark Backwards",
-        [0xc8] = "Counter Reset",
-        [0xc9] = "Show Counter",
-        [0xca] = "Tracking Increment",
-        [0xcb] = "Tracking Decrement",
-        [0xcc] = "Stop/Eject",
-        [0xcd] = "Play/Pause",
-        [0xce] = "Play/Skip",
-        [0xcf] = "Reserved",
-        [0xd0] = "Reserved",
-        [0xd1] = "Reserved",
-        [0xd2] = "Reserved",
-        [0xd3] = "Reserved",
-        [0xd4] = "Reserved",
-        [0xd5] = "Reserved",
-        [0xd6] = "Reserved",
-        [0xd7] = "Reserved",
-        [0xd8] = "Reserved",
-        [0xd9] = "Reserved",
-        [0xda] = "Reserved",
-        [0xdb] = "Reserved",
-        [0xdc] = "Reserved",
-        [0xdd] = "Reserved",
-        [0xde] = "Reserved",
-        [0xdf] = "Reserved",
-        [0xe0] = "Volume",
-        [0xe1] = "Balance",
-        [0xe2] = "Mute",
-        [0xe3] = "Bass",
-        [0xe4] = "Treble",
-        [0xe5] = "Bass Boost",
-        [0xe6] = "Surround Mode",
-        [0xe7] = "Loudness",
-        [0xe8] = "MPX",
-        [0xe9] = "Volume Increment",
-        [0xea] = "Volume Decrement",
-        [0xeb] = "Reserved",
-        [0xec] = "Reserved",
-        [0xed] = "Reserved",
-        [0xee] = "Reserved",
-        [0xef] = "Reserved",
-        [0xf0] = "Speed Select",
-        [0xf1] = "Playback Speed",
-        [0xf2] = "Standard Play",
-        [0xf3] = "Long Play",
-        [0xf4] = "Extended Play",
-        [0xf5] = "Slow",
-        [0xf6] = "Reserved",
-        [0xf7] = "Reserved",
-        [0xf8] = "Reserved",
-        [0xf9] = "Reserved",
-        [0xfa] = "Reserved",
-        [0xfb] = "Reserved",
-        [0xfc] = "Reserved",
-        [0xfd] = "Reserved",
-        [0xfe] = "Reserved",
-        [0xff] = "Reserved",
-        [0x100] = "Fan Enable",
-        [0x101] = "Fan Speed",
-        [0x102] = "Light Enable",
-        [0x103] = "Light Illumination Level",
-        [0x104] = "Climate Control Enable",
-        [0x105] = "Room Temperature",
-        [0x106] = "Security Enable",
-        [0x107] = "Fire Alarm",
-        [0x108] = "Police Alarm",
-        [0x109] = "Proximity",
-        [0x10a] = "Motion",
-        [0x10b] = "Duress Alarm",
-        [0x10c] = "Holdup Alarm",
-        [0x10d] = "Medical Alarm",
-        [0x10e] = "Reserved",
-        [0x10f] = "Reserved",
-        [0x110] = "Reserved",
-        [0x111] = "Reserved",
-        [0x112] = "Reserved",
-        [0x113] = "Reserved",
-        [0x114] = "Reserved",
-        [0x115] = "Reserved",
-        [0x116] = "Reserved",
-        [0x117] = "Reserved",
-        [0x118] = "Reserved",
-        [0x119] = "Reserved",
-        [0x11a] = "Reserved",
-        [0x11b] = "Reserved",
-        [0x11c] = "Reserved",
-        [0x11d] = "Reserved",
-        [0x11e] = "Reserved",
-        [0x11f] = "Reserved",
-        [0x120] = "Reserved", 
-        [0x121] = "Reserved",
-        [0x122] = "Reserved",
-        [0x123] = "Reserved",
-        [0x124] = "Reserved",
-        [0x125] = "Reserved",
-        [0x126] = "Reserved",
-        [0x127] = "Reserved",
-        [0x128] = "Reserved",
-        [0x129] = "Reserved",
-        [0x12a] = "Reserved",
-        [0x12b] = "Reserved",
-        [0x12c] = "Reserved",
-        [0x12d] = "Reserved",
-        [0x12e] = "Reserved",
-        [0x12f] = "Reserved",
-        [0x130] = "Reserved", 
-        [0x131] = "Reserved",
-        [0x132] = "Reserved",
-        [0x133] = "Reserved",
-        [0x134] = "Reserved",
-        [0x135] = "Reserved",
-        [0x136] = "Reserved",
-        [0x137] = "Reserved",
-        [0x138] = "Reserved",
-        [0x139] = "Reserved",
-        [0x13a] = "Reserved",
-        [0x13b] = "Reserved",
-        [0x13c] = "Reserved",
-        [0x13d] = "Reserved",
-        [0x13e] = "Reserved",
-        [0x13f] = "Reserved",
-        [0x140] = "Reserved", 
-        [0x141] = "Reserved",
-        [0x142] = "Reserved",
-        [0x143] = "Reserved",
-        [0x144] = "Reserved",
-        [0x145] = "Reserved",
-        [0x146] = "Reserved",
-        [0x147] = "Reserved",
-        [0x148] = "Reserved",
-        [0x149] = "Reserved",
-        [0x14a] = "Reserved",
-        [0x14b] = "Reserved",
-        [0x14c] = "Reserved",
-        [0x14d] = "Reserved",
-        [0x14e] = "Reserved",
-        [0x14f] = "Reserved",
-        [0x150] = "Balance Right",
-        [0x151] = "Balance Left",
-        [0x152] = "Bass Increment",
-        [0x153] = "Bass Decrement",
-        [0x154] = "Treble Increment",
-        [0x155] = "Treble Decrement",
-        [0x156] = "Reserved",
-        [0x157] = "Reserved",
-        [0x158] = "Reserved",
-        [0x159] = "Reserved",
-        [0x15a] = "Reserved",
-        [0x15b] = "Reserved",
-        [0x15c] = "Reserved",
-        [0x15d] = "Reserved",
-        [0x15e] = "Reserved",
-        [0x15f] = "Reserved",
-        [0x160] = "Speaker System",
-        [0x161] = "Channel Left",
-        [0x162] = "Channel Right",
-        [0x163] = "Channel Center",
-        [0x164] = "Channel Front",
-        [0x165] = "Channel Center Front",
-        [0x166] = "Channel Side",
-        [0x167] = "Channel Surround",
-        [0x168] = "Channel Low Frequency Enhancement",
-        [0x169] = "Channel Top",
-        [0x16a] = "Channel Unknown",
-        [0x16b] = "Reserved",
-        [0x16c] = "Reserved",
-        [0x16d] = "Reserved",
-        [0x16e] = "Reserved",
-        [0x16f] = "Reserved",
-        [0x170] = "Sub-channel",
-        [0x171] = "Sub-channel Increment",
-        [0x172] = "Sub-channel Decrement",
-        [0x173] = "Alternate Audio Increment",
-        [0x174] = "Alternate Audio Decrement",
-        [0x175] = "Reserved",
-        [0x176] = "Reserved",
-        [0x177] = "Reserved",
-        [0x178] = "Reserved",
-        [0x179] = "Reserved",
-        [0x17a] = "Reserved",
-        [0x17b] = "Reserved",
-        [0x17c] = "Reserved",
-        [0x17d] = "Reserved",
-        [0x17e] = "Reserved",
-        [0x17f] = "Reserved",
-        [0x180] = "Application Launch Buttons",
-        [0x181] = "AL Launch Buttion Configuration Tool",
-        [0x182] = "AL Programmable Button Configuration",
-        [0x183] = "AL Consumer Control Configuration",
-        [0x184] = "AL Word Processor",
-        [0x185] = "AL Text Editor",
-        [0x186] = "AL Spreadsheet",
-        [0x187] = "AL Graphics Editor",
-        [0x188] = "AL Presentation App",
-        [0x189] = "AL Database App",
-        [0x18a] = "AL Email Reader",
-        [0x18b] = "AL Newsreader",
-        [0x18c] = "AL Voicemail",
-        [0x18d] = "AL Contacts/Address Book",
-        [0x18e] = "AL Calendar/Schedule",
-        [0x18f] = "AL Task/Project Manager",
-        [0x190] = "AL Log/Journal/Timecard",
-        [0x191] = "AL Checkbook/Finance",
-        [0x192] = "AL Calculator",
-        [0x193] = "AL A/V Capture/Playback",
-        [0x194] = "AL Local Machine Browser",
-        [0x195] = "AL LAN/WAN Browser",
-        [0x196] = "AL Internet Browser",
-        [0x197] = "AL Remote Networking/ISP Connect",
-        [0x198] = "AL Network Conference",
-        [0x199] = "AL Network Chat",
-        [0x19a] = "AL Telephony/Dialer",
-        [0x19b] = "AL Logon",
-        [0x19c] = "AL Logoff",
-        [0x19d] = "AL Logon/Logoff",
-        [0x19e] = "AL Terminal Lock/Screensaver",
-        [0x19f] = "AL Control Panel",
-        [0x1a0] = "AL Command Line Processor/Run",
-        [0x1a1] = "AL Process/Task Manager",
-        [0x1a2] = "AL Select Task/Application",
-        [0x1a3] = "AL Next Task/Application",
-        [0x1a4] = "AL Previous Task/Application",
-        [0x1a5] = "AL Preemptive Halt Task/Application",
-        [0x1a6] = "AL Integrated Help Center",
-        [0x1a7] = "AL Documents",
-        [0x1a8] = "AL Thesaurus",
-        [0x1a9] = "AL Dictionary",
-        [0x1aa] = "AL Desktop",
-        [0x1ab] = "AL Spell Check",
-        [0x1ac] = "AL Grammar Check",
-        [0x1ad] = "AL Wireless Status",
-        [0x1ae] = "AL Keyboard Layout",
-        [0x1af] = "AL Virus Protection",
-        [0x1b0] = "AL Encryption",
-        [0x1b1] = "AL Screen Saver",
-        [0x1b2] = "AL Alarms",
-        [0x1b3] = "AL Clock",
-        [0x1b4] = "AL File Browser",
-        [0x1b5] = "AL Power Status",
-        [0x1b6] = "AL Image Browser",
-        [0x1b7] = "AL Audio Browser",
-        [0x1b8] = "AL Movie Browser",
-        [0x1b9] = "AL Digital Rights Manager",
-        [0x1ba] = "AL Digital Wallet",
-        [0x1bb] = "Reserved",
-        [0x1bc] = "AL Instant Messaging",
-        [0x1bd] = "AL OEM Features Tips/Tutorial Browser",
-        [0x1be] = "AL OEM Help",
-        [0x1bf] = "AL Online Community",
-        [0x1c0] = "AL Entertainment Content Browser",
-        [0x1c1] = "AL Online Shopping Browser",
-        [0x1c2] = "AL SmartCard Information/Help",
-        [0x1c3] = "AL Market Monitor/Finance Browser",
-        [0x1c4] = "AL Customized Corporate News Browser",
-        [0x1c5] = "AL Online Activity Browser",
-        [0x1c6] = "AL Research/Search Browser",
-        [0x1c7] = "AL Audio Player",
-        [0x1c8] = "Reserved",
-        [0x1c9] = "Reserved",
-        [0x1ca] = "Reserved",
-        [0x1cb] = "Reserved",
-        [0x1cc] = "Reserved",
-        [0x1cd] = "Reserved",
-        [0x1ce] = "Reserved",
-        [0x1cf] = "Reserved",
-        [0x1d0] = "Reserved",
-        [0x1d1] = "Reserved",
-        [0x1d2] = "Reserved",
-        [0x1d3] = "Reserved",
-        [0x1d4] = "Reserved",
-        [0x1d5] = "Reserved",
-        [0x1d6] = "Reserved",
-        [0x1d7] = "Reserved",
-        [0x1d8] = "Reserved",
-        [0x1d9] = "Reserved",
-        [0x1da] = "Reserved",
-        [0x1db] = "Reserved",
-        [0x1dc] = "Reserved",
-        [0x1dd] = "Reserved",
-        [0x1de] = "Reserved",
-        [0x1df] = "Reserved",
-        [0x1e0] = "Reserved",
-        [0x1e1] = "Reserved",
-        [0x1e2] = "Reserved",
-        [0x1e3] = "Reserved",
-        [0x1e4] = "Reserved",
-        [0x1e5] = "Reserved",
-        [0x1e6] = "Reserved",
-        [0x1e7] = "Reserved",
-        [0x1e8] = "Reserved",
-        [0x1e9] = "Reserved",
-        [0x1ea] = "Reserved",
-        [0x1eb] = "Reserved",
-        [0x1ec] = "Reserved",
-        [0x1ed] = "Reserved",
-        [0x1ee] = "Reserved",
-        [0x1ef] = "Reserved",
-        [0x1f0] = "Reserved",
-        [0x1f1] = "Reserved",
-        [0x1f2] = "Reserved",
-        [0x1f3] = "Reserved",
-        [0x1f4] = "Reserved",
-        [0x1f5] = "Reserved",
-        [0x1f6] = "Reserved",
-        [0x1f7] = "Reserved",
-        [0x1f8] = "Reserved",
-        [0x1f9] = "Reserved",
-        [0x1fa] = "Reserved",
-        [0x1fb] = "Reserved",
-        [0x1fc] = "Reserved",
-        [0x1fd] = "Reserved",
-        [0x1fe] = "Reserved",
-        [0x1ff] = "Reserved",
-        [0x200] = "Generic GUI Application Controls",
-        [0x201] = "AC New",
-        [0x202] = "AC Open",
-        [0x203] = "AC Close",
-        [0x204] = "AC Exit",
-        [0x205] = "AC Maximize",
-        [0x206] = "AC Minimize",
-        [0x207] = "AC Save",
-        [0x208] = "AC Print",
-        [0x209] = "AC Properties",
-        [0x20a] = "",
-        [0x20b] = "",
-        [0x20c] = "",
-        [0x20d] = "",
-        [0x20e] = "",
-        [0x20f] = "",
-        [0x210] = "",
-        [0x211] = "",
-        [0x212] = "",
-        [0x213] = "",
-        [0x214] = "",
-        [0x215] = "",
-        [0x216] = "",
-        [0x217] = "",
-        [0x218] = "",
-        [0x219] = "",
-        [0x21a] = "AC Undo",
-        [0x21b] = "AC Copy",
-        [0x21c] = "AC Cut",
-        [0x21d] = "AC Paste",
-        [0x21e] = "AC Select All",
-        [0x21f] = "AC Find",
-        [0x220] = "AC Find and Replace",
-        [0x221] = "AC Search",
-        [0x222] = "AC Go To",
-        [0x223] = "AC Home",
-        [0x224] = "AC Back",
-        [0x225] = "AC Forward",
-        [0x226] = "AC Stop",
-        [0x227] = "AC Refresh",
-        [0x228] = "AC Previous Link",
-        [0x229] = "AC Next Link",
-        [0x22a] = "AC Bookmarks",
-        [0x22b] = "AC History",
-        [0x22c] = "AC Subscriptions",
-        [0x22d] = "AC Zoom In",
-        [0x22e] = "AC Zoom Out",
-        [0x22f] = "AC Zoom",
-        [0x230] = "AC Full Screen View",
-        [0x231] = "AC Normal View",
-        [0x232] = "AC View Toggle",
-        [0x233] = "AC Scroll Up",
-        [0x234] = "AC Scroll Down",
-        [0x235] = "AC Scroll",
-        [0x236] = "AC Pan Left",
-        [0x237] = "AC Pan Right",
-        [0x238] = "AC Pan",
-        [0x239] = "AC New Window",
-        [0x23a] = "AC Tile Horizontally",
-        [0x23b] = "AC Tile Vertically",
-        [0x23c] = "AC Format",
-        [0x23d] = "AC Edit",
-        [0x23e] = "AC Bold",
-        [0x23f] = "AC Italics",
-        [0x240] = "AC Undeline",
-        [0x241] = "AC Strikethrough",
-        [0x242] = "AC Subscript",
-        [0x243] = "AC Superscript",
-        [0x244] = "AC All Caps",
-        [0x245] = "AC Rotate",
-        [0x246] = "AC Resize",
-        [0x247] = "AC Flip Horizontal",
-        [0x248] = "AC Flip Vertical",
-        [0x249] = "AC Mirror Horizontal",
-        [0x24a] = "AC Mirror Vertical",
-        [0x24b] = "AC Font Select",
-        [0x24c] = "AC Font Color",
-        [0x24d] = "AC Font Size",
-        [0x24e] = "AC Justify Left",
-        [0x24f] = "AC Justify Center H",
-        [0x250] = "AC Justify Right",
-        [0x251] = "AC Justify Block H",
-        [0x252] = "AC Justify Top",
-        [0x253] = "AC Justify Center V",
-        [0x254] = "AC Justify Bottom",
-        [0x255] = "AC Justify Block V",
-        [0x256] = "AC Indent Decrease",
-        [0x257] = "AC Indent Increase",
-        [0x258] = "AC Numbered List",
-        [0x259] = "AC Restart Numbering",
-        [0x25a] = "AC Bulleted List",
-        [0x25b] = "AC Promote",
-        [0x25c] = "AC Demote",
-        [0x25d] = "AC Yes",
-        [0x25e] = "AC No",
-        [0x25f] = "AC Cancel",
-        [0x260] = "AC Catalog",
-        [0x261] = "AC Buy/Checkout",
-        [0x262] = "AC Add to Cart",
-        [0x263] = "AC Expand",
-        [0x264] = "AC Expand All",
-        [0x265] = "AC Collapse",
-        [0x266] = "AC Collapse All",
-        [0x267] = "AC Print Preview",
-        [0x268] = "AC Paste Special",
-        [0x269] = "AC Insert Mode",
-        [0x26a] = "AC Delete",
-        [0x26b] = "AC Lock",
-        [0x26c] = "AC Unlock",
-        [0x26d] = "AC Protect",
-        [0x26e] = "AC Unprotect",
-        [0x26f] = "AC Attach Comment",
-        [0x270] = "AC Delete Comment",
-        [0x271] = "AC View Comment",
-        [0x272] = "AC Select Word",
-        [0x273] = "AC Select Sentence",
-        [0x274] = "AC Select Paragraph",
-        [0x275] = "AC Select Column",
-        [0x276] = "AC Select Row",
-        [0x277] = "AC Select Table",
-        [0x278] = "AC Select Object",
-        [0x279] = "AC Redo/Repeat",
-        [0x27a] = "AC Sort",
-        [0x27b] = "AC Sort Ascending",
-        [0x27c] = "AC Sort Descending",
-        [0x27d] = "AC Filter",
-        [0x27e] = "AC Set Clock",
-        [0x27f] = "AC View Clock",
-        [0x280] = "AC Select Time Zone",
-        [0x281] = "AC Edit Time Zones",
-        [0x282] = "AC Set Alarm",
-        [0x283] = "AC Clear Alarm",
-        [0x284] = "AC Snooze Alarm",
-        [0x285] = "AC Reset Alarm",
-        [0x286] = "AC Synchronize",
-        [0x287] = "AC Send/Receive",
-        [0x288] = "AC Send To",
-        [0x289] = "AC Reply",
-        [0x28a] = "AC Reply All",
-        [0x28b] = "AC Forward Msg",
-        [0x28c] = "AC Send",
-        [0x28d] = "AC Attach File",
-        [0x28e] = "AC Upload",
-        [0x28f] = "AC Download (Save Target As)",
-        [0x290] = "AC Set Borders",
-        [0x291] = "AC Insert Row",
-        [0x292] = "AC Insert Column",
-        [0x293] = "AC Insert File",
-        [0x294] = "AC Insert Picture",
-        [0x295] = "AC Insert Object",
-        [0x296] = "AC Insert Symbol",
-        [0x297] = "AC Save and Close",
-        [0x298] = "AC Rename",
-        [0x299] = "AC Merge",
-        [0x29a] = "AC Split",
-        [0x29b] = "AC Distrubute Horizontally",
-        [0x29c] = "AC Distrubute Vertically"
+        [0x227] = 0,  /* AC Refresh */
+        [0x22a] = 0   /* AC Bookmarks */
 };
 
@@ -769 +91 @@
 
 /**
- * Translates USB HID Usages from the Consumer Page into their string 
- * representation.
- *
- * @param usage USB HID Consumer Page Usage number.
- * 
- * @retval HelenOS key code corresponding to the given USB Consumer Page Usage.
- */
-const char *usb_multimedia_usage_to_str(int usage)
-{
-        size_t map_length = sizeof(usb_hid_consumer_usage_str) / sizeof(char *);
-
-        if ((usage < 0) || ((size_t)usage >= map_length))
-                return "Unknown usage";
-
-        /*! @todo What if the usage is not in the table? */
-        return usb_hid_consumer_usage_str[usage];
-}
-
-/**
  * @}
  */

uspace/drv/usbhid/multimedia/keymap.h

@@ -39 +39 @@
 unsigned int usb_multimedia_map_usage(int usage);
 
-const char *usb_multimedia_usage_to_str(int usage);
-
 #endif /* USB_HID_MULTIMEDIA_KEYMAP_H_ */
 

uspace/drv/usbhid/multimedia/multimedia.c

@@ -43 +43 @@
 #include <usb/debug.h>
 #include <usb/hid/usages/core.h>
+#include <usb/hid/usages/consumer.h>
 
 #include <errno.h>
@@ -58 +59 @@
 typedef struct usb_multimedia_t {
         /** Previously pressed keys (not translated to key codes). */
-        int32_t *keys_old;
+        //int32_t *keys_old;
         /** Currently pressed keys (not translated to key codes). */
-        int32_t *keys;
+        //int32_t *keys;
         /** Count of stored keys (i.e. number of keys in the report). */
-        size_t key_count;       
+        //size_t key_count;     
         /** IPC phone to the console device (for sending key events). */
         int console_phone;
@@ -174 +175 @@
         
         // free all buffers
-        if ((*multim_dev)->keys != NULL) {
-                free((*multim_dev)->keys);
-        }
-        if ((*multim_dev)->keys_old != NULL) {
-                free((*multim_dev)->keys_old);
-        }
+//      if ((*multim_dev)->keys != NULL) {
+//              free((*multim_dev)->keys);
+//      }
+//      if ((*multim_dev)->keys_old != NULL) {
+//              free((*multim_dev)->keys_old);
+//      }
 
         free(*multim_dev);
@@ -209 +210 @@
                 return rc;
         }
+        
+        usb_log_debug("%s function created (jandle: %" PRIun ").\n",
+            NAME, fun->handle);
         
         rc = ddf_fun_add_to_class(fun, "keyboard");
@@ -241 +245 @@
         multim_dev->console_phone = -1;
         
-        usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
-        
-        usb_hid_report_path_set_report_id(path, 1);
-        
-        multim_dev->key_count = usb_hid_report_size(
-            hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT);
-
-        usb_hid_report_path_free(path);
-        
-        usb_log_debug(NAME " Size of the input report: %zu\n", 
-            multim_dev->key_count);
-        
-        multim_dev->keys = (int32_t *)calloc(multim_dev->key_count, 
-            sizeof(int32_t));
-        
-        if (multim_dev->keys == NULL) {
-                usb_log_fatal("No memory!\n");
-                free(multim_dev);
-                return ENOMEM;
-        }
-        
-        multim_dev->keys_old = 
-                (int32_t *)calloc(multim_dev->key_count, sizeof(int32_t));
-        
-        if (multim_dev->keys_old == NULL) {
-                usb_log_fatal("No memory!\n");
-                free(multim_dev->keys);
-                free(multim_dev);
-                return ENOMEM;
-        }
+//      usb_hid_report_path_t *path = usb_hid_report_path();
+//      usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
+        
+//      usb_hid_report_path_set_report_id(path, 1);
+        
+//      multim_dev->key_count = usb_hid_report_size(
+//          hid_dev->report, 1, USB_HID_REPORT_TYPE_INPUT);
+
+//      usb_hid_report_path_free(path);
+        
+//      usb_log_debug(NAME " Size of the input report: %zu\n", 
+//          multim_dev->key_count);
+        
+//      multim_dev->keys = (int32_t *)calloc(multim_dev->key_count, 
+//          sizeof(int32_t));
+        
+//      if (multim_dev->keys == NULL) {
+//              usb_log_fatal("No memory!\n");
+//              free(multim_dev);
+//              return ENOMEM;
+//      }
+        
+//      multim_dev->keys_old = 
+//              (int32_t *)calloc(multim_dev->key_count, sizeof(int32_t));
+        
+//      if (multim_dev->keys_old == NULL) {
+//              usb_log_fatal("No memory!\n");
+//              free(multim_dev->keys);
+//              free(multim_dev);
+//              return ENOMEM;
+//      }
         
         /*! @todo Autorepeat */
@@ -357 +361 @@
                             usb_multimedia_map_usage(field->usage);
                         const char *key_str = 
-                            usb_multimedia_usage_to_str(field->usage);
+                            usbhid_multimedia_usage_to_str(field->usage);
                         usb_log_info("Pressed key: %s\n", key_str);
                         usb_multimedia_push_ev(hid_dev, multim_dev, KEY_PRESS, 

uspace/drv/usbhid/subdrivers.c

@@ -38 +38 @@
 #include <usb/hid/hidpath.h>
 
-//#include "lgtch-ultrax/lgtch-ultrax.h"
 #include "multimedia/multimedia.h"
 #include "mouse/mousedev.h"
+#include "generic/hiddev.h"
 
 static usb_hid_subdriver_usage_t path_kbd[] = {
@@ -58 +58 @@
 };
 
+//static usb_hid_subdriver_usage_t generic_hid_key_path[] = {
+//      {0, 0}
+//};
+
 const usb_hid_subdriver_mapping_t usb_hid_subdrivers[] = {
         {
                 path_kbd,
-                -1,
+                0,
                 USB_HID_PATH_COMPARE_BEGIN,
                 -1,
@@ -88 +92 @@
         {
                 path_mouse,
-                -1,
+                0,
                 USB_HID_PATH_COMPARE_BEGIN,
                 -1,
@@ -99 +103 @@
                 }
         },
+//      {
+//              generic_hid_key_path,
+//              0,
+//              USB_HID_PATH_COMPARE_ANYWHERE,
+//              -1,
+//              -1,
+//              {
+//                      .init = usb_generic_hid_init,
+//                      .deinit = NULL,
+//                      .poll = usb_generic_hid_polling_callback,
+//                      .poll_end = NULL
+//              }
+//      },
         {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL, NULL}}
 };

uspace/drv/usbhid/usbhid.c

@@ -63 +63 @@
 static const int USB_HID_MAX_SUBDRIVERS = 10;
 
-static fibril_local bool report_received;
+/** @todo What happens if this is not fibril local? */
+//static fibril_local bool report_number;
 
 /*----------------------------------------------------------------------------*/
@@ -234 +235 @@
         }
         
-        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(count * 
+        // add one generic HID subdriver per device
+        
+        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) * 
             sizeof(usb_hid_subdriver_t));
         if (hid_dev->subdrivers == NULL) {
@@ -247 +250 @@
         }
         
-        hid_dev->subdriver_count = count;
+        hid_dev->subdrivers[count].init = usb_generic_hid_init;
+        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
+        hid_dev->subdrivers[count].deinit = NULL;
+        hid_dev->subdrivers[count].poll_end = NULL;
+        
+        hid_dev->subdriver_count = count + 1;
         
         return EOK;
@@ -307 +315 @@
                 
                 if (matched) {
+                        usb_log_debug("Subdriver matched.\n");
                         subdrivers[count++] = &mapping->subdriver;
                 }
@@ -348 +357 @@
 /*----------------------------------------------------------------------------*/
 
+static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
+{
+        assert(hid_dev != NULL && hid_dev->report != NULL);
+        
+        uint8_t report_id = 0;
+        size_t size;/* = usb_hid_report_byte_size(hid_dev->report, report_id, 
+            USB_HID_REPORT_TYPE_INPUT);*/
+        
+        size_t max_size = 0;
+        
+        do {
+                size = usb_hid_report_byte_size(hid_dev->report, report_id, 
+                    USB_HID_REPORT_TYPE_INPUT);
+                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
+                max_size = (size > max_size) ? size : max_size;
+                report_id = usb_hid_get_next_report_id(hid_dev->report, 
+                    report_id, USB_HID_REPORT_TYPE_INPUT);
+        } while (report_id != 0);
+        
+        usb_log_debug("Max size of input report: %zu\n", max_size);
+        
+        hid_dev->max_input_report_size = max_size;
+        assert(hid_dev->input_report == NULL);
+        
+        hid_dev->input_report = malloc(max_size);
+        if (hid_dev->input_report == NULL) {
+                return ENOMEM;
+        }
+        memset(hid_dev->input_report, 0, max_size);
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
 usb_hid_dev_t *usb_hid_new(void)
 {
@@ -402 +446 @@
         /* Get the report descriptor and parse it. */
         rc = usb_hid_process_report_descriptor(hid_dev->usb_dev, 
-            hid_dev->report);
+            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
         
         bool fallback = false;
@@ -483 +527 @@
         }
         
+        // save max input report size and allocate space for the report
+        rc = usb_hid_init_report(hid_dev);
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize input report buffer.\n");
+        }
+        
         return rc;
 }
@@ -500 +550 @@
         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
         
-        int allocated = (hid_dev->input_report != NULL);
-        
-        if (!allocated
-            || hid_dev->input_report_size < buffer_size) {
-                uint8_t *input_old = hid_dev->input_report;
-                uint8_t *input_new = (uint8_t *)malloc(buffer_size);
-                
-                if (input_new == NULL) {
-                        usb_log_error("Failed to allocate space for input "
-                            "buffer. This event may not be reported\n");
-                        memset(hid_dev->input_report, 0, 
-                            hid_dev->input_report_size);
-                } else {
-                        memcpy(input_new, input_old, 
-                            hid_dev->input_report_size);
-                        hid_dev->input_report = input_new;
-                        if (allocated) {
-                                free(input_old);
-                        }
-                        usb_hid_new_report();
-                }
-        }
+//      int allocated = (hid_dev->input_report != NULL);
+        assert(hid_dev->input_report != NULL);
+        usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
+            hid_dev->max_input_report_size, buffer_size);
+        assert(hid_dev->max_input_report_size >= buffer_size);
+        
+//      if (/*!allocated*/
+//          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
+//              uint8_t *input_old = hid_dev->input_report;
+//              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
+                
+//              if (input_new == NULL) {
+//                      usb_log_error("Failed to allocate space for input "
+//                          "buffer. This event may not be reported\n");
+//                      memset(hid_dev->input_report, 0, 
+//                          hid_dev->input_report_size);
+//              } else {
+//                      memcpy(input_new, input_old, 
+//                          hid_dev->input_report_size);
+//                      hid_dev->input_report = input_new;
+//                      if (allocated) {
+//                              free(input_old);
+//                      }
+//                      usb_hid_new_report();
+//              }
+//      }
         
         /*! @todo This should probably be atomic. */
         memcpy(hid_dev->input_report, buffer, buffer_size);
         hid_dev->input_report_size = buffer_size;
+        usb_hid_new_report(hid_dev);
         
         bool cont = false;
@@ -601 +656 @@
 /*----------------------------------------------------------------------------*/
 
-void usb_hid_new_report(void)
-{
-        report_received = false;
-}
-
-/*----------------------------------------------------------------------------*/
-
-void usb_hid_report_received(void)
-{
-        report_received = true;
-}
-
-/*----------------------------------------------------------------------------*/
-
-bool usb_hid_report_ready(void)
-{
-        return !report_received;
-}
+void usb_hid_new_report(usb_hid_dev_t *hid_dev)
+{
+        ++hid_dev->report_nr;
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_hid_report_number(usb_hid_dev_t *hid_dev)
+{
+        return hid_dev->report_nr;
+}
+
+/*----------------------------------------------------------------------------*/
+
+//void usb_hid_report_received(void)
+//{
+//      ++report_number;
+//}
+
+/*----------------------------------------------------------------------------*/
+
+//bool usb_hid_report_ready(void)
+//{
+//      return !report_received;
+//}
 
 /*----------------------------------------------------------------------------*/

uspace/drv/usbhid/usbhid.h

@@ -98 +98 @@
         
         size_t input_report_size;
+        size_t max_input_report_size;
+        
+        int report_nr;
 } usb_hid_dev_t;
 
@@ -127 +130 @@
 //const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev);
 
-void usb_hid_new_report(void);
+void usb_hid_new_report(usb_hid_dev_t *hid_dev);
 
-void usb_hid_report_received(void);
+int usb_hid_report_number(usb_hid_dev_t *hid_dev);
 
-bool usb_hid_report_ready(void);
+//void usb_hid_report_received(void);
+
+//bool usb_hid_report_ready(void);
 
 void usb_hid_free(usb_hid_dev_t **hid_dev);

uspace/drv/usbhub/usbhub.c

@@ -67 +67 @@
     usb_hub_status_t status);
 
-static int usb_process_hub_power_change(usb_hub_info_t * hub_info,
+static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
     usb_hub_status_t status);
 
@@ -336 +336 @@
  */
 static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info){
-        /*
-         * The processing will require opened control pipe and connection
-         * to the host controller.
-         * It is waste of resources but let's hope there will be less
-         * hubs than the phone limit.
-         * FIXME: with some proper locking over pipes and session
-         * auto destruction, this could work better.
-         */
-        int rc = usb_hc_connection_open(&hub_info->connection);
-        if (rc != EOK) {
-                //usb_pipe_end_session(hub_info->control_pipe);
-                usb_log_error("Failed to open connection to HC: %s.\n",
-                    str_error(rc));
-                return rc;
-        }
+        int rc;
 
         rc = usb_device_auto_poll(hub_info->usb_device, 0,
@@ -386 +372 @@
         int opResult;
         if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_OVER_CURRENT)){
-                opResult = usb_hub_clear_feature(hub_info->control_pipe,
-                    USB_HUB_FEATURE_HUB_LOCAL_POWER);
-                if (opResult != EOK) {
-                        usb_log_error("cannot power off hub: %d\n",
-                            opResult);
+                //poweroff all ports
+                unsigned int port;
+                for(port = 1;port <= hub_info->port_count;++port){
+                        opResult = usb_hub_clear_port_feature(
+                            hub_info->control_pipe,port,
+                            USB_HUB_FEATURE_PORT_POWER);
+                        if (opResult != EOK) {
+                                usb_log_warning(
+                                    "cannot power off port %d;  %d\n",
+                                    port, opResult);
+                        }
                 }
         } else {
-                opResult = usb_hub_set_feature(hub_info->control_pipe,
-                    USB_HUB_FEATURE_HUB_LOCAL_POWER);
-                if (opResult != EOK) {
-                        usb_log_error("cannot power on hub: %d\n",
-                            opResult);
+                //power all ports
+                unsigned int port;
+                for(port = 1;port <= hub_info->port_count;++port){
+                        opResult = usb_hub_set_port_feature(
+                            hub_info->control_pipe,port,
+                            USB_HUB_FEATURE_PORT_POWER);
+                        if (opResult != EOK) {
+                                usb_log_warning(
+                                    "cannot power off port %d;  %d\n",
+                                    port, opResult);
+                        }
                 }
         }
@@ -404 +402 @@
 
 /**
- * process hub power change
- *
- * If the power has been lost, reestablish it.
- * If it was reestablished, re-power all ports.
+ * process hub local power change
+ *
+ * This change is ignored.
  * @param hub_info hub instance
  * @param status hub status bitmask
  * @return error code
  */
-static int usb_process_hub_power_change(usb_hub_info_t * hub_info,
+static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
     usb_hub_status_t status) {
         int opResult = EOK;
-        if (!usb_hub_is_status(status,USB_HUB_FEATURE_HUB_LOCAL_POWER)) {
-                //restart power on hub
-                opResult = usb_hub_set_feature(hub_info->control_pipe,
-                    USB_HUB_FEATURE_HUB_LOCAL_POWER);
-                if (opResult != EOK) {
-                        usb_log_error("cannot power on hub: %d\n",
-                            opResult);
-                }
-        } else {//power reestablished on hub- restart ports
-                size_t port;
-                for (port = 1; port <= hub_info->port_count; ++port) {
-                        opResult = usb_hub_set_port_feature(
-                            hub_info->control_pipe,
-                            port, USB_HUB_FEATURE_PORT_POWER);
-                        if (opResult != EOK) {
-                                usb_log_error("Cannot power on port %zu: %s.\n",
-                                    port, str_error(opResult));
-                        }
-                }
-        }
-        if(opResult!=EOK){
-                return opResult;//no feature clearing
-        }
         opResult = usb_hub_clear_feature(hub_info->control_pipe,
             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
@@ -452 +426 @@
  *
  * The change can be either in the over-current condition or
- * local-power lost condition.
+ * local-power change.
  * @param hub_info hub instance
  */
@@ -487 +461 @@
         if (
             usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
-                usb_process_hub_power_change(hub_info, status);
+                usb_process_hub_local_power_change(hub_info, status);
         }
 }

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;
         }