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

implement no-mem test and start validating / tuning with real hardware

Browse Source
This commit is contained in:
ChaCha
2026-03-15 22:18:42 +01:00
parent 3ba8a3a985
commit c363aa6284
22 changed files with 2780 additions and 546 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
Draw.c
View File

@@ -28,64 +28,157 @@ static inline uint32_t f32u(const float f)
}
void
drawRect( const SstRegs * const sst,
drawRect( const SstRegs * const sstregs,
const unsigned char ucNumTMU,
const int16_t x,
const int16_t y,
const int16_t tSizeX,
const int16_t tSizeY)
{
ISET(sst->sARGB,0xFFFFFFFF);
ISET(sst->sOowfbi,f32u(1.0f));
ISET(sst->sVx, f32u((float)x));
ISET(sst->sVy, f32u((float)y));
ISET(sst->sSow0,f32u(0.0f));
ISET(sst->sTow0,f32u(0.0f));
ISET(sstregs->sSetupMode, 0x0020);
ISET(SST_TREX(sstregs,ucNumTMU)->sARGB,0xFFFFFFFF);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y));
ISET(SST_TREX(sstregs,ucNumTMU)->sOowfbi,f32u(1.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0,f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0,f32u(0.0f));
/* 0b10 0000 (Update only S0/T0), doc page 76 */
ISET(sst->sSetupMode, 0x0020);
ISET(sst->sBeginTriCMD, 1);
ISET(sstregs->sBeginTriCMD, 1);
ISET(sst->sVx, f32u((float)(x+tSizeX)));
ISET(sst->sVy, f32u((float)y));
ISET(sst->sSow0,f32u((float)tSizeX));
ISET(sst->sTow0,f32u(0.0f));
ISET(sst->sDrawTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)(x+tSizeX)));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0,f32u((float)tSizeX));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0,f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(sst->sVx, f32u((float)x));
ISET(sst->sVy, f32u((float)y+tSizeY));
ISET(sst->sSow0,f32u(0.0f));
ISET(sst->sTow0,f32u((float)tSizeY));
ISET(sst->sDrawTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y+tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0,f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0,f32u((float)tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(sst->sVx, f32u((float)x+tSizeX));
ISET(sst->sVy, f32u((float)y+tSizeY));
ISET(sst->sSow0,f32u((float)tSizeX));
ISET(sst->sTow0,f32u((float)tSizeY));
ISET(sst->sDrawTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x+tSizeX));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y+tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0,f32u((float)tSizeX));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0,f32u((float)tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(sst->nopCMD, 0x1);
ISET(sstregs->nopCMD, 0x1);
}
void
drawRect2( const SstRegs * const sstregs,
const unsigned char ucNumTMU,
const int16_t x,
const int16_t y,
const int16_t tSizeX,
const int16_t tSizeY)
{
ISET(sstregs->sSetupMode, 0x0020);
//ISET(SST_TREX(sstregs,ucNumTMU)->sARGB,0xFF55AA55);
ISET(SST_TREX(sstregs,ucNumTMU)->sOowfbi, f32u(1.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0, f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0, f32u(0.0f));
/* 0b10 0000 (Update only S0/T0), doc page 76 */
ISET(sstregs->sBeginTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)(x+tSizeX)));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0, f32u((float)tSizeX));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0, f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y+tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0, f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0, f32u((float)tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x+tSizeX));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y+tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0, f32u((float)tSizeX));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0, f32u((float)tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(sstregs->nopCMD, 0x1);
}
void
clearScreen( const SstRegs * const sst,
clearScreen( const SstRegs * const sstregs,
const uint32_t u32Color,
const int16_t u16SizeX,
const int16_t u16SizeY)
{
ISET(sst->clipLeftRight, u16SizeX);
ISET(sst->clipBottomTop, u16SizeY);
ISET(sst->zaColor, u32Color);
//ISET(sst->zaColor, 0x0000);
ISET(sstregs->clipLeftRight, u16SizeX);
ISET(sstregs->clipBottomTop, u16SizeY);
ISET(sstregs->zaColor, u32Color);
//ISET(sstregs->zaColor, 0x0000);
const uint32_t fbz_saved = IGET(sst->fbzMode);
ISET(sst->c1,u32Color);
ISET(sst->c0,0x0);
ISET(sst->zaColor,0x0);
ISET(sst->fbzMode, SST_RGBWRMASK | SST_ZAWRMASK);
ISET(sst->fastfillCMD, 0);
ISET(sst->nopCMD, 0x1);
ISET(sst->fbzMode, fbz_saved);
const uint32_t fbz_saved = IGET(sstregs->fbzMode);
ISET(sstregs->c1,u32Color);
ISET(sstregs->c0,0x0);
ISET(sstregs->zaColor,0x0F);
ISET(sstregs->fbzMode, SST_RGBWRMASK | SST_ZAWRMASK);
ISET(sstregs->fastfillCMD, 0);
ISET(sstregs->nopCMD, 0x1);
ISET(sstregs->fbzMode, fbz_saved);
}
#define XY_ONE (1<<SST_XY_FRACBITS)
void
drawPixel( const SstRegs *sstregs,
const unsigned char ucNumTMU,
const int x,
const int y)
{
ISET( SST_TREX(sstregs,ucNumTMU)->vA.x,x*XY_ONE);
ISET(SST_TREX(sstregs,ucNumTMU)->vA.y,y*XY_ONE);
ISET(SST_TREX(sstregs,ucNumTMU)->vB.x,(x+2)*XY_ONE);
ISET(SST_TREX(sstregs,ucNumTMU)->vB.y,y*XY_ONE);
ISET(SST_TREX(sstregs,ucNumTMU)->vC.x,x*XY_ONE);
ISET(SST_TREX(sstregs,ucNumTMU)->vC.y,(y+1)*XY_ONE);
ISET(SST_TREX(sstregs,ucNumTMU)->triangleCMD,0);
}
void
drawTriangle( const SstRegs * const sstregs,
const unsigned char ucNumTMU,
const int16_t x,
const int16_t y,
const int16_t tSizeX,
const int16_t tSizeY)
{
ISET(sstregs->sSetupMode, 0x0020);
//ISET(SST_TREX(sstregs,ucNumTMU)->sARGB,0xFF55AA55);
ISET(SST_TREX(sstregs,ucNumTMU)->sOowfbi, f32u(1.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0, f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0, f32u(0.0f));
/* 0b10 0000 (Update only S0/T0), doc page 76 */
ISET(sstregs->sBeginTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)(x+tSizeX)));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0, f32u((float)tSizeX));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0, f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(SST_TREX(sstregs,ucNumTMU)->sVx, f32u((float)x));
ISET(SST_TREX(sstregs,ucNumTMU)->sVy, f32u((float)y+tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sSow0, f32u(0.0f));
ISET(SST_TREX(sstregs,ucNumTMU)->sTow0, f32u((float)tSizeY));
ISET(SST_TREX(sstregs,ucNumTMU)->sDrawTriCMD, 1);
ISET(sstregs->nopCMD, 0x1);
}

32
Draw.h
View File

