2006-06-26 07:25:05 +00:00
|
|
|
/* 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>
|
2007-05-08 07:27:57 +00:00
|
|
|
#include <linux/cache.h>
|
2007-02-16 09:27:43 +00:00
|
|
|
#include <linux/timer.h>
|
2009-08-14 13:47:21 +00:00
|
|
|
#include <linux/init.h>
|
2016-03-10 00:16:54 +00:00
|
|
|
#include <linux/of.h>
|
2006-06-26 07:25:05 +00:00
|
|
|
#include <asm/div64.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
2007-02-16 09:27:43 +00:00
|
|
|
struct clocksource;
|
2013-04-25 20:31:44 +00:00
|
|
|
struct module;
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2011-07-21 20:34:05 +00:00
|
|
|
#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
|
2011-07-13 13:24:13 +00:00
|
|
|
#include <asm/clocksource.h>
|
2011-07-21 20:34:05 +00:00
|
|
|
#endif
|
2011-07-13 13:24:13 +00:00
|
|
|
|
2006-06-26 07:25:05 +00:00
|
|
|
/**
|
|
|
|
* struct clocksource - hardware abstraction for a free running counter
|
|
|
|
* Provides mostly state-free accessors to the underlying hardware.
|
2009-02-12 05:03:34 +00:00
|
|
|
* This is the structure used for system time.
|
2006-06-26 07:25:05 +00:00
|
|
|
*
|
|
|
|
* @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.
|
2009-04-21 19:24:00 +00:00
|
|
|
* @read: returns a cycle value, passes clocksource as argument
|
2009-04-21 19:24:02 +00:00
|
|
|
* @enable: optional function to enable the clocksource
|
|
|
|
* @disable: optional function to disable the clocksource
|
2006-06-26 07:25:05 +00:00
|
|
|
* @mask: bitmask for two's complement
|
|
|
|
* subtraction of non 64 bit counters
|
2009-08-14 13:47:28 +00:00
|
|
|
* @mult: cycle to nanosecond multiplier
|
2006-06-26 07:25:05 +00:00
|
|
|
* @shift: cycle to nanosecond divisor (power of two)
|
2009-08-18 17:45:10 +00:00
|
|
|
* @max_idle_ns: max idle time permitted by the clocksource (nsecs)
|
2011-12-19 09:13:19 +00:00
|
|
|
* @maxadj: maximum adjustment value to mult (~11%)
|
2015-03-12 04:16:31 +00:00
|
|
|
* @max_cycles: maximum safe cycle value which won't overflow on multiplication
|
2007-02-16 09:27:36 +00:00
|
|
|
* @flags: flags describing special properties
|
2011-07-13 13:24:13 +00:00
|
|
|
* @archdata: arch-specific data
|
2010-02-02 22:41:41 +00:00
|
|
|
* @suspend: suspend function for the clocksource, if necessary
|
2007-05-09 09:35:15 +00:00
|
|
|
* @resume: resume function for the clocksource, if necessary
|
2016-12-15 10:44:28 +00:00
|
|
|
* @mark_unstable: Optional function to inform the clocksource driver that
|
|
|
|
* the watchdog marked the clocksource unstable
|
2013-04-25 20:31:44 +00:00
|
|
|
* @owner: module reference, must be set by clocksource in modules
|
2015-11-19 10:43:09 +00:00
|
|
|
*
|
|
|
|
* Note: This struct is not used in hotpathes of the timekeeping code
|
|
|
|
* because the timekeeper caches the hot path fields in its own data
|
|
|
|
* structure, so no line cache alignment is required,
|
|
|
|
*
|
|
|
|
* The pointer to the clocksource itself is handed to the read
|
|
|
|
* callback. If you need extra information there you can wrap struct
|
|
|
|
* clocksource into your own struct. Depending on the amount of
|
|
|
|
* information you need you should consider to cache line align that
|
|
|
|
* structure.
|
2006-06-26 07:25:05 +00:00
|
|
|
*/
|
|
|
|
struct clocksource {
|
2016-12-21 19:32:01 +00:00
|
|
|
u64 (*read)(struct clocksource *cs);
|
|
|
|
u64 mask;
|
2006-06-26 07:25:05 +00:00
|
|
|
u32 mult;
|
|
|
|
u32 shift;
|
2009-08-18 17:45:10 +00:00
|
|
|
u64 max_idle_ns;
|
2011-10-31 21:06:35 +00:00
|
|
|
u32 maxadj;
|
2011-07-21 20:34:05 +00:00
|
|
|
#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
|
2011-07-13 13:24:13 +00:00
|
|
|
struct arch_clocksource_data archdata;
|
2007-07-20 18:22:30 +00:00
|
|
|
#endif
|
2015-03-12 04:16:31 +00:00
|
|
|
u64 max_cycles;
|
2011-05-18 21:33:40 +00:00
|
|
|
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);
|
2016-12-15 10:44:28 +00:00
|
|
|
void (*mark_unstable)(struct clocksource *cs);
|
2007-02-16 09:27:43 +00:00
|
|
|
|
2011-12-19 09:13:19 +00:00
|
|
|
/* private: */
|
2007-02-16 09:27:43 +00:00
|
|
|
#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
|
|
|
|
/* Watchdog related data, used by the framework */
|
|
|
|
struct list_head wd_list;
|
2016-12-21 19:32:01 +00:00
|
|
|
u64 cs_last;
|
|
|
|
u64 wd_last;
|
2007-02-16 09:27:43 +00:00
|
|
|
#endif
|
2013-04-25 20:31:44 +00:00
|
|
|
struct module *owner;
|
2015-11-19 10:43:09 +00:00
|
|
|
};
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2007-02-16 09:27:36 +00:00
|
|
|
/*
|
|
|
|
* Clock source flags bits::
|
|
|
|
*/
|
2007-02-16 09:27:43 +00:00
|
|
|
#define CLOCK_SOURCE_IS_CONTINUOUS 0x01
|
|
|
|
#define CLOCK_SOURCE_MUST_VERIFY 0x02
|
|
|
|
|
|
|
|
#define CLOCK_SOURCE_WATCHDOG 0x10
|
|
|
|
#define CLOCK_SOURCE_VALID_FOR_HRES 0x20
|
2009-08-14 13:47:25 +00:00
|
|
|
#define CLOCK_SOURCE_UNSTABLE 0x40
|
2013-03-12 03:56:46 +00:00
|
|
|
#define CLOCK_SOURCE_SUSPEND_NONSTOP 0x80
|
clocksource: Reselect clocksource when watchdog validated high-res capability
Up to commit 5d33b883a (clocksource: Always verify highres capability)
we had no sanity check when selecting a clocksource, which prevented
that a non highres capable clocksource is used when the system already
switched to highres/nohz mode.
The new sanity check works as Alex and Tim found out. It prevents the
TSC from being used. This happens because on x86 the boot process
looks like this:
tsc_start_freqency_validation(TSC);
clocksource_register(HPET);
clocksource_done_booting();
clocksource_select()
Selects HPET which is valid for high-res
switch_to_highres();
clocksource_register(TSC);
TSC is not selected, because it is not yet
flagged as VALID_HIGH_RES
clocksource_watchdog()
Validates TSC for highres, but that does not make TSC
the current clocksource.
Before the sanity check was added, we installed TSC unvalidated which
worked most of the time. If the TSC was really detected as unstable,
then the unstable logic removed it and installed HPET again.
The sanity check is correct and needed. So the watchdog needs to kick
a reselection of the clocksource, when it qualifies TSC as a valid
high res clocksource.
To solve this, we mark the clocksource which got the flag
CLOCK_SOURCE_VALID_FOR_HRES set by the watchdog with an new flag
CLOCK_SOURCE_RESELECT and trigger the watchdog thread. The watchdog
thread evaluates the flag and invokes clocksource_select() when set.
To avoid that the clocksource_done_booting() code, which is about to
install the first real clocksource anyway, needs to go through
clocksource_select and tick_oneshot_notify() pointlessly, split out
the clocksource_watchdog_kthread() list walk code and invoke the
select/notify only when called from clocksource_watchdog_kthread().
So clocksource_done_booting() can utilize the same splitout code
without the select/notify invocation and the clocksource_mutex
unlock/relock dance.
Reported-and-tested-by: Alex Shi <alex.shi@intel.com>
Cc: Hans Peter Anvin <hpa@linux.intel.com>
Cc: Tim Chen <tim.c.chen@linux.intel.com>
Cc: Andi Kleen <andi.kleen@intel.com>
Tested-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Davidlohr Bueso <davidlohr.bueso@hp.com>
Cc: John Stultz <john.stultz@linaro.org>
Link: http://lkml.kernel.org/r/alpine.DEB.2.02.1307042239150.11637@ionos.tec.linutronix.de
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2013-07-04 20:46:45 +00:00
|
|
|
#define CLOCK_SOURCE_RESELECT 0x100
|
2007-02-16 09:27:36 +00:00
|
|
|
|
2006-06-26 07:25:15 +00:00
|
|
|
/* simplify initialization of mask field */
|
2016-12-21 19:32:01 +00:00
|
|
|
#define CLOCKSOURCE_MASK(bits) (u64)((bits) < 64 ? ((1ULL<<(bits))-1) : -1)
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2016-02-27 03:14:13 +00:00
|
|
|
static inline u32 clocksource_freq2mult(u32 freq, u32 shift_constant, u64 from)
|
|
|
|
{
|
|
|
|
/* freq = cyc/from
|
|
|
|
* mult/2^shift = ns/cyc
|
|
|
|
* mult = ns/cyc * 2^shift
|
|
|
|
* mult = from/freq * 2^shift
|
|
|
|
* mult = from * 2^shift / freq
|
|
|
|
* mult = (from<<shift) / freq
|
|
|
|
*/
|
|
|
|
u64 tmp = ((u64)from) << shift_constant;
|
|
|
|
|
|
|
|
tmp += freq/2; /* round for do_div */
|
|
|
|
do_div(tmp, freq);
|
|
|
|
|
|
|
|
return (u32)tmp;
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:25:05 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2016-02-27 03:14:13 +00:00
|
|
|
return clocksource_freq2mult(khz, shift_constant, NSEC_PER_MSEC);
|
2006-06-26 07:25:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2016-02-27 03:14:13 +00:00
|
|
|
return clocksource_freq2mult(hz, shift_constant, NSEC_PER_SEC);
|
2006-06-26 07:25:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-08-14 13:47:26 +00:00
|
|
|
* clocksource_cyc2ns - converts clocksource cycles to nanoseconds
|
2011-12-19 09:13:19 +00:00
|
|
|
* @cycles: cycles
|
|
|
|
* @mult: cycle to nanosecond multiplier
|
|
|
|
* @shift: cycle to nanosecond divisor (power of two)
|
2006-06-26 07:25:05 +00:00
|
|
|
*
|
2016-11-28 22:35:20 +00:00
|
|
|
* Converts clocksource cycles to nanoseconds, using the given @mult and @shift.
|
|
|
|
* The code is optimized for performance and is not intended to work
|
|
|
|
* with absolute clocksource cycles (as those will easily overflow),
|
|
|
|
* but is only intended to be used with relative (delta) clocksource cycles.
|
2006-06-26 07:25:05 +00:00
|
|
|
*
|
|
|
|
* XXX - This could use some mult_lxl_ll() asm optimization
|
|
|
|
*/
|
2016-12-21 19:32:01 +00:00
|
|
|
static inline s64 clocksource_cyc2ns(u64 cycles, u32 mult, u32 shift)
|
2006-06-26 07:25:05 +00:00
|
|
|
{
|
2009-08-14 13:47:26 +00:00
|
|
|
return ((u64) cycles * mult) >> shift;
|
2006-06-26 07:25:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-04-25 20:31:46 +00:00
|
|
|
extern int clocksource_unregister(struct clocksource*);
|
2008-02-15 20:55:54 +00:00
|
|
|
extern void clocksource_touch_watchdog(void);
|
2007-02-16 09:27:33 +00:00
|
|
|
extern void clocksource_change_rating(struct clocksource *cs, int rating);
|
2010-02-02 22:41:41 +00:00
|
|
|
extern void clocksource_suspend(void);
|
2007-05-09 09:35:15 +00:00
|
|
|
extern void clocksource_resume(void);
|
2014-10-14 00:59:09 +00:00
|
|
|
extern struct clocksource * __init clocksource_default_clock(void);
|
2009-08-28 18:25:24 +00:00
|
|
|
extern void clocksource_mark_unstable(struct clocksource *cs);
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2013-07-18 23:21:14 +00:00
|
|
|
extern u64
|
2015-03-12 04:16:31 +00:00
|
|
|
clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask, u64 *max_cycles);
|
2009-11-11 14:05:29 +00:00
|
|
|
extern void
|
|
|
|
clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);
|
|
|
|
|
2010-05-08 01:07:38 +00:00
|
|
|
/*
|
|
|
|
* Don't call __clocksource_register_scale directly, use
|
|
|
|
* clocksource_register_hz/khz
|
|
|
|
*/
|
|
|
|
extern int
|
|
|
|
__clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq);
|
2010-07-14 00:56:28 +00:00
|
|
|
extern void
|
2015-03-12 04:16:40 +00:00
|
|
|
__clocksource_update_freq_scale(struct clocksource *cs, u32 scale, u32 freq);
|
2010-05-08 01:07:38 +00:00
|
|
|
|
2015-03-12 04:16:37 +00:00
|
|
|
/*
|
|
|
|
* Don't call this unless you are a default clocksource
|
|
|
|
* (AKA: jiffies) and absolutely have to.
|
|
|
|
*/
|
|
|
|
static inline int __clocksource_register(struct clocksource *cs)
|
|
|
|
{
|
|
|
|
return __clocksource_register_scale(cs, 1, 0);
|
|
|
|
}
|
|
|
|
|
2010-05-08 01:07:38 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-03-12 04:16:40 +00:00
|
|
|
static inline void __clocksource_update_freq_hz(struct clocksource *cs, u32 hz)
|
2010-07-14 00:56:28 +00:00
|
|
|
{
|
2015-03-12 04:16:40 +00:00
|
|
|
__clocksource_update_freq_scale(cs, 1, hz);
|
2010-07-14 00:56:28 +00:00
|
|
|
}
|
|
|
|
|
2015-03-12 04:16:40 +00:00
|
|
|
static inline void __clocksource_update_freq_khz(struct clocksource *cs, u32 khz)
|
2010-07-14 00:56:28 +00:00
|
|
|
{
|
2015-03-12 04:16:40 +00:00
|
|
|
__clocksource_update_freq_scale(cs, 1000, khz);
|
2010-07-14 00:56:28 +00:00
|
|
|
}
|
2010-05-08 01:07:38 +00:00
|
|
|
|
2007-02-16 09:28:17 +00:00
|
|
|
|
2013-04-25 20:31:44 +00:00
|
|
|
extern int timekeeping_notify(struct clocksource *clock);
|
2009-08-14 13:47:30 +00:00
|
|
|
|
2016-12-21 19:32:01 +00:00
|
|
|
extern u64 clocksource_mmio_readl_up(struct clocksource *);
|
|
|
|
extern u64 clocksource_mmio_readl_down(struct clocksource *);
|
|
|
|
extern u64 clocksource_mmio_readw_up(struct clocksource *);
|
|
|
|
extern u64 clocksource_mmio_readw_down(struct clocksource *);
|
2011-05-08 13:06:52 +00:00
|
|
|
|
|
|
|
extern int clocksource_mmio_init(void __iomem *, const char *,
|
2016-12-21 19:32:01 +00:00
|
|
|
unsigned long, int, unsigned, u64 (*)(struct clocksource *));
|
2011-05-08 13:06:52 +00:00
|
|
|
|
2011-05-08 17:50:20 +00:00
|
|
|
extern int clocksource_i8253_init(void);
|
|
|
|
|
2014-05-08 21:09:24 +00:00
|
|
|
#define CLOCKSOURCE_OF_DECLARE(name, compat, fn) \
|
2016-06-06 22:27:44 +00:00
|
|
|
OF_DECLARE_1_RET(clksrc, name, compat, fn)
|
2016-05-31 14:25:59 +00:00
|
|
|
|
2015-09-28 14:49:16 +00:00
|
|
|
#ifdef CONFIG_CLKSRC_PROBE
|
2015-09-28 14:49:18 +00:00
|
|
|
extern void clocksource_probe(void);
|
2013-01-30 17:49:30 +00:00
|
|
|
#else
|
2015-09-28 14:49:18 +00:00
|
|
|
static inline void clocksource_probe(void) {}
|
2012-11-19 23:41:20 +00:00
|
|
|
#endif
|
|
|
|
|
2015-09-28 14:49:15 +00:00
|
|
|
#define CLOCKSOURCE_ACPI_DECLARE(name, table_id, fn) \
|
|
|
|
ACPI_DECLARE_PROBE_ENTRY(clksrc, name, table_id, 0, NULL, 0, fn)
|
|
|
|
|
2006-06-26 07:25:05 +00:00
|
|
|
#endif /* _LINUX_CLOCKSOURCE_H */
|