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

/*
 * 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>

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

static void	emlxs_handle_sol_flogi(emlxs_port_t *port, emlxs_buf_t *sbp);
static void	emlxs_handle_sol_fdisc(emlxs_port_t *port, emlxs_buf_t *sbp);
static void	emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp);
static void	emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp);
static void	emlxs_handle_sol_logo(emlxs_port_t *port, emlxs_buf_t *sbp);
static void	emlxs_handle_sol_prli(emlxs_port_t *port, emlxs_buf_t *sbp);

static void	emlxs_handle_unsol_rscn(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_flogi(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_plogi(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_logo(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_adisc(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_prli(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_prlo(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_auth(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_echo(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_rtv(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_unsol_rls(emlxs_port_t *port, CHANNEL *cp,
			IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
static void	emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp,
			IOCBQ *iocbq, uint32_t flag);
static void	emlxs_handle_reject(emlxs_port_t *port, emlxs_buf_t *sbp,
			IOCBQ *iocbq, uint32_t flag);

#if (EMLXS_MODREV < EMLXS_MODREV4)
static void	emlxs_send_rsnn(emlxs_port_t *port);

#endif /* < EMLXS_MODREV4 */



/* Routine Declaration - Local */
/* End Routine Declaration - Local */

/*
 *  emlxs_els_handle_event
 *
 *  Description: Process an ELS Response Ring cmpl
 *
 */
extern int
emlxs_els_handle_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
{
	emlxs_port_t *port = &PPORT;
	IOCB *iocb;
	emlxs_buf_t *sbp;
	fc_packet_t *pkt;
	uint32_t *lp0;
	uint32_t command;
	NODELIST *ndlp;
	uint32_t did;
	ELS_PKT *els;

	iocb = &iocbq->iocb;

	HBASTATS.ElsEvent++;

	sbp = (emlxs_buf_t *)iocbq->sbp;

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

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_els_completion_msg,
		    "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
		    iocbq, (uint32_t)iocb->ULPCOMMAND,
		    (uint32_t)iocb->ULPIOTAG, iocb->ULPSTATUS,
		    iocb->un.ulpWord[4]);

		return (1);
	}

	if (cp->channelno != hba->channel_els) {
		HBASTATS.ElsStray++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_els_completion_msg,
		    "Not ELS channel: channel=%d iocbq=%p cmd=0x%x iotag=0x%x "
		    "status=0x%x perr=0x%x", cp->channelno, iocbq,
		    (uint32_t)iocb->ULPCOMMAND, (uint32_t)iocb->ULPIOTAG,
		    iocb->ULPSTATUS, iocb->un.ulpWord[4]);

		return (1);
	}

	port = sbp->iocbq.port;
	pkt = PRIV2PKT(sbp);
	lp0 = (uint32_t *)pkt->pkt_cmd;
	command = *lp0 & ELS_CMD_MASK;
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);

	/* Check if a response buffer was provided */
	if (pkt->pkt_rsplen) {
		EMLXS_MPDATA_SYNC(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
		    DDI_DMA_SYNC_FORKERNEL);
	}

	switch (iocb->ULPCOMMAND) {
		/*
		 * ELS Reply completion
		 */
	case CMD_XMIT_ELS_RSP_CX:
	case CMD_XMIT_ELS_RSP64_CX:

		HBASTATS.ElsRspCompleted++;

		if (command == ELS_CMD_ACC) {
			emlxs_handle_acc(port, sbp, iocbq, 1);
		} else {
			emlxs_handle_reject(port, sbp, iocbq, 1);
		}

		break;

		/*
		 * ELS command completion
		 */
	case CMD_ELS_REQUEST_CR:
	case CMD_ELS_REQUEST64_CR:
	case CMD_ELS_REQUEST_CX:
	case CMD_ELS_REQUEST64_CX:

		HBASTATS.ElsCmdCompleted++;

		sbp->pkt_flags |= PACKET_ELS_RSP_VALID;

		els = (ELS_PKT *)pkt->pkt_resp;

		pkt->pkt_resp_resid =
		    pkt->pkt_rsplen - iocb->un.elsreq64.bdl.bdeSize;
		pkt->pkt_data_resid = pkt->pkt_datalen;

		pkt->pkt_resp_fhdr.d_id = pkt->pkt_cmd_fhdr.s_id;
		pkt->pkt_resp_fhdr.s_id = pkt->pkt_cmd_fhdr.d_id;

		if ((iocb->ULPSTATUS == 0) && (els->elsCode == 0x02)) {
			HBASTATS.ElsCmdGood++;

			if (!(sbp->pkt_flags & PACKET_ALLOCATED)) {
				/*
				 * ULP patch - ULP expects
				 * resp_resid = 0 on success
				 */
				pkt->pkt_resp_resid = 0;
			}

			switch (command) {
			case ELS_CMD_FDISC:	/* Fabric login */
				emlxs_handle_sol_fdisc(port, sbp);

				break;

			case ELS_CMD_FLOGI:	/* Fabric login */
				emlxs_handle_sol_flogi(port, sbp);

				break;

			case ELS_CMD_PLOGI:	/* NPort login */
				emlxs_handle_sol_plogi(port, sbp);

				break;

			case ELS_CMD_ADISC:	/* Adisc */
				emlxs_handle_sol_adisc(port, sbp);

				break;

			case ELS_CMD_LOGO:	/* Logout */
				emlxs_handle_sol_logo(port, sbp);

				break;

			case ELS_CMD_PRLI:	/* Process Log In */
				emlxs_handle_sol_prli(port, sbp);

				break;

			default:
				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_els_completion_msg, "%s: did=%x",
				    emlxs_elscmd_xlate(command), did);

				emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);

				break;
			}

		} else {
			HBASTATS.ElsCmdError++;

			/* Look for LS_REJECT */
			if (iocb->ULPSTATUS == IOSTAT_LS_RJT) {
				pkt->pkt_state = FC_PKT_LS_RJT;
				pkt->pkt_action = FC_ACTION_RETRYABLE;
				pkt->pkt_reason = iocb->un.grsp.perr.statRsn;
				pkt->pkt_expln = iocb->un.grsp.perr.statBaExp;
				sbp->pkt_flags |= PACKET_STATE_VALID;

#ifdef SAN_DIAG_SUPPORT
				ndlp = emlxs_node_find_did(port, did, 1);
				if (ndlp) {
					emlxs_log_sd_lsrjt_event(port,
					    (HBA_WWN *)&ndlp->nlp_portname,
					    command, pkt->pkt_reason,
					    pkt->pkt_expln);
				}
#endif

				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_els_completion_msg,
				    "%s Rejected: did=%x rsn=%x exp=%x",
				    emlxs_elscmd_xlate(command), did,
				    pkt->pkt_reason, pkt->pkt_expln);
			} else if (iocb->ULPSTATUS == IOSTAT_LOCAL_REJECT) {
				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_bad_els_completion_msg,
				    "%s: did=%x Local Reject. %s",
				    emlxs_elscmd_xlate(command), did,
				    emlxs_error_xlate(iocb->un.grsp.perr.
				    statLocalError));
			} else {
				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_bad_els_completion_msg,
				    "%s: did=%x %s (%02x%02x%02x%02x)",
				    emlxs_elscmd_xlate(command), did,
				    emlxs_state_xlate(iocb->ULPSTATUS),
				    iocb->un.grsp.perr.statAction,
				    iocb->un.grsp.perr.statRsn,
				    iocb->un.grsp.perr.statBaExp,
				    iocb->un.grsp.perr.statLocalError);
			}

			switch (command) {
			case ELS_CMD_PLOGI:	/* NPort login failed */
				ndlp = emlxs_node_find_did(port, did, 1);

				if (ndlp && ndlp->nlp_active) {
					/* Open the node again */
					emlxs_node_open(port, ndlp,
					    hba->channel_fcp);
					emlxs_node_open(port, ndlp,
					    hba->channel_ip);
#ifdef DHCHAP_SUPPORT
					if (pkt->pkt_state == FC_PKT_LS_RJT) {
						emlxs_dhc_state(port, ndlp,
						    NODE_STATE_NOCHANGE,
						    pkt->pkt_reason,
						    pkt->pkt_expln);
					}
#endif /*  DHCHAP_SUPPORT */
				}

				break;


			case ELS_CMD_PRLI:	/* Process Log In failed */
				ndlp = emlxs_node_find_did(port, did, 1);

				if (ndlp && ndlp->nlp_active) {
					/* Open the node again */
					emlxs_node_open(port, ndlp,
					    hba->channel_fcp);
				}

				break;

			case ELS_CMD_FDISC:	/* Fabric login */
			case ELS_CMD_FLOGI:	/* Fabric login */
				if (pkt->pkt_state == FC_PKT_LS_RJT) {
					/* This will cause ULP to retry */
					/* FLOGI requests */
					pkt->pkt_reason = FC_REASON_QFULL;
					pkt->pkt_expln = 0;

#ifdef DHCHAP_SUPPORT
					ndlp = emlxs_node_find_did(port,
					    did, 1);
					if (ndlp && ndlp->nlp_active) {
						emlxs_dhc_state(port, ndlp,
						    NODE_STATE_NOCHANGE,
						    pkt->pkt_reason,
						    pkt->pkt_expln);
					}
#endif /*  DHCHAP_SUPPORT */
				}

				if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
					/* Preset the state for deferred cmpl */
					emlxs_set_pkt_state(sbp,
					    iocb->ULPSTATUS,
					    iocb->un.grsp.perr.statLocalError,
					    1);

					if (emlxs_vpi_logi_failed_notify(
					    sbp->port, sbp) == 0) {
						/* Defer completion */
						return (0);
					}
				}

				break;

			default:
				break;
			}

			emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
			    iocb->un.grsp.perr.statLocalError, 1);
		}

		break;

	default:

		HBASTATS.ElsStray++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_els_msg,
		    "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);

		emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
		    iocb->un.grsp.perr.statLocalError, 1);

		break;
	}	/* switch(iocb->ULPCOMMAND) */

	return (0);

} /* emlxs_els_handle_event() */


