Changeset fd07e526 in mainline for uspace/drv/bus/usb/ohci

Timestamp:

2011-09-16T14:50:20Z (15 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

432a269, d1e18573

Parents:

47fecbb (diff), 82a31261 (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 USB changes from bzr://krabicka.net/orome/helenos/usb/

• Move common HC code from uhci/ohci drivers to libusbhost
• Rewrite USB HC interface to have common read/write functions for all transfer types.
• Restructure hc drivers to avoid some hooks and void* casts
• Cleanup the code and remove unnecessary mallocs.

Location:

uspace/drv/bus/usb/ohci

Files:

• Makefile (modified) (1 diff)
• batch.c (deleted)
• endpoint_list.c (modified) (3 diffs)
• endpoint_list.h (modified) (2 diffs)
• hc.c (modified) (12 diffs)
• hc.h (modified) (4 diffs)
• hw_struct/transfer_descriptor.c (modified) (1 diff)
• hw_struct/transfer_descriptor.h (modified) (1 diff)
• iface.c (deleted)
• iface.h (deleted)
• ohci.c (modified) (11 diffs)
• ohci_batch.c (added)
• ohci_batch.h (moved) (moved from uspace/drv/bus/usb/ohci/batch.h ) (1 diff)
• ohci_endpoint.c (moved) (moved from uspace/drv/bus/usb/ohci/hcd_endpoint.c ) (4 diffs)
• ohci_endpoint.h (moved) (moved from uspace/drv/bus/usb/ohci/hcd_endpoint.h ) (3 diffs)
• root_hub.c (modified) (9 diffs)
• root_hub.h (modified) (2 diffs)
• utils/malloc32.h (modified) (1 diff)

uspace/drv/bus/usb/ohci/Makefile

@@ -44 +44 @@
 
 SOURCES = \
-        batch.c \
         endpoint_list.c \
         hc.c \
-        hcd_endpoint.c \
-        iface.c \
         main.c \
         ohci.c \
+        ohci_batch.c \
+        ohci_endpoint.c \
         pci.c \
         root_hub.c \

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

@@ -87 +87 @@
  * 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)
+void endpoint_list_add_ep(endpoint_list_t *instance, ohci_endpoint_t *ep)
 {
         assert(instance);
-        assert(hcd_ep);
-        usb_log_debug2("Queue %s: Adding endpoint(%p).\n",
-            instance->name, hcd_ep);
+        assert(ep);
+        usb_log_debug2("Queue %s: Adding endpoint(%p).\n", instance->name, ep);
 
         fibril_mutex_lock(&instance->guard);
@@ -103 +102 @@
         } else {
                 /* There are active EDs, get the last one */
-                hcd_endpoint_t *last = list_get_instance(
-                    list_last(&instance->endpoint_list), hcd_endpoint_t, link);
+                ohci_endpoint_t *last = list_get_instance(
+                    list_last(&instance->endpoint_list), ohci_endpoint_t, link);
                 last_ed = last->ed;
         }
         /* Keep link */
-        hcd_ep->ed->next = last_ed->next;
+        ep->ed->next = last_ed->next;
         /* Make sure ED is written to the memory */
         write_barrier();
 
         /* Add ed to the hw queue */
-        ed_append_ed(last_ed, hcd_ep->ed);
+        ed_append_ed(last_ed, ep->ed);
         /* Make sure ED is updated */
         write_barrier();
 
         /* Add to the sw list */
-        list_append(&hcd_ep->link, &instance->endpoint_list);
+        list_append(&ep->link, &instance->endpoint_list);
 
-        hcd_endpoint_t *first = list_get_instance(
-            list_first(&instance->endpoint_list), hcd_endpoint_t, link);
+        ohci_endpoint_t *first = list_get_instance(
+            list_first(&instance->endpoint_list), ohci_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);
+                ep, instance->name, first, first->ed);
         if (last_ed == instance->list_head) {
                 usb_log_debug2("%s head ED(%p-0x%0" PRIx32 "): %x:%x:%x:%x.\n",
@@ -138 +137 @@
  * @param[in] endpoint Endpoint to remove.
  */
-void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep)
+void endpoint_list_remove_ep(endpoint_list_t *instance, ohci_endpoint_t *ep)
 {
         assert(instance);
         assert(instance->list_head);
-        assert(hcd_ep);
-        assert(hcd_ep->ed);
+        assert(ep);
+        assert(ep->ed);
 
         fibril_mutex_lock(&instance->guard);
 
-        usb_log_debug2(
-            "Queue %s: removing endpoint(%p).\n", instance->name, hcd_ep);
+        usb_log_debug2("Queue %s: removing endpoint(%p).\n", instance->name, ep);
 
         const char *qpos = NULL;
         ed_t *prev_ed;
         /* Remove from the hardware queue */
-        if (list_first(&instance->endpoint_list) == &hcd_ep->link) {
+        if (list_first(&instance->endpoint_list) == &ep->link) {
                 /* I'm the first one here */
                 prev_ed = instance->list_head;
                 qpos = "FIRST";
         } else {
-                hcd_endpoint_t *prev =
-                    list_get_instance(hcd_ep->link.prev, hcd_endpoint_t, link);
+                ohci_endpoint_t *prev =
+                    list_get_instance(ep->link.prev, ohci_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;
+        assert((prev_ed->next & ED_NEXT_PTR_MASK) == addr_to_phys(ep->ed));
+        prev_ed->next = ep->ed->next;
         /* Make sure ED is updated */
         write_barrier();
 
         usb_log_debug("HCD EP(%p) removed (%s) from %s, next %x.\n",
-            hcd_ep, qpos, instance->name, hcd_ep->ed->next);
+            ep, qpos, instance->name, ep->ed->next);
 
         /* Remove from the endpoint list */
-        list_remove(&hcd_ep->link);
+        list_remove(&ep->link);
         fibril_mutex_unlock(&instance->guard);
 }

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

@@ -37 +37 @@
 #include <fibril_synch.h>
 
-#include "hcd_endpoint.h"
+#include "ohci_endpoint.h"
 #include "hw_struct/endpoint_descriptor.h"
 #include "utils/malloc32.h"
@@ -69 +69 @@
 int endpoint_list_init(endpoint_list_t *instance, const char *name);
 void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next);
-void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
-void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
+void endpoint_list_add_ep(endpoint_list_t *instance, ohci_endpoint_t *ep);
+void endpoint_list_remove_ep(endpoint_list_t *instance, ohci_endpoint_t *ep);
 #endif
 /**

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

@@ -42 +42 @@
 
 #include "hc.h"
-#include "hcd_endpoint.h"
+#include "ohci_endpoint.h"
 
 #define OHCI_USED_INTERRUPTS \
@@ -61 +61 @@
 static int hc_init_memory(hc_t *instance);
 static int interrupt_emulator(hc_t *instance);
-
+static int hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch);
 /*----------------------------------------------------------------------------*/
 /** Get number of commands used in IRQ code.
@@ -128 +128 @@
 
         const usb_address_t hub_address =
-            device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
+            usb_device_manager_get_free_address(
+                &instance->generic.dev_manager, USB_SPEED_FULL);
         if (hub_address <= 0) {
                 usb_log_error("Failed to get OHCI root hub address: %s\n",
@@ -135 +136 @@
         }
         instance->rh.address = hub_address;
-        usb_device_keeper_bind(
-            &instance->manager, hub_address, hub_fun->handle);
-
-#define CHECK_RET_RELEASE(ret, message...) \
+        usb_device_manager_bind(
+            &instance->generic.dev_manager, hub_address, hub_fun->handle);
+
+#define CHECK_RET_UNREG_RETURN(ret, message...) \
 if (ret != EOK) { \
         usb_log_error(message); \
-        hc_remove_endpoint(instance, hub_address, 0, USB_DIRECTION_BOTH); \
-        usb_device_keeper_release(&instance->manager, hub_address); \
+        usb_endpoint_manager_unregister_ep( \
+            &instance->generic.ep_manager, hub_address, 0, USB_DIRECTION_BOTH);\
+        usb_device_manager_release( \
+            &instance->generic.dev_manager, hub_address); \
         return ret; \
 } else (void)0
-
-        int ret = hc_add_endpoint(instance, hub_address, 0, USB_SPEED_FULL,
-            USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH, 64, 0, 0);
-        CHECK_RET_RELEASE(ret,
-            "Failed to add OHCI root hub endpoint 0: %s.\n", str_error(ret));
+        int ret = usb_endpoint_manager_add_ep(
+            &instance->generic.ep_manager, hub_address, 0, USB_DIRECTION_BOTH,
+            USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64, 0);
+        CHECK_RET_UNREG_RETURN(ret,
+            "Failed to register root hub control endpoint: %s.\n",
+            str_error(ret));
 
         ret = ddf_fun_add_match_id(hub_fun, "usb&class=hub", 100);
-        CHECK_RET_RELEASE(ret,
+        CHECK_RET_UNREG_RETURN(ret,
             "Failed to add root hub match-id: %s.\n", str_error(ret));
 
         ret = ddf_fun_bind(hub_fun);
-        CHECK_RET_RELEASE(ret,
+        CHECK_RET_UNREG_RETURN(ret,
             "Failed to bind root hub function: %s.\n", str_error(ret));
 
@@ -187 +191 @@
 
         list_initialize(&instance->pending_batches);
-        usb_device_keeper_init(&instance->manager);
-
-        ret = usb_endpoint_manager_init(&instance->ep_manager,
-            BANDWIDTH_AVAILABLE_USB11);
-        CHECK_RET_RETURN(ret, "Failed to initialize endpoint manager: %s.\n",
+
+        ret = hcd_init(&instance->generic, BANDWIDTH_AVAILABLE_USB11,
+            bandwidth_count_usb11);
+        CHECK_RET_RETURN(ret, "Failed to initialize generic driver: %s.\n",
             str_error(ret));
+        instance->generic.private_data = instance;
+        instance->generic.schedule = hc_schedule;
+        instance->generic.ep_add_hook = ohci_endpoint_init;
 
         ret = hc_init_memory(instance);
@@ -215 +221 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Create and register endpoint structures.
- *
- * @param[in] instance OHCI driver structure.
- * @param[in] address USB address of the device.
- * @param[in] endpoint USB endpoint number.
- * @param[in] speed Communication speeed of the device.
- * @param[in] type Endpoint's transfer type.
- * @param[in] direction Endpoint's direction.
- * @param[in] mps Maximum packet size the endpoint accepts.
- * @param[in] size Maximum allowed buffer size.
- * @param[in] interval Time between transfers(interrupt transfers only).
- * @return Error code
- */
-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 =
-            endpoint_get(address, endpoint, direction, type, speed, mps);
-        if (ep == NULL)
-                return ENOMEM;
-
-        hcd_endpoint_t *hcd_ep = hcd_endpoint_assign(ep);
-        if (hcd_ep == NULL) {
-                endpoint_destroy(ep);
-                return ENOMEM;
-        }
-
-        int 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 */
+void hc_enqueue_endpoint(hc_t *instance, endpoint_t *ep)
+{
+        endpoint_list_t *list = &instance->lists[ep->transfer_type];
+        ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
+        /* Enqueue ep */
         switch (ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
                 instance->registers->control &= ~C_CLE;
-                endpoint_list_add_ep(
-                    &instance->lists[ep->transfer_type], hcd_ep);
+                endpoint_list_add_ep(list, ohci_ep);
                 instance->registers->control_current = 0;
                 instance->registers->control |= C_CLE;
@@ -263 +235 @@
         case USB_TRANSFER_BULK:
                 instance->registers->control &= ~C_BLE;
-                endpoint_list_add_ep(
-                    &instance->lists[ep->transfer_type], hcd_ep);
+                endpoint_list_add_ep(list, ohci_ep);
                 instance->registers->control |= C_BLE;
                 break;
@@ -270 +241 @@
         case USB_TRANSFER_INTERRUPT:
                 instance->registers->control &= (~C_PLE & ~C_IE);
-                endpoint_list_add_ep(
-                    &instance->lists[ep->transfer_type], hcd_ep);
+                endpoint_list_add_ep(list, ohci_ep);
                 instance->registers->control |= C_PLE | C_IE;
                 break;
         }
-
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-/** Dequeue and delete endpoint structures
- *
- * @param[in] instance OHCI hc driver structure.
- * @param[in] address USB address of the device.
- * @param[in] endpoint USB endpoint number.
- * @param[in] direction Direction of the endpoint.
- * @return Error code
- */
-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;
-}
-/*----------------------------------------------------------------------------*/
-/** Get access to endpoint structures
- *
- * @param[in] instance OHCI hc driver structure.
- * @param[in] address USB address of the device.
- * @param[in] endpoint USB endpoint number.
- * @param[in] direction Direction of the endpoint.
- * @param[out] bw Reserved bandwidth.
- * @return Error code
- */
-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;
+}
+/*----------------------------------------------------------------------------*/
+void hc_dequeue_endpoint(hc_t *instance, endpoint_t *ep)
+{
+        /* Dequeue ep */
+        endpoint_list_t *list = &instance->lists[ep->transfer_type];
+        ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
+        switch (ep->transfer_type) {
+        case USB_TRANSFER_CONTROL:
+                instance->registers->control &= ~C_CLE;
+                endpoint_list_remove_ep(list, ohci_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(list, ohci_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(list, ohci_ep);
+                instance->registers->control |= C_PLE | C_IE;
+                break;
+        default:
+                break;
+        }
 }
 /*----------------------------------------------------------------------------*/
@@ -363 +281 @@
  * @return Error code.
  */
-int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch)
-{
-        assert(instance);
-        assert(batch);
-        assert(batch->ep);
+int hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
+{
+        assert(hcd);
+        hc_t *instance = hcd->private_data;
+        assert(instance);
 
         /* Check for root hub communication */
@@ -374 +292 @@
                 return EOK;
         }
+        ohci_transfer_batch_t *ohci_batch = ohci_transfer_batch_get(batch);
+        if (!ohci_batch)
+                return ENOMEM;
 
         fibril_mutex_lock(&instance->guard);
-        list_append(&batch->link, &instance->pending_batches);
-        batch_commit(batch);
+        list_append(&ohci_batch->link, &instance->pending_batches);
+        ohci_transfer_batch_commit(ohci_batch);
 
         /* Control and bulk schedules need a kick to start working */
@@ -417 +338 @@
                     instance->registers->periodic_current);
 
-                link_t *current = instance->pending_batches.head.next;
-                while (current != &instance->pending_batches.head) {
+                link_t *current = list_first(&instance->pending_batches);
+                while (current && current != &instance->pending_batches.head) {
                         link_t *next = current->next;
-                        usb_transfer_batch_t *batch =
-                            usb_transfer_batch_from_link(current);
-
-                        if (batch_is_complete(batch)) {
+                        ohci_transfer_batch_t *batch =
+                            ohci_transfer_batch_from_link(current);
+
+                        if (ohci_transfer_batch_is_complete(batch)) {
                                 list_remove(current);
-                                usb_transfer_batch_finish(batch);
+                                ohci_transfer_batch_finish_dispose(batch);
                         }
 
@@ -434 +355 @@
 
         if (status & I_UE) {
+                usb_log_fatal("Error like no other!\n");
                 hc_start(instance);
         }

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

@@ -41 +41 @@
 
 #include <usb/usb.h>
-#include <usb/host/device_keeper.h>
-#include <usb/host/usb_endpoint_manager.h>
-#include <usbhc_iface.h>
+#include <usb/host/hcd.h>
 
-#include "batch.h"
+#include "ohci_batch.h"
 #include "ohci_regs.h"
 #include "root_hub.h"
@@ -53 +51 @@
 /** Main OHCI 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;
+        /** Generic USB hc driver */
+        hcd_t generic;
 
         /** Memory mapped I/O registers area */
@@ -81 +77 @@
 int hc_get_irq_commands(
     irq_cmd_t cmds[], size_t cmd_size, uintptr_t regs, size_t reg_size);
+int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
 int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
-int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
 
 /** Safely dispose host controller internal structures
@@ -88 +84 @@
  * @param[in] instance Host controller structure to use.
  */
-static inline void hc_fini(hc_t *instance)
-        { /* TODO: implement*/ };
+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);
+void hc_enqueue_endpoint(hc_t *instance, endpoint_t *ep);
+void hc_dequeue_endpoint(hc_t *instance, endpoint_t *ep);
 
-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
- *
- * @param[in] fun DDF function pointer
- * @return cast pointer to driver_data
- */
-static inline hc_t * fun_to_hc(ddf_fun_t *fun)
-        { return fun->driver_data; }
 #endif
 /**

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

@@ -39 +39 @@
 static unsigned togg[2] = { TD_STATUS_T_0, TD_STATUS_T_1 };
 
-void td_init(
-    td_t *instance, usb_direction_t dir, void *buffer, size_t size, int toggle)
+void td_init(td_t *instance,
+    usb_direction_t dir, const void *buffer, size_t size, int toggle)
 {
         assert(instance);

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

@@ -75 +75 @@
 } __attribute__((packed)) td_t;
 
-void td_init(
-    td_t *instance, usb_direction_t dir, void *buffer, size_t size, int toggle);
+void td_init(td_t *instance,
+    usb_direction_t dir, const void *buffer, size_t size, int toggle);
 
 inline static void td_set_next(td_t *instance, td_t *next)

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

@@ -42 +42 @@
 
 #include "ohci.h"
-#include "iface.h"
 #include "pci.h"
 #include "hc.h"
-#include "root_hub.h"
 
 typedef struct ohci {
@@ -52 +50 @@
 
         hc_t hc;
-        rh_t rh;
 } ohci_t;
 
@@ -89 +86 @@
 {
         assert(fun);
-        usb_device_keeper_t *manager = &dev_to_ohci(fun->dev)->hc.manager;
-
-        usb_address_t addr = usb_device_keeper_find(manager, handle);
+        usb_device_manager_t *manager =
+            &dev_to_ohci(fun->dev)->hc.generic.dev_manager;
+
+        const usb_address_t addr = usb_device_manager_find(manager, handle);
         if (addr < 0) {
                 return addr;
@@ -129 +127 @@
 /** Standard USB HC options (HC interface) */
 static ddf_dev_ops_t hc_ops = {
-        .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
+        .interfaces[USBHC_DEV_IFACE] = &hcd_iface,
 };
 /*----------------------------------------------------------------------------*/
@@ -150 +148 @@
 int device_setup_ohci(ddf_dev_t *device)
 {
+        assert(device);
+
         ohci_t *instance = malloc(sizeof(ohci_t));
         if (instance == NULL) {
@@ -155 +155 @@
                 return ENOMEM;
         }
+        instance->rh_fun = NULL;
+        instance->hc_fun = NULL;
 
 #define CHECK_RET_DEST_FREE_RETURN(ret, message...) \
 if (ret != EOK) { \
         if (instance->hc_fun) { \
-                instance->hc_fun->ops = NULL; \
-                instance->hc_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->hc_fun); \
         } \
         if (instance->rh_fun) { \
-                instance->rh_fun->ops = NULL; \
-                instance->rh_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->rh_fun); \
         } \
         free(instance); \
-        device->driver_data = NULL; \
         usb_log_error(message); \
         return ret; \
 } else (void)0
 
-        instance->rh_fun = NULL;
         instance->hc_fun = ddf_fun_create(device, fun_exposed, "ohci_hc");
         int ret = instance->hc_fun ? EOK : ENOMEM;
@@ -194 +190 @@
         ret = pci_get_my_registers(device, &reg_base, &reg_size, &irq);
         CHECK_RET_DEST_FREE_RETURN(ret,
-            "Failed to get memory addresses for %" PRIun ": %s.\n",
+            "Failed to get register memory addresses for %" PRIun ": %s.\n",
             device->handle, str_error(ret));
         usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
@@ -201 +197 @@
         const size_t cmd_count = hc_irq_cmd_count();
         irq_cmd_t irq_cmds[cmd_count];
+        irq_code_t irq_code = { .cmdcount = cmd_count, .cmds = irq_cmds };
+
         ret =
             hc_get_irq_commands(irq_cmds, sizeof(irq_cmds), reg_base, reg_size);
@@ -206 +204 @@
             "Failed to generate IRQ commands: %s.\n", str_error(ret));
 
-        irq_code_t irq_code = { .cmdcount = cmd_count, .cmds = irq_cmds };
 
         /* Register handler to avoid interrupt lockup */
@@ -234 +231 @@
 #define CHECK_RET_FINI_RETURN(ret, message...) \
 if (ret != EOK) { \
+        hc_fini(&instance->hc); \
         unregister_interrupt_handler(device, irq); \
-        hc_fini(&instance->hc); \
         CHECK_RET_DEST_FREE_RETURN(ret, message); \
 } else (void)0
@@ -248 +245 @@
             "Failed to add OHCI to HC class: %s.\n", str_error(ret));
 
-        hc_register_hub(&instance->hc, instance->rh_fun);
-        return EOK;
-
-#undef CHECK_RET_DEST_FUN_RETURN
+        ret = hc_register_hub(&instance->hc, instance->rh_fun);
+        CHECK_RET_FINI_RETURN(ret,
+            "Failed to register OHCI root hub: %s.\n", str_error(ret));
+        return ret;
+
 #undef CHECK_RET_FINI_RETURN
 }

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

