Changes in / [889e8e3:291b8bc] in mainline

Files:

• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• kernel/generic/src/console/console.c (modified) (1 diff)
• kernel/generic/src/mm/as.c (modified) (1 diff)
• uspace/Makefile (modified) (2 diffs)
• uspace/app/init/init.c (modified) (2 diffs)
• uspace/drv/ohci/Makefile (modified) (1 diff)
• uspace/drv/ohci/batch.c (modified) (1 diff)
• uspace/drv/ohci/hc.c (modified) (4 diffs)
• uspace/drv/ohci/hc.h (modified) (1 diff)
• uspace/drv/ohci/iface.h (modified) (1 diff)
• uspace/drv/ohci/main.c (modified) (3 diffs)
• uspace/drv/ohci/ohci.c (added)
• uspace/drv/ohci/ohci.h (added)
• uspace/drv/ohci/root_hub.c (modified) (2 diffs)
• uspace/drv/ohci/root_hub.h (modified) (1 diff)
• uspace/drv/uhci-hcd/Makefile (modified) (1 diff)
• uspace/drv/uhci-hcd/hc.c (modified) (3 diffs)
• uspace/drv/uhci-hcd/root_hub.c (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) (2 diffs)
• uspace/drv/uhci-hcd/utils/malloc32.h (modified) (5 diffs)
• uspace/drv/uhci-hcd/utils/slab.c (added)
• uspace/drv/uhci-hcd/utils/slab.h (added)
• uspace/drv/usbhid/Makefile (deleted)
• uspace/drv/usbhid/conv.c (deleted)
• uspace/drv/usbhid/conv.h (deleted)
• uspace/drv/usbhid/descdump.c (deleted)
• uspace/drv/usbhid/descdump.h (deleted)
• uspace/drv/usbhid/hiddev.c (deleted)
• uspace/drv/usbhid/hiddev.h (deleted)
• uspace/drv/usbhid/hidreq.c (deleted)
• uspace/drv/usbhid/hidreq.h (deleted)
• uspace/drv/usbhid/kbd.h (deleted)
• uspace/drv/usbhid/kbddev.c (deleted)
• uspace/drv/usbhid/kbddev.h (deleted)
• uspace/drv/usbhid/kbdrepeat.c (deleted)
• uspace/drv/usbhid/kbdrepeat.h (deleted)
• uspace/drv/usbhid/layout.h (deleted)
• uspace/drv/usbhid/main.c (deleted)
• uspace/drv/usbhid/usbhid.ma (deleted)
• uspace/drv/usbhub/port_status.h (modified) (2 diffs)
• uspace/drv/usbhub/usbhub.c (modified) (1 diff)
• uspace/drv/usbkbd/Makefile (added)
• uspace/drv/usbkbd/conv.c (added)
• uspace/drv/usbkbd/conv.h (added)
• uspace/drv/usbkbd/kbd.h (added)
• uspace/drv/usbkbd/kbddev.c (added)
• uspace/drv/usbkbd/kbddev.h (added)
• uspace/drv/usbkbd/kbdrepeat.c (added)
• uspace/drv/usbkbd/kbdrepeat.h (added)
• uspace/drv/usbkbd/layout.h (added)
• uspace/drv/usbkbd/main.c (added)
• uspace/drv/usbkbd/usbkbd.ma (added)
• uspace/lib/c/generic/malloc.c (modified) (1 diff)
• uspace/lib/usb/Makefile (modified) (1 diff)
• uspace/lib/usb/include/usb/classes/hidparser.h (modified) (6 diffs)
• uspace/lib/usb/include/usb/classes/hidreport.h (added)
• uspace/lib/usb/include/usb/classes/hidreq.h (added)
• uspace/lib/usb/include/usb/host/device_keeper.h (modified) (3 diffs)
• uspace/lib/usb/src/hidparser.c (modified) (25 diffs)
• uspace/lib/usb/src/hidreport.c (added)
• uspace/lib/usb/src/hidreq.c (added)
• uspace/lib/usb/src/host/device_keeper.c (modified) (4 diffs)

boot/arch/amd64/Makefile.inc

@@ -49 +49 @@
         usbflbk \
         usbhub \
-        usbhid \
+        usbkbd \
         usbmid \
         usbmouse \

kernel/generic/src/console/console.c

@@ -53 +53 @@
 #include <str.h>
 
+/*
+ * devman produces a lot of output and by giving so many pages
+ * we to allow /app/klog to catch-up.
+ */
+#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
+#define KLOG_PAGES    64
+#else
 #define KLOG_PAGES    4
+#endif
+
 #define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
 #define KLOG_LATENCY  8

kernel/generic/src/mm/as.c

@@ -1949 +1949 @@
 sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
 {
-        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
+        if (as_area_create(AS, flags, size, address,
             AS_AREA_ATTR_NONE, &anon_backend, NULL))
                 return (sysarg_t) address;

uspace/Makefile

@@ -122 +122 @@
                 drv/uhci-rhd \
                 drv/usbflbk \
-                drv/usbhid \
+                drv/usbkbd \
                 drv/usbhub \
                 drv/usbmid \
@@ -142 +142 @@
                 drv/uhci-rhd \
                 drv/usbflbk \
-                drv/usbhid \
+                drv/usbkbd \
                 drv/usbhub \
                 drv/usbmid \

uspace/app/init/init.c

@@ -288 +288 @@
         
         spawn("/srv/clip");
-
-#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
-        spawn("/srv/devman");
-#endif
         
         /*
@@ -318 +314 @@
         getterm("term/vc6", "/app/klog", false);
 
-#ifndef CONFIG_DEVMAN_EARLY_LAUNCH
+#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
+        spawn("/srv/devman");
+#else
         getterm("term/vc7", "/srv/devman", false);
 #endif

uspace/drv/ohci/Makefile

@@ -37 +37 @@
         main.c \
         hc.c \
+        ohci.c \
         root_hub.c \
         pci.c

uspace/drv/ohci/batch.c

@@ -118 +118 @@
         instance->next_step = batch_call_in_and_dispose;
         /* TODO: implement */
-        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
+        usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/ohci/hc.c

@@ -39 +39 @@
 #include <usb/debug.h>
 #include <usb/usb.h>
-#include <usb/hub.h>
 #include <usb/ddfiface.h>
 #include <usb/usbdevice.h>
@@ -45 +44 @@
 #include "hc.h"
 
-static int dummy_reset(int foo, void *arg);
 static int interrupt_emulator(hc_t *instance);
+/*----------------------------------------------------------------------------*/
+int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
+{
+        assert(instance);
+        assert(hub_fun);
+
+        usb_address_t hub_address =
+            device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
+        instance->rh.address = hub_address;
+        usb_device_keeper_bind(
+            &instance->manager, hub_address, hub_fun->handle);
+
+        char *match_str = NULL;
+        int ret = asprintf(&match_str, "usb&mid");
+        ret = (match_str == NULL) ? ret : EOK;
+        if (ret < 0) {
+                usb_log_error("Failed to create root hub match-id string.\n");
+                return ret;
+        }
+
+        ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
+        if (ret != EOK) {
+                usb_log_error("Failed add create root hub match-id.\n");
+        }
+        return ret;
+}
 /*----------------------------------------------------------------------------*/
 int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
@@ -68 +92 @@
         }
 
+        rh_init(&instance->rh, dev, instance->registers);
 
