Search
lxdream.org :: lxdream/test/testta.c
lxdream 0.9.1
released Jun 29
Download Now
filename test/testta.c
changeset 193:31151fcc3cb7
prev190:f7653df5e832
next212:8b77a7e6b6f0
author nkeynes
date Sat Aug 05 00:18:21 2006 +0000 (16 years ago)
permissions -rw-r--r--
last change Add error lines to tests with incomplete polys
Split clip tests to separate data file
Add tests for cmd bit 23 ("use list size field")
file annotate diff log raw
nkeynes@185
     1
/**
nkeynes@193
     2
 * $Id: testta.c,v 1.3 2006-08-04 01:38:30 nkeynes Exp $
nkeynes@185
     3
 * 
nkeynes@185
     4
 * Tile Accelerator test cases 
nkeynes@185
     5
 *
nkeynes@185
     6
 * Copyright (c) 2006 Nathan Keynes.
nkeynes@185
     7
 *
nkeynes@185
     8
 * This program is free software; you can redistribute it and/or modify
nkeynes@185
     9
 * it under the terms of the GNU General Public License as published by
nkeynes@185
    10
 * the Free Software Foundation; either version 2 of the License, or
nkeynes@185
    11
 * (at your option) any later version.
nkeynes@185
    12
 *
nkeynes@185
    13
 * This program is distributed in the hope that it will be useful,
nkeynes@185
    14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
nkeynes@185
    15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
nkeynes@185
    16
 * GNU General Public License for more details.
nkeynes@185
    17
 */
nkeynes@185
    18
nkeynes@185
    19
#include <stdio.h>
nkeynes@185
    20
#include "testdata.h"
nkeynes@185
    21
#include "pvr.h"
nkeynes@185
    22
#include "lib.h"
nkeynes@185
    23
#include "asic.h"
nkeynes@185
    24
nkeynes@185
    25
#define DMA_ALIGN(x)   ((void *)((((unsigned int)(x))+0x1F)&0xFFFFFFE0))
nkeynes@185
    26
nkeynes@185
    27
#define OBJ_START 0x00010000
nkeynes@190
    28
#define OBJ_LENGTH 0x00010000
nkeynes@185
    29
#define TILE_START 0x00060000
nkeynes@190
    30
#define TILE_LENGTH 0x00010000
nkeynes@190
    31
nkeynes@190
    32
#define MEM_FILL 0xFE
nkeynes@190
    33
nkeynes@190
    34
int ta_tile_sizes[4] = { 0, 32, 64, 128 };
nkeynes@190
    35
nkeynes@190
    36
#define TILE_SIZE(cfg, tile) ta_tile_sizes[((((cfg->ta_cfg) >> (4*tile))&0x03))]
nkeynes@190
    37
nkeynes@190
    38
struct ta_config default_ta_config = { 0x00111111, GRID_SIZE(640,480), OBJ_START,
nkeynes@190
    39
				       OBJ_START+OBJ_LENGTH, TILE_START+TILE_LENGTH,
nkeynes@190
    40
				       TILE_START, TILE_START+TILE_LENGTH };
nkeynes@190
    41
nkeynes@190
    42
nkeynes@190
    43
int tile_sizes[5];
nkeynes@190
    44
int tile_events[5] = { EVENT_PVR_OPAQUE_DONE, EVENT_PVR_OPAQUEMOD_DONE,
nkeynes@190
    45
		       EVENT_PVR_TRANS_DONE, EVENT_PVR_TRANSMOD_DONE,
nkeynes@190
    46
		       EVENT_PVR_PUNCHOUT_DONE };
nkeynes@190
    47
char *tile_names[5] = { "Opaque", "Opaque Mod", "Trans", "Trans Mod", "Punch Out" };
nkeynes@185
    48
nkeynes@185
    49
#define FLOAT(p) *((float *)(p))
nkeynes@185
    50
nkeynes@190
    51
void make_expected_buffer( test_data_block_t expected_block, char *expect, int length )
nkeynes@190
    52
{
nkeynes@190
    53
    memset( expect, MEM_FILL,length );
nkeynes@190
    54
    
nkeynes@190
    55
    if( expected_block != NULL ) {
nkeynes@190
    56
	if( expected_block->length > length ) {
nkeynes@190
    57
	    fprintf( stderr, "Test data error: expected tile length is %d, but tile size is only %d\n", expected_block->length, length );
nkeynes@190
    58
	    return;
nkeynes@190
    59
	}
nkeynes@190
    60
	memcpy( expect, expected_block->data, expected_block->length );
nkeynes@190
    61
	
nkeynes@190
    62
	if( expected_block->length <= length-4 ) {
nkeynes@190
    63
	    *((unsigned int *)&expect[expected_block->length]) = 0xF0000000;
nkeynes@190
    64
	}
nkeynes@190
    65
    }
nkeynes@190
    66
}
nkeynes@190
    67
