Revert "chore(SPI): align with ArduinoCoreAPI"

fpistm · fpistm · commit 8e8feb0c58c1 · 2023-11-24T08:23:27.000+01:00
This reverts commit 392469a.
diff --git a/libraries/SPI/src/SPI.cpp b/libraries/SPI/src/SPI.cpp
@@ -57,10 +57,9 @@ SPIClass::SPIClass(uint32_t mosi, uint32_t miso, uint32_t sclk, uint32_t ssel)
 void SPIClass::begin(void)
 {
   _spi.handle.State = HAL_SPI_STATE_RESET;
-  _spiSettings = DEFAULT_SPI_SETTINGS;
-  spi_init(&_spi, _spiSettings.getClockFreq(),
-           _spiSettings.getDataMode(),
-           _spiSettings.getBitOrder());
+  spi_init(&_spi, _spiSettings.clk,
+           _spiSettings.dMode,
+           _spiSettings.bOrder);
 }
 
 /**
@@ -70,12 +69,14 @@ void SPIClass::begin(void)
   */
 void SPIClass::beginTransaction(SPISettings settings)
 {
-  if (_spiSettings != settings) {
-    _spiSettings = settings;
-    spi_init(&_spi, _spiSettings.getClockFreq(),
-             _spiSettings.getDataMode(),
-             _spiSettings.getBitOrder());
-  }
+  _spiSettings.clk = settings.clk;
+  _spiSettings.dMode = settings.dMode;
+  _spiSettings.bOrder = settings.bOrder;
+  _spiSettings.noReceive = settings.noReceive;
+
+  spi_init(&_spi, _spiSettings.clk,
+           _spiSettings.dMode,
+           _spiSettings.bOrder);
 }
 
 /**
@@ -101,37 +102,39 @@ void SPIClass::end()
   */
 void SPIClass::setBitOrder(BitOrder bitOrder)
 {
-  _spiSettings.setBitOrder(bitOrder);
+  _spiSettings.bOrder = bitOrder;
 
-  spi_init(&_spi, _spiSettings.getClockFreq(),
-           _spiSettings.getDataMode(),
-           _spiSettings.getBitOrder());
+  spi_init(&_spi, _spiSettings.clk,
+           _spiSettings.dMode,
+           _spiSettings.bOrder);
 }
 
 /**
   * @brief  Deprecated function.
   *         Configure the data mode (clock polarity and clock phase)
-  * @param  mode: SPI_MODE0, SPI_MODE1, SPI_MODE2 or SPI_MODE3
+  * @param  _mode: SPI_MODE0, SPI_MODE1, SPI_MODE2 or SPI_MODE3
   * @note
   *         Mode          Clock Polarity (CPOL)   Clock Phase (CPHA)
   *         SPI_MODE0             0                     0
   *         SPI_MODE1             0                     1
   *         SPI_MODE2             1                     0
   *         SPI_MODE3             1                     1
   */
-
-void SPIClass::setDataMode(uint8_t mode)
+void SPIClass::setDataMode(uint8_t _mode)
 {
-  setDataMode((SPIMode)mode);
-}
-
-void SPIClass::setDataMode(SPIMode mode)
-{
-  _spiSettings.setDataMode(mode);
+  if (SPI_MODE0 == _mode) {
+    _spiSettings.dMode = SPI_MODE_0;
+  } else if (SPI_MODE1 == _mode) {
+    _spiSettings.dMode = SPI_MODE_1;
+  } else if (SPI_MODE2 == _mode) {
+    _spiSettings.dMode = SPI_MODE_2;
+  } else if (SPI_MODE3 == _mode) {
+    _spiSettings.dMode = SPI_MODE_3;
+  }
 
-  spi_init(&_spi, _spiSettings.getClockFreq(),
-           _spiSettings.getDataMode(),
-           _spiSettings.getBitOrder());
+  spi_init(&_spi, _spiSettings.clk,
+           _spiSettings.dMode,
+           _spiSettings.bOrder);
 }
 
 /**
@@ -143,15 +146,15 @@ void SPIClass::setDataMode(SPIMode mode)
 void SPIClass::setClockDivider(uint8_t _divider)
 {
   if (_divider == 0) {
-    _spiSettings.setClockFreq(SPI_SPEED_CLOCK_DEFAULT);
+    _spiSettings.clk = SPI_SPEED_CLOCK_DEFAULT;
   } else {
-    /* Get clock freq of the SPI instance and compute it */
-    _spiSettings.setClockFreq(spi_getClkFreq(&_spi) / _divider);
+    /* Get clk freq of the SPI instance and compute it */
+    _spiSettings.clk = spi_getClkFreq(&_spi) / _divider;
   }
 
