update usart driver

bsp/gd32450z-eval/drivers/board.c

@@ -122,18 +122,13 @@ void rt_hw_board_init()
     
     SystemClock_Config();
     
-#ifdef RT_USING_CONSOLE
-    rt_console_set_device(CONSOLE_DEVICE);
-#endif
-    
 #ifdef RT_USING_COMPONENTS_INIT
     rt_components_board_init();
-
-#else
-    SDRAM_Init();
-    mpu_init();
 #endif
 
+#ifdef RT_USING_CONSOLE
+    rt_console_set_device(CONSOLE_DEVICE);
+#endif
 }
 
 /*@}*/

bsp/gd32450z-eval/drivers/board.h

@@ -49,20 +49,33 @@ extern int __bss_end;
 
 #define HEAP_END          GD32_SRAM_END
 
-// <o> Console on USART: <0=> no console <1=>USART 1 <2=>USART 2 <3=> USART 3
+// <o> Console on USART: 
+//  <127=> no console 
+//  <0=>USART 0 <1=>USART 1 <2=>USART 2 <3=> USART 3
+//  <4=>USART 4 <5=>USART 5 <6=>USART 6 <7=> USART 7
 // 	<i>Default: 1
-#define GD32_CONSOLE_USART		1
+#define GD32_CONSOLE_USART		0
 
 void rt_hw_board_init(void);
 
-#if GD32_CONSOLE_USART == 0
-#define CONSOLE_DEVICE "no"
+#if GD32_CONSOLE_USART == 127
+    #define CONSOLE_DEVICE "no"
+#elif GD32_CONSOLE_USART == 0
+    #define CONSOLE_DEVICE "uart0"
 #elif GD32_CONSOLE_USART == 1
-#define CONSOLE_DEVICE "uart1"
+    #define CONSOLE_DEVICE "uart1"
 #elif GD32_CONSOLE_USART == 2
-#define CONSOLE_DEVICE "uart2"
+    #define CONSOLE_DEVICE "uart2"
 #elif GD32_CONSOLE_USART == 3
-#define CONSOLE_DEVICE "uart3"
+    #define CONSOLE_DEVICE "uart3"
+#elif GD32_CONSOLE_USART == 4
+    #define CONSOLE_DEVICE "uart4"
+#elif GD32_CONSOLE_USART == 5
+    #define CONSOLE_DEVICE "uart5"
+#elif GD32_CONSOLE_USART == 6
+    #define CONSOLE_DEVICE "uart6"
+#elif GD32_CONSOLE_USART == 7
+    #define CONSOLE_DEVICE "uart7"
 #endif
 
 #define FINSH_DEVICE_NAME   CONSOLE_DEVICE

bsp/gd32450z-eval/drivers/drv_usart.c

@@ -22,175 +22,151 @@
 
 #include <rtdevice.h>
 
-#ifdef RT_USING_UART1
-#define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
-#define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
-
-/* Definition for USART1 Pins */
-#define USART1_TX_PIN                    GPIO_PIN_9
-#define USART1_TX_GPIO_PORT              GPIOA
-#define USART1_TX_AF                     GPIO_AF7_USART1
-#define USART1_RX_PIN                    GPIO_PIN_10
-#define USART1_RX_GPIO_PORT              GPIOA
-#define USART1_RX_AF                     GPIO_AF7_USART1
-#endif
-
-#ifdef RT_USING_UART2
-#define USART2_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
-#define USART2_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
-
-/* Definition for USART2 Pins */
-#define USART2_TX_PIN                    GPIO_PIN_2
-#define USART2_TX_GPIO_PORT              GPIOA
-#define USART2_TX_AF                     GPIO_AF7_USART2
-#define USART2_RX_PIN                    GPIO_PIN_3
-#define USART2_RX_GPIO_PORT              GPIOA
-#define USART2_RX_AF                     GPIO_AF7_USART2
-#endif
-
-#ifdef RT_USING_UART3
-#define USART3_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOB_CLK_ENABLE()
-#define USART3_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOB_CLK_ENABLE()
-
-/* Definition for USART3 Pins */
-#define USART3_TX_PIN                    GPIO_PIN_10
-#define USART3_TX_GPIO_PORT              GPIOB
-#define USART3_TX_AF                     GPIO_AF7_USART3
-#define USART3_RX_PIN                    GPIO_PIN_11
-#define USART3_RX_GPIO_PORT              GPIOB
-#define USART3_RX_AF                     GPIO_AF7_USART3
-#endif
-
-#ifdef RT_USING_UART4
-#define USART4_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOC_CLK_ENABLE()
-#define USART4_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOC_CLK_ENABLE()
-
-/* Definition for USART4 Pins */
-#define USART4_TX_PIN                    GPIO_PIN_10
-#define USART4_TX_GPIO_PORT              GPIOC
-#define USART4_TX_AF                     GPIO_AF7_USART4
-#define USART4_RX_PIN                    GPIO_PIN_11
-#define USART4_RX_GPIO_PORT              GPIOC
-#define USART4_RX_AF                     GPIO_AF7_USART4
-#endif
-
-#ifdef RT_USING_UART5
-#define USART5_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOD_CLK_ENABLE()
-#define USART5_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOC_CLK_ENABLE()
-
-/* Definition for USART5 Pins */
-#define USART5_TX_PIN                    GPIO_PIN_12
-#define USART5_TX_GPIO_PORT              GPIOC
-#define USART5_TX_AF                     GPIO_AF7_USART5
-#define USART5_RX_PIN                    GPIO_PIN_2
-#define USART5_RX_GPIO_PORT              GPIOD
-#define USART5_RX_AF                     GPIO_AF7_USART5
-#endif
-
 /* GD32 uart driver */
