Changes in / [51b46f2:0e3505a] 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) (18 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 (deleted)
• drv/uhci-hcd/utils/device_keeper.h (deleted)
• 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 (added)
• drv/usbhid/descparser.h (added)
• 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:
@@ -345 +340 @@
         /* 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. */
@@ -664 +659 @@
 size_t pci_bar_mask_to_size(uint32_t mask)
 {
-        size_t size = mask & ~(mask - 1);
-        return size;
+        return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
 }
 

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>
@@ -54 +53 @@
 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
-    usb_speed_t speed, char *buffer, size_t size,
+    dev_speed_t speed, char *buffer, size_t size,
     char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
@@ -134 +133 @@
 
         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;
 }
@@ -142 +139 @@
 {
         assert(instance);
-        usb_log_debug2("Batch(%p) checking %d packet(s) for completion.\n",
+        usb_log_debug("Checking(%p) %d packet for completion.\n",
             instance, instance->packets);
         instance->transfered_size = 0;
@@ -154 +151 @@
                         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;
                 }
@@ -161 +156 @@
                     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;
@@ -172 +168 @@
         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, low_speed,
-            instance->target, USB_PID_SETUP, instance->setup_buffer,
-            &instance->tds[1]);
+            instance->setup_size, toggle, false, instance->target,
+            USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
 
         /* data stage */
@@ -188 +182 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle++, false, low_speed,
-                    instance->target, USB_PID_OUT, data, &instance->tds[i + 1]);
+                    instance->max_packet_size, toggle++, false, instance->target,
+                    USB_PID_OUT, data, &instance->tds[i + 1]);
         }
 
@@ -195 +189 @@
         i = instance->packets - 1;
         transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-            0, 1, false, low_speed, instance->target, USB_PID_IN, NULL, NULL);
+            0, 1, false, 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);
 }
@@ -210 +201 @@
         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, low_speed, instance->target,
+            instance->setup_size, toggle, false, instance->target,
             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
 
@@ -225 +215 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle, false, low_speed,
-                                instance->target, USB_PID_IN, data, &instance->tds[i + 1]);
+                    instance->max_packet_size, toggle, false, instance->target,
+                    USB_PID_IN, data, &instance->tds[i + 1]);
         }
 
@@ -232 +222 @@
         i = instance->packets - 1;
         transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-            0, 1, false, low_speed, instance->target, USB_PID_OUT, NULL, NULL);
+            0, 1, false, 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);
 }
@@ -247 +234 @@
         assert(instance);
 
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
         int toggle = 1;
         size_t i = 0;
@@ -258 +244 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle, false, low_speed,
-                    instance->target, USB_PID_IN, data, next);
+                    instance->max_packet_size, toggle, false, instance->target,
+                    USB_PID_IN, data, next);
         }
 
@@ -265 +251 @@
 
         instance->next_step = batch_call_in_and_dispose;
-        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
         batch_schedule(instance);
 }
@@ -275 +260 @@
         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;
@@ -286 +270 @@
 
                 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle++, false, low_speed,
-                    instance->target, USB_PID_OUT, data, next);
+                    instance->max_packet_size, toggle++, false, instance->target,
+                    USB_PID_OUT, data, next);
         }
 
@@ -293 +277 @@
 
         instance->next_step = batch_call_out_and_dispose;
-        usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
         batch_schedule(instance);
 }
@@ -305 +288 @@
 
         int err = instance->error;
-        usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
-            instance, instance->transfer_type, str_error(err), err,
-            instance->transfered_size);
+        usb_log_info("Callback IN(%d): %d, %zu.\n", instance->transfer_type,
+            err, instance->transfered_size);
 
         instance->callback_in(instance->fun,
@@ -320 +302 @@
 
         int err = instance->error;
-        usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
-            instance, instance->transfer_type, str_error(err), err);
+        usb_log_info("Callback OUT(%d): %d.\n", instance->transfer_type, err);
         instance->callback_out(instance->fun,
             err, instance->arg);
@@ -330 +311 @@
         assert(instance);
         batch_call_in(instance);
-        usb_log_debug("Batch(%p) disposing.\n", instance);
+        usb_log_debug("Disposing batch: %p.\n", instance);
         free32(instance->tds);
         free32(instance->qh);
@@ -342 +323 @@
         assert(instance);
         batch_call_out(instance);
-        usb_log_debug("Batch(%p) disposing.\n", instance);
+        usb_log_debug("Disposing batch: %p.\n", instance);
         free32(instance->tds);
         free32(instance->qh);
@@ -357 +338 @@
         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;
-        usb_speed_t speed;
+        dev_speed_t speed;
         usb_target_t target;
         usb_transfer_type_t transfer_type;
@@ -71 +76 @@
 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
-    usb_speed_t speed, char *buffer, size_t size,
+    dev_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"
 
 /*----------------------------------------------------------------------------*/
@@ -49 +48 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_log_debug("Default address request with speed %d.\n", speed);
-        device_keeper_reserve_default(&hc->device_manager, speed);
+        usb_address_keeping_reserve_default(&hc->address_manager);
         return EOK;
 }
