chore(spi): avoid SPI_TRANSFER_TIMEOUT as argument

SPI_TRANSFER_TIMEOUT is always passed as an argument
while it is a constant definition.
So simply function call and check.

Signed-off-by: Frederic Pillon <frederic.pillon@st.com>

Author: fpistm

libraries/SPI/src/SPI.cpp

@@ -163,7 +163,7 @@ void SPIClass::setClockDivider(uint8_t divider)
   */
 uint8_t SPIClass::transfer(uint8_t data, bool skipReceive)
 {
-  spi_transfer(&_spi, &data, sizeof(uint8_t), SPI_TRANSFER_TIMEOUT, skipReceive);
+  spi_transfer(&_spi, &data, sizeof(uint8_t), skipReceive);
   return data;
 }
 
@@ -184,8 +184,7 @@ uint16_t SPIClass::transfer16(uint16_t data, bool skipReceive)
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
     data = tmp;
   }
-  spi_transfer(&_spi, (uint8_t *)&data, sizeof(uint16_t),
-               SPI_TRANSFER_TIMEOUT, skipReceive);
+  spi_transfer(&_spi, (uint8_t *)&data, sizeof(uint16_t), skipReceive);
 
   if (_spiSettings.bitOrder) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
@@ -208,8 +207,7 @@ uint16_t SPIClass::transfer16(uint16_t data, bool skipReceive)
 void SPIClass::transfer(void *buf, size_t count, bool skipReceive)
 {
   if ((count != 0) && (buf != NULL)) {
-    spi_transfer(&_spi, ((uint8_t *)buf), count,
-                 SPI_TRANSFER_TIMEOUT, skipReceive);
+    spi_transfer(&_spi, ((uint8_t *)buf), count, skipReceive);
   }
 }
 

libraries/SPI/src/SPI.h

