![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kdi.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 kdi.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: /*
2: * stream driver for DK via KMC-11/KDI board
3: */
4: #include "kdi.h"
5: #include "kmc.h"
6: #if NKDI && NKMC
7:
8: #include "../h/param.h"
9: #include "../h/systm.h"
10: #include "../h/stream.h"
11: #include "../h/ioctl.h"
12: #include "../h/pte.h"
13: #include "../h/map.h"
14: #include "../h/buf.h"
15: #include "../h/ubavar.h"
16: #include "../h/conf.h"
17: #include "../h/ttyld.h"
18: #include "../h/dkstat.h"
19: #include "../h/dkmod.h"
20:
21: #define NKMB 10 /* size of cmd/status buffers */
22: #define KDIPRI 28
23:
24: /* channel states */
25: #define CLOSED 0
26: #define RCLOSE 1 /* remote gone, local still around */
27: #define LCLOSE 2 /* closed locally, not acked yet */
28: #define OPEN 3 /* in use */
29:
30: /*
31: * format of UB addresses sent to KMC
32: */
33: struct kmaddr {
34: u_short hi;
35: u_short lo;
36: };
37:
38: /*
39: * KMC init packet
40: */
41: struct kinit {
42: struct kmaddr cmdaddr; /* UB addr of cmd buf */
43: struct kmaddr stataddr; /* UB addr of statbuf */
44: struct kmaddr bufaddr; /* UB addr of KMC workspace */
45: struct kmaddr csraddr; /* for DR11C - unused */
46: };
47:
48: /*
49: * command/status packets
50: */
51: struct kin { /* KMC command buffer */
52: u_char type; /* command type */
53: u_char serno; /* probably seq number */
54: u_char chan; /* channel number */
55: u_char fill2; /* probably seq number */
56: u_short len; /* byte count */
57: char ctl; /* possible control byte */
58: char mode; /* command variant */
59: struct kmaddr addr; /* UB location of buffer */
60: };
61:
62: /*
63: * Big structure with stuff that needs to be accessible on the unibus
64: */
65: struct kmcdk {
66: struct kinit kinit; /* the init packet */
67: struct kin cmd[NKMB]; /* KMC command buffer */
68: struct kin stat[NKMB]; /* KMC status buffer */
69: char kmcbuf[16*1024]; /* temp space for KMC */
70: } k;
71:
72: struct kdi {
73: struct queue *dkrq;
74: struct block *ibp;
75: struct block *obp;
76: u_short rsize; /* # bytes in last read */
77: char chan;
78: char ostate;
79: } kdi[NKDI];
80:
81:
82: #define KMBUSY 01
83: #define KMSTOP 02
84: #define KMBIG 04 /* rcvd lots last time, use big buffer */
85:
86: /*
87: * device structure
88: */
89: struct device {
90: char sts;
91: char x1;
92: union {
93: struct {
94: u_short lo;
95: u_char hi;
96: } a;
97: struct {
98: u_char x2;
99: u_char x3;
100: u_char ch;
101: u_char ct;
102: u_char sh;
103: u_char st;
104: } q;
105: } u;
106: };
107:
108: /*
109: * KMC commands
110: */
111: #define KC_INIT 1
112: #define KC_SEND 2
113: #define KC_RCVB 3
114: #define KC_CLOSE 4
115: #define KC_XINIT 5
116: #define KC_CMD 6
117: #define KC_FLAG 7
118: #define KC_SOI 8
119:
120: /*
121: * subcommands of KC_CMD or KC_SEND
122: */
123: #define OFLUSH 02 /* flush output */
124: #define OSPND 04 /* suspend output */
125: #define ORSME 010 /* resume output */
126: #define OBOTM 0200 /* send BOTM trailer, not BOT */
127:
128: /*
129: * KMC reports
130: */
131: #define KS_SEND 024
132: #define KS_RDB 025
133: #define KS_EOI 026
134: #define KS_CNTL 027
135: #define KS_ERR 030
136:
137: /*
138: * KC_RCV modes
139: */
140: #define CBLOCK 0040 /* return on block boundary */
141: #define CTIME 0100 /* return when time expires */
142:
143: /*
144: * KS_RDB mode
145: */
146: #define SFULL 0001 /* buffer full */
147: #define SCNTL 0002 /* cntl char recv */
148: #define SABORT 0010 /* rcv aborted */
149: #define SBLOCK 0040 /* block boundary */
150: #define STIME 0100 /* time limit expired */
151:
152: /*
153: * URP control characters
154: */
155: #define D_DELAY 0100
156: #define D_BREAK 0110
157:
158: /*
159: * KMC errors
160: */
161: #define E_NOQB 4 /* internal buffer runout */
162: #define E_UMETA 7 /* unknown control character */
163:
164: /*
165: * tracing
166: */
167: #define DEBUG
168: #ifdef DEBUG
169: struct kin ktrbuf[256];
170: struct kin *ktrp = ktrbuf;
171: #define TRACE(x) *ktrp++ = x; if (ktrp >= &ktrbuf[256]) ktrp = ktrbuf;
172: #else
173: #define TRACE(x) ;
174: #endif
175:
176: int nodev(), kdiopen(), kdiclose(), kdiput(), kdiisrv();
177: struct qinit kdirinit = { nodev, kdiisrv, kdiopen, kdiclose, 0, 0 };
178: struct qinit kdiwinit = { kdiput, NULL, kdiopen, kdiclose, 512, 128 };
179: struct streamtab kdiinfo = { &kdirinit, &kdiwinit };
180:
181: extern u_char blkdata[]; /* stream IO blocks */
182: extern long blkubad; /* unibus address of IO blocks */
183: long kdiubad; /* unibus address of device data */
184: struct kmaddr kmcaddr();
185: int kdiopened;
186: int kmcbad;
187: char kdistate[NKDI];
188: struct dkmodule *kdmodp;
189: extern struct dkmodule dkmod[];
190: extern struct uba_device *kmcdinfo[NKMC];
191: extern struct uba_driver kmcdriver;
192: extern (*kdirint)();
193: extern (*kdixint)();
194: struct dkstat dkstat;
195:
196: /*
197: * open channel
198: */
199: kdiopen(q, dev)
200: register struct queue *q;
201: register dev_t dev;
202: {
203: register struct kdi *kp;
204: register struct block *bp;
205: register mindev = minor(dev);
206:
207: if (mindev <= 0 || mindev >= NKDI || kmcbad)
208: return(0);
209: if (!kdiopened) {
210: if (mindev > 1)
211: return(0);
212: for (kp = &kdi[0]; kp < &kdi[NKDI]; kp++)
213: kp->chan = kp - &kdi[0];
214: if (kdiinit() == 0)
215: return(0);
216: for (kdmodp = dkmod; ;kdmodp++) {
217: if (kdmodp->dev==(dev_t)0 || kdmodp->dev==major(dev)) {
218: kdmodp->dev = major(dev);
219: kdmodp->dkstate = kdistate;
220: kdmodp->nchan = NKDI;
221: break;
222: }
223: }
224: kdiopened++;
225: }
226: kp = &kdi[mindev];
227: if (kdmodp->dkstate[mindev] != CLOSED) {
228: if (mindev&01 && mindev>1) /* outgoing channels cannot reopen */
229: return(0);
230: if (kdmodp->dkstate[mindev] != OPEN)
231: return(0); /* closing channels cannot reopen */
232: return(1);
233: }
234: kp->dkrq = q;
235: q->ptr = (caddr_t)kp;
236: WR(q)->flag |= QDELIM|QBIGB;
237: q->flag |= QDELIM;
238: WR(q)->ptr = (caddr_t)kp;
239: kdmodp->dkstate[mindev] = OPEN;
240: kp->ostate = 0;
241: kcmd(KC_INIT, kp->chan, 0, 0, 0, (caddr_t)0);
242: if ((bp = allocb(64)) == NULL) {
243: kdmodp->dkstate[mindev] = 0;
244: return(0);
245: }
246: kp->ibp = bp;
247: kcmd(KC_RCVB, mindev, bp->lim-bp->wptr, 50,
248: CBLOCK|CTIME, (caddr_t)bp->wptr);
249: return(1);
250: }
251:
252: kdiclose(q)
253: register struct queue *q;
254: {
255: register struct kdi *kp = (struct kdi *)q->ptr;
256: register s, i;
257: register struct block *bp;
258:
259: if (kdmodp->dkstate[kp->chan]==RCLOSE || kdmodp->listnrq==NULL)
260: kdmodp->dkstate[kp->chan] = CLOSED;
261: else if (kdmodp->dkstate[kp->chan] == OPEN) {
262: kdmodp->dkstate[kp->chan] = LCLOSE;
263: for (i=0; i<30 && (WR(q)->count || kp->obp); i++)
264: tsleep((caddr_t)kp, KDIPRI, 1);
265: }
266: kp->dkrq = NULL;
267: if (kdmodp->listnrq)
268: putctl1(RD(kdmodp->listnrq), M_CLOSE, kp->chan);
269: s = spl6();
270: if (kp->obp) {
271: freeb(kp->obp);
272: kp->obp = NULL;
273: }
274: splx(s);
275: kcmd(KC_CLOSE, kp->chan, 0, 0, 0, (caddr_t)NULL);
276: }
277:
278: kdiput(q, bp)
279: register struct queue *q;
280: register struct block *bp;
281: {
282: register struct kdi *kdp = (struct kdi *)q->ptr;
283: register union stmsg *sp;
284: register s;
285:
286: switch(bp->type) {
287:
288: case M_DATA:
289: case M_DELIM:
290: case M_DELAY:
291: case M_BREAK:
292: if (kdmodp->dkstate[kdp->chan] < LCLOSE) {
293: freeb(bp);
294: return;
295: }
296: putq(q, bp);
297: if ((kdp->ostate&KMBUSY)==0)
298: kmstart(kdp);
299: return;
300:
301: case M_CLOSE:
302: s = *bp->rptr;
303: if (s < NKDI) {
304: flushq(q, 1);
305: if (kdmodp->dkstate[s] == OPEN) {
306: kdmodp->dkstate[s] = RCLOSE;
307: putctl(kdi[s].dkrq->next, M_HANGUP);
308: } else if (kdmodp->dkstate[s] == LCLOSE)
309: kdmodp->dkstate[s] = CLOSED;
310: kcmd(KC_CLOSE, s, 0, 0, 0, (caddr_t)NULL);
311: }
312: freeb(bp);
313: return;
314:
315: case M_IOCTL:
316: sp = (union stmsg *)bp->rptr;
317: bp->type = M_IOCACK;
318: switch (sp->ioc0.com) {
319:
320: case TIOCSETP:
321: case TIOCSETN:
322: if (sp->ioc1.sb.sg_ispeed == 0)
323: putctl1(q, M_CLOSE, kdp->chan);
324: case KIOCISURP:
325: bp->wptr = bp->rptr;
326: break;
327:
328: case TIOCGETP:
329: sp->ioc1.sb.sg_ispeed =
330: sp->ioc1.sb.sg_ospeed = B9600;
331: break;
332:
333: case KIOCINIT:
334: kcmd(KC_XINIT, kdp->chan, 0, 0, 0, (caddr_t)NULL);
335: bp->rptr = bp->wptr;
336: break;
337:
338: case KIOCSHUT:
339: if (kdp->chan > 1) {
340: bp->type = M_IOCNAK;
341: break;
342: }
343: kdireset();
344: bp->rptr = bp->wptr;
345: break;
346:
347: case DIOCSTREAM:
348: RD(q)->flag &= ~QDELIM;
349: bp->rptr = bp->wptr;
350: break;
351:
352: case DIOCRECORD:
353: RD(q)->flag |= QDELIM;
354: bp->rptr = bp->wptr;
355: break;
356:
357: default:
358: bp->wptr = bp->rptr;
359: bp->type = M_IOCNAK;
360: break;
361: }
362: qreply(q, bp);
363: return;
364:
365: case M_STOP:
366: s = OSPND;
367: kdp->ostate |= KMSTOP;
368: goto dontcmd;
369:
370: case M_FLUSH:
371: flushq(q, 0);
372: s = spl6();
373: if (kdp->obp) {
374: freeb(kdp->obp);
375: kdp->obp = 0;
376: }
377: kdp->ostate &= ~(KMSTOP|KMBUSY);
378: splx(s);
379: s = OFLUSH|ORSME;
380: goto docmd;
381:
382: case M_START:
383: case M_HANGUP:
384: s = ORSME;
385: kdp->ostate &= ~KMSTOP;
386: goto dontcmd;
387: docmd:
388: kcmd(KC_CMD, kdp->chan, 0, s, 0, (caddr_t)NULL);
389: dontcmd:
390: kmstart(kdp);
391: break;
392:
393: default: /* not handled; just toss */
394: break;
395: }
396: freeb(bp);
397: }
398:
399: kdiisrv(q)
400: register struct queue *q;
401: {
402: register struct kdi *kp = (struct kdi *)q->ptr;
403:
404: if ((q->next->flag&QFULL)==0 && kp->ibp==NULL) {
405: register struct block *bp = allocb(kp->ostate&KMBIG? 1024:64);
406: if (bp == NULL)
407: panic("kdi: can't alloc");
408: kp->ibp = bp;
409: kcmd(KC_RCVB, kp->chan, bp->lim - bp->wptr,
410: 50, CBLOCK|CTIME, (caddr_t)bp->wptr);
411: }
412: }
413:
414: kmstart(kdp)
415: register struct kdi *kdp;
416: {
417: register s = spl5();
418: register struct block *bp;
419: register struct queue *qp;
420: register c;
421: register struct block *xbp;
422:
423: if (kdp->ostate&(KMBUSY|KMSTOP)) {
424: splx(s);
425: return;
426: }
427: if ((qp = kdp->dkrq)==NULL || (qp = WR(qp))==NULL) {
428: splx(s);
429: return;
430: }
431: if (bp = getq(qp)) switch (bp->type) {
432:
433: case M_DELIM:
434: kcmd(KC_SEND, kdp->chan, 0,
435: D_DELAY, 0, (caddr_t)bp->rptr);
436: kdp->ostate |= KMBUSY;
437: kdp->obp = bp;
438: break;
439:
440: case M_DATA:
441: c = OBOTM;
442: if (xbp = qp->first) {
443: if (xbp->type==M_DELIM) {
444: if (xbp = getq(qp))
445: freeb(xbp);
446: c = 0;
447: }
448: } else { /* wait for delim or data */
449: putbq(qp, bp);
450: splx(s);
451: return;
452: }
453: kcmd(KC_SEND, kdp->chan, bp->wptr-bp->rptr,
454: 0, c, (caddr_t)bp->rptr);
455: kdp->ostate |= KMBUSY;
456: dkstat.output += bp->wptr - bp->rptr;
457: kdp->obp = bp;
458: break;
459:
460: case M_DELAY:
461: c = D_DELAY;
462: while (*bp->rptr>0) {
463: c++;
464: *bp->rptr >>= 1;
465: }
466: kcmd(KC_SEND, kdp->chan, 1, c, 0, (caddr_t)bp->rptr);
467: kdp->ostate |= KMBUSY;
468: kdp->obp = bp;
469: break;
470:
471: case M_BREAK:
472: kcmd(KC_SEND, kdp->chan, 0, D_BREAK, 0, (caddr_t)bp->rptr);
473: kdp->ostate |= KMBUSY;
474: kdp->obp = bp;
475: break;
476:
477: default:
478: printf("mesg %o in kdi\n", bp->type);
479: freeb(bp);
480: break;
481: }
482: splx(s);
483: }
484:
485: kcmd(type, chan, len, ctl, mode, addr)
486: caddr_t addr;
487: {
488: register i;
489: register struct device *dp = (struct device *)kmcdinfo[0]->ui_addr;
490: register struct kin *kp;
491: register s = spl5();
492: static struct kmaddr nulladr = {0, 0};
493: static serno;
494:
495: i = dp->u.q.ch;
496: if (i >= NKMB)
497: panic("cmd hd %d in kcmd\n", i);
498: kp = &k.cmd[i];
499: kp->type = type;
500: kp->serno = ++serno;
501: kp->chan = chan;
502: kp->len = len;
503: kp->ctl = ctl;
504: kp->mode = mode;
505: if (addr)
506: kp->addr = kmcaddr(addr, (caddr_t)blkdata, blkubad);
507: else
508: kp->addr = nulladr;
509: i++;
510: if (i >= NKMB)
511: i = 0;
512: dp->u.q.ch = i;
513: TRACE(*kp);
514: splx(s);
515: }
516:
517: /*
518: * Interrupt routine-- unload status buffer:
519: * release write blocks, collect input
520: */
521: kdiintr()
522: {
523: register struct device *dp = (struct device *)(kmcdinfo[0]->ui_addr);
524: register struct kin *sp;
525: register struct kdi *kp;
526: register struct block *bp;
527: register c;
528:
529: for ( ; (c = dp->u.q.st) != dp->u.q.sh; dp->u.q.st = c) {
530: if (c >= NKMB)
531: panic("kdi stat buf is %d\n", c);
532: sp = &k.stat[c];
533: TRACE(*sp);
534: c++;
535: if (c >= NKMB)
536: c = 0;
537: if (sp->chan >= NKDI) {
538: printf("kdi stat chan is 0%o\n", sp->chan);
539: printf("type: %o len: 0%o mode: 0%o\n");
540: continue;
541: }
542: kp = &kdi[sp->chan];
543: switch (sp->type) {
544:
545: case KS_SEND:
546: if (kp->obp) {
547: freeb(kp->obp);
548: kp->obp = NULL;
549: }
550: kp->ostate &= ~KMBUSY;
551: if (kp->dkrq && WR(kp->dkrq)->first)
552: kmstart(kp);
553: break;
554:
555: case KS_RDB:
556: bp = kp->ibp;
557: kp->ibp = NULL;
558: if (kp->dkrq==NULL || kdmodp->dkstate[kp->chan]!=OPEN) {
559: if (bp)
560: freeb(bp);
561: break;
562: }
563: if (sp->mode & SABORT) {
564: printf("kdi rcv abort chan %d mode %o bp %x\n",
565: kp->chan, sp->mode, bp);
566: if (bp)
567: kp->ibp = bp;
568: kp->rsize = 0;
569: kp->ostate &= ~KMBIG;
570: break;
571: }
572: if (bp == NULL) {
573: printf("kdi intr: no ibp\n");
574: break;;
575: }
576: /* special hacks */
577: if (sp->mode&020
578: || sp->mode==0100 && bp->wptr+sp->len == bp->lim) {
579: printf("I");
580: freeb(bp);
581: } else {
582: bp->wptr = bp->lim - sp->len;
583: kp->rsize += bp->wptr - bp->rptr;
584: dkstat.input += bp->wptr - bp->rptr;
585: (*kp->dkrq->next->qinfo->putp)
586: (kp->dkrq->next, bp);
587: kp->ibp = NULL;
588: if(sp->mode&(SBLOCK|STIME)) {
589: putctl(kp->dkrq->next, M_DELIM);
590: kp->ostate &= ~KMBIG;
591: if (kp->rsize >= 512)
592: kp->ostate |= KMBIG;
593: kp->rsize = 0;
594: }
595: if (sp->mode&SCNTL) {
596: switch (sp->ctl) {
597:
598: case D_BREAK:
599: putctl(kp->dkrq->next, M_BREAK);
600: break;
601:
602: }
603: }
604: }
605: if ((kp->dkrq->next->flag&QFULL) == 0) {
606: bp = allocb(kp->ostate&KMBIG? 1024:64);
607: if (bp == NULL)
608: panic("kdi: can't alloc");
609: kp->ibp = bp;
610: kcmd(KC_RCVB, kp->chan, bp->lim - bp->wptr,
611: 50, CBLOCK|CTIME, (caddr_t)bp->wptr);
612: }
613: break;
614:
615: case KS_EOI:
616: printf("kdi chan %d rcv EOI %x\n", sp->chan, sp->len);
617: break;
618:
619: case KS_CNTL:
620: /*
621: printf("kdi chan %d rcv ctl %x\n", sp->chan, sp->len);
622: */
623: break;
624:
625: case KS_ERR:
626: printf("kdi chan %d error %d\n", sp->chan, sp->len);
627: if (sp->len==E_NOQB || sp->len==E_UMETA) {
628: printf("ignored\n");
629: break;
630: }
631: kdireset();
632: break;
633:
634: }
635: }
636: }
637:
638: kdiinit()
639: {
640: register struct device *kp = (struct device *)kmcdinfo[0]->ui_addr;
641: register i;
642: struct kmaddr ka;
643: static time_t kditime;
644: extern time_t time;
645:
646: /* close all open channels? */
647: if (kditime+30 > time)
648: return(0);
649: kp->sts = 0; /* initialize KMC */
650: if (kdiubad == 0) {
651: kdiubad = uballoc(kmcdinfo[0]->ui_ubanum,
652: (caddr_t)&k, sizeof(k), 0);
653: if (kdiubad == 0)
654: panic("UB AD 0 in kdiinit");
655: }
656: k.kinit.cmdaddr = kmcaddr((caddr_t)k.cmd, (caddr_t)&k, kdiubad);
657: k.kinit.stataddr = kmcaddr((caddr_t)k.stat, (caddr_t)&k, kdiubad);
658: k.kinit.bufaddr = kmcaddr((caddr_t)k.kmcbuf, (caddr_t)&k, kdiubad);
659: ka = kmcaddr((caddr_t)&k.kinit, (caddr_t)&k, kdiubad);
660: kp->u.a.lo = ka.lo;
661: kp->u.a.hi = ka.hi;
662: kditime = time;
663: kp->sts = 1; /* start handshake */
664: for (i = 0; i<100000; i++) {
665: if (kp->sts == 2) {
666: kdirint = kdiintr;
667: kdixint = kdiintr;
668: return(1); /* KMC is running OK */
669: }
670: if (kp->sts == 3) {
671: printf("KMC entered state 3\n");
672: return(0);
673: }
674: }
675: printf("KMC did not come ready\n");
676: return(0);
677: }
678:
679: struct kmaddr
680: kmcaddr(memaddr, membase, ubbase)
681: caddr_t memaddr, membase, ubbase;
682: {
683: register struct kmaddr r;
684: register long a;
685:
686: a = (long)memaddr - (long)membase + ((long)ubbase & 0x03ffff);
687: r.hi = a >> 16;
688: r.lo = (u_short)a;
689: return(r);
690: }
691:
692: /*
693: * kmc reload
694: */
695: kdireload()
696: {
697: kdiopened = 0;
698: kdmodp = 0;
699: kmcbad = 0;
700: }
701:
702: /*
703: * zap all open channels
704: */
705: kdireset()
706: {
707: register struct kdi *kp;
708:
709: if (kdmodp==0)
710: return;
711: for (kp = kdi; kp < &kdi[NKDI]; kp++) {
712: register state = kdmodp->dkstate[kp->chan];
713: if ((state==OPEN || state==LCLOSE) && kp->dkrq) {
714: flushq(WR(kp->dkrq), 1);
715: kdmodp->dkstate[kp->chan] = state==OPEN? RCLOSE: CLOSED;
716: putctl(kp->dkrq->next, M_HANGUP);
717: }
718: }
719: kmcbad = 1;
720: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.