extern int
emlxs_els_handle_unsol_req(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	uint32_t cmd_code;
	IOCB *iocb;

	HBASTATS.ElsCmdReceived++;

	iocb = &iocbq->iocb;
	cmd_code = *((uint32_t *)mp->virt) & ELS_CMD_MASK;

	if (!(port->flag & EMLXS_PORT_BOUND)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "%s: sid=%x. Port not bound: Rejecting.",
		    emlxs_elscmd_xlate(cmd_code),
		    iocbq->iocb.un.elsreq.remoteID);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    cmd_code, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);

		return (0);
	}

	switch (cmd_code) {
	case ELS_CMD_RSCN:
		HBASTATS.ElsRscnReceived++;
		emlxs_handle_unsol_rscn(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_FLOGI:
		HBASTATS.ElsFlogiReceived++;
		emlxs_handle_unsol_flogi(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_PLOGI:
		HBASTATS.ElsPlogiReceived++;
		emlxs_handle_unsol_plogi(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_PRLI:
		HBASTATS.ElsPrliReceived++;
		emlxs_handle_unsol_prli(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_PRLO:
		HBASTATS.ElsPrloReceived++;
		emlxs_handle_unsol_prlo(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_LOGO:
		HBASTATS.ElsLogoReceived++;
		emlxs_handle_unsol_logo(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_ADISC:
		HBASTATS.ElsAdiscReceived++;
		emlxs_handle_unsol_adisc(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_AUTH:
		HBASTATS.ElsAuthReceived++;
		emlxs_handle_unsol_auth(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_TEST:
		HBASTATS.ElsTestReceived++;
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "%s: sid=%x. Dropping.",
		    emlxs_elscmd_xlate(cmd_code),
		    iocbq->iocb.un.elsreq.remoteID);

		/* drop it */
		emlxs_close_els_exchange(hba, port, iocb->ULPCONTEXT);
		break;

	case ELS_CMD_ESTC:
		HBASTATS.ElsEstcReceived++;
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "%s: sid=%x. Dropping.",
		    emlxs_elscmd_xlate(cmd_code),
		    iocbq->iocb.un.elsreq.remoteID);

		/* drop it */
		emlxs_close_els_exchange(hba, port, iocb->ULPCONTEXT);
		break;

	case ELS_CMD_FARPR:
		HBASTATS.ElsFarprReceived++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "%s: sid=%x. Dropping.",
		    emlxs_elscmd_xlate(cmd_code),
		    iocbq->iocb.un.elsreq.remoteID);

		/* drop it */
		emlxs_close_els_exchange(hba, port, iocb->ULPCONTEXT);
		break;

	case ELS_CMD_ECHO:
		HBASTATS.ElsEchoReceived++;
		emlxs_handle_unsol_echo(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_RLS:
		HBASTATS.ElsRlsReceived++;
		emlxs_handle_unsol_rls(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_RTV:
		HBASTATS.ElsRtvReceived++;
		emlxs_handle_unsol_rtv(port, cp, iocbq, mp, size);
		break;

	case ELS_CMD_ABTX:
	case ELS_CMD_RCS:
	case ELS_CMD_RES:
	case ELS_CMD_RSS:
	case ELS_CMD_RSI:
	case ELS_CMD_ESTS:
	case ELS_CMD_RRQ:
	case ELS_CMD_REC:
		HBASTATS.ElsGenReceived++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "%s: sid=%x. Rejecting.",
		    emlxs_elscmd_xlate(cmd_code),
		    iocbq->iocb.un.elsreq.remoteID);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT, cmd_code,
		    LSRJT_CMD_UNSUPPORTED, LSEXP_NOTHING_MORE);
		break;

	default:
		HBASTATS.ElsGenReceived++;
		emlxs_handle_unsol_gen_cmd(port, cp, iocbq, mp, size);
		break;
	}

	return (0);

} /* emlxs_els_handle_unsol_req() */


static uint32_t
emlxs_els_delay_discovery(emlxs_port_t *port, emlxs_buf_t *sbp)
{
	emlxs_hba_t	*hba = HBA;
	emlxs_config_t	*cfg;
	SERV_PARM	*parm;

	cfg = &CFG;
	if (!cfg[CFG_DELAY_DISCOVERY].current) {
		return (0);
	}

	parm = &port->fabric_sparam;
	if (((port->prev_did != port->did) ||
	    bcmp(&port->prev_fabric_sparam.portName,
	    &port->fabric_sparam.portName, 8)) &&
	    !(parm->cmn.CLEAN_ADDRESS_BIT)) {

		/* If this is the first time, check config parameter */
		if (port->prev_did || cfg[CFG_DELAY_DISCOVERY].current == 2) {

			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
			    "Clean Address delay: sid=%x prev=%x RATOV %d",
			    port->did, port->prev_did, hba->fc_ratov);

			port->clean_address_sbp = sbp;
			port->clean_address_timer =
			    hba->timer_tics + hba->fc_ratov;

			return (1);
		}
	}
	return (0);

} /* emlxs_els_delay_discovery() */


static void
emlxs_handle_sol_flogi(emlxs_port_t *port, emlxs_buf_t *sbp)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t *cfg = &CFG;
	emlxs_port_t *vport;
	SERV_PARM *sp;
	fc_packet_t *pkt;
	MAILBOXQ *mbox;
	uint32_t did;
	IOCBQ *iocbq;
	IOCB *iocb;
	char buffer[64];
	uint32_t i;
	int rc;
	uint16_t altBbCredit;

	pkt = PRIV2PKT(sbp);
	sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
	iocbq = &sbp->iocbq;
	iocb = &iocbq->iocb;

	mutex_enter(&EMLXS_PORT_LOCK);

	/* Save the fabric service parameters and did */
	bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));

	/* Save E_D_TOV ticks in nanoseconds */
	if (sp->cmn.edtovResolution) {
		hba->fc_edtov = (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
	} else {
		hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
	}

	/* Save R_A_TOV ticks */
	hba->fc_ratov = (LE_SWAP32(sp->cmn.w2.r_a_tov) + 999) / 1000;

	if (sp->cmn.fPort) {
		hba->flag |= FC_FABRIC_ATTACHED;
		hba->flag &= ~FC_PT_TO_PT;

		port->did = iocb->un.elsreq.myID;
		pkt->pkt_resp_fhdr.s_id = LE_SWAP24_LO(FABRIC_DID);
		pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);

		/*
		 * If we are a N-port connected to a Fabric,
		 * fixup sparam's so logins to devices on remote
		 * loops work.
		 */
		altBbCredit = (hba->topology != TOPOLOGY_LOOP)? 1:0;
		hba->sparam.cmn.altBbCredit = altBbCredit;

		/* Set this bit in all the port sparam copies */
		for (i = 0; i < MAX_VPORTS; i++) {
			vport = &VPORT(i);

			if (!(vport->flag & EMLXS_PORT_BOUND)) {
				continue;
			}

			vport->sparam.cmn.altBbCredit = altBbCredit;
		}

		if (sp->cmn.rspMultipleNPort) {
			hba->flag |= FC_NPIV_SUPPORTED;

			if (cfg[CFG_NPIV_DELAY].current) {
				/*
				 * PATCH: for NPIV support on
				 * Brocade switch firmware 5.10b
				 */
				if ((hba->flag & FC_NPIV_ENABLED) &&
				    ((sp->nodeName.IEEE[0] == 0x00) &&
				    (sp->nodeName.IEEE[1] == 0x05) &&
				    (sp->nodeName.IEEE[2] == 0x1e))) {
					hba->flag |= FC_NPIV_DELAY_REQUIRED;
				}
			}
		} else {
			hba->flag |= FC_NPIV_UNSUPPORTED;
		}

		if (!(hba->flag & FC_NPIV_ENABLED)) {
			(void) strlcpy(buffer, "npiv:Disabled ",
			    sizeof (buffer));
		} else if (hba->flag & FC_NPIV_SUPPORTED) {
			(void) strlcpy(buffer, "npiv:Supported ",
			    sizeof (buffer));
		} else {
			(void) strlcpy(buffer, "npiv:Unsupported ",
			    sizeof (buffer));
		}

#ifdef DHCHAP_SUPPORT
		if (!sp->cmn.fcsp_support) {
			(void) strlcat(buffer, "fcsp:Unsupported",
			    sizeof (buffer));
		} else if (cfg[CFG_AUTH_ENABLE].current &&
		    (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
			(void) strlcat(buffer, "fcsp:Supported",
			    sizeof (buffer));
		} else {
			(void) strlcat(buffer, "fcsp:Disabled",
			    sizeof (buffer));
		}
#endif /* DHCHAP_SUPPORT */

		mutex_exit(&EMLXS_PORT_LOCK);

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
		    "FLOGI: did=%x sid=%x prev=%x %s",
		    did, port->did, port->prev_did, buffer);

		/* Update our service parms */
		if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
			/* Update our service parms */
			if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba,
			    MEM_MBOX))) {
				emlxs_mb_config_link(hba, mbox);

				rc =  EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
				    MBX_NOWAIT, 0);
				if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
					emlxs_mem_put(hba, MEM_MBOX,
					    (void *)mbox);
				}
			}
		}

		/* Preset the state for the reg_did */
		emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);

		if (emlxs_els_delay_discovery(port, sbp)) {
			/* Deferred registration of this pkt until */
			/* Clean Address timeout */
			return;
		}

		if (EMLXS_SLI_REG_DID(port, FABRIC_DID, &port->fabric_sparam,
		    sbp, NULL, NULL) == 0) {
			/* Deferred completion of this pkt until */
			/* login is complete */
			return;
		}

		emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
		    IOERR_NO_RESOURCES, 1);

	} else {	/* No switch */

		hba->flag &= ~FC_FABRIC_ATTACHED;
		hba->flag |= FC_PT_TO_PT;

		hba->flag &= ~FC_NPIV_SUPPORTED;
		(void) strlcpy(buffer, "npiv:Disabled.", sizeof (buffer));

		if (emlxs_wwn_cmp((uint8_t *)&sp->portName,
		    (uint8_t *)&port->wwpn) > 0) {
			(void) strlcat(buffer, " P2P Master.",
			    sizeof (buffer));
		} else {
			(void) strlcat(buffer, " P2P Slave.",
			    sizeof (buffer));
		}

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
		    "FLOGI: did=%x sid=%x %s", did, port->did, buffer);

		mutex_exit(&EMLXS_PORT_LOCK);

		if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
			/* Preset the state for the reg_did */
			emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);

			if (EMLXS_SLI_REG_DID(port, FABRIC_DID,
			    &port->fabric_sparam, sbp, NULL, NULL) == 0) {
				/* Deferred completion of this pkt until */
				/* login is complete */
				return;
			}

			emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
			    IOERR_NO_RESOURCES, 1);

		} else {
			emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
		}
	}

	return;

} /* emlxs_handle_sol_flogi() */


static void
emlxs_handle_sol_fdisc(emlxs_port_t *port, emlxs_buf_t *sbp)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t *cfg = &CFG;
	SERV_PARM *sp;
	fc_packet_t *pkt;
	uint32_t did;
	IOCBQ *iocbq;
	IOCB *iocb;
	char buffer[64];

	pkt = PRIV2PKT(sbp);
	sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
	iocbq = &sbp->iocbq;
	iocb = &iocbq->iocb;

	mutex_enter(&EMLXS_PORT_LOCK);

	/* Save the fabric service parameters and did */
	port->did = iocb->un.elsreq.myID;
	bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));

	pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);

	mutex_exit(&EMLXS_PORT_LOCK);

	buffer[0] = 0;

#ifdef DHCHAP_SUPPORT
	if (!sp->cmn.fcsp_support) {
		(void) strlcat(buffer, "fcsp:Unsupported",
		    sizeof (buffer));
	} else if (cfg[CFG_AUTH_ENABLE].current && cfg[CFG_AUTH_NPIV].current) {
		(void) strlcat(buffer, "fcsp:Supported",
		    sizeof (buffer));
	} else {
		(void) strlcat(buffer, "fcsp:Disabled",
		    sizeof (buffer));
	}
#endif /* DHCHAP_SUPPORT */

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
	    "FDISC: did=%x sid=%x %s", did, port->did, buffer);

	/* Preset the state for the reg_did */
	emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);

	if (emlxs_els_delay_discovery(port, sbp)) {
		/* Deferred registration of this pkt until */
		/* Clean Address timeout */
		return;
	}

	if (EMLXS_SLI_REG_DID(port, FABRIC_DID, &port->fabric_sparam, sbp,
	    NULL, NULL) == 0) {
		/*
		 * Deferred completion of this pkt until login is complete
		 */
		return;
	}

	emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);

	return;

} /* emlxs_handle_sol_fdisc() */


static void
emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t *cfg = &CFG;
	SERV_PARM *sp;
	fc_packet_t *pkt;
	uint32_t did;
	uint32_t sid;
	NODELIST *ndlp;
	char buffer[64];

	pkt = PRIV2PKT(sbp);
	sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
	sid = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.s_id);

	buffer[0] = 0;

#ifdef DHCHAP_SUPPORT
	if (!sp->cmn.fcsp_support) {
		(void) strlcat(buffer, "fcsp:Unsupported",
		    sizeof (buffer));
	} else if (cfg[CFG_AUTH_ENABLE].current && cfg[CFG_AUTH_E2E].current &&
	    (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
		(void) strlcat(buffer, "fcsp:Supported",
		    sizeof (buffer));
	} else {
		(void) strlcat(buffer, "fcsp:Disabled",
		    sizeof (buffer));
	}
#endif /* DHCHAP_SUPPORT */

	if (hba->flag & FC_PT_TO_PT) {
		mutex_enter(&EMLXS_PORT_LOCK);

		port->did = sid;
		port->rdid = did;

		/* Save E_D_TOV ticks in nanoseconds */
		if (sp->cmn.edtovResolution) {
			hba->fc_edtov =
			    (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
		} else {
			hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
		}

		/* Only E_D_TOV is valid for PLOGI in pt2pt mode */

		mutex_exit(&EMLXS_PORT_LOCK);
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
	    "PLOGI: sid=%x did=%x %s", sid, did, buffer);

	/* Preset the pkt state for reg_did */
	emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);

	/*
	 * Do register login to Firmware before calling packet completion
	 */
	if (EMLXS_SLI_REG_DID(port, did, sp, sbp, NULL, NULL) == 0) {
		/*
		 * Deferred completion of this pkt until login is complete
		 */
		return;
	}

	ndlp = emlxs_node_find_did(port, did, 1);

	if (ndlp && ndlp->nlp_active) {
		/* Open the node again */
		emlxs_node_open(port, ndlp, hba->channel_fcp);
		emlxs_node_open(port, ndlp, hba->channel_ip);
	}

	emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);

	return;

} /* emlxs_handle_sol_plogi() */