@@ -35 +35 @@
 #define DRV_OHCI_BATCH_H
 
+#include <adt/list.h>
 #include <usbhc_iface.h>
 #include <usb/usb.h>
-#include <usb/host/device_keeper.h>
-#include <usb/host/endpoint.h>
-#include <usb/host/batch.h>
+#include <usb/host/usb_transfer_batch.h>
 
-usb_transfer_batch_t * batch_get(
-    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
-    const char *setup_buffer, size_t setup_size,
-    usbhc_iface_transfer_in_callback_t func_in,
-    usbhc_iface_transfer_out_callback_t func_out,
-    void *arg);
+#include "hw_struct/transfer_descriptor.h"
+#include "hw_struct/endpoint_descriptor.h"
 
-bool batch_is_complete(usb_transfer_batch_t *instance);
+/** OHCI specific data required for USB transfer */
+typedef struct ohci_transfer_batch {
+        /** Link */
+        link_t link;
+        /** Endpoint descriptor of the target endpoint. */
+        ed_t *ed;
+        /** List of TDs needed for the transfer */
+        td_t **tds;
+        /** Number of TDs used by the transfer */
+        size_t td_count;
+        /** Dummy TD to be left at the ED and used by the next transfer */
+        size_t leave_td;
+        /** Data buffer, must be accessible by the OHCI hw. */
+        char *device_buffer;
+        /** Generic USB transfer structure */
+        usb_transfer_batch_t *usb_batch;
+} ohci_transfer_batch_t;
 
