diff --git a/components/drivers/include/drivers/dev_serial.h b/components/drivers/include/drivers/dev_serial.h
index df2a62030aa..b7f627e8cdc 100644
--- a/components/drivers/include/drivers/dev_serial.h
+++ b/components/drivers/include/drivers/dev_serial.h
@@ -76,7 +76,7 @@
  *     if (!serial)
  *     {
  *         rt_kprintf("find %s failed!\n", uart_name);
- *         return RT_ERROR;
+ *         return -RT_ERROR;
  *     }
  *
  *
@@ -97,7 +97,7 @@
  *     }
  *     else
  *     {
- *         ret = RT_ERROR;
+ *         ret = -RT_ERROR;
  *     }
  *
  *     return ret;
@@ -264,7 +264,9 @@ struct rt_serial_device
     void *serial_tx;
 
     struct rt_spinlock spinlock;
-
+#ifdef RT_USING_SERIAL_BYPASS
+    struct rt_serial_bypass* bypass;
+#endif
     struct rt_device_notify rx_notify;
 };
 typedef struct rt_serial_device rt_serial_t;
diff --git a/components/drivers/include/drivers/serial_bypass.h b/components/drivers/include/drivers/serial_bypass.h
new file mode 100644
index 00000000000..890c8947d16
--- /dev/null
+++ b/components/drivers/include/drivers/serial_bypass.h
@@ -0,0 +1,69 @@
+/*
+ * 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
+ */
+
+#ifndef __RTT_BYPASS_H__
+#define __RTT_BYPASS_H__
+#include <rtthread.h>
+#include <rttypes.h>
+#include <rtdevice.h>
+typedef rt_err_t(*bypass_function_t)(struct rt_serial_device* serial, char buf, void* data);
+
+#define RT_BYPASS_LEVEL_MAX 4
+#define RT_BYPASS_LEVEL_1 0
+#define RT_BYPASS_LEVEL_2 1
+#define RT_BYPASS_LEVEL_3 2
+#define RT_BYPASS_LEVEL_4 3
+#define RT_BYPASS_MAX_LEVEL 4
+
+/*The protect level can be register but can not be unregister we should use it carefully*/
+#define RT_BYPASS_PROTECT_LEVEL_1 10
+#define RT_BYPASS_PROTECT_LEVEL_2 11
+#define RT_BYPASS_PROTECT_LEVEL_3 12
+#define RT_BYPASS_PROTECT_LEVEL_4 13
+
+struct rt_serial_bypass_func {
+    /*The function pointer of the bypassed data processing*/
+    bypass_function_t bypass;
+    /*The smaller the array of levels, the higher the priority of execution*/
+    rt_uint8_t level;
+    rt_list_t node;
+    char name[RT_NAME_MAX];
+    void* data;
+};
+
+struct rt_serial_bypass_head
+{
+    rt_list_t head;
+    struct rt_spinlock spinlock;
+};
+
+struct rt_serial_bypass {
+    struct rt_work work;
+
+    struct rt_spinlock spinlock;
+    struct rt_workqueue* lower_workq;
+    struct rt_serial_bypass_head* upper_h;
+    struct rt_serial_bypass_head* lower_h;
+    rt_mutex_t  mutex;
+    struct rt_ringbuffer* pipe;
+};
+
+int serial_bypass_list(int argc, char** argv);
+
+void rt_bypass_work_straight(struct rt_serial_device* serial);
+void rt_bypass_putchar(struct rt_serial_device* serial, rt_uint8_t ch);
+rt_size_t rt_bypass_getchar(struct rt_serial_device* serial, rt_uint8_t* ch);
+
+rt_err_t rt_bypass_upper_unregister(struct rt_serial_device* serial, rt_uint8_t level);
+rt_err_t rt_bypass_lower_unregister(struct rt_serial_device* serial, rt_uint8_t level);
+
+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);
+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);
+#endif
diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h
index c8ed3c04899..387fb475ab6 100644
--- a/components/drivers/include/rtdevice.h
+++ b/components/drivers/include/rtdevice.h
@@ -90,6 +90,9 @@ extern "C" {
 #include "drivers/dev_serial_v2.h"
 #else
 #include "drivers/dev_serial.h"
+#ifdef RT_USING_SERIAL_BYPASS
+#include "drivers/serial_bypass.h"
+#endif /* RT_USING_SERIAL_BYPASS */
 #endif
 #endif /* RT_USING_SERIAL */
 
diff --git a/components/drivers/serial/Kconfig b/components/drivers/serial/Kconfig
index 00fcfb64610..349aaeab2f2 100644
--- a/components/drivers/serial/Kconfig
+++ b/components/drivers/serial/Kconfig
@@ -21,4 +21,7 @@ menuconfig RT_USING_SERIAL
             int "Set RX buffer size"
             depends on !RT_USING_SERIAL_V2
             default 64
-    endif
+        config RT_USING_SERIAL_BYPASS
+            bool "Using serial bypass"
+            default n
+        endif
diff --git a/components/drivers/serial/SConscript b/components/drivers/serial/SConscript
index ce9d2216431..04fa37ed44d 100644
--- a/components/drivers/serial/SConscript
+++ b/components/drivers/serial/SConscript
@@ -16,6 +16,9 @@ if GetDepend(['RT_USING_SERIAL_V2']):
 else:
     src += ['dev_serial.c']
 
+if GetDepend(['RT_USING_SERIAL_BYPASS']):
+    src += ['bypass.c']
+
 if GetDepend(['RT_USING_DM']):
     src += ['serial_dm.c']
 
diff --git a/components/drivers/serial/bypass.c b/components/drivers/serial/bypass.c
new file mode 100644
index 00000000000..04ed71a7246
--- /dev/null
+++ b/components/drivers/serial/bypass.c
@@ -0,0 +1,355 @@
+/*
+ * 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));
+    serial->bypass->pipe = rt_ringbuffer_create(serial->config.bufsz);
+    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: */
+    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;
+    }
+
+    /* 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)
diff --git a/components/drivers/serial/dev_serial.c b/components/drivers/serial/dev_serial.c
index 19043e2ad22..458a5b736ce 100644
--- a/components/drivers/serial/dev_serial.c
+++ b/components/drivers/serial/dev_serial.c
@@ -27,6 +27,7 @@
  * 2020-12-14     Meco Man     implement function of setting window's size(TIOCSWINSZ)
  * 2021-08-22     Meco Man     implement function of getting window's size(TIOCGWINSZ)
  * 2023-09-15     xqyjlj       perf rt_hw_interrupt_disable/enable
+ * 2024-11-25     zhujiale     add bypass mode
  */
 
 #include <rthw.h>
