[PATCH] time: x86_64: convert x86_64 to use GENERIC_TIME
authorjohn stultz <johnstul@us.ibm.com>
Fri, 16 Feb 2007 09:28:20 +0000 (01:28 -0800)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Fri, 16 Feb 2007 16:14:00 +0000 (08:14 -0800)
This patch converts x86_64 to use the GENERIC_TIME infrastructure and adds
clocksource structures for both TSC and HPET (ACPI PM is shared w/ i386).

[akpm@osdl.org: fix printk timestamps]
[akpm@osdl.org: fix printk ckeanups]
[akpm@osdl.org: hpet build fix]
Signed-off-by: John Stultz <johnstul@us.ibm.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Andi Kleen <ak@muc.de>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
arch/x86_64/Kconfig
arch/x86_64/kernel/apic.c
arch/x86_64/kernel/hpet.c
arch/x86_64/kernel/pmtimer.c
arch/x86_64/kernel/smpboot.c
arch/x86_64/kernel/time.c
arch/x86_64/kernel/tsc.c
drivers/char/hangcheck-timer.c
include/asm-x86_64/proto.h
include/asm-x86_64/timex.h

index 7982cbc3bc9488f34c5f6f4e338858032939a997..286b4606fb1efe53aff7a1460ccea97c43f268e5 100644 (file)
@@ -24,6 +24,10 @@ config X86
        bool
        default y
 
+config GENERIC_TIME
+       bool
+       default y
+
 config ZONE_DMA32
        bool
        default y
index 7ce7797796403b9a58536abd90d44ad9a36ebc6c..723417d924c09717c9c6659fbf5fe7361b0caafb 100644 (file)
@@ -786,7 +786,7 @@ static void setup_APIC_timer(unsigned int clocks)
        /* Turn off PIT interrupt if we use APIC timer as main timer.
           Only works with the PM timer right now
           TBD fix it for HPET too. */
