first

rt-thread/components/drivers/ktime/Kconfig

@@ -0,0 +1,3 @@
+menuconfig RT_USING_KTIME
+    bool "Ktime: kernel time"
+    default n

rt-thread/components/drivers/ktime/README.md

@@ -0,0 +1,63 @@
+# ktime
+
+## 1、介绍
+
+ktime 为 kernel time，为内核时间子系统，实现了内核启动时间以及芯片内核 cputimer 时间管理以及一个 ns 精度的高精度定时器，
+
+## 2、如何打开 ktime
+
+使用 ktime 需要在 RT-Thread 的 menuconfig 中选择它，具体路径如下：
+
+```
+RT-Thread Components
+    [*] Ktime: kernel time
+```
+
+## 3、使用 ktime
+
+> 函数的功能以及参数类型已经写在头文件的注释之中，本文不再赘述
+
+### 3.1、boottime
+
+boottime 为系统启动时间，即为系统从上电开始到现在运行的时间，默认的时间基准为芯片内核的 cputimer 的 cnt 值，已经适配了 aarch64 与 riscv64 平台，例如 stm32 等平台需要在自己的 bsp 里面进行适配（boottime 里面函数都为 weak function），需要注意 tick 从中断到设置中间的时延
+
+**此值应当为 Readonly**
+
+### 3.2、cputimer
+
+cputimer 为芯片内核的 cputimer，也可以认为是 os tick 来源的那个定时器，cputimer 主要是提供了一个统一的接口去获得其分辨率，频率，cnt 值
+
+**此值应当为 Readonly**
+
+### 3.3、hrtimer
+
+> TODO: hrtimer 目前还是使用优先级链表的方式进行管理，在遇到任务的大规模并发时还是存在部分性能问题，待内核有一个统一的红黑树组件后，再进行优化
+
+hrtimer 为高精度定时器，需要重写其 weak 函数（需要对接到硬件定时器，否则默认走的是软件定时器，分辨率只有 os tick 的值）才能正常使用，其主要使用方法：
+
+#### 3.3.1、延时
+
+hrtimer 的延时并不是 while(1)式死等，它会将一个线程挂起，睡眠多少时间后通过硬件定时器将其唤醒（注：延时 ns 并不是真的能准确的延时这么多，而是在保证性能的情况下尽可能的延时）
+
+- rt_ktime_hrtimer_sleep：单位为 cputimer 的 tick 值
+- rt_ktime_hrtimer_ndelay：单位为 ns
+- rt_ktime_hrtimer_udelay：单位为 us
+- rt_ktime_hrtimer_mdelay：单位为 ms
+
+#### 3.3.1、定时器
+
+hrtimer 还提供了一套 rt_timer 风格的 api
+
+- rt_ktime_hrtimer_init
+- rt_ktime_hrtimer_delete
+- rt_ktime_hrtimer_start
+- rt_ktime_hrtimer_stop
+- rt_ktime_hrtimer_control
+- rt_ktime_hrtimer_detach
+
+需要注意，此定时器回调函数依旧处于中断之中，不能做一些耗时的任务
+
+## 5、联系方式
+
+- 维护：xqyjlj
+- 主页：https://github.com/xqyjlj

rt-thread/components/drivers/ktime/SConscript

@@ -0,0 +1,19 @@
+import os
+from building import *
+
+Import('rtconfig')
+
+cwd = GetCurrentDir()
+
+src = Glob('src/*.c')
+list = os.listdir(cwd + "/src")
+if rtconfig.ARCH in list:
+    if os.path.exists(cwd + "/src/" + rtconfig.ARCH + "/" + rtconfig.CPU):
+        src += Glob("src/" + rtconfig.ARCH + "/" + rtconfig.CPU + "/*.c")
+    else:
+        src += Glob("src/" + rtconfig.ARCH + "/*.c")
+CPPPATH = [cwd, cwd + "/inc"]
+
+group = DefineGroup('ktime', src, depend=['RT_USING_KTIME'], CPPPATH=CPPPATH)
+
+Return('group')

