1dd50d07693cb9241ce1d064b589d5d4938c64ff
[linux-2.6.git] / arch / alpha / kernel / time.c
1 /*
2  *  linux/arch/alpha/kernel/time.c
3  *
4  *  Copyright (C) 1991, 1992, 1995, 1999, 2000  Linus Torvalds
5  *
6  * This file contains the PC-specific time handling details:
7  * reading the RTC at bootup, etc..
8  * 1994-07-02    Alan Modra
9  *      fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
10  * 1995-03-26    Markus Kuhn
11  *      fixed 500 ms bug at call to set_rtc_mmss, fixed DS12887
12  *      precision CMOS clock update
13  * 1997-09-10   Updated NTP code according to technical memorandum Jan '96
14  *              "A Kernel Model for Precision Timekeeping" by Dave Mills
15  * 1997-01-09    Adrian Sun
16  *      use interval timer if CONFIG_RTC=y
17  * 1997-10-29    John Bowman (bowman@math.ualberta.ca)
18  *      fixed tick loss calculation in timer_interrupt
19  *      (round system clock to nearest tick instead of truncating)
20  *      fixed algorithm in time_init for getting time from CMOS clock
21  * 1999-04-16   Thorsten Kranzkowski (dl8bcu@gmx.net)
22  *      fixed algorithm in do_gettimeofday() for calculating the precise time
23  *      from processor cycle counter (now taking lost_ticks into account)
24  * 2000-08-13   Jan-Benedict Glaw <jbglaw@lug-owl.de>
25  *      Fixed time_init to be aware of epoches != 1900. This prevents
26  *      booting up in 2048 for me;) Code is stolen from rtc.c.
27  * 2003-06-03   R. Scott Bailey <scott.bailey@eds.com>
28  *      Tighten sanity in time_init from 1% (10,000 PPM) to 250 PPM
29  */
30 #include <linux/errno.h>
31 #include <linux/module.h>
32 #include <linux/sched.h>
33 #include <linux/kernel.h>
34 #include <linux/param.h>
35 #include <linux/string.h>
36 #include <linux/mm.h>
37 #include <linux/delay.h>
38 #include <linux/ioport.h>
39 #include <linux/irq.h>
40 #include <linux/interrupt.h>
41 #include <linux/init.h>
42 #include <linux/bcd.h>
43 #include <linux/profile.h>
44
45 #include <asm/uaccess.h>
46 #include <asm/io.h>
47 #include <asm/hwrpb.h>
48 #include <asm/8253pit.h>
49
50 #include <linux/mc146818rtc.h>
51 #include <linux/time.h>
52 #include <linux/timex.h>
53
54 #include "proto.h"
55 #include "irq_impl.h"
56
57 static int set_rtc_mmss(unsigned long);
58
59 DEFINE_SPINLOCK(rtc_lock);
60 EXPORT_SYMBOL(rtc_lock);
61
62 #define TICK_SIZE (tick_nsec / 1000)
63
64 /*
65  * Shift amount by which scaled_ticks_per_cycle is scaled.  Shifting
66  * by 48 gives us 16 bits for HZ while keeping the accuracy good even
67  * for large CPU clock rates.
68  */
69 #define FIX_SHIFT       48
70
71 /* lump static variables together for more efficient access: */
72 static struct {
73         /* cycle counter last time it got invoked */
74         __u32 last_time;
75         /* ticks/cycle * 2^48 */
76         unsigned long scaled_ticks_per_cycle;
77         /* last time the CMOS clock got updated */
78         time_t last_rtc_update;
79         /* partial unused tick */
80         unsigned long partial_tick;
81 } state;
82
83 unsigned long est_cycle_freq;
84
85
86 static inline __u32 rpcc(void)
87 {
88     __u32 result;
89     asm volatile ("rpcc %0" : "=r"(result));
90     return result;
91 }
92
93 /*
94  * timer_interrupt() needs to keep up the real-time clock,
95  * as well as call the "do_timer()" routine every clocktick
96  */
97 irqreturn_t timer_interrupt(int irq, void *dev)
98 {
99         unsigned long delta;
100         __u32 now;
101         long nticks;
102
103 #ifndef CONFIG_SMP
104         /* Not SMP, do kernel PC profiling here.  */
105         profile_tick(CPU_PROFILING);
106 #endif
107
108         write_seqlock(&xtime_lock);
109
110         /*
111          * Calculate how many ticks have passed since the last update,
112          * including any previous partial leftover.  Save any resulting
113          * fraction for the next pass.
114          */
115         now = rpcc();
116         delta = now - state.last_time;
117         state.last_time = now;
118         delta = delta * state.scaled_ticks_per_cycle + state.partial_tick;
119         state.partial_tick = delta & ((1UL << FIX_SHIFT) - 1); 
120         nticks = delta >> FIX_SHIFT;
121
122         while (nticks > 0) {
123                 do_timer(1);
124 #ifndef CONFIG_SMP
125                 update_process_times(user_mode(get_irq_regs()));
126 #endif
127                 nticks--;
128         }
129
130         /*
131          * If we have an externally synchronized Linux clock, then update
132          * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
133          * called as close as possible to 500 ms before the new second starts.
134          */
135         if (ntp_synced()
136             && xtime.tv_sec > state.last_rtc_update + 660
137             && xtime.tv_nsec >= 500000 - ((unsigned) TICK_SIZE) / 2
138             && xtime.tv_nsec <= 500000 + ((unsigned) TICK_SIZE) / 2) {
139                 int tmp = set_rtc_mmss(xtime.tv_sec);
140                 state.last_rtc_update = xtime.tv_sec - (tmp ? 600 : 0);
141         }
142
143         write_sequnlock(&xtime_lock);
144         return IRQ_HANDLED;
145 }
146
147 void __init
148 common_init_rtc(void)
149 {
150         unsigned char x;
151
152         /* Reset periodic interrupt frequency.  */
153         x = CMOS_READ(RTC_FREQ_SELECT) & 0x3f;
154         /* Test includes known working values on various platforms
155            where 0x26 is wrong; we refuse to change those. */
156         if (x != 0x26 && x != 0x25 && x != 0x19 && x != 0x06) {
157                 printk("Setting RTC_FREQ to 1024 Hz (%x)\n", x);
158                 CMOS_WRITE(0x26, RTC_FREQ_SELECT);
159         }
160
161         /* Turn on periodic interrupts.  */
162         x = CMOS_READ(RTC_CONTROL);
163         if (!(x & RTC_PIE)) {
164                 printk("Turning on RTC interrupts.\n");
165                 x |= RTC_PIE;
166                 x &= ~(RTC_AIE | RTC_UIE);
167                 CMOS_WRITE(x, RTC_CONTROL);
168         }
169         (void) CMOS_READ(RTC_INTR_FLAGS);
170
171         outb(0x36, 0x43);       /* pit counter 0: system timer */
172         outb(0x00, 0x40);
173         outb(0x00, 0x40);
174
175         outb(0xb6, 0x43);       /* pit counter 2: speaker */
176         outb(0x31, 0x42);
177         outb(0x13, 0x42);
178
179         init_rtc_irq();
180 }
181
182
183 /* Validate a computed cycle counter result against the known bounds for
184    the given processor core.  There's too much brokenness in the way of
185    timing hardware for any one method to work everywhere.  :-(
186
187    Return 0 if the result cannot be trusted, otherwise return the argument.  */
188
189 static unsigned long __init
190 validate_cc_value(unsigned long cc)
191 {
192         static struct bounds {
193                 unsigned int min, max;
194         } cpu_hz[] __initdata = {
195                 [EV3_CPU]    = {   50000000,  200000000 },      /* guess */
196                 [EV4_CPU]    = {  100000000,  300000000 },
197                 [LCA4_CPU]   = {  100000000,  300000000 },      /* guess */
198                 [EV45_CPU]   = {  200000000,  300000000 },
199                 [EV5_CPU]    = {  250000000,  433000000 },
200                 [EV56_CPU]   = {  333000000,  667000000 },
201                 [PCA56_CPU]  = {  400000000,  600000000 },      /* guess */
202                 [PCA57_CPU]  = {  500000000,  600000000 },      /* guess */
203                 [EV6_CPU]    = {  466000000,  600000000 },
204                 [EV67_CPU]   = {  600000000,  750000000 },
205                 [EV68AL_CPU] = {  750000000,  940000000 },
206                 [EV68CB_CPU] = { 1000000000, 1333333333 },
207                 /* None of the following are shipping as of 2001-11-01.  */
208                 [EV68CX_CPU] = { 1000000000, 1700000000 },      /* guess */
209                 [EV69_CPU]   = { 1000000000, 1700000000 },      /* guess */
210                 [EV7_CPU]    = {  800000000, 1400000000 },      /* guess */
211                 [EV79_CPU]   = { 1000000000, 2000000000 },      /* guess */
212         };
213
214         /* Allow for some drift in the crystal.  10MHz is more than enough.  */
215         const unsigned int deviation = 10000000;
216
217         struct percpu_struct *cpu;
218         unsigned int index;
219
220         cpu = (struct percpu_struct *)((char*)hwrpb + hwrpb->processor_offset);
221         index = cpu->type & 0xffffffff;
222
223         /* If index out of bounds, no way to validate.  */
224         if (index >= ARRAY_SIZE(cpu_hz))
225                 return cc;
226
227         /* If index contains no data, no way to validate.  */
228         if (cpu_hz[index].max == 0)
229                 return cc;
230
231         if (cc < cpu_hz[index].min - deviation
232             || cc > cpu_hz[index].max + deviation)
233                 return 0;
234
235         return cc;
236 }
237
238
239 /*
240  * Calibrate CPU clock using legacy 8254 timer/counter. Stolen from
241  * arch/i386/time.c.
242  */
243
244 #define CALIBRATE_LATCH 0xffff
245 #define TIMEOUT_COUNT   0x100000
246
247 static unsigned long __init
248 calibrate_cc_with_pit(void)
249 {
250         int cc, count = 0;
251
252         /* Set the Gate high, disable speaker */
253         outb((inb(0x61) & ~0x02) | 0x01, 0x61);
254
255         /*
256          * Now let's take care of CTC channel 2
257          *
258          * Set the Gate high, program CTC channel 2 for mode 0,
259          * (interrupt on terminal count mode), binary count,
260          * load 5 * LATCH count, (LSB and MSB) to begin countdown.
261          */
262         outb(0xb0, 0x43);               /* binary, mode 0, LSB/MSB, Ch 2 */
263         outb(CALIBRATE_LATCH & 0xff, 0x42);     /* LSB of count */
264         outb(CALIBRATE_LATCH >> 8, 0x42);       /* MSB of count */
265
266         cc = rpcc();
267         do {
268                 count++;
269         } while ((inb(0x61) & 0x20) == 0 && count < TIMEOUT_COUNT);
270         cc = rpcc() - cc;
271
272         /* Error: ECTCNEVERSET or ECPUTOOFAST.  */
273         if (count <= 1 || count == TIMEOUT_COUNT)
274                 return 0;
275
276         return ((long)cc * PIT_TICK_RATE) / (CALIBRATE_LATCH + 1);
277 }
278
279 /* The Linux interpretation of the CMOS clock register contents:
280    When the Update-In-Progress (UIP) flag goes from 1 to 0, the
281    RTC registers show the second which has precisely just started.
282    Let's hope other operating systems interpret the RTC the same way.  */
283
284 static unsigned long __init
285 rpcc_after_update_in_progress(void)
286 {
287         do { } while (!(CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP));
288         do { } while (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
289
290         return rpcc();
291 }
292
293 void __init
294 time_init(void)
295 {
296         unsigned int year, mon, day, hour, min, sec, cc1, cc2, epoch;
297         unsigned long cycle_freq, tolerance;
298         long diff;
299
300         /* Calibrate CPU clock -- attempt #1.  */
301         if (!est_cycle_freq)
302                 est_cycle_freq = validate_cc_value(calibrate_cc_with_pit());
303
304         cc1 = rpcc();
305
306         /* Calibrate CPU clock -- attempt #2.  */
307         if (!est_cycle_freq) {
308                 cc1 = rpcc_after_update_in_progress();
309                 cc2 = rpcc_after_update_in_progress();
310                 est_cycle_freq = validate_cc_value(cc2 - cc1);
311                 cc1 = cc2;
312         }
313
314         cycle_freq = hwrpb->cycle_freq;
315         if (est_cycle_freq) {
316                 /* If the given value is within 250 PPM of what we calculated,
317                    accept it.  Otherwise, use what we found.  */
318                 tolerance = cycle_freq / 4000;
319                 diff = cycle_freq - est_cycle_freq;
320                 if (diff < 0)
321                         diff = -diff;
322                 if ((unsigned long)diff > tolerance) {
323                         cycle_freq = est_cycle_freq;
324                         printk("HWRPB cycle frequency bogus.  "
325                                "Estimated %lu Hz\n", cycle_freq);
326                 } else {
327                         est_cycle_freq = 0;
328                 }
329         } else if (! validate_cc_value (cycle_freq)) {
330                 printk("HWRPB cycle frequency bogus, "
331                        "and unable to estimate a proper value!\n");
332         }
333
334         /* From John Bowman <bowman@math.ualberta.ca>: allow the values
335            to settle, as the Update-In-Progress bit going low isn't good
336            enough on some hardware.  2ms is our guess; we haven't found 
337            bogomips yet, but this is close on a 500Mhz box.  */
338         __delay(1000000);
339
340         sec = CMOS_READ(RTC_SECONDS);
341         min = CMOS_READ(RTC_MINUTES);
342         hour = CMOS_READ(RTC_HOURS);
343         day = CMOS_READ(RTC_DAY_OF_MONTH);
344         mon = CMOS_READ(RTC_MONTH);
345         year = CMOS_READ(RTC_YEAR);
346
347         if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
348                 BCD_TO_BIN(sec);
349                 BCD_TO_BIN(min);
350                 BCD_TO_BIN(hour);
351                 BCD_TO_BIN(day);
352                 BCD_TO_BIN(mon);
353                 BCD_TO_BIN(year);
354         }
355
356         /* PC-like is standard; used for year >= 70 */
357         epoch = 1900;
358         if (year < 20)
359                 epoch = 2000;
360         else if (year >= 20 && year < 48)
361                 /* NT epoch */
362                 epoch = 1980;
363         else if (year >= 48 && year < 70)
364                 /* Digital UNIX epoch */
365                 epoch = 1952;
366
367         printk(KERN_INFO "Using epoch = %d\n", epoch);
368
369         if ((year += epoch) < 1970)
370                 year += 100;
371
372         xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
373         xtime.tv_nsec = 0;
374
375         wall_to_monotonic.tv_sec -= xtime.tv_sec;
376         wall_to_monotonic.tv_nsec = 0;
377
378         if (HZ > (1<<16)) {
379                 extern void __you_loose (void);
380                 __you_loose();
381         }
382
383         state.last_time = cc1;
384         state.scaled_ticks_per_cycle
385                 = ((unsigned long) HZ << FIX_SHIFT) / cycle_freq;
386         state.last_rtc_update = 0;
387         state.partial_tick = 0L;
388
389         /* Startup the timer source. */
390         alpha_mv.init_rtc();
391 }
392
393 /*
394  * Use the cycle counter to estimate an displacement from the last time
395  * tick.  Unfortunately the Alpha designers made only the low 32-bits of
396  * the cycle counter active, so we overflow on 8.2 seconds on a 500MHz
397  * part.  So we can't do the "find absolute time in terms of cycles" thing
398  * that the other ports do.
399  */
400 void
401 do_gettimeofday(struct timeval *tv)
402 {
403         unsigned long flags;
404         unsigned long sec, usec, seq;
405         unsigned long delta_cycles, delta_usec, partial_tick;
406
407         do {
408                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
409
410                 delta_cycles = rpcc() - state.last_time;
411                 sec = xtime.tv_sec;
412                 usec = (xtime.tv_nsec / 1000);
413                 partial_tick = state.partial_tick;
414
415         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
416
417 #ifdef CONFIG_SMP
418         /* Until and unless we figure out how to get cpu cycle counters
419            in sync and keep them there, we can't use the rpcc tricks.  */
420         delta_usec = 0;
421 #else
422         /*
423          * usec = cycles * ticks_per_cycle * 2**48 * 1e6 / (2**48 * ticks)
424          *      = cycles * (s_t_p_c) * 1e6 / (2**48 * ticks)
425          *      = cycles * (s_t_p_c) * 15625 / (2**42 * ticks)
426          *
427          * which, given a 600MHz cycle and a 1024Hz tick, has a
428          * dynamic range of about 1.7e17, which is less than the
429          * 1.8e19 in an unsigned long, so we are safe from overflow.
430          *
431          * Round, but with .5 up always, since .5 to even is harder
432          * with no clear gain.
433          */
434
435         delta_usec = (delta_cycles * state.scaled_ticks_per_cycle 
436                       + partial_tick) * 15625;
437         delta_usec = ((delta_usec / ((1UL << (FIX_SHIFT-6-1)) * HZ)) + 1) / 2;
438 #endif
439
440         usec += delta_usec;
441         if (usec >= 1000000) {
442                 sec += 1;
443                 usec -= 1000000;
444         }
445
446         tv->tv_sec = sec;
447         tv->tv_usec = usec;
448 }
449
450 EXPORT_SYMBOL(do_gettimeofday);
451
452 int
453 do_settimeofday(struct timespec *tv)
454 {
455         time_t wtm_sec, sec = tv->tv_sec;
456         long wtm_nsec, nsec = tv->tv_nsec;
457         unsigned long delta_nsec;
458
459         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
460                 return -EINVAL;
461
462         write_seqlock_irq(&xtime_lock);
463
464         /* The offset that is added into time in do_gettimeofday above
465            must be subtracted out here to keep a coherent view of the
466            time.  Without this, a full-tick error is possible.  */
467
468 #ifdef CONFIG_SMP
469         delta_nsec = 0;
470 #else
471         delta_nsec = rpcc() - state.last_time;
472         delta_nsec = (delta_nsec * state.scaled_ticks_per_cycle 
473                       + state.partial_tick) * 15625;
474         delta_nsec = ((delta_nsec / ((1UL << (FIX_SHIFT-6-1)) * HZ)) + 1) / 2;
475         delta_nsec *= 1000;
476 #endif
477
478         nsec -= delta_nsec;
479
480         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
481         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
482
483         set_normalized_timespec(&xtime, sec, nsec);
484         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
485
486         ntp_clear();
487
488         write_sequnlock_irq(&xtime_lock);
489         clock_was_set();
490         return 0;
491 }
492
493 EXPORT_SYMBOL(do_settimeofday);
494
495
496 /*
497  * In order to set the CMOS clock precisely, set_rtc_mmss has to be
498  * called 500 ms after the second nowtime has started, because when
499  * nowtime is written into the registers of the CMOS clock, it will
500  * jump to the next second precisely 500 ms later. Check the Motorola
501  * MC146818A or Dallas DS12887 data sheet for details.
502  *
503  * BUG: This routine does not handle hour overflow properly; it just
504  *      sets the minutes. Usually you won't notice until after reboot!
505  */
506
507
508 static int
509 set_rtc_mmss(unsigned long nowtime)
510 {
511         int retval = 0;
512         int real_seconds, real_minutes, cmos_minutes;
513         unsigned char save_control, save_freq_select;
514
515         /* irq are locally disabled here */
516         spin_lock(&rtc_lock);
517         /* Tell the clock it's being set */
518         save_control = CMOS_READ(RTC_CONTROL);
519         CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
520
521         /* Stop and reset prescaler */
522         save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
523         CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
524
525         cmos_minutes = CMOS_READ(RTC_MINUTES);
526         if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
527                 BCD_TO_BIN(cmos_minutes);
528
529         /*
530          * since we're only adjusting minutes and seconds,
531          * don't interfere with hour overflow. This avoids
532          * messing with unknown time zones but requires your
533          * RTC not to be off by more than 15 minutes
534          */
535         real_seconds = nowtime % 60;
536         real_minutes = nowtime / 60;
537         if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1) {
538                 /* correct for half hour time zone */
539                 real_minutes += 30;
540         }
541         real_minutes %= 60;
542
543         if (abs(real_minutes - cmos_minutes) < 30) {
544                 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
545                         BIN_TO_BCD(real_seconds);
546                         BIN_TO_BCD(real_minutes);
547                 }
548                 CMOS_WRITE(real_seconds,RTC_SECONDS);
549                 CMOS_WRITE(real_minutes,RTC_MINUTES);
550         } else {
551                 printk(KERN_WARNING
552                        "set_rtc_mmss: can't update from %d to %d\n",
553                        cmos_minutes, real_minutes);
554                 retval = -1;
555         }
556
557         /* The following flags have to be released exactly in this order,
558          * otherwise the DS12887 (popular MC146818A clone with integrated
559          * battery and quartz) will not reset the oscillator and will not
560          * update precisely 500 ms later. You won't find this mentioned in
561          * the Dallas Semiconductor data sheets, but who believes data
562          * sheets anyway ...                           -- Markus Kuhn
563          */
564         CMOS_WRITE(save_control, RTC_CONTROL);
565         CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
566         spin_unlock(&rtc_lock);
567
568         return retval;
569 }