-       if (vxtime.mode == VXTIME_PMTMR &&
+       if ((pmtmr_ioport != 0) &&
                smp_processor_id() == boot_cpu_id &&
                apic_runs_main_timer == 1 &&
                !cpu_isset(boot_cpu_id, timer_interrupt_broadcast_ipi_mask)) {
index 08ab37c966c223da7f83a5d2be67d06952ea0b7d..c23738899ae9cfa9bc9876bd62ef2882a7b4f6e4 100644 (file)
@@ -21,12 +21,6 @@ unsigned long hpet_tick;     /* HPET clocks / interrupt */
 int hpet_use_timer;            /* Use counter of hpet for time keeping,
                                 * otherwise PIT
                                 */
-unsigned int do_gettimeoffset_hpet(void)
-{
-       /* cap counter read to one tick to avoid inconsistencies */
-       unsigned long counter = hpet_readl(HPET_COUNTER) - vxtime.last;
-       return (min(counter,hpet_tick) * vxtime.quot) >> US_SCALE;
-}
 
 #ifdef CONFIG_HPET
 static __init int late_hpet_init(void)
@@ -451,3 +445,61 @@ static int __init nohpet_setup(char *s)
 
 __setup("nohpet", nohpet_setup);
 
+#define HPET_MASK      0xFFFFFFFF
+#define HPET_SHIFT     22
+
+/* FSEC = 10^-15 NSEC = 10^-9 */
+#define FSEC_PER_NSEC  1000000
+
+static void *hpet_ptr;
+
+static cycle_t read_hpet(void)
+{
+       return (cycle_t)readl(hpet_ptr);
+}
+
+struct clocksource clocksource_hpet = {
+       .name           = "hpet",
+       .rating         = 250,
+       .read           = read_hpet,
+       .mask           = (cycle_t)HPET_MASK,
+       .mult           = 0, /* set below */
+       .shift          = HPET_SHIFT,
+       .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+static int __init init_hpet_clocksource(void)
+{
+       unsigned long hpet_period;
+       void __iomem *hpet_base;
+       u64 tmp;
+
+       if (!hpet_address)
+               return -ENODEV;
+
+       /* calculate the hpet address: */
+       hpet_base = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
+       hpet_ptr = hpet_base + HPET_COUNTER;
+
+       /* calculate the frequency: */
+       hpet_period = readl(hpet_base + HPET_PERIOD);
+
+       /*
+        * hpet period is in femto seconds per cycle
+        * so we need to convert this to ns/cyc units
+        * aproximated by mult/2^shift
+        *
+        *  fsec/cyc * 1nsec/1000000fsec = nsec/cyc = mult/2^shift
+        *  fsec/cyc * 1ns/1000000fsec * 2^shift = mult
+        *  fsec/cyc * 2^shift * 1nsec/1000000fsec = mult
+        *  (fsec/cyc << shift)/1000000 = mult
+        *  (hpet_period << shift)/FSEC_PER_NSEC = mult
+        */
+       tmp = (u64)hpet_period << HPET_SHIFT;
+       do_div(tmp, FSEC_PER_NSEC);
+       clocksource_hpet.mult = (u32)tmp;
+
+       return clocksource_register(&clocksource_hpet);
+}
+
+module_init(init_hpet_clocksource);
index 7554458dc9cbb6f35c2d8caf9f0333f5c7e41410..ae8f91214f1564e510cf63c49efe079eb504853a 100644 (file)
 #include <asm/msr.h>
 #include <asm/vsyscall.h>
 
-/* The I/O port the PMTMR resides at.
- * The location is detected during setup_arch(),
- * in arch/i386/kernel/acpi/boot.c */
-u32 pmtmr_ioport __read_mostly;
-
-/* value of the Power timer at last timer interrupt */
-static u32 offset_delay;
-static u32 last_pmtmr_tick;
-
 #define ACPI_PM_MASK 0xFFFFFF /* limit it to 24 bits */
 
 static inline u32 cyc2us(u32 cycles)
@@ -48,38 +39,6 @@ static inline u32 cyc2us(u32 cycles)
        return (cycles >> 10);
 }
 
-int pmtimer_mark_offset(void)
-{
-       static int first_run = 1;
-       unsigned long tsc;
-       u32 lost;
-
-       u32 tick = inl(pmtmr_ioport);
-       u32 delta;
-
-       delta = cyc2us((tick - last_pmtmr_tick) & ACPI_PM_MASK);
-
-       last_pmtmr_tick = tick;
-       monotonic_base += delta * NSEC_PER_USEC;
-
-       delta += offset_delay;
-
-       lost = delta / (USEC_PER_SEC / HZ);
-       offset_delay = delta % (USEC_PER_SEC / HZ);
-
-       rdtscll(tsc);
-       vxtime.last_tsc = tsc - offset_delay * (u64)cpu_khz / 1000;
-
-       /* don't calculate delay for first run,
-          or if we've got less then a tick */
-       if (first_run || (lost < 1)) {
-               first_run = 0;
-               offset_delay = 0;
-       }
-
-       return lost - 1;
-}
-
 static unsigned pmtimer_wait_tick(void)
 {
        u32 a, b;
@@ -101,23 +60,6 @@ void pmtimer_wait(unsigned us)
        } while (cyc2us(b - a) < us);
 }
 
-void pmtimer_resume(void)
-{
-       last_pmtmr_tick = inl(pmtmr_ioport);
-}
-
-unsigned int do_gettimeoffset_pm(void)
-{
-       u32 now, offset, delta = 0;
-
-       offset = last_pmtmr_tick;
-       now = inl(pmtmr_ioport);
-       delta = (now - offset) & ACPI_PM_MASK;
-
-       return offset_delay + cyc2us(delta);
-}
-
-
 static int __init nopmtimer_setup(char *s)
 {
        pmtmr_ioport = 0;
index 62d828433c3015943fe307fff2b275b5c1e59791..35443729aad8b5fef81caba0483d5e6ab66d5856 100644 (file)
@@ -982,7 +982,6 @@ void __init smp_cpus_done(unsigned int max_cpus)
        smp_cleanup_boot();
        setup_ioapic_dest();
        check_nmi_watchdog();
-       time_init_gtod();
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
index 216fc9d742478902ca0109faa3aaf432a73381a8..d84208e3c6189188132e852e95e998cf5e12842b 100644 (file)
@@ -44,9 +44,6 @@
 #include <asm/apic.h>
 #include <asm/hpet.h>
 
-#ifdef CONFIG_CPU_FREQ
-extern void cpufreq_delayed_get(void);
-#endif
 extern void i8254_timer_resume(void);
 extern int using_apic_timer;
 
@@ -57,8 +54,6 @@ EXPORT_SYMBOL(rtc_lock);
 DEFINE_SPINLOCK(i8253_lock);
 
 unsigned long vxtime_hz = PIT_TICK_RATE;
-int report_lost_ticks;                         /* command line option */
-unsigned long long monotonic_base;
 
 struct vxtime_data __vxtime __section_vxtime;  /* for vsyscalls */
 
@@ -66,76 +61,6 @@ volatile unsigned long __jiffies __section_jiffies = INITIAL_JIFFIES;
 struct timespec __xtime __section_xtime;
 struct timezone __sys_tz __section_sys_tz;
 
-unsigned int (*do_gettimeoffset)(void) = do_gettimeoffset_tsc;
-
-/*
- * This version of gettimeofday() has microsecond resolution and better than
- * microsecond precision, as we're using at least a 10 MHz (usually 14.31818
- * MHz) HPET timer.
- */
-
-void do_gettimeofday(struct timeval *tv)
-{
-       unsigned long seq;
-       unsigned int sec, usec;
-
-       do {
-               seq = read_seqbegin(&xtime_lock);
-
-               sec = xtime.tv_sec;
-               usec = xtime.tv_nsec / NSEC_PER_USEC;
-
-               /* i386 does some correction here to keep the clock 
-                  monotonous even when ntpd is fixing drift.
-                  But they didn't work for me, there is a non monotonic
-                  clock anyways with ntp.
-                  I dropped all corrections now until a real solution can
-                  be found. Note when you fix it here you need to do the same
-                  in arch/x86_64/kernel/vsyscall.c and export all needed
-                  variables in vmlinux.lds. -AK */ 
-               usec += do_gettimeoffset();
-
-       } while (read_seqretry(&xtime_lock, seq));
-
-       tv->tv_sec = sec + usec / USEC_PER_SEC;
-       tv->tv_usec = usec % USEC_PER_SEC;
-}
-
-EXPORT_SYMBOL(do_gettimeofday);
-
-/*
- * settimeofday() first undoes the correction that gettimeofday would do
- * on the time, and then saves it. This is ugly, but has been like this for
- * ages already.
- */
-
-int do_settimeofday(struct timespec *tv)
-{
-       time_t wtm_sec, sec = tv->tv_sec;
-       long wtm_nsec, nsec = tv->tv_nsec;
-
-       if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
-               return -EINVAL;
-
-       write_seqlock_irq(&xtime_lock);
-
-       nsec -= do_gettimeoffset() * NSEC_PER_USEC;
-
-       wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
-       wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
-
-       set_normalized_timespec(&xtime, sec, nsec);
-       set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
-
-       ntp_clear();
-
-       write_sequnlock_irq(&xtime_lock);
-       clock_was_set();
-       return 0;
-}
-
-EXPORT_SYMBOL(do_settimeofday);
-
 unsigned long profile_pc(struct pt_regs *regs)
 {
        unsigned long pc = instruction_pointer(regs);
@@ -225,85 +150,9 @@ static void set_rtc_mmss(unsigned long nowtime)
 }
 
 
-/* monotonic_clock(): returns # of nanoseconds passed since time_init()
- *             Note: This function is required to return accurate
- *             time even in the absence of multiple timer ticks.
- */
-extern unsigned long long cycles_2_ns(unsigned long long cyc);
-unsigned long long monotonic_clock(void)
-{
-       unsigned long seq;
-       u32 last_offset, this_offset, offset;
-       unsigned long long base;
-
-       if (vxtime.mode == VXTIME_HPET) {
-               do {
-                       seq = read_seqbegin(&xtime_lock);
-
-                       last_offset = vxtime.last;
-                       base = monotonic_base;
-                       this_offset = hpet_readl(HPET_COUNTER);
-               } while (read_seqretry(&xtime_lock, seq));
-               offset = (this_offset - last_offset);
-               offset *= NSEC_PER_TICK / hpet_tick;
-       } else {
-               do {
-                       seq = read_seqbegin(&xtime_lock);
-
-                       last_offset = vxtime.last_tsc;
-                       base = monotonic_base;
-               } while (read_seqretry(&xtime_lock, seq));
-               this_offset = get_cycles_sync();
-               offset = cycles_2_ns(this_offset - last_offset);
-       }
-       return base + offset;
-}
-EXPORT_SYMBOL(monotonic_clock);
-
-static noinline void handle_lost_ticks(int lost)
-{
-       static long lost_count;
-       static int warned;
-       if (report_lost_ticks) {
-               printk(KERN_WARNING "time.c: Lost %d timer tick(s)! ", lost);
-               print_symbol("rip %s)\n", get_irq_regs()->rip);
-       }
-
-       if (lost_count == 1000 && !warned) {
-               printk(KERN_WARNING "warning: many lost ticks.\n"
-                      KERN_WARNING "Your time source seems to be instable or "
-                               "some driver is hogging interupts\n");
-               print_symbol("rip %s\n", get_irq_regs()->rip);
-               if (vxtime.mode == VXTIME_TSC && hpet_address) {
-                       printk(KERN_WARNING "Falling back to HPET\n");
-                       if (hpet_use_timer)
-                               vxtime.last = hpet_readl(HPET_T0_CMP) - 
-                                                       hpet_tick;
-                       else
-                               vxtime.last = hpet_readl(HPET_COUNTER);
-                       vxtime.mode = VXTIME_HPET;
-                       vxtime.hpet_address = hpet_address;
-                       do_gettimeoffset = do_gettimeoffset_hpet;
-               }
-               /* else should fall back to PIT, but code missing. */
-               warned = 1;
-       } else
-               lost_count++;
-
-#ifdef CONFIG_CPU_FREQ
-       /* In some cases the CPU can change frequency without us noticing
-          Give cpufreq a change to catch up. */
-       if ((lost_count+1) % 25 == 0)
-               cpufreq_delayed_get();
-#endif
-}
-
 void main_timer_handler(void)
 {
        static unsigned long rtc_update = 0;
-       unsigned long tsc;
-       int delay = 0, offset = 0, lost = 0;
-
 /*
  * Here we are in the timer irq handler. We have irqs locally disabled (so we
  * don't need spin_lock_irqsave()) but we don't know if the timer_bh is running
@@ -313,72 +162,11 @@ void main_timer_handler(void)
 
        write_seqlock(&xtime_lock);
 
-       if (hpet_address)
-               offset = hpet_readl(HPET_COUNTER);
-
-       if (hpet_use_timer) {
-               /* if we're using the hpet timer functionality,
-                * we can more accurately know the counter value
-                * when the timer interrupt occured.
-                */
-               offset = hpet_readl(HPET_T0_CMP) - hpet_tick;
-               delay = hpet_readl(HPET_COUNTER) - offset;
-       } else if (!pmtmr_ioport) {
-               spin_lock(&i8253_lock);
-               outb_p(0x00, 0x43);
-               delay = inb_p(0x40);
-               delay |= inb(0x40) << 8;
-               spin_unlock(&i8253_lock);
-               delay = LATCH - 1 - delay;
-       }
-
-       tsc = get_cycles_sync();
-
-       if (vxtime.mode == VXTIME_HPET) {
-               if (offset - vxtime.last > hpet_tick) {
-                       lost = (offset - vxtime.last) / hpet_tick - 1;
-               }
-
-               monotonic_base += 
-                       (offset - vxtime.last) * NSEC_PER_TICK / hpet_tick;
-
-               vxtime.last = offset;
-#ifdef CONFIG_X86_PM_TIMER
-       } else if (vxtime.mode == VXTIME_PMTMR) {
-               lost = pmtimer_mark_offset();
-#endif
-       } else {
-               offset = (((tsc - vxtime.last_tsc) *
-                          vxtime.tsc_quot) >> US_SCALE) - USEC_PER_TICK;
-
-               if (offset < 0)
-                       offset = 0;
-
-               if (offset > USEC_PER_TICK) {
-                       lost = offset / USEC_PER_TICK;
-                       offset %= USEC_PER_TICK;
-               }
-
-               monotonic_base += cycles_2_ns(tsc - vxtime.last_tsc);
-
-               vxtime.last_tsc = tsc - vxtime.quot * delay / vxtime.tsc_quot;
-
-               if ((((tsc - vxtime.last_tsc) *
-                     vxtime.tsc_quot) >> US_SCALE) < offset)
-                       vxtime.last_tsc = tsc -
-                               (((long) offset << US_SCALE) / vxtime.tsc_quot) - 1;
-       }
-
-       if (lost > 0)
-               handle_lost_ticks(lost);
-       else
-               lost = 0;
-
 /*
  * Do the timer stuff.
  */
 
-       do_timer(lost + 1);
+       do_timer(1);
 #ifndef CONFIG_SMP
        update_process_times(user_mode(get_irq_regs()));
 #endif
@@ -537,12 +325,6 @@ void __init stop_timer_interrupt(void)
        printk(KERN_INFO "timer: %s interrupt stopped.\n", name);
 }
 
-int __init time_setup(char *str)
-{
-       report_lost_ticks = 1;
-       return 1;
-}
-
 static struct irqaction irq0 = {
        timer_interrupt, IRQF_DISABLED, CPU_MASK_NONE, "timer", NULL, NULL
 };
@@ -557,9 +339,7 @@ void __init time_init(void)
        set_normalized_timespec(&wall_to_monotonic,
                                -xtime.tv_sec, -xtime.tv_nsec);
 
-       if (!hpet_arch_init())
-                vxtime_hz = (FSEC_PER_SEC + hpet_period / 2) / hpet_period;
-       else
+       if (hpet_arch_init())
                hpet_address = 0;
 
        if (hpet_use_timer) {
@@ -567,82 +347,26 @@ void __init time_init(void)
                tick_nsec = TICK_NSEC_HPET;
                cpu_khz = hpet_calibrate_tsc();
                timename = "HPET";
-#ifdef CONFIG_X86_PM_TIMER
-       } else if (pmtmr_ioport && !hpet_address) {
-               vxtime_hz = PM_TIMER_FREQUENCY;
-               timename = "PM";
-               pit_init();
-               cpu_khz = pit_calibrate_tsc();
-#endif
        } else {
                pit_init();
                cpu_khz = pit_calibrate_tsc();
                timename = "PIT";
        }
 
-       vxtime.mode = VXTIME_TSC;
-       vxtime.quot = (USEC_PER_SEC << US_SCALE) / vxtime_hz;
-       vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
-       vxtime.last_tsc = get_cycles_sync();
-       set_cyc2ns_scale(cpu_khz);
-       setup_irq(0, &irq0);
-
-#ifndef CONFIG_SMP
-       time_init_gtod();
-#endif
-}
-
-/*
- * Decide what mode gettimeofday should use.
- */
-void time_init_gtod(void)
-{
-       char *timetype;
-
        if (unsynchronized_tsc())
-               notsc = 1;
+               mark_tsc_unstable();
 
        if (cpu_has(&boot_cpu_data, X86_FEATURE_RDTSCP))
                vgetcpu_mode = VGETCPU_RDTSCP;
        else
                vgetcpu_mode = VGETCPU_LSL;
 
-       if (hpet_address && notsc) {
-               timetype = hpet_use_timer ? "HPET" : "PIT/HPET";
-               if (hpet_use_timer)
-                       vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
-               else
-                       vxtime.last = hpet_readl(HPET_COUNTER);
-               vxtime.mode = VXTIME_HPET;
-               vxtime.hpet_address = hpet_address;
-               do_gettimeoffset = do_gettimeoffset_hpet;
-#ifdef CONFIG_X86_PM_TIMER
-       /* Using PM for gettimeofday is quite slow, but we have no other
-          choice because the TSC is too unreliable on some systems. */
-       } else if (pmtmr_ioport && !hpet_address && notsc) {
-               timetype = "PM";
-               do_gettimeoffset = do_gettimeoffset_pm;
-               vxtime.mode = VXTIME_PMTMR;
-               sysctl_vsyscall = 0;
-               printk(KERN_INFO "Disabling vsyscall due to use of PM timer\n");
-#endif
-       } else {
-               timetype = hpet_use_timer ? "HPET/TSC" : "PIT/TSC";
-               vxtime.mode = VXTIME_TSC;
-       }
-
-       printk(KERN_INFO "time.c: Using %ld.%06ld MHz WALL %s GTOD %s timer.\n",
-              vxtime_hz / 1000000, vxtime_hz % 1000000, timename, timetype);
+       set_cyc2ns_scale(cpu_khz);
        printk(KERN_INFO "time.c: Detected %d.%03d MHz processor.\n",
                cpu_khz / 1000, cpu_khz % 1000);
-       vxtime.quot = (USEC_PER_SEC << US_SCALE) / vxtime_hz;
-       vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
-       vxtime.last_tsc = get_cycles_sync();
-
-       set_cyc2ns_scale(cpu_khz);
+       setup_irq(0, &irq0);
 }
 