static void
emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp)
{
	emlxs_hba_t *hba = HBA;
	fc_packet_t *pkt;
	uint32_t did;
	NODELIST *ndlp;

	pkt = PRIV2PKT(sbp);
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "ADISC: did=%x",
	    did);

	ndlp = emlxs_node_find_did(port, did, 1);

	if (ndlp && ndlp->nlp_active) {
		/* Open the node again */
		emlxs_node_open(port, ndlp, hba->channel_fcp);
		emlxs_node_open(port, ndlp, hba->channel_ip);

		if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {

			emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);

			if (emlxs_rpi_resume_notify(port,
			    ndlp->rpip, sbp) == 0) {
				/*
				 * Delay ADISC cmpl to ULP till
				 * after RESUME_RPI
				 */
				return;
			}
		}
	}

	emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);

	return;

} /* emlxs_handle_sol_adisc() */


static void
emlxs_handle_sol_prli(emlxs_port_t *port, emlxs_buf_t *sbp)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t *cfg = &CFG;
	fc_packet_t *pkt;
	NODELIST *ndlp;
	uint32_t did;
	PRLI *npr;
	uint32_t task_retry_id;

	pkt = PRIV2PKT(sbp);
	npr = (PRLI *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);

	ndlp = emlxs_node_find_did(port, did, 1);

	if (ndlp && ndlp->nlp_active) {
		/* Check for FCP support */
		if ((npr->acceptRspCode == PRLI_REQ_EXECUTED) &&
		    (npr->prliType == PRLI_FCP_TYPE)) {
			/* Clear FCP2 support if no ADISC support requested */
			if (cfg[CFG_ADISC_SUPPORT].current == 0) {
				npr->ConfmComplAllowed = 0;
				npr->TaskRetryIdReq = 0;
				npr->Retry = 0;
			}

			/* Check for target */
			if (npr->targetFunc) {
				ndlp->nlp_fcp_info |= NLP_FCP_TGT_DEVICE;
			} else {
				ndlp->nlp_fcp_info &= ~NLP_FCP_TGT_DEVICE;
			}
#ifdef NODE_THROTTLE_SUPPORT
			emlxs_node_throttle_set(port, ndlp);
#endif /* NODE_THROTTLE_SUPPORT */

			/* Check for initiator */
			if (npr->initiatorFunc) {
				ndlp->nlp_fcp_info |= NLP_FCP_INI_DEVICE;
			} else {
				ndlp->nlp_fcp_info &= ~NLP_FCP_INI_DEVICE;
			}

			/* If TRI support is not required then force */
			/* the task_retry_id value to one */
			if (cfg[CFG_TRI_REQUIRED].current == 0) {
				task_retry_id = 1;
			} else {
				task_retry_id = npr->TaskRetryIdReq;
			}

			/* Check for FCP2 target support */
			/* Retry and TaskRetryId bits are both required here */
			if (npr->targetFunc && npr->Retry && task_retry_id) {
				ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
			} else {
				ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
			}
		}

		/* Open the node again */
		emlxs_node_open(port, ndlp, hba->channel_fcp);

		EMLXS_SET_DFC_STATE(ndlp, NODE_ALLOC);

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
		    "PRLI: did=%x info=%02x", did, ndlp->nlp_fcp_info);

		/*
		 * Report PRLI completion
		 */
		emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);

	} else {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
		    "PRLI: did=%x: Node not found. Failing.", did);

		/*
		 * Report PRLI failed
		 */
		emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
		    IOERR_INVALID_RPI, 1);
	}
	return;

} /* emlxs_handle_sol_prli() */


static void
emlxs_handle_sol_logo(emlxs_port_t *port, emlxs_buf_t *sbp)
{
	emlxs_hba_t *hba = HBA;
	fc_packet_t *pkt;
	uint32_t did;
	NODELIST *ndlp;

	pkt = PRIV2PKT(sbp);
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "LOGO: did=%x",
	    did);

	ndlp = emlxs_node_find_did(port, did, 1);

	if (ndlp && ndlp->nlp_active) {
		EMLXS_SET_DFC_STATE(ndlp, NODE_LOGOUT);

		if ((hba->sli_mode == EMLXS_HBA_SLI4_MODE) &&
		    (ndlp->nlp_DID == FABRIC_DID)) {
			(void) emlxs_vpi_logo_cmpl_notify(port);
		} else {
			/* Close the node for any further normal IO */
			emlxs_node_close(port, ndlp, hba->channel_fcp, 60);
			emlxs_node_close(port, ndlp, hba->channel_ip, 60);

			/* Flush tx queues */
			(void) emlxs_tx_node_flush(port, ndlp, 0, 0, 0);

			/* Flush chip queues */
			(void) emlxs_chipq_node_flush(port, 0, ndlp, 0);
		}
	}

	emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);

	if ((hba->sli_mode == EMLXS_HBA_SLI3_MODE) &&
	    (ndlp->nlp_DID == FABRIC_DID)) {
		port->flag &= ~EMLXS_PORT_FLOGI_CMPL;
	}

	return;

} /* emlxs_handle_sol_logo() */


/* ARGSUSED */
static void
emlxs_handle_unsol_rscn(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	uint32_t *lp;
	fc_unsol_buf_t *ubp;
	uint8_t *bp;
	IOCB *iocb;
	uint32_t count;
	uint32_t sid;
	emlxs_ub_priv_t *ub_priv;

	iocb = &iocbq->iocb;
	bp = mp->virt;
	lp = (uint32_t *)bp + 1;
	sid = iocb->un.elsreq.remoteID;

	/* Log the legacy rscn event for physical port only */
	if (port->vpi == 0) {
		emlxs_log_rscn_event(port, bp, size);
	}

	/* Log the vport rscn event for all ports */
	emlxs_log_vportrscn_event(port, bp, size);

	count = ((size - 4) / 4);

	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size,
	    FC_TYPE_EXTENDED_LS, 1);

	if (ubp == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
		    "RSCN rcvd: sid=%x  %d page(s): %08X, %08X. Rejecting.",
		    sid, count, LE_SWAP32(*lp),
		    ((count > 1) ? LE_SWAP32(*(lp + 1)) : 0));

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_RSCN, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);

		goto drop_it;
	}

	bcopy(bp, ubp->ub_buffer, size);
	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = ELS_CMD_RSCN;

	/*
	 * Setup frame header
	 */
	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
	ubp->ub_class = FC_TRAN_CLASS3;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "RSCN: sid=%x  %d page(s): %08X, %08X  buffer=%p token=%x.", sid,
	    count, LE_SWAP32(*lp),
	    ((count > 1) ? LE_SWAP32(*(lp + 1)) : 0), ubp, ub_priv->token);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	emlxs_ub_callback(port, ubp);

drop_it:

	return;

} /* emlxs_handle_unsol_rscn() */


/* This is shared by FCT driver */
extern uint32_t
emlxs_process_unsol_flogi(emlxs_port_t *port, IOCBQ *iocbq, MATCHMAP *mp,
    uint32_t size, char *buffer, size_t len)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t *cfg = &CFG;
	uint8_t *bp;
	IOCB *iocb;
	uint32_t sid;
	SERV_PARM *sp;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

	/* Check payload size */
	if (size < (sizeof (SERV_PARM) + 4)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "FLOGI: sid=%x. Payload too small. %d<%d Rejecting.", sid,
		    size, (sizeof (SERV_PARM) + 4));

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_FLOGI, LSRJT_PROTOCOL_ERR, LSEXP_NOTHING_MORE);

		return (1);
	}

	bp = mp->virt;
	sp = (SERV_PARM *)(bp + sizeof (uint32_t));

	mutex_enter(&EMLXS_PORT_LOCK);

	hba->flag &= ~FC_FABRIC_ATTACHED;
	hba->flag |= FC_PT_TO_PT;

	bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));

	/* Save E_D_TOV ticks in nanoseconds */
	if (sp->cmn.edtovResolution) {
		hba->fc_edtov =
		    (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
	} else {
		hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
	}

	/* Typically the FLOGI ACC rsp has the R_A_TOV value both sides use */

	hba->flag &= ~FC_NPIV_SUPPORTED;
	(void) strlcpy(buffer, "npiv:Disabled.", len);

	if (emlxs_wwn_cmp((uint8_t *)&sp->portName,
	    (uint8_t *)&port->wwpn) > 0) {
		(void) strlcat(buffer, " P2P Master.", len);
	} else {
		(void) strlcat(buffer, " P2P Slave.", len);
	}

#ifdef DHCHAP_SUPPORT
	if (!sp->cmn.fcsp_support) {
		(void) strlcat(buffer, " fcsp:Unsupported", len);
	} else if (cfg[CFG_AUTH_ENABLE].current &&
	    (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
		(void) strlcat(buffer, " fcsp:Supported", len);
	} else {
		(void) strlcat(buffer, " fcsp:Disabled", len);
	}
#endif /* DHCHAP_SUPPORT */

	mutex_exit(&EMLXS_PORT_LOCK);

	return (0);

} /* emlxs_process_unsol_flogi() */


/* ARGSUSED */
static void
emlxs_handle_unsol_flogi(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	uint8_t *bp;
	fc_unsol_buf_t *ubp;
	IOCB *iocb;
	uint32_t sid;
	emlxs_ub_priv_t *ub_priv;
	char buffer[64];

	buffer[0] = 0;

	/* Perform processing of FLOGI payload */
	if (emlxs_process_unsol_flogi(port, iocbq, mp, size, buffer,
	    sizeof (buffer))) {
		return;
	}

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;
	bp = mp->virt;
	size = sizeof (SERV_PARM) + 4;

	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size,
	    FC_TYPE_EXTENDED_LS, 0);

	if (ubp == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
		    "FLOGI rcvd: sid=%x. Rejecting.", sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_FLOGI, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);

		goto drop_it;
	}

	/*
	 * Setup unsolicited buffer and pass it up
	 */
	bcopy(bp, ubp->ub_buffer, size);
	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = ELS_CMD_FLOGI;

	/*
	 * Setup frame header
	 */
	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
	ubp->ub_class = FC_TRAN_CLASS3;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "FLOGI: sid=%x buffer=%p token=%x %s", sid, ubp, ub_priv->token,
	    buffer);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	emlxs_ub_callback(port, ubp);

drop_it:

	return;

} /* emlxs_handle_unsol_flogi() */



