Changes in / [bd2394b:cc5908e] in mainline

Files:

• .bzrignore (modified) (1 diff)
• boot/Makefile.common (modified) (2 diffs)
• uspace/Makefile (modified) (2 diffs)
• uspace/app/lsusb/Makefile (added)
• uspace/app/lsusb/main.c (added)
• uspace/app/usbinfo/main.c (modified) (2 diffs)
• uspace/app/virtusbkbd/Makefile (deleted)
• uspace/app/virtusbkbd/descriptor.h (deleted)
• uspace/app/virtusbkbd/items.h (deleted)
• uspace/app/virtusbkbd/kbdconfig.c (deleted)
• uspace/app/virtusbkbd/kbdconfig.h (deleted)
• uspace/app/virtusbkbd/keys.c (deleted)
• uspace/app/virtusbkbd/keys.h (deleted)
• uspace/app/virtusbkbd/report.h (deleted)
• uspace/app/virtusbkbd/stdreq.c (deleted)
• uspace/app/virtusbkbd/stdreq.h (deleted)
• uspace/app/virtusbkbd/virtusbkbd.c (deleted)
• uspace/app/vuhid/device.c (modified) (5 diffs)
• uspace/app/vuhid/hids/bootkbd.c (modified) (2 diffs)
• uspace/app/vuhid/items.h (added)
• uspace/app/vuhid/main.c (modified) (3 diffs)
• uspace/app/vuhid/report.h (added)
• uspace/app/vuhid/virthid.h (modified) (4 diffs)
• uspace/doc/doxygroups.h (modified) (1 diff)
• uspace/drv/ehci-hcd/main.c (modified) (1 diff)
• uspace/drv/ohci/hc.c (modified) (10 diffs)
• uspace/drv/ohci/hc.h (modified) (1 diff)
• uspace/drv/ohci/main.c (modified) (2 diffs)
• uspace/drv/ohci/ohci.c (modified) (4 diffs)
• uspace/drv/ohci/pci.c (modified) (1 diff)
• uspace/drv/ohci/root_hub.c (modified) (50 diffs)
• uspace/drv/ohci/root_hub.h (modified) (1 diff)
• uspace/drv/uhci-hcd/uhci.c (modified) (1 diff)
• uspace/drv/usbhid/generic/hiddev.c (modified) (4 diffs)
• uspace/drv/usbhid/kbd/kbddev.c (modified) (4 diffs)
• uspace/drv/usbhid/mouse/mousedev.c (modified) (14 diffs)
• uspace/drv/usbhid/mouse/mousedev.h (modified) (1 diff)
• uspace/drv/usbhid/subdrivers.c (modified) (2 diffs)
• uspace/drv/usbhid/usbhid.c (modified) (4 diffs)
• uspace/drv/usbhid/usbhid.h (modified) (2 diffs)
• uspace/drv/usbhub/ports.c (modified) (4 diffs)
• uspace/drv/vhc/main.c (modified) (1 diff)
• uspace/drv/vhc/transfer.c (modified) (2 diffs)
• uspace/lib/c/generic/devman.c (modified) (1 diff)
• uspace/lib/c/include/devman.h (modified) (1 diff)
• uspace/lib/c/include/ipc/devman.h (modified) (1 diff)
• uspace/lib/usb/Makefile (modified) (1 diff)
• uspace/lib/usb/include/usb/classes/hid_report_items.h (modified) (1 diff)
• uspace/lib/usb/include/usb/classes/hidtypes.h (modified) (3 diffs)
• uspace/lib/usb/include/usb/host.h (added)
• uspace/lib/usb/include/usb/usb.h (modified) (1 diff)
• uspace/lib/usb/src/hiddescriptor.c (modified) (9 diffs)
• uspace/lib/usb/src/hidparser.c (modified) (1 diff)
• uspace/lib/usb/src/host.c (added)
• uspace/lib/usbvirt/Makefile (modified) (1 diff)
• uspace/lib/usbvirt/include/usbvirt/device.h (modified) (4 diffs)
• uspace/lib/usbvirt/include/usbvirt/ipc.h (modified) (4 diffs)
• uspace/lib/usbvirt/src/ctrltransfer.c (modified) (3 diffs)
• uspace/lib/usbvirt/src/device.c (added)
• uspace/lib/usbvirt/src/ipc.c (deleted)
• uspace/lib/usbvirt/src/ipc_dev.c (added)
• uspace/lib/usbvirt/src/ipc_hc.c (added)
• uspace/lib/usbvirt/src/private.h (modified) (2 diffs)
• uspace/lib/usbvirt/src/stdreq.c (modified) (4 diffs)
• uspace/lib/usbvirt/src/transfer.c (modified) (6 diffs)
• uspace/srv/devman/main.c (modified) (2 diffs)

.bzrignore

@@ -49 +49 @@
 ./uspace/app/killall/killall
 ./uspace/app/klog/klog
+./uspace/app/lsusb/lsusb
 ./uspace/app/mkfat/mkfat
 ./uspace/app/netstart/netstart

boot/Makefile.common

@@ -128 +128 @@
         $(USPACE_PATH)/app/killall/killall \
         $(USPACE_PATH)/app/mkfat/mkfat \
+        $(USPACE_PATH)/app/lsusb/lsusb \
         $(USPACE_PATH)/app/sbi/sbi \
         $(USPACE_PATH)/app/redir/redir \
@@ -140 +141 @@
         $(USPACE_PATH)/app/stats/stats \
         $(USPACE_PATH)/app/sysinfo/sysinfo \
-        $(USPACE_PATH)/app/tasks/tasks \
         $(USPACE_PATH)/app/top/top \
         $(USPACE_PATH)/app/usbinfo/usbinfo \
-        $(USPACE_PATH)/app/virtusbkbd/vuk \
         $(USPACE_PATH)/app/vuhid/vuh \
         $(USPACE_PATH)/app/websrv/websrv

uspace/Makefile

@@ -41 +41 @@
         app/killall \
         app/klog \
+        app/lsusb \
         app/mkfat \
         app/redir \
@@ -51 +52 @@
         app/top \
         app/usbinfo \
-        app/virtusbkbd \
         app/vuhid \
         app/netecho \

uspace/app/usbinfo/main.c

@@ -45 +45 @@
 #include <usb/usbdevice.h>
 #include <usb/pipes.h>
+#include <usb/host.h>
 #include "usbinfo.h"
+
+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;
+}
 
 static bool resolve_hc_handle_and_dev_addr(const char *devpath,
@@ -60 +92 @@
         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;
         }
 

uspace/app/vuhid/device.c

@@ -77 +77 @@
 {
         vuhid_interface_t *iface = arg;
+        vuhid_data_t *hid_data = iface->vuhid_data;
 
         if (iface->live != NULL) {
                 iface->live(iface);
         }
+
+        fibril_mutex_lock(&hid_data->iface_count_mutex);
+        hid_data->iface_died_count++;
+        fibril_condvar_broadcast(&hid_data->iface_count_cv);
+        fibril_mutex_unlock(&hid_data->iface_count_mutex);
 
         return EOK;
@@ -110 +116 @@
         if ((iface->in_data_size == 0) && (iface->out_data_size == 0)) {
                 return EEMPTY;
+        }
+
+        // FIXME - we shall set vuhid_data to NULL in the main() rather
+        // than to depend on individual interfaces
+        /* Already used interface. */
+        if (iface->vuhid_data != NULL) {
+                return EEXISTS;
         }
 
@@ -252 +265 @@
 
         /* Launch the "life" fibril. */
+        iface->vuhid_data = hid_data;
         fid_t life_fibril = fibril_create(interface_life_fibril, iface);
         if (life_fibril == 0) {
@@ -310 +324 @@
             += total_descr_size;
 
+        hid_data->iface_count++;
         fibril_add_ready(life_fibril);
 
@@ -331 +346 @@
 }
 
+void wait_for_interfaces_death(usbvirt_device_t *dev)
+{
+        vuhid_data_t *hid_data = dev->device_data;
+
+        fibril_mutex_lock(&hid_data->iface_count_mutex);
+        while (hid_data->iface_died_count < hid_data->iface_count) {
+                fibril_condvar_wait(&hid_data->iface_count_cv,
+                    &hid_data->iface_count_mutex);
+        }
+        fibril_mutex_unlock(&hid_data->iface_count_mutex);
+}
 
 /** @}

uspace/app/vuhid/hids/bootkbd.c

@@ -39 +39 @@
 #include <usb/classes/hidut.h>
 
-#include "../../virtusbkbd/report.h"
+#include "../report.h"
 
 uint8_t report_descriptor[] = {
@@ -169 +169 @@
         .on_data_out = on_data_out,
 
-        .live = live
+        .live = live,
+
+        .vuhid_data = NULL
 };
 

uspace/app/vuhid/main.c

@@ -132 +132 @@
         .in_endpoint_first_free = 1,
         .out_endpoints_mapping = { NULL },
-        .out_endpoint_first_free = 1
-};
+        .out_endpoint_first_free = 1,
+
+        .iface_count = 0,
+        .iface_died_count = 0
+        // mutex and CV must be initialized elsewhere
+};
+
 
 /** Keyboard device.
@@ -151 +156 @@
 
         usb_log_enable(USB_LOG_LEVEL_DEBUG2, "vusbhid");
+
+        fibril_mutex_initialize(&vuhid_data.iface_count_mutex);
+        fibril_condvar_initialize(&vuhid_data.iface_count_cv);
 
         /* Determine which interfaces to initialize. */
@@ -182 +190 @@
         printf("Connected to VHCD...\n");
 
-        while (true) {
-                async_usleep(10 * 1000 * 1000);
-        }
+        wait_for_interfaces_death(&hid_dev);
         
         printf("Terminating...\n");
         
+        usbvirt_device_unplug(&hid_dev);
+
         return 0;
 }

