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