/**************************************************************************
 *								          *
 *               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.  *
 *								          *
 *************************************************************************/

/*
 * File:		gmain.s
 * Creator:		hsa@sgi.com
 * Create Date:		Mon Jun 20 11:48:48 PDT 1994
 *
 * This is the 'graphics task' for the RSP. it takes blocks of display
 * list commands and interprets them:	 transforming, shading, clipping,
 * DDA setup, etc., preparing geometry to be rasterized. It is also the
 * center of the graphics system from the game's point of view, and
 * receives all of the RDP control commands, which it passes along.
 *
 * In the absence of a linker, the different source code modules of the
 * graphics task will be include'd here during compilation. See the Makefile
 * for details.
 *
 */


#include <rsp.h>
#include <rcp.h>
#include <os.h>
#include <sptask.h>
#include "mbi.h"

#ifdef FASTLIGHT3D
		.text	RSP_IMEM_BASE	# this is coordinated with rspboot.s
#else /* FASTLIGHT3D */
		.text	TASKBASE	# this is coordinated with rspboot.s
#endif /* FASTLIGHT3D */
		.data	0
	
#define MAIN
#include "gdmem.h"
#include "gfx_regs.h"

		.text

	#################################################################
	#
	#  Begin task initialization
	#
	#  Register $1 holds the task header address
	# format for the task header:
	#
	# (see task.h)
	#

 #=================================================
 #======= in FASTLIGHT doInit is an overlay =======
 #=================================================
#ifdef FASTLIGHT3D

#include "newt.s"
 #		j	doInit		# initialization routine
	# set state pointer:
 #		addi	rsp_state, zero, RSP_STATE_OFFSET
 ### JUMP OCCURS here to doInit:
	
 #=================================================
 #======= ...Otherwise it is #included here =======
 #=================================================
#else /* FASTLIGHT3D */

	# set state pointer:
		addi	rsp_state, zero, RSP_STATE_OFFSET

#include "ginit.s"

#endif /* FASTLIGHT3D */
	
		.ent	main

	#################################################################
	#
	# Note about display list command processing:	
	#
	#    - 'inp' always points to the "next" DL command in DRAM. This
	# 	is the pointer pushed on the stack and used to retrieve the
	#	next block of DL commands.
	#
	#    - 'dinp' is the local pointer in DMEM to the part of the display
	#	list in DMEM.
	#
	#    - 'dlcount' parallels dinp, counting down the remaining DL
	#	commands in DMEM.
	#
	# So when (dlcount == 0) we need to fetch more display list.
	#
	# NOTE:
	# It would be useful to support an "immediate" mode from the host.
	# This would allow a better performance/space trade-off using 
	# generated data, etc. In order to do this we need to modify the
	# display list processing -- basically allow the gtask to go idle
	# and wait for more display list, rather than exit. Needs a couple
	# status registers to sync with the host (GO, IDLE, etc.)
	#
	# Fri Oct  7 10:45:04 PDT 1994
	#
	#################################################################
	#
	#
DMAWaitDL:
		jal	DMAwait
		# note delay slot...		
	
 	# process gfx list:	
.name	dlcmd,	$1
		addi	dinp, zero, RSP_DLINPUT_OFFSET	# delay
DecodeDL:	lw	gfx0, 0(dinp)
DecodeDL1:	lw	gfx1, 4(dinp)
DecodeDL2:
#ifdef	OUTPUT_LOG
		addu	$17,  dinp, inp
		addi	$17,  $17,  -RSP_INPUT_OFFSET
		sw	$17,  RSP_INPUT_OFFSET+4(zero)
		sw	gfx0, RSP_INPUT_OFFSET+0(zero)
		ori	$17,  zero, 0xdead
		sw	$17,  RSP_INPUT_OFFSET+8(zero)
		addiu	$20,  zero, RSP_INPUT_OFFSET
		lw	$19,  RSP_L_7+7*4(zero)
		jal	DMAproc
		addiu	$18,  zero, 15
		addiu	$19,  $19,  8
		sw	$19,  RSP_L_7+7*4(zero)
