xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/fca/fcoei/fcoei_eth.c (revision 1a5e258f)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * The following notice accompanied the original version of this file:
 *
 * BSD LICENSE
 *
 * Copyright(c) 2007 Intel Corporation. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of Intel Corporation nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

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

/*
 * This file defines interface functions between fcoe and fcoei driver.
 */

#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/stat.h>
#include <sys/pci.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/file.h>
#include <sys/cred.h>
#include <sys/byteorder.h>
#include <sys/atomic.h>
#include <sys/scsi/scsi.h>
#include <sys/mac_client.h>
#include <sys/modhash.h>

/*
 * LEADVILLE header files
 */
#include <sys/fibre-channel/fc.h>
#include <sys/fibre-channel/impl/fc_fcaif.h>

/*
 * COMSTAR header files
 */
#include <sys/stmf_defines.h>

/*
 * FCOE header files
 */
#include <sys/fcoe/fcoe_common.h>

/*
 * Driver's own header files
 */
#include <fcoei.h>

/*
 * Forward declaration of internal functions
 */
static void fcoei_process_unsol_els_req(fcoe_frame_t *frm);
static void fcoei_process_sol_els_rsp(fcoe_frame_t *frm);
static void fcoei_process_unsol_abts_req(fcoe_frame_t *frame);
static void fcoei_process_sol_abts_acc(fcoe_frame_t *frame);
static void fcoei_process_sol_abts_rjt(fcoe_frame_t *frame);
static void fcoei_process_sol_ct_rsp(fcoe_frame_t *frame);
static void fcoei_process_unsol_xfer_rdy(fcoe_frame_t *frame);
static void fcoei_process_sol_fcp_resp(fcoe_frame_t *frm);

static void fcoei_fill_fcp_resp(uint8_t *src, uint8_t *dest, int size);
static void fcoei_fill_els_fpkt_resp(fcoe_frame_t *frm, fcoei_exchange_t *xch,
    int size);

/*
 * fcoei_rx_frame
 *	Unsolicited frame is received
 *
 * Input:
 *	frame = unsolicited frame that is received
 *
 * Return:
 *	N/A
 *
 * Comment:
 *	N/A
 */
static void
fcoei_rx_frame(fcoe_frame_t *frm)
{
	if (!(FRM2SS(frm)->ss_flags & SS_FLAG_LV_BOUND)) {
		/*
		 * Release the frame and netb
		 */
		FCOEI_LOG(__FUNCTION__, "not bound now");
		frm->frm_eport->eport_free_netb(frm->frm_netb);
		frm->frm_eport->eport_release_frame(frm);
		return;
	}

	FRM2IFM(frm)->ifm_ae.ae_type = AE_EVENT_UNSOL_FRAME;
	FRM2IFM(frm)->ifm_ae.ae_obj = frm;

	mutex_enter(&FRM2SS(frm)->ss_watchdog_mutex);
	list_insert_tail(&FRM2SS(frm)->ss_event_list, &FRM2IFM(frm)->ifm_ae);
	if (FRM2SS(frm)->ss_flags & SS_FLAG_WATCHDOG_IDLE) {
		cv_signal(&FRM2SS(frm)->ss_watchdog_cv);
	}
	mutex_exit(&FRM2SS(frm)->ss_watchdog_mutex);
}

/*
 * fcoei_release_sol_frame
 *	Release the solicited frame that has just been sent out
 *
 * Input:
 *	frame = solicited frame that has been sent out
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	After FCOE sends solicited frames out, it will call this to notify
 *	FCOEI of the completion.
 */
static void
fcoei_release_sol_frame(fcoe_frame_t *frm)
{
	/*
	 * For request-type frames, it's safe to be handled out of
	 * watchdog, because it needn't update anything
	 */
	switch (FRM2IFM(frm)->ifm_rctl) {
	case R_CTL_SOLICITED_DATA:
	case R_CTL_COMMAND:
	case R_CTL_ELS_REQ:
	case R_CTL_UNSOL_CONTROL:
	case R_CTL_LS_ABTS:
		FRM2SS(frm)->ss_eport->eport_release_frame(frm);
		break;

	default:
		FRM2IFM(frm)->ifm_ae.ae_type = AE_EVENT_SOL_FRAME;
		FRM2IFM(frm)->ifm_ae.ae_obj = frm;

		mutex_enter(&FRM2SS(frm)->ss_watchdog_mutex);
		list_insert_tail(&FRM2SS(frm)->ss_event_list,
		    &FRM2IFM(frm)->ifm_ae);
		if (FRM2SS(frm)->ss_flags & SS_FLAG_WATCHDOG_IDLE) {
			cv_signal(&FRM2SS(frm)->ss_watchdog_cv);
		}
		mutex_exit(&FRM2SS(frm)->ss_watchdog_mutex);
		break;
	}
}

/*
 * fcoei_process_unsol_xfer_rdy
 *	XFER_RDY is received
 *
 * Input:
 *	frm = XFER_RDY frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	N/A
 */
