![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to autoconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev|
Return to autoconf.c CVS log | Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev |
1.1 ! root 1: /* autoconf.c 4.32 81/11/11 */ ! 2: ! 3: /* ! 4: * Setup the system to run on the current machine. ! 5: * ! 6: * Configure() is called at boot time and initializes the uba and mba ! 7: * device tables and the memory controller monitoring. Available ! 8: * devices are determined (from possibilities mentioned in ioconf.c), ! 9: * and the drivers are initialized. ! 10: * ! 11: * N.B.: A lot of the conditionals based on processor type say ! 12: * #if VAX780 ! 13: * and ! 14: * #if VAX750 ! 15: * which may be incorrect after more processors are introduced if they ! 16: * are like either of these machines. ! 17: * ! 18: * TODO: ! 19: * use pcpu info about whether a ubasr exists ! 20: */ ! 21: ! 22: #include "mba.h" ! 23: ! 24: #include "../h/param.h" ! 25: #include "../h/systm.h" ! 26: #include "../h/map.h" ! 27: #include "../h/nexus.h" ! 28: #include "../h/pte.h" ! 29: #include "../h/buf.h" ! 30: #include "../h/mbareg.h" ! 31: #include "../h/mbavar.h" ! 32: #include "../h/dk.h" ! 33: #include "../h/vm.h" ! 34: #include "../h/ubareg.h" ! 35: #include "../h/ubavar.h" ! 36: #include "../h/mtpr.h" ! 37: #include "../h/cpu.h" ! 38: #include "../h/scb.h" ! 39: #include "../h/mem.h" ! 40: ! 41: /* ! 42: * The following several variables are related to ! 43: * the configuration process, and are used in initializing ! 44: * the machine. ! 45: */ ! 46: int cold; /* if 1, still working on cold-start */ ! 47: int nexnum; /* current nexus number */ ! 48: int dkn; /* number of iostat dk numbers assigned so far */ ! 49: ! 50: /* ! 51: * Addresses of the (locore) routines which bootstrap us from ! 52: * hardware traps to C code. Filled into the system control block ! 53: * as necessary. ! 54: */ ! 55: #if NMBA > 0 ! 56: int (*mbaintv[4])() = { Xmba0int, Xmba1int, Xmba2int, Xmba3int }; ! 57: #endif ! 58: #if VAX780 ! 59: int (*ubaintv[4])() = { Xua0int, Xua1int, Xua2int, Xua3int }; ! 60: #endif ! 61: ! 62: /* ! 63: * This allocates the space for the per-uba information, ! 64: * such as buffered data path usage. ! 65: */ ! 66: struct uba_hd uba_hd[MAXNUBA]; ! 67: ! 68: /* ! 69: * Determine mass storage and memory configuration for a machine. ! 70: * Get cpu type, and then switch out to machine specific procedures ! 71: * which will probe adaptors to see what is out there. ! 72: */ ! 73: configure() ! 74: { ! 75: union cpusid cpusid; ! 76: register struct percpu *ocp; ! 77: register int *ip; ! 78: extern char Sysbase[]; ! 79: ! 80: cpusid.cpusid = mfpr(SID); ! 81: for (ocp = percpu; ocp->pc_cputype; ocp++) ! 82: if (ocp->pc_cputype == cpusid.cpuany.cp_type) { ! 83: probenexus(ocp); ! 84: /* ! 85: * Write protect the scb. It is strange ! 86: * that this code is here, but this is as soon ! 87: * as we are done mucking with it, and the ! 88: * write-enable was done in assembly language ! 89: * to which we will never return. ! 90: */ ! 91: ip = (int *)Sysmap; *ip &= ~PG_PROT; *ip |= PG_KR; ! 92: mtpr(TBIS, Sysbase); ! 93: #if GENERIC ! 94: setconf(); ! 95: #endif ! 96: cold = 0; ! 97: memenable(); ! 98: return; ! 99: } ! 100: printf("cpu type %d not configured\n", cpusid.cpuany.cp_type); ! 101: asm("halt"); ! 102: } ! 103: ! 104: /* ! 105: * Probe nexus space, finding the interconnects ! 106: * and setting up and probing mba's and uba's for devices. ! 107: */ ! 108: /*ARGSUSED*/ ! 109: probenexus(pcpu) ! 110: register struct percpu *pcpu; ! 111: { ! 112: register struct nexus *nxv; ! 113: struct nexus *nxp = pcpu->pc_nexbase; ! 114: union nexcsr nexcsr; ! 115: int i; ! 116: ! 117: nexnum = 0, nxv = nexus; ! 118: for (; nexnum < pcpu->pc_nnexus; nexnum++, nxp++, nxv++) { ! 119: nxaccess(nxp, Nexmap[nexnum]); ! 120: if (badaddr((caddr_t)nxv, 4)) ! 121: continue; ! 122: if (pcpu->pc_nextype && pcpu->pc_nextype[nexnum] != NEX_ANY) ! 123: nexcsr.nex_csr = pcpu->pc_nextype[nexnum]; ! 124: else ! 125: nexcsr = nxv->nexcsr; ! 126: if (nexcsr.nex_csr&NEX_APD) ! 127: continue; ! 128: switch (nexcsr.nex_type) { ! 129: ! 130: case NEX_MBA: ! 131: printf("mba%d at tr%d\n", nummba, nexnum); ! 132: if (nummba >= NMBA) { ! 133: printf("%d mba's", nummba); ! 134: goto unconfig; ! 135: } ! 136: #if NMBA > 0 ! 137: mbafind(nxv, nxp); ! 138: nummba++; ! 139: #endif ! 140: break; ! 141: ! 142: case NEX_UBA0: ! 143: case NEX_UBA1: ! 144: case NEX_UBA2: ! 145: case NEX_UBA3: ! 146: printf("uba%d at tr%d\n", numuba, nexnum); ! 147: if (numuba >= 4) { ! 148: printf("5 uba's"); ! 149: goto unsupp; ! 150: } ! 151: #if VAX780 ! 152: if (cpu == VAX_780) ! 153: setscbnex(ubaintv[numuba]); ! 154: #endif ! 155: i = nexcsr.nex_type - NEX_UBA0; ! 156: unifind((struct uba_regs *)nxv, (struct uba_regs *)nxp, ! 157: umem[i], pcpu->pc_umaddr[i], UMEMmap[i]); ! 158: #if VAX780 ! 159: if (cpu == VAX_780) ! 160: ((struct uba_regs *)nxv)->uba_cr = ! 161: UBACR_IFS|UBACR_BRIE| ! 162: UBACR_USEFIE|UBACR_SUEFIE; ! 163: #endif ! 164: numuba++; ! 165: break; ! 166: ! 167: case NEX_DR32: ! 168: /* there can be more than one... are there other codes??? */ ! 169: printf("dr32"); ! 170: goto unsupp; ! 171: ! 172: case NEX_MEM4: ! 173: case NEX_MEM4I: ! 174: case NEX_MEM16: ! 175: case NEX_MEM16I: ! 176: printf("mcr%d at tr%d\n", nmcr, nexnum); ! 177: if (nmcr >= 4) { ! 178: printf("5 mcr's"); ! 179: goto unsupp; ! 180: } ! 181: mcraddr[nmcr++] = (struct mcr *)nxv; ! 182: break; ! 183: ! 184: case NEX_MPM0: ! 185: case NEX_MPM1: ! 186: case NEX_MPM2: ! 187: case NEX_MPM3: ! 188: printf("mpm"); ! 189: goto unsupp; ! 190: ! 191: default: ! 192: printf("nexus type %x", nexcsr.nex_type); ! 193: unsupp: ! 194: printf(" unsupported (at tr %d)\n", nexnum); ! 195: continue; ! 196: unconfig: ! 197: printf(" not configured\n"); ! 198: continue; ! 199: } ! 200: } ! 201: #if VAX780 ! 202: if (cpu == VAX_780) ! 203: { int ubawatch(); timeout(ubawatch, (caddr_t)0, hz); } ! 204: #endif ! 205: } ! 206: ! 207: #if NMBA > 0 ! 208: struct mba_device *mbaconfig(); ! 209: /* ! 210: * Find devices attached to a particular mba ! 211: * and look for each device found in the massbus ! 212: * initialization tables. ! 213: */ ! 214: mbafind(nxv, nxp) ! 215: struct nexus *nxv, *nxp; ! 216: { ! 217: register struct mba_regs *mdp; ! 218: register struct mba_drv *mbd; ! 219: register struct mba_device *mi; ! 220: register struct mba_slave *ms; ! 221: int dn, dt; ! 222: struct mba_device fnd; ! 223: ! 224: mdp = (struct mba_regs *)nxv; ! 225: mba_hd[nummba].mh_mba = mdp; ! 226: mba_hd[nummba].mh_physmba = (struct mba_regs *)nxp; ! 227: setscbnex(mbaintv[nummba]); ! 228: fnd.mi_mba = mdp; ! 229: fnd.mi_mbanum = nummba; ! 230: for (mbd = mdp->mba_drv, dn = 0; mbd < &mdp->mba_drv[8]; mbd++, dn++) { ! 231: dt = mbd->mbd_dt & 0xffff; ! 232: if (dt == 0) ! 233: continue; ! 234: if (dt == MBDT_MOH) ! 235: continue; ! 236: fnd.mi_drive = dn; ! 237: if ((mi = mbaconfig(&fnd, dt)) && (dt & MBDT_TAP)) { ! 238: for (ms = mbsinit; ms->ms_driver; ms++) ! 239: if (ms->ms_driver == mi->mi_driver && ms->ms_alive == 0 && ! 240: (ms->ms_ctlr == mi->mi_unit || ms->ms_ctlr=='?')) { ! 241: if ((*ms->ms_driver->md_slave)(mi, ms)) { ! 242: printf("%s%d at %s%d slave %d\n", ! 243: ms->ms_driver->md_sname, ! 244: ms->ms_unit, ! 245: mi->mi_driver->md_dname, ! 246: mi->mi_unit, ! 247: ms->ms_slave); ! 248: ms->ms_alive = 1; ! 249: ms->ms_ctlr = mi->mi_unit; ! 250: } ! 251: } ! 252: } ! 253: } ! 254: mdp->mba_cr = MBCR_INIT; ! 255: mdp->mba_cr = MBCR_IE; ! 256: } ! 257: ! 258: /* ! 259: * Have found a massbus device; ! 260: * see if it is in the configuration table. ! 261: * If so, fill in its data. ! 262: */ ! 263: struct mba_device * ! 264: mbaconfig(ni, type) ! 265: register struct mba_device *ni; ! 266: register int type; ! 267: { ! 268: register struct mba_device *mi; ! 269: register short *tp; ! 270: register struct mba_hd *mh; ! 271: ! 272: for (mi = mbdinit; mi->mi_driver; mi++) { ! 273: if (mi->mi_alive) ! 274: continue; ! 275: tp = mi->mi_driver->md_type; ! 276: for (mi->mi_type = 0; *tp; tp++, mi->mi_type++) ! 277: if (*tp == (type&MBDT_TYPE)) ! 278: goto found; ! 279: continue; ! 280: found: ! 281: #define match(fld) (ni->fld == mi->fld || mi->fld == '?') ! 282: if (!match(mi_drive) || !match(mi_mbanum)) ! 283: continue; ! 284: printf("%s%d at mba%d drive %d", ! 285: mi->mi_driver->md_dname, mi->mi_unit, ! 286: ni->mi_mbanum, ni->mi_drive); ! 287: printf("\n"); ! 288: mi->mi_alive = 1; ! 289: mh = &mba_hd[ni->mi_mbanum]; ! 290: mi->mi_hd = mh; ! 291: mh->mh_mbip[ni->mi_drive] = mi; ! 292: mh->mh_ndrive++; ! 293: mi->mi_mba = ni->mi_mba; ! 294: mi->mi_drv = &mi->mi_mba->mba_drv[ni->mi_drive]; ! 295: mi->mi_driver->md_info[mi->mi_unit] = mi; ! 296: mi->mi_mbanum = ni->mi_mbanum; ! 297: mi->mi_drive = ni->mi_drive; ! 298: if (mi->mi_dk && dkn < DK_NDRIVE) ! 299: mi->mi_dk = dkn++; ! 300: else ! 301: mi->mi_dk = -1; ! 302: (*mi->mi_driver->md_attach)(mi); ! 303: return (mi); ! 304: } ! 305: return (0); ! 306: } ! 307: #endif ! 308: ! 309: /* ! 310: * Fixctlrmask fixes the masks of the driver ctlr routines ! 311: * which otherwise save r10 and r11 where the interrupt and br ! 312: * level are passed through. ! 313: */ ! 314: fixctlrmask() ! 315: { ! 316: register struct uba_ctlr *um; ! 317: register struct uba_device *ui; ! 318: register struct uba_driver *ud; ! 319: #define phys(a,b) ((b)(((int)(a))&0x7fffffff)) ! 320: ! 321: for (um = ubminit; ud = phys(um->um_driver, struct uba_driver *); um++) ! 322: *phys(ud->ud_probe, short *) &= ~0xc00; ! 323: for (ui = ubdinit; ud = phys(ui->ui_driver, struct uba_driver *); ui++) ! 324: *phys(ud->ud_probe, short *) &= ~0xc00; ! 325: } ! 326: ! 327: /* ! 328: * Find devices on a UNIBUS. ! 329: * Uses per-driver routine to set <br,cvec> into <r11,r10>, ! 330: * and then fills in the tables, with help from a per-driver ! 331: * slave initialization routine. ! 332: */ ! 333: unifind(vubp, pubp, vumem, pumem, memmap) ! 334: struct uba_regs *vubp, *pubp; ! 335: caddr_t vumem, pumem; ! 336: struct pte *memmap; ! 337: { ! 338: #ifndef lint ! 339: register int br, cvec; /* MUST BE r11, r10 */ ! 340: #else ! 341: /* ! 342: * Lint doesn't realize that these ! 343: * can be initialized asynchronously ! 344: * when devices interrupt. ! 345: */ ! 346: register int br = 0, cvec = 0; ! 347: #endif ! 348: register struct uba_device *ui; ! 349: register struct uba_ctlr *um; ! 350: u_short *reg, addr; ! 351: struct uba_hd *uhp; ! 352: struct uba_driver *udp; ! 353: int i, (**ivec)(), haveubasr = 0; ! 354: ! 355: /* ! 356: * Initialize the UNIBUS, by freeing the map ! 357: * registers and the buffered data path registers ! 358: */ ! 359: uhp = &uba_hd[numuba]; ! 360: uhp->uh_map = (struct map *)calloc(UAMSIZ * sizeof (struct map)); ! 361: rminit(uhp->uh_map, NUBMREG, 1, "uba", UAMSIZ); ! 362: switch (cpu) { ! 363: #if VAX780 ! 364: case VAX_780: ! 365: uhp->uh_bdpfree = (1<<NBDP780) - 1; ! 366: haveubasr = 1; ! 367: break; ! 368: #endif ! 369: #if VAX750 ! 370: case VAX_750: ! 371: uhp->uh_bdpfree = (1<<NBDP750) - 1; ! 372: break; ! 373: #endif ! 374: #if VAX7ZZ ! 375: case VAX_7ZZ: ! 376: break; ! 377: #endif ! 378: } ! 379: ! 380: /* ! 381: * Save virtual and physical addresses ! 382: * of adaptor, and allocate and initialize ! 383: * the UNIBUS interrupt vector. ! 384: */ ! 385: uhp->uh_uba = vubp; ! 386: uhp->uh_physuba = pubp; ! 387: /* HAVE TO DO SOMETHING SPECIAL FOR SECOND UNIBUS ON COMETS HERE */ ! 388: if (numuba == 0) ! 389: uhp->uh_vec = UNIvec; ! 390: else ! 391: uhp->uh_vec = (int(**)())calloc(512); ! 392: for (i = 0; i < 128; i++) ! 393: uhp->uh_vec[i] = ! 394: scbentry(&catcher[i*2], SCB_ISTACK); ! 395: /* ! 396: * Set last free interrupt vector for devices with ! 397: * programmable interrupt vectors. Use is to decrement ! 398: * this number and use result as interrupt vector. ! 399: */ ! 400: uhp->uh_lastiv = 0x200; ! 401: ! 402: /* THIS IS A CHEAT: USING THE FACT THAT UMEM and NEXI ARE SAME SIZE */ ! 403: nxaccess((struct nexus *)pumem, memmap); ! 404: #if VAX780 ! 405: if (haveubasr) { ! 406: vubp->uba_sr = vubp->uba_sr; ! 407: vubp->uba_cr = UBACR_IFS|UBACR_BRIE; ! 408: } ! 409: #endif ! 410: /* ! 411: * Map the first page of UNIBUS i/o ! 412: * space to the first page of memory ! 413: * for devices which will need to dma ! 414: * output to produce an interrupt. ! 415: */ ! 416: *(int *)(&vubp->uba_map[0]) = UBAMR_MRV; ! 417: ! 418: #define ubaddr(off) (u_short *)((int)vumem + ((off)&0x1fff)) ! 419: /* ! 420: * Check each unibus mass storage controller. ! 421: * For each one which is potentially on this uba, ! 422: * see if it is really there, and if it is record it and ! 423: * then go looking for slaves. ! 424: */ ! 425: for (um = ubminit; udp = um->um_driver; um++) { ! 426: if (um->um_ubanum != numuba && um->um_ubanum != '?') ! 427: continue; ! 428: addr = (u_short)um->um_addr; ! 429: reg = ubaddr(addr); ! 430: if (badaddr((caddr_t)reg, 2)) ! 431: continue; ! 432: #if VAX780 ! 433: if (haveubasr && vubp->uba_sr) { ! 434: vubp->uba_sr = vubp->uba_sr; ! 435: continue; ! 436: } ! 437: #endif ! 438: cvec = 0x200; ! 439: i = (*udp->ud_probe)(reg); ! 440: #if VAX780 ! 441: if (haveubasr && vubp->uba_sr) { ! 442: vubp->uba_sr = vubp->uba_sr; ! 443: continue; ! 444: } ! 445: #endif ! 446: if (i == 0) ! 447: continue; ! 448: printf("%s%d at uba%d csr %o ", ! 449: udp->ud_mname, um->um_ctlr, numuba, addr); ! 450: if (cvec == 0) { ! 451: printf("zero vector\n"); ! 452: continue; ! 453: } ! 454: if (cvec == 0x200) { ! 455: printf("didn't interrupt\n"); ! 456: continue; ! 457: } ! 458: printf("vec %o, ipl %x\n", cvec, br); ! 459: um->um_alive = 1; ! 460: um->um_ubanum = numuba; ! 461: um->um_hd = &uba_hd[numuba]; ! 462: um->um_addr = (caddr_t)reg; ! 463: udp->ud_minfo[um->um_ctlr] = um; ! 464: for (ivec = um->um_intr; *ivec; ivec++) { ! 465: um->um_hd->uh_vec[cvec/4] = ! 466: scbentry(*ivec, SCB_ISTACK); ! 467: cvec += 4; ! 468: } ! 469: for (ui = ubdinit; ui->ui_driver; ui++) { ! 470: if (ui->ui_driver != udp || ui->ui_alive || ! 471: ui->ui_ctlr != um->um_ctlr && ui->ui_ctlr != '?' || ! 472: ui->ui_ubanum != numuba && ui->ui_ubanum != '?') ! 473: continue; ! 474: if ((*udp->ud_slave)(ui, reg)) { ! 475: ui->ui_alive = 1; ! 476: ui->ui_ctlr = um->um_ctlr; ! 477: ui->ui_ubanum = numuba; ! 478: ui->ui_hd = &uba_hd[numuba]; ! 479: ui->ui_addr = (caddr_t)reg; ! 480: ui->ui_physaddr = pumem + (addr&0x1fff); ! 481: if (ui->ui_dk && dkn < DK_NDRIVE) ! 482: ui->ui_dk = dkn++; ! 483: else ! 484: ui->ui_dk = -1; ! 485: ui->ui_mi = um; ! 486: /* ui_type comes from driver */ ! 487: udp->ud_dinfo[ui->ui_unit] = ui; ! 488: printf("%s%d at %s%d slave %d\n", ! 489: udp->ud_dname, ui->ui_unit, ! 490: udp->ud_mname, um->um_ctlr, ui->ui_slave); ! 491: (*udp->ud_attach)(ui); ! 492: } ! 493: } ! 494: } ! 495: /* ! 496: * Now look for non-mass storage peripherals. ! 497: */ ! 498: for (ui = ubdinit; udp = ui->ui_driver; ui++) { ! 499: if (ui->ui_ubanum != numuba && ui->ui_ubanum != '?' || ! 500: ui->ui_alive || ui->ui_slave != -1) ! 501: continue; ! 502: addr = (u_short)ui->ui_addr; ! 503: reg = ubaddr(addr); ! 504: if (badaddr((caddr_t)reg, 2)) ! 505: continue; ! 506: #if VAX780 ! 507: if (haveubasr && vubp->uba_sr) { ! 508: vubp->uba_sr = vubp->uba_sr; ! 509: continue; ! 510: } ! 511: #endif ! 512: cvec = 0x200; ! 513: i = (*udp->ud_probe)(reg, um->um_ctlr); ! 514: #if VAX780 ! 515: if (haveubasr && vubp->uba_sr) { ! 516: vubp->uba_sr = vubp->uba_sr; ! 517: continue; ! 518: } ! 519: #endif ! 520: if (i == 0) ! 521: continue; ! 522: printf("%s%d at uba%d csr %o ", ! 523: ui->ui_driver->ud_dname, ui->ui_unit, numuba, addr); ! 524: if (cvec == 0) { ! 525: printf("zero vector\n"); ! 526: continue; ! 527: } ! 528: if (cvec == 0x200) { ! 529: printf("didn't interrupt\n"); ! 530: continue; ! 531: } ! 532: printf("vec %o, ipl %x\n", cvec, br); ! 533: ui->ui_hd = &uba_hd[numuba]; ! 534: for (ivec = ui->ui_intr; *ivec; ivec++) { ! 535: ui->ui_hd->uh_vec[cvec/4] = ! 536: scbentry(*ivec, SCB_ISTACK); ! 537: cvec += 4; ! 538: } ! 539: ui->ui_alive = 1; ! 540: ui->ui_ubanum = numuba; ! 541: ui->ui_addr = (caddr_t)reg; ! 542: ui->ui_physaddr = pumem + (addr&0x1fff); ! 543: ui->ui_dk = -1; ! 544: /* ui_type comes from driver */ ! 545: udp->ud_dinfo[ui->ui_unit] = ui; ! 546: (*udp->ud_attach)(ui); ! 547: } ! 548: } ! 549: ! 550: setscbnex(fn) ! 551: int (*fn)(); ! 552: { ! 553: register struct scb *scbp = &scb; ! 554: ! 555: scbp->scb_ipl14[nexnum] = scbp->scb_ipl15[nexnum] = ! 556: scbp->scb_ipl16[nexnum] = scbp->scb_ipl17[nexnum] = ! 557: scbentry(fn, SCB_ISTACK); ! 558: } ! 559: ! 560: /* ! 561: * Make a nexus accessible at physical address phys ! 562: * by mapping kernel ptes starting at pte. ! 563: * ! 564: * WE LEAVE ALL NEXI MAPPED; THIS IS PERHAPS UNWISE ! 565: * SINCE MISSING NEXI DONT RESPOND. BUT THEN AGAIN ! 566: * PRESENT NEXI DONT RESPOND TO ALL OF THEIR ADDRESS SPACE. ! 567: */ ! 568: nxaccess(physa, pte) ! 569: struct nexus *physa; ! 570: register struct pte *pte; ! 571: { ! 572: register int i = btop(sizeof (struct nexus)); ! 573: register unsigned v = btop(physa); ! 574: ! 575: do ! 576: *(int *)pte++ = PG_V|PG_KW|v++; ! 577: while (--i > 0); ! 578: mtpr(TBIA, 0); ! 579: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.