1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#ifndef __POWERPC_CPUTIME_H
17#define __POWERPC_CPUTIME_H
18
19#ifndef CONFIG_VIRT_CPU_ACCOUNTING
20#include <asm-generic/cputime.h>
21#ifdef __KERNEL__
22static inline void setup_cputime_one_jiffy(void) { }
23#endif
24#else
25
26#include <linux/types.h>
27#include <linux/time.h>
28#include <asm/div64.h>
29#include <asm/time.h>
30#include <asm/param.h>
31
32typedef u64 cputime_t;
33typedef u64 cputime64_t;
34
35#define cputime_zero ((cputime_t)0)
36#define cputime_max ((~((cputime_t)0) >> 1) - 1)
37#define cputime_add(__a, __b) ((__a) + (__b))
38#define cputime_sub(__a, __b) ((__a) - (__b))
39#define cputime_div(__a, __n) ((__a) / (__n))
40#define cputime_halve(__a) ((__a) >> 1)
41#define cputime_eq(__a, __b) ((__a) == (__b))
42#define cputime_gt(__a, __b) ((__a) > (__b))
43#define cputime_ge(__a, __b) ((__a) >= (__b))
44#define cputime_lt(__a, __b) ((__a) < (__b))
45#define cputime_le(__a, __b) ((__a) <= (__b))
46
47#define cputime64_zero ((cputime64_t)0)
48#define cputime64_add(__a, __b) ((__a) + (__b))
49#define cputime64_sub(__a, __b) ((__a) - (__b))
50#define cputime_to_cputime64(__ct) (__ct)
51
52#ifdef __KERNEL__
53
54
55
56
57extern cputime_t cputime_one_jiffy;
58
59
60
61
62extern u64 __cputime_jiffies_factor;
63DECLARE_PER_CPU(unsigned long, cputime_last_delta);
64DECLARE_PER_CPU(unsigned long, cputime_scaled_last_delta);
65
66static inline unsigned long cputime_to_jiffies(const cputime_t ct)
67{
68 return mulhdu(ct, __cputime_jiffies_factor);
69}
70
71
72
73static inline cputime_t cputime_to_scaled(const cputime_t ct)
74{
75 if (cpu_has_feature(CPU_FTR_SPURR) &&
76 per_cpu(cputime_last_delta, smp_processor_id()))
77 return ct *
78 per_cpu(cputime_scaled_last_delta, smp_processor_id())/
79 per_cpu(cputime_last_delta, smp_processor_id());
80 return ct;
81}
82
83static inline cputime_t jiffies_to_cputime(const unsigned long jif)
84{
85 cputime_t ct;
86 unsigned long sec;
87
88
89 ct = jif % HZ;
90 sec = jif / HZ;
91 if (ct) {
92 ct *= tb_ticks_per_sec;
93 do_div(ct, HZ);
94 }
95 if (sec)
96 ct += (cputime_t) sec * tb_ticks_per_sec;
97 return ct;
98}
99
100static inline void setup_cputime_one_jiffy(void)
101{
102 cputime_one_jiffy = jiffies_to_cputime(1);
103}
104
105static inline cputime64_t jiffies64_to_cputime64(const u64 jif)
106{
107 cputime_t ct;
108 u64 sec;
109
110
111 ct = jif % HZ;
112 sec = jif / HZ;
113 if (ct) {
114 ct *= tb_ticks_per_sec;
115 do_div(ct, HZ);
116 }
117 if (sec)
118 ct += (cputime_t) sec * tb_ticks_per_sec;
119 return ct;
120}
121
122static inline u64 cputime64_to_jiffies64(const cputime_t ct)
123{
124 return mulhdu(ct, __cputime_jiffies_factor);
125}
126
127
128
129
130extern u64 __cputime_msec_factor;
131
132static inline unsigned long cputime_to_msecs(const cputime_t ct)
133{
134 return mulhdu(ct, __cputime_msec_factor);
135}
136
137static inline cputime_t msecs_to_cputime(const unsigned long ms)
138{
139 cputime_t ct;
140 unsigned long sec;
141
142
143 ct = ms % 1000;
144 sec = ms / 1000;
145 if (ct) {
146 ct *= tb_ticks_per_sec;
147 do_div(ct, 1000);
148 }
149 if (sec)
150 ct += (cputime_t) sec * tb_ticks_per_sec;
151 return ct;
152}
153
154
155
156
157extern u64 __cputime_sec_factor;
158
159static inline unsigned long cputime_to_secs(const cputime_t ct)
160{
161 return mulhdu(ct, __cputime_sec_factor);
162}
163
164static inline cputime_t secs_to_cputime(const unsigned long sec)
165{
166 return (cputime_t) sec * tb_ticks_per_sec;
167}
168
169
170
171
172static inline void cputime_to_timespec(const cputime_t ct, struct timespec *p)
173{
174 u64 x = ct;
175 unsigned int frac;
176
177 frac = do_div(x, tb_ticks_per_sec);
178 p->tv_sec = x;
179 x = (u64) frac * 1000000000;
180 do_div(x, tb_ticks_per_sec);
181 p->tv_nsec = x;
182}
183
184static inline cputime_t timespec_to_cputime(const struct timespec *p)
185{
186 cputime_t ct;
187
188 ct = (u64) p->tv_nsec * tb_ticks_per_sec;
189 do_div(ct, 1000000000);
190 return ct + (u64) p->tv_sec * tb_ticks_per_sec;
191}
192
193
194
195
196static inline void cputime_to_timeval(const cputime_t ct, struct timeval *p)
197{
198 u64 x = ct;
199 unsigned int frac;
200
201 frac = do_div(x, tb_ticks_per_sec);
202 p->tv_sec = x;
203 x = (u64) frac * 1000000;
204 do_div(x, tb_ticks_per_sec);
205 p->tv_usec = x;
206}
207
208static inline cputime_t timeval_to_cputime(const struct timeval *p)
209{
210 cputime_t ct;
211
212 ct = (u64) p->tv_usec * tb_ticks_per_sec;
213 do_div(ct, 1000000);
214 return ct + (u64) p->tv_sec * tb_ticks_per_sec;
215}
216
217
218
219
220extern u64 __cputime_clockt_factor;
221
222static inline unsigned long cputime_to_clock_t(const cputime_t ct)
223{
224 return mulhdu(ct, __cputime_clockt_factor);
225}
226
227static inline cputime_t clock_t_to_cputime(const unsigned long clk)
228{
229 cputime_t ct;
230 unsigned long sec;
231
232
233 ct = clk % USER_HZ;
234 sec = clk / USER_HZ;
235 if (ct) {
236 ct *= tb_ticks_per_sec;
237 do_div(ct, USER_HZ);
238 }
239 if (sec)
240 ct += (cputime_t) sec * tb_ticks_per_sec;
241 return ct;
242}
243
244#define cputime64_to_clock_t(ct) cputime_to_clock_t((cputime_t)(ct))
245
246#endif
247#endif
248#endif
249