创建

828ECO/rt-thread/components/drivers/serial/Kconfig

@@ -0,0 +1,38 @@
+menuconfig RT_USING_SERIAL
+    bool "USING Serial device drivers"
+    select RT_USING_DEVICE_IPC
+    select RT_USING_DEVICE
+    default y
+
+    if RT_USING_SERIAL
+        choice RT_USING_SERIAL_VERSION
+            prompt "Choice Serial version"
+            default RT_USING_SERIAL_V1
+            config RT_USING_SERIAL_V1
+                bool "RT_USING_SERIAL_V1"
+            config RT_USING_SERIAL_V2
+                bool "RT_USING_SERIAL_V2"
+        endchoice
+
+        choice RT_USING_SERIAL_MODE
+            prompt "Choice Serial version"
+            depends on RT_USING_SERIAL_V2
+            default RT_SERIAL_BUF_STRATEGY_OVERWRITE
+            config RT_SERIAL_BUF_STRATEGY_DROP
+                bool "drop new incoming data when the buffer is full"
+            config RT_SERIAL_BUF_STRATEGY_OVERWRITE
+                bool "overwrite old data when the buffer is full"
+        endchoice
+
+        config RT_SERIAL_USING_DMA
+            bool "Enable serial DMA mode"
+            default y
+
+        config RT_SERIAL_RB_BUFSZ
+            int "Set RX buffer size"
+            depends on !RT_USING_SERIAL_V2
+            default 64
+        config RT_USING_SERIAL_BYPASS
+            bool "Using serial bypass"
+            default n
+        endif

828ECO/rt-thread/components/drivers/serial/SConscript

@@ -0,0 +1,32 @@
+from building import *
+
+cwd = GetCurrentDir()
+CPPPATH = [cwd + '/../include']
+group = []
+src = []
+
+if not GetDepend(['RT_USING_SERIAL']):
+    Return('group')
+
+if GetDepend(['RT_USING_SMART']):
+    src += Glob('serial_tty.c')
+
+if GetDepend(['RT_USING_SERIAL_V2']):
+    src += ['dev_serial_v2.c']
+else:
+    src += ['dev_serial.c']
+
+if GetDepend(['RT_USING_SERIAL_BYPASS']):
+    src += ['bypass.c']
+
+if GetDepend(['RT_USING_DM']):
+    src += ['serial_dm.c']
+
+group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH)
+
+list = os.listdir(cwd)
+for item in list:
+    if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
+        group = group + SConscript(os.path.join(item, 'SConscript'))
+
+Return('group')

828ECO/rt-thread/components/drivers/serial/bypass.c

@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2024-11-20     zhujiale     the first version
+ */
+
+#include<rtdevice.h>
+#define DBG_TAG    "UART"
+#define DBG_LVL    DBG_INFO
+#include <rtdbg.h>
+
+static struct rt_serial_bypass_func* rt_bypass_alloc_func(const char* name, rt_uint8_t level, bypass_function_t func, void* data)
+{
+    struct rt_serial_bypass_func* bypass;
+
+    if (!func)
+        return RT_NULL;
+
+    bypass = rt_malloc(sizeof(struct rt_serial_bypass_func));
+    rt_memset(bypass, 0, sizeof(struct rt_serial_bypass_func));
+
+    if (rt_strlen(name) > RT_NAME_MAX - 1)
+        rt_memcpy(bypass->name, name, RT_NAME_MAX);
+    else
+        rt_memcpy(bypass->name, name, rt_strlen(name) + 1);
+
+    bypass->level = level;
+
+    rt_list_init(&bypass->node);
+    bypass->bypass = func;
+    bypass->data = data;
+
+    return bypass;
+}
+
+rt_err_t rt_serial_bypass_init(struct rt_serial_device* serial)
+{
+    serial->bypass = rt_malloc(sizeof(struct rt_serial_bypass));
+    rt_memset(serial->bypass, 0, sizeof(struct rt_serial_bypass));
+#ifdef RT_USING_SERIAL_V2
+    serial->bypass->pipe = rt_ringbuffer_create(serial->config.rx_bufsz);
+#else
+    serial->bypass->pipe = rt_ringbuffer_create(serial->config.bufsz);
+#endif
+    serial->bypass->mutex = rt_mutex_create("serial_bypass", RT_IPC_FLAG_FIFO);
+
+    return RT_EOK;
+}
+
+static rt_err_t rt_bypass_register(struct rt_serial_bypass_head* bypass, const char* name, rt_uint8_t level, bypass_function_t func, void* data)
+{
+    struct rt_serial_bypass_func* pass = RT_NULL;
+    struct rt_list_node* node;
+    int flags;
+
+    RT_DEBUG_NOT_IN_INTERRUPT;
+
+    pass = rt_bypass_alloc_func(name, level, func, data);
+
+    RT_ASSERT(bypass != RT_NULL);
+
+    node = bypass->head.next;
+
+    if (node == &bypass->head)
+    {
+        rt_list_insert_before(&pass->node, node);
+        return RT_EOK;
+    }
+    flags = rt_spin_lock_irqsave(&(bypass->spinlock));
+    do {
+        struct rt_serial_bypass_func* temp_curr;
+        temp_curr = rt_container_of(node, struct rt_serial_bypass_func, node);
+
+        if (level < temp_curr->level)
+        {
+            rt_list_insert_before(node, &pass->node);
+
+            rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
+            return RT_EOK;
+        }
+        else if (level == temp_curr->level)
+        {
+            rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
+            LOG_E("Conflict: bypass [%s] level conflicts with [%s] at level [%d]\n", name, temp_curr->name, level);
+            rt_free(pass);
+            return -RT_ERROR;
+        }
+
+        node = node->next;
+
+    } while (node != &bypass->head);
+
+    rt_list_insert_before(&bypass->head, &pass->node);
+
+    rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
+    return RT_EOK;
+
+}
+
+rt_err_t rt_bypass_upper_register(struct rt_serial_device* serial, const char* name, rt_uint8_t level, bypass_function_t func, void* data)
+{
+    if (!serial->bypass)
+        rt_serial_bypass_init(serial);
+
+    if (!serial->bypass->upper_h)
+    {
+        serial->bypass->upper_h = rt_malloc(sizeof(struct rt_serial_bypass_head));
+        rt_spin_lock_init(&serial->bypass->upper_h->spinlock);
+        rt_list_init(&serial->bypass->upper_h->head);
+
+    }
+
+    return rt_bypass_register(serial->bypass->upper_h, name, level, func, data);
+}
+
+
+
+void rt_bypass_putchar(struct rt_serial_device* serial, rt_uint8_t ch)
+{
+    rt_mutex_take(serial->bypass->mutex, RT_WAITING_FOREVER);
+    rt_ringbuffer_putchar(serial->bypass->pipe, ch);
+    rt_mutex_release(serial->bypass->mutex);
+}
+
+rt_size_t rt_bypass_getchar(struct rt_serial_device* serial, rt_uint8_t* ch)
+{
+    int flags;
+    rt_mutex_take(serial->bypass->mutex, RT_WAITING_FOREVER);
+    flags = rt_ringbuffer_getchar(serial->bypass->pipe, ch);
+    rt_mutex_release(serial->bypass->mutex);
+    return flags;
+}
+
+static inline rt_err_t _bypass_getchar_form_serial_fifo(struct rt_serial_device* serial, char* ch)
+{
+    rt_base_t level;
+    struct rt_serial_rx_fifo* rx_fifo;
+    rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
+    /* disable interrupt */
+    level = rt_spin_lock_irqsave(&(serial->spinlock));
+
+    /* there's no data: */
+#ifdef RT_USING_SERIAL_V2
+    rt_size_t  ringbuf_date_stat;
+    ringbuf_date_stat = rt_ringbuffer_data_len(&rx_fifo->rb);
+    if(!ringbuf_date_stat)
+    {
+        /* no data, enable interrupt and break out */
+        rt_spin_unlock_irqrestore(&(serial->spinlock), level);
+        return -RT_EEMPTY;
+    }
+    if(!rt_ringbuffer_getchar(&rx_fifo->rb, (rt_uint8_t *)ch))
+    {
+        /* Failed to read data */
+        rt_spin_unlock_irqrestore(&(serial->spinlock), level);
+        return -RT_EOK;
+    }
+#else
+    if ((rx_fifo->get_index == rx_fifo->put_index) && (rx_fifo->is_full == RT_FALSE))
+    {
+        /* no data, enable interrupt and break out */
+        rt_spin_unlock_irqrestore(&(serial->spinlock), level);
+        return -RT_EEMPTY;
+    }
+
+    /* otherwise there's the data: */
+    *ch = rx_fifo->buffer[rx_fifo->get_index];
+    rx_fifo->get_index += 1;
+    if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;
+
+    if (rx_fifo->is_full == RT_TRUE)
+    {
+        rx_fifo->is_full = RT_FALSE;
+    }
+#endif
+    /* enable interrupt */
+    rt_spin_unlock_irqrestore(&(serial->spinlock), level);
+
+    return RT_EOK;
+}
+
+static void _lower_work(struct rt_serial_device* serial)
+{
+    struct rt_list_node* node;
+    struct rt_serial_bypass_func* temp_curr = RT_NULL;
+    if (serial->bypass && serial->bypass->lower_h)
+    {
+        while (1)
+        {
+            char ch;
+            if (_bypass_getchar_form_serial_fifo(serial, &ch))
+                return;
+
+            node = serial->bypass->lower_h->head.next;
+
+            while (node != &serial->bypass->lower_h->head)
+            {
+                temp_curr = rt_container_of(node, struct rt_serial_bypass_func, node);
+
+                if (!temp_curr->bypass(serial, ch, temp_curr->data))
+                {
+                    break;
+                }
+
+                node = node->next;
+            }
+            if (node == &serial->bypass->lower_h->head)
+            {
+                rt_bypass_putchar(serial, ch);
+            }
+        }
+    }
+}
+
+
+static void rt_lower_work(struct rt_work* work, void* work_data)
+{
+    struct rt_serial_device* serial = (struct rt_serial_device*)work_data;
+
+    RT_ASSERT(serial != RT_NULL);
+
+    _lower_work(serial);
+}
+
+rt_err_t rt_bypass_lower_register(struct rt_serial_device* serial, const char* name, rt_uint8_t level, bypass_function_t func, void* data)
+{
+    if (!serial->bypass)
+        rt_serial_bypass_init(serial);
+
+    if (!serial->bypass->lower_h)
+    {
+        serial->bypass->lower_workq = rt_workqueue_create("serial bypass", RT_SYSTEM_WORKQUEUE_STACKSIZE,
+            RT_SYSTEM_WORKQUEUE_PRIORITY);
+        rt_work_init(&serial->bypass->work, rt_lower_work, (void*)serial);
+
+        serial->bypass->lower_h = rt_malloc(sizeof(struct rt_serial_bypass_head));
+        rt_spin_lock_init(&serial->bypass->lower_h->spinlock);
+        rt_list_init(&serial->bypass->lower_h->head);
+
+    }
+
+    return rt_bypass_register(serial->bypass->lower_h, name, level, func, data);
+}
+
+void rt_bypass_work_straight(struct rt_serial_device* serial)
+{
+    if (serial->bypass && serial->bypass->lower_h)
+    {
+        _lower_work(serial);
+        return;
+    }
+
+    while (1)
+    {
+        char ch;
+        if (_bypass_getchar_form_serial_fifo(serial, &ch))
+            return;
+
+        rt_bypass_putchar(serial, ch);
+    }
+
+}
+
+rt_err_t rt_bypass_unregister(struct rt_serial_bypass_head* bypass, rt_uint8_t level)
+{
+    struct rt_list_node* node;
+    struct rt_serial_bypass_func* temp_curr = RT_NULL;
+    int flags;
+
+    /*Can not unregister protect level in bypass it general be msh or tty*/
+    if (level > RT_BYPASS_PROTECT_LEVEL_1)
+        return -RT_ERROR;
+
+    if (!bypass)
+        return -RT_ERROR;
+
+    node = bypass->head.next;
+    flags = rt_spin_lock_irqsave(&(bypass->spinlock));
+
+    do {
+        temp_curr = rt_container_of(node, struct rt_serial_bypass_func, node);
+
+        if (level == temp_curr->level)
+        {
+            rt_list_remove(node);
+            rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
+            rt_free(temp_curr);
+            return RT_EOK;
+        }
+
+        node = node->next;
+    } while (node != &bypass->head);
+
+    LOG_E("Can't find bypass with level [%d]", level);
+    rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
+    return -RT_ERROR;
+}
+
+rt_err_t rt_bypass_upper_unregister(struct rt_serial_device* serial, rt_uint8_t level)
+{
+    if (!serial->bypass || !serial->bypass->upper_h)
+        return -RT_ERROR;
+    return rt_bypass_unregister(serial->bypass->upper_h, level);
+}
+
+rt_err_t rt_bypass_lower_unregister(struct rt_serial_device* serial, rt_uint8_t level)
+{
+    if (!serial->bypass || !serial->bypass->lower_h)
+        return -RT_ERROR;
+    return rt_bypass_unregister(serial->bypass->lower_h, level);
+}
+
+int serial_bypass_list(int argc, char** argv)
+{
+    struct rt_serial_device* serial = RT_NULL;
+    struct rt_serial_bypass_func* current;
+    struct rt_list_node* node;
+    int flags;
+
+    serial = (struct rt_serial_device*)rt_console_get_device();
+    if (!serial || !serial->bypass)
+    {
+        rt_kprintf("Serial bypass not initialized.\n");
+        return -1;
+    }
+
+    /* 遍历 Upper Bypass 链表 */
+    if (serial->bypass->upper_h)
+    {
+        rt_kprintf("Upper bypass chain:\n");
+        node = serial->bypass->upper_h->head.next;
+
+        flags = rt_spin_lock_irqsave(&(serial->bypass->upper_h->spinlock)); /* 加锁*/
+        while (node != &serial->bypass->upper_h->head)
+        {
+            current = rt_container_of(node, struct rt_serial_bypass_func, node);
+            rt_kprintf(" - Name: [%s], Level: [%d]\n", current->name, current->level);
+            node = node->next;
+        }
+        rt_spin_unlock_irqrestore(&(serial->bypass->upper_h->spinlock), flags); /* 解锁*/
+    }
+    else
+    {
+        rt_kprintf("Upper bypass chain is empty.\n");
+    }
+
+    /* 遍历 Lower Bypass 链表 */
+    if (serial->bypass->lower_h)
+    {
+        rt_kprintf("Lower bypass chain:\n");
+        node = serial->bypass->lower_h->head.next;
+
+        flags = rt_spin_lock_irqsave(&(serial->bypass->lower_h->spinlock)); /* 加锁*/
+        while (node != &serial->bypass->lower_h->head)
+        {
+            current = rt_container_of(node, struct rt_serial_bypass_func, node);
+            rt_kprintf(" - Name: [%s], Level: [%d]\n", current->name, current->level);
+            node = node->next;
+        }
+        rt_spin_unlock_irqrestore(&(serial->bypass->lower_h->spinlock), flags); /* 解锁*/
+    }
+    else
+    {
+        rt_kprintf("Lower bypass chain is empty.\n");
+    }
+
+    return 0;
+}
+
+
+MSH_CMD_EXPORT(serial_bypass_list, serial bypass list)

