Changes in uspace/lib/usbhost/src/ddf_helpers.c [a6afb4c:4547f11] in mainline

File:

• uspace/lib/usbhost/src/ddf_helpers.c (modified) (17 diffs)

uspace/lib/usbhost/src/ddf_helpers.c

@@ -31 +31 @@
  */
 /** @file
- * Helpers to work with the DDF interface.
- */
+ *
+ */
+
+#include <usb/classes/classes.h>
+#include <usb/debug.h>
+#include <usb/descriptor.h>
+#include <usb/request.h>
+#include <usb/usb.h>
 
 #include <adt/list.h>
@@ -41 +47 @@
 #include <device/hw_res_parsed.h>
 #include <errno.h>
+#include <fibril_synch.h>
+#include <macros.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <str_error.h>
-#include <usb/classes/classes.h>
-#include <usb/debug.h>
-#include <usb/descriptor.h>
-#include <usb/usb.h>
 #include <usb_iface.h>
-#include <usbhc_iface.h>
-
-#include "bus.h"
-#include "endpoint.h"
 
 #include "ddf_helpers.h"
 
-/**
- * DDF usbhc_iface callback. Passes the endpoint descriptors, fills the pipe
- * descriptor according to the contents of the endpoint.
- *
- * @param[in] fun DDF function of the device in question.
- * @param[out] pipe_desc The pipe descriptor to be filled.
- * @param[in] endpoint_desc Endpoint descriptors from the device.
+#define CTRL_PIPE_MIN_PACKET_SIZE 8
+
+typedef struct usb_dev {
+        link_t link;
+        list_t devices;
+        fibril_mutex_t guard;
+        ddf_fun_t *fun;
+        usb_address_t address;
+        usb_speed_t speed;
+        usb_address_t tt_address;
+        unsigned port;
+} usb_dev_t;
+
+typedef struct hc_dev {
+        ddf_fun_t *ctl_fun;
+        hcd_t hcd;
+        usb_dev_t *root_hub;
+} hc_dev_t;
+
+static hc_dev_t *dev_to_hc_dev(ddf_dev_t *dev)
+{
+        return ddf_dev_data_get(dev);
+}
+
+hcd_t *dev_to_hcd(ddf_dev_t *dev)
+{
+        hc_dev_t *hc_dev = dev_to_hc_dev(dev);
+        if (!hc_dev) {
+                usb_log_error("Invalid HCD device.\n");
+                return NULL;
+        }
+        return &hc_dev->hcd;
+}
+
+
+static int hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
+static int hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
+
+
+/* DDF INTERFACE */
+
+/** Register endpoint interface function.
+ * @param fun DDF function.
+ * @param address USB address of the device.
+ * @param endpoint USB endpoint number to be registered.
+ * @param transfer_type Endpoint's transfer type.
+ * @param direction USB communication direction the endpoint is capable of.
+ * @param max_packet_size Maximu size of packets the endpoint accepts.
+ * @param interval Preferred timeout between communication.
  * @return Error code.
  */
