/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright Siemens 1999
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * sgen - SCSI generic device driver
 *
 * The sgen driver provides user programs access to SCSI devices that
 * are not supported by other drivers by providing the USCSI(7I) interface.
 */

#include <sys/modctl.h>
#include <sys/file.h>
#include <sys/scsi/scsi.h>
#include <sys/scsi/targets/sgendef.h>

#define	DDI_NT_SGEN		"ddi_generic:scsi"

static char *sgen_devtypes[] = {
	"direct",		/* 0x00 -- disks */
	"sequential",		/* 0x01 */
	"printer",		/* 0x02 */
	"processor",		/* 0x03 */
	"worm",			/* 0x04 */
	"rodirect",		/* 0x05 */
	"scanner",		/* 0x06 */
	"optical",		/* 0x07 */
	"changer",		/* 0x08 */
	"comm",			/* 0x09 */
	"prepress1",		/* 0x0a -- reserved for prepress (ASC IT8) */
	"prepress2",		/* 0x0b -- reserved for prepress (ASC IT8) */
	"array_ctrl",		/* 0x0c -- storage array */
	"ses",			/* 0x0d -- enclosure services */
	"rbc",			/* 0x0e -- simplified block */
	"ocrw",			/* 0x0f -- optical card read/write */
	"bridge",		/* 0x10 -- reserved for bridging expanders */
	"type_0x11",		/* 0x11 */
	"type_0x12",		/* 0x12 */
	"type_0x13",		/* 0x13 */
	"type_0x14",		/* 0x14 */
	"type_0x15",		/* 0x15 */
	"type_0x16",		/* 0x16 */
	"type_0x17",		/* 0x17 */
	"type_0x18",		/* 0x18 */
	"type_0x19",		/* 0x19 */
	"type_0x1a",		/* 0x1a */
	"type_0x1b",		/* 0x1b */
	"type_0x1c",		/* 0x1c */
	"type_0x1d",		/* 0x1d */
	"type_0x1e",		/* 0x1e */
	"type_unknown"		/* 0x1f is "no device type" or "unknown" */
};

#define	SGEN_NDEVTYPES ((sizeof (sgen_devtypes) / sizeof (char *)))

#define	SGEN_INQSTRLEN 24
#define	SGEN_VENDID_MAX 8
#define	SGEN_PRODID_MAX 16

#define	FILL_SCSI1_LUN(devp, pkt) 					\
	if ((devp)->sd_inq->inq_ansi == 0x1) {				\
		int _lun;						\
		_lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev,	\
		    DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0);		\
		if (_lun > 0) {						\
			((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun =	\
			    _lun;					\
		}							\
	}

#define	SGEN_DO_ERRSTATS(sg_state, x)  \
	if (sg_state->sgen_kstats) { \
		struct sgen_errstats *sp; \
		sp = (struct sgen_errstats *)sg_state->sgen_kstats->ks_data; \
		sp->x.value.ui32++; \
	}

#define	SCBP_C(pkt)	((*(pkt)->pkt_scbp) & STATUS_MASK)

/*
 * Standard entrypoints
 */
static int sgen_attach(dev_info_t *, ddi_attach_cmd_t);
static int sgen_detach(dev_info_t *, ddi_detach_cmd_t);
static int sgen_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int sgen_probe(dev_info_t *);
static int sgen_open(dev_t *, int, int, cred_t *);
static int sgen_close(dev_t, int, int, cred_t *);
static int sgen_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

/*
 * Configuration routines
 */
static int sgen_do_attach(dev_info_t *);
static int sgen_setup_sense(sgen_state_t *);
static void sgen_create_errstats(sgen_state_t *, int);
static int sgen_do_suspend(dev_info_t *);
static int sgen_do_detach(dev_info_t *);
static void sgen_setup_binddb(dev_info_t *);
static void sgen_cleanup_binddb();

/*
 * Packet transport routines
 */
static int  sgen_uscsi_cmd(dev_t, struct uscsi_cmd *, int);
static int sgen_start(struct buf *);
static int sgen_hold_cmdbuf(sgen_state_t *);
static void sgen_rele_cmdbuf(sgen_state_t *);
static int sgen_make_uscsi_cmd(sgen_state_t *, struct buf *);
static void sgen_restart(void *);
static void sgen_callback(struct scsi_pkt *);
static int sgen_handle_autosense(sgen_state_t *, struct scsi_pkt *);
static int sgen_handle_sense(sgen_state_t *);
static int sgen_handle_incomplete(sgen_state_t *, struct scsi_pkt *);
static int sgen_check_error(sgen_state_t *, struct buf *);
static int sgen_initiate_sense(sgen_state_t *, int);
static int sgen_scsi_transport(struct scsi_pkt *);
static int sgen_tur(dev_t);

/*
 * Logging/debugging routines
 */
static void sgen_log(sgen_state_t  *, int,  const char *, ...);
static int sgen_diag_ok(sgen_state_t *, int);
static void sgen_dump_cdb(sgen_state_t *, const char *, union scsi_cdb *, int);
static void sgen_dump_sense(sgen_state_t *, size_t, uchar_t *);

int sgen_diag = 0;
int sgen_sporadic_failures = 0;
int sgen_force_manual_sense = 0;
struct sgen_binddb sgen_binddb;

static struct cb_ops sgen_cb_ops = {
	sgen_open,			/* open */
	sgen_close,			/* close */
	nodev,				/* strategy */
	nodev,				/* print */
	nodev,				/* dump */
	nodev,				/* read */
	nodev,				/* write */
	sgen_ioctl,			/* ioctl */
	nodev,				/* devmap */
	nodev,				/* mmap */
	nodev,				/* segmap */
	nochpoll,			/* poll */
	ddi_prop_op,			/* cb_prop_op */
	0,				/* streamtab  */
	D_MP | D_NEW | D_HOTPLUG	/* Driver compatibility flag */
};

static struct dev_ops sgen_dev_ops = {
	DEVO_REV,		/* devo_rev, */
	0,			/* refcnt  */
	sgen_getinfo,		/* info */
	nodev,			/* identify */
	sgen_probe,		/* probe */
	sgen_attach,		/* attach */
	sgen_detach,		/* detach */
	nodev,			/* reset */
	&sgen_cb_ops,		/* driver operations */
	(struct bus_ops *)0,	/* bus operations */
	NULL			/* power */
};

static void *sgen_soft_state = NULL;

static struct modldrv modldrv = {
	&mod_driverops, "SCSI generic driver %I%", &sgen_dev_ops
};

static struct modlinkage modlinkage = {
	MODREV_1, &modldrv, NULL
};

int
_init(void)
{
	int err;

	sgen_log(NULL, SGEN_DIAG2, "in sgen_init()");
	if ((err = ddi_soft_state_init(&sgen_soft_state,
	    sizeof (sgen_state_t), SGEN_ESTIMATED_NUM_DEVS)) != 0) {
		goto done;
	}

	if ((err = mod_install(&modlinkage)) != 0) {
		ddi_soft_state_fini(&sgen_soft_state);
		goto done;
	}

done:
	sgen_log(NULL, SGEN_DIAG2, "%s sgen_init()", err ? "failed" : "done");
	return (err);
}

int
_fini(void)
{
	int err;
	sgen_log(NULL, SGEN_DIAG2, "in sgen_fini()");

	if ((err = mod_remove(&modlinkage)) != 0) {
		goto done;
	}

	ddi_soft_state_fini(&sgen_soft_state);
	sgen_cleanup_binddb();

done:
	sgen_log(NULL, SGEN_DIAG2, "%s sgen_fini()", err ? "failed" : "done");
	return (err);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

/*
 * sgen_typename()
 * 	return a device type's name by looking it up in the sgen_devtypes table.
 */
static char *
sgen_typename(uchar_t typeno)
{
	if (typeno >= SGEN_NDEVTYPES)
		return ("type_unknown");
	return (sgen_devtypes[typeno]);
}

/*
 * sgen_typenum()
 * 	return a device type's number by looking it up in the sgen_devtypes
 * 	table.
 */
static int
sgen_typenum(const char *typename, uchar_t *typenum)
{
	int i;
	for (i = 0; i < SGEN_NDEVTYPES; i++) {
		if (strcasecmp(sgen_devtypes[i], typename) == 0) {
			*typenum = (uchar_t)i;
			return (0);
		}
	}
	return (-1);
}

/*
 * sgen_setup_binddb()
 * 	initialize a data structure which stores all of the information about
 * 	which devices and device types the driver should bind to.
 */
static void
sgen_setup_binddb(dev_info_t *dip)
{
	char **strs = NULL, *cp, *pcp, *vcp;
	uint_t nelems, pcplen, vcplen, idx;

	ASSERT(sgen_binddb.sdb_init == 0);
	ASSERT(MUTEX_HELD(&sgen_binddb.sdb_lock));

	if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "device-type-config-list", &strs, &nelems) == DDI_PROP_SUCCESS) {
		/*
		 * for each device type specifier make a copy and put it into a
		 * node in the binddb.
		 */
		for (idx = 0; idx < nelems; idx++) {
			sgen_type_node_t *nodep;
			uchar_t devtype;
			cp = strs[idx];
			if (sgen_typenum(cp, &devtype) != 0) {
				sgen_log(NULL, CE_WARN,
				    "unknown device type '%s', "
				    "device unit-address @%s",
				    cp, ddi_get_name_addr(dip));
				continue;
			}
			nodep = kmem_zalloc(sizeof (sgen_type_node_t),
			    KM_SLEEP);
			nodep->node_type = devtype;
			nodep->node_next = sgen_binddb.sdb_type_nodes;
			sgen_binddb.sdb_type_nodes = nodep;

			sgen_log(NULL, SGEN_DIAG2, "found device type "
			    "'%s' in device-type-config-list, "
			    "device unit-address @%s",
			    cp, ddi_get_name_addr(dip));
		}
		ddi_prop_free(strs);
	}

	/*
	 * for each Vendor/Product inquiry pair, build a node and put it
	 * into the the binddb.
	 */
	if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "inquiry-config-list", &strs, &nelems) == DDI_PROP_SUCCESS) {

		if (nelems % 2 == 1) {
			sgen_log(NULL, CE_WARN, "inquiry-config-list must "
			    "contain Vendor/Product pairs, "
			    "device unit-address @%s",
			    ddi_get_name_addr(dip));
			nelems--;
		}
		for (idx = 0; idx < nelems; idx += 2) {
			sgen_inq_node_t *nodep;
			/*
			 * Grab vendor and product ID.
			 */
			vcp = strs[idx];
			vcplen = strlen(vcp);
			if (vcplen == 0 || vcplen > SGEN_VENDID_MAX) {
				sgen_log(NULL, CE_WARN,
				    "Invalid vendor ID '%s', "
				    "device unit-address @%s",
				    vcp, ddi_get_name_addr(dip));
				continue;
			}

			pcp = strs[idx + 1];
			pcplen = strlen(pcp);
			if (pcplen == 0 || pcplen > SGEN_PRODID_MAX) {
				sgen_log(NULL, CE_WARN,
				    "Invalid product ID '%s', "
				    "device unit-address @%s",
				    pcp, ddi_get_name_addr(dip));
				continue;
			}

			nodep = kmem_zalloc(sizeof (sgen_inq_node_t),
			    KM_SLEEP);
			nodep->node_vendor = kmem_alloc(vcplen + 1, KM_SLEEP);
			(void) strcpy(nodep->node_vendor, vcp);
			nodep->node_product = kmem_alloc(pcplen + 1, KM_SLEEP);
			(void) strcpy(nodep->node_product, pcp);

			nodep->node_next = sgen_binddb.sdb_inq_nodes;
			sgen_binddb.sdb_inq_nodes = nodep;

			sgen_log(NULL, SGEN_DIAG2, "found inquiry string "
			    "'%s' '%s' in device-type-config-list, "
			    "device unit-address @%s",
			    nodep->node_vendor, nodep->node_product,
			    ddi_get_name_addr(dip));
		}
		ddi_prop_free(strs);
	}

	sgen_binddb.sdb_init = 1;
}

