Merge branch 'spi-thread-safe'

* spi-thread-safe:
  remove unnecessary locks
  implement thread-safe spi

Author: me-no-dev

cores/esp32/esp32-hal-spi.c

@@ -13,20 +13,20 @@
 // limitations under the License.
 
 #include "esp32-hal-spi.h"
+#include "esp32-hal.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include "freertos/semphr.h"
 #include "rom/ets_sys.h"
 #include "esp_attr.h"
 #include "esp_intr.h"
 #include "rom/gpio.h"
 #include "soc/spi_reg.h"
+#include "soc/spi_struct.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_sig_map.h"
 #include "soc/dport_reg.h"
 
-#define SPI_REG_BASE(p) ((p==0)?DR_REG_SPI0_BASE:((p==1)?DR_REG_SPI1_BASE:((p==2)?DR_REG_SPI2_BASE:((p==3)?DR_REG_SPI3_BASE:0))))
-#define SPI_DEV(i)   ((spi_dev_t *)(SPI_REG_BASE(i)))
-
 #define SPI_CLK_IDX(p)  ((p==0)?SPICLK_OUT_IDX:((p==1)?SPICLK_OUT_IDX:((p==2)?HSPICLK_OUT_IDX:((p==3)?VSPICLK_OUT_MUX_IDX:0))))
 #define SPI_MISO_IDX(p) ((p==0)?SPIQ_OUT_IDX:((p==1)?SPIQ_OUT_IDX:((p==2)?HSPIQ_OUT_IDX:((p==3)?VSPIQ_OUT_IDX:0))))
 #define SPI_MOSI_IDX(p) ((p==0)?SPID_IN_IDX:((p==1)?SPID_IN_IDX:((p==2)?HSPID_IN_IDX:((p==3)?VSPID_IN_IDX:0))))
@@ -39,6 +39,22 @@
 #define SPI_INUM(u)        (2)
 #define SPI_INTR_SOURCE(u) ((u==0)?ETS_SPI0_INTR_SOURCE:((u==1)?ETS_SPI1_INTR_SOURCE:((u==2)?ETS_SPI2_INTR_SOURCE:((p==3)?ETS_SPI3_INTR_SOURCE:0))))
 
+struct spi_struct_t {
+    spi_dev_t * dev;
+    xSemaphoreHandle lock;
+    uint8_t num;
+};
+
+#define SPI_MUTEX_LOCK()    do {} while (xSemaphoreTake(spi->lock, portMAX_DELAY) != pdPASS)
+#define SPI_MUTEX_UNLOCK()  xSemaphoreGive(spi->lock)
+
+static spi_t _spi_bus_array[4] = {
+    {(volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0},
+    {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1},
+    {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 2},
+    {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 3}
+};
+
 void spiAttachSCK(spi_t * spi, int8_t sck)
 {
     if(!spi) {
@@ -71,8 +87,10 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
             miso = 7;
         }
     }
+    SPI_MUTEX_LOCK();
     pinMode(miso, INPUT);
     pinMatrixInAttach(miso, SPI_MISO_IDX(spi->num), false);
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiAttachMOSI(spi_t * spi, int8_t mosi)
@@ -193,49 +211,61 @@ void spiEnableSSPins(spi_t * spi, uint8_t cs_mask)
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->pin.val &= ~(cs_mask & SPI_CS_MASK_ALL);
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiDisableSSPins(spi_t * spi, uint8_t cs_mask)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->pin.val |= (cs_mask & SPI_CS_MASK_ALL);
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiSSEnable(spi_t * spi)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->user.cs_setup = 1;
     spi->dev->user.cs_hold = 1;
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiSSDisable(spi_t * spi)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->user.cs_setup = 0;
     spi->dev->user.cs_hold = 0;
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiSSSet(spi_t * spi)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->pin.cs_keep_active = 1;
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiSSClear(spi_t * spi)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->pin.cs_keep_active = 0;
+    SPI_MUTEX_UNLOCK();
 }
 
 uint32_t spiGetClockDiv(spi_t * spi)
