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

Timestamp:

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

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

1b20da0

Parents:

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

git-author:

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

git-committer:

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

Message:

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

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

Notable additions and features:

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

Location:

uspace/drv/bus/usb/uhci

Files:

• hc.c (modified) (26 diffs)
• hc.h (modified) (5 diffs)
• hw_struct/queue_head.h (modified) (1 diff)
• hw_struct/transfer_descriptor.c (modified) (2 diffs)
• hw_struct/transfer_descriptor.h (modified) (1 diff)
• main.c (modified) (6 diffs)
• transfer_list.c (modified) (9 diffs)
• transfer_list.h (modified) (1 diff)
• uhci_batch.c (modified) (15 diffs)
• uhci_batch.h (modified) (7 diffs)
• uhci_rh.c (modified) (12 diffs)

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty, Petr Manek
  * All rights reserved.
  *
@@ -50 +51 @@
 #include <usb/usb.h>
 #include <usb/host/utils/malloc32.h>
+#include <usb/host/bandwidth.h>
+#include <usb/host/utility.h>
 
 #include "uhci_batch.h"
+#include "transfer_list.h"
 #include "hc.h"
 
@@ -107 +111 @@
  * @return Error code.
  */
-errno_t uhci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res, int *irq)
+errno_t hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
 {
         assert(code);
@@ -140 +144 @@
         code->cmds[3].addr = (void*)&registers->usbsts;
 
-        usb_log_debug("I/O regs at %p (size %zu), IRQ %d.\n",
+        usb_log_debug("I/O regs at %p (size %zu), IRQ %d.",
             RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
 
@@ -157 +161 @@
  * - resume from suspend state (not implemented)
  */
-void uhci_hc_interrupt(hcd_t *hcd, uint32_t status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+static void hc_interrupt(bus_t *bus, uint32_t status)
+{
+        hc_t *instance = bus_to_hc(bus);
+
         /* Lower 2 bits are transaction error and transaction complete */
         if (status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) {
-                LIST_INITIALIZE(done);
-                transfer_list_remove_finished(
-                    &instance->transfers_interrupt, &done);
-                transfer_list_remove_finished(
-                    &instance->transfers_control_slow, &done);
-                transfer_list_remove_finished(
-                    &instance->transfers_control_full, &done);
-                transfer_list_remove_finished(
-                    &instance->transfers_bulk_full, &done);
-
-                list_foreach_safe(done, current, next) {
-                        list_remove(current);
-                        uhci_transfer_batch_t *batch =
-                            uhci_transfer_batch_from_link(current);
-                        uhci_transfer_batch_finish_dispose(batch);
-                }
-        }
+                transfer_list_check_finished(&instance->transfers_interrupt);
+                transfer_list_check_finished(&instance->transfers_control_slow);
+                transfer_list_check_finished(&instance->transfers_control_full);
+                transfer_list_check_finished(&instance->transfers_bulk_full);
+        }
+
         /* Resume interrupts are not supported */
         if (status & UHCI_STATUS_RESUME) {
-                usb_log_error("Resume interrupt!\n");
+                usb_log_error("Resume interrupt!");
         }
 
         /* Bits 4 and 5 indicate hc error */
         if (status & (UHCI_STATUS_PROCESS_ERROR | UHCI_STATUS_SYSTEM_ERROR)) {
-                usb_log_error("UHCI hardware failure!.\n");
+                usb_log_error("UHCI hardware failure!.");
                 ++instance->hw_failures;
                 transfer_list_abort_all(&instance->transfers_interrupt);
@@ -199 +191 @@
                         hc_init_hw(instance);
                 } else {
-                        usb_log_fatal("Too many UHCI hardware failures!.\n");
-                        hc_fini(instance);
+                        usb_log_fatal("Too many UHCI hardware failures!.");
+                        hc_gone(&instance->base);
                 }
         }
@@ -216 +208 @@
  * interrupt fibrils.
  */
-errno_t hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res, bool interrupts)
-{
-        assert(instance);
+errno_t hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         assert(hw_res);
         if (hw_res->io_ranges.count != 1 ||
@@ -224 +216 @@
             return EINVAL;
 
-        instance->hw_interrupts = interrupts;
         instance->hw_failures = 0;
 
@@ -231 +222 @@
             (void **) &instance->registers);
         if (ret != EOK) {
-                usb_log_error("Failed to gain access to registers: %s.\n",
+                usb_log_error("Failed to gain access to registers: %s.",
                     str_error(ret));
                 return ret;
         }
 
-        usb_log_debug("Device registers at %" PRIx64 " (%zuB) accessible.\n",
+        usb_log_debug("Device registers at %" PRIx64 " (%zuB) accessible.",
             hw_res->io_ranges.ranges[0].address.absolute,
             hw_res->io_ranges.ranges[0].size);
@@ -242 +233 @@
         ret = hc_init_mem_structures(instance);
         if (ret != EOK) {
-                usb_log_error("Failed to init UHCI memory structures: %s.\n",
+                usb_log_error("Failed to init UHCI memory structures: %s.",
                     str_error(ret));
                 // TODO: we should disable pio here
@@ -248 +239 @@
         }
 
+        return EOK;
+}
+
+int hc_start(hc_device_t *hcd)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         hc_init_hw(instance);
         (void)hc_debug_checker;
 
-        uhci_rh_init(&instance->rh, instance->registers->ports, "uhci");
-
-        return EOK;
+        return uhci_rh_init(&instance->rh, instance->registers->ports, "uhci");
+}
+
+int hc_setup_roothub(hc_device_t *hcd)
+{
+        return hc_setup_virtual_root_hub(hcd, USB_SPEED_FULL);
 }
 
@@ -260 +260 @@
  * @param[in] instance Host controller structure to use.
  */
-void hc_fini(hc_t *instance)
+int hc_gone(hc_device_t *instance)
 {
         assert(instance);
         //TODO Implement
+        return ENOTSUP;
 }
 
@@ -293 +294 @@
         pio_write_32(&registers->flbaseadd, pa);
 
-        if (instance->hw_interrupts) {
+        if (instance->base.irq_cap >= 0) {
                 /* Enable all interrupts, but resume interrupt */
                 pio_write_16(&instance->registers->usbintr,
@@ -301 +302 @@
         const uint16_t cmd = pio_read_16(&registers->usbcmd);
         if (cmd != 0)
-                usb_log_warning("Previous command value: %x.\n", cmd);
+                usb_log_warning("Previous command value: %x.", cmd);
 
         /* Start the hc with large(64B) packet FSBR */
@@ -308 +309 @@
 }
 
+static usb_transfer_batch_t *create_transfer_batch(endpoint_t *ep)
+{
+        uhci_transfer_batch_t *batch = uhci_transfer_batch_create(ep);
+        return &batch->base;
+}
+
+static void destroy_transfer_batch(usb_transfer_batch_t *batch)
+{
+        uhci_transfer_batch_destroy(uhci_transfer_batch_get(batch));
+}
+
+static endpoint_t *endpoint_create(device_t *device, const usb_endpoint_descriptors_t *desc)
+{
+        endpoint_t *ep = calloc(1, sizeof(uhci_endpoint_t));
+        if (ep)
+                endpoint_init(ep, device, desc);
+        return ep;
+}
+
+static errno_t endpoint_register(endpoint_t *ep)
+{
+        hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
+
+        const errno_t err = usb2_bus_endpoint_register(&hc->bus_helper, ep);
+        if (err)
+                return err;
+
+        transfer_list_t *list = hc->transfers[ep->device->speed][ep->transfer_type];
+        if (!list)
+                /*
+                 * We don't support this combination (e.g. isochronous). Do not
+                 * fail early, because that would block any device with these
+                 * endpoints from connecting. Instead, make sure these transfers
+                 * are denied soon enough with ENOTSUP not to fail on asserts.
+                 */
+                return EOK;
+
+        endpoint_set_online(ep, &list->guard);
+        return EOK;
+}
+
+static void endpoint_unregister(endpoint_t *ep)
+{
+        hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
+        usb2_bus_endpoint_unregister(&hc->bus_helper, ep);
+
+        // Check for the roothub, as it does not schedule into lists
+        if (ep->device->address == uhci_rh_get_address(&hc->rh)) {
+                // FIXME: We shall check the roothub for active transfer. But
+                // as it is polling, there is no way to make it stop doing so.
+                // Return after rewriting uhci rh.
+                return;
+        }
+
+        transfer_list_t *list = hc->transfers[ep->device->speed][ep->transfer_type];
+        if (!list)
+                /*
+                 * We don't support this combination (e.g. isochronous),
+                 * so no transfer can be active.
+                 */
+                return;
+
+        fibril_mutex_lock(&list->guard);
+
+        endpoint_set_offline_locked(ep);
+        /* From now on, no other transfer will be scheduled. */
+
+        if (!ep->active_batch) {
+                fibril_mutex_unlock(&list->guard);
+                return;
+        }
+
+        /* First, offer the batch a short chance to be finished. */
+        endpoint_wait_timeout_locked(ep, 10000);
+
+        if (!ep->active_batch) {
+                fibril_mutex_unlock(&list->guard);
+                return;
+        }
+
+        uhci_transfer_batch_t * const batch =
+                uhci_transfer_batch_get(ep->active_batch);
+
+        /* Remove the batch from the schedule to stop it from being finished. */
+        endpoint_deactivate_locked(ep);
+        transfer_list_remove_batch(list, batch);
+
+        fibril_mutex_unlock(&list->guard);
+
+        /*
+         * We removed the batch from software schedule only, it's still possible
+         * that HC has it in its caches. Better wait a while before we release
+         * the buffers.
+         */
+        async_usleep(20000);
+        batch->base.error = EINTR;
+        batch->base.transferred_size = 0;
+        usb_transfer_batch_finish(&batch->base);
+}
+
+static int device_enumerate(device_t *dev)
+{
+        hc_t * const hc = bus_to_hc(dev->bus);
+        return usb2_bus_device_enumerate(&hc->bus_helper, dev);
+}
+
+static void device_gone(device_t *dev)
+{
+        hc_t * const hc = bus_to_hc(dev->bus);
+        usb2_bus_device_gone(&hc->bus_helper, dev);
+}
+
+static int hc_status(bus_t *, uint32_t *);
+static int hc_schedule(usb_transfer_batch_t *);
+
+static const bus_ops_t uhci_bus_ops = {
+        .interrupt = hc_interrupt,
+        .status = hc_status,
+
+        .device_enumerate = device_enumerate,
+        .device_gone = device_gone,
+
+        .endpoint_create = endpoint_create,
+        .endpoint_register = endpoint_register,
+        .endpoint_unregister = endpoint_unregister,
+
+        .batch_create = create_transfer_batch,
+        .batch_schedule = hc_schedule,
+        .batch_destroy = destroy_transfer_batch,
+};
+
 /** Initialize UHCI hc memory structures.
  *
@@ -321 +453 @@
 {
         assert(instance);
+
+        usb2_bus_helper_init(&instance->bus_helper, &bandwidth_accounting_usb11);
+
+        bus_init(&instance->bus, sizeof(device_t));
+        instance->bus.ops = &uhci_bus_ops;
+
+        hc_device_setup(&instance->base, &instance->bus);
 
         /* Init USB frame list page */
@@ -327 +466 @@
                 return ENOMEM;
         }
-        usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
+        usb_log_debug("Initialized frame list at %p.", instance->frame_list);
 
         /* Init transfer lists */
         errno_t ret = hc_init_transfer_lists(instance);
         if (ret != EOK) {
-                usb_log_error("Failed to initialize transfer lists.\n");
+                usb_log_error("Failed to initialize transfer lists.");
                 return_page(instance->frame_list);
                 return ENOMEM;
         }
-        usb_log_debug("Initialized transfer lists.\n");
+        list_initialize(&instance->pending_endpoints);
+        usb_log_debug("Initialized transfer lists.");
 
 
@@ -366 +506 @@
         errno_t ret = transfer_list_init(&instance->transfers_##type, name); \
         if (ret != EOK) { \
-                usb_log_error("Failed to setup %s transfer list: %s.\n", \
+                usb_log_error("Failed to setup %s transfer list: %s.", \
                     name, str_error(ret)); \
                 transfer_list_fini(&instance->transfers_bulk_full); \
@@ -411 +551 @@
 }
 
-errno_t uhci_hc_status(hcd_t *hcd, uint32_t *status)
-{
-        assert(hcd);
+static errno_t hc_status(bus_t *bus, uint32_t *status)
+{
+        hc_t *instance = bus_to_hc(bus);
         assert(status);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
 
         *status = 0;
@@ -427 +565 @@
 }
 
-/** Schedule batch for execution.
+/**
+ * Schedule batch for execution.
  *
  * @param[in] instance UHCI structure to use.
  * @param[in] batch Transfer batch to schedule.
  * @return Error code
- *
- * Checks for bandwidth availability and appends the batch to the proper queue.
- */
-errno_t uhci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
-        assert(batch);
-
-        if (batch->ep->address == uhci_rh_get_address(&instance->rh))
-                return uhci_rh_schedule(&instance->rh, batch);
-
+ */
+static errno_t hc_schedule(usb_transfer_batch_t *batch)
+{
         uhci_transfer_batch_t *uhci_batch = uhci_transfer_batch_get(batch);
-        if (!uhci_batch) {
-                usb_log_error("Failed to create UHCI transfer structures.\n");
-                return ENOMEM;
-        }
-
-        transfer_list_t *list =
-            instance->transfers[batch->ep->speed][batch->ep->transfer_type];
-        assert(list);
-        transfer_list_add_batch(list, uhci_batch);
-
-        return EOK;
+        endpoint_t *ep = batch->ep;
+        hc_t *hc = bus_to_hc(endpoint_get_bus(ep));
+
+        if (batch->target.address == uhci_rh_get_address(&hc->rh))
+                return uhci_rh_schedule(&hc->rh, batch);
+
+        transfer_list_t * const list =
+            hc->transfers[ep->device->speed][ep->transfer_type];
+
+        if (!list)
+                return ENOTSUP;
+
+        errno_t err;
+        if ((err = uhci_transfer_batch_prepare(uhci_batch)))
+                return err;
+
+        return transfer_list_add_batch(list, uhci_batch);
 }
 
@@ -479 +614 @@
 
                 if (((cmd & UHCI_CMD_RUN_STOP) != 1) || (sts != 0)) {
-                        usb_log_debug2("Command: %X Status: %X Intr: %x\n",
+                        usb_log_debug2("Command: %X Status: %X Intr: %x",
                             cmd, sts, intr);
                 }
@@ -486 +621 @@
                     pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
                 if (frame_list != addr_to_phys(instance->frame_list)) {
-                        usb_log_debug("Framelist address: %p vs. %p.\n",
+                        usb_log_debug("Framelist address: %p vs. %p.",
                             (void *) frame_list,
                             (void *) addr_to_phys(instance->frame_list));
@@ -497 +632 @@
                 uintptr_t real_pa = addr_to_phys(QH(interrupt));
                 if (expected_pa != real_pa) {
-                        usb_log_debug("Interrupt QH: %p (frame %d) vs. %p.\n",
+                        usb_log_debug("Interrupt QH: %p (frame %d) vs. %p.",
                             (void *) expected_pa, frnum, (void *) real_pa);
                 }
@@ -504 +639 @@
                 real_pa = addr_to_phys(QH(control_slow));
                 if (expected_pa != real_pa) {
-                        usb_log_debug("Control Slow QH: %p vs. %p.\n",
+                        usb_log_debug("Control Slow QH: %p vs. %p.",
                             (void *) expected_pa, (void *) real_pa);
                 }
@@ -511 +646 @@
                 real_pa = addr_to_phys(QH(control_full));
                 if (expected_pa != real_pa) {
-                        usb_log_debug("Control Full QH: %p vs. %p.\n",
+                        usb_log_debug("Control Full QH: %p vs. %p.",
                             (void *) expected_pa, (void *) real_pa);
                 }
@@ -518 +653 @@
                 real_pa = addr_to_phys(QH(bulk_full));
                 if (expected_pa != real_pa ) {
-                        usb_log_debug("Bulk QH: %p vs. %p.\n",
+                        usb_log_debug("Bulk QH: %p vs. %p.",
                             (void *) expected_pa, (void *) real_pa);
                 }

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -43 +44 @@
 #include <ddi.h>
 #include <usb/host/hcd.h>
+#include <usb/host/usb2_bus.h>
 #include <usb/host/usb_transfer_batch.h>
 
@@ -99 +101 @@
 /** Main UHCI driver structure */
 typedef struct hc {
+        /* Common hc_device header */
+        hc_device_t base;
+
         uhci_rh_t rh;
+        bus_t bus;
+        usb2_bus_helper_t bus_helper;
+
         /** Addresses of I/O registers */
         uhci_regs_t *registers;
@@ -117 +125 @@
         /** Pointer table to the above lists, helps during scheduling */
         transfer_list_t *transfers[2][4];
-        /** Indicator of hw interrupts availability */
-        bool hw_interrupts;
+
+        /**
+         * Guard for the pending list. Can be locked under EP guard, but not
+         * vice versa.
+         */
+        fibril_mutex_t guard;
+        /** List of endpoints with a transfer scheduled */
+        list_t pending_endpoints;
 
         /** Number of hw failures detected. */
@@ -124 +138 @@
 } hc_t;
 
-extern errno_t hc_init(hc_t *, const hw_res_list_parsed_t *, bool);
-extern void hc_fini(hc_t *);
+typedef struct uhci_endpoint {
+        endpoint_t base;
 
-extern errno_t uhci_hc_gen_irq_code(irq_code_t *, const hw_res_list_parsed_t *, int *);
+        bool toggle;
+} uhci_endpoint_t;
 
-extern void uhci_hc_interrupt(hcd_t *, uint32_t);
-extern errno_t uhci_hc_status(hcd_t *, uint32_t *);
-extern errno_t uhci_hc_schedule(hcd_t *, usb_transfer_batch_t *);
+static inline hc_t *hcd_to_hc(hc_device_t *hcd)
+{
+        assert(hcd);
+        return (hc_t *) hcd;
+}
+
+static inline hc_t *bus_to_hc(bus_t *bus)
+{
+        assert(bus);
+        return member_to_inst(bus, hc_t, bus);
+}
+
+int hc_unschedule_batch(usb_transfer_batch_t *);
+
+extern errno_t hc_add(hc_device_t *, const hw_res_list_parsed_t *);
+extern errno_t hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *, int *);
+extern errno_t hc_start(hc_device_t *);
+extern errno_t hc_setup_roothub(hc_device_t *);
+extern errno_t hc_gone(hc_device_t *);
 
 #endif

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

@@ -48 +48 @@
         /** Pointer to the next entity (another QH or TD */
         volatile link_pointer_t next;
-        /** Pointer to the contained entities (execution controlled by vertical flag*/
+        /**
+         * Pointer to the contained entities
+         * (execution controlled by vertical flag)
+         */
         volatile link_pointer_t element;
-} __attribute__((packed)) qh_t;
+} __attribute__((packed, aligned(16))) qh_t;
 
 /** Initialize queue head structure

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

@@ -104 +104 @@
         instance->buffer_ptr = addr_to_phys(buffer);
 
-        usb_log_debug2("Created TD(%p): %X:%X:%X:%X(%p).\n",
+        usb_log_debug2("Created TD(%p): %X:%X:%X:%X(%p).",
             instance, instance->next, instance->status, instance->device,
             instance->buffer_ptr, buffer);
         td_print_status(instance);
         if (pid == USB_PID_SETUP) {
-                usb_log_debug2("SETUP BUFFER: %s\n",
+                usb_log_debug2("SETUP BUFFER: %s",
                     usb_debug_str_buffer(buffer, 8, 8));
         }
@@ -160 +160 @@
         assert(instance);
         const uint32_t s = instance->status;
-        usb_log_debug2("TD(%p) status(%#" PRIx32 "):%s %d,%s%s%s%s%s%s%s%s%s%s%s %zu.\n",
+        usb_log_debug2("TD(%p) status(%#" PRIx32 "):%s %d,%s%s%s%s%s%s%s%s%s%s%s %zu.",
             instance, instance->status,
             (s & TD_STATUS_SPD_FLAG) ? " SPD," : "",

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

@@ -95 +95 @@
          * memory just needs to be aligned. We don't use it anyway.
          */
-} __attribute__((packed)) td_t;
+} __attribute__((packed, aligned(16))) td_t;
 
 

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Vojtech Horky, Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty, Petr Manek
  * All rights reserved.
  *
@@ -43 +44 @@
 #include <str_error.h>
 #include <usb/debug.h>
-#include <usb/host/ddf_helpers.h>
+#include <usb/host/utility.h>
 
 #include "hc.h"
@@ -49 +50 @@
 #define NAME "uhci"
 
-static errno_t uhci_driver_init(hcd_t *, const hw_res_list_parsed_t *, bool);
-static void uhci_driver_fini(hcd_t *);
-static errno_t disable_legacy(ddf_dev_t *);
+static errno_t disable_legacy(hc_device_t *);
 
-static const ddf_hc_driver_t uhci_hc_driver = {
-        .claim = disable_legacy,
-        .hc_speed = USB_SPEED_FULL,
-        .irq_code_gen = uhci_hc_gen_irq_code,
-        .init = uhci_driver_init,
-        .fini = uhci_driver_fini,
-        .name = "UHCI",
-        .ops = {
-                .schedule    = uhci_hc_schedule,
-                .irq_hook    = uhci_hc_interrupt,
-                .status_hook = uhci_hc_status,
-        },
+static const hc_driver_t uhci_driver = {
+        .name = NAME,
+        .hc_device_size = sizeof(hc_t),
+        .claim = disable_legacy,
+        .irq_code_gen = hc_gen_irq_code,
+        .hc_add = hc_add,
+        .start = hc_start,
+        .setup_root_hub = hc_setup_roothub,
+        .hc_gone = hc_gone,
 };
-
-static errno_t uhci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res, bool irq)
-{
-        assert(hcd);
-        assert(hcd_get_driver_data(hcd) == NULL);
-
-        hc_t *instance = malloc(sizeof(hc_t));
-        if (!instance)
-                return ENOMEM;
-
-        const errno_t ret = hc_init(instance, res, irq);
-        if (ret == EOK) {
-                hcd_set_implementation(hcd, instance, &uhci_hc_driver.ops);
-        } else {
-                free(instance);
-        }
-        return ret;
-}
-
-static void uhci_driver_fini(hcd_t *hcd)
-{
-        assert(hcd);
-        hc_t *hc = hcd_get_driver_data(hcd);
-        if (hc)
-                hc_fini(hc);
-
-        hcd_set_implementation(hcd, NULL, NULL);
-        free(hc);
-}
 
 /** Call the PCI driver with a request to clear legacy support register
@@ -101 +68 @@
  * @return Error code.
  */
-static errno_t disable_legacy(ddf_dev_t *device)
+static errno_t disable_legacy(hc_device_t *hcd)
 {
-        assert(device);
+        assert(hcd);
 
-        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(hcd->ddf_dev);
         if (parent_sess == NULL)
                 return ENOMEM;
@@ -113 +80 @@
         return pci_config_space_write_16(parent_sess, 0xc0, 0xaf00);
 }
-
-/** Initialize a new ddf driver instance for uhci hc and hub.
- *
- * @param[in] device DDF instance of the device to initialize.
- * @return Error code.
- */
-static errno_t uhci_dev_add(ddf_dev_t *device)
-{
-        usb_log_debug2("uhci_dev_add() called\n");
-        assert(device);
-        return hcd_ddf_add_hc(device, &uhci_hc_driver);
-}
-
-static const driver_ops_t uhci_driver_ops = {
-        .dev_add = uhci_dev_add,
-};
-
-static const driver_t uhci_driver = {
-        .name = NAME,
-        .driver_ops = &uhci_driver_ops
-};
-
 
 /** Initialize global driver structures (NONE).
@@ -149 +94 @@
         log_init(NAME);
         logctl_set_log_level(NAME, LVL_NOTE);
-        return ddf_driver_main(&uhci_driver);
+        return hc_driver_main(&uhci_driver);
 }
 /**

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty, Petr Manek
  * All rights reserved.
  *
@@ -41 +42 @@
 #include <usb/host/usb_transfer_batch.h>
 #include <usb/host/utils/malloc32.h>
+#include <usb/host/utility.h>
 
 #include "hw_struct/link_pointer.h"
 #include "transfer_list.h"
-
-static void transfer_list_remove_batch(
-    transfer_list_t *instance, uhci_transfer_batch_t *uhci_batch);
+#include "hc.h"
 
 /** Initialize transfer list structures.
@@ -62 +62 @@
         instance->queue_head = malloc32(sizeof(qh_t));
         if (!instance->queue_head) {
-                usb_log_error("Failed to allocate queue head.\n");
+                usb_log_error("Failed to allocate queue head.");
                 return ENOMEM;
         }
         const uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
-        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).\n",
+        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).",
             name, instance->queue_head, queue_head_pa);
 
@@ -103 +103 @@
 }
 
-/** Add transfer batch to the list and queue.
- *
- * @param[in] instance List to use.
- * @param[in] batch Transfer batch to submit.
+/**
+ * Add transfer batch to the list and queue.
  *
  * The batch is added to the end of the list and queue.
- */
-void transfer_list_add_batch(
+ *
+ * @param[in] instance List to use.
+ * @param[in] batch Transfer batch to submit. After return, the batch must
+ *                  not be used further.
+ */
+int transfer_list_add_batch(
     transfer_list_t *instance, uhci_transfer_batch_t *uhci_batch)
 {
         assert(instance);
         assert(uhci_batch);
-        usb_log_debug2("Batch %p adding to queue %s.\n",
-            uhci_batch->usb_batch, instance->name);
+
+        endpoint_t *ep = uhci_batch->base.ep;
 
         fibril_mutex_lock(&instance->guard);
+
+        const int err = endpoint_activate_locked(ep, &uhci_batch->base);
+        if (err) {
+                fibril_mutex_unlock(&instance->guard);
+                return err;
+        }
+
+        usb_log_debug2("Batch %p adding to queue %s.",
+            uhci_batch, instance->name);
 
         /* Assume there is nothing scheduled */
@@ -145 +156 @@
 
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
-            " scheduled in queue %s.\n", uhci_batch->usb_batch,
-            USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch), instance->name);
+            " scheduled in queue %s.", uhci_batch,
+            USB_TRANSFER_BATCH_ARGS(uhci_batch->base), instance->name);
         fibril_mutex_unlock(&instance->guard);
+        return EOK;
+}
+
+/**
+ * Reset toggle on endpoint callback.
+ */
+static void uhci_reset_toggle(endpoint_t *ep)
+{
+        uhci_endpoint_t *uhci_ep = (uhci_endpoint_t *) ep;
+        uhci_ep->toggle = 0;
 }
 
@@ -155 +176 @@
  * @param[in] done list to fill
  */
-void transfer_list_remove_finished(transfer_list_t *instance, list_t *done)
-{
-        assert(instance);
-        assert(done);
+void transfer_list_check_finished(transfer_list_t *instance)
+{
+        assert(instance);
 
         fibril_mutex_lock(&instance->guard);
-        link_t *current = list_first(&instance->batch_list);
-        while (current && current != &instance->batch_list.head) {
-                link_t * const next = current->next;
-                uhci_transfer_batch_t *batch =
-                    uhci_transfer_batch_from_link(current);
-
-                if (uhci_transfer_batch_is_complete(batch)) {
-                        /* Save for processing */
+        list_foreach_safe(instance->batch_list, current, next) {
+                uhci_transfer_batch_t *batch = uhci_transfer_batch_from_link(current);
+
+                if (uhci_transfer_batch_check_completed(batch)) {
+                        assert(batch->base.ep->active_batch == &batch->base);
+                        endpoint_deactivate_locked(batch->base.ep);
+                        hc_reset_toggles(&batch->base, &uhci_reset_toggle);
                         transfer_list_remove_batch(instance, batch);
-                        list_append(current, done);
+                        usb_transfer_batch_finish(&batch->base);
                 }
-                current = next;
         }
         fibril_mutex_unlock(&instance->guard);
@@ -186 +204 @@
         while (!list_empty(&instance->batch_list)) {
                 link_t * const current = list_first(&instance->batch_list);
-                uhci_transfer_batch_t *batch =
-                    uhci_transfer_batch_from_link(current);
+                uhci_transfer_batch_t *batch = uhci_transfer_batch_from_link(current);
                 transfer_list_remove_batch(instance, batch);
-                uhci_transfer_batch_abort(batch);
         }
         fibril_mutex_unlock(&instance->guard);
@@ -209 +225 @@
         assert(uhci_batch->qh);
         assert(fibril_mutex_is_locked(&instance->guard));
-
-        usb_log_debug2("Batch %p removing from queue %s.\n",
-            uhci_batch->usb_batch, instance->name);
+        assert(!list_empty(&instance->batch_list));
+
+        usb_log_debug2("Batch %p removing from queue %s.",
+            uhci_batch, instance->name);
 
         /* Assume I'm the first */
@@ -233 +250 @@
         list_remove(&uhci_batch->link);
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " removed (%s) "
-            "from %s, next: %x.\n", uhci_batch->usb_batch,
-            USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
+            "from %s, next: %x.", uhci_batch,
+            USB_TRANSFER_BATCH_ARGS(uhci_batch->base),
             qpos, instance->name, uhci_batch->qh->next);
 }

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

@@ -56 +56 @@
 } transfer_list_t;
 
-void transfer_list_fini(transfer_list_t *instance);
-errno_t 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, uhci_transfer_batch_t *batch);
-void transfer_list_remove_finished(transfer_list_t *instance, list_t *done);
-void transfer_list_abort_all(transfer_list_t *instance);
+void transfer_list_fini(transfer_list_t *);
+errno_t transfer_list_init(transfer_list_t *, const char *);
+void transfer_list_set_next(transfer_list_t *, transfer_list_t *);
+errno_t transfer_list_add_batch(transfer_list_t *, uhci_transfer_batch_t *);
+void transfer_list_remove_batch(transfer_list_t *, uhci_transfer_batch_t *);
+void transfer_list_check_finished(transfer_list_t *);
+void transfer_list_abort_all(transfer_list_t *);
 
 #endif

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -46 +47 @@
 
 #include "uhci_batch.h"
+#include "hc.h"
 #include "hw_struct/transfer_descriptor.h"
 
 #define DEFAULT_ERROR_COUNT 3
 
-/** Safely destructs uhci_transfer_batch_t structure.
+/** Transfer batch setup table. */
+static void (*const batch_setup[])(uhci_transfer_batch_t*);
+
+/** Destroys uhci_transfer_batch_t structure.
  *
  * @param[in] uhci_batch Instance to destroy.
  */
-static void uhci_transfer_batch_dispose(uhci_transfer_batch_t *uhci_batch)
-{
-        if (uhci_batch) {
-                usb_transfer_batch_destroy(uhci_batch->usb_batch);
-                free32(uhci_batch->device_buffer);
-                free(uhci_batch);
-        }
-}
-
-/** Finishes usb_transfer_batch and destroys the structure.
- *
- * @param[in] uhci_batch Instance to finish and destroy.
- */
-void uhci_transfer_batch_finish_dispose(uhci_transfer_batch_t *uhci_batch)
+void uhci_transfer_batch_destroy(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        assert(!link_in_use(&uhci_batch->link));
-        usb_transfer_batch_finish(uhci_batch->usb_batch,
-            uhci_transfer_batch_data_buffer(uhci_batch));
-        uhci_transfer_batch_dispose(uhci_batch);
-}
-
-/** Transfer batch setup table. */
-static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t);
+        dma_buffer_free(&uhci_batch->uhci_dma_buffer);
+        free(uhci_batch);
+}
 
 /** Allocate memory and initialize internal data structure.
@@ -85 +71 @@
  * @return Valid pointer if all structures were successfully created,
  * NULL otherwise.
+ */
+uhci_transfer_batch_t * uhci_transfer_batch_create(endpoint_t *ep)
+{
+        uhci_transfer_batch_t *uhci_batch =
+            calloc(1, sizeof(uhci_transfer_batch_t));
+        if (!uhci_batch) {
+                usb_log_error("Failed to allocate UHCI batch.");
+                return NULL;
+        }
+
+        usb_transfer_batch_init(&uhci_batch->base, ep);
+
+        link_initialize(&uhci_batch->link);
+        return uhci_batch;
+}
+
+/* Prepares batch for commiting.
  *
  * Determines the number of needed transfer descriptors (TDs).
@@ -90 +93 @@
  * Initializes parameters needed for the transfer and callback.
  */
-uhci_transfer_batch_t * uhci_transfer_batch_get(usb_transfer_batch_t *usb_batch)
+int uhci_transfer_batch_prepare(uhci_transfer_batch_t *uhci_batch)
 {
         static_assert((sizeof(td_t) % 16) == 0);
-#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
-        if (ptr == NULL) { \
-                usb_log_error(message); \
-                uhci_transfer_batch_dispose(uhci_batch); \
-                return NULL; \
-        } else (void)0
-
-        uhci_transfer_batch_t *uhci_batch =
-            calloc(1, sizeof(uhci_transfer_batch_t));
-        CHECK_NULL_DISPOSE_RETURN(uhci_batch,
-            "Failed to allocate UHCI batch.\n");
-        link_initialize(&uhci_batch->link);
-        uhci_batch->td_count =
-            (usb_batch->buffer_size + usb_batch->ep->max_packet_size - 1)
-            / usb_batch->ep->max_packet_size;
+
+        usb_transfer_batch_t *usb_batch = &uhci_batch->base;
+
+        uhci_batch->td_count = (usb_batch->size + usb_batch->ep->max_packet_size - 1)
+                / usb_batch->ep->max_packet_size;
+
         if (usb_batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
                 uhci_batch->td_count += 2;
         }
 
+        const size_t setup_size = (usb_batch->ep->transfer_type == USB_TRANSFER_CONTROL)
+                ? USB_SETUP_PACKET_SIZE
+                : 0;
+
         const size_t total_size = (sizeof(td_t) * uhci_batch->td_count)
-            + sizeof(qh_t) + usb_batch->setup_size + usb_batch->buffer_size;
-        uhci_batch->device_buffer = malloc32(total_size);
-        CHECK_NULL_DISPOSE_RETURN(uhci_batch->device_buffer,
-            "Failed to allocate UHCI buffer.\n");
-        memset(uhci_batch->device_buffer, 0, total_size);
-
-        uhci_batch->tds = uhci_batch->device_buffer;
-        uhci_batch->qh =
-            (uhci_batch->device_buffer + (sizeof(td_t) * uhci_batch->td_count));
+            + sizeof(qh_t) + setup_size;
+
+        if (dma_buffer_alloc(&uhci_batch->uhci_dma_buffer, total_size)) {
+                usb_log_error("Failed to allocate UHCI buffer.");
+                return ENOMEM;
+        }
+        memset(uhci_batch->uhci_dma_buffer.virt, 0, total_size);
+
+        uhci_batch->tds = uhci_batch->uhci_dma_buffer.virt;
+        uhci_batch->qh = (qh_t *) &uhci_batch->tds[uhci_batch->td_count];
 
         qh_init(uhci_batch->qh);
         qh_set_element_td(uhci_batch->qh, &uhci_batch->tds[0]);
 
-        void *dest =
-            uhci_batch->device_buffer + (sizeof(td_t) * uhci_batch->td_count)
-            + sizeof(qh_t);
+        void *setup_buffer = uhci_transfer_batch_setup_buffer(uhci_batch);
+        assert(setup_buffer == (void *) (uhci_batch->qh + 1));
         /* Copy SETUP packet data to the device buffer */
-        memcpy(dest, usb_batch->setup_buffer, usb_batch->setup_size);
-        dest += usb_batch->setup_size;
-        /* Copy generic data unless they are provided by the device */
-        if (usb_batch->ep->direction != USB_DIRECTION_IN) {
-                memcpy(dest, usb_batch->buffer, usb_batch->buffer_size);
-        }
-        uhci_batch->usb_batch = usb_batch;
+        memcpy(setup_buffer, usb_batch->setup.buffer, setup_size);
+
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
-            " memory structures ready.\n", usb_batch,
+            " memory structures ready.", usb_batch,
             USB_TRANSFER_BATCH_ARGS(*usb_batch));
 
-        const usb_direction_t dir = usb_transfer_batch_direction(usb_batch);
-
         assert(batch_setup[usb_batch->ep->transfer_type]);
-        batch_setup[usb_batch->ep->transfer_type](uhci_batch, dir);
-
-        return uhci_batch;
+        batch_setup[usb_batch->ep->transfer_type](uhci_batch);
+
+        return EOK;
 }
 
@@ -158 +149 @@
  * is reached.
  */
-bool uhci_transfer_batch_is_complete(const uhci_transfer_batch_t *uhci_batch)
+bool uhci_transfer_batch_check_completed(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
+        usb_transfer_batch_t *batch = &uhci_batch->base;
 
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
-            " checking %zu transfer(s) for completion.\n",
-            uhci_batch->usb_batch,
-            USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
+            " checking %zu transfer(s) for completion.",
+            uhci_batch, USB_TRANSFER_BATCH_ARGS(*batch),
             uhci_batch->td_count);
-        uhci_batch->usb_batch->transfered_size = 0;
+        batch->transferred_size = 0;
+
+        uhci_endpoint_t *uhci_ep = (uhci_endpoint_t *) batch->ep;
 
         for (size_t i = 0;i < uhci_batch->td_count; ++i) {
@@ -175 +167 @@
                 }
 
-                uhci_batch->usb_batch->error = td_status(&uhci_batch->tds[i]);
-                if (uhci_batch->usb_batch->error != EOK) {
-                        assert(uhci_batch->usb_batch->ep != NULL);
+                batch->error = td_status(&uhci_batch->tds[i]);
+                if (batch->error != EOK) {
+                        assert(batch->ep != NULL);
 
                         usb_log_debug("Batch %p found error TD(%zu->%p):%"
-                            PRIx32 ".\n", uhci_batch->usb_batch, i,
+                            PRIx32 ".", uhci_batch, i,
                             &uhci_batch->tds[i], uhci_batch->tds[i].status);
                         td_print_status(&uhci_batch->tds[i]);
 
-                        endpoint_toggle_set(uhci_batch->usb_batch->ep,
-                            td_toggle(&uhci_batch->tds[i]));
-                        if (i > 0)
-                                goto substract_ret;
-                        return true;
+                        uhci_ep->toggle = td_toggle(&uhci_batch->tds[i]);
+                        goto substract_ret;
                 }
 
-                uhci_batch->usb_batch->transfered_size
+                batch->transferred_size
                     += td_act_size(&uhci_batch->tds[i]);
                 if (td_is_short(&uhci_batch->tds[i]))
@@ -197 +186 @@
         }
 substract_ret:
-        uhci_batch->usb_batch->transfered_size
-            -= uhci_batch->usb_batch->setup_size;
+        if (batch->transferred_size > 0 && batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
+                assert(batch->transferred_size >= USB_SETUP_PACKET_SIZE);
+                batch->transferred_size -= USB_SETUP_PACKET_SIZE;
+        }
+
+        assert(batch->transferred_size <= batch->size);
+
         return true;
 }
@@ -216 +210 @@
  * The last transfer is marked with IOC flag.
  */
-static void batch_data(uhci_transfer_batch_t *uhci_batch, usb_direction_t dir)
+static void batch_data(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        assert(uhci_batch->usb_batch->ep);
+
+        usb_direction_t dir = uhci_batch->base.dir;
         assert(dir == USB_DIRECTION_OUT || dir == USB_DIRECTION_IN);
 
@@ -226 +220 @@
         const usb_packet_id pid = direction_pids[dir];
         const bool low_speed =
-            uhci_batch->usb_batch->ep->speed == USB_SPEED_LOW;
-        const size_t mps = uhci_batch->usb_batch->ep->max_packet_size;
-        const usb_target_t target = {{
-            uhci_batch->usb_batch->ep->address,
-            uhci_batch->usb_batch->ep->endpoint }};
-
-        int toggle = endpoint_toggle_get(uhci_batch->usb_batch->ep);
+            uhci_batch->base.ep->device->speed == USB_SPEED_LOW;
+        const size_t mps = uhci_batch->base.ep->max_packet_size;
+
+        uhci_endpoint_t *uhci_ep = (uhci_endpoint_t *) uhci_batch->base.ep;
+
+        int toggle = uhci_ep->toggle;
         assert(toggle == 0 || toggle == 1);
 
         size_t td = 0;
-        size_t remain_size = uhci_batch->usb_batch->buffer_size;
+        size_t remain_size = uhci_batch->base.size;
         char *buffer = uhci_transfer_batch_data_buffer(uhci_batch);
 
@@ -248 +241 @@
                 td_init(
                     &uhci_batch->tds[td], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, target, pid, buffer, next_td);
+                    toggle, false, low_speed, uhci_batch->base.target, pid, buffer, next_td);
 
                 ++td;
@@ -256 +249 @@
         }
         td_set_ioc(&uhci_batch->tds[td - 1]);
-        endpoint_toggle_set(uhci_batch->usb_batch->ep, toggle);
+        uhci_ep->toggle = toggle;
         usb_log_debug2(
-            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.\n", \
-            uhci_batch->usb_batch,
-            usb_str_transfer_type(uhci_batch->usb_batch->ep->transfer_type),
-            usb_str_direction(uhci_batch->usb_batch->ep->direction),
-            USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch));
+            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.", \
+            uhci_batch,
+            usb_str_transfer_type(uhci_batch->base.ep->transfer_type),
+            usb_str_direction(uhci_batch->base.ep->direction),
+            USB_TRANSFER_BATCH_ARGS(uhci_batch->base));
 }
 
