Changes in uspace/drv/bus/usb/ehci/hc.c [ddbd088:68e5406] 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/utility.h>
+#include <usb/host/utils/malloc32.h>
 
 #include "ehci_batch.h"
@@ -89 +89 @@
 };
 
+static void hc_start(hc_t *instance);
 static int hc_init_memory(hc_t *instance);
 
@@ -95 +96 @@
  * @param[in] hw_res Device's resources.
  *
+ * @param[out] irq
+ *
  * @return Error code.
  */
-int hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
+int ehci_hc_gen_irq_code(irq_code_t *code, 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)
@@ -128 +130 @@
 
         memcpy(code->cmds, ehci_irq_commands, sizeof(ehci_irq_commands));
+        ehci_caps_regs_t *caps = NULL;
+
+        int 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(instance->caps->caplength));
+            (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(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.",
+        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
             RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
 
-        return hw_res->irqs.irqs[0];
+        *irq = hw_res->irqs.irqs[0];
+        return EOK;
 }
 
@@ -148 +159 @@
  * @return Error code
  */
-int hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
-{
-        hc_t *instance = hcd_to_hc(hcd);
+int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res, bool interrupts)
+{
+        assert(instance);
         assert(hw_res);
         if (hw_res->mem_ranges.count != 1 ||
@@ -161 +172 @@
         if (ret != EOK) {
                 usb_log_error("HC(%p): Failed to gain access to device "
-                    "registers: %s.", instance, str_error(ret));
+                    "registers: %s.\n", 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,
@@ -174 +184 @@
             + EHCI_RD8(instance->caps->caplength));
 
-        list_initialize(&instance->pending_endpoints);
+        list_initialize(&instance->pending_batches);
         fibril_mutex_initialize(&instance->guard);
         fibril_condvar_initialize(&instance->async_doorbell);
@@ -187 +197 @@
         usb_log_info("HC(%p): Initializing RH(%p).", instance, &instance->rh);
         ehci_rh_init(
-            &instance->rh, instance->caps, instance->registers, &instance->guard,
-            "ehci rh");
-
-        ehci_bus_init(&instance->bus, instance);
-        hc_device_setup(hcd, (bus_t *) &instance->bus);
+            &instance->rh, instance->caps, instance->registers, "ehci rh");
+        usb_log_debug("HC(%p): Starting HW.", instance);
+        hc_start(instance);
+
         return EOK;
 }
@@ -199 +208 @@
  * @param[in] instance Host controller structure to use.
  */
-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;
+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
 };
 
@@ -213 +224 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)", instance,
-            ep->device->address, ep->endpoint,
+        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)\n", instance,
+            ep->address, ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -237 +248 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)", instance,
-            ep->device->address, ep->endpoint,
+        usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)\n", instance,
+            ep->address, ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -262 +273 @@
 }
 
-int ehci_hc_status(bus_t *bus_base, uint32_t *status)
-{
-        assert(bus_base);
+int ehci_hc_status(hcd_t *hcd, uint32_t *status)
+{
+        assert(hcd);
+        hc_t *instance = hcd_get_driver_data(hcd);
+        assert(instance);
         assert(status);
-
-        ehci_bus_t *bus = (ehci_bus_t *) bus_base;
-        hc_t *hc = bus->hc;
-        assert(hc);
-
         *status = 0;
-        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);
+        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);
         return EOK;
 }
@@ -286 +294 @@
  * @return Error code.
  */
-int 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);
+int ehci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
+{
+        assert(hcd);
+        hc_t *instance = hcd_get_driver_data(hcd);
+        assert(instance);
 
         /* Check for root hub communication */
-        if (batch->target.address == ehci_rh_get_address(&hc->rh)) {
+        if (batch->ep->address == ehci_rh_get_address(&instance->rh)) {
                 usb_log_debug("HC(%p): Scheduling BATCH(%p) for RH(%p)",
-                    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);
+                    instance, batch, &instance->rh);
+                return ehci_rh_schedule(&instance->rh, batch);
+        }
         ehci_transfer_batch_t *ehci_batch = ehci_transfer_batch_get(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);
+        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);
         ehci_transfer_batch_commit(ehci_batch);
 
