Changeset a39cfb8 in mainline for uspace/drv

Timestamp:

2011-04-14T07:54:33Z (15 years ago)

Author:

Matus Dekanek <smekideki@…>

Branches:

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

Children:

e05d6c3

Parents:

3f3afb9 (diff), 34e8bab (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.

Message:

merge from development

Location:

uspace/drv

Files:

• isa/isa.c (modified) (1 diff)
• ohci/Makefile (modified) (2 diffs)
• ohci/batch.c (modified) (16 diffs)
• ohci/batch.h (modified) (1 diff)
• ohci/endpoint_list.c (moved) (moved from uspace/drv/ohci/transfer_list.c ) (9 diffs)
• ohci/endpoint_list.h (moved) (moved from uspace/drv/ohci/transfer_list.h ) (4 diffs)
• ohci/hc.c (modified) (11 diffs)
• ohci/hc.h (modified) (3 diffs)
• ohci/hcd_endpoint.c (moved) (moved from kernel/generic/src/proc/tasklet.c ) (2 diffs)
• ohci/hcd_endpoint.h (moved) (moved from kernel/generic/include/proc/tasklet.h ) (2 diffs)
• ohci/hw_struct/endpoint_descriptor.h (modified) (1 diff)
• ohci/iface.c (modified) (12 diffs)
• ohci/root_hub.c (modified) (6 diffs)
• ohci/root_hub.h (modified) (2 diffs)
• uhci-hcd/batch.c (modified) (13 diffs)
• uhci-hcd/batch.h (modified) (1 diff)
• uhci-hcd/hc.c (modified) (8 diffs)
• uhci-hcd/hc.h (modified) (5 diffs)
• uhci-hcd/hw_struct/queue_head.h (modified) (4 diffs)
• uhci-hcd/hw_struct/transfer_descriptor.c (modified) (4 diffs)
• uhci-hcd/hw_struct/transfer_descriptor.h (modified) (1 diff)
• uhci-hcd/iface.c (modified) (8 diffs)
• uhci-hcd/main.c (modified) (5 diffs)
• uhci-hcd/pci.c (modified) (5 diffs)
• uhci-hcd/root_hub.c (modified) (2 diffs)
• uhci-hcd/root_hub.h (modified) (1 diff)
• uhci-hcd/transfer_list.c (modified) (11 diffs)
• uhci-hcd/transfer_list.h (modified) (1 diff)
• uhci-hcd/uhci.c (modified) (13 diffs)
• uhci-hcd/uhci.h (modified) (1 diff)

uspace/drv/isa/isa.c

@@ -83 +83 @@
 static bool isa_enable_fun_interrupt(ddf_fun_t *fnode)
 {
-        // TODO
+        /* TODO */
 
         return false;

uspace/drv/ohci/Makefile

@@ -34 +34 @@
 SOURCES = \
         batch.c \
+        endpoint_list.c \
         hc.c \
+        hcd_endpoint.c \
         iface.c \
         main.c \
@@ -40 +42 @@
         pci.c \
         root_hub.c \
-        transfer_list.c \
         hw_struct/endpoint_descriptor.c \
         hw_struct/transfer_descriptor.c

uspace/drv/ohci/batch.c

@@ -39 +39 @@
 
 #include "batch.h"
+#include "hcd_endpoint.h"
 #include "utils/malloc32.h"
 #include "hw_struct/endpoint_descriptor.h"
 #include "hw_struct/transfer_descriptor.h"
 
-typedef struct ohci_batch {
+typedef struct ohci_transfer_batch {
         ed_t *ed;
-        td_t *tds;
+        td_t **tds;
         size_t td_count;
-} ohci_batch_t;
-
+        size_t leave_td;
+        char *device_buffer;
+} ohci_transfer_batch_t;
+
+static void ohci_transfer_batch_dispose(void *ohci_batch)
+{
+        ohci_transfer_batch_t *instance = ohci_batch;
+        if (!instance)
+                return;
+        free32(instance->device_buffer);
+        unsigned i = 0;
+        if (instance->tds) {
+                for (; i< instance->td_count; ++i) {
+                        if (i != instance->leave_td)
+                                free32(instance->tds[i]);
+                }
+                free(instance->tds);
+        }
+        free(instance);
+}
+/*----------------------------------------------------------------------------*/
 static void batch_control(usb_transfer_batch_t *instance,
     usb_direction_t data_dir, usb_direction_t status_dir);
 static void batch_data(usb_transfer_batch_t *instance);
-static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
-static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
-
-#define DEFAULT_ERROR_COUNT 3
+/*----------------------------------------------------------------------------*/
 usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
     char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
@@ -65 +82 @@
                 usb_log_error(message); \
                 if (instance) { \
-                        batch_dispose(instance); \
+                        usb_transfer_batch_dispose(instance); \
                 } \
                 return NULL; \
@@ -73 +90 @@
         CHECK_NULL_DISPOSE_RETURN(instance,
             "Failed to allocate batch instance.\n");
-        usb_target_t target =
-            { .address = ep->address, .endpoint = ep->endpoint };
-        usb_transfer_batch_init(instance, target, ep->transfer_type, ep->speed,
-            ep->max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
-            func_in, func_out, arg, fun, ep, NULL);
-
-        ohci_batch_t *data = malloc(sizeof(ohci_batch_t));
+        usb_transfer_batch_init(instance, ep, buffer, NULL, buffer_size,
+            NULL, setup_size, func_in, func_out, arg, fun, NULL,
+            ohci_transfer_batch_dispose);
+
+        hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
+        assert(hcd_ep);
+
+        ohci_transfer_batch_t *data = calloc(sizeof(ohci_transfer_batch_t), 1);
         CHECK_NULL_DISPOSE_RETURN(data, "Failed to allocate batch data.\n");
-        bzero(data, sizeof(ohci_batch_t));
         instance->private_data = data;
 
-        /* we needs + 1 transfer descriptor as the last one won't be executed */
-        data->td_count = 1 +
+        data->td_count =
             ((buffer_size + OHCI_TD_MAX_TRANSFER - 1) / OHCI_TD_MAX_TRANSFER);
         if (ep->transfer_type == USB_TRANSFER_CONTROL) {
@@ -91 +107 @@
         }
 
-        data->tds = malloc32(sizeof(td_t) * data->td_count);
+        /* we need one extra place for td that is currently assigned to hcd_ep*/
+        data->tds = calloc(sizeof(td_t*), data->td_count + 1);
         CHECK_NULL_DISPOSE_RETURN(data->tds,
             "Failed to allocate transfer descriptors.\n");
-        bzero(data->tds, sizeof(td_t) * data->td_count);
-
-        data->ed = malloc32(sizeof(ed_t));
-        CHECK_NULL_DISPOSE_RETURN(data->ed,
-            "Failed to allocate endpoint descriptor.\n");
-
-        if (buffer_size > 0) {
-                instance->transport_buffer = malloc32(buffer_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
+
+        data->tds[0] = hcd_ep->td;
+        data->leave_td = 0;
+        unsigned i = 1;
+        for (; i <= data->td_count; ++i) {
+                data->tds[i] = malloc32(sizeof(td_t));
+                CHECK_NULL_DISPOSE_RETURN(data->tds[i],
+                    "Failed to allocate TD %d.\n", i );
+        }
+
+        data->ed = hcd_ep->ed;
+
+        if (setup_size + buffer_size > 0) {
+                data->device_buffer = malloc32(setup_size + buffer_size);
+                CHECK_NULL_DISPOSE_RETURN(data->device_buffer,
                     "Failed to allocate device accessible buffer.\n");
-        }
-
-        if (setup_size > 0) {
-                instance->setup_buffer = malloc32(setup_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
-                    "Failed to allocate device accessible setup buffer.\n");
+                instance->setup_buffer = data->device_buffer;
+                instance->data_buffer = data->device_buffer + setup_size;
                 memcpy(instance->setup_buffer, setup_buffer, setup_size);
         }
@@ -116 +135 @@
 }
 /*----------------------------------------------------------------------------*/
-void batch_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        free32(data->ed);
-        free32(data->tds);
-        free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
-        free(data);
-        free(instance);
-}
-/*----------------------------------------------------------------------------*/
 bool batch_is_complete(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        size_t tds = data->td_count - 1;
+        ohci_transfer_batch_t *data = instance->private_data;
+        assert(data);
+        size_t tds = data->td_count;
         usb_log_debug("Batch(%p) checking %d td(s) for completion.\n",
             instance, tds);
@@ -142 +148 @@
         size_t i = 0;
         for (; i < tds; ++i) {
+                assert(data->tds[i] != NULL);
                 usb_log_debug("TD %d: %x:%x:%x:%x.\n", i,
-                    data->tds[i].status, data->tds[i].cbp, data->tds[i].next,
-                    data->tds[i].be);
-                if (!td_is_finished(&data->tds[i])) {
+                    data->tds[i]->status, data->tds[i]->cbp, data->tds[i]->next,
+                    data->tds[i]->be);
+                if (!td_is_finished(data->tds[i])) {
                         return false;
                 }
-                instance->error = td_error(&data->tds[i]);
+                instance->error = td_error(data->tds[i]);
                 /* FIXME: calculate real transfered size */
                 instance->transfered_size = instance->buffer_size;
                 if (instance->error != EOK) {
                         usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
-                            instance, i, data->tds[i].status);
-                        return true;
-//                      endpoint_toggle_set(instance->ep,
+                            instance, i, data->tds[i]->status);
+                        break;
                 }
         }
+        data->leave_td = i;
+        assert(data->leave_td <= data->td_count);
+        hcd_endpoint_t *hcd_ep = hcd_endpoint_get(instance->ep);
+        assert(hcd_ep);
+        hcd_ep->td = data->tds[i];
+
         return true;
 }
 /*----------------------------------------------------------------------------*/