#endif
		srl	dlcmd, gfx0, 29
		andi	dlcmd, dlcmd, 0x06	# GFX op type (jump offset)

	# advance these pointers after consuming gfx0/1
#ifndef	SMARTINP
		addi	inp, inp, 8
#endif
		addi	dinp, dinp, 8
#ifndef	SMARTDLCOUNT
		addi	dlcount, dlcount, -8
#endif
	
	#
	# Get a head start on the next command, if it's a DMA.
	# The register in_bufp points to the fetched data, and
	# should implment the double-buffering...
	#
.name dma_len,	$18
.name dram_addr, $19
.name dmem_addr, $20
		bgtz	dlcmd, ContDecode	# not a DMA...
		# note delay slot	
	#
	# despite being a 16-bit field, the maximum DMA transfer
	# is 256 bytes (16 vertices). Since the G_DL command will
	# also come through here, with a much larger DMA length, we
	# protect the length by masking to 0x01ff...
	#

	# WARNING!
	# We are passing the wrong length to the DMA routine here. 
	# We should pass 'length-1'. We choose not to spend the extra 
	# instruction and correct this, because the place in DMEM 
	# that will potentially be trashed by the extra DMA is 
	# guarenteed to be trash-able. (setup tmp area)
	#
#if (defined(F3DLP_GBI)||defined(F3DEX_GBI))
		andi	dma_len, gfx0, 0x03ff	# pick off DMA length
#else
		andi	dma_len, gfx0, 0x01ff	# pick off DMA length
#endif
		addi	in_bufp, zero, RSP_INPUT_OFFSET

		jal	AddrFixup
		add	dram_addr, gfx1, zero		# delay slot

		jal	DMAread
		add	dmem_addr, zero, in_bufp

.unname dma_len
.unname dram_addr
.unname dmem_addr

	# we do the wait for the DMA in the gdma module. This
	# lets us do some useful work while we wait...
	
.name op_addr, $2
    ContDecode:		
				# compute jump address
		lh	op_addr, OPTYPE_JMP_OFFSET(dlcmd)
		jr	op_addr
	# this delay slot is the first thing the other routines do...
		srl	$2, gfx0, 23		# table byte offset...
.unname op_addr
.unname dlcmd

.name 	yield,		$2
.name	overeturn,	$21	# return address from loadOverlay
	
GfxDone: 	# we're done with this one, do the next one (if available)...
	#
	# stick our head up, see if we need to yield the SP. If so,
	# checkpoint everything then exit.
	#						#
		mfc0	yield, SP_STATUS		# need to yield?
		andi	yield, yield, SP_STATUS_YIELD	#
		bne	yield, zero, RSPYield		#
		lh	overeturn, TASKYIELD(zero)    	# return to RSPYield
							#
.unname yield						#
							#
noYield:						#
#ifdef	SMARTDLCOUNT
 		bne	dlcount, dinp, DecodeDL1		#
#else
 		bgtz	dlcount, DecodeDL1		#
#endif
		lw	gfx0, 0(dinp)			#
 ### BRANCH OCCURS to DecodeDL if dlcount is not zero yet
		j	LoadDL				#
		lh	return, DMAWAITDL(zero)		# return to DMAWaitDL
 ### BRANCH OCCURS to LoadDL: and returns to DMAWaitDL:
							#
		.end	main				#
							#
 #======================================================================
 #======= in FASTLIGHT TaskDone & Yield are overlays - load them =======
 #======================================================================
#ifdef FASTLIGHT3D
.unname	return_save
.name	overp,		$30	# which overlay to load
TaskDone:
		lh	overeturn, TASKDONE(zero)        # return to start
RSPYield:
		j	loadOverlay		  # Load the overlay
		ori	overp, zero, OVERLAY_DONE # Load gdone overlay
 ### BRANCH OCCURS HERE TO loadOverlay:

