Changeset 47e9494 in mainline

Timestamp:

2018-01-16T18:02:46Z (7 years ago)

Author:

Salmelu <salmelu@…>

Branches:

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

Children:

eeca8a6

Parents:

7d1dd2b

Message:

xhci: stub for streams support

Location:

uspace

Files:

• drv/bus/usb/xhci/Makefile (modified) (1 diff)
• drv/bus/usb/xhci/endpoint.c (modified) (4 diffs)
• drv/bus/usb/xhci/endpoint.h (modified) (3 diffs)
• drv/bus/usb/xhci/hw_struct/context.h (modified) (1 diff)
• drv/bus/usb/xhci/hw_struct/trb.h (modified) (1 diff)
• drv/bus/usb/xhci/streams.c (added)
• drv/bus/usb/xhci/streams.h (added)
• drv/bus/usb/xhci/transfers.c (modified) (6 diffs)
• lib/drv/include/usb_iface.h (modified) (1 diff)

uspace/drv/bus/usb/xhci/Makefile

@@ -43 +43 @@
         rh.c \
         scratchpad.c \
+        streams.c \
         transfers.c \
         trb_ring.c

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

@@ -44 +44 @@
 #include "commands.h"
 #include "endpoint.h"
+#include "streams.h"
 
 static int alloc_transfer_ds(xhci_endpoint_t *);
@@ -131 +132 @@
  * @return EP_TYPE_[CONTROL|ISOCH|BULK|INTERRUPT]_[IN|OUT]
  */