+void batch_commit(usb_transfer_batch_t *instance)
+{
+        assert(instance);
+        ohci_transfer_batch_t *data = instance->private_data;
+        assert(data);
+        ed_set_end_td(data->ed, data->tds[data->td_count]);
+}
+/*----------------------------------------------------------------------------*/
 void batch_control_write(usb_transfer_batch_t *instance)
 {
         assert(instance);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
-        instance->next_step = batch_call_out_and_dispose;
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         batch_control(instance, USB_DIRECTION_OUT, USB_DIRECTION_IN);
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
@@ -175 +194 @@
 {
         assert(instance);
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         batch_control(instance, USB_DIRECTION_IN, USB_DIRECTION_OUT);
         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
@@ -183 +202 @@
 {
         assert(instance);
-        assert(instance->direction == USB_DIRECTION_IN);
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         batch_data(instance);
         usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
@@ -192 +210 @@
 {
         assert(instance);
-        assert(instance->direction == USB_DIRECTION_OUT);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
-        instance->next_step = batch_call_out_and_dispose;
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         batch_data(instance);
         usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
@@ -204 +220 @@
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         batch_data(instance);
         usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
@@ -213 +228 @@
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         batch_data(instance);
         usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
@@ -222 +236 @@
 {
         assert(instance);
-        ohci_batch_t *data = instance->private_data;
+        ohci_transfer_batch_t *data = instance->private_data;
         assert(data);
         return data->ed;
@@ -231 +245 @@
 {
         assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        ed_init(data->ed, instance->ep);
-        ed_add_tds(data->ed, &data->tds[0], &data->tds[data->td_count - 1]);
-        usb_log_debug("Created ED(%p): %x:%x:%x:%x.\n", data->ed,
+        ohci_transfer_batch_t *data = instance->private_data;
+        assert(data);
+        usb_log_debug("Using ED(%p): %x:%x:%x:%x.\n", data->ed,
             data->ed->status, data->ed->td_tail, data->ed->td_head,
             data->ed->next);
         int toggle = 0;
         /* setup stage */
-        td_init(&data->tds[0], USB_DIRECTION_BOTH, instance->setup_buffer,
+        td_init(data->tds[0], USB_DIRECTION_BOTH, instance->setup_buffer,
                 instance->setup_size, toggle);
-        td_set_next(&data->tds[0], &data->tds[1]);
-        usb_log_debug("Created SETUP TD: %x:%x:%x:%x.\n", data->tds[0].status,
-            data->tds[0].cbp, data->tds[0].next, data->tds[0].be);
+        td_set_next(data->tds[0], data->tds[1]);
+        usb_log_debug("Created SETUP TD: %x:%x:%x:%x.\n", data->tds[0]->status,
+            data->tds[0]->cbp, data->tds[0]->next, data->tds[0]->be);
 
         /* data stage */
         size_t td_current = 1;
         size_t remain_size = instance->buffer_size;
-        char *transfer_buffer = instance->transport_buffer;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
                 size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
@@ -255 +267 @@
                 toggle = 1 - toggle;
 
-                td_init(&data->tds[td_current], data_dir, transfer_buffer,
+                td_init(data->tds[td_current], data_dir, buffer,
                     transfer_size, toggle);
-                td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
+                td_set_next(data->tds[td_current], data->tds[td_current + 1]);
                 usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
-                    data->tds[td_current].status, data->tds[td_current].cbp,
-                    data->tds[td_current].next, data->tds[td_current].be);
-
-                transfer_buffer += transfer_size;
+                    data->tds[td_current]->status, data->tds[td_current]->cbp,
+                    data->tds[td_current]->next, data->tds[td_current]->be);
+
+                buffer += transfer_size;
                 remain_size -= transfer_size;
-                assert(td_current < data->td_count - 2);
+                assert(td_current < data->td_count - 1);
                 ++td_current;
         }
 
         /* status stage */
-        assert(td_current == data->td_count - 2);
-        td_init(&data->tds[td_current], status_dir, NULL, 0, 1);
+        assert(td_current == data->td_count - 1);
+        td_init(data->tds[td_current], status_dir, NULL, 0, 1);
+        td_set_next(data->tds[td_current], data->tds[td_current + 1]);
         usb_log_debug("Created STATUS TD: %x:%x:%x:%x.\n",
-            data->tds[td_current].status, data->tds[td_current].cbp,
-            data->tds[td_current].next, data->tds[td_current].be);
+            data->tds[td_current]->status, data->tds[td_current]->cbp,
+            data->tds[td_current]->next, data->tds[td_current]->be);
 }
 /*----------------------------------------------------------------------------*/
@@ -279 +292 @@
 {
         assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        ed_init(data->ed, instance->ep);
-        ed_add_tds(data->ed, &data->tds[0], &data->tds[data->td_count - 1]);
-        usb_log_debug("Created ED(%p): %x:%x:%x:%x.\n", data->ed,
+        ohci_transfer_batch_t *data = instance->private_data;
+        assert(data);
+        usb_log_debug("Using ED(%p): %x:%x:%x:%x.\n", data->ed,
             data->ed->status, data->ed->td_tail, data->ed->td_head,
             data->ed->next);
 
-        /* data stage */
         size_t td_current = 0;
         size_t remain_size = instance->buffer_size;
-        char *transfer_buffer = instance->transport_buffer;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
                 size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
                     OHCI_TD_MAX_TRANSFER : remain_size;
 
-                td_init(&data->tds[td_current], instance->ep->direction,
-                    transfer_buffer, transfer_size, -1);
-                td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
+                td_init(data->tds[td_current], instance->ep->direction,
+                    buffer, transfer_size, -1);
+                td_set_next(data->tds[td_current], data->tds[td_current + 1]);
                 usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
-                    data->tds[td_current].status, data->tds[td_current].cbp,
-                    data->tds[td_current].next, data->tds[td_current].be);
-
-                transfer_buffer += transfer_size;
+                    data->tds[td_current]->status, data->tds[td_current]->cbp,
+                    data->tds[td_current]->next, data->tds[td_current]->be);
+
+                buffer += transfer_size;
                 remain_size -= transfer_size;
                 assert(td_current < data->td_count);
@@ -308 +318 @@
         }
 }
-/*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_call_in_and_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_in(instance);
-        batch_dispose(instance);
-}
-/*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_call_out_and_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_out(instance);
-        batch_dispose(instance);
-}
 /**
  * @}

uspace/drv/ohci/batch.h

@@ -50 +50 @@
     void *arg);
 
-void batch_dispose(usb_transfer_batch_t *instance);
+bool batch_is_complete(usb_transfer_batch_t *instance);
 
-bool batch_is_complete(usb_transfer_batch_t *instance);
+void batch_commit(usb_transfer_batch_t *instance);
 
 void batch_control_write(usb_transfer_batch_t *instance);

uspace/drv/ohci/endpoint_list.c

@@ -35 +35 @@
 #include <usb/debug.h>
 
-#include "transfer_list.h"
-
-static void transfer_list_remove_batch(
-    transfer_list_t *instance, usb_transfer_batch_t *batch);
-/*----------------------------------------------------------------------------*/
+#include "endpoint_list.h"
+
 /** Initialize transfer list structures.
  *
@@ -48 +45 @@
  * Allocates memory for internal qh_t structure.
  */
-int transfer_list_init(transfer_list_t *instance, const char *name)
+int endpoint_list_init(endpoint_list_t *instance, const char *name)
 {
         assert(instance);
@@ -62 +59 @@
 
         ed_init(instance->list_head, NULL);
-        list_initialize(&instance->batch_list);
+        list_initialize(&instance->endpoint_list);
         fibril_mutex_initialize(&instance->guard);
         return EOK;
@@ -75 +72 @@
  * Does not check whether this replaces an existing list .
  */
-void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next)
+void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next)
 {
         assert(instance);
@@ -82 +79 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Submit transfer batch to the list and queue.
- *
- * @param[in] instance List to use.
- * @param[in] batch Transfer batch to submit.
- * @return Error code
- *
- * The batch is added to the end of the list and queue.
- */
-void transfer_list_add_batch(
-    transfer_list_t *instance, usb_transfer_batch_t *batch)
-{
-        assert(instance);
-        assert(batch);
-        usb_log_debug2("Queue %s: Adding batch(%p).\n", instance->name, batch);
+/** Submit transfer endpoint to the list and queue.
+ *
+ * @param[in] instance List to use.
+ * @param[in] endpoint Transfer endpoint to submit.
+ * @return Error code
+ *
+ * The endpoint is added to the end of the list and queue.
+ */
+void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep)
+{
+        assert(instance);
+        assert(hcd_ep);
+        usb_log_debug2("Queue %s: Adding endpoint(%p).\n",
+            instance->name, hcd_ep);
 
         fibril_mutex_lock(&instance->guard);
@@ -101 +98 @@
         ed_t *last_ed = NULL;
         /* Add to the hardware queue. */
-        if (list_empty(&instance->batch_list)) {
+        if (list_empty(&instance->endpoint_list)) {
                 /* There is nothing scheduled */
                 last_ed = instance->list_head;
         } else {
                 /* There is something scheduled */
-                usb_transfer_batch_t *last = list_get_instance(
-                    instance->batch_list.prev, usb_transfer_batch_t, link);
-                last_ed = batch_ed(last);
+                hcd_endpoint_t *last = list_get_instance(
+                    instance->endpoint_list.prev, hcd_endpoint_t, link);
+                last_ed = last->ed;
         }
         /* keep link */
-        batch_ed(batch)->next = last_ed->next;
-        ed_append_ed(last_ed, batch_ed(batch));
+        hcd_ep->ed->next = last_ed->next;
+        ed_append_ed(last_ed, hcd_ep->ed);
 
         asm volatile ("": : :"memory");
 
         /* Add to the driver list */
-        list_append(&batch->link, &instance->batch_list);
-
-        usb_transfer_batch_t *first = list_get_instance(
-            instance->batch_list.next, usb_transfer_batch_t, link);
-        usb_log_debug("Batch(%p) added to list %s, first is %p(%p).\n",
-                batch, instance->name, first, batch_ed(first));
+        list_append(&hcd_ep->link, &instance->endpoint_list);
+
+        hcd_endpoint_t *first = list_get_instance(
+            instance->endpoint_list.next, hcd_endpoint_t, link);
+        usb_log_debug("HCD EP(%p) added to list %s, first is %p(%p).\n",
+                hcd_ep, instance->name, first, first->ed);
         if (last_ed == instance->list_head) {
                 usb_log_debug2("%s head ED(%p-%p): %x:%x:%x:%x.\n",
@@ -132 +129 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Create list for finished batches.
+#if 0
+/** Create list for finished endpoints.
  *
  * @param[in] instance List to use.
  * @param[in] done list to fill
  */
-void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
+void endpoint_list_remove_finished(endpoint_list_t *instance, link_t *done)
 {
         assert(instance);
@@ -143 +141 @@
 
         fibril_mutex_lock(&instance->guard);
-        usb_log_debug2("Checking list %s for completed batches(%d).\n",
-            instance->name, list_count(&instance->batch_list));
-        link_t *current = instance->batch_list.next;
-        while (current != &instance->batch_list) {
+        usb_log_debug2("Checking list %s for completed endpointes(%d).\n",
+            instance->name, list_count(&instance->endpoint_list));
+        link_t *current = instance->endpoint_list.next;
+        while (current != &instance->endpoint_list) {
                 link_t *next = current->next;
-                usb_transfer_batch_t *batch =
-                    list_get_instance(current, usb_transfer_batch_t, link);
-
-                if (batch_is_complete(batch)) {
+                hcd_endpoint_t *endpoint =
+                    list_get_instance(current, hcd_endpoint_t, link);
+
+                if (endpoint_is_complete(endpoint)) {
                         /* Save for post-processing */
-                        transfer_list_remove_batch(instance, batch);
+                        endpoint_list_remove_endpoint(instance, endpoint);
                         list_append(current, done);
                 }
@@ -161 +159 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Walk the list and abort all batches.
- *
- * @param[in] instance List to use.
- */
-void transfer_list_abort_all(transfer_list_t *instance)
-{
-        fibril_mutex_lock(&instance->guard);
-        while (!list_empty(&instance->batch_list)) {
-                link_t *current = instance->batch_list.next;
-                usb_transfer_batch_t *batch =
-                    list_get_instance(current, usb_transfer_batch_t, link);
-                transfer_list_remove_batch(instance, batch);
-                usb_transfer_batch_finish_error(batch, EIO);
-        }
-        fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
-/** Remove a transfer batch from the list and queue.
- *
- * @param[in] instance List to use.
- * @param[in] batch Transfer batch to remove.
+/** Walk the list and abort all endpointes.
+ *
+ * @param[in] instance List to use.
+ */
+void endpoint_list_abort_all(endpoint_list_t *instance)
+{
+        fibril_mutex_lock(&instance->guard);
+        while (!list_empty(&instance->endpoint_list)) {
+                link_t *current = instance->endpoint_list.next;
+                hcd_endpoint_t *endpoint =
+                    list_get_instance(current, hcd_endpoint_t, link);
+                endpoint_list_remove_endpoint(instance, endpoint);
+                hcd_endpoint_finish_error(endpoint, EIO);
+        }
+        fibril_mutex_unlock(&instance->guard);
+}
+#endif
+/*----------------------------------------------------------------------------*/
+/** Remove a transfer endpoint from the list and queue.
+ *
+ * @param[in] instance List to use.
+ * @param[in] endpoint Transfer endpoint to remove.
  * @return Error code
  *
  * Does not lock the transfer list, caller is responsible for that.
  */
-void transfer_list_remove_batch(
-    transfer_list_t *instance, usb_transfer_batch_t *batch)
+void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep)
 {
         assert(instance);
         assert(instance->list_head);
-        assert(batch);
-        assert(batch_ed(batch));
-        assert(fibril_mutex_is_locked(&instance->guard));
+        assert(hcd_ep);
+        assert(hcd_ep->ed);
+
+        fibril_mutex_lock(&instance->guard);
 
         usb_log_debug2(
-            "Queue %s: removing batch(%p).\n", instance->name, batch);
+            "Queue %s: removing endpoint(%p).\n", instance->name, hcd_ep);
 
         const char *qpos = NULL;
+        ed_t *prev_ed;
         /* Remove from the hardware queue */
-        if (instance->batch_list.next == &batch->link) {
+        if (instance->endpoint_list.next == &hcd_ep->link) {
                 /* I'm the first one here */
-                assert((instance->list_head->next & ED_NEXT_PTR_MASK)
-                    == addr_to_phys(batch_ed(batch)));
-                instance->list_head->next = batch_ed(batch)->next;
+                prev_ed = instance->list_head;
                 qpos = "FIRST";
         } else {
-                usb_transfer_batch_t *prev =
-                    list_get_instance(
-                        batch->link.prev, usb_transfer_batch_t, link);
-                assert((batch_ed(prev)->next & ED_NEXT_PTR_MASK)
-                    == addr_to_phys(batch_ed(batch)));
-                batch_ed(prev)->next = batch_ed(batch)->next;
+                hcd_endpoint_t *prev =
+                    list_get_instance(hcd_ep->link.prev, hcd_endpoint_t, link);
+                prev_ed = prev->ed;
                 qpos = "NOT FIRST";
         }
+        assert((prev_ed->next & ED_NEXT_PTR_MASK) == addr_to_phys(hcd_ep->ed));
+        prev_ed->next = hcd_ep->ed->next;
+
         asm volatile ("": : :"memory");
-        usb_log_debug("Batch(%p) removed (%s) from %s, next %x.\n",
-            batch, qpos, instance->name, batch_ed(batch)->next);
-
-        /* Remove from the batch list */
-        list_remove(&batch->link);
+        usb_log_debug("HCD EP(%p) removed (%s) from %s, next %x.\n",
+            hcd_ep, qpos, instance->name, hcd_ep->ed->next);
+
+        /* Remove from the endpoint list */
+        list_remove(&hcd_ep->link);
+        fibril_mutex_unlock(&instance->guard);
 }
 /**

uspace/drv/ohci/endpoint_list.h

@@ -32 +32 @@
  * @brief OHCI driver transfer list structure
  */
-#ifndef DRV_OHCI_TRANSFER_LIST_H
-#define DRV_OHCI_TRANSFER_LIST_H
+#ifndef DRV_OHCI_ENDPOINT_LIST_H
+#define DRV_OHCI_ENDPOINT_LIST_H
 
 #include <fibril_synch.h>
 
-#include "batch.h"
+#include "hcd_endpoint.h"
 #include "hw_struct/endpoint_descriptor.h"
 #include "utils/malloc32.h"
 
-typedef struct transfer_list
+typedef struct endpoint_list
 {
         fibril_mutex_t guard;
@@ -47 +47 @@
         uint32_t list_head_pa;
         const char *name;
-        link_t batch_list;
-} transfer_list_t;
+        link_t endpoint_list;
+} endpoint_list_t;
 
 /** Dispose transfer list structures.
@@ -56 +56 @@
  * Frees memory for internal qh_t structure.
  */
-static inline void transfer_list_fini(transfer_list_t *instance)
+static inline void endpoint_list_fini(endpoint_list_t *instance)
 {
         assert(instance);
@@ -62 +62 @@
 }
 
-int transfer_list_init(transfer_list_t *instance, const char *name);
+int endpoint_list_init(endpoint_list_t *instance, const char *name);
 
-void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
+void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next);
 
-void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
+void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
 
-void transfer_list_remove_finished(transfer_list_t *instance, link_t *done);
+void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
+#if 0
+void endpoint_list_remove_finished(endpoint_list_t *instance, link_t *done);
 
-void transfer_list_abort_all(transfer_list_t *instance);
+void endpoint_list_abort_all(endpoint_list_t *instance);
+#endif
 #endif
 /**

uspace/drv/ohci/hc.c

@@ -43 +43 @@
 
 #include "hc.h"
+#include "hcd_endpoint.h"
 
 static int interrupt_emulator(hc_t *instance);
@@ -55 +56 @@
         assert(hub_fun);
 
+        int ret;
+
         usb_address_t hub_address =
             device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
+        if (hub_address <= 0) {
+                usb_log_error("Failed to get OHCI root hub address.\n");
+                return hub_address;
+        }
         instance->rh.address = hub_address;
         usb_device_keeper_bind(
             &instance->manager, hub_address, hub_fun->handle);
 
-        endpoint_t *ep = malloc(sizeof(endpoint_t));
-        assert(ep);
-        int ret = endpoint_init(ep, hub_address, 0, USB_DIRECTION_BOTH,
-            USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64);
-        assert(ret == EOK);
-        ret = usb_endpoint_manager_register_ep(&instance->ep_manager, ep, 0);
-        assert(ret == EOK);
+        ret = hc_add_endpoint(instance, hub_address, 0, USB_SPEED_FULL,
+            USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH, 64, 0, 0);
+        if (ret != EOK) {
+                usb_log_error("Failed to add OHCI rh endpoint 0.\n");
+                usb_device_keeper_release(&instance->manager, hub_address);
+                return ret;
+        }
 
         char *match_str = NULL;
+        /* DDF needs heap allocated string */
         ret = asprintf(&match_str, "usb&class=hub");
-//      ret = (match_str == NULL) ? ret : EOK;
         if (ret < 0) {
                 usb_log_error(
                     "Failed(%d) to create root hub match-id string.\n", ret);
+                usb_device_keeper_release(&instance->manager, hub_address);
                 return ret;
         }
@@ -80 +88 @@
         ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
         if (ret != EOK) {
-                usb_log_error("Failed add create root hub match-id.\n");
+                usb_log_error("Failed add root hub match-id.\n");
         }
         return ret;
@@ -101 +109 @@
             ret, str_error(ret));
 
-        instance->ddf_instance = fun;
         usb_device_keeper_init(&instance->manager);
         ret = usb_endpoint_manager_init(&instance->ep_manager,
@@ -115 +122 @@
         fibril_mutex_initialize(&instance->guard);
 
-        rh_init(&instance->rh, dev, instance->registers);
+        rh_init(&instance->rh, instance->registers);
 
         if (!interrupts) {
@@ -123 +130 @@
         }
 
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch)
-{
-        assert(instance);
-        assert(batch);
-
-        /* check for root hub communication */
-        if (batch->target.address == instance->rh.address) {
-                return rh_request(&instance->rh, batch);
-        }
-
-        fibril_mutex_lock(&instance->guard);
-        switch (batch->transfer_type) {
+        list_initialize(&instance->pending_batches);
+#undef CHECK_RET_RETURN
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+int hc_add_endpoint(
+    hc_t *instance, usb_address_t address, usb_endpoint_t endpoint,
+    usb_speed_t speed, usb_transfer_type_t type, usb_direction_t direction,
+    size_t mps, size_t size, unsigned interval)
+{
+        endpoint_t *ep = malloc(sizeof(endpoint_t));
+        if (ep == NULL)
+                return ENOMEM;
+        int ret =
+            endpoint_init(ep, address, endpoint, direction, type, speed, mps);
+        if (ret != EOK) {
+                free(ep);
+                return ret;
+        }
+
+        hcd_endpoint_t *hcd_ep = hcd_endpoint_assign(ep);
+        if (hcd_ep == NULL) {
+                endpoint_destroy(ep);
+                return ENOMEM;
+        }
+
+        ret = usb_endpoint_manager_register_ep(&instance->ep_manager, ep, size);
+        if (ret != EOK) {
+                hcd_endpoint_clear(ep);
+                endpoint_destroy(ep);
+                return ret;
+        }
+
+        /* Enqueue hcd_ep */
+        switch (ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
                 instance->registers->control &= ~C_CLE;
-                transfer_list_add_batch(
-                    instance->transfers[batch->transfer_type], batch);
-                instance->registers->command_status |= CS_CLF;
-                usb_log_debug2("Set CS control transfer filled: %x.\n",
-                        instance->registers->command_status);
+                endpoint_list_add_ep(
+                    &instance->lists[ep->transfer_type], hcd_ep);
                 instance->registers->control_current = 0;
                 instance->registers->control |= C_CLE;
@@ -150 +174 @@
         case USB_TRANSFER_BULK:
                 instance->registers->control &= ~C_BLE;
-                transfer_list_add_batch(
-                    instance->transfers[batch->transfer_type], batch);
+                endpoint_list_add_ep(
+                    &instance->lists[ep->transfer_type], hcd_ep);
+                instance->registers->control |= C_BLE;
+                break;
+        case USB_TRANSFER_ISOCHRONOUS:
+        case USB_TRANSFER_INTERRUPT:
+                instance->registers->control &= (~C_PLE & ~C_IE);
+                endpoint_list_add_ep(
+                    &instance->lists[ep->transfer_type], hcd_ep);
+                instance->registers->control |= C_PLE | C_IE;
+                break;
+        default:
+                break;
+        }
+
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+int hc_remove_endpoint(hc_t *instance, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&instance->ep_manager,
+            address, endpoint, direction, NULL);
+        if (ep == NULL) {
+                usb_log_error("Endpoint unregister failed: No such EP.\n");
+                fibril_mutex_unlock(&instance->guard);
+                return ENOENT;
+        }
+
+        hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
+        if (hcd_ep) {
+                /* Dequeue hcd_ep */
+                switch (ep->transfer_type) {
+                case USB_TRANSFER_CONTROL:
+                        instance->registers->control &= ~C_CLE;
+                        endpoint_list_remove_ep(
+                            &instance->lists[ep->transfer_type], hcd_ep);
+                        instance->registers->control_current = 0;
+                        instance->registers->control |= C_CLE;
+                        break;
+                case USB_TRANSFER_BULK:
+                        instance->registers->control &= ~C_BLE;
+                        endpoint_list_remove_ep(
+                            &instance->lists[ep->transfer_type], hcd_ep);
+                        instance->registers->control |= C_BLE;
+                        break;
+                case USB_TRANSFER_ISOCHRONOUS:
+                case USB_TRANSFER_INTERRUPT:
+                        instance->registers->control &= (~C_PLE & ~C_IE);
+                        endpoint_list_remove_ep(
+                            &instance->lists[ep->transfer_type], hcd_ep);
+                        instance->registers->control |= C_PLE | C_IE;
+                        break;
+                default:
+                        break;
+                }
+                hcd_endpoint_clear(ep);
+        } else {
+                usb_log_warning("Endpoint without hcd equivalent structure.\n");
+        }
+        int ret = usb_endpoint_manager_unregister_ep(&instance->ep_manager,
+            address, endpoint, direction);
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
+/*----------------------------------------------------------------------------*/
+endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&instance->ep_manager,
+            address, endpoint, direction, bw);
+        fibril_mutex_unlock(&instance->guard);
+        return ep;
+}
+/*----------------------------------------------------------------------------*/
+int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch)
+{
+        assert(instance);
+        assert(batch);
+        assert(batch->ep);
+
+        /* check for root hub communication */
+        if (batch->ep->address == instance->rh.address) {
+                return rh_request(&instance->rh, batch);
+        }
+
+        fibril_mutex_lock(&instance->guard);
+        list_append(&batch->link, &instance->pending_batches);
+        batch_commit(batch);
+        switch (batch->ep->transfer_type) {
+        case USB_TRANSFER_CONTROL:
+                instance->registers->command_status |= CS_CLF;
+                break;
+        case USB_TRANSFER_BULK:
                 instance->registers->command_status |= CS_BLF;
-                usb_log_debug2("Set bulk transfer filled: %x.\n",
-                        instance->registers->command_status);
-                instance->registers->control |= C_BLE;
-                break;
-        case USB_TRANSFER_INTERRUPT:
-        case USB_TRANSFER_ISOCHRONOUS:
-                instance->registers->control &= (~C_PLE & ~C_IE);
-                transfer_list_add_batch(
-                    instance->transfers[batch->transfer_type], batch);
-                instance->registers->control |= C_PLE | C_IE;
-                usb_log_debug2("Added periodic transfer: %x.\n",
-                    instance->registers->periodic_current);
                 break;
         default:
                 break;
         }
+
         fibril_mutex_unlock(&instance->guard);
         return EOK;
@@ -189 +298 @@
                 usb_log_debug2("Periodic current: %p.\n",
                     instance->registers->periodic_current);
-                LIST_INITIALIZE(done);
-                transfer_list_remove_finished(
-                    &instance->transfers_interrupt, &done);
-                transfer_list_remove_finished(
-                    &instance->transfers_isochronous, &done);
-                transfer_list_remove_finished(
-                    &instance->transfers_control, &done);
-                transfer_list_remove_finished(
-                    &instance->transfers_bulk, &done);
-
-                while (!list_empty(&done)) {
-                        link_t *item = done.next;
-                        list_remove(item);
+
+                link_t *current = instance->pending_batches.next;
+                while (current != &instance->pending_batches) {
+                        link_t *next = current->next;
                         usb_transfer_batch_t *batch =
-                            list_get_instance(item, usb_transfer_batch_t, link);
-                        usb_transfer_batch_finish(batch);
+                            usb_transfer_batch_from_link(current);
+
+                        if (batch_is_complete(batch)) {
+                                list_remove(current);
+                                usb_transfer_batch_finish(batch);
+                        }
+                        current = next;
                 }
                 fibril_mutex_unlock(&instance->guard);
@@ -298 +403 @@
 
         /* Use queues */
-        instance->registers->bulk_head = instance->transfers_bulk.list_head_pa;
+        instance->registers->bulk_head =
+            instance->lists[USB_TRANSFER_BULK].list_head_pa;
         usb_log_debug2("Bulk HEAD set to: %p(%p).\n",
-            instance->transfers_bulk.list_head,
-            instance->transfers_bulk.list_head_pa);
+            instance->lists[USB_TRANSFER_BULK].list_head,
+            instance->lists[USB_TRANSFER_BULK].list_head_pa);
 
         instance->registers->control_head =
-            instance->transfers_control.list_head_pa;
+            instance->lists[USB_TRANSFER_CONTROL].list_head_pa;
         usb_log_debug2("Control HEAD set to: %p(%p).\n",
-            instance->transfers_control.list_head,
-            instance->transfers_control.list_head_pa);
+            instance->lists[USB_TRANSFER_CONTROL].list_head,
+            instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
 
         /* Enable queues */
@@ -338 +444 @@
         assert(instance);
 
-#define SETUP_TRANSFER_LIST(type, name) \
+#define SETUP_ENDPOINT_LIST(type) \
 do { \
-        int ret = transfer_list_init(&instance->type, name); \
+        const char *name = usb_str_transfer_type(type); \
+        int ret = endpoint_list_init(&instance->lists[type], name); \
         if (ret != EOK) { \
-                usb_log_error("Failed(%d) to setup %s transfer list.\n", \
+                usb_log_error("Failed(%d) to setup %s endpoint list.\n", \
                     ret, name); \
-                transfer_list_fini(&instance->transfers_isochronous); \
-                transfer_list_fini(&instance->transfers_interrupt); \
-                transfer_list_fini(&instance->transfers_control); \
-                transfer_list_fini(&instance->transfers_bulk); \
+                endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]); \
+                endpoint_list_fini(&instance->lists[USB_TRANSFER_INTERRUPT]); \
+                endpoint_list_fini(&instance->lists[USB_TRANSFER_CONTROL]); \
+                endpoint_list_fini(&instance->lists[USB_TRANSFER_BULK]); \
         } \
 } while (0)
 
-        SETUP_TRANSFER_LIST(transfers_isochronous, "ISOCHRONOUS");
-        SETUP_TRANSFER_LIST(transfers_interrupt, "INTERRUPT");
-        SETUP_TRANSFER_LIST(transfers_control, "CONTROL");
-        SETUP_TRANSFER_LIST(transfers_bulk, "BULK");
-#undef SETUP_TRANSFER_LIST
-        transfer_list_set_next(&instance->transfers_interrupt,
-            &instance->transfers_isochronous);
-
-        /* Assign pointers to be used during scheduling */
-        instance->transfers[USB_TRANSFER_INTERRUPT] =
-          &instance->transfers_interrupt;
-        instance->transfers[USB_TRANSFER_ISOCHRONOUS] =
-          &instance->transfers_interrupt;
-        instance->transfers[USB_TRANSFER_CONTROL] =
-          &instance->transfers_control;
-        instance->transfers[USB_TRANSFER_BULK] =
-          &instance->transfers_bulk;
+        SETUP_ENDPOINT_LIST(USB_TRANSFER_ISOCHRONOUS);
+        SETUP_ENDPOINT_LIST(USB_TRANSFER_INTERRUPT);
+        SETUP_ENDPOINT_LIST(USB_TRANSFER_CONTROL);
+        SETUP_ENDPOINT_LIST(USB_TRANSFER_BULK);
+#undef SETUP_ENDPOINT_LIST
+        endpoint_list_set_next(&instance->lists[USB_TRANSFER_INTERRUPT],
+            &instance->lists[USB_TRANSFER_ISOCHRONOUS]);
 
         return EOK;
@@ -388 +485 @@
         for (; i < 32; ++i) {
                 instance->hcca->int_ep[i] =
-                    instance->transfers_interrupt.list_head_pa;
+                    instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa;
         }
         usb_log_debug2("Interrupt HEADs set to: %p(%p).\n",
-            instance->transfers_interrupt.list_head,
-            instance->transfers_interrupt.list_head_pa);
+            instance->lists[USB_TRANSFER_INTERRUPT].list_head,
+            instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
 
         return EOK;

uspace/drv/ohci/hc.h

@@ -48 +48 @@
 #include "ohci_regs.h"
 #include "root_hub.h"
-#include "transfer_list.h"
+#include "endpoint_list.h"
 #include "hw_struct/hcca.h"
 
 typedef struct hc {
         ohci_regs_t *registers;
+        hcca_t *hcca;
+
         usb_address_t rh_address;
         rh_t rh;
 
-        hcca_t *hcca;
+        endpoint_list_t lists[4];
+        link_t pending_batches;
 
-        transfer_list_t transfers_isochronous;
-        transfer_list_t transfers_interrupt;
-        transfer_list_t transfers_control;
-        transfer_list_t transfers_bulk;
-
-        transfer_list_t *transfers[4];
-
-        ddf_fun_t *ddf_instance;
         usb_device_keeper_t manager;
         usb_endpoint_manager_t ep_manager;
@@ -77 +72 @@
      uintptr_t regs, size_t reg_size, bool interrupts);
 
-int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);
-
-void hc_interrupt(hc_t *instance, uint32_t status);
-
 /** Safely dispose host controller internal structures
  *
@@ -86 +77 @@
  */
 static inline void hc_fini(hc_t *instance) { /* TODO: implement*/ };
+
+int hc_add_endpoint(hc_t *instance, usb_address_t address, usb_endpoint_t ep,
+    usb_speed_t speed, usb_transfer_type_t type, usb_direction_t direction,
+    size_t max_packet_size, size_t size, unsigned interval);
+
+int hc_remove_endpoint(hc_t *instance, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction);
+
+endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw);
+
+int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);
+
+void hc_interrupt(hc_t *instance, uint32_t status);
 
 /** Get and cast pointer to the driver data

uspace/drv/ohci/hcd_endpoint.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2007 Jan Hudecek
- * Copyright (c) 2008 Martin Decky
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
  *
@@ -27 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
-/** @addtogroup genericproc
+/** @addtogroup drvusbohci
  * @{
  */
-/** @file tasklet.c
- *  @brief Tasklet implementation
+/** @file
+ * @brief OHCI driver
  */
+#include "utils/malloc32.h"
+#include "hcd_endpoint.h"
 
-#include <proc/tasklet.h>
-#include <synch/spinlock.h>
-#include <mm/slab.h>
-#include <config.h>
+hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep)
+{
+        assert(ep);
+        hcd_endpoint_t *hcd_ep = malloc(sizeof(hcd_endpoint_t));
+        if (hcd_ep == NULL)
+                return NULL;
 
-/** Spinlock protecting list of tasklets */
-SPINLOCK_INITIALIZE(tasklet_lock);
+        hcd_ep->ed = malloc32(sizeof(ed_t));
+        if (hcd_ep->ed == NULL) {
+                free(hcd_ep);
+                return NULL;
+        }
 
-/** Array of tasklet lists for every CPU */
-tasklet_descriptor_t **tasklet_list;
+        hcd_ep->td = malloc32(sizeof(td_t));
+        if (hcd_ep->td == NULL) {
+                free32(hcd_ep->ed);
+                free(hcd_ep);
+                return NULL;
+        }
 
-void tasklet_init(void)
+        ed_init(hcd_ep->ed, ep);
+        ed_set_td(hcd_ep->ed, hcd_ep->td);
+        endpoint_set_hc_data(ep, hcd_ep, NULL, NULL);
+
+        return hcd_ep;
+}
+/*----------------------------------------------------------------------------*/
+hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
 {
-        unsigned int i;
-        
-        tasklet_list = malloc(sizeof(tasklet_descriptor_t *) * config.cpu_count, 0);
-        if (!tasklet_list)
-                panic("Error initializing tasklets.");
-        
-        for (i = 0; i < config.cpu_count; i++)
-                tasklet_list[i] = NULL;
-        
-        spinlock_initialize(&tasklet_lock, "tasklet_lock");
+        assert(ep);
+        return ep->hc_data.data;
 }
-
-
-/** @}
+/*----------------------------------------------------------------------------*/
+void hcd_endpoint_clear(endpoint_t *ep)
+{
+        assert(ep);
+        hcd_endpoint_t *hcd_ep = ep->hc_data.data;
+        assert(hcd_ep);
+        free32(hcd_ep->ed);
+        free32(hcd_ep->td);
+        free(hcd_ep);
+}
+/**
+ * @}
  */

uspace/drv/ohci/hcd_endpoint.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2007 Jan Hudecek
- * Copyright (c) 2008 Martin Decky
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
  *
@@ -27 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
-/** @addtogroup genericproc
+/** @addtogroup drvusbohci
  * @{
  */
-/** @file tasklet.h
- * @brief Tasklets declarations
+/** @file
+ * @brief OHCI driver
  */
+#ifndef DRV_OHCI_HCD_ENDPOINT_H
+#define DRV_OHCI_HCD_ENDPOINT_H
 
-#ifndef KERN_TASKLET_H_
-#define KERN_TASKLET_H_
-
+#include <assert.h>
 #include <adt/list.h>
 
-/** Tasklet callback type */
-typedef void (* tasklet_callback_t)(void *arg);
+#include <usb/host/endpoint.h>
 
-/** Tasklet state */
-typedef enum {
-        NotActive,
-        Scheduled,
-        InProgress,
-        Disabled
-} tasklet_state_t;
+#include "hw_struct/endpoint_descriptor.h"
+#include "hw_struct/transfer_descriptor.h"
 
-/** Structure describing a tasklet */
-typedef struct tasklet_descriptor {
+typedef struct hcd_endpoint {
+        ed_t *ed;
+        td_t *td;
         link_t link;
-        
-        /** Callback to call */
-        tasklet_callback_t callback;
-        
-        /** Argument passed to the callback */
-        void *arg;
-        
-        /** State of the tasklet */
-        tasklet_state_t state;
-} tasklet_descriptor_t;
+} hcd_endpoint_t;
 
+hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep);
 
-extern void tasklet_init(void);
+hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep);
 
+void hcd_endpoint_clear(endpoint_t *ep);
 #endif
-
-/** @}
+/**
+ * @}
  */

uspace/drv/ohci/hw_struct/endpoint_descriptor.h

@@ -81 +81 @@
 void ed_init(ed_t *instance, endpoint_t *ep);
 
-static inline void ed_add_tds(ed_t *instance, td_t *head, td_t *tail)
+static inline void ed_set_td(ed_t *instance, td_t *td)
 {
         assert(instance);
+        uintptr_t pa = addr_to_phys(td);
         instance->td_head =
-            ((addr_to_phys(head) & ED_TDHEAD_PTR_MASK)
+            ((pa & ED_TDHEAD_PTR_MASK)
             | (instance->td_head & ~ED_TDHEAD_PTR_MASK));
-        instance->td_tail = addr_to_phys(tail) & ED_TDTAIL_PTR_MASK;
+        instance->td_tail = pa & ED_TDTAIL_PTR_MASK;
+}
+
+static inline void ed_set_end_td(ed_t *instance, td_t *td)
+{
+        assert(instance);
+        uintptr_t pa = addr_to_phys(td);
+        instance->td_tail = pa & ED_TDTAIL_PTR_MASK;
 }
 

uspace/drv/ohci/iface.c

@@ -55 +55 @@
 
         size_t res_bw;
-        endpoint_t *ep = usb_endpoint_manager_get_ep(&(*hc)->ep_manager,
+        endpoint_t *ep = hc_get_endpoint(*hc,
             target.address, target.endpoint, direction, &res_bw);
         if (ep == NULL) {
@@ -164 +164 @@
         }
         const size_t size = max_packet_size;
-        int ret;
 
         usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
@@ -170 +169 @@
             usb_str_speed(speed), direction, size, max_packet_size, interval);
 
-        endpoint_t *ep = malloc(sizeof(endpoint_t));
-        if (ep == NULL)
-                return ENOMEM;
-        ret = endpoint_init(ep, address, endpoint, direction,
-            transfer_type, speed, max_packet_size);
-        if (ret != EOK) {
-                free(ep);
-                return ret;
-        }
-
-        ret = usb_endpoint_manager_register_ep(&hc->ep_manager, ep, size);
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-        }
-        return ret;
+        return hc_add_endpoint(hc, address, endpoint, speed, transfer_type,
+            direction, max_packet_size, size, interval);
 }
 /*----------------------------------------------------------------------------*/