@@ -59 +57 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_log_debug("Default address release.\n");
-        device_keeper_release_default(&hc->device_manager);
+        usb_address_keeping_release_default(&hc->address_manager);
         return EOK;
 }
@@ -70 +67 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        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);
+        *address = usb_address_keeping_request(&hc->address_manager);
         if (*address <= 0)
           return *address;
@@ -86 +79 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_log_debug("Address bind %d-%d.\n", address, handle);
-        device_keeper_bind(&hc->device_manager, address, handle);
+        usb_address_keeping_devman_bind(&hc->address_manager, address, handle);
         return EOK;
 }
@@ -96 +88 @@
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
-        usb_log_debug("Address release %d.\n", address);
-        device_keeper_release(&hc->device_manager, address);
+        usb_address_keeping_release_default(&hc->address_manager);
         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)
 {
-        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);
+        dev_speed_t speed = FULL_SPEED;
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
@@ -122 +108 @@
 /*----------------------------------------------------------------------------*/
 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)
 {
-        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);
+        dev_speed_t speed = FULL_SPEED;
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
@@ -145 +127 @@
     usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
-        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);
+        dev_speed_t speed = FULL_SPEED;
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
@@ -166 +143 @@
     usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
-        assert(fun);
-        uhci_t *hc = fun_to_uhci(fun);
-        assert(hc);
-        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        dev_speed_t speed = FULL_SPEED;
 
-        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 = 0;
-        size_t io_reg_size = 0;
-        int irq = 0;
+
+        uintptr_t io_reg_base;
+        size_t io_reg_size;
+        int irq;
 
         int ret =
@@ -94 +95 @@
             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));
@@ -113 +114 @@
          */
         device->driver_data = uhci_hc;
+
         ret = register_interrupt_handler(device, irq, irq_handler,
             &uhci_hc->interrupt_code);
@@ -147 +149 @@
 {
         sleep(3);
-        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
+        usb_log_enable(USB_LOG_LEVEL_INFO, 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"
@@ -85 +83 @@
                                 irq = res->res.interrupt.irq;
                                 irq_found = true;
-                                usb_log_debug2("Found interrupt: %d.\n", irq);
                                 break;
                         case IO_RANGE:
-                                io_address = res->res.io_range.address;
+                                io_address = (uintptr_t)
+                                    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;
@@ -109 +105 @@
         }
 
-        *io_reg_address = io_address;
-        *io_reg_size = io_size;
-        *irq_no = irq;
+        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;
+        }
 
         rc = EOK;
@@ -125 +127 @@
             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>
@@ -44 +41 @@
 #include "uhci.h"
 
-/*----------------------------------------------------------------------------*/
 static int usb_iface_get_hc_handle_rh_impl(ddf_fun_t *root_hub_fun,
     devman_handle_t *handle)
@@ -55 +51 @@
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
+
 static int usb_iface_get_address_rh_impl(ddf_fun_t *fun, devman_handle_t handle,
     usb_address_t *address)
@@ -65 +61 @@
         assert(hc);
 
