Changes in / [50114ef:5f80527] in mainline

Files:

• HelenOS.config (modified) (1 diff)
• uspace/drv/ohci/iface.c (modified) (16 diffs)
• uspace/drv/ohci/main.c (modified) (1 diff)
• uspace/drv/uhci-hcd/Makefile (modified) (1 diff)
• uspace/drv/uhci-hcd/batch.c (modified) (14 diffs)
• uspace/drv/uhci-hcd/batch.h (modified) (1 diff)
• uspace/drv/uhci-hcd/hc.c (deleted)
• uspace/drv/uhci-hcd/hc.h (deleted)
• uspace/drv/uhci-hcd/hw_struct/link_pointer.h (deleted)
• uspace/drv/uhci-hcd/hw_struct/queue_head.h (deleted)
• uspace/drv/uhci-hcd/hw_struct/transfer_descriptor.c (deleted)
• uspace/drv/uhci-hcd/hw_struct/transfer_descriptor.h (deleted)
• uspace/drv/uhci-hcd/iface.c (modified) (15 diffs)
• uspace/drv/uhci-hcd/iface.h (modified) (1 diff)
• uspace/drv/uhci-hcd/root_hub.c (deleted)
• uspace/drv/uhci-hcd/root_hub.h (deleted)
• uspace/drv/uhci-hcd/transfer_list.c (modified) (8 diffs)
• uspace/drv/uhci-hcd/transfer_list.h (modified) (1 diff)
• uspace/drv/uhci-hcd/uhci.c (modified) (9 diffs)
• uspace/drv/uhci-hcd/uhci.h (modified) (2 diffs)
• uspace/drv/uhci-hcd/uhci_hc.c (added)
• uspace/drv/uhci-hcd/uhci_hc.h (added)
• uspace/drv/uhci-hcd/uhci_rh.c (added)
• uspace/drv/uhci-hcd/uhci_rh.h (added)
• uspace/drv/uhci-hcd/uhci_struct/link_pointer.h (added)
• uspace/drv/uhci-hcd/uhci_struct/queue_head.h (added)
• uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c (added)
• uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h (added)
• uspace/drv/uhci-hcd/utils/malloc32.h (modified) (1 diff)
• uspace/lib/usb/src/host/device_keeper.c (modified) (1 diff)

HelenOS.config

@@ -552 +552 @@
 ! CONFIG_RUN_VIRTUAL_USB_HC (n/y)
 
-% Polling UHCI & OHCI (no interrupts)
-! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)

uspace/drv/ohci/iface.c

@@ -33 +33 @@
  */
 #include <ddf/driver.h>
+#include <ddf/interrupt.h>
+#include <device/hw_res.h>
 #include <errno.h>
-
+#include <str_error.h>
+
+#include <usb_iface.h>
+#include <usb/ddfiface.h>
 #include <usb/debug.h>
 