uspace/app/vuhid/virthid.h

@@ -38 +38 @@
 #include <usb/usb.h>
 #include <usbvirt/device.h>
+#include <fibril_synch.h>
 
 #define VUHID_ENDPOINT_MAX USB11_ENDPOINT_MAX
@@ -43 +44 @@
 
 typedef struct vuhid_interface vuhid_interface_t;
+
+typedef struct {
+        vuhid_interface_t *in_endpoints_mapping[VUHID_ENDPOINT_MAX];
+        size_t in_endpoint_first_free;
+        vuhid_interface_t *out_endpoints_mapping[VUHID_ENDPOINT_MAX];
+        size_t out_endpoint_first_free;
+        vuhid_interface_t *interface_mapping[VUHID_INTERFACE_MAX];
+
+        fibril_mutex_t iface_count_mutex;
+        fibril_condvar_t iface_count_cv;
+        size_t iface_count;
+        size_t iface_died_count;
+} vuhid_data_t;
 
 struct vuhid_interface {
@@ -63 +77 @@
 
         void *interface_data;
+
+        vuhid_data_t *vuhid_data;
 };
-
-typedef struct {
-        vuhid_interface_t *in_endpoints_mapping[VUHID_ENDPOINT_MAX];
-        size_t in_endpoint_first_free;
-        vuhid_interface_t *out_endpoints_mapping[VUHID_ENDPOINT_MAX];
-        size_t out_endpoint_first_free;
-        vuhid_interface_t *interface_mapping[VUHID_INTERFACE_MAX];
-} vuhid_data_t;
 
 typedef struct {
@@ -84 +92 @@
 
 int add_interface_by_id(vuhid_interface_t **, const char *, usbvirt_device_t *);
+void wait_for_interfaces_death(usbvirt_device_t *);
 
 #endif

uspace/doc/doxygroups.h

@@ -220 +220 @@
 
         /**
+         * @defgroup lsusb HelenOS version of lsusb command
+         * @ingroup usb
+         * @brief Application for listing USB host controllers.
+         * @details
+         * List all found host controllers.
+         */
+
+        /**
          * @defgroup drvusbmid USB multi interface device driver
          * @ingroup usb

uspace/drv/ehci-hcd/main.c

@@ -97 +97 @@
         }
         hc_fun->ops = &hc_ops;
+
         ret = ddf_fun_bind(hc_fun);
-
         CHECK_RET_RETURN(ret,
             "Failed to bind EHCI function: %s.\n",
+            str_error(ret));
+        ret = ddf_fun_add_to_class(hc_fun, USB_HC_DDF_CLASS_NAME);
+        CHECK_RET_RETURN(ret,
+            "Failed to add EHCI to HC class: %s.\n",
             str_error(ret));
 

uspace/drv/ohci/hc.c

@@ -49 +49 @@
 static int interrupt_emulator(hc_t *instance);
 static void hc_gain_control(hc_t *instance);
-static void hc_init_hw(hc_t *instance);
 static int hc_init_transfer_lists(hc_t *instance);
 static int hc_init_memory(hc_t *instance);
@@ -92 +91 @@
                 usb_log_error("Failed add root hub match-id.\n");
         }
+        ret = ddf_fun_bind(hub_fun);
         return ret;
 }
@@ -111 +111 @@
             ret, str_error(ret));
 
+        list_initialize(&instance->pending_batches);
         usb_device_keeper_init(&instance->manager);
         ret = usb_endpoint_manager_init(&instance->ep_manager,
@@ -117 +118 @@
             str_error(ret));
 
-        hc_gain_control(instance);
         ret = hc_init_memory(instance);
         CHECK_RET_RETURN(ret, "Failed to create OHCI memory structures: %s.\n",
             str_error(ret));
-        hc_init_hw(instance);
+#undef CHECK_RET_RETURN
+
+
+//      hc_init_hw(instance);
+        hc_gain_control(instance);
         fibril_mutex_initialize(&instance->guard);
 
@@ -132 +136 @@
         }
 
-        list_initialize(&instance->pending_batches);
-#undef CHECK_RET_RETURN
         return EOK;
 }
@@ -287 +289 @@
 {
         assert(instance);
-        usb_log_debug("OHCI interrupt: %x.\n", status);
+        usb_log_debug("OHCI(%p) interrupt: %x.\n", instance, status);
         if ((status & ~I_SF) == 0) /* ignore sof status */
                 return;
@@ -339 +341 @@
             (uint32_t*)((char*)instance->registers + 0x100);
         usb_log_debug("OHCI legacy register %p: %x.\n",
-                ohci_emulation_reg, *ohci_emulation_reg);
-        *ohci_emulation_reg &= ~0x1;
+            ohci_emulation_reg, *ohci_emulation_reg);
+        /* Do not change A20 state */
+        *ohci_emulation_reg &= 0x100;
+        usb_log_debug("OHCI legacy register %p: %x.\n",
+            ohci_emulation_reg, *ohci_emulation_reg);
 
         /* Interrupt routing enabled => smm driver is active */
@@ -350 +355 @@
                 }
                 usb_log_info("SMM driver: Ownership taken.\n");
+                instance->registers->control &= (C_HCFS_RESET << C_HCFS_SHIFT);
+                async_usleep(50000);
                 return;
         }
@@ -375 +382 @@
 }
 /*----------------------------------------------------------------------------*/
-void hc_init_hw(hc_t *instance)
+void hc_start_hw(hc_t *instance)
 {
         /* OHCI guide page 42 */
@@ -474 +481 @@
 {
         assert(instance);
+
+        bzero(&instance->rh, sizeof(instance->rh));
         /* Init queues */
         hc_init_transfer_lists(instance);

uspace/drv/ohci/hc.h

@@ -80 +80 @@
      uintptr_t regs, size_t reg_size, bool interrupts);
 
+void hc_start_hw(hc_t *instance);
+
 /** Safely dispose host controller internal structures
  *

uspace/drv/ohci/main.c

@@ -75 +75 @@
                 return ret;
         }
-        device->driver_data = ohci;
+//      device->driver_data = ohci;
+        hc_register_hub(&ohci->hc, ohci->rh_fun);
 
         usb_log_info("Controlling new OHCI device `%s'.\n", device->name);
@@ -93 +94 @@
 {
         usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
-        sleep(5);
         return ddf_driver_main(&ohci_driver);
 }

uspace/drv/ohci/ohci.c

@@ -54 +54 @@
 {
         assert(dev);
+        assert(dev->driver_data);
         hc_t *hc = &((ohci_t*)dev->driver_data)->hc;
         uint16_t status = IPC_GET_ARG1(*call);
@@ -152 +153 @@
         usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
             (void *) mem_reg_base, mem_reg_size, irq);
-
-        ret = pci_disable_legacy(device);
-        CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed(%d) to disable legacy USB: %s.\n", ret, str_error(ret));
 
         bool interrupts = false;
@@ -188 +185 @@
             "Failed(%d) to bind OHCI device function: %s.\n",
             ret, str_error(ret));
+        ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed to add OHCI to HC class: %s.\n", str_error(ret));
+
 #undef CHECK_RET_HC_RETURN
 
@@ -212 +213 @@
             "Failed(%d) to create root hub function.\n", ret);
 
-        hc_register_hub(&instance->hc, instance->rh_fun);
 
         instance->rh_fun->ops = &rh_ops;
         instance->rh_fun->driver_data = NULL;
-        ret = ddf_fun_bind(instance->rh_fun);
-        CHECK_RET_FINI_RETURN(ret,
-            "Failed(%d) to register OHCI root hub.\n", ret);
-
+        
+        device->driver_data = instance;
+
+        hc_start_hw(&instance->hc);
         return EOK;
 #undef CHECK_RET_FINI_RETURN

uspace/drv/ohci/pci.c

@@ -136 +136 @@
         return enabled ? EOK : EIO;
 }
-/*----------------------------------------------------------------------------*/
-/** Implements BIOS handoff routine as decribed in OHCI spec
- *
- * @param[in] device Device asking for interrupts
- * @return Error code.
- */
-int pci_disable_legacy(ddf_dev_t *device)
-{
-        /* TODO: implement */
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
 /**
  * @}

uspace/drv/ohci/root_hub.c

@@ -45 +45 @@
 
 /**
- *      standart device descriptor for ohci root hub
+ * standart device descriptor for ohci root hub
  */
 static const usb_standard_device_descriptor_t ohci_rh_device_descriptor = {
@@ -69 +69 @@
  */
 static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = {
-        /// \TODO some values are default or guessed
         .attributes = 1 << 7,
         .configuration_number = 1,
@@ -87 +86 @@
         .endpoint_count = 1,
         .interface_class = USB_CLASS_HUB,
-        /// \TODO is this correct?
         .interface_number = 1,
         .interface_protocol = 0,
@@ -107 +105 @@
 };
 
+/**
+ * bitmask of hub features that are valid to be cleared
+ */
 static const uint32_t hub_clear_feature_valid_mask =
-        (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
+    (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
 
+/**
+ * bitmask of hub features that are cleared by writing 1 (and not 0)
+ */
 static const uint32_t hub_clear_feature_by_writing_one_mask =
-        1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
-
+    1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
+
+/**
+ * bitmask of hub features that are valid to be set
+ */
 static const uint32_t hub_set_feature_valid_mask =
-        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
+    (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
 (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
 
-
+/**
+ * bitmask of hub features that are set by writing 1 and cleared by writing 0
+ */
 static const uint32_t hub_set_feature_direct_mask =
-        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
-
+    (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
+
+/**
+ * bitmask of port features that are valid to be set
+ */
 static const uint32_t port_set_feature_valid_mask =
-        (1 << USB_HUB_FEATURE_PORT_ENABLE) |
+    (1 << USB_HUB_FEATURE_PORT_ENABLE) |
 (1 << USB_HUB_FEATURE_PORT_SUSPEND) |
 (1 << USB_HUB_FEATURE_PORT_RESET) |
 (1 << USB_HUB_FEATURE_PORT_POWER);
 
+/**
+ * bitmask of port features that can be cleared
+ */
 static const uint32_t port_clear_feature_valid_mask =
-        (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
+    (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
 (1 << USB_HUB_FEATURE_PORT_SUSPEND) |
 (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) |
@@ -141 +156 @@
 //USB_HUB_FEATURE_PORT_LOW_SPEED
 
+/**
+ * bitmask with port status changes
+ */
 static const uint32_t port_status_change_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);
+    (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);
 
 
@@ -154 +172 @@
 
 static int process_get_port_status_request(rh_t *instance, uint16_t port,
-        usb_transfer_batch_t * request);
+    usb_transfer_batch_t * request);
 
 static int process_get_hub_status_request(rh_t *instance,
-        usb_transfer_batch_t * request);
+    usb_transfer_batch_t * request);
 
 static int process_get_status_request(rh_t *instance,
-        usb_transfer_batch_t * request);
+    usb_transfer_batch_t * request);
 
 static void create_interrupt_mask_in_instance(rh_t *instance);
 
 static int process_get_descriptor_request(rh_t *instance,
-        usb_transfer_batch_t *request);
+    usb_transfer_batch_t *request);
 
 static int process_get_configuration_request(rh_t *instance,
-        usb_transfer_batch_t *request);
+    usb_transfer_batch_t *request);
 
 static int process_hub_feature_set_request(rh_t *instance, uint16_t feature);
 
 static int process_hub_feature_clear_request(rh_t *instance,
-        uint16_t feature);
+    uint16_t feature);
 
 static int process_port_feature_set_request(rh_t *instance,
-        uint16_t feature, uint16_t port);
+    uint16_t feature, uint16_t port);
 
 static int process_port_feature_clear_request(rh_t *instance,
-        uint16_t feature, uint16_t port);
+    uint16_t feature, uint16_t port);
 
 static int process_address_set_request(rh_t *instance,
-        uint16_t address);
+    uint16_t address);
 
 static int process_request_with_output(rh_t *instance,
-        usb_transfer_batch_t *request);
+    usb_transfer_batch_t *request);
 
 static int process_request_with_input(rh_t *instance,
-        usb_transfer_batch_t *request);
+    usb_transfer_batch_t *request);
 
 static int process_request_without_data(rh_t *instance,
-        usb_transfer_batch_t *request);
+    usb_transfer_batch_t *request);
 
 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request);
