1 /* $OpenBSD: st.c,v 1.185 2020/09/22 19:32:53 krw Exp $ */ 2 /* $NetBSD: st.c,v 1.71 1997/02/21 23:03:49 thorpej Exp $ */ 3 4 /* 5 * Copyright (c) 1994 Charles Hannum. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Charles Hannum. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Originally written by Julian Elischer (julian@tfs.com) 35 * for TRW Financial Systems for use under the MACH(2.5) operating system. 36 * 37 * TRW Financial Systems, in accordance with their agreement with Carnegie 38 * Mellon University, makes this software available to CMU to distribute 39 * or use in any manner that they see fit as long as this message is kept with 40 * the software. For this reason TFS also grants any other persons or 41 * organisations permission to use or modify this software. 42 * 43 * TFS supplies this software to be publicly redistributed 44 * on the understanding that TFS is not responsible for the correct 45 * functioning of this software in any circumstances. 46 * 47 * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992 48 * major changes by Julian Elischer (julian@jules.dialix.oz.au) May 1993 49 */ 50 51 /* 52 * To do: 53 * work out some better way of guessing what a good timeout is going 54 * to be depending on whether we expect to retension or not. 55 */ 56 57 #include <sys/param.h> 58 #include <sys/systm.h> 59 #include <sys/timeout.h> 60 #include <sys/fcntl.h> 61 #include <sys/errno.h> 62 #include <sys/ioctl.h> 63 #include <sys/stat.h> 64 #include <sys/pool.h> 65 #include <sys/buf.h> 66 #include <sys/mtio.h> 67 #include <sys/device.h> 68 #include <sys/conf.h> 69 #include <sys/vnode.h> 70 71 #include <scsi/scsi_all.h> 72 #include <scsi/scsi_debug.h> 73 #include <scsi/scsi_tape.h> 74 #include <scsi/scsiconf.h> 75 76 /* Defines for device specific stuff */ 77 #define DEF_FIXED_BSIZE 512 78 79 #define STMODE(z) ( minor(z) & 0x03) 80 #define STUNIT(z) ((minor(z) >> 4) ) 81 82 #define STMINOR(unit, mode) (((unit) << 4) + (mode)) 83 #define MAXSTMODES 16 /* Old max retained so minor's don't change. */ 84 85 #define ST_IO_TIME (3 * 60 * 1000) /* 3 minutes */ 86 #define ST_CTL_TIME (30 * 1000) /* 30 seconds */ 87 #define ST_SPC_TIME (4 * 60 * 60 * 1000) /* 4 hours */ 88 89 /* 90 * Maximum density code allowed in SCSI spec (SSC2R08f, Section 8.3). 91 */ 92 #define SCSI_MAX_DENSITY_CODE 0xff 93 94 /* 95 * Define various devices that we know mis-behave in some way, 96 * and note how they are bad, so we can correct for them 97 */ 98 struct mode { 99 int blksize; 100 u_int8_t density; 101 }; 102 103 struct quirkdata { 104 u_int quirks; 105 #define ST_Q_SENSE_HELP 0x0001 /* must do READ for good MODE SENSE */ 106 #define ST_Q_IGNORE_LOADS 0x0002 107 #define ST_Q_UNIMODAL 0x0004 /* unimode drive rejects mode select */ 108 struct mode mode; 109 }; 110 111 struct st_quirk_inquiry_pattern { 112 struct scsi_inquiry_pattern pattern; 113 struct quirkdata quirkdata; 114 }; 115 116 const struct st_quirk_inquiry_pattern st_quirk_patterns[] = { 117 {{T_SEQUENTIAL, T_REMOV, 118 " ", " ", " "}, {0, 119 {512, 0}}}, 120 {{T_SEQUENTIAL, T_REMOV, 121 "TANDBERG", " TDC 3800 ", ""}, {0, 122 {512, 0}}}, 123 {{T_SEQUENTIAL, T_REMOV, 124 "ARCHIVE ", "VIPER 2525 25462", ""}, {ST_Q_SENSE_HELP, 125 {0, 0}}}, 126 {{T_SEQUENTIAL, T_REMOV, 127 "SANKYO ", "CP525 ", ""}, {0, 128 {512, 0}}}, 129 {{T_SEQUENTIAL, T_REMOV, 130 "ANRITSU ", "DMT780 ", ""}, {0, 131 {512, 0}}}, 132 {{T_SEQUENTIAL, T_REMOV, 133 "ARCHIVE ", "VIPER 150 21531", ""}, {ST_Q_SENSE_HELP, 134 {0, 0}}}, 135 {{T_SEQUENTIAL, T_REMOV, 136 "WANGTEK ", "5099ES SCSI", ""}, {0, 137 {512, 0}}}, 138 {{T_SEQUENTIAL, T_REMOV, 139 "WANGTEK ", "5150ES SCSI", ""}, {0, 140 {512, 0}}}, 141 {{T_SEQUENTIAL, T_REMOV, 142 "HP ", "T4000s ", ""}, {ST_Q_UNIMODAL, 143 {0, QIC_3095}}}, 144 {{T_SEQUENTIAL, T_REMOV, 145 "WANGTEK ", "5150ES SCSI FA15", "01 A"}, {ST_Q_IGNORE_LOADS, 146 {0, 0}}}, 147 {{T_SEQUENTIAL, T_REMOV, 148 "TEAC ", "MT-2ST/N50 ", ""}, {ST_Q_IGNORE_LOADS, 149 {0, 0}}}, 150 }; 151 152 #define NOEJECT 0 153 #define EJECT 1 154 155 #define NOREWIND 0 156 #define DOREWIND 1 157 158 struct st_softc { 159 struct device sc_dev; 160 161 int flags; 162 #define ST_INFO_VALID 0x00000001 163 #define ST_WRITTEN 0x00000004 164 #define ST_FIXEDBLOCKS 0x00000008 165 #define ST_AT_FILEMARK 0x00000010 166 #define ST_EIO_PENDING 0x00000020 167 #define ST_EOM_PENDING 0x00000040 168 #define ST_EOD_DETECTED 0x00000080 169 #define ST_FM_WRITTEN 0x00000100 170 #define ST_BLANK_READ 0x00000200 171 #define ST_2FM_AT_EOD 0x00000400 172 #define ST_MOUNTED 0x00000800 173 #define ST_DONTBUFFER 0x00001000 174 #define ST_DYING 0x00004000 175 #define ST_BOD_DETECTED 0x00008000 176 #define ST_MODE_DENSITY 0x00010000 177 #define ST_MODE_BLKSIZE 0x00040000 178 179 u_int quirks; /* quirks for the open mode */ 180 int blksize; /* blksize we are using */ 181 u_int8_t density; /* present density */ 182 short mt_resid; /* last (short) resid */ 183 short mt_erreg; /* last error (sense key) seen */ 184 185 struct scsi_link *sc_link; /* our link to the adpter etc. */ 186 187 int blkmin; /* min blk size */ 188 int blkmax; /* max blk size */ 189 190 u_int32_t media_blksize; /* 0 if not ST_FIXEDBLOCKS */ 191 u_int32_t media_density; /* this is what it said when asked */ 192 int media_fileno; /* relative to BOT. -1 means unknown. */ 193 int media_blkno; /* relative to BOF. -1 means unknown. */ 194 int media_eom; /* relative to BOT. -1 means unknown. */ 195 196 struct mode mode; 197 struct bufq sc_bufq; 198 struct scsi_xshandler sc_xsh; 199 }; 200 201 202 int stmatch(struct device *, void *, void *); 203 void stattach(struct device *, struct device *, void *); 204 int stactivate(struct device *, int); 205 int stdetach(struct device *, int); 206 void stminphys(struct buf *); 207 void ststart(struct scsi_xfer *); 208 209 int st_mount_tape(struct st_softc *, int); 210 void st_unmount(struct st_softc *, int, int); 211 int st_decide_mode(struct st_softc *, int); 212 void st_buf_done(struct scsi_xfer *); 213 int st_read(struct st_softc *, char *, int, int); 214 int st_read_block_limits(struct st_softc *, int); 215 int st_mode_sense(struct st_softc *, int); 216 int st_mode_select(struct st_softc *, int); 217 int st_space(struct st_softc *, int, u_int, int); 218 int st_write_filemarks(struct st_softc *, int, int); 219 int st_check_eod(struct st_softc *, int, int *, int); 220 int st_load(struct st_softc *, u_int, int); 221 int st_rewind(struct st_softc *, u_int, int); 222 int st_interpret_sense(struct scsi_xfer *); 223 int st_touch_tape(struct st_softc *); 224 int st_erase(struct st_softc *, int, int); 225 226 struct cfattach st_ca = { 227 sizeof(struct st_softc), stmatch, stattach, 228 stdetach, stactivate 229 }; 230 231 struct cfdriver st_cd = { 232 NULL, "st", DV_TAPE 233 }; 234 235 #define ST_PER_ACTION (ST_AT_FILEMARK | ST_EIO_PENDING | ST_EOM_PENDING | \ 236 ST_BLANK_READ) 237 238 #define stlookup(unit) (struct st_softc *)device_lookup(&st_cd, (unit)) 239 240 const struct scsi_inquiry_pattern st_patterns[] = { 241 {T_SEQUENTIAL, T_REMOV, 242 "", "", ""}, 243 }; 244 245 int 246 stmatch(struct device *parent, void *match, void *aux) 247 { 248 struct scsi_attach_args *sa = aux; 249 struct scsi_inquiry_data *inq = &sa->sa_sc_link->inqdata; 250 int priority; 251 252 (void)scsi_inqmatch(inq, st_patterns, nitems(st_patterns), 253 sizeof(st_patterns[0]), &priority); 254 return priority; 255 } 256 257 /* 258 * The routine called by the low level scsi routine when it discovers 259 * a device suitable for this driver. 260 */ 261 void 262 stattach(struct device *parent, struct device *self, void *aux) 263 { 264 const struct st_quirk_inquiry_pattern *finger; 265 struct st_softc *st = (void *)self; 266 struct scsi_attach_args *sa = aux; 267 struct scsi_link *link = sa->sa_sc_link; 268 int priority; 269 270 SC_DEBUG(link, SDEV_DB2, ("stattach:\n")); 271 272 /* 273 * Store information needed to contact our base driver 274 */ 275 st->sc_link = link; 276 link->interpret_sense = st_interpret_sense; 277 link->device_softc = st; 278 279 /* Get any quirks and mode information. */ 280 finger = (const struct st_quirk_inquiry_pattern *)scsi_inqmatch( 281 &link->inqdata, 282 st_quirk_patterns, 283 nitems(st_quirk_patterns), 284 sizeof(st_quirk_patterns[0]), &priority); 285 if (finger != NULL) { 286 st->quirks = finger->quirkdata.quirks; 287 st->mode = finger->quirkdata.mode; 288 CLR(st->flags, ST_MODE_BLKSIZE | ST_MODE_DENSITY); 289 if (st->mode.blksize != 0) 290 SET(st->flags, ST_MODE_BLKSIZE); 291 if (st->mode.density != 0) 292 SET(st->flags, ST_MODE_DENSITY); 293 } 294 printf("\n"); 295 296 scsi_xsh_set(&st->sc_xsh, link, ststart); 297 298 /* Set up the buf queue for this device. */ 299 bufq_init(&st->sc_bufq, BUFQ_FIFO); 300 301 /* Start up with media position unknown. */ 302 st->media_fileno = -1; 303 st->media_blkno = -1; 304 st->media_eom = -1; 305 306 /* 307 * Reset the media loaded flag, sometimes the data 308 * acquired at boot time is not quite accurate. This 309 * will be checked again at the first open. 310 */ 311 CLR(link->flags, SDEV_MEDIA_LOADED); 312 } 313 314 int 315 stactivate(struct device *self, int act) 316 { 317 struct st_softc *st = (struct st_softc *)self; 318 319 switch (act) { 320 case DVACT_DEACTIVATE: 321 SET(st->flags, ST_DYING); 322 scsi_xsh_del(&st->sc_xsh); 323 break; 324 } 325 326 return 0; 327 } 328 329 int 330 stdetach(struct device *self, int flags) 331 { 332 struct st_softc *st = (struct st_softc *)self; 333 int cmaj, mn; 334 335 bufq_drain(&st->sc_bufq); 336 337 /* Locate the lowest minor number to be detached. */ 338 mn = STMINOR(self->dv_unit, 0); 339 340 for (cmaj = 0; cmaj < nchrdev; cmaj++) 341 if (cdevsw[cmaj].d_open == stopen) 342 vdevgone(cmaj, mn, mn + MAXSTMODES - 1, VCHR); 343 344 bufq_destroy(&st->sc_bufq); 345 346 return 0; 347 } 348 349 /* 350 * open the device. 351 */ 352 int 353 stopen(dev_t dev, int flags, int fmt, struct proc *p) 354 { 355 struct scsi_link *link; 356 struct st_softc *st; 357 int error = 0; 358 359 st = stlookup(STUNIT(dev)); 360 if (st == NULL) 361 return ENXIO; 362 if (ISSET(st->flags, ST_DYING)) { 363 error = ENXIO; 364 goto done; 365 } 366 link = st->sc_link; 367 368 if (ISSET(flags, FWRITE) && ISSET(link->flags, SDEV_READONLY)) { 369 error = EACCES; 370 goto done; 371 } 372 373 SC_DEBUG(link, SDEV_DB1, ("open: dev=0x%x (unit %d (of %d))\n", dev, 374 STUNIT(dev), st_cd.cd_ndevs)); 375 376 /* 377 * Tape is an exclusive media. Only one open at a time. 378 */ 379 if (ISSET(link->flags, SDEV_OPEN)) { 380 SC_DEBUG(link, SDEV_DB4, ("already open\n")); 381 error = EBUSY; 382 goto done; 383 } 384 385 /* Use st_interpret_sense() now. */ 386 SET(link->flags, SDEV_OPEN); 387 388 /* 389 * Check the unit status. This clears any outstanding errors and 390 * will ensure that media is present. 391 */ 392 error = scsi_test_unit_ready(link, TEST_READY_RETRIES, 393 SCSI_SILENT | SCSI_IGNORE_MEDIA_CHANGE | 394 SCSI_IGNORE_ILLEGAL_REQUEST); 395 396 /* 397 * Terminate any exising mount session if there is no media. 398 */ 399 if (!ISSET(link->flags, SDEV_MEDIA_LOADED)) 400 st_unmount(st, NOEJECT, DOREWIND); 401 402 if (error != 0) { 403 CLR(link->flags, SDEV_OPEN); 404 goto done; 405 } 406 407 error = st_mount_tape(st, flags); 408 if (error != 0) { 409 CLR(link->flags, SDEV_OPEN); 410 goto done; 411 } 412 413 /* 414 * Make sure that a tape opened in write-only mode will have 415 * file marks written on it when closed, even if not written to. 416 * This is for SUN compatibility 417 */ 418 if ((flags & O_ACCMODE) == FWRITE) 419 SET(st->flags, ST_WRITTEN); 420 421 done: 422 SC_DEBUG(link, SDEV_DB2, ("open complete\n")); 423 device_unref(&st->sc_dev); 424 return error; 425 } 426 427 /* 428 * close the device.. only called if we are the LAST 429 * occurrence of an open device 430 */ 431 int 432 stclose(dev_t dev, int flags, int mode, struct proc *p) 433 { 434 struct scsi_link *link; 435 struct st_softc *st; 436 int error = 0; 437 438 st = stlookup(STUNIT(dev)); 439 if (st == NULL) 440 return ENXIO; 441 if (ISSET(st->flags, ST_DYING)) { 442 error = ENXIO; 443 goto done; 444 } 445 link = st->sc_link; 446 447 SC_DEBUG(link, SDEV_DB1, ("closing\n")); 448 449 if (ISSET(st->flags, ST_WRITTEN) && !ISSET(st->flags, ST_FM_WRITTEN)) 450 st_write_filemarks(st, 1, 0); 451 452 switch (STMODE(dev)) { 453 case 0: /* /dev/rstN */ 454 st_unmount(st, NOEJECT, DOREWIND); 455 break; 456 case 1: /* /dev/nrstN */ 457 st_unmount(st, NOEJECT, NOREWIND); 458 break; 459 case 2: /* /dev/erstN */ 460 st_unmount(st, EJECT, DOREWIND); 461 break; 462 case 3: /* /dev/enrstN */ 463 st_unmount(st, EJECT, NOREWIND); 464 break; 465 } 466 CLR(link->flags, SDEV_OPEN); 467 scsi_xsh_del(&st->sc_xsh); 468 469 done: 470 device_unref(&st->sc_dev); 471 return error; 472 } 473 474 /* 475 * Start a new mount session if needed. 476 */ 477 int 478 st_mount_tape(struct st_softc *st, int flags) 479 { 480 struct scsi_link *link = st->sc_link; 481 int error = 0; 482 483 if (ISSET(st->flags, ST_MOUNTED)) 484 return 0; 485 486 SC_DEBUG(link, SDEV_DB1, ("mounting\n")); 487 488 /* 489 * Assume the media is new and give it a chance to 490 * to do a 'load' instruction. 491 */ 492 if ((error = st_load(st, LD_LOAD, 0)) != 0) 493 goto done; 494 495 /* 496 * Throw another dummy instruction to catch 497 * 'Unit attention' errors. Some drives appear to give 498 * these after doing a Load instruction. 499 * (noteably some DAT drives) 500 */ 501 /* XXX */ 502 scsi_test_unit_ready(link, TEST_READY_RETRIES, SCSI_SILENT); 503 504 /* 505 * Some devices can't tell you much until they have been 506 * asked to look at the media. This quirk does this. 507 */ 508 if (ISSET(st->quirks, ST_Q_SENSE_HELP)) 509 if ((error = st_touch_tape(st)) != 0) 510 return error; 511 /* 512 * Load the physical device parameters 513 * loads: blkmin, blkmax 514 */ 515 if (!ISSET(link->flags, SDEV_ATAPI) && 516 (error = st_read_block_limits(st, 0)) != 0) 517 goto done; 518 519 /* 520 * Load the media dependent parameters 521 * includes: media_blksize,media_density 522 * As we have a tape in, it should be reflected here. 523 * If not you may need the "quirk" above. 524 */ 525 if ((error = st_mode_sense(st, 0)) != 0) 526 goto done; 527 528 /* 529 * If we have gained a permanent density from somewhere, 530 * then use it in preference to the one supplied by 531 * default by the driver. 532 */ 533 if (ISSET(st->flags, ST_MODE_DENSITY)) 534 st->density = st->mode.density; 535 else 536 st->density = st->media_density; 537 /* 538 * If we have gained a permanent blocksize 539 * then use it in preference to the one supplied by 540 * default by the driver. 541 */ 542 CLR(st->flags, ST_FIXEDBLOCKS); 543 if (ISSET(st->flags, ST_MODE_BLKSIZE)) { 544 st->blksize = st->mode.blksize; 545 if (st->blksize) 546 SET(st->flags, ST_FIXEDBLOCKS); 547 } else { 548 if ((error = st_decide_mode(st, 0)) != 0) 549 goto done; 550 } 551 if ((error = st_mode_select(st, 0)) != 0) { 552 printf("%s: cannot set selected mode\n", st->sc_dev.dv_xname); 553 goto done; 554 } 555 scsi_prevent(link, PR_PREVENT, 556 SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY); 557 SET(st->flags, ST_MOUNTED); 558 SET(link->flags, SDEV_MEDIA_LOADED); /* move earlier? */ 559 st->media_fileno = 0; 560 st->media_blkno = 0; 561 st->media_eom = -1; 562 563 done: 564 return error; 565 } 566 567 /* 568 * End the present mount session. 569 * Rewind, and optionally eject the tape. 570 * Reset various flags to indicate that all new 571 * operations require another mount operation 572 */ 573 void 574 st_unmount(struct st_softc *st, int eject, int rewind) 575 { 576 struct scsi_link *link = st->sc_link; 577 int nmarks; 578 579 if (eject == NOEJECT && rewind == NOREWIND) { 580 if (ISSET(link->flags, SDEV_MEDIA_LOADED)) 581 return; 582 } 583 584 st->media_fileno = -1; 585 st->media_blkno = -1; 586 587 if (!ISSET(st->flags, ST_MOUNTED)) 588 return; 589 SC_DEBUG(link, SDEV_DB1, ("unmounting\n")); 590 st_check_eod(st, 0, &nmarks, SCSI_IGNORE_NOT_READY); 591 if (rewind == DOREWIND) 592 st_rewind(st, 0, SCSI_IGNORE_NOT_READY); 593 scsi_prevent(link, PR_ALLOW, 594 SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY); 595 if (eject == EJECT) 596 st_load(st, LD_UNLOAD, SCSI_IGNORE_NOT_READY); 597 CLR(st->flags, ST_MOUNTED); 598 CLR(link->flags, SDEV_MEDIA_LOADED); 599 } 600 601 /* 602 * Given all we know about the device, media, mode, 'quirks' and 603 * initial operation, make a decision as to how we should be set 604 * to run (regarding blocking and EOD marks) 605 */ 606 int 607 st_decide_mode(struct st_softc *st, int first_read) 608 { 609 struct scsi_link *link = st->sc_link; 610 611 SC_DEBUG(link, SDEV_DB2, ("starting block mode decision\n")); 612 613 /* ATAPI tapes are always fixed blocksize. */ 614 if (ISSET(link->flags, SDEV_ATAPI)) { 615 SET(st->flags, ST_FIXEDBLOCKS); 616 if (st->media_blksize > 0) 617 st->blksize = st->media_blksize; 618 else 619 st->blksize = DEF_FIXED_BSIZE; 620 goto done; 621 } 622 623 /* 624 * If the drive can only handle fixed-length blocks and only at 625 * one size, perhaps we should just do that. 626 */ 627 if (st->blkmin && (st->blkmin == st->blkmax)) { 628 SET(st->flags, ST_FIXEDBLOCKS); 629 st->blksize = st->blkmin; 630 SC_DEBUG(link, SDEV_DB3, 631 ("blkmin == blkmax of %d\n", st->blkmin)); 632 goto done; 633 } 634 /* 635 * If the tape density mandates (or even suggests) use of fixed 636 * or variable-length blocks, comply. 637 */ 638 switch (st->density) { 639 case HALFINCH_800: 640 case HALFINCH_1600: 641 case HALFINCH_6250: 642 case DDS: 643 CLR(st->flags, ST_FIXEDBLOCKS); 644 st->blksize = 0; 645 SC_DEBUG(link, SDEV_DB3, ("density specified variable\n")); 646 goto done; 647 case QIC_11: 648 case QIC_24: 649 case QIC_120: 650 case QIC_150: 651 case QIC_525: 652 case QIC_1320: 653 SET(st->flags, ST_FIXEDBLOCKS); 654 if (st->media_blksize > 0) 655 st->blksize = st->media_blksize; 656 else 657 st->blksize = DEF_FIXED_BSIZE; 658 SC_DEBUG(link, SDEV_DB3, ("density specified fixed\n")); 659 goto done; 660 } 661 /* 662 * If we're about to read the tape, perhaps we should choose 663 * fixed or variable-length blocks and block size according to 664 * what the drive found on the tape. 665 */ 666 if (first_read) { 667 if (st->media_blksize > 0) 668 SET(st->flags, ST_FIXEDBLOCKS); 669 else 670 CLR(st->flags, ST_FIXEDBLOCKS); 671 st->blksize = st->media_blksize; 672 SC_DEBUG(link, SDEV_DB3, 673 ("Used media_blksize of %d\n", st->media_blksize)); 674 goto done; 675 } 676 /* 677 * We're getting no hints from any direction. Choose variable- 678 * length blocks arbitrarily. 679 */ 680 CLR(st->flags, ST_FIXEDBLOCKS); 681 st->blksize = 0; 682 SC_DEBUG(link, SDEV_DB3, 683 ("Give up and default to variable mode\n")); 684 685 done: 686 /* 687 * Decide whether or not to write two file marks to signify end- 688 * of-data. Make the decision as a function of density. If 689 * the decision is not to use a second file mark, the SCSI BLANK 690 * CHECK condition code will be recognized as end-of-data when 691 * first read. 692 * (I think this should be a by-product of fixed/variable..julian) 693 */ 694 switch (st->density) { 695 /* case 8 mm: What is the SCSI density code for 8 mm, anyway? */ 696 case QIC_11: 697 case QIC_24: 698 case QIC_120: 699 case QIC_150: 700 case QIC_525: 701 case QIC_1320: 702 CLR(st->flags, ST_2FM_AT_EOD); 703 break; 704 default: 705 SET(st->flags, ST_2FM_AT_EOD); 706 } 707 return 0; 708 } 709 710 /* 711 * Actually translate the requested transfer into 712 * one the physical driver can understand 713 * The transfer is described by a buf and will include 714 * only one physical transfer. 715 */ 716 void 717 ststrategy(struct buf *bp) 718 { 719 struct scsi_link *link; 720 struct st_softc *st; 721 int s; 722 723 st = stlookup(STUNIT(bp->b_dev)); 724 if (st == NULL) { 725 bp->b_error = ENXIO; 726 goto bad; 727 } 728 if (ISSET(st->flags, ST_DYING)) { 729 bp->b_error = ENXIO; 730 goto bad; 731 } 732 link = st->sc_link; 733 734 SC_DEBUG(link, SDEV_DB2, ("ststrategy: %ld bytes @ blk %lld\n", 735 bp->b_bcount, (long long)bp->b_blkno)); 736 737 /* 738 * If it's a null transfer, return immediately. 739 */ 740 if (bp->b_bcount == 0) 741 goto done; 742 /* 743 * Odd sized request on fixed drives are verboten 744 */ 745 if (ISSET(st->flags, ST_FIXEDBLOCKS)) { 746 if (bp->b_bcount % st->blksize) { 747 printf("%s: bad request, must be multiple of %d\n", 748 st->sc_dev.dv_xname, st->blksize); 749 bp->b_error = EIO; 750 goto bad; 751 } 752 } 753 /* 754 * as are out-of-range requests on variable drives. 755 */ 756 else if (bp->b_bcount < st->blkmin || 757 (st->blkmax && bp->b_bcount > st->blkmax)) { 758 printf("%s: bad request, must be between %d and %d\n", 759 st->sc_dev.dv_xname, st->blkmin, st->blkmax); 760 bp->b_error = EIO; 761 goto bad; 762 } 763 764 /* 765 * Place it in the queue of activities for this tape 766 * at the end (a bit silly because we only have on user.. 767 * (but it could fork())) 768 */ 769 bufq_queue(&st->sc_bufq, bp); 770 771 /* 772 * Tell the device to get going on the transfer if it's 773 * not doing anything, otherwise just wait for completion 774 * (All a bit silly if we're only allowing 1 open but..) 775 */ 776 scsi_xsh_add(&st->sc_xsh); 777 778 device_unref(&st->sc_dev); 779 return; 780 bad: 781 SET(bp->b_flags, B_ERROR); 782 done: 783 /* Set b_resid to indicate no xfer was done. */ 784 bp->b_resid = bp->b_bcount; 785 s = splbio(); 786 biodone(bp); 787 splx(s); 788 if (st) 789 device_unref(&st->sc_dev); 790 } 791 792 void 793 ststart(struct scsi_xfer *xs) 794 { 795 struct scsi_link *link = xs->sc_link; 796 struct st_softc *st = link->device_softc; 797 struct buf *bp; 798 struct scsi_rw_tape *cmd; 799 int s; 800 801 SC_DEBUG(link, SDEV_DB2, ("ststart\n")); 802 803 if (ISSET(st->flags, ST_DYING)) { 804 scsi_xs_put(xs); 805 return; 806 } 807 808 /* 809 * if the device has been unmounted by the user 810 * then throw away all requests until done 811 */ 812 if (!ISSET(st->flags, ST_MOUNTED) || 813 !ISSET(link->flags, SDEV_MEDIA_LOADED)) { 814 /* make sure that one implies the other.. */ 815 CLR(link->flags, SDEV_MEDIA_LOADED); 816 bufq_drain(&st->sc_bufq); 817 scsi_xs_put(xs); 818 return; 819 } 820 821 for (;;) { 822 bp = bufq_dequeue(&st->sc_bufq); 823 if (bp == NULL) { 824 scsi_xs_put(xs); 825 return; 826 } 827 828 /* 829 * Only FIXEDBLOCK devices have pending I/O or space 830 * operations. 831 */ 832 if (ISSET(st->flags, ST_FIXEDBLOCKS)) { 833 /* 834 * If we are at a filemark but have not reported it yet 835 * then we should report it now 836 */ 837 if (ISSET(st->flags, ST_AT_FILEMARK)) { 838 if ((bp->b_flags & B_READ) == B_WRITE) { 839 /* 840 * Handling of ST_AT_FILEMARK in 841 * st_space will fill in the right file 842 * mark count. 843 * Back up over filemark 844 */ 845 if (st_space(st, 0, SP_FILEMARKS, 0)) { 846 SET(bp->b_flags, B_ERROR); 847 bp->b_resid = bp->b_bcount; 848 bp->b_error = EIO; 849 s = splbio(); 850 biodone(bp); 851 splx(s); 852 continue; 853 } 854 } else { 855 bp->b_resid = bp->b_bcount; 856 bp->b_error = 0; 857 CLR(bp->b_flags, B_ERROR); 858 CLR(st->flags, ST_AT_FILEMARK); 859 s = splbio(); 860 biodone(bp); 861 splx(s); 862 continue; /* seek more work */ 863 } 864 } 865 } 866 867 /* 868 * If we are at EIO or EOM but have not reported it 869 * yet then we should report it now. 870 */ 871 if (ISSET(st->flags, ST_EOM_PENDING | ST_EIO_PENDING)) { 872 bp->b_resid = bp->b_bcount; 873 if (ISSET(st->flags, ST_EIO_PENDING)) { 874 bp->b_error = EIO; 875 SET(bp->b_flags, B_ERROR); 876 } 877 CLR(st->flags, ST_EOM_PENDING | ST_EIO_PENDING); 878 s = splbio(); 879 biodone(bp); 880 splx(s); 881 continue; /* seek more work */ 882 } 883 break; 884 } 885 886 /* 887 * Fill out the scsi command 888 */ 889 cmd = (struct scsi_rw_tape *)&xs->cmd; 890 bzero(cmd, sizeof(*cmd)); 891 if ((bp->b_flags & B_READ) == B_WRITE) { 892 cmd->opcode = WRITE; 893 CLR(st->flags, ST_FM_WRITTEN); 894 SET(st->flags, ST_WRITTEN); 895 SET(xs->flags, SCSI_DATA_OUT); 896 } else { 897 cmd->opcode = READ; 898 SET(xs->flags, SCSI_DATA_IN); 899 } 900 901 /* 902 * Handle "fixed-block-mode" tape drives by using the 903 * block count instead of the length. 904 */ 905 if (ISSET(st->flags, ST_FIXEDBLOCKS)) { 906 SET(cmd->byte2, SRW_FIXED); 907 _lto3b(bp->b_bcount / st->blksize, cmd->len); 908 } else 909 _lto3b(bp->b_bcount, cmd->len); 910 911 if (st->media_blkno != -1) { 912 /* Update block count now, errors will set it to -1. */ 913 if (ISSET(st->flags, ST_FIXEDBLOCKS)) 914 st->media_blkno += _3btol(cmd->len); 915 else if (_3btol(cmd->len) != 0) 916 st->media_blkno++; 917 } 918 919 xs->cmdlen = sizeof(*cmd); 920 xs->timeout = ST_IO_TIME; 921 xs->data = bp->b_data; 922 xs->datalen = bp->b_bcount; 923 xs->done = st_buf_done; 924 xs->cookie = bp; 925 xs->bp = bp; 926 927 /* 928 * go ask the adapter to do all this for us 929 */ 930 scsi_xs_exec(xs); 931 932 /* 933 * should we try do more work now? 934 */ 935 if (bufq_peek(&st->sc_bufq)) 936 scsi_xsh_add(&st->sc_xsh); 937 } 938 939 void 940 st_buf_done(struct scsi_xfer *xs) 941 { 942 struct buf *bp = xs->cookie; 943 int error, s; 944 945 switch (xs->error) { 946 case XS_NOERROR: 947 bp->b_error = 0; 948 CLR(bp->b_flags, B_ERROR); 949 bp->b_resid = xs->resid; 950 break; 951 952 case XS_SENSE: 953 case XS_SHORTSENSE: 954 SC_DEBUG_SENSE(xs); 955 error = st_interpret_sense(xs); 956 if (error == 0) { 957 bp->b_error = 0; 958 CLR(bp->b_flags, B_ERROR); 959 bp->b_resid = xs->resid; 960 break; 961 } 962 if (error != ERESTART) 963 xs->retries = 0; 964 goto retry; 965 966 case XS_BUSY: 967 if (xs->retries) { 968 if (scsi_delay(xs, 1) != ERESTART) 969 xs->retries = 0; 970 } 971 goto retry; 972 973 case XS_TIMEOUT: 974 retry: 975 if (xs->retries--) { 976 scsi_xs_exec(xs); 977 return; 978 } 979 /* FALLTHROUGH */ 980 981 default: 982 bp->b_error = EIO; 983 SET(bp->b_flags, B_ERROR); 984 bp->b_resid = bp->b_bcount; 985 break; 986 } 987 988 s = splbio(); 989 biodone(bp); 990 splx(s); 991 scsi_xs_put(xs); 992 } 993 994 void 995 stminphys(struct buf *bp) 996 { 997 struct scsi_link *link; 998 struct st_softc *sc; 999 1000 sc = stlookup(STUNIT(bp->b_dev)); 1001 if (sc == NULL) 1002 return; 1003 link = sc->sc_link; 1004 1005 if (link->bus->sb_adapter->dev_minphys != NULL) 1006 (*link->bus->sb_adapter->dev_minphys)(bp, link); 1007 else 1008 minphys(bp); 1009 1010 device_unref(&sc->sc_dev); 1011 } 1012 1013 int 1014 stread(dev_t dev, struct uio *uio, int iomode) 1015 { 1016 return physio(ststrategy, dev, B_READ, stminphys, uio); 1017 } 1018 1019 int 1020 stwrite(dev_t dev, struct uio *uio, int iomode) 1021 { 1022 return physio(ststrategy, dev, B_WRITE, stminphys, uio); 1023 } 1024 1025 /* 1026 * Perform special action on behalf of the user; 1027 * knows about the internals of this device 1028 */ 1029 int 1030 stioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) 1031 { 1032 int error = 0; 1033 int nmarks; 1034 int flags = 0; 1035 struct st_softc *st; 1036 int hold_blksize; 1037 u_int8_t hold_density; 1038 struct mtop *mt = (struct mtop *) arg; 1039 int number; 1040 1041 /* 1042 * Find the device that the user is talking about 1043 */ 1044 st = stlookup(STUNIT(dev)); 1045 if (st == NULL) 1046 return ENXIO; 1047 1048 if (ISSET(st->flags, ST_DYING)) { 1049 error = ENXIO; 1050 goto done; 1051 } 1052 1053 hold_blksize = st->blksize; 1054 hold_density = st->density; 1055 1056 switch (cmd) { 1057 1058 case MTIOCGET: { 1059 struct mtget *g = (struct mtget *) arg; 1060 1061 /* 1062 * (to get the current state of READONLY) 1063 */ 1064 error = st_mode_sense(st, SCSI_SILENT); 1065 if (error != 0) 1066 break; 1067 1068 SC_DEBUG(st->sc_link, SDEV_DB1, ("[ioctl: get status]\n")); 1069 bzero(g, sizeof(struct mtget)); 1070 g->mt_type = 0x7; /* Ultrix compat *//*? */ 1071 g->mt_blksiz = st->blksize; 1072 g->mt_density = st->density; 1073 g->mt_mblksiz = st->mode.blksize; 1074 g->mt_mdensity = st->mode.density; 1075 if (ISSET(st->sc_link->flags, SDEV_READONLY)) 1076 SET(g->mt_dsreg, MT_DS_RDONLY); 1077 if (ISSET(st->flags, ST_MOUNTED)) 1078 SET(g->mt_dsreg, MT_DS_MOUNTED); 1079 g->mt_resid = st->mt_resid; 1080 g->mt_erreg = st->mt_erreg; 1081 g->mt_fileno = st->media_fileno; 1082 g->mt_blkno = st->media_blkno; 1083 /* 1084 * clear latched errors. 1085 */ 1086 st->mt_resid = 0; 1087 st->mt_erreg = 0; 1088 break; 1089 } 1090 case MTIOCTOP: { 1091 1092 SC_DEBUG(st->sc_link, SDEV_DB1, 1093 ("[ioctl: op=0x%x count=0x%x]\n", mt->mt_op, mt->mt_count)); 1094 1095 number = mt->mt_count; 1096 switch (mt->mt_op) { 1097 case MTWEOF: /* write an end-of-file record */ 1098 error = st_write_filemarks(st, number, flags); 1099 break; 1100 case MTBSF: /* backward space file */ 1101 number = -number; 1102 case MTFSF: /* forward space file */ 1103 error = st_check_eod(st, 0, &nmarks, flags); 1104 if (error == 0) 1105 error = st_space(st, number - nmarks, 1106 SP_FILEMARKS, flags); 1107 break; 1108 case MTBSR: /* backward space record */ 1109 number = -number; 1110 case MTFSR: /* forward space record */ 1111 error = st_check_eod(st, 1, &nmarks, flags); 1112 if (error == 0) 1113 error = st_space(st, number, SP_BLKS, flags); 1114 break; 1115 case MTREW: /* rewind */ 1116 error = st_rewind(st, 0, flags); 1117 break; 1118 case MTOFFL: /* rewind and put the drive offline */ 1119 st_unmount(st, EJECT, DOREWIND); 1120 break; 1121 case MTNOP: /* no operation, sets status only */ 1122 break; 1123 case MTRETEN: /* retension the tape */ 1124 error = st_load(st, LD_RETENSION, flags); 1125 if (error == 0) 1126 error = st_load(st, LD_LOAD, flags); 1127 break; 1128 case MTEOM: /* forward space to end of media */ 1129 error = st_check_eod(st, 0, &nmarks, flags); 1130 if (error == 0) 1131 error = st_space(st, 1, SP_EOM, flags); 1132 break; 1133 case MTCACHE: /* enable controller cache */ 1134 CLR(st->flags, ST_DONTBUFFER); 1135 goto try_new_value; 1136 case MTNOCACHE: /* disable controller cache */ 1137 SET(st->flags, ST_DONTBUFFER); 1138 goto try_new_value; 1139 case MTERASE: /* erase volume */ 1140 error = st_erase(st, number, flags); 1141 break; 1142 case MTSETBSIZ: /* Set block size for device and mode. */ 1143 if (number == 0) { 1144 CLR(st->flags, ST_FIXEDBLOCKS); 1145 } else { 1146 if ((st->blkmin || st->blkmax) && 1147 (number < st->blkmin || 1148 number > st->blkmax)) { 1149 error = EINVAL; 1150 break; 1151 } 1152 SET(st->flags, ST_FIXEDBLOCKS); 1153 } 1154 st->blksize = number; 1155 goto try_new_value; 1156 1157 case MTSETDNSTY: /* Set density for device and mode. */ 1158 if (number < 0 || number > SCSI_MAX_DENSITY_CODE) { 1159 error = EINVAL; 1160 break; 1161 } 1162 st->density = number; 1163 goto try_new_value; 1164 1165 default: 1166 error = EINVAL; 1167 } 1168 break; 1169 } 1170 case MTIOCIEOT: 1171 case MTIOCEEOT: 1172 break; 1173 1174 #if 0 1175 case MTIOCRDSPOS: 1176 error = st_rdpos(st, 0, (u_int32_t *) arg); 1177 break; 1178 1179 case MTIOCRDHPOS: 1180 error = st_rdpos(st, 1, (u_int32_t *) arg); 1181 break; 1182 1183 case MTIOCSLOCATE: 1184 error = st_setpos(st, 0, (u_int32_t *) arg); 1185 break; 1186 1187 case MTIOCHLOCATE: 1188 error = st_setpos(st, 1, (u_int32_t *) arg); 1189 break; 1190 #endif /* 0 */ 1191 1192 default: 1193 error = scsi_do_ioctl(st->sc_link, cmd, arg, flag); 1194 break; 1195 } 1196 goto done; 1197 1198 try_new_value: 1199 /* 1200 * Check that the mode being asked for is aggreeable to the 1201 * drive. If not, put it back the way it was. 1202 */ 1203 if ((error = st_mode_select(st, 0)) != 0) {/* put it back as it was */ 1204 printf("%s: cannot set selected mode\n", st->sc_dev.dv_xname); 1205 st->density = hold_density; 1206 st->blksize = hold_blksize; 1207 if (st->blksize) 1208 SET(st->flags, ST_FIXEDBLOCKS); 1209 else 1210 CLR(st->flags, ST_FIXEDBLOCKS); 1211 goto done; 1212 } 1213 /* 1214 * As the drive liked it, if we are setting a new default, 1215 * set it into the structures as such. 1216 */ 1217 switch (mt->mt_op) { 1218 case MTSETBSIZ: 1219 st->mode.blksize = st->blksize; 1220 SET(st->flags, ST_MODE_BLKSIZE); 1221 break; 1222 case MTSETDNSTY: 1223 st->mode.density = st->density; 1224 SET(st->flags, ST_MODE_DENSITY); 1225 break; 1226 } 1227 1228 done: 1229 device_unref(&st->sc_dev); 1230 return error; 1231 } 1232 1233 /* 1234 * Do a synchronous read. 1235 */ 1236 int 1237 st_read(struct st_softc *st, char *buf, int size, int flags) 1238 { 1239 struct scsi_rw_tape *cmd; 1240 struct scsi_xfer *xs; 1241 int error; 1242 1243 if (size == 0) 1244 return 0; 1245 1246 xs = scsi_xs_get(st->sc_link, flags | SCSI_DATA_IN); 1247 if (xs == NULL) 1248 return ENOMEM; 1249 xs->cmdlen = sizeof(*cmd); 1250 xs->data = buf; 1251 xs->datalen = size; 1252 xs->retries = 0; 1253 xs->timeout = ST_IO_TIME; 1254 1255 cmd = (struct scsi_rw_tape *)&xs->cmd; 1256 cmd->opcode = READ; 1257 if (ISSET(st->flags, ST_FIXEDBLOCKS)) { 1258 SET(cmd->byte2, SRW_FIXED); 1259 _lto3b(size / (st->blksize ? st->blksize : DEF_FIXED_BSIZE), 1260 cmd->len); 1261 } else 1262 _lto3b(size, cmd->len); 1263 1264 error = scsi_xs_sync(xs); 1265 scsi_xs_put(xs); 1266 1267 return error; 1268 } 1269 1270 /* 1271 * Ask the drive what its min and max blk sizes are. 1272 */ 1273 int 1274 st_read_block_limits(struct st_softc *st, int flags) 1275 { 1276 struct scsi_block_limits_data *block_limits = NULL; 1277 struct scsi_block_limits *cmd; 1278 struct scsi_link *link = st->sc_link; 1279 struct scsi_xfer *xs; 1280 int error = 0; 1281 1282 if (ISSET(link->flags, SDEV_MEDIA_LOADED)) 1283 return 0; 1284 1285 block_limits = dma_alloc(sizeof(*block_limits), PR_NOWAIT); 1286 if (block_limits == NULL) 1287 return ENOMEM; 1288 1289 xs = scsi_xs_get(link, flags | SCSI_DATA_IN); 1290 if (xs == NULL) { 1291 error = ENOMEM; 1292 goto done; 1293 } 1294 1295 xs->cmdlen = sizeof(*cmd); 1296 xs->data = (void *)block_limits; 1297 xs->datalen = sizeof(*block_limits); 1298 xs->timeout = ST_CTL_TIME; 1299 1300 cmd = (struct scsi_block_limits *)&xs->cmd; 1301 cmd->opcode = READ_BLOCK_LIMITS; 1302 1303 error = scsi_xs_sync(xs); 1304 scsi_xs_put(xs); 1305 1306 if (error == 0) { 1307 st->blkmin = _2btol(block_limits->min_length); 1308 st->blkmax = _3btol(block_limits->max_length); 1309 SC_DEBUG(link, SDEV_DB3, 1310 ("(%d <= blksize <= %d)\n", st->blkmin, st->blkmax)); 1311 } 1312 1313 done: 1314 if (block_limits) 1315 dma_free(block_limits, sizeof(*block_limits)); 1316 return error; 1317 } 1318 1319 /* 1320 * Get the scsi driver to send a full inquiry to the 1321 * device and use the results to fill out the global 1322 * parameter structure. 1323 * 1324 * called from: 1325 * attach 1326 * open 1327 * ioctl (to reset original blksize) 1328 */ 1329 int 1330 st_mode_sense(struct st_softc *st, int flags) 1331 { 1332 union scsi_mode_sense_buf *data = NULL; 1333 struct scsi_link *link = st->sc_link; 1334 u_int64_t block_count; 1335 u_int32_t density, block_size; 1336 u_char *page0 = NULL; 1337 u_int8_t dev_spec; 1338 int error = 0, big; 1339 1340 data = dma_alloc(sizeof(*data), PR_NOWAIT); 1341 if (data == NULL) 1342 return ENOMEM; 1343 1344 /* 1345 * Ask for page 0 (vendor specific) mode sense data. 1346 */ 1347 density = 0; 1348 block_count = 0; 1349 block_size = 0; 1350 error = scsi_do_mode_sense(link, 0, data, (void **)&page0, 1, 1351 flags | SCSI_SILENT, &big); 1352 if (error != 0) 1353 goto done; 1354 scsi_parse_blkdesc(link, data, big, &density, &block_count, 1355 &block_size); 1356 1357 /* It is valid for no page0 to be available. */ 1358 1359 if (big) 1360 dev_spec = data->hdr_big.dev_spec; 1361 else 1362 dev_spec = data->hdr.dev_spec; 1363 1364 if (ISSET(dev_spec, SMH_DSP_WRITE_PROT)) 1365 SET(link->flags, SDEV_READONLY); 1366 else 1367 CLR(link->flags, SDEV_READONLY); 1368 1369 st->media_blksize = block_size; 1370 st->media_density = density; 1371 1372 SC_DEBUG(link, SDEV_DB3, 1373 ("density code 0x%x, %d-byte blocks, write-%s, %sbuffered\n", 1374 st->media_density, st->media_blksize, 1375 ISSET(link->flags, SDEV_READONLY) ? "protected" : "enabled", 1376 ISSET(dev_spec, SMH_DSP_BUFF_MODE) ? "" : "un")); 1377 1378 SET(link->flags, SDEV_MEDIA_LOADED); 1379 1380 done: 1381 if (data) 1382 dma_free(data, sizeof(*data)); 1383 return error; 1384 } 1385 1386 /* 1387 * Send a filled out parameter structure to the drive to 1388 * set it into the desire mode etc. 1389 */ 1390 int 1391 st_mode_select(struct st_softc *st, int flags) 1392 { 1393 union scsi_mode_sense_buf *inbuf = NULL, *outbuf = NULL; 1394 struct scsi_blk_desc general; 1395 struct scsi_link *link = st->sc_link; 1396 u_int8_t *page0 = NULL; 1397 int error = 0, big, page0_size; 1398 1399 inbuf = dma_alloc(sizeof(*inbuf), PR_NOWAIT); 1400 if (inbuf == NULL) { 1401 error = ENOMEM; 1402 goto done; 1403 } 1404 outbuf = dma_alloc(sizeof(*outbuf), PR_NOWAIT | PR_ZERO); 1405 if (outbuf == NULL) { 1406 error = ENOMEM; 1407 goto done; 1408 } 1409 1410 /* 1411 * This quirk deals with drives that have only one valid mode and think 1412 * this gives them license to reject all mode selects, even if the 1413 * selected mode is the one that is supported. 1414 */ 1415 if (ISSET(st->quirks, ST_Q_UNIMODAL)) { 1416 SC_DEBUG(link, SDEV_DB3, 1417 ("not setting density 0x%x blksize 0x%x\n", 1418 st->density, st->blksize)); 1419 error = 0; 1420 goto done; 1421 } 1422 1423 if (ISSET(link->flags, SDEV_ATAPI)) { 1424 error = 0; 1425 goto done; 1426 } 1427 1428 bzero(&general, sizeof(general)); 1429 1430 general.density = st->density; 1431 if (ISSET(st->flags, ST_FIXEDBLOCKS)) 1432 _lto3b(st->blksize, general.blklen); 1433 1434 /* 1435 * Ask for page 0 (vendor specific) mode sense data. 1436 * 1437 * page0 == NULL is a valid situation. 1438 */ 1439 error = scsi_do_mode_sense(link, 0, inbuf, (void **)&page0, 1, 1440 flags | SCSI_SILENT, &big); 1441 if (error != 0) 1442 goto done; 1443 1444 if (page0 == NULL) { 1445 page0_size = 0; 1446 } else if (big == 0) { 1447 page0_size = inbuf->hdr.data_length + 1448 sizeof(inbuf->hdr.data_length) - sizeof(inbuf->hdr) - 1449 inbuf->hdr.blk_desc_len; 1450 memcpy(&outbuf->buf[sizeof(outbuf->hdr)+ sizeof(general)], 1451 page0, page0_size); 1452 } else { 1453 page0_size = _2btol(inbuf->hdr_big.data_length) + 1454 sizeof(inbuf->hdr_big.data_length) - 1455 sizeof(inbuf->hdr_big) - 1456 _2btol(inbuf->hdr_big.blk_desc_len); 1457 memcpy(&outbuf->buf[sizeof(outbuf->hdr_big) + sizeof(general)], 1458 page0, page0_size); 1459 } 1460 1461 /* 1462 * Set up for a mode select. 1463 */ 1464 if (big == 0) { 1465 outbuf->hdr.data_length = sizeof(outbuf->hdr) + 1466 sizeof(general) + page0_size - 1467 sizeof(outbuf->hdr.data_length); 1468 if (!ISSET(st->flags, ST_DONTBUFFER)) 1469 outbuf->hdr.dev_spec = SMH_DSP_BUFF_MODE_ON; 1470 outbuf->hdr.blk_desc_len = sizeof(general); 1471 memcpy(&outbuf->buf[sizeof(outbuf->hdr)], 1472 &general, sizeof(general)); 1473 error = scsi_mode_select(st->sc_link, 0, &outbuf->hdr, 1474 flags, ST_CTL_TIME); 1475 goto done; 1476 } 1477 1478 /* MODE SENSE (10) header was returned, so use MODE SELECT (10). */ 1479 _lto2b((sizeof(outbuf->hdr_big) + sizeof(general) + page0_size - 1480 sizeof(outbuf->hdr_big.data_length)), outbuf->hdr_big.data_length); 1481 if (!ISSET(st->flags, ST_DONTBUFFER)) 1482 outbuf->hdr_big.dev_spec = SMH_DSP_BUFF_MODE_ON; 1483 _lto2b(sizeof(general), outbuf->hdr_big.blk_desc_len); 1484 memcpy(&outbuf->buf[sizeof(outbuf->hdr_big)], &general, 1485 sizeof(general)); 1486 1487 error = scsi_mode_select_big(st->sc_link, 0, &outbuf->hdr_big, 1488 flags, ST_CTL_TIME); 1489 done: 1490 if (inbuf) 1491 dma_free(inbuf, sizeof(*inbuf)); 1492 if (outbuf) 1493 dma_free(outbuf, sizeof(*outbuf)); 1494 return error; 1495 } 1496 1497 /* 1498 * issue an erase command 1499 */ 1500 int 1501 st_erase(struct st_softc *st, int full, int flags) 1502 { 1503 struct scsi_erase *cmd; 1504 struct scsi_xfer *xs; 1505 int error; 1506 1507 xs = scsi_xs_get(st->sc_link, flags); 1508 if (xs == NULL) 1509 return ENOMEM; 1510 xs->cmdlen = sizeof(*cmd); 1511 1512 /* 1513 * Full erase means set LONG bit in erase command, which asks 1514 * the drive to erase the entire unit. Without this bit, we're 1515 * asking the drive to write an erase gap. 1516 */ 1517 cmd = (struct scsi_erase *)&xs->cmd; 1518 cmd->opcode = ERASE; 1519 if (full) { 1520 cmd->byte2 = SE_IMMED|SE_LONG; 1521 xs->timeout = ST_SPC_TIME; 1522 } else { 1523 cmd->byte2 = SE_IMMED; 1524 xs->timeout = ST_IO_TIME; 1525 } 1526 1527 /* 1528 * XXX We always do this asynchronously, for now. How long should 1529 * we wait if we want to (eventually) to it synchronously? 1530 */ 1531 error = scsi_xs_sync(xs); 1532 scsi_xs_put(xs); 1533 1534 return error; 1535 } 1536 1537 /* 1538 * skip N blocks/filemarks/seq filemarks/eom 1539 */ 1540 int 1541 st_space(struct st_softc *st, int number, u_int what, int flags) 1542 { 1543 struct scsi_space *cmd; 1544 struct scsi_xfer *xs; 1545 int error; 1546 1547 switch (what) { 1548 case SP_BLKS: 1549 if (ISSET(st->flags, ST_PER_ACTION)) { 1550 if (number > 0) { 1551 CLR(st->flags, ST_PER_ACTION); 1552 return EIO; 1553 } else if (number < 0) { 1554 if (ISSET(st->flags, ST_AT_FILEMARK)) { 1555 /* 1556 * Handling of ST_AT_FILEMARK 1557 * in st_space will fill in the 1558 * right file mark count. 1559 */ 1560 error = st_space(st, 0, SP_FILEMARKS, 1561 flags); 1562 if (error != 0) 1563 return error; 1564 } 1565 if (ISSET(st->flags, ST_BLANK_READ)) { 1566 CLR(st->flags, ST_BLANK_READ); 1567 return EIO; 1568 } 1569 CLR(st->flags, ST_EIO_PENDING | ST_EOM_PENDING); 1570 } 1571 } 1572 break; 1573 case SP_FILEMARKS: 1574 if (ISSET(st->flags, ST_EIO_PENDING)) { 1575 if (number > 0) { 1576 /* pretend we just discovered the error */ 1577 CLR(st->flags, ST_EIO_PENDING); 1578 return EIO; 1579 } else if (number < 0) { 1580 /* back away from the error */ 1581 CLR(st->flags, ST_EIO_PENDING); 1582 } 1583 } 1584 if (ISSET(st->flags, ST_AT_FILEMARK)) { 1585 CLR(st->flags, ST_AT_FILEMARK); 1586 number--; 1587 } 1588 if (ISSET(st->flags, ST_BLANK_READ) && (number < 0)) { 1589 /* back away from unwritten tape */ 1590 CLR(st->flags, ST_BLANK_READ); 1591 number++; /* XXX dubious */ 1592 } 1593 break; 1594 case SP_EOM: 1595 if (ISSET(st->flags, ST_EOM_PENDING)) { 1596 /* We are already there. */ 1597 CLR(st->flags, ST_EOM_PENDING); 1598 return 0; 1599 } 1600 if (ISSET(st->flags, ST_EIO_PENDING)) { 1601 /* pretend we just discovered the error */ 1602 CLR(st->flags, ST_EIO_PENDING); 1603 return EIO; 1604 } 1605 if (ISSET(st->flags, ST_AT_FILEMARK)) 1606 CLR(st->flags, ST_AT_FILEMARK); 1607 break; 1608 } 1609 if (number == 0) 1610 return 0; 1611 1612 xs = scsi_xs_get(st->sc_link, flags); 1613 if (xs == NULL) 1614 return ENOMEM; 1615 1616 cmd = (struct scsi_space *)&xs->cmd; 1617 cmd->opcode = SPACE; 1618 cmd->byte2 = what; 1619 _lto3b(number, cmd->number); 1620 xs->cmdlen = sizeof(*cmd); 1621 xs->timeout = ST_SPC_TIME; 1622 1623 CLR(st->flags, ST_EOD_DETECTED); 1624 1625 error = scsi_xs_sync(xs); 1626 scsi_xs_put(xs); 1627 1628 if (error != 0) { 1629 st->media_fileno = -1; 1630 st->media_blkno = -1; 1631 } else { 1632 switch (what) { 1633 case SP_BLKS: 1634 if (st->media_blkno != -1) { 1635 st->media_blkno += number; 1636 if (st->media_blkno < 0) 1637 st->media_blkno = -1; 1638 } 1639 break; 1640 case SP_FILEMARKS: 1641 if (st->media_fileno != -1) { 1642 if (!ISSET(st->flags, ST_EOD_DETECTED)) 1643 st->media_fileno += number; 1644 if (st->media_fileno > st->media_eom) 1645 st->media_eom = st->media_fileno; 1646 st->media_blkno = 0; 1647 } 1648 break; 1649 case SP_EOM: 1650 if (st->media_eom != -1) { 1651 st->media_fileno = st->media_eom; 1652 st->media_blkno = 0; 1653 } else { 1654 st->media_fileno = -1; 1655 st->media_blkno = -1; 1656 } 1657 break; 1658 default: 1659 st->media_fileno = -1; 1660 st->media_blkno = -1; 1661 break; 1662 } 1663 } 1664 1665 return error; 1666 } 1667 1668 /* 1669 * write N filemarks 1670 */ 1671 int 1672 st_write_filemarks(struct st_softc *st, int number, int flags) 1673 { 1674 struct scsi_write_filemarks *cmd; 1675 struct scsi_xfer *xs; 1676 int error; 1677 1678 if (number < 0) 1679 return EINVAL; 1680 1681 xs = scsi_xs_get(st->sc_link, flags); 1682 if (xs == NULL) 1683 return ENOMEM; 1684 1685 xs->cmdlen = sizeof(*cmd); 1686 xs->timeout = ST_IO_TIME * 4; 1687 1688 switch (number) { 1689 case 0: /* really a command to sync the drive's buffers */ 1690 break; 1691 case 1: 1692 if (ISSET(st->flags, ST_FM_WRITTEN)) /* already have one down */ 1693 CLR(st->flags, ST_WRITTEN); 1694 else 1695 SET(st->flags, ST_FM_WRITTEN); 1696 CLR(st->flags, ST_PER_ACTION); 1697 break; 1698 default: 1699 CLR(st->flags, ST_PER_ACTION | ST_WRITTEN); 1700 break; 1701 } 1702 1703 cmd = (struct scsi_write_filemarks *)&xs->cmd; 1704 cmd->opcode = WRITE_FILEMARKS; 1705 _lto3b(number, cmd->number); 1706 1707 error = scsi_xs_sync(xs); 1708 scsi_xs_put(xs); 1709 1710 if (error != 0) { 1711 st->media_fileno = -1; 1712 st->media_blkno = -1; 1713 st->media_eom = -1; 1714 } else if (st->media_fileno != -1) { 1715 st->media_fileno += number; 1716 st->media_eom = st->media_fileno; 1717 st->media_blkno = 0; 1718 } 1719 1720 return error; 1721 } 1722 1723 /* 1724 * Make sure the right number of file marks is on tape if the 1725 * tape has been written. If the position argument is true, 1726 * leave the tape positioned where it was originally. 1727 * 1728 * nmarks returns the number of marks to skip (or, if position 1729 * true, which were skipped) to get back original position. 1730 */ 1731 int 1732 st_check_eod(struct st_softc *st, int position, int *nmarks, int flags) 1733 { 1734 int error; 1735 1736 switch (st->flags & (ST_WRITTEN | ST_FM_WRITTEN | ST_2FM_AT_EOD)) { 1737 default: 1738 *nmarks = 0; 1739 return 0; 1740 case ST_WRITTEN: 1741 case ST_WRITTEN | ST_FM_WRITTEN | ST_2FM_AT_EOD: 1742 *nmarks = 1; 1743 break; 1744 case ST_WRITTEN | ST_2FM_AT_EOD: 1745 *nmarks = 2; 1746 } 1747 error = st_write_filemarks(st, *nmarks, flags); 1748 if (error == 0 && position != 0) 1749 error = st_space(st, -*nmarks, SP_FILEMARKS, flags); 1750 return error; 1751 } 1752 1753 /* 1754 * load/unload/retension 1755 */ 1756 int 1757 st_load(struct st_softc *st, u_int type, int flags) 1758 { 1759 struct scsi_load *cmd; 1760 struct scsi_xfer *xs; 1761 int error, nmarks; 1762 1763 st->media_fileno = -1; 1764 st->media_blkno = -1; 1765 st->media_eom = -1; 1766 1767 if (type != LD_LOAD) { 1768 error = st_check_eod(st, 0, &nmarks, flags); 1769 if (error != 0) 1770 return error; 1771 } 1772 1773 if (ISSET(st->quirks, ST_Q_IGNORE_LOADS)) { 1774 if (type == LD_LOAD) { 1775 /* 1776 * If we ignore loads, at least we should try a rewind. 1777 */ 1778 return st_rewind(st, 0, flags); 1779 } 1780 return 0; 1781 } 1782 1783 1784 xs = scsi_xs_get(st->sc_link, flags); 1785 if (xs == NULL) 1786 return ENOMEM; 1787 xs->cmdlen = sizeof(*cmd); 1788 xs->timeout = ST_SPC_TIME; 1789 1790 cmd = (struct scsi_load *)&xs->cmd; 1791 cmd->opcode = LOAD; 1792 cmd->how = type; 1793 1794 error = scsi_xs_sync(xs); 1795 scsi_xs_put(xs); 1796 1797 return error; 1798 } 1799 1800 /* 1801 * Rewind the device 1802 */ 1803 int 1804 st_rewind(struct st_softc *st, u_int immediate, int flags) 1805 { 1806 struct scsi_rewind *cmd; 1807 struct scsi_xfer *xs; 1808 int error, nmarks; 1809 1810 error = st_check_eod(st, 0, &nmarks, flags); 1811 if (error != 0) 1812 return error; 1813 CLR(st->flags, ST_PER_ACTION); 1814 1815 xs = scsi_xs_get(st->sc_link, flags); 1816 if (xs == NULL) 1817 return ENOMEM; 1818 xs->cmdlen = sizeof(*cmd); 1819 xs->timeout = immediate ? ST_CTL_TIME : ST_SPC_TIME; 1820 1821 cmd = (struct scsi_rewind *)&xs->cmd; 1822 cmd->opcode = REWIND; 1823 cmd->byte2 = immediate; 1824 1825 error = scsi_xs_sync(xs); 1826 scsi_xs_put(xs); 1827 1828 if (error == 0) { 1829 st->media_fileno = 0; 1830 st->media_blkno = 0; 1831 } 1832 1833 return error; 1834 } 1835 1836 /* 1837 * Look at the returned sense and act on the error and detirmine 1838 * The unix error number to pass back... (0 = report no error) 1839 * (-1 = continue processing) 1840 */ 1841 int 1842 st_interpret_sense(struct scsi_xfer *xs) 1843 { 1844 struct scsi_sense_data *sense = &xs->sense; 1845 struct scsi_link *link = xs->sc_link; 1846 struct scsi_space *space; 1847 struct st_softc *st = link->device_softc; 1848 u_int8_t serr = sense->error_code & SSD_ERRCODE; 1849 u_int8_t skey = sense->flags & SSD_KEY; 1850 int32_t resid, info, number; 1851 int datalen; 1852 1853 if (!ISSET(link->flags, SDEV_OPEN) || 1854 (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED)) 1855 return scsi_interpret_sense(xs); 1856 1857 info = (int32_t)_4btol(sense->info); 1858 1859 switch (skey) { 1860 1861 /* 1862 * We do custom processing in st for the unit becoming ready case. 1863 * in this case we do not allow xs->retries to be decremented 1864 * only on the "Unit Becoming Ready" case. This is because tape 1865 * drives report "Unit Becoming Ready" when loading media, etc. 1866 * and can take a long time. Rather than having a massive timeout 1867 * for all operations (which would cause other problems) we allow 1868 * operations to wait (but be interruptable with Ctrl-C) forever 1869 * as long as the drive is reporting that it is becoming ready. 1870 * all other cases are handled as per the default. 1871 */ 1872 1873 case SKEY_NOT_READY: 1874 if (ISSET(xs->flags, SCSI_IGNORE_NOT_READY)) 1875 return 0; 1876 switch (ASC_ASCQ(sense)) { 1877 case SENSE_NOT_READY_BECOMING_READY: 1878 SC_DEBUG(link, SDEV_DB1, ("not ready: busy (%#x)\n", 1879 sense->add_sense_code_qual)); 1880 /* don't count this as a retry */ 1881 xs->retries++; 1882 return scsi_delay(xs, 1); 1883 default: 1884 return scsi_interpret_sense(xs); 1885 } 1886 break; 1887 case SKEY_BLANK_CHECK: 1888 if (sense->error_code & SSD_ERRCODE_VALID && 1889 xs->cmd.opcode == SPACE) { 1890 switch (ASC_ASCQ(sense)) { 1891 case SENSE_END_OF_DATA_DETECTED: 1892 SET(st->flags, ST_EOD_DETECTED); 1893 space = (struct scsi_space *)&xs->cmd; 1894 number = _3btol(space->number); 1895 st->media_fileno = number - info; 1896 st->media_eom = st->media_fileno; 1897 return 0; 1898 case SENSE_BEGINNING_OF_MEDIUM_DETECTED: 1899 /* Standard says: Position is undefined! */ 1900 SET(st->flags, ST_BOD_DETECTED); 1901 st->media_fileno = -1; 1902 st->media_blkno = -1; 1903 return 0; 1904 } 1905 } 1906 break; 1907 case SKEY_NO_SENSE: 1908 case SKEY_RECOVERED_ERROR: 1909 case SKEY_MEDIUM_ERROR: 1910 case SKEY_VOLUME_OVERFLOW: 1911 break; 1912 default: 1913 return scsi_interpret_sense(xs); 1914 } 1915 1916 /* 1917 * 'resid' can be in units of st->blksize or bytes. xs->resid and 1918 * xs->datalen are always in units of bytes. So we need a variable 1919 * to store datalen in the same units as resid and to adjust 1920 * xs->resid to be in bytes. 1921 */ 1922 if (ISSET(sense->error_code, SSD_ERRCODE_VALID)) { 1923 if (ISSET(st->flags, ST_FIXEDBLOCKS)) 1924 resid = info * st->blksize; /* XXXX overflow? */ 1925 else 1926 resid = info; 1927 } else { 1928 resid = xs->datalen; 1929 } 1930 1931 if (resid < 0 || resid > xs->datalen) 1932 xs->resid = xs->datalen; 1933 else 1934 xs->resid = resid; 1935 1936 datalen = xs->datalen; 1937 if (ISSET(st->flags, ST_FIXEDBLOCKS)) { 1938 resid /= st->blksize; 1939 datalen /= st->blksize; 1940 } 1941 1942 if (ISSET(sense->flags, SSD_FILEMARK)) { 1943 if (st->media_fileno != -1) { 1944 st->media_fileno++; 1945 if (st->media_fileno > st->media_eom) 1946 st->media_eom = st->media_fileno; 1947 st->media_blkno = 0; 1948 } 1949 if (!ISSET(st->flags, ST_FIXEDBLOCKS)) 1950 return 0; 1951 SET(st->flags, ST_AT_FILEMARK); 1952 } 1953 1954 if (ISSET(sense->flags, SSD_EOM)) { 1955 SET(st->flags, ST_EOM_PENDING); 1956 xs->resid = 0; 1957 if (ISSET(st->flags, ST_FIXEDBLOCKS)) 1958 return 0; 1959 } 1960 1961 if (ISSET(sense->flags, SSD_ILI)) { 1962 if (!ISSET(st->flags, ST_FIXEDBLOCKS)) { 1963 if (resid >= 0 && resid <= datalen) 1964 return 0; 1965 if (!ISSET(xs->flags, SCSI_SILENT)) 1966 printf( "%s: bad residual %d out of " 1967 "%d\n", st->sc_dev.dv_xname, resid, 1968 datalen); 1969 return EIO; 1970 } 1971 1972 /* Fixed size blocks. */ 1973 if (ISSET(sense->error_code, SSD_ERRCODE_VALID)) 1974 if (!ISSET(xs->flags, SCSI_SILENT)) 1975 printf("%s: block wrong size, %d blocks " 1976 "residual\n", st->sc_dev.dv_xname, resid); 1977 SET(st->flags, ST_EIO_PENDING); 1978 /* 1979 * This quirk code helps the drive read the first tape block, 1980 * regardless of format. That is required for these drives to 1981 * return proper MODE SENSE information. 1982 */ 1983 if (ISSET(st->quirks, ST_Q_SENSE_HELP) && 1984 !ISSET(link->flags, SDEV_MEDIA_LOADED)) 1985 st->blksize -= 512; 1986 } 1987 1988 if (ISSET(st->flags, ST_FIXEDBLOCKS) && xs->resid == xs->datalen) { 1989 if (ISSET(st->flags, ST_EIO_PENDING)) 1990 return EIO; 1991 if (ISSET(st->flags, ST_AT_FILEMARK)) 1992 return 0; 1993 } 1994 1995 if (skey == SKEY_BLANK_CHECK) { 1996 /* 1997 * This quirk code helps the drive read the first tape block, 1998 * regardless of format. That is required for these drives to 1999 * return proper MODE SENSE information. 2000 */ 2001 if (ISSET(st->quirks, ST_Q_SENSE_HELP) && 2002 !ISSET(link->flags, SDEV_MEDIA_LOADED)) { 2003 /* still starting */ 2004 st->blksize -= 512; 2005 } else if (!ISSET(st->flags, ST_2FM_AT_EOD | ST_BLANK_READ)) { 2006 SET(st->flags, ST_BLANK_READ); 2007 SET(st->flags, ST_EOM_PENDING); 2008 xs->resid = xs->datalen; 2009 return 0; 2010 } 2011 } 2012 2013 return scsi_interpret_sense(xs); 2014 } 2015 2016 /* 2017 * The quirk here is that the drive returns some value to st_mode_sense 2018 * incorrectly until the tape has actually passed by the head. 2019 * 2020 * The method is to set the drive to large fixed-block state (user-specified 2021 * density and 1024-byte blocks), then read and rewind to get it to sense the 2022 * tape. If that doesn't work, try 512-byte fixed blocks. If that doesn't 2023 * work, as a last resort, try variable- length blocks. The result will be 2024 * the ability to do an accurate st_mode_sense. 2025 * 2026 * We know we can do a rewind because we just did a load, which implies rewind. 2027 * Rewind seems preferable to space backward if we have a virgin tape. 2028 * 2029 * The rest of the code for this quirk is in ILI processing and BLANK CHECK 2030 * error processing, both part of st_interpret_sense. 2031 */ 2032 int 2033 st_touch_tape(struct st_softc *st) 2034 { 2035 char *buf = NULL; 2036 int readsize, maxblksize = 1024; 2037 int error = 0; 2038 2039 if ((error = st_mode_sense(st, 0)) != 0) 2040 goto done; 2041 buf = dma_alloc(maxblksize, PR_NOWAIT); 2042 if (buf == NULL) { 2043 error = ENOMEM; 2044 goto done; 2045 } 2046 2047 st->blksize = 1024; 2048 do { 2049 switch (st->blksize) { 2050 case 512: 2051 case 1024: 2052 readsize = st->blksize; 2053 SET(st->flags, ST_FIXEDBLOCKS); 2054 break; 2055 default: 2056 readsize = 1; 2057 CLR(st->flags, ST_FIXEDBLOCKS); 2058 } 2059 if ((error = st_mode_select(st, 0)) != 0) 2060 goto done; 2061 st_read(st, buf, readsize, SCSI_SILENT); /* XXX */ 2062 if ((error = st_rewind(st, 0, 0)) != 0) 2063 goto done; 2064 } while (readsize != 1 && readsize > st->blksize); 2065 done: 2066 dma_free(buf, maxblksize); 2067 return error; 2068 } 2069