/* This is shared by FCT driver */
extern uint32_t
emlxs_process_unsol_plogi(emlxs_port_t *port, IOCBQ *iocbq, MATCHMAP *mp,
    uint32_t size, char *buffer, size_t len)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t *cfg = &CFG;
	uint8_t *bp;
	IOCB *iocb;
	uint32_t sid;
	uint32_t did;
	SERV_PARM *sp;
	MAILBOXQ *mbox;
	emlxs_vvl_fmt_t vvl;
	int rc;

	iocb = &iocbq->iocb;
	did = iocb->un.elsreq.myID;
	sid = iocb->un.elsreq.remoteID;

	if (size < (sizeof (SERV_PARM) + 4)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "PLOGI: sid=%x. Payload too small. %d<%d Rejecting.", sid,
		    size, (sizeof (SERV_PARM) + 4));

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_PLOGI, LSRJT_PROTOCOL_ERR, LSEXP_NOTHING_MORE);

		return (1);
	}

	bp = mp->virt;
	sp = (SERV_PARM *)(bp + sizeof (uint32_t));

	bzero((char *)&vvl, sizeof (emlxs_vvl_fmt_t));

	if (sp->VALID_VENDOR_VERSION) {

		bcopy((caddr_t *)&sp->vendorVersion[0],
		    (caddr_t *)&vvl, sizeof (emlxs_vvl_fmt_t));
		vvl.un0.word0 = LE_SWAP32(vvl.un0.word0);
		vvl.un1.word1 = LE_SWAP32(vvl.un1.word1);
	}

	if ((port->mode == MODE_INITIATOR) &&
	    (port->flag & EMLXS_PORT_RESTRICTED)) {
		uint32_t reject_it = 0;

		/* If remote port is the virtual port, then reject it */
		if ((vvl.un0.w0.oui == 0x0000C9) && (vvl.un1.w1.vport)) {
			reject_it = 1;
		}

		/* If we are a virtual port and the remote device */
		/* is not a switch, then reject it */
		else if (port->vpi && ((sid & FABRIC_DID_MASK) !=
		    FABRIC_DID_MASK)) {
			reject_it = 1;
		}

		if (reject_it) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
			    "PLOGI rcvd: sid=%x. Restricted. Rejecting.",
			    sid);

			(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
			    ELS_CMD_PLOGI, LSRJT_UNABLE_TPC,
			    LSEXP_NOTHING_MORE);

			/* Clear temporary RPI in firmware */
			if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
				(void) EMLXS_SLI_REG_DID(port, sid, sp,
				    NULL, NULL, (IOCBQ *)1);
			}

			return (1);
		}
	}

#ifdef DHCHAP_SUPPORT
	if (emlxs_dhc_verify_login(port, sid, sp)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "PLOGI: sid=%x. FCSP disabled. Rejecting.", sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_PLOGI, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);

		return (1);
	}

	if (!sp->cmn.fcsp_support) {
		(void) strlcat(buffer, "fcsp:Unsupported", len);
	} else if (cfg[CFG_AUTH_ENABLE].current && cfg[CFG_AUTH_E2E].current &&
	    (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
		(void) strlcat(buffer, "fcsp:Supported", len);
	} else {
		(void) strlcat(buffer, "fcsp:Disabled", len);
	}
#endif /* DHCHAP_SUPPORT */

	/* Check if this was a point to point Plogi */
	if (hba->flag & FC_PT_TO_PT) {
		mutex_enter(&EMLXS_PORT_LOCK);

		port->did = did;
		port->rdid = sid;

		/* Save E_D_TOV ticks in nanoseconds */
		if (sp->cmn.edtovResolution) {
			hba->fc_edtov =
			    (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
		} else {
			hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
		}

		/* Only E_D_TOV is valid for PLOGI in pt2pt mode */

		mutex_exit(&EMLXS_PORT_LOCK);

		if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
			/* Update our service parms */
			if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba,
			    MEM_MBOX))) {
				emlxs_mb_config_link(hba, mbox);

				rc =  EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
				    MBX_NOWAIT, 0);
				if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
					emlxs_mem_put(hba, MEM_MBOX,
					    (void *)mbox);
				}

			}
		}
	}

	return (0);

} /* emlxs_process_unsol_plogi() */


/* ARGSUSED */
static void
emlxs_handle_unsol_plogi(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	fc_unsol_buf_t *ubp;
	uint8_t *bp;
	IOCB *iocb;
	uint32_t sid;
	uint32_t did;
	emlxs_ub_priv_t *ub_priv;
	SERV_PARM *sp;
	char buffer[64];

	buffer[0] = 0;

	/* Perform processing of PLOGI payload */
	if (emlxs_process_unsol_plogi(port, iocbq, mp, size, buffer,
	    sizeof (buffer))) {
		return;
	}

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;
	did = iocb->un.elsreq.myID;
	bp = mp->virt;
	sp = (SERV_PARM *)(bp + sizeof (uint32_t));
	size = sizeof (SERV_PARM) + 4;

#ifdef SAN_DIAG_SUPPORT
	emlxs_log_sd_basic_els_event(port, SD_ELS_SUBCATEGORY_PLOGI_RCV,
	    (HBA_WWN *)&sp->portName, (HBA_WWN *)&sp->nodeName);
#endif

	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size,
	    FC_TYPE_EXTENDED_LS, 0);

	if (ubp == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
		    "PLOGI rcvd: sid=%x. Rejecting.", sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_PLOGI, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);

		goto drop_it;
	}

	/*
	 * Setup unsolicited buffer and pass it up
	 */
	bcopy(bp, ubp->ub_buffer, size);
	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = ELS_CMD_PLOGI;

	/*
	 * Setup frame header
	 */
	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
	ubp->ub_class = FC_TRAN_CLASS3;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "PLOGI: sid=%x did=%x buffer=%p token=%x %s", sid, did, ubp,
	    ub_priv->token, buffer);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	/* Create a new node and defer callback */
	if (EMLXS_SLI_REG_DID(port, sid, sp, NULL, ubp, NULL) == 0) {
		/*
		 * Defer completion of this pkt until login is complete
		 */
		goto drop_it;
	}

	emlxs_ub_callback(port, ubp);

drop_it:

	return;

} /* emlxs_handle_unsol_plogi() */


/* ARGSUSED */
static void
emlxs_handle_unsol_prli(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t	*hba = HBA;
	emlxs_config_t	*cfg = &CFG;
	IOCB *iocb;
	uint32_t sid;
	NODELIST *ndlp;
	PRLI *npr;
	fc_unsol_buf_t *ubp;
	emlxs_ub_priv_t *ub_priv;
	uint32_t task_retry_id;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;
	ndlp = emlxs_node_find_did(port, sid, 1);

	if (!ndlp || !ndlp->nlp_active) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "PRLI: sid=%x: Node not found. Rejecting.", sid);

		/* Auto reply to PRLI's */
		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_PRLI, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);

		goto drop_it;
	}

	/* If node exists then save FCP2 support */
	npr = (PRLI *)((caddr_t)mp->virt + sizeof (uint32_t));

	/* Check for FCP2 support */
	if ((npr->prliType == PRLI_FCP_TYPE) && npr->targetFunc) {
		/* Clear FCP2 support if no ADISC support is requested */
		if (cfg[CFG_ADISC_SUPPORT].current == 0) {
			npr->ConfmComplAllowed = 0;
			npr->TaskRetryIdReq = 0;
			npr->Retry = 0;
		}

		/* Check for target */
		if (npr->targetFunc) {
			ndlp->nlp_fcp_info |= NLP_FCP_TGT_DEVICE;
		} else {
			ndlp->nlp_fcp_info &= ~NLP_FCP_TGT_DEVICE;
		}
#ifdef NODE_THROTTLE_SUPPORT
		emlxs_node_throttle_set(port, ndlp);
#endif /* NODE_THROTTLE_SUPPORT */

		/* Check for initiator */
		if (npr->initiatorFunc) {
			ndlp->nlp_fcp_info |= NLP_FCP_INI_DEVICE;
		} else {
			ndlp->nlp_fcp_info &= ~NLP_FCP_INI_DEVICE;
		}

		/* If TRI support is not required then force */
		/* the task_retry_id value to one */
		if (cfg[CFG_TRI_REQUIRED].current == 0) {
			task_retry_id = 1;
		} else {
			task_retry_id = npr->TaskRetryIdReq;
		}

		/* Check for FCP2 target support */
		/* Retry and TaskRetryId bits are both required here */
		if (npr->targetFunc && npr->Retry && task_retry_id) {
			ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
		} else {
			ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
		}
	}

#ifdef ULP_PATCH3
	if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH3) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "PRLI: sid=%x. Accepting.", sid);

		/* Auto reply to PRLI's */
		(void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
		    ELS_CMD_PRLI, 0, 0);
		goto drop_it;
	}
#endif /* ULP_PATCH3 */

	/* Tell ULP about it */
	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size,
	    FC_TYPE_EXTENDED_LS, 0);

	if (ubp == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
		    "PRLI rcvd: sid=%x. Rejecting.", sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_PRLI, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);

		goto drop_it;
	}

	/*
	 * Setup unsolicited buffer and pass it up
	 */
	bcopy(mp->virt, ubp->ub_buffer, size);
	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = ELS_CMD_PRLI;

	/*
	 * Setup frame header
	 */
	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
	ubp->ub_class = FC_TRAN_CLASS3;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "PRLI: sid=%x buffer=%p token=%x info=%02x", sid, ubp,
	    ub_priv->token, ndlp->nlp_fcp_info);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	emlxs_ub_callback(port, ubp);

drop_it:

	return;

} /* emlxs_handle_unsol_prli() */


/* ARGSUSED */
static void
emlxs_handle_unsol_auth(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	IOCB *iocb;
	uint32_t sid;
	NODELIST *ndlp;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

#ifdef DHCHAP_SUPPORT
	ndlp = emlxs_node_find_did(port, sid, 1);

	if (!ndlp || !ndlp->nlp_active) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "AUTH: sid=%x: Node not found. Rejecting.", sid);

		/* Auto reply to AUTH_ELS's */
		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_AUTH, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);

		goto drop_it;
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg, "AUTH: sid=%x", sid);

	(void) emlxs_dhchap_state_machine(port, cp, iocbq, mp, ndlp,
	    NODE_EVENT_RCV_AUTH_MSG);
#else

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "AUTH: sid=%x: Rejecting.", sid);
	(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT, ELS_CMD_AUTH,
	    LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);

#endif /* DHCAHP_SUPPORT */

drop_it:

	return;

} /* emlxs_handle_unsol_auth() */


/* ARGSUSED */
static void
emlxs_handle_unsol_adisc(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	IOCB		*iocb;
#ifdef SAN_DIAG_SUPPORT
	NODELIST	*ndlp;
#endif
	uint32_t	sid;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

#ifdef SAN_DIAG_SUPPORT
	ndlp = emlxs_node_find_did(port, sid, 1);

	if (ndlp) {
		emlxs_log_sd_basic_els_event(port, SD_ELS_SUBCATEGORY_ADISC_RCV,
		    (HBA_WWN *)&ndlp->nlp_portname,
		    (HBA_WWN *)&ndlp->nlp_nodename);
	}
#endif

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "ADISC: sid=%x: Accepting.", sid);
	(void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_ADISC, 0, 0);

	return;

} /* emlxs_handle_unsol_adisc() */


/* ARGSUSED */
static void
emlxs_handle_unsol_prlo(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t	*hba = HBA;
	emlxs_config_t	*cfg = &CFG;
	IOCB *iocb;
	uint32_t sid;
	fc_unsol_buf_t *ubp;
	emlxs_ub_priv_t *ub_priv;
	NODELIST *ndlp;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

	/* Get the node */
	ndlp = emlxs_node_find_did(port, sid, 1);

#ifdef SAN_DIAG_SUPPORT
	if (ndlp) {
		emlxs_log_sd_prlo_event(port, (HBA_WWN *)&ndlp->nlp_portname);
	}
#endif

#ifdef ULP_PATCH4
	if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH4) {
#ifdef ULP_PATCH6
		if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH6) {
			/* Check if this is a SCSI target */
			if (ndlp && (ndlp->nlp_fcp_info & NLP_FCP_TGT_DEVICE)) {
				/* This is a SCSI target */

				/* If only one node is present, then we can */
				/* conclude that we are direct attached */
				/* to a target */
				if (port->node_count == 1) {
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_unsol_els_msg,
					    "PRLO: sid=%x. Accepting and " \
					    "reseting link.",
					    sid);

					/* Send Acc */
					(void) emlxs_els_reply(port, iocbq,
					    ELS_CMD_ACC, ELS_CMD_PRLO, 0, 0);

					/* Spawn a thread to reset the link */
					emlxs_thread_spawn(hba,
					    emlxs_reset_link_thread,
					    NULL, NULL);

					goto drop_it;

				}
				/* Check if fabric is present */
				else if (hba->flag & FC_FABRIC_ATTACHED) {
					/* Auto reply to PRLO */
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_unsol_els_msg,
					    "PRLO: sid=%x. Accepting and " \
					    "generating RSCN.",
					    sid);

					/* Send Acc */
					(void) emlxs_els_reply(port, iocbq,
					    ELS_CMD_ACC, ELS_CMD_PRLO, 0, 0);

					/* Generate an RSCN to wakeup ULP */
					(void) emlxs_generate_rscn(port, sid);

					goto drop_it;
				}
			}
		}
