![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vax|
Return to tu.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vax |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)tu.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #if defined(VAX750) || defined(VAX730)
10: /*
11: * TU58 DECtape II device driver
12: *
13: * TU58 console cassette driver (for VAX-11/750 or VAX-11/730).
14: * The TU58 is treated as a block device (only). Error detection and
15: * recovery is not extensive, but sufficient for most situations. It is
16: * assumed that the TU58 will follow the RSP (or MRSP) protocol exactly,
17: * very few protocol errors are checked for. It is also assumed that
18: * the 730 uses Modified RSP (MRSP), while the 750 may use either RSP
19: * or MRSP depending on whether defined(MRSP) is true or not.
20: * In the case of a 750 without MRSP, the only way for the CPU to
21: * keep up with the tu58 is to lock out virtually everything else.
22: *
23: * NOTE: Reading large amounts of data from the tu58 is likely
24: * to crash your system if you are running multiuser.
25: * ******FOR SINGLE USER USE ONLY*****
26: */
27: #include "param.h"
28: #include "systm.h"
29: #include "buf.h"
30: #include "conf.h"
31: #include "dir.h"
32: #include "user.h"
33: #include "kernel.h"
34:
35: #include "cpu.h"
36: #include "mtpr.h"
37: #include "rsp.h"
38:
39: #define printd if(tudebug) printf
40: #ifdef printd
41: int tudebug; /* printd */
42: #endif printd
43:
44: #define NTU ((cpu == VAX_750) ? 1 : 2)
45: #define DNUM 01 /* mask for drive number (should match NTU) */
46: #define NTUBLK 512 /* number of blocks on a TU58 cassette */
47: #define WRV 02 /* bit in minor dev => write w. read verify */
48: #define NTUQ 2 /* # of blocks which can be queued up */
49: #define spltu() ((cpu == VAX_750) ? spl7() : spl4())
50:
51: #ifndef MRSP
52: #define MRSP (cpu != VAX_750)
53: #endif
54:
55: /*
56: * State information
57: */
58: struct tu {
59: u_char *tu_rbptr; /* pointer to buffer for read */
60: int tu_rcnt; /* how much to read */
61: u_char *tu_wbptr; /* pointer to buffer for write */
62: int tu_wcnt; /* how much to write */
63: int tu_state; /* current state of tansfer operation */
64: int tu_flag; /* read in progress flag */
65: char *tu_addr; /* real buffer data address */
66: int tu_count; /* real requested count */
67: int tu_serrs; /* count of soft errors */
68: int tu_cerrs; /* count of checksum errors */
69: int tu_herrs; /* count of hard errors */
70: char tu_dopen[2]; /* drive is open */
71: } tu;
72:
73:
74: /*
75: * Device register bits
76: */
77: #define READY 0200 /* transmitter ready */
78: #define DONE 0200 /* receiver done */
79: #define IE 0100 /* interrupt enable */
80: #define BREAK 1 /* send break */
81:
82: struct packet tucmd; /* a command sent to the TU58 */
83: struct packet tudata; /* a command or data returned from TU58 */
84:
85: char *tustates[TUS_NSTATES] = {
86: "INIT1", "INIT2", "IDLE", "SENDH", "SENDD", "SENDC", "SENDR",
87: "SENDW", "GETH", "GETD", "GETC", "GET", "WAIT", "RCVERR", "CHKERR"
88: };
89:
90: u_char tunull[2] = { 0, 0 }; /* nulls to send for initialization */
91: u_char tuinit[2] = { TUF_INITF, TUF_INITF }; /* inits to send */
92: static char tu_pcnt[2]; /* pee/vee counters */
93: int tutimer = 0;
94: int tuwake();
95: struct buf tutab; /* I/O queue header */
96:
97: /*
98: * Open the TU58
99: */
100: /*ARGSUSED*/
101: tuopen(dev, flag)
102: {
103: extern int tuwatch();
104: register s;
105:
106: #ifdef lint
107: turintr(); tuwintr();
108: #endif
109: if ((minor(dev)&DNUM) >= NTU)
110: return (ENXIO);
111: if (tu.tu_dopen[minor(dev)&DNUM])
112: return (EBUSY);
113: if (tutimer++ == 0)
114: timeout(tuwatch, (caddr_t)0, hz);
115:
116: s = spltu();
117: tu.tu_dopen[minor(dev)&DNUM]++;
118: /*
119: * If the cassette's already initialized,
120: * just enable interrupts and return.
121: */
122: if (tu.tu_state == TUS_IDLE) {
123: mtpr(CSRS, IE);
124: goto ok;
125: }
126:
127: /*
128: * Must initialize, reset the cassette
129: * and wait for things to settle down.
130: */
131: tureset();
132: sleep((caddr_t)&tu, PZERO+1);
133: tutab.b_active = NULL;
134: if (tu.tu_state != TUS_IDLE) {
135: tu.tu_state = TUS_INIT1;
136: tu.tu_dopen[minor(dev)&DNUM] = 0;
137: tu.tu_rcnt = tu.tu_wcnt = 0;
138: mtpr(CSTS, 0);
139: mtpr(CSRS, 0);
140: splx(s);
141: return (EIO);
142: }
143: ok:
144: splx(s);
145: return (0);
146: }
147:
148: /*
149: * Close the TU58, but make sure all
150: * outstanding i/o is complete first..
151: */
152: /* ARGSUSED */
153: tuclose(dev, flag)
154: dev_t dev;
155: int flag;
156: {
157: int s, unit = minor(dev);
158: struct buf *bp, *last = NULL;
159:
160: s = spltu();
161: while (tu_pcnt[unit])
162: sleep(&tu_pcnt[unit], PRIBIO);
163: /*
164: * No more writes are pending, scan the
165: * buffer queue for oustanding reads from
166: * this unit.
167: */
168: for (bp = tutab.b_actf; bp; bp = bp->b_actf) {
169: if (bp->b_dev == dev)
170: last = bp;
171: }
172: if (last) {
173: last->b_flags |= B_CALL;
174: last->b_iodone = tuwake;
175: sleep((caddr_t)last, PRIBIO);
176: }
177: tu.tu_dopen[unit&DNUM] = 0;
178: if (!tu.tu_dopen[0] && !tu.tu_dopen[1]) {
179: tutimer = 0;
180: mtpr(CSRS, 0);
181: tu.tu_flag = 0;
182: }
183: splx(s);
184: }
185:
186: tuwake(bp)
187: struct buf *bp;
188: {
189: wakeup((caddr_t)bp);
190: }
191:
192: /*
193: * Reset the TU58
194: */
195: tureset()
196: {
197:
198: mtpr(CSRS, 0);
199: tu.tu_state = TUS_INIT1;
200: tu.tu_wbptr = tunull;
201: tu.tu_wcnt = sizeof (tunull);
202: tucmd.pk_flag = TUF_CMD;
203: tucmd.pk_mcount = sizeof (tucmd) - 4;
204: tucmd.pk_mod = 0;
205: tucmd.pk_seq = 0;
206: tucmd.pk_sw = MRSP ? TUSW_MRSP : 0;
207: tutab.b_active++;
208: mtpr(CSTS, IE | BREAK);
209: tuxintr(); /* start output */
210: }
211:
212: /*
213: * Strategy routine for block I/O
214: */
215: tustrategy(bp)
216: register struct buf *bp;
217: {
218: register int s;
219:
220: if (bp->b_blkno >= NTUBLK) {
221: bp->b_flags |= B_ERROR;
222: iodone(bp);
223: return;
224: }
225: if ((bp->b_flags&B_READ) == 0)
226: tu_pee(&tu_pcnt[minor(bp->b_dev)&DNUM]);
227: bp->av_forw = NULL;
228: s = spltu();
229: if (tutab.b_actf == NULL)
230: tutab.b_actf = bp;
231: else
232: tutab.b_actl->av_forw = bp;
233: tutab.b_actl = bp;
234: if (tutab.b_active == NULL)
235: tustart();
236: splx(s);
237: }
238:
239: /*
240: * Start the transfer
241: */
242: tustart()
243: {
244: register struct buf *bp;
245: int s;
246:
247: if ((bp = tutab.b_actf) == NULL)
248: return;
249: s = spltu();
250: if (tu.tu_state != TUS_IDLE) {
251: tureset();
252: splx(s);
253: return;
254: }
255: tutab.b_active++;
256: tutab.b_errcnt = 0;
257: tucmd.pk_op = bp->b_flags&B_READ ? TUOP_READ : TUOP_WRITE;
258: tucmd.pk_mod = ((bp->b_flags&B_READ) == 0 && (minor(bp->b_dev)&WRV)) ?
259: TUMD_WRV : 0;
260: tucmd.pk_unit = (minor(bp->b_dev)&DNUM);
261: tucmd.pk_sw = MRSP ? TUSW_MRSP : 0;
262: tucmd.pk_count = tu.tu_count = bp->b_bcount;
263: tucmd.pk_block = bp->b_blkno;
264: tucmd.pk_chksum =
265: tuchk(*((short *)&tucmd), (u_short *)&tucmd.pk_op,
266: (int)tucmd.pk_mcount);
267: tu.tu_state = bp->b_flags&B_READ ? TUS_SENDR : TUS_SENDW;
268: tu.tu_addr = bp->b_un.b_addr;
269: tu.tu_wbptr = (u_char *)&tucmd;
270: tu.tu_wcnt = sizeof (tucmd);
271: tuxintr();
272: splx(s);
273: }
274:
275: /*
276: * TU58 receiver interrupt
277: */
278: turintr()
279: {
280: register struct buf *bp;
281: register int c;
282:
283: c = mfpr(CSRD)&0xff;
284: if (MRSP) {
285: while ((mfpr(CSTS)&READY) == 0)
286: ;
287: mtpr(CSTD, TUF_CONT); /* ACK */
288: if (tu.tu_rcnt) {
289: *tu.tu_rbptr++ = c;
290: if (--tu.tu_rcnt)
291: return;
292: }
293: }
294:
295: /*
296: * Switch on the state of the transfer.
297: */
298: switch(tu.tu_state) {
299:
300: /*
301: * Probably an overrun error,
302: * cannot happen if MRSP is used
303: */
304: case TUS_RCVERR:
305: mtpr(CSRS, 0); /* flush */
306: printf("overrun error, transfer restarted\n"); /* DEBUG */
307: tu.tu_serrs++;
308: tu_restart();
309: break;
310:
311: /*
312: * If we get an unexpected "continue",
313: * start all over again...
314: */
315: case TUS_INIT2:
316: tu.tu_state = c == TUF_CONT ? TUS_IDLE : TUS_INIT1;
317: tu.tu_flag = 0;
318: wakeup((caddr_t)&tu);
319: tustart();
320: break;
321:
322: /*
323: * Only transition from this state
324: * is on a "continue", so if we don't
325: * get it, reset the world.
326: */
327: case TUS_WAIT: /* waiting for continue */
328: switch(c) {
329: case TUF_CONT: /* got the expected continue */
330: tu.tu_flag = 0;
331: tudata.pk_flag = TUF_DATA;
332: tudata.pk_mcount = MIN(128, tu.tu_count);
333: tudata.pk_chksum =
334: tuchk(*((short *)&tudata), (u_short *)tu.tu_addr,
335: (int)tudata.pk_mcount);
336: tu.tu_state = TUS_SENDH;
337: tu.tu_wbptr = (u_char *)&tudata;
338: tu.tu_wcnt = 2;
339: tuxintr();
340: break;
341:
342: case TUF_CMD: /* sending us an END packet...error */
343: tu.tu_state = TUS_GET;
344: tu.tu_rbptr = (u_char *) &tudata;
345: tu.tu_rcnt = sizeof (tudata) - 1;
346: tu.tu_flag = 1;
347: mtpr (CSTS, 0);
348: *tu.tu_rbptr = c;
349: break;
350:
351: case TUF_INITF:
352: tureset();
353: break;
354:
355: default: /* something random...bad news */
356: tu.tu_state = TUS_INIT1;
357: break;
358: }
359: break;
360:
361: case TUS_SENDW:
362: if (c != TUF_CONT && c != TUF_INITF)
363: goto bad;
364: tureset();
365: break;
366:
367: /*
368: * Got header, now get data; amount to
369: * fetch is included in packet.
370: */
371: case TUS_GETH:
372: if (MRSP && (tudata.pk_flag == TUF_DATA))
373: tu.tu_rbptr = (u_char *)tu.tu_addr;
374: tu.tu_rcnt = tudata.pk_mcount;
375: tu.tu_state = TUS_GETD;
376: break;
377:
378: /*
379: * Got the data, now fetch the checksum.
380: */
381: case TUS_GETD:
382: tu.tu_rbptr = (u_char *)&tudata.pk_chksum;
383: tu.tu_rcnt = sizeof (tudata.pk_chksum);
384: tu.tu_state = TUS_GETC;
385: break;
386:
387: case TUS_CHKERR: /* from tudma only */
388: tu.tu_cerrs++;
389: goto tus_get;
390:
391: case TUS_GET:
392: if (MRSP)
393: /*
394: * The checksum has already been calculated and
395: * verified in the pseudo DMA routine
396: */
397: goto tus_get;
398:
399: case TUS_GETC:
400: /* got entire packet */
401: if (tudata.pk_chksum !=
402: tuchk(*((short *)&tudata), (u_short *)
403: (tudata.pk_flag == TUF_DATA ?
404: (u_short *) tu.tu_addr : (u_short *)&tudata.pk_op),
405: (int)tudata.pk_mcount))
406: tu.tu_cerrs++;
407: tus_get:
408: if (tudata.pk_flag == TUF_DATA) {
409: /* data packet, advance to next */
410: tu.tu_addr += tudata.pk_mcount;
411: tu.tu_count -= tudata.pk_mcount;
412: tu.tu_state = TUS_GETH;
413: tu.tu_rbptr = (u_char *)&tudata; /* next packet */
414: tu.tu_rcnt = 2;
415: } else if (tudata.pk_flag==TUF_CMD && tudata.pk_op==TUOP_END) {
416: /* end packet, idle and reenable transmitter */
417: tu.tu_state = TUS_IDLE;
418: tu.tu_flag = 0;
419: mtpr(CSTS, IE);
420: printd("ON ");
421: if ((bp = tutab.b_actf) == NULL) {
422: printf("tu%d: no bp, active %d\n",
423: tudata.pk_unit, tutab.b_active);
424: tustart();
425: return;
426: }
427: if (tudata.pk_mod > 1) { /* hard error */
428: bp->b_flags |= B_ERROR;
429: tu.tu_herrs++;
430: printf("tu%d: hard error bn%d,",
431: minor(bp->b_dev)&DNUM, bp->b_blkno);
432: printf(" pk_mod %o\n", tudata.pk_mod&0377);
433: } else if (tudata.pk_mod != 0) /* soft error */
434: tu.tu_serrs++;
435: tutab.b_active = NULL;
436: tutab.b_actf = bp->av_forw;
437: bp->b_resid = tu.tu_count;
438: if ((bp->b_flags&B_READ) == 0)
439: tu_vee(&tu_pcnt[minor(bp->b_dev)&DNUM]);
440: iodone(bp);
441: tustart();
442: } else {
443: /*
444: * Neither data nor end: data was lost
445: * somehow, restart the transfer
446: */
447: mtpr(CSRS, 0); /* flush the rest */
448: tu_restart();
449: tu.tu_serrs++;
450: }
451: break;
452:
453: case TUS_IDLE:
454: case TUS_INIT1:
455: break;
456:
457: default:
458: bad:
459: if (c == TUF_INITF) {
460: printf("tu%d protocol error, state=",
461: (int)tudata.pk_unit);
462: printstate(tu.tu_state);
463: printf(", op=%x, cnt=%d, block=%d\n",
464: tucmd.pk_op, tucmd.pk_count, tucmd.pk_block);
465: tutab.b_active = NULL;
466: if (bp = tutab.b_actf) {
467: bp->b_flags |= B_ERROR;
468: tutab.b_actf = bp->av_forw;
469: if ((bp->b_flags&B_READ) == 0)
470: tu_vee(&tu_pcnt[minor(bp->b_dev)&DNUM]);
471: iodone(bp);
472: }
473: tu.tu_state = TUS_INIT1;
474: } else {
475: printf("tu%d: receive state error, state=",
476: (int)tudata.pk_unit);
477: printstate(tu.tu_state);
478: printf(", byte=%x\n", c & 0xff);
479: if (tutab.b_actf)
480: tu_restart();
481: else
482: wakeup((caddr_t)&tu);
483: }
484: }
485: }
486:
487: /*
488: * TU58 transmitter interrupt
489: */
490: tuxintr()
491: {
492:
493: top:
494: if (tu.tu_wcnt) {
495: /* still stuff to send, send one byte */
496: while ((mfpr(CSTS) & READY) == 0)
497: ;
498: mtpr(CSTD, *tu.tu_wbptr++);
499: tu.tu_wcnt--;
500: return;
501: }
502:
503: /*
504: * Last message byte was sent out.
505: * Switch on state of transfer.
506: */
507: if (tudebug) {
508: printf("tuxintr: state=");
509: printstate(tu.tu_state);
510: }
511: switch(tu.tu_state) {
512:
513: /*
514: * Two nulls have been sent, remove break, and send inits
515: */
516: case TUS_INIT1:
517: mtpr(CSTS, IE);
518: printd("ON2 ");
519: tu.tu_state = TUS_INIT2;
520: tu.tu_wbptr = tuinit;
521: tu.tu_wcnt = sizeof (tuinit);
522: goto top;
523:
524: /*
525: * Inits have been sent, wait for a continue msg.
526: */
527: case TUS_INIT2:
528: (void) mfpr(CSRD);
529: mtpr(CSRS, IE);
530: tu.tu_flag = 1;
531: break;
532:
533: /*
534: * Read cmd packet sent, get ready for data
535: */
536: case TUS_SENDR:
537: tu.tu_state = TUS_GETH;
538: tu.tu_rbptr = (u_char *)&tudata;
539: tu.tu_rcnt = 2;
540: tu.tu_flag = 1;
541: mtpr(CSTS, 0); /* disable transmitter interrupts */
542: printd("OFF ");
543: break;
544:
545: /*
546: * Write cmd packet sent, wait for continue
547: */
548: case TUS_SENDW:
549: tu.tu_state = TUS_WAIT;
550: tu.tu_flag = 1;
551: if ((mfpr(CSRS)&IE) == 0) {
552: printf("NO IE\n");
553: mtpr(CSRS, IE);
554: }
555: break;
556:
557: /*
558: * Header sent, send data.
559: */
560: case TUS_SENDH:
561: tu.tu_state = TUS_SENDD;
562: tu.tu_wbptr = (u_char *)tu.tu_addr;
563: tu.tu_wcnt = tudata.pk_mcount;
564: goto top;
565:
566: /*
567: * Data sent, follow with checksum.
568: */
569: case TUS_SENDD:
570: tu.tu_state = TUS_SENDC;
571: tu.tu_wbptr = (u_char *)&tudata.pk_chksum;
572: tu.tu_wcnt = sizeof tudata.pk_chksum;
573: goto top;
574:
575: /*
576: * Checksum sent, wait for continue.
577: */
578: case TUS_SENDC:
579: /*
580: * Updata buffer address and count.
581: */
582: tu.tu_addr += tudata.pk_mcount;
583: tu.tu_count -= tudata.pk_mcount;
584: if (tu.tu_count) {
585: tu.tu_state = TUS_WAIT;
586: tu.tu_flag = 1;
587: break;
588: }
589:
590: /*
591: * End of transmission, get ready for end packet.
592: */
593: tu.tu_state = TUS_GET;
594: tu.tu_rbptr = (u_char *)&tudata;
595: tu.tu_rcnt = sizeof (tudata);
596: tu.tu_flag = 1;
597: mtpr(CSTS, 0);
598: printd("OFF2 ");
599: break;
600:
601: /*
602: * Random interrupt, probably from MRSP ACK
603: */
604: case TUS_IDLE:
605:
606: default:
607: break;
608:
609: }
610: if (tudebug) {
611: printd(" new tu_state=");
612: printstate(tu.tu_state);
613: }
614: }
615:
616: /*
617: * Compute checksum TU58 fashion
618: */
619: #ifdef lint
620: tuchk(word, cp, n)
621: register word;
622: register unsigned short *cp;
623: int n;
624: {
625: register int c = n >> 1;
626: register long temp;
627:
628: do {
629: temp = *cp++; /* temp, only because vax cc won't *r++ */
630: word += temp;
631: } while (--c > 0);
632: if (n & 1)
633: word += *(unsigned char *)cp;
634: while (word & 0xffff0000)
635: word = (word & 0xffff) + ((word >> 16) & 0xffff);
636: return (word);
637: }
638: #else
639: tuchk(word0, wp, n)
640: register int word0; /* r11 */
641: register u_short *wp; /* r10 */
642: register int n; /* r9 */
643: {
644: asm("loop:");
645: asm(" addw2 (r10)+,r11"); /* add a word to sum */
646: asm(" adwc $0,r11"); /* add in carry, end-around */
647: asm(" acbl $2,$-2,r9,loop"); /* done yet? */
648: asm(" blbc r9,ok"); /* odd byte count? */
649: asm(" movzbw (r10),r10"); /* yes, get last byte */
650: asm(" addw2 r10,r11"); /* add it in */
651: asm(" adwc $0,r11"); /* and the carry */
652: asm("ok:");
653: asm(" movl r11,r0"); /* return sum */
654: }
655: #endif
656:
657: tuwatch()
658: {
659: register int s;
660: register struct buf *bp;
661:
662: if (tutimer == 0)
663: return;
664:
665: if (tu.tu_flag == 0) { /* if no read in progress - skip */
666: timeout(tuwatch, (caddr_t)0, hz);
667: return;
668: }
669: if (tu.tu_flag++ <= 40) {
670: timeout(tuwatch, (caddr_t)0, hz);
671: return;
672: }
673: printf("tu%d: read stalled\n", tudata.pk_unit);
674: #ifdef TUDEBUG
675: printf("%X %X %X %X %X %X %X %X\n", tu.tu_rbptr, tu.tu_rcnt,
676: tu.tu_wbptr, tu.tu_wcnt, tu.tu_state, tu.tu_flag,
677: tu.tu_addr, tu.tu_count);
678: #endif
679: s = spltu();
680: tu.tu_flag = 0;
681: (void) mfpr(CSRD);
682: mtpr(CSRS, IE); /* in case we were flushing */
683: mtpr(CSTS, IE);
684: tu.tu_state = TUS_IDLE;
685: if (!tutab.b_active) {
686: wakeup((caddr_t)&tu);
687: goto retry;
688: }
689: if (++tutab.b_errcnt <= 1) {
690: tustart();
691: goto retry;
692: }
693: if (bp = tutab.b_actf) {
694: bp->b_flags |= B_ERROR;
695: if ((bp->b_flags&B_READ) == 0)
696: tu_vee(&tu_pcnt[minor(bp->b_dev)&DNUM]);
697: iodone(bp);
698: }
699: retry:
700: splx(s);
701: timeout(tuwatch, (caddr_t)0, hz);
702: }
703:
704: tu_pee(cp)
705: char *cp;
706: {
707: register int s;
708:
709: s = spltu();
710: if (++(*cp) > NTUQ)
711: sleep(cp, PRIBIO);
712: splx(s);
713: }
714:
715: tu_vee(cp)
716: char *cp;
717: {
718: register int s;
719:
720: s = spltu();
721: if (--(*cp) <= NTUQ)
722: wakeup(cp);
723: splx(s);
724: }
725:
726: tu_restart()
727: {
728: tureset();
729: timeout(tustart, (caddr_t)0, hz * 3);
730: }
731:
732: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.