@@ -41,11 +41,6 @@ extern "C" {
 #define SPI_TRANSMITRECEIVE false
 #define SPI_TRANSMITONLY true
 
-// Defines a default timeout delay in milliseconds for the SPI transfer
-#ifndef SPI_TRANSFER_TIMEOUT
-  #define SPI_TRANSFER_TIMEOUT 1000
-#endif
-
 class SPISettings {
   public:
     constexpr SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode)

libraries/SPI/src/utility/spi_com.c

@@ -502,69 +502,68 @@ void spi_deinit(spi_t *obj)
   * @param  obj : pointer to spi_t structure
   * @param  buffer : tx data to send before reception
   * @param  len : length in byte of the data to send and receive
-  * @param  Timeout: Timeout duration in tick
   * @param  skipReceive: skip receiving data after transmit or not
   * @retval status of the send operation (0) in case of error
   */
-spi_status_e spi_transfer(spi_t *obj, uint8_t *buffer, uint16_t len,
-                          uint32_t Timeout, bool skipReceive)
+spi_status_e spi_transfer(spi_t *obj, uint8_t *buffer, uint16_t len, bool skipReceive)
 {
   spi_status_e ret = SPI_OK;
   uint32_t tickstart, size = len;
   SPI_TypeDef *_SPI = obj->handle.Instance;
   uint8_t *tx_buffer = buffer;
 
-  if ((len == 0) || (Timeout == 0U)) {
-    return Timeout > 0U ? SPI_ERROR : SPI_TIMEOUT;
-  }
-  tickstart = HAL_GetTick();
+  if (len == 0) {
+    ret = SPI_ERROR;
+  } else {
+    tickstart = HAL_GetTick();
 
 #if defined(SPI_CR2_TSIZE)
-  /* Start transfer */
-  LL_SPI_SetTransferSize(_SPI, size);
-  LL_SPI_Enable(_SPI);
-  LL_SPI_StartMasterTransfer(_SPI);
+    /* Start transfer */
+    LL_SPI_SetTransferSize(_SPI, size);
+    LL_SPI_Enable(_SPI);
+    LL_SPI_StartMasterTransfer(_SPI);
 #endif
 
-  while (size--) {
+    while (size--) {
 #if defined(SPI_SR_TXP)
-    while (!LL_SPI_IsActiveFlag_TXP(_SPI));
+      while (!LL_SPI_IsActiveFlag_TXP(_SPI));
 #else
-    while (!LL_SPI_IsActiveFlag_TXE(_SPI));
+      while (!LL_SPI_IsActiveFlag_TXE(_SPI));
 #endif
-    LL_SPI_TransmitData8(_SPI, *tx_buffer++);
+      LL_SPI_TransmitData8(_SPI, *tx_buffer++);
 
-    if (!skipReceive) {
+      if (!skipReceive) {
 #if defined(SPI_SR_RXP)
-      while (!LL_SPI_IsActiveFlag_RXP(_SPI));
+        while (!LL_SPI_IsActiveFlag_RXP(_SPI));
 #else
-      while (!LL_SPI_IsActiveFlag_RXNE(_SPI));
+        while (!LL_SPI_IsActiveFlag_RXNE(_SPI));
 #endif
-      *buffer++ = LL_SPI_ReceiveData8(_SPI);
-    }
-    if ((Timeout != HAL_MAX_DELAY) && (HAL_GetTick() - tickstart >= Timeout)) {
-      ret = SPI_TIMEOUT;
-      break;
+        *buffer++ = LL_SPI_ReceiveData8(_SPI);
+      }
+      if ((SPI_TRANSFER_TIMEOUT != HAL_MAX_DELAY) &&
+          (HAL_GetTick() - tickstart >= SPI_TRANSFER_TIMEOUT)) {
+        ret = SPI_TIMEOUT;
+        break;
+      }
     }
-  }
 
 #if defined(SPI_IFCR_EOTC)
-  // Add a delay before disabling SPI otherwise last-bit/last-clock may be truncated
-  // See https://github.com/stm32duino/Arduino_Core_STM32/issues/1294
-  // Computed delay is half SPI clock
-  delayMicroseconds(obj->disable_delay);
-
-  /* Close transfer */
-  /* Clear flags */
-  LL_SPI_ClearFlag_EOT(_SPI);
-  LL_SPI_ClearFlag_TXTF(_SPI);
-  /* Disable SPI peripheral */
-  LL_SPI_Disable(_SPI);
+    // Add a delay before disabling SPI otherwise last-bit/last-clock may be truncated
+    // See https://github.com/stm32duino/Arduino_Core_STM32/issues/1294
+    // Computed delay is half SPI clock
+    delayMicroseconds(obj->disable_delay);
+
+    /* Close transfer */
+    /* Clear flags */
+    LL_SPI_ClearFlag_EOT(_SPI);
+    LL_SPI_ClearFlag_TXTF(_SPI);
+    /* Disable SPI peripheral */
+    LL_SPI_Disable(_SPI);
 #else
-  /* Wait for end of transfer */
-  while (LL_SPI_IsActiveFlag_BSY(_SPI));
+    /* Wait for end of transfer */
+    while (LL_SPI_IsActiveFlag_BSY(_SPI));
 #endif
-
+  }
   return ret;
 }
 

libraries/SPI/src/utility/spi_com.h

@@ -78,6 +78,13 @@ typedef struct spi_s spi_t;
 #define SPI_SPEED_CLOCK_DIV128_MHZ  ((uint32_t)128)
 #define SPI_SPEED_CLOCK_DIV256_MHZ  ((uint32_t)256)
 
+// Defines a default timeout delay in milliseconds for the SPI transfer
+#ifndef SPI_TRANSFER_TIMEOUT
+#define SPI_TRANSFER_TIMEOUT 1000
+#elif SPI_TRANSFER_TIMEOUT <= 0
+#error "SPI_TRANSFER_TIMEOUT cannot be less or equal to 0!"
+#endif
+
 ///@brief specifies the SPI mode to use
 //Mode          Clock Polarity (CPOL)       Clock Phase (CPHA)
 //SPI_MODE0             0                         0
@@ -103,8 +110,7 @@ typedef enum {
 /* Exported functions ------------------------------------------------------- */
 void spi_init(spi_t *obj, uint32_t speed, SPIMode mode, uint8_t msb);
 void spi_deinit(spi_t *obj);
-spi_status_e spi_transfer(spi_t *obj, uint8_t *buffer, uint16_t len,
-                          uint32_t Timeout, bool skipReceive);
+spi_status_e spi_transfer(spi_t *obj, uint8_t *buffer, uint16_t len, bool skipReceive);
 uint32_t spi_getClkFreq(spi_t *obj);
 
 #ifdef __cplusplus