![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to st.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / sundev|
Return to st.c CVS log | Up to [Research Unix] / researchv9 / sys / sundev |
1.1 ! root 1: /* @(#)st.c 1.1 86/02/03 SMI */ ! 2: ! 3: /* ! 4: * Copyright (c) 1985 by Sun Microsystems, Inc. ! 5: */ ! 6: ! 7: #include "st.h" ! 8: #if NST > 0 ! 9: ! 10: /* ! 11: * Driver for Sysgen SC400 and Emulex MT02 SCSI tape controller. ! 12: */ ! 13: ! 14: #include "../h/param.h" ! 15: #include "../h/systm.h" ! 16: #include "../h/buf.h" ! 17: #include "../h/dir.h" ! 18: #include "../h/conf.h" ! 19: #include "../h/user.h" ! 20: #include "../h/file.h" ! 21: #include "../h/map.h" ! 22: #include "../h/vm.h" ! 23: #include "../h/mtio.h" ! 24: #include "../h/cmap.h" ! 25: ! 26: #include "../sun/dklabel.h" ! 27: #include "../sun/dkio.h" ! 28: #include "../machine/psl.h" ! 29: #include "../machine/mmu.h" ! 30: #include "../machine/cpu.h" ! 31: #include "../sundev/mbvar.h" ! 32: #include "../sundev/screg.h" ! 33: #include "../sundev/sireg.h" ! 34: #include "../sundev/scsi.h" ! 35: #include "../sundev/streg.h" ! 36: ! 37: #define INF 1000000000 ! 38: /* ! 39: * Max # of buffers outstanding per unit. ! 40: */ ! 41: #define MAXSTBUF 3 ! 42: ! 43: /* ! 44: * Bits in minor device. ! 45: */ ! 46: #define STUNIT(dev) (minor(dev) & 03) ! 47: #define T_NOREWIND 04 ! 48: #define QIC_24 8 ! 49: ! 50: extern struct scsi_unit stunits[]; ! 51: extern struct scsi_unit_subr scsi_unit_subr[]; ! 52: extern struct scsi_tape stape[]; ! 53: extern int nstape; ! 54: ! 55: /* ! 56: * Return a pointer to this unit's unit structure. ! 57: */ ! 58: stunitptr(md) ! 59: register struct mb_device *md; ! 60: { ! 61: return ((int)&stunits[md->md_unit]); ! 62: } ! 63: ! 64: /* ! 65: * Attach device (boot time). ! 66: */ ! 67: stattach(md) ! 68: register struct mb_device *md; ! 69: { ! 70: register struct scsi_unit *un; ! 71: register struct scsi_tape *dsi; ! 72: ! 73: un = &stunits[md->md_unit]; ! 74: dsi = &stape[md->md_unit]; ! 75: un->un_md = md; ! 76: un->un_mc = md->md_mc; ! 77: un->un_unit = md->md_unit; ! 78: un->un_target = TARGET(md->md_slave); ! 79: un->un_lun = LUN(md->md_slave); ! 80: un->un_ss = &scsi_unit_subr[TYPE(md->md_flags)]; ! 81: dsi->un_ctype = ST_TYPE_INVALID; ! 82: dsi->un_openf = CLOSED; ! 83: } ! 84: ! 85: stinit(dev) ! 86: dev_t dev; ! 87: { ! 88: register int unit; ! 89: register struct scsi_tape *dsi; ! 90: ! 91: unit = STUNIT(dev); ! 92: dsi = &stape[unit]; ! 93: ! 94: dsi->un_ctype = 1; ! 95: dsi->un_openf = OPENING; ! 96: stcmd(dev, SC_TEST_UNIT_READY, 0); ! 97: if (stcmd(dev, SC_REQUEST_SENSE, 0) == 0 || dsi->un_openf != OPEN) { ! 98: dsi->un_openf = OPENING; ! 99: if (stcmd(dev, SC_REQUEST_SENSE, 0) == 0 || ! 100: dsi->un_openf != OPEN) { ! 101: if (stcmd(dev, SC_REQUEST_SENSE, 0) == 0 || ! 102: dsi->un_openf != OPEN) { ! 103: if (dsi->un_openf == OPEN_FAILED) { ! 104: uprintf("st%d: no cartridge loaded\n", ! 105: unit); ! 106: } else { ! 107: uprintf("st%d: tape not online \n", ! 108: unit); ! 109: } ! 110: dsi->un_openf = CLOSED; ! 111: dsi->un_ctype = ST_TYPE_INVALID; ! 112: return (0); ! 113: } ! 114: } ! 115: } ! 116: dsi->un_openf = CLOSED; ! 117: return (1); ! 118: } ! 119: ! 120: sctopen(dev, flag) ! 121: dev_t dev; ! 122: int flag; ! 123: { ! 124: register struct scsi_unit *un; ! 125: register int unit, s; ! 126: register struct scsi_tape *dsi; ! 127: register int i; ! 128: ! 129: unit = STUNIT(dev); ! 130: if (unit > nstape) { ! 131: u.u_error = ENXIO; ! 132: return; ! 133: } ! 134: un = &stunits[unit]; ! 135: dsi = &stape[unit]; ! 136: if (un->un_mc == 0) { /* never attached */ ! 137: u.u_error = ENXIO; ! 138: return; ! 139: } ! 140: ! 141: /* determine type of tape controller */ ! 142: if (dsi->un_ctype == ST_TYPE_INVALID) { ! 143: if (stinit(dev) == 0) { ! 144: u.u_error = EIO; ! 145: return; ! 146: } ! 147: } ! 148: ! 149: s = spl6(); ! 150: if (dsi->un_openf != CLOSED) { /* already open */ ! 151: (void) splx(s); ! 152: u.u_error = EBUSY; ! 153: return; ! 154: } ! 155: dsi->un_openf = OPEN; ! 156: (void) splx(s); ! 157: dsi->un_read_only = 0; ! 158: ! 159: /* must be qic 24 format */ ! 160: if (!(minor(dev) & QIC_24)) { ! 161: dsi->un_openf = CLOSED; ! 162: u.u_error = EIO; ! 163: return; ! 164: } ! 165: if ((flag & FWRITE) && dsi->un_read_only) { ! 166: uprintf("st%d: cartridge is write protected \n", unit); ! 167: dsi->un_openf = CLOSED; ! 168: u.u_error = EIO; ! 169: return; ! 170: } ! 171: dsi->un_lastiow = 0; ! 172: dsi->un_lastior = 0; ! 173: dsi->un_next_block = 0; ! 174: dsi->un_last_block = INF; ! 175: /* if we reset these here they will never be preserved for "mt status" ! 176: dsi->un_retry_ct = 0; ! 177: dsi->un_underruns = 0; ! 178: */ ! 179: u.u_error = 0; ! 180: return; ! 181: } ! 182: ! 183: /*ARGSUSED*/ ! 184: sctclose(dev, flag) ! 185: register dev_t dev; ! 186: int flag; ! 187: { ! 188: register struct scsi_unit *un; ! 189: register struct scsi_tape *dsi; ! 190: ! 191: un = &stunits[STUNIT(dev)]; ! 192: dsi = &stape[STUNIT(dev)]; ! 193: dsi->un_openf = CLOSING; ! 194: if (dsi->un_lastiow) { ! 195: if (stcmd(dev, SC_WRITE_FILE_MARK, 0) == 0) { ! 196: printf("st%d: stclose failed to write file mark\n", ! 197: un - stunits); ! 198: } ! 199: } ! 200: if ((minor(dev) & T_NOREWIND) == 0) { ! 201: (void) stcmd(dev, SC_REWIND, -1); ! 202: } ! 203: dsi->un_openf = CLOSED; ! 204: } ! 205: ! 206: stcmd(dev, cmd, count) ! 207: dev_t dev; ! 208: int cmd, count; ! 209: { ! 210: register struct buf *bp; ! 211: register int s, error; ! 212: register struct scsi_unit *un; ! 213: ! 214: un = &stunits[STUNIT(dev)]; ! 215: bp = &un->un_sbuf; ! 216: s = splx(pritospl(un->un_mc->mc_intpri)); ! 217: while (bp->b_flags & B_BUSY) { ! 218: /* ! 219: * special test because B_BUSY never gets cleared in ! 220: * the non-waiting rewind case. ! 221: */ ! 222: if (bp->b_bcount == -1 && (bp->b_flags & B_DONE)) { ! 223: break; ! 224: } ! 225: bp->b_flags |= B_WANTED; ! 226: sleep((caddr_t) bp, PRIBIO); ! 227: } ! 228: bp->b_flags = B_BUSY | B_READ; ! 229: (void) splx(s); ! 230: bp->b_dev = dev; ! 231: bp->b_bcount = count; ! 232: un->un_scmd = cmd; ! 233: ststrategy(bp); ! 234: /* ! 235: * In case of rewind on close, don't wait. ! 236: */ ! 237: if (cmd == SC_REWIND && count == -1) { ! 238: return (1); ! 239: } ! 240: s = splx(pritospl(un->un_mc->mc_intpri)); ! 241: while ((bp->b_flags & B_DONE) == 0) { ! 242: sleep((caddr_t) bp, PRIBIO); ! 243: } ! 244: (void) splx(s); ! 245: error = geterror(bp); ! 246: if (bp->b_flags & B_WANTED) { ! 247: wakeup((caddr_t) bp); ! 248: } ! 249: bp->b_flags &= B_ERROR; /* clears B_BUSY */ ! 250: return (error == 0); ! 251: } ! 252: ! 253: ststrategy(bp) ! 254: register struct buf *bp; ! 255: { ! 256: register struct scsi_unit *un; ! 257: register int unit, s; ! 258: register struct buf *ap; ! 259: register struct scsi_tape *dsi; ! 260: ! 261: unit = STUNIT(bp->b_dev); ! 262: if (unit > nstape) { ! 263: printf("st%d: ststrategy: invalid unit %x\n", unit, unit); ! 264: bp->b_flags |= B_ERROR; ! 265: iodone(bp); ! 266: return; ! 267: } ! 268: un = &stunits[unit]; ! 269: dsi = &stape[unit]; ! 270: if (dsi->un_openf != OPEN && bp != &un->un_sbuf) { ! 271: bp->b_flags |= B_ERROR; ! 272: iodone(bp); ! 273: return; ! 274: } ! 275: s = splx(pritospl(un->un_mc->mc_intpri)); ! 276: while (dsi->un_bufcnt >= MAXSTBUF) { ! 277: sleep((caddr_t) &dsi->un_bufcnt, PRIBIO); ! 278: } ! 279: dsi->un_bufcnt++; ! 280: ! 281: /* ! 282: * Put the block at the end of the queue. ! 283: * Should probably have a pointer to the end of ! 284: * the queue, but the queue can't get too long, ! 285: * so the added code complexity probably isn't ! 286: * worth it. ! 287: */ ! 288: ap = &un->un_utab; ! 289: while (ap->b_actf != NULL) { ! 290: ap = ap->b_actf; ! 291: } ! 292: ap->b_actf = bp; ! 293: bp->b_actf = NULL; ! 294: if (un->un_utab.b_active == 0) { ! 295: (*un->un_c->c_ss->scs_ustart)(un); ! 296: bp = &un->un_mc->mc_tab; ! 297: if (bp->b_actf && bp->b_active == 0) { ! 298: (*un->un_c->c_ss->scs_start)(un); ! 299: } ! 300: } ! 301: (void) splx(s); ! 302: } ! 303: ! 304: /* ! 305: * Start the operation. ! 306: */ ! 307: /*ARGSUSED*/ ! 308: ststart(bp, un) ! 309: register struct buf *bp; ! 310: register struct scsi_unit *un; ! 311: { ! 312: register int bno; ! 313: register struct scsi_tape *dsi; ! 314: ! 315: dsi = &stape[STUNIT(bp->b_dev)]; ! 316: /* ! 317: * Default is that last command was NOT a read/write command; ! 318: * if we issue a read/write command we will notice this in stintr(). ! 319: */ ! 320: dsi->un_lastiow = 0; ! 321: dsi->un_lastior = 0; ! 322: if (bp == &un->un_sbuf) { ! 323: un->un_cmd = un->un_scmd; ! 324: un->un_count = bp->b_bcount; ! 325: } else if (bp == &un->un_rbuf) { ! 326: if (bp->b_flags & B_READ) { ! 327: if (dsi->un_eof) { ! 328: bp->b_resid = bp->b_bcount; ! 329: iodone(bp); ! 330: if (dsi->un_bufcnt-- >= MAXSTBUF) { ! 331: wakeup((caddr_t) &dsi->un_bufcnt); ! 332: } ! 333: return (0); ! 334: } ! 335: un->un_cmd = SC_READ; ! 336: } else { ! 337: un->un_cmd = SC_WRITE; ! 338: } ! 339: un->un_count = howmany(bp->b_bcount, DEV_BSIZE); ! 340: un->un_flags |= SC_UNF_DVMA; ! 341: } else { ! 342: bno = bp->b_blkno; ! 343: if (bno > dsi->un_last_block && bp->b_flags & B_READ) { ! 344: /* ! 345: * Can't read past EOF. ! 346: */ ! 347: bp->b_flags |= B_ERROR; ! 348: bp->b_error = EIO; ! 349: iodone(bp); ! 350: if (dsi->un_bufcnt-- >= MAXSTBUF) { ! 351: wakeup((caddr_t) &dsi->un_bufcnt); ! 352: } ! 353: return (0); ! 354: } ! 355: if (bno == dsi->un_last_block && bp->b_flags & B_READ) { ! 356: /* ! 357: * Reading at EOF returns 0 bytes. ! 358: */ ! 359: bp->b_resid = bp->b_bcount; ! 360: iodone(bp); ! 361: if (dsi->un_bufcnt-- >= MAXSTBUF) { ! 362: wakeup((caddr_t) &dsi->un_bufcnt); ! 363: } ! 364: return (0); ! 365: } ! 366: if ((bp->b_flags & B_READ) == 0) { ! 367: /* ! 368: * Writing sets EOF. ! 369: */ ! 370: dsi->un_last_block = bno + 1; ! 371: } ! 372: if (bno != dsi->un_next_block) { ! 373: /* ! 374: * Not the next record. ! 375: * In theory we could space forward, or even rewind ! 376: * and space forward, and maybe someday we will. ! 377: * For now, no one really needs this capability. ! 378: */ ! 379: bp->b_flags |= B_ERROR; ! 380: bp->b_error = ENXIO; ! 381: iodone(bp); ! 382: if (dsi->un_bufcnt-- >= MAXSTBUF) { ! 383: wakeup((caddr_t) &dsi->un_bufcnt); ! 384: } ! 385: return (0); ! 386: } ! 387: /* ! 388: * Position OK, we can do the read or write. ! 389: */ ! 390: if (bp->b_flags & B_READ) { ! 391: un->un_cmd = SC_READ; ! 392: } else { ! 393: un->un_cmd = SC_WRITE; ! 394: } ! 395: un->un_count = howmany(bp->b_bcount, DEV_BSIZE); ! 396: un->un_flags |= SC_UNF_DVMA; ! 397: } ! 398: bp->b_resid = 0; ! 399: return (1); ! 400: } ! 401: ! 402: /* ! 403: * Make a command description block. ! 404: */ ! 405: stmkcdb(c, un) ! 406: register struct scsi_ctlr *c; ! 407: register struct scsi_unit *un; ! 408: { ! 409: register struct scsi_cdb *cdb; ! 410: register struct scsi_tape *dsi; ! 411: int density = 0; ! 412: ! 413: cdb = &c->c_cdb; ! 414: bzero((caddr_t)cdb, sizeof (*cdb)); ! 415: cdb->cmd = un->un_cmd; ! 416: cdb->lun = un->un_lun; ! 417: un->un_dma_addr = un->un_dma_count = 0; ! 418: dsi = &stape[un->un_unit]; ! 419: ! 420: switch (un->un_cmd) { ! 421: ! 422: case SC_WRITE_FILE_MARK: ! 423: case SC_LOAD: ! 424: cdb->count = 1; ! 425: break; ! 426: ! 427: case SC_TEST_UNIT_READY: ! 428: break; ! 429: ! 430: case SC_REWIND: ! 431: break; ! 432: ! 433: case SC_ERASE_CARTRIDGE: ! 434: cdb->t_code = 1; ! 435: break; ! 436: ! 437: case SC_REQUEST_SENSE: ! 438: un->un_dma_addr = (int)c->c_sense - (int)DVMA; ! 439: un->un_dma_count = cdb->count = sizeof (struct st_archive_sense); ! 440: break; ! 441: ! 442: case SC_READ: ! 443: case SC_WRITE: ! 444: cdb->t_code = 1; ! 445: cdb->high_count = un->un_count >> 16; ! 446: cdb->mid_count = (un->un_count >> 8) & 0xFF; ! 447: cdb->low_count = un->un_count & 0xFF; ! 448: un->un_dma_addr = un->un_baddr; ! 449: un->un_dma_count = un->un_count * DEV_BSIZE; ! 450: break; ! 451: ! 452: case SC_SPACE_FILE: ! 453: if (un->un_count == 0) ! 454: cdb->t_code = 3; /* space to end */ ! 455: else ! 456: cdb->t_code = 1; /* space files, not records */ ! 457: /* fall through ... */ ! 458: ! 459: case SC_SPACE_REC: ! 460: cdb->cmd = SC_SPACE; ! 461: cdb->high_count = un->un_count >> 16; ! 462: cdb->mid_count = (un->un_count >> 8) & 0xFF; ! 463: cdb->low_count = un->un_count & 0xFF; ! 464: un->un_dma_addr = un->un_dma_count = 0; ! 465: break; ! 466: ! 467: default: ! 468: printf("st%d: stmkcdb: invalid command %x\n", un - stunits, ! 469: un->un_cmd); ! 470: break; ! 471: } ! 472: } ! 473: ! 474: stintr(c, resid, error) ! 475: register struct scsi_ctlr *c; ! 476: register int resid, error; ! 477: { ! 478: register struct scsi_unit *un; ! 479: register struct buf *bp; ! 480: register struct scsi_tape *dsi; ! 481: struct st_archive_sense *ars; ! 482: ! 483: un = c->c_un; ! 484: bp = un->un_mc->mc_tab.b_actf->b_actf; ! 485: dsi = &stape[STUNIT(bp->b_dev)]; ! 486: ars = (struct st_archive_sense *)c->c_sense; ! 487: ! 488: /* ! 489: * We determine which tape controller we have by the number of ! 490: * sense bytes we get back. ! 491: */ ! 492: if (dsi->un_openf == OPENING && un->un_cmd == SC_REQUEST_SENSE) { ! 493: if (resid || ST_NO_CART(dsi, c->c_sense)) { ! 494: dsi->un_openf = OPEN_FAILED; ! 495: } else { ! 496: dsi->un_openf = OPEN; ! 497: if (ST_WRITE_PROT(dsi, c->c_sense)) ! 498: dsi->un_read_only = 1; ! 499: } ! 500: } ! 501: ! 502: if (c->c_scb.busy) ! 503: bp->b_flags |= B_ERROR; ! 504: else if (error || c->c_scb.chk || resid > 0) { ! 505: if (c->c_scb.chk && ST_RESET(dsi, c->c_sense)) { ! 506: /* ! 507: * Power on or reset occurred ! 508: */ ! 509: dsi->un_reset_occurred = 1; ! 510: bp->b_flags |= B_ERROR; ! 511: } else if (c->c_scb.chk && ST_NO_CART(dsi, c->c_sense)) { ! 512: printf("st%d: no cartridge loaded \n", ! 513: un - stunits); ! 514: bp->b_flags |= B_ERROR; ! 515: } else if (c->c_scb.chk && ST_FILE_MARK(dsi, c->c_sense)) { ! 516: /* ! 517: * File mark detected. ! 518: */ ! 519: dsi->un_eof = 1; ! 520: switch (un->un_cmd) { ! 521: case SC_READ: ! 522: dsi->un_next_block += un->un_count - ! 523: resid / DEV_BSIZE; ! 524: dsi->un_last_block = dsi->un_next_block; ! 525: break; ! 526: case SC_SPACE_REC: ! 527: dsi->un_last_block = dsi->un_next_block += ! 528: un->un_count; /* a little high */ ! 529: break; ! 530: default: ! 531: printf("st%d: scsi tape hit eof on cmd %x\n", ! 532: un - stunits, un->un_cmd); ! 533: break; ! 534: } ! 535: bp->b_resid = resid; ! 536: } else if ((un->un_cmd == SC_WRITE || ! 537: un->un_cmd == SC_WRITE_FILE_MARK) && ! 538: c->c_scb.chk && ST_WRITE_PROT(dsi, c->c_sense)) { ! 539: /* ! 540: * Write protected tape. ! 541: */ ! 542: printf("st%d: tape is write protected \n, ", ! 543: un - stunits); ! 544: dsi->un_read_only = 1; ! 545: bp->b_flags |= B_ERROR; ! 546: } else if (c->c_scb.chk && ST_EOT(dsi, c->c_sense)) { ! 547: /* ! 548: * End of tape. ! 549: */ ! 550: bp->b_resid = bp->b_bcount; ! 551: if (un->un_cmd == SC_WRITE) { ! 552: /* ! 553: * Setting this flag makes stclose() ! 554: * write a file mark before closing. ! 555: * Until a file mark is written, the ! 556: * tape will return invalid command ! 557: * indications and not respond to ! 558: * rewinds. ! 559: */ ! 560: dsi->un_lastiow = 1; ! 561: } ! 562: } else if (c->c_scb.chk && ST_ILLEGAL(dsi, c->c_sense)) { ! 563: printf("st%d: illegal command 0x%x\n", un-stunits, un->un_cmd); ! 564: bp->b_flags |= B_ERROR; ! 565: } else if (ST_CORRECTABLE(dsi, c->c_sense)) ! 566: goto success; ! 567: else if (ST_EOD(dsi, c->c_sense)) ! 568: bp->b_flags |= B_ERROR; ! 569: else { ! 570: /* ! 571: * Some other error which we can't handle. ! 572: */ ! 573: if ((c->c_scb.chk && dsi->un_openf == OPEN)) ! 574: st_pr_sense(c, dsi); ! 575: bp->b_flags |= B_ERROR; ! 576: } ! 577: } else { ! 578: success: ! 579: switch (un->un_cmd) { ! 580: ! 581: case SC_REWIND: ! 582: case SC_ERASE_CARTRIDGE: ! 583: case SC_MODE_SELECT: ! 584: case SC_LOAD: ! 585: dsi->un_next_block = 0; ! 586: dsi->un_eof = 0; ! 587: break; ! 588: ! 589: case SC_WRITE: ! 590: dsi->un_lastiow = 1; ! 591: dsi->un_next_block += un->un_count; ! 592: break; ! 593: ! 594: case SC_READ: ! 595: dsi->un_lastior = 1; ! 596: dsi->un_next_block += un->un_count; ! 597: break; ! 598: ! 599: case SC_SPACE_FILE: ! 600: dsi->un_next_block = 0; ! 601: dsi->un_last_block = INF; ! 602: dsi->un_eof = 0; ! 603: break; ! 604: ! 605: case SC_SPACE_REC: ! 606: dsi->un_next_block += un->un_count; ! 607: break; ! 608: ! 609: case SC_REQUEST_SENSE: ! 610: dsi->un_status = ((char *)ars)[2]; ! 611: /* ! 612: if (ars->ext_sense.add_len >= AR_ES_ADD_LEN) { ! 613: dsi->un_retry_ct += ! 614: (ars->retries_msb << 8) + ! 615: ars->retries_lsb; ! 616: } ! 617: */ ! 618: break; ! 619: ! 620: case SC_TEST_UNIT_READY: ! 621: break; ! 622: ! 623: case SC_WRITE_FILE_MARK: ! 624: dsi->un_next_block = 0; ! 625: dsi->un_last_block = 0; /* i.e. no reads allowed */ ! 626: break; ! 627: ! 628: default: ! 629: printf("st%d: stintr: invalid command %x\n", ! 630: un - stunits, un->un_cmd); ! 631: break; ! 632: } ! 633: } ! 634: if (bp == &un->un_sbuf && ! 635: ((un->un_flags & SC_UNF_DVMA) == 0)) { ! 636: (*c->c_ss->scs_done)(un->un_mc); ! 637: } else { ! 638: mbdone(un->un_mc); ! 639: un->un_flags &= ~SC_UNF_DVMA; ! 640: } ! 641: if (dsi->un_bufcnt-- >= MAXSTBUF) { ! 642: wakeup((caddr_t) &dsi->un_bufcnt); ! 643: } ! 644: } ! 645: ! 646: st_pr_sense(c, dsi) ! 647: register struct scsi_ctlr *c; ! 648: register struct scsi_tape *dsi; ! 649: { ! 650: register struct scsi_unit *un; ! 651: register u_char *cp; ! 652: register int i; ! 653: ! 654: un = c->c_un; ! 655: cp = (u_char *)c->c_sense; ! 656: printf("st%d: stintr: sense ", un - stunits); ! 657: for (i=0; i < sizeof (struct st_archive_sense); i++) ! 658: printf("%x ", *cp++); ! 659: printf("\n"); ! 660: } ! 661: ! 662: sctread(dev) ! 663: register dev_t dev; ! 664: { ! 665: register struct scsi_unit *un; ! 666: register int unit, r, resid; ! 667: register struct scsi_tape *dsi; ! 668: ! 669: unit = STUNIT(dev); ! 670: if (unit > nstape) { ! 671: u.u_error = ENXIO; ! 672: return; ! 673: } ! 674: un = &stunits[unit]; ! 675: dsi = &stape[unit]; ! 676: if (u.u_count % DEV_BSIZE) { ! 677: u.u_error = ENXIO; ! 678: return; /* drive can't do it */ ! 679: } ! 680: resid = u.u_count; ! 681: dsi->un_next_block = u.u_offset / DEV_BSIZE; ! 682: dsi->un_last_block = INF; ! 683: physio(ststrategy, &un->un_rbuf, dev, B_READ, minphys); ! 684: if (dsi->un_eof && u.u_count == resid) { ! 685: dsi->un_eof = 0; /* the user is really getting it */ ! 686: } ! 687: } ! 688: ! 689: sctwrite(dev) ! 690: register dev_t dev; ! 691: { ! 692: register struct scsi_unit *un; ! 693: register int unit; ! 694: register struct scsi_tape *dsi; ! 695: ! 696: unit = STUNIT(dev); ! 697: if (unit > nstape) { ! 698: u.u_error = ENXIO; ! 699: return; ! 700: } ! 701: un = &stunits[unit]; ! 702: dsi = &stape[unit]; ! 703: dsi->un_next_block = u.u_offset / DEV_BSIZE; ! 704: dsi->un_last_block = INF; ! 705: physio(ststrategy, &un->un_rbuf, dev, B_WRITE, minphys); ! 706: } ! 707: ! 708: /*ARGSUSED*/ ! 709: sctioctl(dev, cmd, data, flag) ! 710: register dev_t dev; ! 711: register int cmd; ! 712: register caddr_t data; ! 713: int flag; ! 714: { ! 715: register int fcount; ! 716: struct mtop mtop; ! 717: struct mtget mtget; ! 718: register int unit; ! 719: register struct scsi_tape *dsi; ! 720: static int ops[] = { ! 721: SC_WRITE_FILE_MARK, /* write tape mark */ ! 722: SC_SPACE_FILE, /* forward space file */ ! 723: SC_SPACE_FILE, /* backspace file */ ! 724: SC_SPACE_REC, /* forward space record */ ! 725: SC_SPACE_REC, /* backspace record */ ! 726: SC_REWIND, /* rewind tape */ ! 727: SC_REWIND, /* unload - we just rewind */ ! 728: SC_REQUEST_SENSE, /* get status */ ! 729: SC_REWIND, /* retension - rewind + vu_57 */ ! 730: SC_ERASE_CARTRIDGE, /* erase entire tape */ ! 731: }; ! 732: ! 733: unit = STUNIT(dev); ! 734: if (unit > nstape) { ! 735: u.u_error = ENXIO; ! 736: return; ! 737: } ! 738: dsi = &stape[unit]; ! 739: switch (cmd) { ! 740: case MTIOCTOP: /* tape operation */ ! 741: if (copyin((caddr_t)data, (caddr_t)&mtop, sizeof(mtop))) { ! 742: u.u_error = EFAULT; ! 743: return; ! 744: } ! 745: switch (mtop.mt_op) { ! 746: case MTWEOF: ! 747: case MTERASE: ! 748: if (dsi->un_read_only) { ! 749: u.u_error = ENXIO; ! 750: return; ! 751: } ! 752: } ! 753: ! 754: switch (mtop.mt_op) { ! 755: case MTBSF: ! 756: case MTBSR: ! 757: fcount = -mtop.mt_count; ! 758: break; ! 759: case MTRETEN: ! 760: dsi->un_reten_rewind = 1; ! 761: /* FALL THRU */ ! 762: case MTFSF: ! 763: fcount = mtop.mt_count; ! 764: if (fcount == -1) ! 765: fcount = 0; ! 766: case MTWEOF: ! 767: case MTREW: ! 768: case MTOFFL: ! 769: case MTNOP: ! 770: case MTERASE: ! 771: fcount = mtop.mt_count; ! 772: break; ! 773: default: ! 774: u.u_error = ENXIO; ! 775: return; ! 776: } ! 777: /* ! 778: * If eof_flag then we hit eof but didn't tell the user yet. ! 779: */ ! 780: if (ops[mtop.mt_op] == SC_SPACE_FILE && dsi->un_eof) { ! 781: dsi->un_eof = 0; ! 782: if (mtop.mt_op == MTFSF) ! 783: fcount--; ! 784: } ! 785: if (stcmd(dev, ops[mtop.mt_op], fcount) == 0) ! 786: u.u_error = EIO; ! 787: return; ! 788: ! 789: case MTIOCGET: ! 790: if (stcmd(dev, SC_REQUEST_SENSE, 0) == 0) { ! 791: u.u_error = EIO; ! 792: return; ! 793: } ! 794: mtget.mt_type = MT_ISSC; ! 795: mtget.mt_erreg = dsi->un_status; ! 796: mtget.mt_fileno = dsi->un_retry_ct; ! 797: mtget.mt_blkno = dsi->un_underruns; ! 798: dsi->un_retry_ct = dsi->un_underruns = 0; ! 799: if (copyout((caddr_t)&mtget, data, sizeof(mtget))) ! 800: u.u_error = EFAULT; ! 801: return; ! 802: ! 803: default: ! 804: u.u_error = ENXIO; ! 805: return; ! 806: } ! 807: } ! 808: #endif NST > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.