Return to restart.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / io

Annotation of cci/d/io/restart.c, revision 1.1

1.1     ! root        1: #include "preg.h"
        !             2: 
        !             3: extern long pfint, pfcnt, memflg;
        !             4: extern long sbr, slr, p0br, p0lr, p1br, p1lr, p2br, p2lr, ipl, mme, Pcbb;
        !             5: extern long Isp, Sisr, scbb, ksp;
        !             6: 
        !             7: #define        NBPG    1024
        !             8: #define        TP0BR   0x100
        !             9: #define        TP0LR   0x200
        !            10: #define        TP1BR   0x300
        !            11: #define        TP1LR   0x400
        !            12: #define        TP2BR   0x500
        !            13: #define        TP2LR   0x600
        !            14: #define        TKSP    0x700
        !            15: #define KMEM   64
        !            16: 
        !            17: 
        !            18: pfsetup(baddr)
        !            19: register long *baddr;
        !            20: {      register long ix;
        !            21: 
        !            22:        /* write pattern into 64K of memory */
        !            23:        writes("** writing patterns to 64K bytes of memory...\n");
        !            24:        for(ix=0;ix<((NBPG/4)*KMEM) ;ix++) baddr[ix] = ix;
        !            25: }
        !            26: 
        !            27: 
        !            28: prest(baddr)
        !            29: register long *baddr;
        !            30: {      register long ix;
        !            31: 
        !            32:        writes("** Power restarted...\n");
        !            33:        if (pfint==0) {
        !            34:                writes("   Tahoe did not receive power fail interrupt.\n");
        !            35:                }
        !            36:        if (memflg != 0xcafebabe) {
        !            37:                writes("   Memory is not backed up on when power fails\n");
        !            38:                return(0);
        !            39:                }
        !            40:        writes("   Count is "); writeh(pfcnt);
        !            41: 
        !            42:        /* Check if memory is backed up */
        !            43:        writes("   Checking patterns written to memory previously...\n");
        !            44:        for(ix=0;ix<((NBPG/4)*KMEM) ;ix++) {
        !            45:                if (baddr[ix] != ix) {
        !            46:                        writes("** Memory error, begin address ");
        !            47:                        writeh(baddr); writes(", longword no. "); writeh(ix);
        !            48:                        writes(", actual "); writeh(baddr[ix]);
        !            49:                        break;
        !            50:                        }
        !            51:                }
        !            52:        chk_pr();               /* Check privilege registes */
        !            53: }
        !            54: 
        !            55: chk_pr()
        !            56: {      register long actual;
        !            57: 
        !            58:        actual = mfpr(SBR);
        !            59:        if (actual != sbr) pferr("\n   SBR error ",actual,sbr);
        !            60:        actual = mfpr(SLR);
        !            61:        if (actual != slr) pferr("\n   SLR error ",actual,slr);
        !            62:        actual = mfpr(P0BR);
        !            63:        if (actual != p0br) pferr("\n   P0BR error ",actual,p0br);
        !            64:        actual = mfpr(P0LR);
        !            65:        if (actual != p0lr) pferr("\n   P0LR error ",actual,p0lr);
        !            66:        actual = mfpr(P1BR);
        !            67:        if (actual != p1br) pferr("\n   P1BR error ",actual,p1br);
        !            68:        actual = mfpr(P1LR);
        !            69:        if (actual != p1lr) pferr("\n   P1LR error ",actual,p1lr);
        !            70:        actual = mfpr(P2BR);
        !            71:        if (actual != p2br) pferr("\n   P2BR error ",actual,p2br);
        !            72:        actual = mfpr(P2LR);
        !            73:        if (actual != p2lr) pferr("\n   P2LR error ",actual,p2lr);
        !            74:        actual = mfpr(IPL);
        !            75:        if (actual != ipl) pferr("\n   IPL error ",actual,ipl);
        !            76:        actual = mfpr(MME);
        !            77:        if (actual != mme) pferr("\n   MME error ",actual,mme);
        !            78:        actual = mfpr(PCBB);
        !            79:        if (actual != Pcbb) pferr("\n   PCBB error ",actual,Pcbb);
        !            80:        actual = mfpr(ISP);
        !            81:        if (actual != Isp) pferr("\n   ISP error ",actual,Isp);
        !            82:        actual = mfpr(SISR);
        !            83:        if (actual != Sisr) pferr("\n   SISR error ",actual,Sisr);
        !            84:        actual = mfpr(SCBB);
        !            85:        if (actual != scbb) pferr("\n   SCBB error ",actual,scbb);
        !            86:        actual = mfpr(KSP);
        !            87:        if (actual != ksp) pferr("\n   KSP error ",actual,ksp);
        !            88: }
        !            89: 
        !            90: 
        !            91: mfpr(pn)
        !            92: long pn;
        !            93: {      register long r12;
        !            94: 
        !            95:        asm("mfpr 4(fp),r12");
        !            96:        return(r12);
        !            97: }
        !            98: 
        !            99: pferr(str,actual,expected)
        !           100: char *str;
        !           101: long actual, expected;
        !           102: {
        !           103:        writes(str); writes("** actual "); writeh(actual); 
        !           104:        writes(" , expected "); writeh(expected);
        !           105: }

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