@@ -198 +216 @@
 
 static bool is_zeros(void * buffer, size_t size);
-
-
 
 /** Root hub initialization
@@ -210 +226 @@
             (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
         int opResult = rh_init_descriptors(instance);
-        if(opResult != EOK){
+        if (opResult != EOK) {
                 return opResult;
         }
@@ -216 +232 @@
         instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
         instance->unfinished_interrupt_transfer = NULL;
-        instance->interrupt_mask_size = (instance->port_count + 8)/8;
+        instance->interrupt_mask_size = (instance->port_count + 8) / 8;
         instance->interrupt_buffer = malloc(instance->interrupt_mask_size);
-        if(!instance->interrupt_buffer)
+        if (!instance->interrupt_buffer)
                 return ENOMEM;
-        
-
-        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
+
+        usb_log_info("OHCI root hub with %d ports initialized.\n",
+            instance->port_count);
+
         return EOK;
 }
@@ -245 +262 @@
                 usb_log_info("Root hub got INTERRUPT packet\n");
                 create_interrupt_mask_in_instance(instance);
-                if(is_zeros(instance->interrupt_buffer,
-                    instance->interrupt_mask_size)){
+                if (is_zeros(instance->interrupt_buffer,
+                    instance->interrupt_mask_size)) {
                         usb_log_debug("no changes..\n");
                         instance->unfinished_interrupt_transfer = request;
                         //will be finished later
-                }else{
+                } else {
                         usb_log_debug("processing changes..\n");
                         process_interrupt_mask_in_instance(instance, request);
@@ -256 +273 @@
                 opResult = EOK;
         } else {
+
                 opResult = EINVAL;
                 usb_transfer_batch_finish_error(request, opResult);
@@ -271 +289 @@
  */
 void rh_interrupt(rh_t *instance) {
-        if(!instance->unfinished_interrupt_transfer){
+        if (!instance->unfinished_interrupt_transfer) {
                 return;
         }
@@ -292 +310 @@
 static int create_serialized_hub_descriptor(rh_t *instance) {
         size_t size = 7 +
-            ((instance->port_count +7 )/ 8) * 2;
-        size_t var_size = (instance->port_count +7 )/ 8;
+            ((instance->port_count + 7) / 8) * 2;
+        size_t var_size = (instance->port_count + 7) / 8;
         uint8_t * result = (uint8_t*) malloc(size);
-        if(!result) return ENOMEM;
+        if (!result) return ENOMEM;
 
         bzero(result, size);
@@ -305 +323 @@
         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);
+            ((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;
+        size_t port;
         for (port = 1; port <= instance->port_count; ++port) {
                 uint8_t is_non_removable =
-                        instance->registers->rh_desc_b >> port % 2;
+                    instance->registers->rh_desc_b >> port % 2;
                 result[7 + port / 8] +=
-                        is_non_removable << (port % 8);
+                    is_non_removable << (port % 8);
         }
         size_t i;
@@ -327 +345 @@
         instance->hub_descriptor = result;
         instance->descriptor_size = size;
+
         return EOK;
 }
@@ -340 +359 @@
 static int rh_init_descriptors(rh_t *instance) {
         memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
-                sizeof (ohci_rh_device_descriptor)
-                );
+            sizeof (ohci_rh_device_descriptor)
+            );
         usb_standard_configuration_descriptor_t descriptor;
         memcpy(&descriptor, &ohci_rh_conf_descriptor,
-                sizeof (ohci_rh_conf_descriptor));
+            sizeof (ohci_rh_conf_descriptor));
 
         int opResult = create_serialized_hub_descriptor(instance);
-        if(opResult != EOK){
+        if (opResult != EOK) {
                 return opResult;
         }
         descriptor.total_length =
-                sizeof (usb_standard_configuration_descriptor_t) +
-                sizeof (usb_standard_endpoint_descriptor_t) +
-                sizeof (usb_standard_interface_descriptor_t) +
-                instance->descriptor_size;
+            sizeof (usb_standard_configuration_descriptor_t) +
+            sizeof (usb_standard_endpoint_descriptor_t) +
+            sizeof (usb_standard_interface_descriptor_t) +
+            instance->descriptor_size;
 
         uint8_t * full_config_descriptor =
-                (uint8_t*) malloc(descriptor.total_length);
-        if(!full_config_descriptor){
+            (uint8_t*) malloc(descriptor.total_length);
+        if (!full_config_descriptor) {
                 return ENOMEM;
         }
         memcpy(full_config_descriptor, &descriptor, sizeof (descriptor));
         memcpy(full_config_descriptor + sizeof (descriptor),
-                &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor));
+            &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor));
         memcpy(full_config_descriptor + sizeof (descriptor) +
-                sizeof (ohci_rh_iface_descriptor),
-                &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor));
+            sizeof (ohci_rh_iface_descriptor),
+            &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor));
         memcpy(full_config_descriptor + sizeof (descriptor) +
-                sizeof (ohci_rh_iface_descriptor) +
-                sizeof (ohci_rh_ep_descriptor),
-                instance->hub_descriptor, instance->descriptor_size);
-        
+            sizeof (ohci_rh_iface_descriptor) +
+            sizeof (ohci_rh_ep_descriptor),
+            instance->hub_descriptor, instance->descriptor_size);
+
         instance->descriptors.configuration = full_config_descriptor;
         instance->descriptors.configuration_size = descriptor.total_length;
+
         return EOK;
 }
@@ -389 +409 @@
  */
 static int process_get_port_status_request(rh_t *instance, uint16_t port,
-        usb_transfer_batch_t * request) {
+    usb_transfer_batch_t * request) {
         if (port < 1 || port > instance->port_count)
                 return EINVAL;
@@ -398 +418 @@
         int i;
         for (i = 0; i < instance->port_count; ++i) {
+
                 usb_log_debug("port status %d,x%x\n",
-                        instance->registers->rh_port_status[i],
-                        instance->registers->rh_port_status[i]);
+                    instance->registers->rh_port_status[i],
+                    instance->registers->rh_port_status[i]);
         }
 #endif
@@ -417 +438 @@
  */
 static int process_get_hub_status_request(rh_t *instance,
-        usb_transfer_batch_t * request) {
+    usb_transfer_batch_t * request) {
         uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
@@ -423 +444 @@
         uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
         uint32_buffer[0] = mask & instance->registers->rh_status;
+
         return EOK;
 }
@@ -437 +459 @@
  */
 static int process_get_status_request(rh_t *instance,
-        usb_transfer_batch_t * request) {
+    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_device_request_setup_packet_t*)
+            request->setup_buffer;
 
         usb_hub_bm_request_type_t request_type = request_packet->request_type;
