/* BEGIN_ICS_COPYRIGHT7 ****************************************

Copyright (c) 2015-2017, Intel Corporation

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

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

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

      this list of conditions and the following disclaimer.

    * 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.

    * Neither the name of Intel Corporation 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 OWNER 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.

** END_ICS_COPYRIGHT7   ****************************************/

/* [ICS VERSION STRING: unknown] */

#ifndef _STL_PA_PRIV_H_

#define _STL_PA_PRIV_H_ (1) /* suppress duplicate loading of this file */

#include "iba/stl_pa_types.h"

#include "iba/stl_mad_types.h"

#ifdef __cplusplus

extern "C" {

#endif

static __inline void

BSWAP_STL_PA_IMAGE_ID(STL_PA_IMAGE_ID_DATA *pRecord)

{

#if CPU_LE

	pRecord->imageNumber						= ntoh64(pRecord->imageNumber);

	pRecord->imageOffset						= ntoh32(pRecord->imageOffset);

	pRecord->imageTime.absoluteTime				= ntoh32(pRecord->imageTime.absoluteTime);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_PM_GROUP_INFO(STL_PA_PM_GROUP_INFO_DATA *pRecord, boolean isRequest)

{

#if CPU_LE

	int i;

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	if (isRequest) return;

	pRecord->numInternalPorts				= ntoh32(pRecord->numInternalPorts);

	pRecord->numExternalPorts				= ntoh32(pRecord->numExternalPorts);

	pRecord->internalUtilStats.totalMBps	= ntoh64(pRecord->internalUtilStats.totalMBps);

	pRecord->internalUtilStats.totalKPps	= ntoh64(pRecord->internalUtilStats.totalKPps);

	pRecord->internalUtilStats.avgMBps		= ntoh32(pRecord->internalUtilStats.avgMBps);

	pRecord->internalUtilStats.minMBps		= ntoh32(pRecord->internalUtilStats.minMBps);

	pRecord->internalUtilStats.maxMBps		= ntoh32(pRecord->internalUtilStats.maxMBps);

	pRecord->internalUtilStats.numBWBuckets		= ntoh32(pRecord->internalUtilStats.numBWBuckets);

	for (i = 0; i < STL_PM_UTIL_BUCKETS; i++)

		pRecord->internalUtilStats.BWBuckets[i] = ntoh32(pRecord->internalUtilStats.BWBuckets[i]);

	pRecord->internalUtilStats.avgKPps		= ntoh32(pRecord->internalUtilStats.avgKPps);

	pRecord->internalUtilStats.minKPps		= ntoh32(pRecord->internalUtilStats.minKPps);

	pRecord->internalUtilStats.maxKPps		= ntoh32(pRecord->internalUtilStats.maxKPps);

	pRecord->internalUtilStats.pmaNoRespPorts = ntoh16(pRecord->internalUtilStats.pmaNoRespPorts);

	pRecord->internalUtilStats.topoIncompPorts = ntoh16(pRecord->internalUtilStats.topoIncompPorts);

	pRecord->sendUtilStats.totalMBps		= ntoh64(pRecord->sendUtilStats.totalMBps);

	pRecord->sendUtilStats.totalKPps		= ntoh64(pRecord->sendUtilStats.totalKPps);

	pRecord->sendUtilStats.avgMBps			= ntoh32(pRecord->sendUtilStats.avgMBps);

	pRecord->sendUtilStats.minMBps			= ntoh32(pRecord->sendUtilStats.minMBps);

	pRecord->sendUtilStats.maxMBps			= ntoh32(pRecord->sendUtilStats.maxMBps);

	pRecord->sendUtilStats.numBWBuckets		= ntoh32(pRecord->sendUtilStats.numBWBuckets);

	for (i = 0; i < STL_PM_UTIL_BUCKETS; i++)

		pRecord->sendUtilStats.BWBuckets[i] = ntoh32(pRecord->sendUtilStats.BWBuckets[i]);

	pRecord->sendUtilStats.avgKPps			= ntoh32(pRecord->sendUtilStats.avgKPps);

	pRecord->sendUtilStats.minKPps			= ntoh32(pRecord->sendUtilStats.minKPps);

	pRecord->sendUtilStats.maxKPps			= ntoh32(pRecord->sendUtilStats.maxKPps);

	pRecord->sendUtilStats.pmaNoRespPorts   = ntoh16(pRecord->sendUtilStats.pmaNoRespPorts);

	pRecord->sendUtilStats.topoIncompPorts  = ntoh16(pRecord->sendUtilStats.topoIncompPorts);

	pRecord->recvUtilStats.totalMBps		= ntoh64(pRecord->recvUtilStats.totalMBps);

	pRecord->recvUtilStats.totalKPps		= ntoh64(pRecord->recvUtilStats.totalKPps);

	pRecord->recvUtilStats.avgMBps			= ntoh32(pRecord->recvUtilStats.avgMBps);

	pRecord->recvUtilStats.minMBps			= ntoh32(pRecord->recvUtilStats.minMBps);

	pRecord->recvUtilStats.maxMBps			= ntoh32(pRecord->recvUtilStats.maxMBps);

	pRecord->recvUtilStats.numBWBuckets		= ntoh32(pRecord->recvUtilStats.numBWBuckets);

	for (i = 0; i < STL_PM_UTIL_BUCKETS; i++)

		pRecord->recvUtilStats.BWBuckets[i] = ntoh32(pRecord->recvUtilStats.BWBuckets[i]);

	pRecord->recvUtilStats.avgKPps			= ntoh32(pRecord->recvUtilStats.avgKPps);

	pRecord->recvUtilStats.minKPps			= ntoh32(pRecord->recvUtilStats.minKPps);

	pRecord->recvUtilStats.maxKPps			= ntoh32(pRecord->recvUtilStats.maxKPps);

	pRecord->recvUtilStats.pmaNoRespPorts   = ntoh16(pRecord->recvUtilStats.pmaNoRespPorts);

	pRecord->recvUtilStats.topoIncompPorts  = ntoh16(pRecord->recvUtilStats.topoIncompPorts);

	pRecord->internalCategoryStats.categoryMaximums.integrityErrors			= ntoh32(pRecord->internalCategoryStats.categoryMaximums.integrityErrors);

	pRecord->internalCategoryStats.categoryMaximums.congestion			= ntoh32(pRecord->internalCategoryStats.categoryMaximums.congestion);

	pRecord->internalCategoryStats.categoryMaximums.smaCongestion		= ntoh32(pRecord->internalCategoryStats.categoryMaximums.smaCongestion);

	pRecord->internalCategoryStats.categoryMaximums.bubble				= ntoh32(pRecord->internalCategoryStats.categoryMaximums.bubble);

	pRecord->internalCategoryStats.categoryMaximums.securityErrors			= ntoh32(pRecord->internalCategoryStats.categoryMaximums.securityErrors);

	pRecord->internalCategoryStats.categoryMaximums.routingErrors				= ntoh32(pRecord->internalCategoryStats.categoryMaximums.routingErrors);

        pRecord->internalCategoryStats.categoryMaximums.utilizationPct10 = ntoh16(pRecord->internalCategoryStats.categoryMaximums.utilizationPct10);

        pRecord->internalCategoryStats.categoryMaximums.discardsPct10    = ntoh16(pRecord->internalCategoryStats.categoryMaximums.discardsPct10);

	for (i = 0; i < STL_PM_CATEGORY_BUCKETS; i++) {

		pRecord->internalCategoryStats.ports[i].integrityErrors			= ntoh32(pRecord->internalCategoryStats.ports[i].integrityErrors);

		pRecord->internalCategoryStats.ports[i].congestion			= ntoh32(pRecord->internalCategoryStats.ports[i].congestion);

		pRecord->internalCategoryStats.ports[i].smaCongestion		= ntoh32(pRecord->internalCategoryStats.ports[i].smaCongestion);

		pRecord->internalCategoryStats.ports[i].bubble				= ntoh32(pRecord->internalCategoryStats.ports[i].bubble);

		pRecord->internalCategoryStats.ports[i].securityErrors				= ntoh32(pRecord->internalCategoryStats.ports[i].securityErrors);

		pRecord->internalCategoryStats.ports[i].routingErrors				= ntoh32(pRecord->internalCategoryStats.ports[i].routingErrors);

	}

	pRecord->externalCategoryStats.categoryMaximums.integrityErrors			= ntoh32(pRecord->externalCategoryStats.categoryMaximums.integrityErrors);

	pRecord->externalCategoryStats.categoryMaximums.congestion			= ntoh32(pRecord->externalCategoryStats.categoryMaximums.congestion);

	pRecord->externalCategoryStats.categoryMaximums.smaCongestion		= ntoh32(pRecord->externalCategoryStats.categoryMaximums.smaCongestion);

	pRecord->externalCategoryStats.categoryMaximums.bubble				= ntoh32(pRecord->externalCategoryStats.categoryMaximums.bubble);

	pRecord->externalCategoryStats.categoryMaximums.securityErrors			= ntoh32(pRecord->externalCategoryStats.categoryMaximums.securityErrors);

	pRecord->externalCategoryStats.categoryMaximums.routingErrors				= ntoh32(pRecord->externalCategoryStats.categoryMaximums.routingErrors);

        pRecord->externalCategoryStats.categoryMaximums.utilizationPct10 = ntoh16(pRecord->externalCategoryStats.categoryMaximums.utilizationPct10);

        pRecord->externalCategoryStats.categoryMaximums.discardsPct10    = ntoh16(pRecord->externalCategoryStats.categoryMaximums.discardsPct10);

        for (i = 0; i < STL_PM_CATEGORY_BUCKETS; i++) {

		pRecord->externalCategoryStats.ports[i].integrityErrors			= ntoh32(pRecord->externalCategoryStats.ports[i].integrityErrors);

		pRecord->externalCategoryStats.ports[i].congestion			= ntoh32(pRecord->externalCategoryStats.ports[i].congestion);

		pRecord->externalCategoryStats.ports[i].smaCongestion		= ntoh32(pRecord->externalCategoryStats.ports[i].smaCongestion);

		pRecord->externalCategoryStats.ports[i].bubble				= ntoh32(pRecord->externalCategoryStats.ports[i].bubble);

		pRecord->externalCategoryStats.ports[i].securityErrors				= ntoh32(pRecord->externalCategoryStats.ports[i].securityErrors);

			pRecord->externalCategoryStats.ports[i].routingErrors			= ntoh32(pRecord->externalCategoryStats.ports[i].routingErrors);

	}

	pRecord->maxInternalMBps				= ntoh32(pRecord->maxInternalMBps);

	pRecord->maxExternalMBps				= ntoh32(pRecord->maxExternalMBps);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_GROUP_LIST(STL_PA_GROUP_LIST *pRecord)

{

#if CPU_LE

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_GROUP_CONFIG_REQ(STL_PA_PM_GROUP_CFG_REQ *pRecord)

{

#if CPU_LE

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_GROUP_CONFIG_RSP(STL_PA_PM_GROUP_CFG_RSP *pRecord)

{

#if CPU_LE

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	pRecord->nodeGUID							= ntoh64(pRecord->nodeGUID);

	pRecord->nodeLid							= ntoh32(pRecord->nodeLid);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_GROUP_NODE_INFO_REQ(STL_PA_GROUP_NODEINFO_REQ *pRecord)

{

#if CPU_LE

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	pRecord->nodeGUID							= ntoh64(pRecord->nodeGUID);

	pRecord->nodeLID							= ntoh32(pRecord->nodeLID);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_GROUP_NODE_INFO_RSP(STL_PA_GROUP_NODEINFO_RSP *pRecord)

{

#if CPU_LE

	int i;

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	pRecord->nodeGUID							= ntoh64(pRecord->nodeGUID);

	pRecord->nodeLID							= ntoh32(pRecord->nodeLID);

	for (i = 0; i < 4; i++)

		pRecord->portSelectMask[i]					= ntoh64(pRecord->portSelectMask[i]);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_GROUP_LINK_INFO_REQ(STL_PA_GROUP_LINKINFO_REQ *pRecord)

{

#if CPU_LE

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	pRecord->lid								= ntoh32(pRecord->lid);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_GROUP_LINK_INFO_RSP(STL_PA_GROUP_LINKINFO_RSP *pRecord)

{

#if CPU_LE

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	pRecord->fromLID							= ntoh32(pRecord->fromLID);

	pRecord->toLID								= ntoh32(pRecord->toLID);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_PORT_COUNTERS(STL_PORT_COUNTERS_DATA *pRecord)

{

#if CPU_LE

	pRecord->nodeLid							= ntoh32(pRecord->nodeLid);

	pRecord->flags								= ntoh32(pRecord->flags);

	pRecord->portXmitData						= ntoh64(pRecord->portXmitData);

	pRecord->portRcvData						= ntoh64(pRecord->portRcvData);

	pRecord->portXmitPkts						= ntoh64(pRecord->portXmitPkts);

	pRecord->portRcvPkts						= ntoh64(pRecord->portRcvPkts);

	pRecord->portMulticastXmitPkts				= ntoh64(pRecord->portMulticastXmitPkts);

	pRecord->portMulticastRcvPkts				= ntoh64(pRecord->portMulticastRcvPkts);

	pRecord->localLinkIntegrityErrors			= ntoh64(pRecord->localLinkIntegrityErrors);

	pRecord->fmConfigErrors						= ntoh64(pRecord->fmConfigErrors);

	pRecord->portRcvErrors						= ntoh64(pRecord->portRcvErrors);

	pRecord->excessiveBufferOverruns			= ntoh64(pRecord->excessiveBufferOverruns);

	pRecord->portRcvConstraintErrors			= ntoh64(pRecord->portRcvConstraintErrors);

	pRecord->portRcvSwitchRelayErrors			= ntoh64(pRecord->portRcvSwitchRelayErrors);

	pRecord->portXmitDiscards					= ntoh64(pRecord->portXmitDiscards);

	pRecord->portXmitConstraintErrors			= ntoh64(pRecord->portXmitConstraintErrors);

	pRecord->portRcvRemotePhysicalErrors		= ntoh64(pRecord->portRcvRemotePhysicalErrors);

	pRecord->swPortCongestion					= ntoh64(pRecord->swPortCongestion);

	pRecord->portXmitWait						= ntoh64(pRecord->portXmitWait);

	pRecord->portRcvFECN						= ntoh64(pRecord->portRcvFECN);

	pRecord->portRcvBECN						= ntoh64(pRecord->portRcvBECN);

	pRecord->portXmitTimeCong					= ntoh64(pRecord->portXmitTimeCong);

	pRecord->portXmitWastedBW					= ntoh64(pRecord->portXmitWastedBW);

	pRecord->portXmitWaitData					= ntoh64(pRecord->portXmitWaitData);

	pRecord->portRcvBubble						= ntoh64(pRecord->portRcvBubble);

	pRecord->portMarkFECN						= ntoh64(pRecord->portMarkFECN);

	pRecord->linkErrorRecovery					= ntoh32(pRecord->linkErrorRecovery);

	pRecord->linkDowned							= ntoh32(pRecord->linkDowned);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_CLR_PORT_COUNTERS(STL_CLR_PORT_COUNTERS_DATA *pRecord)

{

#if CPU_LE

	pRecord->NodeLid							= ntoh32(pRecord->NodeLid);

	pRecord->CounterSelectMask.AsReg32			= ntoh32(pRecord->CounterSelectMask.AsReg32);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_CLR_ALL_PORT_COUNTERS(STL_CLR_ALL_PORT_COUNTERS_DATA *pRecord)

{

#if CPU_LE

	pRecord->CounterSelectMask.AsReg32			= ntoh32(pRecord->CounterSelectMask.AsReg32);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_PM_CFG(STL_PA_PM_CFG_DATA *pRecord)

{

#if CPU_LE

	pRecord->sweepInterval						= ntoh32(pRecord->sweepInterval);

	pRecord->maxClients							= ntoh32(pRecord->maxClients);

	pRecord->sizeHistory						= ntoh32(pRecord->sizeHistory);

	pRecord->sizeFreeze							= ntoh32(pRecord->sizeFreeze);

	pRecord->lease								= ntoh32(pRecord->lease);

	pRecord->pmFlags							= ntoh32(pRecord->pmFlags);

	pRecord->categoryThresholds.integrityErrors	= ntoh32(pRecord->categoryThresholds.integrityErrors);

	pRecord->categoryThresholds.congestion	= ntoh32(pRecord->categoryThresholds.congestion);

	pRecord->categoryThresholds.smaCongestion	= ntoh32(pRecord->categoryThresholds.smaCongestion);

	pRecord->categoryThresholds.bubble		= ntoh32(pRecord->categoryThresholds.bubble);

	pRecord->categoryThresholds.securityErrors		= ntoh32(pRecord->categoryThresholds.securityErrors);

	pRecord->categoryThresholds.routingErrors		= ntoh32(pRecord->categoryThresholds.routingErrors);

	pRecord->memoryFootprint					= ntoh64(pRecord->memoryFootprint);

	pRecord->maxAttempts						= ntoh32(pRecord->maxAttempts);

	pRecord->respTimeout						= ntoh32(pRecord->respTimeout);

	pRecord->minRespTimeout						= ntoh32(pRecord->minRespTimeout);

	pRecord->maxParallelNodes					= ntoh32(pRecord->maxParallelNodes);

	pRecord->pmaBatchSize						= ntoh32(pRecord->pmaBatchSize);

	// ErrorClear is uint8

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_FOCUS_PORTS_REQ(STL_FOCUS_PORTS_REQ *pRecord)

{

#if CPU_LE

	pRecord->select						= ntoh32(pRecord->select);

	pRecord->start						= ntoh32(pRecord->start);

	pRecord->range						= ntoh32(pRecord->range);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif

}

static __inline void

BSWAP_STL_PA_FOCUS_PORTS_MULTISELECT_REQ(STL_FOCUS_PORTS_MULTISELECT_REQ *pRecord)

{

#if CPU_LE

	int i;

	pRecord->start						= ntoh32(pRecord->start);

	pRecord->range						= ntoh32(pRecord->range);

	for (i = 0; i < MAX_NUM_FOCUS_PORT_TUPLES; i++) {

		pRecord->tuple[i].select			= ntoh32(pRecord->tuple[i].select);

		pRecord->tuple[i].argument			= ntoh64(pRecord->tuple[i].argument);

	}

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif

}

static __inline void

BSWAP_STL_PA_FOCUS_PORTS_RSP(STL_FOCUS_PORTS_RSP *pRecord)

{

#if CPU_LE

	pRecord->nodeLid					= ntoh32(pRecord->nodeLid);

	pRecord->value						= ntoh64(pRecord->value);

	pRecord->neighborLid				= ntoh32(pRecord->neighborLid);

	pRecord->neighborValue				= ntoh64(pRecord->neighborValue);

	pRecord->nodeGUID					= ntoh64(pRecord->nodeGUID);

	pRecord->neighborGuid				= ntoh64(pRecord->neighborGuid);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_FOCUS_PORTS_MULTISELECT_RSP(STL_FOCUS_PORTS_MULTISELECT_RSP *pRecord)

{

#if CPU_LE

	int i;

	pRecord->nodeLid					= ntoh32(pRecord->nodeLid);

	pRecord->neighborLid					= ntoh32(pRecord->neighborLid);

	pRecord->nodeGUID					= ntoh64(pRecord->nodeGUID);

	pRecord->neighborGuid					= ntoh64(pRecord->neighborGuid);

	for (i = 0; i < MAX_NUM_FOCUS_PORT_TUPLES; i++) {

		pRecord->value[i]				= ntoh64(pRecord->value[i]);

		pRecord->neighborValue[i]			= ntoh64(pRecord->neighborValue[i]);

	}

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_IMAGE_INFO(STL_PA_IMAGE_INFO_DATA *pRecord)

{

#if CPU_LE

	int i;

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	pRecord->sweepStart              = ntoh64(pRecord->sweepStart);

	pRecord->sweepDuration           = ntoh32(pRecord->sweepDuration);

	pRecord->numHFIPorts             = ntoh16(pRecord->numHFIPorts);

	pRecord->numSwitchNodes          = ntoh16(pRecord->numSwitchNodes);

	pRecord->numSwitchPorts          = ntoh32(pRecord->numSwitchPorts);

	pRecord->numLinks                = ntoh32(pRecord->numLinks);

	pRecord->numSMs                  = ntoh32(pRecord->numSMs);

	pRecord->numNoRespNodes          = ntoh32(pRecord->numNoRespNodes);

	pRecord->numNoRespPorts          = ntoh32(pRecord->numNoRespPorts);

	pRecord->numSkippedNodes         = ntoh32(pRecord->numSkippedNodes);

	pRecord->numSkippedPorts         = ntoh32(pRecord->numSkippedPorts);

	pRecord->numUnexpectedClearPorts = ntoh32(pRecord->numUnexpectedClearPorts);

	pRecord->imageInterval           = ntoh32(pRecord->imageInterval);

	for (i = 0; i < 2; i++) {

		pRecord->SMInfo[i].lid        = ntoh32(pRecord->SMInfo[i].lid);

		pRecord->SMInfo[i].smPortGuid = ntoh64(pRecord->SMInfo[i].smPortGuid);

	}

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_MOVE_FREEZE(STL_MOVE_FREEZE_DATA *pRecord)

{

#if CPU_LE

	BSWAP_STL_PA_IMAGE_ID(&pRecord->oldFreezeImage);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->newFreezeImage);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_VF_LIST(STL_PA_VF_LIST *pRecord)

{

#if CPU_LE

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_VF_INFO(STL_PA_VF_INFO_DATA *pRecord, boolean isRequest)

{

#if CPU_LE

	int i;

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

	if (isRequest) return;

	pRecord->numPorts						= ntoh32(pRecord->numPorts);

	pRecord->internalUtilStats.totalMBps	= ntoh64(pRecord->internalUtilStats.totalMBps);

	pRecord->internalUtilStats.totalKPps	= ntoh64(pRecord->internalUtilStats.totalKPps);

	pRecord->internalUtilStats.avgMBps		= ntoh32(pRecord->internalUtilStats.avgMBps);

	pRecord->internalUtilStats.minMBps		= ntoh32(pRecord->internalUtilStats.minMBps);

	pRecord->internalUtilStats.maxMBps		= ntoh32(pRecord->internalUtilStats.maxMBps);

	pRecord->internalUtilStats.numBWBuckets		= ntoh32(pRecord->internalUtilStats.numBWBuckets);

	for (i = 0; i < STL_PM_UTIL_BUCKETS; i++)

		pRecord->internalUtilStats.BWBuckets[i] = ntoh32(pRecord->internalUtilStats.BWBuckets[i]);

	pRecord->internalUtilStats.avgKPps		= ntoh32(pRecord->internalUtilStats.avgKPps);

	pRecord->internalUtilStats.minKPps		= ntoh32(pRecord->internalUtilStats.minKPps);

	pRecord->internalUtilStats.maxKPps		= ntoh32(pRecord->internalUtilStats.maxKPps);

	pRecord->internalUtilStats.pmaNoRespPorts = ntoh16(pRecord->internalUtilStats.pmaNoRespPorts);

	pRecord->internalUtilStats.topoIncompPorts = ntoh16(pRecord->internalUtilStats.topoIncompPorts);

	pRecord->internalCategoryStats.categoryMaximums.integrityErrors			= ntoh32(pRecord->internalCategoryStats.categoryMaximums.integrityErrors);

	pRecord->internalCategoryStats.categoryMaximums.congestion			= ntoh32(pRecord->internalCategoryStats.categoryMaximums.congestion);

	pRecord->internalCategoryStats.categoryMaximums.smaCongestion		= ntoh32(pRecord->internalCategoryStats.categoryMaximums.smaCongestion);

	pRecord->internalCategoryStats.categoryMaximums.bubble				= ntoh32(pRecord->internalCategoryStats.categoryMaximums.bubble);

	pRecord->internalCategoryStats.categoryMaximums.securityErrors			= ntoh32(pRecord->internalCategoryStats.categoryMaximums.securityErrors);

	pRecord->internalCategoryStats.categoryMaximums.routingErrors				= ntoh32(pRecord->internalCategoryStats.categoryMaximums.routingErrors);

        pRecord->internalCategoryStats.categoryMaximums.utilizationPct10 = ntoh16(pRecord->internalCategoryStats.categoryMaximums.utilizationPct10);

        pRecord->internalCategoryStats.categoryMaximums.discardsPct10    = ntoh16(pRecord->internalCategoryStats.categoryMaximums.discardsPct10);

	for (i = 0; i < STL_PM_CATEGORY_BUCKETS; i++) {

		pRecord->internalCategoryStats.ports[i].integrityErrors			= ntoh32(pRecord->internalCategoryStats.ports[i].integrityErrors);

		pRecord->internalCategoryStats.ports[i].congestion			= ntoh32(pRecord->internalCategoryStats.ports[i].congestion);

		pRecord->internalCategoryStats.ports[i].smaCongestion		= ntoh32(pRecord->internalCategoryStats.ports[i].smaCongestion);

		pRecord->internalCategoryStats.ports[i].bubble				= ntoh32(pRecord->internalCategoryStats.ports[i].bubble);

		pRecord->internalCategoryStats.ports[i].securityErrors				= ntoh32(pRecord->internalCategoryStats.ports[i].securityErrors);

		pRecord->internalCategoryStats.ports[i].routingErrors				= ntoh32(pRecord->internalCategoryStats.ports[i].routingErrors);

	}

	pRecord->maxInternalMBps				= ntoh32(pRecord->maxInternalMBps);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_VF_CFG_REQ(STL_PA_VF_CFG_REQ *pRecord)

{

#if CPU_LE

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_VF_CFG_RSP(STL_PA_VF_CFG_RSP *pRecord)

{

#if CPU_LE

	pRecord->nodeGUID						= ntoh64(pRecord->nodeGUID);

	pRecord->nodeLid						= ntoh32(pRecord->nodeLid);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_VF_PORT_COUNTERS(STL_PA_VF_PORT_COUNTERS_DATA *pRecord)

{

#if CPU_LE

	pRecord->nodeLid							= ntoh32(pRecord->nodeLid);

	pRecord->flags								= ntoh32(pRecord->flags);

	pRecord->portVFXmitData						= ntoh64(pRecord->portVFXmitData);

	pRecord->portVFRcvData						= ntoh64(pRecord->portVFRcvData);

	pRecord->portVFXmitPkts						= ntoh64(pRecord->portVFXmitPkts);

	pRecord->portVFRcvPkts						= ntoh64(pRecord->portVFRcvPkts);

	pRecord->portVFXmitDiscards					= ntoh16(pRecord->portVFXmitDiscards);

	pRecord->swPortVFCongestion					= ntoh64(pRecord->swPortVFCongestion);

	pRecord->portVFXmitWait						= ntoh64(pRecord->portVFXmitWait);

	pRecord->portVFRcvFECN						= ntoh64(pRecord->portVFRcvFECN);

	pRecord->portVFRcvBECN						= ntoh64(pRecord->portVFRcvBECN);

	pRecord->portVFXmitTimeCong					= ntoh64(pRecord->portVFXmitTimeCong);

	pRecord->portVFXmitWastedBW					= ntoh64(pRecord->portVFXmitWastedBW);

	pRecord->portVFXmitWaitData					= ntoh64(pRecord->portVFXmitWaitData);

	pRecord->portVFRcvBubble					= ntoh64(pRecord->portVFRcvBubble);

	pRecord->portVFMarkFECN						= ntoh64(pRecord->portVFMarkFECN);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_CLEAR_VF_PORT_COUNTERS(STL_PA_CLEAR_VF_PORT_COUNTERS_DATA *pRecord)

{

#if CPU_LE

	pRecord->nodeLid							= ntoh32(pRecord->nodeLid);

	pRecord->vfCounterSelectMask.AsReg32		= ntoh32(pRecord->vfCounterSelectMask.AsReg32);

#endif /* CPU_LE */

}

static __inline void

BSWAP_STL_PA_VF_FOCUS_PORTS_REQ(STL_PA_VF_FOCUS_PORTS_REQ *pRecord)

{

#if CPU_LE

	pRecord->select						= ntoh32(pRecord->select);

	pRecord->start						= ntoh32(pRecord->start);

	pRecord->range						= ntoh32(pRecord->range);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif

}

static __inline void

BSWAP_STL_PA_VF_FOCUS_PORTS_RSP(STL_PA_VF_FOCUS_PORTS_RSP *pRecord)

{

#if CPU_LE

	pRecord->nodeLid					= ntoh32(pRecord->nodeLid);

	pRecord->value						= ntoh64(pRecord->value);

	pRecord->neighborLid				= ntoh32(pRecord->neighborLid);

	pRecord->neighborValue				= ntoh64(pRecord->neighborValue);

	pRecord->nodeGUID					= ntoh64(pRecord->nodeGUID);

	pRecord->neighborGuid				= ntoh64(pRecord->neighborGuid);

	BSWAP_STL_PA_IMAGE_ID(&pRecord->imageId);

#endif /* CPU_LE */

}

/* Performance Analysis Response Structures */

typedef struct _STL_PA_GROUP_LIST_RESULTS  {

    uint32 NumGroupListRecords;                /* Number of PA Records returned */

    STL_PA_GROUP_LIST GroupListRecords[1];		/* list of PA records returned */

} STL_PA_GROUP_LIST_RESULTS, *PSTL_PA_GROUP_LIST_RESULTS;

typedef struct _STL_PA_GROUP_INFO_RESULTS  {

    uint32 NumGroupInfoRecords;                /* Number of PA Records returned */

    STL_PA_PM_GROUP_INFO_DATA GroupInfoRecords[1];		/* list of PA records returned */

} STL_PA_GROUP_INFO_RESULTS, *PSTL_PA_GROUP_INFO_RESULTS;

typedef struct _STL_PA_GROUP_CONFIG_RESULTS  {

    uint32 NumGroupConfigRecords;                /* Number of PA Records returned */

    STL_PA_PM_GROUP_CFG_RSP GroupConfigRecords[1];		/* list of PA records returned */

} STL_PA_GROUP_CONFIG_RESULTS, *PSTL_PA_GROUP_CONFIG_RESULTS;

typedef struct _STL_PA_GROUP_NODEINFO_RESULTS  {

    uint32 NumGroupNodeInfoRecords;                /* Number of PA Records returned */

    STL_PA_GROUP_NODEINFO_RSP GroupNodeInfoRecords[1];		/* list of PA records returned */

} STL_PA_GROUP_NODEINFO_RESULTS, *PSTL_PA_GROUP_NODEINFO_RESULTS;

typedef struct _STL_PA_GROUP_LINKINFO_RESULTS  {

    uint32 NumGroupLinkInfoRecords;                /* Number of PA Records returned */

    STL_PA_GROUP_LINKINFO_RSP GroupLinkInfoRecords[1];		/* list of PA records returned */

} STL_PA_GROUP_LINKINFO_RESULTS, *PSTL_PA_GROUP_LINKINFO_RESULTS;

typedef struct _STL_PA_PORT_COUNTERS_RESULTS  {

    uint32 NumPortCountersRecords;                /* Number of PA Records returned */

    STL_PORT_COUNTERS_DATA PortCountersRecords[1];		/* list of PA records returned */

} STL_PA_PORT_COUNTERS_RESULTS, *PSTL_PA_PORT_COUNTERS_RESULTS;

typedef struct _STL_PA_CLR_PORT_COUNTERS_RESULTS  {

    uint32 NumClrPortCountersRecords;                /* Number of PA Records returned */

    STL_CLR_PORT_COUNTERS_DATA ClrPortCountersRecords[1];		/* list of PA records returned */

} STL_PA_CLR_PORT_COUNTERS_RESULTS, *PSTL_PA_CLR_PORT_COUNTERS_RESULTS;

typedef struct _STL_PA_CLR_ALL_PORT_COUNTERS_RESULTS  {

    uint32 NumClrAllPortCountersRecords;                /* Number of PA Records returned */

    STL_CLR_ALL_PORT_COUNTERS_DATA ClrAllPortCountersRecords[1];		/* list of PA records returned */

} STL_PA_CLR_ALL_PORT_COUNTERS_RESULTS, *PSTL_PA_CLR_ALL_PORT_COUNTERS_RESULTS;

typedef struct _STL_PA_PM_CONFIG_RESULTS  {

    uint32 NumPmConfigRecords;                /* Number of PA Records returned */

    STL_PA_PM_CFG_DATA PmConfigRecords[1];		/* list of PA records returned */

} STL_PA_PM_CONFIG_RESULTS, *PSTL_PA_PM_CONFIG_RESULTS;

typedef struct _STL_PA_IMAGE_ID_RESULTS  {

    uint32 NumImageIDRecords;                /* Number of PA Records returned */

    STL_PA_IMAGE_ID_DATA ImageIDRecords[1];		/* list of PA records returned */

} STL_PA_IMAGE_ID_RESULTS, *PSTL_PA_IMAGE_ID_RESULTS;

typedef struct _STL_PA_FOCUS_PORTS_RESULTS  {

    uint32 NumFocusPortsRecords;                /* Number of PA Records returned */

    STL_FOCUS_PORTS_RSP FocusPortsRecords[1];		/* list of PA records returned */

} STL_PA_FOCUS_PORTS_RESULTS, *PSTL_PA_FOCUS_PORTS_RESULTS;

typedef struct _STL_PA_FOCUS_PORTS_MULTISELECT_RESULTS  {

    uint32 NumFocusPortsRecords;                /* Number of PA Records returned */

    STL_FOCUS_PORTS_MULTISELECT_RSP FocusPortsRecords[1];		/* list of PA records returned */

} STL_PA_FOCUS_PORTS_MULTISELECT_RESULTS, *PSTL_PA_FOCUS_PORTS_RESULTS_MULTISELECT;

typedef struct _STL_PA_IMAGE_INFO_RESULTS  {

    uint32 NumImageInfoRecords;                /* Number of PA Records returned */

    STL_PA_IMAGE_INFO_DATA ImageInfoRecords[1];		/* list of PA records returned */

} STL_PA_IMAGE_INFO_RESULTS, *PSTL_PA_IMAGE_INFO_RESULTS;

typedef struct _STL_MOVE_FREEZE_RESULTS  {

    uint32 NumMoveFreezeRecords;                /* Number of PA Records returned */

    STL_MOVE_FREEZE_DATA MoveFreezeRecords[1];		/* list of PA records returned */

} STL_MOVE_FREEZE_RESULTS, *PSTL_PA_MOVE_FREEZE_RESULTS;

typedef struct _STL_PA_VF_LIST_RESULTS  {

    uint32 NumVFListRecords;                /* Number of PA Records returned */

    STL_PA_VF_LIST VFListRecords[1];		/* list of PA records returned */

} STL_PA_VF_LIST_RESULTS, *PSTL_PA_VF_LIST_RESULTS;

typedef struct _STL_PA_VF_INFO_RESULTS  {

    uint32 NumVFInfoRecords;                /* Number of PA Records returned */

    STL_PA_VF_INFO_DATA VFInfoRecords[1];		/* list of PA records returned */

} STL_PA_VF_INFO_RESULTS, *PSTL_PA_VF_INFO_RESULTS;

typedef struct _STL_PA_VF_CONFIG_RESULTS  {

    uint32 NumVFConfigRecords;                /* Number of PA Records returned */

    STL_PA_VF_CFG_RSP VFConfigRecords[1];		/* list of PA records returned */

} STL_PA_VF_CONFIG_RESULTS, *PSTL_PA_VF_CONFIG_RESULTS;

typedef struct _STL_PA_VF_FOCUS_PORTS_RESULTS  {

    uint32 NumVFFocusPortsRecords;                /* Number of PA Records returned */

    STL_PA_VF_FOCUS_PORTS_RSP FocusPortsRecords[1];		/* list of PA records returned */

} STL_PA_VF_FOCUS_PORTS_RESULTS, *PSTL_PA_VF_FOCUS_PORTS_RESULTS;

typedef struct _STL_PA_GROUP_LIST2_RESULTS  {

    uint32 NumGroupList2Records;                /* Number of PA Records returned */

    STL_PA_GROUP_LIST2 GroupList2Records[1];		/* list of PA records returned */

} STL_PA_GROUP_LIST2_RESULTS, *PSTL_PA_GROUP_LIST2_RESULTS;

typedef struct _STL_PA_VF_LIST2_RESULTS  {

    uint32 NumVFList2Records;                /* Number of PA Records returned */

    STL_PA_VF_LIST2 VFList2Records[1];		/* list of PA records returned */

} STL_PA_VF_LIST2_RESULTS, *PSTL_PA_VF_LIST2_RESULTS;

/* PortXmitData and PortRcvData are in units of flits (8 bytes) */

#define FLITS_PER_MiB ((uint64)1024*(uint64)1024/(uint64)8)

#define FLITS_PER_MB ((uint64)1000*(uint64)1000/(uint64)8)

#ifdef __cplusplus

}

#endif

#endif /* _STL_PA_PRIV_H_ */