[PATCH] Add the vgetcpu vsyscall
[linux-2.6.git] / 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 #ifdef CONFIG_X86_LOCAL_APIC
45 #include <asm/apic.h>
46 #endif
47
48 #ifdef CONFIG_CPU_FREQ
49 static void cpufreq_delayed_get(void);
50 #endif
51 extern void i8254_timer_resume(void);
52 extern int using_apic_timer;
53
54 static char *timename = NULL;
55
56 DEFINE_SPINLOCK(rtc_lock);
57 EXPORT_SYMBOL(rtc_lock);
58 DEFINE_SPINLOCK(i8253_lock);
59
60 int nohpet __initdata = 0;
61 static int notsc __initdata = 0;
62
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)
66
67 #define NS_SCALE        10 /* 2^10, carefully chosen */
68 #define US_SCALE        32 /* 2^32, arbitralrily chosen */
69
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;
78
79 struct vxtime_data __vxtime __section_vxtime;   /* for vsyscalls */
80
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;
85
86 /*
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.
94  */
95
96 static inline unsigned int do_gettimeoffset_tsc(void)
97 {
98         unsigned long t;
99         unsigned long x;
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;
104         return x;
105 }
106
107 static inline unsigned int do_gettimeoffset_hpet(void)
108 {
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;
112 }
113
114 unsigned int (*do_gettimeoffset)(void) = do_gettimeoffset_tsc;
115
116 /*
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
119  * MHz) HPET timer.
120  */
121
122 void do_gettimeofday(struct timeval *tv)
123 {
124         unsigned long seq, t;
125         unsigned int sec, usec;
126
127         do {
128                 seq = read_seqbegin(&xtime_lock);
129
130                 sec = xtime.tv_sec;
131                 usec = xtime.tv_nsec / NSEC_PER_USEC;
132
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 */ 
141
142                 t = (jiffies - wall_jiffies) * USEC_PER_TICK +
143                         do_gettimeoffset();
144                 usec += t;
145
146         } while (read_seqretry(&xtime_lock, seq));
147
148         tv->tv_sec = sec + usec / USEC_PER_SEC;
149         tv->tv_usec = usec % USEC_PER_SEC;
150 }
151
152 EXPORT_SYMBOL(do_gettimeofday);
153
154 /*
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
157  * ages already.
158  */
159
160 int do_settimeofday(struct timespec *tv)
161 {
162         time_t wtm_sec, sec = tv->tv_sec;
163         long wtm_nsec, nsec = tv->tv_nsec;
164
165         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
166                 return -EINVAL;
167
168         write_seqlock_irq(&xtime_lock);
169
170         nsec -= do_gettimeoffset() * NSEC_PER_USEC +
171                 (jiffies - wall_jiffies) * NSEC_PER_TICK;
172
173         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
174         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
175
176         set_normalized_timespec(&xtime, sec, nsec);
177         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
178
179         ntp_clear();
180
181         write_sequnlock_irq(&xtime_lock);
182         clock_was_set();
183         return 0;
184 }
185
186 EXPORT_SYMBOL(do_settimeofday);
187
188 unsigned long profile_pc(struct pt_regs *regs)
189 {
190         unsigned long pc = instruction_pointer(regs);
191
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 
194            text address.
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];
206         }
207         return pc;
208 }
209 EXPORT_SYMBOL(profile_pc);
210
211 /*
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
216  * sheet for details.
217  */
218
219 static void set_rtc_mmss(unsigned long nowtime)
220 {
221         int real_seconds, real_minutes, cmos_minutes;
222         unsigned char control, freq_select;
223
224 /*
225  * IRQs are disabled when we're called from the timer interrupt,
226  * no need for spin_lock_irqsave()
227  */
228
229         spin_lock(&rtc_lock);
230
231 /*
232  * Tell the clock it's being set and stop it.
233  */
234
235         control = CMOS_READ(RTC_CONTROL);
236         CMOS_WRITE(control | RTC_SET, RTC_CONTROL);
237
238         freq_select = CMOS_READ(RTC_FREQ_SELECT);
239         CMOS_WRITE(freq_select | RTC_DIV_RESET2, RTC_FREQ_SELECT);
240
241         cmos_minutes = CMOS_READ(RTC_MINUTES);
242                 BCD_TO_BIN(cmos_minutes);
243
244 /*
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.
249  */
250
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 */
255         real_minutes %= 60;
256
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);
260         } else {
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);
265         }
266
267 /*
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
273  */
274
275         CMOS_WRITE(control, RTC_CONTROL);
276         CMOS_WRITE(freq_select, RTC_FREQ_SELECT);
277
278         spin_unlock(&rtc_lock);
279 }
280
281
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.
285  */
286 unsigned long long monotonic_clock(void)
287 {
288         unsigned long seq;
289         u32 last_offset, this_offset, offset;
290         unsigned long long base;
291
292         if (vxtime.mode == VXTIME_HPET) {
293                 do {
294                         seq = read_seqbegin(&xtime_lock);
295
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;
302         } else {
303                 do {
304                         seq = read_seqbegin(&xtime_lock);
305
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;
312         }
313         return base + offset;
314 }
315 EXPORT_SYMBOL(monotonic_clock);
316
317 static noinline void handle_lost_ticks(int lost, struct pt_regs *regs)
318 {
319         static long lost_count;
320         static int warned;
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);
324         }
325
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");
333                         if (hpet_use_timer)
334                                 vxtime.last = hpet_readl(HPET_T0_CMP) - 
335                                                         hpet_tick;
336                         else
337                                 vxtime.last = hpet_readl(HPET_COUNTER);
338                         vxtime.mode = VXTIME_HPET;
339                         do_gettimeoffset = do_gettimeoffset_hpet;
340                 }
341                 /* else should fall back to PIT, but code missing. */
342                 warned = 1;
343         } else
344                 lost_count++;
345
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();
351 #endif
352 }
353
354 void main_timer_handler(struct pt_regs *regs)
355 {
356         static unsigned long rtc_update = 0;
357         unsigned long tsc;
358         int delay = 0, offset = 0, lost = 0;
359
360 /*
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
365  */
366
367         write_seqlock(&xtime_lock);
368
369         if (vxtime.hpet_address)
370                 offset = hpet_readl(HPET_COUNTER);
371
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.
376                  */
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);
381                 outb_p(0x00, 0x43);
382                 delay = inb_p(0x40);
383                 delay |= inb(0x40) << 8;
384                 spin_unlock(&i8253_lock);
385                 delay = LATCH - 1 - delay;
386         }
387
388         tsc = get_cycles_sync();
389
390         if (vxtime.mode == VXTIME_HPET) {
391                 if (offset - vxtime.last > hpet_tick) {
392                         lost = (offset - vxtime.last) / hpet_tick - 1;
393                 }
394
395                 monotonic_base += 
396                         (offset - vxtime.last) * NSEC_PER_TICK / hpet_tick;
397
398                 vxtime.last = offset;
399 #ifdef CONFIG_X86_PM_TIMER
400         } else if (vxtime.mode == VXTIME_PMTMR) {
401                 lost = pmtimer_mark_offset();
402 #endif
403         } else {
404                 offset = (((tsc - vxtime.last_tsc) *
405                            vxtime.tsc_quot) >> US_SCALE) - USEC_PER_TICK;
406
407                 if (offset < 0)
408                         offset = 0;
409
410                 if (offset > USEC_PER_TICK) {
411                         lost = offset / USEC_PER_TICK;
412                         offset %= USEC_PER_TICK;
413                 }
414
415                 /* FIXME: 1000 or 1000000? */
416                 monotonic_base += (tsc - vxtime.last_tsc) * 1000000 / cpu_khz;
417
418                 vxtime.last_tsc = tsc - vxtime.quot * delay / vxtime.tsc_quot;
419
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;
424         }
425
426         if (lost > 0) {
427                 handle_lost_ticks(lost, regs);
428                 jiffies += lost;
429         }
430
431 /*
432  * Do the timer stuff.
433  */
434
435         do_timer(regs);
436 #ifndef CONFIG_SMP
437         update_process_times(user_mode(regs));
438 #endif
439
440 /*
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.
444  */
445
446 #ifndef CONFIG_X86_LOCAL_APIC
447         profile_tick(CPU_PROFILING, regs);
448 #else
449         if (!using_apic_timer)
450                 smp_local_timer_interrupt(regs);
451 #endif
452
453 /*
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.
459  */
460
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;
465         }
466  
467         write_sequnlock(&xtime_lock);
468 }
469
470 static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
471 {
472         if (apic_runs_main_timer > 1)
473                 return IRQ_HANDLED;
474         main_timer_handler(regs);
475 #ifdef CONFIG_X86_LOCAL_APIC
476         if (using_apic_timer)
477                 smp_send_timer_broadcast_ipi();
478 #endif
479         return IRQ_HANDLED;
480 }
481
482 static unsigned int cyc2ns_scale __read_mostly;
483
484 static inline void set_cyc2ns_scale(unsigned long cpu_khz)
485 {
486         cyc2ns_scale = (NSEC_PER_MSEC << NS_SCALE) / cpu_khz;
487 }
488
489 static inline unsigned long long cycles_2_ns(unsigned long long cyc)
490 {
491         return (cyc * cyc2ns_scale) >> NS_SCALE;
492 }
493
494 unsigned long long sched_clock(void)
495 {
496         unsigned long a = 0;
497
498 #if 0
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;
505 #endif
506
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
510            purposes. */
511
512         rdtscll(a);
513         return cycles_2_ns(a);
514 }
515
516 static unsigned long get_cmos_time(void)
517 {
518         unsigned int year, mon, day, hour, min, sec;
519         unsigned long flags;
520         unsigned extyear = 0;
521
522         spin_lock_irqsave(&rtc_lock, flags);
523
524         do {
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);
531 #ifdef CONFIG_ACPI
532                 if (acpi_fadt.revision >= FADT2_REVISION_ID &&
533                                         acpi_fadt.century)
534                         extyear = CMOS_READ(acpi_fadt.century);
535 #endif
536         } while (sec != CMOS_READ(RTC_SECONDS));
537
538         spin_unlock_irqrestore(&rtc_lock, flags);
539
540         /*
541          * We know that x86-64 always uses BCD format, no need to check the
542          * config register.
543          */
544
545         BCD_TO_BIN(sec);
546         BCD_TO_BIN(min);
547         BCD_TO_BIN(hour);
548         BCD_TO_BIN(day);
549         BCD_TO_BIN(mon);
550         BCD_TO_BIN(year);
551
552         if (extyear) {
553                 BCD_TO_BIN(extyear);
554                 year += extyear;
555                 printk(KERN_INFO "Extended CMOS year: %d\n", extyear);
556         } else { 
557                 /*
558                  * x86-64 systems only exists since 2002.
559                  * This will work up to Dec 31, 2100
560                  */
561                 year += 2000;
562         }
563
564         return mktime(year, mon, day, hour, min, sec);
565 }
566
567 #ifdef CONFIG_CPU_FREQ
568
569 /* Frequency scaling support. Adjust the TSC based timer when the cpu frequency
570    changes.
571    
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.
575
576    Should fix up last_tsc too. Currently gettimeofday in the
577    first tick after the change will be slightly wrong. */
578
579 #include <linux/workqueue.h>
580
581 static unsigned int cpufreq_delayed_issched = 0;
582 static unsigned int cpufreq_init = 0;
583 static struct work_struct cpufreq_delayed_get_work;
584
585 static void handle_cpufreq_delayed_get(void *v)
586 {
587         unsigned int cpu;
588         for_each_online_cpu(cpu) {
589                 cpufreq_get(cpu);
590         }
591         cpufreq_delayed_issched = 0;
592 }
593
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.
597  */
598 static void cpufreq_delayed_get(void)
599 {
600         static int warned;
601         if (cpufreq_init && !cpufreq_delayed_issched) {
602                 cpufreq_delayed_issched = 1;
603                 if (!warned) {
604                         warned = 1;
605                         printk(KERN_DEBUG 
606         "Losing some ticks... checking if CPU frequency changed.\n");
607                 }
608                 schedule_work(&cpufreq_delayed_get_work);
609         }
610 }
611
612 static unsigned int  ref_freq = 0;
613 static unsigned long loops_per_jiffy_ref = 0;
614
615 static unsigned long cpu_khz_ref = 0;
616
617 static int time_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
618                                  void *data)
619 {
620         struct cpufreq_freqs *freq = data;
621         unsigned long *lpj, dummy;
622
623         if (cpu_has(&cpu_data[freq->cpu], X86_FEATURE_CONSTANT_TSC))
624                 return 0;
625
626         lpj = &dummy;
627         if (!(freq->flags & CPUFREQ_CONST_LOOPS))
628 #ifdef CONFIG_SMP
629                 lpj = &cpu_data[freq->cpu].loops_per_jiffy;
630 #else
631                 lpj = &boot_cpu_data.loops_per_jiffy;
632 #endif
633
634         if (!ref_freq) {
635                 ref_freq = freq->old;
636                 loops_per_jiffy_ref = *lpj;
637                 cpu_khz_ref = cpu_khz;
638         }
639         if ((val == CPUFREQ_PRECHANGE  && freq->old < freq->new) ||
640             (val == CPUFREQ_POSTCHANGE && freq->old > freq->new) ||
641             (val == CPUFREQ_RESUMECHANGE)) {
642                 *lpj =
643                 cpufreq_scale(loops_per_jiffy_ref, ref_freq, freq->new);
644
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;
648         }
649         
650         set_cyc2ns_scale(cpu_khz_ref);
651
652         return 0;
653 }
654  
655 static struct notifier_block time_cpufreq_notifier_block = {
656          .notifier_call  = time_cpufreq_notifier
657 };
658
659 static int __init cpufreq_tsc(void)
660 {
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))
664                 cpufreq_init = 1;
665         return 0;
666 }
667
668 core_initcall(cpufreq_tsc);
669
670 #endif
671
672 /*
673  * calibrate_tsc() calibrates the processor TSC in a very simple way, comparing
674  * it to the HPET timer of known frequency.
675  */
676
677 #define TICK_COUNT 100000000
678
679 static unsigned int __init hpet_calibrate_tsc(void)
680 {
681         int tsc_start, hpet_start;
682         int tsc_now, hpet_now;
683         unsigned long flags;
684
685         local_irq_save(flags);
686         local_irq_disable();
687
688         hpet_start = hpet_readl(HPET_COUNTER);
689         rdtscl(tsc_start);
690
691         do {
692                 local_irq_disable();
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);
698
699         return (tsc_now - tsc_start) * 1000000000L
700                 / ((hpet_now - hpet_start) * hpet_period / 1000);
701 }
702
703
704 /*
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.
710  */
711
712 static unsigned int __init pit_calibrate_tsc(void)
713 {
714         unsigned long start, end;
715         unsigned long flags;
716
717         spin_lock_irqsave(&i8253_lock, flags);
718
719         outb((inb(0x61) & ~0x02) | 0x01, 0x61);
720
721         outb(0xb0, 0x43);
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();
727
728         spin_unlock_irqrestore(&i8253_lock, flags);
729         
730         return (end - start) / 50;
731 }
732
733 #ifdef  CONFIG_HPET
734 static __init int late_hpet_init(void)
735 {
736         struct hpet_data        hd;
737         unsigned int            ntimer;
738
739         if (!vxtime.hpet_address)
740                 return 0;
741
742         memset(&hd, 0, sizeof (hd));
743
744         ntimer = hpet_readl(HPET_ID);
745         ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
746         ntimer++;
747
748         /*
749          * Register with driver.
750          * Timer0 and Timer1 is used by platform.
751          */
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);
759 #endif
760         hd.hd_irq[0] = HPET_LEGACY_8254;
761         hd.hd_irq[1] = HPET_LEGACY_RTC;
762         if (ntimer > 2) {
763                 struct hpet             *hpet;
764                 struct hpet_timer       *timer;
765                 int                     i;
766
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;
773
774         }
775
776         hpet_alloc(&hd);
777         return 0;
778 }
779 fs_initcall(late_hpet_init);
780 #endif
781
782 static int hpet_timer_stop_set_go(unsigned long tick)
783 {
784         unsigned int cfg;
785
786 /*
787  * Stop the timers and reset the main counter.
788  */
789
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);
795
796 /*
797  * Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
798  * and period also hpet_tick.
799  */
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;
806         }
807 /*
808  * Go!
809  */
810
811         cfg |= HPET_CFG_ENABLE;
812         hpet_writel(cfg, HPET_CFG);
813
814         return 0;
815 }
816
817 static int hpet_init(void)
818 {
819         unsigned int id;
820
821         if (!vxtime.hpet_address)
822                 return -1;
823         set_fixmap_nocache(FIX_HPET_BASE, vxtime.hpet_address);
824         __set_fixmap(VSYSCALL_HPET, vxtime.hpet_address, PAGE_KERNEL_VSYSCALL_NOCACHE);
825
826 /*
827  * Read the period, compute tick and quotient.
828  */
829
830         id = hpet_readl(HPET_ID);
831
832         if (!(id & HPET_ID_VENDOR) || !(id & HPET_ID_NUMBER))
833                 return -1;
834
835         hpet_period = hpet_readl(HPET_PERIOD);
836         if (hpet_period < 100000 || hpet_period > 100000000)
837                 return -1;
838
839         hpet_tick = (FSEC_PER_TICK + hpet_period / 2) / hpet_period;
840
841         hpet_use_timer = (id & HPET_ID_LEGSUP);
842
843         return hpet_timer_stop_set_go(hpet_tick);
844 }
845
846 static int hpet_reenable(void)
847 {
848         return hpet_timer_stop_set_go(hpet_tick);
849 }
850
851 #define PIT_MODE 0x43
852 #define PIT_CH0  0x40
853
854 static void __init __pit_init(int val, u8 mode)
855 {
856         unsigned long flags;
857
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);
863 }
864
865 void __init pit_init(void)
866 {
867         __pit_init(LATCH, 0x34); /* binary, mode 2, LSB/MSB, ch 0 */
868 }
869
870 void __init pit_stop_interrupt(void)
871 {
872         __pit_init(0, 0x30); /* mode 0 */
873 }
874
875 void __init stop_timer_interrupt(void)
876 {
877         char *name;
878         if (vxtime.hpet_address) {
879                 name = "HPET";
880                 hpet_timer_stop_set_go(0);
881         } else {
882                 name = "PIT";
883                 pit_stop_interrupt();
884         }
885         printk(KERN_INFO "timer: %s interrupt stopped.\n", name);
886 }
887
888 int __init time_setup(char *str)
889 {
890         report_lost_ticks = 1;
891         return 1;
892 }
893
894 static struct irqaction irq0 = {
895         timer_interrupt, IRQF_DISABLED, CPU_MASK_NONE, "timer", NULL, NULL
896 };
897
898 static int __cpuinit
899 time_cpu_notifier(struct notifier_block *nb, unsigned long action, void *hcpu)
900 {
901         unsigned cpu = (unsigned long) hcpu;
902         if (action == CPU_ONLINE)
903                 vsyscall_set_cpu(cpu);
904         return NOTIFY_DONE;
905 }
906
907 void __init time_init(void)
908 {
909         if (nohpet)
910                 vxtime.hpet_address = 0;
911
912         xtime.tv_sec = get_cmos_time();
913         xtime.tv_nsec = 0;
914
915         set_normalized_timespec(&wall_to_monotonic,
916                                 -xtime.tv_sec, -xtime.tv_nsec);
917
918         if (!hpet_init())
919                 vxtime_hz = (FSEC_PER_SEC + hpet_period / 2) / hpet_period;
920         else
921                 vxtime.hpet_address = 0;
922
923         if (hpet_use_timer) {
924                 /* set tick_nsec to use the proper rate for HPET */
925                 tick_nsec = TICK_NSEC_HPET;
926                 cpu_khz = hpet_calibrate_tsc();
927                 timename = "HPET";
928 #ifdef CONFIG_X86_PM_TIMER
929         } else if (pmtmr_ioport && !vxtime.hpet_address) {
930                 vxtime_hz = PM_TIMER_FREQUENCY;
931                 timename = "PM";
932                 pit_init();
933                 cpu_khz = pit_calibrate_tsc();
934 #endif
935         } else {
936                 pit_init();
937                 cpu_khz = pit_calibrate_tsc();
938                 timename = "PIT";
939         }
940
941         vxtime.mode = VXTIME_TSC;
942         vxtime.quot = (USEC_PER_SEC << US_SCALE) / vxtime_hz;
943         vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
944         vxtime.last_tsc = get_cycles_sync();
945         setup_irq(0, &irq0);
946
947         set_cyc2ns_scale(cpu_khz);
948
949         hotcpu_notifier(time_cpu_notifier, 0);
950         time_cpu_notifier(NULL, CPU_ONLINE, (void *)(long)smp_processor_id());
951
952 #ifndef CONFIG_SMP
953         time_init_gtod();
954 #endif
955 }
956
957 /*
958  * Make an educated guess if the TSC is trustworthy and synchronized
959  * over all CPUs.
960  */
961 __cpuinit int unsynchronized_tsc(void)
962 {
963 #ifdef CONFIG_SMP
964         if (apic_is_clustered_box())
965                 return 1;
966 #endif
967         /* Most intel systems have synchronized TSCs except for
968            multi node systems */
969         if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) {
970 #ifdef CONFIG_ACPI
971                 /* But TSC doesn't tick in C3 so don't use it there */
972                 if (acpi_fadt.length > 0 && acpi_fadt.plvl3_lat < 100)
973                         return 1;
974 #endif
975                 return 0;
976         }
977
978         /* Assume multi socket systems are not synchronized */
979         return num_present_cpus() > 1;
980 }
981
982 /*
983  * Decide what mode gettimeofday should use.
984  */
985 void time_init_gtod(void)
986 {
987         char *timetype;
988
989         if (unsynchronized_tsc())
990                 notsc = 1;
991
992         if (cpu_has(&boot_cpu_data, X86_FEATURE_RDTSCP))
993                 vgetcpu_mode = VGETCPU_RDTSCP;
994         else
995                 vgetcpu_mode = VGETCPU_LSL;
996
997         if (vxtime.hpet_address && notsc) {
998                 timetype = hpet_use_timer ? "HPET" : "PIT/HPET";
999                 if (hpet_use_timer)
1000                         vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
1001                 else
1002                         vxtime.last = hpet_readl(HPET_COUNTER);
1003                 vxtime.mode = VXTIME_HPET;
1004                 do_gettimeoffset = do_gettimeoffset_hpet;
1005 #ifdef CONFIG_X86_PM_TIMER
1006         /* Using PM for gettimeofday is quite slow, but we have no other
1007            choice because the TSC is too unreliable on some systems. */
1008         } else if (pmtmr_ioport && !vxtime.hpet_address && notsc) {
1009                 timetype = "PM";
1010                 do_gettimeoffset = do_gettimeoffset_pm;
1011                 vxtime.mode = VXTIME_PMTMR;
1012                 sysctl_vsyscall = 0;
1013                 printk(KERN_INFO "Disabling vsyscall due to use of PM timer\n");
1014 #endif
1015         } else {
1016                 timetype = hpet_use_timer ? "HPET/TSC" : "PIT/TSC";
1017                 vxtime.mode = VXTIME_TSC;
1018         }
1019
1020         printk(KERN_INFO "time.c: Using %ld.%06ld MHz WALL %s GTOD %s timer.\n",
1021                vxtime_hz / 1000000, vxtime_hz % 1000000, timename, timetype);
1022         printk(KERN_INFO "time.c: Detected %d.%03d MHz processor.\n",
1023                 cpu_khz / 1000, cpu_khz % 1000);
1024         vxtime.quot = (USEC_PER_SEC << US_SCALE) / vxtime_hz;
1025         vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
1026         vxtime.last_tsc = get_cycles_sync();
1027
1028         set_cyc2ns_scale(cpu_khz);
1029 }
1030
1031 __setup("report_lost_ticks", time_setup);
1032
1033 static long clock_cmos_diff;
1034 static unsigned long sleep_start;
1035
1036 /*
1037  * sysfs support for the timer.
1038  */
1039
1040 static int timer_suspend(struct sys_device *dev, pm_message_t state)
1041 {
1042         /*
1043          * Estimate time zone so that set_time can update the clock
1044          */
1045         long cmos_time =  get_cmos_time();
1046
1047         clock_cmos_diff = -cmos_time;
1048         clock_cmos_diff += get_seconds();
1049         sleep_start = cmos_time;
1050         return 0;
1051 }
1052
1053 static int timer_resume(struct sys_device *dev)
1054 {
1055         unsigned long flags;
1056         unsigned long sec;
1057         unsigned long ctime = get_cmos_time();
1058         unsigned long sleep_length = (ctime - sleep_start) * HZ;
1059
1060         if (vxtime.hpet_address)
1061                 hpet_reenable();
1062         else
1063                 i8254_timer_resume();
1064
1065         sec = ctime + clock_cmos_diff;
1066         write_seqlock_irqsave(&xtime_lock,flags);
1067         xtime.tv_sec = sec;
1068         xtime.tv_nsec = 0;
1069         if (vxtime.mode == VXTIME_HPET) {
1070                 if (hpet_use_timer)
1071                         vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
1072                 else
1073                         vxtime.last = hpet_readl(HPET_COUNTER);
1074 #ifdef CONFIG_X86_PM_TIMER
1075         } else if (vxtime.mode == VXTIME_PMTMR) {
1076                 pmtimer_resume();
1077 #endif
1078         } else
1079                 vxtime.last_tsc = get_cycles_sync();
1080         write_sequnlock_irqrestore(&xtime_lock,flags);
1081         jiffies += sleep_length;
1082         wall_jiffies += sleep_length;
1083         monotonic_base += sleep_length * (NSEC_PER_SEC/HZ);
1084         touch_softlockup_watchdog();
1085         return 0;
1086 }
1087
1088 static struct sysdev_class timer_sysclass = {
1089         .resume = timer_resume,
1090         .suspend = timer_suspend,
1091         set_kset_name("timer"),
1092 };
1093
1094 /* XXX this driverfs stuff should probably go elsewhere later -john */
1095 static struct sys_device device_timer = {
1096         .id     = 0,
1097         .cls    = &timer_sysclass,
1098 };
1099
1100 static int time_init_device(void)
1101 {
1102         int error = sysdev_class_register(&timer_sysclass);
1103         if (!error)
1104                 error = sysdev_register(&device_timer);
1105         return error;
1106 }
1107
1108 device_initcall(time_init_device);
1109
1110 #ifdef CONFIG_HPET_EMULATE_RTC
1111 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
1112  * is enabled, we support RTC interrupt functionality in software.
1113  * RTC has 3 kinds of interrupts:
1114  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
1115  *    is updated
1116  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
1117  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
1118  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
1119  * (1) and (2) above are implemented using polling at a frequency of
1120  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
1121  * overhead. (DEFAULT_RTC_INT_FREQ)
1122  * For (3), we use interrupts at 64Hz or user specified periodic
1123  * frequency, whichever is higher.
1124  */
1125 #include <linux/rtc.h>
1126
1127 #define DEFAULT_RTC_INT_FREQ    64
1128 #define RTC_NUM_INTS            1
1129
1130 static unsigned long UIE_on;
1131 static unsigned long prev_update_sec;
1132
1133 static unsigned long AIE_on;
1134 static struct rtc_time alarm_time;
1135
1136 static unsigned long PIE_on;
1137 static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
1138 static unsigned long PIE_count;
1139
1140 static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
1141 static unsigned int hpet_t1_cmp; /* cached comparator register */
1142
1143 int is_hpet_enabled(void)
1144 {
1145         return vxtime.hpet_address != 0;
1146 }
1147
1148 /*
1149  * Timer 1 for RTC, we do not use periodic interrupt feature,
1150  * even if HPET supports periodic interrupts on Timer 1.
1151  * The reason being, to set up a periodic interrupt in HPET, we need to
1152  * stop the main counter. And if we do that everytime someone diables/enables
1153  * RTC, we will have adverse effect on main kernel timer running on Timer 0.
1154  * So, for the time being, simulate the periodic interrupt in software.
1155  *
1156  * hpet_rtc_timer_init() is called for the first time and during subsequent
1157  * interuppts reinit happens through hpet_rtc_timer_reinit().
1158  */
1159 int hpet_rtc_timer_init(void)
1160 {
1161         unsigned int cfg, cnt;
1162         unsigned long flags;
1163
1164         if (!is_hpet_enabled())
1165                 return 0;
1166         /*
1167          * Set the counter 1 and enable the interrupts.
1168          */
1169         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1170                 hpet_rtc_int_freq = PIE_freq;
1171         else
1172                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1173
1174         local_irq_save(flags);
1175         cnt = hpet_readl(HPET_COUNTER);
1176         cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
1177         hpet_writel(cnt, HPET_T1_CMP);
1178         hpet_t1_cmp = cnt;
1179         local_irq_restore(flags);
1180
1181         cfg = hpet_readl(HPET_T1_CFG);
1182         cfg &= ~HPET_TN_PERIODIC;
1183         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
1184         hpet_writel(cfg, HPET_T1_CFG);
1185
1186         return 1;
1187 }
1188
1189 static void hpet_rtc_timer_reinit(void)
1190 {
1191         unsigned int cfg, cnt;
1192
1193         if (unlikely(!(PIE_on | AIE_on | UIE_on))) {
1194                 cfg = hpet_readl(HPET_T1_CFG);
1195                 cfg &= ~HPET_TN_ENABLE;
1196                 hpet_writel(cfg, HPET_T1_CFG);
1197                 return;
1198         }
1199
1200         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1201                 hpet_rtc_int_freq = PIE_freq;
1202         else
1203                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1204
1205         /* It is more accurate to use the comparator value than current count.*/
1206         cnt = hpet_t1_cmp;
1207         cnt += hpet_tick*HZ/hpet_rtc_int_freq;
1208         hpet_writel(cnt, HPET_T1_CMP);
1209         hpet_t1_cmp = cnt;
1210 }
1211
1212 /*
1213  * The functions below are called from rtc driver.
1214  * Return 0 if HPET is not being used.
1215  * Otherwise do the necessary changes and return 1.
1216  */
1217 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
1218 {
1219         if (!is_hpet_enabled())
1220                 return 0;
1221
1222         if (bit_mask & RTC_UIE)
1223                 UIE_on = 0;
1224         if (bit_mask & RTC_PIE)
1225                 PIE_on = 0;
1226         if (bit_mask & RTC_AIE)
1227                 AIE_on = 0;
1228
1229         return 1;
1230 }
1231
1232 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
1233 {
1234         int timer_init_reqd = 0;
1235
1236         if (!is_hpet_enabled())
1237                 return 0;
1238
1239         if (!(PIE_on | AIE_on | UIE_on))
1240                 timer_init_reqd = 1;
1241
1242         if (bit_mask & RTC_UIE) {
1243                 UIE_on = 1;
1244         }
1245         if (bit_mask & RTC_PIE) {
1246                 PIE_on = 1;
1247                 PIE_count = 0;
1248         }
1249         if (bit_mask & RTC_AIE) {
1250                 AIE_on = 1;
1251         }
1252
1253         if (timer_init_reqd)
1254                 hpet_rtc_timer_init();
1255
1256         return 1;
1257 }
1258
1259 int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
1260 {
1261         if (!is_hpet_enabled())
1262                 return 0;
1263
1264         alarm_time.tm_hour = hrs;
1265         alarm_time.tm_min = min;
1266         alarm_time.tm_sec = sec;
1267
1268         return 1;
1269 }
1270
1271 int hpet_set_periodic_freq(unsigned long freq)
1272 {
1273         if (!is_hpet_enabled())
1274                 return 0;
1275
1276         PIE_freq = freq;
1277         PIE_count = 0;
1278
1279         return 1;
1280 }
1281
1282 int hpet_rtc_dropped_irq(void)
1283 {
1284         if (!is_hpet_enabled())
1285                 return 0;
1286
1287         return 1;
1288 }
1289
1290 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1291 {
1292         struct rtc_time curr_time;
1293         unsigned long rtc_int_flag = 0;
1294         int call_rtc_interrupt = 0;
1295
1296         hpet_rtc_timer_reinit();
1297
1298         if (UIE_on | AIE_on) {
1299                 rtc_get_rtc_time(&curr_time);
1300         }
1301         if (UIE_on) {
1302                 if (curr_time.tm_sec != prev_update_sec) {
1303                         /* Set update int info, call real rtc int routine */
1304                         call_rtc_interrupt = 1;
1305                         rtc_int_flag = RTC_UF;
1306                         prev_update_sec = curr_time.tm_sec;
1307                 }
1308         }
1309         if (PIE_on) {
1310                 PIE_count++;
1311                 if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
1312                         /* Set periodic int info, call real rtc int routine */
1313                         call_rtc_interrupt = 1;
1314                         rtc_int_flag |= RTC_PF;
1315                         PIE_count = 0;
1316                 }
1317         }
1318         if (AIE_on) {
1319                 if ((curr_time.tm_sec == alarm_time.tm_sec) &&
1320                     (curr_time.tm_min == alarm_time.tm_min) &&
1321                     (curr_time.tm_hour == alarm_time.tm_hour)) {
1322                         /* Set alarm int info, call real rtc int routine */
1323                         call_rtc_interrupt = 1;
1324                         rtc_int_flag |= RTC_AF;
1325                 }
1326         }
1327         if (call_rtc_interrupt) {
1328                 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
1329                 rtc_interrupt(rtc_int_flag, dev_id, regs);
1330         }
1331         return IRQ_HANDLED;
1332 }
1333 #endif
1334
1335 static int __init nohpet_setup(char *s) 
1336
1337         nohpet = 1;
1338         return 1;
1339
1340
1341 __setup("nohpet", nohpet_setup);
1342
1343 int __init notsc_setup(char *s)
1344 {
1345         notsc = 1;
1346         return 1;
1347 }
1348
1349 __setup("notsc", notsc_setup);