-static int register_endpoint(ddf_fun_t *fun, usb_pipe_desc_t *pipe_desc,
-     const usb_endpoint_descriptors_t *ep_desc)
+static int register_endpoint(
+    ddf_fun_t *fun, usb_endpoint_t endpoint,
+    usb_transfer_type_t transfer_type, usb_direction_t direction,
+    size_t max_packet_size, unsigned packets, unsigned interval)
 {
         assert(fun);
-        hc_device_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
-        device_t *dev = ddf_fun_data_get(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
-        assert(hcd->bus);
         assert(dev);
-
-        endpoint_t *ep;
-        const int err = bus_endpoint_add(dev, ep_desc, &ep);
-        if (err)
-                return err;
-
-        if (pipe_desc) {
-                pipe_desc->endpoint_no = ep->endpoint;
-                pipe_desc->direction = ep->direction;
-                pipe_desc->transfer_type = ep->transfer_type;
-                pipe_desc->max_transfer_size = ep->max_transfer_size;
-        }
-        endpoint_del_ref(ep);
-
-        return EOK;
-}
-
- /**
-  * DDF usbhc_iface callback. Unregister endpoint that makes the other end of
-  * the pipe described.
-  *
-  * @param fun DDF function of the device in question.
-  * @param pipe_desc Pipe description.
-  * @return Error code.
-  */
-static int unregister_endpoint(ddf_fun_t *fun, const usb_pipe_desc_t *pipe_desc)
+        const size_t size = max_packet_size;
+        const usb_target_t target =
+            {{.address = dev->address, .endpoint = endpoint}};
+
+        usb_log_debug("Register endpoint %d:%d %s-%s %zuB %ums.\n",
+            dev->address, endpoint, usb_str_transfer_type(transfer_type),
+            usb_str_direction(direction), max_packet_size, interval);
+
+        return hcd_add_ep(hcd, target, direction, transfer_type,
+            max_packet_size, packets, size, dev->tt_address, dev->port);
+}
+
+/** Unregister endpoint interface function.
+ * @param fun DDF function.
+ * @param address USB address of the endpoint.
+ * @param endpoint USB endpoint number.
+ * @param direction Communication direction of the enpdoint to unregister.
+ * @return Error code.
+ */
+static int unregister_endpoint(
+    ddf_fun_t *fun, usb_endpoint_t endpoint, usb_direction_t direction)
 {
         assert(fun);
-        hc_device_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
-        device_t *dev = ddf_fun_data_get(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
-        assert(hcd->bus);
         assert(dev);
-
-        endpoint_t *ep = bus_find_endpoint(dev, pipe_desc->endpoint_no, pipe_desc->direction);
-        if (!ep)
-                return ENOENT;
-
-        return bus_endpoint_remove(ep);
-}
-
-/**
- * DDF usbhc_iface callback. Calls the respective bus operation directly.
- *
- * @param fun DDF function of the device (hub) requesting the address.
- */
-static int default_address_reservation(ddf_fun_t *fun, bool reserve)
+        const usb_target_t target =
+            {{.address = dev->address, .endpoint = endpoint}};
+        usb_log_debug("Unregister endpoint %d:%d %s.\n",
+            dev->address, endpoint, usb_str_direction(direction));
+        return hcd_remove_ep(hcd, target, direction);
+}
+
+static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
 {
         assert(fun);
-        hc_device_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
-        device_t *dev = ddf_fun_data_get(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
-        assert(hcd->bus);
         assert(dev);
 
-        usb_log_debug("Device %d %s default address", dev->address, reserve ? "requested" : "releasing");
-        if (reserve) {
-                return bus_reserve_default_address(hcd->bus, dev);
-        } else {
-                bus_release_default_address(hcd->bus, dev);
-                return EOK;
-        }
-}
-
-/**
- * DDF usbhc_iface callback. Calls the bus operation directly.
- *
- * @param fun DDF function of the device (hub) requesting the address.
- * @param speed USB speed of the new device
- */
-static int device_enumerate(ddf_fun_t *fun, unsigned port, usb_speed_t speed)
+        usb_log_debug("Device %d requested default address at %s speed\n",
+            dev->address, usb_str_speed(speed));
+        return hcd_reserve_default_address(hcd, speed);
+}
+
+static int release_default_address(ddf_fun_t *fun)
 {
         assert(fun);
-        ddf_dev_t *hc = ddf_fun_get_dev(fun);
-        assert(hc);
-        hc_device_t *hcd = dev_to_hcd(hc);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
-        device_t *hub = ddf_fun_data_get(fun);
-        assert(hub);
-
-        int err;
-
-        if (!usb_speed_is_valid(speed))
-                return EINVAL;
-
-        usb_log_debug("Hub %d reported a new %s speed device on port: %u",
-            hub->address, usb_str_speed(speed), port);
-
-        device_t *dev = hcd_ddf_fun_create(hcd, speed);
-        if (!dev) {
-                usb_log_error("Failed to create USB device function.");
-                return ENOMEM;
-        }
-
-        dev->hub = hub;
-        dev->tier = hub->tier + 1;
-        dev->port = port;
-        dev->speed = speed;
-
-        if ((err = bus_device_enumerate(dev))) {
-                usb_log_error("Failed to initialize USB dev memory structures.");
-                goto err_usb_dev;
-        }
-
-        /* If the driver didn't name the dev when enumerating,
-         * do it in some generic way.
-         */
-        if (!ddf_fun_get_name(dev->fun)) {
-                bus_device_set_default_name(dev);
-        }
-
-        if ((err = ddf_fun_bind(dev->fun))) {
-                usb_log_error("Device(%d): Failed to register: %s.", dev->address, str_error(err));
-                goto err_usb_dev;
-        }
-
-        return EOK;
-
-err_usb_dev:
-        hcd_ddf_fun_destroy(dev);
-        return err;
+        assert(dev);
+
+        usb_log_debug("Device %d released default address\n", dev->address);
+        return hcd_release_default_address(hcd);
+}
+
+static int device_enumerate(ddf_fun_t *fun, unsigned port)
+{
+        assert(fun);
+        ddf_dev_t *ddf_dev = ddf_fun_get_dev(fun);
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+        assert(ddf_dev);
+        assert(dev);
+        usb_log_debug("Hub %d reported a new USB device on port: %u\n",
+            dev->address, port);
+        return hcd_ddf_new_device(ddf_dev, dev, port);
 }
 
