![[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] / 43BSD / sys / vax|
Return to autoconf.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vax |
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.1 (Berkeley) 6/6/86 ! 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: ! 21: #include "pte.h" ! 22: ! 23: #include "param.h" ! 24: #include "systm.h" ! 25: #include "map.h" ! 26: #include "buf.h" ! 27: #include "dk.h" ! 28: #include "vm.h" ! 29: #include "conf.h" ! 30: #include "dmap.h" ! 31: #include "reboot.h" ! 32: ! 33: #include "cpu.h" ! 34: #include "mem.h" ! 35: #include "mtpr.h" ! 36: #include "nexus.h" ! 37: #include "scb.h" ! 38: #include "ioa.h" ! 39: #include "../vaxmba/mbareg.h" ! 40: #include "../vaxmba/mbavar.h" ! 41: #include "../vaxuba/ubareg.h" ! 42: #include "../vaxuba/ubavar.h" ! 43: ! 44: /* ! 45: * The following several variables are related to ! 46: * the configuration process, and are used in initializing ! 47: * the machine. ! 48: */ ! 49: int cold; /* if 1, still working on cold-start */ ! 50: int nexnum; /* current nexus number */ ! 51: int nsbi; /* current sbi number */ ! 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: #if NMBA > 0 ! 61: int (*mbaintv[4])() = { Xmba0int, Xmba1int, Xmba2int, Xmba3int }; ! 62: #if NMBA > 4 ! 63: Need to expand the table for more than 4 massbus adaptors ! 64: #endif ! 65: #endif ! 66: #if defined(VAX780) || defined(VAX8600) ! 67: int (*ubaintv[])() = ! 68: { ! 69: Xua0int, Xua1int, Xua2int, Xua3int, ! 70: #if NUBA > 4 ! 71: Xua4int, Xua5int, Xua6int, Xua7int, ! 72: #endif ! 73: #if NUBA > 8 ! 74: Need to expand the table for more than 8 unibus adaptors ! 75: #endif ! 76: }; ! 77: #endif ! 78: ! 79: /* ! 80: * This allocates the space for the per-uba information, ! 81: * such as buffered data path usage. ! 82: */ ! 83: struct uba_hd uba_hd[NUBA]; ! 84: ! 85: /* ! 86: * Determine mass storage and memory configuration for a machine. ! 87: * Get cpu type, and then switch out to machine specific procedures ! 88: * which will probe adaptors to see what is out there. ! 89: */ ! 90: configure() ! 91: { ! 92: union cpusid cpusid; ! 93: register struct percpu *ocp; ! 94: register int *ip; ! 95: extern char Sysbase[]; ! 96: ! 97: cpusid.cpusid = mfpr(SID); ! 98: for (ocp = percpu; ocp->pc_cputype; ocp++) ! 99: if (ocp->pc_cputype == cpusid.cpuany.cp_type) { ! 100: cpuspeed = ocp->pc_cpuspeed; ! 101: probeio(ocp); ! 102: /* ! 103: * Write protect the scb and UNIBUS interrupt vectors. ! 104: * It is strange that this code is here, but this is ! 105: * as soon as we are done mucking with it, and the ! 106: * write-enable was done in assembly language ! 107: * to which we will never return. ! 108: */ ! 109: ip = (int *)Sysmap + 1; *ip &= ~PG_PROT; *ip |= PG_KR; ! 110: ip++; *ip &= ~PG_PROT; *ip |= PG_KR; ! 111: #if NUBA > 1 ! 112: ip++; *ip &= ~PG_PROT; *ip |= PG_KR; ! 113: #endif ! 114: mtpr(TBIS, Sysbase); ! 115: #if GENERIC ! 116: if ((boothowto & RB_ASKNAME) == 0) ! 117: setroot(); ! 118: setconf(); ! 119: #else ! 120: setroot(); ! 121: #endif ! 122: /* ! 123: * Configure swap area and related system ! 124: * parameter based on device(s) used. ! 125: */ ! 126: swapconf(); ! 127: cold = 0; ! 128: memenable(); ! 129: return; ! 130: } ! 131: printf("cpu type %d not configured\n", cpusid.cpuany.cp_type); ! 132: asm("halt"); ! 133: } ! 134: ! 135: /* ! 136: * Probe the main IO bus(es). ! 137: * The percpu structure gives us a handle on the addresses and/or types. ! 138: */ ! 139: probeio(pcpu) ! 140: register struct percpu *pcpu; ! 141: { ! 142: register struct iobus *iob; ! 143: int ioanum; ! 144: ! 145: ioanum = 0; ! 146: for (iob = pcpu->pc_io; ioanum < pcpu->pc_nioa; ioanum++, iob++) { ! 147: ! 148: switch (iob->io_type) { ! 149: ! 150: #if VAX780 || VAX750 || VAX730 || VAX630 ! 151: case IO_SBI780: ! 152: case IO_CMI750: ! 153: case IO_XXX730: ! 154: case IO_QBUS: ! 155: probenexi((struct nexusconnect *)iob->io_details); ! 156: break; ! 157: #endif ! 158: ! 159: #if VAX8600 ! 160: case IO_ABUS: ! 161: probe_Abus(ioanum, iob); ! 162: break; ! 163: #endif ! 164: default: ! 165: if (iob->io_addr) { ! 166: printf( ! 167: "IO adaptor %d, type %d, at address 0x%x is unsupported\n", ! 168: ioanum, iob->io_type, iob->io_addr); ! 169: } else ! 170: printf("IO adaptor %d, type %d, is unsupported\n", ! 171: ioanum, iob->io_type); ! 172: break; ! 173: } ! 174: } ! 175: } ! 176: ! 177: #if VAX8600 ! 178: probe_Abus(ioanum, iob) ! 179: register struct iobus *iob; ! 180: { ! 181: register struct ioa *ioap; ! 182: union ioacsr ioacsr; ! 183: int type; ! 184: struct sbia_regs *sbiaregs; ! 185: ! 186: ioap = &ioa[ioanum]; ! 187: ioaccess(iob->io_addr, Ioamap[ioanum], iob->io_size); ! 188: if (badaddr((caddr_t)ioap, 4)) ! 189: return; ! 190: ioacsr.ioa_csr = ioap->ioacsr.ioa_csr; ! 191: type = ioacsr.ioa_type & IOA_TYPMSK; ! 192: ! 193: switch (type) { ! 194: ! 195: case IOA_SBIA: ! 196: printf("SBIA%d at IO adaptor %d address 0x%x\n", ! 197: nsbi, ioanum, iob->io_addr); ! 198: probenexi((struct nexusconnect *)iob->io_details); ! 199: nsbi++; ! 200: sbiaregs = (struct sbia_regs *)ioap; ! 201: sbiaregs->sbi_errsum = -1; ! 202: sbiaregs->sbi_error = 0x1000; ! 203: sbiaregs->sbi_fltsts = 0xc0000; ! 204: break; ! 205: ! 206: default: ! 207: printf("IOA%d at address 0x%x is unsupported (type = 0x%x)\n", ! 208: ioanum, iob->io_addr, ioacsr.ioa_type); ! 209: break; ! 210: } ! 211: } ! 212: #endif ! 213: ! 214: /* ! 215: * Probe nexus space, finding the interconnects ! 216: * and setting up and probing mba's and uba's for devices. ! 217: */ ! 218: /*ARGSUSED*/ ! 219: probenexi(pnc) ! 220: register struct nexusconnect *pnc; ! 221: { ! 222: register struct nexus *nxv; ! 223: struct nexus *nxp = pnc->psb_nexbase; ! 224: union nexcsr nexcsr; ! 225: int i; ! 226: ! 227: nexnum = 0, nxv = &nexus[nsbi * NNEXSBI]; ! 228: for (; nexnum < pnc->psb_nnexus; nexnum++, nxp++, nxv++) { ! 229: ioaccess((caddr_t)nxp, Nexmap[nsbi * NNEXSBI + nexnum], ! 230: sizeof(struct nexus)); ! 231: if (badaddr((caddr_t)nxv, 4)) ! 232: continue; ! 233: if (pnc->psb_nextype && pnc->psb_nextype[nexnum] != NEX_ANY) ! 234: nexcsr.nex_csr = pnc->psb_nextype[nexnum]; ! 235: else ! 236: nexcsr = nxv->nexcsr; ! 237: if (nexcsr.nex_csr&NEX_APD) ! 238: continue; ! 239: switch (nexcsr.nex_type) { ! 240: ! 241: case NEX_MBA: ! 242: printf("mba%d at tr%d\n", nummba, nexnum); ! 243: if (nummba >= NMBA) { ! 244: printf("%d mba's", nummba++); ! 245: goto unconfig; ! 246: } ! 247: #if NMBA > 0 ! 248: mbafind(nxv, nxp); ! 249: nummba++; ! 250: #endif ! 251: break; ! 252: ! 253: case NEX_UBA0: ! 254: case NEX_UBA1: ! 255: case NEX_UBA2: ! 256: case NEX_UBA3: ! 257: printf("uba%d at tr%d\n", numuba, nexnum); ! 258: #if VAX750 ! 259: if (numuba >= 2 && cpu == VAX_750) { ! 260: printf("More than 2 UBA's"); ! 261: goto unsupp; ! 262: } ! 263: #endif ! 264: if (numuba >= NUBA) { ! 265: printf("%d uba's", ++numuba); ! 266: goto unconfig; ! 267: } ! 268: #if defined(VAX780) || defined(VAX8600) ! 269: if ((cpu == VAX_780) || (cpu == VAX_8600)) ! 270: setscbnex(ubaintv[numuba]); ! 271: #endif ! 272: i = nexcsr.nex_type - NEX_UBA0; ! 273: unifind((struct uba_regs *)nxv, (struct uba_regs *)nxp, ! 274: umem[numuba], pnc->psb_umaddr[i], UMEMmap[numuba], ! 275: pnc->psb_haveubasr); ! 276: #if defined(VAX780) || defined(VAX8600) ! 277: if ((cpu == VAX_780) || (cpu == VAX_8600)) ! 278: ((struct uba_regs *)nxv)->uba_cr = ! 279: UBACR_IFS|UBACR_BRIE| ! 280: UBACR_USEFIE|UBACR_SUEFIE| ! 281: (((struct uba_regs *)nxv)->uba_cr&0x7c000000); ! 282: #endif ! 283: numuba++; ! 284: break; ! 285: ! 286: case NEX_DR32: ! 287: /* there can be more than one... are there other codes??? */ ! 288: printf("dr32"); ! 289: goto unsupp; ! 290: ! 291: case NEX_MEM4: ! 292: case NEX_MEM4I: ! 293: case NEX_MEM16: ! 294: case NEX_MEM16I: ! 295: printf("mcr%d at tr%d\n", nmcr, nexnum); ! 296: if (nmcr >= 4) { ! 297: printf("5 mcr's"); ! 298: goto unsupp; ! 299: } ! 300: switch (cpu) { ! 301: case VAX_780: ! 302: mcrtype[nmcr] = M780C; ! 303: break; ! 304: case VAX_750: ! 305: mcrtype[nmcr] = M750; ! 306: break; ! 307: case VAX_730: ! 308: mcrtype[nmcr] = M730; ! 309: break; ! 310: } ! 311: mcraddr[nmcr++] = (struct mcr *)nxv; ! 312: break; ! 313: ! 314: case NEX_MEM64I: ! 315: case NEX_MEM64L: ! 316: case NEX_MEM64LI: ! 317: case NEX_MEM256I: ! 318: case NEX_MEM256L: ! 319: case NEX_MEM256LI: ! 320: printf("mcr%d (el) at tr%d\n", nmcr, nexnum); ! 321: if (nmcr >= 4) { ! 322: printf("5 mcr's"); ! 323: goto unsupp; ! 324: } ! 325: if (cpu == VAX_780) ! 326: mcrtype[nmcr] = M780EL; ! 327: mcraddr[nmcr++] = (struct mcr *)nxv; ! 328: if (nexcsr.nex_type != NEX_MEM64I && ! 329: nexcsr.nex_type != NEX_MEM256I) ! 330: break; ! 331: /* fall into ... */ ! 332: ! 333: case NEX_MEM64U: ! 334: case NEX_MEM64UI: ! 335: case NEX_MEM256U: ! 336: case NEX_MEM256UI: ! 337: printf("mcr%d (eu) at tr%d\n", nmcr, nexnum); ! 338: if (nmcr >= 4) { ! 339: printf("5 mcr's"); ! 340: goto unsupp; ! 341: } ! 342: if (cpu == VAX_780) ! 343: mcrtype[nmcr] = M780EU; ! 344: mcraddr[nmcr++] = (struct mcr *)nxv; ! 345: break; ! 346: ! 347: case NEX_MPM0: ! 348: case NEX_MPM1: ! 349: case NEX_MPM2: ! 350: case NEX_MPM3: ! 351: printf("mpm"); ! 352: goto unsupp; ! 353: ! 354: case NEX_CI: ! 355: printf("ci"); ! 356: goto unsupp; ! 357: ! 358: default: ! 359: printf("nexus type %x", nexcsr.nex_type); ! 360: unsupp: ! 361: printf(" unsupported (at tr %d)\n", nexnum); ! 362: continue; ! 363: unconfig: ! 364: printf(" not configured\n"); ! 365: continue; ! 366: } ! 367: } ! 368: if (nummba > NMBA) ! 369: nummba = NMBA; ! 370: if (numuba > NUBA) ! 371: numuba = NUBA; ! 372: } ! 373: ! 374: #if NMBA > 0 ! 375: struct mba_device *mbaconfig(); ! 376: /* ! 377: * Find devices attached to a particular mba ! 378: * and look for each device found in the massbus ! 379: * initialization tables. ! 380: */ ! 381: mbafind(nxv, nxp) ! 382: struct nexus *nxv, *nxp; ! 383: { ! 384: register struct mba_regs *mdp; ! 385: register struct mba_drv *mbd; ! 386: register struct mba_device *mi; ! 387: register struct mba_slave *ms; ! 388: int dn, dt, sn; ! 389: struct mba_device fnd; ! 390: ! 391: mdp = (struct mba_regs *)nxv; ! 392: mba_hd[nummba].mh_mba = mdp; ! 393: mba_hd[nummba].mh_physmba = (struct mba_regs *)nxp; ! 394: setscbnex(mbaintv[nummba]); ! 395: fnd.mi_mba = mdp; ! 396: fnd.mi_mbanum = nummba; ! 397: for (mbd = mdp->mba_drv, dn = 0; mbd < &mdp->mba_drv[8]; mbd++, dn++) { ! 398: if ((mbd->mbd_ds&MBDS_DPR) == 0) ! 399: continue; ! 400: mdp->mba_sr |= MBSR_NED; /* si kludge */ ! 401: dt = mbd->mbd_dt & 0xffff; ! 402: if (dt == 0) ! 403: continue; ! 404: if (mdp->mba_sr&MBSR_NED) ! 405: continue; /* si kludge */ ! 406: if (dt == MBDT_MOH) ! 407: continue; ! 408: fnd.mi_drive = dn; ! 409: #define qeq(a, b) ( a == b || a == '?' ) ! 410: if ((mi = mbaconfig(&fnd, dt)) && (dt & MBDT_TAP)) ! 411: for (sn = 0; sn < 8; sn++) { ! 412: mbd->mbd_tc = sn; ! 413: for (ms = mbsinit; ms->ms_driver; ms++) ! 414: if (ms->ms_driver == mi->mi_driver && ! 415: ms->ms_alive == 0 && ! 416: qeq(ms->ms_ctlr, mi->mi_unit) && ! 417: qeq(ms->ms_slave, sn) && ! 418: (*ms->ms_driver->md_slave)(mi, ms, sn)) { ! 419: printf("%s%d at %s%d slave %d\n" ! 420: , ms->ms_driver->md_sname ! 421: , ms->ms_unit ! 422: , mi->mi_driver->md_dname ! 423: , mi->mi_unit ! 424: , sn ! 425: ); ! 426: ms->ms_alive = 1; ! 427: ms->ms_ctlr = mi->mi_unit; ! 428: ms->ms_slave = sn; ! 429: } ! 430: } ! 431: } ! 432: mdp->mba_cr = MBCR_INIT; ! 433: mdp->mba_cr = MBCR_IE; ! 434: } ! 435: ! 436: /* ! 437: * Have found a massbus device; ! 438: * see if it is in the configuration table. ! 439: * If so, fill in its data. ! 440: */ ! 441: struct mba_device * ! 442: mbaconfig(ni, type) ! 443: register struct mba_device *ni; ! 444: register int type; ! 445: { ! 446: register struct mba_device *mi; ! 447: register short *tp; ! 448: register struct mba_hd *mh; ! 449: ! 450: for (mi = mbdinit; mi->mi_driver; mi++) { ! 451: if (mi->mi_alive) ! 452: continue; ! 453: tp = mi->mi_driver->md_type; ! 454: for (mi->mi_type = 0; *tp; tp++, mi->mi_type++) ! 455: if (*tp == (type&MBDT_TYPE)) ! 456: goto found; ! 457: continue; ! 458: found: ! 459: #define match(fld) (ni->fld == mi->fld || mi->fld == '?') ! 460: if (!match(mi_drive) || !match(mi_mbanum)) ! 461: continue; ! 462: printf("%s%d at mba%d drive %d\n", ! 463: mi->mi_driver->md_dname, mi->mi_unit, ! 464: ni->mi_mbanum, ni->mi_drive); ! 465: mi->mi_alive = 1; ! 466: mh = &mba_hd[ni->mi_mbanum]; ! 467: mi->mi_hd = mh; ! 468: mh->mh_mbip[ni->mi_drive] = mi; ! 469: mh->mh_ndrive++; ! 470: mi->mi_mba = ni->mi_mba; ! 471: mi->mi_drv = &mi->mi_mba->mba_drv[ni->mi_drive]; ! 472: mi->mi_mbanum = ni->mi_mbanum; ! 473: mi->mi_drive = ni->mi_drive; ! 474: /* ! 475: * If drive has never been seen before, ! 476: * give it a dkn for statistics. ! 477: */ ! 478: if (mi->mi_driver->md_info[mi->mi_unit] == 0) { ! 479: mi->mi_driver->md_info[mi->mi_unit] = mi; ! 480: if (mi->mi_dk && dkn < DK_NDRIVE) ! 481: mi->mi_dk = dkn++; ! 482: else ! 483: mi->mi_dk = -1; ! 484: } ! 485: (*mi->mi_driver->md_attach)(mi); ! 486: return (mi); ! 487: } ! 488: return (0); ! 489: } ! 490: #endif ! 491: ! 492: /* ! 493: * Fixctlrmask fixes the masks of the driver ctlr routines ! 494: * which otherwise save r10 and r11 where the interrupt and br ! 495: * level are passed through. ! 496: */ ! 497: fixctlrmask() ! 498: { ! 499: register struct uba_ctlr *um; ! 500: register struct uba_device *ui; ! 501: register struct uba_driver *ud; ! 502: #define phys(a,b) ((b)(((int)(a))&0x7fffffff)) ! 503: ! 504: for (um = ubminit; ud = phys(um->um_driver, struct uba_driver *); um++) ! 505: *phys(ud->ud_probe, short *) &= ~0xc00; ! 506: for (ui = ubdinit; ud = phys(ui->ui_driver, struct uba_driver *); ui++) ! 507: *phys(ud->ud_probe, short *) &= ~0xc00; ! 508: } ! 509: ! 510: /* ! 511: * Find devices on a UNIBUS. ! 512: * Uses per-driver routine to set <br,cvec> into <r11,r10>, ! 513: * and then fills in the tables, with help from a per-driver ! 514: * slave initialization routine. ! 515: */ ! 516: unifind(vubp, pubp, vumem, pumem, memmap, haveubasr) ! 517: struct uba_regs *vubp, *pubp; ! 518: caddr_t vumem, pumem; ! 519: struct pte *memmap; ! 520: int haveubasr; ! 521: { ! 522: #ifndef lint ! 523: register int br, cvec; /* MUST BE r11, r10 */ ! 524: #else ! 525: /* ! 526: * Lint doesn't realize that these ! 527: * can be initialized asynchronously ! 528: * when devices interrupt. ! 529: */ ! 530: register int br = 0, cvec = 0; ! 531: #endif ! 532: register struct uba_device *ui; ! 533: register struct uba_ctlr *um; ! 534: u_short *reg, *ap, addr; ! 535: struct uba_hd *uhp; ! 536: struct uba_driver *udp; ! 537: int i, (**ivec)(); ! 538: caddr_t ualloc, zmemall(); ! 539: extern int catcher[256]; ! 540: ! 541: #if VAX630 ! 542: /* ! 543: * The map registers start right at 20088000 on the ! 544: * ka630, so we have to subtract out the 2k offset to make the ! 545: * pointers work.. ! 546: */ ! 547: if (cpu == VAX_630) { ! 548: vubp = (struct uba_regs *)(((u_long)vubp)-0x800); ! 549: pubp = (struct uba_regs *)(((u_long)pubp)-0x800); ! 550: } ! 551: #endif ! 552: /* ! 553: * Initialize the UNIBUS, by freeing the map ! 554: * registers and the buffered data path registers ! 555: */ ! 556: uhp = &uba_hd[numuba]; ! 557: uhp->uh_map = (struct map *)calloc(UAMSIZ * sizeof (struct map)); ! 558: ubainitmaps(uhp); ! 559: ! 560: /* ! 561: * Save virtual and physical addresses ! 562: * of adaptor, and allocate and initialize ! 563: * the UNIBUS interrupt vector. ! 564: */ ! 565: uhp->uh_uba = vubp; ! 566: uhp->uh_physuba = pubp; ! 567: /* ! 568: * On the 8600, can't use UNIvec; ! 569: * the vectors for the second SBI overlap it. ! 570: */ ! 571: if (cpu == VAX_8600) ! 572: uhp->uh_vec = (int(**)())calloc(512); ! 573: else if (numuba == 0) ! 574: uhp->uh_vec = UNIvec; ! 575: #if NUBA > 1 ! 576: else if (numuba == 1) ! 577: uhp->uh_vec = UNI1vec; ! 578: else ! 579: uhp->uh_vec = (int(**)())calloc(512); ! 580: #endif ! 581: for (i = 0; i < 128; i++) ! 582: uhp->uh_vec[i] = ! 583: scbentry(&catcher[i*2], SCB_ISTACK); ! 584: /* ! 585: * Set last free interrupt vector for devices with ! 586: * programmable interrupt vectors. Use is to decrement ! 587: * this number and use result as interrupt vector. ! 588: */ ! 589: uhp->uh_lastiv = 0x200; ! 590: ! 591: #if VAX630 ! 592: /* ! 593: * Kludge time again. The q22 memory and device reg. address spaces ! 594: * are not physically contiguous, so we need 2 loops to map them ! 595: * into contiguous virtual space. ! 596: */ ! 597: if (cpu == VAX_630) { ! 598: ioaccess(pumem, memmap, (UBAPAGES-16)*NBPG); ! 599: ioaccess(0x20000000, memmap+(UBAPAGES-16), 16*NBPG); ! 600: } else ! 601: #endif ! 602: ioaccess(pumem, memmap, UBAPAGES * NBPG); ! 603: #if defined(VAX780) || defined(VAX8600) ! 604: if (haveubasr) { ! 605: vubp->uba_sr = vubp->uba_sr; ! 606: vubp->uba_cr = UBACR_IFS|UBACR_BRIE; ! 607: } ! 608: #endif ! 609: /* ! 610: * First configure devices that have unibus memory, ! 611: * allowing them to allocate the correct map registers. ! 612: */ ! 613: ubameminit(numuba); ! 614: /* ! 615: * Grab some memory to record the umem address space we allocate, ! 616: * so we can be sure not to place two devices at the same address. ! 617: * ! 618: * We could use just 1/8 of this (we only want a 1 bit flag) but ! 619: * we are going to give it back anyway, and that would make the ! 620: * code here bigger (which we can't give back), so ... ! 621: * ! 622: * One day, someone will make a unibus with something other than ! 623: * an 8K i/o address space, & screw this totally. ! 624: */ ! 625: ualloc = zmemall(memall, 8*1024); ! 626: if (ualloc == (caddr_t)0) ! 627: panic("no mem for unifind"); ! 628: ! 629: /* ! 630: * Map the first page of UNIBUS i/o ! 631: * space to the first page of memory ! 632: * for devices which will need to dma ! 633: * output to produce an interrupt. ! 634: */ ! 635: *(int *)(&vubp->uba_map[0]) = UBAMR_MRV; ! 636: ! 637: #define ubaoff(off) ((off)&0x1fff) ! 638: #define ubaddr(off) (u_short *)((int)vumem + (ubaoff(off)|0x3e000)) ! 639: /* ! 640: * Check each unibus mass storage controller. ! 641: * For each one which is potentially on this uba, ! 642: * see if it is really there, and if it is record it and ! 643: * then go looking for slaves. ! 644: */ ! 645: for (um = ubminit; udp = um->um_driver; um++) { ! 646: if (um->um_ubanum != numuba && um->um_ubanum != '?') ! 647: continue; ! 648: addr = (u_short)um->um_addr; ! 649: /* ! 650: * use the particular address specified first, ! 651: * or if it is given as "0", of there is no device ! 652: * at that address, try all the standard addresses ! 653: * in the driver til we find it ! 654: */ ! 655: for (ap = udp->ud_addr; addr || (addr = *ap++); addr = 0) { ! 656: ! 657: if (ualloc[ubaoff(addr)]) ! 658: continue; ! 659: reg = ubaddr(addr); ! 660: if (badaddr((caddr_t)reg, 2)) ! 661: continue; ! 662: #if defined(VAX780) || defined(VAX8600) ! 663: if (haveubasr && vubp->uba_sr) { ! 664: vubp->uba_sr = vubp->uba_sr; ! 665: continue; ! 666: } ! 667: #endif ! 668: cvec = 0x200; ! 669: i = (*udp->ud_probe)(reg, um->um_ctlr, um); ! 670: #if defined(VAX780) || defined(VAX8600) ! 671: if (haveubasr && vubp->uba_sr) { ! 672: vubp->uba_sr = vubp->uba_sr; ! 673: continue; ! 674: } ! 675: #endif ! 676: if (i == 0) ! 677: continue; ! 678: printf("%s%d at uba%d csr %o ", ! 679: udp->ud_mname, um->um_ctlr, numuba, addr); ! 680: if (cvec == 0) { ! 681: printf("zero vector\n"); ! 682: continue; ! 683: } ! 684: if (cvec == 0x200) { ! 685: printf("didn't interrupt\n"); ! 686: continue; ! 687: } ! 688: printf("vec %o, ipl %x\n", cvec, br); ! 689: um->um_alive = 1; ! 690: um->um_ubanum = numuba; ! 691: um->um_hd = &uba_hd[numuba]; ! 692: um->um_addr = (caddr_t)reg; ! 693: udp->ud_minfo[um->um_ctlr] = um; ! 694: for (ivec = um->um_intr; *ivec; ivec++) { ! 695: um->um_hd->uh_vec[cvec/4] = ! 696: scbentry(*ivec, SCB_ISTACK); ! 697: cvec += 4; ! 698: } ! 699: for (ui = ubdinit; ui->ui_driver; ui++) { ! 700: if (ui->ui_driver != udp || ui->ui_alive || ! 701: ui->ui_ctlr != um->um_ctlr && ui->ui_ctlr != '?' || ! 702: ui->ui_ubanum != numuba && ui->ui_ubanum != '?') ! 703: continue; ! 704: if ((*udp->ud_slave)(ui, reg)) { ! 705: ui->ui_alive = 1; ! 706: ui->ui_ctlr = um->um_ctlr; ! 707: ui->ui_ubanum = numuba; ! 708: ui->ui_hd = &uba_hd[numuba]; ! 709: ui->ui_addr = (caddr_t)reg; ! 710: ui->ui_physaddr = pumem + ubdevreg(addr); ! 711: if (ui->ui_dk && dkn < DK_NDRIVE) ! 712: ui->ui_dk = dkn++; ! 713: else ! 714: ui->ui_dk = -1; ! 715: ui->ui_mi = um; ! 716: /* ui_type comes from driver */ ! 717: udp->ud_dinfo[ui->ui_unit] = ui; ! 718: printf("%s%d at %s%d slave %d\n", ! 719: udp->ud_dname, ui->ui_unit, ! 720: udp->ud_mname, um->um_ctlr, ui->ui_slave); ! 721: (*udp->ud_attach)(ui); ! 722: } ! 723: } ! 724: break; ! 725: } ! 726: } ! 727: /* ! 728: * Now look for non-mass storage peripherals. ! 729: */ ! 730: for (ui = ubdinit; udp = ui->ui_driver; ui++) { ! 731: if (ui->ui_ubanum != numuba && ui->ui_ubanum != '?' || ! 732: ui->ui_alive || ui->ui_slave != -1) ! 733: continue; ! 734: addr = (u_short)ui->ui_addr; ! 735: ! 736: for (ap = udp->ud_addr; addr || (addr = *ap++); addr = 0) { ! 737: ! 738: if (ualloc[ubaoff(addr)]) ! 739: continue; ! 740: reg = ubaddr(addr); ! 741: if (badaddr((caddr_t)reg, 2)) ! 742: continue; ! 743: #if defined(VAX780) || defined(VAX8600) ! 744: if (haveubasr && vubp->uba_sr) { ! 745: vubp->uba_sr = vubp->uba_sr; ! 746: continue; ! 747: } ! 748: #endif ! 749: cvec = 0x200; ! 750: i = (*udp->ud_probe)(reg, ui); ! 751: #if defined(VAX780) || defined(VAX8600) ! 752: if (haveubasr && vubp->uba_sr) { ! 753: vubp->uba_sr = vubp->uba_sr; ! 754: continue; ! 755: } ! 756: #endif ! 757: if (i == 0) ! 758: continue; ! 759: printf("%s%d at uba%d csr %o ", ! 760: ui->ui_driver->ud_dname, ui->ui_unit, numuba, addr); ! 761: if (cvec == 0) { ! 762: printf("zero vector\n"); ! 763: continue; ! 764: } ! 765: if (cvec == 0x200) { ! 766: printf("didn't interrupt\n"); ! 767: continue; ! 768: } ! 769: printf("vec %o, ipl %x\n", cvec, br); ! 770: while (--i >= 0) ! 771: ualloc[ubaoff(addr+i)] = 1; ! 772: ui->ui_hd = &uba_hd[numuba]; ! 773: for (ivec = ui->ui_intr; *ivec; ivec++) { ! 774: ui->ui_hd->uh_vec[cvec/4] = ! 775: scbentry(*ivec, SCB_ISTACK); ! 776: cvec += 4; ! 777: } ! 778: ui->ui_alive = 1; ! 779: ui->ui_ubanum = numuba; ! 780: ui->ui_addr = (caddr_t)reg; ! 781: ui->ui_physaddr = pumem + ubdevreg(addr); ! 782: ui->ui_dk = -1; ! 783: /* ui_type comes from driver */ ! 784: udp->ud_dinfo[ui->ui_unit] = ui; ! 785: (*udp->ud_attach)(ui); ! 786: break; ! 787: } ! 788: } ! 789: ! 790: #ifdef AUTO_DEBUG ! 791: printf("Unibus allocation map"); ! 792: for (i = 0; i < 8*1024; ) { ! 793: register n, m; ! 794: ! 795: if ((i % 128) == 0) { ! 796: printf("\n%6o:", i); ! 797: for (n = 0; n < 128; n++) ! 798: if (ualloc[i+n]) ! 799: break; ! 800: if (n == 128) { ! 801: i += 128; ! 802: continue; ! 803: } ! 804: } ! 805: ! 806: for (n = m = 0; n < 16; n++) { ! 807: m <<= 1; ! 808: m |= ualloc[i++]; ! 809: } ! 810: ! 811: printf(" %4x", m); ! 812: } ! 813: printf("\n"); ! 814: #endif ! 815: ! 816: wmemfree(ualloc, 8*1024); ! 817: } ! 818: ! 819: setscbnex(fn) ! 820: int (*fn)(); ! 821: { ! 822: register struct scb *scbp = &scb; ! 823: ! 824: scbp = (struct scb *)((caddr_t)scbp + nsbi * 512); ! 825: scbp->scb_ipl14[nexnum] = scbp->scb_ipl15[nexnum] = ! 826: scbp->scb_ipl16[nexnum] = scbp->scb_ipl17[nexnum] = ! 827: scbentry(fn, SCB_ISTACK); ! 828: } ! 829: ! 830: /* ! 831: * Make an IO register area accessible at physical address physa ! 832: * by mapping kernel ptes starting at pte. ! 833: */ ! 834: ioaccess(physa, pte, size) ! 835: caddr_t physa; ! 836: register struct pte *pte; ! 837: int size; ! 838: { ! 839: register int i = btop(size); ! 840: register unsigned v = btop(physa); ! 841: ! 842: do ! 843: *(int *)pte++ = PG_V|PG_KW|v++; ! 844: while (--i > 0); ! 845: mtpr(TBIA, 0); ! 846: } ! 847: ! 848: /* ! 849: * Configure swap space and related parameters. ! 850: */ ! 851: swapconf() ! 852: { ! 853: register struct swdevt *swp; ! 854: register int nblks; ! 855: ! 856: for (swp = swdevt; swp->sw_dev; swp++) { ! 857: if (bdevsw[major(swp->sw_dev)].d_psize) { ! 858: nblks = ! 859: (*bdevsw[major(swp->sw_dev)].d_psize)(swp->sw_dev); ! 860: if (swp->sw_nblks == 0 || swp->sw_nblks > nblks) ! 861: swp->sw_nblks = nblks; ! 862: } ! 863: } ! 864: if (!cold) /* in case called for mba device */ ! 865: return; ! 866: if (dumplo == 0 && bdevsw[major(dumpdev)].d_psize) ! 867: dumplo = (*bdevsw[major(dumpdev)].d_psize)(dumpdev) - physmem; ! 868: if (dumplo < 0) ! 869: dumplo = 0; ! 870: } ! 871: ! 872: #define DOSWAP /* Change swdevt, argdev, and dumpdev too */ ! 873: u_long bootdev; /* should be dev_t, but not until 32 bits */ ! 874: ! 875: static char devname[][2] = { ! 876: 'h','p', /* 0 = hp */ ! 877: 0,0, /* 1 = ht */ ! 878: 'u','p', /* 2 = up */ ! 879: 'r','k', /* 3 = hk */ ! 880: 0,0, /* 4 = sw */ ! 881: 0,0, /* 5 = tm */ ! 882: 0,0, /* 6 = ts */ ! 883: 0,0, /* 7 = mt */ ! 884: 0,0, /* 8 = tu */ ! 885: 'r','a', /* 9 = ra */ ! 886: 0,0, /* 10 = ut */ ! 887: 'r','b', /* 11 = rb */ ! 888: 0,0, /* 12 = uu */ ! 889: 0,0, /* 13 = rx */ ! 890: 'r','l', /* 14 = rl */ ! 891: }; ! 892: ! 893: #define PARTITIONMASK 0x7 ! 894: #define PARTITIONSHIFT 3 ! 895: ! 896: /* ! 897: * Attempt to find the device from which we were booted. ! 898: * If we can do so, and not instructed not to do so, ! 899: * change rootdev to correspond to the load device. ! 900: */ ! 901: setroot() ! 902: { ! 903: int majdev, mindev, unit, part, adaptor; ! 904: dev_t temp, orootdev; ! 905: struct swdevt *swp; ! 906: ! 907: if (boothowto & RB_DFLTROOT || ! 908: (bootdev & B_MAGICMASK) != (u_long)B_DEVMAGIC) ! 909: return; ! 910: majdev = (bootdev >> B_TYPESHIFT) & B_TYPEMASK; ! 911: if (majdev > sizeof(devname) / sizeof(devname[0])) ! 912: return; ! 913: adaptor = (bootdev >> B_ADAPTORSHIFT) & B_ADAPTORMASK; ! 914: part = (bootdev >> B_PARTITIONSHIFT) & B_PARTITIONMASK; ! 915: unit = (bootdev >> B_UNITSHIFT) & B_UNITMASK; ! 916: if (majdev == 0) { /* MBA device */ ! 917: #if NMBA > 0 ! 918: register struct mba_device *mbap; ! 919: int mask; ! 920: ! 921: /* ! 922: * The MBA number used at boot time is not necessarily the same as the ! 923: * MBA number used by the kernel. In order to change the rootdev we need to ! 924: * convert the boot MBA number to the kernel MBA number. The address space ! 925: * for an MBA used by the boot code is 0x20010000 + 0x2000 * MBA_number ! 926: * on the 78? and 86?0, 0xf28000 + 0x2000 * MBA_number on the 750. ! 927: * Therefore we can search the mba_hd table for the MBA that has the physical ! 928: * address corresponding to the boot MBA number. ! 929: */ ! 930: #define PHYSADRSHFT 13 ! 931: #define PHYSMBAMASK780 0x7 ! 932: #define PHYSMBAMASK750 0x3 ! 933: ! 934: switch (cpu) { ! 935: ! 936: case VAX_780: ! 937: case VAX_8600: ! 938: default: ! 939: mask = PHYSMBAMASK780; ! 940: break; ! 941: ! 942: case VAX_750: ! 943: mask = PHYSMBAMASK750; ! 944: break; ! 945: } ! 946: for (mbap = mbdinit; mbap->mi_driver; mbap++) ! 947: if (mbap->mi_alive && mbap->mi_drive == unit && ! 948: (((long)mbap->mi_hd->mh_physmba >> PHYSADRSHFT) ! 949: & mask) == adaptor) ! 950: break; ! 951: if (mbap->mi_driver == 0) ! 952: return; ! 953: mindev = mbap->mi_unit; ! 954: #else ! 955: return; ! 956: #endif ! 957: } else { ! 958: register struct uba_device *ubap; ! 959: ! 960: for (ubap = ubdinit; ubap->ui_driver; ubap++) ! 961: if (ubap->ui_alive && ubap->ui_slave == unit && ! 962: ubap->ui_ubanum == adaptor && ! 963: ubap->ui_driver->ud_dname[0] == devname[majdev][0] && ! 964: ubap->ui_driver->ud_dname[1] == devname[majdev][1]) ! 965: break; ! 966: ! 967: if (ubap->ui_driver == 0) ! 968: return; ! 969: mindev = ubap->ui_unit; ! 970: } ! 971: mindev = (mindev << PARTITIONSHIFT) + part; ! 972: orootdev = rootdev; ! 973: rootdev = makedev(majdev, mindev); ! 974: /* ! 975: * If the original rootdev is the same as the one ! 976: * just calculated, don't need to adjust the swap configuration. ! 977: */ ! 978: if (rootdev == orootdev) ! 979: return; ! 980: ! 981: printf("Changing root device to %c%c%d%c\n", ! 982: devname[majdev][0], devname[majdev][1], ! 983: mindev >> PARTITIONSHIFT, part + 'a'); ! 984: ! 985: #ifdef DOSWAP ! 986: mindev &= ~PARTITIONMASK; ! 987: for (swp = swdevt; swp->sw_dev; swp++) { ! 988: if (majdev == major(swp->sw_dev) && ! 989: mindev == (minor(swp->sw_dev) & ~PARTITIONMASK)) { ! 990: temp = swdevt[0].sw_dev; ! 991: swdevt[0].sw_dev = swp->sw_dev; ! 992: swp->sw_dev = temp; ! 993: break; ! 994: } ! 995: } ! 996: if (swp->sw_dev == 0) ! 997: return; ! 998: ! 999: /* ! 1000: * If argdev and dumpdev were the same as the old primary swap ! 1001: * device, move them to the new primary swap device. ! 1002: */ ! 1003: if (temp == dumpdev) ! 1004: dumpdev = swdevt[0].sw_dev; ! 1005: if (temp == argdev) ! 1006: argdev = swdevt[0].sw_dev; ! 1007: #endif ! 1008: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.