/*

 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * Redistribution and use in source and binary forms, with or without

 *  modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *

 * 3. Neither the name of the copyright holder nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.

 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef	_PSIF_HW_PRINT_C

#define	_PSIF_HW_PRINT_C

#if defined(__arm__)

#include <stdio.h>

#include <stdint.h>

#include "psif_endian.h"

typedef uint64_t __be64;

#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>

typedef uint64_t u64;

typedef uint32_t u32;

typedef uint16_t u16;

typedef uint8_t u8;

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

#define xprintf fprintf

#endif

#if !defined(OS_PRIx64)

#define OS_PRIx64 "llx"

#endif

/* Write fixed size bit field represented as unsigned int types */

void write_bits_u8(XFILE *fd, int extent, u8 data)

{

	xprintf(fd, "%#04x", data);

} /* end write_bits_u8(u8 data) */

/* Write fixed size bit field represented as unsigned int types */

void write_bits_u16(XFILE *fd, int extent, u16 data)

{

	xprintf(fd, "%#06x", data);

} /* end write_bits_u16(u16 data) */

/* Write fixed size bit field represented as unsigned int types */

void write_bits_u32(XFILE *fd, int extent, u32 data)

{

	xprintf(fd, "%#010x", data);

} /* end write_bits_u32(u32 data) */

/* Write fixed size bit field represented as unsigned int types */

void write_bits_u64(XFILE *fd, int extent, u64 data)

{

	xprintf(fd, "%#018" OS_PRIx64 "", data);

} /* end write_bits_u64(u64 data) */

/* Convert enum psif_epsc_degrade_cause to string */

const char *string_enum_psif_epsc_degrade_cause(enum psif_epsc_degrade_cause val)

{

	switch (val) {

	case DEGRADE_CAUSE_FLAG_MISSING_GUID:

		return "DEGRADE_CAUSE_FLAG_MISSING_GUID";

	case DEGRADE_CAUSE_FLAG_VPD_INVALID_NAME:

		return "DEGRADE_CAUSE_FLAG_VPD_INVALID_NAME";

	case DEGRADE_CAUSE_FLAG_HW_UNSUPPORTED:

		return "DEGRADE_CAUSE_FLAG_HW_UNSUPPORTED";

	case DEGRADE_CAUSE_FLAG_HW_MDIO_ERROR:

		return "DEGRADE_CAUSE_FLAG_HW_MDIO_ERROR";

	case DEGRADE_CAUSE_FLAG_MODIFY_QP_TIMEOUT:

		return "DEGRADE_CAUSE_FLAG_MODIFY_QP_TIMEOUT";

	case DEGRADE_CAUSE_FLAG_VIRTMODE_RECONF:

		return "DEGRADE_CAUSE_FLAG_VIRTMODE_RECONF";

	case DEGRADE_CAUSE_FLAG_MCAST_LACK_OF_CREDIT:

		return "DEGRADE_CAUSE_FLAG_MCAST_LACK_OF_CREDIT";

	case PSIF_EPSC_DEGRADE_CAUSE_FIELD_MAX:

		return "PSIF_EPSC_DEGRADE_CAUSE_FIELD_MAX";

	default:

		return "UNKNOWN_psif_epsc_degrade_cause";

	}

}

void write_enum_psif_epsc_degrade_cause(XFILE *fd,

	enum psif_epsc_degrade_cause data)

{

	xprintf(fd, "%s", string_enum_psif_epsc_degrade_cause(data));

} /* end write_..._psif_epsc_degrade_cause(psif_epsc_degrade_cause data) */

/* Convert enum psif_mmu_translation to string */

const char *string_enum_psif_mmu_translation(enum psif_mmu_translation val)

{

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

	}

}

void write_enum_psif_mmu_translation(XFILE *fd,

	enum psif_mmu_translation data)

{

	xprintf(fd, "%s", string_enum_psif_mmu_translation(data));

} /* end write_..._psif_mmu_translation(psif_mmu_translation data) */

/* Convert enum psif_page_size to string */

const char *string_enum_psif_page_size(enum psif_page_size val)

{

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

	}

}

void write_enum_psif_page_size(XFILE *fd,

	enum psif_page_size data)

{

	xprintf(fd, "%s", string_enum_psif_page_size(data));

} /* end write_..._psif_page_size(psif_page_size data) */

/* Convert enum psif_wr_type to string */

const char *string_enum_psif_wr_type(enum psif_wr_type val)

{

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

	case PSIF_WR_QP0_SEND_DR_LOOPBACK:

		return "PSIF_WR_QP0_SEND_DR_LOOPBACK";

	case PSIF_WR_EPS_SPECIAL_QP_SEND:

		return "PSIF_WR_EPS_SPECIAL_QP_SEND";

	case PSIF_WR_EPS_QP0_SEND_DR_XMIT:

		return "PSIF_WR_EPS_QP0_SEND_DR_XMIT";

	case PSIF_WR_EPS_QP0_SEND_DR_LOOPBACK:

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

	case PSIF_WR_INVALIDATE_BOTH_KEYS:

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

	case PSIF_WR_GENERATE_COMPLETION:

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

	case PSIF_WR_INVALIDATE_XRCSRQ:

		return "PSIF_WR_INVALIDATE_XRCSRQ";

	case PSIF_WR_INVALIDATE_SGL_CACHE:

		return "PSIF_WR_INVALIDATE_SGL_CACHE";

	default:

		return "UNKNOWN_psif_wr_type";

	}

}

