xref: /onnv-gate/usr/src/uts/intel/io/amr/amr.c (revision 9106:ee8f18cdafb2)

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * Copyright (c) 1999,2000 Michael Smith
 * Copyright (c) 2000 BSDi
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/*
 * Copyright (c) 2002 Eric Moore
 * Copyright (c) 2002 LSI Logic Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The party using or redistributing the source code and binary forms
 *    agrees to the disclaimer below and the terms and conditions set forth
 *    herein.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/int_types.h>
#include <sys/scsi/scsi.h>
#include <sys/dkbad.h>
#include <sys/dklabel.h>
#include <sys/dkio.h>
#include <sys/cdio.h>
#include <sys/mhd.h>
#include <sys/vtoc.h>
#include <sys/dktp/fdisk.h>
#include <sys/scsi/targets/sddef.h>
#include <sys/debug.h>
#include <sys/pci.h>
#include <sys/ksynch.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/byteorder.h>

#include "amrreg.h"
#include "amrvar.h"

/* dynamic debug symbol */
int	amr_debug_var = 0;

#define	AMR_DELAY(cond, count, done_flag) { \
		int local_counter = 0; \
		done_flag = 1; \
		while (!(cond)) { \
			delay(drv_usectohz(100)); \
			if ((local_counter) > count) { \
				done_flag = 0; \
				break; \
			} \
			(local_counter)++; \
		} \
	}

#define	AMR_BUSYWAIT(cond, count, done_flag) { \
		int local_counter = 0; \
		done_flag = 1; \
		while (!(cond)) { \
			drv_usecwait(100); \
			if ((local_counter) > count) { \
				done_flag = 0; \
				break; \
			} \
			(local_counter)++; \
		} \
	}

/*
 * driver interfaces
 */
char _depends_on[] = "misc/scsi";

static uint_t amr_intr(caddr_t arg);
static void amr_done(struct amr_softs *softs);

static int amr_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
			void *arg, void **result);
static int amr_attach(dev_info_t *, ddi_attach_cmd_t);
static int amr_detach(dev_info_t *, ddi_detach_cmd_t);

static int amr_setup_mbox(struct amr_softs *softs);
static int amr_setup_sg(struct amr_softs *softs);

/*
 * Command wrappers
 */
static int amr_query_controller(struct amr_softs *softs);
static void *amr_enquiry(struct amr_softs *softs, size_t bufsize,
			uint8_t cmd, uint8_t cmdsub, uint8_t cmdqual);
static int amr_flush(struct amr_softs *softs);

/*
 * Command processing.
 */
static void amr_rw_command(struct amr_softs *softs,
			struct scsi_pkt *pkt, int lun);
static void amr_mode_sense(union scsi_cdb *cdbp, struct buf *bp,
			unsigned int capacity);
static void amr_set_arq_data(struct scsi_pkt *pkt, uchar_t key);
static int amr_enquiry_mapcmd(struct amr_command *ac, uint32_t data_size);
static void amr_enquiry_unmapcmd(struct amr_command *ac);
static int amr_mapcmd(struct amr_command *ac, int (*callback)(), caddr_t arg);
static void amr_unmapcmd(struct amr_command *ac);

/*
 * Status monitoring
 */
static void amr_periodic(void *data);

/*
 * Interface-specific shims
 */
static int amr_poll_command(struct amr_command *ac);
static void amr_start_waiting_queue(void *softp);
static void amr_call_pkt_comp(struct amr_command *head);

/*
 * SCSI interface
 */
static int amr_setup_tran(dev_info_t  *dip, struct amr_softs *softp);

/*
 * Function prototypes
 *
 * SCSA functions exported by means of the transport table
 */
static int amr_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
	scsi_hba_tran_t *tran, struct scsi_device *sd);
static int amr_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt);
static int amr_tran_reset(struct scsi_address *ap, int level);
static int amr_tran_getcap(struct scsi_address *ap, char *cap, int whom);
static int amr_tran_setcap(struct scsi_address *ap, char *cap, int value,
    int whom);
static struct scsi_pkt *amr_tran_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);
static void amr_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt);
static void amr_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt);
static void amr_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt);

static ddi_dma_attr_t buffer_dma_attr = {
		DMA_ATTR_V0,	/* version of this structure */
		0,		/* lowest usable address */
		0xffffffffull,	/* highest usable address */
		0x00ffffffull,	/* maximum DMAable byte count */
		4,		/* alignment */
		1,		/* burst sizes */
		1,		/* minimum transfer */
		0xffffffffull,	/* maximum transfer */
		0xffffffffull,	/* maximum segment length */
		AMR_NSEG,	/* maximum number of segments */
		AMR_BLKSIZE,	/* granularity */
		0,		/* flags (reserved) */
};

static ddi_dma_attr_t addr_dma_attr = {
		DMA_ATTR_V0,	/* version of this structure */
		0,		/* lowest usable address */
		0xffffffffull,	/* highest usable address */
		0x7fffffff,	/* maximum DMAable byte count */
		4,		/* alignment */
		1,		/* burst sizes */
		1,		/* minimum transfer */
		0xffffffffull,	/* maximum transfer */
		0xffffffffull,	/* maximum segment length */
		1,		/* maximum number of segments */
		1,		/* granularity */
		0,		/* flags (reserved) */
};


static struct dev_ops   amr_ops = {
	DEVO_REV,	/* devo_rev, */
	0,		/* refcnt  */
	amr_info,	/* info */
	nulldev,	/* identify */
	nulldev,	/* probe */
	amr_attach,	/* attach */
	amr_detach,	/* detach */
	nodev,		/* reset */
	NULL,		/* driver operations */
	(struct bus_ops *)0,	/* bus operations */
	0,		/* power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};


extern struct mod_ops mod_driverops;
static struct modldrv modldrv = {
	&mod_driverops,		/* Type of module. driver here */
	"AMR Driver",		/* Name of the module. */
	&amr_ops,		/* Driver ops vector */
};

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

/* DMA access attributes */
static ddi_device_acc_attr_t accattr = {
	DDI_DEVICE_ATTR_V0,
	DDI_NEVERSWAP_ACC,
	DDI_STRICTORDER_ACC
};

static struct amr_softs  *amr_softstatep;


int
_init(void)
{
	int		error;

	error = ddi_soft_state_init((void *)&amr_softstatep,
	    sizeof (struct amr_softs), 0);

	if (error != 0)
		goto error_out;

	if ((error = scsi_hba_init(&modlinkage)) != 0) {
		ddi_soft_state_fini((void*)&amr_softstatep);
		goto error_out;
	}

	error = mod_install(&modlinkage);
	if (error != 0) {
		scsi_hba_fini(&modlinkage);
		ddi_soft_state_fini((void*)&amr_softstatep);
		goto error_out;
	}

	return (error);

error_out:
	cmn_err(CE_NOTE, "_init failed");
	return (error);
}

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

int
_fini(void)
{
	int	error;

	if ((error = mod_remove(&modlinkage)) != 0) {
		return (error);
	}

	scsi_hba_fini(&modlinkage);

	ddi_soft_state_fini((void*)&amr_softstatep);
	return (error);
}


