xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/fca/emlxs/emlxs_fcp.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.
 * Copyright 2020 RackTop Systems, Inc.
 */

#include <emlxs.h>

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

#define	EMLXS_GET_VADDR(hba, rp, icmd) emlxs_mem_get_vaddr(hba, rp, \
	PADDR(icmd->un.cont64[i].addrHigh, icmd->un.cont64[i].addrLow));

static void	emlxs_sbp_abort_add(emlxs_port_t *port, emlxs_buf_t *sbp,
    Q *abort, uint8_t *flag, emlxs_buf_t *fpkt);

#define	SCSI3_PERSISTENT_RESERVE_IN	0x5e
#define	SCSI_INQUIRY			0x12
#define	SCSI_RX_DIAG    		0x1C


/*
 *  emlxs_handle_fcp_event
 *
 *  Description: Process an FCP Rsp Ring completion
 *
 */
/* ARGSUSED */
extern void
emlxs_handle_fcp_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
{
	emlxs_port_t *port = &PPORT;
	emlxs_config_t	*cfg = &CFG;
	IOCB *cmd;
	emlxs_buf_t *sbp;
	fc_packet_t *pkt = NULL;
#ifdef SAN_DIAG_SUPPORT
	NODELIST *ndlp;
#endif
	uint32_t iostat;
	uint8_t localstat;
	fcp_rsp_t *rsp;
	uint32_t rsp_data_resid;
	uint32_t check_underrun;
	uint8_t asc;
	uint8_t ascq;
	uint8_t scsi_status;
	uint8_t sense;
	uint32_t did;
	uint32_t fix_it;
	uint8_t *scsi_cmd;
	uint8_t scsi_opcode;
	uint16_t scsi_dl;
	uint32_t data_rx;
	uint32_t length;

	cmd = &iocbq->iocb;

	/* Initialize the status */
	iostat = cmd->ULPSTATUS;
	localstat = 0;
	scsi_status = 0;
	asc = 0;
	ascq = 0;
	sense = 0;
	check_underrun = 0;
	fix_it = 0;

	HBASTATS.FcpEvent++;

	sbp = (emlxs_buf_t *)iocbq->sbp;

	if (!sbp) {
		/* completion with missing xmit command */
		HBASTATS.FcpStray++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_fcp_completion_msg,
		    "cmd=%x iotag=%d", cmd->ULPCOMMAND, cmd->ULPIOTAG);

		return;
	}

	HBASTATS.FcpCompleted++;

#ifdef SAN_DIAG_SUPPORT
	emlxs_update_sd_bucket(sbp);