-  spi_init(&_spi, _spiSettings.getClockFreq(),
-           _spiSettings.getDataMode(),
-           _spiSettings.getBitOrder());
+  spi_init(&_spi, _spiSettings.clk,
+           _spiSettings.dMode,
+           _spiSettings.bOrder);
 }
 
 /**
@@ -160,9 +163,9 @@ void SPIClass::setClockDivider(uint8_t _divider)
   * @param  data: byte to send.
   * @return byte received from the slave.
   */
-uint8_t SPIClass::transfer(uint8_t data)
+byte SPIClass::transfer(uint8_t data)
 {
-  spi_transfer(&_spi, &data, sizeof(uint8_t), SPI_TRANSFER_TIMEOUT, _spiSettings.getSkipRecv());
+  spi_transfer(&_spi, &data, sizeof(uint8_t), SPI_TRANSFER_TIMEOUT, _spiSettings.noReceive);
   return data;
 }
 
@@ -176,14 +179,14 @@ uint16_t SPIClass::transfer16(uint16_t data)
 {
   uint16_t tmp;
 
-  if (_spiSettings.getBitOrder()) {
+  if (_spiSettings.bOrder) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
     data = tmp;
   }
   spi_transfer(&_spi, (uint8_t *)&data, sizeof(uint16_t),
-               SPI_TRANSFER_TIMEOUT, _spiSettings.getSkipRecv());
+               SPI_TRANSFER_TIMEOUT, _spiSettings.noReceive);
 
-  if (_spiSettings.getBitOrder()) {
+  if (_spiSettings.bOrder) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
     data = tmp;
   }
@@ -194,30 +197,22 @@ uint16_t SPIClass::transfer16(uint16_t data)
 /**
   * @brief  Transfer several bytes. Only one buffer used to send and receive data.
   *         begin() or beginTransaction() must be called at least once before.
-  * @param  buf: pointer to the bytes to send. The bytes received are copy in
+  * @param  _buf: pointer to the bytes to send. The bytes received are copy in
   *         this buffer.
-  * @param  count: number of bytes to send/receive.
+  * @param  _count: number of bytes to send/receive.
   */
-void SPIClass::transfer(void *buf, size_t count)
+void SPIClass::transfer(void *_buf, size_t _count)
 {
   if ((count != 0) && (buf != NULL)) {
     spi_transfer(&_spi, ((uint8_t *)buf), count,
-                 SPI_TRANSFER_TIMEOUT, _spiSettings.getSkipRecv());
+                 SPI_TRANSFER_TIMEOUT, _spiSettings.noReceive);
   }
 }
 
 /**
   * @brief  Not implemented.
   */
-void SPIClass::usingInterrupt(int interruptNumber)
-{
-  UNUSED(interruptNumber);
-}
-
-/**
-  * @brief  Not implemented.
-  */
-void SPIClass::notUsingInterrupt(int interruptNumber)
+void SPIClass::usingInterrupt(uint8_t interruptNumber)
 {
   UNUSED(interruptNumber);
 }
