Changes in / [0e3505a:51b46f2] in mainline

Location:

uspace

Files:

• drv/pciintel/pci.c (modified) (3 diffs)
• drv/uhci-hcd/Makefile (modified) (1 diff)
• drv/uhci-hcd/batch.c (modified) (23 diffs)
• drv/uhci-hcd/batch.h (modified) (2 diffs)
• drv/uhci-hcd/iface.c (modified) (9 diffs)
• drv/uhci-hcd/main.c (modified) (4 diffs)
• drv/uhci-hcd/pci.c (modified) (4 diffs)
• drv/uhci-hcd/root_hub.c (modified) (6 diffs)
• drv/uhci-hcd/transfer_list.c (modified) (6 diffs)
• drv/uhci-hcd/transfer_list.h (modified) (1 diff)
• drv/uhci-hcd/uhci-hcd.ma (modified) (1 diff)
• drv/uhci-hcd/uhci.c (modified) (17 diffs)
• drv/uhci-hcd/uhci.h (modified) (2 diffs)
• drv/uhci-hcd/uhci_struct/transfer_descriptor.c (modified) (4 diffs)
• drv/uhci-hcd/uhci_struct/transfer_descriptor.h (modified) (1 diff)
• drv/uhci-hcd/utils/device_keeper.c (added)
• drv/uhci-hcd/utils/device_keeper.h (added)
• drv/uhci-rhd/main.c (modified) (4 diffs)
• drv/uhci-rhd/port.c (modified) (12 diffs)
• drv/uhci-rhd/port.h (modified) (1 diff)
• drv/uhci-rhd/port_status.c (modified) (2 diffs)
• drv/uhci-rhd/port_status.h (modified) (1 diff)
• drv/uhci-rhd/root_hub.c (modified) (3 diffs)
• drv/uhci-rhd/root_hub.h (modified) (1 diff)
• drv/usbhid/Makefile (modified) (1 diff)
• drv/usbhid/conv.c (modified) (3 diffs)
• drv/usbhid/descparser.c (deleted)
• drv/usbhid/descparser.h (deleted)
• drv/usbhid/hid.h (modified) (2 diffs)
• drv/usbhid/main.c (modified) (27 diffs)
• drv/usbhub/main.c (modified) (2 diffs)
• drv/usbhub/port_status.h (modified) (1 diff)
• drv/usbhub/usbhub.c (modified) (21 diffs)
• drv/usbhub/usbhub.h (modified) (2 diffs)
• lib/usb/include/usb/classes/hid.h (modified) (2 diffs)
• lib/usb/include/usb/classes/hidparser.h (modified) (1 diff)
• lib/usb/include/usb/request.h (modified) (1 diff)
• lib/usb/src/hidparser.c (modified) (1 diff)
• lib/usb/src/request.c (modified) (11 diffs)

uspace/drv/pciintel/pci.c

@@ -320 +320 @@
         /* Get the value of the BAR. */
         val = pci_conf_read_32(fun, addr);
+
+#define IO_MASK  (~0x3)
+#define MEM_MASK (~0xf)
         
         io = (bool) (val & 1);
         if (io) {
                 addrw64 = false;
+                mask = IO_MASK;
         } else {
+                mask = MEM_MASK;
                 switch ((val >> 1) & 3) {
                 case 0:
@@ -340 +345 @@
         /* Get the address mask. */
         pci_conf_write_32(fun, addr, 0xffffffff);
-        mask = pci_conf_read_32(fun, addr);
+        mask &= pci_conf_read_32(fun, addr);
         
         /* Restore the original value. */
@@ -659 +664 @@
 size_t pci_bar_mask_to_size(uint32_t mask)
 {
-        return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
+        size_t size = mask & ~(mask - 1);
+        return size;
 }
 

uspace/drv/uhci-hcd/Makefile

@@ -39 +39 @@
         uhci.c \
         uhci_struct/transfer_descriptor.c \
+        utils/device_keeper.c \
         pci.c \
         batch.c

uspace/drv/uhci-hcd/batch.c

@@ -33 +33 @@
  */
 #include <errno.h>
+#include <str_error.h>
 
 #include <usb/debug.h>
@@ -53 +54 @@
 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
-    dev_speed_t speed, char *buffer, size_t size,
+    usb_speed_t speed, char *buffer, size_t size,
     char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
@@ -133 +134 @@
 
         queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
+        usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
+            instance, target.address, target.endpoint);
         return instance;
 }
@@ -139 +142 @@
 {
         assert(instance);
-        usb_log_debug("Checking(%p) %d packet for completion.\n",
+        usb_log_debug2("Batch(%p) checking %d packet(s) for completion.\n",
             instance, instance->packets);
         instance->transfered_size = 0;
@@ -151 +154 @@
                         if (i > 0)
                                 instance->transfered_size -= instance->setup_size;
+                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
+                          instance, i, instance->tds[i].status);
                         return true;
                 }
@@ -156 +161 @@
                     transfer_descriptor_actual_size(&instance->tds[i]);
         }
-        /* This is just an ugly trick to support the old API */
         instance->transfered_size -= instance->setup_size;
         return true;
@@ -168 +172 @@
         memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
 
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
         int toggle = 0;
         /* setup stage */
         transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
-            instance->setup_size, toggle, false, instance->target,
-            USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
+            instance->setup_size, toggle, false, low_speed,
+            instance->target, USB_PID_SETUP, instance->setup_buffer,
+            &instance->tds[1]);
 
         /* data stage */
@@ -182 +188 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle++, false, instance->target,
-                    USB_PID_OUT, data, &instance->tds[i + 1]);
+                    instance->max_packet_size, toggle++, false, low_speed,
+                    instance->target, USB_PID_OUT, data, &instance->tds[i + 1]);
         }
 
@@ -189 +195 @@
         i = instance->packets - 1;
         transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-            0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
+            0, 1, false, low_speed, instance->target, USB_PID_IN, NULL, NULL);
 
         instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+        usb_log_debug2("Control write last TD status: %x.\n",
+                instance->tds[i].status);
 
         instance->next_step = batch_call_out_and_dispose;
+        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
         batch_schedule(instance);
 }
@@ -201 +210 @@
         assert(instance);
 
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
         int toggle = 0;
         /* setup stage */
         transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
-            instance->setup_size, toggle, false, instance->target,
+            instance->setup_size, toggle, false, low_speed, instance->target,
             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
 
@@ -215 +225 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle, false, instance->target,
-                    USB_PID_IN, data, &instance->tds[i + 1]);
+                    instance->max_packet_size, toggle, false, low_speed,
+                                instance->target, USB_PID_IN, data, &instance->tds[i + 1]);
         }
 
@@ -222 +232 @@
         i = instance->packets - 1;
         transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-            0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
+            0, 1, false, low_speed, instance->target, USB_PID_OUT, NULL, NULL);
 
         instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+        usb_log_debug2("Control read last TD status: %x.\n",
+                instance->tds[i].status);
 
         instance->next_step = batch_call_in_and_dispose;
+        usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
         batch_schedule(instance);
 }
@@ -234 +247 @@
         assert(instance);
 
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
         int toggle = 1;
         size_t i = 0;
@@ -244 +258 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle, false, instance->target,
-                    USB_PID_IN, data, next);
+                    instance->max_packet_size, toggle, false, low_speed,
+                    instance->target, USB_PID_IN, data, next);
         }
 
@@ -251 +265 @@
 
         instance->next_step = batch_call_in_and_dispose;
+        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
         batch_schedule(instance);
 }
@@ -260 +275 @@
         memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
 
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
         int toggle = 1;
         size_t i = 0;
@@ -270 +286 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle++, false, instance->target,
-                    USB_PID_OUT, data, next);
+                    instance->max_packet_size, toggle++, false, low_speed,
+                    instance->target, USB_PID_OUT, data, next);
         }
 
@@ -277 +293 @@
 
         instance->next_step = batch_call_out_and_dispose;
+        usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
         batch_schedule(instance);
 }
@@ -288 +305 @@
 
         int err = instance->error;
-        usb_log_info("Callback IN(%d): %d, %zu.\n", instance->transfer_type,
-            err, instance->transfered_size);
+        usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
+            instance, instance->transfer_type, str_error(err), err,
+            instance->transfered_size);
 
         instance->callback_in(instance->fun,
@@ -302 +320 @@
 
         int err = instance->error;
-        usb_log_info("Callback OUT(%d): %d.\n", instance->transfer_type, err);
+        usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
+            instance, instance->transfer_type, str_error(err), err);
         instance->callback_out(instance->fun,
             err, instance->arg);
@@ -311 +330 @@
         assert(instance);
         batch_call_in(instance);
-        usb_log_debug("Disposing batch: %p.\n", instance);
+        usb_log_debug("Batch(%p) disposing.\n", instance);
         free32(instance->tds);
         free32(instance->qh);
@@ -323 +342 @@
         assert(instance);
         batch_call_out(instance);
-        usb_log_debug("Disposing batch: %p.\n", instance);
+        usb_log_debug("Batch(%p) disposing.\n", instance);
         free32(instance->tds);
         free32(instance->qh);
@@ -338 +357 @@
         return uhci_schedule(hc, instance);
 }
-/*----------------------------------------------------------------------------*/
-/* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
-void batch_control_setup_old(batch_t *instance)
-{
-        assert(instance);
-        instance->packets = 1;
-
-        /* setup stage */
-        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
-            instance->setup_size, 0, false, instance->target,
-            USB_PID_SETUP, instance->setup_buffer, NULL);
-
-        instance->next_step = batch_call_out_and_dispose;
-        batch_schedule(instance);
-}
-/*----------------------------------------------------------------------------*/
-void batch_control_write_data_old(batch_t *instance)
-{
-        assert(instance);
-        instance->packets -= 2;
-        batch_interrupt_out(instance);
-}
-/*----------------------------------------------------------------------------*/
-void batch_control_read_data_old(batch_t *instance)
-{
-        assert(instance);
-        instance->packets -= 2;
-        batch_interrupt_in(instance);
-}
-/*----------------------------------------------------------------------------*/
-void batch_control_write_status_old(batch_t *instance)
-{
-        assert(instance);
-        instance->packets = 1;
-        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
-            0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
-        instance->next_step = batch_call_in_and_dispose;
-        batch_schedule(instance);
-}
-/*----------------------------------------------------------------------------*/
-void batch_control_read_status_old(batch_t *instance)
-{
-        assert(instance);
-        instance->packets = 1;
-        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
-            0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
-        instance->next_step = batch_call_out_and_dispose;
-        batch_schedule(instance);
-}
 /**
  * @}

uspace/drv/uhci-hcd/batch.h

@@ -43 +43 @@
 #include "uhci_struct/queue_head.h"
 
-typedef enum {
-        LOW_SPEED,
-        FULL_SPEED,
-} dev_speed_t;
-
 typedef struct batch
 {
         link_t link;
-        dev_speed_t speed;
+        usb_speed_t speed;
         usb_target_t target;
         usb_transfer_type_t transfer_type;
@@ -76 +71 @@
 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
-    dev_speed_t speed, char *buffer, size_t size,
+    usb_speed_t speed, char *buffer, size_t size,
                 char *setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,

uspace/drv/uhci-hcd/iface.c

@@ -41 +41 @@
 #include "iface.h"
 #include "uhci.h"
+#include "utils/device_keeper.h"
 
 /*----------------------------------------------------------------------------*/
@@ -48 +49 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_address_keeping_reserve_default(&hc->address_manager);
+        usb_log_debug("Default address request with speed %d.\n", speed);
+        device_keeper_reserve_default(&hc->device_manager, speed);
         return EOK;
 }
@@ -57 +59 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_address_keeping_release_default(&hc->address_manager);
+        usb_log_debug("Default address release.\n");
+        device_keeper_release_default(&hc->device_manager);
         return EOK;
 }
@@ -67 +70 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        *address = usb_address_keeping_request(&hc->address_manager);
+        assert(address);
+
+        usb_log_debug("Address request with speed %d.\n", speed);
+        *address = device_keeper_request(&hc->device_manager, speed);
+        usb_log_debug("Address request with result: %d.\n", *address);
         if (*address <= 0)
           return *address;
@@ -79 +86 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_address_keeping_devman_bind(&hc->address_manager, address, handle);
+        usb_log_debug("Address bind %d-%d.\n", address, handle);
+        device_keeper_bind(&hc->device_manager, address, handle);
         return EOK;
 }
@@ -88 +96 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_address_keeping_release_default(&hc->address_manager);
+        usb_log_debug("Address release %d.\n", address);
+        device_keeper_release(&hc->device_manager, address);
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
 static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
-    size_t max_packet_size,
-    void *data, size_t size,
+    size_t max_packet_size, void *data, size_t size,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
-        dev_speed_t speed = FULL_SPEED;
+        assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+
+        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
@@ -108 +122 @@
 /*----------------------------------------------------------------------------*/
 static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
-    size_t max_packet_size,
-    void *data, size_t size,
+    size_t max_packet_size, void *data, size_t size,
     usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
