[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / time.h

#ifndef _LINUX_TIME_H
#define _LINUX_TIME_H

# include <linux/cache.h>
# include <linux/seqlock.h>
# include <linux/math64.h>
#include <uapi/linux/time.h>

extern struct timezone sys_tz;

/* Parameters used to convert the timespec values: */
#define MSEC_PER_SEC	1000L
#define USEC_PER_MSEC	1000L
#define NSEC_PER_USEC	1000L
#define NSEC_PER_MSEC	1000000L
#define USEC_PER_SEC	1000000L
#define NSEC_PER_SEC	1000000000L
#define FSEC_PER_SEC	1000000000000000LL

#define TIME_T_MAX	(time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)

static inline int timespec_equal(const struct timespec *a,
                                 const struct timespec *b)
{
	return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
}

/*
 * lhs < rhs:  return <0
 * lhs == rhs: return 0
 * lhs > rhs:  return >0
 */
static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
{
	if (lhs->tv_sec < rhs->tv_sec)
		return -1;
	if (lhs->tv_sec > rhs->tv_sec)
		return 1;
	return lhs->tv_nsec - rhs->tv_nsec;
}

static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
{
	if (lhs->tv_sec < rhs->tv_sec)
		return -1;
	if (lhs->tv_sec > rhs->tv_sec)
		return 1;
	return lhs->tv_usec - rhs->tv_usec;
}

extern unsigned long mktime(const unsigned int year, const unsigned int mon,
			    const unsigned int day, const unsigned int hour,
			    const unsigned int min, const unsigned int sec);

extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);

/*
 * timespec_add_safe assumes both values are positive and checks
 * for overflow. It will return TIME_T_MAX if the reutrn would be
 * smaller then either of the arguments.
 */
extern struct timespec timespec_add_safe(const struct timespec lhs,
					 const struct timespec rhs);


static inline struct timespec timespec_add(struct timespec lhs,
						struct timespec rhs)
{
	struct timespec ts_delta;
	set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
				lhs.tv_nsec + rhs.tv_nsec);
	return ts_delta;
}

/*
 * sub = lhs - rhs, in normalized form
 */
static inline struct timespec timespec_sub(struct timespec lhs,
						struct timespec rhs)
{
	struct timespec ts_delta;
	set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
				lhs.tv_nsec - rhs.tv_nsec);
	return ts_delta;
}

#define KTIME_MAX			((s64)~((u64)1 << 63))
#if (BITS_PER_LONG == 64)
# define KTIME_SEC_MAX			(KTIME_MAX / NSEC_PER_SEC)
#else
# define KTIME_SEC_MAX			LONG_MAX
#endif

/*
 * Returns true if the timespec is norm, false if denorm:
 */
static inline bool timespec_valid(const struct timespec *ts)
{
	/* Dates before 1970 are bogus */
	if (ts->tv_sec < 0)
		return false;
	/* Can't have more nanoseconds then a second */
	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
		return false;
	return true;
}

static inline bool timespec_valid_strict(const struct timespec *ts)
{
	if (!timespec_valid(ts))
		return false;
	/* Disallow values that could overflow ktime_t */
	if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
		return false;
	return true;
}

extern bool persistent_clock_exist;

static inline bool has_persistent_clock(void)
{
	return persistent_clock_exist;
}

extern void read_persistent_clock(struct timespec *ts);
extern void read_boot_clock(struct timespec *ts);
extern int persistent_clock_is_local;
extern int update_persistent_clock(struct timespec now);
void timekeeping_init(void);
extern int timekeeping_suspended;

unsigned long get_seconds(void);
struct timespec current_kernel_time(void);
struct timespec __current_kernel_time(void); /* does not take xtime_lock */
struct timespec get_monotonic_coarse(void);
void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
				struct timespec *wtom, struct timespec *sleep);
void timekeeping_inject_sleeptime(struct timespec *delta);

#define CURRENT_TIME		(current_kernel_time())
#define CURRENT_TIME_SEC	((struct timespec) { get_seconds(), 0 })