-void batch_commit(usb_transfer_batch_t *instance);
-
-void batch_control_write(usb_transfer_batch_t *instance);
-
-void batch_control_read(usb_transfer_batch_t *instance);
-
-void batch_interrupt_in(usb_transfer_batch_t *instance);
-
-void batch_interrupt_out(usb_transfer_batch_t *instance);
-
-void batch_bulk_in(usb_transfer_batch_t *instance);
-
-void batch_bulk_out(usb_transfer_batch_t *instance);
+ohci_transfer_batch_t * ohci_transfer_batch_get(usb_transfer_batch_t *batch);
+bool ohci_transfer_batch_is_complete(ohci_transfer_batch_t *batch);
+void ohci_transfer_batch_commit(ohci_transfer_batch_t *batch);
+void ohci_transfer_batch_finish_dispose(ohci_transfer_batch_t *batch);
+/*----------------------------------------------------------------------------*/
+static inline ohci_transfer_batch_t *ohci_transfer_batch_from_link(link_t *l)
+{
+        assert(l);
+        return list_get_instance(l, ohci_transfer_batch_t, link);
+}
 #endif
 /**

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

@@ -33 +33 @@
  */
 #include "utils/malloc32.h"
-#include "hcd_endpoint.h"
+#include "ohci_endpoint.h"
+#include "hc.h"
 
 /** Callback to set toggle on ED.
@@ -40 +41 @@
  * @param[in] toggle new value of toggle bit
  */
