Merge remote-tracking branch 'remotes/gitee/master'

15 files changed, 1438 insertions, 169 deletions

diff --git a/components/drivers/Kconfig b/components/drivers/Kconfig
index b0caabc73c..d3fd14b52d 100755
--- a/components/drivers/Kconfig
+++ b/components/drivers/Kconfig
@@ -24,22 +24,30 @@ if RT_USING_DEVICE_IPC
     endif
 endif
 
-config RT_USING_SERIAL
-    bool "Using serial device drivers"
+menuconfig RT_USING_SERIAL
+    bool "USING Serial device drivers"
     select RT_USING_DEVICE_IPC
     select RT_USING_DEVICE
     default y
 
-if RT_USING_SERIAL
-    config RT_SERIAL_USING_DMA
-        bool "Enable serial DMA mode"
-        default y
-
-    config RT_SERIAL_RB_BUFSZ
-        int "Set RX buffer size"
-        default 64
+    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
 
-endif
+        config RT_SERIAL_RB_BUFSZ
+            int "Set RX buffer size"
+            depends on !RT_USING_SERIAL_V2
+            default 64
+    endif
 
 config RT_USING_CAN
     bool "Using CAN device drivers"
@@ -153,20 +161,6 @@ config RT_USING_RTC
         config RT_USING_SOFT_RTC
             bool "Using software simulation RTC device"
             default n
-
-        config RTC_SYNC_USING_NTP
-            bool "Using NTP auto sync RTC time"
-            depends on PKG_NETUTILS_NTP
-            default y
-
-            if RTC_SYNC_USING_NTP
-                config RTC_NTP_FIRST_SYNC_DELAY
-                    int "NTP first sync delay time(second) for network connect"
-                    default 30
-                config RTC_NTP_SYNC_PERIOD
-                    int "NTP auto sync period(second)"
-                    default 3600
-           endif
     endif
 
 config RT_USING_SDIO
diff --git a/components/drivers/cputime/cputime.c b/components/drivers/cputime/cputime.c
index 4a9eee3a71..750733f366 100644
--- a/components/drivers/cputime/cputime.c
+++ b/components/drivers/cputime/cputime.c
@@ -10,6 +10,7 @@
 
 #include <rtdevice.h>
 #include <rtthread.h>
+#include <sys/errno.h>
 
 static const struct rt_clock_cputime_ops *_cputime_ops  = RT_NULL;
 
@@ -24,7 +25,7 @@ float clock_cpu_getres(void)
     if (_cputime_ops)
         return _cputime_ops->cputime_getres();
 
-    rt_set_errno(-ENOSYS);
+    rt_set_errno(ENOSYS);
     return 0;
 }
 
@@ -38,7 +39,7 @@ uint32_t clock_cpu_gettime(void)
     if (_cputime_ops)
         return _cputime_ops->cputime_gettime();
 
-    rt_set_errno(-ENOSYS);
+    rt_set_errno(ENOSYS);
     return 0;
 }
 
diff --git a/components/drivers/include/drivers/rtc.h b/components/drivers/include/drivers/rtc.h
index 3a318357da..9eddf801b7 100644
--- a/components/drivers/include/drivers/rtc.h
+++ b/components/drivers/include/drivers/rtc.h
@@ -17,7 +17,4 @@
 rt_err_t set_date(rt_uint32_t year, rt_uint32_t month, rt_uint32_t day);
 rt_err_t set_time(rt_uint32_t hour, rt_uint32_t minute, rt_uint32_t second);
 
-int rt_soft_rtc_init(void);
-int rt_rtc_ntp_sync_init(void);
-
 #endif /* __RTC_H__ */
