File:  [DragonFly] / src / sys / bus / cam / scsi / scsi_sa.c
Revision 1.9: download - view: text, annotated - select for diffs
Fri Mar 12 03:23:19 2004 UTC (10 years, 1 month ago) by dillon
Branches: MAIN
CVS tags: HEAD
Change M_NOWAIT to M_INTWAIT or M_WAITOK.  CAM does a mediocre job checking
for NULL returns from malloc() and even when it does it generally causes
the device operation to fail instead of retrying, resulting in unacceptable
behavior.  M_NOWAIT semantics allow NULL to be returned during normal system
operation.  This is especially true in DragonFly.

Also remove much of the code that previously checked for NULL.  By using
M_INTWAIT or M_WAITOK, malloc() will panic rather then return NULL.  Only
the addition of M_NULLOK allows a blocking malloc() to return NULL, and we
do not use that flag in CAM.

Add M_ZERO to a number of malloc()'s and remove subsequent bzero()'s, and
add M_ZERO to a few mallocs (primarily for the read capacity data structure)
that did not bother zeroing out the structure before.  While the data is
supposed to be overwritten read-capacity is often quite fragile due to the
SCSI simulation layer, so we do not take any chances.

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