Diff: targets/TARGET_STM/stm_spi_api.c

Revision:

187:0387e8f68319

Parent:

186:707f6e361f3e

Child:

189:f392fc9709a3

--- a/targets/TARGET_STM/stm_spi_api.c	Fri Jun 22 16:45:37 2018 +0100
+++ b/targets/TARGET_STM/stm_spi_api.c	Thu Sep 06 13:40:20 2018 +0100
@@ -42,15 +42,15 @@
 #include "spi_device.h"
 
 #if DEVICE_SPI_ASYNCH
-    #define SPI_INST(obj)    ((SPI_TypeDef *)(obj->spi.spi))
+#define SPI_INST(obj)    ((SPI_TypeDef *)(obj->spi.spi))
 #else
-    #define SPI_INST(obj)    ((SPI_TypeDef *)(obj->spi))
+#define SPI_INST(obj)    ((SPI_TypeDef *)(obj->spi))
 #endif
 
 #if DEVICE_SPI_ASYNCH
-    #define SPI_S(obj)    (( struct spi_s *)(&(obj->spi)))
+#define SPI_S(obj)    (( struct spi_s *)(&(obj->spi)))
 #else
-    #define SPI_S(obj)    (( struct spi_s *)(obj))
+#define SPI_S(obj)    (( struct spi_s *)(obj))
 #endif
 
 #ifndef DEBUG_STDIO
@@ -176,7 +176,7 @@
     if (miso != NC) {
         handle->Init.Direction     = SPI_DIRECTION_2LINES;
     } else {
-       handle->Init.Direction      = SPI_DIRECTION_1LINE;
+        handle->Init.Direction      = SPI_DIRECTION_1LINE;
     }
 
     handle->Init.CLKPhase          = SPI_PHASE_1EDGE;
@@ -311,20 +311,22 @@
  */
 extern int spi_get_clock_freq(spi_t *obj);
 
-static const uint16_t baudrate_prescaler_table[] =	{SPI_BAUDRATEPRESCALER_2,
-                                                    SPI_BAUDRATEPRESCALER_4,
-                                                    SPI_BAUDRATEPRESCALER_8,
-                                                    SPI_BAUDRATEPRESCALER_16,
-                                                    SPI_BAUDRATEPRESCALER_32,
-                                                    SPI_BAUDRATEPRESCALER_64,
-                                                    SPI_BAUDRATEPRESCALER_128,
-                                                    SPI_BAUDRATEPRESCALER_256};
+static const uint16_t baudrate_prescaler_table[] =  {SPI_BAUDRATEPRESCALER_2,
+                                                     SPI_BAUDRATEPRESCALER_4,
+                                                     SPI_BAUDRATEPRESCALER_8,
+                                                     SPI_BAUDRATEPRESCALER_16,
+                                                     SPI_BAUDRATEPRESCALER_32,
+                                                     SPI_BAUDRATEPRESCALER_64,
+                                                     SPI_BAUDRATEPRESCALER_128,
+                                                     SPI_BAUDRATEPRESCALER_256
+                                                    };
 
-void spi_frequency(spi_t *obj, int hz) {
+void spi_frequency(spi_t *obj, int hz)
+{
     struct spi_s *spiobj = SPI_S(obj);
     int spi_hz = 0;
     uint8_t prescaler_rank = 0;
-    uint8_t last_index = (sizeof(baudrate_prescaler_table)/sizeof(baudrate_prescaler_table[0])) - 1;
+    uint8_t last_index = (sizeof(baudrate_prescaler_table) / sizeof(baudrate_prescaler_table[0])) - 1;
     SPI_HandleTypeDef *handle = &(spiobj->handle);
 
     /* Calculate the spi clock for prescaler_rank 0: SPI_BAUDRATEPRESCALER_2 */
@@ -386,7 +388,7 @@
     SPI_HandleTypeDef *handle = &(spiobj->handle);
 
     if (handle->Init.Direction == SPI_DIRECTION_1LINE) {
-        return HAL_SPI_Transmit(handle, (uint8_t*)&value, 1, TIMEOUT_1_BYTE);
+        return HAL_SPI_Transmit(handle, (uint8_t *)&value, 1, TIMEOUT_1_BYTE);
     }
 
 #if defined(LL_SPI_RX_FIFO_TH_HALF)
@@ -441,13 +443,13 @@
     } else {
         /* In case of 1 WIRE only, first handle TX, then Rx */
         if (tx_length != 0) {
-            if (HAL_OK != HAL_SPI_Transmit(handle, (uint8_t*)tx_buffer, tx_length, tx_length*TIMEOUT_1_BYTE)) {
+            if (HAL_OK != HAL_SPI_Transmit(handle, (uint8_t *)tx_buffer, tx_length, tx_length * TIMEOUT_1_BYTE)) {
                 /*  report an error */
                 total = 0;
             }
         }
         if (rx_length != 0) {
-            if (HAL_OK != HAL_SPI_Receive(handle, (uint8_t*)rx_buffer, rx_length, rx_length*TIMEOUT_1_BYTE)) {
+            if (HAL_OK != HAL_SPI_Receive(handle, (uint8_t *)rx_buffer, rx_length, rx_length * TIMEOUT_1_BYTE)) {
                 /*  report an error */
                 total = 0;
             }
@@ -538,18 +540,18 @@
 
     // enable the right hal transfer
     int rc = 0;
-    switch(transfer_type) {
+    switch (transfer_type) {
         case SPI_TRANSFER_TYPE_TXRX:
-            rc = HAL_SPI_TransmitReceive_IT(handle, (uint8_t*)tx, (uint8_t*)rx, words);
+            rc = HAL_SPI_TransmitReceive_IT(handle, (uint8_t *)tx, (uint8_t *)rx, words);
             break;
         case SPI_TRANSFER_TYPE_TX:
-            rc = HAL_SPI_Transmit_IT(handle, (uint8_t*)tx, words);
+            rc = HAL_SPI_Transmit_IT(handle, (uint8_t *)tx, words);
             break;
         case SPI_TRANSFER_TYPE_RX:
             // the receive function also "transmits" the receive buffer so in order
             // to guarantee that 0xff is on the line, we explicitly memset it here
             memset(rx, SPI_FILL_WORD, length);
-            rc = HAL_SPI_Receive_IT(handle, (uint8_t*)rx, words);
+            rc = HAL_SPI_Receive_IT(handle, (uint8_t *)rx, words);
             break;
         default:
             length = 0;
@@ -578,8 +580,9 @@
     bool is16bit = (handle->Init.DataSize == SPI_DATASIZE_16BIT);
 
     // don't do anything, if the buffers aren't valid
-    if (!use_tx && !use_rx)
+    if (!use_tx && !use_rx) {
         return;
+    }
 
     // copy the buffers to the SPI object
     obj->tx_buff.buffer = (void *) tx;
@@ -603,8 +606,8 @@
     // enable the right hal transfer
     if (use_tx && use_rx) {
         // we cannot manage different rx / tx sizes, let's use smaller one
-        size_t size = (tx_length < rx_length)? tx_length : rx_length;
-        if(tx_length != rx_length) {
+        size_t size = (tx_length < rx_length) ? tx_length : rx_length;
+        if (tx_length != rx_length) {
             DEBUG_PRINTF("SPI: Full duplex transfer only 1 size: %d\n", size);
             obj->tx_buff.length = size;
             obj->rx_buff.length = size;
@@ -627,7 +630,7 @@
     if (obj->spi.handle.State == HAL_SPI_STATE_READY) {
         // When HAL SPI is back to READY state, check if there was an error
         int error = obj->spi.handle.ErrorCode;
-        if(error != HAL_SPI_ERROR_NONE) {
+        if (error != HAL_SPI_ERROR_NONE) {
             // something went wrong and the transfer has definitely completed
             event = SPI_EVENT_ERROR | SPI_EVENT_INTERNAL_TRANSFER_COMPLETE;
 
@@ -638,10 +641,10 @@
         } else {
             // else we're done
             event = SPI_EVENT_COMPLETE | SPI_EVENT_INTERNAL_TRANSFER_COMPLETE;
-       }
-       // enable the interrupt
-       NVIC_DisableIRQ(obj->spi.spiIRQ);
-       NVIC_ClearPendingIRQ(obj->spi.spiIRQ);
+        }
+        // enable the interrupt
+        NVIC_DisableIRQ(obj->spi.spiIRQ);
+        NVIC_ClearPendingIRQ(obj->spi.spiIRQ);
     }
 
 
@@ -654,7 +657,7 @@
     SPI_HandleTypeDef *handle = &(spiobj->handle);
     HAL_SPI_StateTypeDef state = HAL_SPI_GetState(handle);
 
-    switch(state) {
+    switch (state) {
         case HAL_SPI_STATE_RESET:
         case HAL_SPI_STATE_READY:
         case HAL_SPI_STATE_ERROR: