Add unified clock_time subsystem core implementation

Co-authored-by: BernardXiong <[email protected]>

Author: Copilot

components/drivers/clock_time/Kconfig

@@ -0,0 +1,50 @@
+menuconfig RT_USING_CLOCK_TIME
+    bool "Using unified clock_time subsystem"
+    default n
+    help
+        Unified time subsystem that consolidates hwtimer, ktime, and cputime.
+        Provides clock source, clock event, and high-resolution timer support.
+
+if RT_USING_CLOCK_TIME
+
+    config RT_USING_CLOCK_HRTIMER
+        bool "Enable high-resolution timer support"
+        default y
+        help
+            Enable high-resolution software timers built on clock_time devices.
+            
+    config RT_USING_CLOCK_CPUTIME
+        bool "Enable CPU time APIs"
+        default y
+        help
+            Enable CPU time measurement and delay APIs.
+
+    config RT_USING_CLOCK_BOOTTIME
+        bool "Enable boottime APIs"
+        default y
+        help
+            Enable system boottime (monotonic time since boot) APIs.
+
+    # Backward compatibility options
+    config RT_USING_HWTIMER
+        bool
+        default y
+        help
+            Legacy option for backward compatibility with hwtimer.
+            Automatically enabled when RT_USING_CLOCK_TIME is enabled.
+
+    config RT_USING_KTIME
+        bool
+        default y if RT_USING_CLOCK_HRTIMER
+        help
+            Legacy option for backward compatibility with ktime.
+            Automatically enabled when RT_USING_CLOCK_HRTIMER is enabled.
+
+    config RT_USING_CPUTIME
+        bool
+        default y if RT_USING_CLOCK_CPUTIME
+        help
+            Legacy option for backward compatibility with cputime.
+            Automatically enabled when RT_USING_CLOCK_CPUTIME is enabled.
+
+endif

components/drivers/clock_time/SConscript

@@ -0,0 +1,28 @@
+from building import *
+
+cwd = GetCurrentDir()
+src = []
+inc = [cwd + '/inc']
+
+if GetDepend(['RT_USING_CLOCK_TIME']):
+    # Core clock_time device implementation
+    src += ['src/clock_time.c']
+    
+    # High-resolution timer support
+    if GetDepend(['RT_USING_CLOCK_HRTIMER']):
+        src += ['src/hrtimer.c']
+    
+    # CPU time APIs
+    if GetDepend(['RT_USING_CLOCK_CPUTIME']):
+        src += ['src/clock_time_cputime.c']
+    
+    # Boottime APIs  
+    if GetDepend(['RT_USING_CLOCK_BOOTTIME']):
+        src += ['src/clock_time_boottime.c']
+    
+    # Tick-based fallback implementation
+    src += ['src/clock_time_tick.c']
+
+group = DefineGroup('Drivers', src, depend = [''], CPPPATH = inc)
+
+Return('group')

components/drivers/clock_time/src/clock_time.c

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-01-01     RT-Thread    Unified clock_time subsystem implementation
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <drivers/clock_time.h>
+
+#define DBG_TAG "clock_time"
+#define DBG_LVL DBG_INFO
+#include <rtdbg.h>
+
+/* Default system clock time device */
+static rt_clock_time_t _default_device = RT_NULL;
+
+/**
+ * @brief Register a clock time device
+ */
+rt_err_t rt_clock_time_device_register(struct rt_clock_time_device *dev,
+                                        const char *name,
+                                        rt_uint8_t caps)
+{
+    rt_err_t result;
+    
+    RT_ASSERT(dev != RT_NULL);
+    RT_ASSERT(name != RT_NULL);
+    RT_ASSERT(dev->ops != RT_NULL);
+    
+    /* Initialize parent device structure */
+    dev->parent.type = RT_Device_Class_Timer;
+    dev->parent.rx_indicate = RT_NULL;
+    dev->parent.tx_complete = RT_NULL;
+    
+    dev->parent.init = RT_NULL;
+    dev->parent.open = RT_NULL;
+    dev->parent.close = RT_NULL;
+    dev->parent.read = RT_NULL;
+    dev->parent.write = RT_NULL;
+    dev->parent.control = RT_NULL;
+    
+    dev->caps = caps;
+    
+    /* Calculate resolution scale factor */
+    if (dev->ops->get_freq)
+    {
+        rt_uint64_t freq = dev->ops->get_freq();
+        if (freq > 0)
+        {
+            /* res_scale = (1e9 * RT_CLOCK_TIME_RESMUL) / freq */
+            dev->res_scale = ((1000000000ULL * RT_CLOCK_TIME_RESMUL) / freq);
+        }
+        else
+        {
+            dev->res_scale = RT_CLOCK_TIME_RESMUL;
+        }
+    }
+    else
+    {
+        dev->res_scale = RT_CLOCK_TIME_RESMUL;
+    }
+    
+    /* Register device */
+    result = rt_device_register(&dev->parent, name, RT_DEVICE_FLAG_RDWR);
+    if (result != RT_EOK)
+    {
+        LOG_E("Failed to register clock_time device: %s", name);
+        return result;
+    }
+    
+    /* Set as default if none exists */
+    if (_default_device == RT_NULL)
+    {
+        _default_device = dev;
+        LOG_D("Set %s as default clock_time device", name);
+    }
+    
+    LOG_I("Registered clock_time device: %s (caps: 0x%02x)", name, caps);
+    
+    return RT_EOK;
+}
+
+/**
+ * @brief Get the default system clock time device
+ */
+rt_clock_time_t rt_clock_time_default(void)
+{
+    return _default_device;
+}
+
+/**
+ * @brief Set the default system clock time device
+ */
+rt_err_t rt_clock_time_set_default(rt_clock_time_t dev)
+{
+    RT_ASSERT(dev != RT_NULL);
+    
+    _default_device = dev;
+    LOG_D("Changed default clock_time device to: %s", dev->parent.parent.name);
+    
+    return RT_EOK;
+}

