Changes in uspace/lib/usbhost/src/hcd.c [20eaa82:f527f58] in mainline

File:

• uspace/lib/usbhost/src/hcd.c (modified) (11 diffs)

uspace/lib/usbhost/src/hcd.c

@@ -44 +44 @@
 #include "hcd.h"
 
+/** Calls ep_add_hook upon endpoint registration.
+ * @param ep Endpoint to be registered.
+ * @param arg hcd_t in disguise.
+ * @return Error code.
+ */
+static int register_helper(endpoint_t *ep, void *arg)
+{
+        hcd_t *hcd = arg;
+        assert(ep);
+        assert(hcd);
+        if (hcd->ops.ep_add_hook)
+                return hcd->ops.ep_add_hook(hcd, ep);
+        return EOK;
+}
+
+/** Calls ep_remove_hook upon endpoint removal.
+ * @param ep Endpoint to be unregistered.
+ * @param arg hcd_t in disguise.
+ */
+static void unregister_helper(endpoint_t *ep, void *arg)
+{
+        hcd_t *hcd = arg;
+        assert(ep);
+        assert(hcd);
+        if (hcd->ops.ep_remove_hook)
+                hcd->ops.ep_remove_hook(hcd, ep);
+}
+
+/** Calls ep_remove_hook upon endpoint removal. Prints warning.
+ *  * @param ep Endpoint to be unregistered.
+ *   * @param arg hcd_t in disguise.
+ *    */
+static void unregister_helper_warn(endpoint_t *ep, void *arg)
+{
+        assert(ep);
+        usb_log_warning("Endpoint %d:%d %s was left behind, removing.\n",
+            ep->address, ep->endpoint, usb_str_direction(ep->direction));
+        unregister_helper(ep, arg);
+}
+
 
 /** Initialize hcd_t structure.
@@ -53 +93 @@
  * @param bw_count Bandwidth compute function, passed to endpoint manager.
  */
-void hcd_init(hcd_t *hcd) {
-        assert(hcd);
-
-        hcd_set_implementation(hcd, NULL, NULL, NULL);
+void hcd_init(hcd_t *hcd, usb_speed_t max_speed, size_t bandwidth,
+    bw_count_func_t bw_count)
+{
+        assert(hcd);
+        usb_bus_init(&hcd->bus, bandwidth, bw_count, max_speed);
+
+        hcd_set_implementation(hcd, NULL, NULL);
 }
 
@@ -63 +106 @@
         assert(hcd);
         usb_address_t address = 0;
-        const int ret = bus_request_address(hcd->bus, &address, false, speed);
+        const int ret = usb_bus_request_address(
+            &hcd->bus, &address, false, speed);
         if (ret != EOK)
                 return ret;
         return address;
 }
+
+int hcd_release_address(hcd_t *hcd, usb_address_t address)
+{
+        assert(hcd);
+        return usb_bus_remove_address(&hcd->bus, address,
+            unregister_helper_warn, hcd);
+}
+
+int hcd_reserve_default_address(hcd_t *hcd, usb_speed_t speed)
+{
+        assert(hcd);
+        usb_address_t address = 0;
+        return usb_bus_request_address(&hcd->bus, &address, true, speed);
+}
+
+int hcd_add_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir,
+    usb_transfer_type_t type, size_t max_packet_size, unsigned packets,
+    size_t size, usb_address_t tt_address, unsigned tt_port)
+{
+        assert(hcd);
+        return usb_bus_add_ep(&hcd->bus, target.address,
+            target.endpoint, dir, type, max_packet_size, packets, size,
+            register_helper, hcd, tt_address, tt_port);
+}
+
+int hcd_remove_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir)
+{
+        assert(hcd);
+        return usb_bus_remove_ep(&hcd->bus, target.address,
+            target.endpoint, dir, unregister_helper, hcd);
+}
+
 
 typedef struct {
@@ -83 +159 @@
                 usb_log_debug2("Reseting toggle on %d:%d.\n",
                     toggle->target.address, toggle->target.endpoint);
-                bus_reset_toggle(toggle->hcd->bus,
+                usb_bus_reset_toggle(&toggle->hcd->bus,
                     toggle->target, toggle->target.endpoint == 0);
         }
@@ -109 +185 @@
         assert(hcd);
 
-        endpoint_t *ep = bus_find_endpoint(hcd->bus, target, direction);
+        endpoint_t *ep = usb_bus_find_ep(&hcd->bus,
+            target.address, target.endpoint, direction);
         if (ep == NULL) {
                 usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
@@ -119 +196 @@
             name, target.address, target.endpoint, size, ep->max_packet_size);
 
-        const size_t bw = bus_count_bw(ep, size);
+        const size_t bw = bandwidth_count_usb11(
+            ep->speed, ep->transfer_type, size, ep->max_packet_size);
         /* Check if we have enough bandwidth reserved */
         if (ep->bandwidth < bw) {
                 usb_log_error("Endpoint(%d:%d) %s needs %zu bw "
                     "but only %zu is reserved.\n",
-                    ep->target.address, ep->target.endpoint, name, bw, ep->bandwidth);
+                    ep->address, ep->endpoint, name, bw, ep->bandwidth);
                 return ENOSPC;
         }
@@ -170 +248 @@
 
 typedef struct {
-        fibril_mutex_t done_mtx;
-        fibril_condvar_t done_cv;
-        unsigned done;
+        volatile unsigned done;
         int ret;
         size_t size;
@@ -182 +258 @@
         assert(d);
         d->ret = ret;
+        d->done = 1;
         d->size = size;
-        fibril_mutex_lock(&d->done_mtx);
-        d->done = 1;
-        fibril_condvar_broadcast(&d->done_cv);
-        fibril_mutex_unlock(&d->done_mtx);
 }
 
@@ -194 +267 @@
         assert(data);
         d->ret = ret;
-        fibril_mutex_lock(&d->done_mtx);
         d->done = 1;
-        fibril_condvar_broadcast(&d->done_cv);
-        fibril_mutex_unlock(&d->done_mtx);
 }
 
@@ -207 +277 @@
         assert(hcd);
         sync_data_t sd = { .done = 0, .ret = EBUSY, .size = size };
-        fibril_mutex_initialize(&sd.done_mtx);
-        fibril_condvar_initialize(&sd.done_cv);
 
         const int ret = hcd_send_batch(hcd, target, dir, data, size, setup_data,
@@ -216 +284 @@
                 return ret;
 
-        fibril_mutex_lock(&sd.done_mtx);
-        while (!sd.done)
-                fibril_condvar_wait(&sd.done_cv, &sd.done_mtx);
-        fibril_mutex_unlock(&sd.done_mtx);
+        while (!sd.done) {
+                async_usleep(1000);
+        }
 
         if (sd.ret == EOK)