sli4_skh_iscsi.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. Neither the name of the copyright holder 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 HOLDER 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.
 *
 */

/**
 * @file
 * Implementation of iSCSI Skyhawk SLI-4 functions
 */

#include "ocs.h"
#include "ocs_hal.h"
#include "sli4.h"
#include "sli4_iscsi.h"
#include "ocs_iscsi_spec.h"

#if defined(OCS_INCLUDE_DEBUG)
#include "ocs_debug.h"
#endif

extern const char *SLI_QNAME[];

static int32_t sli_skh_iscsi_cqe_i_sol(sli4_t *, uint8_t *cqe,
                       sli4_qentry_fields_t *fields);
static int32_t sli_skh_iscsi_cqe_t_sol(sli4_t *, uint8_t *cqe,
                       sli4_qentry_fields_t *fields);
static int32_t sli_skh_iscsi_cqe_t_sol_data_digest(sli4_t *, uint8_t *cqe,
                          sli4_qentry_fields_t *fields);
static int32_t sli_skh_iscsi_cqe_t_cnxinv(sli4_t *, uint8_t *cqe,
                      sli4_qentry_fields_t *fields);
static int32_t sli_skh_iscsi_cqe_t_cmdinv(sli4_t *, uint8_t *cqe,
                      sli4_qentry_fields_t *fields);
static int32_t sli_skh_iscsi_cqe_i_t_dpdu(sli4_t *, uint8_t *cqe,
                      sli4_qentry_fields_t *fields);
static int32_t sli_skh_iscsi_cqe_i_t_dmsg(sli4_t *, uint8_t *cqe,
                      sli4_qentry_fields_t *fields);
static int32_t sli_skh_iscsi_cqe_tx_dif_error(sli4_t *sli4, uint8_t *cqe,
                          sli4_qentry_fields_t *fields);

/*
 * Determine the CQE format based on the "code" in the common format
 */
cqe_handler_t *ini_skh_cqe_handlers[ISCSI_CQE_CODE_MAX+1] =
{
    sli_skh_iscsi_cqe_t_cnxinv,      /* 0 dummy - should not occur */
    sli_skh_iscsi_cqe_i_sol,         /* 1 NORMAL*/
    sli_skh_iscsi_cqe_i_sol,         /* 2 CMD_DIGEST_ERROR */
    sli_skh_iscsi_cqe_i_sol,         /* 3 RECV_PDU_DSL_ERROR */
    sli_skh_iscsi_cqe_i_sol,         /* 4 RECV_SEQ_BURST_ERROR */
    sli_skh_iscsi_cqe_i_sol,         /* 5 RECV_AHS_NOT_SUPPORTED */
    sli_skh_iscsi_cqe_i_sol,         /* 6 HDR_DIGEST_ERROR */
    sli_skh_iscsi_cqe_i_sol,         /* 7 OPCODE_ERROR */
    sli_skh_iscsi_cqe_i_sol,         /* 8 ITT_TTT_WRONG_CXN */
    sli_skh_iscsi_cqe_i_sol,         /* 9 ITT_TTT_TOO_BIG */
    sli_skh_iscsi_cqe_i_sol,         /* A TCP_RECV_RST */
    sli_skh_iscsi_cqe_i_sol,         /* B TCP_TIMEOUT */
    sli_skh_iscsi_cqe_i_sol,         /* C TCP_SENT_RST */
    sli_skh_iscsi_cqe_i_sol,         /* D TCP_RECV_FIN */
    sli_skh_iscsi_cqe_i_sol,         /* E BAD_UNSOL_PDU */
    sli_skh_iscsi_cqe_i_sol,         /* F BAD_WQE_INDEX */
    sli_skh_iscsi_cqe_i_sol,         /* 10 RESIDUAL_OVERRUN */
    sli_skh_iscsi_cqe_i_sol,         /* 11 RESIDUAL_UNDERRUN */
    sli_skh_iscsi_cqe_i_sol,         /* 12 INVALID_STATSN */
    sli_skh_iscsi_cqe_i_sol,         /* 13 R2T_INVALID_FIELDS */
    sli_skh_iscsi_cqe_i_sol,         /* 14 INVALID_LUN */
    sli_skh_iscsi_cqe_i_sol,         /* 15 INVALID_ICD_STATE */
    sli_skh_iscsi_cqe_i_sol,         /* 16 RECV_PDU_INVALID_ITT */
    sli_skh_iscsi_cqe_i_sol,         /* 17 RECV_SEQ_BUF_OUT_OF_ORDER */
    sli_skh_iscsi_cqe_i_sol,         /* 18 RECV_PDU_INVALID_DATASN */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 19 HOST_CXN_INVALIDATION */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 1A HOST_CXN_INVL_WITH_PDU */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 1B HOST_CMD_INVALIDATION */
    sli_skh_iscsi_cqe_i_t_dpdu,      /* 1C UNSOL_HDR_NOTIFY */
    sli_skh_iscsi_cqe_i_t_dpdu,      /* 1D UNSOL_DATA_NOTIFY */
    sli_skh_iscsi_cqe_i_t_dpdu,      /* 1E UNSOL_DATA_DIGEST_ERROR */
    sli_skh_iscsi_cqe_i_t_dmsg,      /* 1F TCP_ACK */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 20 CMD_DATA_DIFF_CXN */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 21 DIF_ERROR */
    sli_skh_iscsi_cqe_t_cnxinv       /* 22 RECV_UNSOL_PDU_ERROR */
};

