xref: /illumos-gate/usr/src/uts/common/io/1394/targets/scsa1394/hba.c (revision 3fe80ca4)

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2023 Oxide Computer Company
 */

/*
 * 1394 mass storage HBA driver
 */

#include <sys/param.h>
#include <sys/errno.h>
#include <sys/cred.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/stat.h>
#include <sys/byteorder.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

#include <sys/1394/targets/scsa1394/impl.h>
#include <sys/1394/targets/scsa1394/cmd.h>

/* DDI/DKI entry points */
static int	scsa1394_attach(dev_info_t *, ddi_attach_cmd_t);
static int	scsa1394_detach(dev_info_t *, ddi_detach_cmd_t);
static int	scsa1394_power(dev_info_t *, int, int);
static int	scsa1394_cpr_suspend(dev_info_t *);
static void	scsa1394_cpr_resume(dev_info_t *);

/* configuration routines */
static void	scsa1394_cleanup(scsa1394_state_t *, int);
static int	scsa1394_attach_1394(scsa1394_state_t *);
static void	scsa1394_detach_1394(scsa1394_state_t *);
static int	scsa1394_attach_threads(scsa1394_state_t *);
static void	scsa1394_detach_threads(scsa1394_state_t *);
static int	scsa1394_attach_scsa(scsa1394_state_t *);
static void	scsa1394_detach_scsa(scsa1394_state_t *);
static int	scsa1394_create_cmd_cache(scsa1394_state_t *);
static void	scsa1394_destroy_cmd_cache(scsa1394_state_t *);
static int	scsa1394_add_events(scsa1394_state_t *);
static void	scsa1394_remove_events(scsa1394_state_t *);

/* device configuration */
static int	scsa1394_scsi_bus_config(dev_info_t *, uint_t,
		ddi_bus_config_op_t, void *, dev_info_t **);
static int	scsa1394_scsi_bus_unconfig(dev_info_t *, uint_t,
		ddi_bus_config_op_t, void *);
static void	scsa1394_create_children(scsa1394_state_t *);
static void	scsa1394_bus_reset(dev_info_t *, ddi_eventcookie_t, void *,
		void *);
static void	scsa1394_disconnect(dev_info_t *, ddi_eventcookie_t, void *,
		void *);
static void	scsa1394_reconnect(dev_info_t *, ddi_eventcookie_t, void *,
		void *);

/* SCSA HBA entry points */
static int	scsa1394_scsi_tgt_init(dev_info_t *, dev_info_t *,
		scsi_hba_tran_t *, struct scsi_device *);
static void	scsa1394_scsi_tgt_free(dev_info_t *, dev_info_t *,
		scsi_hba_tran_t *, struct scsi_device *);
static int	scsa1394_scsi_tgt_probe(struct scsi_device *, int (*)());
static int	scsa1394_probe_g0_nodata(struct scsi_device *, int (*)(),
		uchar_t, uint_t, uint_t);
static int	scsa1394_probe_tran(struct scsi_pkt *);
static struct scsi_pkt *scsa1394_scsi_init_pkt(struct scsi_address *,
		struct scsi_pkt *, struct buf *, int, int, int, int,
		int (*)(), caddr_t arg);
static void	scsa1394_scsi_destroy_pkt(struct scsi_address *,
		struct scsi_pkt *);
static int	scsa1394_scsi_start(struct scsi_address *, struct scsi_pkt *);
static int	scsa1394_scsi_abort(struct scsi_address *, struct scsi_pkt *);
static int	scsa1394_scsi_reset(struct scsi_address *, int);
static int	scsa1394_scsi_getcap(struct scsi_address *, char *, int);
static int	scsa1394_scsi_setcap(struct scsi_address *, char *, int, int);
static void	scsa1394_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
static void	scsa1394_scsi_sync_pkt(struct scsi_address *,
		struct scsi_pkt *);

/* pkt resource allocation routines */
static int	scsa1394_cmd_cache_constructor(void *, void *, int);
static void	scsa1394_cmd_cache_destructor(void *, void *);
static int	scsa1394_cmd_ext_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
		int);
static void	scsa1394_cmd_ext_free(scsa1394_state_t *, scsa1394_cmd_t *);
static int	scsa1394_cmd_cdb_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
		int, int (*)(), caddr_t);
static void	scsa1394_cmd_cdb_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
static int	scsa1394_cmd_buf_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
		int, int (*)(), caddr_t, struct buf *);
static void	scsa1394_cmd_buf_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
static int	scsa1394_cmd_dmac2seg(scsa1394_state_t *, scsa1394_cmd_t *,
		ddi_dma_cookie_t *, uint_t, int);
static void	scsa1394_cmd_seg_free(scsa1394_state_t *, scsa1394_cmd_t *);
static int	scsa1394_cmd_pt_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
		int (*)(), caddr_t, int);
static void	scsa1394_cmd_pt_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
static int	scsa1394_cmd_buf_addr_alloc(scsa1394_state_t *,
		scsa1394_cmd_t *);
static void	scsa1394_cmd_buf_addr_free(scsa1394_state_t *,
		scsa1394_cmd_t *);
static int	scsa1394_cmd_buf_dma_move(scsa1394_state_t *, scsa1394_cmd_t *);


/* pkt and data transfer routines */
static void	scsa1394_prepare_pkt(scsa1394_state_t *, struct scsi_pkt *);
static void	scsa1394_cmd_fill_cdb(scsa1394_lun_t *, scsa1394_cmd_t *);
static void	scsa1394_cmd_fill_cdb_rbc(scsa1394_lun_t *, scsa1394_cmd_t *);
static void	scsa1394_cmd_fill_cdb_other(scsa1394_lun_t *, scsa1394_cmd_t *);
static void	scsa1394_cmd_fill_cdb_len(scsa1394_cmd_t *, int);
static void	scsa1394_cmd_fill_cdb_lba(scsa1394_cmd_t *, int);
static void	scsa1394_cmd_fill_12byte_cdb_len(scsa1394_cmd_t *, int);
static void	scsa1394_cmd_fill_read_cd_cdb_len(scsa1394_cmd_t *, int);
static int	scsa1394_cmd_read_cd_blk_size(uchar_t);
static int	scsa1394_cmd_fake_mode_sense(scsa1394_state_t *,
		scsa1394_cmd_t *);
static int	scsa1394_cmd_fake_inquiry(scsa1394_state_t *, scsa1394_cmd_t *);
static int	scsa1394_cmd_fake_comp(scsa1394_state_t *, scsa1394_cmd_t *);
static int	scsa1394_cmd_setup_next_xfer(scsa1394_lun_t *,
		scsa1394_cmd_t *);
static void	scsa1394_cmd_adjust_cdb(scsa1394_lun_t *, scsa1394_cmd_t *);
static void	scsa1394_cmd_status_wrka(scsa1394_lun_t *, scsa1394_cmd_t *);

/* other routines */
static boolean_t scsa1394_is_my_child(dev_info_t *);
static void *	scsa1394_kmem_realloc(void *, int, int, size_t, int);

static void	*scsa1394_statep;
#define	SCSA1394_INST2STATE(inst) (ddi_get_soft_state(scsa1394_statep, inst))

static struct cb_ops scsa1394_cb_ops = {
	nodev,			/* open */
	nodev,			/* close */
	nodev,			/* strategy */
	nodev,			/* print */
	nodev,			/* dump */
	nodev,			/* read */
	nodev,			/* write */
	NULL,			/* ioctl */
	nodev,			/* devmap */
	nodev,			/* mmap */
	nodev,			/* segmap */
	nochpoll,		/* poll */
	ddi_prop_op,		/* prop_op */
	NULL,			/* stream */
	D_MP,			/* cb_flag */
	CB_REV,			/* rev */
	nodev,			/* aread */
	nodev			/* awrite */
};

static struct dev_ops scsa1394_ops = {
	DEVO_REV,		/* devo_rev, */
	0,			/* refcnt  */
	ddi_no_info,		/* info */
	nulldev,		/* identify */
	nulldev,		/* probe */
	scsa1394_attach,	/* attach */
	scsa1394_detach,	/* detach */
	nodev,			/* reset */
	&scsa1394_cb_ops,	/* driver operations */
	NULL,			/* bus operations */
	scsa1394_power,		/* power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};

static struct modldrv scsa1394_modldrv = {
	&mod_driverops,			/* module type */
	"1394 Mass Storage HBA Driver", /* name of the module */
	&scsa1394_ops,			/* driver ops */
};

static struct modlinkage scsa1394_modlinkage = {
	MODREV_1, (void *)&scsa1394_modldrv, NULL
};

/* tunables */
int scsa1394_bus_config_debug = 0;
int scsa1394_start_stop_fail_max = SCSA1394_START_STOP_FAIL_MAX;
int scsa1394_mode_sense_fail_max = SCSA1394_MODE_SENSE_FAIL_MAX;
int scsa1394_start_stop_timeout_max = SCSA1394_START_STOP_TIMEOUT_MAX;

/* workarounds */
int scsa1394_wrka_rbc2direct = 1;
int scsa1394_wrka_fake_rmb = 0;
int scsa1394_wrka_fake_prin = 1;

int scsa1394_wrka_symbios = 1;
int scsa1394_symbios_page_size = 4 * 1024;	/* must be <= _pagesize */
int scsa1394_symbios_size_max = 512 * 248;	/* multiple of page size */

/*
 *
 * --- DDI/DKI entry points
 *
 */
int
_init(void)
{
	int	ret;

	if (((ret = ddi_soft_state_init(&scsa1394_statep,
	    sizeof (scsa1394_state_t), 1)) != 0)) {
		return (ret);
	}

	if ((ret = scsi_hba_init(&scsa1394_modlinkage)) != 0) {
		ddi_soft_state_fini(&scsa1394_statep);
		return (ret);
	}

	if ((ret = mod_install(&scsa1394_modlinkage)) != 0) {
		scsi_hba_fini(&scsa1394_modlinkage);
		ddi_soft_state_fini(&scsa1394_statep);
		return (ret);
	}

	return (ret);
}

int
_fini(void)
{
	int	ret;

	if ((ret = mod_remove(&scsa1394_modlinkage)) == 0) {
		scsi_hba_fini(&scsa1394_modlinkage);
		ddi_soft_state_fini(&scsa1394_statep);
	}

	return (ret);
}

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

static int
scsa1394_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int		instance = ddi_get_instance(dip);
	scsa1394_state_t *sp;

	switch (cmd) {
	case DDI_ATTACH:
		break;
	case DDI_RESUME:
		scsa1394_cpr_resume(dip);
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}

	if (ddi_soft_state_zalloc(scsa1394_statep, instance) != 0) {
		return (DDI_FAILURE);
	}
	sp = SCSA1394_INST2STATE(instance);

#ifndef __lock_lint
	sp->s_dip = dip;
	sp->s_instance = instance;
#endif
	mutex_init(&sp->s_mutex, NULL, MUTEX_DRIVER,
	    sp->s_attachinfo.iblock_cookie);
	cv_init(&sp->s_event_cv, NULL, CV_DRIVER, NULL);

	if (scsa1394_attach_1394(sp) != DDI_SUCCESS) {
		scsa1394_cleanup(sp, 1);
		return (DDI_FAILURE);
	}

	if (scsa1394_sbp2_attach(sp) != DDI_SUCCESS) {
		scsa1394_cleanup(sp, 2);
		return (DDI_FAILURE);
	}

	if (scsa1394_attach_threads(sp) != DDI_SUCCESS) {
		scsa1394_cleanup(sp, 3);
		return (DDI_FAILURE);
	}

	if (scsa1394_attach_scsa(sp) != DDI_SUCCESS) {
		scsa1394_cleanup(sp, 4);
		return (DDI_FAILURE);
	}

	if (scsa1394_create_cmd_cache(sp) != DDI_SUCCESS) {
		scsa1394_cleanup(sp, 5);
		return (DDI_FAILURE);
	}

	if (scsa1394_add_events(sp) != DDI_SUCCESS) {
		scsa1394_cleanup(sp, 6);
		return (DDI_FAILURE);
	}

	/* prevent async PM changes until we are done */
	(void) pm_busy_component(dip, 0);

	/* Set power to full on */
	(void) pm_raise_power(dip, 0, PM_LEVEL_D0);

	/* we are done */
	(void) pm_idle_component(dip, 0);

