Changeset 32fb6bce in mainline for uspace/drv

Timestamp:

2017-12-18T22:50:21Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

7f70d1c

Parents:

1ea0bbf

git-author:

Ondřej Hlavatý <aearsis@…> (2017-12-18 22:04:50)

git-committer:

Ondřej Hlavatý <aearsis@…> (2017-12-18 22:50:21)

Message:

usbhost: refactoring

This commit moves interrupt, status and schedule to bus
operations. Then the purpose of hcd_t is better defined, and split into
hc_driver_t and hc_device_t. hc_driver_t is used to wrap driver
implementation by the library (similar to how usb_driver_t is used to
wrap usb device drivers). hc_device_t is used as a parent for hc_t
inside drivers, and is allocated inside the DDF device node.

To support these changes, some local identifiers were renamed, some
functions were moved and/or renamed and their arguments changed. The
most notable one being hcd_send_batch → bus_device_send_batch.

Location:

uspace/drv/bus/usb

Files:

• ehci/ehci_bus.c (modified) (3 diffs)
• ehci/ehci_bus.h (modified) (1 diff)
• ehci/hc.c (modified) (10 diffs)
• ehci/hc.h (modified) (2 diffs)
• ehci/main.c (modified) (3 diffs)
• ehci/res.c (modified) (2 diffs)
• ehci/res.h (modified) (1 diff)
• ohci/hc.c (modified) (19 diffs)
• ohci/hc.h (modified) (3 diffs)
• ohci/main.c (modified) (2 diffs)
• ohci/ohci_bus.c (modified) (2 diffs)
• ohci/ohci_bus.h (modified) (1 diff)
• uhci/hc.c (modified) (12 diffs)
• uhci/hc.h (modified) (3 diffs)
• uhci/main.c (modified) (4 diffs)
• vhc/main.c (modified) (2 diffs)
• vhc/transfer.c (modified) (5 diffs)
• vhc/vhcd.h (modified) (3 diffs)
• xhci/bus.c (modified) (5 diffs)
• xhci/hc.c (modified) (3 diffs)
• xhci/hc.h (modified) (4 diffs)
• xhci/main.c (modified) (2 diffs)
• xhci/rh.c (modified) (2 diffs)

uspace/drv/bus/usb/ehci/ehci_bus.c

@@ -162 +162 @@
         .parent = &usb2_bus_ops,
 
+        .interrupt = ehci_hc_interrupt,
+        .status = ehci_hc_status,
         .endpoint_destroy = ehci_endpoint_destroy,
         .endpoint_create = ehci_endpoint_create,
@@ -171 +173 @@
         .batch_create = ehci_create_batch,
         .batch_destroy = ehci_destroy_batch,
+        .batch_schedule = ehci_hc_schedule,
 };
 
