Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 <asm/div64.h> | |
13 | ||
14 | /* We want to use micro-second resolution. */ | |
15 | ||
16 | typedef unsigned long long cputime_t; | |
17 | typedef unsigned long long cputime64_t; | |
18 | ||
19 | #ifndef __s390x__ | |
20 | ||
21 | static inline unsigned int | |
22 | __div(unsigned long long n, unsigned int base) | |
23 | { | |
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 | } | |
30 | ||
31 | #else /* __s390x__ */ | |
32 | ||
33 | static inline unsigned int | |
34 | __div(unsigned long long n, unsigned int base) | |
35 | { | |
36 | return n / base; | |
37 | } | |
38 | ||
39 | #endif /* __s390x__ */ | |
40 | ||
41 | #define cputime_zero (0ULL) | |
42 | #define cputime_max ((~0UL >> 1) - 1) | |
43 | #define cputime_add(__a, __b) ((__a) + (__b)) | |
44 | #define cputime_sub(__a, __b) ((__a) - (__b)) | |
45 | #define cputime_div(__a, __n) ({ \ | |
46 | unsigned long long __div = (__a); \ | |
47 | do_div(__div,__n); \ | |
48 | __div; \ | |
49 | }) | |
50 | #define cputime_halve(__a) ((__a) >> 1) | |
51 | #define cputime_eq(__a, __b) ((__a) == (__b)) | |
52 | #define cputime_gt(__a, __b) ((__a) > (__b)) | |
53 | #define cputime_ge(__a, __b) ((__a) >= (__b)) | |
54 | #define cputime_lt(__a, __b) ((__a) < (__b)) | |
55 | #define cputime_le(__a, __b) ((__a) <= (__b)) | |
56 | #define cputime_to_jiffies(__ct) (__div((__ct), 1000000 / HZ)) | |
06b8e878 | 57 | #define cputime_to_scaled(__ct) (__ct) |
1da177e4 LT |
58 | #define jiffies_to_cputime(__hz) ((cputime_t)(__hz) * (1000000 / HZ)) |
59 | ||
60 | #define cputime64_zero (0ULL) | |
61 | #define cputime64_add(__a, __b) ((__a) + (__b)) | |
62 | #define cputime_to_cputime64(__ct) (__ct) | |
63 | ||
64 | static inline u64 | |
65 | cputime64_to_jiffies64(cputime64_t cputime) | |
66 | { | |
67 | do_div(cputime, 1000000 / HZ); | |
68 | return cputime; | |
69 | } | |
70 | ||
71 | /* | |
72 | * Convert cputime to milliseconds and back. | |
73 | */ | |
74 | static inline unsigned int | |
75 | cputime_to_msecs(const cputime_t cputime) | |
76 | { | |
77 | return __div(cputime, 1000); | |
78 | } | |
79 | ||
80 | static inline cputime_t | |
81 | msecs_to_cputime(const unsigned int m) | |
82 | { | |
83 | return (cputime_t) m * 1000; | |
84 | } | |
85 | ||
86 | /* | |
87 | * Convert cputime to milliseconds and back. | |
88 | */ | |
89 | static inline unsigned int | |
90 | cputime_to_secs(const cputime_t cputime) | |
91 | { | |
92 | return __div(cputime, 1000000); | |
93 | } | |
94 | ||
95 | static inline cputime_t | |
96 | secs_to_cputime(const unsigned int s) | |
97 | { | |
98 | return (cputime_t) s * 1000000; | |
99 | } | |
100 | ||
101 | /* | |
102 | * Convert cputime to timespec and back. | |
103 | */ | |
104 | static inline cputime_t | |
105 | timespec_to_cputime(const struct timespec *value) | |
106 | { | |
107 | return value->tv_nsec / 1000 + (u64) value->tv_sec * 1000000; | |
108 | } | |
109 | ||
110 | static inline void | |
111 | cputime_to_timespec(const cputime_t cputime, struct timespec *value) | |
112 | { | |
113 | #ifndef __s390x__ | |
114 | register_pair rp; | |
115 | ||
116 | rp.pair = cputime >> 1; | |
117 | asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1)); | |
118 | value->tv_nsec = rp.subreg.even * 1000; | |
119 | value->tv_sec = rp.subreg.odd; | |
120 | #else | |
121 | value->tv_nsec = (cputime % 1000000) * 1000; | |
122 | value->tv_sec = cputime / 1000000; | |
123 | #endif | |
124 | } | |
125 | ||
126 | /* | |
127 | * Convert cputime to timeval and back. | |
128 | * Since cputime and timeval have the same resolution (microseconds) | |
129 | * this is easy. | |
130 | */ | |
131 | static inline cputime_t | |
132 | timeval_to_cputime(const struct timeval *value) | |
133 | { | |
134 | return value->tv_usec + (u64) value->tv_sec * 1000000; | |
135 | } | |
136 | ||
137 | static inline void | |
138 | cputime_to_timeval(const cputime_t cputime, struct timeval *value) | |
139 | { | |
140 | #ifndef __s390x__ | |
141 | register_pair rp; | |
142 | ||
143 | rp.pair = cputime >> 1; | |
144 | asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1)); | |
145 | value->tv_usec = rp.subreg.even; | |
146 | value->tv_sec = rp.subreg.odd; | |
147 | #else | |
148 | value->tv_usec = cputime % 1000000; | |
149 | value->tv_sec = cputime / 1000000; | |
150 | #endif | |
151 | } | |
152 | ||
153 | /* | |
154 | * Convert cputime to clock and back. | |
155 | */ | |
156 | static inline clock_t | |
157 | cputime_to_clock_t(cputime_t cputime) | |
158 | { | |
159 | return __div(cputime, 1000000 / USER_HZ); | |
160 | } | |
161 | ||
162 | static inline cputime_t | |
163 | clock_t_to_cputime(unsigned long x) | |
164 | { | |
165 | return (cputime_t) x * (1000000 / USER_HZ); | |
166 | } | |
167 | ||
168 | /* | |
169 | * Convert cputime64 to clock. | |
170 | */ | |
171 | static inline clock_t | |
172 | cputime64_to_clock_t(cputime64_t cputime) | |
173 | { | |
174 | return __div(cputime, 1000000 / USER_HZ); | |
175 | } | |
176 | ||
177 | #endif /* _S390_CPUTIME_H */ |