cqe_handler_t *tgt_skh_cqe_handlers[ISCSI_CQE_CODE_MAX+1] =
{
    sli_skh_iscsi_cqe_t_cnxinv,      /* 0 dummy - should not occur */
    sli_skh_iscsi_cqe_t_sol,         /* 1 NORMAL*/
    sli_skh_iscsi_cqe_t_sol_data_digest, /* 2 CMD_DIGEST_ERROR */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 3 RECV_PDU_DSL_ERROR */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 4 RECV_SEQ_BURST_ERROR */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 5 RECV_AHS_NOT_SUPPORTED */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 6 HDR_DIGEST_ERROR */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 7 OPCODE_ERROR */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 8 ITT_TTT_WRONG_CXN */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 9 ITT_TTT_TOO_BIG */
    sli_skh_iscsi_cqe_t_cnxinv,      /* A TCP_RECV_RST */
    sli_skh_iscsi_cqe_t_cnxinv,      /* B TCP_TIMEOUT */
    sli_skh_iscsi_cqe_t_cnxinv,      /* C TCP_SENT_RST */
    sli_skh_iscsi_cqe_t_cnxinv,      /* D TCP_RECV_FIN */
    sli_skh_iscsi_cqe_t_cnxinv,      /* E BAD_UNSOL_PDU */
    sli_skh_iscsi_cqe_t_cnxinv,      /* F BAD_WQE_INDEX */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 10 RESIDUAL_OVERRUN */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 11 RESIDUAL_UNDERRUN */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 12 INVALID_STATSN */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 13 R2T_INVALID_FIELDS */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 14 INVALID_LUN */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 15 INVALID_ICD_STATE */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 16 RECV_PDU_INVALID_ITT */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 17 RECV_SEQ_BUF_OUT_OF_ORDER */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 18 RECV_PDU_INVALID_DATASN */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 19 HOST_CXN_INVALIDATION */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 1A HOST_CXN_INVL_WITH_PDU */
    sli_skh_iscsi_cqe_t_cmdinv,      /* 1B HOST_CMD_INVALIDATION */
    sli_skh_iscsi_cqe_i_t_dpdu,      /* 1C UNSOL_HDR_NOTIFY */
    sli_skh_iscsi_cqe_i_t_dpdu,      /* 1D UNSOL_DATA_NOTIFY */
    sli_skh_iscsi_cqe_i_t_dpdu,      /* 1E UNSOL_DATA_DIGEST_ERROR */
    sli_skh_iscsi_cqe_i_t_dmsg,      /* 1F TCP_ACK */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 20 CMD_DATA_DIFF_CXN */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 21 DIF_ERROR */
    sli_skh_iscsi_cqe_t_cnxinv,      /* 22 RECV_UNSOL_PDU_ERROR */
    sli_skh_iscsi_cqe_tx_dif_error       /* 23 TX_DIF_ERR */
};

/**
 * @brief Write an DIF WQE work queue entry.
 *
 * @param buf Destination buffer for the WQE.
 * @param dif_info Pointer to the DIF fields (may be NULL).
 * @param sgl0 Pointer to the SGL to put in SGE0 (data).
 * @param sgl_dif Pointer to the SGL to put in SGE1 (DIF separate).
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_dif(void *buf,
        ocs_hal_dif_info_t* dif_info,
        sli4_sge_t *sgl0,
        sli4_sge_t *sgl_dif)
{
    sli4_skh_wqe_dif_t * req = buf;

    if (sgl0 != NULL) {
        req->sge0_addr_high = sgl0->buffer_address_high;
        req->sge0_addr_low  = sgl0->buffer_address_low;
        req->s0l        = sgl0->last;
        req->sge0_offset = sgl0->data_offset;
        req->sge0_length = sgl0->buffer_length;
    }

    if (dif_info->dif_separate) {
        req->sdm = 1;
        if (sgl_dif != NULL) {
            req->mkaddr_addr_high = sgl_dif->buffer_address_high;
            req->mkaddr_addr_low = sgl_dif->buffer_address_low;
        }
    }

    req->dif_enable = 1;
    req->exp_ref_tag = dif_info->ref_tag_cmp;
    req->t10_crc_seed = 0;
    req->t10_atrt = dif_info->disable_app_ref_ffff;
    req->t10_at = dif_info->disable_app_ffff;
    req->rep_ref_tag = dif_info->ref_tag_repl;
    req->meta_tag = dif_info->app_tag_cmp;
    req->dif_blk_size = dif_info->blk_size;
    req->dif_auto_inc = dif_info->auto_incr_ref_tag;
    req->check_meta_tag = dif_info->check_app_tag;
    req->check_ref_tag = dif_info->check_ref_tag;
    req->check_crc = dif_info->check_guard;
    req->replace_ref_tag = dif_info->repl_ref_tag;

    switch(dif_info->dif_oper) {
    case OCS_HAL_DIF_OPER_PASS_THRU:
        req->rx_dif_mode = SLI4_SGE_DIF_OP_IN_CRC_OUT_CRC;
        req->tx_dif_mode = SLI4_SGE_DIF_OP_IN_CRC_OUT_CRC;
        break;
    case OCS_HAL_DIF_OPER_STRIP:
        req->rx_dif_mode = SLI4_SGE_DIF_OP_IN_CRC_OUT_NODIF;
        req->tx_dif_mode = SLI4_SGE_DIF_OP_IN_CRC_OUT_NODIF;
        break;
    case OCS_HAL_DIF_OPER_INSERT:
        req->rx_dif_mode = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CRC;
        req->tx_dif_mode = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CRC;
        break;
    default:
        break;
    }

    return 0;
}


/**
 * @brief write an INITIATOR_WRITE_COMMAND WQE work queue entry
 *
 * @par Description
 *  - sgl[0] points the BHS.
 *  - sgl[1] must be empty.
 *  - sgl[2] starts the data SGEs.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param lun LUN value for the command.
 * @param exp_xfer_len Total # of payload bytes.
 * @param cmdsn iSCSI cmdsn for the command.
 * @param icd_index ICD index fr this request.
 * @param dif_info Pointer to the DIF fields (may be NULL).
 * @param sgl Pointer to the SGEs for this IO.
 * @param n_sge Number of SGEs present.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_ini_write(sli4_t *sli4, void *buf, size_t size,
              uint16_t   lun,
              uint32_t   exp_xfer_len,
              uint32_t   cmdsn,
              uint16_t   icd_index,
              ocs_hal_dif_info_t* dif_info,
              sli4_sge_t *sgl,
              uint32_t    n_sge)
{
    sli4_skh_wqe_ini_write_t * req = buf;

    /* TODO: Replace memset & optimize as 90% data is inited.
     */
    ocs_memset(buf, 0, size);
    req->type = SLI4_WQE_INI_WRITE;
    req->lun = lun & 0xffff;
    req->dsp = (exp_xfer_len > 0 ? 1 : 0);
    req->exp_xfer_len = exp_xfer_len;
    req->icd_index = icd_index;
    req->bhs_addr_high = sgl[0].buffer_address_high;
    req->bhs_addr_low = sgl[0].buffer_address_low;
    req->cmdsn = cmdsn;

    /* Optimization: Providing multiple SGE frags embedded in WQE
     * for achieving better metrics for smaller sized io ops.
     */
    if (dif_info == NULL) {
        if (n_sge > 2) {
            req->sge0_addr_high = sgl[2].buffer_address_high;
            req->sge0_addr_low  = sgl[2].buffer_address_low;
            req->s0l        = sgl[2].last;
            req->sge0_offset    = sgl[2].data_offset;
            req->sge0_length    = sgl[2].buffer_length;
        }

        if (n_sge > 3) {
            req->sge1_addr_high = sgl[3].buffer_address_high;
            req->sge1_addr_low  = sgl[3].buffer_address_low;
            req->s1l        = sgl[3].last;
            req->sge1_offset    = sgl[3].data_offset;
            req->sge1_length    = sgl[3].buffer_length;
        }
    } else {
        /*
         * For initiator WQEs, the BHS is first, followed by a skip,
         * next is the DIF seed, DIF (if separate) and then data.
         */
        sli4_sge_t *sgl_data = NULL;
        sli4_sge_t *sgl_dif  = NULL;

        if (dif_info->dif_separate) {
            sgl_dif  = (n_sge > 3 ? &sgl[3] : NULL);
            sgl_data = (n_sge > 4 ? &sgl[4] : NULL);
        } else {
            sgl_data = (n_sge > 3 ? &sgl[3] : NULL);
        }
        sli_skh_wqe_dif(buf, dif_info, sgl_data, sgl_dif);
    }

    return 0;
}

