Changes in uspace/lib/usbhost/src/ddf_helpers.c [cccd60c3:41df71f9] in mainline

File:

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

uspace/lib/usbhost/src/ddf_helpers.c

@@ -35 +35 @@
 
 #include <usb/classes/classes.h>
+#include <usb/host/bus.h>
 #include <usb/debug.h>
 #include <usb/descriptor.h>
@@ -49 +50 @@
 #include <fibril_synch.h>
 #include <macros.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <str_error.h>
 #include <usb_iface.h>
+#include <usbhc_iface.h>
 
 #include "ddf_helpers.h"
-
-#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;
 
@@ -91 +78 @@
 
 
-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);
+static int hcd_ddf_new_device(hcd_t *hcd, ddf_dev_t *hc, device_t *hub_dev, unsigned port);
+static int hcd_ddf_remove_device(ddf_dev_t *device, device_t *hub, unsigned port);
 
 
@@ -99 +86 @@
 /** 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.
+ * @param endpoint_desc Endpoint description.
  * @return Error code.
  */
 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)
+        ddf_fun_t *fun, usb_endpoint_desc_t *endpoint_desc)
 {
         assert(fun);
         hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
-        usb_dev_t *dev = ddf_fun_data_get(fun);
+        device_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
-        assert(dev);
-        const size_t size = max_packet_size;
-        const usb_target_t target =
-            {{.address = dev->address, .endpoint = endpoint}};
+        assert(hcd->bus);
+        assert(dev);
 
         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.
- */
+                dev->address, endpoint_desc->endpoint_no,
+                usb_str_transfer_type(endpoint_desc->transfer_type),
+                usb_str_direction(endpoint_desc->direction),
+                endpoint_desc->max_packet_size, endpoint_desc->usb2.polling_interval);
+
+        return bus_add_endpoint(hcd->bus, dev, endpoint_desc, NULL);
+}
+
+ /** Unregister endpoint interface function.
+  * @param fun DDF function.
+  * @param endpoint_desc Endpoint description.
+  * @return Error code.
+  */
 static int unregister_endpoint(
-    ddf_fun_t *fun, usb_endpoint_t endpoint, usb_direction_t direction)
+        ddf_fun_t *fun, usb_endpoint_desc_t *endpoint_desc)
 {
         assert(fun);
         hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
-        usb_dev_t *dev = ddf_fun_data_get(fun);
+        device_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
-        assert(dev);
-        const usb_target_t target =
-            {{.address = dev->address, .endpoint = endpoint}};
+        assert(hcd->bus);
+        assert(dev);
+
+        const usb_target_t target = {{
+                .address = dev->address,
+                .endpoint = endpoint_desc->endpoint_no
+        }};
+
         usb_log_debug("Unregister endpoint %d:%d %s.\n",
-            dev->address, endpoint, usb_str_direction(direction));
-        return hcd_remove_ep(hcd, target, direction);
+                dev->address, endpoint_desc->endpoint_no,
+                usb_str_direction(endpoint_desc->direction));
+
+        endpoint_t *ep = bus_find_endpoint(hcd->bus, dev, target, endpoint_desc->direction);
+        if (!ep)
+                return ENOENT;
+
+        return bus_remove_endpoint(hcd->bus, ep);
 }
 
@@ -155 +143 @@
         assert(fun);
         hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
-        usb_dev_t *dev = ddf_fun_data_get(fun);
+        device_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
+        assert(hcd->bus);
         assert(dev);
 
         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);
+        return bus_reserve_default_address(hcd->bus, speed);
 }
 
@@ -168 +157 @@
         assert(fun);
         hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
-        usb_dev_t *dev = ddf_fun_data_get(fun);
+        device_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
+        assert(hcd->bus);
         assert(dev);
 
         usb_log_debug("Device %d released default address\n", dev->address);
-        return hcd_release_default_address(hcd);
+        return bus_release_default_address(hcd->bus);
 }
 
@@ -179 +169 @@
 {
         assert(fun);
+        ddf_dev_t *hc = ddf_fun_get_dev(fun);
+        assert(hc);
+        hcd_t *hcd = dev_to_hcd(hc);
+        assert(hcd);
+        device_t *hub = ddf_fun_data_get(fun);
+        assert(hub);
+
+        usb_log_debug("Hub %d reported a new USB device on port: %u\n",
+            hub->address, port);
+        return hcd_ddf_new_device(hcd, hc, hub, port);
+}
+
+static int device_remove(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);
-}
-
-static int device_remove(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);
+        device_t *dev = ddf_fun_data_get(fun);
         assert(ddf_dev);
         assert(dev);
