![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to haictexp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386|
Return to haictexp CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386 |
1.1 ! root 1: /*********************************************************************** ! 2: * Module: haict.c ! 3: * ! 4: * Unix device driver functions for accessing SCSI tape drives as ! 5: * character devices. Conforms to Mark Williams Coherent definition ! 6: * of the Unix Device Driver interface for Coherent v4.0.1. ! 7: * ! 8: * Copyright (c) 1993, Christopher Sean Hilton, All Rights Reserved. ! 9: * ! 10: * Last Modified: Thu Jul 15 19:59:42 1993 by [chris] ! 11: * ! 12: * $Id: haictexp,v 1.1 93/07/20 11:21:24 bin Exp Locker: bin $ ! 13: */ ! 14: /*********************************************************************** ! 15: * READ THIS * READ THIS * READ THIS * READ THIS * READ THIS * ! 16: * ! 17: * This module is set up for my tape drive, a Tandberg TDC 3600 which ! 18: * is an oddball so here's why things are set up the way they are. ! 19: * This driver is set up for the possiblility that the tape drive ! 20: * is in an external cabinet from the PC. This means that the tape ! 21: * drive may not be turned on when Coherent comes up and runs through ! 22: * the init routines. Thus the init routine only prints a message ! 23: * to the effect that the driver is here. The open routine handles ! 24: * the details of initializing the tape drive. My TDC 3600 automatically ! 25: * retensions the tape cartridge after the tape is loaded and whenever ! 26: * the drive is reset. I've timed this process at about 160 seconds ! 27: * from start to finish. That is why the open routine will wait for ! 28: * 180 seconds testing the drive through the load/unload command with ! 29: * immediate return. This brings up the important fact that tape drives ! 30: * in general are slow devices and can take a long time to ! 31: * complete operations. During the time when a tape drive is busy ! 32: * handling some action the SCSI driver could be doing something ! 33: * else so use the immediate return options whenever possible. ! 34: */ ! 35: ! 36: #include <stddef.h> ! 37: #include <sys/coherent.h> ! 38: #include <sys/buf.h> ! 39: #include <sys/file.h> ! 40: #include <sys/stat.h> ! 41: #include <sys/sched.h> ! 42: #include <errno.h> ! 43: #include <sys/mtioctl.h> ! 44: ! 45: #include <sys/haiscsi.h> ! 46: ! 47: #define TDC3600 /* Compensate for weirdness */ ! 48: #define FIXED /* Fixed block length reads/writes okay */ ! 49: /* #define VARIABLE Variable Block length reads/writes okay */ ! 50: /* #define SHOWBLKSZ Report blocksize on first open */ ! 51: ! 52: #define REWINDTAPE 0x01 ! 53: #define IMMEDIATE 0x0010 ! 54: #define REQSENSE 0x03 ! 55: #define READBLKLMT 0x05 ! 56: #define READ 0x08 ! 57: #define WRITE 0x0a ! 58: #define WRITEFM 0x10 ! 59: #define SPACE 0x11 ! 60: #define SKIP_BLK 0x00 ! 61: #define SKIP_FM 0x01 ! 62: #define SKIP_SEQFM 0x02 ! 63: #define SKIP_EOT 0x03 ! 64: #define MODESELECT 0x15 ! 65: #define ERASE 0x19 ! 66: #define ERASE_BLOCK 0x0000 ! 67: #define ERASE_TAPE 0x0001 ! 68: #define MODESENSE 0x1a ! 69: #define LOAD 0x1b ! 70: #define RETENSION 0x0020 ! 71: ! 72: /*********************************************************************** ! 73: * The Tandberg TDC3600 requires special handling because it doesn't ! 74: * respond properly to a write when the tape is at the logical end ! 75: * of tape. Tape should be organized as follows: ! 76: * ! 77: * File 1 --------------| File 2-m ! 78: * DATA[1] | ...DATA[n] | FILEMARK | DATA[1-n] | FILEMARK | FILEMARK | ! 79: * ! 80: * The double file marks signify the Logical End of Tape. When a ! 81: * tape opened in write mode is written to and then closed on the ! 82: * no rewind device it is necessary to write a Logical End of tape ! 83: * and then skip backwards over one of the filemarks. This leaves ! 84: * the tape positioned between the two filemarks. When this happens ! 85: * on my Tandberg the drive will then lock up (nice huh?) and fail ! 86: * to do anything until the tape is rewound or retensioned. ! 87: */ ! 88: ! 89: ! 90: #define CTDIRTY 0x0001 ! 91: #define CTCLOSING 0x0002 ! 92: ! 93: #define CTILI 0x0020 /* Sensekey's Illegal Length Indicator */ ! 94: #define CTEOM 0x0040 /* Sensekey's End OF Media bit */ ! 95: #define CTFILEMARK 0x0080 /* Sensekey's Filemark bit */ ! 96: #define CTSKMASK (CTILI | CTEOM | CTFILEMARK) ! 97: #define CTRDMD 0x0100 /* We are reading from the tape */ ! 98: #define CTWRTMD 0x0200 /* we are writeing to the tape */ ! 99: int HAI_CACHESZ = 40 * BSIZE; /* 40 Block Cache for each device */ ! 100: ! 101: typedef enum { ! 102: CTIDLE = 0, ! 103: CTINIT, ! 104: CTFBRD, ! 105: CTVBRD, ! 106: CTFBWRT, ! 107: CTVBWRT, ! 108: CTSENSE, ! 109: CTWRITEFM, ! 110: CTSPACE, ! 111: CTREWIND, ! 112: CTERASE, ! 113: CTLOADRETEN ! 114: } ctstate_t; ! 115: ! 116: typedef struct blkdscr_s *blkdscr_p; ! 117: ! 118: typedef struct blkdscr_s { ! 119: union { ! 120: unsigned char mediatype; ! 121: unsigned long totalblocks; ! 122: } mt; ! 123: union { ! 124: unsigned char reserved; ! 125: unsigned long blocksize; ! 126: } rb; ! 127: } blkdscr_t; ! 128: ! 129: typedef struct ctctrl_s *ctctrl_p; ! 130: ! 131: typedef struct ctctrl_s { ! 132: char *cache, /* Transfer Cache */ ! 133: *start; /* Start of data in cache */ ! 134: size_t avail; /* bytes availaible in cache */ ! 135: ctstate_t state; ! 136: unsigned short inuse, /* In Use flag */ ! 137: flags, /* Flags from device */ ! 138: block; /* Block size of device */ ! 139: srb_t srb; /* SCSI Request block for transfers */ ! 140: } ctctrl_t; ! 141: ! 142: static int ctinit(); /* Initialize a SCSI device at (id) */ ! 143: static void ctopen(); /* Open SCSI tape at (dev) */ ! 144: static void ctclose(); /* Close a SCSI tape at (dev) */ ! 145: static void ctread(); /* Read from SCSI tape at (dev) */ ! 146: static void ctwrite(); /* Write SCSI tape at (dev) */ ! 147: static void ctioctl(); /* I/O Control routine */ ! 148: ! 149: extern int nulldev(); ! 150: extern int nonedev(); ! 151: ! 152: #define min(a, b) ((a) < (b) ? (a) : (b)) ! 153: ! 154: dca_t ctdca = { ! 155: ctopen, /* Open */ ! 156: ctclose, /* Close */ ! 157: nonedev, /* Block No Block point here */ ! 158: ctread, /* Read */ ! 159: ctwrite, /* Write */ ! 160: ctioctl, /* Ioctl */ ! 161: ctinit, /* Load */ ! 162: nulldev, /* Unload */ ! 163: nulldev /* Poll */ ! 164: }; ! 165: ! 166: static ctctrl_p ctdevs[MAXDEVS]; ! 167: ! 168: /*********************************************************************** ! 169: * Utility functions. * ! 170: ***********************************************************************/ ! 171: ! 172: /*********************************************************************** ! 173: * loadtape() ! 174: * ! 175: * Move the tape to the load point. ! 176: */ ! 177: ! 178: static int loadtape(c, opt) ! 179: register ctctrl_p c; ! 180: int opt; ! 181: { ! 182: register srb_p r = &(c->srb); ! 183: register g0cmd_p g0 = &(r->cdb. g0); ! 184: ! 185: c->state = CTLOADRETEN; ! 186: r->buf. space = r->buf. addr. vaddr = r->buf. size = 0; ! 187: r->xferdir = 0; ! 188: r->timeout = 300; ! 189: memset(g0, 0, sizeof(cdb_t)); ! 190: g0->opcode = LOAD; ! 191: g0->xfr_len = 1; ! 192: if (opt & IMMEDIATE) ! 193: g0->lun_lba |= 1; ! 194: if (opt & RETENSION) ! 195: g0->xfr_len |= 2; ! 196: doscsi(r, 4, CVBLKIO, IVBLKIO, SVBLKIO, "loadtape"); ! 197: if (r->status != ST_GOOD && printerror(r, "Load failed")) ! 198: u. u_error = EIO; ! 199: ! 200: c->state = CTIDLE; ! 201: c->flags &= ~(CTFILEMARK | CTEOM); ! 202: return (r->status == ST_GOOD); ! 203: } /* loadtape() */ ! 204: ! 205: /*********************************************************************** ! 206: * writefm() ! 207: * ! 208: * Write Filemarks on the tape. ! 209: */ ! 210: ! 211: static void writefm(c, count) ! 212: register ctctrl_p c; ! 213: int count; ! 214: { ! 215: register srb_p r = &(c->srb); ! 216: register g0cmd_p g0 = &(r->cdb. g0); ! 217: ! 218: c->state = CTWRITEFM; ! 219: r->buf. space = r->buf. addr. vaddr = r->buf. size = 0; ! 220: r->xferdir = 0; ! 221: r->timeout = 40; ! 222: g0->opcode = WRITEFM; ! 223: g0->lun_lba = (r->lun << 5); ! 224: g0->lba_mid = ((unsigned char *) &count)[2]; ! 225: g0->lba_low = ((unsigned char *) &count)[1]; ! 226: g0->xfr_len = ((unsigned char *) &count)[0]; ! 227: g0->control = 0; ! 228: doscsi(r, 4, CVBLKIO, IVBLKIO, SVBLKIO, "writefm"); ! 229: if (r->status != ST_GOOD && printerror(r, "Write filemarks failed")) ! 230: u. u_error = EIO; ! 231: c->state = CTIDLE; ! 232: } /* writefm() */ ! 233: ! 234: /*********************************************************************** ! 235: * space() ! 236: * ! 237: * Space over blocks/filemarks/etc. ! 238: */ ! 239: ! 240: static void space(c, count, object) ! 241: register ctctrl_p c; ! 242: int count; ! 243: int object; ! 244: { ! 245: register srb_p r = &(c->srb); ! 246: register g0cmd_p g0 = &(r->cdb. g0); ! 247: ! 248: c->state = CTSPACE; ! 249: r->buf. space = r->buf. addr. vaddr = r->buf. size = 0; ! 250: r->xferdir = 0; ! 251: r->timeout = 300; ! 252: g0->opcode = SPACE; ! 253: g0->lun_lba = (r->lun << 5) | (object & 3); ! 254: g0->lba_mid = ((unsigned char *) &count)[2]; ! 255: g0->lba_low = ((unsigned char *) &count)[1]; ! 256: g0->xfr_len = ((unsigned char *) &count)[0]; ! 257: g0->control = 0; ! 258: doscsi(r, 2, CVBLKIO, IVBLKIO, SVBLKIO, "space"); ! 259: if (r->status != ST_GOOD && printerror(r, "Space failed")) ! 260: u. u_error = EIO; ! 261: c->state = CTIDLE; ! 262: } /* space() */ ! 263: ! 264: /*********************************************************************** ! 265: * rewind() ! 266: * ! 267: * Rewind the tape drive back to the load point. ! 268: */ ! 269: ! 270: static void rewind(c, wait) ! 271: register ctctrl_p c; ! 272: int wait; ! 273: { ! 274: register srb_p r = &(c->srb); ! 275: register g0cmd_p g0 = &(r->cdb. g0); ! 276: ! 277: c->state = CTREWIND; ! 278: r->buf. space = r->buf. addr. vaddr = r->buf. size = 0; ! 279: r->timeout = 300; ! 280: r->xferdir = 0; ! 281: memset(g0, 0, sizeof(cdb_t)); ! 282: g0->opcode = REWINDTAPE; ! 283: if (!wait) ! 284: g0->lun_lba = (r->lun << 5) | 1; ! 285: doscsi(r, 2, CVBLKIO, IVBLKIO, SVBLKIO, "rewind"); ! 286: if (r->status != ST_GOOD && printerror(r, "Rewind failed")) ! 287: u. u_error = EIO; ! 288: c->flags = 0; ! 289: c->state = CTIDLE; ! 290: } /* rewind() */ ! 291: ! 292: static void erase(c, to_eot) ! 293: register ctctrl_p c; ! 294: int to_eot; ! 295: { ! 296: register srb_p r = &(c->srb); ! 297: register g0cmd_p g0 = &(r->cdb. g0); ! 298: ! 299: c->state = CTERASE; ! 300: r->buf. space = r->buf. addr. vaddr = r->buf. size = 0; ! 301: r->timeout = 300; ! 302: r->xferdir = 0; ! 303: memset(g0, 0, sizeof(cdb_t)); ! 304: g0->opcode = ERASE; ! 305: g0->lun_lba = (r->lun << 5); ! 306: if (to_eot) ! 307: g0->lun_lba |= 1; ! 308: doscsi(r, 2, CVBLKIO, IVBLKIO, SVBLKIO, "erase"); ! 309: if (r->status != ST_GOOD && printerror(r, "Erase failed")) ! 310: u. u_error = EIO; ! 311: if (to_eot) ! 312: c->flags &= ~(CTFILEMARK | CTEOM | CTILI | CTDIRTY); ! 313: c->state = CTIDLE; ! 314: } /* erase() */ ! 315: ! 316: /*********************************************************************** ! 317: * Device Driver Entry Point routines. * ! 318: ***********************************************************************/ ! 319: ! 320: /*********************************************************************** ! 321: * ctinit() ! 322: * ! 323: * Initialize the tape device at (id). This doesn't do anything, ! 324: * not even verify that the drive is there because it could be powered ! 325: * off. ! 326: */ ! 327: ! 328: static int ctinit(id) ! 329: register int id; ! 330: { ! 331: register ctctrl_p c = kalloc(sizeof(ctctrl_t) /* + HAI_CACHESZ */); ! 332: ! 333: if (!c) { ! 334: printf("\tCould not allocate control structure.\n"); ! 335: return 0; ! 336: } ! 337: ! 338: printf("\tCoherent SCSI Tape driver v1.1\n"); ! 339: memset(c, 0, sizeof(ctctrl_t)); ! 340: c->inuse = 0; ! 341: c->cache = NULL; /* ((char *) c) + sizeof(ctctrl_t); */ ! 342: c->srb. target = id; ! 343: c->srb. lun = 0; ! 344: c->state = CTIDLE; ! 345: ctdevs[id] = c; ! 346: return 1; ! 347: } ! 348: ! 349: static void ctopen(dev, mode) ! 350: dev_t dev; ! 351: int mode; ! 352: { ! 353: register ctctrl_p c = ctdevs[tid(dev)]; ! 354: register srb_p r = &(c->srb); ! 355: register g0cmd_p g0 = &(r->cdb. g0); ! 356: int s; ! 357: unsigned long blim; ! 358: char buf[64]; ! 359: blkdscr_p bd = (blkdscr_p) (buf + 4); ! 360: ! 361: if (!c) { ! 362: u. u_error = ENXIO; ! 363: return; ! 364: } ! 365: if ((mode != IPR) && (mode != IPW)) { ! 366: u. u_error = EINVAL; ! 367: return; ! 368: } ! 369: ! 370: s = sphi(); ! 371: ! 372: if (c->inuse) { ! 373: u. u_error = EDBUSY; ! 374: goto done; ! 375: } ! 376: ! 377: c->inuse = 1; ! 378: c->state = CTINIT; ! 379: r->dev = dev; /* Save the rewind bit for close. */ ! 380: ! 381: /*********************************************************************** ! 382: * Repeat the test unit ready command to the tape drive. This should ! 383: * return one of three ways: ! 384: * ! 385: * Either there isn't a tape in the drive and the test unit ready ! 386: * will fail all the time: Sense Key 70 00 02 (Not Ready), ! 387: * ! 388: * Or there is a tape in the drive and the user just put it in ! 389: * there: Sense Key 70 00 06 (Unit Attention - tape changed) ! 390: * ! 391: * Or there is a tape in the drive and it's been in use for a ! 392: * used (No Sense Key data at all). ! 393: * ! 394: * If there is a new tape in the drive then do the load command ! 395: * to make sure that it is ready to go. ! 396: */ ! 397: ! 398: r->timeout = 2; ! 399: r->buf. space = r->buf. addr. vaddr = r->buf. size = 0; ! 400: r->xferdir = 0; ! 401: memset(g0, 0, sizeof(cdb_t)); /* Test Unit Ready */ ! 402: memset(r->sensebuf, 0, sizeof(r->sensebuf)); ! 403: doscsi(r, 4, CVBLKIO, IVBLKIO, SVBLKIO, "ctopen"); ! 404: ! 405: /*********************************************************************** ! 406: * If the command fails there probably wasn't a tape in the drive. ! 407: */ ! 408: ! 409: if (r->status != ST_GOOD) { ! 410: if (r->status != ST_USRABRT) ! 411: u. u_error = ENXIO; ! 412: goto openfailed; ! 413: } ! 414: ! 415: /*********************************************************************** ! 416: * Command Passed: check for sense data which would say that the tape ! 417: * was just loaded. If it was then block here because it is very ! 418: * inconvienent to do so in the block routine. (loadtape needs to ! 419: * use v_sleep). ! 420: */ ! 421: ! 422: else if (r->sensebuf[0] == 0x70 && r->sensebuf[2] == 0x06) { ! 423: if (!loadtape(c, 0)) ! 424: goto openfailed; ! 425: } ! 426: ! 427: /*********************************************************************** ! 428: * Do a mode sense right now to check if the tape is write protected ! 429: * and the user asked for write access. Also need to figure out block ! 430: * size for reads and writes. This will end this fixed/variable ! 431: * nonsense. If you need to use variable block mode I will provide ! 432: * an IO control to swap it. Also this way my Tandberg will be supported ! 433: * just like any other tape drive. ! 434: */ ! 435: ! 436: r->buf. space = KRNL_ADDR; ! 437: r->buf. addr. vaddr = (vaddr_t) buf; ! 438: r->buf. size = sizeof(buf); ! 439: r->xferdir = DMAREAD; ! 440: r->timeout = 2; ! 441: memset(g0, 0, sizeof(cdb_t)); ! 442: g0->opcode = MODESENSE; ! 443: g0->xfr_len = sizeof(buf); ! 444: doscsi(r, 3, CVBLKIO, IVBLKIO, SVBLKIO, "ctopen"); ! 445: if (r->status != ST_GOOD) { ! 446: if (printerror(r, "Mode sense failed")) ! 447: u. u_error = EIO; ! 448: goto openfailed; ! 449: } ! 450: ! 451: /*********************************************************************** ! 452: * If tape drive opened in write mode make sure the tape is not write ! 453: * protected now. ! 454: */ ! 455: ! 456: if (mode == IPW && (buf[2] & 0x80) != 0) { ! 457: devmsg(dev, "Tape is write protected"); ! 458: u. u_error = ENXIO; ! 459: goto openfailed; ! 460: } ! 461: ! 462: /*********************************************************************** ! 463: * If mode sense returned any media descriptors take the first one ! 464: * and use it. This should be the default media type. ! 465: */ ! 466: ! 467: if (buf[3]) { /* If mode sense returned any media descriptors */ ! 468: blim = (bd->rb. blocksize & 0xffffff00); ! 469: flip(blim); ! 470: c->block = blim; ! 471: if (c->block && HAI_CACHESZ % c->block) { ! 472: HAI_CACHESZ -= (HAI_CACHESZ % c->block); ! 473: devmsg(r->dev, "HAI_CACHESZ adjusted to %d bytes", HAI_CACHESZ); ! 474: } ! 475: } ! 476: else { ! 477: u. u_error = ENXIO; ! 478: goto openfailed; ! 479: } ! 480: #ifdef SHOWBLKSZ ! 481: devmsg(dev, "Using blocksize %d bytes", c->block); ! 482: #endif ! 483: ! 484: c->flags = (mode == IPR) ? CTRDMD : CTWRTMD; ! 485: if (c->block) { ! 486: c->cache = kalloc(HAI_CACHESZ); ! 487: if (!c->cache) { ! 488: devmsg(dev, "Could not allocate tape cache"); ! 489: u. u_error = ENOMEM; ! 490: goto openfailed; ! 491: } ! 492: c->avail = (c->flags & CTRDMD) ? 0 : HAI_CACHESZ; ! 493: c->start = c->cache; ! 494: } ! 495: c->state = CTIDLE; ! 496: goto done; ! 497: ! 498: openfailed: ! 499: c->state = CTIDLE; ! 500: c->inuse = 0; ! 501: ! 502: done: ! 503: spl(s); ! 504: } /* ctopen() */ ! 505: ! 506: /*********************************************************************** ! 507: * ctclose() ! 508: * ! 509: * Close the SCSI Device at (dev). ! 510: */ ! 511: ! 512: static void ctclose(dev) ! 513: register dev_t dev; ! 514: { ! 515: register ctctrl_p c = ctdevs[tid(dev)]; ! 516: register srb_p r = &(c->srb); ! 517: int s; ! 518: ! 519: if (!c) { ! 520: u. u_error = EINVAL; ! 521: return; ! 522: } ! 523: ! 524: s = sphi(); ! 525: c->flags |= CTCLOSING; ! 526: flushcache(c); ! 527: while (c->state != CTIDLE) { ! 528: /* x_sleep(&(c->flags), ...); */ ! 529: v_sleep(&(c->flags), CVBLKIO, IVBLKIO, SVBLKIO, "ctclose"); ! 530: if (nondsig()) { ! 531: u. u_error = EINTR; ! 532: break; ! 533: } ! 534: } ! 535: spl(s); ! 536: if (c->cache) { ! 537: kfree(c->cache); ! 538: c->cache = c->start = NULL; ! 539: c->avail = 0; ! 540: } ! 541: ! 542: #ifndef TDC3600 ! 543: /*********************************************************************** ! 544: * Write two filemarks (Logical End of Tape) and then skip backwards ! 545: * over one of them to ready for the another write operation on the ! 546: * no rewind device. This code guarantees properly formed tapes according ! 547: * to the wisened old nine-track hacker that I work with. The problem ! 548: * is that... ! 549: */ ! 550: if (c->flags & CTDIRTY) { ! 551: writefm(c, 1); /* Write a file mark */ ! 552: writefm(c, 1); /* Write another filemark */ ! 553: space(c, -1, SKIP_FM); /* Go back to the first filemark */ ! 554: } ! 555: #else ! 556: /* ! 557: * ... problem is that my Tandberg considers it an error to do anything ! 558: * after it has skipped past a filemark. So all commands except load and ! 559: * rewind fail after the the previous code. The following will work in ! 560: * all situations but there is a risk that a user's tapes will only ! 561: * have one filemark at Logical End-of-Tape if the user isn't careful ! 562: * to use the rewind device the last time he uses tape drive. This is ! 563: * only a problem with drives which insist upon doing a Retension each ! 564: * time the tape is changed or the drive gets reset. ! 565: */ ! 566: if (c->flags & CTDIRTY) { ! 567: writefm(c, 1); ! 568: if (r->dev & REWIND) ! 569: writefm(c, 1); ! 570: } ! 571: #endif ! 572: ! 573: if (r->dev & REWIND) ! 574: rewind(c, 0); ! 575: ! 576: c->inuse = 0; ! 577: return; ! 578: } /* ctclose() */ ! 579: ! 580: /*********************************************************************** ! 581: * fillcache() -- Read from the tape into the cache (really?) ! 582: * ! 583: * return 0 and set u. u_error on any errors. ! 584: */ ! 585: ! 586: static int fillcache(c) ! 587: register ctctrl_p c; ! 588: { ! 589: register srb_p r = (&c->srb); ! 590: register g0cmd_p g0 = &(r->cdb. g0); ! 591: size_t xfrsize; ! 592: extsense_p e; ! 593: int info; ! 594: int retval = 0; ! 595: ! 596: r->buf. space = KRNL_ADDR; ! 597: r->buf. addr. vaddr = (vaddr_t) c->cache; ! 598: r->buf. size = xfrsize = HAI_CACHESZ; ! 599: r->xferdir = DMAREAD; ! 600: r->timeout = 30; ! 601: r->tries = 0; ! 602: g0->opcode = READ; ! 603: g0->lun_lba = (r->lun << 5); ! 604: if (c->block) { ! 605: g0->lun_lba |= 1; ! 606: xfrsize = (xfrsize + c->block - 1) / c->block; ! 607: } ! 608: g0->lba_mid = ((unsigned char *) &xfrsize)[2]; ! 609: g0->lba_low = ((unsigned char *) &xfrsize)[1]; ! 610: g0->xfr_len = ((unsigned char *) &xfrsize)[0]; ! 611: g0->control = 0; ! 612: doscsi(r, 1, CVBLKIO, IVBLKIO, SVBLKIO, "ctblkrd"); ! 613: switch (r->status) { ! 614: case ST_GOOD: ! 615: c->start = c->cache; ! 616: c->avail = r->buf. size; ! 617: retval = 1; ! 618: break; ! 619: case ST_CHKCOND: ! 620: e = r->sensebuf; ! 621: if ((e->errorcode & 0x70) == 0x70) { ! 622: info = 0; ! 623: if (e->errorcode & 0x80) { ! 624: info = e->info; ! 625: flip(info); ! 626: } ! 627: if (e->sensekey & (CTFILEMARK | CTEOM)) { ! 628: c->flags |= (e->sensekey & (CTFILEMARK | CTEOM)); ! 629: c->start = c->cache; ! 630: c->avail = HAI_CACHESZ - (info * c->block); ! 631: retval = 1; ! 632: break; ! 633: } ! 634: } ! 635: printsense(r->dev, "Read failed", r->sensebuf); ! 636: u. u_error = EIO; ! 637: retval = 0; ! 638: break; ! 639: case ST_USRABRT: ! 640: retval = 0; ! 641: break; ! 642: default: ! 643: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 644: u. u_error = EIO; ! 645: retval = 0; ! 646: break; ! 647: } ! 648: c->state = CTIDLE; ! 649: return retval; ! 650: } /* fillcache() */ ! 651: ! 652: /*********************************************************************** ! 653: * ctfbrd() -- Fixed block read handler. Reads from the tape ! 654: * drive through the cache when the tape drive is ! 655: * in fixed block mode. ! 656: */ ! 657: ! 658: static void ctfbrd(c, iop) ! 659: register ctctrl_p c; ! 660: register IO *iop; ! 661: { ! 662: register size_t reqcount, /* Total bytes transfered */ ! 663: xfrsize; /* Current transfer size */ ! 664: size_t total, /* System global memory total transfer size */ ! 665: size; /* System global memory current transfer size */ ! 666: ! 667: reqcount = 0; ! 668: while (iop->io_ioc) { ! 669: xfrsize = min(c->avail, iop->io_ioc); ! 670: if (xfrsize) { ! 671: switch (iop->io_seg) { ! 672: case IOSYS: ! 673: memcpy(iop->io. vbase + reqcount, c->start, xfrsize); ! 674: break; ! 675: case IOUSR: ! 676: kucopy(c->start, iop->io. vbase + reqcount, xfrsize); ! 677: break; ! 678: case IOPHY: ! 679: total = 0; ! 680: while (total < xfrsize) { ! 681: size = min(xfrsize - total, NBPC); ! 682: xpcopy(c->start + total, ! 683: iop->io. pbase + reqcount + total, ! 684: size, ! 685: SEG_386_KD | SEG_VIRT); ! 686: total += size; ! 687: } ! 688: break; ! 689: } ! 690: c->start += xfrsize; ! 691: c->avail -= xfrsize; ! 692: reqcount += xfrsize; ! 693: iop->io_ioc -= xfrsize; ! 694: } ! 695: if (iop->io_ioc) { ! 696: if (c->flags & CTFILEMARK) { ! 697: c->flags &= ~CTFILEMARK; ! 698: break; ! 699: } ! 700: ! 701: if (c->flags & CTEOM) { ! 702: u. u_error = EIO; ! 703: break; ! 704: } ! 705: ! 706: if (!fillcache(c)) ! 707: break; ! 708: } ! 709: } /* while */ ! 710: } /* ctfbrd() */ ! 711: ! 712: /*********************************************************************** ! 713: * ctvbrd() -- Variable block read entry point. ! 714: */ ! 715: ! 716: static void ctvbrd(c, iop) ! 717: register ctctrl_p c; ! 718: register IO *iop; ! 719: { ! 720: register srb_p r = &(c->srb); ! 721: register g0cmd_p g0 = &(r->cdb. g0); ! 722: size_t xfrsize; ! 723: extsense_p e; ! 724: int info; ! 725: ! 726: if (c->flags & CTEOM) { ! 727: u. u_error = EIO; ! 728: return; ! 729: } ! 730: if (c->flags & CTFILEMARK) { ! 731: c->flags &= ~CTFILEMARK; ! 732: return; ! 733: } ! 734: c->state = CTVBRD; ! 735: switch (iop->io_seg) { ! 736: case IOSYS: ! 737: r->buf. space = KRNL_ADDR; ! 738: r->buf. addr. vaddr = iop->io. vbase; ! 739: break; ! 740: case IOUSR: ! 741: r->buf. space = USER_ADDR; ! 742: r->buf. addr. vaddr = iop->io. vbase; ! 743: break; ! 744: case IOPHY: ! 745: r->buf. space = PHYS_ADDR; ! 746: r->buf. addr. paddr = iop->io. pbase; ! 747: break; ! 748: } ! 749: r->buf. size = xfrsize = iop->io_ioc; ! 750: r->xferdir = DMAREAD; ! 751: r->timeout = 30; ! 752: g0->opcode = READ; ! 753: g0->lun_lba = (r->lun << 5); ! 754: g0->lba_mid = ((unsigned char *) &xfrsize)[2]; ! 755: g0->lba_low = ((unsigned char *) &xfrsize)[1]; ! 756: g0->xfr_len = ((unsigned char *) &xfrsize)[0]; ! 757: g0->control = 0; ! 758: doscsi(r, 1, CVBLKIO, IVBLKIO, SVBLKIO, "ctvbrd"); ! 759: switch (r->status) { ! 760: case ST_GOOD: ! 761: iop->io_ioc -= r->buf. size; ! 762: break; ! 763: case ST_CHKCOND: ! 764: e = r->sensebuf; ! 765: if ((e->errorcode & 0x70) == 0x70) { ! 766: info = 0; ! 767: if (e->errorcode & 0x80) { ! 768: info = (long) e->info; ! 769: flip(info); ! 770: } ! 771: if (e->sensekey & (CTFILEMARK | CTEOM)) { ! 772: c->flags |= (e->sensekey & (CTFILEMARK | CTEOM)); ! 773: break; ! 774: } ! 775: else if (e->sensekey & CTILI) { ! 776: devmsg(r->dev, ! 777: "Read failed buffer size %d blocksize %d", ! 778: xfrsize, ! 779: xfrsize - info); ! 780: if (info > 0) ! 781: iop->io_ioc -= (xfrsize - info); ! 782: else ! 783: u. u_error = EIO; ! 784: break; ! 785: } ! 786: } ! 787: printsense(r->dev, "Read failed", r->sensebuf); ! 788: u. u_error = EIO; ! 789: break; ! 790: case ST_USRABRT: ! 791: break; ! 792: default: ! 793: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 794: u. u_error = EIO; ! 795: break; ! 796: } ! 797: c->state = CTIDLE; ! 798: } /* ctvbrd() */ ! 799: ! 800: /*********************************************************************** ! 801: * ctread() -- OS Read entry point. ! 802: */ ! 803: ! 804: static void ctread(dev, iop) ! 805: dev_t dev; ! 806: register IO *iop; ! 807: { ! 808: register ctctrl_p c = ctdevs[tid(dev)]; ! 809: ! 810: if (!c) { ! 811: u. u_error = EINVAL; ! 812: return; ! 813: } ! 814: ! 815: if (c->block) ! 816: ctfbrd(c, iop); ! 817: else ! 818: ctvbrd(c, iop); ! 819: } /* ctread() */ ! 820: ! 821: /*********************************************************************** ! 822: * flushcache() -- flush the data in the cache to the tape. ! 823: * ! 824: * returns 0 and sets u. u_error on failure else returns 1. ! 825: */ ! 826: ! 827: static int flushcache(c) ! 828: register ctctrl_p c; ! 829: { ! 830: register srb_p r = (&c->srb); ! 831: register g0cmd_p g0 = &(r->cdb. g0); ! 832: size_t xfrsize; ! 833: extsense_p e; ! 834: int info; ! 835: int retval = 0; ! 836: ! 837: r->buf. space = KRNL_ADDR; ! 838: r->buf. addr. vaddr = (vaddr_t) c->cache; ! 839: r->buf. size = xfrsize = HAI_CACHESZ - c->avail; ! 840: r->xferdir = DMAWRITE; ! 841: r->timeout = 30; ! 842: r->tries = 0; ! 843: g0->opcode = WRITE; ! 844: g0->lun_lba = (r->lun << 5); ! 845: if (c->block) { ! 846: g0->lun_lba |= 1; ! 847: xfrsize = (xfrsize + c->block - 1) / c->block; ! 848: } ! 849: g0->lba_mid = ((unsigned char *) &xfrsize)[2]; ! 850: g0->lba_low = ((unsigned char *) &xfrsize)[1]; ! 851: g0->xfr_len = ((unsigned char *) &xfrsize)[0]; ! 852: g0->control = 0; ! 853: doscsi(r, 1, CVBLKIO, IVBLKIO, SVBLKIO, "ctblkwrt"); ! 854: switch (r->status) { ! 855: case ST_GOOD: ! 856: c->start = c->cache; ! 857: c->avail = HAI_CACHESZ; ! 858: retval = 1; ! 859: break; ! 860: case ST_CHKCOND: ! 861: e = r->sensebuf; ! 862: if ((e->errorcode & 0x70) == 0x70) { ! 863: info = 0; ! 864: if (e->errorcode & 0x80) { ! 865: info = e->info; ! 866: flip(info); ! 867: } ! 868: if (e->sensekey & CTEOM) { ! 869: c->flags |= CTEOM; ! 870: devmsg(r->dev, "End of tape on block write"); ! 871: } ! 872: } ! 873: printsense(r->dev, "Read failed", r->sensebuf); ! 874: u. u_error = EIO; ! 875: retval = 0; ! 876: break; ! 877: case ST_USRABRT: ! 878: retval = 0; ! 879: break; ! 880: default: ! 881: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 882: u. u_error = EIO; ! 883: retval = 0; ! 884: break; ! 885: } ! 886: c->state = CTIDLE; ! 887: return retval; ! 888: } /* flushcache() */ ! 889: ! 890: /*********************************************************************** ! 891: * ctfbwrt() -- Fixed block write. This should be fast because ! 892: * it uses the tapes drives optimum setting and it ! 893: * goes through a cache. ! 894: */ ! 895: ! 896: static void ctfbwrt(c, iop) ! 897: register ctctrl_p c; ! 898: register IO *iop; ! 899: { ! 900: register size_t reqcount, /* Total bytes transfered */ ! 901: xfrsize; /* Current transfer size */ ! 902: size_t total, /* System global memory total transfer size */ ! 903: size; /* System global memory current transfer size */ ! 904: ! 905: reqcount = 0; ! 906: while (iop->io_ioc) { ! 907: xfrsize = min(c->avail, iop->io_ioc); ! 908: if (xfrsize) { ! 909: switch (iop->io_seg) { ! 910: case IOSYS: ! 911: memcpy(c->start, iop->io. vbase + reqcount, xfrsize); ! 912: break; ! 913: case IOUSR: ! 914: ukcopy(iop->io. vbase + reqcount, c->start, xfrsize); ! 915: break; ! 916: case IOPHY: ! 917: total = 0; ! 918: while (total < xfrsize) { ! 919: size = min(xfrsize - total, NBPC); ! 920: pxcopy(iop->io. pbase + reqcount + total, ! 921: c->start + total, ! 922: size, ! 923: SEG_386_KD | SEG_VIRT); ! 924: total += size; ! 925: } ! 926: break; ! 927: } ! 928: c->start += xfrsize; ! 929: c->avail -= xfrsize; ! 930: reqcount += xfrsize; ! 931: iop->io_ioc -= xfrsize; ! 932: } ! 933: if (iop->io_ioc) { ! 934: if (!flushcache(c)) ! 935: break; ! 936: } ! 937: } /* while */ ! 938: } /* ctfbwrt() */ ! 939: ! 940: /*********************************************************************** ! 941: * ctvbwrt() -- Variable block writes. ! 942: */ ! 943: ! 944: ! 945: static void ctvbwrt(c, iop) ! 946: register ctctrl_p c; ! 947: register IO *iop; ! 948: { ! 949: register srb_p r = &(c->srb); ! 950: register g0cmd_p g0 = &(r->cdb. g0); ! 951: size_t xfrsize; ! 952: extsense_p e; ! 953: int info; ! 954: ! 955: c->state = CTVBWRT; ! 956: switch (iop->io_seg) { ! 957: case IOSYS: ! 958: r->buf. space = KRNL_ADDR; ! 959: r->buf. addr. vaddr = iop->io. vbase; ! 960: break; ! 961: case IOUSR: ! 962: r->buf. space = USER_ADDR; ! 963: r->buf. addr. vaddr = iop->io. vbase; ! 964: break; ! 965: case IOPHY: ! 966: r->buf. space = PHYS_ADDR; ! 967: r->buf. addr. paddr = iop->io. pbase; ! 968: break; ! 969: } ! 970: xfrsize = iop->io_ioc; ! 971: r->buf. size = xfrsize; ! 972: r->xferdir = DMAWRITE; ! 973: r->timeout = 30; ! 974: g0->opcode = WRITE; ! 975: g0->lun_lba = (r->lun << 5); ! 976: g0->lba_mid = ((unsigned char *) &xfrsize)[2]; ! 977: g0->lba_low = ((unsigned char *) &xfrsize)[1]; ! 978: g0->xfr_len = ((unsigned char *) &xfrsize)[0]; ! 979: g0->control = 0; ! 980: doscsi(r, 1, CVBLKIO, IVBLKIO, SVBLKIO, "ctvbwrt"); ! 981: switch (r->status) { ! 982: case ST_GOOD: ! 983: iop->io_ioc -= r->buf. size; ! 984: break; ! 985: case ST_CHKCOND: ! 986: e = r->sensebuf; ! 987: if ((e->errorcode & 0x70) == 0x70) { ! 988: info = 0; ! 989: if (e->errorcode & 0x80) { ! 990: info = (long) e->info; ! 991: flip(info); ! 992: } ! 993: if (e->sensekey & CTEOM) { ! 994: c->flags |= CTEOM; ! 995: devmsg(r->dev, "End of tape"); ! 996: } ! 997: } ! 998: printsense(r->dev, "Write failed", r->sensebuf); ! 999: u. u_error = EIO; ! 1000: break; ! 1001: case ST_USRABRT: ! 1002: break; ! 1003: default: ! 1004: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 1005: u. u_error = EIO; ! 1006: break; ! 1007: } ! 1008: c->state = CTIDLE; ! 1009: } /* ctvbwrt() */ ! 1010: ! 1011: /*********************************************************************** ! 1012: * ctwrite() -- Write entry point for tape drive. ! 1013: */ ! 1014: ! 1015: static void ctwrite(dev, iop) ! 1016: register dev_t dev; ! 1017: register IO *iop; ! 1018: { ! 1019: register ctctrl_p c = ctdevs[tid(dev)]; ! 1020: ! 1021: if (!c) { ! 1022: u. u_error = EINVAL; ! 1023: return; ! 1024: } ! 1025: ! 1026: if (c->block) ! 1027: ctfbwrt(c, iop); ! 1028: else ! 1029: ctvbwrt(c, iop); ! 1030: } /* ctwrite() */ ! 1031: ! 1032: /*********************************************************************** ! 1033: * ctioctl() ! 1034: * ! 1035: * I/O Control Entry point for Cartridge tape devices. ! 1036: */ ! 1037: ! 1038: static void ctioctl(dev, cmd /*, vec */) ! 1039: register dev_t dev; ! 1040: register int cmd; ! 1041: /* char *vec; */ ! 1042: { ! 1043: register ctctrl_p c = ctdevs[tid(dev)]; ! 1044: ! 1045: if (!c) { ! 1046: u. u_error = EINVAL; ! 1047: return; ! 1048: } ! 1049: ! 1050: switch (cmd) { ! 1051: case MTREWIND: /* Rewind */ ! 1052: rewind(c, 1); ! 1053: break; ! 1054: case MTWEOF: /* Write end of file mark */ ! 1055: writefm(c, 1); ! 1056: break; ! 1057: case MTRSKIP: /* Record skip */ ! 1058: space(c, 1, SKIP_BLK); ! 1059: break; ! 1060: case MTFSKIP: /* File skip */ ! 1061: space(c, 1, SKIP_FM); ! 1062: break; ! 1063: case MTTENSE: /* Tension tape */ ! 1064: loadtape(c, RETENSION); ! 1065: break; ! 1066: case MTERASE: /* Erase tape */ ! 1067: erase(c, ERASE_TAPE); ! 1068: break; ! 1069: case MTDEC: /* DEC mode */ ! 1070: case MTIBM: /* IBM mode */ ! 1071: case MT800: /* 800 bpi */ ! 1072: case MT1600: /* 1600 bpi */ ! 1073: case MT6250: /* 6250 bpi */ ! 1074: return; ! 1075: default: ! 1076: u. u_error = ENXIO; ! 1077: break; ! 1078: } ! 1079: } /* ctioctl() */ ! 1080: ! 1081: /* End of file */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.