+// Todo: compress uart info
 struct gd32_uart
 {
-    UART_HandleTypeDef UartHandle;
-    IRQn_Type irq;
+    uint32_t uart_periph;           //Todo: 3bits
+    IRQn_Type irqn;                 //Todo: 7bits
+    
+    rcu_periph_enum per_clk;        //Todo: 5bits
+    rcu_periph_enum tx_gpio_clk;    //Todo: 5bits
+    rcu_periph_enum rx_gpio_clk;    //Todo: 5bits
+
+    uint32_t tx_port;               //Todo: 4bits
+    uint16_t tx_af;                 //Todo: 4bits
+    uint16_t tx_pin;                //Todo: 4bits
+    
+    uint32_t rx_port;               //Todo: 4bits
+    uint16_t rx_af;                 //Todo: 4bits
+    uint16_t rx_pin;                //Todo: 4bits
 };
 
+/**
+* @brief UART MSP Initialization
+*        This function configures the hardware resources used in this example:
+*           - Peripheral's clock enable
+*           - Peripheral's GPIO Configuration
+*           - NVIC configuration for UART interrupt request enable
+* @param huart: UART handle pointer
+* @retval None
+*/
+void gd32_uart_gpio_init(struct gd32_uart *uart)
+{
+    /* enable USART clock */
+    rcu_periph_clock_enable(uart->tx_gpio_clk);
+    rcu_periph_clock_enable(uart->rx_gpio_clk);
+    rcu_periph_clock_enable(uart->per_clk);
+
+    /* connect port to USARTx_Tx */
+    gpio_af_set(uart->tx_port, uart->tx_af, uart->tx_pin);
+
+    /* connect port to USARTx_Rx */
+    gpio_af_set(uart->rx_port, uart->rx_af, uart->rx_pin);
+
+    /* configure USART Tx as alternate function push-pull */
+    gpio_mode_set(uart->tx_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, uart->tx_pin);
+    gpio_output_options_set(uart->tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, uart->tx_pin);
+
+    /* configure USART Rx as alternate function push-pull */
+    gpio_mode_set(uart->rx_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, uart->rx_pin);
+    gpio_output_options_set(uart->rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, uart->rx_pin);
+    
+    NVIC_SetPriority(uart->irqn, 0);
+    NVIC_EnableIRQ(uart->irqn);
+}
+
 static rt_err_t gd32_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
 {
-  struct gd32_uart *uart;
-
-  RT_ASSERT(serial != RT_NULL);
-  RT_ASSERT(cfg != RT_NULL);
-
-  uart = (struct gd32_uart *)serial->parent.user_data;
-
-  uart->UartHandle.Init.BaudRate   = cfg->baud_rate;
-  uart->UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
-  uart->UartHandle.Init.Mode       = UART_MODE_TX_RX;
-  uart->UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
-
-  switch (cfg->data_bits)
-  {
-  case DATA_BITS_8:
-      uart->UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
-      break;
-  case DATA_BITS_9:
-      uart->UartHandle.Init.WordLength = UART_WORDLENGTH_9B;
-      break;
-  default:
-      uart->UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
-      break;
-  }
-  switch (cfg->stop_bits)
-  {
-  case STOP_BITS_1:
-      uart->UartHandle.Init.StopBits   = UART_STOPBITS_1;
-      break;
-  case STOP_BITS_2:
-      uart->UartHandle.Init.StopBits   = UART_STOPBITS_2;
-      break;
-  default:
-      uart->UartHandle.Init.StopBits   = UART_STOPBITS_1;
-      break;
-  }
-  switch (cfg->parity)
-  {
-  case PARITY_NONE:
-      uart->UartHandle.Init.Parity     = UART_PARITY_NONE;
-      break;
-  case PARITY_ODD:
-      uart->UartHandle.Init.Parity     = UART_PARITY_ODD;
-      break;
-  case PARITY_EVEN:
-      uart->UartHandle.Init.Parity     = UART_PARITY_EVEN;
-      break;
-  default:
-      uart->UartHandle.Init.Parity     = UART_PARITY_NONE;
-      break;
-  }
-
-  if (HAL_UART_Init(&uart->UartHandle) != HAL_OK)
-  {
-      return RT_ERROR;
-  }
-
-  return RT_EOK;
+    struct gd32_uart *uart;
+
+    RT_ASSERT(serial != RT_NULL);
+    RT_ASSERT(cfg != RT_NULL);
+
+    uart = (struct gd32_uart *)serial->parent.user_data;
+    
+    gd32_uart_gpio_init(uart);
+    
+    usart_baudrate_set(uart->uart_periph, cfg->baud_rate);
+
+    switch (cfg->data_bits)
+    {
+    case DATA_BITS_9:
+        usart_word_length_set(uart->uart_periph, USART_WL_9BIT);
+        break;
+
+    default:
+        usart_word_length_set(uart->uart_periph, USART_WL_8BIT);
+        break;
+    }
+
+    switch (cfg->stop_bits)
+    {
+    case STOP_BITS_2:
+        usart_stop_bit_set(uart->uart_periph, USART_STB_2BIT);
+        break;
+    default:
+        usart_stop_bit_set(uart->uart_periph, USART_STB_1BIT);
+        break;
+    }
+
+    switch (cfg->parity)
+    {
+    case PARITY_ODD:
+        usart_parity_config(uart->uart_periph, USART_PM_ODD);
+        break;
+    case PARITY_EVEN:
+        usart_parity_config(uart->uart_periph, USART_PM_EVEN);
+        break;
+    default:
+        usart_parity_config(uart->uart_periph, USART_PM_NONE);
+        break;
+    }
+
+    usart_receive_config(uart->uart_periph, USART_RECEIVE_ENABLE);
+    usart_transmit_config(uart->uart_periph, USART_TRANSMIT_ENABLE);
+    usart_enable(uart->uart_periph);
+
+    return RT_EOK;
 }
 
 static rt_err_t gd32_control(struct rt_serial_device *serial, int cmd, void *arg)
 {
-  struct gd32_uart *uart;
-
-  RT_ASSERT(serial != RT_NULL);
-  uart = (struct gd32_uart *)serial->parent.user_data;
-
-  switch (cmd)
-  {
-  case RT_DEVICE_CTRL_CLR_INT:
-      /* disable rx irq */
-      NVIC_DisableIRQ(uart->irq);
-      /* disable interrupt */
-      __HAL_UART_DISABLE_IT(&uart->UartHandle, UART_IT_RXNE);
-      break;
-  case RT_DEVICE_CTRL_SET_INT:
-      /* enable rx irq */
-      NVIC_EnableIRQ(uart->irq);
-      /* enable interrupt */
-      __HAL_UART_ENABLE_IT(&uart->UartHandle, UART_IT_RXNE);
-      break;
-  }
-
-  return RT_EOK;
+    struct gd32_uart *uart;
+
+    RT_ASSERT(serial != RT_NULL);
+    uart = (struct gd32_uart *)serial->parent.user_data;
+
+    switch (cmd)
+    {
+    case RT_DEVICE_CTRL_CLR_INT:
+        /* disable rx irq */
+        NVIC_DisableIRQ(uart->irqn);
+        /* disable interrupt */
+        usart_interrupt_disable(uart->uart_periph, USART_INTEN_RBNEIE);
+
+        break;
+    case RT_DEVICE_CTRL_SET_INT:
+        /* enable rx irq */
+        NVIC_EnableIRQ(uart->irqn);
+        /* enable interrupt */
+        usart_interrupt_enable(uart->uart_periph, USART_INTEN_RBNEIE);
+        break;
+    }
+
+    return RT_EOK;
 }
 
