Remove all remaining SPL code. Replace the mtd_cpl field in the machine
[dragonfly.git] / sys / platform / pc32 / isa / clock.c
1 /*-
2  * Copyright (c) 1990 The Regents of the University of California.
3  * All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * William Jolitz and Don Ahn.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *      from: @(#)clock.c       7.2 (Berkeley) 5/12/91
37  * $FreeBSD: src/sys/i386/isa/clock.c,v 1.149.2.6 2002/11/02 04:41:50 iwasaki Exp $
38  * $DragonFly: src/sys/platform/pc32/isa/clock.c,v 1.31 2005/06/16 21:12:47 dillon Exp $
39  */
40
41 /*
42  * Routines to handle clock hardware.
43  */
44
45 /*
46  * inittodr, settodr and support routines written
47  * by Christoph Robitschko <chmr@edvz.tu-graz.ac.at>
48  *
49  * reintroduced and updated by Chris Stenton <chris@gnome.co.uk> 8/10/94
50  */
51
52 #include "use_apm.h"
53 #include "opt_clock.h"
54
55 #include <sys/param.h>
56 #include <sys/systm.h>
57 #include <sys/time.h>
58 #include <sys/kernel.h>
59 #include <sys/bus.h>
60 #ifndef SMP
61 #include <sys/lock.h>
62 #endif
63 #include <sys/sysctl.h>
64 #include <sys/cons.h>
65 #include <sys/systimer.h>
66 #include <sys/globaldata.h>
67 #include <sys/thread2.h>
68 #include <sys/systimer.h>
69
70 #include <machine/clock.h>
71 #ifdef CLK_CALIBRATION_LOOP
72 #endif
73 #include <machine/cputypes.h>
74 #include <machine/frame.h>
75 #include <machine/ipl.h>
76 #include <machine/limits.h>
77 #include <machine/md_var.h>
78 #include <machine/psl.h>
79 #ifdef APIC_IO
80 #include <machine/segments.h>
81 #endif
82 #if defined(SMP) || defined(APIC_IO)
83 #include <machine/smp.h>
84 #endif /* SMP || APIC_IO */
85 #include <machine/specialreg.h>
86
87 #include <i386/isa/icu.h>
88 #include <bus/isa/i386/isa.h>
89 #include <bus/isa/rtc.h>
90 #include <i386/isa/timerreg.h>
91
92 #include <i386/isa/intr_machdep.h>
93
94 #ifdef APIC_IO
95 #include <i386/isa/intr_machdep.h>
96 /* The interrupt triggered by the 8254 (timer) chip */
97 int apic_8254_intr;
98 static u_long read_intr_count (int vec);
99 static void setup_8254_mixed_mode (void);
100 #endif
101 static void i8254_restore(void);
102
103 /*
104  * 32-bit time_t's can't reach leap years before 1904 or after 2036, so we
105  * can use a simple formula for leap years.
106  */
107 #define LEAPYEAR(y) ((u_int)(y) % 4 == 0)
108 #define DAYSPERYEAR   (31+28+31+30+31+30+31+31+30+31+30+31)
109
110 #ifndef TIMER_FREQ
111 #define TIMER_FREQ   1193182
112 #endif
113
114 static uint8_t i8254_walltimer_sel;
115 static uint16_t i8254_walltimer_cntr;
116
117 int     adjkerntz;              /* local offset from GMT in seconds */
118 int     disable_rtc_set;        /* disable resettodr() if != 0 */
119 volatile u_int  idelayed;
120 int     statclock_disable = 1;  /* we don't use the statclock right now */
121 u_int   tsc_freq;
122 int     tsc_is_broken;
123 int     wall_cmos_clock;        /* wall CMOS clock assumed if != 0 */
124 int     timer0_running;
125 enum tstate { RELEASED, ACQUIRED };
126 enum tstate timer0_state;
127 enum tstate timer1_state;
128 enum tstate timer2_state;
129
130 static  int     beeping = 0;
131 static  const u_char daysinmonth[] = {31,28,31,30,31,30,31,31,30,31,30,31};
132 static  u_char  rtc_statusa = RTCSA_DIVIDER | RTCSA_NOPROF;
133 static  u_char  rtc_statusb = RTCSB_24HR | RTCSB_PINTR;
134 static  u_int   tsc_present;
135
136 static int i8254_cputimer_div;
137
138 static struct callout sysbeepstop_ch;
139
140 static sysclock_t i8254_cputimer_count(void);
141 static void i8254_cputimer_construct(struct cputimer *cputimer, sysclock_t last);
142 static void i8254_cputimer_destruct(struct cputimer *cputimer);
143
144 static struct cputimer  i8254_cputimer = {
145     SLIST_ENTRY_INITIALIZER,
146     "i8254",
147     CPUTIMER_PRI_8254,
148     0,
149     i8254_cputimer_count,
150     cputimer_default_fromhz,
151     cputimer_default_fromus,
152     i8254_cputimer_construct,
153     i8254_cputimer_destruct,
154     TIMER_FREQ,
155     0, 0, 0
156 };
157
158 /*
159  * timer0 clock interrupt.  Timer0 is in one-shot mode and has stopped
160  * counting as of this interrupt.  We use timer1 in free-running mode (not
161  * generating any interrupts) as our main counter.  Each cpu has timeouts
162  * pending.
163  */
164 static void
165 clkintr(struct intrframe frame)
166 {
167         static sysclock_t timer1_count;
168         struct globaldata *gd = mycpu;
169         struct globaldata *gscan;
170         int n;
171
172         /*
173          * SWSTROBE mode is a one-shot, the timer is no longer running
174          */
175         timer0_running = 0;
176
177         /*
178          * XXX the dispatcher needs work.  right now we call systimer_intr()
179          * directly or via IPI for any cpu with systimers queued, which is
180          * usually *ALL* of them.  We need a better way to do this.
181          */
182         timer1_count = sys_cputimer->count();
183         for (n = 0; n < ncpus; ++n) {
184             gscan = globaldata_find(n);
185             if (TAILQ_FIRST(&gscan->gd_systimerq) == NULL)
186                 continue;
187             if (gscan != gd) {
188                 lwkt_send_ipiq(gscan, (ipifunc_t)systimer_intr, &timer1_count);
189             } else {
190                 systimer_intr(&timer1_count, &frame);
191             }
192         }
193 }
194
195
196 /*
197  * NOTE! not MP safe.
198  */
199 int
200 acquire_timer2(int mode)
201 {
202         if (timer2_state != RELEASED)
203                 return (-1);
204         timer2_state = ACQUIRED;
205
206         /*
207          * This access to the timer registers is as atomic as possible
208          * because it is a single instruction.  We could do better if we
209          * knew the rate.
210          */
211         outb(TIMER_MODE, TIMER_SEL2 | (mode & 0x3f));
212         return (0);
213 }
214
215 int
216 release_timer2()
217 {
218         if (timer2_state != ACQUIRED)
219                 return (-1);
220         outb(TIMER_MODE, TIMER_SEL2 | TIMER_SQWAVE | TIMER_16BIT);
221         timer2_state = RELEASED;
222         return (0);
223 }
224
225 /*
226  * This routine receives statistical clock interrupts from the RTC.
227  * As explained above, these occur at 128 interrupts per second.
228  * When profiling, we receive interrupts at a rate of 1024 Hz.
229  *
230  * This does not actually add as much overhead as it sounds, because
231  * when the statistical clock is active, the hardclock driver no longer
232  * needs to keep (inaccurate) statistics on its own.  This decouples
233  * statistics gathering from scheduling interrupts.
234  *
235  * The RTC chip requires that we read status register C (RTC_INTR)
236  * to acknowledge an interrupt, before it will generate the next one.
237  * Under high interrupt load, rtcintr() can be indefinitely delayed and
238  * the clock can tick immediately after the read from RTC_INTR.  In this
239  * case, the mc146818A interrupt signal will not drop for long enough
240  * to register with the 8259 PIC.  If an interrupt is missed, the stat
241  * clock will halt, considerably degrading system performance.  This is
242  * why we use 'while' rather than a more straightforward 'if' below.
243  * Stat clock ticks can still be lost, causing minor loss of accuracy
244  * in the statistics, but the stat clock will no longer stop.
245  */
246 static void
247 rtcintr(struct intrframe frame)
248 {
249         while (rtcin(RTC_INTR) & RTCIR_PERIOD)
250                 ;
251                 /* statclock(&frame); no longer used */
252 }
253
254 #include "opt_ddb.h"
255 #ifdef DDB
256 #include <ddb/ddb.h>
257
258 DB_SHOW_COMMAND(rtc, rtc)
259 {
260         printf("%02x/%02x/%02x %02x:%02x:%02x, A = %02x, B = %02x, C = %02x\n",
261                rtcin(RTC_YEAR), rtcin(RTC_MONTH), rtcin(RTC_DAY),
262                rtcin(RTC_HRS), rtcin(RTC_MIN), rtcin(RTC_SEC),
263                rtcin(RTC_STATUSA), rtcin(RTC_STATUSB), rtcin(RTC_INTR));
264 }
265 #endif /* DDB */
266
267 /*
268  * Return the current cpu timer count as a 32 bit integer.
269  */
270 static
271 sysclock_t
272 i8254_cputimer_count(void)
273 {
274         static __uint16_t cputimer_last;
275         __uint16_t count;
276         sysclock_t ret;
277
278         clock_lock();
279         outb(TIMER_MODE, i8254_walltimer_sel | TIMER_LATCH);
280         count = (__uint8_t)inb(i8254_walltimer_cntr);           /* get countdown */
281         count |= ((__uint8_t)inb(i8254_walltimer_cntr) << 8);
282         count = -count;                                 /* -> countup */
283         if (count < cputimer_last)                      /* rollover */
284                 i8254_cputimer.base += 0x00010000;
285         ret = i8254_cputimer.base | count;
286         cputimer_last = count;
287         clock_unlock();
288         return(ret);
289 }
290
291 /*
292  * This function is called whenever the system timebase changes, allowing
293  * us to calculate what is needed to convert a system timebase tick 
294  * into an 8254 tick for the interrupt timer.  If we can convert to a
295  * simple shift, multiplication, or division, we do so.  Otherwise 64
296  * bit arithmatic is required every time the interrupt timer is reloaded.
297  */
298 void
299 cputimer_intr_config(struct cputimer *timer)
300 {
301     int freq;
302     int div;
303
304     /*
305      * Will a simple divide do the trick?
306      */
307     div = (timer->freq + (i8254_cputimer.freq / 2)) / i8254_cputimer.freq;
308     freq = i8254_cputimer.freq * div;
309
310     if (freq >= timer->freq - 1 && freq <= timer->freq + 1)
311         i8254_cputimer_div = div;
312     else
313         i8254_cputimer_div = 0;
314 }
315
316 /*
317  * Reload for the next timeout.  It is possible for the reload value
318  * to be 0 or negative, indicating that an immediate timer interrupt
319  * is desired.  For now make the minimum 2 ticks.
320  *
321  * We may have to convert from the system timebase to the 8254 timebase.
322  */
323 void
324 cputimer_intr_reload(sysclock_t reload)
325 {
326     __uint16_t count;
327
328     if (i8254_cputimer_div)
329         reload /= i8254_cputimer_div;
330     else
331         reload = (int64_t)reload * i8254_cputimer.freq / sys_cputimer->freq;
332
333     if ((int)reload < 2)
334         reload = 2;
335
336     clock_lock();
337     if (timer0_running) {
338         outb(TIMER_MODE, TIMER_SEL0 | TIMER_LATCH);     /* count-down timer */
339         count = (__uint8_t)inb(TIMER_CNTR0);            /* lsb */
340         count |= ((__uint8_t)inb(TIMER_CNTR0) << 8);    /* msb */
341         if (reload < count) {
342             outb(TIMER_MODE, TIMER_SEL0 | TIMER_SWSTROBE | TIMER_16BIT);
343             outb(TIMER_CNTR0, (__uint8_t)reload);       /* lsb */
344             outb(TIMER_CNTR0, (__uint8_t)(reload >> 8)); /* msb */
345         }
346     } else {
347         timer0_running = 1;
348         if (reload > 0xFFFF)
349             reload = 0;         /* full count */
350         outb(TIMER_MODE, TIMER_SEL0 | TIMER_SWSTROBE | TIMER_16BIT);
351         outb(TIMER_CNTR0, (__uint8_t)reload);           /* lsb */
352         outb(TIMER_CNTR0, (__uint8_t)(reload >> 8));    /* msb */
353     }
354     clock_unlock();
355 }
356
357 /*
358  * Wait "n" microseconds.
359  * Relies on timer 1 counting down from (cputimer_freq / hz)
360  * Note: timer had better have been programmed before this is first used!
361  */
362 void
363 DELAY(int n)
364 {
365         int delta, prev_tick, tick, ticks_left;
366
367 #ifdef DELAYDEBUG
368         int getit_calls = 1;
369         int n1;
370         static int state = 0;
371
372         if (state == 0) {
373                 state = 1;
374                 for (n1 = 1; n1 <= 10000000; n1 *= 10)
375                         DELAY(n1);
376                 state = 2;
377         }
378         if (state == 1)
379                 printf("DELAY(%d)...", n);
380 #endif
381         /*
382          * Guard against the timer being uninitialized if we are called
383          * early for console i/o.
384          */
385         if (timer0_state == RELEASED)
386                 i8254_restore();
387
388         /*
389          * Read the counter first, so that the rest of the setup overhead is
390          * counted.  Then calculate the number of hardware timer ticks
391          * required, rounding up to be sure we delay at least the requested
392          * number of microseconds.
393          */
394         prev_tick = sys_cputimer->count();
395         ticks_left = ((u_int)n * (int64_t)sys_cputimer->freq + 999999) /
396                      1000000;
397
398         /*
399          * Loop until done.
400          */
401         while (ticks_left > 0) {
402                 tick = sys_cputimer->count();
403 #ifdef DELAYDEBUG
404                 ++getit_calls;
405 #endif
406                 delta = tick - prev_tick;
407                 prev_tick = tick;
408                 if (delta < 0)
409                         delta = 0;
410                 ticks_left -= delta;
411         }
412 #ifdef DELAYDEBUG
413         if (state == 1)
414                 printf(" %d calls to getit() at %d usec each\n",
415                        getit_calls, (n + 5) / getit_calls);
416 #endif
417 }
418
419 static void
420 sysbeepstop(void *chan)
421 {
422         outb(IO_PPI, inb(IO_PPI)&0xFC); /* disable counter2 output to speaker */
423         beeping = 0;
424         release_timer2();
425 }
426
427 int
428 sysbeep(int pitch, int period)
429 {
430         if (acquire_timer2(TIMER_SQWAVE|TIMER_16BIT))
431                 return(-1);
432         /*
433          * Nobody else is using timer2, we do not need the clock lock
434          */
435         outb(TIMER_CNTR2, pitch);
436         outb(TIMER_CNTR2, (pitch>>8));
437         if (!beeping) {
438                 /* enable counter2 output to speaker */
439                 outb(IO_PPI, inb(IO_PPI) | 3);
440                 beeping = period;
441                 callout_reset(&sysbeepstop_ch, period, sysbeepstop, NULL);
442         }
443         return (0);
444 }
445
446 /*
447  * RTC support routines
448  */
449
450 int
451 rtcin(reg)
452         int reg;
453 {
454         u_char val;
455
456         crit_enter();
457         outb(IO_RTC, reg);
458         inb(0x84);
459         val = inb(IO_RTC + 1);
460         inb(0x84);
461         crit_exit();
462         return (val);
463 }
464
465 static __inline void
466 writertc(u_char reg, u_char val)
467 {
468         crit_enter();
469         inb(0x84);
470         outb(IO_RTC, reg);
471         inb(0x84);
472         outb(IO_RTC + 1, val);
473         inb(0x84);              /* XXX work around wrong order in rtcin() */
474         crit_exit();
475 }
476
477 static __inline int
478 readrtc(int port)
479 {
480         return(bcd2bin(rtcin(port)));
481 }
482
483 static u_int
484 calibrate_clocks(void)
485 {
486         u_int64_t old_tsc;
487         u_int count, prev_count, tot_count;
488         int sec, start_sec, timeout;
489
490         if (bootverbose)
491                 printf("Calibrating clock(s) ... ");
492         if (!(rtcin(RTC_STATUSD) & RTCSD_PWR))
493                 goto fail;
494         timeout = 100000000;
495
496         /* Read the mc146818A seconds counter. */
497         for (;;) {
498                 if (!(rtcin(RTC_STATUSA) & RTCSA_TUP)) {
499                         sec = rtcin(RTC_SEC);
500                         break;
501                 }
502                 if (--timeout == 0)
503                         goto fail;
504         }
505
506         /* Wait for the mC146818A seconds counter to change. */
507         start_sec = sec;
508         for (;;) {
509                 if (!(rtcin(RTC_STATUSA) & RTCSA_TUP)) {
510                         sec = rtcin(RTC_SEC);
511                         if (sec != start_sec)
512                                 break;
513                 }
514                 if (--timeout == 0)
515                         goto fail;
516         }
517
518         /* Start keeping track of the i8254 counter. */
519         prev_count = sys_cputimer->count();
520         tot_count = 0;
521
522         if (tsc_present) 
523                 old_tsc = rdtsc();
524         else
525                 old_tsc = 0;            /* shut up gcc */
526
527         /*
528          * Wait for the mc146818A seconds counter to change.  Read the i8254
529          * counter for each iteration since this is convenient and only
530          * costs a few usec of inaccuracy. The timing of the final reads
531          * of the counters almost matches the timing of the initial reads,
532          * so the main cause of inaccuracy is the varying latency from 
533          * inside getit() or rtcin(RTC_STATUSA) to the beginning of the
534          * rtcin(RTC_SEC) that returns a changed seconds count.  The
535          * maximum inaccuracy from this cause is < 10 usec on 486's.
536          */
537         start_sec = sec;
538         for (;;) {
539                 if (!(rtcin(RTC_STATUSA) & RTCSA_TUP))
540                         sec = rtcin(RTC_SEC);
541                 count = sys_cputimer->count();
542                 tot_count += (int)(count - prev_count);
543                 prev_count = count;
544                 if (sec != start_sec)
545                         break;
546                 if (--timeout == 0)
547                         goto fail;
548         }
549
550         /*
551          * Read the cpu cycle counter.  The timing considerations are
552          * similar to those for the i8254 clock.
553          */
554         if (tsc_present) 
555                 tsc_freq = rdtsc() - old_tsc;
556
557         if (tsc_present)
558                 printf("TSC clock: %u Hz, ", tsc_freq);
559         printf("i8254 clock: %u Hz\n", tot_count);
560         return (tot_count);
561
562 fail:
563         printf("failed, using default i8254 clock of %u Hz\n",
564                 i8254_cputimer.freq);
565         return (i8254_cputimer.freq);
566 }
567
568 static void
569 i8254_restore(void)
570 {
571         timer0_state = ACQUIRED;
572
573         clock_lock();
574
575         /*
576          * Timer0 is our fine-grained variable clock interrupt
577          */
578         outb(TIMER_MODE, TIMER_SEL0 | TIMER_SWSTROBE | TIMER_16BIT);
579         outb(TIMER_CNTR0, 2);   /* lsb */
580         outb(TIMER_CNTR0, 0);   /* msb */
581         clock_unlock();
582
583         /*
584          * Timer1 or timer2 is our free-running clock, but only if another
585          * has not been selected.
586          */
587         cputimer_register(&i8254_cputimer);
588         cputimer_select(&i8254_cputimer, 0);
589 }
590
591 static void
592 i8254_cputimer_construct(struct cputimer *timer, sysclock_t oldclock)
593 {
594         int which;
595
596         /*
597          * Should we use timer 1 or timer 2 ?
598          */
599         which = 0;
600         TUNABLE_INT_FETCH("hw.i8254.walltimer", &which);
601         if (which != 1 && which != 2)
602                 which = 2;
603
604         switch(which) {
605         case 1:
606                 timer->name = "i8254_timer1";
607                 timer->type = CPUTIMER_8254_SEL1;
608                 i8254_walltimer_sel = TIMER_SEL1;
609                 i8254_walltimer_cntr = TIMER_CNTR1;
610                 timer1_state = ACQUIRED;
611                 break;
612         case 2:
613                 timer->name = "i8254_timer2";
614                 timer->type = CPUTIMER_8254_SEL2;
615                 i8254_walltimer_sel = TIMER_SEL2;
616                 i8254_walltimer_cntr = TIMER_CNTR2;
617                 timer2_state = ACQUIRED;
618                 break;
619         }
620
621         timer->base = (oldclock + 0xFFFF) & ~0xFFFF;
622
623         clock_lock();
624         outb(TIMER_MODE, i8254_walltimer_sel | TIMER_RATEGEN | TIMER_16BIT);
625         outb(i8254_walltimer_cntr, 0);  /* lsb */
626         outb(i8254_walltimer_cntr, 0);  /* msb */
627         outb(IO_PPI, inb(IO_PPI) | 1);  /* bit 0: enable gate, bit 1: spkr */
628         clock_unlock();
629 }
630
631 static void
632 i8254_cputimer_destruct(struct cputimer *timer)
633 {
634         switch(timer->type) {
635         case CPUTIMER_8254_SEL1:
636             timer1_state = RELEASED;
637             break;
638         case CPUTIMER_8254_SEL2:
639             timer2_state = RELEASED;
640             break;
641         default:
642             break;
643         }
644         timer->type = 0;
645 }
646
647 static void
648 rtc_restore(void)
649 {
650         /* Restore all of the RTC's "status" (actually, control) registers. */
651         writertc(RTC_STATUSB, RTCSB_24HR);
652         writertc(RTC_STATUSA, rtc_statusa);
653         writertc(RTC_STATUSB, rtc_statusb);
654 }
655
656 /*
657  * Restore all the timers.
658  *
659  * This function is called to resynchronize our core timekeeping after a
660  * long halt, e.g. from apm_default_resume() and friends.  It is also 
661  * called if after a BIOS call we have detected munging of the 8254.
662  * It is necessary because cputimer_count() counter's delta may have grown
663  * too large for nanouptime() and friends to handle, or (in the case of 8254
664  * munging) might cause the SYSTIMER code to prematurely trigger.
665  */
666 void
667 timer_restore(void)
668 {
669         crit_enter();
670         i8254_restore();                /* restore timer_freq and hz */
671         rtc_restore();                  /* reenable RTC interrupts */
672         crit_exit();
673 }
674
675 /*
676  * Initialize 8254 timer 0 early so that it can be used in DELAY().
677  */
678 void
679 startrtclock()
680 {
681         u_int delta, freq;
682
683         /* 
684          * Can we use the TSC?
685          */
686         if (cpu_feature & CPUID_TSC)
687                 tsc_present = 1;
688         else
689                 tsc_present = 0;
690
691         /*
692          * Initial RTC state, don't do anything unexpected
693          */
694         writertc(RTC_STATUSA, rtc_statusa);
695         writertc(RTC_STATUSB, RTCSB_24HR);
696
697         /*
698          * Set the 8254 timer0 in TIMER_SWSTROBE mode and cause it to 
699          * generate an interrupt, which we will ignore for now.
700          *
701          * Set the 8254 timer1 in TIMER_RATEGEN mode and load 0x0000
702          * (so it counts a full 2^16 and repeats).  We will use this timer
703          * for our counting.
704          */
705         i8254_restore();
706         freq = calibrate_clocks();
707 #ifdef CLK_CALIBRATION_LOOP
708         if (bootverbose) {
709                 printf(
710                 "Press a key on the console to abort clock calibration\n");
711                 while (cncheckc() == -1)
712                         calibrate_clocks();
713         }
714 #endif
715
716         /*
717          * Use the calibrated i8254 frequency if it seems reasonable.
718          * Otherwise use the default, and don't use the calibrated i586
719          * frequency.
720          */
721         delta = freq > i8254_cputimer.freq ? 
722                         freq - i8254_cputimer.freq : i8254_cputimer.freq - freq;
723         if (delta < i8254_cputimer.freq / 100) {
724 #ifndef CLK_USE_I8254_CALIBRATION
725                 if (bootverbose)
726                         printf(
727 "CLK_USE_I8254_CALIBRATION not specified - using default frequency\n");
728                 freq = i8254_cputimer.freq;
729 #endif
730                 cputimer_set_frequency(&i8254_cputimer, freq);
731         } else {
732                 if (bootverbose)
733                         printf(
734                     "%d Hz differs from default of %d Hz by more than 1%%\n",
735                                freq, i8254_cputimer.freq);
736                 tsc_freq = 0;
737         }
738
739 #ifndef CLK_USE_TSC_CALIBRATION
740         if (tsc_freq != 0) {
741                 if (bootverbose)
742                         printf(
743 "CLK_USE_TSC_CALIBRATION not specified - using old calibration method\n");
744                 tsc_freq = 0;
745         }
746 #endif
747         if (tsc_present && tsc_freq == 0) {
748                 /*
749                  * Calibration of the i586 clock relative to the mc146818A
750                  * clock failed.  Do a less accurate calibration relative
751                  * to the i8254 clock.
752                  */
753                 u_int64_t old_tsc = rdtsc();
754
755                 DELAY(1000000);
756                 tsc_freq = rdtsc() - old_tsc;
757 #ifdef CLK_USE_TSC_CALIBRATION
758                 if (bootverbose)
759                         printf("TSC clock: %u Hz (Method B)\n", tsc_freq);
760 #endif
761         }
762
763 #if !defined(SMP)
764         /*
765          * We can not use the TSC in SMP mode, until we figure out a
766          * cheap (impossible), reliable and precise (yeah right!)  way
767          * to synchronize the TSCs of all the CPUs.
768          * Curse Intel for leaving the counter out of the I/O APIC.
769          */
770
771 #if NAPM > 0
772         /*
773          * We can not use the TSC if we support APM. Precise timekeeping
774          * on an APM'ed machine is at best a fools pursuit, since 
775          * any and all of the time spent in various SMM code can't 
776          * be reliably accounted for.  Reading the RTC is your only
777          * source of reliable time info.  The i8254 looses too of course
778          * but we need to have some kind of time...
779          * We don't know at this point whether APM is going to be used
780          * or not, nor when it might be activated.  Play it safe.
781          */
782         return;
783 #endif /* NAPM > 0 */
784
785 #endif /* !defined(SMP) */
786 }
787
788 /*
789  * Initialize the time of day register, based on the time base which is, e.g.
790  * from a filesystem.
791  */
792 void
793 inittodr(time_t base)
794 {
795         unsigned long   sec, days;
796         int             yd;
797         int             year, month;
798         int             y, m;
799         struct timespec ts;
800
801         if (base) {
802                 ts.tv_sec = base;
803                 ts.tv_nsec = 0;
804                 set_timeofday(&ts);
805         }
806
807         /* Look if we have a RTC present and the time is valid */
808         if (!(rtcin(RTC_STATUSD) & RTCSD_PWR))
809                 goto wrong_time;
810
811         /* wait for time update to complete */
812         /* If RTCSA_TUP is zero, we have at least 244us before next update */
813         crit_enter();
814         while (rtcin(RTC_STATUSA) & RTCSA_TUP) {
815                 crit_exit();
816                 crit_enter();
817         }
818
819         days = 0;
820 #ifdef USE_RTC_CENTURY
821         year = readrtc(RTC_YEAR) + readrtc(RTC_CENTURY) * 100;
822 #else
823         year = readrtc(RTC_YEAR) + 1900;
824         if (year < 1970)
825                 year += 100;
826 #endif
827         if (year < 1970) {
828                 crit_exit();
829                 goto wrong_time;
830         }
831         month = readrtc(RTC_MONTH);
832         for (m = 1; m < month; m++)
833                 days += daysinmonth[m-1];
834         if ((month > 2) && LEAPYEAR(year))
835                 days ++;
836         days += readrtc(RTC_DAY) - 1;
837         yd = days;
838         for (y = 1970; y < year; y++)
839                 days += DAYSPERYEAR + LEAPYEAR(y);
840         sec = ((( days * 24 +
841                   readrtc(RTC_HRS)) * 60 +
842                   readrtc(RTC_MIN)) * 60 +
843                   readrtc(RTC_SEC));
844         /* sec now contains the number of seconds, since Jan 1 1970,
845            in the local time zone */
846
847         sec += tz.tz_minuteswest * 60 + (wall_cmos_clock ? adjkerntz : 0);
848
849         y = time_second - sec;
850         if (y <= -2 || y >= 2) {
851                 /* badly off, adjust it */
852                 ts.tv_sec = sec;
853                 ts.tv_nsec = 0;
854                 set_timeofday(&ts);
855         }
856         crit_exit();
857         return;
858
859 wrong_time:
860         printf("Invalid time in real time clock.\n");
861         printf("Check and reset the date immediately!\n");
862 }
863
864 /*
865  * Write system time back to RTC
866  */
867 void
868 resettodr()
869 {
870         struct timeval tv;
871         unsigned long tm;
872         int m;
873         int y;
874
875         if (disable_rtc_set)
876                 return;
877
878         microtime(&tv);
879         tm = tv.tv_sec;
880
881         crit_enter();
882         /* Disable RTC updates and interrupts. */
883         writertc(RTC_STATUSB, RTCSB_HALT | RTCSB_24HR);
884
885         /* Calculate local time to put in RTC */
886
887         tm -= tz.tz_minuteswest * 60 + (wall_cmos_clock ? adjkerntz : 0);
888
889         writertc(RTC_SEC, bin2bcd(tm%60)); tm /= 60;    /* Write back Seconds */
890         writertc(RTC_MIN, bin2bcd(tm%60)); tm /= 60;    /* Write back Minutes */
891         writertc(RTC_HRS, bin2bcd(tm%24)); tm /= 24;    /* Write back Hours   */
892
893         /* We have now the days since 01-01-1970 in tm */
894         writertc(RTC_WDAY, (tm+4)%7);                   /* Write back Weekday */
895         for (y = 1970, m = DAYSPERYEAR + LEAPYEAR(y);
896              tm >= m;
897              y++,      m = DAYSPERYEAR + LEAPYEAR(y))
898              tm -= m;
899
900         /* Now we have the years in y and the day-of-the-year in tm */
901         writertc(RTC_YEAR, bin2bcd(y%100));             /* Write back Year    */
902 #ifdef USE_RTC_CENTURY
903         writertc(RTC_CENTURY, bin2bcd(y/100));          /* ... and Century    */
904 #endif
905         for (m = 0; ; m++) {
906                 int ml;
907
908                 ml = daysinmonth[m];
909                 if (m == 1 && LEAPYEAR(y))
910                         ml++;
911                 if (tm < ml)
912                         break;
913                 tm -= ml;
914         }
915
916         writertc(RTC_MONTH, bin2bcd(m + 1));            /* Write back Month   */
917         writertc(RTC_DAY, bin2bcd(tm + 1));             /* Write back Month Day */
918
919         /* Reenable RTC updates and interrupts. */
920         writertc(RTC_STATUSB, rtc_statusb);
921         crit_exit();
922 }
923
924
925 /*
926  * Start both clocks running.  DragonFly note: the stat clock is no longer
927  * used.  Instead, 8254 based systimers are used for all major clock
928  * interrupts.  statclock_disable is set by default.
929  */
930 void
931 cpu_initclocks()
932 {
933         int diag;
934 #ifdef APIC_IO
935         int apic_8254_trial;
936         struct intrec *clkdesc;
937 #endif /* APIC_IO */
938
939         if (statclock_disable) {
940                 /*
941                  * The stat interrupt mask is different without the
942                  * statistics clock.  Also, don't set the interrupt
943                  * flag which would normally cause the RTC to generate
944                  * interrupts.
945                  */
946                 rtc_statusb = RTCSB_24HR;
947         } else {
948                 /* Setting stathz to nonzero early helps avoid races. */
949                 stathz = RTC_NOPROFRATE;
950                 profhz = RTC_PROFRATE;
951         }
952
953         /* Finish initializing 8253 timer 0. */
954 #ifdef APIC_IO
955
956         apic_8254_intr = isa_apic_irq(0);
957         apic_8254_trial = 0;
958         if (apic_8254_intr >= 0 ) {
959                 if (apic_int_type(0, 0) == 3)
960                         apic_8254_trial = 1;
961         } else {
962                 /* look for ExtInt on pin 0 */
963                 if (apic_int_type(0, 0) == 3) {
964                         apic_8254_intr = apic_irq(0, 0);
965                         setup_8254_mixed_mode();
966                 } else 
967                         panic("APIC_IO: Cannot route 8254 interrupt to CPU");
968         }
969
970         clkdesc = inthand_add("clk", apic_8254_intr, (inthand2_t *)clkintr,
971                               NULL, INTR_EXCL | INTR_FAST, NULL);
972         INTREN(1 << apic_8254_intr);
973         
974 #else /* APIC_IO */
975
976         inthand_add("clk", 0, (inthand2_t *)clkintr, NULL,
977                     INTR_EXCL | INTR_FAST, NULL);
978         INTREN(IRQ0);
979
980 #endif /* APIC_IO */
981
982         /* Initialize RTC. */
983         writertc(RTC_STATUSA, rtc_statusa);
984         writertc(RTC_STATUSB, RTCSB_24HR);
985
986         if (statclock_disable == 0) {
987                 diag = rtcin(RTC_DIAG);
988                 if (diag != 0)
989                         printf("RTC BIOS diagnostic error %b\n", diag, RTCDG_BITS);
990
991 #ifdef APIC_IO
992                 if (isa_apic_irq(8) != 8)
993                         panic("APIC RTC != 8");
994 #endif /* APIC_IO */
995
996                 inthand_add("rtc", 8, (inthand2_t *)rtcintr, NULL,
997                             INTR_EXCL | INTR_FAST, NULL);
998
999 #ifdef APIC_IO
1000                 INTREN(APIC_IRQ8);
1001 #else
1002                 INTREN(IRQ8);
1003 #endif /* APIC_IO */
1004
1005                 writertc(RTC_STATUSB, rtc_statusb);
1006         }
1007
1008 #ifdef APIC_IO
1009         if (apic_8254_trial) {
1010                 sysclock_t base;
1011                 int lastcnt = read_intr_count(apic_8254_intr);
1012
1013                 /*
1014                  * XXX this assumes the 8254 is the cpu timer.  Force an
1015                  * 8254 Timer0 interrupt and wait 1/100s for it to happen,
1016                  * then see if we got it.
1017                  */
1018                 printf("APIC_IO: Testing 8254 interrupt delivery\n");
1019                 cputimer_intr_reload(2);        /* XXX assumes 8254 */
1020                 base = sys_cputimer->count();
1021                 while (sys_cputimer->count() - base < sys_cputimer->freq / 100)
1022                         ;       /* nothing */
1023                 if (read_intr_count(apic_8254_intr) - lastcnt == 0) {
1024                         /* 
1025                          * The MP table is broken.
1026                          * The 8254 was not connected to the specified pin
1027                          * on the IO APIC.
1028                          * Workaround: Limited variant of mixed mode.
1029                          */
1030                         INTRDIS(1 << apic_8254_intr);
1031                         inthand_remove(clkdesc);
1032                         printf("APIC_IO: Broken MP table detected: "
1033                                "8254 is not connected to "
1034                                "IOAPIC #%d intpin %d\n",
1035                                int_to_apicintpin[apic_8254_intr].ioapic,
1036                                int_to_apicintpin[apic_8254_intr].int_pin);
1037                         /* 
1038                          * Revoke current ISA IRQ 0 assignment and 
1039                          * configure a fallback interrupt routing from
1040                          * the 8254 Timer via the 8259 PIC to the
1041                          * an ExtInt interrupt line on IOAPIC #0 intpin 0.
1042                          * We reuse the low level interrupt handler number.
1043                          */
1044                         if (apic_irq(0, 0) < 0) {
1045                                 revoke_apic_irq(apic_8254_intr);
1046                                 assign_apic_irq(0, 0, apic_8254_intr);
1047                         }
1048                         apic_8254_intr = apic_irq(0, 0);
1049                         setup_8254_mixed_mode();
1050                         inthand_add("clk", apic_8254_intr,
1051                                     (inthand2_t *)clkintr,
1052                                     NULL,
1053                                     INTR_EXCL | INTR_FAST, NULL);
1054                         INTREN(1 << apic_8254_intr);
1055                 }
1056                 
1057         }
1058         if (apic_int_type(0, 0) != 3 ||
1059             int_to_apicintpin[apic_8254_intr].ioapic != 0 ||
1060             int_to_apicintpin[apic_8254_intr].int_pin != 0) {
1061                 printf("APIC_IO: routing 8254 via IOAPIC #%d intpin %d\n",
1062                        int_to_apicintpin[apic_8254_intr].ioapic,
1063                        int_to_apicintpin[apic_8254_intr].int_pin);
1064         } else {
1065                 printf("APIC_IO: "
1066                        "routing 8254 via 8259 and IOAPIC #0 intpin 0\n");
1067         }
1068 #endif
1069         callout_init(&sysbeepstop_ch);
1070 }
1071
1072 #ifdef APIC_IO
1073 static u_long
1074 read_intr_count(int vec)
1075 {
1076         u_long *up;
1077         up = intr_countp[vec];
1078         if (up)
1079                 return *up;
1080         return 0UL;
1081 }
1082
1083 static void 
1084 setup_8254_mixed_mode()
1085 {
1086         /*
1087          * Allow 8254 timer to INTerrupt 8259:
1088          *  re-initialize master 8259:
1089          *   reset; prog 4 bytes, single ICU, edge triggered
1090          */
1091         outb(IO_ICU1, 0x13);
1092         outb(IO_ICU1 + 1, NRSVIDT);     /* start vector (unused) */
1093         outb(IO_ICU1 + 1, 0x00);        /* ignore slave */
1094         outb(IO_ICU1 + 1, 0x03);        /* auto EOI, 8086 */
1095         outb(IO_ICU1 + 1, 0xfe);        /* unmask INT0 */
1096         
1097         /* program IO APIC for type 3 INT on INT0 */
1098         if (ext_int_setup(0, 0) < 0)
1099                 panic("8254 redirect via APIC pin0 impossible!");
1100 }
1101 #endif
1102
1103 void
1104 setstatclockrate(int newhz)
1105 {
1106         if (newhz == RTC_PROFRATE)
1107                 rtc_statusa = RTCSA_DIVIDER | RTCSA_PROF;
1108         else
1109                 rtc_statusa = RTCSA_DIVIDER | RTCSA_NOPROF;
1110         writertc(RTC_STATUSA, rtc_statusa);
1111 }
1112
1113 #if 0
1114 static unsigned
1115 tsc_get_timecount(struct timecounter *tc)
1116 {
1117         return (rdtsc());
1118 }
1119 #endif
1120
1121 #ifdef KERN_TIMESTAMP
1122 #define KERN_TIMESTAMP_SIZE 16384
1123 static u_long tsc[KERN_TIMESTAMP_SIZE] ;
1124 SYSCTL_OPAQUE(_debug, OID_AUTO, timestamp, CTLFLAG_RD, tsc,
1125         sizeof(tsc), "LU", "Kernel timestamps");
1126 void  
1127 _TSTMP(u_int32_t x)
1128 {
1129         static int i;
1130
1131         tsc[i] = (u_int32_t)rdtsc();
1132         tsc[i+1] = x;
1133         i = i + 2;
1134         if (i >= KERN_TIMESTAMP_SIZE)
1135                 i = 0;
1136         tsc[i] = 0; /* mark last entry */
1137 }
1138 #endif /* KERN_TIMESTAMP */
1139
1140 /*
1141  *
1142  */
1143
1144 static int
1145 hw_i8254_timestamp(SYSCTL_HANDLER_ARGS)
1146 {
1147     sysclock_t count;
1148     __uint64_t tscval;
1149     char buf[32];
1150
1151     crit_enter();
1152     if (sys_cputimer == &i8254_cputimer)
1153         count = sys_cputimer->count();
1154     else
1155         count = 0;
1156     if (tsc_present)
1157         tscval = rdtsc();
1158     else
1159         tscval = 0;
1160     crit_exit();
1161     snprintf(buf, sizeof(buf), "%08x %016llx", count, (long long)tscval);
1162     return(SYSCTL_OUT(req, buf, strlen(buf) + 1));
1163 }
1164
1165 SYSCTL_NODE(_hw, OID_AUTO, i8254, CTLFLAG_RW, 0, "I8254");
1166 SYSCTL_UINT(_hw_i8254, OID_AUTO, freq, CTLFLAG_RD, &i8254_cputimer.freq, 0,
1167             "frequency");
1168 SYSCTL_PROC(_hw_i8254, OID_AUTO, timestamp, CTLTYPE_STRING|CTLFLAG_RD,
1169             0, 0, hw_i8254_timestamp, "A", "");
1170