-static void hcd_ep_toggle_set(void *hcd_ep, int toggle)
+static void ohci_ep_toggle_set(void *ohci_ep, int toggle)
 {
-        hcd_endpoint_t *instance = hcd_ep;
+        ohci_endpoint_t *instance = ohci_ep;
         assert(instance);
         assert(instance->ed);
@@ -53 +54 @@
  * @return Current value of toggle bit.
  */
-static int hcd_ep_toggle_get(void *hcd_ep)
+static int ohci_ep_toggle_get(void *ohci_ep)
 {
-        hcd_endpoint_t *instance = hcd_ep;
+        ohci_endpoint_t *instance = ohci_ep;
         assert(instance);
         assert(instance->ed);
         return ed_toggle_get(instance->ed);
+}
+/*----------------------------------------------------------------------------*/
+/** Disposes hcd endpoint structure
+ *
+ * @param[in] hcd_ep endpoint structure
+ */
+static void ohci_endpoint_fini(endpoint_t *ep)
+{
+        ohci_endpoint_t *instance = ep->hc_data.data;
+        hc_dequeue_endpoint(instance->hcd->private_data, ep);
+        if (instance) {
+                free32(instance->ed);
+                free32(instance->td);
+                free(instance);
+        }
 }
 /*----------------------------------------------------------------------------*/
@@ -66 +82 @@
  * @return pointer to a new hcd endpoint structure, NULL on failure.
  */
-hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep)
+int ohci_endpoint_init(hcd_t *hcd, endpoint_t *ep)
 {
         assert(ep);
-        hcd_endpoint_t *hcd_ep = malloc(sizeof(hcd_endpoint_t));
-        if (hcd_ep == NULL)
-                return NULL;
+        ohci_endpoint_t *ohci_ep = malloc(sizeof(ohci_endpoint_t));
+        if (ohci_ep == NULL)
+                return ENOMEM;
 
-        hcd_ep->ed = malloc32(sizeof(ed_t));
-        if (hcd_ep->ed == NULL) {
-                free(hcd_ep);
-                return NULL;
+        ohci_ep->ed = malloc32(sizeof(ed_t));
+        if (ohci_ep->ed == NULL) {
+                free(ohci_ep);
+                return ENOMEM;
         }
 
-        hcd_ep->td = malloc32(sizeof(td_t));
-        if (hcd_ep->td == NULL) {
-                free32(hcd_ep->ed);
-                free(hcd_ep);
-                return NULL;
+        ohci_ep->td = malloc32(sizeof(td_t));
+        if (ohci_ep->td == NULL) {
+                free32(ohci_ep->ed);
+                free(ohci_ep);
+                return ENOMEM;
         }
 
-        ed_init(hcd_ep->ed, ep);
-        ed_set_td(hcd_ep->ed, hcd_ep->td);
-        endpoint_set_hc_data(ep, hcd_ep, hcd_ep_toggle_get, hcd_ep_toggle_set);
-
-        return hcd_ep;
-}
-/*----------------------------------------------------------------------------*/
-/** Disposes assigned hcd endpoint structure
- *
- * @param[in] ep USBD endpoint structure
- */
-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);
+        ed_init(ohci_ep->ed, ep);
+        ed_set_td(ohci_ep->ed, ohci_ep->td);
+        endpoint_set_hc_data(
+            ep, ohci_ep, ohci_endpoint_fini, ohci_ep_toggle_get, ohci_ep_toggle_set);
+        ohci_ep->hcd = hcd;
+        hc_enqueue_endpoint(hcd->private_data, ep);
+        return EOK;
 }
 /**

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

@@ -38 +38 @@
 #include <adt/list.h>
 #include <usb/host/endpoint.h>
+#include <usb/host/hcd.h>
 
 #include "hw_struct/endpoint_descriptor.h"
@@ -43 +44 @@
 
 /** Connector structure linking ED to to prepared TD. */
