Changeset 17873ac7 in mainline for uspace/lib/usbhost

Timestamp:

2017-10-31T19:06:57Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

479e32d

Parents:

a312d8f

Message:

usbhost endpoint: endpoint→active replaced by tracking active batch

The mechanism is optional, synchronization over endpoint is now not forced. It will be used by xhci to utilize streams.

Location:

uspace/lib/usbhost

Files:

• include/usb/host/bus.h (modified) (2 diffs)
• include/usb/host/endpoint.h (modified) (3 diffs)
• include/usb/host/usb_transfer_batch.h (modified) (3 diffs)
• src/endpoint.c (modified) (7 diffs)
• src/usb2_bus.c (modified) (3 diffs)
• src/usb_transfer_batch.c (modified) (3 diffs)

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

@@ -44 +44 @@
 
 #include <usb/usb.h>
+#include <usb/request.h>
 
 #include <assert.h>
@@ -97 +98 @@
         int (*release_address)(bus_t *, usb_address_t);
 
-        int (*reset_toggle)(bus_t *, usb_target_t, bool);
+        int (*reset_toggle)(bus_t *, usb_target_t, toggle_reset_mode_t);
 
         size_t (*count_bw) (endpoint_t *, size_t);

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

@@ -52 +52 @@
 /** Host controller side endpoint structure. */
 typedef struct endpoint {
+        /** Part of linked list. */
+        link_t link;
         /** Managing bus */
         bus_t *bus;
         /** Reference count. */
         atomic_t refcnt;
-        /** Part of linked list. */
-        link_t link;
         /** USB device */
         device_t *device;
@@ -76 +76 @@
         /** Value of the toggle bit. */
         unsigned toggle:1;
-        /** True if there is a batch using this scheduled for this endpoint. */
-        bool active;
+        /** The currently active transfer batch. Write using methods, read under guard. */
+        usb_transfer_batch_t *active_batch;
         /** Protects resources and active status changes. */
         fibril_mutex_t guard;
@@ -91 +91 @@
 extern void endpoint_del_ref(endpoint_t *);
 
-extern void endpoint_use(endpoint_t *);
-extern void endpoint_release(endpoint_t *);
+/* Pay atention to synchronization of batch access wrt to aborting & finishing from another fibril. */
+
+/* Set currently active batch. The common case is to activate in the same
+ * critical section as scheduling to HW.
+ */
+extern void endpoint_activate_locked(endpoint_t *, usb_transfer_batch_t *);
+
+/* Deactivate the endpoint, allowing others to activate it again. Batch shall
+ * already have an error set. */
+extern void endpoint_deactivate_locked(endpoint_t *);
+
+/* Abort the currenty active batch. */
+void endpoint_abort(endpoint_t *);
 
 extern int endpoint_toggle_get(endpoint_t *);
-extern void endpoint_toggle_set(endpoint_t *, unsigned);
+extern void endpoint_toggle_set(endpoint_t *, bool);
 
 /** list_get_instance wrapper.

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

@@ -40 +40 @@
 #include <usb/request.h>
 
+#include <atomic.h>
 #include <stddef.h>
+#include <errno.h>
 #include <stdint.h>
 #include <usbhc_iface.h>
@@ -86 +88 @@
         /** Size of memory pointed to by buffer member */
         size_t buffer_size;
-
         /** Actually used portion of the buffer */
         size_t transfered_size;
+
         /** Indicates success/failure of the communication */
         int error;
@@ -106 +108 @@
         (batch).buffer_size, (batch).ep->max_packet_size
 
+/** Wrapper for bus operation. */
+usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *);
+
+/** Batch initializer. */
 void usb_transfer_batch_init(usb_transfer_batch_t *, endpoint_t *);
+
+/** Call after status is known, but before releasing endpoint */
+int usb_transfer_batch_reset_toggle(usb_transfer_batch_t *);
+
+/** Batch finalization. */
+void usb_transfer_batch_abort(usb_transfer_batch_t *);
 void usb_transfer_batch_finish(usb_transfer_batch_t *);
 
-usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *);
+/** To be called from outside only when the transfer is not going to be finished
+ * (i.o.w. until successfuly scheduling)
+ */
 void usb_transfer_batch_destroy(usb_transfer_batch_t *);
 

uspace/lib/usbhost/src/endpoint.c

@@ -36 +36 @@
 
 #include <usb/host/endpoint.h>
+#include <usb/host/usb_transfer_batch.h>
 #include <usb/host/bus.h>
 