828ECO/rt-thread/components/drivers/serial/serial_dm.c

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2006-2022, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-11-16     GuEe-GUI     first version
+ */
+
+#include <rtatomic.h>
+#include <drivers/serial_dm.h>
+
+static int uid_min = -1;
+static volatile rt_atomic_t uid = 0;
+
+int serial_dev_set_name(struct rt_serial_device *sdev)
+{
+    int id = -1;
+
+    RT_ASSERT(sdev != RT_NULL);
+
+#ifdef RT_USING_OFW
+    if (sdev->parent.ofw_node)
+    {
+        id = rt_ofw_get_alias_id(sdev->parent.ofw_node, "serial");
+
+        if (id < 0)
+        {
+            id = rt_ofw_get_alias_id(sdev->parent.ofw_node, "uart");
+        }
+    }
+#endif
+
+    if (id < 0)
+    {
+        id = (int)rt_hw_atomic_add(&uid, 1);
+    }
+
+    return rt_dm_dev_set_name(&sdev->parent, "uart%u", id);
+}
+
+static int serial_dm_naming_framework_init(void)
+{
+#ifdef RT_USING_OFW
+    uid_min = rt_ofw_get_alias_last_id("serial");
+
+    if (uid_min < 0)
+    {
+        uid_min = rt_ofw_get_alias_last_id("uart");
+    }
+
+    uid_min = uid_min < 0 ? 0 : (uid_min + 1);
+
+    rt_hw_atomic_store(&uid, uid_min);
+#endif
+
+    return 0;
+}
+INIT_PLATFORM_EXPORT(serial_dm_naming_framework_init);
+
+void *serial_base_from_args(char *str)
+{
+    rt_ubase_t base = 0;
+
+    while (*str && !(*str == 'x' || *str == 'X'))
+    {
+        ++str;
+    }
+    ++str;
+
+    /* The str may get from bootargs that we need check it */
+    while (*str)
+    {
+        if ((*str >= 'a' && *str <= 'f') || (*str >= 'A' && *str <= 'F'))
+        {
+            base = (base << 4) | (((*str | ' ') - 'a') + 10);
+        }
+        else if (*str >= '0' && *str <= '9')
+        {
+            base = (base << 4) | (*str - '0');
+        }
+        else break;
+
+        ++str;
+    }
+
+    return (void *)base;
+}
+
+struct serial_configure serial_cfg_from_args(char *_str)
+{
+    char *str = _str;
+    struct serial_configure cfg = RT_SERIAL_CONFIG_DEFAULT;
+
+    /* Format baudrate/parity/bits/flow (BBBBPNF), Default is 115200n8 */
+    if (str && *str)
+    {
+        rt_uint32_t baudrate = 0;
+
+        /* BBBB is the speed */
+        while (*str && (*str >= '0' && *str <= '9'))
+        {
+            baudrate *= 10;
+            baudrate += *str - '0';
+            ++str;
+        }
+
+        if (baudrate)
+        {
+            cfg.baud_rate = baudrate;
+        }
+
+        /* P is parity (n/o/e) */
+        switch (*str)
+        {
+        case 'n':
+            cfg.parity = PARITY_NONE;
+            break;
+        case 'o':
+            cfg.parity = PARITY_ODD;
+            break;
+        case 'e':
+            cfg.parity = PARITY_EVEN;
+            break;
+        default:
+            --str;
+            break;
+        }
+        ++str;
+
+        /* N is number of bits */
+        if (*str && (*str >= '0' && *str <= '9'))
+        {
+            cfg.data_bits = *str - '0';
+            ++str;
+        }
+
+        /* F is flow ontrol ('r' for RTS) */
+        if (*str)
+        {
+            cfg.flowcontrol = (*str == 'r' ? RT_SERIAL_FLOWCONTROL_CTSRTS : RT_SERIAL_FLOWCONTROL_NONE);
+            ++str;
+        }
+
+    #ifdef RT_USING_OFW
+        if (*str == '\0')
+        {
+            const char earlycon_magic[] = { 'O', 'F', 'W', '\0' };
+
+            if (!rt_strcmp(++str, earlycon_magic))
+            {
+                /* Is OFW earlycon, we should ACK it */
+                rt_memset(str, 0, RT_ARRAY_SIZE(earlycon_magic));
+            }
+        }
+    #endif
+    }
+
+    return cfg;
+}

828ECO/rt-thread/components/drivers/serial/serial_tty.c

@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-11-21     Shell        init ver.
+ */
+
+#define DBG_TAG "drivers.serial"
+#define DBG_LVL DBG_INFO
+#include <rtdbg.h>
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <terminal/terminal.h>
+
+#define TTY_NAME_PREFIX "S" /* (S)erial */
+#define LWP_TTY_WORKQUEUE_PRIORITY 3
+
+struct serial_tty_context
+{
+    struct rt_serial_device *parent;
+    struct rt_device_notify backup_notify;
+    struct rt_work work;
+};
+
+static struct rt_workqueue *_ttyworkq; /* system work queue */
+
+#ifndef RT_USING_DM
+static rt_atomic_t _device_id_counter = 0;
+
+static long get_dec_digits(rt_ubase_t val)
+{
+    long result = 1;
+    while (1)
+    {
+        if (val < 10)
+            return result;
+        if (val < 100)
+            return result + 1;
+        if (val < 1000)
+            return result + 2;
+        if (val < 10000)
+            return result + 3;
+        val /= 10000U;
+        result += 4;
+    }
+    return result;
+}
+#endif
+
+static char *alloc_device_name(struct rt_serial_device *serial)
+{
+    char *tty_dev_name;
+#ifdef RT_USING_DM
+    char *serial_name = serial->parent.parent.name;
+    /*
+     * if RT_USING_DM is defined, the name of the serial device
+     * must be obtained using the serial_dev_set_name function,
+     * and it should begin with "uart".
+     */
+    RT_ASSERT((strlen(serial_name) > strlen("uart")) && (strncmp(serial_name, "uart", 4) == 0));
+    long digits_len = (sizeof(TTY_NAME_PREFIX) - 1) /* raw prefix */
+                      + strlen(serial_name + sizeof("uart") - 1) /* suffix of serial device name*/
+                      + 1;  /* tailing \0 */
+
+    tty_dev_name = rt_malloc(digits_len);
+    if (tty_dev_name)
+        rt_sprintf(tty_dev_name, "%s%s", TTY_NAME_PREFIX, serial_name + sizeof("uart") - 1);
+#else
+    RT_UNUSED(serial);
+    unsigned int devid = rt_atomic_add(&_device_id_counter, 1);
+    long digits_len = (sizeof(TTY_NAME_PREFIX) - 1) /* raw prefix */
+                      + get_dec_digits(devid) + 1;  /* tailing \0 */
+
+    tty_dev_name = rt_malloc(digits_len);
+    if (tty_dev_name)
+        rt_sprintf(tty_dev_name, "%s%u", TTY_NAME_PREFIX, devid);
+#endif
+    return tty_dev_name;
+}
+
+#ifdef LWP_DEBUG_INIT
+static volatile int _early_input = 0;
+
+static void _set_debug(rt_device_t dev, rt_size_t size);
+RT_OBJECT_HOOKLIST_DEFINE_NODE(rt_hw_serial_rxind, _set_debug_node, _set_debug);
+
+static void _set_debug(rt_device_t dev, rt_size_t size)
+{
+    rt_list_remove(&_set_debug_node.list_node);
+    _early_input = 1;
+}
+
+static void _setup_debug_rxind_hook(void)
+{
+    rt_hw_serial_rxind_sethook(&_set_debug_node);
+}
+
+int lwp_startup_debug_request(void)
+{
+    return _early_input;
+}
+
+#else /* !LWP_DEBUG_INIT */
+
+static void _setup_debug_rxind_hook(void)
+{
+    return ;
+}
+
+#endif /* LWP_DEBUG_INIT */
+
+static rt_err_t _serial_ty_bypass(struct rt_serial_device* serial, char ch,void *data)
+{
+    lwp_tty_t tp;
+    tp = (lwp_tty_t)data;
+
+    tty_lock(tp);
+    ttydisc_rint(tp, ch, 0);
+    ttydisc_rint_done(tp);
+    tty_unlock(tp);
+
+    return RT_EOK;
+
+}
+
+rt_inline void _setup_serial(struct rt_serial_device* serial, lwp_tty_t tp,
+                             struct serial_tty_context *softc)
+{
+    rt_bypass_lower_register(serial, "tty", RT_BYPASS_PROTECT_LEVEL_1, _serial_ty_bypass, (void *)tp);
+}
+
+rt_inline void _restore_serial(struct rt_serial_device *serial, lwp_tty_t tp,
+                               struct serial_tty_context *softc)
+{
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_NOTIFY_SET, &softc->backup_notify);
+}
+
+static void _serial_tty_set_speed(struct lwp_tty *tp)
+{
+    struct serial_tty_context *softc = (struct serial_tty_context *)(tp->t_devswsoftc);
+    struct rt_serial_device *serial;
+    struct termios serial_hw_config;
+
+    RT_ASSERT(softc);
+    serial = softc->parent;
+
+    rt_device_control(&(serial->parent), TCGETS, &serial_hw_config);
+    tp->t_termios_init_in.c_cflag |= serial_hw_config.c_cflag;
+
+    tp->t_termios_init_in.__c_ispeed = tp->t_termios_init_in.__c_ospeed = cfgetospeed(&tp->t_termios_init_in);
+}
+
+static int _serial_isbusy(struct rt_serial_device *serial)
+{
+    rt_thread_t user_thread = rt_console_current_user();
+    rt_thread_t self_thread = rt_thread_self();
+
+    return rt_console_get_device() == &serial->parent &&
+           (user_thread != RT_NULL && user_thread != self_thread);
+}
+
+static void serial_tty_outwakeup(struct lwp_tty *tp)
+{
+    char out_char;
+    int len;
+    struct serial_tty_context *context = tty_softc(tp);
+    struct rt_serial_device *device;
+
+    if (!context || !context->parent)
+    {
+        LOG_E("%s: Data corruption", __func__);
+        return;
+    }
+
+    device = context->parent;
+
+    if (_serial_isbusy(device))
+    {
+        return ;
+    }
+
+    while ((len = ttydisc_getc(tp, &out_char, sizeof(out_char))) != 0)
+    {
+        device->ops->putc(device, out_char);
+
+        /* discard remaining if emergency output is happened */
+        if (_serial_isbusy(device))
+        {
+            break;
+        }
+    }
+}
+
+static int serial_tty_open(struct lwp_tty *tp)
+{
+    struct serial_tty_context *softc;
+    struct rt_serial_device *serial;
+    rt_err_t error;
+    int oflags;
+
+    softc = tty_softc(tp);
+    serial = softc->parent;
+
+    LOG_D("%s", __func__);
+
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONSOLE_OFLAG, &oflags);
+
+    error = rt_device_open(&serial->parent, oflags);
+
+    if (!error)
+    {
+        /**
+         * to avoid driver accesssing null data,
+         * these are setup only after tty is registered
+         */
+        _setup_serial(serial, tp, softc);
+    }
+    return error;
+}
+
+static void serial_tty_close(struct lwp_tty *tp)
+{
+    struct serial_tty_context *softc;
+    struct rt_serial_device *serial;
+    softc = tty_softc(tp);
+    serial = softc->parent;
+
+    LOG_D("%s", __func__);
+
+    rt_bypass_lower_unregister(serial, RT_BYPASS_PROTECT_LEVEL_1);
+    rt_device_close(&serial->parent);
+}
+
+static int serial_tty_ioctl(struct lwp_tty *tp, rt_ubase_t cmd, rt_caddr_t data,
+                            struct rt_thread *td)
+{
+    int error;
+    switch (cmd)
+    {
+        default:
+            /**
+             * Note: for the most case, we don't let serial layer handle ioctl,
+             * for that they can't act properly regarding to the process
+             * management system, since it is unawared of that. So a ENOSYS is
+             * returned and caused the TTY layer to handle ioctl itself.
+             */
+            error = -ENOSYS;
+            break;
+    }
+    return error;
+}
+
+static int serial_tty_param(struct lwp_tty *tp, struct termios *t)
+{
+    struct serial_tty_context *softc = (struct serial_tty_context *)(tp->t_devswsoftc);
+    struct rt_serial_device *serial;
+
+    RT_ASSERT(softc);
+    serial = softc->parent;
+
+    if (!tty_opened(tp))
+    {
+        /**
+         * skip configure on open since all configs are copied from the current
+         * configuration on device. So we don't bother to set it back to device
+         * again.
+         */
+        return RT_EOK;
+    }
+
+    cfsetispeed(t, t->__c_ispeed);
+    return rt_device_control(&(serial->parent), TCSETS, t);
+}
+
+static struct lwp_ttydevsw serial_ttydevsw = {
+    .tsw_open = serial_tty_open,
+    .tsw_close = serial_tty_close,
+    .tsw_ioctl = serial_tty_ioctl,
+    .tsw_param = serial_tty_param,
+    .tsw_outwakeup = serial_tty_outwakeup,
+};
+
+rt_err_t rt_hw_serial_register_tty(struct rt_serial_device *serial)
+{
+    rt_err_t rc;
+    lwp_tty_t tty;
+    char *dev_name;
+    struct serial_tty_context *softc;
+
+    if (serial->rx_notify.dev)
+    {
+        return -RT_EBUSY;
+    }
+
+    softc = rt_malloc(sizeof(struct serial_tty_context));
+    if (softc)
+    {
+        dev_name = alloc_device_name(serial);
+
+        if (dev_name)
+        {
+            softc->parent = serial;
+            tty = lwp_tty_create(&serial_ttydevsw, softc);
+            if (tty)
+            {
+                _serial_tty_set_speed(tty);
+                rc = lwp_tty_register(tty, dev_name);
+
+                if (rc != RT_EOK)
+                {
+                    rt_free(tty);
+                    rt_free(softc);
+                }
+            }
+            else
+            {
+                rt_free(softc);
+                rc = -RT_ENOMEM;
+            }
+
+            rt_free(dev_name);
+        }
+        else
+        {
+            rt_free(softc);
+            rc = -RT_ENOMEM;
+        }
+    }
+    else
+    {
+        rc = -RT_ENOMEM;
+    }
+
+    return rc;
+}
+
+rt_err_t rt_hw_serial_unregister_tty(struct rt_serial_device *serial)
+{
+    rt_device_t tty_dev;
+    lwp_tty_t tp;
+    struct serial_tty_context *softc;
+
+    tty_dev = serial->rx_notify.dev;
+    tp = rt_container_of(tty_dev, struct lwp_tty, parent);
+
+    /* restore serial setting */
+    softc = tty_softc(tp);
+    serial->rx_notify = softc->backup_notify;
+
+    tty_lock(tp);
+
+    tty_rel_gone(tp);
+
+    /* device unregister? */
+    rt_device_destroy(&tp->parent);
+    /* resource free? */
+    lwp_tty_delete(tp);
+
+    return RT_EOK;
+}
+
+static int _tty_workqueue_init(void)
+{
+    if (_ttyworkq != RT_NULL)
+        return RT_EOK;
+
+    _ttyworkq = rt_workqueue_create("ttyworkq", RT_SYSTEM_WORKQUEUE_STACKSIZE,
+                                    LWP_TTY_WORKQUEUE_PRIORITY);
+    RT_ASSERT(_ttyworkq != RT_NULL);
+
+    _setup_debug_rxind_hook();
+
+    return RT_EOK;
+}
+INIT_PREV_EXPORT(_tty_workqueue_init);
+
+static rt_err_t _match_tty_iter(struct rt_object *obj, void *data)
+{
+    rt_device_t target = *(rt_device_t *)data;
+    rt_device_t device = rt_container_of(obj, struct rt_device, parent);
+    if (device->type == RT_Device_Class_Char)
+    {
+        lwp_tty_t tp;
+        if (rt_strncmp(obj->name, "tty"TTY_NAME_PREFIX,
+            sizeof("tty"TTY_NAME_PREFIX) - 1) == 0)
+        {
+            struct serial_tty_context *softc;
+
+            tp = rt_container_of(device, struct lwp_tty, parent);
+            softc = tty_softc(tp);
+
+            if (&softc->parent->parent == target)
+            {
+                /* matched, early return */
+                *(rt_device_t *)data = device;
+                return 1;
+            }
+        }
+    }
+
+    return RT_EOK;
+}
+
+/**
+ * @brief The default console is only a backup device with lowest priority.
+ *        It's always recommended to scratch the console from the boot arguments.
+ *        And dont forget to register the device with a higher priority.
+ */
+static int _default_console_setup(void)
+{
+    rt_err_t rc;
+    rt_device_t bakdev;
+    rt_device_t ttydev;
+
+    bakdev = rt_console_get_device();
+    if (!bakdev)
+    {
+        return -RT_ENOENT;
+    }
+
+    ttydev = bakdev;
+    rt_object_for_each(RT_Object_Class_Device, _match_tty_iter, &ttydev);
+
+    if (ttydev != bakdev)
+    {
+        LOG_I("Using /dev/%.*s as default console", RT_NAME_MAX, ttydev->parent.name);
+        lwp_console_register_backend(ttydev, LWP_CONSOLE_LOWEST_PRIOR);
+        rc = RT_EOK;
+    }
+    else
+    {
+        rc = -RT_EINVAL;
+    }
+
+    return rc;
+}
+
+INIT_COMPONENT_EXPORT(_default_console_setup);