#ifndef __lock_lint
	sp->s_dev_state = SCSA1394_DEV_ONLINE;
#endif

	ddi_report_dev(dip);

	return (DDI_SUCCESS);
}

static int
scsa1394_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int		instance = ddi_get_instance(dip);
	scsa1394_state_t *sp;

	if ((sp = SCSA1394_INST2STATE(instance)) == NULL) {
		return (DDI_FAILURE);
	}

	switch (cmd) {
	case DDI_DETACH:
		/* Cycle power state to off and idle  where done/gone */
		(void) pm_lower_power(dip, 0, PM_LEVEL_D3);

		scsa1394_cleanup(sp, SCSA1394_CLEANUP_LEVEL_MAX);
		return (DDI_SUCCESS);
	case DDI_SUSPEND:
		return (scsa1394_cpr_suspend(dip));
	default:
		return (DDI_FAILURE);
	}
}

/*ARGSUSED*/
static int
scsa1394_power(dev_info_t *dip, int comp, int level)
{
	return (DDI_SUCCESS);
}

/*
 * scsa1394_cpr_suspend
 *	determine if the device's state can be changed to SUSPENDED
 */
/* ARGSUSED */
static int
scsa1394_cpr_suspend(dev_info_t *dip)
{
	int		instance = ddi_get_instance(dip);
	scsa1394_state_t *sp;
	int		rval = DDI_FAILURE;

	sp = SCSA1394_INST2STATE(instance);

	ASSERT(sp != NULL);


	mutex_enter(&sp->s_mutex);
	switch (sp->s_dev_state) {
	case SCSA1394_DEV_ONLINE:
	case SCSA1394_DEV_PWRED_DOWN:
	case SCSA1394_DEV_DISCONNECTED:
		sp->s_dev_state = SCSA1394_DEV_SUSPENDED;

		/*  Power down and make device idle */
		(void) pm_lower_power(dip, 0, PM_LEVEL_D3);

		rval = DDI_SUCCESS;
		break;
	case SCSA1394_DEV_SUSPENDED:
	default:
		if (scsa1394_bus_config_debug)
			cmn_err(CE_WARN,
			    "scsa1304_cpr_suspend: Illegal dev state: %d",
			    sp->s_dev_state);

		rval = DDI_SUCCESS;
		break;
	}
	mutex_exit(&sp->s_mutex);

	return (rval);
}

/*
 * scsa2usb_cpr_resume:
 *	restore device's state
 */
static void
scsa1394_cpr_resume(dev_info_t *dip)
{
	int		instance = ddi_get_instance(dip);
	scsa1394_state_t *sp;
	int		i;
	scsa1394_lun_t	*lp;

	sp = SCSA1394_INST2STATE(instance);

	ASSERT(sp != NULL);

	if (sp->s_dev_state != SCSA1394_DEV_SUSPENDED)
		return;

	/*
	 * Go through each lun and reset it to force a reconnect.
	 */
	for (i = 0; i < sp->s_nluns; i++) {
		lp = &sp->s_lun[i];
		if (lp->l_ses != NULL) {  /* Are we loged in? */
			scsa1394_sbp2_req_bus_reset(lp);
			scsa1394_sbp2_req_reconnect(lp);
		}
	}

	/* we are down so let the power get managed */
	(void) pm_idle_component(dip, 0);
}



/*
 *
 * --- configuration routines
 *
 */
static void
scsa1394_cleanup(scsa1394_state_t *sp, int level)
{
	ASSERT((level > 0) && (level <= SCSA1394_CLEANUP_LEVEL_MAX));

	switch (level) {
	default:
		scsa1394_remove_events(sp);
		/* FALLTHRU */
	case 6:
		scsa1394_detach_scsa(sp);
		/* FALLTHRU */
	case 5:
		scsa1394_destroy_cmd_cache(sp);
		/* FALLTHRU */
	case 4:
		scsa1394_detach_threads(sp);
		/* FALLTHRU */
	case 3:
		scsa1394_sbp2_detach(sp);
		/* FALLTHRU */
	case 2:
		scsa1394_detach_1394(sp);
		/* FALLTHRU */
	case 1:
		cv_destroy(&sp->s_event_cv);
		mutex_destroy(&sp->s_mutex);
		ddi_soft_state_free(scsa1394_statep, sp->s_instance);
	}
}

static int
scsa1394_attach_1394(scsa1394_state_t *sp)
{
	int	ret;

	if ((ret = t1394_attach(sp->s_dip, T1394_VERSION_V1, 0,
	    &sp->s_attachinfo, &sp->s_t1394_hdl)) != DDI_SUCCESS) {
		return (ret);
	}

	/* DMA attributes for data buffers */
	sp->s_buf_dma_attr = sp->s_attachinfo.dma_attr;

	/* DMA attributes for page tables */
	sp->s_pt_dma_attr = sp->s_attachinfo.dma_attr;
	sp->s_pt_dma_attr.dma_attr_sgllen = 1;	/* pt must be contiguous */

	if ((ret = t1394_get_targetinfo(sp->s_t1394_hdl, SCSA1394_BUSGEN(sp), 0,
	    &sp->s_targetinfo)) != DDI_SUCCESS) {
		(void) t1394_detach(&sp->s_t1394_hdl, 0);
		return (ret);
	}

	return (DDI_SUCCESS);
}

static void
scsa1394_detach_1394(scsa1394_state_t *sp)
{
	(void) t1394_detach(&sp->s_t1394_hdl, 0);
}

static int
scsa1394_attach_threads(scsa1394_state_t *sp)
{
	char		name[16];
	int		nthr;

	nthr = sp->s_nluns;
	(void) snprintf(name, sizeof (name), "scsa1394%d", sp->s_instance);
	if ((sp->s_taskq = ddi_taskq_create(sp->s_dip, name, nthr,
	    TASKQ_DEFAULTPRI, 0)) == NULL) {
		return (DDI_FAILURE);
	}

	if (scsa1394_sbp2_threads_init(sp) != DDI_SUCCESS) {
		ddi_taskq_destroy(sp->s_taskq);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static void
scsa1394_detach_threads(scsa1394_state_t *sp)
{
	scsa1394_sbp2_threads_fini(sp);
	ddi_taskq_destroy(sp->s_taskq);
}

static int
scsa1394_attach_scsa(scsa1394_state_t *sp)
{
	scsi_hba_tran_t	*tran;
	int		ret;

	sp->s_tran = tran = scsi_hba_tran_alloc(sp->s_dip, SCSI_HBA_CANSLEEP);

	tran->tran_hba_private	= sp;
	tran->tran_tgt_private	= NULL;
	tran->tran_tgt_init	= scsa1394_scsi_tgt_init;
	tran->tran_tgt_probe	= scsa1394_scsi_tgt_probe;
	tran->tran_tgt_free	= scsa1394_scsi_tgt_free;
	tran->tran_start	= scsa1394_scsi_start;
	tran->tran_abort	= scsa1394_scsi_abort;
	tran->tran_reset	= scsa1394_scsi_reset;
	tran->tran_getcap	= scsa1394_scsi_getcap;
	tran->tran_setcap	= scsa1394_scsi_setcap;
	tran->tran_init_pkt	= scsa1394_scsi_init_pkt;
	tran->tran_destroy_pkt	= scsa1394_scsi_destroy_pkt;
	tran->tran_dmafree	= scsa1394_scsi_dmafree;
	tran->tran_sync_pkt	= scsa1394_scsi_sync_pkt;
	tran->tran_reset_notify	= NULL;
	tran->tran_get_bus_addr	= NULL;
	tran->tran_get_name	= NULL;
	tran->tran_bus_reset	= NULL;
	tran->tran_quiesce	= NULL;
	tran->tran_unquiesce	= NULL;
	tran->tran_get_eventcookie = NULL;
	tran->tran_add_eventcall = NULL;
	tran->tran_remove_eventcall = NULL;
	tran->tran_post_event	= NULL;
	tran->tran_bus_config	= scsa1394_scsi_bus_config;
	tran->tran_bus_unconfig	= scsa1394_scsi_bus_unconfig;

	if ((ret = scsi_hba_attach_setup(sp->s_dip, &sp->s_attachinfo.dma_attr,
	    tran, 0)) != DDI_SUCCESS) {
		scsi_hba_tran_free(tran);
		return (ret);
	}

	return (DDI_SUCCESS);
}

static void
scsa1394_detach_scsa(scsa1394_state_t *sp)
{
	int	ret;

	ret = scsi_hba_detach(sp->s_dip);
	ASSERT(ret == DDI_SUCCESS);

	scsi_hba_tran_free(sp->s_tran);
}

static int
scsa1394_create_cmd_cache(scsa1394_state_t *sp)
{
	char	name[64];

	(void) sprintf(name, "scsa1394%d_cache", sp->s_instance);
	sp->s_cmd_cache = kmem_cache_create(name,
	    SCSA1394_CMD_SIZE, sizeof (void *),
	    scsa1394_cmd_cache_constructor, scsa1394_cmd_cache_destructor,
	    NULL, (void *)sp, NULL, 0);

	return ((sp->s_cmd_cache == NULL) ? DDI_FAILURE : DDI_SUCCESS);
}

static void
scsa1394_destroy_cmd_cache(scsa1394_state_t *sp)
{
	kmem_cache_destroy(sp->s_cmd_cache);
}

static int
scsa1394_add_events(scsa1394_state_t *sp)
{
	ddi_eventcookie_t	br_evc, rem_evc, ins_evc;

	if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_BUS_RESET_EVENT,
	    &br_evc) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}
	if (ddi_add_event_handler(sp->s_dip, br_evc, scsa1394_bus_reset,
	    sp, &sp->s_reset_cb_id) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_REMOVE_EVENT,
	    &rem_evc) != DDI_SUCCESS) {
		(void) ddi_remove_event_handler(sp->s_reset_cb_id);
		return (DDI_FAILURE);
	}
	if (ddi_add_event_handler(sp->s_dip, rem_evc, scsa1394_disconnect,
	    sp, &sp->s_remove_cb_id) != DDI_SUCCESS) {
		(void) ddi_remove_event_handler(sp->s_reset_cb_id);
		return (DDI_FAILURE);
	}

	if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_INSERT_EVENT,
	    &ins_evc) != DDI_SUCCESS) {
		(void) ddi_remove_event_handler(sp->s_remove_cb_id);
		(void) ddi_remove_event_handler(sp->s_reset_cb_id);
		return (DDI_FAILURE);
	}
	if (ddi_add_event_handler(sp->s_dip, ins_evc, scsa1394_reconnect,
	    sp, &sp->s_insert_cb_id) != DDI_SUCCESS) {
		(void) ddi_remove_event_handler(sp->s_remove_cb_id);
		(void) ddi_remove_event_handler(sp->s_reset_cb_id);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static void
scsa1394_remove_events(scsa1394_state_t *sp)
{
	ddi_eventcookie_t	evc;

	if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_INSERT_EVENT,
	    &evc) == DDI_SUCCESS) {
		(void) ddi_remove_event_handler(sp->s_insert_cb_id);
	}

	if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_REMOVE_EVENT,
	    &evc) == DDI_SUCCESS) {
		(void) ddi_remove_event_handler(sp->s_remove_cb_id);
	}

	if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_BUS_RESET_EVENT,
	    &evc) == DDI_SUCCESS) {
		(void) ddi_remove_event_handler(sp->s_reset_cb_id);
	}
}