static void
fcoei_process_unsol_xfer_rdy(fcoe_frame_t *frm)
{
	uint16_t		 sol_oxid;
	fcoei_exchange_t	*xch;
	int			 rcv_buf_size;
	int			 offset;
	int			 left_size;
	int			 data_size;
	int			 frm_num;
	int			 idx;
	fcoe_frame_t		*nfrm;

	sol_oxid = FRM_OXID(frm);
	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
		return;
	}

	/*
	 * rcv_buf_size is the total size of data that should be transferred
	 * in this sequence.
	 * offset is based on the exchange not the sequence.
	 */
	xch->xch_rxid = FRM_RXID(frm);
	rcv_buf_size = FCOE_B2V_4(frm->frm_payload + 4);
	offset = FCOE_B2V_4(frm->frm_payload);
	ASSERT(xch->xch_resid >= rcv_buf_size);

	/*
	 * Local variables initialization
	 */
	left_size = rcv_buf_size;
	data_size = FRM2SS(frm)->ss_fcp_data_payload_size;
	frm_num = (rcv_buf_size + data_size - 1) / data_size;

	for (idx = 0; idx < frm_num - 1; idx++) {
		/*
		 * The first (frm_num -1) frames are always full
		 */
		nfrm = FRM2SS(frm)->ss_eport->eport_alloc_frame(
		    FRM2SS(frm)->ss_eport, data_size + FCFH_SIZE, NULL);
		if (nfrm == NULL) {
			FCOEI_LOG(__FUNCTION__, "can't alloc frame");
			return;
		}

		/*
		 * Copy the data payload that will  be transferred
		 */
		bcopy(offset + (uint8_t *)xch->xch_fpkt->pkt_data,
		    nfrm->frm_payload, nfrm->frm_payload_size);

		FFM_R_CTL(R_CTL_SOLICITED_DATA, nfrm);
		FFM_TYPE(FC_TYPE_SCSI_FCP, nfrm);
		FFM_F_CTL(0x010008, nfrm);
		FFM_OXID(xch->xch_oxid, nfrm);
		FFM_RXID(xch->xch_rxid, nfrm);
		FFM_S_ID(FRM_D_ID(frm), nfrm);
		FFM_D_ID(FRM_S_ID(frm), nfrm);
		FFM_SEQ_CNT(idx, nfrm);
		FFM_PARAM(offset, nfrm);
		fcoei_init_ifm(nfrm, xch);

		/*
		 * Submit the frame
		 */
		xch->xch_ss->ss_eport->eport_tx_frame(nfrm);

		/*
		 * Update offset and left_size
		 */
		offset += data_size;
		left_size -= data_size;
	}

	/*
	 * Send the last data frame of this sequence
	 */
	data_size = left_size;
	nfrm = xch->xch_ss->ss_eport->eport_alloc_frame(
	    xch->xch_ss->ss_eport, data_size + FCFH_SIZE, NULL);
	if (nfrm != NULL) {
		fcoei_init_ifm(nfrm, xch);
	} else {
		ASSERT(0);
		return;
	}

	/*
	 * Copy the data payload that will be transferred
	 */
	bcopy(offset + (uint8_t *)xch->xch_fpkt->pkt_data,
	    nfrm->frm_payload, nfrm->frm_payload_size);

	/*
	 * Set ifm_rctl for fcoei_handle_sol_frame_done
	 */
	FRM2IFM(nfrm)->ifm_rctl = R_CTL_SOLICITED_DATA;

	/*
	 * FFM
	 */
	FFM_R_CTL(R_CTL_SOLICITED_DATA, nfrm);
	FFM_TYPE(FC_TYPE_SCSI_FCP, nfrm);
	FFM_F_CTL(0x090008, nfrm);
	FFM_OXID(xch->xch_oxid, nfrm);
	FFM_RXID(xch->xch_rxid, nfrm);
	FFM_S_ID(FRM_D_ID(frm), nfrm);
	FFM_D_ID(FRM_S_ID(frm), nfrm);
	FFM_SEQ_CNT(idx, nfrm);
	FFM_PARAM(offset, nfrm);

	/*
	 * Submit the frame
	 */
	xch->xch_ss->ss_eport->eport_tx_frame(nfrm);

	/*
	 * Sequence is a transaction, so we need only update
	 * xch_remained_bytes in the end.
	 */
	xch->xch_resid -= rcv_buf_size;
}

/*
 * fcoei_process_unsol_els_req
 *	els req frame is received
 *
 * Input:
 *	frm = ELS request frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	We will not create exchange data structure at this time,
 *	and we should create unsolicited buffer, which will only
 *	contain the exchange's request payload.
 */
static void
fcoei_process_unsol_els_req(fcoe_frame_t *frm)
{
	fc_unsol_buf_t		*ub;
	fc_rscn_t		*rscn;
	uint32_t		 offset;
	fcoei_exchange_t	*xch_tmp;

	/*
	 * Get the unsol rxid first
	 */
	FCOEI_SET_UNSOL_FRM_RXID(frm, xch_tmp);

	/*
	 * Do proper ub initialization
	 */
	ub = (fc_unsol_buf_t *)kmem_zalloc(sizeof (fc_unsol_buf_t), KM_SLEEP);
	ub->ub_class = FC_TRAN_CLASS3;
	ub->ub_bufsize = frm->frm_payload_size;
	ub->ub_buffer = kmem_alloc(frm->frm_payload_size, KM_SLEEP);
	ub->ub_port_handle = FRM2SS(frm);
	ub->ub_token = (uint64_t)(long)ub;

	/*
	 * header conversion
	 * Caution: ub_buffer is big endian, but ub_frame should be host-format
	 * RSCN is one exception.
	 */
	FCOEI_FRM2FHDR(frm, &ub->ub_frame);

	/*
	 * If it's FLOGI, and our FLOGI failed last time,
	 * then we post online event
	 */
	if ((FRM2SS(frm)->ss_flags & SS_FLAG_FLOGI_FAILED) &&
	    (frm->frm_payload[0] == LA_ELS_FLOGI)) {
		frm->frm_eport->eport_flags |=
		    EPORT_FLAG_IS_DIRECT_P2P;
		FRM2SS(frm)->ss_bind_info.port_statec_cb(FRM2SS(frm)->ss_port,
		    FC_STATE_ONLINE);
	}

	switch (frm->frm_payload[0]) {
	case LA_ELS_RSCN:
		/*
		 * Only RSCN need byte swapping
		 */
		rscn = (fc_rscn_t *)(void *)ub->ub_buffer;
		rscn->rscn_code = frm->frm_payload[0];
		rscn->rscn_len = frm->frm_payload[1];
		rscn->rscn_payload_len =
		    FCOE_B2V_2(frm->frm_payload + 2);

		offset = 4;
		for (int i = 0; i < rscn->rscn_payload_len - 4; i += 4) {
			*(uint32_t *)((intptr_t)(uint8_t *)ub->ub_buffer +
			    offset) = FCOE_B2V_4(frm->frm_payload + offset);
			offset += 4;
		}
		break;

	default:
		bcopy(frm->frm_payload, ub->ub_buffer, frm->frm_payload_size);
		break;
	}

	/*
	 * Pass this unsol ELS up to Leadville
	 */
	FRM2SS(frm)->ss_bind_info.port_unsol_cb(FRM2SS(frm)->ss_port, ub, 0);
}

