Return to clock.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / boot / pc

Annotation of lucent/sys/src/boot/pc/clock.c, revision 1.1.1.1

1.1       root        1: #include       "u.h"
                      2: #include       "lib.h"
                      3: #include       "mem.h"
                      4: #include       "dat.h"
                      5: #include       "fns.h"
                      6: #include       "io.h"
                      7: #include       "ureg.h"
                      8: 
                      9: /*
                     10:  *  8253 timer
                     11:  */
                     12: enum
                     13: {
                     14:        T0cntr= 0x40,           /* counter ports */
                     15:        T1cntr= 0x41,           /* ... */
                     16:        T2cntr= 0x42,           /* ... */
                     17:        Tmode=  0x43,           /* mode port */
                     18: 
                     19:        /* commands */
                     20:        Latch0= 0x00,           /* latch counter 0's value */
                     21:        Load0=  0x30,           /* load counter 0 with 2 bytes */
                     22: 
                     23:        /* modes */
                     24:        Square= 0x36,           /* perioic square wave */
                     25: 
                     26:        Freq=   1193182,        /* Real clock frequency */
                     27: };
                     28: 
                     29: static int cpufreq = 66000000;
                     30: static int cpumhz = 66;
                     31: static int cputype = 486;
                     32: static int loopconst = 100;
                     33: 
                     34: /*
                     35:  *  delay for l milliseconds more or less.  delayloop is set by
                     36:  *  clockinit() to match the actual CPU speed.
                     37:  */
                     38: void
                     39: delay(int l)
                     40: {
                     41:        aamloop(l*loopconst);
                     42: }
                     43: 
                     44: static void
                     45: clock(Ureg*, void*)
                     46: {
                     47:        m->ticks++;
                     48:        checkalarms();
                     49: }
                     50: 
                     51: void
                     52: clockinit(void)
                     53: {
                     54:        ulong x, y;     /* change in counter */
                     55:        ulong cycles, loops;
                     56: 
                     57:        switch(cputype = x86()){
                     58:        case 386:
                     59:                loops = 10000;
                     60:                cycles = 32;
                     61:                break;
                     62:        case 486:
                     63:                loops = 10000;
                     64:                cycles = 22;
                     65:                break;
                     66:        default:
                     67:                loops = 30000;
                     68:                cycles = 23;
                     69:                break;
                     70:        }
                     71: 
                     72:        /*
                     73:         *  set vector for clock interrupts
                     74:         */
                     75:        setvec(Clockvec, clock, 0);
                     76: 
                     77:        /*
                     78:         *  set clock for 1/HZ seconds
                     79:         */
                     80:        outb(Tmode, Load0|Square);
                     81:        outb(T0cntr, (Freq/HZ));        /* low byte */
                     82:        outb(T0cntr, (Freq/HZ)>>8);     /* high byte */
                     83: 
                     84: 
                     85:        /*
                     86:         *  measure time for the loop
                     87:         *
                     88:         *                      MOVL    loops,CX
                     89:         *      aaml1:          AAM
                     90:         *                      LOOP    aaml1
                     91:         *
                     92:         *  the time for the loop should be independent from external
                     93:         *  cache's and memory system since it fits in the execution
                     94:         *  prefetch buffer.
                     95:         *
                     96:         */
                     97:        outb(Tmode, Latch0);
                     98:        x = inb(T0cntr);
                     99:        x |= inb(T0cntr)<<8;
                    100:        aamloop(loops);
                    101:        outb(Tmode, Latch0);
                    102:        y = inb(T0cntr);
                    103:        y |= inb(T0cntr)<<8;
                    104:        x -= y;
                    105: 
                    106:        /*
                    107:         *  counter  goes at twice the frequency, once per transition,
                    108:         *  i.e., twice per square wave
                    109:         */
                    110:        x >>= 1;
                    111: 
                    112:        /*
                    113:         *  figure out clock frequency and a loop multiplier for delay().
                    114:         */
                    115:        cpufreq = loops*((cycles*Freq)/x);
                    116:        loopconst = (cpufreq/1000)/cycles;      /* AAM+LOOP's for 1 ms */
                    117: 
                    118:        /*
                    119:         *  add in possible .1% error and convert to MHz
                    120:         */
                    121:        cpumhz = (cpufreq + cpufreq/1000)/1000000;
                    122: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.