1 /* 2 * Copyright IBM Corp. 2004 3 * 4 * Author: Martin Schwidefsky <schwidefsky@de.ibm.com> 5 */ 6 7 #ifndef _S390_CPUTIME_H 8 #define _S390_CPUTIME_H 9 10 #include <linux/types.h> 11 #include <linux/percpu.h> 12 #include <linux/spinlock.h> 13 #include <asm/div64.h> 14 15 16 /* We want to use full resolution of the CPU timer: 2**-12 micro-seconds. */ 17 18 typedef unsigned long long __nocast cputime_t; 19 typedef unsigned long long __nocast cputime64_t; 20 21 static inline unsigned long __div(unsigned long long n, unsigned long base) 22 { 23 #ifndef CONFIG_64BIT 24 register_pair rp; 25 26 rp.pair = n >> 1; 27 asm ("dr %0,%1" : "+d" (rp) : "d" (base >> 1)); 28 return rp.subreg.odd; 29 #else /* CONFIG_64BIT */ 30 return n / base; 31 #endif /* CONFIG_64BIT */ 32 } 33 34 #define cputime_one_jiffy jiffies_to_cputime(1) 35 36 /* 37 * Convert cputime to jiffies and back. 38 */ 39 static inline unsigned long cputime_to_jiffies(const cputime_t cputime) 40 { 41 return __div((__force unsigned long long) cputime, 4096000000ULL / HZ); 42 } 43 44 static inline cputime_t jiffies_to_cputime(const unsigned int jif) 45 { 46 return (__force cputime_t)(jif * (4096000000ULL / HZ)); 47 } 48 49 static inline u64 cputime64_to_jiffies64(cputime64_t cputime) 50 { 51 unsigned long long jif = (__force unsigned long long) cputime; 52 do_div(jif, 4096000000ULL / HZ); 53 return jif; 54 } 55 56 static inline cputime64_t jiffies64_to_cputime64(const u64 jif) 57 { 58 return (__force cputime64_t)(jif * (4096000000ULL / HZ)); 59 } 60 61 /* 62 * Convert cputime to microseconds and back. 63 */ 64 static inline unsigned int cputime_to_usecs(const cputime_t cputime) 65 { 66 return (__force unsigned long long) cputime >> 12; 67 } 68 69 static inline cputime_t usecs_to_cputime(const unsigned int m) 70 { 71 return (__force cputime_t)(m * 4096ULL); 72 } 73 74 #define usecs_to_cputime64(m) usecs_to_cputime(m) 75 76 /* 77 * Convert cputime to milliseconds and back. 78 */ 79 static inline unsigned int cputime_to_secs(const cputime_t cputime) 80 { 81 return __div((__force unsigned long long) cputime, 2048000000) >> 1; 82 } 83 84 static inline cputime_t secs_to_cputime(const unsigned int s) 85 { 86 return (__force cputime_t)(s * 4096000000ULL); 87 } 88 89 /* 90 * Convert cputime to timespec and back. 91 */ 92 static inline cputime_t timespec_to_cputime(const struct timespec *value) 93 { 94 unsigned long long ret = value->tv_sec * 4096000000ULL; 95 return (__force cputime_t)(ret + value->tv_nsec * 4096 / 1000); 96 } 97 98 static inline void cputime_to_timespec(const cputime_t cputime, 99 struct timespec *value) 100 { 101 unsigned long long __cputime = (__force unsigned long long) cputime; 102 #ifndef CONFIG_64BIT 103 register_pair rp; 104 105 rp.pair = __cputime >> 1; 106 asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL)); 107 value->tv_nsec = rp.subreg.even * 1000 / 4096; 108 value->tv_sec = rp.subreg.odd; 109 #else 110 value->tv_nsec = (__cputime % 4096000000ULL) * 1000 / 4096; 111 value->tv_sec = __cputime / 4096000000ULL; 112 #endif 113 } 114 115 /* 116 * Convert cputime to timeval and back. 117 * Since cputime and timeval have the same resolution (microseconds) 118 * this is easy. 119 */ 120 static inline cputime_t timeval_to_cputime(const struct timeval *value) 121 { 122 unsigned long long ret = value->tv_sec * 4096000000ULL; 123 return (__force cputime_t)(ret + value->tv_usec * 4096ULL); 124 } 125 126 static inline void cputime_to_timeval(const cputime_t cputime, 127 struct timeval *value) 128 { 129 unsigned long long __cputime = (__force unsigned long long) cputime; 130 #ifndef CONFIG_64BIT 131 register_pair rp; 132 133 rp.pair = __cputime >> 1; 134 asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL)); 135 value->tv_usec = rp.subreg.even / 4096; 136 value->tv_sec = rp.subreg.odd; 137 #else 138 value->tv_usec = (__cputime % 4096000000ULL) / 4096; 139 value->tv_sec = __cputime / 4096000000ULL; 140 #endif 141 } 142 143 /* 144 * Convert cputime to clock and back. 145 */ 146 static inline clock_t cputime_to_clock_t(cputime_t cputime) 147 { 148 unsigned long long clock = (__force unsigned long long) cputime; 149 do_div(clock, 4096000000ULL / USER_HZ); 150 return clock; 151 } 152 153 static inline cputime_t clock_t_to_cputime(unsigned long x) 154 { 155 return (__force cputime_t)(x * (4096000000ULL / USER_HZ)); 156 } 157 158 /* 159 * Convert cputime64 to clock. 160 */ 161 static inline clock_t cputime64_to_clock_t(cputime64_t cputime) 162 { 163 unsigned long long clock = (__force unsigned long long) cputime; 164 do_div(clock, 4096000000ULL / USER_HZ); 165 return clock; 166 } 167 168 struct s390_idle_data { 169 int nohz_delay; 170 unsigned int sequence; 171 unsigned long long idle_count; 172 unsigned long long idle_time; 173 unsigned long long clock_idle_enter; 174 unsigned long long clock_idle_exit; 175 unsigned long long timer_idle_enter; 176 unsigned long long timer_idle_exit; 177 }; 178 179 DECLARE_PER_CPU(struct s390_idle_data, s390_idle); 180 181 cputime64_t s390_get_idle_time(int cpu); 182 183 #define arch_idle_time(cpu) s390_get_idle_time(cpu) 184 185 static inline int s390_nohz_delay(int cpu) 186 { 187 return __get_cpu_var(s390_idle).nohz_delay != 0; 188 } 189 190 #define arch_needs_cpu(cpu) s390_nohz_delay(cpu) 191 192 #endif /* _S390_CPUTIME_H */ 193