bsp:k230:add pdma support for uart driver

Added pdma support for uart driver and a test file test_uart.c.
The test uses pdma to improve uart send speed,
to check if the driver works correctly.

Signed-off-by: XU HU [email protected]

Author: DannyRay019

bsp/k230/.config

@@ -192,7 +192,7 @@ CONFIG_RT_USING_DEVICE_OPS=y
 # CONFIG_RT_USING_THREADSAFE_PRINTF is not set
 CONFIG_RT_USING_CONSOLE=y
 CONFIG_RT_CONSOLEBUF_SIZE=256
-CONFIG_RT_CONSOLE_DEVICE_NAME="uart"
+CONFIG_RT_CONSOLE_DEVICE_NAME="uart0"
 CONFIG_RT_VER_NUM=0x50201
 CONFIG_RT_USING_STDC_ATOMIC=y
 CONFIG_RT_BACKTRACE_LEVEL_MAX_NR=32
@@ -1594,6 +1594,12 @@ CONFIG_PKG_ZLIB_VER="latest"
 # CONFIG_BSP_USING_ADC is not set
 # CONFIG_BSP_USING_TS is not set
 # CONFIG_BSP_USING_PWM is not set
+CONFIG_BSP_USING_UART=y
+CONFIG_BSP_USING_UART0=y
+# CONFIG_BSP_USING_UART1 is not set
+# CONFIG_BSP_USING_UART2 is not set
+# CONFIG_BSP_USING_UART3 is not set
+# CONFIG_BSP_USING_UART4 is not set
 CONFIG_BSP_USING_HARDLOCK=y
 CONFIG_BSP_USING_SDIO=y
 CONFIG_BSP_USING_SDIO0=y

bsp/k230/board/Kconfig

@@ -25,6 +25,33 @@ menu "Drivers Configuration"
                 default n
 
         endif
+    
+    menuconfig BSP_USING_UART
+        bool "Enable UART"
+        select RT_USING_UART
+        default n
+
+        if BSP_USING_UART
+            config BSP_USING_UART0
+                bool "Enable UART0"
+                default n
+
+            config BSP_USING_UART1
+                bool "Enable UART1"
+                default n
+            
+            config BSP_USING_UART2
+                bool "Enable UART2"
+                default n
+            
+            config BSP_USING_UART3
+                bool "Enable UART3"
+                default n
+            
+            config BSP_USING_UART4
+                bool "Enable UART4"
+                default n
+        endif
 
     config BSP_USING_HARDLOCK
         bool "Enable Hard-Lock"

bsp/k230/drivers/interdrv/uart/drv_uart.c

@@ -9,16 +9,36 @@
 #include <rtdevice.h>
 #include <lwp_user_mm.h>
 #include <ioremap.h>
-
+#include <rtdbg.h>
 #include "board.h"
+#include "drv_pdma.h"
+#include <mmu.h>
 #include "drv_uart.h"
 #include "riscv_io.h"
 
+typedef enum
+{
+    TEST_PDMA_EVENT_NONE,
+    TEST_PDMA_EVENT_COMPLETE,
+    TEST_PDMA_EVENT_TIMEOUT
+} test_pdma_event_t;
+
+static rt_event_t uart_pdma_event = RT_NULL;
+
+void uart_pdma_call_back(rt_uint8_t ch, rt_bool_t is_done)
+{
+    /* Send completion or timeout event based on callback status */
+    test_pdma_event_t event_type = is_done ? TEST_PDMA_EVENT_COMPLETE : TEST_PDMA_EVENT_TIMEOUT;
+    rt_event_send(uart_pdma_event, event_type);
+}
+
 #define UART_DEFAULT_BAUDRATE       115200
 #define UART_CLK                    50000000
-#define UART_ADDR UART0_BASE_ADDR
-#define UART_IRQ K230_IRQ_UART0
-
+#define UART0_IRQ                   K230_IRQ_UART0
+#define UART1_IRQ                   K230_IRQ_UART1
+#define UART2_IRQ                   K230_IRQ_UART2
+#define UART3_IRQ                   K230_IRQ_UART3
+#define UART4_IRQ                   K230_IRQ_UART4
 
 #define UART_RBR (0x00)       /* receive buffer register */
 #define UART_THR (0x00)       /* transmit holding register */
