1/* linux/include/linux/clocksource.h 2 * 3 * This file contains the structure definitions for clocksources. 4 * 5 * If you are not a clocksource, or timekeeping code, you should 6 * not be including this file! 7 */ 8#ifndef _LINUX_CLOCKSOURCE_H 9#define _LINUX_CLOCKSOURCE_H 10 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> 19#include <asm/io.h> 20 21/* clocksource cycle base type */ 22typedef u64 cycle_t; 23struct clocksource; 24struct module; 25 26#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA 27#include <asm/clocksource.h> 28#endif 29 30/** 31 * struct cyclecounter - hardware abstraction for a free running counter 32 * Provides completely state-free accessors to the underlying hardware. 33 * Depending on which hardware it reads, the cycle counter may wrap 34 * around quickly. Locking rules (if necessary) have to be defined 35 * by the implementor and user of specific instances of this API. 36 * 37 * @read: returns the current cycle value 38 * @mask: bitmask for two's complement 39 * subtraction of non 64 bit counters, 40 * see CLOCKSOURCE_MASK() helper macro 41 * @mult: cycle to nanosecond multiplier 42 * @shift: cycle to nanosecond divisor (power of two) 43 */ 44struct cyclecounter { 45 cycle_t (*read)(const struct cyclecounter *cc); 46 cycle_t mask; 47 u32 mult; 48 u32 shift; 49}; 50 51/** 52 * struct timecounter - layer above a %struct cyclecounter which counts nanoseconds 53 * Contains the state needed by timecounter_read() to detect 54 * cycle counter wrap around. Initialize with 55 * timecounter_init(). Also used to convert cycle counts into the 56 * corresponding nanosecond counts with timecounter_cyc2time(). Users 57 * of this code are responsible for initializing the underlying 58 * cycle counter hardware, locking issues and reading the time 59 * more often than the cycle counter wraps around. The nanosecond 60 * counter will only wrap around after ~585 years. 61 * 62 * @cc: the cycle counter used by this instance 63 * @cycle_last: most recent cycle counter value seen by 64 * timecounter_read() 65 * @nsec: continuously increasing count 66 */ 67struct timecounter { 68 const struct cyclecounter *cc; 69 cycle_t cycle_last; 70 u64 nsec; 71}; 72 73/** 74 * cyclecounter_cyc2ns - converts cycle counter cycles to nanoseconds 75 * @cc: Pointer to cycle counter. 76 * @cycles: Cycles 77 * 78 * XXX - This could use some mult_lxl_ll() asm optimization. Same code 79 * as in cyc2ns, but with unsigned result. 80 */ 81static inline u64 cyclecounter_cyc2ns(const struct cyclecounter *cc, 82 cycle_t cycles) 83{ 84 u64 ret = (u64)cycles; 85 ret = (ret * cc->mult) >> cc->shift; 86 return ret; 87} 88 89/** 90 * timecounter_init - initialize a time counter 91 * @tc: Pointer to time counter which is to be initialized/reset 92 * @cc: A cycle counter, ready to be used. 93 * @start_tstamp: Arbitrary initial time stamp. 94 * 95 * After this call the current cycle register (roughly) corresponds to 96 * the initial time stamp. Every call to timecounter_read() increments 97 * the time stamp counter by the number of elapsed nanoseconds. 98 */ 99extern void timecounter_init(struct timecounter *tc, 100 const struct cyclecounter *cc, 101 u64 start_tstamp); 102 103/** 104 * timecounter_read - return nanoseconds elapsed since timecounter_init() 105 * plus the initial time stamp 106 * @tc: Pointer to time counter. 107 * 108 * In other words, keeps track of time since the same epoch as 109 * the function which generated the initial time stamp. 110 */ 111extern u64 timecounter_read(struct timecounter *tc); 112 113/** 114 * timecounter_cyc2time - convert a cycle counter to same 115 * time base as values returned by 116 * timecounter_read() 117 * @tc: Pointer to time counter. 118 * @cycle_tstamp: a value returned by tc->cc->read() 119 * 120 * Cycle counts that are converted correctly as long as they 121 * fall into the interval [-1/2 max cycle count, +1/2 max cycle count], 122 * with "max cycle count" == cs->mask+1. 123 * 124 * This allows conversion of cycle counter values which were generated 125 * in the past. 126 */ 127extern u64 timecounter_cyc2time(struct timecounter *tc, 128 cycle_t cycle_tstamp); 129 130/** 131 * struct clocksource - hardware abstraction for a free running counter 132 * Provides mostly state-free accessors to the underlying hardware. 133 * This is the structure used for system time. 134 * 135 * @name: ptr to clocksource name 136 * @list: list head for registration 137 * @rating: rating value for selection (higher is better) 138 * To avoid rating inflation the following 139 * list should give you a guide as to how 140 * to assign your clocksource a rating 141 * 1-99: Unfit for real use 142 * Only available for bootup and testing purposes. 143 * 100-199: Base level usability. 144 * Functional for real use, but not desired. 145 * 200-299: Good. 146 * A correct and usable clocksource. 147 * 300-399: Desired. 148 * A reasonably fast and accurate clocksource. 149 * 400-499: Perfect 150 * The ideal clocksource. A must-use where 151 * available. 152 * @read: returns a cycle value, passes clocksource as argument 153 * @enable: optional function to enable the clocksource 154 * @disable: optional function to disable the clocksource 155 * @mask: bitmask for two's complement 156 * 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 163 * @suspend: suspend function for the clocksource, if necessary 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 */ 168struct clocksource { 169 /* 170 * Hotpath data, fits in a single cache line when the 171 * clocksource itself is cacheline aligned. 172 */ 173 cycle_t (*read)(struct clocksource *cs); 174 cycle_t cycle_last; 175 cycle_t mask; 176 u32 mult; 177 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 const char *name; 185 struct list_head list; 186 int rating; 187 int (*enable)(struct clocksource *cs); 188 void (*disable)(struct clocksource *cs); 189 unsigned long flags; 190 void (*suspend)(struct clocksource *cs); 191 void (*resume)(struct clocksource *cs); 192 193 /* private: */ 194#ifdef CONFIG_CLOCKSOURCE_WATCHDOG 195 /* Watchdog related data, used by the framework */ 196 struct list_head wd_list; 197 cycle_t cs_last; 198 cycle_t wd_last; 199#endif 200 struct module *owner; 201} ____cacheline_aligned; 202 203/* 204 * Clock source flags bits:: 205 */ 206#define CLOCK_SOURCE_IS_CONTINUOUS 0x01 207#define CLOCK_SOURCE_MUST_VERIFY 0x02 208 209#define CLOCK_SOURCE_WATCHDOG 0x10 210#define CLOCK_SOURCE_VALID_FOR_HRES 0x20 211#define CLOCK_SOURCE_UNSTABLE 0x40 212#define CLOCK_SOURCE_SUSPEND_NONSTOP 0x80 213#define CLOCK_SOURCE_RESELECT 0x100 214 215/* simplify initialization of mask field */ 216#define CLOCKSOURCE_MASK(bits) (cycle_t)((bits) < 64 ? ((1ULL<<(bits))-1) : -1) 217 218/** 219 * clocksource_khz2mult - calculates mult from khz and shift 220 * @khz: Clocksource frequency in KHz 221 * @shift_constant: Clocksource shift factor 222 * 223 * Helper functions that converts a khz counter frequency to a timsource 224 * multiplier, given the clocksource shift value 225 */ 226static inline u32 clocksource_khz2mult(u32 khz, u32 shift_constant) 227{ 228 /* khz = cyc/(Million ns) 229 * mult/2^shift = ns/cyc 230 * mult = ns/cyc * 2^shift 231 * mult = 1Million/khz * 2^shift 232 * mult = 1000000 * 2^shift / khz 233 * mult = (1000000<<shift) / khz 234 */ 235 u64 tmp = ((u64)1000000) << shift_constant; 236 237 tmp += khz/2; /* round for do_div */ 238 do_div(tmp, khz); 239 240 return (u32)tmp; 241} 242 243/** 244 * clocksource_hz2mult - calculates mult from hz and shift 245 * @hz: Clocksource frequency in Hz 246 * @shift_constant: Clocksource shift factor 247 * 248 * Helper functions that converts a hz counter 249 * frequency to a timsource multiplier, given the 250 * clocksource shift value 251 */ 252static inline u32 clocksource_hz2mult(u32 hz, u32 shift_constant) 253{ 254 /* hz = cyc/(Billion ns) 255 * mult/2^shift = ns/cyc 256 * mult = ns/cyc * 2^shift 257 * mult = 1Billion/hz * 2^shift 258 * mult = 1000000000 * 2^shift / hz 259 * mult = (1000000000<<shift) / hz 260 */ 261 u64 tmp = ((u64)1000000000) << shift_constant; 262 263 tmp += hz/2; /* round for do_div */ 264 do_div(tmp, hz); 265 266 return (u32)tmp; 267} 268 269/** 270 * clocksource_cyc2ns - converts clocksource cycles to nanoseconds 271 * @cycles: cycles 272 * @mult: cycle to nanosecond multiplier 273 * @shift: cycle to nanosecond divisor (power of two) 274 * 275 * Converts cycles to nanoseconds, using the given mult and shift. 276 * 277 * XXX - This could use some mult_lxl_ll() asm optimization 278 */ 279static inline s64 clocksource_cyc2ns(cycle_t cycles, u32 mult, u32 shift) 280{ 281 return ((u64) cycles * mult) >> shift; 282} 283 284 285extern int clocksource_register(struct clocksource*); 286extern int clocksource_unregister(struct clocksource*); 287extern void clocksource_touch_watchdog(void); 288extern struct clocksource* clocksource_get_next(void); 289extern void clocksource_change_rating(struct clocksource *cs, int rating); 290extern void clocksource_suspend(void); 291extern void clocksource_resume(void); 292extern struct clocksource * __init __weak clocksource_default_clock(void); 293extern void clocksource_mark_unstable(struct clocksource *cs); 294 295extern void 296clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec); 297 298/* 299 * Don't call __clocksource_register_scale directly, use 300 * clocksource_register_hz/khz 301 */ 302extern int 303__clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq); 304extern void 305__clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq); 306 307static inline int clocksource_register_hz(struct clocksource *cs, u32 hz) 308{ 309 return __clocksource_register_scale(cs, 1, hz); 310} 311 312static inline int clocksource_register_khz(struct clocksource *cs, u32 khz) 313{ 314 return __clocksource_register_scale(cs, 1000, khz); 315} 316 317static inline void __clocksource_updatefreq_hz(struct clocksource *cs, u32 hz) 318{ 319 __clocksource_updatefreq_scale(cs, 1, hz); 320} 321 322static inline void __clocksource_updatefreq_khz(struct clocksource *cs, u32 khz) 323{ 324 __clocksource_updatefreq_scale(cs, 1000, khz); 325} 326 327 328extern int timekeeping_notify(struct clocksource *clock); 329 330extern cycle_t clocksource_mmio_readl_up(struct clocksource *); 331extern cycle_t clocksource_mmio_readl_down(struct clocksource *); 332extern cycle_t clocksource_mmio_readw_up(struct clocksource *); 333extern cycle_t clocksource_mmio_readw_down(struct clocksource *); 334 335extern int clocksource_mmio_init(void __iomem *, const char *, 336 unsigned long, int, unsigned, cycle_t (*)(struct clocksource *)); 337 338extern int clocksource_i8253_init(void); 339 340struct device_node; 341typedef void(*clocksource_of_init_fn)(struct device_node *); 342#ifdef CONFIG_CLKSRC_OF 343extern void clocksource_of_init(void); 344 345#define CLOCKSOURCE_OF_DECLARE(name, compat, fn) \ 346 static const struct of_device_id __clksrc_of_table_##name \ 347 __used __section(__clksrc_of_table) \ 348 = { .compatible = compat, \ 349 .data = (fn == (clocksource_of_init_fn)NULL) ? fn : fn } 350#else 351static inline void clocksource_of_init(void) {} 352#define CLOCKSOURCE_OF_DECLARE(name, compat, fn) \ 353 static const struct of_device_id __clksrc_of_table_##name \ 354 __attribute__((unused)) \ 355 = { .compatible = compat, \ 356 .data = (fn == (clocksource_of_init_fn)NULL) ? fn : fn } 357#endif 358 359#endif /* _LINUX_CLOCKSOURCE_H */ 360