xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_mbx.c (revision 4c3888b8)

/*
 * 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 2015 QLogic Corporation */

/*
 * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * ISP2xxx Solaris Fibre Channel Adapter (FCA) driver source file.
 *
 * ***********************************************************************
 * *									**
 * *				NOTICE					**
 * *		COPYRIGHT (C) 1996-2015 QLOGIC CORPORATION		**
 * *			ALL RIGHTS RESERVED				**
 * *									**
 * ***********************************************************************
 *
 */

#include <ql_apps.h>
#include <ql_api.h>
#include <ql_debug.h>
#include <ql_iocb.h>
#include <ql_isr.h>
#include <ql_mbx.h>
#include <ql_nx.h>
#include <ql_xioctl.h>

/*
 * Local data
 */

/*
 * Local prototypes
 */
static int ql_mailbox_command(ql_adapter_state_t *, mbx_cmd_t *);
static int ql_task_mgmt_iocb(ql_adapter_state_t *, ql_tgt_t *, uint64_t,
    uint32_t, uint16_t);
static int ql_abort_cmd_iocb(ql_adapter_state_t *, ql_srb_t *);
static int ql_setup_mbox_dma_transfer(ql_adapter_state_t *, dma_mem_t *,
    caddr_t, uint32_t);
static int ql_setup_mbox_dma_resources(ql_adapter_state_t *, dma_mem_t *,
    uint32_t);
static void ql_setup_mbox_dma_data(dma_mem_t *, caddr_t);
static void ql_get_mbox_dma_data(dma_mem_t *, caddr_t);
static int ql_init_req_q(ql_adapter_state_t *, ql_request_q_t *, uint16_t);
static int ql_init_rsp_q(ql_adapter_state_t *, ql_response_q_t *, uint16_t);
/*
 * ql_mailbox_command
 *	Issue mailbox command and waits for completion.
 *
 * Input:
 *	ha = adapter state pointer.
 *	mcp = mailbox command parameter structure pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
static int
ql_mailbox_command(ql_adapter_state_t *vha, mbx_cmd_t *mcp)
{
	uint16_t		cnt;
	uint32_t		data;
	clock_t			timer, cv_stat;
	int			rval;
	uint32_t		set_flags = 0;
	uint32_t		reset_flags = 0;
	ql_adapter_state_t	*ha = vha->pha;
	int			mbx_cmd = mcp->mb[0];

	QL_PRINT_3(ha, "started, cmd=%xh\n", mbx_cmd);

	/* Acquire mailbox register lock. */
	MBX_REGISTER_LOCK(ha);

	/* Check for mailbox available, if not wait for signal. */
	while (ha->mailbox_flags & MBX_BUSY_FLG) {
		if (ha->task_daemon_flags & TASK_DAEMON_POWERING_DOWN) {
			EL(vha, "powerdown availability cmd=%xh\n", mcp->mb[0]);
			MBX_REGISTER_UNLOCK(ha);
			return (QL_LOCK_TIMEOUT);
		}
		ha->mailbox_flags = (uint8_t)
		    (ha->mailbox_flags | MBX_WANT_FLG);

		/* Set timeout after command that is running. */
		timer = ha->mailbox_flags & MBX_BUSY_FLG ?
		    (mcp->timeout + 20) : 2;
		timer = timer * drv_usectohz(1000000);
		cv_stat = cv_reltimedwait_sig(&ha->cv_mbx_wait,
		    &ha->pha->mbx_mutex, timer, TR_CLOCK_TICK);
		if (cv_stat == -1 || cv_stat == 0) {
			/*
			 * The timeout time 'timer' was
			 * reached without the condition
			 * being signaled.
			 */
			ha->mailbox_flags = (uint8_t)(ha->mailbox_flags &
			    ~MBX_WANT_FLG);
			cv_broadcast(&ha->cv_mbx_wait);

			/* Release mailbox register lock. */
			MBX_REGISTER_UNLOCK(ha);

			if (cv_stat == 0) {
				EL(vha, "waiting for availability aborted, "
				    "cmd=%xh\n", mcp->mb[0]);
				return (QL_ABORTED);
			}
			EL(vha, "failed availability cmd=%xh\n", mcp->mb[0]);
			return (QL_LOCK_TIMEOUT);
		}
	}

	ha->mailbox_flags = (uint8_t)(ha->mailbox_flags | MBX_BUSY_FLG);

	/* Structure pointer for return mailbox registers. */
	ha->mcp = mcp;

	/* Load mailbox registers. */
	data = mcp->out_mb;
	for (cnt = 0; cnt < ha->reg_off->mbox_cnt && data; cnt++) {
		if (data & MBX_0) {
			WRT16_IO_REG(ha, mailbox_in[cnt], mcp->mb[cnt]);
		}
		data >>= 1;
	}

	/* Issue set host interrupt command. */
	ha->mailbox_flags = (uint8_t)(ha->mailbox_flags & ~MBX_INTERRUPT);
	if (CFG_IST(ha, CFG_CTRL_82XX)) {
		WRT32_IO_REG(ha, nx_host_int, NX_MBX_CMD);
	} else if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		WRT32_IO_REG(ha, hccr, HC24_SET_HOST_INT);
	} else {
		WRT16_IO_REG(ha, hccr, HC_SET_HOST_INT);
	}

	/* Wait for command to complete. */
	if (ha->flags & INTERRUPTS_ENABLED &&
	    !(ha->task_daemon_flags & TASK_DAEMON_POWERING_DOWN) &&
	    !ddi_in_panic()) {
		timer = mcp->timeout * drv_usectohz(1000000);
		while (!(ha->mailbox_flags & (MBX_INTERRUPT | MBX_ABORT)) &&
		    !(ha->task_daemon_flags & ISP_ABORT_NEEDED)) {

			if (cv_reltimedwait(&ha->cv_mbx_intr,
			    &ha->pha->mbx_mutex, timer, TR_CLOCK_TICK) == -1) {
				/*
				 * The timeout time 'timer' was
				 * reached without the condition
				 * being signaled.
				 */
				EL(vha, "reltimedwait expired cmd=%xh\n",
				    mcp->mb[0]);
				MBX_REGISTER_UNLOCK(ha);
				while (INTERRUPT_PENDING(ha)) {
					(void) ql_isr((caddr_t)ha);
					INTR_LOCK(ha);
					ha->intr_claimed = B_TRUE;
					INTR_UNLOCK(ha);
				}
				MBX_REGISTER_LOCK(ha);
				break;
			}
		}
	} else {
		/* Release mailbox register lock. */
		MBX_REGISTER_UNLOCK(ha);

		/* Acquire interrupt lock. */
		for (timer = mcp->timeout * 100; timer; timer--) {
			/* Check for pending interrupts. */
			while (INTERRUPT_PENDING(ha)) {
				(void) ql_isr((caddr_t)ha);
				INTR_LOCK(ha);
				ha->intr_claimed = B_TRUE;
				INTR_UNLOCK(ha);
				if (ha->mailbox_flags &
				    (MBX_INTERRUPT | MBX_ABORT) ||
				    ha->task_daemon_flags & ISP_ABORT_NEEDED) {
					break;
				}
			}
			if (ha->mailbox_flags & (MBX_INTERRUPT | MBX_ABORT) ||
			    ha->task_daemon_flags & ISP_ABORT_NEEDED) {
				break;
			} else if (!ddi_in_panic() && timer % 101 == 0) {
				delay(drv_usectohz(10000));
			} else {
				drv_usecwait(10000);
			}
		}

		/* Acquire mailbox register lock. */
		MBX_REGISTER_LOCK(ha);
	}

	/* Mailbox command timeout? */
	if (ha->task_daemon_flags & ISP_ABORT_NEEDED ||
	    ha->mailbox_flags & MBX_ABORT) {
		rval = QL_ABORTED;
	} else if ((ha->mailbox_flags & MBX_INTERRUPT) == 0) {
		if (!CFG_IST(ha, CFG_CTRL_82XX)) {
			if (CFG_IST(ha, CFG_DUMP_MAILBOX_TIMEOUT)) {
				(void) ql_binary_fw_dump(ha, FALSE);
			}
			EL(vha, "command timeout, isp_abort_needed\n");
			set_flags |= ISP_ABORT_NEEDED;
		}
		rval = QL_FUNCTION_TIMEOUT;
	} else {
		ha->mailbox_flags = (uint8_t)
		    (ha->mailbox_flags & ~MBX_INTERRUPT);
		/*
		 * This is the expected completion path so
		 * return the actual mbx cmd completion status.
		 */
		rval = mcp->mb[0];
	}

	/*
	 * Clear outbound to risc mailbox registers per spec. The exception
	 * is on 2200 mailbox 4 and 5 affect the req and resp que indexes
	 * so avoid writing them.
	 */
	if (CFG_IST(ha, CFG_CTRL_22XX)) {
		data = ((mcp->out_mb & ~(MBX_4 | MBX_5)) >> 1);
	} else {
		data = (mcp->out_mb >> 1);
	}
	for (cnt = 1; cnt < ha->reg_off->mbox_cnt && data; cnt++) {
		if (data & MBX_0) {
			WRT16_IO_REG(ha, mailbox_in[cnt], (uint16_t)0);
		}
		data >>= 1;
	}

	/* Reset busy status. */
	ha->mailbox_flags = (uint8_t)(ha->mailbox_flags &
	    ~(MBX_BUSY_FLG | MBX_ABORT));
	ha->mcp = NULL;

	/* If thread is waiting for mailbox go signal it to start. */
	if (ha->mailbox_flags & MBX_WANT_FLG) {
		ha->mailbox_flags = (uint8_t)(ha->mailbox_flags &
		    ~MBX_WANT_FLG);
		cv_broadcast(&ha->cv_mbx_wait);
	}

	/* Release mailbox register lock. */
	MBX_REGISTER_UNLOCK(ha);

	if (set_flags != 0 || reset_flags != 0) {
		ql_awaken_task_daemon(ha, NULL, set_flags, reset_flags);
	}

	if (rval != QL_SUCCESS) {
		EL(vha, "%s failed, rval=%xh, mcp->mb[0]=%xh\n",
		    mbx_cmd_text(mbx_cmd), rval, mcp->mb[0]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_setup_mbox_dma_resources
 *	Prepare the data for a mailbox dma transfer.
 *
 * Input:
 *	ha = adapter state pointer.
 *	mem_desc = descriptor to contain the dma resource information.
 *	data = pointer to the data.
 *	size = size of the data in bytes.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
static int
ql_setup_mbox_dma_transfer(ql_adapter_state_t *ha, dma_mem_t *mem_desc,
    caddr_t data, uint32_t size)
{
	int rval = QL_SUCCESS;

	if ((rval = ql_setup_mbox_dma_resources(ha, mem_desc, size)) ==
	    QL_SUCCESS) {
		ql_setup_mbox_dma_data(mem_desc, data);
	} else {
		EL(ha, "failed, setup_mbox_dma_transfer: %xh\n", rval);
	}

	return (rval);
}

/*
 * ql_setup_mbox_dma_resources
 *	Prepare a dma buffer.
 *
 * Input:
 *	ha = adapter state pointer.
 *	mem_desc = descriptor to contain the dma resource information.
 *	data = pointer to the data.
 *	size = size of the data in bytes.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
static int
ql_setup_mbox_dma_resources(ql_adapter_state_t *ha, dma_mem_t *mem_desc,
    uint32_t size)
{
	int	rval = QL_SUCCESS;

	if ((rval = ql_get_dma_mem(ha, mem_desc, size, LITTLE_ENDIAN_DMA,
	    QL_DMA_RING_ALIGN)) != QL_SUCCESS) {
		EL(ha, "failed, ql_get_dma_mem FC_NOMEM\n");
		rval = QL_MEMORY_ALLOC_FAILED;
	}

	return (rval);
}

/*
 * ql_setup_mbox_dma_data
 *	Move data to the dma buffer.
 *
 * Input:
 *	mem_desc = descriptor to contain the dma resource information.
 *	data = pointer to the data.
 *
 * Returns:
 *
 * Context:
 *	Kernel context.
 */
static void
ql_setup_mbox_dma_data(dma_mem_t *mem_desc, caddr_t data)
{
	/* Copy out going data to DMA buffer. */
	ddi_rep_put8(mem_desc->acc_handle, (uint8_t *)data,
	    (uint8_t *)mem_desc->bp, mem_desc->size, DDI_DEV_AUTOINCR);

	/* Sync DMA buffer. */
	(void) ddi_dma_sync(mem_desc->dma_handle, 0, mem_desc->size,
	    DDI_DMA_SYNC_FORDEV);
}

/*
 * ql_get_mbox_dma_data
 *	Recover data from the dma buffer.
 *
 * Input:
 *	mem_desc = descriptor to contain the dma resource information.
 *	data = pointer to the data.
 *
 * Returns:
 *
 * Context:
 *	Kernel context.
 */
static void
ql_get_mbox_dma_data(dma_mem_t *mem_desc, caddr_t data)
{
	/* Sync in coming DMA buffer. */
	(void) ddi_dma_sync(mem_desc->dma_handle, 0, mem_desc->size,
	    DDI_DMA_SYNC_FORKERNEL);
	/* Copy in coming DMA data. */
	ddi_rep_get8(mem_desc->acc_handle, (uint8_t *)data,
	    (uint8_t *)mem_desc->bp, mem_desc->size, DDI_DEV_AUTOINCR);
}

/*
 * ql_initialize_ip
 *	Initialize IP receive buffer queue.
 *
 * Input:
 *	ha = adapter state pointer.
 *	ha->ip_init_ctrl_blk = setup for transmit.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_initialize_ip(ql_adapter_state_t *ha)
{
	ql_link_t	*link;
	ql_tgt_t	*tq;
	uint16_t	index;
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (!CFG_IST(ha, CFG_FCIP_SUPPORT) || ha->vp_index != 0) {
		ha->flags &= ~IP_INITIALIZED;
		EL(ha, "HBA does not support IP\n");
		return (QL_FUNCTION_FAILED);
	}

	ha->rcvbuf_ring_ptr = ha->rcv_ring.bp;
	ha->rcvbuf_ring_index = 0;

	/* Reset all sequence counts. */
	for (index = 0; index < DEVICE_HEAD_LIST_SIZE; index++) {
		for (link = ha->dev[index].first; link != NULL;
		    link = link->next) {
			tq = link->base_address;
			tq->ub_total_seg_cnt = 0;
		}
	}

	rval = ql_setup_mbox_dma_transfer(ha, &mem_desc,
	    (caddr_t)&ha->ip_init_ctrl_blk, sizeof (ql_comb_ip_init_cb_t));
	if (rval != QL_SUCCESS) {
		EL(ha, "failed, setup_mbox_dma_transfer: %xh\n", rval);
		return (rval);
	}

	mcp->mb[0] = MBC_INITIALIZE_IP;
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[8] = 0;
	mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	mcp->in_mb = MBX_8|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	ql_free_dma_resource(ha, &mem_desc);

	if (rval == QL_SUCCESS) {
		ADAPTER_STATE_LOCK(ha);
		ha->flags |= IP_INITIALIZED;
		ADAPTER_STATE_UNLOCK(ha);
		QL_PRINT_3(ha, "done\n");
	} else {
		ha->flags &= ~IP_INITIALIZED;
		EL(ha, "failed, rval = %xh\n", rval);
	}
	return (rval);
}

/*
 * ql_shutdown_ip
 *	Disconnects firmware IP from system buffers.
 *
 * Input:
 *	ha = adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_shutdown_ip(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;
	fc_unsol_buf_t	*ubp;
	ql_srb_t	*sp;
	uint16_t	index;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_UNLOAD_IP;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	ADAPTER_STATE_LOCK(ha);
	QL_UB_LOCK(ha);
	/* Return all unsolicited buffers that ISP-IP has. */
	for (index = 0; index < QL_UB_LIMIT; index++) {
		ubp = ha->ub_array[index];
		if (ubp != NULL) {
			sp = ubp->ub_fca_private;
			sp->flags &= ~SRB_UB_IN_ISP;
		}
	}

	ha->ub_outcnt = 0;
	QL_UB_UNLOCK(ha);
	ha->flags &= ~IP_INITIALIZED;
	ADAPTER_STATE_UNLOCK(ha);

	if (rval == QL_SUCCESS) {
		/* EMPTY - no need to check return value of MBC_SHUTDOWN_IP */
		QL_PRINT_3(ha, "done\n");
	} else {
		EL(ha, "failed, rval = %xh\n", rval);
	}
	return (rval);
}

