Return to clockedf.c CVS log

Up to [MW Coherent from dump] / coherent / b / kernel / ldrv

Annotation of coherent/b/kernel/ldrv/clockedf.c, revision 1.1

1.1     ! root        1: /* clockedf.c - support routines for alternate clock rate
        !             2:               - this is the FAR version of clocked.c for loadable drivers
        !             3: 
        !             4:   altclk_in(hz, fn) - install routine with specified rate
        !             5:                           "hz" should be a multiple of system rate of 100 Hz
        !             6: 
        !             7:   altclk_out()      - uninstall alternate clock routine and restore system rate
        !             8:                        return old value of "altclk"
        !             9: 
        !            10:   altclk_rate(hz)   - set clock interrupt rate
        !            11:                        new rate must be an even multiple of system rate "HZ"
        !            12:                        return 0 if completed ok, -1 otherwise
        !            13: 
        !            14:   History:
        !            15:     90/08/08 hws       initial version, works with hs.c modified for com[1-4]
        !            16:     90/08/14 hws       make it more like a Unix system call
        !            17:     90/09/12 hws       add far version
        !            18: */
        !            19: 
        !            20: #include       <sys/coherent.h>        /* altclk */
        !            21: #include       <sys/const.h>   /* HZ */
        !            22: 
        !            23: #define        PIT     0x40    /* 8253 port */
        !            24: #define        TMR0_M3 0x36    /* timer 0, mode 3 */
        !            25: #if 0
        !            26: /* nominal IBM rate is 1.1900 MHz */
        !            27: #define        SYS_HZ  1190000L        /* rate of input clock to timer 0 */
        !            28: #else
        !            29: /* current kernel rate is 1.1932 MHz */
        !            30: #define        SYS_HZ  1193200L        /* rate of input clock to timer 0 */
        !            31: #endif
        !            32: 
        !            33: typedef int (*PFI)();  /* pointer to function returning int */
        !            34: 
        !            35: extern saddr_t ucs;
        !            36: 
        !            37: static int altclk_rate(hz)
        !            38: unsigned int hz;
        !            39: {
        !            40:   int s;       /* to save CPU irpt flag */
        !            41:   unsigned int interval;       /* period for hz, in units of 1.19 MHz ticks */
        !            42:   int ret;
        !            43: 
        !            44:   if (hz >= HZ && hz % HZ == 0) {      /* can't go slower than HZ! */
        !            45:     interval = SYS_HZ/hz;
        !            46:     s = sphi();        /* disable irpts */
        !            47:     outb(PIT+3, TMR0_M3);
        !            48:     outb(PIT, interval & 0xff);
        !            49:     outb(PIT, interval >> 8);  /* unsigned shift */
        !            50:     spl(s);    /* restore previous irpt state */
        !            51:     ret = 0;
        !            52:   }
        !            53:   else {
        !            54:     ret = -1;
        !            55:   }
        !            56:   return ret;
        !            57: }
        !            58: 
        !            59: int altclk_in(hz, fn)
        !            60: int hz;
        !            61: PFI fn;
        !            62: {
        !            63:   int ret;
        !            64:   int s;
        !            65: 
        !            66:   if ((ret = altclk_rate(hz)) == 0) {
        !            67:     s = sphi();
        !            68:     altclk = fn;
        !            69:     altsel = cs_sel();
        !            70:     spl(s);
        !            71:   }
        !            72:   return ret;
        !            73: }
        !            74: 
        !            75: PFI altclk_out()
        !            76: {
        !            77:   PFI ret;
        !            78:   int s;
        !            79: 
        !            80:   ret = altclk;
        !            81:   if (ret) {
        !            82:     altclk_rate(HZ);
        !            83:     s = sphi();
        !            84:     altclk = 0;
        !            85:     altsel = 0;
        !            86:     spl(s);
        !            87:   }
        !            88:   return ret;
        !            89: }

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