static int
amr_attach(dev_info_t *dev, ddi_attach_cmd_t cmd)
{
	struct amr_softs	*softs;
	int			error;
	uint32_t		command, i;
	int			instance;
	caddr_t			cfgaddr;

	instance = ddi_get_instance(dev);

	switch (cmd) {
		case DDI_ATTACH:
			break;

		case DDI_RESUME:
			return (DDI_FAILURE);

		default:
			return (DDI_FAILURE);
	}

	/*
	 * Initialize softs.
	 */
	if (ddi_soft_state_zalloc(amr_softstatep, instance) != DDI_SUCCESS)
		return (DDI_FAILURE);
	softs = ddi_get_soft_state(amr_softstatep, instance);
	softs->state |= AMR_STATE_SOFT_STATE_SETUP;

	softs->dev_info_p = dev;

	AMRDB_PRINT((CE_NOTE, "softs: %p; busy_slot addr: %p",
	    (void *)softs, (void *)&(softs->amr_busyslots)));

	if (pci_config_setup(dev, &(softs->pciconfig_handle))
	    != DDI_SUCCESS) {
		goto error_out;
	}
	softs->state |= AMR_STATE_PCI_CONFIG_SETUP;

	error = ddi_regs_map_setup(dev, 1, &cfgaddr, 0, 0,
	    &accattr, &(softs->regsmap_handle));
	if (error != DDI_SUCCESS) {
		goto error_out;
	}
	softs->state |= AMR_STATE_PCI_MEM_MAPPED;

	/*
	 * Determine board type.
	 */
	command = pci_config_get16(softs->pciconfig_handle, PCI_CONF_COMM);

	/*
	 * Make sure we are going to be able to talk to this board.
	 */
	if ((command & PCI_COMM_MAE) == 0) {
		AMRDB_PRINT((CE_NOTE,  "memory window not available"));
		goto error_out;
	}

	/* force the busmaster enable bit on */
	if (!(command & PCI_COMM_ME)) {
		command |= PCI_COMM_ME;
		pci_config_put16(softs->pciconfig_handle,
		    PCI_CONF_COMM, command);
		command = pci_config_get16(softs->pciconfig_handle,
		    PCI_CONF_COMM);
		if (!(command & PCI_COMM_ME))
			goto error_out;
	}

	/*
	 * Allocate and connect our interrupt.
	 */
	if (ddi_intr_hilevel(dev, 0) != 0) {
		AMRDB_PRINT((CE_NOTE,
		    "High level interrupt is not supported!"));
		goto error_out;
	}

	if (ddi_get_iblock_cookie(dev, 0,  &softs->iblock_cookiep)
	    != DDI_SUCCESS) {
		goto error_out;
	}

	mutex_init(&softs->cmd_mutex, NULL, MUTEX_DRIVER,
	    softs->iblock_cookiep); /* should be used in interrupt */
	mutex_init(&softs->queue_mutex, NULL, MUTEX_DRIVER,
	    softs->iblock_cookiep); /* should be used in interrupt */
	mutex_init(&softs->periodic_mutex, NULL, MUTEX_DRIVER,
	    softs->iblock_cookiep); /* should be used in interrupt */
	/* sychronize waits for the busy slots via this cv */
	cv_init(&softs->cmd_cv, NULL, CV_DRIVER, NULL);
	softs->state |= AMR_STATE_KMUTEX_INITED;

	/*
	 * Do bus-independent initialisation, bring controller online.
	 */
	if (amr_setup_mbox(softs) != DDI_SUCCESS)
		goto error_out;
	softs->state |= AMR_STATE_MAILBOX_SETUP;

	if (amr_setup_sg(softs) != DDI_SUCCESS)
		goto error_out;

	softs->state |= AMR_STATE_SG_TABLES_SETUP;

	if (amr_query_controller(softs) != DDI_SUCCESS)
		goto error_out;

	/*
	 * A taskq is created for dispatching the waiting queue processing
	 * thread. The threads number equals to the logic drive number and
	 * the thread number should be 1 if there is no logic driver is
	 * configured for this instance.
	 */
	if ((softs->amr_taskq = ddi_taskq_create(dev, "amr_taskq",
	    MAX(softs->amr_nlogdrives, 1), TASKQ_DEFAULTPRI, 0)) == NULL) {
		goto error_out;
	}
	softs->state |= AMR_STATE_TASKQ_SETUP;

	if (ddi_add_intr(dev, 0, &softs->iblock_cookiep, NULL,
	    amr_intr, (caddr_t)softs) != DDI_SUCCESS) {
		goto error_out;
	}
	softs->state |= AMR_STATE_INTR_SETUP;

	/* set up the tran interface */
	if (amr_setup_tran(softs->dev_info_p, softs) != DDI_SUCCESS) {
		AMRDB_PRINT((CE_NOTE, "setup tran failed"));
		goto error_out;
	}
	softs->state |= AMR_STATE_TRAN_SETUP;

	/* schedule a thread for periodic check */
	mutex_enter(&softs->periodic_mutex);
	softs->timeout_t = timeout(amr_periodic, (void *)softs,
	    drv_usectohz(500000*AMR_PERIODIC_TIMEOUT));
	softs->state |= AMR_STATE_TIMEOUT_ENABLED;
	mutex_exit(&softs->periodic_mutex);

	/* print firmware information in verbose mode */
	cmn_err(CE_CONT, "?MegaRaid %s %s attached.",
	    softs->amr_product_info.pi_product_name,
	    softs->amr_product_info.pi_firmware_ver);

	/* clear any interrupts */
	AMR_QCLEAR_INTR(softs);
	return (DDI_SUCCESS);

error_out:
	if (softs->state & AMR_STATE_INTR_SETUP) {
		ddi_remove_intr(dev, 0, softs->iblock_cookiep);
	}
	if (softs->state & AMR_STATE_TASKQ_SETUP) {
		ddi_taskq_destroy(softs->amr_taskq);
	}
	if (softs->state & AMR_STATE_SG_TABLES_SETUP) {
		for (i = 0; i < softs->sg_max_count; i++) {
			(void) ddi_dma_unbind_handle(
			    softs->sg_items[i].sg_handle);
			(void) ddi_dma_mem_free(
			    &((softs->sg_items[i]).sg_acc_handle));
			(void) ddi_dma_free_handle(
			    &(softs->sg_items[i].sg_handle));
		}
	}
	if (softs->state & AMR_STATE_MAILBOX_SETUP) {
		(void) ddi_dma_unbind_handle(softs->mbox_dma_handle);
		(void) ddi_dma_mem_free(&softs->mbox_acc_handle);
		(void) ddi_dma_free_handle(&softs->mbox_dma_handle);
	}
	if (softs->state & AMR_STATE_KMUTEX_INITED) {
		mutex_destroy(&softs->queue_mutex);
		mutex_destroy(&softs->cmd_mutex);
		mutex_destroy(&softs->periodic_mutex);
		cv_destroy(&softs->cmd_cv);
	}
	if (softs->state & AMR_STATE_PCI_MEM_MAPPED)
		ddi_regs_map_free(&softs->regsmap_handle);
	if (softs->state & AMR_STATE_PCI_CONFIG_SETUP)
		pci_config_teardown(&softs->pciconfig_handle);
	if (softs->state & AMR_STATE_SOFT_STATE_SETUP)
		ddi_soft_state_free(amr_softstatep, instance);
	return (DDI_FAILURE);
}

/*
 * Bring the controller down to a dormant state and detach all child devices.
 * This function is called during detach, system shutdown.
 *
 * Note that we can assume that the bufq on the controller is empty, as we won't
 * allow shutdown if any device is open.
 */
/*ARGSUSED*/
static int amr_detach(dev_info_t *dev, ddi_detach_cmd_t cmd)
{
	struct amr_softs	*softs;
	int			instance;
	uint32_t		i, done_flag;

	instance = ddi_get_instance(dev);
	softs = ddi_get_soft_state(amr_softstatep, instance);

	/* flush the controllor */
	if (amr_flush(softs) != 0) {
		AMRDB_PRINT((CE_NOTE, "device shutdown failed"));
		return (EIO);
	}

	/* release the amr timer */
	mutex_enter(&softs->periodic_mutex);
	softs->state &= ~AMR_STATE_TIMEOUT_ENABLED;
	if (softs->timeout_t) {
		(void) untimeout(softs->timeout_t);
		softs->timeout_t = 0;
	}
	mutex_exit(&softs->periodic_mutex);

	for (i = 0; i < softs->sg_max_count; i++) {
		(void) ddi_dma_unbind_handle(
		    softs->sg_items[i].sg_handle);
		(void) ddi_dma_mem_free(
		    &((softs->sg_items[i]).sg_acc_handle));
		(void) ddi_dma_free_handle(
		    &(softs->sg_items[i].sg_handle));
	}

	(void) ddi_dma_unbind_handle(softs->mbox_dma_handle);
	(void) ddi_dma_mem_free(&softs->mbox_acc_handle);
	(void) ddi_dma_free_handle(&softs->mbox_dma_handle);

	/* disconnect the interrupt handler */
	ddi_remove_intr(softs->dev_info_p,  0, softs->iblock_cookiep);

	/* wait for the completion of current in-progress interruptes */
	AMR_DELAY((softs->amr_interrupts_counter == 0), 1000, done_flag);
	if (!done_flag) {
		cmn_err(CE_WARN, "Suspicious interrupts in-progress.");
	}

	ddi_taskq_destroy(softs->amr_taskq);

	(void) scsi_hba_detach(dev);
	scsi_hba_tran_free(softs->hba_tran);
	ddi_regs_map_free(&softs->regsmap_handle);
	pci_config_teardown(&softs->pciconfig_handle);

	mutex_destroy(&softs->queue_mutex);
	mutex_destroy(&softs->cmd_mutex);
	mutex_destroy(&softs->periodic_mutex);
	cv_destroy(&softs->cmd_cv);

	/* print firmware information in verbose mode */
	cmn_err(CE_NOTE, "?MegaRaid %s %s detached.",
	    softs->amr_product_info.pi_product_name,
	    softs->amr_product_info.pi_firmware_ver);

	ddi_soft_state_free(amr_softstatep, instance);

	return (DDI_SUCCESS);
}


/*ARGSUSED*/
static int amr_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
	void *arg, void **result)
{
	struct amr_softs	*softs;
	int			instance;

	instance = ddi_get_instance(dip);

	switch (infocmd) {
		case DDI_INFO_DEVT2DEVINFO:
			softs = ddi_get_soft_state(amr_softstatep, instance);
			if (softs != NULL) {
				*result = softs->dev_info_p;
				return (DDI_SUCCESS);
			} else {
				*result = NULL;
				return (DDI_FAILURE);
			}
		case DDI_INFO_DEVT2INSTANCE:
			*(int *)result = instance;
			break;
		default:
			break;
	}
	return (DDI_SUCCESS);
}

/*
 * Take an interrupt, or be poked by other code to look for interrupt-worthy
 * status.
 */
static uint_t
amr_intr(caddr_t arg)
{
	struct amr_softs *softs = (struct amr_softs *)arg;

	softs->amr_interrupts_counter++;

	if (AMR_QGET_ODB(softs) != AMR_QODB_READY) {
		softs->amr_interrupts_counter--;
		return (DDI_INTR_UNCLAIMED);
	}

	/* collect finished commands, queue anything waiting */
	amr_done(softs);

	softs->amr_interrupts_counter--;

	return (DDI_INTR_CLAIMED);

}

/*
 * Setup the amr mailbox
 */
