diff --git a/hw/dv/dpi/usbdpi/usbdpi.c b/hw/dv/dpi/usbdpi/usbdpi.c
index 65b7b26..d9ce188 100644
--- a/hw/dv/dpi/usbdpi/usbdpi.c
+++ b/hw/dv/dpi/usbdpi/usbdpi.c
@@ -1267,6 +1267,14 @@
           testUnimplEp(ctx, USB_PID_SETUP, UKDEV_ADDRESS, 1u);
           break;
 
+        case STEP_STREAM_SERVICE:
+          // After the initial testing of the (current) fixed DPI behavior,
+          // we repeatedly try IN transfers, checking and scrambling any
+          // data packets that we received before sending them straight back
+          // to the device for software to check
+          streams_service(ctx);
+          break;
+
         default:
           if (ctx->step < STEP_IDLE_START || ctx->step >= STEP_IDLE_END) {
             pollRX(ctx, ENDPOINT_SERIAL0, false, false);
diff --git a/hw/dv/dpi/usbdpi/usbdpi.core b/hw/dv/dpi/usbdpi/usbdpi.core
index af9297a..c4b244a 100644
--- a/hw/dv/dpi/usbdpi/usbdpi.core
+++ b/hw/dv/dpi/usbdpi/usbdpi.core
@@ -10,12 +10,14 @@
     files:
       - usbdpi.sv: { file_type: systemVerilogSource }
       - usbdpi.c: { file_type: cppSource }
+      - usbdpi_stream.c: { file_type: cppSource }
       - usbdpi_test.c: { file_type: cppSource }
       - usb_crc.c: { file_type: cppSource }
       - usb_monitor.c: { file_type: cppSource }
       - usb_transfer.c: { file_type: cppSource }
       - usb_utils.c: { file_type: cppSource }
       - usbdpi.h: { file_type: cppSource, is_include_file: true }
+      - usbdpi_stream.h: { file_type: cppSource, is_include_file: true }
       - usbdpi_test.h: { file_type: cppSource, is_include_file: true }
       - usb_monitor.h: { file_type: cppSource, is_include_file: true }
       - usb_transfer.h: { file_type: cppSource, is_include_file: true }
diff --git a/hw/dv/dpi/usbdpi/usbdpi.h b/hw/dv/dpi/usbdpi/usbdpi.h
index 1d7488b..cad73ba 100644
--- a/hw/dv/dpi/usbdpi/usbdpi.h
+++ b/hw/dv/dpi/usbdpi/usbdpi.h
@@ -21,6 +21,7 @@
 #endif
 #include "usb_monitor.h"
 #include "usb_transfer.h"
+#include "usbdpi_stream.h"
 
 // Shall we employ a proper simulation of the frame interval (1ms)?
 // TODO - until such time as we can perform multiple control transfers in a
@@ -134,6 +135,10 @@
 // Maximum number of endpoints supported by the DPI model
 #define USBDPI_MAX_ENDPOINTS 16U
 
+// Maximum number of bidirection LFSR-generated byte streams that may be
+// supported simultaneously
+#define USBDPI_MAX_STREAMS (USBDPI_MAX_ENDPOINTS - 1U)
+
 // Maximum number of simultaneous transfer descriptors
 //   (The host model may simply avoid polling for further IN transfers
 //    whilst there are no further desciptors available)
@@ -304,6 +309,23 @@
     uint8_t next_data;
   } ep_out[USBDPI_MAX_ENDPOINTS];
 
+  /**
+   * Number of data streams being used
+   */
+  uint8_t nstreams;
+  /**
+   * Stream number of next stream to attempt IN transfers
+   */
+  uint8_t stream_in;
+  /**
+   * Stream number of next stream to attempt OUT transfers
+   */
+  uint8_t stream_out;
+  /**
+   * Context for streaming data test (usbdev_stream_test)
+   */
+  usbdpi_stream_t stream[USBDPI_MAX_STREAMS];
+
   // Diagnostic logging and bus monitoring
   int loglevel;
   char mon_pathname[FILENAME_MAX];
