USB Bulk Packet Size

Paul Haddad said:

If I send a packet out on my host of 256 bytes the RxHandler will often get called multiple times with 64 bytes worth of data. Likewise if I send out multiple smaller packets in a short amount of time, they'll often be concatenated as a single call to RxHandler.

The usb_dev_bulk example on StellarisWare implements a ring buffer over the bulk OUT endpoint. RxHandler is called by the ring buffer handler (USBBufferEventCallback), not directly by the endpoint interrupt. Also, deffered tick operation (BulkTickHandler) gives another chances of RxHandler call. This complexity makes you mislead.

When the host application sends 64 bytes or less, PC host controller puts single OUT transaction to the device. When the host app sends greater than 64 bytes, PC host controller splits this write call into a sequence of 64 bytes transactions, with the last transaction of 64 bytes or less.

The USB engine on the Stellaris raises endpoint interrupt for each transaction.
On StellarisWare\usblib\device\usbdbulk.c, endpoint interrupt invokes ProcessDataFromHost()

Endpoint interrupt -> HandleEndpoints() -> ProcessDataFromHost()

The reception of a transaction corresponds to ProcessDataFromHost() call exactly one by one.
Here is an excerpt from ProcessDataFromHost() code.

static tBoolean
ProcessDataFromHost(const tUSBDBulkDevice *psDevice, unsigned long ulStatus)
{
    ...
    ...
    // Has a packet been received?
    //
    if(ulEPStatus & USB_DEV_RX_PKT_RDY)
    {
        //
        // Set the flag we use to indicate that a packet read is pending.  This
        // will be cleared if the packet is read.  If the client doesn't read
        // the packet in the context of the USB_EVENT_RX_AVAILABLE callback,
        // the event will be signaled later during tick processing.
        //
        SetDeferredOpFlag(&psInst->usDeferredOpFlags, BULK_DO_PACKET_RX, true);   <-- (1)

        //
        // How big is the packet we've just been sent?
        //
        ulSize = MAP_USBEndpointDataAvail(psInst->ulUSBBase,                      <-- (2)
                                          psInst->ucOUTEndpoint);

        //
        // The receive channel is not blocked so let the caller know
        // that a packet is waiting.  The parameters are set to indicate
        // that the packet has not been read from the hardware FIFO yet.
        //
        psDevice->pfnRxCallback(psDevice->pvRxCBData,                             <-- (3)
                                USB_EVENT_RX_AVAILABLE, ulSize,
                                (void *)0);
    }

In ProcessDataFromHost(),
(1) usDeferredOpFlags raises at BULK_DO_PACKET_RX, which enables deffered tick operation.
(2) The exact transaction (packet) size is read out here.
(3) pfnRxCallback is called with USB_EVENT_RX_AVAILABLE
This pfnRxCallback is assigned to USBBufferEventCallback() in StellarisWare\usblib\usbbuffer.c

usb_bulk_struct.c
const tUSBDBulkDevice g_sBulkDevice =
{
    USB_VID_STELLARIS,
    USB_PID_BULK,
    500,
    USB_CONF_ATTR_SELF_PWR,
    USBBufferEventCallback,    <--- psDevice->pfnRxCallback
    ...

Also, BulkTickHandler() calls USBBufferEventCallback( USB_EVENT_RX_AVAILABLE ), at every tick.
USBBufferEventCallback( USB_EVENT_RX_AVAILABLE ) calls RxHandler()

In this way, RxHandler() is called not just at every transaction reception, but also by tick events after reception.

To know the exact timing and the size of transactions, you have to intercept ProcessDataFromHost() process.

Tsuneo

Tsuneo,

Thanks for the info. The Host is a Mac so not sure there's a SHORT_PACKET_TERMINATE like option (at least I didn't see one when looking around). No big deal since I basically implemented the transfer size in header approach.

For anyone coming across this thread in the future I basically did the below. The Host encodes data as a Magic Header Byte (0x44), followed by a short data length, a byte command, then the actual data. The key thing here is that if you return < than USBBufferDataAvailable bytes, those bytes won't get consumed by the Buffer and will be available next time a packet comes in. So for a large data packet, this handler will get called many times until there's enough data in the buffer to consume. Similarly for small packets, this might get called once and need to handle multiple commands.

I'm still playing around with the below, but hopefully it helps someone else in the future.

 unsigned long bytesRead = 0;

 unsigned long bufferDataAvailable;

 tUSBRingBufObject ringBuffer;

 USBBufferInfoGet(&g_sRxBuffer, &ringBuffer);

 while ((bufferDataAvailable = USBBufferDataAvailable(&g_sRxBuffer))) {

 if (ringBuffer.pucBuf[ringBuffer.ulReadIndex] == 0x44) {

 if (bufferDataAvailable > 3) {

 unsigned short packetLength = (ringBuffer.pucBuf[(ringBuffer.ulReadIndex + 1)%ringBuffer.ulSize] << 8) + ringBuffer.pucBuf[(ringBuffer.ulReadIndex + 2)%ringBuffer.ulSize];

 if (packetLength > MAX_PACKET_SIZE) {

 UARTprintf("Packet too large %d\n", packetLength);

 // Skip a byte in case its an error

 USBBufferDataRemoved(&g_sRxBuffer, 1);

 bytesRead++;

 } else if (packetLength <= bufferDataAvailable - 4) {

 unsigned char packetCommand;

 static unsigned char packetData[MAX_PACKET_SIZE];

 DEBUG_PRINT("Have a packet\n");

 USBBufferDataRemoved(&g_sRxBuffer, 3);

 USBBufferRead(&g_sRxBuffer, &packetCommand, 1);

 USBBufferRead(&g_sRxBuffer, packetData, packetLength);

 handle_command(packetCommand, packetData, packetLength);

 bytesRead += 4 + packetLength;

 } else {

 DEBUG_PRINT("Not enough data need %d have %d\n", packetLength, bufferDataAvailable - 4);

 break;

 }

 } else {

 break;

 }

 } else  {

 UARTprintf("Junk Data 0x%x\n", ringBuffer.pucBuf[ringBuffer.ulReadIndex]);

 USBBufferDataRemoved(&g_sRxBuffer, 1);

 bytesRead++;

}

 }

 DEBUG_PRINT("Read in %d bytes out, remaining %d.\n", bytesRead, USBBufferDataAvailable(&g_sRxBuffer));

 return bytesRead;

 }