include/linux/timekeeping.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_TIMEKEEPING_H
   3 #define _LINUX_TIMEKEEPING_H
   4
   5 #include <linux/errno.h>
   6
   7 /* Included from linux/ktime.h */
   8
   9 void timekeeping_init(void);
  10 extern int timekeeping_suspended;
  11
  12 /* Architecture timer tick functions: */
  13 extern void legacy_timer_tick(unsigned long ticks);
  14
  15 /*
  16  * Get and set timeofday
  17  */
  18 extern int do_settimeofday64(const struct timespec64 *ts);
  19 extern int do_sys_settimeofday64(const struct timespec64 *tv,
  20                                  const struct timezone *tz);
  21
  22 /*
  23  * ktime_get() family: read the current time in a multitude of ways,
  24  *
  25  * The default time reference is CLOCK_MONOTONIC, starting at
  26  * boot time but not counting the time spent in suspend.
  27  * For other references, use the functions with "real", "clocktai",
  28  * "boottime" and "raw" suffixes.
  29  *
  30  * To get the time in a different format, use the ones wit
  31  * "ns", "ts64" and "seconds" suffix.
  32  *
  33  * See Documentation/core-api/timekeeping.rst for more details.
  34  */
  35
  36
  37 /*
  38  * timespec64 based interfaces
  39  */
  40 extern void ktime_get_raw_ts64(struct timespec64 *ts);
  41 extern void ktime_get_ts64(struct timespec64 *ts);
  42 extern void ktime_get_real_ts64(struct timespec64 *tv);
  43 extern void ktime_get_coarse_ts64(struct timespec64 *ts);
  44 extern void ktime_get_coarse_real_ts64(struct timespec64 *ts);
  45
  46 void getboottime64(struct timespec64 *ts);
  47
  48 /*
  49  * time64_t base interfaces
  50  */
  51 extern time64_t ktime_get_seconds(void);
  52 extern time64_t __ktime_get_real_seconds(void);
  53 extern time64_t ktime_get_real_seconds(void);
  54
  55 /*
  56  * ktime_t based interfaces
  57  */
  58
  59 enum tk_offsets {
  60         TK_OFFS_REAL,
  61         TK_OFFS_BOOT,
  62         TK_OFFS_TAI,
  63         TK_OFFS_MAX,
  64 };
  65
  66 extern ktime_t ktime_get(void);
  67 extern ktime_t ktime_get_with_offset(enum tk_offsets offs);
  68 extern ktime_t ktime_get_coarse_with_offset(enum tk_offsets offs);
  69 extern ktime_t ktime_mono_to_any(ktime_t tmono, enum tk_offsets offs);
  70 extern ktime_t ktime_get_raw(void);
  71 extern u32 ktime_get_resolution_ns(void);
  72
  73 /**
  74  * ktime_get_real - get the real (wall-) time in ktime_t format
  75  */
  76 static inline ktime_t ktime_get_real(void)
  77 {
  78         return ktime_get_with_offset(TK_OFFS_REAL);
  79 }
  80
  81 static inline ktime_t ktime_get_coarse_real(void)
  82 {
  83         return ktime_get_coarse_with_offset(TK_OFFS_REAL);
  84 }
  85
  86 /**
  87  * ktime_get_boottime - Returns monotonic time since boot in ktime_t format
  88  *
  89  * This is similar to CLOCK_MONTONIC/ktime_get, but also includes the
  90  * time spent in suspend.
  91  */
  92 static inline ktime_t ktime_get_boottime(void)
  93 {
  94         return ktime_get_with_offset(TK_OFFS_BOOT);
  95 }
  96
  97 static inline ktime_t ktime_get_coarse_boottime(void)
  98 {
  99         return ktime_get_coarse_with_offset(TK_OFFS_BOOT);
 100 }
 101
 102 /**
 103  * ktime_get_clocktai - Returns the TAI time of day in ktime_t format
 104  */
 105 static inline ktime_t ktime_get_clocktai(void)
 106 {
 107         return ktime_get_with_offset(TK_OFFS_TAI);
 108 }
 109
 110 static inline ktime_t ktime_get_coarse_clocktai(void)
 111 {
 112         return ktime_get_coarse_with_offset(TK_OFFS_TAI);
 113 }
 114
 115 static inline ktime_t ktime_get_coarse(void)
 116 {
 117         struct timespec64 ts;
 118
 119         ktime_get_coarse_ts64(&ts);
 120         return timespec64_to_ktime(ts);
 121 }
 122
 123 static inline u64 ktime_get_coarse_ns(void)
 124 {
 125         return ktime_to_ns(ktime_get_coarse());
 126 }
 127
 128 static inline u64 ktime_get_coarse_real_ns(void)
 129 {
 130         return ktime_to_ns(ktime_get_coarse_real());
 131 }
 132
 133 static inline u64 ktime_get_coarse_boottime_ns(void)
 134 {
 135         return ktime_to_ns(ktime_get_coarse_boottime());
 136 }
 137
 138 static inline u64 ktime_get_coarse_clocktai_ns(void)
 139 {
 140         return ktime_to_ns(ktime_get_coarse_clocktai());
 141 }
 142
 143 /**
 144  * ktime_mono_to_real - Convert monotonic time to clock realtime
 145  */
 146 static inline ktime_t ktime_mono_to_real(ktime_t mono)
 147 {
 148         return ktime_mono_to_any(mono, TK_OFFS_REAL);
 149 }
 150
 151 static inline u64 ktime_get_ns(void)
 152 {
 153         return ktime_to_ns(ktime_get());
 154 }
 155
 156 static inline u64 ktime_get_real_ns(void)
 157 {
 158         return ktime_to_ns(ktime_get_real());
 159 }
 160
 161 static inline u64 ktime_get_boottime_ns(void)
 162 {
 163         return ktime_to_ns(ktime_get_boottime());
 164 }
 165
 166 static inline u64 ktime_get_clocktai_ns(void)
 167 {
 168         return ktime_to_ns(ktime_get_clocktai());
 169 }
 170
 171 static inline u64 ktime_get_raw_ns(void)
 172 {
 173         return ktime_to_ns(ktime_get_raw());
 174 }
 175
 176 extern u64 ktime_get_mono_fast_ns(void);
 177 extern u64 ktime_get_raw_fast_ns(void);
 178 extern u64 ktime_get_boot_fast_ns(void);
 179 extern u64 ktime_get_real_fast_ns(void);
 180
 181 /*
 182  * timespec64/time64_t interfaces utilizing the ktime based ones
 183  * for API completeness, these could be implemented more efficiently
 184  * if needed.
 185  */
 186 static inline void ktime_get_boottime_ts64(struct timespec64 *ts)
 187 {
 188         *ts = ktime_to_timespec64(ktime_get_boottime());
 189 }
 190
 191 static inline void ktime_get_coarse_boottime_ts64(struct timespec64 *ts)
 192 {
 193         *ts = ktime_to_timespec64(ktime_get_coarse_boottime());
 194 }
 195
 196 static inline time64_t ktime_get_boottime_seconds(void)
 197 {
 198         return ktime_divns(ktime_get_coarse_boottime(), NSEC_PER_SEC);
 199 }
 200
 201 static inline void ktime_get_clocktai_ts64(struct timespec64 *ts)
 202 {
 203         *ts = ktime_to_timespec64(ktime_get_clocktai());
 204 }
 205
 206 static inline void ktime_get_coarse_clocktai_ts64(struct timespec64 *ts)
 207 {
 208         *ts = ktime_to_timespec64(ktime_get_coarse_clocktai());
 209 }
 210
 211 static inline time64_t ktime_get_clocktai_seconds(void)
 212 {
 213         return ktime_divns(ktime_get_coarse_clocktai(), NSEC_PER_SEC);
 214 }
 215
 216 /*
 217  * RTC specific
 218  */
 219 extern bool timekeeping_rtc_skipsuspend(void);
 220 extern bool timekeeping_rtc_skipresume(void);
 221
 222 extern void timekeeping_inject_sleeptime64(const struct timespec64 *delta);
 223
 224 /*
 225  * struct ktime_timestanps - Simultaneous mono/boot/real timestamps
 226  * @mono:       Monotonic timestamp
 227  * @boot:       Boottime timestamp
 228  * @real:       Realtime timestamp
 229  */
 230 struct ktime_timestamps {
 231         u64             mono;
 232         u64             boot;
 233         u64             real;
 234 };
 235
 236 /**
 237  * struct system_time_snapshot - simultaneous raw/real time capture with
 238  *                               counter value
 239  * @cycles:     Clocksource counter value to produce the system times
 240  * @real:       Realtime system time
 241  * @raw:        Monotonic raw system time
 242  * @clock_was_set_seq:  The sequence number of clock was set events
 243  * @cs_was_changed_seq: The sequence number of clocksource change events
 244  */
 245 struct system_time_snapshot {
 246         u64             cycles;
 247         ktime_t         real;
 248         ktime_t         raw;
 249         unsigned int    clock_was_set_seq;
 250         u8              cs_was_changed_seq;
 251 };
 252
 253 /**
 254  * struct system_device_crosststamp - system/device cross-timestamp
 255  *                                    (synchronized capture)
 256  * @device:             Device time
 257  * @sys_realtime:       Realtime simultaneous with device time
 258  * @sys_monoraw:        Monotonic raw simultaneous with device time
 259  */
 260 struct system_device_crosststamp {
 261         ktime_t device;
 262         ktime_t sys_realtime;
 263         ktime_t sys_monoraw;
 264 };
 265
 266 /**
 267  * struct system_counterval_t - system counter value with the pointer to the
 268  *                              corresponding clocksource
 269  * @cycles:     System counter value
 270  * @cs:         Clocksource corresponding to system counter value. Used by
 271  *              timekeeping code to verify comparibility of two cycle values
 272  */
 273 struct system_counterval_t {
 274         u64                     cycles;
 275         struct clocksource      *cs;
 276 };
 277
 278 /*
 279  * Get cross timestamp between system clock and device clock
 280  */
 281 extern int get_device_system_crosststamp(
 282                         int (*get_time_fn)(ktime_t *device_time,
 283                                 struct system_counterval_t *system_counterval,
 284                                 void *ctx),
 285                         void *ctx,
 286                         struct system_time_snapshot *history,
 287                         struct system_device_crosststamp *xtstamp);
 288
 289 /*
 290  * Simultaneously snapshot realtime and monotonic raw clocks
 291  */
 292 extern void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot);
 293
 294 /* NMI safe mono/boot/realtime timestamps */
 295 extern void ktime_get_fast_timestamps(struct ktime_timestamps *snap);
 296
 297 /*
 298  * Persistent clock related interfaces
 299  */
 300 extern int persistent_clock_is_local;
 301
 302 extern void read_persistent_clock64(struct timespec64 *ts);
 303 void read_persistent_wall_and_boot_offset(struct timespec64 *wall_clock,
 304                                           struct timespec64 *boot_offset);
 305 #ifdef CONFIG_GENERIC_CMOS_UPDATE
 306 extern int update_persistent_clock64(struct timespec64 now);
 307 #endif
 308
 309 #endif