5045 use atomic_{inc,dec}_* instead of atomic_add_*

[illumos-gate.git] / usr / src / uts / common / io / fibre-channel / fca / fcoei / fcoei_eth.c

/*
 * 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));
}