/**
 * @brief Write an INITIATOR_TMF WQE work queue entry.
 * 
 * @par Description
 * - sgl[0] points the the BHS.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param lun The LUN value for the command.
 * @param cmdsn  iSCSI cmdsn for the command.
 * @param icd_index ICD index fr this request.
 * @param sgl Pointer to the SGEs for this IO.
 * @param n_sge Number of SGEs present.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_ini_tmf(sli4_t *sli4, void *buf, size_t size,
            uint16_t   lun,
            uint32_t   cmdsn,
            uint16_t   icd_index,
            sli4_sge_t *sgl,
            uint32_t    n_sge)
{
    sli4_skh_wqe_ini_tmf_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_INI_TMF;
    req->lun = lun & 0xffff;
    req->icd_index = icd_index;
    req->bhs_addr_high = sgl[0].buffer_address_high;
    req->bhs_addr_low = sgl[0].buffer_address_low;
    req->cmdsn = cmdsn;

    return 0;
}


/**
 * @brief Write an INITIATOR_NOP_OUT_COMMAND WQE work queue entry.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param dm Determines whether a dmsg CQE is generated.
 * @param cmdsn iSCSI cmdsn for the command.
 * @param bhs Pointer to the basic header segment.
 * @param payload1 Optional pointer to payload memory.
 * @param payload2 Optional pointer to payload memory.
 * @param exp_xfer_len Total # of payload bytes.
 * @param icd_index ICD index fr this request.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_ini_nop(sli4_t *sli4, void *buf, size_t size,
            uint8_t    dm,
            uint32_t   cmdsn,
            ocs_dma_t *bhs,
            ocs_dma_t *payload1,
            ocs_dma_t *payload2,
            uint32_t   exp_xfer_len,
            uint16_t   icd_index)
{
    sli4_skh_wqe_ini_nop_t *req = buf;

    /* TODO: Replace memset & optimize as 90% data is inited.
     */
    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_INI_NOP;
    req->dsp = (exp_xfer_len > 0 ? 1 : 0);
    req->dm = dm;
    req->exp_xfer_len = exp_xfer_len;
    req->icd_index = icd_index;
    req->bhs_addr_high = ocs_addr32_hi(bhs->phys);
    req->bhs_addr_low = ocs_addr32_lo(bhs->phys);
    req->cmdsn = cmdsn;

    if (exp_xfer_len > 0 && payload1 != NULL) {
        req->sge0_addr_high = ocs_addr32_hi(payload1->phys);
        req->sge0_addr_low  = ocs_addr32_lo(payload1->phys);
        req->s0l        = (payload2 == NULL ? 1 : 0);
        req->sge0_offset    = 0;
        req->sge0_length    = (payload2 != NULL ? payload1->size : exp_xfer_len);
    }

    if (exp_xfer_len > 0 && payload1 != NULL && payload2 != NULL) {
        req->sge1_addr_high = ocs_addr32_hi(payload2->phys);
        req->sge1_addr_low = ocs_addr32_lo(payload2->phys);
        req->s1l = 1;
        req->sge1_offset = payload1->size;
        req->sge1_length = exp_xfer_len - payload1->size;
    }

    return 0;
}

/**
 * @brief write an INITIATOR_READ WQE work queue entry.
 *
 * @par Description
 * - sgl[0] points the the BHS.
 * - sgl[1] must be empty.
 * - sgl[2] starts the data SGEs.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param lun LUN value for the command.
 * @param exp_xfer_len Total # of payload bytes.
 * @param cmdsn iSCSI cmdsn for the command.
 * @param icd_index ICD index fr this request.
 * @param dif_info Pointer to the DIF fields (may be NULL).
 * @param sgl Pointer to the SGEs for this IO.
 * @param n_sge Number of SGEs present.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_ini_read(sli4_t *sli4, void *buf, size_t size,
             uint16_t   lun,
             uint32_t   exp_xfer_len,
             uint32_t   cmdsn,
             uint16_t   icd_index,
             ocs_hal_dif_info_t* dif_info,
             sli4_sge_t *sgl,
             uint32_t    n_sge)
{
    sli4_skh_wqe_ini_read_t *req = buf;

    /* TODO: Replace memset & optimize as 90% data is inited.
     */
    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_INI_READ;
    req->lun = lun & 0xffff;
    req->exp_xfer_len = exp_xfer_len;
    req->icd_index = icd_index;
    req->bhs_addr_high = sgl[0].buffer_address_high;
    req->bhs_addr_low = sgl[0].buffer_address_low;
    req->cmdsn = cmdsn;

    if (dif_info == NULL) {
        if (n_sge > 2) {
            req->sge0_addr_high = sgl[2].buffer_address_high;
            req->sge0_addr_low  = sgl[2].buffer_address_low;
            req->s0l        = sgl[2].last;
            req->sge0_offset    = sgl[2].data_offset;
            req->sge0_length    = sgl[2].buffer_length;
        }

        if (n_sge > 3) {
            req->sge1_addr_high = sgl[3].buffer_address_high;
            req->sge1_addr_low  = sgl[3].buffer_address_low;
            req->s1l        = sgl[3].last;
            req->sge1_offset    = sgl[3].data_offset;
            req->sge1_length    = sgl[3].buffer_length;
        }
    } else {
        /*
         * For initiator WQEs, the BHS is first, followed by a skip,
         * next is the DIF seed, DIF (if separate) and then data.
         */
        sli4_sge_t *sgl_data = NULL;
        sli4_sge_t *sgl_dif  = NULL;

        if (dif_info->dif_separate) {
            sgl_dif  = (n_sge > 3 ? &sgl[3] : NULL);
            sgl_data = (n_sge > 4 ? &sgl[4] : NULL);
        } else {
            sgl_data = (n_sge > 3 ? &sgl[3] : NULL);
        }
        sli_skh_wqe_dif(buf, dif_info, sgl_data, sgl_dif);
    }

    return 0;
}

