| /****************************************************************************** |
| * |
| * Copyright (C) 2012 - 2015 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 |
| * XILINX 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 |
| * @addtogroup axipmon_v6_6 |
| * @{ |
| * |
| * 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. |
| * 6.2 bss 03/02/15 Updated XAxiPmon_SetWriteId, XAxiPmon_SetReadId, |
| * XAxiPmon_GetWriteId, XAxiPmon_GetReadId |
| * XAxiPmon_SetWriteIdMask, XAxiPmon_SetReadIdMask, |
| * XAxiPmon_GetWriteIdMask, XAxiPmon_GetReadIdMask |
| * functions to support Zynq MP APM. |
| * 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. |
| * </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. |
| * |
| ******************************************************************************/ |
| s32 XAxiPmon_CfgInitialize(XAxiPmon *InstancePtr, XAxiPmon_Config *ConfigPtr, |
| UINTPTR 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.Is32BitFiltering = ConfigPtr->Is32BitFiltering; |
| |
| InstancePtr->Config.ScaleFactor = ConfigPtr->ScaleFactor; |
| |
| if ((ConfigPtr->ModeProfile == ConfigPtr->ModeTrace) |
| || (ConfigPtr->ModeAdvanced == 1U)) |
| { |
| InstancePtr->Mode = XAPM_MODE_ADVANCED; |
| } else if (ConfigPtr->ModeTrace == 1U) { |
| 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)) |
| { |
| (void)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)) |
| { |
| (void)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. |
| * |
| ******************************************************************************/ |
| s32 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. |
| * |
| ******************************************************************************/ |
| s32 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 == 0U) && |
| (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 = (u32)RangeUpper << 16; |
| RegValue |= RangeLower; |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_RANGE0_OFFSET + ((u32)IncrementerNum * (u32)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, |
| ((u32)XAPM_RANGE0_OFFSET + ((u32)IncrementerNum * (u32)16))); |
| |
| *RangeLower = (u16)(RegValue & 0x0000FFFFU); |
| *RangeUpper = (u16)((RegValue >> 16) & 0x0000FFFFU); |
| } |
| |
| /****************************************************************************/ |
| /** |
| * |
| * 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. |
| * |
| *****************************************************************************/ |
| s32 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 == 0U) || (CounterNum == 4U) || (CounterNum == 8U)) { |
| Mask = 0xFFFFFF00U; |
| } |
| else if ((CounterNum == 1U) || (CounterNum == 5U) || (CounterNum == 9U)) { |
| Mask = 0xFFFF00FFU; |
| } |
| else if ((CounterNum == 2U) || (CounterNum == 6U)) { |
| Mask = 0xFF00FFFFU; |
| } |
| else { |
| Mask = 0x00FFFFFFU; |
| } |
| |
| if(CounterNum <= 3U) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_MSR0_OFFSET); |
| |
| RegValue = RegValue & Mask; |
| RegValue = RegValue | ((u32)Metrics << (CounterNum * (u8)8)); |
| RegValue = RegValue | ((u32)Slot << ((CounterNum * (u8)8) + (u8)5)); |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_MSR0_OFFSET,RegValue); |
| } |
| else if((CounterNum >= 4U) && (CounterNum <= 7U)) { |
| CounterNum = CounterNum - 4U; |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_MSR1_OFFSET); |
| |
| RegValue = RegValue & Mask; |
| RegValue = RegValue | ((u32)Metrics << (CounterNum * (u8)8)); |
| RegValue = RegValue | ((u32)Slot << ((CounterNum * (u8)8) + (u8)5)); |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| XAPM_MSR1_OFFSET,RegValue); |
| } |
| else { |
| CounterNum = CounterNum - 8U; |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_MSR2_OFFSET); |
| |
| RegValue = RegValue & Mask; |
| RegValue = RegValue | ((u32)Metrics << (CounterNum * (u8)8)); |
| RegValue = RegValue | ((u32)Slot << ((CounterNum * (u8)8) + (u8)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. |
| * |
| *****************************************************************************/ |
| s32 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 <= 3U) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_MSR0_OFFSET); |
| *Metrics = (u8)(RegValue >> (CounterNum * (u8)8)) & 0x1FU; |
| *Slot = (u8)(RegValue >> ((CounterNum * (u8)8) + (u8)5)) & 0x07U; |
| |
| } |
| else if((CounterNum >= 4U) && (CounterNum <= 7U)) { |
| CounterNum = CounterNum - 4U; |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_MSR1_OFFSET); |
| *Metrics = (u8)(RegValue >> (CounterNum * (u8)8)) & 0x1FU; |
| *Slot = (u8)(RegValue >> ((CounterNum * (u8)8) + (u8)5)) & 0x07U; |
| } |
| else { |
| CounterNum = CounterNum - 8U; |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_MSR2_OFFSET); |
| *Metrics = (u8)(RegValue >> (CounterNum * (u8)8)) & 0x1FU; |
| *Slot = (u8)(RegValue >> ((CounterNum * (u8)8) + (u8)5)) & 0x07U; |
| } |
| 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 = 0x0U; |
| *CntLowValue = 0x0U; |
| |
| /* |
| * 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 < 10U ) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_MC0_OFFSET + (CounterNum * (u32)16))); |
| } |
| else if ((CounterNum >= 10U) && (CounterNum < 12U)) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_MC10_OFFSET + ((CounterNum - (u32)10) * (u32)16))); |
| } |
| else if ((CounterNum >= 12U) && (CounterNum < 24U)) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_MC12_OFFSET + ((CounterNum - (u32)12) * (u32)16))); |
| } |
| else if ((CounterNum >= 24U) && (CounterNum < 36U)) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_MC24_OFFSET + ((CounterNum - (u32)24) * (u32)16))); |
| } |
| else { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_MC36_OFFSET + ((CounterNum - (u32)36) * (u32)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 == 1U))); |
| |
| if (CounterNum < 10U ) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_SMC0_OFFSET + (CounterNum * (u32)16))); |
| } |
| else if ((CounterNum >= 10U) && (CounterNum < 12U)) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_SMC10_OFFSET + ((CounterNum - (u32)10) * (u32)16))); |
| } |
| else if ((CounterNum >= 12U) && (CounterNum < 24U)) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_SMC12_OFFSET + ((CounterNum - (u32)12) * (u32)16))); |
| } |
| else if ((CounterNum >= 24U) && (CounterNum < 36U)) { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_SMC24_OFFSET + ((CounterNum - (u32)24) * (u32)16))); |
| } |
| else { |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_SMC36_OFFSET + ((CounterNum - (u32)36) * (u32)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 == 1U)); |
| Xil_AssertNonvoid(IncrementerNum < XAPM_MAX_COUNTERS); |
| |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_INC0_OFFSET + (IncrementerNum * (u32)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 == 1U) && |
| (InstancePtr->Config.HaveSampledCounters == 1U)); |
| Xil_AssertNonvoid(IncrementerNum < XAPM_MAX_COUNTERS); |
| |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_SINC0_OFFSET + (IncrementerNum * (u32)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, (u32)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 |
| * |
| ******************************************************************************/ |
| s32 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 == 1U))); |
| |
| /* Read current register value */ |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)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, |
| (u32)XAPM_FEC_OFFSET, FlagEnables); |
| } |
| |
| /* Write the new value to the Control register to |
| * enable event logging */ |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, (u32)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 |
| * |
| ******************************************************************************/ |
| s32 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 == 1U))); |
| |
| /* Read current register value */ |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_CTL_OFFSET); |
| |
| /* Write the new value to the Control register to disable |
| * event logging */ |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, (u32)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 |
| ******************************************************************************/ |
| s32 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 == 1U))); |
| |
| /* Read current register value */ |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)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, (u32)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 |
| * |
| ******************************************************************************/ |
| s32 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 == 1U))); |
| |
| /* Read current register value */ |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)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, (u32)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 == 1U))); |
| |
| 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 == 1U))); |
| |
| RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_CTL_OFFSET); |
| |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, (u32)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 == 1U)); |
| |
| |
| /* |
| * Write the specified Ranges to corresponding Metric Counter Log |
| * Enable Register |
| */ |
| RegValue = (u32)RangeUpper << 16; |
| RegValue |= RangeLower; |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_MC0LOGEN_OFFSET + (CounterNum * (u32)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 == 1U)); |
| |
| |
| RegValue = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| ((u32)XAPM_MC0LOGEN_OFFSET + (CounterNum * (u32)16))); |
| |
| *RangeLower = (u16)RegValue & 0xFFFFU; |
| *RangeUpper = (u16)(RegValue >> 16) & 0xFFFFU; |
| } |
| |
| /*****************************************************************************/ |
| /** |
| * |
| * 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 == 1U))); |
| |
| 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 |
| * If ID filtering for write is of 32 bits(for Zynq MP APM) width then |
| * WriteID is written to XAPM_ID_OFFSET or if it is 16 bit width |
| * then lower 16 bits of WriteID are written to XAPM_ID_OFFSET. |
| * |
| *****************************************************************************/ |
| void XAxiPmon_SetWriteId(XAxiPmon *InstancePtr, u32 WriteId) |
| { |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertVoid(InstancePtr != NULL); |
| Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| 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); |
| } else { |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| XAPM_ID_OFFSET, WriteId); |
| } |
| } |
| |
| /****************************************************************************/ |
| /** |
| * |
| * 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 |
| * If ID filtering for read is of 32 bits(for Zynq MP APM) width then |
| * ReadId is written to XAPM_RID_OFFSET or if it is 16 bit width |
| * then lower 16 bits of ReadId are written to XAPM_ID_OFFSET. |
| * |
| *****************************************************************************/ |
| void XAxiPmon_SetReadId(XAxiPmon *InstancePtr, u32 ReadId) |
| { |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertVoid(InstancePtr != NULL); |
| Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| 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); |
| } else { |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| XAPM_RID_OFFSET, ReadId); |
| } |
| } |
| |
| /****************************************************************************/ |
| /** |
| * |
| * 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. |
| * If ID filtering for write is of 32 bits(for Zynq MP APM) width then |
| * 32 bit XAPM_ID_OFFSET contents are returned or if it is 16 bit |
| * width then lower 16 bits of XAPM_ID_OFFSET register are returned. |
| * |
| *****************************************************************************/ |
| u32 XAxiPmon_GetWriteId(XAxiPmon *InstancePtr) |
| { |
| |
| u32 WriteId; |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertNonvoid(InstancePtr != NULL); |
| Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_ID_OFFSET); |
| WriteId = RegVal & XAPM_ID_WID_MASK; |
| } else { |
| WriteId = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_ID_OFFSET); |
| } |
| |
| 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. |
| * If ID filtering for write is of 32 bits(for Zynq MP APM) width then |
| * 32 bit XAPM_RID_OFFSET contents are returned or if it is 16 bit |
| * width then higher 16 bits of XAPM_ID_OFFSET register are returned. |
| * |
| *****************************************************************************/ |
| u32 XAxiPmon_GetReadId(XAxiPmon *InstancePtr) |
| { |
| |
| u32 ReadId; |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertNonvoid(InstancePtr != NULL); |
| Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_ID_OFFSET); |
| RegVal = RegVal & XAPM_ID_RID_MASK; |
| ReadId = RegVal >> 16; |
| } else { |
| ReadId = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_RID_OFFSET); |
| } |
| |
| 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 = (u8)XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_CTL_OFFSET); |
| RegVal = RegVal & XAPM_CR_WRLATENCY_START_MASK; |
| if (RegVal != XAPM_LATENCY_ADDR_ISSUE) { |
| return (u8)XAPM_LATENCY_ADDR_ACCEPT; |
| } |
| else { |
| return (u8)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 = (u8)XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_CTL_OFFSET); |
| RegVal = RegVal & XAPM_CR_WRLATENCY_END_MASK; |
| if (RegVal != XAPM_LATENCY_LASTWR) { |
| return (u8)XAPM_LATENCY_FIRSTWR; |
| } |
| else { |
| return (u8)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 = (u8)XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_CTL_OFFSET); |
| RegVal = RegVal & XAPM_CR_RDLATENCY_START_MASK; |
| |
| if (RegVal != XAPM_LATENCY_ADDR_ISSUE) { |
| return (u8)XAPM_LATENCY_ADDR_ACCEPT; |
| } |
| else { |
| return (u8)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 = (u8)XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| (u32)XAPM_CTL_OFFSET); |
| RegVal = RegVal & XAPM_CR_RDLATENCY_END_MASK; |
| if (RegVal != XAPM_LATENCY_LASTRD) { |
| return (u8)XAPM_LATENCY_FIRSTRD; |
| } |
| else { |
| return (u8)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 |
| * If ID masking for write is of 32 bits(for Zynq MP APM) width then |
| * WrMask is written to XAPM_IDMASK_OFFSET or if it is 16 bit width |
| * then lower 16 bits of WrMask are written to XAPM_IDMASK_OFFSET. |
| * |
| *****************************************************************************/ |
| void XAxiPmon_SetWriteIdMask(XAxiPmon *InstancePtr, u32 WrMask) |
| { |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertVoid(InstancePtr != NULL); |
| Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| 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); |
| } else { |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| XAPM_IDMASK_OFFSET, WrMask); |
| } |
| } |
| |
| /****************************************************************************/ |
| /** |
| * |
| * 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 |
| * If ID masking for read is of 32 bits(for Zynq MP APM) width then |
| * RdMask is written to XAPM_RIDMASK_OFFSET or if it is 16 bit width |
| * then lower 16 bits of RdMask are written to XAPM_IDMASK_OFFSET. |
| * |
| *****************************************************************************/ |
| void XAxiPmon_SetReadIdMask(XAxiPmon *InstancePtr, u32 RdMask) |
| { |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertVoid(InstancePtr != NULL); |
| Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| 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); |
| } else { |
| XAxiPmon_WriteReg(InstancePtr->Config.BaseAddress, |
| XAPM_RIDMASK_OFFSET, RdMask); |
| } |
| } |
| |
| /****************************************************************************/ |
| /** |
| * |
| * 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 |
| * If ID masking for write is of 32 bits(for Zynq MP APM) width then |
| * 32 bit XAPM_IDMASK_OFFSET contents are returned or if it is 16 bit |
| * width then lower 16 bits of XAPM_IDMASK_OFFSET register |
| * are returned. |
| * |
| *****************************************************************************/ |
| u32 XAxiPmon_GetWriteIdMask(XAxiPmon *InstancePtr) |
| { |
| |
| u32 WrMask; |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertNonvoid(InstancePtr != NULL); |
| Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_IDMASK_OFFSET); |
| WrMask = RegVal & XAPM_MASKID_WID_MASK; |
| } else { |
| WrMask = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_IDMASK_OFFSET); |
| } |
| |
| 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 |
| * If ID masking for read is of 32 bits(for Zynq MP APM) width then |
| * 32 bit XAPM_RIDMASK_OFFSET contents are returned or if it is 16 bit |
| * width then higher 16 bits of XAPM_IDMASK_OFFSET register |
| * are returned. |
| * |
| *****************************************************************************/ |
| u32 XAxiPmon_GetReadIdMask(XAxiPmon *InstancePtr) |
| { |
| |
| u32 RdMask; |
| u32 RegVal; |
| /* |
| * Assert the arguments. |
| */ |
| Xil_AssertNonvoid(InstancePtr != NULL); |
| Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); |
| |
| if (InstancePtr->Config.Is32BitFiltering == 0U) |
| { |
| RegVal = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_IDMASK_OFFSET); |
| RegVal = RegVal & XAPM_MASKID_RID_MASK; |
| RdMask = RegVal >> 16; |
| } else { |
| RdMask = XAxiPmon_ReadReg(InstancePtr->Config.BaseAddress, |
| XAPM_RIDMASK_OFFSET); |
| } |
| |
| return RdMask; |
| } |
| /** @} */ |