USB superspeed peripherals Forum Discussions

While compiling AN84868's source-code I noticed two compiler warnings. One seems harmless, the other could cause potential issues. I've fixed these 2 issues(bugs). I'm not sure where I should normally report these? The diff for the fixes is below. Hopefully it can be picked up by one of the engineers?

diff --git a/ConfigFpgaSlaveFifoSync/cyfxconfigfpga.h b/ConfigFpgaSlaveFifoSync/cyfxconfigfpga.h
index d8e9444..1fc8d92 100644
--- a/ConfigFpgaSlaveFifoSync/cyfxconfigfpga.h
+++ b/ConfigFpgaSlaveFifoSync/cyfxconfigfpga.h
@@ -38,7 +38,7 @@ extern volatile CyBool_t glIsApplnActive;

 extern CyU3PEvent glFxConfigFpgaAppEvent;    /* Configure FPGA event group. */

-extern uint8_t *seqnum_p;
+extern uint8_t seqnum_p;



diff --git a/ConfigFpgaSlaveFifoSync/cyfxslfifosync.c b/ConfigFpgaSlaveFifoSync/cyfxslfifosync.c
index ce9d0e4..3fc76c0 100644
--- a/ConfigFpgaSlaveFifoSync/cyfxslfifosync.c
+++ b/ConfigFpgaSlaveFifoSync/cyfxslfifosync.c
@@ -84,7 +84,8 @@ uint32_t glDMATxCount = 0;               /* Counter to track the number of buffe
 volatile CyBool_t glIsApplnActive = CyFalse;      /* Whether the loopback application is active or not. */
 uint8_t glEp0Buffer[32];                /* Buffer used for sending EP0 data.    */

-uint8_t *seqnum_p;
+uint8_t seqnum_p;


diff --git a/ConfigFpgaSlaveFifoSync/cyfxgpif2config.h b/ConfigFpgaSlaveFifoSync/cyfxgpif2config.h
index 84d7210..0e3d10e 100644
--- a/ConfigFpgaSlaveFifoSync/cyfxgpif2config.h
+++ b/ConfigFpgaSlaveFifoSync/cyfxgpif2config.h
@@ -85,7 +85,7 @@ uint32_t CyFxGpifRegValue[]  = {
     0x80000380,  /*  CY_U3P_PIB_GPIF_CONFIG */
 #if (CY_FX_SLFIFO_GPIF_16_32BIT_CONF_SELECT == 0)
     0x000010A7,  /*  CY_U3P_PIB_GPIF_BUS_CONFIG */
-#else if (CY_FX_SLFIFO_GPIF_16_32BIT_CONF_SELECT ==1)
+#else // if (CY_FX_SLFIFO_GPIF_16_32BIT_CONF_SELECT == 1)
        0x000010AC, /* 32b data- CY_U3P_PIB_GPIF_BUS_CONFIG */
 #endif
     0x01070002,  /*  CY_U3P_PIB_GPIF_BUS_CONFIG2 */

I'm currently working on a project where the FX3 is interfaced as "Synchronous Slave Fifo" to transfer high-speed data from an FPGA to our PC. Since I also need to implement some simple (4 byte data) low-speed I2C communication with the FPGA to implement control/status registers, I'm looking at what would be the best approach. Browsing through the code examples I've found 2 ways:

1) Implement I2C read/write using vendor-requests in the "USB setup requests (callback)"-block where ep0 is used for data in/out (like in the I2C "Register Mode" Code Example);

2) Implement I2C read/write using events and EP0 in an AppThread (like in the UVC Code Example's UVCAppEP0Thread_Entry()). Perhaps this is normally only done when using the UVCVideo framework?

Of the above is there a "common" way? What would be the best approach?

Furthermore I see 2 ways of initializing the I2C interface:

1) From the start of (one of) the app thread (eg. AppThread_Entry()") before the thread-loop;

2) From "CyFxApplicationDefine" (before any app threads are started);

I suspect it doesn't really matter which one I choose, am I correct?

I've written a more or less working GPIF state machine that uses two threads in ping-pong configuration to continuously acquire data after receiving a trigger.  I've implemented cases where the data is smaller, equal to and larger than the buffer size, and testing with a logic analyzer I think it is working as I expect. 