#endif /* ULP_PATCH6 */

		/* Auto reply to PRLO */
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "PRLO: sid=%x. Accepting.", sid);

		/* Send Acc */
		(void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
		    ELS_CMD_PRLO, 0, 0);

		goto drop_it;
	}
#endif /* ULP_PATCH4 */

	/* Tell ULP about it */

	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size,
	    FC_TYPE_EXTENDED_LS, 0);

	if (ubp == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
		    "PRLO recvd: sid=%x. Rejecting.", sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_PRLO, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);

		goto drop_it;
	}

	/*
	 * Setup unsolicited buffer and pass it up
	 */
	bcopy(mp->virt, ubp->ub_buffer, size);
	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = ELS_CMD_PRLO;

	/*
	 * Setup frame header
	 */
	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
	ubp->ub_class = FC_TRAN_CLASS3;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "PRLO: sid=%x buffeiocbr=%p token=%x.", sid, ubp, ub_priv->token);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	emlxs_ub_callback(port, ubp);

drop_it:

	return;

} /* emlxs_handle_unsol_prlo() */


/* ARGSUSED */
static void
emlxs_handle_unsol_logo(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t	*cfg = &CFG;
	fc_unsol_buf_t *ubp;
	IOCB *iocb;
	uint32_t sid;
	emlxs_ub_priv_t *ub_priv;
	uint32_t reply_sent = 0;
	NODELIST *ndlp;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

	ndlp = emlxs_node_find_did(port, sid, 1);

#ifdef SAN_DIAG_SUPPORT
	if (ndlp) {
		emlxs_log_sd_basic_els_event(port,  SD_ELS_SUBCATEGORY_LOGO_RCV,
		    (HBA_WWN *)&ndlp->nlp_portname,
		    (HBA_WWN *)((uint32_t *)mp->virt + 2));
	}
#endif

	EMLXS_SET_DFC_STATE(ndlp, NODE_LOGOUT);

#ifdef ULP_PATCH6
	if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH6) {
		/* Check if this is a SCSI target */
		if (ndlp && (ndlp->nlp_fcp_info & NLP_FCP_TGT_DEVICE)) {
			/* This is a SCSI target */

			/* If only one node is present, then we can */
			/* conclude that we are direct attached to a target */
			if (port->node_count == 1) {
				EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
				    "LOGO: sid=%x. Accepting and "\
				    "reseting link.", sid);

				(void) emlxs_els_reply(port, iocbq,
				    ELS_CMD_ACC, ELS_CMD_LOGO, 0, 0);

				/* Spawn a thread to reset the link */
				emlxs_thread_spawn(hba, emlxs_reset_link_thread,
				    NULL, NULL);

				goto drop_it;
			}
			/* Check if fabric node is present */
			else if (hba->flag & FC_FABRIC_ATTACHED) {
				/* Send reply ourselves */
				/* We will block all attempts */
				/* for ULP to reply to a LOGO */
				EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
				    "LOGO: sid=%x. Accepting and " \
				    "generating RSCN.", sid);

				(void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
				    ELS_CMD_LOGO, 0, 0);

				/* Generate an RSCN to wakeup ULP */
				if (emlxs_generate_rscn(port, sid)
				    == FC_SUCCESS) {
					goto drop_it;
				}

				reply_sent = 1;
			}
		}
	}
#endif /* ULP_PATCH6 */

	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size,
	    FC_TYPE_EXTENDED_LS, 1);

	if (ubp == NULL) {
		if (!reply_sent) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
			    "LOGO rcvd: sid=%x. Rejecting.", sid);

			(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
			    ELS_CMD_LOGO, LSRJT_LOGICAL_BSY,
			    LSEXP_OUT_OF_RESOURCE);
		}

		goto drop_it;

	}

	/* Setup unsolicited buffer and pass it up */
	bcopy(mp->virt, ubp->ub_buffer, size);
	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = ELS_CMD_LOGO;

	/* Setup frame header */
	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
	ubp->ub_class = FC_TRAN_CLASS3;

#ifdef ULP_PATCH2
	if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH2) {
		if (!reply_sent) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
			    "LOGO: sid=%x buffer=%p token=%x. Accepting.",
			    sid, ubp, ub_priv->token);

			ub_priv->flags |= EMLXS_UB_REPLY;

			/* Send Acc */
			/* Send reply ourselves because ULP */
			/* doesn't always reply to these */
			/* We ll block attempts for ULP to reply to a LOGO */
			(void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
			    ELS_CMD_LOGO, 0, 0);
			reply_sent = 1;
		}
	}
#endif /* ULP_PATCH2 */

	if (!reply_sent) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "LOGO: sid=%x buffer=%p token=%x.", sid, ubp,
		    ub_priv->token);
	}

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	/* Unregister the node */
	if ((sid & FABRIC_DID_MASK) == FABRIC_DID_MASK) {
		if (ndlp) {
			if (EMLXS_SLI_UNREG_NODE(port, ndlp, NULL,
			    ubp, NULL) == 0) {
				/*
				 * Deferred completion of this ubp
				 * until unreg login is complete
				 */
				return;
			}
		}
	}

	emlxs_ub_callback(port, ubp);

drop_it:

	return;

} /* emlxs_handle_unsol_logo() */



/* ARGSUSED */
static void
emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	uint8_t *bp;
	fc_unsol_buf_t *ubp;
	IOCB *iocb;
	uint32_t *lp;
	uint32_t cmd;
	uint32_t sid;
	emlxs_ub_priv_t *ub_priv;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

	bp = mp->virt;
	lp = (uint32_t *)bp;
	cmd = *lp & ELS_CMD_MASK;

	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size,
	    FC_TYPE_EXTENDED_LS, 0);

	if (ubp == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
		    "%s rcvd: sid=%x: Rejecting.", emlxs_elscmd_xlate(cmd),
		    sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT, cmd,
		    LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);

		goto drop_it;
	}

	bcopy(bp, ubp->ub_buffer, size);
	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = cmd;

	/* Setup frame header */
	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
	ubp->ub_class = FC_TRAN_CLASS3;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "%s: sid=%x buffer=%p token=%x.", emlxs_elscmd_xlate(cmd), sid,
	    ubp, ub_priv->token);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	emlxs_ub_callback(port, ubp);

drop_it:

	return;

} /* emlxs_handle_unsol_gen_cmd() */


/* ARGSUSED */
static void
emlxs_handle_unsol_echo(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	uint8_t *bp;
	IOCB *iocb;
	uint32_t *lp;
	uint32_t sid;
	fc_packet_t *pkt;
	uint32_t cmd;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

	bp = mp->virt;
	lp = (uint32_t *)bp;
	cmd = *lp & ELS_CMD_MASK;

	if (!(pkt = emlxs_pkt_alloc(port,
	    size, 0, 0, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "ECHO: sid=%x. Unable to allocate pkt. Rejecting.",
		    sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_ECHO, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
		return;
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "ECHO: sid=%x. Accepting.",
	    sid);

	/* Common initialization */
	pkt->pkt_tran_type = FC_PKT_OUTBOUND;
	pkt->pkt_timeout = (2 * hba->fc_ratov);

	if ((uint32_t)iocb->ULPCLASS == CLASS2) {
		pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
		pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
	}

	/* Build the fc header */
	pkt->pkt_cmd_fhdr.d_id =
	    LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	pkt->pkt_cmd_fhdr.r_ctl =
	    R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
	pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
	pkt->pkt_cmd_fhdr.f_ctl =
	    F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = (cmd >> ELS_CMD_SHIFT) & 0xff;
	pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
	pkt->pkt_cmd_fhdr.ro = 0;

	/* Build the response */
	*lp = ELS_CMD_ACC;
	bcopy(lp, pkt->pkt_cmd, size);

	if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
		/* Free the pkt */
		emlxs_pkt_free(pkt);
		emlxs_abort_els_exchange(hba, port, iocb->ULPCONTEXT);
	}

	return;

} /* emlxs_handle_unsol_echo() */


/* ARGSUSED */
static void
emlxs_handle_unsol_rtv(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	uint8_t *bp;
	IOCB *iocb;
	uint32_t *lp;
	uint32_t sid;
	fc_packet_t *pkt;
	uint32_t cmd;
	SERV_PARM *sp;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

	bp = mp->virt;
	lp = (uint32_t *)bp;
	cmd = *lp & ELS_CMD_MASK;

	if (!(pkt = emlxs_pkt_alloc(port,
	    (4 * sizeof (uint32_t)), 0, 0, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "RTV: sid=%x. Unable to allocate pkt. Rejecting.",
		    sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_RTV, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
		return;
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "RTV: sid=%x. Accepting.",
	    emlxs_elscmd_xlate(cmd),
	    sid);

	/* Common initialization */
	pkt->pkt_tran_type = FC_PKT_OUTBOUND;
	pkt->pkt_timeout = (2 * hba->fc_ratov);

	if ((uint32_t)iocb->ULPCLASS == CLASS2) {
		pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
		pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
	}

	/* Build the fc header */
	pkt->pkt_cmd_fhdr.d_id =
	    LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	pkt->pkt_cmd_fhdr.r_ctl =
	    R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
	pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
	pkt->pkt_cmd_fhdr.f_ctl =
	    F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = (cmd >> ELS_CMD_SHIFT) & 0xff;
	pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
	pkt->pkt_cmd_fhdr.ro = 0;

	/* Build the response */
	sp = (SERV_PARM *)&port->fabric_sparam;
	lp = (uint32_t *)pkt->pkt_cmd;
	lp[0] = ELS_CMD_ACC;
	lp[1] = LE_SWAP32(sp->cmn.w2.r_a_tov);
	lp[2] = LE_SWAP32(sp->cmn.e_d_tov);
	lp[3] = sp->cmn.edtovResolution << 26;

	if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
		/* Free the pkt */
		emlxs_pkt_free(pkt);
		emlxs_abort_els_exchange(hba, port, iocb->ULPCONTEXT);
	}

	return;

} /* emlxs_handle_unsol_rtv() */


/* ARGSUSED */
static void
emlxs_rls_rsp_thread(emlxs_hba_t *hba, void *arg1, void *arg2)
{
	emlxs_port_t *port = (emlxs_port_t *)arg1;
	fc_packet_t *pkt = (fc_packet_t *)arg2;
	MAILBOXQ	*mbq = NULL;
	MAILBOX		*mb;
	la_els_rls_acc_t *rls;
	uint32_t rval;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "RLS: sid=%x. Accepting.",
	    LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id));

	if (!(mbq = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX))) {
		goto dropit;
	}
	mb = (MAILBOX *)mbq;

	/* Read current link status */
	emlxs_mb_read_lnk_stat(hba, mbq);
	rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);

	if (rval != MBX_SUCCESS) {
		goto dropit;
	}

	/* Build the response */
	rls = (la_els_rls_acc_t *)pkt->pkt_cmd;
	rls->ls_code.ls_code = 0x02;
	rls->rls_link_params.rls_link_fail =
	    mb->un.varRdLnk.linkFailureCnt;
	rls->rls_link_params.rls_sync_loss =
	    mb->un.varRdLnk.lossSyncCnt;
	rls->rls_link_params.rls_sig_loss =
	    mb->un.varRdLnk.lossSignalCnt;
	rls->rls_link_params.rls_prim_seq_err =
	    mb->un.varRdLnk.primSeqErrCnt;
	rls->rls_link_params.rls_invalid_word =
	    mb->un.varRdLnk.invalidXmitWord;
	rls->rls_link_params.rls_invalid_crc =
	    mb->un.varRdLnk.crcCnt;

	LE_SWAP32_BUFFER((uint8_t *)rls, sizeof (la_els_rls_acc_t));

	emlxs_mem_put(hba, MEM_MBOX, (void *)mbq);
	mbq = NULL;

	if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
		goto dropit;
	}

	return;

