[components][clock_time] Refactor time subsystem around clock_time (#11111)

* [components][clock_time] Refactor time subsystem around clock_time

Introduce the clock_time core with clock source/event separation, high-resolution scheduling, and boot-time helpers, plus clock_timer adapters for timer peripherals.

Remove legacy ktime/cputime/hwtimer implementations and migrate arch and BSP time paths to the new subsystem while keeping POSIX time integration functional.

Update drivers, Kconfig/SConscript wiring, documentation, and tests; add clock_time overview docs and align naming to clock_boottime/clock_hrtimer/clock_timer.

* [components][clock_time] Use BSP-provided clock timer frequency on riscv64

* [risc-v] Use runtime clock timer frequency for tick and delays

* [bsp] Add clock timer frequency hooks for riscv64 boards

* [bsp] Update Renesas RA driver doc clock_timer link

* [bsp] Sync zynqmp-r5-axu4ev rtconfig after config refresh

* [bsp][rk3500] Update rk3500 clock configuration

* [bsp][hpmicro] Add rt_hw_us_delay hook and update board delays

* [bsp][stm32l496-st-nucleo] enable clock_time for hwtimer sample in ci

* [bsp][hpmicro] Fix rtconfig include scope for hpm6750evk

Move rtconfig.h include outside the ENET_MULTIPLE_PORT guard for hpm6750evk and hpm6750evk2 so configuration macros are available regardless of ENET settings.

* [bsp][raspi3] select clock time for systimer

* [bsp][hpm5300evk] Trim trailing blank line

* [bsp][hpm5301evklite] Trim trailing blank line

* [bsp][hpm5e00evk] Trim trailing blank line

* [bsp][hpm6200evk] Trim trailing blank line

* [bsp][hpm6300evk] Trim trailing blank line

* [bsp][hpm6750evk] Trim trailing blank line

* [bsp][hpm6750evk2] Trim trailing blank line

* [bsp][hpm6750evkmini] Trim trailing blank line

* [bsp][hpm6800evk] Trim trailing blank line

* [bsp][hpm6e00evk] Trim trailing blank line

* [bsp][nxp] switch lpc178x to gcc and remove mcx timer source

* [bsp][stm32] fix the CONFIG_RT_USING_CLOCK_TIME issue.

* [docs][clock_time] add clock time documentation

* [docs][clock_time] Update clock time subsystem documentation

- Update device driver index to use correct page reference
- Clarify upper layer responsibilities in architecture overview
- Update README to describe POSIX/libc, Soft RTC, and device driver usage
- Refine architecture diagram with improved layout and color scheme
- Remove obsolete clock_timer.md file

* [kernel][utest] Trim trailing space

* [clock_time] Fix hrtimer wrap handling

* [clock_time] fix the static rt_inline issue

* [clock_time] fix the rt_clock_hrtimer_control result issue

1 files changed, 38 insertions, 38 deletions

diff --git a/components/libc/compilers/common/ctime.c b/components/libc/compilers/common/ctime.c
index bcd19fc8aa..5e89097b27 100644
--- a/components/libc/compilers/common/ctime.c
+++ b/components/libc/compilers/common/ctime.c
@@ -42,8 +42,8 @@
 #ifdef RT_USING_POSIX_DELAY
 #include <delay.h>
 #endif
-#ifdef RT_USING_KTIME
-#include <ktime.h>
+#ifdef RT_USING_CLOCK_TIME
+#include <drivers/clock_time.h>
 #endif
 
 #define DBG_TAG    "time"
@@ -536,14 +536,14 @@ int settimeofday(const struct timeval *tv, const struct timezone *tz)
 }
 RTM_EXPORT(settimeofday);
 
-#if defined(RT_USING_POSIX_DELAY) && defined(RT_USING_KTIME)
+#if defined(RT_USING_POSIX_DELAY) && defined(RT_USING_CLOCK_TIME)
 int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
 {
     struct timespec old_ts = {0};
     struct timespec new_ts = {0};
-    struct rt_ktime_hrtimer timer;
+    struct rt_clock_hrtimer timer;
 
-    rt_ktime_hrtimer_delay_init(&timer);
+    rt_clock_hrtimer_delay_init(&timer);
 
     if (rqtp == RT_NULL)
     {
@@ -557,14 +557,14 @@ int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
         return -1;
     }
     unsigned long ns = rqtp->tv_sec * NANOSECOND_PER_SECOND + rqtp->tv_nsec;
-    rt_ktime_boottime_get_ns(&old_ts);
-    rt_ktime_hrtimer_ndelay(&timer, ns);
+    rt_clock_boottime_get_ns(&old_ts);
+    rt_clock_hrtimer_ndelay(&timer, ns);
     if (rt_get_errno() == RT_EINTR)
     {
         if (rmtp)
         {
             rt_base_t rsec, rnsec;
-            rt_ktime_boottime_get_ns(&new_ts);
+            rt_clock_boottime_get_ns(&new_ts);
 
             rsec = old_ts.tv_sec + rqtp->tv_sec - new_ts.tv_sec;
             rnsec = old_ts.tv_nsec + rqtp->tv_nsec - new_ts.tv_nsec;
@@ -580,18 +580,18 @@ int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
             }
         }
 
-        rt_ktime_hrtimer_delay_detach(&timer);
+        rt_clock_hrtimer_delay_detach(&timer);
         rt_set_errno(EINTR);
         return -1;
     }
 
