xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/fca/emlxs/emlxs_dump.c (revision a3170057)

/*
 * 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
 * http://www.opensource.org/licenses/cddl1.txt.
 * 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 (c) 2004-2012 Emulex. All rights reserved.
 * Use is subject to license terms.
 */

#include <emlxs.h>

#ifdef DUMP_SUPPORT

/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
EMLXS_MSG_DEF(EMLXS_DUMP_C);

/* ************************************************************************* */
/* Utility functions */
/* ************************************************************************* */

static uint32_t
emlxs_menlo_set_mode(
	emlxs_hba_t *hba,
	uint32_t mode)
{
	emlxs_port_t *port = &PPORT;
	uint32_t cmd_size;
	uint32_t rsp_size;
	menlo_cmd_t *cmd_buf = NULL;
	menlo_rsp_t *rsp_buf = NULL;
	uint32_t rval = 0;

	if (hba->model_info.vendor_id != PCI_VENDOR_ID_EMULEX ||
	    hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return (DFC_INVALID_ADAPTER);
	}

	cmd_size = sizeof (menlo_set_cmd_t);
	cmd_buf = (menlo_cmd_t *)kmem_zalloc(cmd_size, KM_SLEEP);

	rsp_size = 4;
	rsp_buf = (menlo_rsp_t *)kmem_zalloc(rsp_size, KM_SLEEP);

	cmd_buf->code = MENLO_CMD_SET_MODE;
	cmd_buf->set.value1 = mode;
	cmd_buf->set.value2 = 0;

#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)cmd_buf, cmd_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rval = emlxs_send_menlo_cmd(hba, (uint8_t *)cmd_buf, cmd_size,
	    (uint8_t *)rsp_buf, &rsp_size)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_set_mode: Unable to send command.");
		goto done;
	}
#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)rsp_buf, rsp_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rsp_buf->code != 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_set_mode: Menlo command error. code=%d.\n",
		    rsp_buf->code);
	}

	rval = rsp_buf->code;

done:

	if (cmd_buf) {
		kmem_free(cmd_buf, sizeof (menlo_set_cmd_t));
	}

	if (rsp_buf) {
		kmem_free(rsp_buf, 4);
	}

	return (rval);

} /* emlxs_menlo_set_mode() */


static uint32_t
emlxs_menlo_reset(
	emlxs_hba_t *hba,
	uint32_t firmware)
{
	emlxs_port_t *port = &PPORT;
	uint32_t cmd_size;
	uint32_t rsp_size;
	menlo_cmd_t *cmd_buf = NULL;
	menlo_rsp_t *rsp_buf = NULL;
	uint32_t rval = 0;

	if (hba->model_info.vendor_id != PCI_VENDOR_ID_EMULEX ||
	    hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return (DFC_INVALID_ADAPTER);
	}

	cmd_size = sizeof (menlo_reset_cmd_t);
	cmd_buf = (menlo_cmd_t *)kmem_zalloc(cmd_size, KM_SLEEP);

	rsp_size = 4;
	rsp_buf = (menlo_rsp_t *)kmem_zalloc(rsp_size, KM_SLEEP);

	cmd_buf->code = MENLO_CMD_RESET;
	cmd_buf->reset.firmware = firmware;

#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)cmd_buf, cmd_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rval = emlxs_send_menlo_cmd(hba, (uint8_t *)cmd_buf, cmd_size,
	    (uint8_t *)rsp_buf, &rsp_size)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_reset: Unable to send command.");
		goto done;
	}
#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)rsp_buf, rsp_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rsp_buf->code != 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_reset: Menlo command error. code=%d.\n",
		    rsp_buf->code);
	}

	rval = rsp_buf->code;

done:

	if (cmd_buf) {
		kmem_free(cmd_buf, sizeof (menlo_reset_cmd_t));
	}

	if (rsp_buf) {
		kmem_free(rsp_buf, 4);
	}

	return (rval);

} /* emlxs_menlo_reset() */


static uint32_t
emlxs_menlo_get_cfg(
	emlxs_hba_t *hba,
	menlo_get_config_rsp_t *rsp_buf,
	uint32_t rsp_size)
{
	emlxs_port_t *port = &PPORT;
	uint32_t cmd_size;
	menlo_cmd_t *cmd_buf = NULL;
	uint32_t rval = 0;

	if (hba->model_info.vendor_id != PCI_VENDOR_ID_EMULEX ||
	    hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return (DFC_INVALID_ADAPTER);
	}

	cmd_size = sizeof (menlo_get_cmd_t);
	cmd_buf = (menlo_cmd_t *)kmem_zalloc(cmd_size, KM_SLEEP);

	rsp_size = sizeof (menlo_get_config_rsp_t);

	cmd_buf->code = MENLO_CMD_GET_CONFIG;
	cmd_buf->get.context = 0;
	cmd_buf->get.length = rsp_size;

#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)cmd_buf, cmd_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rval = emlxs_send_menlo_cmd(hba, (uint8_t *)cmd_buf, cmd_size,
	    (uint8_t *)rsp_buf, &rsp_size)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_cfg: Unable to send command.");
		goto done;
	}
#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)rsp_buf, rsp_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rsp_buf->code != 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_cfg: Menlo command error. code=%d.\n",
		    rsp_buf->code);
	}

	rval = rsp_buf->code;

done:

	if (cmd_buf) {
		kmem_free(cmd_buf, sizeof (menlo_get_cmd_t));
	}

	return (rval);

} /* emlxs_menlo_get_cfg() */



static uint32_t
emlxs_menlo_get_logcfg(
	emlxs_hba_t *hba,
	menlo_rsp_t *rsp_buf,
	uint32_t rsp_size)
{
	emlxs_port_t *port = &PPORT;
	uint32_t cmd_size;
	menlo_cmd_t *cmd_buf = NULL;
	uint32_t rval = 0;

	if (hba->model_info.vendor_id != PCI_VENDOR_ID_EMULEX ||
	    hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return (DFC_INVALID_ADAPTER);
	}

	cmd_size = sizeof (menlo_get_cmd_t);
	cmd_buf = (menlo_cmd_t *)kmem_zalloc(cmd_size, KM_SLEEP);

	cmd_buf->code = MENLO_CMD_GET_LOG_CONFIG;
	cmd_buf->get.context = 0;
	cmd_buf->get.length = rsp_size;

#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)cmd_buf, cmd_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rval = emlxs_send_menlo_cmd(hba, (uint8_t *)cmd_buf, cmd_size,
	    (uint8_t *)rsp_buf, &rsp_size)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_logcfg: Unable to send command.");
		goto done;
	}
#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)rsp_buf, rsp_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rsp_buf->code != 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_logcfg: Menlo command error. code=%d.\n",
		    rsp_buf->code);
	}

	rval = rsp_buf->code;

done:

	if (cmd_buf) {
		kmem_free(cmd_buf, sizeof (menlo_get_cmd_t));
	}

	return (rval);

} /* emlxs_menlo_get_logcfg() */


static uint32_t
emlxs_menlo_get_log(
	emlxs_hba_t *hba,
	uint32_t id,
	menlo_rsp_t *rsp_buf,
	uint32_t rsp_size)
{
	emlxs_port_t *port = &PPORT;
	uint32_t cmd_size;
	menlo_cmd_t *cmd_buf = NULL;
	uint32_t rval = 0;

	if (hba->model_info.vendor_id != PCI_VENDOR_ID_EMULEX ||
	    hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return (DFC_INVALID_ADAPTER);
	}

	cmd_size = sizeof (menlo_get_cmd_t);
	cmd_buf = (menlo_cmd_t *)kmem_zalloc(cmd_size, KM_SLEEP);

	cmd_buf->code = MENLO_CMD_GET_LOG_DATA;
	cmd_buf->get.context = id;
	cmd_buf->get.length = rsp_size;

#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)cmd_buf, cmd_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rval = emlxs_send_menlo_cmd(hba, (uint8_t *)cmd_buf, cmd_size,
	    (uint8_t *)rsp_buf, &rsp_size)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_log: Unable to send command.");
		goto done;
	}
#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)rsp_buf, rsp_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rsp_buf->code != 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_log: Menlo command error. code=%d.\n",
		    rsp_buf->code);
	}

	rval = rsp_buf->code;

done:

	if (cmd_buf) {
		kmem_free(cmd_buf, sizeof (menlo_get_cmd_t));
	}

	return (rval);

} /* emlxs_menlo_get_log() */


static uint32_t
emlxs_menlo_get_paniclog(
	emlxs_hba_t *hba,
	menlo_rsp_t *rsp_buf,
	uint32_t rsp_size)
{
	emlxs_port_t *port = &PPORT;
	uint32_t cmd_size;
	menlo_cmd_t *cmd_buf = NULL;
	uint32_t rval = 0;

	if (hba->model_info.vendor_id != PCI_VENDOR_ID_EMULEX ||
	    hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return (DFC_INVALID_ADAPTER);
	}

	cmd_size = sizeof (menlo_get_cmd_t);
	cmd_buf = (menlo_cmd_t *)kmem_zalloc(cmd_size, KM_SLEEP);

	cmd_buf->code = MENLO_CMD_GET_PANIC_LOG;
	cmd_buf->get.context = 0;
	cmd_buf->get.length = rsp_size;

#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)cmd_buf, cmd_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rval = emlxs_send_menlo_cmd(hba, (uint8_t *)cmd_buf, cmd_size,
	    (uint8_t *)rsp_buf, &rsp_size)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_paniclog: Unable to send command.");
		goto done;
	}
#ifdef EMLXS_BIG_ENDIAN
	emlxs_swap32_buffer((uint8_t *)rsp_buf, rsp_size);
#endif /* EMLXS_BIG_ENDIAN */

	if (rsp_buf->code != 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
		    "menlo_get_paniclog: Menlo command error. code=%d.\n",
		    rsp_buf->code);
	}

	rval = rsp_buf->code;

done:

	if (cmd_buf) {
		kmem_free(cmd_buf, sizeof (menlo_get_cmd_t));
	}

	return (rval);

} /* emlxs_menlo_get_paniclog() */




extern void
emlxs_fflush(
	emlxs_file_t *fp)
{
	uint32_t offset;

	offset = (uint32_t)((uintptr_t)fp->ptr - (uintptr_t)fp->buffer);

	if (offset > fp->size) {
		fp->ptr = fp->buffer + fp->size;
	}

	return;

} /* emlxs_fflush() */


extern uint32_t
emlxs_ftell(
	emlxs_file_t *fp)
{
	uint32_t offset;

	offset = (uint32_t)((uintptr_t)fp->ptr - (uintptr_t)fp->buffer);

	return (offset);

} /* emlxs_ftell() */


static void
emlxs_fputc(
	uint8_t value,
	emlxs_file_t *fp)
{
	uint32_t offset;

	offset = (uint32_t)((uintptr_t)fp->ptr - (uintptr_t)fp->buffer);

	if ((offset + 1) <= fp->size) {
		*fp->ptr++ = value;
	}

	return;

} /* emlxs_fputc() */


static uint32_t
emlxs_fwrite(
	uint8_t *buffer,
	uint32_t size,
	uint32_t nitems,
	emlxs_file_t *fp)
{
	uint32_t offset;
	uint32_t length;

	length = size * nitems;

	if (length) {
		offset =
		    (uint32_t)((uintptr_t)fp->ptr - (uintptr_t)fp->buffer);

		if ((offset + length) > fp->size) {
			length = fp->size - offset;
		}

		if (length) {
			bcopy(buffer, fp->ptr, length);
			fp->ptr += length;
		}
	}

	return (length);

} /* emlxs_fwrite() */


static uint32_t
emlxs_fprintf(
	emlxs_file_t *fp,
	const char *fmt, ...)
{
	va_list valist;
	char va_str[1024];
	uint32_t length;

	va_start(valist, fmt);
	(void) vsnprintf(va_str, sizeof (va_str), fmt, valist);
	va_end(valist);

	length = emlxs_fwrite((uint8_t *)va_str, strlen(va_str), 1, fp);

	return (length);

} /* emlxs_fprintf() */


extern emlxs_file_t *
emlxs_fopen(
	emlxs_hba_t *hba,
	uint32_t file_type)
{
	emlxs_file_t *fp;

	switch (file_type) {
	case EMLXS_TXT_FILE:
		fp = &hba->dump_txtfile;
		fp->size = EMLXS_TXT_FILE_SIZE;
		break;

	case EMLXS_DMP_FILE:
		fp = &hba->dump_dmpfile;
		fp->size = EMLXS_DMP_FILE_SIZE;
		break;

	case EMLXS_CEE_FILE:
		fp = &hba->dump_ceefile;
		fp->size = EMLXS_CEE_FILE_SIZE;
		break;

	default:
		return (NULL);
	}

	/* Make sure it is word aligned */
	fp->size &= 0xFFFFFFFC;

	if (!fp->buffer) {
		fp->buffer =
		    (uint8_t *)kmem_zalloc(fp->size, KM_SLEEP);

	} else {
		bzero(fp->buffer, fp->size);
	}

	fp->ptr = fp->buffer;

	return (fp);

} /* emlxs_fopen() */


extern uint32_t
emlxs_fclose(
	emlxs_file_t *fp)
{
	uint32_t offset;

	if (fp == NULL) {
		return (0);
	}

	offset = (uint32_t)((uintptr_t)fp->ptr - (uintptr_t)fp->buffer);
	offset = offset % 4;

	switch (offset) {
	case 0:
		break;

	case 1:
		*fp->ptr++ = 0;
		*fp->ptr++ = 0;
		*fp->ptr++ = 0;
		break;

	case 2:
		*fp->ptr++ = 0;
		*fp->ptr++ = 0;
		break;

	case 3:
		*fp->ptr++ = 0;
		break;
	}

	return (0);

} /* emlxs_fclose() */


static void
emlxs_fdelete(
	emlxs_file_t *fp)
{
	if (fp == NULL) {
		return;
	}

	if (fp->buffer && fp->size) {
		kmem_free(fp->buffer, fp->size);
	}

	fp->buffer = NULL;
	fp->ptr = NULL;
	fp->size = 0;

	return;

} /* emlxs_fdelete() */