-        dev_speed_t speed = FULL_SPEED;
+        assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
@@ -127 +145 @@
     usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
-        dev_speed_t speed = FULL_SPEED;
+        assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Control WRITE %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
@@ -143 +166 @@
     usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
-        dev_speed_t speed = FULL_SPEED;
-
+        assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+
+        usb_log_debug("Control READ %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
             max_packet_size, speed, data, size, setup_data, setup_size, callback,

uspace/drv/uhci-hcd/main.c

@@ -82 +82 @@
         usb_log_info("uhci_add_device() called\n");
 
-
-        uintptr_t io_reg_base;
-        size_t io_reg_size;
-        int irq;
+        uintptr_t io_reg_base = 0;
+        size_t io_reg_size = 0;
+        int irq = 0;
 
         int ret =
@@ -95 +94 @@
             io_reg_base, io_reg_size, irq);
 
-        ret = pci_enable_interrupts(device);
-        CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
+//      ret = pci_enable_interrupts(device);
+//      CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
 
         uhci_t *uhci_hc = malloc(sizeof(uhci_t));
@@ -114 +113 @@
          */
         device->driver_data = uhci_hc;
-
         ret = register_interrupt_handler(device, irq, irq_handler,
             &uhci_hc->interrupt_code);
@@ -149 +147 @@
 {
         sleep(3);
-        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
+        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
 
         return ddf_driver_main(&uhci_driver);

uspace/drv/uhci-hcd/pci.c

@@ -38 +38 @@
 #include <devman.h>
 #include <device/hw_res.h>
+
+#include <usb/debug.h>
 
 #include "pci.h"
@@ -83 +85 @@
                                 irq = res->res.interrupt.irq;
                                 irq_found = true;
+                                usb_log_debug2("Found interrupt: %d.\n", irq);
                                 break;
                         case IO_RANGE:
-                                io_address = (uintptr_t)
-                                    res->res.io_range.address;
+                                io_address = res->res.io_range.address;
                                 io_size = res->res.io_range.size;
+                                usb_log_debug2("Found io: %llx %zu.\n",
+                                    res->res.io_range.address, res->res.io_range.size);
                                 io_found = true;
                                 break;
@@ -105 +109 @@
         }
 
-        if (io_reg_address != NULL) {
-                *io_reg_address = io_address;
-        }
-        if (io_reg_size != NULL) {
-                *io_reg_size = io_size;
-        }
-        if (irq_no != NULL) {
-                *irq_no = irq;
-        }
+        *io_reg_address = io_address;
+        *io_reg_size = io_size;
+        *irq_no = irq;
 
         rc = EOK;
@@ -127 +125 @@
             IPC_FLAG_BLOCKING);
         bool enabled = hw_res_enable_interrupt(parent_phone);
+        async_hangup(parent_phone);
         return enabled ? EOK : EIO;
 }

uspace/drv/uhci-hcd/root_hub.c

@@ -34 +34 @@
 #include <assert.h>
 #include <errno.h>
+#include <str_error.h>
 #include <stdio.h>
+#include <ops/hw_res.h>
+
 #include <usb_iface.h>
 #include <usb/debug.h>
@@ -41 +44 @@
 #include "uhci.h"
 
+/*----------------------------------------------------------------------------*/
 static int usb_iface_get_hc_handle_rh_impl(ddf_fun_t *root_hub_fun,
     devman_handle_t *handle)
@@ -51 +55 @@
         return EOK;
 }
-
+/*----------------------------------------------------------------------------*/
 static int usb_iface_get_address_rh_impl(ddf_fun_t *fun, devman_handle_t handle,
     usb_address_t *address)
@@ -61 +65 @@
         assert(hc);
 
-        usb_address_t addr = usb_address_keeping_find(&hc->address_manager,
+        usb_address_t addr = device_keeper_find(&hc->device_manager,
             handle);
         if (addr < 0) {
@@ -73 +77 @@
         return EOK;
 }
-
+/*----------------------------------------------------------------------------*/
 usb_iface_t usb_iface_root_hub_fun_impl = {
         .get_hc_handle = usb_iface_get_hc_handle_rh_impl,
         .get_address = usb_iface_get_address_rh_impl
 };
+/*----------------------------------------------------------------------------*/
+static hw_resource_list_t *get_resource_list(ddf_fun_t *dev)
+{
+        assert(dev);
+        ddf_fun_t *hc_ddf_instance = dev->driver_data;
+        assert(hc_ddf_instance);
+        uhci_t *hc = hc_ddf_instance->driver_data;
+        assert(hc);
 
+        //TODO: fix memory leak
+        hw_resource_list_t *resource_list = malloc(sizeof(hw_resource_list_t));
+        assert(resource_list);
+        resource_list->count = 1;
+        resource_list->resources = malloc(sizeof(hw_resource_t));
+        assert(resource_list->resources);
+        resource_list->resources[0].type = IO_RANGE;
+        resource_list->resources[0].res.io_range.address =
+            ((uintptr_t)hc->registers) + 0x10; // see UHCI design guide
+        resource_list->resources[0].res.io_range.size = 4;
+        resource_list->resources[0].res.io_range.endianness = LITTLE_ENDIAN;
+
+        return resource_list;
+}
+/*----------------------------------------------------------------------------*/
+static hw_res_ops_t hw_res_iface = {
+        .get_resource_list = get_resource_list,
+        .enable_interrupt = NULL
+};
+/*----------------------------------------------------------------------------*/
 static ddf_dev_ops_t root_hub_ops = {
-        .interfaces[USB_DEV_IFACE] = &usb_iface_root_hub_fun_impl
+        .interfaces[USB_DEV_IFACE] = &usb_iface_root_hub_fun_impl,
+        .interfaces[HW_RES_DEV_IFACE] = &hw_res_iface
 };
-
 /*----------------------------------------------------------------------------*/
 int setup_root_hub(ddf_fun_t **fun, ddf_dev_t *hc)
 {
         assert(fun);
+        assert(hc);
         int ret;
 
@@ -105 +138 @@
         ret = ddf_fun_add_match_id(hub, match_str, 100);
         if (ret != EOK) {
-                usb_log_error("Failed to add root hub match id.\n");
+                usb_log_error("Failed(%d) to add root hub match id: %s\n",
+                    ret, str_error(ret));
                 ddf_fun_destroy(hub);
-                return ENOMEM;
+                return ret;
         }
 

uspace/drv/uhci-hcd/transfer_list.c

@@ -70 +70 @@
         assert(instance);
         assert(batch);
+        usb_log_debug2("Adding batch(%p) to queue %s.\n", batch, instance->name);
 
         uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
@@ -83 +84 @@
                 list_append(&batch->link, &instance->batch_list);
                 instance->queue_head->element = pa;
-                usb_log_debug2("Added batch(%p) to queue %s first.\n",
+                usb_log_debug("Batch(%p) added to queue %s first.\n",
                         batch, instance->name);
                 fibril_mutex_unlock(&instance->guard);
@@ -96 +97 @@
         queue_head_append_qh(last->qh, pa);
         list_append(&batch->link, &instance->batch_list);
-        usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n",
+        usb_log_debug("Batch(%p) added to queue %s last, first is %p.\n",
                 batch, instance->name, first );
         fibril_mutex_unlock(&instance->guard);
@@ -108 +109 @@
         assert(instance->queue_head);
         assert(batch->qh);
+        usb_log_debug2("Removing batch(%p) from queue %s.\n", batch, instance->name);
 
         /* I'm the first one here */
         if (batch->link.prev == &instance->batch_list) {
-                usb_log_debug("Removing batch %p was first, next element %x.\n",
-                        batch, batch->qh->next_queue);
+                usb_log_debug("Batch(%p) removed (FIRST) from queue %s, next element %x.\n",
+                        batch, instance->name, batch->qh->next_queue);
                 instance->queue_head->element = batch->qh->next_queue;
         } else {
-                usb_log_debug("Removing batch %p was NOT first, next element %x.\n",
-                        batch, batch->qh->next_queue);
+                usb_log_debug("Batch(%p) removed (NOT FIRST) from queue, next element %x.\n",
+                        batch, instance->name, batch->qh->next_queue);
                 batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
                 prev->qh->next_queue = batch->qh->next_queue;
@@ -123 +125 @@
 }
 /*----------------------------------------------------------------------------*/
-void transfer_list_check(transfer_list_t *instance)
+void transfer_list_remove_finished(transfer_list_t *instance)
 {
         assert(instance);
+
+        LIST_INITIALIZE(done);
+
         fibril_mutex_lock(&instance->guard);
         link_t *current = instance->batch_list.next;
@@ -134 +139 @@
                 if (batch_is_complete(batch)) {
                         transfer_list_remove_batch(instance, batch);
-                        batch->next_step(batch);
+                        list_append(current, &done);
                 }
                 current = next;
         }
         fibril_mutex_unlock(&instance->guard);
+
+        while (!list_empty(&done)) {
+                link_t *item = done.next;
+                list_remove(item);
+                batch_t *batch = list_get_instance(item, batch_t, link);
+                batch->next_step(batch);
+        }
 }
 /**

uspace/drv/uhci-hcd/transfer_list.h

@@ -60 +60 @@
         queue_head_dispose(instance->queue_head);
 }
-void transfer_list_check(transfer_list_t *instance);
+void transfer_list_remove_finished(transfer_list_t *instance);
 
 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);

uspace/drv/uhci-hcd/uhci-hcd.ma

@@ -1 +1 @@
 10 pci/ven=8086&dev=7020
 10 pci/ven=8086&dev=7112
+
+10 pci/ven=8086&dev=27c8
+10 pci/ven=8086&dev=27c9
+10 pci/ven=8086&dev=27ca
+10 pci/ven=8086&dev=27cb
+
+
+10 pci/ven=8086&dev=2830
+10 pci/ven=8086&dev=2831
+10 pci/ven=8086&dev=2832
+10 pci/ven=8086&dev=2834
+10 pci/ven=8086&dev=2835
+
+10 pci/ven=8086&dev=2934
+10 pci/ven=8086&dev=2935
+10 pci/ven=8086&dev=2936
+10 pci/ven=8086&dev=2937
+10 pci/ven=8086&dev=2938
+10 pci/ven=8086&dev=2939

uspace/drv/uhci-hcd/uhci.c

@@ -48 +48 @@
         {
                 .cmd = CMD_PIO_READ_16,
-                .addr = (void*)0xc022,
+                .addr = NULL, /* patched for every instance */
                 .dstarg = 1
         },
         {
                 .cmd = CMD_PIO_WRITE_16,
-                .addr = (void*)0xc022,
+                .addr = NULL, /* pathed for every instance */
                 .value = 0x1f
         },
@@ -68 +68 @@
         assert(hc);
 
-        usb_address_t addr = usb_address_keeping_find(&hc->address_manager,
+        usb_address_t addr = device_keeper_find(&hc->device_manager,
             handle);
         if (addr < 0) {
@@ -80 +80 @@
         return EOK;
 }
-
-
+/*----------------------------------------------------------------------------*/
 static usb_iface_t hc_usb_iface = {
         .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
@@ -89 +88 @@
 static ddf_dev_ops_t uhci_ops = {
         .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
-        .interfaces[USBHC_DEV_IFACE] = &uhci_iface
+        .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
 };
 
@@ -102 +101 @@
         bool low_speed, usb_transfer_type_t, size_t size);
 
-#define CHECK_RET_RETURN(ret, message...) \
+
+int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
+{
+        assert(reg_size >= sizeof(regs_t));
+        int ret;
+
+#define CHECK_RET_DEST_FUN_RETURN(ret, message...) \
         if (ret != EOK) { \
                 usb_log_error(message); \
+                if (instance->ddf_instance) \
+                        ddf_fun_destroy(instance->ddf_instance); \
                 return ret; \
         } else (void) 0
-
-int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
-{
-        assert(reg_size >= sizeof(regs_t));
-        int ret;
 
         /*
@@ -117 +119 @@
          */
         instance->ddf_instance = ddf_fun_create(dev, fun_exposed, "uhci");
-        if (instance->ddf_instance == NULL) {
-                usb_log_error("Failed to create UHCI device function.\n");
-                return ENOMEM;
-        }
+        ret = (instance->ddf_instance == NULL) ? ENOMEM : EOK;
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to create UHCI device function.\n");
+
         instance->ddf_instance->ops = &uhci_ops;
         instance->ddf_instance->driver_data = instance;
 
         ret = ddf_fun_bind(instance->ddf_instance);
-        CHECK_RET_RETURN(ret, "Failed to bind UHCI device function: %s.\n",
-            str_error(ret));
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to bind UHCI device function: %s.\n",
+            ret, str_error(ret));
 
         /* allow access to hc control registers */
         regs_t *io;
         ret = pio_enable(regs, reg_size, (void**)&io);
-        CHECK_RET_RETURN(ret, "Failed to gain access to registers at %p.\n", io);
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to gain access to registers at %p: %s.\n",
+            ret, str_error(ret), io);
         instance->registers = io;
-        usb_log_debug("Device registers accessible.\n");
+        usb_log_debug("Device registers at %p(%u) accessible.\n", io, reg_size);
 
         ret = uhci_init_mem_structures(instance);
-        CHECK_RET_RETURN(ret, "Failed to initialize memory structures.\n");
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to initialize UHCI memory structures.\n");
 
         uhci_init_hw(instance);
 
         instance->cleaner = fibril_create(uhci_interrupt_emulator, instance);
-//      fibril_add_ready(instance->cleaner);
+        fibril_add_ready(instance->cleaner);
 
         instance->debug_checker = fibril_create(uhci_debug_checker, instance);
         fibril_add_ready(instance->debug_checker);
 
-        return EOK;
+        usb_log_info("Started UHCI driver.\n");
+        return EOK;
+#undef CHECK_RET_DEST_FUN_RETURN
 }
 /*----------------------------------------------------------------------------*/
 void uhci_init_hw(uhci_t *instance)
 {
+        /* reset everything, who knows what touched it before us */
+        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
+        async_usleep(10000); /* 10ms according to USB spec */
+        pio_write_16(&instance->registers->usbcmd, 0);
+
+        /* reset hc, all states and counters */
+        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_HCRESET);
+        while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0)
+                { async_usleep(10); }
 
         /* set framelist pointer */