-__setup("report_lost_ticks", time_setup);
 
 static long clock_cmos_diff;
 static unsigned long sleep_start;
@@ -688,20 +412,8 @@ static int timer_resume(struct sys_device *dev)
        write_seqlock_irqsave(&xtime_lock,flags);
        xtime.tv_sec = sec;
        xtime.tv_nsec = 0;
-       if (vxtime.mode == VXTIME_HPET) {
-               if (hpet_use_timer)
-                       vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
-               else
-                       vxtime.last = hpet_readl(HPET_COUNTER);
-#ifdef CONFIG_X86_PM_TIMER
-       } else if (vxtime.mode == VXTIME_PMTMR) {
-               pmtimer_resume();
-#endif
-       } else
-               vxtime.last_tsc = get_cycles_sync();
-       write_sequnlock_irqrestore(&xtime_lock,flags);
        jiffies += sleep_length;
-       monotonic_base += sleep_length * (NSEC_PER_SEC/HZ);
+       write_sequnlock_irqrestore(&xtime_lock,flags);
        touch_softlockup_watchdog();
        return 0;
 }
index 2dbac15ab1f07d43b26996e1f40bbbc678e3d0c0..8c92f2fe7e2eeec425dc9f0485e6818942f70cb2 100644 (file)
@@ -9,32 +9,11 @@
 
 #include <asm/timex.h>
 