@@ -195 +181 @@
         usb_log_debug("Unregister endpoint %d:%d %d.\n",
             address, endpoint, direction);
-        return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
-            endpoint, direction);
+        return hc_remove_endpoint(hc, address, endpoint, direction);
 }
 /*----------------------------------------------------------------------------*/
@@ -228 +213 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -262 +247 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -296 +281 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -330 +315 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -346 +331 @@
  * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
  *      and deallocated by the caller).
- * @param[in] setup_packet_size Size of @p setup_packet buffer in bytes.
+ * @param[in] setup_size Size of @p setup_packet buffer in bytes.
  * @param[in] data_buffer Data buffer (in USB endianess, allocated and
  *      deallocated by the caller).
- * @param[in] data_buffer_size Size of @p data_buffer buffer in bytes.
+ * @param[in] size Size of @p data_buffer buffer in bytes.
  * @param[in] callback Callback to be issued once the transfer is complete.
  * @param[in] arg Pass-through argument to the callback.
@@ -370 +355 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -386 +371 @@
  * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
  *      and deallocated by the caller).
- * @param[in] setup_packet_size Size of @p setup_packet buffer in bytes.
+ * @param[in] setup_size Size of @p setup_packet buffer in bytes.
  * @param[in] data_buffer Buffer where to store the data (in USB endianess,
  *      allocated and deallocated by the caller).
