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 static inline unsigned long long local_tick_disable(void) 56 { 57 unsigned long long old; 58 59 old = S390_lowcore.clock_comparator; 60 S390_lowcore.clock_comparator = -1ULL; 61 set_clock_comparator(S390_lowcore.clock_comparator); 62 return old; 63 } 64 65 static inline void local_tick_enable(unsigned long long comp) 66 { 67 S390_lowcore.clock_comparator = comp; 68 set_clock_comparator(S390_lowcore.clock_comparator); 69 } 70 71 #define CLOCK_TICK_RATE 1193180 /* Underlying HZ */ 72 #define STORE_CLOCK_EXT_SIZE 16 /* stcke writes 16 bytes */ 73 74 typedef unsigned long long cycles_t; 75 76 static inline void get_tod_clock_ext(char *clk) 77 { 78 typedef struct { char _[STORE_CLOCK_EXT_SIZE]; } addrtype; 79 80 asm volatile("stcke %0" : "=Q" (*(addrtype *) clk) : : "cc"); 81 } 82 83 static inline unsigned long long get_tod_clock(void) 84 { 85 unsigned char clk[STORE_CLOCK_EXT_SIZE]; 86 87 get_tod_clock_ext(clk); 88 return *((unsigned long long *)&clk[1]); 89 } 90 91 static inline unsigned long long get_tod_clock_fast(void) 92 { 93 #ifdef CONFIG_HAVE_MARCH_Z9_109_FEATURES 94 unsigned long long clk; 95 96 asm volatile("stckf %0" : "=Q" (clk) : : "cc"); 97 return clk; 98 #else 99 return get_tod_clock(); 100 #endif 101 } 102 103 static inline cycles_t get_cycles(void) 104 { 105 return (cycles_t) get_tod_clock() >> 2; 106 } 107 108 int get_sync_clock(unsigned long long *clock); 109 void init_cpu_timer(void); 110 unsigned long long monotonic_clock(void); 111 112 void tod_to_timeval(__u64 todval, struct timespec64 *xt); 113 114 static inline 115 void stck_to_timespec64(unsigned long long stck, struct timespec64 *ts) 116 { 117 tod_to_timeval(stck - TOD_UNIX_EPOCH, ts); 118 } 119 120 extern u64 sched_clock_base_cc; 121 122 /** 123 * get_clock_monotonic - returns current time in clock rate units 124 * 125 * The caller must ensure that preemption is disabled. 126 * The clock and sched_clock_base get changed via stop_machine. 127 * Therefore preemption must be disabled when calling this 128 * function, otherwise the returned value is not guaranteed to 129 * be monotonic. 130 */ 131 static inline unsigned long long get_tod_clock_monotonic(void) 132 { 133 return get_tod_clock() - sched_clock_base_cc; 134 } 135 136 /** 137 * tod_to_ns - convert a TOD format value to nanoseconds 138 * @todval: to be converted TOD format value 139 * Returns: number of nanoseconds that correspond to the TOD format value 140 * 141 * Converting a 64 Bit TOD format value to nanoseconds means that the value 142 * must be divided by 4.096. In order to achieve that we multiply with 125 143 * and divide by 512: 144 * 145 * ns = (todval * 125) >> 9; 146 * 147 * In order to avoid an overflow with the multiplication we can rewrite this. 148 * With a split todval == 2^32 * th + tl (th upper 32 bits, tl lower 32 bits) 149 * we end up with 150 * 151 * ns = ((2^32 * th + tl) * 125 ) >> 9; 152 * -> ns = (2^23 * th * 125) + ((tl * 125) >> 9); 153 * 154 */ 155 static inline unsigned long long tod_to_ns(unsigned long long todval) 156 { 157 unsigned long long ns; 158 159 ns = ((todval >> 32) << 23) * 125; 160 ns += ((todval & 0xffffffff) * 125) >> 9; 161 return ns; 162 } 163 164 #endif 165