-typedef struct hcd_endpoint {
+typedef struct ohci_endpoint {
         /** OHCI endpoint descriptor */
         ed_t *ed;
@@ -50 +51 @@
         /** Linked list used by driver software */
         link_t link;
-} hcd_endpoint_t;
+        /** Device using this ep */
+        hcd_t *hcd;
+} ohci_endpoint_t;
 
-hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep);
-void hcd_endpoint_clear(endpoint_t *ep);
+int ohci_endpoint_init(hcd_t *hcd, endpoint_t *ep);
 
-/** Get and convert assigned hcd_endpoint_t structure
+/** Get and convert assigned ohci_endpoint_t structure
  * @param[in] ep USBD endpoint structure.
  * @return Pointer to assigned hcd endpoint structure
  */
-static inline hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
+static inline ohci_endpoint_t * ohci_endpoint_get(endpoint_t *ep)
 {
         assert(ep);

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

@@ -121 +121 @@
         assert(request);
 
-        memcpy(request->data_buffer, &mask, size);
         request->transfered_size = size;
-        usb_transfer_batch_finish_error(request, EOK);
+        usb_transfer_batch_finish_error(request, &mask, size, EOK);
 }
 
@@ -206 +205 @@
                 usb_log_debug("Root hub got CONTROL packet\n");
                 const int ret = control_request(instance, request);
