/******************************************************************************
*
* Copyright (C) 2012 - 2014 Xilinx, Inc.  All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/****************************************************************************/
/**
*
* @file xaxipmon.c
*
* This file contains the driver API functions that can be used to access
* the AXI Performance Monitor device.
*
* Refer to the xaxipmon.h header file for more information about this driver.
*
* @note 	None.
*
* <pre>
*
* MODIFICATION HISTORY:
*
* Ver   Who    Date     Changes
* ----- -----  -------- -----------------------------------------------------
* 1.00a bss   02/27/12  First release
* 2.00a bss   06/23/12  Updated to support v2_00a version of IP.
* 3.00a bss   09/03/12  Deleted XAxiPmon_SetAgent, XAxiPmon_GetAgent APIs and
*			modified XAxiPmon_SetMetrics, XAxiPmon_GetMetrics APIs
*			to support v2_01a version of IP.
* 3.01a bss   10/25/12  Added XAxiPmon_StartCounters and XAxiPmon_StopCounters
*			APIs (CR #683799).
*			Added XAxiPmon_StartEventLog and XAxiPmon_StopEventLog
*			APIs (CR #683801).
*			Added XAxiPmon_GetMetricName API (CR #683803).
*			Modified XAxiPmon_SetMetrics and XAxiPmon_GetMetrics
*			(CR #683746)
*			Added XAxiPmon_EnableEventLog,
*			XAxiPmon_DisableMetricsCounter,
*			XAxiPmon_EnableMetricsCounter APIs to replace macros.
*			Added XAxiPmon_SetMetricCounterCutOff,
*			XAxiPmon_GetMetricCounterCutOff,
*			XAxiPmon_EnableExternalTrigger and
*			XAxiPmon_DisableExternalTrigger APIs to support new
*			version of IP.
* 4.00a bss   01/17/13  To support new version of IP:
* 			Added XAxiPmon_SetLogEnableRanges,
*	  		XAxiPmon_GetLogEnableRanges,
*			XAxiPmon_EnableMetricCounterTrigger,
*			XAxiPmon_DisableMetricCounterTrigger,
*			XAxiPmon_EnableEventLogTrigger,
*			XAxiPmon_DisableEventLogTrigger,
*			XAxiPmon_SetWriteLatencyId,
*			XAxiPmon_SetReadLatencyId,
*			XAxiPmon_GetWriteLatencyId,
*			XAxiPmon_GetReadLatencyId APIs and removed
*			XAxiPmon_SetMetricCounterCutOff,
*			XAxiPmon_GetMetricCounterCutOff,
*			XAxiPmon_EnableExternalTrigger and
*			XAxiPmon_DisableExternalTrigger APIs
* 5.00a bss   08/26/13  To support new version of IP:
*			Modified XAxiPmon_CfgInitialize to add Mode of APM and
*			ScaleFactor parameter.
*			Modified Assert functions depending on Mode.
*			Modified XAxiPmon_GetMetricCounter and
*			XAxiPmon_GetSampledMetricCounter to include
*			new Counters.
*			Modified XAxiPmon_SetSampleInterval and
*			XAxiPmon_GetSampleInterval to remove higher 32 bit
*			value of SampleInterval since Sample Interval Register
*			is only 32 bit.
*			Added XAxiPmon_SetWrLatencyStart,
*			XAxiPmon_SetWrLatencyEnd, XAxiPmon_SetRdLatencyStart
*			XAxiPmon_SetRdLatencyEnd, XAxiPmon_GetWrLatencyStart,
*			XAxiPmon_GetWrLatencyEnd, XAxiPmon_GetRdLatencyStart,
*			XAxiPmon_GetRdLatencyEnd, XAxiPmon_SetWriteIdMask,
*			XAxiPmon_SetReadIdMask,
*			XAxiPmon_GetWriteIdMask and
*			XAxiPmon_GetReadIdMask APIs.
*			Renamed:
*			XAxiPmon_SetWriteLatencyId to XAxiPmon_SetWriteId
*			XAxiPmon_SetReadLatencyId to XAxiPmon_SetReadId
*			XAxiPmon_GetWriteLatencyId to XAxiPmon_GetWriteId
*			XAxiPmon_SetReadLatencyId to XAxiPmon_GetReadId.
* 6.2   bss  04/21/14   Updated XAxiPmon_CfgInitialize to Reset counters
*			and FIFOs based on Modes(CR#782671). And if both
*			profile and trace modes are present set mode as
*			Advanced.
* </pre>
*
*****************************************************************************/

/***************************** Include Files ********************************/

#include "xaxipmon.h"

/************************** Constant Definitions *****************************/

/**************************** Type Definitions *******************************/

/***************** Macros (Inline Functions) Definitions *********************/

/************************** Function Prototypes ******************************/

/************************** Variable Definitions *****************************/