/*
 * ql_online_selftest
 *	Issue online self test mailbox command.
 *
 * Input:
 *	ha = adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_online_selftest(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_ONLINE_SELF_TEST;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0 | MBX_1 | MBX_2 | MBX_3;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh, mb1=%xh, mb2=%xh, mb3=%xh\n",
		    rval, mcp->mb[1], mcp->mb[2], mcp->mb[3]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_loop_back
 *	Issue diagnostic loop back frame mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	findex:	FCF index.
 *	lb:	loop back parameter structure pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
#ifndef apps_64bit
int
ql_loop_back(ql_adapter_state_t *ha, uint16_t findex, lbp_t *lb,
    uint32_t h_xmit, uint32_t h_rcv)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
	mcp->mb[1] = lb->options;
	mcp->mb[2] = findex;
	mcp->mb[6] = LSW(h_rcv);
	mcp->mb[7] = MSW(h_rcv);
	mcp->mb[10] = LSW(lb->transfer_count);
	mcp->mb[11] = MSW(lb->transfer_count);
	mcp->mb[12] = lb->transfer_segment_count;
	mcp->mb[13] = lb->receive_segment_count;
	mcp->mb[14] = LSW(lb->transfer_data_address);
	mcp->mb[15] = MSW(lb->transfer_data_address);
	mcp->mb[16] = LSW(lb->receive_data_address);
	mcp->mb[17] = MSW(lb->receive_data_address);
	mcp->mb[18] = LSW(lb->iteration_count);
	mcp->mb[19] = MSW(lb->iteration_count);
	mcp->mb[20] = LSW(h_xmit);
	mcp->mb[21] = MSW(h_xmit);
	mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
	    MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = lb->iteration_count / 300;

	if (mcp->timeout < MAILBOX_TOV) {
		mcp->timeout = MAILBOX_TOV;
	}

	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh, mb1=%xh, mb2=%xh, mb3=%xh\n",
		    rval, mcp->mb[1], mcp->mb[2], mcp->mb[3]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}
#else
int
ql_loop_back(ql_adapter_state_t *ha, uint16_t findex, lbp_t *lb)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
	mcp->mb[1] = lb->options;
	mcp->mb[2] = findex;
	mcp->mb[6] = LSW(h_rcv);
	mcp->mb[7] = MSW(h_rcv);
	mcp->mb[6] = LSW(MSD(lb->receive_data_address));
	mcp->mb[7] = MSW(MSD(lb->receive_data_address));
	mcp->mb[10] = LSW(lb->transfer_count);
	mcp->mb[11] = MSW(lb->transfer_count);
	mcp->mb[12] = lb->transfer_segment_count;
	mcp->mb[13] = lb->receive_segment_count;
	mcp->mb[14] = LSW(lb->transfer_data_address);
	mcp->mb[15] = MSW(lb->transfer_data_address);
	mcp->mb[14] = LSW(LSD(lb->transfer_data_address));
	mcp->mb[15] = MSW(LSD(lb->transfer_data_address));
	mcp->mb[16] = LSW(lb->receive_data_address);
	mcp->mb[17] = MSW(lb->receive_data_address);
	mcp->mb[16] = LSW(LSD(lb->receive_data_address));
	mcp->mb[17] = MSW(LSD(lb->receive_data_address));
	mcp->mb[18] = LSW(lb->iteration_count);
	mcp->mb[19] = MSW(lb->iteration_count);
	mcp->mb[20] = LSW(h_xmit);
	mcp->mb[21] = MSW(h_xmit);
	mcp->mb[20] = LSW(MSD(lb->transfer_data_address));
	mcp->mb[21] = MSW(MSD(lb->transfer_data_address));
	mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
	    MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = lb->iteration_count / 300;

	if (mcp->timeout < MAILBOX_TOV) {
		mcp->timeout = MAILBOX_TOV;
	}

	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}
#endif

/*
 * ql_echo
 *	Issue an ELS echo using the user specified data to a user specified
 *	destination
 *
 * Input:
 *	ha:		adapter state pointer.
 *	findex:		FCF index.
 *	echo_pt:	echo parameter structure pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_echo(ql_adapter_state_t *ha, uint16_t findex, echo_t *echo_pt)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_ECHO;			/* ECHO command */
	mcp->mb[1] = echo_pt->options;		/* command options; 64 bit */
						/* addressing (bit 6) and */
						/* real echo (bit 15 */
	mcp->mb[2] = findex;

	/*
	 * I know this looks strange, using a field labled "not used"
	 * The way the ddi_dma_cookie_t structure/union is defined
	 * is a union of one 64 bit entity with an array of two 32
	 * bit enititys.  Since we have routines to convert 32 bit
	 * entities into 16 bit entities it is easier to use
	 * both 32 bit union members then the one 64 bit union
	 * member
	 */
	if (echo_pt->options & BIT_6) {
		/* 64 bit addressing */
		/* Receive data dest add in system memory bits 47-32 */
		mcp->mb[6] = LSW(echo_pt->receive_data_address.dmac_notused);

		/* Receive data dest add in system memory bits 63-48 */
		mcp->mb[7] = MSW(echo_pt->receive_data_address.dmac_notused);

		/* Transmit data source address in system memory bits 47-32 */
		mcp->mb[20] = LSW(echo_pt->transfer_data_address.dmac_notused);

		/* Transmit data source address in system memory bits 63-48 */
		mcp->mb[21] = MSW(echo_pt->transfer_data_address.dmac_notused);
	}

	/* transfer count bits 15-0 */
	mcp->mb[10] = LSW(echo_pt->transfer_count);

	/* Transmit data source address in system memory bits 15-0 */
	mcp->mb[14] = LSW(echo_pt->transfer_data_address.dmac_address);

	/*  Transmit data source address in system memory bits 31-16 */
	mcp->mb[15] = MSW(echo_pt->transfer_data_address.dmac_address);

	/* Receive data destination address in system memory bits 15-0 */
	mcp->mb[16] = LSW(echo_pt->receive_data_address.dmac_address);

	/*  Receive data destination address in system memory bits 31-16 */
	mcp->mb[17] = MSW(echo_pt->receive_data_address.dmac_address);

	mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|MBX_14|MBX_10|
	    MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_3|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;

	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_send_change_request
 *	Issue send change request mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	fmt:	Registration format.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_send_change_request(ql_adapter_state_t *ha, uint16_t fmt)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
	mcp->mb[1] = fmt;
	mcp->out_mb = MBX_1|MBX_0;
	if (ha->flags & VP_ENABLED) {
		mcp->mb[9] = ha->vp_index;
		mcp->out_mb |= MBX_9;
	}
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_send_lfa
 *	Send a Loop Fabric Address mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	lfa:	LFA command structure pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_send_lfa(ql_adapter_state_t *ha, lfa_cmd_t *lfa)
{
	int		rval;
	uint16_t	size;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	/* LFA_CB sz = 4 16bit words subcommand + 10 16bit words header. */
	size = (uint16_t)((lfa->subcommand_length[0] + 10) << 1);

	rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, (caddr_t)lfa, size);
	if (rval != QL_SUCCESS) {
		EL(ha, "failed, setup_mbox_dma_transfer: %xh\n", rval);
		return (rval);
	}

	mcp->mb[0] = MBC_SEND_LFA_COMMAND;
	mcp->mb[1] = (uint16_t)(size >> 1);
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->in_mb = MBX_0;
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	if (ha->flags & VP_ENABLED) {
		mcp->mb[9] = ha->vp_index;
		mcp->out_mb |= MBX_9;
	}
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_clear_aca
 *	Issue clear ACA mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *	lq:	LUN queue pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_clear_aca(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
		    CF_CLEAR_ACA, 0);
	} else {
		mcp->mb[0] = MBC_CLEAR_ACA;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
		}
		mcp->mb[2] = lq->lun_no;
		mcp->out_mb = MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	(void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_target_reset
 *	Issue target reset mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *	delay:	seconds.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_target_reset(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t delay)
{
	ql_link_t	*link;
	ql_srb_t	*sp;
	uint16_t	index;
	int		rval = QL_SUCCESS;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	ql_requeue_pending_cmds(ha, tq);
	INTR_LOCK(ha);
	for (index = 1; index < ha->pha->osc_max_cnt; index++) {
		if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
		    sp->lun_queue != NULL &&
		    sp->lun_queue->target_queue == tq) {
			sp->flags |= SRB_ABORTING;
		}
	}
	INTR_UNLOCK(ha);

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		/* queue = NULL, all targets. */
		if (tq == NULL) {
			for (index = 0; index < DEVICE_HEAD_LIST_SIZE;
			    index++) {
				for (link = ha->dev[index].first; link !=
				    NULL; link = link->next) {
					tq = link->base_address;
					if (!VALID_DEVICE_ID(ha,
					    tq->loop_id)) {
						continue;
					}

					if (CFG_IST(ha, CFG_FAST_TIMEOUT)) {
						rval = ql_task_mgmt_iocb(ha,
						    tq, 0, CF_DO_NOT_SEND |
						    CF_TARGET_RESET, delay);
					} else {
						rval = ql_task_mgmt_iocb(ha,
						    tq, 0, CF_TARGET_RESET,
						    delay);
					}

					if (rval != QL_SUCCESS) {
						break;
					}
				}

				if (link != NULL) {
					break;
				}
			}
			tq = NULL;
		} else {

			if (CFG_IST(ha, CFG_FAST_TIMEOUT)) {
				rval = ql_task_mgmt_iocb(ha, tq, 0,
				    CF_TARGET_RESET | CF_DO_NOT_SEND, delay);
			} else {
				rval = ql_task_mgmt_iocb(ha, tq, 0,
				    CF_TARGET_RESET, delay);
			}
		}
	} else {
		/* queue = NULL, all targets. */
		if (tq == NULL) {
			mcp->mb[0] = MBC_RESET;
			mcp->mb[1] = delay;
			mcp->out_mb = MBX_1|MBX_0;
		} else {
			mcp->mb[0] = MBC_TARGET_RESET;
			if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
				mcp->mb[1] = tq->loop_id;
			} else {
				mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
			}
			mcp->mb[2] = delay;
			mcp->out_mb = MBX_2|MBX_1|MBX_0;
		}
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	tq == NULL ? (void) ql_marker(ha, 0, 0, MK_SYNC_ALL) :
	    (void) ql_marker(ha, tq->loop_id, 0, MK_SYNC_ID);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_abort_target
 *	Issue abort target mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *	delay:	in seconds.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_abort_target(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t delay)
{
	ql_srb_t	*sp;
	uint16_t	index;
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	ql_requeue_pending_cmds(ha, tq);
	INTR_LOCK(ha);
	for (index = 1; index < ha->pha->osc_max_cnt; index++) {
		if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
		    sp->lun_queue != NULL &&
		    sp->lun_queue->target_queue == tq) {
			sp->flags |= SRB_ABORTING;
		}
	}
	INTR_UNLOCK(ha);

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		rval = ql_task_mgmt_iocb(ha, tq, 0,
		    CF_DO_NOT_SEND | CF_TARGET_RESET, delay);
	} else {
		mcp->mb[0] = MBC_ABORT_TARGET;
		/* Don't send Task Mgt */
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
			mcp->mb[10] = BIT_0;
			mcp->out_mb = MBX_10|MBX_2|MBX_1|MBX_0;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8 | BIT_0);
			mcp->out_mb = MBX_2|MBX_1|MBX_0;
		}
		mcp->mb[2] = delay;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	(void) ql_marker(ha, tq->loop_id, 0, MK_SYNC_ID);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_lun_reset
 *	Issue LUN reset task management mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *	lq:	LUN queue pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_lun_reset(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
{
	ql_srb_t	*sp;
	uint16_t	index;
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	ql_requeue_pending_cmds(ha, tq);
	INTR_LOCK(ha);
	for (index = 1; index < ha->pha->osc_max_cnt; index++) {
		if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
		    sp->lun_queue != NULL &&
		    sp->lun_queue->target_queue == tq &&
		    sp->lun_queue == lq) {
			sp->flags |= SRB_ABORTING;
		}
	}
	INTR_UNLOCK(ha);

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
		    CF_LUN_RESET, 0);
	} else {
		mcp->mb[0] = MBC_LUN_RESET;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
		}
		mcp->mb[2] = lq->lun_no;
		mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	(void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_clear_task_set
 *	Issue clear task set mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *	lq:	LUN queue pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_clear_task_set(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
{
	ql_srb_t	*sp;
	uint16_t	index;
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	ql_requeue_pending_cmds(ha, tq);
	INTR_LOCK(ha);
	for (index = 1; index < ha->pha->osc_max_cnt; index++) {
		if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
		    sp->lun_queue != NULL &&
		    sp->lun_queue->target_queue == tq &&
		    sp->lun_queue == lq) {
			sp->flags |= SRB_ABORTING;
		}
	}
	INTR_UNLOCK(ha);

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
		    CF_CLEAR_TASK_SET, 0);
	} else {
		mcp->mb[0] = MBC_CLEAR_TASK_SET;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
		}
		mcp->mb[2] = lq->lun_no;
		mcp->out_mb = MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	(void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_abort_task_set
 *	Issue abort task set mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *	lq:	LUN queue pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_abort_task_set(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
{
	ql_srb_t	*sp;
	uint16_t	index;
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	ql_requeue_pending_cmds(ha, tq);
	INTR_LOCK(ha);
	for (index = 1; index < ha->pha->osc_max_cnt; index++) {
		if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
		    sp->lun_queue != NULL &&
		    sp->lun_queue->target_queue == tq &&
		    sp->lun_queue == lq) {
			sp->flags |= SRB_ABORTING;
		}
	}
	INTR_UNLOCK(ha);

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
		    CF_ABORT_TASK_SET, 0);
	} else {
		mcp->mb[0] = MBC_ABORT_TASK_SET;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
		}
		mcp->mb[2] = lq->lun_no;
		mcp->out_mb = MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	(void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_task_mgmt_iocb
 *	Function issues task management IOCB.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	tq:		target queue pointer.
 *	lun_addr:	LUN.
 *	flags:		control flags.
 *	delay:		seconds.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context
 */
static int
ql_task_mgmt_iocb(ql_adapter_state_t *ha, ql_tgt_t *tq, uint64_t lun_addr,
    uint32_t flags, uint16_t delay)
{
	ql_mbx_iocb_t	*pkt;
	int		rval;
	uint32_t	pkt_size;
	fcp_ent_addr_t	*fcp_ent_addr;

	QL_PRINT_3(ha, "started\n");

	pkt_size = sizeof (ql_mbx_iocb_t);
	pkt = kmem_zalloc(pkt_size, KM_SLEEP);
	if (pkt == NULL) {
		EL(ha, "failed, kmem_zalloc\n");
		return (QL_MEMORY_ALLOC_FAILED);
	}

	pkt->mgmt.entry_type = TASK_MGMT_TYPE;
	pkt->mgmt.entry_count = 1;

	pkt->mgmt.n_port_hdl = (uint16_t)LE_16(tq->loop_id);
	pkt->mgmt.delay = (uint16_t)LE_16(delay);
	pkt->mgmt.timeout = LE_16(MAILBOX_TOV);

	fcp_ent_addr = (fcp_ent_addr_t *)&lun_addr;
	pkt->mgmt.fcp_lun[2] = lobyte(fcp_ent_addr->ent_addr_0);
	pkt->mgmt.fcp_lun[3] = hibyte(fcp_ent_addr->ent_addr_0);
	pkt->mgmt.fcp_lun[0] = lobyte(fcp_ent_addr->ent_addr_1);
	pkt->mgmt.fcp_lun[1] = hibyte(fcp_ent_addr->ent_addr_1);
	pkt->mgmt.fcp_lun[6] = lobyte(fcp_ent_addr->ent_addr_2);
	pkt->mgmt.fcp_lun[7] = hibyte(fcp_ent_addr->ent_addr_2);
	pkt->mgmt.fcp_lun[4] = lobyte(fcp_ent_addr->ent_addr_3);
	pkt->mgmt.fcp_lun[5] = hibyte(fcp_ent_addr->ent_addr_3);

	pkt->mgmt.control_flags = LE_32(flags);
	pkt->mgmt.target_id[0] = tq->d_id.b.al_pa;
	pkt->mgmt.target_id[1] = tq->d_id.b.area;
	pkt->mgmt.target_id[2] = tq->d_id.b.domain;
	pkt->mgmt.vp_index = ha->vp_index;

	rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size);
	if (rval == QL_SUCCESS && (pkt->sts24.entry_status & 0x3c) != 0) {
		EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
		    pkt->sts24.entry_status, tq->d_id.b24);
		rval = QL_FUNCTION_PARAMETER_ERROR;
	}

	LITTLE_ENDIAN_16(&pkt->sts24.comp_status);

	if (rval == QL_SUCCESS && pkt->sts24.comp_status != CS_COMPLETE) {
		EL(ha, "failed, comp_status=%xh, d_id=%xh\n",
		    pkt->sts24.comp_status, tq->d_id.b24);
		rval = QL_FUNCTION_FAILED;
	}

	kmem_free(pkt, pkt_size);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_loop_port_bypass
 *	Issue loop port bypass mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_loop_port_bypass(ql_adapter_state_t *ha, ql_tgt_t *tq)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_LOOP_PORT_BYPASS;

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[1] = tq->d_id.b.al_pa;
	} else if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
		mcp->mb[1] = tq->loop_id;
	} else {
		mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
	}

	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_loop_port_enable
 *	Issue loop port enable mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_loop_port_enable(ql_adapter_state_t *ha, ql_tgt_t *tq)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_LOOP_PORT_ENABLE;

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[1] = tq->d_id.b.al_pa;
	} else if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
		mcp->mb[1] = tq->loop_id;
	} else {
		mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
	}
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_login_lport
 *	Issue login loop port mailbox command.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	tq:		target queue pointer.
 *	loop_id:	FC loop id.
 *	opt:		options.
 *			LLF_NONE, LLF_PLOGI
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_login_lport(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t loop_id,
    uint16_t opt)
{
	int		rval;
	uint16_t	flags;
	ql_mbx_data_t	mr;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started, d_id=%xh, loop_id=%xh\n",
	    ha->instance, tq->d_id.b24, loop_id);

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		flags = CF_CMD_PLOGI;
		if ((opt & LLF_PLOGI) == 0) {
			flags = (uint16_t)(flags | CFO_COND_PLOGI);
		}
		rval = ql_log_iocb(ha, tq, loop_id, flags, &mr);
	} else {
		mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = loop_id;
		} else {
			mcp->mb[1] = (uint16_t)(loop_id << 8);
		}
		mcp->mb[2] = opt;
		mcp->out_mb = MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "d_id=%xh, loop_id=%xh, failed=%xh\n", tq->d_id.b24,
		    loop_id, rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_login_fport
 *	Issue login fabric port mailbox command.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	tq:		target queue pointer.
 *	loop_id:	FC loop id.
 *	opt:		options.
 *			LFF_NONE, LFF_NO_PLOGI, LFF_NO_PRLI
 *	mr:		pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_login_fport(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t loop_id,
    uint16_t opt, ql_mbx_data_t *mr)
{
	int		rval;
	uint16_t	flags;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started, d_id=%xh, loop_id=%xh\n",
	    ha->instance, tq->d_id.b24, loop_id);

	if ((tq->d_id.b24 & QL_PORT_ID_MASK) == FS_MANAGEMENT_SERVER) {
		opt = (uint16_t)(opt | LFF_NO_PRLI);
	}

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		flags = CF_CMD_PLOGI;
		if (opt & LFF_NO_PLOGI) {
			flags = (uint16_t)(flags | CFO_COND_PLOGI);
		}
		if (opt & LFF_NO_PRLI) {
			flags = (uint16_t)(flags | CFO_SKIP_PRLI);
		}
		rval = ql_log_iocb(ha, tq, loop_id, flags, mr);
	} else {
		mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = loop_id;
			mcp->mb[10] = opt;
			mcp->out_mb = MBX_10|MBX_3|MBX_2|MBX_1|MBX_0;
		} else {
			mcp->mb[1] = (uint16_t)(loop_id << 8 | opt);
			mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
		}
		mcp->mb[2] = MSW(tq->d_id.b24);
		mcp->mb[3] = LSW(tq->d_id.b24);
		mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);

		/* Return mailbox data. */
		if (mr != NULL) {
			mr->mb[0] = mcp->mb[0];
			mr->mb[1] = mcp->mb[1];
			mr->mb[2] = mcp->mb[2];
			mr->mb[6] = mcp->mb[6];
			mr->mb[7] = mcp->mb[7];
		}
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "d_id=%xh, loop_id=%xh, failed=%xh, mb1=%02xh, "
		    "mb2=%04x\n", tq->d_id.b24, loop_id, rval,
		    mr != NULL ? mr->mb[1] : mcp->mb[1],
		    mr != NULL ? mr->mb[2] : mcp->mb[2]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_logout_fabric_port
 *	Issue logout fabric port mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_logout_fabric_port(ql_adapter_state_t *ha, ql_tgt_t *tq)
{
	int		rval;
	uint16_t	flag;
	ql_mbx_data_t	mr;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started, loop_id=%xh d_id=%xh\n",
	    tq->loop_id, tq->d_id.b24);

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		if ((ha->topology & QL_N_PORT) &&
		    (tq->loop_id != 0x7fe) &&
		    (tq->loop_id != 0x7ff)) {
			flag = (uint16_t)(CFO_IMPLICIT_LOGO |
			    CF_CMD_LOGO | CFO_FREE_N_PORT_HANDLE);

			rval = ql_log_iocb(ha, tq, tq->loop_id, flag, &mr);
		} else {
			flag = (uint16_t)(RESERVED_LOOP_ID(ha, tq->loop_id) ?
			    CFO_EXPLICIT_LOGO | CF_CMD_LOGO |
			    CFO_FREE_N_PORT_HANDLE :
			    CFO_IMPLICIT_LOGO | CF_CMD_LOGO |
			    CFO_FREE_N_PORT_HANDLE);

			rval = ql_log_iocb(ha, tq, tq->loop_id, flag, &mr);
		}

		if (rval == QL_SUCCESS) {
			EL(ha, "tq=%ph, loop_id=%xh, d_id=%xh, flag=%xh\n",
			    tq, tq->loop_id, tq->d_id.b24, flag);
		}
	} else {
		flag = (uint16_t)(RESERVED_LOOP_ID(ha, tq->loop_id) ? 1 : 0);
		mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
			mcp->mb[10] = flag;
			mcp->out_mb = MBX_10|MBX_1|MBX_0;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8 | flag);
			mcp->out_mb = MBX_1|MBX_0;
		}
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh, d_id=%xh, loop_id=%xh\n", rval,
		    tq->d_id.b24, tq->loop_id);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_log_iocb
 *	Function issues login/logout IOCB.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	tq:		target queue pointer.
 *	loop_id:	FC Loop ID.
 *	flags:		control flags.
 *	mr:		pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_log_iocb(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t loop_id,
    uint16_t flags, ql_mbx_data_t *mr)
{
	ql_mbx_iocb_t	*pkt;
	int		rval;
	uint32_t	pkt_size;

	QL_PRINT_3(ha, "started\n");

	pkt_size = sizeof (ql_mbx_iocb_t);
	pkt = kmem_zalloc(pkt_size, KM_SLEEP);
	if (pkt == NULL) {
		EL(ha, "failed, kmem_zalloc\n");
		return (QL_MEMORY_ALLOC_FAILED);
	}

	pkt->log.entry_type = LOG_TYPE;
	pkt->log.entry_count = 1;
	pkt->log.n_port_hdl = (uint16_t)LE_16(loop_id);
	pkt->log.control_flags = (uint16_t)LE_16(flags);
	pkt->log.port_id[0] = tq->d_id.b.al_pa;
	pkt->log.port_id[1] = tq->d_id.b.area;
	pkt->log.port_id[2] = tq->d_id.b.domain;
	pkt->log.vp_index = ha->vp_index;

	rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size);
	if (rval == QL_SUCCESS && (pkt->log.entry_status & 0x3c) != 0) {
		EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
		    pkt->log.entry_status, tq->d_id.b24);
		rval = QL_FUNCTION_PARAMETER_ERROR;
	}

	if (rval == QL_SUCCESS) {
		if (pkt->log.rsp_size == 0xB) {
			LITTLE_ENDIAN_32(&pkt->log.io_param[5]);
			tq->cmn_features = MSW(pkt->log.io_param[5]);
			LITTLE_ENDIAN_32(&pkt->log.io_param[6]);
			tq->conc_sequences = MSW(pkt->log.io_param[6]);
			tq->relative_offset = LSW(pkt->log.io_param[6]);
			LITTLE_ENDIAN_32(&pkt->log.io_param[9]);
			tq->class3_recipient_ctl = MSW(pkt->log.io_param[9]);
			tq->class3_conc_sequences = LSW(pkt->log.io_param[9]);
			LITTLE_ENDIAN_32(&pkt->log.io_param[10]);
			tq->class3_open_sequences_per_exch =
			    MSW(pkt->log.io_param[10]);
			tq->prli_payload_length = 0x14;
		}
		if (mr != NULL) {
			LITTLE_ENDIAN_16(&pkt->log.status);
			LITTLE_ENDIAN_32(&pkt->log.io_param[0]);
			LITTLE_ENDIAN_32(&pkt->log.io_param[1]);

			if (pkt->log.status != CS_COMPLETE) {
				EL(ha, "failed, status=%xh, iop0=%xh, iop1="
				    "%xh\n", pkt->log.status,
				    pkt->log.io_param[0],
				    pkt->log.io_param[1]);

				switch (pkt->log.io_param[0]) {
				case CS0_NO_LINK:
				case CS0_FIRMWARE_NOT_READY:
					mr->mb[0] = MBS_COMMAND_ERROR;
					mr->mb[1] = 1;
					break;
				case CS0_NO_IOCB:
				case CS0_NO_PCB_ALLOCATED:
					mr->mb[0] = MBS_COMMAND_ERROR;
					mr->mb[1] = 2;
					break;
				case CS0_NO_EXCH_CTRL_BLK:
					mr->mb[0] = MBS_COMMAND_ERROR;
					mr->mb[1] = 3;
					break;
				case CS0_COMMAND_FAILED:
					mr->mb[0] = MBS_COMMAND_ERROR;
					mr->mb[1] = 4;
					switch (LSB(pkt->log.io_param[1])) {
					case CS1_PLOGI_RESPONSE_FAILED:
						mr->mb[2] = 3;
						break;
					case CS1_PRLI_FAILED:
						mr->mb[2] = 4;
						break;
					case CS1_PRLI_RESPONSE_FAILED:
						mr->mb[2] = 5;
						break;
					case CS1_COMMAND_LOGGED_OUT:
						mr->mb[2] = 7;
						break;
					case CS1_PLOGI_FAILED:
					default:
						EL(ha, "log iop1 = %xh\n",
						    LSB(pkt->log.io_param[1]))
						mr->mb[2] = 2;
						break;
					}
					break;
				case CS0_PORT_NOT_LOGGED_IN:
					mr->mb[0] = MBS_COMMAND_ERROR;
					mr->mb[1] = 4;
					mr->mb[2] = 7;
					break;
				case CS0_NO_FLOGI_ACC:
				case CS0_NO_FABRIC_PRESENT:
					mr->mb[0] = MBS_COMMAND_ERROR;
					mr->mb[1] = 5;
					break;
				case CS0_ELS_REJECT_RECEIVED:
					mr->mb[0] = MBS_COMMAND_ERROR;
					mr->mb[1] = 0xd;
					break;
				case CS0_PORT_ID_USED:
					mr->mb[0] = MBS_PORT_ID_USED;
					mr->mb[1] = LSW(pkt->log.io_param[1]);
					break;
				case CS0_N_PORT_HANDLE_USED:
					mr->mb[0] = MBS_LOOP_ID_USED;
					mr->mb[1] = MSW(pkt->log.io_param[1]);
					mr->mb[2] = LSW(pkt->log.io_param[1]);
					break;
				case CS0_NO_N_PORT_HANDLE_AVAILABLE:
					mr->mb[0] = MBS_ALL_IDS_IN_USE;
					break;
				case CS0_CMD_PARAMETER_ERROR:
				default:
					EL(ha, "pkt->log iop[0]=%xh\n",
					    pkt->log.io_param[0]);
					mr->mb[0] =
					    MBS_COMMAND_PARAMETER_ERROR;
					break;
				}
			} else {
				QL_PRINT_3(ha, "status=%xh\n", pkt->log.status);

				mr->mb[0] = MBS_COMMAND_COMPLETE;
				mr->mb[1] = (uint16_t)
				    (pkt->log.io_param[0] & BIT_4 ? 0 : BIT_0);
				if (pkt->log.io_param[0] & BIT_8) {
					mr->mb[1] = (uint16_t)
					    (mr->mb[1] | BIT_1);
				}
			}
			rval = mr->mb[0];
		}

	}

	kmem_free(pkt, pkt_size);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh, d_id=%xh loop_id=%xh\n",
		    rval, tq->d_id.b24, loop_id);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_port_database
 *	Issue get port database mailbox command
 *	and copy context to device queue.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	tq:	target queue pointer.
 *	opt:	options.
 *		PDF_NONE, PDF_PLOGI, PDF_ADISC
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_port_database(ql_adapter_state_t *ha, ql_tgt_t *tq, uint8_t opt)
{
	int			rval;
	dma_mem_t		mem_desc;
	mbx_cmd_t		mc = {0};
	mbx_cmd_t		*mcp = &mc;
	port_database_23_t	*pd23;

	QL_PRINT_3(ha, "started\n");

	pd23 = (port_database_23_t *)kmem_zalloc(PORT_DATABASE_SIZE, KM_SLEEP);
	if (pd23 == NULL) {
		rval = QL_MEMORY_ALLOC_FAILED;
		EL(ha, "failed, rval = %xh\n", rval);
		return (rval);
	}

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    PORT_DATABASE_SIZE)) != QL_SUCCESS) {
		return (QL_MEMORY_ALLOC_FAILED);
	}

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[0] = MBC_GET_PORT_DATABASE;
		mcp->mb[1] = tq->loop_id;
		mcp->mb[4] = CHAR_TO_SHORT(tq->d_id.b.al_pa, tq->d_id.b.area);
		mcp->mb[5] = (uint16_t)tq->d_id.b.domain;
		mcp->mb[9] = ha->vp_index;
		mcp->mb[10] = (uint16_t)(opt | PDF_ADISC);
		mcp->out_mb = MBX_10|MBX_9|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|
		    MBX_2|MBX_1|MBX_0;
	} else {
		mcp->mb[0] = (uint16_t)(opt == PDF_NONE ?
		    MBC_GET_PORT_DATABASE : MBC_ENHANCED_GET_PORT_DATABASE);
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
			mcp->mb[10] = opt;
			mcp->out_mb = MBX_10|MBX_7|MBX_6|MBX_3|
			    MBX_2|MBX_1|MBX_0;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8 | opt);
			mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
		}
	}

	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, (caddr_t)pd23);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval == QL_SUCCESS) {
		if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
			port_database_24_t *pd24 = (port_database_24_t *)pd23;

			tq->master_state = pd24->current_login_state;
			tq->slave_state = pd24->last_stable_login_state;
			if (PD_PORT_LOGIN(tq)) {
				/* Names are big endian. */
				bcopy((void *)&pd24->port_name[0],
				    (void *)&tq->port_name[0], 8);
				bcopy((void *)&pd24->node_name[0],
				    (void *)&tq->node_name[0], 8);
				tq->hard_addr.b.al_pa = pd24->hard_address[2];
				tq->hard_addr.b.area = pd24->hard_address[1];
				tq->hard_addr.b.domain = pd24->hard_address[0];
				tq->class3_rcv_data_size =
				    pd24->receive_data_size;
				LITTLE_ENDIAN_16(&tq->class3_rcv_data_size);
				tq->prli_svc_param_word_0 =
				    pd24->PRLI_service_parameter_word_0;
				LITTLE_ENDIAN_16(&tq->prli_svc_param_word_0);
				tq->prli_svc_param_word_3 =
				    pd24->PRLI_service_parameter_word_3;
				LITTLE_ENDIAN_16(&tq->prli_svc_param_word_3);
			}
		} else {
			tq->master_state = pd23->master_state;
			tq->slave_state = pd23->slave_state;
			if (PD_PORT_LOGIN(tq)) {
				/* Names are big endian. */
				bcopy((void *)&pd23->port_name[0],
				    (void *)&tq->port_name[0], 8);
				bcopy((void *)&pd23->node_name[0],
				    (void *)&tq->node_name[0], 8);
				tq->hard_addr.b.al_pa = pd23->hard_address[2];
				tq->hard_addr.b.area = pd23->hard_address[1];
				tq->hard_addr.b.domain = pd23->hard_address[0];
				tq->cmn_features = pd23->common_features;
				LITTLE_ENDIAN_16(&tq->cmn_features);
				tq->conc_sequences =
				    pd23->total_concurrent_sequences;
				LITTLE_ENDIAN_16(&tq->conc_sequences);
				tq->relative_offset =
				    pd23->RO_by_information_category;
				LITTLE_ENDIAN_16(&tq->relative_offset);
				tq->class3_recipient_ctl = pd23->recipient;
				LITTLE_ENDIAN_16(&tq->class3_recipient_ctl);
				tq->class3_rcv_data_size =
				    pd23->receive_data_size;
				LITTLE_ENDIAN_16(&tq->class3_rcv_data_size);
				tq->class3_conc_sequences =
				    pd23->concurrent_sequences;
				LITTLE_ENDIAN_16(&tq->class3_conc_sequences);
				tq->class3_open_sequences_per_exch =
				    pd23->open_sequences_per_exchange;
				LITTLE_ENDIAN_16(
				    &tq->class3_open_sequences_per_exch);
				tq->prli_payload_length =
				    pd23->PRLI_payload_length;
				LITTLE_ENDIAN_16(&tq->prli_payload_length);
				tq->prli_svc_param_word_0 =
				    pd23->PRLI_service_parameter_word_0;
				LITTLE_ENDIAN_16(&tq->prli_svc_param_word_0);
				tq->prli_svc_param_word_3 =
				    pd23->PRLI_service_parameter_word_3;
				LITTLE_ENDIAN_16(&tq->prli_svc_param_word_3);
			}
		}

		if (!PD_PORT_LOGIN(tq)) {
			EL(ha, "d_id=%xh, loop_id=%xh, not logged in "
			    "master=%xh, slave=%xh\n", tq->d_id.b24,
			    tq->loop_id, tq->master_state, tq->slave_state);
			rval = QL_NOT_LOGGED_IN;
		} else {
			tq->flags = tq->prli_svc_param_word_3 &
			    PRLI_W3_TARGET_FUNCTION ?
			    tq->flags & ~TQF_INITIATOR_DEVICE :
			    tq->flags | TQF_INITIATOR_DEVICE;

			if ((tq->flags & TQF_INITIATOR_DEVICE) == 0) {
				tq->flags = tq->prli_svc_param_word_3 &
				    PRLI_W3_RETRY ?
				    tq->flags | TQF_TAPE_DEVICE :
				    tq->flags & ~TQF_TAPE_DEVICE;
			} else {
				tq->flags &= ~TQF_TAPE_DEVICE;
			}
		}
	}

	kmem_free(pd23, PORT_DATABASE_SIZE);

	/*
	 * log the trace in any cases other than QL_SUCCESS.
	 */
	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh, d_id=%xh, loop_id=%xh\n",
		    rval, tq->d_id.b24, tq->loop_id);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_loop_position_map
 *	Issue get loop position map mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	size:	size of data buffer.
 *	bufp:	data pointer for DMA data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_loop_position_map(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    (uint32_t)size)) != QL_SUCCESS) {
		EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
		return (QL_MEMORY_ALLOC_FAILED);
	}

	mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bufp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_set_rnid_params
 *	Issue set RNID parameters mailbox command.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	size:		size of data buffer.
 *	bufp:		data pointer for DMA data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_set_rnid_params(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bufp,
	    (uint32_t)size)) != QL_SUCCESS) {
		EL(ha, "failed, setup_mbox_dma_transfer: %x\n", rval);
		return (rval);
	}

	mcp->mb[0] = MBC_SET_PARAMETERS;
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_send_rnid_els
 *	Issue a send node identfication data mailbox command.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	loop_id:	FC loop id.
 *	opt:		options.
 *	size:		size of data buffer.
 *	bufp:		data pointer for DMA data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_send_rnid_els(ql_adapter_state_t *ha, uint16_t loop_id, uint8_t opt,
    size_t size, caddr_t bufp)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    (uint32_t)size)) != QL_SUCCESS) {
		return (QL_MEMORY_ALLOC_FAILED);
	}

	mcp->mb[0] = MBC_SEND_RNID_ELS;
	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[1] = loop_id;
		mcp->mb[9] = ha->vp_index;
		mcp->mb[10] = opt;
		mcp->out_mb = MBX_10|MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	} else if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
		mcp->mb[1] = loop_id;
		mcp->mb[10] = opt;
		mcp->out_mb = MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	} else {
		mcp->mb[1] = (uint16_t)(loop_id << 8 | opt);
		mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	}
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bufp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_rnid_params
 *	Issue get RNID parameters mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	size:	size of data buffer.
 *	bufp:	data pointer for DMA data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_rnid_params(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    (uint32_t)size)) != QL_SUCCESS) {
		return (QL_MEMORY_ALLOC_FAILED);
	}

	mcp->mb[0] = MBC_GET_PARAMETERS;
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bufp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_link_status
 *	Issue get link status mailbox command.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	loop_id:	FC loop id or n_port_hdl.
 *	size:		size of data buffer.
 *	bufp:		data pointer for DMA data.
 *	port_no:	port number to query.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_link_status(ql_adapter_state_t *ha, uint16_t loop_id, size_t size,
    caddr_t bufp, uint8_t port_no)
{
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;
	int		rval = QL_SUCCESS;
	int		retry = 0;

	QL_PRINT_3(ha, "started\n");

	do {
		if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
		    (uint32_t)size)) != QL_SUCCESS) {
			EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
			return (QL_MEMORY_ALLOC_FAILED);
		}

		mcp->mb[0] = MBC_GET_LINK_STATUS;
		if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
			if (loop_id == ha->loop_id) {
				mcp->mb[0] = MBC_GET_STATUS_COUNTS;
				mcp->mb[8] = (uint16_t)(size >> 2);
				mcp->out_mb = MBX_10|MBX_8;
			} else {
				mcp->mb[1] = loop_id;
				mcp->mb[4] = port_no;
				mcp->mb[10] = (uint16_t)(retry ? BIT_3 : 0);
				mcp->out_mb = MBX_10|MBX_4;
			}
		} else {
			if (retry) {
				port_no = (uint8_t)(port_no | BIT_3);
			}
			if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
				mcp->mb[1] = loop_id;
				mcp->mb[10] = port_no;
				mcp->out_mb = MBX_10;
			} else {
				mcp->mb[1] = (uint16_t)((loop_id << 8) |
				    port_no);
				mcp->out_mb = 0;
			}
		}
		mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
		mcp->in_mb = MBX_1|MBX_0;
		mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
		mcp->timeout = MAILBOX_TOV;

		rval = ql_mailbox_command(ha, mcp);

		if (rval == QL_SUCCESS) {
			ql_get_mbox_dma_data(&mem_desc, bufp);
		}

		ql_free_dma_resource(ha, &mem_desc);

		if (rval != QL_SUCCESS) {
			EL(ha, "failed=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
		}

		/*
		 * Some of the devices want d_id in the payload,
		 * strictly as per standard. Let's retry.
		 */

	} while (rval == QL_COMMAND_ERROR && !retry++);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_status_counts
 *	Issue get adapter link status counts mailbox command.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	loop_id:	FC loop id or n_port_hdl.
 *	size:		size of data buffer.
 *	bufp:		data pointer for DMA data.
 *	port_no:	port number to query.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_status_counts(ql_adapter_state_t *ha, uint16_t loop_id, size_t size,
    caddr_t bufp, uint8_t port_no)
{
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;
	int		rval = QL_SUCCESS;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    (uint32_t)size)) != QL_SUCCESS) {
		EL(ha, "setup_mbox_dma_resources failed: %x\n", rval);
		return (QL_MEMORY_ALLOC_FAILED);
	}

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[0] = MBC_GET_STATUS_COUNTS;
		mcp->mb[8] = (uint16_t)(size / 4);
		mcp->out_mb = MBX_10|MBX_8;
	} else {
		mcp->mb[0] = MBC_GET_LINK_STATUS;

		/* allows reporting when link is down */
		if (CFG_IST(ha, CFG_CTRL_22XX) == 0) {
			port_no = (uint8_t)(port_no | BIT_6);
		}

		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = loop_id;
			mcp->mb[10] = port_no;
			mcp->out_mb = MBX_10|MBX_1;
		} else {
			mcp->mb[1] = (uint16_t)((loop_id << 8) |
			    port_no);
			mcp->out_mb = MBX_1;
		}
	}
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bufp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mbx1=%xh, mbx2=%xh\n", rval,
		    mcp->mb[1], mcp->mb[2]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_reset_link_status
 *	Issue Reset Link Error Status mailbox command
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_reset_link_status(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_RESET_LINK_STATUS;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_loop_reset
 *	Issue loop reset.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_loop_reset(ql_adapter_state_t *ha)
{
	int	rval;

	QL_PRINT_3(ha, "started\n");

	if (CFG_IST(ha, CFG_ENABLE_LIP_RESET)) {
		rval = ql_lip_reset(ha, 0xff);
	} else if (CFG_IST(ha, CFG_ENABLE_FULL_LIP_LOGIN)) {
		rval = ql_full_login_lip(ha);
	} else if (CFG_IST(ha, CFG_ENABLE_TARGET_RESET)) {
		rval = ql_target_reset(ha, NULL, ha->loop_reset_delay);
	} else {
		rval = ql_initiate_lip(ha);
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_initiate_lip
 *	Initiate LIP mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_initiate_lip(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
		ql_toggle_loop_state(ha);
		QL_PRINT_3(ha, "8081 done\n");
		return (QL_SUCCESS);
	}
	if (CFG_IST(ha, CFG_FC_TYPE_2)) {
		mcp->mb[0] = MBC_LIP_FULL_LOGIN;
		mcp->mb[1] = BIT_4;
		mcp->mb[3] = ha->loop_reset_delay;
		mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
	} else {
		mcp->mb[0] = MBC_INITIATE_LIP;
		mcp->out_mb = MBX_0;
	}
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_full_login_lip
 *	Issue full login LIP mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_full_login_lip(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
		ql_toggle_loop_state(ha);
		QL_PRINT_3(ha, "8081 done\n");
		return (QL_SUCCESS);
	}
	mcp->mb[0] = MBC_LIP_FULL_LOGIN;
	if (CFG_IST(ha, CFG_FC_TYPE_2)) {
		mcp->mb[1] = BIT_3;
	}
	mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done");
	}

	return (rval);
}

/*
 * ql_lip_reset
 *	Issue lip reset to a port.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	loop_id:	FC loop id.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_lip_reset(ql_adapter_state_t *ha, uint16_t loop_id)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
		ql_toggle_loop_state(ha);
		QL_PRINT_3(ha, "8081 done\n");
		return (QL_SUCCESS);
	}

	if (CFG_IST(ha, CFG_FC_TYPE_2)) {
		mcp->mb[0] = MBC_LIP_FULL_LOGIN;
		mcp->mb[1] = BIT_6;
		mcp->mb[3] = ha->loop_reset_delay;
		mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
	} else {
		mcp->mb[0] = MBC_LIP_RESET;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = loop_id;
			mcp->out_mb = MBX_10|MBX_3|MBX_2|MBX_1|MBX_0;
		} else {
			mcp->mb[1] = (uint16_t)(loop_id << 8);
			mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
		}
		mcp->mb[2] = ha->loop_reset_delay;
	}
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_abort_command
 *	Abort command aborts a specified IOCB.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	sp:	SRB structure pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_abort_command(ql_adapter_state_t *ha, ql_srb_t *sp)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;
	ql_tgt_t	*tq = sp->lun_queue->target_queue;

	QL_PRINT_3(ha, "started\n");

	sp->flags |= SRB_ABORTING;
	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		rval = ql_abort_cmd_iocb(ha, sp);
	} else {
		mcp->mb[0] = MBC_ABORT_COMMAND_IOCB;
		if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
			mcp->mb[1] = tq->loop_id;
		} else {
			mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
		}
		mcp->mb[2] = LSW(sp->handle);
		mcp->mb[3] = MSW(sp->handle);
		mcp->mb[6] = (uint16_t)(sp->flags & SRB_FCP_CMD_PKT ?
		    sp->lun_queue->lun_no : 0);
		mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh, handle=%xh\n", rval,
		    tq->d_id.b24, sp->handle);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_abort_cmd_iocb
 *	Function issues abort command IOCB.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	sp:	SRB structure pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Interrupt or Kernel context, no mailbox commands allowed.
 */
static int
ql_abort_cmd_iocb(ql_adapter_state_t *ha, ql_srb_t *sp)
{
	ql_mbx_iocb_t	*pkt;
	int		rval;
	uint32_t	pkt_size;
	uint16_t	comp_status;
	ql_tgt_t	*tq = sp->lun_queue->target_queue;

	QL_PRINT_3(ha, "started\n");

	pkt_size = sizeof (ql_mbx_iocb_t);
	if ((pkt = kmem_zalloc(pkt_size, KM_SLEEP)) == NULL) {
		EL(ha, "failed, kmem_zalloc\n");
		return (QL_MEMORY_ALLOC_FAILED);
	}

	pkt->abo.entry_type = ABORT_CMD_TYPE;
	pkt->abo.entry_count = 1;
	pkt->abo.n_port_hdl = (uint16_t)LE_16(tq->loop_id);
	if (!CFG_IST(ha, CFG_CTRL_82XX)) {
		pkt->abo.options = AF_NO_ABTS;
	}
	pkt->abo.cmd_handle = LE_32(sp->handle);
	pkt->abo.target_id[0] = tq->d_id.b.al_pa;
	pkt->abo.target_id[1] = tq->d_id.b.area;
	pkt->abo.target_id[2] = tq->d_id.b.domain;
	pkt->abo.vp_index = ha->vp_index;

	rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size);

	if (rval == QL_SUCCESS) {
		if ((pkt->abo.entry_status & 0x3c) != 0) {
			EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
			    pkt->abo.entry_status, tq->d_id.b24);
			rval = QL_FUNCTION_PARAMETER_ERROR;
		} else {
			comp_status = (uint16_t)LE_16(pkt->abo.n_port_hdl);
			if (comp_status != CS_COMPLETE) {
				EL(ha, "failed, comp_status=%xh, d_id=%xh\n",
				    comp_status, tq->d_id.b24);
				rval = QL_FUNCTION_FAILED;
			}
		}
	}

	kmem_free(pkt, pkt_size);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_verify_checksum
 *	Verify loaded RISC firmware.
 *
 * Input:
 *	ha = adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_verify_checksum(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_VERIFY_CHECKSUM;
	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[1] = MSW(ha->risc_fw[0].addr);
		mcp->mb[2] = LSW(ha->risc_fw[0].addr);
	} else {
		mcp->mb[1] = LSW(ha->risc_fw[0].addr);
	}
	mcp->out_mb = MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_id_list
 *	Get d_id and loop ID list.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	bp:	data pointer for DMA data.
 *	size:	size of data buffer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_id_list(ql_adapter_state_t *ha, caddr_t bp, uint32_t size,
    ql_mbx_data_t *mr)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    (uint32_t)size)) != QL_SUCCESS) {
		EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
		return (QL_MEMORY_ALLOC_FAILED);
	}

	mcp->mb[0] = MBC_GET_ID_LIST;
	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[8] = (uint16_t)size;
		mcp->mb[9] = ha->vp_index;
		mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	} else {
		mcp->mb[1] = MSW(LSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[2] = LSW(LSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[3] = MSW(MSD(mem_desc.cookie.dmac_laddress));
		mcp->mb[6] = LSW(MSD(mem_desc.cookie.dmac_laddress));
		mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	}
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
		mr->mb[1] = mcp->mb[1];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_wrt_risc_ram
 *	Load RISC RAM.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	risc_address:	risc ram word address.
 *	bp:		DMA pointer.
 *	word_count:	16/32bit word count.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_wrt_risc_ram(ql_adapter_state_t *ha, uint32_t risc_address, uint64_t bp,
    uint32_t word_count)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[1] = LSW(risc_address);
	mcp->mb[2] = MSW(LSD(bp));
	mcp->mb[3] = LSW(LSD(bp));
	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[0] = MBC_LOAD_RAM_EXTENDED;
		mcp->mb[4] = MSW(word_count);
		mcp->mb[5] = LSW(word_count);
		mcp->mb[8] = MSW(risc_address);
		mcp->out_mb = MBX_0_THRU_8;
	} else {
		mcp->mb[0] = MBC_LOAD_RISC_RAM;
		mcp->mb[4] = LSW(word_count);
		mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	}
	mcp->mb[6] = MSW(MSD(bp));
	mcp->mb[7] = LSW(MSD(bp));
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_rd_risc_ram
 *	Get RISC RAM.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	risc_address:	risc ram word address.
 *	bp:		direct data pointer.
 *	word_count:	16/32bit word count.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_rd_risc_ram(ql_adapter_state_t *ha, uint32_t risc_address, uint64_t bp,
    uint32_t word_count)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[0] = MBC_DUMP_RAM_EXTENDED;
		mcp->mb[1] = LSW(risc_address);
		mcp->mb[2] = MSW(LSD(bp));
		mcp->mb[3] = LSW(LSD(bp));
		mcp->mb[4] = MSW(word_count);
		mcp->mb[5] = LSW(word_count);
		mcp->mb[6] = MSW(MSD(bp));
		mcp->mb[7] = LSW(MSD(bp));
		mcp->mb[8] = MSW(risc_address);
		mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|
		    MBX_0;
	} else {
		mcp->mb[0] = MBC_DUMP_RAM;	/* doesn't support 64bit addr */
		mcp->mb[1] = LSW(risc_address);
		mcp->mb[2] = MSW(LSD(bp));
		mcp->mb[3] = LSW(LSD(bp));
		mcp->mb[4] = LSW(word_count);
		mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	}
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_wrt_risc_ram_word
 *	Write RISC RAM word.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	risc_address:	risc ram word address.
 *	data:		data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_wrt_risc_ram_word(ql_adapter_state_t *ha, uint32_t risc_address,
    uint32_t data)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_WRITE_RAM_EXTENDED;
	mcp->mb[1] = LSW(risc_address);
	mcp->mb[2] = LSW(data);
	mcp->mb[3] = MSW(data);
	mcp->mb[8] = MSW(risc_address);
	mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;

	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_rd_risc_ram_word
 *	Read RISC RAM word.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	risc_address:	risc ram word address.
 *	data:		data pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_rd_risc_ram_word(ql_adapter_state_t *ha, uint32_t risc_address,
    uint32_t *data)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_READ_RAM_EXTENDED;
	mcp->mb[1] = LSW(risc_address);
	mcp->mb[8] = MSW(risc_address);
	mcp->out_mb = MBX_8|MBX_1|MBX_0;
	mcp->in_mb = MBX_3|MBX_2|MBX_0;
	mcp->timeout = MAILBOX_TOV;

	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval = %xh\n", rval);
	} else {
		*data = mcp->mb[2];
		if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
			*data |= mcp->mb[3] << 16;
		}
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_issue_mbx_iocb
 *	Issue IOCB using mailbox command
 *
 * Input:
 *	ha:	adapter state pointer.
 *	bp:	buffer pointer.
 *	size:	buffer size.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_issue_mbx_iocb(ql_adapter_state_t *ha, caddr_t bp, uint32_t size)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bp, size)) !=
	    QL_SUCCESS) {
		EL(ha, "setup_mbox_dma_transfer failed: %x\n", rval);
		return (rval);
	}

	mcp->mb[0] = MBC_EXECUTE_IOCB;
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV + 5;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_mbx_wrap_test
 *	Mailbox register wrap test.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for in/out mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_mbx_wrap_test(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started cfg=0x%llx\n", ha->cfg_flags);

	mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
	if (mr == NULL) {
		mcp->mb[1] = 0xAAAA;
		mcp->mb[2] = 0x5555;
		mcp->mb[3] = 0xAA55;
		mcp->mb[4] = 0x55AA;
		mcp->mb[5] = 0xA5A5;
		mcp->mb[6] = 0x5A5A;
		mcp->mb[7] = 0x2525;
	} else {
		mcp->mb[1] = mr->mb[1];
		mcp->mb[2] = mr->mb[2];
		mcp->mb[3] = mr->mb[3];
		mcp->mb[4] = mr->mb[4];
		mcp->mb[5] = mr->mb[5];
		mcp->mb[6] = mr->mb[6];
		mcp->mb[7] = mr->mb[7];
	}
	mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);
	if (rval == QL_SUCCESS) {
		if (mr == NULL) {
			if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
			    mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA) {
				rval = QL_FUNCTION_FAILED;
			}
			if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
			    mcp->mb[7] != 0x2525) {
				rval = QL_FUNCTION_FAILED;
			}
		} else {
			if (mcp->mb[1] != mr->mb[1] ||
			    mcp->mb[2] != mr->mb[2] ||
			    mcp->mb[3] != mr->mb[3] ||
			    mcp->mb[4] != mr->mb[4]) {
				rval = QL_FUNCTION_FAILED;
			}
			if (mcp->mb[5] != mr->mb[5] ||
			    mcp->mb[6] != mr->mb[6] ||
			    mcp->mb[7] != mr->mb[7]) {
				rval = QL_FUNCTION_FAILED;
			}
		}
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_execute_fw
 *	Start adapter firmware.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_execute_fw(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (CFG_IST(ha, CFG_CTRL_82XX)) {
		return (QL_SUCCESS);
	}

	mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
	if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		mcp->mb[1] = MSW(ha->risc_fw[0].addr);
		mcp->mb[2] = LSW(ha->risc_fw[0].addr);
	} else {
		mcp->mb[1] = LSW(ha->risc_fw[0].addr);
	}
	if (CFG_IST(ha, CFG_LR_SUPPORT)) {
		mcp->mb[4] = BIT_0;
	}
	mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (CFG_IST(ha, CFG_CTRL_22XX)) {
		rval = QL_SUCCESS;
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_firmware_option
 *	 Get Firmware Options Mailbox Command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_firmware_option(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_FIRMWARE_OPTIONS;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_9(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_set_firmware_option
 *	 Set Firmware Options Mailbox Command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_set_firmware_option(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (mr != NULL) {
		mcp->mb[0] = MBC_SET_FIRMWARE_OPTIONS;
		mcp->mb[1] = mr->mb[1];
		mcp->mb[2] = mr->mb[2];
		mcp->mb[3] = mr->mb[3];
		mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);
	} else {
		rval = QL_FUNCTION_PARAMETER_ERROR;
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_init_firmware
 *	 Initialize firmware mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	ha->init_ctrl_blk = setup for transmit.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_init_firmware(ql_adapter_state_t *ha)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (ha->flags & MULTI_QUEUE) {
		WR32_MBAR_REG(ha, ha->req_q[0]->mbar_req_in, 0);
		WR32_MBAR_REG(ha, ha->rsp_queues[0]->mbar_rsp_out, 0);
	} else if (CFG_IST(ha, CFG_CTRL_82XX)) {
		ql_8021_wr_req_in(ha, 0);
		WRT32_IO_REG(ha, req_out, 0);
		WRT32_IO_REG(ha, resp_in, 0);
		WRT32_IO_REG(ha, resp_out, 0);
	} else if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
		WRT32_IO_REG(ha, req_in, 0);
		WRT32_IO_REG(ha, resp_out, 0);
		WRT32_IO_REG(ha, pri_req_in, 0);
		WRT32_IO_REG(ha, atio_req_out, 0);
	} else {
		WRT16_IO_REG(ha, req_in, 0);
		WRT16_IO_REG(ha, resp_out, 0);
	}
	if (ha->req_q[0]->req_out_shadow_ptr) {
		*ha->req_q[0]->req_out_shadow_ptr = 0;
	}
	if (ha->rsp_queues[0]->rsp_in_shadow_ptr) {
		*ha->rsp_queues[0]->rsp_in_shadow_ptr = 0;
	}

	if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc,
	    (caddr_t)&ha->init_ctrl_blk, sizeof (ql_comb_init_cb_t))) !=
	    QL_SUCCESS) {
		EL(ha, "dma setup failed=%xh\n", rval);
		return (rval);
	}

	mcp->mb[0] = (uint16_t)(ha->flags & VP_ENABLED ?
	    MBC_INITIALIZE_MULTI_ID_FW : MBC_INITIALIZE_FIRMWARE);

	if (CFG_IST(ha, CFG_SBUS_CARD)) {
		mcp->mb[1] = (uint16_t)(CFG_IST(ha, CFG_CTRL_22XX) ?
		    0x204c : 0x52);
	}

	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
		uint64_t		ofst, addr;
		ql_init_24xx_cb_t	*icb = (ql_init_24xx_cb_t *)
		    &ha->init_ctrl_blk.cb24;

		mcp->mb[0] = MBC_INITIALIZE_MULTI_ID_FW;
		if (icb->ext_blk.version[0] | icb->ext_blk.version[1]) {
			ofst = (uintptr_t)&icb->ext_blk - (uintptr_t)icb;
			addr = mem_desc.cookie.dmac_laddress + ofst;
			mcp->mb[10] = MSW(LSD(addr));
			mcp->mb[11] = LSW(LSD(addr));
			mcp->mb[12] = MSW(MSD(addr));
			mcp->mb[13] = LSW(MSD(addr));
			mcp->mb[14] = sizeof (ql_ext_icb_8100_t);
			mcp->mb[1] = BIT_0;
		}
		mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|
		    MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	} else {
		mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	}
	mcp->in_mb = MBX_5|MBX_4|MBX_2|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ha->sfp_stat = mcp->mb[2];
		if (CFG_IST(ha, CFG_CTRL_82XX)) {
			(void) ql_8021_get_md_template(ha);
		} else {
			uint16_t	i, opt;

			opt = ha->flags & NO_INTR_HANDSHAKE ?
			    IMO_NONE : IMO_INTERRUPT_HANDSHAKE;
			if (ha->flags & QUEUE_SHADOW_PTRS) {
				opt |= IMO_QUEUE_POINTER_SHADOWING;
			}
			/* Initialize ha multi-response-queue request queue */
			if (ha->rsp_queues_cnt > 1) {
				rval = ql_init_req_q(ha, ha->req_q[1], opt);
				if (rval != QL_SUCCESS) {
					EL(ha, "ql_init_req_q=%xh\n", rval);
					return (rval);
				}
			}
			/* Initialize multi-response queues */
			for (i = 1; i < ha->rsp_queues_cnt; i++) {
				rval = ql_init_rsp_q(ha, ha->rsp_queues[i],
				    opt);
				if (rval != QL_SUCCESS) {
					EL(ha, "ql_init_rsp_q=%xh\n", rval);
					return (rval);
				}
			}
		}
	}
	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_firmware_state
 *	Get adapter firmware state.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_firmware_state(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0_THRU_6;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	ha->fw_state[0] = mcp->mb[0];
	ha->fw_state[1] = mcp->mb[1];
	ha->fw_state[2] = mcp->mb[2];
	ha->fw_state[3] = mcp->mb[3];
	ha->fw_state[4] = mcp->mb[4];
	ha->fw_state[5] = mcp->mb[5];
	ha->fw_state[6] = mcp->mb[6];

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
		mr->mb[4] = mcp->mb[4];
		mr->mb[5] = mcp->mb[5];
		mr->mb[6] = mcp->mb[6];
	}

	ha->sfp_stat = mcp->mb[2];

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_adapter_id
 *	Get adapter ID and topology.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_adapter_id(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		i, rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_ID;
	if (ha->flags & VP_ENABLED) {
		mcp->mb[9] = ha->vp_index;
	}
	mcp->out_mb = MBX_9|MBX_0;
	mcp->in_mb = MBX_0_THRU_19;
	mcp->timeout = MAILBOX_TOV;

	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (mr != NULL) {
		for (i = 0; i < 20; i++) {
			mr->mb[i] = mcp->mb[i];
		}
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_fw_version
 *	Get firmware version.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_fw_version(ql_adapter_state_t *ha, ql_mbx_data_t *mr, uint16_t timeout)
{
	int		rval, i;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_ABOUT_FIRMWARE;
	mcp->out_mb = MBX_0;
	if (CFG_IST(ha, CFG_CTRL_83XX)) {
		mcp->in_mb = MBX_0_THRU_17;
	} else if (CFG_IST(ha, CFG_CTRL_27XX)) {
		mcp->in_mb = MBX_0_THRU_25;
	} else {
		mcp->in_mb = MBX_0_THRU_13;
	}
	mcp->timeout = timeout;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (mr != NULL) {
		for (i = 0; i < ha->reg_off->mbox_cnt && mcp->in_mb; i++) {
			if (mcp->in_mb & MBX_0) {
				mr->mb[i] = mcp->mb[i];
			}
			mcp->in_mb >>= 1;
		}
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_data_rate
 *	 Issue data rate Mailbox Command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_data_rate(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if (mr != NULL) {
		mcp->mb[0] = MBC_DATA_RATE;
		mcp->mb[1] = mr->mb[1];
		mcp->mb[2] = mr->mb[2];
		mcp->out_mb = MBX_2|MBX_1|MBX_0;
		mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
		mcp->timeout = MAILBOX_TOV;
		rval = ql_mailbox_command(ha, mcp);

		/* Return mailbox data. */
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
	} else {
		rval = QL_FUNCTION_PARAMETER_ERROR;
	}

	ha->sfp_stat = mcp->mb[2];

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_Diag_Loopback
 *	Issue Reset Link Status mailbox command
 *
 * Input:
 *	ha:	adapter state pointer.
 *	bp:	buffer pointer.
 *	size:	buffer size.
 *	opt:	command options.
 *	it_cnt:	iteration count.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_diag_loopback(ql_adapter_state_t *ha, caddr_t bp, uint32_t size,
    uint16_t opt, uint32_t it_cnt, ql_mbx_data_t *mr)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bp, size)) !=
	    QL_SUCCESS) {
		EL(ha, "setup_mbox_dma_transfer failed: %x\n", rval);
		return (rval);
	}

	mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
	mcp->mb[1] = opt;
	mcp->mb[2] = ha->fcoe_fcf_idx;
	mcp->mb[6] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[10] = LSW(size);
	mcp->mb[11] = MSW(size);
	mcp->mb[14] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[15] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[16] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[17] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[18] = LSW(it_cnt);
	mcp->mb[19] = MSW(it_cnt);
	mcp->mb[20] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[21] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
	    MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = it_cnt / 300;
	if (mcp->timeout < MAILBOX_TOV) {
		mcp->timeout = MAILBOX_TOV;
	}
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
		mr->mb[18] = mcp->mb[18];
		mr->mb[19] = mcp->mb[19];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mb1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_diag_echo
 *	Issue Diag echo mailbox command.  Valid for qla23xx HBA's.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	bp:	buffer pointer.
 *	size:	buffer size.
 *	opt:	command options.
 *	mr:	pointer to mailbox status.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_diag_echo(ql_adapter_state_t *ha, caddr_t bp, uint32_t size, uint16_t opt,
    ql_mbx_data_t *mr)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bp, size)) !=
	    QL_SUCCESS) {
		EL(ha, "setup_mbox_dma_transfer failed: %x\n", rval);
		return (rval);
	}

	mcp->mb[0] = MBC_ECHO;
	mcp->mb[1] = opt;
	mcp->mb[2] = ha->fcoe_fcf_idx;
	mcp->mb[6] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[10] = LSW(size);
	mcp->mb[14] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[15] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[16] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[17] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[20] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[21] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
	    MBX_14|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mb1=%xh\n", rval,
		    mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_diag_beacon
 *      Enable/Disable beaconing via mailbox command.
 *
 * Input:
 *      ha:     adapter state pointer.
 *      mr:     pointer to mailbox in/out parameters.
 *
 * Returns:
 *      ql local function return status code.
 *
 * Context:
 *      Kernel context.
 */