static int
amr_setup_mbox(struct amr_softs *softs)
{
	uint32_t	move;
	size_t		mbox_len;

	if (ddi_dma_alloc_handle(
	    softs->dev_info_p,
	    &addr_dma_attr,
	    DDI_DMA_SLEEP,
	    NULL,
	    &softs->mbox_dma_handle) != DDI_SUCCESS) {
		AMRDB_PRINT((CE_NOTE, "Cannot alloc dma handle for mailbox"));
		goto error_out;
	}

	if (ddi_dma_mem_alloc(
	    softs->mbox_dma_handle,
	    sizeof (struct amr_mailbox) + 16,
	    &accattr,
	    DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
	    DDI_DMA_SLEEP,
	    NULL,
	    (caddr_t *)(&softs->mbox),
	    &mbox_len,
	    &softs->mbox_acc_handle) !=
	    DDI_SUCCESS) {

		AMRDB_PRINT((CE_WARN, "Cannot alloc dma memory for mailbox"));
		goto error_out;
	}

	if (ddi_dma_addr_bind_handle(
	    softs->mbox_dma_handle,
	    NULL,
	    (caddr_t)softs->mbox,
	    mbox_len,
	    DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
	    DDI_DMA_SLEEP,
	    NULL,
	    &softs->mbox_dma_cookie,
	    &softs->mbox_dma_cookien) != DDI_DMA_MAPPED) {

		AMRDB_PRINT((CE_NOTE, "Cannot bind dma memory for mailbox"));
		goto error_out;
	}

	if (softs->mbox_dma_cookien != 1)
		goto error_out;

	/* The phy address of mailbox must be aligned on a 16-byte boundary */
	move = 16 - (((uint32_t)softs->mbox_dma_cookie.dmac_address)&0xf);
	softs->mbox_phyaddr =
	    (softs->mbox_dma_cookie.dmac_address + move);

	softs->mailbox =
	    (struct amr_mailbox *)(((uintptr_t)softs->mbox) + move);

	AMRDB_PRINT((CE_NOTE, "phraddy=%x, mailbox=%p, softs->mbox=%p, move=%x",
	    softs->mbox_phyaddr, (void *)softs->mailbox,
	    softs->mbox, move));

	return (DDI_SUCCESS);

error_out:
	if (softs->mbox_dma_cookien)
		(void) ddi_dma_unbind_handle(softs->mbox_dma_handle);
	if (softs->mbox_acc_handle) {
		(void) ddi_dma_mem_free(&(softs->mbox_acc_handle));
		softs->mbox_acc_handle = NULL;
	}
	if (softs->mbox_dma_handle) {
		(void) ddi_dma_free_handle(&softs->mbox_dma_handle);
		softs->mbox_dma_handle = NULL;
	}

	return (DDI_FAILURE);
}

/*
 * Perform a periodic check of the controller status
 */
static void
amr_periodic(void *data)
{
	uint32_t		i;
	struct amr_softs	*softs = (struct amr_softs *)data;
	struct scsi_pkt 	*pkt;
	register struct amr_command	*ac;

	for (i = 0; i < softs->sg_max_count; i++) {
		if (softs->busycmd[i] == NULL)
			continue;

		mutex_enter(&softs->cmd_mutex);

		if (softs->busycmd[i] == NULL) {
			mutex_exit(&softs->cmd_mutex);
			continue;
		}

		pkt = softs->busycmd[i]->pkt;

		if ((pkt->pkt_time != 0) &&
		    (ddi_get_time() -
		    softs->busycmd[i]->ac_timestamp >
		    pkt->pkt_time)) {

			cmn_err(CE_WARN,
			    "!timed out packet detected,\
				sc = %p, pkt = %p, index = %d, ac = %p",
			    (void *)softs,
			    (void *)pkt,
			    i,
			    (void *)softs->busycmd[i]);

			ac = softs->busycmd[i];
			ac->ac_next = NULL;

			/* pull command from the busy index */
			softs->busycmd[i] = NULL;
			if (softs->amr_busyslots > 0)
				softs->amr_busyslots--;
			if (softs->amr_busyslots == 0)
				cv_broadcast(&softs->cmd_cv);

			mutex_exit(&softs->cmd_mutex);

			pkt = ac->pkt;
			*pkt->pkt_scbp = 0;
			pkt->pkt_statistics |= STAT_TIMEOUT;
			pkt->pkt_reason = CMD_TIMEOUT;
			if (!(pkt->pkt_flags & FLAG_NOINTR)) {
				/* call pkt callback */
				scsi_hba_pkt_comp(pkt);
			}

		} else {
			mutex_exit(&softs->cmd_mutex);
		}
	}

	/* restart the amr timer */
	mutex_enter(&softs->periodic_mutex);
	if (softs->state & AMR_STATE_TIMEOUT_ENABLED)
		softs->timeout_t = timeout(amr_periodic, (void *)softs,
		    drv_usectohz(500000*AMR_PERIODIC_TIMEOUT));
	mutex_exit(&softs->periodic_mutex);
}

/*
 * Interrogate the controller for the operational parameters we require.
 */
static int
amr_query_controller(struct amr_softs *softs)
{
	struct amr_enquiry3	*aex;
	struct amr_prodinfo	*ap;
	struct amr_enquiry	*ae;
	uint32_t		ldrv;
	int			instance;

	/*
	 * If we haven't found the real limit yet, let us have a couple of
	 * commands in order to be able to probe.
	 */
	if (softs->maxio == 0)
		softs->maxio = 2;

	instance = ddi_get_instance(softs->dev_info_p);

	/*
	 * Try to issue an ENQUIRY3 command
	 */
	if ((aex = amr_enquiry(softs, AMR_ENQ_BUFFER_SIZE, AMR_CMD_CONFIG,
	    AMR_CONFIG_ENQ3, AMR_CONFIG_ENQ3_SOLICITED_FULL)) != NULL) {

		AMRDB_PRINT((CE_NOTE, "First enquiry"));

		for (ldrv = 0; ldrv < aex->ae_numldrives; ldrv++) {
			softs->logic_drive[ldrv].al_size =
			    aex->ae_drivesize[ldrv];
			softs->logic_drive[ldrv].al_state =
			    aex->ae_drivestate[ldrv];
			softs->logic_drive[ldrv].al_properties =
			    aex->ae_driveprop[ldrv];
			AMRDB_PRINT((CE_NOTE,
			    "  drive %d: size: %d state %x properties %x\n",
			    ldrv,
			    softs->logic_drive[ldrv].al_size,
			    softs->logic_drive[ldrv].al_state,
			    softs->logic_drive[ldrv].al_properties));

			if (softs->logic_drive[ldrv].al_state ==
			    AMR_LDRV_OFFLINE)
				cmn_err(CE_NOTE,
				    "!instance %d log-drive %d is offline",
				    instance, ldrv);
			else
				softs->amr_nlogdrives++;
		}
		kmem_free(aex, AMR_ENQ_BUFFER_SIZE);

		if ((ap = amr_enquiry(softs, AMR_ENQ_BUFFER_SIZE,
		    AMR_CMD_CONFIG, AMR_CONFIG_PRODUCT_INFO, 0)) == NULL) {
			AMRDB_PRINT((CE_NOTE,
			    "Cannot obtain product data from controller"));
			return (EIO);
		}

		softs->maxdrives = AMR_40LD_MAXDRIVES;
		softs->maxchan = ap->ap_nschan;
		softs->maxio = ap->ap_maxio;

		bcopy(ap->ap_firmware, softs->amr_product_info.pi_firmware_ver,
		    AMR_FIRMWARE_VER_SIZE);
		softs->amr_product_info.
		    pi_firmware_ver[AMR_FIRMWARE_VER_SIZE] = 0;

		bcopy(ap->ap_product, softs->amr_product_info.pi_product_name,
		    AMR_PRODUCT_INFO_SIZE);
		softs->amr_product_info.
		    pi_product_name[AMR_PRODUCT_INFO_SIZE] = 0;

		kmem_free(ap, AMR_ENQ_BUFFER_SIZE);
		AMRDB_PRINT((CE_NOTE, "maxio=%d", softs->maxio));
	} else {

		AMRDB_PRINT((CE_NOTE, "First enquiry failed, \
				so try another way"));

		/* failed, try the 8LD ENQUIRY commands */
		if ((ae = (struct amr_enquiry *)amr_enquiry(softs,
		    AMR_ENQ_BUFFER_SIZE, AMR_CMD_EXT_ENQUIRY2, 0, 0))
		    == NULL) {

			if ((ae = (struct amr_enquiry *)amr_enquiry(softs,
			    AMR_ENQ_BUFFER_SIZE, AMR_CMD_ENQUIRY, 0, 0))
			    == NULL) {
				AMRDB_PRINT((CE_NOTE,
				    "Cannot obtain configuration data"));
				return (EIO);
			}
			ae->ae_signature = 0;
		}

		/*
		 * Fetch current state of logical drives.
		 */
		for (ldrv = 0; ldrv < ae->ae_ldrv.al_numdrives; ldrv++) {
			softs->logic_drive[ldrv].al_size =
			    ae->ae_ldrv.al_size[ldrv];
			softs->logic_drive[ldrv].al_state =
			    ae->ae_ldrv.al_state[ldrv];
			softs->logic_drive[ldrv].al_properties =
			    ae->ae_ldrv.al_properties[ldrv];
			AMRDB_PRINT((CE_NOTE,
			    " ********* drive %d: %d state %x properties %x",
			    ldrv,
			    softs->logic_drive[ldrv].al_size,
			    softs->logic_drive[ldrv].al_state,
			    softs->logic_drive[ldrv].al_properties));

			if (softs->logic_drive[ldrv].al_state ==
			    AMR_LDRV_OFFLINE)
				cmn_err(CE_NOTE,
				    "!instance %d log-drive %d is offline",
				    instance, ldrv);
			else
				softs->amr_nlogdrives++;
		}

		softs->maxdrives = AMR_8LD_MAXDRIVES;
		softs->maxchan = ae->ae_adapter.aa_channels;
		softs->maxio = ae->ae_adapter.aa_maxio;
		kmem_free(ae, AMR_ENQ_BUFFER_SIZE);
	}

	/*
	 * Mark remaining drives as unused.
	 */
	for (; ldrv < AMR_MAXLD; ldrv++)
		softs->logic_drive[ldrv].al_state = AMR_LDRV_OFFLINE;

	/*
	 * Cap the maximum number of outstanding I/Os.  AMI's driver
	 * doesn't trust the controller's reported value, and lockups have
	 * been seen when we do.
	 */
	softs->maxio = MIN(softs->maxio, AMR_LIMITCMD);

	return (DDI_SUCCESS);
}

/*
 * Run a generic enquiry-style command.
 */