#endif /* SAN_DIAG_SUPPORT */

	pkt = PRIV2PKT(sbp);

	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
	scsi_cmd = (uint8_t *)pkt->pkt_cmd;
	scsi_opcode = scsi_cmd[12];
	data_rx = 0;

	/* Sync data in data buffer only on FC_PKT_FCP_READ */
	if (pkt->pkt_datalen && (pkt->pkt_tran_type == FC_PKT_FCP_READ)) {
		EMLXS_MPDATA_SYNC(pkt->pkt_data_dma, 0, pkt->pkt_datalen,
		    DDI_DMA_SYNC_FORKERNEL);

#ifdef TEST_SUPPORT
		if (hba->underrun_counter && (iostat == IOSTAT_SUCCESS) &&
		    (pkt->pkt_datalen >= 512)) {
			hba->underrun_counter--;
			iostat = IOSTAT_FCP_RSP_ERROR;

			/* Report 512 bytes missing by adapter */
			cmd->un.fcpi.fcpi_parm = pkt->pkt_datalen - 512;

			/* Corrupt 512 bytes of Data buffer */
			bzero((uint8_t *)pkt->pkt_data, 512);

			/* Set FCP response to STATUS_GOOD */
			bzero((uint8_t *)pkt->pkt_resp, pkt->pkt_rsplen);
		}
#endif /* TEST_SUPPORT */
	}

	/* Process the pkt */
	mutex_enter(&sbp->mtx);

	/* Check for immediate return */
	if ((iostat == IOSTAT_SUCCESS) &&
	    (pkt->pkt_comp) &&
	    !(sbp->pkt_flags &
	    (PACKET_ULP_OWNED | PACKET_COMPLETED |
	    PACKET_IN_COMPLETION | PACKET_IN_TXQ | PACKET_IN_CHIPQ |
	    PACKET_IN_DONEQ | PACKET_IN_TIMEOUT | PACKET_IN_FLUSH |
	    PACKET_IN_ABORT | PACKET_POLLED))) {
		HBASTATS.FcpGood++;

		sbp->pkt_flags |=
		    (PACKET_STATE_VALID | PACKET_IN_COMPLETION |
		    PACKET_COMPLETED | PACKET_ULP_OWNED);
		mutex_exit(&sbp->mtx);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
		emlxs_unswap_pkt(sbp);
#endif /* EMLXS_MODREV2X */

#ifdef FMA_SUPPORT
		emlxs_check_dma(hba, sbp);
#endif  /* FMA_SUPPORT */

		cp->ulpCmplCmd++;
		(*pkt->pkt_comp) (pkt);

#ifdef FMA_SUPPORT
		if (hba->flag & FC_DMA_CHECK_ERROR) {
			emlxs_thread_spawn(hba, emlxs_restart_thread,
			    NULL, NULL);
		}
#endif  /* FMA_SUPPORT */

		return;
	}

	/*
	 * A response is only placed in the resp buffer if IOSTAT_FCP_RSP_ERROR
	 * is reported.
	 */

	/* Check if a response buffer was not provided */
	if ((iostat != IOSTAT_FCP_RSP_ERROR) || (pkt->pkt_rsplen == 0)) {
		goto done;
	}

	EMLXS_MPDATA_SYNC(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
	    DDI_DMA_SYNC_FORKERNEL);

	/* Get the response buffer pointer */
	rsp = (fcp_rsp_t *)pkt->pkt_resp;

	/* Validate the response payload */
	if (!rsp->fcp_u.fcp_status.resid_under &&
	    !rsp->fcp_u.fcp_status.resid_over) {
		rsp->fcp_resid = 0;
	}

	if (!rsp->fcp_u.fcp_status.rsp_len_set) {
		rsp->fcp_response_len = 0;
	}

	if (!rsp->fcp_u.fcp_status.sense_len_set) {
		rsp->fcp_sense_len = 0;
	}

	length = sizeof (fcp_rsp_t) + LE_SWAP32(rsp->fcp_response_len) +
	    LE_SWAP32(rsp->fcp_sense_len);

	if (length > pkt->pkt_rsplen) {
		iostat = IOSTAT_RSP_INVALID;
		pkt->pkt_data_resid = pkt->pkt_datalen;
		goto done;
	}

	/* Set the valid response flag */
	sbp->pkt_flags |= PACKET_FCP_RSP_VALID;

	scsi_status = rsp->fcp_u.fcp_status.scsi_status;

#ifdef SAN_DIAG_SUPPORT
	ndlp = (NODELIST *)iocbq->node;
	if (scsi_status == SCSI_STAT_QUE_FULL) {
		emlxs_log_sd_scsi_event(port, SD_SCSI_SUBCATEGORY_QFULL,
		    (HBA_WWN *)&ndlp->nlp_portname, sbp->lun);
	} else if (scsi_status == SCSI_STAT_BUSY) {
		emlxs_log_sd_scsi_event(port,
		    SD_SCSI_SUBCATEGORY_DEVBSY,
		    (HBA_WWN *)&ndlp->nlp_portname, sbp->lun);
	}
