![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nexdev.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / mkconf|
Return to nexdev.c CVS log | Up to [Research Unix] / researchv10no / sys / mkconf |
1.1 root 1: /*
2: * nexus device routines;
3: * both sbi and vaxbi nexus
4: */
5:
6: #include "mkconf.h"
7:
8: /*
9: * addressing fields
10: */
11:
12: static char *sbifields[] = {
13: "bus", "tr", "voff", NULL
14: };
15:
16: #define a_adp addr[0] /* adapter: which sbi, which vaxbi */
17: #define a_tr addr[1] /* nexus number within that adapter */
18: #define a_svoff addr[2] /* sbi devices (like unibus adapter): vector offset */
19:
20: static char *vbifields[] = {
21: "bi", "node", "vec", "voff", NULL
22: };
23:
24: #define a_bvec addr[2] /* vaxbi: vector */
25: #define a_bvoff addr[3] /* vaxbi adapter devices (like dw): vector offset */
26:
27: #define VFMT "X%s%d%d" /* name of vector interface routine */
28:
29: #define MAXNEX 20 /* this many nexus, not highest hardware tr */
30:
31: struct nextab {
32: char adp;
33: char nex;
34: } nextab[MAXNEX];
35:
36: int nextnex;
37:
38: sbisyntax(dp, ap, n)
39: register Dev *dp;
40: char **ap;
41: int n;
42: {
43: char *p;
44:
45: dp->a_svoff = 0;
46: if ((p = keyread(dp->addr, ap, n, sbifields)) != NULL) {
47: fprint(STDERR, "%s %d: bad field %s\n", dp->mdev->name, dp->id, p);
48: errs++;
49: return (1);
50: }
51: dp->vecoff = dp->a_svoff;
52: return (0);
53: }
54:
55: vbisyntax(dp, ap, n)
56: register Dev *dp;
57: char **ap;
58: int n;
59: {
60: char *p;
61:
62: dp->a_bvoff = 0;
63: if ((p = keyread(dp->addr, ap, n, vbifields)) != NULL) {
64: fprint(STDERR, "%s %d: bad field %s\n", dp->mdev->name, dp->id, p);
65: errs++;
66: return (1);
67: }
68: dp->vecoff = dp->a_bvoff;
69: return (0);
70: }
71:
72: /*
73: * fixup routine:
74: * compute and insert our (fixed) interrupt vectors
75: * insert our entry in the table of nexus
76: * and replace our `nexus' address with the appropriate index
77: */
78: int
79: sbifixup(dp)
80: register Dev *dp;
81: {
82: register int vec;
83: register int i;
84: register Mdev *mp;
85: char vname[20];
86:
87: nexparent(dp);
88: mp = dp->mdev;
89: if (mp->nvec) {
90: vec = dp->a_tr*4; /* honest nexus number, mod 16 */
91: vec += 0x100; /* -> br4 vector */
92: if (dp->parent)
93: vec += dp->parent->vecoff;
94: sprint(vname, VFMT, mp->tag, dp->id, 0);
95: for (i = 0; i < 4; i++) {
96: newvec(vec, SINTR, vname);
97: vec += 0x40;
98: }
99: }
100: newnex(dp);
101: }
102:
103: int
104: vbifixup(dp)
105: register Dev *dp;
106: {
107: register int vec;
108: register Mdev *mp;
109: register int i;
110: char vname[20];
111:
112: nexparent(dp);
113: mp = dp->mdev;
114: vec = dp->a_bvec;
115: if (dp->parent) /* && vec > 0x200? */
116: vec += dp->parent->vecoff;
117: for (i = 0; i < mp->nvec; i++, vec += 4) {
118: sprint(vname, VFMT, mp->tag, dp->id, i);
119: newvec(vec, SINTR, vname);
120: }
121: newnex(dp);
122: }
123:
124: newnex(dp)
125: register Dev *dp;
126: {
127: if (nextnex >= MAXNEX) {
128: fprint(STDERR, "%s %d: too many nexus\n", dp->mdev->name, dp->id);
129: errs++;
130: return;
131: }
132: nextab[nextnex].adp = dp->a_adp;
133: nextab[nextnex].nex = dp->a_tr;
134: dp->addr[1] = nextnex;
135: nextnex++;
136: }
137:
138: nexparent(dp)
139: register Dev *dp;
140: {
141: register Dev *ep;
142:
143: for (ep = dlist; ep; ep = ep->next)
144: if (ep->mdev->adptype == dp->mdev->atype
145: && ep->id == dp->a_adp)
146: break;
147: dp->parent = ep;
148: }
149:
150: sbiputaddr(fd, dp)
151: int fd;
152: register Dev *dp;
153: {
154: register int count;
155: register Mdev *mp;
156:
157: nexputtab(fd);
158: mp = dp->mdev;
159: count = 0;
160: fprint(fd, "struct nxaddr %saddr[] = {\n", mp->tag);
161: for (mp = dp->mdev; dp && dp->mdev == mp; dp = dp->next) {
162: while (count++ < dp->id)
163: fprint(fd, "\t{-1, 0},\n");
164: fprint(fd, "\t{%ld, %ld, 0x%lx},\n", dp->a_tr, dp->a_adp, dp->a_svoff);
165: }
166: count *= mp->rept;
167: fprint(fd, "};\nint %scnt = %d;\n", mp->tag, count);
168: putstrs(fd, mp, count);
169: }
170:
171: vbiputaddr(fd, dp)
172: int fd;
173: register Dev *dp;
174: {
175: register int count;
176: register Mdev *mp;
177:
178: nexputtab(fd);
179: mp = dp->mdev;
180: count = 0;
181: fprint(fd, "struct biaddr %saddr[] = {\n", mp->tag);
182: for (mp = dp->mdev; dp && dp->mdev == mp; dp = dp->next) {
183: while (count++ < dp->id)
184: fprint(fd, "\t{-1},\n");
185: fprint(fd, "\t{%ld, 0x%lx, 0x%lx, %ld},\n",
186: dp->a_tr, dp->a_bvec, dp->a_bvoff, dp->a_adp);
187: }
188: count *= mp->rept;
189: fprint(fd, "};\nint %scnt = %d;\n", mp->tag, count);
190: putstrs(fd, mp, count);
191: }
192:
193: /*
194: * put out nexus tables
195: */
196:
197: nexputtab(fd)
198: int fd;
199: {
200: register int i;
201: static int done = 0;
202:
203: if (done++)
204: return;
205: fprint(fd, "\nstruct nextab nextab[] = {\n");
206: for (i = 0; i < nextnex; i++)
207: fprint(fd, "\t%d, %d,\n", nextab[i].adp, nextab[i].nex);
208: fprint(fd, "\t-1\n};\n");
209: }
210:
211: /*
212: * put out vectors
213: */
214:
215: nexputvec(fd, dp)
216: int fd;
217: register Dev *dp;
218: {
219: register int i;
220: char vname[30];
221:
222: for (i = 0; i < dp->mdev->nvec; i++) {
223: sprint(vname, VFMT, dp->mdev->tag, dp->id, i);
224: stdputvec(fd, dp, vname, i);
225: }
226: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.