@@ -21,23 +21,47 @@
#include <stdint.h>
void
drawRect( const SstRegs * const sst,
drawRect( const SstRegs * const sstregs,
const unsigned char ucNumTMU,
const int16_t x,
const int16_t y,
const int16_t tSizeX,
const int16_t tSizeY);
void
drawRect2( const SstRegs * const sstregs,
const unsigned char ucNumTMU,
const int16_t x,
const int16_t y,
const int16_t tSizeX,
const int16_t tSizeY);
void
drawTriangle( const SstRegs * const sstregs,
const unsigned char ucNumTMU,
const int16_t x,
const int16_t y,
const int16_t tSizeX,
const int16_t tSizeY);
void
drawPixel( const SstRegs *sstregs,
const unsigned char ucNumTMU,
const int x,
const int y);
static inline void
drawSquare( const SstRegs * const sst,
drawSquare( const SstRegs * const sstregs,
const unsigned char ucNumTMU,
const int16_t x,
const int16_t y,
const int16_t tSize)
{
drawRect(sst, x, y, tSize, tSize);
drawRect(sstregs,ucNumTMU, x, y, tSize, tSize);
}
void
clearScreen( const SstRegs * const sst,
clearScreen( const SstRegs * const sstregs,
const uint32_t u32Color,
const int16_t u16SizeX,
const int16_t u16SizeY);

36
FaultSources.c
View File

@@ -63,14 +63,7 @@ FaultSource_addScore( def_sFaultSourceScoreRec* const pCtx,
do
{
dScore /= dDivider;
pCtx[eFaultSource].dScore += dScore;
/*
if(dDivider==1.0)
printf("Add score to %s : %02.3f\n",
pCtx[eFaultSource].szName,
dScore);
*/
eFaultSource = pCtx[eFaultSource].eParrentFaultSource;
dDivider *= 5;
}while(eFaultSource != _INVALID_FAULT_SOURCE_);
@@ -126,7 +119,7 @@ FaultSource_getSorted( def_sFaultSourceScoreRec* const pDst,
++idx )
pDst[idx].dScore *= pDst[idx].dWeight;
// shaker sort
// shaker sort FixMe: use qsort()
while(bSwapped)
{
bSwapped = 0;
@@ -225,9 +218,36 @@ FaultSource_display(const def_sFaultSourceScoreRec* const pCtx)
}
}
void
ByteBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint8_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource)
{
for(unsigned char bitPos = 0; bitPos <= 7 ; ++bitPos)
if(ErrorMark & (1u << bitPos))
{
FaultSource_addScore(pCtx, eFaultSource + bitPos, dScore);
}
}
void
WordBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint16_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource)
{
for(unsigned char bitPos = 0; bitPos <= 15 ; ++bitPos)
if(ErrorMark & (1u << bitPos))
{
FaultSource_addScore(pCtx, eFaultSource + bitPos, dScore);
}
}
void
LWordBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint32_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSourceL,

51
FaultSources.h
View File

@@ -23,6 +23,38 @@
#define FAULT_SOURCES(ACTION) \
ACTION(U3_FBI, "U3/FBI (front middle big Chip)" ,VOODOO_BOARD, 1.0)\
ACTION(U3_FBI_FT_DATA_0, "pin 179" ,U3_FBI, 1.0)/*Offset: 1*/\
ACTION(U3_FBI_FT_DATA_1, "pin 178" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_2, "pin 176" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_3, "pin 174" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_4, "pin 173" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_5, "pin 172" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_6, "pin 171" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_7, "pin 168" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_8, "pin 167" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_9, "pin 166" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_10, "pin 165" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_11, "pin 164" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_12, "pin 162" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_13, "pin 161" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_14, "pin 160" ,U3_FBI, 1.0)\
ACTION(U3_FBI_FT_DATA_15, "pin 159" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_0, "pin 155" ,U3_FBI, 1.0)/*Offset: 17*/\
ACTION(U3_FBI_TF_DATA_1, "pin 153" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_2, "pin 152" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_3, "pin 151" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_4, "pin 150" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_5, "pin 148" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_6, "pin 147" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_7, "pin 146" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_8, "pin 142" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_9, "pin 141" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_10, "pin 140" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_11, "pin 139" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_12, "pin 138" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_13, "pin 137" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_14, "pin 136" ,U3_FBI, 1.0)\
ACTION(U3_FBI_TF_DATA_15, "pin 135" ,U3_FBI, 1.0)\
ACTION(U9_TMU0, "U9/TMU0 (front right big Chip)" ,VOODOO_BOARD, 1.0)\
/* /!\ Keep in-order, only appEND new fields */ \
ACTION(U9_TMU0_TEXDATA_0_0, "pin 52" ,U9_TMU0, 1.0)/*Offset: 1*/\
@@ -1028,13 +1060,24 @@ FaultSource_getLoc( const def_sFaultSourceScoreRec* const pCtx,
void
FaultSource_display(const def_sFaultSourceScoreRec* const pCtx);
void
FaultSource_divideAll( def_sFaultSourceScoreRec* const pCtx,
const double dDivider);
void
ByteBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint8_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource);
void
WordBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint16_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSource);
void
LWordBitFaultSet( def_sFaultSourceScoreRec* const pCtx,
const uint32_t ErrorMark,
const double dScore,
const def_eFaultSource eFaultSourceL,
@@ -1055,7 +1098,7 @@ MemChipDQFaultSet( def_sFaultSourceScoreRec* const pCtx,
const def_eFaultSource eFaultSourceH)
{
WordBitFaultSet(pCtx,ErrorMark, dScore, eFaultSourceL + 1, eFaultSourceH + 1);
LWordBitFaultSet(pCtx,ErrorMark, dScore, eFaultSourceL + 1, eFaultSourceH + 1);
}
static inline void
@@ -1065,8 +1108,8 @@ TMUTexDataFaultSet( def_sFaultSourceScoreRec* const pCtx,
const double dScore,
const def_eFaultSource eTMUFaultSource)
{
WordBitFaultSet(pCtx,ErrorMark_w0w1, dScore, eTMUFaultSource + 0 + 1, eTMUFaultSource + 16 + 1);
WordBitFaultSet(pCtx,ErrorMark_w2w3, dScore, eTMUFaultSource + 32 + 1, eTMUFaultSource + 48 + 1);
LWordBitFaultSet(pCtx,ErrorMark_w0w1, dScore, eTMUFaultSource + 0 + 1, eTMUFaultSource + 16 + 1);
LWordBitFaultSet(pCtx,ErrorMark_w2w3, dScore, eTMUFaultSource + 32 + 1, eTMUFaultSource + 48 + 1);
}

3
Makefile
View File

@@ -13,8 +13,11 @@ OBJ=OBJs/main.o \
OBJs/Utils.o \
OBJs/Draw.o \
OBJs/Test_Common.o \
OBJs/Test_Control.o \
OBJs/Test_Address.o \
OBJs/Test_Data.o \
OBJs/Test_Data_NoMem_TestPatterns.o \
OBJs/Test_Data_NoMem.o \
OBJs/Test_Data_Huge.o
HEADERS := $(notdir $(wildcard *.h))

503
Test_Address.c
View File

@@ -14,13 +14,17 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdio.h>
#include "cvg.h"
#include <glide.h>
#include "sst1init.h"
#include "fxpci.h"
#include "Utils.h"
#include "V2MemTest.h"
#include "FaultSources.h"
#include "Utils.h"
#include "Draw.h"
@@ -35,9 +39,9 @@ typedef struct _def_sTestAddress {
}def_sTestAddress;
unsigned long
RenderTestAddress( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
RenderTestAddress( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
@@ -64,24 +68,24 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
{0x000004,0,0,0,0}
*/
{0x000008,0,1,0},
/* {target pin}, { + previous adjacent pin} */
{0x000010,0,2,0}, {0x000018,0,2,0},
{0x000020,0,3,0}, {0x000030,0,3,0},
{0x000040,0,4,0}, {0x000060,0,4,0},
{0x000080,0,5,0}, {0x0000C0,0,5,0},
{0x000100,0,6,0}, {0x000180,0,6,0},
{0x000200,0,7,0}, {0x000300,0,7,0},
{0x000400,0,8,0}, {0x000600,0,8,0},
{0x000800,0,9,0}, {0x000C00,0,9,0},
{0x001000,0,0,1}, {0x001800,0,0,1},
{0x002000,0,0,2}, {0x003000,0,0,2},
{0x004000,0,0,3}, {0x006000,0,0,3},
{0x008000,0,0,4}, {0x00C000,0,0,4},
{0x010000,0,0,5}, {0x018000,0,0,5},
{0x020000,0,0,6}, {0x030000,0,0,6},
{0x040000,0,0,7}, {0x060000,0,0,7},
{0x080000,0,0,8}, {0x0C0000,0,0,8},
{0x100000,0,0,9}, {0x180000,0,0,9},
/* {target pin} */
{0x000010,0,2,0},
{0x000020,0,3,0},
{0x000040,0,4,0},
{0x000080,0,5,0},
{0x000100,0,6,0},
{0x000200,0,7,0},
{0x000400,0,8,0},
{0x000800,0,9,0},
{0x001000,0,0,1},
{0x002000,0,0,2},
{0x004000,0,0,3},
{0x008000,0,0,4},
{0x010000,0,0,5},
{0x020000,0,0,6},
{0x040000,0,0,7},
{0x080000,0,0,8},
{0x100000,0,0,9},
/* Bank1 */
{0x200000,1,0,0},
@@ -91,26 +95,27 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
{0x200004,1,0,0,0}
*/
{0x200008,1,1,0},
/* {target pin}, { + previous adjacent pin} */
{0x200010,1,2,0}, {0x200018,1,2,0},
{0x200020,1,3,0}, {0x200030,1,3,0},
{0x200040,1,4,0}, {0x200060,1,4,0},
{0x200080,1,5,0}, {0x2000C0,1,5,0},
{0x200100,1,6,0}, {0x200180,1,6,0},
{0x200200,1,7,0}, {0x200300,1,7,0},
{0x200400,1,8,0}, {0x200600,1,8,0},
{0x200800,1,9,0}, {0x200C00,1,9,0},
{0x201000,1,0,1}, {0x201800,1,0,1},
{0x202000,1,0,2}, {0x203000,1,0,2},
{0x204000,1,0,3}, {0x206000,1,0,3},
{0x208000,1,0,4}, {0x20C000,1,0,4},
{0x210000,1,0,5}, {0x218000,1,0,5},
{0x220000,1,0,6}, {0x230000,1,0,6},
{0x240000,1,0,7}, {0x260000,1,0,7},
{0x280000,1,0,8}, {0x2C0000,1,0,8},
{0x300000,1,0,9}, {0x380000,1,0,9},
/* {target pin} */
{0x200010,1,2,0},
{0x200020,1,3,0},
{0x200040,1,4,0},
{0x200080,1,5,0},
{0x200100,1,6,0},
{0x200200,1,7,0},
{0x200400,1,8,0},
{0x200800,1,9,0},
{0x201000,1,0,1},
{0x202000,1,0,2},
{0x204000,1,0,3},
{0x208000,1,0,4},
{0x210000,1,0,5},
{0x220000,1,0,6},
{0x240000,1,0,7},
{0x280000,1,0,8},
{0x300000,1,0,9},
};
logD("testing %d MB of memory\n",RamSizeMB);
for(unsigned char idx=0;
idx < (sizeof(add_list)/sizeof(def_sTestAddress));
idx++)
@@ -120,10 +125,40 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
if(RamSizeMB<3 && add_list[idx].u32Addr >= 0x200000) continue;
if(RamSizeMB<2 && add_list[idx].u32Addr >= 0x100000) continue;
logT("idx = %d\n",idx);
logT("u32Addr = 0x%08X\n",add_list[idx].u32Addr);
const uint32_t TestVal1 = get_notnull_random_balanced_mByte();
const uint32_t TestVal2 = get_notnull_random_balanced_mByte();
const uint32_t TestValBlank1 = get_notnull_random_balanced_mByte();
const uint32_t TestValBlank2 = get_notnull_random_balanced_mByte();
logT("TestVal1 = %08X\n",TestVal1);
uint32_t TestVal2 = 0;
do
{
TestVal2 = get_notnull_random_balanced_mByte();
}
while((count_bit32((TestVal2 ^ TestVal1)) < 12));
logT("TestVal2 = %08X\n",TestVal2);
uint32_t TestValBlank1 = 0;
do
{
TestValBlank1 = get_notnull_random_balanced_mByte();
}
while( (count_bit32((TestValBlank1 ^ TestVal1) & 0x0000FFFF) < 6)
|| (count_bit32((TestValBlank1 ^ TestVal1) & 0xFFFF0000) < 6)
|| (count_bit32((TestValBlank1 ^ TestVal2)) < 12));
logT("TestValBlank1 = %08X\n",TestValBlank1);
uint32_t TestValBlank2 = 0;
do
{
TestValBlank2 = get_notnull_random_balanced_mByte();
}
while( (count_bit32((TestValBlank2 ^ TestVal2) & 0x0000FFFF) < 6)
|| (count_bit32((TestValBlank2 ^ TestVal2) & 0xFFFF0000) < 6)
|| (count_bit32((TestValBlank2 ^ TestValBlank1)) < 12)
|| (count_bit32((TestValBlank2 ^ TestVal1)) < 12));
logT("TestValBlank2 = %08X\n",TestValBlank2);
/* Clearing memory targets */
for(unsigned char idxclr=0;
@@ -136,7 +171,7 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
if(RamSizeMB<2 && add_list[idxclr].u32Addr >= 0x100000) continue;
/* set base mem @ */
ISET(sstregs->texBaseAddr, (add_list[idxclr].u32Addr>>3));
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, (add_list[idxclr].u32Addr>>3));
/* set @ to first line, using bits 00..31*/
volatile const FxU32 *texAddrBlank
@@ -157,7 +192,7 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
}
/* set base mem @ */
ISET(sstregs->texBaseAddr, (add_list[idx].u32Addr>>3));
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, (add_list[idx].u32Addr>>3));
/* set @ to first line, using bits 00..31*/
volatile const FxU32 *texAddr
@@ -184,18 +219,18 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
if(RamSizeMB<4 && add_list[idxdraw].u32Addr >= 0x300000) continue;
if(RamSizeMB<3 && add_list[idxdraw].u32Addr >= 0x200000) continue;
if(RamSizeMB<2 && add_list[idxdraw].u32Addr >= 0x100000) continue;
logT("idxdraw = %d, row = %d; col = %d\n",idxdraw,add_list[idxdraw].nRowBit,add_list[idxdraw].nColBit);
/* testing copy beyond tested bit is useless & can raise
false positive */
if(idxdraw > idx) break;
//if(idxdraw > idx) break;
clearScreen(sstregs,0x00000000,2,2);
/* set to mem addr */
ISET(sstregs->texBaseAddr, (add_list[idxdraw].u32Addr >> 3));
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, (add_list[idxdraw].u32Addr >> 3));
/* draw a 2x2 square */
drawSquare(sstregs, 0, 0, 2);
drawSquare(sstregs, ucNumTMU, 0, 0, 2);
sst1InitIdle(sst);
/* first line, to use bits 00..31 */
@@ -206,93 +241,33 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
const uint32_t ErrorMark_L1 = (idxdraw == idx) ? (L1 ^ TestVal1) : (L1 ^ TestValBlank1);
const uint32_t ErrorMark_L2 = (idxdraw == idx) ? (L2 ^ TestVal2) : (L2 ^ TestValBlank2);
const uint32_t ErrorMarkBlank_L1 = (idxdraw == idx) ? (L1 ^ TestValBlank1) : (L1 ^ TestVal1);
const uint32_t ErrorMarkBlank_L2 = (idxdraw == idx) ? (L2 ^ TestValBlank2) : (L2 ^ TestVal2) ;
const uint32_t ErrorMarkOther_L1 = (idxdraw == idx) ? (L1 ^ TestValBlank1) : (L1 ^ TestVal1);
const uint32_t ErrorMarkOther_L2 = (idxdraw == idx) ? (L2 ^ TestValBlank2) : (L2 ^ TestVal2);
if(ErrorMark_L1 || ErrorMark_L2)
{
const def_eFaultSource TMUTexADDR_0_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_0_0 : U8_TMU1_TEX_ADDR_0_0;
const def_eFaultSource TMUTexADDR_1_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_1_0 : U8_TMU1_TEX_ADDR_1_0;
const def_eFaultSource TMUTexADDR_2_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_2_0 : U8_TMU1_TEX_ADDR_2_0;
const def_eFaultSource TMUTexADDR_3_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_3_0 : U8_TMU1_TEX_ADDR_3_0;
const def_eFaultSource TMUTexWE = (ucNumTMU == 0) ? U9_TMU0_TEX_WE : U8_TMU1_TEX_WE;
const def_eFaultSource TMUTexCAS0 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS0 : U8_TMU1_TEX_CAS0;
const def_eFaultSource TMUTexCAS1 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS1 : U8_TMU1_TEX_CAS1;
const def_eFaultSource TMUTexCAS2 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS2 : U8_TMU1_TEX_CAS2;
const def_eFaultSource TMUTexCAS3 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS3 : U8_TMU1_TEX_CAS3;
const def_eFaultSource _TMUTexRAS0 = (ucNumTMU == 0) ? U9_TMU0_TEX_RAS0 : U8_TMU1_TEX_RAS0;
const def_eFaultSource _TMUTexRAS1 = (ucNumTMU == 0) ? U9_TMU0_TEX_RAS1 : U8_TMU1_TEX_RAS1;
const def_eFaultSource TMUTexRASCurrent = (add_list[idxdraw].nBank == 0) ? _TMUTexRAS0 : _TMUTexRAS1;
const def_eFaultSource _MEMChip_B0_0_A0 = (ucNumTMU == 0) ? U14_A0 : U13_A0;
const def_eFaultSource _MEMChip_B0_1_A0 = (ucNumTMU == 0) ? U12_A0 : U11_A0;
const def_eFaultSource _MEMChip_B0_2_A0 = (ucNumTMU == 0) ? U18_A0 : U16_A0;
const def_eFaultSource _MEMChip_B0_3_A0 = (ucNumTMU == 0) ? U17_A0 : U15_A0;
const def_eFaultSource _MEMChip_B1_0_A0 = (ucNumTMU == 0) ? U23_A0 : U27_A0;
const def_eFaultSource _MEMChip_B1_1_A0 = (ucNumTMU == 0) ? U24_A0 : U28_A0;
const def_eFaultSource _MEMChip_B1_2_A0 = (ucNumTMU == 0) ? U25_A0 : U29_A0;
const def_eFaultSource _MEMChip_B1_3_A0 = (ucNumTMU == 0) ? U26_A0 : U30_A0;
const def_eFaultSource TMUTexADDR_0_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_0_0 : U8_TMU1_TEX_ADDR_0_0;
const def_eFaultSource TMUTexADDR_1_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_1_0 : U8_TMU1_TEX_ADDR_1_0;
const def_eFaultSource TMUTexADDR_2_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_2_0 : U8_TMU1_TEX_ADDR_2_0;
const def_eFaultSource TMUTexADDR_3_0 = (ucNumTMU == 0) ? U9_TMU0_TEX_ADDR_3_0 : U8_TMU1_TEX_ADDR_3_0;
const def_eFaultSource _MEMChip_B0_0_A0 = (ucNumTMU == 0) ? U14_A0 : U13_A0;
const def_eFaultSource _MEMChip_B0_1_A0 = (ucNumTMU == 0) ? U12_A0 : U11_A0;
const def_eFaultSource _MEMChip_B0_2_A0 = (ucNumTMU == 0) ? U18_A0 : U16_A0;
const def_eFaultSource _MEMChip_B0_3_A0 = (ucNumTMU == 0) ? U17_A0 : U15_A0;
const def_eFaultSource _MEMChip_B1_0_A0 = (ucNumTMU == 0) ? U23_A0 : U27_A0;
const def_eFaultSource _MEMChip_B1_1_A0 = (ucNumTMU == 0) ? U24_A0 : U28_A0;
const def_eFaultSource _MEMChip_B1_2_A0 = (ucNumTMU == 0) ? U25_A0 : U29_A0;
const def_eFaultSource _MEMChip_B1_3_A0 = (ucNumTMU == 0) ? U26_A0 : U30_A0;
const def_eFaultSource MEMChip_0_A0 = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_0_A0 : _MEMChip_B1_0_A0;
const def_eFaultSource MEMChip_1_A0 = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_1_A0 : _MEMChip_B1_1_A0;
const def_eFaultSource MEMChip_2_A0 = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_2_A0 : _MEMChip_B1_2_A0;
const def_eFaultSource MEMChip_3_A0 = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_3_A0 : _MEMChip_B1_3_A0;
const def_eFaultSource MEMChip_1_A0 = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_1_A0 : _MEMChip_B1_1_A0;
const def_eFaultSource MEMChip_2_A0 = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_2_A0 : _MEMChip_B1_2_A0;
const def_eFaultSource MEMChip_3_A0 = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_3_A0 : _MEMChip_B1_3_A0;
const def_eFaultSource _MEMChip_B0_0_CASL = (ucNumTMU == 0) ? U14_CASL : U13_CASL;
const def_eFaultSource _MEMChip_B0_1_CASL = (ucNumTMU == 0) ? U12_CASL : U11_CASL;
const def_eFaultSource _MEMChip_B0_2_CASL = (ucNumTMU == 0) ? U18_CASL : U16_CASL;
const def_eFaultSource _MEMChip_B0_3_CASL = (ucNumTMU == 0) ? U17_CASL : U15_CASL;
const def_eFaultSource _MEMChip_B1_0_CASL = (ucNumTMU == 0) ? U23_CASL : U27_CASL;
const def_eFaultSource _MEMChip_B1_1_CASL = (ucNumTMU == 0) ? U24_CASL : U28_CASL;
const def_eFaultSource _MEMChip_B1_2_CASL = (ucNumTMU == 0) ? U25_CASL : U29_CASL;
const def_eFaultSource _MEMChip_B1_3_CASL = (ucNumTMU == 0) ? U26_CASL : U30_CASL;
const def_eFaultSource MEMChip_0_CASL = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_0_CASL : _MEMChip_B1_0_CASL;
const def_eFaultSource MEMChip_1_CASL = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_1_CASL : _MEMChip_B1_1_CASL;
const def_eFaultSource MEMChip_2_CASL = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_2_CASL : _MEMChip_B1_2_CASL;
const def_eFaultSource MEMChip_3_CASL = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_3_CASL : _MEMChip_B1_3_CASL;
const def_eFaultSource _MEMChip_B0_0_CASH = (ucNumTMU == 0) ? U14_CASH : U13_CASH;
const def_eFaultSource _MEMChip_B0_1_CASH = (ucNumTMU == 0) ? U12_CASH : U11_CASH;
const def_eFaultSource _MEMChip_B0_2_CASH = (ucNumTMU == 0) ? U18_CASH : U16_CASH;
const def_eFaultSource _MEMChip_B0_3_CASH = (ucNumTMU == 0) ? U17_CASH : U15_CASH;
const def_eFaultSource _MEMChip_B1_0_CASH = (ucNumTMU == 0) ? U23_CASH : U27_CASH;
const def_eFaultSource _MEMChip_B1_1_CASH = (ucNumTMU == 0) ? U24_CASH : U28_CASH;
const def_eFaultSource _MEMChip_B1_2_CASH = (ucNumTMU == 0) ? U25_CASH : U29_CASH;
const def_eFaultSource _MEMChip_B1_3_CASH = (ucNumTMU == 0) ? U26_CASH : U30_CASH;
const def_eFaultSource MEMChip_0_CASH = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_0_CASH : _MEMChip_B1_0_CASH;
const def_eFaultSource MEMChip_1_CASH = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_1_CASH : _MEMChip_B1_1_CASH;
const def_eFaultSource MEMChip_2_CASH = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_2_CASH : _MEMChip_B1_2_CASH;
const def_eFaultSource MEMChip_3_CASH = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_3_CASH : _MEMChip_B1_3_CASH;
const def_eFaultSource _MEMChip_B0_0_RAS = (ucNumTMU == 0) ? U14_RAS : U13_RAS;
const def_eFaultSource _MEMChip_B0_1_RAS = (ucNumTMU == 0) ? U12_RAS : U11_RAS;
const def_eFaultSource _MEMChip_B0_2_RAS = (ucNumTMU == 0) ? U18_RAS : U16_RAS;
const def_eFaultSource _MEMChip_B0_3_RAS = (ucNumTMU == 0) ? U17_RAS : U15_RAS;
const def_eFaultSource _MEMChip_B1_0_RAS = (ucNumTMU == 0) ? U23_RAS : U27_RAS;
const def_eFaultSource _MEMChip_B1_1_RAS = (ucNumTMU == 0) ? U24_RAS : U28_RAS;
const def_eFaultSource _MEMChip_B1_2_RAS = (ucNumTMU == 0) ? U25_RAS : U29_RAS;
const def_eFaultSource _MEMChip_B1_3_RAS = (ucNumTMU == 0) ? U26_RAS : U30_RAS;
const def_eFaultSource MEMChip_0_RAS = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_0_RAS : _MEMChip_B1_0_RAS;
const def_eFaultSource MEMChip_1_RAS = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_1_RAS : _MEMChip_B1_1_RAS;
const def_eFaultSource MEMChip_2_RAS = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_2_RAS : _MEMChip_B1_2_RAS;
const def_eFaultSource MEMChip_3_RAS = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_3_RAS : _MEMChip_B1_3_RAS;
const def_eFaultSource _MEMChip_B0_0_WE = (ucNumTMU == 0) ? U14_WE : U13_WE;
const def_eFaultSource _MEMChip_B0_1_WE = (ucNumTMU == 0) ? U12_WE : U11_WE;
const def_eFaultSource _MEMChip_B0_2_WE = (ucNumTMU == 0) ? U18_WE : U16_WE;
const def_eFaultSource _MEMChip_B0_3_WE = (ucNumTMU == 0) ? U17_WE : U15_WE;
const def_eFaultSource _MEMChip_B1_0_WE = (ucNumTMU == 0) ? U23_WE : U27_WE;
const def_eFaultSource _MEMChip_B1_1_WE = (ucNumTMU == 0) ? U24_WE : U28_WE;
const def_eFaultSource _MEMChip_B1_2_WE = (ucNumTMU == 0) ? U25_WE : U29_WE;
const def_eFaultSource _MEMChip_B1_3_WE = (ucNumTMU == 0) ? U26_WE : U30_WE;
const def_eFaultSource MEMChip_0_WE = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_0_WE : _MEMChip_B1_0_WE;
const def_eFaultSource MEMChip_1_WE = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_1_WE : _MEMChip_B1_1_WE;
const def_eFaultSource MEMChip_2_WE = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_2_WE : _MEMChip_B1_2_WE;
const def_eFaultSource MEMChip_3_WE = (add_list[idxdraw].nBank == 0) ? _MEMChip_B0_3_WE : _MEMChip_B1_3_WE;
const def_eFaultSource _RES_RAS0 = (ucNumTMU == 0) ? R118 : R115;
const def_eFaultSource _RES_RAS1 = (ucNumTMU == 0) ? R149 : R150;
const def_eFaultSource RES_RAS = (add_list[idxdraw].nBank == 0) ? _RES_RAS0 : _RES_RAS1;
const def_eFaultSource RES_CAS = (ucNumTMU == 0) ? RA36 : RA32;
const def_eFaultSource RES_WE = (ucNumTMU == 0) ? R117 : R114;
const def_eFaultSource MEMChip_0_A0_Other = (add_list[idxdraw].nBank == 1) ? _MEMChip_B0_0_A0 : _MEMChip_B1_0_A0;
const def_eFaultSource MEMChip_1_A0_Other = (add_list[idxdraw].nBank == 1) ? _MEMChip_B0_1_A0 : _MEMChip_B1_1_A0;
const def_eFaultSource MEMChip_2_A0_Other = (add_list[idxdraw].nBank == 1) ? _MEMChip_B0_2_A0 : _MEMChip_B1_2_A0;
const def_eFaultSource MEMChip_3_A0_Other = (add_list[idxdraw].nBank == 1) ? _MEMChip_B0_3_A0 : _MEMChip_B1_3_A0;
const def_eFaultSource RES_TEXADDR_0_L = (ucNumTMU == 0) ? RA35 : RA31;
const def_eFaultSource RES_TEXADDR_0_H = (ucNumTMU == 0) ? RA34 : RA30;
@@ -306,240 +281,166 @@ RenderTestAddress( sst1DeviceInfoStruct* devInfo,
const def_eFaultSource RES_TEXADDR_3_L = (ucNumTMU == 0) ? RA22 : RA20;
const def_eFaultSource RES_TEXADDR_3_H = (ucNumTMU == 0) ? RA21 : RA19;
const def_eFaultSource RES_TEXADDR_3_8 = (ucNumTMU == 0) ? R98 : R97;
if(count_bit32(ErrorMark_L1 & 0x0000FFFF) > 2)
{
NbErr++;
if((idxdraw == idx) && count_bit32(ErrorMark_L1 & 0x0000FFFF) > 6)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_WE, 1.0/1);
}
if(count_bit32(ErrorMarkBlank_L1 & 0x0000FFFF) < 3)
{
if(add_list[idx].nColBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_A0 + add_list[idx].nColBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_0_0 + add_list[idx].nColBit, 1.0/1);
if(add_list[idx].nColBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_L + add_list[idx].nColBit + 1, 1.0/2);
else if(add_list[idx].nColBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_H + add_list[idx].nColBit + 1, 1.0/2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_8 + 1, 1.0/2);
}
if(add_list[idx].nRowBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_A0 + add_list[idx].nRowBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_0_0 + add_list[idx].nRowBit, 1.0/1);
if(add_list[idx].nRowBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_L + add_list[idx].nRowBit + 1, 1.0/2);
else if(add_list[idx].nRowBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_H + add_list[idx].nRowBit + 1, 1.0/2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_8 + 1, 1.0/2);
}
}
else
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_RAS, 1.0/4);
if(ErrorMark_L1 & 0x000000FF)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS0, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+1, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_CASL, 1.0/8);
}
if(ErrorMark_L1 & 0x0000FF00)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS1, 1.0/16);;
FaultSource_addScore(pFaultSrcCtx, RES_CAS+2, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_CASH, 1.0/8);
}
}
}
/* considering error only if more than 6 over 16 bits
/* This test is simpler than I wanteed it to be. It focuses
* only on address lines. I thought that reading a totally
* unknown value can mean we have a control line issue but it
* is more complex. In case of 2 addresses lines shorted,
* the value we will get wont necessary be the one we wrote,
* at any place. I am not 100% sure why, but it might be
* because of EDO Ram Page mode... Or maybe lines are also used
* internally by the TMU.. or maybe I just missed something !
*
* Anyway, this test should do the job for @ lines (including
* shorted). And the Control lines will be tested in a different
* Module where @ lines wont change.
*/
/* Considering error only if more than 3 over 16 bits
* are wrong, because we are only testing addresses
* lines here */
if(count_bit32(ErrorMark_L1 & 0xFFFF0000) > 2)
if(count_bit32(ErrorMark_L1 & 0x0000FFFF) > 3)
{
NbErr++;
if((idxdraw == idx) && count_bit32(ErrorMark_L1 & 0xFFFF0000) > 6)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_WE, 1.0/1);
}
if(count_bit32(ErrorMarkBlank_L1 & 0xFFFF0000) < 3)
/* If it matches the Other value with less than
* 3 error bits */
if(count_bit32(ErrorMarkOther_L1 & 0x0000FFFF) < 3)
{
if(add_list[idx].nColBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_A0 + add_list[idx].nColBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_1_0 + add_list[idx].nColBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_A0 + add_list[idx].nColBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_A0_Other + add_list[idx].nColBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_0_0 + add_list[idx].nColBit - 1, 1.0 / 2);
if(add_list[idx].nColBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_L + add_list[idx].nColBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_L + add_list[idx].nColBit - 2, 1.0 / 2);
else if(add_list[idx].nColBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_H + add_list[idx].nColBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_H + add_list[idx].nColBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_8 + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_8, 1.0 / 2);
}
if(add_list[idx].nRowBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_A0 + add_list[idx].nRowBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_1_0 + add_list[idx].nRowBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_A0 + add_list[idx].nRowBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_A0_Other + add_list[idx].nRowBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_0_0 + add_list[idx].nRowBit - 1, 1.0 / 2);
if(add_list[idx].nRowBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_L + add_list[idx].nRowBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_L + add_list[idx].nRowBit - 2, 1.0 / 2);
else if(add_list[idx].nRowBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_H + add_list[idx].nRowBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_H + add_list[idx].nRowBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_8 + 1, 1.0/2);
}
}
else
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_RAS, 1.0/4);
if(ErrorMark_L1 & 0x00FF0000)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS0, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+1, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_CASL, 1.0/8);
}
if(ErrorMark_L1 & 0xFF000000)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS1, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+2, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_CASH, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_0_8, 1.0 / 2);
}
}
}
if(count_bit32(ErrorMark_L2 & 0x0000FFFF) > 2)
if(count_bit32(ErrorMark_L1 & 0xFFFF0000) > 3)
{
NbErr++;
if((idxdraw == idx) && count_bit32(ErrorMark_L2 & 0x0000FFFF) > 6)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_WE, 1.0);
}
if(count_bit32(ErrorMarkBlank_L2 & 0x0000FFFF) < 3)
if(count_bit32(ErrorMarkOther_L1 & 0xFFFF0000) < 3)
{
if(add_list[idx].nColBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_A0 + add_list[idx].nColBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_2_0 + add_list[idx].nColBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_A0 + add_list[idx].nColBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_A0_Other + add_list[idx].nColBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_1_0 + add_list[idx].nColBit - 1, 1.0 / 2);
if(add_list[idx].nColBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_L + add_list[idx].nColBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_L + add_list[idx].nColBit - 2, 1.0 / 2);
else if(add_list[idx].nColBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_H + add_list[idx].nColBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_H + add_list[idx].nColBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_8 + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_8, 1.0 / 2);
}
if(add_list[idx].nRowBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_A0 + add_list[idx].nRowBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_2_0 + add_list[idx].nRowBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_A0 + add_list[idx].nRowBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_A0_Other + add_list[idx].nRowBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_1_0 + add_list[idx].nRowBit - 1, 1.0 / 2);
if(add_list[idx].nRowBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_L + add_list[idx].nRowBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_L + add_list[idx].nRowBit - 2, 1.0 / 2);
else if(add_list[idx].nRowBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_H + add_list[idx].nRowBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_H + add_list[idx].nRowBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_8 + 1, 1.0/2);
}
}
else
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_RAS, 1.0/4);
if(ErrorMark_L2 & 0x000000FF)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS2, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+3, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_CASL, 1.0/8);
}
if(ErrorMark_L2 & 0x0000FF00)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS3, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+4, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_CASH, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_1_8, 1.0 / 2);
}
}
}
if(count_bit32(ErrorMark_L2 & 0xFFFF0000) > 2)
if(count_bit32(ErrorMark_L2 & 0x0000FFFF) > 3)
{
NbErr++;
if((idxdraw == idx) && count_bit32(ErrorMark_L2 & 0xFFFF0000) > 6)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_WE, 1.0);
}
if(count_bit32(ErrorMarkBlank_L2 & 0xFFFF0000) < 3)
if(count_bit32(ErrorMarkOther_L2 & 0x0000FFFF) < 3)
{
if(add_list[idx].nColBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_A0 + add_list[idx].nColBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_3_0 + add_list[idx].nColBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_A0 + add_list[idx].nColBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_A0_Other + add_list[idx].nColBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_2_0 + add_list[idx].nColBit - 1, 1.0 / 2);
if(add_list[idx].nColBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_L + add_list[idx].nColBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_L + add_list[idx].nColBit - 2, 1.0 / 2);
else if(add_list[idx].nColBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_H + add_list[idx].nColBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_H + add_list[idx].nColBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_8 + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_8, 1.0 / 2);
}
if(add_list[idx].nRowBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_A0 + add_list[idx].nRowBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_3_0 + add_list[idx].nRowBit, 1.0/1);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_A0 + add_list[idx].nRowBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_A0_Other + add_list[idx].nRowBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_2_0 + add_list[idx].nRowBit - 1, 1.0 / 2);
if(add_list[idx].nRowBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_L + add_list[idx].nRowBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_L + add_list[idx].nRowBit - 2, 1.0 / 2);
else if(add_list[idx].nRowBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_H + add_list[idx].nRowBit + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_H + add_list[idx].nRowBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_8 + 1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_2_8, 1.0 / 2);
}
}
else
}
if(count_bit32(ErrorMark_L2 & 0xFFFF0000) > 3)
{
NbErr++;
if(count_bit32(ErrorMarkOther_L2 & 0xFFFF0000) < 3)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_RAS, 1.0/4);
if(ErrorMark_L2 & 0x00FF0000)
if(add_list[idx].nColBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS2, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+3, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_CASL, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_A0 + add_list[idx].nColBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_A0_Other + add_list[idx].nColBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_3_0 + add_list[idx].nColBit - 1, 1.0 / 2);
if(add_list[idx].nColBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_L + add_list[idx].nColBit - 2, 1.0 / 2);
else if(add_list[idx].nColBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_H + add_list[idx].nColBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_8, 1.0 / 2);
}
if(ErrorMark_L2 & 0xFF000000)
if(add_list[idx].nRowBit!=0)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS3, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+4, 1.0/16);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_CASH, 1.0/8);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_A0 + add_list[idx].nRowBit - 1, 1.0 / 1);
if(RamSizeMB>=2)
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_A0_Other + add_list[idx].nRowBit - 1, 1.0 / 2);
FaultSource_addScore(pFaultSrcCtx, TMUTexADDR_3_0 + add_list[idx].nRowBit - 1, 1.0 / 2);
if(add_list[idx].nRowBit < 4)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_L + add_list[idx].nRowBit - 2, 1.0 / 2);
else if(add_list[idx].nRowBit < 8)
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_H + add_list[idx].nRowBit - 6, 1.0 / 2);
else
FaultSource_addScore(pFaultSrcCtx, RES_TEXADDR_3_8, 1.0 / 2);
}
}
}