/* Some architectures do not supply their own clocksource.
 * This is mainly the case in architectures that get their
 * inter-tick times by reading the counter on their interval
 * timer. Since these timers wrap every tick, they're not really
 * useful as clocksources. Wrapping them to act like one is possible
 * but not very efficient. So we provide a callout these arches
 * can implement for use with the jiffies clocksource to provide
 * finer then tick granular time.
 */
#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
extern u32 (*arch_gettimeoffset)(void);
#endif

extern void do_gettimeofday(struct timeval *tv);
extern int do_settimeofday(const struct timespec *tv);
extern int do_sys_settimeofday(const struct timespec *tv,
			       const struct timezone *tz);
#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
struct itimerval;
extern int do_setitimer(int which, struct itimerval *value,
			struct itimerval *ovalue);
extern unsigned int alarm_setitimer(unsigned int seconds);
extern int do_getitimer(int which, struct itimerval *value);
extern int __getnstimeofday(struct timespec *tv);
extern void getnstimeofday(struct timespec *tv);
extern void getrawmonotonic(struct timespec *ts);
extern void getnstime_raw_and_real(struct timespec *ts_raw,
		struct timespec *ts_real);
extern void getboottime(struct timespec *ts);
extern void monotonic_to_bootbased(struct timespec *ts);
extern void get_monotonic_boottime(struct timespec *ts);

static inline bool timeval_valid(const struct timeval *tv)
{
	/* Dates before 1970 are bogus */
	if (tv->tv_sec < 0)
		return false;

	/* Can't have more microseconds then a second */
	if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
		return false;

	return true;
}

extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
extern int timekeeping_valid_for_hres(void);
extern u64 timekeeping_max_deferment(void);
extern int timekeeping_inject_offset(struct timespec *ts);
extern s32 timekeeping_get_tai_offset(void);
extern void timekeeping_set_tai_offset(s32 tai_offset);
extern void timekeeping_clocktai(struct timespec *ts);

struct tms;
extern void do_sys_times(struct tms *);

/*
 * Similar to the struct tm in userspace <time.h>, but it needs to be here so
 * that the kernel source is self contained.
 */
struct tm {
	/*
	 * the number of seconds after the minute, normally in the range
	 * 0 to 59, but can be up to 60 to allow for leap seconds
	 */
	int tm_sec;
	/* the number of minutes after the hour, in the range 0 to 59*/
	int tm_min;
	/* the number of hours past midnight, in the range 0 to 23 */
	int tm_hour;
	/* the day of the month, in the range 1 to 31 */
	int tm_mday;
	/* the number of months since January, in the range 0 to 11 */
	int tm_mon;
	/* the number of years since 1900 */
	long tm_year;
	/* the number of days since Sunday, in the range 0 to 6 */
	int tm_wday;
	/* the number of days since January 1, in the range 0 to 365 */
	int tm_yday;
};

void time_to_tm(time_t totalsecs, int offset, struct tm *result);

/**
 * timespec_to_ns - Convert timespec to nanoseconds
 * @ts:		pointer to the timespec variable to be converted
 *
 * Returns the scalar nanosecond representation of the timespec
 * parameter.
 */
static inline s64 timespec_to_ns(const struct timespec *ts)
{
	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
}

/**
 * timeval_to_ns - Convert timeval to nanoseconds
 * @ts:		pointer to the timeval variable to be converted
 *
 * Returns the scalar nanosecond representation of the timeval
 * parameter.
 */
static inline s64 timeval_to_ns(const struct timeval *tv)
{
	return ((s64) tv->tv_sec * NSEC_PER_SEC) +
		tv->tv_usec * NSEC_PER_USEC;
}

/**
 * ns_to_timespec - Convert nanoseconds to timespec
 * @nsec:	the nanoseconds value to be converted
 *
 * Returns the timespec representation of the nsec parameter.
 */
extern struct timespec ns_to_timespec(const s64 nsec);

/**
 * ns_to_timeval - Convert nanoseconds to timeval
 * @nsec:	the nanoseconds value to be converted
 *
 * Returns the timeval representation of the nsec parameter.
 */
extern struct timeval ns_to_timeval(const s64 nsec);

