![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tm.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 tm.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: * @(#)tm.c 7.13 (Berkeley) 7/1/90
7: */
8:
9: #include "te.h"
10: #include "ts.h"
11: #if NTE > 0
12: /*
13: * TM11/TE10 tape driver
14: *
15: * TODO:
16: * test driver with more than one controller
17: * test reset code
18: * what happens if you offline tape during rewind?
19: * test using file system on tape
20: */
21: #include "param.h"
22: #include "systm.h"
23: #include "buf.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 "kernel.h"
34: #include "syslog.h"
35: #include "tprintf.h"
36:
37: #include "machine/pte.h"
38: #include "../vax/cpu.h"
39: #include "ubareg.h"
40: #include "ubavar.h"
41: #include "tmreg.h"
42:
43: /*
44: * There is a ctmbuf per tape controller.
45: * It is used as the token to pass to the internal routines
46: * to execute tape ioctls, and also acts as a lock on the slaves
47: * on the controller, since there is only one per controller.
48: * In particular, when the tape is rewinding on close we release
49: * the user process but any further attempts to use the tape drive
50: * before the rewind completes will hang waiting for ctmbuf.
51: */
52: struct buf ctmbuf[NTM];
53:
54: /*
55: * Driver unibus interface routines and variables.
56: */
57: int tmprobe(), tmslave(), tmattach(), tmdgo(), tmintr();
58: struct uba_ctlr *tmminfo[NTM];
59: struct uba_device *tedinfo[NTE];
60: struct buf teutab[NTE];
61: short tetotm[NTE];
62: u_short tmstd[] = { 0772520, 0 };
63: struct uba_driver tmdriver =
64: { tmprobe, tmslave, tmattach, tmdgo, tmstd, "te", tedinfo, "tm", tmminfo, 0 };
65:
66: /* bits in minor device */
67: #define TEUNIT(dev) (minor(dev)&03)
68: #define TMUNIT(dev) (tetotm[TEUNIT(dev)])
69: #define T_NOREWIND 04
70: #define T_1600BPI 0x8
71:
72: #define INF (daddr_t)1000000L
73:
74: /*
75: * Software state per tape transport.
76: *
77: * 1. A tape drive is a unique-open device; we refuse opens when it is already.
78: * 2. We keep track of the current position on a block tape and seek
79: * before operations by forward/back spacing if necessary.
80: * 3. We remember if the last operation was a write on a tape, so if a tape
81: * is open read write and the last thing done is a write we can
82: * write a standard end of tape mark (two eofs).
83: * 4. We remember the status registers after the last command, using
84: * then internally and returning them to the SENSE ioctl.
85: * 5. We remember the last density the tape was used at. If it is
86: * not a BOT when we start using it and we are writing, we don't
87: * let the density be changed.
88: */
89: struct te_softc {
90: char sc_openf; /* lock against multiple opens */
91: char sc_lastiow; /* last op was a write */
92: daddr_t sc_blkno; /* block number, for block device tape */
93: daddr_t sc_nxrec; /* position of end of tape, if known */
94: u_short sc_erreg; /* copy of last erreg */
95: u_short sc_ioerreg; /* copy of last erreg for I/O command */
96: u_short sc_dsreg; /* copy of last dsreg */
97: short sc_resid; /* copy of last bc */
98: #ifdef unneeded
99: short sc_lastcmd; /* last command to handle direction changes */
100: #endif
101: u_short sc_dens; /* prototype command with density info */
102: short sc_tact; /* timeout is active */
103: daddr_t sc_timo; /* time until timeout expires */
104: int sc_blks; /* number of I/O operations since open */
105: int sc_softerrs; /* number of soft I/O errors since open */
106: tpr_t sc_tpr; /* tprintf handle */
107: } te_softc[NTE];
108: #ifdef unneeded
109: int tmgapsdcnt; /* DEBUG */
110: #endif
111:
112: /*
113: * States for um->um_tab.b_active, the per controller state flag.
114: * This is used to sequence control in the driver.
115: */
116: #define SSEEK 1 /* seeking */
117: #define SIO 2 /* doing seq i/o */
118: #define SCOM 3 /* sending control command */
119: #define SREW 4 /* sending a drive rewind */
120:
121: /*
122: * Determine if there is a controller for
123: * a tm at address reg. Our goal is to make the
124: * device interrupt.
125: */
126: tmprobe(reg)
127: caddr_t reg;
128: {
129: register int br, cvec; /* must be r11,r10; value-result */
130:
131: #ifdef lint
132: br = 0; cvec = br; br = cvec;
133: tmintr(0);
134: #endif
135: ((struct tmdevice *)reg)->tmcs = TM_IE;
136: /*
137: * If this is a tm11, it ought to have interrupted
138: * by now, if it isn't (ie: it is a ts04) then we just
139: * hope that it didn't interrupt, so autoconf will ignore it.
140: * Just in case, we will reference one
141: * of the more distant registers, and hope for a machine
142: * check, or similar disaster if this is a ts.
143: *
144: * Note: on an 11/780, badaddr will just generate
145: * a uba error for a ts; but our caller will notice that
146: * so we won't check for it.
147: */
148: if (badaddr((caddr_t)&((struct tmdevice *)reg)->tmrd, 2))
149: return (0);
150: return (sizeof (struct tmdevice));
151: }
152:
153: /*
154: * Due to a design flaw, we cannot ascertain if the tape
155: * exists or not unless it is on line - ie: unless a tape is
156: * mounted. This is too servere a restriction to bear,
157: * so all units are assumed to exist.
158: */
159: /*ARGSUSED*/
160: tmslave(ui, reg)
161: struct uba_device *ui;
162: caddr_t reg;
163: {
164:
165: return (1);
166: }
167:
168: /*
169: * Record attachment of the unit to the controller.
170: */
171: /*ARGSUSED*/
172: tmattach(ui)
173: struct uba_device *ui;
174: {
175: /*
176: * Tetotm is used in TMUNIT to index the ctmbuf
177: * array given a te unit number.
178: */
179: tetotm[ui->ui_unit] = ui->ui_mi->um_ctlr;
180: }
181:
182: int tmtimer();
183: /*
184: * Open the device. Tapes are unique open
185: * devices, so we refuse if it is already open.
186: * We also check that a tape is available, and
187: * don't block waiting here; if you want to wait
188: * for a tape you should timeout in user code.
189: */
190:
191: #ifdef AVIV
192: int tmdens[4] = { 0x6000, 0x0000, 0x2000, 0 };
193: #endif AVIV
194: int tmdiag;
195:
196: tmopen(dev, flag)
197: dev_t dev;
198: int flag;
199: {
200: register int teunit;
201: register struct uba_device *ui;
202: register struct te_softc *sc;
203: int olddens, dens, error;
204: int s;
205:
206: teunit = TEUNIT(dev);
207: if (teunit>=NTE || (ui = tedinfo[teunit]) == 0 || ui->ui_alive == 0)
208: return (ENXIO);
209: if ((sc = &te_softc[teunit])->sc_openf)
210: return (EBUSY);
211: sc->sc_openf = 1;
212: olddens = sc->sc_dens;
213: dens = TM_IE | TM_GO | (ui->ui_slave << 8);
214: #ifndef AVIV
215: if ((minor(dev) & T_1600BPI) == 0)
216: dens |= TM_D800;
217: #else AVIV
218: dens |= tmdens[(minor(dev)>>3)&03];
219: #endif AVIV
220: sc->sc_dens = dens;
221: get:
222: tmcommand(dev, TM_SENSE, 1);
223: if (sc->sc_erreg&TMER_SDWN) {
224: if (error = tsleep((caddr_t)&lbolt, (PZERO+1) | PCATCH,
225: devopn, 0))
226: return (error);
227: goto get;
228: }
229: sc->sc_dens = olddens;
230: if ((sc->sc_erreg&(TMER_SELR|TMER_TUR)) != (TMER_SELR|TMER_TUR)) {
231: uprintf("te%d: not online\n", teunit);
232: sc->sc_openf = 0;
233: return (EIO);
234: }
235: if ((flag&FWRITE) && (sc->sc_erreg&TMER_WRL)) {
236: uprintf("te%d: no write ring\n", teunit);
237: sc->sc_openf = 0;
238: return (EIO);
239: }
240: if ((sc->sc_erreg&TMER_BOT) == 0 && (flag&FWRITE) &&
241: dens != sc->sc_dens) {
242: uprintf("te%d: can't change density in mid-tape\n", teunit);
243: sc->sc_openf = 0;
244: return (EIO);
245: }
246: sc->sc_blkno = (daddr_t)0;
247: sc->sc_nxrec = INF;
248: sc->sc_lastiow = 0;
249: sc->sc_dens = dens;
250: sc->sc_blks = 0;
251: sc->sc_softerrs = 0;
252: sc->sc_tpr = tprintf_open();
253: s = splclock();
254: if (sc->sc_tact == 0) {
255: sc->sc_timo = INF;
256: sc->sc_tact = 1;
257: timeout(tmtimer, (caddr_t)dev, 5*hz);
258: }
259: splx(s);
260: return (0);
261: }
262:
263: /*
264: * Close tape device.
265: *
266: * If tape was open for writing or last operation was
267: * a write, then write two EOF's and backspace over the last one.
268: * Unless this is a non-rewinding special file, rewind the tape.
269: * Make the tape available to others.
270: */
271: tmclose(dev, flag)
272: register dev_t dev;
273: register flag;
274: {
275: register struct te_softc *sc = &te_softc[TEUNIT(dev)];
276:
277: if (flag == FWRITE || (flag&FWRITE) && sc->sc_lastiow) {
278: tmcommand(dev, TM_WEOF, 1);
279: tmcommand(dev, TM_WEOF, 1);
280: tmcommand(dev, TM_SREV, 1);
281: }
282: if ((minor(dev)&T_NOREWIND) == 0)
283: /*
284: * 0 count means don't hang waiting for rewind complete
285: * rather ctmbuf stays busy until the operation completes
286: * preventing further opens from completing by
287: * preventing a TM_SENSE from completing.
288: */
289: tmcommand(dev, TM_REW, 0);
290: if (sc->sc_blks > 100 && sc->sc_softerrs > sc->sc_blks / 100)
291: log(LOG_INFO, "te%d: %d soft errors in %d blocks\n",
292: TEUNIT(dev), sc->sc_softerrs, sc->sc_blks);
293: tprintf_close(sc->sc_tpr);
294: sc->sc_openf = 0;
295: return (0);
296: }
297:
298: /*
299: * Execute a command on the tape drive
300: * a specified number of times.
301: */
302: tmcommand(dev, com, count)
303: dev_t dev;
304: int com, count;
305: {
306: register struct buf *bp;
307: register int s;
308:
309: bp = &ctmbuf[TMUNIT(dev)];
310: s = spl5();
311: while (bp->b_flags&B_BUSY) {
312: /*
313: * This special check is because B_BUSY never
314: * gets cleared in the non-waiting rewind case.
315: */
316: if (bp->b_repcnt == 0 && (bp->b_flags&B_DONE))
317: break;
318: bp->b_flags |= B_WANTED;
319: sleep((caddr_t)bp, PRIBIO);
320: }
321: bp->b_flags = B_BUSY|B_READ;
322: splx(s);
323: bp->b_dev = dev;
324: bp->b_repcnt = -count;
325: bp->b_command = com;
326: bp->b_blkno = 0;
327: tmstrategy(bp);
328: /*
329: * In case of rewind from close, don't wait.
330: * This is the only case where count can be 0.
331: */
332: if (count == 0)
333: return;
334: iowait(bp);
335: if (bp->b_flags&B_WANTED)
336: wakeup((caddr_t)bp);
337: bp->b_flags &= B_ERROR;
338: }
339:
340: /*
341: * Queue a tape operation.
342: */
343: tmstrategy(bp)
344: register struct buf *bp;
345: {
346: int teunit = TEUNIT(bp->b_dev);
347: register struct uba_ctlr *um;
348: register struct buf *dp;
349: int s;
350:
351: /*
352: * Put transfer at end of unit queue
353: */
354: dp = &teutab[teunit];
355: bp->av_forw = NULL;
356: s = spl5();
357: um = tedinfo[teunit]->ui_mi;
358: if (dp->b_actf == NULL) {
359: dp->b_actf = bp;
360: /*
361: * Transport not already active...
362: * put at end of controller queue.
363: */
364: dp->b_forw = NULL;
365: if (um->um_tab.b_actf == NULL)
366: um->um_tab.b_actf = dp;
367: else
368: um->um_tab.b_actl->b_forw = dp;
369: um->um_tab.b_actl = dp;
370: } else
371: dp->b_actl->av_forw = bp;
372: dp->b_actl = bp;
373: /*
374: * If the controller is not busy, get
375: * it going.
376: */
377: if (um->um_tab.b_active == 0)
378: tmstart(um);
379: splx(s);
380: }
381:
382: /*
383: * Start activity on a tm controller.
384: */
385: tmstart(um)
386: register struct uba_ctlr *um;
387: {
388: register struct buf *bp, *dp;
389: register struct tmdevice *addr = (struct tmdevice *)um->um_addr;
390: register struct te_softc *sc;
391: register struct uba_device *ui;
392: int teunit, cmd;
393: daddr_t blkno;
394:
395: /*
396: * Look for an idle transport on the controller.
397: */
398: loop:
399: if ((dp = um->um_tab.b_actf) == NULL)
400: return;
401: if ((bp = dp->b_actf) == NULL) {
402: um->um_tab.b_actf = dp->b_forw;
403: goto loop;
404: }
405: teunit = TEUNIT(bp->b_dev);
406: ui = tedinfo[teunit];
407: /*
408: * Record pre-transfer status (e.g. for TM_SENSE)
409: */
410: sc = &te_softc[teunit];
411: addr = (struct tmdevice *)um->um_addr;
412: addr->tmcs = (ui->ui_slave << 8);
413: sc->sc_dsreg = addr->tmcs;
414: sc->sc_erreg = addr->tmer;
415: sc->sc_resid = addr->tmbc;
416: /*
417: * Default is that last command was NOT a write command;
418: * if we do a write command we will notice this in tmintr().
419: */
420: sc->sc_lastiow = 0;
421: if (sc->sc_openf < 0 || (addr->tmcs&TM_CUR) == 0) {
422: /*
423: * Have had a hard error on a non-raw tape
424: * or the tape unit is now unavailable
425: * (e.g. taken off line).
426: */
427: bp->b_flags |= B_ERROR;
428: goto next;
429: }
430: if (bp == &ctmbuf[TMUNIT(bp->b_dev)]) {
431: /*
432: * Execute control operation with the specified count.
433: */
434: if (bp->b_command == TM_SENSE)
435: goto next;
436: /*
437: * Set next state; give 5 minutes to complete
438: * rewind, or 10 seconds per iteration (minimum 60
439: * seconds and max 5 minutes) to complete other ops.
440: */
441: if (bp->b_command == TM_REW) {
442: um->um_tab.b_active = SREW;
443: sc->sc_timo = 5 * 60;
444: } else {
445: um->um_tab.b_active = SCOM;
446: sc->sc_timo =
447: imin(imax(10*(int)-bp->b_repcnt,60),5*60);
448: }
449: if (bp->b_command == TM_SFORW || bp->b_command == TM_SREV)
450: addr->tmbc = bp->b_repcnt;
451: goto dobpcmd;
452: }
453: /*
454: * For raw I/O, fudge the current block number
455: * so we don't seek except on a retry.
456: * For raw I/O, fudge the current block number
457: * so we don't seek except on a retry.
458: */
459: if (bp->b_flags & B_RAW) {
460: if (um->um_tab.b_errcnt == 0) {
461: sc->sc_blkno = bdbtofsb(bp->b_blkno);
462: sc->sc_nxrec = sc->sc_blkno + 1;
463: }
464: } else {
465: /*
466: * Handle boundary cases for operation
467: * on non-raw tapes.
468: */
469: if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) {
470: /*
471: * Can't read past known end-of-file.
472: */
473: bp->b_flags |= B_ERROR;
474: bp->b_error = ENXIO;
475: goto next;
476: }
477: if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec &&
478: bp->b_flags&B_READ) {
479: /*
480: * Reading at end of file returns 0 bytes.
481: */
482: bp->b_resid = bp->b_bcount;
483: clrbuf(bp);
484: goto next;
485: }
486: if ((bp->b_flags&B_READ) == 0)
487: /*
488: * Writing sets EOF
489: */
490: sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1;
491: }
492: /*
493: * If the data transfer command is in the correct place,
494: * set up all the registers except the csr, and give
495: * control over to the UNIBUS adapter routines, to
496: * wait for resources to start the i/o.
497: */
498: if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) {
499: addr->tmbc = -bp->b_bcount;
500: if ((bp->b_flags&B_READ) == 0) {
501: if (um->um_tab.b_errcnt &&
502: (sc->sc_ioerreg&(TMER_HARD|TMER_SOFT)) != TMER_BGL)
503: cmd = TM_WIRG;
504: else
505: cmd = TM_WCOM;
506: } else
507: cmd = TM_RCOM;
508: um->um_tab.b_active = SIO;
509: um->um_cmd = sc->sc_dens|cmd;
510: #ifdef notdef
511: if (tmreverseop(sc->sc_lastcmd))
512: while (addr->tmer & TMER_SDWN)
513: DELAY(10),tmgapsdcnt++;
514: sc->sc_lastcmd = TM_RCOM; /* will serve */
515: #endif
516: sc->sc_timo = 60; /* premature, but should serve */
517: (void) ubago(ui);
518: return;
519: }
520: /*
521: * Tape positioned incorrectly;
522: * set to seek forwards or backwards to the correct spot.
523: * This happens for raw tapes only on error retries.
524: */
525: um->um_tab.b_active = SSEEK;
526: if (blkno < bdbtofsb(bp->b_blkno)) {
527: bp->b_command = TM_SFORW;
528: addr->tmbc = blkno - bdbtofsb(bp->b_blkno);
529: } else {
530: bp->b_command = TM_SREV;
531: addr->tmbc = bdbtofsb(bp->b_blkno) - blkno;
532: }
533: sc->sc_timo = imin(imax(10 * -addr->tmbc, 60), 5 * 60);
534: dobpcmd:
535: #ifdef notdef
536: /*
537: * It is strictly necessary to wait for the tape
538: * to stop before changing directions, but the TC11
539: * handles this for us.
540: */
541: if (tmreverseop(sc->sc_lastcmd) != tmreverseop(bp->b_command))
542: while (addr->tmer & TM_SDWN)
543: DELAY(10),tmgapsdcnt++;
544: sc->sc_lastcmd = bp->b_command;
545: #endif
546: /*
547: * Do the command in bp.
548: */
549: addr->tmcs = (sc->sc_dens | bp->b_command);
550: return;
551:
552: next:
553: /*
554: * Done with this operation due to error or
555: * the fact that it doesn't do anything.
556: * Release UBA resources (if any), dequeue
557: * the transfer and continue processing this slave.
558: */
559: if (um->um_ubinfo)
560: ubadone(um);
561: um->um_tab.b_errcnt = 0;
562: dp->b_actf = bp->av_forw;
563: iodone(bp);
564: goto loop;
565: }
566:
567: /*
568: * The UNIBUS resources we needed have been
569: * allocated to us; start the device.
570: */
571: tmdgo(um)
572: register struct uba_ctlr *um;
573: {
574: register struct tmdevice *addr = (struct tmdevice *)um->um_addr;
575:
576: addr->tmba = um->um_ubinfo;
577: addr->tmcs = um->um_cmd | ((um->um_ubinfo >> 12) & 0x30);
578: }
579:
580: /*
581: * Tm interrupt routine.
582: */
583: /*ARGSUSED*/
584: tmintr(tm11)
585: int tm11;
586: {
587: struct buf *dp;
588: register struct buf *bp;
589: register struct uba_ctlr *um = tmminfo[tm11];
590: register struct tmdevice *addr;
591: register struct te_softc *sc;
592: int teunit;
593: register state;
594:
595: if ((dp = um->um_tab.b_actf) == NULL)
596: return;
597: bp = dp->b_actf;
598: teunit = TEUNIT(bp->b_dev);
599: addr = (struct tmdevice *)tedinfo[teunit]->ui_addr;
600: sc = &te_softc[teunit];
601: /*
602: * If last command was a rewind, and tape is still
603: * rewinding, wait for the rewind complete interrupt.
604: */
605: if (um->um_tab.b_active == SREW) {
606: um->um_tab.b_active = SCOM;
607: if (addr->tmer&TMER_RWS) {
608: sc->sc_timo = 5*60; /* 5 minutes */
609: return;
610: }
611: }
612: /*
613: * An operation completed... record status
614: */
615: sc->sc_timo = INF;
616: if (um->um_tab.b_active == SIO)
617: if (um->um_tab.b_active == SIO)
618: sc->sc_ioerreg = addr->tmer;
619: sc->sc_dsreg = addr->tmcs;
620: sc->sc_erreg = addr->tmer;
621: sc->sc_resid = addr->tmbc;
622: if ((bp->b_flags & B_READ) == 0)
623: sc->sc_lastiow = 1;
624: state = um->um_tab.b_active;
625: um->um_tab.b_active = 0;
626: /*
627: * Check for errors.
628: */
629: if (addr->tmcs&TM_ERR) {
630: while (addr->tmer & TMER_SDWN)
631: DELAY(10); /* await settle down */
632: /*
633: * If we hit the end of the tape file, update our position.
634: */
635: if (addr->tmer&TMER_EOF) {
636: tmseteof(bp); /* set blkno and nxrec */
637: state = SCOM; /* force completion */
638: /*
639: * Stuff bc so it will be unstuffed correctly
640: * later to get resid.
641: */
642: addr->tmbc = -bp->b_bcount;
643: goto opdone;
644: }
645: /*
646: * If we were reading raw tape and the only error was that the
647: * record was too long, then we don't consider this an error.
648: */
649: if ((bp->b_flags & (B_READ|B_RAW)) == (B_READ|B_RAW) &&
650: (addr->tmer&(TMER_HARD|TMER_SOFT)) == TMER_RLE)
651: goto ignoreerr;
652: /*
653: * If error is not hard, and this was an i/o operation
654: * retry up to 8 times.
655: */
656: if ((addr->tmer&TMER_HARD)==0 && state==SIO) {
657: if (um->um_tab.b_errcnt++ < 8) {
658: if (tmdiag)
659: log(LOG_DEBUG,
660: "te%d: soft error bn%d er=%b\n",
661: minor(bp->b_dev)&03,
662: bp->b_blkno, sc->sc_erreg,
663: TMER_BITS);
664: sc->sc_blkno++; /* force backspace */
665: ubadone(um);
666: goto opcont;
667: }
668: } else
669: /*
670: * Hard or non-i/o errors on non-raw tape
671: * cause it to close.
672: */
673: if ((bp->b_flags&B_RAW) == 0 && sc->sc_openf > 0)
674: sc->sc_openf = -1;
675: /*
676: * Couldn't recover error
677: */
678: tprintf(sc->sc_tpr,
679: "te%d: hard error bn%d er=%b\n", minor(bp->b_dev)&03,
680: bp->b_blkno, sc->sc_erreg, TMER_BITS);
681: #ifdef AVIV
682: if (tmdiag) {
683: addr->tmmr = DAB;
684: printf("reject code 0%o", addr->tmmr & DAB_MASK);
685: addr->tmmr = DTS;
686: if (addr->tmmr & DTS_MASK)
687: printf(", dead track 0%o", addr->tmmr & DTS_MASK);
688: addr->tmmr = RWERR;
689: printf(", read/write errors %b\n",
690: addr->tmmr & RWERR_MASK,
691: RWERR_BITS);
692: addr->tmmr = DRSENSE;
693: printf("drive sense %b, ", addr->tmmr & DRSENSE_MASK,
694: DRSENSE_BITS);
695: printf("fsr %b\n", addr->tmfsr, FSR_BITS);
696: }
697: #endif AVIV
698: bp->b_flags |= B_ERROR;
699: goto opdone;
700: }
701: /*
702: * Advance tape control FSM.
703: */
704: ignoreerr:
705: switch (state) {
706:
707: case SIO:
708: /*
709: * Read/write increments tape block number
710: */
711: sc->sc_blkno++;
712: sc->sc_blks++;
713: if (um->um_tab.b_errcnt)
714: sc->sc_softerrs++;
715: goto opdone;
716:
717: case SCOM:
718: /*
719: * For forward/backward space record update current position.
720: */
721: if (bp == &ctmbuf[TMUNIT(bp->b_dev)])
722: switch ((int)bp->b_command) {
723:
724: case TM_SFORW:
725: sc->sc_blkno -= bp->b_repcnt;
726: break;
727:
728: case TM_SREV:
729: sc->sc_blkno += bp->b_repcnt;
730: break;
731: }
732: goto opdone;
733:
734: case SSEEK:
735: sc->sc_blkno = bdbtofsb(bp->b_blkno);
736: goto opcont;
737:
738: default:
739: panic("tmintr");
740: }
741: opdone:
742: /*
743: * Reset error count and remove
744: * from device queue.
745: */
746: um->um_tab.b_errcnt = 0;
747: dp->b_actf = bp->av_forw;
748: /*
749: * Check resid; watch out for resid >32767 (tmbc not negative).
750: */
751: bp->b_resid = ((int) -addr->tmbc) & 0xffff;
752: ubadone(um);
753: iodone(bp);
754: /*
755: * Circulate slave to end of controller
756: * queue to give other slaves a chance.
757: */
758: um->um_tab.b_actf = dp->b_forw;
759: if (dp->b_actf) {
760: dp->b_forw = NULL;
761: if (um->um_tab.b_actf == NULL)
762: um->um_tab.b_actf = dp;
763: else
764: um->um_tab.b_actl->b_forw = dp;
765: um->um_tab.b_actl = dp;
766: }
767: if (um->um_tab.b_actf == 0)
768: return;
769: opcont:
770: tmstart(um);
771: }
772:
773: tmtimer(dev)
774: int dev;
775: {
776: register struct te_softc *sc = &te_softc[TEUNIT(dev)];
777: register short x;
778:
779: if (sc->sc_timo != INF && (sc->sc_timo -= 5) < 0) {
780: printf("te%d: lost interrupt\n", TEUNIT(dev));
781: sc->sc_timo = INF;
782: x = spl5();
783: tmintr(TMUNIT(dev));
784: (void) splx(x);
785: }
786: timeout(tmtimer, (caddr_t)dev, 5*hz);
787: }
788:
789: tmseteof(bp)
790: register struct buf *bp;
791: {
792: register int teunit = TEUNIT(bp->b_dev);
793: register struct tmdevice *addr =
794: (struct tmdevice *)tedinfo[teunit]->ui_addr;
795: register struct te_softc *sc = &te_softc[teunit];
796:
797: if (bp == &ctmbuf[TMUNIT(bp->b_dev)]) {
798: if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) {
799: /* reversing */
800: sc->sc_nxrec = bdbtofsb(bp->b_blkno) - addr->tmbc;
801: sc->sc_blkno = sc->sc_nxrec;
802: } else {
803: /* spacing forward */
804: sc->sc_blkno = bdbtofsb(bp->b_blkno) + addr->tmbc;
805: sc->sc_nxrec = sc->sc_blkno - 1;
806: }
807: return;
808: }
809: /* eof on read */
810: sc->sc_nxrec = bdbtofsb(bp->b_blkno);
811: }
812:
813: tmreset(uban)
814: int uban;
815: {
816: register struct uba_ctlr *um;
817: register tm11, teunit;
818: register struct uba_device *ui;
819: register struct buf *dp;
820:
821: for (tm11 = 0; tm11 < NTM; tm11++) {
822: if ((um = tmminfo[tm11]) == 0 || um->um_alive == 0 ||
823: um->um_ubanum != uban)
824: continue;
825: printf(" tm%d", tm11);
826: um->um_tab.b_active = 0;
827: um->um_tab.b_actf = um->um_tab.b_actl = 0;
828: if (um->um_ubinfo) {
829: printf("<%d>", (um->um_ubinfo>>28)&0xf);
830: um->um_ubinfo = 0;
831: }
832: ((struct tmdevice *)(um->um_addr))->tmcs = TM_DCLR;
833: for (teunit = 0; teunit < NTE; teunit++) {
834: if ((ui = tedinfo[teunit]) == 0 || ui->ui_mi != um ||
835: ui->ui_alive == 0)
836: continue;
837: dp = &teutab[teunit];
838: dp->b_active = 0;
839: dp->b_forw = 0;
840: if (um->um_tab.b_actf == NULL)
841: um->um_tab.b_actf = dp;
842: else
843: um->um_tab.b_actl->b_forw = dp;
844: um->um_tab.b_actl = dp;
845: if (te_softc[teunit].sc_openf > 0)
846: te_softc[teunit].sc_openf = -1;
847: }
848: tmstart(um);
849: }
850: }
851:
852: /*ARGSUSED*/
853: tmioctl(dev, cmd, data, flag)
854: caddr_t data;
855: dev_t dev;
856: {
857: int teunit = TEUNIT(dev);
858: register struct te_softc *sc = &te_softc[teunit];
859: register struct buf *bp = &ctmbuf[TMUNIT(dev)];
860: register callcount;
861: int fcount, error = 0;
862: struct mtop *mtop;
863: struct mtget *mtget;
864: /* we depend of the values and order of the MT codes here */
865: static tmops[] =
866: {TM_WEOF,TM_SFORW,TM_SREV,TM_SFORW,TM_SREV,TM_REW,TM_OFFL,TM_SENSE};
867:
868: switch (cmd) {
869:
870: case MTIOCTOP: /* tape operation */
871: mtop = (struct mtop *)data;
872: switch (mtop->mt_op) {
873:
874: case MTWEOF:
875: callcount = mtop->mt_count;
876: fcount = 1;
877: break;
878:
879: case MTFSF: case MTBSF:
880: callcount = mtop->mt_count;
881: fcount = INF;
882: break;
883:
884: case MTFSR: case MTBSR:
885: callcount = 1;
886: fcount = mtop->mt_count;
887: break;
888:
889: case MTREW: case MTOFFL: case MTNOP:
890: callcount = 1;
891: fcount = 1;
892: break;
893:
894: default:
895: return (ENXIO);
896: }
897: if (callcount <= 0 || fcount <= 0)
898: return (EINVAL);
899: while (--callcount >= 0) {
900: tmcommand(dev, tmops[mtop->mt_op], fcount);
901: if ((mtop->mt_op == MTFSR || mtop->mt_op == MTBSR) &&
902: bp->b_resid)
903: return (EIO);
904: if ((bp->b_flags&B_ERROR) || sc->sc_erreg&TMER_BOT)
905: break;
906: }
907: if (bp->b_flags&B_ERROR)
908: if ((error = bp->b_error)==0)
909: return (EIO);
910: return (error);
911:
912: case MTIOCGET:
913: mtget = (struct mtget *)data;
914: mtget->mt_dsreg = sc->sc_dsreg;
915: mtget->mt_erreg = sc->sc_erreg;
916: mtget->mt_resid = sc->sc_resid;
917: mtget->mt_type = MT_ISTM;
918: break;
919:
920: default:
921: return (ENXIO);
922: }
923: return (0);
924: }
925:
926: #define DBSIZE 20
927:
928: tmdump()
929: {
930: register struct uba_device *ui;
931: register struct uba_regs *up;
932: register struct tmdevice *addr;
933: int blk, num;
934: int start;
935:
936: start = 0;
937: num = maxfree;
938: #define phys(a,b) ((b)((int)(a)&0x7fffffff))
939: if (tedinfo[0] == 0)
940: return (ENXIO);
941: ui = phys(tedinfo[0], struct uba_device *);
942: up = phys(ui->ui_hd, struct uba_hd *)->uh_physuba;
943: ubainit(up);
944: DELAY(1000000);
945: addr = (struct tmdevice *)ui->ui_physaddr;
946: tmwait(addr);
947: addr->tmcs = TM_DCLR | TM_GO;
948: while (num > 0) {
949: blk = num > DBSIZE ? DBSIZE : num;
950: tmdwrite(start, blk, addr, up);
951: start += blk;
952: num -= blk;
953: }
954: tmeof(addr);
955: tmeof(addr);
956: tmwait(addr);
957: if (addr->tmcs&TM_ERR)
958: return (EIO);
959: addr->tmcs = TM_REW | TM_GO;
960: tmwait(addr);
961: return (0);
962: }
963:
964: tmdwrite(dbuf, num, addr, up)
965: register dbuf, num;
966: register struct tmdevice *addr;
967: struct uba_regs *up;
968: {
969: register struct pte *io;
970: register int npf;
971:
972: tmwait(addr);
973: io = up->uba_map;
974: npf = num+1;
975: while (--npf != 0)
976: *(int *)io++ = (dbuf++ | (1<<UBAMR_DPSHIFT) | UBAMR_MRV);
977: *(int *)io = 0;
978: addr->tmbc = -(num*NBPG);
979: addr->tmba = 0;
980: addr->tmcs = TM_WCOM | TM_GO;
981: }
982:
983: tmwait(addr)
984: register struct tmdevice *addr;
985: {
986: register s;
987:
988: do
989: s = addr->tmcs;
990: while ((s & TM_CUR) == 0);
991: }
992:
993: tmeof(addr)
994: struct tmdevice *addr;
995: {
996:
997: tmwait(addr);
998: addr->tmcs = TM_WEOF | TM_GO;
999: }
1000: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.