- * @param[in] data_buffer_size Size of @p data_buffer buffer in bytes.
+ * @param[in] size Size of @p data_buffer buffer in bytes.
  * @param[in] callback Callback to be issued once the transfer is complete.
  * @param[in] arg Pass-through argument to the callback.
@@ -409 +394 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;

uspace/drv/ohci/root_hub.c

@@ -205 +205 @@
  * @return Error code.
  */
-int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) {
+int rh_init(rh_t *instance, ohci_regs_t *regs) {
         assert(instance);
-        //instance->address = -1;
         instance->registers = regs;
-        instance->device = dev;
         instance->port_count =
             (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
         rh_init_descriptors(instance);
         // set port power mode to no-power-switching
-        instance->registers->rh_desc_a =
-                instance->registers->rh_desc_a | (1<<9);
+        instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
 
         usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
-
-        //start generic usb hub driver
-
-        /* TODO: implement */
         return EOK;
 }
@@ -237 +230 @@
         assert(request);
         int opResult;
-        if (request->transfer_type == USB_TRANSFER_CONTROL) {
+        if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
                 usb_log_info("Root hub got CONTROL packet\n");
                 opResult = process_ctrl_request(instance, request);
-        } else if (request->transfer_type == USB_TRANSFER_INTERRUPT) {
+        } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
                 usb_log_info("Root hub got INTERRUPT packet\n");
                 void * buffer;
                 create_interrupt_mask(instance, &buffer,
                         &(request->transfered_size));
-                memcpy(request->transport_buffer, buffer,
+                memcpy(request->data_buffer, buffer,
                         request->transfered_size);
                 opResult = EOK;
@@ -374 +367 @@
         if (port < 1 || port > instance->port_count)
                 return EINVAL;
-        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
         uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
@@ -400 +393 @@
 static int process_get_hub_status_request(rh_t *instance,
         usb_transfer_batch_t * request) {
-        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
         //bits, 0,1,16,17
@@ -550 +543 @@
         }
         request->transfered_size = size;
-        memcpy(request->transport_buffer, result_descriptor, size);
+        memcpy(request->data_buffer, result_descriptor, size);
         if (del)
                 free(result_descriptor);
@@ -571 +564 @@
         if (request->buffer_size != 1)
                 return EINVAL;
-        request->transport_buffer[0] = 1;
+        request->data_buffer[0] = 1;
         request->transfered_size = 1;
         return EOK;

uspace/drv/ohci/root_hub.h

@@ -50 +50 @@
         /** usb address of the root hub */
         usb_address_t address;
-        /** ddf device information */
-        ddf_dev_t *device;
         /** hub port count */
         int port_count;
@@ -58 +56 @@
 } rh_t;
 
-int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs);
+int rh_init(rh_t *instance, ohci_regs_t *regs);
 
 int rh_request(rh_t *instance, usb_transfer_batch_t *request);

uspace/drv/uhci-hcd/batch.c

@@ -30 +30 @@
  */
 /** @file
- * @brief UHCI driver USB transaction structure
+ * @brief UHCI driver USB transfer structure
  */
 #include <errno.h>
@@ -45 +45 @@
 #define DEFAULT_ERROR_COUNT 3
 
-typedef struct uhci_batch {
+typedef struct uhci_transfer_batch {
         qh_t *qh;
         td_t *tds;
-        size_t transfers;
-} uhci_batch_t;
+        void *device_buffer;
+        size_t td_count;
+} uhci_transfer_batch_t;
+/*----------------------------------------------------------------------------*/
+static void uhci_transfer_batch_dispose(void *uhci_batch)
+{
+        uhci_transfer_batch_t *instance = uhci_batch;
+        assert(instance);
+        free32(instance->device_buffer);
+        free(instance);
+}
+/*----------------------------------------------------------------------------*/
 
 static void batch_control(usb_transfer_batch_t *instance,
     usb_packet_id data_stage, usb_packet_id status_stage);
 static void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid);