-        rh_init(&instance->rh, dev, instance->registers);
         /* TODO: implement */
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-int hc_register_hub(hc_t *instance)
-{
-        async_usleep(1000000);
-#define CHECK_RET_RETURN(ret, msg...) \
-        if (ret != EOK) { \
-                usb_log_error(msg); \
-                return ret; \
-        } else (void)0
-        assert(instance);
-        assert(instance->ddf_instance);
-        assert(instance->ddf_instance->handle);
-        ddf_dev_t *dev = instance->rh.device;
-        int ret = EOK;
-
-        usb_hc_connection_t conn;
-        ret =
-            usb_hc_connection_initialize(&conn, instance->ddf_instance->handle);
-        CHECK_RET_RETURN(ret, "Failed to initialize hc connection.\n");
-
-        ret = usb_hc_connection_open(&conn);
-        CHECK_RET_RETURN(ret, "Failed to open hc connection.\n");
-
-        usb_address_t address;
-        devman_handle_t handle;
-        ret = usb_hc_new_device_wrapper(dev, &conn, USB_SPEED_FULL, dummy_reset,
-            0, instance, &address, &handle, NULL, NULL, NULL);
-        if (ret != EOK) {
-                usb_log_error("Failed to add rh device.\n");
-                instance->rh.address = -1;
-                return ret;
-        }
-
-        ret = usb_hc_connection_close(&conn);
-        CHECK_RET_RETURN(ret, "Failed to close hc connection.\n");
         return EOK;
 }
@@ -134 +121 @@
 }
 /*----------------------------------------------------------------------------*/
-static int dummy_reset(int foo, void *arg)
-{
-        hc_t *hc = (hc_t*)arg;
-        assert(hc);
-        hc->rh.address = 0;
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int interrupt_emulator(hc_t *instance)
+int interrupt_emulator(hc_t *instance)
 {
         assert(instance);

uspace/drv/ohci/hc.h

@@ -57 +57 @@
 } hc_t;
 
+int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
+
 int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
      uintptr_t regs, size_t reg_size, bool interrupts);
-
-int hc_register_hub(hc_t *instance);
 
 int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);

uspace/drv/ohci/iface.h

@@ -33 +33 @@
  * Common OHCI definitions.
  */
-#ifndef DRV_OHCI_OHCI_H
-#define DRV_OHCI_OHCI_H
+#ifndef DRV_OHCI_IFACE_H
+#define DRV_OHCI_IFACE_H
 
 #include <usbhc_iface.h>
-
-#define NAME "ohci"
 
 extern usbhc_iface_t hc_iface;

uspace/drv/ohci/main.c

@@ -34 +34 @@
  */
 #include <ddf/driver.h>
-#include <ddf/interrupt.h>
-#include <device/hw_res.h>
 #include <errno.h>
 #include <str_error.h>
 
-#include <usb_iface.h>
-#include <usb/ddfiface.h>
 #include <usb/debug.h>
 
-#include "pci.h"
-#include "iface.h"
-#include "hc.h"
+#include "ohci.h"
+
+#define NAME "ohci"
 
 static int ohci_add_device(ddf_dev_t *device);
