lib/time.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000-2009
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  */
   6
   7 #include <common.h>
   8 #include <bootstage.h>
   9 #include <dm.h>
  10 #include <errno.h>
  11 #include <init.h>
  12 #include <time.h>
  13 #include <timer.h>
  14 #include <watchdog.h>
  15 #include <div64.h>
  16 #include <asm/io.h>
  17
  18 #ifndef CONFIG_WD_PERIOD
  19 # define CONFIG_WD_PERIOD       (10 * 1000 * 1000)      /* 10 seconds default */
  20 #endif
  21
  22 DECLARE_GLOBAL_DATA_PTR;
  23
  24 #ifdef CONFIG_SYS_TIMER_RATE
  25 /* Returns tick rate in ticks per second */
  26 ulong notrace get_tbclk(void)
  27 {
  28         return CONFIG_SYS_TIMER_RATE;
  29 }
  30 #endif
  31
  32 #ifdef CONFIG_SYS_TIMER_COUNTER
  33 unsigned long notrace timer_read_counter(void)
  34 {
  35 #ifdef CONFIG_SYS_TIMER_COUNTS_DOWN
  36         return ~readl(CONFIG_SYS_TIMER_COUNTER);
  37 #else
  38         return readl(CONFIG_SYS_TIMER_COUNTER);
  39 #endif
  40 }
  41
  42 ulong timer_get_boot_us(void)
  43 {
  44         ulong count = timer_read_counter();
  45
  46 #if CONFIG_SYS_TIMER_RATE == 1000000
  47         return count;
  48 #elif CONFIG_SYS_TIMER_RATE > 1000000
  49         return lldiv(count, CONFIG_SYS_TIMER_RATE / 1000000);
  50 #elif defined(CONFIG_SYS_TIMER_RATE)
  51         return (unsigned long long)count * 1000000 / CONFIG_SYS_TIMER_RATE;
  52 #else
  53         /* Assume the counter is in microseconds */
  54         return count;
  55 #endif
  56 }
  57
  58 #else
  59 extern unsigned long __weak timer_read_counter(void);
  60 #endif
  61
  62 #if CONFIG_IS_ENABLED(TIMER)
  63 ulong notrace get_tbclk(void)
  64 {
  65         if (!gd->timer) {
  66 #ifdef CONFIG_TIMER_EARLY
  67                 return timer_early_get_rate();
  68 #else
  69                 int ret;
  70
  71                 ret = dm_timer_init();
  72                 if (ret)
  73                         return ret;
  74 #endif
  75         }
  76
  77         return timer_get_rate(gd->timer);
  78 }
  79
  80 uint64_t notrace get_ticks(void)
  81 {
  82         u64 count;
  83         int ret;
  84
  85         if (!gd->timer) {
  86 #ifdef CONFIG_TIMER_EARLY
  87                 return timer_early_get_count();
  88 #else
  89                 int ret;
  90
  91                 ret = dm_timer_init();
  92                 if (ret)
  93                         return ret;
  94 #endif
  95         }
  96
  97         ret = timer_get_count(gd->timer, &count);
  98         if (ret)
  99                 return ret;
 100
 101         return count;
 102 }
 103
 104 #else /* !CONFIG_TIMER */
 105
 106 uint64_t __weak notrace get_ticks(void)
 107 {
 108         unsigned long now = timer_read_counter();
 109
 110         /* increment tbu if tbl has rolled over */
 111         if (now < gd->timebase_l)
 112                 gd->timebase_h++;
 113         gd->timebase_l = now;
 114         return ((uint64_t)gd->timebase_h << 32) | gd->timebase_l;
 115 }
 116
 117 #endif /* CONFIG_TIMER */
 118
 119 /* Returns time in milliseconds */
 120 static uint64_t notrace tick_to_time(uint64_t tick)
 121 {
 122         ulong div = get_tbclk();
 123
 124         tick *= CONFIG_SYS_HZ;
 125         do_div(tick, div);
 126         return tick;
 127 }
 128
 129 int __weak timer_init(void)
 130 {
 131         return 0;
 132 }
 133
 134 /* Returns time in milliseconds */
 135 ulong __weak get_timer(ulong base)
 136 {
 137         return tick_to_time(get_ticks()) - base;
 138 }
 139
 140 static uint64_t notrace tick_to_time_us(uint64_t tick)
 141 {
 142         ulong div = get_tbclk() / 1000;
 143
 144         tick *= CONFIG_SYS_HZ;
 145         do_div(tick, div);
 146         return tick;
 147 }
 148
 149 uint64_t __weak get_timer_us(uint64_t base)
 150 {
 151         return tick_to_time_us(get_ticks()) - base;
 152 }
 153
 154 unsigned long __weak notrace timer_get_us(void)
 155 {
 156         return tick_to_time(get_ticks() * 1000);
 157 }
 158
 159 uint64_t usec_to_tick(unsigned long usec)
 160 {
 161         uint64_t tick = usec;
 162         tick *= get_tbclk();
 163         do_div(tick, 1000000);
 164         return tick;
 165 }
 166
 167 void __weak __udelay(unsigned long usec)
 168 {
 169         uint64_t tmp;
 170
 171         tmp = get_ticks() + usec_to_tick(usec); /* get current timestamp */
 172
 173         while (get_ticks() < tmp+1)     /* loop till event */
 174                  /*NOP*/;
 175 }
 176
 177 /* ------------------------------------------------------------------------- */
 178
 179 void udelay(unsigned long usec)
 180 {
 181         ulong kv;
 182
 183         do {
 184                 WATCHDOG_RESET();
 185                 kv = usec > CONFIG_WD_PERIOD ? CONFIG_WD_PERIOD : usec;
 186                 __udelay(kv);
 187                 usec -= kv;
 188         } while(usec);
 189 }