/*
 * sgen_cleanup_binddb()
 * 	deallocate data structures for binding database.
 */
static void
sgen_cleanup_binddb()
{
	sgen_inq_node_t *inqp, *inqnextp;
	sgen_type_node_t *typep, *typenextp;

	mutex_enter(&sgen_binddb.sdb_lock);
	if (sgen_binddb.sdb_init == 0) {
		mutex_exit(&sgen_binddb.sdb_lock);
		return;
	}

	for (inqp = sgen_binddb.sdb_inq_nodes; inqp != NULL; inqp = inqnextp) {
		inqnextp = inqp->node_next;
		ASSERT(inqp->node_vendor && inqp->node_product);
		kmem_free(inqp->node_vendor,
		    strlen(inqp->node_vendor) + 1);
		kmem_free(inqp->node_product,
		    strlen(inqp->node_product) + 1);
		kmem_free(inqp, sizeof (sgen_inq_node_t));
	}

	for (typep = sgen_binddb.sdb_type_nodes; typep != NULL;
	    typep = typenextp) {
		typenextp = typep->node_next;
		kmem_free(typep, sizeof (sgen_type_node_t));
	}
	mutex_exit(&sgen_binddb.sdb_lock);
}

/*
 * sgen_bind_byinq()
 * 	lookup a device in the binding database by its inquiry data.
 */
static int
sgen_bind_byinq(dev_info_t *dip)
{
	sgen_inq_node_t *nodep;
	char vend_str[SGEN_VENDID_MAX+1];
	char prod_str[SGEN_PRODID_MAX+1];
	struct scsi_device *scsidevp;

	scsidevp = ddi_get_driver_private(dip);

	/*
	 * inq_vid and inq_pid are laid out by the protocol in order in the
	 * inquiry structure, and are not delimited by \0.
	 */
	bcopy(scsidevp->sd_inq->inq_vid, vend_str, SGEN_VENDID_MAX);
	vend_str[SGEN_VENDID_MAX] = '\0';
	bcopy(scsidevp->sd_inq->inq_pid, prod_str, SGEN_PRODID_MAX);
	prod_str[SGEN_PRODID_MAX] = '\0';

	for (nodep = sgen_binddb.sdb_inq_nodes; nodep != NULL;
	    nodep = nodep->node_next) {
		/*
		 * Allow the "*" wildcard to match all vendor IDs.
		 */
		if (strcmp(nodep->node_vendor, "*") != 0) {
			if (strncasecmp(nodep->node_vendor, vend_str,
			    strlen(nodep->node_vendor)) != 0) {
				continue;
			}
		}

		/*
		 * Using strncasecmp() with the key length allows substring
		 * matching for product data.
		 */
		if (strncasecmp(nodep->node_product, prod_str,
		    strlen(nodep->node_product)) == 0) {
			return (0);
		}
	}
	return (-1);
}

/*
 * sgen_bind_bytype()
 * 	lookup a device type in the binding database; if found, return a
 * 	format string corresponding to the string in the .conf file.
 */
static int
sgen_bind_bytype(dev_info_t *dip)
{
	sgen_type_node_t *nodep;
	struct scsi_device *scsidevp;

	scsidevp = ddi_get_driver_private(dip);

	for (nodep = sgen_binddb.sdb_type_nodes; nodep != NULL;
	    nodep = nodep->node_next) {
		if (nodep->node_type == scsidevp->sd_inq->inq_dtype) {
			return (0);
		}
	}
	return (-1);
}

/*
 * sgen_get_binding()
 * 	Check to see if the device in question matches the criteria for
 * 	sgen to bind.
 *
 * 	Either the .conf file must specify a device_type entry which
 * 	matches the SCSI device type of this device, or the inquiry
 * 	string provided by the device must match an inquiry string specified
 * 	in the .conf file.  Inquiry data is matched first.
 */
static int
sgen_get_binding(dev_info_t *dip)
{
	int retval = 0;

	mutex_enter(&sgen_binddb.sdb_lock);
	if (sgen_binddb.sdb_init == 0)
		sgen_setup_binddb(dip);
	mutex_exit(&sgen_binddb.sdb_lock);


	/*
	 * Check device-type-config-list for a match by device type.
	 */
	if (sgen_bind_bytype(dip) == 0)
		goto done;

	/*
	 * Check inquiry-config-list for a match by Vendor/Product ID.
	 */
	if (sgen_bind_byinq(dip) == 0)
		goto done;

	retval = -1;
done:
	return (retval);
}

/*
 * sgen_attach()
 * 	attach(9e) entrypoint.
 */
static int
sgen_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int err;

	sgen_log(NULL, SGEN_DIAG2, "in sgen_attach(), device unit-address @%s",
	    ddi_get_name_addr(dip));

	switch (cmd) {
	case DDI_ATTACH:
		err = sgen_do_attach(dip);
		break;
	case DDI_RESUME:
		err = DDI_SUCCESS;
		break;
	case DDI_PM_RESUME:
	default:
		err = DDI_FAILURE;
		break;
	}

done:
	sgen_log(NULL, SGEN_DIAG2, "%s sgen_attach(), device unit-address @%s",
	    err == DDI_SUCCESS ? "done" : "failed", ddi_get_name_addr(dip));
	return (err);
}

/*
 * sgen_do_attach()
 *	handle the nitty details of attach.
 */
static int
sgen_do_attach(dev_info_t *dip)
{
	int instance;
	struct scsi_device *scsidevp;
	sgen_state_t *sg_state;
	uchar_t devtype;
	struct scsi_inquiry *inq;

	instance = ddi_get_instance(dip);

	scsidevp = ddi_get_driver_private(dip);
	ASSERT(scsidevp);

	sgen_log(NULL, SGEN_DIAG2, "sgen_do_attach: instance = %d, "
	    "device unit-address @%s", instance, ddi_get_name_addr(dip));

	/*
	 * Probe the device in order to get its device type to name the minor
	 * node.
	 */
	if (scsi_probe(scsidevp, NULL_FUNC) != SCSIPROBE_EXISTS) {
		scsi_unprobe(scsidevp);
		return (DDI_FAILURE);
	}

	if (ddi_soft_state_zalloc(sgen_soft_state, instance) != DDI_SUCCESS) {
		sgen_log(NULL, SGEN_DIAG1,
		    "sgen_do_attach: failed to allocate softstate, "
		    "device unit-address @%s", ddi_get_name_addr(dip));
		scsi_unprobe(scsidevp);
		return (DDI_FAILURE);
	}

	inq = scsidevp->sd_inq;		/* valid while device is probed... */
	devtype = inq->inq_dtype;

	sg_state = ddi_get_soft_state(sgen_soft_state, instance);
	sg_state->sgen_scsidev = scsidevp;
	scsidevp->sd_dev = dip;

	/*
	 * Now that sg_state->sgen_scsidev is initialized, it's ok to
	 * call sgen_log with sg_state instead of NULL.
	 */

	/*
	 * If the user specified the sgen_diag property, override the global
	 * sgen_diag setting by setting sg_state's sgen_diag value.  If the
	 * user gave a value out of range, default to '0'.
	 */
	sg_state->sgen_diag = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "sgen-diag", -1);

	if (sg_state->sgen_diag != -1) {
		if (sg_state->sgen_diag < 0 || sg_state->sgen_diag > 3)
			sg_state->sgen_diag = 0;
	}

	sgen_log(sg_state, SGEN_DIAG2,
	    "sgen_do_attach: sgen_soft_state=0x%p, instance=%d, "
	    "device unit-address @%s",
	    sgen_soft_state, instance, ddi_get_name_addr(dip));

	/*
	 * For simplicity, the minor number == the instance number
	 */
	if (ddi_create_minor_node(dip, sgen_typename(devtype), S_IFCHR,
	    instance, DDI_NT_SGEN, NULL) == DDI_FAILURE) {
		scsi_unprobe(scsidevp);
		ddi_prop_remove_all(dip);
		sgen_log(sg_state, SGEN_DIAG1,
		    "sgen_do_attach: minor node creation failed, "
		    "device unit-address @%s", ddi_get_name_addr(dip));
		ddi_soft_state_free(sgen_soft_state, instance);
		return (DDI_FAILURE);
	}

	/*
	 * Allocate the command buffer, then create a condition variable for
	 * managing it; mark the command buffer as free.
	 */
	sg_state->sgen_cmdbuf = getrbuf(KM_SLEEP);
	cv_init(&sg_state->sgen_cmdbuf_cv, NULL, CV_DRIVER, NULL);

	SGEN_CLR_BUSY(sg_state);
	SGEN_CLR_OPEN(sg_state);
	SGEN_CLR_SUSP(sg_state);

	/*
	 * If the hba and the target both support wide xfers, enable them.
	 */
	if (scsi_ifgetcap(&sg_state->sgen_scsiaddr, "wide-xfer", 1) != -1) {
		int wide = 0;
		if ((inq->inq_rdf == RDF_SCSI2) &&
		    (inq->inq_wbus16 || inq->inq_wbus32))
			wide = 1;
		if (scsi_ifsetcap(&sg_state->sgen_scsiaddr, "wide-xfer",
		    wide, 1) == 1) {
			sgen_log(sg_state, SGEN_DIAG1,
			    "sgen_attach: wide xfer %s, "
			    "device unit-address @%s",
			    wide ? "enabled" : "disabled",
			    ddi_get_name_addr(dip));
		}
	}

	/*
	 * This is a little debugging code-- since the codepath for auto-sense
	 * and 'manual' sense is split, toggling this variable will make
	 * sgen act as though the adapter in question can't do auto-sense.
	 */
	if (sgen_force_manual_sense) {
		if (scsi_ifsetcap(&sg_state->sgen_scsiaddr, "auto-rqsense",
		    0, 1) == 1) {
			sg_state->sgen_arq_enabled = 0;
		} else {
			sg_state->sgen_arq_enabled = 1;
		}
	} else {
		/*
		 * Enable autorequest sense, if supported
		 */
		if (scsi_ifgetcap(&sg_state->sgen_scsiaddr,
		    "auto-rqsense", 1) != 1) {
			if (scsi_ifsetcap(&sg_state->sgen_scsiaddr,
			    "auto-rqsense", 1, 1) == 1) {
				sg_state->sgen_arq_enabled = 1;
				sgen_log(sg_state, SGEN_DIAG1,
				    "sgen_attach: auto-request-sense enabled, "
				    "device unit-address @%s",
				    ddi_get_name_addr(dip));
			} else {
				sg_state->sgen_arq_enabled = 0;
				sgen_log(sg_state, SGEN_DIAG1,
				    "sgen_attach: auto-request-sense disabled, "
				    "device unit-address @%s",
				    ddi_get_name_addr(dip));
			}
		} else {
			sg_state->sgen_arq_enabled = 1;	/* already enabled */
			sgen_log(sg_state, SGEN_DIAG1,
			    "sgen_attach: auto-request-sense enabled, "
			    "device unit-address @%s", ddi_get_name_addr(dip));
		}
	}

	/*
	 * Allocate plumbing for manually fetching sense.
	 */
	if (sgen_setup_sense(sg_state) != 0) {
		freerbuf(sg_state->sgen_cmdbuf);
		ddi_prop_remove_all(dip);
		ddi_remove_minor_node(dip, NULL);
		scsi_unprobe(scsidevp);
		sgen_log(sg_state, SGEN_DIAG1,
		    "sgen_do_attach: failed to setup request-sense, "
		    "device unit-address @%s", ddi_get_name_addr(dip));
		ddi_soft_state_free(sgen_soft_state, instance);
		return (DDI_FAILURE);
	}

	sgen_create_errstats(sg_state, instance);

	ddi_report_dev(dip);

	return (DDI_SUCCESS);
}

/*
 * sgen_setup_sense()
 * 	Allocate a request sense packet so that if sgen needs to fetch sense
 * 	data for the user, it will have a pkt ready to send.
 */
static int
sgen_setup_sense(sgen_state_t *sg_state)
{
	struct buf *bp;
	struct scsi_pkt *rqpkt;

	if ((bp = scsi_alloc_consistent_buf(&sg_state->sgen_scsiaddr, NULL,
	    MAX_SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL)) == NULL) {
		return (-1);
	}

	if ((rqpkt = scsi_init_pkt(&sg_state->sgen_scsiaddr, NULL, bp,
	    CDB_GROUP0, 1, 0, PKT_CONSISTENT, SLEEP_FUNC, NULL)) == NULL) {
		scsi_free_consistent_buf(bp);
		return (-1);
	}

	/*
	 * Make the results of running a SENSE available by filling out the
	 * sd_sense field of the scsi device (sgen_sense is just an alias).
	 */
	sg_state->sgen_sense = (struct scsi_extended_sense *)bp->b_un.b_addr;

	(void) scsi_setup_cdb((union scsi_cdb *)rqpkt->pkt_cdbp,
	    SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0);
	FILL_SCSI1_LUN(sg_state->sgen_scsidev, rqpkt);

	rqpkt->pkt_comp = sgen_callback;
	rqpkt->pkt_time = SGEN_IO_TIME;
	rqpkt->pkt_flags |= FLAG_SENSING;
	rqpkt->pkt_private = sg_state;

	sg_state->sgen_rqspkt = rqpkt;
	sg_state->sgen_rqsbuf = bp;

	return (0);
}

/*
 * sgen_create_errstats()
 * 	create named kstats for tracking occurrence of errors.
 */
static void
sgen_create_errstats(sgen_state_t *sg_state, int instance)
{
	char kstatname[KSTAT_STRLEN];
	struct sgen_errstats *stp;

	(void) snprintf(kstatname, KSTAT_STRLEN, "sgen%d,err", instance);
	sg_state->sgen_kstats = kstat_create("sgenerr", instance,
	    kstatname, "device_error", KSTAT_TYPE_NAMED,
	    sizeof (struct sgen_errstats) / sizeof (kstat_named_t),
	    KSTAT_FLAG_PERSISTENT);

	if (sg_state->sgen_kstats == NULL)
		return;

	stp = (struct sgen_errstats *)sg_state->sgen_kstats->ks_data;
	kstat_named_init(&stp->sgen_trans_err, "transport_errors",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_restart, "command_restarts",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_incmp_err, "incomplete_commands",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_autosen_rcv, "autosense_occurred",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_autosen_bad, "autosense_undecipherable",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_sense_rcv, "sense_fetches",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_sense_bad, "sense_data_undecipherable",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_recov_err, "recoverable_error",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_nosen_err, "NO_SENSE_sense_key",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&stp->sgen_unrecov_err, "unrecoverable_sense_error",
	    KSTAT_DATA_UINT32);
	sg_state->sgen_kstats->ks_private = sg_state;
	sg_state->sgen_kstats->ks_update = nulldev;
	kstat_install(sg_state->sgen_kstats);
}

/*
 * sgen_detach()
 * 	detach(9E) entrypoint
 */
static int
sgen_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int instance;
	sgen_state_t *sg_state;

	instance = ddi_get_instance(dip);
	sg_state = ddi_get_soft_state(sgen_soft_state, instance);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_detach(), "
	    "device unit-address @%s", ddi_get_name_addr(dip));

	if (sg_state == NULL) {
		sgen_log(NULL, SGEN_DIAG1,
		    "sgen_detach: failed, no softstate found (%d), "
		    "device unit-address @%s",
		    instance, ddi_get_name_addr(dip));
		return (DDI_FAILURE);
	}

	switch (cmd) {
	case DDI_DETACH:
		return (sgen_do_detach(dip));
	case DDI_SUSPEND:
		return (sgen_do_suspend(dip));
	case DDI_PM_SUSPEND:
	default:
		return (DDI_FAILURE);
	}
}

/*
 * sgen_do_detach()
 * 	detach the driver, tearing down resources.
 */
static int
sgen_do_detach(dev_info_t *dip)
{
	int instance;
	sgen_state_t *sg_state;
	struct scsi_device *devp;

	instance = ddi_get_instance(dip);
	sg_state = ddi_get_soft_state(sgen_soft_state, instance);
	ASSERT(sg_state);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_do_detach(), "
	    "device unit-address @%s", ddi_get_name_addr(dip));
	devp = ddi_get_driver_private(dip);

	mutex_enter(&sg_state->sgen_mutex);
	if (SGEN_IS_BUSY(sg_state)) {
		mutex_exit(&sg_state->sgen_mutex);
		sgen_log(sg_state, SGEN_DIAG1, "sgen_do_detach: failed because "
		    "device is busy, device unit-address @%s",
		    ddi_get_name_addr(dip));
		return (DDI_FAILURE);
	}
	mutex_exit(&sg_state->sgen_mutex);

	/*
	 * Final approach for detach.  Free data allocated by scsi_probe()
	 * in attach.
	 */
	if (sg_state->sgen_restart_timeid)
		(void) untimeout(sg_state->sgen_restart_timeid);
	sg_state->sgen_restart_timeid = 0;
	scsi_unprobe(devp);

	/*
	 * Free auto-request plumbing.
	 */
	scsi_free_consistent_buf(sg_state->sgen_rqsbuf);
	scsi_destroy_pkt(sg_state->sgen_rqspkt);

	if (sg_state->sgen_kstats) {
		kstat_delete(sg_state->sgen_kstats);
		sg_state->sgen_kstats = NULL;
	}

	/*
	 * Free command buffer and clean up
	 */
	freerbuf(sg_state->sgen_cmdbuf);
	cv_destroy(&sg_state->sgen_cmdbuf_cv);

	sgen_log(sg_state, SGEN_DIAG2, "done sgen_do_detach(), "
	    "device unit-address @%s", ddi_get_name_addr(dip));

	ddi_soft_state_free(sgen_soft_state, instance);
	ddi_prop_remove_all(dip);
	ddi_remove_minor_node(dip, NULL);
	return (DDI_SUCCESS);
}

/*
 * sgen_do_suspend()
 * 	suspend the driver.  This sets the "suspend" bit for this target if it
 * 	is currently open; once resumed, the suspend bit will cause
 * 	subsequent I/Os to fail.  We want user programs to close and
 * 	reopen the device to acknowledge that they need to reexamine its
 * 	state and do the right thing.
 */
static int
sgen_do_suspend(dev_info_t *dip)
{
	int instance;
	sgen_state_t *sg_state;

	instance = ddi_get_instance(dip);
	sg_state = ddi_get_soft_state(sgen_soft_state, instance);
	ASSERT(sg_state);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_do_suspend(), "
	    "device unit-address @%s", ddi_get_name_addr(dip));

	if (sg_state->sgen_restart_timeid) {
		(void) untimeout(sg_state->sgen_restart_timeid);
	}
	sg_state->sgen_restart_timeid = 0;

	mutex_enter(&sg_state->sgen_mutex);
	if (SGEN_IS_OPEN(sg_state))
		SGEN_SET_SUSP(sg_state);
	mutex_exit(&sg_state->sgen_mutex);

	sgen_log(sg_state, SGEN_DIAG2, "done sgen_do_suspend(), "
	    "device unit-address @%s", ddi_get_name_addr(dip));
	return (DDI_SUCCESS);
}

/*
 * sgen_getinfo()
 *	getinfo(9e) entrypoint.
 */
/*ARGSUSED*/
static int
sgen_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	dev_t dev;
	sgen_state_t *sg_state;
	int instance, error;
	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		dev = (dev_t)arg;
		instance = getminor(dev);
		if ((sg_state = ddi_get_soft_state(sgen_soft_state, instance))
		    == NULL)
			return (DDI_FAILURE);
		*result = (void *) sg_state->sgen_scsidev->sd_dev;
		error = DDI_SUCCESS;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		dev = (dev_t)arg;
		instance = getminor(dev);
		*result = (void *)(uintptr_t)instance;
		error = DDI_SUCCESS;
		break;
	default:
		error = DDI_FAILURE;
	}
	return (error);
}

/*
 * sgen_probe()
 * 	probe(9e) entrypoint.  sgen *never* returns DDI_PROBE_PARTIAL, in
 * 	order to avoid leaving around extra devinfos.  If sgen's binding
 * 	rules indicate that it should bind, it returns DDI_PROBE_SUCCESS.
 */
static int
sgen_probe(dev_info_t *dip)
{
	struct scsi_device *scsidevp;
	int instance;
	int rval;

	scsidevp = ddi_get_driver_private(dip);
	instance = ddi_get_instance(dip);
	sgen_log(NULL, SGEN_DIAG2, "in sgen_probe(): instance = %d, "
	    "device unit-address @%s", instance, ddi_get_name_addr(dip));

	if (ddi_dev_is_sid(dip) == DDI_SUCCESS)
		return (DDI_PROBE_DONTCARE);

	if (ddi_get_soft_state(sgen_soft_state, instance) != NULL)
		return (DDI_PROBE_FAILURE);

	mutex_enter(&sgen_binddb.sdb_lock);
	if (sgen_binddb.sdb_init == 0) {
		sgen_setup_binddb(dip);
	}
	mutex_exit(&sgen_binddb.sdb_lock);

	/*
	 * A small optimization: if it's impossible for sgen to bind to
	 * any devices, don't bother probing, just fail.
	 */
	if ((sgen_binddb.sdb_inq_nodes == NULL) &&
	    (sgen_binddb.sdb_type_nodes == NULL)) {
		return (DDI_PROBE_FAILURE);
	}

	if (scsi_probe(scsidevp, NULL_FUNC) == SCSIPROBE_EXISTS) {
		if (sgen_get_binding(dip) == 0) {
			rval = DDI_PROBE_SUCCESS;
		}
	} else {
		rval = DDI_PROBE_FAILURE;
	}
	scsi_unprobe(scsidevp);

	sgen_log(NULL, SGEN_DIAG2, "sgen_probe() %s, device unit-address @%s",
	    rval == DDI_PROBE_SUCCESS ? "succeeded" : "failed",
	    ddi_get_name_addr(dip));
	return (rval);
}

/*
 * sgen_open()
 * 	open(9e) entrypoint.  sgen enforces a strict exclusive open policy per
 * 	target.
 */
/*ARGSUSED1*/
static int
sgen_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
{
	dev_t dev = *dev_p;
	sgen_state_t *sg_state;
	int instance;

	instance = getminor(dev);

	if ((sg_state = ddi_get_soft_state(sgen_soft_state, instance)) == NULL)
		return (ENXIO);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_open(): instance = %d",
	    instance);

	mutex_enter(&sg_state->sgen_mutex);

	/*
	 * Don't allow new opens of a suspended device until the last close has
	 * happened.  This is rather simplistic, but keeps the implementation
	 * straightforward.
	 */
	if (SGEN_IS_SUSP(sg_state)) {
		mutex_exit(&sg_state->sgen_mutex);
		return (EIO);
	}

	/*
	 * Enforce exclusive access.
	 */
	if (SGEN_IS_EXCL(sg_state) ||
	    (SGEN_IS_OPEN(sg_state) && (flag & FEXCL))) {
		mutex_exit(&sg_state->sgen_mutex);
		return (EBUSY);
	}

	if (flag & FEXCL)
		SGEN_SET_EXCL(sg_state);

	SGEN_SET_OPEN(sg_state);

	mutex_exit(&sg_state->sgen_mutex);

	return (0);
}