//@@@TODO: For skyhawk context update wqe, address ppdu, sgl chaining
// bits appropriately.
/**
 * @brief Write an CONTEXT_UPDATE_WQE work queue entry
 *
 * @param sli4        SLI context.
 * @param buf         destination buffer for the WQE.
 * @param size        buffer size in bytes.
 * @param lgn_options the target login options for the connection.
 * @param statsn      the status SN for the connection.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_update_context(sli4_t *sli4, void *buf, size_t size,
               ocs_hal_target_login_options_t *lgn_options,
               uint32_t statsn)
{
    sli4_skh_wqe_context_update_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_CONTEXT_UPDATE;
    req->max_burst = lgn_options->session_options.max_burst;
    req->max_send_dsl = lgn_options->max_send_dsl;
    req->first_burst = lgn_options->session_options.first_burst;
    req->max_r2t = lgn_options->session_options.max_r2t;
    req->header_digest_enable = lgn_options->hdr_digest;
    req->data_digest_enable = lgn_options->data_digest;
    req->error_recovery_level = lgn_options->session_options.error_recovery_level;
    req->immediate_data = lgn_options->session_options.immediate_data;
    req->initial_r2t = lgn_options->session_options.initial_r2t;
    req->statsn = statsn;
    req->max_recv_dsl = lgn_options->max_rcv_dsl;
    req->max_cxns = lgn_options->session_options.max_connections;
    req->dm = 1;
    req->data_seq_inorder = lgn_options->session_options.data_sequence_in_order;
    req->data_pdu_inorder = lgn_options->session_options.data_pdu_in_order;

    return 0;
}

/**
 * @brief Write an TGT_STS_WQE work queue entry.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param bhs Pointer to the basic header segment.
 * @param lun LUN value for the command.
 * @param exp_xfer_len Total # of payload bytes.
 * @param exp_data_sn Expected data sequence number.
 * @param itt Initiator transfer tag.
 * @param icd_index ICD index fr this request.
 * @param ref_icd_index Reference ICD Index.
 * @param dif_info Pointer to the DIF fields (may be NULL).
 * @param r2t_offset R2T buffer Offset.
 * @param sgl Pointer to the SGEs for this IO.
 * @param n_sge Number of SGEs present.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_tgt_sts(sli4_t *sli4, void *buf, size_t size,
            ocs_dma_t *bhs,
            uint16_t   lun,
            uint32_t   exp_xfer_len,
            uint32_t   exp_data_sn,
            uint32_t   itt,
            uint16_t   icd_index,
            uint16_t   ref_icd_index,
            ocs_hal_dif_info_t* dif_info,
            uint32_t   r2t_offset,
            sli4_sge_t *sgl,
            uint32_t   n_sge)
{
    sli4_skh_wqe_tgt_sts_t *req = buf;
    uint32_t i;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_TGT_STS;
    req->lun = lun & 0xffff;
    req->exp_xfer_len = exp_xfer_len;
    req->icd_index = icd_index;
    req->exp_data_sn = exp_data_sn;
    req->bhs_addr_high = ocs_addr32_hi(bhs->phys);
    req->bhs_addr_low = ocs_addr32_lo(bhs->phys);
    req->itt = itt;
    req->ref_icd_index = ref_icd_index;
    req->r2t_offset = r2t_offset;

    if (dif_info == NULL) {
        req->dif_enable = 0;
    } else {
        sli4_sge_t *sgl_data = NULL;
        sli4_sge_t *sgl_dif  = NULL;

        if (dif_info->dif_separate) {
            sgl_dif  = (n_sge > 1 ? &sgl[1] : NULL);
            sgl_data = (n_sge > 2 ? &sgl[2] : NULL);
        } else {
            sgl_data = (n_sge > 1 ? &sgl[1] : NULL);
        }
        sli_skh_wqe_dif(buf, dif_info, sgl_data, sgl_dif);
    }

    /* Workaround for Skyhawk DIF issue - change all DIF and DISEED SGEs to SKIPs */
    for (i=0; i<n_sge; i++) {
        if ((sgl[i].sge_type == SLI4_SGE_TYPE_DIF) ||
            (sgl[i].sge_type == SLI4_SGE_TYPE_DISEED)) {
            sgl[i].sge_type = SLI4_SGE_TYPE_SKIP;
        }
    }


    return 0;
}