#endif

	/*
	 * Convert a task abort to a check condition with no data
	 * transferred. We saw a data corruption when Solaris received
	 * a Task Abort from a tape.
	 */

	if (scsi_status == SCSI_STAT_TASK_ABORT) {
		EMLXS_MSGF(EMLXS_CONTEXT,
		    &emlxs_fcp_completion_error_msg,
		    "Task Abort. "
		    "Fixed. did=0x%06x sbp=%p cmd=%02x dl=%d",
		    did, sbp, scsi_opcode, pkt->pkt_datalen);

		rsp->fcp_u.fcp_status.scsi_status =
		    SCSI_STAT_CHECK_COND;
		rsp->fcp_u.fcp_status.rsp_len_set = 0;
		rsp->fcp_u.fcp_status.sense_len_set = 0;
		rsp->fcp_u.fcp_status.resid_over = 0;

		if (pkt->pkt_datalen) {
			rsp->fcp_u.fcp_status.resid_under = 1;
			rsp->fcp_resid =
			    LE_SWAP32(pkt->pkt_datalen);
		} else {
			rsp->fcp_u.fcp_status.resid_under = 0;
			rsp->fcp_resid = 0;
		}

		scsi_status = SCSI_STAT_CHECK_COND;
	}

	/*
	 * We only need to check underrun if data could
	 * have been sent
	 */

	/* Always check underrun if status is good */
	if (scsi_status == SCSI_STAT_GOOD) {
		check_underrun = 1;
	}
	/* Check the sense codes if this is a check condition */
	else if (scsi_status == SCSI_STAT_CHECK_COND) {
		check_underrun = 1;

		/* Check if sense data was provided */
		if (LE_SWAP32(rsp->fcp_sense_len) >= 14) {
			sense = *((uint8_t *)rsp + 32 + 2);
			asc = *((uint8_t *)rsp + 32 + 12);
			ascq = *((uint8_t *)rsp + 32 + 13);
		}

#ifdef SAN_DIAG_SUPPORT
		emlxs_log_sd_scsi_check_event(port,
		    (HBA_WWN *)&ndlp->nlp_portname, sbp->lun,
		    scsi_opcode, sense, asc, ascq);
#endif
	}
	/* Status is not good and this is not a check condition */
	/* No data should have been sent */
	else {
		check_underrun = 0;
	}

	/* Initialize the resids */
	pkt->pkt_resp_resid = 0;
	pkt->pkt_data_resid = 0;

	/* Check if no data was to be transferred */
	if (pkt->pkt_datalen == 0) {
		goto done;
	}

	/* Get the residual underrun count reported by the SCSI reply */
	rsp_data_resid = (rsp->fcp_u.fcp_status.resid_under) ?
	    LE_SWAP32(rsp->fcp_resid) : 0;

	/* Set the pkt_data_resid to what the scsi response resid */
	pkt->pkt_data_resid = rsp_data_resid;

	/* Adjust the pkt_data_resid field if needed */
	if (pkt->pkt_tran_type == FC_PKT_FCP_READ) {
		/*
		 * Get the residual underrun count reported by
		 * our adapter
		 */
		pkt->pkt_data_resid = cmd->un.fcpi.fcpi_parm;

#ifdef SAN_DIAG_SUPPORT
		if ((rsp_data_resid == 0) && (pkt->pkt_data_resid)) {
			emlxs_log_sd_fc_rdchk_event(port,
			    (HBA_WWN *)&ndlp->nlp_portname, sbp->lun,
			    scsi_opcode, pkt->pkt_data_resid);
		}
#endif

		/* Get the actual amount of data transferred */
		data_rx = pkt->pkt_datalen - pkt->pkt_data_resid;

		/*
		 * If the residual being reported by the adapter is
		 * greater than the residual being reported in the
		 * reply, then we have a true underrun.
		 */
		if (check_underrun && (pkt->pkt_data_resid > rsp_data_resid)) {
			switch (scsi_opcode) {
			case SCSI_INQUIRY:
				scsi_dl = scsi_cmd[16];
				break;

			case SCSI_RX_DIAG:
				scsi_dl =
				    (scsi_cmd[15] * 0x100) +
				    scsi_cmd[16];
				break;

			default:
				scsi_dl = pkt->pkt_datalen;
			}

#ifdef FCP_UNDERRUN_PATCH1
if (cfg[CFG_ENABLE_PATCH].current & FCP_UNDERRUN_PATCH1) {
			/*
			 * If status is not good and no data was
			 * actually transferred, then we must fix
			 * the issue
			 */
			if ((scsi_status != SCSI_STAT_GOOD) && (data_rx == 0)) {
				fix_it = 1;

				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_fcp_completion_error_msg,
				    "Underrun(1). Fixed. "
				    "did=0x%06x sbp=%p cmd=%02x "
				    "dl=%d,%d rx=%d rsp=%d",
				    did, sbp, scsi_opcode,
				    pkt->pkt_datalen, scsi_dl,
				    (pkt->pkt_datalen -
				    pkt->pkt_data_resid),
				    rsp_data_resid);

			}
}
#endif /* FCP_UNDERRUN_PATCH1 */


#ifdef FCP_UNDERRUN_PATCH2
if (cfg[CFG_ENABLE_PATCH].current & FCP_UNDERRUN_PATCH2) {
			if (scsi_status == SCSI_STAT_GOOD) {
				emlxs_msg_t	*msg;

				msg = &emlxs_fcp_completion_error_msg;
				/*
				 * If status is good and this is an
				 * inquiry request and the amount of
				 * data
				 */
				/*
				 * requested <= data received, then we
				 * must fix the issue.
				 */

				if ((scsi_opcode == SCSI_INQUIRY) &&
				    (pkt->pkt_datalen >= data_rx) &&
				    (scsi_dl <= data_rx)) {
					fix_it = 1;

					EMLXS_MSGF(EMLXS_CONTEXT, msg,
					    "Underrun(2). Fixed. "
					    "did=0x%06x sbp=%p "
					    "cmd=%02x dl=%d,%d "
					    "rx=%d rsp=%d",
					    did, sbp, scsi_opcode,
					    pkt->pkt_datalen, scsi_dl,
					    data_rx, rsp_data_resid);

				}

				/*
				 * If status is good and this is an
				 * inquiry request and the amount of
				 * data requested >= 128 bytes, but
				 * only 128 bytes were received,
				 * then we must fix the issue.
				 */
				else if ((scsi_opcode == SCSI_INQUIRY) &&
				    (pkt->pkt_datalen >= 128) &&
				    (scsi_dl >= 128) && (data_rx == 128)) {
					fix_it = 1;

					EMLXS_MSGF(EMLXS_CONTEXT, msg,
					    "Underrun(3). Fixed. "
					    "did=0x%06x sbp=%p "
					    "cmd=%02x dl=%d,%d "
					    "rx=%d rsp=%d",
					    did, sbp, scsi_opcode,
					    pkt->pkt_datalen, scsi_dl,
					    data_rx, rsp_data_resid);

				}
			}
}
#endif /* FCP_UNDERRUN_PATCH2 */

			/*
			 * Check if SCSI response payload should be
			 * fixed or if a DATA_UNDERRUN should be
			 * reported
			 */
			if (fix_it) {
				/*
				 * Fix the SCSI response payload itself
				 */
				rsp->fcp_u.fcp_status.resid_under = 1;
				rsp->fcp_resid =
				    LE_SWAP32(pkt->pkt_data_resid);
			} else {
				/*
				 * Change the status from
				 * IOSTAT_FCP_RSP_ERROR to
				 * IOSTAT_DATA_UNDERRUN
				 */
				iostat = IOSTAT_DATA_UNDERRUN;
				pkt->pkt_data_resid =
				    pkt->pkt_datalen;
			}
		}

		/*
		 * If the residual being reported by the adapter is
		 * less than the residual being reported in the reply,
		 * then we have a true overrun. Since we don't know
		 * where the extra data came from or went to then we
		 * cannot trust anything we received
		 */
		else if (rsp_data_resid > pkt->pkt_data_resid) {
			/*
			 * Change the status from
			 * IOSTAT_FCP_RSP_ERROR to
			 * IOSTAT_DATA_OVERRUN
			 */
			iostat = IOSTAT_DATA_OVERRUN;
			pkt->pkt_data_resid = pkt->pkt_datalen;
		}

	} else if ((hba->sli_mode == EMLXS_HBA_SLI4_MODE) &&
	    (pkt->pkt_tran_type == FC_PKT_FCP_WRITE)) {
		/*
		 * Get the residual underrun count reported by
		 * our adapter
		 */
		pkt->pkt_data_resid = cmd->un.fcpi.fcpi_parm;

#ifdef SAN_DIAG_SUPPORT
		if ((rsp_data_resid == 0) && (pkt->pkt_data_resid)) {
			emlxs_log_sd_fc_rdchk_event(port,
			    (HBA_WWN *)&ndlp->nlp_portname, sbp->lun,
			    scsi_opcode, pkt->pkt_data_resid);
		}
#endif /* SAN_DIAG_SUPPORT */

		/* Get the actual amount of data transferred */
		data_rx = pkt->pkt_datalen - pkt->pkt_data_resid;

		/*
		 * If the residual being reported by the adapter is
		 * greater than the residual being reported in the
		 * reply, then we have a true underrun.
		 */
		if (check_underrun && (pkt->pkt_data_resid > rsp_data_resid)) {

			scsi_dl = pkt->pkt_datalen;

#ifdef FCP_UNDERRUN_PATCH1
if (cfg[CFG_ENABLE_PATCH].current & FCP_UNDERRUN_PATCH1) {
			/*
			 * If status is not good and no data was
			 * actually transferred, then we must fix
			 * the issue
			 */
			if ((scsi_status != SCSI_STAT_GOOD) && (data_rx == 0)) {
				fix_it = 1;

				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_fcp_completion_error_msg,
				    "Underrun(1). Fixed. "
				    "did=0x%06x sbp=%p cmd=%02x "
				    "dl=%d,%d rx=%d rsp=%d",
				    did, sbp, scsi_opcode,
				    pkt->pkt_datalen, scsi_dl,
				    (pkt->pkt_datalen -
				    pkt->pkt_data_resid),
				    rsp_data_resid);

			}
}
#endif /* FCP_UNDERRUN_PATCH1 */

			/*
			 * Check if SCSI response payload should be
			 * fixed or if a DATA_UNDERRUN should be
			 * reported
			 */
			if (fix_it) {
				/*
				 * Fix the SCSI response payload itself
				 */
				rsp->fcp_u.fcp_status.resid_under = 1;
				rsp->fcp_resid =
				    LE_SWAP32(pkt->pkt_data_resid);
			} else {
				/*
				 * Change the status from
				 * IOSTAT_FCP_RSP_ERROR to
				 * IOSTAT_DATA_UNDERRUN
				 */
				iostat = IOSTAT_DATA_UNDERRUN;
				pkt->pkt_data_resid =
				    pkt->pkt_datalen;
			}
		}

		/*
		 * If the residual being reported by the adapter is
		 * less than the residual being reported in the reply,
		 * then we have a true overrun. Since we don't know
		 * where the extra data came from or went to then we
		 * cannot trust anything we received
		 */
		else if (rsp_data_resid > pkt->pkt_data_resid) {
			/*
			 * Change the status from
			 * IOSTAT_FCP_RSP_ERROR to
			 * IOSTAT_DATA_OVERRUN
			 */
			iostat = IOSTAT_DATA_OVERRUN;
			pkt->pkt_data_resid = pkt->pkt_datalen;
		}
	}