nkeynes@190
    68
int tilematrix_block_compare( test_data_block_t expected_block, char *tile_ptrs[], int tile_type, int offset )
nkeynes@190
    69
{
nkeynes@190
    70
    int tile_size = tile_sizes[tile_type];
nkeynes@190
    71
    char expect[tile_size];
nkeynes@190
    72
nkeynes@190
    73
    make_expected_buffer(expected_block, expect, tile_size);
nkeynes@190
    74
    return memcmp( expect, tile_ptrs[tile_type]+(offset*tile_sizes[tile_type]), tile_size );
nkeynes@190
    75
}
nkeynes@190
    76
nkeynes@185
    77
int test_ta( test_data_t test_case )
nkeynes@185
    78
{
nkeynes@185
    79
    char buf[1024];
nkeynes@185
    80
    unsigned int *p = DMA_ALIGN(buf);
nkeynes@185
    81
    unsigned int *data = p;
nkeynes@190
    82
    int haveFailure = 0;
nkeynes@190
    83
    int checkedTile[5] = {0,0,0,0,0};
nkeynes@190
    84
    int i;
nkeynes@190
    85
    int hsegs,vsegs;
nkeynes@190
    86
    char *result = (char *)(PVR_VRAM_BASE+OBJ_START);
nkeynes@190
    87
    char *tilematrix = (char *)(PVR_VRAM_BASE+TILE_START+TILE_LENGTH);
nkeynes@190
    88
    char *tile_ptrs[5];
nkeynes@185
    89
nkeynes@185
    90
    asic_clear();
nkeynes@185
    91
nkeynes@190
    92
    memset( PVR_VRAM_BASE, MEM_FILL,  0x00090000 );
nkeynes@190
    93
    test_data_block_t config_data = get_test_data( test_case, "config" );
nkeynes@190
    94
    struct ta_config *config = &default_ta_config;
nkeynes@190
    95
    if( config_data != NULL ) {
nkeynes@190
    96
	if( config_data->length != sizeof(struct ta_config) ) {
nkeynes@190
    97
	    fprintf( stderr, "Invalid config data length %d - aborting test %s\n",
nkeynes@190
    98
		     config_data->length, test_case->test_name );
nkeynes@190
    99
	    return -1;
nkeynes@190
   100
	}
nkeynes@190
   101
	config = (struct ta_config *)config_data->data;
nkeynes@190
   102
    }
nkeynes@190
   103
    ta_init(config);
nkeynes@190
   104
    for( i=0; i<5; i++ ) {
nkeynes@190
   105
	tile_sizes[i] = TILE_SIZE(config,i);
nkeynes@190
   106
    }
nkeynes@190
   107
    hsegs = (config->grid_size & 0xFFFF)+1;
nkeynes@190
   108
    vsegs = (config->grid_size >> 16) + 1;
nkeynes@190
   109
    tile_ptrs[0] = tilematrix;
nkeynes@190
   110
    tile_ptrs[1] = tile_ptrs[0] + (hsegs*vsegs*tile_sizes[0]);
nkeynes@190
   111
    tile_ptrs[2] = tile_ptrs[1] + (hsegs*vsegs*tile_sizes[1]);
nkeynes@190
   112
    tile_ptrs[3] = tile_ptrs[2] + (hsegs*vsegs*tile_sizes[2]);
nkeynes@190
   113
    tile_ptrs[4] = tile_ptrs[3] + (hsegs*vsegs*tile_sizes[3]);
nkeynes@190
   114
nkeynes@185
   115
nkeynes@185
   116
    test_data_block_t input = get_test_data(test_case, "input");
nkeynes@185
   117
    test_data_block_t output = get_test_data(test_case, "output");
nkeynes@190
   118
    test_data_block_t error = get_test_data(test_case, "error");
nkeynes@185
   119
    if( input == NULL || output == NULL ) {
nkeynes@185
   120
	fprintf( stderr, "Skipping test case '%s': data incomplete\n", test_case->test_name );
nkeynes@185
   121
	return -1;
nkeynes@185
   122
    }
nkeynes@185
   123
nkeynes@185
   124
    if( pvr_dma_write( 0x10000000, input->data, input->length, 0 ) == -1 ) {
nkeynes@185
   125
	return -1;
nkeynes@185
   126
    }
nkeynes@190
   127
nkeynes@190
   128
    if( error != NULL ) {
nkeynes@190
   129
	for( i=0; i<error->length; i++ ) {
nkeynes@190
   130
	    if( asic_wait( error->data[i] ) == -1 ) {
nkeynes@190
   131
		fprintf( stderr, "Test %s: failed (Timeout waiting for error event %d)\n",
nkeynes@190
   132
			 test_case->test_name, error->data[i] );
nkeynes@190
   133
		asic_dump( stderr );
nkeynes@190
   134
		return -1;
nkeynes@190
   135
	    }
nkeynes@190
   136
	}
nkeynes@185
   137
    }
nkeynes@185
   138
nkeynes@190
   139
    for( i=0; i<MAX_DATA_BLOCKS; i++ ) {
nkeynes@190
   140
	test_data_block_t data = &test_case->item[i];
nkeynes@190
   141
	int tile, x, y, offset;
nkeynes@190
   142
	if( data->name != NULL ) {
nkeynes@190
   143
	    int result = sscanf( data->name, "tile %d %dx%d", &tile, &x, &y );
nkeynes@190
   144
	    if( result == 1 ) {
nkeynes@190
   145
		x = y = 0;
nkeynes@190
   146
	    } else if( result != 3 ) {
nkeynes@190
   147
		continue;
nkeynes@190
   148
	    }
nkeynes@190
   149
	    tile--;
nkeynes@190
   150
	    offset = x + (y * hsegs);
nkeynes@190
   151
nkeynes@190
   152
	    if( checkedTile[tile] == 0 ) {
nkeynes@190
   153
		if( asic_wait( tile_events[tile] ) == -1 ) {
nkeynes@190
   154
		    fprintf( stderr, "Test %s: failed (Timeout waiting for %s done event)\n", 
nkeynes@190
   155
			     test_case->test_name, tile_names[tile] );
nkeynes@190
   156
		    ta_dump_regs();
nkeynes@190
   157
		    asic_dump( stderr );
nkeynes@190
   158
		    haveFailure = 1;
nkeynes@190
   159
		}
nkeynes@190
   160
	    }
nkeynes@190
   161
nkeynes@190
   162
	    if( tilematrix_block_compare( data, tile_ptrs, tile, offset ) != 0 ) {
nkeynes@190
   163
		fprintf( stderr, "Test %s: Failed (%s matrix %dx%d). ", 
nkeynes@190
   164
			 test_case->test_name, tile_names[tile], x, y );
nkeynes@190
   165
		fwrite_diff32( stderr, data->data, data->length, 
nkeynes@190
   166
			       tile_ptrs[tile] + (tile_sizes[tile]*offset), tile_sizes[tile] );
nkeynes@190
   167
		haveFailure = 1;
nkeynes@190
   168
	    }
nkeynes@190
   169
	    checkedTile[tile] = 1;
nkeynes@190
   170
	}
nkeynes@190
   171
    }
nkeynes@190
   172
nkeynes@190
   173
    /* Overflow */
nkeynes@190
   174
    test_data_block_t plist = get_test_data(test_case, "plist" );
nkeynes@190
   175
    if( plist != NULL ) {
nkeynes@190
   176
	unsigned int plist_posn, plist_end;
nkeynes@190
   177
	if( config->ta_cfg & 0x00100000 ) { /* Descending */
nkeynes@193
   178
	    plist_posn = pvr_get_plist_posn(); //+ tile_sizes[0];
nkeynes@190
   179
	    plist_end = config->plist_start;
nkeynes@190
   180
	} else {
nkeynes@190
   181
	    plist_posn = config->plist_start;
nkeynes@193
   182
	    plist_end = pvr_get_plist_posn() + tile_sizes[0];
nkeynes@190
   183
	}
nkeynes@190
   184
	char *plist_data = (char *)(PVR_VRAM_BASE + plist_posn);
nkeynes@190
   185
	if( test_block_compare( plist, plist_data, plist_end-plist_posn ) != 0 ) {
nkeynes@190
   186
	    fprintf( stderr, "Test %s: Failed (Plist buffer)", test_case->test_name );
nkeynes@190
   187
	    fwrite_diff32( stderr, plist->data, plist->length, (char *)plist_data, 
nkeynes@190
   188
			   plist_end - plist_posn );
nkeynes@190
   189
	    haveFailure = 1;
nkeynes@190
   190
	}
nkeynes@193
   191
	char block[tile_sizes[0]];
nkeynes@193
   192
	memset( block, MEM_FILL, tile_sizes[0] );
nkeynes@193
   193
	if( memcmp( block, plist_data - tile_sizes[0], tile_sizes[0] ) != 0 ) {
nkeynes@193
   194
	    fprintf( stderr, "Test %s: Failed (Plist buffer)", test_case->test_name );
nkeynes@193
   195
	    fwrite_diff32( stderr, block, tile_sizes[0], plist_data - tile_sizes[0],
nkeynes@193
   196
			   tile_sizes[0]);
nkeynes@193
   197
	    haveFailure = 1;
nkeynes@193
   198
	}
nkeynes@190
   199
    }
nkeynes@190
   200
nkeynes@190
   201
    /* Vertex buffer */
nkeynes@185
   202
    int result_length = pvr_get_objbuf_size();
nkeynes@185
   203
    if( test_block_compare( output, result, result_length ) != 0 ) {
nkeynes@190
   204
	fprintf( stderr, "Test %s: Failed (Vertex buffer). ", test_case->test_name );
nkeynes@190
   205
	fwrite_diff32( stderr, output->data, output->length, result, result_length );
nkeynes@190
   206
	haveFailure = 1;
nkeynes@185
   207
    }
nkeynes@185
   208
    
nkeynes@190
   209
nkeynes@190
   210
    for( i=0; i<5; i++ ) {
nkeynes@190
   211
	if( checkedTile[i] == 0 ) {
nkeynes@190
   212
	    if( tilematrix_block_compare( NULL, tile_ptrs, i, 0 ) != 0 ) {
nkeynes@190
   213
		fprintf( stderr, "Test %s: Failed (%s matrix). ", test_case->test_name, tile_names[i] );
nkeynes@190
   214
                fprintf( stderr, "Expected empty buffer at %08X, but was =>\n", 
nkeynes@190
   215
			 (unsigned int)(tile_ptrs[i]) );
nkeynes@190
   216
		fwrite_dump( stderr, tile_ptrs[i], tile_sizes[i] );
nkeynes@190
   217
		//		fwrite_dump( stderr, tile_ptrs[i] - 128, 256 );
nkeynes@190
   218
			 
nkeynes@190
   219
	    }
nkeynes@190
   220
	}
nkeynes@190
   221
    }
nkeynes@193
   222
nkeynes@193
   223
    if( error == NULL ) {
nkeynes@193
   224
	if( asic_check(EVENT_TA_ERROR) || asic_check(EVENT_PVR_PRIM_ALLOC_FAIL) ||
nkeynes@193
   225
	    asic_check(EVENT_PVR_MATRIX_ALLOC_FAIL) || asic_check(EVENT_PVR_BAD_INPUT) ) {
nkeynes@193
   226
	    fprintf( stderr, "Test %s: Failed (unexpected error events)\n", test_case->test_name );
nkeynes@193
   227
	    asic_dump( stderr );
nkeynes@193
   228
	    haveFailure = 1;
nkeynes@193
   229
	}
nkeynes@193
   230
    }
nkeynes@193
   231
nkeynes@190
   232
    if( haveFailure )
nkeynes@190
   233
	return -1;
nkeynes@190
   234
nkeynes@190
   235
    fprintf( stdout, "Test %s: OK\n", test_case->test_name );
nkeynes@190
   236
    return 0;
nkeynes@185
   237
}
nkeynes@185
   238
