/* $NetBSD: ka780.c,v 1.35 2024/02/04 18:47:27 andvar Exp $ */ /*- * Copyright (c) 1982, 1986, 1988 The Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)ka780.c 7.4 (Berkeley) 5/9/91 */ /* * 780-specific code. */ #include __KERNEL_RCSID(0, "$NetBSD: ka780.c,v 1.35 2024/02/04 18:47:27 andvar Exp $"); #include #include #include #include #include #include #include #include #include "ioconf.h" #include "locators.h" static void ka780_memerr(void); static int ka780_mchk(void *); static void ka780_conf(void); static void ka780_attach_cpu(device_t); static int getsort(int type); static int mem_sbi_match(device_t, cfdata_t, void *); static void mem_sbi_attach(device_t, device_t, void *); CFATTACH_DECL_NEW(mem_sbi, sizeof(struct mem_softc), mem_sbi_match, mem_sbi_attach, NULL, NULL); int mem_sbi_match(device_t parent, cfdata_t cf, void *aux) { struct sbi_attach_args * const sa = aux; if (cf->cf_loc[SBICF_TR] != sa->sa_nexnum && cf->cf_loc[SBICF_TR] != SBICF_TR_DEFAULT) return 0; return getsort(sa->sa_type); } int getsort(int type) { switch (type) { case NEX_MEM4: case NEX_MEM4I: case NEX_MEM16: case NEX_MEM16I: return M780C; case NEX_MEM64I: case NEX_MEM64L: case NEX_MEM64LI: case NEX_MEM256I: case NEX_MEM256L: case NEX_MEM256LI: return M780EL; case NEX_MEM64U: case NEX_MEM64UI: case NEX_MEM256U: case NEX_MEM256UI: return M780EU; default: return M_NONE; } } static const char * const ka780_devs[] = { "cpu", "sbi", NULL }; /* * Declaration of 780-specific calls. */ const struct cpu_dep ka780_calls = { .cpu_mchk = ka780_mchk, .cpu_memerr = ka780_memerr, .cpu_conf = ka780_conf, .cpu_gettime = generic_gettime, .cpu_settime = generic_settime, .cpu_vups = 2, /* ~VUPS */ .cpu_scbsz = 5, /* SCB pages */ .cpu_devs = ka780_devs, .cpu_attach_cpu = ka780_attach_cpu, }; /* * Memory controller register usage varies per controller. */ struct mcr780 { int mc_reg[4]; }; #define M780_ICRD 0x40000000 /* inhibit crd interrupts, in [2] */ #define M780_HIER 0x20000000 /* high error rate, in reg[2] */ #define M780_ERLOG 0x10000000 /* error log request, in reg[2] */ /* on a 780, memory crd's occur only when bit 15 is set in the SBIER */ /* register; bit 14 there is an error bit which we also clear */ /* these bits are in the back of the ``red book'' (or in the VMS code) */ #define M780C_INH(mcr) \ ((mcr)->mc_reg[2] = (M780_ICRD|M780_HIER|M780_ERLOG)); \ mtpr(0, PR_SBIER); #define M780C_ENA(mcr) \ ((mcr)->mc_reg[2] = (M780_HIER|M780_ERLOG)); mtpr(3<<14, PR_SBIER); #define M780C_ERR(mcr) \ ((mcr)->mc_reg[2] & (M780_ERLOG)) #define M780C_SYN(mcr) ((mcr)->mc_reg[2] & 0xff) #define M780C_ADDR(mcr) (((mcr)->mc_reg[2] >> 8) & 0xfffff) #define M780EL_INH(mcr) \ ((mcr)->mc_reg[2] = (M780_ICRD|M780_HIER|M780_ERLOG)); \ mtpr(0, PR_SBIER); #define M780EL_ENA(mcr) \ ((mcr)->mc_reg[2] = (M780_HIER|M780_ERLOG)); mtpr(3<<14, PR_SBIER); #define M780EL_ERR(mcr) \ ((mcr)->mc_reg[2] & (M780_ERLOG)) #define M780EL_SYN(mcr) ((mcr)->mc_reg[2] & 0x7f) #define M780EL_ADDR(mcr) (((mcr)->mc_reg[2] >> 11) & 0x1ffff) #define M780EU_INH(mcr) \ ((mcr)->mc_reg[3] = (M780_ICRD|M780_HIER|M780_ERLOG)); \ mtpr(0, PR_SBIER); #define M780EU_ENA(mcr) \ ((mcr)->mc_reg[3] = (M780_HIER|M780_ERLOG)); mtpr(3<<14, PR_SBIER); #define M780EU_ERR(mcr) \ ((mcr)->mc_reg[3] & (M780_ERLOG)) #define M780EU_SYN(mcr) ((mcr)->mc_reg[3] & 0x7f) #define M780EU_ADDR(mcr) (((mcr)->mc_reg[3] >> 11) & 0x1ffff) /* enable crd interrupts */ void mem_sbi_attach(device_t parent, device_t self, void *aux) { struct sbi_attach_args * const sa = (struct sbi_attach_args *)aux; struct mem_softc * const sc = device_private(self); struct mcr780 * const mcr = (void *)sa->sa_ioh; /* XXX */ sc->sc_dev = self; sc->sc_memaddr = (void *)sa->sa_ioh; /* XXX */ sc->sc_memtype = getsort(sa->sa_type); sc->sc_memnr = sa->sa_type; switch (sc->sc_memtype) { case M780C: aprint_normal(": standard"); M780C_ENA(mcr); break; case M780EL: aprint_normal(": (el) "); M780EL_ENA(mcr); if (sc->sc_memnr != NEX_MEM64I && sc->sc_memnr != NEX_MEM256I) break; case M780EU: aprint_normal(": (eu)"); M780EU_ENA(mcr); break; } printf("\n"); } #ifdef TRENDATA /* * Figure out what chip to replace on Trendata boards. * Assumes all your memory is Trendata or the non-Trendata * memory never fails.. */ const struct { u_char m_syndrome; char m_chip[4]; } memlogtab[] = { {0x01, "C00"}, {0x02, "C01"}, {0x04, "C02"}, {0x08, "C03"}, {0x10, "C04"}, {0x19, "L01"}, {0x1A, "L02"}, {0x1C, "L04"}, {0x1F, "L07"}, {0x20, "C05"}, {0x38, "L00"}, {0x3B, "L03"}, {0x3D, "L05"}, {0x3E, "L06"}, {0x40, "C06"}, {0x49, "L09"}, {0x4A, "L10"}, {0x4c, "L12"}, {0x4F, "L15"}, {0x51, "L17"}, {0x52, "L18"}, {0x54, "L20"}, {0x57, "L23"}, {0x58, "L24"}, {0x5B, "L27"}, {0x5D, "L29"}, {0x5E, "L30"}, {0x68, "L08"}, {0x6B, "L11"}, {0x6D, "L13"}, {0x6E, "L14"}, {0x70, "L16"}, {0x73, "L19"}, {0x75, "L21"}, {0x76, "L22"}, {0x79, "L25"}, {0x7A, "L26"}, {0x7C, "L28"}, {0x7F, "L31"}, {0x80, "C07"}, {0x89, "U01"}, {0x8A, "U02"}, {0x8C, "U04"}, {0x8F, "U07"}, {0x91, "U09"}, {0x92, "U10"}, {0x94, "U12"}, {0x97, "U15"}, {0x98, "U16"}, {0x9B, "U19"}, {0x9D, "U21"}, {0x9E, "U22"}, {0xA8, "U00"}, {0xAB, "U03"}, {0xAD, "U05"}, {0xAE, "U06"}, {0xB0, "U08"}, {0xB3, "U11"}, {0xB5, "U13"}, {0xB6, "U14"}, {0xB9, "U17"}, {0xBA, "U18"}, {0xBC, "U20"}, {0xBF, "U23"}, {0xC1, "U25"}, {0xC2, "U26"}, {0xC4, "U28"}, {0xC7, "U31"}, {0xE0, "U24"}, {0xE3, "U27"}, {0xE5, "U29"}, {0xE6, "U30"} }; static void memlog(int m, struct mcr780 *mcr) { int i; for (i = 0; i < __arraycount(memlogtab); i++) if ((u_char)(M780C_SYN(mcr)) == memlogtab[i].m_syndrome) { printf( "mcr%d: replace %s chip in %s bank of memory" " board %d (0-15)\n", m, memlogtab[i].m_chip, (M780C_ADDR(mcr) & 0x8000) ? "upper" : "lower", (M780C_ADDR(mcr) >> 16)); return; } printf("mcr%d: multiple errors, not traceable\n", m); } #endif /* TRENDATA */ /* log crd errors */ void ka780_memerr(void) { struct mem_softc *sc; struct mcr780 *mcr; int m; for (m = 0; m < mem_cd.cd_ndevs; m++) { sc = device_lookup_private(&mem_cd, m); if (sc == NULL) continue; mcr = (struct mcr780 *)sc->sc_memaddr; switch (sc->sc_memtype) { case M780C: if (M780C_ERR(mcr)) { aprint_error_dev(sc->sc_dev, "soft ecc addr %x syn %x\n", M780C_ADDR(mcr), M780C_SYN(mcr)); #ifdef TRENDATA memlog(m, mcr); #endif M780C_INH(mcr); } break; case M780EL: if (M780EL_ERR(mcr)) { aprint_error_dev(sc->sc_dev, "soft ecc addr %x syn %x\n", M780EL_ADDR(mcr), M780EL_SYN(mcr)); M780EL_INH(mcr); } if (sc->sc_memnr != NEX_MEM64I && sc->sc_memnr != NEX_MEM256I) break; case M780EU: if (M780EU_ERR(mcr)) { aprint_error_dev(sc->sc_dev, "soft ecc addr %x syn %x\n", M780EU_ADDR(mcr), M780EU_SYN(mcr)); M780EU_INH(mcr); } break; } } } const char mc780[][3] = { "0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15" }; struct mc780frame { int mc8_bcnt; /* byte count == 0x28 */ int mc8_summary; /* summary parameter (as above) */ int mc8_cpues; /* cpu error status */ int mc8_upc; /* micro pc */ int mc8_vaviba; /* va/viba register */ int mc8_dreg; /* d register */ int mc8_tber0; /* tbuf error reg 0 */ int mc8_tber1; /* tbuf error reg 1 */ int mc8_timo; /* timeout address divided by 4 */ int mc8_parity; /* parity */ int mc8_sbier; /* sbi error register */ int mc8_pc; /* trapped pc */ int mc8_psl; /* trapped psl */ }; int ka780_mchk(void *cmcf) { struct mc780frame * const mcf = (struct mc780frame *)cmcf; int type = mcf->mc8_summary; int sbifs; printf("machine check %x: %s%s\n", type, mc780[type&0xf], (type&0xf0) ? " abort" : " fault"); printf("\tcpues %x upc %x va/viba %x dreg %x tber %x %x\n", mcf->mc8_cpues, mcf->mc8_upc, mcf->mc8_vaviba, mcf->mc8_dreg, mcf->mc8_tber0, mcf->mc8_tber1); sbifs = mfpr(PR_SBIFS); printf("\ttimo %x parity %x sbier %x pc %x psl %x sbifs %x\n", mcf->mc8_timo*4, mcf->mc8_parity, mcf->mc8_sbier, mcf->mc8_pc, mcf->mc8_psl, sbifs); /* THE FUNNY BITS IN THE FOLLOWING ARE FROM THE ``BLACK BOOK'' */ /* AND SHOULD BE PUT IN AN ``sbi.h'' */ mtpr(sbifs &~ 0x2000000, PR_SBIFS); mtpr(mfpr(PR_SBIER) | 0x70c0, PR_SBIER); return (MCHK_PANIC); } struct ka78x { unsigned snr:12, plant:3, eco:8, v785:1, type:8; }; void ka780_conf(void) { /* Enable cache */ mtpr(0x200000, PR_SBIMT); } void ka780_attach_cpu(device_t self) { struct ka78x * const ka78 = (void *)&vax_cpudata; aprint_normal(": KA%s, S/N %d(%d), hardware ECO level %d(%d)\n", cpu_getmodel() + 7, ka78->snr, ka78->plant, ka78->eco >> 4, ka78->eco); aprint_normal_dev(self, "4KB L1 cache"); if (mfpr(PR_ACCS) & 255) { aprint_normal(", FPA present\n"); mtpr(0x8000, PR_ACCS); } else aprint_normal(", no FPA\n"); }