828ECO/rt-thread/components/drivers/serial/utest/Kconfig

@@ -0,0 +1,56 @@
+menu "Serial Test"
+
+    config RT_UTEST_SERIAL_BYPASS
+        bool "Serial Bypass Test"
+        default n
+        depends on RT_USING_SERIAL_BYPASS
+
+    config RT_UTEST_SERIAL_V2
+        bool "Serial V2 Test"
+        default n
+        depends on RT_USING_SERIAL_V2
+
+    if RT_UTEST_SERIAL_V2
+
+        config RT_SERIAL_TC_DEVICE_NAME
+            string "Device Name for Serial Test"
+            default "uart2"
+
+        config RT_SERIAL_TC_RXBUF_SIZE
+            int "RX Buffer Size for Serial Test"
+            default 128
+
+        config RT_SERIAL_TC_TXBUF_SIZE
+            int "TX Buffer Size for Serial Test"
+            default 128
+
+        config RT_SERIAL_TC_SEND_ITERATIONS
+            int "Number of Iterations for Test Routines"
+            default 100
+
+        config RT_UTEST_SERIAL_QEMU
+            bool "QEMU Dedicated Test"
+            default n
+
+        config RT_UTEST_SERIAL_POSIX
+            bool "Serial POSIX Test"
+            default n
+            select RT_USING_DFS
+            select RT_USING_POSIX_FS
+            select RT_USING_POSIX_TERMIOS
+
+        if RT_UTEST_SERIAL_POSIX
+
+            config RT_SERIAL_POSIX_TC_DEVICE_NAME
+                string "Device Name for Serial POSIX Test"
+                default "dev/uart2"
+
+            config RT_SERIAL_POSIX_TC_SEND_ITERATIONS
+                int "Number of Iterations for POSIX Test Routines"
+                default 100
+
+        endif
+
+    endif
+
+endmenu

828ECO/rt-thread/components/drivers/serial/utest/SConscript

@@ -0,0 +1,15 @@
+Import('rtconfig')
+from building import *
+
+cwd     = GetCurrentDir()
+src     = []
+CPPPATH = [cwd]
+
+group = DefineGroup('utestcases', src, depend = ['RT_USING_UTESTCASES', 'RT_USING_SERIAL'], CPPPATH = CPPPATH)
+
+list = os.listdir(cwd)
+for item in list:
+    if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
+        group = group + SConscript(os.path.join(item, 'SConscript'))
+
+Return('group')

828ECO/rt-thread/components/drivers/serial/utest/bypass/SConscript

@@ -0,0 +1,11 @@
+Import('rtconfig')
+from building import *
+
+cwd     = GetCurrentDir()
+src     = Glob('bypass*.c')
+
+CPPPATH = [cwd]
+
+group = DefineGroup('utestcases', src, depend = ['RT_UTEST_SERIAL_BYPASS'], CPPPATH = CPPPATH)
+
+Return('group')

