arch/s390/include/asm/timex.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  *  S390 version
   4  *    Copyright IBM Corp. 1999
   5  *
   6  *  Derived from "include/asm-i386/timex.h"
   7  *    Copyright (C) 1992, Linus Torvalds
   8  */
   9
  10 #ifndef _ASM_S390_TIMEX_H
  11 #define _ASM_S390_TIMEX_H
  12
  13 #include <linux/preempt.h>
  14 #include <linux/time64.h>
  15 #include <asm/lowcore.h>
  16
  17 /* The value of the TOD clock for 1.1.1970. */
  18 #define TOD_UNIX_EPOCH 0x7d91048bca000000ULL
  19
  20 extern u64 clock_comparator_max;
  21
  22 union tod_clock {
  23         __uint128_t val;
  24         struct {
  25                 __uint128_t ei  :  8; /* epoch index */
  26                 __uint128_t tod : 64; /* bits 0-63 of tod clock */
  27                 __uint128_t     : 40;
  28                 __uint128_t pf  : 16; /* programmable field */
  29         };
  30         struct {
  31                 __uint128_t eitod : 72; /* epoch index + bits 0-63 tod clock */
  32                 __uint128_t       : 56;
  33         };
  34         struct {
  35                 __uint128_t us  : 60; /* micro-seconds */
  36                 __uint128_t sus : 12; /* sub-microseconds */
  37                 __uint128_t     : 56;
  38         };
  39 } __packed;
  40
  41 /* Inline functions for clock register access. */
  42 static inline int set_tod_clock(__u64 time)
  43 {
  44         int cc;
  45
  46         asm volatile(
  47                 "   sck   %1\n"
  48                 "   ipm   %0\n"
  49                 "   srl   %0,28\n"
  50                 : "=d" (cc) : "Q" (time) : "cc");
  51         return cc;
  52 }
  53
  54 static inline int store_tod_clock_ext_cc(union tod_clock *clk)
  55 {
  56         int cc;
  57
  58         asm volatile(
  59                 "   stcke  %1\n"
  60                 "   ipm   %0\n"
  61                 "   srl   %0,28\n"
  62                 : "=d" (cc), "=Q" (*clk) : : "cc");
  63         return cc;
  64 }
  65
  66 static __always_inline void store_tod_clock_ext(union tod_clock *tod)
  67 {
  68         asm volatile("stcke %0" : "=Q" (*tod) : : "cc");
  69 }
  70
  71 static inline void set_clock_comparator(__u64 time)
  72 {
  73         asm volatile("sckc %0" : : "Q" (time));
  74 }
  75
  76 static inline void set_tod_programmable_field(u16 val)
  77 {
  78         asm volatile(
  79                 "       lgr     0,%[val]\n"
  80                 "       sckpf\n"
  81                 :
  82                 : [val] "d" ((unsigned long)val)
  83                 : "0");
  84 }
  85
  86 void clock_comparator_work(void);
  87
  88 void __init time_early_init(void);
  89
  90 extern unsigned char ptff_function_mask[16];
  91
  92 /* Function codes for the ptff instruction. */
  93 #define PTFF_QAF        0x00    /* query available functions */
  94 #define PTFF_QTO        0x01    /* query tod offset */
  95 #define PTFF_QSI        0x02    /* query steering information */
  96 #define PTFF_QUI        0x04    /* query UTC information */
  97 #define PTFF_ATO        0x40    /* adjust tod offset */
  98 #define PTFF_STO        0x41    /* set tod offset */
  99 #define PTFF_SFS        0x42    /* set fine steering rate */
 100 #define PTFF_SGS        0x43    /* set gross steering rate */
 101
 102 /* Query TOD offset result */
 103 struct ptff_qto {
 104         unsigned long physical_clock;
 105         unsigned long tod_offset;
 106         unsigned long logical_tod_offset;
 107         unsigned long tod_epoch_difference;
 108 } __packed;
 109
 110 static inline int ptff_query(unsigned int nr)
 111 {
 112         unsigned char *ptr;
 113
 114         ptr = ptff_function_mask + (nr >> 3);
 115         return (*ptr & (0x80 >> (nr & 7))) != 0;
 116 }
 117
 118 /* Query UTC information result */
 119 struct ptff_qui {
 120         unsigned int tm : 2;
 121         unsigned int ts : 2;
 122         unsigned int : 28;
 123         unsigned int pad_0x04;
 124         unsigned long leap_event;
 125         short old_leap;
 126         short new_leap;
 127         unsigned int pad_0x14;
 128         unsigned long prt[5];
 129         unsigned long cst[3];
 130         unsigned int skew;
 131         unsigned int pad_0x5c[41];
 132 } __packed;
 133
 134 /*
 135  * ptff - Perform timing facility function
 136  * @ptff_block: Pointer to ptff parameter block
 137  * @len: Length of parameter block
 138  * @func: Function code
 139  * Returns: Condition code (0 on success)
 140  */
 141 #define ptff(ptff_block, len, func)                                     \
 142 ({                                                                      \
 143         struct addrtype { char _[len]; };                               \
 144         unsigned int reg0 = func;                                       \
 145         unsigned long reg1 = (unsigned long)(ptff_block);               \
 146         int rc;                                                         \
 147                                                                         \
 148         asm volatile(                                                   \
 149                 "       lgr     0,%[reg0]\n"                            \
 150                 "       lgr     1,%[reg1]\n"                            \
 151                 "       ptff\n"                                         \
 152                 "       ipm     %[rc]\n"                                \
 153                 "       srl     %[rc],28\n"                             \
 154                 : [rc] "=&d" (rc), "+m" (*(struct addrtype *)reg1)      \
 155                 : [reg0] "d" (reg0), [reg1] "d" (reg1)                  \
 156                 : "cc", "0", "1");                                      \
 157         rc;                                                             \
 158 })
 159
 160 static inline unsigned long local_tick_disable(void)
 161 {
 162         unsigned long old;
 163
 164         old = get_lowcore()->clock_comparator;
 165         get_lowcore()->clock_comparator = clock_comparator_max;
 166         set_clock_comparator(get_lowcore()->clock_comparator);
 167         return old;
 168 }
 169
 170 static inline void local_tick_enable(unsigned long comp)
 171 {
 172         get_lowcore()->clock_comparator = comp;
 173         set_clock_comparator(get_lowcore()->clock_comparator);
 174 }
 175
 176 #define CLOCK_TICK_RATE         1193180 /* Underlying HZ */
 177
 178 typedef unsigned long cycles_t;
 179
 180 static __always_inline unsigned long get_tod_clock(void)
 181 {
 182         union tod_clock clk;
 183
 184         store_tod_clock_ext(&clk);
 185         return clk.tod;
 186 }
 187
 188 static inline unsigned long get_tod_clock_fast(void)
 189 {
 190         unsigned long clk;
 191
 192         asm volatile("stckf %0" : "=Q" (clk) : : "cc");
 193         return clk;
 194 }
 195
 196 static inline cycles_t get_cycles(void)
 197 {
 198         return (cycles_t) get_tod_clock() >> 2;
 199 }
 200 #define get_cycles get_cycles
 201
 202 int get_phys_clock(unsigned long *clock);
 203 void init_cpu_timer(void);
 204
 205 extern union tod_clock tod_clock_base;
 206
 207 static __always_inline unsigned long __get_tod_clock_monotonic(void)
 208 {
 209         return get_tod_clock() - tod_clock_base.tod;
 210 }
 211
 212 /**
 213  * get_clock_monotonic - returns current time in clock rate units
 214  *
 215  * The clock and tod_clock_base get changed via stop_machine.
 216  * Therefore preemption must be disabled, otherwise the returned
 217  * value is not guaranteed to be monotonic.
 218  */
 219 static inline unsigned long get_tod_clock_monotonic(void)
 220 {
 221         unsigned long tod;
 222
 223         preempt_disable_notrace();
 224         tod = __get_tod_clock_monotonic();
 225         preempt_enable_notrace();
 226         return tod;
 227 }
 228
 229 /**
 230  * tod_to_ns - convert a TOD format value to nanoseconds
 231  * @todval: to be converted TOD format value
 232  * Returns: number of nanoseconds that correspond to the TOD format value
 233  *
 234  * Converting a 64 Bit TOD format value to nanoseconds means that the value
 235  * must be divided by 4.096. In order to achieve that we multiply with 125
 236  * and divide by 512:
 237  *
 238  *    ns = (todval * 125) >> 9;
 239  *
 240  * In order to avoid an overflow with the multiplication we can rewrite this.
 241  * With a split todval == 2^9 * th + tl (th upper 55 bits, tl lower 9 bits)
 242  * we end up with
 243  *
 244  *    ns = ((2^9 * th + tl) * 125 ) >> 9;
 245  * -> ns = (th * 125) + ((tl * 125) >> 9);
 246  *
 247  */
 248 static __always_inline unsigned long tod_to_ns(unsigned long todval)
 249 {
 250         return ((todval >> 9) * 125) + (((todval & 0x1ff) * 125) >> 9);
 251 }
 252
 253 /**
 254  * tod_after - compare two 64 bit TOD values
 255  * @a: first 64 bit TOD timestamp
 256  * @b: second 64 bit TOD timestamp
 257  *
 258  * Returns: true if a is later than b
 259  */
 260 static inline int tod_after(unsigned long a, unsigned long b)
 261 {
 262         if (MACHINE_HAS_SCC)
 263                 return (long) a > (long) b;
 264         return a > b;
 265 }
 266
 267 /**
 268  * tod_after_eq - compare two 64 bit TOD values
 269  * @a: first 64 bit TOD timestamp
 270  * @b: second 64 bit TOD timestamp
 271  *
 272  * Returns: true if a is later than b
 273  */
 274 static inline int tod_after_eq(unsigned long a, unsigned long b)
 275 {
 276         if (MACHINE_HAS_SCC)
 277                 return (long) a >= (long) b;
 278         return a >= b;
 279 }
 280
 281 #endif