done:

	/* Print completion message */
	switch (iostat) {
	case IOSTAT_SUCCESS:
		/* Build SCSI GOOD status */
		if (pkt->pkt_rsplen) {
			bzero((uint8_t *)pkt->pkt_resp, pkt->pkt_rsplen);
		}
		break;

	case IOSTAT_FCP_RSP_ERROR:
		break;

	case IOSTAT_REMOTE_STOP:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Remote Stop. did=0x%06x sbp=%p cmd=%02x", did, sbp,
		    scsi_opcode);
		break;

	case IOSTAT_LOCAL_REJECT:
		localstat = cmd->un.grsp.perr.statLocalError;

		switch (localstat) {
		case IOERR_SEQUENCE_TIMEOUT:
			EMLXS_MSGF(EMLXS_CONTEXT,
			    &emlxs_fcp_completion_error_msg,
			    "Local reject. "
			    "%s did=0x%06x sbp=%p cmd=%02x tmo=%d ",
			    emlxs_error_xlate(localstat), did, sbp,
			    scsi_opcode, pkt->pkt_timeout);
			break;

		default:
			EMLXS_MSGF(EMLXS_CONTEXT,
			    &emlxs_fcp_completion_error_msg,
			    "Local reject. %s 0x%06x %p %02x (%x)(%x)",
			    emlxs_error_xlate(localstat), did, sbp,
			    scsi_opcode, (uint16_t)cmd->ULPIOTAG,
			    (uint16_t)cmd->ULPCONTEXT);
		}

		break;

	case IOSTAT_NPORT_RJT:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Nport reject. did=0x%06x sbp=%p cmd=%02x", did, sbp,
		    scsi_opcode);
		break;

	case IOSTAT_FABRIC_RJT:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Fabric reject. did=0x%06x sbp=%p cmd=%02x", did, sbp,
		    scsi_opcode);
		break;

	case IOSTAT_NPORT_BSY:
#ifdef SAN_DIAG_SUPPORT
		ndlp = (NODELIST *)iocbq->node;
		emlxs_log_sd_fc_bsy_event(port, (HBA_WWN *)&ndlp->nlp_portname);
#endif

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Nport busy. did=0x%06x sbp=%p cmd=%02x", did, sbp,
		    scsi_opcode);
		break;

	case IOSTAT_FABRIC_BSY:
#ifdef SAN_DIAG_SUPPORT
		ndlp = (NODELIST *)iocbq->node;
		emlxs_log_sd_fc_bsy_event(port, NULL);
#endif

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Fabric busy. did=0x%06x sbp=%p cmd=%02x", did, sbp,
		    scsi_opcode);
		break;

	case IOSTAT_INTERMED_RSP:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Intermediate response. did=0x%06x sbp=%p cmd=%02x", did,
		    sbp, scsi_opcode);
		break;

	case IOSTAT_LS_RJT:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "LS Reject. did=0x%06x sbp=%p cmd=%02x", did, sbp,
		    scsi_opcode);
		break;

	case IOSTAT_DATA_UNDERRUN:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Underrun. did=0x%06x sbp=%p cmd=%02x "
		    "dl=%d,%d rx=%d rsp=%d (%02x,%02x,%02x,%02x)",
		    did, sbp, scsi_opcode, pkt->pkt_datalen, scsi_dl, data_rx,
		    rsp_data_resid, scsi_status, sense, asc, ascq);
		break;

	case IOSTAT_DATA_OVERRUN:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Overrun. did=0x%06x sbp=%p cmd=%02x "
		    "dl=%d,%d rx=%d rsp=%d (%02x,%02x,%02x,%02x)",
		    did, sbp, scsi_opcode, pkt->pkt_datalen, scsi_dl, data_rx,
		    rsp_data_resid, scsi_status, sense, asc, ascq);
		break;

	case IOSTAT_RSP_INVALID:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Rsp Invalid. did=0x%06x sbp=%p cmd=%02x dl=%d rl=%d"
		    "(%d, %d, %d)",
		    did, sbp, scsi_opcode, pkt->pkt_datalen, pkt->pkt_rsplen,
		    LE_SWAP32(rsp->fcp_resid),
		    LE_SWAP32(rsp->fcp_sense_len),
		    LE_SWAP32(rsp->fcp_response_len));
		break;

	default:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcp_completion_error_msg,
		    "Unknown status=%x reason=%x did=0x%06x sbp=%p cmd=%02x",
		    iostat, cmd->un.grsp.perr.statLocalError, did, sbp,
		    scsi_opcode);
		break;
	}

	if (iostat == IOSTAT_SUCCESS) {
		HBASTATS.FcpGood++;
	} else {
		HBASTATS.FcpError++;
	}

	mutex_exit(&sbp->mtx);

	emlxs_pkt_complete(sbp, iostat, localstat, 0);

	return;

} /* emlxs_handle_fcp_event() */


/*
 *  emlxs_post_buffer
 *
 *  This routine will post count buffers to the
 *  ring with the QUE_RING_BUF_CN command. This
 *  allows 2 buffers / command to be posted.
 *  Returns the number of buffers NOT posted.
 */
/* SLI3 */
extern int
emlxs_post_buffer(emlxs_hba_t *hba, RING *rp, int16_t cnt)
{
	emlxs_port_t *port = &PPORT;
	IOCB *icmd;
	IOCBQ *iocbq;
	MATCHMAP *mp;
	uint16_t tag;
	uint32_t maxqbuf;
	int32_t i;
	int32_t j;
	uint32_t seg;
	uint32_t size;

	mp = 0;
	maxqbuf = 2;
	tag = (uint16_t)cnt;
	cnt += rp->fc_missbufcnt;

	if (rp->ringno == hba->channel_els) {
		seg = MEM_BUF;