-        /* 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);
+        fibril_mutex_unlock(&instance->guard);
         return EOK;
 }
@@ -333 +325 @@
  * @param[in] status Value of the status register at the time of interrupt.
  */
-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);
+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);
         if (status & USB_STS_PORT_CHANGE_FLAG) {
-                ehci_rh_interrupt(&hc->rh);
+                ehci_rh_interrupt(&instance->rh);
         }
 
         if (status & USB_STS_IRQ_ASYNC_ADVANCE_FLAG) {
-                fibril_mutex_lock(&hc->guard);
-                usb_log_debug2("HC(%p): Signaling doorbell", hc);
-                fibril_condvar_broadcast(&hc->async_doorbell);
-                fibril_mutex_unlock(&hc->guard);
+                fibril_mutex_lock(&instance->guard);
+                usb_log_debug2("HC(%p): Signaling doorbell", instance);
+                fibril_condvar_broadcast(&instance->async_doorbell);
+                fibril_mutex_unlock(&instance->guard);
         }
 
         if (status & (USB_STS_IRQ_FLAG | USB_STS_ERR_IRQ_FLAG)) {
-                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);
+                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)) {
                                 list_remove(current);
-                                hc_reset_toggles(&batch->base, &ehci_ep_toggle_reset);
-                                usb_transfer_batch_finish(&batch->base);
+                                ehci_transfer_batch_finish_dispose(batch);
                         }
                 }
-                fibril_mutex_unlock(&hc->guard);
-
-
+                fibril_mutex_unlock(&instance->guard);
         }
 
         if (status & USB_STS_HOST_ERROR_FLAG) {
-                usb_log_fatal("HCD(%p): HOST SYSTEM ERROR!", hc);
+                usb_log_fatal("HCD(%p): HOST SYSTEM ERROR!", instance);
                 //TODO do something here
         }
@@ -388 +371 @@
  * @param[in] instance EHCI hc driver structure.
  */
-int hc_start(hc_device_t *hcd)
-{
-        hc_t *instance = hcd_to_hc(hcd);
-        usb_log_debug("HC(%p): Starting HW.", instance);
-
+void hc_start(hc_t *instance)
+{
+        assert(instance);
         /* Turn off the HC if it's running, Reseting a running device is
          * undefined */
@@ -423 +404 @@
 
         /* Enable periodic list */
-        assert(instance->periodic_list);
+        assert(instance->periodic_list_base);
         uintptr_t phys_base =
-            addr_to_phys((void*)instance->periodic_list);
+            addr_to_phys((void*)instance->periodic_list_base);
         assert((phys_base & USB_PERIODIC_LIST_BASE_MASK) == phys_base);
         EHCI_WR(instance->registers->periodiclistbase, phys_base);
@@ -444 +425 @@
         usb_log_debug("HC(%p): HW started.", instance);
 
-        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).",
+        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",
             instance,
             &instance->registers->usbcmd, EHCI_RD(instance->registers->usbcmd),
@@ -457 +438 @@
         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);
 }
 
@@ -502 +473 @@
 
         /* Take 1024 periodic list heads, we ignore low mem options */
-        if (dma_buffer_alloc(&instance->dma_buffer, PAGE_SIZE)) {
+        instance->periodic_list_base = get_page();
+        if (!instance->periodic_list_base) {
                 usb_log_error("HC(%p): Failed to get ISO schedule page.",
                     instance);
@@ -509 +481 @@
                 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(link_pointer_t); ++i)
+        for (unsigned i = 0;
+            i < PAGE_SIZE/sizeof(instance->periodic_list_base[0]); ++i)
         {
                 /* Disable everything for now */
-                instance->periodic_list[i] =
+                instance->periodic_list_base[i] =
                     LINK_POINTER_QH(addr_to_phys(instance->int_list.list_head));
         }