/**
 * @brief Write an TGT_DATAIN_WQE work queue entry.
 *
 * @par Description
 * The SGE entries in this WQE are used if all the entries fit in the
 * WQE for a performance increase.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param bhs Pointer to the basic header segment.
 * @param lun LUN value for the command.
 * @param dm Determines whether a dmsg CQE is generated.
 * @param underrun Sets the underrun bit in the auto response.
 * @param overrun Sets the overrun bit in the auto response.
 * @param exp_xfer_len Total # of payload bytes.
 * @param icd_index ICD Index for this request.
 * @param ref_icd_index Reference ICD Index.
 * @param data_sn Starting data sequence number.
 * @param piggy_back_status If true, a good status is sent to the initiator.
 * @param dif_info Pointer to the DIF fields (may be NULL).
 * @param sgl Pointer to the SGEs for this IO.
 * @param n_sge Number of SGEs present.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_tgt_datain(sli4_t *sli4, void *buf, size_t size,
               ocs_dma_t *bhs,
               uint16_t   lun,
               uint8_t    dm,
               uint8_t    underrun,
               uint8_t    overrun,
               uint32_t   exp_xfer_len,
               uint16_t   icd_index,
               uint16_t   ref_icd_index,
               uint32_t   data_sn,
               uint8_t    piggy_back_status,
               ocs_hal_dif_info_t* dif_info,
               sli4_sge_t *sgl,
               uint32_t    n_sge)
{
    sli4_skh_wqe_tgt_datain_t *req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_TGT_DATAIN;
    req->lun = lun & 0xffff;
    req->dsp = (exp_xfer_len > 0 ? 1 : 0);
    req->dm = dm;
    req->underrun = underrun;
    req->overrun = overrun;
    req->exp_xfer_len = exp_xfer_len;
    req->icd_index = icd_index;
    req->ref_icd_index = ref_icd_index;
    req->data_sn = data_sn;
    req->bhs_addr_high = ocs_addr32_hi(bhs->phys);
    req->bhs_addr_low = ocs_addr32_lo(bhs->phys);
    req->piggy_back_status = piggy_back_status;

    req->sge0_addr_high = sgl[0].buffer_address_high;
    req->sge0_addr_low  = sgl[0].buffer_address_low;
    req->s0l        = sgl[0].last;
    req->sge0_offset    = sgl[0].data_offset;
    req->sge0_length    = sgl[0].buffer_length;

    if (dif_info == NULL) {
        if (n_sge > 1) {
            req->sge1_addr_high = sgl[1].buffer_address_high;
            req->sge1_addr_low  = sgl[1].buffer_address_low;
            req->s1l        = sgl[1].last;
            req->sge1_offset    = sgl[1].data_offset;
            req->sge1_length    = sgl[1].buffer_length;
        }
    } else {
        /*
         * For target data in WQEs, the DIF seed is first, then
         * DIF (if separate) and then data.
         */
        sli4_sge_t *sgl_data = NULL;
        sli4_sge_t *sgl_dif  = NULL;

        if (dif_info->dif_separate) {
            sgl_dif  = (n_sge > 1 ? &sgl[1] : NULL);
            sgl_data = (n_sge > 2 ? &sgl[2] : NULL);
        } else {
            sgl_data = (n_sge > 1 ? &sgl[1] : NULL);
        }
        sli_skh_wqe_dif(buf, dif_info, sgl_data, sgl_dif);
    }

    return 0;
}