@@ -95,25 +115,81 @@ struct device_uart
     rt_ubase_t  hw_base;
     void*  pa_base;
     rt_uint32_t irqno;
+
 };
 
 static rt_err_t  rt_uart_configure(struct rt_serial_device *serial, struct serial_configure *cfg);
 static rt_err_t  uart_control(struct rt_serial_device *serial, int cmd, void *arg);
 static int       drv_uart_putc(struct rt_serial_device *serial, char c);
 static int       drv_uart_getc(struct rt_serial_device *serial);
+static rt_ssize_t uart_dma_tran(struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size, int direction);
 
-const struct rt_uart_ops _uart_ops =
+const struct rt_uart_ops _uart_ops = 
 {
-    rt_uart_configure,
-    uart_control,
-    drv_uart_putc,
-    drv_uart_getc,
-    //TODO: add DMA support
-    RT_NULL
+    .configure    = rt_uart_configure,
+    .control      = uart_control,
+    .putc         = drv_uart_putc,
+    .getc         = drv_uart_getc,
+    .dma_transmit = uart_dma_tran
 };
 
-struct rt_serial_device  serial1;
-struct device_uart       uart1;
+struct k230_uart_dev
+{
+    struct rt_serial_device serial;
+    struct device_uart      uart;
+    const char *name;
+    rt_uint32_t pa_base;
+    rt_uint32_t uart_to_size;
+    rt_uint32_t irqno;
+};
+
+/* 支持的 UART 设备列表 */
+static struct k230_uart_dev uart_devs[] =
+{
+#ifdef BSP_USING_UART0
+    {
+        .name   = "uart0",
+        .pa_base = UART0_BASE_ADDR,
+        .uart_to_size = UART0_IO_SIZE,
+        .irqno   = UART0_IRQ,
+    },
+#endif
+#ifdef BSP_USING_UART1
+    {
+        .name   = "uart1",
+        .pa_base = UART1_BASE_ADDR,
+        .uart_to_size = UART1_IO_SIZE,
+        .irqno   = UART1_IRQ,
+    },
+#endif
+#ifdef BSP_USING_UART2
+    {
+        .name   = "uart2",
+        .pa_base = UART2_BASE_ADDR,
+        .uart_to_size = UART2_IO_SIZE,
+        .irqno   = UART2_IRQ,
+    },
+#endif
+#ifdef BSP_USING_UART3
+    {
+        .name   = "uart3",
+        .pa_base = UART3_BASE_ADDR,
+        .uart_to_size = UART3_IO_SIZE,
+        .irqno   = UART3_IRQ,
+    },
+#endif
+#ifdef BSP_USING_UART4
+    {
+        .name   = "uart4",
+        .pa_base = UART4_BASE_ADDR,
+        .uart_to_size = UART4_IO_SIZE,
+        .irqno   = UART4_IRQ,
+    },
+#endif
+#if !defined(BSP_USING_UART0) && !defined(BSP_USING_UART1) && !defined(BSP_USING_UART2) && !defined(BSP_USING_UART3) && !defined(BSP_USING_UART4)
+#error "No UART device defined!"
+#endif
+};
 
 #define write32(addr, val) writel(val, (void*)(addr))
 #define read32(addr) readl((void*)(addr))
@@ -150,7 +226,8 @@ static void _uart_init(void *uart_base)
     write32(uart_base + UART_IER, 0x00);
     /* Enable DLAB */
     write32(uart_base + UART_LCR, 0x80);