/*
 * fcoei_search_abort_xch
 *	Find the exchange that should be aborted
 *
 * Input:
 *	key = oxid of the exchange
 *	val = the exchange
 *	arg = the soft state
 *
 * Returns:
 *	MH_WALK_TERMINATE = found it, terminate the walk
 *	MH_WALK_CONTINUE = not found, continue the walk
 *
 * Comments:
 *	N/A
 */
/* ARGSUSED */
static uint32_t
fcoei_search_abort_xch(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
{
	fcoei_walk_arg_t	*wa = (fcoei_walk_arg_t *)arg;
	fcoei_exchange_t	*xch = (fcoei_exchange_t *)val;

	if (xch->xch_oxid == wa->wa_oxid) {
		wa->wa_xch = xch;
		ASSERT(xch->xch_oxid == CMHK(key));
		return (MH_WALK_TERMINATE);
	}

	return (MH_WALK_CONTINUE);
}

/*
 * fcoei_process_unsol_abts_req
 *	ABTS request is received
 *
 * Input:
 *	frm = ABTS request frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	The remote side wants to abort one unsolicited exchange.
 */
static void
fcoei_process_unsol_abts_req(fcoe_frame_t *frm)
{
	fcoei_exchange_t	*xch = NULL;
	fcoe_frame_t		*nfrm;
	int			 payload_size;
	fcoei_walk_arg_t	 walk_arg;

	/*
	 * According to spec, the responder could want to ABTS xch too
	 */
	if (FRM_SENDER_IS_XCH_RESPONDER(frm)) {
		uint16_t sol_oxid = FRM_OXID(frm);
		(void) mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
		    FMHK(sol_oxid), (mod_hash_val_t *)&xch);
	} else {
		/*
		 * it's a unsolicited exchange, and we need find it out from
		 * unsolicited hash table. But at this time, RXID in frame could
		 * still be 0xFFFF in most cases, so we need do exaustive search
		 */
		walk_arg.wa_xch = NULL;
		walk_arg.wa_oxid = FRM_OXID(frm);
		mod_hash_walk(FRM2SS(frm)->ss_unsol_rxid_hash,
		    fcoei_search_abort_xch, &walk_arg);
		xch = walk_arg.wa_xch;
	}

	if (xch == NULL) {
		payload_size = 4;
		nfrm = FRM2SS(frm)->ss_eport->eport_alloc_frame(
		    FRM2SS(frm)->ss_eport,
		    payload_size + FCFH_SIZE, NULL);
		if (nfrm == NULL) {
			FCOEI_LOG(__FUNCTION__, "can't alloc frame");
			return;
		}

		bzero(nfrm->frm_payload, nfrm->frm_payload_size);
		nfrm->frm_payload[1] = 0x05;
		nfrm->frm_payload[3] = 0xAA;
		FFM_R_CTL(R_CTL_LS_BA_RJT, nfrm);
		fcoei_init_ifm(nfrm, xch);
	} else {
		/*
		 * We should complete the exchange with frm as NULL,
		 * and we don't care its success or failure
		 */
		fcoei_complete_xch(xch, NULL, FC_PKT_FAILURE, FC_REASON_ABTX);

		/*
		 * Construct ABTS ACC frame
		 */
		payload_size = 12;
		nfrm = FRM2SS(frm)->ss_eport->eport_alloc_frame(
		    FRM2SS(frm)->ss_eport, payload_size + FCFH_SIZE, NULL);
		if (nfrm == NULL) {
			FCOEI_LOG(__FUNCTION__, "can't alloc frame");
			return;
		}

		bzero(nfrm->frm_payload, nfrm->frm_payload_size);
		nfrm->frm_payload[4] = 0xFF & (xch->xch_oxid >> 8);
		nfrm->frm_payload[5] = 0xFF & (xch->xch_oxid);
		nfrm->frm_payload[6] = 0xFF & (xch->xch_rxid >> 8);
		nfrm->frm_payload[7] = 0xFF & (xch->xch_rxid);
		nfrm->frm_payload[10] = 0xFF;
		nfrm->frm_payload[11] = 0xFF;

		FFM_R_CTL(R_CTL_LS_BA_ACC, nfrm);
		fcoei_init_ifm(nfrm, xch);
	}

	FFM_D_ID(FRM_S_ID(frm), nfrm);
	FFM_S_ID(FRM_D_ID(frm), nfrm);
	FFM_TYPE(FRM_TYPE(frm), nfrm);
	FFM_F_CTL(FRM_F_CTL(frm), nfrm);
	FFM_OXID(FRM_OXID(frm), nfrm);
	FFM_RXID(FRM_RXID(frm), nfrm);
	FRM2SS(frm)->ss_eport->eport_tx_frame(nfrm);
}

/*
 * fcoei_process_sol_fcp_resp
 *	FCP response is received
 *
 * Input:
 *	frm = FCP response frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	N/A
 */
