Return to mcrnaut.c CVS log

Up to [Research Unix] / researchv10dc / sys / md

Annotation of researchv10dc/sys/md/mcrnaut.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * memory controller support for nautilus
        !             3:  *
        !             4:  * an interpretation of the VMS code
        !             5:  */
        !             6: 
        !             7: #include "sys/param.h"
        !             8: #include "sys/systm.h"
        !             9: 
        !            10: extern long *mcrcsr;   /* virt addr of mem csrs; filled in when spt built */
        !            11: 
        !            12: /*
        !            13:  * mem csrs have no names, just numbers 0-7
        !            14:  * 0-3 have control and status bits
        !            15:  * 4-7 are just magic places to read:
        !            16:  *     csr4 clears memory interrupt
        !            17:  *     csr5 clears memory (and nmi) fault
        !            18:  */
        !            19: 
        !            20: /*
        !            21:  * csr0
        !            22:  */
        !            23: 
        !            24: #define        TOCODE  0x7000000       /* timeout code */
        !            25: #define        ILTO    0x2000000       /* interlock timeout */
        !            26: 
        !            27: /*
        !            28:  * csr1
        !            29:  */
        !            30: 
        !            31: #define        WENABLE 0x100000        /* decode ram write enable -- make sure off */
        !            32: 
        !            33: /*
        !            34:  * csr2
        !            35:  */
        !            36: 
        !            37: #define        RDSHER  0x80000000      /* rds thick and fast */
        !            38: #define        RDS     0x40000000      /* read data substitute (hard error) */
        !            39: #define        CRD     0x20000000      /* corrected read data (soft error) */
        !            40: #define        RDFORCE 0x10000000      /* RDS really NMI bus error */
        !            41: 
        !            42: /*
        !            43:  * csr3
        !            44:  */
        !            45: 
        !            46: #define        IEINTERR 0x80000000     /* internal error intr enab */
        !            47: #define        IEILERR 0x40000000      /* interlock error ie */
        !            48: #define        IECRD   0x20000000      /* soft error ie */
        !            49: #define        IERDS   0x10000000      /* hard error ie */
        !            50: #define        INTERR  0x2000000       /* internal error */
        !            51: 
        !            52: #define        IE      (IEINTERR|IEILERR|IECRD|IERDS)
        !            53: 
        !            54: /*
        !            55:  * init the memory controller:
        !            56:  * enable interrupts
        !            57:  */
        !            58: 
        !            59: mcrinit()
        !            60: {
        !            61:        register long junk;
        !            62:        register long *m;
        !            63: 
        !            64:        if ((m = mcrcsr) == 0)
        !            65:                panic("mcrinit");
        !            66:        mcrclr();
        !            67:        m[3] = IE;
        !            68: }
        !            69: 
        !            70: /*
        !            71:  * here on memory interrupt
        !            72:  * guess whether it's an error
        !            73:  */
        !            74: 
        !            75: mcrint()
        !            76: {
        !            77:        register long *m;
        !            78: 
        !            79:        if ((m = mcrcsr) == 0)
        !            80:                return;
        !            81:        /* cknofault? */
        !            82:        mcrerr();
        !            83: }
        !            84: 
        !            85: /*
        !            86:  * memory error, because controller interrupted or otherwise
        !            87:  */
        !            88: static int crdoff;
        !            89: int mcrreenb();
        !            90: 
        !            91: mcrerr()
        !            92: {
        !            93:        register long *m;
        !            94:        register long csr0, csr1, csr2, csr3;
        !            95:        register long xcsr1;            /* eventually toss out */
        !            96:        register int hard;
        !            97:        static time_t lastcrd;
        !            98: 
        !            99:        if ((m = mcrcsr) == 0)
        !           100:                return;         /* hopeless */
        !           101:        csr0 = m[0];
        !           102:        xcsr1 = m[1];
        !           103:        m[1] = xcsr1 & ~WENABLE;
        !           104:        csr1 = m[1];
        !           105:        csr2 = m[2];
        !           106:        csr3 = m[3];
        !           107:        mcrclr();
        !           108:        hard = 0;
        !           109:        if (csr3 & INTERR)
        !           110:                hard++;
        !           111:        if ((csr0 & TOCODE) == ILTO)
        !           112:                hard++;
        !           113:        if (csr2 & (RDS|RDFORCE))
        !           114:                hard++;
        !           115:        printf("mem %s err: %x %x %x %x (%x)\n", hard ? "hard" : "soft",
        !           116:                csr0, csr1, csr2, csr3, xcsr1);
        !           117:        if (hard)
        !           118:                panic("mcrerr");
        !           119:        if (lastcrd && lastcrd + 5 < time) {
        !           120:                if (crdoff++ == 0)
        !           121:                        timeout(mcrreenb, (caddr_t)0, 15*HZ);
        !           122:                m[3] = (IE &~ IECRD);
        !           123:        }
        !           124:        else
        !           125:                lastcrd = time;
        !           126: }
        !           127: 
        !           128: mcrreenb(x)
        !           129: caddr_t x;
        !           130: {
        !           131:        crdoff = 0;
        !           132:        mcrcsr[3] = IE;
        !           133: }
        !           134: 
        !           135: mcrclr()
        !           136: {
        !           137:        register long junk;
        !           138:        register long *m;
        !           139: 
        !           140:        if ((m = mcrcsr) == 0)
        !           141:                return;
        !           142:        junk = m[4];
        !           143:        junk = m[5];
        !           144:        m[0] = m[0]|TOCODE;
        !           145:        m[1] = m[1];
        !           146:        m[2] = m[2];
        !           147: }

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