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