828ECO/rt-thread/components/drivers/serial/utest/bypass/bypass_conflict.c

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2024-11-20     zhujiale     the first version
+ */
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+static struct rt_serial_device* _serial0;
+static struct rt_spinlock lock;
+static int cnt = 0;
+
+#define __REG32(x) (*((volatile unsigned int*)((rt_ubase_t)x)))
+#define UART_FR(base)   __REG32(base + 0x18)
+#define UART_DR(base)   __REG32(base + 0x00)
+#define UARTFR_TXFF     0x20
+
+static rt_err_t utest_get_c(struct rt_serial_device* serial, char ch, void* data)
+{
+    rt_atomic_add(&cnt, 1);
+    return RT_EOK;
+}
+
+static int utest_getc(struct rt_serial_device* serial)
+{
+    static int num = 0;
+
+    rt_spin_lock(&lock);
+    if (rt_atomic_load(&num) == 10)
+    {
+        rt_atomic_flag_clear(&num);
+        rt_spin_unlock(&lock);
+        return -1;
+    }
+    rt_atomic_add(&num, 1);
+    rt_spin_unlock(&lock);
+    return 'a';
+}
+
+struct hw_uart_device
+{
+    rt_size_t hw_base;
+    rt_size_t irqno;
+};
+
+static int uart_putc(struct rt_serial_device* serial, char c)
+{
+    struct hw_uart_device* uart;
+
+    RT_ASSERT(serial != RT_NULL);
+    uart = (struct hw_uart_device*)serial->parent.user_data;
+
+    while (UART_FR(uart->hw_base) & UARTFR_TXFF);
+    UART_DR(uart->hw_base) = c;
+
+    return 1;
+}
+
+static const struct rt_uart_ops _utest_ops =
+{
+    RT_NULL,
+    RT_NULL,
+    uart_putc,
+    utest_getc,
+};
+
+
+static void thread_rx1(void* parameter)
+{
+    for (int i = 0; i < 10; i++)
+    {
+        rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND);
+    }
+}
+
+static void thread_rx2(void* parameter)
+{
+    for (int i = 0; i < 10; i++)
+    {
+        rt_workqueue_dowork(_serial0->bypass->lower_workq, &_serial0->bypass->work);
+    }
+}
+
+static void thread_high_priority(void* parameter)
+{
+    for (int i = 1; i < 10; i++)
+    {
+        rt_bypass_upper_register(_serial0, "test", i, utest_get_c, RT_NULL);
+        rt_bypass_upper_unregister(_serial0, i);
+    }
+}
+
+static void thread_low_priority(void* parameter)
+{
+    for (int i = 0; i < 20; i++)
+    {
+        rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND);
+    }
+}
+
+static void bypass_rx_stress_003(void)
+{
+    const struct rt_uart_ops* tmp = _serial0->ops;
+
+    rt_thread_t high = rt_thread_create("high_prio", thread_high_priority, RT_NULL, 2048, 15, 10);
+    rt_thread_t low = rt_thread_create("low_prio", thread_low_priority, RT_NULL, 2048, 20, 10);
+
+    rt_atomic_flag_clear(&cnt);
+    _serial0->ops = &_utest_ops;
+    rt_bypass_upper_register(_serial0, "test", 0, utest_get_c, RT_NULL);
+
+    rt_thread_startup(high);
+    rt_thread_startup(low);
+
+    rt_thread_mdelay(1000);
+    _serial0->ops = tmp;
+    rt_bypass_upper_unregister(_serial0, 0);
+    uassert_true(rt_atomic_load(&cnt) == 200);
+}
+
+static void bypass_rx_stress_002(void)
+{
+    const struct rt_uart_ops* tmp = _serial0->ops;
+    rt_thread_t rx2 = rt_thread_create("rx2", thread_rx1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+    rt_thread_t rx3 = rt_thread_create("rx3", thread_rx2, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+
+    rt_atomic_flag_clear(&cnt);
+    _serial0->ops = &_utest_ops;
+    rt_bypass_lower_register(_serial0, "utest", 0, utest_get_c, RT_NULL);
+
+    rt_thread_startup(rx2);
+    rt_thread_startup(rx3);
+
+    rt_thread_mdelay(1000);
+
+    uassert_true(rt_atomic_load(&cnt) == 100);
+    _serial0->ops = tmp;
+    rt_bypass_lower_unregister(_serial0, 0);
+}
+
+static void bypass_rx_stress_001(void)
+{
+    const struct rt_uart_ops* tmp = _serial0->ops;
+    rt_thread_t rx1 = rt_thread_create("rx1", thread_rx1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+    rt_thread_t rx2 = rt_thread_create("rx1", thread_rx1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+
+    cnt = 0;
+    _serial0->ops = &_utest_ops;
+    rt_bypass_upper_register(_serial0, "utest", 0, utest_get_c, RT_NULL);
+
+    rt_thread_startup(rx1);
+    rt_thread_startup(rx2);
+
+    rt_thread_mdelay(1000);
+
+    uassert_true(rt_atomic_load(&cnt) == 200);
+    _serial0->ops = tmp;
+    rt_bypass_upper_unregister(_serial0, 0);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    _serial0 = (struct rt_serial_device*)rt_console_get_device();
+    rt_spin_lock_init(&lock);
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    return RT_EOK;
+}
+
+static void _testcase(void)
+{
+    UTEST_UNIT_RUN(bypass_rx_stress_001);
+    UTEST_UNIT_RUN(bypass_rx_stress_002);
+    UTEST_UNIT_RUN(bypass_rx_stress_003);
+}
+
+UTEST_TC_EXPORT(_testcase, "components.drivers.serial.bypass_rx_stress", utest_tc_init, utest_tc_cleanup, 10);

828ECO/rt-thread/components/drivers/serial/utest/bypass/bypass_lower_run.c

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2024-11-20     zhujiale     the first version
+ */
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+static struct rt_serial_device* _serial0;
+static int cnt = 0;
+
+#define __REG32(x) (*((volatile unsigned int*)((rt_ubase_t)x)))
+#define UART_FR(base)   __REG32(base + 0x18)
+#define UART_DR(base)   __REG32(base + 0x00)
+#define UARTFR_TXFF     0x20
+
+struct hw_uart_device
+{
+    rt_size_t hw_base;
+    rt_size_t irqno;
+};
+
+static int uart_putc(struct rt_serial_device* serial, char c)
+{
+    struct hw_uart_device* uart;
+
+    RT_ASSERT(serial != RT_NULL);
+    uart = (struct hw_uart_device*)serial->parent.user_data;
+
+    while (UART_FR(uart->hw_base) & UARTFR_TXFF);
+    UART_DR(uart->hw_base) = c;
+
+    return 1;
+}
+
+static rt_err_t utest_lower_run_test2(struct rt_serial_device* serial, char ch, void* data)
+{
+    static rt_uint8_t num = 0;
+    num++;
+    uassert_true(ch == ('a' + num));
+    return RT_EOK;
+}
+
+static int utest_getc_2(struct rt_serial_device* serial)
+{
+    static rt_uint8_t num = 0;
+    if (num == 20)
+        return -1;
+    num++;
+    return 'a' + num;
+}
+
+static const struct rt_uart_ops _utest_ops2 =
+{
+    RT_NULL,
+    RT_NULL,
+    uart_putc,
+    utest_getc_2,
+};
+
+static rt_err_t utest_lower_run(struct rt_serial_device* serial, char ch, void* data)
+{
+    uassert_true(ch == 'a');
+    cnt++;
+    return RT_EOK;
+}
+
+
+static int utest_getc(struct rt_serial_device* serial)
+{
+    static rt_uint8_t num = 0;
+    if (num == 10)
+        return -1;
+    num++;
+    return 'a';
+}
+
+static const struct rt_uart_ops _utest_ops =
+{
+    RT_NULL,
+    RT_NULL,
+    uart_putc,
+    utest_getc,
+};
+static void bypass_lower_001(void)
+{
+    const struct rt_uart_ops* tmp = _serial0->ops;
+    _serial0->ops = &_utest_ops;
+    rt_bypass_lower_register(_serial0, "utest", RT_BYPASS_MAX_LEVEL, utest_lower_run, RT_NULL);
+
+    rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND);
+    rt_thread_mdelay(100);
+    uassert_true(cnt == 10);
+    _serial0->ops = tmp;
+    rt_bypass_lower_unregister(_serial0, RT_BYPASS_MAX_LEVEL);
+}
+
+static void bypass_lower_002(void)
+{
+    const struct rt_uart_ops* tmp = _serial0->ops;
+    _serial0->ops = &_utest_ops2;
+    rt_bypass_lower_register(_serial0, "utest", RT_BYPASS_MAX_LEVEL, utest_lower_run_test2, RT_NULL);
+
+    rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND);
+    rt_thread_mdelay(100);
+    uassert_true(cnt == 10);
+    _serial0->ops = tmp;
+    rt_bypass_lower_unregister(_serial0, RT_BYPASS_MAX_LEVEL);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    _serial0 = (struct rt_serial_device*)rt_console_get_device();
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    return RT_EOK;
+}
+
+static void _testcase(void)
+{
+    UTEST_UNIT_RUN(bypass_lower_001);
+    UTEST_UNIT_RUN(bypass_lower_002);
+}
+
+UTEST_TC_EXPORT(_testcase, "components.drivers.serial.bypass_lower", utest_tc_init, utest_tc_cleanup, 10);

828ECO/rt-thread/components/drivers/serial/utest/bypass/bypass_register.c

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2024-11-20     zhujiale     the first version
+ */
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+static struct rt_serial_device* _serial0;
+static struct rt_spinlock lock;
+
+static rt_err_t utest_001_run(struct rt_serial_device* serial, char ch, void* data)
+{
+    return 0;
+}
+
+static void thread_serial_register1(void* parameter)
+{
+    for (int i = 2; i < 10; i += 2)
+    {
+        rt_bypass_upper_register(_serial0, "test", i, utest_001_run, RT_NULL);
+    }
+}
+
+static void thread_serial_register_upper(void* parameter)
+{
+    for (int i = 1; i < 10; i++)
+    {
+        rt_bypass_upper_register(_serial0, "test", i, utest_001_run, RT_NULL);
+    }
+}
+
+static void thread_serial_register_lower(void* parameter)
+{
+    for (int i = 1; i < 10; i++)
+    {
+        rt_bypass_lower_register(_serial0, "test", i, utest_001_run, RT_NULL);
+    }
+}
+
+static void bypass_register_001(void)
+{
+    rt_thread_t t1 = rt_thread_create("serial_register", thread_serial_register1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+    rt_bypass_upper_register(_serial0, "test", 0, utest_001_run, RT_NULL);
+    rt_thread_startup(t1);
+    for (int i = 1; i < 10; i += 2)
+    {
+        rt_bypass_upper_register(_serial0, "test", i, utest_001_run, RT_NULL);
+    }
+    rt_thread_mdelay(1000);
+    rt_list_t* node = _serial0->bypass->upper_h->head.next;
+    for (int i = 0; i < 10;i++)
+    {
+        rt_list_t* next = node->next;
+        struct rt_serial_bypass_func* temp = rt_container_of(node, struct rt_serial_bypass_func, node);
+        uassert_true(temp->level == i);
+        rt_bypass_upper_unregister(_serial0, temp->level);
+        node = next;
+    }
+
+}
+
+static void bypass_register_002(void)
+{
+    rt_thread_t t1 = rt_thread_create("serial_register", thread_serial_register_upper, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+    rt_thread_t t2 = rt_thread_create("serial_register", thread_serial_register_lower, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+    rt_bypass_upper_register(_serial0, "test", 0, utest_001_run, RT_NULL);
+
+    rt_thread_startup(t1);
+    rt_thread_startup(t2);
+
+    rt_thread_mdelay(1000);
+    rt_list_t* node = _serial0->bypass->upper_h->head.next;
+    for (int i = 0; i < 10;i++)
+    {
+        rt_list_t* next = node->next;
+        struct rt_serial_bypass_func* temp = rt_container_of(node, struct rt_serial_bypass_func, node);
+        uassert_true(temp->level == i);
+        rt_bypass_upper_unregister(_serial0, temp->level);
+        node = next;
+    }
+    node = _serial0->bypass->lower_h->head.next;
+    for (int i = 1; i < 10;i++)
+    {
+        rt_list_t* next = node->next;
+        struct rt_serial_bypass_func* temp = rt_container_of(node, struct rt_serial_bypass_func, node);
+        uassert_true(temp->level == i);
+        rt_bypass_lower_unregister(_serial0, temp->level);
+        node = next;
+    }
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    _serial0 = (struct rt_serial_device*)rt_console_get_device();
+    rt_spin_lock_init(&lock);
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    return RT_EOK;
+}
+
+static void _testcase(void)
+{
+    UTEST_UNIT_RUN(bypass_register_001);
+    UTEST_UNIT_RUN(bypass_register_002);
+}
+
+UTEST_TC_EXPORT(_testcase, "components.drivers.serial.bypass_register", utest_tc_init, utest_tc_cleanup, 10);

828ECO/rt-thread/components/drivers/serial/utest/bypass/bypass_upper_run.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2024-11-20     zhujiale     the first version
+ */
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+static struct rt_serial_device* _serial0;
+static int cnt;
+
+#define __REG32(x) (*((volatile unsigned int*)((rt_ubase_t)x)))
+#define UART_FR(base)   __REG32(base + 0x18)
+#define UART_DR(base)   __REG32(base + 0x00)
+#define UARTFR_TXFF     0x20
+static rt_err_t utest_upper_run(struct rt_serial_device* serial, char ch, void* data)
+{
+    uassert_true(ch == 'a');
+    cnt++;
+    return RT_EOK;
+}
+
+static int utest_getc(struct rt_serial_device* serial)
+{
+    static rt_uint8_t num = 0;
+    if (num == 10)
+        return -1;
+    num++;
+    return 'a';
+}
+
+struct hw_uart_device
+{
+    rt_size_t hw_base;
+    rt_size_t irqno;
+};
+
+static int uart_putc(struct rt_serial_device* serial, char c)
+{
+    struct hw_uart_device* uart;
+
+    RT_ASSERT(serial != RT_NULL);
+    uart = (struct hw_uart_device*)serial->parent.user_data;
+
+    while (UART_FR(uart->hw_base) & UARTFR_TXFF);
+    UART_DR(uart->hw_base) = c;
+
+    return 1;
+}
+
+static const struct rt_uart_ops _utest_ops =
+{
+    RT_NULL,
+    RT_NULL,
+    uart_putc,
+    utest_getc,
+};
+
+static rt_err_t utest_lower_run_test2(struct rt_serial_device* serial, char ch, void* data)
+{
+    static rt_uint8_t num = 0;
+    num++;
+    uassert_true(ch == ('a' + num));
+    return RT_EOK;
+}
+
+static int utest_getc_2(struct rt_serial_device* serial)
+{
+    static rt_uint8_t num = 0;
+    if (num == 20)
+        return -1;
+    num++;
+    return 'a' + num;
+}
+
+static const struct rt_uart_ops _utest_ops2 =
+{
+    RT_NULL,
+    RT_NULL,
+    uart_putc,
+    utest_getc_2,
+};
+static void bypass_upper_001(void)
+{
+    const struct rt_uart_ops* tmp = _serial0->ops;
+    _serial0->ops = &_utest_ops;
+    rt_bypass_upper_register(_serial0, "utest", RT_BYPASS_LEVEL_1, utest_upper_run, RT_NULL);
+    rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND);
+    uassert_true(cnt == 10);
+    _serial0->ops = tmp;
+    rt_bypass_upper_unregister(_serial0, RT_BYPASS_LEVEL_1);
+}
+
+static void bypass_upper_002(void)
+{
+    const struct rt_uart_ops* tmp = _serial0->ops;
+    _serial0->ops = &_utest_ops2;
+    rt_bypass_upper_register(_serial0, "utest", RT_BYPASS_MAX_LEVEL, utest_lower_run_test2, RT_NULL);
+
+    rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND);
+    rt_thread_mdelay(100);
+    uassert_true(cnt == 10);
+    _serial0->ops = tmp;
+    rt_bypass_upper_unregister(_serial0, RT_BYPASS_MAX_LEVEL);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    _serial0 = (struct rt_serial_device*)rt_console_get_device();
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    return RT_EOK;
+}
+
+static void _testcase(void)
+{
+    UTEST_UNIT_RUN(bypass_upper_001);
+    UTEST_UNIT_RUN(bypass_upper_002);
+}
+
+UTEST_TC_EXPORT(_testcase, "components.drivers.serial.bypass_upper", utest_tc_init, utest_tc_cleanup, 10);

828ECO/rt-thread/components/drivers/serial/utest/v2/README.md

@@ -0,0 +1,154 @@
+## 1、介绍
+
+该目录下 c 文件是新版本串口的测试用例，在 `examples/utest/testcases/drivers/serial_v2` 目录结构里，该测试用例用来测试串口的各个操作模式是否正常工作。
+
+## 2、 文件说明
+
+| 文件             | 描述                                      |
+| ---------------- | ----------------------------------------- |
+| uart_rxb_txb.c   | 串口接收阻塞和发送阻塞模式 的测试用例     |
+| uart_rxb_txnb.c  | 串口接收阻塞和发送非阻塞模式 的测试用例   |
+| uart_rxnb_txb.c  | 串口接收非阻塞和发送阻塞模式 的测试用例   |
+| uart_rxnb_txnb.c | 串口接收非阻塞和发送非阻塞模式 的测试用例 |
+| uart_blocking_tx.c| 串口阻塞发送模式 的测试                       |
+| uart_blocking_rx.c| 串口阻塞接收模式 的测试                       |
+| uart_nonblocking_tx.c| 串口非阻塞发送模式 的测试                   |
+| uart_nonblocking_rx.c  | 串口非阻塞接收模式 的测试                   |
+| uart_flush_rx | 刷新接收缓冲区的测试 |
+| uart_flush_txb | 阻塞模式下刷新发送缓冲区的测试 |
+| uart_flush_txnb | 非阻塞模式下刷新发送缓冲区的测试 |
+| uart_timeout_rxb_txb | 串口 发送 / 接收 超时的测试 |
+| uart_overflow_rxb_txb | 串口溢出处理的测试 |
+| uart_get_unread_bytes_count | 获取串口接收缓冲区中的数据长度的测试 |
+| uart_posix_nonblock | posix非阻塞测试 |
+| uart_posix_echo_block | posix阻塞echo测试 |
+
+## 3、软硬件环境
+
+硬件上需要支持 RT-Thread 的完整版操作系统，版本为4.0.4及以上，且硬件有串口硬件外设，软件上需要支持 内核接口、IPC 、Device 框架。
+
+## 4、测试项
+
+### 4.1 测试说明
+
+上文所提及的模式是指串口使用时的操作模式，不涉及硬件的工作模式的配置情况（硬件工作模式一般有轮询POLL、中断INT、DMA），因此使用时需要结合具体的硬件工作模式去配置使用。例如 发送阻塞和接收非阻塞模式 ，这个测试有很多种硬件配置，配置情况例如：DMA发送阻塞和DMA接收非阻塞，INT发送阻塞和DMA接收非阻塞，POLL发送阻塞和DMA接收非阻塞等等。因此通过排列组合后的测试场景有4*9=36种，有意义的组合方式为20种。如下表：
+
+
+| 接收非阻塞 | 发送阻塞 | 组合              | 有意义的组合方式 |
+| ---------- | -------- | ----------------- | ---------------- |
+| POLL       | POLL     | RX_POLL + TX_POLL |                  |
+|            | INT      | RX_POLL + TX_INT  |                  |
+|            | DMA      | RX_POLL + TX_DMA  |                  |
+| INT        | POLL     | RX_INT + TX_POLL  | ✔                |
+|            | INT      | RX_INT + TX_INT   | ✔                |
+|            | DMA      | RX_INT + TX_DMA   | ✔                |
+| DMA        | POLL     | RX_DMA + TX_POLL  | ✔                |
+|            | INT      | RX_DMA + TX_INT   | ✔                |
+|            | DMA      | RX_DMA + TX_DMA   | ✔                |
+
+| 接收非阻塞 | 发送非阻塞 | 组合              | 有意义的组合方式 |
+| ---------- | ---------- | ----------------- | ---------------- |
+| POLL       | POLL       | RX_POLL + TX_POLL |                  |
+|            | INT        | RX_POLL + TX_INT  |                  |
+|            | DMA        | RX_POLL + TX_DMA  |                  |
+| INT        | POLL       | RX_INT + TX_POLL  |                  |
+|            | INT        | RX_INT + TX_INT   | ✔                |
+|            | DMA        | RX_INT + TX_DMA   | ✔                |
+| DMA        | POLL       | RX_DMA + TX_POLL  |                  |
+|            | INT        | RX_DMA + TX_INT   | ✔                |
+|            | DMA        | RX_DMA + TX_DMA   | ✔                |
+
+| 接收阻塞 | 发送阻塞 | 组合              | 有意义的组合方式 |
+| -------- | -------- | ----------------- | ---------------- |
+| POLL     | POLL     | RX_POLL + TX_POLL |                  |
+|          | INT      | RX_POLL + TX_INT  |                  |
+|          | DMA      | RX_POLL + TX_DMA  |                  |
+| INT      | POLL     | RX_INT + TX_POLL  | ✔                |
+|          | INT      | RX_INT + TX_INT   | ✔                |
+|          | DMA      | RX_INT + TX_DMA   | ✔                |
+| DMA      | POLL     | RX_DMA + TX_POLL  | ✔                |
+|          | INT      | RX_DMA + TX_INT   | ✔                |
+|          | DMA      | RX_DMA + TX_DMA   | ✔                |
+
+| 接收阻塞 | 发送非阻塞 | 组合              | 有意义的组合方式 |
+| -------- | ---------- | ----------------- | ---------------- |
+| POLL     | POLL       | RX_POLL + TX_POLL |                  |
+|          | INT        | RX_POLL + TX_INT  |                  |
+|          | DMA        | RX_POLL + TX_DMA  |                  |
+| INT      | POLL       | RX_INT + TX_POLL  |                  |
+|          | INT        | RX_INT + TX_INT   | ✔                |
+|          | DMA        | RX_INT + TX_DMA   | ✔                |
+| DMA      | POLL       | RX_DMA + TX_POLL  |                  |
+|          | INT        | RX_DMA + TX_INT   | ✔                |
+|          | DMA        | RX_DMA + TX_DMA   | ✔                |
+
+需要解释的是，为什么会存在无意义的组合模式，举个例子，非阻塞模式下，肯定是不会出现POLL（轮询）方式的，因为POLL方式已经表明是阻塞方式了。
+该测试用例在测试多种组合时，需要通过更改`rtconfig.h`文件对硬件模式进行静态配置。
+
+### 4.2 测试条件
+
+**短接串口的发送TX引脚和接收RX引脚，完成自发自收的回路**。
+
+大致的测试思路:
+
+>发送测试流程 :
+>>1. 先关闭串口,再以需要测试的模式打开.
+>>2. 然后依次发送 UART_SEND_TIMES * （1000以内的随机数）个数据.
+>>3. 打印记录的数据,通过LOG日志的时钟周期来反应发送效率, 通过成功发送的数据量来反应是否产生丢包问题.
+>
+>接收测试流程 : 
+>>1. 先关闭串口,再以需要测试的模式打开.
+>>2. 然后以此接收 同发送测试流程一致的 UART_SEND_TIMES *（1000以内随机数）个数据
+>>3. 接收的同时记录成功接收的数据数量
+>>4. 打印记录的数据, 通过现实成功接收的数据量与串口发送的数据量做对比,来验证是否出现丢包问题
+
+## 5、配置
+
+使用该测试用例需要在 `env` 工具的 `menuconfig` 中做相关配置，配置如下所示（使用 RT-Thread-Studio 的配置路径一致 ）：
+
+```
+RT-Thread Utestcases  --->
+    [*] RT-Thread Utestcases  --->
+           Utest Serial Testcase --->
+                [*] Serial testcase --->
+                	the device name for serial test: uart2	(选择测试的串口)
+                	(128)the rx buffer size for serial test	(测试串口rx缓冲区大小)
+                	(128)the tx buffer size for serial test	(测试串口tx缓冲区大小)
+                	(100)the number of iterations for the test routine.	(测试例程的迭代次数)
+                [*] Serial posix testcase --->
+                	the device name for serial posix test: dev/uart2	(posix测试的串口)
+                	(100)the number of iterations for the posix test routine.	(posix测试例程的迭代次数)
+```
+
+## 6、使用
+
+\- 编译下载。
+
+\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。
+
+\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。
+
+\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。
+
+\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。
+
+\- 在 MSH 中输入 `utest_run testcases.drivers.uart_blocking_tx` 运行串口阻塞发送测试
+
+\- 在 MSH 中输入 `utest_run testcases.drivers.uart_blocking_rx` 运行串口阻塞接收测试
+
+\- 在 MSH 中输入 `utest_run testcases.drivers.uart_nonblocking_tx` 运行串口非阻塞发送测试
+
+其余同理，可在函数内部查看命令。
+
+如果仅仅配置了 `Serial testcase` 相关的测试用例，则直接输入 `utest_run *` 运行即可将上述测试用例按序测试。
+
+## 7、注意事项
+
+\- 需配置正确的测试用例。
+
+\- 如有需要，可开启 ULOG 查看测试用例日志信息。
+
+\- 需在 MSH 中输入正确的命令行。
+
+\- 该测试用例需要结合硬件具体的工作模式（POLL 、INT、DMA）进行测试，而硬件工作模式只能选择一种，因此需要在 `rtconfig.h` 中对串口相应的宏进行配置，来选择不同的工作模式去进行测试。
+

828ECO/rt-thread/components/drivers/serial/utest/v2/SConscript

@@ -0,0 +1,18 @@
+Import('rtconfig')
+from building import *
+
+cwd     = GetCurrentDir()
+src     = Glob('*.c')
+
+path = [cwd]
+
+if GetDepend(['RT_UTEST_SERIAL_POSIX']):
+    src += Glob('posix/*.c')
+
+if GetDepend(['RT_UTEST_SERIAL_QEMU']):
+    src += Glob('qemu/*.c')
+
+group = DefineGroup('utestcases', src, depend = ['RT_UTEST_SERIAL_V2'], CPPPATH = path)
+
+Return('group')
+

828ECO/rt-thread/components/drivers/serial/utest/v2/posix/uart_posix_echo_block.c

@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-16     KyleChan     the first version
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static int32_t    serial_fd;
+static rt_uint8_t uart_over_flag;
+static rt_bool_t  uart_result = RT_TRUE;
+
+static rt_err_t uart_find(void)
+{
+    serial_fd = open(RT_SERIAL_POSIX_TC_DEVICE_NAME, O_RDWR);
+    if (serial_fd == -1)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t configureSerial(int fd, int baud)
+{
+    int32_t        result = 0;
+    struct termios options;
+
+    result = tcgetattr(fd, &options); // 获取当前端口的属性
+    if (result == -1)
+        return -RT_ERROR;
+
+    // 设置波特率
+    result = cfsetispeed(&options, baud); // 设置输入波特率
+    if (result == -1)
+        return -RT_ERROR;
+
+    result = cfsetospeed(&options, baud); // 设置输出波特率
+    if (result == -1)
+        return -RT_ERROR;
+
+    // 设置数据位
+    options.c_cflag &= ~PARENB; // 清除校验位，无校验
+    options.c_cflag &= ~CSTOPB; // 仅一个停止位
+    options.c_cflag &= ~CSIZE;  // 清除掩码
+    options.c_cflag |= CS8;     // 8位数据
+
+    // 设置无流控
+    options.c_cflag &= ~CRTSCTS;                // 不使用硬件流控制
+    options.c_iflag &= ~(IXON | IXOFF | IXANY); // 不使用软件流控制
+
+    // 使能接收器和发送器
+    options.c_cflag |= CLOCAL | CREAD;
+
+    // 设置行终止符
+    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
+
+    // 应用属性
+    result = tcsetattr(fd, TCSANOW, &options);
+    if (result == -1)
+        return -RT_ERROR;
+
+    return RT_EOK;
+}
+
+static void uart_send_entry(void *parameter)
+{
+    rt_uint8_t *uart_write_buffer;
+    rt_uint16_t send_len;
+
+    rt_uint32_t i = 0;
+    send_len      = *(rt_uint16_t *)parameter;
+    /* assign send buffer */
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len);
+    if (uart_write_buffer == RT_NULL)
+    {
+        LOG_E("Without spare memory for uart dma!");
+        uart_result = RT_FALSE;
+        return;
+    }
+
+    rt_memset(uart_write_buffer, 0, send_len);
+
+    for (i = 0; i < send_len; i++)
+    {
+        uart_write_buffer[i] = (rt_uint8_t)i;
+    }
+    /* send buffer */
+    if (write(serial_fd, uart_write_buffer, send_len) != send_len)
+    {
+        LOG_E("device write failed\r\n");
+    }
+    rt_free(uart_write_buffer);
+}
+
+static void uart_rec_entry(void *parameter)
+{
+    rt_uint16_t rev_len;
+
+    rev_len = *(rt_uint16_t *)parameter;
+    rt_uint8_t *uart_write_buffer;
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
+    rt_int32_t  cnt, i;
+    rt_uint8_t  last_old_data;
+    rt_bool_t   fisrt_flag         = RT_TRUE;
+    rt_uint32_t all_receive_length = 0;
+
+    while (1)
+    {
+        cnt = read(serial_fd, (void *)uart_write_buffer, rev_len);
+        if (cnt == 0)
+        {
+            continue;
+        }
+
+        if (fisrt_flag != RT_TRUE)
+        {
+            if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0])
+            {
+                LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]);
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        else
+        {
+            fisrt_flag = RT_FALSE;
+        }
+
+        for (i = 0; i < cnt - 1; i++)
+        {
+            if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1])
+            {
+                LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]);
+
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        all_receive_length += cnt;
+        if (all_receive_length >= rev_len)
+            break;
+        else
+            last_old_data = uart_write_buffer[cnt - 1];
+    }
+    rt_free(uart_write_buffer);
+    uart_over_flag = RT_TRUE;
+}
+
+static rt_err_t uart_api(rt_uint16_t length)
+{
+    rt_thread_t thread_send = RT_NULL;
+    rt_thread_t thread_recv = RT_NULL;
+    rt_err_t    result      = RT_EOK;
+    int         flags       = 0;
+    uart_over_flag          = RT_FALSE;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return -RT_ERROR;
+    }
+
+    result = configureSerial(serial_fd, B115200);
+    if (result == -1)
+    {
+        goto __exit;
+    }
+
+
+    flags = fcntl(serial_fd, F_GETFL, 0);
+    if (flags == -1)
+    {
+        goto __exit;
+    }
+
+    result = fcntl(serial_fd, F_SETFL, flags & ~O_NONBLOCK);
+    if (result == -1)
+    {
+        goto __exit;
+    }
+
+
+    thread_send = rt_thread_create("uart_send", uart_send_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 4, 10);
+    thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 5, 10);
+    if ((thread_send != RT_NULL) && (thread_recv != RT_NULL))
+    {
+        rt_thread_startup(thread_send);
+        rt_thread_startup(thread_recv);
+    }
+    else
+    {
+        result = -RT_ERROR;
+        goto __exit;
+    }
+
+    while (1)
+    {
+        if (uart_result != RT_TRUE)
+        {
+            LOG_E("The test for uart dma is failure.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (uart_over_flag == RT_TRUE)
+        {
+            goto __exit;
+        }
+        /* waiting for test over */
+        rt_thread_mdelay(5);
+    }
+
+__exit:
+    rt_thread_mdelay(5);
+    close(serial_fd);
+    uart_over_flag = RT_FALSE;
+    return result;
+}
+
+static void tc_uart_api(void)
+{
+    rt_uint32_t times = 0;
+    rt_uint16_t num   = 0;
+    rt_uint32_t i     = 0;
+
+    while (RT_SERIAL_POSIX_TC_SEND_ITERATIONS - times)
+    {
+        num = (rand() % 1000) + 1;
+        if (uart_api(num) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] times testing.", num, ++times);
+        else
+        {
+            LOG_E("uart test error");
+            break;
+        }
+    }
+
+__exit:
+    uassert_true(uart_result == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    uart_result    = RT_TRUE;
+    uart_over_flag = RT_FALSE;
+    close(serial_fd);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_posix_echo_block", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/posix/uart_posix_nonblock.c

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-16     KyleChan     the first version
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static int32_t serial_fd;
+
+static rt_err_t uart_find(void)
+{
+    serial_fd = open(RT_SERIAL_POSIX_TC_DEVICE_NAME, O_RDWR);
+    if (serial_fd == -1)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t configureSerial(int fd, int baud)
+{
+    int32_t        result = 0;
+    struct termios options;
+
+    result = tcgetattr(fd, &options); // 获取当前端口的属性
+    if (result == -1)
+        return -RT_ERROR;
+
+    // 设置波特率
+    result = cfsetispeed(&options, baud); // 设置输入波特率
+    if (result == -1)
+        return -RT_ERROR;
+
+    result = cfsetospeed(&options, baud); // 设置输出波特率
+    if (result == -1)
+        return -RT_ERROR;
+
+    // 设置数据位
+    options.c_cflag &= ~PARENB; // 清除校验位，无校验
+    options.c_cflag &= ~CSTOPB; // 仅一个停止位
+    options.c_cflag &= ~CSIZE;  // 清除掩码
+    options.c_cflag |= CS8;     // 8位数据
+
+    // 设置无流控
+    options.c_cflag &= ~CRTSCTS;                // 不使用硬件流控制
+    options.c_iflag &= ~(IXON | IXOFF | IXANY); // 不使用软件流控制
+
+    // 使能接收器和发送器
+    options.c_cflag |= CLOCAL | CREAD;
+
+    // 设置行终止符
+    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
+
+    // 应用属性
+    result = tcsetattr(fd, TCSANOW, &options);
+    if (result == -1)
+        return -RT_ERROR;
+
+    return RT_EOK;
+}
+
+static rt_err_t uart_api()
+{
+    rt_err_t    result = RT_EOK;
+    rt_uint8_t *uart_write_buffer;
+    rt_int32_t  cnt, i, send_size;
+    int         flags = 0;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return -RT_ERROR;
+    }
+
+    result = configureSerial(serial_fd, B115200);
+    if (result == -1)
+    {
+        goto __exit;
+    }
+
+    flags = fcntl(serial_fd, F_GETFL, 0);
+    if (flags == -1)
+    {
+        goto __exit;
+    }
+
+    result = fcntl(serial_fd, F_SETFL, flags | O_NONBLOCK);
+    if (result == -1)
+    {
+        goto __exit;
+    }
+
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(100);
+
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        send_size = 1;
+        cnt       = write(serial_fd, uart_write_buffer, send_size);
+        if (cnt != send_size)
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        rt_thread_mdelay(2);
+        cnt = read(serial_fd, (void *)uart_write_buffer, send_size);
+        if (cnt != send_size)
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        send_size = rand() % 30 + 1;
+        cnt       = write(serial_fd, uart_write_buffer, send_size);
+        if (cnt != send_size)
+        {
+            LOG_E("uart write failed %d %d", cnt, send_size);
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        rt_thread_mdelay(send_size * 0.0868 + 5);
+        cnt = read(serial_fd, (void *)uart_write_buffer, send_size + 1);
+        if (cnt != send_size)
+        {
+            LOG_E("uart read failed %d %d", cnt, send_size);
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_thread_mdelay(5);
+    if (uart_write_buffer)
+        rt_free(uart_write_buffer);
+    close(serial_fd);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    close(serial_fd);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_posix_nonblock", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/qemu/uart_qemu_echo.c

@@ -0,0 +1,171 @@
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+#define UART_SEND_TIMES  100
+#define UART_TEST_NUMBER 6
+
+
+#ifdef RT_UTEST_SERIAL_V2
+#define echo_test_buffer_size (1024)
+
+static rt_device_t u1serial;
+static rt_device_t u2serial;
+
+static rt_uint32_t u2rx_length = 0;
+static rt_uint32_t u2tx_length = 0;
+
+static rt_uint32_t u1rx_length = 0;
+static rt_uint32_t u1tx_length = 0;
+
+static rt_uint8_t uart_over_flag = RT_FALSE;
+
+static void echo_test_u2_thread_entry(void *parameter)
+{
+    char *uart_name = "uart2";
+
+    u2serial = rt_device_find(uart_name);
+    if (!u2serial)
+    {
+        LOG_I("find %s failed!\n", uart_name);
+        return;
+    }
+
+    rt_uint8_t *rx_buffer = rt_malloc(echo_test_buffer_size);
+
+    rt_device_open(u2serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+
+    rt_ssize_t buf_datalen = 0;
+    while (1)
+    {
+        rt_device_control(u2serial, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_datalen);
+        int32_t recbLen = rt_device_read(u2serial, 0, rx_buffer, buf_datalen > 0 ? buf_datalen : 1);
+        if (recbLen > 0)
+        {
+            u2rx_length += recbLen;
+            u2tx_length += rt_device_write(u2serial, 0, rx_buffer, recbLen);
+
+            if (uart_over_flag)
+                break;
+        }
+    }
+    rt_free(rx_buffer);
+}
+
+static void echo_test_u1_thread_entry(void *parameter)
+{
+    rt_uint8_t *rx_buffer   = rt_malloc(echo_test_buffer_size);
+    rt_ssize_t  buf_datalen = 0;
+    while (1)
+    {
+        rt_device_control(u1serial, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_datalen);
+        int32_t recbLen = rt_device_read(u1serial, 0, rx_buffer, buf_datalen > 0 ? buf_datalen : 1);
+        if (recbLen > 0)
+        {
+            u1rx_length += recbLen;
+            if (uart_over_flag)
+                break;
+        }
+    }
+
+    rt_free(rx_buffer);
+}
+
+
+static rt_bool_t echo_test()
+{
+    rt_bool_t result    = RT_TRUE;
+    char     *uart_name = "uart1";
+    u1serial            = rt_device_find(uart_name);
+    if (!u1serial)
+    {
+        LOG_I("find %s failed!\n", uart_name);
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *tx_buffer = rt_malloc(echo_test_buffer_size);
+
+    rt_device_open(u1serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    rt_thread_startup(rt_thread_create("serial2", echo_test_u2_thread_entry, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 4, 5));
+    rt_thread_startup(rt_thread_create("serial1", echo_test_u1_thread_entry, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 5));
+
+    uint32_t sendTotalCount = 0;
+    srand(rt_tick_get());
+    for (uint32_t count = 0; count < 1000; count++)
+    {
+        // Indefinite length of data is sent
+        uint32_t sendCount = rand() % echo_test_buffer_size;
+
+
+        u1tx_length    += rt_device_write(u1serial, 0, tx_buffer, sendCount);
+        sendTotalCount += sendCount;
+
+        // Wait for the cross-send to complete
+        rt_thread_mdelay(UART_SEND_TIMES);
+
+        if (count % 50 == 0)
+        {
+            LOG_I("echo, uart2: tx: %ld, rx: %ld", u2tx_length, u2rx_length);
+            LOG_I("echo, uart1: tx: %ld, rx: %ld", u1tx_length, u1rx_length);
+            if (u2tx_length != u2rx_length || u1tx_length != u1rx_length || u2tx_length != u1tx_length)
+            {
+                LOG_I("echo test error!!!");
+                result = RT_FALSE;
+                break;
+            }
+
+            if (u2tx_length != sendTotalCount)
+            {
+                LOG_I("u2tx_length != sendTotalCount echo test error!!!");
+                result = RT_FALSE;
+                break;
+            }
+        }
+    }
+
+    uart_over_flag = RT_TRUE;
+    // Notify the thread to exit
+    rt_device_write(u1serial, 0, tx_buffer, echo_test_buffer_size);
+    rt_thread_mdelay(30);
+
+    {
+        rt_device_t uart_dev = rt_device_find("uart2");
+        while (rt_device_close(uart_dev) != -RT_ERROR);
+    }
+    {
+        rt_device_t uart_dev = rt_device_find("uart1");
+        while (rt_device_close(uart_dev) != -RT_ERROR);
+    }
+    rt_free(tx_buffer);
+    return result;
+}
+
+static void uart_test_nonblocking_tx(void)
+{
+    uassert_true(echo_test());
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    u1serial       = RT_NULL;
+    u2serial       = RT_NULL;
+    u2rx_length    = 0;
+    u2tx_length    = 0;
+    u1rx_length    = 0;
+    u1tx_length    = 0;
+    uart_over_flag = RT_FALSE;
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(uart_test_nonblocking_tx);
+}
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_qemu_echo", utest_tc_init, utest_tc_cleanup, 10);
+
+#endif

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_blocking_rx.c

@@ -0,0 +1,88 @@
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static rt_bool_t block_read(rt_device_t uart_dev)
+{
+    rt_size_t total_length, recv_length;
+    char      uart_read_buffer[1024], log_buffer[64];
+
+    /* make sure device is closed and reopen it */
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_RX_BLOCKING);
+
+    rt_sprintf(log_buffer, "\nBLOCKING READ BEGIN, PLEASE SEND SOME DATAS\n");
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    total_length  = 0;
+    recv_length   = 0;
+    recv_length   = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer));
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nblock : %d bytes read, total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    recv_length   = 0;
+    recv_length   = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer));
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nblock : %d bytes read , total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    recv_length   = 0;
+    recv_length   = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer));
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nblock : %d bytes read , total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    recv_length   = 0;
+    recv_length   = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer));
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nblock : %d bytes read , total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    recv_length   = 0;
+    recv_length   = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer));
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nblock : %d bytes read , total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    rt_sprintf(log_buffer, "BLOCKING READ END");
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    return RT_TRUE;
+}
+
+static void uart_test_blocking_rx(void)
+{
+    rt_device_t uart_dev;
+    uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    uassert_not_null(uart_dev);
+
+    uassert_true(block_read(uart_dev));
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(uart_test_blocking_rx);
+}
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_blocking_rx", utest_tc_init, utest_tc_cleanup, 10);
+
+#endif

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_blocking_tx.c

