Return to ka630.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / vax

Annotation of 43BSDReno/sys/vax/ka630.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1988 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)ka630.c     7.6 (Berkeley) 11/8/88
        !             7:  */
        !             8: 
        !             9: #ifdef VAX630
        !            10: #include "param.h"
        !            11: #include "time.h"
        !            12: #include "kernel.h"
        !            13: #include "vmmac.h"
        !            14: 
        !            15: #include "mtpr.h"
        !            16: #include "cpu.h"
        !            17: #include "clock.h"
        !            18: #include "pte.h"
        !            19: #include "ka630.h"
        !            20: 
        !            21: /*
        !            22:  * 630-specific routines
        !            23:  */
        !            24: extern struct pte Clockmap[];
        !            25: extern struct pte Ka630map[];
        !            26: struct ka630clock ka630clock;
        !            27: struct ka630cpu ka630cpu;
        !            28: 
        !            29: ka630_init()
        !            30: {
        !            31: 
        !            32:        /*
        !            33:         * Map in the clock and the CPU.
        !            34:         */
        !            35:        ioaccess((caddr_t)0x200b8000, &Clockmap[0], sizeof(struct ka630clock));
        !            36:        ioaccess((caddr_t)0x20080000, &Ka630map[0], sizeof(struct ka630cpu));
        !            37: 
        !            38:        /*
        !            39:         * Clear restart and boot in progress flags in the CPMBX.
        !            40:         */
        !            41:        ka630clock.cpmbx = (ka630clock.cpmbx & KA630CLK_LANG) | KA630CLK_REBOOT;
        !            42: 
        !            43:        /*
        !            44:         * Enable memory parity error detection.
        !            45:         */
        !            46:        ka630cpu.ka630_mser = KA630MSER_PAREN;
        !            47: }
        !            48: 
        !            49: /* Start the real-time clock */
        !            50: ka630_clkstartrt()
        !            51: {
        !            52: 
        !            53:        mtpr(ICCS, ICCS_IE);
        !            54: }
        !            55: 
        !            56: /* init system time from tod clock */
        !            57: /* ARGSUSED */
        !            58: ka630_clkread(base)
        !            59:        time_t base;
        !            60: {
        !            61:        register struct ka630clock *claddr = &ka630clock;
        !            62:        struct chiptime c;
        !            63: 
        !            64:        claddr->csr1 = KA630CLK_SET;
        !            65:        while ((claddr->csr0 & KA630CLK_UIP) != 0)
        !            66:                ;
        !            67:        /* If the clock is valid, use it. */
        !            68:        if ((claddr->csr3 & KA630CLK_VRT) != 0 &&
        !            69:            (claddr->csr1 & KA630CLK_ENABLE) == KA630CLK_ENABLE) {
        !            70:                c.sec = claddr->sec;
        !            71:                c.min = claddr->min;
        !            72:                c.hour = claddr->hr;
        !            73:                c.day = claddr->day;
        !            74:                c.mon = claddr->mon;
        !            75:                c.year = claddr->yr;
        !            76: #ifndef lint
        !            77:                { int t = claddr->csr2; }       /* ??? */
        !            78: #endif
        !            79:                claddr->csr0 = KA630CLK_RATE;
        !            80:                claddr->csr1 = KA630CLK_ENABLE;
        !            81: 
        !            82:                time.tv_sec = chiptotime(&c);
        !            83:                return (time.tv_sec ? CLKREAD_OK : CLKREAD_BAD);
        !            84:        }
        !            85:        printf("WARNING: TOY clock invalid");
        !            86:        return (CLKREAD_BAD);
        !            87: }
        !            88: 
        !            89: /* Set the time of day clock, called via. stime system call.. */
        !            90: ka630_clkwrite()
        !            91: {
        !            92:        register struct ka630clock *claddr = &ka630clock;
        !            93:        struct chiptime c;
        !            94:        int s;
        !            95: 
        !            96:        timetochip(&c);
        !            97:        s = splhigh();
        !            98:        claddr->csr1 = KA630CLK_SET;
        !            99:        while ((claddr->csr0 & KA630CLK_UIP) != 0)
        !           100:                ;
        !           101:        claddr->sec = c.sec;
        !           102:        claddr->min = c.min;
        !           103:        claddr->hr = c.hour;
        !           104:        claddr->day = c.day;
        !           105:        claddr->mon = c.mon;
        !           106:        claddr->yr = c.year;
        !           107: #ifndef lint
        !           108:        { int t = claddr->csr2; }       /* ??? */
        !           109:        { int t = claddr->csr3; }       /* ??? */
        !           110: #endif
        !           111:        claddr->csr0 = KA630CLK_RATE;
        !           112:        claddr->csr1 = KA630CLK_ENABLE;
        !           113:        splx(s);
        !           114: }
        !           115: 
        !           116: ka630_memnop()
        !           117: {
        !           118: 
        !           119:        /* void */
        !           120: }
        !           121: 
        !           122: #define NMC630 10
        !           123: char *mc630[] = {
        !           124:        0,              "immcr (fsd)",  "immcr (ssd)",  "fpu err 0",
        !           125:        "fpu err 7",    "mmu st(tb)",   "mmu st(m=0)",  "pte in p0",
        !           126:        "pte in p1",    "un intr id",
        !           127: };
        !           128: 
        !           129: struct mc630frame {
        !           130:        int     mc63_bcnt;              /* byte count == 0xc */
        !           131:        int     mc63_summary;           /* summary parameter */
        !           132:        int     mc63_mrvaddr;           /* most recent vad */
        !           133:        int     mc63_istate;            /* internal state */
        !           134:        int     mc63_pc;                /* trapped pc */
        !           135:        int     mc63_psl;               /* trapped psl */
        !           136: };
        !           137: 
        !           138: ka630_mchk(cmcf)
        !           139:        caddr_t cmcf;
        !           140: {
        !           141:        register struct ka630cpu *ka630addr = &ka630cpu;
        !           142:        register struct mc630frame *mcf = (struct mc630frame *)cmcf;
        !           143:        register u_int type = mcf->mc63_summary;
        !           144: 
        !           145:        printf("machine check %x", type);
        !           146:        if (type < NMC630 && mc630[type])
        !           147:                printf(": %s", mc630[type]);
        !           148:        printf("\n\tvap %x istate %x pc %x psl %x\n",
        !           149:            mcf->mc63_mrvaddr, mcf->mc63_istate,
        !           150:            mcf->mc63_pc, mcf->mc63_psl);
        !           151:        if (ka630addr->ka630_mser & KA630MSER_MERR) {
        !           152:                printf("\tmser=0x%x ", ka630addr->ka630_mser);
        !           153:                if (ka630addr->ka630_mser & KA630MSER_CPUER)
        !           154:                        printf("page=%d", ka630addr->ka630_cear);
        !           155:                if (ka630addr->ka630_mser & KA630MSER_DQPE)
        !           156:                        printf("page=%d", ka630addr->ka630_dear);
        !           157:                printf("\n");
        !           158:        }
        !           159:        return (MCHK_PANIC);
        !           160: }
        !           161: #endif

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