static void *
amr_enquiry(struct amr_softs *softs, size_t bufsize, uint8_t cmd,
				uint8_t cmdsub, uint8_t cmdqual)
{
	struct amr_command	ac;
	void			*result;

	result = NULL;

	bzero(&ac, sizeof (struct amr_command));
	ac.ac_softs = softs;

	/* set command flags */
	ac.ac_flags |= AMR_CMD_DATAOUT;

	/* build the command proper */
	ac.mailbox.mb_command	= cmd;
	ac.mailbox.mb_cmdsub	= cmdsub;
	ac.mailbox.mb_cmdqual	= cmdqual;

	if (amr_enquiry_mapcmd(&ac, bufsize) != DDI_SUCCESS)
		return (NULL);

	if (amr_poll_command(&ac) || ac.ac_status != 0) {
		AMRDB_PRINT((CE_NOTE, "can not poll command, goto out"));
		amr_enquiry_unmapcmd(&ac);
		return (NULL);
	}

	/* allocate the response structure */
	result = kmem_zalloc(bufsize, KM_SLEEP);

	bcopy(ac.ac_data, result, bufsize);

	amr_enquiry_unmapcmd(&ac);
	return (result);
}

/*
 * Flush the controller's internal cache, return status.
 */
static int
amr_flush(struct amr_softs *softs)
{
	struct amr_command	ac;
	int			error = 0;

	bzero(&ac, sizeof (struct amr_command));
	ac.ac_softs = softs;

	ac.ac_flags |= AMR_CMD_DATAOUT;

	/* build the command proper */
	ac.mailbox.mb_command = AMR_CMD_FLUSH;

	/* have to poll, as the system may be going down or otherwise damaged */
	if (error = amr_poll_command(&ac)) {
		AMRDB_PRINT((CE_NOTE, "can not poll this cmd"));
		return (error);
	}

	return (error);
}

/*
 * Take a command, submit it to the controller and wait for it to return.
 * Returns nonzero on error.  Can be safely called with interrupts enabled.
 */
static int
amr_poll_command(struct amr_command *ac)
{
	struct amr_softs	*softs = ac->ac_softs;
	volatile uint32_t	done_flag;

	AMRDB_PRINT((CE_NOTE, "Amr_Poll bcopy(%p, %p, %d)",
	    (void *)&ac->mailbox,
	    (void *)softs->mailbox,
	    (uint32_t)AMR_MBOX_CMDSIZE));

	mutex_enter(&softs->cmd_mutex);

	while (softs->amr_busyslots != 0)
		cv_wait(&softs->cmd_cv, &softs->cmd_mutex);

	/*
	 * For read/write commands, the scatter/gather table should be
	 * filled, and the last entry in scatter/gather table will be used.
	 */
	if ((ac->mailbox.mb_command == AMR_CMD_LREAD) ||
	    (ac->mailbox.mb_command == AMR_CMD_LWRITE)) {
		bcopy(ac->sgtable,
		    softs->sg_items[softs->sg_max_count - 1].sg_table,
		    sizeof (struct amr_sgentry) * AMR_NSEG);

		(void) ddi_dma_sync(
		    softs->sg_items[softs->sg_max_count - 1].sg_handle,
		    0, 0, DDI_DMA_SYNC_FORDEV);

		ac->mailbox.mb_physaddr =
		    softs->sg_items[softs->sg_max_count - 1].sg_phyaddr;
	}

	bcopy(&ac->mailbox, (void *)softs->mailbox, AMR_MBOX_CMDSIZE);

	/* sync the dma memory */
	(void) ddi_dma_sync(softs->mbox_dma_handle, 0, 0, DDI_DMA_SYNC_FORDEV);

	/* clear the poll/ack fields in the mailbox */
	softs->mailbox->mb_ident = AMR_POLL_COMMAND_ID;
	softs->mailbox->mb_nstatus = AMR_POLL_DEFAULT_NSTATUS;
	softs->mailbox->mb_status = AMR_POLL_DEFAULT_STATUS;
	softs->mailbox->mb_poll = 0;
	softs->mailbox->mb_ack = 0;
	softs->mailbox->mb_busy = 1;

	AMR_QPUT_IDB(softs, softs->mbox_phyaddr | AMR_QIDB_SUBMIT);

	/* sync the dma memory */
	(void) ddi_dma_sync(softs->mbox_dma_handle, 0, 0, DDI_DMA_SYNC_FORCPU);

	AMR_DELAY((softs->mailbox->mb_nstatus != AMR_POLL_DEFAULT_NSTATUS),
	    1000, done_flag);
	if (!done_flag) {
		mutex_exit(&softs->cmd_mutex);
		return (1);
	}

	ac->ac_status = softs->mailbox->mb_status;

	AMR_DELAY((softs->mailbox->mb_poll == AMR_POLL_ACK), 1000, done_flag);
	if (!done_flag) {
		mutex_exit(&softs->cmd_mutex);
		return (1);
	}

	softs->mailbox->mb_poll = 0;
	softs->mailbox->mb_ack = AMR_POLL_ACK;

	/* acknowledge that we have the commands */
	AMR_QPUT_IDB(softs, softs->mbox_phyaddr | AMR_QIDB_ACK);

	AMR_DELAY(!(AMR_QGET_IDB(softs) & AMR_QIDB_ACK), 1000, done_flag);
	if (!done_flag) {
		mutex_exit(&softs->cmd_mutex);
		return (1);
	}

	mutex_exit(&softs->cmd_mutex);
	return (ac->ac_status != AMR_STATUS_SUCCESS);
}

/*
 * setup the scatter/gather table
 */
static int
amr_setup_sg(struct amr_softs *softs)
{
	uint32_t		i;
	size_t			len;
	ddi_dma_cookie_t	cookie;
	uint_t			cookien;

	softs->sg_max_count = 0;

	for (i = 0; i < AMR_MAXCMD; i++) {

		/* reset the cookien */
		cookien = 0;

		(softs->sg_items[i]).sg_handle = NULL;
		if (ddi_dma_alloc_handle(
		    softs->dev_info_p,
		    &addr_dma_attr,
		    DDI_DMA_SLEEP,
		    NULL,
		    &((softs->sg_items[i]).sg_handle)) != DDI_SUCCESS) {

			AMRDB_PRINT((CE_WARN,
			"Cannot alloc dma handle for s/g table"));
			goto error_out;
		}

		if (ddi_dma_mem_alloc((softs->sg_items[i]).sg_handle,
		    sizeof (struct amr_sgentry) * AMR_NSEG,
		    &accattr,
		    DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
		    DDI_DMA_SLEEP, NULL,
		    (caddr_t *)(&(softs->sg_items[i]).sg_table),
		    &len,
		    &(softs->sg_items[i]).sg_acc_handle)
		    != DDI_SUCCESS) {

			AMRDB_PRINT((CE_WARN,
			"Cannot allocate DMA memory"));
			goto error_out;
		}

		if (ddi_dma_addr_bind_handle(
		    (softs->sg_items[i]).sg_handle,
		    NULL,
		    (caddr_t)((softs->sg_items[i]).sg_table),
		    len,
		    DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
		    DDI_DMA_SLEEP,
		    NULL,
		    &cookie,
		    &cookien) != DDI_DMA_MAPPED) {

			AMRDB_PRINT((CE_WARN,
			"Cannot bind communication area for s/g table"));
			goto error_out;
		}

		if (cookien != 1)
			goto error_out;

		softs->sg_items[i].sg_phyaddr = cookie.dmac_address;
		softs->sg_max_count++;
	}

	return (DDI_SUCCESS);

error_out:
	/*
	 * Couldn't allocate/initialize all of the sg table entries.
	 * Clean up the partially-initialized entry before returning.
	 */
	if (cookien) {
		(void) ddi_dma_unbind_handle((softs->sg_items[i]).sg_handle);
	}
	if ((softs->sg_items[i]).sg_acc_handle) {
		(void) ddi_dma_mem_free(&((softs->sg_items[i]).sg_acc_handle));
		(softs->sg_items[i]).sg_acc_handle = NULL;
	}
	if ((softs->sg_items[i]).sg_handle) {
		(void) ddi_dma_free_handle(&((softs->sg_items[i]).sg_handle));
		(softs->sg_items[i]).sg_handle = NULL;
	}

	/*
	 * At least two sg table entries are needed. One is for regular data
	 * I/O commands, the other is for poll I/O commands.
	 */
	return (softs->sg_max_count > 1 ? DDI_SUCCESS : DDI_FAILURE);
}

/*
 * Map/unmap (ac)'s data in the controller's addressable space as required.
 *
 * These functions may be safely called multiple times on a given command.
 */
static void
amr_setup_dmamap(struct amr_command *ac, ddi_dma_cookie_t *buffer_dma_cookiep,
		int nsegments)
{
	struct amr_sgentry	*sg;
	uint32_t		i, size;

	sg = ac->sgtable;

	size = 0;

	ac->mailbox.mb_nsgelem = (uint8_t)nsegments;
	for (i = 0; i < nsegments; i++, sg++) {
		sg->sg_addr = buffer_dma_cookiep->dmac_address;
		sg->sg_count = buffer_dma_cookiep->dmac_size;
		size += sg->sg_count;

		/*
		 * There is no next cookie if the end of the current
		 * window is reached. Otherwise, the next cookie
		 * would be found.
		 */
		if ((ac->current_cookie + i + 1) != ac->num_of_cookie)
			ddi_dma_nextcookie(ac->buffer_dma_handle,
			    buffer_dma_cookiep);
	}

	ac->transfer_size = size;
	ac->data_transfered += size;
}


/*
 * map the amr command for enquiry, allocate the DMA resource
 */