@@ -453 +475 @@
         if (request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
                 return process_get_port_status_request(instance,
-                request_packet->index,
-                request);
+            request_packet->index,
+            request);
+
         return ENOTSUP;
 }
@@ -472 +495 @@
         uint8_t * bitmap = (uint8_t*) (instance->interrupt_buffer);
         uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16))
-                | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
+            | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
         bzero(bitmap, instance->interrupt_mask_size);
         if (instance->registers->rh_status & mask) {
                 bitmap[0] = 1;
         }
-        int port;
+        size_t port;
         mask = port_status_change_mask;
         for (port = 1; port <= instance->port_count; ++port) {
                 if (mask & instance->registers->rh_port_status[port - 1]) {
+
                         bitmap[(port) / 8] += 1 << (port % 8);
                 }
@@ -497 +521 @@
  */
 static int process_get_descriptor_request(rh_t *instance,
-        usb_transfer_batch_t *request) {
+    usb_transfer_batch_t *request) {
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*) request->setup_buffer;
+            (usb_device_request_setup_packet_t*) request->setup_buffer;
         size_t size;
         const void * result_descriptor = NULL;
@@ -543 +567 @@
                 {
                         usb_log_debug("USB_DESCTYPE_EINVAL %d \n",
-                                setup_request->value);
+                            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
-                                );
+                            "%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;
                 }
@@ -560 +584 @@
         request->transfered_size = size;
         memcpy(request->data_buffer, result_descriptor, size);
+
         return EOK;
 }
@@ -573 +598 @@
  */
 static int process_get_configuration_request(rh_t *instance,
-        usb_transfer_batch_t *request) {
+    usb_transfer_batch_t *request) {
         //set and get configuration requests do not have any meaning, only dummy
         //values are returned
@@ -580 +605 @@
         request->data_buffer[0] = 1;
         request->transfered_size = 1;
+
         return EOK;
 }
@@ -592 +618 @@
  */
 static int process_hub_feature_set_request(rh_t *instance,
-        uint16_t feature) {
+    uint16_t feature) {
         if (!((1 << feature) & hub_set_feature_valid_mask))
                 return EINVAL;
-        if(feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER)
+        if (feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER)
                 feature = USB_HUB_FEATURE_C_HUB_LOCAL_POWER << 16;
         instance->registers->rh_status =
-                (instance->registers->rh_status | (1 << feature))
-                & (~hub_clear_feature_by_writing_one_mask);
+            (instance->registers->rh_status | (1 << feature))
+            & (~hub_clear_feature_by_writing_one_mask);
+
         return EOK;
 }
@@ -612 +639 @@
  */
 static int process_hub_feature_clear_request(rh_t *instance,
-        uint16_t feature) {
+    uint16_t feature) {
         if (!((1 << feature) & hub_clear_feature_valid_mask))
                 return EINVAL;
@@ -618 +645 @@
         if ((1 << feature) & hub_set_feature_direct_mask) {
                 instance->registers->rh_status =
-                        (instance->registers->rh_status & (~(1 << feature)))
-                        & (~hub_clear_feature_by_writing_one_mask);
+                    (instance->registers->rh_status & (~(1 << feature)))
+                    & (~hub_clear_feature_by_writing_one_mask);
         } else {//the feature is cleared by writing '1'
+
                 instance->registers->rh_status =
-                        (instance->registers->rh_status
-                        & (~hub_clear_feature_by_writing_one_mask))
-                        | (1 << feature);
+                    (instance->registers->rh_status
+                    & (~hub_clear_feature_by_writing_one_mask))
+                    | (1 << feature);
         }
         return EOK;
@@ -640 +668 @@
  */
 static int process_port_feature_set_request(rh_t *instance,
-        uint16_t feature, uint16_t port) {
+    uint16_t feature, uint16_t port) {
         if (!((1 << feature) & port_set_feature_valid_mask))
                 return EINVAL;
@@ -646 +674 @@
                 return EINVAL;
         instance->registers->rh_port_status[port - 1] =
-                (instance->registers->rh_port_status[port - 1] | (1 << feature))
-                & (~port_clear_feature_valid_mask);
+            (instance->registers->rh_port_status[port - 1] | (1 << feature))
+            & (~port_clear_feature_valid_mask);
         /// \TODO any error?
+
         return EOK;
 }
@@ -663 +692 @@
  */
 static int process_port_feature_clear_request(rh_t *instance,
-        uint16_t feature, uint16_t port) {
+    uint16_t feature, uint16_t port) {
         if (!((1 << feature) & port_clear_feature_valid_mask))
                 return EINVAL;
@@ -673 +702 @@
                 feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
         instance->registers->rh_port_status[port - 1] =
-                (instance->registers->rh_port_status[port - 1]
-                & (~port_clear_feature_valid_mask))
-                | (1 << feature);
+            (instance->registers->rh_port_status[port - 1]
+            & (~port_clear_feature_valid_mask))
+            | (1 << feature);
         /// \TODO any error?
+
         return EOK;
 }
@@ -689 +719 @@
  */
 static int process_address_set_request(rh_t *instance,
-        uint16_t address) {
+    uint16_t address) {
         instance->address = address;
+
         return EOK;
 }
@@ -705 +736 @@
  */
 static int process_request_with_output(rh_t *instance,
-        usb_transfer_batch_t *request) {
+    usb_transfer_batch_t *request) {
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*) request->setup_buffer;
+            (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");
@@ -718 +749 @@
         if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) {
                 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
+
                 return process_get_configuration_request(instance, request);
         }
@@ -734 +766 @@
  */
 static int process_request_with_input(rh_t *instance,
-        usb_transfer_batch_t *request) {
+    usb_transfer_batch_t *request) {
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*) request->setup_buffer;
+            (usb_device_request_setup_packet_t*) request->setup_buffer;
         request->transfered_size = 0;
         if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) {
@@ -744 +776 @@
                 //set and get configuration requests do not have any meaning,
                 //only dummy values are returned
+
                 return EOK;
         }
@@ -760 +793 @@
  */
 static int process_request_without_data(rh_t *instance,
-        usb_transfer_batch_t *request) {
+    usb_transfer_batch_t *request) {
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*) request->setup_buffer;
+            (usb_device_request_setup_packet_t*) request->setup_buffer;
         request->transfered_size = 0;
         if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) {
@@ -768 +801 @@
                         usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
                         return process_hub_feature_clear_request(instance,
-                                setup_request->value);
+                            setup_request->value);
                 }
                 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_clear_request(instance,
-                                setup_request->value,
-                                setup_request->index);
+                            setup_request->value,
+                            setup_request->index);
                 }
                 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
-                        setup_request->request_type);
+                    setup_request->request_type);
                 return EINVAL;
         }
@@ -784 +817 @@
                         usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
                         return process_hub_feature_set_request(instance,
-                                setup_request->value);
+                            setup_request->value);
                 }
                 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->value,
+                            setup_request->index);
                 }
                 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
-                        setup_request->request_type);
+                    setup_request->request_type);
                 return EINVAL;
         }
@@ -799 +832 @@
                 usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
                 return process_address_set_request(instance,
-                        setup_request->value);
+                    setup_request->value);
         }
         usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",
-                setup_request->request_type);
+            setup_request->request_type);
+
         return ENOTSUP;
 }
@@ -836 +870 @@
         }
         usb_log_info("CTRL packet: %s.\n",
-                usb_debug_str_buffer(
-                (const uint8_t *) request->setup_buffer, 8, 8));
+            usb_debug_str_buffer(
+            (const uint8_t *) request->setup_buffer, 8, 8));
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*)
-                request->setup_buffer;
+            (usb_device_request_setup_packet_t*)
+            request->setup_buffer;
         switch (setup_request->request) {
                 case USB_DEVREQ_GET_STATUS:
@@ -847 +881 @@
                         usb_log_debug("processing request with output\n");
                         opResult = process_request_with_output(
-                                instance, request);
+                            instance, request);
                         break;
                 case USB_DEVREQ_CLEAR_FEATURE:
@@ -853 +887 @@
                 case USB_DEVREQ_SET_ADDRESS:
                         usb_log_debug("processing request without "
-                                "additional data\n");
+                            "additional data\n");
                         opResult = process_request_without_data(
-                                instance, request);
+                            instance, request);
                         break;
                 case USB_DEVREQ_SET_DESCRIPTOR:
                 case USB_DEVREQ_SET_CONFIGURATION:
                         usb_log_debug("processing request with "
-                                "input\n");
+                            "input\n");
                         opResult = process_request_with_input(
-                                instance, request);
+                            instance, request);
+
                         break;
                 default:
                         usb_log_warning("received unsuported request: "
-                                "%d\n",
-                                setup_request->request
-                                );
+                            "%d\n",
+                            setup_request->request
+                            );
                         opResult = ENOTSUP;
         }
@@ -888 +923 @@
  * @return
  */
-static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request){
+static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request) {
         memcpy(request->data_buffer, instance->interrupt_buffer,
             instance->interrupt_mask_size);
@@ -894 +929 @@
         instance->unfinished_interrupt_transfer = NULL;
         usb_transfer_batch_finish_error(request, EOK);
+
         return EOK;
 }
@@ -907 +943 @@
  * @return
  */