-static int xhci_endpoint_type(xhci_endpoint_t *ep)
+int xhci_endpoint_type(xhci_endpoint_t *ep)
 {
         const bool in = ep->base.direction == USB_DIRECTION_IN;
@@ -153 +154 @@
 
         return EP_TYPE_INVALID;
-}
-
-/**
- * Test whether an XHCI endpoint uses streams.
- * @param[in] xhci_ep XHCI endpoint to query.
- *
- * @return True if the endpoint uses streams.
- */
-static bool endpoint_using_streams(xhci_endpoint_t *xhci_ep)
-{
-        return xhci_ep->primary_stream_ctx_array != NULL;
-}
-
-// static bool primary_stream_ctx_has_secondary_array(xhci_stream_ctx_t *primary_ctx) {
-//      /* Section 6.2.4.1, SCT values */
-//      return XHCI_STREAM_SCT(*primary_ctx) >= 2;
-// }
-//
-// static size_t secondary_stream_ctx_array_size(xhci_stream_ctx_t *primary_ctx) {
-//      if (XHCI_STREAM_SCT(*primary_ctx) < 2) return 0;
-//      return 2 << XHCI_STREAM_SCT(*primary_ctx);
-// }
-
-/** Initialize primary streams of XHCI bulk endpoint.
- * @param[in] hc Host controller of the endpoint.
- * @param[in] xhci_epi XHCI bulk endpoint to use.
- * @param[in] count Number of primary streams to initialize.
- */
-static void initialize_primary_streams(xhci_hc_t *hc, xhci_endpoint_t *xhci_ep, unsigned count) {
-        for (size_t index = 0; index < count; ++index) {
-                xhci_stream_ctx_t *ctx = &xhci_ep->primary_stream_ctx_array[index];
-                xhci_trb_ring_t *ring = &xhci_ep->primary_stream_rings[index];
-
-                /* Init and register TRB ring for every primary stream */
-                xhci_trb_ring_init(ring); // FIXME: Not checking error code?
-                XHCI_STREAM_DEQ_PTR_SET(*ctx, ring->dequeue);
-
-                /* Set to linear stream array */
-                XHCI_STREAM_SCT_SET(*ctx, 1);
-        }
-}
-
-/** Configure XHCI bulk endpoint's stream context.
- * @param[in] xhci_ep Associated XHCI bulk endpoint.
- * @param[in] ctx Endpoint context to configure.
- * @param[in] pstreams The value of MaxPStreams.
- */
-static void setup_stream_context(xhci_endpoint_t *xhci_ep, xhci_ep_ctx_t *ctx, unsigned pstreams) {
-        XHCI_EP_TYPE_SET(*ctx, xhci_endpoint_type(xhci_ep));
-        XHCI_EP_MAX_PACKET_SIZE_SET(*ctx, xhci_ep->base.max_packet_size);
-        XHCI_EP_MAX_BURST_SIZE_SET(*ctx, xhci_ep->max_burst - 1);
-        XHCI_EP_ERROR_COUNT_SET(*ctx, 3);
-
-        XHCI_EP_MAX_P_STREAMS_SET(*ctx, pstreams);
-        XHCI_EP_TR_DPTR_SET(*ctx, xhci_ep->primary_stream_ctx_dma.phys);
-        // TODO: set HID?
-        XHCI_EP_LSA_SET(*ctx, 1);
-}
-
-/** TODO document this
- */
-int xhci_endpoint_request_streams(xhci_hc_t *hc, xhci_device_t *dev, xhci_endpoint_t *xhci_ep, unsigned count) {
-        if (xhci_ep->base.transfer_type != USB_TRANSFER_BULK
-                || dev->base.speed != USB_SPEED_SUPER) {
-                usb_log_error("Streams are only supported by superspeed bulk endpoints.");
-                return EINVAL;
-        }
-
-        if (xhci_ep->max_streams == 1) {
-                usb_log_error("Streams are not supported by endpoint " XHCI_EP_FMT, XHCI_EP_ARGS(*xhci_ep));
-                return EINVAL;
-        }
-
-        uint8_t max_psa_size = 2 << XHCI_REG_RD(hc->cap_regs, XHCI_CAP_MAX_PSA_SIZE);
-        if (count > max_psa_size) {
-                // FIXME: We don't support secondary stream arrays yet, so we just give up for this
-                return ENOTSUP;
-        }
-
-        if (count > xhci_ep->max_streams) {
-                usb_log_error("Endpoint " XHCI_EP_FMT " supports only %" PRIu32 " streams.",
-                        XHCI_EP_ARGS(*xhci_ep), xhci_ep->max_streams);
-                return EINVAL;
-        }
-
-        if (count <= 1024) {
-                usb_log_debug2("Allocating primary stream context array of size %u for endpoint " XHCI_EP_FMT,
-                        count, XHCI_EP_ARGS(*xhci_ep));
-                if ((dma_buffer_alloc(&xhci_ep->primary_stream_ctx_dma, count * sizeof(xhci_stream_ctx_t))))
-                        return ENOMEM;
-                xhci_ep->primary_stream_ctx_array = xhci_ep->primary_stream_ctx_dma.virt;
-
-                xhci_ep->primary_stream_rings = calloc(count, sizeof(xhci_trb_ring_t));
-                if (!xhci_ep->primary_stream_rings) {
-                        dma_buffer_free(&xhci_ep->primary_stream_ctx_dma);
-                        return ENOMEM;
-                }
-
-                // FIXME: count should be rounded to nearest power of 2 for xHC, workaround for now
-                count = 1024;
-                // FIXME: pstreams are "log2(count) - 1"
-                const size_t pstreams = 9;
-                xhci_ep->primary_stream_ctx_array_size = count;
-
-                memset(xhci_ep->primary_stream_ctx_array, 0, count * sizeof(xhci_stream_ctx_t));
-                initialize_primary_streams(hc, xhci_ep, count);
-
-                xhci_ep_ctx_t ep_ctx;
-                setup_stream_context(xhci_ep, &ep_ctx, pstreams);
-                return hc_add_endpoint(hc, dev->slot_id, xhci_endpoint_index(xhci_ep), &ep_ctx);
-        }
-        // FIXME: Complex stuff not supported yet
-        return ENOTSUP;
 }
 
