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