Update Readme.md

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",
+		printf("%02.3f\t%s [%s]\n",
-				100 * pCtx[idx].dScore / dScoreSum,
+				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);
+}

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_TT_DATA_0, "pin 188" ,U8_TMU1, 1.0)/*Offset: 65*/\
-		ACTION(U8_TMU1_TF_DATA_1, "pin 32" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_1, "pin 189" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_2, "pin 33" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_2, "pin 190" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_3, "pin 34" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_3, "pin 191" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_4, "pin 35" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_4, "pin 192" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_5, "pin 36" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_5, "pin 193" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_6, "pin 37" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_6, "pin 194" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_7, "pin 38" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_7, "pin 195" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_8, "pin 42" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_8, "pin 199" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_9, "pin 44" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_9, "pin 200" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_10, "pin 45" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_10, "pin 201" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_11, "pin 46" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_11, "pin 202" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_12, "pin 47" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_12, "pin 204" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_13, "pin 48" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_13, "pin 205" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_14, "pin 49" ,U8_TMU1, 1.0)\
+		ACTION(U8_TMU1_TT_DATA_14, "pin 206" ,U8_TMU1, 1.0)\
-		ACTION(U8_TMU1_TF_DATA_15, "pin 80" ,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)\
+		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_WE, "pin 136" ,U8_TMU1, 1.0)/*Offset: 119*/\
-		ACTION(U8_TMU1_TEX_ADDR_0_0, "pin 138" ,U8_TMU1, 1.0)\
+		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_

Readme.md

@@ -27,6 +27,12 @@ As this is an open-source tool, feel free to Fork, Raise Tickets or to send Pull
 
 ## Requirements
 
+### The Easiest way : 
+
+[RetroDebian Live](https://gitea.chacha.ddns.net/chacha/RetroDebian)
+
+### The Hard way :
+
 To build this tool you need GNU Make, GCC and Glide 2.x SDK.
 
 Requirement to run this tools depends on the build platform and options.
@@ -60,7 +66,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
@@ -68,7 +74,7 @@ Here is the [hopefully updated] project status.
 		- [X] log level
 		- [ ] log to file
 	- [X] fault analysis
-	- [ ] standalone easy tool (.exe or iso)
+	- [X] standalone easy tool (.exe or iso)
 - [ ] Chore (might never be done...)
 	- [ ] use fixed size types (***e.g. FxUINT32 or uint32_t instead of unsigned long***)
 	- [ ] port / test on more modern build system
@@ -105,20 +111,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
+	- [X] TMU1 to TMU0 fault
-	- [ ] TMU0 to FBI 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 +214,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
 

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++)

Test_Common.c

@@ -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

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_

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);
+		RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U9_TMU0_TF_DATA_0);
-		LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U3_FBI_TF_DATA_0, U3_FBI_TF_DATA_0);
+		RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U3_FBI_TF_DATA_0);
-		QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 0,  1.0 / 16, RA10_1);
+		RGBToBus_Fault_Quartets(pFaultSrcCtx, ErrorMark_L1, 1.0/2, 
-		QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L1 >> 4,  1.0 / 16, RA11_1);
+								RA10_1, RA11_1, RA12_1, RA13_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);
-		
 		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);
+			RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, U9_TMU0_TT_DATA_0);
-			LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, TT_TDATA_R131, TT_TDATA_R131);
+			RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, TT_TDATA_R131);
-			LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U8_TMU1_TF_DATA_0, U8_TMU1_TF_DATA_0);
+			RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L1, 1.0/2, 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, 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);
+		RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U9_TMU0_TF_DATA_0);
-		LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U3_FBI_TF_DATA_0, U3_FBI_TF_DATA_0);
+		RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U3_FBI_TF_DATA_0);
-		QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 0,   1.0 / 16, RA10_1);
+		RGBToBus_Fault_Quartets(pFaultSrcCtx, ErrorMark_L2, 1.0/2, 
-		QuartetBitFaultSet(pFaultSrcCtx, ErrorMark_L2 >> 4,   1.0 / 16, RA11_1);
+								RA10_1, RA11_1, RA12_1, RA13_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);
-		
 		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);
+			RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, U9_TMU0_TT_DATA_0);
-			LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, TT_TDATA_R131, TT_TDATA_R131);
+			RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, TT_TDATA_R131);
-			LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U8_TMU1_TF_DATA_0, U8_TMU1_TF_DATA_0);
+			RGBToBus_Fault(pFaultSrcCtx, ErrorMark_L2, 1.0/2, 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, 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);
 		

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,
+								+ ARGBrelbitIdx,
-							1.0/4);
+							dARGBScore);
 	
 	/* Output path, TMU0 to FBI*/
 	FaultSource_addScore(	pFaultSrcCtx, 
 							U9_TMU0
 								+ 97	//U9_TMU0_TF_DATA_x
-								+ relbitIdxWord,
+								+ ARGBrelbitIdx,
-							1.0/4);
+							dARGBScore);
 	
 	FaultSource_addScore(	pFaultSrcCtx, 
 							U3_FBI_TF_DATA_0
-								+ relbitIdxWord,
+								+ ARGBrelbitIdx,
-							1.0/4);
+							dARGBScore);
 	