dropit:

	emlxs_abort_els_exchange(hba, port, pkt->pkt_cmd_fhdr.rx_id);

	emlxs_pkt_free(pkt);

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

	return;

} /* emlxs_rls_rsp_thread() */


/* ARGSUSED */
static void
emlxs_handle_unsol_rls(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	uint8_t *bp;
	IOCB *iocb;
	uint32_t *lp;
	uint32_t sid;
	fc_packet_t *pkt;
	uint32_t cmd;

	iocb = &iocbq->iocb;
	sid = iocb->un.elsreq.remoteID;

	bp = mp->virt;
	lp = (uint32_t *)bp;
	cmd = *lp++ & ELS_CMD_MASK;

	if (!(pkt = emlxs_pkt_alloc(port,
	    sizeof (la_els_rls_acc_t), 0, 0, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		    "RLS: sid=%x. Unable to allocate pkt.  Rejecting.",
		    sid);

		(void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
		    ELS_CMD_RLS, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
		return;
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "RLS: sid=%x. Scheduling response.",
	    sid);

	/* Common initialization */
	pkt->pkt_tran_type = FC_PKT_OUTBOUND;
	pkt->pkt_timeout = (2 * hba->fc_ratov);

	if ((uint32_t)iocb->ULPCLASS == CLASS2) {
		pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
		pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
	}

	/* Build the fc header */
	pkt->pkt_cmd_fhdr.d_id =
	    LE_SWAP24_LO(iocb->un.elsreq.remoteID);
	pkt->pkt_cmd_fhdr.r_ctl =
	    R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
	pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
	pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
	pkt->pkt_cmd_fhdr.f_ctl =
	    F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = (cmd >> ELS_CMD_SHIFT) & 0xff;
	pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
	pkt->pkt_cmd_fhdr.ro = 0;

	/* We must spawn a separate thread to send the */
	/* read link status mailbox command becasue we are */
	/* normally in a hardware interrupt context here. */
	emlxs_thread_spawn(hba, emlxs_rls_rsp_thread,
	    (void *)port, (void *)pkt);

	return;

} /* emlxs_handle_unsol_rls() */


/* This handles the reply completions to unsolicited cmds */
/* ARGSUSED */
static void
emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
    uint32_t flag)
{
	emlxs_hba_t *hba = HBA;
	fc_packet_t *pkt;
	IOCB *iocb;
	uint32_t did;
	NODELIST *ndlp;
	uint32_t ucmd;
	uint32_t cmd;
	uint32_t *lp;

	iocb = &iocbq->iocb;
	pkt = PRIV2PKT(sbp);
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
	ucmd = pkt->pkt_cmd_fhdr.ox_id << ELS_CMD_SHIFT;
	lp = (uint32_t *)pkt->pkt_cmd;
	cmd = *lp & ELS_CMD_MASK;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
	    "%s %s: did=%x %s %s", emlxs_elscmd_xlate(ucmd),
	    emlxs_elscmd_xlate(cmd), did, emlxs_state_xlate(iocb->ULPSTATUS),
	    emlxs_error_xlate(iocb->un.grsp.perr.statLocalError));

	switch (ucmd) {
	case ELS_CMD_PLOGI:
	case ELS_CMD_ADISC:

		ndlp = emlxs_node_find_did(port, did, 1);

		if (ndlp && ndlp->nlp_active) {
			/* Open the node again */
			emlxs_node_open(port, ndlp, hba->channel_fcp);
			emlxs_node_open(port, ndlp, hba->channel_ip);
		}

		break;

	case ELS_CMD_PRLI:

		ndlp = emlxs_node_find_did(port, did, 1);

		if (ndlp && ndlp->nlp_active) {
			EMLXS_SET_DFC_STATE(ndlp, NODE_ALLOC);

			/* Open the node again */
			emlxs_node_open(port, ndlp, hba->channel_fcp);
		}

		break;
	}

	emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
	    iocb->un.grsp.perr.statLocalError, 1);

	return;

} /* emlxs_handle_acc() */


/* This handles the reply completions to unsolicited cmds */
/* ARGSUSED */
static void
emlxs_handle_reject(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
    uint32_t flag)
{
	emlxs_hba_t *hba = HBA;
	fc_packet_t	*pkt;
	NODELIST	*ndlp;
	IOCB		*iocb;
	uint32_t	did;
	uint32_t	ucmd;
	uint32_t	cmd;
	uint32_t	*lp;

	iocb = &iocbq->iocb;
	pkt = PRIV2PKT(sbp);
	did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
	ucmd = pkt->pkt_cmd_fhdr.ox_id << ELS_CMD_SHIFT;
	lp = (uint32_t *)pkt->pkt_cmd;
	cmd = *lp & ELS_CMD_MASK;

	ndlp = emlxs_node_find_did(port, did, 1);

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
	    "%s %s: did=%x %s %s", emlxs_elscmd_xlate(ucmd),
	    emlxs_elscmd_xlate(cmd), did, emlxs_state_xlate(iocb->ULPSTATUS),
	    emlxs_error_xlate(iocb->un.grsp.perr.statLocalError));

	switch (ucmd) {
	case ELS_CMD_PLOGI:

		if (ndlp && ndlp->nlp_active) {
			/* Open the node again */
			emlxs_node_open(port, ndlp, hba->channel_fcp);
			emlxs_node_open(port, ndlp, hba->channel_ip);
		}

		break;

	case ELS_CMD_PRLI:

		if (ndlp && ndlp->nlp_active) {
			/* Open the node again */
			emlxs_node_open(port, ndlp, hba->channel_fcp);
		}

		break;
	}

	emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
	    iocb->un.grsp.perr.statLocalError, 1);

	return;

} /* emlxs_handle_reject() */


/* ARGSUSED */
extern int32_t
emlxs_els_reply(emlxs_port_t *port, IOCBQ *iocbq, uint32_t type,
    uint32_t type2, uint32_t reason, uint32_t explain)
{
	emlxs_hba_t *hba = HBA;
	emlxs_config_t *cfg = &CFG;
	fc_packet_t *pkt;
	ELS_PKT *els;
	IOCB *iocb;

	iocb = &iocbq->iocb;

	switch (type) {
	case ELS_CMD_ACC:	/* Accept Response */

		/* Allocate the pkt */
		switch (type2) {
		case ELS_CMD_FLOGI:
			pkt = emlxs_pkt_alloc(port,
			    sizeof (uint32_t) + sizeof (SERV_PARM), 0,
			    0, KM_NOSLEEP);
			break;

		case ELS_CMD_ADISC:
			pkt = emlxs_pkt_alloc(port,
			    sizeof (uint32_t) + sizeof (ADISC), 0, 0,
			    KM_NOSLEEP);
			break;

		case ELS_CMD_PRLI:
			pkt = emlxs_pkt_alloc(port,
			    sizeof (uint32_t) + sizeof (PRLI), 0, 0,
			    KM_NOSLEEP);
			break;

		case ELS_CMD_PRLO:
			pkt = emlxs_pkt_alloc(port,
			    sizeof (uint32_t) + sizeof (PRLO), 0, 0,
			    KM_NOSLEEP);
			break;

		case ELS_CMD_AUTH:
		default:
			pkt = emlxs_pkt_alloc(port, sizeof (uint32_t),
			    0, 0, KM_NOSLEEP);
			break;
		}

		if (!pkt) {
			goto dropit;
		}

		/* Common initialization */
		pkt->pkt_tran_type = FC_PKT_OUTBOUND;
		pkt->pkt_timeout = (2 * hba->fc_ratov);

		if ((uint32_t)iocb->ULPCLASS == CLASS2) {
			pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
			pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
		}

		/* Build the fc header */
		pkt->pkt_cmd_fhdr.d_id =
		    LE_SWAP24_LO(iocb->un.elsreq.remoteID);
		pkt->pkt_cmd_fhdr.r_ctl =
		    R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
		pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
		pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
		pkt->pkt_cmd_fhdr.f_ctl =
		    F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
		pkt->pkt_cmd_fhdr.seq_id = 0;
		pkt->pkt_cmd_fhdr.df_ctl = 0;
		pkt->pkt_cmd_fhdr.seq_cnt = 0;
		pkt->pkt_cmd_fhdr.ox_id = (type2 >> ELS_CMD_SHIFT) & 0xff;
		pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
		pkt->pkt_cmd_fhdr.ro = 0;

		/*
		 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		 * "%s ACC send. oxid=%x", emlxs_elscmd_xlate(type2),
		 * pkt->pkt_cmd_fhdr.ox_id);
		 */

		/* Build the command */
		els = (ELS_PKT *)pkt->pkt_cmd;
		els->elsCode = 0x02;

		/* Build the payload */
		switch (type2) {
		case ELS_CMD_ADISC:

			els->un.adisc.hardAL_PA =
			    (uint8_t)cfg[CFG_ASSIGN_ALPA].current;
			bcopy(&port->wwnn, &els->un.adisc.nodeName,
			    sizeof (NAME_TYPE));
			bcopy(&port->wwpn, &els->un.adisc.portName,
			    sizeof (NAME_TYPE));
			els->un.adisc.DID = LE_SWAP24_LO(port->did);

			break;

		case ELS_CMD_PRLI:

			els->elsByte1 = 0x10;
			els->elsByte2 = 0;
			els->elsByte3 = 0x14;

			els->un.prli.prliType = PRLI_FCP_TYPE;
			els->un.prli.estabImagePair = 1;
			els->un.prli.acceptRspCode = PRLI_REQ_EXECUTED;

			if (port->mode == MODE_INITIATOR) {
				els->un.prli.initiatorFunc = 1;
			}

			if (port->mode == MODE_TARGET) {
				els->un.prli.targetFunc = 1;
			}

			els->un.prli.readXferRdyDis = 1;

			if ((hba->vpd.feaLevelHigh >= 0x02) &&
			    (cfg[CFG_ADISC_SUPPORT].current != 0)) {
				els->un.prli.ConfmComplAllowed = 1;
				els->un.prli.Retry = 1;
				els->un.prli.TaskRetryIdReq = 1;
			} else {
				els->un.prli.ConfmComplAllowed = 0;
				els->un.prli.Retry = 0;
				els->un.prli.TaskRetryIdReq = 0;
			}

			break;

		case ELS_CMD_PRLO:

			els->elsByte1 = 0x10;
			els->elsByte2 = 0;
			els->elsByte3 = 0x14;

			els->un.prlo.prloType = PRLO_FCP_TYPE;
			els->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;

			break;


		}	/* switch(type2) */
		break;

	case ELS_CMD_LS_RJT:	/* reject response */

		if (!(pkt = emlxs_pkt_alloc(port,
		    sizeof (uint32_t) + sizeof (LS_RJT), 0, 0, KM_NOSLEEP))) {
			goto dropit;
		}

		pkt->pkt_tran_type = FC_PKT_OUTBOUND;
		pkt->pkt_timeout = (2 * hba->fc_ratov);

		if ((uint32_t)iocb->ULPCLASS == CLASS2) {
			pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
			pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
		}

		/* Build the fc header */
		pkt->pkt_cmd_fhdr.d_id =
		    LE_SWAP24_LO(iocb->un.elsreq.remoteID);
		pkt->pkt_cmd_fhdr.r_ctl =
		    R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
		pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
		pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
		pkt->pkt_cmd_fhdr.f_ctl =
		    F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
		pkt->pkt_cmd_fhdr.seq_id = 0;
		pkt->pkt_cmd_fhdr.df_ctl = 0;
		pkt->pkt_cmd_fhdr.seq_cnt = 0;
		pkt->pkt_cmd_fhdr.ox_id = (type2 >> ELS_CMD_SHIFT) & 0xff;
		pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
		pkt->pkt_cmd_fhdr.ro = 0;

		/*
		 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
		 * "%s LS_RJT send. oxid=%x", emlxs_elscmd_xlate(type2),
		 * pkt->pkt_cmd_fhdr.ox_id);
		 */

		/* Build the command */
		els = (ELS_PKT *)pkt->pkt_cmd;
		els->elsCode = 0x01;
		els->un.lsRjt.un.b.lsRjtRsvd0 = 0;
		els->un.lsRjt.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
		els->un.lsRjt.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
		els->un.lsRjt.un.b.vendorUnique = 0x01;

		break;

	default:
		return (1);
	}

	if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
		/* Free the pkt */
		emlxs_pkt_free(pkt);
		goto dropit;
	}

	return (0);