-    rt_ktime_hrtimer_delay_detach(&timer);
+    rt_clock_hrtimer_delay_detach(&timer);
     return 0;
 }
 RTM_EXPORT(nanosleep);
-#endif /* RT_USING_POSIX_DELAY && RT_USING_KTIME */
+#endif /* RT_USING_POSIX_DELAY && RT_USING_CLOCK_TIME */
 
-#if defined(RT_USING_POSIX_CLOCK) && defined(RT_USING_KTIME)
+#if defined(RT_USING_POSIX_CLOCK) && defined(RT_USING_CLOCK_TIME)
 
 int clock_getres(clockid_t clockid, struct timespec *res)
 {
@@ -609,14 +609,14 @@ int clock_getres(clockid_t clockid, struct timespec *res)
             return _control_rtc(RT_DEVICE_CTRL_RTC_GET_TIMERES, res);
 #endif /* RT_USING_RTC */
 
-        case CLOCK_MONOTONIC:  // use cputimer
+        case CLOCK_MONOTONIC:  // use clock_time counter
         case CLOCK_MONOTONIC_COARSE:
         case CLOCK_MONOTONIC_RAW:
         case CLOCK_BOOTTIME:
         case CLOCK_PROCESS_CPUTIME_ID:
         case CLOCK_THREAD_CPUTIME_ID:
             res->tv_sec  = 0;
-            res->tv_nsec = (rt_ktime_cputimer_getres() / RT_KTIME_RESMUL);
+            res->tv_nsec = (rt_clock_time_get_res_scaled() / RT_CLOCK_TIME_RESMUL);
             return 0;
 
         default:
@@ -646,11 +646,11 @@ int clock_gettime(clockid_t clockid, struct timespec *tp)
         case CLOCK_MONOTONIC_COARSE:
         case CLOCK_MONOTONIC_RAW:
         case CLOCK_BOOTTIME:
-            return rt_ktime_boottime_get_ns(tp);
+            return rt_clock_boottime_get_ns(tp);
 
         case CLOCK_PROCESS_CPUTIME_ID:
         case CLOCK_THREAD_CPUTIME_ID:
-            return rt_ktime_boottime_get_ns(tp);  // TODO not yet implemented
+            return rt_clock_boottime_get_ns(tp);  // TODO not yet implemented
 
         default:
             tp->tv_sec  = 0;
@@ -690,7 +690,7 @@ int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *rqtp, s
         case CLOCK_MONOTONIC:  // use boottime
         case CLOCK_PROCESS_CPUTIME_ID:
             if (flags & TIMER_ABSTIME)
-                err = rt_ktime_boottime_get_ns(&ts);
+                err = rt_clock_boottime_get_ns(&ts);
             break;
 
         default:
@@ -790,9 +790,9 @@ int rt_timespec_to_tick(const struct timespec *time)
 }
 RTM_EXPORT(rt_timespec_to_tick);
 
-#endif /* RT_USING_POSIX_CLOCK && RT_USING_KTIME */
+#endif /* RT_USING_POSIX_CLOCK && RT_USING_CLOCK_TIME */
 
-#if defined(RT_USING_POSIX_TIMER) && defined(RT_USING_KTIME)
+#if defined(RT_USING_POSIX_TIMER) && defined(RT_USING_CLOCK_TIME)
 
 #include <resource_id.h>
 
@@ -801,7 +801,7 @@ RTM_EXPORT(rt_timespec_to_tick);
 
 struct timer_obj
 {
-    struct rt_ktime_hrtimer hrtimer;
+    struct rt_clock_hrtimer hrtimer;
     void (*sigev_notify_func)(union sigval val);
     union sigval val;
     struct timespec interval;              /* Reload value */
@@ -896,11 +896,11 @@ static void rtthread_timer_wrapper(void *timerobj)
         timer->status = NOT_ACTIVE;
     }
 
-    timer->reload = ((timer->interval.tv_sec * NANOSECOND_PER_SECOND + timer->interval.tv_nsec) * RT_KTIME_RESMUL) /
-                    rt_ktime_cputimer_getres();
+    timer->reload = ((timer->interval.tv_sec * NANOSECOND_PER_SECOND + timer->interval.tv_nsec) * RT_CLOCK_TIME_RESMUL) /
+                    rt_clock_time_get_res_scaled();
     if (timer->reload)
     {
-        rt_ktime_hrtimer_start(&timer->hrtimer, timer->reload);
+        rt_clock_hrtimer_start(&timer->hrtimer, timer->reload);
     }
 #ifdef RT_USING_SMART
     /* this field is named as tid in musl */
@@ -1021,7 +1021,7 @@ int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid)
     timer->status = NOT_ACTIVE;
     timer->clockid = clockid;
 
