src/include/timer.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 #ifndef TIMER_H
   3 #define TIMER_H
   4
   5 #include <types.h>
   6
   7 #define NSECS_PER_SEC 1000000000
   8 #define USECS_PER_SEC 1000000
   9 #define MSECS_PER_SEC 1000
  10 #define USECS_PER_MSEC (USECS_PER_SEC / MSECS_PER_SEC)
  11
  12 /* The time structures are defined to be a representation of the time since
  13  * coreboot started executing one of its stages. The reason for using structures
  14  * is to allow for changes in the future. The structures' details are exposed
  15  * so that the compiler can allocate space on the stack and use in other
  16  * structures. In other words, accessing any field within this structure
  17  * outside of the core timer code is not supported. */
  18
  19 struct mono_time {
  20         uint64_t microseconds;
  21 };
  22
  23 /* A timeout_callback structure is used for the book keeping for scheduling
  24  * work in the future. When a callback is called the structure can be
  25  * re-used for scheduling as it is not being tracked by the core timer
  26  * library any more. */
  27 struct timeout_callback {
  28         void *priv;
  29         void (*callback)(struct timeout_callback *tocb);
  30         /* Not for public use. The timer library uses the fields below. */
  31         struct mono_time expiration;
  32 };
  33
  34 /* Obtain the current monotonic time. The assumption is that the time counts
  35  * up from the value 0 with value 0 being the point when the timer was
  36  * initialized.  Additionally, the timer is assumed to only be valid for the
  37  * duration of the boot.
  38  *
  39  * Note that any implementations of timer_monotonic_get()
  40  * need to ensure its timesource does not roll over within 10 secs. The reason
  41  * is that the time between calls to timer_monotonic_get() may be on order
  42  * of 10 seconds. */
  43 void timer_monotonic_get(struct mono_time *mt);
  44
  45 /* Returns 1 if callbacks still present in the queue. 0 if no timers left. */
  46 int timers_run(void);
  47
  48 /* Schedule a callback to be ran microseconds from time of invocation.
  49  * 0 returned on success, < 0 on error. */
  50 int timer_sched_callback(struct timeout_callback *tocb, uint64_t us);
  51
  52 /* Set an absolute time to a number of microseconds. */
  53 static inline void mono_time_set_usecs(struct mono_time *mt, uint64_t us)
  54 {
  55         mt->microseconds = us;
  56 }
  57
  58 /* Set an absolute time to a number of milliseconds. */
  59 static inline void mono_time_set_msecs(struct mono_time *mt, uint64_t ms)
  60 {
  61         mt->microseconds = ms * USECS_PER_MSEC;
  62 }
  63
  64 /* Add microseconds to an absolute time. */
  65 static inline void mono_time_add_usecs(struct mono_time *mt, int64_t us)
  66 {
  67         mt->microseconds += us;
  68 }
  69
  70 /* Add milliseconds to an absolute time. */
  71 static inline void mono_time_add_msecs(struct mono_time *mt, int64_t ms)
  72 {
  73         mono_time_add_usecs(mt, ms * USECS_PER_MSEC);
  74 }
  75
  76 /* Compare two absolute times: Return -1, 0, or 1 if t1 is <, =, or > t2,
  77  * respectively. */
  78 static inline int mono_time_cmp(const struct mono_time *t1,
  79                                 const struct mono_time *t2)
  80 {
  81         if (t1->microseconds == t2->microseconds)
  82                 return 0;
  83
  84         if (t1->microseconds < t2->microseconds)
  85                 return -1;
  86
  87         return 1;
  88 }
  89
  90 /* Return true if t1 after t2  */
  91 static inline int mono_time_after(const struct mono_time *t1,
  92                                   const struct mono_time *t2)
  93 {
  94         return mono_time_cmp(t1, t2) > 0;
  95 }
  96
  97 /* Return true if t1 before t2. */
  98 static inline int mono_time_before(const struct mono_time *t1,
  99                                    const struct mono_time *t2)
 100 {
 101         return mono_time_cmp(t1, t2) < 0;
 102 }
 103
 104 /* Return time difference between t1 and t2. i.e. t2 - t1. */
 105 static inline int64_t mono_time_diff_microseconds(const struct mono_time *t1,
 106                                                   const struct mono_time *t2)
 107 {
 108         return t2->microseconds - t1->microseconds;
 109 }
 110
 111 struct stopwatch {
 112         struct mono_time start;
 113         struct mono_time current;
 114         struct mono_time expires;
 115 };
 116
 117 static inline void stopwatch_init(struct stopwatch *sw)
 118 {
 119         if (CONFIG(HAVE_MONOTONIC_TIMER))
 120                 timer_monotonic_get(&sw->start);
 121         else
 122                 sw->start.microseconds = 0;
 123
 124         sw->current = sw->expires = sw->start;
 125 }
 126
 127 static inline void stopwatch_init_usecs_expire(struct stopwatch *sw, uint64_t us)
 128 {
 129         stopwatch_init(sw);
 130         mono_time_add_usecs(&sw->expires, us);
 131 }
 132
 133 static inline void stopwatch_init_msecs_expire(struct stopwatch *sw, uint64_t ms)
 134 {
 135         stopwatch_init_usecs_expire(sw, USECS_PER_MSEC * ms);
 136 }
 137
 138 /*
 139  * Tick the stopwatch to collect the current time.
 140  */
 141 static inline void stopwatch_tick(struct stopwatch *sw)
 142 {
 143         if (CONFIG(HAVE_MONOTONIC_TIMER))
 144                 timer_monotonic_get(&sw->current);
 145         else
 146                 sw->current.microseconds = 0;
 147 }
 148
 149 /*
 150  * Tick and check the stopwatch for expiration. Returns non-zero on expiration.
 151  */
 152 static inline int stopwatch_expired(struct stopwatch *sw)
 153 {
 154         stopwatch_tick(sw);
 155         return !mono_time_before(&sw->current, &sw->expires);
 156 }
 157
 158 /*
 159  * Tick and check the stopwatch as long as it has not expired.
 160  */
 161 static inline void stopwatch_wait_until_expired(struct stopwatch *sw)
 162 {
 163         while (!stopwatch_expired(sw))
 164                 ;
 165 }
 166
 167 /*
 168  * Return number of microseconds since starting the stopwatch.
 169  */
 170 static inline int64_t stopwatch_duration_usecs(struct stopwatch *sw)
 171 {
 172         /*
 173          * If the stopwatch hasn't been ticked (current == start) tick
 174          * the stopwatch to gather the accumulated time.
 175          */
 176         if (!mono_time_cmp(&sw->start, &sw->current))
 177                 stopwatch_tick(sw);
 178
 179         return mono_time_diff_microseconds(&sw->start, &sw->current);
 180 }
 181
 182 static inline int64_t stopwatch_duration_msecs(struct stopwatch *sw)
 183 {
 184         return stopwatch_duration_usecs(sw) / USECS_PER_MSEC;
 185 }
 186
 187 /*
 188  * Helper macro to wait until a condition becomes true or a timeout elapses.
 189  *
 190  * condition: a C expression to wait for
 191  * timeout: timeout, in microseconds
 192  *
 193  * Returns:
 194  *  0   if the condition still evaluates to false after the timeout elapsed,
 195  * >0   if the condition evaluates to true. The return value is the amount of
 196  *      microseconds waited (at least 1).
 197  */
 198 #define wait_us(timeout_us, condition)                                  \
 199 ({                                                                      \
 200         int64_t __ret = 0;                                                      \
 201         struct stopwatch __sw;                                          \
 202         stopwatch_init_usecs_expire(&__sw, timeout_us);                 \
 203         do {                                                            \
 204                 if (condition) {                                        \
 205                         stopwatch_tick(&__sw);                          \
 206                         __ret = stopwatch_duration_usecs(&__sw);        \
 207                         if (!__ret) /* make sure it evaluates to true */\
 208                                 __ret = 1;                              \
 209                         break;                                          \
 210                 }                                                       \
 211         } while (!stopwatch_expired(&__sw));                            \
 212         __ret;                                                          \
 213 })
 214
 215 #define wait_ms(timeout_ms, condition)                                  \
 216         DIV_ROUND_UP(wait_us((timeout_ms) * USECS_PER_MSEC, condition), \
 217                      USECS_PER_MSEC)
 218
 219 #endif /* TIMER_H */