![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba|
Return to ts.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba |
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: * @(#)ts.c 7.13 (Berkeley) 7/1/90
7: */
8:
9: #include "ts.h"
10: #if NTS > 0
11: /*
12: * TS11 tape driver
13: *
14: * NB: This driver takes advantage of the fact that there is only one
15: * drive per controller.
16: *
17: * TODO:
18: * test dump code
19: */
20: #include "param.h"
21: #include "systm.h"
22: #include "buf.h"
23: #include "conf.h"
24: #include "errno.h"
25: #include "file.h"
26: #include "map.h"
27: #include "vm.h"
28: #include "ioctl.h"
29: #include "mtio.h"
30: #include "cmap.h"
31: #include "uio.h"
32: #include "syslog.h"
33: #include "tprintf.h"
34:
35: #include "machine/pte.h"
36: #include "../vax/cpu.h"
37: #include "ubareg.h"
38: #include "ubavar.h"
39: #include "tsreg.h"
40:
41: /*
42: * There is a ctsbuf per tape controller.
43: * It is used as the token to pass to the internal routines
44: * to execute tape ioctls.
45: * In particular, when the tape is rewinding on close we release
46: * the user process but any further attempts to use the tape drive
47: * before the rewind completes will hang waiting for ctsbuf.
48: */
49: struct buf ctsbuf[NTS];
50:
51: /*
52: * Driver unibus interface routines and variables.
53: */
54: int tsprobe(), tsslave(), tsattach(), tsdgo(), tsintr();
55: struct uba_ctlr *tsminfo[NTS];
56: struct uba_device *tsdinfo[NTS];
57: struct buf tsutab[NTS];
58: u_short tsstd[] = { 0772520, 0 };
59: /* need all these even though controller == drive */
60: struct uba_driver zsdriver =
61: { tsprobe, tsslave, tsattach, tsdgo, tsstd, "ts", tsdinfo, "zs", tsminfo };
62:
63: /* bits in minor device */
64: #define TSUNIT(dev) (minor(dev)&03)
65: #define T_NOREWIND 04
66: #define T_1600BPI 010
67:
68: #define INF (daddr_t)1000000L
69:
70: /*
71: * Software state per tape transport.
72: * Also contains hardware state in message packets.
73: *
74: * 1. A tape drive is a unique-open device; we refuse opens when it is already.
75: * 2. We keep track of the current position on a block tape and seek
76: * before operations by forward/back spacing if necessary.
77: * 3. We remember if the last operation was a write on a tape, so if a tape
78: * is open read write and the last thing done is a write we can
79: * write a standard end of tape mark (two eofs).
80: * 4. We remember the status registers after the last command, using
81: * then internally and returning them to the SENSE ioctl.
82: */
83: struct ts_tsdata { /* data shared with ts11 controller */
84: struct ts_cmd t_cmd; /* the command packet (must be first) */
85: struct ts_sts t_sts; /* status packet, for returned status */
86: struct ts_char t_char; /* characteristics packet */
87: };
88: struct ts_softc {
89: char sc_openf; /* lock against multiple opens */
90: char sc_lastiow; /* last op was a write */
91: short sc_resid; /* copy of last bc */
92: daddr_t sc_blkno; /* block number, for block device tape */
93: daddr_t sc_nxrec; /* position of end of tape, if known */
94: struct ts_tsdata sc_ts;/* command and status packets */
95: struct ts_tsdata *sc_ubaddr; /* Unibus address of tsdata structure */
96: u_short sc_uba; /* Unibus addr of cmd pkt for tsdb */
97: short sc_density; /* value |'ed into char_mode for TC13 density */
98: tpr_t sc_tpr; /* tprintf handle */
99: int sc_blks; /* number of I/O operations since open */
100: int sc_softerrs; /* number of soft I/O errors since open */
101: } ts_softc[NTS];
102:
103: /*
104: * States for um->um_tab.b_active, the per controller state flag.
105: * This is used to sequence control in the driver.
106: */
107: #define SSEEK 1 /* seeking */
108: #define SIO 2 /* doing seq i/o */
109: #define SCOM 3 /* sending control command */
110: #define SREW 4 /* sending a drive rewind */
111:
112: /*
113: * Determine if there is a controller for
114: * a ts at address reg. Our goal is to make the
115: * device interrupt.
116: */
117: /*ARGSUSED*/
118: tsprobe(reg, ctlr, um)
119: caddr_t reg;
120: int ctlr;
121: struct uba_ctlr *um;
122: {
123: register int br, cvec; /* must be r11,r10; value-result */
124: register struct tsdevice *addr = (struct tsdevice *)reg;
125: register struct ts_softc *sc;
126: register int i;
127: int a;
128:
129: #ifdef lint
130: br = 0; cvec = br; br = cvec;
131: tsintr(0);
132: #endif
133: addr->tssr = 0; /* initialize subsystem */
134: DELAY(100);
135: if ((addr->tssr & TS_NBA) == 0)
136: return (0);
137:
138: /*
139: * Make it interrupt.
140: * TS_SETCHR|TS_IE alone refuses to interrupt for me.
141: */
142: sc = &ts_softc[ctlr];
143: tsmap(sc, numuba, &a);
144: i = (int)&sc->sc_ubaddr->t_char;
145: sc->sc_ts.t_cmd.c_loba = i;
146: sc->sc_ts.t_cmd.c_hiba = (i >> 16) & 3;
147: sc->sc_ts.t_cmd.c_size = sizeof(struct ts_char);
148: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_SETCHR;
149: sc->sc_ts.t_char.char_addr = (int)&sc->sc_ubaddr->t_sts;
150: sc->sc_ts.t_char.char_size = sizeof(struct ts_sts);
151: sc->sc_ts.t_char.char_mode = 0; /* mode is unimportant */
152: addr->tsdb = sc->sc_uba;
153: DELAY(20000);
154: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_IE | TS_SENSE;
155: sc->sc_ts.t_cmd.c_repcnt = 1;
156: addr->tsdb = sc->sc_uba;
157: DELAY(20000);
158: /* should have interrupted by now */
159:
160: if (cvec == 0 || cvec == 0x200) /* no interrupt */
161: ubarelse(numuba, &a);
162:
163: return (sizeof (struct tsdevice));
164: }
165:
166: /*
167: * Map in the command, status, and characteristics packet. We
168: * make them contiguous to keep overhead down. This also sets
169: * sc_uba (which then never changes).
170: */
171: tsmap(sc, uban, a)
172: register struct ts_softc *sc;
173: int uban, *a;
174: {
175: register int i;
176:
177: i = uballoc(uban, (caddr_t)&sc->sc_ts, sizeof(sc->sc_ts), 0);
178: if (a != NULL)
179: *a = i;
180: i = UBAI_ADDR(i);
181: sc->sc_ubaddr = (struct ts_tsdata *)i;
182: /*
183: * Note that i == the Unibus address of the command packet,
184: * and that it is a multiple of 4 (guaranteed by the compiler).
185: */
186: sc->sc_uba = i + ((i >> 16) & 3);
187: }
188:
189: /*
190: * TS11 only supports one drive per controller;
191: * check for ui_slave == 0.
192: */
193: /*ARGSUSED*/
194: tsslave(ui, reg)
195: struct uba_device *ui;
196: caddr_t reg;
197: {
198:
199: return (ui->ui_slave == 0); /* non-zero slave not allowed */
200: }
201:
202: /*
203: * Record attachment of the unit to the controller.
204: */
205: /*ARGSUSED*/
206: tsattach(ui)
207: struct uba_device *ui;
208: {
209:
210: /* void */
211: }
212:
213: /*
214: * Open the device. Tapes are unique open
215: * devices, so we refuse if it is already open.
216: */
217: tsopen(dev, flag)
218: dev_t dev;
219: int flag;
220: {
221: register int tsunit = TSUNIT(dev);
222: register struct uba_device *ui;
223: register struct ts_softc *sc;
224:
225: if (tsunit >= NTS || (ui = tsdinfo[tsunit]) == 0 || ui->ui_alive == 0)
226: return (ENXIO);
227: if ((sc = &ts_softc[ui->ui_ctlr])->sc_openf)
228: return (EBUSY);
229: sc->sc_openf = 1;
230: sc->sc_density = (minor(dev) & T_1600BPI) ? TS_NRZI : 0;
231: tscommand(dev, TS_SENSE, 1);
232: if (ctsbuf[tsunit].b_flags & B_ERROR)
233: /*
234: * Try it again in case it went off-line
235: */
236: tscommand(dev, TS_SENSE, 1);
237: if (tsinit(ui->ui_ctlr)) {
238: sc->sc_openf = 0;
239: return (ENXIO);
240: }
241: if ((sc->sc_ts.t_sts.s_xs0&TS_ONL) == 0) {
242: sc->sc_openf = 0;
243: uprintf("ts%d: not online\n", tsunit);
244: return (EIO);
245: }
246: if ((flag&FWRITE) && (sc->sc_ts.t_sts.s_xs0&TS_WLK)) {
247: sc->sc_openf = 0;
248: uprintf("ts%d: no write ring\n", tsunit);
249: return (EIO);
250: }
251: sc->sc_blkno = (daddr_t)0;
252: sc->sc_nxrec = INF;
253: sc->sc_lastiow = 0;
254: sc->sc_blks = 0;
255: sc->sc_softerrs = 0;
256: sc->sc_tpr = tprintf_open();
257: return (0);
258: }
259:
260: /*
261: * Close tape device.
262: *
263: * If tape was open for writing or last operation was
264: * a write, then write two EOF's and backspace over the last one.
265: * Unless this is a non-rewinding special file, rewind the tape.
266: * Make the tape available to others.
267: */
268: tsclose(dev, flag)
269: register dev_t dev;
270: register int flag;
271: {
272: register struct ts_softc *sc = &ts_softc[TSUNIT(dev)];
273:
274: if (flag == FWRITE || (flag&FWRITE) && sc->sc_lastiow) {
275: tscommand(dev, TS_WEOF, 1);
276: tscommand(dev, TS_WEOF, 1);
277: tscommand(dev, TS_SREV, 1);
278: }
279: if ((minor(dev)&T_NOREWIND) == 0)
280: /*
281: * 0 count means don't hang waiting for rewind complete
282: * rather ctsbuf stays busy until the operation completes
283: * preventing further opens from completing by
284: * preventing a TS_SENSE from completing.
285: */
286: tscommand(dev, TS_REW, 0);
287: if (sc->sc_blks > 100 && sc->sc_softerrs > sc->sc_blks / 100)
288: log(LOG_INFO, "ts%d: %d soft errors in %d blocks\n",
289: TSUNIT(dev), sc->sc_softerrs, sc->sc_blks);
290: tprintf_close(sc->sc_tpr);
291: sc->sc_openf = 0;
292: return (0);
293: }
294:
295: /*
296: * Initialize a TS11. Set device characteristics.
297: */
298: tsinit(ctlr)
299: register int ctlr;
300: {
301: register struct ts_softc *sc = &ts_softc[ctlr];
302: register struct uba_ctlr *um = tsminfo[ctlr];
303: register struct tsdevice *addr = (struct tsdevice *)um->um_addr;
304: register int i;
305:
306: if (addr->tssr & (TS_NBA|TS_OFL) || sc->sc_ts.t_sts.s_xs0 & TS_BOT) {
307: addr->tssr = 0; /* subsystem initialize */
308: tswait(addr);
309: i = (int)&sc->sc_ubaddr->t_char;
310: sc->sc_ts.t_cmd.c_loba = i;
311: sc->sc_ts.t_cmd.c_hiba = (i >> 16) & 3;
312: sc->sc_ts.t_cmd.c_size = sizeof(struct ts_char);
313: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_SETCHR;
314: sc->sc_ts.t_char.char_addr = (int)&sc->sc_ubaddr->t_sts;
315: sc->sc_ts.t_char.char_size = sizeof(struct ts_sts);
316: sc->sc_ts.t_char.char_mode = TS_ESS | TS_EAI | TS_ERI |
317: /* TS_ENB | */ sc->sc_density;
318: addr->tsdb = sc->sc_uba;
319: tswait(addr);
320: if (addr->tssr & TS_NBA)
321: return(1);
322: }
323: return(0);
324: }
325:
326: /*
327: * Execute a command on the tape drive
328: * a specified number of times.
329: */
330: tscommand(dev, com, count)
331: dev_t dev;
332: int com, count;
333: {
334: register struct buf *bp;
335: register int s;
336: int didsleep = 0;
337:
338: bp = &ctsbuf[TSUNIT(dev)];
339: s = spl5();
340: while (bp->b_flags&B_BUSY) {
341: /*
342: * This special check is because B_BUSY never
343: * gets cleared in the non-waiting rewind case.
344: */
345: if (bp->b_repcnt == 0 && (bp->b_flags&B_DONE))
346: break;
347: bp->b_flags |= B_WANTED;
348: sleep((caddr_t)bp, PRIBIO);
349: didsleep = 1;
350: }
351: bp->b_flags = B_BUSY|B_READ;
352: splx(s);
353: if (didsleep)
354: (void) tsinit(tsdinfo[TSUNIT(dev)]->ui_ctlr);
355: bp->b_dev = dev;
356: bp->b_repcnt = count;
357: bp->b_command = com;
358: bp->b_blkno = 0;
359: tsstrategy(bp);
360: /*
361: * In case of rewind from close, don't wait.
362: * This is the only case where count can be 0.
363: */
364: if (count == 0)
365: return;
366: biowait(bp);
367: if (bp->b_flags&B_WANTED)
368: wakeup((caddr_t)bp);
369: bp->b_flags &= B_ERROR;
370: }
371:
372: /*
373: * Queue a tape operation.
374: */
375: tsstrategy(bp)
376: register struct buf *bp;
377: {
378: register int tsunit = TSUNIT(bp->b_dev);
379: register struct uba_ctlr *um;
380: register struct buf *dp;
381: int s;
382:
383: /*
384: * Put transfer at end of controller queue
385: */
386: bp->av_forw = NULL;
387: um = tsdinfo[tsunit]->ui_mi;
388: dp = &tsutab[tsunit];
389: s = spl5();
390: if (dp->b_actf == NULL)
391: dp->b_actf = bp;
392: else
393: dp->b_actl->av_forw = bp;
394: dp->b_actl = bp;
395: um->um_tab.b_actf = um->um_tab.b_actl = dp;
396: /*
397: * If the controller is not busy, get
398: * it going.
399: */
400: if (um->um_tab.b_active == 0)
401: tsstart(um);
402: splx(s);
403: }
404:
405: /*
406: * Start activity on a ts controller.
407: */
408: tsstart(um)
409: register struct uba_ctlr *um;
410: {
411: register struct buf *bp;
412: register struct tsdevice *addr = (struct tsdevice *)um->um_addr;
413: register struct ts_softc *sc;
414: register struct uba_device *ui;
415: register int tsunit;
416: int cmd;
417: daddr_t blkno;
418:
419: /*
420: * Start the controller if there is something for it to do.
421: */
422: loop:
423: if ((bp = um->um_tab.b_actf->b_actf) == NULL) {
424: um->um_tab.b_active = 0;
425: return;
426: }
427: tsunit = TSUNIT(bp->b_dev);
428: ui = tsdinfo[tsunit];
429: sc = &ts_softc[tsunit];
430: /*
431: * Default is that last command was NOT a write command;
432: * if we finish a write command we will notice this in tsintr().
433: */
434: sc->sc_lastiow = 0;
435: if (sc->sc_openf < 0 || (addr->tssr&TS_OFL)) {
436: /*
437: * Have had a hard error on a non-raw tape
438: * or the tape unit is now unavailable
439: * (e.g. taken off line).
440: */
441: bp->b_flags |= B_ERROR;
442: goto next;
443: }
444: if (bp == &ctsbuf[tsunit]) {
445: /*
446: * Execute control operation with the specified count.
447: */
448: um->um_tab.b_active =
449: bp->b_command == TS_REW ? SREW : SCOM;
450: sc->sc_ts.t_cmd.c_repcnt = bp->b_repcnt;
451: goto dobpcmd;
452: }
453: /*
454: * For raw I/O, save the current block
455: * number in case we have to retry.
456: */
457: if (bp->b_flags & B_RAW) {
458: if (um->um_tab.b_errcnt == 0)
459: sc->sc_blkno = bdbtofsb(bp->b_blkno);
460: } else {
461: /*
462: * Handle boundary cases for operation
463: * on non-raw tapes.
464: */
465: if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) {
466: /*
467: * Can't read past known end-of-file.
468: */
469: bp->b_flags |= B_ERROR;
470: bp->b_error = ENXIO;
471: goto next;
472: }
473: if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec &&
474: bp->b_flags&B_READ) {
475: /*
476: * Reading at end of file returns 0 bytes.
477: */
478: bp->b_resid = bp->b_bcount;
479: clrbuf(bp);
480: goto next;
481: }
482: if ((bp->b_flags&B_READ) == 0)
483: /*
484: * Writing sets EOF
485: */
486: sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1;
487: }
488:
489: /*
490: * If the data transfer command is in the correct place,
491: * set up all the registers except the csr, and give
492: * control over to the UNIBUS adapter routines, to
493: * wait for resources to start the i/o.
494: */
495: if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) {
496: sc->sc_ts.t_cmd.c_size = bp->b_bcount;
497: if ((bp->b_flags&B_READ) == 0)
498: cmd = TS_WCOM;
499: else
500: cmd = TS_RCOM;
501: if (um->um_tab.b_errcnt)
502: cmd |= TS_RETRY;
503: um->um_tab.b_active = SIO;
504: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_IE | cmd;
505: (void) ubago(ui);
506: return;
507: }
508: /*
509: * Tape positioned incorrectly;
510: * set to seek forwards or backwards to the correct spot.
511: * This happens for raw tapes only on error retries.
512: */
513: um->um_tab.b_active = SSEEK;
514: if (blkno < bdbtofsb(bp->b_blkno)) {
515: bp->b_command = TS_SFORW;
516: sc->sc_ts.t_cmd.c_repcnt = bdbtofsb(bp->b_blkno) - blkno;
517: } else {
518: bp->b_command = TS_SREV;
519: sc->sc_ts.t_cmd.c_repcnt = blkno - bdbtofsb(bp->b_blkno);
520: }
521: dobpcmd:
522: /*
523: * Do the command in bp.
524: */
525: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_IE | bp->b_command;
526: addr->tsdb = sc->sc_uba;
527: return;
528:
529: next:
530: /*
531: * Done with this operation due to error or
532: * the fact that it doesn't do anything.
533: * Release UBA resources (if any), dequeue
534: * the transfer and continue processing this slave.
535: */
536: if (um->um_ubinfo)
537: ubadone(um);
538: um->um_tab.b_errcnt = 0;
539: um->um_tab.b_actf->b_actf = bp->av_forw;
540: biodone(bp);
541: goto loop;
542: }
543:
544: /*
545: * The UNIBUS resources we needed have been
546: * allocated to us; start the device.
547: */
548: tsdgo(um)
549: register struct uba_ctlr *um;
550: {
551: register struct ts_softc *sc = &ts_softc[um->um_ctlr];
552: register int i;
553:
554: /*
555: * The uba code uses byte-offset mode if using bdp;
556: * mask off the low bit here.
557: */
558: i = UBAI_ADDR(um->um_ubinfo);
559: if (UBAI_BDP(um->um_ubinfo))
560: i &= ~1;
561: sc->sc_ts.t_cmd.c_loba = i;
562: sc->sc_ts.t_cmd.c_hiba = (i >> 16) & 3;
563: ((struct tsdevice *)um->um_addr)->tsdb = sc->sc_uba;
564: }
565:
566: /*
567: * Ts interrupt routine.
568: */
569: /*ARGSUSED*/
570: tsintr(tsunit)
571: register int tsunit;
572: {
573: register struct buf *bp;
574: register struct uba_ctlr *um;
575: register struct tsdevice *addr;
576: register struct ts_softc *sc;
577: register int state;
578:
579: #ifdef QBA
580: (void) spl5();
581: #endif
582: um = tsdinfo[tsunit]->ui_mi;
583: if ((bp = um->um_tab.b_actf->b_actf) == NULL)
584: return;
585: addr = (struct tsdevice *)um->um_addr;
586: /*
587: * If last command was a rewind, and tape is still
588: * rewinding, wait for the rewind complete interrupt.
589: *
590: * SHOULD NEVER GET AN INTERRUPT IN THIS STATE.
591: */
592: if (um->um_tab.b_active == SREW) {
593: um->um_tab.b_active = SCOM;
594: if ((addr->tssr&TS_SSR) == 0)
595: return;
596: }
597: /*
598: * An operation completed... record status
599: */
600: sc = &ts_softc[um->um_ctlr];
601: if ((bp->b_flags & B_READ) == 0)
602: sc->sc_lastiow = 1;
603: state = um->um_tab.b_active;
604: /*
605: * Check for errors.
606: */
607: if (addr->tssr&TS_SC) {
608: switch (addr->tssr & TS_TC) {
609: case TS_UNREC: /* unrecoverable */
610: case TS_FATAL: /* fatal error */
611: case TS_RECNM: /* recoverable, no motion */
612: break;
613: case TS_ATTN: /* attention */
614: if (sc->sc_ts.t_sts.s_xs0 & TS_VCK) {
615: /* volume check - may have changed tapes */
616: bp->b_flags |= B_ERROR;
617: goto ignoreerr;
618: }
619: break;
620:
621: case TS_SUCC: /* success termination */
622: printf("ts%d: success\n", tsunit);
623: goto ignoreerr;
624:
625: case TS_ALERT: /* tape status alert */
626: /*
627: * If we hit the end of the tape file,
628: * update our position.
629: */
630: if (sc->sc_ts.t_sts.s_xs0 & (TS_TMK|TS_EOT)) {
631: tsseteof(bp); /* set blkno and nxrec */
632: state = SCOM; /* force completion */
633: /*
634: * Stuff bc so it will be unstuffed correctly
635: * later to get resid.
636: */
637: sc->sc_ts.t_sts.s_rbpcr = bp->b_bcount;
638: goto opdone;
639: }
640: /*
641: * If we were reading raw tape and the record was too
642: * long or too short, we don't consider this an error.
643: */
644: if ((bp->b_flags & (B_READ|B_RAW)) == (B_READ|B_RAW) &&
645: sc->sc_ts.t_sts.s_xs0&(TS_RLS|TS_RLL))
646: goto ignoreerr;
647: /* FALLTHROUGH */
648:
649: case TS_RECOV: /* recoverable, tape moved */
650: /*
651: * If this was an i/o operation retry up to 8 times.
652: */
653: if (state == SIO) {
654: if (++um->um_tab.b_errcnt < 7) {
655: ubadone(um);
656: goto opcont;
657: } else
658: sc->sc_blkno++;
659: } else {
660: /*
661: * Non-i/o errors on non-raw tape
662: * cause it to close.
663: */
664: if ((bp->b_flags&B_RAW) == 0 &&
665: sc->sc_openf > 0)
666: sc->sc_openf = -1;
667: }
668: break;
669:
670: case TS_REJECT: /* function reject */
671: if (state == SIO && sc->sc_ts.t_sts.s_xs0 & TS_WLE)
672: tprintf(sc->sc_tpr, "ts%d: write locked\n",
673: tsunit);
674: if ((sc->sc_ts.t_sts.s_xs0 & TS_ONL) == 0)
675: tprintf(sc->sc_tpr, "ts%d: offline\n",
676: tsunit);
677: break;
678: }
679: /*
680: * Couldn't recover error
681: */
682: tprintf(sc->sc_tpr, "ts%d: hard error bn%d tssr=%b xs0=%b",
683: tsunit, bp->b_blkno, addr->tssr, TSSR_BITS,
684: sc->sc_ts.t_sts.s_xs0, TSXS0_BITS);
685: if (sc->sc_ts.t_sts.s_xs1)
686: tprintf(sc->sc_tpr, " xs1=%b", sc->sc_ts.t_sts.s_xs1,
687: TSXS1_BITS);
688: if (sc->sc_ts.t_sts.s_xs2)
689: tprintf(sc->sc_tpr, " xs2=%b", sc->sc_ts.t_sts.s_xs2,
690: TSXS2_BITS);
691: if (sc->sc_ts.t_sts.s_xs3)
692: tprintf(sc->sc_tpr, " xs3=%b", sc->sc_ts.t_sts.s_xs3,
693: TSXS3_BITS);
694: tprintf(sc->sc_tpr, "\n");
695: bp->b_flags |= B_ERROR;
696: goto opdone;
697: }
698: /*
699: * Advance tape control FSM.
700: */
701: ignoreerr:
702: switch (state) {
703:
704: case SIO:
705: /*
706: * Read/write increments tape block number
707: */
708: sc->sc_blkno++;
709: sc->sc_blks++;
710: if (um->um_tab.b_errcnt)
711: sc->sc_softerrs++;
712: goto opdone;
713:
714: case SCOM:
715: /*
716: * For forward/backward space record update current position.
717: */
718: if (bp == &ctsbuf[tsunit])
719: switch ((int)bp->b_command) {
720:
721: case TS_SFORW:
722: sc->sc_blkno += bp->b_repcnt;
723: break;
724:
725: case TS_SREV:
726: sc->sc_blkno -= bp->b_repcnt;
727: break;
728: }
729: goto opdone;
730:
731: case SSEEK:
732: sc->sc_blkno = bdbtofsb(bp->b_blkno);
733: goto opcont;
734:
735: default:
736: panic("tsintr");
737: }
738: opdone:
739: /*
740: * Reset error count and remove
741: * from device queue.
742: */
743: um->um_tab.b_errcnt = 0;
744: um->um_tab.b_actf->b_actf = bp->av_forw;
745: bp->b_resid = sc->sc_ts.t_sts.s_rbpcr;
746: ubadone(um);
747: biodone(bp);
748: if (um->um_tab.b_actf->b_actf == 0) {
749: um->um_tab.b_active = 0;
750: return;
751: }
752: opcont:
753: tsstart(um);
754: }
755:
756: tsseteof(bp)
757: register struct buf *bp;
758: {
759: register int tsunit = TSUNIT(bp->b_dev);
760: register struct ts_softc *sc = &ts_softc[tsdinfo[tsunit]->ui_ctlr];
761:
762: if (bp == &ctsbuf[tsunit]) {
763: if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) {
764: /* reversing */
765: sc->sc_nxrec = bdbtofsb(bp->b_blkno) -
766: sc->sc_ts.t_sts.s_rbpcr;
767: sc->sc_blkno = sc->sc_nxrec;
768: } else {
769: /* spacing forward */
770: sc->sc_blkno = bdbtofsb(bp->b_blkno) +
771: sc->sc_ts.t_sts.s_rbpcr;
772: sc->sc_nxrec = sc->sc_blkno - 1;
773: }
774: return;
775: }
776: /* eof on read */
777: sc->sc_nxrec = bdbtofsb(bp->b_blkno);
778: }
779:
780: tsreset(uban)
781: int uban;
782: {
783: register struct uba_ctlr *um;
784: register struct uba_device *ui;
785: register int ts11, i;
786:
787: for (ts11 = 0; ts11 < NTS; ts11++) {
788: if ((um = tsminfo[ts11]) == 0 || um->um_alive == 0 ||
789: um->um_ubanum != uban)
790: continue;
791: printf(" ts%d", ts11);
792: um->um_tab.b_active = 0;
793: um->um_tab.b_actf = um->um_tab.b_actl = 0;
794: if (ts_softc[ts11].sc_openf > 0)
795: ts_softc[ts11].sc_openf = -1;
796: if (um->um_ubinfo) {
797: printf("<%d>", UBAI_BDP(um->um_ubinfo));
798: um->um_ubinfo = 0;
799: }
800: /*
801: * tsdinfo should be 1-to-1 with tsminfo, but someone
802: * might have screwed up the config file:
803: */
804: for (i = 0; i < NTS; i++) {
805: if ((ui = tsdinfo[i]) != NULL &&
806: ui->ui_alive && ui->ui_mi == um) {
807: um->um_tab.b_actf = um->um_tab.b_actl =
808: &tsutab[i];
809: break;
810: }
811: }
812: tsmap(&ts_softc[ts11], uban, (int *)NULL);
813: (void) tsinit(ts11);
814: tsstart(um);
815: }
816: }
817:
818: /*ARGSUSED*/
819: tsioctl(dev, cmd, data, flag)
820: caddr_t data;
821: dev_t dev;
822: {
823: int tsunit = TSUNIT(dev);
824: register struct ts_softc *sc = &ts_softc[tsdinfo[tsunit]->ui_ctlr];
825: register struct buf *bp = &ctsbuf[TSUNIT(dev)];
826: register int callcount;
827: int fcount, error = 0;
828: struct mtop *mtop;
829: struct mtget *mtget;
830: /* we depend of the values and order of the MT codes here */
831: static int tsops[] =
832: {TS_WEOF,TS_SFORWF,TS_SREVF,TS_SFORW,TS_SREV,TS_REW,TS_OFFL,TS_SENSE};
833:
834: switch (cmd) {
835:
836: case MTIOCTOP: /* tape operation */
837: mtop = (struct mtop *)data;
838: switch (mtop->mt_op) {
839:
840: case MTWEOF:
841: callcount = mtop->mt_count;
842: fcount = 1;
843: break;
844:
845: case MTFSF: case MTBSF:
846: case MTFSR: case MTBSR:
847: callcount = 1;
848: fcount = mtop->mt_count;
849: break;
850:
851: case MTREW: case MTOFFL: case MTNOP:
852: callcount = 1;
853: fcount = 1;
854: break;
855:
856: default:
857: return (ENXIO);
858: }
859: if (callcount <= 0 || fcount <= 0)
860: return (EINVAL);
861: while (--callcount >= 0) {
862: tscommand(dev, tsops[mtop->mt_op], fcount);
863: if ((mtop->mt_op == MTFSR || mtop->mt_op == MTBSR) &&
864: bp->b_resid)
865: return (EIO);
866: if ((bp->b_flags&B_ERROR) ||
867: sc->sc_ts.t_sts.s_xs0&TS_BOT)
868: break;
869: }
870: if (bp->b_flags&B_ERROR)
871: if ((error = bp->b_error)==0)
872: return (EIO);
873: return (error);
874:
875: case MTIOCGET:
876: mtget = (struct mtget *)data;
877: mtget->mt_dsreg = 0;
878: mtget->mt_erreg = sc->sc_ts.t_sts.s_xs0;
879: mtget->mt_resid = sc->sc_resid;
880: mtget->mt_type = MT_ISTS;
881: break;
882:
883: default:
884: return (ENXIO);
885: }
886: return (0);
887: }
888:
889: #define DBSIZE 20
890:
891: tsdump(dev)
892: dev_t dev;
893: {
894: register struct uba_device *ui;
895: register struct uba_regs *uba;
896: register struct tsdevice *addr;
897: register int i;
898: register struct pte *io;
899: int blk, num, unit, reg, start;
900: u_short db;
901: struct ts_tsdata *tc, *tc_ubaddr;
902:
903: unit = TSUNIT(dev);
904: if (unit >= NTS)
905: return (ENXIO);
906: #define phys(a,b) ((b)((int)(a)&0x7fffffff))
907: ui = phys(tsdinfo[unit], struct uba_device *);
908: if (ui->ui_alive == 0)
909: return (ENXIO);
910: uba = phys(ui->ui_hd, struct uba_hd *)->uh_physuba;
911: ubainit(uba);
912: addr = (struct tsdevice *)ui->ui_physaddr;
913:
914: /* map a ts_tsdata structure */
915: tc = phys(&ts_softc[0].sc_ts, struct ts_tsdata *);
916: num = btoc(sizeof(struct ts_tsdata)) + 1;
917: io = &uba->uba_map[reg = NUBMREG - num];
918: for (i = 0; i < num; i++)
919: *(int *)io++ = UBAMR_MRV | (btop(tc) + i);
920: i = (((int)tc & PGOFSET) | (reg << 9));
921: tc_ubaddr = (struct ts_tsdata *)i;
922: db = i + ((i >> 16) & 3);
923:
924: /* init the drive */
925: addr->tssr = 0;
926: tswait(addr);
927: if ((addr->tssr & (TS_NBA|TS_OFL)) != TS_NBA)
928: return (EFAULT);
929:
930: /* set characteristics */
931: i = (int)&tc_ubaddr->t_char;
932: tc->t_cmd.c_loba = i;
933: tc->t_cmd.c_hiba = (i >> 16) & 3;
934: tc->t_cmd.c_size = sizeof(struct ts_char);
935: tc->t_cmd.c_cmd = TS_ACK | TS_CVC | TS_SETCHR;
936: tc->t_char.char_addr = (int)&tc_ubaddr->t_sts;
937: tc->t_char.char_size = sizeof(struct ts_sts);
938: tc->t_char.char_mode = TS_ESS;
939: addr->tsdb = db;
940: tswait(addr);
941: if (addr->tssr & TS_NBA)
942: return (ENXIO);
943:
944: /* dump */
945: tc->t_cmd.c_cmd = TS_ACK | TS_WCOM;
946: tc->t_cmd.c_repcnt = 1;
947: num = maxfree;
948: for (start = 0, num = maxfree; num > 0; start += blk, num -= blk) {
949: blk = num > DBSIZE ? DBSIZE : num;
950: io = uba->uba_map;
951: for (i = 0; i < blk; i++)
952: *(int *)io++ = UBAMR_MRV | (1 << UBAMR_DPSHIFT) |
953: (start + i);
954: *(int *)io = 0;
955: addr->tsdb = db;
956: tswait(addr);
957: }
958:
959: /* eof */
960: tc->t_cmd.c_cmd = TS_WEOF;
961: addr->tsdb = db;
962: tswait(addr);
963: addr->tsdb = db;
964: tswait(addr);
965:
966: if (addr->tssr&TS_SC)
967: return (EIO);
968: addr->tssr = 0;
969: tswait(addr);
970: return (0);
971: }
972:
973: tswait(addr)
974: register struct tsdevice *addr;
975: {
976:
977: while ((addr->tssr & TS_SSR) == 0)
978: /* void */;
979: }
980:
981: #endif /* NTS > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.