/*
 *
 * --- device configuration
 *
 */
static int
scsa1394_scsi_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
    void *arg, dev_info_t **child)
{
	scsa1394_state_t *sp = SCSA1394_INST2STATE(ddi_get_instance(dip));
	int		ret;

	if (scsa1394_bus_config_debug) {
		flag |= NDI_DEVI_DEBUG;
	}

	ndi_devi_enter(dip);
	if (DEVI(dip)->devi_child == NULL) {
		scsa1394_create_children(sp);
	}
	ret = ndi_busop_bus_config(dip, flag, op, arg, child, 0);
	ndi_devi_exit(dip);

	return (ret);
}

static int
scsa1394_scsi_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
    void *arg)
{
	scsa1394_state_t *sp = SCSA1394_INST2STATE(ddi_get_instance(dip));
	int		ret;
	uint_t		saved_flag = flag;

	if (scsa1394_bus_config_debug) {
		flag |= NDI_DEVI_DEBUG;
	}

	/*
	 * First offline and if offlining successful, then remove children.
	 */
	if (op == BUS_UNCONFIG_ALL) {
		flag &= ~(NDI_DEVI_REMOVE | NDI_UNCONFIG);
	}

	ndi_devi_enter(dip);

	ret = ndi_busop_bus_unconfig(dip, flag, op, arg);

	/*
	 * If previous step was successful and not part of modunload daemon,
	 * attempt to remove children.
	 */
	if ((op == BUS_UNCONFIG_ALL) && (ret == NDI_SUCCESS) &&
	    ((flag & NDI_AUTODETACH) == 0)) {
		flag |= NDI_DEVI_REMOVE;
		ret = ndi_busop_bus_unconfig(dip, flag, op, arg);
	}
	ndi_devi_exit(dip);

	if ((ret != NDI_SUCCESS) && (op == BUS_UNCONFIG_ALL) &&
	    ((saved_flag & NDI_DEVI_REMOVE) != 0)) {
		mutex_enter(&sp->s_mutex);
		if (!sp->s_disconnect_warned) {
			cmn_err(CE_WARN, "scsa1394(%d): "
			    "Disconnected device was busy, please reconnect.\n",
			    sp->s_instance);
			sp->s_disconnect_warned = B_TRUE;
		}
		mutex_exit(&sp->s_mutex);
	}

	return (ret);
}

void
scsa1394_dtype2name(int dtype, char **node_name, char **driver_name)
{
	static struct {
		char	*node_name;
		char	*driver_name;
	} dtype2name[] = {
		{ "disk",	"sd" },		/* DTYPE_DIRECT		0x00 */
		{ "tape",	"st" },		/* DTYPE_SEQUENTIAL	0x01 */
		{ "printer",	NULL },		/* DTYPE_PRINTER	0x02 */
		{ "processor",	NULL },		/* DTYPE_PROCESSOR	0x03 */
		{ "worm",	NULL },		/* DTYPE_WORM		0x04 */
		{ "disk",	"sd" },		/* DTYPE_RODIRECT	0x05 */
		{ "scanner",	NULL },		/* DTYPE_SCANNER	0x06 */
		{ "disk",	"sd" },		/* DTYPE_OPTICAL	0x07 */
		{ "changer",	NULL },		/* DTYPE_CHANGER	0x08 */
		{ "comm",	NULL },		/* DTYPE_COMM		0x09 */
		{ "generic",	NULL },		/* DTYPE_???		0x0A */
		{ "generic",	NULL },		/* DTYPE_???		0x0B */
		{ "array_ctrl",	NULL },		/* DTYPE_ARRAY_CTRL	0x0C */
		{ "esi",	"ses" },	/* DTYPE_ESI		0x0D */
		{ "disk",	"sd" }		/* DTYPE_RBC		0x0E */
	};

	if (dtype < NELEM(dtype2name)) {
		*node_name = dtype2name[dtype].node_name;
		*driver_name = dtype2name[dtype].driver_name;
	} else {
		*node_name = "generic";
		*driver_name = NULL;
	}
}

static void
scsa1394_create_children(scsa1394_state_t *sp)
{
	char		name[SCSA1394_COMPAT_MAX][16];
	char		*compatible[SCSA1394_COMPAT_MAX];
	dev_info_t	*cdip;
	int		i;
	int		dtype;
	char		*node_name;
	char		*driver_name;
	int		ret;

	bzero(name, sizeof (name));
	(void) strcpy(name[0], "sd");
	for (i = 0; i < SCSA1394_COMPAT_MAX; i++) {
		compatible[i] = name[i];
	}

	for (i = 0; i < sp->s_nluns; i++) {
		dtype = scsa1394_sbp2_get_lun_type(&sp->s_lun[i]);
		scsa1394_dtype2name(dtype, &node_name, &driver_name);

		ndi_devi_alloc_sleep(sp->s_dip, node_name,
		    (pnode_t)DEVI_SID_NODEID, &cdip);

		ret = ndi_prop_update_int(DDI_DEV_T_NONE, cdip,
		    SCSI_ADDR_PROP_TARGET, 0);
		if (ret != DDI_PROP_SUCCESS) {
			(void) ndi_devi_free(cdip);
			continue;
		}

		ret = ndi_prop_update_int(DDI_DEV_T_NONE, cdip,
		    SCSI_ADDR_PROP_LUN, i);
		if (ret != DDI_PROP_SUCCESS) {
			ddi_prop_remove_all(cdip);
			(void) ndi_devi_free(cdip);
			continue;
		}

		/*
		 * Some devices don't support LOG SENSE, so tell
		 * sd driver not to send this command.
		 */
		ret = ndi_prop_update_int(DDI_DEV_T_NONE, cdip,
		    "pm-capable", 1);
		if (ret != DDI_PROP_SUCCESS) {
			ddi_prop_remove_all(cdip);
			(void) ndi_devi_free(cdip);
			continue;
		}

		ret = ndi_prop_create_boolean(DDI_DEV_T_NONE, cdip,
		    "hotpluggable");
		if (ret != DDI_PROP_SUCCESS) {
			ddi_prop_remove_all(cdip);
			(void) ndi_devi_free(cdip);
			continue;
		}

		if (driver_name) {
			compatible[0] = driver_name;
			ret = ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip,
			    "compatible", (char **)compatible,
			    SCSA1394_COMPAT_MAX);
			if (ret != DDI_PROP_SUCCESS) {
				ddi_prop_remove_all(cdip);
				(void) ndi_devi_free(cdip);
				continue;
			}
		}

		/*
		 * add property "scsa1394" to distinguish from others' children
		 */
		ret = ndi_prop_create_boolean(DDI_DEV_T_NONE, cdip, "scsa1394");
		if (ret != DDI_PROP_SUCCESS) {
			ddi_prop_remove_all(cdip);
			(void) ndi_devi_free(cdip);
			continue;
		}

		(void) ddi_initchild(sp->s_dip, cdip);
	}
}

/*ARGSUSED*/
static void
scsa1394_bus_reset(dev_info_t *dip, ddi_eventcookie_t evc, void *arg,
    void *data)
{
	scsa1394_state_t	*sp = arg;

	if (sp != NULL) {
		mutex_enter(&sp->s_mutex);
		if (sp->s_dev_state == SCSA1394_DEV_DISCONNECTED) {
			mutex_exit(&sp->s_mutex);
			return;
		}
		sp->s_stat.stat_bus_reset_cnt++;
		sp->s_dev_state = SCSA1394_DEV_BUS_RESET;
		sp->s_attachinfo.localinfo = *(t1394_localinfo_t *)data;
		mutex_exit(&sp->s_mutex);

		scsa1394_sbp2_req(sp, 0, SCSA1394_THREQ_BUS_RESET);
	}
}

/*ARGSUSED*/
static void
scsa1394_disconnect(dev_info_t *dip, ddi_eventcookie_t evc, void *arg,
    void *data)
{
	scsa1394_state_t	*sp = arg;
	dev_info_t		*cdip, *cdip_next;

	if (sp == NULL) {
		return;
	}

	mutex_enter(&sp->s_mutex);
	sp->s_stat.stat_disconnect_cnt++;
	sp->s_dev_state = SCSA1394_DEV_DISCONNECTED;
	mutex_exit(&sp->s_mutex);

	scsa1394_sbp2_disconnect(sp);

	ndi_devi_enter(dip);
	for (cdip = ddi_get_child(dip); cdip != NULL; cdip = cdip_next) {
		cdip_next = ddi_get_next_sibling(cdip);

		mutex_enter(&DEVI(cdip)->devi_lock);
		DEVI_SET_DEVICE_REMOVED(cdip);
		mutex_exit(&DEVI(cdip)->devi_lock);
	}
	ndi_devi_exit(dip);
}

/*ARGSUSED*/
static void
scsa1394_reconnect(dev_info_t *dip, ddi_eventcookie_t evc, void *arg,
    void *data)
{
	scsa1394_state_t	*sp = arg;
	dev_info_t		*cdip, *cdip_next;

	if (sp == NULL) {
		return;
	}

	mutex_enter(&sp->s_mutex);
	sp->s_stat.stat_reconnect_cnt++;
	sp->s_attachinfo.localinfo = *(t1394_localinfo_t *)data;
	sp->s_disconnect_warned = B_FALSE;
	mutex_exit(&sp->s_mutex);

	ndi_devi_enter(dip);
	for (cdip = ddi_get_child(dip); cdip != NULL; cdip = cdip_next) {
		cdip_next = ddi_get_next_sibling(cdip);

		mutex_enter(&DEVI(cdip)->devi_lock);
		DEVI_SET_DEVICE_REINSERTED(cdip);
		mutex_exit(&DEVI(cdip)->devi_lock);
	}
	ndi_devi_exit(dip);

	scsa1394_sbp2_req(sp, 0, SCSA1394_THREQ_RECONNECT);
}

/*
 *
 * --- SCSA entry points
 *
 */
/*ARGSUSED*/
static int
scsa1394_scsi_tgt_init(dev_info_t *dip, dev_info_t *cdip, scsi_hba_tran_t *tran,
    struct scsi_device *sd)
{
	scsa1394_state_t *sp = (scsa1394_state_t *)tran->tran_hba_private;
	int		lun;
	int		plen = sizeof (int);
	int		ret = DDI_FAILURE;

	if (ddi_prop_op(DDI_DEV_T_ANY, cdip, PROP_LEN_AND_VAL_BUF,
	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, SCSI_ADDR_PROP_LUN,
	    (caddr_t)&lun, &plen) != DDI_PROP_SUCCESS) {
		return (DDI_FAILURE);
	}

	if (!scsa1394_is_my_child(cdip)) {
		/*
		 * add property "scsa1394" to distinguish from others' children
		 */
		ret = ndi_prop_create_boolean(DDI_DEV_T_NONE, cdip, "scsa1394");
		if (ret != DDI_PROP_SUCCESS) {
			return (DDI_FAILURE);
		}

		if (scsa1394_dev_is_online(sp)) {
			return (scsa1394_sbp2_login(sp, lun));
		} else {
			return (DDI_FAILURE);
		}
	}

	if ((lun >= sp->s_nluns) || (sp->s_lun[lun].l_cdip != NULL) ||
	    !scsa1394_dev_is_online(sp)) {
		return (DDI_FAILURE);
	}

