Overflow when transmitting SPI data

[rgqsch]

HAL_SPI_TransmitReceive gives a timeout in polling mode.

When transmitting over SPI5 we get a timeout on transmitting upon sending a large dataset (4096 bytes).
SPI5 is configured as a Master, 2 Line device, transmit and receive data in 8 Bit mode.

Not in every loop the SPI_FLAG_RXP is set, so no data is read. This will cause a discrepancy in the TxXferCount and RxXferCount and therefor a Timeout after the /* Timeout management */

When setting a breakpoint on the corresponding SPI_CloseTransfer we also see SPI_FLAG_OVR is set.
However when checking for the SPI_FLAG_OVR in the loop, this is never set and will transmit all bytes successfully. A tiny delay might seem to be the solution. Since the function is polling, a wait for SPI_FLAG_TXP might be a solution

Clock settings:

[rgqsch]

We work with the STM32H7S7I8 running at a SYSCLK of 600Mhz.
The code is running from external RAM bus speed 100MHz, DTR enabled - 8 bit wide
ICache as well as DCache is enabled

We initialize the SPI 5 peripheral as follows:
Peripheral clock 150MHz
BaudRatePrescaler 2 (SPI master clock/8 so outgoing clock @ ~19MHz)
SPI_MODE_MASTER; // Set the mode to SPI master
SPI_DIRECTION_2LINES; // Set the mode to 2 lines full duplex
SPI_DATASIZE_8BIT; // Set the data size to 8 bit

It might be that the peripheral is too fast for the external code to load? I will run a test with the peripheral clock at a lower speed

[KRASTM]

HI @rgqsch,

I think so, I will try to find out more and keep you posted.

With regards,

[KRASTM]

Hello @rgqsch,

I checked with our team, and if you are sure about The code is running from external RAM bus speed 100MHz, they recommend that the speed of the external RAM should be higher than the clock of the peripheral (it can be up to 2 times).

With regards

[rgqsch]

@KRASTM
Thanks for the reply. Just to be clear: we run the code from XSPI2 @100MHz in Memory Mapped Mode. But communicating to another peripheral on SPI5.
I will try reducing the SPI5 clock, and check if that will work

Edit: After setting the APB clock to 18 MHz (and the output clock to the same) I still get mismatches.
I think the function HAL_SPI_TransmitReceive need to wait for an RXP flag after sending. The code might be too fast and the received data is not yet available at the check

I've run a separate test with a simple counter in the function HAL_SPI_TransmitReceive between sending and receiving.

      static uint32_t spi_tx_cnt = 0;
      while( (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXP)) == 0 ) ++spi_tx_cnt;

      /* Check the RXP flag */
      if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXP)) && (initial_RxXferCount > 0UL))

This spi_tx_cnt increases in value, so without this loop the if-statement will be skipped,
This means the initial_RxXferCount is not lowered, and a new byte is sent. But no new byte is received and the initial_RxXferCount will never reach 0 resulting in a timeout

Can you verify this on your part?