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