@@ -276 +269 @@
  * The last transfer is marked with IOC.
  */
-static void batch_control(uhci_transfer_batch_t *uhci_batch, usb_direction_t dir)
+static void batch_control(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        assert(uhci_batch->usb_batch->ep);
+
+        usb_direction_t dir = uhci_batch->base.dir;
         assert(dir == USB_DIRECTION_OUT || dir == USB_DIRECTION_IN);
         assert(uhci_batch->td_count >= 2);
@@ -291 +284 @@
         const usb_packet_id status_stage_pid = status_stage_pids[dir];
         const bool low_speed =
-            uhci_batch->usb_batch->ep->speed == USB_SPEED_LOW;
-        const size_t mps = uhci_batch->usb_batch->ep->max_packet_size;
-        const usb_target_t target = {{
-            uhci_batch->usb_batch->ep->address,
-            uhci_batch->usb_batch->ep->endpoint }};
+            uhci_batch->base.ep->device->speed == USB_SPEED_LOW;
+        const size_t mps = uhci_batch->base.ep->max_packet_size;
+        const usb_target_t target = uhci_batch->base.target;
 
         /* setup stage */
         td_init(
             &uhci_batch->tds[0], DEFAULT_ERROR_COUNT,
-            uhci_batch->usb_batch->setup_size, 0, false,
+            USB_SETUP_PACKET_SIZE, 0, false,
             low_speed, target, USB_PID_SETUP,
             uhci_transfer_batch_setup_buffer(uhci_batch), &uhci_batch->tds[1]);
@@ -307 +298 @@
         size_t td = 1;
         unsigned toggle = 1;
-        size_t remain_size = uhci_batch->usb_batch->buffer_size;
+        size_t remain_size = uhci_batch->base.size;
         char *buffer = uhci_transfer_batch_data_buffer(uhci_batch);
 
@@ -333 +324 @@
         td_set_ioc(&uhci_batch->tds[td]);
 
-        usb_log_debug2("Control last TD status: %x.\n",
+        usb_log_debug2("Control last TD status: %x.",
             uhci_batch->tds[td].status);
 }
 
-static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t) =
+static void (*const batch_setup[])(uhci_transfer_batch_t*) =
 {
         [USB_TRANSFER_CONTROL] = batch_control,

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -43 +44 @@
 #include <stddef.h>
 #include <usb/host/usb_transfer_batch.h>
+#include <usb/host/endpoint.h>
 
 #include "hw_struct/queue_head.h"
@@ -49 +51 @@
 /** UHCI specific data required for USB transfer */
 typedef struct uhci_transfer_batch {
+        usb_transfer_batch_t base;
+
         /** Queue head
          * This QH is used to maintain UHCI schedule structure and the element
@@ -58 +62 @@
         /** Number of TDs used by the transfer */
         size_t td_count;
-        /** Data buffer, must be accessible by the UHCI hw */
-        void *device_buffer;
-        /** Generic transfer data */
-        usb_transfer_batch_t *usb_batch;
+        /* Setup data */
+        char *setup_buffer;
+        /** Backing TDs + setup_buffer */
+        dma_buffer_t uhci_dma_buffer;
         /** List element */
         link_t link;
 } uhci_transfer_batch_t;
 
-uhci_transfer_batch_t * uhci_transfer_batch_get(usb_transfer_batch_t *batch);
-void uhci_transfer_batch_finish_dispose(uhci_transfer_batch_t *uhci_batch);
-bool uhci_transfer_batch_is_complete(const uhci_transfer_batch_t *uhci_batch);
+uhci_transfer_batch_t *uhci_transfer_batch_create(endpoint_t *);
+int uhci_transfer_batch_prepare(uhci_transfer_batch_t *);
+bool uhci_transfer_batch_check_completed(uhci_transfer_batch_t *);
+void uhci_transfer_batch_destroy(uhci_transfer_batch_t *);
 
 /** Get offset to setup buffer accessible to the HC hw.
@@ -74 +79 @@
  * @return Pointer to the setup buffer.
  */
-static inline void * uhci_transfer_batch_setup_buffer(
+static inline void *uhci_transfer_batch_setup_buffer(
     const uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->device_buffer);
-        return uhci_batch->device_buffer + sizeof(qh_t) +
+        return uhci_batch->uhci_dma_buffer.virt + sizeof(qh_t) +
             uhci_batch->td_count * sizeof(td_t);
 }
@@ -87 +91 @@
  * @return Pointer to the data buffer.
  */
-static inline void * uhci_transfer_batch_data_buffer(
+static inline void *uhci_transfer_batch_data_buffer(
     const uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        return uhci_transfer_batch_setup_buffer(uhci_batch) +
-            uhci_batch->usb_batch->setup_size;
-}
-
-/** Aborts the batch.
- * Sets error to EINTR and size off transferd data to 0, before finishing the
- * batch.
- * @param uhci_batch Batch to abort.
- */
-static inline void uhci_transfer_batch_abort(uhci_transfer_batch_t *uhci_batch)
-{
-        assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        uhci_batch->usb_batch->error = EINTR;
-        uhci_batch->usb_batch->transfered_size = 0;
-        uhci_transfer_batch_finish_dispose(uhci_batch);
+        return uhci_batch->base.dma_buffer.virt;
 }
 
@@ -120 +108 @@
 }
 
+static inline uhci_transfer_batch_t *uhci_transfer_batch_get(
+    usb_transfer_batch_t *b)
+{
+        assert(b);
+        return (uhci_transfer_batch_t *) b;
+}
+
 #endif
 

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2013 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -39 +40 @@
 #include <usb/classes/hub.h>
 #include <usb/request.h>
+#include <usb/host/endpoint.h>
 #include <usb/usb.h>
 
@@ -103 +105 @@
         assert(batch);
 
-        const usb_target_t target = {{
-                .address = batch->ep->address,
-                .endpoint = batch->ep->endpoint
-        }};
         do {
-                batch->error = virthub_base_request(&instance->base, target,
-                    usb_transfer_batch_direction(batch), (void*)batch->setup_buffer,
-                    batch->buffer, batch->buffer_size, &batch->transfered_size);
+                batch->error = virthub_base_request(&instance->base, batch->target,
+                    batch->dir, (void*) batch->setup.buffer,
+                    batch->dma_buffer.virt, batch->size, &batch->transferred_size);
                 if (batch->error == ENAK)
                         async_usleep(instance->base.endpoint_descriptor.poll_interval * 1000);
@@ -116 +114 @@
                 //ENAK is technically an error condition
         } while (batch->error == ENAK);
-        usb_transfer_batch_finish(batch, NULL);
-        usb_transfer_batch_destroy(batch);
+        usb_transfer_batch_finish(batch);
         return EOK;
 }
