arch/s390/include/asm/cputime.h

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