-int notsc __initdata = 0;
+static int notsc __initdata = 0;
 
 unsigned int cpu_khz;          /* TSC clocks / usec, not used here */
 EXPORT_SYMBOL(cpu_khz);
 
-/*
- * do_gettimeoffset() returns microseconds since last timer interrupt was
- * triggered by hardware. A memory read of HPET is slower than a register read
- * of TSC, but much more reliable. It's also synchronized to the timer
- * interrupt. Note that do_gettimeoffset() may return more than hpet_tick, if a
- * timer interrupt has happened already, but vxtime.trigger wasn't updated yet.
- * This is not a problem, because jiffies hasn't updated either. They are bound
- * together by xtime_lock.
- */
-
-unsigned int do_gettimeoffset_tsc(void)
-{
-       unsigned long t;
-       unsigned long x;
-       t = get_cycles_sync();
-       if (t < vxtime.last_tsc)
-               t = vxtime.last_tsc; /* hack */
-       x = ((t - vxtime.last_tsc) * vxtime.tsc_quot) >> US_SCALE;
-       return x;
-}
-
 static unsigned int cyc2ns_scale __read_mostly;
 
 void set_cyc2ns_scale(unsigned long khz)
@@ -42,7 +21,7 @@ void set_cyc2ns_scale(unsigned long khz)
        cyc2ns_scale = (NSEC_PER_MSEC << NS_SCALE) / khz;
 }
 
