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

File:

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

uspace/lib/usbhost/src/hcd.c

@@ -41 +41 @@
 #include <errno.h>
 #include <usb_iface.h>
+#include <str_error.h>
 
 #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);
-}
 
 
@@ -93 +54 @@
  * @param bw_count Bandwidth compute function, passed to endpoint manager.
  */
-void hcd_init(hcd_t *hcd, usb_speed_t max_speed, size_t bandwidth,
-    bw_count_func_t bw_count)
-{
+void hcd_init(hcd_t *hcd) {
         assert(hcd);
-        usb_bus_init(&hcd->bus, bandwidth, bw_count, max_speed);
 
-        hcd_set_implementation(hcd, NULL, NULL);
+        hcd_set_implementation(hcd, NULL, NULL, NULL);
 }
 
@@ -106 +64 @@
         assert(hcd);
         usb_address_t address = 0;
-        const int ret = usb_bus_request_address(
-            &hcd->bus, &address, false, speed);
+        const int ret = bus_request_address(hcd->bus, &address, false, speed);
         if (ret != EOK)
                 return ret;
@@ -113 +70 @@
 }
 
-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 {
-        void *original_data;
-        usbhc_iface_transfer_out_callback_t original_callback;
-        usb_target_t target;
-        hcd_t *hcd;
-} toggle_t;
-
-static void toggle_reset_callback(int retval, void *arg)
-{
-        assert(arg);
-        toggle_t *toggle = arg;
-        if (retval == EOK) {
-                usb_log_debug2("Reseting toggle on %d:%d.\n",
-                    toggle->target.address, toggle->target.endpoint);
-                usb_bus_reset_toggle(&toggle->hcd->bus,
-                    toggle->target, toggle->target.endpoint == 0);
-        }
-
-        toggle->original_callback(retval, toggle->original_data);
-}
-
 /** Prepare generic usb_transfer_batch and schedule it.
  * @param hcd Host controller driver.
- * @param fun DDF fun
  * @param target address and endpoint number.
  * @param setup_data Data to use in setup stage (Control communication type)
@@ -177 +80 @@
  * @return Error code.
  */
-int hcd_send_batch(
-    hcd_t *hcd, usb_target_t target, usb_direction_t direction,
-    void *data, size_t size, uint64_t setup_data,
-    usbhc_iface_transfer_in_callback_t in,
-    usbhc_iface_transfer_out_callback_t out, void *arg, const char* name)
+int hcd_send_batch(hcd_t *hcd, device_t *device, usb_target_t target,
+    usb_direction_t direction, char *data, size_t size, uint64_t setup_data,
+    usb_transfer_batch_callback_t on_complete, void *arg, const char *name)
 {
         assert(hcd);
+        assert(device->address == target.address);
 
-        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",
-                    target.address, target.endpoint, name);
-                return ENOENT;
-        }
-
-        usb_log_debug2("%s %d:%d %zu(%zu).\n",
-            name, target.address, target.endpoint, size, ep->max_packet_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->address, ep->endpoint, name, bw, ep->bandwidth);
-                return ENOSPC;
-        }
         if (!hcd->ops.schedule) {
                 usb_log_error("HCD does not implement scheduler.\n");
@@ -210 +92 @@
         }
 
-        /* Check for commands that reset toggle bit */
-        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
-                const int reset_toggle = usb_request_needs_toggle_reset(
-                    (usb_device_request_setup_packet_t *) &setup_data);
-                if (reset_toggle >= 0) {
-                        assert(out);
-                        toggle_t *toggle = malloc(sizeof(toggle_t));
-                        if (!toggle)
-                                return ENOMEM;
-                        toggle->target.address = target.address;
-                        toggle->target.endpoint = reset_toggle;
-                        toggle->original_callback = out;
-                        toggle->original_data = arg;
-                        toggle->hcd = hcd;
-
-                        arg = toggle;
-                        out = toggle_reset_callback;
-                }
+        endpoint_t *ep = bus_find_endpoint(hcd->bus, device, target, direction);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
+                    device->address, target.endpoint, name);
+                return ENOENT;
         }
 
-        usb_transfer_batch_t *batch = usb_transfer_batch_create(
-            ep, data, size, setup_data, in, out, arg);
+        // TODO cut here aka provide helper to call with instance of endpoint_t in hand
+
+        usb_log_debug2("%s %d:%d %zu(%zu).\n",
+            name, target.address, target.endpoint, size, ep->max_packet_size);
+
+        const size_t bw = bus_count_bw(ep, 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",
+                    device->address, ep->endpoint, name, bw, ep->bandwidth);
+                return ENOSPC;
+        }
+
+        usb_transfer_batch_t *batch = usb_transfer_batch_create(ep);
         if (!batch) {
                 usb_log_error("Failed to create transfer batch.\n");
@@ -237 +119 @@
         }
 
+        batch->target = target;
+        batch->buffer = data;
+        batch->buffer_size = size;
+        batch->setup.packed = setup_data;
+        batch->dir = direction;
+        batch->on_complete = on_complete;
+        batch->on_complete_data = arg;
+
+        /* Check for commands that reset toggle bit */
+        if (ep->transfer_type == USB_TRANSFER_CONTROL)
+                batch->toggle_reset_mode
+                        = usb_request_get_toggle_reset_mode(&batch->setup.packet);
+
         const int ret = hcd->ops.schedule(hcd, batch);
-        if (ret != EOK)
+        if (ret != EOK) {
+                usb_log_warning("Batch %p failed to schedule: %s", batch, str_error(ret));
                 usb_transfer_batch_destroy(batch);
+        }
 
         /* Drop our own reference to ep. */
@@ -248 +145 @@
 
 typedef struct {
-        volatile unsigned done;
-        int ret;
-        size_t size;
+        fibril_mutex_t done_mtx;
+        fibril_condvar_t done_cv;
+        unsigned done;
+
+        size_t transfered_size;
+        int error;
 } sync_data_t;
 
-static void transfer_in_cb(int ret, size_t size, void* data)
+static int sync_transfer_complete(usb_transfer_batch_t *batch)
 {
-        sync_data_t *d = data;
+        sync_data_t *d = batch->on_complete_data;
         assert(d);
-        d->ret = ret;
+        d->transfered_size = batch->transfered_size;
+        d->error = batch->error;
+        fibril_mutex_lock(&d->done_mtx);
         d->done = 1;
-        d->size = size;
+        fibril_condvar_broadcast(&d->done_cv);
+        fibril_mutex_unlock(&d->done_mtx);
+        return EOK;
 }
 
-static void transfer_out_cb(int ret, void* data)
-{
-        sync_data_t *d = data;
-        assert(data);
-        d->ret = ret;
-        d->done = 1;
-}
-
-/** this is really ugly version of sync usb communication */
-ssize_t hcd_send_batch_sync(
-    hcd_t *hcd, usb_target_t target, usb_direction_t dir,
-    void *data, size_t size, uint64_t setup_data, const char* name)
+ssize_t hcd_send_batch_sync(hcd_t *hcd, device_t *device, usb_target_t target,
+    usb_direction_t direction, char *data, size_t size, uint64_t setup_data,
+    const char *name)
 {
         assert(hcd);
-        sync_data_t sd = { .done = 0, .ret = EBUSY, .size = size };
+        sync_data_t sd = { .done = 0 };
+        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,
-            dir == USB_DIRECTION_IN ? transfer_in_cb : NULL,
-            dir == USB_DIRECTION_OUT ? transfer_out_cb : NULL, &sd, name);
+        const int ret = hcd_send_batch(hcd, device, target, direction,
+            data, size, setup_data,
+            sync_transfer_complete, &sd, name);
         if (ret != EOK)
                 return ret;
 
-        while (!sd.done) {
-                async_usleep(1000);
-        }
+        fibril_mutex_lock(&sd.done_mtx);
+        while (!sd.done)
+                fibril_condvar_wait(&sd.done_cv, &sd.done_mtx);
+        fibril_mutex_unlock(&sd.done_mtx);
 
-        if (sd.ret == EOK)
-                return sd.size;
-        return sd.ret;
+        return (sd.error == EOK)
+                ? (ssize_t) sd.transfered_size
+                : (ssize_t) sd.error;
 }