/**
 * timespec_add_ns - Adds nanoseconds to a timespec
 * @a:		pointer to timespec to be incremented
 * @ns:		unsigned nanoseconds value to be added
 *
 * This must always be inlined because its used from the x86-64 vdso,
 * which cannot call other kernel functions.
 */
static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
{
	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
	a->tv_nsec = ns;
}

#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _LINUX_TIME_H
	2	#define _LINUX_TIME_H
	3
82644459	4	# include <linux/cache.h>
57a55875	5	# include <linux/seqlock.h>
f595ec96	6	# include <linux/math64.h>
607ca46e	7	#include <uapi/linux/time.h>
1da177e4	8
b418da16 CH	9	extern struct timezone sys_tz;
b418da16 CH	10
57a55875	11	/* Parameters used to convert the timespec values: */
05ebb761 VP	12	#define MSEC_PER_SEC 1000L
	13	#define USEC_PER_MSEC 1000L
	14	#define NSEC_PER_USEC 1000L
	15	#define NSEC_PER_MSEC 1000000L
	16	#define USEC_PER_SEC 1000000L
	17	#define NSEC_PER_SEC 1000000000L
4936a3b9	18	#define FSEC_PER_SEC 1000000000000000LL
1da177e4	19
df0cc053 TG	20	#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
df0cc053 TG	21
5b78cc9a JE	22	static inline int timespec_equal(const struct timespec *a,
5b78cc9a JE	23	const struct timespec *b)
57a55875	24	{
1da177e4	25	return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
57a55875	26	}
1da177e4	27
643a6545 AM	28	/*
	29	* lhs < rhs: return <0
	30	* lhs == rhs: return 0
	31	* lhs > rhs: return >0
	32	*/
77adbfbf	33	static inline int timespec_compare(const struct timespec lhs, const struct timespec rhs)
643a6545 AM	34	{
	35	if (lhs->tv_sec < rhs->tv_sec)
	36	return -1;
	37	if (lhs->tv_sec > rhs->tv_sec)
	38	return 1;
	39	return lhs->tv_nsec - rhs->tv_nsec;
	40	}
	41
77adbfbf	42	static inline int timeval_compare(const struct timeval lhs, const struct timeval rhs)
643a6545 AM	43	{
	44	if (lhs->tv_sec < rhs->tv_sec)
	45	return -1;
	46	if (lhs->tv_sec > rhs->tv_sec)
	47	return 1;
	48	return lhs->tv_usec - rhs->tv_usec;
	49	}
	50
f4818900 IM	51	extern unsigned long mktime(const unsigned int year, const unsigned int mon,
	52	const unsigned int day, const unsigned int hour,
	53	const unsigned int min, const unsigned int sec);
	54
12e09337	55	extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
ce3bf7ab JS	56
	57	/*
	58	* timespec_add_safe assumes both values are positive and checks
	59	* for overflow. It will return TIME_T_MAX if the reutrn would be
	60	* smaller then either of the arguments.
	61	*/
df0cc053 TG	62	extern struct timespec timespec_add_safe(const struct timespec lhs,
df0cc053 TG	63	const struct timespec rhs);
1da177e4	64
ce3bf7ab JS	65
	66	static inline struct timespec timespec_add(struct timespec lhs,
	67	struct timespec rhs)
	68	{
	69	struct timespec ts_delta;
	70	set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
	71	lhs.tv_nsec + rhs.tv_nsec);
	72	return ts_delta;
	73	}
	74
ca74e92b SN	75	/*
	76	* sub = lhs - rhs, in normalized form
	77	*/
	78	static inline struct timespec timespec_sub(struct timespec lhs,
	79	struct timespec rhs)
	80	{
	81	struct timespec ts_delta;
	82	set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
	83	lhs.tv_nsec - rhs.tv_nsec);
	84	return ts_delta;
	85	}
	86
4e8b1452 JS	87	#define KTIME_MAX ((s64)~((u64)1 << 63))
	88	#if (BITS_PER_LONG == 64)
	89	# define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)
	90	#else
	91	# define KTIME_SEC_MAX LONG_MAX
	92	#endif
	93
5f82b2b7 TG	94	/*
	95	* Returns true if the timespec is norm, false if denorm:
	96	*/
