To increase functional and system reliability, the memories in many device modules and subsystems are protected by Error Correcting Code (ECC), which performs Single Error Correction (SEC) and Double Error Detection (DED). Detected errors are reported via ESM. Single bit errors are corrected, and double bit errors are detected. The ECC Aggregator is connected to these memory and interconnect components which have the ECC. The ECC aggregator provides access to control and monitor the ECC protected memories in a module or subsystem.
SDL provides support for ECC aggregator configuration. Each ECC aggregator instance can be independently configured through the same SDL API by passing a different instance. The safety manual also defines test-for-diagnostics for the various IPs with ECC/parity support. The SDL also provides the support for executing ECC aggregator self-tests, using the error injection feature of the ECC aggregator. The ECC aggregators should be configured at startup, after running BIST.
Features Supported
The SDL provides support for the ECC through:
- ECC Configuration API
- ECC self-test API
- ECC error injection API
- ECC static register readback API
ECC error status APIs
The SDL ECC module requires a mapping of certain aggregator registers into the address space of the R5F Core. In these cases, the ECC module will use the DPL API SDL_DPL_addrTranslate() to get the address. The application must provide the mapped address through this call. This mapping is required for any ECC aggregator that is used which has an address which is not in the 32-bit address space. The mapping is expected to always be valid because it may be needed at runtime to get information about ECC errors that may be encountered.
There are over 40 ECC aggregators on the device each supporting multiple memories and interconnects.
Error Injection for Various RAM ID types
There are two types of ECC aggregator RAM IDs supported on the device (wrapper and interconnect). The wrapper types are used for memories where local computations are performed for particular processing cores in the device, and the interconnect types are utilized for interconnect bus signals between cores or to/from peripherals.
For wrapper RAM ID types, after injecting an error, the memory associated with that RAM ID needs to be accessed in order to trigger the error interrupt event. It is the application's responsibility to trigger the error event through memory access after injecting the error.
SysConfig Features
Features NOT Supported
Important Usage Guidelines
Example Usage of R5F ATCM0
The following shows an example of SDL R5F ECC API usage by the application for Error Injection Tests and Exception handling.
Include the below file to access the APIs
#include <sdl/r5/v0/interrupt.h>
#include "ecc_main.h"
Below are the macros specifies the RAM address, ECC aggregator and ECC aggregator RAMID for inject the ECC error
#define SDL_EXAMPLE_ECC_RAM_ADDR (0x00000510u) // R5F ATCM0 RAM address
#define SDL_EXAMPLE_ECC_AGGR SDL_R5FSS0_CORE0_ECC_AGGR
#define SDL_EXAMPLE_ECC_RAM_ID SDL_R5FSS0_CORE0_ECC_AGGR_PULSAR_SL_ATCM0_BANK0_RAM_ID
ESM callback function
This is the list of exception handle and the parameters
{
.udefExptnHandlerArgs = ((void *)0u),
.swiExptnHandlerArgs = ((void *)0u),
.pabtExptnHandlerArgs = ((void *)0u),
.dabtExptnHandlerArgs = ((void *)0u),
.irqExptnHandlerArgs = ((void *)0u),
};
Below are the functions used to print the which exception is occured
void ECC_Test_undefInstructionExptnCallback(void)
{
printf("\r\nUndefined Instruction exception\r\n");
}
void ECC_Test_swIntrExptnCallback(void)
{
printf("\r\nSoftware interrupt exception\r\n");
}
void ECC_Test_prefetchAbortExptnCallback(void)
{
printf("\r\nPrefetch Abort exception\r\n");
}
void ECC_Test_dataAbortExptnCallback(void)
{
printf("\r\nData Abort exception\r\n");
}
void ECC_Test_irqExptnCallback(void)
{
printf("\r\nIrq exception\r\n");
}
void ECC_Test_fiqExptnCallback(void)
{
printf("\r\nFiq exception\r\n");
}
Initilize Exception handler
void ECC_Test_exceptionInit(void)
{
{
.swiExptnCallback = ECC_Test_swIntrExptnCallback,
.pabtExptnCallback = ECC_Test_prefetchAbortExptnCallback,
.dabtExptnCallback = ECC_Test_dataAbortExptnCallback,
.irqExptnCallback = ECC_Test_irqExptnCallback,
.fiqExptnCallback = ECC_Test_fiqExptnCallback,
};
return;
}
This structure defines the elements of ECC Init configuration
static SDL_ECC_MemSubType ECC_Test_R5FSS0_CORE0_subMemTypeList[SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS] =
{
SDL_EXAMPLE_ECC_RAM_ID,
};
{
.
numRams = SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS,
.pMemSubTypeList = &(ECC_Test_R5FSS0_CORE0_subMemTypeList[0]),
};
Enabling the ECC module
Enabling the Event bus
Initialize ECC memory for the ECC aggregator
Initialize ECC parameters for single and double bit error injection
result =
SDL_ECC_init(SDL_EXAMPLE_ECC_AGGR, &ECC_Test_R5FSS0_CORE0_ECCInitConfig);
Execute ECC R5F ATCM0 single bit inject test
int32_t ECC_Test_run_R5FSS0_CORE0_ATCM0_BANK0_1BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nR5FSS0 CORE0 ATCM0 BANK0 Single bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
retVal = -1;
} else {
testLocationValue = injectErrorConfig.
pErrMem[0];
DebugP_log(
"\r\nR5FSS0 CORE0 ATCM0 BANK0 Single bit error inject at pErrMem = 0x%p and the value of pErrMem is 0x%p :test complete\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Execute ECC R5F ATCM0 double bit inject test
int32_t ECC_Test_run_R5FSS0_CORE0_ATCM0_BANK0_2BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nR5FSS0 CORE0 ATCM0 BANK0 Double bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
retVal = -1;
} else {
testLocationValue = injectErrorConfig.
pErrMem[0];
DebugP_log(
"\r\nR5FSS0 CORE0 ATCM0 BANK0 Double bit error inject: pErrMem fixed location = 0x%p once test complete: the value of pErrMem is 0x%p\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Example Usage of R5F BTCM
The following shows an example of SDL R5F ECC API usage by the application for Error Injection Tests and Exception handling.
Include the below file to access the APIs
#include <sdl/r5/v0/interrupt.h>
#include "ecc_main.h"
Below are the macros specifies the RAM address, ECC aggregator and ECC aggregator RAMID for inject the ECC error
#if SDL_B0TCM0_BANK0
#define SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS (1u)
#define SDL_EXAMPLE_ECC_RAM_ADDR (0x00080010u)
#define SDL_EXAMPLE_ECC_AGGR SDL_R5FSS0_CORE0_ECC_AGGR
#define SDL_EXAMPLE_ECC_RAM_ID SDL_R5FSS0_CORE0_ECC_AGGR_PULSAR_SL_B0TCM0_BANK0_RAM_ID
#endif
#if SDL_B0TCM0_BANK1
#define SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS (1u)
#define SDL_EXAMPLE_ECC_RAM_ADDR (0x00081510u)
#define SDL_EXAMPLE_ECC_AGGR SDL_R5FSS0_CORE0_ECC_AGGR
#define SDL_EXAMPLE_ECC_RAM_ID SDL_R5FSS0_CORE0_ECC_AGGR_PULSAR_SL_B0TCM0_BANK1_RAM_ID
#endif
#if SDL_B1TCM0_BANK0
#define SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS (1u)
#define SDL_EXAMPLE_ECC_RAM_ADDR (0x00082510u)
#define SDL_EXAMPLE_ECC_AGGR SDL_R5FSS0_CORE0_ECC_AGGR
#define SDL_EXAMPLE_ECC_RAM_ID SDL_R5FSS0_CORE0_ECC_AGGR_PULSAR_SL_B1TCM0_BANK0_RAM_ID
#endif
#if SDL_B1TCM0_BANK1
#define SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS (1u)
#define SDL_EXAMPLE_ECC_RAM_ADDR (0x00083510u)
#define SDL_EXAMPLE_ECC_AGGR SDL_R5FSS0_CORE0_ECC_AGGR
#define SDL_EXAMPLE_ECC_RAM_ID SDL_R5FSS0_CORE0_ECC_AGGR_PULSAR_SL_B1TCM0_BANK1_RAM_ID
#endif
ESM callback function
This is the list of exception handle and the parameters
{
.udefExptnHandlerArgs = ((void *)0u),
.swiExptnHandlerArgs = ((void *)0u),
.pabtExptnHandlerArgs = ((void *)0u),
.dabtExptnHandlerArgs = ((void *)0u),
.irqExptnHandlerArgs = ((void *)0u),
};
Below are the functions used to print the which exception is occured
void ECC_Test_undefInstructionExptnCallback(void)
{
printf("\r\nUndefined Instruction exception\r\n");
}
void ECC_Test_swIntrExptnCallback(void)
{
printf("\r\nSoftware interrupt exception\r\n");
}
void ECC_Test_prefetchAbortExptnCallback(void)
{
printf("\r\nPrefetch Abort exception\r\n");
}
void ECC_Test_dataAbortExptnCallback(void)
{
printf("\r\nData Abort exception\r\n");
}
void ECC_Test_irqExptnCallback(void)
{
printf("\r\nIrq exception\r\n");
}
void ECC_Test_fiqExptnCallback(void)
{
printf("\r\nFiq exception\r\n");
}
Initilize Exception handler
void ECC_Test_exceptionInit(void)
{
{
.swiExptnCallback = ECC_Test_swIntrExptnCallback,
.pabtExptnCallback = ECC_Test_prefetchAbortExptnCallback,
.dabtExptnCallback = ECC_Test_dataAbortExptnCallback,
.irqExptnCallback = ECC_Test_irqExptnCallback,
.fiqExptnCallback = ECC_Test_fiqExptnCallback,
};
return;
}
This structure defines the elements of ECC Init configuration
static SDL_ECC_MemSubType ECC_Test_R5FSS0_CORE0_subMemTypeList[SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS] =
{
SDL_EXAMPLE_ECC_RAM_ID,
};
{
.
numRams = SDL_R5FSS0_CORE0_MAX_MEM_SECTIONS,
.pMemSubTypeList = &(ECC_Test_R5FSS0_CORE0_subMemTypeList[0]),
};
Enabling the ECC module
#if (SDL_B0TCM0_BANK0) || (SDL_B0TCM0_BANK1)
#endif
#if (SDL_B1TCM0_BANK0) || (SDL_B1TCM0_BANK1)
#endif
Enabling the Event bus
Initialize ECC memory for the ECC aggregator
Initialize ECC parameters for single and double bit error injection
result =
SDL_ECC_init(SDL_EXAMPLE_ECC_AGGR, &ECC_Test_R5FSS0_CORE0_ECCInitConfig);
Execute ECC R5F BTCM single bit inject test
int32_t ECC_Test_run_R5FSS0_CORE0_BTCM_1BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nR5FSS0 CORE0 BTCM Single bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
retVal = -1;
} else {
testLocationValue = injectErrorConfig.
pErrMem[0];
DebugP_log(
"\r\nR5FSS0 CORE0 BTCM Single bit error inject at pErrMem = 0x%p and the value of pErrMem is 0x%p :test complete\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Execute ECC R5F BTCM double bit inject test
int32_t ECC_Test_run_R5FSS0_CORE0_BTCM_2BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nR5FSS0 CORE0 BTCM Double bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
retVal = -1;
} else {
testLocationValue = injectErrorConfig.
pErrMem[0];
DebugP_log(
"\r\nR5FSS0 CORE0 BTCM Double bit error inject: pErrMem fixed location = 0x%p once test complete: the value of pErrMem is 0x%p\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Example Usage of MSS L2
The following shows an example of SDL MSS L2 API usage by the application for Error Injection Tests and Exception handling.
Include the below file to access the APIs
Below are the macros specifies the RAM address, ECC aggregator and ECC aggregator RAMID for inject the ECC error
ESM callback function
This structure defines the elements of ECC Init configuration
{
SDL_EXAMPLE_ECC_RAM_ID,
};
{
.
numRams = SDL_MSS_L2_MAX_MEM_SECTIONS,
.pMemSubTypeList = &(ECC_Test_MSS_L2_subMemTypeList[0]),
};
Event BitMap for ECC ESM callback for MSS
Initialization of MSS L2 memory
Clearing any old interrupt presented
Initialize ECC memory for the ECC aggregator
Initialize ECC parameters for single and double bit error injection
result =
SDL_ECC_init(SDL_EXAMPLE_ECC_AGGR, &ECC_Test_MSS_ECCInitConfig);
Execute ECC MSS L2 single bit inject test
int32_t ECC_Test_run_MSS_L2RAMB_1BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nMSS L2 RAMB Single bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
retVal = -1;
} else {
testLocationValue = injectErrorConfig.
pErrMem[0];
DebugP_log(
"\r\nMSS L2 RAMB Single bit error inject at pErrMem = 0x%p and the value of pErrMem is 0x%p :test complete\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Initialization of MSS L2 memory
SDL_REG32_WR(SDL_MSS_L2_MEM_INIT_ADDR, SDL_ECC_MSS_L2_BANK_MEM_INIT);
while(
SDL_REG32_RD(SDL_MSS_L2_MEM_INIT_DONE_ADDR)!=SDL_ECC_MSS_L2_BANK_MEM_INIT);
SDL_REG32_WR(SDL_MSS_L2_MEM_INIT_DONE_ADDR, SDL_ECC_MSS_L2_BANK_MEM_INIT);
Clearing any old interrupt presented
Execute ECC MSS L2 double bit inject test
int32_t ECC_Test_run_MSS_L2RAMB_2BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nMSS L2 RAMB Double bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
testLocationValue = injectErrorConfig.
pErrMem[0];
if (result != SDL_PASS ) {
retVal = -1;
} else {
DebugP_log(
"\r\nMSS L2 RAMB Double bit error inject: pErrMem fixed location = 0x%p once test complete: the value of pErrMem is 0x%p\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Example Usage of MSS TPTC
The following shows an example of SDL MSS TPTC API usage by the application for Error Injection Tests and Exception handling.
Include the below file to access the APIs
#include <drivers/edma.h>
#include "ti_drivers_config.h"
#include "ti_drivers_open_close.h"
#include "ti_board_open_close.h"
#include "ecc_main.h"
Below are the macros specifies the ECC aggregator and ECC aggregator RAMID for inject the ECC error
ESM callback function
This structure defines the elements of ECC Init configuration
{
SDL_EXAMPLE_ECC_RAM_ID,
};
{
.
numRams = SDL_MSS_MAX_MEM_SECTIONS,
.pMemSubTypeList = &(ECC_Test_MSS_subMemTypeList[0]),
};
Event BitMap for ECC ESM callback for MSS
Initialization of EDMA and ECC injection
testResult = edma_interrupt_transfer(CONFIG_EDMA0, SDL_ECC_SEC, 0u, EDMA_MSS_TPCC_A_EVT_FREE_0);
Initialize EDMA
EDMA_Init();
DebugP_log(
"\r\n[EDMA] Interrupt Transfer Test Started...\r\n");
baseAddr = EDMA_getBaseAddr(gEdmaHandle[edmaConfigNum]);
regionId = EDMA_getRegionId(gEdmaHandle[edmaConfigNum]);
dmaCh = channelEvent;
status = EDMA_allocDmaChannel(gEdmaHandle[edmaConfigNum], &dmaCh);
tcc = channelEvent;
status = EDMA_allocTcc(gEdmaHandle[edmaConfigNum], &tcc);
param = channelEvent;
status = EDMA_allocParam(gEdmaHandle[edmaConfigNum], ¶m);
Initialize ECC memory for the ECC aggregator
Initialize ECC parameters for single and double bit error injection
result =
SDL_ECC_init(SDL_EXAMPLE_ECC_AGGR, &ECC_Test_MSS_ECCInitConfig);
Execute ECC MSS TPTC single bit inject test
int32_t ECC_Test_run_MSS_TPTC_A0_1Bit_InjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
DebugP_log(
"\n MSS TPTC_A0 Single bit error inject: test starting");
injectErrorConfig.
pErrMem = (uint32_t *)(0x0u);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
DebugP_log(
"\n MSS TPTC_A0 Single bit error inject at pErrMem 0x%p test failed",
retVal = -1;
} else {
DebugP_log(
"\n MSS TPTC_A0 Single bit error inject at pErrMem 0x%p",
}
return retVal;
}
Execute ECC MSS TPTC double bit inject test
int32_t ECC_Test_run_MSS_TPTC_A0_2Bit_InjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
DebugP_log(
"\n MSS TPTC_A0 Double bit error inject: starting");
injectErrorConfig.
pErrMem = (uint32_t *)(0x0u);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
DebugP_log(
"\n MSS TPTC_A0 Double bit error inject: at pErrMem 0x%p: fixed location once test failed",
retVal = -1;
} else {
DebugP_log(
"\n MSS TPTC_A0 Double bit error inject at pErrMem 0x%p ",
}
return retVal;
}
Initialize the source address with a pattern and initialize dst address with zero/another pattern (optional)
srcBuffPtr = (uint8_t *) gEdmaTestSrcBuff;
dstBuffPtr = (uint8_t *) gEdmaTestDstBuff;
for(loopCnt = 0U; loopCnt < EDMA_TEST_BUFFER_SIZE; loopCnt++)
{
srcBuffPtr[loopCnt] = (uint8_t)loopCnt;
dstBuffPtr[loopCnt] = 0;
}
EDMA_configureChannelRegion(baseAddr, regionId, EDMA_CHANNEL_TYPE_DMA,
dmaCh, tcc, param, queueType);
EDMA_ccPaRAMEntry_init(&edmaParam);
edmaParam.aCnt = (uint16_t) EDMA_TEST_A_COUNT;
edmaParam.bCnt = (uint16_t) EDMA_TEST_B_COUNT;
edmaParam.cCnt = (uint16_t) EDMA_TEST_C_COUNT;
edmaParam.bCntReload = (uint16_t) EDMA_TEST_B_COUNT;
edmaParam.srcBIdx = (int16_t) EDMA_PARAM_BIDX(EDMA_TEST_A_COUNT);
edmaParam.destBIdx = (int16_t) EDMA_PARAM_BIDX(EDMA_TEST_A_COUNT);
edmaParam.srcCIdx = (int16_t) EDMA_TEST_A_COUNT;
edmaParam.destCIdx = (int16_t) EDMA_TEST_A_COUNT;
edmaParam.linkAddr = 0xFFFFU;
edmaParam.srcBIdxExt = (int8_t) EDMA_PARAM_BIDX_EXT(EDMA_TEST_A_COUNT);
edmaParam.destBIdxExt = (int8_t) EDMA_PARAM_BIDX_EXT(EDMA_TEST_A_COUNT);
edmaParam.opt |=
(EDMA_OPT_TCINTEN_MASK | EDMA_OPT_ITCINTEN_MASK |
((((uint32_t)tcc) << EDMA_OPT_TCC_SHIFT) & EDMA_OPT_TCC_MASK));
EDMA_setPaRAM(baseAddr, param, &edmaParam);
intrObj.tccNum = tcc;
intrObj.cbFxn = &EDMA_regionIsrFxn;
intrObj.appData = (void *) &gEdmaTestDoneSem;
status = EDMA_registerIntr(gEdmaHandle[edmaConfigNum], &intrObj);
for(loopCnt = 0; loopCnt < (EDMA_TEST_B_COUNT * EDMA_TEST_C_COUNT); loopCnt++)
{
EDMA_enableTransferRegion(
baseAddr, regionId, dmaCh, EDMA_TRIG_MODE_MANUAL);
}
for(loopCnt = 0; loopCnt < EDMA_TEST_BUFFER_SIZE; loopCnt++)
{
if(srcBuffPtr[loopCnt] != dstBuffPtr[loopCnt])
{
DebugP_log(
"Error matching value at src and dst address %d\r\n", loopCnt);
result = SDL_EFAIL;
break;
}
}
status = EDMA_unregisterIntr(gEdmaHandle[edmaConfigNum], &intrObj);
EDMA_freeChannelRegion(baseAddr, regionId, EDMA_CHANNEL_TYPE_DMA,
dmaCh, EDMA_TRIG_MODE_MANUAL, tcc, EDMA_TEST_EVT_QUEUE_NO);
status = EDMA_freeDmaChannel(gEdmaHandle[edmaConfigNum], &dmaCh);
status = EDMA_freeTcc(gEdmaHandle[edmaConfigNum], &tcc);
status = EDMA_freeParam(gEdmaHandle[edmaConfigNum], ¶m);
{
DebugP_log(
"\r\n[EDMA] Interrupt Transfer Test Completed!!\r\n");
if(esmError == TRUE)
{
esmError = false;
}
else
{
result = SDL_EFAIL;
DebugP_log(
"\r\nESM interrupt is not occurred.... Test is failed!!\r\n");
}
}
else
{
result = SDL_EFAIL;
}
EDMA_Deinit();
Example Usage of MCAN
Include the below file to access the APIs
Below are the macros specifies the RAM address, ECC aggregator and ECC aggregator RAMID for inject the ECC error
This structure defines the elements of ECC Init configuration
{
SDL_EXAMPLE_ECC_RAM_ID,
};
{
.
numRams = SDL_MCANA_MAX_MEM_SECTIONS,
.pMemSubTypeList = &(ECC_Test_MCANA_subMemTypeList[0]),
};
ESM callback function
Event BitMap for ECC ESM callback for MCAN
Initialize ECC memory for the ECC aggregator
Initialize ECC parameters for single and double bit error injection
result =
SDL_ECC_init(SDL_EXAMPLE_ECC_AGGR, &ECC_Test_MCANA_ECCInitConfig);
Write some data to the RAM memory before injecting
for(i=1;i<=num_of_iterations;i++){
wr_data = (i)<<24 | (i)<<16 | (i)<<8 | i;
}
Execute ECC MCAN single bit inject test
int32_t ECC_Test_run_MCANA_1BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nMCANA Single bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
if (result != SDL_PASS ) {
retVal = -1;
} else {
testLocationValue = injectErrorConfig.
pErrMem[0];
DebugP_log(
"\r\nMCANA Single bit error inject at pErrMem = 0x%p and the value of pErrMem is 0x%p :test complete\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Read data from the RAM memory after injecting
for(i=1;i<=num_of_iterations;i++){
}
Write some data to the RAM memory before injecting
for(i=1;i<=num_of_iterations;i++){
wr_data = (i)<<24 | (i)<<16 | (i)<<8 | i;
}
Execute ECC MCAN double bit inject test
int32_t ECC_Test_run_MCANA_2BitInjectTest(void)
{
SDL_ErrType_t result;
int32_t retVal=0;
volatile uint32_t testLocationValue;
DebugP_log(
"\r\nMCANA double bit error inject: starting \r\n");
injectErrorConfig.
pErrMem = (uint32_t *)(SDL_EXAMPLE_ECC_RAM_ADDR);
SDL_EXAMPLE_ECC_RAM_ID,
&injectErrorConfig);
testLocationValue = injectErrorConfig.
pErrMem[0];
if (result != SDL_PASS ) {
retVal = -1;
} else {
DebugP_log(
"\r\nMCANA Double bit error inject: pErrMem fixed location = 0x%p once test complete: the value of pErrMem is 0x%p\r\n",
injectErrorConfig.
pErrMem, testLocationValue);
}
return retVal;
}
Read data from the RAM memory after injecting
for(i=1;i<=num_of_iterations;i++){
}
Example Usage of TCM Parity
Include the below file to access the APIs
Below are the macros specifies the values need to set for TCM parity Error forcing
ESM callback function
Event BitMap for ESM callback for TCM Parity
Execute TCM Parity Error injection for B0TCM0 for R5FSS0 core 0
Example Usage of DMA Parity
Include the below file to access the APIs
ESM callback function
Event BitMap for ESM callback for TCM Parity
Execute TPCC Parity Error injection
API
APIs for SDL ECC (ECC_AGGR)