Fixes clock_gettime and rt_ktime_boottime_get_ns

Currently the return value of clock_gettime and rt_ktime_boottime_get_ns are restricted by
rt_ktime_cputimer_getres, as the value of rt_ktime_cputimer_getres are not exactly represent the
frequency of the clock, directly using rt_ktime_cputimer_getfrq will ensure the return value of
rt_ktime_boottime_get_ns be more exact.
And also add function rt_muldiv_u64 rt_muldiv_u32 for not losing precision when convert between
cputimer and hrtimer and nanoseconds.

Because rt_ktime_boottime_get_ns depends on rt_ktime_cputimer_getcnt
and rt_ktime_cputimer_getcnt depends rt_tick_get
So the rt_tick_t should be 64bit for long running program.

Use `#if defined(ARCH_CPU_64BIT)` is for
future allow rt_tick_t can be 64bit on 32bit CPU.

Tick count should not be restricted to the CPU

Signed-off-by: Yonggang Luo <[email protected]>

Author: lygstate

bsp/rockchip/rk3500/driver/hwtimer/hwtimer-rockchip_timer.c

@@ -328,16 +328,11 @@ static const struct rk_timer_data rk3399_timer_data =
 
 #ifdef RT_USING_KTIME
 
-uint64_t rt_ktime_hrtimer_getfrq(void)
+rt_uint64_t rt_ktime_hrtimer_getfrq(void)
 {
     return (24 * 1000 * 1000UL);
 }
 
-uint64_t rt_ktime_hrtimer_getres(void)
-{
-    return ((1000UL * 1000 * 1000) * RT_KTIME_RESMUL) / (24 * 1000 * 1000UL);
-}
-
 uint64_t rt_ktime_hrtimer_getcnt(void)
 {
     return rk_timer_current_value(_timer0.timer);
@@ -351,7 +346,7 @@ uint64_t rt_ktime_hrtimer_getcnt(void)
  * @param cnt the count of timer dealy
  * @return rt_err_t 0 forever
  */
-rt_err_t rt_ktime_hrtimer_settimeout(unsigned long cnt)
+rt_err_t rt_ktime_hrtimer_settimeout(rt_uint64_t cnt)
 {
     struct hrt_timer *timer = &_timer0;
     struct rk_timer *time = timer->timer;

components/drivers/ktime/inc/ktime.h

@@ -18,16 +18,14 @@
 
 #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_tick_t            delay_cnt;
+    rt_tick_t            timeout_cnt;
     rt_err_t             error;
     struct rt_completion completion;
     void (*timeout_func)(void *parameter);
@@ -58,33 +56,19 @@ rt_err_t rt_ktime_boottime_get_s(time_t *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);
+rt_uint32_t 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);
+rt_tick_t rt_ktime_cputimer_getcnt(void);
 
 /**
  * @brief Init cputimer
@@ -93,18 +77,11 @@ unsigned long rt_ktime_cputimer_getstep(void);
 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
+ * @brief Get hrtimer frequency, you should re-implemented it in hrtimer device driver
  *
  * @return frequency
  */
-unsigned long rt_ktime_hrtimer_getfrq(void);
+rt_uint64_t rt_ktime_hrtimer_getfrq(void);
 
 /**
  * @brief Get hrtimer the value of the cnt counter
@@ -119,7 +96,7 @@ unsigned long rt_ktime_hrtimer_getcnt(void);
  * @param cnt: hrtimer requires a timing cnt value
  * @return rt_err_t
  */
-rt_err_t rt_ktime_hrtimer_settimeout(unsigned long cnt);
+rt_err_t rt_ktime_hrtimer_settimeout(rt_uint64_t cnt);
 
 /**
  * @brief called in hrtimer device driver isr routinue, it will process the timeouts
@@ -131,7 +108,13 @@ void     rt_ktime_hrtimer_init(rt_ktime_hrtimer_t timer,
                                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);
+/**
+ * @brief start the hrtimer
+ *
+ * @param cnt the cputimer cnt value
+ * @return rt_err_t
+ */
+rt_err_t rt_ktime_hrtimer_start(rt_ktime_hrtimer_t timer, rt_tick_t 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);
@@ -154,30 +137,30 @@ void rt_ktime_hrtimer_process(void);
  * @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);
