![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ut.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 ut.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: * @(#)ut.c 7.11 (Berkeley) 7/1/90 ! 7: */ ! 8: ! 9: #include "tj.h" ! 10: #if NUT > 0 ! 11: /* ! 12: * System Industries Model 9700 Tape Drive ! 13: * emulates a TU45 on the UNIBUS ! 14: * ! 15: * TODO: ! 16: * check out attention processing ! 17: * try reset code and dump code ! 18: */ ! 19: #include "param.h" ! 20: #include "systm.h" ! 21: #include "buf.h" ! 22: #include "conf.h" ! 23: #include "errno.h" ! 24: #include "file.h" ! 25: #include "map.h" ! 26: #include "ioctl.h" ! 27: #include "mtio.h" ! 28: #include "cmap.h" ! 29: #include "time.h" ! 30: #include "uio.h" ! 31: #include "kernel.h" ! 32: #include "syslog.h" ! 33: #include "tprintf.h" ! 34: ! 35: #include "machine/pte.h" ! 36: #include "../vax/cpu.h" ! 37: #include "ubareg.h" ! 38: #include "ubavar.h" ! 39: #include "utreg.h" ! 40: ! 41: struct buf cutbuf[NUT]; /* bufs for control operations */ ! 42: struct buf tjutab[NTJ]; /* bufs for slave queue headers */ ! 43: ! 44: struct uba_ctlr *utminfo[NUT]; ! 45: struct uba_device *tjdinfo[NTJ]; ! 46: int utprobe(), utslave(), utattach(), utdgo(), utintr(), uttimer(); ! 47: u_short utstd[] = { 0772440, 0 }; ! 48: struct uba_driver utdriver = ! 49: { utprobe, utslave, utattach, utdgo, utstd, "tj", tjdinfo, "ut", utminfo, 0 }; ! 50: ! 51: #define MASKREG(reg) ((reg)&0xffff) ! 52: ! 53: /* bits in minor device */ ! 54: #define TJUNIT(dev) (minor(dev)&03) ! 55: #define T_NOREWIND 04 ! 56: #define T_1600BPI 010 ! 57: #define T_6250BPI 020 ! 58: short utdens[] = { UT_NRZI, UT_PE, UT_GCR, UT_NRZI }; ! 59: ! 60: /* slave to controller mapping table */ ! 61: short tjtout[NTJ]; ! 62: #define UTUNIT(dev) (tjtout[TJUNIT(dev)]) ! 63: ! 64: #define INF (daddr_t)1000000L /* a block number that wont exist */ ! 65: ! 66: struct tj_softc { ! 67: char sc_openf; /* exclusive open */ ! 68: char sc_lastiow; /* last I/O operation was a write */ ! 69: daddr_t sc_blkno; /* next block to transfer */ ! 70: daddr_t sc_nxrec; /* next record on tape */ ! 71: u_short sc_erreg; /* image of uter */ ! 72: u_short sc_dsreg; /* image of utds */ ! 73: u_short sc_resid; /* residual from transfer */ ! 74: u_short sc_dens; /* sticky selected density */ ! 75: daddr_t sc_timo; /* time until timeout expires */ ! 76: short sc_tact; /* timeout is active flag */ ! 77: tpr_t sc_tpr; /* tprintf handle */ ! 78: int sc_blks; /* number of I/O operations since open */ ! 79: int sc_softerrs; /* number of soft I/O errors since open */ ! 80: } tj_softc[NTJ]; ! 81: ! 82: /* ! 83: * Internal per/slave states found in sc_state ! 84: */ ! 85: #define SSEEK 1 /* seeking */ ! 86: #define SIO 2 /* doing sequential I/O */ ! 87: #define SCOM 3 /* sending a control command */ ! 88: #define SREW 4 /* doing a rewind op */ ! 89: #define SERASE 5 /* erase inter-record gap */ ! 90: #define SERASED 6 /* erased inter-record gap */ ! 91: ! 92: /*ARGSUSED*/ ! 93: utprobe(reg) ! 94: caddr_t reg; ! 95: { ! 96: register int br, cvec; ! 97: #ifdef lint ! 98: br=0; cvec=br; br=cvec; ! 99: utintr(0); ! 100: #endif ! 101: /* ! 102: * The SI documentation says you must set the RDY bit ! 103: * (even though it's read-only) to force an interrupt. ! 104: */ ! 105: ((struct utdevice *) reg)->utcs1 = UT_IE|UT_NOP|UT_RDY; ! 106: DELAY(10000); ! 107: return (sizeof (struct utdevice)); ! 108: } ! 109: ! 110: /*ARGSUSED*/ ! 111: utslave(ui, reg) ! 112: struct uba_device *ui; ! 113: caddr_t reg; ! 114: { ! 115: /* ! 116: * A real TU45 would support the slave present bit ! 117: * int the drive type register, but this thing doesn't, ! 118: * so there's no way to determine if a slave is present or not. ! 119: */ ! 120: return(1); ! 121: } ! 122: ! 123: utattach(ui) ! 124: struct uba_device *ui; ! 125: { ! 126: tjtout[ui->ui_unit] = ui->ui_mi->um_ctlr; ! 127: } ! 128: ! 129: /* ! 130: * Open the device with exclusive access. ! 131: */ ! 132: utopen(dev, flag) ! 133: dev_t dev; ! 134: int flag; ! 135: { ! 136: register int tjunit = TJUNIT(dev); ! 137: register struct uba_device *ui; ! 138: register struct tj_softc *sc; ! 139: int olddens, dens, error; ! 140: register int s; ! 141: ! 142: if (tjunit >= NTJ || (ui = tjdinfo[tjunit]) == 0 || ui->ui_alive == 0) ! 143: return (ENXIO); ! 144: if ((sc = &tj_softc[tjunit])->sc_openf) ! 145: return (EBUSY); ! 146: sc->sc_openf = 1; ! 147: olddens = sc->sc_dens; ! 148: dens = sc->sc_dens = ! 149: utdens[(minor(dev)&(T_1600BPI|T_6250BPI))>>3]| ! 150: PDP11FMT|(ui->ui_slave&07); ! 151: get: ! 152: utcommand(dev, UT_SENSE, 1); ! 153: if (sc->sc_dsreg&UTDS_PIP) { ! 154: if (error = tsleep((caddr_t)&lbolt, (PZERO+1) | PCATCH, ! 155: devopn, 0)) ! 156: return (error); ! 157: goto get; ! 158: } ! 159: sc->sc_dens = olddens; ! 160: if ((sc->sc_dsreg&UTDS_MOL) == 0) { ! 161: sc->sc_openf = 0; ! 162: uprintf("tj%d: not online\n", tjunit); ! 163: return (EIO); ! 164: } ! 165: if ((flag&FWRITE) && (sc->sc_dsreg&UTDS_WRL)) { ! 166: sc->sc_openf = 0; ! 167: uprintf("tj%d: no write ring\n", tjunit); ! 168: return (EIO); ! 169: } ! 170: if ((sc->sc_dsreg&UTDS_BOT) == 0 && (flag&FWRITE) && ! 171: dens != sc->sc_dens) { ! 172: sc->sc_openf = 0; ! 173: uprintf("tj%d: can't change density in mid-tape\n", tjunit); ! 174: return (EIO); ! 175: } ! 176: sc->sc_blkno = (daddr_t)0; ! 177: sc->sc_nxrec = INF; ! 178: sc->sc_lastiow = 0; ! 179: sc->sc_blks = 0; ! 180: sc->sc_softerrs = 0; ! 181: sc->sc_dens = dens; ! 182: sc->sc_tpr = tprintf_open(); ! 183: /* ! 184: * For 6250 bpi take exclusive use of the UNIBUS. ! 185: */ ! 186: ui->ui_driver->ud_xclu = (dens&(T_1600BPI|T_6250BPI)) == T_6250BPI; ! 187: s = splclock(); ! 188: if (sc->sc_tact == 0) { ! 189: sc->sc_timo = INF; ! 190: sc->sc_tact = 1; ! 191: timeout(uttimer, (caddr_t)dev, 5*hz); ! 192: } ! 193: splx(s); ! 194: return (0); ! 195: } ! 196: ! 197: utclose(dev, flag) ! 198: register dev_t dev; ! 199: register flag; ! 200: { ! 201: register struct tj_softc *sc = &tj_softc[TJUNIT(dev)]; ! 202: ! 203: if (flag == FWRITE || ((flag&FWRITE) && sc->sc_lastiow)) { ! 204: utcommand(dev, UT_WEOF, 1); ! 205: utcommand(dev, UT_WEOF, 1); ! 206: utcommand(dev, UT_SREV, 1); ! 207: } ! 208: if ((minor(dev)&T_NOREWIND) == 0) ! 209: utcommand(dev, UT_REW, 0); ! 210: if (sc->sc_blks > 100 && sc->sc_softerrs > sc->sc_blks / 100) ! 211: log(LOG_INFO, "tj%d: %d soft errors in %d blocks\n", ! 212: TJUNIT(dev), sc->sc_softerrs, sc->sc_blks); ! 213: tprintf_close(sc->sc_tpr); ! 214: sc->sc_openf = 0; ! 215: return (0); ! 216: } ! 217: ! 218: utcommand(dev, com, count) ! 219: dev_t dev; ! 220: int com, count; ! 221: { ! 222: register struct buf *bp; ! 223: register int s; ! 224: ! 225: bp = &cutbuf[UTUNIT(dev)]; ! 226: s = spl5(); ! 227: while (bp->b_flags&B_BUSY) { ! 228: if(bp->b_repcnt == 0 && (bp->b_flags&B_DONE)) ! 229: break; ! 230: bp->b_flags |= B_WANTED; ! 231: sleep((caddr_t)bp, PRIBIO); ! 232: } ! 233: bp->b_flags = B_BUSY|B_READ; ! 234: splx(s); ! 235: bp->b_dev = dev; ! 236: bp->b_command = com; ! 237: bp->b_repcnt = count; ! 238: bp->b_blkno = 0; ! 239: utstrategy(bp); ! 240: if (count == 0) ! 241: return; ! 242: iowait(bp); ! 243: if (bp->b_flags&B_WANTED) ! 244: wakeup((caddr_t)bp); ! 245: bp->b_flags &= B_ERROR; ! 246: } ! 247: ! 248: /* ! 249: * Queue a tape operation. ! 250: */ ! 251: utstrategy(bp) ! 252: register struct buf *bp; ! 253: { ! 254: int tjunit = TJUNIT(bp->b_dev); ! 255: register struct uba_ctlr *um; ! 256: register struct buf *dp; ! 257: int s; ! 258: ! 259: /* ! 260: * Put transfer at end of unit queue ! 261: */ ! 262: dp = &tjutab[tjunit]; ! 263: bp->av_forw = NULL; ! 264: um = tjdinfo[tjunit]->ui_mi; ! 265: s = spl5(); ! 266: if (dp->b_actf == NULL) { ! 267: dp->b_actf = bp; ! 268: /* ! 269: * Transport not active, so... ! 270: * put at end of controller queue ! 271: */ ! 272: dp->b_forw = NULL; ! 273: if (um->um_tab.b_actf == NULL) ! 274: um->um_tab.b_actf = dp; ! 275: else ! 276: um->um_tab.b_actl->b_forw = dp; ! 277: um->um_tab.b_actl = dp; ! 278: } else ! 279: dp->b_actl->av_forw = bp; ! 280: dp->b_actl = bp; ! 281: /* ! 282: * If the controller is not busy, set it going. ! 283: */ ! 284: if (um->um_tab.b_state == 0) ! 285: utstart(um); ! 286: splx(s); ! 287: } ! 288: ! 289: utstart(um) ! 290: register struct uba_ctlr *um; ! 291: { ! 292: register struct utdevice *addr; ! 293: register struct buf *bp, *dp; ! 294: register struct tj_softc *sc; ! 295: struct uba_device *ui; ! 296: int tjunit; ! 297: daddr_t blkno; ! 298: ! 299: loop: ! 300: /* ! 301: * Scan controller queue looking for units with ! 302: * transaction queues to dispatch ! 303: */ ! 304: if ((dp = um->um_tab.b_actf) == NULL) ! 305: return; ! 306: if ((bp = dp->b_actf) == NULL) { ! 307: um->um_tab.b_actf = dp->b_forw; ! 308: goto loop; ! 309: } ! 310: addr = (struct utdevice *)um->um_addr; ! 311: tjunit = TJUNIT(bp->b_dev); ! 312: ui = tjdinfo[tjunit]; ! 313: sc = &tj_softc[tjunit]; ! 314: /* note slave select, density, and format were merged on open */ ! 315: addr->uttc = sc->sc_dens; ! 316: sc->sc_dsreg = addr->utds; ! 317: sc->sc_erreg = addr->uter; ! 318: sc->sc_resid = MASKREG(addr->utfc); ! 319: /* ! 320: * Default is that last command was NOT a write command; ! 321: * if we do a write command we will notice this in utintr(). ! 322: */ ! 323: sc->sc_lastiow = 0; ! 324: if (sc->sc_openf < 0 || (addr->utds&UTDS_MOL) == 0) { ! 325: /* ! 326: * Have had a hard error on a non-raw tape ! 327: * or the tape unit is now unavailable ! 328: * (e.g. taken off line). ! 329: */ ! 330: bp->b_flags |= B_ERROR; ! 331: goto next; ! 332: } ! 333: if (bp == &cutbuf[UTUNIT(bp->b_dev)]) { ! 334: /* ! 335: * Execute a control operation with the specified ! 336: * count. ! 337: */ ! 338: if (bp->b_command == UT_SENSE) ! 339: goto next; ! 340: if (bp->b_command == UT_SFORW && (addr->utds & UTDS_EOT)) { ! 341: bp->b_resid = bp->b_bcount; ! 342: goto next; ! 343: } ! 344: /* ! 345: * Set next state; handle timeouts ! 346: */ ! 347: if (bp->b_command == UT_REW) { ! 348: um->um_tab.b_state = SREW; ! 349: sc->sc_timo = 5*60; ! 350: } else { ! 351: um->um_tab.b_state = SCOM; ! 352: sc->sc_timo = imin(imax(10*(int)-bp->b_repcnt,60),5*60); ! 353: } ! 354: /* NOTE: this depends on the ut command values */ ! 355: if (bp->b_command >= UT_SFORW && bp->b_command <= UT_SREVF) ! 356: addr->utfc = -bp->b_repcnt; ! 357: goto dobpcmd; ! 358: } ! 359: /* ! 360: * For raw I/O, save the current block ! 361: * number in case we have to retry. ! 362: */ ! 363: if (bp->b_flags & B_RAW) { ! 364: if (um->um_tab.b_errcnt == 0) { ! 365: sc->sc_blkno = bdbtofsb(bp->b_blkno); ! 366: sc->sc_nxrec = sc->sc_blkno + 1; ! 367: } ! 368: } ! 369: else { ! 370: /* ! 371: * Handle boundary cases for operation ! 372: * on non-raw tapes. ! 373: */ ! 374: if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) { ! 375: /* can't read past end of file */ ! 376: bp->b_flags |= B_ERROR; ! 377: bp->b_error = ENXIO; ! 378: goto next; ! 379: } ! 380: if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec && ! 381: (bp->b_flags&B_READ)) { ! 382: /* ! 383: * Reading at end of file returns 0 bytes. ! 384: */ ! 385: bp->b_resid = bp->b_bcount; ! 386: clrbuf(bp); ! 387: goto next; ! 388: } ! 389: if ((bp->b_flags&B_READ) == 0) ! 390: sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1; ! 391: } ! 392: /* ! 393: * If the tape is correctly positioned, set up all the ! 394: * registers but the csr, and give control over to the ! 395: * UNIBUS adaptor routines, to wait for resources to ! 396: * start I/O. ! 397: */ ! 398: if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) { ! 399: addr->utwc = -(((bp->b_bcount)+1)>>1); ! 400: addr->utfc = -bp->b_bcount; ! 401: if ((bp->b_flags&B_READ) == 0) { ! 402: /* ! 403: * On write error retries erase the ! 404: * inter-record gap before rewriting. ! 405: */ ! 406: if (um->um_tab.b_errcnt) { ! 407: if (um->um_tab.b_state != SERASED) { ! 408: um->um_tab.b_state = SERASE; ! 409: sc->sc_timo = 60; ! 410: addr->utcs1 = UT_ERASE|UT_IE|UT_GO; ! 411: return; ! 412: } ! 413: } ! 414: if (addr->utds & UTDS_EOT) { ! 415: bp->b_resid = bp->b_bcount; ! 416: um->um_tab.b_state = 0; ! 417: goto next; ! 418: } ! 419: um->um_cmd = UT_WCOM; ! 420: } else ! 421: um->um_cmd = UT_RCOM; ! 422: sc->sc_timo = 60; ! 423: um->um_tab.b_state = SIO; ! 424: (void) ubago(ui); ! 425: return; ! 426: } ! 427: /* ! 428: * Tape positioned incorrectly; seek forwards or ! 429: * backwards to the correct spot. This happens for ! 430: * raw tapes only on error retries. ! 431: */ ! 432: um->um_tab.b_state = SSEEK; ! 433: if (blkno < bdbtofsb(bp->b_blkno)) { ! 434: addr->utfc = blkno - bdbtofsb(bp->b_blkno); ! 435: bp->b_command = UT_SFORW; ! 436: } else { ! 437: addr->utfc = bdbtofsb(bp->b_blkno) - blkno; ! 438: bp->b_command = UT_SREV; ! 439: } ! 440: sc->sc_timo = imin(imax(10 * -addr->utfc, 60), 5*60); ! 441: ! 442: dobpcmd: ! 443: /* ! 444: * Perform the command setup in bp. ! 445: */ ! 446: addr->utcs1 = bp->b_command|UT_IE|UT_GO; ! 447: return; ! 448: next: ! 449: /* ! 450: * Advance to the next command in the slave queue, ! 451: * posting notice and releasing resources as needed. ! 452: */ ! 453: if (um->um_ubinfo) ! 454: ubadone(um); ! 455: um->um_tab.b_errcnt = 0; ! 456: dp->b_actf = bp->av_forw; ! 457: iodone(bp); ! 458: goto loop; ! 459: } ! 460: ! 461: /* ! 462: * Start operation on controller -- ! 463: * UNIBUS resources have been allocated. ! 464: */ ! 465: utdgo(um) ! 466: register struct uba_ctlr *um; ! 467: { ! 468: register struct utdevice *addr = (struct utdevice *)um->um_addr; ! 469: ! 470: addr->utba = (u_short) um->um_ubinfo; ! 471: addr->utcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300)|UT_IE|UT_GO; ! 472: } ! 473: ! 474: /* ! 475: * Ut interrupt handler ! 476: */ ! 477: /*ARGSUSED*/ ! 478: utintr(ut11) ! 479: int ut11; ! 480: { ! 481: struct buf *dp; ! 482: register struct buf *bp; ! 483: register struct uba_ctlr *um = utminfo[ut11]; ! 484: register struct utdevice *addr; ! 485: register struct tj_softc *sc; ! 486: u_short tjunit, cs2, cs1; ! 487: register state; ! 488: ! 489: if ((dp = um->um_tab.b_actf) == NULL) ! 490: return; ! 491: bp = dp->b_actf; ! 492: tjunit = TJUNIT(bp->b_dev); ! 493: addr = (struct utdevice *)tjdinfo[tjunit]->ui_addr; ! 494: sc = &tj_softc[tjunit]; ! 495: /* ! 496: * Record status... ! 497: */ ! 498: sc->sc_timo = INF; ! 499: sc->sc_dsreg = addr->utds; ! 500: sc->sc_erreg = addr->uter; ! 501: sc->sc_resid = MASKREG(addr->utfc); ! 502: if ((bp->b_flags&B_READ) == 0) ! 503: sc->sc_lastiow = 1; ! 504: state = um->um_tab.b_state; ! 505: um->um_tab.b_state = 0; ! 506: /* ! 507: * Check for errors... ! 508: */ ! 509: if ((addr->utds&UTDS_ERR) || (addr->utcs1&UT_TRE)) { ! 510: /* ! 511: * To clear the ERR bit, we must issue a drive clear ! 512: * command, and to clear the TRE bit we must set the ! 513: * controller clear bit. ! 514: */ ! 515: cs2 = addr->utcs2; ! 516: if ((cs1 = addr->utcs1)&UT_TRE) ! 517: addr->utcs2 |= UTCS2_CLR; ! 518: /* is this dangerous ?? */ ! 519: while ((addr->utcs1&UT_RDY) == 0) ! 520: ; ! 521: addr->utcs1 = UT_CLEAR|UT_GO; ! 522: /* ! 523: * If we were reading at 1600 or 6250 bpi and the error ! 524: * was corrected, then don't consider this an error. ! 525: */ ! 526: if (sc->sc_erreg & UTER_COR && (bp->b_flags & B_READ) && ! 527: (addr->uttc & UTTC_DEN) != UT_NRZI) { ! 528: tprintf(sc->sc_tpr, ! 529: "ut%d: soft error bn%d cs1=%b er=%b cs2=%b ds=%b\n", ! 530: tjunit, bp->b_blkno, cs1, UT_BITS, sc->sc_erreg, ! 531: UTER_BITS, cs2, UTCS2_BITS, sc->sc_dsreg, UTDS_BITS); ! 532: sc->sc_erreg &= ~UTER_COR; ! 533: } ! 534: /* ! 535: * If we were reading from a raw tape and the only error ! 536: * was that the record was too long, then we don't consider ! 537: * this an error. ! 538: */ ! 539: if ((bp->b_flags & (B_READ|B_RAW)) == (B_READ|B_RAW) && ! 540: (sc->sc_erreg&UTER_FCE)) ! 541: sc->sc_erreg &= ~UTER_FCE; ! 542: if (sc->sc_erreg == 0) ! 543: goto ignoreerr; ! 544: /* ! 545: * Fix up errors which occur due to backspacing ! 546: * "over" the front of the tape. ! 547: */ ! 548: if ((sc->sc_dsreg & UTDS_BOT) && bp->b_command == UT_SREV && ! 549: ((sc->sc_erreg &= ~(UTER_NEF|UTER_FCE)) == 0)) ! 550: goto opdone; ! 551: /* ! 552: * Retry soft errors up to 8 times ! 553: */ ! 554: if ((sc->sc_erreg&UTER_HARD) == 0 && state == SIO) { ! 555: if (++um->um_tab.b_errcnt < 7) { ! 556: sc->sc_blkno++; ! 557: ubadone(um); ! 558: goto opcont; ! 559: } ! 560: } ! 561: /* ! 562: * Hard or non-I/O errors on non-raw tape ! 563: * cause it to close. ! 564: */ ! 565: if ((bp->b_flags&B_RAW) == 0 && sc->sc_openf > 0) ! 566: sc->sc_openf = -1; ! 567: /* ! 568: * Couldn't recover error. ! 569: */ ! 570: tprintf(sc->sc_tpr, ! 571: "ut%d: hard error bn%d cs1=%b er=%b cs2=%b ds=%b\n", ! 572: tjunit, bp->b_blkno, cs1, UT_BITS, sc->sc_erreg, ! 573: UTER_BITS, cs2, UTCS2_BITS, sc->sc_dsreg, UTDS_BITS); ! 574: bp->b_flags |= B_ERROR; ! 575: goto opdone; ! 576: } ! 577: ! 578: ignoreerr: ! 579: /* ! 580: * If we hit a tape mark update our position. ! 581: */ ! 582: if (sc->sc_dsreg & UTDS_TM && bp->b_flags & B_READ) { ! 583: /* ! 584: * Set blkno and nxrec ! 585: */ ! 586: if (bp == &cutbuf[UTUNIT(bp->b_dev)]) { ! 587: if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) { ! 588: sc->sc_nxrec = ! 589: bdbtofsb(bp->b_blkno) - addr->utfc; ! 590: sc->sc_blkno = sc->sc_nxrec; ! 591: } else { ! 592: sc->sc_blkno = ! 593: bdbtofsb(bp->b_blkno) + addr->utfc; ! 594: sc->sc_nxrec = sc->sc_blkno-1; ! 595: } ! 596: } else ! 597: sc->sc_nxrec = bdbtofsb(bp->b_blkno); ! 598: /* ! 599: * Note: if we get a tape mark on a read, the ! 600: * frame count register will be zero, so b_resid ! 601: * will be calculated correctly below. ! 602: */ ! 603: goto opdone; ! 604: } ! 605: /* ! 606: * Advance tape control FSM. ! 607: */ ! 608: switch (state) { ! 609: ! 610: case SIO: /* read/write increments tape block # */ ! 611: sc->sc_blkno++; ! 612: sc->sc_blks++; ! 613: if (um->um_tab.b_errcnt) ! 614: sc->sc_softerrs++; ! 615: break; ! 616: ! 617: case SCOM: /* motion commands update current position */ ! 618: if (bp == &cutbuf[UTUNIT(bp->b_dev)]) ! 619: switch ((int)bp->b_command) { ! 620: ! 621: case UT_SFORW: ! 622: sc->sc_blkno -= bp->b_repcnt; ! 623: break; ! 624: ! 625: case UT_SREV: ! 626: sc->sc_blkno += bp->b_repcnt; ! 627: break; ! 628: ! 629: case UT_REWOFFL: ! 630: addr->utcs1 = UT_CLEAR|UT_GO; ! 631: break; ! 632: } ! 633: break; ! 634: ! 635: case SSEEK: ! 636: sc->sc_blkno = bdbtofsb(bp->b_blkno); ! 637: goto opcont; ! 638: ! 639: case SERASE: ! 640: /* ! 641: * Completed erase of the inter-record gap due to a ! 642: * write error; now retry the write operation. ! 643: */ ! 644: um->um_tab.b_state = SERASED; ! 645: goto opcont; ! 646: ! 647: case SREW: /* clear attention bit */ ! 648: addr->utcs1 = UT_CLEAR|UT_GO; ! 649: break; ! 650: ! 651: default: ! 652: printf("bad state %d\n", state); ! 653: panic("utintr"); ! 654: } ! 655: ! 656: opdone: ! 657: /* ! 658: * Reset error count and remove ! 659: * from device queue ! 660: */ ! 661: um->um_tab.b_errcnt = 0; ! 662: dp->b_actf = bp->av_forw; ! 663: /* ! 664: * For read command, frame count register contains ! 665: * actual length of tape record. Otherwise, it ! 666: * holds negative residual count. ! 667: */ ! 668: if (state == SIO && um->um_cmd == UT_RCOM) { ! 669: bp->b_resid = 0; ! 670: if (bp->b_bcount > MASKREG(addr->utfc)) ! 671: bp->b_resid = bp->b_bcount - MASKREG(addr->utfc); ! 672: } else ! 673: bp->b_resid = MASKREG(-addr->utfc); ! 674: ubadone(um); ! 675: iodone(bp); ! 676: /* ! 677: * Circulate slave to end of controller queue ! 678: * to give other slaves a chance ! 679: */ ! 680: um->um_tab.b_actf = dp->b_forw; ! 681: if (dp->b_actf) { ! 682: dp->b_forw = NULL; ! 683: if (um->um_tab.b_actf == NULL) ! 684: um->um_tab.b_actf = dp; ! 685: else ! 686: um->um_tab.b_actl->b_forw = dp; ! 687: um->um_tab.b_actl = dp; ! 688: } ! 689: if (um->um_tab.b_actf == 0) ! 690: return; ! 691: opcont: ! 692: utstart(um); ! 693: } ! 694: ! 695: /* ! 696: * Watchdog timer routine. ! 697: */ ! 698: uttimer(dev) ! 699: int dev; ! 700: { ! 701: register struct tj_softc *sc = &tj_softc[TJUNIT(dev)]; ! 702: register short x; ! 703: ! 704: if (sc->sc_timo != INF && (sc->sc_timo -= 5) < 0) { ! 705: printf("tj%d: lost interrupt\n", TJUNIT(dev)); ! 706: sc->sc_timo = INF; ! 707: x = spl5(); ! 708: utintr(UTUNIT(dev)); ! 709: (void) splx(x); ! 710: } ! 711: timeout(uttimer, (caddr_t)dev, 5*hz); ! 712: } ! 713: ! 714: /*ARGSUSED*/ ! 715: utioctl(dev, cmd, data, flag) ! 716: dev_t dev; ! 717: caddr_t data; ! 718: { ! 719: register struct tj_softc *sc = &tj_softc[TJUNIT(dev)]; ! 720: register struct buf *bp = &cutbuf[UTUNIT(dev)]; ! 721: register callcount; ! 722: int fcount, error = 0; ! 723: struct mtop *mtop; ! 724: struct mtget *mtget; ! 725: /* we depend of the values and order of the MT codes here */ ! 726: static utops[] = ! 727: {UT_WEOF,UT_SFORWF,UT_SREVF,UT_SFORW,UT_SREV,UT_REW,UT_REWOFFL,UT_SENSE}; ! 728: ! 729: switch (cmd) { ! 730: ! 731: case MTIOCTOP: ! 732: mtop = (struct mtop *)data; ! 733: switch(mtop->mt_op) { ! 734: ! 735: case MTWEOF: ! 736: case MTFSF: case MTBSF: ! 737: case MTFSR: case MTBSR: ! 738: callcount = mtop->mt_count; ! 739: fcount = 1; ! 740: break; ! 741: ! 742: case MTREW: case MTOFFL: case MTNOP: ! 743: callcount = 1; ! 744: fcount = 1; ! 745: break; ! 746: ! 747: default: ! 748: return (ENXIO); ! 749: } ! 750: if (callcount <= 0 || fcount <= 0) ! 751: return (EINVAL); ! 752: while (--callcount >= 0) { ! 753: utcommand(dev, utops[mtop->mt_op], fcount); ! 754: if ((bp->b_flags&B_ERROR) || (sc->sc_dsreg&UTDS_BOT)) ! 755: break; ! 756: } ! 757: if (bp->b_flags&B_ERROR) ! 758: if ((error = bp->b_error)==0) ! 759: return (EIO); ! 760: return (error); ! 761: ! 762: case MTIOCGET: ! 763: mtget = (struct mtget *)data; ! 764: mtget->mt_dsreg = sc->sc_dsreg; ! 765: mtget->mt_erreg = sc->sc_erreg; ! 766: mtget->mt_resid = sc->sc_resid; ! 767: mtget->mt_type = MT_ISUT; ! 768: break; ! 769: ! 770: default: ! 771: return (ENXIO); ! 772: } ! 773: return (0); ! 774: } ! 775: ! 776: utreset(uban) ! 777: int uban; ! 778: { ! 779: register struct uba_ctlr *um; ! 780: register ut11, tjunit; ! 781: register struct uba_device *ui; ! 782: register struct buf *dp; ! 783: ! 784: for (ut11 = 0; ut11 < NUT; ut11++) { ! 785: if ((um = utminfo[ut11]) == 0 || um->um_alive == 0 || ! 786: um->um_ubanum != uban) ! 787: continue; ! 788: printf(" ut%d", ut11); ! 789: um->um_tab.b_state = 0; ! 790: um->um_tab.b_actf = um->um_tab.b_actl = 0; ! 791: if (um->um_ubinfo) { ! 792: printf("<%d>", (um->um_ubinfo>>28)&0xf); ! 793: um->um_ubinfo = 0; ! 794: } ! 795: ((struct utdevice *)(um->um_addr))->utcs1 = UT_CLEAR|UT_GO; ! 796: ((struct utdevice *)(um->um_addr))->utcs2 |= UTCS2_CLR; ! 797: for (tjunit = 0; tjunit < NTJ; tjunit++) { ! 798: if ((ui = tjdinfo[tjunit]) == 0 || ui->ui_mi != um || ! 799: ui->ui_alive == 0) ! 800: continue; ! 801: dp = &tjutab[tjunit]; ! 802: dp->b_state = 0; ! 803: dp->b_forw = 0; ! 804: if (um->um_tab.b_actf == NULL) ! 805: um->um_tab.b_actf = dp; ! 806: else ! 807: um->um_tab.b_actl->b_forw = dp; ! 808: um->um_tab.b_actl = dp; ! 809: if (tj_softc[tjunit].sc_openf > 0) ! 810: tj_softc[tjunit].sc_openf = -1; ! 811: } ! 812: utstart(um); ! 813: } ! 814: } ! 815: ! 816: /* ! 817: * Do a stand-alone core dump to tape -- ! 818: * from here down, routines are used only in dump context ! 819: */ ! 820: #define DBSIZE 20 ! 821: ! 822: utdump() ! 823: { ! 824: register struct uba_device *ui; ! 825: register struct uba_regs *up; ! 826: register struct utdevice *addr; ! 827: int blk, num = maxfree; ! 828: int start = 0; ! 829: ! 830: #define phys(a,b) ((b)((int)(a)&0x7fffffff)) ! 831: if (tjdinfo[0] == 0) ! 832: return (ENXIO); ! 833: ui = phys(tjdinfo[0], struct uba_device *); ! 834: up = phys(ui->ui_hd, struct uba_hd *)->uh_physuba; ! 835: ubainit(up); ! 836: DELAY(1000000); ! 837: addr = (struct utdevice *)ui->ui_physaddr; ! 838: utwait(addr); ! 839: /* ! 840: * Be sure to set the appropriate density here. We use ! 841: * 6250, but maybe it should be done at 1600 to insure the ! 842: * tape can be read by most any other tape drive available. ! 843: */ ! 844: addr->uttc = UT_GCR|PDP11FMT; /* implicit slave 0 or-ed in */ ! 845: addr->utcs1 = UT_CLEAR|UT_GO; ! 846: while (num > 0) { ! 847: blk = num > DBSIZE ? DBSIZE : num; ! 848: utdwrite(start, blk, addr, up); ! 849: if ((addr->utds&UTDS_ERR) || (addr->utcs1&UT_TRE)) ! 850: return(EIO); ! 851: start += blk; ! 852: num -= blk; ! 853: } ! 854: uteof(addr); ! 855: uteof(addr); ! 856: utwait(addr); ! 857: if ((addr->utds&UTDS_ERR) || (addr->utcs1&UT_TRE)) ! 858: return(EIO); ! 859: addr->utcs1 = UT_REW|UT_GO; ! 860: return (0); ! 861: } ! 862: ! 863: utdwrite(dbuf, num, addr, up) ! 864: register dbuf, num; ! 865: register struct utdevice *addr; ! 866: struct uba_regs *up; ! 867: { ! 868: register struct pte *io; ! 869: register int npf; ! 870: ! 871: utwait(addr); ! 872: io = up->uba_map; ! 873: npf = num + 1; ! 874: while (--npf != 0) ! 875: *(int *)io++ = (dbuf++ | (1<<UBAMR_DPSHIFT) | UBAMR_MRV); ! 876: *(int *)io = 0; ! 877: addr->utwc = -((num*NBPG)>>1); ! 878: addr->utfc = -(num*NBPG); ! 879: addr->utba = 0; ! 880: addr->utcs1 = UT_WCOM|UT_GO; ! 881: } ! 882: ! 883: utwait(addr) ! 884: struct utdevice *addr; ! 885: { ! 886: register s; ! 887: ! 888: do ! 889: s = addr->utds; ! 890: while ((s&UTDS_DRY) == 0); ! 891: } ! 892: ! 893: uteof(addr) ! 894: struct utdevice *addr; ! 895: { ! 896: ! 897: utwait(addr); ! 898: addr->utcs1 = UT_WEOF|UT_GO; ! 899: } ! 900: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.