/* This builds a single core buffer for the IOCTL interface */
extern uint32_t
emlxs_get_dump(
	emlxs_hba_t *hba,
	uint8_t *buffer,
	uint32_t *buflen)
{
	emlxs_port_t *port = &PPORT;
	int32_t i;
	int32_t size;
	int32_t count;
	uint32_t size_dmp;
	uint32_t size_txt;
	uint32_t size_cee;
	emlxs_file_t *fp_txt;
	emlxs_file_t *fp_dmp;
	emlxs_file_t *fp_cee;
	uint32_t *wptr;
	uint8_t *bptr;

	if (!buflen) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "get_dump: Buffer length = 0");
		return (1);
	}

	fp_txt = &hba->dump_txtfile;
	fp_dmp = &hba->dump_dmpfile;
	fp_cee = &hba->dump_ceefile;

	size_txt = emlxs_ftell(fp_txt);
	size_dmp = emlxs_ftell(fp_dmp);
	size_cee = emlxs_ftell(fp_cee);

	size = 0;
	count = 0;
	if (size_txt) {
		count++;
		size += size_txt + 8;
	}
	if (size_dmp) {
		count++;
		size += size_dmp + 8;
	}
	if (size_cee) {
		count++;
		size += size_cee + 8;
	}

	if (size) {
		size += 4;
	}

	if (!buffer) {
		goto done;
	}

	bzero(buffer, *buflen);

	if (*buflen < size) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "get_dump: Buffer length too small. %d < %d",
		    *buflen, size);

		*buflen = 0;
		return (1);
	}

	wptr = (uint32_t *)buffer;
	wptr[0] = count;
	i = 1;

	if (size_txt) {
		wptr[i++] = EMLXS_TXT_FILE_ID;
		wptr[i++] = size_txt;
	}

	if (size_dmp) {
		wptr[i++] = EMLXS_DMP_FILE_ID;
		wptr[i++] = size_dmp;
	}

	if (size_cee) {
		if ((hba->model_info.chip == EMLXS_BE2_CHIP) ||
		    (hba->model_info.chip == EMLXS_BE3_CHIP)) {
			wptr[i++] = EMLXS_FAT_FILE_ID;
		} else {
			wptr[i++] = EMLXS_CEE_FILE_ID;
		}

		wptr[i++] = size_cee;
	}

	bptr = (uint8_t *)&wptr[i];

	if (size_txt) {
		bcopy(fp_txt->buffer, bptr, size_txt);
		bptr += size_txt;
	}

	if (size_dmp) {
		bcopy(fp_dmp->buffer, bptr, size_dmp);
		bptr += size_dmp;
	}

	if (size_cee) {
		bcopy(fp_cee->buffer, bptr, size_cee);
		bptr += size_cee;
	}

done:

	*buflen = size;

	/* printf("Done. buflen=%d \n", *buflen); */

	return (0);

} /* emlxs_get_dump() */


static uint32_t
emlxs_read_cfg_region(
	emlxs_hba_t *hba,
	uint32_t Identifier,
	uint32_t ByteCount,
	uint32_t *pRetByteCount,
	uint8_t *pBuffer)
{
	emlxs_port_t *port = &PPORT;
	MAILBOXQ *mbq;
	uint32_t ByteCountRem;	/* remaining portion of original byte count */
	uint32_t ByteCountReq;	/* requested byte count for a particular dump */
	uint32_t CopyCount;	/* bytes to copy after each successful dump */
	uint32_t Offset;	/* Offset into Config Region, for each dump */
	uint8_t *pLocalBuf;	/* ptr to buffer to receive each dump */

	if (! ByteCount) {
		return (0);
	}

	mbq =
	    (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);

	pLocalBuf = pBuffer;	/* init local pointer to caller's buffer */
	Offset = 0;	/* start at offset 0 */
	*pRetByteCount = 0;	/* init returned byte count */
	CopyCount = 0;

	for (ByteCountRem = ByteCount; ByteCountRem > 0;
	    ByteCountRem -= CopyCount) {

		if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
			MAILBOX4 *mb = (MAILBOX4 *)mbq;

			ByteCountReq =
			    (ByteCountRem < hba->sli.sli4.dump_region.size) ?
			    ByteCountRem : hba->sli.sli4.dump_region.size;

			/* Clear the local dump_region */
			bzero(hba->sli.sli4.dump_region.virt,
			    hba->sli.sli4.dump_region.size);

			bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);

			mb->mbxCommand = MBX_DUMP_MEMORY;
			mb->un.varDmp4.type = DMP_NV_PARAMS;
			mb->un.varDmp4.entry_index = Offset;
			mb->un.varDmp4.region_id = Identifier;

			mb->un.varDmp4.available_cnt = ByteCountReq;
			mb->un.varDmp4.addrHigh =
			    PADDR_HI(hba->sli.sli4.dump_region.phys);
			mb->un.varDmp4.addrLow =
			    PADDR_LO(hba->sli.sli4.dump_region.phys);
			mb->un.varDmp4.rsp_cnt = 0;

			mb->mbxOwner = OWN_HOST;
			mbq->mbox_cmpl = NULL;

			if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
			    MBX_SUCCESS) {
				EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
				    "Unable to read config region. id=%x "\
				    "offset=%x status=%x",
				    Identifier, Offset, mb->mbxStatus);

				kmem_free(mbq, sizeof (MAILBOXQ));
				return (1);
			}

			CopyCount = mb->un.varDmp4.rsp_cnt;

			/* if no more data returned */
			if (CopyCount == 0) {
				break;
			}

			if (CopyCount > ByteCountReq) {
				EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
				    "read_cfg_region: " \
				    "Byte count too big. %d > %d\n",
				    CopyCount, ByteCountReq);

				CopyCount = ByteCountReq;
			}

			bcopy((uint8_t *)hba->sli.sli4.dump_region.virt,
			    pLocalBuf, CopyCount);

		} else {
			MAILBOX *mb = (MAILBOX *)mbq;

			ByteCountReq =
			    (ByteCountRem < DUMP_BC_MAX) ? ByteCountRem :
			    DUMP_BC_MAX;

			bzero((void *)mb, MAILBOX_CMD_BSIZE);

			mb->mbxCommand = MBX_DUMP_MEMORY;
			mb->un.varDmp.type = DMP_NV_PARAMS;
			mb->un.varDmp.cv = 1;
			mb->un.varDmp.region_id = Identifier;
			mb->un.varDmp.entry_index = Offset;
			mb->un.varDmp.word_cnt = ByteCountReq / 4;
			mb->mbxOwner = OWN_HOST;
			mbq->mbox_cmpl = NULL;

			if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
			    MBX_SUCCESS) {
				EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
				    "Unable to read config region. id=%x "\
				    "offset=%x status=%x",
				    Identifier, Offset, mb->mbxStatus);

				kmem_free(mbq, sizeof (MAILBOXQ));
				return (1);
			}

			/* Note: for Type 2/3 Dumps, varDmp.word_cnt is */
			/* actually a byte count. */
			CopyCount = mb->un.varDmp.word_cnt;

			/* if no more data returned */
			if (CopyCount == 0) {
				break;
			}

			if (CopyCount > ByteCountReq) {
				EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
				    "read_cfg_region: " \
				    "Byte count too big. %d > %d\n",
				    CopyCount, ByteCountReq);

				CopyCount = ByteCountReq;
			}

			bcopy((uint8_t *)&mb->un.varDmp.resp_offset, pLocalBuf,
			    CopyCount);
		}

		pLocalBuf += CopyCount;
		Offset += CopyCount;
		*pRetByteCount += CopyCount;
	}

	return (0);

} /* emlxs_read_cfg_region() */



/* ************************************************************************* */
/* ************************************************************************* */
/* Dump Generators, Low-Level */
/* ************************************************************************* */
/* ************************************************************************* */

static uint32_t
emlxs_dump_string_txtfile(
	emlxs_file_t *fpTxtFile,
	char *pString,
	char *pSidLegend,
	char *pLidLegend,
	uint32_t pure)
{

	if (!fpTxtFile) {
		return (1);
	}

	if (pSidLegend && pLidLegend) {
		(void) emlxs_fprintf(fpTxtFile, "%s: %s\n", pSidLegend,
		    pLidLegend);

		if (pure == 0) {
			emlxs_fputc(' ', fpTxtFile);
		}

		(void) emlxs_fwrite((uint8_t *)pString, strlen(pString), 1,
		    fpTxtFile);

		if (pure == 0) {
			emlxs_fputc('\n', fpTxtFile);
			emlxs_fputc('\n', fpTxtFile);
		}
	} else {
		if (pure == 0) {
			emlxs_fputc(' ', fpTxtFile);
		}
		(void) emlxs_fwrite((uint8_t *)pString, strlen(pString), 1,
		    fpTxtFile);
	}

	emlxs_fflush(fpTxtFile);

	return (0);

} /* emlxs_dump_string_txtfile() */


static uint32_t
emlxs_dump_word_txtfile(
	emlxs_file_t *fpTxtFile,
	uint32_t *pBuffer,
	uint32_t WordCount,
	char *pSidLegend,
	char *pLidLegend)
{
	char buf1[256];
	char buf2[256];
	uint32_t *ptr;
	uint32_t j;

	if (!fpTxtFile) {
		return (1);
	}

	/* Write Legend String to the TXT File */
	(void) emlxs_fprintf(fpTxtFile, "%s: %s\n", pSidLegend, pLidLegend);

	/* Write the buffer to the TXT File */
	ptr = pBuffer;

	for (j = 0; j < WordCount; j++) {
		buf1[0] = 0;
		buf2[0] = 0;

		if ((j & 0x03) == 0) {
			(void) snprintf(buf1, sizeof (buf1), "\n%04x:", j * 4);
			(void) strlcat(buf2, buf1, sizeof (buf2));
		}
		/* print 1 word */
		(void) snprintf(buf1, sizeof (buf1), " %08x", ptr[j]);
		(void) strlcat(buf2, buf1, sizeof (buf2));
		(void) emlxs_fwrite((uint8_t *)buf2, strlen(buf2), 1,
		    fpTxtFile);
	}

	emlxs_fputc('\n', fpTxtFile);
	emlxs_fputc('\n', fpTxtFile);
	emlxs_fflush(fpTxtFile);
	return (0);

} /* emlxs_dump_word_txtfile() */




static uint32_t
emlxs_dump_string_dmpfile(
	emlxs_file_t *fpDmpFile,
	char *pString,
	uint8_t sid,
	char *pSidLegend,
	char *pLidLegend)
{
	uint32_t length;
	uint8_t byte;
	uint32_t pos;

	if (!fpDmpFile) {
		return (1);
	}

	/* Write Legend SID to the DMP File */
	emlxs_fputc(SID_LEGEND, fpDmpFile);

	/* Write Argument SID to the DMP File */
	emlxs_fputc(sid, fpDmpFile);

	/* Write Legend String to the DMP File, including a Null Byte */
	(void) emlxs_fprintf(fpDmpFile, "%s: %s", pSidLegend, pLidLegend);
	emlxs_fputc(0, fpDmpFile);

	/* Write Argument SID to the DMP File */
	emlxs_fputc(sid, fpDmpFile);

	/* Write Buffer Length to the DMP File */
	length = (uint32_t)(strlen(pString) + 1);
#ifdef EMLXS_LITTLE_ENDIAN
	byte = (uint8_t)(length & 0x0000FF);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)((length & 0x00FF00) >> 8);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)((length & 0xFF0000) >> 16);
	emlxs_fputc(byte, fpDmpFile);
#endif /* EMLXS_LITTLE_ENDIAN */

#ifdef EMLXS_BIG_ENDIAN
	byte = (uint8_t)((length & 0xFF0000) >> 16);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)((length & 0x00FF00) >> 8);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)(length & 0x0000FF);
	emlxs_fputc(byte, fpDmpFile);
#endif /* EMLXS_BIG_ENDIAN */

	/* Write Argument String to the DMP File, including a Null Byte */
	(void) emlxs_fwrite((uint8_t *)pString, strlen(pString), 1, fpDmpFile);
	emlxs_fputc(0, fpDmpFile);

	emlxs_fflush(fpDmpFile);

#if CC_DUMP_ENABLE_PAD
	/* check file size.. pad as necessary */
	pos = emlxs_ftell(fpDmpFile);
	switch (pos & 0x03) {
	case 0:
		break;
	case 1:
		emlxs_fputc(0, fpDmpFile);
		emlxs_fputc(0, fpDmpFile);
		emlxs_fputc(0, fpDmpFile);
		break;
	case 2:
		emlxs_fputc(0, fpDmpFile);
		emlxs_fputc(0, fpDmpFile);
		break;
	case 3:
		emlxs_fputc(0, fpDmpFile);
		break;
	}
	emlxs_fflush(fpDmpFile);
#endif

	return (0);

} /* emlxs_dump_string_dmpfile() */


/* ************************************************************************** */
/* emlxs_dump_word_dmpfile */
/* If little endian, just write the buffer normally. */
/* However, if Big Endian... Consider the following: */
/* Automatic Dump, initiated by driver, Port Offline (FW WarmStart Mode), */
/* Mailbox in SLIM. */
/* On-Demand Dump, initiated by utility, Port Online (FW Normal Mode), */
/* Mailbox in Host Memory. */
/* We use the same IOCTL to get the DUMP Data, for both cases. */
/* However, it normalizes the data before delivering it to us. */
/* In the Dump File, we must always write the data in native mode. */
/* So, if Big Endian, On-demand Dump, we must swap the words. */
/* ************************************************************************* */
/*ARGSUSED*/
extern uint32_t
emlxs_dump_word_dmpfile(
	emlxs_file_t *fpDmpFile,
	uint8_t *pBuffer,
	uint32_t bufferLen,
	int fSwap)
{
	uint32_t i;
	uint32_t *wptr;

	if (!fpDmpFile) {
		return (1);
	}

	wptr = (uint32_t *)pBuffer;
	for (i = 0; i < bufferLen / 4; i++, wptr++) {
		if (fSwap) {
			uint32_t w1;
			w1 = *wptr;
			*wptr = BE_SWAP32(w1);
		}

		(void) emlxs_fwrite((uint8_t *)wptr, 4, 1, fpDmpFile);
	}

	emlxs_fflush(fpDmpFile);

	return (0);

} /* emlxs_dump_word_dmpfile() */


static uint32_t
emlxs_dump_port_block(
	emlxs_file_t *fpDmpFile,
	uint8_t *pBuffer,
	uint32_t bufferLen,
	DUMP_TABLE_ENTRY entry,
	int fSwap)
{
	uint32_t status;
	uint32_t w;
	uint8_t b;

	if (!fpDmpFile) {
		return (1);
	}

	/* Write Argument SID to the DMP File */
	b = (uint8_t)entry.un.PortBlock.un.s.sid;
	emlxs_fputc(b, fpDmpFile);

#ifdef EMLXS_LITTLE_ENDIAN
	/* Write Buffer Length to the DMP File */
	w = entry.un.PortBlock.un.s.bc;
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x00FF0000) >> 16);
	emlxs_fputc(b, fpDmpFile);

	/* Write address to the DMP File */
	w = entry.un.PortBlock.un.s.addr;
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x00FF0000) >> 16);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0xFF000000) >> 24);
	emlxs_fputc(b, fpDmpFile);