-static bool is_zeros(void * buffer, size_t size){
-        if(!buffer) return true;
-        if(!size) return true;
+static bool is_zeros(void * buffer, size_t size) {
+        if (!buffer) return true;
+        if (!size) return true;
         size_t i;
-        for(i=0;i<size;++i){
-                if(((char*)buffer)[i])
+        for (i = 0; i < size; ++i) {
+                if (((char*) buffer)[i])
                         return false;
         }

uspace/drv/ohci/root_hub.h

@@ -51 +51 @@
         usb_address_t address;
         /** hub port count */
-        int port_count;
+        size_t port_count;
         /** hubs descriptors */
         usb_device_descriptors_t descriptors;

uspace/drv/uhci-hcd/uhci.c

@@ -210 +210 @@
             "Failed(%d) to bind UHCI device function: %s.\n",
             ret, str_error(ret));
+        ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed to add UHCI to HC class: %s.\n", str_error(ret));
+
 #undef CHECK_RET_HC_RETURN
 

uspace/drv/usbhid/generic/hiddev.c

@@ -39 +39 @@
 #include <errno.h>
 #include <str_error.h>
+#include <bool.h>
 
 #include <usbhid_iface.h>
@@ -64 +65 @@
     size_t size, size_t *act_size, unsigned int flags);
 
+static int usb_generic_hid_client_connected(ddf_fun_t *fun);
+
 /*----------------------------------------------------------------------------*/
 
@@ -72 +75 @@
 
 static ddf_dev_ops_t usb_generic_hid_ops = {
-        .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface
+        .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface,
+        .open = usb_generic_hid_client_connected
 };
 
@@ -104 +108 @@
         
         /*! @todo This should probably be atomic. */
-        memcpy(buffer, hid_dev->input_report, hid_dev->input_report_size);
-        *act_size = hid_dev->input_report_size;
+        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();
+        }
         
         // clear the buffer so that it will not be received twice
-        memset(hid_dev->input_report, 0, hid_dev->input_report_size);
+        //memset(hid_dev->input_report, 0, hid_dev->input_report_size);
         
+        // note that we already received this report
+//      report_received = true;
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int usb_generic_hid_client_connected(ddf_fun_t *fun)
+{
+        usb_hid_report_received();
         return EOK;
 }

uspace/drv/usbhid/kbd/kbddev.c

@@ -255 +255 @@
         
         if (hid_dev == NULL || hid_dev->data == NULL) {
+                usb_log_debug("default_connection_handler: "
+                    "Missing parameter.\n");
                 async_answer_0(icallid, EINVAL);
                 return;
@@ -267 +269 @@
 
                 if (kbd_dev->console_phone != -1) {
+                        usb_log_debug("default_connection_handler: "
+                            "console phone already set\n");
                         async_answer_0(icallid, ELIMIT);
                         return;
@@ -272 +276 @@
 
                 kbd_dev->console_phone = callback;
+                
+                usb_log_debug("default_connection_handler: OK\n");
                 async_answer_0(icallid, EOK);
                 return;
         }
         
+        usb_log_debug("default_connection_handler: Wrong function.\n");
         async_answer_0(icallid, EINVAL);
 }
@@ -555 +562 @@
                         usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
                             kbd_dev->keys[i]);
-                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_start(kbd_dev, key);
                         }
+                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
                 } else {
                         // found, nothing happens

uspace/drv/usbhid/mouse/mousedev.c

@@ -43 +43 @@
 #include <str_error.h>
 #include <ipc/mouse.h>
+#include <io/console.h>
+
+#include <ipc/kbd.h>
+#include <io/keycode.h>
 
 #include "mousedev.h"
@@ -61 +65 @@
 
 const char *HID_MOUSE_FUN_NAME = "mouse";
+const char *HID_MOUSE_WHEEL_FUN_NAME = "mouse-wheel";
 const char *HID_MOUSE_CLASS_NAME = "mouse";
+const char *HID_MOUSE_WHEEL_CLASS_NAME = "keyboard";
 
 /** Default idle rate for mouses. */
@@ -119 +125 @@
         
         if (hid_dev == NULL || hid_dev->data == NULL) {
+                usb_log_debug("default_connection_handler: Missing "
+                    "parameters.\n");
                 async_answer_0(icallid, EINVAL);
                 return;
@@ -127 +135 @@
         usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
         
+        int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0) 
+                     ? &mouse_dev->mouse_phone : &mouse_dev->wheel_phone;
+        
         if (method == IPC_M_CONNECT_TO_ME) {
                 int callback = IPC_GET_ARG5(*icall);
 
-                if (mouse_dev->console_phone != -1) {
+                if (*phone != -1) {
+                        usb_log_debug("default_connection_handler: Console "
+                            "phone to mouse already set.\n");
                         async_answer_0(icallid, ELIMIT);
+                        //async_answer_0(icallid, EOK);
                         return;
                 }
 
-                mouse_dev->console_phone = callback;
+                *phone = callback;
                 usb_log_debug("Console phone to mouse set ok (%d).\n", callback);
                 async_answer_0(icallid, EOK);
@@ -141 +155 @@
         }
 
+        usb_log_debug("default_connection_handler: Invalid function.\n");
         async_answer_0(icallid, EINVAL);
 }
@@ -152 +167 @@
                 return NULL;
         }
-        mouse->console_phone = -1;
+        mouse->mouse_phone = -1;
+        mouse->wheel_phone = -1;
         
         return mouse;
@@ -164 +180 @@
         
         // hangup phone to the console
-        if ((*mouse_dev)->console_phone >= 0) {
-                async_hangup((*mouse_dev)->console_phone);
+        if ((*mouse_dev)->mouse_phone >= 0) {
+                async_hangup((*mouse_dev)->mouse_phone);
+        }
+        
+        if ((*mouse_dev)->wheel_phone >= 0) {
+                async_hangup((*mouse_dev)->wheel_phone);
         }
         
@@ -174 +194 @@
 /*----------------------------------------------------------------------------*/
 
-static bool usb_mouse_process_boot_report(usb_hid_dev_t *hid_dev,
-    uint8_t *buffer, size_t buffer_size)
+static void usb_mouse_send_wheel(const usb_mouse_t *mouse_dev, int wheel)
+{
+        console_event_t ev;
+        
+        ev.type = KEY_PRESS;
+        ev.key = (wheel > 0) ? KC_UP : (wheel < 0) ? KC_DOWN : 0;
+        ev.mods = 0;
+        ev.c = 0;
+
+        if (mouse_dev->wheel_phone < 0) {
+                usb_log_warning(
+                    "Connection to console not ready, key discarded.\n");
+                return;
+        }
+        
+        int count = (wheel < 0) ? -wheel : wheel;
+        int i;
+        
+        for (i = 0; i < count * 3; ++i) {
+                usb_log_debug2("Sending key %d to the console\n", ev.key);
+                async_msg_4(mouse_dev->wheel_phone, KBD_EVENT, ev.type, 
+                    ev.key, ev.mods, ev.c);
+                // send key release right away
+                async_msg_4(mouse_dev->wheel_phone, KBD_EVENT, KEY_RELEASE, 
+                    ev.key, ev.mods, ev.c);
+        }
+}
+
+/*----------------------------------------------------------------------------*/
+
+static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, uint8_t *buffer,
+    size_t buffer_size)
 {
         usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
@@ -182 +232 @@
             usb_debug_str_buffer(buffer, buffer_size, 0));
         
-        if (mouse_dev->console_phone < 0) {
+        if (mouse_dev->mouse_phone < 0) {
                 usb_log_error(NAME " No console phone.\n");
                 return false;   // ??
@@ -252 +302 @@
         
         if ((shift_x != 0) || (shift_y != 0)) {
-                async_req_2_0(mouse_dev->console_phone,
+                async_req_2_0(mouse_dev->mouse_phone,
                     MEVENT_MOVE, shift_x, shift_y);
         }
+        
+        /*
+         * Wheel
+         */
+        int wheel = 0;
+        
+        path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_GENERIC_DESKTOP, 
+            USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
+
+        usb_hid_report_path_set_report_id(path, report_id);
+        
+        field = usb_hid_report_get_sibling(
+            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END, 
+            USB_HID_REPORT_TYPE_INPUT);
+
+        if (field != NULL) {
+                usb_log_debug(NAME " VALUE(%X) USAGE(%X)\n", field->value, 
+                    field->usage);
+                wheel = field->value;
+        }
+
+        usb_hid_report_path_free(path);
+        
+        // send arrow up for positive direction and arrow down for negative
+        // direction; three arrows for difference of 1
+        usb_mouse_send_wheel(mouse_dev, wheel);
+        
         
         /*
@@ -274 +352 @@
                 if (mouse_dev->buttons[field->usage - field->usage_minimum] == 0
                     && field->value != 0) {
-                        async_req_2_0(mouse_dev->console_phone,
+                        async_req_2_0(mouse_dev->mouse_phone,
                             MEVENT_BUTTON, field->usage, 1);
                         mouse_dev->buttons[field->usage - field->usage_minimum]
@@ -281 +359 @@
                     mouse_dev->buttons[field->usage - field->usage_minimum] != 0
                     && field->value == 0) {
-                       async_req_2_0(mouse_dev->console_phone,
+                       async_req_2_0(mouse_dev->mouse_phone,
                            MEVENT_BUTTON, field->usage, 0);
                        mouse_dev->buttons[field->usage - field->usage_minimum]
@@ -337 +415 @@
         }
         
+        /*
+         * Special function for acting as keyboard (wheel)
+         */
+        usb_log_debug("Creating DDF function %s...\n", 
+                      HID_MOUSE_WHEEL_FUN_NAME);
+        fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed, 
+            HID_MOUSE_WHEEL_FUN_NAME);
+        if (fun == NULL) {
+                usb_log_error("Could not create DDF function node.\n");
+                return ENOMEM;
+        }
+        
+        /*
+         * Store the initialized HID device and HID ops
+         * to the DDF function.
+         */
+        fun->ops = &hid_dev->ops;
+        fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+
+        rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                usb_log_error("Could not bind DDF function: %s.\n",
+                    str_error(rc));
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+        
+        usb_log_debug("Adding DDF function to class %s...\n", 
+            HID_MOUSE_WHEEL_CLASS_NAME);
+        rc = ddf_fun_add_to_class(fun, HID_MOUSE_WHEEL_CLASS_NAME);
+        if (rc != EOK) {
+                usb_log_error(
+                    "Could not add DDF function to class %s: %s.\n",
+                    HID_MOUSE_WHEEL_CLASS_NAME, str_error(rc));
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+        
         return EOK;
 }
@@ -407 +523 @@
         }
         
-        return usb_mouse_process_boot_report(hid_dev, buffer, buffer_size);
+        return usb_mouse_process_report(hid_dev, buffer, buffer_size);
 }
 