-        usb_address_t addr = device_keeper_find(&hc->device_manager,
+        usb_address_t addr = usb_address_keeping_find(&hc->address_manager,
             handle);
         if (addr < 0) {
@@ -77 +73 @@
         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;
+static ddf_dev_ops_t root_hub_ops = {
+        .interfaces[USB_DEV_IFACE] = &usb_iface_root_hub_fun_impl
+};
 
-        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[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;
 
@@ -138 +105 @@
         ret = ddf_fun_add_match_id(hub, match_str, 100);
         if (ret != EOK) {
-                usb_log_error("Failed(%d) to add root hub match id: %s\n",
-                    ret, str_error(ret));
+                usb_log_error("Failed to add root hub match id.\n");
                 ddf_fun_destroy(hub);
-                return ret;
+                return ENOMEM;
         }
 

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);
@@ -84 +83 @@
                 list_append(&batch->link, &instance->batch_list);
                 instance->queue_head->element = pa;
-                usb_log_debug("Batch(%p) added to queue %s first.\n",
+                usb_log_debug2("Added batch(%p) to queue %s first.\n",
                         batch, instance->name);
                 fibril_mutex_unlock(&instance->guard);
@@ -97 +96 @@
         queue_head_append_qh(last->qh, pa);
         list_append(&batch->link, &instance->batch_list);
-        usb_log_debug("Batch(%p) added to queue %s last, first is %p.\n",
+        usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n",
                 batch, instance->name, first );
         fibril_mutex_unlock(&instance->guard);
@@ -109 +108 @@
         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("Batch(%p) removed (FIRST) from queue %s, next element %x.\n",
-                        batch, instance->name, batch->qh->next_queue);
+                usb_log_debug("Removing batch %p was first, next element %x.\n",
+                        batch, batch->qh->next_queue);
                 instance->queue_head->element = batch->qh->next_queue;
         } else {
-                usb_log_debug("Batch(%p) removed (NOT FIRST) from queue, next element %x.\n",
-                        batch, instance->name, batch->qh->next_queue);
+                usb_log_debug("Removing batch %p was NOT first, next element %x.\n",
+                        batch, batch->qh->next_queue);
                 batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
                 prev->qh->next_queue = batch->qh->next_queue;
@@ -125 +123 @@
 }
 /*----------------------------------------------------------------------------*/
-void transfer_list_remove_finished(transfer_list_t *instance)
+void transfer_list_check(transfer_list_t *instance)
 {
         assert(instance);
-
-        LIST_INITIALIZE(done);
-
         fibril_mutex_lock(&instance->guard);
         link_t *current = instance->batch_list.next;
@@ -139 +134 @@
                 if (batch_is_complete(batch)) {
                         transfer_list_remove_batch(instance, batch);
-                        list_append(current, &done);
+                        batch->next_step(batch);
                 }
                 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_remove_finished(transfer_list_t *instance);
+void transfer_list_check(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 = NULL, /* patched for every instance */
+                .addr = (void*)0xc022,
                 .dstarg = 1
         },
         {
                 .cmd = CMD_PIO_WRITE_16,
-                .addr = NULL, /* pathed for every instance */
+                .addr = (void*)0xc022,
                 .value = 0x1f
         },
@@ -68 +68 @@
         assert(hc);
 
-        usb_address_t addr = device_keeper_find(&hc->device_manager,
+        usb_address_t addr = usb_address_keeping_find(&hc->address_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,
@@ -88 +89 @@
 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
 };
 
@@ -101 +102 @@
         bool low_speed, usb_transfer_type_t, size_t size);
 
+#define CHECK_RET_RETURN(ret, message...) \
+        if (ret != EOK) { \
+                usb_log_error(message); \
+                return ret; \
+        } else (void) 0
 
 int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
@@ -106 +112 @@
         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
 
         /*
@@ -119 +117 @@
          */
         instance->ddf_instance = ddf_fun_create(dev, fun_exposed, "uhci");
-        ret = (instance->ddf_instance == NULL) ? ENOMEM : EOK;
-        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to create UHCI device function.\n");
-
+        if (instance->ddf_instance == NULL) {
+                usb_log_error("Failed to create UHCI device function.\n");
+                return ENOMEM;
+        }
         instance->ddf_instance->ops = &uhci_ops;
         instance->ddf_instance->driver_data = instance;
 
         ret = ddf_fun_bind(instance->ddf_instance);
-        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to bind UHCI device function: %s.\n",
-            ret, str_error(ret));
+        CHECK_RET_RETURN(ret, "Failed to bind UHCI device function: %s.\n",
+            str_error(ret));
 
         /* allow access to hc control registers */
         regs_t *io;
         ret = pio_enable(regs, reg_size, (void**)&io);
-        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to gain access to registers at %p: %s.\n",
-            ret, str_error(ret), io);
+        CHECK_RET_RETURN(ret, "Failed to gain access to registers at %p.\n", io);
         instance->registers = io;
-        usb_log_debug("Device registers at %p(%u) accessible.\n", io, reg_size);
+        usb_log_debug("Device registers accessible.\n");
 
         ret = uhci_init_mem_structures(instance);
-        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to initialize UHCI memory structures.\n");
+        CHECK_RET_RETURN(ret, "Failed to initialize 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);
 
-        usb_log_info("Started UHCI driver.\n");
-        return EOK;
-#undef CHECK_RET_DEST_FUN_RETURN
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
 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 */
@@ -176 +163 @@
         pio_write_16(&instance->registers->usbcmd,
             UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
+        usb_log_debug("Started UHCI HC.\n");
 }
 /*----------------------------------------------------------------------------*/
@@ -181 +169 @@
 {
         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 */
-        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);
-        }
+        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);
 
         /* init transfer lists */
-        ret = uhci_init_transfer_lists(instance);
-        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to initialize transfer lists.\n");
+        int ret = uhci_init_transfer_lists(instance);
+        CHECK_RET_RETURN(ret, "Failed to initialize transfer lists.\n");
         usb_log_debug("Initialized transfer lists.\n");
 
@@ -211 +190 @@
         instance->frame_list = get_page();
         ret = instance ? EOK : ENOMEM;
-        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
+        CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
         usb_log_debug("Initialized frame list.\n");
 
@@ -218 +197 @@
           instance->transfers_interrupt.queue_head_pa
           | LINK_POINTER_QUEUE_HEAD_FLAG;
-
         unsigned i = 0;
         for(; i < UHCI_FRAME_LIST_COUNT; ++i) {
@@ -225 +203 @@
 
         /* init address keeper(libusb) */
-        device_keeper_init(&instance->device_manager);
-        usb_log_debug("Initialized device manager.\n");
-
-        return EOK;
-#undef CHECK_RET_DEST_CMDS_RETURN
+        usb_address_keeping_init(&instance->address_manager, USB11_ADDRESS_MAX);
+        usb_log_debug("Initialized address manager.\n");
+
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -235 +212 @@
 {
         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");
-        CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
+        assert(ret == EOK);
         ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
-        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL FULL list.");
+        assert(ret == EOK);
         ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
-        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
+        assert(ret == EOK);
         ret = transfer_list_init(&instance->transfers_interrupt, "INTERRUPT");
-        CHECK_RET_CLEAR_RETURN(ret, "Failed to init INTERRUPT list.");
+        assert(ret == EOK);
 
         transfer_list_set_next(&instance->transfers_control_full,
@@ -281 +249 @@
 
         return EOK;
-#undef CHECK_RET_CLEAR_RETURN
 }
 /*----------------------------------------------------------------------------*/
@@ -288 +255 @@
         assert(instance);
         assert(batch);
-        const int low_speed = (batch->speed == USB_SPEED_LOW);
+        const int low_speed = (batch->speed == LOW_SPEED);
         if (!allowed_usb_packet(
             low_speed, batch->transfer_type, batch->max_packet_size)) {
@@ -309 +276 @@
 {
         assert(instance);
-//      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);
+        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);
 }
 /*----------------------------------------------------------------------------*/
@@ -324 +291 @@
         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);
-                pio_write_16(&instance->registers->usbsts, 0x1f);
-                async_usleep(UHCI_CLEANER_TIMEOUT * 5);
+                async_usleep(UHCI_CLEANER_TIMEOUT);
         }
         return EOK;
