![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to haiCt.c 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 haiCt.c 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: * The philosophy of this driver is to support basic functions on ! 9: * the tape drive (read, write, retension, rewind, skip, etc). There ! 10: * are more features out there for all the SCSI tape drives out there ! 11: * than I know what to do with. I leave custom support for these ! 12: * drives to the people who have them. To this end this drive will ! 13: * blindly follow whatever information it can get using Mode Sense ! 14: * and Read Block Limits CDB's. These tests are done at open time. ! 15: * An application can change the operation of the driver by applying ! 16: * the mode select command through I/O Control mechanism. ! 17: * ! 18: * Copyright (c) 1993, Christopher Sean Hilton, All Rights Reserved. ! 19: * ! 20: * Last Modified: Mon Jul 26 17:18:59 1993 by [chris] ! 21: * ! 22: * $Id: haict.c,v 2.4 93/08/09 13:45:06 bin Exp Locker: bin $ ! 23: * ! 24: * $Log: haict.c,v $ ! 25: * Revision 2.4 93/08/09 13:45:06 bin ! 26: * Kernel 82 changes ! 27: * ! 28: */ ! 29: ! 30: #include <stddef.h> ! 31: #include <sys/coherent.h> ! 32: #include <sys/buf.h> ! 33: #include <sys/inode.h> ! 34: #include <sys/stat.h> ! 35: #include <sys/sched.h> ! 36: #include <errno.h> ! 37: #include <sys/mtioctl.h> ! 38: #include <sys/file.h> /* Louis */ ! 39: ! 40: #include <sys/haiscsi.h> ! 41: #include <sys/haiioctl.h> ! 42: ! 43: #define REWINDTAPE 0x01 ! 44: #define IMMEDIATE 0x0010 ! 45: #define REQSENSE 0x03 ! 46: #define READBLKLMT 0x05 ! 47: #define READ 0x08 ! 48: #define WRITE 0x0a ! 49: #define WRITEFM 0x10 ! 50: #define SPACE 0x11 ! 51: #define SKIP_BLK 0x00 ! 52: #define SKIP_FM 0x01 ! 53: #define SKIP_SEQFM 0x02 ! 54: #define SKIP_EOT 0x03 ! 55: #define MODESELECT 0x15 ! 56: #define ERASE 0x19 ! 57: #define ERASE_BLOCK 0x0000 ! 58: #define ERASE_TAPE 0x0001 ! 59: #define MODESENSE 0x1a ! 60: #define LOAD 0x1b ! 61: #define RETENSION 0x0020 ! 62: ! 63: /*********************************************************************** ! 64: * The Tandberg TDC3600 requires special handling because it doesn't ! 65: * respond properly to a write when the tape is at the logical end ! 66: * of tape. Tape should be organized as follows: ! 67: * ! 68: * File 1 --------------| File 2-m ! 69: * DATA[1] | ...DATA[n] | FILEMARK | DATA[1-n] | FILEMARK | FILEMARK | ! 70: * ! 71: * The double file marks signify the Logical End of Tape. When a ! 72: * tape opened in write mode is written to and then closed on the ! 73: * no rewind device it is necessary to write a Logical End of tape ! 74: * and then skip backwards over one of the filemarks. This leaves ! 75: * the tape positioned between the two filemarks. When this happens ! 76: * on my Tandberg the drive will then lock up (nice huh?) and fail ! 77: * to do anything until the tape is rewound or retensioned. ! 78: */ ! 79: ! 80: ! 81: #define CTDIRTY 0x0001 ! 82: #define CTCLOSING 0x0002 ! 83: ! 84: #define CTILI 0x0020 /* Sensekey's Illegal Length Indicator */ ! 85: #define CTEOM 0x0040 /* Sensekey's End OF Media bit */ ! 86: #define CTFILEMARK 0x0080 /* Sensekey's Filemark bit */ ! 87: #define CTSKMASK (CTILI | CTEOM | CTFILEMARK) ! 88: #define CTRDMD 0x0100 /* we are reading from the tape */ ! 89: #define CTWRTMD 0x0200 /* we are writing to the tape */ ! 90: ! 91: #ifndef HAICACHESZ ! 92: /* ! 93: * There wasn't much of a difference in speed between 32 and 40 block ! 94: * in my experiance so save as much kalloc memory as possible. ! 95: */ ! 96: ! 97: #define HAICACHESZ (32 * BSIZE)/* 32 Block Cache for each device */ ! 98: #endif ! 99: ! 100: #ifndef HAICTVERBOSE ! 101: /* ! 102: * HAICTVERBOSE is done as a define because I wanted to be able to use two ! 103: * tape drives in my system at one time (why?!). ld complains if it is a ! 104: * patchable constant. This problem must be solved but products must also ! 105: * ship. [csh] ! 106: */ ! 107: ! 108: #define HAICTVERBOSE 0x0001 /* Switch console messages on/off */ ! 109: #endif ! 110: ! 111: typedef enum { ! 112: CTIDLE = 0, ! 113: CTINIT, ! 114: CTFBRD, ! 115: CTVBRD, ! 116: CTFBWRT, ! 117: CTVBWRT, ! 118: CTLASTWRT, ! 119: CTSENSE, ! 120: CTWRITEFM, ! 121: CTSPACE, ! 122: CTREWIND, ! 123: CTERASE, ! 124: CTLOADRETEN, ! 125: CTIOCTL ! 126: } ctstate_t; ! 127: ! 128: /* Block Descriptors in the mode sense command. */ ! 129: ! 130: typedef struct blkdscr_s *blkdscr_p; ! 131: ! 132: typedef struct blkdscr_s { ! 133: union { ! 134: unsigned char mediatype; ! 135: unsigned long totalblocks; ! 136: } mt; ! 137: union { ! 138: unsigned char reserved; ! 139: unsigned long blocksize; ! 140: } rb; ! 141: } blkdscr_t; ! 142: ! 143: typedef struct blklim_s *blklim_p; ! 144: ! 145: typedef struct blklim_s { ! 146: unsigned blmax; /* Maximum size for Reads/Writes */ ! 147: unsigned short blmin; /* Minimum size for Reads/Writes */ ! 148: } blklim_t; ! 149: ! 150: typedef struct ctctrl_s *ctctrl_p; ! 151: ! 152: typedef struct ctctrl_s { ! 153: char *cache, /* Transfer Cache */ ! 154: *start; /* Start of data in cache */ ! 155: size_t cachesize, /* Size of cache */ ! 156: avail; /* bytes availaible in cache */ ! 157: ctstate_t state; ! 158: unsigned block, /* Block size of device */ ! 159: blmax; /* Block limits maximum */ ! 160: unsigned short blmin, /* Block Limits minimum */ ! 161: flags, /* Flags from device */ ! 162: inuse; /* In Use flag */ ! 163: srb_t srb; /* SCSI Request block for transfers */ ! 164: } ctctrl_t; ! 165: ! 166: static int ctinit(); /* Initialize a SCSI device at (id) */ ! 167: static void ctopen(); /* Open SCSI tape at (dev) */ ! 168: static void ctclose(); /* Close a SCSI tape at (dev) */ ! 169: static void ctread(); /* Read from SCSI tape at (dev) */ ! 170: static void ctwrite(); /* Write SCSI tape at (dev) */ ! 171: static void ctioctl(); /* I/O Control routine */ ! 172: static int fillcache(); /* Fill the tape cache */ ! 173: static int flushcache(); /* Flush the tape cache */ ! 174: ! 175: extern int nulldev(); ! 176: extern int nonedev(); ! 177: ! 178: #define min(a, b) ((a) < (b) ? (a) : (b)) ! 179: ! 180: #ifdef TDC3600 ! 181: #define ctdca haict3600 ! 182: #endif ! 183: ! 184: dca_t ctdca = { ! 185: ctopen, /* Open */ ! 186: ctclose, /* Close */ ! 187: hainonblk, /* No Block point here but don't just drop Buffers */ ! 188: ctread, /* Read */ ! 189: ctwrite, /* Write */ ! 190: ctioctl, /* Ioctl */ ! 191: ctinit, /* Load */ ! 192: nulldev, /* Unload */ ! 193: nulldev /* Poll */ ! 194: }; ! 195: ! 196: static ctctrl_p ctdevs[MAXDEVS]; ! 197: ! 198: /*********************************************************************** ! 199: * Utility functions. * ! 200: ***********************************************************************/ ! 201: ! 202: #define ctvmsg(l, cmd) { if (HAICTVERBOSE & (l)) { (cmd); } } ! 203: ! 204: /*********************************************************************** ! 205: * ctbusywait() ! 206: * ! 207: * Wait for the tape drive state to return to idle. This is easy ! 208: * for two reasons: 1) With no block entry point its safe to sleep ! 209: * at any time. 2) We shouldn't really need this anyhow. This is ! 210: * unneccessary because without a block routine and with only one ! 211: * process able to open the tape drive at a time the state of the ! 212: * tape drive driver is well defined. So, why is it here you ask? ! 213: * because one day some user might fork a process that owns the tape ! 214: * drive. This would cause 40 days and nights worth of rain etc. ! 215: * Now all that will happen is both processes will be able to write/read ! 216: * from the tape drive and the data that they get will be complete ! 217: * garbage. However, the kernel will not break. ! 218: */ ! 219: ! 220: static int ctbusywait(c, newstate) ! 221: register ctctrl_p c; ! 222: register ctstate_t newstate; ! 223: { ! 224: register int s; ! 225: int retval; ! 226: ! 227: s = sphi(); ! 228: retval = 1; ! 229: while (c->state != CTIDLE) ! 230: if (x_sleep(&(c->srb. status), pritape, slpriSigCatch, "ctbsywt")) { ! 231: u. u_error = EINTR; ! 232: retval = 0; ! 233: break; ! 234: } ! 235: c->state = newstate; ! 236: spl(s); ! 237: return retval; ! 238: } /* ctbusywait() */ ! 239: ! 240: /*********************************************************************** ! 241: * loadtape() ! 242: * ! 243: * Move the tape to the load point. ! 244: */ ! 245: ! 246: static int loadtape(c, opt) ! 247: register ctctrl_p c; ! 248: int opt; ! 249: { ! 250: register srb_p r = &(c->srb); ! 251: register g0cmd_p g0 = &(r->cdb. g0); ! 252: ! 253: if (!ctbusywait(c, CTLOADRETEN)) ! 254: return 0; ! 255: r->buf. space = (int) r->buf. addr. caddr = r->buf. size = 0; ! 256: r->xferdir = 0; ! 257: r->timeout = 300; ! 258: memset(g0, 0, sizeof(cdb_t)); ! 259: g0->opcode = LOAD; ! 260: g0->xfr_len = 1; /* Move tape to load point. */ ! 261: if (opt & IMMEDIATE) ! 262: g0->lun_lba |= 1; ! 263: if (opt & RETENSION) ! 264: g0->xfr_len |= 2; ! 265: doscsi(r, 4, pritape, slpriSigCatch, "loadtape"); ! 266: if (r->status != ST_GOOD && printerror(r, "Load failed")) ! 267: u. u_error = EIO; ! 268: ! 269: c->state = CTIDLE; ! 270: c->flags &= ~(CTFILEMARK | CTEOM); ! 271: return (r->status == ST_GOOD); ! 272: } /* loadtape() */ ! 273: ! 274: /*********************************************************************** ! 275: * writefm() ! 276: * ! 277: * Write Filemarks on the tape. ! 278: */ ! 279: ! 280: static void writefm(c, count) ! 281: register ctctrl_p c; ! 282: int count; ! 283: { ! 284: register srb_p r = &(c->srb); ! 285: register g0cmd_p g0 = &(r->cdb. g0); ! 286: ! 287: if (!ctbusywait(c, CTWRITEFM)) ! 288: return; ! 289: r->buf. space = (int) r->buf. addr. caddr = r->buf. size = 0; ! 290: r->xferdir = 0; ! 291: r->timeout = 40; ! 292: g0->opcode = WRITEFM; ! 293: g0->lun_lba = (r->lun << 5); ! 294: g0->lba_mid = ((unsigned char *) &count)[2]; ! 295: g0->lba_low = ((unsigned char *) &count)[1]; ! 296: g0->xfr_len = ((unsigned char *) &count)[0]; ! 297: g0->control = 0; ! 298: doscsi(r, 4, pritape, slpriSigCatch, "writefm"); ! 299: if (r->status != ST_GOOD && printerror(r, "Write filemarks failed")) ! 300: u. u_error = EIO; ! 301: c->state = CTIDLE; ! 302: } /* writefm() */ ! 303: ! 304: /*********************************************************************** ! 305: * space() ! 306: * ! 307: * Space over blocks/filemarks/etc. ! 308: */ ! 309: ! 310: static void space(c, count, object) ! 311: register ctctrl_p c; ! 312: int count; ! 313: int object; ! 314: { ! 315: register srb_p r = &(c->srb); ! 316: register g0cmd_p g0 = &(r->cdb. g0); ! 317: ! 318: if (!ctbusywait(c, CTSPACE)) ! 319: return; ! 320: r->buf. space = (int) r->buf. addr. caddr = r->buf. size = 0; ! 321: r->xferdir = 0; ! 322: r->timeout = 300; ! 323: g0->opcode = SPACE; ! 324: g0->lun_lba = (r->lun << 5) | (object & 3); ! 325: g0->lba_mid = ((unsigned char *) &count)[2]; ! 326: g0->lba_low = ((unsigned char *) &count)[1]; ! 327: g0->xfr_len = ((unsigned char *) &count)[0]; ! 328: g0->control = 0; ! 329: doscsi(r, 2, pritape, slpriSigCatch, "space"); ! 330: if (r->status != ST_GOOD && printerror(r, "Space failed")) ! 331: u. u_error = EIO; ! 332: c->state = CTIDLE; ! 333: } /* space() */ ! 334: ! 335: /*********************************************************************** ! 336: * rewind() ! 337: * ! 338: * Rewind the tape drive back to the load point. ! 339: */ ! 340: ! 341: static void rewind(c, wait) ! 342: register ctctrl_p c; ! 343: int wait; ! 344: { ! 345: register srb_p r = &(c->srb); ! 346: register g0cmd_p g0 = &(r->cdb. g0); ! 347: ! 348: if (!ctbusywait(c, CTREWIND)) ! 349: return; ! 350: r->buf. space = (int) r->buf. addr. caddr = r->buf. size = 0; ! 351: r->timeout = 300; ! 352: r->xferdir = 0; ! 353: memset(g0, 0, sizeof(cdb_t)); ! 354: g0->opcode = REWINDTAPE; ! 355: if (!wait) ! 356: g0->lun_lba = (r->lun << 5) | 1; ! 357: doscsi(r, 2, pritape, slpriSigCatch, "rewind"); ! 358: if (r->status != ST_GOOD && printerror(r, "Rewind failed")) ! 359: u. u_error = EIO; ! 360: c->flags = 0; ! 361: c->state = CTIDLE; ! 362: } /* rewind() */ ! 363: ! 364: static void erase(c, to_eot) ! 365: register ctctrl_p c; ! 366: int to_eot; ! 367: { ! 368: register srb_p r = &(c->srb); ! 369: register g0cmd_p g0 = &(r->cdb. g0); ! 370: ! 371: if (!ctbusywait(c, CTERASE)) ! 372: return; ! 373: r->buf. space = (int) r->buf. addr. caddr = r->buf. size = 0; ! 374: r->timeout = 300; ! 375: r->xferdir = 0; ! 376: memset(g0, 0, sizeof(cdb_t)); ! 377: g0->opcode = ERASE; ! 378: g0->lun_lba = (r->lun << 5); ! 379: if (to_eot) ! 380: g0->lun_lba |= 1; ! 381: doscsi(r, 2, pritape, slpriSigCatch, "erase"); ! 382: if (r->status != ST_GOOD && printerror(r, "Erase failed")) ! 383: u. u_error = EIO; ! 384: if (to_eot) ! 385: c->flags &= ~(CTFILEMARK | CTEOM | CTILI | CTDIRTY); ! 386: c->state = CTIDLE; ! 387: } /* erase() */ ! 388: ! 389: /*********************************************************************** ! 390: * Device Driver Entry Point routines. * ! 391: ***********************************************************************/ ! 392: ! 393: /*********************************************************************** ! 394: * ctinit() ! 395: * ! 396: * Initialize the tape device at (id). This doesn't do anything, ! 397: * not even verify that the drive is there because it could be powered ! 398: * off. ! 399: */ ! 400: ! 401: static int ctinit(id) ! 402: register int id; ! 403: { ! 404: register ctctrl_p c = kalloc(sizeof(ctctrl_t)); ! 405: ! 406: if (!c) { ! 407: printf("\tTape Driver: Could not allocate control structure.\n"); ! 408: return 0; ! 409: } ! 410: ! 411: printf("\tCoherent SCSI Tape driver v1.1\n"); ! 412: memset(c, 0, sizeof(ctctrl_t)); ! 413: c->inuse = 0; ! 414: c->cache = c->start = NULL; ! 415: c->cachesize = HAICACHESZ; ! 416: c->srb. target = id; ! 417: c->srb. lun = 0; ! 418: c->state = CTIDLE; ! 419: ctdevs[id] = c; ! 420: return 1; ! 421: } ! 422: ! 423: static void ctopen(dev, mode) ! 424: dev_t dev; ! 425: int mode; ! 426: { ! 427: register ctctrl_p c = ctdevs[tid(dev)]; ! 428: register srb_p r = &(c->srb); ! 429: register g0cmd_p g0 = &(r->cdb. g0); ! 430: int rblerf; /* read block limits error flag */ ! 431: int s; ! 432: char buf[64]; ! 433: blkdscr_p bd = (blkdscr_p) (buf + 4); ! 434: blklim_p bl = (blklim_p) (buf); ! 435: ! 436: if (!c) { ! 437: u. u_error = ENXIO; ! 438: return; ! 439: } ! 440: if ((mode != IPR) && (mode != IPW)) { ! 441: u. u_error = EINVAL; ! 442: return; ! 443: } ! 444: ! 445: s = sphi(); ! 446: ! 447: if (c->inuse) { ! 448: u. u_error = EDBUSY; ! 449: goto done; ! 450: } ! 451: ! 452: c->inuse = 1; ! 453: c->state = CTINIT; ! 454: r->dev = dev; /* Save the rewind bit for close. */ ! 455: ! 456: /*********************************************************************** ! 457: * Repeat the test unit ready command to the tape drive. This tells ! 458: * the state of the tape drive. Repeating the command also clears out ! 459: * the request sense condition which comes after each time the user ! 460: * changes tapes. ! 461: */ ! 462: ! 463: r->timeout = 2; ! 464: r->buf. space = (int) r->buf. addr. caddr = r->buf. size = 0; ! 465: r->xferdir = 0; ! 466: memset(g0, 0, sizeof(cdb_t)); /* Test Unit Ready */ ! 467: memset(r->sensebuf, 0, sizeof(r->sensebuf)); ! 468: doscsi(r, 4, pritape, slpriSigCatch, "ctopen"); ! 469: ! 470: /*********************************************************************** ! 471: * If the command fails there probably wasn't a tape in the drive. ! 472: */ ! 473: ! 474: if (r->status != ST_GOOD) { /* Is there a tape in the drive? */ ! 475: if (r->status != ST_USRABRT) { ! 476: /* Otherwise assume no tape. */ ! 477: u. u_error = ENXIO; ! 478: devmsg(r->dev, "Tape drive not ready."); ! 479: goto openfailed; ! 480: } ! 481: } ! 482: #ifdef TDC3600 ! 483: ! 484: /*********************************************************************** ! 485: * TDC3600's do a retension after all bus device resets and tape changes ! 486: * so I block in the open routine waiting for that operation to complete. ! 487: * This is a kludge to fix the author's system. I anticipate that ! 488: * other host adapters may not be so kind about retrying commands ! 489: * until a device reports that it is no longer busy. Hence the error ! 490: * message when this command fails. All this really does is allows ! 491: * me to safely start applications while the initial retension is still ! 492: * happening [csh]. ! 493: */ ! 494: ! 495: else { ! 496: if (r->sensebuf[0] == 0x70 && r->sensebuf[2] == 0x06) { ! 497: ! 498: /* Yep, The user just put it there */ ! 499: ! 500: r->buf. space = (int) r->buf. addr. caddr = r->buf. size = 0; ! 501: r->xferdir = 0; ! 502: r->timeout = 300; ! 503: memset(g0, 0, sizeof(cdb_t)); ! 504: g0->opcode = LOAD; ! 505: g0->xfr_len = 1; /* Move tape to load point. */ ! 506: doscsi(r, 4, pritape, slpriSigCatch, "ctopen"); ! 507: if (r->status != ST_GOOD && ! 508: printerror(r, "Load failed - TDC3600 not ready")) { ! 509: u. u_error = ENXIO; ! 510: goto openfailed; ! 511: } ! 512: } ! 513: } ! 514: #endif ! 515: ! 516: ctvmsg(0x0100, (devmsg(r->dev, "Read block limits."))); ! 517: #ifdef TDC3600 ! 518: c->blmin = c->blmax = 512; ! 519: ctvmsg(0x0100, (devmsg(r->dev, "Tandberg TDC36XX - Block limits set"))); ! 520: rblerf = 0; ! 521: #else ! 522: r->buf. space = KRNL_ADDR; ! 523: r->buf. addr. caddr = (caddr_t) bl; ! 524: r->buf. size = sizeof(blklim_t); ! 525: r->xferdir = DMAREAD; ! 526: r->timeout = 2; ! 527: memset(g0, 0, sizeof(cdb_t)); ! 528: g0->opcode = READBLKLMT; ! 529: g0->xfr_len = 6; ! 530: doscsi(r, 3, pritape, slpriSigCatch, "ctopen"); ! 531: ! 532: /*********************************************************************** ! 533: * This is a bit oblique: The Read Block limits is used to determine ! 534: * what the tape drive that we have can do. I have yet to run into ! 535: * a tape drive that can do variable mode yet so I'm just winging ! 536: * this. In any case all I did was make it okay for the Archive Tape ! 537: * drives to say "I don't support that command". ! 538: */ ! 539: ! 540: if (rblerf = (r->status != ST_GOOD)) { ! 541: ctvmsg(0x0010, (printerror(r, "Read Block LImits"))); ! 542: c->blmax = c->blmin = 0; ! 543: } ! 544: else { ! 545: flip(bl->blmax); /* SCSI to INTEL order */ ! 546: flip(bl->blmin); /* Ditto */ ! 547: c->blmax = (bl->blmax & 0x00ffffff); ! 548: c->blmin = bl->blmin; ! 549: } ! 550: #endif ! 551: ! 552: /*********************************************************************** ! 553: * Use mode sense to find out if the tape is write protected and also ! 554: * to find out what the current tape blocksize is. ! 555: */ ! 556: ! 557: r->buf. space = KRNL_ADDR; ! 558: r->buf. addr. caddr = (caddr_t) buf; ! 559: r->buf. size = sizeof(buf); ! 560: r->xferdir = DMAREAD; ! 561: r->timeout = 2; ! 562: memset(g0, 0, sizeof(cdb_t)); ! 563: g0->opcode = MODESENSE; ! 564: g0->xfr_len = sizeof(buf); ! 565: doscsi(r, 3, pritape, slpriSigCatch, "ctopen"); ! 566: if (r->status != ST_GOOD) { ! 567: if (printerror(r, "Mode sense failed")) ! 568: u. u_error = EIO; ! 569: goto openfailed; ! 570: } ! 571: ! 572: /*********************************************************************** ! 573: * If tape drive opened in write mode make sure the tape is not write ! 574: * protected now. ! 575: */ ! 576: ! 577: if (mode == IPW && (buf[2] & 0x80) != 0) { ! 578: devmsg(dev, "Tape is write protected"); ! 579: u. u_error = ENXIO; ! 580: goto openfailed; ! 581: } ! 582: ! 583: /*********************************************************************** ! 584: * If mode sense returned any media descriptors take the first one, ! 585: * it's the default, and use it. ! 586: * ! 587: * There are two possible pitfalls here: ! 588: * ! 589: * 1) According to SCSI-1 it not an error to return zero block ! 590: * descriptors. If you're favorite drive returns zero block descriptors ! 591: * this driver will fail here. ! 592: * ! 593: * 2) I am assuming that the first media descriptor returned is ! 594: * the "current" media type which the drive expects to use. This ! 595: * works with SCSI-2 but SCSI-1 says that the first descriptor is ! 596: * the "default" media type. SCSI-1 is lacking in the definition ! 597: * of "default" for my conservative taste (when programming is ! 598: * concerned). ! 599: * ! 600: * I would like to put the issue of supporting real oddball tape drives ! 601: * like my Tandberg to rest and only have one source source file for ! 602: * scsi tape drives but I don't think that will work. In the future ! 603: * there will probably be two or maybe three if DAT proves to be as ! 604: * much fun as this is. ! 605: */ ! 606: ! 607: if (buf[3]) { /* If mode sense returned any media descriptors */ ! 608: bd->rb. blocksize &= 0xffffff00; ! 609: flip(bd->rb. blocksize); ! 610: c->block = bd->rb. blocksize; ! 611: if (c->block && c->cachesize % c->block) ! 612: c->cachesize -= (c->cachesize % c->block); ! 613: } ! 614: else { ! 615: devmsg(r->dev, "No media descriptors: Contact Mark Williams Tech support"); ! 616: u. u_error = ENXIO; ! 617: goto openfailed; ! 618: } ! 619: ctvmsg(0x0001, devmsg(dev, "Blocksize: %d bytes.", c->block)); ! 620: ! 621: /*********************************************************************** ! 622: * One last check: If we aren't using block mode (!c->block) ! 623: * and we didn't get any block limits then we cannot support this ! 624: * drive. ! 625: */ ! 626: ! 627: if (!c->block && rblerf) { ! 628: devmsg(r->dev, "<No block limits on variable mode tape drive>"); ! 629: devmsg(r->dev, "<Contact Mark Williams Tech Support>"); ! 630: u. u_error = ENXIO; ! 631: goto openfailed; ! 632: } ! 633: ! 634: c->flags = (mode == IPR) ? CTRDMD : CTWRTMD; ! 635: if (c->block) { ! 636: c->cache = kalloc(HAICACHESZ); ! 637: if (!c->cache) { ! 638: devmsg(dev, "Could not allocate tape cache"); ! 639: u. u_error = ENOMEM; ! 640: goto openfailed; ! 641: } ! 642: c->avail = (c->flags & CTRDMD) ? 0 : HAICACHESZ; ! 643: c->start = c->cache; ! 644: } ! 645: c->state = CTIDLE; ! 646: goto done; ! 647: ! 648: openfailed: ! 649: c->state = CTIDLE; ! 650: c->inuse = 0; ! 651: ! 652: done: ! 653: spl(s); ! 654: } /* ctopen() */ ! 655: ! 656: /*********************************************************************** ! 657: * ctclose() ! 658: * ! 659: * Close the SCSI Device at (dev). ! 660: */ ! 661: ! 662: static void ctclose(dev) ! 663: register dev_t dev; ! 664: { ! 665: register ctctrl_p c = ctdevs[tid(dev)]; ! 666: register srb_p r = &(c->srb); ! 667: int s; ! 668: ! 669: if (!c) { ! 670: u. u_error = ENXIO; ! 671: return; ! 672: } ! 673: ! 674: s = sphi(); ! 675: if (c->block && (c->flags & CTWRTMD)) { ! 676: if (ctbusywait(c, CTLASTWRT)) ! 677: flushcache(c); ! 678: c->state = CTIDLE; ! 679: } ! 680: spl(s); ! 681: if (c->cache) { ! 682: kfree(c->cache); ! 683: c->cache = c->start = NULL; ! 684: c->avail = 0; ! 685: } ! 686: ! 687: #ifndef TDC3600 ! 688: /* ! 689: * Write two filemarks (Logical End of Tape) and then skip backwards ! 690: * over one of them to ready for the another write operation on the ! 691: * no rewind device. This code guarantees properly formed tapes according ! 692: * to the wisened old nine-track hacker that I work with. The problem ! 693: * is that... ! 694: */ ! 695: if (c->flags & CTDIRTY) { ! 696: writefm(c, 1); /* Write a file mark */ ! 697: writefm(c, 1); /* Write another filemark */ ! 698: space(c, -1, SKIP_FM); /* Go back to the first filemark */ ! 699: } ! 700: #else ! 701: /* ! 702: * ... problem is that my Tandberg considers it an error to do anything ! 703: * after it has skipped past a filemark. So all commands except load and ! 704: * rewind fail after the previous code. The following will work in ! 705: * all situations but there is a risk that a user's tapes will only ! 706: * have one filemark at Logical End-of-Tape if the user isn't careful ! 707: * to use the rewind device the last time he uses tape drive. This is ! 708: * only a problem with drives which insist upon doing a Retension each ! 709: * time the tape is changed or the drive gets reset. ! 710: */ ! 711: if (c->flags & CTDIRTY) { ! 712: writefm(c, 1); ! 713: if (r->dev & REWIND) ! 714: writefm(c, 1); ! 715: } ! 716: #endif ! 717: ! 718: if (r->dev & REWIND) ! 719: rewind(c, 0); ! 720: ! 721: c->inuse = 0; ! 722: return; ! 723: } /* ctclose() */ ! 724: ! 725: /*********************************************************************** ! 726: * fillcache() -- Read from the tape into the cache (really?) ! 727: * ! 728: * return 0 and set u. u_error on any errors. ! 729: */ ! 730: ! 731: static int fillcache(c) ! 732: register ctctrl_p c; ! 733: { ! 734: register srb_p r = (&c->srb); ! 735: register g0cmd_p g0 = &(r->cdb. g0); ! 736: size_t blocks; ! 737: extsense_p e; ! 738: int info; ! 739: int retval = 0; ! 740: ! 741: r->buf. space = KRNL_ADDR; ! 742: r->buf. addr. caddr = (caddr_t) c->cache; ! 743: r->buf. size = HAICACHESZ; ! 744: r->xferdir = DMAREAD; ! 745: r->timeout = 30; ! 746: r->tries = 0; ! 747: g0->opcode = READ; ! 748: g0->lun_lba = (r->lun << 5) | 1; ! 749: blocks = HAICACHESZ / c->block; ! 750: g0->lba_mid = ((unsigned char *) &blocks)[2]; ! 751: g0->lba_low = ((unsigned char *) &blocks)[1]; ! 752: g0->xfr_len = ((unsigned char *) &blocks)[0]; ! 753: g0->control = 0; ! 754: doscsi(r, 1, pritape, slpriSigCatch, "ctblkrd"); ! 755: switch (r->status) { ! 756: case ST_GOOD: ! 757: c->start = c->cache; ! 758: c->avail = r->buf. size; ! 759: retval = 1; ! 760: break; ! 761: case ST_CHKCOND: ! 762: e = r->sensebuf; ! 763: if ((e->errorcode & 0x70) == 0x70) { ! 764: info = 0; ! 765: if (e->errorcode & 0x80) { ! 766: info = e->info; ! 767: flip(info); ! 768: } ! 769: if (e->sensekey & (CTFILEMARK | CTEOM)) { ! 770: c->flags |= (e->sensekey & (CTFILEMARK | CTEOM)); ! 771: c->start = c->cache; ! 772: c->avail = HAICACHESZ - (info * c->block); ! 773: retval = 1; ! 774: break; ! 775: } ! 776: } ! 777: printsense(r->dev, "Read failed", r->sensebuf); ! 778: u. u_error = EIO; ! 779: retval = 0; ! 780: break; ! 781: case ST_USRABRT: ! 782: u. u_error = EINTR; ! 783: c->start = c->cache; ! 784: c->avail = 0; ! 785: retval = 0; ! 786: break; ! 787: default: ! 788: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 789: u. u_error = EIO; ! 790: retval = 0; ! 791: break; ! 792: } ! 793: return retval; ! 794: } /* fillcache() */ ! 795: ! 796: /*********************************************************************** ! 797: * ctfbrd() -- Fixed block read handler. Reads from the tape ! 798: * drive through the cache when the tape drive is ! 799: * in fixed block mode. ! 800: */ ! 801: ! 802: static void ctfbrd(c, iop) ! 803: register ctctrl_p c; ! 804: register IO *iop; ! 805: { ! 806: register size_t reqcount, /* Total bytes transfered toward request */ ! 807: xfrsize; /* Current transfer size */ ! 808: size_t total, /* System global memory total transfer size */ ! 809: size; /* System global memory current transfer size */ ! 810: ! 811: if (!ctbusywait(c, CTFBRD)) ! 812: return; ! 813: reqcount = 0; ! 814: while (iop->io_ioc) { ! 815: xfrsize = min(c->avail, iop->io_ioc); ! 816: if (xfrsize > 0) { ! 817: switch (iop->io_seg) { ! 818: case IOSYS: ! 819: memcpy(iop->io. vbase + reqcount, c->start, xfrsize); ! 820: break; ! 821: case IOUSR: ! 822: kucopy(c->start, iop->io. vbase + reqcount, xfrsize); ! 823: break; ! 824: case IOPHY: ! 825: total = 0; ! 826: while (total < xfrsize) { ! 827: size = min(xfrsize - total, NBPC); ! 828: xpcopy(c->start + total, ! 829: iop->io. pbase + reqcount + total, ! 830: size, ! 831: SEG_386_KD | SEG_VIRT); ! 832: total += size; ! 833: } ! 834: break; ! 835: } ! 836: c->start += xfrsize; ! 837: c->avail -= xfrsize; ! 838: reqcount += xfrsize; ! 839: iop->io_ioc -= xfrsize; ! 840: } ! 841: if (iop->io_ioc) { ! 842: if (c->flags & CTFILEMARK) { ! 843: c->flags &= ~CTFILEMARK; ! 844: break; ! 845: } ! 846: ! 847: if (c->flags & CTEOM) { ! 848: u. u_error = EIO; ! 849: break; ! 850: } ! 851: ! 852: if (!fillcache(c)) ! 853: break; ! 854: } ! 855: } /* while */ ! 856: c->state = CTIDLE; ! 857: } /* ctfbrd() */ ! 858: ! 859: /*********************************************************************** ! 860: * ctvbrd() -- Variable block read entry point. ! 861: */ ! 862: ! 863: static void ctvbrd(c, iop) ! 864: register ctctrl_p c; ! 865: IO *iop; ! 866: { ! 867: register srb_p r = &(c->srb); ! 868: register g0cmd_p g0 = &(r->cdb. g0); ! 869: size_t xfrsize; ! 870: extsense_p e; ! 871: int info; ! 872: ! 873: if (!ctbusywait(c, CTVBRD)) ! 874: return; ! 875: ! 876: if (c->flags & CTEOM) { ! 877: u. u_error = EIO; ! 878: return; ! 879: } ! 880: if (c->flags & CTFILEMARK) { ! 881: c->flags &= ~CTFILEMARK; ! 882: return; ! 883: } ! 884: switch (iop->io_seg) { ! 885: case IOSYS: ! 886: r->buf. space = KRNL_ADDR; ! 887: r->buf. addr. caddr = iop->io. vbase; ! 888: break; ! 889: case IOUSR: ! 890: r->buf. space = USER_ADDR; ! 891: r->buf. addr. caddr = iop->io. vbase; ! 892: break; ! 893: case IOPHY: ! 894: r->buf. space = PHYS_ADDR; ! 895: r->buf. addr. paddr = iop->io. pbase; ! 896: break; ! 897: } ! 898: r->buf. size = xfrsize = iop->io_ioc; ! 899: r->xferdir = DMAREAD; ! 900: r->timeout = 30; ! 901: g0->opcode = READ; ! 902: g0->lun_lba = (r->lun << 5); ! 903: g0->lba_mid = ((unsigned char *) &xfrsize)[2]; ! 904: g0->lba_low = ((unsigned char *) &xfrsize)[1]; ! 905: g0->xfr_len = ((unsigned char *) &xfrsize)[0]; ! 906: g0->control = 0; ! 907: doscsi(r, 1, pritape, slpriSigCatch, "ctvbrd"); ! 908: switch (r->status) { ! 909: case ST_GOOD: ! 910: iop->io_ioc -= r->buf. size; ! 911: break; ! 912: case ST_CHKCOND: ! 913: e = r->sensebuf; ! 914: if ((e->errorcode & 0x70) == 0x70) { ! 915: info = 0; ! 916: if (e->errorcode & 0x80) { ! 917: info = (long) e->info; ! 918: flip(info); ! 919: } ! 920: if (e->sensekey & (CTFILEMARK | CTEOM)) { ! 921: c->flags |= (e->sensekey & (CTFILEMARK | CTEOM)); ! 922: break; ! 923: } ! 924: else if (e->sensekey & CTILI) { ! 925: devmsg(r->dev, ! 926: "Read failed buffer size %d blocksize %d", ! 927: xfrsize, ! 928: xfrsize - info); ! 929: if (info > 0) ! 930: iop->io_ioc -= (xfrsize - info); ! 931: else ! 932: u. u_error = EIO; ! 933: break; ! 934: } ! 935: } ! 936: printsense(r->dev, "Read failed", r->sensebuf); ! 937: u. u_error = EIO; ! 938: break; ! 939: case ST_USRABRT: ! 940: break; ! 941: default: ! 942: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 943: u. u_error = EIO; ! 944: break; ! 945: } ! 946: c->state = CTIDLE; ! 947: } /* ctvbrd() */ ! 948: ! 949: /*********************************************************************** ! 950: * ctread() -- OS Read entry point. ! 951: */ ! 952: ! 953: static void ctread(dev, iop) ! 954: dev_t dev; ! 955: register IO *iop; ! 956: { ! 957: register ctctrl_p c = ctdevs[tid(dev)]; ! 958: ! 959: if (!c) { ! 960: u. u_error = EINVAL; ! 961: return; ! 962: } ! 963: ! 964: if (c->block) ! 965: ctfbrd(c, iop); ! 966: else ! 967: ctvbrd(c, iop); ! 968: } /* ctread() */ ! 969: ! 970: /*********************************************************************** ! 971: * flushcache() -- flush the data in the cache to the tape. ! 972: * ! 973: * returns 0 and sets u. u_error on failure else returns 1. ! 974: */ ! 975: ! 976: static int flushcache(c) ! 977: register ctctrl_p c; ! 978: { ! 979: register srb_p r = (&c->srb); ! 980: register g0cmd_p g0 = &(r->cdb. g0); ! 981: size_t xfrsize; ! 982: extsense_p e; ! 983: int info; ! 984: int retval = 0; ! 985: ! 986: if (c->avail >= HAICACHESZ) ! 987: return 1; ! 988: ! 989: r->buf. space = KRNL_ADDR; ! 990: r->buf. addr. caddr = (caddr_t) c->cache; ! 991: r->buf. size = xfrsize = HAICACHESZ - c->avail; ! 992: r->xferdir = DMAWRITE; ! 993: r->timeout = 30; ! 994: r->tries = 0; ! 995: g0->opcode = WRITE; ! 996: g0->lun_lba = (r->lun << 5); ! 997: if (c->block) { ! 998: g0->lun_lba |= 1; ! 999: xfrsize = (xfrsize + c->block - 1) / c->block; ! 1000: } ! 1001: g0->lba_mid = ((unsigned char *) &xfrsize)[2]; ! 1002: g0->lba_low = ((unsigned char *) &xfrsize)[1]; ! 1003: g0->xfr_len = ((unsigned char *) &xfrsize)[0]; ! 1004: g0->control = 0; ! 1005: doscsi(r, 1, pritape, slpriSigCatch, "ctblkwrt"); ! 1006: switch (r->status) { ! 1007: case ST_GOOD: ! 1008: c->start = c->cache; ! 1009: c->avail = HAICACHESZ; ! 1010: retval = 1; ! 1011: break; ! 1012: case ST_CHKCOND: ! 1013: e = r->sensebuf; ! 1014: if ((e->errorcode & 0x70) == 0x70) { ! 1015: info = 0; ! 1016: if (e->errorcode & 0x80) { ! 1017: info = e->info; ! 1018: flip(info); ! 1019: } ! 1020: if (e->sensekey & CTEOM) { ! 1021: c->flags |= CTEOM; ! 1022: devmsg(r->dev, "End of tape on block write"); ! 1023: } ! 1024: } ! 1025: printsense(r->dev, "Read failed", r->sensebuf); ! 1026: u. u_error = EIO; ! 1027: retval = 0; ! 1028: break; ! 1029: case ST_USRABRT: ! 1030: retval = 0; ! 1031: break; ! 1032: default: ! 1033: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 1034: u. u_error = EIO; ! 1035: retval = 0; ! 1036: break; ! 1037: } ! 1038: return retval; ! 1039: } /* flushcache() */ ! 1040: ! 1041: /*********************************************************************** ! 1042: * ctfbwrt() -- Fixed block write. This should be fast because ! 1043: * it uses the tapes drives optimum setting and it ! 1044: * goes through a cache. ! 1045: */ ! 1046: ! 1047: static void ctfbwrt(c, iop) ! 1048: register ctctrl_p c; ! 1049: register IO *iop; ! 1050: { ! 1051: register size_t reqcount, /* Total bytes transfered */ ! 1052: xfrsize; /* Current transfer size */ ! 1053: size_t total, /* System global memory total transfer size */ ! 1054: size; /* System global memory current transfer size */ ! 1055: ! 1056: if (!ctbusywait(c, CTFBWRT)) ! 1057: return; ! 1058: ! 1059: reqcount = 0; ! 1060: while (iop->io_ioc) { ! 1061: xfrsize = min(c->avail, iop->io_ioc); ! 1062: if (xfrsize) { ! 1063: switch (iop->io_seg) { ! 1064: case IOSYS: ! 1065: memcpy(c->start, iop->io. vbase + reqcount, xfrsize); ! 1066: break; ! 1067: case IOUSR: ! 1068: ukcopy(iop->io. vbase + reqcount, c->start, xfrsize); ! 1069: break; ! 1070: case IOPHY: ! 1071: total = 0; ! 1072: while (total < xfrsize) { ! 1073: size = min(xfrsize - total, NBPC); ! 1074: pxcopy(iop->io. pbase + reqcount + total, ! 1075: c->start + total, ! 1076: size, ! 1077: SEG_386_KD | SEG_VIRT); ! 1078: total += size; ! 1079: } ! 1080: break; ! 1081: } ! 1082: c->start += xfrsize; ! 1083: c->avail -= xfrsize; ! 1084: reqcount += xfrsize; ! 1085: iop->io_ioc -= xfrsize; ! 1086: } ! 1087: if (iop->io_ioc) { ! 1088: if (!flushcache(c)) ! 1089: break; ! 1090: } ! 1091: } /* while */ ! 1092: c->state = CTIDLE; ! 1093: } /* ctfbwrt() */ ! 1094: ! 1095: /*********************************************************************** ! 1096: * ctvbwrt() -- Variable block writes. ! 1097: */ ! 1098: ! 1099: static void ctvbwrt(c, iop) ! 1100: register ctctrl_p c; ! 1101: register IO *iop; ! 1102: { ! 1103: register srb_p r = &(c->srb); ! 1104: register g0cmd_p g0 = &(r->cdb. g0); ! 1105: size_t xfrsize; ! 1106: extsense_p e; ! 1107: int info; ! 1108: ! 1109: if (!ctbusywait(c, CTVBWRT)) ! 1110: return; ! 1111: ! 1112: if (c->blmax && iop->io_ioc > c->blmax) { ! 1113: devmsg(r->dev, "Tape Error: maximum read/write size is %d bytes.", c->blmax); ! 1114: u. u_error = EIO; ! 1115: return; ! 1116: } ! 1117: switch (iop->io_seg) { ! 1118: case IOSYS: ! 1119: r->buf. space = KRNL_ADDR; ! 1120: r->buf. addr. caddr = iop->io. vbase; ! 1121: break; ! 1122: case IOUSR: ! 1123: r->buf. space = USER_ADDR; ! 1124: r->buf. addr. caddr = iop->io. vbase; ! 1125: break; ! 1126: case IOPHY: ! 1127: r->buf. space = PHYS_ADDR; ! 1128: r->buf. addr. paddr = iop->io. pbase; ! 1129: break; ! 1130: } ! 1131: xfrsize = min(iop->io_ioc, c->blmin); ! 1132: r->buf. size = xfrsize; ! 1133: r->xferdir = DMAWRITE; ! 1134: r->timeout = 30; ! 1135: g0->opcode = WRITE; ! 1136: g0->lun_lba = (r->lun << 5); ! 1137: g0->lba_mid = ((unsigned char *) &xfrsize)[2]; ! 1138: g0->lba_low = ((unsigned char *) &xfrsize)[1]; ! 1139: g0->xfr_len = ((unsigned char *) &xfrsize)[0]; ! 1140: g0->control = 0; ! 1141: doscsi(r, 1, pritape, slpriSigCatch, "ctvbwrt"); ! 1142: switch (r->status) { ! 1143: case ST_GOOD: ! 1144: iop->io_ioc -= r->buf. size; ! 1145: break; ! 1146: case ST_CHKCOND: ! 1147: e = r->sensebuf; ! 1148: if ((e->errorcode & 0x70) == 0x70) { ! 1149: info = 0; ! 1150: if (e->errorcode & 0x80) { ! 1151: info = (long) e->info; ! 1152: flip(info); ! 1153: } ! 1154: if (e->sensekey & CTEOM) { ! 1155: c->flags |= CTEOM; ! 1156: devmsg(r->dev, "End of tape"); ! 1157: } ! 1158: } ! 1159: printsense(r->dev, "Write failed", r->sensebuf); ! 1160: u. u_error = EIO; ! 1161: break; ! 1162: case ST_USRABRT: ! 1163: break; ! 1164: default: ! 1165: devmsg(r->dev, "Read failed: status (0x%x)", r->status); ! 1166: u. u_error = EIO; ! 1167: break; ! 1168: } ! 1169: c->state = CTIDLE; ! 1170: } /* ctvbwrt() */ ! 1171: ! 1172: /*********************************************************************** ! 1173: * ctwrite() -- Write entry point for tape drive. ! 1174: */ ! 1175: ! 1176: static void ctwrite(dev, iop) ! 1177: register dev_t dev; ! 1178: register IO *iop; ! 1179: { ! 1180: register ctctrl_p c = ctdevs[tid(dev)]; ! 1181: ! 1182: if (!c) { ! 1183: u. u_error = ENXIO; ! 1184: return; ! 1185: } ! 1186: ! 1187: c->flags |= CTDIRTY; ! 1188: if (c->block) ! 1189: ctfbwrt(c, iop); ! 1190: else ! 1191: ctvbwrt(c, iop); ! 1192: } /* ctwrite() */ ! 1193: ! 1194: /*********************************************************************** ! 1195: * ctioctl() ! 1196: * ! 1197: * I/O Control Entry point for Cartridge tape devices. ! 1198: * ! 1199: * This function had been modified to allow applications level programs ! 1200: * to select modes and features for the tape drive. As stated above, ! 1201: * the philosophy of this driver is to provide least common denominator ! 1202: * support for all tape drives. I know that you spend big bucks to ! 1203: * get that (insert your favorite drive brand/model). If I decide ! 1204: * to support everything out there on the market then I won't be able ! 1205: * to write network drivers, serial drivers, etc. So if you need ! 1206: * to do something to the tape drive to make it work (mode sense/select) ! 1207: * you can do it through this ctioctl as an applications program. ! 1208: */ ! 1209: ! 1210: static void ctioctl(dev, cmd, vec) ! 1211: dev_t dev; ! 1212: register int cmd; ! 1213: char *vec; ! 1214: { ! 1215: register ctctrl_p c = ctdevs[tid(dev)]; ! 1216: register srb_p r = &(c->srb); ! 1217: int s; ! 1218: ! 1219: if (!c) { ! 1220: u. u_error = EINVAL; ! 1221: return; ! 1222: } ! 1223: ! 1224: switch (cmd) { ! 1225: case MTREWIND: /* Rewind */ ! 1226: rewind(c, 1); ! 1227: break; ! 1228: case MTWEOF: /* Write end of file mark */ ! 1229: writefm(c, 1); ! 1230: break; ! 1231: case MTRSKIP: /* Record skip */ ! 1232: space(c, 1, SKIP_BLK); ! 1233: break; ! 1234: case MTFSKIP: /* File skip */ ! 1235: space(c, 1, SKIP_FM); ! 1236: break; ! 1237: case MTTENSE: /* Tension tape */ ! 1238: loadtape(c, RETENSION); ! 1239: break; ! 1240: case MTERASE: /* Erase tape */ ! 1241: erase(c, ERASE_TAPE); ! 1242: break; ! 1243: case MTDEC: /* DEC mode */ ! 1244: case MTIBM: /* IBM mode */ ! 1245: case MT800: /* 800 bpi */ ! 1246: case MT1600: /* 1600 bpi */ ! 1247: case MT6250: /* 6250 bpi */ ! 1248: return; ! 1249: default: ! 1250: if (!ctbusywait(c, CTIOCTL)) ! 1251: return; ! 1252: s = sphi(); ! 1253: haiioctl(r, cmd, vec); ! 1254: c->state = CTIDLE; ! 1255: spl(s); ! 1256: break; ! 1257: } ! 1258: } /* ctioctl() */ ! 1259: ! 1260: /* End of file */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.