/**
 * @brief Write an TGT_SOS_WQE work queue entry.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param bhs Pointer to the basic header segment.
 * @param payload1 Optional pointer to payload memory.
 * @param payload2 Optional pointer to payload memory.
 * @param lun LUN value for the command.
 * @param dm Determines whether a dmsg CQE is generated.
 * @param exp_xfer_len Total # of payload bytes.
 * @param icd_index ICD index for this request.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_tgt_sos(sli4_t *sli4, void *buf, size_t size,
            ocs_dma_t *bhs,
            ocs_dma_t *payload1,
            ocs_dma_t *payload2,
            uint16_t  lun,
            uint8_t   dm,
            uint32_t  exp_xfer_len,
            uint16_t  icd_index)
{
    sli4_skh_wqe_tgt_sos_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_TGT_SOS;
    req->lun = lun & 0xffff;
    req->dsp = (exp_xfer_len > 0 ? 1 : 0);
    req->dm = dm;
    req->exp_xfer_len = exp_xfer_len;
    req->icd_index = icd_index;
    req->bhs_addr_high = ocs_addr32_hi(bhs->phys);
    req->bhs_addr_low = ocs_addr32_lo(bhs->phys);
    req->piggy_back_status = 1;

    if (exp_xfer_len > 0 && payload1 != NULL) {
        req->sge0_addr_high = ocs_addr32_hi(payload1->phys);
        req->sge0_addr_low = ocs_addr32_lo(payload1->phys);
        req->s0l = (payload2 == NULL ? 1 : 0);
        req->sge0_length = (payload2 != NULL ? payload1->size : exp_xfer_len);
    }

    if (exp_xfer_len > 0 && payload1 != NULL && payload2 != NULL) {
        req->sge1_addr_high = ocs_addr32_hi(payload2->phys);
        req->sge1_addr_low = ocs_addr32_lo(payload2->phys);
        req->s1l = 1;
        req->sge1_length = exp_xfer_len - payload1->size;
    }
    return 0;
}


/**
 * @brief Write an DM_CMD_WQE work queue entry.
 *
 * @param sli4 SLI context.
 * @param buf Destination buffer for the WQE.
 * @param size Buffer size in bytes.
 * @param set_dm If TRUE, then a I_T_DMSG_CQE is generated on TCP ACK.
 * @param incr_statsn If TRUE, the statsn is incremented by the FW.
 * @param is_login If TRUE, the statsn is not updated by FW.
 * @param bhs Pointer to the basic header segment.
 * @param payload1 Optional pointer to payload memory.
 * @param payload2 Optional pointer to payload memory.
 * @param exp_xfer_len Total # of payload bytes.
 * @param icd_index ICD index fr this request.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_wqe_unassisted(sli4_t *sli4, void *buf, size_t size,
               uint8_t   set_dm,
               uint8_t   incr_statsn,
               uint8_t   is_login,
               ocs_dma_t *bhs,
               ocs_dma_t *payload1,
               ocs_dma_t *payload2,
               uint32_t  exp_xfer_len,
               uint16_t  icd_index)
{
    sli4_skh_wqe_unassisted_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_UNASSISTED;
    req->dsp  = (exp_xfer_len ? 1 : 0);
    req->dm   = (set_dm ? 1 : 0);
    req->exp_xfer_len = exp_xfer_len;
    req->icd_index = icd_index;
    req->login_pdu = (is_login ? 1 : 0);
    req->bhs_addr_high = ocs_addr32_hi(bhs->phys);
    req->bhs_addr_low = ocs_addr32_lo(bhs->phys);
    req->piggy_back_status = incr_statsn;

    if (exp_xfer_len > 0 && payload1 != NULL) {
        req->sge0_addr_high = ocs_addr32_hi(payload1->phys);
        req->sge0_addr_low = ocs_addr32_lo(payload1->phys);
        req->s0l = (payload2 == NULL ? 1 : 0);
        req->sge0_length = (payload2 != NULL ? payload1->size : exp_xfer_len);
    }

    if (exp_xfer_len > 0 && payload1 != NULL && payload2 != NULL) {
        req->sge1_addr_high = ocs_addr32_hi(payload2->phys);
        req->sge1_addr_low = ocs_addr32_lo(payload2->phys);
        req->s1l = 1;
        req->sge1_length = exp_xfer_len - payload1->size;
    }

    return 0;
}

/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_i_sol(sli4_t *sli4, uint8_t *cqe,
                       sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_i_sol_cqe_t *i_sol = (sli4_skh_iscsi_i_sol_cqe_t *)cqe;
    uint8_t status = 0;
    uint8_t response = 0;

    fields->ctype = SLI_CQENTRY_INI_IO;

    if (i_sol->is_sts_or_rsp) {
        status = i_sol->status_or_response;
    } else {
        response = i_sol->status_or_response;
    }

    fields->msg.isol.residual_cnt =
        (i_sol->code == SLI_STATUS_SOL_CMD_CMPL_NORMAL &&
         (i_sol->underrun | i_sol->overrun) ? i_sol->residual : 0);
    fields->msg.isol.exp_cmdsn    = i_sol->expcmdsn;
    fields->msg.isol.cid          = i_sol->cid;
    fields->msg.isol.hw_status    = i_sol->hw_sts;
    fields->msg.isol.status       = status;
    fields->msg.isol.response     = response;
    //@@@TODO: flags replaced with under-run and over-run ??
    //fields->msg.isol.flags      = i_sol->flags;
    fields->msg.isol.flags        = ((i_sol->underrun << 1) |
                     (i_sol->overrun));
    fields->msg.isol.wqe_index    = i_sol->wqe_index;
    fields->msg.isol.cmd_window   = i_sol->cmd_window;
    fields->msg.isol.code         = i_sol->code;

    if (i_sol->code != ISCSI_CQE_CODE_NORMAL &&
        i_sol->code != ISCSI_CQE_CODE_RESIDUAL_OVERRUN &&
        i_sol->code != ISCSI_CQE_CODE_RESIDUAL_UNDERRUN) {
        ocs_log_test(sli4->os, "WQ Error: status 0x%02x\n", i_sol->code);
        ocs_dump32(OCS_DEBUG_ALWAYS, sli4->os, "cqe", cqe,
               sizeof(sli4_skh_iscsi_i_sol_cqe_t));
    }
    i_sol->valid = 0;
    return 0;
}

/**
 * @brief Write an QWE entry to the queue object.
 *
 * @param sli4 SLI context.
 * @param q Pointer to queue object.
 * @param entry Pointer to entry contents.
 * @param io Pointer to the IO object.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_queue_iscsi_wq_write(sli4_t *sli4, sli4_queue_t *q, uint8_t *entry,
                 void *io)
{
    int32_t     rc = 0;
    ocs_hal_io_t *hal_io = (ocs_hal_io_t*)io;
    sli4_skh_wqe_unassisted_t *wqe = (void*)entry;
    sli4_skh_wqe_unassisted_t *last_wqe_posted;
    sli4_wqe_context_t *ctx;
    uint32_t    val = 0;

    ocs_assert(hal_io, -1);
    ocs_lock(&q->lock);

    /* grab a free entry to see what is open */
    ctx = ocs_list_get_head(&q->u.wq.wqe_free);
    if (NULL != ctx) {
        ocs_list_remove_head(&q->u.wq.wqe_free);
        ocs_list_add_tail(&q->u.wq.wqe_busy, ctx);
        q->u.wq.wqe_free_cnt--;

        last_wqe_posted = q->u.wq.last_wqe_posted;
        hal_io->wq_ctx = ctx;
        ctx->io = io;
        ctx->tcp_ack_status = SLI_STATUS_TCP_ACK_NOTIFY;

        /* Set the tcp ACK flag as required for this WQE */
        ctx->wait_tcp_ack = wqe->dm;

        /*
         * Note: For target STS WQE, set the TTT based on the WRB index and
         * the icd index.
         *
         * Format the TTT generated by iSCSI target
         * |-- WRB-idx (16b) --|-- zero (4b) --|-- SGL-ICD-idx (12b) --|
         */
        if (wqe->type == SLI4_WQE_TGT_STS) {
            uint32_t *dword = hal_io->bhs.virt;

            hal_io->ttt = (((uint32_t)ctx->wrb_index) << 16) | hal_io->icd;
            dword[5] = ocs_htobe32(hal_io->ttt);
        } else if (wqe->type == SLI4_WQE_INI_WRITE ||
               wqe->type == SLI4_WQE_INI_TMF   ||
               wqe->type == SLI4_WQE_INI_READ) {
            uint32_t *dword = hal_io->bhs.virt;

            hal_io->itt = (((uint32_t)ctx->wrb_index) << 16) | hal_io->icd;
            dword[4] = ocs_htobe32(hal_io->itt);
        } else if (wqe->type == SLI4_WQE_UNASSISTED) {
            ocs_cxn_t *node = hal_io->node;
            ocs_dma_t *dma  = &node->login_hdr_mem;

            /* TODO: Unclean fix but works for now:
             * In the case of TMF response io->arg is io, so just
             * ignore lgn_mem manipulation or setting itt/cmdsn in
             * this case.
             */
            if (dma->virt != NULL) {
                uint8_t *byte   = dma->virt;
                uint32_t *dword = dma->virt;

                /* Only update the initiator NOOP/logout PDUs */
                if ((byte[0] & 0x6F) == ISCSI_CMD_LOGOUT ||
                    (byte[0] & 0x6F) == ISCSI_CMD_NOOP) {
                    if (dword[4] != 0xFFFFFFFF) {
                        hal_io->itt = (((uint32_t)ctx->wrb_index) << 16) | hal_io->icd;
                        dword[4] = ocs_htobe32(hal_io->itt);
                    }
                }
            }
        }

        /* Update wrb_index and next pointer */
        wqe->wrb_index = ctx->wrb_index;
        wqe->next_wqe  = ctx->wrb_index;
        if (last_wqe_posted != NULL) {
            last_wqe_posted->next_wqe = ctx->wrb_index;
        }

#if defined(OCS_INCLUDE_DEBUG)
        {
            char desc[32];

            snprintf(desc, sizeof(desc), "%s entry %d", q->name, ctx->wrb_index);

            ocs_dump32(OCS_DEBUG_ENABLE_WQ_DUMP, sli4->os, desc, entry, q->size);
        }
#endif
        ocs_memcpy(ctx->qe, entry, q->size);
        q->index = ctx->wrb_index; /* Needed for dump_queue */
        q->n_posted = 1;
        q->u.wq.last_wqe_posted = ctx->qe;

        ocs_dma_sync(&q->dma, OCS_DMASYNC_PREWRITE);

        val = SLI4_WQ_DOORBELL(q->n_posted, ctx->wrb_index, q->id);
        ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
        q->db_ring_cnt++;
        q->n_posted = 0;
    } else {
        rc = -1;
    }

    ocs_unlock(&q->lock);

    return rc;
}

