Changeset e4d7363 in mainline for uspace/drv/bus/usb/ehci

Timestamp:

2017-06-22T21:34:39Z (9 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

91ca111

Parents:

cb89430

Message:

usbhost: refactor the initialization

Before that, drivers had to setup MMIO range multiple times, or even parse hw
resources themselves again. The former init method was split in half - init and
start. Init shall allocate and initialize inner structures, start shall start
the HC.

In the XHCI it is demonstrated how to isolate inner HC implementation from the
fact this driver is using libusbhost. It adds some boilerplate code, but
I think it leads to cleaner design.

Location:

uspace/drv/bus/usb/ehci

Files:

• hc.c (modified) (8 diffs)
• hc.h (modified) (2 diffs)
• main.c (modified) (4 diffs)
• res.c (modified) (4 diffs)
• res.h (modified) (1 diff)

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

@@ -89 +89 @@
 };
 
-static void hc_start(hc_t *instance);
 static int hc_init_memory(hc_t *instance);
 
@@ -98 +97 @@
  * @return Error code.
  */
-int ehci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res)
+int ehci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
 {
         assert(code);
         assert(hw_res);
+
+        hc_t *instance = hcd_get_driver_data(hcd);
 
         if (hw_res->irqs.count != 1 || hw_res->mem_ranges.count != 1)
@@ -128 +129 @@
 
         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(caps->caplength));
-        code->cmds[0].addr = (void *) &registers->usbsts;
-        code->cmds[3].addr = (void *) &registers->usbsts;
+
+        code->cmds[0].addr = (void *) &instance->registers->usbsts;
+        code->cmds[3].addr = (void *) &instance->registers->usbsts;
         EHCI_WR(code->cmds[1].value, EHCI_USED_INTERRUPTS);
 
@@ -156 +147 @@
  * @return Error code
  */
-int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res, bool interrupts)
+int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res)
 {
         assert(instance);
@@ -172 +163 @@
                 return ret;
         }
+
         usb_log_info("HC(%p): Device registers at %"PRIx64" (%zuB) accessible.",
             instance, hw_res->mem_ranges.ranges[0].address.absolute,
@@ -195 +187 @@
         ehci_rh_init(
             &instance->rh, instance->caps, instance->registers, "ehci rh");
-        usb_log_debug("HC(%p): Starting HW.", instance);
-        hc_start(instance);
 
         return EOK;
@@ -368 +358 @@
  * @param[in] instance EHCI hc driver structure.
  */
-void hc_start(hc_t *instance)
-{
-        assert(instance);
+int hc_start(hc_t *instance, bool interrupts)
+{
+        assert(instance);
+        usb_log_debug("HC(%p): Starting HW.", instance);
+
         /* Turn off the HC if it's running, Reseting a running device is
          * undefined */
@@ -435 +427 @@
         EHCI_WR(instance->registers->usbsts, EHCI_RD(instance->registers->usbsts));
         EHCI_WR(instance->registers->usbintr, EHCI_USED_INTERRUPTS);
+
+        return EOK;
 }
 

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

@@ -82 +82 @@
 } hc_t;
 
-int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res, bool interrupts);
+int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res);
+int hc_start(hc_t *instance, bool interrupts);
 void hc_fini(hc_t *instance);
 
@@ -88 +89 @@
 void hc_dequeue_endpoint(hc_t *instance, const endpoint_t *ep);
 
-int ehci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res);
+int ehci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res);
 
 void ehci_hc_interrupt(hcd_t *hcd, uint32_t status);

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

@@ -52 +52 @@
 #define NAME "ehci"
 