void write_enum_psif_wr_type(XFILE *fd,

	enum psif_wr_type data)

{

	xprintf(fd, "%s", string_enum_psif_wr_type(data));

} /* end write_..._psif_wr_type(psif_wr_type data) */

/* Convert enum psif_port to string */

const char *string_enum_psif_port(enum psif_port val)

{

	switch (val) {

	case PORT_1:

		return "PORT_1";

	case PORT_2:

		return "PORT_2";

	default:

		return "UNKNOWN_psif_port";

	}

}

void write_enum_psif_port(XFILE *fd,

	enum psif_port data)

{

	xprintf(fd, "%s", string_enum_psif_port(data));

} /* end write_..._psif_port(psif_port data) */

/* Convert enum psif_use_ah to string */

const char *string_enum_psif_use_ah(enum psif_use_ah val)

{

	switch (val) {

	case NO_AHA:

		return "NO_AHA";

	case USE_AHA:

		return "USE_AHA";

	default:

		return "UNKNOWN_psif_use_ah";

	}

}

void write_enum_psif_use_ah(XFILE *fd,

	enum psif_use_ah data)

{

	xprintf(fd, "%s", string_enum_psif_use_ah(data));

} /* end write_..._psif_use_ah(psif_use_ah data) */

/* Convert enum psif_tsu_qos to string */

const char *string_enum_psif_tsu_qos(enum psif_tsu_qos val)

{

	switch (val) {

	case QOSL_HIGH_BANDWIDTH:

		return "QOSL_HIGH_BANDWIDTH";

	case QOSL_LOW_LATENCY:

		return "QOSL_LOW_LATENCY";

	default:

		return "UNKNOWN_psif_tsu_qos";

	}

}

void write_enum_psif_tsu_qos(XFILE *fd,

	enum psif_tsu_qos data)

{

	xprintf(fd, "%s", string_enum_psif_tsu_qos(data));

} /* end write_..._psif_tsu_qos(psif_tsu_qos data) */

/* Convert enum psif_wc_opcode to string */

const char *string_enum_psif_wc_opcode(enum psif_wc_opcode val)

{

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

	case PSIF_WC_OPCODE_MASKED_CMP_SWAP:

		return "PSIF_WC_OPCODE_MASKED_CMP_SWAP";

	case PSIF_WC_OPCODE_MASKED_FETCH_ADD:

		return "PSIF_WC_OPCODE_MASKED_FETCH_ADD";

	case PSIF_WC_OPCODE_INVALIDATE_RKEY:

		return "PSIF_WC_OPCODE_INVALIDATE_RKEY";

	case PSIF_WC_OPCODE_INVALIDATE_LKEY:

		return "PSIF_WC_OPCODE_INVALIDATE_LKEY";

	case PSIF_WC_OPCODE_INVALIDATE_BOTH_KEYS:

		return "PSIF_WC_OPCODE_INVALIDATE_BOTH_KEYS";

	case PSIF_WC_OPCODE_INVALIDATE_TLB:

		return "PSIF_WC_OPCODE_INVALIDATE_TLB";

	case PSIF_WC_OPCODE_RESIZE_CQ:

		return "PSIF_WC_OPCODE_RESIZE_CQ";

	case PSIF_WC_OPCODE_SET_SRQ_LIM:

		return "PSIF_WC_OPCODE_SET_SRQ_LIM";

	case PSIF_WC_OPCODE_SET_XRCSRQ_LIM:

		return "PSIF_WC_OPCODE_SET_XRCSRQ_LIM";

	case PSIF_WC_OPCODE_REQ_CMPL_NOTIFY:

		return "PSIF_WC_OPCODE_REQ_CMPL_NOTIFY";

	case PSIF_WC_OPCODE_CMPL_NOTIFY_RCVD:

		return "PSIF_WC_OPCODE_CMPL_NOTIFY_RCVD";

	case PSIF_WC_OPCODE_REARM_CMPL_EVENT:

		return "PSIF_WC_OPCODE_REARM_CMPL_EVENT";

	case PSIF_WC_OPCODE_GENERATE_COMPLETION:

		return "PSIF_WC_OPCODE_GENERATE_COMPLETION";

	case PSIF_WC_OPCODE_INVALIDATE_RQ:

		return "PSIF_WC_OPCODE_INVALIDATE_RQ";

	case PSIF_WC_OPCODE_INVALIDATE_CQ:

		return "PSIF_WC_OPCODE_INVALIDATE_CQ";

	case PSIF_WC_OPCODE_INVALIDATE_RB:

		return "PSIF_WC_OPCODE_INVALIDATE_RB";

	case PSIF_WC_OPCODE_INVALIDATE_XRCSRQ:

		return "PSIF_WC_OPCODE_INVALIDATE_XRCSRQ";

	case PSIF_WC_OPCODE_INVALIDATE_SGL_CACHE:

		return "PSIF_WC_OPCODE_INVALIDATE_SGL_CACHE";

	case PSIF_WC_OPCODE_RECEIVE_SEND:

		return "PSIF_WC_OPCODE_RECEIVE_SEND";

	case PSIF_WC_OPCODE_RECEIVE_RDMA_WR_IMM:

		return "PSIF_WC_OPCODE_RECEIVE_RDMA_WR_IMM";

	case PSIF_WC_OPCODE_RECEIVE_CONDITIONAL_WR_IMM:

		return "PSIF_WC_OPCODE_RECEIVE_CONDITIONAL_WR_IMM";

	default:

		return "UNKNOWN_psif_wc_opcode";

	}

}