@@ -251,7 +281,9 @@ void spiSetClockDiv(spi_t * spi, uint32_t clockDiv)
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->clock.val = clockDiv;
+    SPI_MUTEX_UNLOCK();
 }
 
 uint8_t spiGetDataMode(spi_t * spi)
@@ -278,6 +310,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     switch (dataMode) {
     case SPI_MODE1:
         spi->dev->pin.ck_idle_edge = 0;
@@ -297,6 +330,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
         spi->dev->user.ck_out_edge = 0;
         break;
     }
+    SPI_MUTEX_UNLOCK();
 }
 
 uint8_t spiGetBitOrder(spi_t * spi)
@@ -312,20 +346,23 @@ void spiSetBitOrder(spi_t * spi, uint8_t bitOrder)
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     if (SPI_MSBFIRST == bitOrder) {
         spi->dev->ctrl.wr_bit_order = 0;
         spi->dev->ctrl.rd_bit_order = 0;
     } else if (SPI_LSBFIRST == bitOrder) {
         spi->dev->ctrl.wr_bit_order = 1;
         spi->dev->ctrl.rd_bit_order = 1;
     }
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiStopBus(spi_t * spi)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     spi->dev->slave.trans_done = 0;
     spi->dev->slave.slave_mode = 0;
     spi->dev->pin.val = 0;
@@ -335,18 +372,23 @@ void spiStopBus(spi_t * spi)
     spi->dev->ctrl1.val = 0;
     spi->dev->ctrl2.val = 0;
     spi->dev->clock.val = 0;
+    SPI_MUTEX_UNLOCK();
 }
 
 spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder)
 {
-
-    spi_t* spi = (spi_t*) malloc(sizeof(spi_t));
-    if(spi == 0) {
+    if(spi_num > 3){
         return NULL;
     }
 
-    spi->num = spi_num;
-    spi->dev = (spi_dev_t *)SPI_DEV(spi_num);
+    spi_t * spi = &_spi_bus_array[spi_num];
+
+    if(spi->lock == NULL){
+        spi->lock = xSemaphoreCreateMutex();
+        if(spi->lock == NULL) {
+            return NULL;
+        }
+    }
 
     if(spi_num == HSPI) {
         SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI_CLK_EN_1);
@@ -364,6 +406,7 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
     spiSetBitOrder(spi, bitOrder);
     spiSetClockDiv(spi, clockDiv);
 
+    SPI_MUTEX_LOCK();
     spi->dev->user.usr_mosi = 1;
     spi->dev->user.usr_miso = 1;
     spi->dev->user.doutdin = 1;
@@ -372,6 +415,7 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
     for(i=0; i<16; i++) {
         spi->dev->data_buf[i] = 0x00000000;
     }
+    SPI_MUTEX_UNLOCK();
 
     return spi;
 }
@@ -393,13 +437,15 @@ void spiWrite(spi_t * spi, uint32_t *data, uint8_t len)
     if(len > 16) {
         len = 16;
     }
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
     spi->dev->mosi_dlen.usr_mosi_dbitlen = (len * 32) - 1;
     spi->dev->miso_dlen.usr_miso_dbitlen = (len * 32) - 1;
     for(i=0; i<len; i++) {
         spi->dev->data_buf[i] = data[i];
     }
     spi->dev->cmd.usr = 1;
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiRead(spi_t * spi, uint32_t *data, uint8_t len)
@@ -411,31 +457,39 @@ void spiRead(spi_t * spi, uint32_t *data, uint8_t len)
     if(len > 16) {
         len = 16;
     }
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
     for(i=0; i<len; i++) {
         data[i] = spi->dev->data_buf[i];
     }
+    SPI_MUTEX_UNLOCK();
 }
 
 void spiWriteByte(spi_t * spi, uint8_t data)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
     spi->dev->miso_dlen.usr_miso_dbitlen = 7;
     spi->dev->data_buf[0] = data;
     spi->dev->cmd.usr = 1;
