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