@@ -55 +60 @@
 static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
 {
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_log_debug("Default address request with speed %d.\n", speed);
-        usb_device_keeper_reserve_default_address(&hc->manager, speed);
-        return EOK;
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_log_debug("Default address request with speed %d.\n", speed);
+  usb_device_keeper_reserve_default_address(&hc->manager, speed);
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -70 +75 @@
 static int release_default_address(ddf_fun_t *fun)
 {
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_log_debug("Default address release.\n");
-        usb_device_keeper_release_default_address(&hc->manager);
-        return EOK;
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_log_debug("Default address release.\n");
+  usb_device_keeper_release_default_address(&hc->manager);
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -85 +90 @@
  * @return Error code.
  */
-static int request_address(
-    ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        assert(address);
-
-        usb_log_debug("Address request with speed %d.\n", speed);
-        *address = device_keeper_get_free_address(&hc->manager, speed);
-        usb_log_debug("Address request with result: %d.\n", *address);
-        if (*address <= 0)
-                return *address;
-        return EOK;
+static int request_address(ddf_fun_t *fun, usb_speed_t speed,
+    usb_address_t *address)
+{
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  assert(address);
+
+  usb_log_debug("Address request with speed %d.\n", speed);
+  *address = device_keeper_get_free_address(&hc->manager, speed);
+  usb_log_debug("Address request with result: %d.\n", *address);
+  if (*address <= 0)
+    return *address;
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -108 +113 @@
  * @return Error code.
  */
-static int bind_address(
-    ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_log_debug("Address bind %d-%d.\n", address, handle);
-        usb_device_keeper_bind(&hc->manager, address, handle);
-        return EOK;
+static int bind_address(ddf_fun_t *fun,
+    usb_address_t address, devman_handle_t handle)
+{
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_log_debug("Address bind %d-%d.\n", address, handle);
+  usb_device_keeper_bind(&hc->manager, address, handle);
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -127 +132 @@
 static int release_address(ddf_fun_t *fun, usb_address_t address)
 {
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_log_debug("Address release %d.\n", address);
-        usb_device_keeper_release(&hc->manager, address);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_log_debug("Address release %d.\n", address);
+  usb_device_keeper_release(&hc->manager, address);
+  return EOK;
+}
+
 /** Register endpoint for bandwidth reservation.
  *
@@ -146 +151 @@
  * @return Error code.
  */
-static int register_endpoint(
-    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
+static int register_endpoint(ddf_fun_t *fun,
+    usb_address_t address, usb_endpoint_t endpoint,
     usb_transfer_type_t transfer_type, usb_direction_t direction,
     size_t max_packet_size, unsigned int interval)
@@ -155 +160 @@
         return ENOTSUP;
 }
-/*----------------------------------------------------------------------------*/
+
 /** Unregister endpoint (free some bandwidth reservation).
  *
@@ -164 +169 @@
  * @return Error code.
  */
-static int unregister_endpoint(
-    ddf_fun_t *fun, usb_address_t address,
+static int unregister_endpoint(ddf_fun_t *fun, usb_address_t address,
     usb_endpoint_t endpoint, usb_direction_t direction)
 {
@@ -190 +194 @@
  * @return Error code.
  */
-static int interrupt_out(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
-
-        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
-            target.address, target.endpoint, size, max_packet_size);
-
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
-                speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
-        if (!batch)
-                return ENOMEM;
-        batch_interrupt_out(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
+
+  usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
+      target.address, target.endpoint, size, max_packet_size);
+
+  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
+      max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+      &hc->manager);
+  if (!batch)
+    return ENOMEM;
+  batch_interrupt_out(batch);
+  const int ret = hc_schedule(hc, batch);
+  if (ret != EOK) {
+    batch_dispose(batch);
+    return ret;
+  }
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -233 +236 @@
  * @return Error code.
  */
-static int interrupt_in(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
-        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
-            target.address, target.endpoint, size, max_packet_size);
-
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
-                speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
-        if (!batch)
-                return ENOMEM;
-        batch_interrupt_in(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
+  usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n", 
+      target.address, target.endpoint, size, max_packet_size);
+
+  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
+      max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+      &hc->manager);
+  if (!batch)
+    return ENOMEM;
+  batch_interrupt_in(batch);
+  const int ret = hc_schedule(hc, batch);
+  if (ret != EOK) {
+    batch_dispose(batch);
+    return ret;
+  }
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -275 +278 @@
  * @return Error code.
  */
-static int bulk_out(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
-
-        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
-            target.address, target.endpoint, size, max_packet_size);
-
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
-                data, size, NULL, 0, NULL, callback, arg, &hc->manager);
-        if (!batch)
-                return ENOMEM;
-        batch_bulk_out(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+static int bulk_out(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
+
+  usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
+      target.address, target.endpoint, size, max_packet_size);
+
+  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+      max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+      &hc->manager);
+  if (!batch)
+    return ENOMEM;
+  batch_bulk_out(batch);
+  const int ret = hc_schedule(hc, batch);
+  if (ret != EOK) {
+    batch_dispose(batch);
+    return ret;
+  }
+  return EOK;
+
 }
 /*----------------------------------------------------------------------------*/
@@ -318 +322 @@
  * @return Error code.
  */
-static int bulk_in(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
-        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
-            target.address, target.endpoint, size, max_packet_size);
-
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
-                data, size, NULL, 0, callback, NULL, arg, &hc->manager);
-        if (!batch)
-                return ENOMEM;
-        batch_bulk_in(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+static int bulk_in(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
+  usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
+      target.address, target.endpoint, size, max_packet_size);
+
+  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+      max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+      &hc->manager);
+  if (!batch)
+    return ENOMEM;
+  batch_bulk_in(batch);
+  const int ret = hc_schedule(hc, batch);
+  if (ret != EOK) {
+    batch_dispose(batch);
+    return ret;
+  }
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -363 +367 @@
  * @return Error code.
  */
-static int control_write(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
-    void *setup_data, size_t setup_size, void *data, size_t size,
+static int control_write(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size,
+    void *setup_data, size_t setup_size,
+    void *data, size_t size,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
-        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
-            speed, target.address, target.endpoint, size, max_packet_size);
-
-        if (setup_size != 8)
-                return EINVAL;
-
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
-                speed, data, size, setup_data, setup_size, NULL, callback, arg,
-                &hc->manager);
-        if (!batch)
-                return ENOMEM;
-        usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
-        batch_control_write(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
+  usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
+      speed, target.address, target.endpoint, size, max_packet_size);
+
+  if (setup_size != 8)
+    return EINVAL;
+
+  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
+      max_packet_size, speed, data, size, setup_data, setup_size,
+      NULL, callback, arg, &hc->manager);
+  if (!batch)
+    return ENOMEM;
+  usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
+  batch_control_write(batch);
+  const int ret = hc_schedule(hc, batch);
+  if (ret != EOK) {
+    batch_dispose(batch);
+    return ret;
+  }
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -414 +418 @@
  * @return Error code.
  */
-static int control_read(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
-    void *setup_data, size_t setup_size, void *data, size_t size,
+static int control_read(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size,
+    void *setup_data, size_t setup_size,
+    void *data, size_t size,
     usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
-
-        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
-            speed, target.address, target.endpoint, size, max_packet_size);
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
-                speed, data, size, setup_data, setup_size, callback, NULL, arg,
-                &hc->manager);
-        if (!batch)
-                return ENOMEM;
-        batch_control_read(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+  assert(fun);
+  hc_t *hc = fun_to_hc(fun);
+  assert(hc);
+  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
+
+  usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
+      speed, target.address, target.endpoint, size, max_packet_size);
+  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
+      max_packet_size, speed, data, size, setup_data, setup_size, callback,
+      NULL, arg, &hc->manager);
+  if (!batch)
+    return ENOMEM;
+  batch_control_read(batch);
+  const int ret = hc_schedule(hc, batch);
+  if (ret != EOK) {
+    batch_dispose(batch);
+    return ret;
+  }
+  return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -459 +463 @@
 
         .control_write = control_write,
-        .control_read = control_read,
+        .control_read = control_read
 };
 

