2 * linux/arch/i386/kernel/time.c
4 * Copyright (C) 1991, 1992, 1995 Linus Torvalds
6 * This file contains the PC-specific time handling details:
7 * reading the RTC at bootup, etc..
8 * 1994-07-02 Alan Modra
9 * fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
10 * 1995-03-26 Markus Kuhn
11 * fixed 500 ms bug at call to set_rtc_mmss, fixed DS12887
12 * precision CMOS clock update
13 * 1996-05-03 Ingo Molnar
14 * fixed time warps in do_[slow|fast]_gettimeoffset()
15 * 1997-09-10 Updated NTP code according to technical memorandum Jan '96
16 * "A Kernel Model for Precision Timekeeping" by Dave Mills
17 * 1998-09-05 (Various)
18 * More robust do_fast_gettimeoffset() algorithm implemented
19 * (works with APM, Cyrix 6x86MX and Centaur C6),
20 * monotonic gettimeofday() with fast_get_timeoffset(),
21 * drift-proof precision TSC calibration on boot
22 * (C. Scott Ananian <cananian@alumni.princeton.edu>, Andrew D.
23 * Balsa <andrebalsa@altern.org>, Philip Gladstone <philip@raptor.com>;
24 * ported from 2.0.35 Jumbo-9 by Michael Krause <m.krause@tu-harburg.de>).
25 * 1998-12-16 Andrea Arcangeli
26 * Fixed Jumbo-9 code in 2.1.131: do_gettimeofday was missing 1 jiffy
27 * because was not accounting lost_ticks.
28 * 1998-12-24 Copyright (C) 1998 Andrea Arcangeli
29 * Fixed a xtime SMP race (we need the xtime_lock rw spinlock to
30 * serialize accesses to xtime/lost_ticks).
33 #include <linux/errno.h>
34 #include <linux/sched.h>
35 #include <linux/kernel.h>
36 #include <linux/param.h>
37 #include <linux/string.h>
39 #include <linux/interrupt.h>
40 #include <linux/time.h>
41 #include <linux/delay.h>
42 #include <linux/init.h>
43 #include <linux/smp.h>
44 #include <linux/module.h>
45 #include <linux/sysdev.h>
46 #include <linux/bcd.h>
47 #include <linux/efi.h>
48 #include <linux/mca.h>
54 #include <asm/delay.h>
55 #include <asm/mpspec.h>
56 #include <asm/uaccess.h>
57 #include <asm/processor.h>
58 #include <asm/timer.h>
60 #include "mach_time.h"
62 #include <linux/timex.h>
66 #include <asm/arch_hooks.h>
70 #include <asm/i8259.h>
72 int pit_latch_buggy
; /* extern */
76 unsigned int cpu_khz
; /* Detected as we calibrate the TSC */
77 EXPORT_SYMBOL(cpu_khz
);
79 extern unsigned long wall_jiffies
;
81 DEFINE_SPINLOCK(rtc_lock
);
82 EXPORT_SYMBOL(rtc_lock
);
85 * This is a special lock that is owned by the CPU and holds the index
86 * register we are working with. It is required for NMI access to the
87 * CMOS/RTC registers. See include/asm-i386/mc146818rtc.h for details.
89 volatile unsigned long cmos_lock
= 0;
90 EXPORT_SYMBOL(cmos_lock
);
92 /* Routines for accessing the CMOS RAM/RTC. */
93 unsigned char rtc_cmos_read(unsigned char addr
)
96 lock_cmos_prefix(addr
);
97 outb_p(addr
, RTC_PORT(0));
98 val
= inb_p(RTC_PORT(1));
99 lock_cmos_suffix(addr
);
102 EXPORT_SYMBOL(rtc_cmos_read
);
104 void rtc_cmos_write(unsigned char val
, unsigned char addr
)
106 lock_cmos_prefix(addr
);
107 outb_p(addr
, RTC_PORT(0));
108 outb_p(val
, RTC_PORT(1));
109 lock_cmos_suffix(addr
);
111 EXPORT_SYMBOL(rtc_cmos_write
);
113 static int set_rtc_mmss(unsigned long nowtime
)
118 /* gets recalled with irq locally disabled */
119 /* XXX - does irqsave resolve this? -johnstul */
120 spin_lock_irqsave(&rtc_lock
, flags
);
122 retval
= efi_set_rtc_mmss(nowtime
);
124 retval
= mach_set_rtc_mmss(nowtime
);
125 spin_unlock_irqrestore(&rtc_lock
, flags
);
133 #if defined(CONFIG_SMP) && defined(CONFIG_FRAME_POINTER)
134 unsigned long profile_pc(struct pt_regs
*regs
)
136 unsigned long pc
= instruction_pointer(regs
);
138 if (in_lock_functions(pc
))
139 return *(unsigned long *)(regs
->ebp
+ 4);
143 EXPORT_SYMBOL(profile_pc
);
147 * This is the same as the above, except we _also_ save the current
148 * Time Stamp Counter value at the time of the timer interrupt, so that
149 * we later on can estimate the time of day more exactly.
151 irqreturn_t
timer_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
154 * Here we are in the timer irq handler. We just have irqs locally
155 * disabled but we don't know if the timer_bh is running on the other
156 * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
157 * the irq version of write_lock because as just said we have irq
158 * locally disabled. -arca
160 write_seqlock(&xtime_lock
);
162 #ifdef CONFIG_X86_IO_APIC
165 * Subtle, when I/O APICs are used we have to ack timer IRQ
166 * manually to reset the IRR bit for do_slow_gettimeoffset().
167 * This will also deassert NMI lines for the watchdog if run
168 * on an 82489DX-based system.
170 spin_lock(&i8259A_lock
);
171 outb(0x0c, PIC_MASTER_OCW3
);
172 /* Ack the IRQ; AEOI will end it automatically. */
173 inb(PIC_MASTER_POLL
);
174 spin_unlock(&i8259A_lock
);
178 do_timer_interrupt_hook(regs
);
182 /* The PS/2 uses level-triggered interrupts. You can't
183 turn them off, nor would you want to (any attempt to
184 enable edge-triggered interrupts usually gets intercepted by a
185 special hardware circuit). Hence we have to acknowledge
186 the timer interrupt. Through some incredibly stupid
187 design idea, the reset for IRQ 0 is done by setting the
188 high bit of the PPI port B (0x61). Note that some PS/2s,
189 notably the 55SX, work fine if this is removed. */
191 irq
= inb_p( 0x61 ); /* read the current state */
192 outb_p( irq
|0x80, 0x61 ); /* reset the IRQ */
195 write_sequnlock(&xtime_lock
);
197 #ifdef CONFIG_X86_LOCAL_APIC
198 if (using_apic_timer
)
199 smp_send_timer_broadcast_ipi(regs
);
205 /* not static: needed by APM */
206 unsigned long get_cmos_time(void)
208 unsigned long retval
;
210 spin_lock(&rtc_lock
);
213 retval
= efi_get_time();
215 retval
= mach_get_cmos_time();
217 spin_unlock(&rtc_lock
);
221 EXPORT_SYMBOL(get_cmos_time
);
223 static void sync_cmos_clock(unsigned long dummy
);
225 static DEFINE_TIMER(sync_cmos_timer
, sync_cmos_clock
, 0, 0);
227 static void sync_cmos_clock(unsigned long dummy
)
229 struct timeval now
, next
;
233 * If we have an externally synchronized Linux clock, then update
234 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
235 * called as close as possible to 500 ms before the new second starts.
236 * This code is run on a timer. If the clock is set, that timer
237 * may not expire at the correct time. Thus, we adjust...
241 * Not synced, exit, do not restart a timer (if one is
242 * running, let it run out).
246 do_gettimeofday(&now
);
247 if (now
.tv_usec
>= USEC_AFTER
- ((unsigned) TICK_SIZE
) / 2 &&
248 now
.tv_usec
<= USEC_BEFORE
+ ((unsigned) TICK_SIZE
) / 2)
249 fail
= set_rtc_mmss(now
.tv_sec
);
251 next
.tv_usec
= USEC_AFTER
- now
.tv_usec
;
252 if (next
.tv_usec
<= 0)
253 next
.tv_usec
+= USEC_PER_SEC
;
260 if (next
.tv_usec
>= USEC_PER_SEC
) {
262 next
.tv_usec
-= USEC_PER_SEC
;
264 mod_timer(&sync_cmos_timer
, jiffies
+ timeval_to_jiffies(&next
));
267 void notify_arch_cmos_timer(void)
269 mod_timer(&sync_cmos_timer
, jiffies
+ 1);
272 static long clock_cmos_diff
, sleep_start
;
274 static int timer_suspend(struct sys_device
*dev
, pm_message_t state
)
277 * Estimate time zone so that set_time can update the clock
279 clock_cmos_diff
= -get_cmos_time();
280 clock_cmos_diff
+= get_seconds();
281 sleep_start
= get_cmos_time();
285 static int timer_resume(struct sys_device
*dev
)
289 unsigned long sleep_length
;
291 #ifdef CONFIG_HPET_TIMER
292 if (is_hpet_enabled())
296 sec
= get_cmos_time() + clock_cmos_diff
;
297 sleep_length
= (get_cmos_time() - sleep_start
) * HZ
;
298 write_seqlock_irqsave(&xtime_lock
, flags
);
301 jiffies_64
+= sleep_length
;
302 wall_jiffies
+= sleep_length
;
303 write_sequnlock_irqrestore(&xtime_lock
, flags
);
304 touch_softlockup_watchdog();
308 static struct sysdev_class timer_sysclass
= {
309 .resume
= timer_resume
,
310 .suspend
= timer_suspend
,
311 set_kset_name("timer"),
315 /* XXX this driverfs stuff should probably go elsewhere later -john */
316 static struct sys_device device_timer
= {
318 .cls
= &timer_sysclass
,
321 static int time_init_device(void)
323 int error
= sysdev_class_register(&timer_sysclass
);
325 error
= sysdev_register(&device_timer
);
329 device_initcall(time_init_device
);
331 #ifdef CONFIG_HPET_TIMER
332 extern void (*late_time_init
)(void);
333 /* Duplicate of time_init() below, with hpet_enable part added */
334 static void __init
hpet_time_init(void)
336 xtime
.tv_sec
= get_cmos_time();
337 xtime
.tv_nsec
= (INITIAL_JIFFIES
% HZ
) * (NSEC_PER_SEC
/ HZ
);
338 set_normalized_timespec(&wall_to_monotonic
,
339 -xtime
.tv_sec
, -xtime
.tv_nsec
);
341 if ((hpet_enable() >= 0) && hpet_use_timer
) {
342 printk("Using HPET for base-timer\n");
349 void __init
time_init(void)
351 #ifdef CONFIG_HPET_TIMER
352 if (is_hpet_capable()) {
354 * HPET initialization needs to do memory-mapped io. So, let
355 * us do a late initialization after mem_init().
357 late_time_init
= hpet_time_init
;
361 xtime
.tv_sec
= get_cmos_time();
362 xtime
.tv_nsec
= (INITIAL_JIFFIES
% HZ
) * (NSEC_PER_SEC
/ HZ
);
363 set_normalized_timespec(&wall_to_monotonic
,
364 -xtime
.tv_sec
, -xtime
.tv_nsec
);