@@ -163 +176 @@
         pio_write_16(&instance->registers->usbcmd,
             UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
-        usb_log_debug("Started UHCI HC.\n");
 }
 /*----------------------------------------------------------------------------*/
@@ -169 +181 @@
 {
         assert(instance);
+#define CHECK_RET_DEST_CMDS_RETURN(ret, message...) \
+        if (ret != EOK) { \
+                usb_log_error(message); \
+                if (instance->interrupt_code.cmds != NULL) \
+                        free(instance->interrupt_code.cmds); \
+                return ret; \
+        } else (void) 0
 
         /* init interrupt code */
-        irq_cmd_t *interrupt_commands = malloc(sizeof(uhci_cmds));
-        if (interrupt_commands == NULL) {
-                return ENOMEM;
-        }
-        memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
-        interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
-        interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
-        instance->interrupt_code.cmds = interrupt_commands;
-        instance->interrupt_code.cmdcount =
-            sizeof(uhci_cmds) / sizeof(irq_cmd_t);
+        instance->interrupt_code.cmds = malloc(sizeof(uhci_cmds));
+        int ret = (instance->interrupt_code.cmds == NULL) ? ENOMEM : EOK;
+        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to allocate interrupt cmds space.\n");
+
+        {
+                irq_cmd_t *interrupt_commands = instance->interrupt_code.cmds;
+                memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
+                interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
+                interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
+                instance->interrupt_code.cmdcount =
+                                sizeof(uhci_cmds) / sizeof(irq_cmd_t);
+        }
 
         /* init transfer lists */
-        int ret = uhci_init_transfer_lists(instance);
-        CHECK_RET_RETURN(ret, "Failed to initialize transfer lists.\n");
+        ret = uhci_init_transfer_lists(instance);
+        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to initialize transfer lists.\n");
         usb_log_debug("Initialized transfer lists.\n");
 
@@ -190 +211 @@
         instance->frame_list = get_page();
         ret = instance ? EOK : ENOMEM;
-        CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
+        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
         usb_log_debug("Initialized frame list.\n");
 
@@ -197 +218 @@
           instance->transfers_interrupt.queue_head_pa
           | LINK_POINTER_QUEUE_HEAD_FLAG;
+
         unsigned i = 0;
         for(; i < UHCI_FRAME_LIST_COUNT; ++i) {
@@ -203 +225 @@
 
         /* init address keeper(libusb) */
-        usb_address_keeping_init(&instance->address_manager, USB11_ADDRESS_MAX);
-        usb_log_debug("Initialized address manager.\n");
-
-        return EOK;
+        device_keeper_init(&instance->device_manager);
+        usb_log_debug("Initialized device manager.\n");
+
+        return EOK;
+#undef CHECK_RET_DEST_CMDS_RETURN
 }
 /*----------------------------------------------------------------------------*/
@@ -212 +235 @@
 {
         assert(instance);
+#define CHECK_RET_CLEAR_RETURN(ret, message...) \
+        if (ret != EOK) { \
+                usb_log_error(message); \
+                transfer_list_fini(&instance->transfers_bulk_full); \
+                transfer_list_fini(&instance->transfers_control_full); \
+                transfer_list_fini(&instance->transfers_control_slow); \
+                transfer_list_fini(&instance->transfers_interrupt); \
+                return ret; \
+        } else (void) 0
 
         /* initialize TODO: check errors */
         int ret;
         ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
-        assert(ret == EOK);
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
         ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
-        assert(ret == EOK);
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL FULL list.");
         ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
-        assert(ret == EOK);
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
         ret = transfer_list_init(&instance->transfers_interrupt, "INTERRUPT");
-        assert(ret == EOK);
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init INTERRUPT list.");
 
         transfer_list_set_next(&instance->transfers_control_full,
@@ -249 +281 @@
 
         return EOK;
+#undef CHECK_RET_CLEAR_RETURN
 }
 /*----------------------------------------------------------------------------*/
@@ -255 +288 @@
         assert(instance);
         assert(batch);
-        const int low_speed = (batch->speed == LOW_SPEED);
+        const int low_speed = (batch->speed == USB_SPEED_LOW);
         if (!allowed_usb_packet(
             low_speed, batch->transfer_type, batch->max_packet_size)) {
@@ -276 +309 @@
 {
         assert(instance);
-        if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
-                return;
-        usb_log_debug("UHCI interrupt: %X.\n", status);
-        transfer_list_check(&instance->transfers_interrupt);
-        transfer_list_check(&instance->transfers_control_slow);
-        transfer_list_check(&instance->transfers_control_full);
-        transfer_list_check(&instance->transfers_bulk_full);
+//      if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
+//              return;
+//      usb_log_debug2("UHCI interrupt: %X.\n", status);
+        transfer_list_remove_finished(&instance->transfers_interrupt);
+        transfer_list_remove_finished(&instance->transfers_control_slow);
+        transfer_list_remove_finished(&instance->transfers_control_full);
+        transfer_list_remove_finished(&instance->transfers_bulk_full);
 }
 /*----------------------------------------------------------------------------*/
@@ -291 +324 @@
         assert(instance);
 
-        while(1) {
+        while (1) {
                 uint16_t status = pio_read_16(&instance->registers->usbsts);
+                if (status != 0)
+                        usb_log_debug2("UHCI status: %x.\n", status);
+                status |= 1;
                 uhci_interrupt(instance, status);
-                async_usleep(UHCI_CLEANER_TIMEOUT);
+                pio_write_16(&instance->registers->usbsts, 0x1f);
+                async_usleep(UHCI_CLEANER_TIMEOUT * 5);
         }
         return EOK;
@@ -307 +344 @@
                 const uint16_t sts = pio_read_16(&instance->registers->usbsts);
                 const uint16_t intr = pio_read_16(&instance->registers->usbintr);
-                usb_log_debug("Command: %X Status: %X Interrupts: %x\n",
-                    cmd, sts, intr);
-
-                uintptr_t frame_list = pio_read_32(&instance->registers->flbaseadd);
+                if (((cmd & UHCI_CMD_RUN_STOP) != 1) || (sts != 0)) {
+                        usb_log_debug2("Command: %X Status: %X Intr: %x\n",
+                            cmd, sts, intr);
+                }
+
+                uintptr_t frame_list =
+                    pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
                 if (frame_list != addr_to_phys(instance->frame_list)) {
                         usb_log_debug("Framelist address: %p vs. %p.\n",

uspace/drv/uhci-hcd/uhci.h

@@ -41 +41 @@
 #include <ddi.h>
 
-#include <usb/addrkeep.h>
 #include <usbhc_iface.h>
 
+#include "batch.h"
 #include "transfer_list.h"
-#include "batch.h"
+#include "utils/device_keeper.h"
 
 typedef struct uhci_regs {
@@ -82 +82 @@
 
 typedef struct uhci {
-        usb_address_keeping_t address_manager;
+        device_keeper_t device_manager;
+
         volatile regs_t *registers;
 

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c

@@ -39 +39 @@
 
 void transfer_descriptor_init(transfer_descriptor_t *instance,
-    int error_count, size_t size, bool toggle, bool isochronous,
+    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
     usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
 {
@@ -50 +50 @@
         instance->status = 0
           | ((error_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
+                | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
           | TD_STATUS_ERROR_ACTIVE;
 
@@ -66 +67 @@
         }
 
-        usb_log_info("Created TD: %X:%X:%X:%X(%p).\n",
+        usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
                 instance->next, instance->status, instance->device,
           instance->buffer_ptr, buffer);
-#if 0
-        if (size) {
-                unsigned char * buff = buffer;
-                uhci_print_verbose("TD Buffer dump(%p-%dB): ", buffer, size);
-                unsigned i = 0;
-                /* TODO: Verbose? */
-                for (; i < size; ++i) {
-                        printf((i & 1) ? "%x " : "%x", buff[i]);
-                }
-                printf("\n");
-        }
-#endif
 }
 /*----------------------------------------------------------------------------*/
@@ -88 +77 @@
 
         if ((instance->status & TD_STATUS_ERROR_STALLED) != 0)
-                return EIO;
+                return ESTALL;
 
         if ((instance->status & TD_STATUS_ERROR_CRC) != 0)
-                return EAGAIN;
+                return EBADCHECKSUM;
 
         if ((instance->status & TD_STATUS_ERROR_BUFFER) != 0)

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h

@@ -92 +92 @@
 
 void transfer_descriptor_init(transfer_descriptor_t *instance,
-    int error_count, size_t size, bool toggle, bool isochronous,
+    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
     usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
 

uspace/drv/uhci-rhd/main.c

@@ -33 +33 @@
  */
 #include <ddf/driver.h>
+#include <devman.h>
+#include <device/hw_res.h>
 #include <usb_iface.h>
 #include <usb/ddfiface.h>
@@ -43 +45 @@
 
 #define NAME "uhci-rhd"
+static int hc_get_my_registers(ddf_dev_t *dev,
+    uintptr_t *io_reg_address, size_t *io_reg_size);
 
 static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
@@ -80 +84 @@
         }
 
-        /* TODO: get register values from hc */
-        int ret = uhci_root_hub_init(rh, (void*)0xc030, 4, device);
+        uintptr_t io_regs = 0;
+        size_t io_size = 0;
+
+        int ret = hc_get_my_registers(device, &io_regs, &io_size);
+        assert(ret == EOK);
+
+        /* TODO: verify values from hc */
+        usb_log_info("I/O regs at 0x%X (size %zu).\n", io_regs, io_size);
+        ret = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
         if (ret != EOK) {
                 usb_log_error("Failed(%d) to initialize driver instance.\n", ret);
@@ -102 +113 @@
         .driver_ops = &uhci_rh_driver_ops
 };
-
+/*----------------------------------------------------------------------------*/
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
+        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
         return ddf_driver_main(&uhci_rh_driver);
+}
+/*----------------------------------------------------------------------------*/
+int hc_get_my_registers(ddf_dev_t *dev,
+    uintptr_t *io_reg_address, size_t *io_reg_size)
+{
+        assert(dev != NULL);
+
+        int parent_phone = devman_parent_device_connect(dev->handle,
+            IPC_FLAG_BLOCKING);
+        if (parent_phone < 0) {
+                return parent_phone;
+        }
+
+        int rc;
+
+        hw_resource_list_t hw_resources;
+        rc = hw_res_get_resource_list(parent_phone, &hw_resources);
+        if (rc != EOK) {
+                goto leave;
+        }
+
+        uintptr_t io_address = 0;
+        size_t io_size = 0;
+        bool io_found = false;
+
+        size_t i;
+        for (i = 0; i < hw_resources.count; i++) {
+                hw_resource_t *res = &hw_resources.resources[i];
+                switch (res->type) {
+                        case IO_RANGE:
+                                io_address = (uintptr_t)
+                                    res->res.io_range.address;
+                                io_size = res->res.io_range.size;
+                                io_found = true;
+                                break;
+                        default:
+                                break;
+                }
+        }
+
+        if (!io_found) {
+                rc = ENOENT;
+                goto leave;
+        }
+
+        if (io_reg_address != NULL) {
+                *io_reg_address = io_address;
+        }
+        if (io_reg_size != NULL) {
+                *io_reg_size = io_size;
+        }
+        rc = EOK;
+leave:
+        async_hangup(parent_phone);
+
+        return rc;
 }
 /**

uspace/drv/uhci-rhd/port.c

@@ -34 +34 @@
 #include <errno.h>
 #include <str_error.h>
+#include <fibril_synch.h>
 
 #include <usb/usb.h>    /* usb_address_t */
@@ -45 +46 @@
 #include "port_status.h"
 
-static int uhci_port_new_device(uhci_port_t *port);
+static int uhci_port_new_device(uhci_port_t *port, uint16_t status);
 static int uhci_port_remove_device(uhci_port_t *port);
 static int uhci_port_set_enabled(uhci_port_t *port, bool enabled);
 static int uhci_port_check(void *port);
+static int new_device_enable_port(int portno, void *arg);
 
 int uhci_port_init(
   uhci_port_t *port, port_status_t *address, unsigned number,
-  unsigned usec, ddf_dev_t *rh, int parent_phone)
+  unsigned usec, ddf_dev_t *rh)
 {
         assert(port);
@@ -69 +71 @@
         port->checker = fibril_create(uhci_port_check, port);
         if (port->checker == 0) {
-                usb_log_error(": failed to launch root hub fibril.");
+                usb_log_error("Port(%p - %d): failed to launch root hub fibril.",
+                    port->address, port->number);
                 return ENOMEM;
         }
         fibril_add_ready(port->checker);
-        usb_log_debug(
-          "Added fibril for port %d: %p.\n", number, port->checker);
+        usb_log_debug("Port(%p - %d): Added fibril. %x\n",
+            port->address, port->number, port->checker);
         return EOK;
 }
@@ -90 +93 @@
         uhci_port_t *port_instance = port;
         assert(port_instance);
+//      port_status_write(port_instance->address, 0);
+
+        unsigned count = 0;
 
         while (1) {
+                async_usleep(port_instance->wait_period_usec);
+
                 /* read register value */
                 port_status_t port_status =
@@ -97 +105 @@
 
                 /* debug print */
-                usb_log_debug("Port %d status at %p: 0x%04x.\n",
-                  port_instance->number, port_instance->address, port_status);
-                print_port_status(port_status);
-
-                if (port_status & STATUS_CONNECTED_CHANGED) {
+                static fibril_mutex_t dbg_mtx = FIBRIL_MUTEX_INITIALIZER(dbg_mtx);
+                fibril_mutex_lock(&dbg_mtx);
+                usb_log_debug2("Port(%p - %d): Status: %#04x. === %u\n",
+                  port_instance->address, port_instance->number, port_status, count++);
+//              print_port_status(port_status);
+                fibril_mutex_unlock(&dbg_mtx);
+
+                if ((port_status & STATUS_CONNECTED_CHANGED) != 0) {
+                        usb_log_debug("Port(%p - %d): Connected change detected: %x.\n",
+                            port_instance->address, port_instance->number, port_status);
+
+
                         int rc = usb_hc_connection_open(
                             &port_instance->hc_connection);
                         if (rc != EOK) {
-                                usb_log_error("Failed to connect to HC.");
-                                goto next;
-                        }
-
-                        if (port_status & STATUS_CONNECTED) {
+                                usb_log_error("Port(%p - %d): Failed to connect to HC.",
+                                    port_instance->address, port_instance->number);
+                                continue;
+                        }
+
+                        /* remove any old device */
+                        if (port_instance->attached_device) {
+                                usb_log_debug("Port(%p - %d): Removing device.\n",
+                                    port_instance->address, port_instance->number);
+                                uhci_port_remove_device(port_instance);
+                        }
+
+                        if ((port_status & STATUS_CONNECTED) != 0) {
                                 /* new device */
-                                uhci_port_new_device(port_instance);
+                                uhci_port_new_device(port_instance, port_status);
                         } else {
-                                uhci_port_remove_device(port_instance);
+                                /* ack changes by writing one to WC bits */
+                                port_status_write(port_instance->address, port_status);
+                                usb_log_debug("Port(%p - %d): Change status ACK.\n",
+                                                port_instance->address, port_instance->number);
                         }
 
@@ -119 +145 @@
                             &port_instance->hc_connection);
                         if (rc != EOK) {
-                                usb_log_error("Failed to disconnect from HC.");
-                                goto next;
+                                usb_log_error("Port(%p - %d): Failed to disconnect from HC.",
+                                    port_instance->address, port_instance->number);
                         }
                 }
-        next:
-                async_usleep(port_instance->wait_period_usec);
         }
         return EOK;
@@ -139 +163 @@
         uhci_port_t *port = (uhci_port_t *) arg;
 
-        usb_log_debug("new_device_enable_port(%d)\n", port->number);
+        usb_log_debug2("Port(%p - %d): new_device_enable_port.\n",
+            port->address, port->number);
 
         /*
@@ -147 +172 @@
         async_usleep(100000);
 
-        /* Enable the port. */
-        uhci_port_set_enabled(port, true);
 
         /* The hub maintains the reset signal to that port for 10 ms
@@ -154 +177 @@
          */
         {
-                usb_log_debug("Reset Signal start on port %d.\n",
-                    port->number);
+                usb_log_debug("Port(%p - %d): Reset Signal start.\n",
+                    port->address, port->number);
                 port_status_t port_status =
                         port_status_read(port->address);
@@ -165 +188 @@
                 port_status &= ~STATUS_IN_RESET;
                 port_status_write(port->address, port_status);
-                usb_log_debug("Reset Signal stop on port %d.\n",
-                    port->number);
-        }
-
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-static int uhci_port_new_device(uhci_port_t *port)
+                usb_log_debug("Port(%p - %d): Reset Signal stop.\n",
+                    port->address, port->number);
+        }
+
+        /* Enable the port. */
+        uhci_port_set_enabled(port, true);
+
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+static int uhci_port_new_device(uhci_port_t *port, uint16_t status)
 {
         assert(port);
         assert(usb_hc_connection_is_opened(&port->hc_connection));
 
-        usb_log_info("Detected new device on port %u.\n", port->number);
+        usb_log_info("Port(%p-%d): Detected new device.\n",
+            port->address, port->number);
 
         usb_address_t dev_addr;
         int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
-            USB_SPEED_FULL,
+            ((status & STATUS_LOW_SPEED) != 0) ? USB_SPEED_LOW : USB_SPEED_FULL,
             new_device_enable_port, port->number, port,
             &dev_addr, &port->attached_device, NULL, NULL, NULL);
+
         if (rc != EOK) {
-                usb_log_error("Failed adding new device on port %u: %s.\n",
-                    port->number, str_error(rc));
+                usb_log_error("Port(%p-%d): Failed(%d) adding new device: %s.\n",
+                    port->address, port->number, rc, str_error(rc));
                 uhci_port_set_enabled(port, false);
                 return rc;
         }
 
-        usb_log_info("New device on port %u has address %d (handle %zu).\n",
-            port->number, dev_addr, port->attached_device);
+        usb_log_info("Port(%p-%d): New device has address %d (handle %zu).\n",
+            port->address, port->number, dev_addr, port->attached_device);
 
         return EOK;
@@ -201 +229 @@
 static int uhci_port_remove_device(uhci_port_t *port)
 {
-        usb_log_error("Don't know how to remove device %#x.\n",
-                (unsigned int)port->attached_device);
+        usb_log_error("Port(%p-%d): Don't know how to remove device %#x.\n",
+                port->address, port->number, (unsigned int)port->attached_device);
 //      uhci_port_set_enabled(port, false);
         return EOK;
@@ -223 +251 @@
         port_status_write(port->address, port_status);
 
-        usb_log_info("%s port %d.\n",
-          enabled ? "Enabled" : "Disabled", port->number);
+        usb_log_info("Port(%p-%d): %sabled port.\n",
+                port->address, port->number, enabled ? "En" : "Dis");
         return EOK;
 }

uspace/drv/uhci-rhd/port.h

@@ -55 +55 @@
 int uhci_port_init(
   uhci_port_t *port, port_status_t *address, unsigned number,
-  unsigned usec, ddf_dev_t *rh, int parent_phone);
+  unsigned usec, ddf_dev_t *rh);
 
 void uhci_port_fini(uhci_port_t *port);

uspace/drv/uhci-rhd/port_status.c

@@ -41 +41 @@
 struct flag_name
 {
-        unsigned flag;
+        uint16_t flag;
         const char *name;
 };
@@ -65 +65 @@
         for (;i < sizeof(flags)/sizeof(struct flag_name); ++i) {
                 usb_log_debug2("\t%s status: %s.\n", flags[i].name,
-                  value & flags[i].flag ? "YES" : "NO");
+                  ((value & flags[i].flag) != 0) ? "YES" : "NO");
         }
 }

uspace/drv/uhci-rhd/port_status.h

@@ -41 +41 @@
 typedef uint16_t port_status_t;
 
-enum {
-        STATUS_CONNECTED         = 1 << 0,
-        STATUS_CONNECTED_CHANGED = 1 << 1,
-        STATUS_ENABLED           = 1 << 2,
-        STATUS_ENABLED_CHANGED   = 1 << 3,
-        STATUS_LINE_D_PLUS       = 1 << 4,
-        STATUS_LINE_D_MINUS      = 1 << 5,
-        STATUS_RESUME            = 1 << 6,
-        STATUS_ALWAYS_ONE        = 1 << 7,
+#define STATUS_CONNECTED         (1 << 0)
+#define STATUS_CONNECTED_CHANGED (1 << 1)
+#define STATUS_ENABLED           (1 << 2)
+#define STATUS_ENABLED_CHANGED   (1 << 3)
+#define STATUS_LINE_D_PLUS       (1 << 4)
+#define STATUS_LINE_D_MINUS      (1 << 5)
+#define STATUS_RESUME            (1 << 6)
+#define STATUS_ALWAYS_ONE        (1 << 7)
 
-        STATUS_LOW_SPEED = 1 <<  8,
-        STATUS_IN_RESET  = 1 <<  9,
-        STATUS_SUSPEND   = 1 << 12,
-};
+#define STATUS_LOW_SPEED (1 <<  8)
+#define STATUS_IN_RESET  (1 <<  9)
+#define STATUS_SUSPEND   (1 << 12)
 
 static inline port_status_t port_status_read(port_status_t * address)

uspace/drv/uhci-rhd/root_hub.c

@@ -40 +40 @@
 #include "root_hub.h"
 
-
 int uhci_root_hub_init(
   uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh)
@@ -47 +46 @@
         assert(rh);
         int ret;
-        ret = usb_hc_find(rh->handle, &instance->hc_handle);
-        usb_log_info("rh found(%d) hc handle: %d.\n", ret, instance->hc_handle);
-        if (ret != EOK) {
-                return ret;
-        }
 
         /* allow access to root hub registers */
         assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT == size);
         port_status_t *regs;
-        ret = pio_enable(
-          addr, sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT, (void**)&regs);
+        ret = pio_enable(addr, size, (void**)&regs);
 
         if (ret < 0) {
@@ -67 +60 @@
         unsigned i = 0;
         for (; i < UHCI_ROOT_HUB_PORT_COUNT; ++i) {
-                /* connect to the parent device (HC) */
-                int parent_phone = devman_device_connect(instance->hc_handle, 0);
-                //usb_drv_hc_connect(rh, instance->hc_handle, 0);
-                if (parent_phone < 0) {
-                        usb_log_error("Failed to connect to the HC device port %d.\n", i);
-                        return parent_phone;
-                }
                 /* mind pointer arithmetics */
-                int ret = uhci_port_init(
-                  &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh, parent_phone);
+                ret = uhci_port_init(
+                  &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh);
                 if (ret != EOK) {
                         unsigned j = 0;

uspace/drv/uhci-rhd/root_hub.h

@@ -41 +41 @@
 
 #define UHCI_ROOT_HUB_PORT_COUNT 2
-#define UHCI_ROOT_HUB_PORT_REGISTERS_OFFSET 0x10
-#define ROOT_HUB_WAIT_USEC 10000000 /* 10 seconds */
+#define ROOT_HUB_WAIT_USEC 5000000 /* 5 seconds */
 
 typedef struct root_hub {

uspace/drv/usbhid/Makefile

@@ -39 +39 @@
 SOURCES = \
         main.c \
-        descparser.c \
-        descdump.c \
         conv.c \
         $(STOLEN_LAYOUT_SOURCES)

uspace/drv/usbhid/conv.c

@@ -36 +36 @@
 #include <io/keycode.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <usb/debug.h>
 #include "conv.h"
 
@@ -141 +143 @@
         //[0xe7] = KC_R // TODO: right GUI
         
+        [0x53] = KC_NUM_LOCK,
+        [0x54] = KC_NSLASH,
+        [0x55] = KC_NTIMES,
+        [0x56] = KC_NMINUS,
+        [0x57] = KC_NPLUS,
+        [0x58] = KC_NENTER,
+        [0x59] = KC_N1,
+        [0x5a] = KC_N2,
+        [0x5b] = KC_N3,
+        [0x5c] = KC_N4,
+        [0x5d] = KC_N5,
+        [0x5e] = KC_N6,
+        [0x5f] = KC_N7,
+        [0x60] = KC_N8,
+        [0x61] = KC_N9,
+        [0x62] = KC_N0,
+        [0x63] = KC_NPERIOD
+        
 };
 
@@ -189 +209 @@
 
         key = map[scancode];
+        
+        if (scancode == 0x53) {
+                usb_log_debug("\n\nWe have a NUM LOCK!, sending key %u\n\n", key);
+        }
+        
+        if (scancode == 0x47) {
+                usb_log_debug("\n\nWe have a SCROLL LOCK!, sending key %u\n\n", key);
+        }
+        
+        if (scancode == 0x39) {
+                usb_log_debug("\n\nWe have a CAPS LOCK!, sending key %u\n\n", key);
+        }
+        
 //      if (key != 0)
 //              kbd_push_ev(type, key);

uspace/drv/usbhid/hid.h

@@ -37 +37 @@
 #define USBHID_HID_H_
 
+#include <stdint.h>
+
 #include <usb/classes/hid.h>
 #include <ddf/driver.h>
 #include <usb/pipes.h>
-
-/**
- *
- */
-typedef struct {
-        usb_standard_interface_descriptor_t iface_desc;
-        usb_standard_endpoint_descriptor_t *endpoints;
-        usb_standard_hid_descriptor_t hid_desc;
-        uint8_t *report_desc;
-        //usb_standard_hid_class_descriptor_info_t *class_desc_info;
-        //uint8_t **class_descs;
-} usb_hid_iface_t;
-
-/**
- *
- */
-typedef struct {
-        usb_standard_configuration_descriptor_t config_descriptor;
-        usb_hid_iface_t *interfaces;
-} usb_hid_configuration_t;
 
 /**
@@ -68 +50 @@
 typedef struct {
         ddf_dev_t *device;
-        usb_hid_configuration_t *conf;
-        usb_hid_report_parser_t *parser;
 
         usb_device_connection_t wire;
         usb_endpoint_pipe_t ctrl_pipe;
         usb_endpoint_pipe_t poll_pipe;
+        
+        uint16_t iface;
+        
+        uint8_t *report_desc;
+        usb_hid_report_parser_t *parser;
+        
+        uint8_t *keycodes;
+        size_t keycode_count;
+        uint8_t modifiers;
+        
+        unsigned mods;
+        unsigned lock_keys;
 } usb_hid_dev_kbd_t;
 
-// TODO: more configurations!
-
 #endif

uspace/drv/usbhid/main.c

@@ -51 +51 @@
 #include <usb/descriptor.h>
 #include <io/console.h>
+#include <stdint.h>
+#include <usb/dp.h>
 #include "hid.h"
-#include "descparser.h"
-#include "descdump.h"
 #include "conv.h"
 #include "layout.h"
 
 #define BUFFER_SIZE 8
+#define BUFFER_OUT_SIZE 1
 #define NAME "usbhid"
 
-#define GUESSED_POLL_ENDPOINT 1
+//#define GUESSED_POLL_ENDPOINT 1
+#define BOOTP_REPORT_SIZE 6
+
+static unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK;
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -120 +124 @@
 
 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length)
-{
+{uint8_t buffer[BUFFER_SIZE];
         printf("%s\n", msg);
         
@@ -137 +141 @@
  */
 
-/** Currently active modifiers. 
+/** Currently active modifiers (locks is probably better word).
  *
  * TODO: put to device?
  */
-static unsigned mods = KM_NUM_LOCK;
+//static unsigned mods = KM_NUM_LOCK;
 
 /** Currently pressed lock keys. We track these to tackle autorepeat.  
@@ -147 +151 @@
  * TODO: put to device? 
  */
-static unsigned lock_keys;
+//static unsigned lock_keys;
 
 #define NUM_LAYOUTS 3
@@ -159 +163 @@
 static int active_layout = 0;
 
-static void kbd_push_ev(int type, unsigned int key)
+static void usbkbd_req_set_report(usb_hid_dev_kbd_t *kbd_dev, uint16_t iface,
+    usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size)
+{
+        int rc, sess_rc;
+        
+        sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
+        if (sess_rc != EOK) {
+                usb_log_warning("Failed to start a session: %s.\n",
+                    str_error(sess_rc));
+                return;
+        }
+
+        usb_log_debug("Sending Set_Report request to the device.\n");
+        
+        rc = usb_control_request_set(&kbd_dev->ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_SET_REPORT, type, iface, buffer, buf_size);
+
+        sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
+
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return;
+        }
+
+        if (sess_rc != EOK) {
+                usb_log_warning("Error closing session: %s.\n",
+                    str_error(sess_rc));
+                return;
+        }
+}
+
+static void usbkbd_req_set_protocol(usb_hid_dev_kbd_t *kbd_dev,
+    usb_hid_protocol_t protocol)
+{
+        int rc, sess_rc;
+        
+        sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
+        if (sess_rc != EOK) {
+                usb_log_warning("Failed to start a session: %s.\n",
+                    str_error(sess_rc));
+                return;
+        }
+
+        usb_log_debug("Sending Set_Protocol request to the device ("
+            "protocol: %d, iface: %d).\n", protocol, kbd_dev->iface);
+        
+        rc = usb_control_request_set(&kbd_dev->ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_SET_PROTOCOL, protocol, kbd_dev->iface, NULL, 0);
+
+        sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
+
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return;
+        }
+
+        if (sess_rc != EOK) {
+                usb_log_warning("Error closing session: %s.\n",
+                    str_error(sess_rc));
+                return;
+        }
+}
+
+static void usbkbd_set_led(usb_hid_dev_kbd_t *kbd_dev) 
+{
+        uint8_t buffer[BUFFER_OUT_SIZE];
+        int rc= 0, i;
+        
+        memset(buffer, 0, BUFFER_OUT_SIZE);
+        uint8_t leds = 0;
+
+        if (kbd_dev->mods & KM_NUM_LOCK) {
+                leds |= USB_HID_LED_NUM_LOCK;
+        }
+        
+        if (kbd_dev->mods & KM_CAPS_LOCK) {
+                leds |= USB_HID_LED_CAPS_LOCK;
+        }
+        
+        if (kbd_dev->mods & KM_SCROLL_LOCK) {
+                leds |= USB_HID_LED_SCROLL_LOCK;
+        }
+
+        // TODO: COMPOSE and KANA
+        
+        usb_log_debug("Creating output report.\n");
+        usb_log_debug("Leds: 0x%x\n", leds);
+        if ((rc = usb_hid_boot_keyboard_output_report(
+            leds, buffer, BUFFER_OUT_SIZE)) != EOK) {
+                usb_log_warning("Error composing output report to the keyboard:"
+                    "%s.\n", str_error(rc));
+                return;
+        }
+        
+        usb_log_debug("Output report buffer: ");
+        for (i = 0; i < BUFFER_OUT_SIZE; ++i) {
+                usb_log_debug("0x%x ", buffer[i]);
+        }
+        usb_log_debug("\n");
+        
+        uint16_t value = 0;
+        value |= (USB_HID_REPORT_TYPE_OUTPUT << 8);
+
+        usbkbd_req_set_report(kbd_dev, kbd_dev->iface, value, buffer, 
+            BUFFER_OUT_SIZE);
+}
+
+static void kbd_push_ev(int type, unsigned int key, usb_hid_dev_kbd_t *kbd_dev)
 {
         console_event_t ev;
@@ -177 +292 @@
         if (mod_mask != 0) {
                 if (type == KEY_PRESS)
-                        mods = mods | mod_mask;
+                        kbd_dev->mods = kbd_dev->mods | mod_mask;
                 else
-                        mods = mods & ~mod_mask;
+                        kbd_dev->mods = kbd_dev->mods & ~mod_mask;
         }
 
         switch (key) {
-        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
-        case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
-        case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
+        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; usb_log_debug2("\n\nPushing CAPS LOCK! (mask: %u)\n\n", mod_mask); break;
+        case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; usb_log_debug2("\n\nPushing NUM LOCK! (mask: %u)\n\n", mod_mask); break;
+        case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; usb_log_debug2("\n\nPushing SCROLL LOCK! (mask: %u)\n\n", mod_mask); break;
         default: mod_mask = 0; break;
         }
 
         if (mod_mask != 0) {
+                usb_log_debug2("\n\nChanging mods and lock keys\n");
+                usb_log_debug2("\nmods before: 0x%x\n", kbd_dev->mods);
+                usb_log_debug2("\nLock keys before:0x%x\n\n", kbd_dev->lock_keys);
+                
                 if (type == KEY_PRESS) {
+                        usb_log_debug2("\nKey pressed.\n");
                         /*
                          * Only change lock state on transition from released
@@ -196 +316 @@
                          * up the lock state.
                          */
-                        mods = mods ^ (mod_mask & ~lock_keys);
-                        lock_keys = lock_keys | mod_mask;
+                        kbd_dev->mods = 
+                            kbd_dev->mods ^ (mod_mask & ~kbd_dev->lock_keys);
+                        kbd_dev->lock_keys = kbd_dev->lock_keys | mod_mask;
 
                         /* Update keyboard lock indicator lights. */
-                        // TODO
-                        //kbd_ctl_set_ind(mods);
+                        usbkbd_set_led(kbd_dev);
                 } else {
-                        lock_keys = lock_keys & ~mod_mask;
-                }
-        }
-/*
-        printf("type: %d\n", type);
-        printf("mods: 0x%x\n", mods);
-        printf("keycode: %u\n", key);
-*/
-        
-        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
-                key == KC_F1) {
+                        usb_log_debug2("\nKey released.\n");
+                        kbd_dev->lock_keys = kbd_dev->lock_keys & ~mod_mask;
+                }
+        }
+
+        usb_log_debug2("\n\nmods after: 0x%x\n", kbd_dev->mods);
+        usb_log_debug2("\nLock keys after: 0x%x\n\n", kbd_dev->lock_keys);
+        
+        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F1) {
                 active_layout = 0;
                 layout[active_layout]->reset();
@@ -219 +337 @@
         }
 
-        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
-                key == KC_F2) {
+        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F2) {
                 active_layout = 1;
                 layout[active_layout]->reset();
@@ -226 +343 @@
         }
 
-        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
-                key == KC_F3) {
+        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F3) {
                 active_layout = 2;
                 layout[active_layout]->reset();
@@ -235 +351 @@
         ev.type = type;
         ev.key = key;
-        ev.mods = mods;
+        ev.mods = kbd_dev->mods;
+        
+        if (ev.mods & KM_NUM_LOCK) {
+                usb_log_debug("\n\nNum Lock turned on.\n\n");
+        }
 
         ev.c = layout[active_layout]->parse_ev(&ev);
 
-        printf("Sending key %d to the console\n", ev.key);
+        usb_log_debug2("Sending key %d to the console\n", ev.key);
         assert(console_callback_phone != -1);
-        async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
+        async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, 
+            ev.mods, ev.c);
 }
 /*
@@ -249 +370 @@
         /*
          * TODO:
-         * 1) key press / key release - how does the keyboard notify about release?
+         * 1) key press / key release - how does the keyboard notify about 
+         *    release?
          * 2) layouts (use the already defined), not important now
          * 3) 
          */
 