@@ -224 +217 @@
  * @return Error code.
  */
-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);
-        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");
+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)
+{
+        assert(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(dev);
+
+        target.address = dev->address;
+
+        return hcd_send_batch(hcd, dev, target, USB_DIRECTION_IN,
+            data, size, setup_data,
+            callback, arg, "READ");
 }
 
@@ -250 +243 @@
  * @return Error code.
  */
-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);
-        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,
+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)
+{
+        assert(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(dev);
+
+        target.address = dev->address;
+
+        return hcd_send_batch(hcd, dev, target, USB_DIRECTION_OUT,
+            (char *) data, size, setup_data,
             callback, arg, "WRITE");
 }
@@ -269 +262 @@
 static usb_iface_t usb_iface = {
         .get_my_device_handle = get_my_device_handle,
-
+};
+
+/** USB host controller interface */
+static usbhc_iface_t usbhc_iface = {
         .reserve_default_address = reserve_default_address,
         .release_default_address = release_default_address,
@@ -286 +282 @@
 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, ...) \
@@ -394 +313 @@
         assert(l);
         assert(d);
-        
+
         if (d->vendor_id != 0) {
                 /* First, with release number. */
@@ -401 +320 @@
                     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",
@@ -415 +334 @@
 
         return EOK;
-
-}
-
-static int hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub,
+}
+
+static int hcd_ddf_remove_device(ddf_dev_t *device, device_t *hub,
     unsigned port)
 {
@@ -425 +343 @@
         hcd_t *hcd = dev_to_hcd(device);
         assert(hcd);
+        assert(hcd->bus);
 
         hc_dev_t *hc_dev = dev_to_hc_dev(device);
@@ -431 +350 @@
         fibril_mutex_lock(&hub->guard);
 
-        usb_dev_t *victim = NULL;
-
-        list_foreach(hub->devices, link, usb_dev_t, it) {
+        device_t *victim = NULL;
+
+        list_foreach(hub->devices, link, device_t, it) {
                 if (it->port == port) {
                         victim = it;
@@ -440 +359 @@
         }
         if (victim) {
+                assert(victim->fun);
                 assert(victim->port == port);
+                assert(victim->hub == hub);
                 list_remove(&victim->link);
                 fibril_mutex_unlock(&hub->guard);
@@ -446 +367 @@
                 if (ret == EOK) {
                         usb_address_t address = victim->address;
+                        bus_remove_device(hcd->bus, hcd, victim);
                         ddf_fun_destroy(victim->fun);
-                        hcd_release_address(hcd, address);
+                        bus_release_address(hcd->bus, address);
                 } else {
                         usb_log_warning("Failed to unbind device `%s': %s\n",
@@ -458 +380 @@
 }
 
-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,
+device_t *hcd_ddf_device_create(ddf_dev_t *hc, size_t device_size)
+{
+        /* Create DDF function for the new device */
+        ddf_fun_t *fun = ddf_fun_create(hc, 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, device_size);
+        if (!dev) {
+                ddf_fun_destroy(fun);
+                return NULL;
+        }
+
+        device_init(dev);
+        dev->fun = fun;
+        return dev;
+}
+
+void hcd_ddf_device_destroy(device_t *dev)
+{
+        assert(dev);
+        assert(dev->fun);
+        ddf_fun_destroy(dev->fun);
+}
+
+int hcd_ddf_device_explore(hcd_t *hcd, device_t *device)
+{
+        int err;
+        match_id_list_t mids;
+        usb_standard_device_descriptor_t desc = { 0 };
+
+        init_match_ids(&mids);
+
+        const usb_target_t control_ep = {{
+                .address = device->address,
                 .endpoint = 0,
         }};
-
-        const usb_address_t address = hcd_request_address(hcd, speed);
-        if (address < 0) {
-                usb_log_error("Failed to reserve new address: %s.",
-                    str_error(address));
-                return address;
-        }
-
-        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);
-        ssize_t got = 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");
-
-        if (got != CTRL_PIPE_MIN_PACKET_SIZE) {
-                ret = got < 0 ? got : EOVERFLOW;
-                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);
-        got = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_OUT,
-            NULL, 0, *(uint64_t *)&set_address, "set address");
-
-        usb_log_debug("Device(%d): Removing default (0:0) EP.", address);
-        hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
-
-        if (got != 0) {
-                usb_log_error("Device(%d): Failed to set new address: %s.",
-                    address, str_error(got));
-                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
-                hcd_release_address(hcd, address);
-                return got;
-        }
 
         /* Get std device descriptor */
@@ -571 +426 @@
 
         usb_log_debug("Device(%d): Requesting full device descriptor.",
-            address);
-        got = hcd_send_batch_sync(hcd, target, USB_DIRECTION_IN,
-            &desc, sizeof(desc), *(uint64_t *)&get_device_desc,
+            device->address);
+        ssize_t got = hcd_send_batch_sync(hcd, device, control_ep, USB_DIRECTION_IN,
+            (char *) &desc, sizeof(desc), *(uint64_t *)&get_device_desc,
             "read device descriptor");
-        if (ret != EOK) {
+        if (got < 0) {
+                err = got < 0 ? got : EOVERFLOW;
                 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;
+                    device->address, str_error(err));
+                goto out;
         }
 
         /* Create match ids from the device descriptor */
-        match_id_list_t mids;
-        init_match_ids(&mids);
-
-        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);
+        usb_log_debug("Device(%d): Creating match IDs.", device->address);
+        if ((err = create_match_ids(&mids, &desc))) {
+                usb_log_error("Device(%d): Failed to create match ids: %s", device->address, str_error(err));
+                goto out;
+        }
+
+        list_foreach(mids.ids, link, const match_id_t, mid) {
+                ddf_fun_add_match_id(device->fun, mid->id, mid->score);
+        }
+
+out:
         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;
+        return err;
+}
+
+int hcd_ddf_device_online(ddf_fun_t *fun)
+{
+        assert(fun);
+
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(dev);
+        assert(hcd->bus);
+
+        usb_log_info("Device(%d): Requested to be brought online.", dev->address);
+
+        return bus_online_device(hcd->bus, hcd, dev);
+}
+
+int hcd_ddf_device_offline(ddf_fun_t *fun)
+{
+        assert(fun);
+
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(dev);
+        assert(hcd->bus);
+
+        usb_log_info("Device(%d): Requested to be taken offline.", dev->address);
+
+        return bus_offline_device(hcd->bus, hcd, dev);
+}
+
+static int hcd_ddf_new_device(hcd_t *hcd, ddf_dev_t *hc, device_t *hub, unsigned port)
+{
+        int err;
+        assert(hcd);
+        assert(hcd->bus);
+        assert(hub);
+        assert(hc);
+
+        device_t *dev = hcd_ddf_device_create(hc, hcd->bus->device_size);
+        if (!dev) {
+                usb_log_error("Failed to create USB device function.");
+                return ENOMEM;
+        }
+
+        dev->hub = hub;
+        dev->port = port;
+
+        if ((err = bus_enumerate_device(hcd->bus, hcd, dev))) {
+                usb_log_error("Failed to initialize USB dev memory structures.");
+                return err;
+        }
+
+        /* If the driver didn't name the dev when enumerating,
+         * do it in some generic way.
+         */
+        if (!ddf_fun_get_name(dev->fun)) {
+                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;
+        }
+
+        fibril_mutex_lock(&hub->guard);
+        list_append(&dev->link, &hub->devices);
+        fibril_mutex_unlock(&hub->guard);
+
+        return EOK;
+
+err_usb_dev:
+        hcd_ddf_device_destroy(dev);
+        return err;
 }
 
@@ -616 +531 @@
  * @return Error code
  */
-int hcd_ddf_setup_root_hub(ddf_dev_t *device)
-{
-        assert(device);
-        hcd_t *hcd = dev_to_hcd(device);
+int hcd_setup_virtual_root_hub(hcd_t *hcd, ddf_dev_t *hc)
+{
+        int err;
+
+        assert(hc);
         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;
+        assert(hcd->bus);
+
+        if ((err = bus_reserve_default_address(hcd->bus, USB_SPEED_MAX))) {
+                usb_log_error("Failed to reserve default address for roothub setup: %s", str_error(err));
+                return err;
+        }
+
+        device_t *dev = hcd_ddf_device_create(hc, hcd->bus->device_size);
+        if (!dev) {
+                usb_log_error("Failed to create function for the root hub.");
+                goto err_default_address;
+        }
+
+        ddf_fun_set_name(dev->fun, "roothub");
+
+        /* Assign an address to the device */
+        if ((err = bus_enumerate_device(hcd->bus, hcd, dev))) {
+                usb_log_error("Failed to enumerate roothub device: %s", str_error(err));
+                goto err_usb_dev;
+        }
+
+        if ((err = ddf_fun_bind(dev->fun))) {
+                usb_log_error("Failed to register roothub: %s.", str_error(err));
+                goto err_usb_dev;
+        }
+
+        bus_release_default_address(hcd->bus);
+        return EOK;
+
+err_usb_dev:
+        hcd_ddf_device_destroy(dev);
+err_default_address:
+        bus_release_default_address(hcd->bus);
+        return err;
 }
 
@@ -638 +583 @@
  * This function does all the ddf work for hc driver.
  */
-int hcd_ddf_setup_hc(ddf_dev_t *device, usb_speed_t max_speed,
-    size_t bw, bw_count_func_t bw_count)
+int hcd_ddf_setup_hc(ddf_dev_t *device)
 {
         assert(device);
@@ -648 +592 @@
                 return ENOMEM;
         }
-        instance->root_hub = NULL;
-        hcd_init(&instance->hcd, max_speed, bw, bw_count);
+        hcd_init(&instance->hcd);
 
         int ret = ENOMEM;
@@ -748 +691 @@
     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 *hw_res))
-{
-
+    irq_code_gen_t gen_irq_code)
+{
         assert(device);
+
+        hcd_t *hcd = dev_to_hcd(device);
+
         if (!handler || !gen_irq_code)
                 return ENOTSUP;
@@ -757 +702 @@
         irq_code_t irq_code = {0};
 
-        const int irq = gen_irq_code(&irq_code, hw_res);
+        const int irq = gen_irq_code(&irq_code, hcd, hw_res);
         if (irq < 0) {
                 usb_log_error("Failed to generate IRQ code: %s.\n",
@@ -777 +722 @@
         int ret = hcd_ddf_enable_interrupt(device, irq);
         if (ret != EOK) {
-                usb_log_error("Failed to register interrupt handler: %s.\n",
+                usb_log_error("Failed to enable interrupts: %s.\n",
                     str_error(ret));
                 unregister_interrupt_handler(device, irq_cap);
@@ -844 +789 @@
 {
         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;
@@ -868 +801 @@
         }
 
-        ret = hcd_ddf_setup_hc(device, speed, bw[speed].bw, bw[speed].bw_count);
+        ret = hcd_ddf_setup_hc(device);
         if (ret != EOK) {
                 usb_log_error("Failed to setup generic HCD.\n");
-                hw_res_list_parsed_clean(&hw_res);
-                return ret;
-        }
-
+                goto err_hw_res;
+        }
+
+        hcd_t *hcd = dev_to_hcd(device);
+
+        if (driver->init)
+                ret = driver->init(hcd, &hw_res, device);
+        if (ret != EOK) {
+                usb_log_error("Failed to init HCD.\n");
+                goto err_hcd;
+        }
+
+        /* Setup interrupts  */
         interrupt_handler_t *irq_handler =
             driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
@@ -884 +826 @@
         }
 
+        /* Claim the device from BIOS */
         if (driver->claim)
-                ret = driver->claim(device);
+                ret = driver->claim(hcd, 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);
+                usb_log_error("Failed to claim `%s' for driver `%s': %s",
+                    ddf_dev_get_name(device), driver->name, str_error(ret));
+                goto err_irq;
+        }
+
+        /* Start hw driver */
+        if (driver->start)
+                ret = driver->start(hcd, irqs_enabled);
         if (ret != EOK) {
-                usb_log_error("Failed to init HCD: %s.\n", str_error(ret));
-                goto irq_unregister;
+                usb_log_error("Failed to start HCD: %s.\n", str_error(ret));
+                goto err_irq;
         }
 
@@ -908 +849 @@
                         usb_log_error("Failed to create polling fibril\n");
                         ret = ENOMEM;
-                        goto irq_unregister;
+                        goto err_started;
                 }
                 fibril_add_ready(hcd->polling_fibril);
@@ -919 +860 @@
          * needs to be ready at this time.
          */
-        ret = hcd_ddf_setup_root_hub(device);
+        if (driver->setup_root_hub)
+                ret = driver->setup_root_hub(hcd, 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;
+                goto err_polling;
         }
 
@@ -934 +871 @@
             driver->name, ddf_dev_get_name(device));
         return EOK;
-}
+
+err_polling:
+        // TODO: Stop the polling fibril (refactor the interrupt_polling func)
+        //
+err_started:
+        if (driver->stop)
+                driver->stop(hcd);
+err_irq:
+        unregister_interrupt_handler(device, irq_cap);
+        if (driver->fini)
+                driver->fini(hcd);
+err_hcd:
+        hcd_ddf_clean_hc(device);
+err_hw_res:
+        hw_res_list_parsed_clean(&hw_res);
+        return ret;
+}
+
 /**
  * @}