-static int get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
-{
-        assert(handle);
-  assert(fun != NULL);
-
-  *handle = fun->handle;
-  return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int get_address(
-    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
-{
-        assert(fun);
-        usb_device_keeper_t *manager = &fun_to_hc(fun)->manager;
-  usb_address_t addr = usb_device_keeper_find(manager, handle);
-  if (addr < 0) {
-    return addr;
-  }
-
-  if (address != NULL) {
-    *address = addr;
-  }
-
-  return EOK;
-}
-/*----------------------------------------------------------------------------*/
-/** IRQ handling callback, identifies device
- *
- * @param[in] dev DDF instance of the device to use.
- * @param[in] iid (Unused).
- * @param[in] call Pointer to the call that represents interrupt.
- */
-static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
-{
-        assert(dev);
-        hc_t *hc = (hc_t*)dev->driver_data;
-        assert(hc);
-        hc_interrupt(hc, 0);
-}
 /*----------------------------------------------------------------------------*/
 static driver_ops_t ohci_driver_ops = {
@@ -97 +54 @@
 };
 /*----------------------------------------------------------------------------*/
-static usb_iface_t hc_usb_iface = {
-        .get_address = get_address,
-        .get_hc_handle = get_hc_handle,
-};
-/*----------------------------------------------------------------------------*/
-static ddf_dev_ops_t hc_ops = {
-        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
-        .interfaces[USBHC_DEV_IFACE] = &hc_iface,
-};
-/*----------------------------------------------------------------------------*/
 /** Initializes a new ddf driver instance of OHCI hcd.
  *
@@ -112 +59 @@
  * @return Error code.
  */
-static int ohci_add_device(ddf_dev_t *device)
+int ohci_add_device(ddf_dev_t *device)
 {
+        usb_log_debug("ohci_add_device() called\n");
         assert(device);
-#define CHECK_RET_RETURN(ret, message...) \
-if (ret != EOK) { \
-        usb_log_error(message); \
-        return ret; \
-}
-
-        uintptr_t mem_reg_base = 0;
-        size_t mem_reg_size = 0;
-        int irq = 0;
-
-        int ret =
-            pci_get_my_registers(device, &mem_reg_base, &mem_reg_size, &irq);
-        CHECK_RET_RETURN(ret,
-            "Failed(%d) to get memory addresses:.\n", ret, device->handle);
-        usb_log_info("Memory mapped regs at 0x%X (size %zu), IRQ %d.\n",
-            mem_reg_base, mem_reg_size, irq);
-
-        ret = pci_disable_legacy(device);
-        CHECK_RET_RETURN(ret,
-            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
-
-        hc_t *hcd = malloc(sizeof(hc_t));
-        if (hcd == NULL) {
+        ohci_t *ohci = malloc(sizeof(ohci_t));
+        if (ohci == NULL) {
                 usb_log_error("Failed to allocate OHCI driver.\n");
                 return ENOMEM;
         }
 
-        ddf_fun_t *hc_fun = ddf_fun_create(device, fun_exposed, "ohci-hc");
-        if (hc_fun == NULL) {
-                usb_log_error("Failed to create OHCI function.\n");
-                free(hcd);
-                return ENOMEM;
-        }
-
-
-        bool interrupts = false;
-#ifdef CONFIG_USBHC_NO_INTERRUPTS
-        usb_log_warning("Interrupts disabled in OS config, " \
-            "falling back to polling.\n");
-#else
-        ret = pci_enable_interrupts(device);
+        int ret = ohci_init(ohci, device);
         if (ret != EOK) {
-                usb_log_warning("Failed to enable interrupts: %s.\n",
+                usb_log_error("Failed to initialize OHCI driver: %s.\n",
                     str_error(ret));
-                usb_log_info("HW interrupts not available, " \
-                    "falling back to polling.\n");
-        } else {
-                usb_log_debug("Hw interrupts enabled.\n");
-                interrupts = true;
-        }
-#endif
-
-        ret = hc_init(hcd, hc_fun, device, mem_reg_base, mem_reg_size, interrupts);
-        if (ret != EOK) {
-                usb_log_error("Failed to initialize OHCI driver.\n");
-                free(hcd);
                 return ret;
         }
+        device->driver_data = ohci;
 
-        ret = register_interrupt_handler(device, irq, irq_handler, NULL);
-
-        hc_fun->ops = &hc_ops;
-        ret = ddf_fun_bind(hc_fun);
-        if (ret != EOK) {
-                usb_log_error("Failed to bind OHCI function.\n");
-                ddf_fun_destroy(hc_fun);
-                free(hcd);
-                return ret;
-        }
-        hc_fun->driver_data = hcd;
-
-        fid_t later = fibril_create((int(*)(void*))hc_register_hub, hcd);
-        fibril_add_ready(later);
-
-        usb_log_info("Controlling new OHCI device `%s' (handle %llu).\n",
-            device->name, device->handle);
+        usb_log_info("Controlling new OHCI device `%s'.\n", device->name);
 
         return EOK;
-#undef CHECK_RET_RETURN
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/ohci/root_hub.c

@@ -39 +39 @@
 
 #include "root_hub.h"
+#include "usb/classes/classes.h"
+#include <usb/request.h>
+#include <usb/classes/hub.h>
+
+static const usb_standard_device_descriptor_t ohci_rh_device_descriptor =
+{
+                .configuration_count = 1,
+                .descriptor_type = USB_DESCTYPE_DEVICE,
+                .device_class = USB_CLASS_HUB,
+                .device_protocol = 0,
+                .device_subclass = 0,
+                .device_version = 0,
+                .length = sizeof(usb_standard_device_descriptor_t),
+                /// \TODO this value is guessed
+                .max_packet_size = 8,
+                .vendor_id = 0x16db,
+                .product_id = 0x0001,
+                /// \TODO these values migt be different
+                .str_serial_number = 0,
+                .usb_spec_version = 0,
+};
+
+static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor =
+{
+        /// \TODO some values are default or guessed
+        .attributes = 1<<7,
+        .configuration_number = 1,
+        .descriptor_type = USB_DESCTYPE_CONFIGURATION,
+        .interface_count = 1,
+        .length = sizeof(usb_standard_configuration_descriptor_t),
+        .max_power = 100,
+        .str_configuration = 0,
+};
+
+static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor =
+{
+        .alternate_setting = 0,
+        .descriptor_type = USB_DESCTYPE_INTERFACE,
+        .endpoint_count = 1,
+        .interface_class = USB_CLASS_HUB,
+        /// \TODO is this correct?
+        .interface_number = 1,
+        .interface_protocol = 0,
+        .interface_subclass = 0,
+        .length = sizeof(usb_standard_interface_descriptor_t),
+        .str_interface = 0,
+};
+
+static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor =
+{
+        .attributes = USB_TRANSFER_INTERRUPT,
+        .descriptor_type = USB_DESCTYPE_ENDPOINT,
+        .endpoint_address = 1 + (1<<7),
+        .length = sizeof(usb_standard_endpoint_descriptor_t),
+        .max_packet_size = 8,
+        .poll_interval = 255,
+};
 
 /** Root hub initialization
@@ -50 +107 @@
         instance->device = dev;
 
+
         usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
 
+        //start generic usb hub driver
+        
         /* TODO: implement */
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+
+
+static int process_get_port_status_request(rh_t *instance, uint16_t port,
+                usb_transfer_batch_t * request){
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        request->transfered_size = 4;
+        uint32_buffer[0] = instance->registers->rh_port_status[port -1];
+        return EOK;
+}
+
+static int process_get_hub_status_request(rh_t *instance,
+                usb_transfer_batch_t * request){
+        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        //bits, 0,1,16,17
+        request->transfered_size = 4;
+        uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
+        uint32_buffer[0] = mask & instance->registers->rh_status;
+        return EOK;
+
+}
+
+static void usb_create_serialized_hub_descriptor(rh_t *instance, uint8_t ** out_result,
+                size_t * out_size) {
+        //base size
+        size_t size = 7;
+        //variable size according to port count
+        size_t var_size = instance->port_count / 8 +
+                        ((instance->port_count % 8 > 0) ? 1 : 0);
+        size += 2 * var_size;
+        uint8_t * result = (uint8_t*) malloc(size);
+        bzero(result,size);
+        //size
+        result[0] = size;
+        //descriptor type
+        result[1] = USB_DESCTYPE_HUB;
+        result[2] = instance->port_count;
+        uint32_t hub_desc_reg = instance->registers->rh_desc_a;
+        result[3] = 
+                        ((hub_desc_reg >> 8) %2) +
+                        (((hub_desc_reg >> 9) %2) << 1) +
+                        (((hub_desc_reg >> 10) %2) << 2) +
+                        (((hub_desc_reg >> 11) %2) << 3) +
+                        (((hub_desc_reg >> 12) %2) << 4);
+        result[4] = 0;
+        result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
+        result[6] = 50;
+
+        int port;
+        for (port = 1; port <= instance->port_count; ++port) {
+                result[7 + port/8] +=
+                                ((instance->registers->rh_desc_b >> port)%2) << (port%8);
+        }
+        size_t i;
+        for (i = 0; i < var_size; ++i) {
+                result[7 + var_size + i] = 255;
+        }
+        (*out_result) = result;
+        (*out_size) = size;
+}
+
+
+static int process_get_status_request(rh_t *instance,
+                usb_transfer_batch_t * request)
+{
+        size_t buffer_size = request->buffer_size;
+        usb_device_request_setup_packet_t * request_packet =
+                        (usb_device_request_setup_packet_t*)
+                        request->setup_buffer;
+
+        usb_hub_bm_request_type_t request_type = request_packet->request_type;
+        if(buffer_size<4/*request_packet->length*/){///\TODO
+                usb_log_warning("requested more data than buffer size\n");
+                return EINVAL;
+        }
+
+        if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
+                return process_get_hub_status_request(instance, request);
+        if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
+                return process_get_port_status_request(instance, request_packet->index,
+                                request);
+        return ENOTSUP;
+}
+
+static void create_interrupt_mask(rh_t *instance, void ** buffer,
+                size_t * buffer_size){
+        int bit_count = instance->port_count + 1;
+        (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1;
+        (*buffer) = malloc(*buffer_size);
+        uint8_t * bitmap = (uint8_t*)(*buffer);
+        uint32_t mask = (1<<16) + (1<<17);
+        bzero(bitmap,(*buffer_size));
+        if(instance->registers->rh_status & mask){
+                bitmap[0] = 1;
+        }
+        int port;
+        mask = 0;
+        int i;
+        for(i=16;i<=20;++i)
+                mask += 1<<i;
+        for(port = 1; port<=instance->port_count;++port){
+                if(mask & instance->registers->rh_port_status[port-1]){
+                        bitmap[(port+1)/8] += 1<<(port%8);
+                }
+        }
+}
+
+
+static int process_get_descriptor_request(rh_t *instance,
+                usb_transfer_batch_t *request){
+        /// \TODO
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        size_t size;
+        const void * result_descriptor;
+        const uint16_t setup_request_value = setup_request->value_high;
+                        //(setup_request->value_low << 8);
+        bool del = false;
+
+        switch (setup_request_value)
+        {
+        case USB_DESCTYPE_HUB: {
+                uint8_t * descriptor;
+                usb_create_serialized_hub_descriptor(
+                    instance, &descriptor, &size);
+                result_descriptor = descriptor;
+                break;
+        }
+        case USB_DESCTYPE_DEVICE: {
+                usb_log_debug("USB_DESCTYPE_DEVICE\n");
+                result_descriptor = &ohci_rh_device_descriptor;
+                size = sizeof(ohci_rh_device_descriptor);
+                break;
+        }
+        case USB_DESCTYPE_CONFIGURATION: {
+                usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
+                usb_standard_configuration_descriptor_t * descriptor =
+                                malloc(sizeof(usb_standard_configuration_descriptor_t));
+                memcpy(descriptor, &ohci_rh_conf_descriptor,
+                    sizeof(usb_standard_configuration_descriptor_t));
+                /// \TODO should this include device descriptor?
+                const size_t hub_descriptor_size = 7 +
+                                2* (instance->port_count / 8 +
+                                ((instance->port_count % 8 > 0) ? 1 : 0));
+                descriptor->total_length =
+                                sizeof(usb_standard_configuration_descriptor_t)+
+                                sizeof(usb_standard_endpoint_descriptor_t)+
+                                sizeof(usb_standard_interface_descriptor_t)+
+                                hub_descriptor_size;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_configuration_descriptor_t);
+                del = true;
+                break;
+        }
+        case USB_DESCTYPE_INTERFACE: {
+                usb_log_debug("USB_DESCTYPE_INTERFACE\n");
+                result_descriptor = &ohci_rh_iface_descriptor;
+                size = sizeof(ohci_rh_iface_descriptor);
+                break;
+        }
+        case USB_DESCTYPE_ENDPOINT: {
+                usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
+                result_descriptor = &ohci_rh_ep_descriptor;
+                size = sizeof(ohci_rh_ep_descriptor);
+                break;
+        }
+        default: {
+                usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
+                usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
+                                setup_request->request_type,
+                                setup_request->request,
+                                setup_request_value,
+                                setup_request->index,
+                                setup_request->length
+                                );
+                return EINVAL;
+        }
+        }
+#if 0
+        if(setup_request_value == USB_DESCTYPE_HUB){
+                usb_log_debug("USB_DESCTYPE_HUB\n");
+                //create hub descriptor
+                uint8_t * descriptor;
+                usb_create_serialized_hub_descriptor(instance, 
+                                &descriptor, &size);
+                result_descriptor = descriptor;
+        }else if(setup_request_value == USB_DESCTYPE_DEVICE){
+                //create std device descriptor
+                usb_log_debug("USB_DESCTYPE_DEVICE\n");
+                usb_standard_device_descriptor_t * descriptor =
+                                (usb_standard_device_descriptor_t*)
+                                malloc(sizeof(usb_standard_device_descriptor_t));
+                descriptor->configuration_count = 1;
+                descriptor->descriptor_type = USB_DESCTYPE_DEVICE;
+                descriptor->device_class = USB_CLASS_HUB;
+                descriptor->device_protocol = 0;
+                descriptor->device_subclass = 0;
+                descriptor->device_version = 0;
+                descriptor->length = sizeof(usb_standard_device_descriptor_t);
+                /// \TODO this value is guessed
+                descriptor->max_packet_size = 8;
+                descriptor->product_id = 0x0001;
+                /// \TODO these values migt be different
+                descriptor->str_serial_number = 0;
+                descriptor->str_serial_number = 0;
+                descriptor->usb_spec_version = 0;
+                descriptor->vendor_id = 0x16db;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_device_descriptor_t);
+        }else if(setup_request_value == USB_DESCTYPE_CONFIGURATION){
+                usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
+                usb_standard_configuration_descriptor_t * descriptor =
+                                (usb_standard_configuration_descriptor_t*)
+                                malloc(sizeof(usb_standard_configuration_descriptor_t));
+                /// \TODO some values are default or guessed
+                descriptor->attributes = 1<<7;
+                descriptor->configuration_number = 1;
+                descriptor->descriptor_type = USB_DESCTYPE_CONFIGURATION;
+                descriptor->interface_count = 1;
+                descriptor->length = sizeof(usb_standard_configuration_descriptor_t);
+                descriptor->max_power = 100;
+                descriptor->str_configuration = 0;
+                /// \TODO should this include device descriptor?
+                size_t hub_descriptor_size = 7 +
+                                2* (instance->port_count / 8 +
+                                ((instance->port_count % 8 > 0) ? 1 : 0));
+                descriptor->total_length =
+                                sizeof(usb_standard_configuration_descriptor_t)+
+                                sizeof(usb_standard_endpoint_descriptor_t)+
+                                sizeof(usb_standard_interface_descriptor_t)+
+                                hub_descriptor_size;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_configuration_descriptor_t);
+
+        }else if(setup_request_value == USB_DESCTYPE_INTERFACE){
+                usb_log_debug("USB_DESCTYPE_INTERFACE\n");
+                usb_standard_interface_descriptor_t * descriptor =
+                                (usb_standard_interface_descriptor_t*)
+                                malloc(sizeof(usb_standard_interface_descriptor_t));
+                descriptor->alternate_setting = 0;
+                descriptor->descriptor_type = USB_DESCTYPE_INTERFACE;
+                descriptor->endpoint_count = 1;
+                descriptor->interface_class = USB_CLASS_HUB;
+                /// \TODO is this correct?
+                descriptor->interface_number = 1;
+                descriptor->interface_protocol = 0;
+                descriptor->interface_subclass = 0;
+                descriptor->length = sizeof(usb_standard_interface_descriptor_t);
+                descriptor->str_interface = 0;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_interface_descriptor_t);
+        }else if(setup_request_value == USB_DESCTYPE_ENDPOINT){
+                usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
+                usb_standard_endpoint_descriptor_t * descriptor =
+                                (usb_standard_endpoint_descriptor_t*)
+                                malloc(sizeof(usb_standard_endpoint_descriptor_t));
+                descriptor->attributes = USB_TRANSFER_INTERRUPT;
+                descriptor->descriptor_type = USB_DESCTYPE_ENDPOINT;
+                descriptor->endpoint_address = 1 + (1<<7);
+                descriptor->length = sizeof(usb_standard_endpoint_descriptor_t);
+                descriptor->max_packet_size = 8;
+                descriptor->poll_interval = 255;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_endpoint_descriptor_t);
+        }else{
+                usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
+                usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
+                                setup_request->request_type,
+                                setup_request->request,
+                                setup_request_value,
+                                setup_request->index,
+                                setup_request->length
+                                );
+                return EINVAL;
+        }
+#endif
+        if(request->buffer_size < size){
+                size = request->buffer_size;
+        }
+        request->transfered_size = size;
+        memcpy(request->buffer,result_descriptor,size);
+        if (del)
+                free(result_descriptor);
+        return EOK;
+}
+
+static int process_get_configuration_request(rh_t *instance, 
+                usb_transfer_batch_t *request){
+        //set and get configuration requests do not have any meaning, only dummy
+        //values are returned
+        if(request->buffer_size != 1)
+                return EINVAL;
+        request->buffer[0] = 1;
+        request->transfered_size = 1;
+        return EOK;
+}
+
+static int process_hub_feature_set_request(rh_t *instance,
+                uint16_t feature, bool enable){
+        if(feature > USB_HUB_FEATURE_C_HUB_OVER_CURRENT)
+                return EINVAL;
+        instance->registers->rh_status =
+                        enable ?
+                        (instance->registers->rh_status | (1<<feature))
+                        :
+                        (instance->registers->rh_status & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+}
+
+static int process_port_feature_set_request(rh_t *instance,
+                uint16_t feature, uint16_t port, bool enable){
+        if(feature > USB_HUB_FEATURE_C_PORT_RESET)
+                return EINVAL;
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        instance->registers->rh_port_status[port - 1] =
+                        enable ?
+                        (instance->registers->rh_port_status[port - 1] | (1<<feature))
+                        :
+                        (instance->registers->rh_port_status[port - 1] & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+}
+
+static int process_address_set_request(rh_t *instance,
+                uint16_t address){
+        instance->address = address;
+        return EOK;
+}
+
+static int process_request_with_output(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        if(setup_request->request == USB_DEVREQ_GET_STATUS){
+                usb_log_debug("USB_DEVREQ_GET_STATUS\n");
+                return process_get_status_request(instance, request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
+                usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
+                return process_get_descriptor_request(instance, request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
+                usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
+                return process_get_configuration_request(instance, request);
+        }
+        return ENOTSUP;
+}
+
+static int process_request_with_input(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        request->transfered_size = 0;
+        if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
+                return ENOTSUP;
+        }
+        if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
+                //set and get configuration requests do not have any meaning,
+                //only dummy values are returned
+                return EOK;
+        }
+        return ENOTSUP;
+}
+
+
+static int process_request_without_data(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        request->transfered_size = 0;
+        if(setup_request->request == USB_DEVREQ_CLEAR_FEATURE
+                                || setup_request->request == USB_DEVREQ_SET_FEATURE){
+                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
+                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
+                        return process_hub_feature_set_request(instance, setup_request->value,
+                                        setup_request->request == USB_DEVREQ_SET_FEATURE);
+                }
+                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
+                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
+                        return process_port_feature_set_request(instance, setup_request->value,
+                                        setup_request->index,
+                                        setup_request->request == USB_DEVREQ_SET_FEATURE);
+                }
+                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type);
+                return EINVAL;
+        }
+        if(setup_request->request == USB_DEVREQ_SET_ADDRESS){
+                usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
+                return process_address_set_request(instance, setup_request->value);
+        }
+        usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type);
+        return ENOTSUP;
+}
+
+
+/**
+ *
+ * @param instance
+ * @param request
+ * @return
+ */
 int rh_request(rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
         assert(request);
-        /* TODO: implement */
-        if (request->setup_buffer) {
-                usb_log_info("Root hub got SETUP packet: %s.\n",
-                    usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
-        }
-        usb_log_error("Root hub request processing not implemented.\n");
-        usb_transfer_batch_finish(request, ENOTSUP);
+        int opResult;
+        if(request->transfer_type == USB_TRANSFER_CONTROL){
+                if (request->setup_buffer) {
+                        usb_log_info("Root hub got CTRL packet: %s.\n",
+                                usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
+                        if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
+                                usb_log_error("setup packet too small\n");
+                                return EINVAL;
+                        }
+                        usb_device_request_setup_packet_t * setup_request =
+                                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+                        if(
+                                setup_request->request == USB_DEVREQ_GET_STATUS
+                                || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR
+                                || setup_request->request == USB_DEVREQ_GET_CONFIGURATION
+                        ){
+                                usb_log_debug("processing request with output\n");
+                                opResult = process_request_with_output(instance,request);
+                        }else if(
+                                setup_request->request == USB_DEVREQ_CLEAR_FEATURE
+                                || setup_request->request == USB_DEVREQ_SET_FEATURE
+                                || setup_request->request == USB_DEVREQ_SET_ADDRESS
+                        ){
+                                usb_log_debug("processing request without additional data\n");
+                                opResult = process_request_without_data(instance,request);
+                        }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR
+                                        || setup_request->request == USB_DEVREQ_SET_CONFIGURATION
+                        ){
+                                usb_log_debug("processing request with input\n");
+                                opResult = process_request_with_input(instance,request);
+                        }else{
+                                usb_log_warning("received unsuported request: %d\n",
+                                                setup_request->request
+                                                );
+                                opResult = ENOTSUP;
+                        }
+                }else{
+                        usb_log_error("root hub received empty transaction?");
+                        opResult = EINVAL;
+                }
+        }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){
+                usb_log_info("Root hub got INTERRUPT packet\n");
+                void * buffer;
+                create_interrupt_mask(instance, &buffer,
+                        &(request->transfered_size));
+                memcpy(request->transport_buffer,buffer, request->transfered_size);
+                opResult = EOK;
+        }else{
+                opResult = EINVAL;
+        }
+        usb_transfer_batch_finish(request, opResult);
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+
+
 void rh_interrupt(rh_t *instance)
 {

uspace/drv/ohci/root_hub.h

@@ -45 +45 @@
         usb_address_t address;
         ddf_dev_t *device;
+        int port_count;
 } rh_t;
 