diff --git a/libraries/SPI/src/SPI.h b/libraries/SPI/src/SPI.h
@@ -38,6 +38,12 @@ extern "C" {
 #define SPI_CLOCK_DIV64  64
 #define SPI_CLOCK_DIV128 128
 
+// SPI mode parameters for SPISettings
+#define SPI_MODE0 0x00
+#define SPI_MODE1 0x01
+#define SPI_MODE2 0x02
+#define SPI_MODE3 0x03
+
 #define SPI_TRANSMITRECEIVE 0x0
 #define SPI_TRANSMITONLY 0x1
 
@@ -48,105 +54,37 @@ extern "C" {
 
 class SPISettings {
   public:
-    SPISettings(uint32_t clock, BitOrder bitOrder, SPIMode dataMode, bool skipRecv = SPI_TRANSMITRECEIVE)
-    {
-      if (__builtin_constant_p(clock)) {
-        init_AlwaysInline(clock, bitOrder, dataMode, skipRecv);
-      } else {
-        init_MightInline(clock, bitOrder, dataMode, skipRecv);
-      }
-    }
-
-    SPISettings(uint32_t clock, BitOrder bitOrder, int dataMode, bool skipRecv = SPI_TRANSMITRECEIVE)
-    {
-      if (__builtin_constant_p(clock)) {
-        init_AlwaysInline(clock, bitOrder, (SPIMode)dataMode, skipRecv);
-      } else {
-        init_MightInline(clock, bitOrder, (SPIMode)dataMode, skipRecv);
-      }
-    }
-
-    // Default speed set to 4MHz, SPI mode set to MODE 0 and Bit order set to MSB first.
-    SPISettings()
-    {
-      init_AlwaysInline(SPI_SPEED_CLOCK_DEFAULT, MSBFIRST, SPI_MODE0, SPI_TRANSMITRECEIVE);
-    }
-
-    bool operator==(const SPISettings &rhs) const
-    {
-      if ((this->clockFreq == rhs.clockFreq) &&
-          (this->bitOrder == rhs.bitOrder) &&
-          (this->dataMode == rhs.dataMode) &&
-          (this->skipRecv == rhs.skipRecv)) {
-        return true;
-      }
-      return false;
-    }
-
-    bool operator!=(const SPISettings &rhs) const
-    {
-      return !(*this == rhs);
-    }
-
-    uint32_t getClockFreq() const
-    {
-      return clockFreq;
-    }
-    SPIMode getDataMode() const
-    {
-      return dataMode;
-    }
-    BitOrder getBitOrder() const
-    {
-      return (bitOrder);
-    }
-    bool getSkipRecv() const
-    {
-      return skipRecv;
-    }
-
-    void setClockFreq(uint32_t clkFreq)
-    {
-      clockFreq = clkFreq;
-    }
-    void setDataMode(SPIMode mode)
-    {
-      dataMode = mode;
-    }
-    void setBitOrder(BitOrder order)
-    {
-      bitOrder = order;
-    }
-    void setSkipRecv(bool skip)
-    {
-      skipRecv = skip;
-    }
-
+    constexpr SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, bool noRecv = SPI_TRANSMITRECEIVE)
+      : clk(clock),
+        bOrder(bitOrder),
+        dMode((spi_mode_e)(
+                (SPI_MODE0 == dataMode) ? SPI_MODE_0 :
+                (SPI_MODE1 == dataMode) ? SPI_MODE_1 :
+                (SPI_MODE2 == dataMode) ? SPI_MODE_2 :
+                (SPI_MODE3 == dataMode) ? SPI_MODE_3 :
+                SPI_MODE0
+              )),
+        noReceive(noRecv)
+    { }
+    constexpr SPISettings()
+      : clk(SPI_SPEED_CLOCK_DEFAULT),
+        bOrder(MSBFIRST),
+        dMode(SPI_MODE_0),
+        noReceive(SPI_TRANSMITRECEIVE)
+    { }
   private:
-    void init_MightInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode, bool skipRecv)
-    {
-      init_AlwaysInline(clock, bitOrder, dataMode, skipRecv);
-    }
-
-    // Core developer MUST use an helper function in beginTransaction() to use this data
-    void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode, bool skipRecv) __attribute__((__always_inline__))
-    {
-      this->clockFreq = clock;
-      this->dataMode = dataMode;
-      this->bitOrder = bitOrder;
-      this->skipRecv = skipRecv;
-    }
-
-    uint32_t clockFreq;
-    SPIMode dataMode;
-    BitOrder bitOrder;
-    bool skipRecv;
-
-    friend class HardwareSPI;
+    uint32_t clk;       //specifies the spi bus maximum clock speed
+    BitOrder bOrder;    //bit order (MSBFirst or LSBFirst)
+    spi_mode_e dMode;   //one of the data mode
+    //Mode          Clock Polarity (CPOL)   Clock Phase (CPHA)
+    //SPI_MODE0             0                     0
+    //SPI_MODE1             0                     1
+    //SPI_MODE2             1                     0
+    //SPI_MODE3             1                     1
+    friend class SPIClass;
+    bool noReceive;
 };
 