dropit:

	emlxs_abort_els_exchange(hba, port, iocb->ULPCONTEXT);
	return (1);

} /* emlxs_els_reply() */


#ifdef ULP_PATCH6

extern uint32_t
emlxs_generate_rscn(emlxs_port_t *port, uint32_t d_id)
{
	fc_unsol_buf_t *ubp;
	fc_rscn_t *rscn;
	emlxs_ub_priv_t *ub_priv;
	uint32_t *page;

	ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, 8, FC_TYPE_EXTENDED_LS, 1);

	if (ubp == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
		    "RSCN create: sid=0xfffffd  1 page(s): %08X, 00000000. "
		    "Creation failed.", d_id);

		return ((uint32_t)FC_FAILURE);
	}

	/* Simulate an RSCN payload */
	rscn = (fc_rscn_t *)ubp->ub_buffer;
	rscn->rscn_code = 0x61;
	rscn->rscn_len = 0x04;
	rscn->rscn_payload_len = 0x0008;
	page = ((uint32_t *)rscn);
	page++;
	*page = d_id;

#ifdef EMLXS_I386
	/* Put payload in BE format */
	rscn->rscn_payload_len = LE_SWAP16(rscn->rscn_payload_len);
	*page = LE_SWAP32(d_id);
#endif /* EMLXS_I386 */

	ub_priv = ubp->ub_fca_private;
	ub_priv->cmd = ELS_CMD_RSCN;
	ub_priv->flags |= EMLXS_UB_INTERCEPT;

	ubp->ub_frame.r_ctl = FC_ELS_REQ;
	ubp->ub_frame.type = FC_TYPE_EXTENDED_LS;
	ubp->ub_frame.s_id = 0xfffffd;
	ubp->ub_frame.d_id = LE_SWAP24_LO(port->did);
	ubp->ub_frame.ox_id = ub_priv->token;
	ubp->ub_frame.rx_id = 0xffff;
	ubp->ub_class = FC_TRAN_CLASS3;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
	    "RSCN: sid=fffffd  1 page(s): %08X, 00000000  buffer=%p "
	    "token=%x. Created.", d_id, ubp, ub_priv->token);

#if (EMLXS_MODREVX == EMLXS_MODREV2X)
	emlxs_swap_els_ub(ubp);
#endif /* EMLXS_MODREV2X */

	emlxs_ub_callback(port, ubp);

	return (FC_SUCCESS);

} /* emlxs_generate_rscn() */

#endif /* ULP_PATCH6 */


#ifdef MENLO_SUPPORT
extern int
emlxs_menlo_handle_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
{
	emlxs_port_t *port = &PPORT;
	IOCB *iocb;
	emlxs_buf_t *sbp;
	fc_packet_t *pkt;
	uint32_t cmd_code = 0;
	uint32_t rsp_code = 0;
	menlo_cmd_t *cmd;
	uint32_t *rsp;

	iocb = &iocbq->iocb;

	HBASTATS.CtEvent++;

	sbp = (emlxs_buf_t *)iocbq->sbp;

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

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
		    "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
		    iocbq, (uint32_t)iocb->ULPCOMMAND,
		    (uint32_t)iocb->ULPIOTAG, iocb->ULPSTATUS,
		    iocb->un.ulpWord[4]);

		return (1);
	}

	if (cp->channelno != hba->channel_ct) {
		HBASTATS.CtStray++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
		    "Invalid IO channel:%d iocbq=%p", cp->channelno, iocbq);

		return (1);
	}

	port = sbp->iocbq.port;
	pkt = PRIV2PKT(sbp);

	cmd = (menlo_cmd_t *)pkt->pkt_cmd;
	cmd_code = BE_SWAP32(cmd->code);

	/* Check if a response buffer was provided */
	if (pkt->pkt_rsplen) {
		EMLXS_MPDATA_SYNC(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
		    DDI_DMA_SYNC_FORKERNEL);
	}

	switch (iocb->ULPCOMMAND) {
	/*
	 * MENLO Command completion
	 */
	case CMD_GEN_REQUEST64_CR:
	case CMD_GEN_REQUEST64_CX:

		HBASTATS.CtCmdCompleted++;

		sbp->pkt_flags |= PACKET_CT_RSP_VALID;

		rsp = (uint32_t *)pkt->pkt_resp;
		rsp_code = *rsp;
		rsp_code = BE_SWAP32(rsp_code);

		if (hba->sli_mode >= EMLXS_HBA_SLI3_MODE) {
			pkt->pkt_resp_resid =
			    pkt->pkt_rsplen - iocb->unsli3.ext_iocb.rsplen;
		} else {
			pkt->pkt_resp_resid =
			    pkt->pkt_rsplen - iocb->un.genreq64.bdl.bdeSize;
		}

		pkt->pkt_data_resid = pkt->pkt_datalen;
		pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;

		if ((iocb->ULPSTATUS == 0) && (rsp_code == MENLO_RSP_SUCCESS)) {
			HBASTATS.CtCmdGood++;

			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
			    "%s: %s rxid=0x%x",
			    emlxs_menlo_cmd_xlate(cmd_code),
			    emlxs_menlo_rsp_xlate(rsp_code),
			    iocb->ULPCONTEXT);

		} else {
			HBASTATS.CtCmdError++;

			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
			    "%s: %s %s %s rxid=0x%x",
			    emlxs_menlo_cmd_xlate(cmd_code),
			    emlxs_menlo_rsp_xlate(rsp_code),
			    emlxs_state_xlate(iocb->ULPSTATUS),
			    emlxs_error_xlate(iocb->un.grsp.perr.
			    statLocalError), iocb->ULPCONTEXT);
		}

		emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
		    iocb->un.grsp.perr.statLocalError, 1);

		break;

	default:

		HBASTATS.CtStray++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_ct_msg,
		    "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);

		emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
		    iocb->un.grsp.perr.statLocalError, 1);

		break;

	}	/* switch(iocb->ULPCOMMAND) */

	return (0);

} /* emlxs_menlo_handle_event() */

#endif /* MENLO_SUPPORT */


extern int
emlxs_ct_handle_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
{
	emlxs_port_t *port = &PPORT;
	IOCB *iocb;
	emlxs_buf_t *sbp;
	fc_packet_t *pkt;
	uint32_t *rsp;
	SLI_CT_REQUEST *CtRsp;
	SLI_CT_REQUEST *CtCmd;
	uint32_t cmd_code = 0;
	uint32_t rsp_code = 0;

	iocb = &iocbq->iocb;

	HBASTATS.CtEvent++;

	sbp = (emlxs_buf_t *)iocbq->sbp;

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

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
		    "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
		    iocbq, (uint32_t)iocb->ULPCOMMAND,
		    (uint32_t)iocb->ULPIOTAG, iocb->ULPSTATUS,
		    iocb->un.ulpWord[4]);

		return (1);
	}

	if (cp->channelno != hba->channel_ct) {
		HBASTATS.CtStray++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
		    "Invalid channel: channel=%d iocbq=%p", cp->channelno,
		    iocbq);

		return (1);
	}

	pkt = PRIV2PKT(sbp);
	port = sbp->iocbq.port;
	CtCmd = (SLI_CT_REQUEST *)pkt->pkt_cmd;
	cmd_code = LE_SWAP16(CtCmd->CommandResponse.bits.CmdRsp);

	if (cmd_code == SLI_CT_LOOPBACK) {
		HBASTATS.CtEvent--;
		return (emlxs_dfc_handle_event(hba, cp, iocbq));
	}

	/* Check if a response buffer was provided */
	if (pkt->pkt_rsplen) {
		EMLXS_MPDATA_SYNC(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
		    DDI_DMA_SYNC_FORKERNEL);
	}

	switch (iocb->ULPCOMMAND) {
		/*
		 * CT Reply completion
		 */
	case CMD_XMIT_SEQUENCE_CX:
	case CMD_XMIT_SEQUENCE64_CX:

		HBASTATS.CtRspCompleted++;

		switch (CtCmd->FsType) {
		case 0xFC:	/* Name server */
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
			    "%s: %s %s", emlxs_ctcmd_xlate(cmd_code),
			    emlxs_state_xlate(iocb->ULPSTATUS),
			    emlxs_error_xlate(iocb->un.grsp.perr.
			    statLocalError));
			break;

		case 0xFA:	/* Managment server */
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
			    "%s: %s %s", emlxs_mscmd_xlate(cmd_code),
			    emlxs_state_xlate(iocb->ULPSTATUS),
			    emlxs_error_xlate(iocb->un.grsp.perr.
			    statLocalError));
			break;

		case 0x0A:	/* Emulex Remote server */
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
			    "%s: %s %s", emlxs_rmcmd_xlate(cmd_code),
			    emlxs_state_xlate(iocb->ULPSTATUS),
			    emlxs_error_xlate(iocb->un.grsp.perr.
			    statLocalError));
			break;

		default:
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
			    "%s: %s %s", emlxs_ctcmd_xlate(cmd_code),
			    emlxs_state_xlate(iocb->ULPSTATUS),
			    emlxs_error_xlate(iocb->un.grsp.perr.
			    statLocalError));
		}

		emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
		    iocb->un.grsp.perr.statLocalError, 1);

		break;

		/*
		 * CT Command completion
		 */
	case CMD_GEN_REQUEST64_CR:
	case CMD_GEN_REQUEST64_CX:

		HBASTATS.CtCmdCompleted++;

		sbp->pkt_flags |= PACKET_CT_RSP_VALID;

		rsp = (uint32_t *)pkt->pkt_resp;
		CtRsp = (SLI_CT_REQUEST *)pkt->pkt_resp;
		rsp_code = LE_SWAP16(CtRsp->CommandResponse.bits.CmdRsp);

		if (hba->sli_mode >= EMLXS_HBA_SLI3_MODE) {
			pkt->pkt_resp_resid =
			    pkt->pkt_rsplen - iocb->unsli3.ext_iocb.rsplen;
		} else {
			pkt->pkt_resp_resid =
			    pkt->pkt_rsplen - iocb->un.genreq64.bdl.bdeSize;
		}

		pkt->pkt_data_resid = pkt->pkt_datalen;

		/*
		 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
		 * "INFO: pkt_resid=%d  %d  %d  %x", pkt->pkt_resp_resid,
		 * pkt->pkt_rsplen, iocb->un.genreq64.bdl.bdeSize,
		 * iocb->un.genreq64.bdl.bdeFlags);
		 */

		if ((iocb->ULPSTATUS == 0) &&
		    (rsp_code == SLI_CT_RESPONSE_FS_ACC)) {
			HBASTATS.CtCmdGood++;

			if (!(sbp->pkt_flags & PACKET_ALLOCATED)) {
				/* ULP patch - ULP expects */
				/* resp_resid = 0 on success */
				pkt->pkt_resp_resid = 0;
			}

			switch (CtCmd->FsType) {
			case 0xFC:	/* Name server */
				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_ct_completion_msg,
				    "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
				    emlxs_ctcmd_xlate(cmd_code),
				    emlxs_ctcmd_xlate(rsp_code),
				    CtRsp->ReasonCode, CtRsp->Explanation,
				    LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));

#if (EMLXS_MODREV < EMLXS_MODREV4)
				if (cmd_code == SLI_CTNS_RNN_ID) {
					emlxs_send_rsnn(port);
				}
