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