system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-07-23 11:16:33 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
freebsd-src/sys/dev/ocs_fc/ocs_hw.h
Ram Kishore Vegesna 70547544ce ocs_fc: IO timeout handling and error reporting fix. 
Hardware timeout uses a 8-bit timeout value and expects the timeout to
be less than 255 seconds. Added software timer implemetation to timeout
and abort the IOs with timeout more than 255 seconds.

Fix the timeout problem by dividing CAM timeouts by 1000 as hardware
expects timeout value in seconds.  Before this change, CAM timeouts in
milliseconds were getting truncated to 8 bits and converted to seconds.
So the actual timeout used when going down to the card would depend on
the bottom 8 bits of the timeout used.

Add the mapping of ocs_fc error status to CAM status.

Reported by:	ken
Reviewed by:	ken
Tested by:	ken, ram
Approved by:	ken
MFC after:	1 week
2023-12-12 10:22:58 -05:00

1534 lines
50 KiB
C
Raw Blame History

/*-
* Copyright (c) 2017 Broadcom. All rights reserved.
* The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file
* Defines the Hardware Abstraction Layer (HW) interface functions.
*/
#ifndef _OCS_HW_H
#define _OCS_HW_H
#include "sli4.h"
#include "ocs_hw.h"
#include "ocs_stats.h"
#include "ocs_utils.h"
typedef struct ocs_hw_io_s ocs_hw_io_t;
#if defined(OCS_INCLUDE_DEBUG)
#else
#define ocs_queue_history_wq(...)
#define ocs_queue_history_cqe(...)
#define ocs_queue_history_init(...)
#define ocs_queue_history_free(...)
#endif
/**
* @brief HW queue forward declarations
*/
typedef struct hw_eq_s hw_eq_t;
typedef struct hw_cq_s hw_cq_t;
typedef struct hw_mq_s hw_mq_t;
typedef struct hw_wq_s hw_wq_t;
typedef struct hw_rq_s hw_rq_t;
typedef struct hw_rq_grp_s hw_rq_grp_t;
/* HW asserts/verify
*
*/
extern void _ocs_hw_assert(const char *cond, const char *filename, int linenum);
extern void _ocs_hw_verify(const char *cond, const char *filename, int linenum);
#if defined(HW_NDEBUG)
#define ocs_hw_assert(cond)
#define ocs_hw_verify(cond, ...)
#else
#define ocs_hw_assert(cond) \
do { \
if ((!(cond))) { \
_ocs_hw_assert(#cond, __FILE__, __LINE__); \
} \
} while (0)
#define ocs_hw_verify(cond, ...) \
do { \
if ((!(cond))) { \
_ocs_hw_verify(#cond, __FILE__, __LINE__); \
return __VA_ARGS__; \
} \
} while (0)
#endif
#define ocs_hw_verify_arg(cond) ocs_hw_verify(cond, OCS_HW_RTN_INVALID_ARG)
/*
* HW completion loop control parameters.
*
* The HW completion loop must terminate periodically to keep the OS happy. The
* loop terminates when a predefined time has elapsed, but to keep the overhead of
* computing time down, the time is only checked after a number of loop iterations
* has completed.
*
* OCS_HW_TIMECHECK_ITERATIONS number of loop iterations between time checks
*
*/
#define OCS_HW_TIMECHECK_ITERATIONS 100
#define OCS_HW_MAX_NUM_MQ 1
#define OCS_HW_MAX_NUM_RQ 32
#define OCS_HW_MAX_NUM_EQ 16
#define OCS_HW_MAX_NUM_WQ 32
#define OCE_HW_MAX_NUM_MRQ_PAIRS 16
#define OCS_HW_MAX_WQ_CLASS 4
#define OCS_HW_MAX_WQ_CPU 128
/*
* A CQ will be assinged to each WQ (CQ must have 2X entries of the WQ for abort
* processing), plus a separate one for each RQ PAIR and one for MQ
*/
#define OCS_HW_MAX_NUM_CQ ((OCS_HW_MAX_NUM_WQ*2) + 1 + (OCE_HW_MAX_NUM_MRQ_PAIRS * 2))
/*
* Q hash - size is the maximum of all the queue sizes, rounded up to the next
* power of 2
*/
#define OCS_HW_Q_HASH_SIZE B32_NEXT_POWER_OF_2(OCS_MAX(OCS_HW_MAX_NUM_MQ, OCS_MAX(OCS_HW_MAX_NUM_RQ, \
OCS_MAX(OCS_HW_MAX_NUM_EQ, OCS_MAX(OCS_HW_MAX_NUM_WQ, \
OCS_HW_MAX_NUM_CQ)))))
#define OCS_HW_RQ_HEADER_SIZE 128
#define OCS_HW_RQ_HEADER_INDEX 0
/**
* @brief Options for ocs_hw_command().
*/
enum {
OCS_CMD_POLL, /**< command executes synchronously and busy-waits for completion */
OCS_CMD_NOWAIT, /**< command executes asynchronously. Uses callback */
};
typedef enum {
OCS_HW_RTN_SUCCESS = 0,
OCS_HW_RTN_SUCCESS_SYNC = 1,
OCS_HW_RTN_ERROR = -1,
OCS_HW_RTN_NO_RESOURCES = -2,
OCS_HW_RTN_NO_MEMORY = -3,
OCS_HW_RTN_IO_NOT_ACTIVE = -4,
OCS_HW_RTN_IO_ABORT_IN_PROGRESS = -5,
OCS_HW_RTN_IO_PORT_OWNED_ALREADY_ABORTED = -6,
OCS_HW_RTN_INVALID_ARG = -7,
} ocs_hw_rtn_e;
#define OCS_HW_RTN_IS_ERROR(e) ((e) < 0)
typedef enum {
OCS_HW_RESET_FUNCTION,
OCS_HW_RESET_FIRMWARE,
OCS_HW_RESET_MAX
} ocs_hw_reset_e;
typedef enum {
OCS_HW_N_IO,
OCS_HW_N_SGL,
OCS_HW_MAX_IO,
OCS_HW_MAX_SGE,
OCS_HW_MAX_SGL,
OCS_HW_MAX_NODES,
OCS_HW_MAX_RQ_ENTRIES,
OCS_HW_TOPOLOGY, /**< auto, nport, loop */
OCS_HW_WWN_NODE,
OCS_HW_WWN_PORT,
OCS_HW_FW_REV,
OCS_HW_FW_REV2,
OCS_HW_IPL,
OCS_HW_VPD,
OCS_HW_VPD_LEN,
OCS_HW_MODE, /**< initiator, target, both */
OCS_HW_LINK_SPEED,
OCS_HW_IF_TYPE,
OCS_HW_SLI_REV,
OCS_HW_SLI_FAMILY,
OCS_HW_RQ_PROCESS_LIMIT,
OCS_HW_RQ_DEFAULT_BUFFER_SIZE,
OCS_HW_AUTO_XFER_RDY_CAPABLE,
OCS_HW_AUTO_XFER_RDY_XRI_CNT,
OCS_HW_AUTO_XFER_RDY_SIZE,
OCS_HW_AUTO_XFER_RDY_BLK_SIZE,
OCS_HW_AUTO_XFER_RDY_T10_ENABLE,
OCS_HW_AUTO_XFER_RDY_P_TYPE,
OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA,
OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID,
OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE,
OCS_HW_DIF_CAPABLE,
OCS_HW_DIF_SEED,
OCS_HW_DIF_MODE,
OCS_HW_DIF_MULTI_SEPARATE,
OCS_HW_DUMP_MAX_SIZE,
OCS_HW_DUMP_READY,
OCS_HW_DUMP_PRESENT,
OCS_HW_RESET_REQUIRED,
OCS_HW_FW_ERROR,
OCS_HW_FW_READY,
OCS_HW_HIGH_LOGIN_MODE,
OCS_HW_PREREGISTER_SGL,
OCS_HW_HW_REV1,
OCS_HW_HW_REV2,
OCS_HW_HW_REV3,
OCS_HW_LINKCFG,
OCS_HW_ETH_LICENSE,
OCS_HW_LINK_MODULE_TYPE,
OCS_HW_NUM_CHUTES,
OCS_HW_WAR_VERSION,
OCS_HW_DISABLE_AR_TGT_DIF,
OCS_HW_EMULATE_I_ONLY_AAB, /**< emulate IAAB=0 for initiator-commands only */
OCS_HW_EMULATE_WQE_TIMEOUT, /**< enable driver timeouts for WQEs */
OCS_HW_LINK_CONFIG_SPEED,
OCS_HW_CONFIG_TOPOLOGY,
OCS_HW_BOUNCE,
OCS_HW_PORTNUM,
OCS_HW_BIOS_VERSION_STRING,
OCS_HW_RQ_SELECT_POLICY,
OCS_HW_SGL_CHAINING_CAPABLE,
OCS_HW_SGL_CHAINING_ALLOWED,
OCS_HW_SGL_CHAINING_HOST_ALLOCATED,
OCS_HW_SEND_FRAME_CAPABLE,
OCS_HW_RQ_SELECTION_POLICY,
OCS_HW_RR_QUANTA,
OCS_HW_FILTER_DEF,
OCS_HW_MAX_VPORTS,
OCS_ESOC,
OCS_HW_FW_TIMED_OUT,
} ocs_hw_property_e;
enum {
OCS_HW_TOPOLOGY_AUTO,
OCS_HW_TOPOLOGY_NPORT,
OCS_HW_TOPOLOGY_LOOP,
OCS_HW_TOPOLOGY_NONE,
OCS_HW_TOPOLOGY_MAX
};
enum {
OCS_HW_MODE_INITIATOR,
OCS_HW_MODE_TARGET,
OCS_HW_MODE_BOTH,
OCS_HW_MODE_MAX
};
/**
* @brief Port protocols
*/
typedef enum {
OCS_HW_PORT_PROTOCOL_ISCSI,
OCS_HW_PORT_PROTOCOL_FCOE,
OCS_HW_PORT_PROTOCOL_FC,
OCS_HW_PORT_PROTOCOL_OTHER,
} ocs_hw_port_protocol_e;
#define OCS_HW_MAX_PROFILES 40
/**
* @brief A Profile Descriptor
*/
typedef struct {
uint32_t profile_index;
uint32_t profile_id;
char profile_description[512];
} ocs_hw_profile_descriptor_t;
/**
* @brief A Profile List
*/
typedef struct {
uint32_t num_descriptors;
ocs_hw_profile_descriptor_t descriptors[OCS_HW_MAX_PROFILES];
} ocs_hw_profile_list_t;
/**
* @brief Defines DIF operation modes
*/
enum {
OCS_HW_DIF_MODE_INLINE,
OCS_HW_DIF_MODE_SEPARATE,
};
/**
* @brief Defines the type of RQ buffer
*/
typedef enum {
OCS_HW_RQ_BUFFER_TYPE_HDR,
OCS_HW_RQ_BUFFER_TYPE_PAYLOAD,
OCS_HW_RQ_BUFFER_TYPE_MAX,
} ocs_hw_rq_buffer_type_e;
/**
* @brief Defines a wrapper for the RQ payload buffers so that we can place it
* back on the proper queue.
*/
typedef struct {
uint16_t rqindex;
ocs_dma_t dma;
} ocs_hw_rq_buffer_t;
/**
* @brief T10 DIF operations.
*/
typedef enum {
OCS_HW_DIF_OPER_DISABLED,
OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC,
OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF,
OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM,
OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF,
OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC,
OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM,
OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CHKSUM,
OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CRC,
OCS_HW_SGE_DIF_OP_IN_RAW_OUT_RAW,
} ocs_hw_dif_oper_e;
#define OCS_HW_DIF_OPER_PASS_THRU OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC
#define OCS_HW_DIF_OPER_STRIP OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF
#define OCS_HW_DIF_OPER_INSERT OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC
/**
* @brief T10 DIF block sizes.
*/
typedef enum {
OCS_HW_DIF_BK_SIZE_512,
OCS_HW_DIF_BK_SIZE_1024,
OCS_HW_DIF_BK_SIZE_2048,
OCS_HW_DIF_BK_SIZE_4096,
OCS_HW_DIF_BK_SIZE_520,
OCS_HW_DIF_BK_SIZE_4104,
OCS_HW_DIF_BK_SIZE_NA = 0
} ocs_hw_dif_blk_size_e;
/**
* @brief Link configurations.
*/
typedef enum {
OCS_HW_LINKCFG_4X10G = 0,
OCS_HW_LINKCFG_1X40G,
OCS_HW_LINKCFG_2X16G,
OCS_HW_LINKCFG_4X8G,
OCS_HW_LINKCFG_4X1G,
OCS_HW_LINKCFG_2X10G,
OCS_HW_LINKCFG_2X10G_2X8G,
/* must be last */
OCS_HW_LINKCFG_NA,
} ocs_hw_linkcfg_e;
/**
* @brief link module types
*
* (note: these just happen to match SLI4 values)
*/
enum {
OCS_HW_LINK_MODULE_TYPE_1GB = 0x0004,
OCS_HW_LINK_MODULE_TYPE_2GB = 0x0008,
OCS_HW_LINK_MODULE_TYPE_4GB = 0x0040,
OCS_HW_LINK_MODULE_TYPE_8GB = 0x0080,
OCS_HW_LINK_MODULE_TYPE_10GB = 0x0100,
OCS_HW_LINK_MODULE_TYPE_16GB = 0x0200,
OCS_HW_LINK_MODULE_TYPE_32GB = 0x0400,
};
/**
* @brief T10 DIF information passed to the transport.
*/
typedef struct ocs_hw_dif_info_s {
ocs_hw_dif_oper_e dif_oper;
ocs_hw_dif_blk_size_e blk_size;
uint32_t ref_tag_cmp;
uint32_t ref_tag_repl;
uint32_t app_tag_cmp:16,
app_tag_repl:16;
uint32_t check_ref_tag:1,
check_app_tag:1,
check_guard:1,
auto_incr_ref_tag:1,
repl_app_tag:1,
repl_ref_tag:1,
dif:2,
dif_separate:1,
/* If the APP TAG is 0xFFFF, disable checking the REF TAG and CRC fields */
disable_app_ffff:1,
/* if the APP TAG is 0xFFFF and REF TAG is 0xFFFF_FFFF, disable checking the received CRC field. */
disable_app_ref_ffff:1,
:21;
uint16_t dif_seed;
} ocs_hw_dif_info_t;
typedef enum {
OCS_HW_ELS_REQ, /**< ELS request */
OCS_HW_ELS_RSP, /**< ELS response */
OCS_HW_ELS_RSP_SID, /**< ELS response, override the S_ID */
OCS_HW_FC_CT, /**< FC Common Transport */
OCS_HW_FC_CT_RSP, /**< FC Common Transport Response */
OCS_HW_BLS_ACC, /**< BLS accept (BA_ACC) */
OCS_HW_BLS_ACC_SID, /**< BLS accept (BA_ACC), override the S_ID */
OCS_HW_BLS_RJT, /**< BLS reject (BA_RJT) */
OCS_HW_BCAST, /**< Class 3 broadcast sequence */
OCS_HW_IO_TARGET_READ,
OCS_HW_IO_TARGET_WRITE,
OCS_HW_IO_TARGET_RSP,
OCS_HW_IO_INITIATOR_READ,
OCS_HW_IO_INITIATOR_WRITE,
OCS_HW_IO_INITIATOR_NODATA,
OCS_HW_IO_DNRX_REQUEUE,
OCS_HW_IO_MAX,
} ocs_hw_io_type_e;
typedef enum {
OCS_HW_IO_STATE_FREE,
OCS_HW_IO_STATE_INUSE,
OCS_HW_IO_STATE_WAIT_FREE,
OCS_HW_IO_STATE_WAIT_SEC_HIO,
} ocs_hw_io_state_e;
/* Descriptive strings for the HW IO request types (note: these must always
* match up with the ocs_hw_io_type_e declaration) */
#define OCS_HW_IO_TYPE_STRINGS \
"ELS request", \
"ELS response", \
"ELS response(set SID)", \
"FC CT request", \
"BLS accept", \
"BLS accept(set SID)", \
"BLS reject", \
"target read", \
"target write", \
"target response", \
"initiator read", \
"initiator write", \
"initiator nodata",
/**
* @brief HW command context.
*
* Stores the state for the asynchronous commands sent to the hardware.
*/
typedef struct ocs_command_ctx_s {
ocs_list_t link;
/**< Callback function */
int32_t (*cb)(struct ocs_hw_s *, int32_t, uint8_t *, void *);
void *arg; /**< Argument for callback */
uint8_t *buf; /**< buffer holding command / results */
void *ctx; /**< upper layer context */
} ocs_command_ctx_t;
typedef struct ocs_hw_sgl_s {
uintptr_t addr;
size_t len;
} ocs_hw_sgl_t;
/**
* @brief HW callback type
*
* Typedef for HW "done" callback.
*/
typedef int32_t (*ocs_hw_done_t)(struct ocs_hw_io_s *, ocs_remote_node_t *, uint32_t len, int32_t status, uint32_t ext, void *ul_arg);
typedef union ocs_hw_io_param_u {
struct {
uint16_t ox_id;
uint16_t rx_id;
uint8_t payload[12]; /**< big enough for ABTS BA_ACC */
} bls;
struct {
uint32_t s_id;
uint16_t ox_id;
uint16_t rx_id;
uint8_t payload[12]; /**< big enough for ABTS BA_ACC */
} bls_sid;
struct {
uint8_t r_ctl;
uint8_t type;
uint8_t df_ctl;
uint8_t timeout;
} bcast;
struct {
uint16_t ox_id;
uint8_t timeout;
} els;
struct {
uint32_t s_id;
uint16_t ox_id;
uint8_t timeout;
} els_sid;
struct {
uint8_t r_ctl;
uint8_t type;
uint8_t df_ctl;
uint8_t timeout;
} fc_ct;
struct {
uint8_t r_ctl;
uint8_t type;
uint8_t df_ctl;
uint8_t timeout;
uint16_t ox_id;
} fc_ct_rsp;
struct {
uint32_t offset;
uint16_t ox_id;
uint16_t flags;
uint8_t cs_ctl;
ocs_hw_dif_oper_e dif_oper;
ocs_hw_dif_blk_size_e blk_size;
uint8_t timeout;
uint32_t app_id;
} fcp_tgt;
struct {
ocs_dma_t *cmnd;
ocs_dma_t *rsp;
ocs_hw_dif_oper_e dif_oper;
ocs_hw_dif_blk_size_e blk_size;
uint32_t cmnd_size;
uint16_t flags;
uint32_t timeout;
uint32_t first_burst;
} fcp_ini;
} ocs_hw_io_param_t;
/**
* @brief WQ steering mode
*/
typedef enum {
OCS_HW_WQ_STEERING_CLASS,
OCS_HW_WQ_STEERING_REQUEST,
OCS_HW_WQ_STEERING_CPU,
} ocs_hw_wq_steering_e;
/**
* @brief HW wqe object
*/
typedef struct {
uint32_t abort_wqe_submit_needed:1, /**< set if abort wqe needs to be submitted */
send_abts:1, /**< set to 1 to have hardware to automatically send ABTS */
auto_xfer_rdy_dnrx:1, /**< TRUE if DNRX was set on this IO */
:29;
uint32_t id;
uint32_t abort_reqtag;
ocs_list_link_t link;
uint8_t *wqebuf; /**< work queue entry buffer */
} ocs_hw_wqe_t;
/**
* @brief HW IO object.
*
* Stores the per-IO information necessary for both the lower (SLI) and upper
* layers (ocs).
*/
struct ocs_hw_io_s {
/* Owned by HW */
ocs_list_link_t link; /**< used for busy, wait_free, free lists */
ocs_list_link_t wqe_link; /**< used for timed_wqe list */
ocs_list_link_t dnrx_link; /**< used for io posted dnrx list */
ocs_hw_io_state_e state; /**< state of IO: free, busy, wait_free */
ocs_hw_wqe_t wqe; /**< Work queue object, with link for pending */
ocs_lock_t axr_lock; /**< Lock to synchronize TRSP and AXT Data/Cmd Cqes */
ocs_hw_t *hw; /**< pointer back to hardware context */
ocs_remote_node_t *rnode;
struct ocs_hw_auto_xfer_rdy_buffer_s *axr_buf;
ocs_dma_t xfer_rdy;
uint16_t type;
uint32_t port_owned_abort_count; /**< IO abort count */
hw_wq_t *wq; /**< WQ assigned to the exchange */
uint32_t xbusy; /**< Exchange is active in FW */
ocs_hw_done_t done; /**< Function called on IO completion */
void *arg; /**< argument passed to "IO done" callback */
ocs_hw_done_t abort_done; /**< Function called on abort completion */
void *abort_arg; /**< argument passed to "abort done" callback */
ocs_ref_t ref; /**< refcount object */
size_t length; /**< needed for bug O127585: length of IO */
uint32_t wqe_timeout; /**< timeout value for WQEs */
struct timeval submit_time; /**< timestamp when current WQE was submitted */
uint32_t status_saved:1, /**< if TRUE, latched status should be returned */
abort_in_progress:1, /**< if TRUE, abort is in progress */
quarantine:1, /**< set if IO to be quarantined */
quarantine_first_phase:1, /**< set if first phase of IO */
is_port_owned:1, /**< set if POST_XRI was used to send XRI to th chip */
auto_xfer_rdy_dnrx:1, /**< TRUE if DNRX was set on this IO */
:26;
uint32_t saved_status; /**< latched status */
uint32_t saved_len; /**< latched length */
uint32_t saved_ext; /**< latched extended status */
hw_eq_t *eq; /**< EQ that this HIO came up on */
ocs_hw_wq_steering_e wq_steering; /**< WQ steering mode request */
uint8_t wq_class; /**< WQ class if steering mode is Class */
/* Owned by SLI layer */
uint16_t reqtag; /**< request tag for this HW IO */
uint32_t abort_reqtag; /**< request tag for an abort of this HW IO (note: this is a 32 bit value
to allow us to use UINT32_MAX as an uninitialized value) */
uint32_t indicator; /**< XRI */
ocs_dma_t def_sgl; /**< default scatter gather list */
uint32_t def_sgl_count; /**< count of SGEs in default SGL */
ocs_dma_t *sgl; /**< pointer to current active SGL */
uint32_t sgl_count; /**< count of SGEs in io->sgl */
uint32_t first_data_sge; /**< index of first data SGE */
ocs_dma_t *ovfl_sgl; /**< overflow SGL */
uint32_t ovfl_sgl_count; /**< count of SGEs in default SGL */
sli4_lsp_sge_t *ovfl_lsp; /**< pointer to overflow segment length */
ocs_hw_io_t *ovfl_io; /**< Used for SGL chaining on skyhawk */
uint32_t n_sge; /**< number of active SGEs */
uint32_t sge_offset;
/* BZ 161832 Workaround: */
struct ocs_hw_io_s *sec_hio; /**< Secondary HW IO context */
ocs_hw_io_param_t sec_iparam; /**< Secondary HW IO context saved iparam */
uint32_t sec_len; /**< Secondary HW IO context saved len */
/* Owned by upper layer */
void *ul_io; /**< where upper layer can store reference to its IO */
};
typedef enum {
OCS_HW_PORT_INIT,
OCS_HW_PORT_SHUTDOWN,
OCS_HW_PORT_SET_LINK_CONFIG,
} ocs_hw_port_e;
/**
* @brief Fabric/Domain events
*/
typedef enum {
OCS_HW_DOMAIN_ALLOC_OK, /**< domain successfully allocated */
OCS_HW_DOMAIN_ALLOC_FAIL, /**< domain allocation failed */
OCS_HW_DOMAIN_ATTACH_OK, /**< successfully attached to domain */
OCS_HW_DOMAIN_ATTACH_FAIL, /**< domain attach failed */
OCS_HW_DOMAIN_FREE_OK, /**< successfully freed domain */
OCS_HW_DOMAIN_FREE_FAIL, /**< domain free failed */
OCS_HW_DOMAIN_LOST, /**< previously discovered domain no longer available */
OCS_HW_DOMAIN_FOUND, /**< new domain discovered */
OCS_HW_DOMAIN_CHANGED, /**< previously discovered domain properties have changed */
} ocs_hw_domain_event_e;
typedef enum {
OCS_HW_PORT_ALLOC_OK, /**< port successfully allocated */
OCS_HW_PORT_ALLOC_FAIL, /**< port allocation failed */
OCS_HW_PORT_ATTACH_OK, /**< successfully attached to port */
OCS_HW_PORT_ATTACH_FAIL, /**< port attach failed */
OCS_HW_PORT_FREE_OK, /**< successfully freed port */
OCS_HW_PORT_FREE_FAIL, /**< port free failed */
} ocs_hw_port_event_e;
typedef enum {
OCS_HW_NODE_ATTACH_OK,
OCS_HW_NODE_ATTACH_FAIL,
OCS_HW_NODE_FREE_OK,
OCS_HW_NODE_FREE_FAIL,
OCS_HW_NODE_FREE_ALL_OK,
OCS_HW_NODE_FREE_ALL_FAIL,
} ocs_hw_remote_node_event_e;
typedef enum {
OCS_HW_CB_DOMAIN,
OCS_HW_CB_PORT,
OCS_HW_CB_REMOTE_NODE,
OCS_HW_CB_UNSOLICITED,
OCS_HW_CB_BOUNCE,
OCS_HW_CB_MAX, /**< must be last */
} ocs_hw_callback_e;
/**
* @brief HW unsolicited callback status
*/
typedef enum {
OCS_HW_UNSOL_SUCCESS,
OCS_HW_UNSOL_ERROR,
OCS_HW_UNSOL_ABTS_RCVD,
OCS_HW_UNSOL_MAX, /**< must be last */
} ocs_hw_unsol_status_e;
/**
* @brief Node group rpi reference
*/
typedef struct {
ocs_atomic_t rpi_count;
ocs_atomic_t rpi_attached;
} ocs_hw_rpi_ref_t;
/**
* @brief HW link stat types
*/
typedef enum {
OCS_HW_LINK_STAT_LINK_FAILURE_COUNT,
OCS_HW_LINK_STAT_LOSS_OF_SYNC_COUNT,
OCS_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT,
OCS_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT,
OCS_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT,
OCS_HW_LINK_STAT_CRC_COUNT,
OCS_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT,
OCS_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT,
OCS_HW_LINK_STAT_ARB_TIMEOUT_COUNT,
OCS_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT,
OCS_HW_LINK_STAT_CURR_RCV_B2B_CREDIT,
OCS_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT,
OCS_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT,
OCS_HW_LINK_STAT_RCV_EOFA_COUNT,
OCS_HW_LINK_STAT_RCV_EOFDTI_COUNT,
OCS_HW_LINK_STAT_RCV_EOFNI_COUNT,
OCS_HW_LINK_STAT_RCV_SOFF_COUNT,
OCS_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT,
OCS_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT,
OCS_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT,
OCS_HW_LINK_STAT_MAX, /**< must be last */
} ocs_hw_link_stat_e;
typedef enum {
OCS_HW_HOST_STAT_TX_KBYTE_COUNT,
OCS_HW_HOST_STAT_RX_KBYTE_COUNT,
OCS_HW_HOST_STAT_TX_FRAME_COUNT,
OCS_HW_HOST_STAT_RX_FRAME_COUNT,
OCS_HW_HOST_STAT_TX_SEQ_COUNT,
OCS_HW_HOST_STAT_RX_SEQ_COUNT,
OCS_HW_HOST_STAT_TOTAL_EXCH_ORIG,
OCS_HW_HOST_STAT_TOTAL_EXCH_RESP,
OCS_HW_HOSY_STAT_RX_P_BSY_COUNT,
OCS_HW_HOST_STAT_RX_F_BSY_COUNT,
OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_RQ_BUF_COUNT,
OCS_HW_HOST_STAT_EMPTY_RQ_TIMEOUT_COUNT,
OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_XRI_COUNT,
OCS_HW_HOST_STAT_EMPTY_XRI_POOL_COUNT,
OCS_HW_HOST_STAT_MAX /* MUST BE LAST */
} ocs_hw_host_stat_e;
typedef enum {
OCS_HW_STATE_UNINITIALIZED, /* power-on, no allocations, no initializations */
OCS_HW_STATE_QUEUES_ALLOCATED, /* chip is reset, allocations are complete (queues not registered) */
OCS_HW_STATE_ACTIVE, /* chip is up an running */
OCS_HW_STATE_RESET_IN_PROGRESS, /* chip is being reset */
OCS_HW_STATE_TEARDOWN_IN_PROGRESS, /* teardown has been started */
} ocs_hw_state_e;
/**
* @brief Defines a general FC sequence object, consisting of a header, payload buffers
* and a HW IO in the case of port owned XRI
*/
typedef struct {
ocs_hw_t *hw; /**< HW that owns this sequence */
/* sequence information */
uint8_t fcfi; /**< FCFI associated with sequence */
uint8_t auto_xrdy; /**< If auto XFER_RDY was generated */
uint8_t out_of_xris; /**< If IO would have been assisted if XRIs were available */
ocs_hw_rq_buffer_t *header;
ocs_hw_rq_buffer_t *payload; /**< received frame payload buffer */
/* other "state" information from the SRB (sequence coalescing) */
ocs_hw_unsol_status_e status;
uint32_t xri; /**< XRI associated with sequence; sequence coalescing only */
ocs_hw_io_t *hio; /**< HW IO */
ocs_list_link_t link;
void *hw_priv; /**< HW private context */
} ocs_hw_sequence_t;
/**
* @brief Structure to track optimized write buffers posted to chip owned XRIs.
*
* Note: The rqindex will be set the following "fake" indexes. This will be used
* when the buffer is returned via ocs_seq_free() to make the buffer available
* for re-use on another XRI.
*
* The dma->alloc pointer on the dummy header will be used to get back to this structure when the buffer is freed.
*
* More of these object may be allocated on the fly if more XRIs are pushed to the chip.
*/
#define OCS_HW_RQ_INDEX_DUMMY_HDR 0xFF00
#define OCS_HW_RQ_INDEX_DUMMY_DATA 0xFF01
typedef struct ocs_hw_auto_xfer_rdy_buffer_s {
fc_header_t hdr; /**< used to build a dummy data header for unsolicited processing */
ocs_hw_rq_buffer_t header; /**< Points to the dummy data header */
ocs_hw_rq_buffer_t payload; /**< received frame payload buffer */
ocs_hw_sequence_t seq; /**< sequence for passing the buffers */
uint8_t data_cqe;
uint8_t cmd_cqe;
/* fields saved from the command header that are needed when the data arrives */
uint8_t fcfi;
/* To handle outof order completions save AXR cmd and data cqes */
uint8_t call_axr_cmd;
uint8_t call_axr_data;
ocs_hw_sequence_t *cmd_seq;
} ocs_hw_auto_xfer_rdy_buffer_t;
/**
* @brief Node group rpi reference
*/
typedef struct {
uint8_t overflow;
uint32_t counter;
} ocs_hw_link_stat_counts_t;
/**
* @brief HW object describing fc host stats
*/
typedef struct {
uint32_t counter;
} ocs_hw_host_stat_counts_t;
#define TID_HASH_BITS 8
#define TID_HASH_LEN (1U << TID_HASH_BITS)
typedef struct ocs_hw_iopt_s {
char name[32];
uint32_t instance_index;
ocs_thread_t iopt_thread;
ocs_cbuf_t *iopt_free_queue; /* multiple reader, multiple writer */
ocs_cbuf_t *iopt_work_queue;
ocs_array_t *iopt_cmd_array;
} ocs_hw_iopt_t;
typedef enum {
HW_CQ_HANDLER_LOCAL,
HW_CQ_HANDLER_THREAD,
} hw_cq_handler_e;
#include "ocs_hw_queues.h"
/**
* @brief Stucture used for the hash lookup of queue IDs
*/
typedef struct {
uint32_t id:16,
in_use:1,
index:15;
} ocs_queue_hash_t;
/**
* @brief Define the fields required to implement the skyhawk DIF quarantine.
*/
#define OCS_HW_QUARANTINE_QUEUE_DEPTH 4
typedef struct {
uint32_t quarantine_index;
ocs_hw_io_t *quarantine_ios[OCS_HW_QUARANTINE_QUEUE_DEPTH];
} ocs_quarantine_info_t;
/**
* @brief Define the WQ callback object
*/
typedef struct {
uint16_t instance_index; /**< use for request tag */
void (*callback)(void *arg, uint8_t *cqe, int32_t status);
void *arg;
} hw_wq_callback_t;
typedef struct {
uint64_t fwrev;
/* Control Declarations here ...*/
uint8_t retain_tsend_io_length;
/* Use unregistered RPI */
uint8_t use_unregistered_rpi;
uint32_t unregistered_rid;
uint32_t unregistered_index;
uint8_t disable_ar_tgt_dif; /* Disable auto response if target DIF */
uint8_t disable_dump_loc;
uint8_t use_dif_quarantine;
uint8_t use_dif_sec_xri;
uint8_t override_fcfi;
uint8_t fw_version_too_low;
uint8_t sglc_misreported;
uint8_t ignore_send_frame;
} ocs_hw_workaround_t;
/**
* @brief HW object
*/
struct ocs_hw_s {
ocs_os_handle_t os;
sli4_t sli;
uint16_t ulp_start;
uint16_t ulp_max;
uint32_t dump_size;
ocs_hw_state_e state;
uint8_t hw_setup_called;
uint8_t sliport_healthcheck;
uint16_t watchdog_timeout;
ocs_lock_t watchdog_lock;
/** HW configuration, subject to ocs_hw_set() */
struct {
uint32_t n_eq; /**< number of event queues */
uint32_t n_cq; /**< number of completion queues */
uint32_t n_mq; /**< number of mailbox queues */
uint32_t n_rq; /**< number of receive queues */
uint32_t n_wq; /**< number of work queues */
uint32_t n_io; /**< total number of IO objects */
uint32_t n_sgl;/**< length of SGL */
uint32_t speed; /** requested link speed in Mbps */
uint32_t topology; /** requested link topology */
uint32_t rq_default_buffer_size; /** size of the buffers for first burst */
uint32_t auto_xfer_rdy_xri_cnt; /** Initial XRIs to post to chip at initialization */
uint32_t auto_xfer_rdy_size; /** max size IO to use with this feature */
uint8_t auto_xfer_rdy_blk_size_chip; /** block size to use with this feature */
uint8_t esoc;
uint16_t dif_seed; /** The seed for the DIF CRC calculation */
uint16_t auto_xfer_rdy_app_tag_value;
uint8_t dif_mode; /**< DIF mode to use */
uint8_t i_only_aab; /** Enable initiator-only auto-abort */
uint8_t emulate_wqe_timeout; /** Enable driver wqe timeouts */
uint32_t bounce:1;
const char *queue_topology; /**< Queue topology string */
uint8_t auto_xfer_rdy_t10_enable; /** Enable t10 PI for auto xfer ready */
uint8_t auto_xfer_rdy_p_type; /** p_type for auto xfer ready */
uint8_t auto_xfer_rdy_ref_tag_is_lba;
uint8_t auto_xfer_rdy_app_tag_valid;
uint8_t rq_selection_policy; /** MRQ RQ selection policy */
uint8_t rr_quanta; /** RQ quanta if rq_selection_policy == 2 */
uint32_t filter_def[SLI4_CMD_REG_FCFI_NUM_RQ_CFG];
} config;
/* calculated queue sizes for each type */
uint32_t num_qentries[SLI_QTYPE_MAX];
/* Storage for SLI queue objects */
sli4_queue_t wq[OCS_HW_MAX_NUM_WQ];
sli4_queue_t rq[OCS_HW_MAX_NUM_RQ];
uint16_t hw_rq_lookup[OCS_HW_MAX_NUM_RQ];
sli4_queue_t mq[OCS_HW_MAX_NUM_MQ];
sli4_queue_t cq[OCS_HW_MAX_NUM_CQ];
sli4_queue_t eq[OCS_HW_MAX_NUM_EQ];
/* HW queue */
uint32_t eq_count;
uint32_t cq_count;
uint32_t mq_count;
uint32_t wq_count;
uint32_t rq_count; /**< count of SLI RQs */
ocs_list_t eq_list;
ocs_queue_hash_t cq_hash[OCS_HW_Q_HASH_SIZE];
ocs_queue_hash_t rq_hash[OCS_HW_Q_HASH_SIZE];
ocs_queue_hash_t wq_hash[OCS_HW_Q_HASH_SIZE];
/* Storage for HW queue objects */
hw_wq_t *hw_wq[OCS_HW_MAX_NUM_WQ];
hw_rq_t *hw_rq[OCS_HW_MAX_NUM_RQ];
hw_mq_t *hw_mq[OCS_HW_MAX_NUM_MQ];
hw_cq_t *hw_cq[OCS_HW_MAX_NUM_CQ];
hw_eq_t *hw_eq[OCS_HW_MAX_NUM_EQ];
uint32_t hw_rq_count; /**< count of hw_rq[] entries */
uint32_t hw_mrq_count; /**< count of multirq RQs */
ocs_varray_t *wq_class_array[OCS_HW_MAX_WQ_CLASS]; /**< pool per class WQs */
ocs_varray_t *wq_cpu_array[OCS_HW_MAX_WQ_CPU]; /**< pool per CPU WQs */
/* Sequence objects used in incoming frame processing */
ocs_array_t *seq_pool;
/* Auto XFER RDY Buffers - protect with io_lock */
uint32_t auto_xfer_rdy_enabled:1, /**< TRUE if auto xfer rdy is enabled */
:31;
ocs_pool_t *auto_xfer_rdy_buf_pool; /**< pool of ocs_hw_auto_xfer_rdy_buffer_t objects */
/** Maintain an ordered, linked list of outstanding HW commands. */
ocs_lock_t cmd_lock;
ocs_list_t cmd_head;
ocs_list_t cmd_pending;
uint32_t cmd_head_count;
sli4_link_event_t link;
ocs_hw_linkcfg_e linkcfg; /**< link configuration setting */
uint32_t eth_license; /**< Ethernet license; to enable FCoE on Lancer */
struct {
/**
* Function + argument used to notify upper layer of domain events.
*
* The final argument to the callback is a generic data pointer:
* - ocs_domain_record_t on OCS_HW_DOMAIN_FOUND
* - ocs_domain_t on OCS_HW_DOMAIN_ALLOC_FAIL, OCS_HW_DOMAIN_ALLOC_OK,
* OCS_HW_DOMAIN_FREE_FAIL, OCS_HW_DOMAIN_FREE_OK,
* OCS_HW_DOMAIN_ATTACH_FAIL, OCS_HW_DOMAIN_ATTACH_OK, and
* OCS_HW_DOMAIN_LOST.
*/
int32_t (*domain)(void *, ocs_hw_domain_event_e, void *);
/**
* Function + argument used to notify upper layers of port events.
*
* The final argument to the callback is a pointer to the effected
* SLI port for all events.
*/
int32_t (*port)(void *, ocs_hw_port_event_e, void *);
/** Function + argument used to announce arrival of unsolicited frames */
int32_t (*unsolicited)(void *, ocs_hw_sequence_t *);
int32_t (*rnode)(void *, ocs_hw_remote_node_event_e, void *);
int32_t (*bounce)(void (*)(void *arg), void *arg, uint32_t s_id, uint32_t d_id, uint32_t ox_id);
} callback;
struct {
void *domain;
void *port;
void *unsolicited;
void *rnode;
void *bounce;
} args;
/* OCS domain objects index by FCFI */
int32_t first_domain_idx; /* Workaround for srb->fcfi == 0 */
ocs_domain_t *domains[SLI4_MAX_FCFI];
/* Table of FCFI values index by FCF_index */
uint16_t fcf_index_fcfi[SLI4_MAX_FCF_INDEX];
uint16_t fcf_indicator;
ocs_hw_io_t **io; /**< pointer array of IO objects */
uint8_t *wqe_buffs; /**< array of WQE buffs mapped to IO objects */
ocs_lock_t io_lock; /**< IO lock to synchronize list access */
ocs_lock_t io_abort_lock; /**< IO lock to synchronize IO aborting */
ocs_list_t io_inuse; /**< List of IO objects in use */
ocs_list_t io_timed_wqe; /**< List of IO objects with a timed target WQE */
ocs_list_t io_wait_free; /**< List of IO objects waiting to be freed */
ocs_list_t io_free; /**< List of IO objects available for allocation */
ocs_list_t io_port_owned; /**< List of IO objects posted for chip use */
ocs_list_t io_port_dnrx; /**< List of IO objects needing auto xfer rdy buffers */
ocs_dma_t loop_map;
ocs_dma_t xfer_rdy;
ocs_dma_t dump_sges;
ocs_dma_t rnode_mem;
ocs_dma_t domain_dmem; /*domain dma mem for service params */
ocs_dma_t fcf_dmem; /*dma men for fcf */
ocs_hw_rpi_ref_t *rpi_ref;
char *hw_war_version;
ocs_hw_workaround_t workaround;
ocs_atomic_t io_alloc_failed_count;
#if defined(OCS_DEBUG_QUEUE_HISTORY)
ocs_hw_q_hist_t q_hist;
#endif
ocs_list_t sec_hio_wait_list; /**< BZ 161832 Workaround: Secondary HW IO context wait list */
uint32_t sec_hio_wait_count; /**< BZ 161832 Workaround: Count of IOs that were put on the
* Secondary HW IO wait list
*/
#define HW_MAX_TCMD_THREADS 16
ocs_hw_qtop_t *qtop; /**< pointer to queue topology */
uint32_t tcmd_wq_submit[OCS_HW_MAX_NUM_WQ]; /**< stat: wq sumbit count */
uint32_t tcmd_wq_complete[OCS_HW_MAX_NUM_WQ]; /**< stat: wq complete count */
ocs_timer_t wqe_timer; /**< Timer to periodically check for WQE timeouts */
ocs_timer_t watchdog_timer; /**< Timer for heartbeat */
bool expiration_logged;
uint32_t in_active_wqe_timer:1, /**< TRUE if currently in active wqe timer handler */
active_wqe_timer_shutdown:1, /** TRUE if wqe timer is to be shutdown */
:30;
ocs_list_t iopc_list; /**< list of IO processing contexts */
ocs_lock_t iopc_list_lock; /**< lock for iopc_list */
ocs_pool_t *wq_reqtag_pool; /**< pool of hw_wq_callback_t objects */
ocs_atomic_t send_frame_seq_id; /**< send frame sequence ID */
};
typedef enum {
OCS_HW_IO_INUSE_COUNT,
OCS_HW_IO_FREE_COUNT,
OCS_HW_IO_WAIT_FREE_COUNT,
OCS_HW_IO_PORT_OWNED_COUNT,
OCS_HW_IO_N_TOTAL_IO_COUNT,
} ocs_hw_io_count_type_e;
typedef void (*tcmd_cq_handler)(ocs_hw_t *hw, uint32_t cq_idx, void *cq_handler_arg);
/*
* HW queue data structures
*/
struct hw_eq_s {
ocs_list_link_t link; /**< must be first */
sli4_qtype_e type; /**< must be second */
uint32_t instance;
uint32_t entry_count;
uint32_t entry_size;
ocs_hw_t *hw;
sli4_queue_t *queue;
ocs_list_t cq_list;
#if OCS_STAT_ENABLE
uint32_t use_count;
#endif
ocs_varray_t *wq_array; /*<< array of WQs */
};
struct hw_cq_s {
ocs_list_link_t link; /*<< must be first */
sli4_qtype_e type; /**< must be second */
uint32_t instance; /*<< CQ instance (cq_idx) */
uint32_t entry_count; /*<< Number of entries */
uint32_t entry_size; /*<< entry size */
hw_eq_t *eq; /*<< parent EQ */
sli4_queue_t *queue; /**< pointer to SLI4 queue */
ocs_list_t q_list; /**< list of children queues */
#if OCS_STAT_ENABLE
uint32_t use_count;
#endif
};
typedef struct {
ocs_list_link_t link; /*<< must be first */
sli4_qtype_e type; /*<< must be second */
} hw_q_t;
struct hw_mq_s {
ocs_list_link_t link; /*<< must be first */
sli4_qtype_e type; /*<< must be second */
uint32_t instance;
uint32_t entry_count;
uint32_t entry_size;
hw_cq_t *cq;
sli4_queue_t *queue;
#if OCS_STAT_ENABLE
uint32_t use_count;
#endif
};
struct hw_wq_s {
ocs_list_link_t link; /*<< must be first */
sli4_qtype_e type; /*<< must be second */
uint32_t instance;
ocs_hw_t *hw;
uint32_t entry_count;
uint32_t entry_size;
hw_cq_t *cq;
sli4_queue_t *queue;
uint32_t class;
uint8_t ulp;
/* WQ consumed */
uint32_t wqec_set_count; /*<< how often IOs are submitted with wqce set */
uint32_t wqec_count; /*<< current wqce counter */
uint32_t free_count; /*<< free count */
uint32_t total_submit_count; /*<< total submit count */
ocs_list_t pending_list; /*<< list of IOs pending for this WQ */
/*
* ---Skyhawk only ---
* BZ 160124 - Driver must quarantine XRIs for target writes and
* initiator read when using DIF separates. Throw them on a
* queue until another 4 similar requests are completed to ensure they
* are flushed from the internal chip cache before being re-used.
* The must be a separate queue per CQ because the actual chip completion
* order cannot be determined. Since each WQ has a separate CQ, use the wq
* associated with the IO.
*
* Note: Protected by queue->lock
*/
ocs_quarantine_info_t quarantine_info;
/*
* HW IO allocated for use with Send Frame
*/
ocs_hw_io_t *send_frame_io;
/* Stats */
#if OCS_STAT_ENABLE
uint32_t use_count; /*<< use count */
uint32_t wq_pending_count; /*<< count of HW IOs that were queued on the WQ pending list */
#endif
};
struct hw_rq_s {
ocs_list_link_t link; /*<< must be first */
sli4_qtype_e type; /*<< must be second */
uint32_t instance;
uint32_t entry_count;
uint32_t hdr_entry_size;
uint32_t first_burst_entry_size;
uint32_t data_entry_size;
uint8_t ulp;
bool is_mrq;
uint32_t base_mrq_id;
hw_cq_t *cq;
uint8_t filter_mask; /* Filter mask value */
sli4_queue_t *hdr;
sli4_queue_t *first_burst;
sli4_queue_t *data;
ocs_hw_rq_buffer_t *hdr_buf;
ocs_hw_rq_buffer_t *fb_buf;
ocs_hw_rq_buffer_t *payload_buf;
ocs_hw_sequence_t **rq_tracker; /* RQ tracker for this RQ */
#if OCS_STAT_ENABLE
uint32_t use_count;
uint32_t hdr_use_count;
uint32_t fb_use_count;
uint32_t payload_use_count;
#endif
};
typedef struct ocs_hw_global_s {
const char *queue_topology_string; /**< queue topology string */
} ocs_hw_global_t;
extern ocs_hw_global_t hw_global;
extern hw_eq_t *hw_new_eq(ocs_hw_t *hw, uint32_t entry_count);
extern hw_cq_t *hw_new_cq(hw_eq_t *eq, uint32_t entry_count);
extern uint32_t hw_new_cq_set(hw_eq_t *eqs[], hw_cq_t *cqs[], uint32_t num_cqs, uint32_t entry_count);
extern hw_mq_t *hw_new_mq(hw_cq_t *cq, uint32_t entry_count);
extern hw_wq_t *hw_new_wq(hw_cq_t *cq, uint32_t entry_count, uint32_t class, uint32_t ulp);
extern hw_rq_t *hw_new_rq(hw_cq_t *cq, uint32_t entry_count, uint32_t ulp);
extern uint32_t hw_new_rq_set(hw_cq_t *cqs[], hw_rq_t *rqs[], uint32_t num_rq_pairs, uint32_t entry_count, uint32_t ulp);
extern void hw_del_eq(hw_eq_t *eq);
extern void hw_del_cq(hw_cq_t *cq);
extern void hw_del_mq(hw_mq_t *mq);
extern void hw_del_wq(hw_wq_t *wq);
extern void hw_del_rq(hw_rq_t *rq);
extern void hw_queue_dump(ocs_hw_t *hw);
extern void hw_queue_teardown(ocs_hw_t *hw);
extern int32_t hw_route_rqe(ocs_hw_t *hw, ocs_hw_sequence_t *seq);
extern int32_t ocs_hw_queue_hash_find(ocs_queue_hash_t *, uint16_t);
extern ocs_hw_rtn_e ocs_hw_setup(ocs_hw_t *, ocs_os_handle_t, sli4_port_type_e);
extern ocs_hw_rtn_e ocs_hw_init(ocs_hw_t *);
extern ocs_hw_rtn_e ocs_hw_teardown(ocs_hw_t *);
extern ocs_hw_rtn_e ocs_hw_reset(ocs_hw_t *, ocs_hw_reset_e);
extern int32_t ocs_hw_get_num_eq(ocs_hw_t *);
extern ocs_hw_rtn_e ocs_hw_get(ocs_hw_t *, ocs_hw_property_e, uint32_t *);
extern void *ocs_hw_get_ptr(ocs_hw_t *, ocs_hw_property_e);
extern ocs_hw_rtn_e ocs_hw_set(ocs_hw_t *, ocs_hw_property_e, uint32_t);
extern ocs_hw_rtn_e ocs_hw_set_ptr(ocs_hw_t *, ocs_hw_property_e, void*);
extern int32_t ocs_hw_event_check(ocs_hw_t *, uint32_t);
extern int32_t ocs_hw_process(ocs_hw_t *, uint32_t, uint32_t);
extern ocs_hw_rtn_e ocs_hw_command(ocs_hw_t *, uint8_t *, uint32_t, void *, void *);
extern ocs_hw_rtn_e ocs_hw_callback(ocs_hw_t *, ocs_hw_callback_e, void *, void *);
extern ocs_hw_rtn_e ocs_hw_port_alloc(ocs_hw_t *, ocs_sli_port_t *, ocs_domain_t *, uint8_t *);
extern ocs_hw_rtn_e ocs_hw_port_attach(ocs_hw_t *, ocs_sli_port_t *, uint32_t);
typedef void (*ocs_hw_port_control_cb_t)(int32_t status, uintptr_t value, void *arg);
extern ocs_hw_rtn_e ocs_hw_port_control(ocs_hw_t *, ocs_hw_port_e, uintptr_t, ocs_hw_port_control_cb_t, void *);
extern ocs_hw_rtn_e ocs_hw_port_free(ocs_hw_t *, ocs_sli_port_t *);
extern ocs_hw_rtn_e ocs_hw_domain_alloc(ocs_hw_t *, ocs_domain_t *, uint32_t, uint32_t);
extern ocs_hw_rtn_e ocs_hw_domain_attach(ocs_hw_t *, ocs_domain_t *, uint32_t);
extern ocs_hw_rtn_e ocs_hw_domain_free(ocs_hw_t *, ocs_domain_t *);
extern ocs_hw_rtn_e ocs_hw_domain_force_free(ocs_hw_t *, ocs_domain_t *);
extern ocs_domain_t * ocs_hw_domain_get(ocs_hw_t *, uint16_t);
extern ocs_hw_rtn_e ocs_hw_node_alloc(ocs_hw_t *, ocs_remote_node_t *, uint32_t, ocs_sli_port_t *);
extern ocs_hw_rtn_e ocs_hw_node_free_all(ocs_hw_t *);
extern ocs_hw_rtn_e ocs_hw_node_attach(ocs_hw_t *, ocs_remote_node_t *, ocs_dma_t *);
extern ocs_hw_rtn_e ocs_hw_node_detach(ocs_hw_t *, ocs_remote_node_t *);
extern ocs_hw_rtn_e ocs_hw_node_free_resources(ocs_hw_t *, ocs_remote_node_t *);
extern ocs_hw_rtn_e ocs_hw_node_group_alloc(ocs_hw_t *, ocs_remote_node_group_t *);
extern ocs_hw_rtn_e ocs_hw_node_group_attach(ocs_hw_t *, ocs_remote_node_group_t *, ocs_remote_node_t *);
extern ocs_hw_rtn_e ocs_hw_node_group_free(ocs_hw_t *, ocs_remote_node_group_t *);
extern ocs_hw_io_t *ocs_hw_io_alloc(ocs_hw_t *);
extern ocs_hw_io_t *ocs_hw_io_activate_port_owned(ocs_hw_t *, ocs_hw_io_t *);
extern int32_t ocs_hw_io_free(ocs_hw_t *, ocs_hw_io_t *);
extern uint8_t ocs_hw_io_inuse(ocs_hw_t *hw, ocs_hw_io_t *io);
typedef int32_t (*ocs_hw_srrs_cb_t)(ocs_hw_io_t *io, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *arg);
extern ocs_hw_rtn_e ocs_hw_srrs_send(ocs_hw_t *, ocs_hw_io_type_e, ocs_hw_io_t *, ocs_dma_t *, uint32_t, ocs_dma_t *, ocs_remote_node_t *, ocs_hw_io_param_t *, ocs_hw_srrs_cb_t, void *);
extern ocs_hw_rtn_e ocs_hw_io_send(ocs_hw_t *, ocs_hw_io_type_e, ocs_hw_io_t *, uint32_t, ocs_hw_io_param_t *, ocs_remote_node_t *, void *, void *);
extern ocs_hw_rtn_e _ocs_hw_io_send(ocs_hw_t *hw, ocs_hw_io_type_e type, ocs_hw_io_t *io,
uint32_t len, ocs_hw_io_param_t *iparam, ocs_remote_node_t *rnode,
void *cb, void *arg);
extern ocs_hw_rtn_e ocs_hw_io_register_sgl(ocs_hw_t *, ocs_hw_io_t *, ocs_dma_t *, uint32_t);
extern ocs_hw_rtn_e ocs_hw_io_init_sges(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_io_type_e type);
extern ocs_hw_rtn_e ocs_hw_io_add_seed_sge(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_dif_info_t *dif_info);
extern ocs_hw_rtn_e ocs_hw_io_add_sge(ocs_hw_t *, ocs_hw_io_t *, uintptr_t, uint32_t);
extern ocs_hw_rtn_e ocs_hw_io_add_dif_sge(ocs_hw_t *hw, ocs_hw_io_t *io, uintptr_t addr);
extern ocs_hw_rtn_e ocs_hw_io_abort(ocs_hw_t *, ocs_hw_io_t *, uint32_t, void *, void *);
extern int32_t ocs_hw_io_get_xid(ocs_hw_t *, ocs_hw_io_t *);
extern uint32_t ocs_hw_io_get_count(ocs_hw_t *, ocs_hw_io_count_type_e);
extern uint32_t ocs_hw_get_rqes_produced_count(ocs_hw_t *hw);
typedef void (*ocs_hw_fw_cb_t)(int32_t status, uint32_t bytes_written, uint32_t change_status, void *arg);
extern ocs_hw_rtn_e ocs_hw_firmware_write(ocs_hw_t *, ocs_dma_t *, uint32_t, uint32_t, int, ocs_hw_fw_cb_t, void*);
/* Function for retrieving SFP data */
typedef void (*ocs_hw_sfp_cb_t)(void *, int32_t, uint32_t, uint32_t *, void *);
extern ocs_hw_rtn_e ocs_hw_get_sfp(ocs_hw_t *, uint16_t, ocs_hw_sfp_cb_t, void *);
/* Function for retrieving temperature data */
typedef void (*ocs_hw_temp_cb_t)(int32_t status,
uint32_t curr_temp,
uint32_t crit_temp_thrshld,
uint32_t warn_temp_thrshld,
uint32_t norm_temp_thrshld,
uint32_t fan_off_thrshld,
uint32_t fan_on_thrshld,
void *arg);
extern ocs_hw_rtn_e ocs_hw_get_temperature(ocs_hw_t *, ocs_hw_temp_cb_t, void*);
/* Function for retrieving link statistics */
typedef void (*ocs_hw_link_stat_cb_t)(int32_t status,
uint32_t num_counters,
ocs_hw_link_stat_counts_t *counters,
void *arg);
extern ocs_hw_rtn_e ocs_hw_get_link_stats(ocs_hw_t *,
uint8_t req_ext_counters,
uint8_t clear_overflow_flags,
uint8_t clear_all_counters,
ocs_hw_link_stat_cb_t, void*);
/* Function for retrieving host statistics */
typedef void (*ocs_hw_host_stat_cb_t)(int32_t status,
uint32_t num_counters,
ocs_hw_host_stat_counts_t *counters,
void *arg);
extern ocs_hw_rtn_e ocs_hw_get_host_stats(ocs_hw_t *hw, uint8_t cc, ocs_hw_host_stat_cb_t, void *arg);
extern ocs_hw_rtn_e ocs_hw_raise_ue(ocs_hw_t *, uint8_t);
typedef void (*ocs_hw_dump_get_cb_t)(int32_t status, uint32_t bytes_read, uint8_t eof, void *arg);
extern ocs_hw_rtn_e ocs_hw_dump_get(ocs_hw_t *, ocs_dma_t *, uint32_t, uint32_t, ocs_hw_dump_get_cb_t, void *);
extern ocs_hw_rtn_e ocs_hw_set_dump_location(ocs_hw_t *, uint32_t, ocs_dma_t *, uint8_t);
typedef void (*ocs_get_port_protocol_cb_t)(int32_t status, ocs_hw_port_protocol_e port_protocol, void *arg);
extern ocs_hw_rtn_e ocs_hw_get_port_protocol(ocs_hw_t *hw, uint32_t pci_func, ocs_get_port_protocol_cb_t mgmt_cb, void* ul_arg);
typedef void (*ocs_set_port_protocol_cb_t)(int32_t status, void *arg);
extern ocs_hw_rtn_e ocs_hw_set_port_protocol(ocs_hw_t *hw, ocs_hw_port_protocol_e profile,
uint32_t pci_func, ocs_set_port_protocol_cb_t mgmt_cb,
void* ul_arg);
typedef void (*ocs_get_profile_list_cb_t)(int32_t status, ocs_hw_profile_list_t*, void *arg);
extern ocs_hw_rtn_e ocs_hw_get_profile_list(ocs_hw_t *hw, ocs_get_profile_list_cb_t mgmt_cb, void *arg);
typedef void (*ocs_get_active_profile_cb_t)(int32_t status, uint32_t active_profile, void *arg);
extern ocs_hw_rtn_e ocs_hw_get_active_profile(ocs_hw_t *hw, ocs_get_active_profile_cb_t mgmt_cb, void *arg);
typedef void (*ocs_set_active_profile_cb_t)(int32_t status, void *arg);
extern ocs_hw_rtn_e ocs_hw_set_active_profile(ocs_hw_t *hw, ocs_set_active_profile_cb_t mgmt_cb,
uint32_t profile_id, void *arg);
typedef void (*ocs_get_nvparms_cb_t)(int32_t status, uint8_t *wwpn, uint8_t *wwnn, uint8_t hard_alpa,
uint32_t preferred_d_id, void *arg);
extern ocs_hw_rtn_e ocs_hw_get_nvparms(ocs_hw_t *hw, ocs_get_nvparms_cb_t mgmt_cb, void *arg);
typedef void (*ocs_set_nvparms_cb_t)(int32_t status, void *arg);
extern ocs_hw_rtn_e ocs_hw_set_nvparms(ocs_hw_t *hw, ocs_set_nvparms_cb_t mgmt_cb, uint8_t *wwpn,
uint8_t *wwnn, uint8_t hard_alpa, uint32_t preferred_d_id, void *arg);
extern int32_t ocs_hw_eq_process(ocs_hw_t *hw, hw_eq_t *eq, uint32_t max_isr_time_msec);
extern void ocs_hw_cq_process(ocs_hw_t *hw, hw_cq_t *cq);
extern void ocs_hw_wq_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, int32_t status, uint16_t rid);
extern void ocs_hw_xabt_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, uint16_t rid);
extern int32_t hw_wq_write(hw_wq_t *wq, ocs_hw_wqe_t *wqe);
typedef void (*ocs_hw_dump_clear_cb_t)(int32_t status, void *arg);
extern ocs_hw_rtn_e ocs_hw_dump_clear(ocs_hw_t *, ocs_hw_dump_clear_cb_t, void *);
extern uint8_t ocs_hw_is_io_port_owned(ocs_hw_t *hw, ocs_hw_io_t *io);
extern uint8_t ocs_hw_is_xri_port_owned(ocs_hw_t *hw, uint32_t xri);
extern ocs_hw_io_t * ocs_hw_io_lookup(ocs_hw_t *hw, uint32_t indicator);
extern uint32_t ocs_hw_xri_move_to_port_owned(ocs_hw_t *hw, uint32_t num_xri);
extern ocs_hw_rtn_e ocs_hw_xri_move_to_host_owned(ocs_hw_t *hw, uint8_t num_xri);
extern int32_t ocs_hw_reque_xri(ocs_hw_t *hw, ocs_hw_io_t *io);
ocs_hw_rtn_e ocs_hw_set_persistent_topology(ocs_hw_t *hw, uint32_t topology, uint32_t opts);
extern uint32_t ocs_hw_get_config_persistent_topology(ocs_hw_t *hw);
typedef struct {
/* structure elements used by HW */
ocs_hw_t *hw; /**> pointer to HW */
hw_wq_callback_t *wqcb; /**> WQ callback object, request tag */
ocs_hw_wqe_t wqe; /**> WQE buffer object (may be queued on WQ pending list) */
void (*callback)(int32_t status, void *arg); /**> final callback function */
void *arg; /**> final callback argument */
/* General purpose elements */
ocs_hw_sequence_t *seq;
ocs_dma_t payload; /**> a payload DMA buffer */
} ocs_hw_send_frame_context_t;
#define OCS_HW_OBJECT_G5 0xfeaa0001
#define OCS_HW_OBJECT_G6 0xfeaa0003
#define OCS_FILE_TYPE_GROUP 0xf7
#define OCS_FILE_ID_GROUP 0xa2
struct ocs_hw_grp_hdr {
uint32_t size;
uint32_t magic_number;
uint32_t word2;
uint8_t rev_name[128];
uint8_t date[12];
uint8_t revision[32];
};
ocs_hw_rtn_e
ocs_hw_send_frame(ocs_hw_t *hw, fc_header_le_t *hdr, uint8_t sof, uint8_t eof, ocs_dma_t *payload,
ocs_hw_send_frame_context_t *ctx,
void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg);
/* RQ completion handlers for RQ pair mode */
extern int32_t ocs_hw_rqpair_process_rq(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe);
extern ocs_hw_rtn_e ocs_hw_rqpair_sequence_free(ocs_hw_t *hw, ocs_hw_sequence_t *seq);
extern int32_t ocs_hw_rqpair_process_auto_xfr_rdy_cmd(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe);
extern int32_t ocs_hw_rqpair_process_auto_xfr_rdy_data(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe);
extern ocs_hw_rtn_e ocs_hw_rqpair_init(ocs_hw_t *hw);
extern ocs_hw_rtn_e ocs_hw_rqpair_auto_xfer_rdy_buffer_alloc(ocs_hw_t *hw, uint32_t num_buffers);
extern uint8_t ocs_hw_rqpair_auto_xfer_rdy_buffer_post(ocs_hw_t *hw, ocs_hw_io_t *io, int reuse_buf);
extern ocs_hw_rtn_e ocs_hw_rqpair_auto_xfer_rdy_move_to_port(ocs_hw_t *hw, ocs_hw_io_t *io);
extern void ocs_hw_rqpair_auto_xfer_rdy_move_to_host(ocs_hw_t *hw, ocs_hw_io_t *io);
extern void ocs_hw_rqpair_teardown(ocs_hw_t *hw);
extern ocs_hw_rtn_e ocs_hw_rx_allocate(ocs_hw_t *hw);
extern ocs_hw_rtn_e ocs_hw_rx_post(ocs_hw_t *hw);
extern void ocs_hw_rx_free(ocs_hw_t *hw);
extern void ocs_hw_unsol_process_bounce(void *arg);
typedef int32_t (*ocs_hw_async_cb_t)(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg);
extern int32_t ocs_hw_async_call(ocs_hw_t *hw, ocs_hw_async_cb_t callback, void *arg);
static inline void
ocs_hw_sequence_copy(ocs_hw_sequence_t *dst, ocs_hw_sequence_t *src)
{
/* Copy the src to dst, then zero out the linked list link */
*dst = *src;
ocs_memset(&dst->link, 0, sizeof(dst->link));
}
static inline ocs_hw_rtn_e
ocs_hw_sequence_free(ocs_hw_t *hw, ocs_hw_sequence_t *seq)
{
/* Only RQ pair mode is supported */
return ocs_hw_rqpair_sequence_free(hw, seq);
}
/* HW WQ request tag API */
extern ocs_hw_rtn_e ocs_hw_reqtag_init(ocs_hw_t *hw);
extern hw_wq_callback_t *ocs_hw_reqtag_alloc(ocs_hw_t *hw,
void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg);
extern void ocs_hw_reqtag_free(ocs_hw_t *hw, hw_wq_callback_t *wqcb);
extern hw_wq_callback_t *ocs_hw_reqtag_get_instance(ocs_hw_t *hw, uint32_t instance_index);
extern void ocs_hw_reqtag_reset(ocs_hw_t *hw);
extern uint32_t ocs_hw_dif_blocksize(ocs_hw_dif_info_t *dif_info);
extern int32_t ocs_hw_dif_mem_blocksize(ocs_hw_dif_info_t *dif_info, int wiretomem);
extern int32_t ocs_hw_dif_wire_blocksize(ocs_hw_dif_info_t *dif_info, int wiretomem);
extern uint32_t ocs_hw_get_def_wwn(ocs_t *ocs, uint32_t chan, uint64_t *wwpn, uint64_t *wwnn);
/* Uncomment to enable CPUTRACE */
//#define ENABLE_CPUTRACE
#ifdef ENABLE_CPUTRACE
#define CPUTRACE(t) ocs_printf("trace: %-20s %2s %-16s cpu %2d\n", __func__, t, \
({ocs_thread_t *self = ocs_thread_self(); self != NULL ? self->name : "unknown";}), ocs_thread_getcpu());
#else
#define CPUTRACE(...)
#endif
/* Two levels of macro needed due to expansion */
#define HW_FWREV(a,b,c,d) (((uint64_t)(a) << 48) | ((uint64_t)(b) << 32) | ((uint64_t)(c) << 16) | ((uint64_t)(d)))
#define HW_FWREV_1(x) HW_FWREV(x)
#define OCS_FW_VER_STR2(a,b,c,d) #a "." #b "." #c "." #d
#define OCS_FW_VER_STR(x) OCS_FW_VER_STR2(x)
#define OCS_MIN_FW_VER_LANCER 10,4,255,0
#define OCS_MIN_FW_VER_SKYHAWK 10,4,255,0
extern void ocs_hw_workaround_setup(struct ocs_hw_s *hw);
/**
* @brief Defines the number of the RQ buffers for each RQ
*/
#ifndef OCS_HW_RQ_NUM_HDR
#define OCS_HW_RQ_NUM_HDR 1024
#endif
#ifndef OCS_HW_RQ_NUM_PAYLOAD
#define OCS_HW_RQ_NUM_PAYLOAD 1024
#endif
/**
* @brief Defines the size of the RQ buffers used for each RQ
*/
#ifndef OCS_HW_RQ_SIZE_HDR
#define OCS_HW_RQ_SIZE_HDR 128
#endif
#ifndef OCS_HW_RQ_SIZE_PAYLOAD
#define OCS_HW_RQ_SIZE_PAYLOAD 1024
#endif
/*
* @brief Define the maximum number of multi-receive queues
*/
#ifndef OCS_HW_MAX_MRQS
#define OCS_HW_MAX_MRQS 8
#endif
/*
* @brief Define count of when to set the WQEC bit in a submitted
* WQE, causing a consummed/released completion to be posted.
*/
#ifndef OCS_HW_WQEC_SET_COUNT
#define OCS_HW_WQEC_SET_COUNT 32
#endif
/*
* @brief Send frame timeout in seconds
*/
#ifndef OCS_HW_SEND_FRAME_TIMEOUT
#define OCS_HW_SEND_FRAME_TIMEOUT 10
#endif
/*
* @brief FDT Transfer Hint value, reads greater than this value
* will be segmented to implement fairness. A value of zero disables
* the feature.
*/
#ifndef OCS_HW_FDT_XFER_HINT
#define OCS_HW_FDT_XFER_HINT 8192
#endif
#endif /* !_OCS_HW_H */
Reference in a new issue View git blame Copy permalink