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