+static const keycode_t usb_hid_modifiers_keycodes[USB_HID_MOD_COUNT] = {
+        KC_LCTRL,         /* USB_HID_MOD_LCTRL */
+        KC_LSHIFT,        /* USB_HID_MOD_LSHIFT */
+        KC_LALT,          /* USB_HID_MOD_LALT */
+        0,                /* USB_HID_MOD_LGUI */
+        KC_RCTRL,         /* USB_HID_MOD_RCTRL */
+        KC_RSHIFT,        /* USB_HID_MOD_RSHIFT */
+        KC_RALT,          /* USB_HID_MOD_RALT */
+        0,                /* USB_HID_MOD_RGUI */
+};
+
+static void usbkbd_check_modifier_changes(usb_hid_dev_kbd_t *kbd_dev,
+    uint8_t modifiers)
+{
+        /*
+         * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK
+         *       both as modifiers and as keys with their own scancodes???
+         *
+         * modifiers should be sent as normal keys to usbkbd_parse_scancode()!!
+         * so maybe it would be better if I received it from report parser in 
+         * that way
+         */
+        
+        int i;
+        for (i = 0; i < USB_HID_MOD_COUNT; ++i) {
+                if ((modifiers & usb_hid_modifiers_consts[i]) &&
+                    !(kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
+                        // modifier pressed
+                        if (usb_hid_modifiers_keycodes[i] != 0) {
+                                kbd_push_ev(KEY_PRESS, 
+                                    usb_hid_modifiers_keycodes[i], kbd_dev);
+                        }
+                } else if (!(modifiers & usb_hid_modifiers_consts[i]) &&
+                    (kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
+                        // modifier released
+                        if (usb_hid_modifiers_keycodes[i] != 0) {
+                                kbd_push_ev(KEY_RELEASE, 
+                                    usb_hid_modifiers_keycodes[i], kbd_dev);
+                        }
+                }       // no change
+        }
+        
+        kbd_dev->modifiers = modifiers;
+}
+
+static void usbkbd_check_key_changes(usb_hid_dev_kbd_t *kbd_dev, 
+    const uint8_t *key_codes)
+{
+        // TODO: phantom state!!
+        
+        unsigned int key;
+        unsigned int i, j;
+        
+        // TODO: quite dummy right now, think of better implementation
+        
+        // key releases
+        for (j = 0; j < kbd_dev->keycode_count; ++j) {
+                // try to find the old key in the new key list
+                i = 0;
+                while (i < kbd_dev->keycode_count
+                    && key_codes[i] != kbd_dev->keycodes[j]) {
+                        ++i;
+                }
+                
+                if (i == kbd_dev->keycode_count) {
+                        // not found, i.e. the key was released
+                        key = usbkbd_parse_scancode(kbd_dev->keycodes[j]);
+                        kbd_push_ev(KEY_RELEASE, key, kbd_dev);
+                        usb_log_debug2("\nKey released: %d\n", key);
+                } else {
+                        // found, nothing happens
+                }
+        }
+        
+        // key presses
+        for (i = 0; i < kbd_dev->keycode_count; ++i) {
+                // try to find the new key in the old key list
+                j = 0;
+                while (j < kbd_dev->keycode_count 
+                    && kbd_dev->keycodes[j] != key_codes[i]) { 
+                        ++j;
+                }
+                
+                if (j == kbd_dev->keycode_count) {
+                        // not found, i.e. new key pressed
+                        key = usbkbd_parse_scancode(key_codes[i]);
+                        usb_log_debug2("\nKey pressed: %d (keycode: %d)\n", key,
+                            key_codes[i]);
+                        kbd_push_ev(KEY_PRESS, key, kbd_dev);
+                } else {
+                        // found, nothing happens
+                }
+        }
+        
+        memcpy(kbd_dev->keycodes, key_codes, kbd_dev->keycode_count);
+        
+        usb_log_debug2("\nNew stored keycodes: ");
+        for (i = 0; i < kbd_dev->keycode_count; ++i) {
+                usb_log_debug2("%d ", kbd_dev->keycodes[i]);
+        }
+}
+
 /*
  * Callbacks for parser
@@ -260 +484 @@
     uint8_t modifiers, void *arg)
 {
-        printf("Got keys: ");
+        if (arg == NULL) {
+                usb_log_warning("Missing argument in callback "
+                    "usbkbd_process_keycodes().\n");
+                return;
+        }
+
+        usb_log_debug2("Got keys from parser: ");
         unsigned i;
         for (i = 0; i < count; ++i) {
-                printf("%d ", key_codes[i]);
-        }
-        printf("\n");
-
-        for (i = 0; i < count; ++i) {
-                // TODO: Key press / release
-
-                // TODO: NOT WORKING
-                unsigned int key = usbkbd_parse_scancode(key_codes[i]);
-
-                if (key == 0) {
-                        continue;
-                }
-                kbd_push_ev(KEY_PRESS, key);
-        }
-        printf("\n");
+                usb_log_debug2("%d ", key_codes[i]);
+        }
+        usb_log_debug2("\n");
+        
+        usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg;
+        
+        if (count != kbd_dev->keycode_count) {
+                usb_log_warning("Number of received keycodes (%d) differs from"
+                    " expected number (%d).\n", count, kbd_dev->keycode_count);
+                return;
+        }
+        
+        usbkbd_check_modifier_changes(kbd_dev, modifiers);
+        usbkbd_check_key_changes(kbd_dev, key_codes);
 }
 
@@ -284 +512 @@
  * Kbd functions
  */
-static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev)
-{
-        // iterate over all configurations and interfaces
-        // TODO: more configurations!!
-        unsigned i;
-        for (i = 0; i < kbd_dev->conf->config_descriptor.interface_count; ++i) {
-                // TODO: endianness
-                uint16_t length = 
-                    kbd_dev->conf->interfaces[i].hid_desc.report_desc_info.length;
-                size_t actual_size = 0;
-
-                // allocate space for the report descriptor
-                kbd_dev->conf->interfaces[i].report_desc = (uint8_t *)malloc(length);
+//static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev)
+//{
+//      // iterate over all configurations and interfaces
+//      // TODO: more configurations!!
+//      unsigned i;
+//      for (i = 0; i < kbd_dev->conf->config_descriptor.interface_count; ++i) {
+//              // TODO: endianness
+//              uint16_t length =  kbd_dev->conf->interfaces[i].hid_desc.
+//                  report_desc_info.length;
+//              size_t actual_size = 0;
+
+//              // allocate space for the report descriptor
+//              kbd_dev->conf->interfaces[i].report_desc = 
+//                  (uint8_t *)malloc(length);
                 
-                // get the descriptor from the device
-                int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
-                    USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
-                    i, 0,
-                    kbd_dev->conf->interfaces[i].report_desc, length,
-                    &actual_size);
-
-                if (rc != EOK) {
-                        return rc;
-                }
-
-                assert(actual_size == length);
-
-                //dump_hid_class_descriptor(0, USB_DESCTYPE_HID_REPORT, 
-                //    kbd_dev->conf->interfaces[i].report_desc, length);
-        }
-
+//              // get the descriptor from the device
+//              int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
+//                  USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
+//                  i, 0,
+//                  kbd_dev->conf->interfaces[i].report_desc, length,
+//                  &actual_size);
+
+//              if (rc != EOK) {
+//                      return rc;
+//              }
+
+//              assert(actual_size == length);
+
+//              //dump_hid_class_descriptor(0, USB_DESCTYPE_HID_REPORT, 
+//              //    kbd_dev->conf->interfaces[i].report_desc, length);
+//      }
+
+//      return EOK;
+//}
+
+static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev, 
+    uint8_t *config_desc, size_t config_desc_size, uint8_t *iface_desc)
+{
+        assert(kbd_dev != NULL);
+        assert(config_desc != NULL);
+        assert(config_desc_size != 0);
+        assert(iface_desc != NULL);
+        
+        usb_dp_parser_t parser =  {
+                .nesting = usb_dp_standard_descriptor_nesting
+        };
+        
+        usb_dp_parser_data_t parser_data = {
+                .data = config_desc,
+                .size = config_desc_size,
+                .arg = NULL
+        };
+        
+        /*
+         * First nested descriptor of interface descriptor.
+         */
+        uint8_t *d = 
+            usb_dp_get_nested_descriptor(&parser, &parser_data, iface_desc);
+        
+        /*
+         * Search through siblings until the HID descriptor is found.
+         */
+        while (d != NULL && *(d + 1) != USB_DESCTYPE_HID) {
+                d = usb_dp_get_sibling_descriptor(&parser, &parser_data, 
+                    iface_desc, d);
+        }
+        
+        if (d == NULL) {
+                usb_log_fatal("No HID descriptor found!\n");
+                return ENOENT;
+        }
+        
+        if (*d != sizeof(usb_standard_hid_descriptor_t)) {
+                usb_log_fatal("HID descriptor hass wrong size (%u, expected %u"
+                    ")\n", *d, sizeof(usb_standard_hid_descriptor_t));
+                return EINVAL;
+        }
+        
+        usb_standard_hid_descriptor_t *hid_desc = 
+            (usb_standard_hid_descriptor_t *)d;
+        
+        uint16_t length =  hid_desc->report_desc_info.length;
+        size_t actual_size = 0;
+
+        /*
+         * Allocate space for the report descriptor.
+         */
+        kbd_dev->report_desc = (uint8_t *)malloc(length);
+        if (kbd_dev->report_desc == NULL) {
+                usb_log_fatal("Failed to allocate space for Report descriptor."
+                    "\n");
+                return ENOMEM;
+        }
+        
+        usb_log_debug("Getting Report descriptor, expected size: %u\n", length);
+        
+        /*
+         * Get the descriptor from the device.
+         */
+        int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
+            USB_DESCTYPE_HID_REPORT, 0,
+            kbd_dev->iface, kbd_dev->report_desc, length, &actual_size);
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        if (actual_size != length) {
+                free(kbd_dev->report_desc);
+                kbd_dev->report_desc = NULL;
+                usb_log_fatal("Report descriptor has wrong size (%u, expected "
+                    "%u)\n", actual_size, length);
+                return EINVAL;
+        }
+        
+        usb_log_debug("Done.\n");
+        
         return EOK;
 }