However, I am having inconsistent results if I set the DMA buffer size to be slightly different than the data size.  For example, I wrote a simple application that configures 20 triggers of 4096 samples (16383 bytes) into two CYUSB buffers of 10 triggers each.  This application works great if the DMA buffer size is 16384 bytes, but if I set it 16 bytes smaller to 16368 bytes, I get:

/* Size of DMA buffers used by the application. */
#ifndef CY_FX_DMA_BUF_SIZE
#define CY_FX_DMA_BUF_SIZE              (16368) //not power of 2
#endif

/* Number of DMA buffers to be used on the channel. */
#ifndef CY_FX_DMA_BUF_COUNT
#define CY_FX_DMA_BUF_COUNT             (2)
#endif

CyU3PDmaMultiChannelConfig_t dmaMultiConfig;
CyU3PMemSet ((uint8_t *)&dmaMultiConfig, 0, sizeof (dmaMultiConfig));
dmaMultiConfig.size           = CY_FX_DMA_BUF_SIZE;
  dmaMultiConfig.count          = 4; // CY_FX_DMA_BUF_COUNT;
  dmaMultiConfig.validSckCount  = 2;
  dmaMultiConfig.prodSckId [0]  = (CyU3PDmaSocketId_t)CY_U3P_PIB_SOCKET_0;
  dmaMultiConfig.prodSckId [1]  = (CyU3PDmaSocketId_t)CY_U3P_PIB_SOCKET_1;
  dmaMultiConfig.consSckId [0]  = (CyU3PDmaSocketId_t)(CY_U3P_UIB_SOCKET_CONS_1);
  dmaMultiConfig.prodAvailCount = 0;
  dmaMultiConfig.prodHeader     = 0;
  dmaMultiConfig.prodFooter     = 0;
  dmaMultiConfig.consHeader     = 0;
  dmaMultiConfig.dmaMode        = CY_U3P_DMA_MODE_BYTE;
  //dmaMultiConfig.cb 			= NULL;
  //dmaMultiConfig.notification   = 0;
  dmaMultiConfig.notification   =  CY_U3P_DMA_CB_PROD_EVENT;//| CY_U3P_DMA_CB_CONS_EVENT;//CY_U3P_DMA_CB_PROD_EVENT; //
  dmaMultiConfig.cb             = GpifToUsbDmaCallbackMulti;
  apiRetStatus = CyU3PDmaMultiChannelCreate (&glDmaChHandleMulti, CY_U3P_DMA_TYPE_MANUAL_MANY_TO_ONE,
	 // apiRetStatus = CyU3PDmaMultiChannelCreate (&glDmaChHandleMulti, CY_U3P_DMA_TYPE_AUTO_MANY_TO_ONE,
		  &dmaMultiConfig);
  if (apiRetStatus != CY_U3P_SUCCESS)
  {
	  /* Error handling */
	  CyU3PDebugPrint (4, "DMA Channel Creation Failed, Error Code = %d\n", apiRetStatus);
	  CyFxAppErrorHandler (apiRetStatus);
  }

  /* Set DMA Channel transfer size */
  apiRetStatus = CyU3PDmaMultiChannelSetXfer (&glDmaChHandleMulti, CY_FX_GPIFTOUSB_DMA_TX_SIZE, 0);
  if (apiRetStatus != CY_U3P_SUCCESS)
  {
	  CyU3PDebugPrint (4, "CyU3PDmaChannelSetXfer failed, Error code = %d\n", apiRetStatus);
	  CyFxAppErrorHandler(apiRetStatus);
  }

Cypress FX3 USB StreamerExample Device - 1204 - 241
found our device at index 2
interfaces: 1
endpoints: 4
endpoint type: CONT  IN   512
endpoint type: Bulk  IN   16384
endpoint type: Bulk  OUT  4096
endpoint type: Bulk  IN   4096

Configuring FX3 acquisition with parameters:
Samples per trigger:  4096  (16384 bytes)
Number of triggers: 20
Total acquisition size: 327680 bytes
CYUSB bufferSize: 163840 (0.488281 percent of max)
Total CYUSB buffers per acquisition: 2 (10.000000 triggers per buffer)

Beginning Transfer...

0: Got 16368 bytes (0.999023 triggers)!
1: Got 16368 bytes (0.999023 triggers)!
ERROR:  requested 327680 bytes but got 32736 bytes!

So although I requested 163840 bytes to BeginDataXfer/WaitForXfer/FinishDataXfer, it actually transferred exactly 1 DMA buffer per call.   Concurrently, the FX3 log gives:

