[stm32] uart_periph_set_mode with separate tx,rx enable

sw/airborne/arch/lpc21/mcu_periph/uart_arch.c

@@ -62,7 +62,7 @@ static inline void uart_set_baudrate(struct uart_periph* p, uint32_t baud) {
   ((uartRegs_t *)(p->reg_addr))->fcr = UART_FIFO_8;
 }
 
-void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud, bool_t hw_flow_control __attribute__ ((unused))) {
+void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud) {
   uart_disable_interrupts(p);
   uart_set_baudrate(p, baud);
   uart_enable_interrupts(p);

sw/airborne/arch/omap/mcu_periph/uart_arch.c

@@ -30,7 +30,7 @@
 #include "fms/fms_serial_port.h"
 
 
-void uart_periph_set_baudrate(struct uart_periph* p, uint16_t baud, bool_t hw_flow_control __attribute__ ((unused))) {
+void uart_periph_set_baudrate(struct uart_periph* p, uint16_t baud) {
   struct FmsSerialPort* fmssp;
   // close serial port if already open
   if (p->reg_addr != NULL) {
@@ -102,7 +102,7 @@ static inline void uart_handler(struct uart_periph* p) {
 void uart0_init( void ) {
   uart_periph_init(&uart0);
   uart.dev = UART0_DEV;
-  uart_periph_set_baudrate(&uart0,UART0_BAUD,FALSE);
+  uart_periph_set_baudrate(&uart0, UART0_BAUD);
 }
 
 
@@ -117,7 +117,7 @@ void uart0_handler(void) {
 void uart1_init( void ) {
   uart_periph_init(&uart1);
   uart.dev = UART1_DEV;
-  uart_periph_set_baudrate(&uart1,UART1_BAUD,FALSE);
+  uart_periph_set_baudrate(&uart1, UART1_BAUD);
 }
 
 void uart1_handler(void) {

sw/airborne/arch/stm32/mcu_periph/uart_arch.c

@@ -37,21 +37,13 @@
 
 #include BOARD_CONFIG
 
-void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud, bool_t hw_flow_control) {
+void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud) {
 
   /* Configure USART */
   usart_set_baudrate((u32)p->reg_addr, baud);
   usart_set_databits((u32)p->reg_addr, 8);
   usart_set_stopbits((u32)p->reg_addr, USART_STOPBITS_1);
   usart_set_parity((u32)p->reg_addr, USART_PARITY_NONE);
-  usart_set_mode((u32)p->reg_addr, USART_MODE_TX_RX);
-
-  if (hw_flow_control) {
-    usart_set_flow_control((u32)p->reg_addr, USART_FLOWCONTROL_RTS_CTS);
-  }
-  else {
-    usart_set_flow_control((u32)p->reg_addr, USART_FLOWCONTROL_NONE);
-  }
 
   /* Disable Idle Line interrupt */
   USART_CR1((u32)p->reg_addr) &= ~USART_CR1_IDLEIE;
@@ -66,7 +58,24 @@ void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud, bool_t hw_fl
   usart_enable((u32)p->reg_addr);
 
 }
-// XXX: TODO set_mode function
+
+void uart_periph_set_mode(struct uart_periph* p, bool_t tx_enabled, bool_t rx_enabled, bool_t hw_flow_control) {
+  u32 mode = 0;
+  if (tx_enabled)
+    mode |= USART_MODE_TX;
+  if (rx_enabled)
+    mode |= USART_MODE_RX;
+
+  /* set mode to Tx, Rx or TxRx */
+  usart_set_mode((u32)p->reg_addr, mode);
+
+  if (hw_flow_control) {
+    usart_set_flow_control((u32)p->reg_addr, USART_FLOWCONTROL_RTS_CTS);
+  }
+  else {
+    usart_set_flow_control((u32)p->reg_addr, USART_FLOWCONTROL_NONE);
+  }
+}
 
 void uart_transmit(struct uart_periph* p, uint8_t data ) {
 
@@ -147,7 +156,7 @@ static inline void usart_enable_irq(u8 IRQn) {
   nvic_enable_irq(IRQn);
 }
 
-/* Set RCC and GPIO mode
+/** Set RCC and GPIO mode on the STM32F4
  */
 #ifdef STM32F4
 static inline void set_uart_pin(u32 gpioport, u16 gpio, u8 alt_func_num) {
@@ -174,22 +183,28 @@ static inline void set_uart_pin(u32 gpioport, u16 gpio, u8 alt_func_num) {
 
 #ifdef USE_UART1
 
+/* by default enable UART Tx and Rx */
+#ifndef USE_UART1_TX
+#define USE_UART1_TX TRUE
+#endif
+#ifndef USE_UART1_RX
+#define USE_UART1_RX TRUE
+#endif
+
+#ifndef UART1_HW_FLOW_CONTROL
+#define UART1_HW_FLOW_CONTROL FALSE
+#endif
+
 void uart1_init( void ) {
 
   uart_periph_init(&uart1);
   uart1.reg_addr = (void *)USART1;
 
-  /* init RCC and GPIOS */
+  /* init RCC and GPIOs */
 #if defined(STM32F4)
   rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART1EN);
   set_uart_pin(UART1_GPIO_PORT_RX, UART1_GPIO_RX, UART1_GPIO_AF);
   set_uart_pin(UART1_GPIO_PORT_TX, UART1_GPIO_TX, UART1_GPIO_AF);
-#ifdef UART1_GPIO_CTS
-  set_uart_pin(UART1_GPIO_PORT_CTS, UART1_GPIO_CTS, UART1_GPIO_AF);
-#endif
-#ifdef UART1_GPIO_RTS
-  set_uart_pin(UART1_GPIO_PORT_RTS, UART1_GPIO_RTS, UART1_GPIO_AF);
-#endif
 
 #elif defined(STM32F1)
   rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART1EN);
@@ -206,41 +221,54 @@ void uart1_init( void ) {
 
 #if UART1_HW_FLOW_CONTROL
 #warning "USING UART1 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
+  /* setup CTS and RTS gpios */
+#if defined(STM32F4)
+  set_uart_pin(UART1_GPIO_PORT_CTS, UART1_GPIO_CTS, UART1_GPIO_AF);
+  set_uart_pin(UART1_GPIO_PORT_RTS, UART1_GPIO_RTS, UART1_GPIO_AF);
+#elif defined(STM32F1)
   gpio_set_mode(GPIO_BANK_USART1_RTS, GPIO_MODE_OUTPUT_50_MHZ,
                 GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART1_RTS);
   gpio_set_mode(GPIO_BANK_USART1_CTS, GPIO_MODE_INPUT,
                 GPIO_CNF_INPUT_FLOAT, GPIO_USART1_CTS);
+#endif
+#endif
 
   /* Configure USART1, enable hardware flow control*/
-  uart_periph_set_baudrate(&uart1, UART1_BAUD, TRUE);
-#else
-  /* Configure USART1, no flow control */
-  uart_periph_set_baudrate(&uart1, UART1_BAUD, FALSE);
-#endif
+  uart_periph_set_mode(&uart1, USE_UART1_TX, USE_UART1_RX, UART1_HW_FLOW_CONTROL);
+
+  /* Set USART1 baudrate and enable interrupt */
+  uart_periph_set_baudrate(&uart1, UART1_BAUD);
 }
 
 void usart1_isr(void) { usart_isr(&uart1); }
 
 #endif /* USE_UART1 */
 
+
 #ifdef USE_UART2
 
+/* by default enable UART Tx and Rx */
+#ifndef USE_UART2_TX
+#define USE_UART2_TX TRUE
+#endif
+#ifndef USE_UART2_RX
+#define USE_UART2_RX TRUE
+#endif
+
+#ifndef UART2_HW_FLOW_CONTROL
+#define UART2_HW_FLOW_CONTROL FALSE
+#endif
+
 void uart2_init( void ) {
 
   uart_periph_init(&uart2);
   uart2.reg_addr = (void *)USART2;
 
-  /* init RCC */
+  /* init RCC and GPIOs */
 #if defined(STM32F4)
   rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART2EN);
   set_uart_pin(UART2_GPIO_PORT_RX, UART2_GPIO_RX, UART2_GPIO_AF);
   set_uart_pin(UART2_GPIO_PORT_TX, UART2_GPIO_TX, UART2_GPIO_AF);
-#ifdef UART2_GPIO_CTS
-  set_uart_pin(UART2_GPIO_PORT_CTS, UART2_GPIO_CTS, UART2_GPIO_AF);
-#endif
-#ifdef UART2_GPIO_RTS
-  set_uart_pin(UART2_GPIO_PORT_RTS, UART2_GPIO_RTS, UART2_GPIO_AF);
-#endif
 
 #elif defined(STM32F1)
   rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART2EN);
@@ -254,16 +282,39 @@ void uart2_init( void ) {
   /* Enable USART interrupts in the interrupt controller */
   usart_enable_irq(NVIC_USART2_IRQ);
 
+#if UART2_HW_FLOW_CONTROL && defined(STM32F4)
+#warning "USING UART2 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
+  /* setup CTS and RTS pins */
+  set_uart_pin(UART2_GPIO_PORT_CTS, UART2_GPIO_CTS, UART2_GPIO_AF);
+  set_uart_pin(UART2_GPIO_PORT_RTS, UART2_GPIO_RTS, UART2_GPIO_AF);
+#endif
+
+  /* Configure USART Tx,Rx, and hardware flow control*/
+  uart_periph_set_mode(&uart2, USE_UART2_TX, USE_UART2_RX, UART2_HW_FLOW_CONTROL);
+
   /* Configure USART */
-  uart_periph_set_baudrate(&uart2, UART2_BAUD, FALSE);
+  uart_periph_set_baudrate(&uart2, UART2_BAUD);
 }
 
 void usart2_isr(void) { usart_isr(&uart2); }
 
 #endif /* USE_UART2 */
 
+
 #ifdef USE_UART3
 
+/* by default enable UART Tx and Rx */
+#ifndef USE_UART3_TX
+#define USE_UART3_TX TRUE
+#endif
+#ifndef USE_UART3_RX
+#define USE_UART3_RX TRUE
+#endif
+
+#ifndef UART3_HW_FLOW_CONTROL
+#define UART3_HW_FLOW_CONTROL FALSE
+#endif
+
 void uart3_init( void ) {
 
   uart_periph_init(&uart3);
@@ -274,12 +325,7 @@ void uart3_init( void ) {
   rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
   set_uart_pin(UART3_GPIO_PORT_RX, UART3_GPIO_RX, UART3_GPIO_AF);
   set_uart_pin(UART3_GPIO_PORT_TX, UART3_GPIO_TX, UART3_GPIO_AF);
-#ifdef UART3_GPIO_CTS
-  set_uart_pin(UART3_GPIO_PORT_CTS, UART3_GPIO_CTS, UART3_GPIO_AF);
-#endif
-#ifdef UART3_GPIO_RTS
-  set_uart_pin(UART3_GPIO_PORT_RTS, UART3_GPIO_RTS, UART3_GPIO_AF);
-#endif
+
 #elif defined(STM32F1)
   rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
   rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN);
@@ -295,16 +341,35 @@ void uart3_init( void ) {
   /* Enable USART interrupts in the interrupt controller */
   usart_enable_irq(NVIC_USART3_IRQ);
 
+#if UART3_HW_FLOW_CONTROL && defined(STM32F4)
+#warning "USING UART3 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
+  /* setup CTS and RTS pins */
+  set_uart_pin(UART3_GPIO_PORT_CTS, UART3_GPIO_CTS, UART3_GPIO_AF);
+  set_uart_pin(UART3_GPIO_PORT_RTS, UART3_GPIO_RTS, UART3_GPIO_AF);
+#endif
+
+  /* Configure USART Tx,Rx, and hardware flow control*/
+  uart_periph_set_mode(&uart3, USE_UART3_TX, USE_UART3_RX, UART3_HW_FLOW_CONTROL);
+
   /* Configure USART */
-  uart_periph_set_baudrate(&uart3, UART3_BAUD, FALSE);
+  uart_periph_set_baudrate(&uart3, UART3_BAUD);
 }
 
 void usart3_isr(void) { usart_isr(&uart3); }
 
 #endif /* USE_UART3 */
 
+
 #if defined USE_UART4 && defined STM32F4
 
+/* by default enable UART Tx and Rx */
+#ifndef USE_UART4_TX
+#define USE_UART4_TX TRUE
+#endif
+#ifndef USE_UART4_RX
+#define USE_UART4_RX TRUE
+#endif
+
 void uart4_init( void ) {
 
   uart_periph_init(&uart4);
@@ -319,15 +384,25 @@ void uart4_init( void ) {
   usart_enable_irq(NVIC_UART4_IRQ);
 
   /* Configure USART */
-  uart_periph_set_baudrate(&uart4, UART4_BAUD, FALSE);
+  uart_periph_set_mode(&uart4, USE_UART4_TX, USE_UART4_RX, FALSE);
+  uart_periph_set_baudrate(&uart4, UART4_BAUD);
 }
 
 void uart4_isr(void) { usart_isr(&uart4); }
 
 #endif /* USE_UART4 */
 
+
 #ifdef USE_UART5
 
+/* by default enable UART Tx and Rx */
+#ifndef USE_UART5_TX
+#define USE_UART5_TX TRUE
+#endif
+#ifndef USE_UART5_RX
+#define USE_UART5_RX TRUE
+#endif
+
 void uart5_init( void ) {
 
   uart_periph_init(&uart5);
@@ -352,15 +427,29 @@ void uart5_init( void ) {
   usart_enable_irq(NVIC_UART5_IRQ);
 
   /* Configure USART */
-  uart_periph_set_baudrate(&uart5, UART5_BAUD, FALSE);
+  uart_periph_set_mode(&uart5, USE_UART5_TX, USE_UART5_RX, FALSE);
+  uart_periph_set_baudrate(&uart5, UART5_BAUD);
 }
 
 void uart5_isr(void) { usart_isr(&uart5); }
 
 #endif /* USE_UART5 */
 
+
 #if defined USE_UART6 && defined STM32F4
 
+/* by default enable UART Tx and Rx */
+#ifndef USE_UART6_TX
+#define USE_UART6_TX TRUE
+#endif
+#ifndef USE_UART6_RX
+#define USE_UART6_RX TRUE
+#endif
+
+#ifndef UART6_HW_FLOW_CONTROL
+#define UART6_HW_FLOW_CONTROL FALSE
+#endif
+
 void uart6_init( void ) {
 
   uart_periph_init(&uart6);
@@ -372,16 +461,20 @@ void uart6_init( void ) {
   /* init RCC and GPIOs */
   set_uart_pin(UART6_GPIO_PORT_RX, UART6_GPIO_RX, UART6_GPIO_AF);
   set_uart_pin(UART6_GPIO_PORT_TX, UART6_GPIO_TX, UART6_GPIO_AF);
-#ifdef UART6_GPIO_CTS
-  set_uart_pin(UART6_GPIO_PORT_CTS, UART6_GPIO_CTS, UART6_GPIO_AF);
-#endif
-#ifdef UART6_GPIO_RTS
-  set_uart_pin(UART6_GPIO_PORT_RTS, UART6_GPIO_RTS, UART6_GPIO_AF);
-#endif
 
   /* Enable USART interrupts in the interrupt controller */
   usart_enable_irq(NVIC_USART6_IRQ);
 
+#if UART6_HW_FLOW_CONTROL
+#warning "USING UART6 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
+  /* setup CTS and RTS pins */
+  set_uart_pin(UART6_GPIO_PORT_CTS, UART6_GPIO_CTS, UART6_GPIO_AF);
+  set_uart_pin(UART6_GPIO_PORT_RTS, UART6_GPIO_RTS, UART6_GPIO_AF);
+#endif
+
+  /* Configure USART Tx,Rx and hardware flow control*/
+  uart_periph_set_mode(&uart6, USE_UART6_TX, USE_UART6_RX, UART6_HW_FLOW_CONTROL);
+
   uart_periph_set_baudrate(&uart6, UART6_BAUD, FALSE);
 }
 

sw/airborne/mcu_periph/uart.h

@@ -74,7 +74,8 @@ struct uart_periph {
 
 
 extern void uart_periph_init(struct uart_periph* p);
-extern void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud, bool_t hw_flow_control);
+extern void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud);
+extern void uart_periph_set_mode(struct uart_periph* p, bool_t tx_enabled, bool_t rx_enabled, bool_t hw_flow_control);
 extern void uart_transmit(struct uart_periph* p, uint8_t data);
 extern bool_t uart_check_free_space(struct uart_periph* p, uint8_t len);
 extern uint8_t uart_getch(struct uart_periph* p);
@@ -95,7 +96,7 @@ extern void uart0_init(void);
 #define UART0ChAvailable() uart_char_available(&uart0)
 #define UART0Getch() uart_getch(&uart0)
 #define UART0TxRunning uart0.tx_running
-#define UART0SetBaudrate(_b) uart_periph_set_baudrate(&uart0, _b, FALSE)
+#define UART0SetBaudrate(_b) uart_periph_set_baudrate(&uart0, _b)
 
 #endif // USE_UART0
 
@@ -110,11 +111,7 @@ extern void uart1_init(void);
 #define UART1ChAvailable() uart_char_available(&uart1)
 #define UART1Getch() uart_getch(&uart1)
 #define UART1TxRunning uart1.tx_running
-#if UART1_HW_FLOW_CONTROL
-#define UART1SetBaudrate(_b) uart_periph_set_baudrate(&uart1, _b, TRUE)
-#else
-#define UART1SetBaudrate(_b) uart_periph_set_baudrate(&uart1, _b, FALSE)
-#endif
+#define UART1SetBaudrate(_b) uart_periph_set_baudrate(&uart1, _b)
 
 #endif // USE_UART1
 
@@ -144,7 +141,7 @@ extern void uart3_init(void);
 #define UART3ChAvailable() uart_char_available(&uart3)
 #define UART3Getch() uart_getch(&uart3)
 #define UART3TxRunning uart3.tx_running
-#define UART3SetBaudrate(_b) uart_periph_set_baudrate(&uart3, _b, FALSE)
+#define UART3SetBaudrate(_b) uart_periph_set_baudrate(&uart3, _b)
 
 #endif // USE_UART3
 
@@ -159,7 +156,7 @@ extern void uart4_init(void);
 #define UART4ChAvailable() uart_char_available(&uart4)
 #define UART4Getch() uart_getch(&uart4)
 #define UART4TxRunning uart4.tx_running
-#define UART4SetBaudrate(_b) uart_periph_set_baudrate(&uart4, _b, FALSE)
+#define UART4SetBaudrate(_b) uart_periph_set_baudrate(&uart4, _b)
 
 #endif // USE_UART4
 
@@ -174,7 +171,7 @@ extern void uart5_init(void);
 #define UART5ChAvailable() uart_char_available(&uart5)
 #define UART5Getch() uart_getch(&uart5)
 #define UART5TxRunning uart5.tx_running
-#define UART5SetBaudrate(_b) uart_periph_set_baudrate(&uart5, _b, FALSE)
+#define UART5SetBaudrate(_b) uart_periph_set_baudrate(&uart5, _b)
 
 #endif // USE_UART5
 
@@ -189,7 +186,7 @@ extern void uart6_init(void);
 #define UART6ChAvailable() uart_char_available(&uart6)
 #define UART6Getch() uart_getch(&uart6)
 #define UART6TxRunning uart6.tx_running
-#define UART6SetBaudrate(_b) uart_periph_set_baudrate(&uart6, _b, FALSE)
+#define UART6SetBaudrate(_b) uart_periph_set_baudrate(&uart6, _b)
 
 #endif // USE_UART6