Changeset cc5908e in mainline for uspace/drv

Timestamp:

2011-05-07T14:28:51Z (15 years ago)

Author:

Matej Klonfar <maklf@…>

Branches:

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

Children:

252cf2a, 68b614e

Parents:

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

Message:

Development changes merged

Location:

uspace/drv

Files:

• ehci-hcd/main.c (modified) (1 diff)
• ohci/hc.c (modified) (10 diffs)
• ohci/hc.h (modified) (1 diff)
• ohci/main.c (modified) (2 diffs)
• ohci/ohci.c (modified) (4 diffs)
• ohci/pci.c (modified) (1 diff)
• ohci/root_hub.c (modified) (50 diffs)
• ohci/root_hub.h (modified) (1 diff)
• uhci-hcd/uhci.c (modified) (1 diff)
• usbhid/generic/hiddev.c (modified) (4 diffs)
• usbhid/kbd/kbddev.c (modified) (4 diffs)
• usbhid/mouse/mousedev.c (modified) (14 diffs)
• usbhid/mouse/mousedev.h (modified) (1 diff)
• usbhid/subdrivers.c (modified) (2 diffs)
• usbhid/usbhid.c (modified) (4 diffs)
• usbhid/usbhid.h (modified) (2 diffs)
• usbhub/ports.c (modified) (4 diffs)
• vhc/main.c (modified) (1 diff)
• vhc/transfer.c (modified) (2 diffs)

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