/******************************************************************************
* Copyright (C) 2007 - 2020 Xilinx, Inc.  All rights reserved.
* Copyright (C) 2023 - 2024 Advanced Micro Devices, Inc. All Rights Reserved.
* SPDX-License-Identifier: MIT
******************************************************************************/

/****************************************************************************/
/**
*
* @file xaxipmon.h
* @addtogroup axipmon Overview
* @{
* @details
*
* The XAxiPmon driver supports the Xilinx AXI Performance Monitor device.
*
* The AXI Performance Monitor device provides following features:
*
*	Configurable number of Metric Counters and Incrementers
* 	Computes performance metrics for Agents connected to
*	monitor slots (Up to 8 slots)
*
* The following Metrics can be computed:
*
* Metrics computed for an AXI4 MM agent:
*	Write Request Count: Total number of write requests by/to the agent.
*	Read Request Count: Total number of read requests given by/to the
*			    agent.
*	Read Latency: It is defined as the time from the start of read address
*       	      transaction to the beginning of the read data service.
*	Write Latency: It is defined as the period needed a master completes
*        	       write data transaction, i.e. from write address
*        	       transaction to write response from slave.
*	Write Byte Count: Total number of bytes written by/to the agent.
*        		  This metric is helpful when calculating the
*        		  throughput of the system.
*	Read Byte Count: Total number of bytes read from/by the agent.
*	Average Write Latency: Average write latency seen by the agent.
*        		       It can be derived from total write latency
*        		       and the write request count.
*	Average Read Latency: Average read latency seen by the agent. It can be
*        		      derived from total read latency and the read
*        		      request count.
*	Master Write Idle Cycle Count: Number of idle cycles caused by the
*        			       masters during write transactions to
*        			       the slave.
*	Slave Write Idle Cycle Count: Number of idle cycles caused by this slave
*        			      during write transactions to the slave.
*	Master Read Idle Cycle Count: Number of idle cycles caused by the
*        			      master during read transactions to the
*        			      slave.
*	Slave Read Idle Cycle Count: Number of idle cycles caused by this slave
*        			     during read transactions to the slave.
*
* Metrics computed for an AXI4-Stream agent:
*
*	Transfer Cycle Count: Total number of writes by/to the agent.
*	Data Byte Count: Total number of data bytes written by/to the agent.
*			 This metric helps in calculating the throughput
*			 of the system.
*	Position Byte Count: Total number of position bytes transferred.
*	Null Byte Count: Total number of null bytes transferred.
*	Packet Count: Total number of packets transferred.
*
* There are three modes : Advanced, Profile and Trace.
* - Advanced mode has 10 Mertic Counters, Sampled Metric Counters, Incrementors
*   and Sampled Incrementors.
* - Profile mode has only 47 Metric Counters and Sampled Metric Counters.
* - Trace mode has no Counters.
* User should refer to the hardware device specification for detailed
* information about the device.
*
* This header file contains the prototypes of driver functions that can
* be used to access the AXI Performance Monitor device.
*
*
* <b> Initialization and Configuration </b>
*
* The device driver enables higher layer software (e.g., an application) to
* communicate to the AXI Performance Monitor device.
*
* XAxiPmon_CfgInitialize() API is used to initialize the AXI Performance Monitor
* device. 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.
*
*
* <b>Interrupts</b>
*
* The AXI Performance Monitor does not support Interrupts
*
*
* <b> Virtual Memory </b>
*
* This driver supports Virtual Memory. The RTOS is responsible for calculating
* the correct device base address in Virtual Memory space.
*
*
* <b> Threads </b>
*
* This driver is not thread safe. Any needs for threads or thread mutual
* exclusion must be satisfied by the layer above this driver.
*
* <b> Asserts </b>
*
* Asserts are used within all Xilinx drivers to enforce constraints on argument
* values. Asserts can be turned off on a system-wide basis by defining, at
* compile time, the NDEBUG identifier. By default, asserts are turned on and it
* is recommended that users leave asserts on during development.
*
*
* <b> Building the driver </b>
*
* The XAxiPmon driver is composed of several source files. This allows the user
* to build and link only those parts of the driver that are necessary.
*
* <b> Limitations of the driver </b>
*
*
* <br><br>
*
* <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 To support v2_01_a version of IP:
*			Deleted XAxiPmon_SetAgent, XAxiPmon_GetAgent APIs and
*			added XAPM_FLAG_EVENT, XAPM_FLAG_EVNTSTAR,
*			XAPM_FLAG_EVNTSTOP.
*			Deleted XAxiPmon_SetAgent, XAxiPmon_GetAgent APIs and
*			modified XAxiPmon_SetMetrics, XAxiPmon_GetMetrics APIs
*			in xaxipmon.c
*			Deleted XAPM_AGENT_OFFSET Macro in xaxipmon_hw.h
* 3.01a bss    10/25/12 To support new version of IP:
*			Added XAPM_MCXLOGEN_OFFSET macros in xaxipmon_hw.h.
*			Added XAxiPmon_SetMetricCounterCutOff,
*			XAxiPmon_GetMetricCounterCutOff,
*			XAxiPmon_EnableExternalTrigger and
*			XAxiPmon_DisableExternalTrigger APIs in xaxipmon.c
*			Modified XAxiPmon_SetMetrics and XAxiPmon_GetMetrics
*			(CR #683746) in xaxipmon.c
*			Added XAxiPmon_EnableEventLog,
*			XAxiPmon_DisableMetricsCounter,
*			XAxiPmon_EnableMetricsCounter APIs in xaxipmon.c to
*			replace macros in this file.
*			Added XAPM_FLAG_XXX macros.
*			Added XAxiPmon_StartCounters and XAxiPmon_StopCounters
*			APIs (CR #683799).
*			Added XAxiPmon_StartEventLog and XAxiPmon_StopEventLog
*			APIs (CR #683801).
*			Added XAxiPmon_GetMetricName API (CR #683803).
*			Deleted XAxiPmon_SetAgent, XAxiPmon_GetAgent
*			declarations (CR #677337)
* 4.00a bss    01/17/13 To support new version of IP:
*			Added XAPM_METRIC_SET_12 to XAPM_METRIC_SET_15 macros.
*			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 in xaxipmon.c
*			Added XAPM_LATENCYID_OFFSET,
*			XAPM_CR_EVTLOG_EXTTRIGGER_MASK,
*			XAPM_LATENCYID_RID_MASK and XAPM_LATENCYID_WID_MASK in
*			xaxipmon_hw.h
* 5.00a bss   08/26/13  To support new version of IP:
*			XAxiPmon_SampleMetrics Macro.
*			Modified XAxiPmon_CfgInitialize, Assert functions
*			Added XAxiPmon_GetMetricCounter,
*			XAxiPmon_SetSampleInterval, XAxiPmon_GetSampleInterval,
*			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 and XAxiPmon_SetReadLatencyId to
*			XAxiPmon_GetReadId. in xaxipmon.c
*			Added Macros XAPM_MC10_OFFSET to XAPM_MC47_OFFSET,
*			XAPM_SMC10_OFFSET to XAPM_SMC47_OFFSET,
*			XAPM_IDMASK_OFFSET, XAPM_CR_IDFILTER_ENABLE_MASK,
*			XAPM_CR_WRLATENCY_START_MASK,
*			XAPM_CR_WRLATENCY_END_MASK,
*			XAPM_CR_RDLATENCY_START_MASK,
*			XAPM_CR_RDLATENCY_END_MASK and
*			XAPM_MAX_COUNTERS_PROFILE.
*			Renamed:
*			XAPM_LATENCYID_OFFSET to XAPM_ID_OFFSET,
*			XAPM_LATENCYID_RID_MASK to XAPM_ID_RID_MASK,
*			XAPM_LATENCYID_WID_MASK to XAPM_ID_WID_MASK.
*			in xaxipmon_hw.h.
*			Modified driver tcl to generate new parameters
*			ScaleFactor, ModeProfile, ModeTrace and ModeAdvanced
*			in Config structure.
* 6.0   adk  19/12/13 Updated as per the New Tcl API's
* 6.1   adk  16/04/14 Updated the driver tcl for the newly added parameters in
* 		      The Axi pmon IP.
* 6.2   bss  04/21/14   Updated XAxiPmon_CfgInitialize in xaxipmon.c to Reset
*			counters and FIFOs based on Modes(CR#782671). And if
*			both profile and trace modes are present set mode as
*			Advanced.
* 6.2	bss  03/02/15	To support Zynq MP APM:
*						Added Is32BitFiltering in XAxiPmon_Config structure.
*						Updated XAxiPmon_SetWriteId, XAxiPmon_SetReadId,
*						XAxiPmon_GetWriteId, XAxiPmon_GetReadId
*						XAxiPmon_SetWriteIdMask, XAxiPmon_SetReadIdMask
*						XAxiPmon_GetWriteIdMask, XAxiPmon_GetReadIdMask
*						functions in xaxipmon.c.
*						Added XAPM_RID_OFFSET and XAPM_RIDMASK_OFFSET in
*						xaxipmon_hw.h
*
* 6.3	kvn  07/02/15	Modified code according to MISRA-C:2012 guidelines.
* 6.4   sk   11/10/15 Used UINTPTR instead of u32 for Baseaddress CR# 867425.
*                     Changed the prototype of XAxiPmon_CfgInitialize API.
* 6.5   ms   01/23/17 Modified xil_printf statement in main function for all
*                     examples to ensure that "Successfully ran" and "Failed"
*                     strings are available in all examples. This is a fix
*                     for CR-965028.
*       ms   03/17/17 Added readme.txt file in examples folder for doxygen
*                     generation.
* 6.6   ms   04/18/17 Modified tcl file to add suffix U for all macro
*                     definitions of axipmon in xparameters.h
* 6.10  ht   06/23/23 Added support for system device-tree flow.
* 6.12  ht   12/01/24 Fix GCC warnings.
* </pre>
*
*****************************************************************************/
#ifndef XAXIPMON_H /* Prevent circular inclusions */
#define XAXIPMON_H /* by using protection macros  */

#ifdef __cplusplus
extern "C" {
#endif

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

#include "xil_types.h"
#include "xil_assert.h"
#include "xstatus.h"
#include "xaxipmon_hw.h"

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


/**
 * @name Macro for Maximum number of Counters
 *
 * @{
 */
#define XAPM_MAX_COUNTERS		10U /**< Maximum number of Counters */
#define XAPM_MAX_COUNTERS_PROFILE	48U /**< Maximum number of Counters */

/*@}*/


/**
 * @name Indices for Metric Counters and Sampled Metric Coounters used with
 * 	 XAxiPmon_GetMetricCounter and XAxiPmon_GetSampledMetricCounter APIs
 * @{
 */

#define XAPM_METRIC_COUNTER_0	0U /**< Metric Counter 0 Register Index */
#define XAPM_METRIC_COUNTER_1	1U /**< Metric Counter 1 Register Index */
#define XAPM_METRIC_COUNTER_2	2U /**< Metric Counter 2 Register Index */
#define XAPM_METRIC_COUNTER_3	3U /**< Metric Counter 3 Register Index */
#define XAPM_METRIC_COUNTER_4	4U /**< Metric Counter 4 Register Index */
#define XAPM_METRIC_COUNTER_5	5U /**< Metric Counter 5 Register Index */
#define XAPM_METRIC_COUNTER_6	6U /**< Metric Counter 6 Register Index */
#define XAPM_METRIC_COUNTER_7	7U /**< Metric Counter 7 Register Index */
#define XAPM_METRIC_COUNTER_8	8U /**< Metric Counter 8 Register Index */
#define XAPM_METRIC_COUNTER_9	9U /**< Metric Counter 9 Register Index */

/*@}*/

/**
 * @name Indices for Incrementers and Sampled Incrementers used with
 * 	 XAxiPmon_GetIncrementer and XAxiPmon_GetSampledIncrementer APIs
 * @{
 */

#define XAPM_INCREMENTER_0	0U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_1	1U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_2	2U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_3	3U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_4	4U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_5	5U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_6	6U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_7	7U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_8	8U /**< Metric Counter 0 Register Index */
#define XAPM_INCREMENTER_9	9U /**< Metric Counter 0 Register Index */

/*@}*/

/**
 * @name Macros for Metric Selector Settings
 * @{
 */

#define XAPM_METRIC_SET_0		0U /**< Write Transaction Count */
#define XAPM_METRIC_SET_1		1U /**< Read Transaction Count */
#define XAPM_METRIC_SET_2		2U /**< Write Byte Count */
#define XAPM_METRIC_SET_3		3U /**< Read Byte Count */
#define XAPM_METRIC_SET_4		4U /**< Write Beat Count */
#define XAPM_METRIC_SET_5		5U /**< Total Read Latency */
#define XAPM_METRIC_SET_6		6U /**< Total Write Latency */
#define XAPM_METRIC_SET_7		7U /**< Slv_Wr_Idle_Cnt */
#define XAPM_METRIC_SET_8		8U /**< Mst_Rd_Idle_Cnt */
#define XAPM_METRIC_SET_9		9U /**< Num_BValids */
#define XAPM_METRIC_SET_10		10U /**< Num_WLasts */
#define XAPM_METRIC_SET_11		11U /**< Num_RLasts */
#define XAPM_METRIC_SET_12		12U /**< Minimum Write Latency */
#define XAPM_METRIC_SET_13		13U /**< Maximum Write Latency */
#define XAPM_METRIC_SET_14		14U /**< Minimum Read Latency */
#define XAPM_METRIC_SET_15		15U /**< Maximum Read Latency */
#define XAPM_METRIC_SET_16		16U /**< Transfer Cycle Count */
#define XAPM_METRIC_SET_17		17U /**< Packet Count */
#define XAPM_METRIC_SET_18		18U /**< Data Byte Count */
#define XAPM_METRIC_SET_19		19U /**< Position Byte Count */
#define XAPM_METRIC_SET_20		20U /**< Null Byte Count */
#define XAPM_METRIC_SET_21		21U /**< Slv_Idle_Cnt */
#define XAPM_METRIC_SET_22		22U /**< Mst_Idle_Cnt */
#define XAPM_METRIC_SET_30		30U /**< External event count */


/*@}*/


/**
 * @name Macros for Maximum number of Agents
 * @{
 */

#define XAPM_MAX_AGENTS 	8U /**< Maximum number of Agents */

/*@}*/

/**
 * @name Macros for Flags in Flag Enable Control Register
 * @{
 */

#define XAPM_FLAG_WRADDR	0x00000001 /**< Write Address Flag */
#define XAPM_FLAG_FIRSTWR	0x00000002 /**< First Write Flag */
#define XAPM_FLAG_LASTWR	0x00000004 /**< Last Write Flag */
#define XAPM_FLAG_RESPONSE	0x00000008 /**< Response Flag */
#define XAPM_FLAG_RDADDR	0x00000010 /**< Read Address Flag */
#define XAPM_FLAG_FIRSTRD	0x00000020 /**< First Read Flag */
#define XAPM_FLAG_LASTRD	0x00000040 /**< Last Read Flag */
#define XAPM_FLAG_SWDATA	0x00010000 /**< Software-written Data Flag */
#define XAPM_FLAG_EVENT		0x00020000 /**< Last Read Flag */
#define XAPM_FLAG_EVNTSTOP	0x00040000 /**< Last Read Flag */
#define XAPM_FLAG_EVNTSTART	0x00080000 /**< Last Read Flag */
#define XAPM_FLAG_GCCOVF	0x00100000 /**< Global Clock Counter Overflow
					     *  Flag */
#define XAPM_FLAG_SCLAPSE	0x00200000 /**< Sample Counter Lapse Flag */
#define XAPM_FLAG_MC0		0x00400000U /**< Metric Counter 0 Flag */
#define XAPM_FLAG_MC1		0x00800000U /**< Metric Counter 1 Flag */
#define XAPM_FLAG_MC2		0x01000000U /**< Metric Counter 2 Flag */
#define XAPM_FLAG_MC3		0x02000000U /**< Metric Counter 3 Flag */
#define XAPM_FLAG_MC4		0x04000000U /**< Metric Counter 4 Flag */
#define XAPM_FLAG_MC5		0x08000000U /**< Metric Counter 5 Flag */
#define XAPM_FLAG_MC6		0x10000000U /**< Metric Counter 6 Flag */
#define XAPM_FLAG_MC7		0x20000000U /**< Metric Counter 7 Flag */
#define XAPM_FLAG_MC8		0x40000000U /**< Metric Counter 8 Flag */
#define XAPM_FLAG_MC9		0x80000000U /**< Metric Counter 9 Flag */

/*@}*/

/**
 * @name Macros for Read/Write Latency Start and End points
 * @{
 */
#define XAPM_LATENCY_ADDR_ISSUE		0U /**< Address Issue as start
					point for Latency calculation*/
#define XAPM_LATENCY_ADDR_ACCEPT	1U /**< Address Acceptance as start
					point for Latency calculation*/
#define XAPM_LATENCY_LASTRD		0U /**< Last Read as end point for
					Latency calculation */
#define XAPM_LATENCY_LASTWR		0U /**< Last Write as end point for
					Latency calculation */
#define XAPM_LATENCY_FIRSTRD		1U /**< First Read as end point for
					Latency calculation */
#define XAPM_LATENCY_FIRSTWR		1U /**< First Write as end point for
					Latency calculation */

/*@}*/

/**
 * @name Macros for Modes of APM
 * @{
 */

#define XAPM_MODE_TRACE			2U /**< APM in Trace mode */

#define XAPM_MODE_PROFILE		1U /**< APM in Profile mode */

#define XAPM_MODE_ADVANCED		0U /**< APM in Advanced mode */

/*@}*/

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

/**
 * This typedef contains configuration information for the AXI Performance
 * Monitor device.
 */
typedef struct {
#ifndef SDT
	u16 DeviceId;			/**< Unique ID of device */
#else
	char *Name;
#endif
	UINTPTR BaseAddress;		/**< Device base address */
	s32 GlobalClkCounterWidth;	/**< Global Clock Counter Width */
	s32 MetricSampleCounterWidth ;	/**< Metric Sample Counters Width */
	u8  IsEventCount;		/**< Event Count Enabled 1 - enabled
							   0 - not enabled */
	u8  NumberofSlots;		/**< Number of Monitor Slots */
	u8  NumberofCounters;		/**< Number of Counters */
	u8  HaveSampledCounters;	/**< Have Sampled Counters 1 - present
							    0 - Not present */
	u8 IsEventLog;			/**< Event Logging Enabled 1 - enabled
							    0 - Not enabled */
	u32 FifoDepth;			/**< Event Log FIFO Depth */
	u32 FifoWidth;			/**< Event Log FIFO Width */
	u32 TidWidth; 			/**< Streaming Interface TID Width */
	u8  ScaleFactor;		/**< Event Count Scaling factor */
	u8  ModeAdvanced;		/**< Advanced Mode */
	u8  ModeProfile;		/**< Profile Mode */
	u8  ModeTrace;			/**< Trace Mode */
	u8  Is32BitFiltering;   /**< 32 bit filtering enabled */
#ifdef SDT
	u32 IntId; /**< Interrupt ID on GIC **/
	UINTPTR IntrParent;	/** Bit[0] Interrupt parent type Bit[64/32:1]
				 * Parent base address */
#endif
} XAxiPmon_Config;


/**
 * The driver's instance data. The user is required to allocate a variable
 * of this type for every AXI Performance Monitor device in system. A pointer
 * to a variable of this type is then passed to the driver API functions.
 */
typedef struct {
	XAxiPmon_Config Config;	/**< XAxiPmon_Config of current device */
	u32  IsReady;		/**< Device is initialized and ready  */
	u8   Mode;		/**< APM Mode */
} XAxiPmon;

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


/****************************************************************************/
/**
*
* This routine enables the Global Interrupt.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None.
*
* @note		C-Style signature:
*		void XAxiPmon_IntrGlobalEnable(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_IntrGlobalEnable(InstancePtr)			\
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, 	\
			  XAPM_GIE_OFFSET, 1)


/****************************************************************************/
/**
*
* This routine disables the Global Interrupt.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None.
*
* @note		C-Style signature:
*		void XAxiPmon_IntrGlobalDisable(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_IntrGlobalDisable(InstancePtr)				\
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, 		\
			  XAPM_GIE_OFFSET, 0)


/****************************************************************************/
/**
*
* This routine enables interrupt(s). Use the XAPM_IXR_* constants defined in
* xaxipmon_hw.h to create the bit-mask to enable interrupts.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Mask is the mask to enable. Bit positions of 1 will be enabled.
*		Bit positions of 0 will keep the previous setting. This mask is
*		formed by OR'ing XAPM_IXR__* bits defined in xaxipmon_hw.h.
*
* @return	None.
*
* @note		C-Style signature:
*		void XAxiPmon_IntrEnable(XAxiPmon *InstancePtr, u32 Mask)
*
*****************************************************************************/
#define XAxiPmon_IntrEnable(InstancePtr, Mask)				     \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_IE_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_IE_OFFSET) | (Mask));


/****************************************************************************/
/**
*
* This routine disable interrupt(s). Use the XAPM_IXR_* constants defined in
* xaxipmon_hw.h to create the bit-mask to disable interrupts.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Mask is the mask to disable. Bit positions of 1 will be
*		disabled. Bit positions of 0 will keep the previous setting.
*		This mask is formed by OR'ing XAPM_IXR_* bits defined in
*		xaxipmon_hw.h.
*
* @return	None.
*
* @note		C-Style signature:
*		void XAxiPmon_IntrEnable(XAxiPmon *InstancePtr, u32 Mask)
*
*****************************************************************************/
#define XAxiPmon_IntrDisable(InstancePtr, Mask)				     \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_IE_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_IE_OFFSET) | (Mask));

/****************************************************************************/
/**
*
* This routine clears the specified interrupt(s).
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param	Mask is the mask to clear. Bit positions of 1 will be cleared.
*		This mask is formed by OR'ing XAPM_IXR_* bits defined in
*		xaxipmon_hw.h.
*
* @return	None.
*
* @note		C-Style signature:
*		void XAxiPmon_IntrClear(XAxiPmon *InstancePtr, u32 Mask)
*
*****************************************************************************/
#define XAxiPmon_IntrClear(InstancePtr, Mask)				     \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_IS_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_IS_OFFSET) | (Mask));

/****************************************************************************/
/**
*
* This routine returns the Interrupt Status Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	Interrupt Status Register contents
*
* @note		C-Style signature:
*		void XAxiPmon_IntrClear(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_IntrGetStatus(InstancePtr)				     \
	XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
			 XAPM_IS_OFFSET);

/****************************************************************************/
/**
*
* This function enables the Global Clock Counter.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_EnableGlobalClkCounter(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_EnableGlobalClkCounter(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_CTL_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_CTL_OFFSET) | XAPM_CR_GCC_ENABLE_MASK);

/****************************************************************************/
/**
*
* This function disbles the Global Clock Counter.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_DisableGlobalClkCounter(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_DisableGlobalClkCounter(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_CTL_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_CTL_OFFSET) & ~(XAPM_CR_GCC_ENABLE_MASK));

/****************************************************************************/
/**
*
* This function enables the specified flag in Flag Control Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param 	Flag is one of the XAPM_FLAG_* masks defined in xaxipmon.h
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_EnableFlag(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_EnableFlag(InstancePtr, Flag) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_FEC_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_FEC_OFFSET) | (Flag));

/****************************************************************************/
/**
*
* This function disables the specified flag in Flag Control Register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
* @param 	Flag is one of the XAPM_FLAG_* masks defined in xaxipmon.h*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_DisableFlag(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_DisableFlag(InstancePtr, Flag) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_FEC_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_FEC_OFFSET) & ~(Flag));

/****************************************************************************/
/**
*
* This function loads the sample interval register value into the sample
* interval counter.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_LoadSampleIntervalCounter(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_LoadSampleIntervalCounter(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_SICR_OFFSET, \
			  XAPM_SICR_LOAD_MASK);



/****************************************************************************/
/**
*
* This enables the down count of the sample interval counter.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*	   void XAxiPmon_EnableSampleIntervalCounter(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_EnableSampleIntervalCounter(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_SICR_OFFSET,\
			  XAPM_SICR_ENABLE_MASK);


/****************************************************************************/
/**
*
* This disables the down count of the sample interval counter.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*	    void XAxiPmon_DisableSampleIntervalCounter(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_DisableSampleIntervalCounter(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_SICR_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_SICR_OFFSET) & ~(XAPM_SICR_ENABLE_MASK));

/****************************************************************************/
/**
*
* This enables Reset of Metric Counters when Sample Interval Counter lapses.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_EnableMetricCounterReset(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_EnableMetricCounterReset(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_SICR_OFFSET,\
			  XAPM_SICR_MCNTR_RST_MASK);

/****************************************************************************/
/**
*
* This disables the down count of the sample interval counter.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_DisableMetricCounterReset(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_DisableMetricCounterReset(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_SICR_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_SICR_OFFSET) & ~(XAPM_SICR_MCNTR_RST_MASK));

/****************************************************************************/
/**
*
* This function enables the ID Filter Masking.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_EnableIDFilter(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_EnableIDFilter(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_CTL_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_CTL_OFFSET) | XAPM_CR_IDFILTER_ENABLE_MASK);

/****************************************************************************/
/**
*
* This function disbles the ID Filter masking.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	None
*
* @note		C-Style signature:
*		void XAxiPmon_DisableIDFilter(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_DisableIDFilter(InstancePtr) \
	XAxiPmon_WriteReg((InstancePtr)->Config.BaseAddress, XAPM_CTL_OFFSET, \
			  XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, \
					   XAPM_CTL_OFFSET) & ~(XAPM_CR_IDFILTER_ENABLE_MASK));

/****************************************************************************/
/**
*
* This function samples Metric Counters to Sampled Metric Counters by
* reading Sample Register and also returns interval. i.e. the number of
* clocks in between previous read to the current read of sample register.
*
* @param	InstancePtr is a pointer to the XAxiPmon instance.
*
* @return	Interval. i.e. the number of clocks in between previous
*		read to the current read of sample register.
*
* @note		C-Style signature:
*		u32 XAxiPmon_SampleMetrics(XAxiPmon *InstancePtr)
*
*****************************************************************************/
#define XAxiPmon_SampleMetrics(InstancePtr) \
	XAxiPmon_ReadReg((InstancePtr)->Config.BaseAddress, XAPM_SR_OFFSET);


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

/**
 * Functions in xaxipmon_sinit.c
 */
#ifndef SDT
XAxiPmon_Config *XAxiPmon_LookupConfig(u16 DeviceId);
#else
XAxiPmon_Config *XAxiPmon_LookupConfig(UINTPTR BaseAddress);
#endif

/**
 * Functions in xaxipmon.c
 */
s32 XAxiPmon_CfgInitialize(XAxiPmon *InstancePtr,
			   XAxiPmon_Config *ConfigPtr, UINTPTR EffectiveAddr);

s32 XAxiPmon_ResetMetricCounter(XAxiPmon *InstancePtr);

void XAxiPmon_ResetGlobalClkCounter(XAxiPmon *InstancePtr);

s32 XAxiPmon_ResetFifo(XAxiPmon *InstancePtr);

void XAxiPmon_SetIncrementerRange(XAxiPmon *InstancePtr, u8 IncrementerNum,
				  u16 RangeUpper,	u16 RangeLower);

void XAxiPmon_GetIncrementerRange(XAxiPmon *InstancePtr, u8 IncrementerNum,
				  u16 *RangeUpper, u16 *RangeLower);

void XAxiPmon_SetSampleInterval(XAxiPmon *InstancePtr, u32 SampleInterval);

void XAxiPmon_GetSampleInterval(XAxiPmon *InstancePtr, u32 *SampleInterval);

s32 XAxiPmon_SetMetrics(XAxiPmon *InstancePtr, u8 Slot, u8 Metrics,
			u8 CounterNum);

s32 XAxiPmon_GetMetrics(XAxiPmon *InstancePtr, u8 CounterNum, u8 *Metrics,
			u8 *Slot);
void XAxiPmon_GetGlobalClkCounter(XAxiPmon *InstancePtr, u32 *CntHighValue,
				  u32 *CntLowValue);

u32 XAxiPmon_GetMetricCounter(XAxiPmon *InstancePtr, u32 CounterNum);

u32 XAxiPmon_GetSampledMetricCounter(XAxiPmon *InstancePtr, u32 CounterNum);

u32 XAxiPmon_GetIncrementer(XAxiPmon *InstancePtr, u32 IncrementerNum);

u32 XAxiPmon_GetSampledIncrementer(XAxiPmon *InstancePtr, u32 IncrementerNum);

void XAxiPmon_SetSwDataReg(XAxiPmon *InstancePtr, u32 SwData);

u32 XAxiPmon_GetSwDataReg(XAxiPmon *InstancePtr);

s32 XAxiPmon_StartEventLog(XAxiPmon *InstancePtr, u32 FlagEnables);

s32 XAxiPmon_StopEventLog(XAxiPmon *InstancePtr);

s32 XAxiPmon_StartCounters(XAxiPmon *InstancePtr, u32 SampleInterval);

s32 XAxiPmon_StopCounters(XAxiPmon *InstancePtr);

void XAxiPmon_EnableMetricsCounter(XAxiPmon *InstancePtr);

void XAxiPmon_DisableMetricsCounter(XAxiPmon *InstancePtr);

void XAxiPmon_SetLogEnableRanges(XAxiPmon *InstancePtr, u32 CounterNum,
				 u16 RangeUpper, u16 RangeLower);

void XAxiPmon_GetLogEnableRanges(XAxiPmon *InstancePtr, u32 CounterNum,
				 u16 *RangeUpper, u16 *RangeLower);

void XAxiPmon_EnableEventLog(XAxiPmon *InstancePtr);

void XAxiPmon_EnableMetricCounterTrigger(XAxiPmon *InstancePtr);

void XAxiPmon_DisableMetricCounterTrigger(XAxiPmon *InstancePtr);

void XAxiPmon_EnableEventLogTrigger(XAxiPmon *InstancePtr);

void XAxiPmon_DisableEventLogTrigger(XAxiPmon *InstancePtr);

const char *XAxiPmon_GetMetricName(u8 Metrics);

void XAxiPmon_SetWriteId(XAxiPmon *InstancePtr, u32 WriteId);

void XAxiPmon_SetReadId(XAxiPmon *InstancePtr, u32 ReadId);

u32 XAxiPmon_GetWriteId(XAxiPmon *InstancePtr);

u32 XAxiPmon_GetReadId(XAxiPmon *InstancePtr);

void XAxiPmon_SetWrLatencyStart(XAxiPmon *InstancePtr, u8 Param);

void XAxiPmon_SetWrLatencyEnd(XAxiPmon *InstancePtr, u8 Param);

void XAxiPmon_SetRdLatencyStart(XAxiPmon *InstancePtr, u8 Param);

void XAxiPmon_SetRdLatencyEnd(XAxiPmon *InstancePtr, u8 Param);

u8 XAxiPmon_GetWrLatencyStart(XAxiPmon *InstancePtr);

u8 XAxiPmon_GetWrLatencyEnd(XAxiPmon *InstancePtr);

u8 XAxiPmon_GetRdLatencyStart(XAxiPmon *InstancePtr);

u8 XAxiPmon_GetRdLatencyEnd(XAxiPmon *InstancePtr);

void XAxiPmon_SetWriteIdMask(XAxiPmon *InstancePtr, u32 WrMask);

void XAxiPmon_SetReadIdMask(XAxiPmon *InstancePtr, u32 RdMask);

u32 XAxiPmon_GetWriteIdMask(XAxiPmon *InstancePtr);

u32 XAxiPmon_GetReadIdMask(XAxiPmon *InstancePtr);


/**
 * Functions in xaxipmon_selftest.c
 */
s32 XAxiPmon_SelfTest(XAxiPmon *InstancePtr);

#ifdef __cplusplus
}
#endif

#endif  /* End of protection macro. */
/** @} */