#endif /* EMLXS_LITTLE_ENDIAN */

#ifdef EMLXS_BIG_ENDIAN
	/* Write Buffer Length to the DMP File */
	w = entry.un.PortBlock.un.s.bc;
	b = (uint8_t)((w & 0x00FF0000) >> 16);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);

	/* Write address to the DMP File */
	w = entry.un.PortBlock.un.s.addr;
	b = (uint8_t)((w & 0xFF000000) >> 24);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x00FF0000) >> 16);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
#endif /* EMLXS_BIG_ENDIAN */

	status =
	    emlxs_dump_word_dmpfile(fpDmpFile, pBuffer, bufferLen, fSwap);

	emlxs_fflush(fpDmpFile);

	return (status);

} /* emlxs_dump_port_block() */


static uint32_t
emlxs_dump_port_struct(
	emlxs_file_t *fpDmpFile,
	uint8_t *pBuffer,
	uint32_t bufferLen,
	DUMP_TABLE_ENTRY entry,
	int fSwap)
{
	uint32_t status;
	uint32_t w;
	uint8_t b;

	if (!fpDmpFile) {
		return (1);
	}

	/* Write Argument SID to the DMP File */
	b = (uint8_t)entry.un.PortStruct.un.s.sid;
	emlxs_fputc(b, fpDmpFile);

	/* Write Element Length to the DMP File */
	b = (uint8_t)entry.un.PortStruct.un.s.length;
	emlxs_fputc(b, fpDmpFile);

#ifdef EMLXS_LITTLE_ENDIAN
	/* Write Element Count to the DMP File */
	w = entry.un.PortStruct.un.s.count;
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);

	/* Write Address to the DMP File */
	w = entry.un.PortStruct.un.s.addr;
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x00FF0000) >> 16);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0xFF000000) >> 24);
	emlxs_fputc(b, fpDmpFile);
#endif /* EMLXS_LITTLE_ENDIAN */

#ifdef EMLXS_BIG_ENDIAN
	/* Write Element Count to the DMP File */
	w = entry.un.PortStruct.un.s.count;
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);

	/* Write Address to the DMP File */
	w = entry.un.PortStruct.un.s.addr;
	b = (uint8_t)((w & 0xFF000000) >> 24);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x00FF0000) >> 16);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
#endif /* EMLXS_BIG_ENDIAN */

	status =
	    emlxs_dump_word_dmpfile(fpDmpFile, pBuffer, bufferLen, fSwap);

	emlxs_fflush(fpDmpFile);

	return (status);

} /* emlxs_dump_port_struct() */


static uint32_t
emlxs_dump_host_block(
	emlxs_file_t *fpDmpFile,
	uint8_t *pBuffer,
	uint32_t bufferLen,
	uint8_t sid,
	char *pSidLegend,
	char *pLidLegend,
	int fSwap)
{
	uint32_t status;
	uint32_t length;
	uint8_t byte;

	if (!fpDmpFile) {
		return (1);
	}

	/* Write Legend SID to the DMP File */
	emlxs_fputc(SID_LEGEND, fpDmpFile);

	/* Write Argument SID to the DMP File */
	emlxs_fputc(sid, fpDmpFile);

	/* Write Legend String to the DMP File, including a Null Byte */
	(void) emlxs_fprintf(fpDmpFile, "%s: %s", pSidLegend, pLidLegend);
	emlxs_fputc(0, fpDmpFile);

	/* Write Argument SID to the DMP File */
	emlxs_fputc(sid, fpDmpFile);

	/* Write Buffer Length to the DMP File */
	length = bufferLen;
#ifdef EMLXS_LITTLE_ENDIAN
	byte = (uint8_t)(length & 0x0000FF);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)((length & 0x00FF00) >> 8);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)((length & 0xFF0000) >> 16);
	emlxs_fputc(byte, fpDmpFile);
#endif /* EMLXS_LITTLE_ENDIAN */

#ifdef EMLXS_BIG_ENDIAN
	byte = (uint8_t)((length & 0xFF0000) >> 16);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)((length & 0x00FF00) >> 8);
	emlxs_fputc(byte, fpDmpFile);
	byte = (uint8_t)(length & 0x0000FF);
	emlxs_fputc(byte, fpDmpFile);
#endif /* EMLXS_BIG_ENDIAN */

	status =
	    emlxs_dump_word_dmpfile(fpDmpFile, pBuffer, bufferLen, fSwap);

	emlxs_fflush(fpDmpFile);

	return (status);

} /* emlxs_dump_host_block() */


static uint32_t
emlxs_dump_host_struct(
	emlxs_file_t *fpDmpFile,
	uint8_t *pBuffer,
	uint32_t bufferLen,
	uint32_t elementLength,
	uint32_t elementCount,
	uint8_t sid,
	char *pSidLegend,
	char *pLidLegend,
	int fSwap)
{
	uint32_t status;
	uint32_t w;
	uint8_t b;

	if (!fpDmpFile) {
		return (1);
	}

	/* Write Legend SID to the DMP File */
	emlxs_fputc(SID_LEGEND, fpDmpFile);

	/* Write Argument SID to the DMP File */
	emlxs_fputc(sid, fpDmpFile);

	/* Write Legend String to the DMP File, including a Null Byte */
	(void) emlxs_fprintf(fpDmpFile, "%s: %s", pSidLegend, pLidLegend);
	emlxs_fputc(0, fpDmpFile);

	/* Write Argument SID to the DMP File */
	emlxs_fputc(sid, fpDmpFile);

	/* Write Element Length to the DMP File */
	b = (uint8_t)elementLength;
	emlxs_fputc(b, fpDmpFile);

	/* Write Element Count to the DMP File */
	w = elementCount;
#ifdef EMLXS_LITTLE_ENDIAN
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
#endif /* EMLXS_LITTLE_ENDIAN */

#ifdef EMLXS_BIG_ENDIAN
	b = (uint8_t)((w & 0x0000FF00) >> 8);
	emlxs_fputc(b, fpDmpFile);
	b = (uint8_t)(w & 0x000000FF);
	emlxs_fputc(b, fpDmpFile);
#endif /* EMLXS_BIG_ENDIAN */

	status =
	    emlxs_dump_word_dmpfile(fpDmpFile, pBuffer, bufferLen, fSwap);

	emlxs_fflush(fpDmpFile);

	return (status);

} /* emlxs_dump_host_struct() */


/* ************************************************************************* */
/* ************************************************************************* */
/* Dump Generators, Mid-Level */
/* ************************************************************************* */
/* ************************************************************************* */

static uint32_t
emlxs_dump_parm_table(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	emlxs_config_t *cfg = &CFG;
	uint32_t status;
	uint32_t i;

	/* vars used to build the Dump String */
	char *buf1;
	char *buf2;

	buf1 = (char *)kmem_zalloc(8192, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(8192, KM_SLEEP);

	/* Driver Parameters Heading */
	(void) snprintf(buf1, 8192,
	    "IDX                     string      Low     "\
	    "High      Def      Cur  Exp  Dyn");

	/* Build the buffer containing all the Driver Params */
	for (i = 0; i < NUM_CFG_PARAM; i++) {
		(void) snprintf(buf2, 8192,
		    "\n  %02x: %25s %8x %8x %8x %8x %4x %4x", i,
		    cfg[i].string, cfg[i].low, cfg[i].hi, cfg[i].def,
		    cfg[i].current, (cfg[i].flags & PARM_HIDDEN) ? 0 : 1,
		    (cfg[i].flags & PARM_DYNAMIC) ? 1 : 0);

		(void) strlcat(buf1, buf2, 8192);
	}

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_DP_TABLE,
	    LEGEND_NULL, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_DP_TABLE,
	    LEGEND_DP_TABLE, LEGEND_NULL);

	kmem_free(buf1, 8192);
	kmem_free(buf2, 8192);

	return (status);

} /* emlxs_dump_parm_table() */


static uint32_t
emlxs_dump_model(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	emlxs_vpd_t *vpd = &VPD;
	uint32_t status;

	/* vars used to build the Dump String */
	char buf1[512];
	char buf2[512];

	/* Write the Model into the buffer */
	(void) snprintf(buf2, sizeof (buf2), "%s", vpd->model);
	(void) strlcpy(buf1, "Model: ", sizeof (buf1));
	(void) strlcat(buf1, buf2, sizeof (buf1));

	/* Write the Model Description into the buffer */
	(void) snprintf(buf2, sizeof (buf2), "%s", vpd->model_desc);
	(void) strlcat(buf1, "\n Description: ", sizeof (buf1));
	(void) strlcat(buf1, buf2, sizeof (buf1));

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_HBA_INFO,
	    LEGEND_HBA_MODEL, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_HBA_INFO,
	    LEGEND_HBA_INFO, LEGEND_HBA_MODEL);

	return (status);

} /* emlxs_dump_model() */


static uint32_t
emlxs_dump_wwn(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;

	/* vars used to build the Dump String */
	char buf1[512];
	char buf2[512];
	int i;
	uint8_t *p;

	/* Write the WWPN into the buffer */
	(void) strlcpy(buf1, "Port WWN: ", sizeof (buf1));
	p = (uint8_t *)&hba->wwpn;
	for (i = 0; i < 7; i++) {
		(void) snprintf(buf2, sizeof (buf2), "%02x:", *p++);
		(void) strlcat(buf1, buf2, sizeof (buf1));
	}
	(void) snprintf(buf2, sizeof (buf2), "%02x", *p++);
	(void) strlcat(buf1, buf2, sizeof (buf1));

	/* Write the WWNN into the buffer */
	(void) strlcat(buf1, "\n Node WWN: ", sizeof (buf1));
	p = (uint8_t *)&hba->wwnn;
	for (i = 0; i < 7; i++) {
		(void) snprintf(buf2, sizeof (buf2), "%02x:", *p++);
		(void) strlcat(buf1, buf2, sizeof (buf1));
	}
	(void) snprintf(buf2, sizeof (buf2), "%02x", *p++);
	(void) strlcat(buf1, buf2, sizeof (buf1));

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_HBA_INFO,
	    LEGEND_HBA_WWN, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_HBA_INFO,
	    LEGEND_HBA_INFO, LEGEND_HBA_WWN);

	return (status);

} /* emlxs_dump_wwn() */


static uint32_t
emlxs_dump_serial_number(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	emlxs_vpd_t *vpd = &VPD;
	uint32_t status;

	/* vars used to build the Dump String */
	char buf1[512];
	char buf2[512];

	/* Write the Serial Number into the buffer */
	(void) snprintf(buf2, sizeof (buf2), "%s", vpd->serial_num);
	(void) strlcpy(buf1, LEGEND_HBA_SN, sizeof (buf1));
	(void) strlcat(buf1, ": ", sizeof (buf1));
	(void) strlcat(buf1, buf2, sizeof (buf1));

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_HBA_INFO,
	    LEGEND_HBA_SN, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_HBA_INFO,
	    LEGEND_HBA_INFO, LEGEND_HBA_SN);

	return (status);

} /* emlxs_dump_serial_number() */


