/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1994, Silicon Graphics, Inc.               *
 *                                                                        *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright  law.  They  may not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *                                                                        *
 *************************************************************************/

/*---------------------------------------------------------------------*
        Copyright (C) 1998 Nintendo. (Originated by SGI)
        
        $RCSfile: main.c,v $
        $Revision: 1.1.1.1 $
        $Date: 2002/05/02 03:27:18 $
 *---------------------------------------------------------------------*/

/*
 * File:	main.c
 * Creator:	hsa@sgi.com
 * Create Date:	Fri Oct 14 11:54:35 PDT 1994
 *
 *
 * This application is a test-bed of single frame tests for RSP
 * verification. The idea is that each frame possibly uses a different
 * dataset (see static.c) to render a particular test.
 *
 * Since this 'application' is not an animation, it is a sequence
 * of single-frame tests, it is best to run it without double buffering (-s):
 *
 *		emulate -s -a "-o 2" rspverif rom
 *
 * Use the -a flag to emulate to pass arguments through to this app.
 *
 * NOTE:
 * This test-bed is composed of some shared code, and test-specific
 * code. To add or modify a test case, you should only touch the
 * test-specific code. Modifying shared code might break other tests.
 *
 *  FILES THAT ARE SHARED WITH OTHER TESTS: (don't modify)
 *
 *	main.c
 *	init.c
 *	dynamic.c
 *	zbuffer.c
 *	spec
 *
 *  FILES THAT ARE TEST-SPECIFIC: (may modify)
 *
 *	static.c		(holds static display list data for tests)
 *	rspverif.h		(exports info to main.c, etc.)
 * 	rspverif.c		(holds test frame procedures, etc.)
 *	<any related include files>	(textures, etc.)
 *	Makefile			(make test rules)
 *
 *
 * TO ADD A TEST CASE:
 * New test cases require that you add:
 *
 *	static.c	- add static display list for the test.
 *	rspverif.h	- extern the static display list
 *	rspverif.c	- add the procedure to be called to
 *			  perform the test case. (also put it
 *			  in the testCaseProc table)
 *			- put the static display list pointer
 *			  in the testList table.
 *
 * plus any new textures, include files, etc.
 *
 * All locations are marked with comments that say "ADD TEST CASE"
 * and give some hints what you need to do there.
 *
 * ADVANCED USAGE:
 * You could re-use test case procedures or data, as long as you
 * coordinate with all the tests that share it. It is a bad idea
 * to share data or procedures with a test that someone else may
 * go in and modify.
 *
 * If your test case needs a command line argument, that isn't handled
 * too cleanly. You would have to add it to main.c, and export the
 * global variables, etc. (messy) 
 *
 * This test suite favors single-frame tests. Animation support is clumsy.
 *
 * Fri Oct 14 11:18:33 PDT 1994
 *
 */

#include <ultra64.h>

#if defined( _HW_VERSION_1 )
#define PRINTF  rmonPrintf
#else
#define PRINTF  osSyncPrintf
#endif

#ifdef _EMULATOR
#   include <em.h> /* Only if using emulator */
#   include <verify.h>
#   undef PRINTF
#   define PRINTF emPrintf
#endif

#include <ramrom.h>

#include "rspverif.h"
#include "texture.h"

#ifndef _EMULATOR
#include "controller.h"
#endif

/*
 * Symbol genererated by "makerom" to indicate the end of the code segment
 * in virtual (and physical) memory
 */
extern char _codeSegmentStart[];
extern char _codeSegmentEnd[];
extern char _zbufferSegmentEnd[];
extern char _cfbSegmentEnd[];

/* these are fixed sizes: */
#define SP_UCODE_SIZE		4096
#define SP_UCODE_DATA_SIZE	2048

/*
 * Symbols generated by "makerom" to tell us where the static segment is
 * in ROM.
 */
extern char _staticSegmentRomStart[], _staticSegmentRomEnd[];
extern char _textureSegmentRomStart[], _textureSegmentRomEnd[];

/*
 * Stacks for the threads as well as message queues for synchronization
 */
u64	bootStack[STACKSIZE/8];

static int      uselines  = 0;
static int      useblack  = 0;

static void	idle(void *);
static void	mainproc(void *);