+
 static int usbkbd_process_descriptors(usb_hid_dev_kbd_t *kbd_dev)
 {
@@ -364 +680 @@
             descriptors, config_desc.total_length,
             &kbd_dev->wire);
+        
         if (rc != EOK) {
                 usb_log_error("Failed to initialize poll pipe: %s.\n",
                     str_error(rc));
+                free(descriptors);
                 return rc;
         }
+        
         if (!endpoint_mapping[0].present) {
                 usb_log_warning("Not accepting device, " \
                     "not boot-protocol keyboard.\n");
+                free(descriptors);
                 return EREFUSED;
         }
-
-
-
-
-        kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 
-            sizeof(usb_hid_configuration_t));
-        if (kbd_dev->conf == NULL) {
+        
+        usb_log_debug("Accepted device. Saving interface, and getting Report"
+            " descriptor.\n");
+        
+        /*
+         * Save assigned interface number.
+         */
+        if (endpoint_mapping[0].interface_no < 0) {
+                usb_log_error("Bad interface number.\n");
                 free(descriptors);
-                return ENOMEM;
-        }
-        
-        /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
+                return EINVAL;
+        }
+        
+        kbd_dev->iface = endpoint_mapping[0].interface_no;
+        
+        assert(endpoint_mapping[0].interface != NULL);
+        
+        rc = usbkbd_get_report_descriptor(kbd_dev, descriptors, transferred,
+            (uint8_t *)endpoint_mapping[0].interface);
+        
         free(descriptors);
