clocksource.h 11.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*  linux/include/linux/clocksource.h
 *
 *  This file contains the structure definitions for clocksources.
 *
 *  If you are not a clocksource, or timekeeping code, you should
 *  not be including this file!
 */
#ifndef _LINUX_CLOCKSOURCE_H
#define _LINUX_CLOCKSOURCE_H

#include <linux/types.h>
#include <linux/timex.h>
#include <linux/time.h>
#include <linux/list.h>
15
#include <linux/cache.h>
16
#include <linux/timer.h>
17
#include <linux/init.h>
18 19 20 21 22
#include <asm/div64.h>
#include <asm/io.h>

/* clocksource cycle base type */
typedef u64 cycle_t;
23
struct clocksource;
24
struct module;
25

26
#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
27
#include <asm/clocksource.h>
28
#endif
29

30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
/**
 * struct cyclecounter - hardware abstraction for a free running counter
 *	Provides completely state-free accessors to the underlying hardware.
 *	Depending on which hardware it reads, the cycle counter may wrap
 *	around quickly. Locking rules (if necessary) have to be defined
 *	by the implementor and user of specific instances of this API.
 *
 * @read:		returns the current cycle value
 * @mask:		bitmask for two's complement
 *			subtraction of non 64 bit counters,
 *			see CLOCKSOURCE_MASK() helper macro
 * @mult:		cycle to nanosecond multiplier
 * @shift:		cycle to nanosecond divisor (power of two)
 */
struct cyclecounter {
	cycle_t (*read)(const struct cyclecounter *cc);
	cycle_t mask;
	u32 mult;
	u32 shift;
};

/**
 * struct timecounter - layer above a %struct cyclecounter which counts nanoseconds
 *	Contains the state needed by timecounter_read() to detect
 *	cycle counter wrap around. Initialize with
 *	timecounter_init(). Also used to convert cycle counts into the
 *	corresponding nanosecond counts with timecounter_cyc2time(). Users
 *	of this code are responsible for initializing the underlying
 *	cycle counter hardware, locking issues and reading the time
 *	more often than the cycle counter wraps around. The nanosecond
 *	counter will only wrap around after ~585 years.
 *
 * @cc:			the cycle counter used by this instance
 * @cycle_last:		most recent cycle counter value seen by
 *			timecounter_read()
 * @nsec:		continuously increasing count
 */
struct timecounter {
	const struct cyclecounter *cc;
	cycle_t cycle_last;
	u64 nsec;
};

/**
 * cyclecounter_cyc2ns - converts cycle counter cycles to nanoseconds
75
 * @cc:		Pointer to cycle counter.
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
 * @cycles:	Cycles
 *
 * XXX - This could use some mult_lxl_ll() asm optimization. Same code
 * as in cyc2ns, but with unsigned result.
 */
static inline u64 cyclecounter_cyc2ns(const struct cyclecounter *cc,
				      cycle_t cycles)
{
	u64 ret = (u64)cycles;
	ret = (ret * cc->mult) >> cc->shift;
	return ret;
}

/**
 * timecounter_init - initialize a time counter
 * @tc:			Pointer to time counter which is to be initialized/reset
 * @cc:			A cycle counter, ready to be used.
 * @start_tstamp:	Arbitrary initial time stamp.
 *
 * After this call the current cycle register (roughly) corresponds to
 * the initial time stamp. Every call to timecounter_read() increments
 * the time stamp counter by the number of elapsed nanoseconds.
 */
extern void timecounter_init(struct timecounter *tc,
			     const struct cyclecounter *cc,
			     u64 start_tstamp);

/**
 * timecounter_read - return nanoseconds elapsed since timecounter_init()
 *                    plus the initial time stamp
 * @tc:          Pointer to time counter.
 *
 * In other words, keeps track of time since the same epoch as
 * the function which generated the initial time stamp.
 */
extern u64 timecounter_read(struct timecounter *tc);

/**
 * timecounter_cyc2time - convert a cycle counter to same
 *                        time base as values returned by
 *                        timecounter_read()
 * @tc:		Pointer to time counter.
118
 * @cycle_tstamp:	a value returned by tc->cc->read()
119 120 121 122 123 124 125 126 127 128 129
 *
 * Cycle counts that are converted correctly as long as they
 * fall into the interval [-1/2 max cycle count, +1/2 max cycle count],
 * with "max cycle count" == cs->mask+1.
 *
 * This allows conversion of cycle counter values which were generated
 * in the past.
 */
extern u64 timecounter_cyc2time(struct timecounter *tc,
				cycle_t cycle_tstamp);