static OSThread	idleThread;
static u64	idleThreadStack[STACKSIZE/8];

static OSThread	mainThread;
static u64	mainThreadStack[STACKSIZE/8];

static OSThread	rmonThread;
static u64      rmonStack[RMON_STACKSIZE/8];

#define NUM_PI_MSGS     8

static OSMesg PiMessages[NUM_PI_MSGS];
static OSMesgQueue PiMessageQ;

OSMesgQueue	dmaMessageQ, rspMessageQ, rdpMessageQ, retraceMessageQ;
OSMesg		dmaMessageBuf, rspMessageBuf, rdpMessageBuf, retraceMessageBuf;
OSMesg		dummyMessage;
OSIoMesg	dmaIOMessageBuf;

/*
 * Dynamic segment in code space. Needs K0_TO_PHYS()...
 */
Dynamic dynamic;

    
/*
 * must be in BSS, not on the stack for this to work:
 */
OSTask		tlist;       /* globaltask lists */
Gfx		*glistp;	/* global for test case procs */
    
/*
 * global variables for arguments, to control test cases
 */
static int	keep_mem = 0;
static int	automated = 0;
static int	frame_count = 2;
static int	output_frame = 1;
static int	ani_frame = -1;
static int	ani_count = 0, ani_count_max = 0;
static char	*output_prefix = "InData/rspverif";
static int	rdp_DRAM_io = 0;
static int	rdp_regressionFlag = 0;
static int	rdp_mspanFlushFlag = 0;
static int	debugflag = 0;
static int      draw_buffer = 0;
static int      doyieldtest=0;
static void     *cfb_ptrs[2];
static u64	ramrombuf[RAMROM_MSG_SIZE/8];

int             controlFrame = 0;

typedef union {
    u32		word[2];
    u64		force_alignment;
} scratch_t;
scratch_t scratch_buff[1024], *scrp;

#define PI_BASE	((u32)(0xb0700000))
static u32	*piAddr = (u32 *)(PI_BASE);
u32		dummy_val;

/*
 * private routine used to parse args.
 */
static int
myatoi(char *str)
{
    int		log10[5], logn = 0, val = 0, i, pow10 = 1;

    if (str == NULL || *str == '\0')
	return(-1);
    
    while (*str != '\0') {
	if (!(*str == '0' ||
	      *str == '1' ||
	      *str == '2' ||
	      *str == '3' ||
	      *str == '4' ||
	      *str == '5' ||
	      *str == '6' ||
	      *str == '7' ||
	      *str == '8' ||
	      *str == '9')) {
	    logn = 0;
	    break;
	}

	log10[logn++] = *str - '0';
	str++;
    }
    
    if (logn == 0)
	return(-1);
    
    for (i=logn-1; i>= 0; i--) {
	val += log10[i] * pow10;
	pow10 *= 10;
    }
    return (val);
}

/*
 * private routine used to parse args.
 */
