/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1995, 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:09 $
 *---------------------------------------------------------------------*/

/*
 * File:  main.c
 *
 * standard demo loop
 *
 */

#include <ultra64.h>
#include <PR/ramrom.h>			/*
								 * needed for argument passing into the app 
								 */
#include <assert.h>

#include "app.h"
#include "walk_around.h"
#include "texture.h"

extern int MyPalette;
extern int MyMode;
extern int DoParseRdp;
extern int DoParseGbi;

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

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

/*
 * 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
 * This stack is ridiculously large, and could also be reclaimed once
 * the main thread is started.
 */
u64             bootStack[STACKSIZE / sizeof(u64)];

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

static OSThread idleThread;
static u64      idleThreadStack[STACKSIZE / sizeof(u64)];

static OSThread mainThread;
static u64      mainThreadStack[STACKSIZE / sizeof(u64)];

static OSThread rmonThread;
static u64      rmonStack[RMON_STACKSIZE / sizeof(u64)];

/*
 * this number (the depth of the message queue) needs to be equal
 * * to the maximum number of possible overlapping PI requests.
 * * For this app, 1 or 2 is probably plenty, other apps might
 * * require a lot more.
 */
#define NUM_PI_MSGS     8

static OSMesg   PiMessages[NUM_PI_MSGS];
static OSMesgQueue PiMessageQ;

OSMesgQueue     dmaMessageQ,
                rspMessageQ,
                rdpMessageQ,
                retraceMessageQ;
OSMesg          dmaMessageBuf,
                rspMessageBuf,
                rdpMessageBuf,
                retraceMessageBuf[5];
OSIoMesg        dmaIOMessageBuf;	/*

									 * see man page to understand this 
									 */

/*
 * Dynamic data.
 */
Dynamic         dynamic;

/*
 * necessary for RSP tasks:
 */
extern u64             dram_stack[];
extern u64             rdp_output_len;
extern u64             rdp_output[];

/*
 * Task descriptor.
 */
OSTask          tlist =
{
	M_GFXTASK,					/*
								 * task type 
								 */
	OS_TASK_DP_WAIT,			/*
								 * task flags 
								 */
	NULL,						/*
								 * boot ucode pointer (fill in later) 
								 */
	0,							/*
								 * boot ucode size (fill in later) 
								 */
	NULL,						/*
								 * task ucode pointer (fill in later) 
								 */
	SP_UCODE_SIZE,				/*
								 * task ucode size 
								 */
	NULL,						/*
								 * task ucode data pointer (fill in later) 
								 */
	SP_UCODE_DATA_SIZE,			/*
								 * task ucode data size 
								 */
	&(dram_stack[0]),			/*
								 * task dram stack pointer 
								 */
	SP_DRAM_STACK_SIZE8,		/*
								 * task dram stack size 
								 */
	&(rdp_output[0]),			/*
								 * task output buffer ptr (not always used) 
								 */
	&rdp_output_len,			/*
								 * task output buffer size ptr 
								 */
	NULL,						/*
								 * task data pointer (fill in later) 
								 */
	0,							/*
								 * task data size (fill in later) 
								 */
	NULL,						/*
								 * task yield buffer ptr (not used here) 
								 */
	0							/*
								 * task yield buffer size (not used here) 
								 */
};

Gfx            *glistp;			/*
								 * global for test case procs 
								 */

/*
 * global variables
 */
static int      rdp_DRAM_io = 0;
static int      do_texture = 0;
static int      debugflag = 0;
static int      draw_buffer = 0;