-static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
-static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
-
 
 /** Allocate memory and initialize internal data structure.
  *
  * @param[in] fun DDF function to pass to callback.
- * @param[in] target Device and endpoint target of the transaction.
- * @param[in] transfer_type Interrupt, Control or Bulk.
- * @param[in] max_packet_size maximum allowed size of data transfers.
- * @param[in] speed Speed of the transaction.
+ * @param[in] ep Communication target
  * @param[in] buffer Data source/destination.
  * @param[in] size Size of the buffer.
  * @param[in] setup_buffer Setup data source (if not NULL)
  * @param[in] setup_size Size of setup_buffer (should be always 8)
- * @param[in] func_in function to call on inbound transaction completion
- * @param[in] func_out function to call on outbound transaction completion
+ * @param[in] func_in function to call on inbound transfer completion
+ * @param[in] func_out function to call on outbound transfer completion
  * @param[in] arg additional parameter to func_in or func_out
- * @param[in] ep Pointer to endpoint toggle management structure.
- * @return Valid pointer if all substructures were successfully created,
+ * @return Valid pointer if all structures were successfully created,
  * NULL otherwise.
  *
- * Determines the number of needed transfers (TDs). Prepares a transport buffer
- * (that is accessible by the hardware). Initializes parameters needed for the
- * transaction and callback.
+ * 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.
  */
 usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
@@ -92 +95 @@
         if (ptr == NULL) { \
                 usb_log_error(message); \
-                if (instance) { \
-                        batch_dispose(instance); \
+                if (uhci_data) { \
+                        uhci_transfer_batch_dispose(uhci_data); \
                 } \
                 return NULL; \
         } else (void)0
 
+        uhci_transfer_batch_t *uhci_data =
+            malloc(sizeof(uhci_transfer_batch_t));
+        CHECK_NULL_DISPOSE_RETURN(uhci_data,
+            "Failed to allocate UHCI batch.\n");
+        bzero(uhci_data, sizeof(uhci_transfer_batch_t));
+
+        uhci_data->td_count =
+            (buffer_size + ep->max_packet_size - 1) / ep->max_packet_size;
+        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
+                uhci_data->td_count += 2;
+        }
+
+        assert((sizeof(td_t) % 16) == 0);
+        const size_t total_size = (sizeof(td_t) * uhci_data->td_count)
+            + sizeof(qh_t) + setup_size + buffer_size;
+        uhci_data->device_buffer = malloc32(total_size);
+        CHECK_NULL_DISPOSE_RETURN(uhci_data->device_buffer,
+            "Failed to allocate UHCI buffer.\n");
+        bzero(uhci_data->device_buffer, total_size);
+
+        uhci_data->tds = uhci_data->device_buffer;
+        uhci_data->qh =
+            (uhci_data->device_buffer + (sizeof(td_t) * uhci_data->td_count));
+
+        qh_init(uhci_data->qh);
+        qh_set_element_td(uhci_data->qh, uhci_data->tds);
+
         usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
         CHECK_NULL_DISPOSE_RETURN(instance,
             "Failed to allocate batch instance.\n");
+        void *setup =
+            uhci_data->device_buffer + (sizeof(td_t) * uhci_data->td_count)
+            + sizeof(qh_t);
+        void *data_buffer = setup + setup_size;
         usb_target_t target =
             { .address = ep->address, .endpoint = ep->endpoint };
-        usb_transfer_batch_init(instance, target, ep->transfer_type, ep->speed,
-            ep->max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
-            func_in, func_out, arg, fun, ep, NULL);
-
-
-        uhci_batch_t *data = malloc(sizeof(uhci_batch_t));
-        CHECK_NULL_DISPOSE_RETURN(data, "Failed to allocate batch data.\n");
-        bzero(data, sizeof(uhci_batch_t));
-        instance->private_data = data;
-
-        data->transfers =
-            (buffer_size + ep->max_packet_size - 1) / ep->max_packet_size;
-        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
-                data->transfers += 2;
-        }
-
-        data->tds = malloc32(sizeof(td_t) * data->transfers);
-        CHECK_NULL_DISPOSE_RETURN(
-            data->tds, "Failed to allocate transfer descriptors.\n");
-        bzero(data->tds, sizeof(td_t) * data->transfers);
-
-        data->qh = malloc32(sizeof(qh_t));
-        CHECK_NULL_DISPOSE_RETURN(data->qh,
-            "Failed to allocate batch queue head.\n");
-        qh_init(data->qh);
-        qh_set_element_td(data->qh, addr_to_phys(data->tds));
-
-        if (buffer_size > 0) {
-                instance->transport_buffer = malloc32(buffer_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
-                    "Failed to allocate device accessible buffer.\n");
-        }
-
-        if (setup_size > 0) {
-                instance->setup_buffer = malloc32(setup_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
-                    "Failed to allocate device accessible setup buffer.\n");
-                memcpy(instance->setup_buffer, setup_buffer, setup_size);
-        }
-
+        usb_transfer_batch_init(instance, ep, buffer, data_buffer, buffer_size,
+            setup, setup_size, func_in, func_out, arg, fun,
+            uhci_data, uhci_transfer_batch_dispose);
+
+        memcpy(instance->setup_buffer, setup_buffer, setup_size);
         usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
             instance, target.address, target.endpoint);
@@ -154 +153 @@
  *
  * Walk all TDs. Stop with false if there is an active one (it is to be
- * processed). Stop with true if an error is found. Return true if the last TS
+ * processed). Stop with true if an error is found. Return true if the last TD
  * is reached.
  */
@@ -160 +159 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
 
         usb_log_debug2("Batch(%p) checking %d transfer(s) for completion.\n",
-            instance, data->transfers);
+            instance, data->td_count);
         instance->transfered_size = 0;
         size_t i = 0;
-        for (;i < data->transfers; ++i) {
+        for (;i < data->td_count; ++i) {
                 if (td_is_active(&data->tds[i])) {
                         return false;
@@ -177 +176 @@
                             instance, i, data->tds[i].status);
                         td_print_status(&data->tds[i]);
+
                         assert(instance->ep != NULL);
-
                         endpoint_toggle_set(instance->ep,
                             td_toggle(&data->tds[i]));
@@ -195 +194 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control write transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Uses genercir control function with pids OUT and IN.
+/** Prepares control write transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Uses generic control function with pids OUT and IN.
  */
 void batch_control_write(usb_transfer_batch_t *instance)
@@ -205 +204 @@
         assert(instance);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_control(instance, USB_PID_OUT, USB_PID_IN);
-        instance->next_step = batch_call_out_and_dispose;
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control read transaction.
+/** Prepares control read transfer.
  *
  * @param[in] instance Batch structure to use.
@@ -222 +220 @@
         assert(instance);
         batch_control(instance, USB_PID_IN, USB_PID_OUT);
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt in transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_IN.
+/** Prepare interrupt in transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_IN.
  */
 void batch_interrupt_in(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
         batch_data(instance, USB_PID_IN);
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt out transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_OUT.
+/** Prepare interrupt out transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_OUT.
  */
 void batch_interrupt_out(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_OUT;
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
-        instance->next_step = batch_call_out_and_dispose;
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk in transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_IN.
+/** Prepare bulk in transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_IN.
  */
 void batch_bulk_in(usb_transfer_batch_t *instance)
@@ -269 +264 @@
         assert(instance);
         batch_data(instance, USB_PID_IN);
-        instance->direction = USB_DIRECTION_IN;
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk out transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_OUT.
+/** Prepare bulk out transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_OUT.
  */
 void batch_bulk_out(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_OUT;
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
-        instance->next_step = batch_call_out_and_dispose;
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) BULK OUT initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare generic data transaction
- *
- * @param[in] instance Batch structure to use.
- * @param[in] pid Pid to use for data transfers.
- *
- * Packets with alternating toggle bit and supplied pid value.
+/** Prepare generic data transfer
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] pid Pid to use for data transactions.
+ *
+ * Transactions with alternating toggle bit and supplied pid value.
  * The last transfer is marked with IOC flag.
  */
@@ -303 +295 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
 
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
         int toggle = endpoint_toggle_get(instance->ep);
         assert(toggle == 0 || toggle == 1);
 
-        size_t transfer = 0;
+        size_t td = 0;
         size_t remain_size = instance->buffer_size;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
-                char *trans_data =
-                    instance->transport_buffer + instance->buffer_size
-                    - remain_size;
-
                 const size_t packet_size =
-                    (instance->max_packet_size > remain_size) ?
-                    remain_size : instance->max_packet_size;
-
-                td_t *next_transfer = (transfer + 1 < data->transfers)
-                    ? &data->tds[transfer + 1] : NULL;
-
-                assert(transfer < data->transfers);
+                    (instance->ep->max_packet_size > remain_size) ?
+                    remain_size : instance->ep->max_packet_size;
+
+                td_t *next_td = (td + 1 < data->td_count)
+                    ? &data->tds[td + 1] : NULL;
+
+
+                usb_target_t target =
+                    { instance->ep->address, instance->ep->endpoint };
+
+                assert(td < data->td_count);
+                td_init(
+                    &data->tds[td], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, target, pid, buffer, next_td);
+
+                ++td;
+                toggle = 1 - toggle;
+                buffer += packet_size;
                 assert(packet_size <= remain_size);
-
-                td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, instance->target, pid, trans_data,
-                    next_transfer);
-
-
-                toggle = 1 - toggle;
                 remain_size -= packet_size;
-                ++transfer;
         }
-        td_set_ioc(&data->tds[transfer - 1]);
+        td_set_ioc(&data->tds[td - 1]);
         endpoint_toggle_set(instance->ep, toggle);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare generic control transaction
- *
- * @param[in] instance Batch structure to use.
- * @param[in] data_stage Pid to use for data transfers.
- * @param[in] status_stage Pid to use for data transfers.
+/** Prepare generic control transfer
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] data_stage Pid to use for data tds.
+ * @param[in] status_stage Pid to use for data tds.
  *
  * Setup stage with toggle 0 and USB_PID_SETUP.
@@ -356 +347 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
-        assert(data->transfers >= 2);
-
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = 0;
+        assert(data->td_count >= 2);
+
+        const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
+        const usb_target_t target =
+            { instance->ep->address, instance->ep->endpoint };
+
         /* setup stage */
         td_init(
-            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, toggle, false,
-            low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
+            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, 0, false,
+            low_speed, target, USB_PID_SETUP, instance->setup_buffer,
             &data->tds[1]);
 
         /* data stage */
-        size_t transfer = 1;
+        size_t td = 1;
+        unsigned toggle = 1;
         size_t remain_size = instance->buffer_size;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
-                char *control_data =
-                    instance->transport_buffer + instance->buffer_size
-                    - remain_size;
-
+                const size_t packet_size =
+                    (instance->ep->max_packet_size > remain_size) ?
+                    remain_size : instance->ep->max_packet_size;
+
+                td_init(
+                    &data->tds[td], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, target, data_stage,
+                    buffer, &data->tds[td + 1]);
+
+                ++td;
                 toggle = 1 - toggle;
-
-                const size_t packet_size =
-                    (instance->max_packet_size > remain_size) ?
-                    remain_size : instance->max_packet_size;
-
-                td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, instance->target, data_stage,
-                    control_data, &data->tds[transfer + 1]);
-
-                ++transfer;
-                assert(transfer < data->transfers);
+                buffer += packet_size;
+                assert(td < data->td_count);
                 assert(packet_size <= remain_size);
                 remain_size -= packet_size;
@@ -394 +385 @@
 
         /* status stage */
-        assert(transfer == data->transfers - 1);
+        assert(td == data->td_count - 1);
 
         td_init(
-            &data->tds[transfer], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
-            instance->target, status_stage, NULL, NULL);
-        td_set_ioc(&data->tds[transfer]);
+            &data->tds[td], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
+            target, status_stage, NULL, NULL);
+        td_set_ioc(&data->tds[td]);
 
         usb_log_debug2("Control last TD status: %x.\n",
-            data->tds[transfer].status);
-}
-/*----------------------------------------------------------------------------*/
+            data->tds[td].status);
+}
+/*----------------------------------------------------------------------------*/
+/** Provides access to QH data structure.
+ * @param[in] instance Batch pointer to use.
+ * @return Pointer to the QH used by the batch.
+ */
 qh_t * batch_qh(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
         return data->qh;
 }
