From: Thomas Gleixner Utilize the TSC clocksource again on high-res timers. (dependent on the existence of pmtimer as a fallback to resync across TSC-destructive resume/halt/cpufreq events, but that is normally available.) Signed-off-by: Thomas Gleixner Signed-off-by: Ingo Molnar Signed-off-by: Andrew Morton --- arch/i386/kernel/tsc.c | 50 ++++++++++++++++++++++++--------------- 1 file changed, 31 insertions(+), 19 deletions(-) diff -puN arch/i386/kernel/tsc.c~high-res-timers-utilize-tsc-clocksource-again arch/i386/kernel/tsc.c --- a/arch/i386/kernel/tsc.c~high-res-timers-utilize-tsc-clocksource-again +++ a/arch/i386/kernel/tsc.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -388,42 +389,51 @@ static struct dmi_system_id __initdata b #define TSC_FREQ_CHECK_INTERVAL (10*MSEC_PER_SEC) /* 10sec in MS */ static struct timer_list verify_tsc_freq_timer; +static unsigned long pm_multiplier; /* XXX - Probably should add locking */ static void verify_tsc_freq(unsigned long unused) { static u64 last_tsc; - static unsigned long last_jiffies; + static unsigned long last_jiffies, last_pm; u64 now_tsc, interval_tsc; - unsigned long now_jiffies, interval_jiffies; - + unsigned long now_jiffies, interval_jiffies, pm, pm_delta; if (check_tsc_unstable()) return; rdtscll(now_tsc); now_jiffies = jiffies; + pm = acpi_pm_read_early(); - if (!last_jiffies) { + if (!last_jiffies) goto out; - } interval_jiffies = now_jiffies - last_jiffies; - interval_tsc = now_tsc - last_tsc; - interval_tsc *= HZ; - do_div(interval_tsc, cpu_khz*1000); + + if (pm == last_pm) { + interval_tsc = now_tsc - last_tsc; + interval_tsc *= HZ; + do_div(interval_tsc, cpu_khz*1000); + } else { + if (pm < last_pm) + pm += ACPI_PM_OVRRUN; + pm_delta = pm - last_pm; + interval_tsc = (((u64) pm_delta) * pm_multiplier) >> 22; + do_div(interval_tsc, TICK_NSEC); + } if (interval_tsc < (interval_jiffies * 3 / 4)) { printk("TSC appears to be running slowly. " - "Marking it as unstable\n"); + "Marking it as unstable\n"); mark_tsc_unstable(); return; } - out: last_tsc = now_tsc; last_jiffies = now_jiffies; + last_pm = pm; /* set us up to go off on the next interval: */ mod_timer(&verify_tsc_freq_timer, jiffies + msecs_to_jiffies(TSC_FREQ_CHECK_INTERVAL)); @@ -458,23 +468,25 @@ static int __init init_tsc_clocksource(v current_tsc_khz = tsc_khz; clocksource_tsc.mult = clocksource_khz2mult(current_tsc_khz, clocksource_tsc.shift); -#ifndef CONFIG_HIGH_RES_TIMERS /* lower the rating if we already know its unstable: */ if (check_tsc_unstable()) clocksource_tsc.rating = 0; -#else + /* - * Mark TSC unsuitable for high resolution timers. TSC has so - * many pitfalls: frequency changes, stop in idle ... When we + * Mark TSC unsuitable for high resolution timers, when + * pm_timer is not available as a fallback. TSC has so many + * pitfalls: frequency changes, stop in idle ... When we * switch to high resolution mode we can not longer detect a * firmware caused frequency change, as the emulated tick uses * TSC as reference. This results in a circular dependency. - * Switch only to high resolution mode, if pm_timer or such - * is available. + * Switch only to high resolution mode, if pm_timer or such is + * available. */ - clocksource_tsc.rating = 50; - clocksource_tsc.is_continuous = 0; -#endif + if (!pmtmr_ioport || !clocksource_tsc.rating) + clocksource_tsc.is_continuous = 0; + + pm_multiplier = clocksource_hz2mult(PMTMR_TICKS_PER_SEC, 22); + init_timer(&verify_tsc_freq_timer); verify_tsc_freq_timer.function = verify_tsc_freq; verify_tsc_freq_timer.expires = _