static void
fcoei_process_sol_fcp_resp(fcoe_frame_t *frm)
{
	uint16_t		 sol_oxid;
	uint32_t		 actual_size;
	fcoei_exchange_t	*xch  = NULL;
	fc_packet_t		*fpkt = NULL;
	mod_hash_val_t		 val;
	uint32_t		 i_fcp_status;

	/*
	 * Firstly, we search the related exchange
	 */
	sol_oxid = FRM_OXID(frm);
	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
		PRT_FRM_HDR(__FUNCTION__, frm);
		FCOEI_LOG(__FUNCTION__, "can't find the corresponding xch: "
		    "oxid/%x %lu - %lu", sol_oxid,
		    CURRENT_CLOCK, frm->frm_clock);
		return;
	} else {
		fpkt = xch->xch_fpkt;
	}

	/*
	 * Decide the actual response length
	 */
	actual_size = fpkt->pkt_rsplen;
	if (actual_size > frm->frm_payload_size) {
		actual_size = frm->frm_payload_size;
	}

	/*
	 * Update the exchange and hash table
	 */
	(void) mod_hash_remove(FRM2SS(frm)->ss_sol_oxid_hash,
	    FMHK(xch->xch_oxid), &val);
	ASSERT((fcoei_exchange_t *)val == xch);
	xch->xch_flags &= ~XCH_FLAG_IN_SOL_HASH;

	/*
	 * Upate fpkt related elements
	 */
	FCOEI_FRM2FHDR(frm, &fpkt->pkt_resp_fhdr);

	/*
	 * we should set pkt_reason and pkt_state carefully
	 */
	fpkt->pkt_state = FC_PKT_SUCCESS;
	fpkt->pkt_reason = 0;

	/*
	 * First we zero the first 12 byte of dest
	 */
	bzero(xch->xch_fpkt->pkt_resp, 12);
	i_fcp_status = BE_IN32(frm->frm_payload + 8);
	if (i_fcp_status != 0) {
		fcoei_fill_fcp_resp(frm->frm_payload,
		    (uint8_t *)xch->xch_fpkt->pkt_resp, actual_size);
	}

	/*
	 * Update pkt_resp_resid
	 */
	fpkt->pkt_data_resid = xch->xch_resid;
	if ((xch->xch_resid != 0) && ((xch->xch_resid % 0x200) == 0) &&
	    ((xch->xch_fpkt->pkt_datalen % 0x200) == 0) &&
	    (i_fcp_status == 0)) {
		FCOEI_LOG(__FUNCTION__, "frame lost no pause ? %x/%x",
		    xch->xch_resid, xch->xch_fpkt->pkt_datalen);
		fpkt->pkt_state = FC_PKT_LOCAL_RJT;
		fpkt->pkt_reason = FC_REASON_UNDERRUN;
	}

	/*
	 * Notify LV it's over
	 */
	if (fpkt->pkt_tran_flags & FC_TRAN_NO_INTR) {
		FCOEI_LOG(__FUNCTION__, "BEFORE WAKEUP: %p-%p", fpkt, xch);
		sema_v(&xch->xch_sema);
		FCOEI_LOG(__FUNCTION__, "AFTERE WAKEUP: %p-%p", fpkt, xch);
	} else {
		xch->xch_fpkt->pkt_comp(xch->xch_fpkt);
	}
}

/*
 * fcoei_process_sol_els_rsp
 *	ELS response is received
 *
 * Input:
 *	frm = ELS response frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	N/A
 */
static void
fcoei_process_sol_els_rsp(fcoe_frame_t *frm)
{
	uint16_t		 sol_oxid    = 0;
	uint32_t		 actual_size = 0;
	fcoei_exchange_t	*xch;
	fc_packet_t		*fpkt;

	/*
	 * Look for the related exchange
	 */
	xch = NULL;
	fpkt = NULL;
	sol_oxid = FRM_OXID(frm);
	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
		PRT_FRM_HDR(__FUNCTION__, frm);
		FCOEI_LOG(__FUNCTION__, "can't find the "
		    "corresponding xch: oxid/%x", sol_oxid);
		return;
	}

	xch->xch_rxid = FRM_RXID(frm);
	fpkt = xch->xch_fpkt;

	/*
	 * Decide the actual response length
	 */
	actual_size = frm->frm_payload_size;
	if (actual_size > fpkt->pkt_rsplen) {
		FCOEI_LOG(__FUNCTION__, "pkt_rsplen is smaller"
		    "0x(%x - %x)", actual_size, fpkt->pkt_rsplen);
		actual_size = fpkt->pkt_rsplen;
	}

	/*
	 * Upate fpkt related elements
	 */
	FCOEI_FRM2FHDR(frm, &fpkt->pkt_resp_fhdr);
	fcoei_fill_els_fpkt_resp(frm, xch, actual_size);

	/*
	 * we should set pkt_reason and pkt_state carefully now
	 * Need to analyze pkt_reason according to the response.
	 * Leave it untouched now.
	 */
	if (((ls_code_t *)(void *)xch->xch_fpkt->pkt_resp)->ls_code ==
	    LA_ELS_RJT) {
		fcoei_complete_xch(xch, NULL, FC_PKT_FABRIC_RJT,
		    FC_REASON_INVALID_PARAM);
	} else {
		fcoei_complete_xch(xch, NULL, FC_PKT_SUCCESS, 0);
	}
}

/*
 * fcoei_process_sol_ct_rsp
 *	CT response is received
 *
 * Input:
 *	frm = CT response frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	N/A
 */