-/*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_call_in_and_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_in(instance);
-        batch_dispose(instance);
-}
-/*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_call_out_and_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_out(instance);
-        batch_dispose(instance);
-}
-/*----------------------------------------------------------------------------*/
-/** Correctly dispose all used data structures.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        uhci_batch_t *data = instance->private_data;
-        assert(data);
-        usb_log_debug("Batch(%p) disposing.\n", instance);
-        /* free32 is NULL safe */
-        free32(data->tds);
-        free32(data->qh);
-        free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
-        free(data);
-        free(instance);
-}
 /**
  * @}

uspace/drv/uhci-hcd/batch.h

@@ -30 +30 @@
  */
 /** @file
- * @brief UHCI driver USB transaction structure
+ * @brief UHCI driver USB tranfer helper functions
  */
 #ifndef DRV_UHCI_BATCH_H

uspace/drv/uhci-hcd/hc.c

@@ -66 +66 @@
 static int hc_interrupt_emulator(void *arg);
 static int hc_debug_checker(void *arg);
-#if 0
-static bool usb_is_allowed(
-    bool low_speed, usb_transfer_type_t transfer, size_t size);
-#endif
 /*----------------------------------------------------------------------------*/
 /** Initialize UHCI hcd driver structure
@@ -89 +85 @@
         int ret;
 
-#define CHECK_RET_DEST_FUN_RETURN(ret, message...) \
+#define CHECK_RET_RETURN(ret, message...) \
         if (ret != EOK) { \
                 usb_log_error(message); \
-                if (instance->ddf_instance) \
-                        ddf_fun_destroy(instance->ddf_instance); \
                 return ret; \
         } else (void) 0
@@ -99 +93 @@
         instance->hw_interrupts = interrupts;
         instance->hw_failures = 0;
-
-        /* Setup UHCI function. */
-        instance->ddf_instance = fun;
 
         /* allow access to hc control registers */
         regs_t *io;
         ret = pio_enable(regs, reg_size, (void**)&io);
-        CHECK_RET_DEST_FUN_RETURN(ret,
+        CHECK_RET_RETURN(ret,
             "Failed(%d) to gain access to registers at %p: %s.\n",
-            ret, str_error(ret), io);
+            ret, io, str_error(ret));
         instance->registers = io;
         usb_log_debug("Device registers at %p(%u) accessible.\n",
@@ -114 +105 @@
 
         ret = hc_init_mem_structures(instance);
-        CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed to initialize UHCI memory structures.\n");
+        CHECK_RET_RETURN(ret,
+            "Failed(%d) to initialize UHCI memory structures: %s.\n",
+            ret, str_error(ret));
 
         hc_init_hw(instance);
         if (!interrupts) {
-                instance->cleaner =
+                instance->interrupt_emulator =
                     fibril_create(hc_interrupt_emulator, instance);
-                fibril_add_ready(instance->cleaner);
-        } else {
-                /* TODO: enable interrupts here */
-        }
-
-        instance->debug_checker =
-            fibril_create(hc_debug_checker, instance);
-//      fibril_add_ready(instance->debug_checker);
+                fibril_add_ready(instance->interrupt_emulator);
+        }
+        (void)hc_debug_checker;
 
         return EOK;
@@ -228 +215 @@
         /* Set all frames to point to the first queue head */
         const uint32_t queue =
-          instance->transfers_interrupt.queue_head_pa
-          | LINK_POINTER_QUEUE_HEAD_FLAG;
+            LINK_POINTER_QH(addr_to_phys(
+                instance->transfers_interrupt.queue_head));
 
         unsigned i = 0;
@@ -236 +223 @@
         }
 
-        /* Init device keeper*/
+        /* Init device keeper */
         usb_device_keeper_init(&instance->manager);
         usb_log_debug("Initialized device manager.\n");
@@ -329 +316 @@
 
         transfer_list_t *list =
-            instance->transfers[batch->speed][batch->transfer_type];
+            instance->transfers[batch->ep->speed][batch->ep->transfer_type];
         assert(list);
         transfer_list_add_batch(list, batch);
@@ -479 +466 @@
 #undef QH
 }
-/*----------------------------------------------------------------------------*/
-/** Check transfers for USB validity
- *
- * @param[in] low_speed Transfer speed.
- * @param[in] transfer Transer type
- * @param[in] size Size of data packets
- * @return True if transaction is allowed by USB specs, false otherwise
- */
-#if 0
-bool usb_is_allowed(
-    bool low_speed, usb_transfer_type_t transfer, size_t size)
-{
-        /* see USB specification chapter 5.5-5.8 for magic numbers used here */
-        switch(transfer)
-        {
-        case USB_TRANSFER_ISOCHRONOUS:
-                return (!low_speed && size < 1024);
-        case USB_TRANSFER_INTERRUPT:
-                return size <= (low_speed ? 8 : 64);
-        case USB_TRANSFER_CONTROL: /* device specifies its own max size */
-                return (size <= (low_speed ? 8 : 64));
-        case USB_TRANSFER_BULK: /* device specifies its own max size */
-                return (!low_speed && size <= 64);
-        }
-        return false;
-}
-#endif
 /**
  * @}

uspace/drv/uhci-hcd/hc.h

@@ -48 +48 @@
 #include "transfer_list.h"
 
+/** UHCI I/O registers layout */
 typedef struct uhci_regs {
+        /** Command register, controls HC behaviour */
         uint16_t usbcmd;
 #define UHCI_CMD_MAX_PACKET (1 << 7)
@@ -59 +61 @@
 #define UHCI_CMD_RUN_STOP  (1 << 0)
 
+        /** Status register, 1 means interrupt is asserted (if enabled) */
         uint16_t usbsts;
 #define UHCI_STATUS_HALTED (1 << 5)
@@ -67 +70 @@
 #define UHCI_STATUS_INTERRUPT (1 << 0)
 
+        /** Interrupt enabled registers */
         uint16_t usbintr;
 #define UHCI_INTR_SHORT_PACKET (1 << 3)
@@ -73 +77 @@
 #define UHCI_INTR_CRC (1 << 0)
 
+        /** Register stores frame number used in SOF packet */
         uint16_t frnum;
+
+        /** Pointer(physical) to the Frame List */
         uint32_t flbaseadd;
+
+        /** SOF modification to match external timers */
         uint8_t sofmod;
 } regs_t;
@@ -83 +92 @@
 #define UHCI_ALLOWED_HW_FAIL 5
 
+/* Main HC driver structure */
 typedef struct hc {
+        /** USB bus driver, devices and addresses */
         usb_device_keeper_t manager;
+        /** USB bus driver, endpoints */
         usb_endpoint_manager_t ep_manager;
 
+        /** Addresses of I/O registers */
         regs_t *registers;
 
+        /** Frame List contains 1024 link pointers */
         link_pointer_t *frame_list;
 
+        /** List and queue of interrupt transfers */
+        transfer_list_t transfers_interrupt;
+        /** List and queue of low speed control transfers */
+        transfer_list_t transfers_control_slow;
+        /** List and queue of full speed bulk transfers */
         transfer_list_t transfers_bulk_full;
+        /** List and queue of full speed control transfers */
         transfer_list_t transfers_control_full;
-        transfer_list_t transfers_control_slow;
-        transfer_list_t transfers_interrupt;
 
+        /** Pointer table to the above lists, helps during scheduling */
         transfer_list_t *transfers[2][4];
 
+        /** Code to be executed in kernel interrupt handler */
         irq_code_t interrupt_code;
 
-        fid_t cleaner;
-        fid_t debug_checker;
+        /** Fibril periodically checking status register*/
+        fid_t interrupt_emulator;
+
+        /** Indicator of hw interrupts availability */
         bool hw_interrupts;
+
+        /** Number of hw failures detected. */
         unsigned hw_failures;
-
-        ddf_fun_t *ddf_instance;
 } hc_t;
 

uspace/drv/uhci-hcd/hw_struct/queue_head.h

@@ -34 +34 @@
 #ifndef DRV_UHCI_QH_H
 #define DRV_UHCI_QH_H
-
-/* libc */
 #include <assert.h>
 
 #include "link_pointer.h"
+#include "transfer_descriptor.h"
+#include "utils/malloc32.h"
 
+/** This structure is defined in UHCI design guide p. 31 */
 typedef struct queue_head {
+        /** Pointer to the next entity (another QH or TD */
         volatile link_pointer_t next;
+        /** Pointer to the contained entities (execution controlled by vertical flag*/
         volatile link_pointer_t element;
 } __attribute__((packed)) qh_t;
@@ -64 +67 @@
  * @param[in] pa Physical address of the next queue head.
  *
- * Adds proper flag. If the pointer is NULL or terminal, sets next to terminal
- * NULL.
+ * Adds proper flag. If the pointer is NULL, sets next to terminal NULL.
  */
