1 /* linux/include/linux/clocksource.h
3 * This file contains the structure definitions for clocksources.
5 * If you are not a clocksource, or timekeeping code, you should
6 * not be including this file!
8 #ifndef _LINUX_CLOCKSOURCE_H
9 #define _LINUX_CLOCKSOURCE_H
11 #include <linux/types.h>
12 #include <linux/timex.h>
13 #include <linux/time.h>
14 #include <linux/list.h>
15 #include <linux/cache.h>
16 #include <linux/timer.h>
17 #include <linux/init.h>
18 #include <asm/div64.h>
21 /* clocksource cycle base type */
25 #include <asm/clocksource.h>
28 * struct cyclecounter - hardware abstraction for a free running counter
29 * Provides completely state-free accessors to the underlying hardware.
30 * Depending on which hardware it reads, the cycle counter may wrap
31 * around quickly. Locking rules (if necessary) have to be defined
32 * by the implementor and user of specific instances of this API.
34 * @read: returns the current cycle value
35 * @mask: bitmask for two's complement
36 * subtraction of non 64 bit counters,
37 * see CLOCKSOURCE_MASK() helper macro
38 * @mult: cycle to nanosecond multiplier
39 * @shift: cycle to nanosecond divisor (power of two)
42 cycle_t (*read
)(const struct cyclecounter
*cc
);
49 * struct timecounter - layer above a %struct cyclecounter which counts nanoseconds
50 * Contains the state needed by timecounter_read() to detect
51 * cycle counter wrap around. Initialize with
52 * timecounter_init(). Also used to convert cycle counts into the
53 * corresponding nanosecond counts with timecounter_cyc2time(). Users
54 * of this code are responsible for initializing the underlying
55 * cycle counter hardware, locking issues and reading the time
56 * more often than the cycle counter wraps around. The nanosecond
57 * counter will only wrap around after ~585 years.
59 * @cc: the cycle counter used by this instance
60 * @cycle_last: most recent cycle counter value seen by
62 * @nsec: continuously increasing count
65 const struct cyclecounter
*cc
;
71 * cyclecounter_cyc2ns - converts cycle counter cycles to nanoseconds
72 * @tc: Pointer to cycle counter.
75 * XXX - This could use some mult_lxl_ll() asm optimization. Same code
76 * as in cyc2ns, but with unsigned result.
78 static inline u64
cyclecounter_cyc2ns(const struct cyclecounter
*cc
,
81 u64 ret
= (u64
)cycles
;
82 ret
= (ret
* cc
->mult
) >> cc
->shift
;
87 * timecounter_init - initialize a time counter
88 * @tc: Pointer to time counter which is to be initialized/reset
89 * @cc: A cycle counter, ready to be used.
90 * @start_tstamp: Arbitrary initial time stamp.
92 * After this call the current cycle register (roughly) corresponds to
93 * the initial time stamp. Every call to timecounter_read() increments
94 * the time stamp counter by the number of elapsed nanoseconds.
96 extern void timecounter_init(struct timecounter
*tc
,
97 const struct cyclecounter
*cc
,
101 * timecounter_read - return nanoseconds elapsed since timecounter_init()
102 * plus the initial time stamp
103 * @tc: Pointer to time counter.
105 * In other words, keeps track of time since the same epoch as
106 * the function which generated the initial time stamp.
108 extern u64
timecounter_read(struct timecounter
*tc
);
111 * timecounter_cyc2time - convert a cycle counter to same
112 * time base as values returned by
114 * @tc: Pointer to time counter.
115 * @cycle: a value returned by tc->cc->read()
117 * Cycle counts that are converted correctly as long as they
118 * fall into the interval [-1/2 max cycle count, +1/2 max cycle count],
119 * with "max cycle count" == cs->mask+1.
121 * This allows conversion of cycle counter values which were generated
124 extern u64
timecounter_cyc2time(struct timecounter
*tc
,
125 cycle_t cycle_tstamp
);
128 * struct clocksource - hardware abstraction for a free running counter
129 * Provides mostly state-free accessors to the underlying hardware.
130 * This is the structure used for system time.
132 * @name: ptr to clocksource name
133 * @list: list head for registration
134 * @rating: rating value for selection (higher is better)
135 * To avoid rating inflation the following
136 * list should give you a guide as to how
137 * to assign your clocksource a rating
138 * 1-99: Unfit for real use
139 * Only available for bootup and testing purposes.
140 * 100-199: Base level usability.
141 * Functional for real use, but not desired.
143 * A correct and usable clocksource.
145 * A reasonably fast and accurate clocksource.
147 * The ideal clocksource. A must-use where
149 * @read: returns a cycle value, passes clocksource as argument
150 * @enable: optional function to enable the clocksource
151 * @disable: optional function to disable the clocksource
152 * @mask: bitmask for two's complement
153 * subtraction of non 64 bit counters
154 * @mult: cycle to nanosecond multiplier
155 * @shift: cycle to nanosecond divisor (power of two)
156 * @max_idle_ns: max idle time permitted by the clocksource (nsecs)
157 * @flags: flags describing special properties
158 * @archdata: arch-specific data
159 * @suspend: suspend function for the clocksource, if necessary
160 * @resume: resume function for the clocksource, if necessary
164 * Hotpath data, fits in a single cache line when the
165 * clocksource itself is cacheline aligned.
167 cycle_t (*read
)(struct clocksource
*cs
);
174 #ifdef __ARCH_HAS_CLOCKSOURCE_DATA
175 struct arch_clocksource_data archdata
;
179 struct list_head list
;
181 int (*enable
)(struct clocksource
*cs
);
182 void (*disable
)(struct clocksource
*cs
);
184 void (*suspend
)(struct clocksource
*cs
);
185 void (*resume
)(struct clocksource
*cs
);
187 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
188 /* Watchdog related data, used by the framework */
189 struct list_head wd_list
;
192 } ____cacheline_aligned
;
195 * Clock source flags bits::
197 #define CLOCK_SOURCE_IS_CONTINUOUS 0x01
198 #define CLOCK_SOURCE_MUST_VERIFY 0x02
200 #define CLOCK_SOURCE_WATCHDOG 0x10
201 #define CLOCK_SOURCE_VALID_FOR_HRES 0x20
202 #define CLOCK_SOURCE_UNSTABLE 0x40
204 /* simplify initialization of mask field */
205 #define CLOCKSOURCE_MASK(bits) (cycle_t)((bits) < 64 ? ((1ULL<<(bits))-1) : -1)
208 * clocksource_khz2mult - calculates mult from khz and shift
209 * @khz: Clocksource frequency in KHz
210 * @shift_constant: Clocksource shift factor
212 * Helper functions that converts a khz counter frequency to a timsource
213 * multiplier, given the clocksource shift value
215 static inline u32
clocksource_khz2mult(u32 khz
, u32 shift_constant
)
217 /* khz = cyc/(Million ns)
218 * mult/2^shift = ns/cyc
219 * mult = ns/cyc * 2^shift
220 * mult = 1Million/khz * 2^shift
221 * mult = 1000000 * 2^shift / khz
222 * mult = (1000000<<shift) / khz
224 u64 tmp
= ((u64
)1000000) << shift_constant
;
226 tmp
+= khz
/2; /* round for do_div */
233 * clocksource_hz2mult - calculates mult from hz and shift
234 * @hz: Clocksource frequency in Hz
235 * @shift_constant: Clocksource shift factor
237 * Helper functions that converts a hz counter
238 * frequency to a timsource multiplier, given the
239 * clocksource shift value
241 static inline u32
clocksource_hz2mult(u32 hz
, u32 shift_constant
)
243 /* hz = cyc/(Billion ns)
244 * mult/2^shift = ns/cyc
245 * mult = ns/cyc * 2^shift
246 * mult = 1Billion/hz * 2^shift
247 * mult = 1000000000 * 2^shift / hz
248 * mult = (1000000000<<shift) / hz
250 u64 tmp
= ((u64
)1000000000) << shift_constant
;
252 tmp
+= hz
/2; /* round for do_div */
259 * clocksource_cyc2ns - converts clocksource cycles to nanoseconds
261 * Converts cycles to nanoseconds, using the given mult and shift.
263 * XXX - This could use some mult_lxl_ll() asm optimization
265 static inline s64
clocksource_cyc2ns(cycle_t cycles
, u32 mult
, u32 shift
)
267 return ((u64
) cycles
* mult
) >> shift
;
271 extern int clocksource_register(struct clocksource
*);
272 extern void clocksource_unregister(struct clocksource
*);
273 extern void clocksource_touch_watchdog(void);
274 extern struct clocksource
* clocksource_get_next(void);
275 extern void clocksource_change_rating(struct clocksource
*cs
, int rating
);
276 extern void clocksource_suspend(void);
277 extern void clocksource_resume(void);
278 extern struct clocksource
* __init __weak
clocksource_default_clock(void);
279 extern void clocksource_mark_unstable(struct clocksource
*cs
);
282 clocks_calc_mult_shift(u32
*mult
, u32
*shift
, u32 from
, u32 to
, u32 minsec
);
285 * Don't call __clocksource_register_scale directly, use
286 * clocksource_register_hz/khz
289 __clocksource_register_scale(struct clocksource
*cs
, u32 scale
, u32 freq
);
291 __clocksource_updatefreq_scale(struct clocksource
*cs
, u32 scale
, u32 freq
);
293 static inline int clocksource_register_hz(struct clocksource
*cs
, u32 hz
)
295 return __clocksource_register_scale(cs
, 1, hz
);
298 static inline int clocksource_register_khz(struct clocksource
*cs
, u32 khz
)
300 return __clocksource_register_scale(cs
, 1000, khz
);
303 static inline void __clocksource_updatefreq_hz(struct clocksource
*cs
, u32 hz
)
305 __clocksource_updatefreq_scale(cs
, 1, hz
);
308 static inline void __clocksource_updatefreq_khz(struct clocksource
*cs
, u32 khz
)
310 __clocksource_updatefreq_scale(cs
, 1000, khz
);
314 clocksource_calc_mult_shift(struct clocksource
*cs
, u32 freq
, u32 minsec
)
316 return clocks_calc_mult_shift(&cs
->mult
, &cs
->shift
, freq
,
317 NSEC_PER_SEC
, minsec
);
320 #ifdef CONFIG_GENERIC_TIME_VSYSCALL
322 update_vsyscall(struct timespec
*ts
, struct timespec
*wtm
,
323 struct clocksource
*c
, u32 mult
);
324 extern void update_vsyscall_tz(void);
327 update_vsyscall(struct timespec
*ts
, struct timespec
*wtm
,
328 struct clocksource
*c
, u32 mult
)
332 static inline void update_vsyscall_tz(void)
337 extern void timekeeping_notify(struct clocksource
*clock
);
339 extern cycle_t
clocksource_mmio_readl_up(struct clocksource
*);
340 extern cycle_t
clocksource_mmio_readl_down(struct clocksource
*);
341 extern cycle_t
clocksource_mmio_readw_up(struct clocksource
*);
342 extern cycle_t
clocksource_mmio_readw_down(struct clocksource
*);
344 extern int clocksource_mmio_init(void __iomem
*, const char *,
345 unsigned long, int, unsigned, cycle_t (*)(struct clocksource
*));
347 extern int clocksource_i8253_init(void);
349 #endif /* _LINUX_CLOCKSOURCE_H */