/*****************************************************************************/
/**
*
* This function initializes a specific XAxiPmon device/instance. This function
* must be called prior to using the AXI Performance Monitor device.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	ConfigPtr points to the XAxiPmon device configuration structure.
* @param	EffectiveAddr is the device base address in the virtual memory
*		address space. If the address translation is not used then the
*		physical address is passed.
*		Unexpected errors may occur if the address mapping is changed
*		after this function is invoked.
*
* @return
*		- XST_SUCCESS if successful.
*
* @note		The user needs to first call the XAxiPmon_LookupConfig() API
*		which returns the Configuration structure pointer which is
*		passed as a parameter to the XAxiPmon_CfgInitialize() API.
*
******************************************************************************/
int XAxiPmon_CfgInitialize(XAxiPmon *InstancePtr, XAxiPmon_Config *ConfigPtr,
			  			u32 EffectiveAddr)
{
	/*
	 * Assert the input arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(ConfigPtr != NULL);

	/*
	 * Set the values read from the device config and the base address.
	 */
	InstancePtr->Config.DeviceId = ConfigPtr->DeviceId;
	InstancePtr->Config.BaseAddress = EffectiveAddr;
	InstancePtr->Config.GlobalClkCounterWidth =
				ConfigPtr->GlobalClkCounterWidth;
	InstancePtr->Config.MetricSampleCounterWidth =
				ConfigPtr->MetricSampleCounterWidth;
	InstancePtr->Config.IsEventCount =
				ConfigPtr->IsEventCount;
	InstancePtr->Config.NumberofSlots =
				ConfigPtr->NumberofSlots;
	InstancePtr->Config.NumberofCounters =
				ConfigPtr->NumberofCounters;
	InstancePtr->Config.HaveSampledCounters =
				ConfigPtr->HaveSampledCounters;
	InstancePtr->Config.IsEventLog =
				ConfigPtr->IsEventLog;
	InstancePtr->Config.FifoDepth =
				ConfigPtr->FifoDepth;
	InstancePtr->Config.FifoWidth =
				ConfigPtr->FifoWidth;
	InstancePtr->Config.TidWidth =
				ConfigPtr->TidWidth;

	InstancePtr->Config.ScaleFactor = ConfigPtr->ScaleFactor;

	if ((ConfigPtr->ModeProfile == ConfigPtr->ModeTrace)
			|| ConfigPtr->ModeAdvanced == 1)
	{
		InstancePtr->Mode = XAPM_MODE_ADVANCED;
	} else if (ConfigPtr->ModeTrace == 1) {
		InstancePtr->Mode = XAPM_MODE_TRACE;
	} else {
		InstancePtr->Mode = XAPM_MODE_PROFILE;
	}

	/*
	 * Indicate the instance is now ready to use, initialized without error.
	 */
	InstancePtr->IsReady = XIL_COMPONENT_IS_READY;

	/*
	 * Reset the Counters and FIFO based on Modes.
	 */

	/* Advanced and Profile */
	if(InstancePtr->Mode == XAPM_MODE_ADVANCED ||
			InstancePtr->Mode == XAPM_MODE_PROFILE)
	{
		XAxiPmon_ResetMetricCounter(InstancePtr);
	}
	/* Advanced */
	if(InstancePtr->Mode == XAPM_MODE_ADVANCED)
	{
		XAxiPmon_ResetGlobalClkCounter(InstancePtr);
	}
	/* Advanced and Trace */
	if(InstancePtr->Mode == XAPM_MODE_ADVANCED ||
			InstancePtr->Mode == XAPM_MODE_TRACE)
	{
		XAxiPmon_ResetFifo(InstancePtr);
	}
	return XST_SUCCESS;
}

/*****************************************************************************/
/**
*
* This function resets all Metric Counters and Sampled Metric Counters of
* AXI Performance Monitor.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	XST_SUCCESS
*
*
* @note		None.
*
******************************************************************************/
int XAxiPmon_ResetMetricCounter(XAxiPmon *InstancePtr)
{

	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode != XAPM_MODE_TRACE);

	/*
	 * Write the reset value to the Control register to reset
	 * Metric counters
	 */
	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							 XAPM_CTL_OFFSET);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
					(RegValue | XAPM_CR_MCNTR_RESET_MASK));
	/*
	 * Release from Reset
	 */
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				(RegValue & ~(XAPM_CR_MCNTR_RESET_MASK)));
	return XST_SUCCESS;

}

/*****************************************************************************/
/**
*
* This function resets Global Clock Counter of AXI Performance Monitor
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None.
*
* @note		None.
*
******************************************************************************/
void XAxiPmon_ResetGlobalClkCounter(XAxiPmon *InstancePtr)
{

	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode == XAPM_MODE_ADVANCED);

	/*
	 * Write the reset value to the Control register to reset
	 * Global Clock Counter
	 */
	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							 XAPM_CTL_OFFSET);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
					(RegValue | XAPM_CR_GCC_RESET_MASK));

	/*
	 * Release from Reset
	 */
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				(RegValue & ~(XAPM_CR_GCC_RESET_MASK)));

}

/*****************************************************************************/
/**
*
* This function resets Streaming FIFO of AXI Performance Monitor
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	XST_SUCCESS
*
* @note		None.
*
******************************************************************************/
int XAxiPmon_ResetFifo(XAxiPmon *InstancePtr)
{

	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode != XAPM_MODE_PROFILE);

	/* Check Event Logging is enabled in Hardware */
	if((InstancePtr->Config.IsEventLog == 0) &&
			(InstancePtr->Mode == XAPM_MODE_ADVANCED))
	{
		/*Event logging not enabled in Hardware*/
		return XST_SUCCESS;
	}
	/*
	 * Write the reset value to the Control register to reset
	 * FIFO
	 */
	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							 XAPM_CTL_OFFSET);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
					(RegValue | XAPM_CR_FIFO_RESET_MASK));
	/*
	 * Release from Reset
	 */
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				(RegValue & ~(XAPM_CR_FIFO_RESET_MASK)));

	return XST_SUCCESS;

}

/****************************************************************************/
/**
*
* This function sets Ranges for Incrementers depending on parameters passed.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	IncrementerNum specifies the Incrementer for which Ranges
*		need to be set
* @param 	RangeUpper specifies the Upper limit in 32 bit Register
* @param 	RangeLower specifies the Lower limit in 32 bit Register
*
* @return	None.
*
* @note		None
*
*****************************************************************************/
void XAxiPmon_SetIncrementerRange(XAxiPmon *InstancePtr, u8 IncrementerNum,
					u16 RangeUpper,	u16 RangeLower)
 {

 	u32 RegValue;

 	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode == XAPM_MODE_ADVANCED);
	Xil_AssertVoid(IncrementerNum < XAPM_MAX_COUNTERS);

	/*
	 * Write to the specified Range register
	 */
 	RegValue = RangeUpper << 16;
 	RegValue |= RangeLower;
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
			(XAPM_RANGE0_OFFSET + (IncrementerNum * 16)),
			RegValue);
 }

