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>
53 #include <asm/delay.h>
54 #include <asm/mpspec.h>
55 #include <asm/uaccess.h>
56 #include <asm/processor.h>
57 #include <asm/timer.h>
59 #include "mach_time.h"
61 #include <linux/timex.h>
62 #include <linux/config.h>
66 #include <asm/arch_hooks.h>
70 extern spinlock_t i8259A_lock
;
71 int pit_latch_buggy
; /* extern */
75 u64 jiffies_64
= INITIAL_JIFFIES
;
77 EXPORT_SYMBOL(jiffies_64
);
79 unsigned long cpu_khz
; /* Detected as we calibrate the TSC */
81 extern unsigned long wall_jiffies
;
83 spinlock_t rtc_lock
= SPIN_LOCK_UNLOCKED
;
85 spinlock_t i8253_lock
= SPIN_LOCK_UNLOCKED
;
86 EXPORT_SYMBOL(i8253_lock
);
88 struct timer_opts
*cur_timer
= &timer_none
;
91 * This version of gettimeofday has microsecond resolution
92 * and better than microsecond precision on fast x86 machines with TSC.
94 void do_gettimeofday(struct timeval
*tv
)
97 unsigned long usec
, sec
;
98 unsigned long max_ntp_tick
;
103 seq
= read_seqbegin(&xtime_lock
);
105 usec
= cur_timer
->get_offset();
106 lost
= jiffies
- wall_jiffies
;
109 * If time_adjust is negative then NTP is slowing the clock
110 * so make sure not to go into next possible interval.
111 * Better to lose some accuracy than have time go backwards..
113 if (unlikely(time_adjust
< 0)) {
114 max_ntp_tick
= (USEC_PER_SEC
/ HZ
) - tickadj
;
115 usec
= min(usec
, max_ntp_tick
);
118 usec
+= lost
* max_ntp_tick
;
120 else if (unlikely(lost
))
121 usec
+= lost
* (USEC_PER_SEC
/ HZ
);
124 usec
+= (xtime
.tv_nsec
/ 1000);
125 } while (read_seqretry(&xtime_lock
, seq
));
127 while (usec
>= 1000000) {
136 EXPORT_SYMBOL(do_gettimeofday
);
138 int do_settimeofday(struct timespec
*tv
)
140 time_t wtm_sec
, sec
= tv
->tv_sec
;
141 long wtm_nsec
, nsec
= tv
->tv_nsec
;
143 if ((unsigned long)tv
->tv_nsec
>= NSEC_PER_SEC
)
146 write_seqlock_irq(&xtime_lock
);
148 * This is revolting. We need to set "xtime" correctly. However, the
149 * value in this location is the value at the most recent update of
150 * wall time. Discover what correction gettimeofday() would have
151 * made, and then undo it!
153 nsec
-= cur_timer
->get_offset() * NSEC_PER_USEC
;
154 nsec
-= (jiffies
- wall_jiffies
) * TICK_NSEC
;
156 wtm_sec
= wall_to_monotonic
.tv_sec
+ (xtime
.tv_sec
- sec
);
157 wtm_nsec
= wall_to_monotonic
.tv_nsec
+ (xtime
.tv_nsec
- nsec
);
159 set_normalized_timespec(&xtime
, sec
, nsec
);
160 set_normalized_timespec(&wall_to_monotonic
, wtm_sec
, wtm_nsec
);
162 time_adjust
= 0; /* stop active adjtime() */
163 time_status
|= STA_UNSYNC
;
164 time_maxerror
= NTP_PHASE_LIMIT
;
165 time_esterror
= NTP_PHASE_LIMIT
;
166 write_sequnlock_irq(&xtime_lock
);
171 EXPORT_SYMBOL(do_settimeofday
);
173 static int set_rtc_mmss(unsigned long nowtime
)
177 /* gets recalled with irq locally disabled */
178 spin_lock(&rtc_lock
);
180 retval
= efi_set_rtc_mmss(nowtime
);
182 retval
= mach_set_rtc_mmss(nowtime
);
183 spin_unlock(&rtc_lock
);
188 /* last time the cmos clock got updated */
189 static long last_rtc_update
;
193 /* monotonic_clock(): returns # of nanoseconds passed since time_init()
194 * Note: This function is required to return accurate
195 * time even in the absence of multiple timer ticks.
197 unsigned long long monotonic_clock(void)
199 return cur_timer
->monotonic_clock();
201 EXPORT_SYMBOL(monotonic_clock
);
203 #if defined(CONFIG_SMP) && defined(CONFIG_FRAME_POINTER)
204 unsigned long profile_pc(struct pt_regs
*regs
)
206 unsigned long pc
= instruction_pointer(regs
);
208 if (in_lock_functions(pc
))
209 return *(unsigned long *)(regs
->ebp
+ 4);
213 EXPORT_SYMBOL(profile_pc
);
217 * timer_interrupt() needs to keep up the real-time clock,
218 * as well as call the "do_timer()" routine every clocktick
220 static inline void do_timer_interrupt(int irq
, void *dev_id
,
221 struct pt_regs
*regs
)
223 #ifdef CONFIG_X86_IO_APIC
226 * Subtle, when I/O APICs are used we have to ack timer IRQ
227 * manually to reset the IRR bit for do_slow_gettimeoffset().
228 * This will also deassert NMI lines for the watchdog if run
229 * on an 82489DX-based system.
231 spin_lock(&i8259A_lock
);
232 outb(0x0c, PIC_MASTER_OCW3
);
233 /* Ack the IRQ; AEOI will end it automatically. */
234 inb(PIC_MASTER_POLL
);
235 spin_unlock(&i8259A_lock
);
239 do_timer_interrupt_hook(regs
);
242 * If we have an externally synchronized Linux clock, then update
243 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
244 * called as close as possible to 500 ms before the new second starts.
246 if ((time_status
& STA_UNSYNC
) == 0 &&
247 xtime
.tv_sec
> last_rtc_update
+ 660 &&
248 (xtime
.tv_nsec
/ 1000)
249 >= USEC_AFTER
- ((unsigned) TICK_SIZE
) / 2 &&
250 (xtime
.tv_nsec
/ 1000)
251 <= USEC_BEFORE
+ ((unsigned) TICK_SIZE
) / 2) {
252 /* horrible...FIXME */
254 if (efi_set_rtc_mmss(xtime
.tv_sec
) == 0)
255 last_rtc_update
= xtime
.tv_sec
;
257 last_rtc_update
= xtime
.tv_sec
- 600;
258 } else if (set_rtc_mmss(xtime
.tv_sec
) == 0)
259 last_rtc_update
= xtime
.tv_sec
;
261 last_rtc_update
= xtime
.tv_sec
- 600; /* do it again in 60 s */
266 /* The PS/2 uses level-triggered interrupts. You can't
267 turn them off, nor would you want to (any attempt to
268 enable edge-triggered interrupts usually gets intercepted by a
269 special hardware circuit). Hence we have to acknowledge
270 the timer interrupt. Through some incredibly stupid
271 design idea, the reset for IRQ 0 is done by setting the
272 high bit of the PPI port B (0x61). Note that some PS/2s,
273 notably the 55SX, work fine if this is removed. */
275 irq
= inb_p( 0x61 ); /* read the current state */
276 outb_p( irq
|0x80, 0x61 ); /* reset the IRQ */
282 * This is the same as the above, except we _also_ save the current
283 * Time Stamp Counter value at the time of the timer interrupt, so that
284 * we later on can estimate the time of day more exactly.
286 irqreturn_t
timer_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
289 * Here we are in the timer irq handler. We just have irqs locally
290 * disabled but we don't know if the timer_bh is running on the other
291 * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
292 * the irq version of write_lock because as just said we have irq
293 * locally disabled. -arca
295 write_seqlock(&xtime_lock
);
297 cur_timer
->mark_offset();
299 do_timer_interrupt(irq
, NULL
, regs
);
301 write_sequnlock(&xtime_lock
);
305 /* not static: needed by APM */
306 unsigned long get_cmos_time(void)
308 unsigned long retval
;
310 spin_lock(&rtc_lock
);
313 retval
= efi_get_time();
315 retval
= mach_get_cmos_time();
317 spin_unlock(&rtc_lock
);
322 static long clock_cmos_diff
;
324 static int time_suspend(struct sys_device
*dev
, u32 state
)
327 * Estimate time zone so that set_time can update the clock
329 clock_cmos_diff
= -get_cmos_time();
330 clock_cmos_diff
+= get_seconds();
334 static int time_resume(struct sys_device
*dev
)
337 unsigned long sec
= get_cmos_time() + clock_cmos_diff
;
338 write_seqlock_irqsave(&xtime_lock
, flags
);
341 write_sequnlock_irqrestore(&xtime_lock
, flags
);
345 static struct sysdev_class pit_sysclass
= {
346 .resume
= time_resume
,
347 .suspend
= time_suspend
,
348 set_kset_name("pit"),
352 /* XXX this driverfs stuff should probably go elsewhere later -john */
353 static struct sys_device device_i8253
= {
355 .cls
= &pit_sysclass
,
358 static int time_init_device(void)
360 int error
= sysdev_class_register(&pit_sysclass
);
362 error
= sysdev_register(&device_i8253
);
366 device_initcall(time_init_device
);
368 #ifdef CONFIG_HPET_TIMER
369 extern void (*late_time_init
)(void);
370 /* Duplicate of time_init() below, with hpet_enable part added */
371 void __init
hpet_time_init(void)
373 xtime
.tv_sec
= get_cmos_time();
374 wall_to_monotonic
.tv_sec
= -xtime
.tv_sec
;
375 xtime
.tv_nsec
= (INITIAL_JIFFIES
% HZ
) * (NSEC_PER_SEC
/ HZ
);
376 wall_to_monotonic
.tv_nsec
= -xtime
.tv_nsec
;
378 if (hpet_enable() >= 0) {
379 printk("Using HPET for base-timer\n");
382 cur_timer
= select_timer();
383 printk(KERN_INFO
"Using %s for high-res timesource\n",cur_timer
->name
);
389 void __init
time_init(void)
391 #ifdef CONFIG_HPET_TIMER
392 if (is_hpet_capable()) {
394 * HPET initialization needs to do memory-mapped io. So, let
395 * us do a late initialization after mem_init().
397 late_time_init
= hpet_time_init
;
401 xtime
.tv_sec
= get_cmos_time();
402 wall_to_monotonic
.tv_sec
= -xtime
.tv_sec
;
403 xtime
.tv_nsec
= (INITIAL_JIFFIES
% HZ
) * (NSEC_PER_SEC
/ HZ
);
404 wall_to_monotonic
.tv_nsec
= -xtime
.tv_nsec
;
406 cur_timer
= select_timer();
407 printk(KERN_INFO
"Using %s for high-res timesource\n",cur_timer
->name
);