![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ka820.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vax|
Return to ka820.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vax |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Chris Torek.
7: *
8: * Redistribution is only permitted until one year after the first shipment
9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
10: * binary forms are permitted provided that: (1) source distributions retain
11: * this entire copyright notice and comment, and (2) distributions including
12: * binaries display the following acknowledgement: This product includes
13: * software developed by the University of California, Berkeley and its
14: * contributors'' in the documentation or other materials provided with the
15: * distribution and in all advertising materials mentioning features or use
16: * of this software. Neither the name of the University nor the names of
17: * its contributors may be used to endorse or promote products derived from
18: * this software without specific prior written permission.
19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22: *
23: * @(#)ka820.c 7.3 (Berkeley) 6/28/90
24: */
25:
26: #if VAX8200
27:
28: /*
29: * KA820 specific CPU code. (Note that the VAX8200 uses a KA820, not
30: * a KA8200. Sigh.)
31: */
32:
33: #include "param.h"
34: #include "time.h"
35: #include "kernel.h"
36: #include "vmmac.h"
37:
38: #include "cpu.h"
39: #include "clock.h"
40: #include "ka820.h"
41: #include "mem.h"
42: #include "mtpr.h"
43: #include "pte.h"
44:
45: #include "../vaxbi/bireg.h"
46:
47: extern struct pte Clockmap[];
48: extern struct pte RX50map[];
49: extern struct pte Ka820map[];
50: struct ka820clock ka820clock;
51: struct ka820port ka820port;
52:
53: #ifdef notyet
54: extern struct pte BRAMmap[];
55: extern struct pte EEPROMmap[];
56: char bootram[KA820_BRPAGES * NBPG];
57: char eeprom[KA820_EEPAGES * NBPG];
58: #endif
59:
60: ka820_init()
61: {
62: register int csr;
63:
64: /* map in the various devices */
65: *(int *)&Ka820map[0] = PG_V|PG_KW|btop(KA820_PORTADDR);
66: *(int *)&RX50map[0] = PG_V|PG_KW|btop(KA820_RX50ADDR);
67: *(int *)&Clockmap[0] = PG_V|PG_KW|btop(KA820_CLOCKADDR);
68: #ifdef notyet
69: ioaccess(bootram, BRAMmap, KA820_BRPAGES * NBPG);
70: ioaccess(eeprom, EEPROMmap, KA820_EEPAGES * NBPG);
71: #else
72: mtpr(TBIA, 0);
73: #endif
74:
75: /* reset the console and enable the RX50 */
76: csr = ka820port.csr;
77: csr &= ~KA820PORT_RSTHALT; /* ??? */
78: csr |= KA820PORT_CONSCLR | KA820PORT_CRDCLR | KA820PORT_CONSEN |
79: KA820PORT_RXIE;
80: ka820port.csr = csr;
81: }
82:
83: /* Set system time from clock */
84: /* ARGSUSED */
85: ka820_clkread(base)
86: time_t base;
87: {
88: register struct ka820clock *clock = &ka820clock;
89: struct chiptime c;
90: int s, rv;
91:
92: rv = CLKREAD_OK;
93: /* I wish I knew the differences between these */
94: if ((clock->csr3 & KA820CLK_3_VALID) == 0) {
95: printf("WARNING: TOY clock not marked valid\n");
96: rv = CLKREAD_WARN;
97: }
98: if ((clock->csr1 & KA820CLK_1_GO) != KA820CLK_1_GO) {
99: printf("WARNING: TOY clock stopped\n");
100: rv = CLKREAD_WARN;
101: }
102: /* THIS IS NOT RIGHT (clock may change on us) */
103: s = splhigh();
104: while (clock->csr0 & KA820CLK_0_BUSY)
105: /* void */;
106: c.sec = clock->sec;
107: c.min = clock->min;
108: c.hour = clock->hr;
109: c.day = clock->day;
110: c.mon = clock->mon;
111: c.year = clock->yr;
112: splx(s);
113:
114: /* the darn thing needs tweaking! */
115: c.sec >>= 1; /* tweak */
116: c.min >>= 1; /* tweak */
117: c.hour >>= 1; /* tweak */
118: c.day >>= 1; /* tweak */
119: c.mon >>= 1; /* tweak */
120: c.year >>= 1; /* tweak */
121:
122: time.tv_sec = chiptotime(&c);
123: return (time.tv_sec ? rv : CLKREAD_BAD);
124: }
125:
126: /* store time into clock */
127: ka820_clkwrite()
128: {
129: register struct ka820clock *clock = &ka820clock;
130: struct chiptime c;
131: int s;
132:
133: timetochip(&c);
134:
135: /* play it again, sam (or mike or kirk or ...) */
136: c.sec <<= 1; /* tweak */
137: c.min <<= 1; /* tweak */
138: c.hour <<= 1; /* tweak */
139: c.day <<= 1; /* tweak */
140: c.mon <<= 1; /* tweak */
141: c.year <<= 1; /* tweak */
142:
143: s = splhigh();
144: clock->csr1 = KA820CLK_1_SET;
145: while (clock->csr0 & KA820CLK_0_BUSY)
146: /* void */;
147: clock->sec = c.sec;
148: clock->min = c.min;
149: clock->hr = c.hour;
150: clock->day = c.day;
151: clock->mon = c.mon;
152: clock->yr = c.year;
153: /* should we set a `rate'? */
154: clock->csr1 = KA820CLK_1_GO;
155: splx(s);
156: }
157:
158: /*
159: * MS820 support.
160: */
161: struct ms820regs {
162: struct biiregs biic; /* BI interface chip */
163: u_long ms_gpr[4]; /* the four gprs (unused) */
164: int ms_csr1; /* control/status register 1 */
165: int ms_csr2; /* control/status register 2 */
166: };
167:
168: /*
169: * Bits in CSR1.
170: */
171: #define MS1_ERRSUM 0x80000000 /* error summary (ro) */
172: #define MS1_ECCDIAG 0x40000000 /* ecc diagnostic (rw) */
173: #define MS1_ECCDISABLE 0x20000000 /* ecc disable (rw) */
174: #define MS1_MSIZEMASK 0x1ffc0000 /* mask for memory size (ro) */
175: #define MS1_RAMTYMASK 0x00030000 /* mask for ram type (ro) */
176: #define MS1_RAMTY64K 0x00000000 /* 64K chips */
177: #define MS1_RAMTY256K 0x00010000 /* 256K chips */
178: /* types 2 and 3 reserved */
179: #define MS1_CRDINH 0x00008000 /* inhibit crd interrupts (rw) */
180: #define MS1_MEMVALID 0x00004000 /* memory has been written (ro) */
181: #define MS1_INTLK 0x00002000 /* interlock flag (ro) */
182: #define MS1_BROKE 0x00001000 /* broken (rw) */
183: #define MS1_MBZ 0x00000880 /* zero */
184: #define MS1_MWRITEERR 0x00000400 /* rds during masked write (rw) */
185: #define MS1_CNTLERR 0x00000200 /* internal timing busted (rw) */
186: #define MS1_INTLV 0x00000100 /* internally interleaved (ro) */
187: #define MS1_DIAGC 0x0000007f /* ecc diagnostic bits (rw) */
188:
189: /*
190: * Bits in CSR2.
191: */
192: #define MS2_RDSERR 0x80000000 /* rds error (rw) */
193: #define MS2_HIERR 0x40000000 /* high error rate (rw) */
194: #define MS2_CRDERR 0x20000000 /* crd error (rw) */
195: #define MS2_ADRSERR 0x10000000 /* rds due to addr par err (rw) */
196: #define MS2_MBZ 0x0f000080 /* zero */
197: #define MS2_ADDR 0x00fffe00 /* address in error (relative) (ro) */
198: #define MS2_INTLVADDR 0x00000100 /* error was in bank 1 (ro) */
199: #define MS2_SYN 0x0000007f /* error syndrome (ro, rw diag) */
200:
201:
202: ka820_memenable()
203: {
204: register struct ms820regs *mcr;
205: register int m;
206:
207: for (m = 0; m < nmcr; m++) {
208: mcr = (struct ms820regs *)mcraddr[m];
209: /*
210: * This will be noisy. Should we do anything
211: * about that?
212: */
213: if ((mcr->biic.bi_csr & BICSR_STS) == 0)
214: printf("mcr%d: failed self test\n", m);
215: else {
216: mcr->ms_csr1 = MS1_MWRITEERR | MS1_CNTLERR;
217: mcr->ms_csr2 = MS2_RDSERR | MS2_HIERR |
218: MS2_CRDERR | MS2_ADRSERR;
219: }
220: }
221: }
222:
223: ka820_memerr()
224: {
225: register struct ms820regs *mcr;
226: register int m, hard;
227: register char *type;
228: static char b1[] = "\20\40ERRSUM\37ECCDIAG\36ECCDISABLE\20CRDINH\17VALID\
229: \16INTLK\15BROKE\13MWRITEERR\12CNTLERR\11INTLV";
230: static char b2[] = "\20\40RDS\37HIERR\36CRD\35ADRS";
231:
232: for (m = 0; m < nmcr; m++) {
233: mcr = (struct ms820regs *)mcraddr[m];
234: printf("mcr%d: csr1=%b csr2=%b\n", m, mcr->ms_csr1, b1, mcr->ms_csr2, b2);
235: if ((mcr->ms_csr1 & MS1_ERRSUM) == 0)
236: continue;
237: hard = 1;
238: if (mcr->ms_csr1 & MS1_BROKE)
239: type = "broke";
240: else if (mcr->ms_csr1 & MS1_CNTLERR)
241: type = "cntl err";
242: else if (mcr->ms_csr2 & MS2_ADRSERR)
243: type = "address parity err";
244: else if (mcr->ms_csr2 & MS2_RDSERR)
245: type = "rds err";
246: else if (mcr->ms_csr2 & MS2_CRDERR) {
247: hard = 0;
248: type = "";
249: } else
250: type = "mysterious error";
251: printf("mcr%d: %s%s%s addr %x bank %x syn %x\n", m,
252: hard ? "hard error: " : "soft ecc",
253: type, mcr->ms_csr2 & MS2_HIERR ?
254: " (+ other rds or crd err)" : "",
255: ((mcr->ms_csr2 & MS2_ADDR) + mcr->biic.bi_sadr) >> 9,
256: (mcr->ms_csr2 & MS2_INTLVADDR) != 0,
257: mcr->ms_csr2 & MS2_SYN);
258: mcr->ms_csr1 = mcr->ms_csr1 | MS1_CRDINH;
259: mcr->ms_csr2 = mcr->ms_csr2;
260: }
261: }
262:
263: /* these are bits 0 to 6 in the summary field */
264: char *mc8200[] = {
265: "cpu bad ipl", "ucode lost err",
266: "ucode par err", "DAL par err",
267: "BI bus err", "BTB tag par",
268: "cache tag par",
269: };
270: #define MC8200_BADIPL 0x01
271: #define MC8200_UERR 0x02
272: #define MC8200_UPAR 0x04
273: #define MC8200_DPAR 0x08
274: #define MC8200_BIERR 0x10
275: #define MC8200_BTAGPAR 0x20
276: #define MC8200_CTAGPAR 0x40
277:
278: struct mc8200frame {
279: int mc82_bcnt; /* byte count == 0x20 */
280: int mc82_summary; /* summary parameter */
281: int mc82_param1; /* parameter 1 */
282: int mc82_va; /* va register */
283: int mc82_vap; /* va prime register */
284: int mc82_ma; /* memory address */
285: int mc82_status; /* status word */
286: int mc82_epc; /* error pc */
287: int mc82_upc; /* micro pc */
288: int mc82_pc; /* current pc */
289: int mc82_psl; /* current psl */
290: };
291:
292: ka820_mchk(cmcf)
293: caddr_t cmcf;
294: {
295: register struct mc8200frame *mcf = (struct mc8200frame *)cmcf;
296: register int i, type = mcf->mc82_summary;
297: extern int cold;
298:
299: /* ignore BI bus errors during configuration */
300: if (cold && type == MC8200_BIERR) {
301: mtpr(MCESR, 0xf);
302: return (MCHK_RECOVERED);
303: }
304:
305: /*
306: * SOME ERRORS ARE RECOVERABLE
307: * do it later
308: */
309: printf("machine check %x: ", type);
310: for (i = 0; i < sizeof (mc8200) / sizeof (mc8200[0]); i++)
311: if (type & (1 << i))
312: printf(" %s,", mc8200[i]);
313: printf(" param1 %x\n", mcf->mc82_param1);
314: printf(
315: "\tva %x va' %x ma %x pc %x psl %x\n\tstatus %x errpc %x upc %x\n",
316: mcf->mc82_va, mcf->mc82_vap, mcf->mc82_ma,
317: mcf->mc82_pc, mcf->mc82_psl,
318: mcf->mc82_status, mcf->mc82_epc, mcf->mc82_upc);
319: return (MCHK_PANIC);
320: }
321:
322: /*
323: * Receive a character from logical console.
324: */
325: rxcdintr()
326: {
327: register int c = mfpr(RXCD);
328:
329: /* not sure what (if anything) to do with these */
330: printf("rxcd node %x c=0x%x\n", (c >> 8) & 0xf, c & 0xff);
331: }
332: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.