#endif /* < EMLXS_MODREV4 */

				break;

			case 0xFA:	/* Managment server */
				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_ct_completion_msg,
				    "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
				    emlxs_mscmd_xlate(cmd_code),
				    emlxs_mscmd_xlate(rsp_code),
				    CtRsp->ReasonCode, CtRsp->Explanation,
				    LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));
				break;

			case 0x0A:	/* Emulex Remote server */
				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_ct_completion_msg,
				    "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
				    emlxs_rmcmd_xlate(cmd_code),
				    emlxs_rmcmd_xlate(rsp_code),
				    CtRsp->ReasonCode, CtRsp->Explanation,
				    LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));
				break;

			default:
				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_ct_completion_msg,
				    "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
				    emlxs_ctcmd_xlate(cmd_code),
				    emlxs_ctcmd_xlate(rsp_code),
				    CtRsp->ReasonCode, CtRsp->Explanation,
				    LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));
			}
		} else {
			HBASTATS.CtCmdError++;

			if (rsp_code == SLI_CT_RESPONSE_FS_RJT) {
				pkt->pkt_state = FC_PKT_FS_RJT;
				pkt->pkt_action = FC_ACTION_RETRYABLE;
				pkt->pkt_reason = CtRsp->ReasonCode;
				pkt->pkt_expln = CtRsp->Explanation;
				sbp->pkt_flags |= PACKET_STATE_VALID;

				EMLXS_MSGF(EMLXS_CONTEXT,
				    &emlxs_ct_completion_msg,
				    "%s: Rejected. rsn=%x exp=%x",
				    emlxs_ctcmd_xlate(cmd_code),
				    pkt->pkt_reason, pkt->pkt_expln);
			} else if (iocb->ULPSTATUS == IOSTAT_LOCAL_REJECT) {
				switch (CtCmd->FsType) {
				case 0xFC:	/* Name server */
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s %s",
					    emlxs_ctcmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    emlxs_error_xlate(iocb->un.grsp.
					    perr.statLocalError));
					break;

				case 0xFA:	/* Managment server */
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s %s",
					    emlxs_mscmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    emlxs_error_xlate(iocb->un.grsp.
					    perr.statLocalError));
					break;

				case 0x0A:	/* Emulex Remote server */
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s %s",
					    emlxs_rmcmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    emlxs_error_xlate(iocb->un.grsp.
					    perr.statLocalError));
					break;

				default:
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s %s",
					    emlxs_ctcmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    emlxs_error_xlate(iocb->un.grsp.
					    perr.statLocalError));
				}
			} else {
				switch (CtCmd->FsType) {
				case 0xFC:	/* Name server */
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s (%02x%02x%02x%02x)",
					    emlxs_ctcmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    iocb->un.grsp.perr.statAction,
					    iocb->un.grsp.perr.statRsn,
					    iocb->un.grsp.perr.statBaExp,
					    iocb->un.grsp.perr.
					    statLocalError);
					break;

				case 0xFA:	/* Managment server */
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s (%02x%02x%02x%02x)",
					    emlxs_mscmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    iocb->un.grsp.perr.statAction,
					    iocb->un.grsp.perr.statRsn,
					    iocb->un.grsp.perr.statBaExp,
					    iocb->un.grsp.perr.
					    statLocalError);
					break;

				case 0x0A:	/* Emulex Remote server */
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s (%02x%02x%02x%02x)",
					    emlxs_rmcmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    iocb->un.grsp.perr.statAction,
					    iocb->un.grsp.perr.statRsn,
					    iocb->un.grsp.perr.statBaExp,
					    iocb->un.grsp.perr.
					    statLocalError);
					break;

				default:
					EMLXS_MSGF(EMLXS_CONTEXT,
					    &emlxs_ct_completion_msg,
					    "%s: %s (%02x%02x%02x%02x)",
					    emlxs_ctcmd_xlate(cmd_code),
					    emlxs_state_xlate(iocb->
					    ULPSTATUS),
					    iocb->un.grsp.perr.statAction,
					    iocb->un.grsp.perr.statRsn,
					    iocb->un.grsp.perr.statBaExp,
					    iocb->un.grsp.perr.
					    statLocalError);
				}
			}
		}

		emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
		    iocb->un.grsp.perr.statLocalError, 1);

		break;

	default:

		HBASTATS.CtStray++;

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_ct_msg,
		    "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);

		emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
		    iocb->un.grsp.perr.statLocalError, 1);

		break;
	}	/* switch(iocb->ULPCOMMAND) */

	return (0);

} /* emlxs_ct_handle_event() */


extern int
emlxs_ct_handle_unsol_req(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
    MATCHMAP *mp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	IOCB *iocb;
	SLI_CT_REQUEST *CtCmd;
	uint32_t cmd_code;

	iocb = &iocbq->iocb;

	CtCmd = (SLI_CT_REQUEST *)mp->virt;
	cmd_code = LE_SWAP16(CtCmd->CommandResponse.bits.CmdRsp);

	if (cmd_code == SLI_CT_LOOPBACK) {
		int rval;

		rval = emlxs_dfc_handle_unsol_req(port, cp, iocbq, mp, size);

		return (rval);
	}

	HBASTATS.CtCmdReceived++;

	switch (CtCmd->FsType) {
	case 0xFC:	/* Name server */
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
		    "%s: pl=%p size=%d rxid=%x", emlxs_ctcmd_xlate(cmd_code),
		    CtCmd, size, iocb->ULPCONTEXT);
		break;

	case 0xFA:	/* Managment server */
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
		    "%s: pl=%p size=%d rxid=%x", emlxs_mscmd_xlate(cmd_code),
		    CtCmd, size, iocb->ULPCONTEXT);
		break;

	case 0x0A:	/* Emulex Remote server */
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
		    "%s: pl=%p size=%d rxid=%x", emlxs_rmcmd_xlate(cmd_code),
		    CtCmd, size, iocb->ULPCONTEXT);
		break;

	default:
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
		    "%s: pl=%p size=%d rxid=%x", emlxs_ctcmd_xlate(cmd_code),
		    CtCmd, size, iocb->ULPCONTEXT);
	}

	if (emlxs_log_ct_event(port, (uint8_t *)mp->virt, size,
	    iocb->ULPCONTEXT)) {
		/* Abort the exchange */
		emlxs_abort_ct_exchange(hba, port, iocb->ULPCONTEXT);
	}

	return (0);

} /* emlxs_ct_handle_unsol_req() */


#if (EMLXS_MODREV < EMLXS_MODREV4)
static void
emlxs_send_rsnn(emlxs_port_t *port)
{
	emlxs_hba_t *hba = HBA;
	fc_packet_t *pkt;
	SLI_CT_REQUEST *ct;

	if (!(pkt = emlxs_pkt_alloc(port, sizeof (SLI_CT_REQUEST),
	    sizeof (SLI_CT_REQUEST), 0, KM_NOSLEEP))) {
		return;
	}

	pkt->pkt_tran_type = FC_PKT_EXCHANGE;
	pkt->pkt_timeout = (2 * hba->fc_ratov);

	/* Build the fc header */
	pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(NAMESERVER_DID);
	pkt->pkt_cmd_fhdr.r_ctl = R_CTL_UNSOL_CONTROL;
	pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
	pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
	pkt->pkt_cmd_fhdr.f_ctl =
	    F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = 0xffff;
	pkt->pkt_cmd_fhdr.rx_id = 0xffff;
	pkt->pkt_cmd_fhdr.ro = 0;

	/* Build the command */
	ct = (SLI_CT_REQUEST *)pkt->pkt_cmd;

	ct->RevisionId.bits.Revision = SLI_CT_REVISION;
	ct->RevisionId.bits.InId = 0;

	ct->FsType = SLI_CT_DIRECTORY_SERVICE;
	ct->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;

	ct->CommandResponse.bits.Size = 0;
	ct->CommandResponse.bits.CmdRsp = LE_SWAP16(SLI_CTNS_RSNN_NN);

	bcopy((uint8_t *)&hba->wwnn, (char *)ct->un.rsnn.wwnn, 8);

	ct->un.rsnn.snn_len = strlen(port->snn);
	bcopy(port->snn, (char *)ct->un.rsnn.snn, ct->un.rsnn.snn_len);

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_send_msg, "Sending RSNN_NN. [%s]",
	    port->snn);

	/* Send the pkt later in another thread */
	if (emlxs_pkt_send(pkt, 0) != FC_SUCCESS) {
		/* Free the pkt */
		emlxs_pkt_free(pkt);
	}

	return;

} /* emlxs_send_rsnn() */
#endif /* < EMLXS_MODREV4 */




extern uint32_t
emlxs_ub_send_login_acc(emlxs_port_t *port, fc_unsol_buf_t *ubp)
{
	emlxs_hba_t *hba = HBA;
	fc_packet_t *pkt;
	ELS_PKT *els;
	uint32_t rval;
	emlxs_ub_priv_t *ub_priv;

	ub_priv = ubp->ub_fca_private;

	if (!(pkt = emlxs_pkt_alloc(port,
	    sizeof (uint32_t) + sizeof (SERV_PARM), 0, 0, KM_NOSLEEP))) {
		return (1);
	}

	/* Common initialization */
	pkt->pkt_tran_type = FC_PKT_OUTBOUND;
	pkt->pkt_timeout = (2 * hba->fc_ratov);

	if ((uint32_t)ubp->ub_class == FC_TRAN_CLASS2) {
		pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
		pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
	}

	/* Build the fc header */
	pkt->pkt_cmd_fhdr.d_id = ubp->ub_frame.s_id;
	pkt->pkt_cmd_fhdr.r_ctl =
	    R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
	pkt->pkt_cmd_fhdr.s_id = ubp->ub_frame.d_id;
	pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
	pkt->pkt_cmd_fhdr.f_ctl =
	    F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = (ub_priv->cmd >> ELS_CMD_SHIFT) & 0xff;
	pkt->pkt_cmd_fhdr.rx_id = ubp->ub_frame.rx_id;
	pkt->pkt_cmd_fhdr.ro = 0;

	/* Build the command */
	els = (ELS_PKT *)pkt->pkt_cmd;
	els->elsCode = 0x02;
	bcopy((void *)&port->sparam, (void *)&els->un.logi,
	    sizeof (SERV_PARM));

	if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
		/* Free the pkt */
		emlxs_pkt_free(pkt);
	} else {
		ub_priv->flags |= EMLXS_UB_INTERCEPT;
	}

	return (rval);

} /* emlxs_ub_send_login_acc */


extern void
emlxs_send_logo(emlxs_port_t *port, uint32_t d_id)
{
	emlxs_hba_t *hba = HBA;
	fc_packet_t *pkt;
	ELS_PKT *els;

	if (!(hba->flag & FC_ONLINE_MODE)) {
		return;
	}

	if (hba->state <= FC_LINK_DOWN) {
		return;
	}

	if (!(pkt = emlxs_pkt_alloc(port,
	    sizeof (uint32_t) + sizeof (LOGO),
	    sizeof (uint32_t) + sizeof (LOGO), 0, KM_NOSLEEP))) {
		return;
	}

	pkt->pkt_tran_type = FC_PKT_EXCHANGE;
	pkt->pkt_timeout = (2 * hba->fc_ratov);

	/* Build the fc header */
	pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(d_id);
	pkt->pkt_cmd_fhdr.r_ctl =
	    R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
	pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
	pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
	pkt->pkt_cmd_fhdr.f_ctl =
	    F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = 0xffff;
	pkt->pkt_cmd_fhdr.rx_id = 0xffff;
	pkt->pkt_cmd_fhdr.ro = 0;

	/* Build the command */
	els = (ELS_PKT *)pkt->pkt_cmd;
	els->elsCode = 0x05;
	els->un.logo.un.nPortId32 = pkt->pkt_cmd_fhdr.s_id;
	bcopy((uint8_t *)&port->wwpn, (uint8_t *)&els->un.logo.portName,
	    8);

	/* Send the pkt now */
	if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
		/* Free the pkt */
		emlxs_pkt_free(pkt);
	}

	return;

} /* emlxs_send_logo() */