	if ((ret = scsa1394_sbp2_login(sp, lun)) == DDI_SUCCESS) {
		sp->s_lun[lun].l_cdip = cdip;
	}
	return (ret);
}

/*ARGSUSED*/
static void
scsa1394_scsi_tgt_free(dev_info_t *dip, dev_info_t *cdip, scsi_hba_tran_t *tran,
    struct scsi_device *sd)
{
	scsa1394_state_t *sp = (scsa1394_state_t *)tran->tran_hba_private;
	int		lun;
	int		plen = sizeof (int);

	if (!scsa1394_is_my_child(cdip)) {
		return;
	}

	if (ddi_prop_op(DDI_DEV_T_ANY, cdip, PROP_LEN_AND_VAL_BUF,
	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, SCSI_ADDR_PROP_LUN,
	    (caddr_t)&lun, &plen) != DDI_PROP_SUCCESS) {
		return;
	}

	if ((lun < sp->s_nluns) && (sp->s_lun[lun].l_cdip == cdip)) {
		if (scsa1394_dev_is_online(sp)) {
			scsa1394_sbp2_logout(sp, lun, B_TRUE);
		}
		sp->s_lun[lun].l_cdip = NULL;
	}
}

static int
scsa1394_scsi_tgt_probe(struct scsi_device *sd, int (*waitfunc)())
{
	dev_info_t	*dip = ddi_get_parent(sd->sd_dev);
	scsi_hba_tran_t	*tran = (scsi_hba_tran_t *)ddi_get_driver_private(dip);
	scsa1394_state_t *sp = (scsa1394_state_t *)tran->tran_hba_private;
	scsa1394_lun_t	*lp;

	if (!scsa1394_dev_is_online(sp)) {
		return (SCSIPROBE_FAILURE);
	}
	lp = &sp->s_lun[sd->sd_address.a_lun];

	if (scsa1394_probe_g0_nodata(sd, waitfunc,
	    SCMD_TEST_UNIT_READY, 0, 0) != SCSIPROBE_EXISTS) {
		lp->l_nosup_tur = B_TRUE;
		(void) scsa1394_sbp2_reset(lp, RESET_LUN, NULL);
	}
	if (scsa1394_probe_g0_nodata(sd, waitfunc,
	    SCMD_START_STOP, 0, 1) != SCSIPROBE_EXISTS) {
		lp->l_nosup_start_stop = B_TRUE;
	}

	/* standard probe issues INQUIRY, which some devices may not support */
	if (scsi_hba_probe(sd, waitfunc) != SCSIPROBE_EXISTS) {
		lp->l_nosup_inquiry = B_TRUE;
		scsa1394_sbp2_fake_inquiry(sp, &lp->l_fake_inq);
		bcopy(&lp->l_fake_inq, sd->sd_inq, SUN_INQSIZE);
#ifndef __lock_lint
		lp->l_rmb_orig = 1;
#endif
	}

	if (scsa1394_wrka_fake_rmb) {
		sd->sd_inq->inq_rmb = 1;
	}

	return (SCSIPROBE_EXISTS);
}

static int
scsa1394_probe_g0_nodata(struct scsi_device *sd, int (*waitfunc)(),
    uchar_t cmd, uint_t addr, uint_t cnt)
{
	struct scsi_pkt	*pkt;
	int		ret = SCSIPROBE_EXISTS;

	pkt = scsi_init_pkt(&sd->sd_address, NULL, NULL, CDB_GROUP0,
	    sizeof (struct scsi_arq_status), 0, PKT_CONSISTENT, waitfunc, NULL);

	if (pkt == NULL) {
		return (SCSIPROBE_NOMEM);
	}

	(void) scsi_setup_cdb((union scsi_cdb *)pkt->pkt_cdbp, cmd, addr, cnt,
	    0);
	((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun = sd->sd_address.a_lun;
	pkt->pkt_flags = FLAG_NOINTR;

	if (scsa1394_probe_tran(pkt) < 0) {
		if (pkt->pkt_reason == CMD_INCOMPLETE) {
			ret = SCSIPROBE_NORESP;
		} else if ((pkt->pkt_reason == CMD_TRAN_ERR) &&
		    ((*(pkt->pkt_scbp) & STATUS_MASK) == STATUS_CHECK) &&
		    (pkt->pkt_state & STATE_ARQ_DONE)) {
			ret = SCSIPROBE_EXISTS;
		} else {
			ret = SCSIPROBE_FAILURE;
		}
	}

	scsi_destroy_pkt(pkt);

	return (ret);
}

static int
scsa1394_probe_tran(struct scsi_pkt *pkt)
{
	pkt->pkt_time = SCSA1394_PROBE_TIMEOUT;

	if (scsi_transport(pkt) != TRAN_ACCEPT) {
		return (-1);
	} else if ((pkt->pkt_reason == CMD_INCOMPLETE) &&
	    (pkt->pkt_state == 0)) {
		return (-1);
	} else if (pkt->pkt_reason != CMD_CMPLT) {
		return (-1);
	} else if (((*pkt->pkt_scbp) & STATUS_MASK) == STATUS_BUSY) {
		return (0);
	}
	return (0);
}

/*ARGSUSED*/
static int
scsa1394_scsi_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	return (0);
}

static int
scsa1394_scsi_reset(struct scsi_address *ap, int level)
{
	scsa1394_state_t *sp = ADDR2STATE(ap);
	scsa1394_lun_t	*lp;
	int		ret;

	switch (level) {
	case RESET_ALL:
	case RESET_TARGET:
		lp = &sp->s_lun[0];
		break;
	case RESET_LUN:
		lp = &sp->s_lun[ap->a_lun];
		break;
	default:
		return (DDI_FAILURE);
	}

	ret = scsa1394_sbp2_reset(lp, level, NULL);

	return ((ret == SBP2_SUCCESS) ? 1 : 0);
}

/*ARGSUSED*/
static int
scsa1394_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
{
	scsa1394_state_t *sp = ADDR2STATE(ap);
	size_t		dev_bsize_cap;
	int		ret = -1;

	if (!scsa1394_dev_is_online(sp)) {
		return (-1);
	}

	if (cap == NULL) {
		return (-1);
	}

	switch (scsi_hba_lookup_capstr(cap)) {
	case SCSI_CAP_DMA_MAX:
		ret = sp->s_attachinfo.dma_attr.dma_attr_maxxfer;
		break;
	case SCSI_CAP_SCSI_VERSION:
		ret = SCSI_VERSION_2;
		break;
	case SCSI_CAP_ARQ:
		ret = 1;
		break;
	case SCSI_CAP_UNTAGGED_QING:
		ret = 1;
		break;
	case SCSI_CAP_GEOMETRY:
		dev_bsize_cap = sp->s_totalsec;

		if (sp->s_secsz > DEV_BSIZE) {
			dev_bsize_cap *= sp->s_secsz / DEV_BSIZE;
		} else if (sp->s_secsz < DEV_BSIZE) {
			dev_bsize_cap /= DEV_BSIZE / sp->s_secsz;
		}

		if (dev_bsize_cap < 65536 * 2 * 18) {		/* < ~1GB */
			/* unlabeled floppy, 18k per cylinder */
			ret = ((2 << 16) | 18);
		} else if (dev_bsize_cap < 65536 * 64 * 32) {	/* < 64GB */
			/* 1024k per cylinder */
			ret = ((64 << 16) | 32);
		} else if (dev_bsize_cap < 65536 * 255 * 63) {	/* < ~500GB */
			/* ~8m per cylinder */
			ret = ((255 << 16) | 63);
		} else {					/* .. 8TB */
			/* 64m per cylinder */
			ret = ((512 << 16) | 256);
		}
		break;
	default:
		break;
	}

	return (ret);
}

/*ARGSUSED*/
static int
scsa1394_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
{
	scsa1394_state_t *sp = ADDR2STATE(ap);
	int		ret = -1;

	if (!scsa1394_dev_is_online(sp)) {
		return (-1);
	}

	switch (scsi_hba_lookup_capstr(cap)) {
	case SCSI_CAP_ARQ:
		ret = 1;
		break;
	case SCSI_CAP_DMA_MAX:
	case SCSI_CAP_SCSI_VERSION:
	case SCSI_CAP_UNTAGGED_QING:
		/* supported but not settable */
		ret = 0;
		break;
	case SCSI_CAP_SECTOR_SIZE:
		if (value) {
			sp->s_secsz = value;
		}
		break;
	case SCSI_CAP_TOTAL_SECTORS:
		if (value) {
			sp->s_totalsec = value;
		}
		break;
	default:
		break;
	}

	return (ret);
}

/*ARGSUSED*/
static void
scsa1394_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	scsa1394_cmd_t	*cmd = PKT2CMD(pkt);

	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) {
		(void) ddi_dma_sync(cmd->sc_buf_dma_hdl, 0, 0,
		    (cmd->sc_flags & SCSA1394_CMD_READ) ?
		    DDI_DMA_SYNC_FORCPU : DDI_DMA_SYNC_FORDEV);
	}
}

/*
 *
 * --- pkt resource allocation routines
 *
 */
static struct scsi_pkt *
scsa1394_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
    struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
    int (*callback)(), caddr_t arg)
{
	scsa1394_state_t *sp = ADDR2STATE(ap);
	scsa1394_lun_t	*lp;
	scsa1394_cmd_t	*cmd;
	boolean_t	is_new;	/* new cmd is being allocated */
	int		kf = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;

	if (ap->a_lun >= sp->s_nluns) {
		return (NULL);
	}
	lp = &sp->s_lun[ap->a_lun];

	/*
	 * allocate cmd space
	 */
	if (pkt == NULL) {
		is_new = B_TRUE;
		if ((cmd = kmem_cache_alloc(sp->s_cmd_cache, kf)) == NULL) {
			return (NULL);
		}

		/* initialize cmd */
		pkt = &cmd->sc_scsi_pkt;
		pkt->pkt_ha_private	= cmd;
		pkt->pkt_address	= *ap;
		pkt->pkt_private	= cmd->sc_priv;
		pkt->pkt_scbp		= (uchar_t *)&cmd->sc_scb;
		pkt->pkt_cdbp		= (uchar_t *)&cmd->sc_pkt_cdb;
		pkt->pkt_resid		= 0;

		cmd->sc_lun		= lp;
		cmd->sc_pkt		= pkt;
		cmd->sc_cdb_len		= cmdlen;
		cmd->sc_scb_len		= statuslen;
		cmd->sc_priv_len	= tgtlen;

		/* need external space? */
		if ((cmdlen > sizeof (cmd->sc_pkt_cdb)) ||
		    (statuslen > sizeof (cmd->sc_scb)) ||
		    (tgtlen > sizeof (cmd->sc_priv))) {
			if (scsa1394_cmd_ext_alloc(sp, cmd, kf) !=
			    DDI_SUCCESS) {
				kmem_cache_free(sp->s_cmd_cache, cmd);
				lp->l_stat.stat_err_pkt_kmem_alloc++;
				return (NULL);
			}
		}

		/* allocate DMA resources for CDB */
		if (scsa1394_cmd_cdb_dma_alloc(sp, cmd, flags, callback, arg) !=
		    DDI_SUCCESS) {
			scsa1394_scsi_destroy_pkt(ap, pkt);
			return (NULL);
		}
	} else {
		is_new = B_FALSE;
		cmd = PKT2CMD(pkt);
	}

	cmd->sc_flags &= ~SCSA1394_CMD_RDWR;

	/* allocate/move DMA resources for data buffer */
	if ((bp != NULL) && (bp->b_bcount > 0)) {
		if ((cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) == 0) {
			if (scsa1394_cmd_buf_dma_alloc(sp, cmd, flags, callback,
			    arg, bp) != DDI_SUCCESS) {
				if (is_new) {
					scsa1394_scsi_destroy_pkt(ap, pkt);
				}
				return (NULL);
			}
		} else {
			if (scsa1394_cmd_buf_dma_move(sp, cmd) != DDI_SUCCESS) {
				return (NULL);
			}
		}

		ASSERT(cmd->sc_win_len > 0);
		pkt->pkt_resid = bp->b_bcount - cmd->sc_win_len;
	}

	/*
	 * kernel virtual address may be required for certain workarounds
	 * and in case of B_PHYS or B_PAGEIO, bp_mapin() will get it for us
	 */
	if ((bp != NULL) && ((bp->b_flags & (B_PAGEIO | B_PHYS)) != 0) &&
	    (bp->b_bcount < SCSA1394_MAPIN_SIZE_MAX) &&
	    ((cmd->sc_flags & SCSA1394_CMD_DMA_BUF_MAPIN) == 0)) {
		bp_mapin(bp);
		cmd->sc_flags |= SCSA1394_CMD_DMA_BUF_MAPIN;
	}

	return (pkt);
}

