sli4_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_iscsi SLI-4 iSCSI APIs
 */

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

#include "ocs_os.h"
#include "ocs_hal.h"
#include "sli4_iscsi.h"

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

extern const char *SLI_QNAME[];

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_IFACE_CREATE command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param vlan The vlan/priority
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_iface_create(sli4_t *sli4, void *buf,
                  size_t size, uint64_t tag, uint32_t vlan)
{
    sli4_req_common_iscsi_ntwk_iface_create_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_iface_create_t*)((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_IFACE_CREATE;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->vlan = vlan;

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_iface_create_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_IFACE_CREATE command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param iface the portal interface handle
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_iface_delete(sli4_t *sli4, void *buf,
                  size_t size, uint64_t tag, uint32_t iface)
{
    sli4_req_common_iscsi_ntwk_iface_delete_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_iface_delete_t*)((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_IFACE_DELETE;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->iface = iface;

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_iface_create_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_CONFIGURE_STATELESS_IP_ADDR command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param iface the portal interface handle
 * @param isv4 set to non-zero for IPv4, otherwise IPv6
 * @param retries the number of retry attempts
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_configure_stateless_ip_addr(sli4_t *sli4, void *buf,
                         size_t size, uint64_t tag,
                         uint32_t iface, uint8_t isv4,
                         uint32_t retries)
{
    sli4_req_common_iscsi_ntwk_configure_stateless_ip_addr_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_configure_stateless_ip_addr_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_CONFIGURE_STATELESS_IP_ADDR;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->iface = iface;
    req->ip_type = (isv4 ? 0x01 : 0x10);
    req->flags   = 0x02; /* non-blocking, do not save in flash */
    req->retry_count = retries;

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_configure_stateless_ip_addr_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_RELEASE_STATELESS_IP_ADDR command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param iface the portal interface handle
 * @param isv4 set to non-zero for IPv4, otherwise IPv6
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_release_stateless_ip_addr(sli4_t *sli4, void *buf,
                           size_t size, uint64_t tag,
                           uint32_t iface, uint8_t isv4)
{
    sli4_req_common_iscsi_ntwk_release_stateless_ip_addr_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_release_stateless_ip_addr_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_RELEASE_STATELESS_IP_ADDR;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->iface = iface;
    req->ip_type = (isv4 ? 0x01 : 0x10);

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_release_stateless_ip_addr_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_DISCOVER_ISNS_SERVER command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param iface the portal interface handle
 * @param retries the number of retry attempts
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_discover_isns_server(sli4_t *sli4, void *buf,
                      size_t size, uint64_t tag,
                      uint32_t iface, uint32_t retries)
{
    sli4_req_common_iscsi_ntwk_discover_isns_server_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_discover_isns_server_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_DISCOVER_ISNS_SERVER;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->iface = iface;
    req->retry_count = retries;
    req->flags = 0x02; /* non-blocking, do not save in flash */

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_discover_isns_server_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_DISCOVERED_ISNS_SERVERS command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param iface the portal interface handle
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_discovered_isns_servers(sli4_t *sli4, void *buf,
                         size_t size, uint64_t tag,
                         uint32_t iface)
{
    sli4_req_common_iscsi_ntwk_discovered_isns_servers_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_discovered_isns_servers_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_DISCOVERED_ISNS_SERVERS;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->iface = iface;

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_discover_isns_server_t));
}


/**
 * @ingroup sli_iscsi
 * @brief Converts the IP address type field to the SLI4 equivalent value.
 *
 * @param ip_type the HAL enum to convert.
 *
 * @return the SLI4 IP type
 */
uint8_t
sli_iscsi_conv_hal_ip_addr_type(ocs_hal_ip_type_e ip_type)
{
    uint8_t rval = 0;
    switch(ip_type) {
    case OCS_HAL_IP_TYPE_V4:
        rval = 1;
        break;
    case OCS_HAL_IP_TYPE_DHCP_V4:
        rval = 5;
        break;
    case OCS_HAL_IP_TYPE_V6:
        rval = 0x10;
        break;
    case OCS_HAL_IP_TYPE_AUTO_V6:
        rval = 0x90;
        break;
    case OCS_HAL_IP_TYPE_ROUTABLE_V6:
        rval = 0x30;
        break;
    case OCS_HAL_IP_TYPE_LINK_LOCAL_V6:
        rval = 0x50;
        break;
    default:
        break;
    }
    return rval;
}

/**
 * @ingroup sli_iscsi
 * @brief Converts the SLI4 IP address type field to the HAL equivalent value.
 *
 * @param ip_type the SLI4 value to convert.
 *
 * @return The HAL IP type
 */
ocs_hal_ip_type_e
sli_iscsi_conv_sli4_ip_addr_type(uint8_t ip_type)
{
    ocs_hal_ip_type_e rval = 0;
    switch(ip_type) {
    case 0x01:
    case 0x03:
        rval = OCS_HAL_IP_TYPE_V4;
        break;
    case 0x05:
        rval = OCS_HAL_IP_TYPE_DHCP_V4;
        break;
    case 0x10:
        rval = OCS_HAL_IP_TYPE_V6;
        break;
    case 0x30:
        rval = OCS_HAL_IP_TYPE_ROUTABLE_V6;
        break;
    case 0x50:
        rval = OCS_HAL_IP_TYPE_LINK_LOCAL_V6;
        break;
    case 0x90:
        rval = OCS_HAL_IP_TYPE_AUTO_V6;
        break;
    default:
        break;
    }
    return rval;
}

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_SET_ROUTE_TABLE command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param isadd set to non-zero for adding, otherwise removing
 * @param ip_sub the IP address and subnet to add/remove
 * @param gateway the IP address of the gateway to add/remove
 *
 * @return number of bytes written
 */
int32_t sli_cmd_iscsi_common_set_route_table(sli4_t *sli4, void *buf, size_t size,
                         uint64_t tag, uint8_t isadd,
                         ocs_hal_ip_address_subnet_t *hal_ipsub,
                         ocs_hal_ip_address_t *hal_gateway,
                         ocs_dma_t *dma)
{
    sli4_req_common_iscsi_ntwk_set_route_table_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;
    
    payload_size = dma->size;

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size, dma);
    req = (sli4_req_common_iscsi_ntwk_set_route_table_t *)dma->virt;

    ocs_memset(req, 0, sizeof(sli4_req_common_iscsi_ntwk_set_route_table_t));
    req->hdr.opcode = SLI4_OPC_ISCSI_NTWK_SET_ROUTE_TABLE;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->entry_type = (isadd ? SLI4_ISCSI_ROUTE_TABLE_ENTRY_ADD : SLI4_ISCSI_ROUTE_TABLE_ENTRY_DEL);
    req->entry[0].ip_sub.struct_size = sizeof(sli4_ip_addr_subnet_t);
    req->entry[0].ip_sub.ip_type = sli_iscsi_conv_hal_ip_addr_type(hal_ipsub->ip_type);
    ocs_memcpy(req->entry[0].ip_sub.ip_addr, hal_ipsub->ip_address, 16);
    ocs_memcpy(req->entry[0].ip_sub.subnet, hal_ipsub->subnet, 16);
    req->entry[0].gateway.struct_size = sizeof(sli4_ip_addr_t);
    req->entry[0].gateway.ip_type = sli_iscsi_conv_hal_ip_addr_type(hal_gateway->ip_type);
    ocs_memcpy(req->entry[0].gateway.ip_addr, hal_gateway->ip_address, 16);

    return (cmd_off + sizeof(sli4_req_common_iscsi_ntwk_set_route_table_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_GET_ROUTE_TABLE command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 *
 * @return number of bytes written
 */
int32_t sli_cmd_iscsi_common_get_route_table(sli4_t *sli4, void *buf, size_t size,
                         uint64_t tag, ocs_dma_t *dma)
{
    sli4_req_common_iscsi_ntwk_set_route_table_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;
    
    payload_size = dma->size;

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size, dma);
    req = (sli4_req_common_iscsi_ntwk_set_route_table_t *)dma->virt;

    ocs_memset(req, 0, sizeof(sli4_req_common_iscsi_ntwk_set_route_table_t));
    req->hdr.opcode = SLI4_OPC_ISCSI_NTWK_GET_ROUTE_TABLE;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);

    return (cmd_off + sizeof(sli4_req_common_iscsi_ntwk_set_route_table_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_MODIFY_IP_ADDR command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param iface the portal interface handle
 * @param isadd set to non-zero for adding an address, otherwise removing
 * @param ipaddr the IP address and subnet mask
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_modify_ip_addr(sli4_t *sli4, void *buf,
                    size_t size, uint64_t tag,
                    uint32_t iface, uint8_t isadd,
                    ocs_hal_ip_address_subnet_t *ipaddr)
{
    sli4_req_common_iscsi_ntwk_modify_ip_addr_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_modify_ip_addr_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_MODIFY_IP_ADDR;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->record_count = 1;
    req->action = (isadd ? 1 : 2);
    req->iface = iface;
    req->ip_addr_subnet.struct_size = 40;
    req->ip_addr_subnet.ip_type = sli_iscsi_conv_hal_ip_addr_type(ipaddr->ip_type);
    ocs_memcpy(req->ip_addr_subnet.ip_addr, ipaddr->ip_address, 16);
    ocs_memcpy(req->ip_addr_subnet.subnet, ipaddr->subnet, 16);

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_modify_ip_addr_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param isv4 set to non-zero for IPv4, otherwise IPv6
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_get_default_gateway(sli4_t *sli4, void *buf,
                     size_t size, uint64_t tag,
                     uint8_t isv4)
{
    sli4_req_common_iscsi_ntwk_get_default_gateway_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_get_default_gateway_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_GET_DEFAULT_GATEWAY;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->ip_type = (isv4 ? 0x01 : 0x10);

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_get_default_gateway_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param isadd set to non-zero for adding, otherwise removing
 * @param gateway the IP address of the gateway to add/remove
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_modify_default_gateway(sli4_t *sli4, void *buf,
                        size_t size, uint64_t tag,
                        uint8_t isadd,
                        ocs_hal_ip_address_t *gateway)
{
    sli4_req_common_iscsi_ntwk_modify_default_gateway_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_common_iscsi_ntwk_modify_default_gateway_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->action = (isadd ? 1 : 2);
    req->gateway.struct_size = 24;
    req->gateway.ip_type = sli_iscsi_conv_hal_ip_addr_type(gateway->ip_type);
    ocs_memcpy(req->gateway.ip_addr, gateway->ip_address, 16);

    return(cmd_off + sizeof(sli4_req_common_iscsi_ntwk_modify_default_gateway_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_GET_ALL_IF_ID command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 *
 * @return number of bytes written
 */
int32_t sli_cmd_iscsi_common_get_all_if_id(sli4_t *sli4, void *buf,
                       size_t size, uint64_t tag)
{
    sli4_req_iscsi_ntwk_get_all_if_id_t  *req = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_ntwk_get_all_if_id_t*)((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_GET_ALL_IF_ID;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);

    return(cmd_off + sizeof(sli4_req_iscsi_ntwk_get_all_if_id_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_NTWK_GET_IF_INFO command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param iface the interface handle to retrieve information
 * @param isv4 set to non-zero for IPv4, otherwise IPv6
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_common_get_if_info(sli4_t *sli4, void *buf,
                 size_t size, uint64_t tag,
                 uint32_t iface, uint8_t isv4)
{
    sli4_req_iscsi_ntwk_get_if_info_t  *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_ntwk_get_if_info_t*)((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_NTWK_GET_IF_INFO;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->iface = iface;
    req->ip_type = (isv4 ? 0x01 : 0x10);

    return(cmd_off + sizeof(sli4_req_iscsi_ntwk_get_if_info_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_CLEANUP (version 0) command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param ulp_no the Chute number TBD
 * @param hdrq_id the receive header queue assigned to this connection
 * @param dataq_id the receive data queue assigned to this connection
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_cleanup_v0(sli4_t *sli4, void *buf,
             size_t size, uint64_t tag,
             uint16_t ulp_no,
             uint8_t  hdrq_id,
             uint8_t  dataq_id)
{
    sli4_req_iscsi_cleanup_v0_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_cleanup_v0_t*)((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_CLEANUP;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->ulp = ulp_no;
    req->hdr_ring_id = hdrq_id;
    req->data_ring_id = dataq_id;

    return(cmd_off + sizeof(sli4_req_iscsi_cleanup_v0_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_CLEANUP (version 1) command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param ulp_no the Chute number TBD
 * @param hdrq_id the receive header queue assigned to this connection
 * @param dataq_id the receive data queue assigned to this connection
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_cleanup_v1(sli4_t *sli4, void *buf,
             size_t size, uint64_t tag,
             uint16_t ulp_no,
             uint16_t  hdrq_id,
             uint16_t  dataq_id)
{
    sli4_req_iscsi_cleanup_v1_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_cleanup_v1_t*)((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_CLEANUP;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->hdr.version = 1;
    req->ulp = ulp_no;
    req->hdr_ring_id = hdrq_id;
    req->data_ring_id = dataq_id;

    return(cmd_off + sizeof(sli4_req_iscsi_cleanup_v1_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_SET_FRAGNUM_BITS command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param num_bits the number of bits for SGEs
 *
 * @return number of bytes written
 */
static int32_t
sli_cmd_iscsi_set_fragnum_bits(sli4_t *sli4, void *buf,
                   size_t size, uint64_t tag,
                   uint32_t num_bits)
{
    sli4_req_iscsi_set_frag_bits_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_set_frag_bits_t*)((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_SET_FRAGNUM_BITS;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->num_bits = num_bits;

    return(cmd_off + sizeof(sli4_req_iscsi_set_frag_bits_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_START_LISTEN_SERVER command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param ipaddr the IP address
 * @param tcp_port the TCP port number
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_start_listen_server(sli4_t *sli4, void *buf,
                      size_t size, uint64_t tag,
                      ocs_hal_ip_address_t *ipaddr,
                      uint32_t tcp_port)
{
    sli4_req_iscsi_tgt_start_listen_server_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_tgt_start_listen_server_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_START_LISTEN_SERVER;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->ipaddr.struct_size = 24;
    req->ipaddr.ip_type = sli_iscsi_conv_hal_ip_addr_type(ipaddr->ip_type);
    ocs_memcpy(req->ipaddr.ip_addr, ipaddr->ip_address, 16);
    req->tcp_port = tcp_port;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_start_listen_server_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_STOP_LISTEN_SERVER command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param ipaddr the IP address
 * @param tcp_port the TCP port number
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_stop_listen_server(sli4_t *sli4, void *buf,
                     size_t size, uint64_t tag,
                     ocs_hal_ip_address_t *ipaddr,
                     uint32_t tcp_port)
{
    sli4_req_iscsi_tgt_stop_listen_server_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_tgt_stop_listen_server_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_STOP_LISTEN_SERVER;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->ipaddr.struct_size = 24;
    req->ipaddr.ip_type = sli_iscsi_conv_hal_ip_addr_type(ipaddr->ip_type);
    ocs_memcpy(req->ipaddr.ip_addr, ipaddr->ip_address, 16);
    req->tcp_port = tcp_port;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_stop_listen_server_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_GET_CONNECTION_INFO command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection handle
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_get_connection_info(sli4_t *sli4, void *buf,
                      size_t size, uint64_t tag,
                      uint32_t conn_hdl)
{
    sli4_req_iscsi_tgt_get_connection_info_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_tgt_get_connection_info_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_GET_CONNECTION_INFO;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->conn_handle = conn_hdl;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_get_connection_info_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_CONNECTION_REJECT command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection ID
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_connection_reject(sli4_t *sli4, void *buf,
                    size_t size, uint64_t tag,
                    uint32_t conn_hdl)
{
    sli4_req_iscsi_tgt_connection_reject_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_tgt_connection_reject_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_CONNECTION_REJECT;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->conn_handle = conn_hdl;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_connection_reject_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_OFFLOAD_CONNECTION command (version 0)
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection handle
 * @param tcp_window_size the TCP window advertised
 * @param ulp_no the Chute number TBD
 * @param wq_id the work queue assigned to this connection
 * @param cq_id the completion queue assigned to this connection
 * @param hdrq_id the receive header queue assigned to this connection
 * @param dataq_id the receive data queue assigned to this connection
 * @param nrs set to 1 if the driver will not free resources on the
 *            invalidate_commands completion and will wait for each IO
 *            completion. (Skyhawk only)
 * @param lgn_options the target login options for the connection
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_offload_connection_v0(sli4_t *sli4, void *buf,
                    size_t size, uint64_t tag,
                    uint32_t conn_hdl,
                    uint32_t tcp_window_size,
                    uint16_t ulp_no,
                    uint16_t wq_id,
                    uint16_t cq_id,
                    uint8_t  hdrq_id,
                    uint8_t  dataq_id,
                    uint8_t  nrs,
                    ocs_hal_target_login_options_t *lgn_options)
{
    sli4_req_iscsi_tgt_offload_connection_v0_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;
    sli4_session_login_options_t *session;
    ocs_session_login_options_t *hal_sess;

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

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

    req = (sli4_req_iscsi_tgt_offload_connection_v0_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_OFFLOAD_CONNECTION;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->conn_handle = conn_hdl;
    req->cid = wq_id;
    req->cq_id = cq_id;
    req->hdr_id = hdrq_id;
    req->data_id = dataq_id;
    req->ulp_number = ulp_no;
    req->tcp_window = tcp_window_size;

    if (sli4->features.tcp_offload_nrs) {
        req->nrs = nrs;
    }

    req->login_options.data_digest = lgn_options->data_digest;
    req->login_options.hdr_digest  = lgn_options->hdr_digest;
    req->login_options.max_rcv_dsl = lgn_options->max_rcv_dsl;

    session = &req->login_options.session_options;
    hal_sess = &lgn_options->session_options;
    session->flags =
        ((hal_sess->initial_r2t ? SLI_LOGIN_FLAG_INITIAL_R2T : 0) |
         (hal_sess->immediate_data ? SLI_LOGIN_FLAG_IMMEDIATE_DATA : 0) |
         (hal_sess->data_pdu_in_order ? SLI_LOGIN_FLAG_DATA_PDU_IN_ORDER : 0) |
         (hal_sess->data_sequence_in_order ? SLI_LOGIN_FLAG_DATA_SEQUENCE_IN_ORDER : 0));

    session->error_recovery_level = hal_sess->error_recovery_level;
    session->first_burst = hal_sess->first_burst;
    session->max_burst = hal_sess->max_burst;
    session->max_connections = hal_sess->max_connections;
    session->max_r2t = hal_sess->max_r2t;
    session->def_time_to_wait = hal_sess->def_time_to_wait;
    session->def_time_to_retain = hal_sess->def_time_to_retain;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_offload_connection_v0_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_OFFLOAD_CONNECTION command (version 1)
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection handle
 * @param tcp_window_size the TCP window advertised
 * @param ulp_no the Chute number TBD
 * @param wq_id the work queue assigned to this connection
 * @param cq_id the completion queue assigned to this connection
 * @param hdrq_id the receive header queue assigned to this connection
 * @param dataq_id the receive data queue assigned to this connection
 * @param nrs set to 1 if the driver will not free resources on the
 *            invalidate_commands completion and will wait for each IO
 *            completion. (Skyhawk only)
 * @param lgn_options the target login options for the connection
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_offload_connection_v1(sli4_t *sli4, void *buf,
                    size_t size, uint64_t tag,
                    uint32_t conn_hdl,
                    uint32_t tcp_window_size,
                    uint16_t ulp_no,
                    uint16_t wq_id,
                    uint16_t cq_id,
                    uint16_t hdrq_id,
                    uint16_t dataq_id,
                    uint8_t  nrs,
                    ocs_hal_target_login_options_t *lgn_options)
{
    sli4_req_iscsi_tgt_offload_connection_v1_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;
    sli4_session_login_options_t *session;
    ocs_session_login_options_t *hal_sess;

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

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

    req = (sli4_req_iscsi_tgt_offload_connection_v1_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_OFFLOAD_CONNECTION;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->hdr.version = 1;
    req->conn_handle = conn_hdl;
    req->cid = wq_id;
    req->cq_id = cq_id;
    req->hdr_id = hdrq_id;
    req->data_id = dataq_id;
    req->ulp_number = ulp_no;
    req->tcp_window = tcp_window_size;

    if (sli4->features.tcp_offload_nrs) {
        req->nrs = nrs;
    }

    req->login_options.data_digest = lgn_options->data_digest;
    req->login_options.hdr_digest  = lgn_options->hdr_digest;
    req->login_options.max_rcv_dsl = lgn_options->max_rcv_dsl;

    session = &req->login_options.session_options;
    hal_sess = &lgn_options->session_options;
    session->flags =
        ((hal_sess->initial_r2t ? SLI_LOGIN_FLAG_INITIAL_R2T : 0) |
         (hal_sess->immediate_data ? SLI_LOGIN_FLAG_IMMEDIATE_DATA : 0) |
         (hal_sess->data_pdu_in_order ? SLI_LOGIN_FLAG_DATA_PDU_IN_ORDER : 0) |
         (hal_sess->data_sequence_in_order ? SLI_LOGIN_FLAG_DATA_SEQUENCE_IN_ORDER : 0));

    session->error_recovery_level = hal_sess->error_recovery_level;
    session->first_burst = hal_sess->first_burst;
    session->max_burst = hal_sess->max_burst;
    session->max_connections = hal_sess->max_connections;
    session->max_r2t = hal_sess->max_r2t;
    session->def_time_to_wait = hal_sess->def_time_to_wait;
    session->def_time_to_retain = hal_sess->def_time_to_retain;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_offload_connection_v1_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_INVALIDATE_CONNECTION command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection ID
 * @param cid the wq_id assigned with the connection
 * @param sendRst non-zero sends a TCP reset on the connection.
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_invalidate_connection(sli4_t *sli4, void *buf,
                    size_t size, uint64_t tag,
                    uint32_t conn_hdl,
                    uint16_t cid,
                    uint8_t  sendRst)
{
    sli4_req_iscsi_tgt_invalidate_connection_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_tgt_invalidate_connection_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_INVALIDATE_CONNECTION;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->conn_handle = conn_hdl;
    req->cid = cid;
    req->cleanup_type = (sendRst ? 2 : 1);

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_invalidate_connection_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_START_ESI_LISTEN command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param ipaddr the IP address
 * @param tcp_port the TCP port number
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_start_esi_listen(sli4_t *sli4, void *buf,
                   size_t size, uint64_t tag,
                   ocs_hal_ip_address_t *ipaddr,
                   uint32_t tcp_port)
{
    sli4_req_iscsi_tgt_start_esi_listen_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_tgt_start_esi_listen_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_START_ESI_LISTEN;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->ipaddr.struct_size = 24;
    req->ipaddr.ip_type = sli_iscsi_conv_hal_ip_addr_type(ipaddr->ip_type);
    ocs_memcpy(req->ipaddr.ip_addr, ipaddr->ip_address, 16);
    req->tcp_port = tcp_port;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_start_esi_listen_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_STOP_ESI_LISTEN command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param ipaddr the IP address
 * @param tcp_port the TCP port number
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_stop_esi_listen(sli4_t *sli4, void *buf,
                  size_t size, uint64_t tag,
                  ocs_hal_ip_address_t *ipaddr,
                  uint32_t tcp_port)
{
    sli4_req_iscsi_tgt_stop_esi_listen_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_tgt_stop_esi_listen_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_STOP_ESI_LISTEN;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->ipaddr.struct_size = 24;
    req->ipaddr.ip_type = sli_iscsi_conv_hal_ip_addr_type(ipaddr->ip_type);
    ocs_memcpy(req->ipaddr.ip_addr, ipaddr->ip_address, 16);
    req->tcp_port = tcp_port;

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_stop_esi_listen_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_INI_INVALIDATE_CONNECTION command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection ID
 * @param cid the wq_id assigned with the connection
 * @param sendRst non-zero sends a TCP reset on the connection.
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_ini_invalidate_connection(sli4_t *sli4, void *buf,
                    size_t size, uint64_t tag,
                    uint32_t conn_hdl,
                    uint16_t cid,
                    uint8_t  sendRst)
{
    sli4_req_iscsi_ini_invalidate_connection_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_ini_invalidate_connection_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_INI_INVALIDATE_CONNECTION;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_INI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);

    /* not sure if this is necessary b/c 0x8000 flag is used below
     * however, open-iscsi be2iscsi driver sets this to the conn_hdl
     */
    req->session_handle = conn_hdl;
    req->cid = cid;

    /* flag 0x8000 indicates that session_handle field is ignored;
     * this is used for the Open iSCSI model
     */
    req->cleanup_type = (sendRst ? 0x8002 : 0x8001);

    return(cmd_off + sizeof(sli4_req_iscsi_ini_invalidate_connection_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TGT_ISNS_SEND_PACKET command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param isns_server the IP address of the iSNS server
 * @param tcp_port the TCP port number of the iSNS server
 * @param packet the virtual memory pointer to the packet data
 * @param pkt_length The number of bytes to transmit.
 * @param pkt_mem the DMA buffer that may be used to trasmit the packet
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tgt_isns_send_packet(sli4_t *sli4, void *buf,
                   size_t size, uint64_t tag,
                   ocs_hal_ip_address_t *isns_server,
                   uint32_t tcp_port,
                   void *packet,
                   uint32_t   pkt_length,
                   ocs_dma_t *pkt_mem)
{
    sli4_req_iscsi_tgt_isns_send_packet_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

    /* Make sure the packet fits in the DMA buffer */
    if (pkt_length > pkt_mem->size - sizeof(sli4_req_iscsi_tgt_isns_send_packet_t)) {
        ocs_log_test(sli4->os, "iSNS packet of size %d is too big for DMA buffer of size %d\n",
                 pkt_length,
                 (uint32_t)(pkt_mem->size - sizeof(sli4_req_iscsi_tgt_isns_send_packet_t)));
        return 0;
    }

    /* Payload length must accomodate both request and response */
    payload_size = max(sizeof(sli4_req_iscsi_tgt_isns_send_packet_t),
               pkt_mem->size);

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag,
                          payload_size, pkt_mem);

    ocs_memset(pkt_mem->virt, 0, pkt_mem->size);
    req = (sli4_req_iscsi_tgt_isns_send_packet_t*)pkt_mem->virt;

    req->hdr.opcode    = SLI4_OPC_ISCSI_TGT_ISNS_SEND_PACKET;
    req->hdr.subsystem = SLI4_SUBSYSTEM_ISCSI_TGT;
    req->hdr.request_length = pkt_mem->size - sizeof(sli4_req_hdr_t);
    req->isns_server.struct_size = 24;
    req->isns_server.ip_type     = sli_iscsi_conv_hal_ip_addr_type(isns_server->ip_type);
    ocs_memcpy(req->isns_server.ip_addr, isns_server->ip_address, 16);
    req->isns_server.tcp_port = tcp_port;
    req->pkt_size = pkt_length;

    /* Copy the iSNS packet bytes to the DMA buffer */
    ocs_memcpy(((uint8_t*)req) + sizeof(sli4_req_iscsi_tgt_isns_send_packet_t),
           packet,
           pkt_length);

    return(cmd_off + sizeof(sli4_req_iscsi_tgt_isns_send_packet_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_WQ_CREATE command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param qmem DMA memory for the queue
 * @param cq_id associated CQ_ID
 * @param ulp The ULP to bind the queue to (if dual ULP aware).
 *
 * @note This creates a Version 0 message
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_wq_create(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
            ocs_dma_t *qmem, uint16_t cq_id, uint16_t ulp)
{
    sli4_req_iscsi_wq_create_t  *wq = NULL;
    uint32_t    cmd_off = 0;
    uint32_t    p;
    uintptr_t   addr;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    wq = (sli4_req_iscsi_wq_create_t *)((uint8_t *)buf + cmd_off);

    wq->hdr.opcode = SLI4_OPC_ISCSI_WQ_CREATE;
    wq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    wq->hdr.request_length = sizeof(sli4_req_iscsi_wq_create_t) -
        sizeof(sli4_req_hdr_t);
    /* valid values for number of pages: 1-4 (sec 4.5.1) */
    wq->num_pages = SLI_PAGE_COUNT(qmem->size);

    if (sli4->features.dual_ulp_capable) {
        wq->dua = 1;
        wq->bqu = 1;
        wq->ulp = ulp;
    }

    if (!wq->num_pages || (wq->num_pages > SLI4_ISCSI_WQ_CREATE_V0_MAX_PAGES)) {
        return 0;
    }

    for (p = 0, addr = qmem->phys;
         p < wq->num_pages;
         p++, addr += SLI_PAGE_SIZE) {
        wq->page_physical_address[p].low = ocs_addr32_lo(addr);
        wq->page_physical_address[p].high = ocs_addr32_hi(addr);
    }

    return(cmd_off + sizeof(sli4_req_iscsi_wq_create_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_WQ_DESTROY command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param wq_id WQ_ID
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_wq_destroy(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
             uint16_t wq_id)
{
    sli4_req_iscsi_wq_destroy_t *wq = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    wq = (sli4_req_iscsi_wq_destroy_t *)((uint8_t *)buf + cmd_off);

    wq->hdr.opcode = SLI4_OPC_ISCSI_WQ_DESTROY;
    wq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    wq->hdr.request_length = sizeof(sli4_req_iscsi_wq_destroy_t) -
        sizeof(sli4_req_hdr_t);
    wq->wq_id = wq_id;

    return(cmd_off + sizeof(sli4_req_iscsi_wq_destroy_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_NTWK_SET_MTU command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param mtu the MTU size to set (usually 1500 or 8342 bytes)
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_ntwk_set_mtu(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
               uint32_t mtu)
{
    sli4_req_iscsi_ntwk_set_mtu_t *req = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    req = (sli4_req_iscsi_ntwk_set_mtu_t *)((uint8_t *)buf + cmd_off);

    req->hdr.opcode = SLI4_OPC_ISCSI_NTWK_SET_MTU;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = sizeof(sli4_req_iscsi_ntwk_set_mtu_t) -
        sizeof(sli4_req_hdr_t);
    req->mtu = mtu;

    return(cmd_off + sizeof(sli4_req_iscsi_ntwk_set_mtu_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TCP_CONNECT_AND_OFFLOAD V0 command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param ipaddr the IP address
 * @param tcp_port the TCP port number
 * @param cid The WQ id for this connection
 * @param cq_id The completion queue to be used for this conenction.
 * @param data_out the DMA buffer that may is used data-out and NOP headers
 * @param hdr_ring_id the receive header queue assigned to this connection
 * @param data_ring_id the receive data queue assigned to this connection
 * @param do_offload non-zero instructs the FW to offload the connection.
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tcp_connect_v0(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
                 ocs_hal_ip_address_t *ipaddr,
                 uint32_t   tcp_port,
                 uint16_t   cid,
                 uint16_t   cq_id,
                 ocs_dma_t *data_out,
                 uint16_t   hdr_ring_id,
                 uint16_t   data_ring_id,
                 uint8_t    do_offload)
{
    sli4_req_iscsi_tcp_connect_v0_t *req = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    req = (sli4_req_iscsi_tcp_connect_v0_t *)((uint8_t *)buf + cmd_off);

    req->hdr.opcode = SLI4_OPC_ISCSI_TCP_CONNECT_AND_OFFLOAD;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = sizeof(sli4_req_iscsi_tcp_connect_v0_t) -
        sizeof(sli4_req_hdr_t);
    req->ipaddr.struct_size = 24;
    req->ipaddr.ip_type = sli_iscsi_conv_hal_ip_addr_type(ipaddr->ip_type);
    ocs_memcpy(req->ipaddr.ip_addr, ipaddr->ip_address, 16);
    req->tcp_port = tcp_port;
    req->cid = cid;
    req->cq_id = cq_id;
    req->defq_id = hdr_ring_id;
    req->data_out_tmpl_low = ocs_addr32_lo(data_out->phys);
    req->data_out_tmpl_high = ocs_addr32_hi(data_out->phys);
    req->hdr_ring_id = hdr_ring_id;
    req->data_ring_id = data_ring_id;
    req->do_offload = (do_offload ? 1 : 0);

    return(cmd_off + sizeof(sli4_req_iscsi_tcp_connect_v0_t));
}


int32_t
sli_cmd_iscsi_tcp_connect_v1(sli4_t *sli4, void *buf,
                 size_t size, uint64_t tag,
                 ocs_hal_ip_address_t *ipaddr,
                 uint32_t   tcp_port,
                 uint16_t   cid,
                 uint16_t   cq_id,
                 ocs_dma_t *data_out,
                 uint16_t   hdr_ring_id,
                 uint16_t   data_ring_id,
                 uint8_t    do_offload,
                 uint16_t   window_size,
                 uint8_t    window_scale,
                 uint32_t   tcp_mss)
{
    sli4_req_iscsi_tcp_connect_v1_t *req = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    req = (sli4_req_iscsi_tcp_connect_v1_t *)((uint8_t *)buf + cmd_off);

    req->hdr.opcode = SLI4_OPC_ISCSI_TCP_CONNECT_AND_OFFLOAD;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.version   = 1;
    req->hdr.request_length = sizeof(sli4_req_iscsi_tcp_connect_v1_t) -
        sizeof(sli4_req_hdr_t);
    req->ipaddr.struct_size = 24;
    req->ipaddr.ip_type = sli_iscsi_conv_hal_ip_addr_type(ipaddr->ip_type);
    ocs_memcpy(req->ipaddr.ip_addr, ipaddr->ip_address, 16);
    req->tcp_port = tcp_port;
    req->cid = cid;
    req->cq_id = cq_id;
    req->defq_id = hdr_ring_id;
    req->data_out_tmpl_low = ocs_addr32_lo(data_out->phys);
    req->data_out_tmpl_high = ocs_addr32_hi(data_out->phys);
    req->hdr_ring_id = hdr_ring_id;
    req->data_ring_id = data_ring_id;
    req->do_offload = (do_offload ? 1 : 0);
    req->window_size = window_size;
    req->window_shift = window_scale;
    req->tcp_mss = tcp_mss;

    return(cmd_off + sizeof(sli4_req_iscsi_tcp_connect_v1_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_TCP_DISCONNECT command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection handle returned from the
 *                TCP_CONNECT
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_tcp_disconnect(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
                 uint32_t   conn_hdl)
{
    sli4_req_iscsi_tcp_disconnect_t *req = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    req = (sli4_req_iscsi_tcp_disconnect_t *)((uint8_t *)buf + cmd_off);

    req->hdr.opcode = SLI4_OPC_ISCSI_TCP_DISCONNECT;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = sizeof(sli4_req_iscsi_tcp_disconnect_t) -
        sizeof(sli4_req_hdr_t);
    req->conn_handle = conn_hdl;

    return(cmd_off + sizeof(sli4_req_iscsi_tcp_disconnect_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_GET_CONNECTION_INFO command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param conn_hdl the connection handle
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_get_connection_info(sli4_t *sli4, void *buf,
                  size_t size, uint64_t tag,
                  uint32_t conn_hdl)
{
    sli4_req_iscsi_get_connection_info_t *req = NULL;
    uint32_t cmd_off = 0;
    uint32_t payload_size;

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

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

    req = (sli4_req_iscsi_get_connection_info_t*)
        ((uint8_t *)buf + cmd_off);

    req->hdr.opcode    = SLI4_OPC_ISCSI_GET_CONNECTION_INFO;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
    req->conn_handle = conn_hdl;

    return(cmd_off + sizeof(sli4_req_iscsi_get_connection_info_t));
}



/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_INVALIDATE_COMMANDS command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param msg_mem pointer to DMA memory required to build the non-embedded command
 * @param ios pointer to an array of IOs to abort.
 * @param num_ios The number of IOs to abort
 * @param abort_type The type of abort to perform
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_invalidate_cmds(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
                  ocs_dma_t *msg_mem,
                  ocs_hal_io_t **ios, uint16_t num_ios,
                  ocs_hal_abort_type_e abort_type)
{
    sli4_req_common_iscsi_invalidate_cmds_t *req = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;
    uint32_t    index;

    if (num_ios > 128) {
        ocs_log_test(sli4->os, "%d ios is too many for command\n", num_ios);
        return -1;
    }

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          msg_mem);

    req = (sli4_req_common_iscsi_invalidate_cmds_t *)msg_mem->virt;

    ocs_memset(req, 0, msg_mem->size);
    req->hdr.opcode    = SLI4_OPC_ISCSI_ERROR_RECOVERY_INVALIDATE_CMDS;
    req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    req->hdr.request_length = msg_mem->size - sizeof(sli4_req_hdr_t);

    req->ref_handle = 0;
    req->icd_count  = num_ios;
    req->cleanup_type = (abort_type == OCS_HAL_IO_ABORT_TYPE_TMF ? 1 : 2);
    for (index = 0; index < num_ios; index++) {
        ocs_cxn_t *cxn = ios[index]->node;

        req->icds[index].icd = ios[index]->icd;
        req->icds[index].cid = cxn->wq_id;
    }

    return(cmd_off + sizeof(sli4_req_common_iscsi_invalidate_cmds_t));
}


/**
 * @ingroup sli_iscsi
 * @brief write a COMMON_ISCSI_CFG_REMOVE_SGL_PAGES command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_remove_sgl_pages(sli4_t *sli4, void *buf, size_t size, uint64_t tag)
{
    sli4_req_common_iscsi_cfg_remove_sgl_pages_t    *cmd = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

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

    cmd = (sli4_req_common_iscsi_cfg_remove_sgl_pages_t *)((uint8_t *)buf + cmd_off);

    cmd->hdr.opcode    = SLI4_OPC_ISCSI_CFG_REMOVE_SGL_PAGES;
    cmd->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    cmd->hdr.request_length = sizeof(sli4_req_common_iscsi_cfg_remove_sgl_pages_t) -
        sizeof(sli4_req_hdr_t);

    return(cmd_off + sizeof(sli4_req_common_iscsi_cfg_remove_sgl_pages_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_DEFQ_CREATE command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param qmem DMA memory for the queue
 * @param num_entries The number of entries in the queue.
 * @param cq_id the completion queue id assigned for this work queue
 * @param buffer_size buffer size pointed to by each RQE
 * @param ulp The ULP to bind the queue to (if dual ULP aware).
 *
 * @note This creates a Version 0 message
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_defq_create(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
              ocs_dma_t *qmem, uint32_t num_entries, uint16_t cq_id,
              uint16_t buffer_size, uint16_t ulp)
{
    sli4_req_iscsi_defq_create_t  *defq = NULL;
    uint32_t    cmd_off = 0;
    uint32_t    p;
    uintptr_t   addr;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    defq = (sli4_req_iscsi_defq_create_t *)((uint8_t *)buf + cmd_off);

    defq->hdr.opcode = SLI4_OPC_ISCSI_DEFQ_CREATE;
    defq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    defq->hdr.request_length = sizeof(sli4_req_iscsi_defq_create_t) -
        sizeof(sli4_req_hdr_t);
    /* valid values for number of pages: 1-8 (sec 4.5.6) */
    defq->num_pages = SLI_PAGE_COUNT(qmem->size);
    if (!defq->num_pages || (defq->num_pages > SLI4_ISCSI_DEFQ_CREATE_V0_MAX_PAGES)) {
        ocs_log_test(sli4->os, "num_pages %d not valid\n", defq->num_pages);
        return 0;
    }

    if (sli4->features.dual_ulp_capable) {
        defq->dua = 1;
        defq->bqu = 1;
        defq->ulp = ulp;
    }

    /*
     * rind size is the log base 2 of the total number of entries
     */
    defq->ring_size = ocs_lg2(num_entries) + 1;
    defq->cq_id  = cq_id;

    if ((buffer_size < SLI4_ISCSI_DEFQ_CREATE_V0_MIN_BUF_SIZE) ||
        (buffer_size > SLI4_ISCSI_DEFQ_CREATE_V0_MAX_BUF_SIZE)) {
        ocs_log_test(sli4->os, "buffer_size %d out of range (%d-%d)\n",
            buffer_size,
            SLI4_ISCSI_DEFQ_CREATE_V0_MIN_BUF_SIZE,
            SLI4_ISCSI_DEFQ_CREATE_V0_MAX_BUF_SIZE);
        return -1;
    }
    defq->buffer_size = buffer_size;

    for (p = 0, addr = qmem->phys;
         p < defq->num_pages;
         p++, addr += SLI_PAGE_SIZE) {
        defq->page_physical_address[p].low = ocs_addr32_lo(addr);
        defq->page_physical_address[p].high = ocs_addr32_hi(addr);
    }

    return(cmd_off + sizeof(sli4_req_iscsi_defq_create_t));
}

/**
 * @ingroup sli_iscsi
 * @brief write a ISCSI_DEFQ_DESTROY command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param rq_id RQ_ID
 *
 * @return number of bytes written
 */
int32_t
sli_cmd_iscsi_defq_destroy(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
               uint16_t rq_id)
{
    sli4_req_iscsi_defq_destroy_t *defq = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;

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

    cmd_off = sli_cmd_mailbox_queue_entry(sli4, buf, size, tag, payload_size,
                          NULL);
    defq = (sli4_req_iscsi_defq_destroy_t *)((uint8_t *)buf + cmd_off);

    defq->hdr.opcode = SLI4_OPC_ISCSI_DEFQ_DESTROY;
    defq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    defq->hdr.request_length = sizeof(sli4_req_iscsi_defq_destroy_t) -
        sizeof(sli4_req_hdr_t);
    defq->id = rq_id;

    return(cmd_off + sizeof(sli4_req_iscsi_defq_destroy_t));
}


/**
 * @ingroup sli_iscsi
 * @brief Process an asynchronous Link State event entry
 *
 * Parses ACQE, creates an abstracted event and calls registered callback functions.
 *
 * @param sli4 SLI context
 * @param acqe pointer to Asynchrounous Completion Queue Entry
 *
 * @return 0 on success, non-zero otherwise
 */
int32_t
sli_iscsi_process_link_state(sli4_t *sli4, void *acqe)
{
    sli4_link_state_t   *link_state = acqe;
    sli4_link_event_t   event = { 0 };
    int32_t     rc = 0;

    if (!sli4->link) {
        // bail if there is no callback
        return 0;
    }

    /*
     * Skyhawk has added a new defineition for bit 1 of this field
     * 0 - Physical link
     * 1 - Logical link
     *
     * For our purposes, we don't care, just mask the first bit.
     */
    switch (link_state->attn_type & 1) {
    case SLI4_PORT_LINK_STATUS_DOWN:
        event.status = SLI_LINK_STATUS_DOWN;
        break;
    case SLI4_PORT_LINK_STATUS_UP:
        event.status = SLI_LINK_STATUS_UP;
        break;
    default:
        ocs_log_test(sli4->os, "unsupported link status %#x\n",
            link_state->attn_type);
        event.status = SLI_LINK_STATUS_MAX;
        rc = -1;
    }

    switch (link_state->port_speed) {
    case 0:
        event.speed = 0;
        break;
    case 1:
        event.speed = 10;
        break;
    case 2:
        event.speed = 100;
        break;
    case 3:
        event.speed = 1000;
        break;
    case 4:
        event.speed = 10000;
        break;
    case 5:
        event.speed = 20000;
        break;
    case 6:
        event.speed = 25000;
        break;
    case 7:
        event.speed = 40000;
        break;
    case 8:
        event.speed = 100000;
        break;
    default:
        ocs_log_test(sli4->os, "unsupported port_speed %#x\n",
            link_state->port_speed);
        rc = -1;
    }

    sli4->link(sli4->link_arg, (void *)&event);

    return rc;
}

/**
 * @ingroup sli_iscsi
 * @brief Process an asynchronous iSCSI event entry
 *
 * Parses ACQE, creates an abstracted event and calls registered callback functions.
 *
 * @param sli4 SLI context
 * @param acqe pointer to Asynchrounous Completion Queue Entry
 *
 * @todo XXX all events return LINK_UP
 *
 * @return 0 on success, non-zero otherwise
 */
int32_t
sli_iscsi_process_iscsi(sli4_t *sli4, void *acqe)
{
    sli4_iscsi_t    *iscsi_acqe = acqe;
    int32_t     rc = 0;

    sli4_iscsi_async_event_t event;
    sli4_new_tcp_cnx_event_t *new_tcp = &event.params.new_tcp;
    sli4_stateless_op_cmpl_event_t *stateless_cmpl = &event.params.stateless_cmpl;
    sli4_dhcp_op_cmpl_event_t *dhcp_cmpl = &event.params.dhcp_cmpl;
    sli4_icmpv6_error_event_t *icmp_err = &event.params.icmp_err;
    sli4_port_mtu_chg_event_t *mtu_chg = &event.params.mtu_chg;

    sli4_iscsi_new_tcp_cnx_accepted_t *tcp_event = NULL;
    sli4_iscsi_stateless_op_cmpl_t *stateless_event = NULL;
    sli4_iscsi_dhcp_op_cmpl_t *dhcp_event = NULL;
    sli4_iscsi_icmpv6_error_t *icmp_event = NULL;
    sli4_iscsi_port_mtu_changed_t *mtu_event = NULL;

    ocs_memset(&event, 0, sizeof(sli4_iscsi_async_event_t));
    switch (iscsi_acqe->event_type) {
    case SLI4_ISCSI_ACQE_NEW_TCP_CONNECTION:
        tcp_event = acqe;
        event.event = SLI_ISCSI_ASYNC_NEW_TCP;
        new_tcp->cid = tcp_event->cid;
        ocs_log_debug(sli4->os, "ACQE New TCP Connection 0x%x\n", tcp_event->cid);
        break;
    case SLI4_ISCSI_ACQE_STATELESS_OPERATION_COMPLETE_IPV4:
        stateless_event = acqe;
        event.event = SLI_ISCSI_ASYNC_STATELESS_V4_OP_CMPL;
        stateless_cmpl->status = stateless_event->status;
        stateless_cmpl->additional_status = stateless_event->additional_status;
        stateless_cmpl->iface = stateless_event->iface;
        ocs_log_debug(sli4->os, "Stateless operation complete - IPv4\n");
        break;
    case SLI4_ISCSI_ACQE_STATELESS_OPERATION_COMPLETE_IPV6:
        stateless_event = acqe;
        event.event = SLI_ISCSI_ASYNC_STATELESS_v6_OP_CMPL;
        stateless_cmpl->status = stateless_event->status;
        stateless_cmpl->additional_status = stateless_event->additional_status;
        stateless_cmpl->iface = stateless_event->iface;
        ocs_log_debug(sli4->os, "Stateless operation complete - IPv6\n");
        break;
    case SLI4_ISCSI_ACQE_DHCP_OPERATION_COMPLETE:
        dhcp_event = acqe;
        event.event = SLI_ISCSI_ASYNC_DHCP_OP_CMPL;
        dhcp_cmpl->status = dhcp_event->status;
        dhcp_cmpl->additional_status = dhcp_event->additional_status;
        dhcp_cmpl->iface = dhcp_event->iface;
        ocs_log_debug(sli4->os, "DHCP operation complete\n");
        break;
    case SLI4_ISCSI_ACQE_ICMPV6_ERROR_PKT_RECVD:
        icmp_event = acqe;
        event.event = SLI_ISCSI_ASYNC_ICMPV6_ERROR;
        icmp_err->iface = icmp_event->iface;
        icmp_err->error_code = icmp_event->error_code;
        ocs_log_debug(sli4->os, "iSMPv6 Error packet received\n");
        break;
    case SLI4_ISCSI_ACQE_IPV6_DEFAULT_PORT_MTU_CHANGED:
        mtu_event = acqe;
        event.event = SLI_ISCSI_ASYNC_PORT_MTU_CHANGED;
        mtu_chg->new_mtu = mtu_event->new_mtu;
        ocs_log_debug(sli4->os, "IPv6 default port MTU changed\n");
        break;
    default:
        event.event = SLI_ISCSI_ASYNC_MAX;
        ocs_log_test(sli4->os, "unsupported iSCSI ACQE type %#x\n",
            iscsi_acqe->event_type);
        rc = -1;
    }

    if (sli4->iscsi_async) {
        sli4->iscsi_async(sli4->iscsi_async_arg, (void *)&event);
    }
    return rc;
}

/**
 * @ingroup sli_iscsi
 * @brief Parse a iSCSI work queue CQ entry
 *
 * @param sli4 SLI context
 * @param cq CQ to process
 * @param cqe pointer to the CQ entry
 * @param fields returns the fields embedded in the CQ entry
 *
 * @return 0 on success, non-zero otherwise
 */
int32_t
sli_iscsi_cqe_parse(sli4_t *sli4, sli4_queue_t *cq, uint8_t *cqe,
            sli4_qentry_fields_t *fields)
{
    int32_t rc = -1;
    sli4_iscsi_common_cqe_t *sol_cqe = (sli4_iscsi_common_cqe_t *)cqe;
    uint32_t code = sol_cqe->code;

    if (code <= ISCSI_CQE_CODE_MAX) {
        if (cq->u.flag.is_ini_cq) {
            if (sli4->is_skyhawk) {
                rc = ini_skh_cqe_handlers[code](sli4,
                                cqe, fields);
            } else {
                rc = ini_be3_cqe_handlers[code](sli4,
                                cqe, fields);
            }
        } else {
            if (sli4->is_skyhawk) {
                rc = tgt_skh_cqe_handlers[code](sli4,
                                cqe, fields);
            } else {
                rc = tgt_be3_cqe_handlers[code](sli4,
                                cqe, fields);
            }
        }
    } else {
        ocs_log_test(sli4->os, "CQE code 0x%x exceeds max code value of 0x%x - discarded\n",
                 code, ISCSI_CQE_CODE_MAX);
        ocs_dump32(OCS_DEBUG_ALWAYS, sli4->os, "cqe", cqe,
               sizeof(sli4_iscsi_common_cqe_t));
    }

    return rc;
}

/**
 * @ingroup sli_iscsi
 * @brief allocate a receive queue
 *
 * Allocates DMA memory and configures the requested queue type
 *
 * @param sli4 SLI context
 * @param header pointer to queue object for header
 * @param payload pointer to queue object for payload
 * @param n_entries number of entries to allocate
 * @param hsize header buffer size
 * @param psize payload buffer size
 * @param cq pointer to the completion queue to use for this queue.
 * @param ulp The ULP to bind the queue to (if dual ULP aware).
 *
 * @return 0 on success, -1 otherwise
 */
int32_t
sli_iscsi_defq_alloc(sli4_t *sli4, sli4_queue_t *header, sli4_queue_t *payload,
             uint32_t n_entries, uint32_t hsize, uint32_t psize,
             sli4_queue_t *cq, uint16_t ulp)
{

    if (!sli4 || !header || !payload) {
        ocs_log_err(NULL,
                "bad parameter sli4=%p header=%p payload=%p\n",
                sli4, header, payload);
        return -1;
    }

    ocs_memset(header, 0, sizeof(sli4_queue_t));

    if (__sli_queue_init(sli4, header, SLI_QTYPE_RQ, 0,
                 SLI4_ISCSI_DEFQE_SIZE, n_entries, SLI_PAGE_SIZE)) {
        return -1;
    }

    if (sli_cmd_iscsi_defq_create(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, 0,
                      &header->dma, n_entries, cq->id, hsize, ulp)) {
        if (__sli_create_queue(sli4, header)) {
            ocs_dma_free(sli4->os, &header->dma);
            ocs_memset(&header->dma, 0, sizeof(ocs_dma_t));
            return -1;
        }
        /* header Q_ID must be even */
        if (header->id & 1) {
            ocs_log_test(sli4->os, "bad header RQ_ID %d\n", header->id);
            ocs_dma_free(sli4->os, &header->dma);
            ocs_memset(&header->dma, 0, sizeof(ocs_dma_t));
            return -1;
        }
    } else {
        return -1;
    }
    header->u.flag.is_hdr = TRUE;
    if (0 == sli4->if_type) {
        header->u.flag.rq_batch = TRUE;
    }

    ocs_memset(payload, 0, sizeof(sli4_queue_t));
    if (__sli_queue_init(sli4, payload, SLI_QTYPE_RQ, 0,
                 SLI4_ISCSI_DEFQE_SIZE, n_entries, SLI_PAGE_SIZE)) {
        return -1;
    }

    if (sli_cmd_iscsi_defq_create(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, 0,
                      &payload->dma, n_entries, cq->id, psize, ulp)) {
        if (__sli_create_queue(sli4, payload)) {
            return -1;
        }
        /* payload Q_ID must be 1 bigger than the header Q_ID */
        if ((header->id + 1) != payload->id) {
            ocs_log_test(sli4->os,
                "bad payload RQ_ID %d (header RQ_ID %d\n",
                payload->id, header->id);
            return -1;
        }
    } else {
        return -1;
    }
    if (0 == sli4->if_type) {
        payload->u.flag.rq_batch = TRUE;
    }

    return 0;
}


/**
 * @ingroup sli_iscsi
 * @brief Allocate the SGL pages assigned to the ICD table and post them to
 * the chip.
 *
 * @param sli4 SLI context
 *
 * @return 0 on success, non-zero otherwise
 */
int32_t
sli_iscsi_set_frag_bits(sli4_t *sli4)
{
    uint32_t num_bits;
    sli4_res_hdr_t *hdr;

    switch (sli4->config.num_sges_per_icd) {
    case 32:
        num_bits = 5;
        break;
    case 256:
        num_bits = 8;
        break;
    default:
        ocs_log_test(sli4->os, "Invalid # of SGEs per ICD %d "
            "must be 32 or 256\n", sli4->config.num_sges_per_icd);
        return -1;
    }

    if (sli_cmd_iscsi_set_fragnum_bits(sli4,
                       sli4->bmbx.virt,
                       SLI4_BMBX_SIZE,
                       0, /* tag */
                       num_bits)) {
        if (sli_bmbx_command(sli4)) {
            ocs_log_crit(sli4->os, "bootstrap mailbox write "
                "fail SET_FRAGNUM_BITS\n");
            return -1;
        }
        hdr = (sli4_res_hdr_t *)((uint8_t *)sli4->bmbx.virt +
                     sizeof(sli4_mqe_hdr_t));

        if (hdr->status) {
            ocs_log_test(sli4->os, "bad status SET_FRAGNUM_BITS"
                " status=%#x addl=%#x\n", hdr->status,
                hdr->additional_status);
            return -1;
        } else {
            ocs_log_debug(sli4->os, "Set for %d SGEs\n", sli4->config.num_sges_per_icd);
        }
    } else {
        ocs_log_test(sli4->os, "Error building SET_FRAGNUM_BITS message\n");
        return -1;
    }

    return 0;
}

/**
 * @brief write a COMMON_ISCSI_CFG_POST_SGL_PAGES (v0) command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param pages pointer to an array of DMA page memory
 * @param num_pages The number of pages passed
 * @param page_offset The index of the page into the ICD SGL pages
 *
 * @return number of bytes written
 */
static int32_t
sli_cmd_iscsi_post_sgl_pages_v0(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
                 ocs_dma_t *pages, uint16_t num_pages, uint16_t page_offset)
{
    sli4_req_common_iscsi_cfg_post_sgl_pages_v0_t  *post = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;
    uint32_t    index;

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

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

    post = (sli4_req_common_iscsi_cfg_post_sgl_pages_v0_t *)((uint8_t *)buf + cmd_off);

    post->hdr.opcode    = SLI4_OPC_ISCSI_CFG_POST_SGL_PAGES;
    post->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    post->hdr.request_length = sizeof(sli4_req_common_iscsi_cfg_post_sgl_pages_v0_t) -
        sizeof(sli4_req_hdr_t);

    post->numPages    = num_pages;
    post->page_offset = page_offset;

    for (index = 0; index < num_pages; index++) {
        post->page_physical_address[index].low = ocs_addr32_lo(pages[index].phys);
        post->page_physical_address[index].high = ocs_addr32_hi(pages[index].phys);
    }

    return(cmd_off + sizeof(sli4_req_common_iscsi_cfg_post_sgl_pages_v0_t));
}


/**
 * @ingroup sli_iscsi
 * @brief Allocate the SGL pages assigned to the ICD table and post them to
 * the chip.
 *
 * @param sli4 SLI context
 *
 * @return 0 on success, non-zero otherwise
 */
static int32_t
sli_iscsi_post_sgl_pages_v0(sli4_t *sli4)
{
    uint32_t indx;
    uint32_t page_off = 0;
    uint32_t num_to_post;
    sli4_res_hdr_t *hdr;

    page_off = sli4->icd_base / sli4->icd_num_per_page;
    ocs_log_debug(sli4->os, "ICD SGE page offset is 0x%x, num pages = %d\n",
              page_off, sli4->num_sgl_pages);

    indx = 0;
    while (indx < sli4->num_sgl_pages) {

        num_to_post = sli4->num_sgl_pages - indx;
        if (num_to_post > 26) {
            num_to_post = 26;
        }

        if (sli_cmd_iscsi_post_sgl_pages_v0(sli4,
                            sli4->bmbx.virt,
                            SLI4_BMBX_SIZE,
                            0, /* tag */
                            &sli4->sgl_pages[indx],
                            (uint16_t)num_to_post,
                            (uint16_t)page_off)) {
            if (sli_bmbx_command(sli4)) {
                ocs_log_crit(sli4->os, "bootstrap mailbox write "
                    "fail CFG_POST_SGL (v0)\n");
                return -1;
            }
            hdr = (sli4_res_hdr_t *)((uint8_t *)sli4->bmbx.virt +
                            sizeof(sli4_mqe_hdr_t));

            if (hdr->status) {
                ocs_log_test(sli4->os, "bad create CFG_POST_SGL (v0)"
                    " status=%#x addl=%#x\n", hdr->status,
                     hdr->additional_status);
                return -1;
            }
        } else {
            ocs_log_test(sli4->os, "Error building post SGL page (v0) message\n");
            return -1;
        }

        indx     += num_to_post;
        page_off += num_to_post;
    }

    return 0;
}

/**
 * @brief write a COMMON_ISCSI_CFG_POST_SGL_PAGES (v1) command
 *
 * @param sli4 SLI context
 * @param buf destination buffer for the command
 * @param size buffer size in bytes
 * @param tag command tag
 * @param pages pointer to an array of DMA page memory
 * @param icd_start The starting ICD index
 * @param icd_count The number of ICD to post (1 page per ICD)
 *
 * @return number of bytes written
 */
static int32_t
sli_cmd_iscsi_post_sgl_pages_v1(sli4_t *sli4, void *buf, size_t size, uint64_t tag,
                ocs_dma_t *pages, uint16_t icd_start, uint16_t icd_count)
{
    sli4_req_common_iscsi_cfg_post_sgl_pages_v1_t  *post = NULL;
    uint32_t    cmd_off = 0;
    uint32_t payload_size;
    uint32_t    index;

    /* Payload length must accomodate both request and response */
    payload_size = (sizeof(sli4_req_hdr_t) + 4 + /* ICD count and start */
            (icd_count * 8)); /* page addresses */

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

    post = (sli4_req_common_iscsi_cfg_post_sgl_pages_v1_t *)((uint8_t *)buf + cmd_off);

    post->hdr.opcode    = SLI4_OPC_ISCSI_CFG_POST_SGL_PAGES;
    post->hdr.subsystem = SLI4_SUBSYSTEM_COMMON_ISCSI;
    post->hdr.version   = 1;
    post->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);

    post->icd_start = icd_start;
    post->icd_count = icd_count;

    for (index = 0; index < icd_count; index++) {
        post->page_set[index].page0_low = ocs_addr32_lo(pages[index].phys);
        post->page_set[index].page0_high = ocs_addr32_hi(pages[index].phys);
    }

    return(cmd_off + sizeof(sli4_req_common_iscsi_cfg_post_sgl_pages_v1_t));
}


/**
 * @ingroup sli_iscsi
 * @brief Allocate the SGL pages assigned to the ICD table and post them to
 * the chip.
 *
 * @param sli4 SLI context
 *
 * @return 0 on success, non-zero otherwise
 */
static int32_t
sli_iscsi_post_sgl_pages_v1(sli4_t *sli4)
{
    uint32_t page_size = sizeof(sli4_sge_t) * sli4->config.num_sges_per_icd;
    uint32_t icd_indx = 0;
    uint32_t num_to_post;
    sli4_res_hdr_t *hdr;
    ocs_dma_t pages[20];
    uint32_t page_indx;

    while (icd_indx < sli4->icd_count) {

        num_to_post = sli4->icd_count - icd_indx;
        if (num_to_post > 20) {
            num_to_post = 20;
        }

        /*
         * We need to build an array of DMA of "pages", one per ICD,
         * but in reality, they are not full pages. FW will never know
         * since we will never use that many entries. Chunk the
         * allocated pages into each individual ICD.
         */
        for (page_indx = 0; page_indx < num_to_post; page_indx++) {
            uint32_t icd_off = (icd_indx + page_indx);
            uint32_t page_num = icd_off / sli4->icd_num_per_page;
            uint32_t page_off = ((icd_off % sli4->icd_num_per_page)
                         * page_size);

            pages[page_indx].virt = (uint8_t*)sli4->sgl_pages[page_num].virt + page_off;
            pages[page_indx].phys = sli4->sgl_pages[page_num].phys + page_off;
            pages[page_indx].size = page_size;
        }

        if (sli_cmd_iscsi_post_sgl_pages_v1(sli4,
                            sli4->bmbx.virt,
                            SLI4_BMBX_SIZE,
                            0, /* tag */
                            pages,
                            (uint16_t)(sli4->icd_base + icd_indx),
                            (uint16_t)num_to_post)) {
            if (sli_bmbx_command(sli4)) {
                ocs_log_crit(sli4->os, "bootstrap mailbox write "
                    "fail CFG_POST_SGL (v1)\n");
                return -1;
            }
            hdr = (sli4_res_hdr_t *)((uint8_t *)sli4->bmbx.virt +
                            sizeof(sli4_mqe_hdr_t));

            if (hdr->status) {
                ocs_log_test(sli4->os, "bad create CFG_POST_SGL (v1)"
                    " status=%#x addl=%#x\n", hdr->status,
                     hdr->additional_status);
                return -1;
            }
        } else {
            ocs_log_test(sli4->os,
                     "Error building post SGL page (v1) message\n");
            return -1;
        }

        icd_indx += num_to_post;
    }

    return 0;
}


/**
 * @ingroup sli_iscsi
 * @brief Allocate the SGL pages assigned to the ICD table and post them to
 * the chip.
 *
 * @param sli4 SLI context
 *
 * @return 0 on success, non-zero otherwise
 */
int32_t
sli_iscsi_post_sgl_pages(sli4_t *sli4)
{
    uint32_t indx;
    int32_t rc;


    /*
     * Note: SGEs are 4 dwords, standard number of SGEs is 32 per ICD.
     */
    sli4->icd_num_per_page = 4096 / (sizeof(sli4_sge_t) * sli4->config.num_sges_per_icd);

    sli4->num_sgl_pages = ((sli4->icd_count + sli4->icd_num_per_page - 1) /
                   sli4->icd_num_per_page);

    /* Allocate pages */
    sli4->sgl_pages = ocs_malloc(sli4->os, sizeof(ocs_dma_t) * sli4->num_sgl_pages,
                     OCS_M_ZERO | OCS_M_NOWAIT);
    if (NULL == sli4->sgl_pages) {
        ocs_log_err(sli4->os, "Failed to allocate SGL DMA structures\n");
        return -1;
    }

    for (indx = 0; indx < sli4->num_sgl_pages; indx++) {
        if (ocs_dma_alloc(sli4->os,
                  &sli4->sgl_pages[indx],
                  4096,
                  32)) {
            ocs_log_err(sli4->os, "Failed to allocate SGL page %d\n", indx);
            return -1;
        }
    }

    ocs_log_debug(sli4->os, "Use ver %d to register %d SGEs per ICD\n",
        sli4->config.post_sgl_ver, sli4->config.num_sges_per_icd);

    switch (sli4->config.post_sgl_ver) {
    case 0:
        rc = sli_iscsi_post_sgl_pages_v0(sli4);
        break;
    case 1:
        rc = sli_iscsi_post_sgl_pages_v1(sli4);
        break;
    default:
        ocs_log_test(sli4->os, "Invalid post sgl version of %d\n",
                 sli4->config.post_sgl_ver);
        rc = -1;
    }

    return rc;
}

/**
 * @ingroup sli_iscsi
 * @brief return the ICD and virtual SGL pointer for an IO at the specified
 *    offset into the ICD table.
 *
 * @param sli4 SLI context
 * @param io_offset The offset into the ICD table
 * @param icd returns the ICD representing this IO.
 * @param sgl returns the virtual pointer to the first SGL for this ICD.
 *
 * @return 0 on success, non-zero otherwise
 */
int32_t
sli_iscsi_io_get_icd_and_sgl(sli4_t *sli4, uint32_t io_offset,
                 uint16_t *icd, void **sgl)
{
    int32_t rc = 0;
    uint32_t icd_page_off;
    uint32_t icd_off;

    if (io_offset >= sli4->icd_count) {
        rc = -1;
    } else {
        *icd = sli4->icd_base + io_offset;

        icd_page_off = io_offset / sli4->icd_num_per_page;
        icd_off      = ((io_offset % sli4->icd_num_per_page) *
                (sizeof(sli4_sge_t) * sli4->config.num_sges_per_icd));

        *sgl = ((uint8_t*)sli4->sgl_pages[icd_page_off].virt) + icd_off;
    }
    return rc;
}

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