![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mba.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / sys / md|
Return to mba.c CVS log | Up to [Research Unix] / researchv10dc / sys / md |
1.1 root 1: /*
2: * massbus adapter subroutines
3: * this version for comet
4: */
5:
6: #include "sys/param.h"
7: #include "sys/nxaddr.h"
8: #include "sys/mbaddr.h"
9: #include "sys/mba.h"
10: #include "sys/pte.h"
11: #include "sys/buf.h"
12:
13: /*
14: * hardware things
15: */
16:
17: #define NMAP 256
18:
19: struct mbaregs {
20: long conf; /* configuration register; unused */
21: long cr; /* control register */
22: long sr; /* status register */
23: long va; /* address */
24: long bcr; /* count */
25: long _junk0[251]; /* pad up to 0x400 */
26: long devreg[MBAUNITS][32];
27: long map[NMAP];
28: };
29:
30: #define mbas devreg[0][4] /* attn summary reg; same in all devs */
31:
32: #define CRINIT 01 /* cr -- adapter init */
33: #define CRIE 04 /* cr -- interrupt enable */
34:
35: #define MRV 0x80000000 /* map register -- valid bit */
36: #define MPAGE 0x001fffff /* map register -- page number */
37: /* really only 15 bits on comet; others seem to read 0 */
38:
39: /*
40: * things from mkconf
41: */
42:
43: extern int mbacnt;
44: extern struct mba mba[];
45: extern struct nxaddr mbaaddr[];
46: extern int (*mbavec[][MBAUNITS])();
47: extern char mbaid[][MBAUNITS];
48:
49: #define BUSY 01 /* this mba already transferring */
50: #define INIT 02 /* did init */
51:
52: #define NOUNIT (-1) /* in mbq */
53:
54: caddr_t
55: mbaddr(ap)
56: register struct mbaddr *ap;
57: {
58: register struct mba *mp;
59:
60: if (ap->mbno < 0 || ap->mbno >= mbacnt)
61: return (0);
62: if (ap->unit < 0 || ap->unit >= MBAUNITS)
63: return (0);
64: mp = &mba[ap->mbno];
65: if ((mp->flags & INIT) == 0
66: && mbinit(ap->mbno) == 0)
67: return (0);
68: return ((caddr_t)mp->addr->devreg[ap->unit]);
69: }
70:
71: mbinit(dev)
72: int dev;
73: {
74: register struct mba *mp;
75:
76: mp = &mba[dev];
77: if ((mp->addr = (struct mbaregs *)nxaddr(&mbaaddr[dev])) == NULL
78: || badaddr(&mp->addr->conf, sizeof(long))) {
79: printf("mba%d absent\n");
80: return (0);
81: }
82: mp->addr->cr = CRINIT;
83: mp->addr->cr = CRIE;
84: mp->first = NOUNIT;
85: mp->flags |= INIT;
86: return (1);
87: }
88:
89: /*
90: * enqueue a transfer for this unit;
91: * if not busy, start
92: * if there's already a transfer for this unit, something is wrong
93: */
94: mbstart(ap, bp, go)
95: register struct mbaddr *ap;
96: register struct buf *bp;
97: int (*go)();
98: {
99: register struct mba *mp;
100: register int i;
101:
102: mp = &mba[ap->mbno];
103: i = ap->unit;
104: if (mp->mbuf[i])
105: panic("mbstart");
106: if (mp->first == NOUNIT)
107: mp->first = i;
108: else
109: mp->mbq[mp->last] = i;
110: mp->last = i;
111: mp->mbq[i] = NOUNIT;
112: mp->mbuf[i] = bp;
113: mp->xstart[i] = go;
114: if ((mp->flags & BUSY) == 0)
115: mbxfer(mp);
116: }
117:
118: /*
119: * really start a transfer
120: * mp->lastoff is saved only for mbadj
121: */
122:
123: mbxfer(mp)
124: register struct mba *mp;
125: {
126: register struct mbaregs *reg;
127: register struct pte *p;
128: register long *map;
129: register long size;
130: register struct buf *bp;
131:
132: if (mp->first == NOUNIT)
133: return;
134: reg = mp->addr;
135: bp = mp->mbuf[mp->first];
136: mp->lastoff = (long)bp->b_un.b_addr & PGOFSET;
137: size = btoc(bp->b_bcount);
138: if (mp->lastoff)
139: size++;
140: if (size >= NMAP)
141: size = NMAP-1; /* tough */
142: p = btopte(bp);
143: map = reg->map;
144: while (--size >= 0)
145: *map++ = p++->pg_pfnum | MRV;
146: *map = 0; /* safety */
147: reg->bcr = -bp->b_bcount;
148: reg->va = mp->lastoff;
149: mp->flags |= BUSY;
150: (*mp->xstart[mp->first])(bp);
151: }
152:
153: /*
154: * cheats needed for ECC correction
155: * must be called from interrupt code,
156: * before we've started another transfer
157: */
158:
159: long
160: mbcuraddr(ap)
161: struct mbaddr *ap;
162: {
163: return (mba[ap->mbno].addr->va);
164: }
165:
166: /*
167: * adjust registers to redo current transfer
168: * somewhere in the middle, but not where we were
169: * new buffer address is original+aoff;
170: * new count is as given
171: */
172:
173: mbadj(ap, aoff, count)
174: struct mbaddr *ap;
175: int aoff, count;
176: {
177: register struct mba *mp;
178: register struct mbaregs *reg;
179:
180: mp = &mba[ap->mbno];
181: reg = mp->addr;
182: reg->bcr = -count;
183: reg->va = aoff + mp->lastoff;
184: }
185:
186: /*
187: * xfer was restarted
188: * just mark adapter busy again, and delicately re-insert us in the queue
189: * -- we know we were at the head before
190: */
191:
192: mbcontin(ap)
193: register struct mbaddr *ap;
194: {
195: register struct mba *mp;
196:
197: mp = &mba[ap->mbno];
198: mp->flags |= BUSY;
199: mp->mbq[ap->unit] = mp->first;
200: mp->first = ap->unit;
201: }
202:
203: /*
204: * get, put a byte in MASSBUS space
205: */
206:
207: static long
208: mbphys(ap, addr)
209: struct mbaddr *ap;
210: long addr;
211: {
212: register long m;
213: register int pg;
214: register struct mba *mp;
215:
216: mp = &mba[ap->mbno];
217: if (mp->addr == 0)
218: panic("mbphys");
219: pg = addr / NBPG;
220: if (pg >= NMAP)
221: return (-1);
222: m = mp->addr->map[pg];
223: if ((m & MRV) == 0)
224: return (-1);
225: return ((m & MPAGE) * NBPG + addr % NBPG);
226: }
227:
228: mbgetc(ap, addr)
229: struct mbaddr *ap;
230: long addr;
231: {
232: register long phys;
233:
234: phys = mbphys(ap, addr);
235: if (phys < 0)
236: return (-1);
237: return (phgetc(phys));
238: }
239:
240: int
241: mbputc(ap, addr, c)
242: struct mbaddr *ap;
243: long addr;
244: char c;
245: {
246: register long phys;
247:
248: phys = mbphys(ap, addr);
249: if (phys < 0)
250: return (-1);
251: return (phputc(phys, c));
252: }
253:
254: /*
255: * massbus interrupt
256: * if a transfer in progress, call the driver
257: * if attn, call drivers for that too
258: * it is up to the driver to clear attn
259: * (but for convenience, we promise to tell them what bit to clear)
260: */
261:
262: mba0int(dev)
263: register int dev;
264: {
265: register struct mba *mp;
266: register struct mbaregs *reg;
267: register long sr;
268: register int as, i;
269:
270: if (dev < 0 || dev > mbacnt
271: || (mp = &mba[dev], (mp->flags & INIT)) == 0) {
272: mbshutup(dev);
273: return;
274: }
275: reg = mp->addr;
276: sr = reg->sr;
277: reg->sr = sr; /* clear attn and error latches */
278: as = reg->mbas&0377;
279: if (mp->flags & BUSY) {
280: i = mp->first;
281: mp->mbuf[i] = NULL;
282: mp->first = mp->mbq[i];
283: mp->flags &=~ BUSY;
284: (*mbavec[dev][i])(mbaid[dev][i], sr, (-reg->bcr)&0xffff, as & (1<<i));
285: as &=~ (1<<i);
286: }
287: for (i = 0; as; i++, as >>= 1)
288: if (as & 01)
289: (*mbavec[dev][i])(mbaid[dev][i], 0, 0, 1<<i);
290: if ((mp->flags & BUSY) == 0)
291: mbxfer(mp);
292: }
293:
294: /*
295: * mbavec for non-existent drives points here
296: */
297:
298: mbastray(dev)
299: int dev;
300: {
301: printf("mba%d drive %d stray attn\n", dev>>3, dev&07);
302: }
303:
304: /*
305: * here if didn't expect mba interrupt
306: * might just be a leftover ATTN from a previous boot;
307: * not necessarily cleared
308: */
309:
310: mbshutup(dev)
311: int dev;
312: {
313: register struct mbaregs *reg;
314:
315: if (dev < 0 || dev >= mbacnt
316: || (reg = (struct mbaregs *)nxaddr(&mbaaddr[dev])) == NULL
317: || badaddr(®->conf, sizeof(long))) {
318: printf("mb%d: unacceptable interrupt\n", dev);
319: return; /* and probably get stuck forever */
320: }
321: reg->cr = CRINIT; /* quiet, please */
322: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.