-unsigned long long cycles_2_ns(unsigned long long cyc)
+static unsigned long long cycles_2_ns(unsigned long long cyc)
 {
        return (cyc * cyc2ns_scale) >> NS_SCALE;
 }
@@ -61,6 +40,12 @@ unsigned long long sched_clock(void)
        return cycles_2_ns(a);
 }
 
+static int tsc_unstable;
+
+static inline int check_tsc_unstable(void)
+{
+       return tsc_unstable;
+}
 #ifdef CONFIG_CPU_FREQ
 
 /* Frequency scaling support. Adjust the TSC based timer when the cpu frequency
@@ -89,24 +74,6 @@ static void handle_cpufreq_delayed_get(struct work_struct *v)
        cpufreq_delayed_issched = 0;
 }
 
-/* if we notice lost ticks, schedule a call to cpufreq_get() as it tries
- * to verify the CPU frequency the timing core thinks the CPU is running
- * at is still correct.
- */
-void cpufreq_delayed_get(void)
-{
-       static int warned;
-       if (cpufreq_init && !cpufreq_delayed_issched) {
-               cpufreq_delayed_issched = 1;
-               if (!warned) {
-                       warned = 1;
-                       printk(KERN_DEBUG "Losing some ticks... "
-                               "checking if CPU frequency changed.\n");
-               }
-               schedule_work(&cpufreq_delayed_get_work);
-       }
-}
-
 static unsigned int  ref_freq = 0;
 static unsigned long loops_per_jiffy_ref = 0;
 
