Changeset df6ded8 in mainline for uspace/drv/bus/usb/ehci

Timestamp:

2018-02-28T16:37:50Z (8 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

1b20da0

Parents:

f5e5f73 (diff), b2dca8de (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Jakub Jermar <jakub@…> (2018-02-28 16:06:42)

git-committer:

Jakub Jermar <jakub@…> (2018-02-28 16:37:50)

Message:

Merge github.com:helenos-xhci-team/helenos

This commit merges support for USB 3 and generally refactors, fixes,
extends and cleans up the existing USB framework.

Notable additions and features:

• new host controller driver has been implemented to control various xHC models (among others, NEC Renesas uPD720200)
• isochronous data transfer mode
• support for explicit USB device removal
• USB tablet driver

Location:

uspace/drv/bus/usb/ehci

Files:

• Makefile (modified) (1 diff)
• ehci_batch.c (modified) (17 diffs)
• ehci_batch.h (modified) (3 diffs)
• ehci_bus.c (added)
• ehci_bus.h (moved) (moved from uspace/drv/bus/usb/ehci/ehci_endpoint.h ) (3 diffs)
• ehci_endpoint.c (deleted)
• ehci_rh.c (modified) (13 diffs)
• ehci_rh.h (modified) (2 diffs)
• endpoint_list.c (modified) (7 diffs)
• endpoint_list.h (modified) (3 diffs)
• hc.c (modified) (21 diffs)
• hc.h (modified) (5 diffs)
• hw_struct/iso_transfer_descriptor.h (modified) (1 diff)
• hw_struct/queue_head.c (modified) (4 diffs)
• hw_struct/queue_head.h (modified) (2 diffs)
• hw_struct/split_iso_transfer_descriptor.h (modified) (1 diff)
• hw_struct/transfer_descriptor.c (modified) (5 diffs)
• hw_struct/transfer_descriptor.h (modified) (3 diffs)
• main.c (modified) (3 diffs)
• res.c (modified) (10 diffs)
• res.h (modified) (1 diff)

uspace/drv/bus/usb/ehci/Makefile

@@ -35 +35 @@
 SOURCES = \
         ehci_batch.c \
-        ehci_endpoint.c \
+        ehci_bus.c \
         ehci_rh.c \
         endpoint_list.c \

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2014 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -42 +43 @@
 #include <usb/usb.h>
 #include <usb/debug.h>
-#include <usb/host/utils/malloc32.h>
 
 #include "ehci_batch.h"
-#include "ehci_endpoint.h"
+#include "ehci_bus.h"
 
 /* The buffer pointer list in the qTD is long enough to support a maximum
@@ -53 +53 @@
 #define EHCI_TD_MAX_TRANSFER   (16 * 1024)
 
-static void (*const batch_setup[])(ehci_transfer_batch_t*, usb_direction_t);
+static void (*const batch_setup[])(ehci_transfer_batch_t*);
 
 /** Safely destructs ehci_transfer_batch_t structure
@@ -59 +59 @@
  * @param[in] ehci_batch Instance to destroy.
  */
-static void ehci_transfer_batch_dispose(ehci_transfer_batch_t *ehci_batch)
-{
-        if (!ehci_batch)
-                return;
-        if (ehci_batch->tds) {
-                for (size_t i = 0; i < ehci_batch->td_count; ++i) {
-                        free32(ehci_batch->tds[i]);
-                }
-                free(ehci_batch->tds);
-        }
-        usb_transfer_batch_destroy(ehci_batch->usb_batch);
-        free32(ehci_batch->device_buffer);
+void ehci_transfer_batch_destroy(ehci_transfer_batch_t *ehci_batch)
+{
+        assert(ehci_batch);
+        dma_buffer_free(&ehci_batch->ehci_dma_buffer);
+        usb_log_debug2("Batch(%p): disposed", ehci_batch);
         free(ehci_batch);
-        usb_log_debug2("Batch(%p): disposed", ehci_batch);
-}
-
-/** Finishes usb_transfer_batch and destroys the structure.
- *
- * @param[in] uhci_batch Instance to finish and destroy.
- */
-void ehci_transfer_batch_finish_dispose(ehci_transfer_batch_t *ehci_batch)
-{
-        assert(ehci_batch);
-        assert(ehci_batch->usb_batch);
-        usb_transfer_batch_finish(ehci_batch->usb_batch,
-            ehci_batch->device_buffer + ehci_batch->usb_batch->setup_size);
-        ehci_transfer_batch_dispose(ehci_batch);
 }
 
@@ -94 +73 @@
  * NULL otherwise.
  *
+ */
+ehci_transfer_batch_t * ehci_transfer_batch_create(endpoint_t *ep)
+{
+        assert(ep);
+
+        ehci_transfer_batch_t *ehci_batch = calloc(1, sizeof(ehci_transfer_batch_t));
+        if (!ehci_batch) {
+                usb_log_error("Failed to allocate EHCI batch data.");
+                return NULL;
+        }
+
+        usb_transfer_batch_init(&ehci_batch->base, ep);
+
+        return ehci_batch;
+}
+
+/** Prepares a batch to be sent.
+ *
  * Determines the number of needed transfer descriptors (TDs).
  * Prepares a transport buffer (that is accessible by the hardware).
  * Initializes parameters needed for the transfer and callback.
  */
-ehci_transfer_batch_t * ehci_transfer_batch_get(usb_transfer_batch_t *usb_batch)
-{
-        assert(usb_batch);
-
-        ehci_transfer_batch_t *ehci_batch =
-            calloc(1, sizeof(ehci_transfer_batch_t));
-        if (!ehci_batch) {
-                usb_log_error("Batch %p: Failed to allocate EHCI batch data.",
-                    usb_batch);
-                goto dispose;
-        }
-        link_initialize(&ehci_batch->link);
-        ehci_batch->td_count =
-            (usb_batch->buffer_size + EHCI_TD_MAX_TRANSFER - 1)
-            / EHCI_TD_MAX_TRANSFER;
+int ehci_transfer_batch_prepare(ehci_transfer_batch_t *ehci_batch)
+{
+        assert(ehci_batch);
+
+        const size_t setup_size = (ehci_batch->base.ep->transfer_type == USB_TRANSFER_CONTROL)
+                ? USB_SETUP_PACKET_SIZE
+                : 0;
+
+        const size_t size = ehci_batch->base.size;
+
+        /* Add TD left over by the previous transfer */
+        ehci_batch->qh = ehci_endpoint_get(ehci_batch->base.ep)->qh;
+
+        /* Determine number of TDs needed */
+        ehci_batch->td_count = (size + EHCI_TD_MAX_TRANSFER - 1)
+                / EHCI_TD_MAX_TRANSFER;
 
         /* Control transfer need Setup and Status stage */
-        if (usb_batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
+        if (ehci_batch->base.ep->transfer_type == USB_TRANSFER_CONTROL) {
                 ehci_batch->td_count += 2;
         }
 
-        ehci_batch->tds = calloc(ehci_batch->td_count, sizeof(td_t*));
-        if (!ehci_batch->tds) {
-                usb_log_error("Batch %p: Failed to allocate EHCI transfer "
-                    "descriptors.", usb_batch);
-                goto dispose;
-        }
-
-        /* Add TD left over by the previous transfer */
-        ehci_batch->qh = ehci_endpoint_get(usb_batch->ep)->qh;
-
-        for (unsigned i = 0; i < ehci_batch->td_count; ++i) {
-                ehci_batch->tds[i] = malloc32(sizeof(td_t));
-                if (!ehci_batch->tds[i]) {
-                        usb_log_error("Batch %p: Failed to allocate TD %d.",
-                            usb_batch, i);
-                        goto dispose;
-                }
-                memset(ehci_batch->tds[i], 0, sizeof(td_t));
-        }
-
-
-        /* Mix setup stage and data together, we have enough space */
-        if (usb_batch->setup_size + usb_batch->buffer_size > 0) {
-                /* Use one buffer for setup and data stage */
-                ehci_batch->device_buffer =
-                    malloc32(usb_batch->setup_size + usb_batch->buffer_size);
-                if (!ehci_batch->device_buffer) {
-                        usb_log_error("Batch %p: Failed to allocate device "
-                            "buffer", usb_batch);
-                        goto dispose;
-                }
-                /* Copy setup data */
-                memcpy(ehci_batch->device_buffer, usb_batch->setup_buffer,
-                    usb_batch->setup_size);
-                /* Copy generic data */
-                if (usb_batch->ep->direction != USB_DIRECTION_IN)
-                        memcpy(
-                            ehci_batch->device_buffer + usb_batch->setup_size,
-                            usb_batch->buffer, usb_batch->buffer_size);
-        }
-        ehci_batch->usb_batch = usb_batch;
-
-        const usb_direction_t dir = usb_transfer_batch_direction(usb_batch);
-        assert(batch_setup[usb_batch->ep->transfer_type]);
-        batch_setup[usb_batch->ep->transfer_type](ehci_batch, dir);
-
-        usb_log_debug("Batch %p %s " USB_TRANSFER_BATCH_FMT " initialized.\n",
-            usb_batch, usb_str_direction(dir),
-            USB_TRANSFER_BATCH_ARGS(*usb_batch));
-
-        return ehci_batch;
-dispose:
-        ehci_transfer_batch_dispose(ehci_batch);
-        return NULL;
+        assert(ehci_batch->td_count > 0);
+
+        const size_t tds_size = ehci_batch->td_count * sizeof(td_t);
+
+        /* Mix setup stage and TDs together, we have enough space */
+        if (dma_buffer_alloc(&ehci_batch->ehci_dma_buffer, tds_size + setup_size)) {
+                usb_log_error("Batch %p: Failed to allocate device buffer",
+                    ehci_batch);
+                return ENOMEM;
+        }
+
+        /* Clean TDs */
+        ehci_batch->tds = ehci_batch->ehci_dma_buffer.virt;
+        memset(ehci_batch->tds, 0, tds_size);
+
+        /* Copy setup data */
+        ehci_batch->setup_buffer = ehci_batch->ehci_dma_buffer.virt + tds_size;
+        memcpy(ehci_batch->setup_buffer, ehci_batch->base.setup.buffer, setup_size);
+
+        /* Generic data already prepared*/
+        ehci_batch->data_buffer = ehci_batch->base.dma_buffer.virt;
+
+        if (!batch_setup[ehci_batch->base.ep->transfer_type])
+                return ENOTSUP;
+
+        batch_setup[ehci_batch->base.ep->transfer_type](ehci_batch);
+
+        usb_log_debug("Batch %p %s " USB_TRANSFER_BATCH_FMT " initialized.",
+            ehci_batch, usb_str_direction(ehci_batch->base.dir),
+            USB_TRANSFER_BATCH_ARGS(ehci_batch->base));
+
+        return EOK;
 }
 
@@ -184 +160 @@
  * completes with the last TD.
  */
-bool ehci_transfer_batch_is_complete(const ehci_transfer_batch_t *ehci_batch)
-{
-        assert(ehci_batch);
-        assert(ehci_batch->usb_batch);
-
-        usb_log_debug("Batch %p: checking %zu td(s) for completion.\n",
-            ehci_batch->usb_batch, ehci_batch->td_count);
-
-        usb_log_debug2("Batch %p: QH: %08x:%08x:%08x:%08x:%08x:%08x.\n",
-            ehci_batch->usb_batch,
+bool ehci_transfer_batch_check_completed(ehci_transfer_batch_t *ehci_batch)
+{
+        assert(ehci_batch);
+
+        usb_log_debug("Batch %p: checking %zu td(s) for completion.",
+            ehci_batch, ehci_batch->td_count);
+
+        usb_log_debug2("Batch %p: QH: %08x:%08x:%08x:%08x:%08x:%08x.",
+            ehci_batch,
             ehci_batch->qh->ep_char, ehci_batch->qh->ep_cap,
             ehci_batch->qh->status, ehci_batch->qh->current,
@@ -206 +181 @@
 
         /* Assume all data got through */
-        ehci_batch->usb_batch->transfered_size =
-            ehci_batch->usb_batch->buffer_size;
+        ehci_batch->base.transferred_size = ehci_batch->base.size;
 
         /* Check all TDs */
         for (size_t i = 0; i < ehci_batch->td_count; ++i) {
-                assert(ehci_batch->tds[i] != NULL);
                 usb_log_debug("Batch %p: TD %zu: %08x:%08x:%08x.",
-                    ehci_batch->usb_batch, i,
-                    ehci_batch->tds[i]->status, ehci_batch->tds[i]->next,
-                    ehci_batch->tds[i]->alternate);
-
-                ehci_batch->usb_batch->error = td_error(ehci_batch->tds[i]);
-                if (ehci_batch->usb_batch->error == EOK) {
+                    ehci_batch, i,
+                    ehci_batch->tds[i].status, ehci_batch->tds[i].next,
+                    ehci_batch->tds[i].alternate);
+
+                ehci_batch->base.error = td_error(&ehci_batch->tds[i]);
+                if (ehci_batch->base.error == EOK) {
                         /* If the TD got all its data through, it will report
                          * 0 bytes remain, the sole exception is INPUT with
@@ -231 +204 @@
                          * we leave the very last(unused) TD behind.
                          */
-                        ehci_batch->usb_batch->transfered_size
-                            -= td_remain_size(ehci_batch->tds[i]);
+                        ehci_batch->base.transferred_size
+                            -= td_remain_size(&ehci_batch->tds[i]);
                 } else {
                         usb_log_debug("Batch %p found error TD(%zu):%08x: %s.",
-                            ehci_batch->usb_batch, i,
-                            ehci_batch->tds[i]->status,
-                            str_error_name(ehci_batch->usb_batch->error));
+                            ehci_batch, i,
+                            ehci_batch->tds[i].status,
+                            str_error_name(ehci_batch->base.error));
                         /* Clear possible ED HALT */
                         qh_clear_halt(ehci_batch->qh);
@@ -244 +217 @@
         }
 
-        assert(ehci_batch->usb_batch->transfered_size <=
-            ehci_batch->usb_batch->buffer_size);
+        assert(ehci_batch->base.transferred_size <= ehci_batch->base.size);
+
         /* Clear TD pointers */
         ehci_batch->qh->next = LINK_POINTER_TERM;
         ehci_batch->qh->current = LINK_POINTER_TERM;
-        usb_log_debug("Batch %p complete: %s", ehci_batch->usb_batch,
-            str_error(ehci_batch->usb_batch->error));
+        usb_log_debug("Batch %p complete: %s", ehci_batch,
+            str_error(ehci_batch->base.error));
 
         return true;
@@ -262 +235 @@
 {
         assert(ehci_batch);
-        qh_set_next_td(ehci_batch->qh, ehci_batch->tds[0]);
+        qh_set_next_td(ehci_batch->qh,
+            dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[0]));
 }
 
@@ -268 +242 @@
  *
  * @param[in] ehci_batch Batch structure to use.
- * @param[in] dir Communication direction
  *
  * Setup stage with toggle 0 and direction BOTH(SETUP_PID)
- * Data stage with alternating toggle and direction supplied by parameter.
- * Status stage with toggle 1 and direction supplied by parameter.
- */
-static void batch_control(ehci_transfer_batch_t *ehci_batch, usb_direction_t dir)
-{
-        assert(ehci_batch);
-        assert(ehci_batch->usb_batch);
+ * Data stage with alternating toggle and direction
+ * Status stage with toggle 1 and direction
+ */
+static void batch_control(ehci_transfer_batch_t *ehci_batch)
+{
+        assert(ehci_batch);
+
+        usb_direction_t dir = ehci_batch->base.dir;
         assert(dir == USB_DIRECTION_IN || dir == USB_DIRECTION_OUT);
 
-        usb_log_debug2("Batch %p: Control QH(%"PRIxn"): "
-            "%08x:%08x:%08x:%08x:%08x:%08x", ehci_batch->usb_batch,
-            addr_to_phys(ehci_batch->qh),
+        usb_log_debug2("Batch %p: Control QH(%p): "
+            "%08x:%08x:%08x:%08x:%08x:%08x", ehci_batch,
+            ehci_batch->qh,
             ehci_batch->qh->ep_char, ehci_batch->qh->ep_cap,
             ehci_batch->qh->status, ehci_batch->qh->current,
@@ -292 +266 @@
 
         int toggle = 0;
-        const char* buffer = ehci_batch->device_buffer;
         const usb_direction_t data_dir = dir;
         const usb_direction_t status_dir = reverse_dir[dir];
 
         /* Setup stage */
-        td_init(ehci_batch->tds[0], ehci_batch->tds[1], USB_DIRECTION_BOTH,
-            buffer, ehci_batch->usb_batch->setup_size, toggle, false);
+        td_init(&ehci_batch->tds[0],
+            dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[1]),
+            dma_buffer_phys(&ehci_batch->ehci_dma_buffer, ehci_batch->setup_buffer),
+            USB_DIRECTION_BOTH, USB_SETUP_PACKET_SIZE, toggle, false);
         usb_log_debug2("Batch %p: Created CONTROL SETUP TD(%"PRIxn"): "
-            "%08x:%08x:%08x", ehci_batch->usb_batch,
-            addr_to_phys(ehci_batch->tds[0]),
-            ehci_batch->tds[0]->status, ehci_batch->tds[0]->next,
-            ehci_batch->tds[0]->alternate);
-        buffer += ehci_batch->usb_batch->setup_size;
+            "%08x:%08x:%08x", ehci_batch,
+            dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[0]),
+            ehci_batch->tds[0].status, ehci_batch->tds[0].next,
+            ehci_batch->tds[0].alternate);
 
         /* Data stage */
-        size_t td_current = 1;
-        size_t remain_size = ehci_batch->usb_batch->buffer_size;
+        unsigned td_current = 1;
+        size_t remain_size = ehci_batch->base.size;
+        uintptr_t buffer = dma_buffer_phys(&ehci_batch->base.dma_buffer,
+            ehci_batch->data_buffer);
         while (remain_size > 0) {
-                const size_t transfer_size =
-                    min(remain_size, EHCI_TD_MAX_TRANSFER);
+                const size_t transfer_size = min(remain_size, EHCI_TD_MAX_TRANSFER);
                 toggle = 1 - toggle;
 
-                td_init(ehci_batch->tds[td_current],
-                    ehci_batch->tds[td_current + 1], data_dir, buffer,
-                    transfer_size, toggle, false);
+                td_init(&ehci_batch->tds[td_current],
+                    dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[td_current + 1]),
+                    buffer, data_dir, transfer_size, toggle, false);
                 usb_log_debug2("Batch %p: Created CONTROL DATA TD(%"PRIxn"): "
-                    "%08x:%08x:%08x", ehci_batch->usb_batch,
-                    addr_to_phys(ehci_batch->tds[td_current]),
-                    ehci_batch->tds[td_current]->status,
-                    ehci_batch->tds[td_current]->next,
-                    ehci_batch->tds[td_current]->alternate);
+                    "%08x:%08x:%08x", ehci_batch,
+                    dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[td_current]),
+                    ehci_batch->tds[td_current].status,
+                    ehci_batch->tds[td_current].next,
+                    ehci_batch->tds[td_current].alternate);
 
                 buffer += transfer_size;
@@ -332 +307 @@
         /* Status stage */
         assert(td_current == ehci_batch->td_count - 1);
-        td_init(ehci_batch->tds[td_current], NULL, status_dir, NULL, 0, 1, true);
-        usb_log_debug2("Batch %p: Created CONTROL STATUS TD(%"PRIxn"): "
-            "%08x:%08x:%08x", ehci_batch->usb_batch,
-            addr_to_phys(ehci_batch->tds[td_current]),
-            ehci_batch->tds[td_current]->status,
-            ehci_batch->tds[td_current]->next,
-            ehci_batch->tds[td_current]->alternate);
+        td_init(&ehci_batch->tds[td_current], 0, 0, status_dir, 0, 1, true);
+        usb_log_debug2("Batch %p: Created CONTROL STATUS TD %d(%"PRIxn"): "
+            "%08x:%08x:%08x", ehci_batch, td_current,
+            dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[td_current]),
+            ehci_batch->tds[td_current].status,
+            ehci_batch->tds[td_current].next,
+            ehci_batch->tds[td_current].alternate);
 }
 
@@ -349 +324 @@
  * EHCI hw in ED.
  */
-static void batch_data(ehci_transfer_batch_t *ehci_batch, usb_direction_t dir)
-{
-        assert(ehci_batch);
-        assert(ehci_batch->usb_batch);
-        assert(dir == USB_DIRECTION_IN || dir == USB_DIRECTION_OUT);
-
-        usb_log_debug2("Batch %p: Data QH(%"PRIxn"): "
-            "%08x:%08x:%08x:%08x:%08x:%08x", ehci_batch->usb_batch,
-            addr_to_phys(ehci_batch->qh),
+static void batch_data(ehci_transfer_batch_t *ehci_batch)
+{
+        assert(ehci_batch);
+
+        usb_log_debug2("Batch %p: Data QH(%p): "
+            "%08x:%08x:%08x:%08x:%08x:%08x", ehci_batch,
+            ehci_batch->qh,
             ehci_batch->qh->ep_char, ehci_batch->qh->ep_cap,
             ehci_batch->qh->status, ehci_batch->qh->current,
@@ -363 +336 @@
 
         size_t td_current = 0;
-        size_t remain_size = ehci_batch->usb_batch->buffer_size;
-        char *buffer = ehci_batch->device_buffer;
+        size_t remain_size = ehci_batch->base.size;
+        uintptr_t buffer = dma_buffer_phys(&ehci_batch->base.dma_buffer,
+            ehci_batch->data_buffer);
         while (remain_size > 0) {
                 const size_t transfer_size = remain_size > EHCI_TD_MAX_TRANSFER
@@ -370 +344 @@
 
                 const bool last = (remain_size == transfer_size);
-                td_init(
-                    ehci_batch->tds[td_current],
-                    last ? NULL : ehci_batch->tds[td_current + 1],
-                    dir, buffer, transfer_size, -1, last);
+                td_init(&ehci_batch->tds[td_current],
+                    last ? 0 : dma_buffer_phys(&ehci_batch->ehci_dma_buffer,
+                            &ehci_batch->tds[td_current + 1]),
+                    buffer, ehci_batch->base.dir, transfer_size, -1, last);
 
                 usb_log_debug2("Batch %p: DATA TD(%"PRIxn": %08x:%08x:%08x",
-                    ehci_batch->usb_batch,
-                    addr_to_phys(ehci_batch->tds[td_current]),
-                    ehci_batch->tds[td_current]->status,
-                    ehci_batch->tds[td_current]->next,
-                    ehci_batch->tds[td_current]->alternate);
+                    ehci_batch,
+                    dma_buffer_phys(&ehci_batch->ehci_dma_buffer,
+                        &ehci_batch->tds[td_current]),
+                    ehci_batch->tds[td_current].status,
+                    ehci_batch->tds[td_current].next,
+                    ehci_batch->tds[td_current].alternate);
 
                 buffer += transfer_size;
@@ -390 +365 @@
 
 /** Transfer setup table. */
-static void (*const batch_setup[])(ehci_transfer_batch_t*, usb_direction_t) =
+static void (*const batch_setup[])(ehci_transfer_batch_t*) =
 {
         [USB_TRANSFER_CONTROL] = batch_control,

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2014 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -39 +40 @@
 #include <stdbool.h>
 #include <usb/host/usb_transfer_batch.h>
+#include <usb/dma_buffer.h>
 
 #include "hw_struct/queue_head.h"
@@ -45 +47 @@
 /** EHCI specific data required for USB transfer */
 typedef struct ehci_transfer_batch {
-        /** Link */
-        link_t link;
+        usb_transfer_batch_t base;
+        /** Number of TDs used by the transfer */
+        size_t td_count;
         /** Endpoint descriptor of the target endpoint. */
         qh_t *qh;
-        /** List of TDs needed for the transfer */
-        td_t **tds;
-        /** Number of TDs used by the transfer */
-        size_t td_count;
-        /** Data buffer, must be accessible by the EHCI hw. */
-        char *device_buffer;
+        /** Backend for TDs and setup data. */
+        dma_buffer_t ehci_dma_buffer;
+        /** List of TDs needed for the transfer - backed by dma_buffer */
+        td_t *tds;
+        /** Data buffers - backed by dma_buffer */
+        void *setup_buffer;
+        void *data_buffer;
         /** Generic USB transfer structure */
         usb_transfer_batch_t *usb_batch;
 } ehci_transfer_batch_t;
 
-ehci_transfer_batch_t * ehci_transfer_batch_get(usb_transfer_batch_t *batch);
-bool ehci_transfer_batch_is_complete(const ehci_transfer_batch_t *batch);
+ehci_transfer_batch_t *ehci_transfer_batch_create(endpoint_t *ep);
+int ehci_transfer_batch_prepare(ehci_transfer_batch_t *batch);
 void ehci_transfer_batch_commit(const ehci_transfer_batch_t *batch);
-void ehci_transfer_batch_finish_dispose(ehci_transfer_batch_t *batch);
+bool ehci_transfer_batch_check_completed(ehci_transfer_batch_t *batch);
+void ehci_transfer_batch_destroy(ehci_transfer_batch_t *batch);
 
-static inline ehci_transfer_batch_t *ehci_transfer_batch_from_link(link_t *l)
+static inline ehci_transfer_batch_t *ehci_transfer_batch_get(
+    usb_transfer_batch_t *usb_batch)
 {
-        assert(l);
-        return list_get_instance(l, ehci_transfer_batch_t, link);
+        assert(usb_batch);
+
+        return (ehci_transfer_batch_t *) usb_batch;
 }
+
 #endif
 /**

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -32 +33 @@
  * @brief EHCI driver
  */
-#ifndef DRV_EHCI_HCD_ENDPOINT_H
-#define DRV_EHCI_HCD_ENDPOINT_H
+#ifndef DRV_EHCI_HCD_BUS_H
+#define DRV_EHCI_HCD_BUS_H
 
 #include <assert.h>
 #include <adt/list.h>
+#include <usb/host/usb2_bus.h>
 #include <usb/host/endpoint.h>
-#include <usb/host/hcd.h>
+#include <usb/dma_buffer.h>
 
 #include "hw_struct/queue_head.h"
-#include "hw_struct/transfer_descriptor.h"
 
 /** Connector structure linking ED to to prepared TD. */
 typedef struct ehci_endpoint {
-        /** EHCI endpoint descriptor */
+        /* Inheritance */
+        endpoint_t base;
+
+        /** EHCI endpoint descriptor, backed by dma_buffer */
         qh_t *qh;
-        /** Linked list used by driver software */
-        link_t link;
+        
+        dma_buffer_t dma_buffer;
+
+        /** Link in endpoint_list */
+        link_t eplist_link;
+
+        /** Link in pending_endpoints */
+        link_t pending_link;
 } ehci_endpoint_t;
 
-errno_t ehci_endpoint_init(hcd_t *hcd, endpoint_t *ep);
-void ehci_endpoint_fini(hcd_t *hcd, endpoint_t *ep);
+typedef struct hc hc_t;
+
+typedef struct {
+        bus_t base;
+        usb2_bus_helper_t helper;
+        hc_t *hc;
+} ehci_bus_t;
+
+void ehci_ep_toggle_reset(endpoint_t *);
+void ehci_bus_prepare_ops(void);
+
+errno_t 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)
+static inline ehci_endpoint_t *ehci_endpoint_get(const endpoint_t *ep)
 {
         assert(ep);
-        return ep->hc_data.data;
+        return (ehci_endpoint_t *) ep;
 }
 
-static inline ehci_endpoint_t * ehci_endpoint_list_instance(link_t *l)
+static inline ehci_endpoint_t *ehci_endpoint_list_instance(link_t *l)
 {
-        return list_get_instance(l, ehci_endpoint_t, link);
+        return list_get_instance(l, ehci_endpoint_t, eplist_link);
 }
 
@@ -73 +93 @@
  * @}
  */
-

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2013 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -100 +101 @@
  */
 errno_t ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps, ehci_regs_t *regs,
-    const char *name)
+    fibril_mutex_t *guard, const char *name)
 {
         assert(instance);
@@ -107 +108 @@
             (EHCI_RD(caps->hcsparams) >> EHCI_CAPS_HCS_N_PORTS_SHIFT) &
             EHCI_CAPS_HCS_N_PORTS_MASK;
-        usb_log_debug2("RH(%p): hcsparams: %x.\n", instance,
+        usb_log_debug2("RH(%p): hcsparams: %x.", instance,
             EHCI_RD(caps->hcsparams));
-        usb_log_info("RH(%p): Found %u ports.\n", instance,
+        usb_log_info("RH(%p): Found %u ports.", instance,
             instance->port_count);
 
@@ -127 +128 @@
 
         ehci_rh_hub_desc_init(instance, EHCI_RD(caps->hcsparams));
-        instance->unfinished_interrupt_transfer = NULL;
+        instance->guard = guard;
+        instance->status_change_endpoint = NULL;
 
         return virthub_base_init(&instance->base, name, &ops, instance,
@@ -144 +146 @@
         assert(instance);
         assert(batch);
-        const usb_target_t target = {{
-                .address = batch->ep->address,
-                .endpoint = batch->ep->endpoint,
-        }};
-        batch->error = virthub_base_request(&instance->base, target,
-            usb_transfer_batch_direction(batch), (void*)batch->setup_buffer,
-            batch->buffer, batch->buffer_size, &batch->transfered_size);
+        batch->error = virthub_base_request(&instance->base, batch->target,
+            batch->dir, (void*) batch->setup.buffer,
+            batch->dma_buffer.virt, batch->size,
+            &batch->transferred_size);
         if (batch->error == ENAK) {
                 usb_log_debug("RH(%p): BATCH(%p) adding as unfinished",
                     instance, batch);
-                /* This is safe because only status change interrupt transfers
-                 * return NAK. The assertion holds true because the batch
-                 * existence prevents communication with that ep */
-                assert(instance->unfinished_interrupt_transfer == NULL);
-                instance->unfinished_interrupt_transfer = batch;
+
+                /* Lock the HC guard */
+                fibril_mutex_lock(instance->guard);
+                const int err = endpoint_activate_locked(batch->ep, batch);
+                if (err) {
+                        fibril_mutex_unlock(batch->ep->guard);
+                        return err;
+                }
+
+                /*
+                 * Asserting that the HC do not run two instances of the status
+                 * change endpoint - shall be true.
+                 */
+                assert(!instance->status_change_endpoint);
+
+                endpoint_add_ref(batch->ep);
+                instance->status_change_endpoint = batch->ep;
+                fibril_mutex_unlock(instance->guard);
         } else {
-                usb_transfer_batch_finish(batch, NULL);
-                usb_transfer_batch_destroy(batch);
                 usb_log_debug("RH(%p): BATCH(%p) virtual request complete: %s",
                     instance, batch, str_error(batch->error));
+                usb_transfer_batch_finish(batch);
         }
         return EOK;
@@ -177 +188 @@
 errno_t ehci_rh_interrupt(ehci_rh_t *instance)
 {
-        //TODO atomic swap needed
-        usb_transfer_batch_t *batch = instance->unfinished_interrupt_transfer;
-        instance->unfinished_interrupt_transfer = NULL;
-        usb_log_debug2("RH(%p): Interrupt. Processing batch: %p",
-            instance, batch);
+        fibril_mutex_lock(instance->guard);
+        endpoint_t *ep = instance->status_change_endpoint;
+        if (!ep) {
+                fibril_mutex_unlock(instance->guard);
+                return EOK;
+        }
+
+        usb_transfer_batch_t * const batch = ep->active_batch;
+        endpoint_deactivate_locked(ep);
+        instance->status_change_endpoint = NULL;
+        fibril_mutex_unlock(instance->guard);
+
+        endpoint_del_ref(ep);
+
         if (batch) {
-                const usb_target_t target = {{
-                        .address = batch->ep->address,
-                        .endpoint = batch->ep->endpoint,
-                }};
-                batch->error = virthub_base_request(&instance->base, target,
-                    usb_transfer_batch_direction(batch),
-                    (void*)batch->setup_buffer,
-                    batch->buffer, batch->buffer_size, &batch->transfered_size);
-                usb_transfer_batch_finish(batch, NULL);
-                usb_transfer_batch_destroy(batch);
+                usb_log_debug2("RH(%p): Interrupt. Processing batch: %p",
+                    instance, batch);
+                batch->error = virthub_base_request(&instance->base, batch->target,
+                    batch->dir, (void*) batch->setup.buffer,
+                    batch->dma_buffer.virt, batch->size,
+                    &batch->transferred_size);
+                usb_transfer_batch_finish(batch);
         }
         return EOK;
@@ -258 +275 @@
 
 #define BIT_VAL(val, bit)   ((val & bit) ? 1 : 0)
-#define EHCI2USB(val, bit, feat)   (BIT_VAL(val, bit) << feat)
+#define EHCI2USB(val, bit, mask)   (BIT_VAL(val, bit) ? mask : 0)
 
 /** Port status request handler.
@@ -280 +297 @@
         const uint32_t reg = EHCI_RD(hub->registers->portsc[port]);
         const uint32_t status = uint32_host2usb(
-            EHCI2USB(reg, USB_PORTSC_CONNECT_FLAG, USB_HUB_FEATURE_PORT_CONNECTION) |
-            EHCI2USB(reg, USB_PORTSC_ENABLED_FLAG, USB_HUB_FEATURE_PORT_ENABLE) |
-            EHCI2USB(reg, USB_PORTSC_SUSPEND_FLAG, USB_HUB_FEATURE_PORT_SUSPEND) |
-            EHCI2USB(reg, USB_PORTSC_OC_ACTIVE_FLAG, USB_HUB_FEATURE_PORT_OVER_CURRENT) |
-            EHCI2USB(reg, USB_PORTSC_PORT_RESET_FLAG, USB_HUB_FEATURE_PORT_RESET) |
-            EHCI2USB(reg, USB_PORTSC_PORT_POWER_FLAG, USB_HUB_FEATURE_PORT_POWER) |
+            EHCI2USB(reg, USB_PORTSC_CONNECT_FLAG, USB_HUB_PORT_STATUS_CONNECTION) |
+            EHCI2USB(reg, USB_PORTSC_ENABLED_FLAG, USB_HUB_PORT_STATUS_ENABLE) |
+            EHCI2USB(reg, USB_PORTSC_SUSPEND_FLAG, USB2_HUB_PORT_STATUS_SUSPEND) |
+            EHCI2USB(reg, USB_PORTSC_OC_ACTIVE_FLAG, USB_HUB_PORT_STATUS_OC) |
+            EHCI2USB(reg, USB_PORTSC_PORT_RESET_FLAG, USB_HUB_PORT_STATUS_RESET) |
+            EHCI2USB(reg, USB_PORTSC_PORT_POWER_FLAG, USB2_HUB_PORT_STATUS_POWER) |
             (((reg & USB_PORTSC_LINE_STATUS_MASK) == USB_PORTSC_LINE_STATUS_K) ?
-                (1 << USB_HUB_FEATURE_PORT_LOW_SPEED) : 0) |
-            ((reg & USB_PORTSC_PORT_OWNER_FLAG) ? 0 : (1 << USB_HUB_FEATURE_PORT_HIGH_SPEED)) |
-            EHCI2USB(reg, USB_PORTSC_PORT_TEST_MASK, 11) |
-            EHCI2USB(reg, USB_PORTSC_INDICATOR_MASK, 12) |
-            EHCI2USB(reg, USB_PORTSC_CONNECT_CH_FLAG, USB_HUB_FEATURE_C_PORT_CONNECTION) |
-            EHCI2USB(reg, USB_PORTSC_EN_CHANGE_FLAG, USB_HUB_FEATURE_C_PORT_ENABLE) |
-            (hub->resume_flag[port] ? (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) : 0) |
-            EHCI2USB(reg, USB_PORTSC_OC_CHANGE_FLAG, USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
-            (hub->reset_flag[port] ? (1 << USB_HUB_FEATURE_C_PORT_RESET): 0)
+                (USB2_HUB_PORT_STATUS_LOW_SPEED) : 0) |
+            ((reg & USB_PORTSC_PORT_OWNER_FLAG) ? 0 : USB2_HUB_PORT_STATUS_HIGH_SPEED) |
+            EHCI2USB(reg, USB_PORTSC_PORT_TEST_MASK, USB2_HUB_PORT_STATUS_TEST) |
+            EHCI2USB(reg, USB_PORTSC_INDICATOR_MASK, USB2_HUB_PORT_STATUS_INDICATOR) |
+            EHCI2USB(reg, USB_PORTSC_CONNECT_CH_FLAG, USB_HUB_PORT_STATUS_C_CONNECTION) |
+            EHCI2USB(reg, USB_PORTSC_EN_CHANGE_FLAG, USB2_HUB_PORT_STATUS_C_ENABLE) |
+            (hub->resume_flag[port] ? USB2_HUB_PORT_STATUS_C_SUSPEND : 0) |
+            EHCI2USB(reg, USB_PORTSC_OC_CHANGE_FLAG, USB_HUB_PORT_STATUS_C_OC) |
+            (hub->reset_flag[port] ? USB_HUB_PORT_STATUS_C_RESET: 0)
         );
         /* Note feature numbers for test and indicator feature do not
@@ -396 +413 @@
                 return EOK;
 
-        case USB_HUB_FEATURE_PORT_ENABLE:         /*1*/
+        case USB2_HUB_FEATURE_PORT_ENABLE:         /*1*/
                 usb_log_debug2("RH(%p-%u): Clear port enable.", hub, port);
                 EHCI_CLR(hub->registers->portsc[port],
@@ -402 +419 @@
                 return EOK;
 
-        case USB_HUB_FEATURE_PORT_SUSPEND:        /*2*/
+        case USB2_HUB_FEATURE_PORT_SUSPEND:        /*2*/
                 usb_log_debug2("RH(%p-%u): Clear port suspend.", hub, port);
                 /* If not in suspend it's noop */
@@ -420 +437 @@
                     USB_PORTSC_CONNECT_CH_FLAG);
                 return EOK;
-        case USB_HUB_FEATURE_C_PORT_ENABLE:       /*17*/
+        case USB2_HUB_FEATURE_C_PORT_ENABLE:       /*17*/
                 usb_log_debug2("RH(%p-%u): Clear port enable change.",
                     hub, port);
@@ -432 +449 @@
                     USB_PORTSC_OC_CHANGE_FLAG);
                 return EOK;
-        case USB_HUB_FEATURE_C_PORT_SUSPEND:      /*18*/
+        case USB2_HUB_FEATURE_C_PORT_SUSPEND:      /*18*/
                 usb_log_debug2("RH(%p-%u): Clear port suspend change.",
                     hub, port);
@@ -467 +484 @@
         const unsigned feature = uint16_usb2host(setup_packet->value);
         switch (feature) {
-        case USB_HUB_FEATURE_PORT_ENABLE:  /*1*/
+        case USB2_HUB_FEATURE_PORT_ENABLE:  /*1*/
                 usb_log_debug2("RH(%p-%u): Set port enable.", hub, port);
                 EHCI_SET(hub->registers->portsc[port],
                     USB_PORTSC_ENABLED_FLAG);
                 return EOK;
-        case USB_HUB_FEATURE_PORT_SUSPEND: /*2*/
+        case USB2_HUB_FEATURE_PORT_SUSPEND: /*2*/
                 usb_log_debug2("RH(%p-%u): Set port suspend.", hub, port);
                 EHCI_SET(hub->registers->portsc[port],

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2013 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -61 +62 @@
                 uint8_t rempow[STATUS_BYTES(EHCI_MAX_PORTS) * 2];
         } __attribute__((packed)) hub_descriptor;
-        /** interrupt transfer waiting for an actual interrupt to occur */
-        usb_transfer_batch_t *unfinished_interrupt_transfer;
         bool reset_flag[EHCI_MAX_PORTS];
         bool resume_flag[EHCI_MAX_PORTS];
+
+        /* HC guard */
+        fibril_mutex_t *guard;
+
+        /*
+         * This is sort of hacky, but better than duplicating functionality.
+         * We cannot simply store a pointer to a transfer in-progress, in order
+         * to allow it to be aborted. We can however store a reference to the
+         * Status Change Endpoint. Note that this is mixing two worlds together
+         * - otherwise, the RH is "a device" and have no clue about HC, apart
+         * from accessing its registers.
+         */
+        endpoint_t *status_change_endpoint;
+
 } ehci_rh_t;
 
-errno_t ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps, ehci_regs_t *regs,
-    const char *name);
+errno_t ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps,
+    ehci_regs_t *regs, fibril_mutex_t *guard, const char *name);
 errno_t ehci_rh_schedule(ehci_rh_t *instance, usb_transfer_batch_t *batch);
 errno_t ehci_rh_interrupt(ehci_rh_t *instance);

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2014 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -54 +55 @@
         assert(instance);
         instance->name = name;
-        instance->list_head = malloc32(sizeof(qh_t));
-        if (!instance->list_head) {
+        if (dma_buffer_alloc(&instance->dma_buffer, sizeof(qh_t))) {
                 usb_log_error("EPL(%p-%s): Failed to allocate list head.",
                     instance, name);
                 return ENOMEM;
         }
+        instance->list_head = instance->dma_buffer.virt;
         qh_init(instance->list_head, NULL);
 
@@ -95 +96 @@
 {
         assert(instance);
+        assert(instance->list_head);
         assert(ep);
         assert(ep->qh);
-        usb_log_debug2("EPL(%p-%s): Append endpoint(%p).\n",
+        usb_log_debug2("EPL(%p-%s): Append endpoint(%p).",
             instance, instance->name, ep);
 
@@ -124 +126 @@
         write_barrier();
         /* Add to the sw list */
-        list_append(&ep->link, &instance->endpoint_list);
+        list_append(&ep->eplist_link, &instance->endpoint_list);
 
         ehci_endpoint_t *first = ehci_endpoint_list_instance(
             list_first(&instance->endpoint_list));
-        usb_log_debug("EPL(%p-%s): EP(%p) added to list, first is %p(%p).\n",
+        usb_log_debug("EPL(%p-%s): EP(%p) added to list, first is %p(%p).",
             instance, instance->name, ep, first, first->qh);
         if (last_qh == instance->list_head) {
-                usb_log_debug2("EPL(%p-%s): head EP(%p-%"PRIxn"): %x:%x.\n",
+                usb_log_debug2("EPL(%p-%s): head EP(%p-%"PRIxn"): %x:%x.",
                     instance, instance->name, last_qh,
                     addr_to_phys(instance->list_head),
@@ -153 +155 @@
         fibril_mutex_lock(&instance->guard);
 
-        usb_log_debug2("EPL(%p-%s): removing EP(%p).\n",
+        usb_log_debug2("EPL(%p-%s): removing EP(%p).",
             instance, instance->name, ep);
 
@@ -159 +161 @@
         qh_t *prev_qh;
         /* Remove from the hardware queue */
-        if (list_first(&instance->endpoint_list) == &ep->link) {
+        if (list_first(&instance->endpoint_list) == &ep->eplist_link) {
                 /* I'm the first one here */
                 prev_qh = instance->list_head;
                 qpos = "FIRST";
         } else {
-                prev_qh = ehci_endpoint_list_instance(ep->link.prev)->qh;
+                prev_qh = ehci_endpoint_list_instance(ep->eplist_link.prev)->qh;
                 qpos = "NOT FIRST";
         }
@@ -172 +174 @@
         write_barrier();
 
-        usb_log_debug("EPL(%p-%s): EP(%p) removed (%s), horizontal %x.\n",
+        usb_log_debug("EPL(%p-%s): EP(%p) removed (%s), horizontal %x.",
             instance, instance->name,  ep, qpos, ep->qh->horizontal);
 
         /* Remove from the endpoint list */
-        list_remove(&ep->link);
+        list_remove(&ep->eplist_link);
         fibril_mutex_unlock(&instance->guard);
 }

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

@@ -38 +38 @@
 #include <assert.h>
 #include <fibril_synch.h>
-#include <usb/host/utils/malloc32.h>
 
-#include "ehci_endpoint.h"
+#include "ehci_bus.h"
 #include "hw_struct/queue_head.h"
 
@@ -49 +48 @@
         /** EHCI hw structure at the beginning of the queue */
         qh_t *list_head;
+        dma_buffer_t dma_buffer;
         /** Assigned name, provides nicer debug output */
         const char *name;
@@ -64 +64 @@
 {
         assert(instance);
-        free32(instance->list_head);
+        dma_buffer_free(&instance->dma_buffer);
         instance->list_head = NULL;
 }

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -45 +46 @@
 #include <usb/debug.h>
 #include <usb/usb.h>
-#include <usb/host/utils/malloc32.h>
+#include <usb/host/utility.h>
 
 #include "ehci_batch.h"
@@ -89 +90 @@
 };
 
-static void hc_start(hc_t *instance);
 static errno_t hc_init_memory(hc_t *instance);
 
@@ -100 +100 @@
  * @return Error code.
  */
-errno_t ehci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res, int *irq)
+errno_t hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
 {
         assert(code);
         assert(hw_res);
+        hc_t *instance = hcd_to_hc(hcd);
 
         if (hw_res->irqs.count != 1 || hw_res->mem_ranges.count != 1)
@@ -130 +131 @@
 
         memcpy(code->cmds, ehci_irq_commands, sizeof(ehci_irq_commands));
-        ehci_caps_regs_t *caps = NULL;
-
-        errno_t ret = pio_enable_range(&regs, (void**)&caps);
-        if (ret != EOK) {
-                free(code->ranges);
-                free(code->cmds);
-                return ret;
-        }
 
         ehci_regs_t *registers =
-            (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(caps->caplength));
+                (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(instance->caps->caplength));
         code->cmds[0].addr = (void *) &registers->usbsts;
         code->cmds[3].addr = (void *) &registers->usbsts;
         EHCI_WR(code->cmds[1].value, EHCI_USED_INTERRUPTS);
 
-        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
+        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.",
             RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
 
@@ -159 +152 @@
  * @return Error code
  */
-errno_t hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res, bool interrupts)
-{
-        assert(instance);
+errno_t 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 ||
@@ -172 +165 @@
         if (ret != EOK) {
                 usb_log_error("HC(%p): Failed to gain access to device "
-                    "registers: %s.\n", instance, str_error(ret));
+                    "registers: %s.", instance, str_error(ret));
                 return ret;
         }
+
         usb_log_info("HC(%p): Device registers at %"PRIx64" (%zuB) accessible.",
             instance, hw_res->mem_ranges.ranges[0].address.absolute,
@@ -184 +178 @@
             + EHCI_RD8(instance->caps->caplength));
 
-        list_initialize(&instance->pending_batches);
+        list_initialize(&instance->pending_endpoints);
         fibril_mutex_initialize(&instance->guard);
         fibril_condvar_initialize(&instance->async_doorbell);
@@ -197 +191 @@
         usb_log_info("HC(%p): Initializing RH(%p).", instance, &instance->rh);
         ehci_rh_init(
-            &instance->rh, instance->caps, instance->registers, "ehci rh");
-        usb_log_debug("HC(%p): Starting HW.", instance);
-        hc_start(instance);
-
+            &instance->rh, instance->caps, instance->registers, &instance->guard,
+            "ehci rh");
+
+        ehci_bus_init(&instance->bus, instance);
+        hc_device_setup(hcd, (bus_t *) &instance->bus);
         return EOK;
 }
@@ -208 +203 @@
  * @param[in] instance Host controller structure to use.
  */
-void hc_fini(hc_t *instance)
-{
-        assert(instance);
-        //TODO: stop the hw
-#if 0
-        endpoint_list_fini(&instance->async_list);
-        endpoint_list_fini(&instance->int_list);
-        return_page(instance->periodic_list_base);
-#endif
+int hc_gone(hc_device_t *hcd)
+{
+        hc_t *hc = hcd_to_hc(hcd);
+        endpoint_list_fini(&hc->async_list);
+        endpoint_list_fini(&hc->int_list);
+        dma_buffer_free(&hc->dma_buffer);
+        return EOK;
 };
 
@@ -224 +217 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)\n", instance,
-            ep->address, ep->endpoint,
+        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)", instance,
+            ep->device->address, ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -248 +241 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)\n", instance,
-            ep->address, ep->endpoint,
+        usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)", instance,
+            ep->device->address, ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -273 +266 @@
 }
 
-errno_t ehci_hc_status(hcd_t *hcd, uint32_t *status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+errno_t 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;
 }
@@ -294 +290 @@
  * @return Error code.
  */
-errno_t ehci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+errno_t 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->ep->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);
+        }
+
+        endpoint_t * const ep = batch->ep;
+        ehci_endpoint_t * const ehci_ep = ehci_endpoint_get(ep);
         ehci_transfer_batch_t *ehci_batch = ehci_transfer_batch_get(batch);
-        if (!ehci_batch)
-                return ENOMEM;
-
-        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);
+
+        int err;
+
+        if ((err = ehci_transfer_batch_prepare(ehci_batch)))
+                return err;
+
+        fibril_mutex_lock(&hc->guard);
+
+        if ((err = endpoint_activate_locked(ep, batch))) {
+                fibril_mutex_unlock(&hc->guard);
+                return err;
+        }
+
+        usb_log_debug("HC(%p): Committing BATCH(%p)", hc, batch);
         ehci_transfer_batch_commit(ehci_batch);
 
-        fibril_mutex_unlock(&instance->guard);
+        /* Enqueue endpoint to the checked list */
+        usb_log_debug2("HC(%p): Appending BATCH(%p)", hc, batch);
+        list_append(&ehci_ep->pending_link, &hc->pending_endpoints);
+
+        fibril_mutex_unlock(&hc->guard);
         return EOK;
 }
@@ -325 +337 @@
  * @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) {
-                        ehci_transfer_batch_t *batch =
-                            ehci_transfer_batch_from_link(current);
-
-                        if (ehci_transfer_batch_is_complete(batch)) {
+                fibril_mutex_lock(&hc->guard);
+
+                usb_log_debug2("HC(%p): Scanning %lu pending endpoints", hc,
+                        list_count(&hc->pending_endpoints));
+                list_foreach_safe(hc->pending_endpoints, current, next) {
+                        ehci_endpoint_t *ep
+                                = list_get_instance(current, ehci_endpoint_t, pending_link);
+
+                        ehci_transfer_batch_t *batch
+                                = ehci_transfer_batch_get(ep->base.active_batch);
+                        assert(batch);
+
+                        if (ehci_transfer_batch_check_completed(batch)) {
+                                endpoint_deactivate_locked(&ep->base);
                                 list_remove(current);
-                                ehci_transfer_batch_finish_dispose(batch);
+                                hc_reset_toggles(&batch->base, &ehci_ep_toggle_reset);
+                                usb_transfer_batch_finish(&batch->base);
                         }
                 }
-                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
         }
@@ -371 +392 @@
  * @param[in] instance EHCI hc driver structure.
  */
-void hc_start(hc_t *instance)
-{
-        assert(instance);
+int hc_start(hc_device_t *hcd)
+{
+        hc_t *instance = hcd_to_hc(hcd);
+        usb_log_debug("HC(%p): Starting HW.", instance);
+
         /* Turn off the HC if it's running, Reseting a running device is
          * undefined */
@@ -404 +427 @@
 
         /* Enable periodic list */
-        assert(instance->periodic_list_base);
+        assert(instance->periodic_list);
         uintptr_t phys_base =
-            addr_to_phys((void*)instance->periodic_list_base);
+            addr_to_phys((void*)instance->periodic_list);
         assert((phys_base & USB_PERIODIC_LIST_BASE_MASK) == phys_base);
         EHCI_WR(instance->registers->periodiclistbase, phys_base);
@@ -425 +448 @@
         usb_log_debug("HC(%p): HW started.", instance);
 
-        usb_log_debug2("HC(%p): Registers: \n"
-            "\tUSBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)\n"
-            "\tUSBSTS(%p): %x(0x00001000 = HC halted)\n"
-            "\tUSBINT(%p): %x(0x0 = no interrupts).\n"
-            "\tCONFIG(%p): %x(0x0 = ports controlled by companion hc).\n",
+        usb_log_debug2("HC(%p): Registers: "
+            "\tUSBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)"
+            "\tUSBSTS(%p): %x(0x00001000 = HC halted)"
+            "\tUSBINT(%p): %x(0x0 = no interrupts)."
+            "\tCONFIG(%p): %x(0x0 = ports controlled by companion hc).",
             instance,
             &instance->registers->usbcmd, EHCI_RD(instance->registers->usbcmd),
@@ -438 +461 @@
         EHCI_WR(instance->registers->usbsts, EHCI_RD(instance->registers->usbsts));
         EHCI_WR(instance->registers->usbintr, EHCI_USED_INTERRUPTS);
+
+        return EOK;
+}
+
+/**
+ * Setup roothub as a virtual hub.
+ */
+int hc_setup_roothub(hc_device_t *hcd)
+{
+        return hc_setup_virtual_root_hub(hcd, USB_SPEED_HIGH);
 }
 
@@ -473 +506 @@
 
         /* Take 1024 periodic list heads, we ignore low mem options */
-        instance->periodic_list_base = get_page();
-        if (!instance->periodic_list_base) {
+        if (dma_buffer_alloc(&instance->dma_buffer, PAGE_SIZE)) {
                 usb_log_error("HC(%p): Failed to get ISO schedule page.",
                     instance);
@@ -481 +513 @@
                 return ENOMEM;
         }
+        instance->periodic_list = instance->dma_buffer.virt;
 
         usb_log_debug2("HC(%p): Initializing Periodic list.", instance);
-        for (unsigned i = 0;
-            i < PAGE_SIZE/sizeof(instance->periodic_list_base[0]); ++i)
+        for (unsigned i = 0; i < PAGE_SIZE/sizeof(link_pointer_t); ++i)
         {
                 /* Disable everything for now */
-                instance->periodic_list_base[i] =
+                instance->periodic_list[i] =
                     LINK_POINTER_QH(addr_to_phys(instance->int_list.list_head));
         }

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -55 +56 @@
 /** Main EHCI driver structure */
 typedef struct hc {
+        /* Common device header */
+        hc_device_t base;
+
         /** Memory mapped CAPS register area */
         ehci_caps_regs_t *caps;
@@ -60 +64 @@
         ehci_regs_t *registers;
 
-        /** Iso transfer list */
-        link_pointer_t *periodic_list_base;
+        /** Iso transfer list, backed by dma_buffer */
+        link_pointer_t *periodic_list;
+
+        dma_buffer_t dma_buffer;
 
         /** CONTROL and BULK schedules */
@@ -70 +76 @@
 
         /** List of active transfers */
-        list_t pending_batches;
+        list_t pending_endpoints;
 
         /** Guards schedule and endpoint manipulation */
@@ -80 +86 @@
         /** USB hub emulation structure */
         ehci_rh_t rh;
+
+        /** USB bookkeeping */
+        ehci_bus_t bus;
 } hc_t;
 
-errno_t hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res, 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 *);
 
-errno_t ehci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res, int *irq);
+/* Boottime operations */
+extern errno_t hc_add(hc_device_t *, const hw_res_list_parsed_t *);
+extern errno_t hc_start(hc_device_t *);
+extern errno_t hc_setup_roothub(hc_device_t *);
+extern errno_t hc_gen_irq_code(irq_code_t *, hc_device_t *,
+    const hw_res_list_parsed_t *, int *);
+extern errno_t hc_gone(hc_device_t *);
 
-void ehci_hc_interrupt(hcd_t *hcd, uint32_t status);
-errno_t ehci_hc_status(hcd_t *hcd, uint32_t *status);
-errno_t ehci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch);
+/** Runtime operations */
+extern void ehci_hc_interrupt(bus_t *, uint32_t);
+extern errno_t ehci_hc_status(bus_t *, uint32_t *);
+extern errno_t ehci_hc_schedule(usb_transfer_batch_t *);
+
 #endif
 /**

uspace/drv/bus/usb/ehci/hw_struct/iso_transfer_descriptor.h

@@ -72 +72 @@
         /* 64 bit struct only */
         volatile uint32_t extended_bp[7];
-} itd_t;
+} __attribute__((packed, aligned(32))) itd_t;
 #endif
 /**

uspace/drv/bus/usb/ehci/hw_struct/queue_head.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2013 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -37 +38 @@
 #include <mem.h>
 #include <macros.h>
+#include <usb/host/bus.h>
 
 #include "mem_access.h"
@@ -63 +65 @@
                 return;
         }
-        assert(ep->speed < ARRAY_SIZE(speed));
+        assert(ep->device->speed < ARRAY_SIZE(speed));
         EHCI_MEM32_WR(instance->ep_char,
-            QH_EP_CHAR_ADDR_SET(ep->address) |
+            QH_EP_CHAR_ADDR_SET(ep->device->address) |
             QH_EP_CHAR_EP_SET(ep->endpoint) |
-            speed[ep->speed] |
-            QH_EP_CHAR_MAX_LENGTH_SET(ep->max_packet_size)
-        );
+            speed[ep->device->speed] |
+            QH_EP_CHAR_MAX_LENGTH_SET(ep->max_packet_size));
         if (ep->transfer_type == USB_TRANSFER_CONTROL) {
-                if (ep->speed != USB_SPEED_HIGH)
+                if (ep->device->speed != USB_SPEED_HIGH)
                         EHCI_MEM32_SET(instance->ep_char, QH_EP_CHAR_C_FLAG);
                 /* Let BULK and INT use queue head managed toggle,
@@ -78 +79 @@
         }
         uint32_t ep_cap = QH_EP_CAP_C_MASK_SET(3 << 2) |
-                    QH_EP_CAP_MULTI_SET(ep->packets);
-        if (ep->speed != USB_SPEED_HIGH) {
+            QH_EP_CAP_MULTI_SET(ep->packets_per_uframe);
+        if (usb_speed_is_11(ep->device->speed)) {
+                assert(ep->device->tt.dev != NULL);
                 ep_cap |=
-                    QH_EP_CAP_TT_PORT_SET(ep->tt.port) |
-                    QH_EP_CAP_TT_ADDR_SET(ep->tt.address);
+                    QH_EP_CAP_TT_PORT_SET(ep->device->tt.port) |
+                    QH_EP_CAP_TT_ADDR_SET(ep->device->tt.dev->address);
         }
         if (ep->transfer_type == USB_TRANSFER_INTERRUPT) {

uspace/drv/bus/usb/ehci/hw_struct/queue_head.h

@@ -143 +143 @@
         /* 64 bit struct only */
         volatile uint32_t extended_bp[5];
-} qh_t;
+} __attribute__((packed, aligned(32))) qh_t;
 
 static inline void qh_append_qh(qh_t *qh, const qh_t *next)
@@ -193 +193 @@
 }
 
-static inline void qh_set_next_td(qh_t *qh, td_t *td)
+static inline void qh_set_next_td(qh_t *qh, uintptr_t td)
 {
         assert(qh);
         assert(td);
-        EHCI_MEM32_WR(qh->next, LINK_POINTER_TD(addr_to_phys(td)));
+        EHCI_MEM32_WR(qh->next, LINK_POINTER_TD(td));
 }
 

uspace/drv/bus/usb/ehci/hw_struct/split_iso_transfer_descriptor.h

@@ -89 +89 @@
         /* 64 bit struct only */
         volatile uint32_t extended_bp[2];
-} sitd_t;
+} __attribute__((packed, aligned(32))) sitd_t;
 #endif
 /**

uspace/drv/bus/usb/ehci/hw_struct/transfer_descriptor.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2014 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -39 +40 @@
 
 #include <usb/usb.h>
-#include <usb/host/utils/malloc32.h>
 
 #include "mem_access.h"
@@ -70 +70 @@
 };
 
+#include <usb/debug.h>
+
 /**
  * Initialize EHCI TD.
  * @param instance TD structure to initialize.
- * @param next Next TD in ED list.
+ * @param next_phys Next TD in ED list.
  * @param direction Used to determine PID, BOTH means setup PID.
  * @param buffer Pointer to the first byte of transferred data.
@@ -80 +82 @@
  *        any other value means that ED toggle will be used.
  */