/*
 * sgen_close()
 * 	close(9e) entrypoint.
 */
/*ARGSUSED1*/
static int
sgen_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
	sgen_state_t *sg_state;
	int instance;

	instance = getminor(dev);

	if ((sg_state = ddi_get_soft_state(sgen_soft_state, instance)) == NULL)
		return (ENXIO);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_close(): instance = %d",
	    instance);

	mutex_enter(&sg_state->sgen_mutex);
	SGEN_CLR_OPEN(sg_state);
	SGEN_CLR_EXCL(sg_state);
	SGEN_CLR_SUSP(sg_state); /* closing clears the 'I was suspended' bit */
	mutex_exit(&sg_state->sgen_mutex);

	sgen_log(sg_state, SGEN_DIAG2, "done sgen_close()");

	return (0);
}

/*
 * sgen_ioctl()
 * 	sgen supports the USCSI(7I) ioctl interface.
 */
/*ARGSUSED4*/
static int
sgen_ioctl(dev_t dev,
    int cmd, intptr_t arg, int flag, cred_t *cred_p, int *rval_p)
{
	int retval = 0;
	sgen_state_t *sg_state;
	int instance;

	instance = getminor(dev);

	if ((sg_state = ddi_get_soft_state(sgen_soft_state, instance)) == NULL)
		return (ENXIO);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_ioctl(): instance = %d",
	    instance);

	/*
	 * If the driver has been suspended since the last open, fail all
	 * subsequent IO's so that the userland consumer reinitializes state.
	 */
	mutex_enter(&sg_state->sgen_mutex);
	if (SGEN_IS_SUSP(sg_state)) {
		mutex_exit(&sg_state->sgen_mutex);
		sgen_log(sg_state, SGEN_DIAG1, "sgen_ioctl: returning EIO: "
		    "driver instance %d was previously suspended", instance);
		return (EIO);
	}
	mutex_exit(&sg_state->sgen_mutex);

	switch (cmd) {
	case SGEN_IOC_DIAG: {
		if (arg > 3) {
			arg = 0;
		}
		sg_state->sgen_diag = (int)arg;
		retval = 0;
		break;
	}

	case SGEN_IOC_READY: {
		if (sgen_tur(dev) != 0) {
			retval = EIO;
		} else {
			retval = 0;
		}
		break;
	}

	case USCSICMD:
		retval = sgen_uscsi_cmd(dev, (struct uscsi_cmd *)arg, flag);
		break;

	default:
		retval = ENOTTY;
	}

	sgen_log(sg_state, SGEN_DIAG2, "done sgen_ioctl(), returning %d",
	    retval);

	return (retval);
}

/*
 * sgen_uscsi_cmd()
 * 	Setup, configuration and teardown for a uscsi(7I) command
 */
/*ARGSUSED*/
static int
sgen_uscsi_cmd(dev_t dev, struct uscsi_cmd *ucmd, int flag)
{
	struct uscsi_cmd	*uscmd;
	struct buf	*bp;
	sgen_state_t	*sg_state;
	enum uio_seg	uioseg;
	int	instance;
	int	flags;
	int	err;

	instance = getminor(dev);

	sg_state = ddi_get_soft_state(sgen_soft_state, instance);
	ASSERT(sg_state);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_uscsi_cmd(): instance = %d",
	    instance);

	/*
	 * At this point, we start affecting state relevant to the target,
	 * so access needs to be serialized.
	 */
	if (sgen_hold_cmdbuf(sg_state) != 0) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_uscsi_cmd: interrupted");
		return (EINTR);
	}

	err = scsi_uscsi_alloc_and_copyin((intptr_t)ucmd, flag,
	    &sg_state->sgen_scsiaddr, &uscmd);
	if (err != 0) {
		sgen_rele_cmdbuf(sg_state);
		sgen_log(sg_state, SGEN_DIAG1, "sgen_uscsi_cmd: "
		    "scsi_uscsi_alloc_and_copyin failed\n");
		return (err);
	}

	/*
	 * Clear out undesirable command flags
	 */
	flags = (uscmd->uscsi_flags & ~(USCSI_NOINTR | USCSI_NOPARITY |
	    USCSI_OTAG | USCSI_HTAG | USCSI_HEAD));
	if (flags != uscmd->uscsi_flags) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_uscsi_cmd: cleared "
		    "unsafe uscsi_flags 0x%x", uscmd->uscsi_flags & ~flags);
		uscmd->uscsi_flags = flags;
	}

	if (uscmd->uscsi_cdb != NULL) {
		sgen_dump_cdb(sg_state, "sgen_uscsi_cmd: ",
		    (union scsi_cdb *)uscmd->uscsi_cdb, uscmd->uscsi_cdblen);
	}

	/*
	 * Stash the sense buffer into sgen_rqs_sen for convenience.
	 */
	sg_state->sgen_rqs_sen = uscmd->uscsi_rqbuf;

	bp = sg_state->sgen_cmdbuf;
	bp->av_back = NULL;
	bp->av_forw = NULL;
	bp->b_private = (struct buf *)uscmd;
	uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE : UIO_USERSPACE;

	err = scsi_uscsi_handle_cmd(dev, uioseg, uscmd, sgen_start, bp, NULL);

	if (sg_state->sgen_cmdpkt != NULL) {
		uscmd->uscsi_status = SCBP_C(sg_state->sgen_cmdpkt);
	} else {
		uscmd->uscsi_status = 0;
	}

	sgen_log(sg_state, SGEN_DIAG3, "sgen_uscsi_cmd: awake from waiting "
	    "for command.  Status is 0x%x", uscmd->uscsi_status);

	if (uscmd->uscsi_rqbuf != NULL) {
		int rqlen = uscmd->uscsi_rqlen - uscmd->uscsi_rqresid;
		sgen_dump_sense(sg_state, rqlen,
		    (uchar_t *)uscmd->uscsi_rqbuf);
	}

	(void) scsi_uscsi_copyout_and_free((intptr_t)ucmd, uscmd);

	if (sg_state->sgen_cmdpkt != NULL) {
		scsi_destroy_pkt(sg_state->sgen_cmdpkt);
		sg_state->sgen_cmdpkt = NULL;
	}

	/*
	 * After this point, we can't touch per-target state.
	 */
	sgen_rele_cmdbuf(sg_state);

	sgen_log(sg_state, SGEN_DIAG2, "done sgen_uscsi_cmd()");

	return (err);
}

/*
 * sgen_hold_cmdbuf()
 * 	Acquire a lock on the command buffer for the given target.  Returns
 * 	non-zero if interrupted.
 */
static int
sgen_hold_cmdbuf(sgen_state_t *sg_state)
{
	mutex_enter(&sg_state->sgen_mutex);
	while (SGEN_IS_BUSY(sg_state)) {
		if (!cv_wait_sig(&sg_state->sgen_cmdbuf_cv,
		    &sg_state->sgen_mutex)) {
			mutex_exit(&sg_state->sgen_mutex);
			return (-1);
		}
	}
	SGEN_SET_BUSY(sg_state);
	mutex_exit(&sg_state->sgen_mutex);
	return (0);
}

/*
 * sgen_rele_cmdbuf()
 * 	release the command buffer for a particular target.
 */
static void
sgen_rele_cmdbuf(sgen_state_t *sg_state)
{
	mutex_enter(&sg_state->sgen_mutex);
	SGEN_CLR_BUSY(sg_state);
	cv_signal(&sg_state->sgen_cmdbuf_cv);
	mutex_exit(&sg_state->sgen_mutex);
}

/*
 * sgen_start()
 * 	Transport a uscsi command; this is invoked by physio() or directly
 * 	by sgen_uscsi_cmd().
 */
static int
sgen_start(struct buf *bp)
{
	sgen_state_t *sg_state;
	dev_t dev = bp->b_edev;
	int trans_err;

	if ((sg_state = ddi_get_soft_state(sgen_soft_state,
	    getminor(dev))) == NULL) {
		bp->b_resid = bp->b_bcount;
		bioerror(bp, ENXIO);
		biodone(bp);
		return (ENXIO);
	}

	/*
	 * Sanity checks - command should not be complete, no packet should
	 * be allocated, and there ought to be a uscsi cmd in b_private
	 */
	ASSERT(bp == sg_state->sgen_cmdbuf && sg_state->sgen_cmdpkt == NULL);
	ASSERT((bp->b_flags & B_DONE) == 0);
	ASSERT(bp->b_private);
	if (sgen_make_uscsi_cmd(sg_state, bp) != 0) {
		bp->b_resid = bp->b_bcount;
		bioerror(bp, EFAULT);
		biodone(bp);
		return (EFAULT);
	}

	ASSERT(sg_state->sgen_cmdpkt != NULL);

	/*
	 * Clear out the residual and error fields
	 */
	bp->b_resid = 0;
	bp->b_error = 0;

	trans_err = sgen_scsi_transport(sg_state->sgen_cmdpkt);
	switch (trans_err) {
	case TRAN_ACCEPT:
		break;
	case TRAN_BUSY:
		sgen_log(sg_state, SGEN_DIAG2,
		    "sgen_start: scsi_transport() returned TRAN_BUSY");
		sg_state->sgen_restart_timeid = timeout(sgen_restart, sg_state,
		    SGEN_BSY_TIMEOUT);
		break;
	default:
		/*
		 * Indicate there has been an I/O transfer error.
		 * Be done with the command.
		 */
		mutex_enter(&sg_state->sgen_mutex);
		SGEN_DO_ERRSTATS(sg_state, sgen_trans_err);
		mutex_exit(&sg_state->sgen_mutex);
		sgen_log(sg_state, SGEN_DIAG2, "sgen_start: scsi_transport() "
		    "returned %d", trans_err);
		bioerror(bp, EIO);
		biodone(bp);
		return (EIO);
	}
	sgen_log(sg_state, SGEN_DIAG2, "sgen_start: b_flags 0x%x", bp->b_flags);
	return (0);
}