/****************************************************************************/
/**
*
* This function returns the Ranges of Incrementers Registers.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	IncrementerNum specifies the Incrementer for which Ranges
*		need to be returned.
* @param 	RangeUpper specifies the user reference variable which returns
*		the Upper Range Value of the specified Incrementer.
* @param 	RangeLower specifies the user reference variable which returns
*		the Lower Range Value of the specified Incrementer.
*
* @return	None.
*
* @note		None
*
*****************************************************************************/
void XAxiPmon_GetIncrementerRange(XAxiPmon *InstancePtr, u8 IncrementerNum,
				u16 *RangeUpper, u16 *RangeLower)
 {

 	u32 RegValue;
 	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode == XAPM_MODE_ADVANCED);
	Xil_AssertVoid(IncrementerNum < XAPM_MAX_COUNTERS);

 	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
 				(XAPM_RANGE0_OFFSET + (IncrementerNum * 16)));

 	*RangeLower = RegValue & 0xFFFF;
 	*RangeUpper = (RegValue >> 16) & 0xFFFF;
 }

/****************************************************************************/
/**
*
* This function sets the Sample Interval Register
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	SampleInterval is the Sample Interval value to be set
*
* @return	None
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_SetSampleInterval(XAxiPmon *InstancePtr, u32 SampleInterval)
{

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode != XAPM_MODE_TRACE);

	/*
	 * Set Sample Interval Lower
	 */
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
		XAPM_SI_LOW_OFFSET, SampleInterval);

}

/****************************************************************************/
/**
*
* This function returns the contents of Sample Interval Register
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	SampleInterval is a pointer where the Sample Interval
*		Counter value is returned.
*
* @return 	None.
*
* @note		None.
*
******************************************************************************/
void XAxiPmon_GetSampleInterval(XAxiPmon *InstancePtr, u32 *SampleInterval)
{
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode != XAPM_MODE_TRACE);

	/*
	 * Set Sample Interval Lower
	 */
	*SampleInterval = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
				XAPM_SI_LOW_OFFSET);

}

/****************************************************************************/
/**
*
* This function sets Metrics for specified Counter in the corresponding
* Metric Selector Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Slot is the slot ID for which specified counter has to
*		be connected.
* @param	Metrics is one of the Metric Sets. User has to use
*		XAPM_METRIC_SET_* macros in xaxipmon.h for this parameter
* @param	CounterNum is the Counter Number.
*		The valid values are 0 to 9.
*
* @return	XST_SUCCESS if Success
*		XST_FAILURE if Failure
*
* @note		None.
*
*****************************************************************************/
int XAxiPmon_SetMetrics(XAxiPmon *InstancePtr, u8 Slot, u8 Metrics,
						u8 CounterNum)
{
	u32 RegValue;
	u32 Mask;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_ADVANCED);
	Xil_AssertNonvoid(Slot < XAPM_MAX_AGENTS);
	Xil_AssertNonvoid((Metrics <= XAPM_METRIC_SET_22) ||
			(Metrics == XAPM_METRIC_SET_30));
	Xil_AssertNonvoid(CounterNum < XAPM_MAX_COUNTERS);

	/* Find Mask value to force zero in counternum byte range */
	if (CounterNum == 0 || CounterNum == 4 || CounterNum == 8) {
	  	Mask = 0xFFFFFF00;
	}
	else if (CounterNum == 1 || CounterNum == 5 || CounterNum == 9) {
	  	Mask = 0xFFFF00FF;
	}
	else if (CounterNum == 2 || CounterNum == 6) {
	  	Mask = 0xFF00FFFF;
	}
	else {
	  	Mask = 0x00FFFFFF;
	}

	if(CounterNum <= 3) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
					    XAPM_MSR0_OFFSET);

		RegValue = RegValue & Mask;
		RegValue = RegValue | (Metrics << (CounterNum * 8));
		RegValue = RegValue | (Slot << (CounterNum * 8 + 5));
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
					XAPM_MSR0_OFFSET,RegValue);
	}
	else if((CounterNum >= 4) && (CounterNum <= 7)) {
		CounterNum = CounterNum - 4;
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
					    XAPM_MSR1_OFFSET);

		RegValue = RegValue & Mask;
		RegValue = RegValue | (Metrics << (CounterNum * 8));
		RegValue = RegValue | (Slot << (CounterNum * 8 + 5));
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
					XAPM_MSR1_OFFSET,RegValue);
	}
	else {
		CounterNum = CounterNum - 8;
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
					    XAPM_MSR2_OFFSET);

		RegValue = RegValue & Mask;
		RegValue = RegValue | (Metrics << (CounterNum * 8));
		RegValue = RegValue | (Slot << (CounterNum * 8 + 5));
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
					XAPM_MSR2_OFFSET,RegValue);
	}
	return XST_SUCCESS;
}

/*****************************************************************************/
/**
*
* This function returns Metrics in the specified Counter from the corresponding
* Metric Selector Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	CounterNum is the Counter Number.
*		The valid values are 0 to 9.
* @param	Metrics is a reference parameter from application where metrics
*		of specified counter is filled.
* @praram	Slot is a reference parameter in which slot Id of
*		specified counter is filled
* @return	XST_SUCCESS if Success
*		XST_FAILURE if Failure
*
* @note		None.
*
*****************************************************************************/
int XAxiPmon_GetMetrics(XAxiPmon *InstancePtr, u8 CounterNum, u8 *Metrics,
								u8 *Slot)
{
	u32 RegValue;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_ADVANCED);
	Xil_AssertNonvoid(CounterNum <= XAPM_MAX_COUNTERS);

	if(CounterNum <= 3) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
					XAPM_MSR0_OFFSET);
		*Metrics = (RegValue >> (CounterNum * 8)) & 0x1F;
		*Slot 	= (RegValue >> (CounterNum * 8 + 5)) & 0x7;

	}
	else if((CounterNum >= 4) && (CounterNum <= 7)) {
		CounterNum = CounterNum - 4;
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
					XAPM_MSR1_OFFSET);
		*Metrics = (RegValue >> (CounterNum * 8)) & 0x1F;
		*Slot 	= (RegValue >> (CounterNum * 8 + 5)) & 0x7;
	}
	else {
		CounterNum = CounterNum - 8;
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
					XAPM_MSR2_OFFSET);
		*Metrics = (RegValue >> (CounterNum * 8)) & 0x1F;
		*Slot 	= (RegValue >> (CounterNum * 8 + 5)) & 0x7;
	}
	return XST_SUCCESS;
}

/****************************************************************************/
/**
*
* This function returns the contents of the Global Clock Counter Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	CntHighValue is the user space pointer with which upper 32 bits
*		of Global Clock Counter has to be filled
* @param	CntLowValue is the user space pointer with which lower 32 bits
*		of Global Clock Counter has to be filled
*
* @return	None.
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_GetGlobalClkCounter(XAxiPmon *InstancePtr,u32 *CntHighValue,
							u32 *CntLowValue)
{
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode == XAPM_MODE_ADVANCED);

	*CntHighValue = 0x0;
	*CntLowValue  = 0x0;

	/*
	 * If Counter width is 64 bit then Counter Value has to be
	 * filled at CntHighValue address also.
	 */
	if(InstancePtr->Config.GlobalClkCounterWidth == 64) {

		/* Bits[63:32] exists at XAPM_GCC_HIGH_OFFSET */
		*CntHighValue = XAxiPmon_ReadReg(InstancePtr->
				Config.BaseAddress, XAPM_GCC_HIGH_OFFSET);
	}
	/* Bits[31:0] exists at XAPM_GCC_LOW_OFFSET */
	*CntLowValue = XAxiPmon_ReadReg(InstancePtr->
				Config.BaseAddress, XAPM_GCC_LOW_OFFSET);
}

/****************************************************************************/
/**
*
* This function returns the contents of the Metric Counter Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	CounterNum is the number of the Metric Counter to be read.
*		Use the XAPM_METRIC_COUNTER* defines for the counter number in
*		xaxipmon.h. The valid values are 0 (XAPM_METRIC_COUNTER_0) to
*		47(XAPM_METRIC_COUNTER_47).
* @return	RegValue is the content of specified Metric Counter.
*
* @note		None.
*
*****************************************************************************/
u32 XAxiPmon_GetMetricCounter(XAxiPmon *InstancePtr, u32 CounterNum)
{

	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode != XAPM_MODE_TRACE);
	Xil_AssertNonvoid(CounterNum < XAPM_MAX_COUNTERS_PROFILE);

	if (CounterNum < 10 ) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_MC0_OFFSET + (CounterNum * 16)));
	}
	else if (CounterNum >= 10 && CounterNum < 12) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_MC10_OFFSET + ((CounterNum - 10) * 16)));
	}
	else if (CounterNum >= 12 && CounterNum < 24) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_MC12_OFFSET + ((CounterNum - 12) * 16)));
	}
	else if (CounterNum >= 24 && CounterNum < 36) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_MC24_OFFSET + ((CounterNum - 24) * 16)));
	}
	else
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_MC36_OFFSET + ((CounterNum - 36) * 16)));

	return RegValue;
}

/****************************************************************************/
/**
*
* This function returns the contents of the Sampled Metric Counter Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	CounterNum is the number of the Sampled Metric Counter to read.
*		Use the XAPM_METRIC_COUNTER* defines for the counter number in
*		xaxipmon.h. The valid values are 0 (XAPM_METRIC_COUNTER_0) to
*		47(XAPM_METRIC_COUNTER_47).
*
* @return	RegValue is the content of specified Sampled Metric Counter.
*
* @note		None.
*
*****************************************************************************/
u32 XAxiPmon_GetSampledMetricCounter(XAxiPmon *InstancePtr, u32 CounterNum)
{
	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode != XAPM_MODE_TRACE);
	Xil_AssertNonvoid(CounterNum < XAPM_MAX_COUNTERS_PROFILE);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_PROFILE ||
		((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
			(InstancePtr->Config.HaveSampledCounters == 1)));

	if (CounterNum < 10 ) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_SMC0_OFFSET + (CounterNum * 16)));
	}
	else if (CounterNum >= 10 && CounterNum < 12) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_SMC10_OFFSET + ((CounterNum - 10) * 16)));
	}
	else if (CounterNum >= 12 && CounterNum < 24) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_SMC12_OFFSET + ((CounterNum - 12) * 16)));
	}
	else if (CounterNum >= 24 && CounterNum < 36) {
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_SMC24_OFFSET + ((CounterNum - 24) * 16)));
	}
	else
		RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_SMC36_OFFSET + ((CounterNum - 36) * 16)));

	return RegValue;
}

/****************************************************************************/
/**
*
* This function returns the contents of the Incrementer Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	IncrementerNum is the number of the Incrementer register to
*		read.Use the XAPM_INCREMENTER_* defines for the Incrementer
*		number.The valid values are 0 (XAPM_INCREMENTER_0) to
*		9 (XAPM_INCREMENTER_9).
* @param	IncrementerNum is the number of the specified Incrementer
*		register
* @return	RegValue is content of specified Metric Incrementer register.
*
* @note		None.
*
*****************************************************************************/
u32 XAxiPmon_GetIncrementer(XAxiPmon *InstancePtr, u32 IncrementerNum)
{
	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_ADVANCED &&
				InstancePtr->Config.IsEventCount == 1);
	Xil_AssertNonvoid(IncrementerNum < XAPM_MAX_COUNTERS);

	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
			(XAPM_INC0_OFFSET + (IncrementerNum * 16)));

	return RegValue;
}

/****************************************************************************/
/**
*
* This function returns the contents of the Sampled Incrementer Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	IncrementerNum is the number of the Sampled Incrementer
*		register to read.Use the XAPM_INCREMENTER_* defines for the
*		Incrementer number.The valid values are 0 (XAPM_INCREMENTER_0)
*		to 9 (XAPM_INCREMENTER_9).
* @param	IncrementerNum is the number of the specified Sampled
*		Incrementer register
* @return	RegValue is content of specified Sampled Incrementer register.
*
* @note		None.
*
*****************************************************************************/
u32 XAxiPmon_GetSampledIncrementer(XAxiPmon *InstancePtr, u32 IncrementerNum)
{
	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_ADVANCED &&
				InstancePtr->Config.IsEventCount == 1 &&
				InstancePtr->Config.HaveSampledCounters == 1);
	Xil_AssertNonvoid(IncrementerNum < XAPM_MAX_COUNTERS);

	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
				(XAPM_SINC0_OFFSET + (IncrementerNum * 16)));
	return RegValue;
}

