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