chacha/V2TMUMemTester
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 3 Activity
Files
master
V2TMUMemTester/main.c

760 lines
20 KiB
C
Raw Permalink Blame History

/* 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 <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <getopt.h>
#include "cvg.h"
#include <glide.h>
#include "sst1init.h"
#include "fxpci.h"
#include "V2MemTest.h"
#include "FaultSources.h"
#include "Utils.h"
#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[] =
{
"no error.", // E_ERROR__NO_ERROR
"unknown error.", // E_ERROR__UNKNOWN_ERROR
"unknown argument found in command line.", // E_ERROR__UNKNOWN_ARGUMENT
"wrong argument value.", // E_ERROR__BAD_ARGUMENT_VALUE
"error initializing Voodoo² board.", // E_ERROR__SST1_INIT,
"error getting Voodoo² board informations.", // E_ERROR__SST1_GET_INFO,
"not enough FBI RAM to process TMU tests.", // E_ERROR__NOT_ENOUGH_FBI_RAM,
"TMU not found.", // E_ERROR__TMU_NOT_FOUND,
"no TMU selected.", // E_ERROR__NO_TMU_SELECTED,
"wrong number of TMU selected.", // E_ERROR__WRONG_TMU_SELECTED
};
const char szTitle[] =
"v2-tmu-memtester-%d.%d.%d - A CLI Tool to test & fix Voodoo² TMU System\n"
"Copyright (C) 2026 ChaCha\n";
const char szLicence[] =
"This program is free software : you can redistribute it and/or modify it under\n"
"the terms of the GNU General Public License as published by the Free Software\n"
"Foundation either version 3 of the License, or (at your option) any later version.\n"
"This program is distributed in the hope that it will be useful, but WITHOUT ANY\n"
"WARRANTY !\n";
const char szKool[] =
"Oh nooo.... Have fun fixing your Holy Voodoo² !\n"
"Note: Do not forget to sleep though :) !\n";
const char szKool2[] =
"Did it just worked ?!\n";
const char szHelp[] =
"Usage: ./v2-tmu-memtester [options]\n"
"\n"
"General options:\n"
" -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"
" -q, --quick Quicker test (no pre-heat).\n"
" -c, --continue Continue testing even when error found.\n"
" -f, --force Force test (not detected TMU / RAM).\n"
" --silent Silent mode (suppress normal output).\n"
"\n"
"Verbosity:\n"
" -v Increase log level by one step (repeatable).\n"
" Levels: 0=ERR, 1=WARN, 2=INFO, 3=DEBUG, 4=TRACE\n"
" Default: 2 (INFO). Example: -v -> DEBUG.\n"
"\n"
"Target selection:\n"
" --tmu0 Enable only tests for TMU0.\n"
" --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"
"\n"
"TMU RAM limit override:\n"
" --tmu0-ram <MB> Force TMU0 RAM size: -1=auto, 1..4=MB.\n"
" --tmu1-ram <MB> Force TMU1 RAM size: -1=auto, 1..4=MB.\n"
"\n"
"Examples:\n"
" ./v2-tmu-memtester --tmu0 --address -v\n"
" ./v2-tmu-memtester --tmu0-ram 2 --tmu1-ram -1 -n 10\n"
" ./v2-tmu-memtester --tmu1 --data-huge\n";
def_sOptions sOptions = {
.eLogLevel = E_LOGLEVEL__INFO,
.bSilent = false,
.lNumLoops = 1,
.bTestTMU0 = false,
.eTMU0RamLimit = E_TMU_RAMSIZE__AUTO,
.bTestTMU1 = false,
.eTMU1RamLimit = E_TMU_RAMSIZE__AUTO,
.bTestTMUAddress = false,
.bTestTMUControl = false,
.bTestTMUData = false,
.bTestTMUDataHuge = false,
.bTestNoMem = false,
.bQuick = false,
.bForce = false,
.bContinue = false,
};
static struct option long_args[] = {
/* {<NAME>, <HAS_ARG>, <FLAG>, <VAL> */
{"help", no_argument, NULL, 'h'},
{"num", required_argument, NULL, 'n'},
{"force", no_argument, NULL, 'f'},
{"continue", no_argument, NULL, 'c'},
{"silent", no_argument, &sOptions.bSilent, true},
{"quick", no_argument, NULL, 'q'},
{"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},
};
static def_sFaultSourceScoreRec
ar_dFaultScores_no_mem[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_control[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_address[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_data[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_data_random[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_data_huge[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec*
ar_dFaultScores_Set[6];
const unsigned int uNb_dFaultScores_Set =
sizeof(ar_dFaultScores_Set)/sizeof(def_sFaultSourceScoreRec*);
static def_sFaultSourceScoreRec
ar_dFaultScores_ALL[NB_FAULT_SOURCE];
static def_sFaultSourceScoreRec
ar_dFaultScores_sorted[NB_FAULT_SOURCE];
#define _DEF_TEST_TIME_PER_MB_S 5
int main(const int argc, char ** const argv)
{
int Status = 0;
unsigned long long ullNbErrorAll = 0;
const unsigned char boardNum = 0;
int option_index = 0;
int opt;
bool bQuit = false;
FxU32* sst = NULL;
ar_dFaultScores_Set[0] = ar_dFaultScores_no_mem;
ar_dFaultScores_Set[1] = ar_dFaultScores_control;
ar_dFaultScores_Set[2] = ar_dFaultScores_address;
ar_dFaultScores_Set[3] = ar_dFaultScores_data;
ar_dFaultScores_Set[4] = ar_dFaultScores_data_random;
ar_dFaultScores_Set[5] = ar_dFaultScores_data_huge;
while((opt=getopt_long(argc,argv,"chvfqn:",long_args,&option_index)) != -1)
{
switch(opt)
{
/* other long options ? */
case 0:
break;
/* Version */
case 2:
printf("%d.%d.%d", V2MEMTEST__VERSION__MAJOR,
V2MEMTEST__VERSION__MINOR,
V2MEMTEST__VERSION__PATCH);
bQuit = true;
break;
/* TMU0 long options */
case 3:
/* TMU1 long options */
case 1:
{
def_eTMURamLimit newRAMLimit;
switch(strtol(optarg, NULL, 10))
{
case -1: newRAMLimit = E_TMU_RAMSIZE__AUTO; break;
case 1: newRAMLimit = E_TMU_RAMSIZE__1MB; break;
case 2: newRAMLimit = E_TMU_RAMSIZE__2MB; break;
case 3: newRAMLimit = E_TMU_RAMSIZE__3MB; break;
case 4: newRAMLimit = E_TMU_RAMSIZE__4MB; break;
default:
Status = E_ERROR__BAD_ARGUMENT_VALUE;
ErrorCheck_gotoCleanUp();
break;
}
if(opt==3) sOptions.eTMU0RamLimit = newRAMLimit;
else sOptions.eTMU1RamLimit = newRAMLimit;
}
break;
case '?':
puts(szHelp);
Status = E_ERROR__UNKNOWN_ARGUMENT;
ErrorCheck_gotoCleanUp();
break;
case 'q':
sOptions.bQuick = true;
break;
case 'c':
sOptions.bContinue = true;
break;
case 'f':
sOptions.bForce = true;
break;
case 'h':
puts(szHelp);
bQuit = true;
break;
case 'n':
sOptions.lNumLoops = strtol(optarg, NULL, 10);
if( sOptions.lNumLoops < 0 )
{
Status = E_ERROR__BAD_ARGUMENT_VALUE;
ErrorCheck_gotoCleanUp();
}
break;
case 'v':
if(sOptions.eLogLevel < E_LOGLEVEL__TRACE)
sOptions.eLogLevel++;
break;
default:
Status = E_ERROR__UNKNOWN_ERROR;
ErrorCheck_gotoCleanUp();
break;
}
}
if(bQuit)
return 0;
if(!sOptions.bTestTMU0 && !sOptions.bTestTMU1)
{
sOptions.bTestTMU0 = true;
sOptions.bTestTMU1 = true;
}
if( !sOptions.bTestTMUAddress &&
!sOptions.bTestTMUData &&
!sOptions.bTestTMUDataHuge &&
!sOptions.bTestTMUControl&&
!sOptions.bTestNoMem)
{
sOptions.bTestTMUControl = true;
sOptions.bTestTMUAddress = true;
sOptions.bTestTMUData = true;
sOptions.bTestTMUDataHuge = true;
sOptions.bTestNoMem = true;
}
sst1DeviceInfoStruct devInfo;
memset(&devInfo,0,sizeof(sst1DeviceInfoStruct));
SstRegs *sstregs = NULL;
logI(szTitle, V2MEMTEST__VERSION__MAJOR,
V2MEMTEST__VERSION__MINOR,
V2MEMTEST__VERSION__PATCH);
logI("\n");
logI(szLicence);
logI("\n");
srandom(time(NULL));
FaultSource_reset(ar_dFaultScores_no_mem);
FaultSource_reset(ar_dFaultScores_control);
FaultSource_reset(ar_dFaultScores_address);
FaultSource_reset(ar_dFaultScores_data);
FaultSource_reset(ar_dFaultScores_data_random);
FaultSource_reset(ar_dFaultScores_data_huge);
FaultSource_reset(ar_dFaultScores_ALL);
FaultSource_reset(ar_dFaultScores_sorted);
for(long j=0; j < sOptions.lNumLoops; j++)
{
logI("# processing loop %ld of %ld\n",j+1,sOptions.lNumLoops);
if ((sst = sst1InitMapBoard(boardNum)) == NULL)
{
logE("no Voodoo boards found\n");
Status = E_ERROR__SST1_INIT;
ErrorCheck_gotoCleanUp();
}
sst1InitRegisters(sst);
sstregs = (SstRegs *) sst;
if (sst1InitGetDeviceInfo(sst, &devInfo) == FXFALSE)
{
logE("couldn't get info for Voodoo # %d\n", boardNum);
Status = E_ERROR__SST1_GET_INFO;
ErrorCheck_gotoCleanUp();
}
/* Enabling video output so the Board will
* be configured automatically (FIFO, GRXCLK...)*/
sst1InitVideo(sst,GR_RESOLUTION_800x600,GR_REFRESH_60Hz,0);
logI("FBI detected memory:\t%ld MB\n", (unsigned long)devInfo.fbiMemSize);
if(devInfo.fbiMemSize < 2)
{
logE("couldn't test Voodoo2 TMUs without minimum 2MB of FBI memory\n");
Status = E_ERROR__NOT_ENOUGH_FBI_RAM;
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__WRONG_TMU_SELECTED;
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]);
if((sOptions.eTMU0RamLimit >= 0) && (devInfo.numberTmus>=1))
devInfo.tmuMemSize[0] = sOptions.eTMU0RamLimit;
if((sOptions.eTMU1RamLimit >= 0) && (devInfo.numberTmus==2))
devInfo.tmuMemSize[1] = sOptions.eTMU1RamLimit;
for (int tmu = 0; tmu < devInfo.numberTmus; tmu++)
logI("TMU%d tested memory:\t%ld MB\n", tmu, (unsigned long)devInfo.tmuMemSize[tmu]);
putchar('\n');
if(sOptions.bTestTMU0 && devInfo.numberTmus<1)
{
logE("TMU0 not Found\n");
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");
if(sOptions.bForce)
{
logW("Forcing TMU1 test");
}
else
{
Status = E_ERROR__TMU_NOT_FOUND;
ErrorCheck_gotoCleanUp();
}
}
const bool bTestTMU0 = ( (devInfo.numberTmus > 0)
|| sOptions.bForce)
&& sOptions.bTestTMU0;
const bool bTestTMU1 = ( (devInfo.numberTmus > 1)
|| sOptions.bForce)
&& sOptions.bTestTMU1;
if(!bTestTMU0 && !bTestTMU1)
{
logE("no TMU selected.\n");
Status = E_ERROR__NO_TMU_SELECTED;
ErrorCheck_gotoCleanUp();
}
if(bTestTMU1 && !bTestTMU0)
{
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); // <-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++)
{
if((tmu == 0) && !bTestTMU0) continue;
if((tmu == 1) && !bTestTMU1) continue;
logI("## testing Board %d, TMU %d, %ldMB \n",
boardNum,tmu,(unsigned long)devInfo.tmuMemSize[tmu]);
if(sOptions.bTestNoMem)
{
unsigned long long err=0;
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
}
logI("### data test - no mem\n");
clearScreen(sstregs, 0x00000000, 256, 256);
clock_t test_begin = clock();
do
{
err = test_TMU_datalines_NoMem( &devInfo,
sst,
sstregs,
tmu ,
ar_dFaultScores_no_mem);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< _DEF_TEST_TIME_PER_MB_S));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_no_mem);
if(err)
{
logW("error detected on TMUs tex lines (no-mem test) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
logI("\n");
ISET(sstregs->lfbMode,
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_control);
ullNbErrorAll += err;
if(err || (((i++)%1000)==0))
{
logI( err ? "E" : ".");
fflush(stdout);
}
}
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< _DEF_TEST_TIME_PER_MB_S));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_control);
if(err)
{
logW("error detected on control line !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
if(sOptions.bTestTMUAddress && (devInfo.tmuMemSize[tmu]>0))
{
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_address);
ullNbErrorAll += err;
if(err || (((i++)%28)==0))
{
logI( err ? "E" : ".");
fflush(stdout);
}
}
}
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_address);
if(err)
{
logW("error detected on address line !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
if(sOptions.bTestTMUData && (devInfo.tmuMemSize[tmu]>0))
{
unsigned long long err=0;
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);
clock_t test_begin = clock();
do
{
err = test_TMU_datalines(&devInfo,
sst,
sstregs,
tmu ,
0, /* bit shift mode */
devInfo.tmuMemSize[tmu],
ar_dFaultScores_data);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_data);
if(err)
{
logW("error detected on data line (single bit move) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
if(!sOptions.bQuick)
{
logI("### pre-heating\n");
HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
}
logI("### data test - random patterns\n");
clearScreen(sstregs, 0x00000000, 256, 256);
test_begin = clock();
do
{
err = test_TMU_datalines(&devInfo,
sst,
sstregs,
tmu ,
1, /* random mode */
devInfo.tmuMemSize[tmu],
ar_dFaultScores_data_random);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_data_random);
if(err)
{
logW("error detected on data line (random patterns) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
if(sOptions.bTestTMUDataHuge && (devInfo.tmuMemSize[tmu]>0))
{
unsigned long long err=0;
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);
clock_t test_begin = clock();
do
{
err = test_TMU_datalines_Huge( &devInfo,
sst,
sstregs,
tmu ,
devInfo.tmuMemSize[tmu],
ar_dFaultScores_data_huge);
ullNbErrorAll += err;
logI( err ? "E" : ".");
fflush(stdout);
}
while( (!err || sOptions.bContinue) &&
(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
logI("\n");
FaultSource_nomalize(ar_dFaultScores_data_huge);
if(err)
{
logW("error detected on data line (huge data set) !\n");
if(!sOptions.bContinue)
{
logW("skiping next tests.\n\n");
continue;
}
}
}
logI("\n");
}
sst1InitShutdown(sst);
sst = NULL;
}
FaultSource_sum(ar_dFaultScores_Set,
uNb_dFaultScores_Set,
ar_dFaultScores_ALL);
FaultSource_getSorted(ar_dFaultScores_sorted,ar_dFaultScores_ALL);
FaultSource_nomalize(ar_dFaultScores_sorted);
FaultSource_divideAll(ar_dFaultScores_sorted,0.01);
FaultSource_display(ar_dFaultScores_sorted);
logI("test completed, ullNbErrorAll = %lld\n",ullNbErrorAll);
logI("\n");
if(ullNbErrorAll)
logI(szKool);
else
logI(szKool2);
logI("\n");
CleanUp:
if(sst)
sst1InitShutdown(sst);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink