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