uspace/drv/ohci/main.c

@@ -149 +149 @@
         }
 
-
         bool interrupts = false;
-#ifdef CONFIG_USBHC_NO_INTERRUPTS
-        usb_log_warning("Interrupts disabled in OS config, " \
-            "falling back to polling.\n");
-#else
         ret = pci_enable_interrupts(device);
         if (ret != EOK) {
-                usb_log_warning("Failed to enable interrupts: %s.\n",
-                    str_error(ret));
-                usb_log_info("HW interrupts not available, " \
-                    "falling back to polling.\n");
+                usb_log_warning(
+                    "Failed(%d) to enable interrupts, fall back to polling.\n",
+                    ret);
         } else {
                 usb_log_debug("Hw interrupts enabled.\n");
                 interrupts = true;
         }
-#endif
 
         ret = hc_init(hcd, hc_fun, device, mem_reg_base, mem_reg_size, interrupts);

uspace/drv/uhci-hcd/Makefile

@@ -37 +37 @@
         transfer_list.c \
         uhci.c \
-        hc.c \
-        root_hub.c \
-        hw_struct/transfer_descriptor.c \
+        uhci_hc.c \
+        uhci_rh.c \
+        uhci_struct/transfer_descriptor.c \
         pci.c \
         batch.c

uspace/drv/uhci-hcd/batch.c

@@ -40 +40 @@
 #include "batch.h"
 #include "transfer_list.h"
-#include "hw_struct/transfer_descriptor.h"
+#include "uhci_hc.h"
 #include "utils/malloc32.h"
+#include "uhci_struct/transfer_descriptor.h"
 
 #define DEFAULT_ERROR_COUNT 3