130 131 132
/**
 * struct clocksource - hardware abstraction for a free running counter
 *	Provides mostly state-free accessors to the underlying hardware.
133
 *	This is the structure used for system time.
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
 *
 * @name:		ptr to clocksource name
 * @list:		list head for registration
 * @rating:		rating value for selection (higher is better)
 *			To avoid rating inflation the following
 *			list should give you a guide as to how
 *			to assign your clocksource a rating
 *			1-99: Unfit for real use
 *				Only available for bootup and testing purposes.
 *			100-199: Base level usability.
 *				Functional for real use, but not desired.
 *			200-299: Good.
 *				A correct and usable clocksource.
 *			300-399: Desired.
 *				A reasonably fast and accurate clocksource.
 *			400-499: Perfect
 *				The ideal clocksource. A must-use where
 *				available.
152
 * @read:		returns a cycle value, passes clocksource as argument
153 154
 * @enable:		optional function to enable the clocksource
 * @disable:		optional function to disable the clocksource
155 156
 * @mask:		bitmask for two's complement
 *			subtraction of non 64 bit counters
157
 * @mult:		cycle to nanosecond multiplier
158
 * @shift:		cycle to nanosecond divisor (power of two)
159
 * @max_idle_ns:	max idle time permitted by the clocksource (nsecs)
160
 * @maxadj:		maximum adjustment value to mult (~11%)
161
 * @flags:		flags describing special properties
162
 * @archdata:		arch-specific data
M
Magnus Damm 已提交
163
 * @suspend:		suspend function for the clocksource, if necessary
T
Thomas Gleixner 已提交
164
 * @resume:		resume function for the clocksource, if necessary
165
 * @cycle_last:		most recent cycle counter value seen by ::read()
166
 * @owner:		module reference, must be set by clocksource in modules
167 168
 */
struct clocksource {
169
	/*
170 171
	 * Hotpath data, fits in a single cache line when the
	 * clocksource itself is cacheline aligned.
172
	 */
173
	cycle_t (*read)(struct clocksource *cs);
174
	cycle_t cycle_last;
175 176 177
	cycle_t mask;
	u32 mult;
	u32 shift;
178
	u64 max_idle_ns;
179
	u32 maxadj;
180
#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
181
	struct arch_clocksource_data archdata;
182
#endif
183

184 185 186 187 188 189 190 191
	const char *name;
	struct list_head list;
	int rating;
	int (*enable)(struct clocksource *cs);
	void (*disable)(struct clocksource *cs);
	unsigned long flags;
	void (*suspend)(struct clocksource *cs);
	void (*resume)(struct clocksource *cs);
192

193
	/* private: */
194 195 196
#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
	/* Watchdog related data, used by the framework */
	struct list_head wd_list;
197
	cycle_t cs_last;
198 199
	cycle_t wd_last;
#endif
200
	struct module *owner;
201
} ____cacheline_aligned;
202

203 204 205
/*
 * Clock source flags bits::
 */
206 207 208 209 210
#define CLOCK_SOURCE_IS_CONTINUOUS		0x01
#define CLOCK_SOURCE_MUST_VERIFY		0x02

#define CLOCK_SOURCE_WATCHDOG			0x10
#define CLOCK_SOURCE_VALID_FOR_HRES		0x20
211
#define CLOCK_SOURCE_UNSTABLE			0x40
212
#define CLOCK_SOURCE_SUSPEND_NONSTOP		0x80
213

214
/* simplify initialization of mask field */
215
#define CLOCKSOURCE_MASK(bits) (cycle_t)((bits) < 64 ? ((1ULL<<(bits))-1) : -1)
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268

/**
 * clocksource_khz2mult - calculates mult from khz and shift
 * @khz:		Clocksource frequency in KHz
 * @shift_constant:	Clocksource shift factor
 *
 * Helper functions that converts a khz counter frequency to a timsource
 * multiplier, given the clocksource shift value
 */
static inline u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
{
	/*  khz = cyc/(Million ns)
	 *  mult/2^shift  = ns/cyc
	 *  mult = ns/cyc * 2^shift
	 *  mult = 1Million/khz * 2^shift
	 *  mult = 1000000 * 2^shift / khz
	 *  mult = (1000000<<shift) / khz
	 */
	u64 tmp = ((u64)1000000) << shift_constant;

	tmp += khz/2; /* round for do_div */
	do_div(tmp, khz);

	return (u32)tmp;
}

/**
 * clocksource_hz2mult - calculates mult from hz and shift
 * @hz:			Clocksource frequency in Hz
 * @shift_constant:	Clocksource shift factor
 *
 * Helper functions that converts a hz counter
 * frequency to a timsource multiplier, given the
 * clocksource shift value
 */
