arch/i386/kernel/time.c

   1 /*
   2  *  linux/arch/i386/kernel/time.c
   3  *
   4  *  Copyright (C) 1991, 1992, 1995  Linus Torvalds
   5  *
   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).
  31  */
  32
  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>
  38 #include <linux/mm.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>
  49
  50 #include <asm/io.h>
  51 #include <asm/smp.h>
  52 #include <asm/irq.h>
  53 #include <asm/msr.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>
  59
  60 #include "mach_time.h"
  61
  62 #include <linux/timex.h>
  63 #include <linux/config.h>
  64
  65 #include <asm/hpet.h>
  66
  67 #include <asm/arch_hooks.h>
  68
  69 #include "io_ports.h"
  70
  71 #include <asm/i8259.h>
  72
  73 int pit_latch_buggy;              /* extern */
  74
  75 #include "do_timer.h"
  76
  77 unsigned int cpu_khz;   /* Detected as we calibrate the TSC */
  78 EXPORT_SYMBOL(cpu_khz);
  79
  80 extern unsigned long wall_jiffies;
  81
  82 DEFINE_SPINLOCK(rtc_lock);
  83 EXPORT_SYMBOL(rtc_lock);
  84
  85 #include <asm/i8253.h>
  86
  87 DEFINE_SPINLOCK(i8253_lock);
  88 EXPORT_SYMBOL(i8253_lock);
  89
  90 struct timer_opts *cur_timer __read_mostly = &timer_none;
  91
  92 /*
  93  * This is a special lock that is owned by the CPU and holds the index
  94  * register we are working with.  It is required for NMI access to the
  95  * CMOS/RTC registers.  See include/asm-i386/mc146818rtc.h for details.
  96  */
  97 volatile unsigned long cmos_lock = 0;
  98 EXPORT_SYMBOL(cmos_lock);
  99
 100 /* Routines for accessing the CMOS RAM/RTC. */
 101 unsigned char rtc_cmos_read(unsigned char addr)
 102 {
 103         unsigned char val;
 104         lock_cmos_prefix(addr);
 105         outb_p(addr, RTC_PORT(0));
 106         val = inb_p(RTC_PORT(1));
 107         lock_cmos_suffix(addr);
 108         return val;
 109 }
 110 EXPORT_SYMBOL(rtc_cmos_read);
 111
 112 void rtc_cmos_write(unsigned char val, unsigned char addr)
 113 {
 114         lock_cmos_prefix(addr);
 115         outb_p(addr, RTC_PORT(0));
 116         outb_p(val, RTC_PORT(1));
 117         lock_cmos_suffix(addr);
 118 }
 119 EXPORT_SYMBOL(rtc_cmos_write);
 120
 121 /*
 122  * This version of gettimeofday has microsecond resolution
 123  * and better than microsecond precision on fast x86 machines with TSC.
 124  */
 125 void do_gettimeofday(struct timeval *tv)
 126 {
 127         unsigned long seq;
 128         unsigned long usec, sec;
 129         unsigned long max_ntp_tick;
 130
 131         do {
 132                 unsigned long lost;
 133
 134                 seq = read_seqbegin(&xtime_lock);
 135
 136                 usec = cur_timer->get_offset();
 137                 lost = jiffies - wall_jiffies;
 138
 139                 /*
 140                  * If time_adjust is negative then NTP is slowing the clock
 141                  * so make sure not to go into next possible interval.
 142                  * Better to lose some accuracy than have time go backwards..
 143                  */
 144                 if (unlikely(time_adjust < 0)) {
 145                         max_ntp_tick = (USEC_PER_SEC / HZ) - tickadj;
 146                         usec = min(usec, max_ntp_tick);
 147
 148                         if (lost)
 149                                 usec += lost * max_ntp_tick;
 150                 }
 151                 else if (unlikely(lost))
 152                         usec += lost * (USEC_PER_SEC / HZ);
 153
 154                 sec = xtime.tv_sec;
 155                 usec += (xtime.tv_nsec / 1000);
 156         } while (read_seqretry(&xtime_lock, seq));
 157
 158         while (usec >= 1000000) {
 159                 usec -= 1000000;
 160                 sec++;
 161         }
 162
 163         tv->tv_sec = sec;
 164         tv->tv_usec = usec;
 165 }
 166
 167 EXPORT_SYMBOL(do_gettimeofday);
 168
 169 int do_settimeofday(struct timespec *tv)
 170 {
 171         time_t wtm_sec, sec = tv->tv_sec;
 172         long wtm_nsec, nsec = tv->tv_nsec;
 173
 174         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 175                 return -EINVAL;
 176
 177         write_seqlock_irq(&xtime_lock);
 178         /*
 179          * This is revolting. We need to set "xtime" correctly. However, the
 180          * value in this location is the value at the most recent update of
 181          * wall time.  Discover what correction gettimeofday() would have
 182          * made, and then undo it!
 183          */
 184         nsec -= cur_timer->get_offset() * NSEC_PER_USEC;
 185         nsec -= (jiffies - wall_jiffies) * TICK_NSEC;
 186
 187         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 188         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 189
 190         set_normalized_timespec(&xtime, sec, nsec);
 191         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 192
 193         ntp_clear();
 194         write_sequnlock_irq(&xtime_lock);
 195         clock_was_set();
 196         return 0;
 197 }
 198
 199 EXPORT_SYMBOL(do_settimeofday);
 200
 201 static int set_rtc_mmss(unsigned long nowtime)
 202 {
 203         int retval;
 204
 205         WARN_ON(irqs_disabled());
 206
 207         /* gets recalled with irq locally disabled */
 208         spin_lock_irq(&rtc_lock);
 209         if (efi_enabled)
 210                 retval = efi_set_rtc_mmss(nowtime);
 211         else
 212                 retval = mach_set_rtc_mmss(nowtime);
 213         spin_unlock_irq(&rtc_lock);
 214
 215         return retval;
 216 }
 217
 218
 219 int timer_ack;
 220
 221 /* monotonic_clock(): returns # of nanoseconds passed since time_init()
 222  *              Note: This function is required to return accurate
 223  *              time even in the absence of multiple timer ticks.
 224  */
 225 unsigned long long monotonic_clock(void)
 226 {
 227         return cur_timer->monotonic_clock();
 228 }
 229 EXPORT_SYMBOL(monotonic_clock);
 230
 231 #if defined(CONFIG_SMP) && defined(CONFIG_FRAME_POINTER)
 232 unsigned long profile_pc(struct pt_regs *regs)
 233 {
 234         unsigned long pc = instruction_pointer(regs);
 235
 236         if (in_lock_functions(pc))
 237                 return *(unsigned long *)(regs->ebp + 4);
 238
 239         return pc;
 240 }
 241 EXPORT_SYMBOL(profile_pc);
 242 #endif
 243
 244 /*
 245  * timer_interrupt() needs to keep up the real-time clock,
 246  * as well as call the "do_timer()" routine every clocktick
 247  */
 248 static inline void do_timer_interrupt(int irq, struct pt_regs *regs)
 249 {
 250 #ifdef CONFIG_X86_IO_APIC
 251         if (timer_ack) {
 252                 /*
 253                  * Subtle, when I/O APICs are used we have to ack timer IRQ
 254                  * manually to reset the IRR bit for do_slow_gettimeoffset().
 255                  * This will also deassert NMI lines for the watchdog if run
 256                  * on an 82489DX-based system.
 257                  */
 258                 spin_lock(&i8259A_lock);
 259                 outb(0x0c, PIC_MASTER_OCW3);
 260                 /* Ack the IRQ; AEOI will end it automatically. */
 261                 inb(PIC_MASTER_POLL);
 262                 spin_unlock(&i8259A_lock);
 263         }
 264 #endif
 265
 266         do_timer_interrupt_hook(regs);
 267
 268
 269         if (MCA_bus) {
 270                 /* The PS/2 uses level-triggered interrupts.  You can't
 271                 turn them off, nor would you want to (any attempt to
 272                 enable edge-triggered interrupts usually gets intercepted by a
 273                 special hardware circuit).  Hence we have to acknowledge
 274                 the timer interrupt.  Through some incredibly stupid
 275                 design idea, the reset for IRQ 0 is done by setting the
 276                 high bit of the PPI port B (0x61).  Note that some PS/2s,
 277                 notably the 55SX, work fine if this is removed.  */
 278
 279                 irq = inb_p( 0x61 );    /* read the current state */
 280                 outb_p( irq|0x80, 0x61 );       /* reset the IRQ */
 281         }
 282 }
 283
 284 /*
 285  * This is the same as the above, except we _also_ save the current
 286  * Time Stamp Counter value at the time of the timer interrupt, so that
 287  * we later on can estimate the time of day more exactly.
 288  */
 289 irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 290 {
 291         /*
 292          * Here we are in the timer irq handler. We just have irqs locally
 293          * disabled but we don't know if the timer_bh is running on the other
 294          * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
 295          * the irq version of write_lock because as just said we have irq
 296          * locally disabled. -arca
 297          */
 298         write_seqlock(&xtime_lock);
 299
 300         cur_timer->mark_offset();
 301
 302         do_timer_interrupt(irq, regs);
 303
 304         write_sequnlock(&xtime_lock);
 305         return IRQ_HANDLED;
 306 }
 307
 308 /* not static: needed by APM */
 309 unsigned long get_cmos_time(void)
 310 {
 311         unsigned long retval;
 312
 313         spin_lock(&rtc_lock);
 314
 315         if (efi_enabled)
 316                 retval = efi_get_time();
 317         else
 318                 retval = mach_get_cmos_time();
 319
 320         spin_unlock(&rtc_lock);
 321
 322         return retval;
 323 }
 324 EXPORT_SYMBOL(get_cmos_time);
 325
 326 static void sync_cmos_clock(unsigned long dummy);
 327
 328 static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);
 329
 330 static void sync_cmos_clock(unsigned long dummy)
 331 {
 332         struct timeval now, next;
 333         int fail = 1;
 334
 335         /*
 336          * If we have an externally synchronized Linux clock, then update
 337          * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
 338          * called as close as possible to 500 ms before the new second starts.
 339          * This code is run on a timer.  If the clock is set, that timer
 340          * may not expire at the correct time.  Thus, we adjust...
 341          */
 342         if (!ntp_synced())
 343                 /*
 344                  * Not synced, exit, do not restart a timer (if one is
 345                  * running, let it run out).
 346                  */
 347                 return;
 348
 349         do_gettimeofday(&now);
 350         if (now.tv_usec >= USEC_AFTER - ((unsigned) TICK_SIZE) / 2 &&
 351             now.tv_usec <= USEC_BEFORE + ((unsigned) TICK_SIZE) / 2)
 352                 fail = set_rtc_mmss(now.tv_sec);
 353
 354         next.tv_usec = USEC_AFTER - now.tv_usec;
 355         if (next.tv_usec <= 0)
 356                 next.tv_usec += USEC_PER_SEC;
 357
 358         if (!fail)
 359                 next.tv_sec = 659;
 360         else
 361                 next.tv_sec = 0;
 362
 363         if (next.tv_usec >= USEC_PER_SEC) {
 364                 next.tv_sec++;
 365                 next.tv_usec -= USEC_PER_SEC;
 366         }
 367         mod_timer(&sync_cmos_timer, jiffies + timeval_to_jiffies(&next));
 368 }
 369
 370 void notify_arch_cmos_timer(void)
 371 {
 372         mod_timer(&sync_cmos_timer, jiffies + 1);
 373 }
 374
 375 static long clock_cmos_diff, sleep_start;
 376
 377 static struct timer_opts *last_timer;
 378 static int timer_suspend(struct sys_device *dev, pm_message_t state)
 379 {
 380         /*
 381          * Estimate time zone so that set_time can update the clock
 382          */
 383         clock_cmos_diff = -get_cmos_time();
 384         clock_cmos_diff += get_seconds();
 385         sleep_start = get_cmos_time();
 386         last_timer = cur_timer;
 387         cur_timer = &timer_none;
 388         if (last_timer->suspend)
 389                 last_timer->suspend(state);
 390         return 0;
 391 }
 392
 393 static int timer_resume(struct sys_device *dev)
 394 {
 395         unsigned long flags;
 396         unsigned long sec;
 397         unsigned long sleep_length;
 398
 399 #ifdef CONFIG_HPET_TIMER
 400         if (is_hpet_enabled())
 401                 hpet_reenable();
 402 #endif
 403         setup_pit_timer();
 404         sec = get_cmos_time() + clock_cmos_diff;
 405         sleep_length = (get_cmos_time() - sleep_start) * HZ;
 406         write_seqlock_irqsave(&xtime_lock, flags);
 407         xtime.tv_sec = sec;
 408         xtime.tv_nsec = 0;
 409         write_sequnlock_irqrestore(&xtime_lock, flags);
 410         jiffies += sleep_length;
 411         wall_jiffies += sleep_length;
 412         if (last_timer->resume)
 413                 last_timer->resume();
 414         cur_timer = last_timer;
 415         last_timer = NULL;
 416         touch_softlockup_watchdog();
 417         return 0;
 418 }
 419
 420 static struct sysdev_class timer_sysclass = {
 421         .resume = timer_resume,
 422         .suspend = timer_suspend,
 423         set_kset_name("timer"),
 424 };
 425
 426
 427 /* XXX this driverfs stuff should probably go elsewhere later -john */
 428 static struct sys_device device_timer = {
 429         .id     = 0,
 430         .cls    = &timer_sysclass,
 431 };
 432
 433 static int time_init_device(void)
 434 {
 435         int error = sysdev_class_register(&timer_sysclass);
 436         if (!error)
 437                 error = sysdev_register(&device_timer);
 438         return error;
 439 }
 440
 441 device_initcall(time_init_device);
 442
 443 #ifdef CONFIG_HPET_TIMER
 444 extern void (*late_time_init)(void);
 445 /* Duplicate of time_init() below, with hpet_enable part added */
 446 static void __init hpet_time_init(void)
 447 {
 448         xtime.tv_sec = get_cmos_time();
 449         xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
 450         set_normalized_timespec(&wall_to_monotonic,
 451                 -xtime.tv_sec, -xtime.tv_nsec);
 452
 453         if ((hpet_enable() >= 0) && hpet_use_timer) {
 454                 printk("Using HPET for base-timer\n");
 455         }
 456
 457         cur_timer = select_timer();
 458         printk(KERN_INFO "Using %s for high-res timesource\n",cur_timer->name);
 459
 460         time_init_hook();
 461 }
 462 #endif
 463
 464 void __init time_init(void)
 465 {
 466 #ifdef CONFIG_HPET_TIMER
 467         if (is_hpet_capable()) {
 468                 /*
 469                  * HPET initialization needs to do memory-mapped io. So, let
 470                  * us do a late initialization after mem_init().
 471                  */
 472                 late_time_init = hpet_time_init;
 473                 return;
 474         }
 475 #endif
 476         xtime.tv_sec = get_cmos_time();
 477         xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
 478         set_normalized_timespec(&wall_to_monotonic,
 479                 -xtime.tv_sec, -xtime.tv_nsec);
 480
 481         cur_timer = select_timer();
 482         printk(KERN_INFO "Using %s for high-res timesource\n",cur_timer->name);
 483
 484         time_init_hook();
 485 }