static void
fcoei_process_sol_ct_rsp(fcoe_frame_t *frm)
{
	uint16_t		 sol_oxid    = 0;
	uint32_t		 actual_size = 0;
	fcoei_exchange_t	*xch;
	fc_packet_t		*fpkt;

	/*
	 * Look for the related exchange
	 */
	xch = NULL;
	fpkt = NULL;
	sol_oxid = FRM_OXID(frm);
	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
		FCOEI_LOG(__FUNCTION__, "can't find the "
		    "corresponding xch: oxid/%x", sol_oxid);
		return;
	}

	xch->xch_rxid = FRM_RXID(frm);
	fpkt = xch->xch_fpkt;

	/*
	 * Decide the actual response length
	 */
	actual_size = fpkt->pkt_rsplen;
	if (actual_size > frm->frm_payload_size) {
		FCOEI_LOG(__FUNCTION__, "payload is smaller"
		    "0x(%x - %x)", actual_size, frm->frm_payload_size);
		actual_size = frm->frm_payload_size;
	}

	/*
	 * Update fpkt related elements
	 * Caution: we needn't do byte swapping for CT response
	 */
	FCOEI_FRM2FHDR(frm, &fpkt->pkt_resp_fhdr);
	bcopy(FPLD, (uint8_t *)xch->xch_fpkt->pkt_resp, actual_size);

	/*
	 * Complete it with frm as NULL
	 */
	fcoei_complete_xch(xch, NULL, FC_PKT_SUCCESS, 0);
}

/*
 * fcoei_process_sol_abts_acc
 *	ABTS accpet is received
 *
 * Input:
 *	frm = ABTS accept frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	We will always finish the abortion of solicited exchanges,
 *	so we will not depend on the response from the remote side.
 *	We just log one message.
 */
static void
fcoei_process_sol_abts_acc(fcoe_frame_t *frm)
{
	FCOEI_LOG(__FUNCTION__, "the remote side has agreed to "
	    "abort the exchange: oxid-%x, rxid-%x",
	    FCOE_B2V_2(frm->frm_payload + 4),
	    FCOE_B2V_2(frm->frm_payload + 6));
}

/*
 * fcoei_process_sol_abts_rjt
 *	ABTS reject is received
 *
 * Input:
 *	frm = ABTS reject frame
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	We will alwayas finish the abortion of solicited exchanges,
 *	so we will not depend on the response from the remote side.
 *	We just log one message.
 */
static void
fcoei_process_sol_abts_rjt(fcoe_frame_t *frm)
{
	FCOEI_LOG(__FUNCTION__, "the remote side rejected "
	    "our request to abort one exchange.: %p", frm);
}

/*
 * fcoei_fill_els_fpkt_resp
 *	Fill fpkt ELS response in host format according frm payload
 *
 * Input:
 *	src = frm payload in link format
 *	dest = fpkt ELS response in host format
 *	size = Maximum conversion size
 *	els_op = ELS opcode
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	fpkt->pkt_resp must be mapped to one data structure, and it's
 *	different from the content in the raw frame
 */