static void
parse_args(char *argstring)
{
    int		argc = 1, i;
    char	*arglist[32], **argv = arglist;	/* max 32 args */
    char	*c, *ptr;

    if (argstring == NULL || argstring[0] == '\0')
	return;

    /* re-organize argstring to be like main(argv,argc) */
    ptr = argstring;
    while (*ptr != '\0') {
	while (*ptr != '\0' && (*ptr == ' ')) {
	    *ptr = '\0';
	    ptr++;
	}
	if (*ptr != '\0')
	    arglist[argc++] = ptr;
	while (*ptr != '\0' && (*ptr != ' ')) {
	    ptr++;
	}
    }

    /* ADD TEST CASE:
     * might want to pick off special arguments here.
     */

    /* process the arguments: */
    while ((argc > 1) && (argv[1][0] == '-')) {
	switch(argv[1][1]) {

	  case 'a':
	    automated = 1;	/* exit after doing cases */
	    break;
	    
	  case 'd':
	    rdp_DRAM_io = 1;	/* route RSP output for RDP back to DRAM */
	    break;
	    
	  case 'f':
	    frame_count = myatoi(argv[2]); /* start frame */
	    if (frame_count < 0) {
		frame_count = 0;
		PRINTF("bad frame_count [-f]!\n");
	    }
	    argc--;
	    argv++;
	    break;

	  case 'g':
	    debugflag = 1;
	    break;

	  case 'F':
	    rdp_mspanFlushFlag = 1; /* flush mspan cache by enabling 1PRIM */
            break;
	    
	  case 'm':
	    keep_mem = 1;	/* keep DRAM memory image */
	    break;
	    
	  case 'n':
	    output_prefix = argv[2]; /* output name prefix */
	    argc--;
	    argv++;
	    break;

	  case 'o':
	    output_frame = myatoi(argv[2]); /* frame to output */
	    if (output_frame < 0) {
		PRINTF("bad output_frame [-o]!\n");
	    }
	    argc--;
	    argv++;
	    break;

	  case 'r':
	    rdp_regressionFlag = 1; /* when set, shrink viewport for brevity */
	    break;
	    
	  case 's':
	    ani_frame = myatoi(argv[2]); /* animation frame */
	    if (ani_frame < 0) {
		PRINTF("bad frame_count [-s]!\n");
	    }
	    argc--;
	    argv++;
	    ani_count_max = myatoi(argv[2]); /* animation frame count */
	    if (ani_count_max < 0) {
		ani_count_max = 0;
		PRINTF("bad ani_count_max [-s]!\n");
	    }
	    argc--;
	    argv++;
	    break;
	    
#if 0
	  case 't':		/* "true color" ie 24 bit RGB */
	    cfb_size = G_IM_SIZ_32b;
	    break;
#endif

	case 'l':
	    uselines = 1;
	    break;
	    
	case 'b':
	    useblack = 1;
	    break;
	    
	case 'y':
	    doyieldtest = 1;
	    break;
	    
	  default:
	    PRINTF("option [%s] not recognized.\n", argv[1]);
	    break;
	}
	argc--;
	argv++;
    }
}

OSPiHandle	*handler;

boot(void *arg)
{
    int i, *pr;
    char *ap;
    u32 *argp;
    u32 argbuf[16];
    
    osInitialize();

    handler = osCartRomInit();

#ifndef _EMULATOR
   for (pr = (int *)0xb0700000; (u32)pr < 0xb0702000; pr++)
       osEPiWriteIo(handler, (u32)pr, 0x55555555);
#endif

    argp = (u32 *)RAMROM_APP_WRITE_ADDR;
    for (i=0; i<sizeof(argbuf)/4; i++, argp++) {
	osEPiReadIo(handler, (u32)argp, &argbuf[i]); /* Assume no DMA */
    }
    /* Parse the options */
    parse_args((char *)argbuf);

    osCreateThread(&idleThread, 1, idle, arg, idleThreadStack+STACKSIZE/8, 10);
    osStartThread(&idleThread);

    /* never reached */
}

static void
idle(void *arg)
{
    /* Initialize video */
    osCreateViManager(OS_PRIORITY_VIMGR);
    osViSetMode(&osViModeTable[OS_VI_NTSC_LAN1]);
    
    /*
     * Start PI Mgr for access to cartridge
     */
    osCreatePiManager((OSPri)OS_PRIORITY_PIMGR, &PiMessageQ, PiMessages, 
		      NUM_PI_MSGS);
    
    /*
     * Start RMON for debugging & data xfer (make sure to start 
     * PI Mgr first)
     */
    osCreateThread(&rmonThread, 0, rmonMain, (void *)0,
		   rmonStack+RMON_STACKSIZE/8, OS_PRIORITY_RMON);
    osStartThread(&rmonThread);
    
    /*
     * Create main thread
     */
    osCreateThread(&mainThread, 3, mainproc, arg,
		   mainThreadStack+STACKSIZE/8, 10);
    
    if (!debugflag)
	osStartThread(&mainThread);

    /*
     * Become the idle thread
     */
    osSetThreadPri( 0, 0 );
    for (;;);
}

