Return to autoconf.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982,1986 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:  *     @(#)autoconf.c  7.18 (Berkeley) 9/3/89
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  * Setup the system to run on the current machine.
        !            11:  *
        !            12:  * Configure() is called at boot time and initializes the uba and mba
        !            13:  * device tables and the memory controller monitoring.  Available
        !            14:  * devices are determined (from possibilities mentioned in ioconf.c),
        !            15:  * and the drivers are initialized.
        !            16:  */
        !            17: 
        !            18: #include "mba.h"
        !            19: #include "uba.h"
        !            20: #include "kra.h"               /* XXX wrong file */
        !            21: 
        !            22: #include "param.h"
        !            23: #include "systm.h"
        !            24: #include "map.h"
        !            25: #include "buf.h"
        !            26: #include "dkstat.h"
        !            27: #include "vm.h"
        !            28: #include "malloc.h"
        !            29: #include "conf.h"
        !            30: #include "dmap.h"
        !            31: #include "reboot.h"
        !            32: 
        !            33: #include "pte.h"
        !            34: #include "cpu.h"
        !            35: #include "mem.h"
        !            36: #include "mtpr.h"
        !            37: #include "nexus.h"
        !            38: #include "scb.h"
        !            39: #include "ioa.h"
        !            40: #include "../vaxbi/bireg.h"
        !            41: #include "../vaxmba/mbareg.h"
        !            42: #include "../vaxmba/mbavar.h"
        !            43: #include "../vaxuba/ubareg.h"
        !            44: #include "../vaxuba/ubavar.h"
        !            45: 
        !            46: /*
        !            47:  * The following several variables are related to
        !            48:  * the configuration process, and are used in initializing
        !            49:  * the machine.
        !            50:  */
        !            51: int    cold;           /* if 1, still working on cold-start */
        !            52: int    dkn;            /* number of iostat dk numbers assigned so far */
        !            53: int    cpuspeed = 1;   /* relative cpu speed */
        !            54: 
        !            55: /*
        !            56:  * Addresses of the (locore) routines which bootstrap us from
        !            57:  * hardware traps to C code.  Filled into the system control block
        !            58:  * as necessary.
        !            59:  *
        !            60:  * RIDICULOUS!  CONFIG SHOULD GENERATE AN ioconf.h FOR US, with
        !            61:  * mba glue also in `glue.s'.  (Unibus adapter glue is special, though.)
        !            62:  */
        !            63: #if NMBA > 0
        !            64: int    (*mbaintv[4])() =       { Xmba0int, Xmba1int, Xmba2int, Xmba3int };
        !            65: #if NMBA > 4
        !            66:        Need to expand the table for more than 4 massbus adaptors
        !            67: #endif
        !            68: #endif
        !            69: #if defined(VAX780) || defined(VAX8600)
        !            70: int    (*ubaintv[])() =
        !            71: {
        !            72:        Xua0int, Xua1int, Xua2int, Xua3int,
        !            73: #if NUBA > 4
        !            74:        Xua4int, Xua5int, Xua6int, Xua7int,
        !            75: #endif
        !            76: #if NUBA > 8
        !            77:        Need to expand the table for more than 8 unibus adaptors
        !            78: #endif
        !            79: };
        !            80: #endif
        !            81: #if NKDB > 0
        !            82: /* kdb50 driver does not appear in udminit[] (not without csr!) */
        !            83: int    Xkdbintr0();            /* generated by autoconf */
        !            84: int    (*kdbintv[])() = { Xkdbintr0 };
        !            85: #if NKDB > 1
        !            86:        Need to expand the table for more than 1 KDB adapter
        !            87: #endif
        !            88: #endif
        !            89: 
        !            90: /*
        !            91:  * This allocates the space for the per-uba information,
        !            92:  * such as buffered data path usage.
        !            93:  */
        !            94: struct uba_hd uba_hd[NUBA];
        !            95: 
        !            96: /*
        !            97:  * Determine mass storage and memory configuration for a machine.
        !            98:  * Get cpu type, and then switch out to machine specific procedures
        !            99:  * which will probe adaptors to see what is out there.
        !           100:  */
        !           101: configure()
        !           102: {
        !           103:        union cpusid cpusid;
        !           104:        register struct percpu *ocp;
        !           105:        register struct pte *ip;
        !           106: 
        !           107:        cpusid.cpusid = mfpr(SID);
        !           108:        switch (cpusid.cpuany.cp_type) {
        !           109: #if VAX8600
        !           110:        case VAX_8600:
        !           111:                printf("VAX 8600, serial# %d(%d), hardware ECO level %d(%d)\n",
        !           112:                        cpusid.cpu8600.cp_sno, cpusid.cpu8600.cp_plant,
        !           113:                        cpusid.cpu8600.cp_eco >> 4, cpusid.cpu8600.cp_eco);
        !           114:                break;
        !           115: #endif
        !           116: #if VAX8200
        !           117:        case VAX_8200:
        !           118:                printf("\
        !           119: VAX 82%c0, hardware rev %d, ucode patch rev %d, sec patch %d, ucode rev %d\n",
        !           120:                        cpusid.cpu8200.cp_5 ? '5' : '0',
        !           121:                        cpusid.cpu8200.cp_hrev, cpusid.cpu8200.cp_patch,
        !           122:                        cpusid.cpu8200.cp_secp, cpusid.cpu8200.cp_urev);
        !           123:                mastercpu = mfpr(BINID);
        !           124:                break;
        !           125: #endif
        !           126: #if VAX780
        !           127:        case VAX_780:
        !           128:                printf("\
        !           129: VAX 11/78%c, serial# %d(%d), hardware ECO level %d(%d)\n",
        !           130:                        cpusid.cpu780.cp_5 ? '5' : '0',
        !           131:                        cpusid.cpu780.cp_sno, cpusid.cpu780.cp_plant,
        !           132:                        cpusid.cpu780.cp_eco >> 4, cpusid.cpu780.cp_eco);
        !           133:                break;
        !           134: #endif
        !           135: #if VAX750
        !           136:        case VAX_750:
        !           137:                printf("VAX 11/750, hardware rev %d, ucode rev %d\n",
        !           138:                        cpusid.cpu750.cp_hrev, cpusid.cpu750.cp_urev);
        !           139:                break;
        !           140: #endif
        !           141: #if VAX730
        !           142:        case VAX_730:
        !           143:                printf("VAX 11/730, ucode rev %d\n", cpusid.cpu730.cp_urev);
        !           144:                break;
        !           145: #endif
        !           146: #if VAX630
        !           147:        case VAX_630:
        !           148:                printf("MicroVAX-II\n");
        !           149:                break;
        !           150: #endif
        !           151: #if VAX650
        !           152:        case VAX_650:
        !           153:                printf("MicroVAX 3000, ucode rev %d\n", cpusid.cpu650.cp_urev);
        !           154:                break;
        !           155: #endif
        !           156:        }
        !           157:        for (ocp = percpu; ocp->pc_cputype; ocp++)
        !           158:                if (ocp->pc_cputype == cpusid.cpuany.cp_type) {
        !           159:                        cpuspeed = ocp->pc_cpuspeed;
        !           160:                        cpuops = ocp->pc_ops;
        !           161:                        if (cpuops->cpu_init != NULL)
        !           162:                                (*cpuops->cpu_init)();
        !           163:                        probeio(ocp);
        !           164:                        /*
        !           165:                         * Write protect the scb and UNIBUS interrupt vectors.
        !           166:                         * It is strange that this code is here, but this is
        !           167:                         * as soon as we are done mucking with it, and the
        !           168:                         * write-enable was done in assembly language
        !           169:                         * to which we will never return.
        !           170:                         */
        !           171:                        for (ip = kvtopte(scb); ip < kvtopte(eUNIvec); ip++) {
        !           172:                                *(int *)ip &= ~PG_PROT;
        !           173:                                *(int *)ip |= PG_KR;
        !           174:                        }
        !           175:                        mtpr(TBIA, 0);
        !           176: #if GENERIC
        !           177:                        if ((boothowto & RB_ASKNAME) == 0)
        !           178:                                setroot();
        !           179:                        setconf();
        !           180: #else
        !           181:                        setroot();
        !           182: #endif
        !           183:                        /*
        !           184:                         * Configure swap area and related system
        !           185:                         * parameter based on device(s) used.
        !           186:                         */
        !           187:                        swapconf();
        !           188:                        cold = 0;
        !           189:                        memenable();
        !           190:                        return;
        !           191:                }
        !           192:        printf("cpu type %d not configured\n", cpusid.cpuany.cp_type);
        !           193:        asm("halt");
        !           194: }
        !           195: 
        !           196: #if VAX8600 || VAX780 || VAX750 || VAX730
        !           197: int    nexnum;         /* current nexus number */
        !           198: int    nsbi;           /* current sbi number */
        !           199: #endif
        !           200: #if VAX8200
        !           201: int    numkdb;         /* current ``kdb'' number */
        !           202: int    bi_nodes;       /* XXX remembers found bi nodes */
        !           203: #endif
        !           204: 
        !           205: /*
        !           206:  * Probe the main IO bus(es).
        !           207:  * The percpu structure gives us a handle on the addresses and/or types.
        !           208:  */
        !           209: probeio(pcpu)
        !           210:        register struct percpu *pcpu;
        !           211: {
        !           212:        register struct iobus *iob;
        !           213:        int ioanum;
        !           214: 
        !           215:        ioanum = 0;
        !           216:        for (iob = pcpu->pc_io; ioanum < pcpu->pc_nioa; ioanum++, iob++) {
        !           217: 
        !           218:                switch (iob->io_type) {
        !           219: 
        !           220: #if VAX630 || VAX650
        !           221:                case IO_QBUS:
        !           222:                        probeqbus((struct qbus *)iob->io_details);
        !           223:                        break;
        !           224: #endif
        !           225: 
        !           226: #if VAX780 || VAX750 || VAX730
        !           227:                case IO_SBI780:
        !           228:                case IO_CMI750:
        !           229:                case IO_XXX730:
        !           230:                        probenexi((struct nexusconnect *)iob->io_details);
        !           231:                        break;
        !           232: #endif
        !           233: 
        !           234: #if VAX8600
        !           235:                case IO_ABUS:
        !           236:                        probe_Abus(ioanum, iob);
        !           237:                        break;
        !           238: #endif
        !           239: 
        !           240: #if VAX8200
        !           241:                case IO_BI:
        !           242:                        probe_bi((struct bibus *)iob->io_details);
        !           243:                        break;
        !           244: #endif
        !           245: 
        !           246:                default:
        !           247:                        if (iob->io_addr) {
        !           248:                            printf(
        !           249:                "IO adaptor %d, type %d, at address 0x%x is unsupported\n",
        !           250:                                ioanum, iob->io_type, iob->io_addr);
        !           251:                        } else
        !           252:                            printf("IO adaptor %d, type %d, is unsupported\n",
        !           253:                                ioanum, iob->io_type);
        !           254:                        break;
        !           255:                }
        !           256:        }
        !           257: }
        !           258: 
        !           259: #if VAX8600
        !           260: probe_Abus(ioanum, iob)
        !           261:        register struct iobus *iob;
        !           262: {
        !           263:        register struct ioa *ioap;
        !           264:        union ioacsr ioacsr;
        !           265:        int type;
        !           266:        struct sbia_regs *sbiaregs;
        !           267: #ifdef notyet
        !           268:        int sbi1fail(), sbi1alert(), sbi1fault(), sbi1err();
        !           269: #endif
        !           270: 
        !           271:        ioap = &ioa[ioanum];
        !           272:        ioaccess(iob->io_addr, Ioamap[ioanum], iob->io_size);
        !           273:        if (badaddr((caddr_t)ioap, 4))
        !           274:                return;
        !           275:        ioacsr.ioa_csr = ioap->ioacsr.ioa_csr;
        !           276:        type = ioacsr.ioa_type & IOA_TYPMSK;
        !           277: 
        !           278:        switch (type) {
        !           279: 
        !           280:        case IOA_SBIA:
        !           281:                printf("SBIA%d at IO adaptor %d address 0x%x\n",
        !           282:                    nsbi, ioanum, iob->io_addr);
        !           283: #ifdef notyet
        !           284:                /* I AM NOT SURE THESE ARE IN THE SAME PLACES */
        !           285:                if (nscb == 1) {
        !           286:                        scb[1].scb_sbifail = scbentry(sbi1fail, SCB_ISTACK);
        !           287:                        /* maybe not sbifail, maybe scb1.scb_cmrd */
        !           288:                        /* but how can I find out without a broken SBIA1? */
        !           289:                        scb[1].scb_sbialert = scbentry(sbi1alert, SCB_ISTACK);
        !           290:                        scb[1].scb_sbifault = scbentry(sbi1fault, SCB_ISTACK);
        !           291:                        scb[1].scb_sbierr = scbentry(sbi1err, SCB_ISTACK);
        !           292:                }
        !           293: #endif
        !           294:                probenexi((struct nexusconnect *)iob->io_details);
        !           295:                nsbi++;
        !           296:                sbiaregs = (struct sbia_regs *)ioap;
        !           297:                sbiaregs->sbi_errsum = -1;
        !           298:                sbiaregs->sbi_error = 0x1000;
        !           299:                sbiaregs->sbi_fltsts = 0xc0000;
        !           300:                break;
        !           301: 
        !           302:        default:
        !           303:                printf("IOA%d at address 0x%x is unsupported (type = 0x%x)\n",
        !           304:                    ioanum, iob->io_addr, ioacsr.ioa_type);
        !           305:                break;
        !           306:        }
        !           307: }
        !           308: #endif
        !           309: 
        !           310: #if VAX8600 || VAX780 || VAX750 || VAX730
        !           311: /*
        !           312:  * Probe nexus space, finding the interconnects
        !           313:  * and setting up and probing mba's and uba's for devices.
        !           314:  */
        !           315: probenexi(pnc)
        !           316:        register struct nexusconnect *pnc;
        !           317: {
        !           318:        register struct nexus *nxv;
        !           319:        struct nexus *nxp = pnc->psb_nexbase;
        !           320:        union nexcsr nexcsr;
        !           321:        int i;
        !           322: 
        !           323:        ioaccess((caddr_t)nxp, Nexmap[nsbi * NNEXSBI],
        !           324:            pnc->psb_nnexus * sizeof(struct nexus));
        !           325:        nxv = &nexus[nsbi * NNEXSBI];
        !           326:        for (nexnum = 0; nexnum < pnc->psb_nnexus; nexnum++, nxp++, nxv++) {
        !           327:                if (badaddr((caddr_t)nxv, 4))
        !           328:                        continue;
        !           329:                if (pnc->psb_nextype && pnc->psb_nextype[nexnum] != NEX_ANY)
        !           330:                        nexcsr.nex_csr = pnc->psb_nextype[nexnum];
        !           331:                else
        !           332:                        nexcsr = nxv->nexcsr;
        !           333:                if (nexcsr.nex_csr&NEX_APD)
        !           334:                        continue;
        !           335:                switch (nexcsr.nex_type) {
        !           336: 
        !           337:                case NEX_MBA:
        !           338:                        printf("mba%d at tr%d\n", nummba, nexnum);
        !           339:                        if (nummba >= NMBA) {
        !           340:                                printf("%d mba's", ++nummba);
        !           341:                                goto unconfig;
        !           342:                        }
        !           343: #if NMBA > 0
        !           344:                        mbafind(nxv, nxp);
        !           345:                        nummba++;
        !           346: #endif
        !           347:                        break;
        !           348: 
        !           349:                case NEX_UBA0:
        !           350:                case NEX_UBA1:
        !           351:                case NEX_UBA2:
        !           352:                case NEX_UBA3:
        !           353:                        printf("uba%d at tr%d\n", numuba, nexnum);
        !           354:                        if (numuba >= NUBA) {
        !           355:                                printf("%d uba's", ++numuba);
        !           356:                                goto unconfig;
        !           357:                        }
        !           358: #if NUBA > 0
        !           359: #if VAX750
        !           360:                        if (numuba >= 2 && cpu == VAX_750) {
        !           361:                                printf("More than 2 UBA's");
        !           362:                                goto unsupp;
        !           363:                        }
        !           364: #endif
        !           365: #if defined(VAX780) || defined(VAX8600)
        !           366:                        if (cpu == VAX_780 || cpu == VAX_8600)
        !           367:                                setscbnex(ubaintv[numuba]);
        !           368: #endif
        !           369:                        i = nexcsr.nex_type - NEX_UBA0;
        !           370:                        probeuba((struct uba_regs *)nxv, (struct uba_regs *)nxp,
        !           371:                            pnc->psb_umaddr[i]);
        !           372: #endif /* NUBA */
        !           373:                        break;
        !           374: 
        !           375:                case NEX_DR32:
        !           376:                /* there can be more than one... are there other codes??? */
        !           377:                        printf("dr32");
        !           378:                        goto unsupp;
        !           379: 
        !           380:                case NEX_MEM4:
        !           381:                case NEX_MEM4I:
        !           382:                case NEX_MEM16:
        !           383:                case NEX_MEM16I:
        !           384:                        printf("mcr%d at tr%d\n", nmcr, nexnum);
        !           385:                        if (nmcr >= MAXNMCR) {
        !           386:                                printf("%d mcr's", ++nmcr);
        !           387:                                goto unconfig;
        !           388:                        }
        !           389:                        switch (cpu) {
        !           390: #if VAX780
        !           391:                        case VAX_780:
        !           392:                                /* only ka780 code looks at type */
        !           393:                                mcrtype[nmcr] = M780C;
        !           394:                                break;
        !           395: #endif
        !           396:                        default:
        !           397:                                break;
        !           398:                        }
        !           399:                        mcraddr[nmcr++] = (caddr_t)nxv;
        !           400:                        break;
        !           401: 
        !           402: #if VAX780
        !           403:                case NEX_MEM64I:
        !           404:                case NEX_MEM64L:
        !           405:                case NEX_MEM64LI:
        !           406:                case NEX_MEM256I:
        !           407:                case NEX_MEM256L:
        !           408:                case NEX_MEM256LI:
        !           409:                        printf("mcr%d (el) at tr%d\n", nmcr, nexnum);
        !           410:                        if (nmcr >= MAXNMCR) {
        !           411:                                printf("%d mcr's", ++nmcr);
        !           412:                                goto unconfig;
        !           413:                        }
        !           414:                        mcrtype[nmcr] = M780EL;
        !           415:                        mcraddr[nmcr++] = (caddr_t)nxv;
        !           416:                        if (nexcsr.nex_type != NEX_MEM64I && 
        !           417:                            nexcsr.nex_type != NEX_MEM256I)
        !           418:                                break;
        !           419:                        /* fall into ... */
        !           420: 
        !           421:                case NEX_MEM64U:
        !           422:                case NEX_MEM64UI:
        !           423:                case NEX_MEM256U:
        !           424:                case NEX_MEM256UI:
        !           425:                        printf("mcr%d (eu) at tr%d\n", nmcr, nexnum);
        !           426:                        if (nmcr >= MAXNMCR) {
        !           427:                                printf("%d mcr's", ++nmcr);
        !           428:                                goto unconfig;
        !           429:                        }
        !           430:                        mcrtype[nmcr] = M780EU;
        !           431:                        mcraddr[nmcr++] = (caddr_t)nxv;
        !           432:                        break;
        !           433: #endif
        !           434: 
        !           435:                case NEX_MPM0:
        !           436:                case NEX_MPM1:
        !           437:                case NEX_MPM2:
        !           438:                case NEX_MPM3:
        !           439:                        printf("mpm");
        !           440:                        goto unsupp;
        !           441: 
        !           442:                case NEX_CI:
        !           443:                        printf("ci");
        !           444:                        goto unsupp;
        !           445: 
        !           446:                default:
        !           447:                        printf("nexus type %x", nexcsr.nex_type);
        !           448: unsupp:
        !           449:                        printf(" unsupported (at tr %d)\n", nexnum);
        !           450:                        continue;
        !           451: unconfig:
        !           452:                        printf(" not configured\n");
        !           453:                        continue;
        !           454:                }
        !           455:        }
        !           456:        if (nummba > NMBA)
        !           457:                nummba = NMBA;
        !           458:        if (numuba > NUBA)
        !           459:                numuba = NUBA;
        !           460:        if (nmcr > MAXNMCR)
        !           461:                nmcr = MAXNMCR;
        !           462: }
        !           463: 
        !           464: setscbnex(fn)
        !           465:        int (*fn)();
        !           466: {
        !           467:        register struct scb *scbp = &scb[nsbi];
        !           468: 
        !           469:        scbp->scb_ipl14[nexnum] = scbp->scb_ipl15[nexnum] =
        !           470:            scbp->scb_ipl16[nexnum] = scbp->scb_ipl17[nexnum] =
        !           471:                scbentry(fn, SCB_ISTACK);
        !           472: }
        !           473: #endif
        !           474: 
        !           475: #include "bi.h"
        !           476: #if NBI > 0
        !           477: /*
        !           478:  * Probe BI node space.
        !           479:  *
        !           480:  * THIS DEPENDS ON BI SPACE == NEXUS SPACE
        !           481:  * THIS WILL NOT WORK FOR MULTIPLE BIs
        !           482:  */
        !           483: probe_bi(p)
        !           484:        register struct bibus *p;
        !           485: {
        !           486:        register struct bi_node *biv, *bip;
        !           487:        register int node;
        !           488:        short dtype;
        !           489: 
        !           490:        /* must ignore BI errors while configuring */
        !           491:        bip = p->pbi_base;
        !           492:        ioaccess((caddr_t)bip, Nexmap[0], sizeof(*bip) * NNODEBI);/* XXX */
        !           493:        printf("vaxbi0 at address 0x%x\n", bip);
        !           494:        biv = (struct bi_node *) &nexus[0];     /* XXX */
        !           495:        for (node = 0; node < NNODEBI; node++, bip++, biv++) {
        !           496:                if (badaddr((caddr_t)biv, 4))
        !           497:                        continue;
        !           498:                bi_nodes |= 1 << node;          /* XXX */
        !           499:                dtype = biv->biic.bi_dtype;
        !           500:                /* clear bus errors */
        !           501:                biv->biic.bi_ber = ~(BIBER_MBZ|BIBER_NMR|BIBER_UPEN);
        !           502:                switch (dtype) {
        !           503: 
        !           504:                case BIDT_KA820: {
        !           505:                        /* is this right?? */
        !           506:                        int cp5 = biv->biic.bi_revs & 0x8000 ? '5' : '0';
        !           507: 
        !           508:                        if (node != mastercpu) {
        !           509:                                printf("slave ka82%c cpu", cp5);
        !           510:                                goto unsupp;
        !           511:                        }
        !           512:                        printf("ka82%c cpu at node %x\n", cp5, node);
        !           513:                        biv->biic.bi_intrdes = 1 << mastercpu;
        !           514:                        biv->biic.bi_csr |= BICSR_SEIE | BICSR_HEIE;
        !           515:                        break;
        !           516:                }
        !           517: 
        !           518:                case BIDT_DWBUA:
        !           519:                        if (numuba >= NUBA || /*XXX*/numuba > 2) {
        !           520:                                printf("%d uba's", ++numuba);
        !           521:                                goto unconfig;
        !           522:                        }
        !           523: #if NUBA > 0
        !           524:                        printf("uba%d at node %x\n", numuba, node);
        !           525: 
        !           526:                        /*
        !           527:                         * Run a self test reset to drop any `old' errors,
        !           528:                         * so that they cannot cause a BI bus error.
        !           529:                         */
        !           530:                        (void) bi_selftest(&biv->biic);
        !           531: 
        !           532:                        /*
        !           533:                         * Enable interrupts.  DWBUAs must have
        !           534:                         * high priority.
        !           535:                         */
        !           536:                        biv->biic.bi_intrdes = 1 << mastercpu;
        !           537:                        biv->biic.bi_csr = (biv->biic.bi_csr&~BICSR_ARB_MASK) |
        !           538:                                BICSR_ARB_HIGH;
        !           539:                        probeuba((struct uba_regs *)biv, (struct uba_regs *)bip,
        !           540:                                (caddr_t)UMEM8200(node));
        !           541: #endif /* NUBA */
        !           542:                        break;
        !           543: 
        !           544:                case BIDT_MS820:
        !           545:                        printf("mcr%d at node %x\n", nmcr, node);
        !           546:                        if (nmcr >= MAXNMCR) {
        !           547:                                printf("%d mcr's", ++nmcr);
        !           548:                                goto unconfig;
        !           549:                        }
        !           550:                        mcraddr[nmcr++] = (caddr_t)biv;
        !           551:                        biv->biic.bi_intrdes = 1 << mastercpu;
        !           552:                        biv->biic.bi_csr |= BICSR_SEIE | BICSR_HEIE;
        !           553:                        break;
        !           554: 
        !           555:                case BIDT_KDB50:
        !           556:                        if (numkdb >= NKDB) {
        !           557:                                printf("%d kdb's", ++numkdb);
        !           558:                                goto unconfig;
        !           559:                        }
        !           560: #if NKDB > 0
        !           561:                        printf("kdb%d at node %x\n", numkdb, node);
        !           562:                        kdbconfig(numkdb, (struct biiregs *)biv,
        !           563:                                (struct biiregs *)bip,
        !           564:                                (int)&scb[0].scb_ipl15[node] - (int)&scb[0]);
        !           565:                        scb[0].scb_ipl15[node] =
        !           566:                                scbentry(kdbintv[numkdb], SCB_ISTACK);
        !           567:                        kdbfind(numkdb);
        !           568: #endif
        !           569:                        numkdb++;
        !           570:                        break;
        !           571: 
        !           572:                case BIDT_DEBNA:
        !           573:                case BIDT_DEBNK:
        !           574:                        printf("debna/debnk ethernet");
        !           575:                        goto unsupp;
        !           576: 
        !           577:                default:
        !           578:                        printf("node type 0x%x ", dtype);
        !           579: unsupp:
        !           580:                        printf(" unsupported (at node %x)\n", node);
        !           581:                        break;
        !           582: unconfig:
        !           583:                        printf(" not configured (at node %x)\n", node);
        !           584:                        continue;
        !           585:                }
        !           586: #ifdef DO_EINTRCSR
        !           587:                biv->biic.bi_eintrcsr = BIEIC_IPL17 |
        !           588:                        (int)&scb[0].scb_bierr - (int)&scb[0];
        !           589:                /* but bi reset will need to restore this */
        !           590: #endif
        !           591:        }
        !           592:        if (numuba > NUBA)
        !           593:                numuba = NUBA;
        !           594:        if (numkdb > NKDB)
        !           595:                numkdb = NKDB;
        !           596:        if (nmcr > MAXNMCR)
        !           597:                nmcr = MAXNMCR;
        !           598: }
        !           599: 
        !           600: #if NKDB > 0
        !           601: /*
        !           602:  * Find drives attached to a particular KDB50.
        !           603:  */
        !           604: kdbfind(kdbnum)
        !           605:        int kdbnum;
        !           606: {
        !           607:        extern struct uba_driver kdbdriver;
        !           608:        register struct uba_device *ui;
        !           609:        register struct uba_driver *udp = &kdbdriver;
        !           610:        int t;
        !           611: 
        !           612:        for (ui = ubdinit; ui->ui_driver; ui++) {
        !           613:                /* ui->ui_ubanum is trash */
        !           614:                if (ui->ui_driver != udp || ui->ui_alive ||
        !           615:                    ui->ui_ctlr != kdbnum && ui->ui_ctlr != '?')
        !           616:                        continue;
        !           617:                t = ui->ui_ctlr;
        !           618:                ui->ui_ctlr = kdbnum;
        !           619:                if ((*udp->ud_slave)(ui) == 0) {
        !           620:                        ui->ui_ctlr = t;
        !           621:                        continue;
        !           622:                }
        !           623:                ui->ui_alive = 1;
        !           624:                ui->ui_ubanum = -1;
        !           625: 
        !           626:                /* make these invalid so we can see if someone uses them */
        !           627:                /* might as well make each one different too */
        !           628:                ui->ui_hd = (struct uba_hd *)0xc0000010;
        !           629:                ui->ui_addr = (caddr_t)0xc0000014;
        !           630:                ui->ui_physaddr = (caddr_t)0xc0000018;
        !           631:                ui->ui_mi = (struct uba_ctlr *)0xc000001c;
        !           632: 
        !           633:                if (ui->ui_dk && dkn < DK_NDRIVE)
        !           634:                        ui->ui_dk = dkn++;
        !           635:                else
        !           636:                        ui->ui_dk = -1;
        !           637:                /* ui_type comes from driver */
        !           638:                udp->ud_dinfo[ui->ui_unit] = ui;
        !           639:                printf("%s%d at %s%d slave %d\n",
        !           640:                    udp->ud_dname, ui->ui_unit,
        !           641:                    udp->ud_mname, ui->ui_ctlr, ui->ui_slave);
        !           642:                (*udp->ud_attach)(ui);
        !           643:        }
        !           644: }
        !           645: #endif /* NKDB > 0 */
        !           646: #endif /* NBI > 0 */
        !           647: 
        !           648: #if NMBA > 0
        !           649: struct mba_device *mbaconfig();
        !           650: /*
        !           651:  * Find devices attached to a particular mba
        !           652:  * and look for each device found in the massbus
        !           653:  * initialization tables.
        !           654:  */
        !           655: mbafind(nxv, nxp)
        !           656:        struct nexus *nxv, *nxp;
        !           657: {
        !           658:        register struct mba_regs *mdp;
        !           659:        register struct mba_drv *mbd;
        !           660:        register struct mba_device *mi;
        !           661:        register struct mba_slave *ms;
        !           662:        int dn, dt, sn;
        !           663:        struct mba_device fnd;
        !           664: 
        !           665:        mdp = (struct mba_regs *)nxv;
        !           666:        mba_hd[nummba].mh_mba = mdp;
        !           667:        mba_hd[nummba].mh_physmba = (struct mba_regs *)nxp;
        !           668:        setscbnex(mbaintv[nummba]);
        !           669:        mdp->mba_cr = MBCR_INIT;
        !           670:        mdp->mba_cr = MBCR_IE;
        !           671:        fnd.mi_mba = mdp;
        !           672:        fnd.mi_mbanum = nummba;
        !           673:        for (mbd = mdp->mba_drv, dn = 0; mbd < &mdp->mba_drv[8]; mbd++, dn++) {
        !           674:                if ((mbd->mbd_ds&MBDS_DPR) == 0)
        !           675:                        continue;
        !           676:                mdp->mba_sr |= MBSR_NED;                /* si kludge */
        !           677:                dt = mbd->mbd_dt & 0xffff;
        !           678:                if (dt == 0)
        !           679:                        continue;
        !           680:                if (mdp->mba_sr&MBSR_NED)
        !           681:                        continue;                       /* si kludge */
        !           682:                if (dt == MBDT_MOH)
        !           683:                        continue;
        !           684:                fnd.mi_drive = dn;
        !           685: #define        qeq(a, b)       ( a == b || a == '?' )
        !           686:                if ((mi = mbaconfig(&fnd, dt)) && (dt & MBDT_TAP))
        !           687:                    for (sn = 0; sn < 8; sn++) {
        !           688:                        mbd->mbd_tc = sn;
        !           689:                        for (ms = mbsinit; ms->ms_driver; ms++)
        !           690:                            if (ms->ms_driver == mi->mi_driver &&
        !           691:                                ms->ms_alive == 0 && 
        !           692:                                qeq(ms->ms_ctlr, mi->mi_unit) &&
        !           693:                                qeq(ms->ms_slave, sn) &&
        !           694:                                (*ms->ms_driver->md_slave)(mi, ms, sn)) {
        !           695:                                        printf("%s%d at %s%d slave %d\n"
        !           696:                                            , ms->ms_driver->md_sname
        !           697:                                            , ms->ms_unit
        !           698:                                            , mi->mi_driver->md_dname
        !           699:                                            , mi->mi_unit
        !           700:                                            , sn
        !           701:                                        );
        !           702:                                        ms->ms_alive = 1;
        !           703:                                        ms->ms_ctlr = mi->mi_unit;
        !           704:                                        ms->ms_slave = sn;
        !           705:                                        break;
        !           706:                                }
        !           707:                    }
        !           708:        }
        !           709: }
        !           710: 
        !           711: /*
        !           712:  * Have found a massbus device;
        !           713:  * see if it is in the configuration table.
        !           714:  * If so, fill in its data.
        !           715:  */
        !           716: struct mba_device *
        !           717: mbaconfig(ni, type)
        !           718:        register struct mba_device *ni;
        !           719:        register int type;
        !           720: {
        !           721:        register struct mba_device *mi;
        !           722:        register short *tp;
        !           723:        register struct mba_hd *mh;
        !           724: 
        !           725:        for (mi = mbdinit; mi->mi_driver; mi++) {
        !           726:                if (mi->mi_alive)
        !           727:                        continue;
        !           728:                tp = mi->mi_driver->md_type;
        !           729:                for (mi->mi_type = 0; *tp; tp++, mi->mi_type++)
        !           730:                        if (*tp == (type&MBDT_TYPE))
        !           731:                                goto found;
        !           732:                continue;
        !           733: found:
        !           734: #define        match(fld)      (ni->fld == mi->fld || mi->fld == '?')
        !           735:                if (!match(mi_drive) || !match(mi_mbanum))
        !           736:                        continue;
        !           737:                printf("%s%d at mba%d drive %d",
        !           738:                    mi->mi_driver->md_dname, mi->mi_unit,
        !           739:                    ni->mi_mbanum, ni->mi_drive);
        !           740:                mi->mi_alive = 1;
        !           741:                mh = &mba_hd[ni->mi_mbanum];
        !           742:                mi->mi_hd = mh;
        !           743:                mh->mh_mbip[ni->mi_drive] = mi;
        !           744:                mh->mh_ndrive++;
        !           745:                mi->mi_mba = ni->mi_mba;
        !           746:                mi->mi_drv = &mi->mi_mba->mba_drv[ni->mi_drive];
        !           747:                mi->mi_mbanum = ni->mi_mbanum;
        !           748:                mi->mi_drive = ni->mi_drive;
        !           749:                /*
        !           750:                 * If drive has never been seen before,
        !           751:                 * give it a dkn for statistics.
        !           752:                 */
        !           753:                if (mi->mi_driver->md_info[mi->mi_unit] == 0) {
        !           754:                        mi->mi_driver->md_info[mi->mi_unit] = mi;
        !           755:                        if (mi->mi_dk && dkn < DK_NDRIVE)
        !           756:                                mi->mi_dk = dkn++;
        !           757:                        else
        !           758:                                mi->mi_dk = -1;
        !           759:                }
        !           760:                (*mi->mi_driver->md_attach)(mi);
        !           761:                printf("\n");
        !           762:                return (mi);
        !           763:        }
        !           764:        return (0);
        !           765: }
        !           766: #endif
        !           767: 
        !           768: /*
        !           769:  * Fixctlrmask fixes the masks of the driver ctlr routines
        !           770:  * which otherwise save r10 and r11 where the interrupt and br
        !           771:  * level are passed through.
        !           772:  */
        !           773: fixctlrmask()
        !           774: {
        !           775:        register struct uba_ctlr *um;
        !           776:        register struct uba_device *ui;
        !           777:        register struct uba_driver *ud;
        !           778: #define        phys(a,b) ((b)(((int)(a))&0x7fffffff))
        !           779: 
        !           780:        for (um = ubminit; ud = phys(um->um_driver, struct uba_driver *); um++)
        !           781:                *phys(ud->ud_probe, short *) &= ~0xc00;
        !           782:        for (ui = ubdinit; ud = phys(ui->ui_driver, struct uba_driver *); ui++)
        !           783:                *phys(ud->ud_probe, short *) &= ~0xc00;
        !           784: }
        !           785: 
        !           786: #ifdef QBA
        !           787: /*
        !           788:  * Configure a Q-bus.
        !           789:  */
        !           790: probeqbus(qb)
        !           791:        struct qbus *qb;
        !           792: {
        !           793:        register struct uba_hd *uhp = &uba_hd[numuba];
        !           794: 
        !           795:        ioaccess((caddr_t)qb->qb_map, Nexmap[0],
        !           796:                qb->qb_memsize * sizeof (struct pte));
        !           797:        uhp->uh_type = qb->qb_type;
        !           798:        uhp->uh_uba = (struct uba_regs *)0xc0000000;   /* no uba adaptor regs */
        !           799:        uhp->uh_mr = (struct pte *)&nexus[0];
        !           800:        /*
        !           801:         * The map registers start right at 20088000 on the
        !           802:         * ka630, so we have to subtract out the 2k offset to make the
        !           803:         * pointers work..
        !           804:         */
        !           805:        uhp->uh_physuba = (struct uba_regs *)(((u_long)qb->qb_map)-0x800);
        !           806: 
        !           807:        uhp->uh_memsize = qb->qb_memsize;
        !           808:        ioaccess(qb->qb_maddr, UMEMmap[numuba], uhp->uh_memsize * NBPG);
        !           809:        uhp->uh_mem = umem[numuba];
        !           810: 
        !           811:        /*
        !           812:         * The I/O page is mapped to the 8K of the umem address space
        !           813:         * immediately after the memory section that is mapped.
        !           814:         */
        !           815:        ioaccess(qb->qb_iopage, UMEMmap[numuba] + uhp->uh_memsize,
        !           816:            UBAIOPAGES * NBPG);
        !           817:        uhp->uh_iopage = umem[numuba] + (uhp->uh_memsize * NBPG);
        !           818: 
        !           819:        unifind(uhp, qb->qb_iopage);
        !           820: }
        !           821: #endif
        !           822: 
        !           823: #if NUBA > 0
        !           824: probeuba(vubp, pubp, pumem)
        !           825:        struct uba_regs *vubp, *pubp;
        !           826:        caddr_t pumem;
        !           827: {
        !           828:        register struct uba_hd *uhp = &uba_hd[numuba];
        !           829: 
        !           830:        /*
        !           831:         * Save virtual and physical addresses of adaptor.
        !           832:         */
        !           833:        switch (cpu) {
        !           834: #ifdef DW780
        !           835:        case VAX_8600:
        !           836:        case VAX_780:
        !           837:                uhp->uh_type = DW780;
        !           838:                break;
        !           839: #endif
        !           840: #ifdef DW750
        !           841:        case VAX_750:
        !           842:                uhp->uh_type = DW750;
        !           843:                break;
        !           844: #endif
        !           845: #ifdef DW730
        !           846:        case VAX_730:
        !           847:                uhp->uh_type = DW730;
        !           848:                break;
        !           849: #endif
        !           850: #ifdef DWBUA
        !           851:        case VAX_8200:
        !           852:                uhp->uh_type = DWBUA;
        !           853:                break;
        !           854: #endif
        !           855:        default:
        !           856:                panic("unknown UBA type");
        !           857:                /*NOTREACHED*/
        !           858:        }
        !           859:        uhp->uh_uba = vubp;
        !           860:        uhp->uh_physuba = pubp;
        !           861:        uhp->uh_mr = vubp->uba_map;
        !           862:        uhp->uh_memsize = UBAPAGES;
        !           863: 
        !           864:        ioaccess(pumem, UMEMmap[numuba], (UBAPAGES + UBAIOPAGES) * NBPG);
        !           865:        uhp->uh_mem = umem[numuba];
        !           866:        uhp->uh_iopage = umem[numuba] + (uhp->uh_memsize * NBPG);
        !           867: 
        !           868:        unifind(uhp, pumem + (uhp->uh_memsize * NBPG));
        !           869: }
        !           870: 
        !           871: /*
        !           872:  * Find devices on a UNIBUS.
        !           873:  * Uses per-driver routine to set <br,cvec> into <r11,r10>,
        !           874:  * and then fills in the tables, with help from a per-driver
        !           875:  * slave initialization routine.
        !           876:  */
        !           877: unifind(uhp0, pumem)
        !           878:        struct uba_hd *uhp0;
        !           879:        caddr_t pumem;
        !           880: {
        !           881: #ifndef lint
        !           882:        register int rbr, rcvec;                        /* MUST BE r11, r10 */
        !           883: #else
        !           884:        /*
        !           885:         * Lint doesn't realize that these
        !           886:         * can be initialized asynchronously
        !           887:         * when devices interrupt.
        !           888:         */
        !           889:        register int rbr = 0, rcvec = 0;
        !           890: #endif
        !           891:        register struct uba_device *ui;
        !           892:        register struct uba_ctlr *um;
        !           893:        register struct uba_hd *uhp = uhp0;
        !           894:        u_short *reg, *ap, addr;
        !           895:        struct uba_driver *udp;
        !           896:        int i, (**ivec)();
        !           897:        caddr_t ualloc;
        !           898:        extern quad catcher[128];
        !           899:        extern int br, cvec;
        !           900: #if DW780 || DWBUA
        !           901:        struct uba_regs *vubp = uhp->uh_uba;
        !           902: #endif
        !           903: 
        !           904:        /*
        !           905:         * Initialize the UNIBUS, by freeing the map
        !           906:         * registers and the buffered data path registers
        !           907:         */
        !           908:        uhp->uh_map = (struct map *)
        !           909:                malloc((u_long)(UAMSIZ * sizeof (struct map)), M_DEVBUF,
        !           910:                    M_NOWAIT);
        !           911:        if (uhp->uh_map == 0)
        !           912:                panic("no mem for unibus map");
        !           913:        bzero((caddr_t)uhp->uh_map, (unsigned)(UAMSIZ * sizeof (struct map)));
        !           914:        ubainitmaps(uhp);
        !           915: 
        !           916:        /*
        !           917:         * Initialize space for the UNIBUS interrupt vectors.
        !           918:         * On the 8600, can't use first slot in UNIvec
        !           919:         * (the vectors for the second SBI overlap it);
        !           920:         * move each set of vectors forward.
        !           921:         */
        !           922: #if    VAX8600
        !           923:        if (cpu == VAX_8600)
        !           924:                uhp->uh_vec = UNIvec[numuba + 1];
        !           925:        else
        !           926: #endif
        !           927:                uhp->uh_vec = UNIvec[numuba];
        !           928:        for (i = 0; i < 128; i++)
        !           929:                uhp->uh_vec[i] = scbentry(&catcher[i], SCB_ISTACK);
        !           930:        /*
        !           931:         * Set last free interrupt vector for devices with
        !           932:         * programmable interrupt vectors.  Use is to decrement
        !           933:         * this number and use result as interrupt vector.
        !           934:         */
        !           935:        uhp->uh_lastiv = 0x200;
        !           936: 
        !           937: #ifdef DWBUA
        !           938:        if (uhp->uh_type == DWBUA)
        !           939:                BUA(vubp)->bua_offset = (int)uhp->uh_vec - (int)&scb[0];
        !           940: #endif
        !           941: 
        !           942: #ifdef DW780
        !           943:        if (uhp->uh_type == DW780) {
        !           944:                vubp->uba_sr = vubp->uba_sr;
        !           945:                vubp->uba_cr = UBACR_IFS|UBACR_BRIE;
        !           946:        }
        !           947: #endif
        !           948:        /*
        !           949:         * First configure devices that have unibus memory,
        !           950:         * allowing them to allocate the correct map registers.
        !           951:         */
        !           952:        ubameminit(numuba);
        !           953:        /*
        !           954:         * Grab some memory to record the umem address space we allocate,
        !           955:         * so we can be sure not to place two devices at the same address.
        !           956:         *
        !           957:         * We could use just 1/8 of this (we only want a 1 bit flag) but
        !           958:         * we are going to give it back anyway, and that would make the
        !           959:         * code here bigger (which we can't give back), so ...
        !           960:         *
        !           961:         * One day, someone will make a unibus with something other than
        !           962:         * an 8K i/o address space, & screw this totally.
        !           963:         */
        !           964:        ualloc = (caddr_t)malloc((u_long)(8 * 1024), M_TEMP, M_NOWAIT);
        !           965:        if (ualloc == (caddr_t)0)
        !           966:                panic("no mem for unifind");
        !           967:        bzero(ualloc, 8*1024);
        !           968: 
        !           969:        /*
        !           970:         * Map the first page of UNIBUS i/o
        !           971:         * space to the first page of memory
        !           972:         * for devices which will need to dma
        !           973:         * output to produce an interrupt.
        !           974:         */
        !           975:        *(int *)(&uhp->uh_mr[0]) = UBAMR_MRV;
        !           976: 
        !           977: #define        ubaddr(uhp, off)    (u_short *)((int)(uhp)->uh_iopage + ubdevreg(off))
        !           978:        /*
        !           979:         * Check each unibus mass storage controller.
        !           980:         * For each one which is potentially on this uba,
        !           981:         * see if it is really there, and if it is record it and
        !           982:         * then go looking for slaves.
        !           983:         */
        !           984:        for (um = ubminit; udp = um->um_driver; um++) {
        !           985:                if (um->um_ubanum != numuba && um->um_ubanum != '?' ||
        !           986:                    um->um_alive)
        !           987:                        continue;
        !           988:                addr = (u_short)um->um_addr;
        !           989:                /*
        !           990:                 * use the particular address specified first,
        !           991:                 * or if it is given as "0", of there is no device
        !           992:                 * at that address, try all the standard addresses
        !           993:                 * in the driver til we find it
        !           994:                 */
        !           995:            for (ap = udp->ud_addr; addr || (addr = *ap++); addr = 0) {
        !           996: 
        !           997:                if (ualloc[ubdevreg(addr)])
        !           998:                        continue;
        !           999:                reg = ubaddr(uhp, addr);
        !          1000:                if (badaddr((caddr_t)reg, 2))
        !          1001:                        continue;
        !          1002: #ifdef DW780
        !          1003:                if (uhp->uh_type == DW780 && vubp->uba_sr) {
        !          1004:                        vubp->uba_sr = vubp->uba_sr;
        !          1005:                        continue;
        !          1006:                }
        !          1007: #endif
        !          1008:                cvec = 0x200;
        !          1009:                rcvec = 0x200;
        !          1010:                i = (*udp->ud_probe)(reg, um->um_ctlr, um);
        !          1011: #ifdef DW780
        !          1012:                if (uhp->uh_type == DW780 && vubp->uba_sr) {
        !          1013:                        vubp->uba_sr = vubp->uba_sr;
        !          1014:                        continue;
        !          1015:                }
        !          1016: #endif
        !          1017:                if (i == 0)
        !          1018:                        continue;
        !          1019:                printf("%s%d at uba%d csr %o ",
        !          1020:                    udp->ud_mname, um->um_ctlr, numuba, addr);
        !          1021:                if (rcvec == 0) {
        !          1022:                        printf("zero vector\n");
        !          1023:                        continue;
        !          1024:                }
        !          1025:                if (rcvec == 0x200) {
        !          1026:                        printf("didn't interrupt\n");
        !          1027:                        continue;
        !          1028:                }
        !          1029:                printf("vec %o, ipl %x\n", rcvec, rbr);
        !          1030:                csralloc(ualloc, addr, i);
        !          1031:                um->um_alive = 1;
        !          1032:                um->um_ubanum = numuba;
        !          1033:                um->um_hd = uhp;
        !          1034:                um->um_addr = (caddr_t)reg;
        !          1035:                udp->ud_minfo[um->um_ctlr] = um;
        !          1036:                for (rcvec /= 4, ivec = um->um_intr; *ivec; rcvec++, ivec++)
        !          1037:                        uhp->uh_vec[rcvec] = scbentry(*ivec, SCB_ISTACK);
        !          1038:                for (ui = ubdinit; ui->ui_driver; ui++) {
        !          1039:                        int t;
        !          1040: 
        !          1041:                        if (ui->ui_driver != udp || ui->ui_alive ||
        !          1042:                            ui->ui_ctlr != um->um_ctlr && ui->ui_ctlr != '?' ||
        !          1043:                            ui->ui_ubanum != numuba && ui->ui_ubanum != '?')
        !          1044:                                continue;
        !          1045:                        t = ui->ui_ctlr;
        !          1046:                        ui->ui_ctlr = um->um_ctlr;
        !          1047:                        if ((*udp->ud_slave)(ui, reg) == 0)
        !          1048:                                ui->ui_ctlr = t;
        !          1049:                        else {
        !          1050:                                ui->ui_alive = 1;
        !          1051:                                ui->ui_ubanum = numuba;
        !          1052:                                ui->ui_hd = uhp;
        !          1053:                                ui->ui_addr = (caddr_t)reg;
        !          1054:                                ui->ui_physaddr = pumem + ubdevreg(addr);
        !          1055:                                if (ui->ui_dk && dkn < DK_NDRIVE)
        !          1056:                                        ui->ui_dk = dkn++;
        !          1057:                                else
        !          1058:                                        ui->ui_dk = -1;
        !          1059:                                ui->ui_mi = um;
        !          1060:                                /* ui_type comes from driver */
        !          1061:                                udp->ud_dinfo[ui->ui_unit] = ui;
        !          1062:                                printf("%s%d at %s%d slave %d",
        !          1063:                                    udp->ud_dname, ui->ui_unit,
        !          1064:                                    udp->ud_mname, um->um_ctlr, ui->ui_slave);
        !          1065:                                (*udp->ud_attach)(ui);
        !          1066:                                printf("\n");
        !          1067:                        }
        !          1068:                }
        !          1069:                break;
        !          1070:            }
        !          1071:        }
        !          1072:        /*
        !          1073:         * Now look for non-mass storage peripherals.
        !          1074:         */
        !          1075:        for (ui = ubdinit; udp = ui->ui_driver; ui++) {
        !          1076:                if (ui->ui_ubanum != numuba && ui->ui_ubanum != '?' ||
        !          1077:                    ui->ui_alive || ui->ui_slave != -1)
        !          1078:                        continue;
        !          1079:                addr = (u_short)ui->ui_addr;
        !          1080: 
        !          1081:            for (ap = udp->ud_addr; addr || (addr = *ap++); addr = 0) {
        !          1082:                
        !          1083:                if (ualloc[ubdevreg(addr)])
        !          1084:                        continue;
        !          1085:                reg = ubaddr(uhp, addr);
        !          1086:                if (badaddr((caddr_t)reg, 2))
        !          1087:                        continue;
        !          1088: #ifdef DW780
        !          1089:                if (uhp->uh_type == DW780 && vubp->uba_sr) {
        !          1090:                        vubp->uba_sr = vubp->uba_sr;
        !          1091:                        continue;
        !          1092:                }
        !          1093: #endif
        !          1094:                rcvec = 0x200;
        !          1095:                cvec = 0x200;
        !          1096:                i = (*udp->ud_probe)(reg, ui);
        !          1097: #ifdef DW780
        !          1098:                if (uhp->uh_type == DW780 && vubp->uba_sr) {
        !          1099:                        vubp->uba_sr = vubp->uba_sr;
        !          1100:                        continue;
        !          1101:                }
        !          1102: #endif
        !          1103:                if (i == 0)
        !          1104:                        continue;
        !          1105:                printf("%s%d at uba%d csr %o ",
        !          1106:                    ui->ui_driver->ud_dname, ui->ui_unit, numuba, addr);
        !          1107:                if (rcvec == 0) {
        !          1108:                        printf("zero vector\n");
        !          1109:                        continue;
        !          1110:                }
        !          1111:                if (rcvec == 0x200) {
        !          1112:                        printf("didn't interrupt\n");
        !          1113:                        continue;
        !          1114:                }
        !          1115:                printf("vec %o, ipl %x\n", rcvec, rbr);
        !          1116:                csralloc(ualloc, addr, i);
        !          1117:                ui->ui_hd = uhp;
        !          1118:                for (rcvec /= 4, ivec = ui->ui_intr; *ivec; rcvec++, ivec++)
        !          1119:                        uhp->uh_vec[rcvec] = scbentry(*ivec, SCB_ISTACK);
        !          1120:                ui->ui_alive = 1;
        !          1121:                ui->ui_ubanum = numuba;
        !          1122:                ui->ui_addr = (caddr_t)reg;
        !          1123:                ui->ui_physaddr = pumem + ubdevreg(addr);
        !          1124:                ui->ui_dk = -1;
        !          1125:                /* ui_type comes from driver */
        !          1126:                udp->ud_dinfo[ui->ui_unit] = ui;
        !          1127:                (*udp->ud_attach)(ui);
        !          1128:                break;
        !          1129:            }
        !          1130:        }
        !          1131: 
        !          1132: #ifdef DW780
        !          1133:        if (uhp->uh_type == DW780)
        !          1134:                uhp->uh_uba->uba_cr = UBACR_IFS | UBACR_BRIE |
        !          1135:                    UBACR_USEFIE | UBACR_SUEFIE |
        !          1136:                    (uhp->uh_uba->uba_cr & 0x7c000000);
        !          1137: #endif
        !          1138:        numuba++;
        !          1139: 
        !          1140: #ifdef AUTO_DEBUG
        !          1141:        printf("Unibus allocation map");
        !          1142:        for (i = 0; i < 8*1024; ) {
        !          1143:                register n, m;
        !          1144: 
        !          1145:                if ((i % 128) == 0) {
        !          1146:                        printf("\n%6o:", i);
        !          1147:                        for (n = 0; n < 128; n++)
        !          1148:                                if (ualloc[i+n])
        !          1149:                                        break;
        !          1150:                        if (n == 128) {
        !          1151:                                i += 128;
        !          1152:                                continue;
        !          1153:                        }
        !          1154:                }
        !          1155: 
        !          1156:                for (n = m = 0; n < 16; n++) {
        !          1157:                        m <<= 1;
        !          1158:                        m |= ualloc[i++];
        !          1159:                }
        !          1160: 
        !          1161:                printf(" %4x", m);
        !          1162:        }
        !          1163:        printf("\n");
        !          1164: #endif
        !          1165: 
        !          1166:        free(ualloc, M_TEMP);
        !          1167: }
        !          1168: #endif /* NUBA */
        !          1169: 
        !          1170: /*
        !          1171:  * Mark addresses starting at "addr" and continuing
        !          1172:  * "size" bytes as allocated in the map "ualloc".
        !          1173:  * Warn if the new allocation overlaps a previous allocation.
        !          1174:  */
        !          1175: static
        !          1176: csralloc(ualloc, addr, size)
        !          1177:        caddr_t ualloc;
        !          1178:        u_short addr;
        !          1179:        register int size;
        !          1180: {
        !          1181:        register caddr_t p;
        !          1182:        int warned = 0;
        !          1183: 
        !          1184:        p = &ualloc[ubdevreg(addr+size)];
        !          1185:        while (--size >= 0) {
        !          1186:                if (*--p && !warned) {
        !          1187:                        printf(
        !          1188:        "WARNING: device registers overlap those for a previous device!\n");
        !          1189:                        warned = 1;
        !          1190:                }
        !          1191:                *p = 1;
        !          1192:        }
        !          1193: }
        !          1194: 
        !          1195: /*
        !          1196:  * Make an IO register area accessible at physical address physa
        !          1197:  * by mapping kernel ptes starting at pte.
        !          1198:  */
        !          1199: ioaccess(physa, pte, size)
        !          1200:        caddr_t physa;
        !          1201:        register struct pte *pte;
        !          1202:        int size;
        !          1203: {
        !          1204:        register int i = btoc(size);
        !          1205:        register unsigned v = btop(physa);
        !          1206:        
        !          1207:        do
        !          1208:                *(int *)pte++ = PG_V|PG_KW|v++;
        !          1209:        while (--i > 0);
        !          1210:        mtpr(TBIA, 0);
        !          1211: }
        !          1212: 
        !          1213: /*
        !          1214:  * Configure swap space and related parameters.
        !          1215:  */
        !          1216: swapconf()
        !          1217: {
        !          1218:        register struct swdevt *swp;
        !          1219:        register int nblks;
        !          1220: 
        !          1221:        for (swp = swdevt; swp->sw_dev; swp++)
        !          1222:                if (bdevsw[major(swp->sw_dev)].d_psize) {
        !          1223:                        nblks =
        !          1224:                          (*bdevsw[major(swp->sw_dev)].d_psize)(swp->sw_dev);
        !          1225:                        if (nblks != -1 &&
        !          1226:                            (swp->sw_nblks == 0 || swp->sw_nblks > nblks))
        !          1227:                                swp->sw_nblks = nblks;
        !          1228:                }
        !          1229:        dumpconf();
        !          1230: }
        !          1231: 
        !          1232: #define        DOSWAP                  /* Change swdevt, argdev, and dumpdev too */
        !          1233: u_long bootdev;                /* should be dev_t, but not until 32 bits */
        !          1234: 
        !          1235: static char devname[][2] = {
        !          1236:        'h','p',        /* 0 = hp */
        !          1237:        0,0,            /* 1 = ht */
        !          1238:        'u','p',        /* 2 = up */
        !          1239:        'r','k',        /* 3 = hk */
        !          1240:        0,0,            /* 4 = sw */
        !          1241:        0,0,            /* 5 = tm */
        !          1242:        0,0,            /* 6 = ts */
        !          1243:        0,0,            /* 7 = mt */
        !          1244:        0,0,            /* 8 = tu */
        !          1245:        'r','a',        /* 9 = ra */
        !          1246:        0,0,            /* 10 = ut */
        !          1247:        'r','b',        /* 11 = rb */
        !          1248:        0,0,            /* 12 = uu */
        !          1249:        0,0,            /* 13 = rx */
        !          1250:        'r','l',        /* 14 = rl */
        !          1251:        0,0,            /* 15 = tmscp */
        !          1252:        'k','r',        /* 16 = ra on kdb50 */
        !          1253: };
        !          1254: 
        !          1255: #define        PARTITIONMASK   0x7
        !          1256: #define        PARTITIONSHIFT  3
        !          1257: 
        !          1258: /*
        !          1259:  * Attempt to find the device from which we were booted.
        !          1260:  * If we can do so, and not instructed not to do so,
        !          1261:  * change rootdev to correspond to the load device.
        !          1262:  */
        !          1263: setroot()
        !          1264: {
        !          1265:        int  majdev, mindev, unit, part, controller, adaptor;
        !          1266:        dev_t temp, orootdev;
        !          1267:        struct swdevt *swp;
        !          1268: 
        !          1269:        if (boothowto & RB_DFLTROOT ||
        !          1270:            (bootdev & B_MAGICMASK) != (u_long)B_DEVMAGIC)
        !          1271:                return;
        !          1272:        majdev = B_TYPE(bootdev);
        !          1273:        if (majdev >= sizeof(devname) / sizeof(devname[0]))
        !          1274:                return;
        !          1275:        adaptor = B_ADAPTOR(bootdev);
        !          1276:        controller = B_CONTROLLER(bootdev);
        !          1277:        part = B_PARTITION(bootdev);
        !          1278:        unit = B_UNIT(bootdev);
        !          1279:        if (majdev == 0) {      /* MBA device */
        !          1280: #if NMBA > 0
        !          1281:                register struct mba_device *mbap;
        !          1282:                int mask;
        !          1283: 
        !          1284: /*
        !          1285:  * The MBA number used at boot time is not necessarily the same as the
        !          1286:  * MBA number used by the kernel.  In order to change the rootdev we need to
        !          1287:  * convert the boot MBA number to the kernel MBA number.  The address space
        !          1288:  * for an MBA used by the boot code is 0x20010000 + 0x2000 * MBA_number
        !          1289:  * on the 78? and 86?0, 0xf28000 + 0x2000 * MBA_number on the 750.
        !          1290:  * Therefore we can search the mba_hd table for the MBA that has the physical
        !          1291:  * address corresponding to the boot MBA number.
        !          1292:  */
        !          1293: #define        PHYSADRSHFT     13
        !          1294: #define        PHYSMBAMASK780  0x7
        !          1295: #define        PHYSMBAMASK750  0x3
        !          1296: 
        !          1297:                switch (cpu) {
        !          1298: 
        !          1299:                case VAX_780:
        !          1300:                case VAX_8600:
        !          1301:                default:
        !          1302:                        mask = PHYSMBAMASK780;
        !          1303:                        break;
        !          1304: 
        !          1305:                case VAX_750:
        !          1306:                        mask = PHYSMBAMASK750;
        !          1307:                        break;
        !          1308:                }
        !          1309:                for (mbap = mbdinit; mbap->mi_driver; mbap++)
        !          1310:                        if (mbap->mi_alive && mbap->mi_drive == unit &&
        !          1311:                            (((long)mbap->mi_hd->mh_physmba >> PHYSADRSHFT)
        !          1312:                              & mask) == adaptor)
        !          1313:                                break;
        !          1314:                if (mbap->mi_driver == 0)
        !          1315:                        return;
        !          1316:                mindev = mbap->mi_unit;
        !          1317: #else
        !          1318:                return;
        !          1319: #endif
        !          1320:        } else {
        !          1321:                register struct uba_device *ubap;
        !          1322: 
        !          1323:                for (ubap = ubdinit; ubap->ui_driver; ubap++)
        !          1324:                        if (ubap->ui_alive && ubap->ui_slave == unit &&
        !          1325:                           ubap->ui_ctlr == controller &&
        !          1326:                           ubap->ui_ubanum == adaptor &&
        !          1327:                           ubap->ui_driver->ud_dname[0] == devname[majdev][0] &&
        !          1328:                           ubap->ui_driver->ud_dname[1] == devname[majdev][1])
        !          1329:                                break;
        !          1330: 
        !          1331:                if (ubap->ui_driver == 0)
        !          1332:                        return;
        !          1333:                mindev = ubap->ui_unit;
        !          1334:        }
        !          1335:        mindev = (mindev << PARTITIONSHIFT) + part;
        !          1336:        orootdev = rootdev;
        !          1337:        rootdev = makedev(majdev, mindev);
        !          1338:        /*
        !          1339:         * If the original rootdev is the same as the one
        !          1340:         * just calculated, don't need to adjust the swap configuration.
        !          1341:         */
        !          1342:        if (rootdev == orootdev)
        !          1343:                return;
        !          1344: 
        !          1345:        printf("Changing root device to %c%c%d%c\n",
        !          1346:                devname[majdev][0], devname[majdev][1],
        !          1347:                mindev >> PARTITIONSHIFT, part + 'a');
        !          1348: 
        !          1349: #ifdef DOSWAP
        !          1350:        mindev &= ~PARTITIONMASK;
        !          1351:        for (swp = swdevt; swp->sw_dev; swp++) {
        !          1352:                if (majdev == major(swp->sw_dev) &&
        !          1353:                    mindev == (minor(swp->sw_dev) & ~PARTITIONMASK)) {
        !          1354:                        temp = swdevt[0].sw_dev;
        !          1355:                        swdevt[0].sw_dev = swp->sw_dev;
        !          1356:                        swp->sw_dev = temp;
        !          1357:                        break;
        !          1358:                }
        !          1359:        }
        !          1360:        if (swp->sw_dev == 0)
        !          1361:                return;
        !          1362: 
        !          1363:        /*
        !          1364:         * If argdev and dumpdev were the same as the old primary swap
        !          1365:         * device, move them to the new primary swap device.
        !          1366:         */
        !          1367:        if (temp == dumpdev)
        !          1368:                dumpdev = swdevt[0].sw_dev;
        !          1369:        if (temp == argdev)
        !          1370:                argdev = swdevt[0].sw_dev;
        !          1371: #endif
        !          1372: }

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