@@ -48 +49 @@
         qh_t *qh;
         td_t *tds;
-        size_t transfers;
+        size_t packets;
         usb_device_keeper_t *manager;
 } uhci_batch_t;
@@ -64 +65 @@
  * @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] max_packet_size maximum allowed size of data packets.
  * @param[in] speed Speed of the transaction.
  * @param[in] buffer Data source/destination.
@@ -77 +78 @@
  * NULL otherwise.
  *
- * Determines the number of needed transfers (TDs). Prepares a transport buffer
+ * Determines the number of needed packets (TDs). Prepares a transport buffer
  * (that is accessible by the hardware). Initializes parameters needed for the
  * transaction and callback.
@@ -117 +118 @@
         instance->private_data = data;
 
-        data->transfers = (buffer_size + max_packet_size - 1) / max_packet_size;
+        data->packets = (buffer_size + max_packet_size - 1) / max_packet_size;
         if (transfer_type == USB_TRANSFER_CONTROL) {
-                data->transfers += 2;
-        }
-
-        data->tds = malloc32(sizeof(td_t) * data->transfers);
+                data->packets += 2;
+        }
+
+        data->tds = malloc32(sizeof(td_t) * data->packets);
         CHECK_NULL_DISPOSE_RETURN(
             data->tds, "Failed to allocate transfer descriptors.\n");
-        bzero(data->tds, sizeof(td_t) * data->transfers);
+        bzero(data->tds, sizeof(td_t) * data->packets);
 
         data->qh = malloc32(sizeof(qh_t));
@@ -166 +167 @@
         assert(data);
 
-        usb_log_debug2("Batch(%p) checking %d transfer(s) for completion.\n",
-            instance, data->transfers);
+        usb_log_debug2("Batch(%p) checking %d packet(s) for completion.\n",
+            instance, data->packets);
         instance->transfered_size = 0;
         size_t i = 0;
-        for (;i < data->transfers; ++i) {
+        for (;i < data->packets; ++i) {
                 if (td_is_active(&data->tds[i])) {
                         return false;
@@ -298 +299 @@
  *
  * @param[in] instance Batch structure to use.
- * @param[in] pid Pid to use for data transfers.
+ * @param[in] pid to use for data packets.
  *
  * Packets with alternating toggle bit and supplied pid value.
- * The last transfer is marked with IOC flag.
+ * The last packet is marked with IOC flag.
  */
 void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid)
@@ -314 +315 @@
         assert(toggle == 0 || toggle == 1);
 
-        size_t transfer = 0;
+        size_t packet = 0;
         size_t remain_size = instance->buffer_size;
         while (remain_size > 0) {
@@ -325 +326 @@
                     remain_size : instance->max_packet_size;
 
-                td_t *next_transfer = (transfer + 1 < data->transfers)
-                    ? &data->tds[transfer + 1] : NULL;
-
-                assert(transfer < data->transfers);
+                td_t *next_packet = (packet + 1 < data->packets)
+                    ? &data->tds[packet + 1] : NULL;
+
+                assert(packet < data->packets);
                 assert(packet_size <= remain_size);
 
                 td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
+                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
                     toggle, false, low_speed, instance->target, pid, trans_data,
-                    next_transfer);
+                    next_packet);
 
 
                 toggle = 1 - toggle;
                 remain_size -= packet_size;
-                ++transfer;
-        }
-        td_set_ioc(&data->tds[transfer - 1]);
+                ++packet;
+        }
+        td_set_ioc(&data->tds[packet - 1]);
         usb_device_keeper_set_toggle(data->manager, instance->target,
             instance->direction, toggle);
@@ -349 +350 @@
  *
  * @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.
+ * @param[in] data_stage to use for data packets.
+ * @param[in] status_stage to use for data packets.
  *
  * Setup stage with toggle 0 and USB_PID_SETUP.
  * Data stage with alternating toggle and pid supplied by parameter.
  * Status stage with toggle 1 and pid supplied by parameter.