/****************************************************************************/
/**
*
* This function sets Software-written Data Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	SwData is the Software written Data.
*
* @return	None.
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_SetSwDataReg(XAxiPmon *InstancePtr, u32 SwData)
{
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	/*
	 * Set Software-written Data Register
	 */
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_SWD_OFFSET,
								SwData);
}

/****************************************************************************/
/**
*
* This function returns contents of Software-written Data Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	SwData.
*
* @note		None.
*
*****************************************************************************/
u32 XAxiPmon_GetSwDataReg(XAxiPmon *InstancePtr)
{
	 u32 SwData;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	/*
	 * Set Metric Selector Register
	 */
	SwData = (u32)XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_SWD_OFFSET);
	return SwData;
}

/*****************************************************************************/
/**
*
* This function enables the following in the AXI Performance Monitor:
*   - Event logging
*
* @param        InstancePtr is a pointer to the XAxiPmon instance.
* @param        FlagEnables is a value to write to the flag enables
*               register defined by XAPM_FEC_OFFSET. It is recommended
*               to use the XAPM_FEC_*_MASK mask bits to generate.
*               A value of 0x0 will disable all events to the event
*               log streaming FIFO.
*
* @return       XST_SUCCESS
*
* @note         None
*
******************************************************************************/
int XAxiPmon_StartEventLog(XAxiPmon *InstancePtr, u32 FlagEnables)
{
	u32 RegValue;

  	/*
  	 * Assert the arguments.
  	 */
  	Xil_AssertNonvoid(InstancePtr != NULL);
  	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
  	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_TRACE ||
				((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
			(InstancePtr->Config.IsEventLog == 1)));

    	/* Read current register value */
	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
  							XAPM_CTL_OFFSET);
       	/* Flag Enable register is present only in Advanced Mode */
       	if(InstancePtr->Mode == XAPM_MODE_ADVANCED)
    	{
		/* Now write to flag enables register */
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
				XAPM_FEC_OFFSET, FlagEnables);
	}

	/* Write the new value to the Control register to
	 *	enable event logging */
  	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
  		                  RegValue | XAPM_CR_EVENTLOG_ENABLE_MASK);

  	return XST_SUCCESS;
}

/*****************************************************************************/
/**
*
* This function disables the following in the AXI Performance Monitor:
*   - Event logging
*
* @param        InstancePtr is a pointer to the XAxiPmon instance.
*
* @return       XST_SUCCESS
*
* @note         None
*
******************************************************************************/
int XAxiPmon_StopEventLog(XAxiPmon *InstancePtr)
{
	u32 RegValue;

  	/*
  	 * Assert the arguments.
  	 */
  	Xil_AssertNonvoid(InstancePtr != NULL);
  	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_TRACE ||
			((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
			(InstancePtr->Config.IsEventLog == 1)));

	/* Read current register value */
	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_CTL_OFFSET);

	/* Write the new value to the Control register to disable
	 * event logging */
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
	                    RegValue & ~XAPM_CR_EVENTLOG_ENABLE_MASK);

	return XST_SUCCESS;
}

/*****************************************************************************/
/**
*
* This function enables the following in the AXI Performance Monitor:
*   - Global clock counter
*   - All metric counters
*   - All sampled metric counters
*
* @param    InstancePtr is a pointer to the XAxiPmon instance.
*           SampleInterval is the sample interval for the sampled metric
*           counters
*
* @return   XST_SUCCESS
*
* @note	    None
******************************************************************************/
int XAxiPmon_StartCounters(XAxiPmon *InstancePtr, u32 SampleInterval)
{
	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
 	Xil_AssertNonvoid(InstancePtr != NULL);
  	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_PROFILE ||
				((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
				(InstancePtr->Config.IsEventCount == 1)));

  	/* Read current register value */
  	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
  							XAPM_CTL_OFFSET);
  	/* Globlal Clock Counter is present in Advanced mode only */
  	if(InstancePtr->Mode == XAPM_MODE_ADVANCED)
  	{
		RegValue = RegValue | XAPM_CR_GCC_ENABLE_MASK;
	}

  	/*
  	 * Write the new value to the Control register to enable
  	 * global clock counter and metric counters
  	 */
  	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
              RegValue | XAPM_CR_MCNTR_ENABLE_MASK);

  	/* Set, enable, and load sampled counters */
  	XAxiPmon_SetSampleInterval(InstancePtr, SampleInterval);
  	XAxiPmon_LoadSampleIntervalCounter(InstancePtr);
  	XAxiPmon_EnableSampleIntervalCounter(InstancePtr);

  	return XST_SUCCESS;
}

/*****************************************************************************/
/**
*
* This function disables the following in the AXI Performance Monitor:
*   - Global clock counter
*   - All metric counters
*
* @param        InstancePtr is a pointer to the XAxiPmon instance.
*
* @return       XST_SUCCESS
*
* @note         None
*
******************************************************************************/
int XAxiPmon_StopCounters(XAxiPmon *InstancePtr)
{
	u32 RegValue;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertNonvoid(InstancePtr->Mode == XAPM_MODE_PROFILE ||
				((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
				(InstancePtr->Config.IsEventCount == 1)));

	/* Read current register value */
	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	/* Globlal Clock Counter is present in Advanced mode only */
	if(InstancePtr->Mode == XAPM_MODE_ADVANCED)
	{
		RegValue = RegValue & ~XAPM_CR_GCC_ENABLE_MASK;
	}

	/*
  	 * Write the new value to the Control register to disable
  	 * global clock counter and metric counters
  	 */
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
	RegValue & ~XAPM_CR_MCNTR_ENABLE_MASK);

	return XST_SUCCESS;
}

/*****************************************************************************/
/**
*
* This function enables Metric Counters.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		None
*
*******************************************************************************/
void XAxiPmon_EnableMetricsCounter(XAxiPmon *InstancePtr)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode == XAPM_MODE_PROFILE ||
				((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
				(InstancePtr->Config.IsEventCount == 1)));

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_CTL_OFFSET);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
					RegVal | XAPM_CR_MCNTR_ENABLE_MASK);
}
/****************************************************************************/
/**
*
* This function disables the Metric Counters.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		None
*
*****************************************************************************/
void XAxiPmon_DisableMetricsCounter(XAxiPmon *InstancePtr)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode == XAPM_MODE_PROFILE ||
				((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
				(InstancePtr->Config.IsEventCount == 1)));

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);

	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
					RegVal & ~(XAPM_CR_MCNTR_ENABLE_MASK));
}