static inline u32 clocksource_hz2mult(u32 hz, u32 shift_constant)
{
	/*  hz = cyc/(Billion ns)
	 *  mult/2^shift  = ns/cyc
	 *  mult = ns/cyc * 2^shift
	 *  mult = 1Billion/hz * 2^shift
	 *  mult = 1000000000 * 2^shift / hz
	 *  mult = (1000000000<<shift) / hz
	 */
	u64 tmp = ((u64)1000000000) << shift_constant;

	tmp += hz/2; /* round for do_div */
	do_div(tmp, hz);

	return (u32)tmp;
}

/**
269
 * clocksource_cyc2ns - converts clocksource cycles to nanoseconds
270 271 272
 * @cycles:	cycles
 * @mult:	cycle to nanosecond multiplier
 * @shift:	cycle to nanosecond divisor (power of two)
273
 *
274
 * Converts cycles to nanoseconds, using the given mult and shift.
275 276 277
 *
 * XXX - This could use some mult_lxl_ll() asm optimization
 */
278
static inline s64 clocksource_cyc2ns(cycle_t cycles, u32 mult, u32 shift)
279
{
280
	return ((u64) cycles * mult) >> shift;
281 282 283
}


284
extern int clocksource_register(struct clocksource*);
285
extern int clocksource_unregister(struct clocksource*);
J
Jason Wessel 已提交
286
extern void clocksource_touch_watchdog(void);
287 288
extern struct clocksource* clocksource_get_next(void);
extern void clocksource_change_rating(struct clocksource *cs, int rating);
M
Magnus Damm 已提交
289
extern void clocksource_suspend(void);
T
Thomas Gleixner 已提交
290
extern void clocksource_resume(void);
291
extern struct clocksource * __init __weak clocksource_default_clock(void);
292
extern void clocksource_mark_unstable(struct clocksource *cs);
293

294 295 296
extern void
clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);

297 298 299 300 301 302
/*
 * Don't call __clocksource_register_scale directly, use
 * clocksource_register_hz/khz
 */
extern int
__clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq);
303 304
extern void
__clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq);
305 306 307 308 309 310 311 312 313 314 315

static inline int clocksource_register_hz(struct clocksource *cs, u32 hz)
{
	return __clocksource_register_scale(cs, 1, hz);
}

static inline int clocksource_register_khz(struct clocksource *cs, u32 khz)
{
	return __clocksource_register_scale(cs, 1000, khz);
}

316 317 318 319 320 321 322 323 324
static inline void __clocksource_updatefreq_hz(struct clocksource *cs, u32 hz)
{
	__clocksource_updatefreq_scale(cs, 1, hz);
}

static inline void __clocksource_updatefreq_khz(struct clocksource *cs, u32 khz)
{
	__clocksource_updatefreq_scale(cs, 1000, khz);
}
325

326

327
extern int timekeeping_notify(struct clocksource *clock);
328

329 330 331 332 333 334 335 336
extern cycle_t clocksource_mmio_readl_up(struct clocksource *);
extern cycle_t clocksource_mmio_readl_down(struct clocksource *);
extern cycle_t clocksource_mmio_readw_up(struct clocksource *);
extern cycle_t clocksource_mmio_readw_down(struct clocksource *);

extern int clocksource_mmio_init(void __iomem *, const char *,
	unsigned long, int, unsigned, cycle_t (*)(struct clocksource *));

337 338
extern int clocksource_i8253_init(void);

339 340
struct device_node;
typedef void(*clocksource_of_init_fn)(struct device_node *);
341 342 343 344 345 346
#ifdef CONFIG_CLKSRC_OF
extern void clocksource_of_init(void);

#define CLOCKSOURCE_OF_DECLARE(name, compat, fn)			\
	static const struct of_device_id __clksrc_of_table_##name	\
		__used __section(__clksrc_of_table)			\
347 348
		 = { .compatible = compat,				\
		     .data = (fn == (clocksource_of_init_fn)NULL) ? fn : fn }
349
#else
350
static inline void clocksource_of_init(void) {}
351 352 353 354 355
#define CLOCKSOURCE_OF_DECLARE(name, compat, fn)			\
	static const struct of_device_id __clksrc_of_table_##name	\
		__attribute__((unused))					\
		 = { .compatible = compat,				\
		     .data = (fn == (clocksource_of_init_fn)NULL) ? fn : fn }
356 357
#endif

358
#endif /* _LINUX_CLOCKSOURCE_H */