/**
 * @brief Writes a 1 to the invalidate bit of the WQE.
 *
 * @param sli4 SLI context.
 * @param q Pointer to the queue object.
 * @param io Pointer to the IO object.
 * @param is_for_tm TRUE if the IO is being aborted for task management,
 *                  otherwise FALSE.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_skh_queue_iscsi_wqe_invalidate(sli4_t *sli4, sli4_queue_t *q, void *io,
                   uint8_t is_for_tm)
{
    int32_t     rc = -1;
    sli4_skh_wqe_unassisted_t *wqe;
    sli4_wqe_context_t *ctx;

    /* No clean way to do this excpet to walk the active WQEs */
    ocs_lock(&q->lock);
    ctx = ocs_list_get_head(&q->u.wq.wqe_busy);
    while (NULL != ctx) {
        if (ctx->io == io) {
            wqe = (sli4_skh_wqe_unassisted_t *)ctx->qe;
            wqe->inv = 1;
            rc = 0;

            /*
             * If this is for Task management, then we must wait
             * for the TCP_ACK before issuing a completion for this
             * io, otherwise the FW may still be using it.
             */
            ctx->tcp_ack_status = SLI_STATUS_HOST_CMD_INVALID_NOTIFY;
            ctx->wait_tcp_ack = is_for_tm;
            break;
        }
        ctx = ocs_list_next(&q->u.wq.wqe_busy, ctx);
    }

    ocs_unlock(&q->lock);

    return rc;
}

/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_t_sol(sli4_t *sli4, uint8_t *cqe,
                       sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_t_sol_cqe_t *t_sol = (sli4_skh_iscsi_t_sol_cqe_t *)cqe;

    fields->ctype = SLI_CQENTRY_TGT_IO;

    fields->msg.tsol.hw_status = t_sol->hw_sts;
    fields->msg.tsol.cid       = t_sol->cid;
    fields->msg.tsol.wqe_index = t_sol->wqe_index;
    fields->msg.tsol.code      = t_sol->code;

    if (t_sol->code != ISCSI_CQE_CODE_NORMAL) {
        ocs_log_test(sli4->os, "WQ Error: status 0x%02x\n", t_sol->code);
        ocs_dump32(OCS_DEBUG_ALWAYS, sli4->os, "cqe", cqe,
               sizeof(sli4_skh_iscsi_t_sol_cqe_t));
    }
    t_sol->valid = 0;
    return 0;
}

/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_t_sol_data_digest(sli4_t *sli4, uint8_t *cqe,
                         sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_t_sol_data_digest_cqe_t * msg = (void*)cqe;
    sli4_qentry_fields_data_digest_t *digest = &fields->msg.data_digest;

    fields->ctype = SLI_CQENTRY_TGT_DATA_DIGEST;

    digest->buffer_offset   = msg->buffer_offset;
    digest->exp_statsn  = msg->exp_statsn;
    digest->cid     = msg->cid;
    digest->datasn      = msg->datasn;
    digest->fin     = msg->fin;
    digest->data_seg_length = msg->data_seg_len;
    digest->icd_index   = msg->sgl_icd_index;

    ocs_log_test(sli4->os, "WQ Error: status 0x%02x\n", msg->code);
    ocs_dump32(OCS_DEBUG_ALWAYS, sli4->os, "cqe", cqe,
           sizeof(sli4_skh_iscsi_t_sol_data_digest_cqe_t));
    msg->valid = 0;
    return 0;
}


/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_t_cnxinv(sli4_t *sli4, uint8_t *cqe,
                      sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_t_cnxinv_cqe_t   *msg = (void*)cqe;
    sli4_qentry_fields_cnxinv_t *cnxinv = &fields->msg.cnxinv;

    fields->ctype = SLI_CQENTRY_CNX_INVALID;

    cnxinv->addr_high       = msg->def_buf_addr_high;
    cnxinv->addr_low        = msg->def_buf_addr_low;
    cnxinv->partial_data_length = msg->partial_dsl;
    cnxinv->cid         = msg->cid;
    cnxinv->rq_index        = msg->rq_index;
    cnxinv->code            = msg->code;

    /* Mask normal things or the DVT group gets excited */
    if (cnxinv->code != ISCSI_CQE_CODE_TCP_RECV_FIN &&
        cnxinv->code != ISCSI_CQE_CODE_TCP_RECV_RST &&
        cnxinv->code != ISCSI_CQE_CODE_HOST_CXN_INVALIDATION &&
        cnxinv->code != ISCSI_CQE_CODE_HOST_CXN_INVL_WITH_PDU) {
        ocs_log_test(sli4->os, "WQ Error: status 0x%02x\n", msg->code);
        ocs_dump32(OCS_DEBUG_ALWAYS, sli4->os, "cqe", cqe,
               sizeof(sli4_skh_iscsi_t_cnxinv_cqe_t));
    }
    msg->valid = 0;
    return 0;
}


/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_t_cmdinv(sli4_t *sli4, uint8_t *cqe,
                      sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_t_cmndinv_cqe_t   *msg = (void*)cqe;
    sli4_qentry_fields_tcmdinv_t *cmdinv = &fields->msg.tcmdinv;

    fields->ctype = SLI_CQENTRY_TGT_CMD_INVALID;

    cmdinv->cid   = msg->cid;
    cmdinv->icd_index = msg->sgl_icd_index;
    cmdinv->code      = msg->code;

    ocs_log_test(sli4->os, "WQ Error: status 0x%02x\n", msg->code);
    ocs_dump32(OCS_DEBUG_ALWAYS, sli4->os, "cqe", cqe,
           sizeof(sli4_skh_iscsi_t_cmndinv_cqe_t));
    msg->valid = 0;
    return 0;
}


/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_i_t_dpdu(sli4_t *sli4, uint8_t *cqe,
                      sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_i_t_dpdu_cqe_t *msg = (void*)cqe;
    sli4_qentry_fields_dpdu_t *dpdu = &fields->msg.dpdu;

    fields->ctype     = SLI_CQENTRY_RQ;
    dpdu->code    = msg->code;
    dpdu->addr_high   = msg->def_buf_addr_high;
    dpdu->addr_low    = msg->def_buf_addr_low;
    dpdu->data_length = msg->data_length;
    dpdu->cid     = msg->cid;
    dpdu->rq_index    = msg->rq_index;
    dpdu->final   = msg->fin;

    return 0;
}