-void td_init(td_t *instance, const td_t *next,
-    usb_direction_t direction, const void *buffer, size_t size, int toggle,
-    bool ioc)
+void td_init(td_t *instance, uintptr_t next_phys, uintptr_t buffer,
+    usb_direction_t direction, size_t size, int toggle, bool ioc)
 {
         assert(instance);
@@ -98 +99 @@
         }
 
-        if (buffer != NULL) {
+        if (buffer != 0) {
                 assert(size != 0);
                 for (unsigned i = 0; (i < ARRAY_SIZE(instance->buffer_pointer))
                     && size; ++i) {
-                        const uintptr_t page =
-                            (addr_to_phys(buffer) & TD_BUFFER_POINTER_MASK);
-                        const size_t offset =
-                            ((uintptr_t)buffer & TD_BUFFER_POINTER_OFFSET_MASK);
+                        const uintptr_t offset = buffer & TD_BUFFER_POINTER_OFFSET_MASK;
                         assert(offset == 0 || i == 0);
-                        size -= min((4096 - offset), size);
-                        buffer += min((4096 - offset), size);
-                        EHCI_MEM32_WR(instance->buffer_pointer[i],
-                            page | offset);
+                        const size_t this_size = min(size, 4096 - offset);
+                        EHCI_MEM32_WR(instance->buffer_pointer[i], buffer);
+                        size -= this_size;
+                        buffer += this_size;
                 }
         }
 
-        EHCI_MEM32_WR(instance->next, next ?
-            LINK_POINTER_TD(addr_to_phys(next)) : LINK_POINTER_TERM);
+        EHCI_MEM32_WR(instance->next, next_phys ?
+            LINK_POINTER_TD(next_phys) : LINK_POINTER_TERM);
 
         EHCI_MEM32_WR(instance->alternate, LINK_POINTER_TERM);

uspace/drv/bus/usb/ehci/hw_struct/transfer_descriptor.h

@@ -37 +37 @@
 #include <stddef.h>
 #include <stdint.h>
+#include <macros.h>
 #include "link_pointer.h"
 #include "mem_access.h"
@@ -75 +76 @@
         /* 64 bit struct only */
         volatile uint32_t extended_bp[5];
-} td_t;
+
+} __attribute__((packed,aligned(32))) td_t;
+
+static_assert(sizeof(td_t) % 32 == 0);
 
 static inline bool td_active(const td_t *td)