-        if (rc != EOK) {
-                printf("Problem with parsing standard descriptors.\n");
+        
+        if (rc != EOK) {
+                usb_log_warning("Problem with parsing REPORT descriptor.\n");
                 return rc;
         }
-
-        // get and report descriptors*/
-        rc = usbkbd_get_report_descriptor(kbd_dev);
-        if (rc != EOK) {
-                printf("Problem with parsing HID REPORT descriptor.\n");
-                return rc;
-        }
-        
-        //usbkbd_print_config(kbd_dev->conf);
-
-        /*
-         * TODO: 
-         * 1) select one configuration (lets say the first)
-         * 2) how many interfaces?? how to select one??
-     *    ("The default setting for an interface is always alternate setting zero.")
-         * 3) find endpoint which is IN and INTERRUPT (parse), save its number
-     *    as the endpoint for polling
-         */
-
+        
+        usb_log_debug("Done parsing descriptors.\n");
+        
         return EOK;
 }
@@ -421 +734 @@
 
         if (kbd_dev == NULL) {
-                fprintf(stderr, NAME ": No memory!\n");
+                usb_log_fatal("No memory!\n");
                 return NULL;
         }
@@ -449 +762 @@
 
         /*
-         * will need all descriptors:
-         * 1) choose one configuration from configuration descriptors
-         *    (set it to the device)
-         * 2) set endpoints from endpoint descriptors
-         */
-
-        // TODO: get descriptors, parse descriptors and save endpoints
+         * Get descriptors, parse descriptors and save endpoints.
+         */
         usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
-        //usb_request_set_configuration(&kbd_dev->ctrl_pipe, 1);
+        
         rc = usbkbd_process_descriptors(kbd_dev);
+        
         usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
         if (rc != EOK) {
                 goto error_leave;
         }
-
+        
+        // save the size of the report (boot protocol report by default)
+        kbd_dev->keycode_count = BOOTP_REPORT_SIZE;
+        kbd_dev->keycodes = (uint8_t *)calloc(
+            kbd_dev->keycode_count, sizeof(uint8_t));
+        
+        if (kbd_dev->keycodes == NULL) {
+                usb_log_fatal("No memory!\n");
+                goto error_leave;
+        }
+        
+        kbd_dev->modifiers = 0;
+        kbd_dev->mods = DEFAULT_ACTIVE_MODS;
+        kbd_dev->lock_keys = 0;
+        
+        // set boot protocol
+        usbkbd_req_set_protocol(kbd_dev, USB_HID_PROTOCOL_BOOT);
+        
+        // set LEDs according to internal setup (NUM LOCK enabled)
+        usbkbd_set_led(kbd_dev);
+        
         return kbd_dev;
 
@@ -476 +805 @@
         usb_hid_report_in_callbacks_t *callbacks =
             (usb_hid_report_in_callbacks_t *)malloc(
-                sizeof(usb_hid_report_in_callbacks_t));
+                sizeof(usb_hid_report_in_callbacks_t));
         callbacks->keyboard = usbkbd_process_keycodes;
 
         //usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks, 
         //    NULL);
-        printf("Calling usb_hid_boot_keyboard_input_report() with size %zu\n",
-            actual_size);
+        /*usb_log_debug2("Calling usb_hid_boot_keyboard_input_report() with size"
+            " %zu\n", actual_size);*/
         //dump_buffer("bufffer: ", buffer, actual_size);