static uint32_t
emlxs_dump_fw_version(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	emlxs_vpd_t *vpd = &VPD;
	uint32_t status;

	char *buf1;
	char *buf2;
	uint32_t buf1_size;
	uint32_t buf2_size;

	buf1_size = 1024;
	buf2_size = 1024;

	buf1 = (char *)kmem_zalloc(buf1_size, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(buf2_size, KM_SLEEP);

	/* Write the Firmware Version into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", vpd->fw_version);
	(void) strlcpy(buf1, LEGEND_HBA_FW_VERSION, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the Operational FW Version into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", vpd->opFwName);
	(void) strlcat(buf1, "\n ", buf1_size);
	(void) strlcat(buf1, LEGEND_HBA_FW_OPVERSION, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the SLI-1 FW Version into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", vpd->sli1FwName);
	(void) strlcat(buf1, "\n ", buf1_size);
	(void) strlcat(buf1, LEGEND_HBA_FW_SLI1VERSION, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the SLI-2 FW Version into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", vpd->sli2FwName);
	(void) strlcat(buf1, "\n ", buf1_size);
	(void) strlcat(buf1, LEGEND_HBA_FW_SLI2VERSION, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the SLI-3 FW Version into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", vpd->sli3FwName);
	(void) strlcat(buf1, "\n ", buf1_size);
	(void) strlcat(buf1, LEGEND_HBA_FW_SLI3VERSION, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the Kernel FW Version into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", vpd->postKernName);
	(void) strlcat(buf1, "\n ", buf1_size);
	(void) strlcat(buf1, LEGEND_HBA_FW_KERNELVERSION, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_HBA_INFO,
	    LEGEND_HBA_FW_VERSION, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_HBA_INFO,
	    LEGEND_HBA_INFO, LEGEND_HBA_FW_VERSION);

	kmem_free(buf1, buf1_size);
	kmem_free(buf2, buf2_size);

	return (status);

} /* emlxs_dump_fw_version() */


static uint32_t
emlxs_dump_boot_version(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	emlxs_vpd_t *vpd = &VPD;
	uint32_t status;
	uint32_t state;

	char *buf1;
	char *buf2;
	uint32_t buf1_size;
	uint32_t buf2_size;

	buf1_size = 1024;
	buf2_size = 1024;

	buf1 = (char *)kmem_zalloc(buf1_size, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(buf2_size, KM_SLEEP);

#ifdef EMLXS_SPARC
	if (strcmp(vpd->fcode_version, "none") == 0)
#else
	if (strcmp(vpd->boot_version, "none") == 0)
#endif /* EMLXS_SPARC */
	{
		state = 2;	/* BOOT_BIOS_NOT_PRESENT */
	} else {
		state = emlxs_boot_code_state(hba);
	}

	/* Write the Boot Bios State into the buffer */
	(void) snprintf(buf2, buf2_size, " %d", state);
	(void) strlcpy(buf1, LEGEND_HBA_BB_STATE, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the Boot Bios Version into the buffer */
	if (state == 2) {
		(void) snprintf(buf2, buf2_size, "%s", "unknown");
	} else {
#ifdef EMLXS_SPARC
		(void) snprintf(buf2, buf2_size, "%s (FCode)",
		    vpd->fcode_version);
#else
		(void) snprintf(buf2, buf2_size, "%s", vpd->boot_version);
#endif /* EMLXS_SPARC */
	}

	(void) strlcat(buf1, "\n ", buf1_size);
	(void) strlcat(buf1, LEGEND_HBA_BB_VERSION, buf1_size);
	(void) strlcat(buf1, ": ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_HBA_INFO,
	    LEGEND_HBA_BB_VERSION, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_HBA_INFO,
	    LEGEND_HBA_INFO, LEGEND_HBA_BB_VERSION);

	kmem_free(buf1, buf1_size);
	kmem_free(buf2, buf2_size);

	return (status);

} /* emlxs_dump_boot_version() */


/* ARGSUSED */
static uint32_t
emlxs_dump_cfg_region4_decoded(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	char *pLidLegend,
	DUMP_WAKE_UP_PARAMS *pBuffer,
	uint32_t ByteCount)
{
	uint32_t status;
	char *buf1;	/* text buffer */
	char *buf2;	/* text buffer */
	uint32_t buf1_size;
	uint32_t buf2_size;

	buf1_size = 1024;
	buf2_size = 1024;

	buf1 = (char *)kmem_zalloc(buf1_size, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(buf2_size, KM_SLEEP);

	/* Write the Initial ID into the buffer */
	(void) snprintf(buf2, buf2_size, "%s: %08x %08x",
	    LEGEND_CR4_INITIAL_LOAD,
	    pBuffer->InitialId[0], pBuffer->InitialId[1]);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the Flags Word into the buffer */
	(void) snprintf(buf2, buf2_size, "\n %s: %08x", LEGEND_CR4_FLAGS,
	    pBuffer->Flags);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the Boot Bios ID into the buffer */
	(void) snprintf(buf2, buf2_size, "\n %s: %08x %08x",
	    LEGEND_CR4_BOOT_BIOS_ID,
	    pBuffer->BootBiosId[0], pBuffer->BootBiosId[1]);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the SLI1 ID into the buffer */
	(void) snprintf(buf2, buf2_size, "\n %s: %08x %08x",
	    LEGEND_CR4_SLI1_ID,
	    pBuffer->Sli1Id[0], pBuffer->Sli1Id[1]);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the SLI2 ID into the buffer */
	(void) snprintf(buf2, buf2_size, "\n %s: %08x %08x",
	    LEGEND_CR4_SLI2_ID,
	    pBuffer->Sli2Id[0], pBuffer->Sli2Id[1]);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the SLI3 ID into the buffer */
	(void) snprintf(buf2, buf2_size, "\n %s: %08x %08x",
	    LEGEND_CR4_SLI3_ID,
	    pBuffer->Sli3Id[0], pBuffer->Sli3Id[1]);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the SLI4 ID into the buffer */
	(void) snprintf(buf2, buf2_size, "\n %s: %08x %08x",
	    LEGEND_CR4_SLI4_ID,
	    pBuffer->Sli4Id[0], pBuffer->Sli4Id[1]);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the Erom ID into the buffer */
	(void) snprintf(buf2, buf2_size, "\n %s: %08x %08x",
	    LEGEND_CR4_EROM_ID,
	    pBuffer->EromId[0], pBuffer->EromId[1]);
	(void) strlcat(buf1, buf2, buf1_size);

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_CONFIG_REGION,
	    LEGEND_CONFIG_REGION_4, 0);

	kmem_free(buf1, buf1_size);
	kmem_free(buf2, buf2_size);

	return (status);

} /* emlxs_dump_cfg_region4_decoded() */


/* ARGSUSED */
uint32_t
emlxs_dump_cfg_region14_decoded(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	char *pLidLegend,
	char *pBuffer,
	uint32_t ByteCount)
{
	uint32_t status;
	char *buf1;	/* text buffer */
	char *buf2;	/* text buffer */
	uint32_t buf1_size;
	uint32_t buf2_size;
	int i;
	uint8_t tag;
	uint16_t length;
	uint16_t length2;
	char mnemonic[4];
	int fDone = FALSE;	/* flag to exit VPD loop */

#ifdef EMLXS_BIG_ENDIAN
	uint32_t *wptr;
	uint32_t w1;
#endif

	buf1_size = 1024;
	buf2_size = 1024;

	buf1 = (char *)kmem_zalloc(buf1_size, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(buf2_size, KM_SLEEP);

/* If Big Endian, swap the data in place, */
/* because it's PCI Data (Little Endian) */
#ifdef EMLXS_BIG_ENDIAN
	wptr = (uint32_t *)pBuffer;
	for (i = 0; i < (int)ByteCount / 4; i++, wptr++) {
		w1 = *wptr;
		*wptr = BE_SWAP32(w1);
	}
#endif /* EMLXS_BIG_ENDIAN */

	/* Decode the VPD Data and write it into the buffer */

	/* CR 26941 */
	/* NOTE: The following code is correct, */
	/* should work, and used to work. */
	/* pBuffer points to char, and the symbol VPD_TAG_82 is 0x82. */
	/* The test is an equality test, not a relational test. */
	/* The compiler should generate an 8 bit test, and */
	/* sign extension does not apply. */
	/* I don't know when or why it stopped working, */
	/* and don't have time to dig. */
	/* The cast fixes it. */

	if (((unsigned char)pBuffer[0]) != VPD_TAG_82) {
		(void) snprintf(buf1, buf1_size,
		    "Bad VPD Data: (w0=0x%08x)", *(uint32_t *)pBuffer);
	} else {	/* begin good data */
		i = 0;
		while (!fDone) {
			tag = pBuffer[i++];
			length = pBuffer[i++];
			length |= (pBuffer[i++] << 8);

			switch (tag) {
			case VPD_TAG_82:
				(void) strncpy(buf2, &pBuffer[i],
				    length > buf2_size ? buf2_size : length);
				buf2[length >
				    (buf2_size - 1) ? (buf2_size -
				    1) : length] = 0;
				(void) strlcat(buf1, "Name: ", buf1_size);
				(void) strlcat(buf1, buf2, buf1_size);
				i += length;
				break;

			case VPD_TAG_90:
				for (;;) {
					mnemonic[0] = pBuffer[i++];
					mnemonic[1] = pBuffer[i++];
					mnemonic[2] = 0;

					if (strcmp(mnemonic, "RV") == 0) {
						fDone = TRUE;
						break;
					}

					if (mnemonic[0] == 0) {
						fDone = TRUE;
						break;
					}

					length2 = pBuffer[i++];
					(void) snprintf(buf2, buf2_size,
					    "\n %s: ", mnemonic);
					(void) strlcat(buf1, buf2,
					    buf1_size);
					(void) strncpy(buf2, &pBuffer[i],
					    length2 >
					    buf2_size ? buf2_size : length2);
					buf2[length2 >
					    (buf2_size - 1) ? (buf2_size -
					    1) : length2] = 0;
					(void) strlcat(buf1, buf2,
					    buf1_size);
					i += length2;
				}
				break;

			default:
				break;

			}	/* end switch */

		}	/* end while */

	}	/* good data */

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_CONFIG_REGION,
	    LEGEND_CONFIG_REGION_14, 0);

	kmem_free(buf1, buf1_size);
	kmem_free(buf2, buf2_size);

	return (status);

} /* emlxs_dump_cfg_region14_decoded() */


static uint32_t
emlxs_dump_cfg_region(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile,
	uint8_t Region,
	char *pLidLegend,
	int fSwap)
{
	uint32_t status;
	uint32_t RetByteCount = 0;	/* returned byte count */
	char *buf1;	/* string ops buffer */
	char *buf2;	/* string ops buffer */
	uint32_t buf1_size;
	uint32_t buf2_size;
	uint32_t *buffer;
	int i;

#ifdef EMLXS_LITTLE_ENDIAN
	fSwap = FALSE;
#endif /* EMLXS_LITTLE_ENDIAN */

	buf1_size = 4096;
	buf2_size = 1024;

	buf1 = (char *)kmem_zalloc(buf1_size, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(buf2_size, KM_SLEEP);

	buffer =
	    (uint32_t *)kmem_zalloc(DUMP_MAX_CONFIG_REGION_LENGTH, KM_SLEEP);

	status =
	    emlxs_read_cfg_region(hba, Region, DUMP_MAX_CONFIG_REGION_LENGTH,
	    &RetByteCount, (uint8_t *)buffer);

	if (status != 0) {
		kmem_free(buffer, DUMP_MAX_CONFIG_REGION_LENGTH);
		kmem_free(buf1, buf1_size);
		kmem_free(buf2, buf2_size);
		return (status);
	}

	/* Write the Data into the buffer */
	for (i = 0; i < (int)RetByteCount / 4; i++) {
		if ((i % 8 == 0) && (i != 0)) {
			(void) strlcat((char *)buf1, "\n ", buf1_size);
		}

		(void) snprintf(buf2, buf2_size, "%08x, ", buffer[i]);
		(void) strlcat((char *)buf1, buf2, buf1_size);
	}

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_CONFIG_REGION,
	    pLidLegend, 0);

	status = emlxs_dump_host_block(fpDmpFile,
	    (uint8_t *)buffer,
	    RetByteCount,
	    SID_CONFIG_REGION, LEGEND_CONFIG_REGION, pLidLegend, fSwap);

	if (Region == 4) {
		status =
		    emlxs_dump_cfg_region4_decoded(hba, fpTxtFile, pLidLegend,
		    (DUMP_WAKE_UP_PARAMS *)buffer, RetByteCount);
	}

	if (Region == 14) {
		status =
		    emlxs_dump_cfg_region14_decoded(hba, fpTxtFile,
		    pLidLegend, (char *)buffer, RetByteCount);
	}

	kmem_free(buffer, DUMP_MAX_CONFIG_REGION_LENGTH);
	kmem_free(buf1, buf1_size);
	kmem_free(buf2, buf2_size);

	return (status);

} /* emlxs_dump_cfg_region() */


static uint32_t
emlxs_dump_cfg_regions(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 0,
	    LEGEND_CONFIG_REGION_0, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 1,
	    LEGEND_CONFIG_REGION_1, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 2,
	    LEGEND_CONFIG_REGION_2, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 3,
	    LEGEND_CONFIG_REGION_3, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 4,
	    LEGEND_CONFIG_REGION_4, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 5,
	    LEGEND_CONFIG_REGION_5, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 6,
	    LEGEND_CONFIG_REGION_6, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 7,
	    LEGEND_CONFIG_REGION_7, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 8,
	    LEGEND_CONFIG_REGION_8, TRUE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 9,
	    LEGEND_CONFIG_REGION_9, TRUE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 10,
	    LEGEND_CONFIG_REGION_10, TRUE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 11,
	    LEGEND_CONFIG_REGION_11, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 12,
	    LEGEND_CONFIG_REGION_12, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 13,
	    LEGEND_CONFIG_REGION_13, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 14,
	    LEGEND_CONFIG_REGION_14, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 15,
	    LEGEND_CONFIG_REGION_15, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 16,
	    LEGEND_CONFIG_REGION_16, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 17,
	    LEGEND_CONFIG_REGION_17, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 18,
	    LEGEND_CONFIG_REGION_18, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 19,
	    LEGEND_CONFIG_REGION_19, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 20,
	    LEGEND_CONFIG_REGION_20, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 21,
	    LEGEND_CONFIG_REGION_21, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 22,
	    LEGEND_CONFIG_REGION_22, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 23,
	    LEGEND_CONFIG_REGION_23, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 24,
	    LEGEND_CONFIG_REGION_24, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 25,
	    LEGEND_CONFIG_REGION_25, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 26,
	    LEGEND_CONFIG_REGION_26, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 27,
	    LEGEND_CONFIG_REGION_27, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 28,
	    LEGEND_CONFIG_REGION_28, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 29,
	    LEGEND_CONFIG_REGION_29, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 30,
	    LEGEND_CONFIG_REGION_30, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 31,
	    LEGEND_CONFIG_REGION_31, FALSE);

	status =
	    emlxs_dump_cfg_region(hba, fpTxtFile, fpDmpFile, 32,
	    LEGEND_CONFIG_REGION_32, FALSE);

	return (status);

} /* emlxs_dump_cfg_regions() */


/*ARGSUSED*/
static uint32_t
emlxs_dump_os_version(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	char *buf1;
	char *buf2;
	uint32_t buf1_size;
	uint32_t buf2_size;

	buf1_size = 1024;
	buf2_size = 1024;

	buf1 = (char *)kmem_zalloc(buf1_size, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(buf2_size, KM_SLEEP);

	/* First, write the OS Name string into the buffer */
	(void) strlcpy(buf1, utsname.sysname, buf1_size);

	/* Second, write the Version Info into the buffer */
	(void) snprintf(buf2, buf2_size, ", %s", utsname.release);
	(void) strlcat(buf1, buf2, buf1_size);

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_REV_INFO,
	    LEGEND_REV_OS_VERSION, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_REV_INFO,
	    LEGEND_REV_INFO, LEGEND_REV_OS_VERSION);

	kmem_free(buf1, buf1_size);
	kmem_free(buf2, buf2_size);

	return (status);

} /* emlxs_dump_os_version() */


/*ARGSUSED*/
static uint32_t
emlxs_dump_drv_version(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	char *buf1;
	char *buf2;
	uint32_t buf1_size;
	uint32_t buf2_size;

	buf1_size = 1024;
	buf2_size = 1024;

	buf1 = (char *)kmem_zalloc(buf1_size, KM_SLEEP);
	buf2 = (char *)kmem_zalloc(buf2_size, KM_SLEEP);

	/* Write the Driver Type into the buffer */
	(void) strlcpy(buf1, "Driver Type: ", buf1_size);
	(void) strlcat(buf1, DUMP_DRV_LEADVILLE, buf1_size);

	/* Write the Driver Name into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", DRIVER_NAME);
	(void) strlcat(buf1, "\n Driver Name: ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	/* Write the Driver Version into the buffer */
	(void) snprintf(buf2, buf2_size, "%s", emlxs_version);
	(void) strlcat(buf1, "\n Driver Version: ", buf1_size);
	(void) strlcat(buf1, buf2, buf1_size);

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_REV_INFO,
	    LEGEND_REV_DRV_VERSION, 0);

	status =
	    emlxs_dump_string_dmpfile(fpDmpFile, buf1, SID_REV_INFO,
	    LEGEND_REV_INFO, LEGEND_REV_DRV_VERSION);

	kmem_free(buf1, buf1_size);
	kmem_free(buf2, buf2_size);

	return (status);

} /* emlxs_dump_drv_version() */


static uint32_t
emlxs_dump_file_create(
	emlxs_hba_t *hba,
	emlxs_file_t ** fpTxtFile,
	emlxs_file_t ** fpDmpFile,
	emlxs_file_t ** fpCeeFile)
{
	if (fpTxtFile) {
		/* Create the Dump Files */
		if ((*fpTxtFile = emlxs_fopen(hba, EMLXS_TXT_FILE)) == NULL) {
			return (1);
		}
	}

	if (fpCeeFile) {
		*fpCeeFile = NULL;

		if ((hba->model_info.vendor_id == PCI_VENDOR_ID_EMULEX &&
		    hba->model_info.device_id == PCI_DEVICE_ID_HORNET) ||
		    (hba->model_info.chip == EMLXS_BE2_CHIP) ||
		    (hba->model_info.chip == EMLXS_BE3_CHIP)) {
			if ((*fpCeeFile =
			    emlxs_fopen(hba, EMLXS_CEE_FILE)) == NULL) {
				emlxs_fdelete(*fpTxtFile);
				return (1);
			}
		}
	}

	if (fpDmpFile) {
		if ((*fpDmpFile = emlxs_fopen(hba, EMLXS_DMP_FILE)) == NULL) {
			emlxs_fdelete(*fpTxtFile);
			emlxs_fdelete(*fpCeeFile);
			return (1);
		}

		/* Initialize the DMP File */
		/* Write the single-byte Dump Identification */
		/* SID to the DMP File */
#ifdef EMLXS_LITTLE_ENDIAN
		emlxs_fputc(SID_DUMP_ID_LE, *fpDmpFile);
#endif /* EMLXS_LITTLE_ENDIAN */

#ifdef EMLXS_BIG_ENDIAN
		emlxs_fputc(SID_DUMP_ID_BE, *fpDmpFile);
#endif /* EMLXS_BIG_ENDIAN */

		emlxs_fputc(SID_NULL, *fpDmpFile);
		emlxs_fputc(SID_NULL, *fpDmpFile);
		emlxs_fputc(SID_NULL, *fpDmpFile);
		emlxs_fflush(*fpDmpFile);
	}

	return (0);

} /* emlxs_dump_file_create() */


static uint32_t
emlxs_dump_file_terminate(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile,
	emlxs_file_t *fpCeeFile)
{

	if (fpTxtFile) {
		/* Write a suitable string to the Dump TXT File */
		(void) emlxs_fprintf(fpTxtFile, "Dump File End\n");
		emlxs_fflush(fpTxtFile);
	}

	if (fpCeeFile) {
		if (hba->model_info.vendor_id == PCI_VENDOR_ID_EMULEX &&
		    hba->model_info.device_id == PCI_DEVICE_ID_HORNET) {
			(void) emlxs_fprintf(fpCeeFile, "Dump File End\n");
		}

		emlxs_fflush(fpCeeFile);
	}

	/* Write the single-byte Dump Termination SID to the DMP File */
	if (fpDmpFile) {
		emlxs_fputc(SID_DUMP_TERM, fpDmpFile);
		emlxs_fflush(fpDmpFile);
	}


	return (0);

} /* emlxs_dump_file_terminate() */


static uint32_t
emlxs_dump_file_close(
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile,
	emlxs_file_t *fpCeeFile)
{

	if (fpTxtFile) {
		(void) emlxs_fclose(fpTxtFile);
	}

	if (fpCeeFile) {
		(void) emlxs_fclose(fpCeeFile);
	}

	if (fpDmpFile) {
		(void) emlxs_fclose(fpDmpFile);
	}

	return (0);

} /* emlxs_dump_file_close() */


/* ************************************************************************* */
/* ************************************************************************* */
/* Dump Generators, High Level */
/* ************************************************************************* */
/* ************************************************************************* */


static uint32_t
emlxs_dump_rev_info(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	(void) emlxs_dump_os_version(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_drv_version(hba, fpTxtFile, fpDmpFile);
	return (0);

} /* emlxs_dump_rev_info() */


/* ARGSUSED */
static uint32_t
emlxs_dump_hba_info(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile,
	uint32_t dump_type)
{
	(void) emlxs_dump_model(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_wwn(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_serial_number(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_fw_version(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_boot_version(hba, fpTxtFile, fpDmpFile);


	return (0);

} /* emlxs_dump_hba_info() */


/* ************************************************************************* */
/* emlxs_dump_table_check */
/* Examine Dump Table, and determine its size. */
/* Count and include ID SIDs, and the TERM SID, */
/* but not the Pointer at Addr 654. */
/* See comments for CC_DUMP_USE_ALL_TABLES for additional description. */
/* ************************************************************************* */
static uint32_t
emlxs_dump_table_check(
	emlxs_hba_t *hba,
	uint32_t *pSize)
{
	emlxs_port_t *port = &PPORT;
	int fDone = FALSE;	/* loop control flag */
	uint32_t tableSize = 0;	/* dump table size (word count) */
	MAILBOX *mb;
	MAILBOXQ *mbq;
	uint32_t DumpTableAddr;
	DUMP_TABLE_ENTRY entry;

	*pSize = 0;

	/* Read 1 word from low memory at address 654; */
	/* save the returned Dump Table Base Address */

	mbq =
	    (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
	mb = (MAILBOX *) mbq;

	/* Read the dump table address */
	emlxs_mb_dump(hba, mbq, 0x654, 1);
	if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
		    "Unable to read dump table address. "\
		    "offset=0x654 status=%x",
		    mb->mbxStatus);

		kmem_free(mbq, sizeof (MAILBOXQ));
		return (1);
	}

	DumpTableAddr = mb->un.varDmp.resp_offset;

	if (DumpTableAddr == 0) {
		kmem_free(mbq, sizeof (MAILBOXQ));
		return (1);
	}

	/* Now loop reading Dump Table Entries.. */
	/* break out when we see a Terminator SID */
	while (!fDone) {
		emlxs_mb_dump(hba, mbq, DumpTableAddr, 2);
		if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
		    MBX_SUCCESS) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
			    "Unable to read dump table entry. "\
			    "offset=%x status=%x",
			    DumpTableAddr, mb->mbxStatus);

			kmem_free(mbq, sizeof (MAILBOXQ));
			return (1);
		}

		entry.un.PortBlock.un.w[0] = mb->un.varWords[4];

		switch (entry.un.PortBlock.un.s.sid) {
		/* New Dump Table */
		case SID_ID01:
			tableSize++;
			DumpTableAddr += 4;
			break;

#ifdef CC_DUMP_USE_ALL_TABLES
		/* New Dump Table */
		case SID_ID02:
		case SID_ID03:
			tableSize++;
			DumpTableAddr += 4;
			break;
#else
		/* New Dump Table */
		case SID_ID02:
		case SID_ID03:
			tableSize++;
			fDone = TRUE;
			break;
#endif /* CC_DUMP_USE_ALL_TABLES */

		/* Dump Table(s) Termination - all done */
		case SID_TERM:
			tableSize++;
			fDone = TRUE;
			break;

			/* Dump Table Entry */
		default:
			tableSize += 2;
			DumpTableAddr += 8;
			break;
		}

	}	/* end while */

	*pSize = (tableSize * 4); /* return the total Dump Table size */

	kmem_free(mbq, sizeof (MAILBOXQ));
	return (0);

} /* emlxs_dump_table_check() */


/* ************************************************************************ */
/* emlxs_dump_table_read */
/* Read the Dump Table and store it, for use */
/* subsequently in emlxs_dump_hba_memory. */
/* See comments for CC_DUMP_USE_ALL_TABLES for additional description. */
/* ************************************************************************ */
static uint32_t
emlxs_dump_table_read(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	uint32_t **ppDumpTable,
	uint32_t *pDumpTableSize)
{
	emlxs_port_t *port = &PPORT;
	uint32_t status = 0;
	int fDone = FALSE;
	MAILBOXQ *mbq;
	MAILBOX *mb;
	uint32_t *pDumpTableEntry;
	uint32_t DumpTableAddr;
	DUMP_TABLE_ENTRY entry;

	char buf2[256];
	char *buf1;
	uint32_t size = (32 * 1024);

	/* First, check the dump table and if valid, get its size */
	status = emlxs_dump_table_check(hba, pDumpTableSize);
	if (status != 0) {
		return (status);
	}

	buf1 = (char *)kmem_zalloc(size, KM_SLEEP);

	/* Allocate a buffer to hold the Dump Table */
	*ppDumpTable = (uint32_t *)kmem_zalloc(*pDumpTableSize, KM_SLEEP);

	pDumpTableEntry = *ppDumpTable;

	/* Read 1 word from low memory at address 654; */
	/* save the returned Dump Table Base Address */
	mbq =
	    (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);

	mb = (MAILBOX *) mbq;

	/* Read the dump table address */
	emlxs_mb_dump(hba, mbq, 0x654, 1);
	if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
		    "Unable to read dump table address. "\
		    "offset=0x654 status=%x",
		    mb->mbxStatus);

		kmem_free(buf1, size);
		kmem_free(mbq, sizeof (MAILBOXQ));

		kmem_free(*ppDumpTable, *pDumpTableSize);
		*pDumpTableSize = 0;
		*ppDumpTable = NULL;

		return (1);
	}

	DumpTableAddr = mb->un.varDmp.resp_offset;

	if (DumpTableAddr == 0) {
		kmem_free(buf1, size);
		kmem_free(mbq, sizeof (MAILBOXQ));

		kmem_free(*ppDumpTable, *pDumpTableSize);
		*pDumpTableSize = 0;
		*ppDumpTable = NULL;

		return (1);
	}


	/* Now loop reading Dump Table Entries.. */
	/* break out when we see a Terminator SID */
	while (!fDone) {
		emlxs_mb_dump(hba, mbq, DumpTableAddr, 2);
		if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
		    MBX_SUCCESS) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
			    "Unable to read dump table entry. "\
			    "offset=%x status=%x",
			    DumpTableAddr, mb->mbxStatus);

			kmem_free(buf1, size);
			kmem_free(mbq, sizeof (MAILBOXQ));

			kmem_free(*ppDumpTable, *pDumpTableSize);
			*pDumpTableSize = 0;
			*ppDumpTable = NULL;

			return (1);
		}

		(void) snprintf(buf2, sizeof (buf2), "\n Addr=%08x: ",
		    mb->un.varDmp.base_adr);
		(void) strlcat(buf1, buf2, size);

		entry.un.PortBlock.un.w[0] = mb->un.varWords[4];
		*pDumpTableEntry++ = mb->un.varWords[4];

		switch (entry.un.PortBlock.un.s.sid) {
			/* New Dump Table */
		case SID_ID01:
			(void) snprintf(buf2, sizeof (buf2), "w0=%08x",
			    entry.un.PortBlock.un.w[0]);
			(void) strlcat(buf1, buf2, size);
			DumpTableAddr += 4;
			break;

#ifdef CC_DUMP_USE_ALL_TABLES
		/* New Dump Table */
		case SID_ID02:
		case SID_ID03:
			(void) snprintf(buf2, sizeof (buf2), "w0=%08x",
			    entry.un.PortBlock.un.w[0]);
			(void) strlcat(buf1, buf2, size);
			DumpTableAddr += 4;
			break;
#else
			/* New Dump Table */
		case SID_ID02:
		case SID_ID03:
			(void) snprintf(buf2, sizeof (buf2), "w0=%08x",
			    entry.un.PortBlock.un.w[0]);
			(void) strlcat(buf1, buf2, size);
			fDone = TRUE;
			break;
#endif /* CC_DUMP_USE_ALL_TABLES */

			/* Dump Table(s) Termination - all done */
		case SID_TERM:
			(void) snprintf(buf2, sizeof (buf2), "w0=%08x",
			    entry.un.PortBlock.un.w[0]);
			(void) strlcat(buf1, buf2, size);
			fDone = TRUE;
			break;

			/* Dump Table Entry */
		default:
			entry.un.PortBlock.un.w[1] = mb->un.varWords[5];
			*pDumpTableEntry++ = mb->un.varWords[5];

			(void) snprintf(buf2, sizeof (buf2), "w0=%08x, w1=%08x",
			    entry.un.PortBlock.un.w[0],
			    entry.un.PortBlock.un.w[1]);
			(void) strlcat(buf1, buf2, size);
			DumpTableAddr += 8;
			break;
		}

	}	/* end while */

	status =
	    emlxs_dump_string_txtfile(fpTxtFile, buf1, LEGEND_HBA_MEM_DUMP,
	    LEGEND_HBA_MEM_DUMP_TABLE, 0);

	kmem_free(buf1, size);
	kmem_free(mbq, sizeof (MAILBOXQ));

	if (status != 0) {
		kmem_free(*ppDumpTable, *pDumpTableSize);
		*pDumpTableSize = 0;
		*ppDumpTable = NULL;

		return (status);
	}

	return (0);

} /* emlxs_dump_table_read() */


