274 lines
7.7 KiB
C
274 lines
7.7 KiB
C
/* 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 <stdio.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
#include <cvg.h>
|
|
#include <fxpci.h>
|
|
#include <sst1init.h>
|
|
#include <3dfx.h>
|
|
#include <glide.h>
|
|
|
|
#include "FaultSources.h"
|
|
#include "Utils.h"
|
|
#include "Draw.h"
|
|
|
|
#include "Test_Data_Huge.h"
|
|
|
|
#define _DEF_NB_PIXEL_ROW 256
|
|
#define _DEF_NB_PIXEL_COL 256
|
|
|
|
//#define _PROFILING
|
|
|
|
static unsigned long long
|
|
RenderTest( sst1DeviceInfoStruct* devInfo,
|
|
FxU32* sst,
|
|
SstRegs *sstregs,
|
|
const char ucNumTMU,
|
|
const FxU32 mem)
|
|
{
|
|
unsigned long NbErr = 0;
|
|
#ifdef _PROFILING
|
|
clock_t begin = clock();
|
|
#endif
|
|
ISET(sstregs->texBaseAddr, (mem>>3)); /* set to mem addr */
|
|
|
|
static unsigned short
|
|
ar_u16Pixels[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL];
|
|
static unsigned long
|
|
ar_u16PixelsRaw[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL/2];
|
|
static unsigned short
|
|
ar_u16PixelsReRead[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL];
|
|
|
|
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)
|
|
{
|
|
const unsigned long 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;
|
|
}
|
|
}
|
|
|
|
#ifdef _PROFILING
|
|
clock_t after_create = clock();
|
|
#endif
|
|
|
|
volatile FxU32 *texRowAddr
|
|
= (ucNumTMU<<(21-2)) + (((FxU32)0/*LOD0*/)<<(17-2))
|
|
+ (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
|
|
}
|
|
|
|
#ifdef _PROFILING
|
|
clock_t after_write = clock();
|
|
#define NB_CHECK_LOOP 3
|
|
clock_t before_draw[NB_CHECK_LOOP];
|
|
clock_t after_draw[NB_CHECK_LOOP];
|
|
clock_t after_read[NB_CHECK_LOOP];
|
|
clock_t after_check[NB_CHECK_LOOP];
|
|
#endif
|
|
|
|
for(unsigned int i = 0; i<NB_CHECK_LOOP; i++)
|
|
{
|
|
//printf("draw/checking\n");
|
|
#ifdef _PROFILING
|
|
before_draw[i] = clock();
|
|
#endif
|
|
|
|
drawTriangle(sstregs, 0, 0, 512); /* draw a 252x512 triangle */
|
|
|
|
#ifdef _PROFILING
|
|
after_draw[i] = clock();
|
|
#endif
|
|
/*
|
|
printf("rdy.\n");
|
|
GrLfbInfo_t info;
|
|
if(grLfbLock( GR_LFB_READ_ONLY,
|
|
GR_BUFFER_BACKBUFFER,
|
|
GR_LFBWRITEMODE_ANY,
|
|
GR_ORIGIN_UPPER_LEFT,
|
|
FXFALSE,
|
|
&info)
|
|
)
|
|
{
|
|
printf("got LFB access.\n");
|
|
FxU32 *rptr;
|
|
rptr = info.lfbPtr;
|
|
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+=8)
|
|
{
|
|
ar_u16PixelsReRead[iter_row][iter_col] = *rptr >> 16;
|
|
ar_u16PixelsReRead[iter_row][iter_col+1] = *rptr & 0xFFFF;
|
|
rptr+=1;
|
|
}
|
|
rptr+=info.strideInBytes>>2;
|
|
}
|
|
grLfbUnlock(GR_LFB_READ_ONLY,GR_BUFFER_FRONTBUFFER);
|
|
}
|
|
else
|
|
{
|
|
printf("NOT LFB access.\n");
|
|
}
|
|
*/
|
|
volatile FxU32* pLFB = sst + (SST_LFB_ADDR>>2);
|
|
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 FxU32 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) ;
|
|
|
|
}
|
|
#ifdef _PROFILING
|
|
after_read[i] = clock();
|
|
#endif
|
|
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]);*/
|
|
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]);*/
|
|
NbErr++;
|
|
}
|
|
}
|
|
}
|
|
#ifdef _PROFILING
|
|
after_check[i] = clock();
|
|
#endif
|
|
}
|
|
#ifdef _PROFILING
|
|
clock_t end = clock();
|
|
printf("time to create: %f\n",(double)(after_create-begin)/CLOCKS_PER_SEC);
|
|
printf("time to write: %f\n",(double)(after_write-after_create)/CLOCKS_PER_SEC);
|
|
for(unsigned int i = 0; i<NB_CHECK_LOOP; i++)
|
|
{
|
|
printf("time to draw [%d]: %f\n",i,(double)(after_draw[i]-before_draw[i])/CLOCKS_PER_SEC);
|
|
printf("time to read [%d]: %f\n",i,(double)(after_read[i]-after_draw[i])/CLOCKS_PER_SEC);
|
|
printf("time to check [%d]: %f\n",i,(double)(after_check[i]-after_read[i])/CLOCKS_PER_SEC);
|
|
}
|
|
printf("overall: %f\n",(double)(end-begin)/CLOCKS_PER_SEC);
|
|
#endif
|
|
|
|
return NbErr;
|
|
}
|
|
|
|
unsigned long long
|
|
test_TMU_datalines_Huge( sst1DeviceInfoStruct* devInfo,
|
|
FxU32* sst,
|
|
SstRegs *sstregs,
|
|
const unsigned char ucNumTMU,
|
|
const unsigned char RamSizeMB)
|
|
{
|
|
typedef struct _def_sMemBlock{
|
|
unsigned long ulAddStart;
|
|
unsigned long ulAddEnd;
|
|
unsigned long ulAddLength;
|
|
}def_sMemBlock;
|
|
|
|
const def_sMemBlock ar_memBlocks[] = {
|
|
{ .ulAddStart = 0x000000,
|
|
.ulAddLength = 0x100000
|
|
},
|
|
{ .ulAddStart = 0x100000,
|
|
.ulAddLength = 0x100000
|
|
},
|
|
{ .ulAddStart = 0x200000,
|
|
.ulAddLength = 0x100000
|
|
},
|
|
{ .ulAddStart = 0x300000,
|
|
.ulAddLength = 0x100000
|
|
},
|
|
};
|
|
|
|
unsigned long long ullNbErrorAll = 0;
|
|
|
|
devInfo->tmuInit0[(int)ucNumTMU] = SST_TREXINIT0_DEFAULT ;
|
|
|
|
sst1InitIdle(sst);
|
|
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);
|
|
|
|
for( int iMemBlock = 0;
|
|
iMemBlock <= sizeof(ar_memBlocks)/sizeof(def_sMemBlock);
|
|
iMemBlock++)
|
|
{
|
|
const def_sMemBlock* pMemBlk = &ar_memBlocks[iMemBlock];
|
|
if(RamSizeMB<4 && pMemBlk->ulAddStart >= 0x300000) continue;
|
|
if(RamSizeMB<3 && pMemBlk->ulAddStart >= 0x200000) continue;
|
|
if(RamSizeMB<2 && pMemBlk->ulAddStart >= 0x100000) continue;
|
|
//printf("RamSizeMB= %d, ulAddStart=%08x\n", RamSizeMB,pMemBlk->ulAddStart);
|
|
|
|
for( FxU32 addrTest = pMemBlk->ulAddStart ;
|
|
addrTest < (pMemBlk->ulAddStart + pMemBlk->ulAddLength);
|
|
addrTest += 65536) //256x256x2 (16bit pixels texture)
|
|
{
|
|
//printf("Testing memory block 0x%08x ...\n", addrTest);
|
|
ullNbErrorAll += RenderTest( devInfo,
|
|
sst,
|
|
sstregs,
|
|
ucNumTMU,
|
|
addrTest);
|
|
}
|
|
}
|
|
|
|
/* reset the Init0 register back to its previous value */
|
|
sst1InitIdle(sst);
|
|
ISET(SST_TREX(sst,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
|
|
sst1InitIdle(sst);
|
|
|
|
return ullNbErrorAll;
|
|
}
|