![[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] / 42BSD / sys / vax|
Return to autoconf.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vax |
1.1 ! root 1: /* autoconf.c 6.3 83/08/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: #include "uba.h" ! 24: ! 25: #include "../machine/pte.h" ! 26: ! 27: #include "../h/param.h" ! 28: #include "../h/systm.h" ! 29: #include "../h/map.h" ! 30: #include "../h/buf.h" ! 31: #include "../h/dk.h" ! 32: #include "../h/vm.h" ! 33: #include "../h/conf.h" ! 34: #include "../h/dmap.h" ! 35: ! 36: #include "../vax/cpu.h" ! 37: #include "../vax/mem.h" ! 38: #include "../vax/mtpr.h" ! 39: #include "../vax/nexus.h" ! 40: #include "../vax/scb.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 nexnum; /* current nexus number */ ! 53: int dkn; /* number of iostat dk numbers assigned so far */ ! 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: #endif ! 63: #if VAX780 ! 64: int (*ubaintv[4])() = { Xua0int, Xua1int, Xua2int, Xua3int }; ! 65: #endif ! 66: ! 67: /* ! 68: * This allocates the space for the per-uba information, ! 69: * such as buffered data path usage. ! 70: */ ! 71: struct uba_hd uba_hd[MAXNUBA]; ! 72: ! 73: /* ! 74: * Determine mass storage and memory configuration for a machine. ! 75: * Get cpu type, and then switch out to machine specific procedures ! 76: * which will probe adaptors to see what is out there. ! 77: */ ! 78: configure() ! 79: { ! 80: union cpusid cpusid; ! 81: register struct percpu *ocp; ! 82: register int *ip; ! 83: extern char Sysbase[]; ! 84: ! 85: cpusid.cpusid = mfpr(SID); ! 86: for (ocp = percpu; ocp->pc_cputype; ocp++) ! 87: if (ocp->pc_cputype == cpusid.cpuany.cp_type) { ! 88: probenexus(ocp); ! 89: /* ! 90: * Write protect the scb and UNIBUS interrupt vectors. ! 91: * It is strange that this code is here, but this is ! 92: * as soon as we are done mucking with it, and the ! 93: * write-enable was done in assembly language ! 94: * to which we will never return. ! 95: */ ! 96: ip = (int *)Sysmap + 1; *ip &= ~PG_PROT; *ip |= PG_KR; ! 97: ip++; *ip &= ~PG_PROT; *ip |= PG_KR; ! 98: #if NUBA > 1 ! 99: ip++; *ip &= ~PG_PROT; *ip |= PG_KR; ! 100: #endif ! 101: mtpr(TBIS, Sysbase); ! 102: #if GENERIC ! 103: setconf(); ! 104: #endif ! 105: /* ! 106: * Configure swap area and related system ! 107: * parameter based on device(s) used. ! 108: */ ! 109: swapconf(); ! 110: cold = 0; ! 111: memenable(); ! 112: return; ! 113: } ! 114: printf("cpu type %d not configured\n", cpusid.cpuany.cp_type); ! 115: asm("halt"); ! 116: } ! 117: ! 118: /* ! 119: * Probe nexus space, finding the interconnects ! 120: * and setting up and probing mba's and uba's for devices. ! 121: */ ! 122: /*ARGSUSED*/ ! 123: probenexus(pcpu) ! 124: register struct percpu *pcpu; ! 125: { ! 126: register struct nexus *nxv; ! 127: struct nexus *nxp = pcpu->pc_nexbase; ! 128: union nexcsr nexcsr; ! 129: int i; ! 130: ! 131: nexnum = 0, nxv = nexus; ! 132: for (; nexnum < pcpu->pc_nnexus; nexnum++, nxp++, nxv++) { ! 133: nxaccess(nxp, Nexmap[nexnum]); ! 134: if (badaddr((caddr_t)nxv, 4)) ! 135: continue; ! 136: if (pcpu->pc_nextype && pcpu->pc_nextype[nexnum] != NEX_ANY) ! 137: nexcsr.nex_csr = pcpu->pc_nextype[nexnum]; ! 138: else ! 139: nexcsr = nxv->nexcsr; ! 140: if (nexcsr.nex_csr&NEX_APD) ! 141: continue; ! 142: switch (nexcsr.nex_type) { ! 143: ! 144: case NEX_MBA: ! 145: printf("mba%d at tr%d\n", nummba, nexnum); ! 146: if (nummba >= NMBA) { ! 147: printf("%d mba's", nummba); ! 148: goto unconfig; ! 149: } ! 150: #if NMBA > 0 ! 151: mbafind(nxv, nxp); ! 152: nummba++; ! 153: #endif ! 154: break; ! 155: ! 156: case NEX_UBA0: ! 157: case NEX_UBA1: ! 158: case NEX_UBA2: ! 159: case NEX_UBA3: ! 160: printf("uba%d at tr%d\n", numuba, nexnum); ! 161: if (numuba >= 4) { ! 162: printf("5 uba's"); ! 163: goto unsupp; ! 164: } ! 165: #if VAX780 ! 166: if (cpu == VAX_780) ! 167: setscbnex(ubaintv[numuba]); ! 168: #endif ! 169: i = nexcsr.nex_type - NEX_UBA0; ! 170: unifind((struct uba_regs *)nxv, (struct uba_regs *)nxp, ! 171: umem[i], pcpu->pc_umaddr[i], UMEMmap[i]); ! 172: #if VAX780 ! 173: if (cpu == VAX_780) ! 174: ((struct uba_regs *)nxv)->uba_cr = ! 175: UBACR_IFS|UBACR_BRIE| ! 176: UBACR_USEFIE|UBACR_SUEFIE| ! 177: (((struct uba_regs *)nxv)->uba_cr&0x7c000000); ! 178: #endif ! 179: numuba++; ! 180: break; ! 181: ! 182: case NEX_DR32: ! 183: /* there can be more than one... are there other codes??? */ ! 184: printf("dr32"); ! 185: goto unsupp; ! 186: ! 187: case NEX_MEM4: ! 188: case NEX_MEM4I: ! 189: case NEX_MEM16: ! 190: case NEX_MEM16I: ! 191: case NEX_MEM64L: ! 192: case NEX_MEM64LI: ! 193: case NEX_MEM64U: ! 194: case NEX_MEM64UI: ! 195: case NEX_MEM64I: ! 196: printf("mcr%d at tr%d\n", nmcr, nexnum); ! 197: if (nmcr >= 4) { ! 198: printf("5 mcr's"); ! 199: goto unsupp; ! 200: } ! 201: mcraddr[nmcr++] = (struct mcr *)nxv; ! 202: break; ! 203: ! 204: case NEX_MPM0: ! 205: case NEX_MPM1: ! 206: case NEX_MPM2: ! 207: case NEX_MPM3: ! 208: printf("mpm"); ! 209: goto unsupp; ! 210: ! 211: case NEX_CI: ! 212: printf("ci"); ! 213: goto unsupp; ! 214: ! 215: default: ! 216: printf("nexus type %x", nexcsr.nex_type); ! 217: unsupp: ! 218: printf(" unsupported (at tr %d)\n", nexnum); ! 219: continue; ! 220: unconfig: ! 221: printf(" not configured\n"); ! 222: continue; ! 223: } ! 224: } ! 225: } ! 226: ! 227: #if NMBA > 0 ! 228: struct mba_device *mbaconfig(); ! 229: /* ! 230: * Find devices attached to a particular mba ! 231: * and look for each device found in the massbus ! 232: * initialization tables. ! 233: */ ! 234: mbafind(nxv, nxp) ! 235: struct nexus *nxv, *nxp; ! 236: { ! 237: register struct mba_regs *mdp; ! 238: register struct mba_drv *mbd; ! 239: register struct mba_device *mi; ! 240: register struct mba_slave *ms; ! 241: int dn, dt, sn; ! 242: struct mba_device fnd; ! 243: ! 244: mdp = (struct mba_regs *)nxv; ! 245: mba_hd[nummba].mh_mba = mdp; ! 246: mba_hd[nummba].mh_physmba = (struct mba_regs *)nxp; ! 247: setscbnex(mbaintv[nummba]); ! 248: fnd.mi_mba = mdp; ! 249: fnd.mi_mbanum = nummba; ! 250: for (mbd = mdp->mba_drv, dn = 0; mbd < &mdp->mba_drv[8]; mbd++, dn++) { ! 251: if ((mbd->mbd_ds&MBDS_DPR) == 0) ! 252: continue; ! 253: mdp->mba_sr |= MBSR_NED; /* si kludge */ ! 254: dt = mbd->mbd_dt & 0xffff; ! 255: if (dt == 0) ! 256: continue; ! 257: if (mdp->mba_sr&MBSR_NED) ! 258: continue; /* si kludge */ ! 259: if (dt == MBDT_MOH) ! 260: continue; ! 261: fnd.mi_drive = dn; ! 262: #define qeq(a, b) ( a == b || a == '?' ) ! 263: if ((mi = mbaconfig(&fnd, dt)) && (dt & MBDT_TAP)) ! 264: for (sn = 0; sn < 8; sn++) { ! 265: mbd->mbd_tc = sn; ! 266: for (ms = mbsinit; ms->ms_driver; ms++) ! 267: if (ms->ms_driver == mi->mi_driver && ! 268: ms->ms_alive == 0 && ! 269: qeq(ms->ms_ctlr, mi->mi_unit) && ! 270: qeq(ms->ms_slave, sn) && ! 271: (*ms->ms_driver->md_slave)(mi, ms, sn)) { ! 272: printf("%s%d at %s%d slave %d\n" ! 273: , ms->ms_driver->md_sname ! 274: , ms->ms_unit ! 275: , mi->mi_driver->md_dname ! 276: , mi->mi_unit ! 277: , sn ! 278: ); ! 279: ms->ms_alive = 1; ! 280: ms->ms_ctlr = mi->mi_unit; ! 281: ms->ms_slave = sn; ! 282: } ! 283: } ! 284: } ! 285: mdp->mba_cr = MBCR_INIT; ! 286: mdp->mba_cr = MBCR_IE; ! 287: } ! 288: ! 289: /* ! 290: * Have found a massbus device; ! 291: * see if it is in the configuration table. ! 292: * If so, fill in its data. ! 293: */ ! 294: struct mba_device * ! 295: mbaconfig(ni, type) ! 296: register struct mba_device *ni; ! 297: register int type; ! 298: { ! 299: register struct mba_device *mi; ! 300: register short *tp; ! 301: register struct mba_hd *mh; ! 302: ! 303: for (mi = mbdinit; mi->mi_driver; mi++) { ! 304: if (mi->mi_alive) ! 305: continue; ! 306: tp = mi->mi_driver->md_type; ! 307: for (mi->mi_type = 0; *tp; tp++, mi->mi_type++) ! 308: if (*tp == (type&MBDT_TYPE)) ! 309: goto found; ! 310: continue; ! 311: found: ! 312: #define match(fld) (ni->fld == mi->fld || mi->fld == '?') ! 313: if (!match(mi_drive) || !match(mi_mbanum)) ! 314: continue; ! 315: printf("%s%d at mba%d drive %d\n", ! 316: mi->mi_driver->md_dname, mi->mi_unit, ! 317: ni->mi_mbanum, ni->mi_drive); ! 318: mi->mi_alive = 1; ! 319: mh = &mba_hd[ni->mi_mbanum]; ! 320: mi->mi_hd = mh; ! 321: mh->mh_mbip[ni->mi_drive] = mi; ! 322: mh->mh_ndrive++; ! 323: mi->mi_mba = ni->mi_mba; ! 324: mi->mi_drv = &mi->mi_mba->mba_drv[ni->mi_drive]; ! 325: mi->mi_mbanum = ni->mi_mbanum; ! 326: mi->mi_drive = ni->mi_drive; ! 327: /* ! 328: * If drive has never been seen before, ! 329: * give it a dkn for statistics. ! 330: */ ! 331: if (mi->mi_driver->md_info[mi->mi_unit] == 0) { ! 332: mi->mi_driver->md_info[mi->mi_unit] = mi; ! 333: if (mi->mi_dk && dkn < DK_NDRIVE) ! 334: mi->mi_dk = dkn++; ! 335: else ! 336: mi->mi_dk = -1; ! 337: } ! 338: (*mi->mi_driver->md_attach)(mi); ! 339: return (mi); ! 340: } ! 341: return (0); ! 342: } ! 343: #endif ! 344: ! 345: /* ! 346: * Fixctlrmask fixes the masks of the driver ctlr routines ! 347: * which otherwise save r10 and r11 where the interrupt and br ! 348: * level are passed through. ! 349: */ ! 350: fixctlrmask() ! 351: { ! 352: register struct uba_ctlr *um; ! 353: register struct uba_device *ui; ! 354: register struct uba_driver *ud; ! 355: #define phys(a,b) ((b)(((int)(a))&0x7fffffff)) ! 356: ! 357: for (um = ubminit; ud = phys(um->um_driver, struct uba_driver *); um++) ! 358: *phys(ud->ud_probe, short *) &= ~0xc00; ! 359: for (ui = ubdinit; ud = phys(ui->ui_driver, struct uba_driver *); ui++) ! 360: *phys(ud->ud_probe, short *) &= ~0xc00; ! 361: } ! 362: ! 363: /* ! 364: * Find devices on a UNIBUS. ! 365: * Uses per-driver routine to set <br,cvec> into <r11,r10>, ! 366: * and then fills in the tables, with help from a per-driver ! 367: * slave initialization routine. ! 368: */ ! 369: unifind(vubp, pubp, vumem, pumem, memmap) ! 370: struct uba_regs *vubp, *pubp; ! 371: caddr_t vumem, pumem; ! 372: struct pte *memmap; ! 373: { ! 374: #ifndef lint ! 375: register int br, cvec; /* MUST BE r11, r10 */ ! 376: #else ! 377: /* ! 378: * Lint doesn't realize that these ! 379: * can be initialized asynchronously ! 380: * when devices interrupt. ! 381: */ ! 382: register int br = 0, cvec = 0; ! 383: #endif ! 384: register struct uba_device *ui; ! 385: register struct uba_ctlr *um; ! 386: u_short *reg, *ap, addr; ! 387: struct uba_hd *uhp; ! 388: struct uba_driver *udp; ! 389: int i, (**ivec)(), haveubasr; ! 390: caddr_t ualloc, zmemall(); ! 391: extern int catcher[256]; ! 392: ! 393: /* ! 394: * Initialize the UNIBUS, by freeing the map ! 395: * registers and the buffered data path registers ! 396: */ ! 397: uhp = &uba_hd[numuba]; ! 398: uhp->uh_map = (struct map *)calloc(UAMSIZ * sizeof (struct map)); ! 399: ubainitmaps(uhp); ! 400: haveubasr = cpu == VAX_780; ! 401: ! 402: /* ! 403: * Save virtual and physical addresses ! 404: * of adaptor, and allocate and initialize ! 405: * the UNIBUS interrupt vector. ! 406: */ ! 407: uhp->uh_uba = vubp; ! 408: uhp->uh_physuba = pubp; ! 409: if (numuba == 0) ! 410: uhp->uh_vec = UNIvec; ! 411: #if NUBA > 1 ! 412: else if (numuba == 1) ! 413: uhp->uh_vec = UNI1vec; ! 414: else { ! 415: #if defined(VAX_750) ! 416: if (cpu == VAX_750) ! 417: printf("More than 2 UBA's not supported\n"); ! 418: else ! 419: #endif ! 420: uhp->uh_vec = (int(**)())calloc(512); ! 421: } ! 422: #endif ! 423: for (i = 0; i < 128; i++) ! 424: uhp->uh_vec[i] = ! 425: scbentry(&catcher[i*2], SCB_ISTACK); ! 426: /* ! 427: * Set last free interrupt vector for devices with ! 428: * programmable interrupt vectors. Use is to decrement ! 429: * this number and use result as interrupt vector. ! 430: */ ! 431: uhp->uh_lastiv = 0x200; ! 432: ! 433: ubaaccess(pumem, memmap); ! 434: #if VAX780 ! 435: if (haveubasr) { ! 436: vubp->uba_sr = vubp->uba_sr; ! 437: vubp->uba_cr = UBACR_IFS|UBACR_BRIE; ! 438: } ! 439: #endif ! 440: /* ! 441: * Grab some memory to record the umem address space we allocate, ! 442: * so we can be sure not to place two devices at the same address. ! 443: * ! 444: * We could use just 1/8 of this (we only want a 1 bit flag) but ! 445: * we are going to give it back anyway, and that would make the ! 446: * code here bigger (which we can't give back), so ... ! 447: * ! 448: * One day, someone will make a unibus with something other than ! 449: * an 8K i/o address space, & screw this totally. ! 450: */ ! 451: ualloc = zmemall(memall, 8*1024); ! 452: if (ualloc == (caddr_t)0) ! 453: panic("no mem for unifind"); ! 454: ! 455: /* ! 456: * Map the first page of UNIBUS i/o ! 457: * space to the first page of memory ! 458: * for devices which will need to dma ! 459: * output to produce an interrupt. ! 460: */ ! 461: *(int *)(&vubp->uba_map[0]) = UBAMR_MRV; ! 462: ! 463: #define ubaoff(off) ((off)&0x1fff) ! 464: #define ubaddr(off) (u_short *)((int)vumem + (ubaoff(off)|0x3e000)) ! 465: /* ! 466: * Check each unibus mass storage controller. ! 467: * For each one which is potentially on this uba, ! 468: * see if it is really there, and if it is record it and ! 469: * then go looking for slaves. ! 470: */ ! 471: for (um = ubminit; udp = um->um_driver; um++) { ! 472: if (um->um_ubanum != numuba && um->um_ubanum != '?') ! 473: continue; ! 474: addr = (u_short)um->um_addr; ! 475: /* ! 476: * use the particular address specified first, ! 477: * or if it is given as "0", of there is no device ! 478: * at that address, try all the standard addresses ! 479: * in the driver til we find it ! 480: */ ! 481: for (ap = udp->ud_addr; addr || (addr = *ap++); addr = 0) { ! 482: ! 483: if (ualloc[ubaoff(addr)]) ! 484: continue; ! 485: reg = ubaddr(addr); ! 486: if (badaddr((caddr_t)reg, 2)) ! 487: continue; ! 488: #if VAX780 ! 489: if (haveubasr && vubp->uba_sr) { ! 490: vubp->uba_sr = vubp->uba_sr; ! 491: continue; ! 492: } ! 493: #endif ! 494: cvec = 0x200; ! 495: i = (*udp->ud_probe)(reg, um->um_ctlr); ! 496: #if VAX780 ! 497: if (haveubasr && vubp->uba_sr) { ! 498: vubp->uba_sr = vubp->uba_sr; ! 499: continue; ! 500: } ! 501: #endif ! 502: if (i == 0) ! 503: continue; ! 504: printf("%s%d at uba%d csr %o ", ! 505: udp->ud_mname, um->um_ctlr, numuba, addr); ! 506: if (cvec == 0) { ! 507: printf("zero vector\n"); ! 508: continue; ! 509: } ! 510: if (cvec == 0x200) { ! 511: printf("didn't interrupt\n"); ! 512: continue; ! 513: } ! 514: printf("vec %o, ipl %x\n", cvec, br); ! 515: um->um_alive = 1; ! 516: um->um_ubanum = numuba; ! 517: um->um_hd = &uba_hd[numuba]; ! 518: um->um_addr = (caddr_t)reg; ! 519: udp->ud_minfo[um->um_ctlr] = um; ! 520: for (ivec = um->um_intr; *ivec; ivec++) { ! 521: um->um_hd->uh_vec[cvec/4] = ! 522: scbentry(*ivec, SCB_ISTACK); ! 523: cvec += 4; ! 524: } ! 525: for (ui = ubdinit; ui->ui_driver; ui++) { ! 526: if (ui->ui_driver != udp || ui->ui_alive || ! 527: ui->ui_ctlr != um->um_ctlr && ui->ui_ctlr != '?' || ! 528: ui->ui_ubanum != numuba && ui->ui_ubanum != '?') ! 529: continue; ! 530: if ((*udp->ud_slave)(ui, reg)) { ! 531: ui->ui_alive = 1; ! 532: ui->ui_ctlr = um->um_ctlr; ! 533: ui->ui_ubanum = numuba; ! 534: ui->ui_hd = &uba_hd[numuba]; ! 535: ui->ui_addr = (caddr_t)reg; ! 536: ui->ui_physaddr = pumem + ubdevreg(addr); ! 537: if (ui->ui_dk && dkn < DK_NDRIVE) ! 538: ui->ui_dk = dkn++; ! 539: else ! 540: ui->ui_dk = -1; ! 541: ui->ui_mi = um; ! 542: /* ui_type comes from driver */ ! 543: udp->ud_dinfo[ui->ui_unit] = ui; ! 544: printf("%s%d at %s%d slave %d\n", ! 545: udp->ud_dname, ui->ui_unit, ! 546: udp->ud_mname, um->um_ctlr, ui->ui_slave); ! 547: (*udp->ud_attach)(ui); ! 548: } ! 549: } ! 550: break; ! 551: } ! 552: } ! 553: /* ! 554: * Now look for non-mass storage peripherals. ! 555: */ ! 556: for (ui = ubdinit; udp = ui->ui_driver; ui++) { ! 557: if (ui->ui_ubanum != numuba && ui->ui_ubanum != '?' || ! 558: ui->ui_alive || ui->ui_slave != -1) ! 559: continue; ! 560: addr = (u_short)ui->ui_addr; ! 561: ! 562: for (ap = udp->ud_addr; addr || (addr = *ap++); addr = 0) { ! 563: ! 564: if (ualloc[ubaoff(addr)]) ! 565: continue; ! 566: reg = ubaddr(addr); ! 567: if (badaddr((caddr_t)reg, 2)) ! 568: continue; ! 569: #if VAX780 ! 570: if (haveubasr && vubp->uba_sr) { ! 571: vubp->uba_sr = vubp->uba_sr; ! 572: continue; ! 573: } ! 574: #endif ! 575: cvec = 0x200; ! 576: i = (*udp->ud_probe)(reg); ! 577: #if VAX780 ! 578: if (haveubasr && vubp->uba_sr) { ! 579: vubp->uba_sr = vubp->uba_sr; ! 580: continue; ! 581: } ! 582: #endif ! 583: if (i == 0) ! 584: continue; ! 585: printf("%s%d at uba%d csr %o ", ! 586: ui->ui_driver->ud_dname, ui->ui_unit, numuba, addr); ! 587: if (cvec == 0) { ! 588: printf("zero vector\n"); ! 589: continue; ! 590: } ! 591: if (cvec == 0x200) { ! 592: printf("didn't interrupt\n"); ! 593: continue; ! 594: } ! 595: printf("vec %o, ipl %x\n", cvec, br); ! 596: while (--i >= 0) ! 597: ualloc[ubaoff(addr+i)] = 1; ! 598: ui->ui_hd = &uba_hd[numuba]; ! 599: for (ivec = ui->ui_intr; *ivec; ivec++) { ! 600: ui->ui_hd->uh_vec[cvec/4] = ! 601: scbentry(*ivec, SCB_ISTACK); ! 602: cvec += 4; ! 603: } ! 604: ui->ui_alive = 1; ! 605: ui->ui_ubanum = numuba; ! 606: ui->ui_addr = (caddr_t)reg; ! 607: ui->ui_physaddr = pumem + ubdevreg(addr); ! 608: ui->ui_dk = -1; ! 609: /* ui_type comes from driver */ ! 610: udp->ud_dinfo[ui->ui_unit] = ui; ! 611: (*udp->ud_attach)(ui); ! 612: break; ! 613: } ! 614: } ! 615: ! 616: #ifdef AUTO_DEBUG ! 617: printf("Unibus allocation map"); ! 618: for (i = 0; i < 8*1024; ) { ! 619: register n, m; ! 620: ! 621: if ((i % 128) == 0) { ! 622: printf("\n%6o:", i); ! 623: for (n = 0; n < 128; n++) ! 624: if (ualloc[i+n]) ! 625: break; ! 626: if (n == 128) { ! 627: i += 128; ! 628: continue; ! 629: } ! 630: } ! 631: ! 632: for (n = m = 0; n < 16; n++) { ! 633: m <<= 1; ! 634: m |= ualloc[i++]; ! 635: } ! 636: ! 637: printf(" %4x", m); ! 638: } ! 639: printf("\n"); ! 640: #endif ! 641: ! 642: wmemfree(ualloc, 8*1024); ! 643: } ! 644: ! 645: setscbnex(fn) ! 646: int (*fn)(); ! 647: { ! 648: register struct scb *scbp = &scb; ! 649: ! 650: scbp->scb_ipl14[nexnum] = scbp->scb_ipl15[nexnum] = ! 651: scbp->scb_ipl16[nexnum] = scbp->scb_ipl17[nexnum] = ! 652: scbentry(fn, SCB_ISTACK); ! 653: } ! 654: ! 655: /* ! 656: * Make a nexus accessible at physical address phys ! 657: * by mapping kernel ptes starting at pte. ! 658: * ! 659: * WE LEAVE ALL NEXI MAPPED; THIS IS PERHAPS UNWISE ! 660: * SINCE MISSING NEXI DONT RESPOND. BUT THEN AGAIN ! 661: * PRESENT NEXI DONT RESPOND TO ALL OF THEIR ADDRESS SPACE. ! 662: */ ! 663: nxaccess(physa, pte) ! 664: struct nexus *physa; ! 665: register struct pte *pte; ! 666: { ! 667: register int i = btop(sizeof (struct nexus)); ! 668: register unsigned v = btop(physa); ! 669: ! 670: do ! 671: *(int *)pte++ = PG_V|PG_KW|v++; ! 672: while (--i > 0); ! 673: mtpr(TBIA, 0); ! 674: } ! 675: ! 676: ubaaccess(pumem, pte) ! 677: caddr_t pumem; ! 678: register struct pte *pte; ! 679: { ! 680: register int i = 512; ! 681: register unsigned v = btop(pumem); ! 682: ! 683: do ! 684: *(int *)pte++ = PG_V|PG_KW|v++; ! 685: while (--i > 0); ! 686: mtpr(TBIA, 0); ! 687: } ! 688: ! 689: #define DMMIN 32 ! 690: #define DMMAX 1024 ! 691: #define DMTEXT 1024 ! 692: #define MAXDUMP (10*2048) ! 693: /* ! 694: * Configure swap space and related parameters. ! 695: */ ! 696: swapconf() ! 697: { ! 698: register struct swdevt *swp; ! 699: register int nblks; ! 700: ! 701: for (swp = swdevt; swp->sw_dev; swp++) { ! 702: if (bdevsw[major(swp->sw_dev)].d_psize) ! 703: nblks = ! 704: (*bdevsw[major(swp->sw_dev)].d_psize)(swp->sw_dev); ! 705: if (swp->sw_nblks == 0 || swp->sw_nblks > nblks) ! 706: swp->sw_nblks = nblks; ! 707: } ! 708: if (!cold) /* in case called for mba device */ ! 709: return; ! 710: if (dumplo == 0) ! 711: dumplo = swdevt[0].sw_nblks - MAXDUMP; ! 712: if (dumplo < 0) ! 713: dumplo = 0; ! 714: if (dmmin == 0) ! 715: dmmin = DMMIN; ! 716: if (dmmax == 0) ! 717: dmmax = DMMAX; ! 718: if (dmtext == 0) ! 719: dmtext = DMTEXT; ! 720: if (dmtext > dmmax) ! 721: dmtext = dmmax; ! 722: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.