Merge branch 'master' into security

5 files changed, 2115 insertions, 0 deletions

diff --git a/components/utilities/rt-link/src/SConscript b/components/utilities/rt-link/src/SConscript
new file mode 100644
index 0000000000..8bbb969b2a
--- /dev/null
+++ b/components/utilities/rt-link/src/SConscript
@@ -0,0 +1,13 @@
+Import('rtconfig')
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+CPPPATH = [cwd + '/../inc']
+
+group = DefineGroup('rt-link', src, depend = ['RT_USING_RT_LINK'], CPPPATH = CPPPATH)
+
+if os.path.isfile(os.path.join(cwd, 'hw', 'SConscript')):
+    group = group + SConscript(os.path.join('hw', 'SConscript'))
+
+Return('group')
diff --git a/components/utilities/rt-link/src/rtlink.c b/components/utilities/rt-link/src/rtlink.c
new file mode 100644
index 0000000000..010083aaa5
--- /dev/null
+++ b/components/utilities/rt-link/src/rtlink.c
@@ -0,0 +1,1320 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-02-02     xiangxistu   the first version
+ * 2021-03-19     Sherman      Optimize the transfer process
+ * 2021-04-20     Sherman      Optimize memory footprint
+ * 2021-05-10     Sherman      Add rtlink_status MSH command;
+ *                             Optimize transmission timer Settings;
+ *                             Fix known bugs
+ * 2021-08-06     Sherman      Add NACK, NCRC, non-blocking transmit mode;
+ *                             Add service connection status;
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <board.h>
+#include <rthw.h>
+
+#include <rtlink.h>
+#include <rtlink_hw.h>
+#include <rtlink_utils.h>
+
+#define DBG_ENABLE
+#ifdef USING_RT_LINK_DEBUG
+    #define DBG_LVL DBG_LOG
+#else
+    #define DBG_LVL DBG_INFO
+#endif
+#define DBG_TAG "rtlink"
+#define DBG_COLOR
+#include <rtdbg.h>
+
+#ifdef RT_LINK_USING_SPI
+    #define RT_LINK_LONG_FRAME_TIMEOUT      50
+    #define RT_LINK_SENT_FRAME_TIMEOUT      100
+#else
+    #define RT_LINK_LONG_FRAME_TIMEOUT      100
+    #define RT_LINK_SENT_FRAME_TIMEOUT      100
+#endif /* RT_LINK_USING_SPI */
+
+#define RT_LINK_RECV_DATA_SEQUENCE      0
+#define RT_LINK_INIT_FRAME_SEQENCE      129
+
+#define RT_LINK_THREAD_NAME         "rtlink"
+#define RT_LINK_THREAD_TICK         20
+#define RT_LINK_THREAD_PRIORITY     25
+#define RT_LINK_THREAD_STACK_SIZE   1024 /* 32 bytes aligned */
+
+#define RT_LINK_FRAME_SENT      1
+#define RT_LINK_FRAME_NOSEND    0
+
+typedef enum
+{
+    FIND_FRAME_HEAD     = 0,
+    PARSE_FRAME_HEAD    = 1,
+    PARSE_FRAME_EXTEND  = 2,
+    PARSE_FRAME_SEQ     = 3,
+    CHECK_FRAME_CRC     = 4,
+    HEADLE_FRAME_DATA   = 5,
+} rt_link_frame_parse_t;
+
+/* rtlink SCB(Session control block) */
+static struct rt_link_session *rt_link_scb = RT_NULL;
+struct rt_link_session *rt_link_get_scb(void)
+{
+    return rt_link_scb;
+}
+
+static rt_int16_t rt_link_check_seq(rt_uint8_t new, rt_uint8_t used)
+{
+    rt_int16_t compare_seq = 0;
+    compare_seq = new - used;
+    if (compare_seq < 0)
+    {
+        compare_seq = compare_seq + 256;
+    }
+    return compare_seq;
+}
+
+static int rt_link_frame_init(struct rt_link_frame *frame, rt_uint8_t config)
+{
+    if (frame == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    /* set frame control information */
+    rt_memset(&frame->head, 0, sizeof(struct rt_link_frame_head));
+    if (config & RT_LINK_FLAG_CRC)
+    {
+        frame->head.crc = 1;
+    }
+    if (config & RT_LINK_FLAG_ACK)
+    {
+        frame->head.ack = 1;
+    }
+
+    frame->head.magicid = RT_LINK_FRAME_HEAD;
+    /* frame data information */
+    rt_memset(&frame->extend, 0, sizeof(struct rt_link_extend));
+    frame->crc = 0;
+    frame->real_data = RT_NULL;
+    frame->data_len = 0;
+    frame->index = 0;
+    frame->total = 0;
+    frame->attribute = RT_LINK_RESERVE_FRAME;
+    frame->issent = RT_LINK_FRAME_NOSEND;
+
+    rt_slist_init(&frame->slist);
+
+    return RT_EOK;
+}
+
+/* remove the sending list node*/
+static void rt_link_frame_remove(struct rt_link_service *service)
+{
+    RT_ASSERT(service != RT_NULL);
+    struct rt_link_frame *find_frame = RT_NULL;
+    rt_uint8_t total = 0;
+    rt_slist_t *tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+    if (tem_list != RT_NULL)
+    {
+        do
+        {
+            find_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+            tem_list = rt_slist_next(tem_list);
+            if (find_frame->head.service == service->service)
+            {
+                if (total == 0)
+                {
+                    total = find_frame->total;
+                }
+                /* The data frame order is appended to the list,
+                with total counting starting at 1 and index counting from 0 */
+                LOG_D("remove seq(%d) serv (%d)", find_frame->head.sequence, service->service);
+                rt_enter_critical();
+                rt_slist_remove(&rt_link_scb->tx_data_slist, &find_frame->slist);
+                rt_exit_critical();
+                total--;
+                rt_memset(find_frame, 0, sizeof(struct rt_link_frame));
+                rt_free(find_frame);
+            }
+        } while ((total > 0) && (tem_list != RT_NULL));
+    }
+}
+
+/* Configure the extended field of the frame */
+static rt_err_t rt_link_frame_extend_config(struct rt_link_frame *frame, rt_link_frame_attr_e attribute, rt_uint16_t parameter)
+{
+    frame->head.extend = 1;
+    frame->extend.attribute = attribute;
+    frame->extend.parameter = parameter;
+    return RT_EOK;
+}
+
+static int rt_link_command_frame_send(rt_uint8_t serv, rt_uint8_t sequence, rt_link_frame_attr_e attribute, rt_uint16_t parameter)
+{
+    struct rt_link_frame command_frame = {0};
+    rt_uint8_t data[sizeof(command_frame.head) + sizeof(command_frame.extend)] = {0};
+    rt_uint8_t data_len = 0;
+
+    /* command frame don't need crc and ack ability */
+    rt_link_frame_init(&command_frame, RT_NULL);
+    data_len += sizeof(command_frame.head);
+
+    rt_link_frame_extend_config(&command_frame, attribute, parameter);
+    rt_memcpy(data + data_len, &command_frame.extend, sizeof(command_frame.extend));
+    data_len += sizeof(command_frame.extend);
+
+    command_frame.head.sequence = sequence;
+    command_frame.head.service = serv;
+    rt_memcpy(data, &command_frame.head, sizeof(command_frame.head));
+
+    rt_link_hw_send(data, data_len);
+    return RT_EOK;
+}
+
+static void rt_link_service_send_finish(rt_link_err_e err)
+{
+    struct rt_link_frame *frame = RT_NULL;
+    rt_uint8_t service = RT_LINK_SERVICE_MAX;
+    void *buffer = RT_NULL;
+    rt_slist_t *tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+    if (tem_list == RT_NULL)
+    {
+        return ;
+    }
+    frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+    if (frame)
+    {
+        service = frame->head.service;
+        buffer = frame->real_data - (frame->index * RT_LINK_MAX_DATA_LENGTH);
+        rt_link_scb->service[service]->err = err;
+        rt_link_scb->sendtimer.parameter = 0;
+        rt_link_frame_remove(rt_link_scb->service[service]);
+        if (rt_link_scb->service[service]->timeout_tx != RT_WAITING_NO)
+        {
+            rt_event_send(&rt_link_scb->sendevent, (0x01 << service));
+        }
+        else
+        {
+            rt_link_scb->service[service]->send_cb(rt_link_scb->service[service], buffer);
+        }
+    }
+}
+
+static rt_size_t frame_send(struct rt_link_frame *frame)
+{
+    rt_size_t length = 0;
+    rt_uint8_t *data = RT_NULL;
+
+    rt_memset(rt_link_scb->sendbuffer, 0, sizeof(rt_link_scb->sendbuffer));
+    data = rt_link_scb->sendbuffer;
+    length = RT_LINK_HEAD_LENGTH;
+    if (frame->head.crc)
+    {
+        length += RT_LINK_CRC_LENGTH;
+    }
+    if (frame->head.extend)
+    {
+        length += RT_LINK_EXTEND_LENGTH;
+    }
+
+    length += frame->data_len;
+    frame->head.length = frame->data_len;
+    rt_memcpy(data, &frame->head, RT_LINK_HEAD_LENGTH);
+    data = data + RT_LINK_HEAD_LENGTH;
+    if (frame->head.extend)
+    {
+        rt_memcpy(data, &frame->extend, RT_LINK_EXTEND_LENGTH);
+        data = data + RT_LINK_EXTEND_LENGTH;
+    }
+    if (frame->attribute == RT_LINK_SHORT_DATA_FRAME || frame->attribute == RT_LINK_LONG_DATA_FRAME)
+    {
+        rt_memcpy(data, frame->real_data, frame->data_len);
+        data = data + frame->data_len;
+    }
+    if (frame->head.crc)
+    {
+        frame->crc = rt_link_scb->calculate_crc(RT_FALSE, rt_link_scb->sendbuffer, length - RT_LINK_CRC_LENGTH);
+        rt_memcpy(data, &frame->crc, RT_LINK_CRC_LENGTH);
+    }
+
+    LOG_D("frame send seq(%d) len(%d) attr:(%d), crc:(0x%08x).", frame->head.sequence, length, frame->attribute, frame->crc);
+    return rt_link_hw_send(rt_link_scb->sendbuffer, length);
+}
+
+/* performs data transmission */
+static rt_err_t rt_link_frame_send(rt_slist_t *slist)
+{
+    rt_uint8_t is_finish = RT_FALSE;
+    struct rt_link_frame *frame = RT_NULL;
+    rt_uint8_t send_max = RT_LINK_ACK_MAX;
+
+    /* if slist is tx_data_slist, we should send all data on the slist*/
+    if (slist == &rt_link_scb->tx_data_slist)
+    {
+        slist = rt_slist_next(&rt_link_scb->tx_data_slist);
+    }
+    if (slist == RT_NULL)
+    {
+        LOG_W("send data list NULL");
+        return -RT_ERROR;
+    }
+
+    do
+    {
+        /* get frame for send */
+        frame = rt_container_of(slist, struct rt_link_frame, slist);
+        slist = rt_slist_next(slist);
+
+        if (frame_send(frame) == 0)
+        {
+            rt_link_scb->service[frame->head.service]->err = RT_LINK_EIO;
+            goto __err;
+        }
+        frame->issent = RT_LINK_FRAME_SENT;
+        if ((slist == RT_NULL) || (frame->index + 1 >= frame->total))
+        {
+            send_max = 0;
+            is_finish = RT_TRUE;
+        }
+        else
+        {
+            send_max >>= 1;
+        }
+    }while (send_max);
+
+    if ((is_finish) && (frame->head.ack == 0))
+    {
+        /* NACK frame send finish, remove after sending */
+        rt_link_service_send_finish(RT_LINK_EOK);
+        if (slist != RT_NULL)
+        {
+            LOG_D("Continue sending");
+            rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
+        }
+    }
+    else
+    {
+        rt_int32_t timeout = RT_LINK_SENT_FRAME_TIMEOUT;
+        rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+        rt_timer_start(&rt_link_scb->sendtimer);
+    }
+    return RT_EOK;
+__err:
+    return -RT_ERROR;
+}
+
+static void _stop_recv_long(void)
+{
+    rt_timer_stop(&rt_link_scb->longframetimer);
+    if (rt_link_scb->rx_record.dataspace != RT_NULL)
+    {
+        rt_free(rt_link_scb->rx_record.dataspace);
+        rt_link_scb->rx_record.dataspace = RT_NULL;
+    }
+    rt_link_scb->rx_record.long_count = 0;
+    rt_link_scb->rx_record.total = 0;
+}
+
+static rt_err_t rt_link_frame_stop_receive(struct rt_link_frame *frame)
+{
+    rt_memset(frame, 0, sizeof(struct rt_link_frame));
+    if (rt_link_scb->rx_record.dataspace)
+    {
+        rt_free(rt_link_scb->rx_record.dataspace);
+    }
+    rt_link_scb->rx_record.dataspace = RT_NULL;
+    rt_link_scb->rx_record.long_count = 0;
+    rt_link_scb->rx_record.total = 0;
+
+    rt_timer_stop(&rt_link_scb->recvtimer);
+    rt_link_scb->recvtimer.parameter = 0;
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_resend_handle(struct rt_link_frame *receive_frame)
+{
+    struct rt_link_frame *find_frame = RT_NULL;
+    rt_slist_t *tem_list = RT_NULL;
+
+    tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+    while (tem_list != RT_NULL)
+    {
+        find_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+        if (find_frame->head.sequence == receive_frame->head.sequence)
+        {
+            LOG_D("resend frame(%d)", find_frame->head.sequence);
+            frame_send(find_frame);
+            break;
+        }
+        tem_list = tem_list->next;
+    }
+
+    if (tem_list == RT_NULL)
+    {
+        LOG_D("frame resent failed, can't find(%d).", receive_frame->head.sequence);
+        rt_link_command_frame_send(receive_frame->head.service,
+                                   receive_frame->head.sequence,
+                                   RT_LINK_SESSION_END, RT_NULL);
+    }
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_confirm_handle(struct rt_link_frame *receive_frame)
+{
+    static struct rt_link_frame *send_frame = RT_NULL;
+    rt_slist_t *tem_list = RT_NULL;
+    rt_uint16_t seq_offset = 0;
+    LOG_D("confirm seq(%d) frame", receive_frame->head.sequence);
+
+    rt_timer_stop(&rt_link_scb->sendtimer);
+
+    if (rt_link_scb->service[receive_frame->head.service] != RT_NULL)
+    {
+        rt_link_scb->service[receive_frame->head.service]->state = RT_LINK_CONNECT;
+    }
+
+    if (rt_link_scb->state != RT_LINK_CONNECT)
+    {
+        /* The handshake success and resends the data frame */
+        rt_link_scb->state = RT_LINK_CONNECT;
+        if (rt_slist_first(&rt_link_scb->tx_data_slist))
+        {
+            rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
+        }
+        return RT_EOK;
+    }
+
+    /* Check to see if the frame is send for confirm */
+    tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+    if (tem_list == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+    send_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+    seq_offset = rt_link_check_seq(receive_frame->head.sequence, send_frame->head.sequence);
+    if (seq_offset <= send_frame->total)
+    {
+        rt_link_service_send_finish(RT_LINK_EOK);
+        rt_link_scb->state = RT_LINK_CONNECT;
+
+        tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+        if (tem_list != RT_NULL)
+        {
+            LOG_D("Continue sending");
+            rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
+        }
+    }
+    return RT_EOK;
+}
+
+/* serv type rt_link_service_e */
+static void rt_link_recv_finish(rt_uint8_t serv, void *data, rt_size_t size)
+{
+    if (rt_link_scb->service[serv] == RT_NULL)
+    {
+        rt_link_command_frame_send(serv, 0, RT_LINK_DETACH_FRAME, RT_NULL);
+        return;
+    }
+
+    if (rt_link_scb->service[serv]->recv_cb == RT_NULL)
+    {
+        rt_free(data);
+        LOG_W("service %d haven't been registered.", serv);
+    }
+    else
+    {
+        rt_link_scb->service[serv]->recv_cb(rt_link_scb->service[serv], data, size);
+    }
+}
+
+static rt_err_t rt_link_short_handle(struct rt_link_frame *receive_frame)
+{
+    LOG_D("Seq(%d) short data", receive_frame->head.sequence);
+    rt_link_scb->rx_record.dataspace = rt_malloc(receive_frame->data_len);
+    if (rt_link_scb->rx_record.dataspace != RT_NULL)
+    {
+        if (receive_frame->head.ack)
+        {
+            rt_link_command_frame_send(receive_frame->head.service,
+                                       receive_frame->head.sequence,
+                                       RT_LINK_CONFIRM_FRAME, RT_NULL);
+        }
+        rt_link_scb->rx_record.rx_seq = receive_frame->head.sequence;
+        rt_link_hw_copy(rt_link_scb->rx_record.dataspace, receive_frame->real_data, receive_frame->data_len);
+        rt_link_recv_finish(receive_frame->head.service, rt_link_scb->rx_record.dataspace, receive_frame->data_len);
+        rt_link_scb->rx_record.dataspace = RT_NULL;
+    }
+    else
+    {
+        LOG_W("short data %dB alloc failed", receive_frame->data_len);
+    }
+    receive_frame->real_data = RT_NULL;
+    return 0;
+}
+
+static void _long_handle_first(struct rt_link_frame *receive_frame)
+{
+    if (receive_frame->extend.parameter % RT_LINK_MAX_DATA_LENGTH == 0)
+    {
+        receive_frame->total = receive_frame->extend.parameter / RT_LINK_MAX_DATA_LENGTH;
+    }
+    else
+    {
+        receive_frame->total = receive_frame->extend.parameter / RT_LINK_MAX_DATA_LENGTH + 1;
+    }
+
+    rt_link_scb->rx_record.total = receive_frame->total;
+    rt_link_scb->rx_record.dataspace = rt_malloc(receive_frame->extend.parameter);
+    if (rt_link_scb->rx_record.dataspace == RT_NULL)
+    {
+        LOG_W("long data (%dB) alloc failed.", receive_frame->extend.parameter);
+    }
+}
+
+static void _long_handle_second(struct rt_link_frame *receive_frame)
+{
+    static rt_uint8_t ack_mask = RT_LINK_ACK_MAX;
+    rt_size_t offset = 0; /* offset, count from 0 */
+
+    receive_frame->index = rt_link_check_seq(receive_frame->head.sequence, rt_link_scb->rx_record.rx_seq) - 1;
+    LOG_D("seq(%d), rxseq(%d), index(%d), total(%d), count(0x%x)"
+          , receive_frame->head.sequence
+          , rt_link_scb->rx_record.rx_seq
+          , receive_frame->index
+          , receive_frame->total
+          , rt_link_scb->rx_record.long_count);
+
+    if ((receive_frame->index > RT_LINK_FRAMES_MAX) || (rt_link_scb->rx_record.long_count & (0x01 << receive_frame->index)))
+    {
+        LOG_D("ERR:index %d, rx_seq %d", receive_frame->index, rt_link_scb->rx_record.rx_seq);
+    }
+    else if (rt_link_scb->rx_record.dataspace != RT_NULL)
+    {
+        rt_link_scb->rx_record.long_count |= (0x01 << receive_frame->index);
+        offset = RT_LINK_MAX_DATA_LENGTH * receive_frame->index;
+        rt_link_hw_copy(rt_link_scb->rx_record.dataspace + offset, receive_frame->real_data, receive_frame->data_len);
+
+        if (receive_frame->head.ack)
+        {
+            if (rt_link_utils_num1(rt_link_scb->rx_record.long_count) == rt_link_scb->rx_record.total)
+            {
+                rt_link_command_frame_send(receive_frame->head.service,
+                                           (rt_link_scb->rx_record.rx_seq + rt_link_scb->rx_record.total),
+                                           RT_LINK_CONFIRM_FRAME, RT_NULL);
+            }
+            else if ((rt_link_scb->rx_record.long_count & ack_mask) == ack_mask)
+            {
+                rt_link_command_frame_send(receive_frame->head.service,
+                                           (rt_link_scb->rx_record.rx_seq + rt_link_utils_num1(ack_mask)),
+                                           RT_LINK_CONFIRM_FRAME, RT_NULL);
+                ack_mask |= ack_mask << rt_link_utils_num1(RT_LINK_ACK_MAX);
+            }
+        }
+
+        /* receive a complete package */
+        if (rt_link_utils_num1(rt_link_scb->rx_record.long_count) == rt_link_scb->rx_record.total)
+        {
+            rt_timer_stop(&rt_link_scb->longframetimer);
+            rt_link_recv_finish(receive_frame->head.service, rt_link_scb->rx_record.dataspace, receive_frame->extend.parameter);
+
+            rt_enter_critical();
+            /* empty  rx_record */
+            rt_link_scb->rx_record.rx_seq += rt_link_scb->rx_record.total;
+            rt_link_scb->rx_record.dataspace = RT_NULL;
+            rt_link_scb->rx_record.long_count = 0;
+            rt_link_scb->rx_record.total = 0;
+            ack_mask = RT_LINK_ACK_MAX;
+            rt_exit_critical();
+        }
+        else if (rt_link_hw_recv_len(rt_link_scb->rx_buffer) < (receive_frame->data_len % RT_LINK_MAX_DATA_LENGTH))
+        {
+            rt_int32_t timeout = RT_LINK_LONG_FRAME_TIMEOUT;
+            rt_timer_control(&rt_link_scb->longframetimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+            rt_timer_start(&rt_link_scb->longframetimer);
+        }
+    }
+}
+
+static rt_err_t rt_link_long_handle(struct rt_link_frame *receive_frame)
+{
+    if (rt_link_scb->rx_record.long_count == 0)
+    {
+        /* Receive this long package for the first time:
+         * calculates the total number of frames,
+         * requests space, and turns on the receive timer */
+        _long_handle_first(receive_frame);
+    }
+    if (rt_link_scb->rx_record.total > 0)
+    {
+        /* Intermediate frame processing:
+         * serial number repeated check,
+         * receive completion check, reply to ACK */
+        _long_handle_second(receive_frame);
+    }
+    receive_frame->real_data = RT_NULL;
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_handshake_handle(struct rt_link_frame *receive_frame)
+{
+    LOG_D("HANDSHAKE: seq(%d) param(%d)", receive_frame->head.sequence, receive_frame->extend.parameter);
+    rt_link_scb->state = RT_LINK_CONNECT;
+    /* sync requester tx seq, responder rx seq = requester tx seq */
+    rt_link_scb->rx_record.rx_seq = receive_frame->head.sequence;
+    /* sync requester rx seq, responder tx seq = requester rx seq */
+    rt_link_scb->tx_seq = receive_frame->extend.parameter;
+
+    if (rt_link_scb->service[receive_frame->head.service] != RT_NULL)
+    {
+        rt_link_scb->service[receive_frame->head.service]->state = RT_LINK_CONNECT;
+        rt_link_command_frame_send(receive_frame->head.service,
+                                   receive_frame->head.sequence,
+                                   RT_LINK_CONFIRM_FRAME, RT_NULL);
+    }
+    else
+    {
+        rt_link_command_frame_send(receive_frame->head.service,
+                                   receive_frame->head.sequence,
+                                   RT_LINK_DETACH_FRAME, RT_NULL);
+    }
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_detach_handle(struct rt_link_frame *receive_frame)
+{
+    if (rt_link_scb->service[receive_frame->head.service] != RT_NULL)
+    {
+        rt_link_scb->service[receive_frame->head.service]->state = RT_LINK_DISCONN;
+    }
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_session_end_handle(struct rt_link_frame *receive_frame)
+{
+    rt_link_frame_stop_receive(receive_frame);
+    return RT_EOK;
+}
+
+/* Discriminate frame type */
+static rt_err_t rt_link_parse_frame(struct rt_link_frame *receive_frame)
+{
+    switch (receive_frame->attribute)
+    {
+    case RT_LINK_RESEND_FRAME:
+        rt_link_resend_handle(receive_frame);
+        break;
+    case RT_LINK_CONFIRM_FRAME:
+        rt_link_confirm_handle(receive_frame);
+        break;
+    case RT_LINK_HANDSHAKE_FRAME:
+        rt_link_handshake_handle(receive_frame);
+        break;
+    case RT_LINK_SESSION_END:
+        rt_link_session_end_handle(receive_frame);
+        break;
+    case RT_LINK_DETACH_FRAME:
+        rt_link_detach_handle(receive_frame);
+        break;
+
+    case RT_LINK_SHORT_DATA_FRAME:
+        rt_link_short_handle(receive_frame);
+        break;
+    case RT_LINK_LONG_DATA_FRAME:
+        rt_link_long_handle(receive_frame);
+        break;
+
+    default:
+        return -RT_ERROR;
+    }
+    return RT_EOK;
+}
+
+/* RT_LINK_READ_CHECK_EVENT handle */
+static void rt_link_frame_check(void)
+{
+    static struct rt_link_frame receive_frame = {0};
+    static rt_link_frame_parse_t analysis_status = FIND_FRAME_HEAD;
+    static rt_uint8_t *data = RT_NULL;
+    static rt_uint16_t buff_len = RT_LINK_HEAD_LENGTH;
+
+    struct rt_link_frame *send_frame = RT_NULL;
+    rt_tick_t timeout = 0;
+    rt_uint32_t temporary_crc = 0;
+
+    rt_uint8_t offset = 0;
+    rt_size_t recv_len = rt_link_hw_recv_len(rt_link_scb->rx_buffer);
+    while (recv_len > 0)
+    {
+        switch (analysis_status)
+        {
+        case FIND_FRAME_HEAD:
+        {
+            /* if we can't find frame head, throw that data */
+            if ((*rt_link_scb->rx_buffer->read_point & RT_LINK_FRAME_HEAD_MASK) == RT_LINK_FRAME_HEAD)
+            {
+                analysis_status = PARSE_FRAME_HEAD;
+                break;
+            }
+            rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+            break;
+        }
+
+        case PARSE_FRAME_HEAD:
+        {
+            if (recv_len < buff_len)
+            {
+                LOG_D("HEAD: actual: %d, need: %d.", recv_len, buff_len);
+                return ;
+            }
+            /* Data is an offset address */
+            data = rt_link_scb->rx_buffer->read_point;
+            rt_link_frame_init(&receive_frame, RT_NULL);
+            rt_link_hw_copy((rt_uint8_t *)&receive_frame.head, data, sizeof(struct rt_link_frame_head));
+            rt_link_hw_buffer_point_shift(&data, sizeof(struct rt_link_frame_head));
+
+            LOG_D("HEAD: seq(%d) serv(%d) ack(%d) crc(%d) ext(%d) len(%d) attr(%d)(0x%x)"
+                  , receive_frame.head.sequence
+                  , receive_frame.head.service
+                  , receive_frame.head.ack
+                  , receive_frame.head.crc
+                  , receive_frame.head.extend
+                  , receive_frame.head.length
+                  , receive_frame.extend.attribute
+                  , receive_frame.extend.parameter);
+
+            receive_frame.data_len = receive_frame.head.length;
+            if (receive_frame.head.service >= RT_LINK_SERVICE_MAX)
+            {
+                rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+                goto __find_head;
+            }
+
+            if (receive_frame.head.extend)
+            {
+                buff_len += RT_LINK_EXTEND_LENGTH;
+                analysis_status = PARSE_FRAME_EXTEND;
+            }
+            else
+            {
+                receive_frame.attribute = RT_LINK_SHORT_DATA_FRAME;
+                analysis_status = PARSE_FRAME_SEQ;
+            }
+        }
+
+        case PARSE_FRAME_EXTEND:
+        {
+            if (receive_frame.head.extend)
+            {
+                if (recv_len < buff_len)
+                {
+                    LOG_D("EXTEND: actual: %d, need: %d.", recv_len, buff_len);
+                    /* should set timer, control receive frame timeout, one shot */
+                    timeout = 50;
+                    rt_timer_control(&rt_link_scb->recvtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+                    rt_timer_start(&rt_link_scb->recvtimer);
+                    return;
+                }
+                rt_timer_stop(&rt_link_scb->recvtimer);
+                rt_link_hw_copy((rt_uint8_t *)&receive_frame.extend, data, sizeof(struct rt_link_extend));
+                rt_link_hw_buffer_point_shift(&data, sizeof(struct rt_link_extend));
+                if (receive_frame.extend.attribute < RT_LINK_RESERVE_FRAME)
+                {
+                    receive_frame.attribute = receive_frame.extend.attribute;
+                }
+                else
+                {
+                    LOG_D("EXTEND: attr(%d) err", receive_frame.extend.attribute);
+                    rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+                    goto __find_head;
+                }
+            }
+            analysis_status = PARSE_FRAME_SEQ;
+        }
+
+        case PARSE_FRAME_SEQ:
+        {
+            switch (receive_frame.attribute)
+            {
+            case RT_LINK_CONFIRM_FRAME:
+            case RT_LINK_RESEND_FRAME:
+            {
+                /* Check the send sequence */
+                offset = rt_link_check_seq(receive_frame.head.sequence, rt_link_scb->tx_seq);
+                if (rt_slist_first(&rt_link_scb->tx_data_slist) != RT_NULL)
+                {
+                    send_frame = rt_container_of(rt_link_scb->tx_data_slist.next, struct rt_link_frame, slist);
+                    if (offset > send_frame->total)
+                    {
+                        /* exceptional frame, ignore it */
+                        LOG_D("seq (%d) failed, tx_seq (%d).offset=(%d) total= (%d)", receive_frame.head.sequence, rt_link_scb->tx_seq, offset, send_frame->total);
+                        rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+                        goto __find_head;
+                    }
+                }
+                break;
+            }
+            case RT_LINK_LONG_DATA_FRAME:
+            case RT_LINK_SHORT_DATA_FRAME:
+            case RT_LINK_SESSION_END:
+            {
+                /* Check the receive sequence */
+                offset = rt_link_check_seq(receive_frame.head.sequence, rt_link_scb->rx_record.rx_seq) - 1;
+                if (offset > RT_LINK_FRAMES_MAX)
+                {
+                    /* exceptional frame, ignore it */
+                    LOG_D("seq (%d) failed, rx_seq (%d) offset=(%d) attr= (%d) status (%d)", receive_frame.head.sequence, rt_link_scb->rx_record.rx_seq, offset, receive_frame.attribute, rt_link_scb->state);
+                    rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+                    goto __find_head;
+                }
+            }
+            case RT_LINK_HANDSHAKE_FRAME:
+            case RT_LINK_DETACH_FRAME:
+                analysis_status = HEADLE_FRAME_DATA;
+                break;
+
+            default:
+                LOG_D("quick filter error frame.");
+                rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+                goto __find_head;
+            }
+            buff_len += receive_frame.data_len;
+            if (receive_frame.head.crc)
+            {
+                buff_len += RT_LINK_CRC_LENGTH;
+                analysis_status = CHECK_FRAME_CRC;
+            }
+            else
+            {
+                analysis_status = HEADLE_FRAME_DATA;
+            }
+            /* fill real data point */
+            receive_frame.real_data = data;
+        }
+
+        case CHECK_FRAME_CRC:
+        {
+            if (receive_frame.head.crc)
+            {
+                if (recv_len < buff_len)
+                {
+                    LOG_D("CRC: actual: %d, need: %d.", recv_len, buff_len);
+                    /* should set timer, control receive frame timeout, one shot */
+                    timeout = 50;
+                    rt_timer_control(&rt_link_scb->recvtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+                    rt_timer_start(&rt_link_scb->recvtimer);
+                    return;
+                }
+
+                rt_timer_stop(&rt_link_scb->recvtimer);
+                rt_link_hw_buffer_point_shift(&data, receive_frame.data_len);
+                rt_link_hw_copy((rt_uint8_t *)&receive_frame.crc, data, RT_LINK_CRC_LENGTH);
+                temporary_crc = rt_link_scb->calculate_crc(RT_TRUE, rt_link_scb->rx_buffer->read_point, buff_len - RT_LINK_CRC_LENGTH);
+                if (receive_frame.crc != temporary_crc)
+                {
+                    /* check failed. ready resent */
+                    LOG_D("CRC: calc:(0x%08x) ,recv:(0x%08x).", temporary_crc, receive_frame.crc);
+                    rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+                    goto __find_head;
+                }
+            }
+            analysis_status = HEADLE_FRAME_DATA;
+        }
+
+        case HEADLE_FRAME_DATA:
+        {
+            if (recv_len < buff_len)
+            {
+                LOG_D("PARSE: actual: %d, need: %d.", recv_len, buff_len);
+                /* should set timer, control receive frame timeout, one shot */
+                timeout = 50;
+                rt_timer_control(&rt_link_scb->recvtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+                rt_timer_start(&rt_link_scb->recvtimer);
+                return;
+            }
+            LOG_D("PARSE: buff_len (%d) r (0x%p)  w (0x%p)"
+                  , buff_len, rt_link_scb->rx_buffer->read_point
+                  , rt_link_scb->rx_buffer->write_point);
+            rt_timer_stop(&rt_link_scb->recvtimer);
+            rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, buff_len);
+            rt_link_parse_frame(&receive_frame);
+            data = RT_NULL;
+            buff_len = RT_LINK_HEAD_LENGTH;
+            analysis_status = FIND_FRAME_HEAD;
+            break;
+        }
+
+        default:
+__find_head:
+            LOG_D("to find head (%d)", analysis_status);
+            rt_link_frame_stop_receive(&receive_frame);
+            buff_len = RT_LINK_HEAD_LENGTH;
+            analysis_status = FIND_FRAME_HEAD;
+            break;
+        }
+
+        recv_len = rt_link_hw_recv_len(rt_link_scb->rx_buffer);
+    }
+}
+
+static void rt_link_send_ready(void)
+{
+    struct rt_link_frame *frame = RT_NULL;
+    rt_uint8_t seq = rt_link_scb->tx_seq;
+    if (rt_slist_next(&rt_link_scb->tx_data_slist))
+    {
+        frame = rt_container_of(rt_slist_next(&rt_link_scb->tx_data_slist), struct rt_link_frame, slist);
+    }
+
+    if (rt_link_scb->state != RT_LINK_CONNECT)
+    {
+        rt_link_scb->state = RT_LINK_DISCONN;
+        rt_link_command_frame_send(RT_LINK_SERVICE_RTLINK, seq,
+                                   RT_LINK_HANDSHAKE_FRAME, rt_link_scb->rx_record.rx_seq);
+
+        rt_int32_t timeout = 50;
+        rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+        rt_timer_start(&rt_link_scb->sendtimer);
+    }
+    else
+    {
+        /* Avoid sending the first data frame multiple times */
+        if ((frame != RT_NULL) && (frame->issent == RT_LINK_FRAME_NOSEND))
+        {
+            if (RT_EOK != rt_link_frame_send(&rt_link_scb->tx_data_slist))
+            {
+                rt_link_scb->state = RT_LINK_DISCONN;
+                rt_link_service_send_finish(RT_LINK_EIO);
+            }
+        }
+    }
+}
+
+static void rt_link_frame_recv_timeout(void)
+{
+    /* The receiving frame timeout and a new receive begins */
+    rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, rt_link_hw_recv_len(rt_link_scb->rx_buffer));
+}
+
+static void rt_link_send_timeout(void)
+{
+    LOG_D("send count(%d)", (rt_uint32_t)rt_link_scb->sendtimer.parameter);
+    if ((rt_uint32_t)rt_link_scb->sendtimer.parameter >= 5)
+    {
+        rt_timer_stop(&rt_link_scb->sendtimer);
+        LOG_W("Send timeout, please check the link status!");
+        rt_link_scb->sendtimer.parameter = 0x00;
+        rt_link_service_send_finish(RT_LINK_ETIMEOUT);
+    }
+    else
+    {
+        if (rt_slist_next(&rt_link_scb->tx_data_slist))
+        {
+            struct rt_link_frame *frame = rt_container_of(rt_slist_next(&rt_link_scb->tx_data_slist), struct rt_link_frame, slist);
+            frame->issent = RT_LINK_FRAME_NOSEND;
+            rt_link_command_frame_send(RT_LINK_SERVICE_RTLINK,
+                                       frame->head.sequence,
+                                       RT_LINK_HANDSHAKE_FRAME,
+                                       rt_link_scb->rx_record.rx_seq);
+        }
+    }
+}
+
+static void rt_link_long_recv_timeout(void)
+{
+    if ((rt_uint32_t)rt_link_scb->longframetimer.parameter >= 5)
+    {
+        LOG_W("long package receive timeout");
+        rt_link_scb->longframetimer.parameter = 0x00;
+        _stop_recv_long();
+        rt_timer_stop(&rt_link_scb->longframetimer);
+    }
+    else
+    {
+        rt_uint8_t total = rt_link_scb->rx_record.total;
+        for (; total > 0; total--)
+        {
+            if (((rt_link_scb->rx_record.long_count >> (total - 1)) & 0x01) == 0x00)
+            {
+                /* resend command */
+                rt_link_command_frame_send(RT_LINK_SERVICE_RTLINK,
+                                           (rt_link_scb->rx_record.rx_seq + total),
+                                           RT_LINK_RESEND_FRAME, RT_NULL);
+            }
+        }
+    }
+}
+
+void rt_link_thread(void *parameter)
+{
+    rt_uint32_t recved = 0;
+    while (1)
+    {
+        rt_event_recv(&rt_link_scb->event,
+                      RT_LINK_READ_CHECK_EVENT |
+                      RT_LINK_SEND_READY_EVENT  |
+                      RT_LINK_SEND_TIMEOUT_EVENT |
+                      RT_LINK_RECV_TIMEOUT_FRAME_EVENT |
+                      RT_LINK_RECV_TIMEOUT_LONG_EVENT,
+                      RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                      RT_WAITING_FOREVER,
+                      &recved);
+
+        if (recved & RT_LINK_READ_CHECK_EVENT)
+        {
+            rt_link_frame_check();
+        }
+
+        if (recved & RT_LINK_SEND_READY_EVENT)
+        {
+            rt_link_send_ready();
+        }
+
+        if (recved & RT_LINK_SEND_TIMEOUT_EVENT)
+        {
+            rt_link_send_timeout();
+        }
+
+        if (recved & RT_LINK_RECV_TIMEOUT_FRAME_EVENT)
+        {
+            rt_link_frame_recv_timeout();
+        }
+
+        if (recved & RT_LINK_RECV_TIMEOUT_LONG_EVENT)
+        {
+            rt_link_long_recv_timeout();
+        }
+    }
+}
+
+static void rt_link_sendtimer_callback(void *parameter)
+{
+    rt_uint32_t count = (rt_uint32_t)rt_link_scb->sendtimer.parameter + 1;
+    rt_link_scb->sendtimer.parameter = (void *)count;
+    rt_event_send(&rt_link_scb->event, RT_LINK_SEND_TIMEOUT_EVENT);
+}
+
+static void rt_link_recvtimer_callback(void *parameter)
+{
+    rt_event_send(&rt_link_scb->event, RT_LINK_RECV_TIMEOUT_FRAME_EVENT);
+}
+
+static void rt_link_receive_long_frame_callback(void *parameter)
+{
+    rt_uint32_t count = (rt_uint32_t)rt_link_scb->longframetimer.parameter + 1;
+    rt_link_scb->longframetimer.parameter = (void *)count;
+    rt_event_send(&rt_link_scb->event, RT_LINK_RECV_TIMEOUT_LONG_EVENT);
+}
+
+/**
+ * rtlink send data interface
+ * @param service   Registered service channel, struct rt_link_service
+ * @param data      send data
+ * @param size      send data size
+ * @return The actual size of the data sent
+ * */
+rt_size_t rt_link_send(struct rt_link_service *service, const void *data, rt_size_t size)
+{
+    RT_ASSERT(service != RT_NULL);
+
+    rt_uint32_t recved = 0;
+    rt_uint8_t total = 0; /* The total number of frames to send */
+    rt_uint8_t index = 0; /* The index of the split packet */
+    rt_size_t offset = 0; /* The offset of the send data */
+    rt_size_t send_len = 0;
+
+    struct rt_link_frame *send_frame = RT_NULL;
+    rt_link_frame_attr_e attribute = RT_LINK_SHORT_DATA_FRAME;
+
+    if ((size == 0) || (data == RT_NULL))
+    {
+        service->err = RT_LINK_ERR;
+        goto __exit;
+    }
+
+    service->err = RT_LINK_EOK;
+    if (size % RT_LINK_MAX_DATA_LENGTH == 0)
+    {
+        total = size / RT_LINK_MAX_DATA_LENGTH;
+    }
+    else
+    {
+        total = size / RT_LINK_MAX_DATA_LENGTH + 1;
+    }
+
+    if (total > RT_LINK_FRAMES_MAX)
+    {
+        service->err = RT_LINK_ENOMEM;
+        goto __exit;
+    }
+    else if (total > 1)
+    {
+        attribute =  RT_LINK_LONG_DATA_FRAME;
+    }
+
+    do
+    {
+        send_frame = rt_malloc(sizeof(struct rt_link_frame));
+        if (send_frame == RT_NULL)
+        {
+            service->err = RT_LINK_ENOMEM;
+            goto __exit;
+        }
+        rt_link_frame_init(send_frame, service->flag);
+        send_frame->head.sequence = ++rt_link_scb->tx_seq;
+        send_frame->head.service = service->service;
+        send_frame->real_data = (rt_uint8_t *)data + offset;
+        send_frame->index = index;
+        send_frame->total = total;
+
+        if (attribute == RT_LINK_LONG_DATA_FRAME)
+        {
+            send_frame->attribute = RT_LINK_LONG_DATA_FRAME;
+            if (offset + RT_LINK_MAX_DATA_LENGTH > size)
+            {
+                send_frame->data_len = size - offset;
+            }
+            else
+            {
+                send_frame->data_len = RT_LINK_MAX_DATA_LENGTH;
+                offset += RT_LINK_MAX_DATA_LENGTH;
+            }
+
+            rt_link_frame_extend_config(send_frame, RT_LINK_LONG_DATA_FRAME, size);
+        }
+        else
+        {
+            send_frame->attribute = RT_LINK_SHORT_DATA_FRAME;
+            send_frame->data_len = size;
+        }
+
+        /* append the frame on the tail of list */
+        LOG_D("append send slist, seq(%d), len(%d)", send_frame->head.sequence, send_frame->data_len);
+        rt_slist_append(&rt_link_scb->tx_data_slist, &send_frame->slist);
+
+        index++;
+        send_len += send_frame->data_len;
+    }while(total > index);
+
+    /* Notify the core thread to send packet */
+    rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
+
+    if (service->timeout_tx != RT_WAITING_NO)
+    {
+        /* Wait for the packet to send the result */
+        rt_err_t ret = rt_event_recv(&rt_link_scb->sendevent, (0x01 << service->service),
+                                     RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                                     service->timeout_tx, &recved);
+        if (ret == -RT_ETIMEOUT)
+        {
+            service->err = RT_LINK_ETIMEOUT;
+            send_len = 0;
+        }
+    }
+
+__exit:
+    return send_len;
+}
+
+void rtlink_status(void)
+{
+    rt_kprintf("rtlink(v%s) status:\n", RT_LINK_VER);
+    if (rt_link_scb != RT_NULL)
+    {
+        rt_kprintf("\tlink status=%d\n", rt_link_scb->state);
+
+        rt_kprintf("\trx seq=%d\n", rt_link_scb->rx_record.rx_seq);
+        rt_kprintf("\ttx seq=%d\n", rt_link_scb->tx_seq);
+        rt_kprintf("\trecv len=%d\n", rt_link_hw_recv_len(rt_link_scb->rx_buffer));
+
+        rt_tick_t state = 0;
+        rt_timer_control(&rt_link_scb->longframetimer, RT_TIMER_CTRL_GET_STATE, &state);
+        rt_kprintf("\tlong timer state=%d\n", state);
+        rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_GET_STATE, &state);
+        rt_kprintf("\tsend timer state=%d\n", state);
+
+        rt_kprintf("\tevent set=0x%08x\n", rt_link_scb->event.set);
+        if (rt_link_scb->tx_data_slist.next)
+        {
+            rt_slist_t *data = RT_NULL;
+            rt_slist_for_each(data, &rt_link_scb->tx_data_slist)
+            {
+                rt_kprintf("\tsend data list: serv %u\t", ((struct rt_link_frame_head *)data)->service);
+                rt_kprintf(" seq %u\t", ((struct rt_link_frame_head *)data)->sequence);
+                rt_kprintf(" len %u\n", ((struct rt_link_frame_head *)data)->length);
+            }
+        }
+        else
+        {
+            rt_kprintf("\tsend data list: NULL\n");
+        }
+
+        rt_uint8_t serv = RT_LINK_SERVICE_MAX - 1;
+        while (serv--)
+        {
+            rt_kprintf("\tservices [%d](0x%p)\n", serv, rt_link_scb->service[serv]);
+        }
+    }
+    else
+    {
+        rt_kprintf("status NULL, please check the initialization status!\n");
+    }
+}
+MSH_CMD_EXPORT(rtlink_status, Display RTLINK status);
+
+/**
+ * rtlink deinit the interface
+ * */
+rt_err_t rt_link_deinit(void)
+{
+    rt_enter_critical();
+    rt_link_hw_deinit();
+    if (rt_link_scb)
+    {
+        rt_timer_detach(&rt_link_scb->longframetimer);
+        rt_timer_detach(&rt_link_scb->sendtimer);
+        rt_timer_detach(&rt_link_scb->recvtimer);
+        rt_event_detach(&rt_link_scb->event);
+        rt_free(rt_link_scb);
+        rt_link_scb = RT_NULL;
+    }
+    rt_thread_t thread = rt_thread_find(RT_LINK_THREAD_NAME);
+    if (thread)
+    {
+        rt_thread_delete(thread);
+    }
+    rt_exit_critical();
+    return RT_EOK;
+}
+MSH_CMD_EXPORT(rt_link_deinit, rt link deinit);
+
+/**
+ * rtlink initializes the interface, usually automatically.
+ * @return int Function Execution Result
+ * */
+int rt_link_init(void)
+{
+    rt_err_t result = RT_EOK;
+    rt_thread_t thread = RT_NULL;
+
+    if (rt_link_scb != RT_NULL)
+    {
+        goto __exit;
+    }
+
+    rt_link_scb = rt_malloc(sizeof(struct rt_link_session));
+    if (rt_link_scb == RT_NULL)
+    {
+        result = -RT_ENOMEM;
+        goto __exit;
+    }
+
+    rt_memset(rt_link_scb, 0, sizeof(struct rt_link_session));
+    rt_event_init(&rt_link_scb->event, "rtlink", RT_IPC_FLAG_FIFO);
+    rt_event_control(&rt_link_scb->event, RT_IPC_CMD_RESET, RT_NULL);
+
+    rt_event_init(&rt_link_scb->sendevent, "send_rtlink", RT_IPC_FLAG_FIFO);
+    rt_event_control(&rt_link_scb->sendevent, RT_IPC_CMD_RESET, RT_NULL);
+
+    rt_timer_init(&rt_link_scb->sendtimer, "tx_time", rt_link_sendtimer_callback,
+                  RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC);
+    rt_timer_init(&rt_link_scb->recvtimer, "rx_time", rt_link_recvtimer_callback,
+                  RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT);
+    rt_timer_init(&rt_link_scb->longframetimer, "rxl_time", rt_link_receive_long_frame_callback,
+                  RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC);
+
+    rt_link_scb->rx_record.rx_seq = 255;
+
+    rt_slist_init(&rt_link_scb->tx_data_slist);
+    rt_link_scb->tx_seq = RT_LINK_INIT_FRAME_SEQENCE;
+
+    /* create rtlink core work thread */
+    thread = rt_thread_create(RT_LINK_THREAD_NAME,
+                              rt_link_thread,
+                              RT_NULL,
+                              RT_LINK_THREAD_STACK_SIZE,
+                              RT_LINK_THREAD_PRIORITY,
+                              RT_LINK_THREAD_TICK);
+    if (thread == RT_NULL)
+    {
+        result = -RT_ENOMEM;
+        goto __exit;
+    }
+    rt_thread_startup(thread);
+
+    rt_link_scb->state = RT_LINK_INIT;
+__exit:
+    if (result != RT_EOK)
+    {
+        LOG_E("rtlink init failed.");
+        rt_link_deinit();
+    }
+    else
+    {
+        LOG_I("rtlink init success(VER:%s).", RT_LINK_VER);
+    }
+    return result;
+}
+#ifdef RT_LINK_AUTO_INIT
+    INIT_ENV_EXPORT(rt_link_init);
+#endif
+MSH_CMD_EXPORT(rt_link_init, rt link init);
+
+/**
+ * rtlink service attach
+ * @param service   Registered service channel, struct rt_link_service
+ * @return Function Execution Result
+ * */
+rt_err_t rt_link_service_attach(struct rt_link_service *serv)
+{
+    RT_ASSERT(serv != RT_NULL);
+    if (serv->service >= RT_LINK_SERVICE_MAX)
+    {
+        LOG_W("Invalid parameter.");
+        return -RT_EINVAL;
+    }
+    rt_uint8_t seq = rt_link_scb->tx_seq;
+    rt_link_hw_init();
+    rt_link_scb->service[serv->service] = serv;
+    serv->state = RT_LINK_INIT;
+    LOG_I("rt link attach service[%02d].", serv->service);
+
+    if (rt_slist_next(&rt_link_scb->tx_data_slist))
+    {
+        struct rt_link_frame *frame = rt_container_of(rt_slist_next(&rt_link_scb->tx_data_slist), struct rt_link_frame, slist);
+        seq = frame->head.sequence;
+    }
+    rt_link_command_frame_send(serv->service, seq, RT_LINK_HANDSHAKE_FRAME, rt_link_scb->rx_record.rx_seq);
+    return RT_EOK;
+}
+
+/**
+ * rtlink service detach
+ * @param service   Registered service channel, struct rt_link_service
+ * @return rt_err_t Function Execution Result
+ * */
+rt_err_t rt_link_service_detach(struct rt_link_service *serv)
+{
+    RT_ASSERT(serv != RT_NULL);
+    if (serv->service >= RT_LINK_SERVICE_MAX)
+    {
+        LOG_W("Invalid parameter.");
+        return -RT_EINVAL;
+    }
+    rt_link_command_frame_send(serv->service,
+                               rt_link_scb->tx_seq,
+                               RT_LINK_DETACH_FRAME,
+                               rt_link_scb->rx_record.rx_seq);
+
+    serv->state = RT_LINK_DISCONN;
+    rt_link_scb->service[serv->service] = RT_NULL;
+    LOG_I("rt link detach service[%02d].", serv->service);
+    return RT_EOK;
+}
diff --git a/components/utilities/rt-link/src/rtlink_dev.c b/components/utilities/rt-link/src/rtlink_dev.c
new file mode 100644
index 0000000000..5eff1f9782
--- /dev/null
+++ b/components/utilities/rt-link/src/rtlink_dev.c
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-15     Sherman      the first version
+ */
+
+#define DBG_TAG    "RTLINK_DEV"
+#define DBG_LVL    DBG_LOG
+#include <rtdbg.h>
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <rtlink_dev.h>
+
+#define RTLINK_SERV(dev)  (((struct rt_link_device*)dev)->service)
+
+#ifdef RT_USING_POSIX
+#include <dfs_posix.h>
+#include <dfs_poll.h>
+
+int rtlink_fops_open(struct dfs_fd *fd)
+{
+    rt_uint16_t flags = 0;
+    rt_device_t device;
+
+    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;
+    }
+
+    device = (rt_device_t)fd->data;
+    if (fd->flags & O_NONBLOCK)
+    {
+        rt_device_control(device, RT_LINK_TX_NONBLOCKING | RT_LINK_RX_NONBLOCKING, RT_NULL);
+    }
+
+    return rt_device_open(device, flags);
+}
+
+int rtlink_fops_close(struct dfs_fd *fd)
+{
+    rt_device_t device;
+    device = (rt_device_t)fd->data;
+
+    rt_device_set_rx_indicate(device, RT_NULL);
+    return rt_device_close(device);
+}
+
+int rtlink_fops_ioctl(struct dfs_fd *fd, int cmd, void *args)
+{
+    rt_device_t device;
+    device = (rt_device_t)fd->data;
+
+    if (cmd == O_NONBLOCK)
+    {
+        return rt_device_control(device, RT_LINK_TX_NONBLOCKING | RT_LINK_RX_NONBLOCKING, RT_NULL);
+    }
+    else
+    {
+        return rt_device_control(device, cmd, args);
+    }
+}
+
+int rtlink_fops_read(struct dfs_fd *fd, void *buf, size_t count)
+{
+    int size = 0;
+    rt_device_t device;
+    device = (rt_device_t)fd->data;
+
+    size = rt_device_read(device, -1,  buf, count);
+    if (size <= 0)
+    {
+        size = -EAGAIN;
+    }
+    return size;
+}
+
+int rtlink_fops_write(struct dfs_fd *fd, const void *buf, size_t count)
+{
+    int size = 0;
+    rt_device_t device;
+    device = (rt_device_t)fd->data;
+
+    size = rt_device_write(device, -1, buf, count);
+    if (size <= 0)
+    {
+        size = -EAGAIN;
+    }
+    return size;
+}
+
+int rtlink_fops_poll(struct dfs_fd *fd, struct rt_pollreq *req)
+{
+    int mask = 0;
+    int flags = 0;
+    rt_device_t device;
+    struct rt_link_device *rtlink_dev;
+
+    device = (rt_device_t)fd->data;
+    RT_ASSERT(device != RT_NULL);
+
+    rtlink_dev = (struct rt_link_device *)device;
+
+    flags = fd->flags & O_ACCMODE;
+    if (flags == O_RDONLY || flags == O_RDWR)
+    {
+        rt_base_t level;
+        rt_poll_add(&(device->wait_queue), req);
+
+        level = rt_hw_interrupt_disable();
+        if (RT_NULL != rt_slist_first(&rtlink_dev->recv_head))
+            mask |= POLLIN;
+        rt_hw_interrupt_enable(level);
+    }
+    mask |= POLLOUT;
+
+    return mask;
+}
+
+const static struct dfs_file_ops _rtlink_fops =
+{
+    rtlink_fops_open,
+    rtlink_fops_close,
+    rtlink_fops_ioctl,
+    rtlink_fops_read,
+    rtlink_fops_write,
+    RT_NULL, /* flush */
+    RT_NULL, /* lseek */
+    RT_NULL, /* getdents */
+    rtlink_fops_poll,
+};
+#endif /* RT_USING_POSIX */
+
+/* The event type for the service channel number,
+ * which is used to wake up the service thread in blocking receive mode */
+struct rt_event recv_event;
+
+static rt_err_t rt_link_event_send(struct rt_link_service *serv)
+{
+    RT_ASSERT(serv != RT_NULL);
+    RT_ASSERT(serv->service < RT_LINK_SERVICE_MAX);
+    rt_uint32_t set = 0x01 << serv->service;
+    return rt_event_send(&recv_event, set);
+}
+
+static rt_err_t rt_link_event_recv(struct rt_link_service *service)
+{
+    RT_ASSERT(service != RT_NULL);
+    RT_ASSERT(service->service < RT_LINK_SERVICE_MAX);
+
+    rt_uint32_t set = 0x01 << service->service;
+    rt_uint32_t recved = 0;
+    rt_err_t ret = rt_event_recv(&recv_event,
+                                 set,
+                                 RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
+                                 RT_WAITING_FOREVER,
+                                 &recved);
+    if (recved & set)
+    {
+        return ret;
+    }
+    return RT_ERROR;
+}
+
+static void send_cb(struct rt_link_service *service, void *buffer)
+{
+    RT_ASSERT(service != RT_NULL);
+    RT_ASSERT(buffer != RT_NULL);
+    struct rt_link_device *rtlink = (struct rt_link_device *)service->user_data;
+
+    if (rtlink && rtlink->parent.tx_complete)
+    {
+        rtlink->parent.tx_complete(&rtlink->parent, buffer);
+    }
+}
+
+static void recv_cb(struct rt_link_service *service, void *data, rt_size_t size)
+{
+    RT_ASSERT(service != RT_NULL);
+    struct rt_link_device *rtlink = (struct rt_link_device *)service->user_data;
+
+    if (rtlink)
+    {
+        struct rtlink_recv_list *node = rt_malloc(sizeof(struct rtlink_recv_list));
+        node->data = data;
+        node->size = size;
+        node->index = 0;
+        rt_slist_append(&rtlink->recv_head, &node->list);
+        rt_link_event_send(service);
+
+        if (rtlink->parent.rx_indicate)
+        {
+            rtlink->parent.rx_indicate(&rtlink->parent, size);
+        }
+    }
+    else
+    {
+        rt_free(data);
+    }
+}
+
+rt_err_t  rt_link_dev_init(rt_device_t dev)
+{
+    RT_ASSERT(dev != RT_NULL);
+
+    dev->rx_indicate = RT_NULL;
+    dev->tx_complete = RT_NULL;
+
+    struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+    rtlink->service.service = RT_LINK_SERVICE_MAX;
+    rtlink->service.recv_cb = RT_NULL;
+    rtlink->service.send_cb = RT_NULL;
+    rtlink->service.timeout_tx = RT_WAITING_NO;
+    rtlink->service.user_data = (void *)dev;
+
+    rt_slist_init(&rtlink->recv_head);
+    return RT_EOK;
+}
+
+rt_err_t  rt_link_dev_open(rt_device_t dev, rt_uint16_t oflag)
+{
+    RT_ASSERT(dev != RT_NULL);
+    struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+
+    rtlink->service.recv_cb = recv_cb;
+    rtlink->service.send_cb = send_cb;
+
+    dev->open_flag = oflag & RT_DEVICE_OFLAG_MASK;
+    if (dev->open_flag == RT_DEVICE_OFLAG_RDONLY)
+    {
+        rtlink->service.send_cb = RT_NULL;
+    }
+    else if (dev->open_flag == RT_DEVICE_OFLAG_WRONLY)
+    {
+        rtlink->service.recv_cb = RT_NULL;
+    }
+    return rt_link_service_attach(&rtlink->service);
+}
+
+rt_err_t  rt_link_dev_close(rt_device_t dev)
+{
+    RT_ASSERT(dev != RT_NULL);
+    struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+    return rt_link_service_detach(&rtlink->service);
+}
+
+rt_size_t rt_link_dev_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
+{
+    RT_ASSERT(dev != RT_NULL);
+    RT_ASSERT(buffer != RT_NULL);
+    RT_ASSERT(size != 0);
+
+    struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+    struct rtlink_recv_list *node;
+    rt_size_t read_len = 0;
+    rt_size_t unread_len = 0;
+
+    if (dev->rx_indicate == RT_NULL)
+    {
+        /* RT_LINK_RX_BLOCKING, wait service receive data event */
+        rt_link_event_recv(&rtlink->service);
+    }
+
+    if (rt_slist_first(&rtlink->recv_head) != RT_NULL)
+    {
+        node = rt_container_of(rt_slist_next(&rtlink->recv_head), struct rtlink_recv_list, list);
+        unread_len = (node->size) - (node->index);
+        read_len = (size > unread_len) ? unread_len : size;
+        rt_memcpy(buffer, (rt_uint8_t *)node->data + node->index, read_len);
+        node->index += read_len;
+
+        if (node->index >= node->size)
+        {
+            rt_slist_remove(&rtlink->recv_head, &node->list);
+            node->index = 0;
+            rt_free(node->data);
+            rt_free(node);
+        }
+        if (rt_slist_first(&rtlink->recv_head) != RT_NULL)
+        {
+            rt_link_event_send(&rtlink->service);
+        }
+    }
+    return read_len;
+}
+
+rt_size_t rt_link_dev_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
+{
+    RT_ASSERT(dev != RT_NULL);
+    RT_ASSERT(buffer != RT_NULL);
+    RT_ASSERT(size != 0);
+
+    return rt_link_send(&RTLINK_SERV(dev), buffer, size);
+}
+
+rt_err_t  rt_link_dev_control(rt_device_t dev, int cmd, void *args)
+{
+    RT_ASSERT(dev != RT_NULL);
+
+    if (cmd & RT_DEVICE_CTRL_CONFIG)
+    {
+        if (args == RT_NULL)
+            return RT_EINVAL;
+        RTLINK_SERV(dev).service = ((struct rt_link_service *)args)->service;
+        RTLINK_SERV(dev).timeout_tx = ((struct rt_link_service *)args)->timeout_tx;
+        RTLINK_SERV(dev).flag = ((struct rt_link_service *)args)->flag;
+    }
+
+    if (cmd & RT_LINK_RX_BLOCKING)
+    {
+        dev->rx_indicate = RT_NULL;
+    }
+    if (cmd & RT_LINK_TX_BLOCKING)
+    {
+        RTLINK_SERV(dev).timeout_tx = RT_WAITING_FOREVER;
+        dev->tx_complete = RT_NULL;
+    }
+    if (cmd & RT_LINK_TX_NONBLOCKING)
+    {
+        RTLINK_SERV(dev).timeout_tx = RT_WAITING_NO;
+    }
+
+    return RT_EOK;
+}
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops rtlink_ops =
+{
+    rt_link_dev_init,
+    rt_link_dev_open,
+    rt_link_dev_close,
+    rt_link_dev_read,
+    rt_link_dev_write,
+    rt_link_dev_control
+};
+#endif /* RT_USING_DEVICE_OPS */
+
+/*
+ * rtlink device register
+ */
+rt_err_t rt_link_dev_register(struct rt_link_device *rtlink,
+                              const char              *name,
+                              rt_uint32_t              flag,
+                              void                    *data)
+{
+    rt_err_t ret;
+    struct rt_device *device;
+    RT_ASSERT(rtlink != RT_NULL);
+
+    device = (struct rt_device *)rtlink;
+    device->type        = RT_Device_Class_Char;
+    device->rx_indicate = RT_NULL;
+    device->tx_complete = RT_NULL;
+
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &rtlink_ops;
+#else
+    device->init        = rt_link_dev_init;
+    device->open        = rt_link_dev_open;
+    device->close       = rt_link_dev_close;
+    device->read        = rt_link_dev_read;
+    device->write       = rt_link_dev_write;
+    device->control     = rt_link_dev_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        = &_rtlink_fops;
+#endif
+
+    rt_event_init(&recv_event, "rtlink_dev", RT_IPC_FLAG_FIFO);
+    return ret;
+}
diff --git a/components/utilities/rt-link/src/rtlink_hw.c b/components/utilities/rt-link/src/rtlink_hw.c
new file mode 100644
index 0000000000..696ab5b78a
--- /dev/null
+++ b/components/utilities/rt-link/src/rtlink_hw.c
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-02-02     xiangxistu   the first version
+ * 2021-05-08     Sherman      Optimize the operation function on the rt_link_receive_buffer
+ */
+
+#include <rtthread.h>
+
+#include <rtlink.h>
+#include <rtlink_hw.h>
+#include <rtlink_port.h>
+#include <rtlink_utils.h>
+
+#define DBG_TAG "rtlink_hw"
+#ifdef USING_RT_LINK_HW_DEBUG
+    #define DBG_LVL DBG_LOG
+#else
+    #define DBG_LVL DBG_INFO
+#endif
+#define DBG_COLOR
+#include <rtdbg.h>
+
+static struct rt_link_receive_buffer *rx_buffer = RT_NULL;
+
+struct rt_link_receive_buffer *rt_link_hw_buffer_init(void *parameter)
+{
+    rx_buffer = rt_malloc(sizeof(struct rt_link_receive_buffer));
+    if (rx_buffer != RT_NULL)
+    {
+        rt_memset(rx_buffer, 0, sizeof(struct rt_link_receive_buffer));
+        rx_buffer->read_point = rx_buffer->data;
+        rx_buffer->write_point = rx_buffer->data;
+        rx_buffer->end_point = rx_buffer->data + RT_LINK_RECEIVE_BUFFER_LENGTH; /* Point to memory that has no access rights */
+    }
+    else
+    {
+        LOG_E("receive buffer alloc failed, init failed.");
+    }
+
+    return rx_buffer;
+}
+
+static rt_size_t rt_link_hw_buffer_write(void *data, rt_size_t count)
+{
+    int surplus = 0;
+    if (rx_buffer == RT_NULL)
+    {
+        return 0;
+    }
+    /* (data)----(r)----(w)----(end) */
+    if (rx_buffer->write_point >= rx_buffer->read_point)
+    {
+        rt_size_t w2end = rx_buffer->end_point - rx_buffer->write_point;
+        surplus = RT_LINK_RECEIVE_BUFFER_LENGTH - (rx_buffer->write_point - rx_buffer->read_point);
+        count = count > surplus ? surplus : count;
+        if (count >= w2end)
+        {
+            rt_memcpy(rx_buffer->write_point, data, w2end);
+            rx_buffer->write_point = rx_buffer->data;
+
+            rt_memcpy(rx_buffer->write_point, (rt_uint8_t *)data + w2end, (count - w2end));
+            rx_buffer->write_point += (count - w2end);
+        }
+        else
+        {
+            rt_memcpy(rx_buffer->write_point, data, count);
+            rx_buffer->write_point += count;
+        }
+    }
+    else    /* (data)----(w)----(r)----(end) */
+    {
+        surplus = rx_buffer->read_point - rx_buffer->write_point;
+        count = count > surplus ? surplus : count;
+        rt_memcpy(rx_buffer->write_point, data, count);
+        rx_buffer->write_point += count;
+    }
+    return count;
+}
+
+/* increases buffer pointer by one and circle around if necessary */
+void rt_link_hw_buffer_point_shift(rt_uint8_t **pointer_address, rt_size_t length)
+{
+    rt_uint8_t *pointer = *pointer_address + length;
+
+    if (rx_buffer->write_point >= rx_buffer->read_point)
+    {
+        if (pointer >= rx_buffer->write_point)
+        {
+            *pointer_address = rx_buffer->write_point;
+        }
+        else
+        {
+            *pointer_address = pointer;
+        }
+    }
+    else
+    {
+        if (pointer >= rx_buffer->end_point)
+        {
+            *pointer_address = rx_buffer->data;
+            pointer = pointer - rx_buffer->end_point + rx_buffer->data;
+
+            if (pointer >= rx_buffer->write_point)
+            {
+                *pointer_address = rx_buffer->write_point;
+            }
+            else
+            {
+                *pointer_address = pointer;
+            }
+        }
+        else
+        {
+            *pointer_address = pointer;
+        }
+    }
+}
+
+/* copy data from receive buffer */
+void rt_link_hw_copy(rt_uint8_t *dst, rt_uint8_t *src, rt_size_t count)
+{
+    rt_uint8_t *pointer = RT_NULL;
+
+    pointer = src + count;
+    if (pointer >= rx_buffer->end_point)
+    {
+        rt_size_t offset = 0;
+        offset = rx_buffer->end_point - src;
+        rt_memcpy(dst, src, offset);
+        rt_memcpy(dst + offset,  rx_buffer->data, pointer - rx_buffer->end_point);
+    }
+    else
+    {
+        rt_memcpy(dst, src, count);
+    }
+}
+
+/* Length of data received */
+rt_size_t rt_link_hw_recv_len(struct rt_link_receive_buffer *buffer)
+{
+    if (buffer == RT_NULL)
+    {
+        return 0;
+    }
+    if (buffer->write_point >= buffer->read_point)
+    {
+        return (buffer->write_point - buffer->read_point);
+    }
+    else
+    {
+        return (RT_LINK_RECEIVE_BUFFER_LENGTH - (buffer->read_point - buffer->write_point));
+    }
+}
+
+rt_err_t rt_link_reset_crc32(void)
+{
+#ifdef RT_LINK_USING_HW_CRC
+    return rt_link_hw_crc32_reset();
+#else
+    return rt_link_sf_crc32_reset();
+#endif
+}
+
+rt_uint32_t rt_link_crc32(rt_uint8_t *data, rt_size_t u32_size)
+{
+#ifdef RT_LINK_USING_HW_CRC
+    return rt_link_hw_crc32(data, u32_size);
+#else
+    return rt_link_sf_crc32(data, u32_size);
+#endif
+}
+
+rt_uint32_t rt_link_get_crc(rt_uint8_t using_buffer_ring, rt_uint8_t *data, rt_size_t size)
+{
+    rt_uint32_t crc32 = 0x0;
+    rt_size_t surplus = 0;
+
+    if (data == RT_NULL)
+    {
+        LOG_D("warning, the parameter error: %d, data: 0x%08d.", size, data);
+        return 0;
+    }
+
+    rt_link_reset_crc32();
+    if (using_buffer_ring == 1)
+    {
+        /* modify the missing character */
+        surplus = rx_buffer->end_point - data;
+        if (surplus >= size)
+        {
+            crc32 = rt_link_crc32(data, size);
+        }
+        else
+        {
+            rt_link_crc32(data, surplus);
+            crc32 = rt_link_crc32(rx_buffer->data, size - surplus);
+        }
+    }
+    else
+    {
+        crc32 = rt_link_crc32(data, size);
+    }
+    return crc32;
+}
+
+rt_size_t rt_link_hw_send(void *data, rt_size_t length)
+{
+    rt_size_t send_len = 0;
+    send_len = rt_link_port_send(data, length);
+    if (send_len <= 0)
+    {
+        rt_link_port_reconnect();
+        send_len = rt_link_port_send(data, length);
+    }
+    return send_len;
+}
+
+rt_size_t rt_link_hw_write_cb(void *data, rt_size_t length)
+{
+    /* write real data into rtlink receive buffer */
+    rt_size_t len = rt_link_hw_buffer_write(data, length);
+    struct rt_link_session *scb = rt_link_get_scb();
+    if (scb)
+    {
+        rt_event_send(&scb->event, RT_LINK_READ_CHECK_EVENT);
+    }
+    return len;
+}
+
+rt_err_t rt_link_hw_init(void)
+{
+    struct rt_link_session *scb = rt_link_get_scb();
+    if ((rx_buffer != RT_NULL) || (scb == RT_NULL))
+    {
+        return -RT_ERROR;
+    }
+
+    /* alloc receive buffer to store data */
+    if (rt_link_hw_buffer_init(RT_NULL) == RT_NULL)
+    {
+        return -RT_ENOMEM;
+    }
+    scb->rx_buffer = rx_buffer;
+    scb->calculate_crc = rt_link_get_crc;
+
+    if (RT_EOK != rt_link_port_init())
+    {
+        return -RT_ERROR;
+    }
+
+#ifdef LINK_LAYER_USING_HW_CRC
+    /* crc hardware device for mcu and node */
+    if (RT_EOK != rt_link_hw_crc32_init())
+    {
+        return -RT_ERROR;
+    }
+#endif
+
+    LOG_I("link layer hardware environment init successful.");
+    return RT_EOK;
+}
+
+rt_err_t rt_link_hw_deinit(void)
+{
+    if (rx_buffer)
+    {
+        rt_free(rx_buffer);
+        rx_buffer = RT_NULL;
+    }
+    struct rt_link_session *scb = rt_link_get_scb();
+    if (scb)
+    {
+        scb->rx_buffer = rx_buffer;
+        scb->calculate_crc = RT_NULL;
+    }
+    if (RT_EOK != rt_link_port_deinit())
+    {
+        return -RT_ERROR;
+    }
+
+#ifdef LINK_LAYER_USING_HW_CRC
+    /* crc hardware device for mcu and node */
+    if (RT_EOK != rt_link_hw_crc32_deinit())
+    {
+        return -RT_ERROR;
+    }
+#endif
+
+    LOG_I("rtlink hardware deinit successful.");
+    return RT_EOK;
+}
diff --git a/components/utilities/rt-link/src/rtlink_utils.c b/components/utilities/rt-link/src/rtlink_utils.c
new file mode 100644
index 0000000000..c5cfbb9422
--- /dev/null
+++ b/components/utilities/rt-link/src/rtlink_utils.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-05-15     Sherman      the first version
+ */
+
+#include <rtlink_utils.h>
+
+/* Calculate the number of '1' */
+int rt_link_utils_num1(rt_uint32_t n)
+{
+    int ret = 0;
+    while (n)
+    {
+        n &= n - 1;
+        ret++;
+    }
+    return ret;
+}
+
+#ifdef RT_LINK_USING_SF_CRC
+
+static rt_uint32_t crc = 0xffffffff;
+const rt_uint32_t crc_table[256] =
+{
+    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
+    0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148,
+    0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0,
+    0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8,
+    0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF,
+    0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+    0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87,
+    0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+    0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
+    0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162,
+    0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6,
+    0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D,
+    0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
+    0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525,
+    0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+    0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C,
+    0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
+    0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
+    0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43,
+    0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767,
+    0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3,
+    0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92,
+    0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226,
+    0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82,
+    0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
+    0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
+    0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661,
+    0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+    0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330,
+    0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
+    0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+};
+
+rt_err_t rt_link_sf_crc32_reset(void)
+{
+    crc = 0xffffffff;
+    return RT_EOK;
+}
+
+rt_uint32_t rt_link_sf_crc32(rt_uint8_t *data, rt_size_t len)
+{
+    rt_uint32_t x, y;
+    x = 0;
+    y = 0;
+    rt_size_t i;
+
+    for (i = 0; i < len; i++)
+    {
+        y = (crc ^ data[i]) & 0xff;
+        x = crc_table[y];
+        crc = (crc >> 8) ^ x;
+    }
+    return (crc ^ 0xffffffff);
+}
+#endif /* RT_LINK_USING_SF_CRC */