rt-thread/components/drivers/ktime/inc/ktime.h

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-07-10     xqyjlj       The first version.
+ * 2024-04-26     Shell        Improve ipc performance
+ */
+
+#ifndef __KTIME_H__
+#define __KTIME_H__
+
+#include <stdint.h>
+#include <sys/time.h>
+#include <ipc/completion.h>
+
+#include "rtthread.h"
+
+#define RT_KTIME_RESMUL (1000000ULL)
+
+struct rt_ktime_hrtimer
+{
+    rt_uint8_t           flag;                  /**< compatible to tick timer's flag */
+    char                 name[RT_NAME_MAX];
+    rt_list_t            node;
+    void                *parameter;
+    unsigned long        delay_cnt;
+    unsigned long        timeout_cnt;
+    rt_err_t             error;
+    struct rt_completion completion;
+    void (*timeout_func)(void *parameter);
+};
+typedef struct rt_ktime_hrtimer *rt_ktime_hrtimer_t;
+
+/**
+ * @brief Get boottime with us precision
+ *
+ * @param tv: timeval
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_boottime_get_us(struct timeval *tv);
+
+/**
+ * @brief Get boottime with s precision
+ *
+ * @param t: time_t
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_boottime_get_s(time_t *t);
+
+/**
+ * @brief Get boottime with ns precision
+ *
+ * @param ts: timespec
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_boottime_get_ns(struct timespec *ts);
+
+/**
+ * @brief Get cputimer resolution
+ *
+ * @return (resolution * RT_KTIME_RESMUL)
+ */
+rt_uint64_t rt_ktime_cputimer_getres(void);
+
+/**
+ * @brief Get cputimer frequency
+ *
+ * @return frequency
+ */
+unsigned long rt_ktime_cputimer_getfrq(void);
+
+/**
+ * @brief Get cputimer the value of the cnt counter
+ *
+ * @return cnt
+ */
+unsigned long rt_ktime_cputimer_getcnt(void);
+
+/**
+ * @brief Get cputimer the cnt value corresponding to 1 os tick
+ *
+ * @return step
+ */
+unsigned long rt_ktime_cputimer_getstep(void);
+
+/**
+ * @brief Init cputimer
+ *
+ */
+void rt_ktime_cputimer_init(void);
+
+/**
+ * @brief Get hrtimer resolution
+ *
+ * @return (resolution * RT_KTIME_RESMUL)
+ */
+rt_uint64_t rt_ktime_hrtimer_getres(void);
+
+/**
+ * @brief Get hrtimer frequency
+ *
+ * @return frequency
+ */
+unsigned long rt_ktime_hrtimer_getfrq(void);
+
+/**
+ * @brief Get hrtimer the value of the cnt counter
+ *
+ * @return cnt
+ */
+unsigned long rt_ktime_hrtimer_getcnt(void);
+
+/**
+ * @brief set hrtimer interrupt timeout count (cnt), you should re-implemented it in hrtimer device driver
+ *
+ * @param cnt: hrtimer requires a timing cnt value
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_hrtimer_settimeout(unsigned long cnt);
+
+/**
+ * @brief called in hrtimer device driver isr routinue, it will process the timeouts
+ */
+void     rt_ktime_hrtimer_process(void);
+
+void     rt_ktime_hrtimer_init(rt_ktime_hrtimer_t timer,
+                               const char        *name,
+                               rt_uint8_t         flag,
+                               void (*timeout)(void *parameter),
+                               void *parameter);
+rt_err_t rt_ktime_hrtimer_start(rt_ktime_hrtimer_t timer, unsigned long cnt);
+rt_err_t rt_ktime_hrtimer_stop(rt_ktime_hrtimer_t timer);
+rt_err_t rt_ktime_hrtimer_control(rt_ktime_hrtimer_t timer, int cmd, void *arg);
+rt_err_t rt_ktime_hrtimer_detach(rt_ktime_hrtimer_t timer);
+
+rt_inline void rt_ktime_hrtimer_keep_errno(rt_ktime_hrtimer_t timer, rt_err_t err)
+{
+    RT_ASSERT(timer != RT_NULL);
+
+    timer->error = err;
+    rt_set_errno(-err);
+}
+
+void rt_ktime_hrtimer_delay_init(struct rt_ktime_hrtimer *timer);
+void rt_ktime_hrtimer_delay_detach(struct rt_ktime_hrtimer *timer);
+void rt_ktime_hrtimer_process(void);
+
+/**
+ * @brief sleep by the cputimer cnt value
+ *
+ * @param cnt: the cputimer cnt value
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_hrtimer_sleep(struct rt_ktime_hrtimer *timer, unsigned long cnt);
+
+/**
+ * @brief sleep by ns
+ *
+ * @param ns: ns
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_hrtimer_ndelay(struct rt_ktime_hrtimer *timer, unsigned long ns);
+
+/**
+ * @brief sleep by us
+ *
+ * @param us: us
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_hrtimer_udelay(struct rt_ktime_hrtimer *timer, unsigned long us);
+
+/**
+ * @brief sleep by ms
+ *
+ * @param ms: ms
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_hrtimer_mdelay(struct rt_ktime_hrtimer *timer, unsigned long ms);
+
+#endif

rt-thread/components/drivers/ktime/src/aarch64/cputimer.c

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-07-10     xqyjlj       The first version.
+ */
+
+#include "gtimer.h"
+#include "ktime.h"
+
+static volatile unsigned long _init_cnt = 0;
+
+rt_uint64_t rt_ktime_cputimer_getres(void)
+{
+    return ((1000ULL * 1000 * 1000) * RT_KTIME_RESMUL) / rt_hw_get_gtimer_frq();
+}
+
+unsigned long rt_ktime_cputimer_getfrq(void)
+{
+    return rt_hw_get_gtimer_frq();
+}
+
+unsigned long rt_ktime_cputimer_getcnt(void)
+{
+    return rt_hw_get_cntpct_val() - _init_cnt;
+}
+
+unsigned long rt_ktime_cputimer_getstep(void)
+{
+    return rt_ktime_cputimer_getfrq() / RT_TICK_PER_SECOND;
+}
+
+void rt_ktime_cputimer_init(void)
+{
+    _init_cnt = rt_hw_get_cntpct_val();
+}