.unname overp
.unname overeturn
.name	return_save,	$30
 #======================================================================
 #======= ...Otherwise include Done and Yield here (Yield is in done) ==
 #======================================================================
#else /* FASTLIGHT3D */
.unname overeturn

#include "gdone.s"
#endif /* FASTLIGHT3D */
	#
	#
	##################################################################

	##################################################################
	#
	# start the DMA of the display list into DMEM.
	#
	# Always reads RSP_DLINPUT_SIZE8 bytes into the buffer. We
	# require lists to be terminated with G_ENDDL, so this might be
	# reading a little beyond the actual end.
	#
	# Registers upon call:
	#		inp	pointer to read from
	#		return	where to go when we're done
	#
	# Registers upon return:
	#		dlcount	size actually read (bytes)
	#		dinp	pointer to data we read in
	#
	# Registers used:
	#		return, zero, inp, dlcount, dinp
	#

		.ent	LoadDL
LoadDL:		
#ifdef	SMARTDLCOUNT
 		addi	dlcount, zero, RSP_DLCOUNT_INIT
#else
 		addi	dlcount, zero, RSP_DLINPUT_SIZE8
#endif
 		addi	$20, zero, RSP_DLINPUT_OFFSET
		add	$19, zero, inp
#ifdef	SMARTINP
		addi	inp, inp, RSP_DLINPUT_SIZE8
#endif
 		addi	$18, zero, RSP_DLINPUT_SIZE8 - 1
		j	DMAread
		addi	dinp, zero, RSP_DLINPUT_OFFSET # delay slot

		.end LoadDL
	#
	#
	##################################################################

   	##################################################################
   	#
   	# This routine loads one of the overlays from the DMEM table.
   	# Register $4 has the index into the overlay table to load.
   	#
   	# Assumes overlay table is the first thing in DMEM.
   	#
.unname	return_save
.name	overp,		$30
.name	imem_addr,	$20
.name	dram_addr,	$19
.name	dma_len,	$18
.name	iswrite,	$17
.name	overeturn,	$21
	
	loadOverlaySR:
		add	overeturn, zero, return
	loadOverlay:
		lw	dram_addr, OVERLAY_OFFSET(overp)
		lh	dma_len,   OVERLAY_SIZE(overp)
		jal	DMAread
		lh	imem_addr, OVERLAY_DEST(overp)
		jal	DMAwait
		nop
		jr	overeturn
		# note delay slot
.unname	overp
.unname	imem_addr
.unname	dram_addr
.unname	dma_len
.unname	iswrite
.unname	overeturn
.name	return_save,	$30
   	#
   	#
   	##################################################################
	
	##################################################################
	#
	# Address Fix-up routine.
	#
	# Takes a segment/offset address in register $19, computes
	# the proper DRAM address using the segment table. Returns
	# the answer in register $19
	#
	# (The use of register $19 is NOT random... It's the DRAM
	# address used in DMAproc, often the next thing called.)
	#
	# This code is shared among several routines, the registers
	# used are chosen not to conflict with those.
	#
.name dma_addr,	$19
.name mask, 	$11
.name seg_id,	$12
.name seg_ptr,	$13
		.ent	AddrFixup
    AddrFixup:
#if 0	/* No need SEGADDR_MASK_OFFSET */
		lw	mask, SEGADDR_MASK_OFFSET(zero)
		srl	seg_id, dma_addr, 22
		andi	seg_id, seg_id, 0x3c	# Seg num only RWW
 #		sll	seg_id, seg_id, 2	# leave mult. by 4 for offset
		and	dma_addr, dma_addr, mask
		add	seg_ptr, zero, seg_id
		lw	seg_id, RSP_SEG_OFFSET(seg_ptr)
#else
		srl	seg_id, dma_addr, 22
		andi	seg_id, seg_id, 0x3c
		lw	seg_id, RSP_SEG_OFFSET(seg_id)
		sll	dma_addr, dma_addr, 8
		srl	dma_addr, dma_addr, 8
