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,2006 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/notifier.h>
28 #include <linux/cpu.h>
29 #include <linux/kallsyms.h>
30 #include <linux/acpi.h>
32 #include <acpi/achware.h> /* for PM timer frequency */
33 #include <acpi/acpi_bus.h>
35 #include <asm/8253pit.h>
36 #include <asm/pgtable.h>
37 #include <asm/vsyscall.h>
38 #include <asm/timex.h>
39 #include <asm/proto.h>
41 #include <asm/sections.h>
42 #include <linux/cpufreq.h>
43 #include <linux/hpet.h>
44 #ifdef CONFIG_X86_LOCAL_APIC
48 #ifdef CONFIG_CPU_FREQ
49 static void cpufreq_delayed_get(void);
51 extern void i8254_timer_resume(void);
52 extern int using_apic_timer
;
54 static char *timename
= NULL
;
56 DEFINE_SPINLOCK(rtc_lock
);
57 EXPORT_SYMBOL(rtc_lock
);
58 DEFINE_SPINLOCK(i8253_lock
);
60 int nohpet __initdata
= 0;
61 static int notsc __initdata
= 0;
63 #define USEC_PER_TICK (USEC_PER_SEC / HZ)
64 #define NSEC_PER_TICK (NSEC_PER_SEC / HZ)
65 #define FSEC_PER_TICK (FSEC_PER_SEC / HZ)
67 #define NS_SCALE 10 /* 2^10, carefully chosen */
68 #define US_SCALE 32 /* 2^32, arbitralrily chosen */
70 unsigned int cpu_khz
; /* TSC clocks / usec, not used here */
71 EXPORT_SYMBOL(cpu_khz
);
72 static unsigned long hpet_period
; /* fsecs / HPET clock */
73 unsigned long hpet_tick
; /* HPET clocks / interrupt */
74 int hpet_use_timer
; /* Use counter of hpet for time keeping, otherwise PIT */
75 unsigned long vxtime_hz
= PIT_TICK_RATE
;
76 int report_lost_ticks
; /* command line option */
77 unsigned long long monotonic_base
;
79 struct vxtime_data __vxtime __section_vxtime
; /* for vsyscalls */
81 volatile unsigned long __jiffies __section_jiffies
= INITIAL_JIFFIES
;
82 unsigned long __wall_jiffies __section_wall_jiffies
= INITIAL_JIFFIES
;
83 struct timespec __xtime __section_xtime
;
84 struct timezone __sys_tz __section_sys_tz
;
87 * do_gettimeoffset() returns microseconds since last timer interrupt was
88 * triggered by hardware. A memory read of HPET is slower than a register read
89 * of TSC, but much more reliable. It's also synchronized to the timer
90 * interrupt. Note that do_gettimeoffset() may return more than hpet_tick, if a
91 * timer interrupt has happened already, but vxtime.trigger wasn't updated yet.
92 * This is not a problem, because jiffies hasn't updated either. They are bound
93 * together by xtime_lock.
96 static inline unsigned int do_gettimeoffset_tsc(void)
100 t
= get_cycles_sync();
101 if (t
< vxtime
.last_tsc
)
102 t
= vxtime
.last_tsc
; /* hack */
103 x
= ((t
- vxtime
.last_tsc
) * vxtime
.tsc_quot
) >> US_SCALE
;
107 static inline unsigned int do_gettimeoffset_hpet(void)
109 /* cap counter read to one tick to avoid inconsistencies */
110 unsigned long counter
= hpet_readl(HPET_COUNTER
) - vxtime
.last
;
111 return (min(counter
,hpet_tick
) * vxtime
.quot
) >> US_SCALE
;
114 unsigned int (*do_gettimeoffset
)(void) = do_gettimeoffset_tsc
;
117 * This version of gettimeofday() has microsecond resolution and better than
118 * microsecond precision, as we're using at least a 10 MHz (usually 14.31818
122 void do_gettimeofday(struct timeval
*tv
)
124 unsigned long seq
, t
;
125 unsigned int sec
, usec
;
128 seq
= read_seqbegin(&xtime_lock
);
131 usec
= xtime
.tv_nsec
/ NSEC_PER_USEC
;
133 /* i386 does some correction here to keep the clock
134 monotonous even when ntpd is fixing drift.
135 But they didn't work for me, there is a non monotonic
136 clock anyways with ntp.
137 I dropped all corrections now until a real solution can
138 be found. Note when you fix it here you need to do the same
139 in arch/x86_64/kernel/vsyscall.c and export all needed
140 variables in vmlinux.lds. -AK */
142 t
= (jiffies
- wall_jiffies
) * USEC_PER_TICK
+
146 } while (read_seqretry(&xtime_lock
, seq
));
148 tv
->tv_sec
= sec
+ usec
/ USEC_PER_SEC
;
149 tv
->tv_usec
= usec
% USEC_PER_SEC
;
152 EXPORT_SYMBOL(do_gettimeofday
);
155 * settimeofday() first undoes the correction that gettimeofday would do
156 * on the time, and then saves it. This is ugly, but has been like this for
160 int do_settimeofday(struct timespec
*tv
)
162 time_t wtm_sec
, sec
= tv
->tv_sec
;
163 long wtm_nsec
, nsec
= tv
->tv_nsec
;
165 if ((unsigned long)tv
->tv_nsec
>= NSEC_PER_SEC
)
168 write_seqlock_irq(&xtime_lock
);
170 nsec
-= do_gettimeoffset() * NSEC_PER_USEC
+
171 (jiffies
- wall_jiffies
) * NSEC_PER_TICK
;
173 wtm_sec
= wall_to_monotonic
.tv_sec
+ (xtime
.tv_sec
- sec
);
174 wtm_nsec
= wall_to_monotonic
.tv_nsec
+ (xtime
.tv_nsec
- nsec
);
176 set_normalized_timespec(&xtime
, sec
, nsec
);
177 set_normalized_timespec(&wall_to_monotonic
, wtm_sec
, wtm_nsec
);
181 write_sequnlock_irq(&xtime_lock
);
186 EXPORT_SYMBOL(do_settimeofday
);
188 unsigned long profile_pc(struct pt_regs
*regs
)
190 unsigned long pc
= instruction_pointer(regs
);
192 /* Assume the lock function has either no stack frame or only a single
193 word. This checks if the address on the stack looks like a kernel
195 There is a small window for false hits, but in that case the tick
196 is just accounted to the spinlock function.
197 Better would be to write these functions in assembler again
198 and check exactly. */
199 if (!user_mode(regs
) && in_lock_functions(pc
)) {
200 char *v
= *(char **)regs
->rsp
;
201 if ((v
>= _stext
&& v
<= _etext
) ||
202 (v
>= _sinittext
&& v
<= _einittext
) ||
203 (v
>= (char *)MODULES_VADDR
&& v
<= (char *)MODULES_END
))
204 return (unsigned long)v
;
205 return ((unsigned long *)regs
->rsp
)[1];
209 EXPORT_SYMBOL(profile_pc
);
212 * In order to set the CMOS clock precisely, set_rtc_mmss has to be called 500
213 * ms after the second nowtime has started, because when nowtime is written
214 * into the registers of the CMOS clock, it will jump to the next second
215 * precisely 500 ms later. Check the Motorola MC146818A or Dallas DS12887 data
219 static void set_rtc_mmss(unsigned long nowtime
)
221 int real_seconds
, real_minutes
, cmos_minutes
;
222 unsigned char control
, freq_select
;
225 * IRQs are disabled when we're called from the timer interrupt,
226 * no need for spin_lock_irqsave()
229 spin_lock(&rtc_lock
);
232 * Tell the clock it's being set and stop it.
235 control
= CMOS_READ(RTC_CONTROL
);
236 CMOS_WRITE(control
| RTC_SET
, RTC_CONTROL
);
238 freq_select
= CMOS_READ(RTC_FREQ_SELECT
);
239 CMOS_WRITE(freq_select
| RTC_DIV_RESET2
, RTC_FREQ_SELECT
);
241 cmos_minutes
= CMOS_READ(RTC_MINUTES
);
242 BCD_TO_BIN(cmos_minutes
);
245 * since we're only adjusting minutes and seconds, don't interfere with hour
246 * overflow. This avoids messing with unknown time zones but requires your RTC
247 * not to be off by more than 15 minutes. Since we're calling it only when
248 * our clock is externally synchronized using NTP, this shouldn't be a problem.
251 real_seconds
= nowtime
% 60;
252 real_minutes
= nowtime
/ 60;
253 if (((abs(real_minutes
- cmos_minutes
) + 15) / 30) & 1)
254 real_minutes
+= 30; /* correct for half hour time zone */
257 if (abs(real_minutes
- cmos_minutes
) >= 30) {
258 printk(KERN_WARNING
"time.c: can't update CMOS clock "
259 "from %d to %d\n", cmos_minutes
, real_minutes
);
261 BIN_TO_BCD(real_seconds
);
262 BIN_TO_BCD(real_minutes
);
263 CMOS_WRITE(real_seconds
, RTC_SECONDS
);
264 CMOS_WRITE(real_minutes
, RTC_MINUTES
);
268 * The following flags have to be released exactly in this order, otherwise the
269 * DS12887 (popular MC146818A clone with integrated battery and quartz) will
270 * not reset the oscillator and will not update precisely 500 ms later. You
271 * won't find this mentioned in the Dallas Semiconductor data sheets, but who
272 * believes data sheets anyway ... -- Markus Kuhn
275 CMOS_WRITE(control
, RTC_CONTROL
);
276 CMOS_WRITE(freq_select
, RTC_FREQ_SELECT
);
278 spin_unlock(&rtc_lock
);
282 /* monotonic_clock(): returns # of nanoseconds passed since time_init()
283 * Note: This function is required to return accurate
284 * time even in the absence of multiple timer ticks.
286 unsigned long long monotonic_clock(void)
289 u32 last_offset
, this_offset
, offset
;
290 unsigned long long base
;
292 if (vxtime
.mode
== VXTIME_HPET
) {
294 seq
= read_seqbegin(&xtime_lock
);
296 last_offset
= vxtime
.last
;
297 base
= monotonic_base
;
298 this_offset
= hpet_readl(HPET_COUNTER
);
299 } while (read_seqretry(&xtime_lock
, seq
));
300 offset
= (this_offset
- last_offset
);
301 offset
*= NSEC_PER_TICK
/ hpet_tick
;
304 seq
= read_seqbegin(&xtime_lock
);
306 last_offset
= vxtime
.last_tsc
;
307 base
= monotonic_base
;
308 } while (read_seqretry(&xtime_lock
, seq
));
309 this_offset
= get_cycles_sync();
310 /* FIXME: 1000 or 1000000? */
311 offset
= (this_offset
- last_offset
)*1000 / cpu_khz
;
313 return base
+ offset
;
315 EXPORT_SYMBOL(monotonic_clock
);
317 static noinline
void handle_lost_ticks(int lost
, struct pt_regs
*regs
)
319 static long lost_count
;
321 if (report_lost_ticks
) {
322 printk(KERN_WARNING
"time.c: Lost %d timer tick(s)! ", lost
);
323 print_symbol("rip %s)\n", regs
->rip
);
326 if (lost_count
== 1000 && !warned
) {
327 printk(KERN_WARNING
"warning: many lost ticks.\n"
328 KERN_WARNING
"Your time source seems to be instable or "
329 "some driver is hogging interupts\n");
330 print_symbol("rip %s\n", regs
->rip
);
331 if (vxtime
.mode
== VXTIME_TSC
&& vxtime
.hpet_address
) {
332 printk(KERN_WARNING
"Falling back to HPET\n");
334 vxtime
.last
= hpet_readl(HPET_T0_CMP
) -
337 vxtime
.last
= hpet_readl(HPET_COUNTER
);
338 vxtime
.mode
= VXTIME_HPET
;
339 do_gettimeoffset
= do_gettimeoffset_hpet
;
341 /* else should fall back to PIT, but code missing. */
346 #ifdef CONFIG_CPU_FREQ
347 /* In some cases the CPU can change frequency without us noticing
348 Give cpufreq a change to catch up. */
349 if ((lost_count
+1) % 25 == 0)
350 cpufreq_delayed_get();
354 void main_timer_handler(struct pt_regs
*regs
)
356 static unsigned long rtc_update
= 0;
358 int delay
= 0, offset
= 0, lost
= 0;
361 * Here we are in the timer irq handler. We have irqs locally disabled (so we
362 * don't need spin_lock_irqsave()) but we don't know if the timer_bh is running
363 * on the other CPU, so we need a lock. We also need to lock the vsyscall
364 * variables, because both do_timer() and us change them -arca+vojtech
367 write_seqlock(&xtime_lock
);
369 if (vxtime
.hpet_address
)
370 offset
= hpet_readl(HPET_COUNTER
);
372 if (hpet_use_timer
) {
373 /* if we're using the hpet timer functionality,
374 * we can more accurately know the counter value
375 * when the timer interrupt occured.
377 offset
= hpet_readl(HPET_T0_CMP
) - hpet_tick
;
378 delay
= hpet_readl(HPET_COUNTER
) - offset
;
379 } else if (!pmtmr_ioport
) {
380 spin_lock(&i8253_lock
);
383 delay
|= inb(0x40) << 8;
384 spin_unlock(&i8253_lock
);
385 delay
= LATCH
- 1 - delay
;
388 tsc
= get_cycles_sync();
390 if (vxtime
.mode
== VXTIME_HPET
) {
391 if (offset
- vxtime
.last
> hpet_tick
) {
392 lost
= (offset
- vxtime
.last
) / hpet_tick
- 1;
396 (offset
- vxtime
.last
) * NSEC_PER_TICK
/ hpet_tick
;
398 vxtime
.last
= offset
;
399 #ifdef CONFIG_X86_PM_TIMER
400 } else if (vxtime
.mode
== VXTIME_PMTMR
) {
401 lost
= pmtimer_mark_offset();
404 offset
= (((tsc
- vxtime
.last_tsc
) *
405 vxtime
.tsc_quot
) >> US_SCALE
) - USEC_PER_TICK
;
410 if (offset
> USEC_PER_TICK
) {
411 lost
= offset
/ USEC_PER_TICK
;
412 offset
%= USEC_PER_TICK
;
415 /* FIXME: 1000 or 1000000? */
416 monotonic_base
+= (tsc
- vxtime
.last_tsc
) * 1000000 / cpu_khz
;
418 vxtime
.last_tsc
= tsc
- vxtime
.quot
* delay
/ vxtime
.tsc_quot
;
420 if ((((tsc
- vxtime
.last_tsc
) *
421 vxtime
.tsc_quot
) >> US_SCALE
) < offset
)
422 vxtime
.last_tsc
= tsc
-
423 (((long) offset
<< US_SCALE
) / vxtime
.tsc_quot
) - 1;
427 handle_lost_ticks(lost
, regs
);
432 * Do the timer stuff.
437 update_process_times(user_mode(regs
));
441 * In the SMP case we use the local APIC timer interrupt to do the profiling,
442 * except when we simulate SMP mode on a uniprocessor system, in that case we
443 * have to call the local interrupt handler.
446 #ifndef CONFIG_X86_LOCAL_APIC
447 profile_tick(CPU_PROFILING
, regs
);
449 if (!using_apic_timer
)
450 smp_local_timer_interrupt(regs
);
454 * If we have an externally synchronized Linux clock, then update CMOS clock
455 * accordingly every ~11 minutes. set_rtc_mmss() will be called in the jiffy
456 * closest to exactly 500 ms before the next second. If the update fails, we
457 * don't care, as it'll be updated on the next turn, and the problem (time way
458 * off) isn't likely to go away much sooner anyway.
461 if (ntp_synced() && xtime
.tv_sec
> rtc_update
&&
462 abs(xtime
.tv_nsec
- 500000000) <= tick_nsec
/ 2) {
463 set_rtc_mmss(xtime
.tv_sec
);
464 rtc_update
= xtime
.tv_sec
+ 660;
467 write_sequnlock(&xtime_lock
);
470 static irqreturn_t
timer_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
472 if (apic_runs_main_timer
> 1)
474 main_timer_handler(regs
);
475 #ifdef CONFIG_X86_LOCAL_APIC
476 if (using_apic_timer
)
477 smp_send_timer_broadcast_ipi();
482 static unsigned int cyc2ns_scale __read_mostly
;
484 static inline void set_cyc2ns_scale(unsigned long cpu_khz
)
486 cyc2ns_scale
= (NSEC_PER_MSEC
<< NS_SCALE
) / cpu_khz
;
489 static inline unsigned long long cycles_2_ns(unsigned long long cyc
)
491 return (cyc
* cyc2ns_scale
) >> NS_SCALE
;
494 unsigned long long sched_clock(void)
499 /* Don't do a HPET read here. Using TSC always is much faster
500 and HPET may not be mapped yet when the scheduler first runs.
501 Disadvantage is a small drift between CPUs in some configurations,
502 but that should be tolerable. */
503 if (__vxtime
.mode
== VXTIME_HPET
)
504 return (hpet_readl(HPET_COUNTER
) * vxtime
.quot
) >> US_SCALE
;
507 /* Could do CPU core sync here. Opteron can execute rdtsc speculatively,
508 which means it is not completely exact and may not be monotonous between
509 CPUs. But the errors should be too small to matter for scheduling
513 return cycles_2_ns(a
);
516 static unsigned long get_cmos_time(void)
518 unsigned int year
, mon
, day
, hour
, min
, sec
;
520 unsigned extyear
= 0;
522 spin_lock_irqsave(&rtc_lock
, flags
);
525 sec
= CMOS_READ(RTC_SECONDS
);
526 min
= CMOS_READ(RTC_MINUTES
);
527 hour
= CMOS_READ(RTC_HOURS
);
528 day
= CMOS_READ(RTC_DAY_OF_MONTH
);
529 mon
= CMOS_READ(RTC_MONTH
);
530 year
= CMOS_READ(RTC_YEAR
);
532 if (acpi_fadt
.revision
>= FADT2_REVISION_ID
&&
534 extyear
= CMOS_READ(acpi_fadt
.century
);
536 } while (sec
!= CMOS_READ(RTC_SECONDS
));
538 spin_unlock_irqrestore(&rtc_lock
, flags
);
541 * We know that x86-64 always uses BCD format, no need to check the
555 printk(KERN_INFO
"Extended CMOS year: %d\n", extyear
);
558 * x86-64 systems only exists since 2002.
559 * This will work up to Dec 31, 2100
564 return mktime(year
, mon
, day
, hour
, min
, sec
);
567 #ifdef CONFIG_CPU_FREQ
569 /* Frequency scaling support. Adjust the TSC based timer when the cpu frequency
572 RED-PEN: On SMP we assume all CPUs run with the same frequency. It's
573 not that important because current Opteron setups do not support
574 scaling on SMP anyroads.
576 Should fix up last_tsc too. Currently gettimeofday in the
577 first tick after the change will be slightly wrong. */
579 #include <linux/workqueue.h>
581 static unsigned int cpufreq_delayed_issched
= 0;
582 static unsigned int cpufreq_init
= 0;
583 static struct work_struct cpufreq_delayed_get_work
;
585 static void handle_cpufreq_delayed_get(void *v
)
588 for_each_online_cpu(cpu
) {
591 cpufreq_delayed_issched
= 0;
594 /* if we notice lost ticks, schedule a call to cpufreq_get() as it tries
595 * to verify the CPU frequency the timing core thinks the CPU is running
596 * at is still correct.
598 static void cpufreq_delayed_get(void)
601 if (cpufreq_init
&& !cpufreq_delayed_issched
) {
602 cpufreq_delayed_issched
= 1;
606 "Losing some ticks... checking if CPU frequency changed.\n");
608 schedule_work(&cpufreq_delayed_get_work
);
612 static unsigned int ref_freq
= 0;
613 static unsigned long loops_per_jiffy_ref
= 0;
615 static unsigned long cpu_khz_ref
= 0;
617 static int time_cpufreq_notifier(struct notifier_block
*nb
, unsigned long val
,
620 struct cpufreq_freqs
*freq
= data
;
621 unsigned long *lpj
, dummy
;
623 if (cpu_has(&cpu_data
[freq
->cpu
], X86_FEATURE_CONSTANT_TSC
))
627 if (!(freq
->flags
& CPUFREQ_CONST_LOOPS
))
629 lpj
= &cpu_data
[freq
->cpu
].loops_per_jiffy
;
631 lpj
= &boot_cpu_data
.loops_per_jiffy
;
635 ref_freq
= freq
->old
;
636 loops_per_jiffy_ref
= *lpj
;
637 cpu_khz_ref
= cpu_khz
;
639 if ((val
== CPUFREQ_PRECHANGE
&& freq
->old
< freq
->new) ||
640 (val
== CPUFREQ_POSTCHANGE
&& freq
->old
> freq
->new) ||
641 (val
== CPUFREQ_RESUMECHANGE
)) {
643 cpufreq_scale(loops_per_jiffy_ref
, ref_freq
, freq
->new);
645 cpu_khz
= cpufreq_scale(cpu_khz_ref
, ref_freq
, freq
->new);
646 if (!(freq
->flags
& CPUFREQ_CONST_LOOPS
))
647 vxtime
.tsc_quot
= (USEC_PER_MSEC
<< US_SCALE
) / cpu_khz
;
650 set_cyc2ns_scale(cpu_khz_ref
);
655 static struct notifier_block time_cpufreq_notifier_block
= {
656 .notifier_call
= time_cpufreq_notifier
659 static int __init
cpufreq_tsc(void)
661 INIT_WORK(&cpufreq_delayed_get_work
, handle_cpufreq_delayed_get
, NULL
);
662 if (!cpufreq_register_notifier(&time_cpufreq_notifier_block
,
663 CPUFREQ_TRANSITION_NOTIFIER
))
668 core_initcall(cpufreq_tsc
);
673 * calibrate_tsc() calibrates the processor TSC in a very simple way, comparing
674 * it to the HPET timer of known frequency.
677 #define TICK_COUNT 100000000
679 static unsigned int __init
hpet_calibrate_tsc(void)
681 int tsc_start
, hpet_start
;
682 int tsc_now
, hpet_now
;
685 local_irq_save(flags
);
688 hpet_start
= hpet_readl(HPET_COUNTER
);
693 hpet_now
= hpet_readl(HPET_COUNTER
);
694 tsc_now
= get_cycles_sync();
695 local_irq_restore(flags
);
696 } while ((tsc_now
- tsc_start
) < TICK_COUNT
&&
697 (hpet_now
- hpet_start
) < TICK_COUNT
);
699 return (tsc_now
- tsc_start
) * 1000000000L
700 / ((hpet_now
- hpet_start
) * hpet_period
/ 1000);
705 * pit_calibrate_tsc() uses the speaker output (channel 2) of
706 * the PIT. This is better than using the timer interrupt output,
707 * because we can read the value of the speaker with just one inb(),
708 * where we need three i/o operations for the interrupt channel.
709 * We count how many ticks the TSC does in 50 ms.
712 static unsigned int __init
pit_calibrate_tsc(void)
714 unsigned long start
, end
;
717 spin_lock_irqsave(&i8253_lock
, flags
);
719 outb((inb(0x61) & ~0x02) | 0x01, 0x61);
722 outb((PIT_TICK_RATE
/ (1000 / 50)) & 0xff, 0x42);
723 outb((PIT_TICK_RATE
/ (1000 / 50)) >> 8, 0x42);
724 start
= get_cycles_sync();
725 while ((inb(0x61) & 0x20) == 0);
726 end
= get_cycles_sync();
728 spin_unlock_irqrestore(&i8253_lock
, flags
);
730 return (end
- start
) / 50;
734 static __init
int late_hpet_init(void)
739 if (!vxtime
.hpet_address
)
742 memset(&hd
, 0, sizeof (hd
));
744 ntimer
= hpet_readl(HPET_ID
);
745 ntimer
= (ntimer
& HPET_ID_NUMBER
) >> HPET_ID_NUMBER_SHIFT
;
749 * Register with driver.
750 * Timer0 and Timer1 is used by platform.
752 hd
.hd_phys_address
= vxtime
.hpet_address
;
753 hd
.hd_address
= (void __iomem
*)fix_to_virt(FIX_HPET_BASE
);
754 hd
.hd_nirqs
= ntimer
;
755 hd
.hd_flags
= HPET_DATA_PLATFORM
;
756 hpet_reserve_timer(&hd
, 0);
757 #ifdef CONFIG_HPET_EMULATE_RTC
758 hpet_reserve_timer(&hd
, 1);
760 hd
.hd_irq
[0] = HPET_LEGACY_8254
;
761 hd
.hd_irq
[1] = HPET_LEGACY_RTC
;
764 struct hpet_timer
*timer
;
767 hpet
= (struct hpet
*) fix_to_virt(FIX_HPET_BASE
);
768 timer
= &hpet
->hpet_timers
[2];
769 for (i
= 2; i
< ntimer
; timer
++, i
++)
770 hd
.hd_irq
[i
] = (timer
->hpet_config
&
771 Tn_INT_ROUTE_CNF_MASK
) >>
772 Tn_INT_ROUTE_CNF_SHIFT
;
779 fs_initcall(late_hpet_init
);
782 static int hpet_timer_stop_set_go(unsigned long tick
)
787 * Stop the timers and reset the main counter.
790 cfg
= hpet_readl(HPET_CFG
);
791 cfg
&= ~(HPET_CFG_ENABLE
| HPET_CFG_LEGACY
);
792 hpet_writel(cfg
, HPET_CFG
);
793 hpet_writel(0, HPET_COUNTER
);
794 hpet_writel(0, HPET_COUNTER
+ 4);
797 * Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
798 * and period also hpet_tick.
800 if (hpet_use_timer
) {
801 hpet_writel(HPET_TN_ENABLE
| HPET_TN_PERIODIC
| HPET_TN_SETVAL
|
802 HPET_TN_32BIT
, HPET_T0_CFG
);
803 hpet_writel(hpet_tick
, HPET_T0_CMP
); /* next interrupt */
804 hpet_writel(hpet_tick
, HPET_T0_CMP
); /* period */
805 cfg
|= HPET_CFG_LEGACY
;
811 cfg
|= HPET_CFG_ENABLE
;
812 hpet_writel(cfg
, HPET_CFG
);
817 static int hpet_init(void)
821 if (!vxtime
.hpet_address
)
823 set_fixmap_nocache(FIX_HPET_BASE
, vxtime
.hpet_address
);
824 __set_fixmap(VSYSCALL_HPET
, vxtime
.hpet_address
, PAGE_KERNEL_VSYSCALL_NOCACHE
);
827 * Read the period, compute tick and quotient.
830 id
= hpet_readl(HPET_ID
);
832 if (!(id
& HPET_ID_VENDOR
) || !(id
& HPET_ID_NUMBER
))
835 hpet_period
= hpet_readl(HPET_PERIOD
);
836 if (hpet_period
< 100000 || hpet_period
> 100000000)
839 hpet_tick
= (FSEC_PER_TICK
+ hpet_period
/ 2) / hpet_period
;
841 hpet_use_timer
= (id
& HPET_ID_LEGSUP
);
843 return hpet_timer_stop_set_go(hpet_tick
);
846 static int hpet_reenable(void)
848 return hpet_timer_stop_set_go(hpet_tick
);
851 #define PIT_MODE 0x43
854 static void __init
__pit_init(int val
, u8 mode
)
858 spin_lock_irqsave(&i8253_lock
, flags
);
859 outb_p(mode
, PIT_MODE
);
860 outb_p(val
& 0xff, PIT_CH0
); /* LSB */
861 outb_p(val
>> 8, PIT_CH0
); /* MSB */
862 spin_unlock_irqrestore(&i8253_lock
, flags
);
865 void __init
pit_init(void)
867 __pit_init(LATCH
, 0x34); /* binary, mode 2, LSB/MSB, ch 0 */
870 void __init
pit_stop_interrupt(void)
872 __pit_init(0, 0x30); /* mode 0 */
875 void __init
stop_timer_interrupt(void)
878 if (vxtime
.hpet_address
) {
880 hpet_timer_stop_set_go(0);
883 pit_stop_interrupt();
885 printk(KERN_INFO
"timer: %s interrupt stopped.\n", name
);
888 int __init
time_setup(char *str
)
890 report_lost_ticks
= 1;
894 static struct irqaction irq0
= {
895 timer_interrupt
, IRQF_DISABLED
, CPU_MASK_NONE
, "timer", NULL
, NULL
899 time_cpu_notifier(struct notifier_block
*nb
, unsigned long action
, void *hcpu
)
901 unsigned cpu
= (unsigned long) hcpu
;
902 if (action
== CPU_ONLINE
&&
903 cpu_has(&cpu_data
[cpu
], X86_FEATURE_RDTSCP
)) {
905 p
= smp_processor_id() | (cpu_to_node(smp_processor_id())<<12);
911 void __init
time_init(void)
914 vxtime
.hpet_address
= 0;
916 xtime
.tv_sec
= get_cmos_time();
919 set_normalized_timespec(&wall_to_monotonic
,
920 -xtime
.tv_sec
, -xtime
.tv_nsec
);
923 vxtime_hz
= (FSEC_PER_SEC
+ hpet_period
/ 2) / hpet_period
;
925 vxtime
.hpet_address
= 0;
927 if (hpet_use_timer
) {
928 /* set tick_nsec to use the proper rate for HPET */
929 tick_nsec
= TICK_NSEC_HPET
;
930 cpu_khz
= hpet_calibrate_tsc();
932 #ifdef CONFIG_X86_PM_TIMER
933 } else if (pmtmr_ioport
&& !vxtime
.hpet_address
) {
934 vxtime_hz
= PM_TIMER_FREQUENCY
;
937 cpu_khz
= pit_calibrate_tsc();
941 cpu_khz
= pit_calibrate_tsc();
945 vxtime
.mode
= VXTIME_TSC
;
946 vxtime
.quot
= (USEC_PER_SEC
<< US_SCALE
) / vxtime_hz
;
947 vxtime
.tsc_quot
= (USEC_PER_MSEC
<< US_SCALE
) / cpu_khz
;
948 vxtime
.last_tsc
= get_cycles_sync();
951 set_cyc2ns_scale(cpu_khz
);
953 hotcpu_notifier(time_cpu_notifier
, 0);
954 time_cpu_notifier(NULL
, CPU_ONLINE
, (void *)(long)smp_processor_id());
962 * Make an educated guess if the TSC is trustworthy and synchronized
965 __cpuinit
int unsynchronized_tsc(void)
968 if (apic_is_clustered_box())
971 /* Most intel systems have synchronized TSCs except for
972 multi node systems */
973 if (boot_cpu_data
.x86_vendor
== X86_VENDOR_INTEL
) {
975 /* But TSC doesn't tick in C3 so don't use it there */
976 if (acpi_fadt
.length
> 0 && acpi_fadt
.plvl3_lat
< 100)
982 /* Assume multi socket systems are not synchronized */
983 return num_present_cpus() > 1;
987 * Decide what mode gettimeofday should use.
989 void time_init_gtod(void)
993 if (unsynchronized_tsc())
996 if (vxtime
.hpet_address
&& notsc
) {
997 timetype
= hpet_use_timer
? "HPET" : "PIT/HPET";
999 vxtime
.last
= hpet_readl(HPET_T0_CMP
) - hpet_tick
;
1001 vxtime
.last
= hpet_readl(HPET_COUNTER
);
1002 vxtime
.mode
= VXTIME_HPET
;
1003 do_gettimeoffset
= do_gettimeoffset_hpet
;
1004 #ifdef CONFIG_X86_PM_TIMER
1005 /* Using PM for gettimeofday is quite slow, but we have no other
1006 choice because the TSC is too unreliable on some systems. */
1007 } else if (pmtmr_ioport
&& !vxtime
.hpet_address
&& notsc
) {
1009 do_gettimeoffset
= do_gettimeoffset_pm
;
1010 vxtime
.mode
= VXTIME_PMTMR
;
1011 sysctl_vsyscall
= 0;
1012 printk(KERN_INFO
"Disabling vsyscall due to use of PM timer\n");
1015 timetype
= hpet_use_timer
? "HPET/TSC" : "PIT/TSC";
1016 vxtime
.mode
= VXTIME_TSC
;
1019 printk(KERN_INFO
"time.c: Using %ld.%06ld MHz WALL %s GTOD %s timer.\n",
1020 vxtime_hz
/ 1000000, vxtime_hz
% 1000000, timename
, timetype
);
1021 printk(KERN_INFO
"time.c: Detected %d.%03d MHz processor.\n",
1022 cpu_khz
/ 1000, cpu_khz
% 1000);
1023 vxtime
.quot
= (USEC_PER_SEC
<< US_SCALE
) / vxtime_hz
;
1024 vxtime
.tsc_quot
= (USEC_PER_MSEC
<< US_SCALE
) / cpu_khz
;
1025 vxtime
.last_tsc
= get_cycles_sync();
1027 set_cyc2ns_scale(cpu_khz
);
1030 __setup("report_lost_ticks", time_setup
);
1032 static long clock_cmos_diff
;
1033 static unsigned long sleep_start
;
1036 * sysfs support for the timer.
1039 static int timer_suspend(struct sys_device
*dev
, pm_message_t state
)
1042 * Estimate time zone so that set_time can update the clock
1044 long cmos_time
= get_cmos_time();
1046 clock_cmos_diff
= -cmos_time
;
1047 clock_cmos_diff
+= get_seconds();
1048 sleep_start
= cmos_time
;
1052 static int timer_resume(struct sys_device
*dev
)
1054 unsigned long flags
;
1056 unsigned long ctime
= get_cmos_time();
1057 unsigned long sleep_length
= (ctime
- sleep_start
) * HZ
;
1059 if (vxtime
.hpet_address
)
1062 i8254_timer_resume();
1064 sec
= ctime
+ clock_cmos_diff
;
1065 write_seqlock_irqsave(&xtime_lock
,flags
);
1068 if (vxtime
.mode
== VXTIME_HPET
) {
1070 vxtime
.last
= hpet_readl(HPET_T0_CMP
) - hpet_tick
;
1072 vxtime
.last
= hpet_readl(HPET_COUNTER
);
1073 #ifdef CONFIG_X86_PM_TIMER
1074 } else if (vxtime
.mode
== VXTIME_PMTMR
) {
1078 vxtime
.last_tsc
= get_cycles_sync();
1079 write_sequnlock_irqrestore(&xtime_lock
,flags
);
1080 jiffies
+= sleep_length
;
1081 wall_jiffies
+= sleep_length
;
1082 monotonic_base
+= sleep_length
* (NSEC_PER_SEC
/HZ
);
1083 touch_softlockup_watchdog();
1087 static struct sysdev_class timer_sysclass
= {
1088 .resume
= timer_resume
,
1089 .suspend
= timer_suspend
,
1090 set_kset_name("timer"),
1093 /* XXX this driverfs stuff should probably go elsewhere later -john */
1094 static struct sys_device device_timer
= {
1096 .cls
= &timer_sysclass
,
1099 static int time_init_device(void)
1101 int error
= sysdev_class_register(&timer_sysclass
);
1103 error
= sysdev_register(&device_timer
);
1107 device_initcall(time_init_device
);
1109 #ifdef CONFIG_HPET_EMULATE_RTC
1110 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
1111 * is enabled, we support RTC interrupt functionality in software.
1112 * RTC has 3 kinds of interrupts:
1113 * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
1115 * 2) Alarm Interrupt - generate an interrupt at a specific time of day
1116 * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
1117 * 2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
1118 * (1) and (2) above are implemented using polling at a frequency of
1119 * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
1120 * overhead. (DEFAULT_RTC_INT_FREQ)
1121 * For (3), we use interrupts at 64Hz or user specified periodic
1122 * frequency, whichever is higher.
1124 #include <linux/rtc.h>
1126 #define DEFAULT_RTC_INT_FREQ 64
1127 #define RTC_NUM_INTS 1
1129 static unsigned long UIE_on
;
1130 static unsigned long prev_update_sec
;
1132 static unsigned long AIE_on
;
1133 static struct rtc_time alarm_time
;
1135 static unsigned long PIE_on
;
1136 static unsigned long PIE_freq
= DEFAULT_RTC_INT_FREQ
;
1137 static unsigned long PIE_count
;
1139 static unsigned long hpet_rtc_int_freq
; /* RTC interrupt frequency */
1140 static unsigned int hpet_t1_cmp
; /* cached comparator register */
1142 int is_hpet_enabled(void)
1144 return vxtime
.hpet_address
!= 0;
1148 * Timer 1 for RTC, we do not use periodic interrupt feature,
1149 * even if HPET supports periodic interrupts on Timer 1.
1150 * The reason being, to set up a periodic interrupt in HPET, we need to
1151 * stop the main counter. And if we do that everytime someone diables/enables
1152 * RTC, we will have adverse effect on main kernel timer running on Timer 0.
1153 * So, for the time being, simulate the periodic interrupt in software.
1155 * hpet_rtc_timer_init() is called for the first time and during subsequent
1156 * interuppts reinit happens through hpet_rtc_timer_reinit().
1158 int hpet_rtc_timer_init(void)
1160 unsigned int cfg
, cnt
;
1161 unsigned long flags
;
1163 if (!is_hpet_enabled())
1166 * Set the counter 1 and enable the interrupts.
1168 if (PIE_on
&& (PIE_freq
> DEFAULT_RTC_INT_FREQ
))
1169 hpet_rtc_int_freq
= PIE_freq
;
1171 hpet_rtc_int_freq
= DEFAULT_RTC_INT_FREQ
;
1173 local_irq_save(flags
);
1174 cnt
= hpet_readl(HPET_COUNTER
);
1175 cnt
+= ((hpet_tick
*HZ
)/hpet_rtc_int_freq
);
1176 hpet_writel(cnt
, HPET_T1_CMP
);
1178 local_irq_restore(flags
);
1180 cfg
= hpet_readl(HPET_T1_CFG
);
1181 cfg
&= ~HPET_TN_PERIODIC
;
1182 cfg
|= HPET_TN_ENABLE
| HPET_TN_32BIT
;
1183 hpet_writel(cfg
, HPET_T1_CFG
);
1188 static void hpet_rtc_timer_reinit(void)
1190 unsigned int cfg
, cnt
;
1192 if (unlikely(!(PIE_on
| AIE_on
| UIE_on
))) {
1193 cfg
= hpet_readl(HPET_T1_CFG
);
1194 cfg
&= ~HPET_TN_ENABLE
;
1195 hpet_writel(cfg
, HPET_T1_CFG
);
1199 if (PIE_on
&& (PIE_freq
> DEFAULT_RTC_INT_FREQ
))
1200 hpet_rtc_int_freq
= PIE_freq
;
1202 hpet_rtc_int_freq
= DEFAULT_RTC_INT_FREQ
;
1204 /* It is more accurate to use the comparator value than current count.*/
1206 cnt
+= hpet_tick
*HZ
/hpet_rtc_int_freq
;
1207 hpet_writel(cnt
, HPET_T1_CMP
);
1212 * The functions below are called from rtc driver.
1213 * Return 0 if HPET is not being used.
1214 * Otherwise do the necessary changes and return 1.
1216 int hpet_mask_rtc_irq_bit(unsigned long bit_mask
)
1218 if (!is_hpet_enabled())
1221 if (bit_mask
& RTC_UIE
)
1223 if (bit_mask
& RTC_PIE
)
1225 if (bit_mask
& RTC_AIE
)
1231 int hpet_set_rtc_irq_bit(unsigned long bit_mask
)
1233 int timer_init_reqd
= 0;
1235 if (!is_hpet_enabled())
1238 if (!(PIE_on
| AIE_on
| UIE_on
))
1239 timer_init_reqd
= 1;
1241 if (bit_mask
& RTC_UIE
) {
1244 if (bit_mask
& RTC_PIE
) {
1248 if (bit_mask
& RTC_AIE
) {
1252 if (timer_init_reqd
)
1253 hpet_rtc_timer_init();
1258 int hpet_set_alarm_time(unsigned char hrs
, unsigned char min
, unsigned char sec
)
1260 if (!is_hpet_enabled())
1263 alarm_time
.tm_hour
= hrs
;
1264 alarm_time
.tm_min
= min
;
1265 alarm_time
.tm_sec
= sec
;
1270 int hpet_set_periodic_freq(unsigned long freq
)
1272 if (!is_hpet_enabled())
1281 int hpet_rtc_dropped_irq(void)
1283 if (!is_hpet_enabled())
1289 irqreturn_t
hpet_rtc_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
1291 struct rtc_time curr_time
;
1292 unsigned long rtc_int_flag
= 0;
1293 int call_rtc_interrupt
= 0;
1295 hpet_rtc_timer_reinit();
1297 if (UIE_on
| AIE_on
) {
1298 rtc_get_rtc_time(&curr_time
);
1301 if (curr_time
.tm_sec
!= prev_update_sec
) {
1302 /* Set update int info, call real rtc int routine */
1303 call_rtc_interrupt
= 1;
1304 rtc_int_flag
= RTC_UF
;
1305 prev_update_sec
= curr_time
.tm_sec
;
1310 if (PIE_count
>= hpet_rtc_int_freq
/PIE_freq
) {
1311 /* Set periodic int info, call real rtc int routine */
1312 call_rtc_interrupt
= 1;
1313 rtc_int_flag
|= RTC_PF
;
1318 if ((curr_time
.tm_sec
== alarm_time
.tm_sec
) &&
1319 (curr_time
.tm_min
== alarm_time
.tm_min
) &&
1320 (curr_time
.tm_hour
== alarm_time
.tm_hour
)) {
1321 /* Set alarm int info, call real rtc int routine */
1322 call_rtc_interrupt
= 1;
1323 rtc_int_flag
|= RTC_AF
;
1326 if (call_rtc_interrupt
) {
1327 rtc_int_flag
|= (RTC_IRQF
| (RTC_NUM_INTS
<< 8));
1328 rtc_interrupt(rtc_int_flag
, dev_id
, regs
);
1334 static int __init
nohpet_setup(char *s
)
1340 __setup("nohpet", nohpet_setup
);
1342 int __init
notsc_setup(char *s
)
1348 __setup("notsc", notsc_setup
);