tavor_cmd.h revision e9dc6bff6e018821c8c8ac7fe3e3b42e621e93ae
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _SYS_IB_ADAPTERS_TAVOR_CMD_H
#define _SYS_IB_ADAPTERS_TAVOR_CMD_H
/*
* tavor_cmd.h
* Contains all of the prototypes, #defines, and structures necessary
* for the Tavor Firmware Command routines.
* Specifically it contains the command types, command statuses and flags,
* structures used for managing Tavor mailboxes and outstanding commands,
* and prototypes for most of the functions consumed by other parts of
* the Tavor driver.
*/
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ib/mgt/sm_attr.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Defines used tavor_write_hcr() to determine the duration and number of
* times (at maximum) to poll while waiting for a Tavor firmware command to
* release the HCR resource (i.e. waiting for the command to complete)
*/
#define TAVOR_CMD_POLL_DELAY 1
#define TAVOR_CMD_POLL_MAX 3000000
/*
* The following defines specify the default number of mailboxes (log 2) of
* each type and their size and alignment restrictions. By default the number
* of both "In" and "Out" mailboxes is set to eight (with each mailbox being
* 512 bytes in size), but both the number and sizes of each are controllable
* through the "tavor_log_num_inmbox", "tavor_log_num_outmbox",
* "tavor_log_inmbox_size" and "tavor_log_outmbox_size" configuration
* variables.
*/
#define TAVOR_NUM_MAILBOXES_SHIFT 8
#define TAVOR_NUM_INTR_MAILBOXES_SHIFT 0
#define TAVOR_MBOX_SIZE_SHIFT 0x9
#define TAVOR_MBOX_SIZE (1 << TAVOR_MBOX_SIZE_SHIFT)
#define TAVOR_MBOX_ALIGN TAVOR_MBOX_SIZE
/*
* The following macro determines whether the contents of given mailbox
* type need to be sync'd (with ddi_dma_sync()). This decision is based
* on whether the mailbox is in DDR memory (no sync) or system memory
* (sync required). And it also supports the possibility that if a CQ in
* system memory is mapped DDI_DMA_CONSISTENT, it can be configured to not be
* sync'd because of the "sync override" parameter in the config profile.
*/
#define TAVOR_MBOX_IS_SYNC_REQ(state, type) \
((((((state)->ts_cfg_profile->cp_streaming_consistent) && \
((state)->ts_cfg_profile->cp_consistent_syncoverride))) || \
((&((state)->ts_rsrc_hdl[(type)]))->rsrc_loc == TAVOR_IN_DDR)) \
? 0 : 1)
/*
* These are the defines for the Tavor command type (opcodes). They are
* specified by the Tavor register specification
*/
#define SYS_EN 0x1
#define SYS_DIS 0x2
#define QUERY_DEV_LIM 0x3
#define QUERY_FW 0x4
#define QUERY_DDR 0x5
#define QUERY_ADAPTER 0x6
#define INIT_HCA 0x7
#define CLOSE_HCA 0x8
#define INIT_IB 0x9
#define CLOSE_IB 0xA
#define QUERY_HCA 0xB
#define SET_IB 0xC
#define ACCESS_DDR 0x2E
#define SW2HW_MPT 0xD
#define QUERY_MPT 0xE
#define HW2SW_MPT 0xF
#define READ_MTT 0x10
#define WRITE_MTT 0x11
#define SYNC_TPT 0x2F
#define MAP_EQ 0x12
#define SW2HW_EQ 0x13
#define HW2SW_EQ 0x14
#define QUERY_EQ 0x15
#define SW2HW_CQ 0x16
#define HW2SW_CQ 0x17
#define QUERY_CQ 0x18
#define RESIZE_CQ 0x2C
#define RST2INIT_QP 0x19
#define INIT2INIT_QP 0x2D
#define INIT2RTR_QP 0x1A
#define RTR2RTS_QP 0x1B
#define RTS2RTS_QP 0x1C
#define SQERR2RTS_QP 0x1D
#define TOERR_QP 0x1E
#define RTS2SQD_QP 0x1F
#define SQD2RTS_QP 0x20
#define TORST_QP 0x21
#define QUERY_QP 0x22
#define CONF_SPECIAL_QP 0x23
#define MAD_IFC 0x24
#define READ_MGM 0x25
#define WRITE_MGM 0x26
#define MGID_HASH 0x27
#define CONF_NTU 0x28
#define QUERY_NTU 0x29
#define QUERY_DEBUG_MSG 0x2A
#define SET_DEBUG_MSG 0x2B
#define DIAG_RPRT 0x30
#define MOD_STAT_CFG 0x34
#define SW2HW_SRQ 0x35
#define HW2SW_SRQ 0x36
#define QUERY_SRQ 0x37
#define SQD2SQD_QP 0x38
#define MODIFY_MPT 0x39
/*
* These are the defines for the Tavor command completion statuses. They are
* also specified (in part) by the Tavor register specification. However,
* the TAVOR_CMD_INSUFF_RSRC, TAVOR_CMD_TIMEOUT and TAVOR_CMD_INVALID_STATUS
* codes were added for this driver specifically to indicate the conditions
* when insufficient resources are available for a command, when a command has
* timed out (failure in the Tavor firmware) or when some other invalid result
* was received.
*/
#define TAVOR_CMD_INSUFF_RSRC 0xFFFD
#define TAVOR_CMD_TIMEOUT 0xFFFE
#define TAVOR_CMD_INVALID_STATUS 0xFFFF
#define TAVOR_CMD_SUCCESS 0x00
#define TAVOR_CMD_INTERNAL_ERR 0x01
#define TAVOR_CMD_BAD_OP 0x02
#define TAVOR_CMD_BAD_PARAM 0x03
#define TAVOR_CMD_BAD_SYS_STATE 0x04
#define TAVOR_CMD_BAD_RESOURCE 0x05
#define TAVOR_CMD_RESOURCE_BUSY 0x06
#define TAVOR_CMD_DDR_MEM_ERR 0x07
#define TAVOR_CMD_EXCEED_LIM 0x08
#define TAVOR_CMD_BAD_RES_STATE 0x09
#define TAVOR_CMD_BAD_INDEX 0x0A
#define TAVOR_CMD_BAD_NVMEM 0x0B
#define TAVOR_CMD_BAD_QP_STATE 0x10
#define TAVOR_CMD_BAD_SEG_PARAM 0x20
#define TAVOR_CMD_REG_BOUND 0x21
#define TAVOR_CMD_BAD_PKT 0x30
#define TAVOR_CMD_BAD_SIZE 0x40
/*
* These defines are used in the "special QP" allocation to indicate the type
* of special QP (SMI, GSI, or one of the raw types). These values are
* specified by the Tavor register specification
*/
#define TAVOR_CMD_QP_SMI 0
#define TAVOR_CMD_QP_GSI 1
#define TAVOR_CMD_QP_RAW_IPV6 2
#define TAVOR_CMD_QP_RAW_ETH 3
/*
* For certain Tavor QP state transition commands some optional flags are
* allowed. These "opmask" flags are defined by the Tavor register
* specification as a bitmask.
*/
#define TAVOR_CMD_OP_ALT_PATH (1 << 0)
#define TAVOR_CMD_OP_RRE (1 << 1)
#define TAVOR_CMD_OP_RAE (1 << 2)
#define TAVOR_CMD_OP_RWE (1 << 3)
#define TAVOR_CMD_OP_PKEYINDX (1 << 4)
#define TAVOR_CMD_OP_QKEY (1 << 5)
#define TAVOR_CMD_OP_MINRNRNAK (1 << 6)
#define TAVOR_CMD_OP_PRIM_PATH (1 << 7)
#define TAVOR_CMD_OP_SRA_SET (1 << 8)
#define TAVOR_CMD_OP_RRA_SET (1 << 9)
#define TAVOR_CMD_OP_PM_STATE (1 << 10)
#define TAVOR_CMD_OP_PRIM_PORT (1 << 11)
#define TAVOR_CMD_OP_RETRYCNT (1 << 12)
#define TAVOR_CMD_OP_ALT_RNRRETRY (1 << 13)
#define TAVOR_CMD_OP_ACKTIMEOUT (1 << 14)
#define TAVOR_CMD_OP_PRIM_RNRRETRY (1 << 15)
#define TAVOR_CMD_OP_SCHEDQUEUE (1 << 16)
/*
* The Tavor RTS2SQD command can take the following flag as part of its
* input modifier to request the Send Queue Drained event
*/
#define TAVOR_CMD_REQ_SQD_EVENT 0x80000000
/*
* The Tavor TORST command can take the following flag (as part of a bitmask)
* in its opcode modifier to request that the transition to reset should
* not go through the Error state (and, hence, should not generate "flushed-
* in-error" completions
*/
#define TAVOR_CMD_DIRECT_TO_RESET (1 << 1)
/*
* Some Tavor commands write an OUT mailbox entry, depending on the value of
* the 'opmod' parameter. These defines provide the correct opmod value to
* write depending on whether to write an entry or not.
*/
#define TAVOR_CMD_DO_OUTMBOX (0)
#define TAVOR_CMD_NO_OUTMBOX (1 << 0)
/*
* The Tavor SYS_EN command can take the following opcode modifier options
* to specify whether certain DDR checks should be performed.
*/
#define TAVOR_CMD_SYS_EN_NORMAL 0
#define TAVOR_CMD_SYS_EN_DDR_MEMCHECK 2
#define TAVOR_CMD_SYS_EN_DDR_PRESERVE 3
/*
* The Tavor MAP_EQ command can take the following flags (and use the
* TAVOR_CMD_UNMAP_EQ_MASK input modifier) to indicate whether the given
* event queue should mapped to or unmapped from the given event type.
*/
#define TAVOR_CMD_MAP_EQ_EVT_MAP 0
#define TAVOR_CMD_MAP_EQ_EVT_UNMAP 1
#define TAVOR_CMD_UNMAP_EQ_MASK 0x80000000
/*
* The following defines are used by the MAD_IFC command and the helper
* routines that get PortInfo, NodeInfo, GUIDInfo, and PKeyTable entries.
*
* The first indicates whether of not MKey checking should be enforced.
* This is passed in the opcode modifier field for MAD_IFC commands.
*
* The next set are used to define certain hardcoded management datagram (MAD)
* sizes, offsets, and header formats for each of the helper operations.
*/
#define TAVOR_CMD_MKEY_CHECK 0
#define TAVOR_CMD_MKEY_DONTCHECK 1
#define TAVOR_CMD_BKEY_DONTCHECK 2
#define TAVOR_CMD_MAD_IFC_SIZE 0x100
#define TAVOR_CMD_MADDATA_OFFSET 0x40
#define TAVOR_CMD_MADHDR0 0x01010101
#define TAVOR_CMD_MADHDR1 0x00000000
#define TAVOR_CMD_MADHDR2 0x00000000
#define TAVOR_CMD_MADHDR3 0x00000000
#define TAVOR_CMD_PORTINFO 0x00150000
#define TAVOR_CMD_NODEINFO 0x00110000
#define TAVOR_CMD_NODEDESC 0x00100000
#define TAVOR_CMD_GUIDINFO 0x00140000
#define TAVOR_CMD_PKEYTBLE 0x00160000
#define TAVOR_CMD_PERF_GET 0x01040101
#define TAVOR_CMD_PERF_SET 0x01040102
#define TAVOR_CMD_PERFCNTRS 0x00120000
#define TAVOR_CMD_PERFATTR 0x00000000
/*
* The next few defines are used to indicate the size of the "reserved" area
* in the WRITE_MTT command, and the respective sizes of the SET_IB and
* MGID_HASH commands
*/
#define TAVOR_CMD_WRITEMTT_RSVD_SZ 0x10
#define TAVOR_CMD_SETIB_SZ 0x8
#define TAVOR_CMD_MGIDHASH_SZ 0x10
/*
* This last define is used by tavor_cmn_ownership_cmd_post() to keep track
* of the direction (from hardware ownership to software, or vice versa) of
* the requested operation
*/
#define TAVOR_CMD_RSRC_HW2SW 0
#define TAVOR_CMD_RSRC_SW2HW 1
/*
* The following macros are used for handling any endianness related issues
* that might arise from the Tavor driver's internal use of MADs.
*
* TAVOR_GETPORTINFO_SWAP - All the necessary swapping to handle the
* response to a GetPortInfo MAD
* TAVOR_GETNODEINFO_SWAP - All the necessary swapping to handle the
* response to a GetNodeInfo MAD
* TAVOR_GETGUIDINFO_SWAP - All the necessary swapping to handle the
* response to a GetGUIDInfo MAD
* TAVOR_GETPKEYTABLE_SWAP - All the necessary swapping to handle the
* response to a GetPKeyTable MAD
*/
#ifdef _LITTLE_ENDIAN
#define TAVOR_GETPORTINFO_SWAP(portinfo) \
{ \
(portinfo)->M_Key = ddi_swap64((portinfo)->M_Key); \
(portinfo)->GidPrefix = ddi_swap64((portinfo)->GidPrefix); \
(portinfo)->LID = ddi_swap16((portinfo)->LID); \
(portinfo)->MasterSMLID = ddi_swap16((portinfo)->MasterSMLID); \
(portinfo)->CapabilityMask = \
ddi_swap32((portinfo)->CapabilityMask); \
(portinfo)->DiagCode = ddi_swap16((portinfo)->DiagCode); \
(portinfo)->M_KeyLeasePeriod = \
ddi_swap16((portinfo)->M_KeyLeasePeriod); \
(portinfo)->M_KeyViolations = \
ddi_swap16((portinfo)->M_KeyViolations); \
(portinfo)->P_KeyViolations = \
ddi_swap16((portinfo)->P_KeyViolations); \
(portinfo)->Q_KeyViolations = \
ddi_swap16((portinfo)->Q_KeyViolations); \
}
#else
#define TAVOR_GETPORTINFO_SWAP(portinfo)
#endif
#ifdef _LITTLE_ENDIAN
#define TAVOR_GETNODEINFO_SWAP(nodeinfo) \
{ \
uint32_t tmp; \
\
tmp = ddi_swap32(((uint32_t *)nodeinfo)[9]); \
(nodeinfo)->VendorID = tmp & 0xFFFFFF; \
(nodeinfo)->LocalPortNum = tmp >> 24; \
(nodeinfo)->Revision = \
ddi_swap32(((uint32_t *)nodeinfo)[8]); \
tmp = ddi_swap32(((uint32_t *)nodeinfo)[7]); \
(nodeinfo)->PartitionCap = tmp >> 16; \
(nodeinfo)->DeviceID = tmp & 0xFFFF; \
(nodeinfo)->PortGUID = ddi_swap64((((uint64_t) \
(((uint32_t *)nodeinfo)[6]) << 32) | \
((uint32_t *)nodeinfo)[5])); \
(nodeinfo)->NodeGUID = ddi_swap64((((uint64_t) \
(((uint32_t *)nodeinfo)[4]) << 32) | \
((uint32_t *)nodeinfo)[3])); \
(nodeinfo)->SystemImageGUID = ddi_swap64((((uint64_t) \
(((uint32_t *)nodeinfo)[2]) << 32) | \
((uint32_t *)nodeinfo)[1])); \
}
#else
#define TAVOR_GETNODEINFO_SWAP(nodeinfo) \
{ \
uint32_t tmp; \
\
tmp = ((uint32_t *)nodeinfo)[9]; \
(nodeinfo)->VendorID = tmp & 0xFFFFFF; \
(nodeinfo)->LocalPortNum = tmp >> 24; \
(nodeinfo)->Revision = ((uint32_t *)nodeinfo)[8]; \
tmp = ((uint32_t *)nodeinfo)[7]; \
(nodeinfo)->PartitionCap = tmp >> 16; \
(nodeinfo)->DeviceID = tmp & 0xFFFF; \
(nodeinfo)->PortGUID = (((uint64_t) \
(((uint32_t *)nodeinfo)[5]) << 32) | \
((uint32_t *)nodeinfo)[6]); \
(nodeinfo)->NodeGUID = (((uint64_t) \
(((uint32_t *)nodeinfo)[3]) << 32) | \
((uint32_t *)nodeinfo)[4]); \
(nodeinfo)->SystemImageGUID = (((uint64_t) \
(((uint32_t *)nodeinfo)[1]) << 32) | \
((uint32_t *)nodeinfo)[2]); \
}
#endif
#ifdef _LITTLE_ENDIAN
#define TAVOR_GETGUIDINFO_SWAP(guidinfo) \
{ \
int i; \
\
for (i = 0; i < 8; i++) { \
(guidinfo)->GUIDBlocks[i] = \
ddi_swap64((guidinfo)->GUIDBlocks[i]); \
} \
}
#else
#define TAVOR_GETGUIDINFO_SWAP(guidinfo)
#endif
#ifdef _LITTLE_ENDIAN
#define TAVOR_GETPKEYTABLE_SWAP(pkeytable) \
{ \
int i; \
\
for (i = 0; i < 32; i++) { \
(pkeytable)->P_KeyTableBlocks[i] = \
ddi_swap16((pkeytable)->P_KeyTableBlocks[i]); \
} \
}
#else
#define TAVOR_GETPKEYTABLE_SWAP(pkeytable)
#endif
/*
* The Tavor MODIFY_MPT command can take the following opcode modifier
* options to specify whether to modify for ResizeSRQ() or to swap the
* full MPT entry.
*/
#define TAVOR_CMD_MODIFY_MPT_RESIZESRQ 3
#define TAVOR_CMD_MODIFY_MPT_SWAPFULL 5
/*
* The tavor_mbox_t structure is used internally by the Tavor driver to track
* all the information necessary to manage mailboxes for the Tavor command
* interface. Specifically, by containing a pointer to the buffer, the
* PCI mapped address, the access handle, and a back pointer to the
* tavor_rsrc_t structure used to track this resource, it provides enough
* information allocate, use, and free any type of mailbox.
*
* The mb_indx, mb_next, and mb_prev fields are used only by the mailbox
* alloc/free routines (see tavor_impl_mbox_alloc/free() for more details)
* and are not read or modified by any mailbox consumers. They are used
* to implement a fast allocation mechanism.
*/
typedef struct tavor_mbox_s {
void *mb_addr;
uint64_t mb_mapaddr;
ddi_acc_handle_t mb_acchdl;
tavor_rsrc_t *mb_rsrcptr;
uint_t mb_sync;
uint_t mb_indx;
uint_t mb_next;
uint_t mb_prev;
} tavor_mbox_t;
/*
* The tavor_mboxlist_t structure is used to track all the information
* relevant to the pools of Tavor mailboxes. Specifically, it has a pointer
* to an array of tavor_mbox_t structures, a lock and cv used for blocking
* on alloc when mailboxes are not available, and a head, tail, and entries
* free counter to keep track of which (if any) mailboxes are currently free.
* This is used (along with the mb_indx, mb_next, and mb_prev fields in the
* tavor_mbox_t) to implement the fast allocation mechanism.
*/
typedef struct tavor_mboxlist_s {
kmutex_t mbl_lock;
kcondvar_t mbl_cv;
tavor_mbox_t *mbl_mbox;
uint_t mbl_list_sz;
uint_t mbl_num_alloc;
uint_t mbl_head_indx;
uint_t mbl_tail_indx;
uint_t mbl_entries_free;
uint_t mbl_waiters;
uint_t mbl_pollers;
uint_t mbl_signal;
} tavor_mboxlist_t;
_NOTE(MUTEX_PROTECTS_DATA(tavor_mboxlist_t::mbl_lock,
tavor_mboxlist_t::mbl_mbox
tavor_mboxlist_t::mbl_list_sz
tavor_mboxlist_t::mbl_num_alloc
tavor_mboxlist_t::mbl_cv
tavor_mboxlist_t::mbl_head_indx
tavor_mboxlist_t::mbl_tail_indx
tavor_mboxlist_t::mbl_entries_free
tavor_mboxlist_t::mbl_waiters
tavor_mboxlist_t::mbl_pollers
tavor_mboxlist_t::mbl_signal
tavor_mbox_t::mb_next
tavor_mbox_t::mb_prev))
/*
* The tavor_mbox_info_t structure is used by mailbox allocators to specify
* the type of mailbox(es) being requested. On a call to tavor_mbox_alloc()
* the mbi_alloc_flags may be set to TAVOR_ALLOC_INMBOX, TAVOR_ALLOC_OUTMBOX,
* or both. If it is able to allocate the request type(s) of mailboxes,
* tavor_mbox_alloc() will fill in the "mbi_in" and/or "mbi_out" pointers
* to point to valid tavor_mbox_t structures from the appropriate
* tavor_mboxlist_t (see above).
* This same structure is also passed to tavor_mbox_free(). It is the
* responsibility of the caller to tavor_mbox_alloc() to return this exact
* structure (unmodified) to tavor_mbox_free().
*
* Note: If both "In" and "Out" mailboxes are requested, it is assured that
* no deadlock can result (from holding one mailbox while attempting to get
* the other). This is assured by the fact that the "In" mailbox will always
* be allocated first before attempting to allocate the "Out"
*/
typedef struct tavor_mbox_info_s {
uint_t mbi_alloc_flags;
uint_t mbi_sleep_context;
tavor_mbox_t *mbi_in;
tavor_mbox_t *mbi_out;
} tavor_mbox_info_t;
#define TAVOR_ALLOC_INMBOX (1 << 0)
#define TAVOR_ALLOC_OUTMBOX (1 << 1)
/*
* The tavor_cmd_t structure is used internally by the Tavor driver to track
* all the information necessary to manage outstanding firmware commands on
* the Tavor command interface.
*
* Each tavor_cmd_t structure contains a cv and lock which are used by the
* posting thread to block for completion (with cmd_status being overloaded
* to indicate the condition variable). The cmd_outparam field is used to
* return additional status from those Tavor commands that specifically
* require it.
*
* The cmd_indx, cmd_next, and cmd_prev fields are used by the outstanding
* command alloc/free routines (see tavor_outstanding_cmd_alloc/free() for
* more details). They are used (in much the same way as the mb_indx,
* mb_next, and mb_prev fields in tavor_mbox_t above) to implement a fast
* allocation mechanism.
*/
typedef struct tavor_cmd_s {
kmutex_t cmd_comp_lock;
kcondvar_t cmd_comp_cv;
uint64_t cmd_outparm;
uint_t cmd_status;
uint_t cmd_indx;
uint_t cmd_next;
uint_t cmd_prev;
} tavor_cmd_t;
_NOTE(MUTEX_PROTECTS_DATA(tavor_cmd_t::cmd_comp_lock,
tavor_cmd_t::cmd_comp_cv
tavor_cmd_t::cmd_status))
/*
* The tavor_cmdlist_t structure is used in almost exactly the same way as
* the tavor_mboxlist_t above, but instead to track all the information
* relevant to the pool of outstanding Tavor commands. Specifically, it has
* a pointer to an array of tavor_cmd_t structures, a lock and cv used for
* blocking on alloc when outstanding command slots are not available, and a
* head, tail, and entries free counter to keep track of which (if any)
* command slots are currently free. This is used (along with the cmd_indx,
* cmd_next, and cmd_prev fields in the tavor_cmd_t) to implement the fast
* allocation mechanism.
*/
typedef struct tavor_cmdlist_s {
kmutex_t cml_lock;
kcondvar_t cml_cv;
tavor_cmd_t *cml_cmd;
uint_t cml_list_sz;
uint_t cml_num_alloc;
uint_t cml_head_indx;
uint_t cml_tail_indx;
uint_t cml_entries_free;
uint_t cml_waiters;
} tavor_cmdlist_t;
_NOTE(MUTEX_PROTECTS_DATA(tavor_cmdlist_t::cml_lock,
tavor_cmdlist_t::cml_cv
tavor_cmdlist_t::cml_cmd
tavor_cmdlist_t::cml_list_sz
tavor_cmdlist_t::cml_num_alloc
tavor_cmdlist_t::cml_head_indx
tavor_cmdlist_t::cml_tail_indx
tavor_cmdlist_t::cml_entries_free
tavor_cmdlist_t::cml_waiters
tavor_cmd_t::cmd_next
tavor_cmd_t::cmd_prev))
_NOTE(LOCK_ORDER(tavor_cmdlist_t::cml_lock
tavor_cmd_t::cmd_comp_lock))
/*
* The tavor_cmd_post_t structure is used by all the Tavor Firmware Command
* routines to post to Tavor firmware. The fields almost exactly mimic
* the fields in the Tavor HCR registers. The notable exception is the
* addition of the "cp_flags" field (which can be set to TAVOR_CMD_SPIN or
* TAVOR_CMD_NOSPIN). This flag really controls the value of the "e" bit
* in the HCR (i.e. the bit to indicate whether command should complete
* "in place" - in the HCR - or whether they should have their completions
* written to the command completion event queue. TAVOR_CMD_SPIN means
* to allow commands to complete "in place" and to poll the "go" bit in
* the HCR to determine completion.
*
* We use TAVOR_SLEEP and TAVOR_NOSLEEP for our TAVOR_CMD_ #defines. This is
* to maintain consistency with the rest of the SLEEP flags. Additionally,
* because TAVOR_SLEEPFLAG_FOR_CONTEXT() in tavor_rsrc.h returns TAVOR_SLEEP or
* NOSLEEP we must be compatible with this macro.
*/
typedef struct tavor_cmd_post_s {
uint64_t cp_inparm;
uint64_t cp_outparm;
uint32_t cp_inmod;
uint16_t cp_opcode;
uint16_t cp_opmod;
uint32_t cp_flags;
} tavor_cmd_post_t;
#define TAVOR_CMD_SLEEP_NOSPIN TAVOR_SLEEP
#define TAVOR_CMD_NOSLEEP_SPIN TAVOR_NOSLEEP
/*
* The following are the Tavor Firmware Command routines that accessible
* externally (i.e. throughout the rest of the Tavor driver software).
* These include the all the alloc/free routines, some initialization
* and cleanup routines, and the various specific Tavor firmware commands.
*/
int tavor_cmd_post(tavor_state_t *state, tavor_cmd_post_t *cmdpost);
int tavor_mbox_alloc(tavor_state_t *state, tavor_mbox_info_t *mbox_info,
uint_t mbox_wait);
void tavor_mbox_free(tavor_state_t *state, tavor_mbox_info_t *mbox_info);
int tavor_cmd_complete_handler(tavor_state_t *state, tavor_eqhdl_t eq,
tavor_hw_eqe_t *eqe);
int tavor_inmbox_list_init(tavor_state_t *state);
int tavor_intr_inmbox_list_init(tavor_state_t *state);
int tavor_outmbox_list_init(tavor_state_t *state);
int tavor_intr_outmbox_list_init(tavor_state_t *state);
void tavor_inmbox_list_fini(tavor_state_t *state);
void tavor_intr_inmbox_list_fini(tavor_state_t *state);
void tavor_outmbox_list_fini(tavor_state_t *state);
void tavor_intr_outmbox_list_fini(tavor_state_t *state);
int tavor_outstanding_cmdlist_init(tavor_state_t *state);
void tavor_outstanding_cmdlist_fini(tavor_state_t *state);
/*
* SYS_EN and SYS_DIS - used for startup and shutdown of Tavor device
*/
int tavor_sys_en_cmd_post(tavor_state_t *state, uint_t flags,
uint64_t *errorcode, uint_t sleepflag);
int tavor_sys_dis_cmd_post(tavor_state_t *state, uint_t sleepflag);
/*
* INIT_HCA and CLOSE_HCA - used for initialization and teardown of Tavor
* device configuration
*/
int tavor_init_hca_cmd_post(tavor_state_t *state,
tavor_hw_initqueryhca_t *inithca, uint_t sleepflag);
int tavor_close_hca_cmd_post(tavor_state_t *state, uint_t sleepflag);
/*
* INIT_IB, CLOSE_IB, and SET_IB - used for bring Tavor ports up and down,
* and to set properties of each port (e.g. PortInfo capability mask)
*/
int tavor_init_ib_cmd_post(tavor_state_t *state,
tavor_hw_initib_t *initib, uint_t port, uint_t sleepflag);
int tavor_close_ib_cmd_post(tavor_state_t *state, uint_t port,
uint_t sleepflag);
int tavor_set_ib_cmd_post(tavor_state_t *state, uint32_t capmask,
uint_t port, uint_t reset_qkey, uint_t sleepflag);
/*
* This common function is used to post the following Tavor QP state
* transition firmware commands:
* RTS2SQD, TOERR, TORST, RST2INIT, INIT2INIT, INIT2RTR, RTR2RTS, RTS2RTS,
* SQD2SQD, SQD2RTS, and SQERR2RTS.
*/
int tavor_cmn_qp_cmd_post(tavor_state_t *state, uint_t opcode,
tavor_hw_qpc_t *qp, uint_t qpindx, uint32_t opmask, uint_t sleepflag);
/*
* This common function is used to post the following Tavor query firmware
* commands:
* QUERY_DEV_LIM, QUERY_FW, QUERY_DDR, QUERY_ADAPTER, QUERY_HCA, QUERY_MPT,
* QUERY_EQ, QUERY_CQ, and QUERY_QP.
*/
int tavor_cmn_query_cmd_post(tavor_state_t *state, uint_t opcode,
uint_t queryindx, void *query, uint_t size, uint_t sleepflag);
/*
* This common function is used to post the following Tavor resource ownership
* firmware commands:
* HW2SW_MPT, HW2SW_EQ, HW2SW_CQ, SW2HW_MPT, SW2HW_EQ, and SW2HW_CQ
*/
int tavor_cmn_ownership_cmd_post(tavor_state_t *state, uint_t opcode,
void *hwrsrc, uint_t size, uint_t hwrsrcindx, uint_t sleepflag);
/*
* MAD_IFC and helper functions - used for posting IB MADs to Tavor firmware.
* The helper functions are for the MADs most frequently used by the Tavor
* driver (internally).
*/
int tavor_mad_ifc_cmd_post(tavor_state_t *state, uint_t port,
uint_t sleepflag, uint32_t *mad, uint32_t *resp);
int tavor_getportinfo_cmd_post(tavor_state_t *state, uint_t port,
uint_t sleepflag, sm_portinfo_t *portinfo);
int tavor_getnodeinfo_cmd_post(tavor_state_t *state, uint_t sleepflag,
sm_nodeinfo_t *nodeinfo);
int tavor_getnodedesc_cmd_post(tavor_state_t *state, uint_t sleepflag,
sm_nodedesc_t *nodedesc);
int tavor_getguidinfo_cmd_post(tavor_state_t *state, uint_t port,
uint_t guidblock, uint_t sleepflag, sm_guidinfo_t *guidinfo);
int tavor_getpkeytable_cmd_post(tavor_state_t *state, uint_t port,
uint_t pkeyblock, uint_t sleepflag, sm_pkey_table_t *pkeytable);
int tavor_getperfcntr_cmd_post(tavor_state_t *state, uint_t port,
uint_t sleepflag, tavor_hw_sm_perfcntr_t *perfinfo, int reset);
/*
* WRITE_MTT - used for write MTT entries to the Tavor MTT table
*/
int tavor_write_mtt_cmd_post(tavor_state_t *state,
tavor_mbox_info_t *mbox_info, uint_t num_mtt, uint_t sleepflag);
/*
* SYNC_TPT - used to sync Tavor TPT caches
*/
int tavor_sync_tpt_cmd_post(tavor_state_t *state, uint_t sleepflag);
/*
* MAP_EQ - used for map classes of events to Tavor event queues (EQ)
*/
int tavor_map_eq_cmd_post(tavor_state_t *state, uint_t map,
uint_t eqcindx, uint64_t eqmapmask, uint_t sleepflag);
/*
* RESIZE_CQ - used for resize completion queue (CQ)
*/
int tavor_resize_cq_cmd_post(tavor_state_t *state, tavor_hw_cqc_t *cqc,
uint_t cqcindx, uint32_t *prod_indx, uint_t sleepflag);
/*
* CONF_SPECIAL_QP - used to configure a pair of queue pairs for use as
* special QP. Necessary to enable full QP0 and/or QP1 operation.
*/
int tavor_conf_special_qp_cmd_post(tavor_state_t *state, uint_t qpindx,
uint_t qptype, uint_t sleepflag);
/*
* MGID_HASH, READ_MGM, and WRITE_MGM - used for manipulation of the
* hardware resource tables for multicast groups.
*/
int tavor_mgid_hash_cmd_post(tavor_state_t *state, uint64_t mgid_h,
uint64_t mgid_l, uint64_t *mgid_hash, uint_t sleepflag);
int tavor_read_mgm_cmd_post(tavor_state_t *state, tavor_hw_mcg_t *mcg,
uint_t mcgindx, uint_t sleepflag);
int tavor_write_mgm_cmd_post(tavor_state_t *state, tavor_hw_mcg_t *mcg,
uint_t mcgindx, uint_t sleepflag);
/*
* MOD_STAT_CFG - used to configure (override) settings set in NVRAM before
* a call to QUERY_DEV_LIM. This is primarily used for SRQ settings in
* the firmware.
*/
int tavor_mod_stat_cfg_cmd_post(tavor_state_t *state);
/*
* MODIFY_MPT - used to change MPT attributes of a memory region. This
* is primarily used for Resizing SRQs.
*/
int tavor_modify_mpt_cmd_post(tavor_state_t *state, tavor_hw_mpt_t *mpt,
uint_t mptindx, uint_t flags, uint_t sleepflag);
#ifdef __cplusplus
}
#endif
#endif /* _SYS_IB_ADAPTERS_TAVOR_CMD_H */