static int
amr_enquiry_mapcmd(struct amr_command *ac, uint32_t data_size)
{
	struct amr_softs	*softs = ac->ac_softs;
	size_t			len;
	uint_t			dma_flags;

	AMRDB_PRINT((CE_NOTE, "Amr_enquiry_mapcmd called, ac=%p, flags=%x",
	    (void *)ac, ac->ac_flags));

	if (ac->ac_flags & AMR_CMD_DATAOUT) {
		dma_flags = DDI_DMA_READ;
	} else {
		dma_flags = DDI_DMA_WRITE;
	}

	dma_flags |= DDI_DMA_CONSISTENT;

	/* process the DMA by address bind mode */
	if (ddi_dma_alloc_handle(softs->dev_info_p,
	    &addr_dma_attr, DDI_DMA_SLEEP, NULL,
	    &ac->buffer_dma_handle) !=
	    DDI_SUCCESS) {

		AMRDB_PRINT((CE_WARN,
		"Cannot allocate addr DMA tag"));
		goto error_out;
	}

	if (ddi_dma_mem_alloc(ac->buffer_dma_handle,
	    data_size,
	    &accattr,
	    dma_flags,
	    DDI_DMA_SLEEP,
	    NULL,
	    (caddr_t *)&ac->ac_data,
	    &len,
	    &ac->buffer_acc_handle) !=
	    DDI_SUCCESS) {

		AMRDB_PRINT((CE_WARN,
		"Cannot allocate DMA memory"));
		goto error_out;
	}

	if ((ddi_dma_addr_bind_handle(
	    ac->buffer_dma_handle,
	    NULL, ac->ac_data, len, dma_flags,
	    DDI_DMA_SLEEP, NULL, &ac->buffer_dma_cookie,
	    &ac->num_of_cookie)) != DDI_DMA_MAPPED) {

		AMRDB_PRINT((CE_WARN,
		    "Cannot bind addr for dma"));
		goto error_out;
	}

	ac->ac_dataphys = (&ac->buffer_dma_cookie)->dmac_address;

	((struct amr_mailbox *)&(ac->mailbox))->mb_param = 0;
	ac->mailbox.mb_nsgelem = 0;
	ac->mailbox.mb_physaddr = ac->ac_dataphys;

	ac->ac_flags |= AMR_CMD_MAPPED;

	return (DDI_SUCCESS);

error_out:
	if (ac->num_of_cookie)
		(void) ddi_dma_unbind_handle(ac->buffer_dma_handle);
	if (ac->buffer_acc_handle) {
		ddi_dma_mem_free(&ac->buffer_acc_handle);
		ac->buffer_acc_handle = NULL;
	}
	if (ac->buffer_dma_handle) {
		(void) ddi_dma_free_handle(&ac->buffer_dma_handle);
		ac->buffer_dma_handle = NULL;
	}

	return (DDI_FAILURE);
}

/*
 * unmap the amr command for enquiry, free the DMA resource
 */
static void
amr_enquiry_unmapcmd(struct amr_command *ac)
{
	AMRDB_PRINT((CE_NOTE, "Amr_enquiry_unmapcmd called, ac=%p",
	    (void *)ac));

	/* if the command involved data at all and was mapped */
	if ((ac->ac_flags & AMR_CMD_MAPPED) && ac->ac_data) {
		if (ac->buffer_dma_handle)
			(void) ddi_dma_unbind_handle(
			    ac->buffer_dma_handle);
		if (ac->buffer_acc_handle) {
			ddi_dma_mem_free(&ac->buffer_acc_handle);
			ac->buffer_acc_handle = NULL;
		}
		if (ac->buffer_dma_handle) {
			(void) ddi_dma_free_handle(
			    &ac->buffer_dma_handle);
			ac->buffer_dma_handle = NULL;
		}
	}

	ac->ac_flags &= ~AMR_CMD_MAPPED;
}

/*
 * map the amr command, allocate the DMA resource
 */
static int
amr_mapcmd(struct amr_command *ac, int (*callback)(), caddr_t arg)
{
	uint_t	dma_flags;
	off_t	off;
	size_t	len;
	int	error;
	int	(*cb)(caddr_t);

	AMRDB_PRINT((CE_NOTE, "Amr_mapcmd called, ac=%p, flags=%x",
	    (void *)ac, ac->ac_flags));

	if (ac->ac_flags & AMR_CMD_DATAOUT) {
		dma_flags = DDI_DMA_READ;
	} else {
		dma_flags = DDI_DMA_WRITE;
	}

	if (ac->ac_flags & AMR_CMD_PKT_CONSISTENT) {
		dma_flags |= DDI_DMA_CONSISTENT;
	}
	if (ac->ac_flags & AMR_CMD_PKT_DMA_PARTIAL) {
		dma_flags |= DDI_DMA_PARTIAL;
	}

	if ((!(ac->ac_flags & AMR_CMD_MAPPED)) && (ac->ac_buf == NULL)) {
		ac->ac_flags |= AMR_CMD_MAPPED;
		return (DDI_SUCCESS);
	}

	cb = (callback == NULL_FUNC) ? DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;

	/* if the command involves data at all, and hasn't been mapped */
	if (!(ac->ac_flags & AMR_CMD_MAPPED)) {
		/* process the DMA by buffer bind mode */
		error = ddi_dma_buf_bind_handle(ac->buffer_dma_handle,
		    ac->ac_buf,
		    dma_flags,
		    cb,
		    arg,
		    &ac->buffer_dma_cookie,
		    &ac->num_of_cookie);
		switch (error) {
		case DDI_DMA_PARTIAL_MAP:
			if (ddi_dma_numwin(ac->buffer_dma_handle,
			    &ac->num_of_win) == DDI_FAILURE) {

				AMRDB_PRINT((CE_WARN,
				    "Cannot get dma num win"));
				(void) ddi_dma_unbind_handle(
				    ac->buffer_dma_handle);
				(void) ddi_dma_free_handle(
				    &ac->buffer_dma_handle);
				ac->buffer_dma_handle = NULL;
				return (DDI_FAILURE);
			}
			ac->current_win = 0;
			break;

		case DDI_DMA_MAPPED:
			ac->num_of_win = 1;
			ac->current_win = 0;
			break;

		default:
			AMRDB_PRINT((CE_WARN,
			    "Cannot bind buf for dma"));

			(void) ddi_dma_free_handle(
			    &ac->buffer_dma_handle);
			ac->buffer_dma_handle = NULL;
			return (DDI_FAILURE);
		}

		ac->current_cookie = 0;

		ac->ac_flags |= AMR_CMD_MAPPED;
	} else if (ac->current_cookie == AMR_LAST_COOKIE_TAG) {
		/* get the next window */
		ac->current_win++;
		(void) ddi_dma_getwin(ac->buffer_dma_handle,
		    ac->current_win, &off, &len,
		    &ac->buffer_dma_cookie,
		    &ac->num_of_cookie);
		ac->current_cookie = 0;
	}

	if ((ac->num_of_cookie - ac->current_cookie) > AMR_NSEG) {
		amr_setup_dmamap(ac, &ac->buffer_dma_cookie, AMR_NSEG);
		ac->current_cookie += AMR_NSEG;
	} else {
		amr_setup_dmamap(ac, &ac->buffer_dma_cookie,
		    ac->num_of_cookie - ac->current_cookie);
		ac->current_cookie = AMR_LAST_COOKIE_TAG;
	}

	return (DDI_SUCCESS);
}

/*
 * unmap the amr command, free the DMA resource
 */
static void
amr_unmapcmd(struct amr_command *ac)
{
	AMRDB_PRINT((CE_NOTE, "Amr_unmapcmd called, ac=%p",
	    (void *)ac));

	/* if the command involved data at all and was mapped */
	if ((ac->ac_flags & AMR_CMD_MAPPED) &&
	    ac->ac_buf && ac->buffer_dma_handle)
		(void) ddi_dma_unbind_handle(ac->buffer_dma_handle);

	ac->ac_flags &= ~AMR_CMD_MAPPED;
}

static int
amr_setup_tran(dev_info_t  *dip, struct amr_softs *softp)
{
	softp->hba_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);

	/*
	 * hba_private always points to the amr_softs struct
	 */
	softp->hba_tran->tran_hba_private	= softp;
	softp->hba_tran->tran_tgt_init		= amr_tran_tgt_init;
	softp->hba_tran->tran_tgt_probe		= scsi_hba_probe;
	softp->hba_tran->tran_start		= amr_tran_start;
	softp->hba_tran->tran_reset		= amr_tran_reset;
	softp->hba_tran->tran_getcap		= amr_tran_getcap;
	softp->hba_tran->tran_setcap		= amr_tran_setcap;
	softp->hba_tran->tran_init_pkt		= amr_tran_init_pkt;
	softp->hba_tran->tran_destroy_pkt	= amr_tran_destroy_pkt;
	softp->hba_tran->tran_dmafree		= amr_tran_dmafree;
	softp->hba_tran->tran_sync_pkt		= amr_tran_sync_pkt;
	softp->hba_tran->tran_abort		= NULL;
	softp->hba_tran->tran_tgt_free		= NULL;
	softp->hba_tran->tran_quiesce		= NULL;
	softp->hba_tran->tran_unquiesce		= NULL;
	softp->hba_tran->tran_sd		= NULL;

	if (scsi_hba_attach_setup(dip, &buffer_dma_attr, softp->hba_tran,
	    SCSI_HBA_TRAN_CLONE) != DDI_SUCCESS) {
		scsi_hba_tran_free(softp->hba_tran);
		softp->hba_tran = NULL;
		return (DDI_FAILURE);
	} else {
		return (DDI_SUCCESS);
	}
}