@@ -0,0 +1,119 @@
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+#define UART_SEND_TIMES  100
+#define UART_TEST_NUMBER 6
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static rt_bool_t block_write(rt_device_t uart_dev)
+{
+    rt_size_t i, wr_sz, index, write_num_array[UART_TEST_NUMBER], total_write_num[UART_TEST_NUMBER];
+    rt_tick_t tick1, tick2, tick_array[UART_TEST_NUMBER];
+    char      uart_write_buffer[1024];
+
+    for (i = 0; i < 1024; i++)
+        uart_write_buffer[i] = '0' + (i % 49);
+
+    /* make sure device is closed and reopen it */
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING);
+
+    LOG_D("\nBLOCKING WRITE BEGIN\n");
+
+    index = 0;
+    wr_sz = 0;
+    tick1 = rt_tick_get();
+    for (i = 0; i < UART_SEND_TIMES; i++)
+        wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 1024);
+
+    tick2                    = rt_tick_get();
+    total_write_num[index]   = UART_SEND_TIMES * 1024;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz  = 0;
+    tick1  = rt_tick_get();
+    wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 8);
+    tick2  = rt_tick_get();
+
+    total_write_num[index]   = 8;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz  = 0;
+    tick1  = rt_tick_get();
+    wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 32);
+    tick2  = rt_tick_get();
+
+    total_write_num[index]   = 32;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz  = 0;
+    tick1  = rt_tick_get();
+    wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 128);
+    tick2  = rt_tick_get();
+
+    total_write_num[index]   = 128;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz  = 0;
+    tick1  = rt_tick_get();
+    wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 512);
+    tick2  = rt_tick_get();
+
+    total_write_num[index]   = 512;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz  = 0;
+    tick1  = rt_tick_get();
+    wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 1024);
+    tick2  = rt_tick_get();
+
+    total_write_num[index]   = 1024;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    LOG_D("\nBLOCKING_TX END\n");
+    for (i = 0; i < index; i++)
+    {
+        LOG_D("\nBLOCKING_MODE : write %d / %d bytes in %d ticks\n", write_num_array[i], total_write_num[i], tick_array[i]);
+        rt_thread_mdelay(10);
+    }
+
+    return RT_TRUE;
+}
+
+static void uart_test_blocking_tx(void)
+{
+    rt_device_t uart_dev;
+    uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    uassert_not_null(uart_dev);
+
+    uassert_true(block_write(uart_dev));
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(uart_test_blocking_tx);
+}
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_blocking_tx", utest_tc_init, utest_tc_cleanup, 10);
+
+#endif

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_flush_rx.c

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
+{
+    rt_uint8_t  readBuf[16] = {0};
+    rt_uint32_t readSize    = 0;
+    if (send_size >= sizeof(readBuf))
+    {
+        readSize = sizeof(readBuf);
+    }
+    else
+    {
+        readSize = send_size;
+    }
+
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
+    rt_thread_mdelay(send_size * 0.0868 + 5);
+    if (1 != rt_device_read(&serial->parent, 0, uart_write_buffer, 1))
+    {
+        LOG_E("read failed.");
+        return -RT_ERROR;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL);
+    if (0 != rt_device_read(&serial->parent, 0, uart_write_buffer, 1))
+    {
+        LOG_E("read failed.");
+        return -RT_ERROR;
+    }
+
+    /* Resend the data and check for any discrepancies upon reception */
+    if (readSize > 0)
+    {
+        rt_device_write(&serial->parent, 0, uart_write_buffer, readSize);
+        rt_thread_mdelay(readSize * 0.0868 + 5);
+        rt_device_read(&serial->parent, 0, readBuf, readSize);
+
+        for (rt_uint32_t i = 0; i < readSize; i++)
+        {
+            if (readBuf[i] != uart_write_buffer[i])
+            {
+                LOG_E("index: %d, Read Different data -> former data: %x, current data: %x.", i, uart_write_buffer[i], readBuf[i]);
+                return -RT_ERROR;
+            }
+        }
+    }
+
+    LOG_I("flush rx send_size [%4d]", send_size);
+
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE * 5 + 1);
+    for (rt_uint32_t count = 0; count < (RT_SERIAL_TC_RXBUF_SIZE * 5 + 1); count++)
+    {
+        uart_write_buffer[count] = count;
+    }
+
+    srand(rt_tick_get());
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE + RT_SERIAL_TC_RXBUF_SIZE * (rand() % 5)))
+        {
+            LOG_E("test_item failed.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_RXBUF_SIZE * 5)))
+        {
+            LOG_E("test_item failed.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_flush_rx", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_flush_txb.c

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
+{
+    rt_uint32_t old_tick;
+    rt_tick_t   tick_diff;
+    rt_tick_t   expect_time = send_size * 0.0868;
+
+    rt_uint8_t  readBuf[16] = {0};
+    rt_uint32_t readSize    = 0;
+    if (send_size >= sizeof(readBuf))
+    {
+        readSize = sizeof(readBuf);
+    }
+    else
+    {
+        readSize = send_size;
+    }
+
+    /* In interrupt mode, ticks may be inaccurate; compensation should be applied*/
+    if (send_size > 384)
+    {
+        expect_time -= send_size / 384;
+    }
+
+    old_tick        = rt_tick_get();
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
+    tick_diff = rt_tick_get() - old_tick;
+
+    if (tick_diff < expect_time || tick_diff > (expect_time + 10))
+    {
+        LOG_E("send_size [%4d], time required for TXB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
+        return -RT_ERROR;
+    }
+    else
+    {
+        LOG_I("send_size [%4d], time required for TXB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
+    }
+
+    /* Resend the data and check for any discrepancies upon reception */
+    if (readSize > 0)
+    {
+        rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL);
+        rt_device_write(&serial->parent, 0, uart_write_buffer, readSize);
+        rt_device_read(&serial->parent, 0, readBuf, readSize);
+
+        for (rt_uint32_t i = 0; i < readSize; i++)
+        {
+            if (readBuf[i] != uart_write_buffer[i])
+            {
+                LOG_E("index: %d, Read Different data -> former data: %x, current data: %x.", i, uart_write_buffer[i], readBuf[i]);
+                return -RT_ERROR;
+            }
+        }
+    }
+
+
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE * 5 + 10;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    rt_int32_t  tx_timeout = 10 * 1000;
+    uart_write_buffer      = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_TXBUF_SIZE * 5 + 10);
+    for (rt_uint32_t count = 0; count < (RT_SERIAL_TC_TXBUF_SIZE * 5 + 10); count++)
+    {
+        uart_write_buffer[count] = count;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&tx_timeout);
+
+    srand(rt_tick_get());
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_TXBUF_SIZE * (rand() % 6)))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_TXBUF_SIZE * (rand() % 6) + 1))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_TXBUF_SIZE * 5)))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_flush_txb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_flush_txnb.c

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
+{
+    rt_uint32_t old_tick;
+    rt_tick_t   tick_diff;
+    rt_tick_t   expect_time = send_size * 0.0868;
+    rt_uint8_t  readBuf[16] = {0};
+    rt_uint32_t readSize    = 0;
+    if (send_size >= sizeof(readBuf))
+    {
+        readSize = sizeof(readBuf);
+    }
+    else
+    {
+        readSize = send_size;
+    }
+
+    /* In interrupt mode, ticks may be inaccurate; compensation should be applied */
+    if (send_size > 384)
+    {
+        expect_time -= send_size / 384;
+    }
+
+    old_tick        = rt_tick_get();
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
+    tick_diff = rt_tick_get() - old_tick;
+
+    if (tick_diff < expect_time || tick_diff > (expect_time + 10))
+    {
+        LOG_E("send_size [%4d], time required for TXNB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
+        return -RT_ERROR;
+    }
+    else
+    {
+        LOG_I("send_size [%4d], time required for TXNB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
+    }
+
+    /* Resend the data and check for any discrepancies upon reception */
+    if (readSize > 0)
+    {
+        rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL);
+        rt_device_write(&serial->parent, 0, uart_write_buffer, readSize);
+        rt_device_read(&serial->parent, 0, readBuf, readSize);
+
+        for (rt_uint32_t i = 0; i < readSize; i++)
+        {
+            if (readBuf[i] != uart_write_buffer[i])
+            {
+                LOG_E("index: %d, Read Different data -> former data: %x, current data: %x.", i, uart_write_buffer[i], readBuf[i]);
+                return -RT_ERROR;
+            }
+        }
+    }
+
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE * 5 + 10;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    rt_int32_t  tx_timeout = 1;
+    uart_write_buffer      = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE * 5 + 10);
+    for (rt_uint32_t count = 0; count < (RT_SERIAL_TC_TXBUF_SIZE * 5 + 10); count++)
+    {
+        uart_write_buffer[count] = count;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&tx_timeout);
+
+    srand(rt_tick_get());
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE * (rand() % 6)))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE * (rand() % 6) + 1))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_RXBUF_SIZE * 5)))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_flush_txnb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_get_unread_bytes_count.c

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+/* */
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+static rt_uint8_t               uart_over_flag = RT_FALSE;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t size)
+{
+    rt_uint32_t old_tick;
+    rt_ssize_t  send_len;
+    rt_ssize_t  buf_data_len;
+
+    send_len = rt_device_write(&serial->parent, 0, uart_write_buffer, size);
+    if (size > RT_SERIAL_TC_RXBUF_SIZE)
+    {
+        size = RT_SERIAL_TC_RXBUF_SIZE;
+    }
+
+    rt_thread_delay(5);
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_data_len);
+    if (size != buf_data_len)
+    {
+        return -RT_ERROR;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL);
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_data_len);
+    if (0 != buf_data_len)
+    {
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_TXBUF_SIZE * 5 + 1);
+
+    srand(rt_tick_get());
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE + RT_SERIAL_TC_RXBUF_SIZE * (rand() % 5)))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+
+        if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_RXBUF_SIZE * 5)))
+        {
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_get_unread_bytes_count", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_nonblocking_rx.c

@@ -0,0 +1,98 @@
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static rt_bool_t nonblock_read(rt_device_t uart_dev)
+{
+    rt_size_t total_length, recv_length;
+    char      uart_read_buffer[1024], log_buffer[64];
+
+    /* make sure device is closed and reopen it */
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_RX_NON_BLOCKING);
+
+    rt_sprintf(log_buffer, "\nNONBLOCKING READ BEGIN, PLEASE SEND SOME DATAS\n");
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    total_length = 0;
+    rt_device_write(uart_dev, 0, "5\n", 2);
+    recv_length = 0;
+    recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 256);
+    rt_device_write(uart_dev, 0, uart_read_buffer, 256);
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nnonblock : %d bytes read, total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    rt_device_write(uart_dev, 0, "4\n", 2);
+    recv_length = 0;
+    recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 256);
+    rt_device_write(uart_dev, 0, uart_read_buffer, 256);
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nnonblock : %d bytes read , total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    rt_device_write(uart_dev, 0, "3\n", 2);
+    recv_length = 0;
+    recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 256);
+    rt_device_write(uart_dev, 0, uart_read_buffer, 256);
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nnonblock : %d bytes read, total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    rt_device_write(uart_dev, 0, "2\n", 2);
+    recv_length = 0;
+    recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 128);
+    rt_device_write(uart_dev, 0, uart_read_buffer, 128);
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nnonblock : %d bytes read , total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    rt_device_write(uart_dev, 0, "1\n", 2);
+    recv_length = 0;
+    recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 128);
+    rt_device_write(uart_dev, 0, uart_read_buffer, 128);
+    total_length += recv_length;
+
+    rt_sprintf(log_buffer, "\nnonblock : %d bytes read , total: %d \n", recv_length, total_length);
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    rt_sprintf(log_buffer, "BLOCKING READ END");
+    rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
+
+    return RT_TRUE;
+}
+
+static void uart_test_nonblocking_rx(void)
+{
+    rt_device_t uart_dev;
+    uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    uassert_not_null(uart_dev);
+
+    uassert_true(nonblock_read(uart_dev));
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(uart_test_nonblocking_rx);
+}
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_nonblocking_rx", utest_tc_init, utest_tc_cleanup, 10);
+
+#endif

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_nonblocking_tx.c

