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