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 19typedef unsigned long long __nocast cputime_t; 20typedef unsigned long long __nocast cputime64_t; 21 22static inline unsigned long __div(unsigned long long n, unsigned long base) 23{ 24#ifndef __s390x__ 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 /* __s390x__ */ 31 return n / base; 32#endif /* __s390x__ */ 33} 34 35#define cputime_one_jiffy jiffies_to_cputime(1) 36 37/* 38 * Convert cputime to jiffies and back. 39 */ 40static inline unsigned long cputime_to_jiffies(const cputime_t cputime) 41{ 42 return __div((__force unsigned long long) cputime, 4096000000ULL / HZ); 43} 44 45static inline cputime_t jiffies_to_cputime(const unsigned int jif) 46{ 47 return (__force cputime_t)(jif * (4096000000ULL / HZ)); 48} 49 50static 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 57static 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 */ 65static inline unsigned int cputime_to_usecs(const cputime_t cputime) 66{ 67 return (__force unsigned long long) cputime >> 12; 68} 69 70static 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 */ 80static inline unsigned int cputime_to_secs(const cputime_t cputime) 81{ 82 return __div((__force unsigned long long) cputime, 2048000000) >> 1; 83} 84 85static 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 */ 93static 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 99static 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 __s390x__ 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 */ 121static 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 127static 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 __s390x__ 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 */ 147static 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 154static 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 */ 162static 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 169struct 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 178DECLARE_PER_CPU(struct s390_idle_data, s390_idle); 179 180cputime64_t s390_get_idle_time(int cpu); 181 182#define arch_idle_time(cpu) s390_get_idle_time(cpu) 183 184static 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