void write_enum_psif_wc_opcode(XFILE *fd,

	enum psif_wc_opcode data)

{

	xprintf(fd, "%s", string_enum_psif_wc_opcode(data));

} /* end write_..._psif_wc_opcode(psif_wc_opcode data) */

/* Convert enum psif_wc_status to string */

const char *string_enum_psif_wc_status(enum psif_wc_status val)

{

	switch (val) {

	case PSIF_WC_STATUS_SUCCESS:

		return "PSIF_WC_STATUS_SUCCESS";

	case PSIF_WC_STATUS_LOC_LEN_ERR:

		return "PSIF_WC_STATUS_LOC_LEN_ERR";

	case PSIF_WC_STATUS_LOC_QP_OP_ERR:

		return "PSIF_WC_STATUS_LOC_QP_OP_ERR";

	case PSIF_WC_STATUS_LOC_EEC_OP_ERR:

		return "PSIF_WC_STATUS_LOC_EEC_OP_ERR";

	case PSIF_WC_STATUS_LOC_PROT_ERR:

		return "PSIF_WC_STATUS_LOC_PROT_ERR";

	case PSIF_WC_STATUS_WR_FLUSH_ERR:

		return "PSIF_WC_STATUS_WR_FLUSH_ERR";

	case PSIF_WC_STATUS_MW_BIND_ERR:

		return "PSIF_WC_STATUS_MW_BIND_ERR";

	case PSIF_WC_STATUS_BAD_RESP_ERR:

		return "PSIF_WC_STATUS_BAD_RESP_ERR";

	case PSIF_WC_STATUS_LOC_ACCESS_ERR:

		return "PSIF_WC_STATUS_LOC_ACCESS_ERR";

	case PSIF_WC_STATUS_REM_INV_REQ_ERR:

		return "PSIF_WC_STATUS_REM_INV_REQ_ERR";

	case PSIF_WC_STATUS_REM_ACCESS_ERR:

		return "PSIF_WC_STATUS_REM_ACCESS_ERR";

	case PSIF_WC_STATUS_REM_OP_ERR:

		return "PSIF_WC_STATUS_REM_OP_ERR";

	case PSIF_WC_STATUS_RETRY_EXC_ERR:

		return "PSIF_WC_STATUS_RETRY_EXC_ERR";

	case PSIF_WC_STATUS_RNR_RETRY_EXC_ERR:

		return "PSIF_WC_STATUS_RNR_RETRY_EXC_ERR";

	case PSIF_WC_STATUS_LOC_RDD_VIOL_ERR:

		return "PSIF_WC_STATUS_LOC_RDD_VIOL_ERR";

	case PSIF_WC_STATUS_REM_INV_RD_REQ_ERR:

		return "PSIF_WC_STATUS_REM_INV_RD_REQ_ERR";

	case PSIF_WC_STATUS_REM_ABORT_ERR:

		return "PSIF_WC_STATUS_REM_ABORT_ERR";

	case PSIF_WC_STATUS_INV_EECN_ERR:

		return "PSIF_WC_STATUS_INV_EECN_ERR";

	case PSIF_WC_STATUS_INV_EEC_STATE_ERR:

		return "PSIF_WC_STATUS_INV_EEC_STATE_ERR";

	case PSIF_WC_STATUS_FATAL_ERR:

		return "PSIF_WC_STATUS_FATAL_ERR";

	case PSIF_WC_STATUS_RESP_TIMEOUT_ERR:

		return "PSIF_WC_STATUS_RESP_TIMEOUT_ERR";

	case PSIF_WC_STATUS_GENERAL_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";

	}

}

void write_enum_psif_wc_status(XFILE *fd,

	enum psif_wc_status data)

{

	xprintf(fd, "%s", string_enum_psif_wc_status(data));

} /* end write_..._psif_wc_status(psif_wc_status data) */

/* Convert enum ib_opcode to string */

const char *string_enum_ib_opcode(enum ib_opcode val)

{

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