OSPiHandle	*handler;

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

	/*
	 * notice that you can't call rmonPrintf() until you set
	 * * up the rmon thread.
	 */

	osInitialize();

	handler = osCartRomInit();

	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 
	 */
	ap = (char *) argbuf;
	while (*ap != '\0') {
		while (*ap == ' ')
			ap++;
		if (*ap == '-' && *(ap + 1) == 'd') {
			debugflag = 1;
			ap += 2;
		} else if (*ap == '-' && *(ap + 1) == 't') {
			do_texture = 1;
			ap += 2;
		} else if (*ap == '-' && *(ap + 1) == 'r') {
			rdp_DRAM_io = 1;
			ap += 2;
		}
	}

	osCreateThread(&idleThread, 1, idle, (void *) 0,
				   idleThreadStack + STACKSIZE / sizeof(u64), 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,
				   (void *) (rmonStack + RMON_STACKSIZE / 8),
				   (OSPri) OS_PRIORITY_RMON);
	osStartThread(&rmonThread);

	/*
	 * at this point, AND NOT BEFORE, we can now do an
	 * rmonPrintf()
	 */

	/*
	 * Create main thread
	 */
	osCreateThread(&mainThread, 3, mainproc, arg,
				   mainThreadStack + STACKSIZE / sizeof(u64), 10);

	if (!debugflag)
		osStartThread(&mainThread);

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

	for (;;) ;
}



static void
 spank_monkey ( Dynamic *dynamicp, int monkey )
{
  int i, j;
  int di, dj, mi, mj;


    guRotate(&dynamicp->identity, 0.0, 0.0, 1.0, 0.0);
    guTranslate(&dynamicp->move_x, 31,  0.0, 0.0);
    guTranslate(&dynamicp->move_y,  0.0, 39, 0.0);

    gSPMatrix(glistp++, &(dynamicp->projection),
                G_MTX_PROJECTION|G_MTX_LOAD|G_MTX_NOPUSH);

    gSPMatrix(glistp++, &(dynamicp->viewing),
                G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);

    gSPMatrix(glistp++, &(dynamicp->identity),
                G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_PUSH);

	switch(monkey) {
		case 0:
			/* 8-bit CI */
    		di = 40;
    		dj = 32;
    		mi = 6*di;
    		mj = 8*dj;
    		gSPDisplayList(glistp++, &(mandrill_dl[0]));
			break;
		case 1:
			/* 4-bit */
    		di = 32;
    		dj = 32;
    		mi = 7*di;
    		mj = 8*dj;
    		gSPDisplayList(glistp++, &(mandrill4_dl[0]));
			break;
		case 2:
			/* 16-bit RGBA */
    		di = 32;
    		dj = 32;
    		mi = 7*di;
    		mj = 8*dj;
    		gSPDisplayList(glistp++, &(mandrill32_dl[0]));
			break;
		case 3:
			/* 32-bit RGBA */
    		di = 31;
    		dj = 31;
    		mi = 7*di;
    		mj = 8*dj;
    		gSPDisplayList(glistp++, &(mandrill32_dl[0]));
			break;
		default:
			rmonPrintf("unkown monkey\n");
			break;
	}

    for(i = 0; i < mi; i += di)
    {
      for(j = 0; j < mj; j += dj)
      {
		switch(monkey) {
			case 0:
        	gDPLoadTextureTile( glistp++, CI8mandrill, G_IM_FMT_CI, G_IM_SIZ_8b,
        	256, 240,
        	j, i, j+dj, i+di,
        	0,
        	G_TX_MIRROR, G_TX_MIRROR, 0, 0, 0, 0);
			break;

			case 1:
			/* test 4-bit mode */
        	gDPLoadTextureTile_4b( glistp++, I4mandrill, 
			G_IM_FMT_RGBA, 
        	256, 224,
        	j, i, j+dj, i+di,
        	0,
        	0, 0, 0, 0, 0, 0);
			break;

			case 2:
        	gDPLoadTextureTile( glistp++, RGBA16mandrill, 
			G_IM_FMT_RGBA, G_IM_SIZ_16b,
        	256, 224,
        	j, i, j+dj, i+di,
        	0,
        	0, 0, 0, 0, 0, 0);
			break;

			case 3:
        	gDPLoadTextureTile( glistp++, RGBA32mandrill, 
			G_IM_FMT_RGBA, G_IM_SIZ_32b,
        	256, 224,
        	j, i, j+dj, i+di,
        	0,
        	0, 0, 0, 0, 0, 0);
			break;

		}

        gDPTileSync(glistp++);

#ifndef JUNK
        gDPSetTileSize(glistp++, G_TX_RENDERTILE, 0, 0, (dj) << 2, (di) << 2);
#endif /* JUNK */

		if(monkey > 0) {
        	gSPDisplayList(glistp++, &(mandrill32_face_dl[0]));
		} else {
        	gSPDisplayList(glistp++, &(mandrill_face_dl[0]));
		}

        gSPMatrix(glistp++, &(dynamicp->move_x),
                  G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);

      }
      gSPPopMatrix(glistp++, G_MTX_MODELVIEW);
      gSPMatrix(glistp++, &(dynamicp->move_y),
                G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);
      gSPMatrix(glistp++, &(dynamicp->identity),
                G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_PUSH);
    }
    gSPPopMatrix(glistp++, G_MTX_MODELVIEW);
}