-static inline void qh_set_next_qh(qh_t *instance, uint32_t pa)
+static inline void qh_set_next_qh(qh_t *instance, qh_t *next)
 {
-        /* Address is valid and not terminal */
-        if (pa && ((pa & LINK_POINTER_TERMINATE_FLAG) == 0)) {
+        uint32_t pa = addr_to_phys(next);
+        if (pa) {
                 instance->next = LINK_POINTER_QH(pa);
         } else {
@@ -80 +82 @@
  *
  * @param[in] instance qh_t structure to initialize.
- * @param[in] pa Physical address of the next queue head.
- *
- * Adds proper flag. If the pointer is NULL or terminal, sets element
- * to terminal NULL.
- */
-static inline void qh_set_element_qh(qh_t *instance, uint32_t pa)
-{
-        /* Address is valid and not terminal */
-        if (pa && ((pa & LINK_POINTER_TERMINATE_FLAG) == 0)) {
-                instance->element = LINK_POINTER_QH(pa);
-        } else {
-                instance->element = LINK_POINTER_TERM;
-        }
-}
-/*----------------------------------------------------------------------------*/
-/** Set queue head element pointer
- *
- * @param[in] instance qh_t structure to initialize.
  * @param[in] pa Physical address of the TD structure.
  *
- * Adds proper flag. If the pointer is NULL or terminal, sets element
- * to terminal NULL.
+ * Adds proper flag. If the pointer is NULL, sets element to terminal NULL.
  */
-static inline void qh_set_element_td(qh_t *instance, uint32_t pa)
+static inline void qh_set_element_td(qh_t *instance, td_t *td)
 {
-        if (pa && ((pa & LINK_POINTER_TERMINATE_FLAG) == 0)) {
+        uint32_t pa = addr_to_phys(td);
+        if (pa) {
                 instance->element = LINK_POINTER_TD(pa);
         } else {
@@ -111 +95 @@
         }
 }
-
 #endif
 /**

uspace/drv/uhci-hcd/hw_struct/transfer_descriptor.c

@@ -77 +77 @@
 
         instance->status = 0
-            | ((err_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
+            | ((err_count & TD_STATUS_ERROR_COUNT_MASK)
+                << TD_STATUS_ERROR_COUNT_POS)
             | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
             | (iso ? TD_STATUS_ISOCHRONOUS_FLAG : 0)
@@ -89 +90 @@
             | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
             | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
-            | ((target.address & TD_DEVICE_ADDRESS_MASK) << TD_DEVICE_ADDRESS_POS)
-            | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) << TD_DEVICE_ENDPOINT_POS)
+            | ((target.address & TD_DEVICE_ADDRESS_MASK)
+                << TD_DEVICE_ADDRESS_POS)
+            | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK)
+                << TD_DEVICE_ENDPOINT_POS)
             | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
 
@@ -114 +117 @@
         assert(instance);
 
-        /* this is hc internal error it should never be reported */
+        /* This is hc internal error it should never be reported. */
         if ((instance->status & TD_STATUS_ERROR_BIT_STUFF) != 0)
                 return EAGAIN;
@@ -123 +126 @@
                 return EBADCHECKSUM;
 
-        /* hc does not end transaction on these, it should never be reported */
+        /* HC does not end transactions on these, it should never be reported */
         if ((instance->status & TD_STATUS_ERROR_NAK) != 0)
                 return EAGAIN;
 
-        /* buffer overrun or underrun */
+        /* Buffer overrun or underrun */
         if ((instance->status & TD_STATUS_ERROR_BUFFER) != 0)
                 return ERANGE;
 
-        /* device babble is something serious */
+        /* Device babble is something serious */
         if ((instance->status & TD_STATUS_ERROR_BABBLE) != 0)
                 return EIO;
 
-        /* stall might represent err count reaching zero or stall response from
-         * the device, is err count reached zero, one of the above is reported*/
+        /* Stall might represent err count reaching zero or stall response from
+         * the device. If err count reached zero, one of the above is reported*/
         if ((instance->status & TD_STATUS_ERROR_STALLED) != 0)
                 return ESTALL;

uspace/drv/uhci-hcd/hw_struct/transfer_descriptor.h

@@ -40 +40 @@
 #include "link_pointer.h"
 
-/** UHCI Transfer Descriptor */
+/** Transfer Descriptor, defined in UHCI design guide p. 26 */
 typedef struct transfer_descriptor {
+        /** Pointer to the next entity (TD or QH) */
         link_pointer_t next;
 
+        /** Status doubleword */
         volatile uint32_t status;
 #define TD_STATUS_RESERVED_MASK 0xc000f800
-#define TD_STATUS_SPD_FLAG ( 1 << 29 )
-#define TD_STATUS_ERROR_COUNT_POS ( 27 )
-#define TD_STATUS_ERROR_COUNT_MASK ( 0x3 )
-#define TD_STATUS_LOW_SPEED_FLAG ( 1 << 26 )
-#define TD_STATUS_ISOCHRONOUS_FLAG ( 1 << 25 )
-#define TD_STATUS_IOC_FLAG ( 1 << 24 )
+#define TD_STATUS_SPD_FLAG         (1 << 29)
+#define TD_STATUS_ERROR_COUNT_POS 27
+#define TD_STATUS_ERROR_COUNT_MASK 0x3
+#define TD_STATUS_LOW_SPEED_FLAG   (1 << 26)
+#define TD_STATUS_ISOCHRONOUS_FLAG (1 << 25)
+#define TD_STATUS_IOC_FLAG         (1 << 24)
 
-#define TD_STATUS_ERROR_ACTIVE ( 1 << 23 )
-#define TD_STATUS_ERROR_STALLED ( 1 << 22 )
-#define TD_STATUS_ERROR_BUFFER ( 1 << 21 )
-#define TD_STATUS_ERROR_BABBLE ( 1 << 20 )
-#define TD_STATUS_ERROR_NAK ( 1 << 19 )
-#define TD_STATUS_ERROR_CRC ( 1 << 18 )
-#define TD_STATUS_ERROR_BIT_STUFF ( 1 << 17 )
-#define TD_STATUS_ERROR_RESERVED ( 1 << 16 )
+#define TD_STATUS_ERROR_ACTIVE    (1 << 23)
+#define TD_STATUS_ERROR_STALLED   (1 << 22)
+#define TD_STATUS_ERROR_BUFFER    (1 << 21)
+#define TD_STATUS_ERROR_BABBLE    (1 << 20)
+#define TD_STATUS_ERROR_NAK       (1 << 19)
+#define TD_STATUS_ERROR_CRC       (1 << 18)
+#define TD_STATUS_ERROR_BIT_STUFF (1 << 17)
+#define TD_STATUS_ERROR_RESERVED  (1 << 16)
 #define TD_STATUS_ERROR_POS 16
-#define TD_STATUS_ERROR_MASK ( 0xff )
+#define TD_STATUS_ERROR_MASK 0xff
 
 #define TD_STATUS_ACTLEN_POS 0
 #define TD_STATUS_ACTLEN_MASK 0x7ff
 
+        /* double word with USB device specific info */
         volatile uint32_t device;
 #define TD_DEVICE_MAXLEN_POS 21
-#define TD_DEVICE_MAXLEN_MASK ( 0x7ff )
-#define TD_DEVICE_RESERVED_FLAG ( 1 << 20 )
-#define TD_DEVICE_DATA_TOGGLE_ONE_FLAG ( 1 << 19 )
+#define TD_DEVICE_MAXLEN_MASK 0x7ff
+#define TD_DEVICE_RESERVED_FLAG        (1 << 20)
+#define TD_DEVICE_DATA_TOGGLE_ONE_FLAG (1 << 19)
 #define TD_DEVICE_ENDPOINT_POS 15
-#define TD_DEVICE_ENDPOINT_MASK ( 0xf )
+#define TD_DEVICE_ENDPOINT_MASK 0xf
 #define TD_DEVICE_ADDRESS_POS 8
-#define TD_DEVICE_ADDRESS_MASK ( 0x7f )
+#define TD_DEVICE_ADDRESS_MASK 0x7f
 #define TD_DEVICE_PID_POS 0
-#define TD_DEVICE_PID_MASK ( 0xff )
+#define TD_DEVICE_PID_MASK 0xff
 
+        /** Pointer(physical) to the beginning of the transaction's buffer */
         volatile uint32_t buffer_ptr;
 
-        /* there is 16 bytes of data available here, according to UHCI
-         * Design guide, according to linux kernel the hardware does not care,
-         * it just needs to be aligned, we don't use it anyway
+        /* According to UHCI design guide, there is 16 bytes of
+         * data available here.
+         * According to linux kernel the hardware does not care,
+         * it just needs to be aligned. We don't use it anyway.
          */
 } __attribute__((packed)) td_t;

uspace/drv/uhci-hcd/iface.c

@@ -148 +148 @@
         assert(hc);
         const size_t size = max_packet_size;
-        int ret;
         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, address);
         if (speed >= USB_SPEED_MAX) {
@@ -157 +156 @@
             usb_str_speed(speed), direction, size, max_packet_size, interval);
 
-
-        endpoint_t *ep = malloc(sizeof(endpoint_t));
-        if (ep == NULL)
-                return ENOMEM;
-        ret = endpoint_init(ep, address, endpoint, direction,
-            transfer_type, speed, max_packet_size);
-        if (ret != EOK) {
-                free(ep);
-                return ret;
-        }
-
-        ret = usb_endpoint_manager_register_ep(&hc->ep_manager, ep, size);
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-        }
-        return ret;
+        return usb_endpoint_manager_add_ep(&hc->ep_manager, address, endpoint,
+            direction, transfer_type, speed, max_packet_size, size);
 }
 /*----------------------------------------------------------------------------*/
@@ -210 +195 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -238 +223 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -266 +251 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -294 +279 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -327 +312 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;
@@ -359 +344 @@
         ret = hc_schedule(hc, batch);
         if (ret != EOK) {
-                batch_dispose(batch);
+                usb_transfer_batch_dispose(batch);
         }
         return ret;

uspace/drv/uhci-hcd/main.c

@@ -39 +39 @@
 #include <usb/debug.h>
 
-#include "iface.h"
 #include "uhci.h"
 
@@ -62 +61 @@
 int uhci_add_device(ddf_dev_t *device)
 {
-        usb_log_debug("uhci_add_device() called\n");
+        usb_log_debug2("uhci_add_device() called\n");
         assert(device);
+
         uhci_t *uhci = malloc(sizeof(uhci_t));
         if (uhci == NULL) {
@@ -72 +72 @@
         int ret = uhci_init(uhci, device);
         if (ret != EOK) {
-                usb_log_error("Failed to initialize UHCI driver: %s.\n",
-                    str_error(ret));
+                usb_log_error("Failed(%d) to initialize UHCI driver: %s.\n",
+                    ret, str_error(ret));
                 return ret;
         }
@@ -85 +85 @@
 /** Initialize global driver structures (NONE).
  *
- * @param[in] argc Nmber of arguments in argv vector (ignored).
+ * @param[in] argc Number of arguments in argv vector (ignored).
  * @param[in] argv Cmdline argument vector (ignored).
  * @return Error code.
@@ -94 +94 @@
 {
         printf(NAME ": HelenOS UHCI driver.\n");
-
-        sleep(3); /* TODO: remove in final version */
         usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
 

uspace/drv/uhci-hcd/pci.c

@@ -44 +44 @@
 #include "pci.h"
 
-/** Get address of registers and IRQ for given device.
+/** Get I/O address of registers and IRQ for given device.
  *
  * @param[in] dev Device asking for the addresses.
@@ -53 +53 @@
  */
 int pci_get_my_registers(ddf_dev_t *dev,
-    uintptr_t *io_reg_address, size_t *io_reg_size,
-    int *irq_no)
+    uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
 {
         assert(dev != NULL);
 
-        int parent_phone = devman_parent_device_connect(dev->handle,
-            IPC_FLAG_BLOCKING);
+        int parent_phone =
+            devman_parent_device_connect(dev->handle, IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
                 return parent_phone;
         }
 
-        int rc;
         hw_resource_list_t hw_resources;
-        rc = hw_res_get_resource_list(parent_phone, &hw_resources);
+        int rc = hw_res_get_resource_list(parent_phone, &hw_resources);
         if (rc != EOK) {
                 goto leave;
@@ -95 +93 @@
                             res->res.io_range.address, res->res.io_range.size);
                         io_found = true;
+                        break;
 
                 default:
@@ -113 +112 @@
 leave:
         async_hangup(parent_phone);
-
         return rc;
 }
@@ -145 +143 @@
         }
 
-        /* See UHCI design guide for these values,
+        /* See UHCI design guide for these values p.45,
          * write all WC bits in USB legacy register */
         sysarg_t address = 0xc0;

uspace/drv/uhci-hcd/root_hub.c

@@ -55 +55 @@
         int ret = asprintf(&match_str, "usb&uhci&root-hub");
         if (ret < 0) {
-                usb_log_error("Failed to create root hub match string.\n");
-                return ENOMEM;
+                usb_log_error(
+                    "Failed(%d) to create root hub match string: %s.\n",
+                    ret, str_error(ret));
+                return ret;
         }
 
         ret = ddf_fun_add_match_id(fun, match_str, 100);
         if (ret != EOK) {
+                free(match_str);
                 usb_log_error("Failed(%d) to add root hub match id: %s\n",
                     ret, str_error(ret));
@@ -66 +69 @@
         }
 
-        hw_resource_list_t *resource_list = &instance->resource_list;
-        resource_list->count = 1;
-        resource_list->resources = &instance->io_regs;
-        assert(resource_list->resources);
+        /* Initialize resource structure */
+        instance->resource_list.count = 1;
+        instance->resource_list.resources = &instance->io_regs;
+
         instance->io_regs.type = IO_RANGE;
         instance->io_regs.res.io_range.address = reg_addr;

uspace/drv/uhci-hcd/root_hub.h

@@ -39 +39 @@
 #include <ops/hw_res.h>
 
+/** DDF support structure for uhci-rhd driver, provides I/O resources */
 typedef struct rh {
+        /** List of resources available to the root hub. */
         hw_resource_list_t resource_list;
+        /** The only resource in the above list */
         hw_resource_t io_regs;
 } rh_t;

uspace/drv/uhci-hcd/transfer_list.c

@@ -57 +57 @@
                 return ENOMEM;
         }
-        instance->queue_head_pa = addr_to_phys(instance->queue_head);
+        uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
         usb_log_debug2("Transfer list %s setup with QH: %p(%p).\n",
-            name, instance->queue_head, instance->queue_head_pa);
+            name, instance->queue_head, queue_head_pa);
 
         qh_init(instance->queue_head);