4e8b1452 JS	97	static inline bool timespec_valid(const struct timespec *ts)
	98	{
	99	/* Dates before 1970 are bogus */
	100	if (ts->tv_sec < 0)
	101	return false;
	102	/* Can't have more nanoseconds then a second */
	103	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
	104	return false;
cee58483 JS	105	return true;
	106	}
	107
	108	static inline bool timespec_valid_strict(const struct timespec *ts)
	109	{
	110	if (!timespec_valid(ts))
	111	return false;
4e8b1452 JS	112	/* Disallow values that could overflow ktime_t */
	113	if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
	114	return false;
	115	return true;
	116	}
5f82b2b7	117
31ade306	118	extern bool persistent_clock_exist;
05ad717c	119
31ade306 FT	120	static inline bool has_persistent_clock(void)
	121	{
	122	return persistent_clock_exist;
	123	}
	124
d4f587c6	125	extern void read_persistent_clock(struct timespec *ts);
23970e38	126	extern void read_boot_clock(struct timespec *ts);
84e345e4	127	extern int persistent_clock_is_local;
82644459	128	extern int update_persistent_clock(struct timespec now);
ad596171	129	void timekeeping_init(void);
1c5745aa	130	extern int timekeeping_suspended;
ad596171	131
17c38b74	132	unsigned long get_seconds(void);
1da177e4	133	struct timespec current_kernel_time(void);
8ab4351a	134	struct timespec __current_kernel_time(void); /* does not take xtime_lock */
da15cfda	135	struct timespec get_monotonic_coarse(void);
314ac371 JS	136	void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
314ac371 JS	137	struct timespec wtom, struct timespec sleep);
304529b1	138	void timekeeping_inject_sleeptime(struct timespec *delta);
1da177e4	139
57a55875	140	#define CURRENT_TIME (current_kernel_time())
2c6b47de	141	#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
1da177e4	142
7d27558c JS	143	/* Some architectures do not supply their own clocksource.
	144	* This is mainly the case in architectures that get their
	145	* inter-tick times by reading the counter on their interval
	146	* timer. Since these timers wrap every tick, they're not really
	147	* useful as clocksources. Wrapping them to act like one is possible
	148	* but not very efficient. So we provide a callout these arches
	149	* can implement for use with the jiffies clocksource to provide
	150	* finer then tick granular time.
	151	*/
	152	#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
7b1f6207	153	extern u32 (*arch_gettimeoffset)(void);
7d27558c JS	154	#endif
7d27558c JS	155
1da177e4	156	extern void do_gettimeofday(struct timeval *tv);
1e6d7679 RC	157	extern int do_settimeofday(const struct timespec *tv);
	158	extern int do_sys_settimeofday(const struct timespec *tv,
	159	const struct timezone *tz);
becf8b5d	160	#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
c7887325	161	extern long do_utimes(int dfd, const char __user filename, struct timespec times, int flags);
1da177e4	162	struct itimerval;
57a55875 IM	163	extern int do_setitimer(int which, struct itimerval *value,
57a55875 IM	164	struct itimerval *ovalue);
c08b8a49	165	extern unsigned int alarm_setitimer(unsigned int seconds);
1da177e4	166	extern int do_getitimer(int which, struct itimerval *value);
1e817fb6	167	extern int __getnstimeofday(struct timespec *tv);
57a55875	168	extern void getnstimeofday(struct timespec *tv);
2d42244a	169	extern void getrawmonotonic(struct timespec *ts);
e2c18e49 AG	170	extern void getnstime_raw_and_real(struct timespec *ts_raw,
e2c18e49 AG	171	struct timespec *ts_real);
7c3f1a57 TJ	172	extern void getboottime(struct timespec *ts);
7c3f1a57 TJ	173	extern void monotonic_to_bootbased(struct timespec *ts);
abb3a4ea	174	extern void get_monotonic_boottime(struct timespec *ts);
1da177e4	175
7336dcc2 SL	176	static inline bool timeval_valid(const struct timeval *tv)
	177	{
	178	/* Dates before 1970 are bogus */
	179	if (tv->tv_sec < 0)
	180	return false;
	181
	182	/* Can't have more microseconds then a second */
	183	if (tv->tv_usec < 0 \|\| tv->tv_usec >= USEC_PER_SEC)
	184	return false;
	185
	186	return true;
	187	}
	188