int
ql_diag_beacon(ql_adapter_state_t *ha, int cmd, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	mcp->mb[0] = MBC_SET_LED_CONFIG;
	if (cmd == QL_BEACON_ENABLE) {
		mcp->mb[7] = 0xE;
	} else if (cmd == QL_BEACON_DISABLE) {
		mcp->mb[7] = 0xD;
	} else {
		return (EIO);
	}
	mcp->out_mb = MBX_7|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;

	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	}

	return (rval);
}


/*
 * ql_serdes_param
 *	Set/Get serdes transmit parameters mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer to mailbox in/out parameters.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_serdes_param(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_SERDES_TRANSMIT_PARAMETERS;
	mcp->mb[1] = mr->mb[1];
	mcp->mb[2] = mr->mb[2];
	mcp->mb[3] = mr->mb[3];
	mcp->mb[4] = mr->mb[4];
	mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	mr->mb[0] = mcp->mb[0];
	mr->mb[2] = mcp->mb[2];
	mr->mb[3] = mcp->mb[3];
	mr->mb[4] = mcp->mb[4];

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_timeout_parameters
 *	Issue get timeout parameters mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer to mailbox in/out parameters.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_timeout_parameters(ql_adapter_state_t *ha, uint16_t *tov)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_TIMEOUT_PARAMETERS;
	mcp->mb[1] = ha->fcoe_fcf_idx;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_3|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);
	if (rval == QL_SUCCESS) {
		/* Get 2 * R_A_TOV in seconds */
		if (CFG_IST(ha, CFG_CTRL_22XX) || mcp->mb[3] == 0) {
			*tov = R_A_TOV_DEFAULT;
		} else {
			*tov = (uint16_t)(mcp->mb[3] / 10);
			if (mcp->mb[3] % 10 != 0) {
				*tov = (uint16_t)(*tov + 1);
			}
			/*
			 * Adjust value to prevent driver timeout at the same
			 * time as device.
			 */
			*tov = (uint16_t)(*tov + 5);
		}
	} else {
		*tov = R_A_TOV_DEFAULT;
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_stop_firmware
 *	 Issue stop firmware Mailbox Command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_stop_firmware(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_STOP_FIRMWARE;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = 2;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_read_sfp
 *	Issue Read SFP Mailbox command
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mem:	pointer to dma memory object for command.
 *	dev:	Device address (A0h or A2h).
 *	addr:	Data address on SFP EEPROM (0-255).
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_read_sfp(ql_adapter_state_t *ha, dma_mem_t *mem, uint16_t dev,
    uint16_t addr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_READ_SFP;
	mcp->mb[1] = dev;
	mcp->mb[2] = MSW(mem->cookies->dmac_address);
	mcp->mb[3] = LSW(mem->cookies->dmac_address);
	mcp->mb[6] = MSW(mem->cookies->dmac_notused);
	mcp->mb[7] = LSW(mem->cookies->dmac_notused);
	mcp->mb[8] = LSW(mem->size);
	mcp->mb[9] = addr;
	mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	(void) ddi_dma_sync(mem->dma_handle, 0, mem->size,
	    DDI_DMA_SYNC_FORKERNEL);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_iidma_rate
 *	Issue get/set iidma rate command
 *
 * Input:
 *	ha:		adapter state pointer.
 *	loop_id:	n-port handle to set/get iidma rate.
 *	idma_rate:	Pointer to iidma rate.
 *	option:		iidma firmware option (set or get data).
 *				0 --> Get iidma rate
 *				1 --> Set iidma rate
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_iidma_rate(ql_adapter_state_t *ha, uint16_t loop_id, uint32_t *idma_rate,
    uint32_t option)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_PORT_PARAM;
	mcp->mb[1] = loop_id;
	mcp->mb[2] = (uint16_t)option;
	mcp->out_mb = MBX_0|MBX_1|MBX_2;
	mcp->in_mb = MBX_0|MBX_1;

	if (option & BIT_0) {
		mcp->mb[3] = (uint16_t)*idma_rate;
		mcp->out_mb |= MBX_3;
	} else {
		mcp->in_mb |= MBX_3;
	}

	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mb1=%xh\n", rval, mcp->mb[1]);
	} else {
		if (option == 0) {
			*idma_rate = mcp->mb[3];
		}

		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_set_xmit_parms
 *	Set transmit parameters
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_set_xmit_parms(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_XMIT_PARM;
	mcp->mb[1] = BIT_1;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_fw_etrace
 *	Firmware extended tracing.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mem:	pointer to dma memory object for command.
 *	opt:	options and opcode.
 *	mr:	pointer to mailbox in/out parameters.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_fw_etrace(ql_adapter_state_t *ha, dma_mem_t *mem, uint16_t opt,
    ql_mbx_data_t *mr)
{
	int		rval = QL_SUCCESS;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;
	uint16_t	op_code;
	uint64_t	time;

	QL_PRINT_3(ha, "started\n");

	/* currently no supported options */
	op_code = (uint16_t)(opt & ~0xFF00);

	mcp->mb[0] = MBC_TRACE_CONTROL;
	mcp->mb[1] = op_code;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;

	switch (op_code) {
	case FTO_INSERT_TIME_STAMP:

		(void) drv_getparm(TIME, &time);

		EL(ha, "insert time: %x %xh\n", MSD(time), LSD(time));

		mcp->mb[2] = LSW(LSD(time));
		mcp->mb[3] = MSW(LSD(time));
		mcp->mb[4] = LSW(MSD(time));
		mcp->mb[5] = MSW(MSD(time));
		mcp->out_mb = MBX_0_THRU_5;
		break;

	case FTO_FCE_TRACE_ENABLE:
		/* Firmware Fibre Channel Event Trace Buffer */
		mcp->mb[2] = LSW(mem->cookies->dmac_address);
		mcp->mb[3] = MSW(mem->cookies->dmac_address);
		mcp->mb[4] = LSW(mem->cookies->dmac_notused);
		mcp->mb[5] = MSW(mem->cookies->dmac_notused);
		mcp->mb[6] = (uint16_t)(mem->size / 0x4000);	/* 16kb blks */
		mcp->mb[8] = (uint16_t)ha->fwfcetraceopt;
		mcp->mb[9] = FTO_FCEMAXTRACEBUF;
		mcp->mb[10] = FTO_FCEMAXTRACEBUF;
		mcp->out_mb = MBX_0_THRU_10;
		break;

	case FTO_EXT_TRACE_ENABLE:
		/* Firmware Extended Trace Buffer */
		mcp->mb[2] = LSW(mem->cookies->dmac_address);
		mcp->mb[3] = MSW(mem->cookies->dmac_address);
		mcp->mb[4] = LSW(mem->cookies->dmac_notused);
		mcp->mb[5] = MSW(mem->cookies->dmac_notused);
		mcp->mb[6] = (uint16_t)(mem->size / 0x4000);	/* 16kb blks */
		mcp->out_mb = MBX_0_THRU_7;
		break;

	case FTO_FCE_TRACE_DISABLE:
		/* also causes ISP25xx to flush its internal FCE buffer. */
		mcp->mb[2] = BIT_0;
		mcp->out_mb = MBX_0_THRU_2;
		break;

	case FTO_EXT_TRACE_DISABLE:
		/* just sending the opcode disables it */
		break;

	default:
		EL(ha, "invalid option: %xh\n", opt);
		rval = QL_PARAMETER_ERROR;
		break;
	}

	if (rval == QL_SUCCESS) {
		rval = ql_mailbox_command(ha, mcp);
	}

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
		mr->mb[4] = mcp->mb[4];
		mr->mb[5] = mcp->mb[5];
		mr->mb[6] = mcp->mb[6];
		mr->mb[7] = mcp->mb[7];
		mr->mb[8] = mcp->mb[8];
		mr->mb[9] = mcp->mb[9];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_reset_menlo
 *	 Reset Menlo Mailbox Command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer to mailbox in/out parameters.
 *	opt:	options.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_reset_menlo(ql_adapter_state_t *ha, ql_mbx_data_t *mr, uint16_t opt)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_RESET_MENLO;
	mcp->mb[1] = opt;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
		mr->mb[1] = mcp->mb[1];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_restart_mpi
 *	The Restart MPI Firmware Mailbox Command will reset the MPI RISC,
 *	reload MPI firmware from Flash, and execute the firmware.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_restart_mpi(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_RESTART_MPI;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (rval != QL_SUCCESS) {
		EL(ha, "status=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_idc_request
 *	Inter-Driver Communication Request.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_idc_request(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_IDC_REQUEST;
	mcp->mb[1] = mr->mb[1];
	mcp->mb[2] = mr->mb[2];
	mcp->mb[3] = mr->mb[3];
	mcp->mb[4] = mr->mb[4];
	mcp->mb[5] = mr->mb[5];
	mcp->mb[6] = mr->mb[6];
	mcp->mb[7] = mr->mb[7];
	mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_2|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		mr->mb[2] = mcp->mb[2];
		QL_PRINT_3(ha, "done\n");
	} else {
		EL(ha, "status=%xh, mbx2=%xh\n", rval, mcp->mb[2]);
	}

	return (rval);
}

/*
 * ql_idc_ack
 *	Inter-Driver Communication Acknowledgement.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_idc_ack(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_IDC_ACK;
	mcp->mb[1] = ha->idc_mb[1];
	mcp->mb[2] = ha->idc_mb[2];
	mcp->mb[3] = ha->idc_mb[3];
	mcp->mb[4] = ha->idc_mb[4];
	mcp->mb[5] = ha->idc_mb[5];
	mcp->mb[6] = ha->idc_mb[6];
	mcp->mb[7] = ha->idc_mb[7];
	mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	QL_PRINT_3(ha, "done\n");

	return (rval);
}

/*
 * ql_idc_time_extend
 *	Inter-Driver Communication Time Extend
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_idc_time_extend(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_IDC_TIME_EXTEND;
	mcp->mb[1] = ha->idc_mb[1];
	mcp->mb[2] = ha->idc_mb[2];
	mcp->mb[3] = ha->idc_mb[3];
	mcp->mb[4] = ha->idc_mb[4];
	mcp->mb[5] = ha->idc_mb[5];
	mcp->mb[6] = ha->idc_mb[6];
	mcp->mb[7] = ha->idc_mb[7];
	mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	QL_PRINT_3(ha, "done\n");

	return (rval);
}

/*
 * ql_port_reset
 *	The Port Reset for the external 10G port associated with this function.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_port_reset(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_PORT_RESET;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	QL_PRINT_3(ha, "done\n");

	return (rval);
}

/*
 * ql_set_port_config
 *	The Set Port Configuration command sets the configuration for the
 *	external 10G port associated with this function.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_set_port_config(ql_adapter_state_t *ha, ql_mbx_data_t *mrp)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_SET_PORT_CONFIG;
	mcp->mb[1] = mrp->mb[1];
	mcp->mb[2] = mrp->mb[2];
	mcp->mb[3] = mrp->mb[3];
	mcp->mb[4] = mrp->mb[4];
	mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	QL_PRINT_3(ha, "done\n");

	return (rval);
}

/*
 * ql_get_port_config
 *	The Get Port Configuration command retrieves the current configuration
 *	for the external 10G port associated with this function.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_port_config(ql_adapter_state_t *ha, ql_mbx_data_t *mrp)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_PORT_CONFIG;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		if (mrp != NULL) {
			mrp->mb[1] = mcp->mb[1];
			mrp->mb[2] = mcp->mb[2];
			mrp->mb[3] = mcp->mb[3];
			mrp->mb[4] = mcp->mb[4];
		}
		QL_PRINT_3(ha, "done\n");
	} else {
		EL(ha, "status=%xh, mbx1=%xh, mbx2=%xh, mbx3=%xh, mbx4=%xh\n",
		    rval, mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[4]);
	}

	return (rval);
}

/*
 * ql_flash_access
 *	The Get Port Configuration command retrieves the current configuration
 *	for the external 10G port associated with this function
 *
 * Input:
 *	ha:	adapter state pointer.
 *	cmd:	command.
 *	start:	32bit word address.
 *	end:	32bit word address.
 *	dp:	32bit word pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_flash_access(ql_adapter_state_t *ha, uint16_t cmd, uint32_t start,
    uint32_t end, uint32_t *dp)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started, cmd=%xh\n", cmd);

	mcp->mb[0] = MBC_FLASH_ACCESS;
	mcp->mb[1] = cmd;
	mcp->mb[2] = LSW(start);
	mcp->mb[3] = MSW(start);
	mcp->mb[4] = LSW(end);
	mcp->mb[5] = MSW(end);

	mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0_THRU_4;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "cmd=%xh, status=%xh, mbx1=%xh, mbx2=%xh, mbx3=%xh, "
		    "mbx4=%xh\n", cmd, rval, mcp->mb[1], mcp->mb[2],
		    mcp->mb[3], mcp->mb[4]);
	} else {
		if (dp != NULL) {
			*dp = (uint32_t)mcp->mb[1];
		}
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_xgmac_stats
 *	Issue et XGMAC Statistics Mailbox command
 *
 * Input:
 *	ha:	adapter state pointer.
 *	size:	size of data buffer.
 *	bufp:	data pointer for DMA data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_xgmac_stats(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    (uint32_t)size)) != QL_SUCCESS) {
		EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
		return (QL_MEMORY_ALLOC_FAILED);
	}

	mcp->mb[0] = MBC_GET_XGMAC_STATS;
	mcp->mb[2] = MSW(mem_desc.cookie.dmac_address);
	mcp->mb[3] = LSW(mem_desc.cookie.dmac_address);
	mcp->mb[6] = MSW(mem_desc.cookie.dmac_notused);
	mcp->mb[7] = LSW(mem_desc.cookie.dmac_notused);
	mcp->mb[8] = (uint16_t)(size >> 2);
	mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bufp);
	}
	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "status=%xh, mbx1=%xh, mbx2=%xh\n", rval, mcp->mb[1],
		    mcp->mb[2]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_dcbx_params
 *	Issue get DCBX parameters mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	size:	size of data buffer.
 *	bufp:	data pointer for DMA data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_dcbx_params(ql_adapter_state_t *ha, uint32_t size, caddr_t bufp)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc, size)) !=
	    QL_SUCCESS) {
		EL(ha, "failed=%xh\n", QL_MEMORY_ALLOC_FAILED);
		return (QL_MEMORY_ALLOC_FAILED);
	}

	mcp->mb[0] = MBC_GET_DCBX_PARAMS;
	mcp->mb[1] = 0;	/* Return all DCBX paramters */
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[8] = (uint16_t)size;
	mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bufp);
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}
/*
 * ql_get_fcf_list
 *	Issue get FCF list mailbox command.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	fcf_list:	pointer to ql_fcf_list_desc_t
 *	bufp:		data pointer for DMA data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */

int
ql_get_fcf_list_mbx(ql_adapter_state_t *ha, ql_fcf_list_desc_t *fcf_list,
    caddr_t bufp)
{
	int		rval;
	dma_mem_t	mem_desc;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
	    fcf_list->buffer_size)) !=
	    QL_SUCCESS) {
		EL(ha, "failed=%xh\n", QL_MEMORY_ALLOC_FAILED);
		return (QL_MEMORY_ALLOC_FAILED);
	}

	mcp->mb[0] = MBC_GET_FCF_LIST;
	mcp->mb[1] = fcf_list->options;
	mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
	mcp->mb[8] = (uint16_t)fcf_list->buffer_size;
	mcp->mb[9] = fcf_list->fcf_index;
	mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval == QL_SUCCESS) {
		ql_get_mbox_dma_data(&mem_desc, bufp);
		fcf_list->buffer_size = (uint16_t)mcp->mb[1];
	}

	ql_free_dma_resource(ha, &mem_desc);

	if (rval != QL_SUCCESS) {
		EL(ha, "status=%xh, mbx1=%xh, mbx2=%xh\n", rval, mcp->mb[1],
		    mcp->mb[2]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_resource_cnts
 *	Issue get Resourse Count mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */

int
ql_get_resource_cnts(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
	mcp->out_mb = MBX_9|MBX_1|MBX_0;
	mcp->in_mb = MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|
	    MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
		mr->mb[6] = mcp->mb[6];
		mr->mb[7] = mcp->mb[7];
		mr->mb[10] = mcp->mb[10];
		mr->mb[11] = mcp->mb[11];
		mr->mb[12] = mcp->mb[12];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_toggle_interrupt
 *	 Issue Toggle Interrupt Mailbox Command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	opt:	0 = disable, 1 = enable.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_toggle_interrupt(ql_adapter_state_t *ha, uint16_t opt)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
	mcp->mb[1] = opt;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->timeout = 2;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_get_md_template
 *	Issue request mini-dump template Mailbox command
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mem:	pointer to dma memory object for command.
 *	mr:	pointer for return mailboxes.
 *	ofst:	template offset.
 *	opt:	request command code.
 *		GTO_TEMPLATE_SIZE	= Request Template Size.
 *		GTO_TEMPLATE		= Request Template.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_md_template(ql_adapter_state_t *ha, dma_mem_t *mem, ql_mbx_data_t *mr,
    uint32_t ofst, uint16_t opt)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_MD_TEMPLATE;
	mcp->mb[2] = opt;
	if (mem != NULL) {
		mcp->mb[4] = LSW(mem->cookies->dmac_address);
		mcp->mb[5] = MSW(mem->cookies->dmac_address);
		mcp->mb[6] = LSW(mem->cookies->dmac_notused);
		mcp->mb[7] = MSW(mem->cookies->dmac_notused);
		mcp->mb[8] = LSW(mem->size);
		mcp->mb[9] = MSW(mem->size);
	}
	if (ofst != 0) {
		mcp->mb[10] = LSW(ofst);
		mcp->mb[11] = MSW(ofst);
	}
	mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|
	    MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_15|MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|
	    MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	if (mr != NULL) {
		mr->mb[0] = mcp->mb[0];
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
		mr->mb[4] = mcp->mb[4];
		mr->mb[5] = mcp->mb[5];
		mr->mb[6] = mcp->mb[6];
		mr->mb[7] = mcp->mb[7];
		mr->mb[8] = mcp->mb[8];
		mr->mb[9] = mcp->mb[9];
		mr->mb[10] = mcp->mb[10];
		mr->mb[11] = mcp->mb[11];
		mr->mb[12] = mcp->mb[12];
		mr->mb[13] = mcp->mb[13];
		mr->mb[12] = mcp->mb[14];
		mr->mb[13] = mcp->mb[15];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_init_req_q
 *	 Initialize request queue.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	req_q:	request queue structure pointer.
 *	opt:	Initialize Multiple Queue mailbox command options.
 *
 * Returns:
 *	ql driver local function return status codes
 *
 * Context:
 *	Kernel context.
 */
static int
ql_init_req_q(ql_adapter_state_t *ha, ql_request_q_t *req_q, uint16_t opt)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started, req_q_number=%d\n", req_q->req_q_number);

	if (!(opt & IMO_QOS_UPDATE)) {
		req_q->req_ring_ptr = req_q->req_ring.bp;
		req_q->req_ring_index = 0;
		req_q->req_q_cnt = (uint16_t)(req_q->req_entry_cnt - 1);
		WR32_MBAR_REG(ha, req_q->mbar_req_in, 0);
		if (req_q->req_out_shadow_ptr) {
			*req_q->req_out_shadow_ptr = 0;
		}
	}

	mcp->mb[0] = MBC_INIT_MULTIPLE_QUEUE;
	mcp->mb[1] = (uint16_t)(opt | IMO_QUEUE_NOT_ASSOCIATED);
	mcp->mb[2] = MSW(LSD(req_q->req_ring.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(req_q->req_ring.cookie.dmac_laddress));
	mcp->mb[4] = req_q->req_q_number;
	mcp->mb[5] = req_q->req_entry_cnt;
	mcp->mb[6] = MSW(MSD(req_q->req_ring.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(req_q->req_ring.cookie.dmac_laddress));
	mcp->mb[11] = ha->vp_index;
	mcp->mb[12] = 0;
	mcp->mb[14] = 1;
	mcp->out_mb = MBX_0_THRU_14;
	mcp->in_mb = MBX_0_THRU_1;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "status=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_init_rsp_q
 *	 Initialize response queue.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	rsp_q:	response queue structure pointer.
 *	opt:	Initialize Multiple Queue mailbox command options.
 *
 * Returns:
 *	ql driver local function return status codes
 *
 * Context:
 *	Kernel context.
 */
static int
ql_init_rsp_q(ql_adapter_state_t *ha, ql_response_q_t *rsp_q, uint16_t opt)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started, rsp_q_number=%d\n", rsp_q->rsp_q_number);

	if (!(opt & IMO_DELETE_Q)) {
		rsp_q->rsp_ring_ptr = rsp_q->rsp_ring.bp;
		rsp_q->rsp_ring_index = 0;
		WR32_MBAR_REG(ha, rsp_q->mbar_rsp_out, 0);
		if (rsp_q->rsp_in_shadow_ptr) {
			*rsp_q->rsp_in_shadow_ptr = 0;
		}
	}

	mcp->mb[0] = MBC_INIT_MULTIPLE_QUEUE;
	mcp->mb[1] = (uint16_t)(opt | IMO_QUEUE_NOT_ASSOCIATED |
	    IMO_RESPONSE_Q_SERVICE);
	mcp->mb[2] = MSW(LSD(rsp_q->rsp_ring.cookie.dmac_laddress));
	mcp->mb[3] = LSW(LSD(rsp_q->rsp_ring.cookie.dmac_laddress));
	mcp->mb[4] = rsp_q->rsp_q_number;
	mcp->mb[5] = rsp_q->rsp_entry_cnt;
	mcp->mb[6] = MSW(MSD(rsp_q->rsp_ring.cookie.dmac_laddress));
	mcp->mb[7] = LSW(MSD(rsp_q->rsp_ring.cookie.dmac_laddress));
	mcp->mb[14] = rsp_q->msi_x_vector;
	mcp->out_mb = MBX_0_THRU_14;
	mcp->in_mb = MBX_0_THRU_1;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "status=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_load_flash_image
 *	Load Flash Firmware.
 *
 * Input:
 *	ha:	adapter state pointer.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_load_flash_image(ql_adapter_state_t *ha)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_LOAD_FLASH_IMAGE;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh, mbx1=%xh, mbx2=%xh\n",
		    rval, mcp->mb[1], mcp->mb[2]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_set_led_config
 *	Set LED Configuration.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_set_led_config(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_SET_LED_CONFIG;
	mcp->mb[1] = mr->mb[1];
	mcp->mb[2] = mr->mb[2];
	mcp->mb[3] = mr->mb[3];
	mcp->mb[4] = mr->mb[4];
	mcp->mb[5] = mr->mb[5];
	mcp->mb[6] = mr->mb[6];
	mcp->out_mb = MBX_0_THRU_6;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}
/*
 * ql_get_led_config
 *	Get LED Configuration.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_led_config(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_LED_CONFIG;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0_THRU_6;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return config data. */
	if (mr != NULL) {
		mr->mb[1] = mcp->mb[1];
		mr->mb[2] = mcp->mb[2];
		mr->mb[3] = mcp->mb[3];
		mr->mb[4] = mcp->mb[4];
		mr->mb[5] = mcp->mb[5];
		mr->mb[6] = mcp->mb[6];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_led_config
 *	Set/Get Fibre Channel LED Configuration command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	opt:	Options.
 *	led0:	LED 0 configuration.
 *	led1:	LED 1 configuration.
 *	led2:	LED 2 configuration.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	qlc local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_led_config(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int			rval = QL_SUCCESS;
	mbx_cmd_t		mc = {0};
	mbx_cmd_t		*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_FC_LED_CONFIG;
	mcp->mb[1] = mr->mb[1];
	mcp->mb[2] = mr->mb[2];
	mcp->mb[3] = mr->mb[3];
	mcp->mb[4] = mr->mb[4];
	mcp->out_mb = MBX_0_THRU_4;
	mcp->in_mb = MBX_0_THRU_4;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	mr->mb[0] = mcp->mb[0];
	mr->mb[1] = mcp->mb[1];
	mr->mb[2] = mcp->mb[2];
	mr->mb[3] = mcp->mb[3];
	mr->mb[4] = mcp->mb[4];

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_write_remote_reg
 *	Writes a register within another function.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	addr:	address.
 *	data:	data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_write_remote_reg(ql_adapter_state_t *ha, uint32_t addr, uint32_t data)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_10(ha, "started, addr=%xh, data=%xh\n", addr, data);

	mcp->mb[0] = MBC_WRITE_REMOTE_REG;
	mcp->mb[1] = LSW(addr);
	mcp->mb[2] = MSW(addr);
	mcp->mb[3] = LSW(data);
	mcp->mb[4] = MSW(data);
	mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mbx1=%xh, addr=%xh, data=%xh\n", rval,
		    mcp->mb[1], addr, data);
	} else {
		/*EMPTY*/
		QL_PRINT_10(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_read_remote_reg
 *	Read a register within another function.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	addr:	address.
 *	data:	data pointer.
 *
 * Returns:
 *	qlc local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_read_remote_reg(ql_adapter_state_t *ha, uint32_t addr, uint32_t *dp)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_10(ha, "started, addr=%xh\n", addr);

	mcp->mb[0] = MBC_READ_REMOTE_REG;
	mcp->mb[1] = LSW(addr);
	mcp->mb[2] = MSW(addr);
	mcp->out_mb = MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed=%xh, mbx1=%xh, addr=%xh\n", rval, mcp->mb[1],
		    addr);
	} else {
		*dp = SHORT_TO_LONG(mcp->mb[3], mcp->mb[4]);
		QL_PRINT_10(ha, "done, addr=%xh, data=%xh\n", addr, *dp);
	}
	return (rval);
}

/*
 * ql_get_temp
 *	Issue get temperature mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_get_temp(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_GET_PARAMETERS;
	mcp->mb[1] = READ_ASIC_TEMP << 8;
	mcp->out_mb = MBX_0_THRU_1;
	mcp->in_mb = MBX_0_THRU_1;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return config data. */
	if (mr != NULL) {
		mr->mb[1] = mcp->mb[1];
	}

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}
	return (rval);
}

/*
 * ql_write_serdes
 *	Issue write FC serdes register mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_write_serdes(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_WRITE_SERDES_REG;
	mcp->mb[1] = mr->mb[1];
	mcp->mb[2] = mr->mb[2];
	mcp->mb[3] = mr->mb[3];
	mcp->mb[4] = mr->mb[4];
	mcp->mb[5] = mr->mb[5];
	mcp->mb[6] = mr->mb[6];
	mcp->out_mb = MBX_0_THRU_6;
	mcp->in_mb = MBX_0;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh\n", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}

/*
 * ql_read_serdes
 *	Issue read FC serdes register mailbox command.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	mr:	pointer for mailbox data.
 *
 * Returns:
 *	ql local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
ql_read_serdes(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
{
	int		rval;
	mbx_cmd_t	mc = {0};
	mbx_cmd_t	*mcp = &mc;

	QL_PRINT_3(ha, "started\n");

	mcp->mb[0] = MBC_READ_SERDES_REG;
	mcp->mb[1] = mr->mb[1];
	mcp->mb[2] = mr->mb[2];
	mcp->mb[3] = mr->mb[3];
	mcp->mb[4] = mr->mb[4];
	mcp->mb[5] = mr->mb[5];
	mcp->mb[6] = mr->mb[6];
	mcp->out_mb = MBX_0_THRU_6;
	mcp->in_mb = MBX_0_THRU_6;
	mcp->timeout = MAILBOX_TOV;
	rval = ql_mailbox_command(ha, mcp);

	/* Return mailbox data. */
	mr->mb[0] = mcp->mb[0];
	mr->mb[1] = mcp->mb[1];
	mr->mb[2] = mcp->mb[2];
	mr->mb[3] = mcp->mb[3];
	mr->mb[4] = mcp->mb[4];
	mr->mb[4] = mcp->mb[5];
	mr->mb[4] = mcp->mb[6];

	if (rval != QL_SUCCESS) {
		EL(ha, "failed, rval=%xh", rval);
	} else {
		/*EMPTY*/
		QL_PRINT_3(ha, "done\n");
	}

	return (rval);
}