/*
 * This is the main routine of the app.
 */
static void
mainproc(void *arg)
{
	OSTask         *tlistp;
	Dynamic        *dynamicp;
	char           *staticSegment;
	char           *textureSegment;
	u16             perspNorm;

	/*
	 * Setup the message queues
	 */
	osCreateMesgQueue(&dmaMessageQ, &dmaMessageBuf, 1);

	osCreateMesgQueue(&rspMessageQ, &rspMessageBuf, 1);
	osSetEventMesg(OS_EVENT_SP, &rspMessageQ, NULL);

	osCreateMesgQueue(&rdpMessageQ, &rdpMessageBuf, 1);
	osSetEventMesg(OS_EVENT_DP, &rdpMessageQ, NULL);

	osCreateMesgQueue(&retraceMessageQ, retraceMessageBuf, 5);
	osViSetEvent(&retraceMessageQ, NULL, 1);

	/*
	 * Stick the static segment right after the code/data segment
	 */
	staticSegment = _codeSegmentEnd;


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

	osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);

	/*
	 * Wait for DMA to finish
	 */
	(void) osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);

	/*
	 * Force texture to have alignment that causes TLUT load to fail
	 */
	textureSegment = (char *)0x8034e720;


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

	osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);

	PRINTF("staticSegment = %08x\n", staticSegment);
	PRINTF("textureSegment = %08x\n", textureSegment);

	/*
	 * Wait for DMA to finish
	 */
	(void) osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);

#ifdef WALK_AROUND
	assert(walkAroundInit(128, 512, 200) >= 0);
#endif

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

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

#ifdef WALK_AROUND

		guPerspective(&dynamicp->projection, &perspNorm,
					  33, 320.0 / 240.0, 100, 10000, 1.0);

		/*
		 * sets viewing matrix 
		 */
		walkAround(dynamicp);

#else

		guOrtho(&dynamicp->projection,
				-(float) SCREEN_WD / 2.0F, (float) SCREEN_WD / 2.0F,
				-(float) SCREEN_HT / 2.0F, (float) SCREEN_HT / 2.0F,
				1.0F, 10.0F, 1.0F);
		guRotate(&dynamicp->viewing, 0.0F, 0.0F, 0.0F, 1.0F);

