Changeset 17873ac7 in mainline for uspace/drv/bus/usb/xhci

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/drv/bus/usb/xhci

Files:

• bus.c (modified) (2 diffs)
• endpoint.h (modified) (1 diff)
• transfers.c (modified) (6 diffs)
• transfers.h (modified) (1 diff)

uspace/drv/bus/usb/xhci/bus.c

@@ -198 +198 @@
         for (size_t i = 0; i < ARRAY_SIZE(xhci_dev->endpoints); ++i) {
                 xhci_endpoint_t *ep = xhci_dev->endpoints[i];
-                if (!ep || !ep->base.active)
+                if (!ep)
                         continue;
 
-                /* FIXME: This is racy. */
-                if ((err = xhci_transfer_abort(&ep->active_transfer))) {
-                        usb_log_warning("Failed to abort active transfer to "
-                            " endpoint " XHCI_EP_FMT ": %s", XHCI_EP_ARGS(*ep),
-                            str_error(err));
-                }
+                endpoint_abort(&ep->base);
         }
 
@@ -454 +449 @@
 }
 
-static int reset_toggle(bus_t *bus_base, usb_target_t target, bool all)
+static int reset_toggle(bus_t *bus_base, usb_target_t target, toggle_reset_mode_t mode)
 {
         // TODO: Implement me!

uspace/drv/bus/usb/xhci/endpoint.h

@@ -68 +68 @@
         /** Main transfer ring (unused if streams are enabled) */
         xhci_trb_ring_t ring;
-
-        /** There shall be only one transfer active on an endpoint. The
-         * synchronization is performed using the active flag in base
-         * endpoint_t */
-        xhci_transfer_t active_transfer;
 
         /** Primary stream context array (or NULL if endpoint doesn't use streams). */

uspace/drv/bus/usb/xhci/transfers.c

@@ -101 +101 @@
 xhci_transfer_t* xhci_transfer_create(endpoint_t* ep)
 {
-        xhci_endpoint_t *xhci_ep = xhci_endpoint_get(ep);
-        xhci_transfer_t *transfer = &xhci_ep->active_transfer;
-
-        /* Do not access the transfer yet, it may be still in use. */
+        xhci_transfer_t *transfer = calloc(1, sizeof(xhci_transfer_t));
+        if (!transfer)
+                return NULL;
 
         usb_transfer_batch_init(&transfer->batch, ep);
-        assert(ep->active);
-
-        /* Clean just our data. */
-        memset(((void *) transfer) + sizeof(usb_transfer_batch_t), 0,
-            sizeof(xhci_transfer_t) - sizeof(usb_transfer_batch_t));
-
         return transfer;
 }
@@ -246 +239 @@
         usb_log_error("Isochronous transfers are not yet implemented!");
         return ENOTSUP;
-}
-
-int xhci_transfer_abort(xhci_transfer_t *transfer)
-{
-        usb_transfer_batch_t *batch = &transfer->batch;
-        batch->error = EAGAIN;
-        batch->transfered_size = 0;
-        usb_transfer_batch_finish(batch);
-        return EOK;
 }
 
@@ -277 +261 @@
         }
 
-        xhci_transfer_t *transfer = &ep->active_transfer;
-
-        /** FIXME: This is racy. Do we care? */
+        /* FIXME: This is racy. Do we care? */
         ep->ring.dequeue = addr;
 
-        usb_transfer_batch_t *batch = &transfer->batch;
+        fibril_mutex_lock(&ep->base.guard);
+        usb_transfer_batch_t *batch = ep->base.active_batch;
+        if (!batch) {
+                fibril_mutex_unlock(&ep->base.guard);
+                return ENOENT;
+        }
 
         batch->error = (TRB_COMPLETION_CODE(*trb) == XHCI_TRBC_SUCCESS) ? EOK : ENAK;
         batch->transfered_size = batch->buffer_size - TRB_TRANSFER_LENGTH(*trb);
+        usb_transfer_batch_reset_toggle(batch);
+        endpoint_deactivate_locked(&ep->base);
+        fibril_mutex_unlock(&ep->base.guard);
+
+        xhci_transfer_t *transfer = xhci_transfer_from_batch(batch);
 
         if (batch->dir == USB_DIRECTION_IN) {
@@ -309 +301 @@
 {
         assert(hc);
+        endpoint_t *ep = batch->ep;
 
         xhci_transfer_t *transfer = xhci_transfer_from_batch(batch);
-        xhci_endpoint_t *xhci_ep = xhci_endpoint_get(batch->ep);
-        assert(xhci_ep);
-
+        xhci_endpoint_t *xhci_ep = xhci_endpoint_get(ep);
         xhci_device_t *xhci_dev = xhci_ep_to_dev(xhci_ep);
 
         /* Offline devices don't schedule transfers other than on EP0. */
-        if (!xhci_dev->online && xhci_ep->base.endpoint) {
+        if (!xhci_dev->online && ep->endpoint > 0) {
                 return EAGAIN;
         }
@@ -334 +325 @@
         if (batch->buffer_size > 0) {
                 transfer->hc_buffer = malloc32(batch->buffer_size);
-        }
-
+                if (!transfer->hc_buffer)
+                        return ENOMEM;
+        }
 
         if (batch->dir != USB_DIRECTION_IN) {
@@ -342 +334 @@
         }
 
+        fibril_mutex_lock(&ep->guard);
+        endpoint_activate_locked(ep, batch);
         const int err = transfer_handlers[batch->ep->transfer_type](hc, transfer);
-        if (err)
+
+        if (err) {
+                endpoint_deactivate_locked(ep);
+                fibril_mutex_unlock(&ep->guard);
                 return err;
+        }
+
+        /* After the critical section, the transfer can already be finished or aborted. */
+        transfer = NULL; batch = NULL;
+        fibril_mutex_unlock(&ep->guard);
 
         const uint8_t slot_id = xhci_dev->slot_id;

uspace/drv/bus/usb/xhci/transfers.h

@@ -58 +58 @@
 xhci_transfer_t* xhci_transfer_create(endpoint_t *);
 int xhci_transfer_schedule(xhci_hc_t *, usb_transfer_batch_t *);
-int xhci_transfer_abort(xhci_transfer_t *);
 int xhci_handle_transfer_event(xhci_hc_t *, xhci_trb_t *);
 void xhci_transfer_destroy(xhci_transfer_t *);