Changes in uspace/drv/bus/usb/ehci/hc.c [b7fd2a0:5a6cc679] in mainline

File:

• uspace/drv/bus/usb/ehci/hc.c (modified) (20 diffs)

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

@@ -45 +45 @@
 #include <usb/debug.h>
 #include <usb/usb.h>
-#include <usb/host/utils/malloc32.h>
+#include <usb/host/utility.h>
 
 #include "ehci_batch.h"
@@ -89 +89 @@
 };
 
-static void hc_start(hc_t *instance);
 static errno_t hc_init_memory(hc_t *instance);
 
@@ -100 +99 @@
  * @return Error code.
  */
-errno_t ehci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res, int *irq)
+errno_t hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
 {
         assert(code);
         assert(hw_res);
+        hc_t *instance = hcd_to_hc(hcd);
 
         if (hw_res->irqs.count != 1 || hw_res->mem_ranges.count != 1)
@@ -130 +130 @@
 
         memcpy(code->cmds, ehci_irq_commands, sizeof(ehci_irq_commands));
-        ehci_caps_regs_t *caps = NULL;
-
-        errno_t ret = pio_enable_range(&regs, (void**)&caps);
-        if (ret != EOK) {
-                free(code->ranges);
-                free(code->cmds);
-                return ret;
-        }
 
         ehci_regs_t *registers =
-            (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(caps->caplength));
+                (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(instance->caps->caplength));
         code->cmds[0].addr = (void *) &registers->usbsts;
         code->cmds[3].addr = (void *) &registers->usbsts;
         EHCI_WR(code->cmds[1].value, EHCI_USED_INTERRUPTS);
 
-        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
+        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.",
             RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
 
@@ -159 +151 @@
  * @return Error code
  */
-errno_t hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res, bool interrupts)
-{
-        assert(instance);
+errno_t hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+{
+        hc_t *instance = hcd_to_hc(hcd);
         assert(hw_res);
         if (hw_res->mem_ranges.count != 1 ||
@@ -172 +164 @@
         if (ret != EOK) {
                 usb_log_error("HC(%p): Failed to gain access to device "
-                    "registers: %s.\n", instance, str_error(ret));
+                    "registers: %s.", instance, str_error(ret));
                 return ret;
         }
+
         usb_log_info("HC(%p): Device registers at %"PRIx64" (%zuB) accessible.",
             instance, hw_res->mem_ranges.ranges[0].address.absolute,
@@ -184 +177 @@
             + EHCI_RD8(instance->caps->caplength));
 
-        list_initialize(&instance->pending_batches);
+        list_initialize(&instance->pending_endpoints);
         fibril_mutex_initialize(&instance->guard);
         fibril_condvar_initialize(&instance->async_doorbell);
@@ -197 +190 @@
         usb_log_info("HC(%p): Initializing RH(%p).", instance, &instance->rh);
         ehci_rh_init(
-            &instance->rh, instance->caps, instance->registers, "ehci rh");
-        usb_log_debug("HC(%p): Starting HW.", instance);
-        hc_start(instance);
-
+            &instance->rh, instance->caps, instance->registers, &instance->guard,
+            "ehci rh");
+
+        ehci_bus_init(&instance->bus, instance);
+        hc_device_setup(hcd, (bus_t *) &instance->bus);
         return EOK;
 }
@@ -208 +202 @@
  * @param[in] instance Host controller structure to use.
  */
-void hc_fini(hc_t *instance)
-{
-        assert(instance);
-        //TODO: stop the hw
-#if 0
-        endpoint_list_fini(&instance->async_list);
-        endpoint_list_fini(&instance->int_list);
-        return_page(instance->periodic_list_base);
-#endif
+int hc_gone(hc_device_t *hcd)
+{
+        hc_t *hc = hcd_to_hc(hcd);
+        endpoint_list_fini(&hc->async_list);
+        endpoint_list_fini(&hc->int_list);
+        dma_buffer_free(&hc->dma_buffer);
+        return EOK;
 };
 
@@ -224 +216 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)\n", instance,
-            ep->address, ep->endpoint,
+        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)", instance,
+            ep->device->address, ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -248 +240 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)\n", instance,
-            ep->address, ep->endpoint,
+        usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)", instance,
+            ep->device->address, ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -273 +265 @@
 }
 
