Annotation of sys/arch/vax/uba/ts.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ts.c,v 1.17 2007/06/06 17:15:13 deraadt Exp $ */
2: /* $NetBSD: ts.c,v 1.11 1997/01/11 11:34:43 ragge Exp $ */
3:
4: /*-
5: * Copyright (c) 1991 The Regents of the University of California.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the University nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: *
32: * @(#)tmscp.c 7.16 (Berkeley) 5/9/91
33: */
34:
35: /*
36: * sccsid = "@(#)tmscp.c 1.24 (ULTRIX) 1/21/86";
37: */
38:
39: /************************************************************************
40: * *
41: * Licensed from Digital Equipment Corporation *
42: * Copyright (c) *
43: * Digital Equipment Corporation *
44: * Maynard, Massachusetts *
45: * 1985, 1986 *
46: * All rights reserved. *
47: * *
48: * The Information in this software is subject to change *
49: * without notice and should not be construed as a commitment *
50: * by Digital Equipment Corporation. Digital makes no *
51: * representations about the suitability of this software for *
52: * any purpose. It is supplied "As Is" without expressed or *
53: * implied warranty. *
54: * *
55: * If the Regents of the University of California or its *
56: * licensees modify the software in a manner creating *
57: * diriviative copyright rights, appropriate copyright *
58: * legends may be placed on the drivative work in addition *
59: * to that set forth above. *
60: * *
61: ************************************************************************/
62:
63: /*
64: * TSV05/TS05 device driver, written by Bertram Barth.
65: *
66: * should be TS11 compatible (untested)
67: */
68:
69: #define TS11_COMPAT /* don't use extended features provided by TS05 */
70:
71: #ifdef NEED_18BIT
72: #define TS_UBAFLAGS UBA_NEED16
73: #else
74: #define TS_UBAFLAGS 0
75: #endif
76:
77: #define ENABLE_ESS
78: #define ENABLE_END
79:
80: #define ENABLE_EAI /* enable Attention-Interrupts */
81: #undef ENABLE_EAI
82:
83: #define ENABLE_ERI /* Enable Release Buffer Interrupts */
84: #undef ENABLE_ERI
85:
86: #ifdef DEBUG
87: int tsdebug = 1;
88: # define debug(x) if (tsdebug > 0) {DELAY(2000); printf x; DELAY(3000);}
89: # define debug10(x) if (tsdebug > 9) printf x
90: #else
91: # define debug(x) /* just ignore it */
92: # define debug10(x) /* just ignore it */
93: #endif
94:
95: #ifdef TRACE
96: int tstrace = 1;
97: # define trace(x) if (tstrace > 0) {DELAY(2000); printf x; DELAY(3000);}
98: #else
99: # define trace(x) /* just ignore it */
100: #endif
101:
102: /*
103: * TODO: most :-)
104: *
105: * include uba-mapping into tsinit();
106: * merge tsinit(), tsreset() and tsprobe();
107: * complete tsintr();
108: * add proper error/status messages
109: * make messages appear where they are intended to.
110: * check for termination-classes and appropriate actions.
111: * check if flags like CVC and ATTN should be used.
112: * look for correct handling of attentions.
113: * check for correct usage of retry-commands.
114: * ...
115: */
116:
117:
118: #include <sys/param.h>
119: #include <sys/systm.h>
120: #include <sys/kernel.h>
121: #include <sys/buf.h>
122: #include <sys/conf.h>
123: #include <sys/errno.h>
124: #include <sys/file.h>
125: #include <sys/syslog.h>
126: #include <sys/ioctl.h>
127: #include <sys/mtio.h>
128: #include <sys/uio.h>
129: #include <sys/proc.h>
130:
131: #include <machine/pte.h>
132: #include <machine/sid.h>
133: #include <machine/cpu.h>
134: #include <machine/mtpr.h>
135:
136: #include <vax/uba/ubareg.h>
137: #include <vax/uba/ubavar.h>
138:
139: #include <vax/uba/tsreg.h>
140:
141: #include "ts.h"
142:
143: /*
144: * ts command packets and communication area (per controller)
145: */
146: struct ts {
147: struct tsdevice *reg; /* address of i/o-registers */
148: struct tscmd cmd; /* command packet(s) */
149: struct tsmsg msg; /* message packet(s) */
150: } ts[NTS];
151:
152: /*
153: * Software status, per controller.
154: * also status per tape-unit, since only one unit per controller
155: * (thus we have no struct ts_info)
156: */
157: struct ts_softc {
158: struct device sc_dev; /* Autoconf ... */
159: struct uba_unit sc_unit; /* Struct common for UBA to talk */
160: struct ts *sc_ts; /* Unibus address of uda struct */
161: short sc_mapped; /* Unibus map allocated ? */
162: int sc_ubainfo; /* Unibus mapping info */
163: short sc_state; /* see below: ST_xxx */
164: short sc_flags; /* see below: FL_xxx */
165: short sc_lcmd; /* last command word */
166: short sc_rtc; /* retry count for lcmd */
167: short sc_lssr; /* last status register */
168: short sc_lmsgh; /* last message header */
169: short sc_lxst0; /* last status word */
170: short sc_cmdf; /* command flags (ack,cvc,ie) */
171: short sc_openf; /* lock against multiple opens */
172: short sc_liowf; /* last operation was write */
173: int sc_micro; /* microcode revision */
174: int sc_ivec; /* interrupt vector address */
175: short sc_ipl; /* interrupt priority, Q-bus */
176: };
177:
178: void tsintr(int);
179: int tsinit(struct ts_softc *);
180: void tscommand(dev_t, int, int);
181: int tsstatus(int);
182: int tsexec(int, int);
183: int tsstart(struct ts_softc *, struct buf *);
184: int tswchar(int);
185: void tsreset(int);
186: void tsxstatus(struct tsmsg *);
187: int tsmatch(struct device *, void *, void *);
188: void tsattach(struct device *, struct device *, void *);
189: void tsstrategy(struct buf *);
190:
191: int tsopen(dev_t, int, int, struct proc *);
192: int tsclose(dev_t, int, int, struct proc *);
193: int tsioctl(dev_t, u_long, caddr_t, int, struct proc *);
194: int tsread(dev_t, struct uio *);
195: int tswrite(dev_t, struct uio *);
196: int tsdump(dev_t, daddr64_t, caddr_t, size_t);
197:
198: struct cfdriver ts_cd = {
199: NULL, "ts", DV_DULL
200: };
201:
202: struct cfattach ts_ca = {
203: sizeof(struct ts_softc), tsmatch, tsattach
204: };
205:
206:
207: #define ST_INVALID 0 /* uninitialized, before probe */
208: #define ST_PROBE 1 /* during tsprobe(), not used */
209: #define ST_SLAVE 2 /* in tsslave(), init almost complete */
210: #define ST_ATTACH 3 /* during tsattach(), not used */
211: #define ST_INITIALIZED 4 /* init completed, set by tsintr() */
212: #define ST_RUNNING 5
213: #define ST_IDLE 6
214: #define ST_BUSY 7
215:
216: /* Bits in minor device */
217: #define TS_UNIT(dev) (minor(dev)&03)
218: #define TS_HIDENSITY 010
219:
220: #define TS_PRI LOG_INFO
221:
222:
223: /*
224: * Since we don't have credits and thus only one operation per time,
225: * we don't have and don't need queues like MSCP/TMSCP use them.
226: * Per controller we only need one internal buffer for ioctls and
227: * two pointers to buffers to simulate similar behaviour ...
228: */
229: struct buf ts_cbuf[NTS]; /* internal cmd buffer (for ioctls) */
230: struct buf *ts_wtab[NTS]; /* dummy I/O wait queue */
231: #define b_ubinfo b_resid /* Unibus mapping info, per buffer */
232:
233: /*----------------------------------------------------------------------*/
234:
235: /*
236: * Initialize a TS device. Set up UBA mapping registers,
237: * initialize data structures, what else ???
238: */
239: int
240: tsinit (sc)
241: struct ts_softc *sc;
242: {
243: volatile struct tsdevice *tsregs;
244: int unit = sc->sc_dev.dv_unit;
245: struct uba_unit *uu;
246:
247: uu = &sc->sc_unit;
248: tsregs = (struct tsdevice *)ts[unit].reg;
249: if (sc->sc_mapped == 0) {
250: /*
251: * Map the communications area and command and message
252: * buffer into Unibus address space.
253: */
254: sc->sc_ubainfo = uballoc((struct uba_softc *)
255: sc->sc_dev.dv_parent,
256: (caddr_t)&ts[unit], sizeof (struct ts), TS_UBAFLAGS);
257: sc->sc_ts = (struct ts *)(UBAI_ADDR(sc->sc_ubainfo));
258: sc->sc_mapped = 1;
259: }
260:
261: /*
262: * bertram: start hardware initialization ??????
263: */
264:
265: /* tsreset(unit); */
266:
267: return (1);
268: }
269:
270: /*
271: * send a command using the default command-buffer for this unit/controller.
272: * If a command-word is given, then assemble a one-word command.
273: * other words in command-buffer are unchanged and must thus be initialized
274: * before calling this function.
275: */
276: int
277: tsexec (ctlr, cmd)
278: int ctlr;
279: int cmd;
280: {
281: register struct ts_softc *sc = ts_cd.cd_devs[ctlr];
282: register struct tscmd *tscmdp = &ts[ctlr].cmd;
283: register long tscmdma = (long)&sc->sc_ts->cmd; /* mapped address */
284: volatile struct tsdevice *tsreg = ts[ctlr].reg;
285: volatile char *dbx = ((char *)tsreg) + 3;
286: volatile short sr;
287:
288: sc->sc_cmdf |= TS_CF_ACK | TS_CF_IE;
289: tscmdp->cmdr = sc->sc_cmdf | cmd;
290: tscmdp->cmdr = TS_CF_ACK | TS_CF_IE | sc->sc_cmdf | cmd;
291: sc->sc_cmdf = 0; /* XXX */
292:
293: #ifdef DEBUG
294: switch (tscmdp->cmdr & TS_CF_CMASK) {
295: case TS_CMD_RNF: cmdName = "Read Next (Forward)"; break;
296: case TS_CMD_RPR: cmdName = "Read Previous (Reverse)"; break;
297: case TS_CMD_WCHAR: cmdName = "Write Characteristics"; break;
298: case TS_CMD_WD: cmdName = "Write Data (Next)"; break;
299: case TS_CMD_WDR: cmdName = "Write Data (Retry)"; break;
300: case TS_CMD_SRF: cmdName = "Space Records Forward"; break;
301: case TS_CMD_SRR: cmdName = "Space Records Reverse"; break;
302: case TS_CMD_STMF: cmdName = "Skip Tape Marks Forward"; break;
303: case TS_CMD_STMR: cmdName = "Skip Tape Marks Reverse"; break;
304: case TS_CMD_RWND: cmdName = "Rewind"; break;
305: case TS_CMD_WTM: cmdName = "Write Tape Mark"; break;
306: case TS_CMD_WTMR: cmdName = "Write Tape Mark (Retry)"; break;
307: case TS_CMD_STAT: cmdName = "Get Status (END)"; break;
308: default: cmdName = "Unexpected Command"; break;
309: }
310: #endif
311:
312: sr = tsreg->tssr;
313: if ((sr & TS_SSR) == 0) { /* subsystem NOT ready */
314: printf ("%s%d: subsystem not ready [%x]\n",
315: sc->sc_dev.dv_xname, sr);
316: return (-1);
317: }
318: dbx = ((char *)tsreg) + 3; /* dbx is located at the fourth byte */
319: *dbx = (tscmdma >> 18) & 0x0F; /* load bits 18-21 into dbx */
320:
321: /* possible race-condition with ATTN !!! */
322:
323: sr = tsreg->tssr;
324: if ((sr & TS_RMR) != 0) { /* Register modification Refused */
325: printf ("ts: error writing TSDBX\n");
326: return (-1);
327: }
328: /* now load bits 15-2 at pos 15-2 and bits 17,16 at pos 1,0 of TSDB */
329: tsreg->tsdb = (tscmdma & 0xfffc) | ((tscmdma >> 16) & 0x03);
330:
331: /*
332: * wait for SSR or RMR to show up
333: */
334: sr = tsreg->tssr;
335: if ((sr & TS_SSR) != 0) { /* something went wrong .. */
336: if (sr & TS_RMR) {
337: printf ("ts: error writing TSDB (RMR)\n");
338: return (-1);
339: }
340: if (sr & TS_NXM) {
341: printf ("ts: error writing TSDB (NXM)\n");
342: return (-1);
343: }
344: printf ("ts: error 0x%x while writing TSDB\n", sr);
345: tsstatus (sr);
346: return (-1);
347: }
348:
349: return (0); /* completed successfully */
350: }
351:
352: /*
353: * Execute a (ioctl) command on the tape drive a specified number of times.
354: * This routine sets up a buffer and calls the strategy routine which
355: * issues the command to the controller.
356: */
357: void
358: tscommand (dev, cmd, count)
359: register dev_t dev;
360: int cmd;
361: int count;
362: {
363: register struct buf *bp;
364: register int s;
365:
366: trace (("tscommand (%d, %x, %d)\n", TS_UNIT(dev), cmd, count));
367:
368: s = splbio();
369: bp = &ts_cbuf[TS_UNIT(dev)];
370:
371: while (bp->b_flags & B_BUSY) {
372: /*
373: * This special check is because B_BUSY never
374: * gets cleared in the non-waiting rewind case. ???
375: */
376: if (bp->b_bcount == 0 && (bp->b_flags & B_DONE))
377: break;
378: bp->b_flags |= B_WANTED;
379: tsleep ((caddr_t)bp, PRIBIO, "tscommand", 0);
380: /* check MOT-flag !!! */
381: }
382: bp->b_flags = B_BUSY | B_READ;
383:
384: splx(s);
385:
386: /*
387: * Load the buffer. The b_count field gets used to hold the command
388: * count. the b_resid field gets used to hold the command mneumonic.
389: * These 2 fields are "known" to be "safe" to use for this purpose.
390: * (Most other drivers also use these fields in this way.)
391: */
392: bp->b_dev = dev;
393: bp->b_bcount = count;
394: bp->b_resid = cmd;
395: bp->b_blkno = 0;
396: tsstrategy (bp);
397: /*
398: * In case of rewind from close, don't wait.
399: * This is the only case where count can be 0.
400: */
401: if (count == 0) {
402: debug (("tscommand: direct return, no biowait.\n"));
403: return;
404: }
405: debug (("tscommand: calling biowait ...\n"));
406: biowait (bp);
407: if (bp->b_flags & B_WANTED)
408: wakeup ((caddr_t)bp);
409: bp->b_flags &= B_ERROR;
410: }
411:
412: /*
413: * Start an I/O operation on TS05 controller
414: */
415: int
416: tsstart (sc, bp)
417: register struct ts_softc *sc;
418: register struct buf *bp;
419: {
420: int ctlr = sc->sc_dev.dv_unit;
421: volatile struct tsdevice *tsreg = ts[ctlr].reg;
422: register struct tscmd *tscmdp = &ts[ctlr].cmd;
423: register struct buf *dp;
424: volatile int i, itmp;
425: int ioctl;
426: int cmd;
427: int s;
428:
429: if ((dp = ts_wtab[ctlr]) != NULL) {
430: /*
431: * There's already a command pending ...
432: * Either we are called by tsintr or we have missed
433: * something important (race condition).
434: */
435:
436: /* bertram: ubarelse ??? */
437: ts_wtab[ctlr] = NULL;
438: dp->b_flags |= B_ERROR;
439: s = splbio();
440: biodone (dp);
441: splx(s);
442:
443: if (tsreg->tssr & TS_SC) { /* Special Condition; Error */
444: log (TS_PRI, "%s: tssr 0x%x, state %d\n",
445: sc->sc_dev.dv_xname, tsreg->tssr, sc->sc_state);
446: tsinit (sc);
447: return (-1);
448: }
449: /* XXX */
450: }
451:
452: /*
453: * Check if command is an ioctl or not (ie. read or write).
454: * If it's an ioctl then just set the flags for later use;
455: * For other commands attempt to setup a buffer pointer.
456: */
457: if (bp == &ts_cbuf[ctlr]) {
458: ioctl = 1;
459: } else {
460: ioctl = 0;
461:
462: /*
463: * now we try to map the buffer into uba map space (???)
464: */
465: i = TS_UBAFLAGS;
466: switch (vax_cputype) {
467: case VAX_8600:
468: case VAX_780:
469: i |= UBA_CANTWAIT;
470: break;
471: case VAX_750:
472: i |= sc->sc_unit.uu_ubinfo | UBA_CANTWAIT;
473: break;
474: case VAX_730:
475: case VAX_78032:
476: i |= UBA_CANTWAIT;
477: break;
478: default:
479: printf ("unsupported cpu %d in tsstart.\n", vax_cputype);
480: } /* end switch (vax_cputype) */
481:
482: if ((i = ubasetup(sc->sc_dev.dv_parent->dv_unit, bp, i)) == 0) {
483: /*
484: * For some reasons which I don't (yet? :) understand,
485: * tmscp.c initiates in this situation a GET-UNIT
486: * command. (Because no data-buffers are necessary?)
487: */
488: cmd = TS_CMD_STAT;
489: goto do_cmd;
490: return (-1); /* ??? */
491: }
492: #if defined(VAX750)
493: if (vax_cputype == VAX_750)
494: itmp = i & 0xfffffff; /* mask off bdp */
495: else
496: #endif
497: itmp = i;
498:
499: /* XXX */
500: }
501:
502: /*
503: * If it's an ioctl command, then assemble the command.
504: * The "b_resid" field holds the command-number as defined
505: * in <sys/mtio.h>
506: */
507: if (ioctl) {
508: switch ((int)bp->b_resid) {
509: case MTWEOF:
510: cmd = TS_CMD_WTM;
511: break;
512: case MTFSF:
513: cmd = TS_CMD_STMF;
514: tscmdp->cw1 = bp->b_bcount;
515: break;
516: case MTBSF:
517: cmd = TS_CMD_STMR;
518: tscmdp->cw1 = bp->b_bcount;
519: break;
520: case MTFSR:
521: cmd = TS_CMD_SRF;
522: tscmdp->cw1 = bp->b_bcount;
523: break;
524: case MTBSR:
525: cmd = TS_CMD_SRR;
526: tscmdp->cw1 = bp->b_bcount;
527: break;
528: case MTREW:
529: cmd = TS_CMD_RWND;
530: #ifndef TS11_COMPAT
531: if (bp->b_bcount == 0) {
532: cmd = TS_CMD_RWII;
533: }
534: #endif
535: break;
536: case MTOFFL:
537: cmd = TS_CMD_RWUL;
538: break;
539: case MTNOP:
540: cmd = TS_CMD_STAT;
541: break;
542: default:
543: printf ("%s: bad ioctl %d\n", sc->sc_dev.dv_xname,
544: (int)bp->b_resid);
545: /* Need a no-op. get status */
546: cmd = TS_CMD_STAT;
547: } /* end switch (bp->b_resid) */
548: } else { /* Its a read/write command (not an ioctl) */
549: tscmdp->cw1 = UBAI_ADDR(i) & 0xffff;
550: tscmdp->cw2 = (UBAI_ADDR(i) >> 16) & 0x3f;
551: tscmdp->cw3 = bp->b_bcount;
552:
553: if (bp->b_flags & B_READ) {
554: cmd = TS_CMD_RNF;
555: }
556: else {
557: cmd = TS_CMD_WD;
558: }
559: bp->b_ubinfo = itmp; /* save mapping info */
560: }
561:
562: /*
563: * Move buffer to I/O wait pseudo-queue
564: */
565: if (ts_wtab[ctlr]) {
566: /*
567: * we are already waiting for something ...
568: * this should not happen, so we have a problem now.
569: * bertram: set error-flag and call biodone() ???
570: */
571: }
572: ts_wtab[ctlr] = bp;
573:
574: /*
575: * Now that the command-buffer is setup, give it to the controller
576: */
577: do_cmd:
578: return (tsexec(ctlr, cmd));
579: }
580:
581: /*
582: * initialize the controller by sending WRITE CHARACTERISTICS command.
583: * contents of command- and message-buffer are assembled during this
584: * function.
585: */
586: int
587: tswchar (ctlr)
588: int ctlr;
589: {
590: struct ts_softc *sc = ts_cd.cd_devs[ctlr];
591: volatile struct tsdevice *tsregs = ts[ctlr].reg;
592: volatile struct tscmd *tscmdp = &ts[ctlr].cmd;
593: volatile struct tsmsg *tsmsgp = &ts[ctlr].msg;
594: volatile unsigned int sr, ma, timeout;
595:
596: /*
597: * assemble and send "WRITE CHARACTERISTICS" command
598: */
599: ma = (long)tsmsgp;
600: if (ma & 0x7FC00001) { /* address must be even and 22-bit */
601: printf ("invalid address 0x%0x for msg-buffer.\n", ma);
602: return (-1);
603: }
604:
605: tsmsgp->hdr = ma & 0xFFFF; /* low order addr. bits */
606: tsmsgp->dfl = (ma >> 16) & 0x003F; /* high order addr. bits */
607: tsmsgp->rbpcr = 16; /* size of message-buffer */
608: tsmsgp->xst0 = 0; /* chacacteristics mode word */
609: tsmsgp->xst1 = 0; /* control word (ext.feat.) */
610:
611: #ifdef TS11_COMPAT
612: tsmsgp->rbpcr = 14; /* size of message-buffer */
613: tsmsgp->xst0 = 0; /* chacacteristics mode word */
614: tsmsgp->xst1 = 0; /* control word (ext.feat.) */
615: #else
616: tsmsgp->rbpcr = 16; /* size of extended message buffer */
617: tsmsgp->xst0 = 0; /* chacacteristics mode word */
618: tsmsgp->xst1 = 0; /* unit-select */
619: tsmsgp->xst1 |= TS_WC_HSP; /* high speed */
620: #endif
621:
622: #ifdef ENABLE_ESS
623: tsmsgp->xst0 |= TS_WC_ESS;
624: #ifdef ENABLE_ENB
625: tsmsgp->xst0 |= TS_WC_ENB;
626: #endif
627: #endif
628:
629: #ifdef ENABLE_EAI
630: tsmsgp->xst0 |= TS_WC_EAI;
631: #ifdef ENABLE_ERI
632: tsmsgp->xst0 |= TS_WC_ERI;
633: #endif
634: #endif
635:
636: tscmdp->cmdr = TS_CF_ACK | TS_CF_IE | TS_CMD_WCHAR; /* obsolete */
637: tscmdp->cw1 = ma & 0xFFFF;
638: tscmdp->cw2 = (ma >> 16) & 0x003F;
639: tscmdp->cw3 = 10; /* size of charact.-data */
640:
641: if (tsexec (ctlr, TS_CMD_WCHAR) < 0) {
642: printf ("%s: write characteristics command failed [%x]\n",
643: sc->sc_dev.dv_xname, tsregs->tssr);
644: return (-1);
645: }
646:
647: timeout = 1000; /* timeout in 10 seconds */
648: do {
649: DELAY(10000);
650: sr = tsregs->tssr;
651: debug10 (("\ttssr: 0x%x\n", sr));
652: if (timeout-- > 0) {
653: printf ("timeout during initialize.");
654: tsstatus (sr);
655: return (-1);
656: }
657: } while ((sr & TS_SSR) == 0);
658: tsstatus (sr);
659:
660: return (0);
661: }
662:
663: /*
664: *
665: */
666: void
667: tsreset(ctlr)
668: int ctlr;
669: {
670: struct ts_softc *sc = ts_cd.cd_devs[ctlr];
671: volatile struct tsdevice *tsreg = ts[ctlr].reg;
672: volatile unsigned int sr, timeout;
673:
674: /*
675: * reset ctlr by writing into TSSR, then write characteristics
676: */
677: timeout = 1000; /* timeout in 10 seconds */
678: tsreg->tssr = 0; /* start initialization */
679: do {
680: DELAY(10000);
681: sr = tsreg->tssr;
682: debug10 (("\ttssr: 0x%x\n", sr));
683: if (timeout-- > 0) {
684: if (sr != 0)
685: printf ("%s: timeout waiting for TS_SSR\n",
686: sc->sc_dev.dv_xname);
687: tsstatus (sr);
688: return;
689: }
690: } while ((sr & TS_SSR) == 0); /* wait until subsystem ready */
691: tsstatus (sr);
692:
693: return;
694: }
695:
696: /*
697: * probe for device. If found, try to raise an interrupt.
698: * XXX - most of this should be done in the attach routine.
699: */
700: int
701: tsmatch(parent, match, aux)
702: struct device *parent;
703: void *match, *aux;
704: {
705: struct ts_softc *sc = match;
706: struct uba_softc *uh = (void *)parent;
707: struct uba_attach_args *ua = aux;
708: struct tsdevice *tsregs = (struct tsdevice*)ua->ua_addr;
709: volatile unsigned int sr, timeout, count;
710: int ctlr = sc->sc_dev.dv_unit;
711:
712: ts_wtab[ctlr] = NULL;
713: sc->sc_ts = &ts[ctlr];
714: sc->sc_state = ST_PROBE;
715: sc->sc_flags = 0;
716: ts[ctlr].reg = (struct tsdevice*)ua->ua_addr;
717:
718: /*
719: * Set host-settable interrupt vector.
720: * Assign 0 to the TSSR register to start the ts-device initialization.
721: * The device is not really initialized at this point, this is just to
722: * find out if the device exists.
723: */
724: sc->sc_ivec = (uh->uh_lastiv -= 4);
725:
726: count = 0;
727: again:
728: timeout = 1000; /* timeout in 10 seconds */
729: tsregs->tssr = 0; /* start initialization */
730: do {
731: DELAY(10000);
732: sr = tsregs->tssr;
733: debug10 (("\ttssr-1: 0x%x\n", sr));
734: if (timeout-- > 0) {
735: if (sr != 0) /* the device exists !!! */
736: printf ("%s: timeout waiting for TS_SSR\n",
737: sc->sc_dev.dv_xname);
738: tsstatus (sr);
739: goto bad;
740: }
741: } while ((sr & TS_SSR) == 0); /* wait until subsystem ready */
742: tsstatus (sr);
743:
744: tswchar (ctlr); /* write charact. to enable interrupts */
745: /* completion of this will raise the intr. */
746:
747: #ifdef notyet
748: sc->sc_ipl = br = qbgetpri();
749: #else
750: sc->sc_ipl = 0x15;
751: #endif
752: return (sizeof (struct tsdevice));
753:
754: bad: if (++count < 3)
755: goto again;
756:
757: #ifdef notyet
758: splx(s);
759: #endif
760: return (0);
761: }
762:
763:
764: /*
765: * Try to find a slave (a drive) on the controller.
766: * Since there's only one drive per controller there's nothing to do.
767: * (we could check the status of the drive (online/offline/...)
768: */
769: void
770: tsattach(parent, self, aux)
771: struct device *parent, *self;
772: void *aux;
773: {
774: struct ts_softc *sc = (void *)self;
775: int ctlr = sc->sc_dev.dv_unit;
776: struct tsmsg *tsmsgp = &ts[ctlr].msg;
777:
778: trace (("tsslave (%x, %x)\n", ui, reg));
779:
780: /*
781: * write the characteristics (again)
782: * This will raise an interrupt during ST_SLAVE which indicates
783: * completion of initialization ...
784: */
785: sc->sc_state = ST_SLAVE; /* tsintr() checks this ... */
786: if (tswchar (ctlr) < 0) {
787: printf ("%s: cannot initialize", sc->sc_dev.dv_xname);
788: }
789: sc->sc_micro = (tsmsgp->xst2 & TS_SF_MCRL) >> 2;
790: printf ("%s: rev %d, extended features %s, transport %s\n",
791: sc->sc_dev.dv_xname, sc->sc_micro,
792: (tsmsgp->xst2 & TS_SF_EFES ? "enabled" : "disabled"),
793: (ts[ctlr].reg->tssr & TS_OFL ? "offline" : "online"));
794:
795: tsinit (sc); /* must be called once, why not here ? */
796: }
797:
798:
799: /*
800: * TSV05/TS05 interrupt routine
801: */
802: void
803: tsintr(ctlr)
804: int ctlr;
805: {
806: register struct ts_softc *sc = ts_cd.cd_devs[ctlr];
807: register struct tsmsg *tsmsgp = &ts[ctlr].msg;
808: register struct tscmd *tscmdp = &ts[ctlr].cmd;
809: volatile struct tsdevice *tsreg = ts[ctlr].reg;
810: struct uba_unit *um = &sc->sc_unit;
811: register struct buf *bp;
812:
813: unsigned short sr = tsreg->tssr; /* save TSSR */
814: unsigned short mh = tsmsgp->hdr; /* and msg-header */
815: /* clear the message header ??? */
816:
817: short ccode = tscmdp->cmdr & TS_CF_CCODE;
818: short cmask = tscmdp->cmdr & TS_CF_CMASK;
819:
820: #ifdef DEBUG
821: {
822: char bits[64];
823: printf ("TSSR: %s, MSG: %x ", bitmask_snprintf(sr,
824: TS_TSSR_BITS, bits, sizeof(bits)), mh);
825: }
826: switch (tsmsgp->hdr & 0x001F) {
827: case 16: printf ("(End)"); break;
828: case 17: printf ("(Fail)"); break;
829: case 18: printf ("(Error)"); break;
830: case 19: printf ("(Attention)"); break;
831: }
832: #endif
833:
834: trace ((" tsintr (%d, %d, %d, %x)\n", uba, vector, level, ctlr));
835:
836: if (tsmsgp->xst0 & TS_SF_VCK)
837: sc->sc_cmdf |= TS_CF_CVC;
838:
839: #ifdef QBA /* copied from uda.c */
840: if(vax_cputype == VAX_78032)
841: splx(sc->sc_ipl); /* Qbus interrupt protocol is odd */
842: #endif
843:
844: /*
845: * There are two different things which can (and should) be checked:
846: * the actual (internal) state and the device's result (tssr/msg.hdr)
847: *
848: * For each state there's only one "normal" interrupt. Anything else
849: * has to be checked more intensively. Thus in a first run according
850: * to the internal state the expected interrupt is checked/handled.
851: *
852: * In a second run the remaining (not yet handled) interrupts are
853: * checked according to the drive's result.
854: */
855: switch (sc->sc_state) {
856:
857: case ST_INVALID:
858: /*
859: * Ignore unsolicited interrupts.
860: */
861: log (LOG_WARNING, "%s: stray intr [%x,%x]\n",
862: sc->sc_dev.dv_xname, sr, mh);
863: return;
864:
865: case ST_SLAVE:
866: /*
867: * this interrupt was caused by write-charact. command
868: * issued by tsslave() and indicates the end of the
869: * initialization phase. Just ignore it ...
870: */
871: if ((sr & TS_SC) != 0 || (sr & TS_TC) != TS_TC_NORM) {
872: printf("%s: problem during init [%x,%x]\n",
873: sc->sc_dev.dv_xname, sr, mh);
874: /* return here ??? */
875: /* break and check the error outside switch ??? */
876: break;
877: }
878: sc->sc_state = ST_RUNNING;
879: return;
880:
881:
882: case ST_RUNNING:
883: /*
884: * Here we expect interrupts indicating the end of
885: * commands or indicating problems.
886: */
887: /*
888: * Anything else is handled outside this switch ...
889: */
890: break;
891:
892: case ST_IDLE:
893: break;
894:
895:
896: default:
897: printf ("%s: unexpected interrupt during state %d [%x,%x]\n",
898: sc->sc_dev.dv_xname, sc->sc_state, sr, mh);
899: return;
900: }
901:
902: /*
903: * now we check the termination class.
904: */
905: switch (sr & TS_TC) {
906:
907: case TS_TC_NORM:
908: /*
909: * Normal termination -- The operation is completed
910: * witout incident.
911: */
912: sc->sc_state = ST_IDLE; /* XXX ??? */
913: sc->sc_state = ST_RUNNING;
914: sc->sc_liowf = (ccode == TS_CC_WRITE);
915: sc->sc_rtc = 0;
916: if ((bp = ts_wtab[ctlr]) != NULL) {
917: ts_wtab[ctlr] = NULL; /* pseudo-unlink */
918:
919: if (bp != &ts_cbuf[ctlr]) { /* no ioctl */
920: ubarelse((struct uba_softc *)
921: sc->sc_dev.dv_parent,
922: (int *)&bp->b_ubinfo);
923: #if defined(VAX750)
924: if (vax_cputype == VAX_750 &&
925: sc->sc_unit.uu_ubinfo != 0)
926: ubarelse((struct uba_softc *)
927: sc->sc_dev.dv_parent,
928: &sc->sc_unit.uu_ubinfo);
929: /* XXX */
930: #endif
931: }
932: bp->b_resid = tsmsgp->rbpcr;
933: debug (("tsintr: biodone(NORM) [%d,%d,%d]\n",
934: bp->b_resid, bp->b_bcount, tsmsgp->rbpcr));
935: biodone (bp); /* bertram: ioctl ??? */
936: }
937: return;
938:
939: case TS_TC_ATTN:
940: /*
941: * Attention condition -- this code indicates that the
942: * drive has undergone a status change, such as going
943: * off-line or coming on-line.
944: * (Without EAI enabled, no Attention interrupts occur.
945: * drive status changes are signaled by the VCK flag.)
946: */
947: return;
948:
949: case TS_TC_TSA:
950: /*
951: * Tape Status Alert -- A status condition is encountered
952: * that may have significance to the program. Bits of
953: * interest in the extended status registers include
954: * TMK, EOT and RLL.
955: */
956: debug (("Tape Status Alert\n"));
957: tsxstatus (tsmsgp);
958: if (tsmsgp->xst0 & TS_SF_TMK) {
959: debug (("Tape Mark detected"));
960: }
961: if (tsmsgp->xst0 & TS_SF_EOT) {
962: debug (("End of Tape"));
963: }
964: break;
965:
966: case TS_TC_FR:
967: /*
968: * Function Reject -- The specified function was not
969: * initiated. Bits of interest include OFL, VCK, BOT,
970: * WLE, ILC and ILA.
971: */
972: debug (("Function reject\n"));
973: tsxstatus (tsmsgp);
974: if (sr & TS_OFL) {
975: printf ("tape is off-line.\n");
976: break;
977: }
978: if (tsmsgp->xst0 & TS_SF_VCK) {
979: printf ("Volume check: repeating command ...\n");
980: tsexec (ctlr, tscmdp->cmdr);
981: return;
982: }
983: if (tsmsgp->xst0 & TS_SF_BOT) {
984: printf ("bottom of tape.\n");
985: }
986: if (tsmsgp->xst0 & TS_SF_WLE) {
987: printf ("Write Lock Error\n");
988: }
989: break;
990:
991: case TS_TC_TPD:
992: /*
993: * Recoverable Error -- Tape position is a record beyond
994: * what its position was when the function was initiated.
995: * Suggested recovery procedure is to log the error and
996: * issue the appropriate retry command.
997: */
998: debug (("Tape position down\n"));
999: switch (cmask) {
1000: case TS_CMD_RNF: /* Read Next (forward) */
1001: debug (("retry read forward ...\n"));
1002: sc->sc_rtc = 1;
1003: tsexec (ctlr, TS_CMD_RPF);
1004: return;
1005: case TS_CMD_RPR: /* Read Previous (Reverse) */
1006: debug (("retry read reverse ...\n"));
1007: sc->sc_rtc = 1;
1008: tsexec (ctlr, TS_CMD_RNR);
1009: return;
1010: case TS_CMD_WD: /* Write Data (Next) */
1011: debug (("retry write data ...\n"));
1012: sc->sc_rtc = 1;
1013: tsexec (ctlr, TS_CMD_WDR);
1014: return;
1015: case TS_CMD_WTM:
1016: debug (("retry write tape mark ...\n"));
1017: sc->sc_rtc = 1;
1018: tsexec (ctlr, TS_CMD_WTMR);
1019: return;
1020: default:
1021: debug (("TPD in command %x\n", cmask));
1022: }
1023: break;
1024:
1025: case TS_TC_TNM:
1026: /*
1027: * Recoverable Error -- Tape position has not changed.
1028: * Suggested recovery procedure is to log the error and
1029: * reissue the original command.
1030: */
1031: printf ("Tape not moved\n");
1032: if (sc->sc_rtc < 3) {
1033: sc->sc_rtc++;
1034: /* bertram: log the error !!! */
1035: printf ("retrying command %x (%d)\n",
1036: tscmdp->cmdr, sc->sc_rtc);
1037: tsexec (ctlr, tscmdp->cmdr);
1038: return;
1039: }
1040: break;
1041:
1042: case TS_TC_TPL:
1043: /*
1044: * Unrecoverable Error -- Tape position has been lost.
1045: * No valid recovery procedures exist unless the tape
1046: * has labels or sequence numbers.
1047: */
1048: printf ("Tape position lost\n");
1049: break;
1050:
1051: case TS_TC_FCE:
1052: /*
1053: * Fatal subsytem Error -- The subsytem is incapable
1054: * of properly performing commands, or at least its
1055: * integrity is seriously questionable. Refer to the
1056: * fatal class code field in the TSSR register for
1057: * additional information on the type of fatal error.
1058: */
1059: printf ("Fatal Controller Error\n");
1060:
1061: default:
1062: printf ("%s: error 0x%x, resetting controller\n",
1063: sc->sc_dev.dv_xname, sr & TS_TC);
1064: tsreset (ctlr);
1065: }
1066:
1067: /*
1068: * reset controller ?? call tsinit() ???
1069: */
1070: if ((bp = ts_wtab[ctlr]) != NULL) {
1071: ts_wtab[ctlr] = NULL; /* pseudo unlink */
1072:
1073: if (bp != &ts_cbuf[ctlr]) /* no ioctl */
1074: ubarelse((struct uba_softc *)sc->sc_dev.dv_parent,
1075: (int *)&bp->b_ubinfo);
1076:
1077: if ((sr & TS_TC) != TS_TC_NORM)
1078: bp->b_flags |= B_ERROR;
1079:
1080: debug (("resid:%d, count:%d, rbpcr:%d\n",
1081: bp->b_resid, bp->b_bcount, tsmsgp->rbpcr));
1082: bp->b_resid = tsmsgp->rbpcr; /* XXX */
1083: debug (("tsintr: biodone(%x)\n", bp->b_flags));
1084: biodone (bp);
1085: }
1086: if ((sr & TS_TC) > TS_TC_FR)
1087: tsreset (ctlr);
1088:
1089: return;
1090: }
1091:
1092:
1093: /*
1094: * Open a ts device and set the unit online. If the controller is not
1095: * in the run state, call init to initialize the ts controller first.
1096: */
1097: int
1098: tsopen (dev, flag, type, p)
1099: dev_t dev;
1100: int flag, type;
1101: struct proc *p;
1102: {
1103: register struct uba_device *ui;
1104: register struct uba_ctlr *um;
1105: register struct ts_softc *sc;
1106: register int unit = TS_UNIT(dev);
1107: int s;
1108:
1109: trace (("tsopen (%x, %x)\n", dev, flag));
1110:
1111: if (unit >= ts_cd.cd_ndevs)
1112: return ENXIO;
1113:
1114: sc = ts_cd.cd_devs[unit];
1115: if (sc == 0)
1116: return ENXIO;
1117:
1118: if (sc->sc_openf)
1119: return EBUSY;
1120:
1121: sc->sc_openf = 1;
1122:
1123: s = splbio ();
1124: if (sc->sc_state < ST_RUNNING) { /* XXX */
1125: printf ("%s not running.\n", sc->sc_dev.dv_xname);
1126: splx(s);
1127: sc->sc_openf = 0;
1128: return (ENXIO);
1129: }
1130: splx(s);
1131:
1132: /*
1133: * check if transport is really online.
1134: * (without attention-interrupts enabled, we really don't know
1135: * the actual state of the transport. Thus we call get-status
1136: * (ie. MTNOP) once and check the actual status.)
1137: */
1138: tscommand (dev, MTNOP, 1);
1139: if (ts[unit].reg->tssr & TS_OFL) {
1140: printf ("%s: transport is offline.\n", sc->sc_dev.dv_xname);
1141: sc->sc_openf = 0;
1142: return EIO; /* transport is offline */
1143: }
1144:
1145: sc->sc_liowf = 0;
1146: return 0;
1147: }
1148:
1149:
1150: /*
1151: * Close tape device.
1152: *
1153: * If tape was open for writing or last operation was
1154: * a write, then write two EOF's and backspace over the last one.
1155: * Unless this is a non-rewinding special file, rewind the tape.
1156: *
1157: * Make the tape available to others, by clearing openf flag.
1158: */
1159: int
1160: tsclose (dev, flag, type, p)
1161: dev_t dev;
1162: int flag, type;
1163: struct proc *p;
1164: {
1165: register struct ts_softc *sc = ts_cd.cd_devs[TS_UNIT(dev)];
1166:
1167: if (flag == FWRITE || ((flag & FWRITE) && sc->sc_liowf)) {
1168: /*
1169: * We are writing two tape marks (EOT), but place the tape
1170: * before the second one, so that another write operation
1171: * will overwrite the second one and leave and EOF-mark.
1172: */
1173: tscommand (dev, MTWEOF, 1); /* Write Tape Mark */
1174: tscommand (dev, MTWEOF, 1); /* Write Tape Mark */
1175: tscommand (dev, MTBSF, 1); /* Skip Tape Marks Reverse */
1176: }
1177:
1178: if ((dev & T_NOREWIND) == 0)
1179: tscommand (dev, MTREW, 0);
1180:
1181: sc->sc_openf = 0;
1182: sc->sc_liowf = 0;
1183: return 0;
1184: }
1185:
1186:
1187: /*
1188: * Manage buffers and perform block mode read and write operations.
1189: */
1190: void
1191: tsstrategy (bp)
1192: register struct buf *bp;
1193: {
1194: register int unit = TS_UNIT(bp->b_dev);
1195: struct ts_softc *sc = (void *)ts_cd.cd_devs[unit];
1196: int s;
1197:
1198: s = splbio ();
1199: /*
1200: * we have only one command at one time, no credits.
1201: * thus we don't need buffer management and controller queue
1202: * just try to execute the command ...
1203: */
1204:
1205: tsstart (sc, bp);
1206: splx(s);
1207: return;
1208: }
1209:
1210:
1211: /*
1212: * Catch ioctl commands, and call the "command" routine to do them.
1213: */
1214: int
1215: tsioctl (dev, cmd, data, flag, p)
1216: dev_t dev;
1217: u_long cmd;
1218: caddr_t data;
1219: int flag;
1220: struct proc *p;
1221: {
1222: register struct buf *bp = &ts_cbuf[TS_UNIT(dev)];
1223: register struct ts_softc *sc;
1224: register struct mtop *mtop; /* mag tape cmd op to perform */
1225: register struct mtget *mtget; /* mag tape struct to get info in */
1226: register callcount; /* number of times to call routine */
1227: int scount; /* number of files/records to space */
1228: int spaceop = 0; /* flag for skip/space operation */
1229: int error = 0;
1230:
1231: trace (("tsioctl (%x, %x, %x, %d)\n", dev, cmd, data, flag));
1232:
1233: switch (cmd) {
1234: case MTIOCTOP: /* do a mag tape op */
1235: mtop = (struct mtop *)data;
1236: switch (mtop->mt_op) {
1237: case MTWEOF: /* write an end-of-file record */
1238: callcount = mtop->mt_count;
1239: scount = 1;
1240: break;
1241: case MTFSF: /* forward space file */
1242: case MTBSF: /* backward space file */
1243: case MTFSR: /* forward space record */
1244: case MTBSR: /* backward space record */
1245: spaceop = 1;
1246: callcount = 1;
1247: scount = mtop->mt_count;
1248: break;
1249: case MTREW: /* rewind */
1250: case MTOFFL: /* rewind and put the drive offline */
1251: case MTNOP: /* no operation, sets status only */
1252: callcount = 1;
1253: scount = 1; /* wait for this rewind */
1254: break;
1255: case MTRETEN: /* retension */
1256: case MTERASE: /* erase entire tape */
1257: case MTEOM: /* forward to end of media */
1258: case MTNBSF: /* backward space to begin of file */
1259: case MTCACHE: /* enable controller cache */
1260: case MTNOCACHE: /* disable controller cache */
1261: case MTSETBSIZ: /* set block size; 0 for variable */
1262: case MTSETDNSTY: /* set density code for current mode */
1263: debug (("ioctl %d not implemented.\n", mtop->mt_op));
1264: return (ENXIO);
1265: default:
1266: debug (("invalid ioctl %d\n", mtop->mt_op));
1267: return (ENXIO);
1268: } /* switch (mtop->mt_op) */
1269:
1270: if (callcount <= 0 || scount <= 0) {
1271: debug (("invalid values %d/%d\n", callcount, scount));
1272: return (EINVAL);
1273: }
1274: do {
1275: tscommand (dev, mtop->mt_op, scount);
1276: if (spaceop && bp->b_resid) {
1277: debug (("spaceop didn't complete\n"));
1278: return (EIO);
1279: }
1280: if (bp->b_flags & B_ERROR) {
1281: debug (("error in ioctl %d\n", mtop->mt_op));
1282: break;
1283: }
1284: } while (--callcount > 0);
1285: if (bp->b_flags & B_ERROR)
1286: if ((error = bp->b_error) == 0)
1287: return (EIO);
1288: return (error);
1289:
1290: case MTIOCGET: /* get tape status */
1291: sc = ts_cd.cd_devs[TS_UNIT(dev)];
1292: mtget = (struct mtget *)data;
1293: mtget->mt_type = MT_ISTS;
1294: mtget->mt_dsreg = (unsigned)(ts[TS_UNIT(dev)].reg->tssr);
1295: mtget->mt_erreg = (unsigned)(ts[TS_UNIT(dev)].msg.hdr);
1296: mtget->mt_resid = 0; /* ??? */
1297: mtget->mt_density = 0; /* ??? */
1298: break;
1299:
1300: case MTIOCIEOT: /* ignore EOT error */
1301: debug (("MTIOCIEOT not implemented.\n"));
1302: return (ENXIO);
1303:
1304: case MTIOCEEOT: /* enable EOT error */
1305: debug (("MTIOCEEOT not implemented.\n"));
1306: return (ENXIO);
1307:
1308: default:
1309: debug (("invalid ioctl cmd 0x%x\n", cmd));
1310: return (ENXIO);
1311: }
1312:
1313: return (0);
1314: }
1315:
1316:
1317: /*
1318: *
1319: */
1320: int
1321: tsread (dev, uio)
1322: dev_t dev;
1323: struct uio *uio;
1324: {
1325: return (physio (tsstrategy, NULL, dev, B_READ, minphys, uio));
1326: }
1327:
1328: /*
1329: *
1330: */
1331: int
1332: tswrite (dev, uio)
1333: dev_t dev;
1334: struct uio *uio;
1335: {
1336: return (physio (tsstrategy, NULL, dev, B_WRITE, minphys, uio));
1337: }
1338:
1339: /*
1340: *
1341: */
1342: int
1343: tsdump(dev, blkno, va, size)
1344: dev_t dev;
1345: daddr64_t blkno;
1346: caddr_t va;
1347: size_t size;
1348: {
1349: trace (("tsdump (%x)\n", dev));
1350: return 0;
1351: }
1352:
1353: /*----------------------------------------------------------------------*/
1354:
1355: int
1356: tsstatus (sr)
1357: int sr;
1358: {
1359: #ifdef DEBUG
1360: char bits[64];
1361:
1362: debug (("status: TSSR=%s\n", bitmask_snprintf(sr, TS_TSSR_BITS,
1363: bits, sizeof(bits))));
1364:
1365: if (tsdebug < 5)
1366: return (0);
1367:
1368: if (sr & TS_SC) printf ("special condition\n");
1369: if (sr & TS_UPE) printf ("UPE\n");
1370: if (sr & TS_SCE) printf ("Sanity Check Error\n");
1371: if (sr & TS_RMR) printf ("Register Modification Refused\n");
1372: if (sr & TS_NXM) printf ("Nonexistent Memory\n");
1373: if (sr & TS_NBA) printf ("Need Buffer Address\n");
1374: if (sr & TS_A11) printf ("Address Bits 17-16\n");
1375: if (sr & TS_SSR) printf ("Subsystem Ready\n");
1376: if (sr & TS_OFL) printf ("Off Line\n");
1377: if (sr & TS_FTC) printf ("Fatal Termination Class Code\n");
1378: switch (sr & TS_TC) {
1379: case TS_TC_NORM: printf ("Normal Termination\n"); break;
1380: case TS_TC_ATTN: printf ("Attention Condition\n"); break;
1381: case TS_TC_TSA: printf ("Tape status \n"); break;
1382: case TS_TC_FR: printf ("Function reject\n"); break;
1383: case TS_TC_TPD: printf ("Tape position down\n"); break;
1384: case TS_TC_TNM: printf ("Tape not moved\n"); break;
1385: case TS_TC_TPL: printf ("Tape position lost\n"); break;
1386: case TS_TC_FCE: printf ("Fatal Controller Error\n"); break;
1387: }
1388: #endif
1389: return (0);
1390: }
1391:
1392: void
1393: tsxstatus (mp)
1394: struct tsmsg *mp;
1395: {
1396: #ifdef DEBUG
1397: char bits[64];
1398:
1399: debug (("tsxstatus: xst0=%s, ", bitmask_snprintf(mp->xst0,
1400: TS_XST0_BITS, bits, sizeof(bits))));
1401: debug (("xst1=%s, ", bitmask_snprintf(mp->xst1, TS_XST1_BITS,
1402: bits, sizeof(bits))));
1403: debug (("xst2=%s, ", bitmask_snprintf(mp->xst2, TS_XST2_BITS,
1404: bits, sizeof(bits))));
1405: debug (("xst3=%s, ", bitmask_snprintf(mp->xst3, TS_XST3_BITS,
1406: bits, sizeof(bits))));
1407: debug (("xst4=%s\n", bitmask_snprintf(mp->xst4, "\20",
1408: bits, sizeof(bits))));
1409:
1410: if (tsdebug < 10)
1411: return (0);
1412:
1413: if (mp->xst0 & TS_SF_TMK) printf ("Tape Mark Detected\n");
1414: if (mp->xst0 & TS_SF_RLS) printf ("Record Length Short\n");
1415: if (mp->xst0 & TS_SF_LET) printf ("Logical End of Tape\n");
1416: if (mp->xst0 & TS_SF_RLL) printf ("Record Length Long\n");
1417: if (mp->xst0 & TS_SF_WLE) printf ("Write Lock Error\n");
1418: if (mp->xst0 & TS_SF_NEF) printf ("Nonexecutable Function\n");
1419: if (mp->xst0 & TS_SF_ILC) printf ("Illegal Command\n");
1420: if (mp->xst0 & TS_SF_ILA) printf ("Illegal Address\n");
1421: if (mp->xst0 & TS_SF_MOT) printf ("Motion\n");
1422: if (mp->xst0 & TS_SF_ONL) printf ("On-Line\n");
1423: if (mp->xst0 & TS_SF_IE) printf ("Interrupt Enable\n");
1424: if (mp->xst0 & TS_SF_VCK) printf ("Volume Check\n");
1425: if (mp->xst0 & TS_SF_PED) printf ("Phase Encoded Drive\n");
1426: if (mp->xst0 & TS_SF_WLK) printf ("Write Locked\n");
1427: if (mp->xst0 & TS_SF_BOT) printf ("Beginning of Tape\n");
1428: if (mp->xst0 & TS_SF_EOT) printf ("End of Tape\n");
1429:
1430: if (mp->xst1 & TS_SF_DLT) printf ("Data Late\n");
1431: if (mp->xst1 & TS_SF_COR) printf ("Correctable Data\n");
1432: if (mp->xst1 & TS_SF_RBP) printf ("Read Bus Parity Error\n");
1433: if (mp->xst1 & TS_SF_UNC) printf ("Uncorrectable Data or Hard Error\n");
1434:
1435: if (mp->xst2 & TS_SF_OPM) printf ("Operation in Progress\n");
1436: if (mp->xst2 & TS_SF_RCE) printf ("RAM Checksum Error\n");
1437: if (mp->xst2 & TS_SF_WCF) printf ("Write Clock Failure\n");
1438: if (mp->xst2 & TS_SF_EFES) printf ("extended features enabled\n");
1439: if (mp->xst2 & TS_SF_BES) printf ("Buffering enabled\n");
1440:
1441: printf ("micro-code revision level: %d\n", (mp->xst2 & TS_SF_MCRL)>>2);
1442: printf ("unit number: %d\n", (mp->xst2 & TS_SF_UNIT));
1443:
1444: if (mp->xst3 & TS_SF_MDE)
1445: printf ("Micro-Diagnostics Error Code: 0x%x\n", mp->xst3 >> 8);
1446: if (mp->xst3 & TS_SF_OPI) printf ("Operation Incomplete\n");
1447: if (mp->xst3 & TS_SF_REV) printf ("Revers\n");
1448: if (mp->xst3 & TS_SF_DCK) printf ("Density Check\n");
1449: if (mp->xst3 & TS_SF_RIB) printf ("Reverse into BOT\n");
1450:
1451: if (mp->xst4 & TS_SF_HSP) printf ("High Speed\n");
1452: if (mp->xst4 & TS_SF_RCX) printf ("Retry Count Exceeded\n");
1453: #endif
1454: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ts.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / uba