#endif /*
	    * WALK_AROUND 
	    */

		/*
		 * Tell RCP where each segment is
		 */
		gSPSegment(glistp++, 0, 0x0);	/*
										 * Physical address segment 
										 */
		gSPSegment(glistp++, STATIC_SEGMENT, OS_K0_TO_PHYSICAL(staticSegment));
		gSPSegment(glistp++, CFB_SEGMENT, OS_K0_TO_PHYSICAL(cfb[draw_buffer]));
		gSPSegment(glistp++, CZB_SEGMENT, OS_K0_TO_PHYSICAL(czb));
		gSPSegment(glistp++, TEXTURE_SEGMENT, OS_K0_TO_PHYSICAL(textureSegment));
		/*
		 * Initialize RDP state.
		 */
		gSPDisplayList(glistp++, rdpinit_dl);

		/*
		 * Initialize RSP state.
		 */
		gSPDisplayList(glistp++, rspinit_dl);

		/*
		 * Clear color framebuffer.
		 */
		gSPDisplayList(glistp++, clearczb_dl);
		gSPDisplayList(glistp++, clearcfb_dl);
		gSPTexture(glistp++, 0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON);

		/*
		 * simple triangle: 
		 */
		if (MyMode == 0) {
			gSPDisplayList(glistp++, textri_dl);
		} else if (MyMode == 1) {
			gSPDisplayList(glistp++, shadetri_dl);
		} else if (MyMode == 2) {
			gSPDisplayList(glistp++, ci_load_4b);
			gDPPipeSync(glistp++);
			gDPSetTile(glistp++, G_IM_FMT_CI, G_IM_SIZ_4b, 
				1, 0, 0, MyPalette, 
				0, 0, 0, 0, 0, 0);
			gSPDisplayList(glistp++, ci_face);
		} else if (MyMode == 3) {
			gSPDisplayList(glistp++, ci_face_8b);
		} else if (MyMode == 4) {
			spank_monkey(dynamicp, 1);
		} else if (MyMode == 5) {
			spank_monkey(dynamicp, 0);
		} else if (MyMode == 6) {
			spank_monkey(dynamicp, 2);
		} else if (MyMode == 7) {
			spank_monkey(dynamicp, 3);
		}

		gDPFullSync(glistp++);
		gSPEndDisplayList(glistp++);

		assert((glistp - dynamicp->glist) < GLIST_LEN);

		/*
		 * Build graphics task:
		 *
		 */
		tlistp->t.ucode_boot = (u64 *) rspbootTextStart;
		tlistp->t.ucode_boot_size = (u32) rspbootTextEnd - (u32) rspbootTextStart;

		/*
		 * choose which ucode to run:
		 */
		if (rdp_DRAM_io || DoParseRdp) {
			/*
			 * re-direct output to DRAM: 
			 */
			tlistp->t.ucode = (u64 *) gspFast3D_dramTextStart;
			tlistp->t.ucode_data = (u64 *) gspFast3D_dramDataStart;
		} else {
			/*
			 * RSP output over XBUS to RDP: 
			 */
			tlistp->t.ucode = (u64 *) gspFast3DTextStart;
			tlistp->t.ucode_data = (u64 *) gspFast3DDataStart;
		}

		/*
		 * initial display list: 
		 */
		tlistp->t.data_ptr = (u64 *) dynamicp->glist;
		tlistp->t.data_size = (u32) ((glistp - dynamicp->glist) * sizeof(Gfx));

		if(DoParseGbi) {
			 guParseGbiDL(tlistp->t.data_ptr, tlistp->t.data_size, GU_PARSEGBI_FLTMTX); 
		}

		/*
		 * Write back dirty cache lines that need to be read by the RCP.
		 */
		osWritebackDCache(&dynamic, sizeof(dynamic));

		/*
		 * start up the RSP task
		 */
		osSpTaskStart(tlistp);

		/*
		 * wait for SP completion 
		 */
		(void) osRecvMesg(&rspMessageQ, NULL, OS_MESG_BLOCK);

		if (rdp_DRAM_io || DoParseRdp) {

			guParseRdpDL(rdp_output, rdp_output_len, 0); 

			/*
			 * Send the DP display list to the DP:
			 */
			osDpSetNextBuffer(&(rdp_output[0]),rdp_output_len);
		}

		(void) osRecvMesg(&rdpMessageQ, NULL, OS_MESG_BLOCK);

		/*
		 * setup to swap buffers 
		 */
		osViSwapBuffer(cfb[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, NULL, OS_MESG_BLOCK);

		/*
		 * Wait for Vertical retrace to finish swap buffers 
		 */
		(void) osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
		 draw_buffer ^= 1;
	}
}