rt-thread/components/drivers/ktime/src/boottime.c

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-07-10     xqyjlj       The first version.
+ */
+
+#include "ktime.h"
+
+#define __KTIME_MUL ((1000ULL * 1000 * 1000) / RT_TICK_PER_SECOND)
+
+rt_weak rt_err_t rt_ktime_boottime_get_us(struct timeval *tv)
+{
+    RT_ASSERT(tv != RT_NULL);
+
+    rt_uint64_t ns = (rt_ktime_cputimer_getcnt() * rt_ktime_cputimer_getres()) / RT_KTIME_RESMUL;
+
+    tv->tv_sec  = ns / (1000ULL * 1000 * 1000);
+    tv->tv_usec = (ns % (1000ULL * 1000 * 1000)) / 1000;
+
+    return RT_EOK;
+}
+
+rt_weak rt_err_t rt_ktime_boottime_get_s(time_t *t)
+{
+    RT_ASSERT(t != RT_NULL);
+
+    rt_uint64_t ns = (rt_ktime_cputimer_getcnt() * rt_ktime_cputimer_getres()) / RT_KTIME_RESMUL;
+
+    *t = ns / (1000ULL * 1000 * 1000);
+
+    return RT_EOK;
+}
+
+rt_weak rt_err_t rt_ktime_boottime_get_ns(struct timespec *ts)
+{
+    RT_ASSERT(ts != RT_NULL);
+
+    rt_uint64_t ns = (rt_ktime_cputimer_getcnt() * rt_ktime_cputimer_getres()) / RT_KTIME_RESMUL;
+
+    ts->tv_sec  = ns / (1000ULL * 1000 * 1000);
+    ts->tv_nsec = ns % (1000ULL * 1000 * 1000);
+
+    return RT_EOK;
+}