-	switch(WordIdx)
+	if(ARGBrelbitIdx>=12)
 	{
-		case 0:
+		logD("- RA13_x : %s\n",pFaultSrcCtx[RA13_1+ARGBrelbitIdx-12].szName);
-		case 2:
+		FaultSource_addScore(	pFaultSrcCtx,
-			if(relbitIdx<=3)
+								RA13_1
-			{
+									+ ARGBrelbitIdx -12,
-				logD("- RA1x_x : %s\n",pFaultSrcCtx[RA10_1+relbitIdxQuartet].szName);
+								dARGBScore);
-				FaultSource_addScore(	pFaultSrcCtx,
+	}
-										RA10_1
+	else if(ARGBrelbitIdx>=8)
-											+ relbitIdxQuartet,
+	{
-										1.0/8);
+		logD("- RA12_x : %s\n",pFaultSrcCtx[RA12_1+ARGBrelbitIdx-8].szName);
-			}
+		FaultSource_addScore(	pFaultSrcCtx,
-			else
+								RA12_1
-			{
+									+ ARGBrelbitIdx -8,
-				logD("- RA1x_x : %s\n",pFaultSrcCtx[RA11_1+relbitIdxQuartet].szName);
+								dARGBScore);
-				FaultSource_addScore(	pFaultSrcCtx,
+	}
-										RA11_1
+	else if(ARGBrelbitIdx>=4)
-											+ relbitIdxQuartet,
+	{
-										1.0/8);
+		logD("- RA11_x : %s\n",pFaultSrcCtx[RA11_1+ARGBrelbitIdx-4].szName);
-			}
+		FaultSource_addScore(	pFaultSrcCtx,
-			break;
+								RA11_1
-		case 1:
+									+ ARGBrelbitIdx -4,
-		case 3:
+								dARGBScore);
-			if(relbitIdx<=3)
+	}
-			{
+	else
-				logD("- RA1x_x : %s\n",pFaultSrcCtx[RA12_1+relbitIdxQuartet].szName);
+	{
-				FaultSource_addScore(	pFaultSrcCtx,
+		logD("- RA10_x : %s\n",pFaultSrcCtx[RA10_1+ARGBrelbitIdx].szName);
-										RA12_1
+		FaultSource_addScore(	pFaultSrcCtx,
-											+ relbitIdxQuartet,
+								RA10_1
-										1.0/8);
+									+ ARGBrelbitIdx,
-			}
+								dARGBScore);
-			else
-			{
-				logD("- RA1x_x : %s\n",pFaultSrcCtx[RA13_1+relbitIdxQuartet].szName);
-				FaultSource_addScore(	pFaultSrcCtx,
-										RA13_1
-											+ relbitIdxQuartet,
-										1.0/8);
-			}
-			break;
 	}
 	
 	/* 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,
+									+ ARGBrelbitIdx,
-								1.0/4);
+								dARGBScore);
 		/* line adaptation resistors */
 		FaultSource_addScore(	pFaultSrcCtx,
 								TT_TDATA_R131
 									+ 0
-									+ relbitIdxWord, 
+									+ ARGBrelbitIdx, 
-								1.0/4);
+								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,
+									+ ARGBrelbitIdx,
-								1.0/4);
+								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 create: %f\n",
-	logI("time to write: %f\n",(double)(after_write-after_create)/CLOCKS_PER_SEC);
+	(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 draw [%d]: %f\n",
-		logI("time to read [%d]: %f\n",i,(double)(after_read[i]-after_draw[i])/CLOCKS_PER_SEC);
+		i, (double)(after_draw[i]-before_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 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);

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; 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;
 		}
 	}
+	
+	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; i<uNbREFPatterns;i++)
+		if((!ScoreSet[i].pREF->bReferenceSet) && (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]);*/
 	}
 	

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 <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;

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 <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'},
+	{"force",		no_argument,		NULL,						'f'},
-	/*{"log",			required_argument,	NULL,						'l'},*/
+	{"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 
+static def_sFaultSourceScoreRec 
-ar_dFaultScores[NB_FAULT_SOURCE];
+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,
+													sst,
-														sstregs,
+													sstregs,
-														tmu ,
+													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");
-					logW("skiping next tests.\n\n");
+					if(!sOptions.bContinue)
-					continue;
+					{
+						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
+				while(	(!err || sOptions.bContinue) &&
-						&& (((double)(clock() - test_begin)/CLOCKS_PER_SEC)
+						(((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");
+					if(!sOptions.bContinue)
-					continue;
+					{
+						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
+				while(	(!err || sOptions.bContinue) &&
-						&& (((double)(clock() - test_begin)/CLOCKS_PER_SEC)
+						(((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");
+					if(!sOptions.bContinue)
-					continue;
+					{
+						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");
+					if(!sOptions.bContinue)
-					continue;
+					{
+						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");
+					if(!sOptions.bContinue)
-					continue;
+					{
+						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");
+					if(!sOptions.bContinue)
-					continue;
+					{
+						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);