-static int ehci_driver_init(hcd_t *, const hw_res_list_parsed_t *, bool);
+static int ehci_driver_init(hcd_t *, const hw_res_list_parsed_t *);
+static int ehci_driver_claim(hcd_t *, ddf_dev_t *);
+static int ehci_driver_start(hcd_t *, bool);
 static void ehci_driver_fini(hcd_t *);
 
 static const ddf_hc_driver_t ehci_hc_driver = {
-        .claim = disable_legacy,
         .hc_speed = USB_SPEED_HIGH,
+        .name = "EHCI-PCI",
+        .init = ehci_driver_init,
         .irq_code_gen = ehci_hc_gen_irq_code,
-        .init = ehci_driver_init,
+        .claim = ehci_driver_claim,
+        .start = ehci_driver_start,
         .fini = ehci_driver_fini,
-        .name = "EHCI-PCI",
         .ops = {
                 .schedule       = ehci_hc_schedule,
@@ -72 +75 @@
 
 
-static int ehci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res,
-    bool irq)
+static int ehci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res)
 {
         assert(hcd);
@@ -82 +84 @@
                 return ENOMEM;
 
-        const int ret = hc_init(instance, res, irq);
+        const int ret = hc_init(instance, res);
         if (ret == EOK) {
                 hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops);
@@ -89 +91 @@
         }
         return ret;
+}
+
+static int ehci_driver_claim(hcd_t *hcd, ddf_dev_t *dev)
+{
+        hc_t *instance = hcd_get_driver_data(hcd);
+        assert(instance);
+
+        return disable_legacy(instance, dev);
+}
+
+static int ehci_driver_start(hcd_t *hcd, bool irq) {
+        hc_t *instance = hcd_get_driver_data(hcd);
+        assert(instance);
+
+        return hc_start(instance, irq);
 }
 

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

@@ -172 +172 @@
 }
 
-int disable_legacy(ddf_dev_t *device)
+int disable_legacy(hc_t *hc, ddf_dev_t *device)
 {
         assert(device);
@@ -183 +183 @@
         usb_log_debug("Disabling EHCI legacy support.\n");
 
-        hw_res_list_parsed_t res;
-        hw_res_list_parsed_init(&res);
-        int ret = hw_res_get_list_parsed(parent_sess, &res, 0);
-        if (ret != EOK) {
-                usb_log_error("Failed to get resource list: %s\n",
-                    str_error(ret));
-                goto clean;
-        }
-
-        if (res.mem_ranges.count < 1) {
-                usb_log_error("Incorrect mem range count: %zu",
-                    res.mem_ranges.count);
-                ret = EINVAL;
-                goto clean;
-        }
-
-        /* Map EHCI registers */
-        void *regs = NULL;
-        ret = pio_enable_range(&res.mem_ranges.ranges[0], &regs);
-        if (ret != EOK) {
-                usb_log_error("Failed to map registers %p: %s.\n",
-                    RNGABSPTR(res.mem_ranges.ranges[0]), str_error(ret));
-                goto clean;
-        }
-
-        usb_log_debug("Registers mapped at: %p.\n", regs);
-
-        ehci_caps_regs_t *ehci_caps = regs;
-
-        const uint32_t hcc_params = EHCI_RD(ehci_caps->hccparams);
+
+        const uint32_t hcc_params = EHCI_RD(hc->caps->hccparams);
         usb_log_debug2("Value of hcc params register: %x.\n", hcc_params);
 
@@ -221 +193 @@
         usb_log_debug2("Value of EECP: %x.\n", eecp);
 
-        ret = disable_extended_caps(parent_sess, eecp);
+        int ret = disable_extended_caps(parent_sess, eecp);
         if (ret != EOK) {
                 usb_log_error("Failed to disable extended capabilities: %s.\n",
@@ -228 +200 @@
         }
 clean:
-        //TODO unmap registers
-        hw_res_list_parsed_clean(&res);
         async_hangup(parent_sess);
         return ret;

uspace/drv/bus/usb/ehci/res.h

@@ -39 +39 @@
 #include <device/hw_res_parsed.h>
 
-extern int disable_legacy(ddf_dev_t *);
+#include "hc.h"
+
+extern int disable_legacy(hc_t *, ddf_dev_t *);
 
 #endif