+rt_err_t rt_ktime_hrtimer_sleep(struct rt_ktime_hrtimer *timer, rt_tick_t 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);
+rt_err_t rt_ktime_hrtimer_ndelay(struct rt_ktime_hrtimer *timer, rt_uint64_t 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);
+rt_err_t rt_ktime_hrtimer_udelay(struct rt_ktime_hrtimer *timer, rt_uint64_t 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);
+rt_err_t rt_ktime_hrtimer_mdelay(struct rt_ktime_hrtimer *timer, rt_uint64_t ms);
 
 #endif

components/drivers/ktime/src/aarch64/cputimer.c

@@ -11,26 +11,16 @@
 #include "gtimer.h"
 #include "ktime.h"
 
-static volatile unsigned long _init_cnt = 0;
+static volatile rt_uint64_t _init_cnt = 0;
 
-rt_uint64_t rt_ktime_cputimer_getres(void)
+rt_uint32_t rt_ktime_cputimer_getfrq(void)
 {
-    return ((1000ULL * 1000 * 1000) * RT_KTIME_RESMUL) / rt_hw_get_gtimer_frq();
+    return (rt_uint32_t)rt_hw_get_gtimer_frq();
 }
 
-unsigned long rt_ktime_cputimer_getfrq(void)
+rt_tick_t rt_ktime_cputimer_getcnt(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;
+    return (rt_tick_t)(rt_hw_get_cntpct_val() - _init_cnt);
 }
 
 void rt_ktime_cputimer_init(void)

components/drivers/ktime/src/boottime.c

@@ -9,17 +9,17 @@
  */
 
 #include "ktime.h"
-
-#define __KTIME_MUL ((1000ULL * 1000 * 1000) / RT_TICK_PER_SECOND)
+#include "rttypes.h"
 
 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;
+    rt_tick_t cnt = rt_ktime_cputimer_getcnt();
+    rt_uint32_t freq = rt_ktime_cputimer_getfrq();
 
-    tv->tv_sec  = ns / (1000ULL * 1000 * 1000);
-    tv->tv_usec = (ns % (1000ULL * 1000 * 1000)) / 1000;
+    tv->tv_sec  = (time_t)(cnt / freq);
+    tv->tv_usec = rt_muldiv_u32((rt_uint32_t)(cnt % freq), MICROSECOND_PER_SECOND, freq, NULL);
 
     return RT_EOK;
 }
@@ -28,9 +28,10 @@ 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;
+    rt_tick_t cnt = rt_ktime_cputimer_getcnt();
+    rt_uint32_t freq = rt_ktime_cputimer_getfrq();
 
-    *t = ns / (1000ULL * 1000 * 1000);
+    *t = (time_t)(cnt / freq);
 
     return RT_EOK;
 }
@@ -39,10 +40,11 @@ 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;
+    rt_tick_t cnt = rt_ktime_cputimer_getcnt();
+    rt_uint32_t freq = rt_ktime_cputimer_getfrq();
 
-    ts->tv_sec  = ns / (1000ULL * 1000 * 1000);
-    ts->tv_nsec = ns % (1000ULL * 1000 * 1000);
+    ts->tv_sec  = (time_t)(cnt / freq);
+    ts->tv_nsec = rt_muldiv_u32((rt_uint32_t)(cnt % freq), NANOSECOND_PER_SECOND, freq, NULL);
 
     return RT_EOK;
 }

components/drivers/ktime/src/cputimer.c

@@ -10,26 +10,16 @@
 
 #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)
+rt_weak rt_uint32_t rt_ktime_cputimer_getfrq(void)
 {
     return RT_TICK_PER_SECOND;
 }
 
-rt_weak unsigned long rt_ktime_cputimer_getcnt(void)
+rt_weak rt_tick_t 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;