原始版本

RT_Thread/components/drivers/serial/Kconfig

@@ -0,0 +1,27 @@
+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
+            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
+        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

RT_Thread/components/drivers/serial/SConscript

@@ -0,0 +1,27 @@
+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)
+
+Return('group')

RT_Thread/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)

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;
+}

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);