Undesired behaviour from HAL SPI DMA Slave

[Krautermann]

For some reason HAL_SPI_STATE remains busy forever after executing HAL_SPI_Receive_DMA. This happen for the SPI slave of SPI #2 of the STM32H745XI board. 

The problem goes away when I change the SPI mode from slave to master, but that's not a proper workaround. I want to have a half-duplex communication between a master and a slave SPI. So I need a slave that can receive data via DMA!

/* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_DMA_Init();
 MX_FMC_Init();
 MX_LTDC_Init();
 MX_CRC_Init();
 MX_DMA2D_Init();
 MX_SPI2_Init();
 MX_SPI4_Init();
 MX_QUADSPI_Init();
 MX_TouchGFX_Init();
 /* USER CODE BEGIN 2 */


 /* USER CODE END 2 */

 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
 /* USER CODE END WHILE */

 MX_TouchGFX_Process();
 /* USER CODE BEGIN 3 */
 	 HAL_SPI_Receive_DMA(&hspi2, RX_Buffer, sizeof(RX_Buffer));
 	 while(HAL_SPI_GetState(&hspi2)!= HAL_SPI_STATE_READY){} //Gets stuck here forever!!!!

	 transfer_complete=0;
	 HAL_SPI_Transmit_DMA(&hspi4, TX_Buffer, sizeof(TX_Buffer));
	 while(HAL_SPI_GetState(&hspi4)!= HAL_SPI_STATE_READY){}
	 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_SET);
 }

static void MX_SPI2_Init(void)
{
 /* SPI2 parameter configuration*/
 hspi2.Instance = SPI2;
 hspi2.Init.Mode = SPI_MODE_SLAVE;
 hspi2.Init.Direction = SPI_DIRECTION_1LINE;
 hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
 hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
 hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
 hspi2.Init.NSS = SPI_NSS_SOFT;
 hspi2.Init.FirstBit = SPI_FIRSTBIT_LSB;
 hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
 hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
 hspi2.Init.CRCPolynomial = 0x0;
 hspi2.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
 hspi2.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
 hspi2.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
 hspi2.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
 hspi2.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
 hspi2.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
 hspi2.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
 hspi2.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
 hspi2.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
 hspi2.Init.IOSwap = SPI_IO_SWAP_DISABLE;
 if (HAL_SPI_Init(&hspi2) != HAL_OK)
 {
 Error_Handler();
 }
}
static void MX_SPI4_Init(void)
{
 /* SPI4 parameter configuration*/
 hspi4.Instance = SPI4;
 hspi4.Init.Mode = SPI_MODE_MASTER;
 hspi4.Init.Direction = SPI_DIRECTION_1LINE;
 hspi4.Init.DataSize = SPI_DATASIZE_8BIT;
 hspi4.Init.CLKPolarity = SPI_POLARITY_LOW;
 hspi4.Init.CLKPhase = SPI_PHASE_1EDGE;
 hspi4.Init.NSS = SPI_NSS_SOFT;
 hspi4.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
 hspi4.Init.FirstBit = SPI_FIRSTBIT_LSB;
 hspi4.Init.TIMode = SPI_TIMODE_DISABLE;
 hspi4.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
 hspi4.Init.CRCPolynomial = 0x0;
 hspi4.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
 hspi4.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
 hspi4.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
 hspi4.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
 hspi4.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
 hspi4.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
 hspi4.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
 hspi4.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
 hspi4.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
 hspi4.Init.IOSwap = SPI_IO_SWAP_DISABLE;
 if (HAL_SPI_Init(&hspi4) != HAL_OK)
 {
 Error_Handler();
 }
}

I even changed the clock speed for the slave and it still didn't solve the problem. HAL_SPI_Receive (polling mode) works fine. I even changed DMA Stream and that didn't work neither.

Could someone with knowledge on SPI/DMA shed some light on this issue?

[Krautermann]