/*
 * sgen_scsi_transport()
 * 	a simple scsi_transport() wrapper which can be configured to inject
 * 	sporadic errors for testing.
 */
static int
sgen_scsi_transport(struct scsi_pkt *pkt)
{
	int trans_err;
	static int cnt = 0;
	sgen_state_t *sg_state = pkt->pkt_private;

	if (sgen_sporadic_failures == 0) {
		return (scsi_transport(pkt));
	}

	cnt = (cnt * 2416 + 374441) % 1771875;	/* borrowed from kmem.c */
	if (cnt % 40 == 1) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_scsi_transport: "
		    "injecting sporadic BUSY");
		trans_err = TRAN_BUSY;
	} else if (cnt % 40 == 2) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_scsi_transport: "
		    "injecting sporadic BADPKT");
		trans_err = TRAN_BADPKT;
	} else {
		/*
		 * Most of the time we take the normal path
		 */
		trans_err = scsi_transport(pkt);
	}
	return (trans_err);
}

/*
 * sgen_make_uscsi_cmd()
 * 	Initialize a SCSI packet usable for USCSI.
 */
static int
sgen_make_uscsi_cmd(sgen_state_t *sg_state, struct buf *bp)
{
	struct scsi_pkt	*pkt;
	struct uscsi_cmd *ucmd;
	int stat_size = 1;
	int flags = 0;

	ASSERT(bp);

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_make_uscsi_cmd()");

	ucmd = (struct uscsi_cmd *)bp->b_private;

	if (ucmd->uscsi_flags & USCSI_RQENABLE) {
		if (ucmd->uscsi_rqlen > SENSE_LENGTH) {
			stat_size = (int)(ucmd->uscsi_rqlen) +
			    sizeof (struct scsi_arq_status) -
			    sizeof (struct scsi_extended_sense);
			flags = PKT_XARQ;
		} else {
			stat_size = sizeof (struct scsi_arq_status);
		}
	}

	sgen_log(sg_state, SGEN_DIAG3, "sgen_make_uscsi_cmd: b_bcount = %ld",
	    bp->b_bcount);
	pkt = scsi_init_pkt(&sg_state->sgen_scsiaddr,
	    NULL,			/* in_pkt - null so it'll be alloc'd */
	    bp->b_bcount ? bp : NULL,	/* buf structure for data xfer */
	    ucmd->uscsi_cdblen,		/* cmdlen */
	    stat_size,			/* statuslen */
	    0,				/* privatelen */
	    flags,			/* flags */
	    SLEEP_FUNC,			/* callback */
	    (caddr_t)sg_state);		/* callback_arg */

	if (pkt == NULL) {
		sgen_log(sg_state, SGEN_DIAG2, "failed sgen_make_uscsi_cmd()");
		return (-1);
	}

	pkt->pkt_comp = sgen_callback;
	pkt->pkt_private = sg_state;
	sg_state->sgen_cmdpkt = pkt;

	/*
	 * We *don't* call scsi_setup_cdb here, as is customary, since the
	 * user could specify a command from one group, but pass cdblen
	 * as something totally different.  If cdblen is smaller than expected,
	 * this results in scsi_setup_cdb writing past the end of the cdb.
	 */
	bcopy(ucmd->uscsi_cdb, pkt->pkt_cdbp, ucmd->uscsi_cdblen);
	if (ucmd->uscsi_cdblen >= CDB_GROUP0) {
		FILL_SCSI1_LUN(sg_state->sgen_scsidev, pkt);
	}

	if (ucmd->uscsi_timeout > 0)
		pkt->pkt_time = ucmd->uscsi_timeout;
	else
		pkt->pkt_time = SGEN_IO_TIME;

	/*
	 * Set packet options
	 */
	if (ucmd->uscsi_flags & USCSI_SILENT)
		pkt->pkt_flags |= FLAG_SILENT;
	if (ucmd->uscsi_flags & USCSI_ISOLATE)
		pkt->pkt_flags |= FLAG_ISOLATE;
	if (ucmd->uscsi_flags & USCSI_DIAGNOSE)
		pkt->pkt_flags |= FLAG_DIAGNOSE;
	if (ucmd->uscsi_flags & USCSI_RENEGOT) {
		pkt->pkt_flags |= FLAG_RENEGOTIATE_WIDE_SYNC;
	}

	/* Transfer uscsi information to scsi_pkt */
	(void) scsi_uscsi_pktinit(ucmd, pkt);

	sgen_log(sg_state, SGEN_DIAG2, "done sgen_make_uscsi_cmd()");
	return (0);
}


/*
 * sgen_restart()
 * 	sgen_restart() is called after a timeout, when a command has been
 * 	postponed due to a TRAN_BUSY response from the HBA.
 */
static void
sgen_restart(void *arg)
{
	sgen_state_t *sg_state = (sgen_state_t *)arg;
	struct scsi_pkt *pkt;
	struct buf *bp;

	sgen_log(sg_state, SGEN_DIAG2, "in sgen_restart()");

	bp = sg_state->sgen_cmdbuf;
	pkt = sg_state->sgen_cmdpkt;
	ASSERT(bp && pkt);

	SGEN_DO_ERRSTATS(sg_state, sgen_restart);

	/*
	 * If the packet is marked with the sensing flag, sgen is off running
	 * a request sense, and *that packet* is what needs to be restarted.
	 */
	if (pkt->pkt_flags & FLAG_SENSING) {
		sgen_log(sg_state, SGEN_DIAG3,
		    "sgen_restart: restarting REQUEST SENSE");
		pkt = sg_state->sgen_rqspkt;
	}

	if (sgen_scsi_transport(pkt) != TRAN_ACCEPT) {
		bp->b_resid = bp->b_bcount;
		bioerror(bp, EIO);
		biodone(bp);
	}
}

/*
 * sgen_callback()
 * 	Command completion processing
 *
 * 	sgen's completion processing is very pessimistic-- it does not retry
 * 	failed commands; instead, it allows the user application to make
 * 	decisions about what has gone wrong.
 */
static void
sgen_callback(struct scsi_pkt *pkt)
{
	sgen_state_t *sg_state;
	struct uscsi_cmd *ucmd;
	struct buf *bp;
	int action;

	sg_state = pkt->pkt_private;
	/*
	 * bp should always be the command buffer regardless of whether
	 * this is a command completion or a request-sense completion.
	 * This is because there is no need to biodone() the sense buf
	 * when it completes-- we want to biodone() the actual command buffer!
	 */
	bp = sg_state->sgen_cmdbuf;
	if (pkt->pkt_flags & FLAG_SENSING) {
		ASSERT(pkt == sg_state->sgen_rqspkt);
		sgen_log(sg_state, SGEN_DIAG2,
		    "in sgen_callback() (SENSE completion callback)");
	} else {
		ASSERT(pkt == sg_state->sgen_cmdpkt);
		sgen_log(sg_state, SGEN_DIAG2,
		    "in sgen_callback() (command completion callback)");
	}
	ucmd = (struct uscsi_cmd *)bp->b_private;

	sgen_log(sg_state, SGEN_DIAG3, "sgen_callback: reason=0x%x resid=%ld "
	    "state=0x%x", pkt->pkt_reason, pkt->pkt_resid, pkt->pkt_state);

	/* Transfer scsi_pkt information to uscsi */
	(void) scsi_uscsi_pktfini(pkt, ucmd);

	if (pkt->pkt_reason != CMD_CMPLT) {
		/*
		 * The command did not complete.
		 */
		sgen_log(sg_state, SGEN_DIAG3,
		    "sgen_callback: command did not complete");
		action = sgen_handle_incomplete(sg_state, pkt);
	} else if (sg_state->sgen_arq_enabled &&
	    (pkt->pkt_state & STATE_ARQ_DONE)) {
		/*
		 * The auto-rqsense happened, and the packet has a filled-in
		 * scsi_arq_status structure, pointed to by pkt_scbp.
		 */
		sgen_log(sg_state, SGEN_DIAG3,
		    "sgen_callback: received auto-requested sense");
		action = sgen_handle_autosense(sg_state, pkt);
		ASSERT(action != FETCH_SENSE);
	} else if (pkt->pkt_flags & FLAG_SENSING) {
		/*
		 * sgen was running a REQUEST SENSE. Decode the sense data and
		 * decide what to do next.
		 *
		 * Clear FLAG_SENSING on the original packet for completeness.
		 */
		sgen_log(sg_state, SGEN_DIAG3, "sgen_callback: received sense");
		sg_state->sgen_cmdpkt->pkt_flags &= ~FLAG_SENSING;
		action = sgen_handle_sense(sg_state);
		ASSERT(action != FETCH_SENSE);
	} else {
		/*
		 * Command completed and we're not getting sense. Check for
		 * errors and decide what to do next.
		 */
		sgen_log(sg_state, SGEN_DIAG3,
		    "sgen_callback: command appears complete");
		action = sgen_check_error(sg_state, bp);
	}

	switch (action) {
	case FETCH_SENSE:
		/*
		 * If there is sense to fetch, break out to prevent biodone'ing
		 * until the sense fetch is complete.
		 */
		if (sgen_initiate_sense(sg_state,
		    scsi_pkt_allocated_correctly(pkt) ?
		    pkt->pkt_path_instance : 0) == 0)
			break;
		/*FALLTHROUGH*/
	case COMMAND_DONE_ERROR:
		bp->b_resid = bp->b_bcount;
		bioerror(bp, EIO);
		/*FALLTHROUGH*/
	case COMMAND_DONE:
		biodone(bp);
		break;
	default:
		ASSERT(0);
		break;
	}

	sgen_log(sg_state, SGEN_DIAG2, "done sgen_callback()");
}