@@ -300 +188 @@
 static void free_transfer_ds(xhci_endpoint_t *xhci_ep)
 {
-        if (endpoint_using_streams(xhci_ep)) {
-                usb_log_debug2("Freeing primary stream context array of endpoint " XHCI_EP_FMT, XHCI_EP_ARGS(*xhci_ep));
-
-                // maybe check if LSA, then skip?
-                // for (size_t index = 0; index < primary_stream_ctx_array_size(xhci_ep); ++index) {
-                //      xhci_stream_ctx_t *primary_ctx = xhci_ep->primary_stream_ctx_array + index;
-                //      if (primary_stream_ctx_has_secondary_array(primary_ctx)) {
-                //              // uintptr_t phys = XHCI_STREAM_DEQ_PTR(*primary_ctx);
-                //              /* size_t size = */ secondary_stream_ctx_array_size(primary_ctx);
-                //              // TODO: somehow map the address to virtual and free the secondary array
-                //      }
-                // }
-                for (size_t index = 0; index < xhci_ep->primary_stream_ctx_array_size; ++index) {
-                        // FIXME: Get the trb ring associated with stream [index] and fini it
-                }
-                dma_buffer_free(&xhci_ep->primary_stream_ctx_dma);
+        if (xhci_ep->primary_stream_data_size) {
+                xhci_stream_free_ds(xhci_ep);
         } else {
                 usb_log_debug2("Freeing main transfer ring of endpoint " XHCI_EP_FMT, XHCI_EP_ARGS(*xhci_ep));
-
                 xhci_trb_ring_fini(&xhci_ep->ring);
         }

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

@@ -51 +51 @@
 typedef struct xhci_device xhci_device_t;
 typedef struct xhci_endpoint xhci_endpoint_t;
+typedef struct xhci_stream_data xhci_stream_data_t;
 typedef struct xhci_bus xhci_bus_t;
 
@@ -71 +72 @@
         xhci_trb_ring_t ring;
 
-        /** Primary stream context array (or NULL if endpoint doesn't use streams). */
+        /** Primary stream context data array (or NULL if endpoint doesn't use streams). */
+        xhci_stream_data_t *primary_stream_data_array;
+
+        /** Primary stream context array - allocated for xHC hardware. */
         xhci_stream_ctx_t *primary_stream_ctx_array;
         dma_buffer_t primary_stream_ctx_dma;
 
-        /** Primary stream ring array (or NULL if endpoint doesn't use streams). */
-        xhci_trb_ring_t *primary_stream_rings;
-
-        /** Size of the allocated primary stream context array (and ring array). */
-        uint16_t primary_stream_ctx_array_size;
+        /** Size of the allocated primary stream data array (and context array). */
+        uint16_t primary_stream_data_size;
 
         /* Maximum number of primary streams (0 - 2^16). */
@@ -129 +130 @@
 #define XHCI_DEV_ARGS(dev)               ddf_fun_get_name((dev).base.fun), (dev).slot_id
 
+int xhci_endpoint_type(xhci_endpoint_t *ep);
+
 int xhci_endpoint_init(xhci_endpoint_t *, device_t *, const usb_endpoint_descriptors_t *);
 void xhci_endpoint_fini(xhci_endpoint_t *);
-
-int xhci_endpoint_request_streams(xhci_hc_t *, xhci_device_t *, xhci_endpoint_t *, unsigned);
 
 uint8_t xhci_endpoint_dci(xhci_endpoint_t *);

uspace/drv/bus/usb/xhci/hw_struct/context.h

@@ -167 +167 @@
 #define XHCI_STREAM_DCS(ctx)       XHCI_QWORD_EXTRACT((ctx).data[0],  0, 0)
 #define XHCI_STREAM_SCT(ctx)       XHCI_QWORD_EXTRACT((ctx).data[0],  3, 1)
-#define XHCI_STREAM_DEQ_PTR(ctx)   XHCI_QWORD_EXTRACT((ctx).data[0], 63, 4)
+#define XHCI_STREAM_DEQ_PTR(ctx)   (XHCI_QWORD_EXTRACT((ctx).data[0], 63, 4) << 4)
 #define XHCI_STREAM_EDTLA(ctx)     XHCI_QWORD_EXTRACT((ctx).data[1], 24, 0)
 

uspace/drv/bus/usb/xhci/hw_struct/trb.h

@@ -102 +102 @@
 #define TRB_LINK_TC(trb)        XHCI_DWORD_EXTRACT((trb).control, 1, 1)
 #define TRB_IOC(trb)            XHCI_DWORD_EXTRACT((trb).control, 5, 5)
+#define TRB_EVENT_DATA(trb)             XHCI_DWORD_EXTRACT((trb).control, 2, 2)
 
 #define TRB_TRANSFER_LENGTH(trb)        XHCI_DWORD_EXTRACT((trb).status, 23, 0)

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

@@ -39 +39 @@
 #include "hc.h"
 #include "hw_struct/trb.h"
+#include "streams.h"
 #include "transfers.h"
 #include "trb_ring.h"
@@ -121 +122 @@
 static xhci_trb_ring_t *get_ring(xhci_hc_t *hc, xhci_transfer_t *transfer)
 {
-        return &xhci_endpoint_get(transfer->batch.ep)->ring;
+        xhci_endpoint_t *ep = xhci_endpoint_get(transfer->batch.ep);
+        if (ep->primary_stream_data_size == 0) return &ep->ring;
+        uint32_t stream_id = transfer->batch.target.stream;
+
+        xhci_stream_data_t *stream_data = xhci_get_stream_ctx_data(ep, stream_id);
+        if (stream_data == NULL) {
+                usb_log_warning("No transfer ring was found for stream %u.", stream_id);
+                return NULL;
+        }
+
+        return &stream_data->ring;
 }
 
@@ -202 +213 @@
         // data size (sent for OUT, or buffer size)
         TRB_CTRL_SET_XFER_LEN(trb, transfer->batch.buffer_size);
-        // FIXME: TD size 4.11.2.4
-        TRB_CTRL_SET_TD_SIZE(trb, 1);
-
-        // we want an interrupt after this td is done
-        TRB_CTRL_SET_IOC(trb, 1);
-
-        TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL);
-
-        xhci_trb_ring_t* ring = get_ring(hc, transfer);
-
-        return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
+
+        /* The stream-enabled endpoints need to chain ED trb */
+        xhci_endpoint_t *ep = xhci_endpoint_get(transfer->batch.ep);
+        if (!ep->primary_stream_data_size) {
+                // FIXME: TD size 4.11.2.4
+                TRB_CTRL_SET_TD_SIZE(trb, 1);
+
+                // we want an interrupt after this td is done
+                TRB_CTRL_SET_IOC(trb, 1);
+                TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL);
+
+                xhci_trb_ring_t* ring = get_ring(hc, transfer);
+                return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
+        }
+        else {
+                TRB_CTRL_SET_TD_SIZE(trb, 2);
+                TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL);
+                TRB_CTRL_SET_CHAIN(trb, 1);
+                TRB_CTRL_SET_ENT(trb, 1);
+
+                xhci_trb_ring_t* ring = get_ring(hc, transfer);
+                int err = xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
+
+                if (err) {
+                        return err;
+                }
+
+                xhci_trb_clean(&trb);
+                trb.parameter = host2xhci(64, (uintptr_t) transfer);
+                TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_EVENT_DATA);
+                TRB_CTRL_SET_IOC(trb, 1);
+
+                return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
+        }
 }
 
