arch/x86_64/kernel/time.c

   1 /*
   2  *  linux/arch/x86-64/kernel/time.c
   3  *
   4  *  "High Precision Event Timer" based timekeeping.
   5  *
   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
  14  */
  15
  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>
  31 #ifdef CONFIG_ACPI
  32 #include <acpi/achware.h>       /* for PM timer frequency */
  33 #include <acpi/acpi_bus.h>
  34 #endif
  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>
  40 #include <asm/hpet.h>
  41 #include <asm/sections.h>
  42 #include <linux/cpufreq.h>
  43 #include <linux/hpet.h>
  44 #include <asm/apic.h>
  45
  46 #ifdef CONFIG_CPU_FREQ
  47 static void cpufreq_delayed_get(void);
  48 #endif
  49 extern void i8254_timer_resume(void);
  50 extern int using_apic_timer;
  51
  52 static char *timename = NULL;
  53
  54 DEFINE_SPINLOCK(rtc_lock);
  55 EXPORT_SYMBOL(rtc_lock);
  56 DEFINE_SPINLOCK(i8253_lock);
  57
  58 int nohpet __initdata = 0;
  59 static int notsc __initdata = 0;
  60
  61 #define USEC_PER_TICK (USEC_PER_SEC / HZ)
  62 #define NSEC_PER_TICK (NSEC_PER_SEC / HZ)
  63 #define FSEC_PER_TICK (FSEC_PER_SEC / HZ)
  64
  65 #define NS_SCALE        10 /* 2^10, carefully chosen */
  66 #define US_SCALE        32 /* 2^32, arbitralrily chosen */
  67
  68 unsigned int cpu_khz;                                   /* TSC clocks / usec, not used here */
  69 EXPORT_SYMBOL(cpu_khz);
  70 static unsigned long hpet_period;                       /* fsecs / HPET clock */
  71 unsigned long hpet_tick;                                /* HPET clocks / interrupt */
  72 int hpet_use_timer;                             /* Use counter of hpet for time keeping, otherwise PIT */
  73 unsigned long vxtime_hz = PIT_TICK_RATE;
  74 int report_lost_ticks;                          /* command line option */
  75 unsigned long long monotonic_base;
  76
  77 struct vxtime_data __vxtime __section_vxtime;   /* for vsyscalls */
  78
  79 volatile unsigned long __jiffies __section_jiffies = INITIAL_JIFFIES;
  80 struct timespec __xtime __section_xtime;
  81 struct timezone __sys_tz __section_sys_tz;
  82
  83 /*
  84  * do_gettimeoffset() returns microseconds since last timer interrupt was
  85  * triggered by hardware. A memory read of HPET is slower than a register read
  86  * of TSC, but much more reliable. It's also synchronized to the timer
  87  * interrupt. Note that do_gettimeoffset() may return more than hpet_tick, if a
  88  * timer interrupt has happened already, but vxtime.trigger wasn't updated yet.
  89  * This is not a problem, because jiffies hasn't updated either. They are bound
  90  * together by xtime_lock.
  91  */
  92
  93 static inline unsigned int do_gettimeoffset_tsc(void)
  94 {
  95         unsigned long t;
  96         unsigned long x;
  97         t = get_cycles_sync();
  98         if (t < vxtime.last_tsc)
  99                 t = vxtime.last_tsc; /* hack */
 100         x = ((t - vxtime.last_tsc) * vxtime.tsc_quot) >> US_SCALE;
 101         return x;
 102 }
 103
 104 static inline unsigned int do_gettimeoffset_hpet(void)
 105 {
 106         /* cap counter read to one tick to avoid inconsistencies */
 107         unsigned long counter = hpet_readl(HPET_COUNTER) - vxtime.last;
 108         return (min(counter,hpet_tick) * vxtime.quot) >> US_SCALE;
 109 }
 110
 111 unsigned int (*do_gettimeoffset)(void) = do_gettimeoffset_tsc;
 112
 113 /*
 114  * This version of gettimeofday() has microsecond resolution and better than
 115  * microsecond precision, as we're using at least a 10 MHz (usually 14.31818
 116  * MHz) HPET timer.
 117  */
 118
 119 void do_gettimeofday(struct timeval *tv)
 120 {
 121         unsigned long seq;
 122         unsigned int sec, usec;
 123
 124         do {
 125                 seq = read_seqbegin(&xtime_lock);
 126
 127                 sec = xtime.tv_sec;
 128                 usec = xtime.tv_nsec / NSEC_PER_USEC;
 129
 130                 /* i386 does some correction here to keep the clock
 131                    monotonous even when ntpd is fixing drift.
 132                    But they didn't work for me, there is a non monotonic
 133                    clock anyways with ntp.
 134                    I dropped all corrections now until a real solution can
 135                    be found. Note when you fix it here you need to do the same
 136                    in arch/x86_64/kernel/vsyscall.c and export all needed
 137                    variables in vmlinux.lds. -AK */
 138                 usec += do_gettimeoffset();
 139
 140         } while (read_seqretry(&xtime_lock, seq));
 141
 142         tv->tv_sec = sec + usec / USEC_PER_SEC;
 143         tv->tv_usec = usec % USEC_PER_SEC;
 144 }
 145
 146 EXPORT_SYMBOL(do_gettimeofday);
 147
 148 /*
 149  * settimeofday() first undoes the correction that gettimeofday would do
 150  * on the time, and then saves it. This is ugly, but has been like this for
 151  * ages already.
 152  */
 153
 154 int do_settimeofday(struct timespec *tv)
 155 {
 156         time_t wtm_sec, sec = tv->tv_sec;
 157         long wtm_nsec, nsec = tv->tv_nsec;
 158
 159         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 160                 return -EINVAL;
 161
 162         write_seqlock_irq(&xtime_lock);
 163
 164         nsec -= do_gettimeoffset() * NSEC_PER_USEC;
 165
 166         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 167         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 168
 169         set_normalized_timespec(&xtime, sec, nsec);
 170         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 171
 172         ntp_clear();
 173
 174         write_sequnlock_irq(&xtime_lock);
 175         clock_was_set();
 176         return 0;
 177 }
 178
 179 EXPORT_SYMBOL(do_settimeofday);
 180
 181 unsigned long profile_pc(struct pt_regs *regs)
 182 {
 183         unsigned long pc = instruction_pointer(regs);
 184
 185         /* Assume the lock function has either no stack frame or a copy
 186            of eflags from PUSHF
 187            Eflags always has bits 22 and up cleared unlike kernel addresses. */
 188         if (!user_mode(regs) && in_lock_functions(pc)) {
 189                 unsigned long *sp = (unsigned long *)regs->rsp;
 190                 if (sp[0] >> 22)
 191                         return sp[0];
 192                 if (sp[1] >> 22)
 193                         return sp[1];
 194         }
 195         return pc;
 196 }
 197 EXPORT_SYMBOL(profile_pc);
 198
 199 /*
 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
 204  * sheet for details.
 205  */
 206
 207 static void set_rtc_mmss(unsigned long nowtime)
 208 {
 209         int real_seconds, real_minutes, cmos_minutes;
 210         unsigned char control, freq_select;
 211
 212 /*
 213  * IRQs are disabled when we're called from the timer interrupt,
 214  * no need for spin_lock_irqsave()
 215  */
 216
 217         spin_lock(&rtc_lock);
 218
 219 /*
 220  * Tell the clock it's being set and stop it.
 221  */
 222
 223         control = CMOS_READ(RTC_CONTROL);
 224         CMOS_WRITE(control | RTC_SET, RTC_CONTROL);
 225
 226         freq_select = CMOS_READ(RTC_FREQ_SELECT);
 227         CMOS_WRITE(freq_select | RTC_DIV_RESET2, RTC_FREQ_SELECT);
 228
 229         cmos_minutes = CMOS_READ(RTC_MINUTES);
 230                 BCD_TO_BIN(cmos_minutes);
 231
 232 /*
 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.
 237  */
 238
 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 */
 243         real_minutes %= 60;
 244
 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);
 248         } else {
 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);
 253         }
 254
 255 /*
 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
 261  */
 262
 263         CMOS_WRITE(control, RTC_CONTROL);
 264         CMOS_WRITE(freq_select, RTC_FREQ_SELECT);
 265
 266         spin_unlock(&rtc_lock);
 267 }
 268
 269
 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.
 273  */
 274 static inline unsigned long long cycles_2_ns(unsigned long long cyc);
 275 unsigned long long monotonic_clock(void)
 276 {
 277         unsigned long seq;
 278         u32 last_offset, this_offset, offset;
 279         unsigned long long base;
 280
 281         if (vxtime.mode == VXTIME_HPET) {
 282                 do {
 283                         seq = read_seqbegin(&xtime_lock);
 284
 285                         last_offset = vxtime.last;
 286                         base = monotonic_base;
 287                         this_offset = hpet_readl(HPET_COUNTER);
 288                 } while (read_seqretry(&xtime_lock, seq));
 289                 offset = (this_offset - last_offset);
 290                 offset *= NSEC_PER_TICK / hpet_tick;
 291         } else {
 292                 do {
 293                         seq = read_seqbegin(&xtime_lock);
 294
 295                         last_offset = vxtime.last_tsc;
 296                         base = monotonic_base;
 297                 } while (read_seqretry(&xtime_lock, seq));
 298                 this_offset = get_cycles_sync();
 299                 offset = cycles_2_ns(this_offset - last_offset);
 300         }
 301         return base + offset;
 302 }
 303 EXPORT_SYMBOL(monotonic_clock);
 304
 305 static noinline void handle_lost_ticks(int lost)
 306 {
 307         static long lost_count;
 308         static int warned;
 309         if (report_lost_ticks) {
 310                 printk(KERN_WARNING "time.c: Lost %d timer tick(s)! ", lost);
 311                 print_symbol("rip %s)\n", get_irq_regs()->rip);
 312         }
 313
 314         if (lost_count == 1000 && !warned) {
 315                 printk(KERN_WARNING "warning: many lost ticks.\n"
 316                        KERN_WARNING "Your time source seems to be instable or "
 317                                 "some driver is hogging interupts\n");
 318                 print_symbol("rip %s\n", get_irq_regs()->rip);
 319                 if (vxtime.mode == VXTIME_TSC && vxtime.hpet_address) {
 320                         printk(KERN_WARNING "Falling back to HPET\n");
 321                         if (hpet_use_timer)
 322                                 vxtime.last = hpet_readl(HPET_T0_CMP) -
 323                                                         hpet_tick;
 324                         else
 325                                 vxtime.last = hpet_readl(HPET_COUNTER);
 326                         vxtime.mode = VXTIME_HPET;
 327                         do_gettimeoffset = do_gettimeoffset_hpet;
 328                 }
 329                 /* else should fall back to PIT, but code missing. */
 330                 warned = 1;
 331         } else
 332                 lost_count++;
 333
 334 #ifdef CONFIG_CPU_FREQ
 335         /* In some cases the CPU can change frequency without us noticing
 336            Give cpufreq a change to catch up. */
 337         if ((lost_count+1) % 25 == 0)
 338                 cpufreq_delayed_get();
 339 #endif
 340 }
 341
 342 void main_timer_handler(void)
 343 {
 344         static unsigned long rtc_update = 0;
 345         unsigned long tsc;
 346         int delay = 0, offset = 0, lost = 0;
 347
 348 /*
 349  * Here we are in the timer irq handler. We have irqs locally disabled (so we
 350  * don't need spin_lock_irqsave()) but we don't know if the timer_bh is running
 351  * on the other CPU, so we need a lock. We also need to lock the vsyscall
 352  * variables, because both do_timer() and us change them -arca+vojtech
 353  */
 354
 355         write_seqlock(&xtime_lock);
 356
 357         if (vxtime.hpet_address)
 358                 offset = hpet_readl(HPET_COUNTER);
 359
 360         if (hpet_use_timer) {
 361                 /* if we're using the hpet timer functionality,
 362                  * we can more accurately know the counter value
 363                  * when the timer interrupt occured.
 364                  */
 365                 offset = hpet_readl(HPET_T0_CMP) - hpet_tick;
 366                 delay = hpet_readl(HPET_COUNTER) - offset;
 367         } else if (!pmtmr_ioport) {
 368                 spin_lock(&i8253_lock);
 369                 outb_p(0x00, 0x43);
 370                 delay = inb_p(0x40);
 371                 delay |= inb(0x40) << 8;
 372                 spin_unlock(&i8253_lock);
 373                 delay = LATCH - 1 - delay;
 374         }
 375
 376         tsc = get_cycles_sync();
 377
 378         if (vxtime.mode == VXTIME_HPET) {
 379                 if (offset - vxtime.last > hpet_tick) {
 380                         lost = (offset - vxtime.last) / hpet_tick - 1;
 381                 }
 382
 383                 monotonic_base +=
 384                         (offset - vxtime.last) * NSEC_PER_TICK / hpet_tick;
 385
 386                 vxtime.last = offset;
 387 #ifdef CONFIG_X86_PM_TIMER
 388         } else if (vxtime.mode == VXTIME_PMTMR) {
 389                 lost = pmtimer_mark_offset();
 390 #endif
 391         } else {
 392                 offset = (((tsc - vxtime.last_tsc) *
 393                            vxtime.tsc_quot) >> US_SCALE) - USEC_PER_TICK;
 394
 395                 if (offset < 0)
 396                         offset = 0;
 397
 398                 if (offset > USEC_PER_TICK) {
 399                         lost = offset / USEC_PER_TICK;
 400                         offset %= USEC_PER_TICK;
 401                 }
 402
 403                 monotonic_base += cycles_2_ns(tsc - vxtime.last_tsc);
 404
 405                 vxtime.last_tsc = tsc - vxtime.quot * delay / vxtime.tsc_quot;
 406
 407                 if ((((tsc - vxtime.last_tsc) *
 408                       vxtime.tsc_quot) >> US_SCALE) < offset)
 409                         vxtime.last_tsc = tsc -
 410                                 (((long) offset << US_SCALE) / vxtime.tsc_quot) - 1;
 411         }
 412
 413         if (lost > 0)
 414                 handle_lost_ticks(lost);
 415         else
 416                 lost = 0;
 417
 418 /*
 419  * Do the timer stuff.
 420  */
 421
 422         do_timer(lost + 1);
 423 #ifndef CONFIG_SMP
 424         update_process_times(user_mode(get_irq_regs()));
 425 #endif
 426
 427 /*
 428  * In the SMP case we use the local APIC timer interrupt to do the profiling,
 429  * except when we simulate SMP mode on a uniprocessor system, in that case we
 430  * have to call the local interrupt handler.
 431  */
 432
 433         if (!using_apic_timer)
 434                 smp_local_timer_interrupt();
 435
 436 /*
 437  * If we have an externally synchronized Linux clock, then update CMOS clock
 438  * accordingly every ~11 minutes. set_rtc_mmss() will be called in the jiffy
 439  * closest to exactly 500 ms before the next second. If the update fails, we
 440  * don't care, as it'll be updated on the next turn, and the problem (time way
 441  * off) isn't likely to go away much sooner anyway.
 442  */
 443
 444         if (ntp_synced() && xtime.tv_sec > rtc_update &&
 445                 abs(xtime.tv_nsec - 500000000) <= tick_nsec / 2) {
 446                 set_rtc_mmss(xtime.tv_sec);
 447                 rtc_update = xtime.tv_sec + 660;
 448         }
 449
 450         write_sequnlock(&xtime_lock);
 451 }
 452
 453 static irqreturn_t timer_interrupt(int irq, void *dev_id)
 454 {
 455         if (apic_runs_main_timer > 1)
 456                 return IRQ_HANDLED;
 457         main_timer_handler();
 458         if (using_apic_timer)
 459                 smp_send_timer_broadcast_ipi();
 460         return IRQ_HANDLED;
 461 }
 462
 463 static unsigned int cyc2ns_scale __read_mostly;
 464
 465 static inline void set_cyc2ns_scale(unsigned long cpu_khz)
 466 {
 467         cyc2ns_scale = (NSEC_PER_MSEC << NS_SCALE) / cpu_khz;
 468 }
 469
 470 static inline unsigned long long cycles_2_ns(unsigned long long cyc)
 471 {
 472         return (cyc * cyc2ns_scale) >> NS_SCALE;
 473 }
 474
 475 unsigned long long sched_clock(void)
 476 {
 477         unsigned long a = 0;
 478
 479 #if 0
 480         /* Don't do a HPET read here. Using TSC always is much faster
 481            and HPET may not be mapped yet when the scheduler first runs.
 482            Disadvantage is a small drift between CPUs in some configurations,
 483            but that should be tolerable. */
 484         if (__vxtime.mode == VXTIME_HPET)
 485                 return (hpet_readl(HPET_COUNTER) * vxtime.quot) >> US_SCALE;
 486 #endif
 487
 488         /* Could do CPU core sync here. Opteron can execute rdtsc speculatively,
 489            which means it is not completely exact and may not be monotonous between
 490            CPUs. But the errors should be too small to matter for scheduling
 491            purposes. */
 492
 493         rdtscll(a);
 494         return cycles_2_ns(a);
 495 }
 496
 497 static unsigned long get_cmos_time(void)
 498 {
 499         unsigned int year, mon, day, hour, min, sec;
 500         unsigned long flags;
 501         unsigned century = 0;
 502
 503         spin_lock_irqsave(&rtc_lock, flags);
 504
 505         do {
 506                 sec = CMOS_READ(RTC_SECONDS);
 507                 min = CMOS_READ(RTC_MINUTES);
 508                 hour = CMOS_READ(RTC_HOURS);
 509                 day = CMOS_READ(RTC_DAY_OF_MONTH);
 510                 mon = CMOS_READ(RTC_MONTH);
 511                 year = CMOS_READ(RTC_YEAR);
 512 #ifdef CONFIG_ACPI
 513                 if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID &&
 514                                         acpi_gbl_FADT.century)
 515                         century = CMOS_READ(acpi_gbl_FADT.century);
 516 #endif
 517         } while (sec != CMOS_READ(RTC_SECONDS));
 518
 519         spin_unlock_irqrestore(&rtc_lock, flags);
 520
 521         /*
 522          * We know that x86-64 always uses BCD format, no need to check the
 523          * config register.
 524          */
 525
 526         BCD_TO_BIN(sec);
 527         BCD_TO_BIN(min);
 528         BCD_TO_BIN(hour);
 529         BCD_TO_BIN(day);
 530         BCD_TO_BIN(mon);
 531         BCD_TO_BIN(year);
 532
 533         if (century) {
 534                 BCD_TO_BIN(century);
 535                 year += century * 100;
 536                 printk(KERN_INFO "Extended CMOS year: %d\n", century * 100);
 537         } else {
 538                 /*
 539                  * x86-64 systems only exists since 2002.
 540                  * This will work up to Dec 31, 2100
 541                  */
 542                 year += 2000;
 543         }
 544
 545         return mktime(year, mon, day, hour, min, sec);
 546 }
 547
 548 #ifdef CONFIG_CPU_FREQ
 549
 550 /* Frequency scaling support. Adjust the TSC based timer when the cpu frequency
 551    changes.
 552
 553    RED-PEN: On SMP we assume all CPUs run with the same frequency.  It's
 554    not that important because current Opteron setups do not support
 555    scaling on SMP anyroads.
 556
 557    Should fix up last_tsc too. Currently gettimeofday in the
 558    first tick after the change will be slightly wrong. */
 559
 560 #include <linux/workqueue.h>
 561
 562 static unsigned int cpufreq_delayed_issched = 0;
 563 static unsigned int cpufreq_init = 0;
 564 static struct work_struct cpufreq_delayed_get_work;
 565
 566 static void handle_cpufreq_delayed_get(struct work_struct *v)
 567 {
 568         unsigned int cpu;
 569         for_each_online_cpu(cpu) {
 570                 cpufreq_get(cpu);
 571         }
 572         cpufreq_delayed_issched = 0;
 573 }
 574
 575 /* if we notice lost ticks, schedule a call to cpufreq_get() as it tries
 576  * to verify the CPU frequency the timing core thinks the CPU is running
 577  * at is still correct.
 578  */
 579 static void cpufreq_delayed_get(void)
 580 {
 581         static int warned;
 582         if (cpufreq_init && !cpufreq_delayed_issched) {
 583                 cpufreq_delayed_issched = 1;
 584                 if (!warned) {
 585                         warned = 1;
 586                         printk(KERN_DEBUG
 587         "Losing some ticks... checking if CPU frequency changed.\n");
 588                 }
 589                 schedule_work(&cpufreq_delayed_get_work);
 590         }
 591 }
 592
 593 static unsigned int  ref_freq = 0;
 594 static unsigned long loops_per_jiffy_ref = 0;
 595
 596 static unsigned long cpu_khz_ref = 0;
 597
 598 static int time_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
 599                                  void *data)
 600 {
 601         struct cpufreq_freqs *freq = data;
 602         unsigned long *lpj, dummy;
 603
 604         if (cpu_has(&cpu_data[freq->cpu], X86_FEATURE_CONSTANT_TSC))
 605                 return 0;
 606
 607         lpj = &dummy;
 608         if (!(freq->flags & CPUFREQ_CONST_LOOPS))
 609 #ifdef CONFIG_SMP
 610                 lpj = &cpu_data[freq->cpu].loops_per_jiffy;
 611 #else
 612                 lpj = &boot_cpu_data.loops_per_jiffy;
 613 #endif
 614
 615         if (!ref_freq) {
 616                 ref_freq = freq->old;
 617                 loops_per_jiffy_ref = *lpj;
 618                 cpu_khz_ref = cpu_khz;
 619         }
 620         if ((val == CPUFREQ_PRECHANGE  && freq->old < freq->new) ||
 621             (val == CPUFREQ_POSTCHANGE && freq->old > freq->new) ||
 622             (val == CPUFREQ_RESUMECHANGE)) {
 623                 *lpj =
 624                 cpufreq_scale(loops_per_jiffy_ref, ref_freq, freq->new);
 625
 626                 cpu_khz = cpufreq_scale(cpu_khz_ref, ref_freq, freq->new);
 627                 if (!(freq->flags & CPUFREQ_CONST_LOOPS))
 628                         vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
 629         }
 630
 631         set_cyc2ns_scale(cpu_khz_ref);
 632
 633         return 0;
 634 }
 635
 636 static struct notifier_block time_cpufreq_notifier_block = {
 637          .notifier_call  = time_cpufreq_notifier
 638 };
 639
 640 static int __init cpufreq_tsc(void)
 641 {
 642         INIT_WORK(&cpufreq_delayed_get_work, handle_cpufreq_delayed_get);
 643         if (!cpufreq_register_notifier(&time_cpufreq_notifier_block,
 644                                        CPUFREQ_TRANSITION_NOTIFIER))
 645                 cpufreq_init = 1;
 646         return 0;
 647 }
 648
 649 core_initcall(cpufreq_tsc);
 650
 651 #endif
 652
 653 /*
 654  * calibrate_tsc() calibrates the processor TSC in a very simple way, comparing
 655  * it to the HPET timer of known frequency.
 656  */
 657
 658 #define TICK_COUNT 100000000
 659 #define TICK_MIN   5000
 660 #define MAX_READ_RETRIES 5
 661
 662 /*
 663  * Some platforms take periodic SMI interrupts with 5ms duration. Make sure none
 664  * occurs between the reads of the hpet & TSC.
 665  */
 666 static void __init read_hpet_tsc(int *hpet, int *tsc)
 667 {
 668         int tsc1, tsc2, hpet1, retries = 0;
 669         static int msg;
 670
 671         do {
 672                 tsc1 = get_cycles_sync();
 673                 hpet1 = hpet_readl(HPET_COUNTER);
 674                 tsc2 = get_cycles_sync();
 675         } while (tsc2 - tsc1 > TICK_MIN && retries++ < MAX_READ_RETRIES);
 676         if (retries >= MAX_READ_RETRIES && !msg++)
 677                 printk(KERN_WARNING
 678                        "hpet.c: exceeded max retries to read HPET & TSC\n");
 679         *hpet = hpet1;
 680         *tsc = tsc2;
 681 }
 682
 683
 684 static unsigned int __init hpet_calibrate_tsc(void)
 685 {
 686         int tsc_start, hpet_start;
 687         int tsc_now, hpet_now;
 688         unsigned long flags;
 689
 690         local_irq_save(flags);
 691         local_irq_disable();
 692
 693         read_hpet_tsc(&hpet_start, &tsc_start);
 694
 695         do {
 696                 local_irq_disable();
 697                 read_hpet_tsc(&hpet_now, &tsc_now);
 698                 local_irq_restore(flags);
 699         } while ((tsc_now - tsc_start) < TICK_COUNT &&
 700                  (hpet_now - hpet_start) < TICK_COUNT);
 701
 702         return (tsc_now - tsc_start) * 1000000000L
 703                 / ((hpet_now - hpet_start) * hpet_period / 1000);
 704 }
 705
 706
 707 /*
 708  * pit_calibrate_tsc() uses the speaker output (channel 2) of
 709  * the PIT. This is better than using the timer interrupt output,
 710  * because we can read the value of the speaker with just one inb(),
 711  * where we need three i/o operations for the interrupt channel.
 712  * We count how many ticks the TSC does in 50 ms.
 713  */
 714
 715 static unsigned int __init pit_calibrate_tsc(void)
 716 {
 717         unsigned long start, end;
 718         unsigned long flags;
 719
 720         spin_lock_irqsave(&i8253_lock, flags);
 721
 722         outb((inb(0x61) & ~0x02) | 0x01, 0x61);
 723
 724         outb(0xb0, 0x43);
 725         outb((PIT_TICK_RATE / (1000 / 50)) & 0xff, 0x42);
 726         outb((PIT_TICK_RATE / (1000 / 50)) >> 8, 0x42);
 727         start = get_cycles_sync();
 728         while ((inb(0x61) & 0x20) == 0);
 729         end = get_cycles_sync();
 730
 731         spin_unlock_irqrestore(&i8253_lock, flags);
 732
 733         return (end - start) / 50;
 734 }
 735
 736 #ifdef  CONFIG_HPET
 737 static __init int late_hpet_init(void)
 738 {
 739         struct hpet_data        hd;
 740         unsigned int            ntimer;
 741
 742         if (!vxtime.hpet_address)
 743                 return 0;
 744
 745         memset(&hd, 0, sizeof (hd));
 746
 747         ntimer = hpet_readl(HPET_ID);
 748         ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
 749         ntimer++;
 750
 751         /*
 752          * Register with driver.
 753          * Timer0 and Timer1 is used by platform.
 754          */
 755         hd.hd_phys_address = vxtime.hpet_address;
 756         hd.hd_address = (void __iomem *)fix_to_virt(FIX_HPET_BASE);
 757         hd.hd_nirqs = ntimer;
 758         hd.hd_flags = HPET_DATA_PLATFORM;
 759         hpet_reserve_timer(&hd, 0);
 760 #ifdef  CONFIG_HPET_EMULATE_RTC
 761         hpet_reserve_timer(&hd, 1);
 762 #endif
 763         hd.hd_irq[0] = HPET_LEGACY_8254;
 764         hd.hd_irq[1] = HPET_LEGACY_RTC;
 765         if (ntimer > 2) {
 766                 struct hpet             *hpet;
 767                 struct hpet_timer       *timer;
 768                 int                     i;
 769
 770                 hpet = (struct hpet *) fix_to_virt(FIX_HPET_BASE);
 771                 timer = &hpet->hpet_timers[2];
 772                 for (i = 2; i < ntimer; timer++, i++)
 773                         hd.hd_irq[i] = (timer->hpet_config &
 774                                         Tn_INT_ROUTE_CNF_MASK) >>
 775                                 Tn_INT_ROUTE_CNF_SHIFT;
 776
 777         }
 778
 779         hpet_alloc(&hd);
 780         return 0;
 781 }
 782 fs_initcall(late_hpet_init);
 783 #endif
 784
 785 static int hpet_timer_stop_set_go(unsigned long tick)
 786 {
 787         unsigned int cfg;
 788
 789 /*
 790  * Stop the timers and reset the main counter.
 791  */
 792
 793         cfg = hpet_readl(HPET_CFG);
 794         cfg &= ~(HPET_CFG_ENABLE | HPET_CFG_LEGACY);
 795         hpet_writel(cfg, HPET_CFG);
 796         hpet_writel(0, HPET_COUNTER);
 797         hpet_writel(0, HPET_COUNTER + 4);
 798
 799 /*
 800  * Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
 801  * and period also hpet_tick.
 802  */
 803         if (hpet_use_timer) {
 804                 hpet_writel(HPET_TN_ENABLE | HPET_TN_PERIODIC | HPET_TN_SETVAL |
 805                     HPET_TN_32BIT, HPET_T0_CFG);
 806                 hpet_writel(hpet_tick, HPET_T0_CMP); /* next interrupt */
 807                 hpet_writel(hpet_tick, HPET_T0_CMP); /* period */
 808                 cfg |= HPET_CFG_LEGACY;
 809         }
 810 /*
 811  * Go!
 812  */
 813
 814         cfg |= HPET_CFG_ENABLE;
 815         hpet_writel(cfg, HPET_CFG);
 816
 817         return 0;
 818 }
 819
 820 static int hpet_init(void)
 821 {
 822         unsigned int id;
 823
 824         if (!vxtime.hpet_address)
 825                 return -1;
 826         set_fixmap_nocache(FIX_HPET_BASE, vxtime.hpet_address);
 827         __set_fixmap(VSYSCALL_HPET, vxtime.hpet_address, PAGE_KERNEL_VSYSCALL_NOCACHE);
 828
 829 /*
 830  * Read the period, compute tick and quotient.
 831  */
 832
 833         id = hpet_readl(HPET_ID);
 834
 835         if (!(id & HPET_ID_VENDOR) || !(id & HPET_ID_NUMBER))
 836                 return -1;
 837
 838         hpet_period = hpet_readl(HPET_PERIOD);
 839         if (hpet_period < 100000 || hpet_period > 100000000)
 840                 return -1;
 841
 842         hpet_tick = (FSEC_PER_TICK + hpet_period / 2) / hpet_period;
 843
 844         hpet_use_timer = (id & HPET_ID_LEGSUP);
 845
 846         return hpet_timer_stop_set_go(hpet_tick);
 847 }
 848
 849 static int hpet_reenable(void)
 850 {
 851         return hpet_timer_stop_set_go(hpet_tick);
 852 }
 853
 854 #define PIT_MODE 0x43
 855 #define PIT_CH0  0x40
 856
 857 static void __init __pit_init(int val, u8 mode)
 858 {
 859         unsigned long flags;
 860
 861         spin_lock_irqsave(&i8253_lock, flags);
 862         outb_p(mode, PIT_MODE);
 863         outb_p(val & 0xff, PIT_CH0);    /* LSB */
 864         outb_p(val >> 8, PIT_CH0);      /* MSB */
 865         spin_unlock_irqrestore(&i8253_lock, flags);
 866 }
 867
 868 void __init pit_init(void)
 869 {
 870         __pit_init(LATCH, 0x34); /* binary, mode 2, LSB/MSB, ch 0 */
 871 }
 872
 873 void __init pit_stop_interrupt(void)
 874 {
 875         __pit_init(0, 0x30); /* mode 0 */
 876 }
 877
 878 void __init stop_timer_interrupt(void)
 879 {
 880         char *name;
 881         if (vxtime.hpet_address) {
 882                 name = "HPET";
 883                 hpet_timer_stop_set_go(0);
 884         } else {
 885                 name = "PIT";
 886                 pit_stop_interrupt();
 887         }
 888         printk(KERN_INFO "timer: %s interrupt stopped.\n", name);
 889 }
 890
 891 int __init time_setup(char *str)
 892 {
 893         report_lost_ticks = 1;
 894         return 1;
 895 }
 896
 897 static struct irqaction irq0 = {
 898         timer_interrupt, IRQF_DISABLED, CPU_MASK_NONE, "timer", NULL, NULL
 899 };
 900
 901 void __init time_init(void)
 902 {
 903         if (nohpet)
 904                 vxtime.hpet_address = 0;
 905
 906         xtime.tv_sec = get_cmos_time();
 907         xtime.tv_nsec = 0;
 908
 909         set_normalized_timespec(&wall_to_monotonic,
 910                                 -xtime.tv_sec, -xtime.tv_nsec);
 911
 912         if (!hpet_init())
 913                 vxtime_hz = (FSEC_PER_SEC + hpet_period / 2) / hpet_period;
 914         else
 915                 vxtime.hpet_address = 0;
 916
 917         if (hpet_use_timer) {
 918                 /* set tick_nsec to use the proper rate for HPET */
 919                 tick_nsec = TICK_NSEC_HPET;
 920                 cpu_khz = hpet_calibrate_tsc();
 921                 timename = "HPET";
 922 #ifdef CONFIG_X86_PM_TIMER
 923         } else if (pmtmr_ioport && !vxtime.hpet_address) {
 924                 vxtime_hz = PM_TIMER_FREQUENCY;
 925                 timename = "PM";
 926                 pit_init();
 927                 cpu_khz = pit_calibrate_tsc();
 928 #endif
 929         } else {
 930                 pit_init();
 931                 cpu_khz = pit_calibrate_tsc();
 932                 timename = "PIT";
 933         }
 934
 935         vxtime.mode = VXTIME_TSC;
 936         vxtime.quot = (USEC_PER_SEC << US_SCALE) / vxtime_hz;
 937         vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
 938         vxtime.last_tsc = get_cycles_sync();
 939         set_cyc2ns_scale(cpu_khz);
 940         setup_irq(0, &irq0);
 941
 942 #ifndef CONFIG_SMP
 943         time_init_gtod();
 944 #endif
 945 }
 946
 947 /*
 948  * Make an educated guess if the TSC is trustworthy and synchronized
 949  * over all CPUs.
 950  */
 951 __cpuinit int unsynchronized_tsc(void)
 952 {
 953 #ifdef CONFIG_SMP
 954         if (apic_is_clustered_box())
 955                 return 1;
 956 #endif
 957         /* Most intel systems have synchronized TSCs except for
 958            multi node systems */
 959         if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) {
 960 #ifdef CONFIG_ACPI
 961                 /* But TSC doesn't tick in C3 so don't use it there */
 962                 if (acpi_gbl_FADT.header.length > 0 && acpi_gbl_FADT.C3latency < 1000)
 963                         return 1;
 964 #endif
 965                 return 0;
 966         }
 967
 968         /* Assume multi socket systems are not synchronized */
 969         return num_present_cpus() > 1;
 970 }
 971
 972 /*
 973  * Decide what mode gettimeofday should use.
 974  */
 975 void time_init_gtod(void)
 976 {
 977         char *timetype;
 978
 979         if (unsynchronized_tsc())
 980                 notsc = 1;
 981
 982         if (cpu_has(&boot_cpu_data, X86_FEATURE_RDTSCP))
 983                 vgetcpu_mode = VGETCPU_RDTSCP;
 984         else
 985                 vgetcpu_mode = VGETCPU_LSL;
 986
 987         if (vxtime.hpet_address && notsc) {
 988                 timetype = hpet_use_timer ? "HPET" : "PIT/HPET";
 989                 if (hpet_use_timer)
 990                         vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
 991                 else
 992                         vxtime.last = hpet_readl(HPET_COUNTER);
 993                 vxtime.mode = VXTIME_HPET;
 994                 do_gettimeoffset = do_gettimeoffset_hpet;
 995 #ifdef CONFIG_X86_PM_TIMER
 996         /* Using PM for gettimeofday is quite slow, but we have no other
 997            choice because the TSC is too unreliable on some systems. */
 998         } else if (pmtmr_ioport && !vxtime.hpet_address && notsc) {
 999                 timetype = "PM";
1000                 do_gettimeoffset = do_gettimeoffset_pm;
1001                 vxtime.mode = VXTIME_PMTMR;
1002                 sysctl_vsyscall = 0;
1003                 printk(KERN_INFO "Disabling vsyscall due to use of PM timer\n");
1004 #endif
1005         } else {
1006                 timetype = hpet_use_timer ? "HPET/TSC" : "PIT/TSC";
1007                 vxtime.mode = VXTIME_TSC;
1008         }
1009
1010         printk(KERN_INFO "time.c: Using %ld.%06ld MHz WALL %s GTOD %s timer.\n",
1011                vxtime_hz / 1000000, vxtime_hz % 1000000, timename, timetype);
1012         printk(KERN_INFO "time.c: Detected %d.%03d MHz processor.\n",
1013                 cpu_khz / 1000, cpu_khz % 1000);
1014         vxtime.quot = (USEC_PER_SEC << US_SCALE) / vxtime_hz;
1015         vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
1016         vxtime.last_tsc = get_cycles_sync();
1017
1018         set_cyc2ns_scale(cpu_khz);
1019 }
1020
1021 __setup("report_lost_ticks", time_setup);
1022
1023 static long clock_cmos_diff;
1024 static unsigned long sleep_start;
1025
1026 /*
1027  * sysfs support for the timer.
1028  */
1029
1030 static int timer_suspend(struct sys_device *dev, pm_message_t state)
1031 {
1032         /*
1033          * Estimate time zone so that set_time can update the clock
1034          */
1035         long cmos_time =  get_cmos_time();
1036
1037         clock_cmos_diff = -cmos_time;
1038         clock_cmos_diff += get_seconds();
1039         sleep_start = cmos_time;
1040         return 0;
1041 }
1042
1043 static int timer_resume(struct sys_device *dev)
1044 {
1045         unsigned long flags;
1046         unsigned long sec;
1047         unsigned long ctime = get_cmos_time();
1048         long sleep_length = (ctime - sleep_start) * HZ;
1049
1050         if (sleep_length < 0) {
1051                 printk(KERN_WARNING "Time skew detected in timer resume!\n");
1052                 /* The time after the resume must not be earlier than the time
1053                  * before the suspend or some nasty things will happen
1054                  */
1055                 sleep_length = 0;
1056                 ctime = sleep_start;
1057         }
1058         if (vxtime.hpet_address)
1059                 hpet_reenable();
1060         else
1061                 i8254_timer_resume();
1062
1063         sec = ctime + clock_cmos_diff;
1064         write_seqlock_irqsave(&xtime_lock,flags);
1065         xtime.tv_sec = sec;
1066         xtime.tv_nsec = 0;
1067         if (vxtime.mode == VXTIME_HPET) {
1068                 if (hpet_use_timer)
1069                         vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
1070                 else
1071                         vxtime.last = hpet_readl(HPET_COUNTER);
1072 #ifdef CONFIG_X86_PM_TIMER
1073         } else if (vxtime.mode == VXTIME_PMTMR) {
1074                 pmtimer_resume();
1075 #endif
1076         } else
1077                 vxtime.last_tsc = get_cycles_sync();
1078         write_sequnlock_irqrestore(&xtime_lock,flags);
1079         jiffies += sleep_length;
1080         monotonic_base += sleep_length * (NSEC_PER_SEC/HZ);
1081         touch_softlockup_watchdog();
1082         return 0;
1083 }
1084
1085 static struct sysdev_class timer_sysclass = {
1086         .resume = timer_resume,
1087         .suspend = timer_suspend,
1088         set_kset_name("timer"),
1089 };
1090
1091 /* XXX this driverfs stuff should probably go elsewhere later -john */
1092 static struct sys_device device_timer = {
1093         .id     = 0,
1094         .cls    = &timer_sysclass,
1095 };
1096
1097 static int time_init_device(void)
1098 {
1099         int error = sysdev_class_register(&timer_sysclass);
1100         if (!error)
1101                 error = sysdev_register(&device_timer);
1102         return error;
1103 }
1104
1105 device_initcall(time_init_device);
1106
1107 #ifdef CONFIG_HPET_EMULATE_RTC
1108 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
1109  * is enabled, we support RTC interrupt functionality in software.
1110  * RTC has 3 kinds of interrupts:
1111  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
1112  *    is updated
1113  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
1114  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
1115  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
1116  * (1) and (2) above are implemented using polling at a frequency of
1117  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
1118  * overhead. (DEFAULT_RTC_INT_FREQ)
1119  * For (3), we use interrupts at 64Hz or user specified periodic
1120  * frequency, whichever is higher.
1121  */
1122 #include <linux/rtc.h>
1123
1124 #define DEFAULT_RTC_INT_FREQ    64
1125 #define RTC_NUM_INTS            1
1126
1127 static unsigned long UIE_on;
1128 static unsigned long prev_update_sec;
1129
1130 static unsigned long AIE_on;
1131 static struct rtc_time alarm_time;
1132
1133 static unsigned long PIE_on;
1134 static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
1135 static unsigned long PIE_count;
1136
1137 static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
1138 static unsigned int hpet_t1_cmp; /* cached comparator register */
1139
1140 int is_hpet_enabled(void)
1141 {
1142         return vxtime.hpet_address != 0;
1143 }
1144
1145 /*
1146  * Timer 1 for RTC, we do not use periodic interrupt feature,
1147  * even if HPET supports periodic interrupts on Timer 1.
1148  * The reason being, to set up a periodic interrupt in HPET, we need to
1149  * stop the main counter. And if we do that everytime someone diables/enables
1150  * RTC, we will have adverse effect on main kernel timer running on Timer 0.
1151  * So, for the time being, simulate the periodic interrupt in software.
1152  *
1153  * hpet_rtc_timer_init() is called for the first time and during subsequent
1154  * interuppts reinit happens through hpet_rtc_timer_reinit().
1155  */
1156 int hpet_rtc_timer_init(void)
1157 {
1158         unsigned int cfg, cnt;
1159         unsigned long flags;
1160
1161         if (!is_hpet_enabled())
1162                 return 0;
1163         /*
1164          * Set the counter 1 and enable the interrupts.
1165          */
1166         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1167                 hpet_rtc_int_freq = PIE_freq;
1168         else
1169                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1170
1171         local_irq_save(flags);
1172
1173         cnt = hpet_readl(HPET_COUNTER);
1174         cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
1175         hpet_writel(cnt, HPET_T1_CMP);
1176         hpet_t1_cmp = cnt;
1177
1178         cfg = hpet_readl(HPET_T1_CFG);
1179         cfg &= ~HPET_TN_PERIODIC;
1180         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
1181         hpet_writel(cfg, HPET_T1_CFG);
1182
1183         local_irq_restore(flags);
1184
1185         return 1;
1186 }
1187
1188 static void hpet_rtc_timer_reinit(void)
1189 {
1190         unsigned int cfg, cnt, ticks_per_int, lost_ints;
1191
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);
1196                 return;
1197         }
1198
1199         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1200                 hpet_rtc_int_freq = PIE_freq;
1201         else
1202                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1203
1204         /* It is more accurate to use the comparator value than current count.*/
1205         ticks_per_int = hpet_tick * HZ / hpet_rtc_int_freq;
1206         hpet_t1_cmp += ticks_per_int;
1207         hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
1208
1209         /*
1210          * If the interrupt handler was delayed too long, the write above tries
1211          * to schedule the next interrupt in the past and the hardware would
1212          * not interrupt until the counter had wrapped around.
1213          * So we have to check that the comparator wasn't set to a past time.
1214          */
1215         cnt = hpet_readl(HPET_COUNTER);
1216         if (unlikely((int)(cnt - hpet_t1_cmp) > 0)) {
1217                 lost_ints = (cnt - hpet_t1_cmp) / ticks_per_int + 1;
1218                 /* Make sure that, even with the time needed to execute
1219                  * this code, the next scheduled interrupt has been moved
1220                  * back to the future: */
1221                 lost_ints++;
1222
1223                 hpet_t1_cmp += lost_ints * ticks_per_int;
1224                 hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
1225
1226                 if (PIE_on)
1227                         PIE_count += lost_ints;
1228
1229                 if (printk_ratelimit())
1230                         printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
1231                                hpet_rtc_int_freq);
1232         }
1233 }
1234
1235 /*
1236  * The functions below are called from rtc driver.
1237  * Return 0 if HPET is not being used.
1238  * Otherwise do the necessary changes and return 1.
1239  */
1240 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
1241 {
1242         if (!is_hpet_enabled())
1243                 return 0;
1244
1245         if (bit_mask & RTC_UIE)
1246                 UIE_on = 0;
1247         if (bit_mask & RTC_PIE)
1248                 PIE_on = 0;
1249         if (bit_mask & RTC_AIE)
1250                 AIE_on = 0;
1251
1252         return 1;
1253 }
1254
1255 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
1256 {
1257         int timer_init_reqd = 0;
1258
1259         if (!is_hpet_enabled())
1260                 return 0;
1261
1262         if (!(PIE_on | AIE_on | UIE_on))
1263                 timer_init_reqd = 1;
1264
1265         if (bit_mask & RTC_UIE) {
1266                 UIE_on = 1;
1267         }
1268         if (bit_mask & RTC_PIE) {
1269                 PIE_on = 1;
1270                 PIE_count = 0;
1271         }
1272         if (bit_mask & RTC_AIE) {
1273                 AIE_on = 1;
1274         }
1275
1276         if (timer_init_reqd)
1277                 hpet_rtc_timer_init();
1278
1279         return 1;
1280 }
1281
1282 int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
1283 {
1284         if (!is_hpet_enabled())
1285                 return 0;
1286
1287         alarm_time.tm_hour = hrs;
1288         alarm_time.tm_min = min;
1289         alarm_time.tm_sec = sec;
1290
1291         return 1;
1292 }
1293
1294 int hpet_set_periodic_freq(unsigned long freq)
1295 {
1296         if (!is_hpet_enabled())
1297                 return 0;
1298
1299         PIE_freq = freq;
1300         PIE_count = 0;
1301
1302         return 1;
1303 }
1304
1305 int hpet_rtc_dropped_irq(void)
1306 {
1307         if (!is_hpet_enabled())
1308                 return 0;
1309
1310         return 1;
1311 }
1312
1313 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1314 {
1315         struct rtc_time curr_time;
1316         unsigned long rtc_int_flag = 0;
1317         int call_rtc_interrupt = 0;
1318
1319         hpet_rtc_timer_reinit();
1320
1321         if (UIE_on | AIE_on) {
1322                 rtc_get_rtc_time(&curr_time);
1323         }
1324         if (UIE_on) {
1325                 if (curr_time.tm_sec != prev_update_sec) {
1326                         /* Set update int info, call real rtc int routine */
1327                         call_rtc_interrupt = 1;
1328                         rtc_int_flag = RTC_UF;
1329                         prev_update_sec = curr_time.tm_sec;
1330                 }
1331         }
1332         if (PIE_on) {
1333                 PIE_count++;
1334                 if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
1335                         /* Set periodic int info, call real rtc int routine */
1336                         call_rtc_interrupt = 1;
1337                         rtc_int_flag |= RTC_PF;
1338                         PIE_count = 0;
1339                 }
1340         }
1341         if (AIE_on) {
1342                 if ((curr_time.tm_sec == alarm_time.tm_sec) &&
1343                     (curr_time.tm_min == alarm_time.tm_min) &&
1344                     (curr_time.tm_hour == alarm_time.tm_hour)) {
1345                         /* Set alarm int info, call real rtc int routine */
1346                         call_rtc_interrupt = 1;
1347                         rtc_int_flag |= RTC_AF;
1348                 }
1349         }
1350         if (call_rtc_interrupt) {
1351                 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
1352                 rtc_interrupt(rtc_int_flag, dev_id);
1353         }
1354         return IRQ_HANDLED;
1355 }
1356 #endif
1357
1358 static int __init nohpet_setup(char *s)
1359 {
1360         nohpet = 1;
1361         return 1;
1362 }
1363
1364 __setup("nohpet", nohpet_setup);
1365
1366 int __init notsc_setup(char *s)
1367 {
1368         notsc = 1;
1369         return 1;
1370 }
1371
1372 __setup("notsc", notsc_setup);