diff --git a/hw/dv/dpi/usbdpi/usbdpi_stream.c b/hw/dv/dpi/usbdpi/usbdpi_stream.c
new file mode 100644
index 0000000..a6d4139
--- /dev/null
+++ b/hw/dv/dpi/usbdpi/usbdpi_stream.c
@@ -0,0 +1,589 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "usb_utils.h"
+#include "usbdpi.h"
+
+// Seed numbers for the LFSR generators in each transfer direction for
+// the given stream number
+#define USBTST_LFSR_SEED(s) (uint8_t)(0x10U + (s)*7U)
+#define USBDPI_LFSR_SEED(s) (uint8_t)(0x9BU - (s)*7U)
+// Seed number of packet retrying
+#define RETRY_LFSR_SEED(s) (uint8_t)(0x24U + (s)*7U)
+
+// Simple LFSR for 8-bit sequences
+#define LFSR_ADVANCE(lfsr) \
+  (((lfsr) << 1) ^         \
+   ((((lfsr) >> 1) ^ ((lfsr) >> 2) ^ ((lfsr) >> 3) ^ ((lfsr) >> 7)) & 1u))
+
+// Stream signature words
+#define STREAM_SIGNATURE_HEAD 0x579EA01AU
+#define STREAM_SIGNATURE_TAIL 0x160AE975U
+
+// Verbose logging/diagnostic reporting
+// TODO - consider folding this into the existing log level
+static const bool verbose = false;
+
+static const bool expect_sig = true;
+
+// Determine the next stream for which IN data packets shall be requested
+static inline unsigned in_stream_next(usbdpi_ctx_t *ctx);
+
+// Determine the next stream for which OUT data shall be sent
+static inline unsigned out_stream_next(usbdpi_ctx_t *ctx);
+
+// Check a data packet received from the test software (usbdev_stream_test)
+static bool stream_data_check(usbdpi_ctx_t *ctx, usbdpi_stream_t *s,
+                              const usbdpi_transfer_t *rx, bool accept);
+
+// Generate a data packet as if it had been received from the device
+static usbdpi_transfer_t *stream_data_gen(usbdpi_ctx_t *ctx, usbdpi_stream_t *s,
+                                          unsigned len);
+
+// Check a data packet received from the test software (usbdev_stream_test)
+// and collect the data, combined with our LFSR-generated random stream,
+// for later transmission back to the device
+static usbdpi_transfer_t *stream_data_process(usbdpi_ctx_t *ctx,
+                                              usbdpi_stream_t *s,
+                                              usbdpi_transfer_t *rx);
+
+// Check the stream signature
+static bool stream_sig_check(usbdpi_ctx_t *ctx, usbdpi_stream_t *s,
+                             usbdpi_transfer_t *rx);
+
+// Determine the next stream for which IN data packets shall be requested
+inline unsigned in_stream_next(usbdpi_ctx_t *ctx) {
+  uint8_t id = ctx->stream_in;
+  if (++id >= ctx->nstreams) {
+    id = 0U;
+  }
+  ctx->stream_in = id;
+  return id;
+}
+
+// Determine the next stream for which OUT data shall be sent
+inline unsigned out_stream_next(usbdpi_ctx_t *ctx) {
+  uint8_t id = ctx->stream_out;
+  if (++id >= ctx->nstreams) {
+    id = 0U;
+  }
+  ctx->stream_out = id;
+  return id;
+}
+
+// Initialize streaming state for the given number of streams
+bool streams_init(usbdpi_ctx_t *ctx, unsigned nstreams, bool retrieve,
+                  bool checking, bool retrying, bool send) {
+  // Can we support the requested number of streams?
+  if (!nstreams || nstreams > USBDPI_MAX_STREAMS) {
+    return false;
+  }
+
+  if (verbose) {
+    printf("[usbdpi] Stream test running with %u streams(s)\n", nstreams);
+    printf("[usbdpi] - retrieve %c checking %c retrying %c send %c\n",
+           retrieve ? 'Y' : 'N', checking ? 'Y' : 'N', retrying ? 'Y' : 'N',
+           send ? 'Y' : 'N');
+  }
+
+  // Remember the number of streams and initialize the arbitration of
+  // IN and OUT traffic
+  ctx->nstreams = nstreams;
+  ctx->stream_in = 0U;
+  ctx->stream_out = nstreams - 1U;
+
+  for (unsigned id = 0U; id < nstreams; id++) {
+    // Poll device for IN packets in streaming test?
+    ctx->stream[id].retrieve = retrieve;
+    // Attempt to sent OUT packets to device in streaming test?
+    ctx->stream[id].send = send;
+    // Checking of received data against expected LFSR output
+    ctx->stream[id].checking = checking;
+    // Request retrying of IN packets, feigning error
+    ctx->stream[id].retrying = retrying;
+    // Endpoints to be used by this stream
+    ctx->stream[id].ep_in = 1U + id;
+    ctx->stream[id].ep_out = 1U + id;
+    // LFSR state for this byte stream
+    ctx->stream[id].tst_lfsr = USBTST_LFSR_SEED(id);
+    ctx->stream[id].dpi_lfsr = USBDPI_LFSR_SEED(id);
+    // LFSR-controlled packet retrying state
+    ctx->stream[id].retry_lfsr = RETRY_LFSR_SEED(id);
+    ctx->stream[id].nretries = 0U;
+    // No received packets
+    ctx->stream[id].received = NULL;
+  }
+  return true;
+}
+
+// Check a data packet received from the test software (usbdev_stream_test)
+bool stream_data_check(usbdpi_ctx_t *ctx, usbdpi_stream_t *s,
+                       const usbdpi_transfer_t *rx, bool accept) {
+  assert(rx);
+
+  // The byte count _includes_ the DATAx PID and the two CRC bytes
+  //
+  // Note: we are expecting a LFSR-generated byte stream, but we do not
+  //       make assumptions about the number or size of the data packets
+  //       that make up the stream
+
+  unsigned num_bytes = transfer_length(rx);
+  unsigned idx = rx->data_start + 1u;  // Skip past the DATAx PID
+  bool ok = false;
+
+  // Validate the received packet - data length valid and checksum present
+  if (num_bytes >= sizeof(rx->data) || idx + 2u > num_bytes) {
+    printf("[usbdpi] Unexpected/malformed data packet (0x%x 0x%x)\n", idx,
+           num_bytes);
+  } else {
+    // Data field within received packet
+    const uint8_t *sp = &rx->data[idx];
+    num_bytes -= 3u;
+
+    // Check that the CRC16 checksum of the data field is as expected
+    uint16_t rx_crc = sp[num_bytes] | (sp[num_bytes + 1u] << 8);
+    uint16_t crc = CRC16(sp, num_bytes);
+    if (rx_crc != crc) {
+      printf("[usbdpi] Mismatched CRC16 0x%04x received, expected 0x%04x\n",
+             rx_crc, crc);
+    } else {
+      // Data toggle synchronization
+      unsigned pid = ctx->ep_in[s->ep_in].next_data;
+      if (rx->data[0] == pid) {
+        // If we've decided to reject this packet then we still check its
+        // content but we do not advance the data toggle because we're
+        // pretending that we didn't receive it successfully
+        if (accept) {
+          ctx->ep_in[s->ep_in].next_data = DATA_TOGGLE_ADVANCE(pid);
+        }
+
+        // Tentatively acceptable, but we still have to check and report any and
+        // all mismatched bytes
+        ok = accept;
+      }
+
+      // Iff running a performance investigation, checking may be undesired
+      // because it causes us to reject and retry the transmission
+      if (s->checking) {
+        // Note: use a local copy of the LFSR so that we can check the data
+        //       field even on those packets that we choose to reject
+        uint8_t tst_lfsr = s->tst_lfsr;
+        while (num_bytes-- > 0U) {
+          uint8_t recvd = *sp++;
+          if (recvd != tst_lfsr) {
+            printf(
+                "[usbdpi] Mismatched data from device 0x%02x, "
+                "expected 0x%02x\n",
+                recvd, tst_lfsr);
+            ok = false;
+          }
+          // Advance our local LFSR
+          tst_lfsr = LFSR_ADVANCE(tst_lfsr);
+        }
+
+        // Update the LFSR only if we've accepted valid data and will not
+        // be receiving this data again
+        if (accept && ok) {
+          s->tst_lfsr = tst_lfsr;
+        }
+      } else {
+        printf("[usbdpi] Warning: Stream data checking disabled\n");
+      }
+    }
+  }
+
+  return ok;
+}
+
+// Generate a data packet as if it had been received from the device
+usbdpi_transfer_t *stream_data_gen(usbdpi_ctx_t *ctx, usbdpi_stream_t *s,
+                                   unsigned len) {
+  usbdpi_transfer_t *tr = transfer_alloc(ctx);
+  if (tr) {
+    // Pretend that we have successfully received the packet with the correct
+    // data toggling...
+    uint8_t data = ctx->ep_in[s->ep_in].next_data;
+    ctx->ep_in[s->ep_in].next_data = DATA_TOGGLE_ADVANCE(data);
+    // ...and that the data is as expected
+    uint8_t *dp = transfer_data_start(tr, data, len);
+    for (unsigned idx = 0U; idx < len; idx++) {
+      dp[idx] = s->tst_lfsr;
+      s->tst_lfsr = LFSR_ADVANCE(s->tst_lfsr);
+    }
+    transfer_data_end(tr, dp + len);
+  }
+  return tr;
+}
+
+// Process a received data packet to produce a corresponding reply packet
+// by XORing our LFSR output with the received data
+//
+// Note: for now we do this even if the received data mismatches because
+//       only the CPU software has the capacity to decide upon and report
+//       test status
+usbdpi_transfer_t *stream_data_process(usbdpi_ctx_t *ctx, usbdpi_stream_t *s,
+                                       usbdpi_transfer_t *rx) {
+  // Note: checkStreamData has already been called on this packet
+  assert(rx);
+
+  // The byte count _includes_ the DATAx PID and the two CRC bytes
+  unsigned num_bytes = rx->num_bytes;
+  unsigned idx = rx->data_start + 1u;  // Skip past the DATAx PID
+
+  // Data field within received packet
+  const uint8_t *sp = &rx->data[idx];
+  num_bytes -= 3u;
+
+  // Allocate a new buffer for the reply
+  usbdpi_transfer_t *reply = transfer_alloc(ctx);
+  assert(reply);
+
+  // Construct OUT token packet to the target endpoint, using the
+  // appropriate DATAx PID
+  const uint8_t ep_out = s->ep_out;
+  transfer_token(reply, USB_PID_OUT, ctx->dev_address, ep_out);
+  uint8_t *dp =
+      transfer_data_start(reply, ctx->ep_out[ep_out].next_data, num_bytes);
+  assert(dp);
+
+  while (num_bytes-- > 0U) {
+    uint8_t recvd = *sp++;
+
+    // Simply XOR the two LFSR-generated streams together
+    *dp++ = recvd ^ s->dpi_lfsr;
+    if (verbose) {
+      printf("[usbdpi] 0x%02x <- 0x%02x ^ 0x%02x\n", *(dp - 1), recvd,
+             s->dpi_lfsr);
+    }
+
+    // Advance our LFSR
+    //
+    // TODO - decide whether we want to do this here; if the device
+    // responds with a NAK, requiring us to retry, or we decide to
+    // resend the packet, then we don't want to advance again
+    s->dpi_lfsr = LFSR_ADVANCE(s->dpi_lfsr);
+  }
+
+  transfer_data_end(reply, dp);
+
+  return reply;
+}
+
+// Check the stream signature
+bool stream_sig_check(usbdpi_ctx_t *ctx, usbdpi_stream_t *s,
+                      usbdpi_transfer_t *rx) {
+  // Packet should be PID, data field and CRC16
+  if (transfer_length(rx) == 3U + 0x10U) {
+    const uint8_t *sig = transfer_data_field(rx);
+    if (sig) {
+      // Signature format:
+      //   Bits Description
+      //   32   head signature
+      //   8    initial vaue of LFSR
+      //   8    stream number
+      //   16   reserved, SBZ
+      //   32   number of bytes to be transferred
+      //   32   tail signature
+      // Note: all 32-bit quantities are in little endian order
+
+      uint32_t num_bytes = get_le32(&sig[8]);
+      if (verbose) {
+        printf("[usbdpi] Stream signature at %p head 0x%x tail 0x%x\n", sig,
+               get_le32(&sig[0]), get_le32(&sig[12]));
+      }
+
+      // Basic validation check; words are transmitted in little endian order
+      if (get_le32(&sig[0]) == STREAM_SIGNATURE_HEAD &&
+          get_le32(&sig[12]) == STREAM_SIGNATURE_TAIL &&
+          // sanity check on transfer length, though we rely upon the CPU
+          // oftware to send, receive and count the number of bytes
+          num_bytes > 0U && num_bytes < 0x10000000U && !sig[6] && !sig[7]) {
+        // Signature includes the initial value of the device-side LFSR
+        s->tst_lfsr = sig[4];
+        // Update data toggle
+        uint8_t pid = transfer_data_pid(rx);
+        ctx->ep_in[s->ep_in].next_data = DATA_TOGGLE_ADVANCE(pid);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Service streaming data (usbdev_stream_test)
+void streams_service(usbdpi_ctx_t *ctx) {
+  if (verbose) {
+    //    printf("[usbdpi] streams_service hostSt %u in %u out %u\n",
+    //    ctx->hostSt,
+    //           ctx->stream_in, ctx->stream_out);
+  }
+
+  // Maximum time for transmission of a packet ought to be circa 80 bytes of
+  // data, 640 bits. Allowing for bitstuffing this means we need to leave ~800
+  const unsigned min_time_left = 800U;
+
+  switch (ctx->hostSt) {
+    // --------------------------------------------
+    // Try to transmit a data packet to the device
+    // --------------------------------------------
+    case HS_STARTFRAME:
+    case HS_STREAMOUT: {
+      // Decide whether we have enough time within this frame to attempt
+      // another transmission
+      uint32_t next_frame = ctx->frame_start + FRAME_INTERVAL;
+      if ((next_frame - ctx->tick_bits) > min_time_left) {  // HACK
+        unsigned id = out_stream_next(ctx);
+        usbdpi_stream_t *s = &ctx->stream[id];
+        if (s->send) {
+          // Start by trying to transmit a data packet that we've received, if
+          // any
+          if (s->received) {
+            if (ctx->sending) {
+              transfer_release(ctx, ctx->sending);
+            }
+
+            // Scramble the oldest received packet with our LFSR-generated byte
+            // stream and send it to the device
+            usbdpi_transfer_t *reply = stream_data_process(ctx, s, s->received);
+            transfer_send(ctx, reply);
+
+            uint32_t max_bits =
+                transfer_length(ctx->sending) * 10 + 160;  // HACK
+            ctx->wait = USBDPI_TIMEOUT(ctx, max_bits);
+            ctx->bus_state = kUsbBulkOut;
+            ctx->lastrxpid = 0;
+            ctx->hostSt = HS_WAITACK;
+          } else {
+            // Nothing to send, try receiving...
+            ctx->hostSt = HS_STREAMIN;
+          }
+        } else {
+          // We're not sending anything - discard any received data
+          while (s->received) {
+            usbdpi_transfer_t *tr = s->received;
+            s->received = tr->next;
+            transfer_release(ctx, tr);
+          }
+          ctx->hostSt = HS_STREAMIN;
+        }
+      } else {
+        // Wait until the next bus frame
+        ctx->hostSt = HS_NEXTFRAME;
+      }
+    } break;
+
+    // Await acknowledgement of the packet that we just transmitted
+    case HS_WAITACK:
+      if (ctx->sending) {
+        // Forget reference to the buffer we just tried to send; the received
+        // packet remains in the list of received buffers to try again later
+        transfer_release(ctx, ctx->sending);
+        ctx->sending = NULL;
+      }
+
+      if (ctx->bus_state == kUsbBulkOutAck) {
+        bool proceed = false;
+
+        if (verbose) {
+          printf("[usbdpi] OUT - response is PID 0x%02x from device (%s)\n",
+                 ctx->lastrxpid, decode_pid(ctx->lastrxpid));
+        }
+
+        switch (ctx->lastrxpid) {
+          case USB_PID_ACK: {
+            // Transmitted packet was accepted, so we can retire it...
+            usbdpi_stream_t *s = &ctx->stream[ctx->stream_out];
+            usbdpi_transfer_t *rx = s->received;
+            assert(rx);
+            s->received = rx->next;
+            transfer_release(ctx, rx);
+
+            uint8_t ep_out = s->ep_out;
+            ctx->ep_out[ep_out].next_data =
+                DATA_TOGGLE_ADVANCE(ctx->ep_out[ep_out].next_data);
+            proceed = true;
+          } break;
+
+          // We may receive a NAK from the device if it is unable to receive the
+          // packet right now
+          case USB_PID_NAK:
+            printf(
+                "[usbdpi] frame 0x%x tick_bits 0x%x NAK received from device\n",
+                ctx->frame, ctx->tick_bits);
+            proceed = true;
+            break;
+
+          default:
+            printf("[usbdpi] Unexpected PID 0x%02x from device (%s)\n",
+                   ctx->lastrxpid, decode_pid(ctx->lastrxpid));
+            ctx->hostSt = HS_NEXTFRAME;
+            break;
+        }
+
+        ctx->hostSt = proceed ? HS_STREAMIN : HS_NEXTFRAME;
+      } else if (ctx->tick_bits >= ctx->wait) {
+        printf("[usbdpi] Timed out waiting for OUT response\n");
+        ctx->hostSt = HS_NEXTFRAME;
+      }
+      break;
+
+    // ---------------------------------------------
+    // Try to collect a data packet from the device
+    // ---------------------------------------------
+    case HS_STREAMIN: {
+      // Decide whether we have enough time within this frame to attempt
+      // another fetch
+      //
+      // TODO - find out what the host behaviour should be at this point;
+      //        the device must be required to respond within a certain
+      //        time interval, and then the bus transmission speed
+      //        determines the maximum delay
+      uint32_t next_frame = ctx->frame_start + FRAME_INTERVAL;
+      if ((next_frame - ctx->tick_bits) > min_time_left) {  // HACK
+        unsigned id = in_stream_next(ctx);
+        usbdpi_stream_t *s = &ctx->stream[id];
+        if (s->retrieve) {
+          // Ensure that a buffer is available for constructing a transfer
+          usbdpi_transfer_t *tr = ctx->sending;
+          if (!tr) {
+            tr = transfer_alloc(ctx);
+            assert(tr);
+
+            ctx->sending = tr;
+          }
+
+          transfer_token(tr, USB_PID_IN, ctx->dev_address, s->ep_in);
+
+          transfer_send(ctx, tr);
+          ctx->bus_state = kUsbBulkInToken;
+          ctx->hostSt = HS_WAIT_PKT;
+          ctx->lastrxpid = 0;
+        } else {
+          // We're not required to poll for IN data, but if we're sending we
+          //   must still fake the reception of valid packet data because
+          //   the sw test will be expecting valid data
+          if (s->send && !s->received) {
+            // For simplicity we just create max length packets
+            const unsigned len = USBDEV_MAX_PACKET_SIZE;
+            s->received = stream_data_gen(ctx, s, len);
+          }
+          ctx->hostSt = HS_STREAMOUT;
+        }
+      } else {
+        // Wait until the next bus frame
+        ctx->hostSt = HS_NEXTFRAME;
+      }
+    } break;
+
+    case HS_WAIT_PKT:
+      // Wait max time for a response + packet
+      ctx->wait = ctx->tick_bits + 18 + 8 + 8 + 64 * 8 + 16;
+      ctx->hostSt = HS_ACKIFDATA;
+      break;
+    case HS_ACKIFDATA:
+      if (ctx->bus_state == kUsbBulkInData && ctx->recving) {
+        // We have a response from the device
+        switch (ctx->lastrxpid) {
+          case USB_PID_DATA0:
+          case USB_PID_DATA1: {
+            // Steal the received packet; it belongs to the stream
+            usbdpi_transfer_t *rx = ctx->recving;
+            ctx->recving = NULL;
+            // Decide whether we want to ACK or NAK this packet
+            unsigned id = ctx->stream_in;
+            usbdpi_stream_t *s = &ctx->stream[id];
+            bool accept = false;
+            if (s->retrying && s->nretries) {
+              s->nretries--;
+            } else {
+              // Decide the number of retries for the next data packet
+              // Note: by randomizing the number of retries, rather than
+              // independently deciding each accept/reject, we guarantee an
+              // upper bound on the run time
+              switch (s->retry_lfsr & 7U) {
+                case 7U:
+                  s->nretries = 3U;
+                  break;
+                case 6U:
+                case 5U:
+                  s->nretries = 2U;
+                  break;
+                case 4U:
+                  s->nretries = 1U;
+                  break;
+                default:
+                  s->nretries = 0U;
+                  break;
+              }
+              s->retry_lfsr = LFSR_ADVANCE(s->retry_lfsr);
+              accept = true;
+            }
+            if (!accept) {
+              printf("[usbdpi] Requesting resend of data\n");
+              usb_monitor_log(ctx->mon, "[usbdpi] Requesting resend of data\n");
+            }
+
+            if (expect_sig && !s->sig_recvd) {
+              // Note: the stream signature is primarily of use on a physical
+              // USB connection to a host since the endpoint to port mapping is
+              // variable. With t-l sim we can rely upon the first packet being
+              // the signature and nothing else
+              accept = stream_sig_check(ctx, s, rx);
+              transfer_release(ctx, rx);
+              // TODO - run time error, signal test failure to the software
+              assert(accept);
+              if (accept) {
+                s->sig_recvd = true;
+              }
+            } else {
+              if (stream_data_check(ctx, s, rx, accept)) {
+                // Collect the received packets in preparation for later
+                // transmission with modification back to the device
+                usbdpi_transfer_t *tr = s->received;
+                if (tr) {
+                  while (tr->next)
+                    tr = tr->next;
+                  tr->next = rx;
+                } else {
+                  s->received = rx;
+                }
+              } else {
+                transfer_release(ctx, rx);
+                accept = false;
+              }
+            }
+
+            usbdpi_transfer_t *tr = ctx->sending;
+            assert(tr);
+
+            transfer_status(ctx, tr, accept ? USB_PID_ACK : USB_PID_NAK);
+
+            ctx->hostSt = HS_STREAMOUT;
+          } break;
+
+          case USB_PID_NAK:
+            // No data available
+            ctx->hostSt = HS_STREAMOUT;
+            break;
+
+          default:
+            printf("[usbdpi] Unexpected PID 0x%02x from device (%s)\n",
+                   ctx->lastrxpid, decode_pid(ctx->lastrxpid));
+            ctx->hostSt = HS_NEXTFRAME;
+            break;
+        }
+      } else if (ctx->tick_bits >= ctx->wait) {
+        printf("[usbdpi] Timed out waiting for IN response\n");
+        ctx->hostSt = HS_NEXTFRAME;
+      }
+      break;
+
+    default:
+      break;
+  }
+}
diff --git a/hw/dv/dpi/usbdpi/usbdpi_stream.h b/hw/dv/dpi/usbdpi/usbdpi_stream.h
new file mode 100644
index 0000000..a48acfc
--- /dev/null
+++ b/hw/dv/dpi/usbdpi/usbdpi_stream.h
@@ -0,0 +1,89 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef OPENTITAN_HW_DV_DPI_USBDPI_USBDPI_STREAM_H_
+#define OPENTITAN_HW_DV_DPI_USBDPI_USBDPI_STREAM_H_
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "usb_transfer.h"
+
+// Forwards declaration of USBDPI context
+typedef struct usbdpi_ctx usbdpi_ctx_t;
+
+// Context for streaming data test (usbdev_stream_test)
+typedef struct usbdpi_stream {
+  /**
+   * Test requires polling device for IN packets
+   */
+  bool retrieve;
+  /**
+   * Test requires attempting to send OUT packets to device
+   */
+  bool send;
+  /**
+   * Request trying of IN packets, feigning error
+   */
+  bool retrying;
+  /**
+   * Checking of received byte stream; disable iff
+   * investigating IN performance
+   */
+  bool checking;
+  /**
+   * Have we received the stream signature yet?
+   */
+  bool sig_recvd;
+  /**
+   * Device endpoint from which IN packets are retrieved
+   */
+  uint8_t ep_in;
+  /**
+   * Device endpoint to which OUT packets are sent
+   */
+  uint8_t ep_out;
+  /**
+   * Device-generated LFSR; predicts data expected from usbdev_stream_test
+   */
+  uint8_t tst_lfsr;
+  /**
+   * DPI-generated LFSR-generated data, to be combined with received data
+   */
+  uint8_t dpi_lfsr;
+  /**
+   * LFSR state for p-randomized retrying of received data
+   */
+  uint8_t retry_lfsr;
+  /**
+   * Number of times (still) to retry before accepting the current data packet
+   */
+  uint8_t nretries;
+  /***
+   * Linked-list of received transfers
+   */
+  usbdpi_transfer_t *received;
+} usbdpi_stream_t;
+
+/**
+ * Initialize streaming state for the given number of streams
+ *
+ * @param  ctx       USBDPI context state
+ * @param  nstreams  Number of concurrent byte streams
+ * @param  retrieve  Retrieve IN packets from device
+ * @param  checking  Checking of received data against expected LFSR output
+ * @param  retrying  Request retrying of IN packets, feigning error
+ * @param  send      Attempt to send OUT packets to device
+ * @return           true iff initialized successfully
+ */
+bool streams_init(usbdpi_ctx_t *ctx, unsigned nstreams, bool retrieve,
+                  bool checking, bool retrying, bool send);
+
+/**
+ * Service streaming data (usbdev_stream_test)
+ *
+ * @param  ctx       USBDPI context state
+ */
+void streams_service(usbdpi_ctx_t *ctx);
+
+#endif  // OPENTITAN_HW_DV_DPI_USBDPI_USBDPI_STREAM_H_
diff --git a/hw/dv/dpi/usbdpi/usbdpi_test.c b/hw/dv/dpi/usbdpi/usbdpi_test.c
index 1d9492c..8c8236e 100644
--- a/hw/dv/dpi/usbdpi/usbdpi_test.c
+++ b/hw/dv/dpi/usbdpi/usbdpi_test.c
@@ -6,6 +6,8 @@
 
 #include <assert.h>
 
+#include "usbdpi_stream.h"
+
 // Test-specific initialization
 void usbdpi_test_init(usbdpi_ctx_t *ctx) {
   // Test-specific initialization code
@@ -17,6 +19,24 @@
       bOK = true;
       break;
 
+    // Initialize streaming test
+    case 1: {
+      // Number of concurrent byte streams
+      const unsigned nstreams = ctx->test_arg[0] & 0xfU;
+      // Poll device for IN packets in streaming test?
+      bool retrieve = (ctx->test_arg[0] & 0x10U) != 0U;
+      // Checking of received data against expected LFSR output
+      bool checking = (ctx->test_arg[0] & 0x20U) != 0U;
+      // Request retrying of IN packets, feigning error
+      bool retrying = (ctx->test_arg[0] & 0x40U) != 0U;
+      // Attempt to send OUT packets to device
+      bool send = (ctx->test_arg[0] & 0x80U) != 0U;
+
+      if (nstreams <= USBDPI_MAX_STREAMS) {
+        bOK = streams_init(ctx, nstreams, retrieve, checking, retrying, send);
+      }
+    } break;
+
     default:
       assert(!"Unrecognised/unsupported test in USBDPI");
       break;
diff --git a/sw/device/tests/BUILD b/sw/device/tests/BUILD
index ee5b006..4ec67c3 100644
--- a/sw/device/tests/BUILD
+++ b/sw/device/tests/BUILD
@@ -1924,6 +1924,30 @@
 )
 
 opentitan_functest(
+    name = "usbdev_stream_test",
+    srcs = ["usbdev_stream_test.c"],
+    cw310 = cw310_params(
+        timeout = "eternal",
+    ),
+    targets = [
+        "verilator",
+        "cw310_test_rom",
+    ],
+    verilator = verilator_params(
+        timeout = "long",
+    ),
+    deps = [
+        "//hw/top_earlgrey/sw/autogen:top_earlgrey",
+        "//sw/device/lib/dif:pinmux",
+        "//sw/device/lib/runtime:log",
+        "//sw/device/lib/runtime:print",
+        "//sw/device/lib/testing:pinmux_testutils",
+        "//sw/device/lib/testing:usb_testutils",
+        "//sw/device/lib/testing/test_framework:ottf_main",
+    ],
+)
+
+opentitan_functest(
     name = "rstmgr_alert_info_test",
     srcs = ["rstmgr_alert_info_test.c"],
     cw310 = cw310_params(
diff --git a/sw/device/tests/usbdev_stream_test.c b/sw/device/tests/usbdev_stream_test.c
new file mode 100644
index 0000000..427582a
--- /dev/null
+++ b/sw/device/tests/usbdev_stream_test.c
@@ -0,0 +1,753 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+//
+// USB streaming data test
+//
+// This test requires interaction with the USB DPI model or a test application
+// on the USB host. The test initializes the USB device and configures a set of
+// endpoints for data streaming using bulk transfers.
+//
+// The DPI model mimicks an USB host. After device initialization, it detects
+// the assertion of the pullup and first assigns an address to the device.
+// For this test it will then repeatedly fetch data via IN requests to
+// each stream and propagate that data to the corresponding OUT endpoints.
+//
+// The data itself is pseudo-randomly generated by the sender and,
+// independently, by the receiving code to check that the data has been
+// propapgated unmodified and without data loss, corruption, replication etc.
+
+#include "sw/device/lib/dif/dif_pinmux.h"
+#include "sw/device/lib/runtime/log.h"
+#include "sw/device/lib/runtime/print.h"
+#include "sw/device/lib/testing/pinmux_testutils.h"
+#include "sw/device/lib/testing/test_framework/check.h"
+#include "sw/device/lib/testing/test_framework/ottf_main.h"
+#include "sw/device/lib/testing/usb_testutils.h"
+#include "sw/device/lib/testing/usb_testutils_controlep.h"
+
+#include "hw/top_earlgrey/sw/autogen/top_earlgrey.h"  // Generated.
+
+// Maximum number of concurrent streams
+#ifdef USBDEV_NUM_ENDPOINTS
+// Endpoint zero implements the default control pipe
+#define STREAMS_MAX (USBDEV_NUM_ENDPOINTS - 1U)
+#else
+#define STREAMS_MAX 11U
+#endif
+
+// TODO - currently we are unable to send the configuration descriptor
+// if we try to describe more than two bidirectional endpoints
+#if STREAMS_MAX > 2U
+#undef STREAMS_MAX
+#define STREAMS_MAX 2U
+#endif
+
+// Number of streams to be tested
+#ifndef NUM_STREAMS
+#define NUM_STREAMS STREAMS_MAX
+#endif
+
+// Maximum number of buffer simultaneously awaiting transmission
+// (we must leave some available for packet reception)
+#ifndef MAX_TX_BUFFERS
+#define MAX_TX_BUFFERS 24U
+#endif
+
+// This takes about 256s presently with 10MHz CPU in CW-310 FPGA and physical
+// USB with randomized packet sizes and the default memcpy implementation;
+// The _MEM_FASTER switch drops the run time to 187s
+#define TRANSFER_BYTES_FPGA (0x10U << 20)
+
+// This is appropriate for a Verilator chip simulation with 15 min timeout
+#define TRANSFER_BYTES_VERILATOR 0x2400U
+
+// This is about the amount that we can transfer within a 1 hour 'eternal' test
+//#define TRANSFER_BYTES_LONG (0xD0U << 20)
+
+// Stream signature words
+#define STREAM_SIGNATURE_HEAD 0x579EA01AU
+#define STREAM_SIGNATURE_TAIL 0x160AE975U
+
+// Seed numbers for the LFSR generators in each transfer direction for
+// the given stream number
+#define USBTST_LFSR_SEED(s) (uint8_t)(0x10U + (s)*7U)
+#define USBDPI_LFSR_SEED(s) (uint8_t)(0x9BU - (s)*7U)
+
+// Buffer size randomization
+#define BUFSZ_LFSR_SEED(s) (uint8_t)(0x17U + (s)*7U)
+
+// Simple LFSR for 8-bit sequences
+// Note: zero is an isolated state that shall be avoided
+#define LFSR_ADVANCE(lfsr) \
+  (((lfsr) << 1) ^         \
+   ((((lfsr) >> 1) ^ ((lfsr) >> 2) ^ ((lfsr) >> 3) ^ ((lfsr) >> 7)) & 1U))
+
+// Forward declaration to context state
+typedef struct usbdev_stream_test_ctx usbdev_stream_test_ctx_t;
+
+/**
+ * Stream signature
+ * Note: this needs to be transferred over a byte stream
+ */
+typedef struct __attribute__((packed)) usbdev_stream_sig {
+  /**
+   * Head signature word
+   */
+  uint32_t head_sig;
+  /**
+   * Initial value of LFSR
+   */
+  uint8_t init_lfsr;
+  /**
+   * Stream number
+   */
+  uint8_t stream;
+  /**
+   * Reserved fields; should be zero
+   */
+  uint8_t reserved1;
+  uint8_t reserved2;
+  /**
+   * Number of bytes to be transferred
+   */
+  uint32_t num_bytes;
+  /**
+   * Tail signature word
+   */
+  uint32_t tail_sig;
+} usbdev_stream_sig_t;
+
+/**
+ * Context state for a single stream
+ */
+typedef struct usbdev_stream {
+  /**
+   * Pointer to test context; callback functions receive only stream pointer
+   */
+  usbdev_stream_test_ctx_t *ctx;
+  /**
+   * Stream IDentifier
+   */
+  uint8_t id;
+  /**
+   * Has the stream signature been sent yet?
+   */
+  bool sent_sig;
+  /**
+   * USB device endpoint being used for data transmission
+   */
+  uint8_t tx_ep;
+  /**
+   * Transmission Linear Feedback Shift Register (for PRND data generation)
+   */
+  uint8_t tx_lfsr;
+  /**
+   * Total number of bytes presented to the USB device for transmission
+   */
+  uint32_t tx_bytes;
+  /**
+   * Transmission-side LFSR for selection of buffer size
+   */
+  uint8_t tx_buf_size;
+
+  /**
+   * USB device endpoint being used for data reception
+   */
+  uint8_t rx_ep;
+  /**
+   * Reception-side LFSR state (mirrors USBDPI generation of PRND data)
+   */
+  uint8_t rx_lfsr;
+  /**
+   * Reception-side shadow of transmission LFSR
+   */
+  uint8_t rxtx_lfsr;
+  /**
+   * Total number of bytes received from the USB device
+   */
+  uint32_t rx_bytes;
+  /**
+   * Size of transfer in bytes
+   */
+  uint32_t transfer_bytes;
+} usbdev_stream_t;
+
+/**
+ * Context state for streaming test
+ */
+struct usbdev_stream_test_ctx {
+  /**
+   * Context pointer
+   */
+  usb_testutils_ctx_t *usbdev;
+  /**
+   * State information for each of the test streams
+   */
+  usbdev_stream_t streams[STREAMS_MAX];
+  /**
+   * Per-endpoint limits on the number of buffers that may be queued for
+   * transmission
+   */
+  uint8_t tx_bufs_limit[USBDEV_NUM_ENDPOINTS];
+  /**
+   * Per-endpoint counts of completed buffers queued for transmission
+   */
+  uint8_t tx_bufs_queued[USBDEV_NUM_ENDPOINTS];
+  /**
+   * Total number of completed buffers
+   */
+  uint8_t tx_queued_total;
+  /**
+   * Buffers that have been filled but cannot yet be presented for transmission
+   * TODO - perhaps absorb the buffer queuing into usb_testutils because the dif
+   * API is explicitly not robust against back-to-back sending of multiple
+   * buffers to a single endpoint, and because the read performance is reliant
+   * upon having additional buffer(s) already available for immediate
+   * presentation
+   */
+  // 12 X 24 X 4 (or 8?)( BYTES... could perhaps simplify this at some point
+  dif_usbdev_buffer_t tx_bufs[USBDEV_NUM_ENDPOINTS][MAX_TX_BUFFERS];
+};
+
+/**
+ * Configuration values for USB.
+ * TODO - dymamically construct a config descriptor appropriate to the test;
+ *        this would avoid creating unusable ports on the host and also provide
+ *        a little more testing
+ */
+static const uint8_t config_descriptors[] = {
+    USB_CFG_DSCR_HEAD(USB_CFG_DSCR_LEN + STREAMS_MAX * (USB_INTERFACE_DSCR_LEN +
+                                                        2 * USB_EP_DSCR_LEN),
+                      STREAMS_MAX),
+
+    VEND_INTERFACE_DSCR(0, 2, 0x50, 1),
+    USB_BULK_EP_DSCR(0, 1U, USBDEV_MAX_PACKET_SIZE, 0),
+    USB_BULK_EP_DSCR(1, 1U, USBDEV_MAX_PACKET_SIZE, 0),
+
+    VEND_INTERFACE_DSCR(1, 2, 0x50, 1),
+    USB_BULK_EP_DSCR(0, 2U, USBDEV_MAX_PACKET_SIZE, 0),
+    USB_BULK_EP_DSCR(1, 2U, USBDEV_MAX_PACKET_SIZE, 0),
+};
+
+/**
+ * Test descriptor
+ */
+static const uint8_t test_descriptor[] = {
+    USB_TESTUTILS_TEST_DSCR(1, NUM_STREAMS | 0xF0U, 0, 0, 0)};
+
+/**
+ * USB device context types.
+ */
+static usb_testutils_ctx_t usbdev;
+static usb_testutils_controlep_ctx_t usbdev_control;
+
+/**
+ * Pinmux handle
+ */
+static dif_pinmux_t pinmux;
+
+/**
+ * State information for streaming data test
+ */
+static usbdev_stream_test_ctx_t stream_test;
+
+/**
+ * Specify whether to perform verbose logging, for visibility
+ *   (Note that this substantially alters the timing of interactions with the
+ * DPI model and will increase the simulation time)
+ */
+static bool verbose = false;
+
+/**
+ * Send only maximal length packets?
+ * (important for performance measurements on the USB, but obviously undesirable
+ *  for testing reliability/function)
+ */
+static bool max_packets = false;
+
+/**
+ * Number of streams to be created
+ */
+static const unsigned nstreams = NUM_STREAMS;
+
+/**
+ * Diagnostic logging; expensive
+ */
+static bool log_traffic = false;
+
+// Dump a sequence of bytes as hexadecimal and ASCII for diagnostic purposes
+static void buffer_dump(const uint8_t *data, size_t n) {
+  static const char hex_digits[] = "0123456789abcdef";
+  const unsigned ncols = 0x20u;
+  char buf[ncols * 4u + 2u];
+
+  // Note: we have no generic (s(n))printf functionality and must use LOG_INFO()
+  while (n > 0u) {
+    const unsigned chunk = (n > ncols) ? ncols : (unsigned)n;
+    const uint8_t *row = data;
+    unsigned idx = 0u;
+    char *dp = buf;
+
+    // Columns of hexadecimal bytes
+    while (idx < chunk) {
+      dp[0] = hex_digits[row[idx] >> 4];
+      dp[1] = hex_digits[row[idx++] & 0xfu];
+      dp[2] = ' ';
+      dp += 3;
+    }
+    while (idx++ < ncols) {
+      dp[2] = dp[1] = dp[0] = ' ';
+      dp += 3;
+    }
+
+    // Printable ASCII characters
+    for (unsigned idx = 0u; idx < chunk; idx++) {
+      char ch = row[idx];
+      *dp++ = (ch < ' ' || ch >= 0x80u) ? '.' : ch;
+    }
+    *dp = '\0';
+    LOG_INFO("%s", buf);
+    data += chunk;
+    n -= chunk;
+  }
+}
+
+// Create a stream signature buffer
+static uint32_t buffer_sig_create(usbdev_stream_t *s,
+                                  dif_usbdev_buffer_t *buf) {
+  usbdev_stream_sig_t sig;
+
+  sig.head_sig = STREAM_SIGNATURE_HEAD;
+  sig.init_lfsr = s->tx_lfsr;
+  sig.stream = s->id;
+  sig.reserved1 = 0U;
+  sig.reserved2 = 0U;
+  sig.num_bytes = s->transfer_bytes;
+  sig.tail_sig = STREAM_SIGNATURE_TAIL;
+
+  // Sanity check because the host-side code relies upon the same structure
+  CHECK(sizeof(sig) == 0x10U);
+
+  size_t bytes_written;
+  CHECK_DIF_OK(dif_usbdev_buffer_write(usbdev.dev, buf, (uint8_t *)&sig,
+                                       sizeof(sig), &bytes_written));
+  CHECK(bytes_written == sizeof(sig));
+
+  // Note: stream signature is not included in the count of bytes transferred
+
+  return bytes_written;
+}
+
+// Fill a buffer with LFSR-generated data
+static void buffer_fill(usbdev_stream_t *s, dif_usbdev_buffer_t *buf,
+                        uint8_t num_bytes) {
+  alignas(uint32_t) uint8_t data[USBDEV_MAX_PACKET_SIZE];
+
+  CHECK(num_bytes <= buf->remaining_bytes);
+  CHECK(num_bytes <= sizeof(data));
+
+  if (true) {
+    // Emit LFSR-generated byte stream; keep this brief so that we can
+    // reduce our latency in responding to USB events (usb_testutils employs
+    // polling at present)
+    uint8_t lfsr = s->tx_lfsr;
+
+    const uint8_t *edp = &data[num_bytes];
+    uint8_t *dp = data;
+    while (dp < edp) {
+      *dp++ = lfsr;
+      lfsr = LFSR_ADVANCE(lfsr);
+    }
+
+    // Update the LFSR for the next packet
+    s->tx_lfsr = lfsr;
+  } else {
+    // Undefined buffer contents
+  }
+
+  if (verbose && log_traffic) {
+    buffer_dump(data, num_bytes);
+  }
+
+  size_t bytes_written;
+
+  CHECK_DIF_OK(dif_usbdev_buffer_write(usbdev.dev, buf, data, num_bytes,
+                                       &bytes_written));
+  CHECK(bytes_written == num_bytes);
+  s->tx_bytes += bytes_written;
+}
+
+// Check the contents of a received buffer
+static void buffer_check(usbdev_stream_test_ctx_t *ctx, usbdev_stream_t *s,
+                         dif_usbdev_rx_packet_info_t packet_info,
+                         dif_usbdev_buffer_t buf) {
+  usb_testutils_ctx_t *usbdev = ctx->usbdev;
+  uint8_t len = packet_info.length;
+
+  if (len > 0) {
+    alignas(uint32_t) uint8_t data[USBDEV_MAX_PACKET_SIZE];
+
+    CHECK(len <= sizeof(data));
+
+    size_t bytes_read;
+
+    // Notes: the buffer being read here is USBDEV memory accessed as MMIO, so
+    //        only the DIF accesses it directly. when we consume the final bytes
+    //        from the read buffer, it is automatically returned to the buffer
+    //        pool.
+    CHECK_DIF_OK(dif_usbdev_buffer_read(usbdev->dev, usbdev->buffer_pool, &buf,
+                                        data, len, &bytes_read));
+    CHECK(bytes_read == len);
+
+    if (log_traffic) {
+      buffer_dump(data, bytes_read);
+    }
+
+    // Check received data against expected LFSR-generated byte stream;
+    // keep this brief so that we can reduce our latency in responding to
+    // USB events (usb_testutils employs polling at present)
+    uint8_t rxtx_lfsr = s->rxtx_lfsr;
+    uint8_t rx_lfsr = s->rx_lfsr;
+
+    const uint8_t *esp = &data[bytes_read];
+    const uint8_t *sp = data;
+    while (sp < esp) {
+      // Received data should be the XOR of two LFSR-generated PRND streams -
+      // ours on the
+      //   transmission side, and that of the DPI model
+      uint8_t expected = rxtx_lfsr ^ rx_lfsr;
+      CHECK(expected == *sp,
+            "S%u: Unexpected received data 0x%02x : (LFSRs 0x%02x 0x%02x)",
+            s->id, *sp, rxtx_lfsr, rx_lfsr);
+
+      rxtx_lfsr = LFSR_ADVANCE(rxtx_lfsr);
+      rx_lfsr = LFSR_ADVANCE(rx_lfsr);
+      sp++;
+    }
+
+    // Update the LFSRs for the next packet
+    s->rxtx_lfsr = rxtx_lfsr;
+    s->rx_lfsr = rx_lfsr;
+  } else {
+    // In the event that we've received a zero-length data packet, we still
+    // must return the buffer to the pool
+    CHECK_DIF_OK(
+        dif_usbdev_buffer_return(usbdev->dev, usbdev->buffer_pool, &buf));
+  }
+}
+
+// Callback for successful buffer transmission
+static void strm_tx_done(void *stream_v) {
+  usbdev_stream_t *s = (usbdev_stream_t *)stream_v;
+  usbdev_stream_test_ctx_t *ctx = s->ctx;
+  usb_testutils_ctx_t *usbdev = ctx->usbdev;
+
+  // If we do not have at least one queued buffer then something has gone wrong
+  // and this callback is inappropriate
+  uint8_t tx_ep = s->tx_ep;
+  uint8_t nqueued = ctx->tx_bufs_queued[tx_ep];
+
+  if (verbose) {
+    LOG_INFO("strm_tx_done called. %u (%u total) buffers(s) are queued",
+             nqueued, ctx->tx_queued_total);
+  }
+
+  CHECK(nqueued > 0);
+
+  // Note: since buffer transmission and completion signalling both occur within
+  // the foreground code (polling, not interrupt-driven) there is no issue of
+  // potential races here
+
+  if (nqueued > 0) {
+    // Shuffle the buffer descriptions, without using memmove
+    for (unsigned idx = 1u; idx < nqueued; idx++) {
+      ctx->tx_bufs[tx_ep][idx - 1u] = ctx->tx_bufs[tx_ep][idx];
+    }
+
+    // Is there another buffer ready to be transmitted?
+    ctx->tx_queued_total--;
+    ctx->tx_bufs_queued[tx_ep] = --nqueued;
+
+    if (nqueued) {
+      CHECK_DIF_OK(
+          dif_usbdev_send(usbdev->dev, tx_ep, &ctx->tx_bufs[tx_ep][0u]));
+    }
+  }
+}
+
+// Callback for buffer reception
+static void strm_rx(void *stream_v, dif_usbdev_rx_packet_info_t packet_info,
+                    dif_usbdev_buffer_t buf) {
+  usbdev_stream_t *s = (usbdev_stream_t *)stream_v;
+  usbdev_stream_test_ctx_t *ctx = s->ctx;
+  usb_testutils_ctx_t *usbdev = ctx->usbdev;
+
+  CHECK(packet_info.endpoint == s->rx_ep);
+
+  // We do not expect to receive SETUP packets to this endpoint
+  CHECK(!packet_info.is_setup);
+
+  if (verbose) {
+    LOG_INFO("Stream %u: Received buffer of %u bytes(s)", s->id,
+             packet_info.length);
+  }
+
+  if (true) {
+    buffer_check(ctx, s, packet_info, buf);
+  } else {
+    // Note: this is just test code for measuring the OUT throughput
+    usb_testutils_ctx_t *usbdev = ctx->usbdev;
+    CHECK_DIF_OK(
+        dif_usbdev_buffer_return(usbdev->dev, usbdev->buffer_pool, &buf));
+  }
+
+  s->rx_bytes += packet_info.length;
+}
+
+// Callback for unexpected data reception (IN endpoint)
+static void rx_show(void *stream_v, dif_usbdev_rx_packet_info_t packet_info,
+                    dif_usbdev_buffer_t buf) {
+  usbdev_stream_t *s = (usbdev_stream_t *)stream_v;
+  usbdev_stream_test_ctx_t *ctx = s->ctx;
+  usb_testutils_ctx_t *usbdev = ctx->usbdev;
+  uint8_t data[0x100U];
+  size_t bytes_read;
+  CHECK_DIF_OK(dif_usbdev_buffer_read(usbdev->dev, usbdev->buffer_pool, &buf,
+                                      data, packet_info.length, &bytes_read));
+  LOG_INFO("rx_show packet of %u byte(s) - read %u", packet_info.length,
+           bytes_read);
+  buffer_dump(data, bytes_read);
+}
+
+// Returns an indication of whether a stream has completed its data transfer
+bool stream_completed(const usbdev_stream_t *s) {
+  return (s->tx_bytes >= s->transfer_bytes) &&
+         (s->rx_bytes >= s->transfer_bytes);
+}
+
+// Initialise a stream, preparing it for use
+static void stream_init(usbdev_stream_test_ctx_t *ctx, usbdev_stream_t *s,
+                        uint8_t id, uint8_t ep_in, uint8_t ep_out,
+                        uint32_t transfer_bytes) {
+  // We need to be able to locate the test context given only the stream
+  // pointer within the strm_tx_done callback from usb_testutils
+  s->ctx = ctx;
+
+  // Remember the stream IDentifier
+  s->id = id;
+
+  // Not yet sent stream signature
+  s->sent_sig = false;
+
+  // Initialise the transfer state
+  s->tx_bytes = 0u;
+  s->rx_bytes = 0u;
+  s->transfer_bytes = transfer_bytes;
+
+  // Initialise the LFSR state for transmission and reception sides
+  // - we use a simple LFSR to generate a PRND stream to transmit to the USBPI
+  // - the USBDPI XORs the received data with another LFSR-generated stream of
+  //   its own, and transmits the result back to us
+  // - to check the returned data, our reception code mimics both LFSRs
+  s->tx_lfsr = USBTST_LFSR_SEED(id);
+  s->rxtx_lfsr = s->tx_lfsr;
+  s->rx_lfsr = USBDPI_LFSR_SEED(id);
+
+  // Packet size randomization
+  s->tx_buf_size = BUFSZ_LFSR_SEED(id);
+
+  // Set up the endpoint for IN transfers (TO host)
+  //
+  // Note: We install the rx_show handler to catch any misdirected data
+  // transfers
+  void (*rx)(void *, dif_usbdev_rx_packet_info_t, dif_usbdev_buffer_t) =
+      (ep_in == ep_out) ? strm_rx : rx_show;
+
+  s->tx_ep = ep_in;
+  usb_testutils_endpoint_setup(ctx->usbdev, ep_in, kUsbdevOutStream, s,
+                               strm_tx_done, rx, NULL, NULL);
+  s->rx_ep = ep_out;
+  if (ep_out != ep_in) {
+    // Set up the endpoint for OUT transfers (FROM host)
+    usb_testutils_endpoint_setup(ctx->usbdev, ep_out, kUsbdevOutStream, s, NULL,
+                                 strm_rx, NULL, NULL);
+  }
+}
+
+// Service the given stream, preparing and/or sending any data that we can;
+// data reception is handled via callbacks and requires no attention here
+static void stream_service(usbdev_stream_test_ctx_t *ctx, usbdev_stream_t *s) {
+  // Generate output data as soon as possible and make it available for
+  //   collection by the host
+
+  uint8_t tx_ep = s->tx_ep;
+  uint8_t nqueued = ctx->tx_bufs_queued[tx_ep];
+
+  if (s->tx_bytes < s->transfer_bytes &&        // More bytes to transfer?
+      nqueued < ctx->tx_bufs_limit[tx_ep] &&    // Endpoint allowed buffer?
+      ctx->tx_queued_total < MAX_TX_BUFFERS) {  // Total buffers not exceeded?
+    dif_usbdev_buffer_t buf;
+
+    // See whether we can populate another buffer yet
+    dif_result_t dif_result =
+        dif_usbdev_buffer_request(usbdev.dev, usbdev.buffer_pool, &buf);
+    if (dif_result == kDifOk) {
+      // This is just for reporting the number of buffers presented to the
+      // USB device, as a progress indicator
+      static unsigned bufs_sent = 0u;
+      uint32_t num_bytes;
+
+      if (s->sent_sig) {
+        if (max_packets) {
+          num_bytes = USBDEV_MAX_PACKET_SIZE;
+        } else {
+          // Vary the amount of data sent per buffer
+          num_bytes = s->tx_buf_size % (USBDEV_MAX_PACKET_SIZE + 1u);
+          s->tx_buf_size = LFSR_ADVANCE(s->tx_buf_size);
+        }
+        uint32_t tx_left = s->transfer_bytes - s->tx_bytes;
+        if (num_bytes > tx_left)
+          num_bytes = tx_left;
+
+        buffer_fill(s, &buf, num_bytes);
+      } else {
+        // Construct a signature to send to the host-side software,
+        // identifying the stream and its properties
+        num_bytes = buffer_sig_create(s, &buf);
+        s->sent_sig = true;
+      }
+
+      // Remember the buffer until we're informed that it has been
+      // successfully transmitted
+      //
+      // Note: since the 'tx_done' callback occurs from foreground code that
+      // is polling, there is no issue of interrupt races here
+      ctx->tx_bufs[tx_ep][nqueued] = buf;
+      ctx->tx_bufs_queued[tx_ep] = ++nqueued;
+      ctx->tx_queued_total++;
+
+      // Can we present this buffer for transmission yet?
+      if (nqueued <= 1U) {
+        CHECK_DIF_OK(dif_usbdev_send(usbdev.dev, tx_ep, &buf));
+      }
+
+      if (verbose) {
+        LOG_INFO(
+            "Stream %u: %uth buffer (of 0x%x byte(s)) awaiting transmission",
+            s->id, bufs_sent, num_bytes);
+      }
+      bufs_sent++;
+    } else {
+      // If we have no more buffers available right now, continue polling...
+      CHECK(dif_result == kDifUnavailable);
+    }
+  }
+}
+
+OTTF_DEFINE_TEST_CONFIG();
+
+bool test_main(void) {
+  // Context state for streaming test
+  usbdev_stream_test_ctx_t *ctx = &stream_test;
+
+  CHECK(kDeviceType == kDeviceSimVerilator || kDeviceType == kDeviceFpgaCw310,
+        "This test is not expected to run on platforms other than the "
+        "Verilator simulation or CW310 FPGA. It needs logic on the host side "
+        "to retrieve, scramble and return the generated byte stream");
+
+  LOG_INFO("Running USBDEV Stream Test");
+
+  // Check we can support the requested number of streams
+  CHECK(nstreams && nstreams < USBDEV_NUM_ENDPOINTS);
+
+  // Decide upon the number of bytes to be transferred for the entire test
+  uint32_t transfer_bytes = TRANSFER_BYTES_FPGA;
+  if (kDeviceType == kDeviceSimVerilator) {
+    transfer_bytes = TRANSFER_BYTES_VERILATOR;
+  }
+  transfer_bytes = (transfer_bytes + nstreams - 1) / nstreams;
+  LOG_INFO(" - %u stream(s), 0x%x bytes each", nstreams, transfer_bytes);
+
+  CHECK_DIF_OK(dif_pinmux_init(
+      mmio_region_from_addr(TOP_EARLGREY_PINMUX_AON_BASE_ADDR), &pinmux));
+  pinmux_testutils_init(&pinmux);
+  CHECK_DIF_OK(dif_pinmux_input_select(
+      &pinmux, kTopEarlgreyPinmuxPeripheralInUsbdevSense,
+      kTopEarlgreyPinmuxInselIoc7));
+
+  // Remember context state for usb_testutils context
+  ctx->usbdev = &usbdev;
+
+  // Call `usbdev_init` here so that DPI will not start until the
+  // simulation has finished all of the printing, which takes a while
+  // if `--trace` was passed in.
+  usb_testutils_init(ctx->usbdev, /*pinflip=*/false, /*en_diff_rcvr=*/false,
+                     /*tx_use_d_se0=*/false);
+  usb_testutils_controlep_init(&usbdev_control, ctx->usbdev, 0,
+                               config_descriptors, sizeof(config_descriptors),
+                               test_descriptor, sizeof(test_descriptor));
+  while (usbdev_control.device_state != kUsbTestutilsDeviceConfigured) {
+    usb_testutils_poll(ctx->usbdev);
+  }
+
+  // Initialise the state of each stream
+  for (unsigned id = 0U; id < nstreams; id++) {
+    // Which endpoint are we using for the IN transfers to the host?
+    const uint8_t ep_in = 1u + id;
+    // Which endpoint are we using for the OUT transfers from the host?
+    const uint8_t ep_out = 1u + id;
+    stream_init(ctx, &ctx->streams[id], id, ep_in, ep_out, transfer_bytes);
+  }
+
+  // Decide how many buffers each endpoint may queue up for transmission;
+  // we must ensure that there are buffers available for reception, and we
+  // do not want any endpoint to starve another
+  for (unsigned s = 0U; s < nstreams; s++) {
+    // This is slightly overspending the available buffers, leaving the
+    //   endpoints to vie for the final few buffers, so it's important that
+    //   we limit the total number of buffers across all endpoints too
+    unsigned ep = ctx->streams[s].tx_ep;
+    ctx->tx_bufs_queued[ep] = 0U;
+    ctx->tx_bufs_limit[ep] = (MAX_TX_BUFFERS + nstreams - 1) / nstreams;
+  }
+  ctx->tx_queued_total = 0U;
+
+  if (verbose) {
+    LOG_INFO("Commencing data transfer...");
+  }
+
+  bool bDone = false;
+  do {
+    for (unsigned s = 0U; s < nstreams; s++) {
+      stream_service(ctx, &ctx->streams[s]);
+
+      // We must keep polling regularly in order to handle detection of packet
+      // transmission as well as perform packet reception and checking
+      usb_testutils_poll(ctx->usbdev);
+    }
+
+    // See whether any streams still have more work to do
+    unsigned s = 0U;
+    while (s < nstreams && stream_completed(&ctx->streams[s])) {
+      s++;
+    }
+    bDone = (s >= nstreams);
+  } while (!bDone);
+
+  // Determine the total counts of bytes sent and received
+  uint32_t tx_bytes = 0U;
+  uint32_t rx_bytes = 0U;
+  for (unsigned s = 0U; s < nstreams; s++) {
+    tx_bytes += ctx->streams[s].tx_bytes;
+    rx_bytes += ctx->streams[s].rx_bytes;
+  }
+
+  LOG_INFO("USB sent 0x%x byte(s), received and checked 0x%x byte(s)", tx_bytes,
+           rx_bytes);
+
+  CHECK(tx_bytes == nstreams * transfer_bytes,
+        "Unexpected count of byte(s) sent to USB host");
+
+  return true;
+}