static void
fcoei_fill_els_fpkt_resp(fcoe_frame_t *frm, fcoei_exchange_t *xch, int size)
{
	uint8_t			*src	   = frm->frm_payload;
	uint8_t			*dest	   = (uint8_t *)xch->xch_fpkt->pkt_resp;
	ls_code_t		*els_code  = (ls_code_t *)(void *)dest;
	la_els_logi_t		*els_logi  = (la_els_logi_t *)(void *)dest;
	la_els_adisc_t		*els_adisc = (la_els_adisc_t *)(void *)dest;
	la_els_rls_acc_t	*els_rls;
	la_els_rnid_acc_t	*els_rnid;
	struct fcp_prli_acc	*prli_acc;
	int			 offset;

	els_code->ls_code = FCOE_B2V_1(src);
	if (els_code->ls_code == LA_ELS_RJT) {
		FCOEI_LOG(__FUNCTION__, "size :%d", size);
		return;
	}

	switch (((ls_code_t *)(void *)xch->xch_fpkt->pkt_cmd)->ls_code) {
	case LA_ELS_FLOGI:
		bcopy((char *)frm->frm_hdr - 22,
		    frm->frm_eport->eport_efh_dst, ETHERADDRL);
		if (frm->frm_payload[8] & 0x10) {
			/*
			 * We are in fabric p2p mode
			 */
			uint8_t src_addr[ETHERADDRL];
			frm->frm_eport->eport_flags &=
			    ~EPORT_FLAG_IS_DIRECT_P2P;
			FCOE_SET_DEFAULT_OUI(src_addr);
			bcopy(frm->frm_hdr->hdr_d_id, src_addr + 3, 3);
			frm->frm_eport->eport_set_mac_address(
			    frm->frm_eport, src_addr, 1);
		} else {
			/*
			 * We are in direct p2p mode
			 */
			frm->frm_eport->eport_flags |=
			    EPORT_FLAG_IS_DIRECT_P2P;
		}

		if (!(FRM2SS(frm)->ss_eport->eport_flags &
		    EPORT_FLAG_IS_DIRECT_P2P)) {
			FRM2SS(frm)->ss_p2p_info.fca_d_id = FRM_D_ID(frm);
		}

		/* FALLTHROUGH */

	case LA_ELS_PLOGI:
		if (FRM2SS(frm)->ss_eport->eport_flags &
		    EPORT_FLAG_IS_DIRECT_P2P) {
			FRM2SS(frm)->ss_p2p_info.fca_d_id = FRM_D_ID(frm);
			FRM2SS(frm)->ss_p2p_info.d_id = FRM_S_ID(frm);
		}

		offset = offsetof(la_els_logi_t, common_service);
		els_logi->common_service.fcph_version = FCOE_B2V_2(src +
		    offset);
		offset += 2;
		els_logi->common_service.btob_credit = FCOE_B2V_2(src +
		    offset);
		offset += 2;
		els_logi->common_service.cmn_features = FCOE_B2V_2(src +
		    offset);
		offset += 2;
		els_logi->common_service.rx_bufsize = FCOE_B2V_2(src +
		    offset);
		offset += 2;
		els_logi->common_service.conc_sequences = FCOE_B2V_2(src +
		    offset);
		offset += 2;
		els_logi->common_service.relative_offset = FCOE_B2V_2(src +
		    offset);
		offset += 2;
		els_logi->common_service.e_d_tov = FCOE_B2V_4(src +
		    offset);

		/*
		 * port/node WWN
		 */
		offset = offsetof(la_els_logi_t, nport_ww_name);
		bcopy(src + offset, &els_logi->nport_ww_name, 8);
		offset = offsetof(la_els_logi_t, node_ww_name);
		bcopy(src + offset, &els_logi->node_ww_name, 8);

		/*
		 * class_3
		 */
		offset = offsetof(la_els_logi_t, class_3);
		els_logi->class_3.class_opt = FCOE_B2V_2(src + offset);
		offset += 2;
		els_logi->class_3.initiator_ctl = FCOE_B2V_2(src + offset);
		offset += 2;
		els_logi->class_3.recipient_ctl = FCOE_B2V_2(src + offset);
		offset += 2;
		els_logi->class_3.rcv_size = FCOE_B2V_2(src + offset);
		offset += 2;
		els_logi->class_3.conc_sequences = FCOE_B2V_2(src + offset);
		offset += 2;
		els_logi->class_3.n_port_e_to_e_credit = FCOE_B2V_2(src +
		    offset);
		offset += 2;
		els_logi->class_3.open_seq_per_xchng = FCOE_B2V_2(src + offset);

		break;

	case LA_ELS_PRLI:
		/*
		 * PRLI service parameter response page
		 *
		 * fcp_prli_acc doesn't include ls_code, don't use offsetof
		 */
		offset = 4;
		prli_acc = (struct fcp_prli_acc *)(void *)(dest + offset);
		prli_acc->type = FCOE_B2V_1(src + offset);
		/*
		 * Type code extension
		 */
		offset += 1;
		/*
		 * PRLI response flags
		 */
		offset += 1;
		prli_acc->orig_process_assoc_valid =
		    (FCOE_B2V_2(src + offset) & BIT_15) ? 1 : 0;
		prli_acc->resp_process_assoc_valid =
		    (FCOE_B2V_2(src + offset) & BIT_14) ? 1 : 0;
		prli_acc->image_pair_established =
		    (FCOE_B2V_2(src + offset) & BIT_13) ? 1 : 0;
		prli_acc->accept_response_code =
		    (FCOE_B2V_2(src + offset) & 0x0F00) >> 8;
		/*
		 * process associator
		 */
		offset += 2;
		prli_acc->orig_process_associator = FCOE_B2V_4(src + offset);
		offset += 4;
		prli_acc->resp_process_associator = FCOE_B2V_4(src + offset);
		/*
		 * FC-4 type
		 */
		offset += 4;
		prli_acc->initiator_fn =
		    (FCOE_B2V_4(src + offset) & BIT_5) ? 1 : 0;
		prli_acc->target_fn =
		    (FCOE_B2V_4(src + offset) & BIT_4) ? 1 : 0;
		prli_acc->cmd_data_mixed =
		    (FCOE_B2V_4(src + offset) & BIT_3) ? 1 : 0;
		prli_acc->data_resp_mixed =
		    (FCOE_B2V_4(src + offset) & BIT_2) ? 1 : 0;
		prli_acc->read_xfer_rdy_disabled =
		    (FCOE_B2V_4(src + offset) & BIT_1) ? 1 : 0;
		prli_acc->write_xfer_rdy_disabled =
		    (FCOE_B2V_4(src + offset) & BIT_0) ? 1 : 0;

		break;

	case LA_ELS_LOGO:
		/*
		 * could only be LS_ACC, no additional information
		 */
		els_code->ls_code = FCOE_B2V_1(src);
		break;

	case LA_ELS_SCR:
		/*
		 * LS_ACC/LS_RJT, no additional information
		 */
		els_code->ls_code = FCOE_B2V_1(src);
		break;

	case LA_ELS_ADISC:
		offset = 5;
		els_adisc->hard_addr.hard_addr = FCOE_B2V_3(src + offset);
		offset = offsetof(la_els_adisc_t, port_wwn);
		bcopy(src + offset, &els_adisc->port_wwn, 8);
		offset = offsetof(la_els_adisc_t, node_wwn);
		bcopy(src + offset, &els_adisc->node_wwn, 8);
		offset += 9;
		els_adisc->nport_id.port_id = FCOE_B2V_3(src + offset);
		break;
	case LA_ELS_RLS:
		els_rls = (la_els_rls_acc_t *)(void *)dest;
		els_rls->ls_code.ls_code = FCOE_B2V_1(src);
		offset = 4;
		els_rls->rls_link_params.rls_link_fail =
		    FCOE_B2V_4(src + offset);
		offset = 8;
		els_rls->rls_link_params.rls_sync_loss =
		    FCOE_B2V_4(src + offset);
		offset = 12;
		els_rls->rls_link_params.rls_sig_loss =
		    FCOE_B2V_4(src + offset);
		offset = 16;
		els_rls->rls_link_params.rls_prim_seq_err =
		    FCOE_B2V_4(src + offset);
		offset = 20;
		els_rls->rls_link_params.rls_invalid_word =
		    FCOE_B2V_4(src + offset);
		offset = 24;
		els_rls->rls_link_params.rls_invalid_crc =
		    FCOE_B2V_4(src + offset);
		break;
	case LA_ELS_RNID:
		els_rnid = (la_els_rnid_acc_t *)(void *)dest;
		els_rnid->ls_code.ls_code = FCOE_B2V_1(src);
		offset = 4;
		bcopy(src + offset, &els_rnid->hdr.data_format, 1);
		offset = 5;
		bcopy(src + offset, &els_rnid->hdr.cmn_len, 1);
		offset = 7;
		bcopy(src + offset, &els_rnid->hdr.specific_len, 1);
		offset = 8;
		bcopy(src + offset, els_rnid->data, FCIO_RNID_MAX_DATA_LEN);
		break;
	default:
		FCOEI_LOG(__FUNCTION__, "unsupported R_CTL");
		break;
	}
}

