![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxmba|
Return to mt.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxmba |
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: * @(#)mt.c 7.3 (Berkeley) 6/6/88
7: */
8:
9: #include "mu.h"
10: #if NMT > 0
11: /*
12: * TM78/TU78 tape driver
13: *
14: * Original author - ?
15: * Most error recovery bug fixes - ggs (ulysses!ggs)
16: * `read reverse' error recovery - ggs (ulysses!ggs)
17: *
18: * OPTIONS:
19: * MTLERRM - Long error message text - twd, Brown University
20: *
21: * TODO:
22: * Add odd byte count kludge from VMS driver (?)
23: * Write dump routine
24: */
25:
26: #include "param.h"
27: #include "systm.h"
28: #include "buf.h"
29: #include "conf.h"
30: #include "dir.h"
31: #include "file.h"
32: #include "user.h"
33: #include "map.h"
34: #include "ioctl.h"
35: #include "mtio.h"
36: #include "cmap.h"
37: #include "uio.h"
38: #include "tty.h"
39: #include "syslog.h"
40:
41: #include "../vax/pte.h"
42: #include "../vax/cpu.h"
43: #include "mbareg.h"
44: #include "mbavar.h"
45: #include "mtreg.h"
46:
47: #define MTTIMEOUT 10000 /* loop limit for controller test */
48: #define INF 1000000L /* a block number that won't exist */
49: #define MASKREG(r) ((r) & 0xffff) /* the control registers have 16 bits */
50:
51: /* Bits for sc_flags */
52:
53: #define H_WRITTEN 01 /* last operation was a write */
54: #define H_EOT 02 /* end of tape encountered */
55: #define H_IEOT 04 /* ignore EOT condition */
56:
57: int mt_do_readrev = 1;
58:
59: /* Per unit status information */
60:
61: struct mu_softc {
62: char sc_openf; /* unit is open if != 0 */
63: char sc_flags; /* state flags */
64: daddr_t sc_blkno; /* current physical block number */
65: daddr_t sc_nxrec; /* firewall input block number */
66: u_short sc_erreg; /* copy of mter or mtner */
67: u_short sc_dsreg; /* copy of mtds */
68: short sc_resid; /* residual function count for ioctl */
69: short sc_dens; /* density code - MT_GCR or zero */
70: int sc_i_mtas; /* mtas at slave attach time */
71: int sc_i_mtner; /* mtner at slave attach time */
72: int sc_i_mtds; /* mtds at slave attach time */
73: struct tty *sc_ttyp; /* record user's tty for errors */
74: int sc_blks; /* number of I/O operations since open */
75: int sc_softerrs; /* number of soft I/O errors since open */
76: } mu_softc[NMU];
77:
78: struct buf cmtbuf[NMT]; /* tape command buffer structures */
79:
80: struct mba_device *mtinfo[NMT]; /* unit to ctlr structures */
81: struct mba_slave *muinfo[NMU]; /* unit to slave structures */
82:
83: char mtds_bits[] = MTDS_BITS; /* mtds bit names for error messages */
84: short mttypes[] = { MBDT_TU78, 0 };
85:
86: int mtattach(), mtslave(), mtustart(), mtstart(), mtndtint(), mtdtint();
87: struct mba_driver mtdriver =
88: { mtattach, mtslave, mtustart, mtstart, mtdtint, mtndtint,
89: mttypes, "mt", "mu", mtinfo };
90:
91: /* Bits in minor device */
92: #define MUUNIT(dev) (minor(dev)&03)
93: #define H_NOREWIND 04
94: #define H_6250BPI 010
95:
96: #define MTUNIT(dev) (muinfo[MUUNIT(dev)]->ms_ctlr)
97:
98: void mtcreset();
99:
100: /*ARGSUSED*/
101: mtattach(mi)
102: struct mba_device *mi;
103: {
104:
105: /* void */
106: }
107:
108: mtslave(mi, ms, sn)
109: struct mba_device *mi;
110: struct mba_slave *ms;
111: int sn;
112: {
113: register struct mu_softc *sc = &mu_softc[ms->ms_unit];
114: register struct mtdevice *mtaddr = (struct mtdevice *)mi->mi_drv;
115: int s = spl5(), rtn = 0, i;
116:
117: /*
118: * Just in case the controller is ill, reset it. Then issue
119: * a sense operation and wait about a second for it to respond.
120: */
121: mtcreset(mtaddr);
122: mtaddr->mtas = -1;
123: mtaddr->mtncs[sn] = MT_SENSE|MT_GO;
124: for (i = MTTIMEOUT; i > 0; i--) {
125: DELAY(50);
126: if (MASKREG(mtaddr->mtas) != 0)
127: break;
128: }
129: sc->sc_i_mtas = mtaddr->mtas;
130: sc->sc_i_mtner = mtaddr->mtner;
131: sc->sc_i_mtds = mtaddr->mtds;
132:
133: /*
134: * If no response, whimper. If wrong response, call it an
135: * unsolicited interrupt and use mtndtint to log and correct.
136: * Otherwise, note whether this slave exists.
137: */
138: if (i <= 0)
139: printf("mt: controller hung\n");
140: else if ((mtaddr->mtner & MTER_INTCODE) != MTER_DONE)
141: (void) mtndtint(mi);
142: else if (mtaddr->mtds & MTDS_PRES) {
143: muinfo[ms->ms_unit] = ms;
144: rtn = 1;
145: }
146:
147: /* cancel the interrupt, then wait a little while for it to go away */
148: mtaddr->mtas = mtaddr->mtas;
149: DELAY(10);
150: splx(s);
151: return (rtn);
152: }
153:
154: mtopen(dev, flag)
155: dev_t dev;
156: int flag;
157: {
158: register int muunit;
159: register struct mu_softc *sc;
160: register struct mba_slave *ms;
161:
162: muunit = MUUNIT(dev);
163: if (muunit >= NMU || (ms = muinfo[muunit]) == NULL ||
164: ms->ms_alive == 0 || mtinfo[ms->ms_ctlr]->mi_alive == 0)
165: return (ENXIO);
166: if ((sc = &mu_softc[muunit])->sc_openf)
167: return (EBUSY);
168: sc->sc_openf = 1;
169: sc->sc_dens = (minor(dev) & H_6250BPI) ? MT_GCR : 0;
170: mtcommand(dev, MT_SENSE, 1);
171: if ((sc->sc_dsreg & MTDS_ONL) == 0) {
172: uprintf("mu%d: not online\n", muunit);
173: sc->sc_openf = 0;
174: return (EIO);
175: }
176: if ((sc->sc_dsreg & MTDS_AVAIL) == 0) {
177: uprintf("mu%d: not online (port selector)\n", muunit);
178: sc->sc_openf = 0;
179: return (EIO);
180: }
181: if ((flag & FWRITE) && (sc->sc_dsreg & MTDS_FPT)) {
182: uprintf("mu%d: no write ring\n", muunit);
183: sc->sc_openf = 0;
184: return (EIO);
185: }
186: if ((sc->sc_dsreg & MTDS_BOT) == 0 && (flag & FWRITE) &&
187: (sc->sc_dens == MT_GCR) != ((sc->sc_dsreg & MTDS_PE) == 0)) {
188: uprintf("mu%d: can't change density in mid-tape\n", muunit);
189: sc->sc_openf = 0;
190: return (EIO);
191: }
192: sc->sc_blkno = (daddr_t)0;
193:
194: /*
195: * Since cooked I/O may do a read-ahead before a write, trash
196: * on a tape can make the first write fail. Suppress the first
197: * read-ahead unless definitely doing read-write.
198: */
199: sc->sc_nxrec = ((flag & (FTRUNC | FWRITE)) == (FTRUNC | FWRITE)) ?
200: (daddr_t)0 : (daddr_t)INF;
201: sc->sc_flags = 0;
202: sc->sc_blks = 0;
203: sc->sc_softerrs = 0;
204: sc->sc_ttyp = u.u_ttyp;
205: return (0);
206: }
207:
208: mtclose(dev, flag)
209: register dev_t dev;
210: register int flag;
211: {
212: register struct mu_softc *sc = &mu_softc[MUUNIT(dev)];
213:
214: if ((flag & (FREAD | FWRITE)) == FWRITE ||
215: ((flag & FWRITE) && (sc->sc_flags & H_WRITTEN)))
216: mtcommand(dev, MT_CLS|sc->sc_dens, 1);
217: if ((minor(dev) & H_NOREWIND) == 0)
218: mtcommand(dev, MT_REW, 0);
219: if (sc->sc_blks > 100 && sc->sc_softerrs > sc->sc_blks / 100)
220: log(LOG_INFO, "mu%d: %d soft errors in %d blocks\n",
221: MUUNIT(dev), sc->sc_softerrs, sc->sc_blks);
222: sc->sc_openf = 0;
223: }
224:
225: mtcommand(dev, com, count)
226: dev_t dev;
227: int com, count;
228: {
229: register struct buf *bp;
230: int s;
231:
232: bp = &cmtbuf[MTUNIT(dev)];
233: s = spl5();
234: while (bp->b_flags & B_BUSY) {
235: if (bp->b_repcnt == 0 && (bp->b_flags & B_DONE))
236: break;
237: bp->b_flags |= B_WANTED;
238: sleep((caddr_t)bp, PRIBIO);
239: }
240: bp->b_flags = B_BUSY|B_READ;
241: splx(s);
242: bp->b_dev = dev;
243: bp->b_command = com;
244: bp->b_repcnt = count;
245: bp->b_blkno = 0;
246: bp->b_error = 0;
247: mtstrategy(bp);
248: if (count == 0)
249: return;
250: biowait(bp);
251: if (bp->b_flags & B_WANTED)
252: wakeup((caddr_t)bp);
253: bp->b_flags &= B_ERROR;
254: }
255:
256: mtstrategy(bp)
257: register struct buf *bp;
258: {
259: register struct buf *dp;
260: struct mba_device *mi = mtinfo[MTUNIT(bp->b_dev)];
261: int s;
262:
263: /*
264: * If this is a data transfer operation, set the resid to a
265: * default value (EOF) to simplify getting it right during
266: * error recovery or bail out.
267: */
268: if (bp != &cmtbuf[MTUNIT(bp->b_dev)])
269: bp->b_resid = bp->b_bcount;
270:
271: /*
272: * Link this request onto the end of the queue for this
273: * controller, then start I/O if not already active.
274: */
275: bp->av_forw = NULL;
276: dp = &mi->mi_tab;
277: s = spl5();
278: if (dp->b_actf == NULL)
279: dp->b_actf = bp;
280: else
281: dp->b_actl->av_forw = bp;
282: dp->b_actl = bp;
283: if (dp->b_active == 0)
284: mbustart(mi);
285: splx(s);
286: }
287:
288: mtustart(mi)
289: register struct mba_device *mi;
290: {
291: register struct mtdevice *mtaddr = (struct mtdevice *)mi->mi_drv;
292: register struct buf *bp = mi->mi_tab.b_actf;
293: register struct mu_softc *sc = &mu_softc[MUUNIT(bp->b_dev)];
294: daddr_t blkno;
295: int count;
296:
297: if (sc->sc_openf < 0) {
298: bp->b_flags |= B_ERROR;
299: return (MBU_NEXT);
300: }
301: if (bp != &cmtbuf[MTUNIT(bp->b_dev)]) {
302: /*
303: * Data transfer. If write at end of tape,
304: * signal "no space" unless suppressed
305: * by MTIOCIEOT.
306: */
307: if ((sc->sc_flags & (H_EOT | H_IEOT)) == H_EOT &&
308: (bp->b_flags & B_READ) == 0) {
309: bp->b_flags |= B_ERROR;
310: bp->b_error = ENOSPC;
311: return (MBU_NEXT);
312: }
313:
314: if (bp->b_flags & B_RAW) {
315: /* raw transfer; never seek */
316: sc->sc_blkno = bdbtofsb(bp->b_blkno);
317: sc->sc_nxrec = sc->sc_blkno + 1;
318: } else {
319: /* seek beyond end of file */
320: if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) {
321: bp->b_flags |= B_ERROR;
322: bp->b_error = ENXIO;
323: return (MBU_NEXT);
324: }
325:
326: /*
327: * This should be end of file, but the buffer
328: * system wants a one-block look-ahead. Humor it.
329: */
330: if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec &&
331: bp->b_flags & B_READ) {
332: bp->b_resid = bp->b_bcount;
333: clrbuf(bp);
334: return (MBU_NEXT);
335: }
336:
337: /* If writing, mark the next block invalid. */
338: if ((bp->b_flags & B_READ) == 0)
339: sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1;
340: }
341: } else {
342: /* It's a command, do it now. */
343: mtaddr->mtncs[MUUNIT(bp->b_dev)] =
344: (bp->b_repcnt<<8)|bp->b_command|MT_GO;
345: return (MBU_STARTED);
346: }
347:
348: /*
349: * If raw I/O, or if the tape is positioned correctly for
350: * cooked I/O, set the byte count, unit number and repeat count
351: * then tell the MASSBUS to proceed. Note that a negative
352: * bcount tells mbstart to map the buffer for "read backwards".
353: */
354: if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) {
355: if (mi->mi_tab.b_errcnt == 2) {
356: mtaddr->mtbc = -bp->b_bcount;
357: mtaddr->mtca = MUUNIT(bp->b_dev);
358: } else {
359: mtaddr->mtbc = bp->b_bcount;
360: mtaddr->mtca = (1<<2)|MUUNIT(bp->b_dev);
361: }
362: return (MBU_DODATA);
363: }
364:
365: /* Issue skip operations to position the next block for cooked I/O. */
366:
367: if (blkno < bdbtofsb(bp->b_blkno))
368: count = bdbtofsb(bp->b_blkno) - blkno;
369: else
370: count = blkno - bdbtofsb(bp->b_blkno);
371: if ((unsigned)count > 0377)
372: count = 0377;
373: mtaddr->mtncs[MUUNIT(bp->b_dev)] = count | MT_SFORW|MT_GO;
374: return (MBU_STARTED);
375: }
376:
377: mtstart(mi)
378: register struct mba_device *mi;
379: {
380: register struct buf *bp = mi->mi_tab.b_actf;
381: register struct mu_softc *sc = &mu_softc[MUUNIT(bp->b_dev)];
382:
383: if (bp->b_flags & B_READ)
384: if (mi->mi_tab.b_errcnt == 2)
385: return (MT_READREV|MT_GO);
386: else
387: return (MT_READ|MT_GO);
388: else
389: return (MT_WRITE|sc->sc_dens|MT_GO);
390: }
391:
392: mtdtint(mi, mbsr)
393: register struct mba_device *mi;
394: int mbsr;
395: {
396: register struct mtdevice *mtaddr = (struct mtdevice *)mi->mi_drv;
397: register struct buf *bp = mi->mi_tab.b_actf;
398: register struct mu_softc *sc;
399: register int er;
400:
401: /* I'M still NOT SURE IF THIS SHOULD ALWAYS BE THE CASE SO FOR NOW... */
402: if ((mtaddr->mtca & 3) != MUUNIT(bp->b_dev)) {
403: printf("mt: wrong unit!\n");
404: mtaddr->mtca = MUUNIT(bp->b_dev);
405: }
406:
407: er = MASKREG(mtaddr->mter);
408: sc = &mu_softc[MUUNIT(bp->b_dev)];
409: sc->sc_erreg = er;
410: if (bp->b_flags & B_READ)
411: sc->sc_flags &= ~H_WRITTEN;
412: else
413: sc->sc_flags |= H_WRITTEN;
414: switch (er & MTER_INTCODE) {
415:
416: case MTER_EOT:
417: sc->sc_flags |= H_EOT;
418: /* fall into MTER_DONE */
419:
420: case MTER_DONE:
421: sc->sc_blkno++;
422: if (mi->mi_tab.b_errcnt == 2) {
423: bp->b_bcount = bp->b_resid;
424: bp->b_resid -= MASKREG(mtaddr->mtbc);
425: if (bp->b_resid > 0 && (bp->b_flags & B_RAW) == 0)
426: bp->b_flags |= B_ERROR;
427: } else
428: bp->b_resid = 0;
429: break;
430:
431: case MTER_SHRTREC:
432: sc->sc_blkno++;
433: bp->b_bcount = bp->b_resid;
434: bp->b_resid -= MASKREG(mtaddr->mtbc);
435: if ((bp->b_flags & B_RAW) == 0)
436: bp->b_flags |= B_ERROR;
437: break;
438:
439: case MTER_RETRY:
440: /*
441: * Simple re-try. Since resid is always a copy of the
442: * original byte count, use it to restore the count.
443: */
444: mi->mi_tab.b_errcnt = 1;
445: bp->b_bcount = bp->b_resid;
446: return (MBD_RETRY);
447:
448: case MTER_RDOPP:
449: /*
450: * The controller just decided to read it backwards.
451: * If the controller returns a byte count of zero,
452: * change it to 1, since zero encodes 65536, which
453: * isn't quite what we had in mind. The byte count
454: * may be larger than the size of the input buffer, so
455: * limit the count to the buffer size. After
456: * making the byte count reasonable, set bcount to the
457: * negative of the controller's version of the byte
458: * count so that the start address for the transfer is
459: * set up correctly.
460: */
461: if (mt_do_readrev) {
462: mi->mi_tab.b_errcnt = 2;
463: if ((bp->b_bcount = MASKREG(mtaddr->mtbc)) == 0)
464: bp->b_bcount = 1;
465: if (bp->b_bcount > bp->b_resid)
466: bp->b_bcount = bp->b_resid;
467: bp->b_bcount = -(bp->b_bcount);
468: return(MBD_RETRY);
469: } else if (MASKREG(mtaddr->mtbc) <= bp->b_resid) {
470: sc->sc_blkno++;
471: bp->b_bcount = bp->b_resid;
472: bp->b_resid -= MASKREG(mtaddr->mtbc);
473: bp->b_flags |= B_ERROR;
474: break;
475: }
476: bp->b_flags |= B_ERROR;
477: /* fall into MTER_LONGREC */
478:
479: case MTER_LONGREC:
480: sc->sc_blkno++;
481: bp->b_bcount = bp->b_resid;
482: bp->b_resid = 0;
483: bp->b_error = ENOMEM;
484: bp->b_flags |= B_ERROR;
485: break;
486:
487: case MTER_NOTCAP:
488: printf("mu%d: blank tape\n", MUUNIT(bp->b_dev));
489: goto err;
490:
491: case MTER_TM:
492: /*
493: * End of file. Since the default byte count has
494: * already been set, just count the block and proceed.
495: */
496: sc->sc_blkno++;
497: err:
498: sc->sc_nxrec = bdbtofsb(bp->b_blkno);
499: break;
500:
501: case MTER_OFFLINE:
502: if (sc->sc_openf > 0) {
503: sc->sc_openf = -1;
504: tprintf(sc->sc_ttyp, "mu%d: offline\n",
505: MUUNIT(bp->b_dev));
506: }
507: bp->b_flags |= B_ERROR;
508: break;
509:
510: case MTER_NOTAVL:
511: if (sc->sc_openf > 0) {
512: sc->sc_openf = -1;
513: tprintf(sc->sc_ttyp, "mu%d: offline (port selector)\n",
514: MUUNIT(bp->b_dev));
515: }
516: bp->b_flags |= B_ERROR;
517: break;
518:
519: case MTER_FPT:
520: tprintf(sc->sc_ttyp, "mu%d: no write ring\n",
521: MUUNIT(bp->b_dev));
522: bp->b_flags |= B_ERROR;
523: break;
524:
525: case MTER_UNREAD:
526: sc->sc_blkno++;
527: bp->b_bcount = bp->b_resid;
528: bp->b_resid -= MIN(MASKREG(mtaddr->mtbc), bp->b_bcount);
529:
530: /* code 010 means a garbage record, nothing serious. */
531: if ((er & MTER_FAILCODE) == (010 << MTER_FSHIFT)) {
532: tprintf(sc->sc_ttyp,
533: "mu%d: rn=%d bn=%d unreadable record\n",
534: MUUNIT(bp->b_dev), sc->sc_blkno, bp->b_blkno);
535: bp->b_flags |= B_ERROR;
536: break;
537: }
538:
539: /*
540: * Anything else might be a hardware problem,
541: * fall into the error report.
542: */
543:
544: default:
545: /*
546: * The bits in sc->sc_dsreg are from the last sense
547: * command. To get the most recent copy, you have to
548: * do a sense at interrupt level, which requires nested
549: * error processing. This is a bit messy, so leave
550: * well enough alone.
551: */
552: tprintf(sc->sc_ttyp, "\
553: mu%d: hard error (data transfer) rn=%d bn=%d mbsr=%b er=0%o ds=%b\n",
554: MUUNIT(bp->b_dev), sc->sc_blkno, bp->b_blkno,
555: mbsr, mbsr_bits, er,
556: MASKREG(sc->sc_dsreg), mtds_bits);
557: #ifdef MTLERRM
558: mtintfail(er);
559: #endif
560: bp->b_flags |= B_ERROR;
561:
562: /*
563: * The TM78 manual says to reset the controller after
564: * TM fault B or MASSBUS fault.
565: */
566: if ((er & MTER_INTCODE) == MTER_TMFLTB ||
567: (er & MTER_INTCODE) == MTER_MBFLT)
568: mtcreset(mtaddr);
569: }
570:
571: /*
572: * Just in case some strange error slipped through (drive off
573: * line during read-reverse error recovery comes to mind), make
574: * sure the byte count is reasonable.
575: */
576: if (bp->b_bcount < 0)
577: bp->b_bcount = bp->b_resid;
578:
579: if ((bp->b_flags & B_ERROR) == 0) {
580: /* this counts reverse reads as soft errors */
581: sc->sc_blks++;
582: if (mi->mi_tab.b_errcnt) /* alternatively, if == 1 */
583: sc->sc_softerrs++;
584: }
585: return (MBD_DONE);
586: }
587:
588: mtndtint(mi)
589: register struct mba_device *mi;
590: {
591: register struct mtdevice *mtaddr = (struct mtdevice *)mi->mi_drv;
592: register struct buf *bp = mi->mi_tab.b_actf;
593: register struct mu_softc *sc;
594: register int er, fc;
595: int unit;
596:
597: unit = (mtaddr->mtner >> 8) & 3;
598: er = MASKREG(mtaddr->mtner);
599: sc = &mu_softc[unit];
600: sc->sc_erreg = er;
601:
602: /* Check for unsolicited interrupts. */
603: if (bp == NULL || unit != MUUNIT(bp->b_dev)) {
604: if ((er & MTER_INTCODE) == MTER_ONLINE)
605: return (MBN_SKIP);
606:
607: printf("mu%d: stray intr (non data transfer) er=0%o ds=%b\n",
608: unit, er, MASKREG(sc->sc_dsreg), mtds_bits);
609: #ifdef MTLERRM
610: mtintfail(er);
611: #endif
612: if ((er & MTER_INTCODE) == MTER_TMFLTB ||
613: (er & MTER_INTCODE) == MTER_MBFLT) {
614: /*
615: * Reset the controller, then set error status
616: * if there was anything active when the fault
617: * occurred. This may shoot an innocent
618: * bystander, but it's better than letting
619: * an error slip through.
620: */
621: mtcreset(mtaddr);
622: if (bp != NULL) {
623: bp->b_flags |= B_ERROR;
624: return (MBN_DONE);
625: }
626: }
627: return (MBN_SKIP);
628: }
629:
630: fc = (mtaddr->mtncs[unit] >> 8) & 0xff;
631: sc->sc_resid = fc;
632:
633: /*
634: * Clear the "written" flag after any operation that changes
635: * the position of the tape.
636: */
637: if (bp != &cmtbuf[MTUNIT(bp->b_dev)] || bp->b_command != MT_SENSE)
638: sc->sc_flags &= ~H_WRITTEN;
639:
640: switch (er & MTER_INTCODE) {
641:
642: case MTER_EOT:
643: sc->sc_flags |= H_EOT;
644: /* fall into MTER_DONE */
645:
646: case MTER_DONE:
647: /* If this is a command buffer, just update the status. */
648: if (bp == &cmtbuf[MTUNIT(bp->b_dev)]) {
649: done:
650: if (bp->b_command == MT_SENSE)
651: sc->sc_dsreg = MASKREG(mtaddr->mtds);
652: return (MBN_DONE);
653: }
654:
655: /*
656: * It's not a command buffer, must be a cooked I/O
657: * skip operation (perhaps a shaky assumption, but it
658: * wasn't my idea).
659: */
660: if ((fc = bdbtofsb(bp->b_blkno) - sc->sc_blkno) < 0)
661: sc->sc_blkno -= MIN(0377, -fc);
662: else
663: sc->sc_blkno += MIN(0377, fc);
664: return (MBN_RETRY);
665:
666: case MTER_ONLINE: /* ddj -- shouldn't happen but did */
667: case MTER_RWDING:
668: return (MBN_SKIP); /* ignore "rewind started" interrupt */
669:
670: case MTER_NOTCAP:
671: tprintf(sc->sc_ttyp, "mu%d: blank tape\n", MUUNIT(bp->b_dev));
672: bp->b_flags |= B_ERROR;
673: return (MBN_DONE);
674:
675: case MTER_TM:
676: case MTER_LEOT:
677: /*
678: * For an ioctl skip operation, count a tape mark as
679: * a record. If there's anything left to do, update
680: * the repeat count and re-start the command.
681: */
682: if (bp == &cmtbuf[MTUNIT(bp->b_dev)]) {
683: if ((sc->sc_resid = bp->b_repcnt = fc - 1) == 0)
684: return (MBN_DONE);
685: else
686: return (MBN_RETRY);
687: } else {
688: /*
689: * Cooked I/O again. Just update the books and
690: * wait for someone else to return end of file or
691: * complain about a bad seek.
692: */
693: if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) {
694: sc->sc_nxrec = bdbtofsb(bp->b_blkno) + fc - 1;
695: sc->sc_blkno = sc->sc_nxrec;
696: } else {
697: sc->sc_nxrec = bdbtofsb(bp->b_blkno) - fc;
698: sc->sc_blkno = sc->sc_nxrec + 1;
699: }
700: }
701: return (MBN_RETRY);
702:
703: case MTER_FPT:
704: tprintf(sc->sc_ttyp, "mu%d: no write ring\n",
705: MUUNIT(bp->b_dev));
706: bp->b_flags |= B_ERROR;
707: return (MBN_DONE);
708:
709: case MTER_OFFLINE:
710: /* If `off line' was intentional, don't complain. */
711: if (bp == &cmtbuf[MTUNIT(bp->b_dev)] &&
712: bp->b_command == MT_UNLOAD)
713: return(MBN_DONE);
714: if (sc->sc_openf > 0) {
715: sc->sc_openf = -1;
716: tprintf(sc->sc_ttyp, "mu%d: offline\n",
717: MUUNIT(bp->b_dev));
718: }
719: bp->b_flags |= B_ERROR;
720: return (MBN_DONE);
721:
722: case MTER_NOTAVL:
723: if (sc->sc_openf > 0) {
724: sc->sc_openf = -1;
725: tprintf(sc->sc_ttyp, "mu%d: offline (port selector)\n",
726: MUUNIT(bp->b_dev));
727: }
728: bp->b_flags |= B_ERROR;
729: return (MBN_DONE);
730:
731: case MTER_BOT:
732: if (bp == &cmtbuf[MTUNIT(bp->b_dev)])
733: goto done;
734: /* fall through */
735:
736: default:
737: tprintf(sc->sc_ttyp, "\
738: mu%d: hard error (non data transfer) rn=%d bn=%d er=0%o ds=%b\n",
739: MUUNIT(bp->b_dev), sc->sc_blkno, bp->b_blkno,
740: er, MASKREG(sc->sc_dsreg), mtds_bits);
741: #ifdef MTLERRM
742: mtintfail(er);
743: #endif
744: if ((er & MTER_INTCODE) == MTER_TMFLTB ||
745: (er & MTER_INTCODE) == MTER_MBFLT)
746: mtcreset(mtaddr); /* reset the controller */
747: bp->b_flags |= B_ERROR;
748: return (MBN_DONE);
749: }
750: /* NOTREACHED */
751: }
752:
753: void
754: mtcreset(mtaddr)
755: register struct mtdevice *mtaddr;
756: {
757: register int i;
758:
759: mtaddr->mtid = MTID_CLR; /* reset the TM78 */
760: DELAY(200);
761: for (i = MTTIMEOUT; i > 0; i--) {
762: DELAY(50); /* don't nag */
763: if ((mtaddr->mtid & MTID_RDY) != 0)
764: return; /* exit when ready */
765: }
766: printf("mt: controller hung\n");
767: }
768:
769: /*ARGSUSED*/
770: mtioctl(dev, cmd, data, flag)
771: dev_t dev;
772: int cmd;
773: caddr_t data;
774: int flag;
775: {
776: register struct mu_softc *sc = &mu_softc[MUUNIT(dev)];
777: register struct buf *bp = &cmtbuf[MTUNIT(dev)];
778: register struct mtop *mtop;
779: register struct mtget *mtget;
780: int callcount, fcount;
781: int op;
782:
783: /* We depend on the values and order of the MT codes here. */
784:
785: static mtops[] =
786: {MT_WTM,MT_SFORWF,MT_SREVF,MT_SFORW,MT_SREV,MT_REW,MT_UNLOAD,MT_SENSE};
787:
788: switch (cmd) {
789:
790: /* tape operation */
791:
792: case MTIOCTOP:
793: mtop = (struct mtop *)data;
794: switch (mtop->mt_op) {
795:
796: case MTWEOF:
797: callcount = mtop->mt_count;
798: fcount = 1;
799: break;
800:
801: case MTFSF: case MTBSF:
802: callcount = mtop->mt_count;
803: fcount = 1;
804: break;
805:
806: case MTFSR: case MTBSR:
807: callcount = 1;
808: fcount = mtop->mt_count;
809: break;
810:
811: case MTREW: case MTOFFL:
812: callcount = 1;
813: fcount = 1;
814: break;
815:
816: default:
817: return (ENXIO);
818: }
819: if (callcount <= 0 || fcount <= 0)
820: return (EINVAL);
821: op = mtops[mtop->mt_op];
822: if (op == MT_WTM)
823: op |= sc->sc_dens;
824: while (--callcount >= 0) {
825: register int n, fc = fcount;
826:
827: do {
828: n = MIN(fc, 0xff);
829: mtcommand(dev, op, n);
830: n -= sc->sc_resid;
831: fc -= n;
832: switch (mtop->mt_op) {
833:
834: case MTWEOF:
835: sc->sc_blkno += (daddr_t)n;
836: sc->sc_nxrec = sc->sc_blkno - 1;
837: break;
838:
839: case MTOFFL:
840: case MTREW:
841: case MTFSF:
842: sc->sc_blkno = (daddr_t)0;
843: sc->sc_nxrec = (daddr_t)INF;
844: break;
845:
846: case MTBSF:
847: if (sc->sc_resid) {
848: sc->sc_blkno = (daddr_t)0;
849: sc->sc_nxrec = (daddr_t)INF;
850: } else {
851: sc->sc_blkno = (daddr_t)(-1);
852: sc->sc_nxrec = (daddr_t)(-1);
853: }
854: break;
855:
856: case MTFSR:
857: sc->sc_blkno += (daddr_t)n;
858: break;
859:
860: case MTBSR:
861: sc->sc_blkno -= (daddr_t)n;
862: break;
863: }
864: if (sc->sc_resid)
865: break;
866: } while (fc);
867: if (fc) {
868: sc->sc_resid = callcount + fc;
869: if (mtop->mt_op == MTFSR ||
870: mtop->mt_op == MTBSR)
871: return (EIO);
872: break;
873: }
874: if (bp->b_flags & B_ERROR)
875: break;
876: }
877: return (geterror(bp));
878:
879: /* tape status */
880: case MTIOCGET:
881: mtget = (struct mtget *)data;
882: mtget->mt_erreg = sc->sc_erreg;
883: mtget->mt_resid = sc->sc_resid;
884: mtcommand(dev, MT_SENSE, 1); /* update drive status */
885: mtget->mt_dsreg = sc->sc_dsreg;
886: mtget->mt_type = MT_ISMT;
887: break;
888:
889: /* ignore EOT condition */
890: case MTIOCIEOT:
891: sc->sc_flags |= H_IEOT;
892: break;
893:
894: /* enable EOT condition */
895: case MTIOCEEOT:
896: sc->sc_flags &= ~H_IEOT;
897: break;
898:
899: default:
900: return (ENXIO);
901: }
902: return (0);
903: }
904:
905: #define DBSIZE 20
906:
907: mtdump()
908: {
909: register struct mba_device *mi;
910: register struct mba_regs *mp;
911: int blk, num;
912: int start;
913:
914: start = 0;
915: num = maxfree;
916: #define phys(a,b) ((b)((int)(a)&0x7fffffff))
917: if (mtinfo[0] == 0)
918: return (ENXIO);
919: mi = phys(mtinfo[0], struct mba_device *);
920: mp = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
921: mp->mba_cr = MBCR_IE;
922: #if lint
923: blk = 0; num = blk; start = num; blk = start;
924: return (0);
925: #endif
926: #ifdef notyet
927: mtaddr = (struct mtdevice *)&mp->mba_drv[mi->mi_drive];
928: mtaddr->mttc = MTTC_PDP11|MTTC_1600BPI;
929: mtaddr->mtcs1 = MT_DCLR|MT_GO;
930: while (num > 0) {
931: blk = num > DBSIZE ? DBSIZE : num;
932: mtdwrite(start, blk, mtaddr, mp);
933: start += blk;
934: num -= blk;
935: }
936: mteof(mtaddr);
937: mteof(mtaddr);
938: mtwait(mtaddr);
939: if (mtaddr->mtds&MTDS_ERR)
940: return (EIO);
941: mtaddr->mtcs1 = MT_REW|MT_GO;
942: return (0);
943: }
944:
945: mtdwrite(dbuf, num, mtaddr, mp)
946: register dbuf, num;
947: register struct mtdevice *mtaddr;
948: struct mba_regs *mp;
949: {
950: register struct pte *io;
951: register int i;
952:
953: mtwait(mtaddr);
954: io = mp->mba_map;
955: for (i = 0; i < num; i++)
956: *(int *)io++ = dbuf++ | PG_V;
957: mtaddr->mtfc = -(num*NBPG);
958: mp->mba_sr = -1;
959: mp->mba_bcr = -(num*NBPG);
960: mp->mba_var = 0;
961: mtaddr->mtcs1 = MT_WCOM|MT_GO;
962: }
963:
964: mtwait(mtaddr)
965: struct mtdevice *mtaddr;
966: {
967: register s;
968:
969: do
970: s = mtaddr->mtds;
971: while ((s & MTDS_DRY) == 0);
972: }
973:
974: mteof(mtaddr)
975: struct mtdevice *mtaddr;
976: {
977:
978: mtwait(mtaddr);
979: mtaddr->mtcs1 = MT_WEOF|MT_GO;
980: #endif notyet
981: }
982:
983: #ifdef MTLERRM
984: /*
985: * Failure messages for each failure code, per interrupt code.
986: * Each table ends with a code of -1 as a default.
987: */
988: struct fmesg {
989: int f_code;
990: char *f_mesg;
991: };
992:
993: static char unclass[] = "unclassified failure code";
994:
995: /* MTER_BOT */
996: static struct fmesg botmsg[] = {
997: 01, "tape was at BOT",
998: 02, "BOT seen after tape started",
999: 03, "ARA ID detected",
1000: -1, unclass
1001: };
1002:
1003: /* MTER_NOTRDY */
1004: static struct fmesg notrdymsg[] = {
1005: 01, "TU on-line but not ready",
1006: 02, "fatal error has occurred",
1007: 03, "access allowed by not really"
1008: -1, unclass
1009: };
1010:
1011: /* MTER_NOTCAP */
1012: static struct fmesg notcapmsg[] = {
1013: 01, "no record found within 25 feet",
1014: 02, "ID burst neither PE nor GCR",
1015: 03, "ARA ID not found",
1016: 04, "no gap found after ID burst",
1017: -1, unclass
1018: };
1019:
1020: /* MTER_LONGREC */
1021: static struct fmesg longrecmsg[] = {
1022: 00, "extended sense data not found",
1023: 01, "extended sense data updated",
1024: -1, unclass
1025: };
1026:
1027: /* MTER_UNREAD, MTER_ERROR, MTER_EOTERR, MTER_BADTAPE */
1028: static struct fmesg code22msg[] = {
1029: 01, "GCR write error",
1030: 02, "GCR read error",
1031: 03, "PE read error",
1032: 04, "PE write error",
1033: 05, "at least 1 bit set in ECCSTA",
1034: 06, "PE write error",
1035: 07, "GCR write error",
1036: 010, "RSTAT contains bad code",
1037: 011, "PE write error",
1038: 012, "MASSBUS parity error",
1039: 013, "invalid data transferred",
1040: -1, unclass
1041: };
1042:
1043: /* MTER_TMFLTA */
1044: static struct fmesg tmfltamsg[] = {
1045: 01, "illegal command code",
1046: 02, "DT command issued when NDT command active",
1047: 03, "WMC error",
1048: 04, "RUN not received from MASSBUS controller",
1049: 05, "mismatch in command read - function routine",
1050: 06, "ECC ROM parity error",
1051: 07, "XMC ROM parity error",
1052: 010, "mismatch in command read - ID burst command",
1053: 011, "mismatch in command read - verify ARA burst command",
1054: 012, "mismatch in command read - verify ARA ID command",
1055: 013, "mismatch in command read - verify gap command",
1056: 014, "mismatch in command read - read id burst command",
1057: 015, "mismatch in command read - verify ARA ID command",
1058: 016, "mismatch in command read - verify gap command",
1059: 017, "mismatch in command read - find gap command",
1060: 020, "WMC LEFT failed to set",
1061: 021, "XL PE set in INTSTA register",
1062: 022, "XMC DONE did not set",
1063: 023, "WMC ROM PE or RD PE set in WMCERR register",
1064: -1, unclass
1065: };
1066:
1067: /* MTER_TUFLTA */
1068: static struct fmesg tufltamsg[] = {
1069: 01, "TU status parity error",
1070: 02, "TU command parity error",
1071: 03, "rewinding tape went offline",
1072: 04, "tape went not ready during DSE",
1073: 05, "TU CMD status changed during DSE",
1074: 06, "TU never came up to speed",
1075: 07, "TU velocity changed",
1076: 010, "TU CMD did not load correctly to start tape motion",
1077: 011, "TU CMD did not load correctly to set drive density",
1078: 012, "TU CMD did not load correctly to start tape motion to write BOT ID",
1079: 013, "TU CMD did not load correctly to backup tape to BOT after failing to write BOT ID",
1080: 014, "failed to write density ID burst",
1081: 015, "failed to write ARA burst",
1082: 016, "failed to write ARA ID",
1083: 017, "ARA error bit set in MTA status B register",
1084: 021, "could not find a gap after ID code was written correctly",
1085: 022, "TU CMD did not load correctly to start tape motion to read ID burst",
1086: 023, "timeout looking for BOT after detecting ARA ID burst",
1087: 024, "failed to write tape mark",
1088: 025, "tape never came up to speed while trying to reposition for retry of writing tape mark",
1089: 026, "TU CMD did not load correctly to start tape motion in erase gap routine",
1090: 027, "could not detect a gap in in erase gap routine",
1091: 030, "could not detect a gap after writing record",
1092: 031, "read path terminated before entire record was written",
1093: 032, "could not find a gap after writing record and read path terminated early",
1094: 033, "TU CMD did not load correctly to backup for retry of write tape mark",
1095: 034, "TU velocity changed after up to speed while trying to reposition for retry of writing tape mark",
1096: 035, "TU CMD did not load correctly to backup to retry a load of BOT ID",
1097: 036, "timeout looking for BOT after failing to write BOT ID",
1098: 037, "TU velocity changed while writing PE gap before starting to write record",
1099: 040, "TU CMD did not load correctly to set PE tape density at start of write BOT ID burst",
1100: 041, "TU CMD did not load correctly to set GCR tape density after writing Density ID",
1101: 042, "TU CMD did not load correctly to set PE tape density at start of read from BOT",
1102: 043, "TU CMD did not load correctly to set GCR tape density after reading a GCR Density ID burst",
1103: };
1104:
1105: /* MTER_TMFLTB */
1106: static char inlinetest[] = "inline test failed";
1107: static struct fmesg tmfltbmsg[] = {
1108: 00, "RST0 interrupt occurred with TM RDY set",
1109: 01, "power failed to interrupt",
1110: 02, "unknown interrupt on channel 5.5",
1111: 03, "unknown interrupt on channel 6.5",
1112: 04, "unknown interrupt on channel 7",
1113: 05, "unknown interrupt on channel 7.5",
1114: 06, "CAS contention retry count expired",
1115: 07, "CAS contention error not retryable",
1116: 010, "queue error, could not find queue entry",
1117: 011, "queue entry already full",
1118: 012, "8085 ROM parity error",
1119: 013, inlinetest,
1120: 013, inlinetest,
1121: 014, inlinetest,
1122: 015, inlinetest,
1123: 016, inlinetest,
1124: 017, inlinetest,
1125: 020, inlinetest,
1126: 021, inlinetest,
1127: 022, inlinetest,
1128: 023, inlinetest,
1129: 024, inlinetest,
1130: 025, inlinetest,
1131: 026, inlinetest,
1132: 027, inlinetest,
1133: 030, inlinetest,
1134: 031, inlinetest,
1135: 032, inlinetest,
1136: 033, inlinetest,
1137: 034, inlinetest,
1138: 035, inlinetest,
1139: 036, inlinetest,
1140: 037, inlinetest,
1141: 040, inlinetest,
1142: 041, inlinetest,
1143: 042, inlinetest,
1144: 043, inlinetest,
1145: 044, inlinetest,
1146: 045, inlinetest
1147: 046, inlinetest,
1148: 047, inlinetest,
1149: 050, inlinetest,
1150: 051, inlinetest,
1151: 052, inlinetest,
1152: 053, inlinetest,
1153: 054, inlinetest,
1154: 055, inlinetest,
1155: 056, inlinetest,
1156: 057, inlinetest,
1157: -1, unclass
1158: };
1159:
1160: /* MTER_MBFLT */
1161: static struct fmesg mbfltmsg[] = {
1162: 01, "control bus parity error",
1163: 02, "illegal register referenced",
1164: -1, unclass
1165: };
1166:
1167: /*
1168: * MTER_LEOT, MTER_RWDING, NTER_NOTAVL, MTER_NONEX, MTER_KEYFAIL,
1169: * and default: no failure message.
1170: */
1171: static struct fmesg nullmsg[] = {
1172: -1, ""
1173: };
1174:
1175: /*
1176: * Interrupt code table.
1177: */
1178: static struct errmsg {
1179: int e_code;
1180: char *e_mesg;
1181: struct fmesg *e_fmesg;
1182: } errmsg[] = {
1183: MTER_BOT, "unexpected BOT", botmsg,
1184: MTER_LEOT, "unexpected LEOT", nullmsg,
1185: MTER_RWDING, "tape rewinding", nullmsg,
1186: MTER_NOTRDY, "drive not ready", notrdymsg,
1187: MTER_NOTAVL, "drive not available", nullmsg,
1188: MTER_NONEX, "unit does not exist", nullmsg,
1189: MTER_NOTCAP, "not capable", notcapmsg,
1190: MTER_LONGREC, "long record", longrecmsg,
1191: MTER_UNREAD, "unreadable record", code22msg,
1192: MTER_ERROR, "error", code22msg,
1193: MTER_EOTERR, "EOT error", code22msg,
1194: MTER_BADTAPE, "tape position lost", code22msg,
1195: MTER_TMFLTA, "TM fault A", tmfltamsg,
1196: MTER_TUFLTA, "TU fault A", tufltamsg,
1197: MTER_TMFLTB, "TM fault B", tmfltbmsg,
1198: MTER_MBFLT, "MB fault", mbfltmsg,
1199: MTER_KEYFAIL, "keypad entry error", nullmsg,
1200: -1, "unclassified error", nullmsg
1201: };
1202:
1203: /*
1204: * Decode an interrupt-time failure.
1205: */
1206: mtintfail(erreg)
1207: int erreg;
1208: {
1209: register struct errmsg *e;
1210: register struct fmesg *f;
1211: register int ecode, fcode;
1212:
1213: ecode = erreg & MTER_INTCODE;
1214: fcode = (erreg & MTER_FAILCODE) >> MTER_FSHIFT;
1215: for (e = errmsg; e->e_code >= 0; e++)
1216: if (e->e_code == ecode)
1217: break;
1218: for (f = e->e_fmesg; f->f_code >= 0; f++)
1219: if (f->f_code == fcode)
1220: break;
1221: printf(" interrupt code = 0%o <%s>\n", ecode, e->e_mesg);
1222: printf(" failure code = 0%o <%s>\n", fcode, f->f_mesg);
1223: }
1224: #endif /* MTLERRM */
1225: #endif /* NMT > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.