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