-const SPISettings DEFAULT_SPI_SETTINGS = SPISettings();
-
 class SPIClass {
   public:
     SPIClass();
@@ -187,7 +125,7 @@ class SPIClass {
       _spi.pin_ssel = (ssel);
     };
 
-    virtual void begin(void);
+    virtual void begin();
     void end(void);
 
     /* This function should be used to configure the SPI instance in case you
@@ -199,21 +137,19 @@ class SPIClass {
     /* Transfer functions: must be called after initialization of the SPI
      * instance with begin() or beginTransaction().
      */
-    virtual uint8_t transfer(uint8_t _data);
+    virtual byte transfer(uint8_t _data);
     virtual uint16_t transfer16(uint16_t _data);
-    virtual void transfer(void *buf, size_t count);
+    virtual void transfer(void *_buf, size_t _count);
 
     /* These methods are deprecated and kept for compatibility.
      * Use SPISettings with SPI.beginTransaction() to configure SPI parameters.
      */
     void setBitOrder(BitOrder);
     void setDataMode(uint8_t);
-    void setDataMode(SPIMode);
     void setClockDivider(uint8_t);
 
-    // Not implemented functions. Kept for compatibility.
-    void usingInterrupt(int interruptNumber);
-    void notUsingInterrupt(int interruptNumber);
+    // Not implemented functions. Kept for backward compatibility.
+    void usingInterrupt(uint8_t interruptNumber);
     void attachInterrupt(void);
     void detachInterrupt(void);
 
@@ -229,7 +165,7 @@ class SPIClass {
 
   private:
     /* Current SPISettings */
-    SPISettings   _spiSettings = DEFAULT_SPI_SETTINGS;
+    SPISettings   _spiSettings = SPISettings();
 };
 
 extern SPIClass SPI;
diff --git a/libraries/SPI/src/utility/spi_com.c b/libraries/SPI/src/utility/spi_com.c
@@ -227,7 +227,7 @@ static uint32_t compute_disable_delay(spi_t *obj)
   * @param  msb : set to 1 in msb first
   * @retval None
   */
-void spi_init(spi_t *obj, uint32_t speed, SPIMode mode, uint8_t msb)
+void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
 {
   if (obj == NULL) {
     return;
@@ -313,13 +313,13 @@ void spi_init(spi_t *obj, uint32_t speed, SPIMode mode, uint8_t msb)
 
   handle->Init.Direction         = SPI_DIRECTION_2LINES;
 
-  if ((mode == SPI_MODE0) || (mode == SPI_MODE2)) {
+  if ((mode == SPI_MODE_0) || (mode == SPI_MODE_2)) {
     handle->Init.CLKPhase          = SPI_PHASE_1EDGE;
   } else {
     handle->Init.CLKPhase          = SPI_PHASE_2EDGE;
   }
 
-  if ((mode == SPI_MODE0) || (mode == SPI_MODE1)) {
+  if ((mode == SPI_MODE_0) || (mode == SPI_MODE_1)) {
     handle->Init.CLKPolarity       = SPI_POLARITY_LOW;
   } else {
     handle->Init.CLKPolarity       = SPI_POLARITY_HIGH;
diff --git a/libraries/SPI/src/utility/spi_com.h b/libraries/SPI/src/utility/spi_com.h