-    rt_ktime_hrtimer_init(&timer->hrtimer, timername, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_HARD_TIMER,
+    rt_clock_hrtimer_init(&timer->hrtimer, timername, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_HARD_TIMER,
                           rtthread_timer_wrapper, timer);
 
     _timerid = resource_id_get(&id_timer);
@@ -1031,7 +1031,7 @@ int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid)
         rt_free(param);
 #endif /* RT_USING_SMART */
 
-        rt_ktime_hrtimer_detach(&timer->hrtimer);
+        rt_clock_hrtimer_detach(&timer->hrtimer);
         rt_free(timer);
         rt_set_errno(ENOMEM);
         return -1;
@@ -1083,9 +1083,9 @@ int timer_delete(timer_t timerid)
     if (timer->status == ACTIVE)
     {
         timer->status = NOT_ACTIVE;
-        rt_ktime_hrtimer_stop(&timer->hrtimer);
+        rt_clock_hrtimer_stop(&timer->hrtimer);
     }
-    rt_ktime_hrtimer_detach(&timer->hrtimer);
+    rt_clock_hrtimer_detach(&timer->hrtimer);
 
 #ifdef RT_USING_SMART
     if (timer->pid)
@@ -1135,8 +1135,8 @@ int timer_gettime(timer_t timerid, struct itimerspec *its)
     if (timer->status == ACTIVE)
     {
         unsigned long remain_cnt;
-        rt_ktime_hrtimer_control(&timer->hrtimer, RT_TIMER_CTRL_GET_REMAIN_TIME, &remain_cnt);
-        nanoseconds = ((remain_cnt - rt_ktime_cputimer_getcnt()) * rt_ktime_cputimer_getres()) / RT_KTIME_RESMUL;
+        rt_clock_hrtimer_control(&timer->hrtimer, RT_TIMER_CTRL_GET_REMAIN_TIME, &remain_cnt);
+        nanoseconds = ((remain_cnt - rt_clock_time_get_counter()) * rt_clock_time_get_res_scaled()) / RT_CLOCK_TIME_RESMUL;
         seconds     = nanoseconds / NANOSECOND_PER_SECOND;
         nanoseconds = nanoseconds % NANOSECOND_PER_SECOND;
         its->it_value.tv_sec = (rt_int32_t)seconds;
@@ -1191,7 +1191,7 @@ int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
     {
         if (timer->status == ACTIVE)
         {
-            rt_ktime_hrtimer_stop(&timer->hrtimer);
+            rt_clock_hrtimer_stop(&timer->hrtimer);
         }
 
         timer->status = NOT_ACTIVE;
@@ -1213,7 +1213,7 @@ int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
         case CLOCK_PROCESS_CPUTIME_ID:
         case CLOCK_THREAD_CPUTIME_ID:
             if (flags & TIMER_ABSTIME)
-                err = rt_ktime_boottime_get_ns(&ts);
+                err = rt_clock_boottime_get_ns(&ts);
             break;
         default:
             rt_set_errno(EINVAL);
@@ -1228,8 +1228,8 @@ int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
     if (ns <= 0)
         return 0;
 
-    unsigned long res       = rt_ktime_cputimer_getres();
-    timer->reload           = (ns * RT_KTIME_RESMUL) / res;
+    unsigned long res       = rt_clock_time_get_res_scaled();
+    timer->reload           = (ns * RT_CLOCK_TIME_RESMUL) / res;
     timer->interval.tv_sec  = value->it_interval.tv_sec;
     timer->interval.tv_nsec = value->it_interval.tv_nsec;
     timer->value.tv_sec     = value->it_value.tv_sec;
@@ -1237,18 +1237,18 @@ int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
 
     if (timer->status == ACTIVE)
     {
-        rt_ktime_hrtimer_stop(&timer->hrtimer);
+        rt_clock_hrtimer_stop(&timer->hrtimer);
     }
     timer->status = ACTIVE;
 
     if ((value->it_interval.tv_sec == 0) && (value->it_interval.tv_nsec == 0))
-        rt_ktime_hrtimer_control(&timer->hrtimer, RT_TIMER_CTRL_SET_ONESHOT, RT_NULL);
+        rt_clock_hrtimer_control(&timer->hrtimer, RT_TIMER_CTRL_SET_ONESHOT, RT_NULL);
     else
-        rt_ktime_hrtimer_control(&timer->hrtimer, RT_TIMER_CTRL_SET_PERIODIC, RT_NULL);
+        rt_clock_hrtimer_control(&timer->hrtimer, RT_TIMER_CTRL_SET_PERIODIC, RT_NULL);
 
-    rt_ktime_hrtimer_start(&timer->hrtimer, timer->reload);
+    rt_clock_hrtimer_start(&timer->hrtimer, timer->reload);
 
     return 0;
 }
 RTM_EXPORT(timer_settime);
-#endif /* RT_USING_POSIX_TIMER && RT_USING_KTIME */
+#endif /* RT_USING_POSIX_TIMER && RT_USING_CLOCK_TIME */