-errno_t ehci_hc_status(hcd_t *hcd, uint32_t *status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+errno_t ehci_hc_status(bus_t *bus_base, uint32_t *status)
+{
+        assert(bus_base);
         assert(status);
+
+        ehci_bus_t *bus = (ehci_bus_t *) bus_base;
+        hc_t *hc = bus->hc;
+        assert(hc);
+
         *status = 0;
-        if (instance->registers) {
-                *status = EHCI_RD(instance->registers->usbsts);
-                EHCI_WR(instance->registers->usbsts, *status);
-        }
-        usb_log_debug2("HC(%p): Read status: %x", instance, *status);
+        if (hc->registers) {
+                *status = EHCI_RD(hc->registers->usbsts);
+                EHCI_WR(hc->registers->usbsts, *status);
+        }
+        usb_log_debug2("HC(%p): Read status: %x", hc, *status);
         return EOK;
 }
@@ -294 +289 @@
  * @return Error code.
  */
-errno_t ehci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        assert(instance);
+errno_t ehci_hc_schedule(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+
+        ehci_bus_t *bus = (ehci_bus_t *) endpoint_get_bus(batch->ep);
+        hc_t *hc = bus->hc;
+        assert(hc);
 
         /* Check for root hub communication */
-        if (batch->ep->address == ehci_rh_get_address(&instance->rh)) {
+        if (batch->target.address == ehci_rh_get_address(&hc->rh)) {
                 usb_log_debug("HC(%p): Scheduling BATCH(%p) for RH(%p)",
-                    instance, batch, &instance->rh);
-                return ehci_rh_schedule(&instance->rh, batch);
-        }
+                    hc, batch, &hc->rh);
+                return ehci_rh_schedule(&hc->rh, batch);
+        }
+
+        endpoint_t * const ep = batch->ep;
+        ehci_endpoint_t * const ehci_ep = ehci_endpoint_get(ep);
         ehci_transfer_batch_t *ehci_batch = ehci_transfer_batch_get(batch);
-        if (!ehci_batch)
-                return ENOMEM;
-
-        fibril_mutex_lock(&instance->guard);
-        usb_log_debug2("HC(%p): Appending BATCH(%p)", instance, batch);
-        list_append(&ehci_batch->link, &instance->pending_batches);
-        usb_log_debug("HC(%p): Committing BATCH(%p)", instance, batch);
+
+        int err;
+
+        if ((err = ehci_transfer_batch_prepare(ehci_batch)))
+                return err;
+
+        fibril_mutex_lock(&hc->guard);
+
+        if ((err = endpoint_activate_locked(ep, batch))) {
+                fibril_mutex_unlock(&hc->guard);
+                return err;
+        }
+
+        usb_log_debug("HC(%p): Committing BATCH(%p)", hc, batch);
         ehci_transfer_batch_commit(ehci_batch);
 
-        fibril_mutex_unlock(&instance->guard);
+        /* Enqueue endpoint to the checked list */
+        usb_log_debug2("HC(%p): Appending BATCH(%p)", hc, batch);
+        list_append(&ehci_ep->pending_link, &hc->pending_endpoints);
+
+        fibril_mutex_unlock(&hc->guard);
         return EOK;
 }
@@ -325 +336 @@
  * @param[in] status Value of the status register at the time of interrupt.
  */