/* ************************************************************************* */
/* emlxs_dump_hba_memory */
/* Guided by the Dump Table previously read in, */
/* generate the Port Memory Dump. */
/* See comments for CC_DUMP_USE_ALL_TABLES for additional description. */
/* ************************************************************************* */
static uint32_t
emlxs_dump_hba_memory(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile,
	uint32_t *pDumpTable)
{
	emlxs_port_t *port = &PPORT;
	uint32_t status = 0;
	int fDone = FALSE;
	DUMP_TABLE_ENTRY entry;
	MAILBOXQ *mbq;
	MAILBOX *mb;
	uint32_t byteCount;
	uint32_t byteCountRem;
	uint8_t *pBuf;
	uint8_t *p1;
	uint32_t portAddr;
	int fSwap = FALSE;
	uint32_t offset = 0;
	uint32_t wcount;
	uint32_t total = 0;

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	mbq =
	    (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);

	mb = (MAILBOX *) mbq;

	/* loop reading Dump Table Entries.. break out when */
	/* we see a Terminator SID */
	while (!fDone) {
		entry.un.PortBlock.un.w[0] = *pDumpTable++;

		switch (entry.un.PortBlock.un.s.sid) {

			/* New Dump Table */
		case SID_ID01:
			break;

#ifdef CC_DUMP_USE_ALL_TABLES
			/* New Dump Table */
		case SID_ID02:
		case SID_ID03:
			break;
#else
			/* New Dump Table */
		case SID_ID02:
		case SID_ID03:
			fDone = TRUE;
			break;
#endif /* CC_DUMP_USE_ALL_TABLES */

			/* Dump Table(s) Termination - all done */
		case SID_TERM:
			fDone = TRUE;
			break;

		default:
			/* Dump Table Entry */
			entry.un.PortBlock.un.w[1] = *pDumpTable++;

#ifdef CC_DUMP_FW_BUG_1
			if (entry.un.PortBlock.un.w[1] == 0x3E0000) {
				break;
			}
#endif /* CC_DUMP_FW_BUG_1 */

			/* Check if indirect address, and */
			/* obtain the new address if so */
			if ((entry.un.PortBlock.un.s.addr & 0x80000000) != 0) {
				offset =
				    (entry.un.PortBlock.un.s.
				    addr & 0x01FFFFFF);
				emlxs_mb_dump(hba, mbq, offset, 1);
				if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT,
				    0) != MBX_SUCCESS) {
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_init_debug_msg,
					    "Unable to read dump table entry. "\
					    "offset=%x status=%x",
					    offset, mb->mbxStatus);

					kmem_free(mbq, sizeof (MAILBOXQ));
					return (1);
				}

				/* replace the indirect address in the */
				/* Dump Table */
				entry.un.PortBlock.un.s.addr =
				    mb->un.varWords[4];
			}

			/* determine byte count to dump */
			byteCount = entry.un.PortBlock.un.s.bc;
			if (entry.un.PortBlock.un.s.sid & SID_MULT_ELEM) {
				if (entry.un.PortStruct.un.s.count == 0) {
					byteCount =
					    256 *
					    entry.un.PortStruct.un.s.length;
				} else {
					byteCount =
					    entry.un.PortStruct.un.s.count *
					    entry.un.PortStruct.un.s.length;
				}
			}

			total += byteCount;
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
			    "Dump: addr=%x count=%d total=%d", offset,
			    byteCount, total);

			/* allocate a buffer to receive the dump data */
			pBuf = (uint8_t *)kmem_zalloc(byteCount, KM_SLEEP);

			/* loop issuing MBX commands, 18x measly words at */
			/* a time */

			/* init vars */
			byteCountRem = byteCount;
			p1 = pBuf;
			portAddr = entry.un.PortBlock.un.s.addr;

			for (;;) {
				if (byteCountRem == 0) {
					break;
				}

				wcount =
				    (byteCountRem / 4 >=
				    0x18) ? 0x18 : (byteCountRem / 4);
				emlxs_mb_dump(hba, mbq, portAddr, wcount);
				if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT,
				    0) != MBX_SUCCESS) {
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_init_debug_msg,
					    "Unable to read dump table entry."\
					    " offset=%x wc=%d status=%x",
					    portAddr, wcount, mb->mbxStatus);
					break;
				}

				bcopy((uint8_t *)&mb->un.varWords[4], p1,
				    (mb->un.varDmp.word_cnt * 4));

				byteCountRem -= (mb->un.varDmp.word_cnt * 4);
				p1 += (mb->un.varDmp.word_cnt * 4);
				portAddr += (mb->un.varDmp.word_cnt * 4);

			}	/* end for */

			if (status == 0) {
				if (entry.un.PortBlock.un.s.
				    sid & SID_MULT_ELEM) {
					status =
					    emlxs_dump_port_struct(fpDmpFile,
					    pBuf, byteCount, entry, fSwap);
				} else {
					status =
					    emlxs_dump_port_block(fpDmpFile,
					    pBuf, byteCount, entry, fSwap);
				}
			}

			if (pBuf) {
				kmem_free(pBuf, byteCount);
			}

			break;

		}	/* end switch */

	}	/* end while */

	kmem_free(mbq, sizeof (MAILBOXQ));

	return (status);

} /* emlxs_dump_hba_memory() */