-        int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks, 
-            NULL);
-        if (rc != EOK) {
-                printf("Error in usb_hid_boot_keyboard_input_report(): %d\n", rc);
+        int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size,
+            callbacks, kbd_dev);
+        
+        if (rc != EOK) {
+                usb_log_warning("Error in usb_hid_boot_keyboard_input_report():"
+                    "%s\n", str_error(rc));
         }
 }
@@ -497 +828 @@
         size_t actual_size;
 
-        printf("Polling keyboard...\n");
+        usb_log_info("Polling keyboard...\n");
 
         while (true) {
@@ -504 +835 @@
                 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
                 if (sess_rc != EOK) {
-                        printf("Failed to start a session: %s.\n",
+                        usb_log_warning("Failed to start a session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -514 +845 @@
 
                 if (rc != EOK) {
-                        printf("Error polling the keyboard: %s.\n",
+                        usb_log_warning("Error polling the keyboard: %s.\n",
                             str_error(rc));
                         continue;
@@ -520 +851 @@
 
                 if (sess_rc != EOK) {
-                        printf("Error closing session: %s.\n",
+                        usb_log_warning("Error closing session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -530 +861 @@
                  */
                 if (actual_size == 0) {
-                        printf("Keyboard returned NAK\n");
+                        usb_log_debug("Keyboard returned NAK\n");
                         continue;
                 }
@@ -537 +868 @@
                  * TODO: Process pressed keys.
                  */
-                printf("Calling usbkbd_process_interrupt_in()\n");
+                usb_log_debug("Calling usbkbd_process_interrupt_in()\n");
                 usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size);
         }
@@ -547 +878 @@
 static int usbkbd_fibril_device(void *arg)
 {
-        printf("!!! USB device fibril\n");
-
         if (arg == NULL) {
-                printf("No device!\n");
+                usb_log_error("No device!\n");
                 return -1;
         }
-
-        ddf_dev_t *dev = (ddf_dev_t *)arg;
-
-        // initialize device (get and process descriptors, get address, etc.)
-        usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
-        if (kbd_dev == NULL) {
-                printf("Error while initializing device.\n");
-                return -1;
-        }
+        
+        usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg;
 
         usbkbd_poll_keyboard(kbd_dev);
@@ -570 +892 @@
 static int usbkbd_add_device(ddf_dev_t *dev)
 {
-        /* For now, fail immediately. */
-        //return ENOTSUP;
-
-        /*
-         * When everything is okay, connect to "our" HC.
-         *
-         * Not supported yet, skip..
-         */
-//      int phone = usb_drv_hc_connect_auto(dev, 0);
-//      if (phone < 0) {
-//              /*
-//               * Connecting to HC failed, roll-back and announce
-//               * failure.
-//               */
-//              return phone;
-//      }
-
-//      dev->parent_phone = phone;
-
         /*
          * Create default function.
@@ -601 +904 @@
         rc = ddf_fun_add_to_class(kbd_fun, "keyboard");
         assert(rc == EOK);
-
+        
+        /* 
+         * Initialize device (get and process descriptors, get address, etc.)
+         */
+        usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
+        if (kbd_dev == NULL) {
+                usb_log_error("Error while initializing device.\n");
+                return -1;
+        }
+
+        usb_log_info("Device initialized.\n");
+        
         /*
          * Create new fibril for handling this keyboard
          */
-        fid_t fid = fibril_create(usbkbd_fibril_device, dev);
+        fid_t fid = fibril_create(usbkbd_fibril_device, kbd_dev);
         if (fid == 0) {
-                printf("%s: failed to start fibril for HID device\n", NAME);
+                usb_log_error("Failed to start fibril for HID device\n");
                 return ENOMEM;
         }
@@ -634 +948 @@
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid");
+        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
         return ddf_driver_main(&kbd_driver);
 }

uspace/drv/usbhub/main.c

@@ -34 +34 @@
 #include <errno.h>
 #include <async.h>
+#include <stdio.h>
 
 #include "usbhub.h"
@@ -51 +52 @@
 };
 
-int usb_hub_control_loop(void * noparam){
-        while(true){
-                usb_hub_check_hub_changes();
-                async_usleep(1000 * 1000 );/// \TODO proper number once
-        }
-        return 0;
-}
-
-
 int main(int argc, char *argv[])
 {
         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
-        
+        dprintf(USB_LOG_LEVEL_INFO, "starting hub driver");
+
+        //this is probably not needed anymore
         fibril_mutex_initialize(&usb_hub_list_lock);
         fibril_mutex_lock(&usb_hub_list_lock);
         usb_lst_init(&usb_hub_list);
         fibril_mutex_unlock(&usb_hub_list_lock);
-
-        fid_t fid = fibril_create(usb_hub_control_loop, NULL);
-        if (fid == 0) {
-                fprintf(stderr, NAME ": failed to start monitoring fibril," \
-                    " driver aborting.\n");
-                return ENOMEM;
-        }
-        fibril_add_ready(fid);
-
+        
         return ddf_driver_main(&hub_driver);
 }

uspace/drv/usbhub/port_status.h

@@ -177 +177 @@
 }
 
+/**
+ * set the device request to be a port disable request
+ * @param request
+ * @param port
+ */
+static inline void usb_hub_unset_power_port_request(
+usb_device_request_setup_packet_t * request, uint16_t port
+){
+        request->index = port;
+        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
+        request->request = USB_HUB_REQUEST_CLEAR_FEATURE;
+        request->value = USB_HUB_FEATURE_PORT_POWER;
+        request->length = 0;
+}
+
 /** get i`th bit of port status */
 static inline bool usb_port_get_bit(usb_port_status_t * status, int idx)

uspace/drv/usbhub/usbhub.c

@@ -44 +44 @@
 #include <usb/request.h>
 #include <usb/classes/hub.h>
+#include <stdio.h>
 
 #include "usbhub.h"
@@ -56 +57 @@
 };
 
-/** Hub status-change endpoint description */
+/** Hub status-change endpoint description
+ *
+ * For more see usb hub specification in 11.15.1 of
+ */
 static usb_endpoint_description_t status_change_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
         .direction = USB_DIRECTION_IN,
         .interface_class = USB_CLASS_HUB,
+        .interface_subclass = 0,
+        .interface_protocol = 0,
         .flags = 0
 };
+
+int usb_hub_control_loop(void * hub_info_param){
+        usb_hub_info_t * hub_info = (usb_hub_info_t*)hub_info_param;
+        while(true){
+                usb_hub_check_hub_changes(hub_info);
+                async_usleep(1000 * 1000 );/// \TODO proper number once
+        }
+        return 0;
+}
 
 
@@ -135 +150 @@
 
         //configuration descriptor
-        /// \TODO check other configurations
+        /// \TODO check other configurations?
         usb_standard_configuration_descriptor_t config_descriptor;
         opResult = usb_request_get_bare_configuration_descriptor(
@@ -179 +194 @@
         }
 
-        /**
-         * Initialize the interrupt in endpoint.
-         * \TODO this code should be checked...
-         */
         usb_endpoint_mapping_t endpoint_mapping[1] = {
                 {
@@ -210 +221 @@
         return EOK;
         
-
-        // Initialize the interrupt(=status change) endpoint.
-        /*usb_endpoint_pipe_initialize(
-                &result->endpoints->status_change,
-                &result->device_connection, );USB_TRANSFER_INTERRUPT
-        USB_DIRECTION_IN*/
-
 }
 
@@ -249 +253 @@
         usb_endpoint_pipe_start_session(&result->endpoints.control);
         opResult = usb_request_get_descriptor(&result->endpoints.control,
-                        USB_REQUEST_TYPE_CLASS,
-                        USB_DESCTYPE_HUB, 0, 0, serialized_descriptor,
+                        USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
+                        USB_DESCTYPE_HUB,
+                        0, 0, serialized_descriptor,
                         USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
         usb_endpoint_pipe_end_session(&result->endpoints.control);
@@ -267 +272 @@
         }
 
-        
         dprintf(USB_LOG_LEVEL_INFO, "setting port count to %d",descriptor->ports_count);
         result->port_count = descriptor->ports_count;
@@ -329 +333 @@
 
         //add the hub to list
+        //is this needed now?
         fibril_mutex_lock(&usb_hub_list_lock);
         usb_lst_append(&usb_hub_list, hub_info);
         fibril_mutex_unlock(&usb_hub_list_lock);
-
         dprintf(USB_LOG_LEVEL_DEBUG, "hub info added to list");
+
+        dprintf(USB_LOG_LEVEL_DEBUG, "adding to ddf");
+        ddf_fun_t *hub_fun = ddf_fun_create(dev, fun_exposed, "hub");
+        assert(hub_fun != NULL);
+        hub_fun->ops = NULL;
+
+        int rc = ddf_fun_bind(hub_fun);
+        assert(rc == EOK);
+        rc = ddf_fun_add_to_class(hub_fun, "hub");
+        assert(rc == EOK);
+
+        fid_t fid = fibril_create(usb_hub_control_loop, hub_info);
+        if (fid == 0) {
+                dprintf(USB_LOG_LEVEL_ERROR, 
+                                ": failed to start monitoring fibril for new hub");
+                return ENOMEM;
+        }
+        fibril_add_ready(fid);
+
+        dprintf(USB_LOG_LEVEL_DEBUG, "hub fibril created");
         //(void)hub_info;
-        usb_hub_check_hub_changes();
+        //usb_hub_check_hub_changes();
         
         dprintf(USB_LOG_LEVEL_INFO, "hub dev added");
@@ -368 +392 @@
         //opResult = usb_drv_reserve_default_address(hc);
         opResult = usb_hc_reserve_default_address(&hub->connection, USB_SPEED_LOW);
-
-        if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_WARNING, "cannot assign default address, it is probably used");
+        
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_WARNING, 
+                                "cannot assign default address, it is probably used %d",opResult);
                 return;
         }
@@ -381 +406 @@
                         );
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, "something went wrong when reseting a port");
+                dprintf(USB_LOG_LEVEL_ERROR, 
+                                "something went wrong when reseting a port %d",opResult);
                 //usb_hub_release_default_address(hc);
                 usb_hc_release_default_address(&hub->connection);
@@ -394 +420 @@
  */
 static void usb_hub_finalize_add_device( usb_hub_info_t * hub,
-                uint16_t port) {
+                uint16_t port, bool isLowSpeed) {
 
         int opResult;
@@ -417 +443 @@
                         &new_device_connection);
         /// \TODO get highspeed info
-
-
-
+        usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
 
 
@@ -425 +449 @@
         usb_address_t new_device_address = usb_hc_request_address(
                         &hub->connection,
-                        USB_SPEED_LOW/// \TODO fullspeed??
+                        speed/// \TODO fullspeed??
                         );
         if (new_device_address < 0) {
@@ -436 +460 @@
         //opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
         //    new_device_address);
+        usb_endpoint_pipe_start_session(&new_device_pipe);
         opResult = usb_request_set_address(&new_device_pipe,new_device_address);
-
-        if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, "could not set address for new device");
+        usb_endpoint_pipe_end_session(&new_device_pipe);
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_ERROR, 
+                                "could not set address for new device %d",opResult);
                 usb_hc_release_default_address(&hub->connection);
                 return;
@@ -458 +484 @@
 
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, "could not start driver for new device");
+                dprintf(USB_LOG_LEVEL_ERROR, 
+                                "could not start driver for new device %d",opResult);
                 return;
         }
@@ -469 +496 @@
                         &hub->attached_devs[port]);
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, "could not assign address of device in hcd");
+                dprintf(USB_LOG_LEVEL_ERROR, 
+                                "could not assign address of device in hcd %d",opResult);
                 return;
         }
@@ -511 +539 @@
 }
 
+
+/**
+ *Process over current condition on port.
+ * 
+ * Turn off the power on the port.
+ *
+ * @param hub
+ * @param port
+ */
+static void usb_hub_over_current( usb_hub_info_t * hub,
+                uint16_t port){
+        int opResult;
+        opResult = usb_hub_clear_port_feature(&hub->endpoints.control,
+            port, USB_HUB_FEATURE_PORT_POWER);
+        if(opResult!=EOK){
+                dprintf(USB_LOG_LEVEL_ERROR, "cannot power off port %d;  %d",
+                                port, opResult);
+        }
+}
+
 /**
  * Process interrupts on given hub port
@@ -522 +570 @@
         //determine type of change
         usb_endpoint_pipe_t *pipe = &hub->endpoints.control;
-        int opResult = usb_endpoint_pipe_start_session(pipe);
         
-        if(opResult != EOK){
-                dprintf(USB_LOG_LEVEL_ERROR, "cannot open pipe %d", opResult);
-        }
-
-        /*
-        usb_target_t target;
-        target.address=address;
-        target.endpoint=0;
-        */
+        int opResult;
 
         usb_port_status_t status;
@@ -547 +586 @@
                         );
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, "ERROR: could not get port status");
+                dprintf(USB_LOG_LEVEL_ERROR, "could not get port status");
                 return;
         }
         if (rcvd_size != sizeof (usb_port_status_t)) {
-                dprintf(USB_LOG_LEVEL_ERROR, "ERROR: received status has incorrect size");
+                dprintf(USB_LOG_LEVEL_ERROR, "received status has incorrect size");
                 return;
         }
