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: * @(#)ts.c 7.1 (Berkeley) 6/5/86 7: */ 8: 9: #include "ts.h" 10: #if NTS > 0 11: /* 12: * TS11 tape driver 13: * 14: * TODO: 15: * write dump code 16: */ 17: #include "../machine/pte.h" 18: 19: #include "param.h" 20: #include "systm.h" 21: #include "buf.h" 22: #include "dir.h" 23: #include "conf.h" 24: #include "user.h" 25: #include "file.h" 26: #include "map.h" 27: #include "vm.h" 28: #include "ioctl.h" 29: #include "mtio.h" 30: #include "cmap.h" 31: #include "uio.h" 32: #include "tty.h" 33: 34: #include "../vax/cpu.h" 35: #include "ubareg.h" 36: #include "ubavar.h" 37: #include "tsreg.h" 38: 39: /* 40: * There is a ctsbuf per tape controller. 41: * It is used as the token to pass to the internal routines 42: * to execute tape ioctls. 43: * In particular, when the tape is rewinding on close we release 44: * the user process but any further attempts to use the tape drive 45: * before the rewind completes will hang waiting for ctsbuf. 46: */ 47: struct buf ctsbuf[NTS]; 48: 49: /* 50: * Raw tape operations use rtsbuf. The driver 51: * notices when rtsbuf is being used and allows the user 52: * program to continue after errors and read records 53: * not of the standard length (BSIZE). 54: */ 55: struct buf rtsbuf[NTS]; 56: 57: /* 58: * Driver unibus interface routines and variables. 59: */ 60: int tsprobe(), tsslave(), tsattach(), tsdgo(), tsintr(); 61: struct uba_ctlr *tsminfo[NTS]; 62: struct uba_device *tsdinfo[NTS]; 63: struct buf tsutab[NTS]; 64: u_short tsstd[] = { 0772520, 0 }; 65: /*** PROBABLY DON'T NEED ALL THESE SINCE CONTROLLER == DRIVE ***/ 66: struct uba_driver zsdriver = 67: { tsprobe, tsslave, tsattach, tsdgo, tsstd, "ts", tsdinfo, "zs", tsminfo, 0 }; 68: 69: /* bits in minor device */ 70: #define TSUNIT(dev) (minor(dev)&03) 71: #define T_NOREWIND 04 72: 73: #define INF (daddr_t)1000000L 74: 75: /* 76: * Software state per tape transport. 77: * Also contains hardware state in message packets. 78: * 79: * 1. A tape drive is a unique-open device; we refuse opens when it is already. 80: * 2. We keep track of the current position on a block tape and seek 81: * before operations by forward/back spacing if necessary. 82: * 3. We remember if the last operation was a write on a tape, so if a tape 83: * is open read write and the last thing done is a write we can 84: * write a standard end of tape mark (two eofs). 85: * 4. We remember the status registers after the last command, using 86: * then internally and returning them to the SENSE ioctl. 87: */ 88: struct ts_softc { 89: char sc_openf; /* lock against multiple opens */ 90: char sc_lastiow; /* last op was a write */ 91: short sc_resid; /* copy of last bc */ 92: daddr_t sc_blkno; /* block number, for block device tape */ 93: daddr_t sc_nxrec; /* position of end of tape, if known */ 94: struct ts_cmd sc_cmd; /* the command packet */ 95: struct ts_sts sc_sts; /* status packet, for returned status */ 96: struct ts_char sc_char; /* characteristics packet */ 97: struct ts_softc *sc_ubaddr; /* Unibus address of ts_softc structure */ 98: u_short sc_uba; /* Unibus addr of cmd pkt for tsdb */ 99: short sc_mapped; /* is ts_sfotc mapped in Unibus space? */ 100: struct tty *sc_ttyp; /* record user's tty for errors */ 101: } ts_softc[NTS]; 102: 103: /* 104: * States for um->um_tab.b_active, the per controller state flag. 105: * This is used to sequence control in the driver. 106: */ 107: #define SSEEK 1 /* seeking */ 108: #define SIO 2 /* doing seq i/o */ 109: #define SCOM 3 /* sending control command */ 110: #define SREW 4 /* sending a drive rewind */ 111: 112: /* 113: * Determine if there is a controller for 114: * a ts at address reg. Our goal is to make the 115: * device interrupt. 116: */ 117: /*ARGSUSED*/ 118: tsprobe(reg) 119: caddr_t reg; 120: { 121: register int br, cvec; /* must be r11,r10; value-result */ 122: 123: #ifdef lint 124: br = 0; cvec = br; br = cvec; 125: tsintr(0); 126: #endif 127: ((struct tsdevice *)reg)->tssr = 0; 128: DELAY(100); 129: if ((((struct tsdevice *)reg)->tssr & TS_NBA) == 0) 130: return(0); 131: /* IT'S TOO HARD TO MAKE THIS THING INTERRUPT JUST TO FIND ITS VECTOR */ 132: cvec = ((unsigned)reg) & 07 ? 0260 : 0224; 133: br = 0x15; 134: return (sizeof (struct tsdevice)); 135: } 136: 137: /* 138: * TS11 only supports one drive per controller; 139: * check for ui_slave == 0. 140: * 141: * DO WE REALLY NEED THIS ROUTINE??? 142: */ 143: /*ARGSUSED*/ 144: tsslave(ui, reg) 145: struct uba_device *ui; 146: caddr_t reg; 147: { 148: 149: if (ui->ui_slave) /* non-zero slave not allowed */ 150: return(0); 151: return (1); 152: } 153: 154: /* 155: * Record attachment of the unit to the controller. 156: * 157: * SHOULD THIS ROUTINE DO ANYTHING??? 158: */ 159: /*ARGSUSED*/ 160: tsattach(ui) 161: struct uba_device *ui; 162: { 163: 164: } 165: 166: /* 167: * Open the device. Tapes are unique open 168: * devices, so we refuse if it is already open. 169: * We also check that a tape is available, and 170: * don't block waiting here; if you want to wait 171: * for a tape you should timeout in user code. 172: */ 173: tsopen(dev, flag) 174: dev_t dev; 175: int flag; 176: { 177: register int tsunit; 178: register struct uba_device *ui; 179: register struct ts_softc *sc; 180: 181: tsunit = TSUNIT(dev); 182: if (tsunit>=NTS || (ui = tsdinfo[tsunit]) == 0 || ui->ui_alive == 0) 183: return (ENXIO); 184: if ((sc = &ts_softc[tsunit])->sc_openf) 185: return (EBUSY); 186: if (tsinit(tsunit)) 187: return (ENXIO); 188: tscommand(dev, TS_SENSE, 1); 189: if ((sc->sc_sts.s_xs0&TS_ONL) == 0) { 190: uprintf("ts%d: not online\n", tsunit); 191: return (EIO); 192: } 193: if ((flag&FWRITE) && (sc->sc_sts.s_xs0&TS_WLK)) { 194: uprintf("ts%d: no write ring\n", tsunit); 195: return (EIO); 196: } 197: sc->sc_openf = 1; 198: sc->sc_blkno = (daddr_t)0; 199: sc->sc_nxrec = INF; 200: sc->sc_lastiow = 0; 201: sc->sc_ttyp = u.u_ttyp; 202: return (0); 203: } 204: 205: /* 206: * Close tape device. 207: * 208: * If tape was open for writing or last operation was 209: * a write, then write two EOF's and backspace over the last one. 210: * Unless this is a non-rewinding special file, rewind the tape. 211: * Make the tape available to others. 212: */ 213: tsclose(dev, flag) 214: register dev_t dev; 215: register flag; 216: { 217: register struct ts_softc *sc = &ts_softc[TSUNIT(dev)]; 218: 219: if (flag == FWRITE || (flag&FWRITE) && sc->sc_lastiow) { 220: tscommand(dev, TS_WEOF, 1); 221: tscommand(dev, TS_WEOF, 1); 222: tscommand(dev, TS_SREV, 1); 223: } 224: if ((minor(dev)&T_NOREWIND) == 0) 225: /* 226: * 0 count means don't hang waiting for rewind complete 227: * rather ctsbuf stays busy until the operation completes 228: * preventing further opens from completing by 229: * preventing a TS_SENSE from completing. 230: */ 231: tscommand(dev, TS_REW, 0); 232: sc->sc_openf = 0; 233: } 234: 235: /* 236: * Initialize the TS11. Set up Unibus mapping for command 237: * packets and set device characteristics. 238: */ 239: tsinit(unit) 240: register int unit; 241: { 242: register struct ts_softc *sc = &ts_softc[unit]; 243: register struct uba_ctlr *um = tsminfo[unit]; 244: register struct tsdevice *addr = (struct tsdevice *)um->um_addr; 245: register int i; 246: 247: /* 248: * Map the command and message packets into Unibus 249: * address space. We do all the command and message 250: * packets at once to minimize the amount of Unibus 251: * mapping necessary. 252: */ 253: if (sc->sc_mapped == 0) { 254: ctsbuf[unit].b_un.b_addr = (caddr_t)sc; 255: ctsbuf[unit].b_bcount = sizeof(*sc); 256: i = ubasetup(um->um_ubanum, &ctsbuf[unit], 0); 257: i &= 0777777; 258: sc->sc_ubaddr = (struct ts_softc *)i; 259: sc->sc_mapped++; 260: } 261: /* 262: * Now initialize the TS11 controller. 263: * Set the characteristics. 264: */ 265: if (addr->tssr & (TS_NBA|TS_OFL)) { 266: addr->tssr = 0; /* subsystem initialize */ 267: tswait(addr); 268: i = (int)&sc->sc_ubaddr->sc_cmd; /* Unibus addr of cmd */ 269: sc->sc_uba = (u_short)(i + ((i>>16)&3)); 270: sc->sc_char.char_addr = (int)&sc->sc_ubaddr->sc_sts; 271: sc->sc_char.char_size = sizeof(struct ts_sts); 272: sc->sc_char.char_mode = TS_ESS; 273: sc->sc_cmd.c_cmd = TS_ACK | TS_SETCHR; 274: i = (int)&sc->sc_ubaddr->sc_char; 275: sc->sc_cmd.c_loba = i; 276: sc->sc_cmd.c_hiba = (i>>16)&3; 277: sc->sc_cmd.c_size = sizeof(struct ts_char); 278: addr->tsdb = sc->sc_uba; 279: tswait(addr); 280: if (addr->tssr & TS_NBA) 281: return(1); 282: } 283: return(0); 284: } 285: 286: /* 287: * Execute a command on the tape drive 288: * a specified number of times. 289: */ 290: tscommand(dev, com, count) 291: dev_t dev; 292: int com, count; 293: { 294: register struct buf *bp; 295: register int s; 296: 297: bp = &ctsbuf[TSUNIT(dev)]; 298: s = spl5(); 299: while (bp->b_flags&B_BUSY) { 300: /* 301: * This special check is because B_BUSY never 302: * gets cleared in the non-waiting rewind case. 303: */ 304: if (bp->b_repcnt == 0 && (bp->b_flags&B_DONE)) 305: break; 306: bp->b_flags |= B_WANTED; 307: sleep((caddr_t)bp, PRIBIO); 308: } 309: bp->b_flags = B_BUSY|B_READ; 310: splx(s); 311: bp->b_dev = dev; 312: bp->b_repcnt = count; 313: bp->b_command = com; 314: bp->b_blkno = 0; 315: tsstrategy(bp); 316: /* 317: * In case of rewind from close, don't wait. 318: * This is the only case where count can be 0. 319: */ 320: if (count == 0) 321: return; 322: iowait(bp); 323: if (bp->b_flags&B_WANTED) 324: wakeup((caddr_t)bp); 325: bp->b_flags &= B_ERROR; 326: } 327: 328: /* 329: * Queue a tape operation. 330: */ 331: tsstrategy(bp) 332: register struct buf *bp; 333: { 334: int tsunit = TSUNIT(bp->b_dev); 335: register struct uba_ctlr *um; 336: register struct buf *dp; 337: register int s; 338: 339: /* 340: * Put transfer at end of controller queue 341: */ 342: bp->av_forw = NULL; 343: um = tsdinfo[tsunit]->ui_mi; 344: s = spl5(); 345: dp = &tsutab[tsunit]; 346: if (dp->b_actf == NULL) 347: dp->b_actf = bp; 348: else 349: dp->b_actl->av_forw = bp; 350: dp->b_actl = bp; 351: um->um_tab.b_actf = um->um_tab.b_actl = dp; 352: /* 353: * If the controller is not busy, get 354: * it going. 355: */ 356: if (um->um_tab.b_active == 0) 357: tsstart(um); 358: splx(s); 359: } 360: 361: /* 362: * Start activity on a ts controller. 363: */ 364: tsstart(um) 365: register struct uba_ctlr *um; 366: { 367: register struct buf *bp; 368: register struct tsdevice *addr = (struct tsdevice *)um->um_addr; 369: register struct ts_softc *sc; 370: register struct ts_cmd *tc; 371: register struct uba_device *ui; 372: int tsunit, cmd; 373: daddr_t blkno; 374: 375: /* 376: * Start the controller if there is something for it to do. 377: */ 378: loop: 379: if ((bp = um->um_tab.b_actf->b_actf) == NULL) 380: return; 381: tsunit = TSUNIT(bp->b_dev); 382: ui = tsdinfo[tsunit]; 383: sc = &ts_softc[tsunit]; 384: tc = &sc->sc_cmd; 385: /* 386: * Default is that last command was NOT a write command; 387: * if we do a write command we will notice this in tsintr(). 388: */ 389: sc->sc_lastiow = 0; 390: if (sc->sc_openf < 0 || (addr->tssr&TS_OFL)) { 391: /* 392: * Have had a hard error on a non-raw tape 393: * or the tape unit is now unavailable 394: * (e.g. taken off line). 395: */ 396: bp->b_flags |= B_ERROR; 397: goto next; 398: } 399: if (bp == &ctsbuf[TSUNIT(bp->b_dev)]) { 400: /* 401: * Execute control operation with the specified count. 402: */ 403: um->um_tab.b_active = 404: bp->b_command == TS_REW ? SREW : SCOM; 405: tc->c_repcnt = bp->b_repcnt; 406: goto dobpcmd; 407: } 408: /* 409: * The following checks handle boundary cases for operation 410: * on non-raw tapes. On raw tapes the initialization of 411: * sc->sc_nxrec by tsphys causes them to be skipped normally 412: * (except in the case of retries). 413: */ 414: if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) { 415: /* 416: * Can't read past known end-of-file. 417: */ 418: bp->b_flags |= B_ERROR; 419: bp->b_error = ENXIO; 420: goto next; 421: } 422: if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec && 423: bp->b_flags&B_READ) { 424: /* 425: * Reading at end of file returns 0 bytes. 426: */ 427: bp->b_resid = bp->b_bcount; 428: clrbuf(bp); 429: goto next; 430: } 431: if ((bp->b_flags&B_READ) == 0) 432: /* 433: * Writing sets EOF 434: */ 435: sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1; 436: /* 437: * If the data transfer command is in the correct place, 438: * set up all the registers except the csr, and give 439: * control over to the UNIBUS adapter routines, to 440: * wait for resources to start the i/o. 441: */ 442: if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) { 443: tc->c_size = bp->b_bcount; 444: if ((bp->b_flags&B_READ) == 0) 445: cmd = TS_WCOM; 446: else 447: cmd = TS_RCOM; 448: if (um->um_tab.b_errcnt) 449: cmd |= TS_RETRY; 450: um->um_tab.b_active = SIO; 451: tc->c_cmd = TS_ACK | TS_CVC | TS_IE | cmd; 452: (void) ubago(ui); 453: return; 454: } 455: /* 456: * Tape positioned incorrectly; 457: * set to seek forwards or backwards to the correct spot. 458: * This happens for raw tapes only on error retries. 459: */ 460: um->um_tab.b_active = SSEEK; 461: if (blkno < bdbtofsb(bp->b_blkno)) { 462: bp->b_command = TS_SFORW; 463: tc->c_repcnt = bdbtofsb(bp->b_blkno) - blkno; 464: } else { 465: bp->b_command = TS_SREV; 466: tc->c_repcnt = blkno - bdbtofsb(bp->b_blkno); 467: } 468: dobpcmd: 469: /* 470: * Do the command in bp. 471: */ 472: tc->c_cmd = TS_ACK | TS_CVC | TS_IE | bp->b_command; 473: addr->tsdb = sc->sc_uba; 474: return; 475: 476: next: 477: /* 478: * Done with this operation due to error or 479: * the fact that it doesn't do anything. 480: * Release UBA resources (if any), dequeue 481: * the transfer and continue processing this slave. 482: */ 483: if (um->um_ubinfo) 484: ubadone(um); 485: um->um_tab.b_errcnt = 0; 486: um->um_tab.b_actf->b_actf = bp->av_forw; 487: iodone(bp); 488: goto loop; 489: } 490: 491: /* 492: * The UNIBUS resources we needed have been 493: * allocated to us; start the device. 494: */ 495: tsdgo(um) 496: register struct uba_ctlr *um; 497: { 498: register struct tsdevice *addr = (struct tsdevice *)um->um_addr; 499: register struct ts_softc *sc = &ts_softc[um->um_ctlr]; 500: register int i; 501: 502: /* 503: * The uba code uses byte-offset mode if using bdp; 504: * mask off the low bit here. 505: */ 506: i = um->um_ubinfo & 0777777; 507: if (UBAI_BDP(um->um_ubinfo)) 508: i &= ~1; 509: sc->sc_cmd.c_loba = i; 510: sc->sc_cmd.c_hiba = (i>>16)&3; 511: addr->tsdb = sc->sc_uba; 512: } 513: 514: /* 515: * Ts interrupt routine. 516: */ 517: /*ARGSUSED*/ 518: tsintr(ts11) 519: int ts11; 520: { 521: register struct buf *bp; 522: register struct uba_ctlr *um = tsminfo[ts11]; 523: register struct tsdevice *addr; 524: register struct ts_softc *sc; 525: int tsunit; 526: register state; 527: #if VAX630 528: spl5(); 529: #endif 530: if ((bp = um->um_tab.b_actf->b_actf) == NULL) 531: return; 532: tsunit = TSUNIT(bp->b_dev); 533: addr = (struct tsdevice *)tsdinfo[tsunit]->ui_addr; 534: /* 535: * If last command was a rewind, and tape is still 536: * rewinding, wait for the rewind complete interrupt. 537: * 538: * SHOULD NEVER GET AN INTERRUPT IN THIS STATE. 539: */ 540: if (um->um_tab.b_active == SREW) { 541: um->um_tab.b_active = SCOM; 542: if ((addr->tssr&TS_SSR) == 0) 543: return; 544: } 545: /* 546: * An operation completed... record status 547: */ 548: sc = &ts_softc[tsunit]; 549: if ((bp->b_flags & B_READ) == 0) 550: sc->sc_lastiow = 1; 551: state = um->um_tab.b_active; 552: um->um_tab.b_active = 0; 553: /* 554: * Check for errors. 555: */ 556: if (addr->tssr&TS_SC) { 557: switch (addr->tssr & TS_TC) { 558: case TS_UNREC: /* unrecoverable */ 559: case TS_FATAL: /* fatal error */ 560: case TS_ATTN: /* attention (shouldn't happen) */ 561: case TS_RECNM: /* recoverable, no motion */ 562: break; 563: 564: case TS_SUCC: /* success termination */ 565: printf("ts%d: success\n", TSUNIT(minor(bp->b_dev))); 566: goto ignoreerr; 567: 568: case TS_ALERT: /* tape status alert */ 569: /* 570: * If we hit the end of the tape file, 571: * update our position. 572: */ 573: if (sc->sc_sts.s_xs0 & (TS_TMK|TS_EOT)) { 574: tsseteof(bp); /* set blkno and nxrec */ 575: state = SCOM; /* force completion */ 576: /* 577: * Stuff bc so it will be unstuffed correctly 578: * later to get resid. 579: */ 580: sc->sc_sts.s_rbpcr = bp->b_bcount; 581: goto opdone; 582: } 583: /* 584: * If we were reading raw tape and the record was too long 585: * or too short, then we don't consider this an error. 586: */ 587: if (bp == &rtsbuf[TSUNIT(bp->b_dev)] && (bp->b_flags&B_READ) && 588: sc->sc_sts.s_xs0&(TS_RLS|TS_RLL)) 589: goto ignoreerr; 590: case TS_RECOV: /* recoverable, tape moved */ 591: /* 592: * If this was an i/o operation retry up to 8 times. 593: */ 594: if (state==SIO) { 595: if (++um->um_tab.b_errcnt < 7) { 596: ubadone(um); 597: goto opcont; 598: } else 599: sc->sc_blkno++; 600: } else { 601: /* 602: * Non-i/o errors on non-raw tape 603: * cause it to close. 604: */ 605: if (sc->sc_openf>0 && bp != &rtsbuf[TSUNIT(bp->b_dev)]) 606: sc->sc_openf = -1; 607: } 608: break; 609: 610: case TS_REJECT: /* function reject */ 611: if (state == SIO && sc->sc_sts.s_xs0 & TS_WLE) 612: tprintf(sc->sc_ttyp, "ts%d: write locked\n", 613: TSUNIT(bp->b_dev)); 614: if ((sc->sc_sts.s_xs0 & TS_ONL) == 0) 615: tprintf(sc->sc_ttyp, "ts%d: offline\n", 616: TSUNIT(bp->b_dev)); 617: break; 618: } 619: /* 620: * Couldn't recover error 621: */ 622: tprintf(sc->sc_ttyp, "ts%d: hard error bn%d xs0=%b", 623: TSUNIT(bp->b_dev), bp->b_blkno, sc->sc_sts.s_xs0, TSXS0_BITS); 624: if (sc->sc_sts.s_xs1) 625: tprintf(sc->sc_ttyp, " xs1=%b", sc->sc_sts.s_xs1, 626: TSXS1_BITS); 627: if (sc->sc_sts.s_xs2) 628: tprintf(sc->sc_ttyp, " xs2=%b", sc->sc_sts.s_xs2, 629: TSXS2_BITS); 630: if (sc->sc_sts.s_xs3) 631: tprintf(sc->sc_ttyp, " xs3=%b", sc->sc_sts.s_xs3, 632: TSXS3_BITS); 633: tprintf(sc->sc_ttyp, "\n"); 634: bp->b_flags |= B_ERROR; 635: goto opdone; 636: } 637: /* 638: * Advance tape control FSM. 639: */ 640: ignoreerr: 641: switch (state) { 642: 643: case SIO: 644: /* 645: * Read/write increments tape block number 646: */ 647: sc->sc_blkno++; 648: goto opdone; 649: 650: case SCOM: 651: /* 652: * For forward/backward space record update current position. 653: */ 654: if (bp == &ctsbuf[TSUNIT(bp->b_dev)]) 655: switch ((int)bp->b_command) { 656: 657: case TS_SFORW: 658: sc->sc_blkno += bp->b_repcnt; 659: break; 660: 661: case TS_SREV: 662: sc->sc_blkno -= bp->b_repcnt; 663: break; 664: } 665: goto opdone; 666: 667: case SSEEK: 668: sc->sc_blkno = bdbtofsb(bp->b_blkno); 669: goto opcont; 670: 671: default: 672: panic("tsintr"); 673: } 674: opdone: 675: /* 676: * Reset error count and remove 677: * from device queue. 678: */ 679: um->um_tab.b_errcnt = 0; 680: um->um_tab.b_actf->b_actf = bp->av_forw; 681: bp->b_resid = sc->sc_sts.s_rbpcr; 682: ubadone(um); 683: iodone(bp); 684: if (um->um_tab.b_actf->b_actf == 0) 685: return; 686: opcont: 687: tsstart(um); 688: } 689: 690: tsseteof(bp) 691: register struct buf *bp; 692: { 693: register int tsunit = TSUNIT(bp->b_dev); 694: register struct ts_softc *sc = &ts_softc[tsunit]; 695: 696: if (bp == &ctsbuf[TSUNIT(bp->b_dev)]) { 697: if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) { 698: /* reversing */ 699: sc->sc_nxrec = bdbtofsb(bp->b_blkno) - sc->sc_sts.s_rbpcr; 700: sc->sc_blkno = sc->sc_nxrec; 701: } else { 702: /* spacing forward */ 703: sc->sc_blkno = bdbtofsb(bp->b_blkno) + sc->sc_sts.s_rbpcr; 704: sc->sc_nxrec = sc->sc_blkno - 1; 705: } 706: return; 707: } 708: /* eof on read */ 709: sc->sc_nxrec = bdbtofsb(bp->b_blkno); 710: } 711: 712: tsread(dev, uio) 713: dev_t dev; 714: struct uio *uio; 715: { 716: int errno; 717: 718: errno = tsphys(dev, uio); 719: if (errno) 720: return (errno); 721: return (physio(tsstrategy, &rtsbuf[TSUNIT(dev)], dev, B_READ, minphys, uio)); 722: } 723: 724: tswrite(dev, uio) 725: dev_t dev; 726: struct uio *uio; 727: { 728: int errno; 729: 730: errno = tsphys(dev, uio); 731: if (errno) 732: return (errno); 733: return (physio(tsstrategy, &rtsbuf[TSUNIT(dev)], dev, B_WRITE, minphys, uio)); 734: } 735: 736: /* 737: * Check that a raw device exists. 738: * If it does, set up sc_blkno and sc_nxrec 739: * so that the tape will appear positioned correctly. 740: */ 741: tsphys(dev, uio) 742: dev_t dev; 743: struct uio *uio; 744: { 745: register int tsunit = TSUNIT(dev); 746: register daddr_t a; 747: register struct ts_softc *sc; 748: register struct uba_device *ui; 749: 750: if (tsunit >= NTS || (ui=tsdinfo[tsunit]) == 0 || ui->ui_alive == 0) 751: return (ENXIO); 752: sc = &ts_softc[tsunit]; 753: a = bdbtofsb(uio->uio_offset >> 9); 754: sc->sc_blkno = a; 755: sc->sc_nxrec = a + 1; 756: return (0); 757: } 758: 759: tsreset(uban) 760: int uban; 761: { 762: register struct uba_ctlr *um; 763: register struct uba_device *ui; 764: register struct buf *dp; 765: register ts11; 766: 767: for (ts11 = 0; ts11 < NTS; ts11++) { 768: if ((um = tsminfo[ts11]) == 0 || um->um_alive == 0 || 769: um->um_ubanum != uban) 770: continue; 771: printf(" ts%d", ts11); 772: um->um_tab.b_active = 0; 773: um->um_tab.b_actf = um->um_tab.b_actl = 0; 774: if (ts_softc[ts11].sc_openf > 0) 775: ts_softc[ts11].sc_openf = -1; 776: if (um->um_ubinfo) { 777: printf("<%d>", (um->um_ubinfo>>28)&0xf); 778: um->um_ubinfo = 0; 779: } 780: if ((ui = tsdinfo[ts11]) && ui->ui_mi == um && ui->ui_alive) { 781: dp = &tsutab[ts11]; 782: dp->b_active = 0; 783: dp->b_forw = 0; 784: if (um->um_tab.b_actf == NULL) 785: um->um_tab.b_actf = dp; 786: else 787: um->um_tab.b_actl->b_forw = dp; 788: um->um_tab.b_actl = dp; 789: } 790: ts_softc[ts11].sc_mapped = 0; 791: (void) tsinit(ts11); 792: tsstart(um); 793: } 794: } 795: 796: /*ARGSUSED*/ 797: tsioctl(dev, cmd, data, flag) 798: caddr_t data; 799: dev_t dev; 800: { 801: int tsunit = TSUNIT(dev); 802: register struct ts_softc *sc = &ts_softc[tsunit]; 803: register struct buf *bp = &ctsbuf[TSUNIT(dev)]; 804: register callcount; 805: int fcount; 806: struct mtop *mtop; 807: struct mtget *mtget; 808: /* we depend of the values and order of the MT codes here */ 809: static tsops[] = 810: {TS_WEOF,TS_SFORWF,TS_SREVF,TS_SFORW,TS_SREV,TS_REW,TS_OFFL,TS_SENSE}; 811: 812: switch (cmd) { 813: 814: case MTIOCTOP: /* tape operation */ 815: mtop = (struct mtop *)data; 816: switch (mtop->mt_op) { 817: 818: case MTWEOF: 819: callcount = mtop->mt_count; 820: fcount = 1; 821: break; 822: 823: case MTFSF: case MTBSF: 824: case MTFSR: case MTBSR: 825: callcount = 1; 826: fcount = mtop->mt_count; 827: break; 828: 829: case MTREW: case MTOFFL: case MTNOP: 830: callcount = 1; 831: fcount = 1; 832: break; 833: 834: default: 835: return (ENXIO); 836: } 837: if (callcount <= 0 || fcount <= 0) 838: return (EINVAL); 839: while (--callcount >= 0) { 840: tscommand(dev, tsops[mtop->mt_op], fcount); 841: if ((mtop->mt_op == MTFSR || mtop->mt_op == MTBSR) && 842: bp->b_resid) 843: return (EIO); 844: if ((bp->b_flags&B_ERROR) || sc->sc_sts.s_xs0&TS_BOT) 845: break; 846: } 847: return (geterror(bp)); 848: 849: case MTIOCGET: 850: mtget = (struct mtget *)data; 851: mtget->mt_dsreg = 0; 852: mtget->mt_erreg = sc->sc_sts.s_xs0; 853: mtget->mt_resid = sc->sc_resid; 854: mtget->mt_type = MT_ISTS; 855: break; 856: 857: default: 858: return (ENXIO); 859: } 860: return (0); 861: } 862: 863: #define DBSIZE 20 864: 865: tsdump() 866: { 867: register struct uba_device *ui; 868: register struct uba_regs *up; 869: register struct tsdevice *addr; 870: int blk, num; 871: int start; 872: 873: start = 0; 874: num = maxfree; 875: #define phys(a,b) ((b)((int)(a)&0x7fffffff)) 876: if (tsdinfo[0] == 0) 877: return (ENXIO); 878: ui = phys(tsdinfo[0], struct uba_device *); 879: up = phys(ui->ui_hd, struct uba_hd *)->uh_physuba; 880: ubainit(up); 881: DELAY(1000000); 882: addr = (struct tsdevice *)ui->ui_physaddr; 883: addr->tssr = 0; 884: tswait(addr); 885: while (num > 0) { 886: blk = num > DBSIZE ? DBSIZE : num; 887: tsdwrite(start, blk, addr, up); 888: start += blk; 889: num -= blk; 890: } 891: tseof(addr); 892: tseof(addr); 893: tswait(addr); 894: if (addr->tssr&TS_SC) 895: return (EIO); 896: addr->tssr = 0; 897: tswait(addr); 898: return (0); 899: } 900: 901: tsdwrite(dbuf, num, addr, up) 902: register int dbuf, num; 903: register struct tsdevice *addr; 904: struct uba_regs *up; 905: { 906: register struct pte *io; 907: register int npf; 908: 909: tswait(addr); 910: io = up->uba_map; 911: npf = num+1; 912: while (--npf != 0) 913: *(int *)io++ = (dbuf++ | (1<<UBAMR_DPSHIFT) | UBAMR_MRV); 914: *(int *)io = 0; 915: #ifdef notyet 916: addr->tsbc = -(num*NBPG); 917: addr->tsba = 0; 918: addr->tscs = TS_WCOM | TM_GO; 919: #endif 920: } 921: 922: tswait(addr) 923: register struct tsdevice *addr; 924: { 925: register s; 926: 927: do 928: s = addr->tssr; 929: while ((s & TS_SSR) == 0); 930: } 931: 932: tseof(addr) 933: struct tsdevice *addr; 934: { 935: 936: tswait(addr); 937: #ifdef notyet 938: addr->tscs = TS_WEOF | TM_GO; 939: #endif 940: } 941: #endif
|
Last modified: 1986-06-05
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 2499 |
|