@@ -142,7 +109,7 @@ static int time_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
 
                cpu_khz = cpufreq_scale(cpu_khz_ref, ref_freq, freq->new);
                if (!(freq->flags & CPUFREQ_CONST_LOOPS))
-                       vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
+                       mark_tsc_unstable();
        }
 
        set_cyc2ns_scale(cpu_khz_ref);
@@ -169,12 +136,6 @@ core_initcall(cpufreq_tsc);
 
 static int tsc_unstable = 0;
 
-void mark_tsc_unstable(void)
-{
-       tsc_unstable = 1;
-}
-EXPORT_SYMBOL_GPL(mark_tsc_unstable);
-
 /*
  * Make an educated guess if the TSC is trustworthy and synchronized
  * over all CPUs.
@@ -210,3 +171,49 @@ int __init notsc_setup(char *s)
 }
 
 __setup("notsc", notsc_setup);
+
+
+/* clock source code: */
+static cycle_t read_tsc(void)
+{
+       cycle_t ret = (cycle_t)get_cycles_sync();
+       return ret;
+}
+
+static struct clocksource clocksource_tsc = {
+       .name                   = "tsc",
+       .rating                 = 300,
+       .read                   = read_tsc,
+       .mask                   = CLOCKSOURCE_MASK(64),
+       .shift                  = 22,
+       .flags                  = CLOCK_SOURCE_IS_CONTINUOUS |
+                                 CLOCK_SOURCE_MUST_VERIFY,
+};
+
+void mark_tsc_unstable(void)
+{
+       if (!tsc_unstable) {
+               tsc_unstable = 1;
+               /* Change only the rating, when not registered */
+               if (clocksource_tsc.mult)
+                       clocksource_change_rating(&clocksource_tsc, 0);
+               else
+                       clocksource_tsc.rating = 0;
+       }
+}
+EXPORT_SYMBOL_GPL(mark_tsc_unstable);
+
+static int __init init_tsc_clocksource(void)
+{
+       if (!notsc) {
+               clocksource_tsc.mult = clocksource_khz2mult(cpu_khz,
+                                                       clocksource_tsc.shift);
+               if (check_tsc_unstable())
+                       clocksource_tsc.rating = 0;
+
+               return clocksource_register(&clocksource_tsc);
+       }
+       return 0;
+}
+
+module_init(init_tsc_clocksource);
index 1aa93a752a9c0c636bf6945224c7ea6aa787bf48..ae76a9ffe89f56481dc0cb851e3e0687b66b8694 100644 (file)
@@ -117,7 +117,7 @@ __setup("hcheck_reboot", hangcheck_parse_reboot);
 __setup("hcheck_dump_tasks", hangcheck_parse_dump_tasks);
 #endif /* not MODULE */
 