/*ARGSUSED*/
static int
amr_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
	scsi_hba_tran_t *tran, struct scsi_device *sd)
{
	struct amr_softs	*softs;
	ushort_t		target = sd->sd_address.a_target;
	uchar_t			lun = sd->sd_address.a_lun;

	softs = (struct amr_softs *)
	    (sd->sd_address.a_hba_tran->tran_hba_private);

	if ((lun == 0) && (target < AMR_MAXLD))
		if (softs->logic_drive[target].al_state != AMR_LDRV_OFFLINE)
			return (DDI_SUCCESS);

	return (DDI_FAILURE);
}

static int
amr_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	struct amr_softs	*softs;
	struct buf		*bp = NULL;
	union scsi_cdb		*cdbp = (union scsi_cdb *)pkt->pkt_cdbp;
	int			ret;
	uint32_t		capacity;
	struct amr_command	*ac;

	AMRDB_PRINT((CE_NOTE, "amr_tran_start, cmd=%X,target=%d,lun=%d",
	    cdbp->scc_cmd, ap->a_target, ap->a_lun));

	softs = (struct amr_softs *)(ap->a_hba_tran->tran_hba_private);
	if ((ap->a_lun != 0) || (ap->a_target >= AMR_MAXLD) ||
	    (softs->logic_drive[ap->a_target].al_state ==
	    AMR_LDRV_OFFLINE)) {
		cmn_err(CE_WARN, "target or lun is not correct!");
		ret = TRAN_BADPKT;
		return (ret);
	}

	ac = (struct amr_command *)pkt->pkt_ha_private;
	bp = ac->ac_buf;

	AMRDB_PRINT((CE_NOTE, "scsi cmd accepted, cmd=%X", cdbp->scc_cmd));

	switch (cdbp->scc_cmd) {
	case SCMD_READ:		/* read		*/
	case SCMD_READ_G1:	/* read	g1	*/
	case SCMD_READ_BUFFER:	/* read buffer	*/
	case SCMD_WRITE:	/* write	*/
	case SCMD_WRITE_G1:	/* write g1	*/
	case SCMD_WRITE_BUFFER:	/* write buffer	*/
		amr_rw_command(softs, pkt, ap->a_target);

		if (pkt->pkt_flags & FLAG_NOINTR) {
			(void) amr_poll_command(ac);
			pkt->pkt_state |= (STATE_GOT_BUS
			    | STATE_GOT_TARGET
			    | STATE_SENT_CMD
			    | STATE_XFERRED_DATA);
			*pkt->pkt_scbp = 0;
			pkt->pkt_statistics |= STAT_SYNC;
			pkt->pkt_reason = CMD_CMPLT;
		} else {
			mutex_enter(&softs->queue_mutex);
			if (softs->waiting_q_head == NULL) {
				ac->ac_prev = NULL;
				ac->ac_next = NULL;
				softs->waiting_q_head = ac;
				softs->waiting_q_tail = ac;
			} else {
				ac->ac_next = NULL;
				ac->ac_prev = softs->waiting_q_tail;
				softs->waiting_q_tail->ac_next = ac;
				softs->waiting_q_tail = ac;
			}
			mutex_exit(&softs->queue_mutex);
			amr_start_waiting_queue((void *)softs);
		}
		ret = TRAN_ACCEPT;
		break;

	case SCMD_INQUIRY: /* inquiry */
		if (bp && bp->b_un.b_addr && bp->b_bcount) {
			struct scsi_inquiry inqp;
			uint8_t *sinq_p = (uint8_t *)&inqp;

			bzero(&inqp, sizeof (struct scsi_inquiry));

			if (((char *)cdbp)[1] || ((char *)cdbp)[2]) {
				/*
				 * The EVDP and pagecode is
				 * not supported
				 */
				sinq_p[1] = 0xFF;
				sinq_p[2] = 0x0;
			} else {
				inqp.inq_len = AMR_INQ_ADDITIONAL_LEN;
				inqp.inq_ansi = AMR_INQ_ANSI_VER;
				inqp.inq_rdf = AMR_INQ_RESP_DATA_FORMAT;
				/* Enable Tag Queue */
				inqp.inq_cmdque = 1;
				bcopy("MegaRaid", inqp.inq_vid,
				    sizeof (inqp.inq_vid));
				bcopy(softs->amr_product_info.pi_product_name,
				    inqp.inq_pid,
				    AMR_PRODUCT_INFO_SIZE);
				bcopy(softs->amr_product_info.pi_firmware_ver,
				    inqp.inq_revision,
				    AMR_FIRMWARE_VER_SIZE);
			}

			amr_unmapcmd(ac);

			if (bp->b_flags & (B_PHYS | B_PAGEIO))
				bp_mapin(bp);
			bcopy(&inqp, bp->b_un.b_addr,
			    sizeof (struct scsi_inquiry));

			pkt->pkt_state |= STATE_XFERRED_DATA;
		}
		pkt->pkt_reason = CMD_CMPLT;
		pkt->pkt_state |= (STATE_GOT_BUS
		    | STATE_GOT_TARGET
		    | STATE_SENT_CMD);
		*pkt->pkt_scbp = 0;
		ret = TRAN_ACCEPT;
		if (!(pkt->pkt_flags & FLAG_NOINTR))
			scsi_hba_pkt_comp(pkt);
		break;

	case SCMD_READ_CAPACITY: /* read capacity */
		if (bp && bp->b_un.b_addr && bp->b_bcount) {
			struct scsi_capacity cp;

			capacity = softs->logic_drive[ap->a_target].al_size - 1;
			cp.capacity = BE_32(capacity);
			cp.lbasize = BE_32(512);

			amr_unmapcmd(ac);

			if (bp->b_flags & (B_PHYS | B_PAGEIO))
				bp_mapin(bp);
			bcopy(&cp, bp->b_un.b_addr, 8);
		}
		pkt->pkt_reason = CMD_CMPLT;
		pkt->pkt_state |= (STATE_GOT_BUS
		    | STATE_GOT_TARGET
		    | STATE_SENT_CMD
		    | STATE_XFERRED_DATA);
		*pkt->pkt_scbp = 0;
		ret = TRAN_ACCEPT;
		if (!(pkt->pkt_flags & FLAG_NOINTR))
			scsi_hba_pkt_comp(pkt);
		break;

	case SCMD_MODE_SENSE:		/* mode sense */
	case SCMD_MODE_SENSE_G1:	/* mode sense g1 */
		amr_unmapcmd(ac);

		capacity = softs->logic_drive[ap->a_target].al_size - 1;
		amr_mode_sense(cdbp, bp, capacity);

		pkt->pkt_reason = CMD_CMPLT;
		pkt->pkt_state |= (STATE_GOT_BUS
		    | STATE_GOT_TARGET
		    | STATE_SENT_CMD
		    | STATE_XFERRED_DATA);
		*pkt->pkt_scbp = 0;
		ret = TRAN_ACCEPT;
		if (!(pkt->pkt_flags & FLAG_NOINTR))
			scsi_hba_pkt_comp(pkt);
		break;

	case SCMD_TEST_UNIT_READY:	/* test unit ready */
	case SCMD_REQUEST_SENSE:	/* request sense */
	case SCMD_FORMAT:		/* format */
	case SCMD_START_STOP:		/* start stop */
	case SCMD_SYNCHRONIZE_CACHE:	/* synchronize cache */
		if (bp && bp->b_un.b_addr && bp->b_bcount) {
			amr_unmapcmd(ac);

			if (bp->b_flags & (B_PHYS | B_PAGEIO))
				bp_mapin(bp);
			bzero(bp->b_un.b_addr, bp->b_bcount);

			pkt->pkt_state |= STATE_XFERRED_DATA;
		}
		pkt->pkt_reason = CMD_CMPLT;
		pkt->pkt_state |= (STATE_GOT_BUS
		    | STATE_GOT_TARGET
		    | STATE_SENT_CMD);
		ret = TRAN_ACCEPT;
		*pkt->pkt_scbp = 0;
		if (!(pkt->pkt_flags & FLAG_NOINTR))
			scsi_hba_pkt_comp(pkt);
		break;

	default: /* any other commands */
		amr_unmapcmd(ac);
		pkt->pkt_reason = CMD_INCOMPLETE;
		pkt->pkt_state = (STATE_GOT_BUS
		    | STATE_GOT_TARGET
		    | STATE_SENT_CMD
		    | STATE_GOT_STATUS
		    | STATE_ARQ_DONE);
		ret = TRAN_ACCEPT;
		*pkt->pkt_scbp = 0;
		amr_set_arq_data(pkt, KEY_ILLEGAL_REQUEST);
		if (!(pkt->pkt_flags & FLAG_NOINTR))
			scsi_hba_pkt_comp(pkt);
		break;
	}

	return (ret);
}

/*
 * tran_reset() will reset the bus/target/adapter to support the fault recovery
 * functionality according to the "level" in interface. However, we got the
 * confirmation from LSI that these HBA cards does not support any commands to
 * reset bus/target/adapter/channel.
 *
 * If the tran_reset() return a FAILURE to the sd, the system will not
 * continue to dump the core. But core dump is an crucial method to analyze
 * problems in panic. Now we adopt a work around solution, that is to return
 * a fake SUCCESS to sd during panic, which will force the system continue
 * to dump core though the core may have problems in some situtation because
 * some on-the-fly commands will continue DMAing data to the memory.
 * In addition, the work around core dump method may not be performed
 * successfully if the panic is caused by the HBA itself. So the work around
 * solution is not a good example for the implementation of tran_reset(),
 * the most reasonable approach should send a reset command to the adapter.
 */