@@ -344 +307 @@
                 const uint16_t sts = pio_read_16(&instance->registers->usbsts);
                 const uint16_t intr = pio_read_16(&instance->registers->usbintr);
-                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;
+                usb_log_debug("Command: %X Status: %X Interrupts: %x\n",
+                    cmd, sts, intr);
+
+                uintptr_t frame_list = pio_read_32(&instance->registers->flbaseadd);
                 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 "transfer_list.h"
 #include "batch.h"
-#include "transfer_list.h"
-#include "utils/device_keeper.h"
 
 typedef struct uhci_regs {
@@ -82 +82 @@
 
 typedef struct uhci {
-        device_keeper_t device_manager;
-
+        usb_address_keeping_t address_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, bool low_speed,
+    int error_count, size_t size, bool toggle, bool isochronous,
     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;
 
@@ -67 +66 @@
         }
 
-        usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
+        usb_log_info("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
 }
 /*----------------------------------------------------------------------------*/
@@ -77 +88 @@
 
         if ((instance->status & TD_STATUS_ERROR_STALLED) != 0)
-                return ESTALL;
+                return EIO;
 
         if ((instance->status & TD_STATUS_ERROR_CRC) != 0)
-                return EBADCHECKSUM;
+                return EAGAIN;
 
         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, bool low_speed,
+    int error_count, size_t size, bool toggle, bool isochronous,
     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>
@@ -45 +43 @@
 
 #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)
@@ -84 +80 @@
         }
 
-        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);
+        /* TODO: get register values from hc */
+        int ret = uhci_root_hub_init(rh, (void*)0xc030, 4, device);
         if (ret != EOK) {
                 usb_log_error("Failed(%d) to initialize driver instance.\n", ret);
@@ -113 +102 @@
         .driver_ops = &uhci_rh_driver_ops
 };
-/*----------------------------------------------------------------------------*/
+
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
+        usb_log_enable(USB_LOG_LEVEL_INFO, 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 */
@@ -46 +45 @@
 #include "port_status.h"
 
-static int uhci_port_new_device(uhci_port_t *port, uint16_t status);
+static int uhci_port_new_device(uhci_port_t *port);
 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)
+  unsigned usec, ddf_dev_t *rh, int parent_phone)
 {
         assert(port);
@@ -71 +69 @@
         port->checker = fibril_create(uhci_port_check, port);
         if (port->checker == 0) {
-                usb_log_error("Port(%p - %d): failed to launch root hub fibril.",
-                    port->address, port->number);
+                usb_log_error(": failed to launch root hub fibril.");
                 return ENOMEM;
         }
         fibril_add_ready(port->checker);
-        usb_log_debug("Port(%p - %d): Added fibril. %x\n",
-            port->address, port->number, port->checker);
+        usb_log_debug(
+          "Added fibril for port %d: %p.\n", number, port->checker);
         return EOK;
 }
@@ -93 +90 @@
         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 =
@@ -105 +97 @@
 
                 /* debug print */