-static int gd32_putc(struct rt_serial_device *serial, char c)
+static int gd32_putc(struct rt_serial_device *serial, char ch)
 {
     struct gd32_uart *uart;
 
     RT_ASSERT(serial != RT_NULL);
     uart = (struct gd32_uart *)serial->parent.user_data;
 
-    while((__HAL_UART_GET_FLAG(&uart->UartHandle, UART_FLAG_TXE) == RESET));
-    uart->UartHandle.Instance->DR = c;
+    usart_data_transmit(uart->uart_periph, ch);
+    while((usart_flag_get(uart->uart_periph, USART_FLAG_TC) == RESET));
+    
     return 1;
 }
 
@@ -203,8 +179,8 @@ static int gd32_getc(struct rt_serial_device *serial)
     uart = (struct gd32_uart *)serial->parent.user_data;
 
     ch = -1;
-    if (__HAL_UART_GET_FLAG(&uart->UartHandle, UART_FLAG_RXNE) != RESET)
-        ch = uart->UartHandle.Instance->DR & 0xff;
+    if (usart_flag_get(uart->uart_periph, USART_FLAG_RBNE) != RESET)
+        ch = usart_data_receive(uart->uart_periph);
     return ch;
 }
 
@@ -213,306 +189,64 @@ static int gd32_getc(struct rt_serial_device *serial)
  *
  * @param serial serial device
  */