/*ARGSUSED*/
static int
amr_tran_reset(struct scsi_address *ap, int level)
{
	struct amr_softs	*softs;
	volatile uint32_t	done_flag;

	if (ddi_in_panic()) {
		softs = (struct amr_softs *)(ap->a_hba_tran->tran_hba_private);

		/* Acknowledge the card if there are any significant commands */
		while (softs->amr_busyslots > 0) {
			AMR_DELAY((softs->mailbox->mb_busy == 0),
			    AMR_RETRYCOUNT, done_flag);
			if (!done_flag) {
				/*
				 * command not completed, indicate the
				 * problem and continue get ac
				 */
				cmn_err(CE_WARN,
				    "AMR command is not completed");
				return (0);
			}

			AMR_QPUT_IDB(softs, softs->mbox_phyaddr | AMR_QIDB_ACK);

			/* wait for the acknowledge from hardware */
			AMR_BUSYWAIT(!(AMR_QGET_IDB(softs) & AMR_QIDB_ACK),
			    AMR_RETRYCOUNT, done_flag);
			if (!done_flag) {
				/*
				 * command is not completed, return from the
				 * current interrupt and wait for the next one
				 */
				cmn_err(CE_WARN, "No answer from the hardware");

				mutex_exit(&softs->cmd_mutex);
				return (0);
			}

			softs->amr_busyslots -= softs->mailbox->mb_nstatus;
		}

		/* flush the controllor */
		(void) amr_flush(softs);

		/*
		 * If the system is in panic, the tran_reset() will return a
		 * fake SUCCESS to sd, then the system would continue dump the
		 * core by poll commands. This is a work around for dumping
		 * core in panic.
		 *
		 * Note: Some on-the-fly command will continue DMAing data to
		 *	 the memory when the core is dumping, which may cause
		 *	 some flaws in the dumped core file, so a cmn_err()
		 *	 will be printed out to warn users. However, for most
		 *	 cases, the core file will be fine.
		 */
		cmn_err(CE_WARN, "This system contains a SCSI HBA card/driver "
		    "that doesn't support software reset. This "
		    "means that memory being used by the HBA for "
		    "DMA based reads could have been updated after "
		    "we panic'd.");
		return (1);
	} else {
		/* return failure to sd */
		return (0);
	}
}

/*ARGSUSED*/
static int
amr_tran_getcap(struct scsi_address *ap, char *cap, int whom)
{
	struct amr_softs	*softs;

	/*
	 * We don't allow inquiring about capabilities for other targets
	 */
	if (cap == NULL || whom == 0)
		return (-1);

	softs = ((struct amr_softs *)(ap->a_hba_tran)->tran_hba_private);

	switch (scsi_hba_lookup_capstr(cap)) {
	case SCSI_CAP_ARQ:
		return (1);
	case SCSI_CAP_GEOMETRY:
		return ((AMR_DEFAULT_HEADS << 16) | AMR_DEFAULT_CYLINDERS);
	case SCSI_CAP_SECTOR_SIZE:
		return (AMR_DEFAULT_SECTORS);
	case SCSI_CAP_TOTAL_SECTORS:
		/* number of sectors */
		return (softs->logic_drive[ap->a_target].al_size);
	case SCSI_CAP_UNTAGGED_QING:
	case SCSI_CAP_TAGGED_QING:
		return (1);
	default:
		return (-1);
	}
}

/*ARGSUSED*/
static int
amr_tran_setcap(struct scsi_address *ap, char *cap, int value,
		int whom)
{
	/*
	 * We don't allow setting capabilities for other targets
	 */
	if (cap == NULL || whom == 0) {
		AMRDB_PRINT((CE_NOTE,
		    "Set Cap not supported, string = %s, whom=%d",
		    cap, whom));
		return (-1);
	}

	switch (scsi_hba_lookup_capstr(cap)) {
	case SCSI_CAP_ARQ:
		return (1);
	case SCSI_CAP_TOTAL_SECTORS:
		return (1);
	case SCSI_CAP_SECTOR_SIZE:
		return (1);
	case SCSI_CAP_UNTAGGED_QING:
	case SCSI_CAP_TAGGED_QING:
		return ((value == 1) ? 1 : 0);
	default:
		return (0);
	}
}

static struct scsi_pkt *
amr_tran_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)
{
	struct amr_softs	*softs;
	struct amr_command	*ac;
	uint32_t		slen;

	softs = (struct amr_softs *)(ap->a_hba_tran->tran_hba_private);

	if ((ap->a_lun != 0)||(ap->a_target >= AMR_MAXLD)||
	    (softs->logic_drive[ap->a_target].al_state ==
	    AMR_LDRV_OFFLINE)) {
		return (NULL);
	}

	if (pkt == NULL) {
		/* force auto request sense */
		slen = MAX(statuslen, sizeof (struct scsi_arq_status));

		pkt = scsi_hba_pkt_alloc(softs->dev_info_p, ap, cmdlen,
		    slen, tgtlen, sizeof (struct amr_command),
		    callback, arg);
		if (pkt == NULL) {
			AMRDB_PRINT((CE_WARN, "scsi_hba_pkt_alloc failed"));
			return (NULL);
		}
		pkt->pkt_address	= *ap;
		pkt->pkt_comp		= (void (*)())NULL;
		pkt->pkt_time		= 0;
		pkt->pkt_resid		= 0;
		pkt->pkt_statistics	= 0;
		pkt->pkt_reason		= 0;

		ac = (struct amr_command *)pkt->pkt_ha_private;
		ac->ac_buf = bp;
		ac->cmdlen = cmdlen;
		ac->ac_softs = softs;
		ac->pkt = pkt;
		ac->ac_flags &= ~AMR_CMD_GOT_SLOT;
		ac->ac_flags &= ~AMR_CMD_BUSY;

		if ((bp == NULL) || (bp->b_bcount == 0)) {
			return (pkt);
		}

		if (ddi_dma_alloc_handle(softs->dev_info_p, &buffer_dma_attr,
		    DDI_DMA_SLEEP, NULL,
		    &ac->buffer_dma_handle) != DDI_SUCCESS) {

			AMRDB_PRINT((CE_WARN,
			    "Cannot allocate buffer DMA tag"));
			scsi_hba_pkt_free(ap, pkt);
			return (NULL);

		}

	} else {
		if ((bp == NULL) || (bp->b_bcount == 0)) {
			return (pkt);
		}
		ac = (struct amr_command *)pkt->pkt_ha_private;
	}

	ASSERT(ac != NULL);

	if (bp->b_flags & B_READ) {
		ac->ac_flags |= AMR_CMD_DATAOUT;
	} else {
		ac->ac_flags |= AMR_CMD_DATAIN;
	}

	if (flags & PKT_CONSISTENT) {
		ac->ac_flags |= AMR_CMD_PKT_CONSISTENT;
	}

	if (flags & PKT_DMA_PARTIAL) {
		ac->ac_flags |= AMR_CMD_PKT_DMA_PARTIAL;
	}

	if (amr_mapcmd(ac, callback, arg) != DDI_SUCCESS) {
		scsi_hba_pkt_free(ap, pkt);
		return (NULL);
	}

	pkt->pkt_resid = bp->b_bcount - ac->data_transfered;

	AMRDB_PRINT((CE_NOTE,
	    "init pkt, pkt_resid=%d, b_bcount=%d, data_transfered=%d",
	    (uint32_t)pkt->pkt_resid, (uint32_t)bp->b_bcount,
	    ac->data_transfered));

	ASSERT(pkt->pkt_resid >= 0);

	return (pkt);
}

static void
amr_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	struct amr_command *ac = (struct amr_command *)pkt->pkt_ha_private;

	amr_unmapcmd(ac);

	if (ac->buffer_dma_handle) {
		(void) ddi_dma_free_handle(&ac->buffer_dma_handle);
		ac->buffer_dma_handle = NULL;
	}

	scsi_hba_pkt_free(ap, pkt);
	AMRDB_PRINT((CE_NOTE, "Destroy pkt called"));
}

/*ARGSUSED*/
static void
amr_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	struct amr_command *ac = (struct amr_command *)pkt->pkt_ha_private;

	if (ac->buffer_dma_handle) {
		(void) ddi_dma_sync(ac->buffer_dma_handle, 0, 0,
		    (ac->ac_flags & AMR_CMD_DATAIN) ?
		    DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
	}
}

/*ARGSUSED*/
static void
amr_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	struct amr_command *ac = (struct amr_command *)pkt->pkt_ha_private;

	if (ac->ac_flags & AMR_CMD_MAPPED) {
		(void) ddi_dma_unbind_handle(ac->buffer_dma_handle);
		(void) ddi_dma_free_handle(&ac->buffer_dma_handle);
		ac->buffer_dma_handle = NULL;
		ac->ac_flags &= ~AMR_CMD_MAPPED;
	}

}

/*ARGSUSED*/
static void
amr_rw_command(struct amr_softs *softs, struct scsi_pkt *pkt, int target)
{
	struct amr_command	*ac = (struct amr_command *)pkt->pkt_ha_private;
	union scsi_cdb		*cdbp = (union scsi_cdb *)pkt->pkt_cdbp;
	uint8_t			cmd;

	if (ac->ac_flags & AMR_CMD_DATAOUT) {
		cmd = AMR_CMD_LREAD;
	} else {
		cmd = AMR_CMD_LWRITE;
	}

	ac->mailbox.mb_command = cmd;
	ac->mailbox.mb_blkcount =
	    (ac->transfer_size + AMR_BLKSIZE - 1)/AMR_BLKSIZE;
	ac->mailbox.mb_lba = (ac->cmdlen == 10) ?
	    GETG1ADDR(cdbp) : GETG0ADDR(cdbp);
	ac->mailbox.mb_drive = (uint8_t)target;
}