static void
mainproc(void *arg)
{
    int		keep_going = 1, i, j;
    OSTask	*tlistp;
    Dynamic	*dynamicp;
    char	*staticSegment;
    char	*textureSegment;
    char	*textureSegmentEnd;
    int 	testListCount;
    int 	controllerSlot;
#ifdef _EMULATOR
    MouseState	ms;
    /* this structure must be aligned to 64-bit boundary: */
    VerifyInfo	*info = (VerifyInfo *)osPhysicalToVirtual(VERIFY_INFO_PHYSADDR);
#endif
    u32		dmemaddr, t1, t2, t3;
    u16		perspNorm;
    int		x, y, w, h;
    float	fix_float_bug;

    /* apps need to do this in order to init the R4300 floating point... */
    fix_float_bug = 1.0;


#ifdef _EMULATOR
    /*
     * This is how arguments are passed via emulator:
     *
     *		emulate -a "<app args>" rspverif rom
     */
    parse_args(arg);
#endif
    
    cfb_ptrs[0] = cfb_16_a;
    cfb_ptrs[1] = cfb_16_b;

    /*
     * Setup the message queues
     */
    osCreateMesgQueue(&dmaMessageQ, &dmaMessageBuf, 1);
    
    osCreateMesgQueue(&rspMessageQ, &rspMessageBuf, 1);
    osSetEventMesg(OS_EVENT_SP, &rspMessageQ, dummyMessage);
    
    osCreateMesgQueue(&rdpMessageQ, &rdpMessageBuf, 1);
    osSetEventMesg(OS_EVENT_DP, &rdpMessageQ, dummyMessage);
    
    osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
    osViSetEvent(&retraceMessageQ, dummyMessage, 1);
    
    /*
     * Stick the static segment right after the frame buffer
     */
    staticSegment = _cfbSegmentEnd+8;

    dmaIOMessageBuf.hdr.pri      = OS_MESG_PRI_NORMAL;
    dmaIOMessageBuf.hdr.retQueue = &dmaMessageQ;
    dmaIOMessageBuf.dramAddr     = staticSegment;
    dmaIOMessageBuf.devAddr      = (u32)_staticSegmentRomStart;
    dmaIOMessageBuf.size         = _staticSegmentRomEnd-_staticSegmentRomStart;

    osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);
    
    /*
     * Wait for DMA to finish
     */
    (void)osRecvMesg(&dmaMessageQ, &dummyMessage, OS_MESG_BLOCK);

    /*
     * Initialize controller
     */
#ifndef _EMULATOR
    controllerSlot = initControllers();
#endif

    /*
     * Stick the texture segment right after the static segment
     */
    textureSegment = (_staticSegmentRomEnd - _staticSegmentRomStart) +
		      _cfbSegmentEnd+8;

    /* add an offset to textureSegment placement for testing */
    /*
    textureSegment = (char *)0x8034e430;
    textureSegment = (char *)0x8034e438;
    textureSegment = (char *)0x8034e440;
    note: 0x8034e430 + 0x100*i + 0x8*j, for i = 0,5 and j =0,2 show hw1 problem
    textureSegment += (24 + 0x1fe980);
    textureSegment += (24 + 0x18e980);
    */
    textureSegment += (24 + 0x18e980);
    textureSegmentEnd = (_textureSegmentRomEnd - _textureSegmentRomStart) +
		        textureSegment;
    if (((textureSegment < _codeSegmentEnd)&&(textureSegment > _codeSegmentStart))||
        ((textureSegmentEnd < _codeSegmentEnd)&&
	 (textureSegmentEnd > _codeSegmentStart))) {
#ifndef _EMULATOR
       rmonPrintf("moved textureSegment past codeSegment\n");
#endif
       textureSegment = (char *)0x8034e438;
    }


    dmaIOMessageBuf.hdr.pri      = OS_MESG_PRI_NORMAL;
    dmaIOMessageBuf.hdr.retQueue = &dmaMessageQ;
    dmaIOMessageBuf.dramAddr     = textureSegment;
    dmaIOMessageBuf.devAddr      = (u32)_textureSegmentRomStart;
    dmaIOMessageBuf.size         = _textureSegmentRomEnd-_textureSegmentRomStart;

    osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);

#ifndef _EMULATOR
	rmonPrintf("textureSegment 0x%x\n",textureSegment);