static void
scsa1394_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	scsa1394_state_t *sp = ADDR2STATE(ap);
	scsa1394_cmd_t	*cmd = PKT2CMD(pkt);

	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) {
		scsa1394_cmd_buf_dma_free(sp, cmd);
	}
	if (cmd->sc_flags & SCSA1394_CMD_DMA_CDB_VALID) {
		scsa1394_cmd_cdb_dma_free(sp, cmd);
	}
	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_MAPIN) {
		bp_mapout(cmd->sc_bp);
		cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_MAPIN;
	}
	if (cmd->sc_flags & SCSA1394_CMD_EXT) {
		scsa1394_cmd_ext_free(sp, cmd);
	}

	kmem_cache_free(sp->s_cmd_cache, cmd);
}

static void
scsa1394_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	scsa1394_state_t *sp = ADDR2STATE(ap);
	scsa1394_cmd_t	*cmd = PKT2CMD(pkt);

	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) {
		scsa1394_cmd_buf_dma_free(sp, cmd);
	}
	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_MAPIN) {
		bp_mapout(cmd->sc_bp);
		cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_MAPIN;
	}
}

/*ARGSUSED*/
static int
scsa1394_cmd_cache_constructor(void *buf, void *cdrarg, int kf)
{
	scsa1394_cmd_t	*cmd = buf;

	bzero(buf, SCSA1394_CMD_SIZE);
	cmd->sc_task.ts_drv_priv = cmd;

	return (0);
}

/*ARGSUSED*/
static void
scsa1394_cmd_cache_destructor(void *buf, void *cdrarg)
{
}

/*
 * allocate and deallocate external cmd space (ie. not part of scsa1394_cmd_t)
 * for non-standard length cdb, pkt_private, status areas
 */
static int
scsa1394_cmd_ext_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd, int kf)
{
	struct scsi_pkt	*pkt = cmd->sc_pkt;
	void		*buf;

	if (cmd->sc_cdb_len > sizeof (cmd->sc_pkt_cdb)) {
		if ((buf = kmem_zalloc(cmd->sc_cdb_len, kf)) == NULL) {
			return (DDI_FAILURE);
		}
		pkt->pkt_cdbp = buf;
		cmd->sc_flags |= SCSA1394_CMD_CDB_EXT;
	}

	if (cmd->sc_scb_len > sizeof (cmd->sc_scb)) {
		if ((buf = kmem_zalloc(cmd->sc_scb_len, kf)) == NULL) {
			scsa1394_cmd_ext_free(sp, cmd);
			return (DDI_FAILURE);
		}
		pkt->pkt_scbp = buf;
		cmd->sc_flags |= SCSA1394_CMD_SCB_EXT;
	}

	if (cmd->sc_priv_len > sizeof (cmd->sc_priv)) {
		if ((buf = kmem_zalloc(cmd->sc_priv_len, kf)) == NULL) {
			scsa1394_cmd_ext_free(sp, cmd);
			return (DDI_FAILURE);
		}
		pkt->pkt_private = buf;
		cmd->sc_flags |= SCSA1394_CMD_PRIV_EXT;
	}

	return (DDI_SUCCESS);
}

/*ARGSUSED*/
static void
scsa1394_cmd_ext_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	struct scsi_pkt	*pkt = cmd->sc_pkt;

	if (cmd->sc_flags & SCSA1394_CMD_CDB_EXT) {
		kmem_free(pkt->pkt_cdbp, cmd->sc_cdb_len);
	}
	if (cmd->sc_flags & SCSA1394_CMD_SCB_EXT) {
		kmem_free(pkt->pkt_scbp, cmd->sc_scb_len);
	}
	if (cmd->sc_flags & SCSA1394_CMD_PRIV_EXT) {
		kmem_free(pkt->pkt_private, cmd->sc_priv_len);
	}
	cmd->sc_flags &= ~SCSA1394_CMD_EXT;
}

/*ARGSUSED*/
static int
scsa1394_cmd_cdb_dma_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd,
    int flags, int (*callback)(), caddr_t arg)
{
	if (sbp2_task_orb_alloc(cmd->sc_lun->l_lun, &cmd->sc_task,
	    sizeof (scsa1394_cmd_orb_t)) != SBP2_SUCCESS) {
		return (DDI_FAILURE);
	}

	cmd->sc_flags |= SCSA1394_CMD_DMA_CDB_VALID;
	return (DDI_SUCCESS);
}

/*ARGSUSED*/
static void
scsa1394_cmd_cdb_dma_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	sbp2_task_orb_free(cmd->sc_lun->l_lun, &cmd->sc_task);
	cmd->sc_flags &= ~SCSA1394_CMD_DMA_CDB_VALID;
}

/*
 * buffer resources
 */
static int
scsa1394_cmd_buf_dma_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd,
    int flags, int (*callback)(), caddr_t arg, struct buf *bp)
{
	scsa1394_lun_t	*lp = cmd->sc_lun;
	int		kf = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
	int		dma_flags;
	ddi_dma_cookie_t dmac;
	uint_t		ccount;
	int		error;
	int		ret;

	cmd->sc_bp = bp;

	if ((ddi_dma_alloc_handle(sp->s_dip, &sp->s_buf_dma_attr, callback,
	    NULL, &cmd->sc_buf_dma_hdl)) != DDI_SUCCESS) {
		bioerror(bp, 0);
		return (DDI_FAILURE);
	}

	cmd->sc_flags &= ~SCSA1394_CMD_RDWR;
	if (bp->b_flags & B_READ) {
		dma_flags = DDI_DMA_READ;
		cmd->sc_flags |= SCSA1394_CMD_READ;
	} else {
		dma_flags = DDI_DMA_WRITE;
		cmd->sc_flags |= SCSA1394_CMD_WRITE;
	}
	if (flags & PKT_CONSISTENT) {
		dma_flags |= DDI_DMA_CONSISTENT;
	}
	if (flags & PKT_DMA_PARTIAL) {
		dma_flags |= DDI_DMA_PARTIAL;
	}

	ret = ddi_dma_buf_bind_handle(cmd->sc_buf_dma_hdl, bp, dma_flags,
	    callback, arg, &dmac, &ccount);

	switch (ret) {
	case DDI_DMA_MAPPED:
		cmd->sc_nwin = 1;
		cmd->sc_curwin = 0;
		cmd->sc_win_offset = 0;
		cmd->sc_win_len = bp->b_bcount;
		break;

	case DDI_DMA_PARTIAL_MAP:
		/* retrieve number of windows and first window cookie */
		cmd->sc_curwin = 0;
		if ((ddi_dma_numwin(cmd->sc_buf_dma_hdl, &cmd->sc_nwin) !=
		    DDI_SUCCESS) ||
		    (ddi_dma_getwin(cmd->sc_buf_dma_hdl, cmd->sc_curwin,
		    &cmd->sc_win_offset, &cmd->sc_win_len, &dmac, &ccount) !=
		    DDI_SUCCESS)) {
			(void) ddi_dma_unbind_handle(cmd->sc_buf_dma_hdl);
			ddi_dma_free_handle(&cmd->sc_buf_dma_hdl);
			return (DDI_FAILURE);
		}
		lp->l_stat.stat_cmd_buf_dma_partial++;
		break;

	case DDI_DMA_NORESOURCES:
		error = 0;
		goto map_error;

	case DDI_DMA_BADATTR:
	case DDI_DMA_NOMAPPING:
		error = EFAULT;
		goto map_error;

	default:
		error = EINVAL;

	map_error:
		bioerror(bp, error);
		lp->l_stat.stat_err_cmd_buf_dbind++;
		ddi_dma_free_handle(&cmd->sc_buf_dma_hdl);
		return (DDI_FAILURE);
	}
	cmd->sc_flags |= SCSA1394_CMD_DMA_BUF_BIND_VALID;

	/*
	 * setup page table if needed
	 */
	if ((ccount == 1) && (dmac.dmac_size <= SBP2_PT_SEGSIZE_MAX) &&
	    (!sp->s_symbios ||
	    (dmac.dmac_size <= scsa1394_symbios_page_size))) {
		cmd->sc_buf_nsegs = 1;
		cmd->sc_buf_seg_mem.ss_len = dmac.dmac_size;
		cmd->sc_buf_seg_mem.ss_daddr = dmac.dmac_address;
		cmd->sc_buf_seg = &cmd->sc_buf_seg_mem;
	} else {
		/* break window into segments */
		if (scsa1394_cmd_dmac2seg(sp, cmd, &dmac, ccount, kf) !=
		    DDI_SUCCESS) {
			scsa1394_cmd_buf_dma_free(sp, cmd);
			bioerror(bp, 0);
			return (DDI_FAILURE);
		}

		/* allocate DMA resources for page table */
		if (scsa1394_cmd_pt_dma_alloc(sp, cmd, callback, arg,
		    cmd->sc_buf_nsegs) != DDI_SUCCESS) {
			scsa1394_cmd_buf_dma_free(sp, cmd);
			bioerror(bp, 0);
			return (DDI_FAILURE);
		}
	}

	/* allocate 1394 addresses for segments */
	if (scsa1394_cmd_buf_addr_alloc(sp, cmd) != DDI_SUCCESS) {
		scsa1394_cmd_buf_dma_free(sp, cmd);
		bioerror(bp, 0);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static void
scsa1394_cmd_buf_dma_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	scsa1394_cmd_buf_addr_free(sp, cmd);
	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_PT_VALID) {
		scsa1394_cmd_pt_dma_free(sp, cmd);
	}
	scsa1394_cmd_seg_free(sp, cmd);
	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_BIND_VALID) {
		(void) ddi_dma_unbind_handle(cmd->sc_buf_dma_hdl);
		ddi_dma_free_handle(&cmd->sc_buf_dma_hdl);
	}
	cmd->sc_flags &= ~(SCSA1394_CMD_DMA_BUF_VALID | SCSA1394_CMD_RDWR);
}

/*
 * Break a set DMA cookies into segments suitable for SBP-2 page table.
 * This routine can reuse/reallocate segment array from previous calls.
 */