/****************************************************************************/
/**
*
* This function sets the Upper and Lower Ranges for specified Metric Counter
* Log Enable Register.Event Logging starts when corresponding Metric Counter
* value falls in between these ranges
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	CounterNum is the Metric Counter number for which
*		Ranges are to be assigned.Use the XAPM_METRIC_COUNTER*
*		defines for the counter number in xaxipmon.h.
*		The valid values are 0 (XAPM_METRIC_COUNTER_0) to
*		9 (XAPM_METRIC_COUNTER_9).
* @param 	RangeUpper specifies the Upper limit in 32 bit Register
* @param 	RangeLower specifies the Lower limit in 32 bit Register
* @return	None
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_SetLogEnableRanges(XAxiPmon *InstancePtr, u32 CounterNum,
					u16 RangeUpper, u16 RangeLower)
{
	u32 RegValue;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(CounterNum < XAPM_MAX_COUNTERS);
	Xil_AssertVoid((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
				(InstancePtr->Config.IsEventCount == 1));


	/*
	 * Write the specified Ranges to corresponding Metric Counter Log
	 * Enable Register
	 */
	RegValue = RangeUpper << 16;
	RegValue |= RangeLower;
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
		(XAPM_MC0LOGEN_OFFSET + (CounterNum * 16)), RegValue);

}

/****************************************************************************/
/**
*
* This function returns the Ranges of specified Metric Counter Log
* Enable Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	CounterNum is the Metric Counter number for which
*		Ranges are to be returned.Use the XAPM_METRIC_COUNTER*
*		defines for the counter number in xaxipmon.h.
*		The valid values are 0 (XAPM_METRIC_COUNTER_0) to
*		9 (XAPM_METRIC_COUNTER_9).
*
* @param 	RangeUpper specifies the user reference variable which returns
*		the Upper Range Value of the specified Metric Counter
*		Log Enable Register.
* @param 	RangeLower specifies the user reference variable which returns
*		the Lower Range Value of the specified Metric Counter
*		Log Enable Register.
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_GetLogEnableRanges(XAxiPmon *InstancePtr, u32 CounterNum,
					u16 *RangeUpper, u16 *RangeLower)
{
	u32 RegValue;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(CounterNum < XAPM_MAX_COUNTERS);
	Xil_AssertVoid((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
				(InstancePtr->Config.IsEventCount == 1));


	RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
	 			(XAPM_MC0LOGEN_OFFSET + (CounterNum * 16)));

	*RangeLower = RegValue & 0xFFFF;
 	*RangeUpper = (RegValue >> 16) & 0xFFFF;
}

/*****************************************************************************/
/**
*
* This function enables Event Logging.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		None
*
*******************************************************************************/
void XAxiPmon_EnableEventLog(XAxiPmon *InstancePtr)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode == XAPM_MODE_TRACE ||
				((InstancePtr->Mode == XAPM_MODE_ADVANCED) &&
				(InstancePtr->Config.IsEventLog == 1)));

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				RegVal | XAPM_CR_EVENTLOG_ENABLE_MASK);
}

/*****************************************************************************/
/**
*
* This function enables External trigger pulse so that Metric Counters can be
* started on external trigger pulse for a Slot.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		None
*
*******************************************************************************/
void XAxiPmon_EnableMetricCounterTrigger(XAxiPmon *InstancePtr)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode != XAPM_MODE_TRACE);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				RegVal | XAPM_CR_MCNTR_EXTTRIGGER_MASK);
}

/****************************************************************************/
/**
*
* This function disables the External trigger pulse used to start Metric
* Counters on external trigger pulse for a Slot.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		None
*
*****************************************************************************/
void XAxiPmon_DisableMetricCounterTrigger(XAxiPmon *InstancePtr)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode != XAPM_MODE_TRACE);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);

	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				RegVal & ~(XAPM_CR_MCNTR_EXTTRIGGER_MASK));
}

/*****************************************************************************/
/**
*
* This function enables External trigger pulse for Event Log
* so that Event Logging can be started on external trigger pulse for a Slot.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		None
*
*******************************************************************************/
void XAxiPmon_EnableEventLogTrigger(XAxiPmon *InstancePtr)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode != XAPM_MODE_PROFILE);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				RegVal | XAPM_CR_EVTLOG_EXTTRIGGER_MASK);
}

/****************************************************************************/
/**
*
* This function disables the External trigger pulse used to start Event
* Log on external trigger pulse for a Slot.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		None
*
*****************************************************************************/
void XAxiPmon_DisableEventLogTrigger(XAxiPmon *InstancePtr)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
	Xil_AssertVoid(InstancePtr->Mode != XAPM_MODE_PROFILE);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);

	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, XAPM_CTL_OFFSET,
				RegVal & ~(XAPM_CR_EVTLOG_EXTTRIGGER_MASK));
}