-static void uart_isr(struct rt_serial_device *serial) {
+static void uart_isr(struct rt_serial_device *serial)
+{
     struct gd32_uart *uart = (struct gd32_uart *) serial->parent.user_data;
 
     RT_ASSERT(uart != RT_NULL);
 
     /* UART in mode Receiver -------------------------------------------------*/
-    if ((__HAL_UART_GET_FLAG(&uart->UartHandle, UART_FLAG_RXNE) != RESET) &&
-            (__HAL_UART_GET_IT_SOURCE(&uart->UartHandle, UART_IT_RXNE) != RESET))
+    if ((usart_interrupt_flag_get(uart->uart_periph, USART_INT_RBNEIE) != RESET) &&
+            (usart_flag_get(uart->uart_periph, USART_FLAG_RBNE) != RESET))
     {
         rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
         /* Clear RXNE interrupt flag */
-        __HAL_UART_CLEAR_FLAG(&uart->UartHandle, UART_FLAG_RXNE);
+        usart_flag_clear(uart->uart_periph, USART_FLAG_RBNE);
     }
 }
 
-/**
-* @brief UART MSP Initialization
-*        This function configures the hardware resources used in this example:
-*           - Peripheral's clock enable
-*           - Peripheral's GPIO Configuration
-*           - NVIC configuration for UART interrupt request enable
-* @param huart: UART handle pointer
-* @retval None
-*/
-void HAL_UART_MspInit(UART_HandleTypeDef *huart)
+static const struct rt_uart_ops gd32_uart_ops =
 {
-    GPIO_InitTypeDef  GPIO_InitStruct;
-
-#if defined(RT_USING_UART1)
-    if (huart->Instance == USART1)
-    {
-        /*##-1- Enable peripherals and GPIO Clocks #################################*/
-        /* Enable GPIO TX/RX clock */
-        USART1_TX_GPIO_CLK_ENABLE();
-        USART1_RX_GPIO_CLK_ENABLE();
-
-        /* Enable USARTx clock */
-        __HAL_RCC_USART1_CLK_ENABLE();
-
-        /*##-2- Configure peripheral GPIO ##########################################*/
-        /* UART TX GPIO pin configuration  */
-        GPIO_InitStruct.Pin       = USART1_TX_PIN;
-        GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
-        GPIO_InitStruct.Pull      = GPIO_PULLUP;
-        GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;
-        GPIO_InitStruct.Alternate = USART1_TX_AF;
-
-        HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);
-
-        /* UART RX GPIO pin configuration  */
-        GPIO_InitStruct.Pin = USART1_RX_PIN;
-        GPIO_InitStruct.Alternate = USART1_RX_AF;
-
-        HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
-
-        HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
-        HAL_NVIC_EnableIRQ(USART1_IRQn);
-    }
-#endif
-
-#if defined(RT_USING_UART2)
-    if (huart->Instance == USART2)
-    {
-        /*##-1- Enable peripherals and GPIO Clocks #################################*/
-        /* Enable GPIO TX/RX clock */
-        USART2_TX_GPIO_CLK_ENABLE();
-        USART2_RX_GPIO_CLK_ENABLE();
-
-        /* Enable USARTx clock */
-        __HAL_RCC_USART2_CLK_ENABLE();
-
-        /*##-2- Configure peripheral GPIO ##########################################*/
-        /* UART TX GPIO pin configuration  */
-        GPIO_InitStruct.Pin       = USART2_TX_PIN;
-        GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
-        GPIO_InitStruct.Pull      = GPIO_PULLUP;
-        GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;
-        GPIO_InitStruct.Alternate = USART2_TX_AF;
-
-        HAL_GPIO_Init(USART2_TX_GPIO_PORT, &GPIO_InitStruct);
-
-        /* UART RX GPIO pin configuration  */
-        GPIO_InitStruct.Pin = USART2_RX_PIN;
-        GPIO_InitStruct.Alternate = USART2_RX_AF;
-
-        HAL_GPIO_Init(USART2_RX_GPIO_PORT, &GPIO_InitStruct);
-
-        HAL_NVIC_SetPriority(USART2_IRQn, 0, 1);
-        HAL_NVIC_EnableIRQ(USART2_IRQn);
-    }
-#endif
-
-#if defined(RT_USING_UART3)
-    if (huart->Instance == USART3)
-    {
-        /*##-1- Enable peripherals and GPIO Clocks #################################*/
-        /* Enable GPIO TX/RX clock */
-        USART3_TX_GPIO_CLK_ENABLE();
-        USART3_RX_GPIO_CLK_ENABLE();
-
-        /* Enable USARTx clock */
-        __HAL_RCC_USART3_CLK_ENABLE();
-
-        /*##-2- Configure peripheral GPIO ##########################################*/
-        /* UART TX GPIO pin configuration  */
-        GPIO_InitStruct.Pin       = USART3_TX_PIN;
-        GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
-        GPIO_InitStruct.Pull      = GPIO_PULLUP;
-        GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;
-        GPIO_InitStruct.Alternate = USART3_TX_AF;
-
-        HAL_GPIO_Init(USART3_TX_GPIO_PORT, &GPIO_InitStruct);
-
-        /* UART RX GPIO pin configuration  */
-        GPIO_InitStruct.Pin = USART3_RX_PIN;
-        GPIO_InitStruct.Alternate = USART3_RX_AF;
-
-        HAL_GPIO_Init(USART3_RX_GPIO_PORT, &GPIO_InitStruct);
-
-        HAL_NVIC_SetPriority(USART3_IRQn, 0, 1);
-        HAL_NVIC_EnableIRQ(USART3_IRQn);
-    }
-#endif
-
-#if defined(RT_USING_UART4)
-    if (huart->Instance == USART4)
-    {
-        /*##-1- Enable peripherals and GPIO Clocks #################################*/
-        /* Enable GPIO TX/RX clock */
-        USART4_TX_GPIO_CLK_ENABLE();
-        USART4_RX_GPIO_CLK_ENABLE();
-
-        /* Enable USARTx clock */
-        __HAL_RCC_USART4_CLK_ENABLE();
-
-        /*##-2- Configure peripheral GPIO ##########################################*/
-        /* UART TX GPIO pin configuration  */
-        GPIO_InitStruct.Pin       = USART4_TX_PIN;
-        GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
-        GPIO_InitStruct.Pull      = GPIO_PULLUP;
-        GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;
-        GPIO_InitStruct.Alternate = USART4_TX_AF;
-
-        HAL_GPIO_Init(USART4_TX_GPIO_PORT, &GPIO_InitStruct);
-
-        /* UART RX GPIO pin configuration  */
-        GPIO_InitStruct.Pin = USART4_RX_PIN;
-        GPIO_InitStruct.Alternate = USART4_RX_AF;
-
-        HAL_GPIO_Init(USART4_RX_GPIO_PORT, &GPIO_InitStruct);
-
-        HAL_NVIC_SetPriority(USART4_IRQn, 0, 1);
-        HAL_NVIC_EnableIRQ(USART4_IRQn);
-    }
-#endif
-
-#if defined(RT_USING_UART5)
-    if (huart->Instance == USART5)
-    {
-        /*##-1- Enable peripherals and GPIO Clocks #################################*/
-        /* Enable GPIO TX/RX clock */
-        USART5_TX_GPIO_CLK_ENABLE();
-        USART5_RX_GPIO_CLK_ENABLE();
-
-        /* Enable USARTx clock */
-        __HAL_RCC_USART5_CLK_ENABLE();
-
-        /*##-2- Configure peripheral GPIO ##########################################*/
-        /* UART TX GPIO pin configuration  */
-        GPIO_InitStruct.Pin       = USART5_TX_PIN;
-        GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
-        GPIO_InitStruct.Pull      = GPIO_PULLUP;
-        GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;
-        GPIO_InitStruct.Alternate = USART5_TX_AF;
-
-        HAL_GPIO_Init(USART5_TX_GPIO_PORT, &GPIO_InitStruct);
-
-        /* UART RX GPIO pin configuration  */
-        GPIO_InitStruct.Pin = USART5_RX_PIN;
-        GPIO_InitStruct.Alternate = USART5_RX_AF;
-
-        HAL_GPIO_Init(USART5_RX_GPIO_PORT, &GPIO_InitStruct);
-
-        HAL_NVIC_SetPriority(USART5_IRQn, 0, 1);
-        HAL_NVIC_EnableIRQ(USART5_IRQn);
-    }
-#endif
-}
+    gd32_configure,
+    gd32_control,
+    gd32_putc,
+    gd32_getc,
+};
 