/*
 * fcoei_fill_fcp_resp
 *	Fill fpkt FCP response in host format according to frm payload
 *
 * Input:
 *	src - frm payload in link format
 *	dest - fpkt FCP response in host format
 *	size - Maximum conversion size
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	This is called only for SCSI response with non good status
 */
static void
fcoei_fill_fcp_resp(uint8_t *src, uint8_t *dest, int size)
{
	fcp_rsp_t	*fcp_rsp_iu = (fcp_rsp_t *)(void *)dest;
	int		 offset;

	/*
	 * set fcp_status
	 */
	offset = offsetof(fcp_rsp_t, fcp_u);
	offset += 2;
	fcp_rsp_iu->fcp_u.fcp_status.resid_under =
	    (FCOE_B2V_1(src + offset) & BIT_3) ? 1 : 0;
	fcp_rsp_iu->fcp_u.fcp_status.resid_over =
	    (FCOE_B2V_1(src + offset) & BIT_2) ? 1 : 0;
	fcp_rsp_iu->fcp_u.fcp_status.sense_len_set =
	    (FCOE_B2V_1(src + offset) & BIT_1) ? 1 : 0;
	fcp_rsp_iu->fcp_u.fcp_status.rsp_len_set =
	    (FCOE_B2V_1(src + offset) & BIT_0) ? 1 : 0;
	offset += 1;
	fcp_rsp_iu->fcp_u.fcp_status.scsi_status = FCOE_B2V_1(src + offset);
	/*
	 * fcp_resid/fcp_sense_len/fcp_response_len
	 */
	offset = offsetof(fcp_rsp_t, fcp_resid);
	fcp_rsp_iu->fcp_resid = FCOE_B2V_4(src + offset);
	offset = offsetof(fcp_rsp_t, fcp_sense_len);
	fcp_rsp_iu->fcp_sense_len = FCOE_B2V_4(src + offset);
	offset = offsetof(fcp_rsp_t, fcp_response_len);
	fcp_rsp_iu->fcp_response_len = FCOE_B2V_4(src + offset);
	/*
	 * sense or response
	 */
	offset += 4;
	if (fcp_rsp_iu->fcp_sense_len) {
		if ((offset + fcp_rsp_iu->fcp_sense_len) > size) {
			FCOEI_LOG(__FUNCTION__, "buffer too small - sens");
			return;
		}
		bcopy(src + offset, dest + offset, fcp_rsp_iu->fcp_sense_len);
		offset += fcp_rsp_iu->fcp_sense_len;
	}

	if (fcp_rsp_iu->fcp_response_len) {
		if ((offset + fcp_rsp_iu->fcp_response_len) > size) {
			FCOEI_LOG(__FUNCTION__, "buffer too small - resp");
			return;
		}
		bcopy(src + offset, dest + offset,
		    fcp_rsp_iu->fcp_response_len);
	}
}

void
fcoei_init_ect_vectors(fcoe_client_t *ect)
{
	ect->ect_rx_frame	   = fcoei_rx_frame;
	ect->ect_port_event	   = fcoei_port_event;
	ect->ect_release_sol_frame = fcoei_release_sol_frame;
}

/*
 * fcoei_process_unsol_frame
 *	Unsolicited frame is received
 *
 * Input:
 *	frame = unsolicited frame that is received
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	watchdog will call this to process unsolicited frames that we
 *	just received fcoei_process_xx is used to handle different
 *	unsolicited frames
 */
void
fcoei_process_unsol_frame(fcoe_frame_t *frm)
{
	fcoei_exchange_t	*xch;
	uint16_t		 sol_oxid;

	switch (FRM_R_CTL(frm)) {
	case R_CTL_SOLICITED_DATA:
		/*
		 * READ data phase frame
		 * Find the associated exchange
		 */
		sol_oxid = FRM_OXID(frm);
		if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
		    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
			PRT_FRM_HDR(__FUNCTION__, frm);
			FCOEI_LOG(__FUNCTION__, "associated xch not found: "
			    "oxid/%x %lu - %lu", sol_oxid,
			    CURRENT_CLOCK, frm->frm_clock);
			break;
		}

		/*
		 * Copy data into fpkt data buffer, and update the counter
		 */
		bcopy(frm->frm_payload, (uint8_t *)xch->xch_fpkt->pkt_data +
		    FRM_PARAM(frm), frm->frm_payload_size);
		xch->xch_resid -= frm->frm_payload_size;
		xch->xch_rxid = FRM_RXID(frm);
		break;

	case R_CTL_XFER_RDY:
		fcoei_process_unsol_xfer_rdy(frm);
		break;

	case R_CTL_STATUS:
		fcoei_process_sol_fcp_resp(frm);
		break;

	case R_CTL_ELS_REQ:
		fcoei_process_unsol_els_req(frm);
		break;

	case R_CTL_LS_ABTS:
		fcoei_process_unsol_abts_req(frm);
		break;

	case R_CTL_ELS_RSP:
		fcoei_process_sol_els_rsp(frm);
		break;

	case R_CTL_SOLICITED_CONTROL:
		fcoei_process_sol_ct_rsp(frm);
		break;

	case R_CTL_LS_BA_ACC:
		fcoei_process_sol_abts_acc(frm);
		break;

	case R_CTL_LS_BA_RJT:
		fcoei_process_sol_abts_rjt(frm);
		break;

	default:
		/*
		 * Unsupported frame
		 */
		PRT_FRM_HDR("Unsupported unsol frame: ", frm);
	}

	/*
	 * Release the frame and netb
	 */
	frm->frm_eport->eport_free_netb(frm->frm_netb);
	frm->frm_eport->eport_release_frame(frm);
}