uspace/drv/uhci-hcd/Makefile

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

uspace/drv/uhci-hcd/hc.c

@@ -223 +223 @@
         ret = instance ? EOK : ENOMEM;
         CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
-        usb_log_debug("Initialized frame list.\n");
+        usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
 
         /* Set all frames to point to the first queue head */
@@ -336 +336 @@
             instance->transfers[batch->speed][batch->transfer_type];
         assert(list);
+        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                usb_device_keeper_use_control(
+                    &instance->manager, batch->target.address);
+        }
         transfer_list_add_batch(list, batch);
 
@@ -357 +361 @@
         /* Lower 2 bits are transaction error and transaction complete */
         if (status & 0x3) {
-                transfer_list_remove_finished(&instance->transfers_interrupt);
-                transfer_list_remove_finished(&instance->transfers_control_slow);
-                transfer_list_remove_finished(&instance->transfers_control_full);
-                transfer_list_remove_finished(&instance->transfers_bulk_full);
+                LIST_INITIALIZE(done);
+                transfer_list_remove_finished(
+                    &instance->transfers_interrupt, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_control_slow, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_control_full, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_bulk_full, &done);
+
+                while (!list_empty(&done)) {
+                        link_t *item = done.next;
+                        list_remove(item);
+                        usb_transfer_batch_t *batch =
+                            list_get_instance(item, usb_transfer_batch_t, link);
+                        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                                usb_device_keeper_release_control(
+                                    &instance->manager, batch->target.address);
+                        }
+                        batch->next_step(batch);
+                }
         }
         /* bits 4 and 5 indicate hc error */