components/drivers/clock_time/src/clock_time_boottime.c

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-01-01     RT-Thread    Boottime APIs implementation
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <drivers/clock_time.h>
+#include <sys/time.h>
+
+rt_weak rt_err_t rt_clock_boottime_get_us(struct timeval *tv)
+{
+    RT_ASSERT(tv != RT_NULL);
+
+    rt_uint64_t ns = (rt_clock_cputimer_getcnt() * rt_clock_cputimer_getres()) / RT_CLOCK_TIME_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_clock_boottime_get_s(time_t *t)
+{
+    RT_ASSERT(t != RT_NULL);
+
+    rt_uint64_t ns = (rt_clock_cputimer_getcnt() * rt_clock_cputimer_getres()) / RT_CLOCK_TIME_RESMUL;
+
+    *t = ns / (1000ULL * 1000 * 1000);
+
+    return RT_EOK;
+}
+
+rt_weak rt_err_t rt_clock_boottime_get_ns(struct timespec *ts)
+{
+    RT_ASSERT(ts != RT_NULL);
+
+    rt_uint64_t ns = (rt_clock_cputimer_getcnt() * rt_clock_cputimer_getres()) / RT_CLOCK_TIME_RESMUL;
+
+    ts->tv_sec  = ns / (1000ULL * 1000 * 1000);
+    ts->tv_nsec = ns % (1000ULL * 1000 * 1000);
+
+    return RT_EOK;
+}

components/drivers/clock_time/src/clock_time_cputime.c

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-01-01     RT-Thread    CPU time APIs (delegates to clock_time core)
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <drivers/clock_time.h>
+
+/*
+ * Additional CPU time utility functions
+ * Core implementations are in clock_time_tick.c
+ */
+
+/* These functions are implemented inline or use the core APIs */
+
+/* Note: The main cputime APIs are now:
+ *   rt_clock_cputimer_getres()
+ *   rt_clock_cputimer_getfrq()
+ *   rt_clock_cputimer_getcnt()
+ *   rt_clock_cputimer_init()
+ *
+ * These are defined in clock_time_tick.c as weak functions
+ * that can be overridden by BSP implementations.
+ */

components/drivers/clock_time/src/clock_time_tick.c

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-01-01     RT-Thread    Tick-based fallback implementation for clock_time
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <drivers/clock_time.h>
+
+/*
+ * CPU Timer APIs - Default tick-based implementation
+ * These are weak functions that can be overridden by BSP-specific implementations
+ */
+
+rt_weak rt_uint64_t rt_clock_cputimer_getres(void)
+{
+    /* Resolution in nanoseconds * RT_CLOCK_TIME_RESMUL */
+    return ((1000ULL * 1000 * 1000) * RT_CLOCK_TIME_RESMUL) / RT_TICK_PER_SECOND;
+}
+
+rt_weak unsigned long rt_clock_cputimer_getfrq(void)
+{
+    return RT_TICK_PER_SECOND;
+}
+
+rt_weak unsigned long rt_clock_cputimer_getcnt(void)
+{
+    return rt_tick_get();
+}
+
+rt_weak void rt_clock_cputimer_init(void)
+{
+    /* Default: no initialization needed for tick-based implementation */
+    return;
+}