/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_i_t_dmsg(sli4_t *sli4, uint8_t *cqe,
                      sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_i_t_dmsg_cqe_t *msg  = (void*)cqe;
    sli4_qentry_fields_dmsg_t *dmsg = &fields->msg.dmsg;

    fields->ctype = SLI_CQENTRY_TCP_ACK;

    dmsg->cid   = msg->cid;
    dmsg->wqe_index = msg->wqe_index;
    dmsg->code  = msg->code;

    return 0;
}

/**
 * @brief Parse an iSCSI work queue CQ entry.
 *
 * @param sli4 SLI context.
 * @param cqe Pointer to the CQ entry.
 * @param fields Returns the fields embedded in the CQ entry.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t sli_skh_iscsi_cqe_tx_dif_error(sli4_t *sli4, uint8_t *cqe,
                          sli4_qentry_fields_t *fields)
{
    sli4_skh_iscsi_tx_dif_error_cqe_t *msg  = (void*)cqe;
    sli4_qentry_fields_tx_dif_error_t *dif_err = &fields->msg.tx_dif_err;

    fields->ctype = SLI_CQENTRY_TX_DIF_ERROR;

    dif_err->dif_error = msg->dif_error;
    dif_err->icd_index = msg->icd_index;
    dif_err->cid = msg->cid;

    return 0;
}

/**
 * @brief Write a COMMON_GET_SLI4_PARAMETERS command to the provided buffer.
 *
 * @param sli4 SLI context pointer.
 * @param buf Virtual pointer to the destination buffer.
 * @param size Buffer size in bytes.
 *
 * @return Number of bytes written.
 */
static int32_t
sli_skh_cmd_common_get_sli4_parameters(sli4_t *sli4, void *buf, size_t size)
{
    sli4_skh_req_common_get_sli4_parameters_t *req;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

    /* Payload length must accomodate both request and response */
    payload_size = max(sizeof(sli4_skh_req_common_get_sli4_parameters_t),
               sizeof(sli4_skh_res_common_get_sli4_parameters_t));

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, 0,
                          payload_size,
                          NULL);

    req = (sli4_skh_req_common_get_sli4_parameters_t*)((uint8_t*)buf + cmd_off);
    req->hdr.opcode         = SLI4_OPC_COMMON_GET_SLI4_PARAMETERS;
    req->hdr.subsystem      = SLI4_SUBSYSTEM_COMMON;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    return cmd_off + sizeof(sli4_skh_req_common_get_sli4_parameters_t);
}


/**
 * @brief Issue the GET_SLI4_PARAMETERS IOCTL and populate the results.
 *
 * @param sli4 SLI context.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
int32_t
sli_skh_get_sli4_parameters(sli4_t *sli4)
{
    if (sli_skh_cmd_common_get_sli4_parameters(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
        sli4_skh_res_common_get_sli4_parameters_t *parms =
            (sli4_skh_res_common_get_sli4_parameters_t *)
            (((uint8_t *)sli4->bmbx.virt) + sizeof(sli4_mqe_hdr_t));

        if (sli_bmbx_command(sli4)) {
            ocs_log_crit(sli4->os, "bootstrap mailbox write fail (GET_SLI4_PARAMETERS)\n");
            return -1;
        }
        if (parms->hdr.status) {
            ocs_log_test(sli4->os, "COMMON_GET_SLI4_PARAMETERS bad status %#x\n",
                parms->hdr.status);
            return -1;
        }

        sli4->config.max_qentries[SLI_QTYPE_EQ] = sli_convert_mask_to_count(parms->eqe_count_method,
                parms->eqe_count_mask);

        sli4->config.max_qentries[SLI_QTYPE_CQ] = sli_convert_mask_to_count(parms->cqe_count_method,
                parms->cqe_count_mask);

        sli4->config.max_qentries[SLI_QTYPE_MQ] = sli_convert_mask_to_count(parms->mqe_count_method,
                parms->mqe_count_mask);

        sli4->config.max_qentries[SLI_QTYPE_WQ] = sli_convert_mask_to_count(parms->wqe_count_method,
                parms->wqe_count_mask);

        sli4->config.max_qentries[SLI_QTYPE_RQ] = sli_convert_mask_to_count(parms->rqe_count_method,
                parms->rqe_count_mask);

        sli4->config.sge_supported_length = parms->sge_supported_length;
        sli4->frg_num_field_offset = parms->frg_num_field_offset;
        sli4->frg_num_field_mask   = (1 << parms->frg_num_field_size) - 1;
        sli4->sgl_idx_field_offset = parms->sgl_idx_field_offset;
        sli4->sgl_idx_field_mask   = (1 << parms->sgl_idx_field_size) - 1;
        sli4->chain_sge_init_0     = parms->chain_sge_init_0;
        sli4->chain_sge_init_1     = parms->chain_sge_init_1;
        sli4->features.t10_dif_capable      = parms->t10pi;
        sli4->features.sgl_chaining_capable = parms->sglc;
        sli4->features.t10_dif_inline_capable = parms->timm;
        sli4->features.t10_dif_separate_capable = parms->tsmm;
    } else {
        ocs_log_test(sli4->os, "bad GET_SLI4_PARAMETERS write\n");
        return -1;
    }
    return 0;
}

sli_wqe_handlers_t sli_skh_iscsi_wqe_handlers = {
    .wqe_update_context     = sli_skh_wqe_update_context,
    .wqe_ini_read           = sli_skh_wqe_ini_read,
    .wqe_ini_write          = sli_skh_wqe_ini_write,
    .wqe_ini_nop            = sli_skh_wqe_ini_nop,
    .wqe_ini_tmf            = sli_skh_wqe_ini_tmf,
    .wqe_tgt_datain         = sli_skh_wqe_tgt_datain,
    .wqe_tgt_sts            = sli_skh_wqe_tgt_sts,
    .wqe_tgt_sos            = sli_skh_wqe_tgt_sos,
    .wqe_unassisted         = sli_skh_wqe_unassisted,
    .queue_iscsi_wq_write       = sli_skh_queue_iscsi_wq_write,
    .queue_iscsi_wqe_invalidate = sli_skh_queue_iscsi_wqe_invalidate
};

/* vim: set noexpandtab textwidth=120: */