- * The last transfer is marked with IOC.
+ * The last packet is marked with IOC.
  */
 void batch_control(usb_transfer_batch_t *instance,
@@ -363 +364 @@
         uhci_batch_t *data = instance->private_data;
         assert(data);
-        assert(data->transfers >= 2);
+        assert(data->packets >= 2);
 
         const bool low_speed = instance->speed == USB_SPEED_LOW;
@@ -374 +375 @@
 
         /* data stage */
-        size_t transfer = 1;
+        size_t packet = 1;
         size_t remain_size = instance->buffer_size;
         while (remain_size > 0) {
@@ -388 +389 @@
 
                 td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
+                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
                     toggle, false, low_speed, instance->target, data_stage,
-                    control_data, &data->tds[transfer + 1]);
-
-                ++transfer;
-                assert(transfer < data->transfers);
+                    control_data, &data->tds[packet + 1]);
+
+                ++packet;
+                assert(packet < data->packets);
                 assert(packet_size <= remain_size);
                 remain_size -= packet_size;
@@ -399 +400 @@
 
         /* status stage */
-        assert(transfer == data->transfers - 1);
+        assert(packet == data->packets - 1);
 
         td_init(
-            &data->tds[transfer], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
+            &data->tds[packet], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
             instance->target, status_stage, NULL, NULL);
-        td_set_ioc(&data->tds[transfer]);
+        td_set_ioc(&data->tds[packet]);
 
         usb_log_debug2("Control last TD status: %x.\n",
-            data->tds[transfer].status);
+            data->tds[packet].status);
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci-hcd/batch.h

@@ -42 +42 @@
 #include <usb/host/batch.h>
 
