[S390] cputime: add sparse checking and cleanup
[linux-2.6.git] / arch / powerpc / include / asm / cputime.h
1 /*
2  * Definitions for measuring cputime on powerpc machines.
3  *
4  * Copyright (C) 2006 Paul Mackerras, IBM Corp.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  *
11  * If we have CONFIG_VIRT_CPU_ACCOUNTING, we measure cpu time in
12  * the same units as the timebase.  Otherwise we measure cpu time
13  * in jiffies using the generic definitions.
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__
22 static 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
32 typedef u64 __nocast cputime_t;
33 typedef u64 __nocast cputime64_t;
34
35 #ifdef __KERNEL__
36
37 /*
38  * One jiffy in timebase units computed during initialization
39  */
40 extern cputime_t cputime_one_jiffy;
41
42 /*
43  * Convert cputime <-> jiffies
44  */
45 extern u64 __cputime_jiffies_factor;
46 DECLARE_PER_CPU(unsigned long, cputime_last_delta);
47 DECLARE_PER_CPU(unsigned long, cputime_scaled_last_delta);
48
49 static inline unsigned long cputime_to_jiffies(const cputime_t ct)
50 {
51         return mulhdu((__force u64) ct, __cputime_jiffies_factor);
52 }
53
54 /* Estimate the scaled cputime by scaling the real cputime based on
55  * the last scaled to real ratio */
56 static inline cputime_t cputime_to_scaled(const cputime_t ct)
57 {
58         if (cpu_has_feature(CPU_FTR_SPURR) &&
59             __get_cpu_var(cputime_last_delta))
60                 return (__force u64) ct *
61                         __get_cpu_var(cputime_scaled_last_delta) /
62                         __get_cpu_var(cputime_last_delta);
63         return ct;
64 }
65
66 static inline cputime_t jiffies_to_cputime(const unsigned long jif)
67 {
68         u64 ct;
69         unsigned long sec;
70
71         /* have to be a little careful about overflow */
72         ct = jif % HZ;
73         sec = jif / HZ;
74         if (ct) {
75                 ct *= tb_ticks_per_sec;
76                 do_div(ct, HZ);
77         }
78         if (sec)
79                 ct += (cputime_t) sec * tb_ticks_per_sec;
80         return (__force cputime_t) ct;
81 }
82
83 static inline void setup_cputime_one_jiffy(void)
84 {
85         cputime_one_jiffy = jiffies_to_cputime(1);
86 }
87
88 static inline cputime64_t jiffies64_to_cputime64(const u64 jif)
89 {
90         u64 ct;
91         u64 sec;
92
93         /* have to be a little careful about overflow */
94         ct = jif % HZ;
95         sec = jif / HZ;
96         if (ct) {
97                 ct *= tb_ticks_per_sec;
98                 do_div(ct, HZ);
99         }
100         if (sec)
101                 ct += (u64) sec * tb_ticks_per_sec;
102         return (__force cputime64_t) ct;
103 }
104
105 static inline u64 cputime64_to_jiffies64(const cputime_t ct)
106 {
107         return mulhdu((__force u64) ct, __cputime_jiffies_factor);
108 }
109
110 /*
111  * Convert cputime <-> microseconds
112  */
113 extern u64 __cputime_msec_factor;
114
115 static inline unsigned long cputime_to_usecs(const cputime_t ct)
116 {
117         return mulhdu((__force u64) ct, __cputime_msec_factor) * USEC_PER_MSEC;
118 }
119
120 static inline cputime_t usecs_to_cputime(const unsigned long us)
121 {
122         u64 ct;
123         unsigned long sec;
124
125         /* have to be a little careful about overflow */
126         ct = us % 1000000;
127         sec = us / 1000000;
128         if (ct) {
129                 ct *= tb_ticks_per_sec;
130                 do_div(ct, 1000);
131         }
132         if (sec)
133                 ct += (cputime_t) sec * tb_ticks_per_sec;
134         return (__force cputime_t) ct;
135 }
136
137 /*
138  * Convert cputime <-> seconds
139  */
140 extern u64 __cputime_sec_factor;
141
142 static inline unsigned long cputime_to_secs(const cputime_t ct)
143 {
144         return mulhdu((__force u64) ct, __cputime_sec_factor);
145 }
146
147 static inline cputime_t secs_to_cputime(const unsigned long sec)
148 {
149         return (__force cputime_t)((u64) sec * tb_ticks_per_sec);
150 }
151
152 /*
153  * Convert cputime <-> timespec
154  */
155 static inline void cputime_to_timespec(const cputime_t ct, struct timespec *p)
156 {
157         u64 x = (__force u64) ct;
158         unsigned int frac;
159
160         frac = do_div(x, tb_ticks_per_sec);
161         p->tv_sec = x;
162         x = (u64) frac * 1000000000;
163         do_div(x, tb_ticks_per_sec);
164         p->tv_nsec = x;
165 }
166
167 static inline cputime_t timespec_to_cputime(const struct timespec *p)
168 {
169         u64 ct;
170
171         ct = (u64) p->tv_nsec * tb_ticks_per_sec;
172         do_div(ct, 1000000000);
173         return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec);
174 }
175
176 /*
177  * Convert cputime <-> timeval
178  */
179 static inline void cputime_to_timeval(const cputime_t ct, struct timeval *p)
180 {
181         u64 x = (__force u64) ct;
182         unsigned int frac;
183
184         frac = do_div(x, tb_ticks_per_sec);
185         p->tv_sec = x;
186         x = (u64) frac * 1000000;
187         do_div(x, tb_ticks_per_sec);
188         p->tv_usec = x;
189 }
190
191 static inline cputime_t timeval_to_cputime(const struct timeval *p)
192 {
193         u64 ct;
194
195         ct = (u64) p->tv_usec * tb_ticks_per_sec;
196         do_div(ct, 1000000);
197         return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec);
198 }
199
200 /*
201  * Convert cputime <-> clock_t (units of 1/USER_HZ seconds)
202  */
203 extern u64 __cputime_clockt_factor;
204
205 static inline unsigned long cputime_to_clock_t(const cputime_t ct)
206 {
207         return mulhdu((__force u64) ct, __cputime_clockt_factor);
208 }
209
210 static inline cputime_t clock_t_to_cputime(const unsigned long clk)
211 {
212         u64 ct;
213         unsigned long sec;
214
215         /* have to be a little careful about overflow */
216         ct = clk % USER_HZ;
217         sec = clk / USER_HZ;
218         if (ct) {
219                 ct *= tb_ticks_per_sec;
220                 do_div(ct, USER_HZ);
221         }
222         if (sec)
223                 ct += (u64) sec * tb_ticks_per_sec;
224         return (__force cputime_t) ct;
225 }
226
227 #define cputime64_to_clock_t(ct)        cputime_to_clock_t((cputime_t)(ct))
228
229 #endif /* __KERNEL__ */
230 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
231 #endif /* __POWERPC_CPUTIME_H */