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