chacha/V2TMUMemTester
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 3 Activity

improved overall diagnostics, and specifically TMU-FBI BUS.

Browse Source
This commit is contained in:
ChaCha
2026-03-16 18:12:11 +01:00
parent c363aa6284
commit 712e9cfcab
11 changed files with 488 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
FaultSources.c
View File

@@ -62,6 +62,8 @@ FaultSource_addScore( def_sFaultSourceScoreRec* const pCtx,
double dDivider = 1.0;
do
{
//if(dDivider==1.0)
// printf("set Score %f to %s\n",dScore,pCtx[eFaultSource].szName);
dScore /= dDivider;
pCtx[eFaultSource].dScore += dScore;
eFaultSource = pCtx[eFaultSource].eParrentFaultSource;
@@ -69,6 +71,32 @@ FaultSource_addScore( def_sFaultSourceScoreRec* const pCtx,
}while(eFaultSource != _INVALID_FAULT_SOURCE_);
}
void
FaultSource_nomalize( def_sFaultSourceScoreRec* const pCtx)
{
double dSum = 0.0;
for(unsigned long idx = 0; idx < NB_FAULT_SOURCE; ++idx )
dSum+= pCtx[idx].dScore;
if(dSum != 0)
FaultSource_divideAll(pCtx,dSum);
}
// This function can only be used on non-sorted Rec (is relies on indexes)!
void
FaultSource_sum( def_sFaultSourceScoreRec** const pCtxRef,
const unsigned int uNbRef,
def_sFaultSourceScoreRec* const pCtx)
{
for(unsigned long idx = 0; idx < NB_FAULT_SOURCE; ++idx )
{
for(unsigned long idxRef = 0; idxRef < uNbRef; ++idxRef )
{
pCtx[idx].dScore += pCtxRef[idxRef][idx].dScore;
}
}
FaultSource_divideAll(pCtx,uNbRef);
}
void
FaultSource_divideAll( def_sFaultSourceScoreRec* const pCtx,
const double dDivider)
@@ -115,7 +143,7 @@ FaultSource_getSorted( def_sFaultSourceScoreRec* const pDst,
sizeof(_ar_dFaultScores));
for(unsigned long idx = 0;
idx < (NB_FAULT_SOURCE - 1);
idx < NB_FAULT_SOURCE;
++idx )
pDst[idx].dScore *= pDst[idx].dWeight;
@@ -190,14 +218,6 @@ FaultSource_getLoc( const def_sFaultSourceScoreRec* const pCtx,
void
FaultSource_display(const def_sFaultSourceScoreRec* const pCtx)
{
double dScoreSum = 1;
for(unsigned long idx = 0;
idx < NB_FAULT_SOURCE
&& pCtx[idx].dScore > 0;
++idx )
dScoreSum += pCtx[idx].dScore;
printf("------------------------------------------------\n");
printf("\ndefects list:\n\n");
printf("score\telement [Loc]\n");
@@ -211,8 +231,8 @@ FaultSource_display(const def_sFaultSourceScoreRec* const pCtx)
static char buff[1024] = {0};
buff[0]='\0';
FaultSource_getLoc(pCtx,idx, buff);
printf("%02.5f\t%s [%s]\n",
100 * pCtx[idx].dScore / dScoreSum,
printf("%02.3f\t%s [%s]\n",
pCtx[idx].dScore,
pCtx[idx].szName,
buff );
}
@@ -274,3 +294,98 @@ QuartetBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
if(ErrorMark & (1u << bitPos))
FaultSource_addScore(pCtx, eFaultSource + bitPos, dScore);
}
void
RGBToBus_Fault( def_sFaultSourceScoreRec* const pCtx,
const uint32_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource)
{
const uint16_t u16pix1 = ErrorMark & 0xFFFF;
const uint16_t u16pix2 = (ErrorMark>>16) & 0xFFFF;
uint16_t u16Bus_r8 = ((u16pix1>>11) & 0x1F) << 3;
uint16_t u16Bus_g8 = ((u16pix1>>5) & 0x3F) << 2;
uint16_t u16Bus_b8 = ((u16pix1>>0) & 0x1F) << 3;
uint16_t u16Bus_a8 = 0;
/*
uint16_t u16Fault_W1 = (u16Bus_g8<<8) + u16Bus_b8;
uint16_t u16Fault_W2 = (u16Bus_a8<<8) + u16Bus_r8;
*/
/* Incoming data wont have Alpha channel, so we must normalize
* Fault weight */
ByteBitFaultSet(pCtx, u16Bus_b8, dScore/2, eFaultSource);
ByteBitFaultSet(pCtx, u16Bus_g8, dScore, eFaultSource + 8);
ByteBitFaultSet(pCtx, u16Bus_r8, dScore/2, eFaultSource);
//ByteBitFaultSet(pCtx, u16Bus_a8, dScore, eFaultSource + 8);
u16Bus_r8 = ((u16pix2>>11) & 0x1F) << 3;
u16Bus_g8 = ((u16pix2>>5) & 0x3F) << 2;
u16Bus_b8 = ((u16pix2>>0) & 0x1F) << 3;
u16Bus_a8 = 0;
/*
uint16_t u16Fault_W3 = (u16Bus_g8<<8) + u16Bus_b8;
uint16_t u16Fault_W4 = (u16Bus_a8<<8) + u16Bus_r8;
*/
/* Incoming data wont have Alpha channel, so we must normalize
* Fault weight */
ByteBitFaultSet(pCtx, u16Bus_b8, dScore/2, eFaultSource);
ByteBitFaultSet(pCtx, u16Bus_g8, dScore, eFaultSource + 8);
ByteBitFaultSet(pCtx, u16Bus_r8, dScore/2, eFaultSource);
//ByteBitFaultSet(pCtx, u16Bus_a8, dScore, eFaultSource + 8);
}
void
RGBToBus_Fault_Quartets( def_sFaultSourceScoreRec* const pCtx,
const uint32_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource1,
const def_eFaultSource eFaultSource2,
const def_eFaultSource eFaultSource3,
const def_eFaultSource eFaultSource4)
{
const uint16_t u16pix1 = ErrorMark & 0xFFFF;
const uint16_t u16pix2 = (ErrorMark>>16) & 0xFFFF;
uint16_t u16Bus_r8 = ((u16pix1>>11) & 0x1F) << 3;
uint16_t u16Bus_g8 = ((u16pix1>>5) & 0x3F) << 2;
uint16_t u16Bus_b8 = ((u16pix1>>0) & 0x1F) << 3;
uint16_t u16Bus_a8 = 0;
/*
uint16_t u16Fault_W1 = (u16Bus_g8<<8) + u16Bus_b8;
uint16_t u16Fault_W2 = (u16Bus_a8<<8) + u16Bus_r8;
*/
/* Incoming data wont have Alpha channel, so we must normalize
* Fault weight */
QuartetBitFaultSet(pCtx, u16Bus_b8 & 0xF, dScore/2, eFaultSource1);
QuartetBitFaultSet(pCtx, (u16Bus_b8<<4) & 0xF, dScore/2, eFaultSource2);
QuartetBitFaultSet(pCtx, u16Bus_g8 & 0xF, dScore, eFaultSource3);
QuartetBitFaultSet(pCtx, (u16Bus_g8<<4) & 0xF, dScore, eFaultSource4);
QuartetBitFaultSet(pCtx, u16Bus_r8 & 0xF, dScore/2, eFaultSource1);
QuartetBitFaultSet(pCtx, (u16Bus_r8<<4) & 0xF, dScore/2, eFaultSource2);
//QuartetBitFaultSet(pCtx, u16Bus_a8 & 0xF, dScore, eFaultSource3);
//QuartetBitFaultSet(pCtx, (u16Bus_a8<<4) & 0xF, dScore, eFaultSource4);
u16Bus_r8 = ((u16pix2>>11) & 0x1F) << 3;
u16Bus_g8 = ((u16pix2>>5) & 0x3F) << 2;
u16Bus_b8 = ((u16pix2>>0) & 0x1F) << 3;
u16Bus_a8 = 0;
/*
uint16_t u16Fault_W3 = (u16Bus_g8<<8) + u16Bus_b8;
uint16_t u16Fault_W4 = (u16Bus_a8<<8) + u16Bus_r8;
*/
/* Incoming data wont have Alpha channel, so we must normalize
* Fault weight */
QuartetBitFaultSet(pCtx, u16Bus_b8 & 0xF, dScore/2, eFaultSource1);
QuartetBitFaultSet(pCtx, (u16Bus_b8<<4) & 0xF, dScore/2, eFaultSource2);
QuartetBitFaultSet(pCtx, u16Bus_g8 & 0xF, dScore, eFaultSource3);
QuartetBitFaultSet(pCtx, (u16Bus_g8<<4) & 0xF, dScore, eFaultSource4);
QuartetBitFaultSet(pCtx, u16Bus_r8 & 0xF, dScore/2, eFaultSource1);
QuartetBitFaultSet(pCtx, (u16Bus_r8<<4) & 0xF, dScore/2, eFaultSource2);
//QuartetBitFaultSet(pCtx, u16Bus_a8 & 0xF, dScore, eFaultSource3);
//QuartetBitFaultSet(pCtx, (u16Bus_a8<<4) & 0xF, dScore, eFaultSource4);
}

94
FaultSources.h
View File

@@ -214,7 +214,7 @@
ACTION(U9_TMU0_TEX_ADDR_3_8, "pin 182" ,U9_TMU0, 1.0)\
ACTION(U8_TMU1, "U8/TMU1 (front left big Chip)" ,VOODOO_BOARD, 1.0)\
/* /!\ Keep in-order, only appEND new fields */ \
ACTION(U8_TMU1_TEXDATA_0_0, "pin 52" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_0_0, "pin 52" ,U8_TMU1, 1.0)/*Offset: 1*/\
ACTION(U8_TMU1_TEXDATA_0_1, "pin 53" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_0_2, "pin 54" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_0_3, "pin 55" ,U8_TMU1, 1.0)\
@@ -230,7 +230,7 @@
ACTION(U8_TMU1_TEXDATA_0_13, "pin 67" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_0_14, "pin 69" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_0_15, "pin 70" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_1_0, "pin 90" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_1_0, "pin 90" ,U8_TMU1, 1.0)/*Offset: 17*/\
ACTION(U8_TMU1_TEXDATA_1_1, "pin 91" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_1_2, "pin 92" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_1_3, "pin 93" ,U8_TMU1, 1.0)\
@@ -246,7 +246,7 @@
ACTION(U8_TMU1_TEXDATA_1_13, "pin 106" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_1_14, "pin 107" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_1_15, "pin 108" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_2_0, "pin 71" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_2_0, "pin 71" ,U8_TMU1, 1.0)/*Offset: 33*/\
ACTION(U8_TMU1_TEXDATA_2_1, "pin 72" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_2_2, "pin 74" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_2_3, "pin 75" ,U8_TMU1, 1.0)\
@@ -262,7 +262,7 @@
ACTION(U8_TMU1_TEXDATA_2_13, "pin 87" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_2_14, "pin 88" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_2_15, "pin 89" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_3_0, "pin 110" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_3_0, "pin 110" ,U8_TMU1, 1.0)/*Offset: 49*/\
ACTION(U8_TMU1_TEXDATA_3_1, "pin 111" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_3_2, "pin 112" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_3_3, "pin 113" ,U8_TMU1, 1.0)\
@@ -278,23 +278,23 @@
ACTION(U8_TMU1_TEXDATA_3_13, "pin 125" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_3_14, "pin 126" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEXDATA_3_15, "pin 127" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_0, "pin 30" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_1, "pin 32" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_2, "pin 33" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_3, "pin 34" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_4, "pin 35" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_5, "pin 36" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_6, "pin 37" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_7, "pin 38" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_8, "pin 42" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_9, "pin 44" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_10, "pin 45" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_11, "pin 46" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_12, "pin 47" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_13, "pin 48" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_14, "pin 49" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_15, "pin 80" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_FT_DATA_0, "pin 6" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_0, "pin 188" ,U8_TMU1, 1.0)/*Offset: 65*/\
ACTION(U8_TMU1_TT_DATA_1, "pin 189" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_2, "pin 190" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_3, "pin 191" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_4, "pin 192" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_5, "pin 193" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_6, "pin 194" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_7, "pin 195" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_8, "pin 199" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_9, "pin 200" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_10, "pin 201" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_11, "pin 202" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_12, "pin 204" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_13, "pin 205" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_14, "pin 206" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TT_DATA_15, "pin 207" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_FT_DATA_0, "pin 6" ,U8_TMU1, 1.0)/*Offset: 81*/\
ACTION(U8_TMU1_FT_DATA_1, "pin 7" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_FT_DATA_2, "pin 8" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_FT_DATA_3, "pin 9" ,U8_TMU1, 1.0)\
@@ -310,14 +310,30 @@
ACTION(U8_TMU1_FT_DATA_13, "pin 23" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_FT_DATA_14, "pin 24" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_FT_DATA_15, "pin 25" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_RAS0, "pin 129" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_0, "pin 30" ,U8_TMU1, 1.0)/*Offset: 97*/\
ACTION(U8_TMU1_TF_DATA_1, "pin 32" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_2, "pin 33" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_3, "pin 34" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_4, "pin 35" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_5, "pin 36" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_6, "pin 37" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_7, "pin 38" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_8, "pin 42" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_9, "pin 44" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_10, "pin 45" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_11, "pin 46" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_12, "pin 47" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_13, "pin 48" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_14, "pin 49" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TF_DATA_15, "pin 80" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_RAS0, "pin 129" ,U8_TMU1, 1.0)/*Offset: 113*/\
ACTION(U8_TMU1_TEX_RAS1, "pin 130" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_CAS0, "pin 131" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_CAS0, "pin 131" ,U8_TMU1, 1.0)/*Offset: 115*/\
ACTION(U8_TMU1_TEX_CAS1, "pin 132" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_CAS2, "pin 134" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_CAS3, "pin 135" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_WE, "pin 136" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_0_0, "pin 138" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_WE, "pin 136" ,U8_TMU1, 1.0)/*Offset: 119*/\
ACTION(U8_TMU1_TEX_ADDR_0_0, "pin 138" ,U8_TMU1, 1.0)/*Offset: 120*/\
ACTION(U8_TMU1_TEX_ADDR_0_1, "pin 139" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_0_2, "pin 141" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_0_3, "pin 142" ,U8_TMU1, 1.0)\
@@ -326,7 +342,7 @@
ACTION(U8_TMU1_TEX_ADDR_0_6, "pin 146" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_0_7, "pin 147" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_0_8, "pin 149" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_1_0, "pin 161" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_1_0, "pin 161" ,U8_TMU1, 1.0)/*Offset: 129*/\
ACTION(U8_TMU1_TEX_ADDR_1_1, "pin 162" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_1_2, "pin 164" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_1_3, "pin 165" ,U8_TMU1, 1.0)\
@@ -335,7 +351,7 @@
ACTION(U8_TMU1_TEX_ADDR_1_6, "pin 168" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_1_7, "pin 169" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_1_8, "pin 171" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_2_0, "pin 150" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_2_0, "pin 150" ,U8_TMU1, 1.0)/*Offset: 138*/\
ACTION(U8_TMU1_TEX_ADDR_2_1, "pin 151" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_2_2, "pin 152" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_2_3, "pin 154" ,U8_TMU1, 1.0)\
@@ -344,7 +360,7 @@
ACTION(U8_TMU1_TEX_ADDR_2_6, "pin 157" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_2_7, "pin 158" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_2_8, "pin 160" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_3_0, "pin 172" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_3_0, "pin 172" ,U8_TMU1, 1.0)/*Offset: 147*/\
ACTION(U8_TMU1_TEX_ADDR_3_1, "pin 174" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_3_2, "pin 175" ,U8_TMU1, 1.0)\
ACTION(U8_TMU1_TEX_ADDR_3_3, "pin 176" ,U8_TMU1, 1.0)\
@@ -1063,7 +1079,13 @@ FaultSource_display(const def_sFaultSourceScoreRec* const pCtx);
void
FaultSource_divideAll( def_sFaultSourceScoreRec* const pCtx,
const double dDivider);
void
FaultSource_nomalize( def_sFaultSourceScoreRec* const pCtx);
void
FaultSource_sum( def_sFaultSourceScoreRec** const pCtxRef,
const unsigned int uNbRef,
def_sFaultSourceScoreRec* const pCtx);
void
ByteBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint8_t ErrorMark,
@@ -1112,7 +1134,6 @@ TMUTexDataFaultSet( def_sFaultSourceScoreRec* const pCtx,
LWordBitFaultSet(pCtx,ErrorMark_w2w3, dScore, eTMUFaultSource + 32 + 1, eTMUFaultSource + 48 + 1);
}
static inline void
TMUTexDataCtrlFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint32_t ErrorMark,
@@ -1139,4 +1160,19 @@ TMUTexDataCtrlFaultSet( def_sFaultSourceScoreRec* const pCtx,
}
}
void
RGBToBus_Fault( def_sFaultSourceScoreRec* const pCtx,
const uint32_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource);
void
RGBToBus_Fault_Quartets( def_sFaultSourceScoreRec* const pCtx,
const uint32_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource1,
const def_eFaultSource eFaultSource2,
const def_eFaultSource eFaultSource3,
const def_eFaultSource eFaultSource4);
#endif //_DEF_FAULTSOURCES_H_

13
Readme.md
View File

@@ -60,7 +60,7 @@ Here is the [hopefully updated] project status.
- [X] test data (random pattern)
- [X] test address
- [X] test data (huge block)
- [ ] test draw triangle shape (no texture)
- [X] test draw no-mem (no texture)
- [ ] CLI options
- [X] help
- [X] single test run
@@ -105,20 +105,20 @@ Here is the [hopefully updated] project status.
- [ ] force 0
- [ ] force 1
- [ ] floating
- [X] 1MB TMU test (faulty)
- [X] 1MB TMU test (= faulty voodoo2)
- [X] 2MB TMU test (= 8MB Voodoo2)
- [X] 4MB TMU test (= 12MB Voodoo2)
- [X] TMU0 or TMU1 only*
- [ ] FBI to TMU1 fault
- [ ] FBI to TMU0 fault
- [ ] TMU1 to TMU0 fault
- [ ] TMU0 to FBI fault
- [X] TMU1 to TMU0 fault
- [X] TMU0 to FBI fault
- [ ] Documentation
- [X] CLI help (integrated in the bin)
- [ ] short youtube video
- [ ] better explanation on how memory is accessed
- [ ] Other / Ideas
- [ ] integration with (or in) Witchery ?
- [ ] integration with Witchery ?
## TMU0 Memory test
@@ -208,9 +208,6 @@ Here is a simplified data flow diagram:
8. The CPU requests the pixels using the Linear Frame Buffer access
9. The CPU can compare the rendered value with the original texture
## Accessing different memory regions
TBD
## Note on driver aspect

2
Test_Address.c
View File

@@ -115,7 +115,7 @@ RenderTestAddress( sst1DeviceInfoStruct * const devInfo,
{0x300000,1,0,9},
};
logD("testing %d MB of memory\n",RamSizeMB);
logT("testing %d MB of memory\n",RamSizeMB);
for(unsigned char idx=0;
idx < (sizeof(add_list)/sizeof(def_sTestAddress));
idx++)

4
Test_Common.c
View File

@@ -45,9 +45,9 @@ HeatMemAndTMU( sst1DeviceInfoStruct * const devInfo,
for (int i=0; i<ucNumTMU; i++)
ISET(SST_TREX(sstregs,i)->textureMode, SST_TC_PASS | SST_TCA_PASS);
/* Setting texture base address window for both CPU and TMU
/* Setting texture base address window
*/
ISET(sstregs->texBaseAddr, (mem>>3));
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, (mem>>3));
/* Setting texture base address (to access it from CPU).
* We wont draw anything bigger than the texture so we can just use LOD0

1
Test_Common.h
View File

@@ -25,4 +25,5 @@ HeatMemAndTMU( sst1DeviceInfoStruct * const devInfo,
const char ucNumTMU,
const FxU32 mem);
#endif //_DEF_TEST_COMMON_H_

79
Test_Data.c
View File

@@ -73,18 +73,12 @@ RenderTest( sst1DeviceInfoStruct * const devInfo,
drawRect(sstregs, ucNumTMU, 0, 0, 2, 2);
sst1InitIdle(sst);
const double dScoreFront = (mem >= 0x200000) ? 1.0 / 2 : 1.0 / 1;
const double dScoreBack = (mem >= 0x200000) ? 1.0 / 1 : 1.0 / 2;
/* reading back first line pixels addresses */
const uint32_t L1_1 = IGET(sst[(SST_LFB_ADDR >> 2) + 0]);
/* reading back second line pixels addresses */
const uint32_t L2_1 = IGET(sst[(SST_LFB_ADDR >> 2) + (2048 >> 2) + 0]);
const uint32_t ErrorMark_L1 = L1_1 ^ ( value1 + 0 );
const uint32_t ErrorMark_L2 = L2_1 ^ ( value2 + 0 );
const double dScoreFront = (mem >= 0x200000) ? 1.0 / 8 : 1.0 / 4;
const double dScoreBack = (mem >= 0x200000) ? 1.0 / 4 : 1.0 / 8;
if(ErrorMark_L1)
{
NbErr++;
@@ -92,40 +86,33 @@ RenderTest( sst1DeviceInfoStruct * const devInfo,
logD( "# fault on 1st line, value : 0x%04X [expected 0x%04X] !\n",
value1, L1_1);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U9_TMU0_TF_DATA_0, U9_TMU0_TF_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U3_FBI_TF_DATA_0, U3_FBI_TF_DATA_0);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 0, 1.0 / 16, RA10_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 4, 1.0 / 16, RA11_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 8, 1.0 / 16, RA12_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 12, 1.0 / 16, RA13_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 16, 1.0 / 16, RA10_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 20, 1.0 / 16, RA11_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 24, 1.0 / 16, RA12_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 28, 1.0 / 16, RA13_1);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U9_TMU0_TF_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U3_FBI_TF_DATA_0);
RGBToBus_Fault_Quartets(pFaultSrcCtx, ErrorMark_L1, 1.0/2,
RA10_1, RA11_1, RA12_1, RA13_1);
if(ucNumTMU == 0)
{
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/ 2, U9_TMU0_FT_DATA_0);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreFront, U14, U12);
if(RamSizeMB>2)
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreBack, U23, U24);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 4, U9_TMU0 + 1, U9_TMU0 + 16 + 1);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 1, U9_TMU0 + 1, U9_TMU0 + 16 + 1);
}
else
{
/* during TMU1 test, TMU0 doesnt receive any textures => ignoring these
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 2, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U9_TMU0_FT_DATA_0);
*/
/* U9_TMU0_TT_DATA_x is only tested when using TMU1 */
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U9_TMU0_TT_DATA_0, U9_TMU0_TT_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, TT_TDATA_R131, TT_TDATA_R131);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U8_TMU1_TF_DATA_0, U8_TMU1_TF_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U8_TMU1_FT_DATA_0, U8_TMU1_FT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U9_TMU0_TT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, TT_TDATA_R131);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U8_TMU1_TF_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U8_TMU1_FT_DATA_0);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreFront, U13, U11);
if(RamSizeMB>2)
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreBack, U27, U28);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 4, U8_TMU1 + 1, U8_TMU1 + 16 + 1);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 1, U8_TMU1 + 1, U8_TMU1 + 16 + 1);
}
logD("## overall fault LW bit-map : \n");
@@ -136,6 +123,9 @@ RenderTest( sst1DeviceInfoStruct * const devInfo,
}
}
/* reading back second line pixels addresses */
const uint32_t L2_1 = IGET(sst[(SST_LFB_ADDR >> 2) + (2048 >> 2) + 0]);
const uint32_t ErrorMark_L2 = L2_1 ^ ( value2 + 0 );
if(ErrorMark_L2)
{
NbErr++;
@@ -143,40 +133,33 @@ RenderTest( sst1DeviceInfoStruct * const devInfo,
logD( "# fault on 2nd line, value : 0x%04X [expected 0x%04X] !\n",
value2, L2_1);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U9_TMU0_TF_DATA_0, U9_TMU0_TF_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U3_FBI_TF_DATA_0, U3_FBI_TF_DATA_0);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 0, 1.0 / 16, RA10_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 4, 1.0 / 16, RA11_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 8, 1.0 / 16, RA12_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 12, 1.0 / 16, RA13_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 16, 1.0 / 16, RA10_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 20, 1.0 / 16, RA11_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 24, 1.0 / 16, RA12_1);
QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 28, 1.0 / 16, RA13_1);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U9_TMU0_TF_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U3_FBI_TF_DATA_0);
RGBToBus_Fault_Quartets(pFaultSrcCtx, ErrorMark_L2, 1.0/2,
RA10_1, RA11_1, RA12_1, RA13_1);
if(ucNumTMU == 0)
{
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U9_TMU0_FT_DATA_0);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreFront, U18, U17);
if(RamSizeMB>2)
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreBack, U25, U26);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L2, 1.0 / 4, U9_TMU0 + 32 + 1, U9_TMU0 + 48 + 1);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L2, 1.0 / 1, U9_TMU0 + 32 + 1, U9_TMU0 + 48 + 1);
}
else
{
/* during TMU1 test, TMU0 doesnt receive any textures => ignoring these
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 2, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U9_TMU0_FT_DATA_0);
*/
/* U9_TMU0_TT_DATA_x is only tested when using TMU1 */
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U9_TMU0_TT_DATA_0, U9_TMU0_TT_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, TT_TDATA_R131, TT_TDATA_R131);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U8_TMU1_TF_DATA_0, U8_TMU1_TF_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U8_TMU1_FT_DATA_0, U8_TMU1_FT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U9_TMU0_TT_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, TT_TDATA_R131);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U8_TMU1_TF_DATA_0);
RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U8_TMU1_FT_DATA_0);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreFront, U16, U15);
if(RamSizeMB>2)
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreBack, U29, U30);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L2, 1.0 / 4, U8_TMU1 + 32 + 1, U8_TMU1 + 48 + 1);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L2, 1.0 / 1, U8_TMU1 + 32 + 1, U8_TMU1 + 48 + 1);
}
logD("## overall fault LW bit-map : \n");
if(sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
@@ -243,7 +226,7 @@ test_TMU_datalines( sst1DeviceInfoStruct * const devInfo,
if(RamSizeMB < 2 && pMemBlk->ulAddStart >= 0x100000) continue;
logD("Testing @ 0x%08x to 0x%08x ...\n",
logT("Testing @ 0x%08x to 0x%08x ...\n",
pMemBlk->ulAddStart,
pMemBlk->ulAddStart + pMemBlk->ulAddLength -4);

141
Test_Data_Huge.c
View File

@@ -122,11 +122,8 @@ AssignFault(const def_sFaultSheet * const
def_sFaultSourceScoreRec * const
pFaultSrcCtx)
{
//const unsigned char relbitIdxQuartet= bitIdx%4;
const unsigned char relbitIdxQuartet = _relbitIdxQuartet;
//const unsigned char relbitIdx = bitIdx%8;
const unsigned char relbitIdx = _relbitIdx;
//const unsigned char relbitIdxWord = bitIdx%16;
const unsigned char relbitIdxWord = _relbitIdxWord;
static unsigned char nbErrLWord = 0;
@@ -144,67 +141,90 @@ AssignFault(const def_sFaultSheet * const
logD("## fault on LW bit: %d\n",bitIdx);
/* We need to remap the faulty bit to the ARGB Bus, from the RGB565 Value.
* Based on this code:
* uint16_t u16Bus_r8 = ((u16pix1>>11) & 0x1F) << 3;
* uint16_t u16Bus_g8 = ((u16pix1>>5) & 0x3F) << 2;
* uint16_t u16Bus_b8 = ((u16pix1>>0) & 0x1F) << 3;
* uint16_t u16Bus_a8 = 0;
*
* //uint16_t u16Fault_W1 = (u16Bus_g8<<8) + u16Bus_b8;
* //uint16_t u16Fault_W2 = (u16Bus_a8<<8) + u16Bus_r8;
*
*/
uint8_t ARGBrelbitIdx;
double dARGBScore = 1.0/4.0;
if(relbitIdxWord>=11) //RED
{
ARGBrelbitIdx = relbitIdxWord -11 +3;
//There is no Alpha channel so score shouldnt be divided by 2
}
else if(relbitIdxWord>=5) //GREEN
{
ARGBrelbitIdx = relbitIdxWord -5 +2 +8;
dARGBScore /= 2;
}
else //BLUE
{
ARGBrelbitIdx = relbitIdxWord +3;
dARGBScore /= 2;
}
logD("## ARGB Bus bit: %d\n",ARGBrelbitIdx);
logD("- TMU : %s\n",pFaultSrcCtx[psCurFaultSheet->Ux_TMU].szName);
/* Texture Source path, FBI to TMUx*/
FaultSource_addScore( pFaultSrcCtx,
psCurFaultSheet->Ux_TMU
+ 81 //Ux_TMUx_FT_DATA_x
+ relbitIdxWord,
1.0/4);
+ ARGBrelbitIdx,
dARGBScore);
/* Output path, TMU0 to FBI*/
FaultSource_addScore( pFaultSrcCtx,
U9_TMU0
+ 97 //U9_TMU0_TF_DATA_x
+ relbitIdxWord,
1.0/4);
+ ARGBrelbitIdx,
dARGBScore);
FaultSource_addScore( pFaultSrcCtx,
U3_FBI_TF_DATA_0
+ relbitIdxWord,
1.0/4);
+ ARGBrelbitIdx,
dARGBScore);
switch(WordIdx)
if(ARGBrelbitIdx>=12)
{
case 0:
case 2:
if(relbitIdx<=3)
{
logD("- RA1x_x : %s\n",pFaultSrcCtx[RA10_1+relbitIdxQuartet].szName);
FaultSource_addScore( pFaultSrcCtx,
RA10_1
+ relbitIdxQuartet,
1.0/8);
}
else
{
logD("- RA1x_x : %s\n",pFaultSrcCtx[RA11_1+relbitIdxQuartet].szName);
FaultSource_addScore( pFaultSrcCtx,
RA11_1
+ relbitIdxQuartet,
1.0/8);
}
break;
case 1:
case 3:
if(relbitIdx<=3)
{
logD("- RA1x_x : %s\n",pFaultSrcCtx[RA12_1+relbitIdxQuartet].szName);
FaultSource_addScore( pFaultSrcCtx,
RA12_1
+ relbitIdxQuartet,
1.0/8);
}
else
{
logD("- RA1x_x : %s\n",pFaultSrcCtx[RA13_1+relbitIdxQuartet].szName);
logD("- RA13_x : %s\n",pFaultSrcCtx[RA13_1+ARGBrelbitIdx-12].szName);
FaultSource_addScore( pFaultSrcCtx,
RA13_1
+ relbitIdxQuartet,
1.0/8);
+ ARGBrelbitIdx -12,
dARGBScore);
}
break;
else if(ARGBrelbitIdx>=8)
{
logD("- RA12_x : %s\n",pFaultSrcCtx[RA12_1+ARGBrelbitIdx-8].szName);
FaultSource_addScore( pFaultSrcCtx,
RA12_1
+ ARGBrelbitIdx -8,
dARGBScore);
}
else if(ARGBrelbitIdx>=4)
{
logD("- RA11_x : %s\n",pFaultSrcCtx[RA11_1+ARGBrelbitIdx-4].szName);
FaultSource_addScore( pFaultSrcCtx,
RA11_1
+ ARGBrelbitIdx -4,
dARGBScore);
}
else
{
logD("- RA10_x : %s\n",pFaultSrcCtx[RA10_1+ARGBrelbitIdx].szName);
FaultSource_addScore( pFaultSrcCtx,
RA10_1
+ ARGBrelbitIdx,
dARGBScore);
}
/* Transfert path, TMU1 to TMU0*/
@@ -214,21 +234,21 @@ AssignFault(const def_sFaultSheet * const
FaultSource_addScore( pFaultSrcCtx,
U8_TMU1
+ 97 //U8_TMU1_TF_DATA_x
+ relbitIdxWord,
1.0/4);
+ ARGBrelbitIdx,
dARGBScore);
/* line adaptation resistors */
FaultSource_addScore( pFaultSrcCtx,
TT_TDATA_R131
+ 0
+ relbitIdxWord,
1.0/4);
+ ARGBrelbitIdx,
dARGBScore);
/* TMU0 input */
/* Note: U9_TMU0_TT_DATA_x is only tested when using TMU1 */
FaultSource_addScore( pFaultSrcCtx,
U9_TMU0
+ 65 //U9_TMU0_TT_DATA_x
+ relbitIdxWord,
1.0/4);
+ ARGBrelbitIdx,
dARGBScore);
}
if(WordIdx>=2)
@@ -583,13 +603,18 @@ RenderTest( sst1DeviceInfoStruct * const
}
#ifdef _PROFILING
clock_t end = clock();
logI("time to create: %f\n",(double)(after_create-begin)/CLOCKS_PER_SEC);
logI("time to write: %f\n",(double)(after_write-after_create)/CLOCKS_PER_SEC);
logI("time to create: %f\n",
(double)(after_create-begin)/CLOCKS_PER_SEC);
logI("time to write: %f\n",
(double)(after_write-after_create)/CLOCKS_PER_SEC);
for(unsigned int i = 0; i<_NB_CHECK_LOOP; i++)
{
logI("time to draw [%d]: %f\n",i,(double)(after_draw[i]-before_draw[i])/CLOCKS_PER_SEC);
logI("time to read [%d]: %f\n",i,(double)(after_read[i]-after_draw[i])/CLOCKS_PER_SEC);
logI("time to check [%d]: %f\n",i,(double)(after_check[i]-after_read[i])/CLOCKS_PER_SEC);
logI("time to draw [%d]: %f\n",
i, (double)(after_draw[i]-before_draw[i])/CLOCKS_PER_SEC);
logI("time to read [%d]: %f\n",
i, (double)(after_read[i]-after_draw[i])/CLOCKS_PER_SEC);
logI("time to check [%d]: %f\n",
i, (double)(after_check[i]-after_read[i])/CLOCKS_PER_SEC);
}
logI("overall: %f\n",(double)(end-begin)/CLOCKS_PER_SEC);
#endif
@@ -654,7 +679,7 @@ test_TMU_datalines_Huge( sst1DeviceInfoStruct * const
addrTest < (pMemBlk->ulAddStart + pMemBlk->ulAddLength);
addrTest += 131072) /* 256x256x2 (16bit pixels texture) */
{
logD("Testing memory block 0x%08x ...\n", addrTest);
logT("Testing memory block 0x%08x ...\n", addrTest);
const unsigned long long
ullNbError = RenderTest( devInfo,
sst,
@@ -672,7 +697,7 @@ test_TMU_datalines_Huge( sst1DeviceInfoStruct * const
}
}
clearScreen(sstregs,0x00000000,256,256);
clearScreen(sstregs, 0x00000000, 256, 256);
/* reset the Init0 register back to its previous value */
sst1InitIdle(sst);

34
Test_Data_NoMem.c
View File

@@ -46,7 +46,6 @@ extern const def_sFaultSourceLineMap ar_sFaultSourceLineMap[];
void DisplayPattern(const def_sTestPattern * const pREF)
{
printf("==========================\n");
printf("RGB: %04X %04X %04X %04X\n",
pREF->data.access.u16Pix[0][0],
pREF->data.access.u16Pix[0][1],
@@ -111,6 +110,7 @@ double ComputePatternDistance( const def_sTestPattern * const pA,
dDistance += dComputeDistance32(pA->data.raw[i+3],pB->data.raw[i+3]);
}
dDistance /= 12*4*32;
logT("dDistance: %f\n",dDistance);
return dDistance;
}
@@ -145,6 +145,7 @@ void GetNearestIndexes( const def_sTestPattern * const pREF,
{
ScoreSet[i].pREF = &pSet[i];
ScoreSet[i].dScore = (1 - ScaleScore(ComputePatternDistance(pREF,pSet+i),100));
logT("ScoreSet[%d].dScore = %f\n",i,ScoreSet[i].dScore);
}
qsort(ScoreSet,uNbPattern,sizeof(def_sScoreSet),scoreSetCmp);
@@ -176,20 +177,23 @@ unsigned char DistributeFaults( const def_sTestPattern * const pREF,
GetNearestIndexes(pREF,pREFPatterns,ScoreSet,uNbREFPatterns);
for( int i =0; i<uNbREFPatterns;i++)
for( int i = 0 ; i < uNbREFPatterns ; i++)
{
if( ScoreSet[i].pREF->bReferenceSet && ScoreSet[i].dScore==100)
{
//logD("No Fault found\n");
free(ScoreSet);
return 0;
}
}
if( sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
{
DisplayPattern(pREF);
logD("==========================\n");
for( int i =0; i<uNbREFPatterns;i++)
logD("Read:\n");
if( sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
DisplayPattern(pREF);
for( int i = 0 ; i < uNbREFPatterns ; i++)
{
logD("==========================\n");
if((!ScoreSet[i].pREF->bReferenceSet) && (ScoreSet[i].dScore>=80))
{
logD( "%d Score = %f\n",
@@ -199,11 +203,13 @@ unsigned char DistributeFaults( const def_sTestPattern * const pREF,
[ScoreSet[i].pREF->u8FaultLineIdx]
.eTMUFaultSource_TMU0_RES,
ScoreSet[i].dScore);
/*FaultSource_addScore( pFaultSrcCtx,
FaultSource_addScore( pFaultSrcCtx,
ar_sFaultSourceLineMap
[ScoreSet[i].pREF->u8FaultLineIdx]
.eTMUFaultSource_FBI,
ScoreSet[i].dScore);*/
ScoreSet[i].dScore);
FaultSource_addScore( pFaultSrcCtx,
ar_sFaultSourceLineMap
[ScoreSet[i].pREF->u8FaultLineIdx]
@@ -216,6 +222,7 @@ unsigned char DistributeFaults( const def_sTestPattern * const pREF,
[ScoreSet[i].pREF->u8FaultLineIdx]
.eTMUFaultSource_TMU0_TMU1,
ScoreSet[i].dScore);
FaultSource_addScore( pFaultSrcCtx,
ar_sFaultSourceLineMap
[ScoreSet[i].pREF->u8FaultLineIdx]
@@ -224,7 +231,6 @@ unsigned char DistributeFaults( const def_sTestPattern * const pREF,
}
}
}
}
free(ScoreSet);
@@ -300,7 +306,7 @@ void TestStep_NoMem(FxU32 * const sst,
SST_RGB565 | SST_TC_REPLACE | SST_TCA_REPLACE);
}
#define N_LOOP_TEST 20
#define N_LOOP_TEST 100
unsigned long long
test_TMU_datalines_NoMem( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
@@ -355,27 +361,27 @@ test_TMU_datalines_NoMem( sst1DeviceInfoStruct * const devInfo,
/* RGB: 0, A: 0*/
/***************/
/* Not implemented because the "all on" test should be enough for now
TestStep_NoMem( sst, sstregs, ucNumTMU, 0 ,0, 1,
TestStep_NoMem( sst, sstregs, ucNumTMU, 0 ,0, 0,
&ar_ResultPattern[i][0]);*/
/***************/
/* RGB: 1, A: 0*/
/***************/
/* Not implemented because the "all on" test should be enough for now
TestStep_NoMem( sst, sstregs, ucNumTMU, 1, 0, 1,
TestStep_NoMem( sst, sstregs, ucNumTMU, 1, 0, 0,
&ar_ResultPattern[i][1]);*/
/***************/
/* RGB: 1, A: 1*/
/***************/
TestStep_NoMem( sst, sstregs, ucNumTMU, 1, 1 , 1,
TestStep_NoMem( sst, sstregs, ucNumTMU, 1, 1 , 0,
&ar_ResultPattern[i][2]);
/***************/
/* RGB: 0, A: 1*/
/***************/
/* Not implemented because the "all on" test should be enough for now
TestStep_NoMem( sst, sstregs, ucNumTMU, 0, 1 , 1,
TestStep_NoMem( sst, sstregs, ucNumTMU, 0, 1 , 0,
&ar_ResultPattern[i][3]);*/
}

6
V2MemTest.h
View File

@@ -19,7 +19,7 @@
#define _DEF_V2MEMTEST_H_
#define V2MEMTEST__VERSION__MAJOR 0
#define V2MEMTEST__VERSION__MINOR 4
#define V2MEMTEST__VERSION__MINOR 5
#define V2MEMTEST__VERSION__PATCH 0
#include <stdbool.h>
@@ -58,6 +58,7 @@ typedef enum _def_eErrorCode {
E_ERROR__NOT_ENOUGH_FBI_RAM,
E_ERROR__TMU_NOT_FOUND,
E_ERROR__NO_TMU_SELECTED,
E_ERROR__WRONG_TMU_SELECTED,
E_INVALID_ERROR_CODE,
}def_eErrorCode;
@@ -67,8 +68,6 @@ typedef struct _def_sOptions
{
def_eLogLevel eLogLevel;
int bSilent;
char szLogFileName[2048];
char szTSVFile[2048];
long lNumLoops;
int bTestTMU0;
def_eTMURamLimit eTMU0RamLimit;
@@ -81,6 +80,7 @@ typedef struct _def_sOptions
int bTestNoMem;
int bQuick;
int bForce;
int bContinue;
} def_sOptions;
extern def_sOptions sOptions;

163
main.c
View File

@@ -52,6 +52,7 @@ const char* szErrorMsg[] =
"not enough FBI RAM to process TMU tests.", // E_ERROR__NOT_ENOUGH_FBI_RAM,
"TMU not found.", // E_ERROR__TMU_NOT_FOUND,
"no TMU selected.", // E_ERROR__NO_TMU_SELECTED,
"wrong number of TMU selected.", // E_ERROR__WRONG_TMU_SELECTED
};
const char szTitle[] =
@@ -80,10 +81,9 @@ const char szHelp[] =
" --version Print version (MAJOR.MINOR.PATCH) and exit.\n"
" -n, --num <N> Number of loops (default: 1).\n"
" -q, --quick Quicker test (no pre-heat).\n"
" -c, --continue Continue testing even when error found.\n"
" -f, --force Force test (not detected TMU / RAM).\n"
/*" -l, --log <file> Log file path.\n"*/
" --silent Silent mode (suppress normal output).\n"
/*" -t, --tsv <file> TSV output file path.\n"*/
"\n"
"Verbosity:\n"
" -v Increase log level by one step (repeatable).\n"
@@ -106,7 +106,6 @@ const char szHelp[] =
" --tmu1-ram <MB> Force TMU1 RAM size: -1=auto, 1..4=MB.\n"
"\n"
"Examples:\n"
/*" ./v2-tmu-memtester --tmu0 --address -v --tsv out.tsv\n"*/
" ./v2-tmu-memtester --tmu0 --address -v\n"
" ./v2-tmu-memtester --tmu0-ram 2 --tmu1-ram -1 -n 10\n"
" ./v2-tmu-memtester --tmu1 --data-huge\n";
@@ -114,8 +113,6 @@ const char szHelp[] =
def_sOptions sOptions = {
.eLogLevel = E_LOGLEVEL__INFO,
.bSilent = false,
.szLogFileName = {0},
.szTSVFile = {0},
.lNumLoops = 1,
.bTestTMU0 = false,
.eTMU0RamLimit = E_TMU_RAMSIZE__AUTO,
@@ -128,17 +125,17 @@ def_sOptions sOptions = {
.bTestNoMem = false,
.bQuick = false,
.bForce = false,
.bContinue = false,
};
static struct option long_args[] = {
/* {<NAME>, <HAS_ARG>, <FLAG>, <VAL> */
{"help", no_argument, NULL, 'h'},
{"num", required_argument, NULL, 'n'},
{"force", required_argument, NULL, 'f'},
/*{"log", required_argument, NULL, 'l'},*/
{"force", no_argument, NULL, 'f'},
{"continue", no_argument, NULL, 'c'},
{"silent", no_argument, &sOptions.bSilent, true},
{"quick", no_argument, NULL, 'q'},
/*{"tsv", required_argument, NULL, 't'},*/
{"tmu0", no_argument, &sOptions.bTestTMU0, true},
{"tmu1", no_argument, &sOptions.bTestTMU1, true},
{"control", no_argument, &sOptions.bTestTMUControl, true},
@@ -152,10 +149,34 @@ static struct option long_args[] = {
};
def_sFaultSourceScoreRec
ar_dFaultScores[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_no_mem[NB_FAULT_SOURCE];
def_sFaultSourceScoreRec
static def_sFaultSourceScoreRec
ar_dFaultScores_control[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_address[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_data[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_data_random[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_data_huge[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec*
ar_dFaultScores_Set[6];
const unsigned int uNb_dFaultScores_Set =
sizeof(ar_dFaultScores_Set)/sizeof(def_sFaultSourceScoreRec*);
static def_sFaultSourceScoreRec
ar_dFaultScores_ALL[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_sorted[NB_FAULT_SOURCE];
#define _DEF_TEST_TIME_PER_MB_S 5
@@ -170,7 +191,14 @@ int main(const int argc, char ** const argv)
bool bQuit = false;
FxU32* sst = NULL;
while((opt=getopt_long(argc,argv,"hvfqn:t:l:",long_args,&option_index)) != -1)
ar_dFaultScores_Set[0] = ar_dFaultScores_no_mem;
ar_dFaultScores_Set[1] = ar_dFaultScores_control;
ar_dFaultScores_Set[2] = ar_dFaultScores_address;
ar_dFaultScores_Set[3] = ar_dFaultScores_data;
ar_dFaultScores_Set[4] = ar_dFaultScores_data_random;
ar_dFaultScores_Set[5] = ar_dFaultScores_data_huge;
while((opt=getopt_long(argc,argv,"chvfqn:",long_args,&option_index)) != -1)
{
switch(opt)
{
@@ -212,19 +240,12 @@ int main(const int argc, char ** const argv)
Status = E_ERROR__UNKNOWN_ARGUMENT;
ErrorCheck_gotoCleanUp();
break;
/*
case 'l':
strncpy(sOptions.szLogFileName, optarg, 2048);
break;
*/
/*
case 't':
strncpy(sOptions.szTSVFile, optarg, 2048);
break;
*/
case 'q':
sOptions.bQuick = true;
break;
case 'c':
sOptions.bContinue = true;
break;
case 'f':
sOptions.bForce = true;
break;
@@ -290,7 +311,14 @@ int main(const int argc, char ** const argv)
srandom(time(NULL));
FaultSource_reset(ar_dFaultScores);
FaultSource_reset(ar_dFaultScores_no_mem);
FaultSource_reset(ar_dFaultScores_control);
FaultSource_reset(ar_dFaultScores_address);
FaultSource_reset(ar_dFaultScores_data);
FaultSource_reset(ar_dFaultScores_data_random);
FaultSource_reset(ar_dFaultScores_data_huge);
FaultSource_reset(ar_dFaultScores_ALL);
FaultSource_reset(ar_dFaultScores_sorted);
for(long j=0; j < sOptions.lNumLoops; j++)
{
@@ -334,7 +362,7 @@ int main(const int argc, char ** const argv)
}
else
{
Status = E_ERROR__NO_TMU_SELECTED; //FixMe: custom error
Status = E_ERROR__WRONG_TMU_SELECTED;
ErrorCheck_gotoCleanUp();
}
}
@@ -425,7 +453,8 @@ int main(const int argc, char ** const argv)
if((tmu == 0) && !bTestTMU0) continue;
if((tmu == 1) && !bTestTMU1) continue;
logI("## testing Board %d, TMU %d, %ldMB \n",boardNum,tmu,(unsigned long)devInfo.tmuMemSize[tmu]);
logI("## testing Board %d, TMU %d, %ldMB \n",
boardNum,tmu,(unsigned long)devInfo.tmuMemSize[tmu]);
if(sOptions.bTestNoMem)
{
@@ -434,11 +463,11 @@ int main(const int argc, char ** const argv)
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
}
logI("### data test - no mem\n");
clearScreen(sstregs,0x00000000,256,256);
clearScreen(sstregs, 0x00000000, 256, 256);
clock_t test_begin = clock();
do
@@ -447,23 +476,28 @@ int main(const int argc, char ** const argv)
sst,
sstregs,
tmu ,
ar_dFaultScores);
ar_dFaultScores_no_mem);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while(!err &&
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< _DEF_TEST_TIME_PER_MB_S));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_no_mem);
if(err)
{
logW("error detected on TMUs tex lines (no-mem test) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
logI("\n");
ISET(sstregs->lfbMode,
@@ -477,11 +511,11 @@ int main(const int argc, char ** const argv)
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
}
logI("### control lines test - simple\n");
clearScreen(sstregs,0x00000000,256,256);
clearScreen(sstregs, 0x00000000, 256, 256);
clock_t test_begin = clock();
int i=0;
@@ -492,7 +526,7 @@ int main(const int argc, char ** const argv)
sstregs,
tmu,
devInfo.tmuMemSize[tmu],
ar_dFaultScores);
ar_dFaultScores_control);
ullNbErrorAll += err;
if(err || (((i++)%1000)==0))
{
@@ -500,18 +534,22 @@ int main(const int argc, char ** const argv)
fflush(stdout);
}
}
while(!err
&& (((double)(clock() - test_begin)/CLOCKS_PER_SEC)
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< _DEF_TEST_TIME_PER_MB_S));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_control);
if(err)
{
logW("error detected on control line !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
if(sOptions.bTestTMUAddress && (devInfo.tmuMemSize[tmu]>0))
{
@@ -520,11 +558,11 @@ int main(const int argc, char ** const argv)
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
HeatMemAndTMU(&devInfo, sst, sstregs, tmu,0x000000);
}
logI("### address lines test - cumulated\n");
clearScreen(sstregs,0x00000000,256,256);
clearScreen(sstregs, 0x00000000, 256, 256);
clock_t test_begin = clock();
int i=0;
@@ -540,7 +578,7 @@ int main(const int argc, char ** const argv)
sstregs,
tmu,
stepMemSize,
ar_dFaultScores);
ar_dFaultScores_address);
ullNbErrorAll += err;
if(err || (((i++)%28)==0))
{
@@ -549,18 +587,22 @@ int main(const int argc, char ** const argv)
}
}
}
while(!err
&& (((double)(clock() - test_begin)/CLOCKS_PER_SEC)
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_address);
if(err)
{
logW("error detected on address line !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
if(sOptions.bTestTMUData && (devInfo.tmuMemSize[tmu]>0))
{
@@ -569,11 +611,11 @@ int main(const int argc, char ** const argv)
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
}
logI("### data test - single bit move\n");
clearScreen(sstregs,0x00000000,256,256);
clearScreen(sstregs, 0x00000000, 256, 256);
clock_t test_begin = clock();
do
@@ -584,31 +626,35 @@ int main(const int argc, char ** const argv)
tmu ,
0, /* bit shift mode */
devInfo.tmuMemSize[tmu],
ar_dFaultScores);
ar_dFaultScores_data);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while(!err &&
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_data);
if(err)
{
logW("error detected on data line (single bit move) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
}
logI("### data test - random patterns\n");
clearScreen(sstregs,0x00000000,256,256);
clearScreen(sstregs, 0x00000000, 256, 256);
test_begin = clock();
do
@@ -619,23 +665,27 @@ int main(const int argc, char ** const argv)
tmu ,
1, /* random mode */
devInfo.tmuMemSize[tmu],
ar_dFaultScores);
ar_dFaultScores_data_random);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while(!err &&
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_data_random);
if(err)
{
logW("error detected on data line (random patterns) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
if(sOptions.bTestTMUDataHuge && (devInfo.tmuMemSize[tmu]>0))
{
@@ -644,11 +694,11 @@ int main(const int argc, char ** const argv)
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
}
logI("### data test - huge data set\n");
clearScreen(sstregs,0x00000000,256,256);
clearScreen(sstregs, 0x00000000, 256, 256);
clock_t test_begin = clock();
do
@@ -658,23 +708,27 @@ int main(const int argc, char ** const argv)
sstregs,
tmu ,
devInfo.tmuMemSize[tmu],
ar_dFaultScores);
ar_dFaultScores_data_huge);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while(!err &&
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_data_huge);
if(err)
{
logW("error detected on data line (huge data set) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
logI("\n");
}
@@ -682,7 +736,12 @@ int main(const int argc, char ** const argv)
sst = NULL;
}
FaultSource_getSorted(ar_dFaultScores_sorted,ar_dFaultScores);
FaultSource_sum(ar_dFaultScores_Set,
uNb_dFaultScores_Set,
ar_dFaultScores_ALL);
FaultSource_getSorted(ar_dFaultScores_sorted,ar_dFaultScores_ALL);
FaultSource_nomalize(ar_dFaultScores_sorted);
FaultSource_divideAll(ar_dFaultScores_sorted,0.01);
FaultSource_display(ar_dFaultScores_sorted);
logI("test completed, ullNbErrorAll = %lld\n",ullNbErrorAll);