Restarting the GPIF !
No Error :26
No Error :26
CYU3P_PIB_ERR_THR0_WR_OVERRUN: 1
CYU3P_PIB_ERR_THR0_WR_OVERRUN: 2
CYU3P_PIB_ERR_THR0_WR_OVERRUN: 3
CYU3P_PIB_ERR_THR1_WR_OVERRUN: 4
CYU3P_PIB_ERR_THR0_WR_OVERRUN: 5
CYU3P_PIB_ERR_THR1_WR_OVERRUN: 6
CYU3P_PIB_ERR_THR1_WR_OVERRUN: 7
CYU3P_PIB_ERR_THR0_WR_OVERRUN: 8
CYU3P_PIB_ERR_THR1_WR_OVERRUN: 9

So the first two DMA buffers are transferred, but the next 9 are ignored.  Watching on the logic analyzer, I see 10 triggers received and the GPIF successfully entering the completion state.

First, I had thought that WaitForXfer would only be signaled when it has received the requested amount of data.  Here however it returns exactly 1 DMA buffer, or about 10% of the requested amount.  What determines how much data is available when WaitForXfer is signaled?

Second, why does it behave differently with different DMA buffer sizes?  For example, if I increase the buffer size by 16 bytes:

Samples per trigger:  4096  (16384 bytes)
Number of triggers: 20
Total acquisition size: 327680 bytes
CYUSB bufferSize: 163840 (0.488281 percent of max)
Total CYUSB buffers per acquisition: 2 (10.000000 triggers per buffer)

Beginning Transfer...

0: Got 163840 bytes (10.000000 triggers)!
1: Got 163840 bytes (10.000000 triggers)!
acquisition succeeded!

It now returns the full requested amount of data.  Is there something in the GPIF state machine that tells the CYAPI to transfer less data at a time?

Hi,

I am testing UART communication operation with the sample USB-UART bridge (cyfxusbuart) that comes with the EZ-USB FX3 SDK 1.3.4.

Using Tera Term on a Windows PC, I was able to send and receive ASCII code without any problems.

However, the BREAK signal cannot be transmitted.

Similarly, using Tera Term, the BREAK signal can be transmitted with the FTDI FT4232H.

Therefore, I think that the setting of TeraTerm is not a problem.

Could you please teach me how to send a BREAK signal over the FX3's USB-UART bridge?

Best Regards,

Taguchi

Hello,

I'm developing a driver to the IMX477, the same of the Raspberry HQ Camera. I have developed a small passive adapter board to route the MIPI lanes of the Denebola kit to a Arducam Module (pretty much a raspberry HQ Camera).

I have configured the sensor, and I've created a new configuration for the sensor. The sensor receives the configuration through CCI and starts the stream base on the configured, which was confirmed by probing the MIPI lanes. The configuration follows

The configuration is accepted by the configuration as valid. 

However, when I try to start streaming, I not only do not receive any image, but the application does not generate any log. I have activated SENSOR_DEBUG, PRINT_FRAME_INFO, and RESET_TIMER_ENABLE, but the last messages of debug received from UART are:

bRType = 0x81, bRequest = 0x0, wValue = 0x0, wIndex = 0x0, wLength= 0x2
bRType = 0x21, bRequest = 0x1, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x82, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x83, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0x21, bRequest = 0x1, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x81, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0x21, bRequest = 0x1, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x82, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x83, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0x21, bRequest = 0x1, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x81, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0x21, bRequest = 0x1, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x82, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x83, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0x21, bRequest = 0x1, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0xA1, bRequest = 0x81, wValue = 0x100, wIndex = 0x1, wLength= 0x22
bRType = 0x21, bRequest = 0x1, wValue = 0x200, wIndex = 0x1, wLength= 0x22
Writing Configuration Settings:
AplnStrt:SMState = 0x2

And it stays like that. I can send UVC requests after that  normally, which means the firmware is not halted. 

Any advice on how to debug this? I have no clue what to try. 

How can I check that at least some frames , or even bits for that matter, are being received on the GPIF coming from the sensor? 

I appreciate all the help you can provide.

Best,

Renato

When I read CYUSB301X, I read above current list.

I cannot understand the meaning latch-up current.

What status is latch-up?

Hi Sir. 

Good day. We had met some issues for using CX3 USB HID with IMU ICM20602. The sample rate now is set to 1k but it does not quit stable. Our architecture is as follows

I also provide the reference config and code at attched file src.zip.