@@ -198 +191 @@
 {
         assert(fun);
-        device_t *hub = ddf_fun_data_get(fun);
-        assert(hub);
-        usb_log_debug("Hub `%s' reported removal of device on port %u",
+        ddf_dev_t *ddf_dev = ddf_fun_get_dev(fun);
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+        assert(ddf_dev);
+        assert(dev);
+        usb_log_debug("Hub `%s' reported removal of device on port %u\n",
             ddf_fun_get_name(fun), port);
-
-        device_t *victim = NULL;
-
-        fibril_mutex_lock(&hub->guard);
-        list_foreach(hub->devices, link, device_t, it) {
-                if (it->port == port) {
-                        victim = it;
-                        break;
-                }
-        }
-        fibril_mutex_unlock(&hub->guard);
-
-        if (!victim) {
-                usb_log_warning("Hub '%s' tried to remove non-existent"
-                    " device.", ddf_fun_get_name(fun));
-                return ENOENT;
-        }
-
-        assert(victim->fun);
-        assert(victim->port == port);
-        assert(victim->hub == hub);
-
-        bus_device_gone(victim);
-        return EOK;
-}
-
-/**
- * Gets description of the device that is calling.
+        return hcd_ddf_remove_device(ddf_dev, dev, port);
+}
+
+/** Gets handle of the respective device.
  *
  * @param[in] fun Device function.
- * @param[out] desc Device descriptor to be filled.
+ * @param[out] handle Place to write the handle.
  * @return Error code.
  */
-static int get_device_description(ddf_fun_t *fun, usb_device_desc_t *desc)
+static int get_my_device_handle(ddf_fun_t *fun, devman_handle_t *handle)
 {
         assert(fun);
-        device_t *dev = ddf_fun_data_get(fun);
-        assert(dev);
-
-        if (!desc)
-                return EOK;
-
-        *desc = (usb_device_desc_t) {
-                .address = dev->address,
-                .depth = dev->tier,
-                .speed = dev->speed,
-                .handle = ddf_fun_get_handle(fun),
-                .iface = -1,
-        };
+        if (handle)
+                *handle = ddf_fun_get_handle(fun);
         return EOK;
 }
@@ -264 +224 @@
  * @return Error code.
  */
-static int dev_read(ddf_fun_t *fun, usb_target_t target,
-    uint64_t setup_data, char *data, size_t size,
-    usbhc_iface_transfer_callback_t callback, void *arg)
+static int dev_read(ddf_fun_t *fun, usb_endpoint_t endpoint,
+    uint64_t setup_data, uint8_t *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
         assert(fun);
-        device_t *dev = ddf_fun_data_get(fun);
-        assert(dev);
-
-        target.address = dev->address;
-
-        if (!usb_target_is_valid(&target))
-                return EINVAL;
-
-        if (size > 0 && data == NULL)
-                return EBADMEM;
-
-        if (!callback && arg)
-                return EBADMEM;
-
-        return bus_device_send_batch(dev, target, USB_DIRECTION_IN,
-            data, size, setup_data,
-            callback, arg, "READ");
+        usb_dev_t *usb_dev = ddf_fun_data_get(fun);
+        assert(usb_dev);
+        const usb_target_t target = {{
+            .address =  usb_dev->address,
+            .endpoint = endpoint,
+        }};
+        return hcd_send_batch(dev_to_hcd(ddf_fun_get_dev(fun)), target,
+            USB_DIRECTION_IN, data, size, setup_data, callback, NULL, arg,
+            "READ");
 }
 
@@ -298 +250 @@
  * @return Error code.
  */
-static int dev_write(ddf_fun_t *fun, usb_target_t target,
-    uint64_t setup_data, const char *data, size_t size,
-    usbhc_iface_transfer_callback_t callback, void *arg)
+static int dev_write(ddf_fun_t *fun, usb_endpoint_t endpoint,
+    uint64_t setup_data, const uint8_t *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
         assert(fun);
-        device_t *dev = ddf_fun_data_get(fun);
-        assert(dev);
-
-        target.address = dev->address;
-
-        if (!usb_target_is_valid(&target))
-                return EINVAL;
-
-        if (size > 0 && data == NULL)
-                return EBADMEM;
-
-        if (!callback && arg)
-                return EBADMEM;
-
-        return bus_device_send_batch(dev, target, USB_DIRECTION_OUT,
-            (char *) data, size, setup_data,
+        usb_dev_t *usb_dev = ddf_fun_data_get(fun);
+        assert(usb_dev);
+        const usb_target_t target = {{
+            .address =  usb_dev->address,
+            .endpoint = endpoint,
+        }};
+        return hcd_send_batch(dev_to_hcd(ddf_fun_get_dev(fun)),
+            target, USB_DIRECTION_OUT, (uint8_t*)data, size, setup_data, NULL,
             callback, arg, "WRITE");
 }
@@ -324 +268 @@
 /** USB device interface */
 static usb_iface_t usb_iface = {
-        .get_my_description = get_device_description,
-};
-
-/** USB host controller interface */
-static usbhc_iface_t usbhc_iface = {
-        .default_address_reservation = default_address_reservation,
+        .get_my_device_handle = get_my_device_handle,
+
+        .reserve_default_address = reserve_default_address,
+        .release_default_address = release_default_address,
 
         .device_enumerate = device_enumerate,
@@ -344 +286 @@
 static ddf_dev_ops_t usb_ops = {
         .interfaces[USB_DEV_IFACE] = &usb_iface,
-        .interfaces[USBHC_DEV_IFACE] = &usbhc_iface,
 };
 
 
 /* DDF HELPERS */
+
+#define GET_DEVICE_DESC(size) \
+{ \
+        .request_type = SETUP_REQUEST_TYPE_DEVICE_TO_HOST \
+            | (USB_REQUEST_TYPE_STANDARD << 5) \
+            | USB_REQUEST_RECIPIENT_DEVICE, \
+        .request = USB_DEVREQ_GET_DESCRIPTOR, \
+        .value = uint16_host2usb(USB_DESCTYPE_DEVICE << 8), \
+        .index = uint16_host2usb(0), \
+        .length = uint16_host2usb(size), \
+};
+
+#define SET_ADDRESS(address) \
+{ \
+        .request_type = SETUP_REQUEST_TYPE_HOST_TO_DEVICE \
+            | (USB_REQUEST_TYPE_STANDARD << 5) \
+            | USB_REQUEST_RECIPIENT_DEVICE, \
+        .request = USB_DEVREQ_SET_ADDRESS, \
+        .value = uint16_host2usb(address), \
+        .index = uint16_host2usb(0), \
+        .length = uint16_host2usb(0), \
+};
+
+static int hcd_ddf_add_device(ddf_dev_t *parent, usb_dev_t *hub_dev,
+    unsigned port, usb_address_t address, usb_speed_t speed, const char *name,
+    const match_id_list_t *mids)
+{
+        assert(parent);
+
+        char default_name[10] = { 0 }; /* usbxyz-ss */
+        if (!name) {
+                snprintf(default_name, sizeof(default_name) - 1,
+                    "usb%u-%cs", address, usb_str_speed(speed)[0]);
+                name = default_name;
+        }
+
+        ddf_fun_t *fun = ddf_fun_create(parent, fun_inner, name);
+        if (!fun)
+                return ENOMEM;
+        usb_dev_t *info = ddf_fun_data_alloc(fun, sizeof(usb_dev_t));
+        if (!info) {
+                ddf_fun_destroy(fun);
+                return ENOMEM;
+        }
+        info->address = address;
+        info->speed = speed;
+        info->fun = fun;
+        info->port = port;
+        info->tt_address = hub_dev ? hub_dev->tt_address : -1;
+        link_initialize(&info->link);
+        list_initialize(&info->devices);
+        fibril_mutex_initialize(&info->guard);
+
+        if (hub_dev && hub_dev->speed == USB_SPEED_HIGH && usb_speed_is_11(speed))
+                info->tt_address = hub_dev->address;
+
+        ddf_fun_set_ops(fun, &usb_ops);
+        list_foreach(mids->ids, link, const match_id_t, mid) {
+                ddf_fun_add_match_id(fun, mid->id, mid->score);
+        }
+
+        int ret = ddf_fun_bind(fun);
+        if (ret != EOK) {
+                ddf_fun_destroy(fun);
+                return ret;
+        }
+
+        if (hub_dev) {
+                fibril_mutex_lock(&hub_dev->guard);
+                list_append(&info->link, &hub_dev->devices);
+                fibril_mutex_unlock(&hub_dev->guard);
+        } else {
+                hc_dev_t *hc_dev = dev_to_hc_dev(parent);
+                assert(hc_dev->root_hub == NULL);
+                hc_dev->root_hub = info;
+        }
+        return EOK;
+}
 
 #define ADD_MATCHID_OR_RETURN(list, sc, str, ...) \
@@ -375 +394 @@
         assert(l);
         assert(d);
-
+        
         if (d->vendor_id != 0) {
                 /* First, with release number. */
@@ -382 +401 @@
                     d->vendor_id, d->product_id, (d->device_version >> 8),
                     (d->device_version & 0xff));
-
+        
                 /* Next, without release number. */
                 ADD_MATCHID_OR_RETURN(l, 90, "usb&vendor=%#04x&product=%#04x",
@@ -396 +415 @@
 
         return EOK;
-}
-
-device_t *hcd_ddf_fun_create(hc_device_t *hc, usb_speed_t speed)
-{
-        /* Create DDF function for the new device */
-        ddf_fun_t *fun = ddf_fun_create(hc->ddf_dev, fun_inner, NULL);
-        if (!fun)
-                return NULL;
-
-        ddf_fun_set_ops(fun, &usb_ops);
-
-        /* Create USB device node for the new device */
-        device_t *dev = ddf_fun_data_alloc(fun, hc->bus->device_size);
-        if (!dev) {
-                ddf_fun_destroy(fun);
-                return NULL;
-        }
-
-        bus_device_init(dev, hc->bus);
-        dev->fun = fun;
-        dev->speed = speed;
-        return dev;
-}
-
-void hcd_ddf_fun_destroy(device_t *dev)
-{
-        assert(dev);
-        assert(dev->fun);
-        ddf_fun_destroy(dev->fun);
-}
-
-int hcd_ddf_setup_match_ids(device_t *device, usb_standard_device_descriptor_t *desc)
-{
-        int err;
+
+}
+
+static int hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub,
+    unsigned port)
+{
+        assert(device);
+
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+
+        hc_dev_t *hc_dev = dev_to_hc_dev(device);
+        assert(hc_dev);
+
+        fibril_mutex_lock(&hub->guard);
+
+        usb_dev_t *victim = NULL;
+
+        list_foreach(hub->devices, link, usb_dev_t, it) {
+                if (it->port == port) {
+                        victim = it;
+                        break;
+                }
+        }
+        if (victim) {
+                assert(victim->port == port);
+                list_remove(&victim->link);
+                fibril_mutex_unlock(&hub->guard);
+                const int ret = ddf_fun_unbind(victim->fun);
+                if (ret == EOK) {
+                        usb_address_t address = victim->address;
+                        ddf_fun_destroy(victim->fun);
+                        hcd_release_address(hcd, address);
+                } else {
+                        usb_log_warning("Failed to unbind device `%s': %s\n",
+                            ddf_fun_get_name(victim->fun), str_error(ret));
+                }
+                return EOK;
+        }
+        fibril_mutex_unlock(&hub->guard);
+        return ENOENT;
+}
+
+static int hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port)
+{
+        assert(device);
+
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+
+        usb_speed_t speed = USB_SPEED_MAX;
+
+        /* This checks whether the default address is reserved and gets speed */
+        int ret = usb_bus_get_speed(&hcd->bus, USB_ADDRESS_DEFAULT, &speed);
+        if (ret != EOK) {
+                usb_log_error("Failed to verify speed: %s.", str_error(ret));
+                return ret;
+        }
+
+        usb_log_debug("Found new %s speed USB device.", usb_str_speed(speed));
+
+        static const usb_target_t default_target = {{
+                .address = USB_ADDRESS_DEFAULT,
+                .endpoint = 0,
+        }};
+
+        usb_address_t address;
+        ret = hcd_request_address(hcd, speed, &address);
+        if (ret != EOK) {
+                usb_log_error("Failed to reserve new address: %s.",
+                    str_error(ret));
+                return ret;
+        }
+
+        usb_log_debug("Reserved new address: %d\n", address);
+
+        const usb_target_t target = {{
+                .address = address,
+                .endpoint = 0,
+        }};
+
+        const usb_address_t tt_address = hub ? hub->tt_address : -1;
+
+        /* Add default pipe on default address */
+        usb_log_debug("Device(%d): Adding default target(0:0)\n", address);
+        ret = hcd_add_ep(hcd,
+            default_target, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
+            CTRL_PIPE_MIN_PACKET_SIZE, CTRL_PIPE_MIN_PACKET_SIZE, 1,
+            tt_address, port);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to add default target: %s.",
+                    address, str_error(ret));
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+
+        /* Get max packet size for default pipe */
+        usb_standard_device_descriptor_t desc = { 0 };
+        const usb_device_request_setup_packet_t get_device_desc_8 =
+            GET_DEVICE_DESC(CTRL_PIPE_MIN_PACKET_SIZE);
+
+        // TODO CALLBACKS
+        usb_log_debug("Device(%d): Requesting first 8B of device descriptor.",
+            address);
+        size_t got;
+        ret = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_IN,
+            &desc, CTRL_PIPE_MIN_PACKET_SIZE, *(uint64_t *)&get_device_desc_8,
+            "read first 8 bytes of dev descriptor", &got);
+
+        if (ret == EOK && got != CTRL_PIPE_MIN_PACKET_SIZE) {
+                ret = EOVERFLOW;
+        }
+
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to get 8B of dev descr: %s.",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+
+        /* Register EP on the new address */
+        usb_log_debug("Device(%d): Registering control EP.", address);
+        ret = hcd_add_ep(hcd, target, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
+            ED_MPS_PACKET_SIZE_GET(uint16_usb2host(desc.max_packet_size)),
+            ED_MPS_TRANS_OPPORTUNITIES_GET(uint16_usb2host(desc.max_packet_size)),
+            ED_MPS_PACKET_SIZE_GET(uint16_usb2host(desc.max_packet_size)),
+            tt_address, port);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to register EP0: %s",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+
+        /* Set new address */
+        const usb_device_request_setup_packet_t set_address =
+            SET_ADDRESS(target.address);
+
+        usb_log_debug("Device(%d): Setting USB address.", address);
+        ret = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_OUT,
+            NULL, 0, *(uint64_t *)&set_address, "set address", &got);
+
+        usb_log_debug("Device(%d): Removing default (0:0) EP.", address);
+        hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to set new address: %s.",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+
+        /* Get std device descriptor */
+        const usb_device_request_setup_packet_t get_device_desc =
+            GET_DEVICE_DESC(sizeof(desc));
+
+        usb_log_debug("Device(%d): Requesting full device descriptor.",
+            address);
+        ret = hcd_send_batch_sync(hcd, target, USB_DIRECTION_IN,
+            &desc, sizeof(desc), *(uint64_t *)&get_device_desc,
+            "read device descriptor", &got);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to set get dev descriptor: %s",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+                return ret;
+        }
+
+        /* Create match ids from the device descriptor */
         match_id_list_t mids;