uspace/drv/uhci-hcd/root_hub.c

@@ -48 +48 @@
  * @return Error code.
  */
-int rh_init(
-    rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
+int rh_init(rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
 {
         assert(fun);

uspace/drv/uhci-hcd/transfer_list.c

@@ -58 +58 @@
         }
         instance->queue_head_pa = addr_to_phys(instance->queue_head);
+        usb_log_debug2("Transfer list %s setup with QH: %p(%p).\n",
+            name, instance->queue_head, instance->queue_head_pa);
 
         qh_init(instance->queue_head);
@@ -118 +120 @@
         qh_set_next_qh(last_qh, pa);
 
+        asm volatile ("": : :"memory");
+
         /* Add to the driver list */
         list_append(&batch->link, &instance->batch_list);
@@ -137 +141 @@
  * this transfer list leading to the deadlock if its done inline.
  */
-void transfer_list_remove_finished(transfer_list_t *instance)
-{
-        assert(instance);
-
-        LIST_INITIALIZE(done);
+void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
+{
+        assert(instance);
+        assert(done);
 
         fibril_mutex_lock(&instance->guard);
@@ -153 +156 @@
                         /* Save for post-processing */
                         transfer_list_remove_batch(instance, batch);
-                        list_append(current, &done);
+                        list_append(current, done);
                 }
                 current = next;
@@ -159 +162 @@
         fibril_mutex_unlock(&instance->guard);
 
-        while (!list_empty(&done)) {
-                link_t *item = done.next;
-                list_remove(item);
-                usb_transfer_batch_t *batch =
-                    list_get_instance(item, usb_transfer_batch_t, link);
-                batch->next_step(batch);
-        }
 }
 /*----------------------------------------------------------------------------*/
@@ -222 +218 @@
                 qpos = "NOT FIRST";
         }
+        asm volatile ("": : :"memory");
         /* Remove from the batch list */
         list_remove(&batch->link);

uspace/drv/uhci-hcd/transfer_list.h

@@ -67 +67 @@
 void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
 
-void transfer_list_remove_finished(transfer_list_t *instance);
+void transfer_list_remove_finished(transfer_list_t *instance, link_t *done);
 
 void transfer_list_abort_all(transfer_list_t *instance);

uspace/drv/uhci-hcd/uhci.c

@@ -44 +44 @@
 #include "pci.h"
 
-
 /** IRQ handling callback, identifies device
  *
@@ -108 +107 @@
 /*----------------------------------------------------------------------------*/
 static ddf_dev_ops_t hc_ops = {
-        .interfaces[USB_DEV_IFACE] = &usb_iface,
+//      .interfaces[USB_DEV_IFACE] = &usb_iface,
         .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
 };

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

@@ -40 +40 @@
 #include <as.h>
 
+#include "slab.h"
+
 #define UHCI_STRCUTURES_ALIGNMENT 16
 #define UHCI_REQUIRED_PAGE_SIZE 4096
+
 
 /** Get physical address translation
@@ -54 +57 @@
 
         uintptr_t result;
-        int ret = as_get_physical_mapping(addr, &result);
+        const int ret = as_get_physical_mapping(addr, &result);
+        assert(ret == EOK);
 
         if (ret != EOK)
@@ -66 +70 @@
  * @return Address of the alligned and big enough memory place, NULL on failure.
  */
-static inline void * malloc32(size_t size)
-        { return memalign(UHCI_STRCUTURES_ALIGNMENT, size); }
+static inline void * malloc32(size_t size) {
+        if (size <= SLAB_ELEMENT_SIZE)
+                return slab_malloc_g();
+        assert(false);
+        return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
+}
 /*----------------------------------------------------------------------------*/
 /** Physical mallocator simulator
@@ -73 +81 @@
  * @param[in] addr Address of the place allocated by malloc32
  */
-static inline void free32(void *addr)
-        { if (addr) free(addr); }
+static inline void free32(void *addr) {
+        if (!addr)
+                return;
+        if (slab_in_range_g(addr))
+                return slab_free_g(addr);
+        free(addr);
+}
 /*----------------------------------------------------------------------------*/
 /** Create 4KB page mapping
@@ -82 +95 @@
 static inline void * get_page(void)
 {
-        void * free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
-        assert(free_address);
+        void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
+        assert(free_address); /* TODO: remove this assert */
         if (free_address == 0)
                 return NULL;
-        void* ret =
-          as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
+        void *ret = as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
                   AS_AREA_READ | AS_AREA_WRITE);
         if (ret != free_address)