nkeynes@185
   239
int main( int argc, char *argv[] ) 
nkeynes@185
   240
{
nkeynes@185
   241
    int test_cases = 0;
nkeynes@185
   242
    int test_failures = 0;
nkeynes@185
   243
    test_data_t test_data = load_test_dataset(stdin);
nkeynes@185
   244
    test_data_t test_case = test_data;
nkeynes@185
   245
nkeynes@185
   246
    asic_mask_all();
nkeynes@185
   247
    pvr_init();
nkeynes@185
   248
nkeynes@185
   249
    while( test_case != NULL ) {
nkeynes@185
   250
	test_cases++;
nkeynes@185
   251
	int result = test_ta(test_case);
nkeynes@185
   252
	if( result != 0 ) {
nkeynes@185
   253
	    test_failures++;
nkeynes@185
   254
	}
nkeynes@185
   255
	test_case = test_case->next;
nkeynes@185
   256
    }
nkeynes@185
   257
    free_test_dataset(test_data);
nkeynes@185
   258
    if( test_failures != 0 ) {
nkeynes@185
   259
	fprintf( stderr, "%d/%d test failures!\n", test_failures, test_cases );
nkeynes@185
   260
	return 1;
nkeynes@185
   261
    } else {
nkeynes@185
   262
	fprintf( stderr, "%d tests OK\n", test_cases );
nkeynes@185
   263
	return 0;
nkeynes@185
   264
    }
nkeynes@185
   265
}
.