static uint32_t
emlxs_dump_hba(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status = 0;
	uint32_t *pDumpTable = 0;
	uint32_t DumpTableSize = 0;

	if (hba->sli_mode >= EMLXS_HBA_SLI4_MODE) {
		return (1);
	}

	/* HBA should be in WARM state here */
	status =
	    emlxs_dump_table_read(hba, fpTxtFile, &pDumpTable,
	    &DumpTableSize);
	if (status) {
		return (status);
	}

	status = emlxs_dump_hba_memory(hba, fpDmpFile, pDumpTable);

	if (pDumpTable != 0) {
		kmem_free(pDumpTable, DumpTableSize);
	}

	return (status);

} /* emlxs_dump_hba() */


/* ************************************************************************* */
/* emlxs_dump_drv_region */
/* Common subroutine for all the Dump_Sli"Structures" Routines */
/* NOTE: This routine does not free pBuf. This is by design. */
/* The caller does it. */
/* ************************************************************************* */
static uint32_t
emlxs_dump_drv_region(
	emlxs_hba_t *hba,
	uint32_t regionId,
	uint8_t **pBuf,
	uint32_t *pBufLen)
{  /* ptr to length of buffer */
	uint32_t status;
	uint32_t size;

	*pBuf = NULL;
	*pBufLen = 0;

	size = 0;
	status = emlxs_get_dump_region(hba, regionId, NULL, &size);

	if (status != 0) {
		return (1);
	}

	/* Now that we know the required length, request the actual data */
	*pBuf = (uint8_t *)kmem_zalloc(size, KM_SLEEP);

	status = emlxs_get_dump_region(hba, regionId, *pBuf, &size);

	if (status != 0) {
		kmem_free(*pBuf, size);
		*pBuf = NULL;

		return (1);
	}

	*pBufLen = size;

	return (status);

} /* emlxs_dump_drv_region() */


