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 */
26 * struct cyclecounter - hardware abstraction for a free running counter
27 * Provides completely state-free accessors to the underlying hardware.
28 * Depending on which hardware it reads, the cycle counter may wrap
29 * around quickly. Locking rules (if necessary) have to be defined
30 * by the implementor and user of specific instances of this API.
32 * @read: returns the current cycle value
33 * @mask: bitmask for two's complement
34 * subtraction of non 64 bit counters,
35 * see CLOCKSOURCE_MASK() helper macro
36 * @mult: cycle to nanosecond multiplier
37 * @shift: cycle to nanosecond divisor (power of two)
40 cycle_t (*read
)(const struct cyclecounter
*cc
);
47 * struct timecounter - layer above a %struct cyclecounter which counts nanoseconds
48 * Contains the state needed by timecounter_read() to detect
49 * cycle counter wrap around. Initialize with
50 * timecounter_init(). Also used to convert cycle counts into the
51 * corresponding nanosecond counts with timecounter_cyc2time(). Users
52 * of this code are responsible for initializing the underlying
53 * cycle counter hardware, locking issues and reading the time
54 * more often than the cycle counter wraps around. The nanosecond
55 * counter will only wrap around after ~585 years.
57 * @cc: the cycle counter used by this instance
58 * @cycle_last: most recent cycle counter value seen by
60 * @nsec: continuously increasing count
63 const struct cyclecounter
*cc
;
69 * cyclecounter_cyc2ns - converts cycle counter cycles to nanoseconds
70 * @tc: Pointer to cycle counter.
73 * XXX - This could use some mult_lxl_ll() asm optimization. Same code
74 * as in cyc2ns, but with unsigned result.
76 static inline u64
cyclecounter_cyc2ns(const struct cyclecounter
*cc
,
79 u64 ret
= (u64
)cycles
;
80 ret
= (ret
* cc
->mult
) >> cc
->shift
;
85 * timecounter_init - initialize a time counter
86 * @tc: Pointer to time counter which is to be initialized/reset
87 * @cc: A cycle counter, ready to be used.
88 * @start_tstamp: Arbitrary initial time stamp.
90 * After this call the current cycle register (roughly) corresponds to
91 * the initial time stamp. Every call to timecounter_read() increments
92 * the time stamp counter by the number of elapsed nanoseconds.
94 extern void timecounter_init(struct timecounter
*tc
,
95 const struct cyclecounter
*cc
,
99 * timecounter_read - return nanoseconds elapsed since timecounter_init()
100 * plus the initial time stamp
101 * @tc: Pointer to time counter.
103 * In other words, keeps track of time since the same epoch as
104 * the function which generated the initial time stamp.
106 extern u64
timecounter_read(struct timecounter
*tc
);
109 * timecounter_cyc2time - convert a cycle counter to same
110 * time base as values returned by
112 * @tc: Pointer to time counter.
113 * @cycle: a value returned by tc->cc->read()
115 * Cycle counts that are converted correctly as long as they
116 * fall into the interval [-1/2 max cycle count, +1/2 max cycle count],
117 * with "max cycle count" == cs->mask+1.
119 * This allows conversion of cycle counter values which were generated
122 extern u64
timecounter_cyc2time(struct timecounter
*tc
,
123 cycle_t cycle_tstamp
);
126 * struct clocksource - hardware abstraction for a free running counter
127 * Provides mostly state-free accessors to the underlying hardware.
128 * This is the structure used for system time.
130 * @name: ptr to clocksource name
131 * @list: list head for registration
132 * @rating: rating value for selection (higher is better)
133 * To avoid rating inflation the following
134 * list should give you a guide as to how
135 * to assign your clocksource a rating
136 * 1-99: Unfit for real use
137 * Only available for bootup and testing purposes.
138 * 100-199: Base level usability.
139 * Functional for real use, but not desired.
141 * A correct and usable clocksource.
143 * A reasonably fast and accurate clocksource.
145 * The ideal clocksource. A must-use where
147 * @read: returns a cycle value, passes clocksource as argument
148 * @enable: optional function to enable the clocksource
149 * @disable: optional function to disable the clocksource
150 * @mask: bitmask for two's complement
151 * subtraction of non 64 bit counters
152 * @mult: cycle to nanosecond multiplier
153 * @shift: cycle to nanosecond divisor (power of two)
154 * @flags: flags describing special properties
155 * @vread: vsyscall based read
156 * @resume: resume function for the clocksource, if necessary
160 * First part of structure is read mostly
163 struct list_head list
;
165 cycle_t (*read
)(struct clocksource
*cs
);
166 int (*enable
)(struct clocksource
*cs
);
167 void (*disable
)(struct clocksource
*cs
);
172 cycle_t (*vread
)(void);
173 void (*resume
)(void);
175 void *fsys_mmio
; /* used by fsyscall asm code */
176 #define CLKSRC_FSYS_MMIO_SET(mmio, addr) ((mmio) = (addr))
178 #define CLKSRC_FSYS_MMIO_SET(mmio, addr) do { } while (0)
182 * Second part is written at each timer interrupt
183 * Keep it in a different cache line to dirty no
184 * more than one cache line.
186 cycle_t cycle_last ____cacheline_aligned_in_smp
;
188 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
189 /* Watchdog related data, used by the framework */
190 struct list_head wd_list
;
196 * Clock source flags bits::
198 #define CLOCK_SOURCE_IS_CONTINUOUS 0x01
199 #define CLOCK_SOURCE_MUST_VERIFY 0x02
201 #define CLOCK_SOURCE_WATCHDOG 0x10
202 #define CLOCK_SOURCE_VALID_FOR_HRES 0x20
203 #define CLOCK_SOURCE_UNSTABLE 0x40
205 /* simplify initialization of mask field */
206 #define CLOCKSOURCE_MASK(bits) (cycle_t)((bits) < 64 ? ((1ULL<<(bits))-1) : -1)
209 * clocksource_khz2mult - calculates mult from khz and shift
210 * @khz: Clocksource frequency in KHz
211 * @shift_constant: Clocksource shift factor
213 * Helper functions that converts a khz counter frequency to a timsource
214 * multiplier, given the clocksource shift value
216 static inline u32
clocksource_khz2mult(u32 khz
, u32 shift_constant
)
218 /* khz = cyc/(Million ns)
219 * mult/2^shift = ns/cyc
220 * mult = ns/cyc * 2^shift
221 * mult = 1Million/khz * 2^shift
222 * mult = 1000000 * 2^shift / khz
223 * mult = (1000000<<shift) / khz
225 u64 tmp
= ((u64
)1000000) << shift_constant
;
227 tmp
+= khz
/2; /* round for do_div */
234 * clocksource_hz2mult - calculates mult from hz and shift
235 * @hz: Clocksource frequency in Hz
236 * @shift_constant: Clocksource shift factor
238 * Helper functions that converts a hz counter
239 * frequency to a timsource multiplier, given the
240 * clocksource shift value
242 static inline u32
clocksource_hz2mult(u32 hz
, u32 shift_constant
)
244 /* hz = cyc/(Billion ns)
245 * mult/2^shift = ns/cyc
246 * mult = ns/cyc * 2^shift
247 * mult = 1Billion/hz * 2^shift
248 * mult = 1000000000 * 2^shift / hz
249 * mult = (1000000000<<shift) / hz
251 u64 tmp
= ((u64
)1000000000) << shift_constant
;
253 tmp
+= hz
/2; /* round for do_div */
260 * clocksource_cyc2ns - converts clocksource cycles to nanoseconds
262 * Converts cycles to nanoseconds, using the given mult and shift.
264 * XXX - This could use some mult_lxl_ll() asm optimization
266 static inline s64
clocksource_cyc2ns(cycle_t cycles
, u32 mult
, u32 shift
)
268 return ((u64
) cycles
* mult
) >> shift
;
272 /* used to install a new clocksource */
273 extern int clocksource_register(struct clocksource
*);
274 extern void clocksource_unregister(struct clocksource
*);
275 extern void clocksource_touch_watchdog(void);
276 extern struct clocksource
* clocksource_get_next(void);
277 extern void clocksource_change_rating(struct clocksource
*cs
, int rating
);
278 extern void clocksource_resume(void);
279 extern struct clocksource
* __init __weak
clocksource_default_clock(void);
281 #ifdef CONFIG_GENERIC_TIME_VSYSCALL
282 extern void update_vsyscall(struct timespec
*ts
, struct clocksource
*c
);
283 extern void update_vsyscall_tz(void);
285 static inline void update_vsyscall(struct timespec
*ts
, struct clocksource
*c
)
289 static inline void update_vsyscall_tz(void)
294 extern void timekeeping_notify(struct clocksource
*clock
);
296 #endif /* _LINUX_CLOCKSOURCE_H */