-
         init_match_ids(&mids);
 
-        /* Create match ids from the device descriptor */
-        usb_log_debug("Device(%d): Creating match IDs.", device->address);
-        if ((err = create_match_ids(&mids, desc))) {
-                return err;
-        }
-
-        list_foreach(mids.ids, link, const match_id_t, mid) {
-                ddf_fun_add_match_id(device->fun, mid->id, mid->score);
-        }
-
-        return EOK;
+        usb_log_debug("Device(%d): Creating match IDs.", address);
+        ret = create_match_ids(&mids, &desc);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to create match ids: %s",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+                return ret;
+        }
+
+        /* Register device */
+        usb_log_debug("Device(%d): Registering DDF device.", address);
+        ret = hcd_ddf_add_device(device, hub, port, address, speed, NULL, &mids);
+        clean_match_ids(&mids);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to register: %s.",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+        }
+
+        return ret;
+}
+
+/** Announce root hub to the DDF
+ *
+ * @param[in] device Host controller ddf device
+ * @return Error code
+ */
+int hcd_ddf_setup_root_hub(ddf_dev_t *device)
+{
+        assert(device);
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+
+        hcd_reserve_default_address(hcd, hcd->bus.max_speed);
+        const int ret = hcd_ddf_new_device(device, NULL, 0);
+        hcd_release_default_address(hcd);
+        return ret;
 }
 