rt-thread/components/drivers/ktime/src/cputimer.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-07-10     xqyjlj       The first version.
+ */
+
+#include "ktime.h"
+
+rt_weak rt_uint64_t rt_ktime_cputimer_getres(void)
+{
+    return ((1000ULL * 1000 * 1000) * RT_KTIME_RESMUL) / RT_TICK_PER_SECOND;
+}
+
+rt_weak unsigned long rt_ktime_cputimer_getfrq(void)
+{
+    return RT_TICK_PER_SECOND;
+}
+
+rt_weak unsigned long rt_ktime_cputimer_getcnt(void)
+{
+    return rt_tick_get();
+}
+
+rt_weak unsigned long rt_ktime_cputimer_getstep(void)
+{
+    return 1;
+}
+
+rt_weak void rt_ktime_cputimer_init(void)
+{
+    return;
+}

rt-thread/components/drivers/ktime/src/hrtimer.c

@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-07-10     xqyjlj       The first version.
+ * 2023-09-15     xqyjlj       perf rt_hw_interrupt_disable/enable
+ */
+
+#include <rtdevice.h>
+#include <rthw.h>
+#include <rtthread.h>
+
+#define DBG_SECTION_NAME               "drv.ktime"
+#define DBG_LEVEL                      DBG_INFO
+#include <rtdbg.h>
+
+#include "ktime.h"
+
+#ifdef ARCH_CPU_64BIT
+#define _HRTIMER_MAX_CNT UINT64_MAX
+#else
+#define _HRTIMER_MAX_CNT UINT32_MAX
+#endif
+
+static rt_list_t          _timer_list   = RT_LIST_OBJECT_INIT(_timer_list);
+static RT_DEFINE_SPINLOCK(_spinlock);
+
+rt_inline rt_ktime_hrtimer_t _first_hrtimer(void)
+{
+    return rt_list_isempty(&_timer_list) ? RT_NULL : rt_list_first_entry(&_timer_list, struct rt_ktime_hrtimer, node);
+}
+
+rt_weak rt_uint64_t rt_ktime_hrtimer_getres(void)
+{
+    return ((1000ULL * 1000 * 1000) * RT_KTIME_RESMUL) / RT_TICK_PER_SECOND;
+}
+
+rt_weak unsigned long rt_ktime_hrtimer_getfrq(void)
+{
+    return RT_TICK_PER_SECOND;
+}
+
+rt_weak unsigned long rt_ktime_hrtimer_getcnt(void)
+{
+    return rt_tick_get();
+}
+
+rt_weak rt_err_t rt_ktime_hrtimer_settimeout(unsigned long cnt)
+{
+    static rt_timer_t timer = RT_NULL;
+    static struct rt_timer _sh_rtimer;
+
+    RT_ASSERT(cnt > 0);
+
+    if (timer == RT_NULL)
+    {
+        timer = &_sh_rtimer;
+        rt_timer_init(timer, "shrtimer", (void (*)(void *))rt_ktime_hrtimer_process, RT_NULL, cnt, RT_TIMER_FLAG_ONE_SHOT);
+    }
+    else
+    {
+        rt_tick_t tick = cnt;
+        rt_timer_control(timer, RT_TIMER_CTRL_SET_TIME, &tick);
+        rt_timer_control(timer, RT_TIMER_CTRL_SET_PARM, RT_NULL);
+    }
+
+    if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)
+    {
+        rt_timer_stop(timer);
+    }
+
+    rt_timer_start(timer);
+    return RT_EOK;
+}
+
+/**
+ * @brief convert cnt from cputimer cnt to hrtimer cnt
+ *
+ * @param cnt
+ * @return unsigned long
+ */
+static unsigned long _cnt_convert(unsigned long cnt)
+{
+    unsigned long rtn   = 0;
+    unsigned long count = cnt - rt_ktime_cputimer_getcnt();
+    if (count > (_HRTIMER_MAX_CNT / 2))
+        return 0;
+
+    rtn = (count * rt_ktime_cputimer_getres()) / rt_ktime_hrtimer_getres();
+    return rtn == 0 ? 1 : rtn; /* at least 1 */
+}
+
+static void _sleep_timeout(void *parameter)
+{
+    struct rt_ktime_hrtimer *timer = parameter;
+    rt_completion_done(&timer->completion);
+}
+
+static void _insert_timer_to_list_locked(rt_ktime_hrtimer_t timer)
+{
+    rt_ktime_hrtimer_t iter;
+
+    rt_list_for_each_entry(iter, &_timer_list, node)
+    {
+        if (iter->timeout_cnt > timer->timeout_cnt)
+        {
+            break;
+        }
+    }
+    rt_list_insert_before(&iter->node, &(timer->node));
+
+    timer->flag |= RT_TIMER_FLAG_ACTIVATED;
+}
+
+static void _hrtimer_process_locked(void)
+{
+    rt_ktime_hrtimer_t timer;
+
+    for (timer = _first_hrtimer();
+        (timer != RT_NULL) && (timer->timeout_cnt <= rt_ktime_cputimer_getcnt());
+        timer = _first_hrtimer())
+    {
+        rt_list_remove(&(timer->node));
+
+        if (timer->flag & RT_TIMER_FLAG_PERIODIC)
+        {
+            timer->timeout_cnt = timer->delay_cnt + rt_ktime_cputimer_getcnt();
+            _insert_timer_to_list_locked(timer);
+        }
+        else
+        {
+            timer->flag &= ~RT_TIMER_FLAG_ACTIVATED;
+        }
+
+        if (timer->timeout_func)
+        {
+            timer->timeout_func(timer->parameter);
+        }
+    }
+}
+
+static void _set_next_timeout_locked(void)
+{
+    rt_ktime_hrtimer_t timer;
+    rt_ubase_t next_timeout_hrtimer_cnt;
+    rt_bool_t find_next;
+
+    do
+    {
+        find_next = RT_FALSE;
+        if ((timer = _first_hrtimer()) != RT_NULL)
+        {
+            next_timeout_hrtimer_cnt = _cnt_convert(timer->timeout_cnt);
+            if (next_timeout_hrtimer_cnt > 0)
+            {
+                rt_ktime_hrtimer_settimeout(next_timeout_hrtimer_cnt);
+            }
+            else
+            {
+                _hrtimer_process_locked();
+                find_next = RT_TRUE;
+            }
+        }
+    }
+    while (find_next);
+}
+
+void rt_ktime_hrtimer_process(void)
+{
+    rt_base_t level = rt_spin_lock_irqsave(&_spinlock);
+
+    _hrtimer_process_locked();
+    _set_next_timeout_locked();
+
+    rt_spin_unlock_irqrestore(&_spinlock, level);
+}
+
+void rt_ktime_hrtimer_init(rt_ktime_hrtimer_t timer,
+                           const char        *name,
+                           rt_uint8_t         flag,
+                           void (*timeout)(void *parameter),
+                           void *parameter)
+{
+    /* parameter check */
+    RT_ASSERT(timer != RT_NULL);
+    RT_ASSERT(timeout != RT_NULL);
+
+    rt_memset(timer, 0, sizeof(struct rt_ktime_hrtimer));
+
+    timer->flag         = flag & ~RT_TIMER_FLAG_ACTIVATED;
+    timer->timeout_func = timeout;
+    timer->parameter    = parameter;
+    rt_strncpy(timer->name, name, RT_NAME_MAX - 1);
+    rt_list_init(&(timer->node));
+    rt_completion_init(&timer->completion);
+}
+
+rt_err_t rt_ktime_hrtimer_start(rt_ktime_hrtimer_t timer, unsigned long delay_cnt)
+{
+    rt_base_t  level;
+
+    /* parameter check */
+    RT_ASSERT(timer != RT_NULL);
+    RT_ASSERT(delay_cnt < (_HRTIMER_MAX_CNT / 2));
+
+    timer->delay_cnt    = delay_cnt;
+    timer->timeout_cnt  = timer->delay_cnt + rt_ktime_cputimer_getcnt();
+
+    level = rt_spin_lock_irqsave(&_spinlock);
+
+    if (timer->flag & RT_TIMER_FLAG_ACTIVATED)
+    {
+        rt_spin_unlock_irqrestore(&_spinlock, level);
+        return -RT_ERROR;
+    }
+
+    _insert_timer_to_list_locked(timer);
+    _set_next_timeout_locked();
+
+    rt_spin_unlock_irqrestore(&_spinlock, level);
+
+    return RT_EOK;
+}
+
+rt_err_t rt_ktime_hrtimer_stop(rt_ktime_hrtimer_t timer)
+{
+    rt_base_t level;
+
+    RT_ASSERT(timer != RT_NULL); /* timer check */
+
+    level = rt_spin_lock_irqsave(&_spinlock);
+
+    if (!(timer->flag & RT_TIMER_FLAG_ACTIVATED))
+    {
+        rt_spin_unlock_irqrestore(&_spinlock, level);
+        return -RT_ERROR;
+    }
+
+    rt_list_remove(&timer->node);
+    timer->flag &= ~RT_TIMER_FLAG_ACTIVATED;
+    _set_next_timeout_locked();
+
+    rt_spin_unlock_irqrestore(&_spinlock, level);
+
+    return RT_EOK;
+}
+
+rt_err_t rt_ktime_hrtimer_control(rt_ktime_hrtimer_t timer, int cmd, void *arg)
+{
+    rt_base_t level;
+
+    /* parameter check */
+    RT_ASSERT(timer != RT_NULL);
+
+    level = rt_spin_lock_irqsave(&_spinlock);
+    switch (cmd)
+    {
+
+    case RT_TIMER_CTRL_GET_TIME:
+        *(unsigned long *)arg = timer->delay_cnt;
+        break;
+
+    case RT_TIMER_CTRL_SET_TIME:
+        RT_ASSERT((*(unsigned long *)arg) < (_HRTIMER_MAX_CNT / 2));
+        timer->delay_cnt    = *(unsigned long *)arg;
+        timer->timeout_cnt  = *(unsigned long *)arg + rt_ktime_cputimer_getcnt();
+        break;
+
+    case RT_TIMER_CTRL_SET_ONESHOT:
+        timer->flag &= ~RT_TIMER_FLAG_PERIODIC;
+        break;
+
+    case RT_TIMER_CTRL_SET_PERIODIC:
+        timer->flag |= RT_TIMER_FLAG_PERIODIC;
+        break;
+
+    case RT_TIMER_CTRL_GET_STATE:
+        if (timer->flag & RT_TIMER_FLAG_ACTIVATED)
+        {
+            /*timer is start and run*/
+            *(rt_uint32_t *)arg = RT_TIMER_FLAG_ACTIVATED;
+        }
+        else
+        {
+            /*timer is stop*/
+            *(rt_uint32_t *)arg = RT_TIMER_FLAG_DEACTIVATED;
+        }
+        break;
+
+    case RT_TIMER_CTRL_GET_REMAIN_TIME:
+        *(unsigned long *)arg = timer->timeout_cnt;
+        break;
+    case RT_TIMER_CTRL_GET_FUNC:
+        arg = (void *)timer->timeout_func;
+        break;
+
+    case RT_TIMER_CTRL_SET_FUNC:
+        timer->timeout_func = (void (*)(void *))arg;
+        break;
+
+    case RT_TIMER_CTRL_GET_PARM:
+        *(void **)arg = timer->parameter;
+        break;
+
+    case RT_TIMER_CTRL_SET_PARM:
+        timer->parameter = arg;
+        break;
+
+    default:
+        break;
+    }
+    rt_spin_unlock_irqrestore(&_spinlock, level);
+
+    return RT_EOK;
+}
+
+rt_err_t rt_ktime_hrtimer_detach(rt_ktime_hrtimer_t timer)
+{
+    rt_base_t level;
+
+    /* parameter check */
+    RT_ASSERT(timer != RT_NULL);
+
+    /* notify the timer stop event */
+    rt_completion_wakeup_by_errno(&timer->completion, RT_ERROR);
+
+    level = rt_spin_lock_irqsave(&_spinlock);
+
+    /* stop timer */
+    timer->flag &= ~RT_TIMER_FLAG_ACTIVATED;
+    /* when interrupted */
+    if (timer->error == -RT_EINTR || timer->error == RT_EINTR)
+    {
+        rt_list_remove(&timer->node);
+        _set_next_timeout_locked();
+    }
+
+    rt_spin_unlock_irqrestore(&_spinlock, level);
+
+    return RT_EOK;
+}
+
+/************************** delay ***************************/
+
+void rt_ktime_hrtimer_delay_init(struct rt_ktime_hrtimer *timer)
+{
+    rt_ktime_hrtimer_init(timer, "hrtimer_sleep", RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_HARD_TIMER,
+                          _sleep_timeout, timer);
+}
+
+void rt_ktime_hrtimer_delay_detach(struct rt_ktime_hrtimer *timer)
+{
+    rt_ktime_hrtimer_detach(timer);
+}
+
+rt_err_t rt_ktime_hrtimer_sleep(struct rt_ktime_hrtimer *timer, unsigned long cnt)
+{
+    rt_err_t err;
+
+    if (cnt == 0)
+        return -RT_EINVAL;
+
+    err = rt_ktime_hrtimer_start(timer, cnt);
+    if (err)
+        return err;
+
+    err = rt_completion_wait_flags(&(timer->completion), RT_WAITING_FOREVER,
+                                   RT_INTERRUPTIBLE);
+    rt_ktime_hrtimer_keep_errno(timer, err);
+
+    return err;
+}
+
+rt_err_t rt_ktime_hrtimer_ndelay(struct rt_ktime_hrtimer *timer, unsigned long ns)
+{
+    rt_uint64_t res = rt_ktime_cputimer_getres();
+    return rt_ktime_hrtimer_sleep(timer, (ns * RT_KTIME_RESMUL) / res);
+}
+
+rt_err_t rt_ktime_hrtimer_udelay(struct rt_ktime_hrtimer *timer, unsigned long us)
+{
+    return rt_ktime_hrtimer_ndelay(timer, us * 1000);
+}
+
+rt_err_t rt_ktime_hrtimer_mdelay(struct rt_ktime_hrtimer *timer, unsigned long ms)
+{
+    return rt_ktime_hrtimer_ndelay(timer, ms * 1000000);
+}

rt-thread/components/drivers/ktime/src/risc-v/virt64/cputimer.c

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-07-10     xqyjlj       The first version.
+ */
+
+#include "ktime.h"
+
+static volatile unsigned long _init_cnt = 0;
+
+rt_uint64_t rt_ktime_cputimer_getres(void)
+{
+    return ((1000ULL * 1000 * 1000) * RT_KTIME_RESMUL) / CPUTIME_TIMER_FREQ;
+}
+
+unsigned long rt_ktime_cputimer_getfrq(void)
+{
+    return CPUTIME_TIMER_FREQ;
+}
+
+unsigned long rt_ktime_cputimer_getcnt(void)
+{
+    unsigned long time_elapsed;
+    __asm__ __volatile__("rdtime %0" : "=r"(time_elapsed));
+    return time_elapsed - _init_cnt;
+}
+
+unsigned long rt_ktime_cputimer_getstep(void)
+{
+    return rt_ktime_cputimer_getfrq() / RT_TICK_PER_SECOND;
+}
+
+void rt_ktime_cputimer_init(void)
+{
+    __asm__ __volatile__("rdtime %0" : "=r"(_init_cnt));
+}