uspace/drv/usbhub/port_status.h

@@ -30 +30 @@
  */
 
-#ifndef PORT_STATUS_H
-#define PORT_STATUS_H
+#ifndef HUB_PORT_STATUS_H
+#define HUB_PORT_STATUS_H
 
 #include <bool.h>
@@ -335 +335 @@
 
 
-#endif  /* PORT_STATUS_H */
+#endif  /* HUB_PORT_STATUS_H */
 
 /**

uspace/drv/usbhub/usbhub.c

@@ -162 +162 @@
             std_descriptor->configuration_count);
         if(std_descriptor->configuration_count<1){
-                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
-                //shouldn`t I return?
-                //definitely
+                usb_log_error("there are no configurations available\n");
                 return EINVAL;
         }

uspace/lib/c/generic/malloc.c

@@ -240 +240 @@
         size_t asize = ALIGN_UP(size, PAGE_SIZE);
         
-        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
+        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
         if (astart == (void *) -1)
                 return false;

uspace/lib/usb/Makefile

@@ -50 +50 @@
         src/usb.c \
         src/usbdevice.c \
+        src/hidreq.c \
+        src/hidreport.c \
         src/host/device_keeper.c \
         src/host/batch.c

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

@@ -70 +70 @@
  * Description of path of usage pages and usages in report descriptor
  */
+#define USB_HID_PATH_COMPARE_STRICT                             0
+#define USB_HID_PATH_COMPARE_END                                1
+#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    4
+
 typedef struct {
         int32_t usage_page;
+        int32_t usage;
+
+        link_t link;
+} usb_hid_report_usage_path_t;
+
+typedef struct {
+        int depth;      
+        link_t link;
 } usb_hid_report_path_t;
 
@@ -79 +91 @@
 typedef struct {
         int32_t id;
-        int32_t usage_page;
-        int32_t usage;  
         int32_t usage_minimum;
         int32_t usage_maximum;
@@ -107 +117 @@
         uint8_t item_flags;
 
+        usb_hid_report_path_t *usage_path;
         link_t link;
 } usb_hid_report_item_t;
@@ -117 +128 @@
         link_t feature;
 } usb_hid_report_parser_t;      
-
 
 
@@ -194 +204 @@
 int usb_hid_parse_report(const usb_hid_report_parser_t *parser,  
     const uint8_t *data, size_t size,
+    usb_hid_report_path_t *path, int flags,
     const usb_hid_report_in_callbacks_t *callbacks, void *arg);
 
 int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
-        const usb_hid_report_path_t *path);
+        usb_hid_report_path_t *path, int flags);
 
 
@@ -204 +215 @@
 void usb_hid_descriptor_print(usb_hid_report_parser_t *parser);
 
+/* usage path functions */
+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_append_item(usb_hid_report_path_t *usage_path, 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);
+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_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path);
+
+
+// output
+//      - funkce co vrati cesty poli v output reportu
+//      - funkce co pro danou cestu nastavi data
+//      - finalize
+
 #endif
 /**

uspace/lib/usb/include/usb/host/device_keeper.h

@@ -51 +51 @@
         usb_speed_t speed;
         bool occupied;
+        bool control_used;
         uint16_t toggle_status[2];
         devman_handle_t handle;
@@ -61 +62 @@
         struct usb_device_info devices[USB_ADDRESS_COUNT];
         fibril_mutex_t guard;
-        fibril_condvar_t default_address_occupied;
+        fibril_condvar_t change;
         usb_address_t last_address;
 } usb_device_keeper_t;
@@ -97 +98 @@
     usb_address_t address);
 
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_address_t address);
+
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_address_t address);
+
 #endif
 /**

uspace/lib/usb/src/hidparser.c

@@ -47 +47 @@
 
 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_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_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_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_item_t *report_item, usb_hid_report_path_t *usage_path);
 
 void usb_hid_descriptor_print_list(link_t *head);
@@ -63 +63 @@
 int usb_pow(int a, int b);
 
+
 int usb_pow(int a, int b)
 {
@@ -84 +85 @@
 {
    if(parser == NULL) {
-        return -1;
+        return EINVAL;
    }
 
@@ -110 +111 @@
         int ret;
         usb_hid_report_item_t *report_item=0;
-        usb_hid_report_item_t *new_report_item;
+        usb_hid_report_item_t *new_report_item; 
+        usb_hid_report_path_t *usage_path;
+        usb_hid_report_path_t *tmp_usage_path;
 
         size_t offset_input=0;
@@ -117 +120 @@
         
 
+        /* parser structure initialization*/
+        if(usb_hid_parser_init(parser) != EOK) {
+                return EINVAL;
+        }
+        
+
+        /*report item initialization*/
         if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
                 return ENOMEM;
         }
         memset(report_item, 0, sizeof(usb_hid_report_item_t));
