Branch data     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 update_process_times(int user);
      14                 :            : extern void xtime_update(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                 :        573 : static inline ktime_t ktime_get_real(void)
      78                 :            : {
      79                 :        573 :         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                 :       1424 : static inline ktime_t ktime_get_boottime(void)
      94                 :            : {
      95                 :       1424 :         return ktime_get_with_offset(TK_OFFS_BOOT);
      96                 :            : }
      97                 :            : 
      98                 :          0 : static inline ktime_t ktime_get_coarse_boottime(void)
      99                 :            : {
     100                 :          0 :         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                 :         72 : static inline ktime_t ktime_mono_to_real(ktime_t mono)
     148                 :            : {
     149                 :         72 :         return ktime_mono_to_any(mono, TK_OFFS_REAL);
     150                 :            : }
     151                 :            : 
     152                 :      12526 : static inline u64 ktime_get_ns(void)
     153                 :            : {
     154   [ +  -  #  # ]:      12526 :         return ktime_to_ns(ktime_get());
     155                 :            : }
     156                 :            : 
     157                 :          0 : static inline u64 ktime_get_real_ns(void)
     158                 :            : {
     159                 :          0 :         return ktime_to_ns(ktime_get_real());
     160                 :            : }
     161                 :            : 
     162                 :       1397 : static inline u64 ktime_get_boottime_ns(void)
     163                 :            : {
     164                 :       1397 :         return ktime_to_ns(ktime_get_boottime());
     165                 :            : }
     166                 :            : 
     167                 :          0 : static inline u64 ktime_get_clocktai_ns(void)
     168                 :            : {
     169                 :          0 :         return ktime_to_ns(ktime_get_clocktai());
     170                 :            : }
     171                 :            : 
     172                 :          0 : static inline u64 ktime_get_raw_ns(void)
     173                 :            : {
     174         [ #  # ]:          0 :         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_real_fast_ns(void);
     181                 :            : 
     182                 :            : /*
     183                 :            :  * timespec64/time64_t interfaces utilizing the ktime based ones
     184                 :            :  * for API completeness, these could be implemented more efficiently
     185                 :            :  * if needed.
     186                 :            :  */
     187                 :         24 : static inline void ktime_get_boottime_ts64(struct timespec64 *ts)
     188                 :            : {
     189                 :         24 :         *ts = ktime_to_timespec64(ktime_get_boottime());
     190                 :         24 : }
     191                 :            : 
     192                 :            : static inline void ktime_get_coarse_boottime_ts64(struct timespec64 *ts)
     193                 :            : {
     194                 :            :         *ts = ktime_to_timespec64(ktime_get_coarse_boottime());
     195                 :            : }
     196                 :            : 
     197                 :          0 : static inline time64_t ktime_get_boottime_seconds(void)
     198                 :            : {
     199                 :          0 :         return ktime_divns(ktime_get_coarse_boottime(), NSEC_PER_SEC);
     200                 :            : }
     201                 :            : 
     202                 :          0 : static inline void ktime_get_clocktai_ts64(struct timespec64 *ts)
     203                 :            : {
     204                 :          0 :         *ts = ktime_to_timespec64(ktime_get_clocktai());
     205                 :          0 : }
     206                 :            : 
     207                 :            : static inline void ktime_get_coarse_clocktai_ts64(struct timespec64 *ts)
     208                 :            : {
     209                 :            :         *ts = ktime_to_timespec64(ktime_get_coarse_clocktai());
     210                 :            : }
     211                 :            : 
     212                 :            : static inline time64_t ktime_get_clocktai_seconds(void)
     213                 :            : {
     214                 :            :         return ktime_divns(ktime_get_coarse_clocktai(), NSEC_PER_SEC);
     215                 :            : }
     216                 :            : 
     217                 :            : /*
     218                 :            :  * RTC specific
     219                 :            :  */
     220                 :            : extern bool timekeeping_rtc_skipsuspend(void);
     221                 :            : extern bool timekeeping_rtc_skipresume(void);
     222                 :            : 
     223                 :            : extern void timekeeping_inject_sleeptime64(const struct timespec64 *delta);
     224                 :            : 
     225                 :            : /*
     226                 :            :  * struct system_time_snapshot - simultaneous raw/real time capture with
     227                 :            :  *      counter value
     228                 :            :  * @cycles:     Clocksource counter value to produce the system times
     229                 :            :  * @real:       Realtime system time
     230                 :            :  * @raw:        Monotonic raw system time
     231                 :            :  * @clock_was_set_seq:  The sequence number of clock was set events
     232                 :            :  * @cs_was_changed_seq: The sequence number of clocksource change events
     233                 :            :  */
     234                 :            : struct system_time_snapshot {
     235                 :            :         u64             cycles;
     236                 :            :         ktime_t         real;
     237                 :            :         ktime_t         raw;
     238                 :            :         unsigned int    clock_was_set_seq;
     239                 :            :         u8              cs_was_changed_seq;
     240                 :            : };
     241                 :            : 
     242                 :            : /*
     243                 :            :  * struct system_device_crosststamp - system/device cross-timestamp
     244                 :            :  *      (syncronized capture)
     245                 :            :  * @device:             Device time
     246                 :            :  * @sys_realtime:       Realtime simultaneous with device time
     247                 :            :  * @sys_monoraw:        Monotonic raw simultaneous with device time
     248                 :            :  */
     249                 :            : struct system_device_crosststamp {
     250                 :            :         ktime_t device;
     251                 :            :         ktime_t sys_realtime;
     252                 :            :         ktime_t sys_monoraw;
     253                 :            : };
     254                 :            : 
     255                 :            : /*
     256                 :            :  * struct system_counterval_t - system counter value with the pointer to the
     257                 :            :  *      corresponding clocksource
     258                 :            :  * @cycles:     System counter value
     259                 :            :  * @cs:         Clocksource corresponding to system counter value. Used by
     260                 :            :  *      timekeeping code to verify comparibility of two cycle values
     261                 :            :  */
     262                 :            : struct system_counterval_t {
     263                 :            :         u64                     cycles;
     264                 :            :         struct clocksource      *cs;
     265                 :            : };
     266                 :            : 
     267                 :            : /*
     268                 :            :  * Get cross timestamp between system clock and device clock
     269                 :            :  */
     270                 :            : extern int get_device_system_crosststamp(
     271                 :            :                         int (*get_time_fn)(ktime_t *device_time,
     272                 :            :                                 struct system_counterval_t *system_counterval,
     273                 :            :                                 void *ctx),
     274                 :            :                         void *ctx,
     275                 :            :                         struct system_time_snapshot *history,
     276                 :            :                         struct system_device_crosststamp *xtstamp);
     277                 :            : 
     278                 :            : /*
     279                 :            :  * Simultaneously snapshot realtime and monotonic raw clocks
     280                 :            :  */
     281                 :            : extern void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot);
     282                 :            : 
     283                 :            : /*
     284                 :            :  * Persistent clock related interfaces
     285                 :            :  */
     286                 :            : extern int persistent_clock_is_local;
     287                 :            : 
     288                 :            : extern void read_persistent_clock64(struct timespec64 *ts);
     289                 :            : void read_persistent_wall_and_boot_offset(struct timespec64 *wall_clock,
     290                 :            :                                           struct timespec64 *boot_offset);
     291                 :            : extern int update_persistent_clock64(struct timespec64 now);
     292                 :            : 
     293                 :            : #endif