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