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