@@ -92 +96 @@
 errno_t td_error(const td_t *td);
 
-void td_init(td_t *td, const td_t *next, usb_direction_t dir, const void * buf,
+void td_init(td_t *td, uintptr_t next_phys, uintptr_t buf, usb_direction_t dir,
     size_t buf_size, int toggle, bool ioc);
 

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

@@ -2 +2 @@
  * Copyright (c) 2011 Jan Vesely
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2018 Ondrej Hlavaty, Petr Manek
  * All rights reserved.
  *
@@ -35 +36 @@
  */
 
-#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/ddf_helpers.h>
+#include <usb/host/hcd.h>
 
 #include "res.h"
 #include "hc.h"
-#include "ehci_endpoint.h"
 
 #define NAME "ehci"
 
-static errno_t ehci_driver_init(hcd_t *, const hw_res_list_parsed_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 = {
+        .hc_add = hc_add,
+        .irq_code_gen = hc_gen_irq_code,
         .claim = disable_legacy,
-        .hc_speed = USB_SPEED_HIGH,
-        .irq_code_gen = ehci_hc_gen_irq_code,
-        .init = ehci_driver_init,
-        .fini = ehci_driver_fini,
-        .name = "EHCI-PCI",
-        .ops = {
-                .schedule       = ehci_hc_schedule,
-                .ep_add_hook    = ehci_endpoint_init,
-                .ep_remove_hook = ehci_endpoint_fini,
-                .irq_hook       = ehci_hc_interrupt,
-                .status_hook    = ehci_hc_status,
-        }
+        .start = hc_start,
+        .setup_root_hub = hc_setup_roothub,
+        .hc_gone = hc_gone,
 };
-
-
-static errno_t ehci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res,
-    bool irq)
-{
-        assert(hcd);
-        assert(hcd_get_driver_data(hcd) == NULL);
-
-        hc_t *instance = malloc(sizeof(hc_t));
-        if (!instance)
-                return ENOMEM;
-
-        const errno_t ret = hc_init(instance, res, irq);
-        if (ret == EOK) {
-                hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops);
-        } else {
-                free(instance);
-        }
-        return ret;
-}
-
-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);
-}
-
-/** Initializes a new ddf driver instance of EHCI hcd.
- *
- * @param[in] device DDF instance of the device to initialize.
- * @return Error code.
- */
-static errno_t 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 const driver_ops_t ehci_driver_ops = {
-        .dev_add = ehci_dev_add,
-};
-
-static const driver_t ehci_driver = {
-        .name = NAME,
-        .driver_ops = &ehci_driver_ops
-};
-
 
 /** Initializes global driver structures (NONE).
@@ -139 +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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -45 +46 @@
 #include <pci_dev_iface.h>
 
+#include "hc.h"
 #include "res.h"
 #include "ehci_regs.h"
@@ -73 +75 @@
             eecp + USBLEGSUP_OFFSET, &usblegsup);
         if (ret != EOK) {
-                usb_log_error("Failed to read USBLEGSUP: %s.\n", str_error(ret));
-                return ret;
-        }
-        usb_log_debug2("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
+                usb_log_error("Failed to read USBLEGSUP: %s.", str_error(ret));
+                return ret;
+        }
+        usb_log_debug2("USBLEGSUP: %" PRIx32 ".", usblegsup);
 
         /* Request control from firmware/BIOS by writing 1 to highest
          * byte. (OS Control semaphore)*/