@@ -457 +643 @@
  * This function does all the ddf work for hc driver.
  */
-int hcd_ddf_setup_hc(ddf_dev_t *device, size_t size)
+int hcd_ddf_setup_hc(ddf_dev_t *device, usb_speed_t max_speed,
+    size_t bw, bw_count_func_t bw_count)
 {
         assert(device);
 
-        hc_device_t *instance = ddf_dev_data_alloc(device, size);
+        hc_dev_t *instance = ddf_dev_data_alloc(device, sizeof(hc_dev_t));
         if (instance == NULL) {
-                usb_log_error("Failed to allocate HCD ddf structure.");
+                usb_log_error("Failed to allocate HCD ddf structure.\n");
                 return ENOMEM;
         }
-        instance->ddf_dev = device;
+        instance->root_hub = NULL;
+        hcd_init(&instance->hcd, max_speed, bw, bw_count);
 
         int ret = ENOMEM;
         instance->ctl_fun = ddf_fun_create(device, fun_exposed, "ctl");
         if (!instance->ctl_fun) {
-                usb_log_error("Failed to create HCD ddf fun.");
+                usb_log_error("Failed to create HCD ddf fun.\n");
                 goto err_destroy_fun;
         }
@@ -477 +665 @@
         ret = ddf_fun_bind(instance->ctl_fun);
         if (ret != EOK) {
-                usb_log_error("Failed to bind ctl_fun: %s.", str_error(ret));
+                usb_log_error("Failed to bind ctl_fun: %s.\n", str_error(ret));
                 goto err_destroy_fun;
         }
@@ -483 +671 @@
         ret = ddf_fun_add_to_category(instance->ctl_fun, USB_HC_CATEGORY);
         if (ret != EOK) {
-                usb_log_error("Failed to add fun to category: %s.",
+                usb_log_error("Failed to add fun to category: %s.\n",
                     str_error(ret));
                 ddf_fun_unbind(instance->ctl_fun);
@@ -498 +686 @@
 }
 
-void hcd_ddf_clean_hc(hc_device_t *hcd)
-{
-        if (ddf_fun_unbind(hcd->ctl_fun) == EOK)
-                ddf_fun_destroy(hcd->ctl_fun);
-}
-
+void hcd_ddf_clean_hc(ddf_dev_t *device)
+{
+        assert(device);
+        hc_dev_t *hc = dev_to_hc_dev(device);
+        assert(hc);
+        const int ret = ddf_fun_unbind(hc->ctl_fun);
+        if (ret == EOK)
+                ddf_fun_destroy(hc->ctl_fun);
+}
+
+//TODO: Cache parent session in HCD
 /** Call the parent driver with a request to enable interrupt
  *
@@ -510 +703 @@
  * @return Error code.
  */
-int hcd_ddf_enable_interrupt(hc_device_t *hcd, int inum)
-{
-        async_sess_t *parent_sess = ddf_dev_parent_sess_get(hcd->ddf_dev);
+int hcd_ddf_enable_interrupt(ddf_dev_t *device, int inum)
+{
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
         if (parent_sess == NULL)
                 return EIO;
@@ -519 +712 @@
 }
 
-int hcd_ddf_get_registers(hc_device_t *hcd, hw_res_list_parsed_t *hw_res)
-{
-        async_sess_t *parent_sess = ddf_dev_parent_sess_get(hcd->ddf_dev);
+//TODO: Cache parent session in HCD
+int hcd_ddf_get_registers(ddf_dev_t *device, hw_res_list_parsed_t *hw_res)
+{
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
         if (parent_sess == NULL)
                 return EIO;
@@ -532 +726 @@
 }
 
+// TODO: move this someplace else
+static inline void irq_code_clean(irq_code_t *code)
+{
+        if (code) {
+                free(code->ranges);
+                free(code->cmds);
+                code->ranges = NULL;
+                code->cmds = NULL;
+                code->rangecount = 0;
+                code->cmdcount = 0;
+        }
+}
+
+/** Register interrupt handler
+ *
+ * @param[in] device Host controller DDF device
+ * @param[in] regs Register range
+ * @param[in] irq Interrupt number
+ * @paran[in] handler Interrupt handler
+ * @param[in] gen_irq_code IRQ code generator.
+ *
+ * @param[out] handle  IRQ capability handle on success.
+ *
+ * @return Error code.
+ */
+int hcd_ddf_setup_interrupts(ddf_dev_t *device,
+    const hw_res_list_parsed_t *hw_res,
+    interrupt_handler_t handler,
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *, int *),
+    cap_handle_t *handle)
+{
+
+        assert(device);
+        if (!handler || !gen_irq_code)
+                return ENOTSUP;
+
+        irq_code_t irq_code = {0};
+
+        int irq;
+        int ret = gen_irq_code(&irq_code, hw_res, &irq);
+        if (ret != EOK) {
+                usb_log_error("Failed to generate IRQ code: %s.\n",
+                    str_error(ret));
+                return ret;
+        }
+
+        /* Register handler to avoid interrupt lockup */
+        ret = register_interrupt_handler(device, irq, handler,
+            &irq_code, handle);
+        irq_code_clean(&irq_code);
+        if (ret != EOK) {
+                usb_log_error("Failed to register interrupt handler: %s.\n",
+                    str_error(ret));
+                return ret;
+        }
+
+        /* Enable interrupts */
+        ret = hcd_ddf_enable_interrupt(device, irq);
+        if (ret != EOK) {
+                usb_log_error("Failed to register interrupt handler: %s.\n",
+                    str_error(ret));
+                unregister_interrupt_handler(device, *handle);
+        }
+        return ret;
+}
+
+/** IRQ handling callback, forward status from call to diver structure.
+ *
+ * @param[in] dev DDF instance of the device to use.
+ * @param[in] call Pointer to the call from kernel.
+ */
+void ddf_hcd_gen_irq_handler(ipc_call_t *call, ddf_dev_t *dev)
+{
+        assert(dev);
+        hcd_t *hcd = dev_to_hcd(dev);
+        if (!hcd || !hcd->ops.irq_hook) {
+                usb_log_error("Interrupt on not yet initialized device.\n");
+                return;
+        }
+        const uint32_t status = IPC_GET_ARG1(*call);
+        hcd->ops.irq_hook(hcd, status);
+}
+
+static int interrupt_polling(void *arg)
+{
+        hcd_t *hcd = arg;
+        assert(hcd);
+        if (!hcd->ops.status_hook || !hcd->ops.irq_hook)
+                return ENOTSUP;
+        uint32_t status = 0;
+        while (hcd->ops.status_hook(hcd, &status) == EOK) {
+                hcd->ops.irq_hook(hcd, status);
+                status = 0;
+                /* We should wait 1 frame - 1ms here, but this polling is a
+                 * lame crutch anyway so don't hog the system. 10ms is still
+                 * good enough for emergency mode */
+                async_usleep(10000);
+        }
+        return EOK;
+}
+
+/** Initialize hc and rh DDF structures and their respective drivers.
+ *
+ * @param device DDF instance of the device to use
+ * @param speed Maximum supported speed
+ * @param bw Available bandwidth (arbitrary units)
+ * @param bw_count Bandwidth computing function
+ * @param irq_handler IRQ handling function
+ * @param gen_irq_code Function to generate IRQ pseudocode
+ *                     (it needs to return used irq number)
+ * @param driver_init Function to initialize HC driver
+ * @param driver_fini Function to cleanup HC driver
+ * @return Error code
+ *
+ * This function does all the preparatory work for hc and rh drivers:
+ *  - gets device's hw resources
+ *  - attempts to enable interrupts
+ *  - registers interrupt handler
+ *  - calls driver specific initialization
+ *  - registers root hub
+ */
+int hcd_ddf_add_hc(ddf_dev_t *device, const ddf_hc_driver_t *driver)
+{
+        assert(driver);
+        static const struct { size_t bw; bw_count_func_t bw_count; }bw[] = {
+            [USB_SPEED_FULL] = { .bw = BANDWIDTH_AVAILABLE_USB11,
+                                 .bw_count = bandwidth_count_usb11 },
+            [USB_SPEED_HIGH] = { .bw = BANDWIDTH_AVAILABLE_USB11,
+                                 .bw_count = bandwidth_count_usb11 },
+        };
+
+        int ret = EOK;
+        const usb_speed_t speed = driver->hc_speed;
+        if (speed >= ARRAY_SIZE(bw) || bw[speed].bw == 0) {
+                usb_log_error("Driver `%s' reported unsupported speed: %s",
+                    driver->name, usb_str_speed(speed));
+                return ENOTSUP;
+        }
+
+        hw_res_list_parsed_t hw_res;
+        ret = hcd_ddf_get_registers(device, &hw_res);
+        if (ret != EOK) {
+                usb_log_error("Failed to get register memory addresses "
+                    "for `%s': %s.\n", ddf_dev_get_name(device),
+                    str_error(ret));
+                return ret;
+        }
+
+        ret = hcd_ddf_setup_hc(device, speed, bw[speed].bw, bw[speed].bw_count);
+        if (ret != EOK) {
+                usb_log_error("Failed to setup generic HCD.\n");
+                hw_res_list_parsed_clean(&hw_res);
+                return ret;
+        }
+
+        interrupt_handler_t *irq_handler =
+            driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
+        int irq_cap;
+        int irq_ret = hcd_ddf_setup_interrupts(device, &hw_res,
+            irq_handler, driver->irq_code_gen, &irq_cap);
+        bool irqs_enabled = (irq_ret == EOK);
+        if (irqs_enabled) {
+                usb_log_debug("Hw interrupts enabled.\n");
+        }
+
+        if (driver->claim) {
+                ret = driver->claim(device);
+                if (ret != EOK) {
+                        usb_log_error("Failed to claim `%s' for driver `%s'",
+                            ddf_dev_get_name(device), driver->name);
+                        return ret;
+                }
+        }
+
+
+        /* Init hw driver */
+        hcd_t *hcd = dev_to_hcd(device);
+        ret = driver->init(hcd, &hw_res, irqs_enabled);
+        hw_res_list_parsed_clean(&hw_res);
+        if (ret != EOK) {
+                usb_log_error("Failed to init HCD: %s.\n", str_error(ret));
+                goto irq_unregister;
+        }
+
+        /* Need working irq replacement to setup root hub */
+        if (!irqs_enabled && hcd->ops.status_hook) {
+                hcd->polling_fibril = fibril_create(interrupt_polling, hcd);
+                if (hcd->polling_fibril == 0) {
+                        usb_log_error("Failed to create polling fibril\n");
+                        ret = ENOMEM;
+                        goto irq_unregister;
+                }
+                fibril_add_ready(hcd->polling_fibril);
+                usb_log_warning("Failed to enable interrupts: %s."
+                    " Falling back to polling.\n", str_error(irq_ret));
+        }
+
+        /*
+         * Creating root hub registers a new USB device so HC
+         * needs to be ready at this time.
+         */
+        ret = hcd_ddf_setup_root_hub(device);
+        if (ret != EOK) {
+                usb_log_error("Failed to setup HC root hub: %s.\n",
+                    str_error(ret));
+                driver->fini(dev_to_hcd(device));
+irq_unregister:
+                /* Unregistering non-existent should be ok */
+                unregister_interrupt_handler(device, irq_cap);
+                hcd_ddf_clean_hc(device);
+                return ret;
+        }
+
+        usb_log_info("Controlling new `%s' device `%s'.\n",
+            driver->name, ddf_dev_get_name(device));
+        return EOK;
+}
 /**
  * @}