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