#endif
		jr	return
		add	dma_addr, dma_addr, seg_id	# delay slot
		.end	AddrFixup
.unname dma_addr
.unname mask
.unname seg_id
.unname seg_ptr
	#
	##################################################################
	
#ifndef	SWITCH_UCODE
	# Procedure to do DMA reads/writes.
	# Procedure to do DMA waits.
#include	"gloaduc.s"
#endif
		
	##################################################################
	#
	# other "modules" are appended by #include
	#

 #==============================================================================
 #===== If FASTLIGHT Yield Restart is in init overlay, otherwise it's here =====
 #==============================================================================
#ifndef FASTLIGHT3D
#	define YIELD_RESTART
#	define YIELD_STOP
#	include "gyield.s"
#	undef YIELD_STOP
#	undef YIELD_RESTART
#endif /* FASTLIGHT3D */
	
 #==============================================================================
 #===== Output module (either DRAM or directly to XBUS) ========================
 #==============================================================================
#ifdef OUTPUT_DRAM
 #  if (defined(F3DLP_GBI)||defined(F3DEX_GBI))
 #	ERROR !!!! ERROR !!!!
 #  else
#   include "goutdram.s"
 #  endif
#else
#  ifdef OUTPUT_FIFO
#    ifdef OUTPUT_DUMP
#      include "goutdump.s"
#    else
#      include "goutfifo.s"
#    endif
#  else
#    if (defined(F3DLP_GBI)||defined(F3DEX_GBI))
	ERROR !!!! ERROR !!!!
#    else
#      include "goutxbus.s"
#    endif
#  endif
#endif
	
 #==============================================================================
 #===== Command parsing modules for immediate, rdp, and dma commands ===========
 #==============================================================================
#include "gimm.s"
	
#include "grdp.s"
	
#include "gdma.s"
	

 #==============================================================================
 #===== Clip and/or light and/or setup code for lines or polygons ==============
 #==============================================================================
#ifdef LINE3D
#   include "gclipl.s"	
#   include "gline.s"
#else
#   include "goverlays.s"
#   ifndef NODATA
#ifndef _HW_VERSION_1
#  ifdef F3DLP_GBI
#       include "glsetup.s"
#  else
#    ifdef NOSUBPIXEL
#       include "glxsetup.s"
#    else
#       include "gsetup.s"
#    endif
#  endif
#else
#       include "gsetup1.s"
#endif
#   endif
#endif

#ifdef	SWITCH_UCODE
#if	(defined(DMANOWAIT2))
# define	LOADUC_A_SIZE	6
#elif	(defined(DMANOWAIT)||defined(DMA2BUF))
# define	LOADUC_A_SIZE	3
#else
# define	LOADUC_A_SIZE	0
#endif
#ifdef	SMARTINP
# define	LOADUC_B_SIZE	2
#else
# define	LOADUC_B_SIZE	0
#endif
#define		LOADUC_START	0x04001f94-(LOADUC_A_SIZE+LOADUC_B_SIZE)*4

#ifdef	NODATA
	.symbol	case_G_SWITCH_UCODE,	LOADUC_START
	.symbol	DMAwait,		0x04001fc4	/* gloaduc */
	.symbol	DMAread,		0x04001fd4	/* gloaduc */
	.symbol	DMAproc,		0x04001fd8	/* gloaduc */
#else
EndOfBody:
	.print	__FILE__
 .print  "\n===========================\n"
 .print  ">>>> Remain = %d inst(s).\n", (LOADUC_START-EndOfBody)/4
 .dmax	 1025-(LOADUC_A_SIZE+LOADUC_B_SIZE+27)
 .print  "===========================\n"
	.space	LOADUC_START
#include	"gloaduc.s"
#endif
#endif
EndOfProg:
	.print	__FILE__
	.print	" : IMEM used %d instructions ", (EndOfProg - 0x04001000)/4
	.print  "(must be < 1024).\n"
	.dmax	1025
	#
	#
	##################################################################