Line data    Source code

       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         525 : static inline ktime_t ktime_get_real(void)
      77             : {
      78         525 :         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         928 : static inline ktime_t ktime_get_boottime(void)
      93             : {
      94         928 :         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           0 : static inline ktime_t ktime_get_clocktai(void)
     106             : {
     107           0 :         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          24 : static inline ktime_t ktime_mono_to_real(ktime_t mono)
     147             : {
     148          24 :         return ktime_mono_to_any(mono, TK_OFFS_REAL);
     149             : }
     150             : 
     151       13596 : static inline u64 ktime_get_ns(void)
     152             : {
     153       13596 :         return ktime_to_ns(ktime_get());
     154             : }
     155             : 
     156           4 : static inline u64 ktime_get_real_ns(void)
     157             : {
     158           4 :         return ktime_to_ns(ktime_get_real());
     159             : }
     160             : 
     161         916 : static inline u64 ktime_get_boottime_ns(void)
     162             : {
     163         916 :         return ktime_to_ns(ktime_get_boottime());
     164             : }
     165             : 
     166           0 : static inline u64 ktime_get_clocktai_ns(void)
     167             : {
     168           0 :         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          11 : static inline void ktime_get_boottime_ts64(struct timespec64 *ts)
     187             : {
     188          11 :         *ts = ktime_to_timespec64(ktime_get_boottime());
     189          11 : }
     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           0 : static inline void ktime_get_clocktai_ts64(struct timespec64 *ts)
     202             : {
     203           0 :         *ts = ktime_to_timespec64(ktime_get_clocktai());
     204           0 : }
     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