uspace/drv/usbhid/mouse/mousedev.h

@@ -48 +48 @@
         //suseconds_t poll_interval_us;
         /** IPC phone to console (consumer). */
-        int console_phone;
+        int mouse_phone;
+        int wheel_phone;
         
         int32_t *buttons;

uspace/drv/usbhid/subdrivers.c

@@ -36 +36 @@
 #include "subdrivers.h"
 #include "usb/classes/hidut.h"
+#include "usb/classes/hidpath.h"
 
 #include "lgtch-ultrax/lgtch-ultrax.h"
+#include "mouse/mousedev.h"
 
 static usb_hid_subdriver_usage_t path_kbd[] = {
         {USB_HIDUT_PAGE_KEYBOARD, 0}, 
+        {0, 0}
+};
+
+static usb_hid_subdriver_usage_t path_mouse2[] = {
+        {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_X},
         {0, 0}
 };
@@ -79 +86 @@
                 }
         },
+        {
+                path_mouse2,
+                -1,
+                USB_HID_PATH_COMPARE_END 
+                | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
+                -1,
+                -1,
+                {
+                        .init = usb_mouse_init,
+                        .deinit = usb_mouse_deinit,
+                        .poll = usb_mouse_polling_callback,
+                        .poll_end = NULL
+                }
+        },
         {NULL, -1, 0, -1, -1, {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;
+
 /*----------------------------------------------------------------------------*/
 
@@ -412 +414 @@
         }
         
-        // TODO: remove the mouse hack
-        if (hid_dev->poll_pipe_index == USB_HID_MOUSE_POLL_EP_NO ||
-            fallback) {
+        if (fallback) {
                 // fall back to boot protocol
                 switch (hid_dev->poll_pipe_index) {
@@ -509 +509 @@
                                 free(input_old);
                         }
+                        usb_hid_new_report();
                 }
         }
@@ -589 +590 @@
 /*----------------------------------------------------------------------------*/
 
+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_free(usb_hid_dev_t **hid_dev)
 {

uspace/drv/usbhid/usbhid.h

@@ -44 +44 @@
 #include <usb/devdrv.h>
 #include <usb/classes/hid.h>
+#include <bool.h>
 
 struct usb_hid_dev;
@@ -128 +129 @@
 //const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev);
 
+void usb_hid_new_report(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/ports.c

@@ -53 +53 @@
         size_t port;
         usb_speed_t speed;
+};
+
+/**
+ * count of port status changes that are not explicitly handled by
+ * any function here and must be cleared by hand
+ */
+static const unsigned int non_handled_changes_count = 2;
+
+/**
+ * port status changes that are not explicitly handled by
+ * any function here and must be cleared by hand
+ */
+static const int non_handled_changes[] =  {
+        USB_HUB_FEATURE_C_PORT_ENABLE,
+        USB_HUB_FEATURE_C_PORT_SUSPEND
 };
 
@@ -131 +146 @@
             &status, USB_HUB_FEATURE_C_PORT_CONNECTION,false);
         usb_port_status_set_bit(
-            &status, USB_HUB_FEATURE_PORT_RESET,false);
-        usb_port_status_set_bit(
             &status, USB_HUB_FEATURE_C_PORT_RESET,false);
         usb_port_status_set_bit(
             &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT,false);
-        /// \TODO what about port power change?
-        if (status >> 16) {
-                usb_log_info("there was unsupported change on port %d: %X\n",
-                        port, status);
-
+        
+        //clearing not yet handled changes      
+        unsigned int feature_idx;
+        for(feature_idx = 0;feature_idx<non_handled_changes_count;
+            ++feature_idx){
+                unsigned int bit_idx = non_handled_changes[feature_idx];
+                if(status & (1<<bit_idx)){
+                        usb_log_info(
+                            "there was not yet handled change on port %d: %d"
+                            ";clearing it\n",
+                        port, bit_idx);
+                        int opResult = usb_hub_clear_port_feature(
+                            hub->control_pipe,
+                            port, bit_idx);
+                        if (opResult != EOK) {
+                                usb_log_warning(
+                                    "could not clear port flag %d: %d\n",
+                                    bit_idx, opResult
+                                    );
+                        }
+                        usb_port_status_set_bit(
+                            &status, bit_idx,false);
+                }
+        }
+        if(status>>16){
+                usb_log_info("there is still some unhandled change %X\n",
+                    status);
         }
 }
@@ -222 +257 @@
                     "Port %zu reset complete but port not enabled.\n",
                     (size_t) port);
+        }
+        /* Clear the port reset change. */
+        int rc = usb_hub_clear_port_feature(hub->control_pipe,
+            port, USB_HUB_FEATURE_C_PORT_RESET);
+        if (rc != EOK) {
+                usb_log_error("Failed to clear port %d reset feature: %s.\n",
+                    port, str_error(rc));
         }
 }
@@ -319 +361 @@
         fibril_mutex_unlock(&my_port->reset_mutex);
 
-        /* Clear the port reset change. */
-        rc = usb_hub_clear_port_feature(hub->control_pipe,
-            port_no, USB_HUB_FEATURE_C_PORT_RESET);
-        if (rc != EOK) {
-                usb_log_error("Failed to clear port %d reset feature: %s.\n",
-                    port_no, str_error(rc));
-                return rc;
-        }
-
         if (my_port->reset_okay) {
                 return EOK;

uspace/drv/vhc/main.c

@@ -104 +104 @@
         }
 
-        ddf_fun_add_to_class(hc, "usbhc");
+        rc = ddf_fun_add_to_class(hc, USB_HC_DDF_CLASS_NAME);
+        if (rc != EOK) {
+                usb_log_fatal("Failed to add function to HC class: %s.\n",
+                    str_error(rc));
+                free(data);
+                return rc;
+        }
 
         virtual_hub_device_init(hc);

uspace/drv/vhc/transfer.c

@@ -135 +135 @@
                 if (transfer->direction == USB_DIRECTION_IN) {
                         rc = usbvirt_ipc_send_control_read(phone,
-                            transfer->endpoint,
                             transfer->setup_buffer, transfer->setup_buffer_size,
                             transfer->data_buffer, transfer->data_buffer_size,
@@ -142 +141 @@
                         assert(transfer->direction == USB_DIRECTION_OUT);
                         rc = usbvirt_ipc_send_control_write(phone,
-                            transfer->endpoint,
                             transfer->setup_buffer, transfer->setup_buffer_size,
                             transfer->data_buffer, transfer->data_buffer_size);

uspace/lib/c/generic/devman.c

@@ -374 +374 @@
 }
 
+int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
+{
+        int phone = devman_get_phone(DEVMAN_CLIENT, 0);
+
+        if (phone < 0)
+                return phone;
+
+        async_serialize_start();
+
+        ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_DEVICE_PATH,
+            handle, &answer);
+
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(phone, path, path_size,
+            &data_request_call);
+        if (data_request == 0) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return ENOMEM;
+        }
+
+        sysarg_t data_request_rc;
+        sysarg_t opening_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        async_wait_for(req, &opening_request_rc);
+
+        async_serialize_end();
+
+        if (data_request_rc != EOK) {
+                /* Prefer the 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;
+        }
+
+        path[path_size - 1] = 0;
+
+        if (IPC_GET_ARG2(data_request_call) >= path_size) {
+                return ELIMIT;
+        }
+
+        return EOK;
+}
+
 
 /** @}

uspace/lib/c/include/devman.h

@@ -55 +55 @@
 extern int devman_device_get_handle_by_class(const char *, const char *,
     devman_handle_t *, unsigned int);
+extern int devman_get_device_path(devman_handle_t, char *, size_t);
 
 extern int devman_add_device_to_class(devman_handle_t, const char *);

uspace/lib/c/include/ipc/devman.h

@@ -149 +149 @@
 typedef enum {
         DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
-        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS
+        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
+        DEVMAN_DEVICE_GET_DEVICE_PATH
 } client_to_devman_t;
 

uspace/lib/usb/Makefile

@@ -46 +46 @@
         src/hidparser.c \
         src/hiddescriptor.c \
+        src/host.c \
         src/hub.c \
         src/pipepriv.c \

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

@@ -46 +46 @@
 #define USB_HID_ITEM_IS_LONG(data)      (data == 0xFE)
 
+
+/**
+ * Extended usage macros
+ */
+#define USB_HID_IS_EXTENDED_USAGE(usage)        ((usage & 0xFFFF0000) != 0)
+#define USB_HID_EXTENDED_USAGE_PAGE(usage)      ((usage & 0xFFFF0000) >> 16)
+#define USB_HID_EXTENDED_USAGE(usage)           (usage & 0xFFFF)
 
 /**

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

@@ -39 +39 @@
 #include <adt/list.h>
 
-#define USB_HID_MAX_USAGES      20
+#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)))
@@ -92 +92 @@
         int32_t physical_minimum;
         int32_t physical_maximum;
-        uint32_t usage_minimum;
-        uint32_t usage_maximum;
+        int32_t usage_minimum;
+        int32_t usage_maximum;
         uint32_t unit;
         uint32_t unit_exponent;
-        
+
+        uint32_t *usages;
+        size_t usages_count;
 
         int32_t value;
@@ -121 +123 @@
 
         /** */  
-        uint32_t usage_minimum;
-        /** */  
-        uint32_t usage_maximum;
+        int32_t usage_minimum;
+        /** */  
+        int32_t usage_maximum;
         /** */  
         int32_t logical_minimum;

uspace/lib/usb/include/usb/usb.h

@@ -172 +172 @@
 } usb_packet_id;
 