-/**
-* @brief UART MSP De-Initialization
-*        This function frees the hardware resources used in this example:
-*          - Disable the Peripheral's clock
-*          - Revert GPIO and NVIC configuration to their default state
-* @param huart: UART handle pointer
-* @retval None
-*/
-void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
+#if defined(RT_USING_USART0)
+/* UART1 device driver structure */
+struct gd32_uart usart0 =
 {
-#if defined(RT_USING_UART1)
-    if (huart->Instance == USART1)
-    {
-        /*##-1- Reset peripherals ##################################################*/
-        __HAL_RCC_USART1_FORCE_RESET();
-        __HAL_RCC_USART1_RELEASE_RESET();
-
-        /*##-2- Disable peripherals and GPIO Clocks #################################*/
-        /* Configure UART Tx as alternate function  */
-        HAL_GPIO_DeInit(USART1_TX_GPIO_PORT, USART1_TX_PIN);
-        /* Configure UART Rx as alternate function  */
-        HAL_GPIO_DeInit(USART1_RX_GPIO_PORT, USART1_RX_PIN);
-
-        HAL_NVIC_DisableIRQ(USART1_IRQn);
-    }
-#endif
-
-#if defined(RT_USING_UART2)
-    if (huart->Instance == USART2)
-    {
-        /*##-1- Reset peripherals ##################################################*/
-        __HAL_RCC_USART2_FORCE_RESET();
-        __HAL_RCC_USART2_RELEASE_RESET();
-
-        /*##-2- Disable peripherals and GPIO Clocks #################################*/
-        /* Configure UART Tx as alternate function  */
-        HAL_GPIO_DeInit(USART2_TX_GPIO_PORT, USART2_TX_PIN);
-        /* Configure UART Rx as alternate function  */
-        HAL_GPIO_DeInit(USART2_RX_GPIO_PORT, USART2_RX_PIN);
-
-        HAL_NVIC_DisableIRQ(USART2_IRQn);
-    }
-#endif
-
-#if defined(RT_USING_UART3)
-    if (huart->Instance == USART3)
-    {
-        /*##-1- Reset peripherals ##################################################*/
-        __HAL_RCC_USART3_FORCE_RESET();
-        __HAL_RCC_USART3_RELEASE_RESET();
-
-        /*##-2- Disable peripherals and GPIO Clocks #################################*/
-        /* Configure UART Tx as alternate function  */
-        HAL_GPIO_DeInit(USART3_TX_GPIO_PORT, USART3_TX_PIN);
-        /* Configure UART Rx as alternate function  */
-        HAL_GPIO_DeInit(USART3_RX_GPIO_PORT, USART3_RX_PIN);
-
-        HAL_NVIC_DisableIRQ(USART3_IRQn);
-    }
-#endif
-
-#if defined(RT_USING_UART4)
-    if (huart->Instance == USART4)
-    {
-        /*##-1- Reset peripherals ##################################################*/
-        __HAL_RCC_USART4_FORCE_RESET();
-        __HAL_RCC_USART4_RELEASE_RESET();
-
-        /*##-2- Disable peripherals and GPIO Clocks #################################*/
-        /* Configure UART Tx as alternate function  */
-        HAL_GPIO_DeInit(USART4_TX_GPIO_PORT, USART4_TX_PIN);
-        /* Configure UART Rx as alternate function  */
-        HAL_GPIO_DeInit(USART4_RX_GPIO_PORT, USART4_RX_PIN);
-
-        HAL_NVIC_DisableIRQ(USART4_IRQn);
-    }
-#endif
+    USART0,                                 // uart peripheral index
+    USART0_IRQn,                            // uart iqrn
+    RCU_USART0, RCU_GPIOA, RCU_GPIOA,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOA, GPIO_AF_7, GPIO_PIN_9,           // tx port, tx alternate, tx pin
+    GPIOA, GPIO_AF_7, GPIO_PIN_10,          // rx port, rx alternate, rx pin
+};
+struct rt_serial_device serial0;
 