@@ -0,0 +1,124 @@
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "utest.h"
+
+#define UART_SEND_TIMES  100
+#define UART_TEST_NUMBER 6
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static rt_bool_t nonblock_write(rt_device_t uart_dev)
+{
+    rt_size_t  wr_sz = 0, tmp = 0, i, write_num_array[UART_TEST_NUMBER], total_write_num[UART_TEST_NUMBER], index;
+    rt_tick_t  tick1, tick2, tick_array[UART_TEST_NUMBER];
+    rt_uint8_t uart_write_buffer[1024];
+
+    for (i = 0; i < 1024; i++)
+        uart_write_buffer[i] = '0' + (i % 50);
+
+    /* make sure device is closed and reopen it */
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_NON_BLOCKING | RT_DEVICE_FLAG_RX_NON_BLOCKING);
+
+    LOG_D("\nNONBLOCKING WRITE BEGIN\n");
+
+    index = 0;
+    tmp   = 0;
+    tick1 = rt_tick_get();
+    for (i = 0; i < UART_SEND_TIMES; i++)
+    {
+        wr_sz = 0;
+        while (wr_sz < 1024)
+            wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 1024 - wr_sz);
+        tmp += wr_sz;
+    }
+    tick2                    = rt_tick_get();
+    total_write_num[index]   = UART_SEND_TIMES * 1024;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = tmp;
+
+    wr_sz = 0;
+    tick1 = rt_tick_get();
+    while (wr_sz < 8)
+        wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 8 - wr_sz);
+    tick2                    = rt_tick_get();
+    total_write_num[index]   = 8;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz = 0;
+    tick1 = rt_tick_get();
+    while (wr_sz < 32)
+        wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 32 - wr_sz);
+    tick2                    = rt_tick_get();
+    total_write_num[index]   = 32;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz = 0;
+    tick1 = rt_tick_get();
+    while (wr_sz < 128)
+        wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 128 - wr_sz);
+    tick2                    = rt_tick_get();
+    total_write_num[index]   = 128;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz = 0;
+    tick1 = rt_tick_get();
+    while (wr_sz < 512)
+        wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 512 - wr_sz);
+    tick2                    = rt_tick_get();
+    total_write_num[index]   = 512;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    wr_sz = 0;
+    tick1 = rt_tick_get();
+    while (wr_sz < 1024)
+        wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 1024 - wr_sz);
+    tick2                    = rt_tick_get();
+    total_write_num[index]   = 1024;
+    tick_array[index]        = tick2 - tick1;
+    write_num_array[index++] = wr_sz;
+
+    LOG_D("\nNONBLOCKING_TX END\n");
+    for (i = 0; i < index; i++)
+    {
+        LOG_D("\nNONBLOCKING_MODE : write %d / %d bytes in %d ticks\n", write_num_array[i], total_write_num[i], tick_array[i]);
+        rt_thread_mdelay(10);
+    }
+
+    return RT_TRUE;
+}
+
+static void uart_test_nonblocking_tx(void)
+{
+    rt_device_t uart_dev;
+    uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    uassert_not_null(uart_dev);
+
+    uassert_true(nonblock_write(uart_dev));
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(uart_test_nonblocking_tx);
+}
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_nonblocking_tx", utest_tc_init, utest_tc_cleanup, 10);
+
+#endif

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_overflow_rxb_txb.c

