/*
*/
/*
* 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
*
* 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.
*/
#ifndef _PSIF_HW_PRINT_C
#define _PSIF_HW_PRINT_C
#if defined(__arm__)
#include <stdio.h>
#include <stdint.h>
#include "psif_endian.h"
#else /* virtualized */
#if !defined(__KERNEL__)
#include <stdio.h>
#include <string.h>
#if !defined(_PSIFAPI_KERNEL_TYPES_H)
#define _PSIFAPI_KERNEL_TYPES_H
#include <stdint.h>
#endif /* (_PSIFAPI_KERNEL_TYPES_H) */
#include "os_header.h"
#endif /* !defined(__KERNEL__) */
#endif /* __arm__ */
#include "psif_api.h"
#include "psif_hw_data.h"
#include "psif_hw_macro.h"
#include "psif_hw_setget.h"
#include "psif_hw_print.h"
#include "psif_api.h"
#if !defined(xprintf)
#endif
#if !defined(OS_PRIx64)
#endif
/* Write fixed size bit field represented as unsigned int types */
{
} /* end write_bits_u8(u8 data) */
/* Write fixed size bit field represented as unsigned int types */
{
} /* end write_bits_u16(u16 data) */
/* Write fixed size bit field represented as unsigned int types */
{
} /* end write_bits_u32(u32 data) */
/* Write fixed size bit field represented as unsigned int types */
{
} /* end write_bits_u64(u64 data) */
/* Convert enum psif_epsc_degrade_cause to string */
{
switch (val) {
return "DEGRADE_CAUSE_FLAG_MISSING_GUID";
return "DEGRADE_CAUSE_FLAG_VPD_INVALID_NAME";
return "DEGRADE_CAUSE_FLAG_HW_UNSUPPORTED";
return "DEGRADE_CAUSE_FLAG_HW_MDIO_ERROR";
return "DEGRADE_CAUSE_FLAG_MODIFY_QP_TIMEOUT";
return "DEGRADE_CAUSE_FLAG_VIRTMODE_RECONF";
return "DEGRADE_CAUSE_FLAG_MCAST_LACK_OF_CREDIT";
return "PSIF_EPSC_DEGRADE_CAUSE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_degrade_cause";
}
}
enum psif_epsc_degrade_cause data)
{
} /* end write_..._psif_epsc_degrade_cause(psif_epsc_degrade_cause data) */
/* Convert enum psif_mmu_translation to string */
{
switch (val) {
case MMU_PASS_THROUGH0:
return "MMU_PASS_THROUGH0";
case MMU_PASS_THROUGH_PAD:
return "MMU_PASS_THROUGH_PAD";
case MMU_GVA2GPA_MODE:
return "MMU_GVA2GPA_MODE";
case MMU_GVA2GPA_MODE_PAD:
return "MMU_GVA2GPA_MODE_PAD";
case MMU_PRETRANSLATED:
return "MMU_PRETRANSLATED";
case MMU_PRETRANSLATED_PAD:
return "MMU_PRETRANSLATED_PAD";
case MMU_EPSA_MODE:
return "MMU_EPSA_MODE";
case MMU_EPSC_MODE:
return "MMU_EPSC_MODE";
default:
return "UNKNOWN_psif_mmu_translation";
}
}
enum psif_mmu_translation data)
{
} /* end write_..._psif_mmu_translation(psif_mmu_translation data) */
/* Convert enum psif_page_size to string */
{
switch (val) {
case PAGE_SIZE_IA32E_4KB:
return "PAGE_SIZE_IA32E_4KB";
case PAGE_SIZE_IA32E_2MB:
return "PAGE_SIZE_IA32E_2MB";
case PAGE_SIZE_IA32E_1GB:
return "PAGE_SIZE_IA32E_1GB";
case PAGE_SIZE_S64_8KB:
return "PAGE_SIZE_S64_8KB";
case PAGE_SIZE_S64_64KB:
return "PAGE_SIZE_S64_64KB";
case PAGE_SIZE_S64_512KB:
return "PAGE_SIZE_S64_512KB";
case PAGE_SIZE_S64_4MB:
return "PAGE_SIZE_S64_4MB";
case PAGE_SIZE_S64_32MB:
return "PAGE_SIZE_S64_32MB";
case PAGE_SIZE_S64_2GB:
return "PAGE_SIZE_S64_2GB";
case PAGE_SIZE_S64_16GB:
return "PAGE_SIZE_S64_16GB";
default:
return "UNKNOWN_psif_page_size";
}
}
enum psif_page_size data)
{
} /* end write_..._psif_page_size(psif_page_size data) */
/* Convert enum psif_wr_type to string */
{
switch (val) {
case PSIF_WR_SEND:
return "PSIF_WR_SEND";
case PSIF_WR_SEND_IMM:
return "PSIF_WR_SEND_IMM";
case PSIF_WR_SPECIAL_QP_SEND:
return "PSIF_WR_SPECIAL_QP_SEND";
case PSIF_WR_QP0_SEND_DR_XMIT:
return "PSIF_WR_QP0_SEND_DR_XMIT";
return "PSIF_WR_QP0_SEND_DR_LOOPBACK";
return "PSIF_WR_EPS_SPECIAL_QP_SEND";
return "PSIF_WR_EPS_QP0_SEND_DR_XMIT";
return "PSIF_WR_EPS_QP0_SEND_DR_LOOPBACK";
case PSIF_WR_RDMA_WR:
return "PSIF_WR_RDMA_WR";
case PSIF_WR_RDMA_WR_IMM:
return "PSIF_WR_RDMA_WR_IMM";
case PSIF_WR_RDMA_RD:
return "PSIF_WR_RDMA_RD";
case PSIF_WR_CMP_SWAP:
return "PSIF_WR_CMP_SWAP";
case PSIF_WR_FETCH_ADD:
return "PSIF_WR_FETCH_ADD";
case PSIF_WR_MASK_CMP_SWAP:
return "PSIF_WR_MASK_CMP_SWAP";
case PSIF_WR_MASK_FETCH_ADD:
return "PSIF_WR_MASK_FETCH_ADD";
case PSIF_WR_LSO:
return "PSIF_WR_LSO";
case PSIF_WR_INVALIDATE_RKEY:
return "PSIF_WR_INVALIDATE_RKEY";
case PSIF_WR_INVALIDATE_LKEY:
return "PSIF_WR_INVALIDATE_LKEY";
return "PSIF_WR_INVALIDATE_BOTH_KEYS";
case PSIF_WR_INVALIDATE_TLB:
return "PSIF_WR_INVALIDATE_TLB";
case PSIF_WR_RESIZE_CQ:
return "PSIF_WR_RESIZE_CQ";
case PSIF_WR_SET_SRQ_LIM:
return "PSIF_WR_SET_SRQ_LIM";
case PSIF_WR_SET_XRCSRQ_LIM:
return "PSIF_WR_SET_XRCSRQ_LIM";
case PSIF_WR_REQ_CMPL_NOTIFY:
return "PSIF_WR_REQ_CMPL_NOTIFY";
case PSIF_WR_CMPL_NOTIFY_RCVD:
return "PSIF_WR_CMPL_NOTIFY_RCVD";
case PSIF_WR_REARM_CMPL_EVENT:
return "PSIF_WR_REARM_CMPL_EVENT";
return "PSIF_WR_GENERATE_COMPLETION";
case PSIF_WR_INVALIDATE_RQ:
return "PSIF_WR_INVALIDATE_RQ";
case PSIF_WR_INVALIDATE_CQ:
return "PSIF_WR_INVALIDATE_CQ";
return "PSIF_WR_INVALIDATE_XRCSRQ";
return "PSIF_WR_INVALIDATE_SGL_CACHE";
default:
return "UNKNOWN_psif_wr_type";
}
}
enum psif_wr_type data)
{
} /* end write_..._psif_wr_type(psif_wr_type data) */
/* Convert enum psif_port to string */
{
switch (val) {
case PORT_1:
return "PORT_1";
case PORT_2:
return "PORT_2";
default:
return "UNKNOWN_psif_port";
}
}
{
} /* end write_..._psif_port(psif_port data) */
/* Convert enum psif_use_ah to string */
{
switch (val) {
case NO_AHA:
return "NO_AHA";
case USE_AHA:
return "USE_AHA";
default:
return "UNKNOWN_psif_use_ah";
}
}
enum psif_use_ah data)
{
} /* end write_..._psif_use_ah(psif_use_ah data) */
/* Convert enum psif_tsu_qos to string */
{
switch (val) {
case QOSL_HIGH_BANDWIDTH:
return "QOSL_HIGH_BANDWIDTH";
case QOSL_LOW_LATENCY:
return "QOSL_LOW_LATENCY";
default:
return "UNKNOWN_psif_tsu_qos";
}
}
enum psif_tsu_qos data)
{
} /* end write_..._psif_tsu_qos(psif_tsu_qos data) */
/* Convert enum psif_wc_opcode to string */
{
switch (val) {
case PSIF_WC_OPCODE_SEND:
return "PSIF_WC_OPCODE_SEND";
case PSIF_WC_OPCODE_RDMA_WR:
return "PSIF_WC_OPCODE_RDMA_WR";
case PSIF_WC_OPCODE_RDMA_READ:
return "PSIF_WC_OPCODE_RDMA_READ";
case PSIF_WC_OPCODE_CMP_SWAP:
return "PSIF_WC_OPCODE_CMP_SWAP";
case PSIF_WC_OPCODE_FETCH_ADD:
return "PSIF_WC_OPCODE_FETCH_ADD";
case PSIF_WC_OPCODE_LSO:
return "PSIF_WC_OPCODE_LSO";
return "PSIF_WC_OPCODE_MASKED_CMP_SWAP";
return "PSIF_WC_OPCODE_MASKED_FETCH_ADD";
return "PSIF_WC_OPCODE_INVALIDATE_RKEY";
return "PSIF_WC_OPCODE_INVALIDATE_LKEY";
return "PSIF_WC_OPCODE_INVALIDATE_BOTH_KEYS";
return "PSIF_WC_OPCODE_INVALIDATE_TLB";
case PSIF_WC_OPCODE_RESIZE_CQ:
return "PSIF_WC_OPCODE_RESIZE_CQ";
return "PSIF_WC_OPCODE_SET_SRQ_LIM";
return "PSIF_WC_OPCODE_SET_XRCSRQ_LIM";
return "PSIF_WC_OPCODE_REQ_CMPL_NOTIFY";
return "PSIF_WC_OPCODE_CMPL_NOTIFY_RCVD";
return "PSIF_WC_OPCODE_REARM_CMPL_EVENT";
return "PSIF_WC_OPCODE_GENERATE_COMPLETION";
return "PSIF_WC_OPCODE_INVALIDATE_RQ";
return "PSIF_WC_OPCODE_INVALIDATE_CQ";
return "PSIF_WC_OPCODE_INVALIDATE_RB";
return "PSIF_WC_OPCODE_INVALIDATE_XRCSRQ";
return "PSIF_WC_OPCODE_INVALIDATE_SGL_CACHE";
return "PSIF_WC_OPCODE_RECEIVE_SEND";
return "PSIF_WC_OPCODE_RECEIVE_RDMA_WR_IMM";
return "PSIF_WC_OPCODE_RECEIVE_CONDITIONAL_WR_IMM";
default:
return "UNKNOWN_psif_wc_opcode";
}
}
enum psif_wc_opcode data)
{
} /* end write_..._psif_wc_opcode(psif_wc_opcode data) */
/* Convert enum psif_wc_status to string */
{
switch (val) {
case PSIF_WC_STATUS_SUCCESS:
return "PSIF_WC_STATUS_SUCCESS";
return "PSIF_WC_STATUS_LOC_LEN_ERR";
return "PSIF_WC_STATUS_LOC_QP_OP_ERR";
return "PSIF_WC_STATUS_LOC_EEC_OP_ERR";
return "PSIF_WC_STATUS_LOC_PROT_ERR";
return "PSIF_WC_STATUS_WR_FLUSH_ERR";
return "PSIF_WC_STATUS_MW_BIND_ERR";
return "PSIF_WC_STATUS_BAD_RESP_ERR";
return "PSIF_WC_STATUS_LOC_ACCESS_ERR";
return "PSIF_WC_STATUS_REM_INV_REQ_ERR";
return "PSIF_WC_STATUS_REM_ACCESS_ERR";
return "PSIF_WC_STATUS_REM_OP_ERR";
return "PSIF_WC_STATUS_RETRY_EXC_ERR";
return "PSIF_WC_STATUS_RNR_RETRY_EXC_ERR";
return "PSIF_WC_STATUS_LOC_RDD_VIOL_ERR";
return "PSIF_WC_STATUS_REM_INV_RD_REQ_ERR";
return "PSIF_WC_STATUS_REM_ABORT_ERR";
return "PSIF_WC_STATUS_INV_EECN_ERR";
return "PSIF_WC_STATUS_INV_EEC_STATE_ERR";
case PSIF_WC_STATUS_FATAL_ERR:
return "PSIF_WC_STATUS_FATAL_ERR";
return "PSIF_WC_STATUS_RESP_TIMEOUT_ERR";
return "PSIF_WC_STATUS_GENERAL_ERR";
case PSIF_WC_STATUS_FIELD_MAX:
return "PSIF_WC_STATUS_FIELD_MAX";
default:
return "UNKNOWN_psif_wc_status";
}
}
enum psif_wc_status data)
{
} /* end write_..._psif_wc_status(psif_wc_status data) */
/* Convert enum ib_opcode to string */
{
switch (val) {
case RC_SEND_First:
return "RC_SEND_First";
case RC_SEND_Middle:
return "RC_SEND_Middle";
case RC_SEND_Last:
return "RC_SEND_Last";
case RC_SEND_Last_Imm:
return "RC_SEND_Last_Imm";
case RC_SEND_Only:
return "RC_SEND_Only";
case RC_SEND_Only_Imm:
return "RC_SEND_Only_Imm";
case RC_RDMA_WR_First:
return "RC_RDMA_WR_First";
case RC_RDMA_WR_Middle:
return "RC_RDMA_WR_Middle";
case RC_RDMA_WR_Last:
return "RC_RDMA_WR_Last";
case RC_RDMA_WR_Last_Imm:
return "RC_RDMA_WR_Last_Imm";
case RC_RDMA_WR_Only:
return "RC_RDMA_WR_Only";
case RC_RDMA_WR_Only_Imm:
return "RC_RDMA_WR_Only_Imm";
case RC_RDMA_RD_Req:
return "RC_RDMA_RD_Req";
case RC_RDMA_RD_Resp_First:
return "RC_RDMA_RD_Resp_First";
case RC_RDMA_RD_Resp_Middle:
return "RC_RDMA_RD_Resp_Middle";
case RC_RDMA_RD_Resp_Last:
return "RC_RDMA_RD_Resp_Last";
case RC_RDMA_RD_Resp_Only:
return "RC_RDMA_RD_Resp_Only";
case RC_ACK:
return "RC_ACK";
case RC_Atomic_ACK:
return "RC_Atomic_ACK";
case RC_CmpSwap:
return "RC_CmpSwap";
case RC_FetchAdd:
return "RC_FetchAdd";
case RC_Reserved:
return "RC_Reserved";
case RC_SEND_Last_Invalid:
return "RC_SEND_Last_Invalid";
case RC_SEND_Only_Invalid:
return "RC_SEND_Only_Invalid";
case RC_MaskCmpSwap:
return "RC_MaskCmpSwap";
case RC_MaskFetchAdd:
return "RC_MaskFetchAdd";
case UC_SEND_First:
return "UC_SEND_First";
case UC_SEND_Middle:
return "UC_SEND_Middle";
case UC_SEND_Last:
return "UC_SEND_Last";
case UC_SEND_Last_Imm:
return "UC_SEND_Last_Imm";
case UC_SEND_Only:
return "UC_SEND_Only";
case UC_SEND_Only_Imm:
return "UC_SEND_Only_Imm";
case UC_RDMA_WR_First:
return "UC_RDMA_WR_First";
case UC_RDMA_WR_Middle:
return "UC_RDMA_WR_Middle";
case UC_RDMA_WR_Last:
return "UC_RDMA_WR_Last";
case UC_RDMA_WR_Last_Imm:
return "UC_RDMA_WR_Last_Imm";
case UC_RDMA_WR_Only:
return "UC_RDMA_WR_Only";
case UC_RDMA_WR_Only_Imm:
return "UC_RDMA_WR_Only_Imm";
case RD_SEND_First:
return "RD_SEND_First";
case RD_SEND_Middle:
return "RD_SEND_Middle";
case RD_SEND_Last:
return "RD_SEND_Last";
case RD_SEND_Last_Imm:
return "RD_SEND_Last_Imm";
case RD_SEND_Only:
return "RD_SEND_Only";
case RD_SEND_Only_Imm:
return "RD_SEND_Only_Imm";
case RD_RDMA_WR_First:
return "RD_RDMA_WR_First";
case RD_RDMA_WR_Middle:
return "RD_RDMA_WR_Middle";
case RD_RDMA_WR_Last:
return "RD_RDMA_WR_Last";
case RD_RDMA_WR_Last_Imm:
return "RD_RDMA_WR_Last_Imm";
case RD_RDMA_WR_Only:
return "RD_RDMA_WR_Only";
case RD_RDMA_WR_Only_Imm:
return "RD_RDMA_WR_Only_Imm";
case RD_RDMA_RD_Req:
return "RD_RDMA_RD_Req";
case RD_RDMA_RD_Resp_First:
return "RD_RDMA_RD_Resp_First";
case RD_RDMA_RD_Resp_Middle:
return "RD_RDMA_RD_Resp_Middle";
case RD_RDMA_RD_Resp_Last:
return "RD_RDMA_RD_Resp_Last";
case RD_RDMA_RD_Resp_Only:
return "RD_RDMA_RD_Resp_Only";
case RD_ACK:
return "RD_ACK";
case RD_Atomic_ACK:
return "RD_Atomic_ACK";
case RD_CmpSwap:
return "RD_CmpSwap";
case RD_FetchAdd:
return "RD_FetchAdd";
case RD_RESYNC:
return "RD_RESYNC";
case UD_SEND_Only:
return "UD_SEND_Only";
case UD_SEND_Only_Imm:
return "UD_SEND_Only_Imm";
case CNP:
return "CNP";
case XRC_SEND_First:
return "XRC_SEND_First";
case XRC_SEND_Middle:
return "XRC_SEND_Middle";
case XRC_SEND_Last:
return "XRC_SEND_Last";
case XRC_SEND_Last_Imm:
return "XRC_SEND_Last_Imm";
case XRC_SEND_Only:
return "XRC_SEND_Only";
case XRC_SEND_Only_Imm:
return "XRC_SEND_Only_Imm";
case XRC_RDMA_WR_First:
return "XRC_RDMA_WR_First";
case XRC_RDMA_WR_Middle:
return "XRC_RDMA_WR_Middle";
case XRC_RDMA_WR_Last:
return "XRC_RDMA_WR_Last";
case XRC_RDMA_WR_Last_Imm:
return "XRC_RDMA_WR_Last_Imm";
case XRC_RDMA_WR_Only:
return "XRC_RDMA_WR_Only";
case XRC_RDMA_WR_Only_Imm:
return "XRC_RDMA_WR_Only_Imm";
case XRC_RDMA_RD_Req:
return "XRC_RDMA_RD_Req";
case XRC_RDMA_RD_Resp_First:
return "XRC_RDMA_RD_Resp_First";
case XRC_RDMA_RD_Resp_Middle:
return "XRC_RDMA_RD_Resp_Middle";
case XRC_RDMA_RD_Resp_Last:
return "XRC_RDMA_RD_Resp_Last";
case XRC_RDMA_RD_Resp_Only:
return "XRC_RDMA_RD_Resp_Only";
case XRC_ACK:
return "XRC_ACK";
case XRC_Atomic_ACK:
return "XRC_Atomic_ACK";
case XRC_CmpSwap:
return "XRC_CmpSwap";
case XRC_FetchAdd:
return "XRC_FetchAdd";
case XRC_Reserved:
return "XRC_Reserved";
case XRC_SEND_Last_Invalid:
return "XRC_SEND_Last_Invalid";
case XRC_SEND_Only_Invalid:
return "XRC_SEND_Only_Invalid";
case XRC_MaskCmpSwap:
return "XRC_MaskCmpSwap";
case XRC_MaskFetchAdd:
return "XRC_MaskFetchAdd";
case MANSP1_INVALID:
return "MANSP1_INVALID";
case MANSP1_HOST_READ:
return "MANSP1_HOST_READ";
case MANSP1_HOST_WRITE:
return "MANSP1_HOST_WRITE";
return "MANSP1_HOST_READ_NO_DMAVT";
return "MANSP1_HOST_WRITE_NO_DMAVT";
case MANSP1_INTERNAL_TYPE:
return "MANSP1_INTERNAL_TYPE";
return "MANSP1_INTERNAL_TYPE_MMU_BYPASS";
case MANSP1_HOST_CMP_SWAP:
return "MANSP1_HOST_CMP_SWAP";
case MANSP1_DR_LOOPBACK:
return "MANSP1_DR_LOOPBACK";
case MANSP1_ARP_LOOPBACK:
return "MANSP1_ARP_LOOPBACK";
default:
return "UNKNOWN_ib_opcode";
}
}
{
} /* end write_..._ib_opcode(ib_opcode data) */
/* Convert enum psif_eps_a_core to string */
{
switch (val) {
case PSIF_EPS_A_1:
return "PSIF_EPS_A_1";
case PSIF_EPS_A_2:
return "PSIF_EPS_A_2";
case PSIF_EPS_A_3:
return "PSIF_EPS_A_3";
case PSIF_EPS_A_4:
return "PSIF_EPS_A_4";
default:
return "UNKNOWN_psif_eps_a_core";
}
}
enum psif_eps_a_core data)
{
} /* end write_..._psif_eps_a_core(psif_eps_a_core data) */
/* Convert enum psif_qp_state to string */
{
switch (val) {
case PSIF_QP_STATE_RESET:
return "PSIF_QP_STATE_RESET";
case PSIF_QP_STATE_INIT:
return "PSIF_QP_STATE_INIT";
case PSIF_QP_STATE_RTR:
return "PSIF_QP_STATE_RTR";
case PSIF_QP_STATE_RTS:
return "PSIF_QP_STATE_RTS";
case PSIF_QP_STATE_SQERR:
return "PSIF_QP_STATE_SQERR";
case PSIF_QP_STATE_ERROR:
return "PSIF_QP_STATE_ERROR";
case PSIF_QP_STATE_INVALID:
return "PSIF_QP_STATE_INVALID";
default:
return "UNKNOWN_psif_qp_state";
}
}
enum psif_qp_state data)
{
} /* end write_..._psif_qp_state(psif_qp_state data) */
/* Convert enum psif_cmpl_outstanding_error to string */
{
switch (val) {
case CMPL_NO_ERROR:
return "CMPL_NO_ERROR";
return "CMPL_RQS_INVALID_REQUEST_ERR";
return "CMPL_RQS_QP_IN_WRONG_STATE_ERR";
return "CMPL_RQS_MAX_OUTSTANDING_REACHED_ERR";
return "CMPL_RQS_REQUEST_FENCED_ERR";
return "CMPL_RQS_CMD_FROM_EPS_ERR";
case CMPL_DMA_SGL_RD_ERR:
return "CMPL_DMA_SGL_RD_ERR";
case CMPL_DMA_PYLD_RD_ERR:
return "CMPL_DMA_PYLD_RD_ERR";
case CMPL_DMA_SGL_LENGTH_ERR:
return "CMPL_DMA_SGL_LENGTH_ERR";
case CMPL_DMA_LKEY_ERR:
return "CMPL_DMA_LKEY_ERR";
default:
return "UNKNOWN_psif_cmpl_outstanding_error";
}
}
{
} /* end write_..._psif_cmpl_outstanding_error(psif_cmpl_outstanding_error data) */
/* Convert enum psif_expected_op to string */
{
switch (val) {
case NO_OPERATION_IN_PROGRESS:
return "NO_OPERATION_IN_PROGRESS";
case EXPECT_SEND_MIDDLE_LAST:
return "EXPECT_SEND_MIDDLE_LAST";
return "EXPECT_RDMA_WR_MIDDLE_LAST";
return "EXPECT_DM_PUT_MIDDLE_LAST";
default:
return "UNKNOWN_psif_expected_op";
}
}
enum psif_expected_op data)
{
} /* end write_..._psif_expected_op(psif_expected_op data) */
/* Convert enum psif_migration to string */
{
switch (val) {
case APM_OFF:
return "APM_OFF";
case APM_MIGRATED:
return "APM_MIGRATED";
case APM_REARM:
return "APM_REARM";
case APM_ARMED:
return "APM_ARMED";
default:
return "UNKNOWN_psif_migration";
}
}
enum psif_migration data)
{
} /* end write_..._psif_migration(psif_migration data) */
/* Convert enum psif_qp_trans to string */
{
switch (val) {
case PSIF_QP_TRANSPORT_RC:
return "PSIF_QP_TRANSPORT_RC";
case PSIF_QP_TRANSPORT_UC:
return "PSIF_QP_TRANSPORT_UC";
case PSIF_QP_TRANSPORT_RD:
return "PSIF_QP_TRANSPORT_RD";
case PSIF_QP_TRANSPORT_UD:
return "PSIF_QP_TRANSPORT_UD";
case PSIF_QP_TRANSPORT_RSVD1:
return "PSIF_QP_TRANSPORT_RSVD1";
case PSIF_QP_TRANSPORT_XRC:
return "PSIF_QP_TRANSPORT_XRC";
case PSIF_QP_TRANSPORT_MANSP1:
return "PSIF_QP_TRANSPORT_MANSP1";
case PSIF_QP_TRANSPORT_MANSP2:
return "PSIF_QP_TRANSPORT_MANSP2";
default:
return "UNKNOWN_psif_qp_trans";
}
}
enum psif_qp_trans data)
{
} /* end write_..._psif_qp_trans(psif_qp_trans data) */
/* Convert enum psif_bool to string */
{
switch (val) {
case FALSE:
return "FALSE";
case TRUE:
return "TRUE";
default:
return "UNKNOWN_psif_bool";
}
}
{
} /* end write_..._psif_bool(psif_bool data) */
/* Convert enum psif_eoib_type to string */
{
switch (val) {
case EOIB_FULL:
return "EOIB_FULL";
case EOIB_PARTIAL:
return "EOIB_PARTIAL";
case EOIB_QKEY_ONLY:
return "EOIB_QKEY_ONLY";
case EOIB_NONE:
return "EOIB_NONE";
default:
return "UNKNOWN_psif_eoib_type";
}
}
enum psif_eoib_type data)
{
} /* end write_..._psif_eoib_type(psif_eoib_type data) */
/* Convert enum psif_comm_live to string */
{
switch (val) {
case NO_COMM_ESTABLISHED:
return "NO_COMM_ESTABLISHED";
case COMM_ESTABLISHED:
return "COMM_ESTABLISHED";
default:
return "UNKNOWN_psif_comm_live";
}
}
enum psif_comm_live data)
{
} /* end write_..._psif_comm_live(psif_comm_live data) */
/* Convert enum psif_path_mtu to string */
{
switch (val) {
case MTU_INVALID:
return "MTU_INVALID";
case MTU_256B:
return "MTU_256B";
case MTU_512B:
return "MTU_512B";
case MTU_1024B:
return "MTU_1024B";
case MTU_2048B:
return "MTU_2048B";
case MTU_4096B:
return "MTU_4096B";
case MTU_10240B:
return "MTU_10240B";
case MTU_XXX:
return "MTU_XXX";
default:
return "UNKNOWN_psif_path_mtu";
}
}
enum psif_path_mtu data)
{
} /* end write_..._psif_path_mtu(psif_path_mtu data) */
/* Convert enum psif_use_grh to string */
{
switch (val) {
case NO_GRH:
return "NO_GRH";
case USE_GRH:
return "USE_GRH";
default:
return "UNKNOWN_psif_use_grh";
}
}
enum psif_use_grh data)
{
} /* end write_..._psif_use_grh(psif_use_grh data) */
/* Convert enum psif_loopback to string */
{
switch (val) {
case NO_LOOPBACK:
return "NO_LOOPBACK";
case LOOPBACK:
return "LOOPBACK";
default:
return "UNKNOWN_psif_loopback";
}
}
enum psif_loopback data)
{
} /* end write_..._psif_loopback(psif_loopback data) */
/* Convert enum psif_qp_command to string */
{
switch (val) {
case QP_CMD_INVALID:
return "QP_CMD_INVALID";
case QP_CMD_MODIFY:
return "QP_CMD_MODIFY";
case QP_CMD_QUERY:
return "QP_CMD_QUERY";
case QP_CMD_CHECK_TIMEOUT:
return "QP_CMD_CHECK_TIMEOUT";
default:
return "UNKNOWN_psif_qp_command";
}
}
enum psif_qp_command data)
{
} /* end write_..._psif_qp_command(psif_qp_command data) */
/* Convert enum psif_mbox_type to string */
{
switch (val) {
case MBOX_EPSA0:
return "MBOX_EPSA0";
case MBOX_EPSA1:
return "MBOX_EPSA1";
case MBOX_EPSA2:
return "MBOX_EPSA2";
case MBOX_EPSA3:
return "MBOX_EPSA3";
case MBOX_EPSC:
return "MBOX_EPSC";
case MBOX_EPS_MAX:
return "MBOX_EPS_MAX";
case PSIF_MBOX_TYPE_FIELD_MAX:
return "PSIF_MBOX_TYPE_FIELD_MAX";
default:
return "UNKNOWN_psif_mbox_type";
}
}
enum psif_mbox_type data)
{
} /* end write_..._psif_mbox_type(psif_mbox_type data) */
/* Convert enum psif_dma_vt_key_states to string */
{
switch (val) {
case PSIF_DMA_KEY_INVALID:
return "PSIF_DMA_KEY_INVALID";
case PSIF_DMA_KEY_FREE:
return "PSIF_DMA_KEY_FREE";
case PSIF_DMA_KEY_VALID:
return "PSIF_DMA_KEY_VALID";
case PSIF_DMA_KEY_MMU_VALID:
return "PSIF_DMA_KEY_MMU_VALID";
default:
return "UNKNOWN_psif_dma_vt_key_states";
}
}
enum psif_dma_vt_key_states data)
{
} /* end write_..._psif_dma_vt_key_states(psif_dma_vt_key_states data) */
/* Convert enum psif_flash_image_type to string */
{
switch (val) {
case PSIF_IMAGE_INVALID:
return "PSIF_IMAGE_INVALID";
case PSIF_IMAGE_BOOT_LOADER:
return "PSIF_IMAGE_BOOT_LOADER";
return "PSIF_IMAGE_EPS_C_APPLICATION";
return "PSIF_IMAGE_EPS_A_APPLICATION";
case PSIF_IMAGE_DIAGNOSTICS:
return "PSIF_IMAGE_DIAGNOSTICS";
return "PSIF_FLASH_IMAGE_TYPE_FIELD_MAX";
default:
return "UNKNOWN_psif_flash_image_type";
}
}
enum psif_flash_image_type data)
{
} /* end write_..._psif_flash_image_type(psif_flash_image_type data) */
/* Convert enum psif_event to string */
{
switch (val) {
case PSIF_EVENT_NO_CHANGE:
return "PSIF_EVENT_NO_CHANGE";
return "PSIF_EVENT_SGID_TABLE_CHANGED";
return "PSIF_EVENT_PKEY_TABLE_CHANGED";
return "PSIF_EVENT_MASTER_SM_LID_CHANGED";
return "PSIF_EVENT_MASTER_SM_SL_CHANGED";
return "PSIF_EVENT_SUBNET_TIMEOUT_CHANGED";
return "PSIF_EVENT_IS_SM_DISABLED_CHANGED";
return "PSIF_EVENT_CLIENT_REREGISTER";
return "PSIF_EVENT_LID_TABLE_CHANGED";
return "PSIF_EVENT_EPSC_COMPLETION";
case PSIF_EVENT_MAILBOX:
return "PSIF_EVENT_MAILBOX";
case PSIF_EVENT_EXTENSION:
return "PSIF_EVENT_EXTENSION";
case PSIF_EVENT_LOG:
return "PSIF_EVENT_LOG";
case PSIF_EVENT_PORT_ACTIVE:
return "PSIF_EVENT_PORT_ACTIVE";
case PSIF_EVENT_PORT_ERR:
return "PSIF_EVENT_PORT_ERR";
case PSIF_EVENT_QUEUE_FULL:
return "PSIF_EVENT_QUEUE_FULL";
case PSIF_EVENT_DEGRADED_MODE:
return "PSIF_EVENT_DEGRADED_MODE";
return "PSIF_EVENT_EPSC_KEEP_ALIVE";
return "PSIF_EVENT_EPSC_MMU_FLUSH_DONE";
case PSIF_EVENT_FIELD_MAX:
return "PSIF_EVENT_FIELD_MAX";
default:
return "UNKNOWN_psif_event";
}
}
enum psif_event data)
{
} /* end write_..._psif_event(psif_event data) */
/* Convert enum psif_tsu_error_types to string */
{
switch (val) {
case TSU_NO_ERROR:
return "TSU_NO_ERROR";
case TSU_IBPR_ICRC_ERR:
return "TSU_IBPR_ICRC_ERR";
return "TSU_IBPR_INVALID_PKEY_ERR";
case TSU_IBPR_INVALID_QP_ERR:
return "TSU_IBPR_INVALID_QP_ERR";
case TSU_IBPR_VSWITCH_UF_ERR:
return "TSU_IBPR_VSWITCH_UF_ERR";
case TSU_IBPR_PKTLEN_ERR:
return "TSU_IBPR_PKTLEN_ERR";
return "TSU_IBPR_UNDEFINED_OPCODE_ERR";
return "TSU_IBPR_MCAST_NO_GRH_ERR";
return "TSU_IBPR_MCAST_NO_TARGET_ERR";
return "TSU_IBPR_INVALID_DGID_ERR";
case TSU_IBPR_BADPKT_ERR:
return "TSU_IBPR_BADPKT_ERR";
case TSU_RCV_QP_INVALID_ERR:
return "TSU_RCV_QP_INVALID_ERR";
case TSU_RCV_HDR_BTH_TVER_ERR:
return "TSU_RCV_HDR_BTH_TVER_ERR";
case TSU_RCV_HDR_BTH_QP_ERR:
return "TSU_RCV_HDR_BTH_QP_ERR";
case TSU_RCV_HDR_GRH_ERR:
return "TSU_RCV_HDR_GRH_ERR";
case TSU_RCV_HDR_PKEY_ERR:
return "TSU_RCV_HDR_PKEY_ERR";
case TSU_RCV_HDR_QKEY_ERR:
return "TSU_RCV_HDR_QKEY_ERR";
case TSU_RCV_HDR_LID_ERR:
return "TSU_RCV_HDR_LID_ERR";
case TSU_RCV_HDR_MAD_ERR:
return "TSU_RCV_HDR_MAD_ERR";
case TSU_RCV_EOIB_MCAST_ERR:
return "TSU_RCV_EOIB_MCAST_ERR";
case TSU_RCV_EOIB_BCAST_ERR:
return "TSU_RCV_EOIB_BCAST_ERR";
case TSU_RCV_EOIB_UCAST_ERR:
return "TSU_RCV_EOIB_UCAST_ERR";
return "TSU_RCV_EOIB_TCP_PORT_VIOLATION_ERR";
case TSU_RCV_EOIB_RUNTS_ERR:
return "TSU_RCV_EOIB_RUNTS_ERR";
return "TSU_RCV_EOIB_OUTER_VLAN_ERR";
return "TSU_RCV_EOIB_VLAN_TAG_ERR";
case TSU_RCV_EOIB_VID_ERR:
return "TSU_RCV_EOIB_VID_ERR";
return "TSU_RCV_IPOIB_TCP_PORT_VIOLATION_ERR";
case TSU_RCV_MCAST_DUP_ERR:
return "TSU_RCV_MCAST_DUP_ERR";
case TSU_RCV_ECC_ERR:
return "TSU_RCV_ECC_ERR";
return "TSU_DSCR_RESPONDER_RC_PSN_ERR";
return "TSU_DSCR_RESPONDER_RC_DUPLICATE";
return "TSU_DSCR_RESPONDER_RC_OPCODE_SEQ_ERR";
return "TSU_DSCR_RESPONDER_RC_OPCODE_VAL_ERR";
return "TSU_DSCR_RESPONDER_RC_OPCODE_LEN_ERR";
return "TSU_DSCR_RESPONDER_RC_DMALEN_ERR";
return "TSU_DSCR_RESPONDER_XRC_PSN_ERR";
return "TSU_DSCR_RESPONDER_XRC_DUPLICATE";
return "TSU_DSCR_RESPONDER_XRC_OPCODE_SEQ_ERR";
return "TSU_DSCR_RESPONDER_XRC_OPCODE_VAL_ERR";
return "TSU_DSCR_RESPONDER_XRC_OPCODE_LEN_ERR";
return "TSU_DSCR_RESPONDER_XRC_DMALEN_ERR";
return "TSU_DSCR_RESPONDER_UC_PSN_ERR";
return "TSU_DSCR_RESPONDER_UC_OPCODE_SEQ_ERR";
return "TSU_DSCR_RESPONDER_UC_OPCODE_VAL_ERR";
return "TSU_DSCR_RESPONDER_UC_OPCODE_LEN_ERR";
return "TSU_DSCR_RESPONDER_UC_DMALEN_ERR";
return "TSU_DSCR_RESPONDER_UD_OPCODE_LEN_ERR";
return "TSU_DSCR_RESPONDER_DUPLICATE_WITH_ERR";
return "TSU_DSCR_QP_CAP_MASKED_ATOMIC_ENABLE_ERR";
return "TSU_DSCR_QP_CAP_RDMA_RD_ENABLE_ERR";
return "TSU_DSCR_QP_CAP_RDMA_WR_ENABLE_ERR";
return "TSU_DSCR_QP_CAP_ATOMIC_ENABLE_ERR";
return "TSU_DSCR_XRC_DOMAIN_VIOLATION_ERR";
case TSU_DSCR_XRCETH_ERR:
return "TSU_DSCR_XRCETH_ERR";
case TSU_DSCR_RQ_INVALID_ERR:
return "TSU_DSCR_RQ_INVALID_ERR";
case TSU_DSCR_RQ_PD_CHECK_ERR:
return "TSU_DSCR_RQ_PD_CHECK_ERR";
case TSU_DSCR_RQ_EMPTY_ERR:
return "TSU_DSCR_RQ_EMPTY_ERR";
case TSU_DSCR_RQ_IN_ERROR_ERR:
return "TSU_DSCR_RQ_IN_ERROR_ERR";
return "TSU_DSCR_TRANSLATION_TYPE_ERR";
return "TSU_DSCR_RQ_DESCRIPTOR_INCONSISTENT_ERR";
return "TSU_DSCR_MISALIGNED_ATOMIC_ERR";
case TSU_DSCR_PCIE_ERR:
return "TSU_DSCR_PCIE_ERR";
case TSU_DSCR_ECC_ERR:
return "TSU_DSCR_ECC_ERR";
case TSU_RQH_PCIE_ERR:
return "TSU_RQH_PCIE_ERR";
case TSU_RQH_SGL_LKEY_ERR:
return "TSU_RQH_SGL_LKEY_ERR";
return "TSU_RQH_NOT_ENOUGH_RQ_SPACE_ERR";
case TSU_RQH_ECC_ERR:
return "TSU_RQH_ECC_ERR";
return "TSU_VAL_DUPLICATE_WITH_ERR";
case TSU_VAL_RKEY_VLD_ERR:
return "TSU_VAL_RKEY_VLD_ERR";
return "TSU_VAL_RKEY_ADDR_RANGE_ERR";
case TSU_VAL_RKEY_ACCESS_ERR:
return "TSU_VAL_RKEY_ACCESS_ERR";
case TSU_VAL_RKEY_PD_ERR:
return "TSU_VAL_RKEY_PD_ERR";
case TSU_VAL_RKEY_RANGE_ERR:
return "TSU_VAL_RKEY_RANGE_ERR";
case TSU_VAL_LKEY_VLD_ERR:
return "TSU_VAL_LKEY_VLD_ERR";
return "TSU_VAL_LKEY_ADDR_RANGE_ERR";
case TSU_VAL_LKEY_ACCESS_ERR:
return "TSU_VAL_LKEY_ACCESS_ERR";
case TSU_VAL_LKEY_PD_ERR:
return "TSU_VAL_LKEY_PD_ERR";
case TSU_VAL_LKEY_RANGE_ERR:
return "TSU_VAL_LKEY_RANGE_ERR";
return "TSU_VAL_TRANSLATION_TYPE_ERR";
case TSU_VAL_PCIE_ERR:
return "TSU_VAL_PCIE_ERR";
case TSU_VAL_ECC_ERR:
return "TSU_VAL_ECC_ERR";
return "TSU_MMU_DUPLICATE_WITH_ERR";
case TSU_MMU_PTW_ERR:
return "TSU_MMU_PTW_ERR";
case TSU_MMU_UF_ERR:
return "TSU_MMU_UF_ERR";
case TSU_MMU_AC_ERR:
return "TSU_MMU_AC_ERR";
case TSU_MMU_ECC_ERR:
return "TSU_MMU_ECC_ERR";
case TSU_CBLD_CQ_INVALID_ERR:
return "TSU_CBLD_CQ_INVALID_ERR";
case TSU_CBLD_CQ_FULL_ERR:
return "TSU_CBLD_CQ_FULL_ERR";
return "TSU_CBLD_CQ_ALREADY_IN_ERR";
case TSU_CBLD_CQ_IS_PROXY_ERR:
return "TSU_CBLD_CQ_IS_PROXY_ERR";
return "TSU_CBLD_TRANSLATION_TYPE_ERR";
return "TSU_CBLD_CQ_DESCRIPTOR_INCONSISTENT_ERR";
case TSU_CBLD_ECC_ERR:
return "TSU_CBLD_ECC_ERR";
case TSU_CBLD_PCIE_ERR:
return "TSU_CBLD_PCIE_ERR";
case TSU_CBLD_QP_ERR:
return "TSU_CBLD_QP_ERR";
case TSU_RQS_CHECKSUM_ERR:
return "TSU_RQS_CHECKSUM_ERR";
case TSU_RQS_SEQNUM_ERR:
return "TSU_RQS_SEQNUM_ERR";
return "TSU_RQS_INVALID_REQUEST_ERR";
return "TSU_RQS_QP_IN_WRONG_STATE_ERR";
case TSU_RQS_STOP_TIMER_ERR:
return "TSU_RQS_STOP_TIMER_ERR";
case TSU_RQS_CMD_FROM_EPS_ERR:
return "TSU_RQS_CMD_FROM_EPS_ERR";
case TSU_RQS_SQ_FLUSH_ERR:
return "TSU_RQS_SQ_FLUSH_ERR";
case TSU_RQS_SMP_NOT_AUTH_ERR:
return "TSU_RQS_SMP_NOT_AUTH_ERR";
return "TSU_RQS_REQUEST_FENCED_ERR";
return "TSU_RQS_MAX_OUTSTANDING_REACHED_ERR";
case TSU_RQS_ECC_ERR:
return "TSU_RQS_ECC_ERR";
return "TSU_RQS_EOIB_QKEY_VIOLATION";
return "TSU_RQS_IPOIB_QKEY_VIOLATION";
return "TSU_RQS_EOIB_MODE_VIOLATION";
case TSU_RQS_MISCONFIGURED_QP:
return "TSU_RQS_MISCONFIGURED_QP";
return "TSU_RQS_PORT_AUTH_VIOLATION";
case TSU_DMA_SGL_RD_ERR:
return "TSU_DMA_SGL_RD_ERR";
case TSU_DMA_REQ_PYLD_RD_ERR:
return "TSU_DMA_REQ_PYLD_RD_ERR";
case TSU_DMA_RESP_PYLD_RD_ERR:
return "TSU_DMA_RESP_PYLD_RD_ERR";
case TSU_DMA_SGL_LENGTH_ERR:
return "TSU_DMA_SGL_LENGTH_ERR";
case TSU_DMA_LKEY_ERR:
return "TSU_DMA_LKEY_ERR";
case TSU_DMA_RKEY_ERR:
return "TSU_DMA_RKEY_ERR";
case TSU_DMA_LSO_PKTLEN_ERR:
return "TSU_DMA_LSO_PKTLEN_ERR";
return "TSU_DMA_LSO_ILLEGAL_CLASSIFICATION_ERR";
case TSU_DMA_PCIE_ERR:
return "TSU_DMA_PCIE_ERR";
case TSU_DMA_ECC_ERR:
return "TSU_DMA_ECC_ERR";
case TSU_CMPL_PCIE_ERR:
return "TSU_CMPL_PCIE_ERR";
case TSU_CMPL_ECC_ERR:
return "TSU_CMPL_ECC_ERR";
return "TSU_CMPL_REQUESTER_PSN_ERR";
return "TSU_CMPL_REQUESTER_SYNDROME_ERR";
return "TSU_CMPL_REQUESTER_OUTSTANDING_MATCH_ERR";
return "TSU_CMPL_REQUESTER_LEN_ERR";
return "TSU_CMPL_REQUESTER_UNEXP_OPCODE_ERR";
return "TSU_CMPL_REQUESTER_DUPLICATE";
case TSU_CMPL_RC_IN_ERROR_ERR:
return "TSU_CMPL_RC_IN_ERROR_ERR";
case TSU_CMPL_NAK_RNR_ERR:
return "TSU_CMPL_NAK_RNR_ERR";
return "TSU_CMPL_NAK_SEQUENCE_ERR";
return "TSU_CMPL_NAK_INVALID_REQUEST_ERR";
return "TSU_CMPL_NAK_REMOTE_ACCESS_ERR";
return "TSU_CMPL_NAK_REMOTE_OPS_ERR";
return "TSU_CMPL_NAK_INVALID_RD_REQUEST_ERR";
case TSU_CMPL_TIMEOUT_ERR:
return "TSU_CMPL_TIMEOUT_ERR";
case TSU_CMPL_IMPLIED_NAK:
return "TSU_CMPL_IMPLIED_NAK";
case TSU_CMPL_GHOST_RESP_ERR:
return "TSU_CMPL_GHOST_RESP_ERR";
default:
return "UNKNOWN_psif_tsu_error_types";
}
}
enum psif_tsu_error_types data)
{
} /* end write_..._psif_tsu_error_types(psif_tsu_error_types data) */
/* Convert enum psif_eps_core_id to string */
{
switch (val) {
case PSIF_EVENT_CORE_EPS_A_1:
return "PSIF_EVENT_CORE_EPS_A_1";
case PSIF_EVENT_CORE_EPS_A_2:
return "PSIF_EVENT_CORE_EPS_A_2";
case PSIF_EVENT_CORE_EPS_A_3:
return "PSIF_EVENT_CORE_EPS_A_3";
case PSIF_EVENT_CORE_EPS_A_4:
return "PSIF_EVENT_CORE_EPS_A_4";
case PSIF_EVENT_CORE_EPS_C:
return "PSIF_EVENT_CORE_EPS_C";
return "PSIF_EPS_CORE_ID_FIELD_MAX";
default:
return "UNKNOWN_psif_eps_core_id";
}
}
enum psif_eps_core_id data)
{
} /* end write_..._psif_eps_core_id(psif_eps_core_id data) */
/* Convert enum psif_epsc_port_state to string */
{
switch (val) {
case EPSC_PORT_NOP:
return "EPSC_PORT_NOP";
case EPSC_PORT_DOWN:
return "EPSC_PORT_DOWN";
case EPSC_PORT_INIT:
return "EPSC_PORT_INIT";
case EPSC_PORT_ARMED:
return "EPSC_PORT_ARMED";
case EPSC_PORT_ACTIVE:
return "EPSC_PORT_ACTIVE";
case EPSC_PORT_ACTIVE_DEFER:
return "EPSC_PORT_ACTIVE_DEFER";
return "PSIF_EPSC_PORT_STATE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_port_state";
}
}
enum psif_epsc_port_state data)
{
} /* end write_..._psif_epsc_port_state(psif_epsc_port_state data) */
/* Convert enum psif_epsc_log_mode to string */
{
switch (val) {
case EPSC_LOG_MODE_OFF:
return "EPSC_LOG_MODE_OFF";
case EPSC_LOG_MODE_SCAT:
return "EPSC_LOG_MODE_SCAT";
case EPSC_LOG_MODE_MALLOC:
return "EPSC_LOG_MODE_MALLOC";
case EPSC_LOG_MODE_LOCAL:
return "EPSC_LOG_MODE_LOCAL";
case EPSC_LOG_MODE_HOST:
return "EPSC_LOG_MODE_HOST";
case EPSC_LOG_MODE_SAVE:
return "EPSC_LOG_MODE_SAVE";
return "PSIF_EPSC_LOG_MODE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_log_mode";
}
}
enum psif_epsc_log_mode data)
{
} /* end write_..._psif_epsc_log_mode(psif_epsc_log_mode data) */
/* Convert enum psif_epsc_log_level to string */
{
switch (val) {
case EPS_LOG_OFF:
return "EPS_LOG_OFF";
case EPS_LOG_FATAL:
return "EPS_LOG_FATAL";
case EPS_LOG_ERROR:
return "EPS_LOG_ERROR";
case EPS_LOG_WARN:
return "EPS_LOG_WARN";
case EPS_LOG_INFO:
return "EPS_LOG_INFO";
case EPS_LOG_DEBUG:
return "EPS_LOG_DEBUG";
case EPS_LOG_TRACE:
return "EPS_LOG_TRACE";
case EPS_LOG_ALL:
return "EPS_LOG_ALL";
return "PSIF_EPSC_LOG_LEVEL_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_log_level";
}
}
enum psif_epsc_log_level data)
{
} /* end write_..._psif_epsc_log_level(psif_epsc_log_level data) */
/* Convert enum psif_epsc_interrupt_source to string */
{
switch (val) {
case EPSC_INTR_LCSR:
return "EPSC_INTR_LCSR";
case EPSC_INTR_MBOX:
return "EPSC_INTR_MBOX";
case EPSC_INTR_XIU:
return "EPSC_INTR_XIU";
case EPSC_INTR_IBU0:
return "EPSC_INTR_IBU0";
case EPSC_INTR_IBU1:
return "EPSC_INTR_IBU1";
case EPSC_INTR_TSU_NCSI:
return "EPSC_INTR_TSU_NCSI";
case EPSC_INTR_TSU_IBPB:
return "EPSC_INTR_TSU_IBPB";
case EPSC_INTR_TSU_DMA:
return "EPSC_INTR_TSU_DMA";
case EPSC_INTR_TSU_RQS:
return "EPSC_INTR_TSU_RQS";
case EPSC_INTR_TSU_QPS:
return "EPSC_INTR_TSU_QPS";
case EPSC_INTR_TSU_SQS:
return "EPSC_INTR_TSU_SQS";
case EPSC_INTR_TSU_ERR:
return "EPSC_INTR_TSU_ERR";
case EPSC_INTR_TSU_CMPL:
return "EPSC_INTR_TSU_CMPL";
case EPSC_INTR_TSU_VAL:
return "EPSC_INTR_TSU_VAL";
case EPSC_INTR_TSU_RQH:
return "EPSC_INTR_TSU_RQH";
case EPSC_INTR_TSU_DSCR:
return "EPSC_INTR_TSU_DSCR";
case EPSC_INTR_TSU_RCV:
return "EPSC_INTR_TSU_RCV";
case EPSC_INTR_TSU_IBPR:
return "EPSC_INTR_TSU_IBPR";
case EPSC_INTR_TSU_CBU:
return "EPSC_INTR_TSU_CBU";
case EPSC_INTR_TSU_HOST:
return "EPSC_INTR_TSU_HOST";
case EPSC_INTR_TSU_MMU:
return "EPSC_INTR_TSU_MMU";
default:
return "UNKNOWN_psif_epsc_interrupt_source";
}
}
{
} /* end write_..._psif_epsc_interrupt_source(psif_epsc_interrupt_source data) */
/* Convert enum psif_epsc_interrupt_pri to string */
{
switch (val) {
case EPSC_INTR_RESERVED:
return "EPSC_INTR_RESERVED";
case EPSC_INTR_LOW:
return "EPSC_INTR_LOW";
case EPSC_INTR_HIGH:
return "EPSC_INTR_HIGH";
case EPSC_INTR_FATAL:
return "EPSC_INTR_FATAL";
default:
return "UNKNOWN_psif_epsc_interrupt_pri";
}
}
enum psif_epsc_interrupt_pri data)
{
} /* end write_..._psif_epsc_interrupt_pri(psif_epsc_interrupt_pri data) */
/* Convert enum psif_epsc_csr_status to string */
{
switch (val) {
case EPSC_SUCCESS:
return "EPSC_SUCCESS";
case EPSC_EKEYREJECTED:
return "EPSC_EKEYREJECTED";
case EPSC_EADDRNOTAVAIL:
return "EPSC_EADDRNOTAVAIL";
case EPSC_EOPNOTSUPP:
return "EPSC_EOPNOTSUPP";
case EPSC_ENOMEM:
return "EPSC_ENOMEM";
case EPSC_ENODATA:
return "EPSC_ENODATA";
case EPSC_EAGAIN:
return "EPSC_EAGAIN";
case EPSC_ECANCELED:
return "EPSC_ECANCELED";
case EPSC_ECONNRESET:
return "EPSC_ECONNRESET";
case EPSC_ECSR:
return "EPSC_ECSR";
return "EPSC_MODIFY_QP_OUT_OF_RANGE";
case EPSC_MODIFY_QP_INVALID:
return "EPSC_MODIFY_QP_INVALID";
return "EPSC_MODIFY_CANNOT_CHANGE_QP_ATTR";
return "EPSC_MODIFY_INVALID_QP_STATE";
return "EPSC_MODIFY_INVALID_MIG_STATE";
case EPSC_MODIFY_TIMEOUT:
return "EPSC_MODIFY_TIMEOUT";
case EPSC_ETEST_HEAD:
return "EPSC_ETEST_HEAD";
case EPSC_ETEST_TAIL:
return "EPSC_ETEST_TAIL";
case EPSC_ETEST_PATTERN:
return "EPSC_ETEST_PATTERN";
case EPSC_EADDRINUSE:
return "EPSC_EADDRINUSE";
case EPSC_EINVALID_VHCA:
return "EPSC_EINVALID_VHCA";
case EPSC_EINVALID_PORT:
return "EPSC_EINVALID_PORT";
case EPSC_EINVALID_ADDRESS:
return "EPSC_EINVALID_ADDRESS";
case EPSC_EINVALID_PARAMETER:
return "EPSC_EINVALID_PARAMETER";
case EPSC_FAIL:
return "EPSC_FAIL";
default:
return "UNKNOWN_psif_epsc_csr_status";
}
}
enum psif_epsc_csr_status data)
{
} /* end write_..._psif_epsc_csr_status(psif_epsc_csr_status data) */
/* Convert enum psif_epsc_csr_opcode to string */
{
switch (val) {
case EPSC_NOOP:
return "EPSC_NOOP";
case EPSC_MAILBOX_PING:
return "EPSC_MAILBOX_PING";
case EPSC_KEEP_ALIVE:
return "EPSC_KEEP_ALIVE";
case EPSC_SETUP:
return "EPSC_SETUP";
case EPSC_TEARDOWN:
return "EPSC_TEARDOWN";
case EPSC_SET:
return "EPSC_SET";
case EPSC_SET_SINGLE:
return "EPSC_SET_SINGLE";
case EPSC_SET_ONE_CSR:
return "EPSC_SET_ONE_CSR";
case EPSC_SETUP_BASEADDR:
return "EPSC_SETUP_BASEADDR";
case EPSC_SET_BASEADDR:
return "EPSC_SET_BASEADDR";
case EPSC_SET_BASEADDR_EQ:
return "EPSC_SET_BASEADDR_EQ";
case EPSC_SET_LID:
return "EPSC_SET_LID";
case OBSOLETE_1:
return "OBSOLETE_1";
case OBSOLETE_2:
return "OBSOLETE_2";
case EPSC_SET_GID:
return "EPSC_SET_GID";
case EPSC_SET_EOIB_MAC:
return "EPSC_SET_EOIB_MAC";
case EPSC_SET_VLINK_STATE:
return "EPSC_SET_VLINK_STATE";
case EPSC_QUERY_VLINK_STATE:
return "EPSC_QUERY_VLINK_STATE";
case EPSC_UF_RESET:
return "EPSC_UF_RESET";
case EPSC_MODIFY_QP:
return "EPSC_MODIFY_QP";
case EPSC_GET_SINGLE:
return "EPSC_GET_SINGLE";
case EPSC_GET_ONE_CSR:
return "EPSC_GET_ONE_CSR";
case EPSC_QUERY_QP:
return "EPSC_QUERY_QP";
case EPSC_QUERY_HW_RQ:
return "EPSC_QUERY_HW_RQ";
case EPSC_QUERY_HW_SQ:
return "EPSC_QUERY_HW_SQ";
case EPSC_QUERY_DEVICE:
return "EPSC_QUERY_DEVICE";
case EPSC_QUERY_PORT_1:
return "EPSC_QUERY_PORT_1";
case EPSC_QUERY_PORT_2:
return "EPSC_QUERY_PORT_2";
case EPSC_QUERY_PKEY:
return "EPSC_QUERY_PKEY";
case EPSC_QUERY_GID:
return "EPSC_QUERY_GID";
case EPSC_MODIFY_DEVICE:
return "EPSC_MODIFY_DEVICE";
case EPSC_MODIFY_PORT_1:
return "EPSC_MODIFY_PORT_1";
case EPSC_MODIFY_PORT_2:
return "EPSC_MODIFY_PORT_2";
case EPSC_MC_ATTACH:
return "EPSC_MC_ATTACH";
case EPSC_MC_DETACH:
return "EPSC_MC_DETACH";
case EPSC_MC_QUERY:
return "EPSC_MC_QUERY";
case EPSC_EVENT_ACK:
return "EPSC_EVENT_ACK";
case EPSC_EVENT_INDEX:
return "EPSC_EVENT_INDEX";
case EPSC_FLASH_START:
return "EPSC_FLASH_START";
case EPSC_FLASH_INFO:
return "EPSC_FLASH_INFO";
case EPSC_FLASH_ERASE_SECTOR:
return "EPSC_FLASH_ERASE_SECTOR";
case EPSC_FLASH_RD:
return "EPSC_FLASH_RD";
case EPSC_FLASH_WR:
return "EPSC_FLASH_WR";
case EPSC_FLASH_CHECK:
return "EPSC_FLASH_CHECK";
case EPSC_FLASH_SCAN:
return "EPSC_FLASH_SCAN";
case EPSC_FLASH_STOP:
return "EPSC_FLASH_STOP";
case EPSC_UPDATE:
return "EPSC_UPDATE";
case EPSC_TRACE_STATUS:
return "EPSC_TRACE_STATUS";
case EPSC_TRACE_SETUP:
return "EPSC_TRACE_SETUP";
case EPSC_TRACE_START:
return "EPSC_TRACE_START";
case EPSC_TRACE_STOP:
return "EPSC_TRACE_STOP";
case EPSC_TRACE_ACQUIRE:
return "EPSC_TRACE_ACQUIRE";
case EPSC_TEST_HOST_RD:
return "EPSC_TEST_HOST_RD";
case EPSC_TEST_HOST_WR:
return "EPSC_TEST_HOST_WR";
case EPSC_FW_VERSION:
return "EPSC_FW_VERSION";
case EPSC_LOG_CTRL:
return "EPSC_LOG_CTRL";
case EPSC_LOG_REQ_NOTIFY:
return "EPSC_LOG_REQ_NOTIFY";
case EPSC_LINK_CNTRL:
return "EPSC_LINK_CNTRL";
case EPSC_A_CONTROL:
return "EPSC_A_CONTROL";
case EPSC_A_COMMAND:
return "EPSC_A_COMMAND";
case EPSC_EXERCISE_MMU:
return "EPSC_EXERCISE_MMU";
case EPSC_CLI_ACCESS:
return "EPSC_CLI_ACCESS";
case EPSC_MAD_PROCESS:
return "EPSC_MAD_PROCESS";
case EPSC_MAD_SEND_WR:
return "EPSC_MAD_SEND_WR";
case EPSC_QUERY:
return "EPSC_QUERY";
return "EPSC_HOST_INT_COMMON_CTRL";
return "EPSC_HOST_INT_CHANNEL_CTRL";
case EPSC_UF_CTRL:
return "EPSC_UF_CTRL";
case EPSC_FLUSH_CACHES:
return "EPSC_FLUSH_CACHES";
case EPSC_PMA_COUNTERS:
return "EPSC_PMA_COUNTERS";
case EPSC_VIMMA_CTRL:
return "EPSC_VIMMA_CTRL";
case EPSC_BER_DATA:
return "EPSC_BER_DATA";
case EPSC_LAST_OP:
return "EPSC_LAST_OP";
return "PSIF_EPSC_CSR_OPCODE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_csr_opcode";
}
}
enum psif_epsc_csr_opcode data)
{
} /* end write_..._psif_epsc_csr_opcode(psif_epsc_csr_opcode data) */
/* Convert enum psif_epsc_csr_flags to string */
{
switch (val) {
case EPSC_FL_NONE:
return "EPSC_FL_NONE";
case EPSC_FL_NOTIFY:
return "EPSC_FL_NOTIFY";
case EPSC_FL_PQP:
return "EPSC_FL_PQP";
case EPSC_FL_IGNORE_ERROR:
return "EPSC_FL_IGNORE_ERROR";
return "PSIF_EPSC_CSR_FLAGS_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_csr_flags";
}
}
enum psif_epsc_csr_flags data)
{
} /* end write_..._psif_epsc_csr_flags(psif_epsc_csr_flags data) */
/* Convert enum psif_vlink_state to string */
{
switch (val) {
case PSIF_LINK_DISABLED:
return "PSIF_LINK_DISABLED";
case PSIF_LINK_DOWN:
return "PSIF_LINK_DOWN";
case PSIF_LINK_INIT:
return "PSIF_LINK_INIT";
case PSIF_LINK_ARM:
return "PSIF_LINK_ARM";
case PSIF_LINK_ACTIVE:
return "PSIF_LINK_ACTIVE";
default:
return "UNKNOWN_psif_vlink_state";
}
}
enum psif_vlink_state data)
{
} /* end write_..._psif_vlink_state(psif_vlink_state data) */
/* Convert enum psif_epsc_csr_modify_device_flags to string */
const char *string_enum_psif_epsc_csr_modify_device_flags(enum psif_epsc_csr_modify_device_flags val)
{
switch (val) {
return "PSIF_DEVICE_MODIFY_SYS_IMAGE_GUID";
return "PSIF_DEVICE_MODIFY_NODE_DESC";
return "PSIF_EPSC_CSR_MODIFY_DEVICE_FLAGS_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_csr_modify_device_flags";
}
}
{
} /* end write_..._psif_epsc_csr_modify_device_flags(psif_epsc_csr_modify_device_flags data) */
/* Convert enum psif_epsc_csr_modify_port_flags to string */
{
switch (val) {
case PSIF_PORT_SHUTDOWN:
return "PSIF_PORT_SHUTDOWN";
case PSIF_PORT_INIT_TYPE:
return "PSIF_PORT_INIT_TYPE";
return "PSIF_PORT_RESET_QKEY_CNTR";
return "PSIF_PORT_RESET_PKEY_CNTR";
return "PSIF_EPSC_CSR_MODIFY_PORT_FLAGS_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_csr_modify_port_flags";
}
}
{
} /* end write_..._psif_epsc_csr_modify_port_flags(psif_epsc_csr_modify_port_flags data) */
/* Convert enum psif_epsc_csr_epsa_command to string */
{
switch (val) {
case EPSC_A_LOAD:
return "EPSC_A_LOAD";
case EPSC_A_START:
return "EPSC_A_START";
case EPSC_A_STOP:
return "EPSC_A_STOP";
case EPSC_A_STATUS:
return "EPSC_A_STATUS";
return "PSIF_EPSC_CSR_EPSA_COMMAND_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_csr_epsa_command";
}
}
{
} /* end write_..._psif_epsc_csr_epsa_command(psif_epsc_csr_epsa_command data) */
/* Convert enum psif_epsa_command to string */
{
switch (val) {
case EPSA_DYNAMIC_LOAD:
return "EPSA_DYNAMIC_LOAD";
case EPSA_TEST_FABOUT:
return "EPSA_TEST_FABOUT";
case EPSA_TEST_FABIN:
return "EPSA_TEST_FABIN";
case EPSA_TEST_FABIN_FABOUT:
return "EPSA_TEST_FABIN_FABOUT";
case EPSA_TEST_SKJM_MEMREAD:
return "EPSA_TEST_SKJM_MEMREAD";
case EPSA_TEST_SKJM_MEMWRITE:
return "EPSA_TEST_SKJM_MEMWRITE";
case EPSA_TEST_SKJM_MEMLOCK:
return "EPSA_TEST_SKJM_MEMLOCK";
case EPSA_SKJM_LOAD:
return "EPSA_SKJM_LOAD";
case EPSA_SKJM_ACC:
return "EPSA_SKJM_ACC";
case EPSA_SKJM_MEMACC:
return "EPSA_SKJM_MEMACC";
case EPSA_GET_PROXY_QP_SQ_KEY:
return "EPSA_GET_PROXY_QP_SQ_KEY";
case EPSA_GENERIC_CMD:
return "EPSA_GENERIC_CMD";
return "PSIF_EPSA_COMMAND_FIELD_MAX";
default:
return "UNKNOWN_psif_epsa_command";
}
}
enum psif_epsa_command data)
{
} /* end write_..._psif_epsa_command(psif_epsa_command data) */
/* Convert enum psif_epsc_query_op to string */
{
switch (val) {
case EPSC_QUERY_BLANK:
return "EPSC_QUERY_BLANK";
case EPSC_QUERY_CAP_VCB:
return "EPSC_QUERY_CAP_VCB";
case EPSC_QUERY_CAP_PCB:
return "EPSC_QUERY_CAP_PCB";
case EPSC_QUERY_NUM_UF:
return "EPSC_QUERY_NUM_UF";
case EPSC_QUERY_GID_HI:
return "EPSC_QUERY_GID_HI";
case EPSC_QUERY_GID_LO:
return "EPSC_QUERY_GID_LO";
case EPSC_QUERY_P_KEY:
return "EPSC_QUERY_P_KEY";
case EPSC_QUERY_Q_KEY:
return "EPSC_QUERY_Q_KEY";
case EPSC_QUERY_UF:
return "EPSC_QUERY_UF";
case EPSC_QUERY_LINK_STATE:
return "EPSC_QUERY_LINK_STATE";
case EPSC_QUERY_VHCA_STATE:
return "EPSC_QUERY_VHCA_STATE";
case EPSC_QUERY_INT_COMMON:
return "EPSC_QUERY_INT_COMMON";
case EPSC_QUERY_INT_CHAN_RATE:
return "EPSC_QUERY_INT_CHAN_RATE";
return "EPSC_QUERY_INT_CHAN_AUSEC";
return "EPSC_QUERY_INT_CHAN_PUSEC";
case EPSC_QUERY_CAP_VCB_LO:
return "EPSC_QUERY_CAP_VCB_LO";
case EPSC_QUERY_CAP_VCB_HI:
return "EPSC_QUERY_CAP_VCB_HI";
case EPSC_QUERY_CAP_PCB_LO:
return "EPSC_QUERY_CAP_PCB_LO";
case EPSC_QUERY_CAP_PCB_HI:
return "EPSC_QUERY_CAP_PCB_HI";
return "EPSC_QUERY_PMA_REDIRECT_QP";
case EPSC_QUERY_FW_UPTIME:
return "EPSC_QUERY_FW_UPTIME";
case EPSC_QUERY_FW_PROG_DATE:
return "EPSC_QUERY_FW_PROG_DATE";
case EPSC_QUERY_FW_BUILD_DATE:
return "EPSC_QUERY_FW_BUILD_DATE";
case EPSC_QUERY_FW_CURR_IMG:
return "EPSC_QUERY_FW_CURR_IMG";
return "EPSC_QUERY_FW_ONESHOT_IMG";
return "EPSC_QUERY_FW_AUTOSTART_IMG";
return "EPSC_QUERY_FW_START_CAUSE";
case EPSC_QUERY_FW_VERSION:
return "EPSC_QUERY_FW_VERSION";
case EPSC_QUERY_SQ_NUM_BRE:
return "EPSC_QUERY_SQ_NUM_BRE";
case EPSC_QUERY_NUM_CQOVF:
return "EPSC_QUERY_NUM_CQOVF";
case EPSC_QUERY_SQ_NUM_WRFE:
return "EPSC_QUERY_SQ_NUM_WRFE";
case EPSC_QUERY_RQ_NUM_WRFE:
return "EPSC_QUERY_RQ_NUM_WRFE";
case EPSC_QUERY_RQ_NUM_LAE:
return "EPSC_QUERY_RQ_NUM_LAE";
case EPSC_QUERY_RQ_NUM_LPE:
return "EPSC_QUERY_RQ_NUM_LPE";
case EPSC_QUERY_SQ_NUM_LLE:
return "EPSC_QUERY_SQ_NUM_LLE";
case EPSC_QUERY_RQ_NUM_LLE:
return "EPSC_QUERY_RQ_NUM_LLE";
case EPSC_QUERY_SQ_NUM_LQPOE:
return "EPSC_QUERY_SQ_NUM_LQPOE";
case EPSC_QUERY_RQ_NUM_LQPOE:
return "EPSC_QUERY_RQ_NUM_LQPOE";
case EPSC_QUERY_SQ_NUM_OOS:
return "EPSC_QUERY_SQ_NUM_OOS";
case EPSC_QUERY_RQ_NUM_OOS:
return "EPSC_QUERY_RQ_NUM_OOS";
case EPSC_QUERY_SQ_NUM_RREE:
return "EPSC_QUERY_SQ_NUM_RREE";
case EPSC_QUERY_SQ_NUM_TREE:
return "EPSC_QUERY_SQ_NUM_TREE";
case EPSC_QUERY_SQ_NUM_ROE:
return "EPSC_QUERY_SQ_NUM_ROE";
case EPSC_QUERY_RQ_NUM_ROE:
return "EPSC_QUERY_RQ_NUM_ROE";
case EPSC_QUERY_SQ_NUM_RAE:
return "EPSC_QUERY_SQ_NUM_RAE";
case EPSC_QUERY_RQ_NUM_RAE:
return "EPSC_QUERY_RQ_NUM_RAE";
return "EPSC_QUERY_RQ_NUM_UDSDPRD";
return "EPSC_QUERY_RQ_NUM_UCSDPRD";
case EPSC_QUERY_SQ_NUM_RIRE:
return "EPSC_QUERY_SQ_NUM_RIRE";
case EPSC_QUERY_RQ_NUM_RIRE:
return "EPSC_QUERY_RQ_NUM_RIRE";
case EPSC_QUERY_SQ_NUM_RNR:
return "EPSC_QUERY_SQ_NUM_RNR";
case EPSC_QUERY_RQ_NUM_RNR:
return "EPSC_QUERY_RQ_NUM_RNR";
return "EPSC_QUERY_FW_TWOSHOT_IMG";
case EPSC_QUERY_FW_TYPE:
return "EPSC_QUERY_FW_TYPE";
case EPSC_QUERY_FW_SIZE:
return "EPSC_QUERY_FW_SIZE";
case EPSC_QUERY_FW_SLOT_SIZE:
return "EPSC_QUERY_FW_SLOT_SIZE";
case EPSC_QUERY_BL_VERSION:
return "EPSC_QUERY_BL_VERSION";
case EPSC_QUERY_BL_BUILD_DATE:
return "EPSC_QUERY_BL_BUILD_DATE";
case EPSC_QUERY_CLEAN_CQ_ID:
return "EPSC_QUERY_CLEAN_CQ_ID";
case EPSC_QUERY_CAP_TSL_TX:
return "EPSC_QUERY_CAP_TSL_TX";
case EPSC_QUERY_CAP_TSL_RX:
return "EPSC_QUERY_CAP_TSL_RX";
return "EPSC_QUERY_RESET_CBLD_DIAG_COUNTERS";
case EPSC_QUERY_MAX_QP_USED:
return "EPSC_QUERY_MAX_QP_USED";
return "EPSC_QUERY_MODQP_TO_SOURCE";
return "EPSC_QUERY_MODQP_TO_DEBUG";
return "EPSC_QUERY_DEGRADED_CAUSE";
return "EPSC_QUERY_SPIN_SET_CONTROL";
case EPSC_QUERY_VPD_MAC:
return "EPSC_QUERY_VPD_MAC";
return "EPSC_QUERY_VPD_PART_NUMBER";
case EPSC_QUERY_VPD_REVISION:
return "EPSC_QUERY_VPD_REVISION";
return "EPSC_QUERY_VPD_SERIAL_NUMBER";
return "EPSC_QUERY_VPD_MANUFACTURER";
return "EPSC_QUERY_VPD_PRODUCT_NAME";
case EPSC_QUERY_VPD_BASE_GUID:
return "EPSC_QUERY_VPD_BASE_GUID";
return "EPSC_QUERY_MAP_QP0_TO_TSL";
return "EPSC_QUERY_MAP_PQP_TO_TSL";
return "EPSC_QUERY_MAP_SL_TO_TSL_LO";
return "EPSC_QUERY_MAP_SL_TO_TSL_HI";
return "EPSC_QUERY_TA_UPPER_TWELVE";
return "EPSC_QUERY_PA_UPPER_TWELVE";
case EPSC_QUERY_NUM_VFS:
return "EPSC_QUERY_NUM_VFS";
case EPSC_QUERY_CREDIT_MODE:
return "EPSC_QUERY_CREDIT_MODE";
case EPSC_QUERY_CPLD_VERSION:
return "EPSC_QUERY_CPLD_VERSION";
return "EPSC_QUERY_EXTERNAL_PORT_INFO";
case EPSC_QUERY_LAST:
return "EPSC_QUERY_LAST";
return "PSIF_EPSC_QUERY_OP_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_query_op";
}
}
enum psif_epsc_query_op data)
{
} /* end write_..._psif_epsc_query_op(psif_epsc_query_op data) */
/* Convert enum psif_epsc_csr_update_opcode to string */
{
switch (val) {
case EPSC_UPDATE_OP_POLL:
return "EPSC_UPDATE_OP_POLL";
case EPSC_UPDATE_OP_START:
return "EPSC_UPDATE_OP_START";
case EPSC_UPDATE_OP_ERASE:
return "EPSC_UPDATE_OP_ERASE";
case EPSC_UPDATE_OP_WRITE:
return "EPSC_UPDATE_OP_WRITE";
case EPSC_UPDATE_OP_READ:
return "EPSC_UPDATE_OP_READ";
case EPSC_UPDATE_OP_STOP:
return "EPSC_UPDATE_OP_STOP";
case EPSC_UPDATE_OP_SET:
return "EPSC_UPDATE_OP_SET";
case EPSC_UPDATE_OP_MAX:
return "EPSC_UPDATE_OP_MAX";
return "PSIF_EPSC_CSR_UPDATE_OPCODE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_csr_update_opcode";
}
}
{
} /* end write_..._psif_epsc_csr_update_opcode(psif_epsc_csr_update_opcode data) */
/* Convert enum psif_epsc_flash_slot to string */
{
switch (val) {
case EPSC_FLASH_SLOT_INVALID:
return "EPSC_FLASH_SLOT_INVALID";
return "EPSC_FLASH_SLOT_EPS_C_IMG_1";
return "EPSC_FLASH_SLOT_EPS_C_IMG_2";
return "EPSC_FLASH_SLOT_EPS_A_IMG";
case EPSC_FLASH_SLOT_BOOT_IMG:
return "EPSC_FLASH_SLOT_BOOT_IMG";
case EPSC_FLASH_SLOT_COUNT:
return "EPSC_FLASH_SLOT_COUNT";
return "PSIF_EPSC_FLASH_SLOT_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_flash_slot";
}
}
enum psif_epsc_flash_slot data)
{
} /* end write_..._psif_epsc_flash_slot(psif_epsc_flash_slot data) */
/* Convert enum psif_epsc_update_set to string */
{
switch (val) {
case EPSC_UPDATE_SET_INVALID:
return "EPSC_UPDATE_SET_INVALID";
return "EPSC_UPDATE_SET_AUTOSTART_IMG";
return "EPSC_UPDATE_SET_ONESHOT_IMG";
return "EPSC_UPDATE_SET_TWOSHOT_IMG";
return "EPSC_UPDATE_SET_IMG_VALID";
return "PSIF_EPSC_UPDATE_SET_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_update_set";
}
}
enum psif_epsc_update_set data)
{
} /* end write_..._psif_epsc_update_set(psif_epsc_update_set data) */
/* Convert enum psif_epsc_csr_uf_ctrl_opcode to string */
{
switch (val) {
case EPSC_UF_CTRL_MMU_FLUSH:
return "EPSC_UF_CTRL_MMU_FLUSH";
return "EPSC_UF_CTRL_GET_UF_USED_QP";
return "EPSC_UF_CTRL_CLEAR_UF_USED_QP";
case EPSC_UF_CTRL_SMP_ENABLE:
return "EPSC_UF_CTRL_SMP_ENABLE";
case EPSC_UF_CTRL_SMP_DISABLE:
return "EPSC_UF_CTRL_SMP_DISABLE";
return "EPSC_UF_CTRL_VLINK_CONNECT";
return "EPSC_UF_CTRL_VLINK_DISCONNECT";
return "EPSC_UF_CTRL_GET_HIGHEST_QP_IDX";
return "EPSC_UF_CTRL_RESET_HIGHEST_QP_IDX";
return "PSIF_EPSC_CSR_UF_CTRL_OPCODE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_csr_uf_ctrl_opcode";
}
}
{
} /* end write_..._psif_epsc_csr_uf_ctrl_opcode(psif_epsc_csr_uf_ctrl_opcode data) */
/* Convert enum psif_epsc_vimma_ctrl_opcode to string */
{
switch (val) {
return "EPSC_VIMMA_CTRL_GET_VER_AND_COMPAT";
return "EPSC_VIMMA_CTRL_GET_MISC_INFO";
return "EPSC_VIMMA_CTRL_GET_GUIDS";
return "EPSC_VIMMA_CTRL_GET_REG_INFO";
return "EPSC_VIMMA_CTRL_GET_VHCA_STATS";
return "EPSC_VIMMA_CTRL_SET_VFP_VHCA_REGISTER";
return "EPSC_VIMMA_CTRL_SET_VFP_VHCA_DEREGISTER";
return "EPSC_VIMMA_CTRL_SET_ADMIN_MODE";
return "PSIF_EPSC_VIMMA_CTRL_OPCODE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_vimma_ctrl_opcode";
}
}
{
} /* end write_..._psif_epsc_vimma_ctrl_opcode(psif_epsc_vimma_ctrl_opcode data) */
/* Convert enum psif_epsc_vimma_admmode to string */
{
switch (val) {
return "EPSC_VIMMA_CTRL_IB_ADM_MODE_SM_STANDARD";
return "EPSC_VIMMA_CTRL_IB_ADM_MODE_VM_FABRIC_PROFILE";
return "PSIF_EPSC_VIMMA_ADMMODE_FIELD_MAX";
default:
return "UNKNOWN_psif_epsc_vimma_admmode";
}
}
enum psif_epsc_vimma_admmode data)
{
} /* end write_..._psif_epsc_vimma_admmode(psif_epsc_vimma_admmode data) */
/* Convert enum psif_cq_state to string */
{
switch (val) {
case PSIF_CQ_UNARMED:
return "PSIF_CQ_UNARMED";
case PSIF_CQ_ARMED_SE:
return "PSIF_CQ_ARMED_SE";
case PSIF_CQ_ARMED_ALL:
return "PSIF_CQ_ARMED_ALL";
case PSIF_CQ_TRIGGERED:
return "PSIF_CQ_TRIGGERED";
default:
return "UNKNOWN_psif_cq_state";
}
}
enum psif_cq_state data)
{
} /* end write_..._psif_cq_state(psif_cq_state data) */
/* Convert enum psif_rss_hash_source to string */
{
switch (val) {
case RSS_WITHOUT_PORT:
return "RSS_WITHOUT_PORT";
case RSS_WITH_PORT:
return "RSS_WITH_PORT";
default:
return "UNKNOWN_psif_rss_hash_source";
}
}
enum psif_rss_hash_source data)
{
} /* end write_..._psif_rss_hash_source(psif_rss_hash_source data) */
#if !defined(PSIF_EXCLUDE_WRITE_STRUCTS)
int network_order,
const struct psif_csr_mmu_config *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_mmu_config(psif_csr_mmu_config data) */
int network_order,
const struct psif_mmu_cntx *data)
{
if (network_order) {
}
} /* end write_..._psif_mmu_cntx(psif_mmu_cntx data) */
int network_order,
const struct psif_vlan_union_struct *data)
{
} /* end write_..._psif_vlan_union_struct(psif_vlan_union_struct data) */
int network_order,
const union psif_cq_desc_vlan_pri *data)
{
} /* end write_..._psif_cq_desc_vlan_pri(psif_cq_desc_vlan_pri data) */
int network_order,
const struct psif_wr_common *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_common(psif_wr_common data) */
int network_order,
const struct psif_wr_qp *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_qp(psif_wr_qp data) */
int network_order,
const struct psif_wr_local *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_local(psif_wr_local data) */
int network_order,
const struct psif_wr_addr *data)
{
} /* end write_..._psif_wr_addr(psif_wr_addr data) */
int network_order,
const struct psif_wr_send_header_ud *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_send_header_ud(psif_wr_send_header_ud data) */
int network_order,
const struct psif_wr_send_header_uc_rc_xrc *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_send_header_uc_rc_xrc(psif_wr_send_header_uc_rc_xrc data) */
int network_order,
const union psif_wr_send_header *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_send_header(psif_wr_send_header data) */
int network_order,
const struct psif_wr_remote *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_remote(psif_wr_remote data) */
int network_order,
const struct psif_wr_rdma *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_rdma(psif_wr_rdma data) */
int network_order,
const struct psif_send_completion_id *data)
{
if (network_order) {
}
} /* end write_..._psif_send_completion_id(psif_send_completion_id data) */
int network_order,
const struct psif_event_completion_id *data)
{
if (network_order) {
}
} /* end write_..._psif_event_completion_id(psif_event_completion_id data) */
int network_order,
const union psif_completion_wc_id *data)
{
if (network_order) {
}
} /* end write_..._psif_completion_wc_id(psif_completion_wc_id data) */
int network_order,
const union psif_descriptor_union *data)
{
} /* end write_..._psif_descriptor_union(psif_descriptor_union data) */
int network_order,
const struct psif_wr_su *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_su(psif_wr_su data) */
int network_order,
const union psif_wr_details *data)
{
if (network_order) {
}
} /* end write_..._psif_wr_details(psif_wr_details data) */
int network_order,
const struct psif_wr_xrc *data)
{
} /* end write_..._psif_wr_xrc(psif_wr_xrc data) */
int network_order,
{
if (network_order) {
}
/* assertion: offsetof(struct psif_wr, imm) == sizeof(struct psif_wr_common) */
}
/* write_union_psif_wr_details(fd, 0, &(data->details)); */
/* write_union_psif_wr_send_header(fd, 0, &(data->send)); */
switch (op) {
case PSIF_WR_SEND:
case PSIF_WR_SEND_IMM:
case PSIF_WR_SPECIAL_QP_SEND:
case PSIF_WR_QP0_SEND_DR_XMIT:
if (ud) {
} else {
}
break;
case PSIF_WR_RDMA_WR:
case PSIF_WR_RDMA_WR_IMM:
case PSIF_WR_RDMA_RD:
break;
case PSIF_WR_CMP_SWAP:
case PSIF_WR_FETCH_ADD:
case PSIF_WR_MASK_CMP_SWAP:
case PSIF_WR_MASK_FETCH_ADD:
break;
case PSIF_WR_INVALIDATE_RKEY:
case PSIF_WR_INVALIDATE_LKEY:
case PSIF_WR_INVALIDATE_TLB:
case PSIF_WR_RESIZE_CQ:
case PSIF_WR_SET_SRQ_LIM:
case PSIF_WR_SET_XRCSRQ_LIM:
case PSIF_WR_REQ_CMPL_NOTIFY:
case PSIF_WR_CMPL_NOTIFY_RCVD:
case PSIF_WR_REARM_CMPL_EVENT:
case PSIF_WR_INVALIDATE_RQ:
case PSIF_WR_INVALIDATE_CQ:
break;
case PSIF_WR_LSO:
break;
}
}
int network_order,
{
if (network_order) {
}
} /* end write_..._psif_wr(psif_wr data) */
int network_order,
{
} /* end write_..._psif_next(psif_next data) */
int network_order,
const struct psif_sq_sw *data)
{
if (network_order) {
}
} /* end write_..._psif_sq_sw(psif_sq_sw data) */
int network_order,
const struct psif_sq_hw *data)
{
if (network_order) {
}
} /* end write_..._psif_sq_hw(psif_sq_hw data) */
int network_order,
const struct psif_sq_entry *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 32; i++) {
}
}
} /* end write_..._psif_sq_entry(psif_sq_entry data) */
int network_order,
const struct psif_rq_scatter *data)
{
if (network_order) {
}
} /* end write_..._psif_rq_scatter(psif_rq_scatter data) */
int network_order,
const struct psif_rq_sw *data)
{
if (network_order) {
}
} /* end write_..._psif_rq_sw(psif_rq_sw data) */
int network_order,
const struct psif_rq_hw *data)
{
if (network_order) {
}
} /* end write_..._psif_rq_hw(psif_rq_hw data) */
int network_order,
const struct psif_rq_entry *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 16; i++) {
}
}
} /* end write_..._psif_rq_entry(psif_rq_entry data) */
int network_order,
const struct psif_qp_core *data)
{
if (network_order) {
}
} /* end write_..._psif_qp_core(psif_qp_core data) */
int network_order,
const struct psif_qp_path *data)
{
if (network_order) {
}
} /* end write_..._psif_qp_path(psif_qp_path data) */
int network_order,
const struct psif_query_qp *data)
{
if (network_order) {
}
} /* end write_..._psif_query_qp(psif_query_qp data) */
int network_order,
{
if (network_order) {
}
} /* end write_..._psif_qp(psif_qp data) */
int network_order,
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 32; i++) {
}
}
} /* end write_..._psif_cb(psif_cb data) */
int network_order,
const struct psif_modify_qp *data)
{
if (network_order) {
}
} /* end write_..._psif_modify_qp(psif_modify_qp data) */
int network_order,
{
if (network_order) {
}
} /* end write_..._psif_key(psif_key data) */
int network_order,
const struct psif_flash_header_app *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 4; i++) {
}
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
{ unsigned int i; for (i = 0; i < 4; i++) {
}
}
{ unsigned int i; for (i = 0; i < 4; i++) {
}
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
} /* end write_..._psif_flash_header_app(psif_flash_header_app data) */
int network_order,
const struct psif_flash_header_all *data)
{
if (network_order) {
}
} /* end write_..._psif_flash_header_all(psif_flash_header_all data) */
int network_order,
const struct psif_eq_entry *data)
{
if (network_order) {
}
} /* end write_..._psif_eq_entry(psif_eq_entry data) */
int network_order,
const struct psif_epsc_exercise_mmu *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_exercise_mmu(psif_epsc_exercise_mmu data) */
int network_order,
const struct psif_epsc_csr_rsp *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_rsp(psif_epsc_csr_rsp data) */
int network_order,
const struct psif_epsc_csr_opaque *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 11; i++) {
}
}
} /* end write_..._psif_epsc_csr_opaque(psif_epsc_csr_opaque data) */
int network_order,
const struct psif_epsc_csr_single *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_single(psif_epsc_csr_single data) */
int network_order,
const struct psif_epsc_csr_base_addr *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 7; i++) {
}
}
} /* end write_..._psif_epsc_csr_base_addr(psif_epsc_csr_base_addr data) */
int network_order,
const struct psif_csr_modify_qp_ctrl *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_modify_qp_ctrl(psif_csr_modify_qp_ctrl data) */
int network_order,
const struct psif_epsc_csr_modify_qp *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_modify_qp(psif_epsc_csr_modify_qp data) */
int network_order,
const struct psif_epsc_csr_query_qp *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
} /* end write_..._psif_epsc_csr_query_qp(psif_epsc_csr_query_qp data) */
int network_order,
const struct psif_csr_own_lid_base *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_own_lid_base(psif_csr_own_lid_base data) */
int network_order,
const struct psif_csr_snd_lid *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_snd_lid(psif_csr_snd_lid data) */
int network_order,
const struct psif_csr_rcv_lid *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_rcv_lid(psif_csr_rcv_lid data) */
int network_order,
const struct psif_epsc_csr_set_lid *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 7; i++) {
}
}
} /* end write_..._psif_epsc_csr_set_lid(psif_epsc_csr_set_lid data) */
int network_order,
const struct psif_epsc_csr_set_gid *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
} /* end write_..._psif_epsc_csr_set_gid(psif_epsc_csr_set_gid data) */
int network_order,
const struct psif_epsc_csr_set_eoib_mac *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 9; i++) {
}
}
} /* end write_..._psif_epsc_csr_set_eoib_mac(psif_epsc_csr_set_eoib_mac data) */
int network_order,
const struct psif_epsc_csr_vlink_state *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 10; i++) {
}
}
} /* end write_..._psif_epsc_csr_vlink_state(psif_epsc_csr_vlink_state data) */
int network_order,
const struct psif_epsc_csr_query_hw *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 9; i++) {
}
}
} /* end write_..._psif_epsc_csr_query_hw(psif_epsc_csr_query_hw data) */
int network_order,
const struct psif_epsc_csr_query_table *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 10; i++) {
}
}
} /* end write_..._psif_epsc_csr_query_table(psif_epsc_csr_query_table data) */
int network_order,
const struct psif_epsc_csr_mc *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
} /* end write_..._psif_epsc_csr_mc(psif_epsc_csr_mc data) */
int network_order,
const struct psif_epsc_csr_event *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
{ unsigned int i; for (i = 0; i < 2; i++) {
}
}
} /* end write_..._psif_epsc_csr_event(psif_epsc_csr_event data) */
int network_order,
const struct psif_epsc_csr_modify_device *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 64; i++) {
}
}
} /* end write_..._psif_epsc_csr_modify_device(psif_epsc_csr_modify_device data) */
int network_order,
const struct psif_epsc_csr_modify_port *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_modify_port(psif_epsc_csr_modify_port data) */
int network_order,
const struct psif_epsc_csr_test_host_wrd *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_test_host_wrd(psif_epsc_csr_test_host_wrd data) */
int network_order,
const struct psif_epsc_csr_flash_access *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_flash_access(psif_epsc_csr_flash_access data) */
int network_order,
const struct psif_epsc_csr_trace_acquire *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 8; i++) {
}
}
} /* end write_..._psif_epsc_csr_trace_acquire(psif_epsc_csr_trace_acquire data) */
int network_order,
const struct psif_epsc_csr_fw_version *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_fw_version(psif_epsc_csr_fw_version data) */
int network_order,
const struct psif_epsc_csr_log_ctrl *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_log_ctrl(psif_epsc_csr_log_ctrl data) */
int network_order,
const struct psif_epsc_csr_epsa_cntrl *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_epsa_cntrl(psif_epsc_csr_epsa_cntrl data) */
int network_order,
const struct psif_epsc_csr_epsa_cmd *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 16; i++) {
}
}
} /* end write_..._psif_epsc_csr_epsa_cmd(psif_epsc_csr_epsa_cmd data) */
int network_order,
const struct psif_epsc_csr_cli_access *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 72; i++) {
}
}
} /* end write_..._psif_epsc_csr_cli_access(psif_epsc_csr_cli_access data) */
int network_order,
const struct psif_epsc_csr_mad_process *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_mad_process(psif_epsc_csr_mad_process data) */
int network_order,
const struct psif_epsc_csr_mad_send_wr *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_mad_send_wr(psif_epsc_csr_mad_send_wr data) */
int network_order,
const struct psif_epsc_query_req *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_query_req(psif_epsc_query_req data) */
int network_order,
const struct psif_epsc_csr_query *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_query(psif_epsc_csr_query data) */
int network_order,
const struct psif_epsc_csr_set *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_set(psif_epsc_csr_set data) */
int network_order,
const struct psif_epsc_csr_interrupt_common *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_interrupt_common(psif_epsc_csr_interrupt_common data) */
int network_order,
const struct psif_interrupt_attributes *data)
{
if (network_order) {
}
} /* end write_..._psif_interrupt_attributes(psif_interrupt_attributes data) */
int network_order,
const struct psif_epsc_csr_interrupt_channel *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_interrupt_channel(psif_epsc_csr_interrupt_channel data) */
int network_order,
const union psif_epsc_update_set_or_offset *data)
{
} /* end write_..._psif_epsc_update_set_or_offset(psif_epsc_update_set_or_offset data) */
int network_order,
const struct psif_epsc_csr_update *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_update(psif_epsc_csr_update data) */
int network_order,
const struct psif_epsc_csr_uf_ctrl *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_uf_ctrl(psif_epsc_csr_uf_ctrl data) */
int network_order,
const struct psif_csr_mmu_flush_caches *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_mmu_flush_caches(psif_csr_mmu_flush_caches data) */
int network_order,
const struct psif_epsc_flush_caches *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_flush_caches(psif_epsc_flush_caches data) */
int network_order,
const struct psif_epsc_csr_pma_counters *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_pma_counters(psif_epsc_csr_pma_counters data) */
int network_order,
const struct psif_epsc_vimma_dereg *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 4; i++) {
}
}
} /* end write_..._psif_epsc_vimma_dereg(psif_epsc_vimma_dereg data) */
int network_order,
const struct psif_epsc_vimma_vfp_reg *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 16; i++) {
}
}
} /* end write_..._psif_epsc_vimma_vfp_reg(psif_epsc_vimma_vfp_reg data) */
int network_order,
const struct psif_epsc_vimma_set_admmode *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 4; i++) {
}
}
} /* end write_..._psif_epsc_vimma_set_admmode(psif_epsc_vimma_set_admmode data) */
int network_order,
const struct psif_epsc_vimma_reg_info *data)
{
if (network_order) {
}
{ unsigned int i; for (i = 0; i < 4; i++) {
}
}
} /* end write_..._psif_epsc_vimma_reg_info(psif_epsc_vimma_reg_info data) */
int network_order,
const union psif_epsc_vimma_ctrl_cmd *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_vimma_ctrl_cmd(psif_epsc_vimma_ctrl_cmd data) */
int network_order,
const struct psif_epsc_csr_vimma_ctrl *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_vimma_ctrl(psif_epsc_csr_vimma_ctrl data) */
int network_order,
const struct psif_epsc_csr_ber_data *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_ber_data(psif_epsc_csr_ber_data data) */
int network_order,
const union psif_epsc_csr_details *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_details(psif_epsc_csr_details data) */
int network_order,
const struct psif_epsc_csr_req *data)
{
if (network_order) {
network_order = 0;
}
case EPSC_SETUP_BASEADDR:
case EPSC_SET_BASEADDR:
case EPSC_SET_BASEADDR_EQ:
break;
case EPSC_MODIFY_QP:
break;
case EPSC_QUERY_QP:
break;
case EPSC_SET_LID:
break;
case EPSC_SET_GID:
break;
case EPSC_SET_EOIB_MAC:
break;
case EPSC_SET_VLINK_STATE:
case EPSC_QUERY_VLINK_STATE:
break;
case EPSC_QUERY_DEVICE:
case EPSC_QUERY_PORT_1:
case EPSC_QUERY_PORT_2:
case EPSC_QUERY_HW_RQ:
case EPSC_QUERY_HW_SQ:
break;
case EPSC_QUERY_PKEY:
case EPSC_QUERY_GID:
break;
case EPSC_MC_ATTACH:
case EPSC_MC_DETACH:
case EPSC_MC_QUERY:
break;
case EPSC_EVENT_ACK:
break;
case EPSC_MODIFY_DEVICE:
break;
case EPSC_MODIFY_PORT_1:
case EPSC_MODIFY_PORT_2:
break;
case EPSC_FW_VERSION:
break;
case EPSC_LOG_CTRL:
break;
case EPSC_A_CONTROL:
break;
case EPSC_A_COMMAND:
break;
case EPSC_CLI_ACCESS:
break;
case EPSC_MAD_PROCESS:
break;
case EPSC_MAD_SEND_WR:
break;
case EPSC_QUERY:
break;
case EPSC_SET:
break;
break;
break;
case EPSC_UF_CTRL:
break;
case EPSC_FLUSH_CACHES:
break;
case EPSC_PMA_COUNTERS:
break;
case EPSC_NOOP:
case EPSC_TEARDOWN:
case EPSC_TRACE_STATUS:
case EPSC_TRACE_START:
case EPSC_TRACE_STOP:
case EPSC_FLASH_START:
case EPSC_FLASH_INFO:
case EPSC_FLASH_STOP:
case EPSC_GET_SINGLE:
case EPSC_GET_ONE_CSR:
case EPSC_LOG_REQ_NOTIFY:
break;
case EPSC_SET_SINGLE:
case EPSC_SET_ONE_CSR:
case EPSC_UF_RESET:
case EPSC_EVENT_INDEX:
case EPSC_LINK_CNTRL:
break;
default:
break;
}
} /* end write_..._psif_epsc_csr_req(psif_epsc_csr_req data) */
int network_order,
const struct psif_epsc_csr_req *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_req(psif_epsc_csr_req data) */
int network_order,
const struct psif_epsc_csr_doorbell *data)
{
if (network_order) {
}
} /* end write_..._psif_epsc_csr_doorbell(psif_epsc_csr_doorbell data) */
int network_order,
const struct psif_cq_sw *data)
{
if (network_order) {
}
} /* end write_..._psif_cq_sw(psif_cq_sw data) */
int network_order,
const struct psif_cq_hw *data)
{
if (network_order) {
}
} /* end write_..._psif_cq_hw(psif_cq_hw data) */
int network_order,
const union psif_seq_num_immdt *data)
{
} /* end write_..._psif_seq_num_immdt(psif_seq_num_immdt data) */
int network_order,
const struct psif_offload_info *data)
{
if (network_order) {
}
} /* end write_..._psif_offload_info(psif_offload_info data) */
int network_order,
const union psif_offload_wc_id *data)
{
if (network_order) {
}
} /* end write_..._psif_offload_wc_id(psif_offload_wc_id data) */
int network_order,
const struct psif_cq_entry *data)
{
if (network_order) {
}
} /* end write_..._psif_cq_entry(psif_cq_entry data) */
int network_order,
const struct psif_csr_generic *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_generic(psif_csr_generic data) */
int network_order,
const struct psif_base_addr *data)
{
if (network_order) {
}
} /* end write_..._psif_base_addr(psif_base_addr data) */
int network_order,
{
if (network_order) {
}
} /* end write_..._psif_ah(psif_ah data) */
int network_order,
const struct psif_csr_ibpr_eoib_mac1 *data)
{
if (network_order) {
}
} /* end write_..._psif_csr_ibpr_eoib_mac1(psif_csr_ibpr_eoib_mac1 data) */
#endif /* !defined(PSIF_EXCLUDE_WRITE_STRUCTS) */
#endif /* _PSIF_HW_PRINT_C */