-                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);
-
-
+                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) {
                         int rc = usb_hc_connection_open(
                             &port_instance->hc_connection);
                         if (rc != EOK) {
-                                usb_log_error("Port(%p - %d): Failed to connect to HC.",
-                                    port_instance->address, port_instance->number);
-                                continue;
+                                usb_log_error("Failed to connect to HC.");
+                                goto next;
                         }
 
-                        /* remove any old device */
-                        if (port_instance->attached_device) {
-                                usb_log_debug("Port(%p - %d): Removing device.\n",
-                                    port_instance->address, port_instance->number);
+                        if (port_status & STATUS_CONNECTED) {
+                                /* new device */
+                                uhci_port_new_device(port_instance);
+                        } else {
                                 uhci_port_remove_device(port_instance);
-                        }
-
-                        if ((port_status & STATUS_CONNECTED) != 0) {
-                                /* new device */
-                                uhci_port_new_device(port_instance, port_status);
-                        } else {
-                                /* 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);
                         }
 
@@ -145 +119 @@
                             &port_instance->hc_connection);
                         if (rc != EOK) {
-                                usb_log_error("Port(%p - %d): Failed to disconnect from HC.",
-                                    port_instance->address, port_instance->number);
+                                usb_log_error("Failed to disconnect from HC.");
+                                goto next;
                         }
                 }
+        next:
+                async_usleep(port_instance->wait_period_usec);
         }
         return EOK;
@@ -163 +139 @@
         uhci_port_t *port = (uhci_port_t *) arg;
 
-        usb_log_debug2("Port(%p - %d): new_device_enable_port.\n",
-            port->address, port->number);
+        usb_log_debug("new_device_enable_port(%d)\n", port->number);
 
         /*
@@ -172 +147 @@
         async_usleep(100000);
 
+        /* Enable the port. */
+        uhci_port_set_enabled(port, true);
 
         /* The hub maintains the reset signal to that port for 10 ms
@@ -177 +154 @@
          */
         {
-                usb_log_debug("Port(%p - %d): Reset Signal start.\n",
-                    port->address, port->number);
+                usb_log_debug("Reset Signal start on port %d.\n",
+                    port->number);
                 port_status_t port_status =
                         port_status_read(port->address);
@@ -188 +165 @@
                 port_status &= ~STATUS_IN_RESET;
                 port_status_write(port->address, port_status);
-                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)
+                usb_log_debug("Reset Signal stop on port %d.\n",
+                    port->number);
+        }
+
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+static int uhci_port_new_device(uhci_port_t *port)
 {
         assert(port);
         assert(usb_hc_connection_is_opened(&port->hc_connection));
 
-        usb_log_info("Port(%p-%d): Detected new device.\n",
-            port->address, port->number);
+        usb_log_info("Detected new device on port %u.\n", port->number);
 
         usb_address_t dev_addr;
         int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
-            ((status & STATUS_LOW_SPEED) != 0) ? USB_SPEED_LOW : USB_SPEED_FULL,
+            USB_SPEED_FULL,
             new_device_enable_port, port->number, port,
             &dev_addr, &port->attached_device, NULL, NULL, NULL);
-
         if (rc != EOK) {
-                usb_log_error("Port(%p-%d): Failed(%d) adding new device: %s.\n",
-                    port->address, port->number, rc, str_error(rc));
+                usb_log_error("Failed adding new device on port %u: %s.\n",
+                    port->number, str_error(rc));
                 uhci_port_set_enabled(port, false);
                 return rc;
         }
 
-        usb_log_info("Port(%p-%d): New device has address %d (handle %zu).\n",
-            port->address, port->number, dev_addr, port->attached_device);
+        usb_log_info("New device on port %u has address %d (handle %zu).\n",
+            port->number, dev_addr, port->attached_device);
 
         return EOK;
@@ -229 +201 @@
 static int uhci_port_remove_device(uhci_port_t *port)
 {
-        usb_log_error("Port(%p-%d): Don't know how to remove device %#x.\n",
-                port->address, port->number, (unsigned int)port->attached_device);
+        usb_log_error("Don't know how to remove device %#x.\n",
+                (unsigned int)port->attached_device);
 //      uhci_port_set_enabled(port, false);
         return EOK;
@@ -251 +223 @@
         port_status_write(port->address, port_status);
 
-        usb_log_info("Port(%p-%d): %sabled port.\n",
-                port->address, port->number, enabled ? "En" : "Dis");
+        usb_log_info("%s port %d.\n",
+          enabled ? "Enabled" : "Disabled", port->number);
         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);
+  unsigned usec, ddf_dev_t *rh, int parent_phone);
 
 void uhci_port_fini(uhci_port_t *port);

uspace/drv/uhci-rhd/port_status.c

@@ -41 +41 @@
 struct flag_name
 {
-        uint16_t flag;
+        unsigned 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) != 0) ? "YES" : "NO");
+                  value & flags[i].flag ? "YES" : "NO");
         }
 }

uspace/drv/uhci-rhd/port_status.h

@@ -41 +41 @@
 typedef uint16_t port_status_t;
 
-#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)
+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_LOW_SPEED (1 <<  8)
-#define STATUS_IN_RESET  (1 <<  9)
-#define STATUS_SUSPEND   (1 << 12)
+        STATUS_LOW_SPEED = 1 <<  8,
+        STATUS_IN_RESET  = 1 <<  9,
+        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)
@@ -46 +47 @@
         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, size, (void**)&regs);