@@ -267 +301 @@
         xhci_endpoint_t *ep = xhci_endpoint_get(ep_base);
 
-        xhci_trb_ring_update_dequeue(&ep->ring, addr);
-
-        if (ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS) {
-                isoch_handle_transfer_event(hc, ep, trb);
-                endpoint_del_ref(&ep->base);
-                return EOK;
-        }
-
-        fibril_mutex_lock(&ep->base.guard);
-        usb_transfer_batch_t *batch = ep->base.active_batch;
-        if (!batch) {
+        usb_transfer_batch_t *batch;
+        xhci_transfer_t *transfer;
+
+        if (TRB_EVENT_DATA(*trb)) {
+                assert(ep->base.transfer_type != USB_TRANSFER_ISOCHRONOUS);
+                /* We are received transfer pointer instead - work with that */
+                transfer = (xhci_transfer_t *) addr;
+                xhci_trb_ring_t * ring = get_ring(hc, transfer);
+                xhci_trb_ring_update_dequeue(ring, transfer->interrupt_trb_phys);
+                batch = &transfer->batch;
+
+                fibril_mutex_lock(&ep->base.guard);
+                endpoint_deactivate_locked(&ep->base);
                 fibril_mutex_unlock(&ep->base.guard);
-                endpoint_del_ref(&ep->base);
-                return ENOENT;
+        }
+        else {
+                xhci_trb_ring_update_dequeue(&ep->ring, addr);
+
+                if (ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS) {
+                        isoch_handle_transfer_event(hc, ep, trb);
+                        endpoint_del_ref(&ep->base);
+                        return EOK;
+                }
+
+                fibril_mutex_lock(&ep->base.guard);
+                batch = ep->base.active_batch;
+                if (!batch) {
+                        fibril_mutex_unlock(&ep->base.guard);
+                        endpoint_del_ref(&ep->base);
+                        return ENOENT;
+                }
+
+                transfer = xhci_transfer_from_batch(batch);
+
+                endpoint_deactivate_locked(&ep->base);
+                fibril_mutex_unlock(&ep->base.guard);
         }
 
@@ -296 +352 @@
         }
 
-        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) {
                 assert(batch->buffer);
@@ -370 +421 @@
 
         const uint8_t slot_id = xhci_dev->slot_id;
-        const uint8_t target = xhci_endpoint_index(xhci_ep) + 1; /* EP Doorbells start at 1 */
+        /* EP Doorbells start at 1 */
+        const uint8_t target = (xhci_endpoint_index(xhci_ep) + 1) | (batch->target.stream << 16);
         hc_ring_doorbell(hc, slot_id, target);
         return EOK;

uspace/lib/drv/include/usb_iface.h

@@ -89 +89 @@
                 usb_address_t address;
                 usb_endpoint_t endpoint;
+                uint32_t stream;
         } __attribute__((packed));
-        uint32_t packed;
+        uint64_t packed;
 } usb_target_t;