-        
-        link_initialize(&(report_item->link));  
-
+        list_initialize(&(report_item->link));  
+
+        /* usage path context initialization */
+        if(!(usage_path=usb_hid_report_path())){
+                return ENOMEM;
+        }
+        
         while(i<size){  
                 if(!USB_HID_ITEM_IS_LONG(data[i])){
 
                         if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
-                                return -1; // TODO ERROR CODE
+                                return EINVAL; // TODO ERROR CODE
                         }
                         
@@ -141 +155 @@
                         
                         ret = usb_hid_report_parse_tag(tag,class,data+i+1,
-                                                 item_size,report_item);
+                                                       item_size,report_item, usage_path);
                         usb_log_debug2("ret: %u\n", ret);
                         switch(ret){
                                 case USB_HID_NEW_REPORT_ITEM:
                                         // store report item to report and create the new one
-                                        usb_log_debug("\nNEW REPORT ITEM: %X",tag);
+                                        usb_log_debug("\nNEW REPORT ITEM: %X",ret);
+
+                                        // store current usage path
+                                        report_item->usage_path = usage_path;
+
+                                        // new current usage path 
+                                        tmp_usage_path = usb_hid_report_path();
+                                        
+                                        // copy old path to the new one
+                                        usb_hid_report_path_clone(tmp_usage_path, usage_path);
+
+                                        // swap
+                                        usage_path = tmp_usage_path;
+                                        tmp_usage_path = NULL;
+
                                         
                                         switch(tag) {
@@ -184 +212 @@
                                         link_initialize(&(new_report_item->link));
                                         report_item = new_report_item;
-                                        
+                                                                                
                                         break;
                                 case USB_HID_REPORT_TAG_PUSH:
@@ -284 +312 @@
  */
 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_item_t *report_item, usb_hid_report_path_t *usage_path)
 {       
         int ret;
@@ -291 +319 @@
                 case USB_HID_TAG_CLASS_MAIN:
 
-                        if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item)) == EOK) {
+                        if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) {
                                 return USB_HID_NEW_REPORT_ITEM;
                         }
@@ -301 +329 @@
 
                 case USB_HID_TAG_CLASS_GLOBAL:  
-                        return usb_hid_report_parse_global_tag(tag,data,item_size,report_item);
+                        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);
+                        return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path);
                         break;
                 default:
@@ -323 +351 @@
 
 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_item_t *report_item, usb_hid_report_path_t *usage_path)
+{               
         switch(tag)
         {
@@ -335 +363 @@
                         
                 case USB_HID_REPORT_TAG_COLLECTION:
-                        // TODO
+                        usb_hid_report_path_append_item(usage_path, 0, 0);
+                                                
                         return USB_HID_NO_ACTION;
                         break;
                         
                 case USB_HID_REPORT_TAG_END_COLLECTION:
-                        /* should be ignored */
+                        // TODO
+                        // znici posledni uroven ve vsech usage paths
+                        // otazka jestli nema nicit dve, respektive novou posledni vynulovat?
+                        usb_hid_report_remove_last_item(usage_path);
                         return USB_HID_NO_ACTION;
                         break;
@@ -361 +393 @@
 
 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_item_t *report_item, usb_hid_report_path_t *usage_path)
 {
         // TODO take care about the bit length of data
@@ -367 +399 @@
         {
                 case USB_HID_REPORT_TAG_USAGE_PAGE:
-                        report_item->usage_page = usb_hid_report_tag_data_int32(data,item_size);
+                        // zmeni to jenom v poslednim poli aktualni usage path
+                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL,
+                                usb_hid_report_tag_data_int32(data,item_size));
                         break;
                 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
@@ -418 +452 @@
  */
 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_item_t *report_item, usb_hid_report_path_t *usage_path)
 {
         switch(tag)
         {
                 case USB_HID_REPORT_TAG_USAGE:
-                        report_item->usage = usb_hid_report_tag_data_int32(data,item_size);
+                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL,
+                                usb_hid_report_tag_data_int32(data,item_size));
                         break;
                 case USB_HID_REPORT_TAG_USAGE_MINIMUM:
@@ -491 +526 @@
 {
         usb_hid_report_item_t *report_item;
+        usb_hid_report_usage_path_t *path_item;
+        link_t *path;
         link_t *item;
         
@@ -507 +544 @@
                 usb_log_debug("\tCONSTANT/VAR: %X\n", USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags));
                 usb_log_debug("\tVARIABLE/ARRAY: %X\n", USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags));
-                usb_log_debug("\tUSAGE: %X\n", report_item->usage);
-                usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page);
+                usb_log_debug("\tUSAGE PATH:\n");
+
+                path = report_item->usage_path->link.next;
+                while(path != &report_item->usage_path->link)   {
+                        path_item = list_get_instance(path, usb_hid_report_usage_path_t, link);
+                        usb_log_debug("\t\tUSAGE PAGE: %X, USAGE: %X\n", path_item->usage_page, path_item->usage);
+                        path = path->next;
+                }
+                
+                
+//              usb_log_debug("\tUSAGE: %X\n", report_item->usage);
+//              usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page);
                 usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum);
                 usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum);          