+        ret = pio_enable(
+          addr, sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT, (void**)&regs);
 
         if (ret < 0) {
@@ -60 +67 @@
         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 */
-                ret = uhci_port_init(
-                  &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh);
+                int ret = uhci_port_init(
+                  &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh, parent_phone);
                 if (ret != EOK) {
                         unsigned j = 0;

uspace/drv/uhci-rhd/root_hub.h

@@ -41 +41 @@
 
 #define UHCI_ROOT_HUB_PORT_COUNT 2
-#define ROOT_HUB_WAIT_USEC 5000000 /* 5 seconds */
+#define UHCI_ROOT_HUB_PORT_REGISTERS_OFFSET 0x10
+#define ROOT_HUB_WAIT_USEC 10000000 /* 10 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"
 
@@ -143 +141 @@
         //[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
-        
 };
 
@@ -209 +189 @@
 
         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;
 
 /**
@@ -50 +68 @@
 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 BOOTP_REPORT_SIZE 6
-
-static unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK;
+#define GUESSED_POLL_ENDPOINT 1
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -124 +120 @@
 
 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length)
-{uint8_t buffer[BUFFER_SIZE];
+{
         printf("%s\n", msg);
         
@@ -141 +137 @@
  */
 
-/** Currently active modifiers (locks is probably better word).
+/** Currently active modifiers. 
  *
  * 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.  
@@ -151 +147 @@
  * TODO: put to device? 
  */
-//static unsigned lock_keys;
+static unsigned lock_keys;
 
 #define NUM_LAYOUTS 3
@@ -163 +159 @@
 static int active_layout = 0;
 
-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)
+static void kbd_push_ev(int type, unsigned int key)
 {
         console_event_t ev;
@@ -292 +177 @@
         if (mod_mask != 0) {
                 if (type == KEY_PRESS)
-                        kbd_dev->mods = kbd_dev->mods | mod_mask;
+                        mods = mods | mod_mask;
                 else
-                        kbd_dev->mods = kbd_dev->mods & ~mod_mask;
+                        mods = mods & ~mod_mask;
         }
 
         switch (key) {
-        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;
+        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;
         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
@@ -316 +196 @@
                          * up the lock state.
                          */
-                        kbd_dev->mods = 
-                            kbd_dev->mods ^ (mod_mask & ~kbd_dev->lock_keys);
-                        kbd_dev->lock_keys = kbd_dev->lock_keys | mod_mask;
+                        mods = mods ^ (mod_mask & ~lock_keys);
+                        lock_keys = lock_keys | mod_mask;
 
                         /* Update keyboard lock indicator lights. */
-                        usbkbd_set_led(kbd_dev);
+                        // TODO
+                        //kbd_ctl_set_ind(mods);
                 } else {
-                        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) {
+                        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) {
                 active_layout = 0;
                 layout[active_layout]->reset();
@@ -337 +219 @@
         }
 
-        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F2) {
+        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
+                key == KC_F2) {
                 active_layout = 1;
                 layout[active_layout]->reset();
@@ -343 +226 @@
         }
 
-        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F3) {
+        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
+                key == KC_F3) {
                 active_layout = 2;
                 layout[active_layout]->reset();
@@ -351 +235 @@
         ev.type = type;
         ev.key = key;
-        ev.mods = kbd_dev->mods;
-        
-        if (ev.mods & KM_NUM_LOCK) {
-                usb_log_debug("\n\nNum Lock turned on.\n\n");
-        }
+        ev.mods = mods;
 
         ev.c = layout[active_layout]->parse_ev(&ev);
 
-        usb_log_debug2("Sending key %d to the console\n", ev.key);
+        printf("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);
 }
 /*
@@ -370 +249 @@
         /*
          * 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
@@ -484 +260 @@
     uint8_t modifiers, void *arg)
 {
-        if (arg == NULL) {
-                usb_log_warning("Missing argument in callback "
-                    "usbkbd_process_keycodes().\n");
-                return;
-        }
-
-        usb_log_debug2("Got keys from parser: ");
+        printf("Got keys: ");
         unsigned i;
         for (i = 0; i < count; ++i) {
-                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);
+                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");
 }
 
@@ -512 +284 @@
  * 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);
-//      }
-
-//      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");
-        
+                // 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_process_descriptors(usb_hid_dev_kbd_t *kbd_dev)
 {
@@ -680 +364 @@
             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");
+                return EREFUSED;
+        }
+
+
+
+
+        kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 
+            sizeof(usb_hid_configuration_t));
+        if (kbd_dev->conf == NULL) {
                 free(descriptors);
-                return EREFUSED;
-        }
-        
-        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 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);
-        
+                return ENOMEM;
+        }
+        
+        /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
         free(descriptors);
-        
-        if (rc != EOK) {
-                usb_log_warning("Problem with parsing REPORT descriptor.\n");
+        if (rc != EOK) {
+                printf("Problem with parsing standard descriptors.\n");
                 return rc;
         }
-        
-        usb_log_debug("Done parsing descriptors.\n");
-        
+
+        // 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
+         */
+
         return EOK;
 }
@@ -734 +421 @@
 
         if (kbd_dev == NULL) {
-                usb_log_fatal("No memory!\n");
+                fprintf(stderr, NAME ": No memory!\n");
                 return NULL;
         }
@@ -762 +449 @@
 
         /*
-         * Get descriptors, parse descriptors and save endpoints.
-         */
+         * 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
         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;
 
@@ -805 +476 @@
         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);
-        /*usb_log_debug2("Calling usb_hid_boot_keyboard_input_report() with size"
-            " %zu\n", actual_size);*/
+        printf("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, kbd_dev);
-        
-        if (rc != EOK) {
-                usb_log_warning("Error in usb_hid_boot_keyboard_input_report():"
-                    "%s\n", str_error(rc));
+        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);
         }
 }
@@ -828 +497 @@
         size_t actual_size;
 