#endif

    /*
     * Wait for DMA of texture segment to finish
     */
    (void)osRecvMesg(&dmaMessageQ, &dummyMessage, OS_MESG_BLOCK);

    /*
    PRINTF("static segment start:  %x\n", staticSegment);
    PRINTF("static segment end:    %x\n", staticSegment +
		(_staticSegmentRomEnd - _staticSegmentRomStart));
    PRINTF("texture segment start: %x\n", textureSegment);
    PRINTF("texture segment end:   %x\n", textureSegment + 
		(_textureSegmentRomEnd - _textureSegmentRomStart));
    */

    /* 
     * count the test cases. Can't use sizeof(), do it
     * here.
     */
    testListCount = 0;
    while (testList[testListCount] != (Gfx *) NULL)
	testListCount++;
    testListCount--;
#ifndef _EMULATOR
	rmonPrintf("testListCount %d\n",testListCount);
#endif

    /*
     * Main game loop
     */
    while (keep_going) {

	/*
	 * this is only needed for regman freaks....
	 */
	piAddr = (u32 *)(PI_BASE);

	/*
	 * Read controller
	 */
#ifndef _EMULATOR
	readController(controllerSlot);
#endif

	/*
	 * pointers to build the display list.
	 */
	tlistp = &tlist;
	dynamicp = &dynamic;
	glistp = &(dynamicp->glist[0]);

	/*
	 * This test suite assumes the initialization
	 * sequences are all the same. You can un-do some state
	 * in your private test display list, if you like.
	 * You should also reset things you change.
	 *
	 */

	/*
	 * Tell RCP where each segment is
	 */
	gSPSegment(glistp++, 0, 0x0);	/* K0 (physical) address segment */
	gSPSegment(glistp++, STATIC_SEGMENT,
		   osVirtualToPhysical(staticSegment));
        gSPSegment(glistp++, TEXTURE_SEGMENT,
    	   	   osVirtualToPhysical(textureSegment));


	if (rdp_mspanFlushFlag) {
	    /*
	     * Force the pipeline to empty after the rendering of each
	     * display list item, to avoid incurring span buffer cache 
	     * coherency problems with DRAM r-m-w cycles.
	     */
	    gDPPipelineMode(glistp++, G_PM_1PRIMITIVE);
	}
	
	gSPDisplayList(glistp++, rdpinit_dl);
	gSPDisplayList(glistp++, rspinit_dl);

	/*
	 * If the rdp_regressionFlag is set, apply a 1/4 shrink to the 
	 * viewport so that the tests will render more quickly (because they
	 * won't be as fill limited).  Do this after we invoke the display
	 * list pointed to by setup_rspstate.
	 */
	if (rdp_regressionFlag) {
	    gSPDisplayList(glistp++, regression_viewport);
	} 
	
	/*
	 * Clear framebuffer
	 * doing this as a static display list is a little messier, due
	 * to cfb pointer conversion...
	 */
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_FILL);
	/*
	 * clear color, cvg = FULL or 1
	 */
#ifdef _EMULATOR
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
			 osVirtualToPhysical(cfb_ptrs[draw_buffer]));
#else
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
			 OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));
#endif
	gDPSetFillColor(glistp++, GPACK_RGBA5551(64,64,255,1) << 16 | 
			 GPACK_RGBA5551(64,64,255,1)); 
	gDPPipeSync(glistp++);
	gDPFillRectangle(glistp++, 0, 0, SCREEN_WD-1, SCREEN_HT-1);
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_1CYCLE);

	/*
	 * Clear zbuffer
	 */
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_FILL);
	gDPSetDepthImage(glistp++, APP_ZBUFFER);
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
				APP_ZBUFFER);
	gDPSetFillColor(glistp++, GPACK_ZDZ(G_MAXFBZ, 0) << 16 |
			GPACK_ZDZ(G_MAXFBZ, 0));
	gDPPipeSync(glistp++);
	gDPFillRectangle(glistp++, 0, 0, SCREEN_WD-1, SCREEN_HT-1);
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_1CYCLE);
#ifdef _EMULATOR
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
			 osVirtualToPhysical(cfb_ptrs[draw_buffer]));
#else
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
			 OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));