-int ehci_bus_init(ehci_bus_t *bus, hcd_t *hcd, hc_t *hc)
+int ehci_bus_init(ehci_bus_t *bus, hc_t *hc)
 {
         assert(hc);
@@ -181 +184 @@
         bus_t *bus_base = (bus_t *) bus;
 
-        usb2_bus_init(usb2_bus, hcd, BANDWIDTH_AVAILABLE_USB11);
+        usb2_bus_init(usb2_bus, BANDWIDTH_AVAILABLE_USB11);
         bus_base->ops = &ehci_bus_ops;
 

uspace/drv/bus/usb/ehci/ehci_bus.h

@@ -63 +63 @@
 void ehci_bus_prepare_ops(void);
 
-int ehci_bus_init(ehci_bus_t *, hcd_t *, hc_t *);
+int ehci_bus_init(ehci_bus_t *, hc_t *);
 
 /** Get and convert assigned ehci_endpoint_t structure
  * @param[in] ep USBD endpoint structure.
- * @return Pointer to assigned hcd endpoint structure
+ * @return Pointer to assigned ehci endpoint structure
  */
 static inline ehci_endpoint_t * ehci_endpoint_get(const endpoint_t *ep)

uspace/drv/bus/usb/ehci/hc.c

@@ -97 +97 @@
  * @return Error code.
  */
-int ehci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
+int hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
 {
         assert(code);
         assert(hw_res);
-
-        hc_t *instance = hcd_get_driver_data(hcd);
+        hc_t *instance = hcd_to_hc(hcd);
 
         if (hw_res->irqs.count != 1 || hw_res->mem_ranges.count != 1)
@@ -149 +148 @@
  * @return Error code
  */
-int hc_init(hc_t *instance, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
-{
-        assert(instance);
+int hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         assert(hw_res);
         if (hw_res->mem_ranges.count != 1 ||
@@ -190 +189 @@
             &instance->rh, instance->caps, instance->registers, "ehci rh");
 
-        ehci_bus_init(&instance->bus, hcd, instance);
+        ehci_bus_init(&instance->bus, instance);
+        hc_device_setup(hcd, (bus_t *) &instance->bus);
         return EOK;
 }
@@ -198 +198 @@
  * @param[in] instance Host controller structure to use.
  */
-void hc_fini(hc_t *instance)
+int hc_gone(hc_device_t *instance)
 {
         assert(instance);
+        return EOK;
         //TODO: stop the hw
 #if 0
@@ -263 +264 @@
 }
 
-int ehci_hc_status(hcd_t *hcd, uint32_t *status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+int ehci_hc_status(bus_t *bus_base, uint32_t *status)
+{
+        assert(bus_base);
         assert(status);
+
+        ehci_bus_t *bus = (ehci_bus_t *) bus_base;
+        hc_t *hc = bus->hc;
+        assert(hc);
+
         *status = 0;
-        if (instance->registers) {
-                *status = EHCI_RD(instance->registers->usbsts);
-                EHCI_WR(instance->registers->usbsts, *status);
-        }
-        usb_log_debug2("HC(%p): Read status: %x", instance, *status);
+        if (hc->registers) {
+                *status = EHCI_RD(hc->registers->usbsts);
+                EHCI_WR(hc->registers->usbsts, *status);
+        }
+        usb_log_debug2("HC(%p): Read status: %x", hc, *status);
         return EOK;
 }
@@ -284 +288 @@
  * @return Error code.
  */
-int ehci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+int ehci_hc_schedule(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+
+        ehci_bus_t *bus = (ehci_bus_t *) endpoint_get_bus(batch->ep);
+        hc_t *hc = bus->hc;
+        assert(hc);
 
         /* Check for root hub communication */
-        if (batch->target.address == ehci_rh_get_address(&instance->rh)) {
+        if (batch->target.address == ehci_rh_get_address(&hc->rh)) {
                 usb_log_debug("HC(%p): Scheduling BATCH(%p) for RH(%p)",
-                    instance, batch, &instance->rh);
-                return ehci_rh_schedule(&instance->rh, batch);
+                    hc, batch, &hc->rh);
+                return ehci_rh_schedule(&hc->rh, batch);
         }
 
@@ -303 +309 @@
                 return err;
 
-        fibril_mutex_lock(&instance->guard);
-        usb_log_debug2("HC(%p): Appending BATCH(%p)", instance, batch);
-        list_append(&ehci_batch->link, &instance->pending_batches);
-        usb_log_debug("HC(%p): Committing BATCH(%p)", instance, batch);
+        fibril_mutex_lock(&hc->guard);
+        usb_log_debug2("HC(%p): Appending BATCH(%p)", hc, batch);
+        list_append(&ehci_batch->link, &hc->pending_batches);
+        usb_log_debug("HC(%p): Committing BATCH(%p)", hc, batch);
         ehci_transfer_batch_commit(ehci_batch);
 
-        fibril_mutex_unlock(&instance->guard);
+        fibril_mutex_unlock(&hc->guard);
         return EOK;
 }
@@ -318 +324 @@
  * @param[in] status Value of the status register at the time of interrupt.
  */
-void ehci_hc_interrupt(hcd_t *hcd, uint32_t status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        status = EHCI_RD(status);
-        assert(instance);
-
-        usb_log_debug2("HC(%p): Interrupt: %"PRIx32, instance, status);
+void ehci_hc_interrupt(bus_t *bus_base, uint32_t status)
+{
+        assert(bus_base);
+
+        ehci_bus_t *bus = (ehci_bus_t *) bus_base;
+        hc_t *hc = bus->hc;
+        assert(hc);
+
+        usb_log_debug2("HC(%p): Interrupt: %"PRIx32, hc, status);
         if (status & USB_STS_PORT_CHANGE_FLAG) {
-                ehci_rh_interrupt(&instance->rh);
+                ehci_rh_interrupt(&hc->rh);
         }
 
         if (status & USB_STS_IRQ_ASYNC_ADVANCE_FLAG) {
-                fibril_mutex_lock(&instance->guard);
-                usb_log_debug2("HC(%p): Signaling doorbell", instance);
-                fibril_condvar_broadcast(&instance->async_doorbell);
-                fibril_mutex_unlock(&instance->guard);
+                fibril_mutex_lock(&hc->guard);
+                usb_log_debug2("HC(%p): Signaling doorbell", hc);
+                fibril_condvar_broadcast(&hc->async_doorbell);
+                fibril_mutex_unlock(&hc->guard);
         }
 
         if (status & (USB_STS_IRQ_FLAG | USB_STS_ERR_IRQ_FLAG)) {
-                fibril_mutex_lock(&instance->guard);
-
-                usb_log_debug2("HC(%p): Scanning %lu pending batches", instance,
-                        list_count(&instance->pending_batches));
-                list_foreach_safe(instance->pending_batches, current, next) {
+                fibril_mutex_lock(&hc->guard);
+
+                usb_log_debug2("HC(%p): Scanning %lu pending batches", hc,
+                        list_count(&hc->pending_batches));
+                list_foreach_safe(hc->pending_batches, current, next) {
                         ehci_transfer_batch_t *batch =
                             ehci_transfer_batch_from_link(current);
@@ -351 +358 @@
                         }
                 }
-                fibril_mutex_unlock(&instance->guard);
+                fibril_mutex_unlock(&hc->guard);
         }
 
         if (status & USB_STS_HOST_ERROR_FLAG) {
-                usb_log_fatal("HCD(%p): HOST SYSTEM ERROR!", instance);
+                usb_log_fatal("HCD(%p): HOST SYSTEM ERROR!", hc);
                 //TODO do something here
         }
@@ -364 +371 @@
  * @param[in] instance EHCI hc driver structure.
  */
-int hc_start(hc_t *instance, bool interrupts)
-{
-        assert(instance);
+int hc_start(hc_device_t *hcd)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         usb_log_debug("HC(%p): Starting HW.", instance);
 

uspace/drv/bus/usb/ehci/hc.h

@@ -55 +55 @@
 /** Main EHCI driver structure */
 typedef struct hc {
+        /* Common device header */
+        hc_device_t base;
+
         /** Memory mapped CAPS register area */
         ehci_caps_regs_t *caps;
@@ -85 +88 @@
 } hc_t;
 
-int hc_init(hc_t *instance, hcd_t *hcd, const hw_res_list_parsed_t *hw_res);
-int hc_start(hc_t *instance, bool interrupts);
-void hc_fini(hc_t *instance);
+static inline hc_t *hcd_to_hc(hc_device_t *hcd)
+{
+        assert(hcd);
+        return (hc_t *) hcd;
+}
 
-void hc_enqueue_endpoint(hc_t *instance, const endpoint_t *ep);
-void hc_dequeue_endpoint(hc_t *instance, const endpoint_t *ep);
+void hc_enqueue_endpoint(hc_t *, const endpoint_t *);
+void hc_dequeue_endpoint(hc_t *, const endpoint_t *);
 
-int ehci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res);
+/* Boottime operations */
+int hc_add(hc_device_t *, const hw_res_list_parsed_t *);
+int hc_start(hc_device_t *);
+int hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *);
+int hc_gone(hc_device_t *);
 
-void ehci_hc_interrupt(hcd_t *hcd, uint32_t status);
-int ehci_hc_status(hcd_t *hcd, uint32_t *status);
-int ehci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch);
+/** Runtime operations */
+void ehci_hc_interrupt(bus_t *, uint32_t);
+int ehci_hc_status(bus_t *, uint32_t *);
+int ehci_hc_schedule(usb_transfer_batch_t *);
+
 #endif
 /**

uspace/drv/bus/usb/ehci/main.c

@@ -35 +35 @@
  */
 
-#include <ddf/driver.h>
-#include <ddf/interrupt.h>
-#include <device/hw_res.h>
-#include <errno.h>
-#include <str_error.h>
 #include <io/logctl.h>
-
-#include <usb_iface.h>
-#include <usb/debug.h>
+#include <usb/host/hcd.h>
 #include <usb/host/ddf_helpers.h>
 
@@ -51 +44 @@
 #define NAME "ehci"
 
-static int ehci_driver_init(hcd_t *, const hw_res_list_parsed_t *, ddf_dev_t *);
-static int ehci_driver_claim(hcd_t *, ddf_dev_t *);
-static int ehci_driver_start(hcd_t *, bool);
-static void ehci_driver_fini(hcd_t *);
+static const hc_driver_t ehci_driver = {
+        .name = NAME,
+        .hc_device_size = sizeof(hc_t),
 
-static const ddf_hc_driver_t ehci_hc_driver = {
-        .name = "EHCI-PCI",
-        .init = ehci_driver_init,
-        .irq_code_gen = ehci_hc_gen_irq_code,
-        .claim = ehci_driver_claim,
-        .start = ehci_driver_start,
+        .hc_add = hc_add,
+        .irq_code_gen = hc_gen_irq_code,
+        .claim = disable_legacy,
+        .start = hc_start,
         .setup_root_hub = hcd_setup_virtual_root_hub,
-        .fini = ehci_driver_fini,
-        .ops = {
-                .schedule       = ehci_hc_schedule,
-                .irq_hook       = ehci_hc_interrupt,
-                .status_hook    = ehci_hc_status,
-        }
+        .hc_gone = hc_gone,
 };
-
-
-static int ehci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res, ddf_dev_t *device)
-{
-        assert(hcd);
-        assert(hcd_get_driver_data(hcd) == NULL);
-
-        hc_t *instance = malloc(sizeof(hc_t));
-        if (!instance)
-                return ENOMEM;
-
-        const int ret = hc_init(instance, hcd, res);
-        if (ret == EOK) {
-                hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops, &instance->bus.base.base);
-        } else {
-                free(instance);
-        }
-        return ret;
-}
-
-static int ehci_driver_claim(hcd_t *hcd, ddf_dev_t *dev)
-{
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
-
-        return disable_legacy(instance, dev);
-}
-
-static int ehci_driver_start(hcd_t *hcd, bool irq) {
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
-
-        return hc_start(instance, irq);
-}
-
-static void ehci_driver_fini(hcd_t *hcd)
-{
-        assert(hcd);
-        hc_t *hc = hcd_get_driver_data(hcd);
-        if (hc)
-                hc_fini(hc);
-
-        free(hc);
-        hcd_set_implementation(hcd, NULL, NULL, NULL);
-}
-
-/** Initializes a new ddf driver instance of EHCI hcd.
- *
- * @param[in] device DDF instance of the device to initialize.
- * @return Error code.
- */
-static int ehci_dev_add(ddf_dev_t *device)
-{
-        usb_log_debug("ehci_dev_add() called\n");
-        assert(device);
-
-        return hcd_ddf_add_hc(device, &ehci_hc_driver);
-
-}
-
-static int ehci_fun_online(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_online(fun);
-}
-
-static int ehci_fun_offline(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_offline(fun);
-}
-
-
-static const driver_ops_t ehci_driver_ops = {
-        .dev_add = ehci_dev_add,
-        .fun_online = ehci_fun_online,
-        .fun_offline = ehci_fun_offline
-};
-
-static const driver_t ehci_driver = {
-        .name = NAME,
-        .driver_ops = &ehci_driver_ops
-};
-
 
 /** Initializes global driver structures (NONE).
@@ -165 +68 @@
         log_init(NAME);
         logctl_set_log_level(NAME, LVL_NOTE);
-        return ddf_driver_main(&ehci_driver);
+        return hc_driver_main(&ehci_driver);
 }
 

uspace/drv/bus/usb/ehci/res.c

@@ -45 +45 @@
 #include <pci_dev_iface.h>
 
+#include "hc.h"
 #include "res.h"
 #include "ehci_regs.h"
@@ -172 +173 @@
 }
 
-int disable_legacy(hc_t *hc, ddf_dev_t *device)
+int disable_legacy(hc_device_t *hcd)
 {
-        assert(device);
-
-        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
+        hc_t *hc = hcd_to_hc(hcd);
+
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(hcd->ddf_dev);
         if (parent_sess == NULL)
                 return ENOMEM;

uspace/drv/bus/usb/ehci/res.h

@@ -36 +36 @@
 #define DRV_EHCI_PCI_H
 
-#include <ddf/driver.h>
-#include <device/hw_res_parsed.h>
+typedef struct hc_device hc_device_t;
 
-#include "hc.h"
-
-extern int disable_legacy(hc_t *, ddf_dev_t *);
+extern int disable_legacy(hc_device_t *);
 
 #endif

uspace/drv/bus/usb/ohci/hc.c

@@ -101 +101 @@
  * @return Error code.
  */
-int ohci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
+int hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
 {
         assert(code);
@@ -149 +149 @@
  * @return Error code
  */
-int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res)
-{
-        assert(instance);
+int hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         assert(hw_res);
         if (hw_res->mem_ranges.count != 1 ||
@@ -186 +186 @@
  * @param[in] instance Host controller structure to use.
  */
-void hc_fini(hc_t *instance)
+int hc_gone(hc_device_t *instance)
 {
         assert(instance);
         /* TODO: implement*/
-};
+        return ENOTSUP;
+}
 
 void hc_enqueue_endpoint(hc_t *instance, const endpoint_t *ep)
@@ -260 +261 @@
 }
 
-int ohci_hc_status(hcd_t *hcd, uint32_t *status)
-{
-        assert(hcd);
+int ohci_hc_status(bus_t *bus_base, uint32_t *status)
+{
+        assert(bus_base);
         assert(status);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
-
-        if (instance->registers){
-                *status = OHCI_RD(instance->registers->interrupt_status);
-                OHCI_WR(instance->registers->interrupt_status, *status);
+
+        ohci_bus_t *bus = (ohci_bus_t *) bus_base;
+        hc_t *hc = bus->hc;
+        assert(hc);
+
+        if (hc->registers){
+                *status = OHCI_RD(hc->registers->interrupt_status);
+                OHCI_WR(hc->registers->interrupt_status, *status);
         }
         return EOK;
@@ -280 +283 @@
  * @return Error code.
  */
-int ohci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+int ohci_hc_schedule(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+
+        ohci_bus_t *bus = (ohci_bus_t *) endpoint_get_bus(batch->ep);
+        hc_t *hc = bus->hc;
+        assert(hc);
 
         /* Check for root hub communication */
-        if (batch->target.address == ohci_rh_get_address(&instance->rh)) {
+        if (batch->target.address == ohci_rh_get_address(&hc->rh)) {
                 usb_log_debug("OHCI root hub request.\n");
-                return ohci_rh_schedule(&instance->rh, batch);
+                return ohci_rh_schedule(&hc->rh, batch);
         }
         ohci_transfer_batch_t *ohci_batch = ohci_transfer_batch_get(batch);
@@ -299 +304 @@
                 return err;
 
-        fibril_mutex_lock(&instance->guard);
-        list_append(&ohci_batch->link, &instance->pending_batches);
+        fibril_mutex_lock(&hc->guard);
+        list_append(&ohci_batch->link, &hc->pending_batches);
         ohci_transfer_batch_commit(ohci_batch);
 
@@ -307 +312 @@
         {
         case USB_TRANSFER_CONTROL:
-                OHCI_SET(instance->registers->command_status, CS_CLF);
+                OHCI_SET(hc->registers->command_status, CS_CLF);
                 break;
         case USB_TRANSFER_BULK:
-                OHCI_SET(instance->registers->command_status, CS_BLF);
+                OHCI_SET(hc->registers->command_status, CS_BLF);
                 break;
         default:
                 break;
         }
-        fibril_mutex_unlock(&instance->guard);
+        fibril_mutex_unlock(&hc->guard);
         return EOK;
 }
@@ -324 +329 @@
  * @param[in] status Value of the status register at the time of interrupt.
  */
-void ohci_hc_interrupt(hcd_t *hcd, uint32_t status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
+void ohci_hc_interrupt(bus_t *bus_base, uint32_t status)
+{
+        assert(bus_base);
+
+        ohci_bus_t *bus = (ohci_bus_t *) bus_base;
+        hc_t *hc = bus->hc;
+        assert(hc);
+
         status = OHCI_RD(status);
-        assert(instance);
+        assert(hc);
         if ((status & ~I_SF) == 0) /* ignore sof status */
                 return;
-        usb_log_debug2("OHCI(%p) interrupt: %x.\n", instance, status);
+        usb_log_debug2("OHCI(%p) interrupt: %x.\n", hc, status);
         if (status & I_RHSC)
-                ohci_rh_interrupt(&instance->rh);
+                ohci_rh_interrupt(&hc->rh);
 
         if (status & I_WDH) {
-                fibril_mutex_lock(&instance->guard);
-                usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).\n", instance->hcca,
-                    OHCI_RD(instance->registers->hcca),
-                    (void *) addr_to_phys(instance->hcca));
+                fibril_mutex_lock(&hc->guard);
+                usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).\n", hc->hcca,
+                    OHCI_RD(hc->registers->hcca),
+                    (void *) addr_to_phys(hc->hcca));
                 usb_log_debug2("Periodic current: %#" PRIx32 ".\n",
-                    OHCI_RD(instance->registers->periodic_current));
-
-                link_t *current = list_first(&instance->pending_batches);
-                while (current && current != &instance->pending_batches.head) {
+                    OHCI_RD(hc->registers->periodic_current));
+
+                link_t *current = list_first(&hc->pending_batches);
+                while (current && current != &hc->pending_batches.head) {
                         link_t *next = current->next;
                         ohci_transfer_batch_t *batch =
@@ -357 +366 @@
                         current = next;
                 }
-                fibril_mutex_unlock(&instance->guard);
+                fibril_mutex_unlock(&hc->guard);
         }
 
         if (status & I_UE) {
                 usb_log_fatal("Error like no other!\n");
-                hc_start(instance);
+                hc_start(&hc->base);
         }
 
@@ -374 +383 @@
  * @param[in] instance OHCI hc driver structure.
  */
-void hc_gain_control(hc_t *instance)
-{
-        assert(instance);
+int hc_gain_control(hc_device_t *hcd)
+{
+        hc_t *instance = hcd_to_hc(hcd);
 
         usb_log_debug("Requesting OHCI control.\n");
@@ -409 +418 @@
                 C_HCFS_SET(instance->registers->control, C_HCFS_RESET);
                 async_usleep(50000);
-                return;
+                return EOK;
         }
 
@@ -418 +427 @@
                 if (hc_status == C_HCFS_OPERATIONAL) {
                         usb_log_info("BIOS driver: HC operational.\n");
-                        return;
+                        return EOK;
                 }
                 /* HC is suspended assert resume for 20ms */
@@ -424 +433 @@
                 async_usleep(20000);
                 usb_log_info("BIOS driver: HC resumed.\n");
-                return;
+                return EOK;
         }
 
@@ -431 +440 @@
         usb_log_debug("Host controller found in reset state.\n");
         async_usleep(50000);
+        return EOK;
 }
 
@@ -437 +447 @@
  * @param[in] instance OHCI hc driver structure.
  */
-void hc_start(hc_t *instance)
-{
+int hc_start(hc_device_t *hcd)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         ohci_rh_init(&instance->rh, instance->registers, "ohci rh");
 
@@ -489 +500 @@
 
         /* Enable interrupts */
-        if (instance->hw_interrupts) {
+        if (instance->base.irq_cap >= 0) {
                 OHCI_WR(instance->registers->interrupt_enable,
                     OHCI_USED_INTERRUPTS);
@@ -508 +519 @@
         usb_log_debug("OHCI HC up and running (ctl_reg=0x%x).\n",
             OHCI_RD(instance->registers->control));
+
+        return EOK;
 }
 
@@ -555 +568 @@
         memset(&instance->rh, 0, sizeof(instance->rh));
         /* Init queues */
-        const int ret = hc_init_transfer_lists(instance);
+        int ret = hc_init_transfer_lists(instance);
         if (ret != EOK) {
                 return ret;
@@ -574 +587 @@
             instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
 
+        if ((ret = ohci_bus_init(&instance->bus, instance))) {
+                usb_log_error("HC(%p): Failed to setup bus : %s",
+                    instance, str_error(ret));
+                return ret;
+        }
+
+        hc_device_setup(&instance->base, (bus_t *) &instance->bus);
+
         return EOK;
 }

uspace/drv/bus/usb/ohci/hc.h

@@ -58 +58 @@
 /** Main OHCI driver structure */
 typedef struct hc {
+        /** Common hcd header */
+        hc_device_t base;
+
         /** Memory mapped I/O registers area */
         ohci_regs_t *registers;
@@ -70 +73 @@
         list_t pending_batches;
 
-        /** Fibril for periodic checks if interrupts can't be used */
-        fid_t interrupt_emulator;
-
         /** Guards schedule and endpoint manipulation */
         fibril_mutex_t guard;
-
-        /** interrupts available */
-        bool hw_interrupts;
 
         /** USB hub emulation structure */
@@ -86 +83 @@
 } hc_t;
 
-extern int hc_init(hc_t *, const hw_res_list_parsed_t *);
-extern void hc_gain_control(hc_t *instance);
-extern void hc_start(hc_t *instance);
-extern void hc_fini(hc_t *);
+static inline hc_t * hcd_to_hc(hc_device_t *hcd)
+{
+        assert(hcd);
+        return (hc_t *) hcd;
+}
+
+extern int hc_add(hc_device_t *, const hw_res_list_parsed_t *);
+extern int hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *);
+extern int hc_gain_control(hc_device_t *);
+extern int hc_start(hc_device_t *);
+extern int hc_gone(hc_device_t *);
 
 extern void hc_enqueue_endpoint(hc_t *, const endpoint_t *);
 extern void hc_dequeue_endpoint(hc_t *, const endpoint_t *);
 
-int ohci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res);
-
-extern void ohci_hc_interrupt(hcd_t *, uint32_t);
-extern int ohci_hc_status(hcd_t *, uint32_t *);
-extern int ohci_hc_schedule(hcd_t *, usb_transfer_batch_t *);
+extern int ohci_hc_schedule(usb_transfer_batch_t *);
+extern int ohci_hc_status(bus_t *, uint32_t *);
+extern void ohci_hc_interrupt(bus_t *, uint32_t);
 
 #endif

uspace/drv/bus/usb/ohci/main.c

@@ -48 +48 @@
 
 #define NAME "ohci"
-static int ohci_driver_init(hcd_t *, const hw_res_list_parsed_t *, ddf_dev_t *);
-static int ohci_driver_start(hcd_t *, bool);
-static int ohci_driver_claim(hcd_t *, ddf_dev_t *);
-static void ohci_driver_fini(hcd_t *);
 
-static const ddf_hc_driver_t ohci_hc_driver = {
-        .irq_code_gen = ohci_hc_gen_irq_code,
-        .init = ohci_driver_init,
-        .claim = ohci_driver_claim,
-        .start = ohci_driver_start,
+static const hc_driver_t ohci_driver = {
+        .name = NAME,
+        .hc_device_size = sizeof(hc_t),
+
+        .hc_add = hc_add,
+        .irq_code_gen = hc_gen_irq_code,
+        .claim = hc_gain_control,
+        .start = hc_start,
         .setup_root_hub = hcd_setup_virtual_root_hub,
-        .fini = ohci_driver_fini,
-        .name = "OHCI",
-        .ops = {
-                .schedule       = ohci_hc_schedule,
-                .irq_hook       = ohci_hc_interrupt,
-                .status_hook    = ohci_hc_status,
-        },
-};
-
-
-static int ohci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res, ddf_dev_t *device)
-{
-        int err;
-
-        assert(hcd);
-        assert(hcd_get_driver_data(hcd) == NULL);
-
-        hc_t *instance = malloc(sizeof(hc_t));
-        if (!instance)
-                return ENOMEM;
-
-        if ((err = hc_init(instance, res)) != EOK)
-                goto err;
-
-        if ((err = ohci_bus_init(&instance->bus, hcd, instance)))
-                goto err;
-
-        hcd_set_implementation(hcd, instance, &ohci_hc_driver.ops, &instance->bus.base.base);
-
-        return EOK;
-
-err:
-        free(instance);
-        return err;
-}
-
-static int ohci_driver_claim(hcd_t *hcd, ddf_dev_t *dev)
-{
-        hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        hc_gain_control(hc);
-
-        return EOK;
-}
-
-static int ohci_driver_start(hcd_t *hcd, bool interrupts)
-{
-        hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        hc->hw_interrupts = interrupts;
-        hc_start(hc);
-        return EOK;
-}
-
-static void ohci_driver_fini(hcd_t *hcd)
-{
-        assert(hcd);
-        hc_t *hc = hcd_get_driver_data(hcd);
-        if (hc)
-                hc_fini(hc);
-
-        hcd_set_implementation(hcd, NULL, NULL, NULL);
-        free(hc);
-}
-
-/** Initializes a new ddf driver instance of OHCI hcd.
- *
- * @param[in] device DDF instance of the device to initialize.
- * @return Error code.
- */
-static int ohci_dev_add(ddf_dev_t *device)
-{
-        usb_log_debug("ohci_dev_add() called\n");
-        assert(device);
-        return hcd_ddf_add_hc(device, &ohci_hc_driver);
-}
-
-static int ohci_fun_online(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_online(fun);
-}
-
-static int ohci_fun_offline(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_offline(fun);
-}
-
-
-static const driver_ops_t ohci_driver_ops = {
-        .dev_add = ohci_dev_add,
-        .fun_online = ohci_fun_online,
-        .fun_offline = ohci_fun_offline
-};
-
-static const driver_t ohci_driver = {
-        .name = NAME,
-        .driver_ops = &ohci_driver_ops
+        .hc_gone = hc_gone,
 };
 
@@ -171 +72 @@
 {
         log_init(NAME);
-        return ddf_driver_main(&ohci_driver);
+        return hc_driver_main(&ohci_driver);
 }
 

uspace/drv/bus/usb/ohci/ohci_bus.c

@@ -158 +158 @@
         .parent = &usb2_bus_ops,
 
+        .interrupt = ohci_hc_interrupt,
+        .status = ohci_hc_status,
+
         .endpoint_destroy = ohci_endpoint_destroy,
         .endpoint_create = ohci_endpoint_create,
@@ -167 +170 @@
         .batch_create = ohci_create_batch,
         .batch_destroy = ohci_destroy_batch,
+        .batch_schedule = ohci_hc_schedule,
 };
 
 
-int ohci_bus_init(ohci_bus_t *bus, hcd_t *hcd, hc_t *hc)
+int ohci_bus_init(ohci_bus_t *bus, hc_t *hc)
 {
         assert(hc);
         assert(bus);
 
-
         usb2_bus_t *usb2_bus = (usb2_bus_t *) bus;
         bus_t *bus_base = (bus_t *) bus;
 
-        usb2_bus_init(usb2_bus, hcd, BANDWIDTH_AVAILABLE_USB11);
+        usb2_bus_init(usb2_bus, BANDWIDTH_AVAILABLE_USB11);
         bus_base->ops = &ohci_bus_ops;
 

uspace/drv/bus/usb/ohci/ohci_bus.h

@@ -62 +62 @@
 } ohci_bus_t;
 
-int ohci_bus_init(ohci_bus_t *, hcd_t *, hc_t *);
+int ohci_bus_init(ohci_bus_t *, hc_t *);
 
 /** Get and convert assigned ohci_endpoint_t structure

uspace/drv/bus/usb/uhci/hc.c

@@ -95 +95 @@
 
 static void hc_init_hw(const hc_t *instance);
-static int hc_init_mem_structures(hc_t *instance, hcd_t *);
+static int hc_init_mem_structures(hc_t *instance, hc_device_t *);
 static int hc_init_transfer_lists(hc_t *instance);
 
@@ -107 +107 @@
  * @return Error code.
  */
-int uhci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
+int hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
 {
         assert(code);
@@ -156 +156 @@
  * - resume from suspend state (not implemented)
  */
-void uhci_hc_interrupt(hcd_t *hcd, uint32_t status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+static void hc_interrupt(bus_t *bus, uint32_t status)
+{
+        hc_t *instance = bus_to_hc(bus);
+
         /* Lower 2 bits are transaction error and transaction complete */
         if (status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) {
@@ -199 +198 @@
                 } else {
                         usb_log_fatal("Too many UHCI hardware failures!.\n");
-                        hc_fini(instance);
+                        hc_gone(&instance->base);
                 }
         }
@@ -215 +214 @@
  * interrupt fibrils.
  */
-int hc_init(hc_t *instance, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
-{
-        assert(instance);
+int hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         assert(hw_res);
         if (hw_res->io_ranges.count != 1 ||
@@ -249 +248 @@
 }
 
-void hc_start(hc_t *instance)
-{
+int hc_start(hc_device_t *hcd)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         hc_init_hw(instance);
         (void)hc_debug_checker;
 
-        uhci_rh_init(&instance->rh, instance->registers->ports, "uhci");
+        return uhci_rh_init(&instance->rh, instance->registers->ports, "uhci");
 }
 
@@ -261 +261 @@
  * @param[in] instance Host controller structure to use.
  */
-void hc_fini(hc_t *instance)
+int hc_gone(hc_device_t *instance)
 {
         assert(instance);
         //TODO Implement
+        return ENOTSUP;
 }
 
@@ -294 +295 @@
         pio_write_32(&registers->flbaseadd, pa);
 
-        if (instance->hw_interrupts) {
+        if (instance->base.irq_cap >= 0) {
                 /* Enable all interrupts, but resume interrupt */
                 pio_write_16(&instance->registers->usbintr,
@@ -320 +321 @@
 }
 
+static int hc_status(bus_t *, uint32_t *);
+static int hc_schedule(usb_transfer_batch_t *);
+
 static const bus_ops_t uhci_bus_ops = {
         .parent = &usb2_bus_ops,
 
+        .interrupt = hc_interrupt,
+        .status = hc_status,
+
         .endpoint_count_bw = bandwidth_count_usb11,
         .batch_create = create_transfer_batch,
+        .batch_schedule = hc_schedule,
         .batch_destroy = destroy_transfer_batch,
 };
@@ -338 +346 @@
  *  - frame list page (needs to be one UHCI hw accessible 4K page)
  */
-int hc_init_mem_structures(hc_t *instance, hcd_t *hcd)
+int hc_init_mem_structures(hc_t *instance, hc_device_t *hcd)
 {
         int err;
         assert(instance);
 
-        if ((err = usb2_bus_init(&instance->bus, hcd, BANDWIDTH_AVAILABLE_USB11)))
+        if ((err = usb2_bus_init(&instance->bus, BANDWIDTH_AVAILABLE_USB11)))
                 return err;
 
         bus_t *bus = (bus_t *) &instance->bus;
         bus->ops = &uhci_bus_ops;
+
+        hc_device_setup(&instance->base, bus);
 
         /* Init USB frame list page */
@@ -438 +448 @@
 }
 
-int uhci_hc_status(hcd_t *hcd, uint32_t *status)
-{
-        assert(hcd);
+static int hc_status(bus_t *bus, uint32_t *status)
+{
+        hc_t *instance = bus_to_hc(bus);
         assert(status);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
 
         *status = 0;
@@ -462 +470 @@
  * Checks for bandwidth availability and appends the batch to the proper queue.
  */
-int uhci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+static int hc_schedule(usb_transfer_batch_t *batch)
+{
+        hc_t *instance = bus_to_hc(endpoint_get_bus(batch->ep));
         assert(batch);
 

uspace/drv/bus/usb/uhci/hc.h

@@ -100 +100 @@
 /** Main UHCI driver structure */
 typedef struct hc {
+        /* Common hc_device header */
+        hc_device_t base;
+
         uhci_rh_t rh;
         usb2_bus_t bus;
@@ -119 +122 @@
         /** Pointer table to the above lists, helps during scheduling */
         transfer_list_t *transfers[2][4];
-        /** Indicator of hw interrupts availability */
-        bool hw_interrupts;
 
         /** Number of hw failures detected. */
@@ -126 +127 @@
 } hc_t;
 
-extern int hc_init(hc_t *, hcd_t *, const hw_res_list_parsed_t *);
-extern void hc_start(hc_t *);
-extern void hc_fini(hc_t *);
+static inline hc_t *hcd_to_hc(hc_device_t *hcd)
+{
+        assert(hcd);
+        return (hc_t *) hcd;
+}
 
-extern int uhci_hc_gen_irq_code(irq_code_t *, hcd_t *,const hw_res_list_parsed_t *);
+static inline hc_t *bus_to_hc(bus_t *bus)
+{
+        assert(bus);
+        return member_to_inst(bus, hc_t, bus);
+}
 
-extern void uhci_hc_interrupt(hcd_t *, uint32_t);
-extern int uhci_hc_status(hcd_t *, uint32_t *);
-extern int uhci_hc_schedule(hcd_t *, usb_transfer_batch_t *);
+extern int hc_add(hc_device_t *, const hw_res_list_parsed_t *);
+extern int hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *);
+extern int hc_start(hc_device_t *);
+extern int hc_gone(hc_device_t *);
 
 #endif

uspace/drv/bus/usb/uhci/main.c

@@ -49 +49 @@
 #define NAME "uhci"
 
-static int uhci_driver_init(hcd_t *, const hw_res_list_parsed_t *, ddf_dev_t *);
-static int uhci_driver_start(hcd_t *, bool);
-static void uhci_driver_fini(hcd_t *);
-static int disable_legacy(hcd_t *, ddf_dev_t *);
+static int disable_legacy(hc_device_t *);
 
-static const ddf_hc_driver_t uhci_hc_driver = {
-        .claim = disable_legacy,
-        .irq_code_gen = uhci_hc_gen_irq_code,
-        .init = uhci_driver_init,
-        .start = uhci_driver_start,
+static const hc_driver_t uhci_driver = {
+        .name = NAME,
+        .hc_device_size = sizeof(hc_t),
+        .claim = disable_legacy,
+        .irq_code_gen = hc_gen_irq_code,
+        .hc_add = hc_add,
+        .start = hc_start,
         .setup_root_hub = hcd_setup_virtual_root_hub,
-        .fini = uhci_driver_fini,
-        .name = "UHCI",
-        .ops = {
-                .schedule    = uhci_hc_schedule,
-                .irq_hook    = uhci_hc_interrupt,
-                .status_hook = uhci_hc_status,
-        },
+        .hc_gone = hc_gone,
 };
-
-static int uhci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res, ddf_dev_t *device)
-{
-        int err;
-
-        assert(hcd);
-        assert(hcd_get_driver_data(hcd) == NULL);
-
-        hc_t *instance = malloc(sizeof(hc_t));
-        if (!instance)
-                return ENOMEM;
-
-        if ((err = hc_init(instance, hcd, res)) != EOK)
-                goto err;
-
-        hcd_set_implementation(hcd, instance, &uhci_hc_driver.ops, &instance->bus.base);
-
-        return EOK;
-
-err:
-        free(instance);
-        return err;
-}
-
-static int uhci_driver_start(hcd_t *hcd, bool interrupts)
-{
-        assert(hcd);
-        hc_t *hc = hcd_get_driver_data(hcd);
-
-        hc->hw_interrupts = interrupts;
-        hc_start(hc);
-        return EOK;
-}
-
-static void uhci_driver_fini(hcd_t *hcd)
-{
-        assert(hcd);
-        hc_t *hc = hcd_get_driver_data(hcd);
-        if (hc)
-                hc_fini(hc);
-
-        hcd_set_implementation(hcd, NULL, NULL, NULL);
-        free(hc);
-}
 
 /** Call the PCI driver with a request to clear legacy support register
@@ -118 +67 @@
  * @return Error code.
  */
-static int disable_legacy(hcd_t *hcd, ddf_dev_t *device)
+static int disable_legacy(hc_device_t *hcd)
 {
-        assert(device);
+        assert(hcd);
 
-        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(hcd->ddf_dev);
         if (parent_sess == NULL)
                 return ENOMEM;
@@ -130 +79 @@
         return pci_config_space_write_16(parent_sess, 0xc0, 0xaf00);
 }
-
-/** Initialize a new ddf driver instance for uhci hc and hub.
- *
- * @param[in] device DDF instance of the device to initialize.
- * @return Error code.
- */
-static int uhci_dev_add(ddf_dev_t *device)
-{
-        usb_log_debug2("uhci_dev_add() called\n");
-        assert(device);
-        return hcd_ddf_add_hc(device, &uhci_hc_driver);
-}
-
-static int uhci_fun_online(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_online(fun);
-}
-
-static int uhci_fun_offline(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_offline(fun);
-}
-
-static const driver_ops_t uhci_driver_ops = {
-        .dev_add = uhci_dev_add,
-        .fun_online = uhci_fun_online,
-        .fun_offline = uhci_fun_offline
-};
-
-static const driver_t uhci_driver = {
-        .name = NAME,
-        .driver_ops = &uhci_driver_ops
-};
-
 
 /** Initialize global driver structures (NONE).
@@ -178 +93 @@
         log_init(NAME);
         logctl_set_log_level(NAME, LVL_DEBUG2);
-        return ddf_driver_main(&uhci_driver);
+        return hc_driver_main(&uhci_driver);
 }
 /**

uspace/drv/bus/usb/vhc/main.c

@@ -69 +69 @@
                 return ret;
         }
-        vhc_init(vhc, dev_to_hcd(dev));
         return EOK;
 }
 
-hcd_ops_t vhc_hc_ops = {
-        .schedule = vhc_schedule,
-};
-
 static int vhc_dev_add(ddf_dev_t *dev)
 {
+        /* Initialize generic structures */
+        int ret = hcd_ddf_setup_hc(dev, sizeof(vhc_data_t));
+        if (ret != EOK) {
+                usb_log_error("Failed to init HCD structures: %s.\n",
+                   str_error(ret));
+                return ret;
+        }
+        vhc_data_t *vhc = ddf_dev_data_get(dev);
+        vhc_init(vhc);
+
+        hc_device_setup(&vhc->base, (bus_t *) &vhc->bus);
+
         /* Initialize virtual structure */
         ddf_fun_t *ctl_fun = NULL;
-        int ret = vhc_control_node(dev, &ctl_fun);
+        ret = vhc_control_node(dev, &ctl_fun);
         if (ret != EOK) {
                 usb_log_error("Failed to setup control node.\n");
                 return ret;
         }
-        vhc_data_t *data = ddf_fun_data_get(ctl_fun);
-
-        /* Initialize generic structures */
-        ret = hcd_ddf_setup_hc(dev);
-        if (ret != EOK) {
-                usb_log_error("Failed to init HCD structures: %s.\n",
-                   str_error(ret));
-                ddf_fun_destroy(ctl_fun);
-                return ret;
-        }
-
-        hcd_set_implementation(dev_to_hcd(dev), data, &vhc_hc_ops, &data->bus.base);
 
         /* Add virtual hub device */
-        ret = vhc_virtdev_plug_hub(data, &data->hub, NULL, 0);
+        ret = vhc_virtdev_plug_hub(vhc, &vhc->hub, NULL, 0);
         if (ret != EOK) {
                 usb_log_error("Failed to plug root hub: %s.\n", str_error(ret));
@@ -111 +106 @@
          * needs to be ready at this time.
          */
-        ret = hcd_setup_virtual_root_hub(dev_to_hcd(dev), dev);
+        ret = hcd_setup_virtual_root_hub(&vhc->base);
         if (ret != EOK) {
                 usb_log_error("Failed to init VHC root hub: %s\n",

uspace/drv/bus/usb/vhc/transfer.c

@@ -40 +40 @@
 static bool is_set_address_transfer(vhc_transfer_t *transfer)
 {
-        if (transfer->batch->target.endpoint != 0) {
-                return false;
-        }
-        if (transfer->batch->ep->transfer_type != USB_TRANSFER_CONTROL) {
-                return false;
-        }
-        if (transfer->batch->dir != USB_DIRECTION_OUT) {
+        if (transfer->batch.target.endpoint != 0) {
+                return false;
+        }
+        if (transfer->batch.ep->transfer_type != USB_TRANSFER_CONTROL) {
+                return false;
+        }
+        if (transfer->batch.dir != USB_DIRECTION_OUT) {
                 return false;
         }
         const usb_device_request_setup_packet_t *setup
-                = &transfer->batch->setup.packet;
+                = &transfer->batch.setup.packet;
         if (setup->request_type != 0) {
                 return false;
@@ -150 +150 @@
         assert(outcome != ENAK);
         assert(transfer);
-        assert(transfer->batch);
-        transfer->batch->error = outcome;
-        transfer->batch->transfered_size = data_transfer_size;
-        usb_transfer_batch_finish(transfer->batch);
+        transfer->batch.error = outcome;
+        transfer->batch.transfered_size = data_transfer_size;
+        usb_transfer_batch_finish(&transfer->batch);
         free(transfer);
+}
+
+static usb_transfer_batch_t *batch_create(endpoint_t *ep)
+{
+        vhc_transfer_t *transfer = calloc(1, sizeof(vhc_transfer_t));
+        usb_transfer_batch_init(&transfer->batch, ep);
+        link_initialize(&transfer->link);
+        return &transfer->batch;
 }
 
 static const bus_ops_t vhc_bus_ops = {
         .parent = &usb2_bus_ops,
+
         .endpoint_count_bw = bandwidth_count_usb11,
+        .batch_create = batch_create,
+        .batch_schedule = vhc_schedule,
 };
 
-int vhc_init(vhc_data_t *instance, hcd_t *hcd)
+int vhc_init(vhc_data_t *instance)
 {
         assert(instance);
         list_initialize(&instance->devices);
         fibril_mutex_initialize(&instance->guard);
-        usb2_bus_init(&instance->bus, hcd, BANDWIDTH_AVAILABLE_USB11);
+        usb2_bus_init(&instance->bus, BANDWIDTH_AVAILABLE_USB11);
         instance->bus.base.ops = &vhc_bus_ops;
-        instance->magic = 0xDEADBEEF;
         return virthub_init(&instance->hub, "root hub");
 }
 
-int vhc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
+int vhc_schedule(usb_transfer_batch_t *batch)
+{
         assert(batch);
-        vhc_data_t *vhc = hcd_get_driver_data(hcd);
+        vhc_transfer_t *transfer = (vhc_transfer_t *) batch;
+        vhc_data_t *vhc = bus_to_vhc(endpoint_get_bus(batch->ep));
         assert(vhc);
-
-        vhc_transfer_t *transfer = malloc(sizeof(vhc_transfer_t));
-        if (!transfer)
-                return ENOMEM;
-        link_initialize(&transfer->link);
-        transfer->batch = batch;
 
         fibril_mutex_lock(&vhc->guard);
@@ -192 +195 @@
         list_foreach(vhc->devices, link, vhc_virtdev_t, dev) {
                 fibril_mutex_lock(&dev->guard);
-                if (dev->address == transfer->batch->target.address) {
+                if (dev->address == transfer->batch.target.address) {
                         if (!targets) {
                                 list_append(&transfer->link, &dev->transfer_queue);
@@ -227 +230 @@
                 size_t data_transfer_size = 0;
                 if (dev->dev_sess) {
-                        rc = process_transfer_remote(transfer->batch,
+                        rc = process_transfer_remote(&transfer->batch,
                             dev->dev_sess, &data_transfer_size);
                 } else if (dev->dev_local != NULL) {
-                        rc = process_transfer_local(transfer->batch,
+                        rc = process_transfer_local(&transfer->batch,
                             dev->dev_local, &data_transfer_size);
                 } else {
@@ -244 +247 @@
                         if (is_set_address_transfer(transfer)) {
                                 usb_device_request_setup_packet_t *setup =
-                                    (void*) transfer->batch->setup.buffer;
+                                    (void*) transfer->batch.setup.buffer;
                                 dev->address = setup->value;
                                 usb_log_debug2("Address changed to %d\n",

uspace/drv/bus/usb/vhc/vhcd.h

@@ -39 +39 @@
 #include <usbvirt/device.h>
 #include <async.h>
+#include <macros.h>
 
 #include <usb/host/hcd.h>
 #include <usb/host/usb2_bus.h>
+#include <usb/host/usb_transfer_batch.h>
 
 #define NAME "vhc"
@@ -56 +58 @@
 
 typedef struct {
-        uint32_t magic;
+        hc_device_t base;
+
+        usb2_bus_t bus;
+        ddf_fun_t *virtual_fun;
         list_t devices;
         fibril_mutex_t guard;
         usbvirt_device_t hub;
-        usb2_bus_t bus;
 } vhc_data_t;
 
 typedef struct {
+        usb_transfer_batch_t batch;
         link_t link;
-        usb_transfer_batch_t *batch;
 } vhc_transfer_t;
+
+static inline vhc_data_t *hcd_to_vhc(hc_device_t *hcd)
+{
+        assert(hcd);
+        return (vhc_data_t *) hcd;
+}
+
+static inline vhc_data_t *bus_to_vhc(bus_t *bus)
+{
+        assert(bus);
+        return member_to_inst(bus, vhc_data_t, bus);
+}
 
 void on_client_close(ddf_fun_t *fun);
@@ -77 +93 @@
 void vhc_virtdev_unplug(vhc_data_t *, uintptr_t);
 
-int vhc_init(vhc_data_t *instance, hcd_t *);
-int vhc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch);
+int vhc_init(vhc_data_t *);
+int vhc_schedule(usb_transfer_batch_t *);
 int vhc_transfer_queue_processor(void *arg);
 

uspace/drv/bus/usb/xhci/bus.c

@@ -111 +111 @@
 
         uint16_t max_packet_size;
-        if ((err = hcd_get_ep0_max_packet_size(&max_packet_size, hc->hcd, &dev->base)))
+        if ((err = hcd_get_ep0_max_packet_size(&max_packet_size, (bus_t *) &hc->bus, &dev->base)))
                 return err;
 
@@ -168 +168 @@
 
         /* Read the device descriptor, derive the match ids */
-        if ((err = hcd_ddf_device_explore(dev))) {
+        if ((err = hcd_device_explore(dev))) {
                 usb_log_error("Device(%d): Failed to explore device: %s", dev->address, str_error(err));
                 goto err_address;
@@ -233 +233 @@
         /* Destroy DDF device. */
         /* XXX: Not a good idea, this method should not destroy devices. */
-        hcd_ddf_device_destroy(dev);
+        hcd_ddf_fun_destroy(dev);
 
         return EOK;
@@ -501 +501 @@
         BIND_OP(batch_destroy)
 #undef BIND_OP
+
+        .interrupt = hc_interrupt,
+        .status = hc_status,
+        .batch_schedule = hc_schedule,
 };
 
@@ -507 +511 @@
         assert(bus);
 
-        bus_init(&bus->base, hc->hcd, sizeof(xhci_device_t));
+        bus_init(&bus->base, sizeof(xhci_device_t));
 
         bus->devices_by_slot = calloc(hc->max_slots, sizeof(xhci_device_t *));

uspace/drv/bus/usb/xhci/hc.c

@@ -432 +432 @@
  * Used only when polling. Shall supplement the irq_commands.
  */
-int hc_status(xhci_hc_t *hc, uint32_t *status)
-{
+int hc_status(bus_t *bus, uint32_t *status)
+{
+        xhci_hc_t *hc = bus_to_hc(bus);
         int ip = XHCI_REG_RD(hc->rt_regs->ir, XHCI_INTR_IP);
         if (ip) {
@@ -449 +450 @@
 }
 
-int hc_schedule(xhci_hc_t *hc, usb_transfer_batch_t *batch)
+int hc_schedule(usb_transfer_batch_t *batch)
 {
         assert(batch);
-        assert(batch->ep);
+        xhci_hc_t *hc = bus_to_hc(endpoint_get_bus(batch->ep));
 
         if (!batch->target.address) {
@@ -532 +533 @@
 }
 
-void hc_interrupt(xhci_hc_t *hc, uint32_t status)
-{
+void hc_interrupt(bus_t *bus, uint32_t status)
+{
+        xhci_hc_t *hc = bus_to_hc(bus);
         status = xhci2host(32, status);
 

uspace/drv/bus/usb/xhci/hc.h

@@ -51 +51 @@
 
 typedef struct xhci_hc {
+        /** Common HC device header */
+        hc_device_t base;
+
         /* MMIO range */
         addr_range_t mmio_range;
@@ -86 +89 @@
         xhci_port_speed_t speeds [16];
         uint8_t speed_to_psiv [USB_SPEED_MAX];
+} xhci_hc_t;
 
-        /* TODO: Hack. Figure out a better way. */
-        hcd_t *hcd;
-} xhci_hc_t;
+static inline xhci_hc_t *bus_to_hc(bus_t *bus)
+{
+        assert(bus);
+        return member_to_inst(bus, xhci_hc_t, bus);
+}
 
 typedef struct xhci_endpoint xhci_endpoint_t;
@@ -99 +105 @@
 int hc_irq_code_gen(irq_code_t *, xhci_hc_t *, const hw_res_list_parsed_t *);
 int hc_start(xhci_hc_t *, bool);
-int hc_schedule(xhci_hc_t *hc, usb_transfer_batch_t *batch);
-int hc_status(xhci_hc_t *, uint32_t *);
-void hc_interrupt(xhci_hc_t *, uint32_t);
 void hc_fini(xhci_hc_t *);
 int hc_ring_doorbell(xhci_hc_t *, unsigned, unsigned);
@@ -113 +116 @@
 int hc_update_endpoint(xhci_hc_t *, uint32_t, uint8_t, xhci_ep_ctx_t *);
 
+int hc_schedule(usb_transfer_batch_t *batch);
+int hc_status(bus_t *, uint32_t *);
+void hc_interrupt(bus_t *, uint32_t);
+
 #endif
 

uspace/drv/bus/usb/xhci/main.c

@@ -47 +47 @@
 #define NAME "xhci"
 
-static int hc_driver_init(hcd_t *, const hw_res_list_parsed_t *, ddf_dev_t *);
-static int hcd_irq_code_gen(irq_code_t *, hcd_t *, const hw_res_list_parsed_t *);
-static int hcd_claim(hcd_t *, ddf_dev_t *);
-static int hcd_start(hcd_t *, bool);
-static int hcd_status(hcd_t *, uint32_t *);
-static void hcd_interrupt(hcd_t *, uint32_t);
-static int hcd_schedule(hcd_t *, usb_transfer_batch_t *);
-static void hc_driver_fini(hcd_t *);
+static inline xhci_hc_t *hcd_to_hc(hc_device_t *hcd)
+{
+        assert(hcd);
+        return (xhci_hc_t *) hcd;
+}
 
-static const ddf_hc_driver_t xhci_ddf_hc_driver = {
-        .name = "XHCI-PCI",
-        .init = hc_driver_init,
+static int hcd_hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+{
+        int err;
+        xhci_hc_t *hc = hcd_to_hc(hcd);
+        hc_device_setup(hcd, (bus_t *) &hc->bus);
+
+        if ((err = hc_init_mmio(hc, hw_res)))
+                return err;
+
+        if ((err = hc_init_memory(hc, hcd->ddf_dev)))
+                return err;
+
+        return EOK;
+}
+
+static int hcd_irq_code_gen(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+{
+        xhci_hc_t *hc = hcd_to_hc(hcd);
+        return hc_irq_code_gen(code, hc, hw_res);
+}
+
+static int hcd_claim(hc_device_t *hcd)
+{
+        xhci_hc_t *hc = hcd_to_hc(hcd);
+        return hc_claim(hc, hcd->ddf_dev);
+}
+
+static int hcd_start(hc_device_t *hcd)
+{
+        xhci_hc_t *hc = hcd_to_hc(hcd);
+        return hc_start(hc, hcd->irq_cap >= 0);
+}
+
+static int hcd_hc_gone(hc_device_t *hcd)
+{
+        xhci_hc_t *hc = hcd_to_hc(hcd);
+        hc_fini(hc);
+        return EOK;
+}
+
+static const hc_driver_t xhci_driver = {
+        .name = NAME,
+        .hc_device_size = sizeof(xhci_hc_t),
+
+        .hc_add = hcd_hc_add,
         .irq_code_gen = hcd_irq_code_gen,
         .claim = hcd_claim,
         .start = hcd_start,
-        .setup_root_hub = NULL,
-        .fini = hc_driver_fini,
-        .ops = {
-                .schedule       = hcd_schedule,
-                .irq_hook       = hcd_interrupt,
-                .status_hook    = hcd_status,
-        }
+        .hc_gone = hcd_hc_gone,
 };
-
-static int hc_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *hw_res, ddf_dev_t *device)
-{
-        int err;
-
-        xhci_hc_t *hc = malloc(sizeof(xhci_hc_t));
-        if (!hc)
-                return ENOMEM;
-
-        if ((err = hc_init_mmio(hc, hw_res)))
-                goto err;
-
-        hc->hcd = hcd;
-
-        if ((err = hc_init_memory(hc, device)))
-                goto err;
-
-        hcd_set_implementation(hcd, hc, &xhci_ddf_hc_driver.ops, &hc->bus.base);
-
-        return EOK;
-err:
-        free(hc);
-        return err;
-}
-
-static int hcd_irq_code_gen(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        return hc_irq_code_gen(code, hc, hw_res);
-}
-
-static int hcd_claim(hcd_t *hcd, ddf_dev_t *dev)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        return hc_claim(hc, dev);
-}
-
-static int hcd_start(hcd_t *hcd, bool irq)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        return hc_start(hc, irq);
-}
-
-static int hcd_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        return hc_schedule(hc, batch);
-}
-
-static int hcd_status(hcd_t *hcd, uint32_t *status)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-        assert(status);
-
-        return hc_status(hc, status);
-}
-
-static void hcd_interrupt(hcd_t *hcd, uint32_t status)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        hc_interrupt(hc, status);
-}
-
-static void hc_driver_fini(hcd_t *hcd)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        hc_fini(hc);
-
-        free(hc);
-}
-
-/** Initializes a new ddf driver instance of XHCI hcd.
- *
- * @param[in] device DDF instance of the device to initialize.
- * @return Error code.
- */
-static int xhci_dev_add(ddf_dev_t *device)
-{
-        usb_log_info("Adding device %s", ddf_dev_get_name(device));
-        return hcd_ddf_add_hc(device, &xhci_ddf_hc_driver);
-}
-
-static int xhci_fun_online(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_online(fun);
-}
-
-static int xhci_fun_offline(ddf_fun_t *fun)
-{
-        return hcd_ddf_device_offline(fun);
-}
-
-
-static const driver_ops_t xhci_driver_ops = {
-        .dev_add = xhci_dev_add,
-        .fun_online = xhci_fun_online,
-        .fun_offline = xhci_fun_offline
-};
-
-static const driver_t xhci_driver = {
-        .name = NAME,
-        .driver_ops = &xhci_driver_ops
-};
-
 
 /** Initializes global driver structures (NONE).
@@ -200 +116 @@
         log_init(NAME);
         logctl_set_log_level(NAME, LVL_DEBUG2);
-        return ddf_driver_main(&xhci_driver);
+        return hc_driver_main(&xhci_driver);
 }
 

uspace/drv/bus/usb/xhci/rh.c

@@ -94 +94 @@
         xhci_bus_t *bus = &rh->hc->bus;
 
-        device_t *dev = hcd_ddf_device_create(rh->hc_device, &bus->base);
+        device_t *dev = hcd_ddf_fun_create(&rh->hc->base);
         if (!dev) {
                 usb_log_error("Failed to create USB device function.");
@@ -132 +132 @@
 
 err_usb_dev:
-        hcd_ddf_device_destroy(dev);
+        hcd_ddf_fun_destroy(dev);
         return err;
 }