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
|
Last modified: 1986-06-05
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 3113 |
|