@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+static rt_uint8_t               uart_over_flag = RT_FALSE;
+static rt_bool_t                uart_result    = RT_TRUE;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+
+static void uart_send_entry(void *parameter)
+{
+    rt_uint32_t send_len;
+    rt_uint8_t *uart_write_buffer = RT_NULL;
+    rt_uint32_t i                 = 0;
+    send_len                      = *(rt_uint32_t *)parameter;
+
+    /* assign send buffer */
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len);
+    if (uart_write_buffer == RT_NULL)
+    {
+        LOG_E("Without spare memory for uart dma!");
+        uart_result = RT_FALSE;
+        return;
+    }
+
+    rt_memset(uart_write_buffer, 0, send_len);
+
+    for (i = 0; i < send_len; i++)
+    {
+        uart_write_buffer[i] = (rt_uint8_t)i;
+    }
+    /* send buffer */
+    if (rt_device_write(&serial->parent, 0, uart_write_buffer, send_len) != send_len)
+    {
+        LOG_E("device write failed\r\n");
+    }
+    rt_free(uart_write_buffer);
+}
+
+static void uart_rec_entry(void *parameter)
+{
+    rt_uint32_t rev_len;
+    rt_uint8_t *uart_write_buffer;
+    rt_int32_t  cnt, i;
+    rev_len           = *(rt_uint32_t *)parameter;
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(rev_len + 1);
+
+    while (1)
+    {
+        cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE);
+        if (cnt != RT_SERIAL_TC_RXBUF_SIZE)
+        {
+            uart_result = RT_FALSE;
+            rt_free(uart_write_buffer);
+            return;
+        }
+
+#ifdef RT_SERIAL_BUF_STRATEGY_DROP
+        for (i = 0; i < cnt; i++)
+        {
+            if (uart_write_buffer[i] != i)
+            {
+                LOG_E("Read Different data2 -> former data: %x, current data: %x.", uart_write_buffer[i], i);
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+#else
+        for (i = cnt - 1; i >= 0; i--)
+        {
+            if (uart_write_buffer[i] != ((rev_len - (cnt - i)) % (UINT8_MAX + 1)))
+            {
+                LOG_E("Read Different data2 -> former data: %x, current data: %x.", uart_write_buffer[i], ((rev_len - (cnt - i)) % (UINT8_MAX + 1)));
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+#endif /* RT_SERIAL_BUF_STRATEGY_DROP */
+        break;
+    }
+    rt_free(uart_write_buffer);
+    uart_over_flag = RT_TRUE;
+}
+
+static rt_err_t uart_api(rt_uint32_t length)
+{
+    rt_thread_t thread_send = RT_NULL;
+    rt_thread_t thread_recv = RT_NULL;
+    rt_err_t    result      = RT_EOK;
+    uart_over_flag          = RT_FALSE;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return -RT_ERROR;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    rt_int32_t timeout = 5000;
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout);
+
+    thread_send = rt_thread_create("uart_send", uart_send_entry, &length, 2048, RT_THREAD_PRIORITY_MAX - 4, 10);
+    thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &length, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+    if ((thread_send != RT_NULL) && (thread_recv != RT_NULL))
+    {
+        rt_thread_startup(thread_send);
+        /* waiting for data transmission to complete*/
+        rt_thread_mdelay(length * 0.0868 + 10);
+        rt_thread_startup(thread_recv);
+    }
+    else
+    {
+        result = -RT_ERROR;
+        goto __exit;
+    }
+
+    while (1)
+    {
+        if (uart_result != RT_TRUE)
+        {
+            LOG_E("The test for uart dma is failure.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (uart_over_flag == RT_TRUE)
+        {
+            goto __exit;
+        }
+        /* waiting for test over */
+        rt_thread_mdelay(5);
+    }
+__exit:
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result;
+}
+
+static void tc_uart_api(void)
+{
+    rt_uint32_t count = 0;
+    rt_uint16_t num   = 0;
+    rt_uint32_t i     = 0;
+
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    srand(rt_tick_get());
+    while (RT_SERIAL_TC_SEND_ITERATIONS - count)
+    {
+        num = (rand() % RT_SERIAL_TC_RXBUF_SIZE) + 1;
+        if (uart_api(num + RT_SERIAL_TC_RXBUF_SIZE) == RT_EOK)
+            LOG_I("data_lens [%3d], it is correct to read and write data. [%d] count testing.", num, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            break;
+        }
+    }
+
+__exit:
+    uassert_true(uart_result == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    uart_result          = RT_TRUE;
+    uart_over_flag       = RT_FALSE;
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_overflow_rxb_txb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_rxb_txb.c

@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-16     KyleChan     the first version
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+static rt_uint8_t               uart_over_flag;
+static rt_bool_t                uart_result = RT_TRUE;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static void uart_send_entry(void *parameter)
+{
+    rt_uint8_t *uart_write_buffer;
+    rt_uint16_t send_len;
+
+    rt_uint32_t i = 0;
+    send_len      = *(rt_uint16_t *)parameter;
+    /* assign send buffer */
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len);
+    if (uart_write_buffer == RT_NULL)
+    {
+        LOG_E("Without spare memory for uart dma!");
+        uart_result = RT_FALSE;
+        return;
+    }
+
+    rt_memset(uart_write_buffer, 0, send_len);
+
+    for (i = 0; i < send_len; i++)
+    {
+        uart_write_buffer[i] = (rt_uint8_t)i;
+    }
+    /* send buffer */
+    if (rt_device_write(&serial->parent, 0, uart_write_buffer, send_len) != send_len)
+    {
+        LOG_E("device write failed\r\n");
+    }
+    rt_free(uart_write_buffer);
+}
+
+static void uart_rec_entry(void *parameter)
+{
+    rt_uint16_t rev_len;
+
+    rev_len = *(rt_uint16_t *)parameter;
+    rt_uint8_t *uart_write_buffer;
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
+    rt_int32_t  cnt, i;
+    rt_uint8_t  last_old_data;
+    rt_bool_t   fisrt_flag         = RT_TRUE;
+    rt_uint32_t all_receive_length = 0;
+
+    while (1)
+    {
+        cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, rev_len);
+        if (cnt == 0)
+        {
+            continue;
+        }
+
+        if (fisrt_flag != RT_TRUE)
+        {
+            if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0])
+            {
+                LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]);
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        else
+        {
+            fisrt_flag = RT_FALSE;
+        }
+
+        for (i = 0; i < cnt - 1; i++)
+        {
+            if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1])
+            {
+                LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]);
+
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        all_receive_length += cnt;
+        if (all_receive_length >= rev_len)
+            break;
+        else
+            last_old_data = uart_write_buffer[cnt - 1];
+    }
+    rt_free(uart_write_buffer);
+    uart_over_flag = RT_TRUE;
+}
+
+static rt_err_t uart_api(rt_uint16_t length)
+{
+    rt_thread_t thread_send = RT_NULL;
+    rt_thread_t thread_recv = RT_NULL;
+    rt_err_t    result      = RT_EOK;
+    uart_over_flag          = RT_FALSE;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return -RT_ERROR;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    rt_int32_t timeout = 5000;
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout);
+
+    thread_send = rt_thread_create("uart_send", uart_send_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 4, 10);
+    thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 5, 10);
+    if ((thread_send != RT_NULL) && (thread_recv != RT_NULL))
+    {
+        rt_thread_startup(thread_send);
+        rt_thread_startup(thread_recv);
+    }
+    else
+    {
+        result = -RT_ERROR;
+        goto __exit;
+    }
+
+    while (1)
+    {
+        if (uart_result != RT_TRUE)
+        {
+            LOG_E("The test for uart dma is failure.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (uart_over_flag == RT_TRUE)
+        {
+            goto __exit;
+        }
+        /* waiting for test over */
+        rt_thread_mdelay(5);
+    }
+
+__exit:
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    uart_over_flag = RT_FALSE;
+    return result;
+}
+
+static void tc_uart_api(void)
+{
+    rt_uint32_t count = 0;
+    rt_uint16_t num   = 0;
+    rt_uint32_t i     = 0;
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    srand(rt_tick_get());
+    while (RT_SERIAL_TC_SEND_ITERATIONS - count)
+    {
+        num = (rand() % 1000) + 1;
+        if (uart_api(num) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            break;
+        }
+    }
+
+__exit:
+    uassert_true(uart_result == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    uart_result          = RT_TRUE;
+    uart_over_flag       = RT_FALSE;
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_rxb_txb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_rxb_txnb.c

@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-16     KyleChan     the first version
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+static rt_sem_t                 tx_sem;
+static rt_uint8_t               uart_over_flag;
+static rt_bool_t                uart_result = RT_TRUE;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t uart_tx_completion(rt_device_t device, void *buffer)
+{
+    rt_sem_release(tx_sem);
+
+    return RT_EOK;
+}
+
+static void uart_send_entry(void *parameter)
+{
+    rt_uint8_t *uart_write_buffer;
+    rt_uint16_t send_len, len = 0;
+    rt_err_t    result;
+
+    rt_uint32_t i = 0;
+    send_len      = *(rt_uint16_t *)parameter;
+    /* assign send buffer */
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len);
+    if (uart_write_buffer == RT_NULL)
+    {
+        LOG_E("Without spare memory for uart dma!");
+        uart_result = RT_FALSE;
+        return;
+    }
+
+    rt_memset(uart_write_buffer, 0, send_len);
+
+    for (i = 0; i < send_len; i++)
+    {
+        uart_write_buffer[i] = (rt_uint8_t)i;
+    }
+    /* send buffer */
+    while (send_len - len)
+    {
+        len    += rt_device_write(&serial->parent, 0, uart_write_buffer + len, send_len - len);
+        result  = rt_sem_take(tx_sem, RT_WAITING_FOREVER);
+        if (result != RT_EOK)
+        {
+            LOG_E("take sem err in send.");
+        }
+    }
+    rt_free(uart_write_buffer);
+}
+
+static void uart_rec_entry(void *parameter)
+{
+    rt_uint16_t rev_len;
+
+    rev_len = *(rt_uint16_t *)parameter;
+    rt_uint8_t *uart_write_buffer;
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
+    rt_int32_t  cnt, i;
+    rt_uint8_t  last_old_data;
+    rt_bool_t   fisrt_flag         = RT_TRUE;
+    rt_uint32_t all_receive_length = 0;
+
+    while (1)
+    {
+        cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, rev_len);
+        if (cnt != rev_len)
+        {
+            continue;
+        }
+
+        if (fisrt_flag != RT_TRUE)
+        {
+            if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0])
+            {
+                LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]);
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        else
+        {
+            fisrt_flag = RT_FALSE;
+        }
+
+        for (i = 0; i < cnt - 1; i++)
+        {
+            if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1])
+            {
+                LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]);
+
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        all_receive_length += cnt;
+        if (all_receive_length >= rev_len)
+            break;
+        else
+            last_old_data = uart_write_buffer[cnt - 1];
+    }
+    rt_free(uart_write_buffer);
+    uart_over_flag = RT_TRUE;
+}
+
+static rt_err_t uart_api(rt_uint16_t test_buf)
+{
+    rt_thread_t thread_send = RT_NULL;
+    rt_thread_t thread_recv = RT_NULL;
+    rt_err_t    result      = RT_EOK;
+    uart_over_flag          = RT_FALSE;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return -RT_ERROR;
+    }
+
+    tx_sem = rt_sem_create("tx_sem", 0, RT_IPC_FLAG_PRIO);
+    if (tx_sem == RT_NULL)
+    {
+        LOG_E("Init sem failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    rt_int32_t timeout = 5000;
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout);
+
+    /* set receive callback function */
+    result = rt_device_set_tx_complete(&serial->parent, uart_tx_completion);
+    if (result != RT_EOK)
+    {
+        goto __exit;
+    }
+
+    thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 5, 10);
+    thread_send = rt_thread_create("uart_send", uart_send_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 4, 10);
+
+    if (thread_send != RT_NULL && thread_recv != RT_NULL)
+    {
+        rt_thread_startup(thread_recv);
+        rt_thread_startup(thread_send);
+    }
+    else
+    {
+        result = -RT_ERROR;
+        goto __exit;
+    }
+
+    while (1)
+    {
+        if (uart_result != RT_TRUE)
+        {
+            LOG_E("The test for uart dma is failure.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (uart_over_flag == RT_TRUE)
+        {
+            goto __exit;
+        }
+        /* waiting for test over */
+        rt_thread_mdelay(5);
+    }
+__exit:
+    if (tx_sem)
+        rt_sem_delete(tx_sem);
+
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    uart_over_flag = RT_FALSE;
+    return result;
+}
+
+static void tc_uart_api(void)
+{
+    rt_uint32_t count = 0;
+    rt_uint16_t num   = 0;
+    rt_uint32_t i     = 0;
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    srand(rt_tick_get());
+    while (RT_SERIAL_TC_SEND_ITERATIONS - count)
+    {
+        num = (rand() % 1000) + 1;
+        if (uart_api(num) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            break;
+        }
+    }
+
+__exit:
+    uassert_true(uart_result == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    tx_sem               = RT_NULL;
+    uart_result          = RT_TRUE;
+    uart_over_flag       = RT_FALSE;
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_rxb_txnb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_rxnb_txb.c

@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-16     KyleChan     the first version
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+static rt_sem_t                 rx_sem;
+static rt_uint8_t               uart_over_flag;
+static rt_bool_t                uart_result = RT_TRUE;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t uart_rx_indicate(rt_device_t device, rt_size_t size)
+{
+    rt_sem_release(rx_sem);
+
+    return RT_EOK;
+}
+
+static void uart_send_entry(void *parameter)
+{
+    rt_uint8_t *uart_write_buffer;
+    rt_uint16_t send_len;
+
+    rt_uint32_t i = 0;
+    send_len      = *(rt_uint16_t *)parameter;
+
+    /* assign send buffer */
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len);
+    if (uart_write_buffer == RT_NULL)
+    {
+        LOG_E("Without spare memory for uart dma!");
+        uart_result = RT_FALSE;
+        return;
+    }
+
+    rt_memset(uart_write_buffer, 0, send_len);
+
+    for (i = 0; i < send_len; i++)
+    {
+        uart_write_buffer[i] = (rt_uint8_t)i;
+    }
+
+    /* send buffer */
+    if (rt_device_write(&serial->parent, 0, uart_write_buffer, send_len) != send_len)
+    {
+        LOG_E("device write failed\r\n");
+    }
+    rt_free(uart_write_buffer);
+}
+
+static void uart_rec_entry(void *parameter)
+{
+    rt_uint16_t rev_len;
+
+    rev_len = *(rt_uint16_t *)parameter;
+    rt_uint8_t *uart_write_buffer;
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
+    rt_int32_t  cnt, i;
+    rt_uint8_t  last_old_data;
+    rt_bool_t   fisrt_flag         = RT_TRUE;
+    rt_uint32_t all_receive_length = 0;
+
+    while (1)
+    {
+        rt_err_t result;
+
+        result = rt_sem_take(rx_sem, RT_WAITING_FOREVER);
+        if (result != RT_EOK)
+        {
+            LOG_E("take sem err in recv.");
+        }
+
+        cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, rev_len);
+        if (cnt == 0)
+        {
+            continue;
+        }
+
+        if (fisrt_flag != RT_TRUE)
+        {
+            if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0])
+            {
+                LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]);
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        else
+        {
+            fisrt_flag = RT_FALSE;
+        }
+
+        for (i = 0; i < cnt - 1; i++)
+        {
+            if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1])
+            {
+                LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]);
+
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        all_receive_length += cnt;
+        if (all_receive_length >= rev_len)
+            break;
+        else
+            last_old_data = uart_write_buffer[cnt - 1];
+    }
+    rt_free(uart_write_buffer);
+    uart_over_flag = RT_TRUE;
+}
+
+static rt_err_t uart_api(rt_uint16_t test_buf)
+{
+    rt_thread_t thread_send = RT_NULL;
+    rt_thread_t thread_recv = RT_NULL;
+    rt_err_t    result      = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return -RT_ERROR;
+    }
+
+    rx_sem = rt_sem_create("rx_sem", 0, RT_IPC_FLAG_PRIO);
+    if (rx_sem == RT_NULL)
+    {
+        LOG_E("Init sem failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    /* reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        uart_result = RT_FALSE;
+        rt_sem_delete(rx_sem);
+        return -RT_ERROR;
+    }
+
+    rt_int32_t timeout = 5000;
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout);
+
+    /* set receive callback function */
+    result = rt_device_set_rx_indicate(&serial->parent, uart_rx_indicate);
+    if (result != RT_EOK)
+    {
+        goto __exit;
+    }
+
+    thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 5, 10);
+    thread_send = rt_thread_create("uart_send", uart_send_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 4, 10);
+
+    if (thread_send != RT_NULL && thread_recv != RT_NULL)
+    {
+        rt_thread_startup(thread_recv);
+        rt_thread_startup(thread_send);
+    }
+    else
+    {
+        result = -RT_ERROR;
+        goto __exit;
+    }
+
+    while (1)
+    {
+        if (uart_result != RT_TRUE)
+        {
+            LOG_E("The test for uart dma is failure.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (uart_over_flag == RT_TRUE)
+        {
+            goto __exit;
+        }
+        /* waiting for test over */
+        rt_thread_mdelay(5);
+    }
+__exit:
+    if (rx_sem)
+        rt_sem_delete(rx_sem);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    uart_over_flag = RT_FALSE;
+    return result;
+}
+
+static void tc_uart_api(void)
+{
+    rt_uint32_t count = 0;
+    rt_uint16_t num   = 0;
+    rt_uint32_t i     = 0;
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    srand(rt_tick_get());
+    while (RT_SERIAL_TC_SEND_ITERATIONS - count)
+    {
+        num = (rand() % 1000) + 1;
+        if (uart_api(num) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            break;
+        }
+    }
+
+__exit:
+    uassert_true(uart_result == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rx_sem               = RT_NULL;
+    uart_result          = RT_TRUE;
+    uart_over_flag       = RT_FALSE;
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_rxnb_txb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_rxnb_txnb.c

@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-16     KyleChan     the first version
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+static rt_sem_t                 tx_sem;
+static rt_sem_t                 rx_sem;
+static rt_uint8_t               uart_over_flag;
+static rt_bool_t                uart_result = RT_TRUE;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t uart_tx_completion(rt_device_t device, void *buffer)
+{
+    rt_sem_release(tx_sem);
+    return RT_EOK;
+}
+
+static rt_err_t uart_rx_indicate(rt_device_t device, rt_size_t size)
+{
+    rt_sem_release(rx_sem);
+    return RT_EOK;
+}
+
+static void uart_send_entry(void *parameter)
+{
+    rt_uint8_t *uart_write_buffer;
+    rt_uint16_t send_len, len = 0;
+    rt_err_t    result;
+
+    rt_uint32_t i = 0;
+    send_len      = *(rt_uint16_t *)parameter;
+    /* assign send buffer */
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len);
+    if (uart_write_buffer == RT_NULL)
+    {
+        LOG_E("Without spare memory for uart dma!");
+        uart_result = RT_FALSE;
+        return;
+    }
+
+    rt_memset(uart_write_buffer, 0, send_len);
+
+    for (i = 0; i < send_len; i++)
+    {
+        uart_write_buffer[i] = (rt_uint8_t)i;
+    }
+    /* send buffer */
+    while (send_len - len)
+    {
+        len    += rt_device_write(&serial->parent, 0, uart_write_buffer + len, send_len - len);
+        result  = rt_sem_take(tx_sem, RT_WAITING_FOREVER);
+        if (result != RT_EOK)
+        {
+            LOG_E("take sem err in send.");
+        }
+    }
+    rt_free(uart_write_buffer);
+}
+
+static void uart_rec_entry(void *parameter)
+{
+    rt_uint16_t rev_len;
+
+    rev_len = *(rt_uint16_t *)parameter;
+    rt_uint8_t *uart_write_buffer;
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
+    rt_int32_t  cnt, i;
+    rt_uint8_t  last_old_data;
+    rt_bool_t   fisrt_flag         = RT_TRUE;
+    rt_uint32_t all_receive_length = 0;
+
+    while (1)
+    {
+        rt_err_t result;
+
+        result = rt_sem_take(rx_sem, RT_WAITING_FOREVER);
+        if (result != RT_EOK)
+        {
+            LOG_E("take sem err in recv.");
+        }
+
+        cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, rev_len);
+        if (cnt == 0)
+        {
+            continue;
+        }
+
+        if (fisrt_flag != RT_TRUE)
+        {
+            if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0])
+            {
+                LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]);
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        else
+        {
+            fisrt_flag = RT_FALSE;
+        }
+
+        for (i = 0; i < cnt - 1; i++)
+        {
+            if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1])
+            {
+                LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]);
+
+                uart_result = RT_FALSE;
+                rt_free(uart_write_buffer);
+                return;
+            }
+        }
+        all_receive_length += cnt;
+        if (all_receive_length >= rev_len)
+            break;
+        else
+            last_old_data = uart_write_buffer[cnt - 1];
+    }
+    rt_free(uart_write_buffer);
+    uart_over_flag = RT_TRUE;
+}
+
+static rt_err_t uart_api(rt_uint16_t test_buf)
+{
+    rt_thread_t thread_send = RT_NULL;
+    rt_thread_t thread_recv = RT_NULL;
+    rt_err_t    result      = RT_EOK;
+    uart_over_flag          = RT_FALSE;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return -RT_ERROR;
+    }
+
+    rx_sem = rt_sem_create("rx_sem", 0, RT_IPC_FLAG_PRIO);
+    if (rx_sem == RT_NULL)
+    {
+        LOG_E("Init rx_sem failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    tx_sem = rt_sem_create("tx_sem", 0, RT_IPC_FLAG_PRIO);
+    if (tx_sem == RT_NULL)
+    {
+        LOG_E("Init tx_sem failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    /* reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        uart_result = RT_FALSE;
+        return -RT_ERROR;
+    }
+
+    rt_int32_t timeout = 5000;
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout);
+
+    /* set receive callback function */
+    result = rt_device_set_tx_complete(&serial->parent, uart_tx_completion);
+    if (result != RT_EOK)
+    {
+        goto __exit;
+    }
+
+    result = rt_device_set_rx_indicate(&serial->parent, uart_rx_indicate);
+    if (result != RT_EOK)
+    {
+        goto __exit;
+    }
+
+    thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 5, 10);
+    thread_send = rt_thread_create("uart_send", uart_send_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 4, 10);
+
+    if (thread_send != RT_NULL && thread_recv != RT_NULL)
+    {
+        rt_thread_startup(thread_recv);
+        rt_thread_startup(thread_send);
+    }
+    else
+    {
+        result = -RT_ERROR;
+        goto __exit;
+    }
+
+    while (1)
+    {
+        if (uart_result != RT_TRUE)
+        {
+            LOG_E("The test for uart dma is failure.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (uart_over_flag == RT_TRUE)
+        {
+            goto __exit;
+        }
+        /* waiting for test over */
+        rt_thread_mdelay(5);
+    }
+__exit:
+    if (tx_sem)
+        rt_sem_delete(tx_sem);
+
+    if (rx_sem)
+        rt_sem_delete(rx_sem);
+
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    uart_over_flag = RT_FALSE;
+    return result;
+}
+
+static void tc_uart_api(void)
+{
+    rt_uint32_t count = 0;
+    rt_uint16_t num   = 0;
+    rt_uint32_t i     = 0;
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    for (i = 1; i < 10; i++)
+    {
+        if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            goto __exit;
+        }
+    }
+
+    srand(rt_tick_get());
+    while (RT_SERIAL_TC_SEND_ITERATIONS - count)
+    {
+        num = (rand() % 1000) + 1;
+        if (uart_api(num) == RT_EOK)
+            LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count);
+        else
+        {
+            LOG_E("uart test error");
+            break;
+        }
+    }
+
+__exit:
+    uassert_true(uart_result == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    tx_sem               = RT_NULL;
+    uart_result          = RT_TRUE;
+    uart_over_flag       = RT_FALSE;
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_rxnb_txnb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_timeout_rxb.c

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t rx_timeout_test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
+{
+    rt_uint32_t readSize             = 0;
+    rt_int32_t  rx_timeout_send_size = send_size - send_size / 3;
+    rt_int32_t  rx_timeout           = rt_tick_from_millisecond(0.0868 * rx_timeout_send_size + 1);
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&rx_timeout);
+
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
+
+    readSize = rt_device_read(&serial->parent, 0, uart_write_buffer, size);
+    if (readSize < (rx_timeout_send_size - 70) || readSize > (send_size - 80))
+    {
+        LOG_E("readSize [%4d], rx_timeout_send_size [%4d]", readSize, rx_timeout_send_size);
+        return -RT_ERROR;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
+    /* Waiting for rx to complete reception */
+    rt_thread_mdelay(0.0868 * (send_size / 3));
+
+    LOG_I("rx timeout send_size [%4d]", send_size);
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = 2048;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(2048);
+
+
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        srand(rt_tick_get());
+        if (RT_EOK != rx_timeout_test_item(uart_write_buffer, 1024 + (rand() % 1024)))
+        {
+            LOG_E("test_item failed.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_timeout_rxb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_timeout_rxb_txb.c

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+/* */
+
+#ifdef RT_UTEST_SERIAL_V2
+
+static struct rt_serial_device *serial;
+static rt_bool_t                uart_result     = RT_TRUE;
+static rt_uint8_t               uart_write_flag = RT_TRUE;
+static rt_uint8_t               uart_over_flag  = RT_FALSE;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+
+static void uart_send_entry(void *parameter)
+{
+    rt_uint8_t *uart_write_buffer = RT_NULL;
+    rt_uint32_t i                 = 0;
+
+    /* assign send buffer */
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE);
+    if (uart_write_buffer == RT_NULL)
+    {
+        LOG_E("Without spare memory for uart dma!");
+        uart_result = RT_FALSE;
+        return;
+    }
+
+    for (i = 0; i < RT_SERIAL_TC_RXBUF_SIZE; i++)
+    {
+        uart_write_buffer[i] = (rt_uint8_t)i;
+    }
+
+    while (1)
+    {
+        if (uart_write_flag == RT_FALSE)
+            break;
+
+        rt_device_write(&serial->parent, 0, uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE / 3);
+        rt_thread_mdelay(40);
+    }
+
+    rt_free(uart_write_buffer);
+}
+
+static void uart_rec_entry(void *parameter)
+{
+    rt_uint8_t *uart_write_buffer;
+    rt_tick_t   old_tick;
+    rt_tick_t   tick_diff;
+    rt_ssize_t  recv_len;
+    rt_uint32_t i;
+    rt_int32_t  timeout = 0;
+    uart_write_buffer   = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE * 10 + 1);
+
+    timeout = 100;
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout);
+
+    uart_write_flag = RT_TRUE;
+    for (i = 0; i < 10; i++)
+    {
+        rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL);
+        old_tick  = rt_tick_get();
+        recv_len  = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE);
+        tick_diff = rt_tick_get() - old_tick;
+        if (tick_diff > 100 + 1 || tick_diff < 100)
+        {
+            LOG_E("timeout_test: recv_size [%d], RX block time [%d], expect_time [100 - 101]", recv_len, tick_diff);
+            uart_write_flag = RT_FALSE;
+            uart_result     = RT_FALSE;
+            rt_free(uart_write_buffer);
+            rt_thread_mdelay(60);
+            return;
+        }
+
+        LOG_I("timeout_test: RX block time [%d], expect_time [100 - 101]", tick_diff);
+    }
+    uart_write_flag = RT_FALSE;
+
+    rt_thread_mdelay(60);
+    timeout = 10;
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&timeout);
+
+    for (i = 0; i < 10; i++)
+    {
+        old_tick  = rt_tick_get();
+        recv_len  = rt_device_write(&serial->parent, 0, uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE * 10);
+        tick_diff = rt_tick_get() - old_tick;
+        if (tick_diff > 10 + 1 || tick_diff < 10)
+        {
+            LOG_E("timeout_test: recv_size [%d], TX block time [%d], expect_time [10 - 11]", recv_len, tick_diff);
+            uart_result = RT_FALSE;
+            rt_free(uart_write_buffer);
+            return;
+        }
+
+        LOG_I("timeout_test: TX block time [%d], expect_time [10 - 11]", tick_diff);
+        rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
+    }
+
+    rt_free(uart_write_buffer);
+    uart_over_flag = RT_TRUE;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_thread_t thread_send = RT_NULL;
+    rt_thread_t thread_recv = RT_NULL;
+    rt_err_t    result      = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    thread_send = rt_thread_create("uart_send", uart_send_entry, NULL, 2048, RT_THREAD_PRIORITY_MAX - 4, 10);
+    thread_recv = rt_thread_create("uart_recv", uart_rec_entry, NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10);
+
+    if ((thread_send != RT_NULL) && (thread_recv != RT_NULL))
+    {
+        rt_thread_startup(thread_send);
+        rt_thread_startup(thread_recv);
+    }
+    else
+    {
+        result = -RT_ERROR;
+        goto __exit;
+    }
+
+    while (1)
+    {
+        if (uart_result != RT_TRUE)
+        {
+            LOG_E("The test for uart dma is failure.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+        if (uart_over_flag == RT_TRUE)
+        {
+            goto __exit;
+        }
+        /* waiting for test over */
+        rt_thread_mdelay(5);
+    }
+
+__exit:
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    uart_result          = RT_TRUE;
+    uart_write_flag      = RT_TRUE;
+    uart_over_flag       = RT_FALSE;
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_timeout_rxb_txb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

828ECO/rt-thread/components/drivers/serial/utest/v2/uart_timeout_txb.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+#ifdef RT_UTEST_SERIAL_V2
+#ifndef BSP_UART2_TX_USING_DMA
+
+static struct rt_serial_device *serial;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t tx_timeout_test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
+{
+    rt_uint32_t readSize             = 0;
+    rt_int32_t  tx_timeout_send_size = send_size - send_size / 3;
+    rt_int32_t  tx_timeout           = rt_tick_from_millisecond(0.0868 * tx_timeout_send_size + 1);
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&tx_timeout);
+
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size < (tx_timeout_send_size - 70) || size > (send_size - 80))
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, tx_timeout_send_size);
+        return -RT_ERROR;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
+    /* Waiting for rx to complete reception */
+    rt_thread_mdelay(0.0868 * (send_size / 3));
+
+    LOG_I("tx timeout send_size [%4d]", send_size);
+
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(2048);
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        srand(rt_tick_get());
+        if (RT_EOK != tx_timeout_test_item(uart_write_buffer, 1024 + (rand() % 1024)))
+        {
+            LOG_E("test_item failed.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "components.drivers.serial.v2.uart_timeout_txb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* BSP_UART2_TX_USING_DMA */
+#endif /* TC_UART_USING_TC */