Does anyone has idea or further suggestion for debugging this issue?

Hi, 

I'm using the FX3 development kit (CYUSB3KIT-001) along with SDK 1.3.4

After building the example project "FX3BootAppGcc" with no changes.

Using an unprogrammed board I use program->fx3->spi,  I can see that a reenumeration occurs with the new code reporting as "fx3 usb bootprogrammer device" the SPI is then programmed and on power cycling the board doesn't appear as "Cypress FX3 USB BootLoader Device" instead it appears as "Cypress FX3 USB BulkloopExample Device" this is telling me that the new new code has been loaded correctly from SPI.

Now when I want to reprogram the RAM with another image file in this case I'm using the "CyBootProgrammer.img" that comes along with the control center application. I use program->fx3->RAM, I'm given the option of selecting a new image file to download and the application says "programming succeeded" but no reenumeration occurs. I can also try to reprogram the SPI also with a new image file. I'm given the option of selecting the new image file but I get the message "Programming of SPI FLASH Error code not found"

I can fix this by modifying the "FX3BootAppGcc" code by change the  noReEnum in the command "CyFx3BootUsbStart" from "CyTrue" to "CyFalse".

After rebuilding with the noReEnum set to "CyFalse" and reprogramming the board (by removing one of the spi jumpers to get it to go back to the "Cypress FX3 USB BootLoader Device") then using the program->fx3->SPI I can follow the same steps as before I can now use program->fx3->spi or RAM to load a new image file into the FX3 it will reenumerate correctly.

This behaviour seems to be causing another project of ours to break, we merge the secondary bootloader and application code to have the ability to infield upgrade our code.

If we put the noReEnum to CyFalse when we tell our application code to go back to bootloader all vendor commands seem to stop working, if we keep the noReEnum to CyTrue then we can jump back to bootloader but we cant load a new image onto RAM or SPI.

I've attached the the "FX3BootAppGcc" projects with the noReEnum set to CyTrue and CyFalse if you want to test them along with the CyBootProgrammer.img which I was trying to load into the RAM.

Dear sir,

    I have a new project in which CYUSB3013/3014 will be used, it uses 32bit slavefifo with flagA (set to CURRENT_THREAD_DMA_READY) connected to an external host (FPGA), the auto DMA channel (from PPort to USB) is set to CY_U3P_DMA_MODE_BUFFER mode (instead of Byte mode), e.g. the DMA buffer size is 2048bytes and count is 16. External host (FPGA) will read the FlagA and if there's available buffer it will write 2048 bytes (Buffer size) to the SlaveFIFO.

I'm wondering (not fully sure after reading the docs) about FlagA's behavoir,  when the FlagA is set to " CURRENT_THREAD_DMA_READY" (assuming active "L"), it will be "L" when there's at least one available DMA buffer (2048 bytes) and FPGA can write 2048 bytes (or 4 bytes , which i guess for "Byte" mode only???), and it will be "H" when all the buffers (e.g. 16 buffers) are occupied.  Is that correct?

If it's 4 bytes space only (when FlagA is "L") even in DMA buffer mode, i might have to set to DMA Byte mode, set flagA as "watermark" and set proper water mark If i want to write a bulk of bytes (e.g. 2048 bytes) to slaveFIFO at one time (one check of the flag).  is there other alternative?

Thanks!

JT

I have FX3 CYUSB2014 / 3014 and I'm trying to make UART work in DMA mode to receive and process data from UART.  Using a Manual DMA Channel to read data, and process in a callback.  Right now, it just sends the data over the host USB (CDC Interface)  I've tried different buffer sizes and counts.

Sending "packets" of 32 bytes at a time to test, After about 4-16 packets it fails with error 73, CY_U3P_ERROR_DMA_FAILURE.  Any later calls to CyU3PDmaChannelSetWrapUp return error 71 - CY_U3P_ERROR_INVALID_SEQUENCE.

Wondering why it fails in the first place, or what can be done to reset, and recover the data.

Thanks-Greg

INIT:

