[PATCH] detect soft lockups
[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         touch_softlockup_watchdog();
1045         return 0;
1046 }
1047
1048 static struct sysdev_class timer_sysclass = {
1049         .resume = timer_resume,
1050         .suspend = timer_suspend,
1051         set_kset_name("timer"),
1052 };
1053
1054
1055 /* XXX this driverfs stuff should probably go elsewhere later -john */
1056 static struct sys_device device_timer = {
1057         .id     = 0,
1058         .cls    = &timer_sysclass,
1059 };
1060
1061 static int time_init_device(void)
1062 {
1063         int error = sysdev_class_register(&timer_sysclass);
1064         if (!error)
1065                 error = sysdev_register(&device_timer);
1066         return error;
1067 }
1068
1069 device_initcall(time_init_device);
1070
1071 #ifdef CONFIG_HPET_EMULATE_RTC
1072 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
1073  * is enabled, we support RTC interrupt functionality in software.
1074  * RTC has 3 kinds of interrupts:
1075  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
1076  *    is updated
1077  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
1078  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
1079  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
1080  * (1) and (2) above are implemented using polling at a frequency of
1081  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
1082  * overhead. (DEFAULT_RTC_INT_FREQ)
1083  * For (3), we use interrupts at 64Hz or user specified periodic
1084  * frequency, whichever is higher.
1085  */
1086 #include <linux/rtc.h>
1087
1088 extern irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
1089
1090 #define DEFAULT_RTC_INT_FREQ    64
1091 #define RTC_NUM_INTS            1
1092
1093 static unsigned long UIE_on;
1094 static unsigned long prev_update_sec;
1095
1096 static unsigned long AIE_on;
1097 static struct rtc_time alarm_time;
1098
1099 static unsigned long PIE_on;
1100 static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
1101 static unsigned long PIE_count;
1102
1103 static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
1104
1105 int is_hpet_enabled(void)
1106 {
1107         return vxtime.hpet_address != 0;
1108 }
1109
1110 /*
1111  * Timer 1 for RTC, we do not use periodic interrupt feature,
1112  * even if HPET supports periodic interrupts on Timer 1.
1113  * The reason being, to set up a periodic interrupt in HPET, we need to
1114  * stop the main counter. And if we do that everytime someone diables/enables
1115  * RTC, we will have adverse effect on main kernel timer running on Timer 0.
1116  * So, for the time being, simulate the periodic interrupt in software.
1117  *
1118  * hpet_rtc_timer_init() is called for the first time and during subsequent
1119  * interuppts reinit happens through hpet_rtc_timer_reinit().
1120  */
1121 int hpet_rtc_timer_init(void)
1122 {
1123         unsigned int cfg, cnt;
1124         unsigned long flags;
1125
1126         if (!is_hpet_enabled())
1127                 return 0;
1128         /*
1129          * Set the counter 1 and enable the interrupts.
1130          */
1131         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1132                 hpet_rtc_int_freq = PIE_freq;
1133         else
1134                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1135
1136         local_irq_save(flags);
1137         cnt = hpet_readl(HPET_COUNTER);
1138         cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
1139         hpet_writel(cnt, HPET_T1_CMP);
1140         local_irq_restore(flags);
1141
1142         cfg = hpet_readl(HPET_T1_CFG);
1143         cfg |= HPET_TN_ENABLE | HPET_TN_SETVAL | HPET_TN_32BIT;
1144         hpet_writel(cfg, HPET_T1_CFG);
1145
1146         return 1;
1147 }
1148
1149 static void hpet_rtc_timer_reinit(void)
1150 {
1151         unsigned int cfg, cnt;
1152
1153         if (!(PIE_on | AIE_on | UIE_on))
1154                 return;
1155
1156         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1157                 hpet_rtc_int_freq = PIE_freq;
1158         else
1159                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1160
1161         /* It is more accurate to use the comparator value than current count.*/
1162         cnt = hpet_readl(HPET_T1_CMP);
1163         cnt += hpet_tick*HZ/hpet_rtc_int_freq;
1164         hpet_writel(cnt, HPET_T1_CMP);
1165
1166         cfg = hpet_readl(HPET_T1_CFG);
1167         cfg |= HPET_TN_ENABLE | HPET_TN_SETVAL | HPET_TN_32BIT;
1168         hpet_writel(cfg, HPET_T1_CFG);
1169
1170         return;
1171 }
1172
1173 /*
1174  * The functions below are called from rtc driver.
1175  * Return 0 if HPET is not being used.
1176  * Otherwise do the necessary changes and return 1.
1177  */
1178 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
1179 {
1180         if (!is_hpet_enabled())
1181                 return 0;
1182
1183         if (bit_mask & RTC_UIE)
1184                 UIE_on = 0;
1185         if (bit_mask & RTC_PIE)
1186                 PIE_on = 0;
1187         if (bit_mask & RTC_AIE)
1188                 AIE_on = 0;
1189
1190         return 1;
1191 }
1192
1193 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
1194 {
1195         int timer_init_reqd = 0;
1196
1197         if (!is_hpet_enabled())
1198                 return 0;
1199
1200         if (!(PIE_on | AIE_on | UIE_on))
1201                 timer_init_reqd = 1;
1202
1203         if (bit_mask & RTC_UIE) {
1204                 UIE_on = 1;
1205         }
1206         if (bit_mask & RTC_PIE) {
1207                 PIE_on = 1;
1208                 PIE_count = 0;
1209         }
1210         if (bit_mask & RTC_AIE) {
1211                 AIE_on = 1;
1212         }
1213
1214         if (timer_init_reqd)
1215                 hpet_rtc_timer_init();
1216
1217         return 1;
1218 }
1219
1220 int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
1221 {
1222         if (!is_hpet_enabled())
1223                 return 0;
1224
1225         alarm_time.tm_hour = hrs;
1226         alarm_time.tm_min = min;
1227         alarm_time.tm_sec = sec;
1228
1229         return 1;
1230 }
1231
1232 int hpet_set_periodic_freq(unsigned long freq)
1233 {
1234         if (!is_hpet_enabled())
1235                 return 0;
1236
1237         PIE_freq = freq;
1238         PIE_count = 0;
1239
1240         return 1;
1241 }
1242
1243 int hpet_rtc_dropped_irq(void)
1244 {
1245         if (!is_hpet_enabled())
1246                 return 0;
1247
1248         return 1;
1249 }
1250
1251 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1252 {
1253         struct rtc_time curr_time;
1254         unsigned long rtc_int_flag = 0;
1255         int call_rtc_interrupt = 0;
1256
1257         hpet_rtc_timer_reinit();
1258
1259         if (UIE_on | AIE_on) {
1260                 rtc_get_rtc_time(&curr_time);
1261         }
1262         if (UIE_on) {
1263                 if (curr_time.tm_sec != prev_update_sec) {
1264                         /* Set update int info, call real rtc int routine */
1265                         call_rtc_interrupt = 1;
1266                         rtc_int_flag = RTC_UF;
1267                         prev_update_sec = curr_time.tm_sec;
1268                 }
1269         }
1270         if (PIE_on) {
1271                 PIE_count++;
1272                 if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
1273                         /* Set periodic int info, call real rtc int routine */
1274                         call_rtc_interrupt = 1;
1275                         rtc_int_flag |= RTC_PF;
1276                         PIE_count = 0;
1277                 }
1278         }
1279         if (AIE_on) {
1280                 if ((curr_time.tm_sec == alarm_time.tm_sec) &&
1281                     (curr_time.tm_min == alarm_time.tm_min) &&
1282                     (curr_time.tm_hour == alarm_time.tm_hour)) {
1283                         /* Set alarm int info, call real rtc int routine */
1284                         call_rtc_interrupt = 1;
1285                         rtc_int_flag |= RTC_AF;
1286                 }
1287         }
1288         if (call_rtc_interrupt) {
1289                 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
1290                 rtc_interrupt(rtc_int_flag, dev_id, regs);
1291         }
1292         return IRQ_HANDLED;
1293 }
1294 #endif
1295
1296
1297
1298 static int __init nohpet_setup(char *s) 
1299
1300         nohpet = 1;
1301         return 0;
1302
1303
1304 __setup("nohpet", nohpet_setup);
1305
1306
1307 static int __init notsc_setup(char *s)
1308 {
1309         notsc = 1;
1310         return 0;
1311 }
1312
1313 __setup("notsc", notsc_setup);
1314
1315