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

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/ohci

Files:

• hc.c (modified) (6 diffs)
• hc.h (modified) (2 diffs)
• main.c (modified) (5 diffs)

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

@@ -89 +89 @@
 };
 
-static void hc_gain_control(hc_t *instance);
-static void hc_start(hc_t *instance);
 static int hc_init_transfer_lists(hc_t *instance);
 static int hc_init_memory(hc_t *instance);
@@ -103 +101 @@
  * @return Error code.
  */
-int ohci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res)
+int ohci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
 {
         assert(code);
@@ -151 +149 @@
  * @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 +170 @@
         list_initialize(&instance->pending_batches);
         fibril_mutex_initialize(&instance->guard);
-        instance->hw_interrupts = interrupts;
 
         ret = hc_init_memory(instance);
@@ -181 +178 @@
                 return ret;
         }
-
-        hc_gain_control(instance);
-
-        ohci_rh_init(&instance->rh, instance->registers, "ohci rh");
-        hc_start(instance);
 
         return EOK;
@@ -443 +435 @@
 void hc_start(hc_t *instance)
 {
+        ohci_rh_init(&instance->rh, instance->registers, "ohci rh");
+
         /* OHCI guide page 42 */
         assert(instance);

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

@@ -80 +80 @@
 } hc_t;
 
-extern int hc_init(hc_t *, const hw_res_list_parsed_t *, bool);
+extern int hc_init(hc_t *, const hw_res_list_parsed_t *);
+extern void hc_gain_control(hc_t *instance);
+extern void hc_start(hc_t *instance);
 extern void hc_fini(hc_t *);
 
@@ -86 +88 @@
 extern void hc_dequeue_endpoint(hc_t *, const endpoint_t *);
 
-int ohci_hc_gen_irq_code(irq_code_t *code, const hw_res_list_parsed_t *hw_res);
+int ohci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res);
 
 extern void ohci_hc_interrupt(hcd_t *, uint32_t);

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

@@ -47 +47 @@
 
 #define NAME "ohci"
-static int ohci_driver_init(hcd_t *, const hw_res_list_parsed_t *, bool);
+static int ohci_driver_init(hcd_t *, const hw_res_list_parsed_t *);
+static int ohci_driver_start(hcd_t *, bool);
+static int ohci_driver_claim(hcd_t *, ddf_dev_t *);
 static void ohci_driver_fini(hcd_t *);
 
@@ -54 +56 @@
         .irq_code_gen = ohci_hc_gen_irq_code,
         .init = ohci_driver_init,
+        .claim = ohci_driver_claim,
+        .start = ohci_driver_start,
         .fini = ohci_driver_fini,
         .name = "OHCI",
@@ -66 +70 @@
 
 
-static int ohci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res, bool irq)
+static int ohci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res)
 {
         assert(hcd);
@@ -75 +79 @@
                 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, &ohci_hc_driver.ops);
@@ -82 +86 @@
         }
         return ret;
+}
+
+static int ohci_driver_claim(hcd_t *hcd, ddf_dev_t *dev)
+{
+        hc_t *hc = hcd_get_driver_data(hcd);
+        assert(hc);
+
+        hc_gain_control(hc);
+
+        return EOK;
+}
+
+static int ohci_driver_start(hcd_t *hcd, bool interrupts)
+{
+        hc_t *hc = hcd_get_driver_data(hcd);
+        assert(hc);
+
+        hc->hw_interrupts = interrupts;
+        hc_start(hc);
+        return EOK;
 }