-#include "hw_struct/queue_head.h"
+#include "uhci_struct/queue_head.h"
 
 usb_transfer_batch_t * batch_get(

uspace/drv/uhci-hcd/iface.c

@@ -33 +33 @@
  */
 #include <ddf/driver.h>
+#include <remote_usbhc.h>
+
+#include <usb/debug.h>
+
 #include <errno.h>
 
-#include <usb/debug.h>
-
 #include "iface.h"
-#include "hc.h"
+#include "uhci_hc.h"
 
 /** Reserve default address interface function
@@ -46 +48 @@
  * @return Error code.
  */
+/*----------------------------------------------------------------------------*/
 static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
 {
         assert(fun);
-        hc_t *hc = fun_to_hc(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Default address request with speed %d.\n", speed);
-        usb_device_keeper_reserve_default_address(&hc->manager, speed);
+        usb_device_keeper_reserve_default_address(&hc->device_manager, speed);
         return EOK;
 }
@@ -64 +67 @@
 {
         assert(fun);
-        hc_t *hc = fun_to_hc(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Default address release.\n");
-        usb_device_keeper_release_default_address(&hc->manager);
+        usb_device_keeper_release_default_address(&hc->device_manager);
         return EOK;
 }
@@ -78 +81 @@
  * @return Error code.
  */
-static int request_address(
-    ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
+static int request_address(ddf_fun_t *fun, usb_speed_t speed,
+    usb_address_t *address)
+{
+        assert(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         assert(address);
 
         usb_log_debug("Address request with speed %d.\n", speed);
-        *address = device_keeper_get_free_address(&hc->manager, speed);
+        *address = device_keeper_get_free_address(&hc->device_manager, speed);
         usb_log_debug("Address request with result: %d.\n", *address);
         if (*address <= 0)
-                return *address;
+          return *address;
         return EOK;
 }
@@ -105 +108 @@
 {
         assert(fun);
-        hc_t *hc = fun_to_hc(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Address bind %d-%d.\n", address, handle);
-        usb_device_keeper_bind(&hc->manager, address, handle);
+        usb_device_keeper_bind(&hc->device_manager, address, handle);
         return EOK;
 }
@@ -121 +124 @@
 {
         assert(fun);
-        hc_t *hc = fun_to_hc(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Address release %d.\n", address);
-        usb_device_keeper_release(&hc->manager, address);
+        usb_device_keeper_release(&hc->device_manager, address);
         return EOK;
 }
@@ -139 +142 @@
  * @return Error code.
  */
-static int interrupt_out(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
+static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
 
         usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
-                speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
+        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+            &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_interrupt_out(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -176 +179 @@
  * @return Error code.
  */
-static int interrupt_in(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
+static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
         usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
-                speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
+        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+                        &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_interrupt_in(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -212 +215 @@
  * @return Error code.
  */
-static int bulk_out(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
+static int bulk_out(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
 
         usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
-                data, size, NULL, 0, NULL, callback, arg, &hc->manager);
+        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+            &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_bulk_out(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -249 +252 @@
  * @return Error code.
  */
-static int bulk_in(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
-    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
+static int bulk_in(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
         usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
-                data, size, NULL, 0, callback, NULL, arg, &hc->manager);
+        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+            &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_bulk_in(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -279 +282 @@
  * @param[in] target USB device to write to.
  * @param[in] max_packet_size maximum size of data packet the device accepts.
- * @param[in] setup_data Data to send with SETUP transfer.
- * @param[in] setup_size Size of data to send with SETUP transfer (always 8B).
+ * @param[in] setup_data Data to send with SETUP packet.
+ * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
  * @param[in] data Source of data.
  * @param[in] size Size of data source.
@@ -287 +290 @@
  * @return Error code.
  */
-static int control_write(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
+static int control_write(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size,
     void *setup_data, size_t setup_size, void *data, size_t size,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
         assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
         usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
             speed, target.address, target.endpoint, size, max_packet_size);
@@ -303 +305 @@
                 return EINVAL;
 
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
-                data, size, setup_data, setup_size, NULL, callback, arg,
-                &hc->manager);
-        if (!batch)
-                return ENOMEM;
-        usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
+        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, setup_data, setup_size,
+            NULL, callback, arg, &hc->device_manager);
+        if (!batch)
+                return ENOMEM;
+        usb_device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
         batch_control_write(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -331 +333 @@
  * @return Error code.
  */
-static int control_read(
-    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
+static int control_read(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size,
     void *setup_data, size_t setup_size, void *data, size_t size,
     usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
         assert(fun);
-        hc_t *hc = fun_to_hc(fun);
-        assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
 
         usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
             speed, target.address, target.endpoint, size, max_packet_size);
-        usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
-                data, size, setup_data, setup_size, callback, NULL, arg,
-                &hc->manager);
+        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, setup_data, setup_size, callback,
+            NULL, arg, &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_control_read(batch);
-        const int ret = hc_schedule(hc, batch);
-        if (ret != EOK) {
-                batch_dispose(batch);
-        }
-        return ret;
-}
-/*----------------------------------------------------------------------------*/
-usbhc_iface_t hc_iface = {
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+usbhc_iface_t uhci_hc_iface = {
         .reserve_default_address = reserve_default_address,
         .release_default_address = release_default_address,
@@ -368 +369 @@
         .interrupt_in = interrupt_in,
 
+        .bulk_in = bulk_in,
         .bulk_out = bulk_out,
-        .bulk_in = bulk_in,
-
+
+        .control_read = control_read,
         .control_write = control_write,
-        .control_read = control_read,
 };
 /**

uspace/drv/uhci-hcd/iface.h

@@ -38 +38 @@
 #include <usbhc_iface.h>
 
-extern usbhc_iface_t hc_iface;
+extern usbhc_iface_t uhci_hc_iface;
 
 #endif

uspace/drv/uhci-hcd/transfer_list.c

@@ -79 +79 @@
         if (!instance->queue_head)
                 return;
-        /* Set both queue_head.next to point to the follower */
+        /* Set both next and element to point to the same QH */
         qh_set_next_qh(instance->queue_head, next->queue_head_pa);
+        qh_set_element_qh(instance->queue_head, next->queue_head_pa);
 }
 /*----------------------------------------------------------------------------*/
@@ -91 +92 @@
  * 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)
+void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch)
 {
         assert(instance);
@@ -98 +98 @@
         usb_log_debug2("Queue %s: Adding batch(%p).\n", instance->name, batch);
 
+        const uint32_t pa = addr_to_phys(batch_qh(batch));
+        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
+
+        /* New batch will be added to the end of the current list
+         * so set the link accordingly */
+        qh_set_next_qh(batch_qh(batch), instance->queue_head->next);
+
         fibril_mutex_lock(&instance->guard);
 
-        qh_t *last_qh = NULL;
         /* Add to the hardware queue. */
         if (list_empty(&instance->batch_list)) {
                 /* There is nothing scheduled */
-                last_qh = instance->queue_head;
+                qh_t *qh = instance->queue_head;
+                assert(qh->element == qh->next);
+                qh_set_element_qh(qh, pa);
         } else {
                 /* There is something scheduled */
                 usb_transfer_batch_t *last = list_get_instance(
                     instance->batch_list.prev, usb_transfer_batch_t, link);
-                last_qh = batch_qh(last);
-        }
-        const uint32_t pa = addr_to_phys(batch_qh(batch));
-        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
-
-        /* keep link */
-        batch_qh(batch)->next = last_qh->next;
-        qh_set_next_qh(last_qh, pa);
-
+                qh_set_next_qh(batch_qh(last), pa);
+        }
         /* Add to the driver list */
         list_append(&batch->link, &instance->batch_list);
@@ -147 +148 @@
         while (current != &instance->batch_list) {
                 link_t *next = current->next;
-                usb_transfer_batch_t *batch =
-                    list_get_instance(current, usb_transfer_batch_t, link);
+                usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link);
 
                 if (batch_is_complete(batch)) {
@@ -162 +162 @@
                 link_t *item = done.next;
                 list_remove(item);
-                usb_transfer_batch_t *batch =
-                    list_get_instance(item, usb_transfer_batch_t, link);
+                usb_transfer_batch_t *batch = list_get_instance(item, usb_transfer_batch_t, link);
                 batch->next_step(batch);
         }
@@ -175 +174 @@
 {
         fibril_mutex_lock(&instance->guard);
-        while (!list_empty(&instance->batch_list)) {
+        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);
+                usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link);
                 transfer_list_remove_batch(instance, batch);
                 usb_transfer_batch_finish(batch, EIO);
@@ -193 +191 @@
  * 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 transfer_list_remove_batch(transfer_list_t *instance, usb_transfer_batch_t *batch)
 {
         assert(instance);
@@ -200 +197 @@
         assert(batch);
         assert(batch_qh(batch));
-        assert(fibril_mutex_is_locked(&instance->guard));
-
         usb_log_debug2(
             "Queue %s: removing batch(%p).\n", instance->name, batch);
 
-        const char *qpos = NULL;
+        const char * pos = NULL;
         /* Remove from the hardware queue */
-        if (instance->batch_list.next == &batch->link) {
+        if (batch->link.prev == &instance->batch_list) {
                 /* 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;
-                qpos = "FIRST";
+                qh_set_element_qh(instance->queue_head, batch_qh(batch)->next);
+                pos = "FIRST";
         } else {
                 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;
-                qpos = "NOT FIRST";
-        }
-        /* Remove from the batch list */
+                    list_get_instance(batch->link.prev, usb_transfer_batch_t, link);
+                qh_set_next_qh(batch_qh(prev), batch_qh(batch)->next);
+                pos = "NOT FIRST";
+        }
+        /* Remove from the driver list */
         list_remove(&batch->link);
-        usb_log_debug("Batch(%p) removed (%s) from %s, next %x.\n",
-            batch, qpos, instance->name, batch_qh(batch)->next);
+        usb_log_debug("Batch(%p) removed (%s) from %s, next element %x.\n",
+            batch, pos, instance->name, batch_qh(batch)->next);
 }
 /**

uspace/drv/uhci-hcd/transfer_list.h

@@ -37 +37 @@
 #include <fibril_synch.h>
 
+#include "uhci_struct/queue_head.h"
+
 #include "batch.h"
-#include "hw_struct/queue_head.h"
 
 typedef struct transfer_list

uspace/drv/uhci-hcd/uhci.c

@@ -54 +54 @@
 {
         assert(dev);
-        hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
+        uhci_hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
         uint16_t status = IPC_GET_ARG1(*call);
         assert(hc);
-        hc_interrupt(hc, status);
+        uhci_hc_interrupt(hc, status);
 }
 /*----------------------------------------------------------------------------*/
@@ -70 +70 @@
 {
         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.device_manager;
 
         usb_address_t addr = usb_device_keeper_find(manager, handle);
@@ -107 +107 @@
 };
 /*----------------------------------------------------------------------------*/
-static ddf_dev_ops_t hc_ops = {
+static ddf_dev_ops_t uhci_hc_ops = {
         .interfaces[USB_DEV_IFACE] = &usb_iface,
-        .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
+        .interfaces[USBHC_DEV_IFACE] = &uhci_hc_iface, /* see iface.h/c */
 };
 /*----------------------------------------------------------------------------*/
@@ -120 +120 @@
 {
         assert(fun);
-        return &((rh_t*)fun->driver_data)->resource_list;
+        return &((uhci_rh_t*)fun->driver_data)->resource_list;
 }
 /*----------------------------------------------------------------------------*/
@@ -128 +128 @@
 };
 /*----------------------------------------------------------------------------*/
-static ddf_dev_ops_t rh_ops = {
+static ddf_dev_ops_t uhci_rh_ops = {
         .interfaces[USB_DEV_IFACE] = &usb_iface,
         .interfaces[HW_RES_DEV_IFACE] = &hw_res_iface
@@ -175 +175 @@
 
         bool interrupts = false;
-#ifdef CONFIG_USBHC_NO_INTERRUPTS
-        usb_log_warning("Interrupts disabled in OS config, " \
-            "falling back to polling.\n");
-#else
         ret = pci_enable_interrupts(device);
         if (ret != EOK) {
-                usb_log_warning("Failed to enable interrupts: %s.\n",
-                    str_error(ret));
-                usb_log_info("HW interrupts not available, " \
-                    "falling back to polling.\n");
+                usb_log_warning(
+                    "Failed(%d) to enable interrupts, fall back to polling.\n",
+                    ret);
         } else {
                 usb_log_debug("Hw interrupts enabled.\n");
                 interrupts = true;
         }
-#endif
 
         instance->hc_fun = ddf_fun_create(device, fun_exposed, "uhci-hc");
@@ -196 +190 @@
             "Failed(%d) to create HC function.\n", ret);
 
-        ret = hc_init(&instance->hc, instance->hc_fun,
+        ret = uhci_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);
-        instance->hc_fun->ops = &hc_ops;
+        instance->hc_fun->ops = &uhci_hc_ops;
         instance->hc_fun->driver_data = &instance->hc;
         ret = ddf_fun_bind(instance->hc_fun);
@@ -214 +208 @@
         if (instance->rh_fun) \
                 ddf_fun_destroy(instance->rh_fun); \
-        hc_fini(&instance->hc); \
+        uhci_hc_fini(&instance->hc); \
         return ret; \
 }
@@ -229 +223 @@
             "Failed(%d) to create root hub function.\n", ret);
 
-        ret = rh_init(&instance->rh, instance->rh_fun,
+        ret = uhci_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);
 
-        instance->rh_fun->ops = &rh_ops;
+        instance->rh_fun->ops = &uhci_rh_ops;
         instance->rh_fun->driver_data = &instance->rh;
         ret = ddf_fun_bind(instance->rh_fun);

uspace/drv/uhci-hcd/uhci.h

@@ -38 +38 @@
 #include <ddf/driver.h>
 
-#include "hc.h"
-#include "root_hub.h"
+#include "uhci_hc.h"
+#include "uhci_rh.h"
 
 typedef struct uhci {
@@ -45 +45 @@
         ddf_fun_t *rh_fun;
 
-        hc_t hc;
-        rh_t rh;
+        uhci_hc_t hc;
+        uhci_rh_t rh;
 } uhci_t;
 

uspace/drv/uhci-hcd/utils/malloc32.h

@@ -50 +50 @@
 static inline uintptr_t addr_to_phys(void *addr)
 {
-        if (addr == NULL)
-                return 0;
-
         uintptr_t result;
         int ret = as_get_physical_mapping(addr, &result);

uspace/lib/usb/src/host/device_keeper.c

@@ -214 +214 @@
         fibril_mutex_lock(&instance->guard);
 
-        usb_address_t new_address = instance->last_address;
-        do {
-                ++new_address;
-                if (new_address > USB11_ADDRESS_MAX)
-                        new_address = 1;
+        usb_address_t new_address = instance->last_address + 1;
+        while (instance->devices[new_address].occupied) {
                 if (new_address == instance->last_address) {
                         fibril_mutex_unlock(&instance->guard);
                         return ENOSPC;
                 }
-        } while (instance->devices[new_address].occupied);
+                if (new_address == USB11_ADDRESS_MAX)
+                        new_address = 1;
+                ++new_address;
+        }
 
         assert(new_address != USB_ADDRESS_DEFAULT);