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

integration on real hardware

Browse Source
This commit is contained in:
ChaCha
2026-03-09 01:10:56 +01:00
parent c54b332e8d
commit cde38d3f75
14 changed files with 1771 additions and 1109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

430
Test_Data_Huge.c
View File

@@ -14,8 +14,9 @@
* 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>
#define _BSD_SOURCE 1
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
@@ -38,31 +39,35 @@
//#define _PROFILING
#define _DEF_PREHEAT_TIME_S 10
#define _DEF_PREHEAT_TIME_S 5
static void
HeatMemAndTMU( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
const char ucNumTMU,
const FxU32 mem)
FxU32* sst,
SstRegs *sstregs,
const char ucNumTMU,
const FxU32 mem)
{
ISET(sstregs->texBaseAddr, (mem>>3)); /* set to mem addr */
/* set base mem @ */
ISET(sstregs->texBaseAddr, (mem>>3));
volatile FxU32 *texRowAddr
= (ucNumTMU<<(21-2)) + (((FxU32)0/*LOD0*/)<<(17-2))
= (ucNumTMU<<(21-2))
+ (((FxU32)0)<<(17-2)) /*LOD0*/
+ (FxU32 *)SST_TEX_ADDRESS(sst);
for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
{
for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
{
ISET(texRowAddr[iter_col/2], get_notnull_random_balanced_mByte());
ISET(texRowAddr[iter_col/2], 0x55AA);
}
texRowAddr += (1<<(9-2)); //jump to next line
/* move to next line */
texRowAddr += (1<<(9-2));
}
clock_t begin = clock();
//printf("PREHEATING TMU/RAM\n");
do
{
if(((sst1InitReturnStatus(sst) & SST_FIFOLEVEL)) >= 0x20)
@@ -72,27 +77,215 @@ HeatMemAndTMU( sst1DeviceInfoStruct* devInfo,
}
}
while(((double)(clock() - begin)/CLOCKS_PER_SEC) < _DEF_PREHEAT_TIME_S );
//printf("PREHEATING Done\n");
sst1InitIdle(sst);
}
typedef struct _def_sFaultSheet{
unsigned char ucNumTMU;
unsigned char bEvenRow;
def_eFaultSource Ux_MEMChip_MainMSB;
def_eFaultSource Ux_MEMChip_MainLSB;
def_eFaultSource Ux_MEMChip_AltMSB;
def_eFaultSource Ux_MEMChip_AltLSB;
def_eFaultSource Ux_MEMChip_CAS02;
def_eFaultSource Ux_MEMChip_CAS13;
def_eFaultSource Ux_MEMChip_RAS0;
def_eFaultSource Ux_MEMChip_RAS1;
def_eFaultSource Ux_MEMChip_WE;
def_eFaultSource Ux_TMU;
}def_sFaultSheet;
static const def_sFaultSheet sFaultSheet[MAX_TMU][2] =
{
{ /*TMU0*/
{ /*ODD row*/
.ucNumTMU = 0,
.bEvenRow = 0,
.Ux_MEMChip_MainMSB = U14,
.Ux_MEMChip_MainLSB = U12,
.Ux_MEMChip_AltMSB = U23,
.Ux_MEMChip_AltLSB = U24,
.Ux_MEMChip_CAS02 = U9_TMU0_TEX_CAS0,
.Ux_MEMChip_CAS13 = U9_TMU0_TEX_CAS1,
.Ux_MEMChip_RAS0 = U9_TMU0_TEX_RAS0,
.Ux_MEMChip_RAS1 = U9_TMU0_TEX_RAS1,
.Ux_MEMChip_WE = U9_TMU0_TEX_WE,
.Ux_TMU = U9_TMU0,
},
{ /*EVEN row*/
.ucNumTMU = 0,
.bEvenRow = 1,
.Ux_MEMChip_MainMSB = U18,
.Ux_MEMChip_MainLSB = U17,
.Ux_MEMChip_AltMSB = U25,
.Ux_MEMChip_AltLSB = U26,
.Ux_MEMChip_CAS02 = U9_TMU0_TEX_CAS2,
.Ux_MEMChip_CAS13 = U9_TMU0_TEX_CAS3,
.Ux_MEMChip_RAS0 = U9_TMU0_TEX_RAS0,
.Ux_MEMChip_RAS1 = U9_TMU0_TEX_RAS1,
.Ux_MEMChip_WE = U9_TMU0_TEX_WE,
.Ux_TMU = U9_TMU0,
},
},
{ /*TMU1*/
{ /*ODD row*/
.ucNumTMU = 1,
.bEvenRow = 0,
.Ux_MEMChip_MainMSB = U13,
.Ux_MEMChip_MainLSB = U11,
.Ux_MEMChip_AltMSB = U27,
.Ux_MEMChip_AltLSB = U28,
.Ux_MEMChip_CAS02 = U8_TMU1_TEX_CAS0,
.Ux_MEMChip_CAS13 = U8_TMU1_TEX_CAS1,
.Ux_MEMChip_RAS0 = U8_TMU1_TEX_RAS0,
.Ux_MEMChip_RAS1 = U8_TMU1_TEX_RAS1,
.Ux_MEMChip_WE = U8_TMU1_TEX_WE,
.Ux_TMU = U8_TMU1,
},
{ /*EVEN row*/
.ucNumTMU = 2,
.bEvenRow = 1,
.Ux_MEMChip_MainMSB = U16,
.Ux_MEMChip_MainLSB = U15,
.Ux_MEMChip_AltMSB = U29,
.Ux_MEMChip_AltLSB = U30,
.Ux_MEMChip_CAS02 = U8_TMU1_TEX_CAS2,
.Ux_MEMChip_CAS13 = U8_TMU1_TEX_CAS3,
.Ux_MEMChip_RAS0 = U8_TMU1_TEX_RAS0,
.Ux_MEMChip_RAS1 = U8_TMU1_TEX_RAS1,
.Ux_MEMChip_WE = U8_TMU1_TEX_WE,
.Ux_TMU = U8_TMU1,
},
}
};
static void
AssignFault(const def_sFaultSheet* 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 relbitIdxQuartet= bitIdx%4;
const unsigned char relbitIdxQuartet = _relbitIdxQuartet;
//const unsigned char relbitIdx = bitIdx%8;
const unsigned char relbitIdx = _relbitIdx;
//const unsigned char relbitIdxWord = bitIdx%16;
const unsigned char relbitIdxWord = _relbitIdxWord;
static unsigned char nbErrLWord = 0;
static unsigned char nbErrWord = 0;
if(bitIdx==0)
nbErrLWord = 1;
else
nbErrLWord++;
if(relbitIdxWord==0)
nbErrWord = 1;
else
nbErrWord++;
/* Texture Source path, FBI to TMUx*/
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_TMU+81+relbitIdxWord, 1.0/4); //Ux_TMUx_FT_DATA_x
/* Output path, TMU0 to FBI*/
FaultSource_addScore(pFaultSrcCtx, U9_TMU0+97+relbitIdxWord, 1.0/4); //U9_TMU0_TF_DATA_x
switch(WordIdx)
{
case 0:
case 2:
if(relbitIdx<=3)
FaultSource_addScore(pFaultSrcCtx, RA10_1+relbitIdxQuartet,1.0/8);
else
FaultSource_addScore(pFaultSrcCtx, RA11_1+relbitIdxQuartet,1.0/8);
break;
case 1:
case 3:
if(relbitIdx<=3)
FaultSource_addScore(pFaultSrcCtx, RA12_1+relbitIdxQuartet,1.0/8);
else
FaultSource_addScore(pFaultSrcCtx, RA13_1+relbitIdxQuartet,1.0/8);
break;
}
/* Transfert path, TMU1 to TMU0*/
if(psCurFaultSheet->ucNumTMU == 1)
{
/* TMU1 output */
FaultSource_addScore(pFaultSrcCtx, U8_TMU1+97+relbitIdxWord, 1.0/4); //U8_TMU1_TF_DATA_x
/* line adaptation resistors */
FaultSource_addScore(pFaultSrcCtx, TT_TDATA_R131+relbitIdxWord, 1.0/4); //TT_TDATA_R131++
/* TMU0 input */
/* Note: U9_TMU0_TT_DATA_x is only tested when using TMU1 */
FaultSource_addScore(pFaultSrcCtx, U9_TMU0+65+relbitIdxWord, 1.0/4); //U9_TMU0_TT_DATA_x
}
if(WordIdx>=2)
{
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_MEMChip_MainLSB+1+relbitIdxWord, 1.0/2); //ok
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_MEMChip_AltLSB+1+relbitIdxWord, 1.0/4);
}
else
{
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_MEMChip_MainMSB+1+relbitIdxWord, 1.0/2); //ok
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_MEMChip_AltMSB+1+relbitIdxWord, 1.0/4);
}
if(!psCurFaultSheet->bEvenRow)
{
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_TMU+1+0+bitIdx, 1.0/2); //Ux_TMUx_TEXDATA_0_0
}
else
{
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_TMU+1+32+bitIdx, 1.0/2); //Ux_TMUx_TEXDATA_2_0
}
if((relbitIdxWord==15) && (nbErrWord>16))
{
switch(WordIdx)
{
case 0:
case 2:
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_MEMChip_CAS02, 1.0);
break;
case 1:
case 3:
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_MEMChip_CAS13, 1.0);
break;
}
FaultSource_addScore(pFaultSrcCtx,
mem < 0x200000 ?
psCurFaultSheet->Ux_MEMChip_RAS0
: psCurFaultSheet->Ux_MEMChip_RAS1,
1.0/2);
FaultSource_addScore(pFaultSrcCtx, psCurFaultSheet->Ux_MEMChip_WE, 1.0/2);
}
}
static unsigned long long
RenderTest( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
const char ucNumTMU,
const FxU32 mem)
const FxU32 mem,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
{
unsigned long NbErr = 0;
unsigned long long NbErr = 0;
#ifdef _PROFILING
clock_t begin = clock();
#endif
ISET(sstregs->texBaseAddr, (mem>>3)); /* set to mem addr */
/* set base mem @ */
ISET(sstregs->texBaseAddr, (mem>>3));
static uint16_t
ar_u16Pixels[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL];
static uint32_t
ar_u16PixelsRaw[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL/2];
static uint16_t
ar_u16PixelsReRead[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL];
@@ -101,7 +294,6 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
{
const uint32_t NewData = get_notnull_random_balanced_mByte();
ar_u16PixelsRaw[iter_row][iter_col/2] = NewData;
ar_u16Pixels[iter_row][iter_col] = NewData >>16;
ar_u16Pixels[iter_row][iter_col+1] = NewData & 0xFFFF;
}
@@ -112,17 +304,17 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
#endif
volatile FxU32 *texRowAddr
= (ucNumTMU<<(21-2)) + (((FxU32)0/*LOD0*/)<<(17-2))
= (ucNumTMU<<(21-2))
+ (((FxU32)0)<<(17-2)) /*LOD0*/
+ (FxU32 *)SST_TEX_ADDRESS(sst);
for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
{
for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL/2; iter_col++)
{
//printf("writing %d\n",ar_u16PixelsRaw[iter_row][iter_col]);
ISET(texRowAddr[iter_col], ar_u16PixelsRaw[iter_row][iter_col]);
}
texRowAddr += (1<<(9-2)); //jump to next line
mmio_fastwrite32( texRowAddr,
(uint32_t*)ar_u16Pixels[iter_row],
_DEF_NB_PIXEL_COL/2);
/* move to next line */
texRowAddr += (1<<(9-2));
}
#ifdef _PROFILING
@@ -133,12 +325,14 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
clock_t after_check[_NB_CHECK_LOOP];
#endif
clearScreen(sstregs,0x00000000,256,256);
for(unsigned int i = 0; i<_NB_CHECK_LOOP; i++)
{
//printf("draw/checking\n");
#ifdef _PROFILING
before_draw[i] = clock();
#endif
/* draw a 256x256 square */
drawSquare(sstregs, 0, 0, 256);
sst1InitIdle(sst);
@@ -147,47 +341,143 @@ RenderTest( sst1DeviceInfoStruct* devInfo,
after_draw[i] = clock();
#endif
volatile FxU32* pLFB = sst + (SST_LFB_ADDR>>2);
for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; ++iter_row)
{
//printf("reading row %d\n",iter_row);
for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
{
const uint32_t u32Data = *pLFB++;
ar_u16PixelsReRead[iter_row][iter_col] = u32Data >> 16;
ar_u16PixelsReRead[iter_row][iter_col+1] = u32Data & 0xFFFF;
//printf("read: %d\n",u32Data);
}
pLFB += ((2048)>>2) - ((_DEF_NB_PIXEL_COL*2) >>2) ;
mmio_fastread32((uint32_t*)&ar_u16PixelsReRead[iter_row],
pLFB,
_DEF_NB_PIXEL_COL/2);
//printf("copy done\n");
pLFB += ((2048)>>2) ;
}
#ifdef _PROFILING
after_read[i] = clock();
#endif
for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
//logI("Pre-Analysing...\n");
static uint32_t
ar_u32ErrorMark_Lx[_DEF_NB_PIXEL_ROW*_DEF_NB_PIXEL_COL/2];
for(unsigned int iter = 0; iter < _DEF_NB_PIXEL_ROW*_DEF_NB_PIXEL_COL/2; iter+=2)
{
ar_u32ErrorMark_Lx[iter]
= (*((uint32_t*)ar_u16PixelsReRead+iter))
^ (*((uint32_t*)ar_u16Pixels+iter));
ar_u32ErrorMark_Lx[iter+1]
= (*((uint32_t*)ar_u16PixelsReRead+iter+1))
^ (*((uint32_t*)ar_u16Pixels+iter+1));
}
//logI("Analysing...\n");
for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; ++iter_row)
{
//printf("checking row %d\n",iter_row);
for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
{
if(ar_u16PixelsReRead[iter_row][iter_col] != ar_u16Pixels[iter_row][iter_col])
{/*
printf("Error pix1 on row %d, col %d: expected %04x, got %04x\n",
iter_row, iter_col,
ar_u16Pixels[iter_row][iter_col],
ar_u16PixelsReRead[iter_row][iter_col]);*/
//printf("walk\n");
const uint32_t ErrorMark_Lx = ar_u32ErrorMark_Lx[(iter_row*_DEF_NB_PIXEL_COL+iter_col)/2];
if(!ErrorMark_Lx) continue;
const uint16_t ErrorMark_Lx_n1 = ErrorMark_Lx & 0xFFFF;
const uint16_t ErrorMark_Lx_n2 = ErrorMark_Lx >> 16;
const def_sFaultSheet* psCurFaultSheet = &sFaultSheet[(int)ucNumTMU][iter_row%2];
//unsigned char nbBitError = 0;
if(ErrorMark_Lx & 0x000000FFu)
{
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 & 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 & 0x0000FF00u)
{
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 & 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 & 0x00FF0000u)
{
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 & 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 & 0xFF000000u)
{
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 & 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_n1)
{
if(sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
{
printf("Error pix1 on row %d, col %d: expected %04x, got %04x\n",
iter_row, iter_col,
ar_u16Pixels[iter_row][iter_col],
ar_u16PixelsReRead[iter_row][iter_col]);
}
NbErr++;
}
if(ar_u16PixelsReRead[iter_row][iter_col+1] != ar_u16Pixels[iter_row][iter_col+1])
{/*
printf("Error pix2 on row %d, col %d: expected %04x, got %04x\n",
iter_row, iter_col,
ar_u16Pixels[iter_row][iter_col+1],
ar_u16PixelsReRead[iter_row][iter_col+1]);*/
else
{
if(sOptions.eLogLevel >= E_LOGLEVEL__TRACE)
{
printf("Ok pix1 on row %d, col %d: value %04x\n",
iter_row, iter_col,
ar_u16Pixels[iter_row][iter_col]);
}
}
if(ErrorMark_Lx_n2)
{
if(sOptions.eLogLevel >= E_LOGLEVEL__DEBUG)
{
printf("Error pix2 on row %d, col %d: expected %04x, got %04x\n",
iter_row, iter_col+1,
ar_u16Pixels[iter_row][iter_col+1],
ar_u16PixelsReRead[iter_row][iter_col+1]);
}
NbErr++;
}
else
{
if(sOptions.eLogLevel >= E_LOGLEVEL__TRACE)
{
printf("Ok pix2 on row %d, col %d: value %04x\n",
iter_row, iter_col+1,
ar_u16Pixels[iter_row][iter_col+1]);
}
}
}
}
//logI("Analysing Done\n");
#ifdef _PROFILING
after_check[i] = clock();
#endif
@@ -213,7 +503,8 @@ test_TMU_datalines_Huge( sst1DeviceInfoStruct* devInfo,
FxU32* sst,
SstRegs *sstregs,
const unsigned char ucNumTMU,
const unsigned char RamSizeMB)
const unsigned char RamSizeMB,
def_sFaultSourceScoreRec* const pFaultSrcCtx)
{
typedef struct _def_sMemBlock{
uint32_t ulAddStart;
@@ -237,19 +528,19 @@ test_TMU_datalines_Huge( sst1DeviceInfoStruct* devInfo,
};
unsigned long long ullNbErrorAll = 0;
devInfo->tmuInit0[(int)ucNumTMU] = SST_TREXINIT0_DEFAULT ;
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
/* set downstream TMUs to passthrough */
for (int i=0; i<ucNumTMU; i++)
ISET(SST_TREX(sstregs,i)->textureMode, SST_TC_PASS | SST_TCA_PASS);
for( int iMemBlock = 0;
iMemBlock <= sizeof(ar_memBlocks)/sizeof(def_sMemBlock);
iMemBlock < sizeof(ar_memBlocks)/sizeof(def_sMemBlock);
iMemBlock++)
{
const def_sMemBlock* pMemBlk = &ar_memBlocks[iMemBlock];
@@ -258,21 +549,40 @@ test_TMU_datalines_Huge( sst1DeviceInfoStruct* devInfo,
if(RamSizeMB<2 && pMemBlk->ulAddStart >= 0x100000) continue;
//printf("RamSizeMB= %d, ulAddStart=%08x\n", RamSizeMB,pMemBlk->ulAddStart);
putchar('-');
fflush(stdout);
//HeatMemAndTMU(devInfo,sst,sstregs,ucNumTMU,pMemBlk->ulAddStart);
putchar('-');
fflush(stdout);
for( FxU32 addrTest = pMemBlk->ulAddStart ;
addrTest < (pMemBlk->ulAddStart + pMemBlk->ulAddLength);
addrTest += 65536) //256x256x2 (16bit pixels texture)
addrTest += 131072) /* 256x256x2 (16bit pixels texture) */
{
//printf("Testing memory block 0x%08x ...\n", addrTest);
ullNbErrorAll += RenderTest( devInfo,
const unsigned long long
ullNbError = RenderTest( devInfo,
sst,
sstregs,
ucNumTMU,
addrTest);
addrTest,
pFaultSrcCtx);
ullNbErrorAll += ullNbError;
if(ullNbError)
putchar('E');
else
putchar('-');
fflush(stdout);
}
}
clearScreen(sstregs,0x00000000,256,256);
/* reset the Init0 register back to its previous value */
sst1InitIdle(sst);
devInfo->tmuInit0[(int)ucNumTMU] = _trexInit0;
ISET(SST_TREX(sst,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
sst1InitIdle(sst);