Changeset 7191992 in mainline

Timestamp:

2014-01-02T19:49:35Z (10 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

1a0fa29c

Parents:

7813516

Message:

libusbhost: Add more helper functions.

Location:

uspace

Files:

• drv/bus/usb/ehci/ehci.c (modified) (1 diff)
• drv/bus/usb/ohci/ohci.c (modified) (1 diff)
• drv/bus/usb/uhci/uhci.c (modified) (1 diff)
• drv/bus/usb/vhc/main.c (modified) (1 diff)
• lib/usbhost/include/usb/host/ddf_helpers.h (modified) (1 diff)
• lib/usbhost/include/usb/host/hcd.h (modified) (4 diffs)
• lib/usbhost/src/ddf_helpers.c (modified) (3 diffs)

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

@@ -135 +135 @@
         /* Connect EHCI to generic HCD */
         hcd_set_implementation(dev_to_hcd(device), hc,
-            hc_schedule, NULL, NULL);
+            hc_schedule, NULL, NULL, NULL);
 
         /* HC should be running OK. We can add root hub */

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

@@ -134 +134 @@
         /* Connect OHCI to generic HCD */
         hcd_set_implementation(dev_to_hcd(device), hc,
-            hc_schedule, ohci_endpoint_init, ohci_endpoint_fini);
+            hc_schedule, ohci_endpoint_init, ohci_endpoint_fini, NULL);
 
         /* HC should be running OK. We can add root hub */

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

@@ -130 +130 @@
         }
 
-        hcd_set_implementation(dev_to_hcd(device), hc, hc_schedule, NULL, NULL);
+        hcd_set_implementation(dev_to_hcd(device), hc, hc_schedule, NULL, NULL, NULL);
 
         /*

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

@@ -95 +95 @@
         }
 
-        hcd_set_implementation(dev_to_hcd(dev), data, vhc_schedule, NULL, NULL);
+        hcd_set_implementation(dev_to_hcd(dev), data, vhc_schedule, NULL, NULL, NULL);
 
         /* Add virtual hub device */

uspace/lib/usbhost/include/usb/host/ddf_helpers.h

@@ -58 +58 @@
     interrupt_handler_t handler,
     int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *));
+void ddf_hcd_gen_irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call);
+int ddf_hcd_device_setup_all(ddf_dev_t *device, usb_speed_t speed, size_t bw,
+    bw_count_func_t bw_count,
+    interrupt_handler_t irq_handler,
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *hw_res),
+    int (*driver_init)(hcd_t *, const hw_res_list_parsed_t *, bool),
+    void (*driver_fini)(hcd_t *));
 
 #endif

uspace/lib/usbhost/include/usb/host/hcd.h

@@ -51 +51 @@
 typedef int (*ep_add_hook_t)(hcd_t *, endpoint_t *);
 typedef void (*ep_remove_hook_t)(hcd_t *, endpoint_t *);
+typedef void (*interrupt_hook_t)(hcd_t *, uint32_t);
 
 typedef struct {
@@ -61 +62 @@
         /** Hook called upon removing of an endpoint. */
         ep_remove_hook_t ep_remove_hook;
+        /** Hook to be called on device interrupt, passes ARG1 */
+        interrupt_hook_t irq_hook;
 } hc_driver_t;
 
@@ -76 +79 @@
 
 static inline void hcd_set_implementation(hcd_t *hcd, void *data,
-    schedule_hook_t schedule, ep_add_hook_t add_hook, ep_remove_hook_t rem_hook)
+    schedule_hook_t schedule, ep_add_hook_t add_hook, ep_remove_hook_t rem_hook,
+    interrupt_hook_t irq_hook)
 {
         assert(hcd);
@@ -83 +87 @@
         hcd->driver.ep_add_hook = add_hook;
         hcd->driver.ep_remove_hook = rem_hook;
+        hcd->driver.irq_hook = irq_hook;
 }
 

uspace/lib/usbhost/src/ddf_helpers.c

@@ -653 +653 @@
 }
 