1da177e4	189	extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
cf4fc6cb	190	extern int timekeeping_valid_for_hres(void);
98962465	191	extern u64 timekeeping_max_deferment(void);
c528f7c6	192	extern int timekeeping_inject_offset(struct timespec *ts);
cc244dda JS	193	extern s32 timekeeping_get_tai_offset(void);
cc244dda JS	194	extern void timekeeping_set_tai_offset(s32 tai_offset);
1ff3c967	195	extern void timekeeping_clocktai(struct timespec *ts);
1da177e4	196
f06febc9 FM	197	struct tms;
	198	extern void do_sys_times(struct tms *);
	199
57f1f087 Z	200	/*
	201	* Similar to the struct tm in userspace <time.h>, but it needs to be here so
	202	* that the kernel source is self contained.
	203	*/
	204	struct tm {
	205	/*
	206	* the number of seconds after the minute, normally in the range
	207	* 0 to 59, but can be up to 60 to allow for leap seconds
	208	*/
	209	int tm_sec;
	210	/* the number of minutes after the hour, in the range 0 to 59*/
	211	int tm_min;
	212	/* the number of hours past midnight, in the range 0 to 23 */
	213	int tm_hour;
	214	/* the day of the month, in the range 1 to 31 */
	215	int tm_mday;
	216	/* the number of months since January, in the range 0 to 11 */
	217	int tm_mon;
	218	/* the number of years since 1900 */
	219	long tm_year;
	220	/* the number of days since Sunday, in the range 0 to 6 */
	221	int tm_wday;
	222	/* the number of days since January 1, in the range 0 to 365 */
	223	int tm_yday;
	224	};
	225
	226	void time_to_tm(time_t totalsecs, int offset, struct tm *result);
	227
f8f46da3 TG	228	/**
	229	* timespec_to_ns - Convert timespec to nanoseconds
	230	* @ts: pointer to the timespec variable to be converted
	231	*
	232	* Returns the scalar nanosecond representation of the timespec
	233	* parameter.
	234	*/
df869b63	235	static inline s64 timespec_to_ns(const struct timespec *ts)
f8f46da3	236	{
df869b63	237	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
f8f46da3 TG	238	}
	239
	240	/**
	241	* timeval_to_ns - Convert timeval to nanoseconds
	242	* @ts: pointer to the timeval variable to be converted
	243	*
	244	* Returns the scalar nanosecond representation of the timeval
	245	* parameter.
	246	*/
df869b63	247	static inline s64 timeval_to_ns(const struct timeval *tv)
f8f46da3	248	{
df869b63	249	return ((s64) tv->tv_sec * NSEC_PER_SEC) +
f8f46da3 TG	250	tv->tv_usec * NSEC_PER_USEC;
	251	}
	252
	253	/**
	254	* ns_to_timespec - Convert nanoseconds to timespec
	255	* @nsec: the nanoseconds value to be converted
	256	*
	257	* Returns the timespec representation of the nsec parameter.
	258	*/
df869b63	259	extern struct timespec ns_to_timespec(const s64 nsec);
f8f46da3 TG	260
	261	/**
	262	* ns_to_timeval - Convert nanoseconds to timeval
	263	* @nsec: the nanoseconds value to be converted
	264	*
	265	* Returns the timeval representation of the nsec parameter.
	266	*/
df869b63	267	extern struct timeval ns_to_timeval(const s64 nsec);
f8f46da3	268
cf3c769b JS	269	/**
	270	* timespec_add_ns - Adds nanoseconds to a timespec
	271	* @a: pointer to timespec to be incremented
	272	* @ns: unsigned nanoseconds value to be added
9412e286 JF	273	*
	274	* This must always be inlined because its used from the x86-64 vdso,
	275	* which cannot call other kernel functions.
cf3c769b	276	*/
9412e286	277	static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
cf3c769b	278	{
9412e286	279	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
cf3c769b JS	280	a->tv_nsec = ns;
cf3c769b JS	281	}
8b3d1cda	282
1da177e4	283	#endif