-void ehci_hc_interrupt(hcd_t *hcd, uint32_t status)
-{
-        assert(hcd);
-        hc_t *instance = hcd_get_driver_data(hcd);
-        status = EHCI_RD(status);
-        assert(instance);
-
-        usb_log_debug2("HC(%p): Interrupt: %"PRIx32, instance, status);
+void ehci_hc_interrupt(bus_t *bus_base, uint32_t status)
+{
+        assert(bus_base);
+
+        ehci_bus_t *bus = (ehci_bus_t *) bus_base;
+        hc_t *hc = bus->hc;
+        assert(hc);
+
+        usb_log_debug2("HC(%p): Interrupt: %"PRIx32, hc, status);
         if (status & USB_STS_PORT_CHANGE_FLAG) {
-                ehci_rh_interrupt(&instance->rh);
+                ehci_rh_interrupt(&hc->rh);
         }
 
         if (status & USB_STS_IRQ_ASYNC_ADVANCE_FLAG) {
-                fibril_mutex_lock(&instance->guard);
-                usb_log_debug2("HC(%p): Signaling doorbell", instance);
-                fibril_condvar_broadcast(&instance->async_doorbell);
-                fibril_mutex_unlock(&instance->guard);
+                fibril_mutex_lock(&hc->guard);
+                usb_log_debug2("HC(%p): Signaling doorbell", hc);
+                fibril_condvar_broadcast(&hc->async_doorbell);
+                fibril_mutex_unlock(&hc->guard);
         }
 
         if (status & (USB_STS_IRQ_FLAG | USB_STS_ERR_IRQ_FLAG)) {
-                fibril_mutex_lock(&instance->guard);
-
-                usb_log_debug2("HC(%p): Scanning %lu pending batches", instance,
-                        list_count(&instance->pending_batches));
-                list_foreach_safe(instance->pending_batches, current, next) {
-                        ehci_transfer_batch_t *batch =
-                            ehci_transfer_batch_from_link(current);
-
-                        if (ehci_transfer_batch_is_complete(batch)) {
+                fibril_mutex_lock(&hc->guard);
+
+                usb_log_debug2("HC(%p): Scanning %lu pending endpoints", hc,
+                        list_count(&hc->pending_endpoints));
+                list_foreach_safe(hc->pending_endpoints, current, next) {
+                        ehci_endpoint_t *ep
+                                = list_get_instance(current, ehci_endpoint_t, pending_link);
+
+                        ehci_transfer_batch_t *batch
+                                = ehci_transfer_batch_get(ep->base.active_batch);
+                        assert(batch);
+
+                        if (ehci_transfer_batch_check_completed(batch)) {
+                                endpoint_deactivate_locked(&ep->base);
                                 list_remove(current);
-                                ehci_transfer_batch_finish_dispose(batch);
+                                hc_reset_toggles(&batch->base, &ehci_ep_toggle_reset);
+                                usb_transfer_batch_finish(&batch->base);
                         }
                 }
-                fibril_mutex_unlock(&instance->guard);
+                fibril_mutex_unlock(&hc->guard);
+
+
         }
 
         if (status & USB_STS_HOST_ERROR_FLAG) {
-                usb_log_fatal("HCD(%p): HOST SYSTEM ERROR!", instance);
+                usb_log_fatal("HCD(%p): HOST SYSTEM ERROR!", hc);
                 //TODO do something here
         }
@@ -371 +391 @@
  * @param[in] instance EHCI hc driver structure.
  */
-void hc_start(hc_t *instance)
-{
-        assert(instance);
+int hc_start(hc_device_t *hcd)
+{
+        hc_t *instance = hcd_to_hc(hcd);
+        usb_log_debug("HC(%p): Starting HW.", instance);
+
         /* Turn off the HC if it's running, Reseting a running device is
          * undefined */
@@ -404 +426 @@
 
         /* Enable periodic list */
-        assert(instance->periodic_list_base);
+        assert(instance->periodic_list);
         uintptr_t phys_base =
-            addr_to_phys((void*)instance->periodic_list_base);
+            addr_to_phys((void*)instance->periodic_list);
         assert((phys_base & USB_PERIODIC_LIST_BASE_MASK) == phys_base);
         EHCI_WR(instance->registers->periodiclistbase, phys_base);
@@ -425 +447 @@
         usb_log_debug("HC(%p): HW started.", instance);
 
-        usb_log_debug2("HC(%p): Registers: \n"
-            "\tUSBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)\n"
-            "\tUSBSTS(%p): %x(0x00001000 = HC halted)\n"
-            "\tUSBINT(%p): %x(0x0 = no interrupts).\n"
-            "\tCONFIG(%p): %x(0x0 = ports controlled by companion hc).\n",
+        usb_log_debug2("HC(%p): Registers: "
+            "\tUSBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)"
+            "\tUSBSTS(%p): %x(0x00001000 = HC halted)"
+            "\tUSBINT(%p): %x(0x0 = no interrupts)."
+            "\tCONFIG(%p): %x(0x0 = ports controlled by companion hc).",
             instance,
             &instance->registers->usbcmd, EHCI_RD(instance->registers->usbcmd),
@@ -438 +460 @@
         EHCI_WR(instance->registers->usbsts, EHCI_RD(instance->registers->usbsts));
         EHCI_WR(instance->registers->usbintr, EHCI_USED_INTERRUPTS);
+
+        return EOK;
+}
+
+/**
+ * Setup roothub as a virtual hub.
+ */
+int hc_setup_roothub(hc_device_t *hcd)
+{
+        return hc_setup_virtual_root_hub(hcd, USB_SPEED_HIGH);
 }
 
@@ -473 +505 @@
 
         /* Take 1024 periodic list heads, we ignore low mem options */
-        instance->periodic_list_base = get_page();
-        if (!instance->periodic_list_base) {
+        if (dma_buffer_alloc(&instance->dma_buffer, PAGE_SIZE)) {
                 usb_log_error("HC(%p): Failed to get ISO schedule page.",
                     instance);
@@ -481 +512 @@
                 return ENOMEM;
         }
+        instance->periodic_list = instance->dma_buffer.virt;
 
         usb_log_debug2("HC(%p): Initializing Periodic list.", instance);
-        for (unsigned i = 0;
-            i < PAGE_SIZE/sizeof(instance->periodic_list_base[0]); ++i)
+        for (unsigned i = 0; i < PAGE_SIZE/sizeof(link_pointer_t); ++i)
         {
                 /* Disable everything for now */
-                instance->periodic_list_base[i] =
+                instance->periodic_list[i] =
                     LINK_POINTER_QH(addr_to_phys(instance->int_list.list_head));
         }