-#if defined(RT_USING_UART5)
-    if (huart->Instance == USART5)
-    {
-        /*##-1- Reset peripherals ##################################################*/
-        __HAL_RCC_USART5_FORCE_RESET();
-        __HAL_RCC_USART5_RELEASE_RESET();
+void USART0_IRQHandler(void)
+{
+    /* enter interrupt */
+    rt_interrupt_enter();
 
-        /*##-2- Disable peripherals and GPIO Clocks #################################*/
-        /* Configure UART Tx as alternate function  */
-        HAL_GPIO_DeInit(USART5_TX_GPIO_PORT, USART5_TX_PIN);
-        /* Configure UART Rx as alternate function  */
-        HAL_GPIO_DeInit(USART5_RX_GPIO_PORT, USART5_RX_PIN);
+    uart_isr(&serial0);
 
-        HAL_NVIC_DisableIRQ(USART5_IRQn);
-    }
-#endif
+    /* leave interrupt */
+    rt_interrupt_leave();
 }
 
+#endif /* RT_USING_USART0 */
 
-static const struct rt_uart_ops gd32_uart_ops =
-{
-    gd32_configure,
-    gd32_control,
-    gd32_putc,
-    gd32_getc,
-};
-
-#if defined(RT_USING_UART1)
+#if defined(RT_USING_USART1)
 /* UART1 device driver structure */