/*
 * sgen_initiate_sense()
 *	Send the sgen_rqspkt to the target, thereby requesting sense data.
 */
static int
sgen_initiate_sense(sgen_state_t *sg_state, int path_instance)
{
	/* use same path_instance as command */
	if (scsi_pkt_allocated_correctly(sg_state->sgen_rqspkt))
		sg_state->sgen_rqspkt->pkt_path_instance = path_instance;

	switch (sgen_scsi_transport(sg_state->sgen_rqspkt)) {
	case TRAN_ACCEPT:
		sgen_log(sg_state, SGEN_DIAG3, "sgen_initiate_sense: "
		    "sense fetch transport accepted.");
		return (0);
	case TRAN_BUSY:
		sgen_log(sg_state, SGEN_DIAG2, "sgen_initiate_sense: "
		    "sense fetch transport busy, setting timeout.");
		sg_state->sgen_restart_timeid = timeout(sgen_restart, sg_state,
		    SGEN_BSY_TIMEOUT);
		return (0);
	default:
		sgen_log(sg_state, SGEN_DIAG2, "sgen_initiate_sense: "
		    "sense fetch transport failed or busy.");
		return (-1);
	}
}

/*
 * sgen_handle_incomplete()
 * 	sgen is pessimistic, but also careful-- it doesn't try to retry
 * 	incomplete commands, but it also doesn't go resetting devices;
 * 	it is hard to tell if the device will be tolerant of that sort
 * 	of prodding.
 *
 * 	This routine has been left as a guide for the future--- the
 * 	current administration's hands-off policy may need modification.
 */
/*ARGSUSED*/
static int
sgen_handle_incomplete(sgen_state_t *sg_state, struct scsi_pkt *pkt)
{
	SGEN_DO_ERRSTATS(sg_state, sgen_incmp_err);
	return (COMMAND_DONE_ERROR);
}

/*
 * sgen_handle_autosense()
 * 	Deal with SENSE data acquired automatically via the auto-request-sense
 * 	facility.
 *
 * 	Sgen takes a pessimistic view of things-- it doesn't retry commands,
 * 	and unless the device recovered from the problem, this routine returns
 * 	COMMAND_DONE_ERROR.
 */
static int
sgen_handle_autosense(sgen_state_t *sg_state, struct scsi_pkt *pkt)
{
	struct scsi_arq_status *arqstat;
	struct uscsi_cmd *ucmd =
	    (struct uscsi_cmd *)sg_state->sgen_cmdbuf->b_private;
	int amt;

	arqstat = (struct scsi_arq_status *)(pkt->pkt_scbp);

	SGEN_DO_ERRSTATS(sg_state, sgen_autosen_rcv);

	if (arqstat->sts_rqpkt_reason != CMD_CMPLT) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_autosense: ARQ"
		    "failed to complete.");
		SGEN_DO_ERRSTATS(sg_state, sgen_autosen_bad);
		return (COMMAND_DONE_ERROR);
	}

	if (pkt->pkt_state & STATE_XARQ_DONE) {
		amt = MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid;
	} else {
		if (arqstat->sts_rqpkt_resid > SENSE_LENGTH) {
			amt = MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid;
		} else {
			amt = SENSE_LENGTH - arqstat->sts_rqpkt_resid;
		}
	}

	if (ucmd->uscsi_flags & USCSI_RQENABLE) {
		ucmd->uscsi_rqstatus = *((char *)&arqstat->sts_rqpkt_status);
		uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen);
		ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen;
		ASSERT(ucmd->uscsi_rqlen && sg_state->sgen_rqs_sen);
		bcopy(&(arqstat->sts_sensedata), sg_state->sgen_rqs_sen, rqlen);
		sgen_log(sg_state, SGEN_DIAG2, "sgen_handle_autosense: "
		    "uscsi_rqstatus=0x%x uscsi_rqresid=%d\n",
		    ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid);
	}

	if (arqstat->sts_rqpkt_status.sts_chk) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_autosense: got "
		    "check condition on auto request sense!");
		SGEN_DO_ERRSTATS(sg_state, sgen_autosen_bad);
		return (COMMAND_DONE_ERROR);
	}

	if (((arqstat->sts_rqpkt_state & STATE_XFERRED_DATA) == 0) ||
	    (amt == 0)) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_autosense: got "
		    "auto-sense, but it contains no data!");
		SGEN_DO_ERRSTATS(sg_state, sgen_autosen_bad);
		return (COMMAND_DONE_ERROR);
	}

	/*
	 * Stuff the sense data pointer into sgen_sense for later retrieval
	 */
	sg_state->sgen_sense = &arqstat->sts_sensedata;

	/*
	 * Now, check to see whether we got enough sense data to make any
	 * sense out if it (heh-heh).
	 */
	if (amt < SUN_MIN_SENSE_LENGTH) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_autosense: not "
		    "enough auto sense data");
		return (COMMAND_DONE_ERROR);
	}

	switch (arqstat->sts_sensedata.es_key) {
	case KEY_RECOVERABLE_ERROR:
		SGEN_DO_ERRSTATS(sg_state, sgen_recov_err);
		break;
	case KEY_NO_SENSE:
		SGEN_DO_ERRSTATS(sg_state, sgen_nosen_err);
		break;
	default:
		SGEN_DO_ERRSTATS(sg_state, sgen_unrecov_err);
		break;
	}

	return (COMMAND_DONE);
}

/*
 * sgen_handle_sense()
 * 	Examine sense data that was manually fetched from the target.
 */
static int
sgen_handle_sense(sgen_state_t *sg_state)
{
	struct scsi_pkt *rqpkt = sg_state->sgen_rqspkt;
	struct scsi_status *rqstatus = (struct scsi_status *)rqpkt->pkt_scbp;
	struct uscsi_cmd *ucmd =
	    (struct uscsi_cmd *)sg_state->sgen_cmdbuf->b_private;
	int amt;

	SGEN_DO_ERRSTATS(sg_state, sgen_sense_rcv);

	amt = MAX_SENSE_LENGTH - rqpkt->pkt_resid;

	if (ucmd->uscsi_flags & USCSI_RQENABLE) {
		ucmd->uscsi_rqstatus = *((char *)rqstatus);
		uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen);
		ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen;
		ASSERT(ucmd->uscsi_rqlen && sg_state->sgen_rqs_sen);
		bcopy(sg_state->sgen_sense, sg_state->sgen_rqs_sen, rqlen);
		sgen_log(sg_state, SGEN_DIAG2, "sgen_handle_sense: "
		    "uscsi_rqstatus=0x%x uscsi_rqresid=%d\n",
		    ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid);
	}

	if (rqstatus->sts_busy) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_sense: got busy "
		    "on request sense");
		SGEN_DO_ERRSTATS(sg_state, sgen_sense_bad);
		return (COMMAND_DONE_ERROR);
	}

	if (rqstatus->sts_chk) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_sense: got check "
		    "condition on request sense!");
		SGEN_DO_ERRSTATS(sg_state, sgen_sense_bad);
		return (COMMAND_DONE_ERROR);
	}

	if ((rqpkt->pkt_state & STATE_XFERRED_DATA) == 0 || amt == 0) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_sense: got "
		    "sense, but it contains no data");
		SGEN_DO_ERRSTATS(sg_state, sgen_sense_bad);
		return (COMMAND_DONE_ERROR);
	}

	/*
	 * Now, check to see whether we got enough sense data to make any
	 * sense out if it (heh-heh).
	 */
	if (amt < SUN_MIN_SENSE_LENGTH) {
		sgen_log(sg_state, SGEN_DIAG1, "sgen_handle_sense: not "
		    "enough sense data");
		SGEN_DO_ERRSTATS(sg_state, sgen_sense_bad);
		return (COMMAND_DONE_ERROR);
	}

	/*
	 * Decode the sense data-- this was deposited here for us by the
	 * setup in sgen_do_attach(). (note that sgen_sense is an alias for
	 * the sd_sense field in the scsi_device).
	 */
	sgen_log(sg_state, SGEN_DIAG1, "Sense key is %s [0x%x]",
	    scsi_sname(sg_state->sgen_sense->es_key),
	    sg_state->sgen_sense->es_key);
	switch (sg_state->sgen_sense->es_key) {
	case KEY_RECOVERABLE_ERROR:
		SGEN_DO_ERRSTATS(sg_state, sgen_recov_err);
		break;
	case KEY_NO_SENSE:
		SGEN_DO_ERRSTATS(sg_state, sgen_nosen_err);
		break;
	default:
		SGEN_DO_ERRSTATS(sg_state, sgen_unrecov_err);
		break;
	}

	return (COMMAND_DONE);
}