-                usb_transfer_batch_finish_error(request, ret);
+                usb_transfer_batch_finish_error(request, NULL, 0, ret);
                 break;
         case USB_TRANSFER_INTERRUPT:
@@ -215 +214 @@
                         assert(instance->unfinished_interrupt_transfer == NULL);
                         instance->unfinished_interrupt_transfer = request;
-                        break;
+                        return;
                 }
                 usb_log_debug("Processing changes...\n");
@@ -223 +222 @@
         default:
                 usb_log_error("Root hub got unsupported request.\n");
-                usb_transfer_batch_finish_error(request, EINVAL);
-        }
+                usb_transfer_batch_finish_error(request, NULL, 0, EINVAL);
+        }
+        usb_transfer_batch_dispose(request);
 }
 /*----------------------------------------------------------------------------*/
@@ -244 +244 @@
         interrupt_request(instance->unfinished_interrupt_transfer,
             mask, instance->interrupt_mask_size);
+        usb_transfer_batch_dispose(instance->unfinished_interrupt_transfer);
 
         instance->unfinished_interrupt_transfer = NULL;
@@ -389 +390 @@
                 const uint32_t data = instance->registers->rh_status &
                     (RHS_LPS_FLAG | RHS_LPSC_FLAG | RHS_OCI_FLAG | RHS_OCIC_FLAG);
