1610 lines
55 KiB
C
1610 lines
55 KiB
C
//###########################################################################
|
|
//
|
|
// FILE: erad.h
|
|
//
|
|
// TITLE: C28x ERAD driver.
|
|
//
|
|
//###########################################################################
|
|
// $Copyright:
|
|
// Copyright (C) 2022 Texas Instruments Incorporated - http://www.ti.com
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the
|
|
// distribution.
|
|
//
|
|
// Neither the name of Texas Instruments Incorporated nor the names of
|
|
// its contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
// $
|
|
//###########################################################################
|
|
|
|
#ifndef ERAD_H
|
|
#define ERAD_H
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// If building with a C++ compiler, make all of the definitions in this header
|
|
// have a C binding.
|
|
//
|
|
//*****************************************************************************
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \addtogroup erad_api ERAD
|
|
//! @{
|
|
//
|
|
//*****************************************************************************
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include "inc/hw_erad.h"
|
|
#include "inc/hw_memmap.h"
|
|
#include "inc/hw_types.h"
|
|
#include "cpu.h"
|
|
#include "debug.h"
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Useful defines used within the driver functions. Not intended for use by
|
|
// application code.
|
|
//
|
|
//*****************************************************************************
|
|
|
|
//
|
|
// Macros for but positions of some register bit fields
|
|
//
|
|
#define ERAD_HWBP_CNTL_STOP_S 0x05U
|
|
#define ERAD_HWBP_CNTL_RTOSINT_S 0x06U
|
|
|
|
#define ERAD_CTM_CNTL_EVENT_MODE_S 0x03U
|
|
#define ERAD_CTM_CNTL_RST_ON_MATCH_S 0x04U
|
|
#define ERAD_CTM_CNTL_STOP_S 0x06U
|
|
#define ERAD_CTM_CNTL_RTOSINT_S 0x07U
|
|
|
|
//
|
|
// Macro function for getting the instance number from the base address
|
|
//
|
|
#define ERAD_getBusCompInstance(base) (1U << ((base >> 3U) & 0x7U))
|
|
#define ERAD_getCounterInstance(base) ((1U << ((base >> 4U) & 0x3U)) << 8U)
|
|
#define ERAD_getCRCInstance(base) (1U << (((base >> 4U) & 0xFU) - 1U))
|
|
|
|
//
|
|
// Macro function to get the HWBP event number from the base address
|
|
//
|
|
#define ERAD_BUSCOMP_BASE_TO_EVENT(base) ((base >> 3U) & 0x07U)
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_enableModules() or
|
|
//! ERAD_disableModules() as \e instances parameter.
|
|
//
|
|
//*****************************************************************************
|
|
|
|
#define ERAD_INST_BUSCOMP1 0x00000001UL //!< Instance for bus comparator 1
|
|
#define ERAD_INST_BUSCOMP2 0x00000002UL //!< Instance for bus comparator 2
|
|
#define ERAD_INST_BUSCOMP3 0x00000004UL //!< Instance for bus comparator 3
|
|
#define ERAD_INST_BUSCOMP4 0x00000008UL //!< Instance for bus comparator 4
|
|
#define ERAD_INST_BUSCOMP5 0x00000010UL //!< Instance for bus comparator 5
|
|
#define ERAD_INST_BUSCOMP6 0x00000020UL //!< Instance for bus comparator 6
|
|
#define ERAD_INST_BUSCOMP7 0x00000040UL //!< Instance for bus comparator 7
|
|
#define ERAD_INST_BUSCOMP8 0x00000080UL //!< Instance for bus comparator 8
|
|
#define ERAD_INST_COUNTER1 0x00000100UL //!< Instance for counter 1
|
|
#define ERAD_INST_COUNTER2 0x00000200UL //!< Instance for counter 2
|
|
#define ERAD_INST_COUNTER3 0x00000400UL //!< Instance for counter 3
|
|
#define ERAD_INST_COUNTER4 0x00000800UL //!< Instance for counter 4
|
|
#define ERAD_INST_CRC1 0x00000001UL //!< Instance for CRC unit 1
|
|
#define ERAD_INST_CRC2 0x00000002UL //!< Instance for CRC unit 2
|
|
#define ERAD_INST_CRC3 0x00000004UL //!< Instance for CRC unit 3
|
|
#define ERAD_INST_CRC4 0x00000008UL //!< Instance for CRC unit 4
|
|
#define ERAD_INST_CRC5 0x00000010UL //!< Instance for CRC unit 5
|
|
#define ERAD_INST_CRC6 0x00000020UL //!< Instance for CRC unit 6
|
|
#define ERAD_INST_CRC7 0x00000040UL //!< Instance for CRC unit 7
|
|
#define ERAD_INST_CRC8 0x00000080UL //!< Instance for CRC unit 8
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_setCounterInputConditioning() as options
|
|
//! parameter.
|
|
//
|
|
//*****************************************************************************
|
|
#define ERAD_INPUT_INVERT_DISABLE 0x00U //!< Do not invert the input
|
|
#define ERAD_INPUT_INVERT_ENABLE 0x01U //!< Invert the input
|
|
#define ERAD_INPUT_SYNC_DISABLE 0x00U //!< Disable 2-stage synchronizer
|
|
#define ERAD_INPUT_SYNC_ENABLE 0x02U //!< Enable 2-stage synchronizer
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_initModule() as \e owner parameter to
|
|
//! set owner of ERAD.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_OWNER_NOOWNER = 0, //!< No owner
|
|
ERAD_OWNER_APPLICATION = 1, //!< Application owned
|
|
ERAD_OWNER_DEBUGGER = 2 //!< Debugger owned
|
|
} ERAD_Owner;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can are returned by ERAD_getBusCompStatus() and
|
|
//! ERAD_getCounterStatus() to indicate the state of the respective module.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_STATE_IDLE = 0, //!< Module is idle
|
|
ERAD_STATE_ENABLED = 2, //!< Module is enabled
|
|
ERAD_STATE_COMPLETED = 3 //!< Module was enabled and an event occurred
|
|
} ERAD_Status;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_configBusComp() and ERAD_profile()
|
|
//! as \e config_params.bus_sel parameter to choose which CPU bus to monitor.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_BUSCOMP_BUS_PAB = 0, //!< Use the Program Address Bus
|
|
ERAD_BUSCOMP_BUS_VPC = 1, //!< Use the Virtual Program Counter
|
|
ERAD_BUSCOMP_BUS_DWAB = 2, //!< Use the Data Write Address Bus
|
|
ERAD_BUSCOMP_BUS_DRAB = 3, //!< Use the Data Read Address Bus
|
|
ERAD_BUSCOMP_BUS_DWDB = 4, //!< Use the Data Write Data Bus
|
|
ERAD_BUSCOMP_BUS_DRDB = 5, //!< Use the Data Read Data Bus
|
|
ERAD_BUSCOMP_BUS_VPC_I_ALIGNED = 6, //!< Use VPC Instruction aligned match
|
|
ERAD_BUSCOMP_BUS_VPC_R1_ALIGNED = 7, //!< Use VPC R1 aligned match
|
|
ERAD_BUSCOMP_BUS_VPC_R2_ALIGNED = 8, //!< Use VPC R2 aligned match
|
|
ERAD_BUSCOMP_BUS_VPC_W_ALIGNED = 9, //!< Use VPC Word aligned match
|
|
} ERAD_BusComp_Bus_Select;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_configBusComp() and ERAD_profile()
|
|
//! as \e config_params.comp_mode to indicate what kind of comparison to use
|
|
//! for the bus comparators.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_BUSCOMP_COMPMODE_GT = 4, //!< Check for greater than
|
|
ERAD_BUSCOMP_COMPMODE_GE = 5, //!< Check for greater than equal to
|
|
ERAD_BUSCOMP_COMPMODE_LT = 6, //!< Check for lesser than
|
|
ERAD_BUSCOMP_COMPMODE_LE = 7, //!< Check for lesser than equal to
|
|
ERAD_BUSCOMP_COMPMODE_EQ = 0 //!< Check for only equality
|
|
} ERAD_BusComp_Comp_Mode;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_configCounterInStartStopMode()
|
|
//! and ERAD_configCounterInCountingMode() as \e config_params.event_mode to
|
|
//! indicate whether to count rising edges or the number of CPU clock cycles an
|
|
//! is active.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_COUNTER_MODE_ACTIVE = 0, //!< Count number of CPU
|
|
//! Cycles event is active for
|
|
ERAD_COUNTER_MODE_RISING_EDGE = 1 //!< Count number of Rising
|
|
//! Edges of event
|
|
} ERAD_Counter_Event_Mode;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_configCounterInStartStopMode()
|
|
//! and ERAD_configCounterInCountingMode() as \e config_params.event to
|
|
//! indicate what event to consider as input. Also may be passed to
|
|
//! ERAD_configCounterInStartStopMode() as \e start_event and \e stop_event
|
|
//! to indicate start and stop events for the counter.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_EVENT_HWBP1 = 0,
|
|
ERAD_EVENT_HWBP2 = 1,
|
|
ERAD_EVENT_HWBP3 = 2,
|
|
ERAD_EVENT_HWBP4 = 3,
|
|
ERAD_EVENT_HWBP5 = 4,
|
|
ERAD_EVENT_HWBP6 = 5,
|
|
ERAD_EVENT_HWBP7 = 6,
|
|
ERAD_EVENT_HWBP8 = 7,
|
|
ERAD_EVENT_COUNTER1_EVENT = 8,
|
|
ERAD_EVENT_COUNTER2_EVENT = 9,
|
|
ERAD_EVENT_COUNTER3_EVENT = 10,
|
|
ERAD_EVENT_COUNTER4_EVENT = 11,
|
|
ERAD_EVENT_ERAD_OR_MASK0 = 12,
|
|
ERAD_EVENT_ERAD_OR_MASK1 = 13,
|
|
ERAD_EVENT_ERAD_OR_MASK2 = 14,
|
|
ERAD_EVENT_ERAD_OR_MASK3 = 15,
|
|
ERAD_EVENT_ERAD_AND_MASK0 = 16,
|
|
ERAD_EVENT_ERAD_AND_MASK1 = 17,
|
|
ERAD_EVENT_ERAD_AND_MASK2 = 18,
|
|
ERAD_EVENT_ERAD_AND_MASK3 = 19,
|
|
ERAD_EVENT_PIE_INT1 = 20,
|
|
ERAD_EVENT_PIE_INT2 = 21,
|
|
ERAD_EVENT_PIE_INT3 = 22,
|
|
ERAD_EVENT_PIE_INT4 = 23,
|
|
ERAD_EVENT_PIE_INT5 = 24,
|
|
ERAD_EVENT_PIE_INT6 = 25,
|
|
ERAD_EVENT_PIE_INT7 = 26,
|
|
ERAD_EVENT_PIE_INT8 = 27,
|
|
ERAD_EVENT_PIE_INT9 = 28,
|
|
ERAD_EVENT_PIE_INT10 = 29,
|
|
ERAD_EVENT_PIE_INT11 = 30,
|
|
ERAD_EVENT_PIE_INT12 = 31,
|
|
ERAD_EVENT_TIMER1_TINT0 = 32,
|
|
ERAD_EVENT_TIMER1_TINT1 = 33,
|
|
ERAD_EVENT_TIMER2_TINT2 = 34,
|
|
ERAD_EVENT_CLA_INTERRUPT1 = 35,
|
|
ERAD_EVENT_CLA_INTERRUPT2 = 36,
|
|
ERAD_EVENT_CLA_INTERRUPT3 = 37,
|
|
ERAD_EVENT_CLA_INTERRUPT4 = 38,
|
|
ERAD_EVENT_CLA_INTERRUPT5 = 39,
|
|
ERAD_EVENT_CLA_INTERRUPT6 = 40,
|
|
ERAD_EVENT_CLA_INTERRUPT7 = 41,
|
|
ERAD_EVENT_CLA_INTERRUPT8 = 42,
|
|
ERAD_EVENT_ECAT_PDI_SOF = 43,
|
|
ERAD_EVENT_ECAT_PDI_EOF = 44,
|
|
ERAD_EVENT_ECAT_PCI_WD_TRIGGER = 43,
|
|
ERAD_EVENT_ECAT_PDI_UC_IRQ = 46,
|
|
ERAD_EVENT_ECAT_SYNC_OUT0 = 47,
|
|
ERAD_EVENT_ECAT_SYNC_OUT1 = 48,
|
|
ERAD_EVENT_ECAT_DRAM_PARITY_ERROR = 49,
|
|
ERAD_EVENT_MCANA_EVT0 = 50,
|
|
ERAD_EVENT_MCANA_EVT1 = 51,
|
|
ERAD_EVENT_MCANA_EVT2 = 52,
|
|
ERAD_EVENT_ADCSOCA = 53,
|
|
ERAD_EVENT_ADCSOCB = 54,
|
|
ERAD_EVENT_CLATASKRUN1 = 55,
|
|
ERAD_EVENT_CLATASKRUN2 = 56,
|
|
ERAD_EVENT_CLATASKRUN3 = 57,
|
|
ERAD_EVENT_CLATASKRUN4 = 58,
|
|
ERAD_EVENT_CLATASKRUN5 = 59,
|
|
ERAD_EVENT_CLATASKRUN6 = 60,
|
|
ERAD_EVENT_CLATASKRUN7 = 61,
|
|
ERAD_EVENT_CLATASKRUN8 = 62,
|
|
ERAD_EVENT_EPWMXBAR_OUT1 = 63,
|
|
ERAD_EVENT_EPWMXBAR_OUT2 = 64,
|
|
ERAD_EVENT_EPWMXBAR_OUT3 = 65,
|
|
ERAD_EVENT_EPWMXBAR_OUT4 = 66,
|
|
ERAD_EVENT_EPWMXBAR_OUT5 = 67,
|
|
ERAD_EVENT_EPWMXBAR_OUT6 = 68,
|
|
ERAD_EVENT_EPWMXBAR_OUT7 = 69,
|
|
ERAD_EVENT_EPWMXBAR_OUT8 = 70,
|
|
ERAD_EVENT_INPUTXBAR0 = 71,
|
|
ERAD_EVENT_INPUTXBAR1 = 72,
|
|
ERAD_EVENT_INPUTXBAR2 = 73,
|
|
ERAD_EVENT_INPUTXBAR3 = 74,
|
|
ERAD_EVENT_INPUTXBAR4 = 75,
|
|
ERAD_EVENT_INPUTXBAR5 = 76,
|
|
ERAD_EVENT_INPUTXBAR6 = 77,
|
|
ERAD_EVENT_INPUTXBAR7 = 78,
|
|
ERAD_EVENT_INPUTXBAR8 = 79,
|
|
ERAD_EVENT_INPUTXBAR9 = 80,
|
|
ERAD_EVENT_INPUTXBAR10 = 81,
|
|
ERAD_EVENT_INPUTXBAR11 = 82,
|
|
ERAD_EVENT_INPUTXBAR12 = 83,
|
|
ERAD_EVENT_INPUTXBAR13 = 84,
|
|
ERAD_EVENT_INPUTXBAR14 = 85,
|
|
ERAD_EVENT_INPUTXBAR15 = 86,
|
|
ERAD_EVENT_CPUx_CPUSTAT = 87,
|
|
ERAD_EVENT_CPUx_DBGACK = 88,
|
|
ERAD_EVENT_CPUx_NMI = 89,
|
|
ERAD_EVENT_CMPSS1_CTRIPH_OR_CTRIPL = 90,
|
|
ERAD_EVENT_CMPSS2_CTRIPH_OR_CTRIPL = 91,
|
|
ERAD_EVENT_CMPSS3_CTRIPH_OR_CTRIPL = 92,
|
|
ERAD_EVENT_CMPSS4_CTRIPH_OR_CTRIPL = 93,
|
|
ERAD_EVENT_CMPSS5_CTRIPH_OR_CTRIPL = 94,
|
|
ERAD_EVENT_CMPSS6_CTRIPH_OR_CTRIPL = 95,
|
|
ERAD_EVENT_CMPSS7_CTRIPH_OR_CTRIPL = 96,
|
|
ERAD_EVENT_CMPSS8_CTRIPH_OR_CTRIPL = 97,
|
|
ERAD_EVENT_SD1FLT1_COMPH_OR_COMPL = 98,
|
|
ERAD_EVENT_SD1FLT2_COMPH_OR_COMPL = 99,
|
|
ERAD_EVENT_SD1FLT3_COMPH_OR_COMPL = 100,
|
|
ERAD_EVENT_SD1FLT4_COMPH_OR_COMPL = 101,
|
|
ERAD_EVENT_SD2FLT1_COMPH_OR_COMPL = 102,
|
|
ERAD_EVENT_SD2FLT2_COMPH_OR_COMPL = 103,
|
|
ERAD_EVENT_SD2FLT3_COMPH_OR_COMPL = 104,
|
|
ERAD_EVENT_SD2FLT4_COMPH_OR_COMPL = 105,
|
|
ERAD_EVENT_ADCAINT1 = 106,
|
|
ERAD_EVENT_ADCAINT2 = 107,
|
|
ERAD_EVENT_ADCAINT3 = 108,
|
|
ERAD_EVENT_ADCAINT4 = 109,
|
|
ERAD_EVENT_ADCBINT1 = 110,
|
|
ERAD_EVENT_ADCBINT2 = 111,
|
|
ERAD_EVENT_ADCBINT3 = 112,
|
|
ERAD_EVENT_ADCBINT4 = 113,
|
|
ERAD_EVENT_ADCCINT1 = 114,
|
|
ERAD_EVENT_ADCCINT2 = 115,
|
|
ERAD_EVENT_ADCCINT3 = 116,
|
|
ERAD_EVENT_ADCCINT4 = 117,
|
|
ERAD_EVENT_ADCDINT1 = 118,
|
|
ERAD_EVENT_ADCDINT2 = 119,
|
|
ERAD_EVENT_ADCDINT3 = 120,
|
|
ERAD_EVENT_ADCDINT4 = 121,
|
|
|
|
ERAD_EVENT_NO_EVENT = 256
|
|
} ERAD_Counter_Input_Event;
|
|
|
|
typedef enum
|
|
{
|
|
ERAD_AND_MASK1 = 0,
|
|
ERAD_AND_MASK2 = 1,
|
|
ERAD_AND_MASK3 = 2,
|
|
ERAD_AND_MASK4 = 3,
|
|
ERAD_OR_MASK1 = 4,
|
|
ERAD_OR_MASK2 = 5,
|
|
ERAD_OR_MASK3 = 6,
|
|
ERAD_OR_MASK4 = 7
|
|
} ERAD_Mask;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_setCRCQualifier() as the \e qualifier
|
|
//! paramter to specify which events to set as the qualifier for the CRC unit.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_CRC_QUAL_NONE = 0, //!< Use every valid event as qualifier
|
|
//!< for CRC computation
|
|
ERAD_CRC_QUAL_HWBP1 = 1, //!< CRC Compute Qualified by HWBP_EVENT1
|
|
ERAD_CRC_QUAL_HWBP2 = 2, //!< CRC Compute Qualified by HWBP_EVENT2
|
|
ERAD_CRC_QUAL_HWBP3 = 3, //!< CRC Compute Qualified by HWBP_EVENT3
|
|
ERAD_CRC_QUAL_HWBP4 = 4, //!< CRC Compute Qualified by HWBP_EVENT4
|
|
ERAD_CRC_QUAL_HWBP5 = 5, //!< CRC Compute Qualified by HWBP_EVENT5
|
|
ERAD_CRC_QUAL_HWBP6 = 6, //!< CRC Compute Qualified by HWBP_EVENT6
|
|
ERAD_CRC_QUAL_HWBP7 = 7, //!< CRC Compute Qualified by HWBP_EVENT7
|
|
ERAD_CRC_QUAL_HWBP8 = 8, //!< CRC Compute Qualified by HWBP_EVENT8
|
|
ERAD_CRC_QUAL_HWBP_OR1 = 9, //!< CRC Compute Qualified by HWBP_EVENT_OR1
|
|
ERAD_CRC_QUAL_HWBP_OR2 = 10, //!< CRC Compute Qualified by HWBP_EVENT_OR1
|
|
ERAD_CRC_QUAL_HWBP_OR3 = 11, //!< CRC Compute Qualified by HWBP_EVENT_OR1
|
|
ERAD_CRC_QUAL_HWBP_OR4 = 12, //!< CRC Compute Qualified by HWBP_EVENT_OR1
|
|
ERAD_CRC_QUAL_HWBP_AND1 = 13, //!< CRC Compute Qualified by HWBP_EVENT_AND2
|
|
ERAD_CRC_QUAL_HWBP_AND2 = 14, //!< CRC Compute Qualified by HWBP_EVENT_AND2
|
|
ERAD_CRC_QUAL_HWBP_AND3 = 15, //!< CRC Compute Qualified by HWBP_EVENT_AND2
|
|
ERAD_CRC_QUAL_HWBP_AND4 = 16 //!< CRC Compute Qualified by HWBP_EVENT_AND2
|
|
} ERAD_CRC_Qualifiers;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Values that can be passed to ERAD_setCounterInputConditioning() as
|
|
//! \e input_type parameter. To specify which input to condition.
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
ERAD_COUNTER_COUNT_INPUT = 0,
|
|
ERAD_COUNTER_START_INPUT = 1,
|
|
ERAD_COUNTER_STOP_INPUT = 2,
|
|
ERAD_COUNTER_RESET_INPUT = 3
|
|
} ERAD_Counter_Input_Type;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Structure that is passed to ERAD_configBusComp() as \e config_params
|
|
//! to configure a bus comparator.
|
|
//
|
|
//*****************************************************************************
|
|
typedef struct
|
|
{
|
|
uint32_t mask; //!< Mask to be used for comparing
|
|
uint32_t reference; //!< Reference value to be compared
|
|
ERAD_BusComp_Comp_Mode comp_mode; //!< Comparison mode
|
|
bool enable_int; //!< Enable Interrupt on event match
|
|
bool enable_stop; //!< Enable CPU halt on event match
|
|
ERAD_BusComp_Bus_Select bus_sel; //!< Bus to be monitored
|
|
} ERAD_BusComp_Config;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Structure that is passed to ERAD_profile() as \e config_params to setup
|
|
//! the required modules appropriately for each use case.
|
|
//
|
|
//*****************************************************************************
|
|
typedef struct
|
|
{
|
|
uint32_t start_address; //!< Start address
|
|
uint32_t end_address; //!< End address
|
|
ERAD_BusComp_Bus_Select bus_sel; //!< Bus to be monitored
|
|
uint32_t busComp_base1; //!< Bus comparators to be used
|
|
uint32_t busComp_base2; //!< Bus comparators to be used
|
|
uint32_t counter_base; //!< Counter to be used
|
|
} ERAD_Profile_Params;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Structure that is passed to ERAD_configCounterInStartStopMode() and
|
|
//! ERA_configCounterInCountingMode() as \e config_params to setup a
|
|
//! counter appropriately.
|
|
//
|
|
//*****************************************************************************
|
|
typedef struct
|
|
{
|
|
ERAD_Counter_Input_Event event; //!< Input Event to be counted
|
|
ERAD_Counter_Event_Mode event_mode; //!< Active / rising edge
|
|
uint32_t reference; //!< Reference to be compared
|
|
bool rst_on_match; //!< Enable counter reset on match
|
|
bool enable_int; //!< Enable Interrupt on match
|
|
bool enable_stop; //!< Enable CPU halt on match
|
|
} ERAD_Counter_Config;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Structure that is passed to ERAD_enableInterruptOnAddressHit() and
|
|
//! ERAD_countAddressHits() as \e config_params to select the bus and the
|
|
//! address to compare. \e bus_Sel can be one of the following:
|
|
//! \b ERAD_BUSCOMP_BUS_PAB : for instruction fetch at the address
|
|
//! \b ERAD_BUSCOMP_BUS_DWAB : for data write access to the address
|
|
//! \b ERAD_BUSCOMP_BUS_DRAB : for data read access to the address
|
|
//
|
|
//*****************************************************************************
|
|
typedef struct
|
|
{
|
|
uint32_t address; //!< Address to compare
|
|
uint32_t mask; //!< Mask for the address compare
|
|
ERAD_BusComp_Bus_Select bus_sel; //!< Bus to be monitored
|
|
} ERAD_AddressHit_Params;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Prototypes for the APIs.
|
|
//
|
|
//*****************************************************************************
|
|
|
|
#ifdef DEBUG
|
|
//*****************************************************************************
|
|
//
|
|
//! \internal
|
|
//! Checks a bus comparator base address.
|
|
//!
|
|
//! \param base specifies the bus comparator base address.
|
|
//!
|
|
//! This function determines if a bus comparator base address is valid.
|
|
//!
|
|
//! \return Returns \b true if the base address is valid and \b false
|
|
//! otherwise.
|
|
//
|
|
//*****************************************************************************
|
|
static inline bool
|
|
ERAD_isValidBusCompBase(uint32_t base)
|
|
{
|
|
return((base == ERAD_HWBP1_BASE) ||
|
|
(base == ERAD_HWBP2_BASE) ||
|
|
(base == ERAD_HWBP3_BASE) ||
|
|
(base == ERAD_HWBP4_BASE) ||
|
|
(base == ERAD_HWBP5_BASE) ||
|
|
(base == ERAD_HWBP6_BASE) ||
|
|
(base == ERAD_HWBP7_BASE) ||
|
|
(base == ERAD_HWBP8_BASE));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \internal
|
|
//! Checks a counter base address.
|
|
//!
|
|
//! \param base specifies the counter base address.
|
|
//!
|
|
//! This function determines if a counter base address is valid.
|
|
//!
|
|
//! \return Returns \b true if the base address is valid and \b false
|
|
//! otherwise.
|
|
//
|
|
//*****************************************************************************
|
|
static inline bool
|
|
ERAD_isValidCounterBase(uint32_t base)
|
|
{
|
|
return((base == ERAD_COUNTER1_BASE) ||
|
|
(base == ERAD_COUNTER2_BASE) ||
|
|
(base == ERAD_COUNTER3_BASE) ||
|
|
(base == ERAD_COUNTER4_BASE));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \internal
|
|
//! Checks a CRC base address.
|
|
//!
|
|
//! \param base specifies the CRC base address.
|
|
//!
|
|
//! This function determines if a CRC base address is valid.
|
|
//!
|
|
//! \return Returns \b true if the base address is valid and \b false
|
|
//! otherwise.
|
|
//
|
|
//*****************************************************************************
|
|
static inline bool
|
|
ERAD_isValidCRCBase(uint32_t base)
|
|
{
|
|
return((base == ERAD_CRC1_BASE) ||
|
|
(base == ERAD_CRC2_BASE) ||
|
|
(base == ERAD_CRC3_BASE) ||
|
|
(base == ERAD_CRC4_BASE) ||
|
|
(base == ERAD_CRC5_BASE) ||
|
|
(base == ERAD_CRC6_BASE) ||
|
|
(base == ERAD_CRC7_BASE) ||
|
|
(base == ERAD_CRC8_BASE));
|
|
}
|
|
|
|
#endif
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Gets the current owner of ERAD.
|
|
//!
|
|
//! \param None.
|
|
//!
|
|
//! This function returns the current owner of ERAD.
|
|
//!
|
|
//! \return Owner of ERAD.
|
|
//
|
|
//*****************************************************************************
|
|
static inline ERAD_Owner
|
|
ERAD_getOwnership(void)
|
|
{
|
|
//
|
|
// Read Global Owner register and return value
|
|
//
|
|
return((ERAD_Owner)((HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_OWNER) &
|
|
ERAD_GLBL_OWNER_OWNER_M) >> ERAD_GLBL_OWNER_OWNER_S));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Sets the current owner of ERAD.
|
|
//!
|
|
//! \param owner is the Owner of ERAD that is to be set
|
|
//!
|
|
//! This function sets the current owner of ERAD.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_setOwnership(ERAD_Owner owner)
|
|
{
|
|
//
|
|
// Set the Global Owner as owner
|
|
//
|
|
EALLOW;
|
|
HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_OWNER) =
|
|
((uint16_t)owner & ERAD_GLBL_OWNER_OWNER_M) << ERAD_GLBL_OWNER_OWNER_S;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Resets the counter using the global registers.
|
|
//!
|
|
//! \param instances is the OR'd value of counter instances to be reset.
|
|
//! Following macros can be used:
|
|
//! - \b ERAD_INST_COUNTER1
|
|
//! - \b ERAD_INST_COUNTER2
|
|
//! - \b ERAD_INST_COUNTER3
|
|
//! - \b ERAD_INST_COUNTER4
|
|
//!
|
|
//! This function resets the selected counters using the global registers.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_resetCounter(uint16_t instances)
|
|
{
|
|
//
|
|
// Resets the counter by writing into the global registers
|
|
//
|
|
EALLOW;
|
|
HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_CTM_RESET) |= instances >> 8U;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Enables counters and bus comparators.
|
|
//!
|
|
//! \param instances is the OR'd value of instances of the counters and bus
|
|
//! comparators. Following macros can be used:
|
|
//! - \b ERAD_INST_BUSCOMP1
|
|
//! - \b ERAD_INST_BUSCOMP2
|
|
//! - \b ERAD_INST_BUSCOMP3
|
|
//! - \b ERAD_INST_BUSCOMP4
|
|
//! - \b ERAD_INST_BUSCOMP5
|
|
//! - \b ERAD_INST_BUSCOMP6
|
|
//! - \b ERAD_INST_BUSCOMP7
|
|
//! - \b ERAD_INST_BUSCOMP8
|
|
//! - \b ERAD_INST_COUNTER1
|
|
//! - \b ERAD_INST_COUNTER2
|
|
//! - \b ERAD_INST_COUNTER3
|
|
//! - \b ERAD_INST_COUNTER4
|
|
//!
|
|
//! This function enables bus comparators and counters whose instances are
|
|
//! passed.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_enableModules(uint16_t instances)
|
|
{
|
|
//
|
|
// Write into Global register for enabling the required modules
|
|
//
|
|
EALLOW;
|
|
HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_ENABLE) |= instances;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Disables counters and bus comparators.
|
|
//!
|
|
//! \param instances is the OR'd value of instances of the counters and bus
|
|
//! comparators. Following macros can be used:
|
|
//! - \b ERAD_INST_BUSCOMP1
|
|
//! - \b ERAD_INST_BUSCOMP2
|
|
//! - \b ERAD_INST_BUSCOMP3
|
|
//! - \b ERAD_INST_BUSCOMP4
|
|
//! - \b ERAD_INST_BUSCOMP5
|
|
//! - \b ERAD_INST_BUSCOMP6
|
|
//! - \b ERAD_INST_BUSCOMP7
|
|
//! - \b ERAD_INST_BUSCOMP8
|
|
//! - \b ERAD_INST_COUNTER1
|
|
//! - \b ERAD_INST_COUNTER2
|
|
//! - \b ERAD_INST_COUNTER3
|
|
//! - \b ERAD_INST_COUNTER4
|
|
//!
|
|
//! This function disables bus comparators and counters whose instances are
|
|
//! passed.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_disableModules(uint16_t instances)
|
|
{
|
|
//
|
|
// Write into Global register for disabling the required modules
|
|
//
|
|
EALLOW;
|
|
HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_ENABLE) &= (~instances);
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Initialises ERAD.
|
|
//!
|
|
//! \param owner is the owner of ERAD that is to be set.
|
|
//!
|
|
//! This function resets all the counters and disables all bus comparators and
|
|
//! counters.
|
|
//! Also sets the owner of the ERAD to the required owner.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_initModule(ERAD_Owner owner)
|
|
{
|
|
//
|
|
// Set the owner of ERAD as required
|
|
//
|
|
ERAD_setOwnership(owner);
|
|
|
|
//
|
|
// Disable all counters and bus comparators
|
|
//
|
|
ERAD_disableModules(ERAD_INST_BUSCOMP1 | ERAD_INST_BUSCOMP2 |
|
|
ERAD_INST_BUSCOMP3 | ERAD_INST_BUSCOMP4 |
|
|
ERAD_INST_BUSCOMP5 | ERAD_INST_BUSCOMP6 |
|
|
ERAD_INST_BUSCOMP7 | ERAD_INST_BUSCOMP8 |
|
|
ERAD_INST_COUNTER1 | ERAD_INST_COUNTER2 |
|
|
ERAD_INST_COUNTER3 | ERAD_INST_COUNTER4);
|
|
|
|
//
|
|
// Reset all counters
|
|
//
|
|
ERAD_resetCounter(ERAD_INST_COUNTER1 | ERAD_INST_COUNTER2 |
|
|
ERAD_INST_COUNTER3 | ERAD_INST_COUNTER4);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Returns the completed status of any of the modules.
|
|
//!
|
|
//! \param None.
|
|
//!
|
|
//! This function returns the completed status of the counters and bus
|
|
//! comparators as stored in the global registers. This allows us to read just
|
|
//! one register and see if any of the modules are in a completed state.
|
|
//!
|
|
//! \return Completed status of all the modules as stored in the global
|
|
//! register.
|
|
//
|
|
//*****************************************************************************
|
|
static inline uint16_t
|
|
ERAD_getHaltStatus(void)
|
|
{
|
|
//
|
|
// Read and return from the global register
|
|
//
|
|
return(HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_HALT_STAT));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Returns the event fired status of any of the modules.
|
|
//!
|
|
//! \param None.
|
|
//!
|
|
//! This function returns the event fired status of the counters and bus
|
|
//! comparators as stored in the global registers. This allows us to read just
|
|
//! one register and see if any of the modules have fired.
|
|
//!
|
|
//! \return Event fired status of all the modules as stored in the global
|
|
//! register.
|
|
//
|
|
//*****************************************************************************
|
|
static inline uint16_t
|
|
ERAD_getEventStatus(void)
|
|
{
|
|
//
|
|
// Read and return from the global register
|
|
//
|
|
return(HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_EVENT_STAT));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Enables an NMI for the specified modules.
|
|
//!
|
|
//! \param instances is the OR'd value of the instances of the counters and
|
|
//! bus comparator units that need to have an NMI enabled. Following macros can
|
|
//! be used:
|
|
//! - \b ERAD_INST_BUSCOMP1
|
|
//! - \b ERAD_INST_BUSCOMP2
|
|
//! - \b ERAD_INST_BUSCOMP3
|
|
//! - \b ERAD_INST_BUSCOMP4
|
|
//! - \b ERAD_INST_BUSCOMP5
|
|
//! - \b ERAD_INST_BUSCOMP6
|
|
//! - \b ERAD_INST_BUSCOMP7
|
|
//! - \b ERAD_INST_BUSCOMP8
|
|
//! - \b ERAD_INST_COUNTER1
|
|
//! - \b ERAD_INST_COUNTER2
|
|
//! - \b ERAD_INST_COUNTER3
|
|
//! - \b ERAD_INST_COUNTER4
|
|
//!
|
|
//! This function enables an NMI to be generated whenever any of the specified
|
|
//! counters or bus comparator units generate and event.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_enableNMI(uint16_t instances)
|
|
{
|
|
EALLOW;
|
|
HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_NMI_CTL) |= instances;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Disables an NMI for the specified modules.
|
|
//!
|
|
//! \param instances is the OR'd value of the instances of the counters and
|
|
//! bus comparator units that need to have an NMI disabled. Following macros can
|
|
//! be used:
|
|
//! - \b ERAD_INST_BUSCOMP1
|
|
//! - \b ERAD_INST_BUSCOMP2
|
|
//! - \b ERAD_INST_BUSCOMP3
|
|
//! - \b ERAD_INST_BUSCOMP4
|
|
//! - \b ERAD_INST_BUSCOMP5
|
|
//! - \b ERAD_INST_BUSCOMP6
|
|
//! - \b ERAD_INST_BUSCOMP7
|
|
//! - \b ERAD_INST_BUSCOMP8
|
|
//! - \b ERAD_INST_COUNTER1
|
|
//! - \b ERAD_INST_COUNTER2
|
|
//! - \b ERAD_INST_COUNTER3
|
|
//! - \b ERAD_INST_COUNTER4
|
|
//!
|
|
//! This function disables the NMI for the specified counters and bus
|
|
//! comparator units.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_disableNMI(uint16_t instances)
|
|
{
|
|
EALLOW;
|
|
HWREGH(ERAD_GLOBAL_BASE + ERAD_O_GLBL_NMI_CTL) &= (~instances);
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Returns the status of a bus comparator.
|
|
//!
|
|
//! \param base is the base of the bus comparator.
|
|
//!
|
|
//! This function returns the status of the bus comparator whose base was
|
|
//! passed. It may be either \b ERAD_STATE_IDLE, \b ERAD_STATE_ENABLED or
|
|
//! \b ERAD_STATE_COMPLETED.
|
|
//!
|
|
//! \return Status of bus comparator.
|
|
//
|
|
//*****************************************************************************
|
|
static inline ERAD_Status
|
|
ERAD_getBusCompStatus(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidBusCompBase(base));
|
|
|
|
//
|
|
// Read and return status of bus comparator
|
|
//
|
|
return((ERAD_Status)((HWREGH(base + ERAD_O_HWBP_STATUS) &
|
|
ERAD_HWBP_STATUS_STATUS_M) >> ERAD_HWBP_STATUS_STATUS_S));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Clears the event fired status of any of the modules.
|
|
//!
|
|
//! \param base is the base of the bus comparator.
|
|
//!
|
|
//! This function clears the event fired status of the bus comparator and
|
|
//! brings the module and brings the module back to \b ERAD_STATE_IDLE .
|
|
//!
|
|
//! \return None
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_clearBusCompEvent(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidBusCompBase(base));
|
|
|
|
//
|
|
// Clear the event fired bit by writing into EVENT_CLR register
|
|
//
|
|
EALLOW;
|
|
HWREGH(base + ERAD_O_HWBP_CLEAR) = ERAD_HWBP_CLEAR_EVENT_CLR;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Returns the status of a counter.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//!
|
|
//! This function returns the status of the counter whose base was
|
|
//! passed. It may be either \b ERAD_STATE_IDLE, \b ERAD_STATE_ENABLED or
|
|
//! \b ERAD_STATE_COMPLETED.
|
|
//!
|
|
//! \return Status of counter.
|
|
//
|
|
//*****************************************************************************
|
|
static inline ERAD_Status
|
|
ERAD_getCounterStatus(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Read and return status of the counter
|
|
//
|
|
return((ERAD_Status)((HWREGH(base + ERAD_O_CTM_STATUS) &
|
|
ERAD_CTM_STATUS_STATUS_M) >> ERAD_CTM_STATUS_STATUS_S));
|
|
}
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the bus comparators.
|
|
//!
|
|
//! \param base is the base of the bus comparator to be configured.
|
|
//! \param config_params are the configuration parameters to be used to
|
|
//! configure the bus comparator.
|
|
//!
|
|
//! This function configures the bus comparator with the given parameters.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_configBusComp(uint32_t base, ERAD_BusComp_Config config_params);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the counter in Counting mode.
|
|
//!
|
|
//! \param base is the base of the counter to be configured.
|
|
//! \param config_params are the configuration parameters to be used to
|
|
//! configure the counter.
|
|
//!
|
|
//! This function configures the counter with the given parameters. The counter
|
|
//! is setup in Counting mode, which means counting begins as soon as the
|
|
//! counter is enabled.
|
|
//! NOTE: This function does not enable the counter. The counter must be
|
|
//! enabled using the \b ERAD_enableModules method to begin counting.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_configCounterInCountingMode(uint32_t base,
|
|
ERAD_Counter_Config config_params);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the counter in Start-Stop mode.
|
|
//!
|
|
//! \param base is the base of the counter to be configured.
|
|
//! \param config_params are the configuration parameters to be used to
|
|
//! configure the counter.
|
|
//! \param start_event is the event that starts the counter
|
|
//! \param stop_event is the event which stops that counter
|
|
//!
|
|
//! This function configures the counter with the given parameters. The counter
|
|
//! is setup in Start-Stop mode, which means counting will happen only between
|
|
//! two specified events. The event that will be counted can be any of the
|
|
//! \b ERAD_Counter_Input_Event and not only CPU cycles.
|
|
//! NOTE: \b ERAD_EVENT_NO_EVENT causes the counter to use the CPU cycles.
|
|
//! NOTE: This function does not enable the counter. The counter must be
|
|
//! enabled using the \b ERAD_enableModules method to begin counting.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_configCounterInStartStopMode(uint32_t base,
|
|
ERAD_Counter_Config config_params,
|
|
ERAD_Counter_Input_Event start_event,
|
|
ERAD_Counter_Input_Event stop_event);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the counter in Start-Stop Cumulative mode.
|
|
//!
|
|
//! \param base is the base of the counter to be configured.
|
|
//! \param config_params are the configuration parameters to be used to
|
|
//! configure the counter.
|
|
//! \param start_event is the event that starts the counter
|
|
//! \param stop_event is the event which stops that counter
|
|
//!
|
|
//! This function configures the counter with the given parameters. The counter
|
|
//! is setup in Cumulative mode, which means counting will happen only between
|
|
//! two specified events and the counter will not reset on \b stop_event. The
|
|
//! event that will be counted can be any of the \b ERAD_Counter_Input_Event
|
|
//! and not only CPU cycles.
|
|
//! NOTE: \b ERAD_EVENT_NO_EVENT causes the counter to use the CPU cycles.
|
|
//! NOTE: This function does not enable the counter. The counter must be
|
|
//! enabled using the \b ERAD_enableModules method to begin counting.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_configCounterInCumulativeMode(uint32_t base,
|
|
ERAD_Counter_Config config_params,
|
|
ERAD_Counter_Input_Event start_event,
|
|
ERAD_Counter_Input_Event stop_event);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the AND and OR masks
|
|
//!
|
|
//! \param mask is the Mask to be used.
|
|
//!
|
|
//! \param instances is the OR'd value of the instances of the bus comparator
|
|
//! units whose events need to be used for the mask. Following macros can be
|
|
//! used:
|
|
//! - \b ERAD_INST_BUSCOMP1
|
|
//! - \b ERAD_INST_BUSCOMP2
|
|
//! - \b ERAD_INST_BUSCOMP3
|
|
//! - \b ERAD_INST_BUSCOMP4
|
|
//! - \b ERAD_INST_BUSCOMP5
|
|
//! - \b ERAD_INST_BUSCOMP6
|
|
//! - \b ERAD_INST_BUSCOMP7
|
|
//! - \b ERAD_INST_BUSCOMP8
|
|
//! - \b ERAD_INST_COUNTER1
|
|
//! - \b ERAD_INST_COUNTER2
|
|
//! - \b ERAD_INST_COUNTER3
|
|
//! - \b ERAD_INST_COUNTER4
|
|
//!
|
|
//! \param enable_int True if interrupt needs to be enabled, False if not
|
|
//!
|
|
//! This function enables the event generated from the specified bus comparator
|
|
//! units to be used for the specified Mask. It also configures the interrupt
|
|
//! generation when the mask event occurs.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_configMask(ERAD_Mask mask, uint32_t instances, bool enable_int);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the reset event of the counter.
|
|
//!
|
|
//! \param base is the base of the counter to be configured.
|
|
//! \param reset_event is the event upon which the counter must be reset.
|
|
//!
|
|
//! This function sets the event upon which the counter must reset and enables
|
|
//! reset upon such an event.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_enableCounterResetInput(uint32_t base,
|
|
ERAD_Counter_Input_Event reset_event)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Setup up the counter such that the reset event is set and enabled
|
|
//
|
|
EALLOW;
|
|
HWREG(base + ERAD_O_CTM_CNTL) |= ERAD_CTM_CNTL_RST_EN;
|
|
HWREG(base + ERAD_O_CTM_INPUT_SEL_2) =
|
|
(HWREG(base + ERAD_O_CTM_INPUT_SEL_2) &
|
|
~ERAD_CTM_INPUT_SEL_2_RST_INP_SEL_M) |
|
|
((uint16_t)reset_event << ERAD_CTM_INPUT_SEL_2_RST_INP_SEL_S);
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Disables the reset event of the counter.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//!
|
|
//! This function disables the reset event that may have been set earlier
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_disableCounterResetInput(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Disable the reset bit
|
|
//
|
|
EALLOW;
|
|
HWREGH(base + ERAD_O_CTM_CNTL) &= (~ERAD_CTM_CNTL_RST_EN);
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Clears an event that may have fired in the counter upon match.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//!
|
|
//! This function clears a counter event that may have fired when the counter
|
|
//! hit a match.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_clearCounterEvent(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Clear the event by writing into CTM_CLEAR register
|
|
//
|
|
EALLOW;
|
|
HWREGH(base + ERAD_O_CTM_CLEAR) = ERAD_CTM_CLEAR_EVENT_CLEAR;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Clears an overflow that may have occured in the counter.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//!
|
|
//! This function clears the overflow bit that may have got set when the
|
|
//! counter may have crossed 0xFFFFFFFF.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_clearCounterOverflow(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Clear the overflow bit by writing into the CTM_CLEAR register
|
|
//
|
|
EALLOW;
|
|
HWREGH(base + ERAD_O_CTM_CLEAR) = ERAD_CTM_CLEAR_OVERFLOW_CLEAR;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Gets the current count of a counter.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//!
|
|
//! This function returns the current count of the counter which was
|
|
//! configured earlier.
|
|
//!
|
|
//! \return Returns the value of the current count of the counter.
|
|
//
|
|
//*****************************************************************************
|
|
static inline uint32_t
|
|
ERAD_getCurrentCount(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Return the current count
|
|
//
|
|
return(HWREG(base + ERAD_O_CTM_COUNT));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Sets the current count of a counter.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//! \param value is the value to be written as the current count.
|
|
//!
|
|
//! This function sets the current count of the counter which was
|
|
//! configured earlier. This can be used to reset the counter or start at
|
|
//! a value other than 0.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_setCurrentCount(uint32_t base, uint32_t value)
|
|
{
|
|
//
|
|
// Check if owner is APPLICATION or NO_OWNER
|
|
//
|
|
ASSERT((ERAD_getOwnership() == ERAD_OWNER_APPLICATION) ||
|
|
(ERAD_getOwnership() == ERAD_OWNER_NOOWNER));
|
|
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Write the value into CTM_COUNT register
|
|
//
|
|
EALLOW;
|
|
HWREG(base + ERAD_O_CTM_COUNT) = value;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Gets the maximum count of a counter.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//!
|
|
//! This function returns the current maximum count of the counter which was
|
|
//! configured earlier.
|
|
//!
|
|
//! \return Returns the value of the current maximum count of the counter.
|
|
//
|
|
//*****************************************************************************
|
|
static inline uint32_t
|
|
ERAD_getMaxCount(uint32_t base)
|
|
{
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Return the maximum value
|
|
//
|
|
return(HWREG(base + ERAD_O_CTM_MAX_COUNT));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Sets the maximum count of a counter.
|
|
//!
|
|
//! \param base is the base of the counter.
|
|
//! \param value is the value to be written as the maximum count.
|
|
//!
|
|
//! This function sets the current maximum count of the counter which was
|
|
//! configured earlier.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_setMaxCount(uint32_t base, uint32_t value)
|
|
{
|
|
//
|
|
// Check if owner is APPLICATION or NO_OWNER
|
|
//
|
|
ASSERT((ERAD_getOwnership() == ERAD_OWNER_APPLICATION) ||
|
|
(ERAD_getOwnership() == ERAD_OWNER_NOOWNER));
|
|
|
|
//
|
|
// Check if the base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCounterBase(base));
|
|
|
|
//
|
|
// Write the value into the CTM_MAX_COUNT register
|
|
//
|
|
EALLOW;
|
|
HWREG(base + ERAD_O_CTM_MAX_COUNT) = value;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Sets conditioning on the inputs to the counter.
|
|
//!
|
|
//! \param base is the base value of the counter to be configured
|
|
//! \param input_type defines which input needs to be conditioned
|
|
//! \param options is the kind of conditioning that needs to applied. This will
|
|
//! be an OR'd value of \b ERAD_INVERT_ENABLE, \b ERAD_INVERT_DISABLE,
|
|
//! \b ERAD_SYNC_ENABLE or \b ERAD_SYNC_DISABLE.
|
|
//!
|
|
//! This function conditions the inputs to the counter specified. This includes
|
|
//! inverting the input and enabling a 2-stage synchronizer for any 4 of the
|
|
//! inputs: \e reset, \e stop, \e start, \e count_input.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_setCounterInputConditioning(uint32_t base,
|
|
ERAD_Counter_Input_Type input_type,
|
|
uint16_t options)
|
|
{
|
|
//
|
|
// Write into the Input Conditioning register
|
|
//
|
|
EALLOW;
|
|
HWREGH(base + ERAD_O_CTM_INPUT_COND) =
|
|
(HWREGH(base + ERAD_O_CTM_INPUT_COND) &
|
|
~(0x03U << (uint16_t)input_type)) | (options << input_type);
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Initialises the CRC unit.
|
|
//!
|
|
//! \param instances is the OR'd value of CRC instances. Following macros can
|
|
//! be used:
|
|
//! - \b ERAD_INST_CRC1
|
|
//! - \b ERAD_INST_CRC2
|
|
//! - \b ERAD_INST_CRC3
|
|
//! - \b ERAD_INST_CRC4
|
|
//! - \b ERAD_INST_CRC5
|
|
//! - \b ERAD_INST_CRC6
|
|
//! - \b ERAD_INST_CRC7
|
|
//! - \b ERAD_INST_CRC8
|
|
//!
|
|
//! This function initialises the specified CRC units.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_initCRC(uint16_t instances)
|
|
{
|
|
//
|
|
// Write into the CRC GLOBAL CTRL register
|
|
//
|
|
EALLOW;
|
|
HWREGH(ERAD_CRC_GLOBAL_BASE + ERAD_O_CRC_GLOBAL_CTRL) |= instances;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Enables the CRC unit.
|
|
//!
|
|
//! \param instances is the OR'd value of CRC instances. Following macros can
|
|
//! be used:
|
|
//! - \b ERAD_INST_CRC1
|
|
//! - \b ERAD_INST_CRC2
|
|
//! - \b ERAD_INST_CRC3
|
|
//! - \b ERAD_INST_CRC4
|
|
//! - \b ERAD_INST_CRC5
|
|
//! - \b ERAD_INST_CRC6
|
|
//! - \b ERAD_INST_CRC7
|
|
//! - \b ERAD_INST_CRC8
|
|
//!
|
|
//! This function enables the specified CRC units.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_enableCRC(uint16_t instances)
|
|
{
|
|
//
|
|
// Write into the CRC GLOBAL CTRL register
|
|
//
|
|
EALLOW;
|
|
HWREGH(ERAD_CRC_GLOBAL_BASE + ERAD_O_CRC_GLOBAL_CTRL) |= instances << 8;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Disables the CRC unit.
|
|
//!
|
|
//! \param instances is the OR'd value of CRC instances. Following macros can
|
|
//! be used:
|
|
//! - \b ERAD_INST_CRC1
|
|
//! - \b ERAD_INST_CRC2
|
|
//! - \b ERAD_INST_CRC3
|
|
//! - \b ERAD_INST_CRC4
|
|
//! - \b ERAD_INST_CRC5
|
|
//! - \b ERAD_INST_CRC6
|
|
//! - \b ERAD_INST_CRC7
|
|
//! - \b ERAD_INST_CRC8
|
|
//!
|
|
//! This function disables the specified CRC units.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_disableCRC(uint16_t instances)
|
|
{
|
|
//
|
|
// Write into the CRC GLOBAL CTRL register
|
|
//
|
|
EALLOW;
|
|
HWREGH(ERAD_CRC_GLOBAL_BASE + ERAD_O_CRC_GLOBAL_CTRL) &= ~(instances << 8);
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Gets the current value of the CRC unit.
|
|
//!
|
|
//! \param base is the base value of CRC unit
|
|
//!
|
|
//! This function returns the current value of te specified CRC unit.
|
|
//!
|
|
//! \return Current CRC value.
|
|
//
|
|
//*****************************************************************************
|
|
static inline uint32_t
|
|
ERAD_getCurrentCRC(uint32_t base)
|
|
{
|
|
//
|
|
// Check if base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCRCBase(base));
|
|
|
|
//
|
|
// Read from the current value register of the specified CRC unit
|
|
//
|
|
return(HWREG(base + ERAD_O_CRC_CURRENT));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Sets the seed value of the CRC unit
|
|
//!
|
|
//! \param base is the base value of the CRC unit
|
|
//! \param seed is the value of seed to be set
|
|
//!
|
|
//! This function sets a seed value of the CRC unit.
|
|
//! Note: The corresponding CRC unit must be disabled before setting the seed
|
|
//! value.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_setSeed(uint32_t base, uint32_t seed)
|
|
{
|
|
//
|
|
// Check if base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCRCBase(base));
|
|
|
|
//
|
|
// Check if the unit is disabled
|
|
//
|
|
ASSERT((HWREGH(ERAD_CRC_GLOBAL_BASE + ERAD_O_CRC_GLOBAL_CTRL) &
|
|
ERAD_getCRCInstance(base)) == 0U);
|
|
|
|
//
|
|
// Write into the CRC SEED register
|
|
//
|
|
EALLOW;
|
|
HWREGH(base + ERAD_O_CRC_SEED) = seed;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Sets the qualifier event of the CRC unit
|
|
//!
|
|
//! \param base is the base value of the CRC unit
|
|
//! \param qualifier is the type of qualifier to be set
|
|
//!
|
|
//! This function sets a qualifier to decide which events require a CRC
|
|
//! computation.
|
|
//! Note: The corresponding CRC unit must be disabled before setting the
|
|
//! qualifier.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
static inline void
|
|
ERAD_setCRCQualifier(uint32_t base, ERAD_CRC_Qualifiers qualifier)
|
|
{
|
|
//
|
|
// Check if base is valid
|
|
//
|
|
ASSERT(ERAD_isValidCRCBase(base));
|
|
|
|
//
|
|
// Check if the unit is disabled
|
|
//
|
|
ASSERT((HWREGH(ERAD_CRC_GLOBAL_BASE + ERAD_O_CRC_GLOBAL_CTRL) &
|
|
ERAD_getCRCInstance(base)) == 0U);
|
|
|
|
//
|
|
// Write into the CRC Qualifier register
|
|
//
|
|
EALLOW;
|
|
HWREGH(base + ERAD_O_CRC_QUALIFIER) = qualifier;
|
|
EDIS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the ERAD to profile a certain piece of code
|
|
//!
|
|
//! \param config_params are the parameters that will be used to configure ERAD
|
|
//!
|
|
//! This function configures 2 bus comparators and 1 counter to profile a
|
|
//! certain piece of code. The base address of the bus comparators and the
|
|
//! counter to be used are specified in \e config_params.
|
|
//! Note: Use \b ERAD_getMaxCount to get the latest profiled value. The
|
|
//! maximum count of the counter being used must be reset to 0x0 to get the
|
|
//! correct value everytime.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_profile(ERAD_Profile_Params config_params);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Enables an RTOS interrupt at a specified address.
|
|
//!
|
|
//! \param config_params contrains the bus to be monitored and the address
|
|
//! \param busComp_base is the base of the bus compoarator to be used
|
|
//!
|
|
//! This function enables an RTOS interrupt to be generated when an address
|
|
//! in memory or instruction is hit.
|
|
//!
|
|
//! If the selected bus is \b ERAD_BUSCOMP_BUS_PAB, then the ERAD will be
|
|
//! configured to trigger an interrupt when there is instruction fetch happening
|
|
//! at the specified address. Similary, if \b ERAD_BUSCOMP_BUS_DWAB is selected,
|
|
//! the ERAD will be configured to trigger an interrupt when there write
|
|
//! access to the specified address, and so on.
|
|
//!
|
|
//! Use \e
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_enableInterruptOnAddressHit(ERAD_AddressHit_Params config_params,
|
|
uint32_t busComp_base);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Configures the ERAD to count the number of times a the specified address
|
|
//! is hit
|
|
//!
|
|
//! \param config_params are the parameters that will be used to configure ERAD
|
|
//! \param busComp_base is the base of the bus compoarator to be used
|
|
//! \param counter_base is the base of the counter to be used
|
|
//!
|
|
//! This function configures 1 bus comparator and 1 counter to count how many
|
|
//! times a the specified address is hit.
|
|
//!
|
|
//! If the selected bus is \b ERAD_BUSCOMP_BUS_PAB, then the ERAD will be
|
|
//! configured to count the number of times an instruction fetch happens
|
|
//! at the specified address. Similary, if \b ERAD_BUSCOMP_BUS_DWAB is selected,
|
|
//! the ERAD will be configured to count the number of times there is a write
|
|
//! access to the specified address, and so on.
|
|
//!
|
|
//! \return None.
|
|
//
|
|
//*****************************************************************************
|
|
extern void
|
|
ERAD_countAddressHits(ERAD_AddressHit_Params config_params,
|
|
uint32_t busComp_base, uint32_t counter_base);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Close the Doxygen group.
|
|
//! @}
|
|
//
|
|
//*****************************************************************************
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Mark the end of the C bindings section for C++ compilers.
|
|
//
|
|
//*****************************************************************************
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // ERAD_H
|