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 <asm/div64.h>
  12
  13 #define CPUTIME_PER_USEC 4096ULL
  14 #define CPUTIME_PER_SEC (CPUTIME_PER_USEC * USEC_PER_SEC)
  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 #define cmpxchg_cputime(ptr, old, new) cmpxchg64(ptr, old, new)
  22
  23 static inline unsigned long __div(unsigned long long n, unsigned long base)
  24 {
  25 #ifndef CONFIG_64BIT
  26         register_pair rp;
  27
  28         rp.pair = n >> 1;
  29         asm ("dr %0,%1" : "+d" (rp) : "d" (base >> 1));
  30         return rp.subreg.odd;
  31 #else /* CONFIG_64BIT */
  32         return n / base;
  33 #endif /* CONFIG_64BIT */
  34 }
  35
  36 #define cputime_one_jiffy               jiffies_to_cputime(1)
  37
  38 /*
  39  * Convert cputime to jiffies and back.
  40  */
  41 static inline unsigned long cputime_to_jiffies(const cputime_t cputime)
  42 {
  43         return __div((__force unsigned long long) cputime, CPUTIME_PER_SEC / HZ);
  44 }
  45
  46 static inline cputime_t jiffies_to_cputime(const unsigned int jif)
  47 {
  48         return (__force cputime_t)(jif * (CPUTIME_PER_SEC / HZ));
  49 }
  50
  51 static inline u64 cputime64_to_jiffies64(cputime64_t cputime)
  52 {
  53         unsigned long long jif = (__force unsigned long long) cputime;
  54         do_div(jif, CPUTIME_PER_SEC / HZ);
  55         return jif;
  56 }
  57
  58 static inline cputime64_t jiffies64_to_cputime64(const u64 jif)
  59 {
  60         return (__force cputime64_t)(jif * (CPUTIME_PER_SEC / HZ));
  61 }
  62
  63 /*
  64  * Convert cputime to microseconds and back.
  65  */
  66 static inline unsigned int cputime_to_usecs(const cputime_t cputime)
  67 {
  68         return (__force unsigned long long) cputime >> 12;
  69 }
  70
  71 static inline cputime_t usecs_to_cputime(const unsigned int m)
  72 {
  73         return (__force cputime_t)(m * CPUTIME_PER_USEC);
  74 }
  75
  76 #define usecs_to_cputime64(m)           usecs_to_cputime(m)
  77
  78 /*
  79  * Convert cputime to milliseconds and back.
  80  */
  81 static inline unsigned int cputime_to_secs(const cputime_t cputime)
  82 {
  83         return __div((__force unsigned long long) cputime, CPUTIME_PER_SEC / 2) >> 1;
  84 }
  85
  86 static inline cputime_t secs_to_cputime(const unsigned int s)
  87 {
  88         return (__force cputime_t)(s * CPUTIME_PER_SEC);
  89 }
  90
  91 /*
  92  * Convert cputime to timespec and back.
  93  */
  94 static inline cputime_t timespec_to_cputime(const struct timespec *value)
  95 {
  96         unsigned long long ret = value->tv_sec * CPUTIME_PER_SEC;
  97         return (__force cputime_t)(ret + __div(value->tv_nsec * CPUTIME_PER_USEC, NSEC_PER_USEC));
  98 }
  99
 100 static inline void cputime_to_timespec(const cputime_t cputime,
 101                                        struct timespec *value)
 102 {
 103         unsigned long long __cputime = (__force unsigned long long) cputime;
 104 #ifndef CONFIG_64BIT
 105         register_pair rp;
 106
 107         rp.pair = __cputime >> 1;
 108         asm ("dr %0,%1" : "+d" (rp) : "d" (CPUTIME_PER_SEC / 2));
 109         value->tv_nsec = rp.subreg.even * NSEC_PER_USEC / CPUTIME_PER_USEC;
 110         value->tv_sec = rp.subreg.odd;
 111 #else
 112         value->tv_nsec = (__cputime % CPUTIME_PER_SEC) * NSEC_PER_USEC / CPUTIME_PER_USEC;
 113         value->tv_sec = __cputime / CPUTIME_PER_SEC;
 114 #endif
 115 }
 116
 117 /*
 118  * Convert cputime to timeval and back.
 119  * Since cputime and timeval have the same resolution (microseconds)
 120  * this is easy.
 121  */
 122 static inline cputime_t timeval_to_cputime(const struct timeval *value)
 123 {
 124         unsigned long long ret = value->tv_sec * CPUTIME_PER_SEC;
 125         return (__force cputime_t)(ret + value->tv_usec * CPUTIME_PER_USEC);
 126 }
 127
 128 static inline void cputime_to_timeval(const cputime_t cputime,
 129                                       struct timeval *value)
 130 {
 131         unsigned long long __cputime = (__force unsigned long long) cputime;
 132 #ifndef CONFIG_64BIT
 133         register_pair rp;
 134
 135         rp.pair = __cputime >> 1;
 136         asm ("dr %0,%1" : "+d" (rp) : "d" (CPUTIME_PER_USEC / 2));
 137         value->tv_usec = rp.subreg.even / CPUTIME_PER_USEC;
 138         value->tv_sec = rp.subreg.odd;
 139 #else
 140         value->tv_usec = (__cputime % CPUTIME_PER_SEC) / CPUTIME_PER_USEC;
 141         value->tv_sec = __cputime / CPUTIME_PER_SEC;
 142 #endif
 143 }
 144
 145 /*
 146  * Convert cputime to clock and back.
 147  */
 148 static inline clock_t cputime_to_clock_t(cputime_t cputime)
 149 {
 150         unsigned long long clock = (__force unsigned long long) cputime;
 151         do_div(clock, CPUTIME_PER_SEC / USER_HZ);
 152         return clock;
 153 }
 154
 155 static inline cputime_t clock_t_to_cputime(unsigned long x)
 156 {
 157         return (__force cputime_t)(x * (CPUTIME_PER_SEC / USER_HZ));
 158 }
 159
 160 /*
 161  * Convert cputime64 to clock.
 162  */
 163 static inline clock_t cputime64_to_clock_t(cputime64_t cputime)
 164 {
 165         unsigned long long clock = (__force unsigned long long) cputime;
 166         do_div(clock, CPUTIME_PER_SEC / USER_HZ);
 167         return clock;
 168 }
 169
 170 cputime64_t arch_cpu_idle_time(int cpu);
 171
 172 #define arch_idle_time(cpu) arch_cpu_idle_time(cpu)
 173
 174 #endif /* _S390_CPUTIME_H */