/****************************************************************************/
/**
*
* This function returns a name for a given Metric.
*
* @param        Metrics is one of the Metric Sets. User has to use
*               XAPM_METRIC_SET_* macros in xaxipmon.h for this parameter
*
* @return       const char *
*
* @note         None
*
*****************************************************************************/
const char * XAxiPmon_GetMetricName(u8 Metrics)
{
	if (Metrics == XAPM_METRIC_SET_0 ){
  		return "Write Transaction Count";
	}
	if (Metrics == XAPM_METRIC_SET_1 ){
			return "Read Transaction Count";
	}
	if (Metrics == XAPM_METRIC_SET_2 ){
			return "Write Byte Count";
	}
	if (Metrics == XAPM_METRIC_SET_3 ){
			return "Read Byte Count";
	}
	if (Metrics == XAPM_METRIC_SET_4 ){
			return "Write Beat Count";
	}
	if (Metrics == XAPM_METRIC_SET_5 ){
			return "Total Read Latency";
	}
	if (Metrics == XAPM_METRIC_SET_6 ){
			return "Total Write Latency";
	}
	if (Metrics == XAPM_METRIC_SET_7 ){
		return "Slv_Wr_Idle_Cnt";
	}
	if (Metrics == XAPM_METRIC_SET_8 ){
			return "Mst_Rd_Idle_Cnt";
	}
	if (Metrics == XAPM_METRIC_SET_9 ){
			return "Num_BValids";
	}
	if (Metrics == XAPM_METRIC_SET_10){
		return "Num_WLasts";
	}
	if (Metrics == XAPM_METRIC_SET_11){
			return "Num_RLasts";
	}
	if (Metrics == XAPM_METRIC_SET_12){
			return "Minimum Write Latency";
	}
	if (Metrics == XAPM_METRIC_SET_13){
			return "Maximum Write Latency";
	}
	if (Metrics == XAPM_METRIC_SET_14){
			return "Minimum Read Latency";
	}
	if (Metrics == XAPM_METRIC_SET_15){
			return "Maximum Read Latency";
	}
	if (Metrics == XAPM_METRIC_SET_16){
			return "Transfer Cycle Count";
	}
	if (Metrics == XAPM_METRIC_SET_17){
			return "Packet Count";
	}
	if (Metrics == XAPM_METRIC_SET_18){
			return "Data Byte Count";
	}
	if (Metrics == XAPM_METRIC_SET_19){
			return "Position Byte Count";
	}
	if (Metrics == XAPM_METRIC_SET_20){
			return "Null Byte Count";
	}
	if (Metrics == XAPM_METRIC_SET_21){
			return "Slv_Idle_Cnt";
	}
	if (Metrics == XAPM_METRIC_SET_22){
			return "Mst_Idle_Cnt";
	}
	if (Metrics == XAPM_METRIC_SET_30){
			return "External event count";
	}
	return "Unsupported";
}

/****************************************************************************/
/**
*
* This function sets Write ID in ID register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	WriteId is the Write ID to be written in ID register.
*
* @return	None.
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_SetWriteId(XAxiPmon *InstancePtr, u16 WriteId)
{
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_ID_OFFSET);
	RegVal = RegVal & ~(XAPM_ID_WID_MASK);
	RegVal = RegVal | WriteId;
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
				XAPM_ID_OFFSET, RegVal);
}

/****************************************************************************/
/**
*
* This function sets Read ID in ID register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	ReadId is the Read ID to be written in ID register.
*
* @return	None.
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_SetReadId(XAxiPmon *InstancePtr, u16 ReadId)
{
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_ID_OFFSET);
	RegVal = RegVal & ~(XAPM_ID_RID_MASK);
	RegVal = RegVal | (ReadId << 16);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
				XAPM_ID_OFFSET, RegVal);
}

/****************************************************************************/
/**
*
* This function returns Write ID in ID register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	WriteId is the required Write ID in ID register.
*
* @note		None.
*
*****************************************************************************/
u16 XAxiPmon_GetWriteId(XAxiPmon *InstancePtr)
{

	u16 WriteId;
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_ID_OFFSET);
	WriteId = RegVal & XAPM_ID_WID_MASK;

	return WriteId;
}

/****************************************************************************/
/**
*
* This function returns Read ID in ID register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	ReadId is the required Read ID in ID register.
*
* @note		None.
*
*****************************************************************************/
u16 XAxiPmon_GetReadId(XAxiPmon *InstancePtr)
{

	u16 ReadId;
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_ID_OFFSET);
	RegVal = RegVal & XAPM_ID_RID_MASK;
	ReadId = RegVal >> 16;

	return ReadId;
}

/*****************************************************************************/
/**
*
* This function sets Latency Start point to calculate write latency.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Param is XAPM_LATENCY_ADDR_ISSUE or XAPM_LATENCY_ADDR_ACCEPT
*		in xaxipmon.h.
* @return	None
*
* @note		Param can be 0 - XAPM_LATENCY_ADDR_ISSUE
*		or 1 - XAPM_LATENCY_ADDR_ACCEPT
*
*******************************************************************************/
void XAxiPmon_SetWrLatencyStart(XAxiPmon *InstancePtr, u8 Param)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	if (Param == XAPM_LATENCY_ADDR_ACCEPT) {
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
		  XAPM_CTL_OFFSET, RegVal | XAPM_CR_WRLATENCY_START_MASK);
	}
	else {
		XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET,
			XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET) & ~(XAPM_CR_WRLATENCY_START_MASK));
	}
}

/*****************************************************************************/
/**
*
* This function sets Latency End point to calculate write latency.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Param is XAPM_LATENCY_LASTWR or XAPM_LATENCY_FIRSTWR
* 		in xaxipmon.h.
*
* @return	None
*
* @note		Param can be 0 - XAPM_LATENCY_LASTWR
*		or 1 - XAPM_LATENCY_FIRSTWR
*
*******************************************************************************/
void XAxiPmon_SetWrLatencyEnd(XAxiPmon *InstancePtr, u8 Param)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	if (Param == XAPM_LATENCY_FIRSTWR) {
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
		  XAPM_CTL_OFFSET, RegVal | XAPM_CR_WRLATENCY_END_MASK);
	}
	else {
		XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET,
			XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET) & ~(XAPM_CR_WRLATENCY_END_MASK));
	}
}

/*****************************************************************************/
/**
*
* This function sets Latency Start point to calculate read latency.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Param is XAPM_LATENCY_ADDR_ISSUE or XAPM_LATENCY_ADDR_ACCEPT
*		in xaxipmon.h.
*
* @return	None
*
* @note		Param can be 0 - XAPM_LATENCY_ADDR_ISSUE
*		or 1 - XAPM_LATENCY_ADDR_ACCEPT
*
*******************************************************************************/
void XAxiPmon_SetRdLatencyStart(XAxiPmon *InstancePtr, u8 Param)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	if (Param == XAPM_LATENCY_ADDR_ACCEPT) {
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
		  XAPM_CTL_OFFSET, RegVal | XAPM_CR_RDLATENCY_START_MASK);
	}
	else {
		XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET,
			XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET) & ~(XAPM_CR_RDLATENCY_START_MASK));
	}
}