+    SPI_MUTEX_UNLOCK();
 }
 
 uint8_t spiReadByte(spi_t * spi)
 {
     if(!spi) {
         return 0;
     }
+    uint8_t data;
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
-    return spi->dev->data_buf[0] & 0xFF;
+    data = spi->dev->data_buf[0] & 0xFF;
+    SPI_MUTEX_UNLOCK();
+    return data;
 }
 
 uint32_t __spiTranslate16(uint16_t data, bool msb)
@@ -480,41 +534,53 @@ void spiWriteWord(spi_t * spi, uint16_t data)
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
     spi->dev->miso_dlen.usr_miso_dbitlen = 15;
     spi->dev->data_buf[0] = __spiTranslate16(data, !spi->dev->ctrl.wr_bit_order);
     spi->dev->cmd.usr = 1;
+    SPI_MUTEX_UNLOCK();
 }
 
 uint16_t spiReadWord(spi_t * spi)
 {
     if(!spi) {
         return 0;
     }
+    uint16_t data;
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
-    return __spiTranslate16(spi->dev->data_buf[0] & 0xFFFF, !spi->dev->ctrl.rd_bit_order);
+    data = __spiTranslate16(spi->dev->data_buf[0] & 0xFFFF, !spi->dev->ctrl.rd_bit_order);
+    SPI_MUTEX_UNLOCK();
+    return data;
 }
 
 void spiWriteLong(spi_t * spi, uint32_t data)
 {
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
     spi->dev->miso_dlen.usr_miso_dbitlen = 31;
     spi->dev->data_buf[0] = __spiTranslate32(data, !spi->dev->ctrl.wr_bit_order);
     spi->dev->cmd.usr = 1;
+    SPI_MUTEX_UNLOCK();
 }
 
 uint32_t spiReadLong(spi_t * spi)
 {
     if(!spi) {
         return 0;
     }
+    uint32_t data;
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
-    return __spiTranslate32(spi->dev->data_buf[0], !spi->dev->ctrl.rd_bit_order);
+    data = __spiTranslate32(spi->dev->data_buf[0], !spi->dev->ctrl.rd_bit_order);
+    SPI_MUTEX_UNLOCK();
+    return data;
 }
 
 void spiTransferBits(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
@@ -529,6 +595,7 @@ void spiTransferBits(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
     uint32_t bytes = (bits + 7) / 8;//64 max
     uint32_t mask = (((uint64_t)1 << bits) - 1) & 0xFFFFFFFF;
 
+    SPI_MUTEX_LOCK();
     while(spi->dev->cmd.usr);
     spi->dev->mosi_dlen.usr_mosi_dbitlen = (bits - 1);
     spi->dev->miso_dlen.usr_miso_dbitlen = (bits - 1);
@@ -555,6 +622,7 @@ void spiTransferBits(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
             *out = __spiTranslate32(spi->dev->data_buf[0] & mask, !spi->dev->ctrl.wr_bit_order);
         }
     }
+    SPI_MUTEX_UNLOCK();
 }
 
 void __spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t bytes)
@@ -605,6 +673,7 @@ void spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t size)
     if(!spi) {
         return;
     }
+    SPI_MUTEX_LOCK();
     while(size) {
         if(size > 64) {
             __spiTransferBytes(spi, data, out, 64);
@@ -620,6 +689,7 @@ void spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t size)
             size = 0;
         }
     }
+    SPI_MUTEX_UNLOCK();
 }
 
 

cores/esp32/esp32-hal-spi.h

@@ -19,8 +19,8 @@
 extern "C" {
 #endif
 
-#include "esp32-hal.h"
-#include "soc/spi_struct.h"
+#include <stdint.h>
+#include <stdbool.h>
 
 #define SPI_HAS_TRANSACTION
 
@@ -51,10 +51,8 @@ extern "C" {
 #define SPI_LSBFIRST 0
 #define SPI_MSBFIRST 1
 
-typedef struct {
-    spi_dev_t * dev;
-    uint8_t num;
-} spi_t;
+struct spi_struct_t;
+typedef struct spi_struct_t spi_t;
 
 spi_t * spiStartBus(uint8_t spi_num, uint32_t freq, uint8_t dataMode, uint8_t bitOrder);
 void spiStopBus(spi_t * spi);