-struct gd32_uart uart1 =
+struct gd32_uart usart1 =
 {
-    {USART1},
-    USART1_IRQn,
+    USART1,                                 // uart peripheral index
+    USART1_IRQn,                            // uart iqrn
+    RCU_USART1, RCU_GPIOA, RCU_GPIOA,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOA, GPIO_AF_7, GPIO_PIN_2,           // tx port, tx alternate, tx pin
+    GPIOA, GPIO_AF_7, GPIO_PIN_3,           // rx port, rx alternate, rx pin
 };
 struct rt_serial_device serial1;
 
@@ -529,12 +263,15 @@ void USART1_IRQHandler(void)
 
 #endif /* RT_USING_UART1 */
 
-#if defined(RT_USING_UART2)
+#if defined(RT_USING_USART2)
 /* UART2 device driver structure */
-struct gd32_uart uart2 =
+struct gd32_uart usart2 =
 {
-    {USART2},
-    USART2_IRQn,
+    USART2,                                 // uart peripheral index
+    USART2_IRQn,                            // uart iqrn
+    RCU_USART2, RCU_GPIOB, RCU_GPIOB,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOB, GPIO_AF_7, GPIO_PIN_10,          // tx port, tx alternate, tx pin
+    GPIOB, GPIO_AF_7, GPIO_PIN_11,          // rx port, rx alternate, rx pin
 };
 struct rt_serial_device serial2;
 
@@ -555,12 +292,15 @@ void USART2_IRQHandler(void)
 /* UART3 device driver structure */
 struct gd32_uart uart3 =
 {
-    {USART3},
-    USART3_IRQn,
+    UART3,                                 // uart peripheral index
+    UART3_IRQn,                            // uart iqrn
+    RCU_UART3, RCU_GPIOC, RCU_GPIOC,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOC, GPIO_AF_8, GPIO_PIN_10,         // tx port, tx alternate, tx pin
+    GPIOC, GPIO_AF_8, GPIO_PIN_11,         // rx port, rx alternate, rx pin
 };
 struct rt_serial_device serial3;
 
-void USART3_IRQHandler(void)
+void UART3_IRQHandler(void)
 {
     /* enter interrupt */
     rt_interrupt_enter();
@@ -577,8 +317,11 @@ void USART3_IRQHandler(void)
 /* UART4 device driver structure */
 struct gd32_uart uart4 =
 {
-    {UART4},
-    UART4_IRQn,
+    UART4,                                 // uart peripheral index
+    UART4_IRQn,                            // uart iqrn
+    RCU_UART4, RCU_GPIOC, RCU_GPIOD,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOC, GPIO_AF_8, GPIO_PIN_12,         // tx port, tx alternate, tx pin
+    GPIOD, GPIO_AF_8, GPIO_PIN_2,          // rx port, rx alternate, rx pin
 };
 struct rt_serial_device serial4;
 
@@ -594,16 +337,19 @@ void UART4_IRQHandler(void)
 }
 #endif /* RT_USING_UART4 */
 
-#if defined(RT_USING_UART5)
+#if defined(RT_USING_USART5)
 /* UART5 device driver structure */
-struct gd32_uart uart5 =
+struct gd32_uart usart5 =
 {
-    {UART5},
-    UART5_IRQn,
+    USART5,                                 // uart peripheral index
+    USART5_IRQn,                            // uart iqrn
+    RCU_USART5, RCU_GPIOC, RCU_GPIOC,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOC, GPIO_AF_8, GPIO_PIN_6,           // tx port, tx alternate, tx pin
+    GPIOC, GPIO_AF_8, GPIO_PIN_7,           // rx port, rx alternate, rx pin
 };
 struct rt_serial_device serial5;
 