@@ -206 +203 @@
         data[0] = ((value & STATUS_LINE_D_MINUS) ? 1 : 0)
             | ((value & STATUS_LINE_D_PLUS) ? 2 : 0);
-        RH_DEBUG(hub, port, "Bus state %" PRIx8 "(source %" PRIx16")\n",
+        RH_DEBUG(hub, port, "Bus state %" PRIx8 "(source %" PRIx16")",
             data[0], value);
         *act_size = 1;
@@ -214 +211 @@
 #define BIT_VAL(val, bit) \
         ((val & bit) ? 1 : 0)
-#define UHCI2USB(val, bit, feat) \
-        (BIT_VAL(val, bit) << feat)
+#define UHCI2USB(val, bit, mask) \
+        (BIT_VAL(val, bit) ? (mask) : 0)
 
 /** Port status request handler.
@@ -240 +237 @@
         const uint16_t val = pio_read_16(hub->ports[port]);
         const uint32_t status = uint32_host2usb(
-            UHCI2USB(val, STATUS_CONNECTED, USB_HUB_FEATURE_PORT_CONNECTION) |
-            UHCI2USB(val, STATUS_ENABLED, USB_HUB_FEATURE_PORT_ENABLE) |
-            UHCI2USB(val, STATUS_SUSPEND, USB_HUB_FEATURE_PORT_SUSPEND) |
-            UHCI2USB(val, STATUS_IN_RESET, USB_HUB_FEATURE_PORT_RESET) |
-            UHCI2USB(val, STATUS_ALWAYS_ONE, USB_HUB_FEATURE_PORT_POWER) |
-            UHCI2USB(val, STATUS_LOW_SPEED, USB_HUB_FEATURE_PORT_LOW_SPEED) |
-            UHCI2USB(val, STATUS_CONNECTED_CHANGED, USB_HUB_FEATURE_C_PORT_CONNECTION) |
-            UHCI2USB(val, STATUS_ENABLED_CHANGED, USB_HUB_FEATURE_C_PORT_ENABLE) |
-//          UHCI2USB(val, STATUS_SUSPEND, USB_HUB_FEATURE_C_PORT_SUSPEND) |
-            ((hub->reset_changed[port] ? 1 : 0) << USB_HUB_FEATURE_C_PORT_RESET)
+            UHCI2USB(val, STATUS_CONNECTED, USB_HUB_PORT_STATUS_CONNECTION) |
+            UHCI2USB(val, STATUS_ENABLED, USB_HUB_PORT_STATUS_ENABLE) |
+            UHCI2USB(val, STATUS_SUSPEND, USB2_HUB_PORT_STATUS_SUSPEND) |
+            UHCI2USB(val, STATUS_IN_RESET, USB_HUB_PORT_STATUS_RESET) |
+            UHCI2USB(val, STATUS_ALWAYS_ONE, USB2_HUB_PORT_STATUS_POWER) |
+            UHCI2USB(val, STATUS_LOW_SPEED, USB2_HUB_PORT_STATUS_LOW_SPEED) |
+            UHCI2USB(val, STATUS_CONNECTED_CHANGED, USB_HUB_PORT_STATUS_C_CONNECTION) |
+            UHCI2USB(val, STATUS_ENABLED_CHANGED, USB2_HUB_PORT_STATUS_C_ENABLE) |
+//          UHCI2USB(val, STATUS_SUSPEND, USB2_HUB_PORT_STATUS_C_SUSPEND) |
+            (hub->reset_changed[port] ?  USB_HUB_PORT_STATUS_C_RESET : 0)
         );
         RH_DEBUG(hub, port, "Port status %" PRIx32 " (source %" PRIx16
-            "%s)\n", uint32_usb2host(status), val,
+            "%s)", uint32_usb2host(status), val,
             hub->reset_changed[port] ? "-reset" : "");
         memcpy(data, &status, sizeof(status));
@@ -278 +275 @@
         const uint16_t val = status & (~STATUS_WC_BITS);
         switch (feature) {
-        case USB_HUB_FEATURE_PORT_ENABLE:
+        case USB2_HUB_FEATURE_PORT_ENABLE:
                 RH_DEBUG(hub, port, "Clear port enable (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], val & ~STATUS_ENABLED);
                 break;
-        case USB_HUB_FEATURE_PORT_SUSPEND:
+        case USB2_HUB_FEATURE_PORT_SUSPEND:
                 RH_DEBUG(hub, port, "Clear port suspend (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], val & ~STATUS_SUSPEND);
                 // TODO we should do resume magic
-                usb_log_warning("Resume is not implemented on port %u\n", port);
+                usb_log_warning("Resume is not implemented on port %u", port);
                 break;
         case USB_HUB_FEATURE_PORT_POWER:
-                RH_DEBUG(hub, port, "Clear port power (status %" PRIx16 ")\n",
+                RH_DEBUG(hub, port, "Clear port power (status %" PRIx16 ")",
                     status);
                 /* We are always powered */
-                usb_log_warning("Tried to power off port %u\n", port);
+                usb_log_warning("Tried to power off port %u", port);
                 break;
         case USB_HUB_FEATURE_C_PORT_CONNECTION:
                 RH_DEBUG(hub, port, "Clear port conn change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], val | STATUS_CONNECTED_CHANGED);
                 break;
         case USB_HUB_FEATURE_C_PORT_RESET:
                 RH_DEBUG(hub, port, "Clear port reset change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 hub->reset_changed[port] = false;
                 break;
-        case USB_HUB_FEATURE_C_PORT_ENABLE:
+        case USB2_HUB_FEATURE_C_PORT_ENABLE:
                 RH_DEBUG(hub, port, "Clear port enable change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], status | STATUS_ENABLED_CHANGED);
                 break;
-        case USB_HUB_FEATURE_C_PORT_SUSPEND:
+        case USB2_HUB_FEATURE_C_PORT_SUSPEND:
                 RH_DEBUG(hub, port, "Clear port suspend change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 //TODO
                 return ENOTSUP;
         case USB_HUB_FEATURE_C_PORT_OVER_CURRENT:
                 RH_DEBUG(hub, port, "Clear port OC change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 /* UHCI Does not report over current */
                 //TODO: newer chips do, but some have broken wiring
@@ -324 +321 @@
         default:
                 RH_DEBUG(hub, port, "Clear unknown feature %d (status %"
-                    PRIx16 ")\n", feature, status);
-                usb_log_warning("Clearing feature %d is unsupported\n",
+                    PRIx16 ")", feature, status);
+                usb_log_warning("Clearing feature %d is unsupported",
                     feature);
                 return ESTALL;
@@ -352 +349 @@
         case USB_HUB_FEATURE_PORT_RESET:
                 RH_DEBUG(hub, port, "Set port reset before (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 uhci_port_reset_enable(hub->ports[port]);
                 hub->reset_changed[port] = true;
                 RH_DEBUG(hub, port, "Set port reset after (status %" PRIx16
-                    ")\n", pio_read_16(hub->ports[port]));
-                break;
-        case USB_HUB_FEATURE_PORT_SUSPEND:
+                    ")", pio_read_16(hub->ports[port]));
+                break;
+        case USB2_HUB_FEATURE_PORT_SUSPEND:
                 RH_DEBUG(hub, port, "Set port suspend (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 pio_write_16(hub->ports[port],
                     (status & ~STATUS_WC_BITS) | STATUS_SUSPEND);
-                usb_log_warning("Suspend is not implemented on port %u\n", port);
+                usb_log_warning("Suspend is not implemented on port %u", port);
                 break;
         case USB_HUB_FEATURE_PORT_POWER:
                 RH_DEBUG(hub, port, "Set port power (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 /* We are always powered */
-                usb_log_warning("Tried to power port %u\n", port);
+                usb_log_warning("Tried to power port %u", port);
                 break;
         case USB_HUB_FEATURE_C_PORT_CONNECTION:
-        case USB_HUB_FEATURE_C_PORT_ENABLE:
-        case USB_HUB_FEATURE_C_PORT_SUSPEND:
+        case USB2_HUB_FEATURE_C_PORT_ENABLE:
+        case USB2_HUB_FEATURE_C_PORT_SUSPEND:
         case USB_HUB_FEATURE_C_PORT_OVER_CURRENT:
                 RH_DEBUG(hub, port, "Set port change flag (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 /* These are voluntary and don't have to be set
                  * there is no way we could do it on UHCI anyway */
@@ -382 +379 @@
         default:
                 RH_DEBUG(hub, port, "Set unknown feature %d (status %" PRIx16
-                    ")\n", feature, status);
-                usb_log_warning("Setting feature %d is unsupported\n",
+                    ")", feature, status);
+                usb_log_warning("Setting feature %d is unsupported",
                     feature);
                 return ESTALL;
@@ -422 +419 @@
                 RH_DEBUG(hub, -1, "Event mask %" PRIx8
                     " (status_a %" PRIx16 "%s),"
-                    " (status_b %" PRIx16 "%s)\n", status,
+                    " (status_b %" PRIx16 "%s)", status,
                     status_a, hub->reset_changed[0] ? "-reset" : "",
                     status_b, hub->reset_changed[1] ? "-reset" : "" );