diff --git a/components/drivers/include/drivers/serial_v2.h b/components/drivers/include/drivers/serial_v2.h
new file mode 100644
index 0000000000..3ba46bdcdd
--- /dev/null
+++ b/components/drivers/include/drivers/serial_v2.h
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author           Notes
+ * 2021-06-01     KyleChan     first version
+ */
+
+#ifndef __SERIAL_V2_H__
+#define __SERIAL_V2_H__
+
+#include <rtthread.h>
+
+#define BAUD_RATE_2400                  2400
+#define BAUD_RATE_4800                  4800
+#define BAUD_RATE_9600                  9600
+#define BAUD_RATE_19200                 19200
+#define BAUD_RATE_38400                 38400
+#define BAUD_RATE_57600                 57600
+#define BAUD_RATE_115200                115200
+#define BAUD_RATE_230400                230400
+#define BAUD_RATE_460800                460800
+#define BAUD_RATE_921600                921600
+#define BAUD_RATE_2000000               2000000
+#define BAUD_RATE_3000000               3000000
+
+#define DATA_BITS_5                     5
+#define DATA_BITS_6                     6
+#define DATA_BITS_7                     7
+#define DATA_BITS_8                     8
+#define DATA_BITS_9                     9
+
+#define STOP_BITS_1                     0
+#define STOP_BITS_2                     1
+#define STOP_BITS_3                     2
+#define STOP_BITS_4                     3
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#define PARITY_NONE                     0
+#define PARITY_ODD                      1
+#define PARITY_EVEN                     2
+#endif
+
+#define BIT_ORDER_LSB                   0
+#define BIT_ORDER_MSB                   1
+
+#define NRZ_NORMAL                      0       /* Non Return to Zero : normal mode */
+#define NRZ_INVERTED                    1       /* Non Return to Zero : inverted mode */
+
+#define RT_DEVICE_FLAG_RX_BLOCKING      0x1000
+#define RT_DEVICE_FLAG_RX_NON_BLOCKING  0x2000
+
+#define RT_DEVICE_FLAG_TX_BLOCKING      0x4000
+#define RT_DEVICE_FLAG_TX_NON_BLOCKING  0x8000
+
+#define RT_SERIAL_RX_BLOCKING           RT_DEVICE_FLAG_RX_BLOCKING
+#define RT_SERIAL_RX_NON_BLOCKING       RT_DEVICE_FLAG_RX_NON_BLOCKING
+#define RT_SERIAL_TX_BLOCKING           RT_DEVICE_FLAG_TX_BLOCKING
+#define RT_SERIAL_TX_NON_BLOCKING       RT_DEVICE_FLAG_TX_NON_BLOCKING
+
+#define RT_DEVICE_CHECK_OPTMODE         0x20
+
+#define RT_SERIAL_EVENT_RX_IND          0x01    /* Rx indication */
+#define RT_SERIAL_EVENT_TX_DONE         0x02    /* Tx complete   */
+#define RT_SERIAL_EVENT_RX_DMADONE      0x03    /* Rx DMA transfer done */
+#define RT_SERIAL_EVENT_TX_DMADONE      0x04    /* Tx DMA transfer done */
+#define RT_SERIAL_EVENT_RX_TIMEOUT      0x05    /* Rx timeout    */
+
+#define RT_SERIAL_ERR_OVERRUN           0x01
+#define RT_SERIAL_ERR_FRAMING           0x02
+#define RT_SERIAL_ERR_PARITY            0x03
+
+#define RT_SERIAL_TX_DATAQUEUE_SIZE     2048
+#define RT_SERIAL_TX_DATAQUEUE_LWM      30
+
+#define RT_SERIAL_RX_MINBUFSZ 64
+#define RT_SERIAL_TX_MINBUFSZ 64
+
+#define RT_SERIAL_TX_BLOCKING_BUFFER       1
+#define RT_SERIAL_TX_BLOCKING_NO_BUFFER    0
+
+/* Default config for serial_configure structure */
+#define RT_SERIAL_CONFIG_DEFAULT              \
+{                                             \
+    BAUD_RATE_115200,    /* 115200 bits/s */  \
+    DATA_BITS_8,         /* 8 databits */     \
+    STOP_BITS_1,         /* 1 stopbit */      \
+    PARITY_NONE,         /* No parity  */     \
+    BIT_ORDER_LSB,       /* LSB first sent */ \
+    NRZ_NORMAL,          /* Normal mode */    \
+    RT_SERIAL_RX_MINBUFSZ, /* rxBuf size */   \
+    RT_SERIAL_TX_MINBUFSZ, /* txBuf size */   \
+    0                                         \
+}
+
+struct serial_configure
+{
+    rt_uint32_t baud_rate;
+
+    rt_uint32_t data_bits               :4;
+    rt_uint32_t stop_bits               :2;
+    rt_uint32_t parity                  :2;
+    rt_uint32_t bit_order               :1;
+    rt_uint32_t invert                  :1;
+    rt_uint32_t rx_bufsz                :16;
+    rt_uint32_t tx_bufsz                :16;
+    rt_uint32_t reserved                :6;
+};
+
+/*
+ * Serial Receive FIFO mode
+ */
+struct rt_serial_rx_fifo
+{
+    struct rt_ringbuffer rb;
+
+    struct rt_completion rx_cpt;
+
+    rt_uint16_t rx_cpt_index;
+
+    /* software fifo */
+    rt_uint8_t buffer[];
+};
+
+/*
+ * Serial Transmit FIFO mode
+ */
+struct rt_serial_tx_fifo
+{
+    struct rt_ringbuffer rb;
+
+    rt_size_t put_size;
+
+    rt_bool_t activated;
+
+    struct rt_completion tx_cpt;
+
+    /* software fifo */
+    rt_uint8_t buffer[];
+};
+
+struct rt_serial_device
+{
+    struct rt_device          parent;
+
+    const struct rt_uart_ops *ops;
+    struct serial_configure   config;
+
+    void *serial_rx;
+    void *serial_tx;
+};
+
+/**
+ * uart operators
+ */
+struct rt_uart_ops
+{
+    rt_err_t (*configure)(struct rt_serial_device       *serial,
+                          struct serial_configure       *cfg);
+
+    rt_err_t (*control)(struct rt_serial_device         *serial,
+                                            int          cmd,
+                                            void        *arg);
+
+    int (*putc)(struct rt_serial_device *serial, char c);
+    int (*getc)(struct rt_serial_device *serial);
+
+    rt_size_t (*transmit)(struct rt_serial_device       *serial,
+                                 rt_uint8_t             *buf,
+                                 rt_size_t               size,
+                                 rt_uint32_t             tx_flag);
+};
+
+void rt_hw_serial_isr(struct rt_serial_device *serial, int event);
+
+rt_err_t rt_hw_serial_register(struct rt_serial_device      *serial,
+                               const  char                  *name,
+                                      rt_uint32_t            flag,
+                                      void                  *data);
+
+#endif
diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h
index fbd3c9e7b2..07a2be361e 100644
--- a/components/drivers/include/rtdevice.h
+++ b/components/drivers/include/rtdevice.h
@@ -57,7 +57,11 @@ extern "C" {
 #endif /* RT_USING_USB_HOST */
 
 #ifdef RT_USING_SERIAL
+#ifdef RT_USING_SERIAL_V2
+#include "drivers/serial_v2.h"
+#else
 #include "drivers/serial.h"
+#endif
 #endif /* RT_USING_SERIAL */
 
 #ifdef RT_USING_I2C
diff --git a/components/drivers/pm/pm.c b/components/drivers/pm/pm.c
index 80ed101498..cf488a9ce1 100644
--- a/components/drivers/pm/pm.c
+++ b/components/drivers/pm/pm.c
@@ -836,12 +836,10 @@ rt_uint32_t rt_pm_module_get_status(void)
     rt_uint32_t req_status = 0x00;
     pm = &_pm;
 
-    for (index = 0; index < 32; index ++)
+    for (index = 0; index < PM_MODULE_MAX_ID; index ++)
     {
         if (pm->module_status[index].req_status == 0x01)
             req_status |= 1<<index;
-        if (index >= PM_MODULE_MAX_ID)
-            break;
     }
 
     return req_status;
diff --git a/components/drivers/rtc/README.md b/components/drivers/rtc/README.md
index 23010cf4b7..dff71f9d67 100644
--- a/components/drivers/rtc/README.md
+++ b/components/drivers/rtc/README.md
@@ -55,26 +55,11 @@ msh />date 2018 02 16 01 15 30    # 设置当前时间为 2018-02-16 01:15:30
 msh />
 ```
 
-### 2.4 启用 NTP 时间自动同步
-
-如果 RT-Thread 已接入互联网，可启用 NTP 时间自动同步功能，定期同步本地时间。
-
-在 menuconfig 中启用 `RTC_SYNC_USING_NTP` 配置。启用该功能后，会自动开启 [netutils package](https://github.com/RT-Thread-packages/netutils) 的 NTP 功能。同时务必确保 RT-Thread 网络访问正常。
-
-启用该配置后，还有两个配置是用户可选配置：
-
-- `RTC_NTP_FIRST_SYNC_DELAY`: 首次执行 NTP 时间同步的延时。延时的目的在于，给网络连接预留一定的时间，尽量提高第一次执行 NTP 时间同步时的成功率。默认时间为 30S；
-- `RTC_NTP_SYNC_PERIOD`: NTP 自动同步周期，单位为秒，默认一小时（即 3600S）同步一次。
-
-> 注意：如果没有使用组件自动初始化功能，则需手动调用 `int rt_rtc_ntp_sync_init(void)` ，完成该功能初始化。
-
-### 2.5 启用 Soft RTC （软件模拟 RTC）
+### 2.4 启用 Soft RTC （软件模拟 RTC）
 
 这个模式非常适用于对时间精度要求不高，没有硬件 RTC 的产品。
 
-#### 2.5.1 使用方法
+#### 2.4.1 使用方法
 
 在 menuconfig 中启用 `RT_USING_SOFT_RTC` 配置。
 
-> 注意：如果没有使用组件自动初始化功能，则需手动调用 `int rt_soft_rtc_init(void)` ，完成该功能初始化。
-
diff --git a/components/drivers/rtc/SConscript b/components/drivers/rtc/SConscript
index b922db70c2..c3252fe7f9 100644
--- a/components/drivers/rtc/SConscript
+++ b/components/drivers/rtc/SConscript
@@ -3,22 +3,16 @@ from building import *
 cwd = GetCurrentDir()
 src = [] 
 
-rtc = ['rtc.c']
-
-rtc_alarm = ['alarm.c']
-
-soft_rtc = ['soft_rtc.c']
-
 CPPPATH = [cwd + '/../include']
 group = []
 
 if GetDepend(['RT_USING_RTC']):
     src = src + ['rtc.c', 'rtc_core.c']
     if GetDepend(['RT_USING_ALARM']): 
-        src = src + rtc_alarm
+        src = src + ['alarm.c']
     if GetDepend(['RT_USING_SOFT_RTC']): 
-        src = src + soft_rtc
+        src = src + ['soft_rtc.c']
 
 group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_RTC'], CPPPATH = CPPPATH)
 
-Return('group')
+Return('group')
\ No newline at end of file
diff --git a/components/drivers/rtc/rtc.c b/components/drivers/rtc/rtc.c
index 2b9397da90..3a843e2e0c 100644
--- a/components/drivers/rtc/rtc.c
+++ b/components/drivers/rtc/rtc.c
@@ -9,26 +9,18 @@
  * 2012-04-12     aozima       optimization: find rtc device only first.
  * 2012-04-16     aozima       add scheduler lock for set_date and set_time.
  * 2018-02-16     armink       add auto sync time by NTP
+ * 2021-05-09     Meco Man     remove NTP
  */
 
-#include <sys/time.h>
+#include <time.h>
 #include <string.h>
+#include <stdlib.h>
 #include <rtthread.h>
 #include <drivers/rtc.h>
 
 #ifdef RT_USING_RTC
 
-/* Using NTP auto sync RTC time */
-#ifdef RTC_SYNC_USING_NTP
-/* NTP first sync delay time for network connect, unit: second */
-#ifndef RTC_NTP_FIRST_SYNC_DELAY
-#define RTC_NTP_FIRST_SYNC_DELAY                 (30)
-#endif
-/* NTP sync period, unit: second */
-#ifndef RTC_NTP_SYNC_PERIOD
-#define RTC_NTP_SYNC_PERIOD                      (1L*60L*60L)
-#endif
-#endif /* RTC_SYNC_USING_NTP */
+
 
 /**
  * Set system date(time not modify, local timezone).
@@ -130,67 +122,8 @@ rt_err_t set_time(rt_uint32_t hour, rt_uint32_t minute, rt_uint32_t second)
     return ret;
 }
 
-#ifdef RTC_SYNC_USING_NTP
-static void ntp_sync_thread_enrty(void *param)
-{
-    extern time_t ntp_sync_to_rtc(const char *host_name);
-    /* first sync delay for network connect */
-    rt_thread_delay(RTC_NTP_FIRST_SYNC_DELAY * RT_TICK_PER_SECOND);
-
-    while (1)
-    {
-        ntp_sync_to_rtc(NULL);
-        rt_thread_delay(RTC_NTP_SYNC_PERIOD * RT_TICK_PER_SECOND);
-    }
-}
-
-int rt_rtc_ntp_sync_init(void)
-{
-    static rt_bool_t init_ok = RT_FALSE;
-    rt_thread_t thread;
-
-    if (init_ok)
-    {
-        return 0;
-    }
-
-    thread = rt_thread_create("ntp_sync", ntp_sync_thread_enrty, RT_NULL, 1536, 26, 2);
-    if (thread)
-    {
-        rt_thread_startup(thread);
-    }
-    else
-    {
-        return -RT_ENOMEM;
-    }
-
-    init_ok = RT_TRUE;
-
-    return RT_EOK;
-}
-INIT_COMPONENT_EXPORT(rt_rtc_ntp_sync_init);
-#endif /* RTC_SYNC_USING_NTP */
-
-#ifdef RT_USING_FINSH
+#ifdef FINSH_USING_MSH
 #include <finsh.h>
-#include <rtdevice.h>
-
-/**
- * show date and time (local timezone)
- */
-void list_date(void)
-{
-    time_t now;
-
-    now = time(RT_NULL);
-    rt_kprintf("%.*s\n", 25, ctime(&now));
-}
-FINSH_FUNCTION_EXPORT(list_date, show date and time (local timezone))
-FINSH_FUNCTION_EXPORT(set_date, set date(local timezone) e.g: set_date(2010,2,28))
-FINSH_FUNCTION_EXPORT(set_time, set time(local timezone) e.g: set_time(23,59,59))
-
-
-#if defined(RT_USING_FINSH) && defined(FINSH_USING_MSH)
 /**
  * get date and time or set (local timezone) [year month day hour min sec]
  */
@@ -253,9 +186,7 @@ static void date(uint8_t argc, char **argv)
         rt_kprintf("e.g: date 2018 01 01 23 59 59 or date\n");
     }
 }
-MSH_CMD_EXPORT(list_date, show date and time (local timezone))
 MSH_CMD_EXPORT(date, get date and time or set (local timezone) [year month day hour min sec])
+#endif /* FINSH_USING_MSH */
 
-#endif /* defined(RT_USING_FINSH) && defined(FINSH_USING_MSH) */
-#endif /* RT_USING_FINSH */
 #endif /* RT_USING_RTC */
diff --git a/components/drivers/rtc/soft_rtc.c b/components/drivers/rtc/soft_rtc.c
index 9e1b7c35fd..255579f35e 100644
--- a/components/drivers/rtc/soft_rtc.c
+++ b/components/drivers/rtc/soft_rtc.c
@@ -104,7 +104,7 @@ const static struct rt_device_ops soft_rtc_ops =
 };
 #endif
 
-int rt_soft_rtc_init(void)
+static int rt_soft_rtc_init(void)
 {
     static rt_bool_t init_ok = RT_FALSE;
     struct tm time_new = SOFT_RTC_TIME_DEFAULT;
diff --git a/components/drivers/serial/SConscript b/components/drivers/serial/SConscript
index a6eb115919..81d791803a 100644
--- a/components/drivers/serial/SConscript
+++ b/components/drivers/serial/SConscript
@@ -1,8 +1,14 @@
 from building import *
 
-cwd     = GetCurrentDir()
-src	= Glob('*.c')
+cwd = GetCurrentDir()
 CPPPATH = [cwd + '/../include']
-group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_SERIAL'], CPPPATH = CPPPATH)
+group = []
+if GetDepend(['RT_USING_SERIAL']):
+    if GetDepend(['RT_USING_SERIAL_V2']):
+        src = Glob('serial_v2.c')
+        group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_SERIAL_V2'], CPPPATH = CPPPATH)
+    else:
+        src = Glob('serial.c')
+        group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_SERIAL'], CPPPATH = CPPPATH)
 
 Return('group')
diff --git a/components/drivers/serial/serial.c b/components/drivers/serial/serial.c
index 2736ceed66..76298ea153 100644
--- a/components/drivers/serial/serial.c
+++ b/components/drivers/serial/serial.c
@@ -38,6 +38,7 @@
 #ifdef RT_USING_POSIX
 #include <dfs_posix.h>
 #include <dfs_poll.h>
+#include <sys/ioctl.h>
 
 #ifdef RT_USING_POSIX_TERMIOS
 #include <posix_termios.h>
@@ -954,9 +955,7 @@ static void _tc_flush(struct rt_serial_device *serial, int queue)
             {
                 RT_ASSERT(RT_NULL != rx_fifo);
                 level = rt_hw_interrupt_disable();
-                rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
-                rx_fifo->put_index = 0;
-                rx_fifo->get_index = 0;
+                rx_fifo->get_index = rx_fifo->put_index;
                 rx_fifo->is_full = RT_FALSE;
                 rt_hw_interrupt_enable(level);
             }
diff --git a/components/drivers/serial/serial_v2.c b/components/drivers/serial/serial_v2.c
new file mode 100644
index 0000000000..d6ae508cab
--- /dev/null
+++ b/components/drivers/serial/serial_v2.c
@@ -0,0 +1,1188 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-01     KyleChan     first version
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define DBG_TAG    "UART"
+#define DBG_LVL    DBG_INFO
+#include <rtdbg.h>
+
+#ifdef RT_USING_POSIX
+#include <dfs_posix.h>
+#include <dfs_poll.h>
+
+#ifdef getc
+#undef getc
+#endif
+
+#ifdef putc
+#undef putc
+#endif
+
+static rt_err_t serial_fops_rx_ind(rt_device_t dev, rt_size_t size)
+{
+    rt_wqueue_wakeup(&(dev->wait_queue), (void*)POLLIN);
+
+    return RT_EOK;
+}
+
+/* fops for serial */
+static int serial_fops_open(struct dfs_fd *fd)
+{
+    rt_err_t ret = 0;
+    rt_uint16_t flags = 0;
+    rt_device_t device;
+
+    device = (rt_device_t)fd->data;
+    RT_ASSERT(device != RT_NULL);
+
+    switch (fd->flags & O_ACCMODE)
+    {
+    case O_RDONLY:
+        LOG_D("fops open: O_RDONLY!");
+        flags = RT_DEVICE_FLAG_RDONLY;
+        break;
+    case O_WRONLY:
+        LOG_D("fops open: O_WRONLY!");
+        flags = RT_DEVICE_FLAG_WRONLY;
+        break;
+    case O_RDWR:
+        LOG_D("fops open: O_RDWR!");
+        flags = RT_DEVICE_FLAG_RDWR;
+        break;
+    default:
+        LOG_E("fops open: unknown mode - %d!", fd->flags & O_ACCMODE);
+        break;
+    }
+
+    if ((fd->flags & O_ACCMODE) != O_WRONLY)
+        rt_device_set_rx_indicate(device, serial_fops_rx_ind);
+    ret = rt_device_open(device, flags);
+    if (ret == RT_EOK) return 0;
+
+    return ret;
+}
+
+static int serial_fops_close(struct dfs_fd *fd)
+{
+    rt_device_t device;
+
+    device = (rt_device_t)fd->data;
+
+    rt_device_set_rx_indicate(device, RT_NULL);
+    rt_device_close(device);
+
+    return 0;
+}
+
+static int serial_fops_ioctl(struct dfs_fd *fd, int cmd, void *args)
+{
+    rt_device_t device;
+
+    device = (rt_device_t)fd->data;
+    switch (cmd)
+    {
+    case FIONREAD:
+        break;
+    case FIONWRITE:
+        break;
+    }
+
+    return rt_device_control(device, cmd, args);
+}
+
+static int serial_fops_read(struct dfs_fd *fd, void *buf, size_t count)
+{
+    int size = 0;
+    rt_device_t device;
+
+    device = (rt_device_t)fd->data;
+
+    do
+    {
+        size = rt_device_read(device, -1,  buf, count);
+        if (size <= 0)
+        {
+            if (fd->flags & O_NONBLOCK)
+            {
+                size = -EAGAIN;
+                break;
+            }
+
+            rt_wqueue_wait(&(device->wait_queue), 0, RT_WAITING_FOREVER);
+        }
+    }while (size <= 0);
+
+    return size;
+}
+
+static int serial_fops_write(struct dfs_fd *fd, const void *buf, size_t count)
+{
+    rt_device_t device;
+
+    device = (rt_device_t)fd->data;
+    return rt_device_write(device, -1, buf, count);
+}
+
+static int serial_fops_poll(struct dfs_fd *fd, struct rt_pollreq *req)
+{
+    int mask = 0;
+    int flags = 0;
+    rt_device_t device;
+    struct rt_serial_device *serial;
+
+    device = (rt_device_t)fd->data;
+    RT_ASSERT(device != RT_NULL);
+
+    serial = (struct rt_serial_device *)device;
+
+    /* only support POLLIN */
+    flags = fd->flags & O_ACCMODE;
+    if (flags == O_RDONLY || flags == O_RDWR)
+    {
+        rt_base_t level;
+        struct rt_serial_rx_fifo* rx_fifo;
+
+        rt_poll_add(&(device->wait_queue), req);
+
+        rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx;
+
+        level = rt_hw_interrupt_disable();
+
+        if (rt_ringbuffer_data_len(&rx_fifo->rb))
+            mask |= POLLIN;
+        rt_hw_interrupt_enable(level);
+    }
+    // mask|=POLLOUT;
+   return mask;
+}
+
+const static struct dfs_file_ops _serial_fops =
+{
+    serial_fops_open,
+    serial_fops_close,
+    serial_fops_ioctl,
+    serial_fops_read,
+    serial_fops_write,
+    RT_NULL, /* flush */
+    RT_NULL, /* lseek */
+    RT_NULL, /* getdents */
+    serial_fops_poll,
+};
+#endif
+
+static rt_size_t rt_serial_get_linear_buffer(struct rt_ringbuffer       *rb,
+                                                    rt_uint8_t         **ptr)
+{
+    rt_size_t size;
+
+    RT_ASSERT(rb != RT_NULL);
+
+    *ptr = RT_NULL;
+
+    /* whether has enough data  */
+    size = rt_ringbuffer_data_len(rb);
+
+    /* no data */
+    if (size == 0)
+        return 0;
+
+    *ptr = &rb->buffer_ptr[rb->read_index];
+
+    if(rb->buffer_size - rb->read_index > size)
+    {
+        return size;
+    }
+
+    return rb->buffer_size - rb->read_index;
+}
+
+static rt_size_t rt_serial_update_read_index(struct rt_ringbuffer    *rb,
+                                                    rt_uint16_t       read_index)
+{
+    rt_size_t size;
+
+    RT_ASSERT(rb != RT_NULL);
+
+    /* whether has enough data  */
+    size = rt_ringbuffer_data_len(rb);
+
+    /* no data */
+    if (size == 0)
+        return 0;
+
+    /* less data */
+    if(size < read_index)
+        read_index = size;
+
+    if(rb->buffer_size - rb->read_index > read_index)
+    {
+        rb->read_index += read_index;
+        return read_index;
+    }
+
+    read_index = rb->buffer_size - rb->read_index;
+
+    /* we are going into the other side of the mirror */
+    rb->read_mirror = ~rb->read_mirror;
+    rb->read_index = 0;
+
+    return read_index;
+}
+
+static rt_size_t rt_serial_update_write_index(struct rt_ringbuffer  *rb,
+                                                     rt_uint16_t     write_index)
+{
+    rt_uint16_t size;
+    RT_ASSERT(rb != RT_NULL);
+
+    /* whether has enough space */
+    size = rt_ringbuffer_space_len(rb);
+
+    /* no space */
+    if (size == 0)
+        return 0;
+
+    /* drop some data */
+    if (size < write_index)
+        write_index = size;
+
+    if (rb->buffer_size - rb->write_index > write_index)
+    {
+        /* this should not cause overflow because there is enough space for
+         * length of data in current mirror */
+        rb->write_index += write_index;
+        return write_index;
+    }
+
+    /* we are going into the other side of the mirror */
+    rb->write_mirror = ~rb->write_mirror;
+    rb->write_index = write_index - (rb->buffer_size - rb->write_index);
+
+    return write_index;
+}
+
+
+/**
+  * @brief Serial polling receive data routine, This function will receive data
+  *        in a continuous loop by one by one byte.
+  * @param dev The pointer of device driver structure
+  * @param pos Empty parameter.
+  * @param buffer Receive data buffer.
+  * @param size Receive data buffer length.
+  * @return Return the final length of data received.
+  */
+rt_size_t _serial_poll_rx(struct rt_device          *dev,
+                                 rt_off_t            pos,
+                                 void               *buffer,
+                                 rt_size_t           size)
+{
+    struct rt_serial_device *serial;
+    rt_size_t getc_size;
+    int getc_element;      /* Gets one byte of data received */
+    rt_uint8_t *getc_buffer;     /* Pointer to the receive data buffer */
+
+    RT_ASSERT(dev != RT_NULL);
+
+    serial = (struct rt_serial_device *)dev;
+    RT_ASSERT(serial != RT_NULL);
+    getc_buffer = (rt_uint8_t *)buffer;
+    getc_size = size;
+
+    while(size)
+    {
+        getc_element = serial->ops->getc(serial);
+        if (getc_element == -1) break;
+
+        *getc_buffer = getc_element;
+
+        ++ getc_buffer;
+        -- size;
+
+        if (serial->parent.open_flag & RT_DEVICE_FLAG_STREAM)
+        {
+            /* If open_flag satisfies RT_DEVICE_FLAG_STREAM
+             * and the received character is '\n', exit the loop directly */
+            if (getc_element == '\n') break;
+        }
+    }
+
+   return getc_size - size;
+}
+
+/**
+  * @brief Serial polling transmit data routines, This function will transmit
+  *        data in a continuous loop by one by one byte.
+  * @param dev The pointer of device driver structure
+  * @param pos Empty parameter.
+  * @param buffer Transmit data buffer.
+  * @param size Transmit data buffer length.
+  * @return Return the final length of data received.
+  */
+rt_size_t _serial_poll_tx(struct rt_device           *dev,
+                                 rt_off_t             pos,
+                                 const void          *buffer,
+                                 rt_size_t            size)
+{
+    struct rt_serial_device *serial;
+    rt_size_t putc_size;
+    rt_uint8_t *putc_buffer;    /* Pointer to the transmit data buffer */
+    RT_ASSERT(dev != RT_NULL);
+
+    serial = (struct rt_serial_device *)dev;
+    RT_ASSERT(serial != RT_NULL);
+
+    putc_buffer = (rt_uint8_t *)buffer;
+    putc_size = size;
+
+    while (size)
+    {
+        if (serial->parent.open_flag & RT_DEVICE_FLAG_STREAM)
+        {
+            /* If open_flag satisfies RT_DEVICE_FLAG_STREAM and the received character is '\n',
+             * inserts '\r' character before '\n' character for the effect of carriage return newline */
+            if (*putc_buffer == '\n')
+                serial->ops->putc(serial, '\r');
+        }
+        serial->ops->putc(serial, *putc_buffer);
+
+        ++ putc_buffer;
+        -- size;
+    }
+
+     return putc_size - size;
+}
+
+/**
+  * @brief Serial receive data routines, This function will receive
+  *        data by using fifo
+  * @param dev The pointer of device driver structure
+  * @param pos Empty parameter.
+  * @param buffer Receive data buffer.
+  * @param size Receive data buffer length.
+  * @return Return the final length of data received.
+  */
+static rt_size_t _serial_fifo_rx(struct rt_device        *dev,
+                                        rt_off_t          pos,
+                                        void             *buffer,
+                                        rt_size_t         size)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_rx_fifo *rx_fifo;
+    rt_base_t level;
+    rt_size_t recv_len;  /* The length of data from the ringbuffer */
+
+    RT_ASSERT(dev != RT_NULL);
+    if (size == 0) return 0;
+
+    serial = (struct rt_serial_device *)dev;
+
+    RT_ASSERT((serial != RT_NULL) && (buffer != RT_NULL));
+
+    rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
+
+    if (dev->open_flag & RT_SERIAL_RX_BLOCKING)
+    {
+        if (size > serial->config.rx_bufsz)
+        {
+            LOG_W("(%s) serial device received data:[%d] larger than "
+               "rx_bufsz:[%d], please increase the BSP_UARTx_RX_BUFSIZE option",
+                dev->parent.name, size, serial->config.rx_bufsz);
+
+            return 0;
+        }
+        /* Get the length of the data from the ringbuffer */
+        recv_len = rt_ringbuffer_data_len(&(rx_fifo->rb));
+
+        if (recv_len < size)
+        {
+            /* When recv_len is less than size, rx_cpt_index is updated to the size
+            * and rt_current_thread is suspend until rx_cpt_index is equal to 0 */
+            rx_fifo->rx_cpt_index = size;
+            rt_completion_wait(&(rx_fifo->rx_cpt), RT_WAITING_FOREVER);
+        }
+    }
+
+    /* This part of the code is open_flag as RT_SERIAL_RX_NON_BLOCKING */
+
+    level = rt_hw_interrupt_disable();
+    /* When open_flag is RT_SERIAL_RX_NON_BLOCKING,
+     * the data is retrieved directly from the ringbuffer and returned */
+    recv_len = rt_ringbuffer_get(&(rx_fifo->rb), buffer, size);
+
+    rt_hw_interrupt_enable(level);
+
+    return recv_len;
+}
+
+/**
+  * @brief Serial transmit data routines, This function will transmit
+  *        data by using blocking_nbuf.
+  * @param dev The pointer of device driver structure
+  * @param pos Empty parameter.
+  * @param buffer Transmit data buffer.
+  * @param size Transmit data buffer length.
+  * @return Return the final length of data transmit.
+  */
+static rt_size_t _serial_fifo_tx_blocking_nbuf(struct rt_device        *dev,
+                                                      rt_off_t          pos,
+                                                const void             *buffer,
+                                                      rt_size_t         size)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_tx_fifo *tx_fifo = RT_NULL;
+
+    RT_ASSERT(dev != RT_NULL);
+    if (size == 0) return 0;
+
+    serial = (struct rt_serial_device *)dev;
+    RT_ASSERT((serial != RT_NULL) && (buffer != RT_NULL));
+    tx_fifo = (struct rt_serial_tx_fifo *) serial->serial_tx;
+    RT_ASSERT(tx_fifo != RT_NULL);
+
+    /* When serial transmit in tx_blocking mode,
+     * if the activated mode is RT_TRUE, it will return directly */
+    if (tx_fifo->activated == RT_TRUE)  return 0;
+
+    tx_fifo->activated = RT_TRUE;
+    /* Call the transmit interface for transmission */
+    serial->ops->transmit(serial,
+                          (rt_uint8_t *)buffer,
+                          size,
+                          RT_SERIAL_TX_BLOCKING);
+    /* Waiting for the transmission to complete */
+    rt_completion_wait(&(tx_fifo->tx_cpt), RT_WAITING_FOREVER);
+
+    return size;
+}
+
+/**
+  * @brief Serial transmit data routines, This function will transmit
+  *        data by using blocking_buf.
+  * @param dev The pointer of device driver structure
+  * @param pos Empty parameter.
+  * @param buffer Transmit data buffer.
+  * @param size Transmit data buffer length.
+  * @return Return the final length of data transmit.
+  */
+static rt_size_t _serial_fifo_tx_blocking_buf(struct rt_device        *dev,
+                                                     rt_off_t          pos,
+                                               const void             *buffer,
+                                                    rt_size_t          size)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_tx_fifo *tx_fifo = RT_NULL;
+
+    RT_ASSERT(dev != RT_NULL);
+    if (size == 0) return 0;
+
+    serial = (struct rt_serial_device *)dev;
+    RT_ASSERT((serial != RT_NULL) && (buffer != RT_NULL));
+    tx_fifo = (struct rt_serial_tx_fifo *) serial->serial_tx;
+    RT_ASSERT(tx_fifo != RT_NULL);
+    /* When serial transmit in tx_blocking mode,
+     * if the activated mode is RT_TRUE, it will return directly */
+    if (tx_fifo->activated == RT_TRUE)  return 0;
+
+    tx_fifo->activated = RT_TRUE;
+    rt_size_t length = size;
+    rt_size_t offset = 0;
+
+    while (size)
+    {
+        /* Copy one piece of data into the ringbuffer at a time
+         * until the length of the data is equal to size */
+        tx_fifo->put_size = rt_ringbuffer_put(&(tx_fifo->rb),
+                                               (rt_uint8_t *)buffer + offset,
+                                               size);
+
+        offset += tx_fifo->put_size;
+        size -= tx_fifo->put_size;
+        /* Call the transmit interface for transmission */
+        serial->ops->transmit(serial,
+                             (rt_uint8_t *)buffer + offset,
+                             tx_fifo->put_size,
+                             RT_SERIAL_TX_BLOCKING);
+        /* Waiting for the transmission to complete */
+        rt_completion_wait(&(tx_fifo->tx_cpt), RT_WAITING_FOREVER);
+    }
+
+    return length;
+}
+
+/**
+  * @brief Serial transmit data routines, This function will transmit
+  *        data by using nonblocking.
+  * @param dev The pointer of device driver structure
+  * @param pos Empty parameter.
+  * @param buffer Transmit data buffer.
+  * @param size Transmit data buffer length.
+  * @return Return the final length of data transmit.
+  */
+static rt_size_t _serial_fifo_tx_nonblocking(struct rt_device        *dev,
+                                                    rt_off_t          pos,
+                                              const void             *buffer,
+                                                    rt_size_t         size)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_tx_fifo *tx_fifo;
+    rt_base_t level;
+    rt_size_t length;
+
+    RT_ASSERT(dev != RT_NULL);
+    if (size == 0) return 0;
+
+    serial = (struct rt_serial_device *)dev;
+    RT_ASSERT((serial != RT_NULL) && (buffer != RT_NULL));
+    tx_fifo = (struct rt_serial_tx_fifo *) serial->serial_tx;
+
+    level = rt_hw_interrupt_disable();
+
+    if (tx_fifo->activated == RT_FALSE)
+    {
+        /* When serial transmit in tx_non_blocking mode, if the activated mode is RT_FALSE,
+         * start copying data into the ringbuffer */
+        tx_fifo->activated = RT_TRUE;
+        /* Copying data into the ringbuffer */
+        length = rt_ringbuffer_put(&(tx_fifo->rb), buffer, size);
+
+        rt_hw_interrupt_enable(level);
+
+        rt_uint8_t *put_ptr = RT_NULL;
+        /* Get the linear length buffer from rinbuffer */
+        tx_fifo->put_size = rt_serial_get_linear_buffer(&(tx_fifo->rb), &put_ptr);
+        /* Call the transmit interface for transmission */
+        serial->ops->transmit(serial,
+                              put_ptr,
+                              tx_fifo->put_size,
+                              RT_SERIAL_TX_NON_BLOCKING);
+        /* In tx_nonblocking mode, there is no need to call rt_completion_wait() APIs to wait
+         * for the rt_current_thread to resume */
+        return length;
+    }
+
+    /* If the activated mode is RT_FALSE, it means that serial device is transmitting,
+     * where only the data in the ringbuffer and there is no need to call the transmit() API.
+     * Note that this part of the code requires disable interrupts
+     * to prevent multi thread reentrant */
+
+    /* Copying data into the ringbuffer */
+    length = rt_ringbuffer_put(&(tx_fifo->rb), buffer, size);
+
+    rt_hw_interrupt_enable(level);
+
+    return length;
+}
+
+
+/**
+  * @brief Enable serial transmit mode.
+  * @param dev The pointer of device driver structure
+  * @param rx_oflag The flag of that the serial port opens.
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_tx_enable(struct rt_device        *dev,
+                                           rt_uint16_t       tx_oflag)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_tx_fifo *tx_fifo = RT_NULL;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    if (serial->config.tx_bufsz == 0)
+    {
+        /* Cannot use RT_SERIAL_TX_NON_BLOCKING when tx_bufsz is 0 */
+        if (tx_oflag == RT_SERIAL_TX_NON_BLOCKING)
+        {
+            LOG_E("(%s) serial device with misconfigure: tx_bufsz = 0",
+                    dev->parent.name);
+            return -RT_EINVAL;
+        }
+
+        dev->write = _serial_poll_tx;
+        dev->open_flag |= RT_SERIAL_TX_BLOCKING;
+        return RT_EOK;
+    }
+    /* Limits the minimum value of tx_bufsz */
+    if (serial->config.tx_bufsz < RT_SERIAL_TX_MINBUFSZ)
+        serial->config.tx_bufsz = RT_SERIAL_TX_MINBUFSZ;
+
+    if (tx_oflag == RT_SERIAL_TX_BLOCKING)
+    {
+        /* When using RT_SERIAL_TX_BLOCKING, it is necessary to determine
+         * whether serial device needs to use buffer */
+        rt_err_t optmode;  /* The operating mode used by serial device */
+        /* Call the Control() API to get the operating mode */
+        optmode = serial->ops->control(serial,
+                                       RT_DEVICE_CHECK_OPTMODE,
+                                       (void *)RT_DEVICE_FLAG_TX_BLOCKING);
+        if (optmode == RT_SERIAL_TX_BLOCKING_BUFFER)
+        {
+            /* If use RT_SERIAL_TX_BLOCKING_BUFFER, the ringbuffer is initialized */
+            tx_fifo = (struct rt_serial_tx_fifo *) rt_malloc
+                    (sizeof(struct rt_serial_tx_fifo) + serial->config.tx_bufsz);
+            RT_ASSERT(tx_fifo != RT_NULL);
+
+            rt_ringbuffer_init(&(tx_fifo->rb),
+                                tx_fifo->buffer,
+                                serial->config.tx_bufsz);
+            serial->serial_tx = tx_fifo;
+            dev->write = _serial_fifo_tx_blocking_buf;
+        }
+        else
+        {
+            /* If not use RT_SERIAL_TX_BLOCKING_BUFFER,
+             * the control() API is called to configure the serial device */
+            tx_fifo = (struct rt_serial_tx_fifo*) rt_malloc
+                    (sizeof(struct rt_serial_tx_fifo));
+            RT_ASSERT(tx_fifo != RT_NULL);
+
+            serial->serial_tx = tx_fifo;
+            dev->write = _serial_fifo_tx_blocking_nbuf;
+            /* Call the control() API to configure the serial device by RT_SERIAL_TX_BLOCKING*/
+            serial->ops->control(serial,
+                                RT_DEVICE_CTRL_CONFIG,
+                                (void *)RT_SERIAL_TX_BLOCKING);
+        }
+
+        tx_fifo->activated = RT_FALSE;
+        tx_fifo->put_size = 0;
+        rt_completion_init(&(tx_fifo->tx_cpt));
+        dev->open_flag |= RT_SERIAL_TX_BLOCKING;
+
+        return RT_EOK;
+    }
+    /* When using RT_SERIAL_TX_NON_BLOCKING, ringbuffer needs to be initialized,
+     * and initialize the tx_fifo->activated value is RT_FALSE.
+     */
+    tx_fifo = (struct rt_serial_tx_fifo *) rt_malloc
+            (sizeof(struct rt_serial_tx_fifo) + serial->config.tx_bufsz);
+    RT_ASSERT(tx_fifo != RT_NULL);
+
+    tx_fifo->activated = RT_FALSE;
+    tx_fifo->put_size = 0;
+    rt_ringbuffer_init(&(tx_fifo->rb),
+                        tx_fifo->buffer,
+                        serial->config.tx_bufsz);
+    serial->serial_tx = tx_fifo;
+
+    dev->write = _serial_fifo_tx_nonblocking;
+    dev->open_flag |= RT_SERIAL_TX_NON_BLOCKING;
+    /* Call the control() API to configure the serial device by RT_SERIAL_TX_NON_BLOCKING*/
+    serial->ops->control(serial,
+                        RT_DEVICE_CTRL_CONFIG,
+                        (void *)RT_SERIAL_TX_NON_BLOCKING);
+
+    return RT_EOK;
+}
+
+
+/**
+  * @brief Enable serial receive mode.
+  * @param dev The pointer of device driver structure
+  * @param rx_oflag The flag of that the serial port opens.
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_rx_enable(struct rt_device        *dev,
+                                           rt_uint16_t       rx_oflag)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_rx_fifo *rx_fifo = RT_NULL;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    if (serial->config.rx_bufsz == 0)
+    {
+        /* Cannot use RT_SERIAL_RX_NON_BLOCKING when rx_bufsz is 0 */
+        if (rx_oflag == RT_SERIAL_RX_NON_BLOCKING)
+        {
+            LOG_E("(%s) serial device with misconfigure: rx_bufsz = 0",
+                    dev->parent.name);
+            return -RT_EINVAL;
+        }
+
+        dev->read = _serial_poll_rx;
+        dev->open_flag |= RT_SERIAL_RX_BLOCKING;
+        return RT_EOK;
+    }
+    /* Limits the minimum value of rx_bufsz */
+    if (serial->config.rx_bufsz < RT_SERIAL_RX_MINBUFSZ)
+        serial->config.rx_bufsz = RT_SERIAL_RX_MINBUFSZ;
+
+    rx_fifo = (struct rt_serial_rx_fifo *) rt_malloc
+            (sizeof(struct rt_serial_rx_fifo) + serial->config.rx_bufsz);
+
+    RT_ASSERT(rx_fifo != RT_NULL);
+    rt_ringbuffer_init(&(rx_fifo->rb), rx_fifo->buffer, serial->config.rx_bufsz);
+
+    serial->serial_rx = rx_fifo;
+    dev->read = _serial_fifo_rx;
+
+    if (rx_oflag == RT_SERIAL_RX_NON_BLOCKING)
+    {
+        dev->open_flag |= RT_SERIAL_RX_NON_BLOCKING;
+        /* Call the control() API to configure the serial device by RT_SERIAL_RX_NON_BLOCKING*/
+        serial->ops->control(serial,
+                            RT_DEVICE_CTRL_CONFIG,
+                            (void *) RT_SERIAL_RX_NON_BLOCKING);
+
+        return RT_EOK;
+    }
+    /* When using RT_SERIAL_RX_BLOCKING, rt_completion_init() and rx_cpt_index are initialized */
+    rx_fifo->rx_cpt_index = 0;
+    rt_completion_init(&(rx_fifo->rx_cpt));
+    dev->open_flag |= RT_SERIAL_RX_BLOCKING;
+    /* Call the control() API to configure the serial device by RT_SERIAL_RX_BLOCKING*/
+    serial->ops->control(serial,
+                        RT_DEVICE_CTRL_CONFIG,
+                        (void *) RT_SERIAL_RX_BLOCKING);
+
+    return RT_EOK;
+}
+
+/**
+  * @brief Disable serial receive mode.
+  * @param dev The pointer of device driver structure
+  * @param rx_oflag The flag of that the serial port opens.
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_rx_disable(struct rt_device        *dev,
+                                            rt_uint16_t       rx_oflag)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_rx_fifo *rx_fifo;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    dev->read = RT_NULL;
+    if (serial->serial_rx == RT_NULL) return RT_EOK;
+
+    do
+    {
+        if (rx_oflag == RT_SERIAL_RX_NON_BLOCKING)
+        {
+            dev->open_flag &= ~ RT_SERIAL_RX_NON_BLOCKING;
+            serial->ops->control(serial,
+                                RT_DEVICE_CTRL_CLR_INT,
+                                (void *)RT_SERIAL_RX_NON_BLOCKING);
+            break;
+        }
+
+        dev->open_flag &= ~ RT_SERIAL_RX_BLOCKING;
+        serial->ops->control(serial,
+                            RT_DEVICE_CTRL_CLR_INT,
+                            (void *)RT_SERIAL_RX_BLOCKING);
+    } while (0);
+
+    rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+    RT_ASSERT(rx_fifo != RT_NULL);
+    rt_free(rx_fifo);
+    serial->serial_rx = RT_NULL;
+
+    return RT_EOK;
+}
+
+/**
+  * @brief Disable serial tranmit mode.
+  * @param dev The pointer of device driver structure
+  * @param rx_oflag The flag of that the serial port opens.
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_tx_disable(struct rt_device        *dev,
+                                            rt_uint16_t       tx_oflag)
+{
+    struct rt_serial_device *serial;
+    struct rt_serial_tx_fifo *tx_fifo;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    dev->write = RT_NULL;
+    if (serial->serial_tx == RT_NULL) return RT_EOK;
+
+    tx_fifo = (struct rt_serial_tx_fifo *)serial->serial_tx;
+    RT_ASSERT(tx_fifo != RT_NULL);
+
+    do
+    {
+        if (tx_oflag == RT_SERIAL_TX_NON_BLOCKING)
+        {
+            dev->open_flag &= ~ RT_SERIAL_TX_NON_BLOCKING;
+
+            serial->ops->control(serial,
+                                RT_DEVICE_CTRL_CLR_INT,
+                                (void *)RT_SERIAL_TX_NON_BLOCKING);
+            break;
+        }
+
+        rt_completion_done(&(tx_fifo->tx_cpt));
+        dev->open_flag &= ~ RT_SERIAL_TX_BLOCKING;
+        serial->ops->control(serial,
+                            RT_DEVICE_CTRL_CLR_INT,
+                            (void *)RT_SERIAL_TX_BLOCKING);
+    } while (0);
+
+    rt_free(tx_fifo);
+    serial->serial_tx = RT_NULL;
+
+    return RT_EOK;
+}
+
+/**
+  * @brief Initialize the serial device.
+  * @param dev The pointer of device driver structure
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_init(struct rt_device *dev)
+{
+    rt_err_t result = RT_EOK;
+    struct rt_serial_device *serial;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    /* initialize rx/tx */
+    serial->serial_rx = RT_NULL;
+    serial->serial_tx = RT_NULL;
+
+    /* apply configuration */
+    if (serial->ops->configure)
+        result = serial->ops->configure(serial, &serial->config);
+
+    return result;
+}
+
+/**
+  * @brief Open the serial device.
+  * @param dev The pointer of device driver structure
+  * @param oflag The flag of that the serial port opens.
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
+{
+    struct rt_serial_device *serial;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    /* Check that the device has been turned on */
+    if ((dev->open_flag) & (15 << 12))
+    {
+        LOG_D("(%s) serial device has already been opened, it will run in its original configuration", dev->parent.name);
+        return RT_EOK;
+    }
+
+    LOG_D("open serial device: 0x%08x with open flag: 0x%04x",
+        dev, oflag);
+
+    /* By default, the receive mode of a serial devide is RT_SERIAL_RX_NON_BLOCKING */
+    if ((oflag & RT_SERIAL_RX_BLOCKING) == RT_SERIAL_RX_BLOCKING)
+        dev->open_flag |= RT_SERIAL_RX_BLOCKING;
+    else
+        dev->open_flag |= RT_SERIAL_RX_NON_BLOCKING;
+
+    /* By default, the transmit mode of a serial devide is RT_SERIAL_TX_BLOCKING */
+    if ((oflag & RT_SERIAL_TX_NON_BLOCKING) == RT_SERIAL_TX_NON_BLOCKING)
+        dev->open_flag |= RT_SERIAL_TX_NON_BLOCKING;
+    else
+        dev->open_flag |= RT_SERIAL_TX_BLOCKING;
+
+    /* set steam flag */
+    if ((oflag & RT_DEVICE_FLAG_STREAM) ||
+        (dev->open_flag & RT_DEVICE_FLAG_STREAM))
+        dev->open_flag |= RT_DEVICE_FLAG_STREAM;
+
+    /* initialize the Rx structure according to open flag */
+    if (serial->serial_rx == RT_NULL)
+        rt_serial_rx_enable(dev, dev->open_flag &
+                            (RT_SERIAL_RX_BLOCKING | RT_SERIAL_RX_NON_BLOCKING));
+
+    /* initialize the Tx structure according to open flag */
+    if (serial->serial_tx == RT_NULL)
+        rt_serial_tx_enable(dev, dev->open_flag &
+                            (RT_SERIAL_TX_BLOCKING | RT_SERIAL_TX_NON_BLOCKING));
+
+    return RT_EOK;
+}
+
+
+/**
+  * @brief Close the serial device.
+  * @param dev The pointer of device driver structure
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_close(struct rt_device *dev)
+{
+    struct rt_serial_device *serial;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    /* this device has more reference count */
+    if (dev->ref_count > 1) return -RT_ERROR;
+    /* Disable serial receive mode. */
+    rt_serial_rx_disable(dev, dev->open_flag &
+                        (RT_SERIAL_RX_BLOCKING | RT_SERIAL_RX_NON_BLOCKING));
+    /* Disable serial tranmit mode. */
+    rt_serial_tx_disable(dev, dev->open_flag &
+                        (RT_SERIAL_TX_BLOCKING | RT_SERIAL_TX_NON_BLOCKING));
+
+    /* Clear the callback function */
+    serial->parent.rx_indicate = RT_NULL;
+    serial->parent.tx_complete = RT_NULL;
+
+    /* Call the control() API to close the serial device */
+    serial->ops->control(serial, RT_DEVICE_CTRL_CLOSE, RT_NULL);
+    dev->flag &= ~RT_DEVICE_FLAG_ACTIVATED;
+
+    return RT_EOK;
+}
+
+/**
+  * @brief Control the serial device.
+  * @param dev The pointer of device driver structure
+  * @param cmd The command value that controls the serial device
+  * @param args The parameter value that controls the serial device
+  * @return Return the status of the operation.
+  */
+static rt_err_t rt_serial_control(struct rt_device *dev,
+                                  int               cmd,
+                                  void             *args)
+{
+    rt_err_t ret = RT_EOK;
+    struct rt_serial_device *serial;
+
+    RT_ASSERT(dev != RT_NULL);
+    serial = (struct rt_serial_device *)dev;
+
+    switch (cmd)
+    {
+        case RT_DEVICE_CTRL_SUSPEND:
+            /* suspend device */
+            dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
+            break;
+
+        case RT_DEVICE_CTRL_RESUME:
+            /* resume device */
+            dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
+            break;
+
+        case RT_DEVICE_CTRL_CONFIG:
+            if (args != RT_NULL)
+            {
+                struct serial_configure *pconfig = (struct serial_configure *) args;
+                if (serial->parent.ref_count)
+                {
+                    /*can not change buffer size*/
+                    return -RT_EBUSY;
+                }
+               /* set serial configure */
+                serial->config = *pconfig;
+                serial->ops->configure(serial,
+                                    (struct serial_configure *) args);
+            }
+
+            break;
+
+        default :
+            /* control device */
+            ret = serial->ops->control(serial, cmd, args);
+            break;
+    }
+
+    return ret;
+}
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops serial_ops =
+{
+    rt_serial_init,
+    rt_serial_open,
+    rt_serial_close,
+    rt_serial_read,
+    rt_serial_write,
+    rt_serial_control
+};
+#endif
+
+/**
+  * @brief Register the serial device.
+  * @param serial RT-thread serial device.
+  * @param name The device driver's name
+  * @param flag The capabilities flag of device.
+  * @param data The device driver's data.
+  * @return Return the status of the operation.
+  */
+rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
+                               const char              *name,
+                               rt_uint32_t              flag,
+                               void                    *data)
+{
+    rt_err_t ret;
+    struct rt_device *device;
+    RT_ASSERT(serial != RT_NULL);
+
+    device = &(serial->parent);
+
+    device->type        = RT_Device_Class_Char;
+    device->rx_indicate = RT_NULL;
+    device->tx_complete = RT_NULL;
+
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &serial_ops;
+#else
+    device->init        = rt_serial_init;
+    device->open        = rt_serial_open;
+    device->close       = rt_serial_close;
+    device->read        = RT_NULL;
+    device->write       = RT_NULL;
+    device->control     = rt_serial_control;
+#endif
+    device->user_data   = data;
+
+    /* register a character device */
+    ret = rt_device_register(device, name, flag);
+
+#if defined(RT_USING_POSIX)
+    /* set fops */
+    device->fops        = &_serial_fops;
+#endif
+    return ret;
+}
+
+/**
+  * @brief ISR for serial interrupt
+  * @param serial RT-thread serial device.
+  * @param event ISR event type.
+  */
+void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
+{
+    RT_ASSERT(serial != RT_NULL);
+
+    switch (event & 0xff)
+    {
+        /* Interrupt receive event */
+        case RT_SERIAL_EVENT_RX_IND:
+        case RT_SERIAL_EVENT_RX_DMADONE:
+        {
+            struct rt_serial_rx_fifo *rx_fifo;
+            rt_size_t rx_length = 0;
+            rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+            RT_ASSERT(rx_fifo != RT_NULL);
+
+            /* If the event is RT_SERIAL_EVENT_RX_IND, rx_length is equal to 0 */
+            rx_length = (event & (~0xff)) >> 8;
+
+            if (rx_length)
+                rt_serial_update_write_index(&(rx_fifo->rb), rx_length);
+
+            /* Get the length of the data from the ringbuffer */
+            rx_length = rt_ringbuffer_data_len(&rx_fifo->rb);
+            if (rx_length == 0) break;
+
+            if (serial->parent.open_flag & RT_SERIAL_RX_BLOCKING)
+            {
+                if (rx_fifo->rx_cpt_index && rx_length >= rx_fifo->rx_cpt_index )
+                {
+                    rx_fifo->rx_cpt_index = 0;
+                    rt_completion_done(&(rx_fifo->rx_cpt));
+                }
+            }
+            /* Trigger the receiving completion callback */
+            if (serial->parent.rx_indicate != RT_NULL)
+                serial->parent.rx_indicate(&(serial->parent), rx_length);
+            break;
+        }
+
+        /* Interrupt transmit event */
+        case RT_SERIAL_EVENT_TX_DONE:
+        {
+            struct rt_serial_tx_fifo *tx_fifo;
+            rt_size_t tx_length = 0;
+            tx_fifo = (struct rt_serial_tx_fifo *)serial->serial_tx;
+            RT_ASSERT(tx_fifo != RT_NULL);
+
+            /* Get the length of the data from the ringbuffer */
+            tx_length = rt_ringbuffer_data_len(&tx_fifo->rb);
+            /* If there is no data in tx_ringbuffer,
+             * then the transmit completion callback is triggered*/
+            if (tx_length == 0)
+            {
+                tx_fifo->activated = RT_FALSE;
+                /* Trigger the transmit completion callback */
+                if (serial->parent.tx_complete != RT_NULL)
+                    serial->parent.tx_complete(&serial->parent, RT_NULL);
+
+                if (serial->parent.open_flag & RT_SERIAL_TX_BLOCKING)
+                    rt_completion_done(&(tx_fifo->tx_cpt));
+
+                break;
+            }
+
+            /* Call the transmit interface for transmission again */
+            /* Note that in interrupt mode, tx_fifo->buffer and tx_length
+             * are inactive parameters */
+            serial->ops->transmit(serial,
+                                tx_fifo->buffer,
+                                tx_length,
+                                serial->parent.open_flag & ( \
+                                RT_SERIAL_TX_BLOCKING | \
+                                RT_SERIAL_TX_NON_BLOCKING));
+            break;
+        }
+
+        case RT_SERIAL_EVENT_TX_DMADONE:
+        {
+            struct rt_serial_tx_fifo *tx_fifo;
+            tx_fifo = (struct rt_serial_tx_fifo *)serial->serial_tx;
+            RT_ASSERT(tx_fifo != RT_NULL);
+
+            tx_fifo->activated = RT_FALSE;
+
+            /* Trigger the transmit completion callback */
+            if (serial->parent.tx_complete != RT_NULL)
+                serial->parent.tx_complete(&serial->parent, RT_NULL);
+
+            if (serial->parent.open_flag & RT_SERIAL_TX_BLOCKING)
+            {
+                rt_completion_done(&(tx_fifo->tx_cpt));
+                break;
+            }
+
+            rt_serial_update_read_index(&tx_fifo->rb, tx_fifo->put_size);
+            /* Get the length of the data from the ringbuffer.
+             * If there is some data in tx_ringbuffer,
+             * then call the transmit interface for transmission again */
+            if (rt_ringbuffer_data_len(&tx_fifo->rb))
+            {
+                tx_fifo->activated = RT_TRUE;
+
+                rt_uint8_t *put_ptr  = RT_NULL;
+                /* Get the linear length buffer from rinbuffer */
+                tx_fifo->put_size = rt_serial_get_linear_buffer(&(tx_fifo->rb), &put_ptr);
+                /* Call the transmit interface for transmission again */
+                serial->ops->transmit(serial,
+                                    put_ptr,
+                                    tx_fifo->put_size,
+                                    RT_SERIAL_TX_NON_BLOCKING);
+            }
+
+            break;
+        }
+
+        default:
+            break;
+    }
+}
diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c
index 236c1ffec7..7fa5eb067d 100644
--- a/components/drivers/src/pipe.c
+++ b/components/drivers/src/pipe.c
@@ -11,11 +11,13 @@
 #include <rthw.h>
 #include <rtdevice.h>
 #include <stdint.h>
+#include <sys/errno.h>
 
-#if defined(RT_USING_POSIX)
+#ifdef RT_USING_POSIX
 #include <dfs_file.h>
 #include <dfs_posix.h>
 #include <dfs_poll.h>
+#include <sys/ioctl.h>
 
 static int pipe_fops_open(struct dfs_fd *fd)
 {
@@ -374,7 +376,7 @@ rt_size_t rt_pipe_read(rt_device_t device, rt_off_t pos, void *buffer, rt_size_t
 
     if (device == RT_NULL)
     {
-        rt_set_errno(-EINVAL);
+        rt_set_errno(EINVAL);
         return 0;
     }
     if (count == 0) return 0;
@@ -402,7 +404,7 @@ rt_size_t rt_pipe_write(rt_device_t device, rt_off_t pos, const void *buffer, rt
 
     if (device == RT_NULL)
     {
-        rt_set_errno(-EINVAL);
+        rt_set_errno(EINVAL);
         return 0;
     }
     if (count == 0) return 0;
@@ -516,12 +518,12 @@ int rt_pipe_delete(const char *name)
         }
         else
         {
-            result = -ENODEV;
+            result = -RT_EINVAL;
         }
     }
     else
     {
-        result = -ENODEV;
+        result = -RT_EINVAL;
     }
 
     return result;
diff --git a/components/drivers/touch/touch.c b/components/drivers/touch/touch.c
index abe2c0fe24..1a747d8669 100644
--- a/components/drivers/touch/touch.c
+++ b/components/drivers/touch/touch.c
@@ -77,6 +77,8 @@ static void rt_touch_irq_enable(rt_touch_t touch)
     {
         rt_pin_irq_enable(touch->config.irq_pin.pin, RT_TRUE);
     }
+#else
+    touch->ops->touch_control(touch, RT_TOUCH_CTRL_ENABLE_INT, RT_NULL);
 #endif
 }
 
@@ -88,6 +90,8 @@ static void rt_touch_irq_disable(rt_touch_t touch)
     {
         rt_pin_irq_enable(touch->config.irq_pin.pin, RT_FALSE);
     }
+#else
+    touch->ops->touch_control(touch, RT_TOUCH_CTRL_DISABLE_INT, RT_NULL);
 #endif
 }
 
@@ -144,28 +148,6 @@ static rt_err_t rt_touch_control(rt_device_t dev, int cmd, void *args)
 
     switch (cmd)
     {
-    case RT_TOUCH_CTRL_GET_ID:
-        if (args)
-        {
-            result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_GET_ID, args);
-        }
-        else
-        {
-            result = -RT_ERROR;
-        }
-
-        break;
-    case RT_TOUCH_CTRL_GET_INFO:
-        if (args)
-        {
-            result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_GET_INFO, args);
-        }
-        else
-        {
-            result = -RT_ERROR;
-        }
-
-        break;
     case RT_TOUCH_CTRL_SET_MODE:
         result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_SET_MODE, args);
 
@@ -206,8 +188,11 @@ static rt_err_t rt_touch_control(rt_device_t dev, int cmd, void *args)
     case RT_TOUCH_CTRL_ENABLE_INT:
         rt_touch_irq_enable(touch);
         break;
+
+    case RT_TOUCH_CTRL_GET_ID:
+    case RT_TOUCH_CTRL_GET_INFO:
     default:
-        return -RT_ERROR;
+        return touch->ops->touch_control(touch, cmd, args);
     }
 
     return result;