-
 //TODO: Move this to generic ddf?
 /** Call the parent driver with a request to enable interrupts
@@ -701 +700 @@
 }
 
-
 /** Register interrupt handler
  *
@@ -752 +750 @@
         return irq;
 }
+
+/** IRQ handling callback, forward status from call to diver structure.
+ *
+ * @param[in] dev DDF instance of the device to use.
+ * @param[in] iid (Unused).
+ * @param[in] call Pointer to the call from kernel.
+ */
+void ddf_hcd_gen_irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
+{
+        assert(dev);
+        hcd_t *hcd = dev_to_hcd(dev);
+        if (!hcd || !hcd->driver.irq_hook) {
+                usb_log_error("Interrupt on not yet initialized device.\n");
+                return;
+        }
+        const uint32_t status = IPC_GET_ARG1(*call);
+        hcd->driver.irq_hook(hcd, status);
+}
+/** Initialize hc and rh DDF structures and their respective drivers.
+ *
+ * @param device DDF instance of the device to use
+ * @param speed Maximum supported speed
+ * @param bw Available bandwidth (arbitrary units)
+ * @param bw_count Bandwidth computing function
+ * @param irq_handler IRQ handling function
+ * @param gen_irq_code Function to generate IRQ pseudocode
+ *                     (it needs to return used irq number)
+ * @param driver_init Function to initialize HC driver
+ * @param driver_fini Function to cleanup HC driver
+ * @return Error code
+ *
+ * This function does all the preparatory work for hc and rh drivers:
+ *  - gets device's hw resources
+ *  - attempts to enable interrupts
+ *  - registers interrupt handler
+ *  - calls driver specific initialization
+ *  - registers root hub
+ */
+int ddf_hcd_device_setup_all(ddf_dev_t *device, usb_speed_t speed, size_t bw,
+    bw_count_func_t bw_count,
+    interrupt_handler_t irq_handler,
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *hw_res),
+    int (*driver_init)(hcd_t *, const hw_res_list_parsed_t *, bool),
+    void (*driver_fini)(hcd_t *)
+    )
+{
+        assert(device);
+
+        hw_res_list_parsed_t hw_res;
+        int ret = hcd_ddf_get_registers(device, &hw_res);
+        if (ret != EOK) {
+                usb_log_error("Failed to get register memory addresses "
+                    "for %" PRIun ": %s.\n", ddf_dev_get_handle(device),
+                    str_error(ret));
+                return ret;
+        }
+
+        ret = hcd_ddf_setup_hc(device, speed, bw, bw_count);
+        if (ret != EOK) {
+                usb_log_error("Failed to setup generic HCD.\n");
+                hw_res_list_parsed_clean(&hw_res);
+                return ret;
+        }
+
+        const int irq = hcd_ddf_setup_interrupts(device, &hw_res, irq_handler,
+            gen_irq_code);
+        if (irq < 0) {
+                usb_log_warning("Failed to enable interrupts: %s."
+                    " Falling back to polling.\n", str_error(irq));
+        } else {
+                usb_log_debug("Hw interrupts enabled.\n");
+        }
+
+        /* Init hw driver */
+        ret = driver_init(dev_to_hcd(device), &hw_res, !(irq < 0));
+        hw_res_list_parsed_clean(&hw_res);
+        if (ret != EOK) {
+                usb_log_error("Failed to init uhci_hcd: %s.\n", str_error(ret));
+                goto irq_unregister;
+        }
+
+        /*
+         * Creating root hub registers a new USB device so HC
+         * needs to be ready at this time.
+         */
+        ret = hcd_ddf_setup_root_hub(device);
+        if (ret != EOK) {
+                usb_log_error("Failed to setup UHCI root hub: %s.\n",
+                    str_error(ret));
+                driver_fini(dev_to_hcd(device));
+irq_unregister:
+                /* Unregistering non-existent should be ok */
+                unregister_interrupt_handler(device, irq);
+                hcd_ddf_clean_hc(device);
+        }
+        return ret;
+}
 /**
  * @}