diff --git a/FaultSources.c b/FaultSources.c index f1916ca..879dab5 100644 --- a/FaultSources.c +++ b/FaultSources.c @@ -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); +} diff --git a/FaultSources.h b/FaultSources.h index b2739bc..2d5a583 100644 --- a/FaultSources.h +++ b/FaultSources.h @@ -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_ diff --git a/Readme.md b/Readme.md index 0456110..d3eca0c 100644 --- a/Readme.md +++ b/Readme.md @@ -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 diff --git a/Test_Address.c b/Test_Address.c index f133eb2..4bcbd75 100644 --- a/Test_Address.c +++ b/Test_Address.c @@ -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++) diff --git a/Test_Common.c b/Test_Common.c index 55e291f..8822dec 100644 --- a/Test_Common.c +++ b/Test_Common.c @@ -45,9 +45,9 @@ HeatMemAndTMU( sst1DeviceInfoStruct * const devInfo, for (int i=0; itextureMode, 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 diff --git a/Test_Common.h b/Test_Common.h index 931bb0e..71dac1e 100644 --- a/Test_Common.h +++ b/Test_Common.h @@ -24,5 +24,6 @@ HeatMemAndTMU( sst1DeviceInfoStruct * const devInfo, SstRegs * const sstregs, const char ucNumTMU, const FxU32 mem); + #endif //_DEF_TEST_COMMON_H_ diff --git a/Test_Data.c b/Test_Data.c index e70ae93..06372ca 100644 --- a/Test_Data.c +++ b/Test_Data.c @@ -73,59 +73,46 @@ 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++; logD("===========================================================\n"); 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,47 +123,43 @@ 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++; logD("===========================================================\n"); 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); diff --git a/Test_Data_Huge.c b/Test_Data_Huge.c index bb90314..5775082 100644 --- a/Test_Data_Huge.c +++ b/Test_Data_Huge.c @@ -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); - FaultSource_addScore( pFaultSrcCtx, - RA13_1 - + relbitIdxQuartet, - 1.0/8); - } - break; + logD("- RA13_x : %s\n",pFaultSrcCtx[RA13_1+ARGBrelbitIdx-12].szName); + FaultSource_addScore( pFaultSrcCtx, + RA13_1 + + ARGBrelbitIdx -12, + dARGBScore); + } + 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); diff --git a/Test_Data_NoMem.c b/Test_Data_NoMem.c index c276e22..c5ef1a0 100644 --- a/Test_Data_NoMem.c +++ b/Test_Data_NoMem.c @@ -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,52 +177,57 @@ unsigned char DistributeFaults( const def_sTestPattern * const pREF, GetNearestIndexes(pREF,pREFPatterns,ScoreSet,uNbREFPatterns); - for( int i =0; ibReferenceSet && ScoreSet[i].dScore==100) { //logD("No Fault found\n"); + free(ScoreSet); return 0; } } + + logD("==========================\n"); + logD("Read:\n"); if( sOptions.eLogLevel >= E_LOGLEVEL__DEBUG) - { DisplayPattern(pREF); + for( int i = 0 ; i < uNbREFPatterns ; i++) + { logD("==========================\n"); - for( int i =0; ibReferenceSet) && (ScoreSet[i].dScore>=80)) { - if((!ScoreSet[i].pREF->bReferenceSet) && (ScoreSet[i].dScore>=80)) + logD( "%d Score = %f\n", + ScoreSet[i].pREF->u8FaultLineIdx,ScoreSet[i].dScore); + FaultSource_addScore( pFaultSrcCtx, + ar_sFaultSourceLineMap + [ScoreSet[i].pREF->u8FaultLineIdx] + .eTMUFaultSource_TMU0_RES, + ScoreSet[i].dScore); + + FaultSource_addScore( pFaultSrcCtx, + ar_sFaultSourceLineMap + [ScoreSet[i].pREF->u8FaultLineIdx] + .eTMUFaultSource_FBI, + ScoreSet[i].dScore); + + FaultSource_addScore( pFaultSrcCtx, + ar_sFaultSourceLineMap + [ScoreSet[i].pREF->u8FaultLineIdx] + .eTMUFaultSource_TMU0_FBI, + ScoreSet[i].dScore); + if(ucNumTMU==1) { - logD( "%d Score = %f\n", - ScoreSet[i].pREF->u8FaultLineIdx,ScoreSet[i].dScore); FaultSource_addScore( pFaultSrcCtx, ar_sFaultSourceLineMap [ScoreSet[i].pREF->u8FaultLineIdx] - .eTMUFaultSource_TMU0_RES, + .eTMUFaultSource_TMU0_TMU1, ScoreSet[i].dScore); - /*FaultSource_addScore( pFaultSrcCtx, - ar_sFaultSourceLineMap - [ScoreSet[i].pREF->u8FaultLineIdx] - .eTMUFaultSource_FBI, - ScoreSet[i].dScore);*/ + FaultSource_addScore( pFaultSrcCtx, ar_sFaultSourceLineMap [ScoreSet[i].pREF->u8FaultLineIdx] - .eTMUFaultSource_TMU0_FBI, + .eTMUFaultSource_TMU1, ScoreSet[i].dScore); - if(ucNumTMU==1) - { - FaultSource_addScore( pFaultSrcCtx, - ar_sFaultSourceLineMap - [ScoreSet[i].pREF->u8FaultLineIdx] - .eTMUFaultSource_TMU0_TMU1, - ScoreSet[i].dScore); - FaultSource_addScore( pFaultSrcCtx, - ar_sFaultSourceLineMap - [ScoreSet[i].pREF->u8FaultLineIdx] - .eTMUFaultSource_TMU1, - ScoreSet[i].dScore); - } } } } @@ -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]);*/ } diff --git a/V2MemTest.h b/V2MemTest.h index 4248c62..39fe51b 100644 --- a/V2MemTest.h +++ b/V2MemTest.h @@ -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 @@ -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; diff --git a/main.c b/main.c index 8af8b20..7ab22ad 100644 --- a/main.c +++ b/main.c @@ -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 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 Log file path.\n"*/ " --silent Silent mode (suppress normal output).\n" - /*" -t, --tsv 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 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[] = { /* {, , , */ {"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,34 +463,39 @@ 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 { err = test_TMU_datalines_NoMem( &devInfo, - sst, - sstregs, - tmu , - ar_dFaultScores); + sst, + sstregs, + tmu , + 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"); - logW("skiping next tests.\n\n"); - continue; + if(!sOptions.bContinue) + { + logW("skiping next tests.\n\n"); + continue; + } } } logI("\n"); @@ -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,16 +534,20 @@ 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"); - logW("skiping next tests.\n\n"); - continue; + if(!sOptions.bContinue) + { + logW("skiping next tests.\n\n"); + continue; + } } } @@ -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,16 +587,20 @@ 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"); - logW("skiping next tests.\n\n"); - continue; + if(!sOptions.bContinue) + { + logW("skiping next tests.\n\n"); + continue; + } } } @@ -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"); - logW("skiping next tests.\n\n"); - continue; + 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,36 +665,40 @@ 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"); - logW("skiping next tests.\n\n"); - continue; + if(!sOptions.bContinue) + { + logW("skiping next tests.\n\n"); + continue; + } } } - if(sOptions.bTestTMUDataHuge && (devInfo.tmuMemSize[tmu]>0)) + if(sOptions.bTestTMUDataHuge && (devInfo.tmuMemSize[tmu]>0)) { unsigned long long err=0; 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,21 +708,25 @@ 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"); - logW("skiping next tests.\n\n"); - continue; + if(!sOptions.bContinue) + { + logW("skiping next tests.\n\n"); + continue; + } } } logI("\n"); @@ -681,8 +735,13 @@ int main(const int argc, char ** const argv) sst1InitShutdown(sst); 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);