static int
scsa1394_cmd_dmac2seg(scsa1394_state_t *sp, scsa1394_cmd_t *cmd,
    ddi_dma_cookie_t *dmac, uint_t ccount, int kf)
{
	scsa1394_lun_t	*lp = cmd->sc_lun;
	int		i;
	int		nsegs;
	size_t		segsize_max;
	size_t		dmac_resid;
	uint32_t	dmac_addr;
	scsa1394_cmd_seg_t *seg;

	if (!sp->s_symbios) {
		/*
		 * Number of segments is unknown at this point. Start with
		 * a reasonable estimate and grow it later if needed.
		 */
		nsegs = max(ccount, cmd->sc_win_len / SBP2_PT_SEGSIZE_MAX) * 2;
		segsize_max = SBP2_PT_SEGSIZE_MAX;
	} else {
		/*
		 * For Symbios workaround we know exactly the number of segments
		 * Additional segment may be needed if buffer is not aligned.
		 */
		nsegs =
		    howmany(cmd->sc_win_len, scsa1394_symbios_page_size) + 1;
		segsize_max = scsa1394_symbios_page_size;
	}

	if (nsegs > cmd->sc_buf_nsegs_alloc) {
		if ((cmd->sc_buf_seg = scsa1394_kmem_realloc(cmd->sc_buf_seg,
		    cmd->sc_buf_nsegs_alloc, nsegs,
		    sizeof (scsa1394_cmd_seg_t), kf)) == NULL) {
			cmd->sc_buf_nsegs_alloc = 0;
			return (DDI_FAILURE);
		}
		cmd->sc_buf_nsegs_alloc = nsegs;
	}

	/* each cookie maps into one or more segments */
	cmd->sc_buf_nsegs = 0;
	i = ccount;
	for (;;) {
		dmac_resid = dmac->dmac_size;
		dmac_addr = dmac->dmac_address;
		while (dmac_resid > 0) {
			/* grow array if needed */
			if (cmd->sc_buf_nsegs >= cmd->sc_buf_nsegs_alloc) {
				if ((cmd->sc_buf_seg = scsa1394_kmem_realloc(
				    cmd->sc_buf_seg,
				    cmd->sc_buf_nsegs_alloc,
				    cmd->sc_buf_nsegs_alloc + ccount,
				    sizeof (scsa1394_cmd_seg_t), kf)) == NULL) {
					return (DDI_FAILURE);
				}
				cmd->sc_buf_nsegs_alloc += ccount;
			}

			seg = &cmd->sc_buf_seg[cmd->sc_buf_nsegs];
			seg->ss_len = min(dmac_resid, segsize_max);
			seg->ss_daddr = (uint64_t)dmac_addr;
			dmac_addr += seg->ss_len;
			dmac_resid -= seg->ss_len;
			cmd->sc_buf_nsegs++;
		}
		ASSERT(dmac_resid == 0);

		/* grab next cookie */
		if (--i <= 0) {
			break;
		}
		ddi_dma_nextcookie(cmd->sc_buf_dma_hdl, dmac);
	}

	if (cmd->sc_buf_nsegs > lp->l_stat.stat_cmd_buf_max_nsegs) {
		lp->l_stat.stat_cmd_buf_max_nsegs = cmd->sc_buf_nsegs;
	}

	return (DDI_SUCCESS);
}

/*ARGSUSED*/
static void
scsa1394_cmd_seg_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	if (cmd->sc_buf_nsegs_alloc > 0) {
		kmem_free(cmd->sc_buf_seg, cmd->sc_buf_nsegs_alloc *
		    sizeof (scsa1394_cmd_seg_t));
	}
	cmd->sc_buf_seg = NULL;
	cmd->sc_buf_nsegs = 0;
	cmd->sc_buf_nsegs_alloc = 0;
}

static int
scsa1394_cmd_pt_dma_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd,
    int (*callback)(), caddr_t arg, int cnt)
{
	scsa1394_lun_t	*lp = cmd->sc_lun;
	size_t		len, rlen;
	uint_t		ccount;
	t1394_alloc_addr_t aa;
	int		result;

	/* allocate DMA memory for page table */
	if ((ddi_dma_alloc_handle(sp->s_dip, &sp->s_pt_dma_attr,
	    callback, NULL, &cmd->sc_pt_dma_hdl)) != DDI_SUCCESS) {
		lp->l_stat.stat_err_cmd_pt_dmem_alloc++;
		return (DDI_FAILURE);
	}

	cmd->sc_pt_ent_alloc = cnt;
	len = cmd->sc_pt_ent_alloc * SBP2_PT_ENT_SIZE;
	if (ddi_dma_mem_alloc(cmd->sc_pt_dma_hdl, len,
	    &sp->s_attachinfo.acc_attr, DDI_DMA_CONSISTENT, callback, arg,
	    &cmd->sc_pt_kaddr, &rlen, &cmd->sc_pt_acc_hdl) != DDI_SUCCESS) {
		ddi_dma_free_handle(&cmd->sc_pt_dma_hdl);
		lp->l_stat.stat_err_cmd_pt_dmem_alloc++;
		return (DDI_FAILURE);
	}

	if (ddi_dma_addr_bind_handle(cmd->sc_pt_dma_hdl, NULL,
	    cmd->sc_pt_kaddr, len, DDI_DMA_READ | DDI_DMA_CONSISTENT,
	    callback, arg, &cmd->sc_pt_dmac, &ccount) != DDI_DMA_MAPPED) {
		ddi_dma_mem_free(&cmd->sc_pt_acc_hdl);
		ddi_dma_free_handle(&cmd->sc_pt_dma_hdl);
		lp->l_stat.stat_err_cmd_pt_dmem_alloc++;
		return (DDI_FAILURE);
	}
	ASSERT(ccount == 1);	/* because dma_attr_sgllen is 1 */

	/* allocate 1394 address for page table */
	aa.aa_type = T1394_ADDR_FIXED;
	aa.aa_length = len;
	aa.aa_address = cmd->sc_pt_dmac.dmac_address;
	aa.aa_evts.recv_read_request = NULL;
	aa.aa_evts.recv_write_request = NULL;
	aa.aa_evts.recv_lock_request = NULL;
	aa.aa_arg = NULL;
	aa.aa_kmem_bufp = NULL;
	aa.aa_enable = T1394_ADDR_RDENBL;
	if (t1394_alloc_addr(sp->s_t1394_hdl, &aa, 0, &result) != DDI_SUCCESS) {
		(void) ddi_dma_unbind_handle(cmd->sc_pt_dma_hdl);
		ddi_dma_mem_free(&cmd->sc_pt_acc_hdl);
		ddi_dma_free_handle(&cmd->sc_pt_dma_hdl);
		lp->l_stat.stat_err_cmd_pt_addr_alloc++;
		return (DDI_FAILURE);
	}
	ASSERT(aa.aa_address != 0);
	cmd->sc_pt_baddr = aa.aa_address;
	cmd->sc_pt_addr_hdl = aa.aa_hdl;

	cmd->sc_flags |= SCSA1394_CMD_DMA_BUF_PT_VALID;

	return (DDI_SUCCESS);
}

static void
scsa1394_cmd_pt_dma_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	(void) ddi_dma_unbind_handle(cmd->sc_pt_dma_hdl);
	ddi_dma_mem_free(&cmd->sc_pt_acc_hdl);
	ddi_dma_free_handle(&cmd->sc_pt_dma_hdl);
	(void) t1394_free_addr(sp->s_t1394_hdl, &cmd->sc_pt_addr_hdl, 0);
	cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_PT_VALID;
}

/*
 * allocate 1394 addresses for all buffer segments
 */
static int
scsa1394_cmd_buf_addr_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	scsa1394_lun_t	*lp = cmd->sc_lun;
	t1394_alloc_addr_t aa;
	scsa1394_cmd_seg_t *seg;
	int		result;
	int		i;

	aa.aa_type = T1394_ADDR_FIXED;
	aa.aa_evts.recv_read_request = NULL;
	aa.aa_evts.recv_write_request = NULL;
	aa.aa_evts.recv_lock_request = NULL;
	aa.aa_arg = NULL;
	aa.aa_kmem_bufp = NULL;
	if (cmd->sc_flags & SCSA1394_CMD_READ) {
		aa.aa_enable = T1394_ADDR_RDENBL;
	} else {
		aa.aa_enable = T1394_ADDR_WRENBL;
	}

	for (i = 0; i < cmd->sc_buf_nsegs; i++) {
		seg = &cmd->sc_buf_seg[i];

		/* segment bus address */
		aa.aa_length = seg->ss_len;
		aa.aa_address = seg->ss_daddr;

		if (t1394_alloc_addr(sp->s_t1394_hdl, &aa, 0, &result) !=
		    DDI_SUCCESS) {
			lp->l_stat.stat_err_cmd_buf_addr_alloc++;
			return (DDI_FAILURE);
		}
		ASSERT(aa.aa_address != 0);
		seg->ss_baddr = aa.aa_address;
		seg->ss_addr_hdl = aa.aa_hdl;
	}

	cmd->sc_flags |= SCSA1394_CMD_DMA_BUF_ADDR_VALID;

	return (DDI_SUCCESS);
}

static void
scsa1394_cmd_buf_addr_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	int		i;

	for (i = 0; i < cmd->sc_buf_nsegs; i++) {
		if (cmd->sc_buf_seg[i].ss_addr_hdl) {
			(void) t1394_free_addr(sp->s_t1394_hdl,
			    &cmd->sc_buf_seg[i].ss_addr_hdl, 0);
		}
	}
	cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_ADDR_VALID;
}

/*
 * move to next DMA window
 */
static int
scsa1394_cmd_buf_dma_move(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	/* scsa1394_lun_t	*lp = cmd->sc_lun; */
	ddi_dma_cookie_t dmac;
	uint_t		ccount;

	/* for small pkts, leave things where they are (says WDD) */
	if ((cmd->sc_curwin == cmd->sc_nwin) && (cmd->sc_nwin == 1)) {
		return (DDI_SUCCESS);
	}
	if (++cmd->sc_curwin >= cmd->sc_nwin) {
		return (DDI_FAILURE);
	}
	if (ddi_dma_getwin(cmd->sc_buf_dma_hdl, cmd->sc_curwin,
	    &cmd->sc_win_offset, &cmd->sc_win_len, &dmac, &ccount) !=
	    DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	scsa1394_cmd_buf_addr_free(sp, cmd);

	/*
	 * setup page table if needed
	 */
	if ((ccount == 1) && (dmac.dmac_size <= SBP2_PT_SEGSIZE_MAX) &&
	    (!sp->s_symbios ||
	    (dmac.dmac_size <= scsa1394_symbios_page_size))) {
		/* but first, free old resources */
		if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_PT_VALID) {
			scsa1394_cmd_pt_dma_free(sp, cmd);
		}
		scsa1394_cmd_seg_free(sp, cmd);

		cmd->sc_buf_nsegs = 1;
		cmd->sc_buf_seg_mem.ss_len = dmac.dmac_size;
		cmd->sc_buf_seg_mem.ss_daddr = dmac.dmac_address;
		cmd->sc_buf_seg = &cmd->sc_buf_seg_mem;
	} else {
		/* break window into segments */
		if (scsa1394_cmd_dmac2seg(sp, cmd, &dmac, ccount, KM_NOSLEEP) !=
		    DDI_SUCCESS) {
			return (DDI_FAILURE);
		}

		/* allocate DMA resources */
		if (scsa1394_cmd_pt_dma_alloc(sp, cmd, NULL_FUNC, NULL,
		    cmd->sc_buf_nsegs) != DDI_SUCCESS) {
			return (DDI_FAILURE);
		}
	}

	/* allocate 1394 addresses for segments */
	if (scsa1394_cmd_buf_addr_alloc(sp, cmd) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

/*
 *
 * --- pkt and data transfer routines
 *
 */
static int
scsa1394_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	scsa1394_state_t *sp = ADDR2STATE(ap);
	scsa1394_cmd_t	*cmd = PKT2CMD(pkt);
	scsa1394_lun_t	*lp = cmd->sc_lun;
	int		ret;

	/*
	 * since we don't support polled I/O, just accept the packet
	 * so the rest of the file systems get synced properly
	 */
	if (ddi_in_panic()) {
		scsa1394_prepare_pkt(sp, pkt);
		return (TRAN_ACCEPT);
	}

	/* polling not supported yet */
	if (pkt->pkt_flags & FLAG_NOINTR) {
		return (TRAN_BADPKT);
	}

	mutex_enter(&sp->s_mutex);
	if (sp->s_dev_state != SCSA1394_DEV_ONLINE) {
		/*
		 * If device is temporarily gone due to bus reset,
		 * return busy to prevent prevent scary console messages.
		 * If permanently gone, leave it to scsa1394_cmd_fake_comp().
		 */
		if (sp->s_dev_state == SCSA1394_DEV_BUS_RESET) {
			mutex_exit(&sp->s_mutex);
			return (TRAN_BUSY);
		}
	}
	mutex_exit(&sp->s_mutex);

	if ((ap->a_lun >= sp->s_nluns) ||
	    (ap->a_lun != pkt->pkt_address.a_lun)) {
		return (TRAN_BADPKT);
	}

	scsa1394_prepare_pkt(sp, pkt);

	/* some commands may require fake completion */
	if ((ret = scsa1394_cmd_fake_comp(sp, cmd)) == DDI_SUCCESS) {
		return (TRAN_ACCEPT);
	}

	scsa1394_cmd_fill_cdb(lp, cmd);

	if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_PT_VALID) {
		scsa1394_sbp2_seg2pt(lp, cmd);
	}

	scsa1394_sbp2_cmd2orb(lp, cmd);		/* convert into ORB */

	if ((ret = scsa1394_sbp2_start(lp, cmd)) != TRAN_BUSY) {
		scsa1394_sbp2_nudge(lp);
	}

	return (ret);
}

