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

1 files changed, 28 insertions, 72 deletions

diff --git a/os/hal/platforms/STM32/USARTv1/uart_lld.c b/os/hal/platforms/STM32/USARTv1/uart_lld.c
index cad1cf084..d77d9bd98 100644
--- a/os/hal/platforms/STM32/USARTv1/uart_lld.c
+++ b/os/hal/platforms/STM32/USARTv1/uart_lld.c
@@ -59,16 +59,16 @@
   STM32_DMA_GETCHANNEL(STM32_UART_UART4_RX_DMA_STREAM,                      \

                        STM32_UART4_RX_DMA_CHN)

 

-#define UART4_TX_DMA_CHANNEL                                               \

-  STM32_DMA_GETCHANNEL(STM32_UART_UART4_TX_DMA_STREAM,                     \

+#define UART4_TX_DMA_CHANNEL                                                \

+  STM32_DMA_GETCHANNEL(STM32_UART_UART4_TX_DMA_STREAM,                      \

                        STM32_UART4_TX_DMA_CHN)

 

 #define UART5_RX_DMA_CHANNEL                                                \

   STM32_DMA_GETCHANNEL(STM32_UART_UART5_RX_DMA_STREAM,                      \

                        STM32_UART5_RX_DMA_CHN)

 

-#define UART5_TX_DMA_CHANNEL                                               \

-  STM32_DMA_GETCHANNEL(STM32_UART_UART5_TX_DMA_STREAM,                     \

+#define UART5_TX_DMA_CHANNEL                                                \

+  STM32_DMA_GETCHANNEL(STM32_UART_UART5_TX_DMA_STREAM,                      \

                        STM32_UART5_TX_DMA_CHN)

 

 #define USART6_RX_DMA_CHANNEL                                               \

@@ -79,14 +79,6 @@
   STM32_DMA_GETCHANNEL(STM32_UART_USART6_TX_DMA_STREAM,                     \

                        STM32_USART6_TX_DMA_CHN)

 

-#if (STM32_UART_USE_UART4 || STM32_UART_USE_UART5)

-  #define STM32_UART45_CR2_CHECK_MASK (USART_CR2_STOP_0 | USART_CR2_CLKEN | \

-                        USART_CR2_CPOL | USART_CR2_CPHA | USART_CR2_LBCL)

-

-  #define STM32_UART45_CR3_CHECK_MASK (USART_CR3_CTSIE | USART_CR3_CTSE |   \

-                       USART_CR3_RTSE | USART_CR3_SCEN | USART_CR3_NACK)

-#endif

-

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

 /* Driver exported variables.                                                */

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

@@ -508,28 +500,6 @@ void uart_lld_init(void) {
 }

 

 /**

- * @brief   Check CR2 and CR3 values for compatibility with UART4, UART5.

- *

- * @param[in] uartp     pointer to the @p UARTDriver object

- *

- * @notapi

- */

-#if (STM32_UART_USE_UART4 || STM32_UART_USE_UART5)

-static void uart_check_config(const UARTDriver *uartp) {

-

-  uint16_t cr;

-

-  cr = uartp->config->cr2;

-  chDbgCheck((cr & STM32_UART45_CR2_CHECK_MASK) == 0,

-      "Some flags from CR2 unavailable for this UART");

-

-  cr = uartp->config->cr3;

-  chDbgCheck((cr & STM32_UART45_CR3_CHECK_MASK) == 0,

-      "Some flags from CR3 unavailable for this UART");

-}

-#endif /* (STM32_UART_USE_UART4 || STM32_UART_USE_UART5) */

-