/*
 * fcoei_handle_sol_frame_done
 *	solicited frame is just sent out
 *
 * Input:
 *	frame = solicited frame that has been sent out
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	watchdog will call this to handle solicited frames that FCOEI
 *	has sent out Non-request frame post handling
 */
void
fcoei_handle_sol_frame_done(fcoe_frame_t *frm)
{
	/*
	 * the corresponding xch could be NULL at this time
	 */
	fcoei_exchange_t	*xch  = FRM2IFM(frm)->ifm_xch;

	switch (FRM2IFM(frm)->ifm_rctl) {
	case R_CTL_ELS_RSP:
		/*
		 * Complete it with frm as NULL
		 */
		fcoei_complete_xch(xch, NULL, FC_PKT_SUCCESS, 0);
		break;

	case R_CTL_LS_BA_ACC:
		FCOEI_LOG(__FUNCTION__,  "BA_ACC out: xch-%p, frm-%p",
		    xch, frm);
		PRT_FRM_HDR("LS_BA_ACC", frm);
		break;

	case R_CTL_LS_BA_RJT:
		FCOEI_LOG(__FUNCTION__,  "BA_RJT out: xch-%p, frm-%p",
		    xch, frm);
		PRT_FRM_HDR("LS_BA_RJT", frm);
		break;

	default:
		/*
		 * Unsupported frame
		 */
		PRT_FRM_HDR("Unsupported sol frame: ", frm);
	}

	/*
	 * We should release only the frame, and we don't care its netb
	 */
	FRM2SS(frm)->ss_eport->eport_release_frame(frm);
}

/*
 * fcoei_port_event
 *	link/port state changed
 *
 * Input:
 *	eport = to indicate which port has changed
 *	event = what change
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	refer fctl.h for ss_link_state value
 */
void
fcoei_port_event(fcoe_port_t *eport, uint32_t event)
{
	fcoei_event_t	*ae;

	if (!(EPORT2SS(eport)->ss_flags & SS_FLAG_LV_BOUND)) {
		FCOEI_LOG(__FUNCTION__, "not bound now");
		return;
	}

	mutex_enter(&EPORT2SS(eport)->ss_watchdog_mutex);
	switch (event) {
	case FCOE_NOTIFY_EPORT_LINK_DOWN:
		EPORT2SS(eport)->ss_link_state = FC_STATE_OFFLINE;
		cmn_err(CE_NOTE, "%02x%02x%02x%02x%02x%02x%02x%02x Link down",
		    eport->eport_portwwn[0], eport->eport_portwwn[1],
		    eport->eport_portwwn[2], eport->eport_portwwn[3],
		    eport->eport_portwwn[4], eport->eport_portwwn[5],
		    eport->eport_portwwn[6], eport->eport_portwwn[7]);
		break;

	case FCOE_NOTIFY_EPORT_LINK_UP:
		if (eport->eport_mtu >= 2200) {
			EPORT2SS(eport)->ss_fcp_data_payload_size =
			    FCOE_DEFAULT_FCP_DATA_PAYLOAD_SIZE;
		} else {
			FCOEI_LOG(__FUNCTION__, "fcoei: MTU is not big enough. "
			    "we will use 1K frames in FCP data phase.");
			EPORT2SS(eport)->ss_fcp_data_payload_size =
			    FCOE_MIN_FCP_DATA_PAYLOAD_SIZE;
		}

		cmn_err(CE_NOTE, "%02x%02x%02x%02x%02x%02x%02x%02x Link up",
		    eport->eport_portwwn[0], eport->eport_portwwn[1],
		    eport->eport_portwwn[2], eport->eport_portwwn[3],
		    eport->eport_portwwn[4], eport->eport_portwwn[5],
		    eport->eport_portwwn[6], eport->eport_portwwn[7]);
		EPORT2SS(eport)->ss_link_state = FC_STATE_ONLINE;
		break;

	default:
		FCOEI_LOG(__FUNCTION__, "unsupported event");
		mutex_exit(&EPORT2SS(eport)->ss_watchdog_mutex);

		return;
	}

	EPORT2SS(eport)->ss_port_event_counter++;
	ae = (fcoei_event_t *)kmem_zalloc(sizeof (fcoei_event_t), KM_SLEEP);
	ae->ae_type = AE_EVENT_PORT;
	ae->ae_obj = EPORT2SS(eport);
	ae->ae_specific = EPORT2SS(eport)->ss_link_state;
	list_insert_tail(&EPORT2SS(eport)->ss_event_list, ae);
	mutex_exit(&EPORT2SS(eport)->ss_watchdog_mutex);
}

/*
 * fcoei_process_event_port
 *	link/port state changed
 *
 * Input:
 *	ae = link fcoei_event
 *
 * Returns:
 *	N/A
 *
 * Comments:
 *	asynchronous events from FCOE
 */
void
fcoei_process_event_port(fcoei_event_t *ae)
{
	fcoei_soft_state_t	*ss = (fcoei_soft_state_t *)ae->ae_obj;

	if (ss->ss_eport->eport_link_speed == FCOE_PORT_SPEED_1G) {
		ae->ae_specific |= FC_STATE_1GBIT_SPEED;
	} else if (ss->ss_eport->eport_link_speed ==
	    FCOE_PORT_SPEED_10G) {
		ae->ae_specific |= FC_STATE_10GBIT_SPEED;
	}

	if (ss->ss_flags & SS_FLAG_LV_BOUND) {
		ss->ss_bind_info.port_statec_cb(ss->ss_port,
		    (uint32_t)ae->ae_specific);
	} else {
		FCOEI_LOG(__FUNCTION__, "ss %p not bound now", ss);
	}

	atomic_dec_32(&ss->ss_port_event_counter);
	kmem_free(ae, sizeof (fcoei_event_t));
}