+/** Class name for USB host controllers. */
+#define USB_HC_DDF_CLASS_NAME "usbhc"
+
 #endif
 /**

uspace/lib/usb/src/hiddescriptor.c

@@ -116 +116 @@
         int i;
 
-        for(i=0; i<report_item->usages_count; i++){
-                usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]);
-        }
-
+        usb_log_debug("usages_count  - %zu\n", report_item->usages_count);
+
+        uint32_t *usages;
+        int usages_used=0;
+        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);
+        }
+        else {
+                usages = NULL;
+        }
+        
         usb_hid_report_path_t *path = report_item->usage_path;  
         for(i=0; i<report_item->count; i++){
@@ -133 +141 @@
                 field->physical_maximum = report_item->physical_maximum;
 
-                field->usage_minimum = report_item->usage_minimum;
-                field->usage_maximum = report_item->usage_maximum;
-                if(report_item->extended_usage_page != 0){
-                        field->usage_page = report_item->extended_usage_page;
+                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
+                        */
+                        field->usage = 0;
+                        field->usage_page = report_item->usage_page;
+
+                        field->usages_count = report_item->usages_count;
+                        field->usages = usages;
+                        usages_used = 1;
                 }
                 else {
-                        field->usage_page = report_item->usage_page;
-                }
-
-                if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
-                        uint32_t usage;
-                        if(i < report_item->usages_count){
+                        /* Fill the correct Usage and Usage Page */
+                        int32_t usage;
+                        if(i < report_item->usages_count) {
                                 usage = report_item->usages[i];
                         }
@@ -151 +163 @@
                         }
 
-                                                
-                        if((usage & 0xFFFF0000) != 0){
-                                field->usage_page = (usage >> 16);                                      
-                                field->usage = (usage & 0xFFFF);
+                        if(USB_HID_IS_EXTENDED_USAGE(usage)){
+                                field->usage = USB_HID_EXTENDED_USAGE(usage);
+                                field->usage_page = USB_HID_EXTENDED_USAGE_PAGE(usage);
                         }
                         else {
                                 field->usage = usage;
-                        }
-
-                        
-                }       
-
-                if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {
-                        field->usage = report_item->usage_minimum + i;                                  
+                                field->usage_page = report_item->usage_page;
+                        }
                 }
                 
@@ -209 +215 @@
         }
 
+        // free only when not used!!!
+        if(usages && usages_used == 0) {
+                free(usages);
+        }
 
         return EOK;
@@ -565 +575 @@
                         }
                         break;
-                case USB_HID_REPORT_TAG_USAGE_MINIMUM:
-
-                        usb_log_debug("USAGE_MINIMUM (SIZE: %d), data[0](%x), data[1](%x), data[2](%x) data[3](%x)\n",
-                                      item_size, *data, *(data+1), *(data+2), *(data+3));
-                        
+                case USB_HID_REPORT_TAG_USAGE_MINIMUM:                  
                         if (item_size == 3) {
                                 // usage extended usages
@@ -581 +587 @@
                 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; 
@@ -588 +599 @@
                                 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++] = i;
+                                }
+                        }
+                        report_item->extended_usage_page = 0;
+                        
                         break;
                 case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
@@ -660 +684 @@
 
                 usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
-                usb_log_debug("\t\tSIZE: %X\n", report_item->size);                             
+                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);                
@@ -699 +723 @@
                 usb_log_debug("Report ID: %d\n", report_des->report_id);
                 usb_log_debug("\tType: %d\n", report_des->type);
-                usb_log_debug("\tLength: %d\n", report_des->bit_length);                
-                usb_log_debug("\tItems: %d\n", report_des->item_length);                
+                usb_log_debug("\tLength: %zu\n", report_des->bit_length);               
+                usb_log_debug("\tItems: %zu\n", report_des->item_length);               
 
                 usb_hid_descriptor_print_list(&report_des->report_items);

uspace/lib/usb/src/hidparser.c

@@ -138 +138 @@
                                 // array
                                 item->value = usb_hid_translate_data(item, data);
