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