static uint32_t
emlxs_dump_sli_regs(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	status = emlxs_dump_drv_region(hba, DR_SLI_REGS, &pBuf, &bufLen);

	if (status != 0) {
		return (status);
	}

	status =
	    emlxs_dump_host_block(fpDmpFile, pBuf, bufLen, SID_SLI_REGS,
	    LEGEND_SLI_STRUCTURES, LEGEND_SLI_REGS, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_sli_regs() */


static uint32_t
emlxs_dump_slim(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile,
	uint32_t dump_type)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	status = emlxs_dump_drv_region(hba, DR_SLIM, &pBuf, &bufLen);

	if (status != 0) {
		return (status);
	}

	/* The SLIM Dump is only useful if it's a */
	/* Driver-Initiated dump, say, after a HW Error */
	if (dump_type == DUMP_TYPE_DRIVER) {
		status =
		    emlxs_dump_word_txtfile(fpTxtFile, (uint32_t *)pBuf,
		    0x40, LEGEND_SLI_STRUCTURES, LEGEND_SLIM);
	}

	status =
	    emlxs_dump_host_block(fpDmpFile, pBuf, bufLen, SID_SLIM,
	    LEGEND_SLI_STRUCTURES, LEGEND_SLIM, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_slim() */


static uint32_t
emlxs_dump_pcb(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	status = emlxs_dump_drv_region(hba, DR_PCB, &pBuf, &bufLen);
	if (status != 0) {
		return (status);
	}

	status =
	    emlxs_dump_host_block(fpDmpFile, pBuf, bufLen, SID_PCB,
	    LEGEND_SLI_STRUCTURES, LEGEND_PCB, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_pcb() */


static uint32_t
emlxs_dump_mbox(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	status = emlxs_dump_drv_region(hba, DR_MBX, &pBuf, &bufLen);
	if (status != 0) {
		return (status);
	}

	status =
	    emlxs_dump_host_block(fpDmpFile, pBuf, bufLen, SID_MBX,
	    LEGEND_SLI_STRUCTURES, LEGEND_MBX, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_mbox() */


static uint32_t
emlxs_dump_host_pointers(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	status = emlxs_dump_drv_region(hba, DR_HOST_PTRS, &pBuf, &bufLen);
	if (status != 0) {
		return (status);
	}

	status =
	    emlxs_dump_host_block(fpDmpFile, pBuf, bufLen, SID_HOST_PTRS,
	    LEGEND_SLI_STRUCTURES, LEGEND_HOST_PTRS, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_host_pointers() */


static uint32_t
emlxs_dump_port_pointers(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	status = emlxs_dump_drv_region(hba, DR_PORT_PTRS, &pBuf, &bufLen);
	if (status != 0) {
		return (status);
	}

	status =
	    emlxs_dump_host_block(fpDmpFile, pBuf, bufLen, SID_PORT_PTRS,
	    LEGEND_SLI_STRUCTURES, LEGEND_PORT_PTRS, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_port_pointers() */


static uint32_t
emlxs_dump_rings(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	status = emlxs_dump_drv_region(hba, DR_RINGS, &pBuf, &bufLen);
	if (status != 0) {
		return (status);
	}

	status =
	    emlxs_dump_host_struct(fpDmpFile, pBuf, bufLen, sizeof (IOCB),
	    bufLen / sizeof (IOCB), SID_RINGS, LEGEND_SLI_STRUCTURES,
	    LEGEND_RINGS, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_rings() */


static uint32_t
emlxs_dump_drv_internals(
	emlxs_hba_t *hba,
	emlxs_file_t *fpDmpFile)
{
	uint32_t status;
	uint8_t *pBuf;	/* ptr to data buffer to receive Dump Region Data */
	uint32_t bufLen = 0;	/* length of buffer */
	int fSwap = FALSE;	/* flag to pass to emlxs_dump_word_dmpfile */

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (!fpDmpFile) {
		return (1);
	}

	status = emlxs_dump_drv_region(hba, DR_INTERNAL, &pBuf, &bufLen);
	if (status != 0) {
		return (status);
	}

	status =
	    emlxs_dump_host_block(fpDmpFile, pBuf, bufLen, SID_INTERNAL_SOL,
	    LEGEND_SLI_STRUCTURES, LEGEND_DRIVER_SPEC, fSwap);

	kmem_free(pBuf, bufLen);

	return (status);

} /* emlxs_dump_drv_internals() */


static uint32_t
emlxs_dump_sli_interface(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile,
	uint32_t dump_type)
{

	if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
		/* HBA should be in OFFLINE state here */

		(void) emlxs_dump_sli_regs(hba, fpDmpFile);
		(void) emlxs_dump_slim(hba, fpTxtFile, fpDmpFile, dump_type);
		(void) emlxs_dump_pcb(hba, fpDmpFile);
		(void) emlxs_dump_mbox(hba, fpDmpFile);
		(void) emlxs_dump_host_pointers(hba, fpDmpFile);
		(void) emlxs_dump_port_pointers(hba, fpDmpFile);
		(void) emlxs_dump_rings(hba, fpDmpFile);
	}

	(void) emlxs_dump_drv_internals(hba, fpDmpFile);

	return (0);

} /* emlxs_dump_sli_interface() */


static uint32_t
emlxs_dump_menlo_log(
	emlxs_hba_t *hba,
	emlxs_file_t *fpCeeFile)
{
	uint32_t RmStatus;
	int i, j;
	int isWrapped = FALSE;
	char buf1[2048] = { 0 };
	char buf2[2048] = { 0 };

	/* Get Config Command vars */
	menlo_get_config_rsp_t GcBuf;
	menlo_get_config_rsp_t *pGcBuf = &GcBuf;

	/* Get Log Config Command vars */
	uint32_t LcBufSize;
	menlo_rsp_t *pLcBuf = NULL;
	uint32_t NumLogs;
	menlo_log_t *pLcEntry;

	/* Get Log Data Command vars */
	uint32_t LdBufSize;
	menlo_rsp_t *pLdBuf = NULL;
	uint16_t Head;
	uint8_t *pLogEntry;
	char *pLogString;

	/* Get Panic Log Command vars */
	uint32_t PlBufSize;
	menlo_rsp_t *pPlBuf = NULL;
	uint32_t PanicLogEntryCount;
	uint32_t PanicLogEntrySize;

	if (hba->model_info.vendor_id != PCI_VENDOR_ID_EMULEX ||
	    hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return (DFC_INVALID_ADAPTER);
	}

	/* First, issue a GetConfig command, which gives us */
	/* the Log Config and Panic Log sizes */

	RmStatus =
	    emlxs_menlo_get_cfg(hba, pGcBuf, sizeof (menlo_get_config_rsp_t));

	if (RmStatus != 0) {
		goto done;
	}

	LcBufSize = GcBuf.log_cfg_size + 8;
	PlBufSize = GcBuf.panic_log_size;

	pLcBuf = (menlo_rsp_t *)kmem_zalloc(LcBufSize, KM_SLEEP);

	RmStatus = emlxs_menlo_get_logcfg(hba, pLcBuf, LcBufSize);

	if (RmStatus != 0) {
		goto done;
	}

	buf1[0] = 0;
	RmStatus =
	    emlxs_dump_string_txtfile(fpCeeFile, buf1,
	    LEGEND_MENLO_LOG_CONFIG, LEGEND_NULL, 0);

	NumLogs = pLcBuf->log_cfg.num_logs;
	pLcEntry = (menlo_log_t *)&pLcBuf->log_cfg.data;

	buf1[0] = 0;
	(void) snprintf(buf2, sizeof (buf2), "LogId   Entries   Size   Name");
	(void) strlcat(buf1, buf2, sizeof (buf1));
	(void) snprintf(buf2, sizeof (buf2), "\n-----   -------   ----   ----");
	(void) strlcat(buf1, buf2, sizeof (buf1));

	RmStatus = emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);

	for (i = 0; i < (int)NumLogs; i++) {
		buf1[0] = 0;
		(void) snprintf(buf2, sizeof (buf2),
		    "\n %2d      %4d    %4d    %s",
		    pLcEntry[i].id,
		    pLcEntry[i].num_entries,
		    pLcEntry[i].entry_size, pLcEntry[i].name);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		RmStatus =
		    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);
	}

	/* Now issue a series of GetLogData commands, */
	/* which gives us the actual Logs */

	for (i = 0; i < (int)NumLogs; i++) {
		LdBufSize =
		    (pLcEntry[i].num_entries *pLcEntry[i].entry_size) + 8;

		pLdBuf = (menlo_rsp_t *)kmem_zalloc(LdBufSize, KM_SLEEP);

		RmStatus = emlxs_menlo_get_log(hba, i, pLdBuf, LdBufSize);

		if (RmStatus != 0) {
			goto done;
		}

		/* print a caption for the current log */
		buf1[0] = 0;
		(void) snprintf(buf2, sizeof (buf2), "\n\nLog %d:", i);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		(void) snprintf(buf2, sizeof (buf2), " %s", pLcEntry[i].name);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		(void) snprintf(buf2, sizeof (buf2), "\n");

		for (j = 0; j < 75; j++) {
			(void) strlcat(buf2, "-", sizeof (buf2));
		}

		(void) strlcat(buf1, buf2, sizeof (buf1));
		RmStatus =
		    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);

		/* check the head entry to determine whether */
		/* the log has wrapped or not */
		Head = pLdBuf->log.head;
		pLogEntry = (uint8_t *)&pLdBuf->log.data;
		pLogString =
		    (char *)&(pLogEntry[Head *pLcEntry[i].entry_size]);

		isWrapped = FALSE;
		if (strlen(pLogString) != 0) {
			isWrapped = TRUE;
		}

		/* if log is wrapped, get entries from the */
		/* Head through the End */
		if (isWrapped) {
			for (j = Head; j < (int)pLcEntry[i].num_entries; j++) {
				pLogString =
				    (char *)&(pLogEntry[j *
				    pLcEntry[i].entry_size]);
				buf1[0] = 0;
				(void) snprintf(buf2, sizeof (buf2),
				    "\n%3d: %s", j, pLogString);
				(void) strlcat(buf1, buf2, sizeof (buf1));
				RmStatus =
				    emlxs_dump_string_txtfile(fpCeeFile, buf1,
				    0, 0, 1);
			}
		}

		/* if wrapped or not, get entries from the Top */
		/* through the Head */
		for (j = 0; j < Head; j++) {
			pLogString =
			    (char *)&(pLogEntry[j * pLcEntry[i].entry_size]);
			buf1[0] = 0;
			(void) snprintf(buf2, sizeof (buf2), "\n%3d: %s", j,
			    pLogString);
			(void) strlcat(buf1, buf2, sizeof (buf1));
			RmStatus =
			    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0,
			    1);
		}
	}	/* end for i */

	/* Now issue a GetPanicLog command, which gives us the Panic Log */

	/* print a caption for the current log */
	(void) strlcpy(buf1, LEGEND_MENLO_LOG_PANIC_REGS, sizeof (buf1));
	buf2[0] = 0;
	for (j = 0; j < 75; j++) {
		(void) strlcat(buf2, "-", sizeof (buf2));
	}
	(void) strlcat(buf1, buf2, sizeof (buf1));
	RmStatus = emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);

	pPlBuf = (menlo_rsp_t *)kmem_zalloc(PlBufSize, KM_SLEEP);

	RmStatus = emlxs_menlo_get_paniclog(hba, pPlBuf, PlBufSize);

	if (RmStatus == 0) {
		buf1[0] = 0;
		(void) snprintf(buf2, sizeof (buf2), "\nType         = %x",
		    pPlBuf->panic_log.type);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		(void) snprintf(buf2, sizeof (buf2), "\nRegsEpc      = %08x",
		    pPlBuf->panic_log.regs_epc);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		(void) snprintf(buf2, sizeof (buf2), "\nRegsCp0Cause = %08x",
		    pPlBuf->panic_log.regs_cp0_cause);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		(void) snprintf(buf2, sizeof (buf2), "\nRegsCp0Stat  = %08x",
		    pPlBuf->panic_log.regs_cp0_status);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		RmStatus =
		    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);

		buf1[0] = 0;
		for (i = 0; i < MENLO_NUM_GP_REGS; i++) {
			(void) snprintf(buf2, sizeof (buf2),
			    "\nRegsGp[%02x]   = %08x", i,
			    pPlBuf->panic_log.regs_gp[i]);
			(void) strlcat(buf1, buf2, sizeof (buf1));
		}
		RmStatus =
		    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);

		buf1[0] = 0;
		(void) snprintf(buf2, sizeof (buf2), "\nLogPresent   = %08x",
		    pPlBuf->panic_log.log_present);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		PanicLogEntryCount = pPlBuf->panic_log.num_entries;
		(void) snprintf(buf2, sizeof (buf2), "\nNumEntries   = %08x",
		    PanicLogEntryCount);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		PanicLogEntrySize = pPlBuf->panic_log.entry_size;
		(void) snprintf(buf2, sizeof (buf2), "\nEntrySize    = %d.",
		    PanicLogEntrySize);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		(void) snprintf(buf2, sizeof (buf2), "\nHead Entry   = %d.",
		    pPlBuf->panic_log.head);
		(void) strlcat(buf1, buf2, sizeof (buf1));
		RmStatus =
		    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);

		/* print a caption for the current log */
		(void) strlcpy(buf1, LEGEND_MENLO_LOG_PANIC_LOGS,
		    sizeof (buf1));
		buf2[0] = 0;
		for (j = 0; j < 75; j++) {
			(void) strlcat(buf2, "-", sizeof (buf2));
		}
		(void) strlcat(buf1, buf2, sizeof (buf2));
		RmStatus =
		    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0, 1);

		/* check the head entry to determine whether the */
		/* log has wrapped or not */
		Head = pPlBuf->panic_log.head;
		pLogEntry = (uint8_t *)&pPlBuf->panic_log.data;
		pLogString = (char *)&(pLogEntry[Head * PanicLogEntrySize]);
		isWrapped = FALSE;
		if (strlen(pLogString) != 0) {
			isWrapped = TRUE;
		}

		/* if log is wrapped, get entries from the */
		/* Head through the End */
		if (isWrapped) {
			for (j = Head; j < (int)PanicLogEntryCount; j++) {
				pLogString =
				    (char *)&(pLogEntry[j *
				    PanicLogEntrySize]);
				buf1[0] = 0;
				(void) snprintf(buf2, sizeof (buf2),
				    "\n%3d: %s", j, pLogString);
				(void) strlcat(buf1, buf2, sizeof (buf2));
				RmStatus =
				    emlxs_dump_string_txtfile(fpCeeFile, buf1,
				    0, 0, 1);
			}
		}
		/* if wrapped or not, get entries from the Top */
		/* through the Head */
		for (j = 0; j < Head; j++) {
			pLogString =
			    (char *)&(pLogEntry[j * PanicLogEntrySize]);
			buf1[0] = 0;
			(void) snprintf(buf2, sizeof (buf2), "\n%3d: %s", j,
			    pLogString);
			(void) strlcat(buf1, buf2, sizeof (buf2));
			RmStatus =
			    emlxs_dump_string_txtfile(fpCeeFile, buf1, 0, 0,
			    1);
		}
	}

	RmStatus = emlxs_dump_string_txtfile(fpCeeFile, "\n\n", 0, 0, 1);

done:

	if (pLdBuf != 0) {
		kmem_free(pLdBuf, LdBufSize);
	}

	if (pLcBuf != 0) {
		kmem_free(pLcBuf, LcBufSize);
	}

	if (pPlBuf != 0) {
		kmem_free(pPlBuf, PlBufSize);
	}

	return (RmStatus);

} /* emlxs_dump_menlo_log() */


static uint32_t
emlxs_dump_saturn_log(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpDmpFile)
{
	emlxs_port_t *port = &PPORT;
	MAILBOXQ *mbq;
	MAILBOX *mb;
	MATCHMAP *mp = NULL;
	uint32_t status;
	uint32_t logSize = 0;
	uintptr_t tempAddress;
	int fSwap = FALSE;
	uint32_t i;
	uint32_t block_size;
	uint32_t offset;

#ifdef EMLXS_BIG_ENDIAN
	fSwap = TRUE;
#endif /* EMLXS_BIG_ENDIAN */

	if (hba->model_info.chip != EMLXS_SATURN_CHIP) {
		return (1);
	}

	mbq =
	    (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);

	mb = (MAILBOX *) mbq;

	/* Step 1: Call MBX_READ_EVENT_LOG_STATUS to get the log size. */
	for (i = 0; i < 10; i++) {
		bzero((void *)mb, MAILBOX_CMD_BSIZE);
		mb->mbxCommand = MBX_READ_EVENT_LOG_STATUS;
		mbq->mbox_cmpl = NULL;

		if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) ==
		    MBX_SUCCESS) {
			break;
		}

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
		    "Unable to read event log status. status=%x",
		    mb->mbxStatus);

		if ((mb->mbxStatus & 0xFFFF) == MBXERR_NOT_SUPPORTED ||
		    (mb->mbxStatus & 0xFFFF) == MBX_DRVR_ERROR) {
			(void) emlxs_dump_string_txtfile(fpTxtFile,
			    NV_LOG_NOT_INCLUDED_IN_DMP,
			    LEGEND_NON_VOLATILE_LOG,
			    LEGEND_NV_LOG_DRIVER_NOT_SUPPORTED, 0);

			kmem_free(mbq, sizeof (MAILBOXQ));
			return (1);
		}

		/* The call to get the log size simply fails. */
		/* Retry up to 10 times. */
		if ((mb->mbxStatus & 0xFFFF) != MBX_BUSY) {
			/* Mailbox fails for some unknown reason. */
			/* Put something in the txt to indicate this case. */
			(void) emlxs_dump_string_txtfile(fpTxtFile,
			    NV_LOG_NOT_INCLUDED_IN_DMP,
			    LEGEND_NON_VOLATILE_LOG,
			    LEGEND_NV_LOG_STATUS_ERROR, 0);

			kmem_free(mbq, sizeof (MAILBOXQ));
			return (1);
		}
	}

	if (i >= 10) {
		(void) emlxs_dump_string_txtfile(fpTxtFile,
		    NV_LOG_NOT_INCLUDED_IN_DMP, LEGEND_NON_VOLATILE_LOG,
		    LEGEND_NV_LOG_STATUS_ERROR, 0);

		kmem_free(mbq, sizeof (MAILBOXQ));
		return (1);
	}

	/* Step 2: Use the log size from step 1 to call MBX_READ_EVENT_LOG */
	logSize = mb->un.varLogStat.size;

	if ((mp = emlxs_mem_buf_alloc(hba, logSize)) == 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
		    "Unable to allocate receive buffer. "
		    "size=%d",
		    logSize);

		kmem_free(mbq, sizeof (MAILBOXQ));
		return (1);
	}

	for (offset = 0; offset < logSize; offset = offset + 1024) {
		if (logSize - offset < 1024) {
			block_size = logSize - offset;
		} else {
			block_size = 1024;
		}

		tempAddress = (uintptr_t)(mp->phys + offset);

		bzero((void *)mb, MAILBOX_CMD_BSIZE);
		mb->mbxCommand = MBX_READ_EVENT_LOG;	/* 0x38 */
		mb->un.varRdEvtLog.read_log = 1;	/* read log */
		mb->un.varRdEvtLog.mbox_rsp = 0;	/* not using Mailbox */
		mb->un.varRdEvtLog.offset = offset;
		mb->un.varRdEvtLog.un.sp64.tus.f.bdeFlags = 0x0;
		mb->un.varRdEvtLog.un.sp64.tus.f.bdeSize = block_size;
		mb->un.varRdEvtLog.un.sp64.addrLow = PADDR_LO(tempAddress);
		mb->un.varRdEvtLog.un.sp64.addrHigh = PADDR_HI(tempAddress);
		mbq->mbox_cmpl = NULL;

		if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
		    MBX_SUCCESS) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
			    "Unable to read event log. status=%x",
			    mb->mbxStatus);

			emlxs_mem_buf_free(hba, mp);
			kmem_free(mbq, sizeof (MAILBOXQ));
			return (1);
		}
	}

	/* Step 3: Dump the log to the DMP file as raw data. */

	/* Write a string to text file to direct the user to the DMP */
	/* file for the actual log. */
	status =
	    emlxs_dump_string_txtfile(fpTxtFile, NV_LOG_INCLUDED_IN_DMP,
	    LEGEND_NON_VOLATILE_LOG, LEGEND_NULL, 0);

	/* Write the real log to the DMP file. */
	EMLXS_MPDATA_SYNC(mp->dma_handle, 0, logSize, DDI_DMA_SYNC_FORKERNEL);

	status =
	    emlxs_dump_host_block(fpDmpFile, mp->virt, logSize,
	    SID_NON_VOLATILE_LOG, LEGEND_NON_VOLATILE_LOG, LEGEND_NULL,
	    fSwap);

#ifdef FMA_SUPPORT
	if (emlxs_fm_check_dma_handle(hba, mp->dma_handle)
	    != DDI_FM_OK) {
		EMLXS_MSGF(EMLXS_CONTEXT,
		    &emlxs_invalid_dma_handle_msg,
		    "dump_saturn_log: hdl=%p",
		    mp->dma_handle);
		status = 1;
	}
#endif  /* FMA_SUPPORT */

	emlxs_mem_buf_free(hba, mp);
	kmem_free(mbq, sizeof (MAILBOXQ));
	return (status);

} /* emlxs_dump_saturn_log() */


static uint32_t
emlxs_dump_tigershark_log(
	emlxs_hba_t *hba,
	emlxs_file_t *fpTxtFile,
	emlxs_file_t *fpCeeFile)
{
	emlxs_port_t *port = &PPORT;
	uint32_t rval = 0;
	uint32_t offset;
	uint32_t log_size;
	uint32_t xfer_size;
	uint32_t buffer_size;
	uint8_t *buffer = NULL;
	uint8_t *bptr;
	uint8_t *payload;
	MAILBOXQ *mbq = NULL;
	MAILBOX4 *mb = NULL;
	MATCHMAP *mp = NULL;
	IOCTL_COMMON_MANAGE_FAT *fat;
	mbox_req_hdr_t *hdr_req;

	if ((hba->model_info.chip != EMLXS_BE2_CHIP) &&
	    (hba->model_info.chip != EMLXS_BE3_CHIP)) {
		return (1);
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
	    "Querying FAT...");

	mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
	    KM_SLEEP);

	mb = (MAILBOX4*)mbq;

	if ((mp = emlxs_mem_buf_alloc(hba, (sizeof (mbox_req_hdr_t) +
	    sizeof (IOCTL_COMMON_MANAGE_FAT) + BE_MAX_XFER_SIZE))) == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "Unable to allocate FAT buffer.");

		rval = 1;
		goto done;
	}

	/* Query FAT */
	mb->un.varSLIConfig.be.embedded = 0;
	mbq->nonembed = (void *)mp;
	mbq->mbox_cmpl = NULL;

	mb->mbxCommand = MBX_SLI_CONFIG;
	mb->mbxOwner = OWN_HOST;

	hdr_req = (mbox_req_hdr_t *)mp->virt;
	hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON;
	hdr_req->opcode = COMMON_OPCODE_MANAGE_FAT;
	hdr_req->timeout = 0;
	hdr_req->req_length = sizeof (IOCTL_COMMON_MANAGE_FAT);

	fat = (IOCTL_COMMON_MANAGE_FAT *)(hdr_req + 1);
	fat->params.request.fat_operation = QUERY_FAT;
	fat->params.request.read_log_offset = 0;
	fat->params.request.read_log_length = 0;
	fat->params.request.data_buffer_size = BE_MAX_XFER_SIZE;

	if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
	    MBX_SUCCESS) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "FAT Query failed. status=%x",
		    mb->mbxStatus);

		rval = 1;
		goto done;
	}

	log_size = fat->params.response.log_size;
	buffer_size = fat->params.response.log_size;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
	    "FAT: log_size=%d", log_size);

	if (buffer_size == 0) {
		goto done;
	}

	if ((buffer = (uint8_t *)kmem_alloc(
	    buffer_size, KM_NOSLEEP)) == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "Unable to allocate log buffer.");

		rval = 1;
		goto done;
	}
	bzero(buffer, buffer_size);

	/* Upload Log */
	bptr = buffer;
	offset = 0;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
	    "Uploading log... (%d bytes)", log_size);

	while (log_size) {
		bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);
		bzero((void *) mp->virt, mp->size);

		xfer_size = min(BE_MAX_XFER_SIZE, log_size);

		mb->un.varSLIConfig.be.embedded = 0;
		mbq->nonembed = (void *)mp;
		mbq->mbox_cmpl = NULL;

		mb->mbxCommand = MBX_SLI_CONFIG;
		mb->mbxOwner = OWN_HOST;

		hdr_req = (mbox_req_hdr_t *)mp->virt;
		hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON;
		hdr_req->opcode = COMMON_OPCODE_MANAGE_FAT;
		hdr_req->timeout = 0;
		hdr_req->req_length =
		    sizeof (IOCTL_COMMON_MANAGE_FAT) + xfer_size;

		fat = (IOCTL_COMMON_MANAGE_FAT *)(hdr_req + 1);
		fat->params.request.fat_operation = RETRIEVE_FAT;
		fat->params.request.read_log_offset = offset;
		fat->params.request.read_log_length = xfer_size;
		fat->params.request.data_buffer_size = BE_MAX_XFER_SIZE;

		if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
		    MBX_SUCCESS) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
			    "Failed to upload log. status=%x",
			    mb->mbxStatus);

			(void) emlxs_dump_string_txtfile(fpTxtFile,
			    NV_LOG_NOT_INCLUDED_IN_FAT,
			    LEGEND_NON_VOLATILE_LOG,
			    LEGEND_NV_LOG_STATUS_ERROR, 0);

			rval = 1;
			goto done;
		}

		payload = (uint8_t *)(&fat->params.response.data_buffer);

		BE_SWAP32_BCOPY(payload, bptr, xfer_size);

		log_size -= xfer_size;
		offset += xfer_size;
		bptr += xfer_size;
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
	    "Log upload complete.");

	/* Write a string to text file to direct the user to the CEE */
	/* file for the actual log. */
	rval =
	    emlxs_dump_string_txtfile(fpTxtFile, NV_LOG_INCLUDED_IN_FAT,
	    LEGEND_NON_VOLATILE_LOG, LEGEND_NULL, 0);


	/* Write the log to the CEE file. */
	/* First word is the log size */
	bptr = buffer + sizeof (uint32_t);
	log_size = buffer_size - sizeof (uint32_t);
	rval = emlxs_dump_word_dmpfile(fpCeeFile, (uint8_t *)bptr,
	    log_size, 0);

