Can you assume predictable ordering of responses when enqueuing multiple USB Mass Storage read commands?

Short answer:
No, you cannot safely assume that the responses will be returned in the same order you enqueued them — unless you implement strict synchronization and tracking mechanisms.

🔍 Why not?

Even though the USB Mass Storage Class (MSC) Bulk-Only Transport (BOT) protocol is logically sequential (CBW → Data → CSW), the XHCI controller and host stack introduce a layer of abstraction and parallelism:

1. XHCI TRBs (Transfer Request Blocks) are processed asynchronously.

2. The controller may reorder or pipeline requests for performance.

3. The Bulk-In endpoint is shared for both data and CSW, and the host must parse and interpret the incoming data stream correctly.

🧠 How to correlate responses with requests?

The key is the dCBWTag field in the CBW and the matching dCSWTag in the CSW. This is your only reliable way to correlate a CSW with its corresponding CBW.

However, this doesn't help you before the CSW — i.e., when you're reading the actual data payload. So you must:

• Track the order of CBWs you enqueue.

• Associate each CBW with a known memory buffer for its expected data size.

• Ensure that the Bulk-In TRBs are aligned with the expected data sizes and order.

✅ Best Practice: Use a Command Queue with Metadata

To manage multiple enqueued requests safely:

1. Maintain a queue of pending commands, each with:

   • CBW tag

   • Expected data size

   • Target memory address

2. Enqueue Bulk-In TRBs in the same order as CBWs, matching the expected data sizes.

3. On interrupt, parse the data and CSW, and match using the tag.

4. Validate that the data received matches the expected size before processing the CSW.

⚠️ Important Caveats

• If any command stalls, the entire sequence may be disrupted.

• If data sizes are misaligned, you may read part of one response into the wrong buffer.

• CSWs are only 13 bytes, but they must be read after the data phase — so you must know when the data ends.

🧪 Example Mapping (Ideal Case)

CBW TagLBASizeData AddressCSW Address0x0104 KiB0x100000x10000x0284 KiB0x200000x11000x032024 KiB0x300000x1200

If you enqueue TRBs in this exact order and sizes match, yes, the data will likely end up in the correct buffers — but only if nothing goes wrong.

🧩 Final Thoughts

To maximize throughput without risking data misalignment, consider:

• Using UASP (USB Attached SCSI Protocol) instead of BOT — it supports command queuing natively.

• Implementing a state machine to track each command's lifecycle.

• Using interrupts or polling to confirm each transfer before proceeding.