CyU3PReturnStatus_t InitializeDebugConsole(void)
{
CyU3PUartConfig_t uartConfig;
CyU3PDmaChannelConfig_t dmaConfig;
CyU3PReturnStatus_t Status = CY_U3P_SUCCESS;

Status = CyU3PUartInit(); // Start the UART driver
CheckStatus("CyU3PUartInit", Status);

CyU3PMemSet ((uint8_t *)&uartConfig, 0, sizeof (uartConfig));
uartConfig.baudRate = CY_U3P_UART_BAUDRATE_115200; //default buad of UART
uartConfig.stopBit = CY_U3P_UART_ONE_STOP_BIT;
uartConfig.parity = CY_U3P_UART_NO_PARITY;
uartConfig.txEnable = CyTrue;
uartConfig.rxEnable = CyTrue;
uartConfig.flowCtrl = CyFalse;
uartConfig.isDma = CyTrue;
Status = CyU3PUartSetConfig(&uartConfig, UartCallback); // Configure the UART hardware
CheckStatus("CyU3PUartSetConfig", Status);

Status = CyU3PUartTxSetBlockXfer(0xFFFFFFFF); // Send as much data as I need to
CheckStatus("CyU3PUartTxSetBlockXfer", Status);
Status = CyU3PDebugInit(CY_U3P_LPP_SOCKET_UART_CONS, 6); // Attach the Debug driver above the UART driver
if (Status == CY_U3P_SUCCESS) glDebugTxEnabled = CyTrue;
CheckStatus("ConsoleOutEnabled", Status);
CyU3PDebugPreamble(CyFalse); // Skip preamble, debug info is targeted for a person

// Now setup a DMA channel to receive characters from the Uart Rx
Status = CyU3PUartRxSetBlockXfer(1); //was 1 GH 7/1/2021
CheckStatus("CyU3PUartRxSetBlockXfer", Status);
CyU3PMemSet((uint8_t *)&dmaConfig, 0, sizeof(dmaConfig));
dmaConfig.size = 128; // 16 is Minimum size allowed, I only need 1 byte. sb multiples of 16
dmaConfig.count = 8; // I can't type faster than the Uart Callback routine!
dmaConfig.prodSckId = CY_U3P_LPP_SOCKET_UART_PROD;
dmaConfig.consSckId = CY_U3P_CPU_SOCKET_CONS;
dmaConfig.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaConfig.notification = CY_U3P_DMA_CB_PROD_EVENT;
Status = CyU3PDmaChannelCreate(&glUARTtoCPU_Handle, CY_U3P_DMA_TYPE_MANUAL_IN, &dmaConfig);
CheckStatus("CreateDebugRxDmaChannel", Status);
if (Status != CY_U3P_SUCCESS) CyU3PDmaChannelDestroy(&glUARTtoCPU_Handle);
else
{
Status = CyU3PDmaChannelSetXfer(&glUARTtoCPU_Handle, 0); //Zero for infinite transfer
CheckStatus("ConsoleInEnabled", Status);
}
return Status;
}

CALLBACK:

void UartCallback(CyU3PUartEvt_t Event, CyU3PUartError_t Error)
// Handle characters typed in by the developer
{
CyU3PDmaBuffer_t ConsoleInDmaBuffer;
CyU3PReturnStatus_t Status = CY_U3P_SUCCESS;
char pInputChar[32] = ""; 
uint16_t bufferlen ;

if (Event == CY_U3P_UART_EVENT_RX_DONE)
{
Status = CyU3PDmaChannelSetWrapUp(&glUARTtoCPU_Handle);
CheckStatus("CyU3PDmaChannelSetWrapUp", Status);

if(Status == CY_U3P_SUCCESS)
{
Status = CyU3PDmaChannelGetBuffer(&glUARTtoCPU_Handle, &ConsoleInDmaBuffer, CYU3P_NO_WAIT);
CheckStatus("CyU3PDmaChannelGetBuffer", Status);

if(Status == CY_U3P_SUCCESS)
{
if (ConsoleInDmaBuffer.count > 0)
{
if (ConsoleInDmaBuffer.count > 31) //max of 31 to prevent filling the string.
{
bufferlen = 31;
}
else
{
bufferlen = ConsoleInDmaBuffer.count;
}

strncpy(pInputChar,(char*)ConsoleInDmaBuffer.buffer,bufferlen);

if (gUartEcho)
{
DebugPrint(0, "%s", pInputChar); // Echo the character
}
// If True, the characters typed on the debug console are sent to the PC Host via the CDC Interface
if (gUartReTransOnCDC)
{
SendString(pInputChar);
}
}
}
}

CyU3PDmaChannelDiscardBuffer(&glUARTtoCPU_Handle);
}
CyU3PUartRxSetBlockXfer(1); //Set back to 1 to reset
}