-    if (bdiv) {
+    if (bdiv)
+    {
         /* Set divisor low byte */
         write32(uart_base + UART_DLL, dll);
         /* Set divisor high byte */
@@ -301,6 +378,109 @@ static int drv_uart_getc(struct rt_serial_device *serial)
     return (int)*rbr;
 }
 
+static rt_ssize_t uart_dma_write(struct rt_serial_device *serial, const void *buffer, rt_size_t size)
+{
+    rt_uint8_t ch;
+    rt_err_t err;
+    rt_uint32_t recv_event;
+
+    struct k230_uart_dev *uart_dev = rt_container_of(serial, struct k230_uart_dev, serial);
+    uint32_t len = RT_ALIGN(size, 64);
+    uint8_t *buf = rt_malloc_align(len, 64);
+    rt_memcpy(buf, buffer, size);
+    rt_hw_cpu_dcache_clean((void*)buf, len);
+    void *buf_pa = rt_kmem_v2p(buf);
+    rt_event_control(uart_pdma_event, RT_IPC_CMD_RESET, NULL);
+
+    /* Configure DMA transfer */
+    err = k230_pdma_request_channel(&ch);
+
+    usr_pdma_cfg_t pdma_cfg;
+    /* Configure DMA parameters */
+    if (!strcmp(uart_dev->name, "uart0"))
+    {
+        pdma_cfg.device = UART0_TX;
+    }
+    else if (!strcmp(uart_dev->name, "uart1"))
+    {
+        pdma_cfg.device = UART1_TX;
+    }
+    else if (!strcmp(uart_dev->name, "uart2"))
+    {
+        pdma_cfg.device = UART2_TX;
+    }
+    else if (!strcmp(uart_dev->name, "uart3"))
+    {
+        pdma_cfg.device = UART3_TX;
+    }
+    else if (!strcmp(uart_dev->name, "uart4"))
+    {
+        pdma_cfg.device = UART4_TX;
+    }
+    
+    pdma_cfg.src_addr = buf_pa;
+    pdma_cfg.dst_addr = (rt_uint8_t *)uart_dev->pa_base;
+    pdma_cfg.line_size = len;
+
+    /* Set channel configuration */
+    pdma_cfg.pdma_ch_cfg.ch_src_type = CONTINUE;
+    pdma_cfg.pdma_ch_cfg.ch_dev_hsize = PSBYTE1;
+    pdma_cfg.pdma_ch_cfg.ch_dat_endian = PDEFAULT;
+    pdma_cfg.pdma_ch_cfg.ch_dev_blen = PBURST_LEN_16;
+    pdma_cfg.pdma_ch_cfg.ch_priority = 7;
+    pdma_cfg.pdma_ch_cfg.ch_dev_tout = 0xFFF;
+
+    err = k230_pdma_set_callback(ch, uart_pdma_call_back);
+    if(err != RT_EOK)
+    {
+        LOG_E("pdma_set_callback failed, err=%d\n", err);
+    }
+    err = k230_pdma_config(ch, &pdma_cfg);
+    if(err != RT_EOK)
+    {
+        LOG_E("pdma_config failed, err=%d\n", err);
+    }
+    /* Start transfer and wait for completion */
+    err = k230_pdma_start(ch);
+    if(err != RT_EOK)
+    {
+        LOG_E("pdma_start failed, err=%d\n", err);
+    }
+    err = rt_event_recv(uart_pdma_event,
+                       TEST_PDMA_EVENT_COMPLETE | TEST_PDMA_EVENT_TIMEOUT,
+                       RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                       RT_WAITING_FOREVER,
+                       &recv_event);
+    /* Cleanup */
+    if(err != RT_EOK)
+    {
+        LOG_E("event_recv failed, err=%d\n", err);
+    }
+    err = k230_pdma_stop(ch);
+    if(err != RT_EOK)
+    {
+        LOG_E("pdma_stop failed, err=%d\n", err);
+    }
+    err = k230_pdma_release_channel(ch);
+    if(err != RT_EOK)
+    {
+        LOG_E("pdma_release_channel failed, err=%d\n", err);
+    }
+    rt_free_align(buf);
+    return size;
+}
+
+static rt_ssize_t uart_dma_tran(struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size, int direction)
+{
+    rt_ssize_t len;
+    if (RT_SERIAL_DMA_TX == direction)
+    {
+        len = uart_dma_write(serial, (void*)buf, size);
+    }
+    rt_hw_serial_isr(serial, RT_SERIAL_EVENT_TX_DMADONE);
+    return len;
+}
+
 static void rt_hw_uart_isr(int irq, void *param)
 {
     struct rt_serial_device *serial = (struct rt_serial_device*)param;
@@ -331,7 +511,7 @@ static void rt_hw_uart_isr(int irq, void *param)
         }
     #ifdef RT_USING_SERIAL_V2
         uint8_t data;
-
+        
         do {
             data = readb((void*)(uart_base + UART_RBR));
             rt_ringbuffer_putchar(&(rx_fifo->rb), data);
@@ -354,32 +534,49 @@ static void rt_hw_uart_isr(int irq, void *param)
  */
 int rt_hw_uart_init(void)
 {
-    struct rt_serial_device *serial;
-    struct device_uart      *uart;
     struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    rt_err_t ret;
 
+    uart_pdma_event = (rt_event_t)rt_malloc(sizeof(struct rt_event));
+    if (uart_pdma_event == RT_NULL)
     {
-        serial  = &serial1;
-        uart    = &uart1;
+        LOG_E("Failed to allocate memory for pdma_event!");
+        return -RT_ENOMEM;
+    }
 
-        serial->ops              = &_uart_ops;
-        serial->config           = config;
-        serial->config.baud_rate = UART_DEFAULT_BAUDRATE;
+    if (rt_event_init(uart_pdma_event, "pdma_event", RT_IPC_FLAG_FIFO) != RT_EOK)
+    {
+        LOG_E("Failed to init pdma_event!");
+        rt_free(uart_pdma_event);
+        return -RT_ERROR;
+    }
 
-        uart->pa_base = (void *)UART_ADDR;
-        uart->hw_base = (rt_base_t)rt_ioremap(uart->pa_base, 0x1000);
-        uart->irqno     = UART_IRQ;
+    for (int i = 0; i < sizeof(uart_devs)/sizeof(uart_devs[0]); i++)
+    {
+        struct k230_uart_dev *dev = &uart_devs[i];
 
-        _uart_init((void*)(uart->hw_base));
+        dev->serial.ops = &_uart_ops;
+        dev->serial.config = config;
+        dev->serial.config.baud_rate = UART_DEFAULT_BAUDRATE;
 
-        rt_hw_interrupt_install(uart->irqno, rt_hw_uart_isr, serial, "uart1");
-        rt_hw_interrupt_umask(uart->irqno);
+        dev->uart.pa_base = (void *)dev->pa_base;
+        dev->uart.hw_base = (rt_base_t)rt_ioremap(dev->uart.pa_base, dev->uart_to_size);
+        dev->uart.irqno   = dev->irqno;
 
-        rt_hw_serial_register(serial,
-                              RT_CONSOLE_DEVICE_NAME,
-                              RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
-                              uart);
-    }
+        _uart_init((void*)(dev->uart.hw_base));
 
-    return 0;
-}
+        rt_hw_interrupt_install(dev->uart.irqno, rt_hw_uart_isr, &dev->serial, dev->name);
+        rt_hw_interrupt_umask(dev->uart.irqno);
+
+        ret = rt_hw_serial_register(&dev->serial,
+                                    dev->name,
+                                    RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_DMA_TX,
+                                    &dev->uart);
+        if (ret != RT_EOK)
+        {
+            LOG_E("Failed to register %s, ret=%d\n", dev->name, ret);
+            return ret;
+        }
+    }
+    return RT_EOK;
+}

bsp/k230/drivers/utest/SConscript

@@ -24,6 +24,9 @@ if GetDepend('RT_UTEST_USING_ALL_CASES') or GetDepend('BSP_UTEST_DRIVERS'):
     if GetDepend('BSP_USING_TS'):
         src += ['test_ts.c']
 
+    if GetDepend('BSP_USING_UART'):
+        src += ['test_uart.c']
+     
 group = DefineGroup('utestcases', src, depend = [''])
 
 Return('group')