/*
 * sgen_check_error()
 * 	examine the command packet for abnormal completion.
 *
 *	sgen_check_error should only be called at the completion of the
 *	command packet.
 */
static int
sgen_check_error(sgen_state_t *sg_state, struct buf *bp)
{
	struct scsi_pkt *pkt = sg_state->sgen_cmdpkt;
	struct scsi_status *status = (struct scsi_status *)pkt->pkt_scbp;
	struct uscsi_cmd *ucmd =
	    (struct uscsi_cmd *)sg_state->sgen_cmdbuf->b_private;

	if (status->sts_busy) {
		sgen_log(sg_state, SGEN_DIAG1,
		    "sgen_check_error: target is busy");
		return (COMMAND_DONE_ERROR);
	}

	/*
	 * pkt_resid will reflect, at this point, a residual of how many bytes
	 * were not transferred; a non-zero pkt_resid is an error.
	 */
	if (pkt->pkt_resid) {
		bp->b_resid += pkt->pkt_resid;
	}

	if (status->sts_chk) {
		if (ucmd->uscsi_flags & USCSI_RQENABLE) {
			if (sg_state->sgen_arq_enabled) {
				sgen_log(sg_state, SGEN_DIAG1,
				    "sgen_check_error: strange: target "
				    "indicates CHECK CONDITION with auto-sense "
				    "enabled.");
			}
			sgen_log(sg_state, SGEN_DIAG2, "sgen_check_error: "
			    "target ready for sense fetch");
			return (FETCH_SENSE);
		} else {
			sgen_log(sg_state, SGEN_DIAG2, "sgen_check_error: "
			    "target indicates CHECK CONDITION");
		}
	}

	return (COMMAND_DONE);
}

/*
 * sgen_tur()
 * 	test if a target is ready to operate by sending it a TUR command.
 */
static int
sgen_tur(dev_t dev)
{
	char cmdblk[CDB_GROUP0];
	struct uscsi_cmd scmd;

	bzero(&scmd, sizeof (scmd));
	scmd.uscsi_bufaddr = 0;
	scmd.uscsi_buflen = 0;
	bzero(cmdblk, CDB_GROUP0);
	cmdblk[0] = (char)SCMD_TEST_UNIT_READY;
	scmd.uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_WRITE;
	scmd.uscsi_cdb = cmdblk;
	scmd.uscsi_cdblen = CDB_GROUP0;

	return (sgen_uscsi_cmd(dev, &scmd, FKIOCTL));
}

/*
 * sgen_diag_ok()
 * 	given an sg_state and a desired diagnostic level, return true if
 * 	it is acceptable to output a message.
 */
/*ARGSUSED*/
static int
sgen_diag_ok(sgen_state_t *sg_state, int level)
{
	int diag_lvl;

	switch (level) {
	case CE_WARN:
	case CE_NOTE:
	case CE_CONT:
	case CE_PANIC:
		return (1);
	case SGEN_DIAG1:
	case SGEN_DIAG2:
	case SGEN_DIAG3:
		if (sg_state) {
			/*
			 * Check to see if user overrode the diagnostics level
			 * for this instance (either via SGEN_IOC_DIAG or via
			 * .conf file).  If not, fall back to the global diag
			 * level.
			 */
			if (sg_state->sgen_diag != -1)
				diag_lvl = sg_state->sgen_diag;
			else
				diag_lvl = sgen_diag;
		} else {
			diag_lvl = sgen_diag;
		}
		if (((diag_lvl << 8) | CE_CONT) >= level) {
			return (1);
		} else {
			return (0);
		}
	default:
		return (1);
	}
}

/*PRINTFLIKE3*/
static void
sgen_log(sgen_state_t *sg_state, int level, const char *fmt, ...)
{
	va_list	ap;
	char buf[256];

	if (!sgen_diag_ok(sg_state, level))
		return;

	va_start(ap, fmt);
	(void) vsnprintf(buf, sizeof (buf), fmt, ap);
	va_end(ap);

	switch (level) {
	case CE_NOTE:
	case CE_CONT:
	case CE_WARN:
	case CE_PANIC:
		if (sg_state == (sgen_state_t *)NULL) {
			cmn_err(level, "%s", buf);
		} else {
			scsi_log(sg_state->sgen_devinfo, "sgen", level,
			    "%s", buf);
		}
		break;
	case SGEN_DIAG1:
	case SGEN_DIAG2:
	case SGEN_DIAG3:
	default:
		if (sg_state == (sgen_state_t *)NULL) {
			scsi_log(NULL, "sgen", CE_CONT, "%s", buf);
		} else {
			scsi_log(sg_state->sgen_devinfo, "sgen", CE_CONT,
			    "%s", buf);
		}
	}
}

/*
 * sgen_dump_cdb()
 * 	dump out the contents of a cdb.  Take care that 'label' is not too
 * 	large, or 'buf' could overflow.
 */
static void
sgen_dump_cdb(sgen_state_t *sg_state, const char *label,
    union scsi_cdb *cdb, int cdblen)
{
	static char hex[] = "0123456789abcdef";
	char *buf, *p;
	size_t nbytes;
	int i;
	uchar_t	*cdbp = (uchar_t *)cdb;

	/*
	 * fastpath-- if we're not able to print out, don't do all of this
	 * extra work.
	 */
	if (!sgen_diag_ok(sg_state, SGEN_DIAG3))
		return;

	/*
	 * 3 characters for each byte (because of the ' '), plus the size of
	 * the label, plus the trailing ']' and the null character.
	 */
	nbytes = 3 * cdblen + strlen(label) + strlen(" CDB = [") + 2;
	buf = kmem_alloc(nbytes, KM_SLEEP);
	(void) sprintf(buf, "%s CDB = [", label);
	p = &buf[strlen(buf)];
	for (i = 0; i < cdblen; i++, cdbp++) {
		if (i > 0)
			*p++ = ' ';
		*p++ = hex[(*cdbp >> 4) & 0x0f];
		*p++ = hex[*cdbp & 0x0f];
	}
	*p++ = ']';
	*p = 0;
	sgen_log(sg_state, SGEN_DIAG3, buf);
	kmem_free(buf, nbytes);
}

static void
sgen_dump_sense(sgen_state_t *sg_state, size_t rqlen, uchar_t *rqbuf)
{
	static char hex[] = "0123456789abcdef";
	char *buf, *p;
	size_t nbytes;
	int i;

	/*
	 * fastpath-- if we're not able to print out, don't do all of this
	 * extra work.
	 */
	if (!sgen_diag_ok(sg_state, SGEN_DIAG3))
		return;

	/*
	 * 3 characters for each byte (because of the ' '), plus the size of
	 * the label, plus the trailing ']' and the null character.
	 */
	nbytes = 3 * rqlen + strlen(" SENSE = [") + 2;
	buf = kmem_alloc(nbytes, KM_SLEEP);
	(void) sprintf(buf, "SENSE = [");
	p = &buf[strlen(buf)];
	for (i = 0; i < rqlen; i++, rqbuf++) {
		if (i > 0)
			*p++ = ' ';
		*p++ = hex[(*rqbuf >> 4) & 0x0f];
		*p++ = hex[*rqbuf & 0x0f];
	}
	*p++ = ']';
	*p = 0;
	sgen_log(sg_state, SGEN_DIAG3, buf);
	kmem_free(buf, nbytes);
}