@@ -303,6 +304,23 @@ rt_inline int _serial_int_rx(struct rt_serial_device *serial, rt_uint8_t *data,
     rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx;
     RT_ASSERT(rx_fifo != RT_NULL);
 
+#ifdef RT_USING_SERIAL_BYPASS
+    if (serial->bypass)
+    {
+        rt_bypass_work_straight(serial);
+        while (length)
+        {
+            rt_uint8_t ch;
+            if (!rt_bypass_getchar(serial, &ch))
+                break;
+
+            *data = ch & 0xff;
+            data++; length--;
+        }
+
+        return size - length;
+    }
+#endif
     /* read from software FIFO */
     while (length)
     {
@@ -1413,10 +1431,31 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
                 ch = serial->ops->getc(serial);
                 if (ch == -1) break;
 
-
                 /* disable interrupt */
-                level = rt_spin_lock_irqsave(&(serial->spinlock));
+#ifdef RT_USING_SERIAL_BYPASS
+                if (serial->bypass && serial->bypass->upper_h && (serial->bypass->upper_h->head.next != &serial->bypass->upper_h->head))
+                {
+                    rt_bool_t skip = RT_FALSE;
+                    char buf = (char)ch;
+                    int ret;
+                    rt_list_t* node = serial->bypass->upper_h->head.next;
+                    do {
+                        struct rt_serial_bypass_func* bypass_run = rt_container_of(node, struct rt_serial_bypass_func, node);
+                        ret = bypass_run->bypass(serial, buf, bypass_run->data);
+                        if (!ret)
+                        {
+                            skip = RT_TRUE;
+                            break;
+                        }
+                        node = node->next;
+                    } while (node != &serial->bypass->upper_h->head);
 
+                    if (skip)
+                        continue;
+                }
+
+#endif
+                level = rt_spin_lock_irqsave(&(serial->spinlock));
                 rx_fifo->buffer[rx_fifo->put_index] = ch;
                 rx_fifo->put_index += 1;
                 if (rx_fifo->put_index >= serial->config.bufsz) rx_fifo->put_index = 0;
@@ -1435,17 +1474,12 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
                 rt_spin_unlock_irqrestore(&(serial->spinlock), level);
             }
 
-            /**
-             * Invoke callback.
-             * First try notify if any, and if notify is existed, rx_indicate()
-             * is not callback. This separate the priority and makes the reuse
-             * of same serial device reasonable for RT console.
-             */
-            if (serial->rx_notify.notify)
-            {
-                serial->rx_notify.notify(serial->rx_notify.dev);
-            }
-            else if (serial->parent.rx_indicate != RT_NULL)
+#ifdef RT_USING_SERIAL_BYPASS
+            if (serial->bypass && serial->bypass->lower_h)
+                rt_workqueue_dowork(serial->bypass->lower_workq, &serial->bypass->work);
+#endif
+
+            if (serial->parent.rx_indicate != RT_NULL)
             {
                 rt_size_t rx_length;
 
diff --git a/components/drivers/serial/serial_tty.c b/components/drivers/serial/serial_tty.c
index bbf61f8ae06..dae668a2ef8 100644
--- a/components/drivers/serial/serial_tty.c
+++ b/components/drivers/serial/serial_tty.c
@@ -114,59 +114,24 @@ static void _setup_debug_rxind_hook(void)
 
 #endif /* LWP_DEBUG_INIT */
 
-static void _tty_rx_notify(struct rt_device *device)
+static rt_err_t _serial_ty_bypass(struct rt_serial_device* serial, char ch,void *data)
 {
     lwp_tty_t tp;
-    struct serial_tty_context *softc;
-
-    tp = rt_container_of(device, struct lwp_tty, parent);
-    RT_ASSERT(tp);
-
-    softc = tty_softc(tp);
-
-    if (_ttyworkq)
-        rt_workqueue_submit_work(_ttyworkq, &softc->work, 0);
-}
-
-static void _tty_rx_worker(struct rt_work *work, void *data)
-{
-    char input;
-    rt_ssize_t readbytes;
-    lwp_tty_t tp = data;
-    struct serial_tty_context *softc;
-    struct rt_serial_device *serial;
+    tp = (lwp_tty_t)data;
 
     tty_lock(tp);
-
-    while (1)
-    {
-        softc = tty_softc(tp);
-        serial = softc->parent;
-        readbytes = rt_device_read(&serial->parent, -1, &input, 1);
-        if (readbytes != 1)
-        {
-            break;
-        }
-
-        ttydisc_rint(tp, input, 0);
-    }
-
+    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,
+rt_inline void _setup_serial(struct rt_serial_device* serial, lwp_tty_t tp,
                              struct serial_tty_context *softc)
 {
-    struct rt_device_notify notify;
-
-    softc->backup_notify = serial->rx_notify;
-    notify.dev = &tp->parent;
-    notify.notify = _tty_rx_notify;
-
-    rt_device_init(&serial->parent);
-
-    rt_device_control(&serial->parent, RT_DEVICE_CTRL_NOTIFY_SET, &notify);
+    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,
@@ -345,7 +310,6 @@ rt_err_t rt_hw_serial_register_tty(struct rt_serial_device *serial)
             {
                 _serial_tty_set_speed(tty);
                 rc = lwp_tty_register(tty, dev_name);
-                rt_work_init(&softc->work, _tty_rx_worker, tty);
 
                 if (rc != RT_EOK)
                 {
diff --git a/components/lwp/terminal/Kconfig b/components/lwp/terminal/Kconfig
index 7fd77e75055..a62df007538 100644
--- a/components/lwp/terminal/Kconfig
+++ b/components/lwp/terminal/Kconfig
@@ -2,6 +2,7 @@ menuconfig LWP_USING_TERMINAL
     bool "Terminal I/O Subsystem"
     depends on RT_USING_SMART
     default y
+    select RT_USING_SERIAL_BYPASS
 
 if LWP_USING_TERMINAL
     config LWP_PTY_MAX_PARIS_LIMIT
diff --git a/examples/utest/testcases/Kconfig b/examples/utest/testcases/Kconfig
index d28c0e9600f..4f66474c705 100644
--- a/examples/utest/testcases/Kconfig
+++ b/examples/utest/testcases/Kconfig
@@ -11,6 +11,7 @@ rsource "utest/Kconfig"
 rsource "kernel/Kconfig"
 rsource "cpp11/Kconfig"
 rsource "drivers/serial_v2/Kconfig"
+rsource "drivers/serial_bypass/Kconfig"
 rsource "drivers/ipc/Kconfig"
 rsource "posix/Kconfig"
 rsource "mm/Kconfig"
diff --git a/examples/utest/testcases/drivers/serial_bypass/Kconfig b/examples/utest/testcases/drivers/serial_bypass/Kconfig
new file mode 100644
index 00000000000..149a2a9d95c
--- /dev/null
+++ b/examples/utest/testcases/drivers/serial_bypass/Kconfig
@@ -0,0 +1,7 @@
+menu "Serial-Bypass Testcase"
+
+config UTEST_SERIAL_BYPASS
+    bool "Serial testcase"
+    default n
+
+endmenu
diff --git a/examples/utest/testcases/drivers/serial_bypass/SConscript b/examples/utest/testcases/drivers/serial_bypass/SConscript
new file mode 100644
index 00000000000..86be64011bf
--- /dev/null
+++ b/examples/utest/testcases/drivers/serial_bypass/SConscript
@@ -0,0 +1,11 @@
+Import('rtconfig')
+from building import *
+
+cwd     = GetCurrentDir()
+src     = Glob('bypass*.c')
+
+CPPPATH = [cwd]
+
+group = DefineGroup('utestcases', src, depend = ['UTEST_SERIAL_BYPASS'], CPPPATH = CPPPATH)
+
+Return('group')
diff --git a/examples/utest/testcases/drivers/serial_bypass/bypass_conflict.c b/examples/utest/testcases/drivers/serial_bypass/bypass_conflict.c
new file mode 100644
index 00000000000..175a45a108d
--- /dev/null
+++ b/examples/utest/testcases/drivers/serial_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, "testcase.bypass.conflict.001", utest_tc_init, utest_tc_cleanup, 10);
diff --git a/examples/utest/testcases/drivers/serial_bypass/bypass_lower_run.c b/examples/utest/testcases/drivers/serial_bypass/bypass_lower_run.c
new file mode 100644
index 00000000000..5cfb3cc197a
--- /dev/null
+++ b/examples/utest/testcases/drivers/serial_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, "testcase.bypass.lower.001", utest_tc_init, utest_tc_cleanup, 10);
diff --git a/examples/utest/testcases/drivers/serial_bypass/bypass_register.c b/examples/utest/testcases/drivers/serial_bypass/bypass_register.c
new file mode 100644
index 00000000000..df4e07b9aa2
--- /dev/null
+++ b/examples/utest/testcases/drivers/serial_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, "testcase.bypass.register.001", utest_tc_init, utest_tc_cleanup, 10);
diff --git a/examples/utest/testcases/drivers/serial_bypass/bypass_upper_run.c b/examples/utest/testcases/drivers/serial_bypass/bypass_upper_run.c
new file mode 100644
index 00000000000..c5c14996875
--- /dev/null
+++ b/examples/utest/testcases/drivers/serial_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, "testcase.bypass.upper.001", utest_tc_init, utest_tc_cleanup, 10);