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