done:

	if (mbq) {
		emlxs_mem_put(hba, MEM_MBOX, (void *)mbq);
	}

	if (mp) {
		emlxs_mem_buf_free(hba, mp);
	}

	if (buffer) {
		kmem_free(buffer, buffer_size);
	}

	if (rval == 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "Dump complete.");
	}

	return (rval);

} /* emlxs_dump_tigershark_log() */


extern uint32_t
emlxs_dump_user_event(
	emlxs_hba_t *hba)
{
	emlxs_port_t *port = &PPORT;
	uint32_t status;
	emlxs_file_t *fpTxtFile;
	emlxs_file_t *fpDmpFile;
	emlxs_file_t *fpCeeFile;

	mutex_enter(&EMLXS_DUMP_LOCK);

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
	    "User Event: Firmware core dump initiated...");

	status =
	    emlxs_dump_file_create(hba, &fpTxtFile, &fpDmpFile, &fpCeeFile);
	if (status != 0) {
		mutex_exit(&EMLXS_DUMP_LOCK);
		return (1);
	}

	(void) emlxs_dump_rev_info(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_hba_info(hba, fpTxtFile, fpDmpFile, DUMP_TYPE_USER);
	(void) emlxs_dump_parm_table(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_cfg_regions(hba, fpTxtFile, fpDmpFile);

	if (hba->model_info.chip == EMLXS_SATURN_CHIP) {
		(void) emlxs_set_hba_mode(hba, DDI_ONDI);
		(void) emlxs_dump_saturn_log(hba, fpTxtFile, fpDmpFile);
	}

	if ((hba->model_info.chip == EMLXS_BE2_CHIP) ||
	    (hba->model_info.chip == EMLXS_BE3_CHIP)) {
		(void) emlxs_dump_tigershark_log(hba, fpTxtFile, fpCeeFile);
	}

	if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
		(void) emlxs_set_hba_mode(hba, DDI_DIAGDI);
	}

	(void) emlxs_dump_sli_interface(hba, fpTxtFile, fpDmpFile,
	    DUMP_TYPE_USER);

	if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
		(void) emlxs_set_hba_mode(hba, DDI_WARMDI);
	}

	(void) emlxs_dump_hba(hba, fpTxtFile, fpDmpFile);

	(void) emlxs_set_hba_mode(hba, DDI_ONDI);

	status = emlxs_menlo_set_mode(hba, MENLO_MAINTENANCE_MODE_ENABLE);
	if (status == 0) {
		(void) emlxs_dump_menlo_log(hba, fpCeeFile);
		(void) emlxs_menlo_set_mode(hba,
		    MENLO_MAINTENANCE_MODE_DISABLE);
	}

	(void) emlxs_dump_file_terminate(hba, fpTxtFile, fpDmpFile, fpCeeFile);
	(void) emlxs_dump_file_close(fpTxtFile, fpDmpFile, fpCeeFile);

	mutex_exit(&EMLXS_DUMP_LOCK);
	return (0);

} /* emlxs_dump_user_event() */


extern uint32_t
emlxs_dump_temp_event(
	emlxs_hba_t *hba,
	uint32_t tempType,
	uint32_t temp)
{
	emlxs_port_t *port = &PPORT;
	uint32_t status;
	emlxs_file_t *fpTxtFile;

	/* misc vars */
	char sBuf1[512];	/* general purpose string buffer */
	char sBuf2[256];	/* general purpose string buffer */
	char sBuf3[256];	/* general purpose string buffer */

	if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "Temperature Event: type=%d temp=%d.  "\
		    "Invalid SLI4 event.",
		    tempType, temp);

		return (1);
	}

	mutex_enter(&EMLXS_DUMP_LOCK);

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
	    "Temperature Event: type=%d temp=%d.  "\
	    "Firmware core dump initiated...",
	    tempType, temp);

	status = emlxs_dump_file_create(hba, &fpTxtFile, 0, 0);
	if (status != 0) {
		mutex_exit(&EMLXS_DUMP_LOCK);
		return (1);
	}

	/* Now generate the Dump */
	/* Note: ignore return (status); if one part fails, */
	/* keep trying to dump more stuff. */

	/* Write a warning at the top of the file */
	(void) strlcpy(sBuf1, "WARNING: HBA Temperature Event:\n",
	    sizeof (sBuf1));
	switch (tempType) {
	case TEMP_TYPE_CRITICAL:
		(void) snprintf(sBuf2, sizeof (sBuf2),
		    " Event Type  = %d (Critical)\n", tempType);
		break;
	case TEMP_TYPE_THRESHOLD:
		(void) snprintf(sBuf2, sizeof (sBuf2),
		    " Event Type  = %d (Threshold)\n", tempType);
		break;
	case TEMP_TYPE_NORMAL:
		(void) snprintf(sBuf2, sizeof (sBuf2),
		    " Event Type  = %d (Normal)\n", tempType);
		break;
	default:
		(void) snprintf(sBuf2, sizeof (sBuf2),
		    " Unknown Event Type  = %d\n", tempType);
		break;
	}
	(void) snprintf(sBuf3, sizeof (sBuf3), " Temperature = %d\n\n", temp);
	(void) strlcat(sBuf1, sBuf2, sizeof (sBuf1));
	(void) strlcat(sBuf1, sBuf3, sizeof (sBuf1));

	(void) emlxs_dump_string_txtfile(fpTxtFile, sBuf1, 0, 0, 0);

	(void) emlxs_dump_rev_info(hba, fpTxtFile, NULL);
	(void) emlxs_dump_hba_info(hba, fpTxtFile, NULL, DUMP_TYPE_TEMP);

	(void) emlxs_dump_file_terminate(hba, fpTxtFile, NULL, NULL);
	(void) emlxs_dump_file_close(fpTxtFile, NULL, NULL);

	mutex_exit(&EMLXS_DUMP_LOCK);
	return (0);

} /* emlxs_dump_temp_event() */


extern uint32_t
emlxs_dump_drv_event(
	emlxs_hba_t *hba)
{
	emlxs_port_t *port = &PPORT;
	uint32_t status;
	emlxs_file_t *fpTxtFile;
	emlxs_file_t *fpDmpFile;
	emlxs_file_t *fpCeeFile;

	mutex_enter(&EMLXS_DUMP_LOCK);

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
	    "Dump Event: Firmware core dump initiated...");

	status =
	    emlxs_dump_file_create(hba, &fpTxtFile, &fpDmpFile, &fpCeeFile);
	if (status != 0) {
		mutex_exit(&EMLXS_DUMP_LOCK);
		return (1);
	}

	if (hba->model_info.chip == EMLXS_SATURN_CHIP) {
		(void) emlxs_set_hba_mode(hba, DDI_ONDI);
		(void) emlxs_dump_saturn_log(hba, fpTxtFile, fpDmpFile);
	}

	if ((hba->model_info.chip == EMLXS_BE2_CHIP) ||
	    (hba->model_info.chip == EMLXS_BE3_CHIP)) {
		(void) emlxs_dump_tigershark_log(hba, fpTxtFile, fpCeeFile);
	}

	if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
		(void) emlxs_set_hba_mode(hba, DDI_DIAGDI);
	}

	(void) emlxs_dump_sli_interface(hba, fpTxtFile, fpDmpFile,
	    DUMP_TYPE_DRIVER);

	if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
		(void) emlxs_set_hba_mode(hba, DDI_WARMDI);
	}

	(void) emlxs_dump_hba(hba, fpTxtFile, fpDmpFile);

	if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
		(void) emlxs_set_hba_mode(hba, DDI_ONDI);
	}

	status = emlxs_menlo_set_mode(hba, MENLO_MAINTENANCE_MODE_ENABLE);
	if (status == 0) {
		(void) emlxs_dump_menlo_log(hba, fpCeeFile);
	}

	/* Now generate the rest of the Dump */
	(void) emlxs_dump_rev_info(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_hba_info(hba, fpTxtFile, fpDmpFile, DUMP_TYPE_DRIVER);
	(void) emlxs_dump_parm_table(hba, fpTxtFile, fpDmpFile);
	(void) emlxs_dump_cfg_regions(hba, fpTxtFile, fpDmpFile);

	(void) emlxs_dump_file_terminate(hba, fpTxtFile, fpDmpFile, fpCeeFile);
	(void) emlxs_dump_file_close(fpTxtFile, fpDmpFile, fpCeeFile);

	/* The last step of the Menlo Dump. */
	(void) emlxs_menlo_reset(hba, MENLO_FW_OPERATIONAL);

	(void) emlxs_set_hba_mode(hba, DDI_WARMDI);

	mutex_exit(&EMLXS_DUMP_LOCK);


	return (0);

} /* emlxs_dump_drv_event() */


/* ARGSUSED */
extern void
emlxs_dump_drv_thread(emlxs_hba_t *hba,
	void *arg1, void *arg2)
{
	(void) emlxs_dump_drv_event(hba);

	/* Clear the Dump flag */
	mutex_enter(&EMLXS_PORT_LOCK);
	hba->flag &= ~FC_DUMP_ACTIVE;
	mutex_exit(&EMLXS_PORT_LOCK);

	return;

} /* emlxs_dump_drv_thread() */


/* ARGSUSED */
extern void
emlxs_dump_user_thread(emlxs_hba_t *hba,
	void *arg1, void *arg2)
{
	(void) emlxs_dump_user_event(hba);

	/* Clear the Dump flag */
	mutex_enter(&EMLXS_PORT_LOCK);
	hba->flag &= ~FC_DUMP_ACTIVE;
	mutex_exit(&EMLXS_PORT_LOCK);

	return;

} /* emlxs_dump_user_thread() */


/* ARGSUSED */
extern void
emlxs_dump_temp_thread(emlxs_hba_t *hba,
	void *arg1, void *arg2)
{
	dump_temp_event_t *temp_event = (dump_temp_event_t *)arg1;

	(void) emlxs_dump_temp_event(temp_event->hba, temp_event->type,
	    temp_event->temp);

	/* Free the temp event object */
	kmem_free(temp_event, sizeof (dump_temp_event_t));

	/* Clear the Dump flag */
	mutex_enter(&EMLXS_PORT_LOCK);
	hba->flag &= ~FC_DUMP_ACTIVE;
	mutex_exit(&EMLXS_PORT_LOCK);

	return;

} /* emlxs_dump_temp_thread() */


/* Schedules a dump thread */
/* temp_type and temp are only valid for type=EMLXS_TEMP_DUMP */
extern void
emlxs_dump(emlxs_hba_t *hba, uint32_t type, uint32_t temp_type, uint32_t temp)
{
	emlxs_port_t *port = &PPORT;
	dump_temp_event_t *temp_event = NULL;

	mutex_enter(&EMLXS_PORT_LOCK);

	/* Check if it is safe to dump */
	if (!(hba->flag & FC_DUMP_SAFE)) {
		mutex_exit(&EMLXS_PORT_LOCK);

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "dump: Dump disabled.");

		return;
	}

	/* Check if a dump is already in progess */
	if (hba->flag & FC_DUMP_ACTIVE) {
		mutex_exit(&EMLXS_PORT_LOCK);

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "dump: Dump already in progress.");

		return;
	}

	/* Prepare to schedule dump */
	switch (type) {
	case EMLXS_DRV_DUMP:
	case EMLXS_USER_DUMP:
		break;

	case EMLXS_TEMP_DUMP:
		temp_event = (dump_temp_event_t *)kmem_alloc(
		    sizeof (dump_temp_event_t), KM_NOSLEEP);

		if (temp_event == NULL) {
			mutex_exit(&EMLXS_PORT_LOCK);

			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
			    "dump: Unable to allocate temp object.");

			return;
		}

		temp_event->hba  = hba;
		temp_event->type = temp_type;
		temp_event->temp = temp;
		break;

	default:
		mutex_exit(&EMLXS_PORT_LOCK);

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_dump_msg,
		    "dump: Error: Unknown dump type. (%x)",
		    type);

		return;
	}

	/* Set the Dump-in-progess flag */
	hba->flag |= FC_DUMP_ACTIVE;
	mutex_exit(&EMLXS_PORT_LOCK);

	/* Create a separate thread to run the dump event */
	switch (type) {
	case EMLXS_DRV_DUMP:
		emlxs_thread_spawn(hba, emlxs_dump_drv_thread, NULL, NULL);
		break;

	case EMLXS_TEMP_DUMP:
		emlxs_thread_spawn(hba, emlxs_dump_temp_thread,
		    (void *)temp_event, NULL);
		break;

	case EMLXS_USER_DUMP:
		emlxs_thread_spawn(hba, emlxs_dump_user_thread, NULL, NULL);
		break;
	}

	return;

} /* emlxs_dump() */

extern void
emlxs_dump_wait(emlxs_hba_t *hba)
{
	/* Wait for the Dump flag to clear */
	while ((hba->flag & FC_DUMP_ACTIVE)) {
		BUSYWAIT_MS(1000);
	}

} /* emlxs_dump_wait() */


#endif /* DUMP_SUPPORT */