@@ -566 +605 @@
                 }
         }
+        //over current
+        if (usb_port_overcurrent_change(&status)) {
+                //check if it was not auto-resolved
+                if(usb_port_over_current(&status)){
+                        usb_hub_over_current(hub,port);
+                }else{
+                        dprintf(USB_LOG_LEVEL_INFO,
+                                "over current condition was auto-resolved on port %d",port);
+                }
+        }
         //port reset
         if (usb_port_reset_completed(&status)) {
                 dprintf(USB_LOG_LEVEL_INFO, "port reset complete");
                 if (usb_port_enabled(&status)) {
-                        usb_hub_finalize_add_device(hub, port);
+                        usb_hub_finalize_add_device(hub, port, usb_port_low_speed(&status));
                 } else {
-                        dprintf(USB_LOG_LEVEL_WARNING, "ERROR: port reset, but port still not enabled");
+                        dprintf(USB_LOG_LEVEL_WARNING, "port reset, but port still not enabled");
                 }
         }
@@ -585 +634 @@
         }
         /// \TODO handle other changes
-        /// \TODO debug log for various situations
-        usb_endpoint_pipe_end_session(pipe);
-
-
-}
-
-/**
- * Check changes on all known hubs.
- */
-void usb_hub_check_hub_changes(void) {
+}
+
+/**
+ * Check changes on particular hub
+ * @param hub_info_param
+ */
+void usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
+        int opResult;
+        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
+        if(opResult != EOK){
+                dprintf(USB_LOG_LEVEL_ERROR,
+                                "could not initialize communication for hub; %d", opResult);
+                return;
+        }
+
+        size_t port_count = hub_info->port_count;
+
+        /// FIXME: count properly
+        size_t byte_length = ((port_count+1) / 8) + 1;
+                void *change_bitmap = malloc(byte_length);
+        size_t actual_size;
+
         /*
-         * Iterate through all hubs.
+         * Send the request.
          */
-        usb_general_list_t * lst_item;
-        fibril_mutex_lock(&usb_hub_list_lock);
-        for (lst_item = usb_hub_list.next;
-                        lst_item != &usb_hub_list;
-                        lst_item = lst_item->next) {
-                fibril_mutex_unlock(&usb_hub_list_lock);
-                usb_hub_info_t * hub_info = ((usb_hub_info_t*)lst_item->data);
-                int opResult;
-
-                opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
-                if(opResult != EOK){
-                        continue;
+        opResult = usb_endpoint_pipe_read(
+                        &hub_info->endpoints.status_change,
+                        change_bitmap, byte_length, &actual_size
+                        );
+
+        if (opResult != EOK) {
+                free(change_bitmap);
+                dprintf(USB_LOG_LEVEL_WARNING, "something went wrong while getting status of hub");
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
+                return;
+        }
+        unsigned int port;
+        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.control);
+        if(opResult!=EOK){
+                dprintf(USB_LOG_LEVEL_ERROR, "could not start control pipe session %d",
+                                opResult);
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
+                return;
+        }
+        opResult = usb_hc_connection_open(&hub_info->connection);
+        if(opResult!=EOK){
+                dprintf(USB_LOG_LEVEL_ERROR, "could not start host controller session %d",
+                                opResult);
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
+                return;
+        }
+
+        ///todo, opresult check, pre obe konekce
+        for (port = 1; port < port_count+1; ++port) {
+                bool interrupt =
+                                (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2;
+                if (interrupt) {
+                        usb_hub_process_interrupt(
+                                hub_info, port);
                 }
-                /*
-                 * Check status change pipe of this hub.
-                 */
-                /*
-                usb_target_t target;
-                target.address = hub_info->address;
-                target.endpoint = 1;/// \TODO get from endpoint descriptor
-                dprintf(USB_LOG_LEVEL_INFO, "checking changes for hub at addr %d",
-                    target.address);
-                */
-                size_t port_count = hub_info->port_count;
-
-                /*
-                 * Connect to respective HC.
-                 *
-                int hc = usb_drv_hc_connect_auto(hub_info->device, 0);
-                if (hc < 0) {
-                        continue;
-                }*/
-
-                /// FIXME: count properly
-                size_t byte_length = ((port_count+1) / 8) + 1;
-
-                void *change_bitmap = malloc(byte_length);
-                size_t actual_size;
-                //usb_handle_t handle;
-
-                /*
-                 * Send the request.
-                 */
-                opResult = usb_endpoint_pipe_read(
-                                &hub_info->endpoints.status_change,
-                                change_bitmap, byte_length, &actual_size
-                                );
-
-                //usb_drv_async_wait_for(handle);
-
-                if (opResult != EOK) {
-                        free(change_bitmap);
-                        dprintf(USB_LOG_LEVEL_WARNING, "something went wrong while getting status of hub");
-                        continue;
-                }
-                unsigned int port;
-                for (port = 1; port < port_count+1; ++port) {
-                        bool interrupt =
-                                        (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2;
-                        if (interrupt) {
-                                usb_hub_process_interrupt(
-                                        hub_info, port);
-                        }
-                }
-                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
-                free(change_bitmap);
-                
-
-                //async_hangup(hc);
-                fibril_mutex_lock(&usb_hub_list_lock);
-        }
-        fibril_mutex_unlock(&usb_hub_list_lock);
-}
-
-
+        }
+        usb_hc_connection_close(&hub_info->connection);
+        usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
+        usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
+        free(change_bitmap);
+}
 
 

uspace/drv/usbhub/usbhub.h

@@ -75 +75 @@
 /**
  * function running the hub-controlling loop.
- * @param noparam fundtion does not need any parameters
+ * @param hub_info_param hub info pointer
  */
-int usb_hub_control_loop(void * noparam);
+int usb_hub_control_loop(void * hub_info_param);
 
 /** Callback when new hub device is detected.
@@ -87 +87 @@
 
 /**
- * check changes on all registered hubs
+ * check changes on specified hub
+ * @param hub_info_param pointer to usb_hub_info_t structure
  */
-void usb_hub_check_hub_changes(void);
+void usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);
 
 
-//int usb_add_hub_device(device_t *);
 
 

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

@@ -51 +51 @@
 } usb_hid_request_t;
 
+typedef enum {
+        USB_HID_REPORT_TYPE_INPUT = 1,
+        USB_HID_REPORT_TYPE_OUTPUT = 2,
+        USB_HID_REPORT_TYPE_FEATURE = 3
+} usb_hid_report_type_t;
+
+typedef enum {
+        USB_HID_PROTOCOL_BOOT = 0,
+        USB_HID_PROTOCOL_REPORT = 1
+} usb_hid_protocol_t;
+
 /** USB/HID subclass constants. */
 typedef enum {
@@ -62 +73 @@
         USB_HID_PROTOCOL_KEYBOARD = 1,
         USB_HID_PROTOCOL_MOUSE = 2
-} usb_hid_protocol_t;
+} usb_hid_iface_protocol_t;
 
 /** Part of standard USB HID descriptor specifying one class descriptor.

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

@@ -70 +70 @@
 } usb_hid_report_in_callbacks_t;
 
-#define USB_HID_BOOT_KEYBOARD_NUM_LOCK          0x01
-#define USB_HID_BOOT_KEYBOARD_CAPS_LOCK         0x02
-#define USB_HID_BOOT_KEYBOARD_SCROLL_LOCK       0x04
-#define USB_HID_BOOT_KEYBOARD_COMPOSE           0x08
-#define USB_HID_BOOT_KEYBOARD_KANA                      0x10
+
+typedef enum {
+        USB_HID_MOD_LCTRL = 0x01,
+        USB_HID_MOD_LSHIFT = 0x02,
+        USB_HID_MOD_LALT = 0x04,
+        USB_HID_MOD_LGUI = 0x08,
+        USB_HID_MOD_RCTRL = 0x10,
+        USB_HID_MOD_RSHIFT = 0x20,
+        USB_HID_MOD_RALT = 0x40,
+        USB_HID_MOD_RGUI = 0x80,
+        USB_HID_MOD_COUNT = 8
+} usb_hid_modifiers_t;
+
+typedef enum {
+        USB_HID_LED_NUM_LOCK = 0x1,
+        USB_HID_LED_CAPS_LOCK = 0x2,
+        USB_HID_LED_SCROLL_LOCK = 0x4,
+        USB_HID_LED_COMPOSE = 0x8,
+        USB_HID_LED_KANA = 0x10,
+        USB_HID_LED_COUNT = 5
+} usb_hid_led_t;
+
+static const usb_hid_modifiers_t 
+    usb_hid_modifiers_consts[USB_HID_MOD_COUNT] = {
+        USB_HID_MOD_LCTRL,
+        USB_HID_MOD_LSHIFT,
+        USB_HID_MOD_LALT,
+        USB_HID_MOD_LGUI,
+        USB_HID_MOD_RCTRL,
+        USB_HID_MOD_RSHIFT,
+        USB_HID_MOD_RALT,
+        USB_HID_MOD_RGUI
+};
+
+//static const usb_hid_led_t usb_hid_led_consts[USB_HID_LED_COUNT] = {
+//      USB_HID_LED_NUM_LOCK,
+//      USB_HID_LED_CAPS_LOCK,
+//      USB_HID_LED_SCROLL_LOCK,
+//      USB_HID_LED_COMPOSE,
+//      USB_HID_LED_KANA
+//};
+
+//#define USB_HID_BOOT_KEYBOARD_NUM_LOCK                0x01
+//#define USB_HID_BOOT_KEYBOARD_CAPS_LOCK               0x02
+//#define USB_HID_BOOT_KEYBOARD_SCROLL_LOCK     0x04
+//#define USB_HID_BOOT_KEYBOARD_COMPOSE         0x08
+//#define USB_HID_BOOT_KEYBOARD_KANA                    0x10
 
 /*

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

@@ -96 +96 @@
 int usb_request_set_address(usb_endpoint_pipe_t *, usb_address_t);
 int usb_request_get_descriptor(usb_endpoint_pipe_t *, usb_request_type_t,
-    uint8_t, uint8_t, uint16_t, void *, size_t, size_t *);
+    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t, 
+    size_t *);
 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t *, usb_request_type_t,
-    uint8_t, uint8_t, uint16_t, void **, size_t *);
+    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void **, size_t *);
 int usb_request_get_device_descriptor(usb_endpoint_pipe_t *,
     usb_standard_device_descriptor_t *);

uspace/lib/usb/src/hidparser.c

@@ -144 +144 @@
 int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size)
 {
-        if(size != 1){
+        if (size < 1){
                 return -1;
         }
 
-        /* used only first five bits, others are only padding*/
-        *data = leds;
+        data[0] = leds;
         return EOK;
 }

uspace/lib/usb/src/request.c

@@ -36 +36 @@
 #include <errno.h>
 #include <assert.h>
+#include <usb/debug.h>
 
 #define MAX_DATA_LENGTH ((size_t)(0xFFFF))
@@ -209 +210 @@
  */
 int usb_request_get_descriptor(usb_endpoint_pipe_t *pipe,
-    usb_request_type_t request_type,
+    usb_request_type_t request_type, usb_request_recipient_t recipient,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -224 +225 @@
 
         return usb_control_request_get(pipe,
-            request_type, USB_REQUEST_RECIPIENT_DEVICE,
+            request_type, recipient,
             USB_DEVREQ_GET_DESCRIPTOR,
             wValue, language,
@@ -242 +243 @@
  */
 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
-    usb_request_type_t request_type,
+    usb_request_type_t request_type, usb_request_recipient_t recipient,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -258 +259 @@
         uint8_t tmp_buffer[1];
         size_t bytes_transfered;
-        rc = usb_request_get_descriptor(pipe, request_type,
+        rc = usb_request_get_descriptor(pipe, request_type, recipient,
             descriptor_type, descriptor_index, language,
             &tmp_buffer, 1, &bytes_transfered);
@@ -283 +284 @@
         }
 
-        rc = usb_request_get_descriptor(pipe, request_type,
+        rc = usb_request_get_descriptor(pipe, request_type, recipient,
             descriptor_type, descriptor_index, language,
             buffer, size, &bytes_transfered);
@@ -320 +321 @@
         usb_standard_device_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_DEVICE,
-            0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, 
+            USB_DESCTYPE_DEVICE, 0, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -366 +367 @@
         usb_standard_configuration_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
-            index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_CONFIGURATION, index, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -406 +407 @@
 
         return usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
-            index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_CONFIGURATION, index, 0,
             descriptor, descriptor_size, actual_size);
 }
@@ -452 +453 @@
         size_t string_descriptor_size = 0;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING, 0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_STRING, 0, 0,
             (void **) &string_descriptor, &string_descriptor_size);
         if (rc != EOK) {
@@ -535 +537 @@
         size_t string_size;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING,
-            index, uint16_host2usb(lang),
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_STRING, index, uint16_host2usb(lang),
             (void **) &string, &string_size);
         if (rc != EOK) {