sys/bus/cam/scsi/scsi_sa.c

   1 /*
   2  * $FreeBSD: src/sys/cam/scsi/scsi_sa.c,v 1.45.2.13 2002/12/17 17:08:50 trhodes Exp $
   3  * $DragonFly: src/sys/bus/cam/scsi/scsi_sa.c,v 1.12 2004/05/19 22:52:38 dillon Exp $
   4  *
   5  * Implementation of SCSI Sequential Access Peripheral driver for CAM.
   6  *
   7  * Copyright (c) 1999, 2000 Matthew Jacob
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions, and the following disclaimer,
  15  *    without modification, immediately at the beginning of the file.
  16  * 2. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  23  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/queue.h>
  35 #ifdef _KERNEL
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #endif
  39 #include <sys/types.h>
  40 #ifdef _KERNEL
  41 #include <sys/buf.h>
  42 #include <sys/malloc.h>
  43 #endif
  44 #include <sys/mtio.h>
  45 #include <sys/conf.h>
  46 #ifdef _KERNEL
  47 #include <sys/proc.h>
  48 #include <sys/buf2.h>
  49 #endif
  50 #include <sys/devicestat.h>
  51 #include <machine/limits.h>
  52
  53 #ifndef _KERNEL
  54 #include <stdio.h>
  55 #include <string.h>
  56 #endif
  57
  58 #include "../cam.h"
  59 #include "../cam_ccb.h"
  60 #include "../cam_extend.h"
  61 #include "../cam_periph.h"
  62 #include "../cam_xpt_periph.h"
  63 #include "../cam_debug.h"
  64
  65 #include "scsi_all.h"
  66 #include "scsi_message.h"
  67 #include "scsi_sa.h"
  68
  69 #ifdef _KERNEL
  70
  71 #include <opt_sa.h>
  72
  73 #ifndef SA_IO_TIMEOUT
  74 #define SA_IO_TIMEOUT           4
  75 #endif
  76 #ifndef SA_SPACE_TIMEOUT
  77 #define SA_SPACE_TIMEOUT        1 * 60
  78 #endif
  79 #ifndef SA_REWIND_TIMEOUT
  80 #define SA_REWIND_TIMEOUT       2 * 60
  81 #endif
  82 #ifndef SA_ERASE_TIMEOUT
  83 #define SA_ERASE_TIMEOUT        4 * 60
  84 #endif
  85
  86 #define SCSIOP_TIMEOUT          (60 * 1000)     /* not an option */
  87
  88 #define IO_TIMEOUT              (SA_IO_TIMEOUT * 60 * 1000)
  89 #define REWIND_TIMEOUT          (SA_REWIND_TIMEOUT * 60 * 1000)
  90 #define ERASE_TIMEOUT           (SA_ERASE_TIMEOUT * 60 * 1000)
  91 #define SPACE_TIMEOUT           (SA_SPACE_TIMEOUT * 60 * 1000)
  92
  93 /*
  94  * Additional options that can be set for config: SA_1FM_AT_EOT
  95  */
  96
  97 #ifndef UNUSED_PARAMETER
  98 #define UNUSED_PARAMETER(x)     x = x
  99 #endif
 100
 101 #define QFRLS(ccb)      \
 102         if (((ccb)->ccb_h.status & CAM_DEV_QFRZN) != 0) \
 103                 cam_release_devq((ccb)->ccb_h.path, 0, 0, 0, FALSE)
 104
 105 /*
 106  * Driver states
 107  */
 108
 109
 110 typedef enum {
 111         SA_STATE_NORMAL, SA_STATE_ABNORMAL
 112 } sa_state;
 113
 114 #define ccb_pflags      ppriv_field0
 115 #define ccb_bp          ppriv_ptr1
 116
 117 #define SA_CCB_BUFFER_IO        0x0
 118 #define SA_CCB_WAITING          0x1
 119 #define SA_CCB_TYPEMASK         0x1
 120 #define SA_POSITION_UPDATED     0x2
 121
 122 #define Set_CCB_Type(x, type)                           \
 123         x->ccb_h.ccb_pflags &= ~SA_CCB_TYPEMASK;        \
 124         x->ccb_h.ccb_pflags |= type
 125
 126 #define CCB_Type(x)     (x->ccb_h.ccb_pflags & SA_CCB_TYPEMASK)
 127
 128
 129
 130 typedef enum {
 131         SA_FLAG_OPEN            = 0x0001,
 132         SA_FLAG_FIXED           = 0x0002,
 133         SA_FLAG_TAPE_LOCKED     = 0x0004,
 134         SA_FLAG_TAPE_MOUNTED    = 0x0008,
 135         SA_FLAG_TAPE_WP         = 0x0010,
 136         SA_FLAG_TAPE_WRITTEN    = 0x0020,
 137         SA_FLAG_EOM_PENDING     = 0x0040,
 138         SA_FLAG_EIO_PENDING     = 0x0080,
 139         SA_FLAG_EOF_PENDING     = 0x0100,
 140         SA_FLAG_ERR_PENDING     = (SA_FLAG_EOM_PENDING|SA_FLAG_EIO_PENDING|
 141                                    SA_FLAG_EOF_PENDING),
 142         SA_FLAG_INVALID         = 0x0200,
 143         SA_FLAG_COMP_ENABLED    = 0x0400,
 144         SA_FLAG_COMP_SUPP       = 0x0800,
 145         SA_FLAG_COMP_UNSUPP     = 0x1000,
 146         SA_FLAG_TAPE_FROZEN     = 0x2000
 147 } sa_flags;
 148
 149 typedef enum {
 150         SA_MODE_REWIND          = 0x00,
 151         SA_MODE_NOREWIND        = 0x01,
 152         SA_MODE_OFFLINE         = 0x02
 153 } sa_mode;
 154
 155 typedef enum {
 156         SA_PARAM_NONE           = 0x00,
 157         SA_PARAM_BLOCKSIZE      = 0x01,
 158         SA_PARAM_DENSITY        = 0x02,
 159         SA_PARAM_COMPRESSION    = 0x04,
 160         SA_PARAM_BUFF_MODE      = 0x08,
 161         SA_PARAM_NUMBLOCKS      = 0x10,
 162         SA_PARAM_WP             = 0x20,
 163         SA_PARAM_SPEED          = 0x40,
 164         SA_PARAM_ALL            = 0x7f
 165 } sa_params;
 166
 167 typedef enum {
 168         SA_QUIRK_NONE           = 0x00,
 169         SA_QUIRK_NOCOMP         = 0x01, /* Can't deal with compression at all */
 170         SA_QUIRK_FIXED          = 0x02, /* Force fixed mode */
 171         SA_QUIRK_VARIABLE       = 0x04, /* Force variable mode */
 172         SA_QUIRK_2FM            = 0x08, /* Needs Two File Marks at EOD */
 173         SA_QUIRK_1FM            = 0x10, /* No more than 1 File Mark at EOD */
 174         SA_QUIRK_NODREAD        = 0x20, /* Don't try and dummy read density */
 175         SA_QUIRK_NO_MODESEL     = 0x40, /* Don't do mode select at all */
 176         SA_QUIRK_NO_CPAGE       = 0x80  /* Don't use DEVICE COMPRESSION page */
 177 } sa_quirks;
 178
 179 /* units are bits 4-7, 16-21 (1024 units) */
 180 #define SAUNIT(DEV) \
 181         (((minor(DEV) & 0xF0) >> 4) |  ((minor(DEV) & 0x3f0000) >> 16))
 182
 183 #define SAMODE(z) ((minor(z) & 0x3))
 184 #define SADENSITY(z) (((minor(z) >> 2) & 0x3))
 185 #define SA_IS_CTRL(z) (minor(z) & (1 << 29))
 186
 187 #define SA_NOT_CTLDEV   0
 188 #define SA_CTLDEV       1
 189
 190 #define SA_ATYPE_R      0
 191 #define SA_ATYPE_NR     1
 192 #define SA_ATYPE_ER     2
 193
 194 #define SAMINOR(ctl, unit, mode, access) \
 195         ((ctl << 29) | ((unit & 0x3f0) << 16) | ((unit & 0xf) << 4) | \
 196         (mode << 0x2) | (access & 0x3))
 197
 198 #define SA_UNITMASK     SAMINOR(0, -1, 0, 0)
 199 #define SA_UNIT(unit)   SAMINOR(0, unit, 0, 0)
 200
 201 #define SA_NUM_MODES    4
 202
 203 struct sa_softc {
 204         sa_state        state;
 205         sa_flags        flags;
 206         sa_quirks       quirks;
 207         struct          buf_queue_head buf_queue;
 208         int             queue_count;
 209         struct          devstat device_stats;
 210         int             blk_gran;
 211         int             blk_mask;
 212         int             blk_shift;
 213         u_int32_t       max_blk;
 214         u_int32_t       min_blk;
 215         u_int32_t       comp_algorithm;
 216         u_int32_t       saved_comp_algorithm;
 217         u_int32_t       media_blksize;
 218         u_int32_t       last_media_blksize;
 219         u_int32_t       media_numblks;
 220         u_int8_t        media_density;
 221         u_int8_t        speed;
 222         u_int8_t        scsi_rev;
 223         u_int8_t        dsreg;          /* mtio mt_dsreg, redux */
 224         int             buffer_mode;
 225         int             filemarks;
 226         union           ccb saved_ccb;
 227         int             last_resid_was_io;
 228
 229         /*
 230          * Relative to BOT Location.
 231          */
 232         daddr_t         fileno;
 233         daddr_t         blkno;
 234
 235         /*
 236          * Latched Error Info
 237          */
 238         struct {
 239                 struct scsi_sense_data _last_io_sense;
 240                 u_int32_t _last_io_resid;
 241                 u_int8_t _last_io_cdb[CAM_MAX_CDBLEN];
 242                 struct scsi_sense_data _last_ctl_sense;
 243                 u_int32_t _last_ctl_resid;
 244                 u_int8_t _last_ctl_cdb[CAM_MAX_CDBLEN];
 245 #define last_io_sense   errinfo._last_io_sense
 246 #define last_io_resid   errinfo._last_io_resid
 247 #define last_io_cdb     errinfo._last_io_cdb
 248 #define last_ctl_sense  errinfo._last_ctl_sense
 249 #define last_ctl_resid  errinfo._last_ctl_resid
 250 #define last_ctl_cdb    errinfo._last_ctl_cdb
 251         } errinfo;
 252         /*
 253          * Misc other flags/state
 254          */
 255         u_int32_t
 256                                 : 31,
 257                 ctrl_mode       : 1;    /* control device open */
 258 };
 259
 260 struct sa_quirk_entry {
 261         struct scsi_inquiry_pattern inq_pat;    /* matching pattern */
 262         sa_quirks quirks;       /* specific quirk type */
 263         u_int32_t prefblk;      /* preferred blocksize when in fixed mode */
 264 };
 265
 266 static struct sa_quirk_entry sa_quirk_table[] =
 267 {
 268         {
 269                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "OnStream",
 270                   "ADR*", "*"}, SA_QUIRK_FIXED|SA_QUIRK_NODREAD |
 271                    SA_QUIRK_1FM|SA_QUIRK_NO_MODESEL, 32768
 272         },
 273         {
 274                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "ARCHIVE",
 275                   "Python 06408*", "*"}, SA_QUIRK_NODREAD, 0
 276         },
 277         {
 278                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "ARCHIVE",
 279                   "Python 25601*", "*"}, SA_QUIRK_NOCOMP|SA_QUIRK_NODREAD, 0
 280         },
 281         {
 282                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "ARCHIVE",
 283                   "Python*", "*"}, SA_QUIRK_NODREAD, 0
 284         },
 285         {
 286                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "ARCHIVE",
 287                   "VIPER 150*", "*"}, SA_QUIRK_FIXED|SA_QUIRK_1FM, 512
 288         },
 289         {
 290                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "ARCHIVE",
 291                   "VIPER 2525 25462", "-011"},
 292                   SA_QUIRK_NOCOMP|SA_QUIRK_1FM|SA_QUIRK_NODREAD, 0
 293         },
 294         {
 295                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "ARCHIVE",
 296                   "VIPER 2525*", "*"}, SA_QUIRK_FIXED|SA_QUIRK_1FM, 1024
 297         },
 298 #if     0
 299         {
 300                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "HP",
 301                   "C15*", "*"}, SA_QUIRK_VARIABLE|SA_QUIRK_NO_CPAGE, 0,
 302         },
 303 #endif
 304         {
 305                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "HP",
 306                   "C56*", "*"}, SA_QUIRK_VARIABLE|SA_QUIRK_2FM, 0
 307         },
 308         {
 309                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "HP",
 310                   "T20*", "*"}, SA_QUIRK_FIXED|SA_QUIRK_1FM, 512
 311         },
 312         {
 313                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "HP",
 314                   "T4000*", "*"}, SA_QUIRK_FIXED|SA_QUIRK_1FM, 512
 315         },
 316         {
 317                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "HP",
 318                   "HP-88780*", "*"}, SA_QUIRK_VARIABLE|SA_QUIRK_2FM, 0
 319         },
 320         {
 321                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "KENNEDY",
 322                   "*", "*"}, SA_QUIRK_VARIABLE|SA_QUIRK_2FM, 0
 323         },
 324         {
 325                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "M4 DATA",
 326                   "123107 SCSI*", "*"}, SA_QUIRK_VARIABLE|SA_QUIRK_2FM, 0
 327         },
 328         {       /* jreynold@primenet.com */
 329                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "Seagate",
 330                 "STT8000N*", "*"}, SA_QUIRK_1FM, 0
 331         },
 332         {       /* mike@sentex.net */
 333                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "Seagate",
 334                 "STT20000*", "*"}, SA_QUIRK_1FM, 0
 335         },
 336         {
 337                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "TANDBERG",
 338                   " TDC 3600", "U07:"}, SA_QUIRK_NOCOMP|SA_QUIRK_1FM, 512
 339         },
 340         {
 341                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "TANDBERG",
 342                   " TDC 3800", "*"}, SA_QUIRK_NOCOMP|SA_QUIRK_1FM, 512
 343         },
 344         {
 345                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "TANDBERG",
 346                   " TDC 4100", "*"}, SA_QUIRK_NOCOMP|SA_QUIRK_1FM, 512
 347         },
 348         {
 349                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "TANDBERG",
 350                   " TDC 4200", "*"}, SA_QUIRK_NOCOMP|SA_QUIRK_1FM, 512
 351         },
 352         {
 353                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "TANDBERG",
 354                   " SLR*", "*"}, SA_QUIRK_1FM, 0
 355         },
 356         {
 357                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "WANGTEK",
 358                   "5525ES*", "*"}, SA_QUIRK_FIXED|SA_QUIRK_1FM, 512
 359         },
 360         {
 361                 { T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "WANGTEK",
 362                   "51000*", "*"}, SA_QUIRK_FIXED|SA_QUIRK_1FM, 1024
 363         }
 364 };
 365
 366 static  d_open_t        saopen;
 367 static  d_close_t       saclose;
 368 static  d_strategy_t    sastrategy;
 369 static  d_ioctl_t       saioctl;
 370 static  periph_init_t   sainit;
 371 static  periph_ctor_t   saregister;
 372 static  periph_oninv_t  saoninvalidate;
 373 static  periph_dtor_t   sacleanup;
 374 static  periph_start_t  sastart;
 375 static  void            saasync(void *callback_arg, u_int32_t code,
 376                                 struct cam_path *path, void *arg);
 377 static  void            sadone(struct cam_periph *periph,
 378                                union ccb *start_ccb);
 379 static  int             saerror(union ccb *ccb, u_int32_t cam_flags,
 380                                 u_int32_t sense_flags);
 381 static int              samarkswanted(struct cam_periph *);
 382 static int              sacheckeod(struct cam_periph *periph);
 383 static int              sagetparams(struct cam_periph *periph,
 384                                     sa_params params_to_get,
 385                                     u_int32_t *blocksize, u_int8_t *density,
 386                                     u_int32_t *numblocks, int *buff_mode,
 387                                     u_int8_t *write_protect, u_int8_t *speed,
 388                                     int *comp_supported, int *comp_enabled,
 389                                     u_int32_t *comp_algorithm,
 390                                     sa_comp_t *comp_page);
 391 static int              sasetparams(struct cam_periph *periph,
 392                                     sa_params params_to_set,
 393                                     u_int32_t blocksize, u_int8_t density,
 394                                     u_int32_t comp_algorithm,
 395                                     u_int32_t sense_flags);
 396 static void             saprevent(struct cam_periph *periph, int action);
 397 static int              sarewind(struct cam_periph *periph);
 398 static int              saspace(struct cam_periph *periph, int count,
 399                                 scsi_space_code code);
 400 static int              samount(struct cam_periph *, int, dev_t);
 401 static int              saretension(struct cam_periph *periph);
 402 static int              sareservereleaseunit(struct cam_periph *periph,
 403                                              int reserve);
 404 static int              saloadunload(struct cam_periph *periph, int load);
 405 static int              saerase(struct cam_periph *periph, int longerase);
 406 static int              sawritefilemarks(struct cam_periph *periph,
 407                                          int nmarks, int setmarks);
 408 static int              sardpos(struct cam_periph *periph, int, u_int32_t *);
 409 static int              sasetpos(struct cam_periph *periph, int, u_int32_t *);
 410
 411
 412 static struct periph_driver sadriver =
 413 {
 414         sainit, "sa",
 415         TAILQ_HEAD_INITIALIZER(sadriver.units), /* generation */ 0
 416 };
 417
 418 DATA_SET(periphdriver_set, sadriver);
 419
 420 /* For 2.2-stable support */
 421 #ifndef D_TAPE
 422 #define D_TAPE 0
 423 #endif
 424
 425 #define SA_CDEV_MAJOR 14
 426
 427 static struct cdevsw sa_cdevsw = {
 428         /* name */      "sa",
 429         /* maj */       SA_CDEV_MAJOR,
 430         /* flags */     D_TAPE,
 431         /* port */      NULL,
 432         /* clone */     NULL,
 433
 434         /* open */      saopen,
 435         /* close */     saclose,
 436         /* read */      physread,
 437         /* write */     physwrite,
 438         /* ioctl */     saioctl,
 439         /* poll */      nopoll,
 440         /* mmap */      nommap,
 441         /* strategy */  sastrategy,
 442         /* dump */      nodump,
 443         /* psize */     nopsize
 444 };
 445
 446 static struct extend_array *saperiphs;
 447
 448 static int
 449 saopen(dev_t dev, int flags, int fmt, struct thread *td)
 450 {
 451         struct cam_periph *periph;
 452         struct sa_softc *softc;
 453         int unit;
 454         int mode;
 455         int density;
 456         int error;
 457         int s;
 458
 459         unit = SAUNIT(dev);
 460         mode = SAMODE(dev);
 461         density = SADENSITY(dev);
 462
 463         s = splsoftcam();
 464         periph = cam_extend_get(saperiphs, unit);
 465         if (periph == NULL) {
 466                 (void) splx(s);
 467                 return (ENXIO);
 468         }
 469         softc = (struct sa_softc *)periph->softc;
 470         if ((error = cam_periph_lock(periph, PCATCH)) != 0) {
 471                 splx(s);
 472                 return (error);
 473         }
 474         splx(s);
 475
 476         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE|CAM_DEBUG_INFO,
 477             ("saopen(%d): dev=0x%x softc=0x%x\n", unit, unit, softc->flags));
 478
 479         if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
 480                 cam_periph_unlock(periph);
 481                 return (ENXIO);
 482         }
 483         if (SA_IS_CTRL(dev)) {
 484                 softc->ctrl_mode = 1;
 485                 cam_periph_unlock(periph);
 486                 return (0);
 487         }
 488
 489
 490         if (softc->flags & SA_FLAG_OPEN) {
 491                 error = EBUSY;
 492         } else if (softc->flags & SA_FLAG_INVALID) {
 493                 error = ENXIO;
 494         } else {
 495                 /*
 496                  * The function samount ensures media is loaded and ready.
 497                  * It also does a device RESERVE if the tape isn't yet mounted.
 498                  */
 499                 error = samount(periph, flags, dev);
 500         }
 501
 502         if (error) {
 503                 cam_periph_release(periph);
 504         } else {
 505                 saprevent(periph, PR_PREVENT);
 506                 softc->flags |= SA_FLAG_OPEN;
 507         }
 508         cam_periph_unlock(periph);
 509         return (error);
 510 }
 511
 512 static int
 513 saclose(dev_t dev, int flag, int fmt, struct thread *td)
 514 {
 515         struct  cam_periph *periph;
 516         struct  sa_softc *softc;
 517         int     unit, mode, error, writing, tmp;
 518         int     closedbits = SA_FLAG_OPEN;
 519
 520         unit = SAUNIT(dev);
 521         mode = SAMODE(dev);
 522         periph = cam_extend_get(saperiphs, unit);
 523         if (periph == NULL)
 524                 return (ENXIO);
 525
 526         softc = (struct sa_softc *)periph->softc;
 527
 528         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE|CAM_DEBUG_INFO,
 529             ("saclose(%d): dev=0x%x softc=0x%x\n", unit, unit, softc->flags));
 530
 531
 532         if ((error = cam_periph_lock(periph, 0)) != 0) {
 533                 return (error);
 534         }
 535
 536         if (SA_IS_CTRL(dev)) {
 537                 softc->ctrl_mode = 0;
 538                 cam_periph_release(periph);
 539                 cam_periph_unlock(periph);
 540                 return (0);
 541         }
 542
 543         /*
 544          * Were we writing the tape?
 545          */
 546         writing = (softc->flags & SA_FLAG_TAPE_WRITTEN) != 0;
 547
 548         /*
 549          * See whether or not we need to write filemarks. If this
 550          * fails, we probably have to assume we've lost tape
 551          * position.
 552          */
 553         error = sacheckeod(periph);
 554         if (error) {
 555                 xpt_print_path(periph->path);
 556                 printf("failed to write terminating filemark(s)\n");
 557                 softc->flags |= SA_FLAG_TAPE_FROZEN;
 558         }
 559
 560         /*
 561          * Whatever we end up doing, allow users to eject tapes from here on.
 562          */
 563         saprevent(periph, PR_ALLOW);
 564
 565         /*
 566          * Decide how to end...
 567          */
 568         if ((softc->flags & SA_FLAG_TAPE_MOUNTED) == 0) {
 569                 closedbits |= SA_FLAG_TAPE_FROZEN;
 570         } else switch (mode) {
 571         case SA_MODE_OFFLINE:
 572                 /*
 573                  * An 'offline' close is an unconditional release of
 574                  * frozen && mount conditions, irrespective of whether
 575                  * these operations succeeded. The reason for this is
 576                  * to allow at least some kind of programmatic way
 577                  * around our state getting all fouled up. If somebody
 578                  * issues an 'offline' command, that will be allowed
 579                  * to clear state.
 580                  */
 581                 (void) sarewind(periph);
 582                 (void) saloadunload(periph, FALSE);
 583                 closedbits |= SA_FLAG_TAPE_MOUNTED|SA_FLAG_TAPE_FROZEN;
 584                 break;
 585         case SA_MODE_REWIND:
 586                 /*
 587                  * If the rewind fails, return an error- if anyone cares,
 588                  * but not overwriting any previous error.
 589                  *
 590                  * We don't clear the notion of mounted here, but we do
 591                  * clear the notion of frozen if we successfully rewound.
 592                  */
 593                 tmp = sarewind(periph);
 594                 if (tmp) {
 595                         if (error != 0)
 596                                 error = tmp;
 597                 } else {
 598                         closedbits |= SA_FLAG_TAPE_FROZEN;
 599                 }
 600                 break;
 601         case SA_MODE_NOREWIND:
 602                 /*
 603                  * If we're not rewinding/unloading the tape, find out
 604                  * whether we need to back up over one of two filemarks
 605                  * we wrote (if we wrote two filemarks) so that appends
 606                  * from this point on will be sane.
 607                  */
 608                 if (error == 0 && writing && (softc->quirks & SA_QUIRK_2FM)) {
 609                         tmp = saspace(periph, -1, SS_FILEMARKS);
 610                         if (tmp) {
 611                                 xpt_print_path(periph->path);
 612                                 printf("unable to backspace over one of double"
 613                                    " filemarks at end of tape\n");
 614                                 xpt_print_path(periph->path);
 615                                 printf("it is possible that this device"
 616                                    " needs a SA_QUIRK_1FM quirk set for it\n");
 617                                 softc->flags |= SA_FLAG_TAPE_FROZEN;
 618                         }
 619                 }
 620                 break;
 621         default:
 622                 xpt_print_path(periph->path);
 623                 panic("unknown mode 0x%x in saclose\n", mode);
 624                 /* NOTREACHED */
 625                 break;
 626         }
 627
 628         /*
 629          * We wish to note here that there are no more filemarks to be written.
 630          */
 631         softc->filemarks = 0;
 632         softc->flags &= ~SA_FLAG_TAPE_WRITTEN;
 633
 634         /*
 635          * And we are no longer open for business.
 636          */
 637         softc->flags &= ~closedbits;
 638
 639         /*
 640          * Inform users if tape state if frozen....
 641          */
 642         if (softc->flags & SA_FLAG_TAPE_FROZEN) {
 643                 xpt_print_path(periph->path);
 644                 printf("tape is now frozen- use an OFFLINE, REWIND or MTEOM "
 645                     "command to clear this state.\n");
 646         }
 647
 648         /* release the device if it is no longer mounted */
 649         if ((softc->flags & SA_FLAG_TAPE_MOUNTED) == 0)
 650                 sareservereleaseunit(periph, FALSE);
 651
 652         cam_periph_unlock(periph);
 653         cam_periph_release(periph);
 654
 655         return (error);
 656 }
 657
 658 /*
 659  * Actually translate the requested transfer into one the physical driver
 660  * can understand.  The transfer is described by a buf and will include
 661  * only one physical transfer.
 662  */
 663 static void
 664 sastrategy(struct buf *bp)
 665 {
 666         struct cam_periph *periph;
 667         struct sa_softc *softc;
 668         u_int  unit;
 669         int    s;
 670
 671         if (SA_IS_CTRL(bp->b_dev)) {
 672                 bp->b_error = EINVAL;
 673                 goto bad;
 674         }
 675         unit = SAUNIT(bp->b_dev);
 676         periph = cam_extend_get(saperiphs, unit);
 677         if (periph == NULL) {
 678                 bp->b_error = ENXIO;
 679                 goto bad;
 680         }
 681         softc = (struct sa_softc *)periph->softc;
 682
 683         s = splsoftcam();
 684
 685         if (softc->flags & SA_FLAG_INVALID) {
 686                 splx(s);
 687                 bp->b_error = ENXIO;
 688                 goto bad;
 689         }
 690
 691         if (softc->flags & SA_FLAG_TAPE_FROZEN) {
 692                 splx(s);
 693                 bp->b_error = EPERM;
 694                 goto bad;
 695         }
 696
 697         splx(s);
 698
 699         /*
 700          * If it's a null transfer, return immediatly
 701          */
 702         if (bp->b_bcount == 0)
 703                 goto done;
 704
 705         /* valid request?  */
 706         if (softc->flags & SA_FLAG_FIXED) {
 707                 /*
 708                  * Fixed block device.  The byte count must
 709                  * be a multiple of our block size.
 710                  */
 711                 if (((softc->blk_mask != ~0) &&
 712                     ((bp->b_bcount & softc->blk_mask) != 0)) ||
 713                     ((softc->blk_mask == ~0) &&
 714                     ((bp->b_bcount % softc->min_blk) != 0))) {
 715                         xpt_print_path(periph->path);
 716                         printf("Invalid request.  Fixed block device "
 717                                "requests must be a multiple "
 718                                "of %d bytes\n", softc->media_blksize);
 719                         bp->b_error = EINVAL;
 720                         goto bad;
 721                 }
 722         } else if ((bp->b_bcount > softc->max_blk) ||
 723                    (bp->b_bcount < softc->min_blk) ||
 724                    (bp->b_bcount & softc->blk_mask) != 0) {
 725
 726                 xpt_print_path(periph->path);
 727                 printf("Invalid request.  Variable block device "
 728                     "requests must be ");
 729                 if (softc->blk_mask != 0) {
 730                         printf("a multiple of %d ", (0x1 << softc->blk_gran));
 731                 }
 732                 printf("between %d and %d bytes\n", softc->min_blk,
 733                     softc->max_blk);
 734                 bp->b_error = EINVAL;
 735                 goto bad;
 736         }
 737
 738         /*
 739          * Mask interrupts so that the device cannot be invalidated until
 740          * after we are in the queue.  Otherwise, we might not properly
 741          * clean up one of the buffers.
 742          */
 743         s = splbio();
 744
 745         /*
 746          * Place it at the end of the queue.
 747          */
 748         bufq_insert_tail(&softc->buf_queue, bp);
 749
 750         softc->queue_count++;
 751         CAM_DEBUG(periph->path, CAM_DEBUG_INFO, ("sastrategy: enqueuing a %d "
 752             "%s byte %s queue count now %d\n", (int) bp->b_bcount,
 753              (softc->flags & SA_FLAG_FIXED)?  "fixed" : "variable",
 754              (bp->b_flags & B_READ)? "read" : "write", softc->queue_count));
 755
 756         splx(s);
 757
 758         /*
 759          * Schedule ourselves for performing the work.
 760          */
 761         xpt_schedule(periph, 1);
 762
 763         return;
 764 bad:
 765         bp->b_flags |= B_ERROR;
 766 done:
 767
 768         /*
 769          * Correctly set the buf to indicate a completed xfer
 770          */
 771         bp->b_resid = bp->b_bcount;
 772         biodone(bp);
 773 }
 774
 775 static int
 776 saioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td)
 777 {
 778         struct cam_periph *periph;
 779         struct sa_softc *softc;
 780         scsi_space_code spaceop;
 781         int didlockperiph = 0;
 782         int s;
 783         int unit;
 784         int mode;
 785         int density;
 786         int error = 0;
 787
 788         unit = SAUNIT(dev);
 789         mode = SAMODE(dev);
 790         density = SADENSITY(dev);
 791         error = 0;              /* shut up gcc */
 792         spaceop = 0;            /* shut up gcc */
 793
 794         periph = cam_extend_get(saperiphs, unit);
 795         if (periph == NULL)
 796                 return (ENXIO);
 797
 798         softc = (struct sa_softc *)periph->softc;
 799
 800         /*
 801          * Check for control mode accesses. We allow MTIOCGET and
 802          * MTIOCERRSTAT (but need to be the only one open in order
 803          * to clear latched status), and MTSETBSIZE, MTSETDNSTY
 804          * and MTCOMP (but need to be the only one accessing this
 805          * device to run those).
 806          */
 807
 808         if (SA_IS_CTRL(dev)) {
 809                 switch (cmd) {
 810                 case MTIOCGETEOTMODEL:
 811                 case MTIOCGET:
 812                         break;
 813                 case MTIOCERRSTAT:
 814                         /*
 815                          * If the periph isn't already locked, lock it
 816                          * so our MTIOCERRSTAT can reset latched error stats.
 817                          *
 818                          * If the periph is already locked, skip it because
 819                          * we're just getting status and it'll be up to the
 820                          * other thread that has this device open to do
 821                          * an MTIOCERRSTAT that would clear latched status.
 822                          */
 823                         s = splsoftcam();
 824                         if ((periph->flags & CAM_PERIPH_LOCKED) == 0) {
 825                                 error = cam_periph_lock(periph, PCATCH);
 826                                 if (error != 0) {
 827                                         splx(s);
 828                                         return (error);
 829                                 }
 830                                 didlockperiph = 1;
 831                         }
 832                         break;
 833
 834                 case MTIOCSETEOTMODEL:
 835                 case MTSETBSIZ:
 836                 case MTSETDNSTY:
 837                 case MTCOMP:
 838                         /*
 839                          * We need to acquire the peripheral here rather
 840                          * than at open time because we are sharing writable
 841                          * access to data structures.
 842                          */
 843                         s = splsoftcam();
 844                         error = cam_periph_lock(periph, PCATCH);
 845                         if (error != 0) {
 846                                 splx(s);
 847                                 return (error);
 848                         }
 849                         didlockperiph = 1;
 850                         break;
 851
 852                 default:
 853                         return (EINVAL);
 854                 }
 855         }
 856
 857         /*
 858          * Find the device that the user is talking about
 859          */
 860         switch (cmd) {
 861         case MTIOCGET:
 862         {
 863                 struct mtget *g = (struct mtget *)arg;
 864
 865                 /*
 866                  * If this isn't the control mode device, actually go out
 867                  * and ask the drive again what it's set to.
 868                  */
 869                 if (!SA_IS_CTRL(dev)) {
 870                         u_int8_t write_protect;
 871                         int comp_enabled, comp_supported;
 872                         error = sagetparams(periph, SA_PARAM_ALL,
 873                             &softc->media_blksize, &softc->media_density,
 874                             &softc->media_numblks, &softc->buffer_mode,
 875                             &write_protect, &softc->speed, &comp_supported,
 876                             &comp_enabled, &softc->comp_algorithm, NULL);
 877                         if (error)
 878                                 break;
 879                         if (write_protect)
 880                                 softc->flags |= SA_FLAG_TAPE_WP;
 881                         else
 882                                 softc->flags &= ~SA_FLAG_TAPE_WP;
 883                         softc->flags &= ~(SA_FLAG_COMP_SUPP|
 884                             SA_FLAG_COMP_ENABLED|SA_FLAG_COMP_UNSUPP);
 885                         if (comp_supported) {
 886                                 if (softc->saved_comp_algorithm == 0)
 887                                         softc->saved_comp_algorithm =
 888                                             softc->comp_algorithm;
 889                                 softc->flags |= SA_FLAG_COMP_SUPP;
 890                                 if (comp_enabled)
 891                                         softc->flags |= SA_FLAG_COMP_ENABLED;
 892                         } else
 893                                 softc->flags |= SA_FLAG_COMP_UNSUPP;
 894                 }
 895                 bzero(g, sizeof(struct mtget));
 896                 g->mt_type = MT_ISAR;
 897                 if (softc->flags & SA_FLAG_COMP_UNSUPP) {
 898                         g->mt_comp = MT_COMP_UNSUPP;
 899                         g->mt_comp0 = MT_COMP_UNSUPP;
 900                         g->mt_comp1 = MT_COMP_UNSUPP;
 901                         g->mt_comp2 = MT_COMP_UNSUPP;
 902                         g->mt_comp3 = MT_COMP_UNSUPP;
 903                 } else {
 904                         if ((softc->flags & SA_FLAG_COMP_ENABLED) == 0) {
 905                                 g->mt_comp = MT_COMP_DISABLED;
 906                         } else {
 907                                 g->mt_comp = softc->comp_algorithm;
 908                         }
 909                         g->mt_comp0 = softc->comp_algorithm;
 910                         g->mt_comp1 = softc->comp_algorithm;
 911                         g->mt_comp2 = softc->comp_algorithm;
 912                         g->mt_comp3 = softc->comp_algorithm;
 913                 }
 914                 g->mt_density = softc->media_density;
 915                 g->mt_density0 = softc->media_density;
 916                 g->mt_density1 = softc->media_density;
 917                 g->mt_density2 = softc->media_density;
 918                 g->mt_density3 = softc->media_density;
 919                 g->mt_blksiz = softc->media_blksize;
 920                 g->mt_blksiz0 = softc->media_blksize;
 921                 g->mt_blksiz1 = softc->media_blksize;
 922                 g->mt_blksiz2 = softc->media_blksize;
 923                 g->mt_blksiz3 = softc->media_blksize;
 924                 g->mt_fileno = softc->fileno;
 925                 g->mt_blkno = softc->blkno;
 926                 g->mt_dsreg = (short) softc->dsreg;
 927                 /*
 928                  * Yes, we know that this is likely to overflow
 929                  */
 930                 if (softc->last_resid_was_io) {
 931                         if ((g->mt_resid = (short) softc->last_io_resid) != 0) {
 932                                 if (SA_IS_CTRL(dev) == 0 || didlockperiph) {
 933                                         softc->last_io_resid = 0;
 934                                 }
 935                         }
 936                 } else {
 937                         if ((g->mt_resid = (short)softc->last_ctl_resid) != 0) {
 938                                 if (SA_IS_CTRL(dev) == 0 || didlockperiph) {
 939                                         softc->last_ctl_resid = 0;
 940                                 }
 941                         }
 942                 }
 943                 error = 0;
 944                 break;
 945         }
 946         case MTIOCERRSTAT:
 947         {
 948                 struct scsi_tape_errors *sep =
 949                     &((union mterrstat *)arg)->scsi_errstat;
 950
 951                 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
 952                     ("saioctl: MTIOCERRSTAT\n"));
 953
 954                 bzero(sep, sizeof(*sep));
 955                 sep->io_resid = softc->last_io_resid;
 956                 bcopy((caddr_t) &softc->last_io_sense, sep->io_sense,
 957                     sizeof (sep->io_sense));
 958                 bcopy((caddr_t) &softc->last_io_cdb, sep->io_cdb,
 959                     sizeof (sep->io_cdb));
 960                 sep->ctl_resid = softc->last_ctl_resid;
 961                 bcopy((caddr_t) &softc->last_ctl_sense, sep->ctl_sense,
 962                     sizeof (sep->ctl_sense));
 963                 bcopy((caddr_t) &softc->last_ctl_cdb, sep->ctl_cdb,
 964                     sizeof (sep->ctl_cdb));
 965
 966                 if (SA_IS_CTRL(dev) == 0 || didlockperiph)
 967                         bzero((caddr_t) &softc->errinfo,
 968                             sizeof (softc->errinfo));
 969                 error = 0;
 970                 break;
 971         }
 972         case MTIOCTOP:
 973         {
 974                 struct mtop *mt;
 975                 int    count;
 976
 977                 mt = (struct mtop *)arg;
 978
 979                 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
 980                          ("saioctl: op=0x%x count=0x%x\n",
 981                           mt->mt_op, mt->mt_count));
 982
 983                 count = mt->mt_count;
 984                 switch (mt->mt_op) {
 985                 case MTWEOF:    /* write an end-of-file marker */
 986                         /*
 987                          * We don't need to clear the SA_FLAG_TAPE_WRITTEN
 988                          * flag because by keeping track of filemarks
 989                          * we have last written we know ehether or not
 990                          * we need to write more when we close the device.
 991                          */
 992                         error = sawritefilemarks(periph, count, FALSE);
 993                         break;
 994                 case MTWSS:     /* write a setmark */
 995                         error = sawritefilemarks(periph, count, TRUE);
 996                         break;
 997                 case MTBSR:     /* backward space record */
 998                 case MTFSR:     /* forward space record */
 999                 case MTBSF:     /* backward space file */
1000                 case MTFSF:     /* forward space file */
1001                 case MTBSS:     /* backward space setmark */
1002                 case MTFSS:     /* forward space setmark */
1003                 case MTEOD:     /* space to end of recorded medium */
1004                 {
1005                         int nmarks;
1006
1007                         spaceop = SS_FILEMARKS;
1008                         nmarks = softc->filemarks;
1009                         error = sacheckeod(periph);
1010                         if (error) {
1011                                 xpt_print_path(periph->path);
1012                                 printf("EOD check prior to spacing failed\n");
1013                                 softc->flags |= SA_FLAG_EIO_PENDING;
1014                                 break;
1015                         }
1016                         nmarks -= softc->filemarks;
1017                         switch(mt->mt_op) {
1018                         case MTBSR:
1019                                 count = -count;
1020                                 /* FALLTHROUGH */
1021                         case MTFSR:
1022                                 spaceop = SS_BLOCKS;
1023                                 break;
1024                         case MTBSF:
1025                                 count = -count;
1026                                 /* FALLTHROUGH */
1027                         case MTFSF:
1028                                 break;
1029                         case MTBSS:
1030                                 count = -count;
1031                                 /* FALLTHROUGH */
1032                         case MTFSS:
1033                                 spaceop = SS_SETMARKS;
1034                                 break;
1035                         case MTEOD:
1036                                 spaceop = SS_EOD;
1037                                 count = 0;
1038                                 nmarks = 0;
1039                                 break;
1040                         default:
1041                                 error = EINVAL;
1042                                 break;
1043                         }
1044                         if (error)
1045                                 break;
1046
1047                         nmarks = softc->filemarks;
1048                         /*
1049                          * XXX: Why are we checking again?
1050                          */
1051                         error = sacheckeod(periph);
1052                         if (error)
1053                                 break;
1054                         nmarks -= softc->filemarks;
1055                         error = saspace(periph, count - nmarks, spaceop);
1056                         /*
1057                          * At this point, clear that we've written the tape
1058                          * and that we've written any filemarks. We really
1059                          * don't know what the applications wishes to do next-
1060                          * the sacheckeod's will make sure we terminated the
1061                          * tape correctly if we'd been writing, but the next
1062                          * action the user application takes will set again
1063                          * whether we need to write filemarks.
1064                          */
1065                         softc->flags &=
1066                             ~(SA_FLAG_TAPE_WRITTEN|SA_FLAG_TAPE_FROZEN);
1067                         softc->filemarks = 0;
1068                         break;
1069                 }
1070                 case MTREW:     /* rewind */
1071                         (void) sacheckeod(periph);
1072                         error = sarewind(periph);
1073                         /* see above */
1074                         softc->flags &=
1075                             ~(SA_FLAG_TAPE_WRITTEN|SA_FLAG_TAPE_FROZEN);
1076                         softc->flags &= ~SA_FLAG_ERR_PENDING;
1077                         softc->filemarks = 0;
1078                         break;
1079                 case MTERASE:   /* erase */
1080                         error = saerase(periph, count);
1081                         softc->flags &=
1082                             ~(SA_FLAG_TAPE_WRITTEN|SA_FLAG_TAPE_FROZEN);
1083                         softc->flags &= ~SA_FLAG_ERR_PENDING;
1084                         break;
1085                 case MTRETENS:  /* re-tension tape */
1086                         error = saretension(periph);
1087                         softc->flags &=
1088                             ~(SA_FLAG_TAPE_WRITTEN|SA_FLAG_TAPE_FROZEN);
1089                         softc->flags &= ~SA_FLAG_ERR_PENDING;
1090                         break;
1091                 case MTOFFL:    /* rewind and put the drive offline */
1092
1093                         (void) sacheckeod(periph);
1094                         /* see above */
1095                         softc->flags &= ~SA_FLAG_TAPE_WRITTEN;
1096                         softc->filemarks = 0;
1097
1098                         error = sarewind(periph);
1099                         /* clear the frozen flag anyway */
1100                         softc->flags &= ~SA_FLAG_TAPE_FROZEN;
1101
1102                         /*
1103                          * Be sure to allow media removal before ejecting.
1104                          */
1105
1106                         saprevent(periph, PR_ALLOW);
1107                         if (error == 0) {
1108                                 error = saloadunload(periph, FALSE);
1109                                 if (error == 0) {
1110                                         softc->flags &= ~SA_FLAG_TAPE_MOUNTED;
1111                                 }
1112                         }
1113                         break;
1114
1115                 case MTNOP:     /* no operation, sets status only */
1116                 case MTCACHE:   /* enable controller cache */
1117                 case MTNOCACHE: /* disable controller cache */
1118                         error = 0;
1119                         break;
1120
1121                 case MTSETBSIZ: /* Set block size for device */
1122
1123                         error = sasetparams(periph, SA_PARAM_BLOCKSIZE, count,
1124                                             0, 0, 0);
1125                         if (error == 0) {
1126                                 softc->last_media_blksize =
1127                                     softc->media_blksize;
1128                                 softc->media_blksize = count;
1129                                 if (count) {
1130                                         softc->flags |= SA_FLAG_FIXED;
1131                                         if (powerof2(count)) {
1132                                                 softc->blk_shift =
1133                                                     ffs(count) - 1;
1134                                                 softc->blk_mask = count - 1;
1135                                         } else {
1136                                                 softc->blk_mask = ~0;
1137                                                 softc->blk_shift = 0;
1138                                         }
1139                                         /*
1140                                          * Make the user's desire 'persistent'.
1141                                          */
1142                                         softc->quirks &= ~SA_QUIRK_VARIABLE;
1143                                         softc->quirks |= SA_QUIRK_FIXED;
1144                                 } else {
1145                                         softc->flags &= ~SA_FLAG_FIXED;
1146                                         if (softc->max_blk == 0) {
1147                                                 softc->max_blk = ~0;
1148                                         }
1149                                         softc->blk_shift = 0;
1150                                         if (softc->blk_gran != 0) {
1151                                                 softc->blk_mask =
1152                                                     softc->blk_gran - 1;
1153                                         } else {
1154                                                 softc->blk_mask = 0;
1155                                         }
1156                                         /*
1157                                          * Make the user's desire 'persistent'.
1158                                          */
1159                                         softc->quirks |= SA_QUIRK_VARIABLE;
1160                                         softc->quirks &= ~SA_QUIRK_FIXED;
1161                                 }
1162                         }
1163                         break;
1164                 case MTSETDNSTY:        /* Set density for device and mode */
1165                         if (count > UCHAR_MAX) {
1166                                 error = EINVAL;
1167                                 break;
1168                         } else {
1169                                 error = sasetparams(periph, SA_PARAM_DENSITY,
1170                                                     0, count, 0, 0);
1171                         }
1172                         break;
1173                 case MTCOMP:    /* enable compression */
1174                         /*
1175                          * Some devices don't support compression, and
1176                          * don't like it if you ask them for the
1177                          * compression page.
1178                          */
1179                         if ((softc->quirks & SA_QUIRK_NOCOMP) ||
1180                             (softc->flags & SA_FLAG_COMP_UNSUPP)) {
1181                                 error = ENODEV;
1182                                 break;
1183                         }
1184                         error = sasetparams(periph, SA_PARAM_COMPRESSION,
1185                             0, 0, count, SF_NO_PRINT);
1186                         break;
1187                 default:
1188                         error = EINVAL;
1189                 }
1190                 break;
1191         }
1192         case MTIOCIEOT:
1193         case MTIOCEEOT:
1194                 error = 0;
1195                 break;
1196         case MTIOCRDSPOS:
1197                 error = sardpos(periph, 0, (u_int32_t *) arg);
1198                 break;
1199         case MTIOCRDHPOS:
1200                 error = sardpos(periph, 1, (u_int32_t *) arg);
1201                 break;
1202         case MTIOCSLOCATE:
1203                 error = sasetpos(periph, 0, (u_int32_t *) arg);
1204                 break;
1205         case MTIOCHLOCATE:
1206                 error = sasetpos(periph, 1, (u_int32_t *) arg);
1207                 break;
1208         case MTIOCGETEOTMODEL:
1209                 error = 0;
1210                 if (softc->quirks & SA_QUIRK_1FM)
1211                         mode = 1;
1212                 else
1213                         mode = 2;
1214                 *((u_int32_t *) arg) = mode;
1215                 break;
1216         case MTIOCSETEOTMODEL:
1217                 error = 0;
1218                 switch (*((u_int32_t *) arg)) {
1219                 case 1:
1220                         softc->quirks &= ~SA_QUIRK_2FM;
1221                         softc->quirks |= SA_QUIRK_1FM;
1222                         break;
1223                 case 2:
1224                         softc->quirks &= ~SA_QUIRK_1FM;
1225                         softc->quirks |= SA_QUIRK_2FM;
1226                         break;
1227                 default:
1228                         error = EINVAL;
1229                         break;
1230                 }
1231                 break;
1232         default:
1233                 error = cam_periph_ioctl(periph, cmd, arg, saerror);
1234                 break;
1235         }
1236
1237         /*
1238          * Check to see if we cleared a frozen state
1239          */
1240         if (error == 0 && (softc->flags & SA_FLAG_TAPE_FROZEN)) {
1241                 switch(cmd) {
1242                 case MTIOCRDSPOS:
1243                 case MTIOCRDHPOS:
1244                 case MTIOCSLOCATE:
1245                 case MTIOCHLOCATE:
1246                         softc->fileno = (daddr_t) -1;
1247                         softc->blkno = (daddr_t) -1;
1248                         softc->flags &= ~SA_FLAG_TAPE_FROZEN;
1249                         xpt_print_path(periph->path);
1250                         printf("tape state now unfrozen.\n");
1251                         break;
1252                 default:
1253                         break;
1254                 }
1255         }
1256         if (didlockperiph) {
1257                 cam_periph_unlock(periph);
1258         }
1259         return (error);
1260 }
1261
1262 static void
1263 sainit(void)
1264 {
1265         cam_status status;
1266         struct cam_path *path;
1267
1268         /*
1269          * Create our extend array for storing the devices we attach to.
1270          */
1271         saperiphs = cam_extend_new();
1272         if (saperiphs == NULL) {
1273                 printf("sa: Failed to alloc extend array!\n");
1274                 return;
1275         }
1276
1277         /*
1278          * Install a global async callback.
1279          */
1280         status = xpt_create_path(&path, NULL, CAM_XPT_PATH_ID,
1281                                  CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
1282
1283         if (status == CAM_REQ_CMP) {
1284                 /* Register the async callbacks of interrest */
1285                 struct ccb_setasync csa; /*
1286                                           * This is an immediate CCB,
1287                                           * so using the stack is OK
1288                                           */
1289                 xpt_setup_ccb(&csa.ccb_h, path, 5);
1290                 csa.ccb_h.func_code = XPT_SASYNC_CB;
1291                 csa.event_enable = AC_FOUND_DEVICE;
1292                 csa.callback = saasync;
1293                 csa.callback_arg = NULL;
1294                 xpt_action((union ccb *)&csa);
1295                 status = csa.ccb_h.status;
1296                 xpt_free_path(path);
1297         }
1298
1299         if (status != CAM_REQ_CMP) {
1300                 printf("sa: Failed to attach master async callback "
1301                        "due to status 0x%x!\n", status);
1302         }
1303 }
1304
1305 static void
1306 saoninvalidate(struct cam_periph *periph)
1307 {
1308         struct sa_softc *softc;
1309         struct buf *q_bp;
1310         struct ccb_setasync csa;
1311         int s;
1312
1313         softc = (struct sa_softc *)periph->softc;
1314
1315         /*
1316          * De-register any async callbacks.
1317          */
1318         xpt_setup_ccb(&csa.ccb_h, periph->path,
1319                       /* priority */ 5);
1320         csa.ccb_h.func_code = XPT_SASYNC_CB;
1321         csa.event_enable = 0;
1322         csa.callback = saasync;
1323         csa.callback_arg = periph;
1324         xpt_action((union ccb *)&csa);
1325
1326         softc->flags |= SA_FLAG_INVALID;
1327
1328         /*
1329          * Although the oninvalidate() routines are always called at
1330          * splsoftcam, we need to be at splbio() here to keep the buffer
1331          * queue from being modified while we traverse it.
1332          */
1333         s = splbio();
1334
1335         /*
1336          * Return all queued I/O with ENXIO.
1337          * XXX Handle any transactions queued to the card
1338          *     with XPT_ABORT_CCB.
1339          */
1340         while ((q_bp = bufq_first(&softc->buf_queue)) != NULL){
1341                 bufq_remove(&softc->buf_queue, q_bp);
1342                 q_bp->b_resid = q_bp->b_bcount;
1343                 q_bp->b_error = ENXIO;
1344                 q_bp->b_flags |= B_ERROR;
1345                 biodone(q_bp);
1346         }
1347         softc->queue_count = 0;
1348         splx(s);
1349
1350         xpt_print_path(periph->path);
1351         printf("lost device\n");
1352
1353 }
1354
1355 static void
1356 sacleanup(struct cam_periph *periph)
1357 {
1358         struct sa_softc *softc;
1359
1360         softc = (struct sa_softc *)periph->softc;
1361
1362         devstat_remove_entry(&softc->device_stats);
1363
1364         cam_extend_release(saperiphs, periph->unit_number);
1365         xpt_print_path(periph->path);
1366         printf("removing device entry\n");
1367         cdevsw_remove(&sa_cdevsw, SA_UNITMASK, SA_UNIT(periph->unit_number));
1368         free(softc, M_DEVBUF);
1369 }
1370
1371 static void
1372 saasync(void *callback_arg, u_int32_t code,
1373         struct cam_path *path, void *arg)
1374 {
1375         struct cam_periph *periph;
1376
1377         periph = (struct cam_periph *)callback_arg;
1378         switch (code) {
1379         case AC_FOUND_DEVICE:
1380         {
1381                 struct ccb_getdev *cgd;
1382                 cam_status status;
1383
1384                 cgd = (struct ccb_getdev *)arg;
1385                 if (cgd == NULL)
1386                         break;
1387
1388                 if (SID_TYPE(&cgd->inq_data) != T_SEQUENTIAL)
1389                         break;
1390
1391                 /*
1392                  * Allocate a peripheral instance for
1393                  * this device and start the probe
1394                  * process.
1395                  */
1396                 status = cam_periph_alloc(saregister, saoninvalidate,
1397                                           sacleanup, sastart,
1398                                           "sa", CAM_PERIPH_BIO, cgd->ccb_h.path,
1399                                           saasync, AC_FOUND_DEVICE, cgd);
1400
1401                 if (status != CAM_REQ_CMP
1402                  && status != CAM_REQ_INPROG)
1403                         printf("saasync: Unable to probe new device "
1404                                 "due to status 0x%x\n", status);
1405                 break;
1406         }
1407         default:
1408                 cam_periph_async(periph, code, path, arg);
1409                 break;
1410         }
1411 }
1412
1413 static cam_status
1414 saregister(struct cam_periph *periph, void *arg)
1415 {
1416         struct sa_softc *softc;
1417         struct ccb_setasync csa;
1418         struct ccb_getdev *cgd;
1419         caddr_t match;
1420         int i;
1421
1422         cgd = (struct ccb_getdev *)arg;
1423         if (periph == NULL) {
1424                 printf("saregister: periph was NULL!!\n");
1425                 return (CAM_REQ_CMP_ERR);
1426         }
1427
1428         if (cgd == NULL) {
1429                 printf("saregister: no getdev CCB, can't register device\n");
1430                 return (CAM_REQ_CMP_ERR);
1431         }
1432
1433         softc = malloc(sizeof (*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
1434         softc->scsi_rev = SID_ANSI_REV(&cgd->inq_data);
1435         softc->state = SA_STATE_NORMAL;
1436         softc->fileno = (daddr_t) -1;
1437         softc->blkno = (daddr_t) -1;
1438
1439         bufq_init(&softc->buf_queue);
1440         periph->softc = softc;
1441         cam_extend_set(saperiphs, periph->unit_number, periph);
1442
1443         /*
1444          * See if this device has any quirks.
1445          */
1446         match = cam_quirkmatch((caddr_t)&cgd->inq_data,
1447                                (caddr_t)sa_quirk_table,
1448                                sizeof(sa_quirk_table)/sizeof(*sa_quirk_table),
1449                                sizeof(*sa_quirk_table), scsi_inquiry_match);
1450
1451         if (match != NULL) {
1452                 softc->quirks = ((struct sa_quirk_entry *)match)->quirks;
1453                 softc->last_media_blksize =
1454                     ((struct sa_quirk_entry *)match)->prefblk;
1455 #ifdef  CAMDEBUG
1456                 xpt_print_path(periph->path);
1457                 printf("found quirk entry %d\n", (int)
1458                     (((struct sa_quirk_entry *) match) - sa_quirk_table));
1459 #endif
1460         } else
1461                 softc->quirks = SA_QUIRK_NONE;
1462
1463         /*
1464          * The SA driver supports a blocksize, but we don't know the
1465          * blocksize until we media is inserted.  So, set a flag to
1466          * indicate that the blocksize is unavailable right now.
1467          */
1468         devstat_add_entry(&softc->device_stats, "sa", periph->unit_number, 0,
1469             DEVSTAT_BS_UNAVAILABLE, SID_TYPE(&cgd->inq_data) |
1470             DEVSTAT_TYPE_IF_SCSI, DEVSTAT_PRIORITY_TAPE);
1471
1472         cdevsw_add(&sa_cdevsw, SA_UNITMASK, SA_UNIT(periph->unit_number));
1473         make_dev(&sa_cdevsw, SAMINOR(SA_CTLDEV,
1474             periph->unit_number, 0, SA_ATYPE_R), UID_ROOT, GID_OPERATOR,
1475             0660, "r%s%d.ctl", periph->periph_name, periph->unit_number);
1476
1477         make_dev(&sa_cdevsw, SAMINOR(SA_NOT_CTLDEV,
1478             periph->unit_number, 0, SA_ATYPE_R), UID_ROOT, GID_OPERATOR,
1479             0660, "r%s%d", periph->periph_name, periph->unit_number);
1480
1481         make_dev(&sa_cdevsw, SAMINOR(SA_NOT_CTLDEV,
1482             periph->unit_number, 0, SA_ATYPE_NR), UID_ROOT, GID_OPERATOR,
1483             0660, "nr%s%d", periph->periph_name, periph->unit_number);
1484
1485         make_dev(&sa_cdevsw, SAMINOR(SA_NOT_CTLDEV,
1486             periph->unit_number, 0, SA_ATYPE_ER), UID_ROOT, GID_OPERATOR,
1487             0660, "er%s%d", periph->periph_name, periph->unit_number);
1488
1489         for (i = 0; i < SA_NUM_MODES; i++) {
1490
1491                 make_dev(&sa_cdevsw,
1492                     SAMINOR(SA_NOT_CTLDEV, periph->unit_number, i, SA_ATYPE_R),
1493                     UID_ROOT, GID_OPERATOR, 0660, "r%s%d.%d",
1494                     periph->periph_name, periph->unit_number, i);
1495
1496                 make_dev(&sa_cdevsw,
1497                     SAMINOR(SA_NOT_CTLDEV, periph->unit_number, i, SA_ATYPE_NR),
1498                     UID_ROOT, GID_OPERATOR, 0660, "nr%s%d.%d",
1499                     periph->periph_name, periph->unit_number, i);
1500
1501
1502                 make_dev(&sa_cdevsw,
1503                     SAMINOR(SA_NOT_CTLDEV, periph->unit_number, i, SA_ATYPE_ER),
1504                     UID_ROOT, GID_OPERATOR, 0660, "er%s%d.%d",
1505                     periph->periph_name, periph->unit_number, i);
1506         }
1507
1508         /*
1509          * Add an async callback so that we get
1510          * notified if this device goes away.
1511          */
1512         xpt_setup_ccb(&csa.ccb_h, periph->path, /* priority */ 5);
1513         csa.ccb_h.func_code = XPT_SASYNC_CB;
1514         csa.event_enable = AC_LOST_DEVICE;
1515         csa.callback = saasync;
1516         csa.callback_arg = periph;
1517         xpt_action((union ccb *)&csa);
1518
1519         xpt_announce_periph(periph, NULL);
1520
1521         return (CAM_REQ_CMP);
1522 }
1523
1524 static void
1525 sastart(struct cam_periph *periph, union ccb *start_ccb)
1526 {
1527         struct sa_softc *softc;
1528
1529         softc = (struct sa_softc *)periph->softc;
1530
1531         CAM_DEBUG(periph->path, CAM_DEBUG_INFO, ("sastart"));
1532
1533
1534         switch (softc->state) {
1535         case SA_STATE_NORMAL:
1536         {
1537                 /* Pull a buffer from the queue and get going on it */
1538                 struct buf *bp;
1539                 int s;
1540
1541                 /*
1542                  * See if there is a buf with work for us to do..
1543                  */
1544                 s = splbio();
1545                 bp = bufq_first(&softc->buf_queue);
1546                 if (periph->immediate_priority <= periph->pinfo.priority) {
1547                         CAM_DEBUG_PRINT(CAM_DEBUG_SUBTRACE,
1548                                         ("queuing for immediate ccb\n"));
1549                         Set_CCB_Type(start_ccb, SA_CCB_WAITING);
1550                         SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h,
1551                                           periph_links.sle);
1552                         periph->immediate_priority = CAM_PRIORITY_NONE;
1553                         splx(s);
1554                         wakeup(&periph->ccb_list);
1555                 } else if (bp == NULL) {
1556                         splx(s);
1557                         xpt_release_ccb(start_ccb);
1558                 } else if ((softc->flags & SA_FLAG_ERR_PENDING) != 0) {
1559                         struct buf *done_bp;
1560 again:
1561                         softc->queue_count--;
1562                         bufq_remove(&softc->buf_queue, bp);
1563                         bp->b_resid = bp->b_bcount;
1564                         done_bp = bp;
1565                         if ((softc->flags & SA_FLAG_EOM_PENDING) != 0) {
1566                                 /*
1567                                  * We now just clear errors in this case
1568                                  * and let the residual be the notifier.
1569                                  */
1570                                 bp->b_error = 0;
1571                         } else if ((softc->flags & SA_FLAG_EOF_PENDING) != 0) {
1572                                 /*
1573                                  * This can only happen if we're reading
1574                                  * in fixed length mode. In this case,
1575                                  * we dump the rest of the list the
1576                                  * same way.
1577                                  */
1578                                 bp->b_error = 0;
1579                                 if (bufq_first(&softc->buf_queue) != NULL) {
1580                                         biodone(done_bp);
1581                                         goto again;
1582                                 }
1583                         } else if ((softc->flags & SA_FLAG_EIO_PENDING) != 0) {
1584                                 bp->b_error = EIO;
1585                                 bp->b_flags |= B_ERROR;
1586                         }
1587                         bp = bufq_first(&softc->buf_queue);
1588                         /*
1589                          * Only if we have no other buffers queued up
1590                          * do we clear the pending error flag.
1591                          */
1592                         if (bp == NULL)
1593                                 softc->flags &= ~SA_FLAG_ERR_PENDING;
1594                         CAM_DEBUG(periph->path, CAM_DEBUG_INFO,
1595                             ("sastart- ERR_PENDING now 0x%x, bp is %sNULL, "
1596                             "%d more buffers queued up\n",
1597                             (softc->flags & SA_FLAG_ERR_PENDING),
1598                             (bp != NULL)? "not " : " ", softc->queue_count));
1599                         splx(s);
1600                         xpt_release_ccb(start_ccb);
1601                         biodone(done_bp);
1602                 } else {
1603                         u_int32_t length;
1604
1605                         bufq_remove(&softc->buf_queue, bp);
1606                         softc->queue_count--;
1607
1608                         if ((softc->flags & SA_FLAG_FIXED) != 0) {
1609                                 if (softc->blk_shift != 0) {
1610                                         length =
1611                                             bp->b_bcount >> softc->blk_shift;
1612                                 } else if (softc->media_blksize != 0) {
1613                                         length =
1614                                             bp->b_bcount / softc->media_blksize;
1615                                 } else {
1616                                         bp->b_error = EIO;
1617                                         xpt_print_path(periph->path);
1618                                         printf("zero blocksize for "
1619                                             "FIXED length writes?\n");
1620                                         splx(s);
1621                                         biodone(bp);
1622                                         break;
1623                                 }
1624                                 CAM_DEBUG(periph->path, CAM_DEBUG_INFO,
1625                                     ("Fixed Record Count is %d\n", length));
1626                         } else {
1627                                 length = bp->b_bcount;
1628                                 CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_INFO,
1629                                     ("Variable Record Count is %d\n", length));
1630                         }
1631                         devstat_start_transaction(&softc->device_stats);
1632                         /*
1633                          * Some people have theorized that we should
1634                          * suppress illegal length indication if we are
1635                          * running in variable block mode so that we don't
1636                          * have to request sense every time our requested
1637                          * block size is larger than the written block.
1638                          * The residual information from the ccb allows
1639                          * us to identify this situation anyway.  The only
1640                          * problem with this is that we will not get
1641                          * information about blocks that are larger than
1642                          * our read buffer unless we set the block size
1643                          * in the mode page to something other than 0.
1644                          *
1645                          * I believe that this is a non-issue. If user apps
1646                          * don't adjust their read size to match our record
1647                          * size, that's just life. Anyway, the typical usage
1648                          * would be to issue, e.g., 64KB reads and occasionally
1649                          * have to do deal with 512 byte or 1KB intermediate
1650                          * records.
1651                          */
1652                         softc->dsreg = (bp->b_flags & B_READ)?
1653                             MTIO_DSREG_RD : MTIO_DSREG_WR;
1654                         scsi_sa_read_write(&start_ccb->csio, 0, sadone,
1655                             MSG_SIMPLE_Q_TAG, (bp->b_flags & B_READ) != 0,
1656                             FALSE, (softc->flags & SA_FLAG_FIXED) != 0,
1657                             length, bp->b_data, bp->b_bcount, SSD_FULL_SIZE,
1658                             IO_TIMEOUT);
1659                         start_ccb->ccb_h.ccb_pflags &= ~SA_POSITION_UPDATED;
1660                         Set_CCB_Type(start_ccb, SA_CCB_BUFFER_IO);
1661                         start_ccb->ccb_h.ccb_bp = bp;
1662                         bp = bufq_first(&softc->buf_queue);
1663                         splx(s);
1664                         xpt_action(start_ccb);
1665                 }
1666
1667                 if (bp != NULL) {
1668                         /* Have more work to do, so ensure we stay scheduled */
1669                         xpt_schedule(periph, 1);
1670                 }
1671                 break;
1672         }
1673         case SA_STATE_ABNORMAL:
1674         default:
1675                 panic("state 0x%x in sastart", softc->state);
1676                 break;
1677         }
1678 }
1679
1680
1681 static void
1682 sadone(struct cam_periph *periph, union ccb *done_ccb)
1683 {
1684         struct sa_softc *softc;
1685         struct ccb_scsiio *csio;
1686
1687         softc = (struct sa_softc *)periph->softc;
1688         csio = &done_ccb->csio;
1689         switch (CCB_Type(csio)) {
1690         case SA_CCB_BUFFER_IO:
1691         {
1692                 struct buf *bp;
1693                 int error;
1694
1695                 softc->dsreg = MTIO_DSREG_REST;
1696                 bp = (struct buf *)done_ccb->ccb_h.ccb_bp;
1697                 error = 0;
1698                 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1699                         if ((error = saerror(done_ccb, 0, 0)) == ERESTART) {
1700                                 /*
1701                                  * A retry was scheduled, so just return.
1702                                  */
1703                                 return;
1704                         }
1705                 }
1706
1707                 if (error == EIO) {
1708                         int s;
1709                         struct buf *q_bp;
1710
1711                         /*
1712                          * Catastrophic error. Mark the tape as frozen
1713                          * (we no longer know tape position).
1714                          *
1715                          * Return all queued I/O with EIO, and unfreeze
1716                          * our queue so that future transactions that
1717                          * attempt to fix this problem can get to the
1718                          * device.
1719                          *
1720                          */
1721
1722                         s = splbio();
1723                         softc->flags |= SA_FLAG_TAPE_FROZEN;
1724                         while ((q_bp = bufq_first(&softc->buf_queue)) != NULL) {
1725                                 bufq_remove(&softc->buf_queue, q_bp);
1726                                 q_bp->b_resid = q_bp->b_bcount;
1727                                 q_bp->b_error = EIO;
1728                                 q_bp->b_flags |= B_ERROR;
1729                                 biodone(q_bp);
1730                         }
1731                         splx(s);
1732                 }
1733                 if (error != 0) {
1734                         bp->b_resid = bp->b_bcount;
1735                         bp->b_error = error;
1736                         bp->b_flags |= B_ERROR;
1737                         /*
1738                          * In the error case, position is updated in saerror.
1739                          */
1740                 } else {
1741                         bp->b_resid = csio->resid;
1742                         bp->b_error = 0;
1743                         if (csio->resid != 0) {
1744                                 bp->b_flags |= B_ERROR;
1745                         }
1746                         if ((bp->b_flags & B_READ) == 0) {
1747                                 softc->flags |= SA_FLAG_TAPE_WRITTEN;
1748                                 softc->filemarks = 0;
1749                         }
1750                         if (!(csio->ccb_h.ccb_pflags & SA_POSITION_UPDATED) &&
1751                             (softc->blkno != (daddr_t) -1)) {
1752                                 if ((softc->flags & SA_FLAG_FIXED) != 0) {
1753                                         u_int32_t l;
1754                                         if (softc->blk_shift != 0) {
1755                                                 l = bp->b_bcount >>
1756                                                         softc->blk_shift;
1757                                         } else {
1758                                                 l = bp->b_bcount /
1759                                                         softc->media_blksize;
1760                                         }
1761                                         softc->blkno += (daddr_t) l;
1762                                 } else {
1763                                         softc->blkno++;
1764                                 }
1765                         }
1766                 }
1767                 /*
1768                  * If we had an error (immediate or pending),
1769                  * release the device queue now.
1770                  */
1771                 if (error || (softc->flags & SA_FLAG_ERR_PENDING))
1772                         cam_release_devq(done_ccb->ccb_h.path, 0, 0, 0, 0);
1773 #ifdef  CAMDEBUG
1774                 if (error || bp->b_resid) {
1775                         CAM_DEBUG(periph->path, CAM_DEBUG_INFO,
1776                                   ("error %d resid %ld count %ld\n", error,
1777                                   bp->b_resid, bp->b_bcount));
1778                 }
1779 #endif
1780                 devstat_end_transaction_buf(&softc->device_stats, bp);
1781                 biodone(bp);
1782                 break;
1783         }
1784         case SA_CCB_WAITING:
1785         {
1786                 /* Caller will release the CCB */
1787                 wakeup(&done_ccb->ccb_h.cbfcnp);
1788                 return;
1789         }
1790         }
1791         xpt_release_ccb(done_ccb);
1792 }
1793
1794 /*
1795  * Mount the tape (make sure it's ready for I/O).
1796  */
1797 static int
1798 samount(struct cam_periph *periph, int oflags, dev_t dev)
1799 {
1800         struct  sa_softc *softc;
1801         union   ccb *ccb;
1802         int     error;
1803
1804         /*
1805          * oflags can be checked for 'kind' of open (read-only check) - later
1806          * dev can be checked for a control-mode or compression open - later
1807          */
1808         UNUSED_PARAMETER(oflags);
1809         UNUSED_PARAMETER(dev);
1810
1811
1812         softc = (struct sa_softc *)periph->softc;
1813
1814         /*
1815          * This should determine if something has happend since the last
1816          * open/mount that would invalidate the mount. We do *not* want
1817          * to retry this command- we just want the status. But we only
1818          * do this if we're mounted already- if we're not mounted,
1819          * we don't care about the unit read state and can instead use
1820          * this opportunity to attempt to reserve the tape unit.
1821          */
1822
1823         if (softc->flags & SA_FLAG_TAPE_MOUNTED) {
1824                 ccb = cam_periph_getccb(periph, 1);
1825                 scsi_test_unit_ready(&ccb->csio, 0, sadone,
1826                     MSG_SIMPLE_Q_TAG, SSD_FULL_SIZE, IO_TIMEOUT);
1827                 error = cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
1828                     &softc->device_stats);
1829                 QFRLS(ccb);
1830                 if (error == ENXIO) {
1831                         softc->flags &= ~SA_FLAG_TAPE_MOUNTED;
1832                         scsi_test_unit_ready(&ccb->csio, 0, sadone,
1833                             MSG_SIMPLE_Q_TAG, SSD_FULL_SIZE, IO_TIMEOUT);
1834                         error = cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
1835                             &softc->device_stats);
1836                         QFRLS(ccb);
1837                 } else if (error) {
1838                         /*
1839                          * We don't need to freeze the tape because we
1840                          * will now attempt to rewind/load it.
1841                          */
1842                         softc->flags &= ~SA_FLAG_TAPE_MOUNTED;
1843                         if (CAM_DEBUGGED(ccb->ccb_h.path, CAM_DEBUG_INFO)) {
1844                                 xpt_print_path(ccb->ccb_h.path);
1845                                 printf("error %d on TUR in samount\n", error);
1846                         }
1847                 }
1848         } else {
1849                 error = sareservereleaseunit(periph, TRUE);
1850                 if (error) {
1851                         return (error);
1852                 }
1853                 ccb = cam_periph_getccb(periph, 1);
1854                 scsi_test_unit_ready(&ccb->csio, 0, sadone,
1855                     MSG_SIMPLE_Q_TAG, SSD_FULL_SIZE, IO_TIMEOUT);
1856                 error = cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
1857                     &softc->device_stats);
1858                 QFRLS(ccb);
1859         }
1860
1861         if ((softc->flags & SA_FLAG_TAPE_MOUNTED) == 0) {
1862                 struct scsi_read_block_limits_data *rblim = NULL;
1863                 int comp_enabled, comp_supported;
1864                 u_int8_t write_protect, guessing = 0;
1865
1866                 /*
1867                  * Clear out old state.
1868                  */
1869                 softc->flags &= ~(SA_FLAG_TAPE_WP|SA_FLAG_TAPE_WRITTEN|
1870                                   SA_FLAG_ERR_PENDING|SA_FLAG_COMP_ENABLED|
1871                                   SA_FLAG_COMP_SUPP|SA_FLAG_COMP_UNSUPP);
1872                 softc->filemarks = 0;
1873
1874                 /*
1875                  * *Very* first off, make sure we're loaded to BOT.
1876                  */
1877                 scsi_load_unload(&ccb->csio, 2, sadone, MSG_SIMPLE_Q_TAG, FALSE,
1878                     FALSE, FALSE, 1, SSD_FULL_SIZE, REWIND_TIMEOUT);
1879                 error = cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
1880                     &softc->device_stats);
1881                 QFRLS(ccb);
1882
1883                 /*
1884                  * In case this doesn't work, do a REWIND instead
1885                  */
1886                 if (error) {
1887                         scsi_rewind(&ccb->csio, 2, sadone, MSG_SIMPLE_Q_TAG,
1888                             FALSE, SSD_FULL_SIZE, REWIND_TIMEOUT);
1889                         error = cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
1890                                 &softc->device_stats);
1891                         QFRLS(ccb);
1892                 }
1893                 if (error) {
1894                         xpt_release_ccb(ccb);
1895                         goto exit;
1896                 }
1897
1898                 /*
1899                  * Do a dummy test read to force access to the
1900                  * media so that the drive will really know what's
1901                  * there. We actually don't really care what the
1902                  * blocksize on tape is and don't expect to really
1903                  * read a full record.
1904                  */
1905                 rblim = malloc(8192, M_TEMP, M_INTWAIT);
1906
1907                 if ((softc->quirks & SA_QUIRK_NODREAD) == 0) {
1908                         scsi_sa_read_write(&ccb->csio, 0, sadone,
1909                             MSG_SIMPLE_Q_TAG, 1, FALSE, 0, 8192,
1910                             (void *) rblim, 8192, SSD_FULL_SIZE,
1911                             IO_TIMEOUT);
1912                         (void) cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
1913                             &softc->device_stats);
1914                         QFRLS(ccb);
1915                         scsi_rewind(&ccb->csio, 1, sadone, MSG_SIMPLE_Q_TAG,
1916                             FALSE, SSD_FULL_SIZE, REWIND_TIMEOUT);
1917                         error = cam_periph_runccb(ccb, saerror, 0,
1918                             SF_NO_PRINT | SF_RETRY_SELTO | SF_RETRY_UA,
1919                             &softc->device_stats);
1920                         QFRLS(ccb);
1921                         if (error) {
1922                                 xpt_print_path(ccb->ccb_h.path);
1923                                 printf("unable to rewind after test read\n");
1924                                 xpt_release_ccb(ccb);
1925                                 goto exit;
1926                         }
1927                 }
1928
1929                 /*
1930                  * Next off, determine block limits.
1931                  */
1932                 scsi_read_block_limits(&ccb->csio, 5, sadone, MSG_SIMPLE_Q_TAG,
1933                     rblim, SSD_FULL_SIZE, SCSIOP_TIMEOUT);
1934
1935                 error = cam_periph_runccb(ccb, saerror, 0,
1936                     SF_NO_PRINT | SF_RETRY_UA | SF_RETRY_SELTO,
1937                     &softc->device_stats);
1938                 QFRLS(ccb);
1939                 xpt_release_ccb(ccb);
1940
1941                 if (error != 0) {
1942                         /*
1943                          * If it's less than SCSI-2, READ BLOCK LIMITS is not
1944                          * a MANDATORY command. Anyway- it doesn't matter-
1945                          * we can proceed anyway.
1946                          */
1947                         softc->blk_gran = 0;
1948                         softc->max_blk = ~0;
1949                         softc->min_blk = 0;
1950                 } else {
1951                         if (softc->scsi_rev >= SCSI_REV_3) {
1952                                 softc->blk_gran = RBL_GRAN(rblim);
1953                         } else {
1954                                 softc->blk_gran = 0;
1955                         }
1956                         /*
1957                          * We take max_blk == min_blk to mean a default to
1958                          * fixed mode- but note that whatever we get out of
1959                          * sagetparams below will actually determine whether
1960                          * we are actually *in* fixed mode.
1961                          */
1962                         softc->max_blk = scsi_3btoul(rblim->maximum);
1963                         softc->min_blk = scsi_2btoul(rblim->minimum);
1964
1965
1966                 }
1967                 /*
1968                  * Next, perform a mode sense to determine
1969                  * current density, blocksize, compression etc.
1970                  */
1971                 error = sagetparams(periph, SA_PARAM_ALL,
1972                                     &softc->media_blksize,
1973                                     &softc->media_density,
1974                                     &softc->media_numblks,
1975                                     &softc->buffer_mode, &write_protect,
1976                                     &softc->speed, &comp_supported,
1977                                     &comp_enabled, &softc->comp_algorithm,
1978                                     NULL);
1979
1980                 if (error != 0) {
1981                         /*
1982                          * We could work a little harder here. We could
1983                          * adjust our attempts to get information. It
1984                          * might be an ancient tape drive. If someone
1985                          * nudges us, we'll do that.
1986                          */
1987                         goto exit;
1988                 }
1989
1990                 /*
1991                  * If no quirk has determined that this is a device that is
1992                  * preferred to be in fixed or variable mode, now is the time
1993                  * to find out.
1994                  */
1995                 if ((softc->quirks & (SA_QUIRK_FIXED|SA_QUIRK_VARIABLE)) == 0) {
1996                         guessing = 1;
1997                         /*
1998                          * This could be expensive to find out. Luckily we
1999                          * only need to do this once. If we start out in
2000                          * 'default' mode, try and set ourselves to one
2001                          * of the densities that would determine a wad
2002                          * of other stuff. Go from highest to lowest.
2003                          */
2004                         if (softc->media_density == SCSI_DEFAULT_DENSITY) {
2005                                 int i;
2006                                 static u_int8_t ctry[] = {
2007                                         SCSI_DENSITY_HALFINCH_PE,
2008                                         SCSI_DENSITY_HALFINCH_6250C,
2009                                         SCSI_DENSITY_HALFINCH_6250,
2010                                         SCSI_DENSITY_HALFINCH_1600,
2011                                         SCSI_DENSITY_HALFINCH_800,
2012                                         SCSI_DENSITY_QIC_4GB,
2013                                         SCSI_DENSITY_QIC_2GB,
2014                                         SCSI_DENSITY_QIC_525_320,
2015                                         SCSI_DENSITY_QIC_150,
2016                                         SCSI_DENSITY_QIC_120,
2017                                         SCSI_DENSITY_QIC_24,
2018                                         SCSI_DENSITY_QIC_11_9TRK,
2019                                         SCSI_DENSITY_QIC_11_4TRK,
2020                                         SCSI_DENSITY_QIC_1320,
2021                                         SCSI_DENSITY_QIC_3080,
2022                                         0
2023                                 };
2024                                 for (i = 0; ctry[i]; i++) {
2025                                         error = sasetparams(periph,
2026                                             SA_PARAM_DENSITY, 0, ctry[i],
2027                                             0, SF_NO_PRINT);
2028                                         if (error == 0) {
2029                                                 softc->media_density = ctry[i];
2030                                                 break;
2031                                         }
2032                                 }
2033                         }
2034                         switch (softc->media_density) {
2035                         case SCSI_DENSITY_QIC_11_4TRK:
2036                         case SCSI_DENSITY_QIC_11_9TRK:
2037                         case SCSI_DENSITY_QIC_24:
2038                         case SCSI_DENSITY_QIC_120:
2039                         case SCSI_DENSITY_QIC_150:
2040                         case SCSI_DENSITY_QIC_525_320:
2041                         case SCSI_DENSITY_QIC_1320:
2042                         case SCSI_DENSITY_QIC_3080:
2043                                 softc->quirks &= ~SA_QUIRK_2FM;
2044                                 softc->quirks |= SA_QUIRK_FIXED|SA_QUIRK_1FM;
2045                                 softc->last_media_blksize = 512;
2046                                 break;
2047                         case SCSI_DENSITY_QIC_4GB:
2048                         case SCSI_DENSITY_QIC_2GB:
2049                                 softc->quirks &= ~SA_QUIRK_2FM;
2050                                 softc->quirks |= SA_QUIRK_FIXED|SA_QUIRK_1FM;
2051                                 softc->last_media_blksize = 1024;
2052                                 break;
2053                         default:
2054                                 softc->last_media_blksize =
2055                                     softc->media_blksize;
2056                                 softc->quirks |= SA_QUIRK_VARIABLE;
2057                                 break;
2058                         }
2059                 }
2060
2061                 /*
2062                  * If no quirk has determined that this is a device that needs
2063                  * to have 2 Filemarks at EOD, now is the time to find out.
2064                  */
2065
2066                 if ((softc->quirks & SA_QUIRK_2FM) == 0) {
2067                         switch (softc->media_density) {
2068                         case SCSI_DENSITY_HALFINCH_800:
2069                         case SCSI_DENSITY_HALFINCH_1600:
2070                         case SCSI_DENSITY_HALFINCH_6250:
2071                         case SCSI_DENSITY_HALFINCH_6250C:
2072                         case SCSI_DENSITY_HALFINCH_PE:
2073                                 softc->quirks &= ~SA_QUIRK_1FM;
2074                                 softc->quirks |= SA_QUIRK_2FM;
2075                                 break;
2076                         default:
2077                                 break;
2078                         }
2079                 }
2080
2081                 /*
2082                  * Now validate that some info we got makes sense.
2083                  */
2084                 if ((softc->max_blk < softc->media_blksize) ||
2085                     (softc->min_blk > softc->media_blksize &&
2086                     softc->media_blksize)) {
2087                         xpt_print_path(ccb->ccb_h.path);
2088                         printf("BLOCK LIMITS (%d..%d) could not match current "
2089                             "block settings (%d)- adjusting\n", softc->min_blk,
2090                             softc->max_blk, softc->media_blksize);
2091                         softc->max_blk = softc->min_blk =
2092                             softc->media_blksize;
2093                 }
2094
2095                 /*
2096                  * Now put ourselves into the right frame of mind based
2097                  * upon quirks...
2098                  */
2099 tryagain:
2100                 /*
2101                  * If we want to be in FIXED mode and our current blocksize
2102                  * is not equal to our last blocksize (if nonzero), try and
2103                  * set ourselves to this last blocksize (as the 'preferred'
2104                  * block size).  The initial quirkmatch at registry sets the
2105                  * initial 'last' blocksize. If, for whatever reason, this
2106                  * 'last' blocksize is zero, set the blocksize to 512,
2107                  * or min_blk if that's larger.
2108                  */
2109                 if ((softc->quirks & SA_QUIRK_FIXED) &&
2110                     (softc->quirks & SA_QUIRK_NO_MODESEL) == 0 &&
2111                     (softc->media_blksize != softc->last_media_blksize)) {
2112                         softc->media_blksize = softc->last_media_blksize;
2113                         if (softc->media_blksize == 0) {
2114                                 softc->media_blksize = 512;
2115                                 if (softc->media_blksize < softc->min_blk) {
2116                                         softc->media_blksize = softc->min_blk;
2117                                 }
2118                         }
2119                         error = sasetparams(periph, SA_PARAM_BLOCKSIZE,
2120                             softc->media_blksize, 0, 0, SF_NO_PRINT);
2121                         if (error) {
2122                                 xpt_print_path(ccb->ccb_h.path);
2123                                 printf("unable to set fixed blocksize to %d\n",
2124                                      softc->media_blksize);
2125                                 goto exit;
2126                         }
2127                 }
2128
2129                 if ((softc->quirks & SA_QUIRK_VARIABLE) &&
2130                     (softc->media_blksize != 0)) {
2131                         softc->last_media_blksize = softc->media_blksize;
2132                         softc->media_blksize = 0;
2133                         error = sasetparams(periph, SA_PARAM_BLOCKSIZE,
2134                             0, 0, 0, SF_NO_PRINT);
2135                         if (error) {
2136                                 /*
2137                                  * If this fails and we were guessing, just
2138                                  * assume that we got it wrong and go try
2139                                  * fixed block mode. Don't even check against
2140                                  * density code at this point.
2141                                  */
2142                                 if (guessing) {
2143                                         softc->quirks &= ~SA_QUIRK_VARIABLE;
2144                                         softc->quirks |= SA_QUIRK_FIXED;
2145                                         if (softc->last_media_blksize == 0)
2146                                                 softc->last_media_blksize = 512;
2147                                         goto tryagain;
2148                                 }
2149                                 xpt_print_path(ccb->ccb_h.path);
2150                                 printf("unable to set variable blocksize\n");
2151                                 goto exit;
2152                         }
2153                 }
2154
2155                 /*
2156                  * Now that we have the current block size,
2157                  * set up some parameters for sastart's usage.
2158                  */
2159                 if (softc->media_blksize) {
2160                         softc->flags |= SA_FLAG_FIXED;
2161                         if (powerof2(softc->media_blksize)) {
2162                                 softc->blk_shift =
2163                                     ffs(softc->media_blksize) - 1;
2164                                 softc->blk_mask = softc->media_blksize - 1;
2165                         } else {
2166                                 softc->blk_mask = ~0;
2167                                 softc->blk_shift = 0;
2168                         }
2169                 } else {
2170                         /*
2171                          * The SCSI-3 spec allows 0 to mean "unspecified".
2172                          * The SCSI-1 spec allows 0 to mean 'infinite'.
2173                          *
2174                          * Either works here.
2175                          */
2176                         if (softc->max_blk == 0) {
2177                                 softc->max_blk = ~0;
2178                         }
2179                         softc->blk_shift = 0;
2180                         if (softc->blk_gran != 0) {
2181                                 softc->blk_mask = softc->blk_gran - 1;
2182                         } else {
2183                                 softc->blk_mask = 0;
2184                         }
2185                 }
2186
2187                 if (write_protect)
2188                         softc->flags |= SA_FLAG_TAPE_WP;
2189
2190                 if (comp_supported) {
2191                         if (softc->saved_comp_algorithm == 0)
2192                                 softc->saved_comp_algorithm =
2193                                     softc->comp_algorithm;
2194                         softc->flags |= SA_FLAG_COMP_SUPP;
2195                         if (comp_enabled)
2196                                 softc->flags |= SA_FLAG_COMP_ENABLED;
2197                 } else
2198                         softc->flags |= SA_FLAG_COMP_UNSUPP;
2199
2200                 if ((softc->buffer_mode == SMH_SA_BUF_MODE_NOBUF) &&
2201                     (softc->quirks & SA_QUIRK_NO_MODESEL) == 0) {
2202                         error = sasetparams(periph, SA_PARAM_BUFF_MODE, 0,
2203                             0, 0, SF_NO_PRINT);
2204                         if (error == 0) {
2205                                 softc->buffer_mode = SMH_SA_BUF_MODE_SIBUF;
2206                         } else {
2207                                 xpt_print_path(ccb->ccb_h.path);
2208                                 printf("unable to set buffered mode\n");
2209                         }
2210                         error = 0;      /* not an error */
2211                 }
2212
2213
2214                 if (error == 0) {
2215                         softc->flags |= SA_FLAG_TAPE_MOUNTED;
2216                 }
2217 exit:
2218                 if (rblim != NULL)
2219                         free(rblim, M_TEMP);
2220
2221                 if (error != 0) {
2222                         softc->dsreg = MTIO_DSREG_NIL;
2223                 } else {
2224                         softc->fileno = softc->blkno = 0;
2225                         softc->dsreg = MTIO_DSREG_REST;
2226                 }
2227 #ifdef  SA_1FM_AT_EOD
2228                 if ((softc->quirks & SA_QUIRK_2FM) == 0)
2229                         softc->quirks |= SA_QUIRK_1FM;
2230 #else
2231                 if ((softc->quirks & SA_QUIRK_1FM) == 0)
2232                         softc->quirks |= SA_QUIRK_2FM;
2233 #endif
2234         } else
2235                 xpt_release_ccb(ccb);
2236
2237         /*
2238          * If we return an error, we're not mounted any more,
2239          * so release any device reservation.
2240          */
2241         if (error != 0) {
2242                 (void) sareservereleaseunit(periph, FALSE);
2243         } else {
2244                 /*
2245                  * Clear I/O residual.
2246                  */
2247                 softc->last_io_resid = 0;
2248                 softc->last_ctl_resid = 0;
2249         }
2250         return (error);
2251 }
2252
2253 /*
2254  * How many filemarks do we need to write if we were to terminate the
2255  * tape session right now? Note that this can be a negative number
2256  */
2257
2258 static int
2259 samarkswanted(struct cam_periph *periph)
2260 {
2261         int     markswanted;
2262         struct  sa_softc *softc;
2263
2264         softc = (struct sa_softc *)periph->softc;
2265         markswanted = 0;
2266         if ((softc->flags & SA_FLAG_TAPE_WRITTEN) != 0) {
2267                 markswanted++;
2268                 if (softc->quirks & SA_QUIRK_2FM)
2269                         markswanted++;
2270         }
2271         markswanted -= softc->filemarks;
2272         return (markswanted);
2273 }
2274
2275 static int
2276 sacheckeod(struct cam_periph *periph)
2277 {
2278         int     error;
2279         int     markswanted;
2280         struct  sa_softc *softc;
2281
2282         softc = (struct sa_softc *)periph->softc;
2283         markswanted = samarkswanted(periph);
2284
2285         if (markswanted > 0) {
2286                 error = sawritefilemarks(periph, markswanted, FALSE);
2287         } else {
2288                 error = 0;
2289         }
2290         return (error);
2291 }
2292
2293 static int
2294 saerror(union ccb *ccb, u_int32_t cflgs, u_int32_t sflgs)
2295 {
2296         static const char *toobig =
2297             "%d-byte tape record bigger than supplied buffer\n";
2298         struct  cam_periph *periph;
2299         struct  sa_softc *softc;
2300         struct  ccb_scsiio *csio;
2301         struct  scsi_sense_data *sense;
2302         u_int32_t resid = 0;
2303         int32_t info = 0;
2304         cam_status status;
2305         int error_code, sense_key, asc, ascq, error, aqvalid;
2306
2307         periph = xpt_path_periph(ccb->ccb_h.path);
2308         softc = (struct sa_softc *)periph->softc;
2309         csio = &ccb->csio;
2310         sense = &csio->sense_data;
2311         scsi_extract_sense(sense, &error_code, &sense_key, &asc, &ascq);
2312         aqvalid = sense->extra_len >= 6;
2313         error = 0;
2314
2315         status = csio->ccb_h.status & CAM_STATUS_MASK;
2316
2317         /*
2318          * Calculate/latch up, any residuals... We do this in a funny 2-step
2319          * so we can print stuff here if we have CAM_DEBUG enabled for this
2320          * unit.
2321          */
2322         if (status == CAM_SCSI_STATUS_ERROR) {
2323                 if ((sense->error_code & SSD_ERRCODE_VALID) != 0) {
2324                         info = (int32_t) scsi_4btoul(sense->info);
2325                         resid = info;
2326                         if ((softc->flags & SA_FLAG_FIXED) != 0)
2327                                 resid *= softc->media_blksize;
2328                 } else {
2329                         resid = csio->dxfer_len;
2330                         info = resid;
2331                         if ((softc->flags & SA_FLAG_FIXED) != 0) {
2332                                 if (softc->media_blksize)
2333                                         info /= softc->media_blksize;
2334                         }
2335                 }
2336                 if (CCB_Type(csio) == SA_CCB_BUFFER_IO) {
2337                         bcopy((caddr_t) sense, (caddr_t) &softc->last_io_sense,
2338                             sizeof (struct scsi_sense_data));
2339                         bcopy(csio->cdb_io.cdb_bytes, softc->last_io_cdb,
2340                             (int) csio->cdb_len);
2341                         softc->last_io_resid = resid;
2342                         softc->last_resid_was_io = 1;
2343                 } else {
2344                         bcopy((caddr_t) sense, (caddr_t) &softc->last_ctl_sense,
2345                             sizeof (struct scsi_sense_data));
2346                         bcopy(csio->cdb_io.cdb_bytes, softc->last_ctl_cdb,
2347                             (int) csio->cdb_len);
2348                         softc->last_ctl_resid = resid;
2349                         softc->last_resid_was_io = 0;
2350                 }
2351                 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, ("CDB[0]=0x%x Key 0x%x "
2352                     "ASC/ASCQ 0x%x/0x%x CAM STATUS 0x%x flags 0x%x resid %d "
2353                     "dxfer_len %d\n", csio->cdb_io.cdb_bytes[0] & 0xff,
2354                     sense_key, asc, ascq, status,
2355                     sense->flags & ~SSD_KEY_RESERVED, resid, csio->dxfer_len));
2356         } else {
2357                 CAM_DEBUG(periph->path, CAM_DEBUG_INFO,
2358                     ("Cam Status 0x%x\n", status));
2359         }
2360
2361         switch (status) {
2362         case CAM_REQ_CMP:
2363                 return (0);
2364         case CAM_SCSI_STATUS_ERROR:
2365                 /*
2366                  * If a read/write command, we handle it here.
2367                  */
2368                 if (CCB_Type(csio) != SA_CCB_WAITING) {
2369                         break;
2370                 }
2371                 /*
2372                  * If this was just EOM/EOP, Filemark, Setmark or ILI detected
2373                  * on a non read/write command, we assume it's not an error
2374                  * and propagate the residule and return.
2375                  */
2376                 if ((aqvalid && asc == 0 && ascq > 0 && ascq <= 5) ||
2377                     (aqvalid == 0 && sense_key == SSD_KEY_NO_SENSE)) {
2378                         csio->resid = resid;
2379                         QFRLS(ccb);
2380                         return (0);
2381                 }
2382                 /*
2383                  * Otherwise, we let the common code handle this.
2384                  */
2385                 return (cam_periph_error(ccb, cflgs, sflgs, &softc->saved_ccb));
2386
2387         /*
2388          * XXX: To Be Fixed
2389          * We cannot depend upon CAM honoring retry counts for these.
2390          */
2391         case CAM_SCSI_BUS_RESET:
2392         case CAM_BDR_SENT:
2393                 if (ccb->ccb_h.retry_count <= 0) {
2394                         return (EIO);
2395                         break;
2396                 }
2397                 /* FALLTHROUGH */
2398         default:
2399                 return (cam_periph_error(ccb, cflgs, sflgs, &softc->saved_ccb));
2400         }
2401
2402         /*
2403          * Handle filemark, end of tape, mismatched record sizes....
2404          * From this point out, we're only handling read/write cases.
2405          * Handle writes && reads differently.
2406          */
2407
2408         if (csio->cdb_io.cdb_bytes[0] == SA_WRITE) {
2409                 if (sense_key == SSD_KEY_VOLUME_OVERFLOW) {
2410                         csio->resid = resid;
2411                         error = ENOSPC;
2412                 } else if (sense->flags & SSD_EOM) {
2413                         softc->flags |= SA_FLAG_EOM_PENDING;
2414                         /*
2415                          * Grotesque as it seems, the few times
2416                          * I've actually seen a non-zero resid,
2417                          * the tape drive actually lied and had
2418                          * writtent all the data!.
2419                          */
2420                         csio->resid = 0;
2421                 }
2422         } else {
2423                 csio->resid = resid;
2424                 if (sense_key == SSD_KEY_BLANK_CHECK) {
2425                         if (softc->quirks & SA_QUIRK_1FM) {
2426                                 error = 0;
2427                                 softc->flags |= SA_FLAG_EOM_PENDING;
2428                         } else {
2429                                 error = EIO;
2430                         }
2431                 } else if (sense->flags & SSD_FILEMARK) {
2432                         if (softc->flags & SA_FLAG_FIXED) {
2433                                 error = -1;
2434                                 softc->flags |= SA_FLAG_EOF_PENDING;
2435                         }
2436                         /*
2437                          * Unconditionally, if we detected a filemark on a read,
2438                          * mark that we've run moved a file ahead.
2439                          */
2440                         if (softc->fileno != (daddr_t) -1) {
2441                                 softc->fileno++;
2442                                 softc->blkno = 0;
2443                                 csio->ccb_h.ccb_pflags |= SA_POSITION_UPDATED;
2444                         }
2445                 }
2446         }
2447
2448         /*
2449          * Incorrect Length usually applies to read, but can apply to writes.
2450          */
2451         if (error == 0 && (sense->flags & SSD_ILI)) {
2452                 if (info < 0) {
2453                         xpt_print_path(csio->ccb_h.path);
2454                         printf(toobig, csio->dxfer_len - info);
2455                         csio->resid = csio->dxfer_len;
2456                         error = EIO;
2457                 } else {
2458                         csio->resid = resid;
2459                         if (softc->flags & SA_FLAG_FIXED) {
2460                                 softc->flags |= SA_FLAG_EIO_PENDING;
2461                         }
2462                         /*
2463                          * Bump the block number if we hadn't seen a filemark.
2464                          * Do this independent of errors (we've moved anyway).
2465                          */
2466                         if ((sense->flags & SSD_FILEMARK) == 0) {
2467                                 if (softc->blkno != (daddr_t) -1) {
2468                                         softc->blkno++;
2469                                         csio->ccb_h.ccb_pflags |=
2470                                            SA_POSITION_UPDATED;
2471                                 }
2472                         }
2473                 }
2474         }
2475
2476         if (error <= 0) {
2477                 /*
2478                  * Unfreeze the queue if frozen as we're not returning anything
2479                  * to our waiters that would indicate an I/O error has occurred
2480                  * (yet).
2481                  */
2482                 QFRLS(ccb);
2483                 error = 0;
2484         }
2485         return (error);
2486 }
2487
2488 static int
2489 sagetparams(struct cam_periph *periph, sa_params params_to_get,
2490             u_int32_t *blocksize, u_int8_t *density, u_int32_t *numblocks,
2491             int *buff_mode, u_int8_t *write_protect, u_int8_t *speed,
2492             int *comp_supported, int *comp_enabled, u_int32_t *comp_algorithm,
2493             sa_comp_t *tcs)
2494 {
2495         union ccb *ccb;
2496         void *mode_buffer;
2497         struct scsi_mode_header_6 *mode_hdr;
2498         struct scsi_mode_blk_desc *mode_blk;
2499         int mode_buffer_len;
2500         struct sa_softc *softc;
2501         u_int8_t cpage;
2502         int error;
2503         cam_status status;
2504
2505         softc = (struct sa_softc *)periph->softc;
2506         ccb = cam_periph_getccb(periph, 1);
2507         if (softc->quirks & SA_QUIRK_NO_CPAGE)
2508                 cpage = SA_DEVICE_CONFIGURATION_PAGE;
2509         else
2510                 cpage = SA_DATA_COMPRESSION_PAGE;
2511
2512 retry:
2513         mode_buffer_len = sizeof(*mode_hdr) + sizeof(*mode_blk);
2514
2515         if (params_to_get & SA_PARAM_COMPRESSION) {
2516                 if (softc->quirks & SA_QUIRK_NOCOMP) {
2517                         *comp_supported = FALSE;
2518                         params_to_get &= ~SA_PARAM_COMPRESSION;
2519                 } else
2520                         mode_buffer_len += sizeof (sa_comp_t);
2521         }
2522
2523         mode_buffer = malloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
2524         mode_hdr = (struct scsi_mode_header_6 *)mode_buffer;
2525         mode_blk = (struct scsi_mode_blk_desc *)&mode_hdr[1];
2526
2527         /* it is safe to retry this */
2528         scsi_mode_sense(&ccb->csio, 5, sadone, MSG_SIMPLE_Q_TAG, FALSE,
2529             SMS_PAGE_CTRL_CURRENT, (params_to_get & SA_PARAM_COMPRESSION) ?
2530             cpage : SMS_VENDOR_SPECIFIC_PAGE, mode_buffer, mode_buffer_len,
2531             SSD_FULL_SIZE, SCSIOP_TIMEOUT);
2532
2533         error = cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
2534             &softc->device_stats);
2535         QFRLS(ccb);
2536
2537         status = ccb->ccb_h.status & CAM_STATUS_MASK;
2538
2539         if (error == EINVAL && (params_to_get & SA_PARAM_COMPRESSION) != 0) {
2540                 /*
2541                  * Hmm. Let's see if we can try another page...
2542                  * If we've already done that, give up on compression
2543                  * for this device and remember this for the future
2544                  * and attempt the request without asking for compression
2545                  * info.
2546                  */
2547                 if (cpage == SA_DATA_COMPRESSION_PAGE) {
2548                         cpage = SA_DEVICE_CONFIGURATION_PAGE;
2549                         goto retry;
2550                 }
2551                 softc->quirks |= SA_QUIRK_NOCOMP;
2552                 free(mode_buffer, M_TEMP);
2553                 goto retry;
2554         } else if (status == CAM_SCSI_STATUS_ERROR) {
2555                 /* Tell the user about the fatal error. */
2556                 scsi_sense_print(&ccb->csio);
2557                 goto sagetparamsexit;
2558         }
2559
2560         /*
2561          * If the user only wants the compression information, and
2562          * the device doesn't send back the block descriptor, it's
2563          * no big deal.  If the user wants more than just
2564          * compression, though, and the device doesn't pass back the
2565          * block descriptor, we need to send another mode sense to
2566          * get the block descriptor.
2567          */
2568         if ((mode_hdr->blk_desc_len == 0) &&
2569             (params_to_get & SA_PARAM_COMPRESSION) &&
2570             (params_to_get & ~(SA_PARAM_COMPRESSION))) {
2571
2572                 /*
2573                  * Decrease the mode buffer length by the size of
2574                  * the compression page, to make sure the data
2575                  * there doesn't get overwritten.
2576                  */
2577                 mode_buffer_len -= sizeof (sa_comp_t);
2578
2579                 /*
2580                  * Now move the compression page that we presumably
2581                  * got back down the memory chunk a little bit so
2582                  * it doesn't get spammed.
2583                  */
2584                 bcopy(&mode_hdr[0], &mode_hdr[1], sizeof (sa_comp_t));
2585                 bzero(&mode_hdr[0], sizeof (mode_hdr[0]));
2586
2587                 /*
2588                  * Now, we issue another mode sense and just ask
2589                  * for the block descriptor, etc.
2590                  */
2591
2592                 scsi_mode_sense(&ccb->csio, 2, sadone, MSG_SIMPLE_Q_TAG, FALSE,
2593                     SMS_PAGE_CTRL_CURRENT, SMS_VENDOR_SPECIFIC_PAGE,
2594                     mode_buffer, mode_buffer_len, SSD_FULL_SIZE,
2595                     SCSIOP_TIMEOUT);
2596
2597                 error = cam_periph_runccb(ccb, saerror, 0, SF_NO_PRINT,
2598                     &softc->device_stats);
2599                 QFRLS(ccb);
2600
2601                 if (error != 0)
2602                         goto sagetparamsexit;
2603         }
2604
2605         if (params_to_get & SA_PARAM_BLOCKSIZE)
2606                 *blocksize = scsi_3btoul(mode_blk->blklen);
2607
2608         if (params_to_get & SA_PARAM_NUMBLOCKS)
2609                 *numblocks = scsi_3btoul(mode_blk->nblocks);
2610
2611         if (params_to_get & SA_PARAM_BUFF_MODE)
2612                 *buff_mode = mode_hdr->dev_spec & SMH_SA_BUF_MODE_MASK;
2613
2614         if (params_to_get & SA_PARAM_DENSITY)
2615                 *density = mode_blk->density;
2616
2617         if (params_to_get & SA_PARAM_WP)
2618                 *write_protect = (mode_hdr->dev_spec & SMH_SA_WP)? TRUE : FALSE;
2619
2620         if (params_to_get & SA_PARAM_SPEED)
2621                 *speed = mode_hdr->dev_spec & SMH_SA_SPEED_MASK;
2622
2623         if (params_to_get & SA_PARAM_COMPRESSION) {
2624                 sa_comp_t *ntcs = (sa_comp_t *) &mode_blk[1];
2625                 if (cpage == SA_DATA_COMPRESSION_PAGE) {
2626                         struct scsi_data_compression_page *cp = &ntcs->dcomp;
2627                         *comp_supported =
2628                             (cp->dce_and_dcc & SA_DCP_DCC)? TRUE : FALSE;
2629                         *comp_enabled =
2630                             (cp->dce_and_dcc & SA_DCP_DCE)? TRUE : FALSE;
2631                         *comp_algorithm = scsi_4btoul(cp->comp_algorithm);
2632                 } else {
2633                         struct scsi_dev_conf_page *cp = &ntcs->dconf;
2634                         /*
2635                          * We don't really know whether this device supports
2636                          * Data Compression if the the algorithm field is
2637                          * zero. Just say we do.
2638                          */
2639                         *comp_supported = TRUE;
2640                         *comp_enabled =
2641                             (cp->sel_comp_alg != SA_COMP_NONE)? TRUE : FALSE;
2642                         *comp_algorithm = cp->sel_comp_alg;
2643                 }
2644                 if (tcs != NULL)
2645                         bcopy(ntcs, tcs, sizeof (sa_comp_t));
2646         }
2647
2648         if (CAM_DEBUGGED(periph->path, CAM_DEBUG_INFO)) {
2649                 int idx;
2650                 char *xyz = mode_buffer;
2651                 xpt_print_path(periph->path);
2652                 printf("Mode Sense Data=");
2653                 for (idx = 0; idx < mode_buffer_len; idx++)
2654                         printf(" 0x%02x", xyz[idx] & 0xff);
2655                 printf("\n");
2656         }
2657
2658 sagetparamsexit:
2659
2660         xpt_release_ccb(ccb);
2661         free(mode_buffer, M_TEMP);
2662         return (error);
2663 }
2664
2665 /*
2666  * The purpose of this function is to set one of four different parameters
2667  * for a tape drive:
2668  *      - blocksize
2669  *      - density
2670  *      - compression / compression algorithm
2671  *      - buffering mode
2672  *
2673  * The assumption is that this will be called from saioctl(), and therefore
2674  * from a process context.  Thus the waiting malloc calls below.  If that
2675  * assumption ever changes, the malloc calls should be changed to be
2676  * NOWAIT mallocs.
2677  *
2678  * Any or all of the four parameters may be set when this function is
2679  * called.  It should handle setting more than one parameter at once.
2680  */
2681 static int
2682 sasetparams(struct cam_periph *periph, sa_params params_to_set,
2683             u_int32_t blocksize, u_int8_t density, u_int32_t calg,
2684             u_int32_t sense_flags)
2685 {
2686         struct sa_softc *softc;
2687         u_int32_t current_blocksize;
2688         u_int32_t current_calg;
2689         u_int8_t current_density;
2690         u_int8_t current_speed;
2691         int comp_enabled, comp_supported;
2692         void *mode_buffer;
2693         int mode_buffer_len;
2694         struct scsi_mode_header_6 *mode_hdr;
2695         struct scsi_mode_blk_desc *mode_blk;
2696         sa_comp_t *ccomp, *cpage;
2697         int buff_mode;
2698         union ccb *ccb = NULL;
2699         int error;
2700
2701         softc = (struct sa_softc *)periph->softc;
2702
2703         ccomp = malloc(sizeof (sa_comp_t), M_TEMP, M_INTWAIT);
2704
2705         /*
2706          * Since it doesn't make sense to set the number of blocks, or
2707          * write protection, we won't try to get the current value.  We
2708          * always want to get the blocksize, so we can set it back to the
2709          * proper value.
2710          */
2711         error = sagetparams(periph,
2712             params_to_set | SA_PARAM_BLOCKSIZE | SA_PARAM_SPEED,
2713             &current_blocksize, &current_density, NULL, &buff_mode, NULL,
2714             &current_speed, &comp_supported, &comp_enabled,
2715             &current_calg, ccomp);
2716
2717         if (error != 0) {
2718                 free(ccomp, M_TEMP);
2719                 return (error);
2720         }
2721
2722         mode_buffer_len = sizeof(*mode_hdr) + sizeof(*mode_blk);
2723         if (params_to_set & SA_PARAM_COMPRESSION)
2724                 mode_buffer_len += sizeof (sa_comp_t);
2725
2726         mode_buffer = malloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
2727
2728         mode_hdr = (struct scsi_mode_header_6 *)mode_buffer;
2729         mode_blk = (struct scsi_mode_blk_desc *)&mode_hdr[1];
2730
2731         ccb = cam_periph_getccb(periph, 1);
2732
2733 retry:
2734
2735         if (params_to_set & SA_PARAM_COMPRESSION) {
2736                 if (mode_blk) {
2737                         cpage = (sa_comp_t *)&mode_blk[1];
2738                 } else {
2739                         cpage = (sa_comp_t *)&mode_hdr[1];
2740                 }
2741                 bcopy(ccomp, cpage, sizeof (sa_comp_t));
2742                 cpage->hdr.pagecode &= ~0x80;
2743         } else
2744                 cpage = NULL;
2745
2746         /*
2747          * If the caller wants us to set the blocksize, use the one they
2748          * pass in.  Otherwise, use the blocksize we got back from the
2749          * mode select above.
2750          */
2751         if (mode_blk) {
2752                 if (params_to_set & SA_PARAM_BLOCKSIZE)
2753                         scsi_ulto3b(blocksize, mode_blk->blklen);
2754                 else
2755                         scsi_ulto3b(current_blocksize, mode_blk->blklen);
2756
2757                 /*
2758                  * Set density if requested, else preserve old density.
2759                  * SCSI_SAME_DENSITY only applies to SCSI-2 or better
2760                  * devices, else density we've latched up in our softc.
2761                  */
2762                 if (params_to_set & SA_PARAM_DENSITY) {
2763                         mode_blk->density = density;
2764                 } else if (softc->scsi_rev > SCSI_REV_CCS) {
2765                         mode_blk->density = SCSI_SAME_DENSITY;
2766                 } else {
2767                         mode_blk->density = softc->media_density;
2768                 }
2769         }
2770
2771         /*
2772          * For mode selects, these two fields must be zero.
2773          */
2774         mode_hdr->data_length = 0;
2775         mode_hdr->medium_type = 0;
2776
2777         /* set the speed to the current value */
2778         mode_hdr->dev_spec = current_speed;
2779
2780         /* set single-initiator buffering mode */
2781         mode_hdr->dev_spec |= SMH_SA_BUF_MODE_SIBUF;
2782
2783         if (mode_blk)
2784                 mode_hdr->blk_desc_len = sizeof(struct scsi_mode_blk_desc);
2785         else
2786                 mode_hdr->blk_desc_len = 0;
2787
2788         /*
2789          * First, if the user wants us to set the compression algorithm or
2790          * just turn compression on, check to make sure that this drive
2791          * supports compression.
2792          */
2793         if (params_to_set & SA_PARAM_COMPRESSION) {
2794                 /*
2795                  * If the compression algorithm is 0, disable compression.
2796                  * If the compression algorithm is non-zero, enable
2797                  * compression and set the compression type to the
2798                  * specified compression algorithm, unless the algorithm is
2799                  * MT_COMP_ENABLE.  In that case, we look at the
2800                  * compression algorithm that is currently set and if it is
2801                  * non-zero, we leave it as-is.  If it is zero, and we have
2802                  * saved a compression algorithm from a time when
2803                  * compression was enabled before, set the compression to
2804                  * the saved value.
2805                  */
2806                 switch (ccomp->hdr.pagecode & ~0x80) {
2807                 case SA_DATA_COMPRESSION_PAGE:
2808                 if (ccomp->dcomp.dce_and_dcc & SA_DCP_DCC) {
2809                         struct scsi_data_compression_page *dcp = &cpage->dcomp;
2810                         if (calg == 0) {
2811                                 /*
2812                                  * Disable compression, but leave the
2813                                  * decompression and the capability bit
2814                                  * alone.
2815                                  */
2816                                 dcp->dce_and_dcc = SA_DCP_DCC;
2817                                 dcp->dde_and_red |= SA_DCP_DDE;
2818                                 break;
2819                         }
2820                         /* enable compression && decompression */
2821                         dcp->dce_and_dcc = SA_DCP_DCE | SA_DCP_DCC;
2822                         dcp->dde_and_red |= SA_DCP_DDE;
2823                         /*
2824                          * If there, use compression algorithm from caller.
2825                          * Otherwise, if there's a saved compression algorithm
2826                          * and there is no current algorithm, use the saved
2827                          * algorithm. Else parrot back what we got and hope
2828                          * for the best.
2829                          */
2830                         if (calg != MT_COMP_ENABLE) {
2831                                 scsi_ulto4b(calg, dcp->comp_algorithm);
2832                                 scsi_ulto4b(calg, dcp->decomp_algorithm);
2833                         } else if (scsi_4btoul(dcp->comp_algorithm) == 0 &&
2834                             softc->saved_comp_algorithm != 0) {
2835                                 scsi_ulto4b(softc->saved_comp_algorithm,
2836                                     dcp->comp_algorithm);
2837                                 scsi_ulto4b(softc->saved_comp_algorithm,
2838                                     dcp->decomp_algorithm);
2839                         }
2840                         break;
2841                 }
2842                 case SA_DEVICE_CONFIGURATION_PAGE:
2843                 {
2844                         struct scsi_dev_conf_page *dcp = &cpage->dconf;
2845                         if (calg == 0) {
2846                                 dcp->sel_comp_alg = SA_COMP_NONE;
2847                                 break;
2848                         }
2849                         if (calg != MT_COMP_ENABLE) {
2850                                 dcp->sel_comp_alg = calg;
2851                         } else if (dcp->sel_comp_alg == SA_COMP_NONE &&
2852                             softc->saved_comp_algorithm != 0) {
2853                                 dcp->sel_comp_alg = softc->saved_comp_algorithm;
2854                         }
2855                         break;
2856                 }
2857                 default:
2858                         /*
2859                          * The drive doesn't seem to support compression,
2860                          * so turn off the set compression bit.
2861                          */
2862                         params_to_set &= ~SA_PARAM_COMPRESSION;
2863                         xpt_print_path(periph->path);
2864                         printf("device does not seem to support compression\n");
2865
2866                         /*
2867                          * If that was the only thing the user wanted us to set,
2868                          * clean up allocated resources and return with
2869                          * 'operation not supported'.
2870                          */
2871                         if (params_to_set == SA_PARAM_NONE) {
2872                                 free(mode_buffer, M_TEMP);
2873                                 xpt_release_ccb(ccb);
2874                                 return (ENODEV);
2875                         }
2876
2877                         /*
2878                          * That wasn't the only thing the user wanted us to set.
2879                          * So, decrease the stated mode buffer length by the
2880                          * size of the compression mode page.
2881                          */
2882                         mode_buffer_len -= sizeof(sa_comp_t);
2883                 }
2884         }
2885
2886         /* It is safe to retry this operation */
2887         scsi_mode_select(&ccb->csio, 5, sadone, MSG_SIMPLE_Q_TAG,
2888             (params_to_set & SA_PARAM_COMPRESSION)? TRUE : FALSE,
2889             FALSE, mode_buffer, mode_buffer_len, SSD_FULL_SIZE, SCSIOP_TIMEOUT);
2890
2891         error = cam_periph_runccb(ccb, saerror, 0,
2892             sense_flags, &softc->device_stats);
2893         QFRLS(ccb);
2894
2895         if (CAM_DEBUGGED(periph->path, CAM_DEBUG_INFO)) {
2896                 int idx;
2897                 char *xyz = mode_buffer;
2898                 xpt_print_path(periph->path);
2899                 printf("Err%d, Mode Select Data=", error);
2900                 for (idx = 0; idx < mode_buffer_len; idx++)
2901                         printf(" 0x%02x", xyz[idx] & 0xff);
2902                 printf("\n");
2903         }
2904
2905
2906         if (error) {
2907                 /*
2908                  * If we can, try without setting density/blocksize.
2909                  */
2910                 if (mode_blk) {
2911                         if ((params_to_set &
2912                             (SA_PARAM_DENSITY|SA_PARAM_BLOCKSIZE)) == 0) {
2913                                 mode_blk = NULL;
2914                                 goto retry;
2915                         }
2916                 } else {
2917                         mode_blk = (struct scsi_mode_blk_desc *)&mode_hdr[1];
2918                         cpage = (sa_comp_t *)&mode_blk[1];
2919                 }
2920
2921                 /*
2922                  * If we were setting the blocksize, and that failed, we
2923                  * want to set it to its original value.  If we weren't
2924                  * setting the blocksize, we don't want to change it.
2925                  */
2926                 scsi_ulto3b(current_blocksize, mode_blk->blklen);
2927
2928                 /*
2929                  * Set density if requested, else preserve old density.
2930                  * SCSI_SAME_DENSITY only applies to SCSI-2 or better
2931                  * devices, else density we've latched up in our softc.
2932                  */
2933                 if (params_to_set & SA_PARAM_DENSITY) {
2934                         mode_blk->density = current_density;
2935                 } else if (softc->scsi_rev > SCSI_REV_CCS) {
2936                         mode_blk->density = SCSI_SAME_DENSITY;
2937                 } else {
2938                         mode_blk->density = softc->media_density;
2939                 }
2940
2941                 if (params_to_set & SA_PARAM_COMPRESSION)
2942                         bcopy(ccomp, cpage, sizeof (sa_comp_t));
2943
2944                 /*
2945                  * The retry count is the only CCB field that might have been
2946                  * changed that we care about, so reset it back to 1.
2947                  */
2948                 ccb->ccb_h.retry_count = 1;
2949                 cam_periph_runccb(ccb, saerror, 0, sense_flags,
2950                     &softc->device_stats);
2951                 QFRLS(ccb);
2952         }
2953
2954         xpt_release_ccb(ccb);
2955
2956         if (ccomp != NULL)
2957                 free(ccomp, M_TEMP);
2958
2959         if (params_to_set & SA_PARAM_COMPRESSION) {
2960                 if (error) {
2961                         softc->flags &= ~SA_FLAG_COMP_ENABLED;
2962                         /*
2963                          * Even if we get an error setting compression,
2964                          * do not say that we don't support it. We could
2965                          * have been wrong, or it may be media specific.
2966                          *      softc->flags &= ~SA_FLAG_COMP_SUPP;
2967                          */
2968                         softc->saved_comp_algorithm = softc->comp_algorithm;
2969                         softc->comp_algorithm = 0;
2970                 } else {
2971                         softc->flags |= SA_FLAG_COMP_ENABLED;
2972                         softc->comp_algorithm = calg;
2973                 }
2974         }
2975
2976         free(mode_buffer, M_TEMP);
2977         return (error);
2978 }
2979
2980 static void
2981 saprevent(struct cam_periph *periph, int action)
2982 {
2983         struct  sa_softc *softc;
2984         union   ccb *ccb;
2985         int     error, sf;
2986
2987         softc = (struct sa_softc *)periph->softc;
2988
2989         if ((action == PR_ALLOW) && (softc->flags & SA_FLAG_TAPE_LOCKED) == 0)
2990                 return;
2991         if ((action == PR_PREVENT) && (softc->flags & SA_FLAG_TAPE_LOCKED) != 0)
2992                 return;
2993
2994         /*
2995          * We can be quiet about illegal requests.
2996          */
2997         if (CAM_DEBUGGED(periph->path, CAM_DEBUG_INFO)) {
2998                 sf = 0;
2999         } else
3000                 sf = SF_QUIET_IR;
3001
3002         ccb = cam_periph_getccb(periph, 1);
3003
3004         /* It is safe to retry this operation */
3005         scsi_prevent(&ccb->csio, 5, sadone, MSG_SIMPLE_Q_TAG, action,
3006             SSD_FULL_SIZE, SCSIOP_TIMEOUT);
3007
3008         error = cam_periph_runccb(ccb, saerror, 0, sf, &softc->device_stats);
3009         QFRLS(ccb);
3010         if (error == 0) {
3011                 if (action == PR_ALLOW)
3012                         softc->flags &= ~SA_FLAG_TAPE_LOCKED;
3013                 else
3014                         softc->flags |= SA_FLAG_TAPE_LOCKED;
3015         }
3016
3017         xpt_release_ccb(ccb);
3018 }
3019
3020 static int
3021 sarewind(struct cam_periph *periph)
3022 {
3023         union   ccb *ccb;
3024         struct  sa_softc *softc;
3025         int     error;
3026
3027         softc = (struct sa_softc *)periph->softc;
3028
3029         ccb = cam_periph_getccb(periph, 1);
3030
3031         /* It is safe to retry this operation */
3032         scsi_rewind(&ccb->csio, 2, sadone, MSG_SIMPLE_Q_TAG, FALSE,
3033             SSD_FULL_SIZE, REWIND_TIMEOUT);
3034
3035         softc->dsreg = MTIO_DSREG_REW;
3036         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3037         softc->dsreg = MTIO_DSREG_REST;
3038
3039         if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
3040                 cam_release_devq(ccb->ccb_h.path, 0, 0, 0, FALSE);
3041
3042         xpt_release_ccb(ccb);
3043         if (error == 0)
3044                 softc->fileno = softc->blkno = (daddr_t) 0;
3045         else
3046                 softc->fileno = softc->blkno = (daddr_t) -1;
3047         return (error);
3048 }
3049
3050 static int
3051 saspace(struct cam_periph *periph, int count, scsi_space_code code)
3052 {
3053         union   ccb *ccb;
3054         struct  sa_softc *softc;
3055         int     error;
3056
3057         softc = (struct sa_softc *)periph->softc;
3058
3059         ccb = cam_periph_getccb(periph, 1);
3060
3061         /* This cannot be retried */
3062
3063         scsi_space(&ccb->csio, 0, sadone, MSG_SIMPLE_Q_TAG, code, count,
3064             SSD_FULL_SIZE, SPACE_TIMEOUT);
3065
3066         /*
3067          * Clear residual because we will be using it.
3068          */
3069         softc->last_ctl_resid = 0;
3070
3071         softc->dsreg = (count < 0)? MTIO_DSREG_REV : MTIO_DSREG_FWD;
3072         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3073         softc->dsreg = MTIO_DSREG_REST;
3074
3075         if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
3076                 cam_release_devq(ccb->ccb_h.path, 0, 0, 0, FALSE);
3077
3078         xpt_release_ccb(ccb);
3079
3080         /*
3081          * If a spacing operation has failed, we need to invalidate
3082          * this mount.
3083          *
3084          * If the spacing operation was setmarks or to end of recorded data,
3085          * we no longer know our relative position.
3086          *
3087          * If the spacing operations was spacing files in reverse, we
3088          * take account of the residual, but still check against less
3089          * than zero- if we've gone negative, we must have hit BOT.
3090          *
3091          * If the spacing operations was spacing records in reverse and
3092          * we have a residual, we've either hit BOT or hit a filemark.
3093          * In the former case, we know our new record number (0). In
3094          * the latter case, we have absolutely no idea what the real
3095          * record number is- we've stopped between the end of the last
3096          * record in the previous file and the filemark that stopped
3097          * our spacing backwards.
3098          */
3099         if (error) {
3100                 softc->fileno = softc->blkno = (daddr_t) -1;
3101         } else if (code == SS_SETMARKS || code == SS_EOD) {
3102                 softc->fileno = softc->blkno = (daddr_t) -1;
3103         } else if (code == SS_FILEMARKS && softc->fileno != (daddr_t) -1) {
3104                 softc->fileno += (count - softc->last_ctl_resid);
3105                 if (softc->fileno < 0)  /* we must of hit BOT */
3106                         softc->fileno = 0;
3107                 softc->blkno = 0;
3108         } else if (code == SS_BLOCKS && softc->blkno != (daddr_t) -1) {
3109                 softc->blkno += (count - softc->last_ctl_resid);
3110                 if (count < 0) {
3111                         if (softc->last_ctl_resid || softc->blkno < 0) {
3112                                 if (softc->fileno == 0) {
3113                                         softc->blkno = 0;
3114                                 } else {
3115                                         softc->blkno = (daddr_t) -1;
3116                                 }
3117                         }
3118                 }
3119         }
3120         return (error);
3121 }
3122
3123 static int
3124 sawritefilemarks(struct cam_periph *periph, int nmarks, int setmarks)
3125 {
3126         union   ccb *ccb;
3127         struct  sa_softc *softc;
3128         int     error, nwm = 0;
3129
3130         softc = (struct sa_softc *)periph->softc;
3131
3132         ccb = cam_periph_getccb(periph, 1);
3133         /*
3134          * Clear residual because we will be using it.
3135          */
3136         softc->last_ctl_resid = 0;
3137
3138         softc->dsreg = MTIO_DSREG_FMK;
3139         /* this *must* not be retried */
3140         scsi_write_filemarks(&ccb->csio, 0, sadone, MSG_SIMPLE_Q_TAG,
3141             FALSE, setmarks, nmarks, SSD_FULL_SIZE, IO_TIMEOUT);
3142         softc->dsreg = MTIO_DSREG_REST;
3143
3144
3145         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3146
3147         if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
3148                 cam_release_devq(ccb->ccb_h.path, 0, 0, 0, FALSE);
3149
3150         if (error == 0 && nmarks) {
3151                 struct sa_softc *softc = (struct sa_softc *)periph->softc;
3152                 nwm = nmarks - softc->last_ctl_resid;
3153                 softc->filemarks += nwm;
3154         }
3155
3156         xpt_release_ccb(ccb);
3157
3158         /*
3159          * Update relative positions (if we're doing that).
3160          */
3161         if (error) {
3162                 softc->fileno = softc->blkno = (daddr_t) -1;
3163         } else if (softc->fileno != (daddr_t) -1) {
3164                 softc->fileno += nwm;
3165                 softc->blkno = 0;
3166         }
3167         return (error);
3168 }
3169
3170 static int
3171 sardpos(struct cam_periph *periph, int hard, u_int32_t *blkptr)
3172 {
3173         struct scsi_tape_position_data loc;
3174         union ccb *ccb;
3175         struct sa_softc *softc = (struct sa_softc *)periph->softc;
3176         int error;
3177
3178         /*
3179          * We try and flush any buffered writes here if we were writing
3180          * and we're trying to get hardware block position. It eats
3181          * up performance substantially, but I'm wary of drive firmware.
3182          *
3183          * I think that *logical* block position is probably okay-
3184          * but hardware block position might have to wait for data
3185          * to hit media to be valid. Caveat Emptor.
3186          */
3187
3188         if (hard && (softc->flags & SA_FLAG_TAPE_WRITTEN)) {
3189                 error = sawritefilemarks(periph, 0, 0);
3190                 if (error && error != EACCES)
3191                         return (error);
3192         }
3193
3194         ccb = cam_periph_getccb(periph, 1);
3195         scsi_read_position(&ccb->csio, 1, sadone, MSG_SIMPLE_Q_TAG,
3196             hard, &loc, SSD_FULL_SIZE, SCSIOP_TIMEOUT);
3197         softc->dsreg = MTIO_DSREG_RBSY;
3198         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3199         softc->dsreg = MTIO_DSREG_REST;
3200         if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
3201                 cam_release_devq(ccb->ccb_h.path, 0, 0, 0, 0);
3202
3203         if (error == 0) {
3204                 if (loc.flags & SA_RPOS_UNCERTAIN) {
3205                         error = EINVAL;         /* nothing is certain */
3206                 } else {
3207                         *blkptr = scsi_4btoul(loc.firstblk);
3208                 }
3209         }
3210
3211         xpt_release_ccb(ccb);
3212         return (error);
3213 }
3214
3215 static int
3216 sasetpos(struct cam_periph *periph, int hard, u_int32_t *blkptr)
3217 {
3218         union ccb *ccb;
3219         struct sa_softc *softc;
3220         int error;
3221
3222         /*
3223          * We used to try and flush any buffered writes here.
3224          * Now we push this onto user applications to either
3225          * flush the pending writes themselves (via a zero count
3226          * WRITE FILEMARKS command) or they can trust their tape
3227          * drive to do this correctly for them.
3228          */
3229
3230         softc = (struct sa_softc *)periph->softc;
3231         ccb = cam_periph_getccb(periph, 1);
3232
3233
3234         scsi_set_position(&ccb->csio, 1, sadone, MSG_SIMPLE_Q_TAG,
3235             hard, *blkptr, SSD_FULL_SIZE, SPACE_TIMEOUT);
3236
3237
3238         softc->dsreg = MTIO_DSREG_POS;
3239         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3240         softc->dsreg = MTIO_DSREG_REST;
3241         if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
3242                 cam_release_devq(ccb->ccb_h.path, 0, 0, 0, 0);
3243         xpt_release_ccb(ccb);
3244         /*
3245          * Note relative file && block number position as now unknown.
3246          */
3247         softc->fileno = softc->blkno = (daddr_t) -1;
3248         return (error);
3249 }
3250
3251 static int
3252 saretension(struct cam_periph *periph)
3253 {
3254         union ccb *ccb;
3255         struct sa_softc *softc;
3256         int error;
3257
3258         softc = (struct sa_softc *)periph->softc;
3259
3260         ccb = cam_periph_getccb(periph, 1);
3261
3262         /* It is safe to retry this operation */
3263         scsi_load_unload(&ccb->csio, 5, sadone, MSG_SIMPLE_Q_TAG, FALSE,
3264             FALSE, TRUE,  TRUE, SSD_FULL_SIZE, ERASE_TIMEOUT);
3265
3266         softc->dsreg = MTIO_DSREG_TEN;
3267         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3268         softc->dsreg = MTIO_DSREG_REST;
3269
3270         if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
3271                 cam_release_devq(ccb->ccb_h.path, 0, 0, 0, FALSE);
3272         xpt_release_ccb(ccb);
3273         if (error == 0)
3274                 softc->fileno = softc->blkno = (daddr_t) 0;
3275         else
3276                 softc->fileno = softc->blkno = (daddr_t) -1;
3277         return (error);
3278 }
3279
3280 static int
3281 sareservereleaseunit(struct cam_periph *periph, int reserve)
3282 {
3283         union ccb *ccb;
3284         struct sa_softc *softc;
3285         int error;
3286
3287         softc = (struct sa_softc *)periph->softc;
3288         ccb = cam_periph_getccb(periph,  1);
3289
3290         /* It is safe to retry this operation */
3291         scsi_reserve_release_unit(&ccb->csio, 2, sadone, MSG_SIMPLE_Q_TAG,
3292             FALSE,  0, SSD_FULL_SIZE,  SCSIOP_TIMEOUT, reserve);
3293         softc->dsreg = MTIO_DSREG_RBSY;
3294         error = cam_periph_runccb(ccb, saerror, 0,
3295             SF_RETRY_UA | SF_NO_PRINT, &softc->device_stats);
3296         softc->dsreg = MTIO_DSREG_REST;
3297         QFRLS(ccb);
3298         xpt_release_ccb(ccb);
3299
3300         /*
3301          * If the error was Illegal Request, then the device doesn't support
3302          * RESERVE/RELEASE. This is not an error.
3303          */
3304         if (error == EINVAL) {
3305                 error = 0;
3306         }
3307
3308         return (error);
3309 }
3310
3311 static int
3312 saloadunload(struct cam_periph *periph, int load)
3313 {
3314         union   ccb *ccb;
3315         struct  sa_softc *softc;
3316         int     error;
3317
3318         softc = (struct sa_softc *)periph->softc;
3319
3320         ccb = cam_periph_getccb(periph, 1);
3321
3322         /* It is safe to retry this operation */
3323         scsi_load_unload(&ccb->csio, 5, sadone, MSG_SIMPLE_Q_TAG, FALSE,
3324             FALSE, FALSE, load, SSD_FULL_SIZE, REWIND_TIMEOUT);
3325
3326         softc->dsreg = (load)? MTIO_DSREG_LD : MTIO_DSREG_UNL;
3327         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3328         softc->dsreg = MTIO_DSREG_REST;
3329         QFRLS(ccb);
3330         xpt_release_ccb(ccb);
3331
3332         if (error || load == 0)
3333                 softc->fileno = softc->blkno = (daddr_t) -1;
3334         else if (error == 0)
3335                 softc->fileno = softc->blkno = (daddr_t) 0;
3336         return (error);
3337 }
3338
3339 static int
3340 saerase(struct cam_periph *periph, int longerase)
3341 {
3342
3343         union   ccb *ccb;
3344         struct  sa_softc *softc;
3345         int error;
3346
3347         softc = (struct sa_softc *)periph->softc;
3348
3349         ccb = cam_periph_getccb(periph, 1);
3350
3351         scsi_erase(&ccb->csio, 1, sadone, MSG_SIMPLE_Q_TAG, FALSE, longerase,
3352             SSD_FULL_SIZE, ERASE_TIMEOUT);
3353
3354         softc->dsreg = MTIO_DSREG_ZER;
3355         error = cam_periph_runccb(ccb, saerror, 0, 0, &softc->device_stats);
3356         softc->dsreg = MTIO_DSREG_REST;
3357
3358         if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
3359                 cam_release_devq(ccb->ccb_h.path, 0, 0, 0, FALSE);
3360         xpt_release_ccb(ccb);
3361         return (error);
3362 }
3363
3364 #endif /* _KERNEL */
3365
3366 /*
3367  * Read tape block limits command.
3368  */
3369 void
3370 scsi_read_block_limits(struct ccb_scsiio *csio, u_int32_t retries,
3371                    void (*cbfcnp)(struct cam_periph *, union ccb *),
3372                    u_int8_t tag_action,
3373                    struct scsi_read_block_limits_data *rlimit_buf,
3374                    u_int8_t sense_len, u_int32_t timeout)
3375 {
3376         struct scsi_read_block_limits *scsi_cmd;
3377
3378         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_IN, tag_action,
3379              (u_int8_t *)rlimit_buf, sizeof(*rlimit_buf), sense_len,
3380              sizeof(*scsi_cmd), timeout);
3381
3382         scsi_cmd = (struct scsi_read_block_limits *)&csio->cdb_io.cdb_bytes;
3383         bzero(scsi_cmd, sizeof(*scsi_cmd));
3384         scsi_cmd->opcode = READ_BLOCK_LIMITS;
3385 }
3386
3387 void
3388 scsi_sa_read_write(struct ccb_scsiio *csio, u_int32_t retries,
3389                    void (*cbfcnp)(struct cam_periph *, union ccb *),
3390                    u_int8_t tag_action, int readop, int sli,
3391                    int fixed, u_int32_t length, u_int8_t *data_ptr,
3392                    u_int32_t dxfer_len, u_int8_t sense_len, u_int32_t timeout)
3393 {
3394         struct scsi_sa_rw *scsi_cmd;
3395
3396         scsi_cmd = (struct scsi_sa_rw *)&csio->cdb_io.cdb_bytes;
3397         scsi_cmd->opcode = readop ? SA_READ : SA_WRITE;
3398         scsi_cmd->sli_fixed = 0;
3399         if (sli && readop)
3400                 scsi_cmd->sli_fixed |= SAR_SLI;
3401         if (fixed)
3402                 scsi_cmd->sli_fixed |= SARW_FIXED;
3403         scsi_ulto3b(length, scsi_cmd->length);
3404         scsi_cmd->control = 0;
3405
3406         cam_fill_csio(csio, retries, cbfcnp, readop ? CAM_DIR_IN : CAM_DIR_OUT,
3407             tag_action, data_ptr, dxfer_len, sense_len,
3408             sizeof(*scsi_cmd), timeout);
3409 }
3410
3411 void
3412 scsi_load_unload(struct ccb_scsiio *csio, u_int32_t retries,
3413                  void (*cbfcnp)(struct cam_periph *, union ccb *),
3414                  u_int8_t tag_action, int immediate, int eot,
3415                  int reten, int load, u_int8_t sense_len,
3416                  u_int32_t timeout)
3417 {
3418         struct scsi_load_unload *scsi_cmd;
3419
3420         scsi_cmd = (struct scsi_load_unload *)&csio->cdb_io.cdb_bytes;
3421         bzero(scsi_cmd, sizeof(*scsi_cmd));
3422         scsi_cmd->opcode = LOAD_UNLOAD;
3423         if (immediate)
3424                 scsi_cmd->immediate = SLU_IMMED;
3425         if (eot)
3426                 scsi_cmd->eot_reten_load |= SLU_EOT;
3427         if (reten)
3428                 scsi_cmd->eot_reten_load |= SLU_RETEN;
3429         if (load)
3430                 scsi_cmd->eot_reten_load |= SLU_LOAD;
3431
3432         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_NONE, tag_action,
3433             NULL, 0, sense_len, sizeof(*scsi_cmd), timeout);
3434 }
3435
3436 void
3437 scsi_rewind(struct ccb_scsiio *csio, u_int32_t retries,
3438             void (*cbfcnp)(struct cam_periph *, union ccb *),
3439             u_int8_t tag_action, int immediate, u_int8_t sense_len,
3440             u_int32_t timeout)
3441 {
3442         struct scsi_rewind *scsi_cmd;
3443
3444         scsi_cmd = (struct scsi_rewind *)&csio->cdb_io.cdb_bytes;
3445         bzero(scsi_cmd, sizeof(*scsi_cmd));
3446         scsi_cmd->opcode = REWIND;
3447         if (immediate)
3448                 scsi_cmd->immediate = SREW_IMMED;
3449
3450         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_NONE, tag_action, NULL,
3451             0, sense_len, sizeof(*scsi_cmd), timeout);
3452 }
3453
3454 void
3455 scsi_space(struct ccb_scsiio *csio, u_int32_t retries,
3456            void (*cbfcnp)(struct cam_periph *, union ccb *),
3457            u_int8_t tag_action, scsi_space_code code,
3458            u_int32_t count, u_int8_t sense_len, u_int32_t timeout)
3459 {
3460         struct scsi_space *scsi_cmd;
3461
3462         scsi_cmd = (struct scsi_space *)&csio->cdb_io.cdb_bytes;
3463         scsi_cmd->opcode = SPACE;
3464         scsi_cmd->code = code;
3465         scsi_ulto3b(count, scsi_cmd->count);
3466         scsi_cmd->control = 0;
3467
3468         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_NONE, tag_action, NULL,
3469             0, sense_len, sizeof(*scsi_cmd), timeout);
3470 }
3471
3472 void
3473 scsi_write_filemarks(struct ccb_scsiio *csio, u_int32_t retries,
3474                      void (*cbfcnp)(struct cam_periph *, union ccb *),
3475                      u_int8_t tag_action, int immediate, int setmark,
3476                      u_int32_t num_marks, u_int8_t sense_len,
3477                      u_int32_t timeout)
3478 {
3479         struct scsi_write_filemarks *scsi_cmd;
3480
3481         scsi_cmd = (struct scsi_write_filemarks *)&csio->cdb_io.cdb_bytes;
3482         bzero(scsi_cmd, sizeof(*scsi_cmd));
3483         scsi_cmd->opcode = WRITE_FILEMARKS;
3484         if (immediate)
3485                 scsi_cmd->byte2 |= SWFMRK_IMMED;
3486         if (setmark)
3487                 scsi_cmd->byte2 |= SWFMRK_WSMK;
3488
3489         scsi_ulto3b(num_marks, scsi_cmd->num_marks);
3490
3491         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_NONE, tag_action, NULL,
3492             0, sense_len, sizeof(*scsi_cmd), timeout);
3493 }
3494
3495 /*
3496  * The reserve and release unit commands differ only by their opcodes.
3497  */
3498 void
3499 scsi_reserve_release_unit(struct ccb_scsiio *csio, u_int32_t retries,
3500                           void (*cbfcnp)(struct cam_periph *, union ccb *),
3501                           u_int8_t tag_action, int third_party,
3502                           int third_party_id, u_int8_t sense_len,
3503                           u_int32_t timeout, int reserve)
3504 {
3505         struct scsi_reserve_release_unit *scsi_cmd;
3506
3507         scsi_cmd = (struct scsi_reserve_release_unit *)&csio->cdb_io.cdb_bytes;
3508         bzero(scsi_cmd, sizeof(*scsi_cmd));
3509
3510         if (reserve)
3511                 scsi_cmd->opcode = RESERVE_UNIT;
3512         else
3513                 scsi_cmd->opcode = RELEASE_UNIT;
3514
3515         if (third_party) {
3516                 scsi_cmd->lun_thirdparty |= SRRU_3RD_PARTY;
3517                 scsi_cmd->lun_thirdparty |=
3518                         ((third_party_id << SRRU_3RD_SHAMT) & SRRU_3RD_MASK);
3519         }
3520
3521         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_NONE, tag_action, NULL,
3522             0, sense_len, sizeof(*scsi_cmd), timeout);
3523 }
3524
3525 void
3526 scsi_erase(struct ccb_scsiio *csio, u_int32_t retries,
3527            void (*cbfcnp)(struct cam_periph *, union ccb *),
3528            u_int8_t tag_action, int immediate, int long_erase,
3529            u_int8_t sense_len, u_int32_t timeout)
3530 {
3531         struct scsi_erase *scsi_cmd;
3532
3533         scsi_cmd = (struct scsi_erase *)&csio->cdb_io.cdb_bytes;
3534         bzero(scsi_cmd, sizeof(*scsi_cmd));
3535
3536         scsi_cmd->opcode = ERASE;
3537
3538         if (immediate)
3539                 scsi_cmd->lun_imm_long |= SE_IMMED;
3540
3541         if (long_erase)
3542                 scsi_cmd->lun_imm_long |= SE_LONG;
3543
3544         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_NONE, tag_action, NULL,
3545             0, sense_len, sizeof(*scsi_cmd), timeout);
3546 }
3547
3548 /*
3549  * Read Tape Position command.
3550  */
3551 void
3552 scsi_read_position(struct ccb_scsiio *csio, u_int32_t retries,
3553                    void (*cbfcnp)(struct cam_periph *, union ccb *),
3554                    u_int8_t tag_action, int hardsoft,
3555                    struct scsi_tape_position_data *sbp,
3556                    u_int8_t sense_len, u_int32_t timeout)
3557 {
3558         struct scsi_tape_read_position *scmd;
3559
3560         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_IN, tag_action,
3561             (u_int8_t *)sbp, sizeof (*sbp), sense_len, sizeof(*scmd), timeout);
3562         scmd = (struct scsi_tape_read_position *)&csio->cdb_io.cdb_bytes;
3563         bzero(scmd, sizeof(*scmd));
3564         scmd->opcode = READ_POSITION;
3565         scmd->byte1 = hardsoft;
3566 }
3567
3568 /*
3569  * Set Tape Position command.
3570  */
3571 void
3572 scsi_set_position(struct ccb_scsiio *csio, u_int32_t retries,
3573                    void (*cbfcnp)(struct cam_periph *, union ccb *),
3574                    u_int8_t tag_action, int hardsoft, u_int32_t blkno,
3575                    u_int8_t sense_len, u_int32_t timeout)
3576 {
3577         struct scsi_tape_locate *scmd;
3578
3579         cam_fill_csio(csio, retries, cbfcnp, CAM_DIR_NONE, tag_action,
3580             (u_int8_t *)NULL, 0, sense_len, sizeof(*scmd), timeout);
3581         scmd = (struct scsi_tape_locate *)&csio->cdb_io.cdb_bytes;
3582         bzero(scmd, sizeof(*scmd));
3583         scmd->opcode = LOCATE;
3584         if (hardsoft)
3585                 scmd->byte1 |= SA_SPOS_BT;
3586         scsi_ulto4b(blkno, scmd->blkaddr);
3587 }