-/**

  * @brief   Configures and activates the UART peripheral.

  *

  * @param[in] uartp     pointer to the @p UARTDriver object

@@ -538,31 +508,22 @@ static void uart_check_config(const UARTDriver *uartp) {
  */

 void uart_lld_start(UARTDriver *uartp) {

 

-#if STM32_UART_USE_UART4

-  if (uartp == &UARTD4)

-    uart_check_config(uartp);

-#elif STM32_UART_USE_UART5

-  else if (uartp == &UARTD5)

-    uart_check_config(uartp);

-#endif

-

   if (uartp->state == UART_STOP) {

 #if STM32_UART_USE_USART1

     if (&UARTD1 == uartp) {

-      bool_t b;

+      bool b;

       b = dmaStreamAllocate(uartp->dmarx,

                             STM32_UART_USART1_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_rx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #1", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       b = dmaStreamAllocate(uartp->dmatx,

                             STM32_UART_USART1_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_tx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #2", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       rccEnableUSART1(FALSE);

-      nvicEnableVector(STM32_USART1_NUMBER,

-                       CORTEX_PRIORITY_MASK(STM32_UART_USART1_IRQ_PRIORITY));

+      nvicEnableVector(STM32_USART1_NUMBER, STM32_UART_USART1_IRQ_PRIORITY);

       uartp->dmamode |= STM32_DMA_CR_CHSEL(USART1_RX_DMA_CHANNEL) |

                         STM32_DMA_CR_PL(STM32_UART_USART1_DMA_PRIORITY);

     }

@@ -570,20 +531,19 @@ void uart_lld_start(UARTDriver *uartp) {
 

 #if STM32_UART_USE_USART2

     if (&UARTD2 == uartp) {

-      bool_t b;

+      bool b;

       b = dmaStreamAllocate(uartp->dmarx,

                             STM32_UART_USART2_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_rx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #3", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       b = dmaStreamAllocate(uartp->dmatx,

                             STM32_UART_USART2_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_tx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #4", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       rccEnableUSART2(FALSE);

-      nvicEnableVector(STM32_USART2_NUMBER,

-                       CORTEX_PRIORITY_MASK(STM32_UART_USART2_IRQ_PRIORITY));

+      nvicEnableVector(STM32_USART2_NUMBER, STM32_UART_USART2_IRQ_PRIORITY);

       uartp->dmamode |= STM32_DMA_CR_CHSEL(USART2_RX_DMA_CHANNEL) |

                         STM32_DMA_CR_PL(STM32_UART_USART2_DMA_PRIORITY);

     }

@@ -591,20 +551,19 @@ void uart_lld_start(UARTDriver *uartp) {
 

 #if STM32_UART_USE_USART3

     if (&UARTD3 == uartp) {

-      bool_t b;

+      bool b;

       b = dmaStreamAllocate(uartp->dmarx,

                             STM32_UART_USART3_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_rx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #5", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       b = dmaStreamAllocate(uartp->dmatx,

                             STM32_UART_USART3_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_tx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #6", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       rccEnableUSART3(FALSE);

-      nvicEnableVector(STM32_USART3_NUMBER,

-                       CORTEX_PRIORITY_MASK(STM32_UART_USART3_IRQ_PRIORITY));

+      nvicEnableVector(STM32_USART3_NUMBER, STM32_UART_USART3_IRQ_PRIORITY);

       uartp->dmamode |= STM32_DMA_CR_CHSEL(USART3_RX_DMA_CHANNEL) |

                         STM32_DMA_CR_PL(STM32_UART_USART3_DMA_PRIORITY);

     }

@@ -612,20 +571,19 @@ void uart_lld_start(UARTDriver *uartp) {
 

 #if STM32_UART_USE_UART4

     if (&UARTD4 == uartp) {

-      bool_t b;

+      bool b;

       b = dmaStreamAllocate(uartp->dmarx,

                             STM32_UART_UART4_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_rx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #7", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       b = dmaStreamAllocate(uartp->dmatx,

                             STM32_UART_UART4_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_tx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #8", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       rccEnableUART4(FALSE);

-      nvicEnableVector(STM32_UART4_NUMBER,

-                       CORTEX_PRIORITY_MASK(STM32_UART_UART4_IRQ_PRIORITY));

+      nvicEnableVector(STM32_UART4_NUMBER, STM32_UART_UART4_IRQ_PRIORITY);

       uartp->dmamode |= STM32_DMA_CR_CHSEL(UART4_RX_DMA_CHANNEL) |

                         STM32_DMA_CR_PL(STM32_UART_UART4_DMA_PRIORITY);

     }

@@ -633,20 +591,19 @@ void uart_lld_start(UARTDriver *uartp) {
 

 #if STM32_UART_USE_UART5

     if (&UARTD5 == uartp) {

-      bool_t b;

+      bool b;

       b = dmaStreamAllocate(uartp->dmarx,

                             STM32_UART_UART5_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_rx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #9", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       b = dmaStreamAllocate(uartp->dmatx,

                             STM32_UART_UART5_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_tx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #10", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       rccEnableUART5(FALSE);

-      nvicEnableVector(STM32_UART5_NUMBER,

-                       CORTEX_PRIORITY_MASK(STM32_UART_UART5_IRQ_PRIORITY));

+      nvicEnableVector(STM32_UART5_NUMBER, STM32_UART_UART5_IRQ_PRIORITY);

       uartp->dmamode |= STM32_DMA_CR_CHSEL(UART5_RX_DMA_CHANNEL) |

                         STM32_DMA_CR_PL(STM32_UART_UART5_DMA_PRIORITY);

     }

@@ -654,20 +611,19 @@ void uart_lld_start(UARTDriver *uartp) {
 

 #if STM32_UART_USE_USART6

     if (&UARTD6 == uartp) {

-      bool_t b;

+      bool b;

       b = dmaStreamAllocate(uartp->dmarx,

                             STM32_UART_USART6_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_rx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #11", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       b = dmaStreamAllocate(uartp->dmatx,

                             STM32_UART_USART6_IRQ_PRIORITY,

                             (stm32_dmaisr_t)uart_lld_serve_tx_end_irq,

                             (void *)uartp);

-      chDbgAssert(!b, "uart_lld_start(), #12", "stream already allocated");

+      osalDbgAssert(!b, "stream already allocated");

       rccEnableUSART6(FALSE);

-      nvicEnableVector(STM32_USART6_NUMBER,

-                       CORTEX_PRIORITY_MASK(STM32_UART_USART6_IRQ_PRIORITY));

+      nvicEnableVector(STM32_USART6_NUMBER, STM32_UART_USART6_IRQ_PRIORITY);

       uartp->dmamode |= STM32_DMA_CR_CHSEL(USART6_RX_DMA_CHANNEL) |

                         STM32_DMA_CR_PL(STM32_UART_USART6_DMA_PRIORITY);

     }