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

/**
\defgroup sli_be3_iscsi SLI-4 BE3 iSCSI APIs
 */

/**
 * @file
 * Implementation of iSCSI BE3 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_be3_iscsi_cqe_i_sol(sli4_t *, uint8_t *cqe,
                       sli4_qentry_fields_t *fields);
static int32_t sli_be3_iscsi_cqe_t_sol(sli4_t *, uint8_t *cqe,
                       sli4_qentry_fields_t *fields);
static int32_t sli_be3_iscsi_cqe_t_sol_data_digest(sli4_t *, uint8_t *cqe,
                              sli4_qentry_fields_t *fields);
static int32_t sli_be3_iscsi_cqe_t_cnxinv(sli4_t *, uint8_t *cqe,
                          sli4_qentry_fields_t *fields);
static int32_t sli_be3_iscsi_cqe_t_cmdinv(sli4_t *, uint8_t *cqe,
                          sli4_qentry_fields_t *fields);
static int32_t sli_be3_iscsi_cqe_i_t_dpdu(sli4_t *, uint8_t *cqe,
                          sli4_qentry_fields_t *fields);
static int32_t sli_be3_iscsi_cqe_i_t_dmsg(sli4_t *, uint8_t *cqe,
                          sli4_qentry_fields_t *fields);

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


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

/**
 * @ingroup sli_be3_iscsi
 * @brief Write an INITIATOR_WRITE_COMMAND WQE work queue entry.
 *
 * @par Description
 * - sgl[0] - points to 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 number of payload bytes.
 * @param cmdsn The iSCSI cmdsn for the command.
 * @param icd_index ICD index for 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_be3_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_be3_wqe_ini_write_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_INI_WRITE;
    req->lun = lun & 0x3fff;
    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;
    if (dif_info) {
        req->dif_mode = dif_info->dif_oper;
        req->dif_blk_size = dif_info->blk_size;
    }

    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;
    }

    return 0;
}

/**
 * @ingroup sli_be3_iscsi
 * @brief Write an INITIATOR_TMF WQE work queue entry.
 *
 * @par Description
 * - sgl[0] - points to the BHS.
 *
 * @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 cmdsn iSCSI cmdsn for the command.
 * @param icd_index ICD index for 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_be3_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_be3_wqe_ini_tmf_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_INI_TMF;
    req->lun = lun & 0x3fff;
    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;
}


/**
 * @ingroup sli_be3_iscsi
 * @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 The 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 number 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_be3_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_be3_wqe_ini_nop_t * req = buf;

    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;
}

/**
 * @ingroup sli_be3_iscsi
 * @brief Write an INITIATOR_READ WQE work queue entry.
 *
 * @par Description
 * - sgl[0] - points to 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 The LUN value for the command.
 * @param exp_xfer_len Total number of payload bytes.
 * @param cmdsn iSCSI cmdsn for the command.
 * @param icd_index ICD index for 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_be3_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_be3_wqe_ini_read_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_INI_READ;
    req->lun = lun & 0x3fff;
    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) {
        req->dif_mode = dif_info->dif_oper;
        req->dif_blk_size = dif_info->blk_size;
    }

    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;
    }

    return 0;
}

/**
 * @brief Write a 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 Target login options for the connection.
 * @param statsn Status SN for the connection.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_be3_wqe_update_context(sli4_t *sli4, void *buf, size_t size,
               ocs_hal_target_login_options_t *lgn_options,
               uint32_t statsn)
{
    sli4_be3_wqe_context_update_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_CONTEXT_UPDATE;
    req->dm = 1;
    req->max_burst = lgn_options->session_options.max_burst;
    req->max_recv_dsl = lgn_options->max_rcv_dsl;
    req->first_burst = lgn_options->session_options.first_burst;
    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;

    return 0;
}

/**
 * @ingroup sli_be3_iscsi
 * @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 number of payload bytes.
 * @param exp_data_sn Expected data sequence number.
 * @param itt Initiator transfer tag.
 * @param icd_index ICD index for 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_be3_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_be3_wqe_tgt_sts_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_TGT_STS;
    req->lun = lun & 0x3fff;
    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;
    if (dif_info) {
        req->dif_mode = dif_info->dif_oper;
        req->dif_blk_size = dif_info->blk_size;
    }
    req->r2t_offset = r2t_offset;

    return 0;
}

/**
 * @ingroup sli_be3_iscsi
 * @brief Write a 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 The 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 number of payload bytes.
 * @param icd_index ICD index fr 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_be3_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_be3_wqe_tgt_datain_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_TGT_DATAIN;
    req->lun = lun & 0x3fff;
    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;
    if (dif_info) {
        req->dif_mode = dif_info->dif_oper;
        req->dif_blk_size = dif_info->blk_size;
    }

    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 (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;
    }

    return 0;
}

/**
 * @ingroup sli_be3_iscsi
 * @brief Write a 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 The 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 fr this request.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_be3_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_be3_wqe_tgt_sos_t * req = buf;

    ocs_memset(buf, 0, size);

    req->type = SLI4_WQE_TGT_SOS;
    req->lun = lun & 0x3fff;
    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;
}

/**
 * @ingroup sli_be3_iscsi
 * @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 number 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_be3_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_be3_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;
    }

    // TODO:  Revisit this
    /* The following is based on code in be2iscsi.  The HAL layer
     * currently doesn't let us send a WQE with a type of INI_NOP_OUT.
     * The firmware appears to have issues with sending a NOP OUT
     * using a DM_CMD.  The be2iscsi driver sends a NOP OUT as a
     * INI_READ.
     *
     * This code switches a NOP OUT PDU to use a type of INI_READ,
     * as the be2iscsi driver does.  There is probably a better way
     * to do this, but this works for now.
     *
     */
    {
        iscsi_bhs_t *hdr = bhs->virt;

        if (hdr->opcode == ISCSI_CMD_NOOP) {

            // Change the type to a IREAD
            req->type = SLI4_WQE_INI_READ;
            req->dm = 0;
        }

    }
    return 0;
}

