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