#endif

	/* end of standard display list part. */

	/*
	 * Setup our dynamic segment, depending on which test:
	 */
	if (ani_frame < 0 || ani_frame > testListCount) {
	    if (frame_count > testListCount) {
		frame_count = 0;
		if (automated)
		    keep_going = 0;
	    }
	    (*testCaseProcs[frame_count])(dynamicp, frame_count);
	    
	} else {
	    if (automated && ani_count >= ani_count_max)
		keep_going = 0;
	    
	    (*testCaseProcs[ani_frame])(dynamicp, ani_frame);
	}
	
	/* put in full sync for RSP processing */
	/*
	gDPFullSync(glistp++);
	*/
	gSPEndDisplayList(glistp++);

	/* 
	 * Build graphics task:
	 *
	 */
	tlistp->t.type = M_GFXTASK;
	tlistp->t.flags = OS_TASK_DP_WAIT;
	tlistp->t.ucode_boot = (unsigned long long *) rspbootTextStart;
	tlistp->t.ucode_boot_size = ((int)rspbootTextEnd - 
				     (int)rspbootTextStart);
	/*
	 * choose which ucode to run:
	 */
	if (rdp_DRAM_io) {
	    /* re-direct output to DRAM: */
	    if (uselines) {
		tlistp->t.ucode = (unsigned long long *)
		    gspLine3D_dramTextStart;
		tlistp->t.ucode_data = (unsigned long long *)
		    gspLine3D_dramDataStart;
	    } else {
		tlistp->t.ucode = (unsigned long long *)
		    gspFast3D_dramTextStart;
		tlistp->t.ucode_data = (unsigned long long *)
		    gspFast3D_dramDataStart; 
	    }
	} else {
	    /* SP output over XBUS to DP: */
	    if (uselines) {
		tlistp->t.ucode = (unsigned long long *)
		    gspLine3DTextStart;
		tlistp->t.ucode_data = (unsigned long long *)
		    gspLine3DDataStart;
	    } else {
		tlistp->t.ucode = (unsigned long long *)
		    gspFast3DTextStart;
		tlistp->t.ucode_data = (unsigned long long *)
		    gspFast3DDataStart;
	    }
	}
	tlistp->t.ucode_size = SP_UCODE_SIZE;
	tlistp->t.ucode_data_size = SP_UCODE_DATA_SIZE;
	
	tlistp->t.dram_stack = (unsigned long long *) &(dram_stack[0]);
	tlistp->t.dram_stack_size = SP_DRAM_STACK_SIZE8;

	if (rdp_DRAM_io) {
	    tlistp->t.output_buff = (unsigned long long *) &(rdp_output[0]);
#ifdef _EMULATOR
	    tlistp->t.output_buff_size = (unsigned long long *)
		&(info->rdpListSize);
#else
	    tlistp->t.output_buff_size = (unsigned long long *)
		&rdp_output_len;
#endif
	} else {
	    tlistp->t.output_buff = (unsigned long long *) 0x0;
	    tlistp->t.output_buff_size = (unsigned long long *) 0x0;
	}

	/* initial display list: */
	tlistp->t.data_ptr = (unsigned long long *) dynamicp->glist;
	tlistp->t.data_size = ((int)(glistp - dynamicp->glist) *
			       sizeof (Gfx));
	tlistp->t.yield_data_ptr = (unsigned long long *) NULL;
	tlistp->t.yield_data_size = 0xDA0;

#ifdef _EMULATOR
	/*
	 * Fill in verify info structure: (for verification ONLY)
	 */
	info->rspListAddr    = (unsigned int) tlistp->t.data_ptr;
	info->rspListSize    = tlistp->t.data_size;
	info->rspListType    = ((4096-128) << 12) | tlistp->t.type;
	info->ucodeTextAddr  = (unsigned int) tlistp->t.ucode;
	info->ucodeDataAddr  = (unsigned int) tlistp->t.ucode_data;
	info->ucodeDataSize  = tlistp->t.ucode_data_size;
	info->dramStackAddr  = (unsigned int) tlistp->t.dram_stack;
	info->dramStackSize  = tlistp->t.dram_stack_size;
	info->rdpListSize    = 0;
	info->rdpListAddr    = (unsigned int) tlistp->t.output_buff;
	info->bootUcodeAddr  = (unsigned int) tlistp->t.ucode_boot;
	info->width          = SCREEN_WD;
	info->height         = SCREEN_HT;
	info->frameBuffer0Addr = osVirtualToPhysical(cfb_16_a);
	info->frameBuffer1Addr = osVirtualToPhysical(cfb_16_b);
	info->zBufferAddr    = osVirtualToPhysical(zbuffer);
	info->magicNumber    = MAGICNUMBER; /* Kaelyn's birthday: 0x102594 */
	info->version        = VERSION;
	info->frameBufferFormat = G_IM_FMT_RGBA;
	info->frameBufferSize =  G_IM_SIZ_16b;