-                            item->usage = (item->value - item->physical_minimum) + item->usage_minimum;
+                
+                                item->usage = USB_HID_EXTENDED_USAGE(item->usages[item->value - item->physical_minimum]);
+                                item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(item->usages[item->value - item->physical_minimum]);
+
                         }
                         else {

uspace/lib/usbvirt/Makefile

@@ -33 +33 @@
 
 SOURCES = \
-        src/ipc.c \
         src/ctrltransfer.c \
+        src/device.c \
+        src/ipc_dev.c \
+        src/ipc_hc.c \
         src/stdreq.c \
         src/transfer.c

uspace/lib/usbvirt/include/usbvirt/device.h

@@ -31 +31 @@
  */
 /** @file
- * @brief Virtual USB device.
+ * Virtual USB device.
  */
 #ifndef LIBUSBVIRT_DEVICE_H_
@@ -39 +39 @@
 #include <usb/request.h>
 
+/** Maximum number of endpoints supported by virtual USB. */
 #define USBVIRT_ENDPOINT_MAX 16
 
 typedef struct usbvirt_device usbvirt_device_t;
 
-typedef int (*usbvirt_on_data_to_device_t)(usbvirt_device_t *, usb_endpoint_t,
-    usb_transfer_type_t, void *, size_t);
-typedef int (*usbvirt_on_data_from_device_t)(usbvirt_device_t *, usb_endpoint_t,
-    usb_transfer_type_t, void *, size_t, size_t *);
-typedef int (*usbvirt_on_control_t)(usbvirt_device_t *,
-    const usb_device_request_setup_packet_t *, uint8_t *, size_t *);
-
-typedef struct {
+/** Callback for data to device (OUT transaction).
+ *
+ * @param dev Virtual device to which the transaction belongs.
+ * @param endpoint Target endpoint number.
+ * @param transfer_type Transfer type.
+ * @param buffer Data buffer.
+ * @param buffer_size Size of the buffer in bytes.
+ * @return Error code.
+ */
+typedef int (*usbvirt_on_data_to_device_t)(usbvirt_device_t *dev,
+    usb_endpoint_t endpoint, usb_transfer_type_t transfer_type,
+    void *buffer, size_t buffer_size);
+
+/** Callback for data from device (IN transaction).
+ *
+ * @param dev Virtual device to which the transaction belongs.
+ * @param endpoint Target endpoint number.
+ * @param transfer_type Transfer type.
+ * @param buffer Data buffer to write answer to.
+ * @param buffer_size Size of the buffer in bytes.
+ * @param act_buffer_size Write here how many bytes were actually written.
+ * @return Error code.
+ */
+typedef int (*usbvirt_on_data_from_device_t)(usbvirt_device_t *dev,
+    usb_endpoint_t endpoint, usb_transfer_type_t transfer_type,
+    void *buffer, size_t buffer_size, size_t *act_buffer_size);
+
+/** Callback for control transfer on endpoint zero.
+ *
+ * Notice that size of the data buffer is expected to be read from the
+ * setup packet.
+ *
+ * @param dev Virtual device to which the transaction belongs.
+ * @param setup_packet Standard setup packet.
+ * @param data Data (might be NULL).
+ * @param act_data_size Size of returned data in bytes.
+ * @return Error code.
+ */
+typedef int (*usbvirt_on_control_t)(usbvirt_device_t *dev,
+    const usb_device_request_setup_packet_t *setup_packet,
+    uint8_t *data, size_t *act_data_size);
+
+/** Callback for control request on a virtual USB device.
+ *
+ * See usbvirt_control_reply_helper() for simple way of answering
+ * control read requests.
+ */
+typedef struct {
+        /** Request direction (in or out). */
         usb_direction_t req_direction;
+        /** Request recipient (device, interface or endpoint). */
         usb_request_recipient_t req_recipient;
+        /** Request type (standard, class or vendor). */
         usb_request_type_t req_type;
+        /** Actual request code. */
         uint8_t request;
+        /** Request handler name for debugging purposes. */
         const char *name;
+        /** Callback to be executed on matching request. */
         usbvirt_on_control_t callback;
 } usbvirt_control_request_handler_t;
@@ -77 +124 @@
 } usbvirt_device_configuration_t;
 
-/** Standard USB descriptors. */
+/** Standard USB descriptors for virtual device. */
 typedef struct {
         /** Standard device descriptor.
@@ -102 +149 @@
 } usbvirt_device_state_t;
 
-typedef struct {
+/** Ops structure for virtual USB device. */
+typedef struct {
+        /** Callbacks for data to device.
+         * Index zero is ignored.
+         */
         usbvirt_on_data_to_device_t data_out[USBVIRT_ENDPOINT_MAX];
+        /** Callbacks for data from device.
+         * Index zero is ignored.
+         */
         usbvirt_on_data_from_device_t data_in[USBVIRT_ENDPOINT_MAX];
+        /** Array of control handlers.
+         * Last handler is expected to have the @c callback field set to NULL
+         */
         usbvirt_control_request_handler_t *control;
+        /** Callback when device changes state.
+         *
+         * The value of @c state attribute of @p dev device is not
+         * defined during call of this function.
+         *
+         * @param dev The virtual USB device.
+         * @param old_state Old device state.
+         * @param new_state New device state.
+         */
         void (*state_changed)(usbvirt_device_t *dev,
             usbvirt_device_state_t old_state, usbvirt_device_state_t new_state);
 } usbvirt_device_ops_t;
 
+/** Virtual USB device. */
 struct usbvirt_device {
+        /** Name for debugging purposes. */
         const char *name;
+        /** Custom device data. */
         void *device_data;
+        /** Device ops. */
         usbvirt_device_ops_t *ops;
+        /** Device descriptors. */
         usbvirt_descriptors_t *descriptors;
+        /** Current device address.
+         * You shall treat this field as read only in your code.
+         */
         usb_address_t address;
+        /** Current device state.
+         * You shall treat this field as read only in your code.
+         */
         usbvirt_device_state_t state;
+        /** Phone to the host controller.
+         * You shall treat this field as read only in your code.
+         */
+        int vhc_phone;
 };
 
 int usbvirt_device_plug(usbvirt_device_t *, const char *);
+void usbvirt_device_unplug(usbvirt_device_t *);
 
 void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *,

uspace/lib/usbvirt/include/usbvirt/ipc.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2011 Vojtech Horky
  * All rights reserved.
  *
@@ -31 +31 @@
  */
 /** @file
- * @brief Virtual USB device.
+ * IPC wrappers for virtual USB.
  */
 #ifndef LIBUSBVIRT_IPC_H_
@@ -40 +40 @@
 #include <bool.h>
 
+/** IPC methods communication between host controller and virtual device. */
 typedef enum {
         IPC_M_USBVIRT_GET_NAME = IPC_FIRST_USER_METHOD + 80,
@@ -45 +46 @@
         IPC_M_USBVIRT_CONTROL_WRITE,
         IPC_M_USBVIRT_INTERRUPT_IN,
-        IPC_M_USBVIRT_INTERRUPT_OUT
-} usbvirt_ipc_t;
+        IPC_M_USBVIRT_INTERRUPT_OUT,
+        IPC_M_USBVIRT_BULK_IN,
+        IPC_M_USBVIRT_BULK_OUT
+} usbvirt_hc_to_device_method_t;
 
-int usbvirt_ipc_send_control_read(int, usb_endpoint_t, void *, size_t,
+int usbvirt_ipc_send_control_read(int, void *, size_t,
     void *, size_t, size_t *);
-int usbvirt_ipc_send_control_write(int, usb_endpoint_t, void *, size_t,
+int usbvirt_ipc_send_control_write(int, void *, size_t,
     void *, size_t);
 int usbvirt_ipc_send_data_in(int, usb_endpoint_t, usb_transfer_type_t,

uspace/lib/usbvirt/src/ctrltransfer.c

@@ +1 @@
+/*
+ * Copyright (c) 2011 Vojtech Horky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libusbvirt
+ * @{
+ */
+/** @file
+ * Control transfer handling.
+ */
 #include "private.h"
 #include <usb/request.h>
@@ -5 +39 @@
 #include <errno.h>
 
+/** Find and execute control transfer handler for virtual USB device.
+ *
+ * @param dev Target virtual device.
+ * @param control_handlers Array of control request handlers.
+ * @param setup Setup packet.
+ * @param data Extra data.
+ * @param data_sent_size Size of extra data in bytes.
+ * @return Error code.
+ * @retval EFORWARD No suitable handler found.
+ */
 int process_control_transfer(usbvirt_device_t *dev,
     usbvirt_control_request_handler_t *control_handlers,
@@ -52 +96 @@
         return EFORWARD;
 }
+
+
+/**
+ * @}
+ */

uspace/lib/usbvirt/src/private.h

@@ +1 @@
+/*
+ * Copyright (c) 2011 Vojtech Horky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libusbvirt
+ * @{
+ */
+/** @file
+ * Private definitions.
+ */
+#ifndef USBVIRT_PRIVATE_H_
+#define USBVIRT_PRIVATE_H_
+
 #include <usbvirt/device.h>
 
@@ -7 +44 @@
 
 extern usbvirt_control_request_handler_t library_handlers[];
+
+#endif
+/**
+ * @}
+ */

uspace/lib/usbvirt/src/stdreq.c

@@ +1 @@
+/*
+ * Copyright (c) 2011 Vojtech Horky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libusbvirt
+ * @{
+ */
+/** @file
+ * Standard control request handlers.
+ */
 #include "private.h"
 #include <usb/request.h>
@@ -4 +38 @@
 #include <errno.h>
 
+/** Helper for replying to control read transfer from virtual USB device.
+ *
+ * This function takes care of copying data to answer buffer taking care
+ * of buffer sizes properly.
+ *
+ * @param setup_packet The setup packet.
+ * @param data Data buffer to write to.
+ * @param act_size Where to write actual size of returned data.
+ * @param actual_data Data to be returned.
+ * @param actual_data_size Size of answer data (@p actual_data) in bytes.
+ */
 void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *setup_packet,
     uint8_t *data, size_t *act_size,
@@ -144 +189 @@
 }
 
+/** Standard request handlers. */
 usbvirt_control_request_handler_t library_handlers[] = {
         {
@@ -173 +219 @@
 };
 
+/**
+ * @}
+ */

uspace/lib/usbvirt/src/transfer.c

@@ -31 +31 @@
  */
 /** @file
- *
+ * Transfer handling.
  */
 #include <usbvirt/device.h>
@@ -39 +39 @@
 #include "private.h"
 
+/** Process a control transfer to the virtual USB device.
+ *
+ * @param dev Target device.
+ * @param setup Setup packet data.
+ * @param setup_size Size of setup packet.
+ * @param data Extra data (DATA stage).
+ * @param data_size Size of extra data in bytes.
+ * @param data_size_sent Number of actually send bytes during the transfer
+ *      (only used for READ transfers).
+ * @return Error code.
+ */
 static int usbvirt_control_transfer(usbvirt_device_t *dev,
     void *setup, size_t setup_size,
@@ -78 +89 @@
 }
 
+/** Issue a control write transfer to virtual USB device.
+ *
+ * @see usbvirt_control_transfer
+ *
+ * @param dev Target virtual device.
+ * @param setup Setup data.
+ * @param setup_size Size of setup packet.
+ * @param data Extra data (DATA stage).
+ * @param data_size Size of extra data buffer in bytes.
+ * @return Error code.
+ */
 int usbvirt_control_write(usbvirt_device_t *dev, void *setup, size_t setup_size,
     void *data, size_t data_size)
@@ -85 +107 @@
 }
 
+/** Issue a control read transfer to virtual USB device.
+ *
+ * @see usbvirt_control_transfer
+ *
+ * @param dev Target virtual device.
+ * @param setup Setup data.
+ * @param setup_size Size of setup packet.
+ * @param data Extra data (DATA stage).
+ * @param data_size Size of extra data buffer in bytes.
+ * @param data_size_sent Number of actually send bytes during the transfer.
+ * @return Error code.
+ */
 int usbvirt_control_read(usbvirt_device_t *dev, void *setup, size_t setup_size,
     void *data, size_t data_size, size_t *data_size_sent)
@@ -92 +126 @@
 }
 
+/** Send data to virtual USB device.
+ *
+ * @param dev Target virtual device.
+ * @param transf_type Transfer type (interrupt, bulk).
+ * @param endpoint Endpoint number.
+ * @param data Data sent from the driver to the device.
+ * @param data_size Size of the @p data buffer in bytes.
+ * @return Error code.
+ */
 int usbvirt_data_out(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
     usb_endpoint_t endpoint, void *data, size_t data_size)
@@ -108 +151 @@
 }
 
+/** Request data from virtual USB device.
+ *
+ * @param dev Target virtual device.
+ * @param transf_type Transfer type (interrupt, bulk).
+ * @param endpoint Endpoint number.
+ * @param data Where to stored data the device returns to the driver.
+ * @param data_size Size of the @p data buffer in bytes.
+ * @param data_size_sent Number of actually written bytes.
+ * @return Error code.
+ */
 int usbvirt_data_in(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
     usb_endpoint_t endpoint, void *data, size_t data_size, size_t *data_size_sent)

uspace/srv/devman/main.c

@@ -515 +515 @@
 }
 
+/** Find device path by its handle. */
+static void devman_get_device_path_by_handle(ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        devman_handle_t handle = IPC_GET_ARG1(*icall);
+
+        fun_node_t *fun = find_fun_node(&device_tree, handle);
+        if (fun == NULL) {
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+
+        ipc_callid_t data_callid;
+        size_t data_len;
+        if (!async_data_read_receive(&data_callid, &data_len)) {
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+
+        void *buffer = malloc(data_len);
+        if (buffer == NULL) {
+                async_answer_0(data_callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+
+        size_t sent_length = str_size(fun->pathname);
+        if (sent_length > data_len) {
+                sent_length = data_len;
+        }
+
+        async_data_read_finalize(data_callid, fun->pathname, sent_length);
+        async_answer_0(iid, EOK);
+
+        free(buffer);
+}
+
 
 /** Function for handling connections from a client to the device manager. */
@@ -536 +573 @@
                 case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS:
                         devman_function_get_handle_by_class(callid, &call);
+                        break;
+                case DEVMAN_DEVICE_GET_DEVICE_PATH:
+                        devman_get_device_path_by_handle(callid, &call);
                         break;
                 default: