Added a polled exchange function to the SPI driver model, implemented on LPCxxxx SPI drivers.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@2302 35acf78f-673a-0410-8e92-d51de3d6d3f4

10 files changed, 117 insertions, 19 deletions

diff --git a/os/hal/include/spi.h b/os/hal/include/spi.h
index ed8ba8de0..92fccec61 100644
--- a/os/hal/include/spi.h
+++ b/os/hal/include/spi.h
@@ -186,6 +186,21 @@ typedef enum {
   spi_lld_receive(spip, n, rxbuf);                                          \

 }

 

+/**

+ * @brief   Exchanges one frame using a polled wait.

+ * @details This synchronous function exchanges one frame using a polled

+ *          synchronization method. This function is useful when exchanging

+ *          small amount of data on high speed channels, usually in this

+ *          situation is much more efficient just wait for completion using

+ *          polling than suspending the thread waiting for an interrupt.

+ * @note    This API is implemented as a macro in order to minimize latency.

+ *
+ * @param[in] spip      pointer to the @p SPIDriver object

+ * @param[in] frame     the data frame to send over the SPI bus

+ * @return              The received data frame from the SPI bus.

+ */

+#define spiPolledExchange(spip, frame) spi_lld_polled_exchange(spip, frame)

+

 #if SPI_USE_WAIT || defined(__DOXYGEN__)

 /**

  * @brief   Waits for operation completion.

diff --git a/os/hal/platforms/LPC11xx/spi_lld.c b/os/hal/platforms/LPC11xx/spi_lld.c
index becf691a3..8b0081b5e 100644
--- a/os/hal/platforms/LPC11xx/spi_lld.c
+++ b/os/hal/platforms/LPC11xx/spi_lld.c
@@ -234,13 +234,15 @@ void spi_lld_start(SPIDriver *spip) {
 void spi_lld_stop(SPIDriver *spip) {

 

   if (spip->spd_state != SPI_STOP) {

+    spip->spd_ssp->CR1  = 0;

+    spip->spd_ssp->CR0  = 0;

+    spip->spd_ssp->CPSR = 0;

 #if LPC11xx_SPI_USE_SSP0

     if (&SPID1 == spip) {

       LPC_SYSCON->PRESETCTRL &= ~1;

       LPC_SYSCON->SYSAHBCLKCTRL &= ~(1 << 11);

       LPC_SYSCON->SSP0CLKDIV = 0;

       NVICDisableVector(SSP0_IRQn);

-      return;

     }

 #endif

 #if LPC11xx_SPI_USE_SSP1

@@ -249,12 +251,8 @@ void spi_lld_stop(SPIDriver *spip) {
       LPC_SYSCON->SYSAHBCLKCTRL &= ~(1 << 18);

       LPC_SYSCON->SSP1CLKDIV = 0;

       NVICDisableVector(SSP1_IRQn);

-      return;

     }

 #endif

-    spip->spd_ssp->CR1  = 0;

-    spip->spd_ssp->CR0  = 0;

-    spip->spd_ssp->CPSR = 0;

   }

 }

 

@@ -372,6 +370,26 @@ void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf) {
   spip->spd_ssp->IMSC = IMSC_ROR | IMSC_RT | IMSC_TX | IMSC_RX;

 }

 

+/**

+ * @brief   Exchanges one frame using a polled wait.

+ * @details This synchronous function exchanges one frame using a polled

+ *          synchronization method. This function is useful when exchanging

+ *          small amount of data on high speed channels, usually in this

+ *          situation is much more efficient just wait for completion using

+ *          polling than suspending the thread waiting for an interrupt.

+ *

+ * @param[in] spip      pointer to the @p SPIDriver object

+ * @param[in] frame     the data frame to send over the SPI bus

+ * @return              The received data frame from the SPI bus.

+ */

+uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame) {

+

+  spip->spd_ssp->DR = (uint32_t)frame;

+  while ((spip->spd_ssp->SR & SR_RNE) == 0)

+    ;

+  return (uint16_t)spip->spd_ssp->DR;

+}

+

 #endif /* CH_HAL_USE_SPI */

 

 /** @} */

diff --git a/os/hal/platforms/LPC11xx/spi_lld.h b/os/hal/platforms/LPC11xx/spi_lld.h
index 021099097..b3f38056f 100644
--- a/os/hal/platforms/LPC11xx/spi_lld.h
+++ b/os/hal/platforms/LPC11xx/spi_lld.h
@@ -334,6 +334,7 @@ extern "C" {
                         const void *txbuf, void *rxbuf);

   void spi_lld_send(SPIDriver *spip, size_t n, const void *txbuf);

   void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf);

+  uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame);

 #ifdef __cplusplus

 }

 #endif

diff --git a/os/hal/platforms/LPC13xx/spi_lld.c b/os/hal/platforms/LPC13xx/spi_lld.c
index d9b8ef06f..ee6a71c8f 100644
--- a/os/hal/platforms/LPC13xx/spi_lld.c
+++ b/os/hal/platforms/LPC13xx/spi_lld.c
@@ -196,18 +196,17 @@ void spi_lld_start(SPIDriver *spip) {
 void spi_lld_stop(SPIDriver *spip) {

 

   if (spip->spd_state != SPI_STOP) {

+    spip->spd_ssp->CR1  = 0;

+    spip->spd_ssp->CR0  = 0;

+    spip->spd_ssp->CPSR = 0;

 #if LPC13xx_SPI_USE_SSP0

     if (&SPID1 == spip) {

       LPC_SYSCON->PRESETCTRL &= ~1;

       LPC_SYSCON->SYSAHBCLKCTRL &= ~(1 << 11);

       LPC_SYSCON->SSPCLKDIV = 0;

       NVICDisableVector(SSP_IRQn);

-      return;

     }

 #endif

-    spip->spd_ssp->CR1  = 0;

-    spip->spd_ssp->CR0  = 0;

-    spip->spd_ssp->CPSR = 0;

   }

 }

 

@@ -325,6 +324,26 @@ void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf) {
   spip->spd_ssp->IMSC = IMSC_ROR | IMSC_RT | IMSC_TX | IMSC_RX;

 }

 

+/**

+ * @brief   Exchanges one frame using a polled wait.

+ * @details This synchronous function exchanges one frame using a polled

+ *          synchronization method. This function is useful when exchanging

+ *          small amount of data on high speed channels, usually in this

+ *          situation is much more efficient just wait for completion using

+ *          polling than suspending the thread waiting for an interrupt.

+ *

+ * @param[in] spip      pointer to the @p SPIDriver object

+ * @param[in] frame     the data frame to send over the SPI bus

+ * @return              The received data frame from the SPI bus.

+ */

+uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame) {

+

+  spip->spd_ssp->DR = (uint32_t)frame;

+  while ((spip->spd_ssp->SR & SR_RNE) == 0)

+    ;

+  return (uint16_t)spip->spd_ssp->DR;

+}

+

 #endif /* CH_HAL_USE_SPI */

 

 /** @} */

diff --git a/os/hal/platforms/LPC13xx/spi_lld.h b/os/hal/platforms/LPC13xx/spi_lld.h
index c85f358b8..add7c3323 100644
--- a/os/hal/platforms/LPC13xx/spi_lld.h
+++ b/os/hal/platforms/LPC13xx/spi_lld.h
@@ -334,6 +334,7 @@ extern "C" {
                         const void *txbuf, void *rxbuf);

   void spi_lld_send(SPIDriver *spip, size_t n, const void *txbuf);

   void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf);

+  uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame);

 #ifdef __cplusplus

 }

 #endif

diff --git a/os/hal/platforms/LPC214x/spi_lld.c b/os/hal/platforms/LPC214x/spi_lld.c
index 7c3287298..6df0106b2 100644
--- a/os/hal/platforms/LPC214x/spi_lld.c
+++ b/os/hal/platforms/LPC214x/spi_lld.c
@@ -99,7 +99,7 @@ static void serve_interrupt(SPIDriver *spip) {
       (void)ssp->SSP_DR;

     if (--spip->spd_rxcnt == 0) {

       chDbgAssert(spip->spd_txcnt == 0,

-                  "chSemResetI(), #1", "counter out of synch");

+                  "spi_serve_interrupt(), #1", "counter out of synch");

       /* Stops the IRQ sources.*/

       ssp->SSP_IMSC = 0;

       /* Portable SPI ISR code defined in the high level driver, note, it is

@@ -178,7 +178,7 @@ void spi_lld_start(SPIDriver *spip) {
   spip->spd_ssp->SSP_ICR  = ICR_RT | ICR_ROR;

   spip->spd_ssp->SSP_CR0  = spip->spd_config->spc_cr0;

   spip->spd_ssp->SSP_CPSR = spip->spd_config->spc_cpsr;

-  spip->spd_ssp->SSP_CR1  = spip->spd_config->spc_cr1 | CR1_SSE;

+  spip->spd_ssp->SSP_CR1  = CR1_SSE;

 }

 

 /**

@@ -191,16 +191,15 @@ void spi_lld_start(SPIDriver *spip) {
 void spi_lld_stop(SPIDriver *spip) {

 

   if (spip->spd_state != SPI_STOP) {

+    spip->spd_ssp->SSP_CR1  = 0;

+    spip->spd_ssp->SSP_CR0  = 0;

+    spip->spd_ssp->SSP_CPSR = 0;

 #if LPC214x_SPI_USE_SSP

     if (&SPID1 == spip) {

       PCONP = (PCONP & PCALL) & ~PCSPI1;

       VICIntEnClear = INTMASK(SOURCE_SPI1);

     }

 #endif

-    spip->spd_ssp->SSP_CR1  = 0;

-    spip->spd_ssp->SSP_CR0  = 0;

-    spip->spd_ssp->SSP_CPSR = 0;

-    PCONP &= ~PCSPI1;

   }

 }

 

@@ -318,6 +317,26 @@ void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf) {
   spip->spd_ssp->SSP_IMSC = IMSC_ROR | IMSC_RT | IMSC_TX | IMSC_RX;

 }

 

+/**

+ * @brief   Exchanges one frame using a polled wait.

+ * @details This synchronous function exchanges one frame using a polled

+ *          synchronization method. This function is useful when exchanging

+ *          small amount of data on high speed channels, usually in this

+ *          situation is much more efficient just wait for completion using

+ *          polling than suspending the thread waiting for an interrupt.

+ *

+ * @param[in] spip      pointer to the @p SPIDriver object

+ * @param[in] frame     the data frame to send over the SPI bus

+ * @return              The received data frame from the SPI bus.

+ */

+uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame) {

+

+  spip->spd_ssp->SSP_DR = (uint32_t)frame;

+  while ((spip->spd_ssp->SSP_SR & SR_RNE) == 0)

+    ;

+  return (uint16_t)spip->spd_ssp->SSP_DR;

+}

+

 #endif /* CH_HAL_USE_SPI */

 

 /** @} */

diff --git a/os/hal/platforms/LPC214x/spi_lld.h b/os/hal/platforms/LPC214x/spi_lld.h
index eafa23f88..a4b16f76a 100644
--- a/os/hal/platforms/LPC214x/spi_lld.h
+++ b/os/hal/platforms/LPC214x/spi_lld.h
@@ -117,10 +117,6 @@ typedef struct {
    */

   uint16_t              spc_cr0;

   /**

-   * @brief SSP CR1 initialization data.

-   */

-  uint16_t              spc_cr1;

-  /**

    * @brief SSP CPSR initialization data.

    */

   uint32_t              spc_cpsr;

@@ -205,6 +201,7 @@ extern "C" {
                         const void *txbuf, void *rxbuf);

   void spi_lld_send(SPIDriver *spip, size_t n, const void *txbuf);

   void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf);

+  uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame);

 #ifdef __cplusplus

 }

 #endif

diff --git a/os/hal/templates/halconf.h b/os/hal/templates/halconf.h
index 20cd4c54e..d5cd47cb5 100644
--- a/os/hal/templates/halconf.h
+++ b/os/hal/templates/halconf.h
@@ -173,6 +173,17 @@
 #define MMC_POLLING_DELAY           10

 #endif

 

+/**

+ * @brief   Uses the SPI polled API for small data transfers.

+ * @details Polled transfers usually improve performance because it

+ *          saves two context switches and interrupt servicing. Note

+ *          that this option has no effect on large transfers which

+ *          are always performed using DMAs/IRQs.

+ */

+#if !defined(MMC_USE_SPI_POLLING) || defined(__DOXYGEN__)

+#define MMC_USE_SPI_POLLING         TRUE

+#endif

+

 /*===========================================================================*/

 /* PAL driver related settings.                                              */

 /*===========================================================================*/

diff --git a/os/hal/templates/spi_lld.c b/os/hal/templates/spi_lld.c
index 1fca51d41..f3053f725 100644
--- a/os/hal/templates/spi_lld.c
+++ b/os/hal/templates/spi_lld.c
@@ -177,6 +177,22 @@ void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf) {
 

 }

 

+/**

+ * @brief   Exchanges one frame using a polled wait.

+ * @details This synchronous function exchanges one frame using a polled

+ *          synchronization method. This function is useful when exchanging

+ *          small amount of data on high speed channels, usually in this

+ *          situation is much more efficient just wait for completion using

+ *          polling than suspending the thread waiting for an interrupt.

+ *

+ * @param[in] spip      pointer to the @p SPIDriver object

+ * @param[in] frame     the data frame to send over the SPI bus

+ * @return              The received data frame from the SPI bus.

+ */

+uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame) {

+

+}

+

 #endif /* CH_HAL_USE_SPI */

 

 /** @} */

diff --git a/os/hal/templates/spi_lld.h b/os/hal/templates/spi_lld.h
index 7fff799d1..acc6a699f 100644
--- a/os/hal/templates/spi_lld.h
+++ b/os/hal/templates/spi_lld.h
@@ -132,6 +132,7 @@ extern "C" {
                         const void *txbuf, void *rxbuf);

   void spi_lld_send(SPIDriver *spip, size_t n, const void *txbuf);

   void spi_lld_receive(SPIDriver *spip, size_t n, void *rxbuf);

+  uint16_t spi_lld_polled_exchange(SPIDriver *spip, uint16_t frame);

 #ifdef __cplusplus

 }

 #endif