Changeset 32fb6bce in mainline for uspace/lib/usbhost/src/bus.c

Timestamp:

2017-12-18T22:50:21Z (6 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

7f70d1c

Parents:

1ea0bbf

git-author:

Ondřej Hlavatý <aearsis@…> (2017-12-18 22:04:50)

git-committer:

Ondřej Hlavatý <aearsis@…> (2017-12-18 22:50:21)

Message:

usbhost: refactoring

This commit moves interrupt, status and schedule to bus
operations. Then the purpose of hcd_t is better defined, and split into
hc_driver_t and hc_device_t. hc_driver_t is used to wrap driver
implementation by the library (similar to how usb_driver_t is used to
wrap usb device drivers). hc_device_t is used as a parent for hc_t
inside drivers, and is allocated inside the DDF device node.

To support these changes, some local identifiers were renamed, some
functions were moved and/or renamed and their arguments changed. The
most notable one being hcd_send_batch → bus_device_send_batch.

File:

• uspace/lib/usbhost/src/bus.c (modified) (3 diffs)

uspace/lib/usbhost/src/bus.c

@@ -46 +46 @@
  * Initializes the bus structure.
  */
-void bus_init(bus_t *bus, hcd_t *hcd, size_t device_size)
-{
-        assert(bus);
-        assert(hcd);
+void bus_init(bus_t *bus, size_t device_size)
+{
+        assert(bus);
         assert(device_size >= sizeof(device_t));
         memset(bus, 0, sizeof(bus_t));
 
         fibril_mutex_initialize(&bus->guard);
-        bus->hcd = hcd;
         bus->device_size = device_size;
 }
@@ -61 +59 @@
 {
         assert(bus);
-        assert(bus->hcd);
 
         memset(dev, 0, sizeof(*dev));
@@ -258 +255 @@
 }
 
+/** Prepare generic usb_transfer_batch and schedule it.
+ * @param device Device for which to send the batch
+ * @param target address and endpoint number.
+ * @param setup_data Data to use in setup stage (Control communication type)
+ * @param in Callback for device to host communication.
+ * @param out Callback for host to device communication.
+ * @param arg Callback parameter.
+ * @param name Communication identifier (for nicer output).
+ * @return Error code.
+ */
+int bus_device_send_batch(device_t *device, usb_target_t target,
+    usb_direction_t direction, char *data, size_t size, uint64_t setup_data,
+    usbhc_iface_transfer_callback_t on_complete, void *arg, const char *name)
+{
+        assert(device->address == target.address);
+
+        /* Temporary reference */
+        endpoint_t *ep = bus_find_endpoint(device, target, direction);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
+                    device->address, target.endpoint, name);
+                return ENOENT;
+        }
+
+        assert(ep->device == device);
+
+        const int err = endpoint_send_batch(ep, target, direction, data, size, setup_data,
+            on_complete, arg, name);
+
+        /* Temporary reference */
+        endpoint_del_ref(ep);
+
+        return err;
+}
+
+typedef struct {
+        fibril_mutex_t done_mtx;
+        fibril_condvar_t done_cv;
+        unsigned done;
+
+        size_t transfered_size;
+        int error;
+} sync_data_t;
+
+static int sync_transfer_complete(void *arg, int error, size_t transfered_size)
+{
+        sync_data_t *d = arg;
+        assert(d);
+        d->transfered_size = transfered_size;
+        d->error = error;
+        fibril_mutex_lock(&d->done_mtx);
+        d->done = 1;
+        fibril_condvar_broadcast(&d->done_cv);
+        fibril_mutex_unlock(&d->done_mtx);
+        return EOK;
+}
+
+ssize_t bus_device_send_batch_sync(device_t *device, usb_target_t target,
+    usb_direction_t direction, char *data, size_t size, uint64_t setup_data,
+    const char *name)
+{
+        sync_data_t sd = { .done = 0 };
+        fibril_mutex_initialize(&sd.done_mtx);
+        fibril_condvar_initialize(&sd.done_cv);
+
+        const int ret = bus_device_send_batch(device, target, direction,
+            data, size, setup_data,
+            sync_transfer_complete, &sd, name);
+        if (ret != EOK)
+                return ret;
+
+        fibril_mutex_lock(&sd.done_mtx);
+        while (!sd.done) {
+                fibril_condvar_wait_timeout(&sd.done_cv, &sd.done_mtx, 3000000);
+                if (!sd.done)
+                        usb_log_debug2("Still waiting...");
+        }
+        fibril_mutex_unlock(&sd.done_mtx);
+
+        return (sd.error == EOK)
+                ? (ssize_t) sd.transfered_size
+                : (ssize_t) sd.error;
+}
+
 /**
  * @}