[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / asm-powerpc / cputime.h

/*
 * Definitions for measuring cputime on powerpc machines.
 *
 * Copyright (C) 2006 Paul Mackerras, IBM Corp.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 * If we have CONFIG_VIRT_CPU_ACCOUNTING, we measure cpu time in
 * the same units as the timebase.  Otherwise we measure cpu time
 * in jiffies using the generic definitions.
 */

#ifndef __POWERPC_CPUTIME_H
#define __POWERPC_CPUTIME_H

#ifndef CONFIG_VIRT_CPU_ACCOUNTING
#include <asm-generic/cputime.h>
#else

#include <linux/types.h>
#include <linux/time.h>
#include <asm/div64.h>
#include <asm/time.h>
#include <asm/param.h>

typedef u64 cputime_t;
typedef u64 cputime64_t;

#define cputime_zero			((cputime_t)0)
#define cputime_max			((~((cputime_t)0) >> 1) - 1)
#define cputime_add(__a, __b)		((__a) +  (__b))
#define cputime_sub(__a, __b)		((__a) -  (__b))
#define cputime_div(__a, __n)		((__a) /  (__n))
#define cputime_halve(__a)		((__a) >> 1)
#define cputime_eq(__a, __b)		((__a) == (__b))
#define cputime_gt(__a, __b)		((__a) >  (__b))
#define cputime_ge(__a, __b)		((__a) >= (__b))
#define cputime_lt(__a, __b)		((__a) <  (__b))
#define cputime_le(__a, __b)		((__a) <= (__b))

#define cputime64_zero			((cputime64_t)0)
#define cputime64_add(__a, __b)		((__a) + (__b))
#define cputime64_sub(__a, __b)		((__a) - (__b))
#define cputime_to_cputime64(__ct)	(__ct)

#ifdef __KERNEL__

/*
 * Convert cputime <-> jiffies
 */
extern u64 __cputime_jiffies_factor;
DECLARE_PER_CPU(unsigned long, cputime_last_delta);
DECLARE_PER_CPU(unsigned long, cputime_scaled_last_delta);

static inline unsigned long cputime_to_jiffies(const cputime_t ct)
{
	return mulhdu(ct, __cputime_jiffies_factor);
}

/* Estimate the scaled cputime by scaling the real cputime based on
 * the last scaled to real ratio */
static inline cputime_t cputime_to_scaled(const cputime_t ct)
{
	if (cpu_has_feature(CPU_FTR_SPURR) &&
	    per_cpu(cputime_last_delta, smp_processor_id()))
		return ct *
			per_cpu(cputime_scaled_last_delta, smp_processor_id())/
			per_cpu(cputime_last_delta, smp_processor_id());
	return ct;
}

static inline cputime_t jiffies_to_cputime(const unsigned long jif)
{
	cputime_t ct;
	unsigned long sec;

	/* have to be a little careful about overflow */
	ct = jif % HZ;
	sec = jif / HZ;
	if (ct) {
		ct *= tb_ticks_per_sec;
		do_div(ct, HZ);
	}
	if (sec)
		ct += (cputime_t) sec * tb_ticks_per_sec;
	return ct;
}

static inline cputime64_t jiffies64_to_cputime64(const u64 jif)
{
	cputime_t ct;
	u64 sec;

	/* have to be a little careful about overflow */
	ct = jif % HZ;
	sec = jif / HZ;
	if (ct) {
		ct *= tb_ticks_per_sec;
		do_div(ct, HZ);
	}
	if (sec)
		ct += (cputime_t) sec * tb_ticks_per_sec;
	return ct;
}

static inline u64 cputime64_to_jiffies64(const cputime_t ct)
{
	return mulhdu(ct, __cputime_jiffies_factor);
}

/*
 * Convert cputime <-> milliseconds
 */
extern u64 __cputime_msec_factor;

static inline unsigned long cputime_to_msecs(const cputime_t ct)
{
	return mulhdu(ct, __cputime_msec_factor);
}

static inline cputime_t msecs_to_cputime(const unsigned long ms)
{
	cputime_t ct;
	unsigned long sec;

	/* have to be a little careful about overflow */
	ct = ms % 1000;
	sec = ms / 1000;
	if (ct) {
		ct *= tb_ticks_per_sec;
		do_div(ct, 1000);
	}
	if (sec)
		ct += (cputime_t) sec * tb_ticks_per_sec;
	return ct;
}

/*
 * Convert cputime <-> seconds
 */
extern u64 __cputime_sec_factor;

static inline unsigned long cputime_to_secs(const cputime_t ct)
{
	return mulhdu(ct, __cputime_sec_factor);
}

static inline cputime_t secs_to_cputime(const unsigned long sec)
{
	return (cputime_t) sec * tb_ticks_per_sec;
}

/*
 * Convert cputime <-> timespec
 */
static inline void cputime_to_timespec(const cputime_t ct, struct timespec *p)
{
	u64 x = ct;
	unsigned int frac;

	frac = do_div(x, tb_ticks_per_sec);
	p->tv_sec = x;
	x = (u64) frac * 1000000000;
	do_div(x, tb_ticks_per_sec);
	p->tv_nsec = x;
}

static inline cputime_t timespec_to_cputime(const struct timespec *p)
{
	cputime_t ct;

	ct = (u64) p->tv_nsec * tb_ticks_per_sec;
	do_div(ct, 1000000000);
	return ct + (u64) p->tv_sec * tb_ticks_per_sec;
}

/*
 * Convert cputime <-> timeval
 */
static inline void cputime_to_timeval(const cputime_t ct, struct timeval *p)
{
	u64 x = ct;
	unsigned int frac;

	frac = do_div(x, tb_ticks_per_sec);
	p->tv_sec = x;
	x = (u64) frac * 1000000;
	do_div(x, tb_ticks_per_sec);
	p->tv_usec = x;
}

static inline cputime_t timeval_to_cputime(const struct timeval *p)
{
	cputime_t ct;

	ct = (u64) p->tv_usec * tb_ticks_per_sec;
	do_div(ct, 1000000);
	return ct + (u64) p->tv_sec * tb_ticks_per_sec;
}

/*
 * Convert cputime <-> clock_t (units of 1/USER_HZ seconds)
 */
extern u64 __cputime_clockt_factor;

static inline unsigned long cputime_to_clock_t(const cputime_t ct)
{
	return mulhdu(ct, __cputime_clockt_factor);
}

static inline cputime_t clock_t_to_cputime(const unsigned long clk)
{
	cputime_t ct;
	unsigned long sec;

	/* have to be a little careful about overflow */
	ct = clk % USER_HZ;
	sec = clk / USER_HZ;
	if (ct) {
		ct *= tb_ticks_per_sec;
		do_div(ct, USER_HZ);
	}
	if (sec)
		ct += (cputime_t) sec * tb_ticks_per_sec;
	return ct;
}

#define cputime64_to_clock_t(ct)	cputime_to_clock_t((cputime_t)(ct))

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