-        usb_log_debug("Requesting OS control.\n");
+        usb_log_debug("Requesting OS control.");
         ret = pci_config_space_write_8(parent_sess,
             eecp + USBLEGSUP_OFFSET + 3, 1);
         if (ret != EOK) {
-                usb_log_error("Failed to request OS EHCI control: %s.\n",
+                usb_log_error("Failed to request OS EHCI control: %s.",
                     str_error(ret));
                 return ret;
@@ -102 +104 @@
 
         if ((usblegsup & USBLEGSUP_BIOS_CONTROL) == 0) {
-                usb_log_info("BIOS released control after %zu usec.\n", wait);
+                usb_log_info("BIOS released control after %zu usec.", wait);
                 return EOK;
         }
@@ -108 +110 @@
         /* BIOS failed to hand over control, this should not happen. */
         usb_log_warning( "BIOS failed to release control after "
-            "%zu usecs, force it.\n", wait);
+            "%zu usecs, force it.", wait);
         ret = pci_config_space_write_32(parent_sess,
             eecp + USBLEGSUP_OFFSET, USBLEGSUP_OS_CONTROL);
         if (ret != EOK) {
-                usb_log_error("Failed to force OS control: %s.\n",
+                usb_log_error("Failed to force OS control: %s.",
                     str_error(ret));
                 return ret;
@@ -129 +131 @@
                     eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
                 if (ret != EOK) {
-                        usb_log_error("Failed to get USBLEGCTLSTS: %s.\n",
+                        usb_log_error("Failed to get USBLEGCTLSTS: %s.",
                             str_error(ret));
                         return ret;
                 }
-                usb_log_debug2("USBLEGCTLSTS: %" PRIx32 ".\n", usblegctlsts);
+                usb_log_debug2("USBLEGCTLSTS: %" PRIx32 ".", usblegctlsts);
                 /*
                  * Zero SMI enables in legacy control register.
@@ -142 +144 @@
                     eecp + USBLEGCTLSTS_OFFSET, 0xe0000000);
                 if (ret != EOK) {
-                        usb_log_error("Failed to zero USBLEGCTLSTS: %s\n",
+                        usb_log_error("Failed to zero USBLEGCTLSTS: %s",
                             str_error(ret));
                         return ret;
@@ -152 +154 @@
                     eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
                 if (ret != EOK) {
-                        usb_log_error("Failed to get USBLEGCTLSTS 2: %s.\n",
+                        usb_log_error("Failed to get USBLEGCTLSTS 2: %s.",
                             str_error(ret));
                         return ret;
                 }
-                usb_log_debug2("Zeroed USBLEGCTLSTS: %" PRIx32 ".\n",
+                usb_log_debug2("Zeroed USBLEGCTLSTS: %" PRIx32 ".",
                     usblegctlsts);
         }
@@ -164 +166 @@
             eecp + USBLEGSUP_OFFSET, &usblegsup);
         if (ret != EOK) {
-                usb_log_error("Failed to read USBLEGSUP: %s.\n",
-                    str_error(ret));
-                return ret;
-        }
-        usb_log_debug2("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
+                usb_log_error("Failed to read USBLEGSUP: %s.",
+                    str_error(ret));
+                return ret;
+        }
+        usb_log_debug2("USBLEGSUP: %" PRIx32 ".", usblegsup);
         return ret;
 }
 
-errno_t disable_legacy(ddf_dev_t *device)
+errno_t 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;
 
-        usb_log_debug("Disabling EHCI legacy support.\n");
-
-        hw_res_list_parsed_t res;
-        hw_res_list_parsed_init(&res);
-        errno_t ret = hw_res_get_list_parsed(parent_sess, &res, 0);
-        if (ret != EOK) {
-                usb_log_error("Failed to get resource list: %s\n",
-                    str_error(ret));
-                goto clean;
-        }
-
-        if (res.mem_ranges.count < 1) {
-                usb_log_error("Incorrect mem range count: %zu",
-                    res.mem_ranges.count);
-                ret = EINVAL;
-                goto clean;
-        }
-
-        /* Map EHCI registers */
-        void *regs = NULL;
-        ret = pio_enable_range(&res.mem_ranges.ranges[0], &regs);
-        if (ret != EOK) {
-                usb_log_error("Failed to map registers %p: %s.\n",
-                    RNGABSPTR(res.mem_ranges.ranges[0]), str_error(ret));
-                goto clean;
-        }
-
-        usb_log_debug("Registers mapped at: %p.\n", regs);
-
-        ehci_caps_regs_t *ehci_caps = regs;
-
-        const uint32_t hcc_params = EHCI_RD(ehci_caps->hccparams);
-        usb_log_debug2("Value of hcc params register: %x.\n", hcc_params);
+        usb_log_debug("Disabling EHCI legacy support.");
+
+        const uint32_t hcc_params = EHCI_RD(hc->caps->hccparams);
+        usb_log_debug2("Value of hcc params register: %x.", hcc_params);
 
         /* Read value of EHCI Extended Capabilities Pointer
@@ -218 +191 @@
         const uint32_t eecp =
             (hcc_params >> EHCI_CAPS_HCC_EECP_SHIFT) & EHCI_CAPS_HCC_EECP_MASK;
-        usb_log_debug2("Value of EECP: %x.\n", eecp);
-
-        ret = disable_extended_caps(parent_sess, eecp);
-        if (ret != EOK) {
-                usb_log_error("Failed to disable extended capabilities: %s.\n",
+        usb_log_debug2("Value of EECP: %x.", eecp);
+
+        int ret = disable_extended_caps(parent_sess, eecp);
+        if (ret != EOK) {
+                usb_log_error("Failed to disable extended capabilities: %s.",
                     str_error(ret));
                     goto clean;
         }
 clean:
-        //TODO unmap registers
-        hw_res_list_parsed_clean(&res);
+        async_hangup(parent_sess);
         return ret;
 }

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;
 
-extern errno_t disable_legacy(ddf_dev_t *);
+extern errno_t disable_legacy(hc_device_t *);
 
 #endif