/**
 * @ingroup sli_be3_iscsi
 * @brief Write an WQE entry to the queue object.
 *
 * @param sli4 SLI context.
 * @param q Pointer to the queue object.
 * @param entry Pointer to the entry contents.
 * @param io Pointer to the IO object.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
static int32_t
sli_be3_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_be3_wqe_unassisted_t *wqe = (void*)entry;
        sli4_be3_wqe_unassisted_t *last_wqe_posted;
        sli4_wqe_context_t *ctx;
        uint32_t    val = 0;

        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) {

            if (!ctx->wait_tcp_ack) {
                /* DM is false, so we expect to get a I_SOL_CQE when the reply
                 * comes back.  Per the SLI-4 iSCSI Command Reference, section
                 * 2.2.2.3:  "For WQE operations where the response from the target
                 * is processed in a solicited manner by the SLI Port, the ITT
                 * must be set in the following manner:"
                 */
                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);

            }
                }

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

            // For any WQE type other than CONTEXT_UPDATE also dump the BHS
            ocs_swap_and_dump32(OCS_DEBUG_ENABLE_WQ_DUMP, sli4->os, "BHS",
                        hal_io->bhs.virt, sizeof(iscsi_login_cmd_hdr_t));
                }

#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);
                sli_reg_write(sli4, SLI4_REG_IO_WQ_DOORBELL, val);
                q->n_posted = 0;
        } else {
                rc = -1;
                ocs_log_err(sli4->os, "failed to allocate a WQE object\n");
        }

        ocs_unlock(&q->lock);

        return rc;
}