@@ -67 +67 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Dispose transfer list structures.
+ *
+ * @param[in] instance Memory place to use.
+ *
+ * Frees memory for internal qh_t structure.
+ */
+void transfer_list_fini(transfer_list_t *instance)
+{
+        assert(instance);
+        free32(instance->queue_head);
+}
 /** Set the next list in transfer list chain.
  *
@@ -81 +92 @@
         if (!instance->queue_head)
                 return;
-        /* Set both queue_head.next to point to the follower */
-        qh_set_next_qh(instance->queue_head, next->queue_head_pa);
-}
-/*----------------------------------------------------------------------------*/
-/** Submit transfer batch to the list and queue.
+        /* Set queue_head.next to point to the follower */
+        qh_set_next_qh(instance->queue_head, next->queue_head);
+}
+/*----------------------------------------------------------------------------*/
+/** Add transfer batch to the list and queue.
  *
  * @param[in] instance List to use.
  * @param[in] batch Transfer batch to submit.
- * @return Error code
  *
  * The batch is added to the end of the list and queue.
@@ -109 +119 @@
         } else {
                 /* There is something scheduled */
-                usb_transfer_batch_t *last = list_get_instance(
-                    instance->batch_list.prev, usb_transfer_batch_t, link);
+                usb_transfer_batch_t *last =
+                    usb_transfer_batch_from_link(instance->batch_list.prev);
                 last_qh = batch_qh(last);
         }
@@ -118 +128 @@
         /* keep link */
         batch_qh(batch)->next = last_qh->next;
-        qh_set_next_qh(last_qh, pa);
+        qh_set_next_qh(last_qh, batch_qh(batch));
 
         asm volatile ("": : :"memory");
@@ -132 +142 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Create list for finished batches.
+/** Add completed bantches to the provided list.
  *
  * @param[in] instance List to use.
@@ -147 +157 @@
                 link_t *next = current->next;
                 usb_transfer_batch_t *batch =
-                    list_get_instance(current, usb_transfer_batch_t, link);
+                    usb_transfer_batch_from_link(current);
 
                 if (batch_is_complete(batch)) {
-                        /* Save for post-processing */
+                        /* Save for processing */
                         transfer_list_remove_batch(instance, batch);
                         list_append(current, done);
@@ -159 +169 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Walk the list and abort all batches.
+/** Walk the list and finish all batches with EINTR.
  *
  * @param[in] instance List to use.
@@ -169 +179 @@
                 link_t *current = instance->batch_list.next;
                 usb_transfer_batch_t *batch =
-                    list_get_instance(current, usb_transfer_batch_t, link);
+                    usb_transfer_batch_from_link(current);
                 transfer_list_remove_batch(instance, batch);
-                usb_transfer_batch_finish_error(batch, EIO);
+                usb_transfer_batch_finish_error(batch, EINTR);
         }
         fibril_mutex_unlock(&instance->guard);
@@ -180 +190 @@
  * @param[in] instance List to use.
  * @param[in] batch Transfer batch to remove.
- * @return Error code
  *
  * Does not lock the transfer list, caller is responsible for that.
@@ -197 +206 @@
 
         const char *qpos = NULL;
+        qh_t *prev_qh = NULL;
         /* Remove from the hardware queue */
         if (instance->batch_list.next == &batch->link) {
                 /* I'm the first one here */
-                assert((instance->queue_head->next & LINK_POINTER_ADDRESS_MASK)
-                    == addr_to_phys(batch_qh(batch)));
-                instance->queue_head->next = batch_qh(batch)->next;
+                prev_qh = instance->queue_head;
                 qpos = "FIRST";
         } else {
+                /* The thing before me is a batch too */
                 usb_transfer_batch_t *prev =
-                    list_get_instance(
-                        batch->link.prev, usb_transfer_batch_t, link);
-                assert((batch_qh(prev)->next & LINK_POINTER_ADDRESS_MASK)
-                    == addr_to_phys(batch_qh(batch)));
-                batch_qh(prev)->next = batch_qh(batch)->next;
+                    usb_transfer_batch_from_link(batch->link.prev);
+                prev_qh = batch_qh(prev);
                 qpos = "NOT FIRST";
         }
+        assert((prev_qh->next & LINK_POINTER_ADDRESS_MASK)
+            == addr_to_phys(batch_qh(batch)));
+        prev_qh->next = batch_qh(batch)->next;
         asm volatile ("": : :"memory");
         /* Remove from the batch list */
         list_remove(&batch->link);
-        usb_log_debug("Batch(%p) removed (%s) from %s, next %x.\n",
+        usb_log_debug("Batch(%p) removed (%s) from %s, next: %x.\n",
             batch, qpos, instance->name, batch_qh(batch)->next);
 }

uspace/drv/uhci-hcd/transfer_list.h

@@ -39 +39 @@
 #include "batch.h"
 #include "hw_struct/queue_head.h"
-#include "utils/malloc32.h"
 
+/** Structure maintaining both hw queue and software list
+ * of currently executed transfers
+ */
 typedef struct transfer_list
 {
+        /** Guard against multiple add/remove races */
         fibril_mutex_t guard;
+        /** UHCI hw structure represeting this queue */
         qh_t *queue_head;
-        uint32_t queue_head_pa;
+        /** Assigned name, for nicer debug output */
         const char *name;
+        /** List of all batches in this list */
         link_t batch_list;
 } transfer_list_t;
 
-/** Dispose transfer list structures.
- *
- * @param[in] instance Memory place to use.
- *
- * Frees memory for internal qh_t structure.
- */
-static inline void transfer_list_fini(transfer_list_t *instance)
-{
-        assert(instance);
-        free32(instance->queue_head);
-}
-
+void transfer_list_fini(transfer_list_t *instance);
 int transfer_list_init(transfer_list_t *instance, const char *name);
-
 void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
-
-void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
-
+void transfer_list_add_batch(
+    transfer_list_t *instance, usb_transfer_batch_t *batch);
 void transfer_list_remove_finished(transfer_list_t *instance, link_t *done);
-
 void transfer_list_abort_all(transfer_list_t *instance);
 #endif

uspace/drv/uhci-hcd/uhci.c

@@ -44 +44 @@
 #include "pci.h"
 
-/** IRQ handling callback, identifies device
+/** IRQ handling callback, forward status from call to diver structure.
  *
  * @param[in] dev DDF instance of the device to use.
  * @param[in] iid (Unused).
- * @param[in] call Pointer to the call that represents interrupt.
+ * @param[in] call Pointer to the call from kernel.
  */
 static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
@@ -61 +61 @@
 /** Get address of the device identified by handle.
  *
- * @param[in] dev DDF instance of the device to use.
- * @param[in] iid (Unused).
- * @param[in] call Pointer to the call that represents interrupt.
+ * @param[in] fun DDF instance of the function to use.
+ * @param[in] handle DDF handle of the driver seeking its USB address.
+ * @param[out] address Found address.
  */
 static int usb_iface_get_address(
@@ -69 +69 @@
 {
         assert(fun);
-        usb_device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.manager;
+        usb_device_keeper_t *manager =
+            &((uhci_t*)fun->dev->driver_data)->hc.manager;
 
         usb_address_t addr = usb_device_keeper_find(manager, handle);
@@ -83 +84 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Gets handle of the respective hc (this or parent device).
- *
- * @param[in] root_hub_fun Root hub function seeking hc handle.
- * @param[out] handle Place to write the handle.
+/** Gets handle of the respective hc.
+ *
+ * @param[in] fun DDF function of uhci device.
+ * @param[out] handle Host cotnroller handle.
  * @return Error code.
  */
@@ -100 +101 @@
 }
 /*----------------------------------------------------------------------------*/
-/** This iface is generic for both RH and HC. */
+/** USB interface implementation used by RH */
 static usb_iface_t usb_iface = {
         .get_hc_handle = usb_iface_get_hc_handle,
@@ -106 +107 @@
 };
 /*----------------------------------------------------------------------------*/
+/** Operations supported by the HC driver */
 static ddf_dev_ops_t hc_ops = {
-//      .interfaces[USB_DEV_IFACE] = &usb_iface,
         .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
 };
@@ -122 +123 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Interface to provide the root hub driver with hw info */
 static hw_res_ops_t hw_res_iface = {
         .get_resource_list = get_resource_list,
@@ -127 +129 @@
 };
 /*----------------------------------------------------------------------------*/
+/** RH function support for uhci-rhd */
 static ddf_dev_ops_t rh_ops = {
         .interfaces[USB_DEV_IFACE] = &usb_iface,
@@ -132 +135 @@
 };
 /*----------------------------------------------------------------------------*/
-/** Initialize hc and rh ddf structures and their respective drivers.
+/** Initialize hc and rh DDF structures and their respective drivers.
  *
  * @param[in] instance UHCI structure to use.
@@ -138 +141 @@
  *
  * This function does all the preparatory work for hc and rh drivers:
- *  - gets device hw resources
- *  - disables UHCI legacy support
+ *  - gets device's hw resources
+ *  - disables UHCI legacy support (PCI config space)
  *  - asks for interrupt
  *  - registers interrupt handler
@@ -193 +196 @@
         ret = (instance->hc_fun == NULL) ? ENOMEM : EOK;
         CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed(%d) to create HC function.\n", ret);
+            "Failed(%d) to create HC function: %s.\n", ret, str_error(ret));
 
         ret = hc_init(&instance->hc, instance->hc_fun,
             (void*)io_reg_base, io_reg_size, interrupts);
-        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to init uhci-hcd.\n", ret);
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed(%d) to init uhci-hcd: %s.\n", ret, str_error(ret));
+
         instance->hc_fun->ops = &hc_ops;
         instance->hc_fun->driver_data = &instance->hc;
@@ -221 +226 @@
             &instance->hc.interrupt_code);
         CHECK_RET_FINI_RETURN(ret,
-            "Failed(%d) to register interrupt handler.\n", ret);
+            "Failed(%d) to register interrupt handler: %s.\n",
+            ret, str_error(ret));
 
         instance->rh_fun = ddf_fun_create(device, fun_inner, "uhci-rh");
         ret = (instance->rh_fun == NULL) ? ENOMEM : EOK;
         CHECK_RET_FINI_RETURN(ret,
-            "Failed(%d) to create root hub function.\n", ret);
+            "Failed(%d) to create root hub function: %s.\n",
+            ret, str_error(ret));
 
         ret = rh_init(&instance->rh, instance->rh_fun,
             (uintptr_t)instance->hc.registers + 0x10, 4);
         CHECK_RET_FINI_RETURN(ret,
-            "Failed(%d) to setup UHCI root hub.\n", ret);
+            "Failed(%d) to setup UHCI root hub: %s.\n", ret, str_error(ret));
 
         instance->rh_fun->ops = &rh_ops;
@@ -237 +244 @@
         ret = ddf_fun_bind(instance->rh_fun);
         CHECK_RET_FINI_RETURN(ret,
-            "Failed(%d) to register UHCI root hub.\n", ret);
+            "Failed(%d) to register UHCI root hub: %s.\n", ret, str_error(ret));
 
         return EOK;

uspace/drv/uhci-hcd/uhci.h

@@ -41 +41 @@
 #include "root_hub.h"
 
+/** Structure representing both functions of UHCI hc, USB host controller
+ * and USB root hub */
 typedef struct uhci {
+        /** Pointer to DDF represenation of UHCI host controller */
         ddf_fun_t *hc_fun;
+        /** Pointer to DDF represenation of UHCI root hub */
         ddf_fun_t *rh_fun;
 
+        /** Internal driver's represenation of UHCI host controller */
         hc_t hc;
+        /** Internal driver's represenation of UHCI root hub */
         rh_t rh;
 } uhci_t;
 
 int uhci_init(uhci_t *instance, ddf_dev_t *device);
-
 #endif
 /**