@@ -68 +69 @@
                 }
                 else {
-                        assert(!ep->active);
+                        assert(ep->active_batch == NULL);
 
                         /* Assume mostly the eps will be allocated by malloc. */
@@ -79 +80 @@
  * @param ep endpoint_t structure.
  */
-void endpoint_use(endpoint_t *ep)
+void endpoint_activate_locked(endpoint_t *ep, usb_transfer_batch_t *batch)
 {
         assert(ep);
-        /* Add reference for active endpoint. */
-        endpoint_add_ref(ep);
-        fibril_mutex_lock(&ep->guard);
-        while (ep->active)
+        assert(batch);
+        assert(batch->ep == ep);
+        assert(fibril_mutex_is_locked(&ep->guard));
+
+        while (ep->active_batch != NULL)
                 fibril_condvar_wait(&ep->avail, &ep->guard);
-        ep->active = true;
-        fibril_mutex_unlock(&ep->guard);
+        ep->active_batch = batch;
 }
 
@@ -94 +95 @@
  * @param ep endpoint_t structure.
  */
-void endpoint_release(endpoint_t *ep)
+void endpoint_deactivate_locked(endpoint_t *ep)
 {
         assert(ep);
+        assert(fibril_mutex_is_locked(&ep->guard));
+
+        if (ep->active_batch && ep->active_batch->error == EOK)
+                usb_transfer_batch_reset_toggle(ep->active_batch);
+
+        ep->active_batch = NULL;
+        fibril_condvar_signal(&ep->avail);
+}
+
+/** Abort an active batch on endpoint, if any.
+ *
+ * @param[in] ep endpoint_t structure.
+ */
+void endpoint_abort(endpoint_t *ep)
+{
+        assert(ep);
+
         fibril_mutex_lock(&ep->guard);
-        ep->active = false;
+        usb_transfer_batch_t *batch = ep->active_batch;
+        endpoint_deactivate_locked(ep);
         fibril_mutex_unlock(&ep->guard);
-        fibril_condvar_signal(&ep->avail);
-        /* Drop reference for active endpoint. */
-        endpoint_del_ref(ep);
+
+        if (batch)
+                usb_transfer_batch_abort(batch);
 }
 
@@ -112 +131 @@
 {
         assert(ep);
-        fibril_mutex_lock(&ep->guard);
-        const int ret = ep->bus->ops.endpoint_get_toggle
+
+        return ep->bus->ops.endpoint_get_toggle
             ? ep->bus->ops.endpoint_get_toggle(ep)
             : ep->toggle;
-        fibril_mutex_unlock(&ep->guard);
-        return ret;
 }
 
@@ -124 +141 @@
  * @param ep endpoint_t structure.
  */
-void endpoint_toggle_set(endpoint_t *ep, unsigned toggle)
+void endpoint_toggle_set(endpoint_t *ep, bool toggle)
 {
         assert(ep);
-        assert(toggle == 0 || toggle == 1);
-        fibril_mutex_lock(&ep->guard);
+
         if (ep->bus->ops.endpoint_set_toggle) {
                 ep->bus->ops.endpoint_set_toggle(ep, toggle);
@@ -135 +151 @@
                 ep->toggle = toggle;
         }
-        fibril_mutex_unlock(&ep->guard);
 }
 

uspace/lib/usbhost/src/usb2_bus.c

@@ -367 +367 @@
 }
 
-static int usb2_bus_reset_toggle(bus_t *bus_base, usb_target_t target, bool all)
+static int usb2_bus_reset_toggle(bus_t *bus_base, usb_target_t target, toggle_reset_mode_t mode)
 {
         usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
@@ -374 +374 @@
                 return EINVAL;
 
+        if (mode == RESET_NONE)
+                return EOK;
+
         int ret = ENOENT;
 
@@ -379 +382 @@
                 assert(ep->device->address == target.address);
 
-                if (all || ep->endpoint == target.endpoint) {
+                if (mode == RESET_ALL || ep->endpoint == target.endpoint) {
                         endpoint_toggle_set(ep, 0);
                         ret = EOK;

uspace/lib/usbhost/src/usb_transfer_batch.c

@@ -63 +63 @@
 void usb_transfer_batch_init(usb_transfer_batch_t *batch, endpoint_t *ep)
 {
-        endpoint_use(ep);
-
         memset(batch, 0, sizeof(*batch));
         batch->ep = ep;
 }
 
-/** Call the handler of the batch.
+/** Resolve resetting toggle.
  *
  * @param[in] batch Batch structure to use.
  */
-static int batch_complete(usb_transfer_batch_t *batch)
+int usb_transfer_batch_reset_toggle(usb_transfer_batch_t *batch)
 {
         assert(batch);
 
-        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " completed.\n",
-            batch, USB_TRANSFER_BATCH_ARGS(*batch));
+        if (batch->error != EOK || batch->toggle_reset_mode == RESET_NONE)
+                return EOK;
 
-        if (batch->error == EOK && batch->toggle_reset_mode != RESET_NONE) {
-                usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " resets %s",
-                    batch, USB_TRANSFER_BATCH_ARGS(*batch),
-                    batch->toggle_reset_mode == RESET_ALL ? "all EPs toggle" : "EP toggle");
-                bus_reset_toggle(batch->ep->bus, 
-                    batch->target, batch->toggle_reset_mode == RESET_ALL);
-        }
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " resets %s",
+            batch, USB_TRANSFER_BATCH_ARGS(*batch),
+            batch->toggle_reset_mode == RESET_ALL ? "all EPs toggle" : "EP toggle");
 
-        return batch->on_complete
-                ? batch->on_complete(batch)
-                : EOK;
+        return bus_reset_toggle(batch->ep->bus, batch->target, batch->toggle_reset_mode);
 }
 
@@ -114 +106 @@
                 free(batch);
         }
-
-        endpoint_release(batch->ep);
 }
 
@@ -126 +116 @@
 void usb_transfer_batch_finish(usb_transfer_batch_t *batch)
 {
-        const int err = batch_complete(batch);
-        if (err)
-                usb_log_warning("batch %p failed to complete: %s", batch, str_error(err));
+        assert(batch);
+        assert(batch->ep);
+
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " finishing.\n",
+            batch, USB_TRANSFER_BATCH_ARGS(*batch));
+
+        if (batch->on_complete) {
+                const int err = batch->on_complete(batch);
+                if (err)
+                        usb_log_warning("batch %p failed to complete: %s",
+                            batch, str_error(err));
+        }
 
         usb_transfer_batch_destroy(batch);
+}
+
+/** Finish a transfer batch as an aborted one.
+ *
+ * @param[in] batch Batch structure to use.
+ */
+void usb_transfer_batch_abort(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+        assert(batch->ep);
+
+        batch->error = EAGAIN;
+        usb_transfer_batch_finish(batch);
 }