-#if defined(CONFIG_X86_64) || defined(CONFIG_S390)
+#if defined(CONFIG_S390)
 # define HAVE_MONOTONIC
 # define TIMER_FREQ 1000000000ULL
 #elif defined(CONFIG_IA64)
index 2ce3adf7bfdcf624b161b15ebc1537aa5b0a45b3..f590ae088f0d7bbfe9ae1c0e69ca64bc315e3b31 100644 (file)
@@ -45,11 +45,9 @@ extern u32 pmtmr_ioport;
 #else
 #define pmtmr_ioport 0
 #endif
-extern unsigned long long monotonic_base;
 extern int sysctl_vsyscall;
 extern int nohpet;
 extern unsigned long vxtime_hz;
-extern void time_init_gtod(void);
 
 extern void early_printk(const char *fmt, ...) __attribute__((format(printf,1,2)));
 
index a0174757aee2618d42d604cf286eecb008b812ea..beb6d9014a63dc2d32f44d62b321fbb4dc402072 100644 (file)
@@ -28,9 +28,6 @@ extern int read_current_timer(unsigned long *timer_value);
 #define US_SCALE        32 /* 2^32, arbitralrily chosen */
 
 extern struct vxtime_data vxtime;
-
-extern unsigned int do_gettimeoffset_hpet(void);
-extern unsigned int do_gettimeoffset_tsc(void);
+extern void mark_tsc_unstable(void);
 extern void set_cyc2ns_scale(unsigned long khz);
-extern int notsc;
 #endif