![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lsys / io|
Return to dk.c CVS log | Up to [Research Unix] / researchv10dc / lsys / io |
1.1 root 1: /*
2: * Datakit driver
3: */
4: #include "sys/param.h"
5: #include "sys/systm.h"
6: #include "sys/stream.h"
7: #include "sys/dkio.h"
8: #include "sys/ubaddr.h"
9: #include "sys/conf.h"
10: #include "sys/dk.h"
11: #include "sys/dkstat.h"
12: #include "sys/dkmod.h"
13:
14: #define SAFETY 1 /* turn off doubtful speed hack */
15:
16: struct device {
17: unsigned short csr;
18: unsigned short dko;
19: unsigned short dki;
20: };
21:
22: struct device *DKADDR; /* assume one addr for now */
23:
24: extern struct dk dk[];
25: extern int dkcnt;
26: extern char dkstate[];
27:
28: #define DKXCL 01
29:
30: int dkalive;
31: struct dkstat dkstat;
32: extern struct dkmodule dkmod[];
33: struct dkmodule *dkmodp;
34:
35: /*
36: * Hardware control bits
37: */
38: #define DKTENAB 0100
39: #define DKRENAB 040
40: #define ENABS (DKRENAB)
41: #define DKTDONE 0200
42: #define DKRDONE 0100000
43: #define D_OSEQ 0
44: #define D_READ 01
45: #define D_WRITE 02
46: #define D_XPACK 03
47: #define DKMARK 01000
48: #define DKDATA 0400
49: #define DKPARITY 0100000
50:
51: #define DKOPKT 16 /* biggest output packet */
52: #define DKIPKT 16 /* biggest input packet */
53: #define DKISML 16 /* smallest interesting allocation */
54: #define DKITHRES 200
55:
56: int dkclose(), dkput();
57: long dkopen();
58:
59: static struct qinit dkrinit = { noput, NULL, dkopen, dkclose, 0, 0 };
60: struct qinit dkwinit = { dkput, NULL, dkopen, dkclose, 0, 0 };
61: struct streamtab dkinfo = { &dkrinit, &dkwinit };
62: struct cdevsw dkcdev = cstrinit(&dkinfo);
63: extern struct ubaddr dkaddr[];
64:
65: /*
66: * open DK channel
67: */
68: long
69: dkopen(q, dev)
70: register struct queue *q;
71: register dev_t dev;
72: {
73: register struct dk *dkp;
74: static opened, badtime;
75: register chan;
76:
77: chan = minor(dev);
78: if (chan<=0 || chan>=dkcnt)
79: return(0);
80: if (!opened) {
81: register i;
82:
83: if ((DKADDR = (struct device *)ubaddr(&dkaddr[0])) == NULL
84: || badaddr(DKADDR, 2)) {
85: printf("dk0 absent\n");
86: return (0);
87: }
88: DKADDR->csr = D_OSEQ;
89: DKADDR->dko = 0; /* Clear fifo's */
90: i = 256; /* sanity count */
91: DELAY(1000); /* wait for board to reset */
92: do {
93: if (DKADDR->csr & DKTDONE) {
94: dkalive = 0;
95: if (time > badtime + 300) {
96: badtime = time;
97: printf("DK interface bad\n");
98: }
99: return(0);
100: }
101: } while (--i);
102: if ((dkmodp = dkmodall(dev, 0, dkcnt)) == NULL)
103: return (0);
104: dkmodp->dkstate = dkstate;
105: dkalive = 1;
106: for (dkp = dk, i = 0; i < dkcnt; dkp++, i++)
107: dkp->chan = i;
108: DKADDR->csr = ENABS;
109: opened++;
110: dkrecover(chan);
111: }
112: dkp = &dk[chan];
113: if (dkstate[chan] != DKCLOSED) { /* already open */
114: if (dkp->flag & DKXCL)
115: return(0);
116: if (dkstate[chan] != DKOPEN)
117: return(0); /* closing channels can't reopen */
118: return(1);
119: }
120: dkp->dkrq = q;
121: q->ptr = (caddr_t)dkp;
122: WR(q)->ptr = (caddr_t)dkp;
123: dkp->flag = DKXCL;
124: dkp->icnt = 0;
125: dkp->isize = 0;
126: dkp->ibuf = 0;
127: dkp->ialloc = DKISML;
128: dkstate[chan] = DKOPEN;
129: return(1);
130: }
131:
132: /*
133: * Timer to recover from lost interrupt condition.
134: */
135: dkrecover(dev)
136: dev_t dev;
137: {
138: register int ps = spl5();
139:
140: if (DKADDR->csr & DKRDONE)
141: dk1int(dev);
142: splx(ps);
143:
144: timeout(dkrecover, (caddr_t)dev, HZ/2);
145: }
146:
147: /*
148: * close DK channel
149: */
150: dkclose(q)
151: register struct queue *q;
152: {
153: register struct dk *dkp;
154: register struct block *bp;
155:
156: dkp = (struct dk *)q->ptr;
157: dkp->dkrq = NULL;
158: dkp->flag = 0;
159: if (dkstate[dkp->chan] == DKRCLOSE || dkmodp->listnrq==NULL)
160: dkstate[dkp->chan] = DKCLOSED;
161: else if (dkstate[dkp->chan] == DKOPEN)
162: dkstate[dkp->chan] = DKLCLOSE;
163: if (dkmodp->listnrq)
164: putctl2(RD(dkmodp->listnrq), M_PRICTL, DKMCLOSE, dkp->chan);
165: if (dkp->ibuf)
166: freeb(dkp->ibuf);
167: while ((bp = dkp->ofirst) != NULL) {
168: dkp->ofirst = bp->next;
169: freeb(bp);
170: }
171: dkp->ibuf = 0;
172: }
173:
174: /*
175: * DK receiver interrupt.
176: */
177:
178: #define PUTIN(bp, q) {\
179: dkstat.input += (bp)->wptr - (bp)->rptr;\
180: if (((q)->next->flag & QFULL) == 0)\
181: (*(q)->next->qinfo->putp)(q->next, bp);\
182: else\
183: freeb(bp);\
184: }
185:
186: #define DKSIZUP(dkp) {\
187: if (dkp->isize > DKITHRES) {\
188: dkp->ialloc = dkp->isize;\
189: dkp->icnt = 3;\
190: } else if (--dkp->icnt <= 0) {\
191: dkp->icnt = 0;\
192: dkp->ialloc = DKISML;\
193: }\
194: dkp->isize = 0;\
195: }
196:
197: dk1int(dev)
198: {
199: register struct queue *q;
200: register struct block *bp;
201: register struct dk *dkp;
202: register struct device *reg;
203: register c, nbytes;
204: register sane, chan;
205: register struct block **bpp;
206: struct block *blist[DKIPKT+2];
207:
208: if ((reg = DKADDR) == NULL)
209: return;
210: c = 0;
211: dkp = NULL;
212: while (reg->csr & DKRDONE) {
213: reg->csr = D_READ|ENABS;
214: if ((c & DKMARK) == 0) {
215: /* Search for channel number */
216: sane = 256;
217: do {
218: c = reg->dki;
219: if (c & DKMARK || --sane==0)
220: break;
221: } while (reg->csr & DKRDONE);
222: }
223: if ((c & DKMARK) == 0) {
224: dkstat.markflt++;
225: continue;
226: }
227: if ((c & DKPARITY) == 0) {
228: dkstat.markparity++;
229: c = 0;
230: continue;
231: }
232: /* check channel */
233: chan = c & 0777;
234: if (dkp && dkp->chan != chan) {
235: if ((bp = dkp->ibuf) != NULL)
236: PUTIN(bp, q);
237: DKSIZUP(dkp);
238: dkp->ibuf = NULL;
239: }
240: if (chan == 0 || chan >= dkcnt || (q = dk[chan].dkrq)==NULL) {
241: if (chan>0 && chan<dkcnt) {
242: if (dkmodp->listnrq)
243: putctl2(RD(dkmodp->listnrq),
244: M_PRICTL, DKMCLOSE, chan);
245: dkstat.closepack++;
246: } else if (chan == 0)
247: dkstat.pack0++;
248: else
249: dkstat.packstrange++;
250: for (nbytes=0; nbytes<DKIPKT; nbytes++) {
251: c = reg->dki;
252: if (c & DKMARK)
253: break;
254: }
255: continue;
256: }
257: dkp = (struct dk *)q->ptr;
258: if ((bp = dkp->ibuf) == NULL
259: && (bp = allocb(dkp->ialloc)) == NULL)
260: return;
261: bpp = blist;
262: for (nbytes=0; nbytes<DKIPKT; nbytes++) {
263: #ifdef SAFETY
264: if ((reg->csr&DKRDONE) == 0)
265: break;
266: #endif
267: c = reg->dki;
268: if ((c&(DKPARITY|DKMARK|DKDATA)) == (DKPARITY|DKDATA)) {
269: if (bp->wptr >= bp->lim) {
270: *bpp++ = bp;
271: if ((bp = allocb(DKISML)) == NULL)
272: break;
273: }
274: *bp->wptr++ = c;
275: dkp->isize++;
276: continue;
277: }
278: /*
279: * control or error
280: */
281: if (c & DKMARK) {
282: dkstat.shortpack++;
283: break;
284: }
285: if ((c & DKPARITY) == 0) {
286: dkstat.parity++;
287: break;
288: }
289: if ((c & 0377) == 0) /* control-null */
290: continue;
291: if (bp->wptr > bp->rptr) {
292: *bpp++ = bp;
293: if ((bp = allocb(DKISML)) == NULL)
294: break;
295: }
296: bp->type = M_CTL;
297: *bp->wptr++ = c;
298: }
299: if (bpp == blist && bp->type == M_DATA) {
300: dkp->ibuf = bp;
301: continue;
302: }
303: *bpp++ = bp;
304: *bpp = NULL;
305: bpp = blist;
306: while ((bp = *bpp++) != NULL)
307: PUTIN(bp, q);
308: DKSIZUP(dkp);
309: dkp->ibuf = NULL;
310: }
311: if (dkp && (bp = dkp->ibuf) != NULL) {
312: PUTIN(bp, q);
313: DKSIZUP(dkp);
314: dkp->ibuf = NULL;
315: }
316: }
317:
318: /*
319: * DK put procedure
320: */
321: dkput(q, bp)
322: register struct queue *q;
323: register struct block *bp;
324: {
325: register n;
326: register bn;
327: int s;
328: register struct device *reg = DKADDR;
329: register struct dk *dkp;
330:
331: dkp = (struct dk *)q->ptr;
332: if (dkp == NULL) {
333: freeb(bp);
334: return;
335: }
336: switch (bp->type) {
337:
338: case M_IOCTL:
339: bp->type = M_IOCACK;
340: switch (stiocom(bp)) {
341: case DIOCNXCL:
342: dkp->flag &=~ DKXCL;
343: bp->wptr = bp->rptr;
344: bp->type = M_IOCACK;
345: break;
346:
347: default:
348: bp->type = M_IOCNAK;
349: break;
350: }
351: qreply(q, bp);
352: return;
353:
354: case M_CTL:
355: case M_DATA:
356: s = spl6();
357: bp->next = NULL;
358: if (dkp->ofirst == NULL)
359: dkp->ofirst = bp;
360: else
361: dkp->olast->next = bp;
362: dkp->olast = bp;
363: if ((bp->class&S_DELIM)==0 || dkalive == 0) {
364: splx(s);
365: return;
366: }
367: /*
368: * S_DELIM:
369: * push out data
370: */
371: n = DKOPKT;
372: reg->csr = D_WRITE + ENABS;
373: reg->dko = DKMARK + dkp->chan;
374: while ((bp = dkp->ofirst) != NULL) {
375: dkp->ofirst = bp->next;
376: if (bp->wptr == bp->rptr) {
377: freeb(bp);
378: continue;
379: }
380: dkstat.output += bp->wptr - bp->rptr;
381: if (n <= 0) {
382: reg->csr = D_XPACK + ENABS;
383: reg->dko = 0;
384: n = DKOPKT;
385: reg->csr = D_WRITE + ENABS;
386: reg->dko = DKMARK + dkp->chan;
387: }
388: --n;
389: reg->dko = *bp->rptr++ | ((bp->type==M_DATA)?DKDATA:0);
390: while ((bn = bp->wptr - bp->rptr) > 0) {
391: if (bn > n)
392: bn = n;
393: n -= bn;
394: while (--bn >= 0)
395: reg->dko = *bp->rptr++ | DKDATA;
396: if (n <= 0) {
397: reg->csr = D_XPACK + ENABS;
398: reg->dko = 0;
399: n = DKOPKT;
400: reg->csr = D_WRITE + ENABS;
401: reg->dko = DKMARK + dkp->chan;
402: }
403: }
404: freeb(bp);
405: }
406: reg->csr = D_XPACK + ENABS;
407: reg->dko = 0;
408: splx(s);
409: return;
410:
411: case M_PRICTL:
412: switch (*bp->rptr) {
413: case DKMCLOSE:
414: n = bp->rptr[1];
415: if (n < dkcnt) {
416: if (dkstate[n] == DKOPEN) {
417: dkstate[n] = DKRCLOSE;
418: putctl(dk[n].dkrq->next, M_HANGUP);
419: } else if (dkstate[n] == DKLCLOSE)
420: dkstate[n] = DKCLOSED;
421: }
422: freeb(bp);
423: return;
424:
425: case DKMXINIT:
426: n = bp->rptr[1];
427: if (n < dkcnt && dkstate[n] == DKOPEN)
428: (*dk[n].dkrq->next->qinfo->putp)(dk[n].dkrq->next, bp);
429: else
430: freeb(bp);
431: return;
432:
433: default:
434: freeb(bp);
435: return;
436: }
437:
438: default:
439: freeb(bp);
440: return;
441: }
442: }
443:
444: /*
445: * transmit interrupt
446: */
447:
448: dk0int(dev)
449: int dev;
450: {
451: printf("dk%d xmit stray\n", dev);
452: }
453:
454: /*
455: * unibus reset
456: */
457: dkreset()
458: {
459: if (DKADDR)
460: DKADDR->csr = ENABS;
461: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.