/*****************************************************************************/
/**
*
* This function sets Latency End point to calculate read latency.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Param is XAPM_LATENCY_LASTRD or XAPM_LATENCY_FIRSTRD
* 		in xaxipmon.h.
*
* @return	None
*
* @note		Param can be 0 - XAPM_LATENCY_LASTRD
*		or 1 - XAPM_LATENCY_FIRSTRD
*
*******************************************************************************/
void XAxiPmon_SetRdLatencyEnd(XAxiPmon *InstancePtr, u8 Param)
{
	u32 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	if (Param == XAPM_LATENCY_FIRSTRD) {
		XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
		  XAPM_CTL_OFFSET, RegVal | XAPM_CR_RDLATENCY_END_MASK);
	}
	else {
		XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET,
			XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress,
			XAPM_CTL_OFFSET) & ~(XAPM_CR_RDLATENCY_END_MASK));
	}
}

/*****************************************************************************/
/**
*
* This function returns Write Latency Start point.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	Returns 0 - XAPM_LATENCY_ADDR_ISSUE or
*			1 - XAPM_LATENCY_ADDR_ACCEPT
*
* @note		None
*
*******************************************************************************/
u8 XAxiPmon_GetWrLatencyStart(XAxiPmon *InstancePtr)
{
	u8 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	RegVal = RegVal & XAPM_CR_WRLATENCY_START_MASK;
	if (RegVal != XAPM_LATENCY_ADDR_ISSUE) {
		return XAPM_LATENCY_ADDR_ACCEPT;
	}
	else {
		return XAPM_LATENCY_ADDR_ISSUE;
	}
}

/*****************************************************************************/
/**
*
* This function returns Write Latency End point.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	Returns 0 - XAPM_LATENCY_LASTWR or
*			1 - XAPM_LATENCY_FIRSTWR.
*
* @note		None
*
*******************************************************************************/
u8 XAxiPmon_GetWrLatencyEnd(XAxiPmon *InstancePtr)
{
	u8 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	RegVal = RegVal & XAPM_CR_WRLATENCY_END_MASK;
	if (RegVal != XAPM_LATENCY_LASTWR) {
		return XAPM_LATENCY_FIRSTWR;
	}
	else {
		return XAPM_LATENCY_LASTWR;
	}
}

/*****************************************************************************/
/**
*
* This function returns read Latency Start point.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	Returns 0 - XAPM_LATENCY_ADDR_ISSUE or
*			1 - XAPM_LATENCY_ADDR_ACCEPT
*
* @note		None
*
*******************************************************************************/
u8 XAxiPmon_GetRdLatencyStart(XAxiPmon *InstancePtr)
{
	u8 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	RegVal = RegVal & XAPM_CR_RDLATENCY_START_MASK;

	if (RegVal != XAPM_LATENCY_ADDR_ISSUE) {
		return	XAPM_LATENCY_ADDR_ACCEPT;
	}
	else {
		return XAPM_LATENCY_ADDR_ISSUE;
	}
}

/*****************************************************************************/
/**
*
* This function returns Read Latency End point.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	Returns 0 - XAPM_LATENCY_LASTRD or
*			1 - XAPM_LATENCY_FIRSTRD.
*
* @note		None
*
*******************************************************************************/
u8 XAxiPmon_GetRdLatencyEnd(XAxiPmon *InstancePtr)
{
	u8 RegVal;

	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
							XAPM_CTL_OFFSET);
	RegVal = RegVal & XAPM_CR_RDLATENCY_END_MASK;
	if (RegVal != XAPM_LATENCY_LASTRD) {
		return XAPM_LATENCY_FIRSTRD;
	}
	else {
		return XAPM_LATENCY_LASTRD;
	}

}

/****************************************************************************/
/**
*
* This function sets Write ID Mask in ID Mask register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	WrMask is the Write ID mask to be written in ID register.
*
* @return	None.
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_SetWriteIdMask(XAxiPmon *InstancePtr, u16 WrMask)
{
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_IDMASK_OFFSET);
	RegVal = RegVal & ~(XAPM_MASKID_WID_MASK);
	RegVal = RegVal | WrMask;
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
				XAPM_IDMASK_OFFSET, RegVal);
}

/****************************************************************************/
/**
*
* This function sets Read ID Mask in ID Mask register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	RdMask is the Read ID mask to be written in ID Mask register.
*
* @return	None.
*
* @note		None.
*
*****************************************************************************/
void XAxiPmon_SetReadIdMask(XAxiPmon *InstancePtr, u16 RdMask)
{
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertVoid(InstancePtr != NULL);
	Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_IDMASK_OFFSET);
	RegVal = RegVal & ~(XAPM_MASKID_RID_MASK);
	RegVal = RegVal | (RdMask << 16);
	XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress,
				XAPM_IDMASK_OFFSET, RegVal);
}

/****************************************************************************/
/**
*
* This function returns Write ID Mask in ID Mask register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	WrMask is the required Write ID Mask in ID Mask register.
*
* @note		None.
*
*****************************************************************************/
u16 XAxiPmon_GetWriteIdMask(XAxiPmon *InstancePtr)
{

	u16 WrMask;
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_IDMASK_OFFSET);
	WrMask = RegVal & XAPM_MASKID_WID_MASK;

	return WrMask;
}

/****************************************************************************/
/**
*
* This function returns Read ID Mask in ID Mask register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	RdMask is the required Read ID Mask in ID Mask register.
*
* @note		None.
*
*****************************************************************************/
u16 XAxiPmon_GetReadIdMask(XAxiPmon *InstancePtr)
{

	u16 RdMask;
	u32 RegVal;
	/*
	 * Assert the arguments.
	 */
	Xil_AssertNonvoid(InstancePtr != NULL);
	Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);

	RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress,
						XAPM_IDMASK_OFFSET);
	RegVal = RegVal & XAPM_MASKID_RID_MASK;
	RdMask = RegVal >> 16;

	return RdMask;
}