#endif
	
	/*
	 * Can just flush 16KB and forget about each individual pieces
	 * of data to flush.
	 */
	osWritebackDCacheAll();
	
#ifdef _EMULATOR
	/* possibly send display list to RSP simulator: */
        if (ani_frame < 0 || ani_frame > testListCount) {
	    if (frame_count == output_frame) {
		emRSPFrame(output_prefix, frame_count, keep_mem, rdp_DRAM_io, 0);
		output_frame = -1;	/* only output once... */
	    }
	} else {
            /*
	     * using the -s flag (ani_frame) will always cause
	     * the RSP to be invoked.
	     *
	     */
	    emRSPFrame(output_prefix, ani_count++, keep_mem, rdp_DRAM_io, 0);
	}
#endif

	/* unwrap this macro for debugging:
	 *
	 *	osSpTaskStart(tlistp);
	 *
	 */
	osSpTaskLoad(tlistp);
	osSpTaskStartGo(tlistp);
	
#ifdef _EMULATOR
	(void)osRecvMesg(&rspMessageQ, &dummyMessage, OS_MESG_BLOCK);
	emDisplayBuffer(osVirtualToPhysical(cfb_ptrs[draw_buffer]));
	(void)osRecvMesg(&retraceMessageQ, &dummyMessage, OS_MESG_BLOCK);
#else
	if (rdp_DRAM_io)
	    /* wait for SP completion */
	    (void)osRecvMesg(&rspMessageQ, &dummyMessage, OS_MESG_BLOCK);
	else
	    /* ignore SP completion */
	    (void)osRecvMesg(&rdpMessageQ, &dummyMessage, OS_MESG_BLOCK);

	if (rdp_DRAM_io) {
	    /*
	     * Send the DP display list to the DP:
	     */
	    guParseRdpDL(&(rdp_output[0]), (u32)rdp_output_len, 0);
	    dummy_val = osDpSetNextBuffer(&(rdp_output[0]),rdp_output_len);
	    (void)osRecvMesg(&rdpMessageQ, &dummyMessage, OS_MESG_BLOCK);
	}

	/* setup to swap buffers */
	osViSwapBuffer(cfb_ptrs[draw_buffer]);

	/* Make sure there isn't an old retrace in queue 
	 * (assumes queue has a depth of 1) 
	 */
	if (MQ_IS_FULL(&retraceMessageQ))
	    (void)osRecvMesg(&retraceMessageQ, &dummyMessage, OS_MESG_BLOCK);
	
	/* Wait for Vertical retrace to finish swap buffers */
	(void)osRecvMesg(&retraceMessageQ, &dummyMessage, OS_MESG_BLOCK);
	draw_buffer ^= 1;

	/* delay loop for helping to determine frame of occurrence */
	/*
	for (i = 0; i < 15000000; i++);
	rmonPrintf("frame_count %d \n",frame_count);
	*/
#endif

#ifdef _EMULATOR
	/*
	if (automated) {
	    keep_going = TRUE;
	    if (output_frame == -1) keep_going = FALSE;
	}
	*/
	if (automated) {
	    frame_count++;
	} else {
	    emGetMouseState(&ms);
	    if (ms.buttons & BUTTON_LEFT) {
		frame_count++;
		while (ms.buttons & BUTTON_LEFT)/* de-bounce mouse state: */
		    emGetMouseState(&ms);
	    } else if (ms.buttons & BUTTON_MIDDLE) {
		;
	    } else if (ms.buttons & BUTTON_RIGHT) {
		;
	    }
	}
#else
	frame_count = controlFrame;
	if ((frame_count < 0)||(frame_count > testListCount)) {
           frame_count = 0;
           controlFrame = 0;
	}
#endif

    }

#ifdef _EMULATOR
    emRSPQuit();
#endif
    for(;;);   
}