-        usb_log_info("Polling keyboard...\n");
+        printf("Polling keyboard...\n");
 
         while (true) {
@@ -835 +504 @@
                 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
                 if (sess_rc != EOK) {
-                        usb_log_warning("Failed to start a session: %s.\n",
+                        printf("Failed to start a session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -845 +514 @@
 
                 if (rc != EOK) {
-                        usb_log_warning("Error polling the keyboard: %s.\n",
+                        printf("Error polling the keyboard: %s.\n",
                             str_error(rc));
                         continue;
@@ -851 +520 @@
 
                 if (sess_rc != EOK) {
-                        usb_log_warning("Error closing session: %s.\n",
+                        printf("Error closing session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -861 +530 @@
                  */
                 if (actual_size == 0) {
-                        usb_log_debug("Keyboard returned NAK\n");
+                        printf("Keyboard returned NAK\n");
                         continue;
                 }
@@ -868 +537 @@
                  * TODO: Process pressed keys.
                  */
-                usb_log_debug("Calling usbkbd_process_interrupt_in()\n");
+                printf("Calling usbkbd_process_interrupt_in()\n");
                 usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size);
         }
@@ -878 +547 @@
 static int usbkbd_fibril_device(void *arg)
 {
+        printf("!!! USB device fibril\n");
+
         if (arg == NULL) {
-                usb_log_error("No device!\n");
+                printf("No device!\n");
                 return -1;
         }
-        
-        usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg;
+
+        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;
+        }
 
         usbkbd_poll_keyboard(kbd_dev);
@@ -892 +570 @@
 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.
@@ -904 +601 @@
         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, kbd_dev);
+        fid_t fid = fibril_create(usbkbd_fibril_device, dev);
         if (fid == 0) {
-                usb_log_error("Failed to start fibril for HID device\n");
+                printf("%s: failed to start fibril for HID device\n", NAME);
                 return ENOMEM;
         }
@@ -948 +634 @@
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
+        usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid");
         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"
@@ -52 +51 @@
 };
 
+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"
@@ -57 +56 @@
 };
 
-/** Hub status-change endpoint description
- *
- * For more see usb hub specification in 11.15.1 of
- */
+/** Hub status-change endpoint description */
 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;
-}
 
 
@@ -150 +135 @@
 
         //configuration descriptor
-        /// \TODO check other configurations?
+        /// \TODO check other configurations
         usb_standard_configuration_descriptor_t config_descriptor;
         opResult = usb_request_get_bare_configuration_descriptor(
@@ -194 +179 @@
         }
 
+        /**
+         * Initialize the interrupt in endpoint.
+         * \TODO this code should be checked...
+         */
         usb_endpoint_mapping_t endpoint_mapping[1] = {
                 {
@@ -221 +210 @@
         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*/
+
 }
 
@@ -253 +249 @@
         usb_endpoint_pipe_start_session(&result->endpoints.control);
         opResult = usb_request_get_descriptor(&result->endpoints.control,
-                        USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
-                        USB_DESCTYPE_HUB,
-                        0, 0, serialized_descriptor,
+                        USB_REQUEST_TYPE_CLASS,
+                        USB_DESCTYPE_HUB, 0, 0, serialized_descriptor,
                         USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
         usb_endpoint_pipe_end_session(&result->endpoints.control);
@@ -272 +267 @@
         }
 
+        
         dprintf(USB_LOG_LEVEL_INFO, "setting port count to %d",descriptor->ports_count);
         result->port_count = descriptor->ports_count;
@@ -333 +329 @@
 
         //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");
@@ -392 +368 @@
         //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 %d",opResult);
+
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_WARNING, "cannot assign default address, it is probably used");
                 return;
         }
@@ -406 +381 @@
                         );
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                "something went wrong when reseting a port %d",opResult);
+                dprintf(USB_LOG_LEVEL_ERROR, "something went wrong when reseting a port");
                 //usb_hub_release_default_address(hc);
                 usb_hc_release_default_address(&hub->connection);
@@ -420 +394 @@
  */
 static void usb_hub_finalize_add_device( usb_hub_info_t * hub,
-                uint16_t port, bool isLowSpeed) {
+                uint16_t port) {
 
         int opResult;
@@ -443 +417 @@
                         &new_device_connection);
         /// \TODO get highspeed info
-        usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
+
+
+
 
 
@@ -449 +425 @@
         usb_address_t new_device_address = usb_hc_request_address(
                         &hub->connection,
-                        speed/// \TODO fullspeed??
+                        USB_SPEED_LOW/// \TODO fullspeed??
                         );
         if (new_device_address < 0) {
@@ -460 +436 @@
         //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);
-        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);
+
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_ERROR, "could not set address for new device");
                 usb_hc_release_default_address(&hub->connection);
                 return;
@@ -484 +458 @@
 
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                "could not start driver for new device %d",opResult);
+                dprintf(USB_LOG_LEVEL_ERROR, "could not start driver for new device");
                 return;
         }
@@ -496 +469 @@
                         &hub->attached_devs[port]);
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                "could not assign address of device in hcd %d",opResult);
+                dprintf(USB_LOG_LEVEL_ERROR, "could not assign address of device in hcd");
                 return;
         }
@@ -539 +511 @@
 }
 
