1 /* 2 * S390 version 3 * Copyright IBM Corp. 1999 4 * 5 * Derived from "include/asm-i386/timex.h" 6 * Copyright (C) 1992, Linus Torvalds 7 */ 8 9 #ifndef _ASM_S390_TIMEX_H 10 #define _ASM_S390_TIMEX_H 11 12 #include <asm/lowcore.h> 13 #include <linux/time64.h> 14 15 /* The value of the TOD clock for 1.1.1970. */ 16 #define TOD_UNIX_EPOCH 0x7d91048bca000000ULL 17 18 /* Inline functions for clock register access. */ 19 static inline int set_tod_clock(__u64 time) 20 { 21 int cc; 22 23 asm volatile( 24 " sck %1\n" 25 " ipm %0\n" 26 " srl %0,28\n" 27 : "=d" (cc) : "Q" (time) : "cc"); 28 return cc; 29 } 30 31 static inline int store_tod_clock(__u64 *time) 32 { 33 int cc; 34 35 asm volatile( 36 " stck %1\n" 37 " ipm %0\n" 38 " srl %0,28\n" 39 : "=d" (cc), "=Q" (*time) : : "cc"); 40 return cc; 41 } 42 43 static inline void set_clock_comparator(__u64 time) 44 { 45 asm volatile("sckc %0" : : "Q" (time)); 46 } 47 48 static inline void store_clock_comparator(__u64 *time) 49 { 50 asm volatile("stckc %0" : "=Q" (*time)); 51 } 52 53 void clock_comparator_work(void); 54 55 void __init ptff_init(void); 56 57 extern unsigned char ptff_function_mask[16]; 58 extern unsigned long lpar_offset; 59 extern unsigned long initial_leap_seconds; 60 61 /* Function codes for the ptff instruction. */ 62 #define PTFF_QAF 0x00 /* query available functions */ 63 #define PTFF_QTO 0x01 /* query tod offset */ 64 #define PTFF_QSI 0x02 /* query steering information */ 65 #define PTFF_QUI 0x04 /* query UTC information */ 66 #define PTFF_ATO 0x40 /* adjust tod offset */ 67 #define PTFF_STO 0x41 /* set tod offset */ 68 #define PTFF_SFS 0x42 /* set fine steering rate */ 69 #define PTFF_SGS 0x43 /* set gross steering rate */ 70 71 /* Query TOD offset result */ 72 struct ptff_qto { 73 unsigned long long physical_clock; 74 unsigned long long tod_offset; 75 unsigned long long logical_tod_offset; 76 unsigned long long tod_epoch_difference; 77 } __packed; 78 79 static inline int ptff_query(unsigned int nr) 80 { 81 unsigned char *ptr; 82 83 ptr = ptff_function_mask + (nr >> 3); 84 return (*ptr & (0x80 >> (nr & 7))) != 0; 85 } 86 87 /* Query UTC information result */ 88 struct ptff_qui { 89 unsigned int tm : 2; 90 unsigned int ts : 2; 91 unsigned int : 28; 92 unsigned int pad_0x04; 93 unsigned long leap_event; 94 short old_leap; 95 short new_leap; 96 unsigned int pad_0x14; 97 unsigned long prt[5]; 98 unsigned long cst[3]; 99 unsigned int skew; 100 unsigned int pad_0x5c[41]; 101 } __packed; 102 103 static inline int ptff(void *ptff_block, size_t len, unsigned int func) 104 { 105 typedef struct { char _[len]; } addrtype; 106 register unsigned int reg0 asm("0") = func; 107 register unsigned long reg1 asm("1") = (unsigned long) ptff_block; 108 int rc; 109 110 asm volatile( 111 " .word 0x0104\n" 112 " ipm %0\n" 113 " srl %0,28\n" 114 : "=d" (rc), "+m" (*(addrtype *) ptff_block) 115 : "d" (reg0), "d" (reg1) : "cc"); 116 return rc; 117 } 118 119 static inline unsigned long long local_tick_disable(void) 120 { 121 unsigned long long old; 122 123 old = S390_lowcore.clock_comparator; 124 S390_lowcore.clock_comparator = -1ULL; 125 set_clock_comparator(S390_lowcore.clock_comparator); 126 return old; 127 } 128 129 static inline void local_tick_enable(unsigned long long comp) 130 { 131 S390_lowcore.clock_comparator = comp; 132 set_clock_comparator(S390_lowcore.clock_comparator); 133 } 134 135 #define CLOCK_TICK_RATE 1193180 /* Underlying HZ */ 136 #define STORE_CLOCK_EXT_SIZE 16 /* stcke writes 16 bytes */ 137 138 typedef unsigned long long cycles_t; 139 140 static inline void get_tod_clock_ext(char *clk) 141 { 142 typedef struct { char _[STORE_CLOCK_EXT_SIZE]; } addrtype; 143 144 asm volatile("stcke %0" : "=Q" (*(addrtype *) clk) : : "cc"); 145 } 146 147 static inline unsigned long long get_tod_clock(void) 148 { 149 unsigned char clk[STORE_CLOCK_EXT_SIZE]; 150 151 get_tod_clock_ext(clk); 152 return *((unsigned long long *)&clk[1]); 153 } 154 155 static inline unsigned long long get_tod_clock_fast(void) 156 { 157 #ifdef CONFIG_HAVE_MARCH_Z9_109_FEATURES 158 unsigned long long clk; 159 160 asm volatile("stckf %0" : "=Q" (clk) : : "cc"); 161 return clk; 162 #else 163 return get_tod_clock(); 164 #endif 165 } 166 167 static inline cycles_t get_cycles(void) 168 { 169 return (cycles_t) get_tod_clock() >> 2; 170 } 171 172 int get_phys_clock(unsigned long long *clock); 173 void init_cpu_timer(void); 174 unsigned long long monotonic_clock(void); 175 176 void tod_to_timeval(__u64 todval, struct timespec64 *xt); 177 178 static inline 179 void stck_to_timespec64(unsigned long long stck, struct timespec64 *ts) 180 { 181 tod_to_timeval(stck - TOD_UNIX_EPOCH, ts); 182 } 183 184 extern u64 sched_clock_base_cc; 185 186 /** 187 * get_clock_monotonic - returns current time in clock rate units 188 * 189 * The caller must ensure that preemption is disabled. 190 * The clock and sched_clock_base get changed via stop_machine. 191 * Therefore preemption must be disabled when calling this 192 * function, otherwise the returned value is not guaranteed to 193 * be monotonic. 194 */ 195 static inline unsigned long long get_tod_clock_monotonic(void) 196 { 197 return get_tod_clock() - sched_clock_base_cc; 198 } 199 200 /** 201 * tod_to_ns - convert a TOD format value to nanoseconds 202 * @todval: to be converted TOD format value 203 * Returns: number of nanoseconds that correspond to the TOD format value 204 * 205 * Converting a 64 Bit TOD format value to nanoseconds means that the value 206 * must be divided by 4.096. In order to achieve that we multiply with 125 207 * and divide by 512: 208 * 209 * ns = (todval * 125) >> 9; 210 * 211 * In order to avoid an overflow with the multiplication we can rewrite this. 212 * With a split todval == 2^32 * th + tl (th upper 32 bits, tl lower 32 bits) 213 * we end up with 214 * 215 * ns = ((2^32 * th + tl) * 125 ) >> 9; 216 * -> ns = (2^23 * th * 125) + ((tl * 125) >> 9); 217 * 218 */ 219 static inline unsigned long long tod_to_ns(unsigned long long todval) 220 { 221 unsigned long long ns; 222 223 ns = ((todval >> 32) << 23) * 125; 224 ns += ((todval & 0xffffffff) * 125) >> 9; 225 return ns; 226 } 227 228 #endif 229