-                memcpy(request->data_buffer, &data, 4);
-                TRANSFER_OK(4);
+                memcpy(request->buffer, &data, sizeof(data));
+                TRANSFER_OK(sizeof(data));
         }
 
@@ -402 +403 @@
                 const uint32_t data =
                     instance->registers->rh_port_status[port - 1];
-                memcpy(request->data_buffer, &data, 4);
-                TRANSFER_OK(4);
+                memcpy(request->buffer, &data, sizeof(data));
+                TRANSFER_OK(sizeof(data));
         }
 
@@ -483 +484 @@
         }
 
-        memcpy(request->data_buffer, descriptor, size);
+        memcpy(request->buffer, descriptor, size);
         TRANSFER_OK(size);
 }
@@ -713 +714 @@
                 if (request->buffer_size != 1)
                         return EINVAL;
-                request->data_buffer[0] = 1;
+                request->buffer[0] = 1;
                 TRANSFER_OK(1);
 

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

@@ -37 +37 @@
 #include <usb/usb.h>
 #include <usb/dev/driver.h>
+#include <usb/host/usb_transfer_batch.h>
 
 #include "ohci_regs.h"
-#include "batch.h"
 
 #define HUB_DESCRIPTOR_MAX_SIZE (7 + 2 + 2)
@@ -66 +66 @@
         /** size of hub descriptor */
         size_t hub_descriptor_size;
-
 } rh_t;
 

uspace/drv/bus/usb/ohci/utils/malloc32.h

@@ -46 +46 @@
  * @return Physical address if exists, NULL otherwise.
  */
-static inline uintptr_t addr_to_phys(void *addr)
+static inline uintptr_t addr_to_phys(const void *addr)
 {
         uintptr_t result;