-void UART5_IRQHandler(void)
+void USART5_IRQHandler(void)
 {
     /* enter interrupt */
     rt_interrupt_enter();
@@ -616,14 +362,78 @@ void UART5_IRQHandler(void)
 
 #endif /* RT_USING_UART5 */
 
+#if defined(RT_USING_UART6)
+/* UART6 device driver structure */
+struct gd32_uart uart6 =
+{
+    UART6,                                 // uart peripheral index
+    UART6_IRQn,                            // uart iqrn
+    RCU_UART6, RCU_GPIOE, RCU_GPIOE,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOE, GPIO_AF_8, GPIO_PIN_7,          // tx port, tx alternate, tx pin
+    GPIOE, GPIO_AF_8, GPIO_PIN_8,          // rx port, rx alternate, rx pin
+};
+struct rt_serial_device serial6;
+
+void UART6_IRQHandler(void)
+{
+    /* enter interrupt */
+    rt_interrupt_enter();
+
+    uart_isr(&serial6);
+
+    /* leave interrupt */
+    rt_interrupt_leave();
+}
+
+#endif /* RT_USING_UART6 */
+
+#if defined(RT_USING_UART7)
+/* UART7 device driver structure */
+struct gd32_uart uart7 =
+{
+    UART7,                                 // uart peripheral index
+    UART7_IRQn,                            // uart iqrn
+    RCU_UART7, RCU_GPIOE, RCU_GPIOE,       // periph clock, tx gpio clock, rt gpio clock
+    GPIOE, GPIO_AF_8, GPIO_PIN_0,          // tx port, tx alternate, tx pin
+    GPIOE, GPIO_AF_8, GPIO_PIN_1,          // rx port, rx alternate, rx pin
+};
+struct rt_serial_device serial7;
+
+void UART7_IRQHandler(void)
+{
+    /* enter interrupt */
+    rt_interrupt_enter();
+
+    uart_isr(&serial7);
+
+    /* leave interrupt */
+    rt_interrupt_leave();
+}
+
+#endif /* RT_USING_UART7 */
+
+
 int gd32_hw_usart_init(void)
 {
     struct gd32_uart *uart;
     struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    
+#ifdef RT_USING_USART0
+    uart = &usart0;
+
+    serial0.ops    = &gd32_uart_ops;
+    serial0.config = config;
 
-#ifdef RT_USING_UART1
-    uart = &uart1;
-    uart->UartHandle.Instance = USART1;
+    /* register UART1 device */
+    rt_hw_serial_register(&serial0,
+                          "uart0",
+                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
+                          uart);
+#endif /* RT_USING_USART0 */
+
+
+#ifdef RT_USING_USART1
+    uart = &usart1;
 
     serial1.ops    = &gd32_uart_ops;
     serial1.config = config;
@@ -635,14 +445,13 @@ int gd32_hw_usart_init(void)
                           uart);
 #endif /* RT_USING_UART1 */
 
-#ifdef RT_USING_UART2
-    uart = &uart2;
-    uart->UartHandle.Instance = USART2;
+#ifdef RT_USING_USART2
+    uart = &usart2;
 
     serial2.ops    = &gd32_uart_ops;
     serial2.config = config;
 
-    /* register UART1 device */
+    /* register UART2 device */
     rt_hw_serial_register(&serial2,
                           "uart2",
                           RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
@@ -651,7 +460,6 @@ int gd32_hw_usart_init(void)
 
 #ifdef RT_USING_UART3
     uart = &uart3;
-    uart->UartHandle.Instance = USART3;
 
     serial3.ops    = &gd32_uart_ops;
     serial3.config = config;
@@ -665,7 +473,6 @@ int gd32_hw_usart_init(void)
 
 #ifdef RT_USING_UART4
     uart = &uart4;
-    uart->UartHandle.Instance = USART4;
 
     serial4.ops    = &gd32_uart_ops;
     serial4.config = config;
@@ -677,9 +484,8 @@ int gd32_hw_usart_init(void)
                           uart);
 #endif /* RT_USING_UART4 */
 
-#ifdef RT_USING_UART5
-    uart = &uart5;
-    uart->UartHandle.Instance = USART5;
+#ifdef RT_USING_USART5
+    uart = &usart5;
 
     serial5.ops    = &gd32_uart_ops;
     serial5.config = config;
@@ -690,6 +496,32 @@ int gd32_hw_usart_init(void)
                           RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
                           uart);
 #endif /* RT_USING_UART5 */
+    
+#ifdef RT_USING_UART6
+    uart = &uart6;
+
+    serial6.ops    = &gd32_uart_ops;
+    serial6.config = config;
+
+    /* register UART6 device */
+    rt_hw_serial_register(&serial6,
+                          "uart6",
+                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
+                          uart);
+#endif /* RT_USING_UART6 */
+    
+#ifdef RT_USING_UART7
+    uart = &uart7;
+
+    serial7.ops    = &gd32_uart_ops;
+    serial7.config = config;
+
+    /* register UART7 device */
+    rt_hw_serial_register(&serial7,
+                          "uart7",
+                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
+                          uart);
+#endif /* RT_USING_UART7 */
     return 0;
 }
 INIT_BOARD_EXPORT(gd32_hw_usart_init);