-
-/**
- *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
@@ -570 +522 @@
         //determine type of change
         usb_endpoint_pipe_t *pipe = &hub->endpoints.control;
+        int opResult = usb_endpoint_pipe_start_session(pipe);
         
-        int opResult;
+        if(opResult != EOK){
+                dprintf(USB_LOG_LEVEL_ERROR, "cannot open pipe %d", opResult);
+        }
+
+        /*
+        usb_target_t target;
+        target.address=address;
+        target.endpoint=0;
+        */
 
         usb_port_status_t status;
@@ -586 +547 @@
                         );
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, "could not get port status");
+                dprintf(USB_LOG_LEVEL_ERROR, "ERROR: could not get port status");
                 return;
         }
         if (rcvd_size != sizeof (usb_port_status_t)) {
-                dprintf(USB_LOG_LEVEL_ERROR, "received status has incorrect size");
+                dprintf(USB_LOG_LEVEL_ERROR, "ERROR: received status has incorrect size");
                 return;
         }
@@ -605 +566 @@
                 }
         }
-        //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_port_low_speed(&status));
+                        usb_hub_finalize_add_device(hub, port);
                 } else {
-                        dprintf(USB_LOG_LEVEL_WARNING, "port reset, but port still not enabled");
+                        dprintf(USB_LOG_LEVEL_WARNING, "ERROR: port reset, but port still not enabled");
                 }
         }
@@ -634 +585 @@
         }
         /// \TODO handle other changes
-}
-
-/**
- * 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;
+        /// \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) {
+        /*
+         * Iterate through all hubs.
+         */
+        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;
+                }
+                /*
+                 * 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;
-
-        /*
-         * Send the request.
-         */
-        opResult = usb_endpoint_pipe_read(
-                        &hub_info->endpoints.status_change,
-                        change_bitmap, byte_length, &actual_size
-                        );
-
-        if (opResult != EOK) {
+                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);
-                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);
-                }
-        }
-        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);
-}
+                
+
+                //async_hangup(hc);
+                fibril_mutex_lock(&usb_hub_list_lock);
+        }
+        fibril_mutex_unlock(&usb_hub_list_lock);
+}
+
+
 
 

uspace/drv/usbhub/usbhub.h

@@ -75 +75 @@
 /**
  * function running the hub-controlling loop.
- * @param hub_info_param hub info pointer
+ * @param noparam fundtion does not need any parameters
  */
-int usb_hub_control_loop(void * hub_info_param);
+int usb_hub_control_loop(void * noparam);
 
 /** Callback when new hub device is detected.
@@ -87 +87 @@
 
 /**
- * check changes on specified hub
- * @param hub_info_param pointer to usb_hub_info_t structure
+ * check changes on all registered hubs
  */
-void usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);
+void usb_hub_check_hub_changes(void);
 
 
+//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 {
@@ -73 +62 @@
         USB_HID_PROTOCOL_KEYBOARD = 1,
         USB_HID_PROTOCOL_MOUSE = 2
-} usb_hid_iface_protocol_t;
+} usb_hid_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;
 
-
-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
+#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,
-    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t, 
-    size_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,
-    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void **, size_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;
         }
 
-        data[0] = leds;
+        /* used only first five bits, others are only padding*/
+        *data = 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))
@@ -210 +209 @@
  */
 int usb_request_get_descriptor(usb_endpoint_pipe_t *pipe,
-    usb_request_type_t request_type, usb_request_recipient_t recipient,
+    usb_request_type_t request_type,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -225 +224 @@
 
         return usb_control_request_get(pipe,
-            request_type, recipient,
+            request_type, USB_REQUEST_RECIPIENT_DEVICE,
             USB_DEVREQ_GET_DESCRIPTOR,
             wValue, language,
@@ -243 +242 @@
  */
 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
-    usb_request_type_t request_type, usb_request_recipient_t recipient,
+    usb_request_type_t request_type,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -259 +258 @@
         uint8_t tmp_buffer[1];
         size_t bytes_transfered;
-        rc = usb_request_get_descriptor(pipe, request_type, recipient,
+        rc = usb_request_get_descriptor(pipe, request_type,
             descriptor_type, descriptor_index, language,
             &tmp_buffer, 1, &bytes_transfered);
@@ -284 +283 @@
         }
 
-        rc = usb_request_get_descriptor(pipe, request_type, recipient,
+        rc = usb_request_get_descriptor(pipe, request_type,
             descriptor_type, descriptor_index, language,
             buffer, size, &bytes_transfered);
@@ -321 +320 @@
         usb_standard_device_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, 
-            USB_DESCTYPE_DEVICE, 0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_DEVICE,
+            0, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -367 +366 @@
         usb_standard_configuration_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_CONFIGURATION, index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
+            index, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -407 +406 @@
 
         return usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_CONFIGURATION, index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
+            index, 0,
             descriptor, descriptor_size, actual_size);
 }
@@ -453 +452 @@
         size_t string_descriptor_size = 0;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_STRING, 0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING, 0, 0,
             (void **) &string_descriptor, &string_descriptor_size);
         if (rc != EOK) {
@@ -537 +535 @@
         size_t string_size;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_STRING, index, uint16_host2usb(lang),
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING,
+            index, uint16_host2usb(lang),
             (void **) &string, &string_size);
         if (rc != EOK) {