void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
 if(hspi->Instance==SPI2)
 {
 /* USER CODE BEGIN SPI2_MspInit 0 */

 /* USER CODE END SPI2_MspInit 0 */

 /** Initializes the peripherals clock
 */
 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SPI2;
 PeriphClkInitStruct.Spi123ClockSelection = RCC_SPI123CLKSOURCE_PLL;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
 {
 Error_Handler();
 }

 /* Peripheral clock enable */
 __HAL_RCC_SPI2_CLK_ENABLE();

 __HAL_RCC_GPIOB_CLK_ENABLE();
 __HAL_RCC_GPIOD_CLK_ENABLE();
 __HAL_RCC_GPIOI_CLK_ENABLE();
 /**SPI2 GPIO Configuration
 PB4 (NJTRST) ------> SPI2_NSS
 PD3 ------> SPI2_SCK
 PI2 ------> SPI2_MISO
 */
 GPIO_InitStruct.Pin = GPIO_PIN_4;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 GPIO_InitStruct.Alternate = GPIO_AF7_SPI2;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = GPIO_PIN_3;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
 HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = GPIO_PIN_2;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
 HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);

 /* SPI2 DMA Init */
 /* SPI2_RX Init */
 hdma_spi2_rx.Instance = DMA2_Stream1;
 hdma_spi2_rx.Init.Request = DMA_REQUEST_SPI2_RX;
 hdma_spi2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
 hdma_spi2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
 hdma_spi2_rx.Init.MemInc = DMA_MINC_ENABLE;
 hdma_spi2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
 hdma_spi2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
 hdma_spi2_rx.Init.Mode = DMA_NORMAL;
 hdma_spi2_rx.Init.Priority = DMA_PRIORITY_LOW;
 hdma_spi2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
 if (HAL_DMA_Init(&hdma_spi2_rx) != HAL_OK)
 {
 Error_Handler();
 }

 __HAL_LINKDMA(hspi,hdmarx,hdma_spi2_rx);

 /* SPI2_TX Init */
 hdma_spi2_tx.Instance = DMA2_Stream0;
 hdma_spi2_tx.Init.Request = DMA_REQUEST_SPI2_TX;
 hdma_spi2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
 hdma_spi2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
 hdma_spi2_tx.Init.MemInc = DMA_MINC_ENABLE;
 hdma_spi2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
 hdma_spi2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
 hdma_spi2_tx.Init.Mode = DMA_NORMAL;
 hdma_spi2_tx.Init.Priority = DMA_PRIORITY_LOW;
 hdma_spi2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
 if (HAL_DMA_Init(&hdma_spi2_tx) != HAL_OK)
 {
 Error_Handler();
 }

 __HAL_LINKDMA(hspi,hdmatx,hdma_spi2_tx);

 /* SPI2 interrupt Init */
 HAL_NVIC_SetPriority(SPI2_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(SPI2_IRQn);
 /* USER CODE BEGIN SPI2_MspInit 1 */

 /* USER CODE END SPI2_MspInit 1 */
 }
 else if(hspi->Instance==SPI4)
 {
 /* USER CODE BEGIN SPI4_MspInit 0 */

 /* USER CODE END SPI4_MspInit 0 */

 /** Initializes the peripherals clock
 */
 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SPI4;
 PeriphClkInitStruct.Spi45ClockSelection = RCC_SPI45CLKSOURCE_D2PCLK1;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
 {
 Error_Handler();
 }

 /* Peripheral clock enable */
 __HAL_RCC_SPI4_CLK_ENABLE();

 __HAL_RCC_GPIOE_CLK_ENABLE();
 /**SPI4 GPIO Configuration
 PE2 ------> SPI4_SCK
 PE4 ------> SPI4_NSS
 PE6 ------> SPI4_MOSI
 */
 GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_4|GPIO_PIN_6;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 GPIO_InitStruct.Alternate = GPIO_AF5_SPI4;
 HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

 /* SPI4 DMA Init */
 /* SPI4_TX Init */
 hdma_spi4_tx.Instance = DMA1_Stream1;
 hdma_spi4_tx.Init.Request = DMA_REQUEST_SPI4_TX;
 hdma_spi4_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
 hdma_spi4_tx.Init.PeriphInc = DMA_PINC_DISABLE;
 hdma_spi4_tx.Init.MemInc = DMA_MINC_ENABLE;
 hdma_spi4_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
 hdma_spi4_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
 hdma_spi4_tx.Init.Mode = DMA_NORMAL;
 hdma_spi4_tx.Init.Priority = DMA_PRIORITY_LOW;
 hdma_spi4_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
 if (HAL_DMA_Init(&hdma_spi4_tx) != HAL_OK)
 {
 Error_Handler();
 }

 __HAL_LINKDMA(hspi,hdmatx,hdma_spi4_tx);

 /* SPI4_RX Init */
 hdma_spi4_rx.Instance = DMA1_Stream0;
 hdma_spi4_rx.Init.Request = DMA_REQUEST_SPI4_RX;
 hdma_spi4_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
 hdma_spi4_rx.Init.PeriphInc = DMA_PINC_DISABLE;
 hdma_spi4_rx.Init.MemInc = DMA_MINC_ENABLE;
 hdma_spi4_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
 hdma_spi4_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
 hdma_spi4_rx.Init.Mode = DMA_NORMAL;
 hdma_spi4_rx.Init.Priority = DMA_PRIORITY_LOW;
 hdma_spi4_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
 if (HAL_DMA_Init(&hdma_spi4_rx) != HAL_OK)
 {
 Error_Handler();
 }

 __HAL_LINKDMA(hspi,hdmarx,hdma_spi4_rx);

 /* SPI4 interrupt Init */
 HAL_NVIC_SetPriority(SPI4_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(SPI4_IRQn);
 /* USER CODE BEGIN SPI4_MspInit 1 */

 /* USER CODE END SPI4_MspInit 1 */
 }

}

[Krautermann]

Problem solved!

The slave SPI remains in HAL_Busy_RX state because it's waiting to receive a buffer of size mentioned by the user, which in this case is sizeof(RX_Buffer). It is important to note that SPI slave will remain in busy state even if it receives a buffer smaller than sizeof(RX_Buffer). To solve this problem change sizeof(RX_Buffer) to sizeof(TX_Buffer). Moreover remove the line of code 

while(HAL_SPI_GetState(&hspi2)!= HAL_SPI_STATE_READY){}

Because the processor needs to execute HAL_SPI_Transmit_DMA for the master to send data for the slave to receive.