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