/**
 * @ingroup sli_be3_iscsi
 * @brief Writes a 1 to the invalidate bit of the WQE.
 *
 * @param sli4 SLI context.
 * @param q Pointer to 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_be3_queue_iscsi_wqe_invalidate(sli4_t *sli4, sli4_queue_t *q, void *io,
                   uint8_t is_for_tm)
{
        int32_t     rc = -1;
        sli4_be3_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_be3_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_be3_iscsi_cqe_i_sol(sli4_t *sli4, uint8_t *cqe,
                       sli4_qentry_fields_t *fields)
{
    sli4_be3_iscsi_i_sol_cqe_t *i_sol = (sli4_be3_iscsi_i_sol_cqe_t *)cqe;

    fields->ctype = SLI_CQENTRY_INI_IO;

    fields->msg.isol.residual_cnt =
        ((i_sol->code == ISCSI_CQE_CODE_RESIDUAL_OVERRUN ||
          i_sol->code == ISCSI_CQE_CODE_RESIDUAL_UNDERRUN) ? 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       = i_sol->status;
    fields->msg.isol.response     = i_sol->response;
    fields->msg.isol.flags        = i_sol->flags;
    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 &&
        i_sol->code != ISCSI_CQE_CODE_TCP_RECV_FIN) {
        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_be3_iscsi_i_sol_cqe_t));
    }
    i_sol->valid = 0;
    return 0;
}

/**
 * @brief Parse a 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_be3_iscsi_cqe_t_sol(sli4_t *sli4, uint8_t *cqe,
                       sli4_qentry_fields_t *fields)
{
    sli4_be3_iscsi_t_sol_cqe_t *t_sol = (sli4_be3_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_be3_iscsi_t_sol_cqe_t));
    }
    t_sol->valid = 0;
    return 0;
}

/**
 * @brief Parse a 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_be3_iscsi_cqe_t_sol_data_digest(sli4_t *sli4, uint8_t *cqe,
                               sli4_qentry_fields_t *fields)
{
    sli4_be3_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_be3_iscsi_t_sol_data_digest_cqe_t));
    msg->valid = 0;
    return 0;
}


/**
 * @brief Parse a 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_be3_iscsi_cqe_t_cnxinv(sli4_t *sli4, uint8_t *cqe,
                          sli4_qentry_fields_t *fields)
{
    sli4_be3_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_be3_iscsi_t_cnxinv_cqe_t));
    }
    msg->valid = 0;
    return 0;
}


/**
 * @brief Parse a 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_be3_iscsi_cqe_t_cmdinv(sli4_t *sli4, uint8_t *cqe,
                          sli4_qentry_fields_t *fields)
{
    sli4_be3_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_be3_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_be3_iscsi_cqe_i_t_dpdu(sli4_t *sli4, uint8_t *cqe,
                          sli4_qentry_fields_t *fields)
{
    sli4_be3_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 a 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_be3_iscsi_cqe_i_t_dmsg(sli4_t *sli4, uint8_t *cqe,
                          sli4_qentry_fields_t *fields)
{
    sli4_be3_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 Note: GET_SLI4_PARAMETERS IOCTL is not supported on BE3, so we just
 *              return constant values.
 *
 * @param sli4 SLI context.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
int32_t
sli_be3_get_sli4_parameters(sli4_t *sli4)
{
    sli4->config.max_qentries[SLI_QTYPE_EQ] = 1024;
    sli4->config.max_qentries[SLI_QTYPE_CQ] = 1024;
    sli4->config.max_qentries[SLI_QTYPE_MQ] = 128;
    sli4->config.max_qentries[SLI_QTYPE_WQ] = 128;
    sli4->config.max_qentries[SLI_QTYPE_RQ] = 512;
    sli4->config.sge_supported_length       = 65536;

    return 0;
}

sli_wqe_handlers_t sli_be3_iscsi_wqe_handlers = {
        .wqe_update_context         = sli_be3_wqe_update_context,
        .wqe_ini_read               = sli_be3_wqe_ini_read,
        .wqe_ini_write              = sli_be3_wqe_ini_write,
        .wqe_ini_nop                = sli_be3_wqe_ini_nop,
        .wqe_ini_tmf                = sli_be3_wqe_ini_tmf,
        .wqe_tgt_datain             = sli_be3_wqe_tgt_datain,
        .wqe_tgt_sts                = sli_be3_wqe_tgt_sts,
        .wqe_tgt_sos                = sli_be3_wqe_tgt_sos,
        .wqe_unassisted             = sli_be3_wqe_unassisted,
        .queue_iscsi_wq_write       = sli_be3_queue_iscsi_wq_write,
        .queue_iscsi_wqe_invalidate = sli_be3_queue_iscsi_wqe_invalidate
};

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