static void
amr_mode_sense(union scsi_cdb *cdbp, struct buf *bp, unsigned int capacity)
{
	uchar_t			pagecode;
	struct mode_format	*page3p;
	struct mode_geometry	*page4p;
	struct mode_header	*headerp;
	uint32_t		ncyl;

	if (!(bp && bp->b_un.b_addr && bp->b_bcount))
		return;

	if (bp->b_flags & (B_PHYS | B_PAGEIO))
		bp_mapin(bp);

	pagecode = cdbp->cdb_un.sg.scsi[0];
	switch (pagecode) {
	case SD_MODE_SENSE_PAGE3_CODE:
		headerp = (struct mode_header *)(bp->b_un.b_addr);
		headerp->bdesc_length = MODE_BLK_DESC_LENGTH;

		page3p = (struct mode_format *)((caddr_t)headerp +
		    MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH);
		page3p->mode_page.code = BE_8(SD_MODE_SENSE_PAGE3_CODE);
		page3p->mode_page.length = BE_8(sizeof (struct mode_format));
		page3p->data_bytes_sect = BE_16(AMR_DEFAULT_SECTORS);
		page3p->sect_track = BE_16(AMR_DEFAULT_CYLINDERS);

		return;

	case SD_MODE_SENSE_PAGE4_CODE:
		headerp = (struct mode_header *)(bp->b_un.b_addr);
		headerp->bdesc_length = MODE_BLK_DESC_LENGTH;

		page4p = (struct mode_geometry *)((caddr_t)headerp +
		    MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH);
		page4p->mode_page.code = BE_8(SD_MODE_SENSE_PAGE4_CODE);
		page4p->mode_page.length = BE_8(sizeof (struct mode_geometry));
		page4p->heads = BE_8(AMR_DEFAULT_HEADS);
		page4p->rpm = BE_16(AMR_DEFAULT_ROTATIONS);

		ncyl = capacity / (AMR_DEFAULT_HEADS*AMR_DEFAULT_CYLINDERS);
		page4p->cyl_lb = BE_8(ncyl & 0xff);
		page4p->cyl_mb = BE_8((ncyl >> 8) & 0xff);
		page4p->cyl_ub = BE_8((ncyl >> 16) & 0xff);

		return;
	default:
		bzero(bp->b_un.b_addr, bp->b_bcount);
		return;
	}
}

static void
amr_set_arq_data(struct scsi_pkt *pkt, uchar_t key)
{
	struct scsi_arq_status *arqstat;

	arqstat = (struct scsi_arq_status *)(pkt->pkt_scbp);
	arqstat->sts_status.sts_chk = 1; /* CHECK CONDITION */
	arqstat->sts_rqpkt_reason = CMD_CMPLT;
	arqstat->sts_rqpkt_resid = 0;
	arqstat->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
	    STATE_SENT_CMD | STATE_XFERRED_DATA;
	arqstat->sts_rqpkt_statistics = 0;
	arqstat->sts_sensedata.es_valid = 1;
	arqstat->sts_sensedata.es_class = CLASS_EXTENDED_SENSE;
	arqstat->sts_sensedata.es_key = key;
}

static void
amr_start_waiting_queue(void *softp)
{
	uint32_t		slot;
	struct amr_command	*ac;
	volatile uint32_t	done_flag;
	struct amr_softs	*softs = (struct amr_softs *)softp;

	/* only one command allowed at the same time */
	mutex_enter(&softs->queue_mutex);
	mutex_enter(&softs->cmd_mutex);

	while ((ac = softs->waiting_q_head) != NULL) {
		/*
		 * Find an available slot, the last slot is
		 * occupied by poll I/O command.
		 */
		for (slot = 0; slot < (softs->sg_max_count - 1); slot++) {
			if (softs->busycmd[slot] == NULL) {
				if (AMR_QGET_IDB(softs) & AMR_QIDB_SUBMIT) {
					/*
					 * only one command allowed at the
					 * same time
					 */
					mutex_exit(&softs->cmd_mutex);
					mutex_exit(&softs->queue_mutex);
					return;
				}

				ac->ac_timestamp = ddi_get_time();

				if (!(ac->ac_flags & AMR_CMD_GOT_SLOT)) {

					softs->busycmd[slot] = ac;
					ac->ac_slot = slot;
					softs->amr_busyslots++;

					bcopy(ac->sgtable,
					    softs->sg_items[slot].sg_table,
					    sizeof (struct amr_sgentry) *
					    AMR_NSEG);

					(void) ddi_dma_sync(
					    softs->sg_items[slot].sg_handle,
					    0, 0, DDI_DMA_SYNC_FORDEV);

					ac->mailbox.mb_physaddr =
					    softs->sg_items[slot].sg_phyaddr;
				}

				/* take the cmd from the queue */
				softs->waiting_q_head = ac->ac_next;

				ac->mailbox.mb_ident = ac->ac_slot + 1;
				ac->mailbox.mb_busy = 1;
				ac->ac_next = NULL;
				ac->ac_prev = NULL;
				ac->ac_flags |= AMR_CMD_GOT_SLOT;

				/* clear the poll/ack fields in the mailbox */
				softs->mailbox->mb_poll = 0;
				softs->mailbox->mb_ack = 0;

				AMR_DELAY((softs->mailbox->mb_busy == 0),
				    AMR_RETRYCOUNT, done_flag);
				if (!done_flag) {
					/*
					 * command not completed, indicate the
					 * problem and continue get ac
					 */
					cmn_err(CE_WARN,
					    "AMR command is not completed");
					break;
				}

				bcopy(&ac->mailbox, (void *)softs->mailbox,
				    AMR_MBOX_CMDSIZE);
				ac->ac_flags |= AMR_CMD_BUSY;

				(void) ddi_dma_sync(softs->mbox_dma_handle,
				    0, 0, DDI_DMA_SYNC_FORDEV);

				AMR_QPUT_IDB(softs,
				    softs->mbox_phyaddr | AMR_QIDB_SUBMIT);

				/*
				 * current ac is submitted
				 * so quit 'for-loop' to get next ac
				 */
				break;
			}
		}

		/* no slot, finish our task */
		if (slot == softs->maxio)
			break;
	}

	/* only one command allowed at the same time */
	mutex_exit(&softs->cmd_mutex);
	mutex_exit(&softs->queue_mutex);
}

static void
amr_done(struct amr_softs *softs)
{

	uint32_t		i, idx;
	volatile uint32_t	done_flag;
	struct amr_mailbox	*mbox, mbsave;
	struct amr_command	*ac, *head, *tail;

	head = tail = NULL;

	AMR_QPUT_ODB(softs, AMR_QODB_READY);

	/* acknowledge interrupt */
	(void) AMR_QGET_ODB(softs);

	mutex_enter(&softs->cmd_mutex);

	if (softs->mailbox->mb_nstatus != 0) {
		(void) ddi_dma_sync(softs->mbox_dma_handle,
		    0, 0, DDI_DMA_SYNC_FORCPU);

		/* save mailbox, which contains a list of completed commands */
		bcopy((void *)(uintptr_t)(volatile void *)softs->mailbox,
		    &mbsave, sizeof (mbsave));

		mbox = &mbsave;

		AMR_QPUT_IDB(softs, softs->mbox_phyaddr | AMR_QIDB_ACK);

		/* wait for the acknowledge from hardware */
		AMR_BUSYWAIT(!(AMR_QGET_IDB(softs) & AMR_QIDB_ACK),
		    AMR_RETRYCOUNT, done_flag);
		if (!done_flag) {
			/*
			 * command is not completed, return from the current
			 * interrupt and wait for the next one
			 */
			cmn_err(CE_WARN, "No answer from the hardware");

			mutex_exit(&softs->cmd_mutex);
			return;
		}

		for (i = 0; i < mbox->mb_nstatus; i++) {
			idx = mbox->mb_completed[i] - 1;
			ac = softs->busycmd[idx];

			if (ac != NULL) {
				/* pull the command from the busy index */
				softs->busycmd[idx] = NULL;
				if (softs->amr_busyslots > 0)
					softs->amr_busyslots--;
				if (softs->amr_busyslots == 0)
					cv_broadcast(&softs->cmd_cv);

				ac->ac_flags &= ~AMR_CMD_BUSY;
				ac->ac_flags &= ~AMR_CMD_GOT_SLOT;
				ac->ac_status = mbox->mb_status;

				/* enqueue here */
				if (head) {
					tail->ac_next = ac;
					tail = ac;
					tail->ac_next = NULL;
				} else {
					tail = head = ac;
					ac->ac_next = NULL;
				}
			} else {
				AMRDB_PRINT((CE_WARN,
				    "ac in mailbox is NULL!"));
			}
		}
	} else {
		AMRDB_PRINT((CE_WARN, "mailbox is not ready for copy out!"));
	}

	mutex_exit(&softs->cmd_mutex);

	if (head != NULL) {
		amr_call_pkt_comp(head);
	}

	/* dispatch a thread to process the pending I/O if there is any */
	if ((ddi_taskq_dispatch(softs->amr_taskq, amr_start_waiting_queue,
	    (void *)softs, DDI_NOSLEEP)) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "No memory available to dispatch taskq");
	}
}

static void
amr_call_pkt_comp(register struct amr_command *head)
{
	register struct scsi_pkt	*pkt;
	register struct amr_command	*ac, *localhead;

	localhead = head;

	while (localhead) {
		ac = localhead;
		localhead = ac->ac_next;
		ac->ac_next = NULL;

		pkt = ac->pkt;
		*pkt->pkt_scbp = 0;

		if (ac->ac_status == AMR_STATUS_SUCCESS) {
			pkt->pkt_state |= (STATE_GOT_BUS
			    | STATE_GOT_TARGET
			    | STATE_SENT_CMD
			    | STATE_XFERRED_DATA);
			pkt->pkt_reason = CMD_CMPLT;
		} else {
			pkt->pkt_state |= STATE_GOT_BUS
			    | STATE_ARQ_DONE;
			pkt->pkt_reason = CMD_INCOMPLETE;
			amr_set_arq_data(pkt, KEY_HARDWARE_ERROR);
		}
		if (!(pkt->pkt_flags & FLAG_NOINTR)) {
			scsi_hba_pkt_comp(pkt);
		}
	}
}