2 * linux/arch/x86-64/kernel/time.c
4 * "High Precision Event Timer" based timekeeping.
6 * Copyright (c) 1991,1992,1995 Linus Torvalds
7 * Copyright (c) 1994 Alan Modra
8 * Copyright (c) 1995 Markus Kuhn
9 * Copyright (c) 1996 Ingo Molnar
10 * Copyright (c) 1998 Andrea Arcangeli
11 * Copyright (c) 2002 Vojtech Pavlik
12 * Copyright (c) 2003 Andi Kleen
13 * RTC support code taken from arch/i386/kernel/timers/time_hpet.c
16 #include <linux/kernel.h>
17 #include <linux/sched.h>
18 #include <linux/interrupt.h>
19 #include <linux/init.h>
20 #include <linux/mc146818rtc.h>
21 #include <linux/time.h>
22 #include <linux/ioport.h>
23 #include <linux/module.h>
24 #include <linux/device.h>
25 #include <linux/sysdev.h>
26 #include <linux/bcd.h>
27 #include <linux/kallsyms.h>
28 #include <linux/acpi.h>
30 #include <acpi/achware.h> /* for PM timer frequency */
32 #include <asm/8253pit.h>
33 #include <asm/pgtable.h>
34 #include <asm/vsyscall.h>
35 #include <asm/timex.h>
36 #include <asm/proto.h>
38 #include <asm/sections.h>
39 #include <linux/cpufreq.h>
40 #include <linux/hpet.h>
41 #ifdef CONFIG_X86_LOCAL_APIC
45 #ifdef CONFIG_CPU_FREQ
46 static void cpufreq_delayed_get(void);
48 extern void i8254_timer_resume(void);
49 extern int using_apic_timer;
51 static char *time_init_gtod(void);
53 DEFINE_SPINLOCK(rtc_lock);
54 DEFINE_SPINLOCK(i8253_lock);
56 int nohpet __initdata = 0;
57 static int notsc __initdata = 0;
59 unsigned int cpu_khz; /* TSC clocks / usec, not used here */
60 static unsigned long hpet_period; /* fsecs / HPET clock */
61 unsigned long hpet_tick; /* HPET clocks / interrupt */
62 int hpet_use_timer; /* Use counter of hpet for time keeping, otherwise PIT */
63 unsigned long vxtime_hz = PIT_TICK_RATE;
64 int report_lost_ticks; /* command line option */
65 unsigned long long monotonic_base;
67 struct vxtime_data __vxtime __section_vxtime; /* for vsyscalls */
69 volatile unsigned long __jiffies __section_jiffies = INITIAL_JIFFIES;
70 unsigned long __wall_jiffies __section_wall_jiffies = INITIAL_JIFFIES;
71 struct timespec __xtime __section_xtime;
72 struct timezone __sys_tz __section_sys_tz;
75 * do_gettimeoffset() returns microseconds since last timer interrupt was
76 * triggered by hardware. A memory read of HPET is slower than a register read
77 * of TSC, but much more reliable. It's also synchronized to the timer
78 * interrupt. Note that do_gettimeoffset() may return more than hpet_tick, if a
79 * timer interrupt has happened already, but vxtime.trigger wasn't updated yet.
80 * This is not a problem, because jiffies hasn't updated either. They are bound
81 * together by xtime_lock.
84 static inline unsigned int do_gettimeoffset_tsc(void)
88 t = get_cycles_sync();
89 if (t < vxtime.last_tsc)
90 t = vxtime.last_tsc; /* hack */
91 x = ((t - vxtime.last_tsc) * vxtime.tsc_quot) >> 32;
95 static inline unsigned int do_gettimeoffset_hpet(void)
97 /* cap counter read to one tick to avoid inconsistencies */
98 unsigned long counter = hpet_readl(HPET_COUNTER) - vxtime.last;
99 return (min(counter,hpet_tick) * vxtime.quot) >> 32;
102 unsigned int (*do_gettimeoffset)(void) = do_gettimeoffset_tsc;
105 * This version of gettimeofday() has microsecond resolution and better than
106 * microsecond precision, as we're using at least a 10 MHz (usually 14.31818
110 void do_gettimeofday(struct timeval *tv)
112 unsigned long seq, t;
113 unsigned int sec, usec;
116 seq = read_seqbegin(&xtime_lock);
119 usec = xtime.tv_nsec / 1000;
121 /* i386 does some correction here to keep the clock
122 monotonous even when ntpd is fixing drift.
123 But they didn't work for me, there is a non monotonic
124 clock anyways with ntp.
125 I dropped all corrections now until a real solution can
126 be found. Note when you fix it here you need to do the same
127 in arch/x86_64/kernel/vsyscall.c and export all needed
128 variables in vmlinux.lds. -AK */
130 t = (jiffies - wall_jiffies) * (1000000L / HZ) +
134 } while (read_seqretry(&xtime_lock, seq));
136 tv->tv_sec = sec + usec / 1000000;
137 tv->tv_usec = usec % 1000000;
140 EXPORT_SYMBOL(do_gettimeofday);
143 * settimeofday() first undoes the correction that gettimeofday would do
144 * on the time, and then saves it. This is ugly, but has been like this for
148 int do_settimeofday(struct timespec *tv)
150 time_t wtm_sec, sec = tv->tv_sec;
151 long wtm_nsec, nsec = tv->tv_nsec;
153 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
156 write_seqlock_irq(&xtime_lock);
158 nsec -= do_gettimeoffset() * 1000 +
159 (jiffies - wall_jiffies) * (NSEC_PER_SEC/HZ);
161 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
162 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
164 set_normalized_timespec(&xtime, sec, nsec);
165 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
169 write_sequnlock_irq(&xtime_lock);
174 EXPORT_SYMBOL(do_settimeofday);
176 unsigned long profile_pc(struct pt_regs *regs)
178 unsigned long pc = instruction_pointer(regs);
180 /* Assume the lock function has either no stack frame or only a single
181 word. This checks if the address on the stack looks like a kernel
183 There is a small window for false hits, but in that case the tick
184 is just accounted to the spinlock function.
185 Better would be to write these functions in assembler again
186 and check exactly. */
187 if (in_lock_functions(pc)) {
188 char *v = *(char **)regs->rsp;
189 if ((v >= _stext && v <= _etext) ||
190 (v >= _sinittext && v <= _einittext) ||
191 (v >= (char *)MODULES_VADDR && v <= (char *)MODULES_END))
192 return (unsigned long)v;
193 return ((unsigned long *)regs->rsp)[1];
197 EXPORT_SYMBOL(profile_pc);
200 * In order to set the CMOS clock precisely, set_rtc_mmss has to be called 500
201 * ms after the second nowtime has started, because when nowtime is written
202 * into the registers of the CMOS clock, it will jump to the next second
203 * precisely 500 ms later. Check the Motorola MC146818A or Dallas DS12887 data
207 static void set_rtc_mmss(unsigned long nowtime)
209 int real_seconds, real_minutes, cmos_minutes;
210 unsigned char control, freq_select;
213 * IRQs are disabled when we're called from the timer interrupt,
214 * no need for spin_lock_irqsave()
217 spin_lock(&rtc_lock);
220 * Tell the clock it's being set and stop it.
223 control = CMOS_READ(RTC_CONTROL);
224 CMOS_WRITE(control | RTC_SET, RTC_CONTROL);
226 freq_select = CMOS_READ(RTC_FREQ_SELECT);
227 CMOS_WRITE(freq_select | RTC_DIV_RESET2, RTC_FREQ_SELECT);
229 cmos_minutes = CMOS_READ(RTC_MINUTES);
230 BCD_TO_BIN(cmos_minutes);
233 * since we're only adjusting minutes and seconds, don't interfere with hour
234 * overflow. This avoids messing with unknown time zones but requires your RTC
235 * not to be off by more than 15 minutes. Since we're calling it only when
236 * our clock is externally synchronized using NTP, this shouldn't be a problem.
239 real_seconds = nowtime % 60;
240 real_minutes = nowtime / 60;
241 if (((abs(real_minutes - cmos_minutes) + 15) / 30) & 1)
242 real_minutes += 30; /* correct for half hour time zone */
245 if (abs(real_minutes - cmos_minutes) >= 30) {
246 printk(KERN_WARNING "time.c: can't update CMOS clock "
247 "from %d to %d\n", cmos_minutes, real_minutes);
249 BIN_TO_BCD(real_seconds);
250 BIN_TO_BCD(real_minutes);
251 CMOS_WRITE(real_seconds, RTC_SECONDS);
252 CMOS_WRITE(real_minutes, RTC_MINUTES);
256 * The following flags have to be released exactly in this order, otherwise the
257 * DS12887 (popular MC146818A clone with integrated battery and quartz) will
258 * not reset the oscillator and will not update precisely 500 ms later. You
259 * won't find this mentioned in the Dallas Semiconductor data sheets, but who
260 * believes data sheets anyway ... -- Markus Kuhn
263 CMOS_WRITE(control, RTC_CONTROL);
264 CMOS_WRITE(freq_select, RTC_FREQ_SELECT);
266 spin_unlock(&rtc_lock);
270 /* monotonic_clock(): returns # of nanoseconds passed since time_init()
271 * Note: This function is required to return accurate
272 * time even in the absence of multiple timer ticks.
274 unsigned long long monotonic_clock(void)
277 u32 last_offset, this_offset, offset;
278 unsigned long long base;
280 if (vxtime.mode == VXTIME_HPET) {
282 seq = read_seqbegin(&xtime_lock);
284 last_offset = vxtime.last;
285 base = monotonic_base;
286 this_offset = hpet_readl(HPET_COUNTER);
287 } while (read_seqretry(&xtime_lock, seq));
288 offset = (this_offset - last_offset);
289 offset *= (NSEC_PER_SEC/HZ) / hpet_tick;
292 seq = read_seqbegin(&xtime_lock);
294 last_offset = vxtime.last_tsc;
295 base = monotonic_base;
296 } while (read_seqretry(&xtime_lock, seq));
297 this_offset = get_cycles_sync();
298 offset = (this_offset - last_offset)*1000 / cpu_khz;
300 return base + offset;
302 EXPORT_SYMBOL(monotonic_clock);
304 static noinline void handle_lost_ticks(int lost, struct pt_regs *regs)
306 static long lost_count;
308 if (report_lost_ticks) {
309 printk(KERN_WARNING "time.c: Lost %d timer tick(s)! ", lost);
310 print_symbol("rip %s)\n", regs->rip);
313 if (lost_count == 1000 && !warned) {
314 printk(KERN_WARNING "warning: many lost ticks.\n"
315 KERN_WARNING "Your time source seems to be instable or "
316 "some driver is hogging interupts\n");
317 print_symbol("rip %s\n", regs->rip);
318 if (vxtime.mode == VXTIME_TSC && vxtime.hpet_address) {
319 printk(KERN_WARNING "Falling back to HPET\n");
321 vxtime.last = hpet_readl(HPET_T0_CMP) -
324 vxtime.last = hpet_readl(HPET_COUNTER);
325 vxtime.mode = VXTIME_HPET;
326 do_gettimeoffset = do_gettimeoffset_hpet;
328 /* else should fall back to PIT, but code missing. */
333 #ifdef CONFIG_CPU_FREQ
334 /* In some cases the CPU can change frequency without us noticing
335 Give cpufreq a change to catch up. */
336 if ((lost_count+1) % 25 == 0)
337 cpufreq_delayed_get();
341 void main_timer_handler(struct pt_regs *regs)
343 static unsigned long rtc_update = 0;
345 int delay = 0, offset = 0, lost = 0;
348 * Here we are in the timer irq handler. We have irqs locally disabled (so we
349 * don't need spin_lock_irqsave()) but we don't know if the timer_bh is running
350 * on the other CPU, so we need a lock. We also need to lock the vsyscall
351 * variables, because both do_timer() and us change them -arca+vojtech
354 write_seqlock(&xtime_lock);
356 if (vxtime.hpet_address)
357 offset = hpet_readl(HPET_COUNTER);
359 if (hpet_use_timer) {
360 /* if we're using the hpet timer functionality,
361 * we can more accurately know the counter value
362 * when the timer interrupt occured.
364 offset = hpet_readl(HPET_T0_CMP) - hpet_tick;
365 delay = hpet_readl(HPET_COUNTER) - offset;
366 } else if (!pmtmr_ioport) {
367 spin_lock(&i8253_lock);
370 delay |= inb(0x40) << 8;
371 spin_unlock(&i8253_lock);
372 delay = LATCH - 1 - delay;
375 tsc = get_cycles_sync();
377 if (vxtime.mode == VXTIME_HPET) {
378 if (offset - vxtime.last > hpet_tick) {
379 lost = (offset - vxtime.last) / hpet_tick - 1;
383 (offset - vxtime.last)*(NSEC_PER_SEC/HZ) / hpet_tick;
385 vxtime.last = offset;
386 #ifdef CONFIG_X86_PM_TIMER
387 } else if (vxtime.mode == VXTIME_PMTMR) {
388 lost = pmtimer_mark_offset();
391 offset = (((tsc - vxtime.last_tsc) *
392 vxtime.tsc_quot) >> 32) - (USEC_PER_SEC / HZ);
397 if (offset > (USEC_PER_SEC / HZ)) {
398 lost = offset / (USEC_PER_SEC / HZ);
399 offset %= (USEC_PER_SEC / HZ);
402 monotonic_base += (tsc - vxtime.last_tsc)*1000000/cpu_khz ;
404 vxtime.last_tsc = tsc - vxtime.quot * delay / vxtime.tsc_quot;
406 if ((((tsc - vxtime.last_tsc) *
407 vxtime.tsc_quot) >> 32) < offset)
408 vxtime.last_tsc = tsc -
409 (((long) offset << 32) / vxtime.tsc_quot) - 1;
413 handle_lost_ticks(lost, regs);
418 * Do the timer stuff.
423 update_process_times(user_mode(regs));
427 * In the SMP case we use the local APIC timer interrupt to do the profiling,
428 * except when we simulate SMP mode on a uniprocessor system, in that case we
429 * have to call the local interrupt handler.
432 #ifndef CONFIG_X86_LOCAL_APIC
433 profile_tick(CPU_PROFILING, regs);
435 if (!using_apic_timer)
436 smp_local_timer_interrupt(regs);
440 * If we have an externally synchronized Linux clock, then update CMOS clock
441 * accordingly every ~11 minutes. set_rtc_mmss() will be called in the jiffy
442 * closest to exactly 500 ms before the next second. If the update fails, we
443 * don't care, as it'll be updated on the next turn, and the problem (time way
444 * off) isn't likely to go away much sooner anyway.
447 if (ntp_synced() && xtime.tv_sec > rtc_update &&
448 abs(xtime.tv_nsec - 500000000) <= tick_nsec / 2) {
449 set_rtc_mmss(xtime.tv_sec);
450 rtc_update = xtime.tv_sec + 660;
453 write_sequnlock(&xtime_lock);
456 static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
458 if (apic_runs_main_timer > 1)
460 main_timer_handler(regs);
461 #ifdef CONFIG_X86_LOCAL_APIC
462 if (using_apic_timer)
463 smp_send_timer_broadcast_ipi();
468 static unsigned int cyc2ns_scale __read_mostly;
469 #define CYC2NS_SCALE_FACTOR 10 /* 2^10, carefully chosen */
471 static inline void set_cyc2ns_scale(unsigned long cpu_khz)
473 cyc2ns_scale = (1000000 << CYC2NS_SCALE_FACTOR)/cpu_khz;
476 static inline unsigned long long cycles_2_ns(unsigned long long cyc)
478 return (cyc * cyc2ns_scale) >> CYC2NS_SCALE_FACTOR;
481 unsigned long long sched_clock(void)
486 /* Don't do a HPET read here. Using TSC always is much faster
487 and HPET may not be mapped yet when the scheduler first runs.
488 Disadvantage is a small drift between CPUs in some configurations,
489 but that should be tolerable. */
490 if (__vxtime.mode == VXTIME_HPET)
491 return (hpet_readl(HPET_COUNTER) * vxtime.quot) >> 32;
494 /* Could do CPU core sync here. Opteron can execute rdtsc speculatively,
495 which means it is not completely exact and may not be monotonous between
496 CPUs. But the errors should be too small to matter for scheduling
500 return cycles_2_ns(a);
503 static unsigned long get_cmos_time(void)
505 unsigned int year, mon, day, hour, min, sec;
507 unsigned extyear = 0;
509 spin_lock_irqsave(&rtc_lock, flags);
512 sec = CMOS_READ(RTC_SECONDS);
513 min = CMOS_READ(RTC_MINUTES);
514 hour = CMOS_READ(RTC_HOURS);
515 day = CMOS_READ(RTC_DAY_OF_MONTH);
516 mon = CMOS_READ(RTC_MONTH);
517 year = CMOS_READ(RTC_YEAR);
519 if (acpi_fadt.revision >= FADT2_REVISION_ID &&
521 extyear = CMOS_READ(acpi_fadt.century);
523 } while (sec != CMOS_READ(RTC_SECONDS));
525 spin_unlock_irqrestore(&rtc_lock, flags);
528 * We know that x86-64 always uses BCD format, no need to check the
542 printk(KERN_INFO "Extended CMOS year: %d\n", extyear);
545 * x86-64 systems only exists since 2002.
546 * This will work up to Dec 31, 2100
551 return mktime(year, mon, day, hour, min, sec);
554 #ifdef CONFIG_CPU_FREQ
556 /* Frequency scaling support. Adjust the TSC based timer when the cpu frequency
559 RED-PEN: On SMP we assume all CPUs run with the same frequency. It's
560 not that important because current Opteron setups do not support
561 scaling on SMP anyroads.
563 Should fix up last_tsc too. Currently gettimeofday in the
564 first tick after the change will be slightly wrong. */
566 #include <linux/workqueue.h>
568 static unsigned int cpufreq_delayed_issched = 0;
569 static unsigned int cpufreq_init = 0;
570 static struct work_struct cpufreq_delayed_get_work;
572 static void handle_cpufreq_delayed_get(void *v)
575 for_each_online_cpu(cpu) {
578 cpufreq_delayed_issched = 0;
581 /* if we notice lost ticks, schedule a call to cpufreq_get() as it tries
582 * to verify the CPU frequency the timing core thinks the CPU is running
583 * at is still correct.
585 static void cpufreq_delayed_get(void)
588 if (cpufreq_init && !cpufreq_delayed_issched) {
589 cpufreq_delayed_issched = 1;
593 "Losing some ticks... checking if CPU frequency changed.\n");
595 schedule_work(&cpufreq_delayed_get_work);
599 static unsigned int ref_freq = 0;
600 static unsigned long loops_per_jiffy_ref = 0;
602 static unsigned long cpu_khz_ref = 0;
604 static int time_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
607 struct cpufreq_freqs *freq = data;
608 unsigned long *lpj, dummy;
610 if (cpu_has(&cpu_data[freq->cpu], X86_FEATURE_CONSTANT_TSC))
614 if (!(freq->flags & CPUFREQ_CONST_LOOPS))
616 lpj = &cpu_data[freq->cpu].loops_per_jiffy;
618 lpj = &boot_cpu_data.loops_per_jiffy;
622 ref_freq = freq->old;
623 loops_per_jiffy_ref = *lpj;
624 cpu_khz_ref = cpu_khz;
626 if ((val == CPUFREQ_PRECHANGE && freq->old < freq->new) ||
627 (val == CPUFREQ_POSTCHANGE && freq->old > freq->new) ||
628 (val == CPUFREQ_RESUMECHANGE)) {
630 cpufreq_scale(loops_per_jiffy_ref, ref_freq, freq->new);
632 cpu_khz = cpufreq_scale(cpu_khz_ref, ref_freq, freq->new);
633 if (!(freq->flags & CPUFREQ_CONST_LOOPS))
634 vxtime.tsc_quot = (1000L << 32) / cpu_khz;
637 set_cyc2ns_scale(cpu_khz_ref);
642 static struct notifier_block time_cpufreq_notifier_block = {
643 .notifier_call = time_cpufreq_notifier
646 static int __init cpufreq_tsc(void)
648 INIT_WORK(&cpufreq_delayed_get_work, handle_cpufreq_delayed_get, NULL);
649 if (!cpufreq_register_notifier(&time_cpufreq_notifier_block,
650 CPUFREQ_TRANSITION_NOTIFIER))
655 core_initcall(cpufreq_tsc);
660 * calibrate_tsc() calibrates the processor TSC in a very simple way, comparing
661 * it to the HPET timer of known frequency.
664 #define TICK_COUNT 100000000
666 static unsigned int __init hpet_calibrate_tsc(void)
668 int tsc_start, hpet_start;
669 int tsc_now, hpet_now;
672 local_irq_save(flags);
675 hpet_start = hpet_readl(HPET_COUNTER);
680 hpet_now = hpet_readl(HPET_COUNTER);
681 tsc_now = get_cycles_sync();
682 local_irq_restore(flags);
683 } while ((tsc_now - tsc_start) < TICK_COUNT &&
684 (hpet_now - hpet_start) < TICK_COUNT);
686 return (tsc_now - tsc_start) * 1000000000L
687 / ((hpet_now - hpet_start) * hpet_period / 1000);
692 * pit_calibrate_tsc() uses the speaker output (channel 2) of
693 * the PIT. This is better than using the timer interrupt output,
694 * because we can read the value of the speaker with just one inb(),
695 * where we need three i/o operations for the interrupt channel.
696 * We count how many ticks the TSC does in 50 ms.
699 static unsigned int __init pit_calibrate_tsc(void)
701 unsigned long start, end;
704 spin_lock_irqsave(&i8253_lock, flags);
706 outb((inb(0x61) & ~0x02) | 0x01, 0x61);
709 outb((PIT_TICK_RATE / (1000 / 50)) & 0xff, 0x42);
710 outb((PIT_TICK_RATE / (1000 / 50)) >> 8, 0x42);
711 start = get_cycles_sync();
712 while ((inb(0x61) & 0x20) == 0);
713 end = get_cycles_sync();
715 spin_unlock_irqrestore(&i8253_lock, flags);
717 return (end - start) / 50;
721 static __init int late_hpet_init(void)
726 if (!vxtime.hpet_address)
729 memset(&hd, 0, sizeof (hd));
731 ntimer = hpet_readl(HPET_ID);
732 ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
736 * Register with driver.
737 * Timer0 and Timer1 is used by platform.
739 hd.hd_phys_address = vxtime.hpet_address;
740 hd.hd_address = (void __iomem *)fix_to_virt(FIX_HPET_BASE);
741 hd.hd_nirqs = ntimer;
742 hd.hd_flags = HPET_DATA_PLATFORM;
743 hpet_reserve_timer(&hd, 0);
744 #ifdef CONFIG_HPET_EMULATE_RTC
745 hpet_reserve_timer(&hd, 1);
747 hd.hd_irq[0] = HPET_LEGACY_8254;
748 hd.hd_irq[1] = HPET_LEGACY_RTC;
751 struct hpet_timer *timer;
754 hpet = (struct hpet *) fix_to_virt(FIX_HPET_BASE);
755 timer = &hpet->hpet_timers[2];
756 for (i = 2; i < ntimer; timer++, i++)
757 hd.hd_irq[i] = (timer->hpet_config &
758 Tn_INT_ROUTE_CNF_MASK) >>
759 Tn_INT_ROUTE_CNF_SHIFT;
766 fs_initcall(late_hpet_init);
769 static int hpet_timer_stop_set_go(unsigned long tick)
774 * Stop the timers and reset the main counter.
777 cfg = hpet_readl(HPET_CFG);
778 cfg &= ~(HPET_CFG_ENABLE | HPET_CFG_LEGACY);
779 hpet_writel(cfg, HPET_CFG);
780 hpet_writel(0, HPET_COUNTER);
781 hpet_writel(0, HPET_COUNTER + 4);
784 * Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
785 * and period also hpet_tick.
787 if (hpet_use_timer) {
788 hpet_writel(HPET_TN_ENABLE | HPET_TN_PERIODIC | HPET_TN_SETVAL |
789 HPET_TN_32BIT, HPET_T0_CFG);
790 hpet_writel(hpet_tick, HPET_T0_CMP);
791 hpet_writel(hpet_tick, HPET_T0_CMP); /* AK: why twice? */
792 cfg |= HPET_CFG_LEGACY;
798 cfg |= HPET_CFG_ENABLE;
799 hpet_writel(cfg, HPET_CFG);
804 static int hpet_init(void)
808 if (!vxtime.hpet_address)
810 set_fixmap_nocache(FIX_HPET_BASE, vxtime.hpet_address);
811 __set_fixmap(VSYSCALL_HPET, vxtime.hpet_address, PAGE_KERNEL_VSYSCALL_NOCACHE);
814 * Read the period, compute tick and quotient.
817 id = hpet_readl(HPET_ID);
819 if (!(id & HPET_ID_VENDOR) || !(id & HPET_ID_NUMBER))
822 hpet_period = hpet_readl(HPET_PERIOD);
823 if (hpet_period < 100000 || hpet_period > 100000000)
826 hpet_tick = (1000000000L * (USEC_PER_SEC / HZ) + hpet_period / 2) /
829 hpet_use_timer = (id & HPET_ID_LEGSUP);
831 return hpet_timer_stop_set_go(hpet_tick);
834 static int hpet_reenable(void)
836 return hpet_timer_stop_set_go(hpet_tick);
839 #define PIT_MODE 0x43
842 static void __init __pit_init(int val, u8 mode)
846 spin_lock_irqsave(&i8253_lock, flags);
847 outb_p(mode, PIT_MODE);
848 outb_p(val & 0xff, PIT_CH0); /* LSB */
849 outb_p(val >> 8, PIT_CH0); /* MSB */
850 spin_unlock_irqrestore(&i8253_lock, flags);
853 void __init pit_init(void)
855 __pit_init(LATCH, 0x34); /* binary, mode 2, LSB/MSB, ch 0 */
858 void __init pit_stop_interrupt(void)
860 __pit_init(0, 0x30); /* mode 0 */
863 void __init stop_timer_interrupt(void)
866 if (vxtime.hpet_address) {
868 hpet_timer_stop_set_go(0);
871 pit_stop_interrupt();
873 printk(KERN_INFO "timer: %s interrupt stopped.\n", name);
876 int __init time_setup(char *str)
878 report_lost_ticks = 1;
882 static struct irqaction irq0 = {
883 timer_interrupt, SA_INTERRUPT, CPU_MASK_NONE, "timer", NULL, NULL
886 void __init time_init(void)
892 vxtime.hpet_address = 0;
894 xtime.tv_sec = get_cmos_time();
897 set_normalized_timespec(&wall_to_monotonic,
898 -xtime.tv_sec, -xtime.tv_nsec);
901 vxtime_hz = (1000000000000000L + hpet_period / 2) / hpet_period;
903 vxtime.hpet_address = 0;
905 if (hpet_use_timer) {
906 /* set tick_nsec to use the proper rate for HPET */
907 tick_nsec = TICK_NSEC_HPET;
908 cpu_khz = hpet_calibrate_tsc();
910 #ifdef CONFIG_X86_PM_TIMER
911 } else if (pmtmr_ioport && !vxtime.hpet_address) {
912 vxtime_hz = PM_TIMER_FREQUENCY;
915 cpu_khz = pit_calibrate_tsc();
919 cpu_khz = pit_calibrate_tsc();
923 vxtime.mode = VXTIME_TSC;
924 gtod = time_init_gtod();
926 printk(KERN_INFO "time.c: Using %ld.%06ld MHz WALL %s GTOD %s timer.\n",
927 vxtime_hz / 1000000, vxtime_hz % 1000000, timename, gtod);
928 printk(KERN_INFO "time.c: Detected %d.%03d MHz processor.\n",
929 cpu_khz / 1000, cpu_khz % 1000);
930 vxtime.quot = (1000000L << 32) / vxtime_hz;
931 vxtime.tsc_quot = (1000L << 32) / cpu_khz;
932 vxtime.last_tsc = get_cycles_sync();
935 set_cyc2ns_scale(cpu_khz);
939 * Make an educated guess if the TSC is trustworthy and synchronized
942 __cpuinit int unsynchronized_tsc(void)
945 if (apic_is_clustered_box())
947 /* Intel systems are normally all synchronized. Exceptions
948 are handled in the check above. */
949 if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
952 /* Assume multi socket systems are not synchronized */
953 return num_present_cpus() > 1;
957 * Decide what mode gettimeofday should use.
959 __init static char *time_init_gtod(void)
963 if (unsynchronized_tsc())
965 if (vxtime.hpet_address && notsc) {
966 timetype = hpet_use_timer ? "HPET" : "PIT/HPET";
968 vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
970 vxtime.last = hpet_readl(HPET_COUNTER);
971 vxtime.mode = VXTIME_HPET;
972 do_gettimeoffset = do_gettimeoffset_hpet;
973 #ifdef CONFIG_X86_PM_TIMER
974 /* Using PM for gettimeofday is quite slow, but we have no other
975 choice because the TSC is too unreliable on some systems. */
976 } else if (pmtmr_ioport && !vxtime.hpet_address && notsc) {
978 do_gettimeoffset = do_gettimeoffset_pm;
979 vxtime.mode = VXTIME_PMTMR;
981 printk(KERN_INFO "Disabling vsyscall due to use of PM timer\n");
984 timetype = hpet_use_timer ? "HPET/TSC" : "PIT/TSC";
985 vxtime.mode = VXTIME_TSC;
990 __setup("report_lost_ticks", time_setup);
992 static long clock_cmos_diff;
993 static unsigned long sleep_start;
996 * sysfs support for the timer.
999 static int timer_suspend(struct sys_device *dev, pm_message_t state)
1002 * Estimate time zone so that set_time can update the clock
1004 long cmos_time = get_cmos_time();
1006 clock_cmos_diff = -cmos_time;
1007 clock_cmos_diff += get_seconds();
1008 sleep_start = cmos_time;
1012 static int timer_resume(struct sys_device *dev)
1014 unsigned long flags;
1016 unsigned long ctime = get_cmos_time();
1017 unsigned long sleep_length = (ctime - sleep_start) * HZ;
1019 if (vxtime.hpet_address)
1022 i8254_timer_resume();
1024 sec = ctime + clock_cmos_diff;
1025 write_seqlock_irqsave(&xtime_lock,flags);
1028 if (vxtime.mode == VXTIME_HPET) {
1030 vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
1032 vxtime.last = hpet_readl(HPET_COUNTER);
1033 #ifdef CONFIG_X86_PM_TIMER
1034 } else if (vxtime.mode == VXTIME_PMTMR) {
1038 vxtime.last_tsc = get_cycles_sync();
1039 write_sequnlock_irqrestore(&xtime_lock,flags);
1040 jiffies += sleep_length;
1041 wall_jiffies += sleep_length;
1042 monotonic_base += sleep_length * (NSEC_PER_SEC/HZ);
1043 touch_softlockup_watchdog();
1047 static struct sysdev_class timer_sysclass = {
1048 .resume = timer_resume,
1049 .suspend = timer_suspend,
1050 set_kset_name("timer"),
1053 /* XXX this driverfs stuff should probably go elsewhere later -john */
1054 static struct sys_device device_timer = {
1056 .cls = &timer_sysclass,
1059 static int time_init_device(void)
1061 int error = sysdev_class_register(&timer_sysclass);
1063 error = sysdev_register(&device_timer);
1067 device_initcall(time_init_device);
1069 #ifdef CONFIG_HPET_EMULATE_RTC
1070 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
1071 * is enabled, we support RTC interrupt functionality in software.
1072 * RTC has 3 kinds of interrupts:
1073 * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
1075 * 2) Alarm Interrupt - generate an interrupt at a specific time of day
1076 * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
1077 * 2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
1078 * (1) and (2) above are implemented using polling at a frequency of
1079 * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
1080 * overhead. (DEFAULT_RTC_INT_FREQ)
1081 * For (3), we use interrupts at 64Hz or user specified periodic
1082 * frequency, whichever is higher.
1084 #include <linux/rtc.h>
1086 #define DEFAULT_RTC_INT_FREQ 64
1087 #define RTC_NUM_INTS 1
1089 static unsigned long UIE_on;
1090 static unsigned long prev_update_sec;
1092 static unsigned long AIE_on;
1093 static struct rtc_time alarm_time;
1095 static unsigned long PIE_on;
1096 static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
1097 static unsigned long PIE_count;
1099 static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
1100 static unsigned int hpet_t1_cmp; /* cached comparator register */
1102 int is_hpet_enabled(void)
1104 return vxtime.hpet_address != 0;
1108 * Timer 1 for RTC, we do not use periodic interrupt feature,
1109 * even if HPET supports periodic interrupts on Timer 1.
1110 * The reason being, to set up a periodic interrupt in HPET, we need to
1111 * stop the main counter. And if we do that everytime someone diables/enables
1112 * RTC, we will have adverse effect on main kernel timer running on Timer 0.
1113 * So, for the time being, simulate the periodic interrupt in software.
1115 * hpet_rtc_timer_init() is called for the first time and during subsequent
1116 * interuppts reinit happens through hpet_rtc_timer_reinit().
1118 int hpet_rtc_timer_init(void)
1120 unsigned int cfg, cnt;
1121 unsigned long flags;
1123 if (!is_hpet_enabled())
1126 * Set the counter 1 and enable the interrupts.
1128 if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1129 hpet_rtc_int_freq = PIE_freq;
1131 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1133 local_irq_save(flags);
1134 cnt = hpet_readl(HPET_COUNTER);
1135 cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
1136 hpet_writel(cnt, HPET_T1_CMP);
1138 local_irq_restore(flags);
1140 cfg = hpet_readl(HPET_T1_CFG);
1141 cfg &= ~HPET_TN_PERIODIC;
1142 cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
1143 hpet_writel(cfg, HPET_T1_CFG);
1148 static void hpet_rtc_timer_reinit(void)
1150 unsigned int cfg, cnt;
1152 if (unlikely(!(PIE_on | AIE_on | UIE_on))) {
1153 cfg = hpet_readl(HPET_T1_CFG);
1154 cfg &= ~HPET_TN_ENABLE;
1155 hpet_writel(cfg, HPET_T1_CFG);
1159 if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1160 hpet_rtc_int_freq = PIE_freq;
1162 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1164 /* It is more accurate to use the comparator value than current count.*/
1166 cnt += hpet_tick*HZ/hpet_rtc_int_freq;
1167 hpet_writel(cnt, HPET_T1_CMP);
1172 * The functions below are called from rtc driver.
1173 * Return 0 if HPET is not being used.
1174 * Otherwise do the necessary changes and return 1.
1176 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
1178 if (!is_hpet_enabled())
1181 if (bit_mask & RTC_UIE)
1183 if (bit_mask & RTC_PIE)
1185 if (bit_mask & RTC_AIE)
1191 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
1193 int timer_init_reqd = 0;
1195 if (!is_hpet_enabled())
1198 if (!(PIE_on | AIE_on | UIE_on))
1199 timer_init_reqd = 1;
1201 if (bit_mask & RTC_UIE) {
1204 if (bit_mask & RTC_PIE) {
1208 if (bit_mask & RTC_AIE) {
1212 if (timer_init_reqd)
1213 hpet_rtc_timer_init();
1218 int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
1220 if (!is_hpet_enabled())
1223 alarm_time.tm_hour = hrs;
1224 alarm_time.tm_min = min;
1225 alarm_time.tm_sec = sec;
1230 int hpet_set_periodic_freq(unsigned long freq)
1232 if (!is_hpet_enabled())
1241 int hpet_rtc_dropped_irq(void)
1243 if (!is_hpet_enabled())
1249 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1251 struct rtc_time curr_time;
1252 unsigned long rtc_int_flag = 0;
1253 int call_rtc_interrupt = 0;
1255 hpet_rtc_timer_reinit();
1257 if (UIE_on | AIE_on) {
1258 rtc_get_rtc_time(&curr_time);
1261 if (curr_time.tm_sec != prev_update_sec) {
1262 /* Set update int info, call real rtc int routine */
1263 call_rtc_interrupt = 1;
1264 rtc_int_flag = RTC_UF;
1265 prev_update_sec = curr_time.tm_sec;
1270 if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
1271 /* Set periodic int info, call real rtc int routine */
1272 call_rtc_interrupt = 1;
1273 rtc_int_flag |= RTC_PF;
1278 if ((curr_time.tm_sec == alarm_time.tm_sec) &&
1279 (curr_time.tm_min == alarm_time.tm_min) &&
1280 (curr_time.tm_hour == alarm_time.tm_hour)) {
1281 /* Set alarm int info, call real rtc int routine */
1282 call_rtc_interrupt = 1;
1283 rtc_int_flag |= RTC_AF;
1286 if (call_rtc_interrupt) {
1287 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
1288 rtc_interrupt(rtc_int_flag, dev_id, regs);
1294 static int __init nohpet_setup(char *s)
1300 __setup("nohpet", nohpet_setup);
1302 int __init notsc_setup(char *s)
1308 __setup("notsc", notsc_setup);