@@ -530 +577 @@
 void usb_hid_descriptor_print(usb_hid_report_parser_t *parser)
 {
+        if(parser == NULL) {
+                return;
+        }
+        
         usb_log_debug("INPUT:\n");
         usb_hid_descriptor_print_list(&parser->input);
@@ -561 +612 @@
         
             report_item = list_get_instance(next, usb_hid_report_item_t, link);
+
+                while(!list_empty(&report_item->usage_path->link)) {
+                        usb_hid_report_remove_last_item(report_item->usage_path);
+                }
+
+                
             next = next->next;
             
@@ -600 +657 @@
 int usb_hid_parse_report(const usb_hid_report_parser_t *parser,  
     const uint8_t *data, size_t size,
+    usb_hid_report_path_t *path, int flags,
     const usb_hid_report_in_callbacks_t *callbacks, void *arg)
 {
@@ -615 +673 @@
         size_t j=0;
 
+        if(parser == NULL) {
+                return EINVAL;
+        }
+
+        
         // get the size of result keycodes array
-        usb_hid_report_path_t path;
-        path.usage_page = BAD_HACK_USAGE_PAGE;
-        key_count = usb_hid_report_input_length(parser, &path);
+        key_count = usb_hid_report_input_length(parser, path, flags);
 
         if(!(keys = malloc(sizeof(uint8_t) * key_count))){
@@ -629 +690 @@
 
                 item = list_get_instance(list_item, usb_hid_report_item_t, link);
-                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) &&
-                   (item->usage_page == path.usage_page)) {
+                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 
+                   (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) {
                         for(j=0; j<(size_t)(item->count); j++) {
                                 if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) ||
@@ -640 +701 @@
                                         // bitmapa
                                         if((item_value = usb_hid_translate_data(item, data, j)) != 0) {
-                                                keys[i++] = j + item->usage_minimum;
+                                                keys[i++] = (item->count - 1 - j) + item->usage_minimum;
                                         }
                                         else {
@@ -736 +797 @@
 
 int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
-        const usb_hid_report_path_t *path)
-{
+        usb_hid_report_path_t *path, int flags)
+{       
         int ret = 0;
         link_t *item;
         usb_hid_report_item_t *report_item;
 
+        if(parser == NULL) {
+                return EINVAL;
+        }
+        
         item = (&parser->input)->next;
         while(&parser->input != item) {
                 report_item = list_get_instance(item, usb_hid_report_item_t, link);
                 if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) &&
-                   (report_item->usage_page == path->usage_page)) {
+                   (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) {
                         ret += report_item->count;
                 }
@@ -757 +822 @@
 
 
+/**
+ * 
+ */
+int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 
+                                    int32_t usage_page, int32_t usage)
+{       
+        usb_hid_report_usage_path_t *item;
+
+        if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) {
+                return ENOMEM;
+        }
+        list_initialize(&item->link);
+
+        item->usage = usage;
+        item->usage_page = usage_page;
+        
+        list_append (&usage_path->link, &item->link);
+        usage_path->depth++;
+        return EOK;
+}
+
+/**
+ *
+ */
+void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path)
+{
+        usb_hid_report_usage_path_t *item;
+        
+        if(!list_empty(&usage_path->link)){
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);             
+                list_remove(usage_path->link.prev);
+                usage_path->depth--;
+                free(item);
+        }
+}
+
+/**
+ *
+ */
+void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path)
+{
+        usb_hid_report_usage_path_t *item;
+        
+        if(!list_empty(&usage_path->link)){     
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
+                memset(item, 0, sizeof(usb_hid_report_usage_path_t));
+        }
+}
+
+/**
+ *
+ */
+void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data)
+{
+        usb_hid_report_usage_path_t *item;
+        
+        if(!list_empty(&usage_path->link)){     
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
+
+                switch(tag) {
+                        case USB_HID_TAG_CLASS_GLOBAL:
+                                item->usage_page = data;
+                                break;
+                        case USB_HID_TAG_CLASS_LOCAL:
+                                item->usage = data;
+                                break;
+                }
+        }
+        
+}
+
+/**
+ *
+ */
+int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 
+                                      usb_hid_report_path_t *path,
+                                      int flags)
+{
+        usb_hid_report_usage_path_t *report_item;
+        usb_hid_report_usage_path_t *path_item;
+
+        link_t *report_link;
+        link_t *path_link;
+
+        int only_page;
+
+        if(path->depth == 0){
+                return EOK;
+        }
+
+
+        if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){
+                flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY;
+        }
+        
+        switch(flags){
+                /* path must be completly identical */
+                case USB_HID_PATH_COMPARE_STRICT:
+                                if(report_path->depth != path->depth){
+                                        return 1;
+                                }
+
+                                report_link = report_path->link.next;
+                                path_link = path->link.next;
+                        
+                                while((report_link != &report_path->link) && (path_link != &path->link)) {
+                                        report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
+                                        path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);            
+
+                                        if((report_item->usage_page != path_item->usage_page) || 
+                                           ((only_page == 0) && (report_item->usage != path_item->usage))) {
+                                                   return 1;
+                                        } else {
+                                                report_link = report_link->next;
+                                                path_link = path_link->next;                    
+                                        }
+                        
+                                }
+
+                                if((report_link == &report_path->link) && (path_link == &path->link)) {
+                                        return EOK;
+                                }
+                                else {
+                                        return 1;
+                                }                                               
+                        break;
+
+                /* given path must be the end of the report one*/
+                case USB_HID_PATH_COMPARE_END:
+                                report_link = report_path->link.prev;
+                                path_link = path->link.prev;
+
+                                if(list_empty(&path->link)){
+                                        return EOK;
+                                }
+                        
+                                while((report_link != &report_path->link) && (path_link != &path->link)) {
+                                        report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
+                                        path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);            
+
+                                        if((report_item->usage_page != path_item->usage_page) || 
+                                           ((only_page == 0) && (report_item->usage != path_item->usage))) {
+                                                   return 1;
+                                        } else {
+                                                report_link = report_link->prev;
+                                                path_link = path_link->prev;                    
+                                        }
+                        
+                                }
+
+                                if(path_link == &path->link) {
+                                        return EOK;
+                                }
+                                else {
+                                        return 1;
+                                }                                               
+                        
+                        break;
+
+                default:
+                        return EINVAL;
+        }
+        
+        
+        
+        
+}
+
+/**
+ *
+ */
+usb_hid_report_path_t *usb_hid_report_path(void)
+{
+        usb_hid_report_path_t *path;
+        path = malloc(sizeof(usb_hid_report_path_t));
+        if(!path){
+                return NULL;
+        }
+        else {
+                path->depth = 0;
+                list_initialize(&path->link);
+                return path;
+        }
+}
+
+/**
+ *
+ */
+void usb_hid_report_path_free(usb_hid_report_path_t *path)
+{
+        while(!list_empty(&path->link)){
+                usb_hid_report_remove_last_item(path);
+        }
+}
+
+
+/**
+ *
+ */
+int     usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path)
+{
+        usb_hid_report_usage_path_t *path_item;
+        link_t *path_link;
+
+        
+        if(list_empty(&usage_path->link)){
+                return EOK;
+        }
+
+        path_link = usage_path->link.next;
+        while(path_link != &usage_path->link) {
+                path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
+                usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage);
+
+                path_link = path_link->next;
+        }
+
+        return EOK;
+}
+
 
 /**

uspace/lib/usb/src/host/device_keeper.c

@@ -49 +49 @@
         assert(instance);
         fibril_mutex_initialize(&instance->guard);
-        fibril_condvar_initialize(&instance->default_address_occupied);
+        fibril_condvar_initialize(&instance->change);
         instance->last_address = 0;
         unsigned i = 0;
         for (; i < USB_ADDRESS_COUNT; ++i) {
                 instance->devices[i].occupied = false;
+                instance->devices[i].control_used = false;
                 instance->devices[i].handle = 0;
                 instance->devices[i].toggle_status[0] = 0;
@@ -71 +72 @@
         fibril_mutex_lock(&instance->guard);
         while (instance->devices[USB_ADDRESS_DEFAULT].occupied) {
-                fibril_condvar_wait(&instance->default_address_occupied,
-                    &instance->guard);
+                fibril_condvar_wait(&instance->change, &instance->guard);
         }
         instance->devices[USB_ADDRESS_DEFAULT].occupied = true;
@@ -90 +90 @@
         instance->devices[USB_ADDRESS_DEFAULT].occupied = false;
         fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->default_address_occupied);
+        fibril_condvar_signal(&instance->change);
 }
 /*----------------------------------------------------------------------------*/
@@ -309 +309 @@
         return instance->devices[address].speed;
 }
-
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_address_t address)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[address].control_used) {
+                fibril_condvar_wait(&instance->change, &instance->guard);
+        }
+        instance->devices[address].control_used = true;
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_address_t address)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        instance->devices[address].control_used = false;
+        fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_signal(&instance->change);
+}
 /**
  * @}