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