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