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 cputime_t; 20typedef unsigned long long cputime64_t; 21 22#ifndef __s390x__ 23 24static inline unsigned int 25__div(unsigned long long n, unsigned int base) 26{ 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} 33 34#else /* __s390x__ */ 35 36static inline unsigned int 37__div(unsigned long long n, unsigned int base) 38{ 39 return n / base; 40} 41 42#endif /* __s390x__ */ 43 44#define cputime_zero (0ULL) 45#define cputime_one_jiffy jiffies_to_cputime(1) 46#define cputime_max ((~0UL >> 1) - 1) 47#define cputime_add(__a, __b) ((__a) + (__b)) 48#define cputime_sub(__a, __b) ((__a) - (__b)) 49#define cputime_div(__a, __n) ({ \ 50 unsigned long long __div = (__a); \ 51 do_div(__div,__n); \ 52 __div; \ 53}) 54#define cputime_halve(__a) ((__a) >> 1) 55#define cputime_eq(__a, __b) ((__a) == (__b)) 56#define cputime_gt(__a, __b) ((__a) > (__b)) 57#define cputime_ge(__a, __b) ((__a) >= (__b)) 58#define cputime_lt(__a, __b) ((__a) < (__b)) 59#define cputime_le(__a, __b) ((__a) <= (__b)) 60#define cputime_to_jiffies(__ct) (__div((__ct), 4096000000ULL / HZ)) 61#define cputime_to_scaled(__ct) (__ct) 62#define jiffies_to_cputime(__hz) ((cputime_t)(__hz) * (4096000000ULL / HZ)) 63 64#define cputime64_zero (0ULL) 65#define cputime64_add(__a, __b) ((__a) + (__b)) 66#define cputime_to_cputime64(__ct) (__ct) 67 68static inline u64 69cputime64_to_jiffies64(cputime64_t cputime) 70{ 71 do_div(cputime, 4096000000ULL / HZ); 72 return cputime; 73} 74 75/* 76 * Convert cputime to milliseconds and back. 77 */ 78static inline unsigned int 79cputime_to_msecs(const cputime_t cputime) 80{ 81 return cputime_div(cputime, 4096000); 82} 83 84static inline cputime_t 85msecs_to_cputime(const unsigned int m) 86{ 87 return (cputime_t) m * 4096000; 88} 89 90/* 91 * Convert cputime to milliseconds and back. 92 */ 93static inline unsigned int 94cputime_to_secs(const cputime_t cputime) 95{ 96 return __div(cputime, 2048000000) >> 1; 97} 98 99static inline cputime_t 100secs_to_cputime(const unsigned int s) 101{ 102 return (cputime_t) s * 4096000000ULL; 103} 104 105/* 106 * Convert cputime to timespec and back. 107 */ 108static inline cputime_t 109timespec_to_cputime(const struct timespec *value) 110{ 111 return value->tv_nsec * 4096 / 1000 + (u64) value->tv_sec * 4096000000ULL; 112} 113 114static inline void 115cputime_to_timespec(const cputime_t cputime, struct timespec *value) 116{ 117#ifndef __s390x__ 118 register_pair rp; 119 120 rp.pair = cputime >> 1; 121 asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL)); 122 value->tv_nsec = rp.subreg.even * 1000 / 4096; 123 value->tv_sec = rp.subreg.odd; 124#else 125 value->tv_nsec = (cputime % 4096000000ULL) * 1000 / 4096; 126 value->tv_sec = cputime / 4096000000ULL; 127#endif 128} 129 130/* 131 * Convert cputime to timeval and back. 132 * Since cputime and timeval have the same resolution (microseconds) 133 * this is easy. 134 */ 135static inline cputime_t 136timeval_to_cputime(const struct timeval *value) 137{ 138 return value->tv_usec * 4096 + (u64) value->tv_sec * 4096000000ULL; 139} 140 141static inline void 142cputime_to_timeval(const cputime_t cputime, struct timeval *value) 143{ 144#ifndef __s390x__ 145 register_pair rp; 146 147 rp.pair = cputime >> 1; 148 asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL)); 149 value->tv_usec = rp.subreg.even / 4096; 150 value->tv_sec = rp.subreg.odd; 151#else 152 value->tv_usec = (cputime % 4096000000ULL) / 4096; 153 value->tv_sec = cputime / 4096000000ULL; 154#endif 155} 156 157/* 158 * Convert cputime to clock and back. 159 */ 160static inline clock_t 161cputime_to_clock_t(cputime_t cputime) 162{ 163 return cputime_div(cputime, 4096000000ULL / USER_HZ); 164} 165 166static inline cputime_t 167clock_t_to_cputime(unsigned long x) 168{ 169 return (cputime_t) x * (4096000000ULL / USER_HZ); 170} 171 172/* 173 * Convert cputime64 to clock. 174 */ 175static inline clock_t 176cputime64_to_clock_t(cputime64_t cputime) 177{ 178 return cputime_div(cputime, 4096000000ULL / USER_HZ); 179} 180 181struct s390_idle_data { 182 unsigned int sequence; 183 unsigned long long idle_count; 184 unsigned long long idle_enter; 185 unsigned long long idle_time; 186 int nohz_delay; 187}; 188 189DECLARE_PER_CPU(struct s390_idle_data, s390_idle); 190 191void vtime_start_cpu(__u64 int_clock, __u64 enter_timer); 192cputime64_t s390_get_idle_time(int cpu); 193 194#define arch_idle_time(cpu) s390_get_idle_time(cpu) 195 196static inline void s390_idle_check(struct pt_regs *regs, __u64 int_clock, 197 __u64 enter_timer) 198{ 199 if (regs->psw.mask & PSW_MASK_WAIT) 200 vtime_start_cpu(int_clock, enter_timer); 201} 202 203static inline int s390_nohz_delay(int cpu) 204{ 205 return per_cpu(s390_idle, cpu).nohz_delay != 0; 206} 207 208#define arch_needs_cpu(cpu) s390_nohz_delay(cpu) 209 210#endif /* _S390_CPUTIME_H */ 211