/*ARGSUSED*/
static void
scsa1394_prepare_pkt(scsa1394_state_t *sp, struct scsi_pkt *pkt)
{
	scsa1394_cmd_t	*cmd = PKT2CMD(pkt);

	pkt->pkt_reason = CMD_CMPLT;
	pkt->pkt_state = 0;
	pkt->pkt_statistics = 0;
	*(pkt->pkt_scbp) = STATUS_GOOD;

	if (cmd) {
		cmd->sc_timeout = pkt->pkt_time;

		/* workarounds */
		switch (pkt->pkt_cdbp[0]) {
		/*
		 * sd does START_STOP_UNIT during attach with a 200 sec timeout.
		 * at this time devi_lock is held, prtconf will be stuck.
		 * reduce timeout for the time being.
		 */
		case SCMD_START_STOP:
			cmd->sc_timeout = min(cmd->sc_timeout,
			    scsa1394_start_stop_timeout_max);
			break;
		default:
			break;
		}
	}
}

static void
scsa1394_cmd_fill_cdb(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
{
	cmd->sc_cdb_actual_len = cmd->sc_cdb_len;

	mutex_enter(&lp->l_mutex);

	switch (lp->l_dtype_orig) {
	case DTYPE_DIRECT:
	case DTYPE_RODIRECT:
	case DTYPE_OPTICAL:
	case SCSA1394_DTYPE_RBC:
		scsa1394_cmd_fill_cdb_rbc(lp, cmd);
		break;
	default:
		scsa1394_cmd_fill_cdb_other(lp, cmd);
		break;
	}

	mutex_exit(&lp->l_mutex);
}

static void
scsa1394_cmd_fill_cdb_rbc(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
{
	scsa1394_state_t *sp = lp->l_sp;
	struct scsi_pkt	*pkt = CMD2PKT(cmd);
	int		lba, opcode;
	struct buf	*bp = cmd->sc_bp;
	size_t		len;
	size_t		blk_size;
	int		sz;

	opcode = pkt->pkt_cdbp[0];
	blk_size  = lp->l_lba_size;

	switch (opcode) {
	case SCMD_READ:
		/* RBC only supports 10-byte read/write */
		lba = SCSA1394_LBA_6BYTE(pkt);
		len = SCSA1394_LEN_6BYTE(pkt);
		opcode = SCMD_READ_G1;
		cmd->sc_cdb_actual_len = CDB_GROUP1;
		break;
	case SCMD_WRITE:
		lba = SCSA1394_LBA_6BYTE(pkt);
		len = SCSA1394_LEN_6BYTE(pkt);
		opcode = SCMD_WRITE_G1;
		cmd->sc_cdb_actual_len = CDB_GROUP1;
		break;
	case SCMD_READ_G1:
	case SCMD_READ_LONG:
		lba = SCSA1394_LBA_10BYTE(pkt);
		len = SCSA1394_LEN_10BYTE(pkt);
		break;
	case SCMD_WRITE_G1:
	case SCMD_WRITE_LONG:
		lba = SCSA1394_LBA_10BYTE(pkt);
		len = SCSA1394_LEN_10BYTE(pkt);
		if ((lp->l_dtype_orig == DTYPE_RODIRECT) &&
		    (bp != NULL) && (len != 0)) {
			sz = SCSA1394_CDRW_BLKSZ(bp->b_bcount, len);
			if (SCSA1394_VALID_CDRW_BLKSZ(sz)) {
				blk_size = sz;
			}
		}
		break;
	case SCMD_READ_CD:
		lba = SCSA1394_LBA_10BYTE(pkt);
		len = SCSA1394_LEN_READ_CD(pkt);
		blk_size = scsa1394_cmd_read_cd_blk_size(pkt->pkt_cdbp[1] >> 2);
		break;
	case SCMD_READ_G5:
		lba = SCSA1394_LBA_12BYTE(pkt);
		len = SCSA1394_LEN_12BYTE(pkt);
		break;
	case SCMD_WRITE_G5:
		lba = SCSA1394_LBA_12BYTE(pkt);
		len = SCSA1394_LEN_12BYTE(pkt);
		break;
	default:
		/* no special mapping for other commands */
		scsa1394_cmd_fill_cdb_other(lp, cmd);
		return;
	}
	cmd->sc_blk_size = blk_size;

	/* limit xfer length for Symbios workaround */
	if (sp->s_symbios && (len * blk_size > scsa1394_symbios_size_max)) {
		cmd->sc_flags |= SCSA1394_CMD_SYMBIOS_BREAKUP;

		cmd->sc_total_blks = cmd->sc_resid_blks = len;

		len = scsa1394_symbios_size_max / blk_size;
	}
	cmd->sc_xfer_blks = len;
	cmd->sc_xfer_bytes = len * blk_size;

	/* finalize new CDB */
	switch (pkt->pkt_cdbp[0]) {
	case SCMD_READ:
	case SCMD_WRITE:
		/*
		 * We rewrite READ/WRITE G0 commands as READ/WRITE G1.
		 * Build new cdb from scatch.
		 * The lba and length fields is updated below.
		 */
		bzero(cmd->sc_cdb, cmd->sc_cdb_actual_len);
		break;
	default:
		/*
		 * Copy the non lba/len fields.
		 * The lba and length fields is updated below.
		 */
		bcopy(pkt->pkt_cdbp, cmd->sc_cdb, cmd->sc_cdb_actual_len);
		break;
	}

	cmd->sc_cdb[0] = (uchar_t)opcode;
	scsa1394_cmd_fill_cdb_lba(cmd, lba);
	switch (opcode) {
	case SCMD_READ_CD:
		scsa1394_cmd_fill_read_cd_cdb_len(cmd, len);
		break;
	case SCMD_WRITE_G5:
	case SCMD_READ_G5:
		scsa1394_cmd_fill_12byte_cdb_len(cmd, len);
		break;
	default:
		scsa1394_cmd_fill_cdb_len(cmd, len);
		break;
	}
}

/*ARGSUSED*/
static void
scsa1394_cmd_fill_cdb_other(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
{
	struct scsi_pkt	*pkt = CMD2PKT(cmd);

	cmd->sc_xfer_bytes = cmd->sc_win_len;
	cmd->sc_xfer_blks = cmd->sc_xfer_bytes / lp->l_lba_size;
	cmd->sc_total_blks = cmd->sc_xfer_blks;
	cmd->sc_lba = 0;

	bcopy(pkt->pkt_cdbp, cmd->sc_cdb, cmd->sc_cdb_len);
}

/*
 * fill up parts of CDB
 */
static void
scsa1394_cmd_fill_cdb_len(scsa1394_cmd_t *cmd, int len)
{
	cmd->sc_cdb[7] = len >> 8;
	cmd->sc_cdb[8] = (uchar_t)len;
}

static void
scsa1394_cmd_fill_cdb_lba(scsa1394_cmd_t *cmd, int lba)
{
	cmd->sc_cdb[2] = lba >> 24;
	cmd->sc_cdb[3] = lba >> 16;
	cmd->sc_cdb[4] = lba >> 8;
	cmd->sc_cdb[5] = (uchar_t)lba;
	cmd->sc_lba = lba;
}

static void
scsa1394_cmd_fill_12byte_cdb_len(scsa1394_cmd_t *cmd, int len)
{
	cmd->sc_cdb[6] = len >> 24;
	cmd->sc_cdb[7] = len >> 16;
	cmd->sc_cdb[8] = len >> 8;
	cmd->sc_cdb[9] = (uchar_t)len;
}

static void
scsa1394_cmd_fill_read_cd_cdb_len(scsa1394_cmd_t *cmd, int len)
{
	cmd->sc_cdb[6] = len >> 16;
	cmd->sc_cdb[7] = len >> 8;
	cmd->sc_cdb[8] = (uchar_t)len;
}

/*
 * For SCMD_READ_CD, figure out the block size based on expected sector type.
 * See MMC SCSI Specs section 6.1.15
 */
static int
scsa1394_cmd_read_cd_blk_size(uchar_t expected_sector_type)
{
	int blk_size;

	switch (expected_sector_type) {
	case READ_CD_EST_CDDA:
		blk_size = CDROM_BLK_2352;
		break;
	case READ_CD_EST_MODE2:
		blk_size = CDROM_BLK_2336;
		break;
	case READ_CD_EST_MODE2FORM2:
		blk_size = CDROM_BLK_2324;
		break;
	case READ_CD_EST_MODE2FORM1:
	case READ_CD_EST_ALLTYPE:
	case READ_CD_EST_MODE1:
	default:
		blk_size = CDROM_BLK_2048;
	}

	return (blk_size);
}

/*ARGSUSED*/
static int
scsa1394_cmd_fake_mode_sense(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	struct scsi_pkt	*pkt = CMD2PKT(cmd);
	struct scsi_arq_status *arqp = (struct scsi_arq_status *)pkt->pkt_scbp;
	struct scsi_extended_sense *esp = &arqp->sts_sensedata;

	*(pkt->pkt_scbp) = STATUS_CHECK;
	*(uint8_t *)&arqp->sts_rqpkt_status = STATUS_GOOD;
	arqp->sts_rqpkt_reason = CMD_CMPLT;
	arqp->sts_rqpkt_resid = 0;
	arqp->sts_rqpkt_state |= STATE_XFERRED_DATA;
	arqp->sts_rqpkt_statistics = 0;

	bzero(esp, sizeof (struct scsi_extended_sense));

	esp->es_class = CLASS_EXTENDED_SENSE;

	esp->es_key = KEY_ILLEGAL_REQUEST;

	pkt->pkt_reason = CMD_CMPLT;
	pkt->pkt_state |= (STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD |
	    STATE_XFERRED_DATA | STATE_GOT_STATUS);

	if (pkt->pkt_comp) {
		(*pkt->pkt_comp)(pkt);
	}
	return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
scsa1394_cmd_fake_inquiry(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	scsa1394_lun_t	*lp = cmd->sc_lun;
	struct scsi_pkt	*pkt = CMD2PKT(cmd);
	struct scsi_inquiry *inq;

	/* copy fabricated inquiry data */
	inq = (struct scsi_inquiry *)cmd->sc_bp->b_un.b_addr;
	bcopy(&lp->l_fake_inq, inq, sizeof (struct scsi_inquiry));

	pkt->pkt_resid -= sizeof (struct scsi_inquiry);
	pkt->pkt_reason = CMD_CMPLT;
	pkt->pkt_state |= (STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD |
	    STATE_XFERRED_DATA | STATE_GOT_STATUS);

	if (pkt->pkt_comp) {
		(*pkt->pkt_comp)(pkt);
	}
	return (DDI_SUCCESS);
}

/*
 * If command allows fake completion (without actually being transported),
 * call completion callback and return DDI_SUCCESS.
 * Otherwise return DDI_FAILURE.
 */
static int
scsa1394_cmd_fake_comp(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
{
	struct scsi_pkt	*pkt = CMD2PKT(cmd);
	scsa1394_lun_t	*lp = cmd->sc_lun;
	int		ret = DDI_SUCCESS;

	/*
	 * agreement with sd in case of device hot removal
	 * is to fake completion with CMD_DEV_GONE
	 */
	mutex_enter(&sp->s_mutex);
	if (sp->s_dev_state != SCSA1394_DEV_ONLINE) {
		mutex_exit(&sp->s_mutex);
		pkt->pkt_reason = CMD_DEV_GONE;
		if (pkt->pkt_comp) {
			(*pkt->pkt_comp)(pkt);
		}
		return (DDI_SUCCESS);
	}
	mutex_exit(&sp->s_mutex);

	mutex_enter(&lp->l_mutex);

	switch (pkt->pkt_cdbp[0]) {
	/*
	 * RBC support for PRIN/PROUT is optional
	 */
	case SCMD_PRIN:
	case SCMD_PROUT:
		if (!scsa1394_wrka_fake_prin) {
			ret = DDI_FAILURE;
		}
		break;
	/*
	 * Some fixed disks don't like doorlock cmd. And they don't need it.
	 */
	case SCMD_DOORLOCK:
		if (lp->l_rmb_orig != 0) {
			ret = DDI_FAILURE;
		}
		break;
	case SCMD_TEST_UNIT_READY:
		if (!lp->l_nosup_tur) {
			ret = DDI_FAILURE;
		}
		break;
	case SCMD_START_STOP:
		if (!lp->l_nosup_start_stop) {
			ret = DDI_FAILURE;
		}
		break;
	case SCMD_INQUIRY:
		if (!lp->l_nosup_inquiry) {
			ret = DDI_FAILURE;
		} else {
			mutex_exit(&lp->l_mutex);
			return (scsa1394_cmd_fake_inquiry(sp, cmd));
		}
		break;
	case SCMD_MODE_SENSE:
		if (!lp->l_mode_sense_fake) {
			ret = DDI_FAILURE;
		} else {
			mutex_exit(&lp->l_mutex);
			return (scsa1394_cmd_fake_mode_sense(sp, cmd));
		}
		break;
	default:
		ret = DDI_FAILURE;
	}

	mutex_exit(&lp->l_mutex);

	if (ret != DDI_SUCCESS) {
		return (ret);
	}

	ASSERT(*(pkt->pkt_scbp) == STATUS_GOOD);
	ASSERT(pkt->pkt_reason == CMD_CMPLT);
	pkt->pkt_state |= (STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD |
	    STATE_XFERRED_DATA | STATE_GOT_STATUS);

	if (pkt->pkt_comp) {
		(*pkt->pkt_comp)(pkt);
	}
	return (DDI_SUCCESS);
}

/*
 * Returns DDI_SUCCESS if next xfer setup successfully, DDI_FAILURE otherwise.
 */
static int
scsa1394_cmd_setup_next_xfer(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
{
	struct scsi_pkt		*pkt = CMD2PKT(cmd);

	ASSERT(cmd->sc_flags & SCSA1394_CMD_SYMBIOS_BREAKUP);

	cmd->sc_resid_blks -= cmd->sc_xfer_blks;
	if (cmd->sc_resid_blks <= 0) {
		pkt->pkt_resid = 0;
		return (DDI_FAILURE);
	}

	scsa1394_cmd_adjust_cdb(lp, cmd);

	scsa1394_sbp2_seg2pt(lp, cmd);

	scsa1394_sbp2_cmd2orb(lp, cmd);

	if (scsa1394_sbp2_start(lp, cmd) != TRAN_ACCEPT) {
		pkt->pkt_resid = cmd->sc_resid_blks * cmd->sc_blk_size;
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

/*
 * new lba = current lba + previous xfer len
 */
/*ARGSUSED*/
static void
scsa1394_cmd_adjust_cdb(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
{
	int		len;

	ASSERT(cmd->sc_flags & SCSA1394_CMD_SYMBIOS_BREAKUP);

	cmd->sc_lba += cmd->sc_xfer_blks;
	len = cmd->sc_resid_blks;

	/* limit xfer length for Symbios workaround */
	if (len * cmd->sc_blk_size > scsa1394_symbios_size_max) {
		len = scsa1394_symbios_size_max / cmd->sc_blk_size;
	}

	switch (cmd->sc_cdb[0]) {
	case SCMD_READ_CD:
		scsa1394_cmd_fill_read_cd_cdb_len(cmd, len);
		break;
	case SCMD_WRITE_G5:
	case SCMD_READ_G5:
		scsa1394_cmd_fill_12byte_cdb_len(cmd, len);
		break;
	case SCMD_WRITE_G1:
	case SCMD_WRITE_LONG:
	default:
		scsa1394_cmd_fill_cdb_len(cmd, len);
	}

	scsa1394_cmd_fill_cdb_lba(cmd, cmd->sc_lba);

	cmd->sc_xfer_blks = len;
	cmd->sc_xfer_bytes = len * cmd->sc_blk_size;
}

void
scsa1394_cmd_status_proc(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
{
	struct scsi_pkt		*pkt = CMD2PKT(cmd);

	/* next iteration of partial xfer? */
	if ((pkt->pkt_reason == CMD_CMPLT) &&
	    (cmd->sc_flags & SCSA1394_CMD_SYMBIOS_BREAKUP)) {
		if (scsa1394_cmd_setup_next_xfer(lp, cmd) == DDI_SUCCESS) {
			return;
		}
	}
	cmd->sc_flags &= ~SCSA1394_CMD_SYMBIOS_BREAKUP;

	/* apply workarounds */
	if (pkt->pkt_reason == CMD_CMPLT) {
		scsa1394_cmd_status_wrka(lp, cmd);
	}

	mutex_enter(&lp->l_mutex);

	/* mode sense workaround */
	if (pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
		if (pkt->pkt_reason == CMD_CMPLT) {
			lp->l_mode_sense_fail_cnt = 0;
		} else if (++lp->l_mode_sense_fail_cnt >=
		    scsa1394_mode_sense_fail_max) {
			lp->l_mode_sense_fake = B_TRUE;
		}
	} else {
		lp->l_mode_sense_fail_cnt = 0;
	}

	mutex_exit(&lp->l_mutex);

	if (pkt->pkt_comp) {
		(*pkt->pkt_comp)(pkt);
	}
}

static void
scsa1394_cmd_status_wrka(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
{
	struct scsi_pkt	*pkt = CMD2PKT(cmd);

	mutex_enter(&lp->l_mutex);

	switch (pkt->pkt_cdbp[0]) {
	case SCMD_INQUIRY: {
		struct scsi_inquiry *inq;

		inq = (struct scsi_inquiry *)cmd->sc_bp->b_un.b_addr;

		/* change dtype RBC to DIRECT, sd doesn't support RBC */
		lp->l_dtype_orig = inq->inq_dtype;
		if ((inq->inq_dtype == SCSA1394_DTYPE_RBC) &&
		    scsa1394_wrka_rbc2direct) {
			inq->inq_dtype = DTYPE_DIRECT;
		}

		/* force RMB to 1 */
		lp->l_rmb_orig = inq->inq_rmb;
		if (scsa1394_wrka_fake_rmb) {
			inq->inq_rmb = 1;
		}
		break;
	}
	case SCMD_READ_CAPACITY: {
		uint32_t	*capacity_buf;

		capacity_buf = (uint32_t *)cmd->sc_bp->b_un.b_addr;

		if (lp->l_dtype_orig != DTYPE_RODIRECT) {
			lp->l_lba_size = min(BE_32(capacity_buf[1]), DEV_BSIZE);
			if (lp->l_lba_size == 0) {
				cmn_err(CE_WARN, "zero LBA size reported, "
				    "possibly broken device");
				lp->l_lba_size = DEV_BSIZE;
			}
		} else {
			lp->l_lba_size = 2048;
		}
	}
	default:
		break;
	}

	mutex_exit(&lp->l_mutex);
}

/*
 * --- thread management
 *
 * dispatch a thread
 */
int
scsa1394_thr_dispatch(scsa1394_thread_t *thr)
{
	scsa1394_lun_t		*lp = thr->thr_lun;
	scsa1394_state_t	*sp = lp->l_sp;
	int			ret;

	ASSERT(mutex_owned(&lp->l_mutex));
	ASSERT(thr->thr_state == SCSA1394_THR_INIT);

	thr->thr_state = SCSA1394_THR_RUN;

	ret = ddi_taskq_dispatch(sp->s_taskq, thr->thr_func, thr->thr_arg,
	    KM_SLEEP);
	return (ret);
}

/*
 * cancel thread
 */
void
scsa1394_thr_cancel(scsa1394_thread_t *thr)
{
	scsa1394_lun_t		*lp = thr->thr_lun;

	ASSERT(mutex_owned(&lp->l_mutex));

	thr->thr_req |= SCSA1394_THREQ_EXIT;
	cv_signal(&thr->thr_cv);

	/* wait until the thread actually exits */
	do {
		if (cv_wait_sig(&thr->thr_cv, &lp->l_mutex) == 0) {
			break;
		}
	} while (thr->thr_state != SCSA1394_THR_EXIT);
}

/*
 * wake thread
 */
void
scsa1394_thr_wake(scsa1394_thread_t *thr, int req)
{
	scsa1394_lun_t		*lp = thr->thr_lun;

	ASSERT(mutex_owned(&lp->l_mutex));

	thr->thr_req |= req;
	cv_signal(&thr->thr_cv);
}

void
scsa1394_thr_clear_req(scsa1394_thread_t *thr, int mask)
{
	scsa1394_lun_t		*lp = thr->thr_lun;

	mutex_enter(&lp->l_mutex);
	thr->thr_req &= ~mask;
	mutex_exit(&lp->l_mutex);
}

/*
 *
 * --- other routines
 *
 */
static boolean_t
scsa1394_is_my_child(dev_info_t *dip)
{
	return ((dip != NULL) && (ddi_prop_exists(DDI_DEV_T_ANY, dip,
	    DDI_PROP_DONTPASS, "scsa1394") == 1));
}

boolean_t
scsa1394_dev_is_online(scsa1394_state_t *sp)
{
	boolean_t	ret;

	mutex_enter(&sp->s_mutex);
	ret = (sp->s_dev_state == SCSA1394_DEV_ONLINE);
	mutex_exit(&sp->s_mutex);

	return (ret);
}

static void *
scsa1394_kmem_realloc(void *old_buf, int old_size, int new_size, size_t elsize,
    int kf)
{
	void	*new_buf;

	new_buf = kmem_zalloc(new_size * elsize, kf);

	if (old_size > 0) {
		if (new_buf != NULL) {
			bcopy(old_buf, new_buf, old_size * elsize);
		}
		kmem_free(old_buf, old_size * elsize);
	}

	return (new_buf);
}