6
Test_Address.h
View File

@@ -19,9 +19,9 @@
#define _DEF_TEST_ADDRESS_H_
unsigned long
RenderTestAddress( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
RenderTestAddress( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec* const pFaultSrcCtx);

8
Test_Common.c
View File

@@ -35,9 +35,9 @@
#define _DEF_PREHEAT_NB_PIXEL_COL 256
void
HeatMemAndTMU( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
HeatMemAndTMU( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const FxU32 mem)
{
@@ -75,7 +75,7 @@ HeatMemAndTMU( sst1DeviceInfoStruct* devInfo,
if(((sst1InitReturnStatus(sst) & SST_FIFOLEVEL)) >= 0x20)
{
/* draw a 256x256 square */
drawSquare(sstregs, 0, 0, 256);
drawSquare(sstregs, ucNumTMU, 0, 0, 256);
}
}
while(((double)(clock() - begin)/CLOCKS_PER_SEC) < _DEF_PREHEAT_TIME_S );

6
Test_Common.h
View File

@@ -19,9 +19,9 @@
#define _DEF_TEST_COMMON_H_
void
HeatMemAndTMU( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
HeatMemAndTMU( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const FxU32 mem);

457
Test_Control.c Normal file
View File

@@ -0,0 +1,457 @@
/* V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
* Copyright (C) 2026 ChaCha
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdio.h>
#include "cvg.h"
#include <glide.h>
#include "sst1init.h"
#include "fxpci.h"
#include "Utils.h"
#include "V2MemTest.h"
#include "FaultSources.h"
#include "Utils.h"
#include "Draw.h"
#include "Test_Control.h"
static void
WriteTex( FxU32 * const sst,
SstRegs * const sstregs,
const uint32_t baseAddr,
const char ucNumTMU,
const uint32_t Val1,
const uint32_t Val2)
{
/* set base mem @ */
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, (baseAddr>>3));
/* set @ to first line, using bits 00..31*/
volatile const FxU32 *texAddrBlank
= (ucNumTMU<<(21-2))
+ (((FxU32)0)<<(17-2)) /*LOD0*/
+ (FxU32 *)SST_TEX_ADDRESS(sst);
/* write the value */
ISET(texAddrBlank[0], Val1);
/* set @ to second line, to use bits 32..63*/
volatile const FxU32 *texAddrBlank2
= (ucNumTMU<<(21-2))
+ (((FxU32)0)<<(17-2)) /*LOD0*/
+ (1<<(9-2))
+ (FxU32 *)SST_TEX_ADDRESS(sst);
/* write the value */
ISET(texAddrBlank2[0], Val2);
}
unsigned long
CheckRead( FxU32 * const sst,
SstRegs * const sstregs,
const uint32_t baseAddr,
const char ucNumTMU,
const unsigned char bNominal,
const uint32_t Val1,
const uint32_t Val2,
const uint32_t ValOther1,
const uint32_t ValOther2,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
{
unsigned long NbErr=0;
const unsigned char nBank = (baseAddr<0x200000) ? 0 : 1;
const def_eFaultSource TMUTexWE = (ucNumTMU == 0) ? U9_TMU0_TEX_WE : U8_TMU1_TEX_WE;
const def_eFaultSource TMUTexCAS0 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS0 : U8_TMU1_TEX_CAS0;
const def_eFaultSource TMUTexCAS1 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS1 : U8_TMU1_TEX_CAS1;
const def_eFaultSource TMUTexCAS2 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS2 : U8_TMU1_TEX_CAS2;
const def_eFaultSource TMUTexCAS3 = (ucNumTMU == 0) ? U9_TMU0_TEX_CAS3 : U8_TMU1_TEX_CAS3;
const def_eFaultSource _TMUTexRAS0 = (ucNumTMU == 0) ? U9_TMU0_TEX_RAS0 : U8_TMU1_TEX_RAS0;
const def_eFaultSource _TMUTexRAS1 = (ucNumTMU == 0) ? U9_TMU0_TEX_RAS1 : U8_TMU1_TEX_RAS1;
const def_eFaultSource TMUTexRASCurrent = (nBank == 0) ? _TMUTexRAS0 : _TMUTexRAS1;
const def_eFaultSource _MEMChip_B0_0_CASL = (ucNumTMU == 0) ? U14_CASL : U13_CASL;
const def_eFaultSource _MEMChip_B0_1_CASL = (ucNumTMU == 0) ? U12_CASL : U11_CASL;
const def_eFaultSource _MEMChip_B0_2_CASL = (ucNumTMU == 0) ? U18_CASL : U16_CASL;
const def_eFaultSource _MEMChip_B0_3_CASL = (ucNumTMU == 0) ? U17_CASL : U15_CASL;
const def_eFaultSource _MEMChip_B1_0_CASL = (ucNumTMU == 0) ? U23_CASL : U27_CASL;
const def_eFaultSource _MEMChip_B1_1_CASL = (ucNumTMU == 0) ? U24_CASL : U28_CASL;
const def_eFaultSource _MEMChip_B1_2_CASL = (ucNumTMU == 0) ? U25_CASL : U29_CASL;
const def_eFaultSource _MEMChip_B1_3_CASL = (ucNumTMU == 0) ? U26_CASL : U30_CASL;
const def_eFaultSource MEMChip_0_CASL = (nBank == 0) ? _MEMChip_B0_0_CASL : _MEMChip_B1_0_CASL;
const def_eFaultSource MEMChip_1_CASL = (nBank == 0) ? _MEMChip_B0_1_CASL : _MEMChip_B1_1_CASL;
const def_eFaultSource MEMChip_2_CASL = (nBank == 0) ? _MEMChip_B0_2_CASL : _MEMChip_B1_2_CASL;
const def_eFaultSource MEMChip_3_CASL = (nBank == 0) ? _MEMChip_B0_3_CASL : _MEMChip_B1_3_CASL;
const def_eFaultSource _MEMChip_B0_0_CASH = (ucNumTMU == 0) ? U14_CASH : U13_CASH;
const def_eFaultSource _MEMChip_B0_1_CASH = (ucNumTMU == 0) ? U12_CASH : U11_CASH;
const def_eFaultSource _MEMChip_B0_2_CASH = (ucNumTMU == 0) ? U18_CASH : U16_CASH;
const def_eFaultSource _MEMChip_B0_3_CASH = (ucNumTMU == 0) ? U17_CASH : U15_CASH;
const def_eFaultSource _MEMChip_B1_0_CASH = (ucNumTMU == 0) ? U23_CASH : U27_CASH;
const def_eFaultSource _MEMChip_B1_1_CASH = (ucNumTMU == 0) ? U24_CASH : U28_CASH;
const def_eFaultSource _MEMChip_B1_2_CASH = (ucNumTMU == 0) ? U25_CASH : U29_CASH;
const def_eFaultSource _MEMChip_B1_3_CASH = (ucNumTMU == 0) ? U26_CASH : U30_CASH;
const def_eFaultSource MEMChip_0_CASH = (nBank == 0) ? _MEMChip_B0_0_CASH : _MEMChip_B1_0_CASH;
const def_eFaultSource MEMChip_1_CASH = (nBank == 0) ? _MEMChip_B0_1_CASH : _MEMChip_B1_1_CASH;
const def_eFaultSource MEMChip_2_CASH = (nBank == 0) ? _MEMChip_B0_2_CASH : _MEMChip_B1_2_CASH;
const def_eFaultSource MEMChip_3_CASH = (nBank == 0) ? _MEMChip_B0_3_CASH : _MEMChip_B1_3_CASH;
const def_eFaultSource _MEMChip_B0_0_RAS = (ucNumTMU == 0) ? U14_RAS : U13_RAS;
const def_eFaultSource _MEMChip_B0_1_RAS = (ucNumTMU == 0) ? U12_RAS : U11_RAS;
const def_eFaultSource _MEMChip_B0_2_RAS = (ucNumTMU == 0) ? U18_RAS : U16_RAS;
const def_eFaultSource _MEMChip_B0_3_RAS = (ucNumTMU == 0) ? U17_RAS : U15_RAS;
const def_eFaultSource _MEMChip_B1_0_RAS = (ucNumTMU == 0) ? U23_RAS : U27_RAS;
const def_eFaultSource _MEMChip_B1_1_RAS = (ucNumTMU == 0) ? U24_RAS : U28_RAS;
const def_eFaultSource _MEMChip_B1_2_RAS = (ucNumTMU == 0) ? U25_RAS : U29_RAS;
const def_eFaultSource _MEMChip_B1_3_RAS = (ucNumTMU == 0) ? U26_RAS : U30_RAS;
const def_eFaultSource MEMChip_0_RAS = (nBank == 0) ? _MEMChip_B0_0_RAS : _MEMChip_B1_0_RAS;
const def_eFaultSource MEMChip_1_RAS = (nBank == 0) ? _MEMChip_B0_1_RAS : _MEMChip_B1_1_RAS;
const def_eFaultSource MEMChip_2_RAS = (nBank == 0) ? _MEMChip_B0_2_RAS : _MEMChip_B1_2_RAS;
const def_eFaultSource MEMChip_3_RAS = (nBank == 0) ? _MEMChip_B0_3_RAS : _MEMChip_B1_3_RAS;
const def_eFaultSource _MEMChip_B0_0_WE = (ucNumTMU == 0) ? U14_WE : U13_WE;
const def_eFaultSource _MEMChip_B0_1_WE = (ucNumTMU == 0) ? U12_WE : U11_WE;
const def_eFaultSource _MEMChip_B0_2_WE = (ucNumTMU == 0) ? U18_WE : U16_WE;
const def_eFaultSource _MEMChip_B0_3_WE = (ucNumTMU == 0) ? U17_WE : U15_WE;
const def_eFaultSource _MEMChip_B1_0_WE = (ucNumTMU == 0) ? U23_WE : U27_WE;
const def_eFaultSource _MEMChip_B1_1_WE = (ucNumTMU == 0) ? U24_WE : U28_WE;
const def_eFaultSource _MEMChip_B1_2_WE = (ucNumTMU == 0) ? U25_WE : U29_WE;
const def_eFaultSource _MEMChip_B1_3_WE = (ucNumTMU == 0) ? U26_WE : U30_WE;
const def_eFaultSource MEMChip_0_WE = (nBank == 0) ? _MEMChip_B0_0_WE : _MEMChip_B1_0_WE;
const def_eFaultSource MEMChip_1_WE = (nBank == 0) ? _MEMChip_B0_1_WE : _MEMChip_B1_1_WE;
const def_eFaultSource MEMChip_2_WE = (nBank == 0) ? _MEMChip_B0_2_WE : _MEMChip_B1_2_WE;
const def_eFaultSource MEMChip_3_WE = (nBank == 0) ? _MEMChip_B0_3_WE : _MEMChip_B1_3_WE;
const def_eFaultSource _RES_RAS0 = (ucNumTMU == 0) ? R118 : R115;
const def_eFaultSource _RES_RAS1 = (ucNumTMU == 0) ? R149 : R150;
const def_eFaultSource RES_RAS = (nBank == 0) ? _RES_RAS0 : _RES_RAS1;
const def_eFaultSource RES_CAS = (ucNumTMU == 0) ? RA36 : RA32;
const def_eFaultSource RES_WE = (ucNumTMU == 0) ? R117 : R114;
clearScreen(sstregs,0x00000000,2,2);
/* set to mem addr */
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, (baseAddr >> 3));
/* draw a 2x2 square */
drawSquare(sstregs, ucNumTMU, 0, 0, 2);
sst1InitIdle(sst);
/* first line, to use bits 00..31 */
const uint32_t L1 = IGET(sst[(SST_LFB_ADDR>>2) + 0]);
/* second line, to use bits 32..63 */
const uint32_t L2 = IGET(sst[(SST_LFB_ADDR>>2) + (2048>>2) + 0]);
const uint32_t ErrorMark_L1 = (L1 ^ Val1);
const uint32_t ErrorMark_L2 = (L2 ^ Val2);
const uint32_t ErrorMark_L1_Other = (L1 ^ ValOther1);
const uint32_t ErrorMark_L2_Other = (L2 ^ ValOther2);
if(count_bit32(ErrorMark_L1 & 0x0000FFFF) > 4)
{
NbErr++;
/* If we are reading the value of the other Bank
* then it has to be a bank select problem*/
if(!bNominal && count_bit32(ErrorMark_L1_Other & 0x0000FFFF) < 4)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_RAS, 2.0);
}
else
{
/* WE can fail only in case of plain failure */
if(count_bit32(ErrorMark_L1 & 0x0000FFFF) > 8)
{
/*WE are shared accross all memory chips so
* we divide the weight by 4.*/
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_WE, 1.0);
}
unsigned char bLSBFailed = false;
unsigned char bMSBFailed = false;
if(count_bit32(ErrorMark_L1 & 0x000000FF) > 2)
{
/*CAS are shared accross multiple memory chips so
* we divide the weight by 2.*/
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS0, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_CASL, 1.0);
bLSBFailed = true;
}
if(count_bit32(ErrorMark_L1 & 0x0000FF00) > 2)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS1, 1.0/2);;
FaultSource_addScore(pFaultSrcCtx, RES_CAS+2, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_CASH, 1.0);
bMSBFailed = true;
}
/* RAS is declared failed only if both CAS failed */
if(bLSBFailed && bMSBFailed)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0);
FaultSource_addScore(pFaultSrcCtx, MEMChip_0_RAS, 4.0);
}
}
}
if(count_bit32(ErrorMark_L1 & 0xFFFF0000) > 4)
{
NbErr++;
if(!bNominal && count_bit32(ErrorMark_L1_Other & 0xFFFF0000) < 4)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_RAS, 2.0);
}
else
{
if(count_bit32(ErrorMark_L1 & 0xFFFF0000) > 8)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_WE, 1.0);
}
unsigned char bLSBFailed = false;
unsigned char bMSBFailed = false;
if(count_bit32(ErrorMark_L1 & 0x00FF0000) > 2)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS0, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+1, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_CASL, 1.0);
bLSBFailed = true;
}
if(count_bit32(ErrorMark_L1 & 0xFF000000) > 2)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS1, 1.0/2);;
FaultSource_addScore(pFaultSrcCtx, RES_CAS+2, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_CASH, 1.0);
bMSBFailed = true;
}
if(bLSBFailed && bMSBFailed)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0);
FaultSource_addScore(pFaultSrcCtx, MEMChip_1_RAS, 4.0);
}
}
}
if(count_bit32(ErrorMark_L2 & 0x0000FFFF) > 4)
{
NbErr++;
if(!bNominal && count_bit32(ErrorMark_L2_Other & 0x0000FFFF) < 4)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_RAS, 2.0);
}
else
{
if(count_bit32(ErrorMark_L2 & 0x0000FFFF) > 8)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_WE, 1.0);
}
unsigned char bLSBFailed = false;
unsigned char bMSBFailed = false;
if(count_bit32(ErrorMark_L2 & 0x000000FF) > 2)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS2, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+3, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_CASL, 1.0);
bLSBFailed = true;
}
if(count_bit32(ErrorMark_L2 & 0x0000FF00) > 2)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS3, 1.0/2);;
FaultSource_addScore(pFaultSrcCtx, RES_CAS+4, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_CASH, 1.0);
bMSBFailed = true;
}
if(bLSBFailed && bMSBFailed)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0);
FaultSource_addScore(pFaultSrcCtx, MEMChip_2_RAS, 4.0);
}
}
}
if(count_bit32(ErrorMark_L2 & 0xFFFF0000) > 4)
{
NbErr++;
if(!bNominal && count_bit32(ErrorMark_L2_Other & 0xFFFF0000) < 4)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_RAS, 2.0);
}
else
{
if(count_bit32(ErrorMark_L2 & 0xFFFF0000) > 8)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexWE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, RES_WE, 1.0/4);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_WE, 1.0);
}
unsigned char bLSBFailed = false;
unsigned char bMSBFailed = false;
if(count_bit32(ErrorMark_L2 & 0x00FF0000) > 2)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS2, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, RES_CAS+3, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_CASL, 1.0);
bLSBFailed = true;
}
if(count_bit32(ErrorMark_L2 & 0xFF000000) > 2)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexCAS3, 1.0/2);;
FaultSource_addScore(pFaultSrcCtx, RES_CAS+4, 1.0/2);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_CASH, 1.0);
bMSBFailed = true;
}
if(bLSBFailed && bMSBFailed)
{
FaultSource_addScore(pFaultSrcCtx, TMUTexRASCurrent, 1.0);
FaultSource_addScore(pFaultSrcCtx, RES_RAS, 1.0);
FaultSource_addScore(pFaultSrcCtx, MEMChip_3_RAS, 4.0);
}
}
}
return NbErr;
}
unsigned long
TestControl( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec * const pFaultSrcCtx)
{
unsigned long NbErr=0;
sst1InitIdle(sst);
unsigned long _trexInit0 = IGET(SST_TREX(sstregs,ucNumTMU)->trexInit0);
devInfo->tmuInit0[(int)ucNumTMU] = SST_TREXINIT0_DEFAULT ;
ISET(SST_TREX(sstregs,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
sst1InitIdle(sst);
/* set downstream TMUs to passthrough */
for (int i=0; i<ucNumTMU; i++)
ISET(SST_TREX(sstregs,i)->textureMode, SST_TC_PASS | SST_TCA_PASS);
const uint32_t TestVal1 = get_notnull_random_balanced_mByte();
logT("TestVal1 = %08X\n",TestVal1);
uint32_t TestVal2 = 0;
do
{
TestVal2 = get_notnull_random_balanced_mByte();
}
while((count_bit32((TestVal2 ^ TestVal1)) < 12));
logT("TestVal2 = %08X\n",TestVal2);
uint32_t TestValBlank1 = 0;
do
{
TestValBlank1 = get_notnull_random_balanced_mByte();
}
while( (count_bit32((TestValBlank1 ^ TestVal1) & 0x0000FFFF) < 6)
|| (count_bit32((TestValBlank1 ^ TestVal1) & 0xFFFF0000) < 6)
|| (count_bit32((TestValBlank1 ^ TestVal2)) < 12));
logT("TestValBlank1 = %08X\n", TestValBlank1);
uint32_t TestValBlank2 = 0;
do
{
TestValBlank2 = get_notnull_random_balanced_mByte();
}
while( (count_bit32((TestValBlank2 ^ TestVal2) & 0x0000FFFF) < 6)
|| (count_bit32((TestValBlank2 ^ TestVal2) & 0xFFFF0000) < 6)
|| (count_bit32((TestValBlank2 ^ TestValBlank1)) < 12)
|| (count_bit32((TestValBlank2 ^ TestVal1)) < 12));
logT("TestValBlank2 = %08X\n", TestValBlank2);
/* write initial Values */
/* Bank 0*/
WriteTex(sst, sstregs, 0x000000, ucNumTMU, TestValBlank1, TestValBlank2);
/* Bank 1*/
if(RamSizeMB>2)
{
WriteTex(sst, sstregs, 0x200000, ucNumTMU, TestValBlank1, TestValBlank2);
}
/* write to Bank 0 */
WriteTex(sst, sstregs, 0x000000, ucNumTMU, TestVal1, TestVal2);
/* read and check Bank 0 (nominal check)*/
NbErr += CheckRead(sst, sstregs, 0x000000, ucNumTMU,
true, TestVal1, TestVal2, TestValBlank1, TestValBlank2, pFaultSrcCtx);
/* if Bank 1 available*/
if(RamSizeMB>2)
{
/* read and check Bank 1(no modification check)*/
NbErr += CheckRead(sst, sstregs, 0x200000, ucNumTMU,
false, TestValBlank1, TestValBlank2, TestVal1, TestVal2, pFaultSrcCtx);
/* write initial Values */
/* Bank 0*/
WriteTex(sst, sstregs, 0x000000, ucNumTMU, TestValBlank1, TestValBlank2);
/* Bank 1*/
if(RamSizeMB>2)
{
WriteTex(sst, sstregs, 0x200000, ucNumTMU, TestValBlank1, TestValBlank2);
}
/* write to Bank 1 */
WriteTex(sst, sstregs, 0x200000, ucNumTMU, TestVal1, TestVal2);
/* read and check Bank 1 (nominal check)*/
NbErr += CheckRead(sst, sstregs, 0x200000, ucNumTMU,
true, TestVal1, TestVal2, TestValBlank1, TestValBlank2, pFaultSrcCtx);
/* read and check Bank 0 (no modification check)*/
NbErr += CheckRead(sst, sstregs, 0x000000, ucNumTMU,
false, TestValBlank1, TestValBlank2, TestVal1, TestVal2, pFaultSrcCtx);
}
clearScreen(sstregs,0x00000000,2,2);
sst1InitIdle(sst);
devInfo->tmuInit0[(int)ucNumTMU] = _trexInit0;
ISET(SST_TREX(sst,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
sst1InitIdle(sst);
return NbErr;
}

29
Test_Control.h Normal file
View File

@@ -0,0 +1,29 @@
/* V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
* Copyright (C) 2026 ChaCha
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef _DEF_TEST_CONTROL_H_
#define _DEF_TEST_CONTROL_H_
unsigned long
TestControl(sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec * const pFaultSrcCtx);
#endif //_DEF_TEST_CONTROL_H_

116
Test_Data.c
View File

@@ -14,6 +14,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#define _BSD_SOURCE 1
#include <stdint.h>
#include <stdio.h>
@@ -33,13 +34,14 @@
#include "Test_Data.h"
static unsigned long long
RenderTest( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
RenderTest( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const FxU32 mem,
const FxU32 value1,
const FxU32 value2,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
{
unsigned long long NbErr = 0;
@@ -51,7 +53,7 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
ISET(SST_TREX(sstregs,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
sst1InitIdle(sst);
ISET(sstregs->texBaseAddr, mem>>3);
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, mem>>3);
/* Writing to first texture line, to use RAM bits 0..31 */
volatile FxU32 *texAddr
@@ -68,7 +70,7 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
clearScreen(sstregs,0x00000000,8,2);
/* draw a 2x2 rectangle */
drawRect(sstregs,0,0,2,2);
drawRect(sstregs, ucNumTMU, 0, 0, 2, 2);
sst1InitIdle(sst);
/* reading back first line pixels addresses */
@@ -89,8 +91,9 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
logD("===========================================================\n");
logD( "# fault on 1st line, value : 0x%04X [expected 0x%04X] !\n",
value1, L1_1);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U9_TMU0_TF_DATA_0, U9_TMU0_TF_DATA_0);
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);
@@ -102,50 +105,29 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
if(ucNumTMU == 0)
{
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreFront, U14, U12);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreBack, U23, U24);
WordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 4, U9_TMU0 + 1, U9_TMU0 + 16 + 1);
TMUTexDataCtrlFaultSet( pFaultSrcCtx,
ErrorMark_L1,
1.0 / 8,
U9_TMU0_TEX_CAS0,
U9_TMU0_TEX_CAS1,
mem < 0x200000 ?
U9_TMU0_TEX_RAS0
: U9_TMU0_TEX_RAS1,
U9_TMU0_TEX_WE);
if(RamSizeMB>2)
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreBack, U23, U24);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 4, U9_TMU0 + 1, U9_TMU0 + 16 + 1);
}
else
{
/* during TMU1 test, TMU0 doesnt receive any textures => ignoring these
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 2, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 2, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
*/
/* U9_TMU0_TT_DATA_x is only tested when using TMU1 */
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U9_TMU0_TT_DATA_0, U9_TMU0_TT_DATA_0);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, TT_TDATA_R131, TT_TDATA_R131);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U8_TMU1_TF_DATA_0, U8_TMU1_TF_DATA_0);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L1, 1.0 / 16, U8_TMU1_FT_DATA_0, U8_TMU1_FT_DATA_0);
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);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreFront, U13, U11);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreBack, U27, U28);
WordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 4, U8_TMU1 + 1, U8_TMU1 + 16 + 1);
TMUTexDataCtrlFaultSet( pFaultSrcCtx,
ErrorMark_L1,
1.0 / 8,
U8_TMU1_TEX_CAS0,
U8_TMU1_TEX_CAS1,
mem < 0x200000 ?
U8_TMU1_TEX_RAS0
: U8_TMU1_TEX_RAS1,
U8_TMU1_TEX_WE);
if(RamSizeMB>2)
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L1, dScoreBack, U27, U28);
LWordBitFaultSet(pFaultSrcCtx,ErrorMark_L1, 1.0 / 4, U8_TMU1 + 1, U8_TMU1 + 16 + 1);
}
logD("## overall fault LW bit-map : \n");
if(sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
{
@@ -160,8 +142,9 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
logD("===========================================================\n");
logD( "# fault on 2nd line, value : 0x%04X [expected 0x%04X] !\n",
value2, L2_1);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U9_TMU0_TF_DATA_0, U9_TMU0_TF_DATA_0);
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);
@@ -173,43 +156,27 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
if(ucNumTMU == 0)
{
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreFront, U18, U17);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreBack, U25, U26);
WordBitFaultSet(pFaultSrcCtx,ErrorMark_L2, 1.0 / 4, U9_TMU0 + 32 + 1, U9_TMU0 + 48 + 1);
TMUTexDataCtrlFaultSet( pFaultSrcCtx,
ErrorMark_L2,
1.0 / 8,
U9_TMU0_TEX_CAS2,
U9_TMU0_TEX_CAS3,
mem < 0x200000 ? U9_TMU0_TEX_RAS0 : U9_TMU0_TEX_RAS1,
U9_TMU0_TEX_WE);
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);
}
else
{
/* during TMU1 test, TMU0 doesnt receive any textures => ignoring these
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 2, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
LWordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 2, U9_TMU0_FT_DATA_0, U9_TMU0_FT_DATA_0);
*/
/* U9_TMU0_TT_DATA_x is only tested when using TMU1 */
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U9_TMU0_TT_DATA_0, U9_TMU0_TT_DATA_0);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, TT_TDATA_R131, TT_TDATA_R131);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U8_TMU1_TF_DATA_0, U8_TMU1_TF_DATA_0);
WordBitFaultSet(pFaultSrcCtx, ErrorMark_L2, 1.0 / 16, U8_TMU1_FT_DATA_0, U8_TMU1_FT_DATA_0);
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);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreFront, U16, U15);
MemChipDQFaultSet(pFaultSrcCtx, ErrorMark_L2, dScoreBack, U29, U30);
WordBitFaultSet(pFaultSrcCtx,ErrorMark_L2, 1.0 / 4, U8_TMU1 + 32 + 1, U8_TMU1 + 48 + 1);
TMUTexDataCtrlFaultSet( pFaultSrcCtx,
ErrorMark_L2,
1.0 / 8,
U8_TMU1_TEX_CAS2,
U8_TMU1_TEX_CAS3,
mem < 0x200000 ?
U8_TMU1_TEX_RAS0
: U8_TMU1_TEX_RAS1,
U8_TMU1_TEX_WE);
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);
}
logD("## overall fault LW bit-map : \n");
if(sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
@@ -231,9 +198,9 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
}
unsigned long long
test_TMU_datalines( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
test_TMU_datalines( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const unsigned char ucNumTMU,
const unsigned char bRandom,
const unsigned char RamSizeMB,
@@ -298,12 +265,13 @@ test_TMU_datalines( sst1DeviceInfoStruct* devInfo,
addrTest,
bitTest,
bitTest2,
RamSizeMB,
pFaultSrcCtx);
ullNbErrorAll += ulNbError;
if((bRandom && (nloop > 64)) || bitTest == 0)
break;
bitTest = bRandom ?
get_notnull_random_balanced_mByte()
: (bitTest << 1);

6
Test_Data.h
View File

@@ -19,9 +19,9 @@
#define _DEF_TEST_DATA_H_
unsigned long long
test_TMU_datalines( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
test_TMU_datalines( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const unsigned char ucNumTMU,
const unsigned char bRandom,
const unsigned char RamSizeMB,

129
Test_Data_Huge.c
View File

@@ -110,14 +110,17 @@ static const def_sFaultSheet sFaultSheet[MAX_TMU][2] =
};
static void
AssignFault(const def_sFaultSheet* psCurFaultSheet,
AssignFault(const def_sFaultSheet * const
psCurFaultSheet,
const FxU32 mem,
const unsigned char bitIdx,
const unsigned char _relbitIdx,
const unsigned char _relbitIdxWord,
const unsigned char _relbitIdxQuartet,
const unsigned char WordIdx,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec * const
pFaultSrcCtx)
{
//const unsigned char relbitIdxQuartet= bitIdx%4;
const unsigned char relbitIdxQuartet = _relbitIdxQuartet;
@@ -156,6 +159,12 @@ AssignFault(const def_sFaultSheet* psCurFaultSheet,
+ 97 //U9_TMU0_TF_DATA_x
+ relbitIdxWord,
1.0/4);
FaultSource_addScore( pFaultSrcCtx,
U3_FBI_TF_DATA_0
+ relbitIdxWord,
1.0/4);
switch(WordIdx)
{
case 0:
@@ -234,11 +243,12 @@ AssignFault(const def_sFaultSheet* psCurFaultSheet,
+ 1
+ relbitIdxWord,
1.0/2); //ok
FaultSource_addScore( pFaultSrcCtx,
psCurFaultSheet->Ux_MEMChip_AltMSB
+ 1
+ relbitIdxWord,
1.0/4);
if(RamSizeMB>2)
FaultSource_addScore( pFaultSrcCtx,
psCurFaultSheet->Ux_MEMChip_AltMSB
+ 1
+ relbitIdxWord,
1.0/4);
}
else
{
@@ -251,11 +261,12 @@ AssignFault(const def_sFaultSheet* psCurFaultSheet,
+ 1
+ relbitIdxWord,
1.0/2);
FaultSource_addScore( pFaultSrcCtx,
psCurFaultSheet->Ux_MEMChip_AltLSB
+ 1
+ relbitIdxWord,
1.0/4);
if(RamSizeMB>2)
FaultSource_addScore( pFaultSrcCtx,
psCurFaultSheet->Ux_MEMChip_AltLSB
+ 1
+ relbitIdxWord,
1.0/4);
}
logD( "- TMUx_TEXDATA_x_x : %s\n",
@@ -306,12 +317,15 @@ AssignFault(const def_sFaultSheet* psCurFaultSheet,
}
static unsigned long long
RenderTest( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
const char ucNumTMU,
const FxU32 mem,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
RenderTest( sst1DeviceInfoStruct * const
devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const char ucNumTMU,
const FxU32 mem,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec * const
pFaultSrcCtx)
{
unsigned long long NbErr = 0;
static char szBuff[1024];
@@ -340,7 +354,7 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
/* Setting texture base address window for both CPU and TMU
*/
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
@@ -389,7 +403,7 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
#endif
/* draw a 256x256 square */
drawSquare(sstregs, 0, 0, 256);
drawSquare(sstregs, ucNumTMU, 0, 0, 256);
sst1InitIdle(sst);
#ifdef _PROFILING
@@ -479,34 +493,34 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
if(ErrorMark_Lx & 0x0000000Fu)
{
/*All calls have a lot of pre-computed const values to fast things up.*/
if(ErrorMark_Lx & 0x00000001u) AssignFault(psCurFaultSheet,mem,0,0,0,0,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000002u) AssignFault(psCurFaultSheet,mem,1,1,1,1,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000004u) AssignFault(psCurFaultSheet,mem,2,2,2,2,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000008u) AssignFault(psCurFaultSheet,mem,3,3,3,3,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000001u) AssignFault(psCurFaultSheet,mem,0,0,0,0,0,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000002u) AssignFault(psCurFaultSheet,mem,1,1,1,1,0,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000004u) AssignFault(psCurFaultSheet,mem,2,2,2,2,0,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000008u) AssignFault(psCurFaultSheet,mem,3,3,3,3,0,RamSizeMB,pFaultSrcCtx);
}
if(ErrorMark_Lx & 0x000000F0u)
{
if(ErrorMark_Lx & 0x00000010u) AssignFault(psCurFaultSheet,mem,4,4,4,0,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000020u) AssignFault(psCurFaultSheet,mem,5,5,5,1,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000040u) AssignFault(psCurFaultSheet,mem,6,6,6,2,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000080u) AssignFault(psCurFaultSheet,mem,7,7,7,3,0,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000010u) AssignFault(psCurFaultSheet,mem,4,4,4,0,0,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000020u) AssignFault(psCurFaultSheet,mem,5,5,5,1,0,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000040u) AssignFault(psCurFaultSheet,mem,6,6,6,2,0,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000080u) AssignFault(psCurFaultSheet,mem,7,7,7,3,0,RamSizeMB,pFaultSrcCtx);
}
}
if(ErrorMark_Lx & 0x0000FF00u)
{
if(ErrorMark_Lx & 0x00000F00u)
{
if(ErrorMark_Lx & 0x00000100u) AssignFault(psCurFaultSheet,mem,8,0, 8, 0,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000200u) AssignFault(psCurFaultSheet,mem,9,1, 9, 1,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000400u) AssignFault(psCurFaultSheet,mem,10,2,10,2,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000800u) AssignFault(psCurFaultSheet,mem,11,3,11,3,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000100u) AssignFault(psCurFaultSheet,mem,8,0, 8, 0,1,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000200u) AssignFault(psCurFaultSheet,mem,9,1, 9, 1,1,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000400u) AssignFault(psCurFaultSheet,mem,10,2,10,2,1,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00000800u) AssignFault(psCurFaultSheet,mem,11,3,11,3,1,RamSizeMB,pFaultSrcCtx);
}
if(ErrorMark_Lx & 0x0000F000u)
{
if(ErrorMark_Lx & 0x00001000u) AssignFault(psCurFaultSheet,mem,12,4,12,0,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00002000u) AssignFault(psCurFaultSheet,mem,13,5,13,1,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00004000u) AssignFault(psCurFaultSheet,mem,14,6,14,2,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00008000u) AssignFault(psCurFaultSheet,mem,15,7,15,3,1,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00001000u) AssignFault(psCurFaultSheet,mem,12,4,12,0,1,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00002000u) AssignFault(psCurFaultSheet,mem,13,5,13,1,1,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00004000u) AssignFault(psCurFaultSheet,mem,14,6,14,2,1,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00008000u) AssignFault(psCurFaultSheet,mem,15,7,15,3,1,RamSizeMB,pFaultSrcCtx);
}
}
}
@@ -521,34 +535,34 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
{
if(ErrorMark_Lx & 0x000F0000u)
{
if(ErrorMark_Lx & 0x00010000u) AssignFault(psCurFaultSheet,mem,16,0,0,0,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00020000u) AssignFault(psCurFaultSheet,mem,17,1,1,1,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00040000u) AssignFault(psCurFaultSheet,mem,18,2,2,2,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00080000u) AssignFault(psCurFaultSheet,mem,19,3,3,3,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00010000u) AssignFault(psCurFaultSheet,mem,16,0,0,0,2,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00020000u) AssignFault(psCurFaultSheet,mem,17,1,1,1,2,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00040000u) AssignFault(psCurFaultSheet,mem,18,2,2,2,2,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00080000u) AssignFault(psCurFaultSheet,mem,19,3,3,3,2,RamSizeMB,pFaultSrcCtx);
}
if(ErrorMark_Lx & 0x00F00000u)
{
if(ErrorMark_Lx & 0x00100000u) AssignFault(psCurFaultSheet,mem,20,4,4,0,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00200000u) AssignFault(psCurFaultSheet,mem,21,5,5,1,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00400000u) AssignFault(psCurFaultSheet,mem,22,6,6,2,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00800000u) AssignFault(psCurFaultSheet,mem,23,7,7,3,2,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00100000u) AssignFault(psCurFaultSheet,mem,20,4,4,0,2,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00200000u) AssignFault(psCurFaultSheet,mem,21,5,5,1,2,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00400000u) AssignFault(psCurFaultSheet,mem,22,6,6,2,2,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x00800000u) AssignFault(psCurFaultSheet,mem,23,7,7,3,2,RamSizeMB,pFaultSrcCtx);
}
}
if(ErrorMark_Lx & 0xFF000000u)
{
if(ErrorMark_Lx & 0x0F000000u)
{
if(ErrorMark_Lx & 0x01000000u) AssignFault(psCurFaultSheet,mem,24,0,8, 0,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x02000000u) AssignFault(psCurFaultSheet,mem,25,1,9, 1,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x04000000u) AssignFault(psCurFaultSheet,mem,26,2,10,2,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x08000000u) AssignFault(psCurFaultSheet,mem,27,3,11,3,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x01000000u) AssignFault(psCurFaultSheet,mem,24,0,8, 0,3,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x02000000u) AssignFault(psCurFaultSheet,mem,25,1,9, 1,3,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x04000000u) AssignFault(psCurFaultSheet,mem,26,2,10,2,3,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x08000000u) AssignFault(psCurFaultSheet,mem,27,3,11,3,3,RamSizeMB,pFaultSrcCtx);
}
if(ErrorMark_Lx & 0xF0000000u)
{
if(ErrorMark_Lx & 0x10000000u) AssignFault(psCurFaultSheet,mem,28,4,12,0,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x20000000u) AssignFault(psCurFaultSheet,mem,29,5,13,1,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x40000000u) AssignFault(psCurFaultSheet,mem,30,6,14,2,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x80000000u) AssignFault(psCurFaultSheet,mem,31,7,15,3,3,pFaultSrcCtx);
if(ErrorMark_Lx & 0x10000000u) AssignFault(psCurFaultSheet,mem,28,4,12,0,3,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x20000000u) AssignFault(psCurFaultSheet,mem,29,5,13,1,3,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x40000000u) AssignFault(psCurFaultSheet,mem,30,6,14,2,3,RamSizeMB,pFaultSrcCtx);
if(ErrorMark_Lx & 0x80000000u) AssignFault(psCurFaultSheet,mem,31,7,15,3,3,RamSizeMB,pFaultSrcCtx);
}
}
}
@@ -584,12 +598,14 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
}
unsigned long long
test_TMU_datalines_Huge( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
test_TMU_datalines_Huge( sst1DeviceInfoStruct * const
devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const unsigned char ucNumTMU,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
def_sFaultSourceScoreRec * const
pFaultSrcCtx)
{
typedef struct _def_sMemBlock{
uint32_t ulAddStart;
@@ -645,6 +661,7 @@ test_TMU_datalines_Huge( sst1DeviceInfoStruct* devInfo,
sstregs,
ucNumTMU,
addrTest,
RamSizeMB,
pFaultSrcCtx);
ullNbErrorAll += ullNbError;
if(ullNbError)

6
Test_Data_Huge.h
View File

@@ -19,9 +19,9 @@
#define _DEF_TEST_DATA_HUGE_H_
unsigned long long
test_TMU_datalines_Huge( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
test_TMU_datalines_Huge( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const unsigned char ucNumTMU,
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec* const pFaultSrcCtx);

653
Test_Data_NoMem.c Normal file
View File

@@ -0,0 +1,653 @@
/* V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
* Copyright (C) 2026 ChaCha
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#define _BSD_SOURCE 1
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <math.h>
#include "cvg.h"
#include <glide.h>
#include "sst1init.h"
#include "fxpci.h"
#include "FaultSources.h"
#include "Utils.h"
#include "Draw.h"
#include "Test_Common.h"
#include "Test_Data_Huge.h"
#include "Test_Data_NoMem.h"
extern const def_sTestPattern ar_sExpectedPattern_Test3[];
extern const unsigned int uNbPattern_Test3;
extern const def_sTestPattern ar_sExpectedPattern_Test3_Dither[];
extern const unsigned int uNbPattern_Test3_Dither;
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],
pREF->data.access.u16Pix[0][2],
pREF->data.access.u16Pix[0][3]);
printf("RGB: %04X %04X %04X %04X\n",
pREF->data.access.u16Pix[1][0],
pREF->data.access.u16Pix[1][1],
pREF->data.access.u16Pix[1][2],
pREF->data.access.u16Pix[1][3]);
printf("RGB: %04X %04X %04X %04X\n",
pREF->data.access.u16Pix[2][0],
pREF->data.access.u16Pix[2][1],
pREF->data.access.u16Pix[2][2],
pREF->data.access.u16Pix[2][3]);
printf("RGB: %04X %04X %04X %04X\n",
pREF->data.access.u16Pix[3][0],
pREF->data.access.u16Pix[3][1],
pREF->data.access.u16Pix[3][2],
pREF->data.access.u16Pix[3][3]);
printf("Alpha: %02X %02X %02X %02X\n",
pREF->data.access.u8APix[0][0],
pREF->data.access.u8APix[0][1],
pREF->data.access.u8APix[0][2],
pREF->data.access.u8APix[0][3]);
printf("Alpha: %02X %02X %02X %02X\n",
pREF->data.access.u8APix[1][0],
pREF->data.access.u8APix[1][1],
pREF->data.access.u8APix[1][2],
pREF->data.access.u8APix[1][3]);
printf("Alpha: %02X %02X %02X %02X\n",
pREF->data.access.u8APix[2][0],
pREF->data.access.u8APix[2][1],
pREF->data.access.u8APix[2][2],
pREF->data.access.u8APix[2][3]);
printf("Alpha: %02X %02X %02X %02X\n",
pREF->data.access.u8APix[3][0],
pREF->data.access.u8APix[3][1],
pREF->data.access.u8APix[3][2],
pREF->data.access.u8APix[3][3]);
}
// Returns the distance between A & B, normalized between 0 and 1.
// 0 means they are perfectly identicals.
// 1 means they are entirely diferents.
double ComputePatternDistance( const def_sTestPattern * const pA,
const def_sTestPattern * const pB)
{
double dDistance = 0;
logT("========================\n");
logT("Compare A|B:\n");
for (unsigned int i = 0; i <12; i=i+4)
{
logT("%08X\t%08X\n",pA->data.raw[i],pB->data.raw[i]);
logT("%08X\t%08X\n",pA->data.raw[i+1],pB->data.raw[i+1]);
logT("%08X\t%08X\n",pA->data.raw[i+2],pB->data.raw[i+2]);
logT("%08X\t%08X\n",pA->data.raw[i+3],pB->data.raw[i+3]);
dDistance += dComputeDistance32(pA->data.raw[i], pB->data.raw[i]);
dDistance += dComputeDistance32(pA->data.raw[i+1],pB->data.raw[i+1]);
dDistance += dComputeDistance32(pA->data.raw[i+2],pB->data.raw[i+2]);
dDistance += dComputeDistance32(pA->data.raw[i+3],pB->data.raw[i+3]);
}
dDistance /= 12*4*32;
return dDistance;
}
typedef struct _def_sScoreSet{
double dScore;
const def_sTestPattern * pREF;
}def_sScoreSet;
int scoreSetCmp(const void * const first, const void * const second)
{
const double scoreFirst = ((def_sScoreSet*)first)->dScore;
const double scoreSecond = ((def_sScoreSet*)second)->dScore;
return scoreFirst > scoreSecond ? -1 :
(scoreFirst < scoreSecond ? 1 : 0);
}
double inline ScaleScore(const double dIn,const double dK)
{
return (1.0-exp(-dK*dIn))/(1.0-exp(-dK));
//return log(1.0+(dK*dIn))/log(1.0+dK);
}
/* returns a def_sScoreSet array, containing ordered reference to testPattern
* plus the corresponding score.
*/
void GetNearestIndexes( const def_sTestPattern * const pREF,
const def_sTestPattern * const pSet,
def_sScoreSet * const ScoreSet,
const unsigned int uNbPattern)
{
for (unsigned int i = 0; i < uNbPattern; i++)
{
ScoreSet[i].pREF = &pSet[i];
ScoreSet[i].dScore = (1 - ScaleScore(ComputePatternDistance(pREF,pSet+i),100));
}
qsort(ScoreSet,uNbPattern,sizeof(def_sScoreSet),scoreSetCmp);
double dFirstScore = -INFINITY;
for (unsigned int i = 0; i < uNbPattern; i++)
{
if(i==0)
dFirstScore = ScoreSet[i].dScore;
ScoreSet[i].dScore = (ScoreSet[i].dScore / dFirstScore) * 100;
}
}
unsigned char DistributeFaults( const def_sTestPattern * const pREF,
const def_sTestPattern * const pREFPatterns,
const unsigned int uNbREFPatterns,
const unsigned char ucNumTMU,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
{
def_sScoreSet * const ScoreSet
= (def_sScoreSet*)malloc(uNbREFPatterns*sizeof(def_sScoreSet));
if(ScoreSet==NULL)
{
logE("Cannot allocate memory...");
return 1;
}
GetNearestIndexes(pREF,pREFPatterns,ScoreSet,uNbREFPatterns);
for( int i =0; i<uNbREFPatterns;i++)
{
if( ScoreSet[i].pREF->bReferenceSet && ScoreSet[i].dScore==100)
{
//logD("No Fault found\n");
return 0;
}
}
if( sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
{
DisplayPattern(pREF);
logD("==========================\n");
for( int i =0; i<uNbREFPatterns;i++)
{
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)
{
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);
}
}
}
}
free(ScoreSet);
return 1;
}
void TestStep_NoMem(FxU32 * const sst,
SstRegs * const sstregs,
const unsigned char ucNumTMU,
const uint8_t bEnableRGB,
const uint8_t bEnbleAlpha,
const uint8_t bEnableDitherValues,
def_sTestPattern * const psResultPattern)
{
ISET(SST_TREX(sstregs,ucNumTMU)->texBaseAddr, (0x000000>>3));
volatile const FxU32 * const pLFB1 = sst + (SST_LFB_ADDR>>2);
volatile const FxU32 * const pLFB2 = pLFB1 +((2048)>>2) ;
volatile const FxU32 * const pLFB3 = pLFB2 +((2048)>>2) ;
volatile const FxU32 * const pLFB4 = pLFB3 +((2048)>>2) ;
ISET( SST_TREX(sstregs,ucNumTMU)->textureMode,
SST_RGB565
| (bEnableRGB ? SST_TC_ONE : SST_TC_ZERO)
| (bEnbleAlpha ? SST_TCA_ONE :SST_TCA_ZERO));
if(bEnableDitherValues)
{
/* We are using dithering to detect lsb Faults.
* We need a non-zero original LFB value for dithering to happen.
* Drawing a triangle make detection easier.*/
clearScreen(sstregs,(1 << 11) | (0<<5) |(1),8,8);
drawTriangle(sstregs, ucNumTMU, 0, 0, 3, 4);
}
else
{
clearScreen(sstregs,0x00000000,8,8);
drawRect2(sstregs, ucNumTMU, 0, 0, 4, 4);
}
sst1InitIdle(sst);
mmio_fastread32((uint32_t*)psResultPattern->data.access.u16Pix[0], pLFB1, 2);
mmio_fastread32((uint32_t*)psResultPattern->data.access.u16Pix[1], pLFB2, 2);
mmio_fastread32((uint32_t*)psResultPattern->data.access.u16Pix[2], pLFB3, 2);
mmio_fastread32((uint32_t*)psResultPattern->data.access.u16Pix[3], pLFB4, 2);
const uint32_t OldlfbMode = IGET(sstregs->lfbMode);
ISET(sstregs->lfbMode, (OldlfbMode & ~SST_LFB_READFRONTBUFFER) //SST_LFB_READBACKBUFFER
| SST_LFB_READDEPTHABUFFER);
psResultPattern->data.access.u8APix[0][0] = pLFB1[0] & 0xFF;
psResultPattern->data.access.u8APix[0][1] = (pLFB1[0]>>16) & 0xFF;
psResultPattern->data.access.u8APix[0][2] = pLFB1[1] & 0xFF;
psResultPattern->data.access.u8APix[0][3] = (pLFB1[1]>>16) & 0xFF;
psResultPattern->data.access.u8APix[1][0] = pLFB2[0] & 0xFF;
psResultPattern->data.access.u8APix[1][1] = (pLFB2[0]>>16) & 0xFF;
psResultPattern->data.access.u8APix[1][2] = pLFB2[1] & 0xFF;
psResultPattern->data.access.u8APix[1][3] = (pLFB2[1]>>16) & 0xFF;
psResultPattern->data.access.u8APix[2][0] = pLFB3[0] & 0xFF;
psResultPattern->data.access.u8APix[2][1] = (pLFB3[0]>>16) & 0xFF;
psResultPattern->data.access.u8APix[2][2] = pLFB3[1] & 0xFF;
psResultPattern->data.access.u8APix[2][3] = (pLFB3[1]>>16) & 0xFF;
psResultPattern->data.access.u8APix[3][0] = pLFB4[0] & 0xFF;
psResultPattern->data.access.u8APix[3][1] = (pLFB4[0]>>16) & 0xFF;
psResultPattern->data.access.u8APix[3][2] = pLFB4[1] & 0xFF;
psResultPattern->data.access.u8APix[3][3] = (pLFB4[1]>>16) & 0xFF;
ISET(sstregs->lfbMode, OldlfbMode);
ISET( SST_TREX(sstregs,ucNumTMU)->textureMode,
SST_RGB565 | SST_TC_REPLACE | SST_TCA_REPLACE);
}
#define N_LOOP_TEST 20
unsigned long long
test_TMU_datalines_NoMem( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const unsigned char ucNumTMU,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
{
unsigned long long ullNbErrorAll = 0;
static def_sTestPattern ar_ResultPattern[N_LOOP_TEST][8];
sst1InitIdle(sst);
const uint32_t OldlfbMode = IGET(sstregs->lfbMode);//SST_LFB_READBACKBUFFER
ISET(sstregs->lfbMode, SST_LFB_565 | SST_LFB_READFRONTBUFFER | SST_LFB_RGBALANES_ARGB);
const uint32_t OldfbzMode = IGET(sstregs->fbzMode);
ISET(sstregs->fbzMode,
// SST_DRAWBUFFER_BACK
SST_DRAWBUFFER_FRONT
| SST_RGBWRMASK
| SST_ZAWRMASK
| SST_ENALPHABUFFER // <-for NoMEM test ?? Not needed
| SST_ENALPHAMASK); // <-for NoMEM test; Needed
const uint32_t OldtrexInit0 = IGET(SST_TREX(sstregs,ucNumTMU)->trexInit0);
devInfo->tmuInit0[(int)ucNumTMU] = SST_TREXINIT0_DEFAULT ;
ISET(SST_TREX(sstregs,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
sst1InitIdle(sst);
/* set downstream TMUs to passthrough */
for (int i=0; i< ucNumTMU; i++)
{
ISET(SST_TREX(sstregs,i)->textureMode, SST_RGB565 | SST_TC_PASS | SST_TCA_PASS);
}
/* Testing several time to exclude instabilities */
for(unsigned int i = 0; i < N_LOOP_TEST ; i++)
{
/* this test is using the only feature I found that can
* control TMUs output without using TMU's RAM. Using
* textureMode we can force a TMU to output RGB value to
* 0xFFFFFF or 0x000000 (only), and A(lpha) to 0xFF or 0x00 (Only).
* So we will try these 4 pattern and check what we get on the LFB.
* Then eventually we can make "smart" Fault recognition...
*
* To make things harder, the physical data bus is 16Bit (DDR?).
* So [AR] and [GB] or superposed.
* */
/***************/
/* RGB: 0, A: 0*/
/***************/
/* Not implemented because the "all on" test should be enough for now
TestStep_NoMem( sst, sstregs, ucNumTMU, 0 ,0, 1,
&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,
&ar_ResultPattern[i][1]);*/
/***************/
/* RGB: 1, A: 1*/
/***************/
TestStep_NoMem( sst, sstregs, ucNumTMU, 1, 1 , 1,
&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,
&ar_ResultPattern[i][3]);*/
}
/* Same test but with dithering enabled to get bit 0-1 values */
ISET(sstregs->fbzMode,
// SST_DRAWBUFFER_BACK
SST_DRAWBUFFER_FRONT
| SST_ENDITHER // <- enabling Dithering for this test
| SST_RGBWRMASK
| SST_ZAWRMASK
| SST_ENALPHABUFFER
| SST_ENALPHAMASK);
for(unsigned int i = 0; i < N_LOOP_TEST ; i++)
{
/* this test is using the only feature I found that can
* control TMUs output without using TMU's RAM. Using
* textureMode we can force a TMU to output RGB value to
* 0xFFFFFF or 0x000000 (only), and A(lpha) to 0xFF or 0x00 (Only).
* So we will try these 4 pattern and check what we get on the LFB.
* Then eventually we can make "smart" Fault recognition...
*
* To make things harder, the physical data bus is 16Bit (DDR?).
* So [AR] and [GB] or superposed.
* */
/***************/
/* RGB: 0, A: 0*/
/***************/
/* Not implemented because the "all on" test should be enough for now
TestStep_NoMem( sst, sstregs, ucNumTMU, 0 ,0, 1,
&ar_ResultPattern[i][4]);*/
/***************/
/* RGB: 1, A: 0*/
/***************/
/* Not implemented because the "all on" test should be enough for now
TestStep_NoMem( sst, sstregs, ucNumTMU, 1, 0, 1,
&ar_ResultPattern[i][5]);*/
/***************/
/* RGB: 1, A: 1*/
/***************/
TestStep_NoMem( sst, sstregs, ucNumTMU, 1, 1 , 1,
&ar_ResultPattern[i][6]);
/***************/
/* RGB: 0, A: 1*/
/***************/
/* Not implemented because the "all on" test should be enough for now
TestStep_NoMem( sst, sstregs, ucNumTMU, 0, 1 , 1,
&ar_ResultPattern[i][7]);*/
}
/* Post processing test results */
for(unsigned int i = 0; i < N_LOOP_TEST ; i++)
{ /* Not implemented because the "all on" test should be enough for now
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][0],
ar_sExpectedPattern_Test1,
uNbPattern_Test1,
ucNumTMU,
pFaultSrcCtx);*/
/* Not implemented because the "all on" test should be enough for now
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][1],
ar_sExpectedPattern_Test2,
uNbPattern_Test2,
ucNumTMU,
pFaultSrcCtx);*/
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][2],
ar_sExpectedPattern_Test3,
uNbPattern_Test3,
ucNumTMU,
pFaultSrcCtx);
/* Not implemented because the "all on" test should be enough for now
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][3],
ar_sExpectedPattern_Test4,
uNbPattern_Test4,
ucNumTMU,
pFaultSrcCtx);*/
/* Not implemented because the "all on" test should be enough for now
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][4],
ar_sExpectedPattern_Test1_Dither,
uNbPattern_Test1_Dither,
ucNumTMU,
pFaultSrcCtx);*/
/* Not implemented because the "all on" test should be enough for now
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][5],
ar_sExpectedPattern_Test2_Dither,
uNbPattern_Test2_Dither,
ucNumTMU,
pFaultSrcCtx);*/
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][6],
ar_sExpectedPattern_Test3_Dither,
uNbPattern_Test3_Dither,
ucNumTMU,
pFaultSrcCtx);
/* Not implemented because the "all on" test should be enough for now
ullNbErrorAll +=
DistributeFaults( &ar_ResultPattern[i][7],
ar_sExpectedPattern_Test4_Dither,
uNbPattern_Test4_Dither,
ucNumTMU,
pFaultSrcCtx);*/
}
/* reset the Init0 register back to its previous value */
ISET(sstregs->lfbMode,OldlfbMode);
ISET(sstregs->fbzMode, OldfbzMode);
sst1InitIdle(sst);
devInfo->tmuInit0[(int)ucNumTMU] = OldtrexInit0;
ISET(SST_TREX(sstregs,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
sst1InitIdle(sst);
return ullNbErrorAll;
}
/* This is an attempt to simulate TMU->FBI->LFB values exchange and
* computation. It partially works for normal mode (no dithering, alpha buffer
* enabled), with two exception: Alpha bit XX seems to have a special behaviour
* that just zeros the output. And the colour mixing hasnt been reverse
* enginered. The dithering algorithm hasnt been reversed either.
* Then, because we are using pattern distance matching, this function is not
* used anymore. I let it here in case one day we want/need to implement a more
* accurate test
*
int simuFault_step( uint8_t bRGB,
uint8_t bA,
uint16_t u16CurrentPixel,
uint8_t u8CurrentAPixel,
uint16_t * const pu16RenderedPixel,
uint8_t * const pu8RenderedAPixel,
uint16_t u16BUSFaultMap )
{
// TMU Output force set
const uint8_t u8TMU_r8 = bRGB ? 0xFF : 0;
const uint8_t u8TMU_g8 = bRGB ? 0xFF : 0;
const uint8_t u8TMU_b8 = bRGB ? 0xFF : 0;
const uint8_t u8TMU_a8 = bA ? 0xFF : 0;
// TMU Output values packing (useless as its only all 0 or 1, but for brain model..)
const uint16_t u16Sent_W1 = (u8TMU_g8<<8) + u8TMU_b8;
const uint16_t u16Sent_W2 = (u8TMU_a8<<8) + u8TMU_r8;
// FBI receiving + Error aplication
const uint16_t u16received_W1 = u16Sent_W1 & ~u16BUSFaultMap;
const uint16_t u16received_W2 = u16Sent_W2 & ~u16BUSFaultMap;
// FBI received colours unpacking (!!! to be checked)
uint16_t u16FBI_Input_r8 = (u16received_W2 & 0xFF);
uint16_t u16FBI_Input_g8 = (u16received_W1 >> 8);
uint16_t u16FBI_Input_b8 = (u16received_W1 & 0xFF);
uint16_t u16FBI_Input_a8 = (u16received_W2 >> 8);
// FBI LFB current colours unpacking
const uint16_t u16FBI_Current_r8 = ((u16CurrentPixel>>11) & 0x1F) << 3;
const uint16_t u16FBI_Current_g8 = ((u16CurrentPixel>>5) & 0x3F) << 2;
const uint16_t u16FBI_Current_b8 = ((u16CurrentPixel>>0) & 0x1F) << 3;
const uint16_t u16FBI_Current_a8 = u8CurrentAPixel;
// Mixing current and new colours
//u16FBI_Input_r8 *= u16FBI_Input_a8;
// This does not work
//u16FBI_Input_r8 += u16FBI_Current_r8 * (255-u16FBI_Input_a8);
//u16FBI_Input_r8 >>=8;
//u16FBI_Input_g8 *= u16FBI_Input_a8;
//u16FBI_Input_g8 += u16FBI_Current_g8 * (255-u16FBI_Input_a8);
//u16FBI_Input_g8 >>=8;
//u16FBI_Input_b8 *= u16FBI_Input_a8;
//u16FBI_Input_b8 += u16FBI_Current_b8 * (255-u16FBI_Input_a8);
//u16FBI_Input_b8 >>=8;
//u16FBI_Input_a8 *= u16FBI_Input_a8;
//u16FBI_Input_a8 += u16FBI_Current_a8*(255-u16FBI_Input_a8);
//u16FBI_Input_a8 >>=8;
const uint16_t u16LFB_R5G6B5_r5 = (u16FBI_Input_r8>>3) & 0x1F;
const uint16_t u16LFB_R5G6B5_g6 = (u16FBI_Input_g8>>2) & 0x3F;
const uint16_t u16LFB_R5G6B5_b5 = (u16FBI_Input_b8>>3) & 0x1F;
const uint16_t u8LFB_R5G6B5_a8 = (u16FBI_Input_a8>>0) & 0xFF;
const uint16_t u16LBF_R5G6B5_Pixel = (u16LFB_R5G6B5_r5 <<11)
+ (u16LFB_R5G6B5_g6<<5)
+ (u16LFB_R5G6B5_b5);
const uint8_t u8LBF_R5G6B5_APixel = u8LFB_R5G6B5_a8;
*pu16RenderedPixel = u16LBF_R5G6B5_Pixel;
*pu8RenderedAPixel = u8LBF_R5G6B5_APixel;
return 0;
}
*/
/* In conjonction to the previous function, the idea here was to precompute all
* the possible fault pattern and use them as a comparison to find the actual
* one using real measurement. It is now deprecated in favor of the pattern
* distance matching.
*
void simuFault( uint8_t bRGB,
uint8_t bA )
{
uint16_t u16RenderedPixel;
uint8_t u8RenderedAPixel;
uint32_t u16PreviousPixel = 0;
uint16_t u8PreviousAPixel = 0;
//for(char bitPos1 = -1; bitPos1 <= 15 ; ++bitPos1)
//for(u8PreviousAPixel= 0; u8PreviousAPixel <= 0xFF ; ++u8PreviousAPixel)
{
//for(u16PreviousPixel= 0; u16PreviousPixel <= 0xFFFF ; ++u16PreviousPixel)
{
//u16PreviousPixel += (bitPos1 ==-1) ? 0 : (1u << bitPos1);
uint16_t Pattern_OK;
uint16_t APattern_OK;
for(char bitPos = -1; bitPos <= 15 ; ++bitPos)
{
const uint16_t u16FaultMap = (bitPos ==-1) ? 0 : (1u << bitPos);
simuFault_step( bRGB,
bA,
u16PreviousPixel,
u8PreviousAPixel,
&u16RenderedPixel,
&u8RenderedAPixel,
u16FaultMap);
//if(u16FaultMap==0)
//{
// Pattern_OK = u16RenderedPixel;
// APattern_OK = u8RenderedAPixel;
//}
//else if(u16FaultMap==0x100)
//{
// if((u16RenderedPixel!=Pattern_OK) && (u8RenderedAPixel!=APattern_OK))
// {
// printf("bRGB %d\n",bRGB);
// printf("bA, %d\n",bA);
// printf("u16PreviousPixel %04X\n",u16PreviousPixel);
// printf("u8PreviousAPixel %02X\n",u8PreviousAPixel);
// printf("SIMU: %04X\n",u16FaultMap);
// printf("\t0x%04X | 0x%02X %c\n",
// u16RenderedPixel,
// u8RenderedAPixel,
// (u16RenderedPixel==0xFFFF)
// && (u8RenderedAPixel==0xFF) ? '!' : ' ');
// }
//}
printf("bRGB %d\n",bRGB);
printf("bA, %d\n",bA);
printf("u16PreviousPixel %04X\n",u16PreviousPixel);
printf("u8PreviousAPixel %02X\n",u8PreviousAPixel);
printf("SIMU: %04X\n",u16FaultMap);
printf("\t0x%04X | 0x%02X %c\n",
u16RenderedPixel,
u8RenderedAPixel,
(u16RenderedPixel==0xFFFF)
&& (u8RenderedAPixel==0xFF) ? '!' : ' ');
}
}
}
}
*/

56
Test_Data_NoMem.h Normal file
View File

@@ -0,0 +1,56 @@
/* V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
* Copyright (C) 2026 ChaCha
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef _DEF_TEST_DATA_NOMEM_H_
#define _DEF_TEST_DATA_NOMEM_H_
#include <stdint.h>
#include "cvg.h"
#include "FaultSources.h"
typedef union _def_uTestPatternData{
struct {
uint16_t u16Pix[4][4]; //value in LFB after Blend
uint8_t u8APix[4][4]; //value in LFB after Blend
}access;
uint32_t raw[8+4];
}def_uTestPatternData;
typedef struct _def_sFaultSourceLineMap
{
def_eFaultSource eTMUFaultSource_FBI;
def_eFaultSource eTMUFaultSource_TMU0_RES;
def_eFaultSource eTMUFaultSource_TMU0_FBI;
def_eFaultSource eTMUFaultSource_TMU0_TMU1;
def_eFaultSource eTMUFaultSource_TMU1;
}def_sFaultSourceLineMap;
typedef struct _def_sTestPattern
{
uint8_t bReferenceSet;
uint8_t u8FaultLineIdx;
def_uTestPatternData data; // expected value in LFB after Blend
}def_sTestPattern;
unsigned long long
test_TMU_datalines_NoMem( sst1DeviceInfoStruct * const devInfo,
FxU32 * const sst,
SstRegs * const sstregs,
const unsigned char ucNumTMU,
def_sFaultSourceScoreRec* const pFaultSrcCtx);
#endif //_DEF_TEST_DATA_NOMEM_H_

761
Test_Data_NoMem_TestPatterns.c Normal file
View File

@@ -0,0 +1,761 @@
/* V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
* Copyright (C) 2026 ChaCha
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "Test_Data_NoMem.h"
const def_sFaultSourceLineMap ar_sFaultSourceLineMap[] =
{
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_0,
.eTMUFaultSource_TMU0_RES = RA10_1,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_0,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_0,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_0,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_1,
.eTMUFaultSource_TMU0_RES = RA10_2,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_1,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_1,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_1,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_2,
.eTMUFaultSource_TMU0_RES = RA10_3,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_2,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_2,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_2,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_3,
.eTMUFaultSource_TMU0_RES = RA10_4,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_3,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_3,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_3,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_4,
.eTMUFaultSource_TMU0_RES = RA11_1,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_4,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_4,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_4,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_5,
.eTMUFaultSource_TMU0_RES = RA11_2,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_5,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_5,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_5,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_6,
.eTMUFaultSource_TMU0_RES = RA11_3,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_6,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_6,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_6,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_7,
.eTMUFaultSource_TMU0_RES = RA11_4,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_7,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_7,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_7,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_8,
.eTMUFaultSource_TMU0_RES = RA12_1,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_8,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_8,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_8,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_9,
.eTMUFaultSource_TMU0_RES = RA12_2,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_9,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_9,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_9,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_10,
.eTMUFaultSource_TMU0_RES = RA12_3,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_10,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_10,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_10,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_11,
.eTMUFaultSource_TMU0_RES = RA12_4,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_11,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_11,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_11,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_12,
.eTMUFaultSource_TMU0_RES = RA13_1,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_12,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_12,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_12,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_13,
.eTMUFaultSource_TMU0_RES = RA13_2,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_13,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_13,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_13,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_14,
.eTMUFaultSource_TMU0_RES = RA13_3,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_14,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_14,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_14,
},
{
.eTMUFaultSource_FBI = U3_FBI_TF_DATA_15,
.eTMUFaultSource_TMU0_RES = RA13_4,
.eTMUFaultSource_TMU0_FBI = U9_TMU0_TF_DATA_15,
.eTMUFaultSource_TMU0_TMU1 = U9_TMU0_FT_DATA_15,
.eTMUFaultSource_TMU1 = U8_TMU1_TF_DATA_15,
},
};
const def_sTestPattern ar_sExpectedPattern_Test3[] =
{
{
.bReferenceSet = true, // Nominal set
.u8FaultLineIdx = 0,
.data = {
.access = {
.u16Pix = { {0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 0,
.data = {
.access = {
.u16Pix = { {0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 1,
.data = {
.access = {
.u16Pix = { {0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 2,
.data = {
.access = {
.u16Pix = { {0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 3,
.data = {
.access = {
.u16Pix = { {0xF7FE,0xF7FF,0xFFFF,0xFFFF},
{0xF7FE,0xF7FE,0xF7FF,0xFFFF},
{0xF7FE,0xF7FE,0xF7FE,0xF7FE},
{0xF7FE,0xF7FE,0xF7FE,0xF7FE}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 4,
.data = {
.access = {
.u16Pix = { {0xEFFD,0xEFFF,0xFFFF,0xFFFF},
{0xEFFD,0xEFFD,0xEFFF,0xFFFF},
{0xEFFD,0xEFFD,0xEFFD,0xEFFD},
{0xEFFD,0xEFFD,0xEFFD,0xEFFD}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 5,
.data = {
.access = {
.u16Pix = { {0xDFFB,0xDFFF,0xFFFF,0xFFFF},
{0xDFFB,0xDFFB,0xDFFF,0xFFFF},
{0xDFFB,0xDFFB,0xDFFB,0xDFFB},
{0xDFFB,0xDFFB,0xDFFB,0xDFFB}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 6,
.data = {
.access = {
.u16Pix = { {0xBFF7,0xBFFF,0xFFFF,0xFFFF},
{0xBFF7,0xBFF7,0xBFFF,0xFFFF},
{0xBFF7,0xBFF7,0xBFF7,0xBFF7},
{0xBFF7,0xBFF7,0xBFF7,0xBFF7}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 7,
.data = {
.access = {
.u16Pix = { {0x7FEF,0x7FFF,0xFFFF,0xFFFF},
{0x7FEF,0x7FEF,0x7FFF,0xFFFF},
{0x7FEF,0x7FEF,0x7FEF,0x7FEF},
{0x7FEF,0x7FEF,0x7FEF,0x7FEF}
},
.u8APix = { {0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 8,
.data = {
.access = {
.u16Pix = { {0x0000,0x0000,0xFFFF,0xFFFF},
{0x0000,0x0000,0x0000,0xFFFF},
{0x0000,0x0000,0x0000,0x0000},
{0x0000,0x0000,0x0000,0x0000}
},
.u8APix = { {0x00,0x00,0xFF,0xFF},
{0x00,0x00,0x00,0xFF},
{0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 9,
.data = {
.access = {
.u16Pix = { {0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF},
{0xFFFF,0xFFFF,0xFFFF,0xFFFF}
},
.u8APix = { {0xFD,0xFD,0xFF,0xFF},
{0xFD,0xFD,0xFD,0xFF},
{0xFD,0xFD,0xFD,0xFD},
{0xFD,0xFD,0xFD,0xFD}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 10,
.data = {
.access = {
.u16Pix = { {0xFFDF,0xFFFF,0xFFFF,0xFFFF},
{0xFFDF,0xFFDF,0xFFFF,0xFFFF},
{0xFFDF,0xFFDF,0xFFDF,0xFFFF},
{0xFFDF,0xFFDF,0xFFDF,0xFFDF}
},
.u8APix = { {0xFB,0xFB,0xFB,0xFB},
{0xFB,0xFB,0xFB,0xFB},
{0xFB,0xFB,0xFB,0xFB},
{0xFB,0xFB,0xFB,0xFB}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 11,
.data = {
.access = {
.u16Pix = { {0xFFBF,0xFFFF,0xFFFF,0xFFFF},
{0xFFBF,0xFFBF,0xFFFF,0xFFFF},
{0xFFBF,0xFFBF,0xFFBF,0xFFBF},
{0xFFBF,0xFFBF,0xFFBF,0xFFBF}
},
.u8APix = { {0xF7,0xF7,0xFF,0xFF},
{0xF7,0xF7,0xF7,0xFF},
{0xF7,0xF7,0xF7,0xF7},
{0xF7,0xF7,0xF7,0xF7}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 12,
.data = {
.access = {
.u16Pix = { {0xFF7F,0xFFFF,0xFFFF,0xFFFF},
{0xFF7F,0xFF7F,0xFFFF,0xFFFF},
{0xFF7F,0xFF7F,0xFF7F,0xFF7F},
{0xFF7F,0xFF7F,0xFF7F,0xFF7F}
},
.u8APix = { {0xEF,0xEF,0xFF,0xFF},
{0xEF,0xEF,0xEF,0xFF},
{0xEF,0xEF,0xEF,0xEF},
{0xEF,0xEF,0xEF,0xEF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 13,
.data = {
.access = {
.u16Pix = { {0xFEFF,0xFFFF,0xFFFF,0xFFFF},
{0xFEFF,0xFEFF,0xFFFF,0xFFFF},
{0xFEFF,0xFEFF,0xFEFF,0xFEFF},
{0xFEFF,0xFEFF,0xFEFF,0xFEFF}
},
.u8APix = { {0xDF,0xDF,0xFF,0xFF},
{0xDF,0xDF,0xDF,0xFF},
{0xDF,0xDF,0xDF,0xDF},
{0xDF,0xDF,0xDF,0xDF}
},
}
}
},
{ //OK
.bReferenceSet = false,
.u8FaultLineIdx = 14,
.data = {
.access = {
.u16Pix = { {0xFDFF,0xFFFF,0xFFFF,0xFFFF},
{0xFDFF,0xFDFF,0xFFFF,0xFFFF},
{0xFDFF,0xFDFF,0xFDFF,0xFDFF},
{0xFDFF,0xFDFF,0xFDFF,0xFDFF}
},
.u8APix = { {0xBF,0xBF,0xFF,0xFF},
{0xBF,0xBF,0xBF,0xFF},
{0xBF,0xBF,0xBF,0xBF},
{0xBF,0xBF,0xBF,0xBF}
},
}
}
},
{//OK
.bReferenceSet = false,
.u8FaultLineIdx = 15,
.data = {
.access = {
.u16Pix = { {0xFBFF,0xFFFF,0xFFFF,0xFFFF},
{0xFBFF,0xFBFF,0xFFFF,0xFFFF},
{0xFBFF,0xFBFF,0xFBFF,0xFBFF},
{0xFBFF,0xFBFF,0xFBFF,0xFBFF}
},
.u8APix = { {0x7F,0x7F,0xFF,0xFF},
{0x7F,0x7F,0x7F,0xFF},
{0x7F,0x7F,0x7F,0x7F},
{0x7F,0x7F,0x7F,0x7F}
},
}
}
},
};
const unsigned int uNbPattern_Test3 =
sizeof(ar_sExpectedPattern_Test3)/sizeof(def_sTestPattern);
const def_sTestPattern ar_sExpectedPattern_Test3_Dither[] =
{
{
.bReferenceSet = true, // Nominal set
.u8FaultLineIdx = 0,
.data = {
.access = {
.u16Pix = { {0xFFFF,0xFFFF,0xFFFF,0x0040},
{0xFFFF,0xFFFF,0x0040,0x0040},
{0xFFFF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 0,
.data = {
.access = {
.u16Pix = { {0xF7FE,0xFFFF,0xFFFF,0x0040},
{0xFFFF,0xFFFF,0x0040,0x0040},
{0xFFFF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 1,
.data = {
.access = {
.u16Pix = { {0xF7FE,0xFFFF,0xFFFF,0x0040},
{0xFFFF,0xFFFF,0x0040,0x0040},
{0xF7FE,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 2,
.data = {
.access = {
.u16Pix = { {0xF7FE,0xFFFF,0xFFFF,0x0040},
{0xFFFF,0xF7FE,0x0040,0x0040},
{0xF7FE,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 3,
.data = {
.access = {
.u16Pix = { {0xF7FE,0xF7FF,0xFFFF,0x0040},
{0xF7FE,0xF7FE,0x0040,0x0040},
{0xF7FE,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 4,
.data = {
.access = {
.u16Pix = { {0xEFFD,0xEFFF,0xFFFF,0x0040},
{0xEFFD,0xEFFD,0x0040,0x0040},
{0xEFFD,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 5,
.data = {
.access = {
.u16Pix = { {0xDFFB,0xDFFF,0xFFFF,0x0040},
{0xDFFB,0xDFFB,0x0040,0x0040},
{0xDFFB,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 6,
.data = {
.access = {
.u16Pix = { {0xBFF7,0xBFFF,0xFFFF,0x0040},
{0xC7F8,0xBFF7,0x0040,0x0040},
{0xBFF7,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 7,
.data = {
.access = {
.u16Pix = { {0x7FEF,0x7FEF,0xFFFF,0x0040},
{0x87F0,0x7FEF,0x0040,0x0040},
{0x7FEF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFF,0xFF,0xFF,0x0F},
{0xFF,0xFF,0x0F,0x0F},
{0xFF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 8,
.data = {
.access = {
.u16Pix = { {0x0040,0x0040,0xFFFF,0x0040},
{0x0040,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0x0F,0x0F,0xFF,0x0F},
{0x0F,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 9,
.data = {
.access = {
.u16Pix = { {0xFFDF,0xFFFF,0xFFFF,0x0040},
{0xFFFF,0xFFDF,0x0040,0x0040},
{0xFFDF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFD,0xFD,0xFF,0x0F},
{0xFD,0xFD,0x0F,0x0F},
{0xFD,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 10,
.data = {
.access = {
.u16Pix = { {0xFFDF,0xFFFF,0xFFFF,0x0040},
{0xFFDF,0xFFDF,0x0040,0x0040},
{0xFFDF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xFB,0xFB,0xFF,0x0F},
{0xFB,0xFB,0x0F,0x0F},
{0xFB,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 11,
.data = {
.access = {
.u16Pix = { {0xFFBF,0xFFFF,0xFFFF,0x0040},
{0xFFBF,0xFFBF,0x0040,0x0040},
{0xFFBF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xF7,0xF7,0xFF,0x0F},
{0xF7,0xF7,0x0F,0x0F},
{0xF7,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 12,
.data = {
.access = {
.u16Pix = { {0xFF7F,0xFFFF,0xFFFF,0x0040},
{0xFF7F,0xFF7F,0x0040,0x0040},
{0xFF7F,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xEF,0xEF,0xFF,0x0F},
{0xEF,0xEF,0x0F,0x0F},
{0xEF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 13,
.data = {
.access = {
.u16Pix = { {0xFEFF,0xFFFF,0xFFFF,0x0040},
{0xFEFF,0xFEFF,0x0040,0x0040},
{0xFEFF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xDF,0xDF,0xFF,0x0F},
{0xDF,0xDF,0x0F,0x0F},
{0xDF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{ //OK !
.bReferenceSet = false,
.u8FaultLineIdx = 14,
.data = {
.access = {
.u16Pix = { {0xFDFF,0xFFFF,0xFFFF,0x0040},
{0xFDFF,0xFDFF,0x0040,0x0040},
{0xFDFF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0xBF,0xBF,0xFF,0x0F},
{0xBF,0xBF,0x0F,0x0F},
{0xBF,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
{//OK
.bReferenceSet = false,
.u8FaultLineIdx = 15,
.data = {
.access = {
.u16Pix = { {0xFBFF,0xFFFF,0xFFFF,0x0040},
{0xFC1F,0xFBFF,0x0040,0x0040},
{0xFBFF,0x0040,0x0040,0x0040},
{0x0040,0x0040,0x0040,0x0040}
},
.u8APix = { {0x7F,0xFF,0xFF,0x0F},
{0x7F,0x7F,0x0F,0x0F},
{0x7F,0x0F,0x0F,0x0F},
{0x0F,0x0F,0x0F,0x0F}
},
}
}
},
};
const unsigned int uNbPattern_Test3_Dither =
sizeof(ar_sExpectedPattern_Test3_Dither)/sizeof(def_sTestPattern);

4
Utils.c
View File

@@ -23,7 +23,7 @@
#include "Utils.h"
void
sprintbin32( char* szBuff,
sprintbin32( char * szBuff,
const uint32_t ulVal,
const unsigned char bGroupByBytes)
{
@@ -53,7 +53,7 @@ printbin32( const uint32_t ulVal,
}
void
sprintbin32Info(char* szBuff,
sprintbin32Info(char * szBuff,
const uint32_t ulVal,
const unsigned short uhb,
const unsigned short ulb)

15
Utils.h
View File

@@ -55,25 +55,31 @@
static inline unsigned char
count_bit32(const uint32_t ulVal)
{
/*
unsigned char cpt = 0;
for(uint32_t idxBit = 0x80000000u; idxBit != 0; idxBit >>= 1)
if(ulVal & idxBit)
cpt++;
return cpt;
*/
return __builtin_popcount(ulVal);
}
static inline unsigned char
count_bit8(const uint8_t ulVal)
{
/*
unsigned char cpt = 0;
for(uint8_t idxBit = 0x80u; idxBit != 0; idxBit >>= 1)
if(ulVal & idxBit)
cpt++;
return cpt;
*/
return __builtin_popcount(ulVal);
}
void
sprintbin32( char* szBuff,
sprintbin32( char * const szBuff,
const uint32_t ulVal,
const unsigned char bGroupByBytes);
@@ -82,7 +88,7 @@ printbin32( const uint32_t ulVal,
const unsigned char bGroupByBytes);
void
sprintbin32Info(char* szBuff,
sprintbin32Info(char * const szBuff,
const uint32_t ulVal,
const unsigned short uhb,
const unsigned short ulb);
@@ -142,4 +148,9 @@ mmio_fastwrite32( volatile uint32_t * dst,
}
}
static inline double dComputeDistance32(const uint32_t u32A,const uint32_t u32B)
{
return (double)__builtin_popcount( u32A ^ u32B);
}
#endif //_DEF_UTILS_H_

25
V2MemTest.h
View File

@@ -1,9 +1,26 @@
/* V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
* Copyright (C) 2026 ChaCha
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef _DEF_V2MEMTEST_H_
#define _DEF_V2MEMTEST_H_
#define V2MEMTEST__VERSION__MAJOR 0
#define V2MEMTEST__VERSION__MINOR 2
#define V2MEMTEST__VERSION__PATCH 2
#define V2MEMTEST__VERSION__MINOR 4
#define V2MEMTEST__VERSION__PATCH 0
#include <stdbool.h>
#include <stdlib.h>
@@ -57,9 +74,13 @@ typedef struct _def_sOptions
def_eTMURamLimit eTMU0RamLimit;
int bTestTMU1;
def_eTMURamLimit eTMU1RamLimit;
int bTestTMUControl;
int bTestTMUAddress;
int bTestTMUData;
int bTestTMUDataHuge;
int bTestNoMem;
int bQuick;
int bForce;
} def_sOptions;
extern def_sOptions sOptions;

255
main.c
View File

@@ -35,9 +35,11 @@
#include "Draw.h"
#include "Test_Common.h"
#include "Test_Control.h"
#include "Test_Address.h"
#include "Test_Data.h"
#include "Test_Data_Huge.h"
#include "Test_Data_NoMem.h"
const char* szErrorMsg[] =
{
@@ -77,7 +79,9 @@ const char szHelp[] =
" -h, --help Show this help and exit.\n"
" --version Print version (MAJOR.MINOR.PATCH) and exit.\n"
" -n, --num <N> Number of loops (default: 1).\n"
" -l, --log <file> Log file path.\n"
" -q, --quick Quicker test (no pre-heat).\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"
@@ -91,6 +95,8 @@ const char szHelp[] =
" --tmu1 Enable only tests for TMU1.\n"
"\n"
"Test selection [ all if none set ] :\n"
" --no-mem Run no-mem test.\n"
" --control Run control lines tests.\n"
" --address Run address tests.\n"
" --data Run data tests.\n"
" --data-huge Run large/extended data tests.\n"
@@ -116,22 +122,30 @@ def_sOptions sOptions = {
.bTestTMU1 = false,
.eTMU1RamLimit = E_TMU_RAMSIZE__AUTO,
.bTestTMUAddress = false,
.bTestTMUControl = false,
.bTestTMUData = false,
.bTestTMUDataHuge = false,
.bTestNoMem = false,
.bQuick = false,
.bForce = false,
};
static struct option long_args[] = {
/* {<NAME>, <HAS_ARG>, <FLAG>, <VAL> */
{"help", no_argument, NULL, 'h'},
{"num", required_argument, NULL, 'n'},
{"log", required_argument, NULL, 'l'},
{"force", required_argument, NULL, 'f'},
/*{"log", required_argument, NULL, 'l'},*/
{"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},
{"address", no_argument, &sOptions.bTestTMUAddress, true},
{"data", no_argument, &sOptions.bTestTMUData, true},
{"data-huge", no_argument, &sOptions.bTestTMUDataHuge, true},
{"no-mem", no_argument, &sOptions.bTestNoMem, true},
{"tmu0-ram", required_argument, NULL, 3},
{"tmu1-ram", required_argument, NULL, 1},
{"version", no_argument, NULL, 2},
@@ -146,7 +160,7 @@ ar_dFaultScores_sorted[NB_FAULT_SOURCE];
#define _DEF_TEST_TIME_PER_MB_S 5
int main(int argc, char **argv)
int main(const int argc, char ** const argv)
{
int Status = 0;
unsigned long long ullNbErrorAll = 0;
@@ -156,7 +170,7 @@ int main(int argc, char **argv)
bool bQuit = false;
FxU32* sst = NULL;
while((opt=getopt_long(argc,argv,"hvn:t:l:",long_args,&option_index)) != -1)
while((opt=getopt_long(argc,argv,"hvfqn:t:l:",long_args,&option_index)) != -1)
{
switch(opt)
{
@@ -198,15 +212,22 @@ int main(int argc, char **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 'f':
sOptions.bForce = true;
break;
case 'h':
puts(szHelp);
bQuit = true;
@@ -244,11 +265,15 @@ int main(int argc, char **argv)
if( !sOptions.bTestTMUAddress &&
!sOptions.bTestTMUData &&
!sOptions.bTestTMUDataHuge)
!sOptions.bTestTMUDataHuge &&
!sOptions.bTestTMUControl&&
!sOptions.bTestNoMem)
{
sOptions.bTestTMUControl = true;
sOptions.bTestTMUAddress = true;
sOptions.bTestTMUData = true;
sOptions.bTestTMUDataHuge = true;
sOptions.bTestNoMem = true;
}
sst1DeviceInfoStruct devInfo;
@@ -299,6 +324,21 @@ int main(int argc, char **argv)
ErrorCheck_gotoCleanUp();
}
if(devInfo.numberTmus>2) //FixMe: This case can happen if U8_TMU1_TF_DATA_9 is wrong
{
logE("Only 2 TMUs are supported\n");
if(sOptions.bForce)
{
logW("Forcing one TMU");
devInfo.numberTmus = 1;
}
else
{
Status = E_ERROR__NO_TMU_SELECTED; //FixMe: custom error
ErrorCheck_gotoCleanUp();
}
}
for (int tmu = 0; tmu < devInfo.numberTmus; tmu++)
logI("TMU%d detected memory:\t%ld MB\n", tmu, (unsigned long)devInfo.tmuMemSize[tmu]);
@@ -315,25 +355,38 @@ int main(int argc, char **argv)
if(sOptions.bTestTMU0 && devInfo.numberTmus<1)
{
logE("TMU0 not Found\n");
Status = E_ERROR__TMU_NOT_FOUND;
ErrorCheck_gotoCleanUp();
if(sOptions.bForce)
{
logW("Forcing TMU0 test");
}
else
{
Status = E_ERROR__TMU_NOT_FOUND;
ErrorCheck_gotoCleanUp();
}
}
if(sOptions.bTestTMU1 && devInfo.numberTmus<2)
{
logE("TMU1 not Found\n");
Status = E_ERROR__TMU_NOT_FOUND;
ErrorCheck_gotoCleanUp();
if(sOptions.bForce)
{
logW("Forcing TMU1 test");
}
else
{
Status = E_ERROR__TMU_NOT_FOUND;
ErrorCheck_gotoCleanUp();
}
}
const bool bTestTMU0 = (devInfo.numberTmus > 0)
&& (devInfo.tmuMemSize[0] > 0)
&& sOptions.bTestTMU0;
const bool bTestTMU0 = ( (devInfo.numberTmus > 0)
|| sOptions.bForce)
&& sOptions.bTestTMU0;
const bool bTestTMU1 = (devInfo.numberTmus > 1)
&& (devInfo.tmuMemSize[1] > 0)
&& sOptions.bTestTMU1;
const bool bTestTMU1 = ( (devInfo.numberTmus > 1)
|| sOptions.bForce)
&& sOptions.bTestTMU1;
if(!bTestTMU0 && !bTestTMU1)
{
logE("no TMU selected.\n");
@@ -345,10 +398,26 @@ int main(int argc, char **argv)
logW("/!\\ make sure you did test TMU0 BEFORE TMU1.\n\n");
}
ISET(sstregs->lfbMode, SST_LFB_RGBALANES_ARGB | SST_LFB_READFRONTBUFFER);
ISET(sstregs->fbzMode, SST_DRAWBUFFER_FRONT | SST_RGBWRMASK);
ISET(sstregs->fbzColorPath, SST_RGBSEL_TREXOUT | SST_CC_PASS | SST_ENTEXTUREMAP);
ISET(sstregs->textureMode, SST_RGB565 | SST_TC_REPLACE | SST_TCA_REPLACE);
ISET(sstregs->lfbMode,
SST_LFB_RGBALANES_ARGB
| SST_LFB_READFRONTBUFFER);
ISET(sstregs->fbzMode,
SST_DRAWBUFFER_FRONT
| SST_RGBWRMASK); // <-for NoMEM test
ISET( sstregs->fbzColorPath,
SST_RGBSEL_TMUOUT
| SST_ASEL_TMUOUT // <-for NoMEM test
| SST_ENTEXTUREMAP);
for (int tmu = 0; tmu < devInfo.numberTmus; tmu++)
{
ISET( SST_TREX(sstregs,tmu)->textureMode,
SST_RGB565
| SST_TC_REPLACE
| SST_TCA_REPLACE);
}
ISET(sstregs->tLOD, 0);
for (int tmu = 0; tmu < devInfo.numberTmus; tmu++)
@@ -357,29 +426,128 @@ int main(int argc, char **argv)
if((tmu == 1) && !bTestTMU1) continue;
logI("## testing Board %d, TMU %d, %ldMB \n",boardNum,tmu,(unsigned long)devInfo.tmuMemSize[tmu]);
if(sOptions.bTestTMUAddress)
if(sOptions.bTestNoMem)
{
unsigned long long err=0;
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
}
logI("### address & control lines test - cumulated\n");
logI("### data test - no mem\n");
clearScreen(sstregs,0x00000000,256,256);
clock_t test_begin = clock();
do
{
err = RenderTestAddress(&devInfo,
err = test_TMU_datalines_NoMem( &devInfo,
sst,
sstregs,
tmu ,
ar_dFaultScores);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while(!err &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< _DEF_TEST_TIME_PER_MB_S));
logI("\n");
if(err)
{
logW("error detected on TMUs tex lines (no-mem test) !\n");
logW("skiping next tests.\n\n");
continue;
}
}
logI("\n");
ISET(sstregs->lfbMode,
SST_LFB_RGBALANES_ARGB
| SST_LFB_READFRONTBUFFER);
if(sOptions.bTestTMUControl && (devInfo.tmuMemSize[tmu]>0))
{
unsigned long long err=0;
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
}
logI("### control lines test - simple\n");
clearScreen(sstregs,0x00000000,256,256);
clock_t test_begin = clock();
int i=0;
do
{
err = TestControl(&devInfo,
sst,
sstregs,
tmu,
devInfo.tmuMemSize[tmu],
ar_dFaultScores);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
if(err || (((i++)%1000)==0))
{
logI( err ? "E" : ".");
fflush(stdout);
}
}
while(!err
&& (((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< _DEF_TEST_TIME_PER_MB_S));
logI("\n");
if(err)
{
logW("error detected on control line !\n");
logW("skiping next tests.\n\n");
continue;
}
}
if(sOptions.bTestTMUAddress && (devInfo.tmuMemSize[tmu]>0))
{
unsigned long long err=0;
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
}
logI("### address lines test - cumulated\n");
clearScreen(sstregs,0x00000000,256,256);
clock_t test_begin = clock();
int i=0;
do
{
err = 0;
for( unsigned char stepMemSize=1;
(stepMemSize <= devInfo.tmuMemSize[tmu]) && !err;
stepMemSize++)
{
err = RenderTestAddress(&devInfo,
sst,
sstregs,
tmu,
stepMemSize,
ar_dFaultScores);
ullNbErrorAll += err;
if(err || (((i++)%28)==0))
{
logI( err ? "E" : ".");
fflush(stdout);
}
}
}
while(!err
&& (((double)(clock() - test_begin)/CLOCKS_PER_SEC)
@@ -394,12 +562,15 @@ int main(int argc, char **argv)
}
}
if(sOptions.bTestTMUData)
if(sOptions.bTestTMUData && (devInfo.tmuMemSize[tmu]>0))
{
unsigned long long err=0;
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
}
logI("### data test - single bit move\n");
clearScreen(sstregs,0x00000000,256,256);
@@ -429,9 +600,12 @@ int main(int argc, char **argv)
logW("skiping next tests.\n\n");
continue;
}
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
}
logI("### data test - random patterns\n");
clearScreen(sstregs,0x00000000,256,256);
@@ -463,12 +637,15 @@ int main(int argc, char **argv)
}
}
if(sOptions.bTestTMUDataHuge)
if(sOptions.bTestTMUDataHuge && (devInfo.tmuMemSize[tmu]>0))
{
unsigned long long err=0;
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo,sst,sstregs,tmu,0x000000);
}
logI("### data test - huge data set\n");
clearScreen(sstregs,0x00000000,256,256);
@@ -500,7 +677,7 @@ int main(int argc, char **argv)
}
logI("\n");
}
sst1InitShutdown(sst);
sst = NULL;
}