/ogc_patches/gx.c

Large files files are truncated, but you can click here to view the full file

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include "asm.h"
#include "processor.h"
#include "irq.h"
#include "lwp.h"
#include "system.h"
#include "video.h"
#include "video_types.h"
#include "lwp_watchdog.h"
#include "gx.h"

//#define _GP_DEBUG

#define GX_FINISH		2
#define BIG_NUMBER		(1024*1024)
#define WGPIPE			(0xCC008000)

#define _SHIFTL(v, s, w)	\
    ((u32) (((u32)(v) & ((0x01 << (w)) - 1)) << (s)))
#define _SHIFTR(v, s, w)	\
    ((u32)(((u32)(v) >> (s)) & ((0x01 << (w)) - 1)))

#define FIFO_PUTU8(x)	*(vu8*)WGPIPE = (u8)(x)
#define FIFO_PUTS8(x)	*(vs8*)WGPIPE = (s8)(x)
#define FIFO_PUTU16(x)	*(vu16*)WGPIPE = (u16)(x)
#define FIFO_PUTS16(x)	*(vs16*)WGPIPE = (s16)(x)
#define FIFO_PUTU32(x)	*(vu32*)WGPIPE = (u32)(x)
#define FIFO_PUTS32(x)	*(vs32*)WGPIPE = (s32)(x)
#define FIFO_PUTF32(x)	*(vf32*)WGPIPE = (f32)(x)

#define GX_LOAD_BP_REG(x)				\
	do {								\
		FIFO_PUTU8(0x61);				\
		FIFO_PUTU32((x));				\
	} while(0)

#define GX_LOAD_CP_REG(x, y)			\
	do {								\
		FIFO_PUTU8(0x08);				\
		FIFO_PUTU8((x));				\
		FIFO_PUTU32((y));				\
	} while(0)

#define GX_LOAD_XF_REG(x, y)			\
	do {								\
		FIFO_PUTU8(0x10);				\
		FIFO_PUTU32(((x)&0xffff));		\
		FIFO_PUTU32((y));				\
	} while(0)

#define GX_LOAD_XF_REGS(x, n)			\
	do {								\
		FIFO_PUTU8(0x10);				\
		FIFO_PUTU32((((((n)&0xffff)-1)<<16)|((x)&0xffff)));				\
	} while(0)

#define XY(x, y)   (((y) << 10) | (x))

#define GX_DEFAULT_BG	{64,64,64,255}
#define BLACK			{0,0,0,0}
#define WHITE			{255,255,255,255}

struct __gxfifo {
	u32 buf_start;
	u32 buf_end;
	u32 size;
	u32 hi_mark;
	u32 lo_mark;
	u32 rd_ptr;
	u32 wt_ptr;
	u32 rdwt_dst;
	u8 pad0[96];
};

static GXFifoObj _gxdefiniobj;
static void *_gxcurrbp = NULL;
static lwp_t _gxcurrentlwp = LWP_THREAD_NULL;

static u8 _gxcpufifoready = 0;
static u8 _gxgpfifoready = 0;
static u8 _cpgplinked = 0;
static u16 _gxgpstatus = 0;
static vu32 _gxoverflowsuspend = 0;
static vu32 _gxoverflowcount = 0;
static vu32 _gxfinished = 0;
static lwpq_t _gxwaitfinish;

static struct __gxfifo *_gpfifo = NULL;
static struct __gxfifo *_cpufifo = NULL;
static GXFifoObj *_gxoldcpufifo = NULL;
static GXBreakPtCallback breakPtCB = NULL;
static GXDrawDoneCallback drawDoneCB = NULL;
static GXDrawSyncCallback tokenCB = NULL;

static GXTexRegionCallback regionCB = NULL;
static GXTlutRegionCallback tlut_regionCB = NULL;

static vu32* const _piReg = (u32*)0xCC003000;
static vu16* const _cpReg = (u16*)0xCC000000;
static vu16* const _peReg = (u16*)0xCC001000;
static vu16* const _memReg = (u16*)0xCC004000;

static u8 _gxtevcolid[9] = {0,1,0,1,0,1,7,5,6};
static u8 _gxtexmode0ids[8] = {0x80,0x81,0x82,0x83,0xA0,0xA1,0xA2,0xA3};
static u8 _gxtexmode1ids[8] = {0x84,0x85,0x86,0x87,0xA4,0xA5,0xA6,0xA7};
static u8 _gxteximg0ids[8] = {0x88,0x89,0x8A,0x8B,0xA8,0xA9,0xAA,0xAB};
static u8 _gxteximg1ids[8] = {0x8C,0x8D,0x8E,0x8F,0xAC,0xAD,0xAE,0xAF};
static u8 _gxteximg2ids[8] = {0x90,0x91,0x92,0x93,0xB0,0xB1,0xB2,0xB3};
static u8 _gxteximg3ids[8] = {0x94,0x95,0x96,0x97,0xB4,0xB5,0xB6,0xB7};
static u8 _gxtextlutids[8] = {0x98,0x99,0x9A,0x9B,0xB8,0xB9,0xBA,0xBB};

#ifdef TEXCACHE_TESTING
static u32 _gxtexregionaddrtable[48] =
{
	0x00000000,0x00010000,0x00020000,0x00030000,
	0x00040000,0x00050000,0x00060000,0x00070000,
	0x00008000,0x00018000,0x00028000,0x00038000,
	0x00048000,0x00058000,0x00068000,0x00078000,
	0x00000000,0x00090000,0x00020000,0x000B0000,
	0x00040000,0x00098000,0x00060000,0x000B8000,
	0x00080000,0x00010000,0x000A0000,0x00030000,
	0x00088000,0x00050000,0x000A8000,0x00070000,
	0x00000000,0x00090000,0x00020000,0x000B0000,
	0x00040000,0x00090000,0x00060000,0x000B0000,
	0x00080000,0x00010000,0x000A0000,0x00030000,
	0x00080000,0x00050000,0x000A0000,0x00070000
};
#endif

struct __gxfifo _gx_dl_fifo;
u8 _gx_saved_data[1280];

extern u8 __gxregs[];
static u32 *_gx = (u32*)__gxregs;

extern void __UnmaskIrq(u32);
extern void __MaskIrq(u32);
extern long long gettime();

static s32 __gx_onreset(s32 final);

static sys_resetinfo __gx_resetinfo = {
	{},
	__gx_onreset,
	127
};

#ifdef _GP_DEBUG
extern int printk(const char *fmt,...);
#endif

static __inline__ s32 IsWriteGatherBufferEmpty()
{
	_sync();
	return (mfwpar()&0x0001);
}

static __inline__ void DisableWriteGatherPipe()
{
	mthid2((mfhid2()&~0x40000000));
}

static __inline__ void EnableWriteGatherPipe()
{
	mtwpar(0x0C008000);
	mthid2((mfhid2()|0x40000000));
}

static __inline__ void __GX_FifoLink(u8 enable)
{
	((u16*)_gx)[1] = ((((u16*)_gx)[1]&~0x10)|(_SHIFTL(enable,4,1)));
	_cpReg[1] = ((u16*)_gx)[1];
}

static __inline__ void __GX_WriteFifoIntReset(u8 inthi,u8 intlo)
{
	((u16*)_gx)[2] = ((((u16*)_gx)[2]&~0x03)|(_SHIFTL(intlo,1,1))|(inthi&1));
	_cpReg[2] = ((u16*)_gx)[2];
}

static __inline__ void __GX_WriteFifoIntEnable(u8 inthi, u8 intlo)
{
	((u16*)_gx)[1] = ((((u16*)_gx)[1]&~0x0C)|(_SHIFTL(intlo,3,1))|(_SHIFTL(inthi,2,1)));
	_cpReg[1] = ((u16*)_gx)[1];
}

static __inline__ void __GX_FifoReadEnable()
{
	((u16*)_gx)[1] = ((((u16*)_gx)[1]&~0x01)|1);
	_cpReg[1] = ((u16*)_gx)[1];
}

static __inline__ void __GX_FifoReadDisable()
{
	((u16*)_gx)[1] = ((((u16*)_gx)[1]&~0x01)|0);
	_cpReg[1] = ((u16*)_gx)[1];
}

static s32 __gx_onreset(s32 final)
{
	if(final==FALSE) {
		GX_Flush();
		GX_AbortFrame();
	}
	return 1;
}

static u8 __GX_IsGPCPUFifoLinked()
{
	return _cpgplinked;
}

static u8 __GX_IsGPFifoReady()
{
	return _gxgpfifoready;
}

static u8 __GX_IsCPUFifoReady()
{
	return _gxcpufifoready;
}

static void __GX_InitRevBits()
{
	s32 i;
	
	i=0;
	while(i<8) {
		_gx[0x10+i] = 0x40000000;
		_gx[0x18+i] = 0x80000000;
		GX_LOAD_CP_REG((0x0080|i),_gx[0x18+i]);
		i++;
	}
	
	GX_LOAD_XF_REG(0x1000,0x3f);
	GX_LOAD_XF_REG(0x1012,0x01);
	
	GX_LOAD_BP_REG(0x5800000f);

}

static void __GX_WaitAbort(u32 delay)
{
	u64 start,end;

	start = gettime();
	while(1) {
		end = gettime();
		if(diff_ticks(start,end)>=(u64)delay) break;
	};
}

static u32 __GX_ReadMemCounterU32(u32 reg)
{
	u16 lcnt,ucnt,tmp;

	tmp = _memReg[reg];
	do {
		ucnt = tmp;
		lcnt = _memReg[reg+1];
		tmp = _memReg[reg];
	} while(tmp!=ucnt);
	return (u32)((ucnt<<16)|lcnt);
}

static void __GX_WaitAbortPixelEngine()
{ 
	u32 cnt,tmp;

	cnt = __GX_ReadMemCounterU32(39);
	do {
		tmp = cnt;
		__GX_WaitAbort(8);
		cnt = __GX_ReadMemCounterU32(39);
	} while(cnt!=tmp);
}

static void __GX_Abort()
{
	if(_gx[0x1ff] && __GX_IsGPFifoReady())
		__GX_WaitAbortPixelEngine();
	
	_piReg[6] = 1;
	__GX_WaitAbort(50);
	
	_piReg[6] = 0;
	__GX_WaitAbort(5);
}

static void __GX_SaveCPUFifoAux(struct __gxfifo *fifo)
{
	u32 level;

	_CPU_ISR_Disable(level);
	GX_Flush();
	
	fifo->buf_start = (u32)MEM_PHYSICAL_TO_K0(_piReg[0x03]);
	fifo->buf_end = (u32)MEM_PHYSICAL_TO_K0(_piReg[0x04]);
	fifo->wt_ptr = (u32)MEM_PHYSICAL_TO_K0(((_piReg[0x05]&~0x04000000)));

	if(_cpgplinked) {
		fifo->rd_ptr = (u32)MEM_PHYSICAL_TO_K0(_SHIFTL(_cpReg[29],16,16)|(_cpReg[28]&0xffff));
		fifo->rdwt_dst = (_SHIFTL(_cpReg[25],16,16)|(_cpReg[24]&0xffff));
	} else {
		fifo->rdwt_dst = (fifo->wt_ptr - fifo->rd_ptr);
		if(fifo->rdwt_dst<0) fifo->rdwt_dst = (fifo->rdwt_dst + fifo->size);
	}
	
	_CPU_ISR_Restore(level);
}

static void __GX_CleanGPFifo()
{
	u32 level;

	if(!_gxgpfifoready) return;

	_CPU_ISR_Disable(level);
	__GX_FifoReadDisable();
	__GX_WriteFifoIntEnable(FALSE,FALSE);

	_gpfifo->rd_ptr = _gpfifo->wt_ptr;
	_gpfifo->rdwt_dst = 0;
	
	/* setup rd<->wd dist */
	_cpReg[24] = _SHIFTL(_gpfifo->rdwt_dst,0,16);
	_cpReg[25] = _SHIFTR(_gpfifo->rdwt_dst,16,16);

	/* setup wt ptr */
	_cpReg[26] = _SHIFTL(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->wt_ptr),0,16);
	_cpReg[27] = _SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->wt_ptr),16,16);

	/* setup rd ptr */
	_cpReg[28] = _SHIFTL(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->rd_ptr),0,16);
	_cpReg[29] = _SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->rd_ptr),16,16);
	ppcsync();

	if(_cpgplinked) {
		_cpufifo->rd_ptr = _gpfifo->rd_ptr;
		_cpufifo->wt_ptr = _gpfifo->wt_ptr;
		_cpufifo->rdwt_dst = _gpfifo->rdwt_dst;

		_piReg[5] = (_cpufifo->wt_ptr&0x1FFFFFE0);
		__GX_WriteFifoIntEnable(TRUE,FALSE);
		__GX_FifoLink(TRUE);
	}
	((u16*)_gx)[1] &= ~0x22;
	_cpReg[1] = ((u16*)_gx)[1];
	breakPtCB = NULL;
	
	__GX_WriteFifoIntReset(TRUE,TRUE);
	__GX_FifoReadEnable();
	_CPU_ISR_Restore(level);
}

static void __GXOverflowHandler()
{
	if(!_gxoverflowsuspend) {
		_gxoverflowsuspend = 1;
		_gxoverflowcount++;
		__GX_WriteFifoIntEnable(GX_DISABLE,GX_ENABLE);
		__GX_WriteFifoIntReset(GX_TRUE,GX_FALSE);
		LWP_SuspendThread(_gxcurrentlwp);
	}
}

static void __GXUnderflowHandler()
{	
	if(_gxoverflowsuspend) {
		_gxoverflowsuspend = 0;
		LWP_ResumeThread(_gxcurrentlwp);
		__GX_WriteFifoIntReset(GX_TRUE,GX_TRUE);
		__GX_WriteFifoIntEnable(GX_ENABLE,GX_DISABLE);
	}
}

static void __GXCPInterruptHandler(u32 irq,void *ctx)
{
	((u16*)_gx)[0] = _cpReg[0];

	if((((u16*)_gx)[1]&0x08) && (((u16*)_gx)[0]&0x02)) 
		__GXUnderflowHandler();

	if((((u16*)_gx)[1]&0x04) && (((u16*)_gx)[0]&0x01))
		__GXOverflowHandler();

	if((((u16*)_gx)[1]&0x20) && (((u16*)_gx)[0]&0x10)) {
		((u16*)_gx)[1] &= ~0x20;
		_cpReg[1] = ((u16*)_gx)[1];
		if(breakPtCB)
			breakPtCB();
	}
}

static void __GXTokenInterruptHandler(u32 irq,void *ctx)
{
	u16 token = _peReg[7];
	
	if(tokenCB)
		tokenCB(token);
	
	_peReg[5] = (_peReg[5]&~0x04)|0x04;	
}

static void __GXFinishInterruptHandler(u32 irq,void *ctx)
{
#ifdef _GP_DEBUG
	printf("__GXFinishInterruptHandler()\n");
#endif
	_peReg[5] = (_peReg[5]&~0x08)|0x08;	
	_gxfinished = 1;

	if(drawDoneCB)
		drawDoneCB();
	
	LWP_ThreadBroadcast(_gxwaitfinish);
}

static void __GX_PEInit()
{
	IRQ_Request(IRQ_PI_PETOKEN,__GXTokenInterruptHandler,NULL);
	__UnmaskIrq(IRQMASK(IRQ_PI_PETOKEN));

	IRQ_Request(IRQ_PI_PEFINISH,__GXFinishInterruptHandler,NULL);
	__UnmaskIrq(IRQMASK(IRQ_PI_PEFINISH));

	_peReg[5] = 0x0F;
}

static void __GX_FifoInit()
{
	IRQ_Request(IRQ_PI_CP,__GXCPInterruptHandler,NULL);
	__UnmaskIrq(IRQMASK(IRQ_PI_CP));

	_gxcpufifoready = 0;
	_gxgpfifoready = 0;
	_gxoverflowsuspend = 0;
	_cpufifo = NULL;
	_gpfifo = NULL;
	_gxcurrentlwp = LWP_GetSelf();
}

static void __GX_SetTmemConfig(u8 nr)
{
	if(nr==0) {
		//  Set_TextureImage0-3, GXTexMapID=0-3 tmem_offset=00000000, cache_width=32 kb, cache_height=32 kb, image_type=cached
		GX_LOAD_BP_REG(0x8c0d8000);
		GX_LOAD_BP_REG(0x900dc000);
		GX_LOAD_BP_REG(0x8d0d8400);
		GX_LOAD_BP_REG(0x910dc400);
		GX_LOAD_BP_REG(0x8e0d8800);
		GX_LOAD_BP_REG(0x920dc800);
		GX_LOAD_BP_REG(0x8f0d8c00);
		GX_LOAD_BP_REG(0x930dcc00);

		//  Set_TextureImage0-3, GXTexMapID=4-7 tmem_offset=00010000, cache_width=32 kb, cache_height=32 kb, image_type=cached
		GX_LOAD_BP_REG(0xac0d9000);
		GX_LOAD_BP_REG(0xb00dd000);
		GX_LOAD_BP_REG(0xad0d9400);
		GX_LOAD_BP_REG(0xb10dd400);
		GX_LOAD_BP_REG(0xae0d9800);
		GX_LOAD_BP_REG(0xb20dd800);
		GX_LOAD_BP_REG(0xaf0d9c00);
		GX_LOAD_BP_REG(0xb30ddc00);

		return;
	}

	if(nr==1) {
		//  Set_TextureImage0-3, GXTexMapID=0-3 tmem_offset=00000000, cache_width=32 kb, cache_height=32 kb, image_type=cached
		GX_LOAD_BP_REG(0x8c0d8000);
		GX_LOAD_BP_REG(0x900dc000);
		GX_LOAD_BP_REG(0x8d0d8800);
		GX_LOAD_BP_REG(0x910dc800);
		GX_LOAD_BP_REG(0x8e0d9000);
		GX_LOAD_BP_REG(0x920dd000);
		GX_LOAD_BP_REG(0x8f0d9800);
		GX_LOAD_BP_REG(0x930dd800);

		//  Set_TextureImage0-3, GXTexMapID=4-7 tmem_offset=00010000, cache_width=32 kb, cache_height=32 kb, image_type=cached
		GX_LOAD_BP_REG(0xac0da000);
		GX_LOAD_BP_REG(0xb00de000);
		GX_LOAD_BP_REG(0xad0da800);
		GX_LOAD_BP_REG(0xb10de800);
		GX_LOAD_BP_REG(0xae0db000);
		GX_LOAD_BP_REG(0xb20df000);
		GX_LOAD_BP_REG(0xaf0db800);
		GX_LOAD_BP_REG(0xb30df800);

		return;
	}

	if(nr==2) {
		//  Set_TextureImage0-3, GXTexMapID=0-3 tmem_offset=00000000, cache_width=32 kb, cache_height=32 kb, image_type=cached
		GX_LOAD_BP_REG(0x8c0d8000);
		GX_LOAD_BP_REG(0x900dc000);
		GX_LOAD_BP_REG(0x8d0d8800);
		GX_LOAD_BP_REG(0x910dc800);
		GX_LOAD_BP_REG(0x8e0d9000);
		GX_LOAD_BP_REG(0x920dd000);
		GX_LOAD_BP_REG(0x8f0d9800);
		GX_LOAD_BP_REG(0x930dd800);

		//  Set_TextureImage0-3, GXTexMapID=4-7 tmem_offset=00010000, cache_width=32 kb, cache_height=32 kb, image_type=cached
		GX_LOAD_BP_REG(0xac0da000);
		GX_LOAD_BP_REG(0xb00dc400);
		GX_LOAD_BP_REG(0xad0da800);
		GX_LOAD_BP_REG(0xb10dcc00);
		GX_LOAD_BP_REG(0xae0db000);
		GX_LOAD_BP_REG(0xb20dd400);
		GX_LOAD_BP_REG(0xaf0db800);
		GX_LOAD_BP_REG(0xb30ddc00);
		
		return;
	}
}

static GXTexRegion* __GXDefRegionCallback(GXTexObj *obj,u8 mapid)
{
	u8 fmt;
	u32 idx;
	static u32 regionA = 0;
	static u32 regionB = 0;
	GXTexRegion *ret = NULL;

	fmt = GX_GetTexFmt(obj);
	if(fmt==0x0008 || fmt==0x0009 || fmt==0x000a) {
		idx = regionB++;
		ret = (GXTexRegion*)(&_gx[0x120+((idx&0x3)*(sizeof(GXTexRegion)>>2))]);
	} else {
		idx = regionA++;
		ret = (GXTexRegion*)(&_gx[0x100+((idx&0x7)*(sizeof(GXTexRegion)>>2))]);
	}
	return ret;
}

static GXTlutRegion* __GXDefTlutRegionCallback(u32 tlut_name)
{
	return (GXTlutRegion*)(&_gx[0x150+(tlut_name*(sizeof(GXTlutRegion)>>2))]);
}

static void __GX_InitGX()
{
	s32 i;
	u32 flag;
	GXRModeObj *rmode;
	Mtx identity_matrix = 
	{
		{1,0,0,0},
		{0,1,0,0},
		{0,0,1,0}
	};
	
	rmode = VIDEO_GetPreferredMode(NULL);

	GX_SetCopyClear((GXColor)BLACK,0xffffff);
	GX_SetTexCoordGen(GX_TEXCOORD0,GX_TG_MTX2x4,GX_TG_TEX0,GX_IDENTITY);
	GX_SetTexCoordGen(GX_TEXCOORD1,GX_TG_MTX2x4,GX_TG_TEX1,GX_IDENTITY);
	GX_SetTexCoordGen(GX_TEXCOORD2,GX_TG_MTX2x4,GX_TG_TEX2,GX_IDENTITY);
	GX_SetTexCoordGen(GX_TEXCOORD3,GX_TG_MTX2x4,GX_TG_TEX3,GX_IDENTITY);
	GX_SetTexCoordGen(GX_TEXCOORD4,GX_TG_MTX2x4,GX_TG_TEX4,GX_IDENTITY);
	GX_SetTexCoordGen(GX_TEXCOORD5,GX_TG_MTX2x4,GX_TG_TEX5,GX_IDENTITY);
	GX_SetTexCoordGen(GX_TEXCOORD6,GX_TG_MTX2x4,GX_TG_TEX6,GX_IDENTITY);
	GX_SetTexCoordGen(GX_TEXCOORD7,GX_TG_MTX2x4,GX_TG_TEX7,GX_IDENTITY);
	GX_SetNumTexGens(1);
	GX_ClearVtxDesc();
	GX_InvVtxCache();
	
	GX_SetLineWidth(6,GX_TO_ZERO);
	GX_SetPointSize(6,GX_TO_ZERO);

	GX_EnableTexOffsets(GX_TEXCOORD0,GX_DISABLE,GX_DISABLE);
	GX_EnableTexOffsets(GX_TEXCOORD1,GX_DISABLE,GX_DISABLE);
	GX_EnableTexOffsets(GX_TEXCOORD2,GX_DISABLE,GX_DISABLE);
	GX_EnableTexOffsets(GX_TEXCOORD3,GX_DISABLE,GX_DISABLE);
	GX_EnableTexOffsets(GX_TEXCOORD4,GX_DISABLE,GX_DISABLE);
	GX_EnableTexOffsets(GX_TEXCOORD5,GX_DISABLE,GX_DISABLE);
	GX_EnableTexOffsets(GX_TEXCOORD6,GX_DISABLE,GX_DISABLE);
	GX_EnableTexOffsets(GX_TEXCOORD7,GX_DISABLE,GX_DISABLE);

	GX_LoadPosMtxImm(identity_matrix,GX_PNMTX0);
	GX_LoadNrmMtxImm(identity_matrix,GX_PNMTX0);
	GX_SetCurrentMtx(GX_PNMTX0);
	GX_LoadTexMtxImm(identity_matrix,GX_IDENTITY,GX_MTX3x4);
	GX_LoadTexMtxImm(identity_matrix,GX_DTTIDENTITY,GX_MTX3x4);

	GX_SetViewport(0,0,rmode->fbWidth,rmode->efbHeight,0,1);
	GX_SetCoPlanar(GX_DISABLE);
	GX_SetCullMode(GX_CULL_BACK);
	GX_SetClipMode(GX_CLIP_DISABLE);

	GX_SetScissor(0,0,rmode->fbWidth,rmode->efbHeight);
	GX_SetScissorBoxOffset(0,0);

	GX_SetNumChans(0);

	GX_SetChanCtrl(GX_COLOR0A0,GX_DISABLE,GX_SRC_REG,GX_SRC_VTX,GX_LIGHTNULL,GX_DF_NONE,GX_AF_NONE);
	GX_SetChanAmbColor(GX_COLOR0A0,(GXColor)BLACK);
	GX_SetChanMatColor(GX_COLOR0A0,(GXColor)WHITE);
	
	GX_SetChanCtrl(GX_COLOR1A1,GX_DISABLE,GX_SRC_REG,GX_SRC_VTX,GX_LIGHTNULL,GX_DF_NONE,GX_AF_NONE);
	GX_SetChanAmbColor(GX_COLOR1A1,(GXColor)BLACK);
	GX_SetChanMatColor(GX_COLOR1A1,(GXColor)WHITE);

	GX_InvalidateTexAll();
	GX_SetTexRegionCallback(__GXDefRegionCallback);
	GX_SetTlutRegionCallback(__GXDefTlutRegionCallback);

	GX_SetTevOrder(GX_TEVSTAGE0,GX_TEXCOORD0,GX_TEXMAP0,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE1,GX_TEXCOORD1,GX_TEXMAP1,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE2,GX_TEXCOORD2,GX_TEXMAP2,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE3,GX_TEXCOORD3,GX_TEXMAP3,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE4,GX_TEXCOORD4,GX_TEXMAP4,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE5,GX_TEXCOORD5,GX_TEXMAP5,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE6,GX_TEXCOORD6,GX_TEXMAP6,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE7,GX_TEXCOORD7,GX_TEXMAP7,GX_COLOR0A0);
	GX_SetTevOrder(GX_TEVSTAGE8,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetTevOrder(GX_TEVSTAGE9,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetTevOrder(GX_TEVSTAGE10,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetTevOrder(GX_TEVSTAGE11,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetTevOrder(GX_TEVSTAGE12,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetTevOrder(GX_TEVSTAGE13,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetTevOrder(GX_TEVSTAGE14,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetTevOrder(GX_TEVSTAGE15,GX_TEXCOORDNULL,GX_TEXMAP_NULL,GX_COLORNULL);
	GX_SetNumTevStages(1);
	GX_SetTevOp(GX_TEVSTAGE0,GX_REPLACE);
	GX_SetAlphaCompare(GX_ALWAYS,0,GX_AOP_AND,GX_ALWAYS,0);
	GX_SetZTexture(GX_ZT_DISABLE,GX_TF_Z8,0);
	for(i=0;i<GX_MAX_TEVSTAGE;i++) {
		GX_SetTevKColorSel(i,GX_TEV_KCSEL_1_4);
		GX_SetTevKAlphaSel(i,GX_TEV_KASEL_1);
		GX_SetTevSwapMode(i,GX_TEV_SWAP0,GX_TEV_SWAP0);
	}

	GX_SetTevSwapModeTable(GX_TEV_SWAP0,GX_CH_RED,GX_CH_GREEN,GX_CH_BLUE,GX_CH_ALPHA);
	GX_SetTevSwapModeTable(GX_TEV_SWAP1,GX_CH_RED,GX_CH_RED,GX_CH_RED,GX_CH_ALPHA);
	GX_SetTevSwapModeTable(GX_TEV_SWAP2,GX_CH_GREEN,GX_CH_GREEN,GX_CH_GREEN,GX_CH_ALPHA);
	GX_SetTevSwapModeTable(GX_TEV_SWAP3,GX_CH_BLUE,GX_CH_BLUE,GX_CH_BLUE,GX_CH_ALPHA);
	for(i=0;i<GX_MAX_TEVSTAGE;i++) {
		GX_SetTevDirect(i);
	}

	GX_SetNumIndStages(0);
	GX_SetIndTexCoordScale(GX_INDTEXSTAGE0,GX_ITS_1,GX_ITS_1);
	GX_SetIndTexCoordScale(GX_INDTEXSTAGE1,GX_ITS_1,GX_ITS_1);
	GX_SetIndTexCoordScale(GX_INDTEXSTAGE2,GX_ITS_1,GX_ITS_1);
	GX_SetIndTexCoordScale(GX_INDTEXSTAGE3,GX_ITS_1,GX_ITS_1);

	GX_SetFog(GX_FOG_NONE,0,1,0.1,1,(GXColor)BLACK);
	GX_SetFogRangeAdj(GX_DISABLE,0,NULL);

	GX_SetBlendMode(GX_BM_NONE,GX_BL_SRCALPHA,GX_BL_INVSRCALPHA,GX_LO_CLEAR);
	GX_SetColorUpdate(GX_ENABLE);
	GX_SetAlphaUpdate(GX_ENABLE);
	GX_SetZMode(GX_ENABLE,GX_LEQUAL,GX_TRUE);
	GX_SetZCompLoc(GX_TRUE);
	GX_SetDither(GX_ENABLE);
	GX_SetDstAlpha(GX_DISABLE,0);
	GX_SetPixelFmt(GX_PF_RGB8_Z24,GX_ZC_LINEAR);

	GX_SetFieldMask(GX_ENABLE,GX_ENABLE);
	
	flag = 0;
	if(rmode->viHeight==(rmode->xfbHeight<<1)) flag = 1;
	GX_SetFieldMode(rmode->field_rendering,flag);

	GX_SetCopyClear((GXColor)GX_DEFAULT_BG,0x00ffffff);
	GX_SetDispCopySrc(0,0,rmode->fbWidth,rmode->efbHeight);
	GX_SetDispCopyDst(rmode->fbWidth,rmode->efbHeight);
	GX_SetDispCopyYScale(1.0);
	GX_SetCopyClamp(GX_CLAMP_TOP|GX_CLAMP_BOTTOM);
	GX_SetCopyFilter(GX_FALSE,NULL,GX_FALSE,NULL);
	GX_SetDispCopyGamma(GX_GM_1_0);
	GX_SetDispCopyFrame2Field(GX_COPY_PROGRESSIVE);
	GX_ClearBoundingBox();
	
	GX_PokeColorUpdate(GX_TRUE);
	GX_PokeAlphaUpdate(GX_TRUE);
	GX_PokeDither(GX_FALSE);
	GX_PokeBlendMode(GX_BM_NONE,GX_BL_ZERO,GX_BL_ONE,GX_LO_SET);
	GX_PokeAlphaMode(GX_ALWAYS,0);
	GX_PokeAlphaRead(GX_READ_FF);
	GX_PokeDstAlpha(GX_DISABLE,0);
	GX_PokeZMode(GX_TRUE,GX_ALWAYS,GX_TRUE);

	GX_SetGPMetric(GX_PERF0_NONE,GX_PERF1_NONE);
	GX_ClearGPMetric();
}

static void __GX_FlushTextureState()
{
	GX_LOAD_BP_REG(_gx[0xaf]);
}

static void __GX_XfVtxSpecs()
{
	u32 xfvtxspecs = 0;
	u32 nrms,texs,cols;

	cols = 0;
	if(_gx[0x06]&0x6000) cols++;
	if(_gx[0x06]&0x18000) cols++;

	nrms = 0;
	if(_gx[0x08]==1) nrms = 1;
	else if(_gx[0x08]==2) nrms = 2;
	
	texs = 0;
	if(_gx[0x07]&0x3) texs++;
	if(_gx[0x07]&0xc) texs++;
	if(_gx[0x07]&0x30) texs++;
	if(_gx[0x07]&0xc0) texs++;
	if(_gx[0x07]&0x300) texs++;
	if(_gx[0x07]&0xc00) texs++;
	if(_gx[0x07]&0x3000) texs++;
	if(_gx[0x07]&0xc000) texs++;
	
	xfvtxspecs = (_SHIFTL(texs,4,4))|(_SHIFTL(nrms,2,2))|(cols&0x3);
	GX_LOAD_XF_REG(0x1008,xfvtxspecs);
}

static void __GX_SetMatrixIndex(u32 mtx)
{
	if(mtx<5) {
		GX_LOAD_CP_REG(0x30,_gx[0x03]);
		GX_LOAD_XF_REG(0x1018,_gx[0x03]);
	} else {
		GX_LOAD_CP_REG(0x40,_gx[0x04]);
		GX_LOAD_XF_REG(0x1019,_gx[0x04]);
	}
}

static void __GX_SendFlushPrim()
{
	u32 tmp,tmp2,cnt;

	tmp = ((u16*)_gx)[30]*((u16*)_gx)[31];

	FIFO_PUTU8(0x98);
	FIFO_PUTU16(((u16*)_gx)[30]);

	tmp2 = (tmp+3)/4;
	if(tmp>0) {
		cnt = tmp2/8;
		while(cnt) {
			FIFO_PUTU32(0);
			FIFO_PUTU32(0);
			FIFO_PUTU32(0);
			FIFO_PUTU32(0);
			FIFO_PUTU32(0);
			FIFO_PUTU32(0);
			FIFO_PUTU32(0);
			FIFO_PUTU32(0);
			cnt--;
		}
		tmp2 &= 0x0007;
		if(tmp2) {
			while(tmp2) {
				FIFO_PUTU32(0);
				tmp2--;
			}
		}
	}
	((u16*)_gx)[29] = 1;
}

static void __GX_SetVCD()
{
	GX_LOAD_CP_REG(0x50,_gx[0x06]);
	GX_LOAD_CP_REG(0x60,_gx[0x07]);
	__GX_XfVtxSpecs();
}

static void __GX_SetVAT()
{
	u8 setvtx = 0;
	s32 i;

	for(i=0;i<8;i++) {
		setvtx = (1<<i);
		if(_gx[0x02]&setvtx) {
			GX_LOAD_CP_REG((0x70|(i&7)),_gx[0x10+i]);
			GX_LOAD_CP_REG((0x80|(i&7)),_gx[0x18+i]);
			GX_LOAD_CP_REG((0x90|(i&7)),_gx[0x20+i]);
		}
	}
	_gx[0x02] = 0;
}

static void __SetSURegs(u8 texmap,u8 texcoord)
{
	u16 wd,ht;
	u8 wrap_s,wrap_t;
	u32 regA,regB;

	wd = _gx[0x40+texmap]&0x3ff;
	ht = _SHIFTR(_gx[0x40+texmap],10,10);
	wrap_s = _gx[0x50+texmap]&3;
	wrap_t = _SHIFTR(_gx[0x50+texmap],2,2);
	
	regA = 0xa0+(texcoord&0x7);
	regB = 0xb0+(texcoord&0x7);
	_gx[regA] = (_gx[regA]&~0x0000ffff)|wd;
	_gx[regB] = (_gx[regB]&~0x0000ffff)|ht;
	_gx[regA] = (_gx[regA]&~0x00010000)|(_SHIFTL(wrap_s,16,1));
	_gx[regB] = (_gx[regB]&~0x00010000)|(_SHIFTL(wrap_t,16,1));

	GX_LOAD_BP_REG(_gx[regA]);
	GX_LOAD_BP_REG(_gx[regB]);
}

static void __GX_SetSUTexRegs()
{
	u32 i;
	u32 indtev,dirtev;
	u8 texcoord,texmap;
	u32 tevreg,tevm,texcm;

	dirtev = (_SHIFTR(_gx[0xac],10,4))+1;
	indtev = _SHIFTR(_gx[0xac],16,3);

	//indirect texture order
	for(i=0;i<indtev;i++) {
		switch(i) {
			case GX_INDTEXSTAGE0:
				texmap = _gx[0xc2]&7;
				texcoord = _SHIFTR(_gx[0xc2],3,3);
				break;
			case GX_INDTEXSTAGE1:
				texmap = _SHIFTR(_gx[0xc2],6,3);
				texcoord = _SHIFTR(_gx[0xc2],9,3);
				break;
			case GX_INDTEXSTAGE2:
				texmap = _SHIFTR(_gx[0xc2],12,3);
				texcoord = _SHIFTR(_gx[0xc2],15,3);
				break;
			case GX_INDTEXSTAGE3:
				texmap = _SHIFTR(_gx[0xc2],18,3);
				texcoord = _SHIFTR(_gx[0xc2],21,3);
				break;
			default:
				texmap = 0;
				texcoord = 0;
				break;
		}

		texcm = _SHIFTL(1,texcoord,1); 
		if(!(_gx[0x05]&texcm))
			__SetSURegs(texmap,texcoord);
	}

	//direct texture order
	for(i=0;i<dirtev;i++) {
		tevreg = 0xc3+(_SHIFTR(i,1,3));
		texmap = (_gx[0x30+i]&0xff);

		if(i&1) texcoord = _SHIFTR(_gx[tevreg],15,3);
		else texcoord = _SHIFTR(_gx[tevreg],3,3);
		
		tevm = _SHIFTL(1,i,1);
		texcm = _SHIFTL(1,texcoord,1);
		if(texmap!=0xff && (_gx[0x0a]&tevm) && !(_gx[0x05]&texcm)) {
			__SetSURegs(texmap,texcoord);
		}
	}
}

static void __GX_SetGenMode()
{
	GX_LOAD_BP_REG(_gx[0xac]);
	((u16*)_gx)[29] = 0;
}

static void __GX_UpdateBPMask()
{
#if defined(HW_DOL)
	u32 i;
	u32 nbmp,nres;
	u8 ntexmap;

	nbmp = _SHIFTR(_gx[0xac],16,3);

	nres = 0;
	for(i=0;i<nbmp;i++) {
		switch(i) {
			case GX_INDTEXSTAGE0:
				ntexmap = _gx[0xc2]&7;
				break;
			case GX_INDTEXSTAGE1:
				ntexmap = _SHIFTR(_gx[0xc2],6,3);
				break;
			case GX_INDTEXSTAGE2:
				ntexmap = _SHIFTR(_gx[0xc2],12,3);
				break;
			case GX_INDTEXSTAGE3:
				ntexmap = _SHIFTR(_gx[0xc2],18,3);
				break;
			default:
				ntexmap = 0;
				break;
		}
		nres |= (1<<ntexmap);
	}

	if((_gx[0xaf]&0xff)!=nres) {
		_gx[0xaf] = (_gx[0xaf]&~0xff)|(nres&0xff);
		GX_LOAD_BP_REG(_gx[0xaf]);
	}
#endif
}

static void __GX_SetIndirectMask(u32 mask)
{
	_gx[0xaf] = ((_gx[0xaf]&~0xff)|(mask&0xff));
	GX_LOAD_BP_REG(_gx[0xaf]);
}

static void __GX_SetTexCoordGen()
{
	u32 i,mask;
	u32 texcoord;

	if(_gx[0x09]&0x02000000) GX_LOAD_XF_REG(0x103f,(_gx[0xac]&0xf));

	i = 0;
	texcoord = 0x1040;
	mask = _SHIFTR(_gx[0x09],16,8);
	while(mask) {
		if(mask&0x0001) {
			GX_LOAD_XF_REG(texcoord,_gx[0xe0+(i<<1)]);
			GX_LOAD_XF_REG((texcoord+0x10),_gx[0xe1+(i<<1)]);
		}
		mask >>= 1;
		texcoord++;
		i++;
	}
}

static void __GX_SetChanColor()
{
	if(_gx[0x09]&0x0100)
		GX_LOAD_XF_REG(0x100a,_gx[0xf0]);
	if(_gx[0x09]&0x0200)
		GX_LOAD_XF_REG(0x100b,_gx[0xf1]);
	if(_gx[0x09]&0x0400)
		GX_LOAD_XF_REG(0x100c,_gx[0xf2]);
	if(_gx[0x09]&0x0800)
		GX_LOAD_XF_REG(0x100d,_gx[0xf3]);
}

static void __GX_SetChanCntrl()
{
	u32 i,chan,mask;

	if(_gx[0x09]&0x01000000) GX_LOAD_XF_REG(0x1009,(_SHIFTR(_gx[0xac],4,3)));

	i = 0;
	chan = 0x100e;
	mask = _SHIFTR(_gx[0x09],12,4);
	while(mask) {
		if(mask&0x0001) GX_LOAD_XF_REG(chan,_gx[0xf4+i]);
		
		mask >>= 1;
		chan++;
		i++;
	}
}

static void __GX_SetDirtyState()
{
	if(_gx[0x09]&0x0001) {
		__GX_SetSUTexRegs();
	}
	if(_gx[0x09]&0x0002) {
		__GX_UpdateBPMask();
	}
	if(_gx[0x09]&0x0004) {
		__GX_SetGenMode();
	}
	if(_gx[0x09]&0x0008) {
		__GX_SetVCD();
	}
	if(_gx[0x09]&0x0010) {
		__GX_SetVAT();
	}
	if(_gx[0x09]&~0xff) {
		if(_gx[0x09]&0x0f00) {
			__GX_SetChanColor();
		}
		if(_gx[0x09]&0x0100f000) {
			__GX_SetChanCntrl();
		}
		if(_gx[0x09]&0x02ff0000) {
			__GX_SetTexCoordGen();
		}
		if(_gx[0x09]&0x04000000) {
			__GX_SetMatrixIndex(0);
			__GX_SetMatrixIndex(5);
		}
	}
	_gx[0x09] = 0;
}

static u32 __GX_GetNumXfbLines(u16 efbHeight,u32 yscale)
{
	u32 tmp,tmp1;

	tmp = (((efbHeight-1)<<8)/yscale)+1;
	if(yscale>128 && yscale<256) {
		while(yscale&0x01) yscale >>= 1;
		tmp1 = yscale*(efbHeight/yscale);
		if(!(efbHeight-tmp1)) tmp++;
	}
	if(tmp>1024) tmp = 1024;
	
	return tmp;
}

GXFifoObj* GX_Init(void *base,u32 size)
{
	s32 i,re0,re1,addr;
#ifdef TEXCACHE_TESTING
	u32 tmem;
#else
	u32 tmem_even,tmem_odd;
#endif
	u32 divis,res;
	u32 divid = TB_BUS_CLOCK;
	GXTexRegion *region = NULL;
	GXTlutRegion *tregion = NULL;

	LWP_InitQueue(&_gxwaitfinish);
	SYS_RegisterResetFunc(&__gx_resetinfo);

	memset(_gx,0,2048);
	
	__GX_FifoInit();
	GX_InitFifoBase(&_gxdefiniobj,base,size);
	GX_SetCPUFifo(&_gxdefiniobj);
	GX_SetGPFifo(&_gxdefiniobj);
	__GX_PEInit();
	EnableWriteGatherPipe();

	_gx[0x1ff] = 1;

	_gx[0xaf] = 0xff;
	_gx[0xaf] = (_gx[0xaf]&~0xff000000)|(_SHIFTL(0x0f,24,8));

	i=0;
	re0 = 0xc0;
	re1 = 0xc1;
	while(i<16) {
		addr = 0x80+i;
		_gx[addr] = (_gx[addr]&~0xff000000)|(_SHIFTL(re0,24,8));
		addr = 0x90+i;
		_gx[addr] = (_gx[addr]&~0xff000000)|(_SHIFTL(re1,24,8));
		re0 += 2; re1 += 2; i++;
	}
	
	_gx[0x05] = 0;
	_gx[0x09] = 0;

	((u8*)_gx)[0x371] = 1;
	((u8*)_gx)[0x372] = 0;
	
	_gx[0xa8] = (_gx[0xa8]&~0xff000000)|(_SHIFTL(0x20,24,8));
	_gx[0xa9] = (_gx[0xa9]&~0xff000000)|(_SHIFTL(0x21,24,8));
	_gx[0xaa] = (_gx[0xaa]&~0xff000000)|(_SHIFTL(0x22,24,8));
	_gx[0xac] = (_gx[0xac]&~0xff000000)|(_SHIFTL(0x00,24,8));

	i=0;
	re0 = 0x30;
	re1 = 0x31;
	while(i<8) {
		addr = 0xa0+i;
		_gx[addr] = (_gx[addr]&~0xff000000)|(_SHIFTL(re0,24,8));
		addr = 0xb0+i;
		_gx[addr] = (_gx[addr]&~0xff000000)|(_SHIFTL(re1,24,8));
		re0 += 2; re1 += 2; i++;
	}
	
	_gx[0xb8] = (_gx[0xb8]&~0xff000000)|(_SHIFTL(0x40,24,8));
	_gx[0xb9] = (_gx[0xb9]&~0xff000000)|(_SHIFTL(0x41,24,8));
	_gx[0xba] = (_gx[0xba]&~0xff000000)|(_SHIFTL(0x42,24,8));
	_gx[0xbb] = (_gx[0xbb]&~0xff000000)|(_SHIFTL(0x43,24,8));

	i=0;
	re0 = 0x25;
	while(i<11) {
		addr = 0xc0+i;
		_gx[addr] = (_gx[addr]&~0xff000000)|(_SHIFTL(re0,24,8));
		re0++; i++;
	}

	divis = 500;
	res = (u32)(divid/divis);
	__GX_FlushTextureState();
	GX_LOAD_BP_REG(0x69000000|((_SHIFTR(res,11,24))|0x0400));
	
	divis = 4224;
	res = (u32)(res/divis);
	__GX_FlushTextureState();
	GX_LOAD_BP_REG(0x46000000|(res|0x0200));

	i=0;
	re0 = 0xf6;
	while(i<8) {
		addr = 0xd0+i;
		_gx[addr] = (_gx[addr]&~0xff000000)|(_SHIFTL(re0,24,8));
		re0++; i++;
	}

	_gx[0x0a] = 0;
	_gx[0x0b] = GX_PERF0_NONE;
	_gx[0x0c] = GX_PERF1_NONE;
	_gx[0x0d] = 0;

	__GX_InitRevBits();

	i=0;
	while(i<16) {
		_gx[0x30+i] = 0xff;
		i++;
	}

#ifdef TEXCACHE_TESTING
	i = 0;
	while(i<8) {
		region = (GXTexRegion*)(&_gx[0x100+(i*(sizeof(GXTexRegion)>>2))]);
		GX_InitTexCacheRegion(region,GX_FALSE,_gxtexregionaddrtable[i+0],GX_TEXCACHE_32K,_gxtexregionaddrtable[i+8],GX_TEXCACHE_32K);

		region = (GXTexRegion*)(&_gx[0x120+(i*(sizeof(GXTexRegion)>>2))]);
		GX_InitTexCacheRegion(region,GX_FALSE,_gxtexregionaddrtable[i+16],GX_TEXCACHE_32K,_gxtexregionaddrtable[i+24],GX_TEXCACHE_32K);

		region = (GXTexRegion*)(&_gx[0x140+(i*(sizeof(GXTexRegion)>>2))]);
		GX_InitTexCacheRegion(region,GX_TRUE,_gxtexregionaddrtable[i+32],GX_TEXCACHE_32K,_gxtexregionaddrtable[i+40],GX_TEXCACHE_32K);

		i++;
	}

	i=0;
	while(i<16) {
		tmem = 0x000C0000+(i<<13);
		tregion = (GXTlutRegion*)(&_gx[0x160+(i*(sizeof(GXTlutRegion)>>2))]);
		GX_InitTlutRegion(tregion,tmem,GX_TLUT_256);
		i++;
	}

	i=0;
	while(i<4) {
		tmem = 0x000E0000+(i<<15);
		tregion = (GXTlutRegion*)(&_gx[0x160+((i+16)*(sizeof(GXTlutRegion)>>2))]);
		GX_InitTlutRegion(tregion,tmem,GX_TLUT_1K);
		i++;
	}
#else
	for(i=0;i<8;i++) {
		tmem_even = tmem_odd = (i<<15);
		region = (GXTexRegion*)(&_gx[0x100+(i*(sizeof(GXTexRegion)>>2))]);
		GX_InitTexCacheRegion(region,GX_FALSE,tmem_even,GX_TEXCACHE_32K,(tmem_odd+0x00080000),GX_TEXCACHE_32K);
	}
	for(i=0;i<4;i++) {
		tmem_even = ((0x08+(i<<1))<<15);
		tmem_odd = ((0x09+(i<<1))<<15);
		region = (GXTexRegion*)(&_gx[0x120+(i*(sizeof(GXTexRegion)>>2))]);
		GX_InitTexCacheRegion(region,GX_FALSE,tmem_even,GX_TEXCACHE_32K,tmem_odd,GX_TEXCACHE_32K);
	}
	for(i=0;i<16;i++) {
		tmem_even = (i<<13)+0x000C0000;
		tregion = (GXTlutRegion*)(&_gx[0x150+(i*(sizeof(GXTlutRegion)>>2))]);
		GX_InitTlutRegion(tregion,tmem_even,GX_TLUT_256);
	}
	for(i=0;i<4;i++) {
		tmem_even = (i<<15)+0x000E0000;
		tregion = (GXTlutRegion*)(&_gx[0x150+((i+16)*(sizeof(GXTlutRegion)>>2))]);
		GX_InitTlutRegion(tregion,tmem_even,GX_TLUT_1K);
	}
#endif
	_cpReg[3] = 0;
	GX_LOAD_CP_REG(0x20,0x00000000);
	GX_LOAD_XF_REG(0x1006,0x0);
	
	GX_LOAD_BP_REG(0x23000000);
	GX_LOAD_BP_REG(0x24000000);
	GX_LOAD_BP_REG(0x67000000);

	__GX_SetIndirectMask(0);
#ifdef TEXCACHE_TESTING
	__GX_SetTmemConfig(2);
#else
	__GX_SetTmemConfig(0);
#endif
	__GX_InitGX();
	
	return &_gxdefiniobj;
}

void GX_InitFifoBase(GXFifoObj *fifo,void *base,u32 size)
{
	struct __gxfifo *ptr = (struct __gxfifo*)fifo;

	if(!ptr || size<GX_FIFO_MINSIZE || ptr==_cpufifo || ptr==_gpfifo) return;

	ptr->buf_start = (u32)base;
	ptr->buf_end = (u32)base + size - 4;
	ptr->size = size;
	ptr->rdwt_dst = 0;

	GX_InitFifoLimits(fifo,(size-GX_FIFO_HIWATERMARK),((size>>1)&0x7fffffe0));
	GX_InitFifoPtrs(fifo,base,base);
}

void GX_InitFifoLimits(GXFifoObj *fifo,u32 hiwatermark,u32 lowatermark)
{
	struct __gxfifo *ptr = (struct __gxfifo*)fifo;
	
	ptr->hi_mark = hiwatermark;
	ptr->lo_mark = lowatermark;
}

void GX_InitFifoPtrs(GXFifoObj *fifo,void *rd_ptr,void *wt_ptr)
{
	u32 level;
	s32 rdwt_dst;
	struct __gxfifo *ptr = (struct __gxfifo*)fifo;

	_CPU_ISR_Disable(level);
	rdwt_dst =  wt_ptr-rd_ptr;
	ptr->rd_ptr = (u32)rd_ptr;
	ptr->wt_ptr = (u32)wt_ptr;
	ptr->rdwt_dst = rdwt_dst;
	if(rdwt_dst<0) {
		rdwt_dst += ptr->size;
		ptr->rd_ptr = rdwt_dst;
	}
	_CPU_ISR_Restore(level);
}

void GX_GetFifoPtrs(GXFifoObj *fifo,void **rd_ptr,void **wt_ptr)
{
	struct __gxfifo *ptr = (struct __gxfifo*)fifo;

	if(_cpufifo==ptr) ptr->wt_ptr = (u32)MEM_PHYSICAL_TO_K0((_piReg[5]&~0x04000000));
	if(_gpfifo==ptr) {
		ptr->rd_ptr = MEM_VIRTUAL_TO_PHYSICAL(_SHIFTL(_cpReg[29],16,16)|(_cpReg[28]&0xffff));
		ptr->rdwt_dst = (_SHIFTL(_cpReg[25],16,16)|(_cpReg[24]&0xffff));
	} else {
		ptr->rdwt_dst = (ptr->wt_ptr - ptr->rd_ptr);
		if(ptr->rd_ptr<0) ptr->rdwt_dst += ptr->size;
	}
	*rd_ptr = (void*)ptr->rd_ptr;
	*wt_ptr = (void*)ptr->wt_ptr;
}

void GX_SetCPUFifo(GXFifoObj *fifo)
{
	u32 level;
	
	_CPU_ISR_Disable(level);
	_gxcpufifoready = 0;
	_cpufifo = (struct __gxfifo*)fifo;
	if(_cpufifo==_gpfifo) {
		_piReg[3] = MEM_VIRTUAL_TO_PHYSICAL(_cpufifo->buf_start);
		_piReg[4] = MEM_VIRTUAL_TO_PHYSICAL(_cpufifo->buf_end);
		_piReg[5] = (_cpufifo->wt_ptr&0x1FFFFFE0);
		_cpgplinked = 1;
		
		__GX_WriteFifoIntReset(GX_TRUE,GX_TRUE);
		__GX_WriteFifoIntEnable(GX_ENABLE,GX_DISABLE);
		__GX_FifoLink(GX_TRUE);

		_CPU_ISR_Restore(level);
		return;
	}
	if(_cpgplinked) {
		__GX_FifoLink(GX_FALSE);
		_cpgplinked = 0;
	}
	__GX_WriteFifoIntEnable(GX_DISABLE,GX_DISABLE);

	_piReg[3] = MEM_VIRTUAL_TO_PHYSICAL(_cpufifo->buf_start);
	_piReg[4] = MEM_VIRTUAL_TO_PHYSICAL(_cpufifo->buf_end);
	_piReg[5] = (_cpufifo->wt_ptr&0x1FFFFFE0);
	_gxcpufifoready = 1;
	_CPU_ISR_Restore(level);
}

GXFifoObj* GX_GetCPUFifo()
{
	return (GXFifoObj*)_cpufifo;
}

void GX_SetGPFifo(GXFifoObj *fifo)
{
	u32 level;

	_CPU_ISR_Disable(level);
	_gxgpfifoready = 0;
	__GX_FifoReadDisable();
	__GX_WriteFifoIntEnable(GX_DISABLE,GX_DISABLE);
	
	_gpfifo = (struct __gxfifo*)fifo;
	
	/* setup fifo base */
	_cpReg[16] = _SHIFTL(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->buf_start),0,16);
	_cpReg[17] = _SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->buf_start),16,16);
	
	/* setup fifo end */
	_cpReg[18] = _SHIFTL(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->buf_end),0,16);
	_cpReg[19] = _SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->buf_end),16,16);
	
	/* setup hiwater mark */
	_cpReg[20] = _SHIFTL(_gpfifo->hi_mark,0,16);
	_cpReg[21] = _SHIFTR(_gpfifo->hi_mark,16,16);
	
	/* setup lowater mark */
	_cpReg[22] = _SHIFTL(_gpfifo->lo_mark,0,16);
	_cpReg[23] = _SHIFTR(_gpfifo->lo_mark,16,16);
	
	/* setup rd<->wd dist */
	_cpReg[24] = _SHIFTL(_gpfifo->rdwt_dst,0,16);
	_cpReg[25] = _SHIFTR(_gpfifo->rdwt_dst,16,16);
	
	/* setup wt ptr */
	_cpReg[26] = _SHIFTL(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->wt_ptr),0,16);
	_cpReg[27] = _SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->wt_ptr),16,16);
	
	/* setup rd ptr */
	_cpReg[28] = _SHIFTL(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->rd_ptr),0,16);
	_cpReg[29] = _SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(_gpfifo->rd_ptr),16,16);

	if(_cpufifo==_gpfifo) {
		_cpgplinked = 1;
		__GX_WriteFifoIntEnable(GX_ENABLE,GX_DISABLE);
		__GX_FifoLink(GX_TRUE);
	} else {
		_cpgplinked = 0;
		__GX_WriteFifoIntEnable(GX_DISABLE,GX_DISABLE);
		__GX_FifoLink(GX_FALSE);
	}
	__GX_WriteFifoIntReset(GX_TRUE,GX_TRUE);
	__GX_FifoReadEnable();
	_gxgpfifoready = 1;
	_CPU_ISR_Restore(level);
}

GXFifoObj* GX_GetGPFifo()
{
	return (GXFifoObj*)_gpfifo;
}

void GX_SaveCPUFifo(GXFifoObj *fifo)
{
	struct __gxfifo *ptr = (struct __gxfifo*)fifo;
	__GX_SaveCPUFifoAux(ptr);
}

u32 GX_GetOverflowCount()
{
	return _gxoverflowcount;
}

u32 GX_ResetOverflowCount()
{
	u32 ret = _gxoverflowcount;
	_gxoverflowcount = 0;
	return ret;
}

lwp_t GX_GetCurrentGXThread()
{
	return _gxcurrentlwp;
}

lwp_t GX_SetCurrentGXThread()
{
	u32 level;

	_CPU_ISR_Disable(level);
	lwp_t ret = _gxcurrentlwp;
	_gxcurrentlwp = LWP_GetSelf();
	_CPU_ISR_Restore(level);

	return ret;
}

volatile void* GX_RedirectWriteGatherPipe(void *ptr)
{
	u32 level;

	_CPU_ISR_Disable(level);
	GX_Flush();
	while(!IsWriteGatherBufferEmpty());

	mtwpar(0x0C008000);
	if(_cpgplinked) {
		__GX_FifoLink(GX_FALSE);
		__GX_WriteFifoIntEnable(GX_DISABLE,GX_DISABLE);
	}
	_cpufifo->wt_ptr = (u32)MEM_PHYSICAL_TO_K0(_piReg[5]&~0x04000000);
	
	_piReg[3] = 0;
	_piReg[4] = 0x04000000;
	_piReg[5] = (((u32)ptr&0x3FFFFFE0)&~0x04000000);
	_sync();
	
	_CPU_ISR_Restore(level);

	return (volatile void*)0x0C008000;
}

void GX_RestoreWriteGatherPipe()
{
	u32 level;

	_CPU_ISR_Disable(level);
	
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	
	ppcsync();
	while(!IsWriteGatherBufferEmpty());
	
	mtwpar(0x0C008000);
	_piReg[3] = MEM_VIRTUAL_TO_PHYSICAL(_cpufifo->buf_start);
	_piReg[4] = MEM_VIRTUAL_TO_PHYSICAL(_cpufifo->buf_end);
	_piReg[5] = (((u32)_cpufifo->wt_ptr&0x3FFFFFE0)&~0x04000000);
	if(_cpgplinked) {
		__GX_WriteFifoIntReset(GX_TRUE,GX_TRUE);
		__GX_WriteFifoIntEnable(GX_ENABLE,GX_DISABLE);
		__GX_FifoLink(GX_TRUE);
	}	
	_sync();
	_CPU_ISR_Restore(level);
}

void GX_Flush()
{
	if(_gx[0x09]) 
		__GX_SetDirtyState();

	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	FIFO_PUTU32(0);
	
	ppcsync();
}

void GX_EnableBreakPt(void *break_pt)
{
	u32 level = 0;
	_CPU_ISR_Disable(level);
	__GX_FifoReadDisable();
	_cpReg[30] = _SHIFTL(MEM_VIRTUAL_TO_PHYSICAL(break_pt),0,16);
	_cpReg[31] = _SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(break_pt),16,16);
	((u16*)_gx)[1] = (((u16*)_gx)[1]&~0x22)|0x22;
	_cpReg[1] = ((u16*)_gx)[1];
	_gxcurrbp = break_pt;
	__GX_FifoReadEnable();
 	_CPU_ISR_Restore(level);
}

void GX_DisableBreakPt()
{
	u32 level = 0;
	_CPU_ISR_Disable(level);
	((u16*)_gx)[1] = (((u16*)_gx)[1]&~0x22);
	_cpReg[1] = ((u16*)_gx)[1];
	_gxcurrbp = NULL;
	_CPU_ISR_Restore(level);
}

#if defined(HW_DOL)
void GX_AbortFrame()
{
	_piReg[6] = 1;
	__GX_WaitAbort(50);
	_piReg[6] = 0;
	__GX_WaitAbort(5);

	if(__GX_IsGPFifoReady())
		__GX_CleanGPFifo();
}
#elif defined(HW_RVL)
void GX_AbortFrame()
{
	__GX_Abort();
	if(__GX_IsGPFifoReady()) {
		__GX_CleanGPFifo();
		__GX_InitRevBits();
		
		_gx[0x09] = 0;
		GX_Flush();
	}
}
#endif

void GX_SetDrawSync(u16 token)
{
	u32 level = 0;
	_CPU_ISR_Disable(level);
	GX_LOAD_BP_REG(0x48000000 | token);
	GX_LOAD_BP_REG(0x47000000 | token);
	GX_Flush();
	_CPU_ISR_Restore(level);
}

u16 GX_GetDrawSync()
{
	return _peReg[7];
}

void GX_SetDrawDone()
{
	u32 level;
	_CPU_ISR_Disable(level);
	GX_LOAD_BP_REG(0x45000002); // set draw done!
	GX_Flush();
	_gxfinished = 0;
	_CPU_ISR_Restore(level);
}


void GX_WaitDrawDone()
{
	u32 level;
#ifdef _GP_DEBUG
	printf("GX_WaitDrawDone()\n\n");
#endif
	_CPU_ISR_Disable(level);
	while(!_gxfinished)
		LWP_ThreadSleep(_gxwaitfinish);
	_CPU_ISR_Restore(level);
}

void GX_DrawDone()
{
	u32 level;

	_CPU_ISR_Disable(level);
	GX_LOAD_BP_REG(0x45000002); // set draw done!
	GX_Flush();

	_gxfinished = 0;
	_CPU_ISR_Flash(level);

	while(!_gxfinished)
		LWP_ThreadSleep(_gxwaitfinish);
	_CPU_ISR_Restore(level);
}

GXDrawDoneCallback GX_SetDrawDoneCallback(GXDrawDoneCallback cb)
{
	u32 level;

	_CPU_ISR_Disable(level);
	GXDrawDoneCallback ret = drawDoneCB;
	drawDoneCB = cb;
	_CPU_ISR_Restore(level);
	return ret;
}

GXDrawSyncCallback GX_SetDrawSyncCallback(GXDrawSyncCallback cb)
{
	u32 level;

	_CPU_ISR_Disable(level);
	GXDrawSyncCallback ret = tokenCB;
	tokenCB = cb;
	_CPU_ISR_Restore(level);
	return ret;
}

GXBreakPtCallback GX_SetBreakPtCallback(GXBreakPtCallback cb)
{
	u32 level;

	_CPU_ISR_Disable(level);
	GXBreakPtCallback ret = breakPtCB;
	breakPtCB = cb;
	_CPU_ISR_Restore(level);
	return ret;
}

void GX_PixModeSync()
{
	GX_LOAD_BP_REG(_gx[0xbb]);
}

void GX_TexModeSync()
{
	GX_LOAD_BP_REG(0x63000000);
}

void GX_SetMisc(u32 token,u32 value)
{
	u32 cnt;

	if(token==GX_MT_XF_FLUSH) {
		((u16*)_gx)[30] = value;
		cnt = cntlzw(((u16*)_gx)[30]);
		((u16*)_gx)[28] = _SHIFTR(cnt,5,16);

		((u16*)_gx)[29] = 1;
		if(!((u16*)_gx)[30]) return;

		_gx[0x09] |= 0x0008;
	} else if(token==GX_MT_DL_SAVE_CTX) {
		((u8*)_gx)[0x371] = (value&0xff);
	}
	return;
}

void GX_SetViewportJitter(f32 xOrig,f32 yOrig,f32 wd,f32 ht,f32 nearZ,f32 farZ,u32 field)
{
	f32 x0,y0,x1,y1,n,f,z;
	static f32 Xfactor = 0.5;
	static f32 Yfactor = 342.0;
	static f32 Zfactor = 16777215.0;
	
	if(!field) yOrig -= Xfactor;
	
	x0 = wd*Xfactor;
	y0 = (-ht)*Xfactor;
	x1 = (xOrig+(wd*Xfactor))+Yfactor;
	y1 = (yOrig+(ht*Xfactor))+Yfactor;
	n = Zfactor*nearZ;
	f = Zfactor*farZ;
	z = f-n;
	
	GX_LOAD_XF_REGS(0x101a,6);
	FIFO_PUTF32(x0);
	FIFO_PUTF32(y0);
	FIFO_PUTF32(z);
	FIFO_PUTF32(x1);
	FIFO_PUTF32(y1);
	FIFO_PUTF32(f);
}

void GX_SetViewport(f32 xOrig,f32 yOrig,f32 wd,f32 ht,f32 nearZ,f32 farZ)
{
	GX_SetViewportJitter(xOrig,yOrig,wd,ht,nearZ,farZ,1);
}

void GX_LoadProjectionMtx(Mtx44 mt,u8 type)
{
	f32 tmp[7];

	((u32*)((void*)tmp))[6] = (u32)type;
	tmp[0] = mt[0][0];
	tmp[2] = mt[1][1];
	tmp[4] = mt[2][2];
	tmp[5] = mt[2][3];
	
	switch(type) {
		case GX_PERSPECTIVE:
			tmp[1] = mt[0][2];
			tmp[3] = mt[1][2];
			break;
		case GX_ORTHOGRAPHIC:
			tmp[1] = mt[0][3];
			tmp[3] = mt[1][3];
			break;
	}

	GX_LOAD_XF_REGS(0x1020,7);
	FIFO_PUTF32(tmp[0]);
	FIFO_PUTF32(tmp[1]);
	FIFO_PUTF32(tmp[2]);
	FIFO_PUTF32(tmp[3]);
	FIFO_PUTF32(tmp[4]);
	FIFO_PUTF32(tmp[5]);
	FIFO_PUTF32(tmp[6]);
}

static void __GetImageTileCount(u32 fmt,u16 wd,u16 ht,u32 *xtiles,u32 *ytiles,u32 *zplanes)
{
	u32 xshift,yshift,tile;
	
	switch(fmt) {
		case GX_TF_I4:
		case GX_TF_IA4:
		case GX_CTF_R4:
		case GX_CTF_RA4:
		case GX_CTF_Z4:
			xshift = 3;
			yshift = 3;
			break;
		case GX_TF_Z8:
		case GX_TF_I8:
		case GX_TF_IA8:
		case GX_CTF_RA8:
		case GX_CTF_A8:
		case GX_CTF_R8:
		case GX_CTF_G8:
		case GX_CTF_B8:
		case GX_CTF_RG8:
		case GX_CTF_GB8:
		case GX_CTF_Z8M:
		case GX_CTF_Z8L:
			xshift = 3;
			yshift = 2;
			break;
		case GX_TF_Z16:
		case GX_TF_Z24X8:
		case GX_CTF_Z16L:
		case GX_TF_RGB565:
		case GX_TF_RGB5A3:
		case GX_TF_RGBA8:
			xshift = 2;
			yshift = 2;
			break;
		default:
			xshift = 0;
			yshift = 0;
			break;
	}
	
	if(!(wd&0xffff)) wd = 1;
	if(!(ht&0xffff)) ht = 1;

	wd &= 0xffff;
	tile = (wd+((1<<xshift)-1))>>xshift;
	*xtiles = tile;

	ht &= 0xffff;
	tile = (ht+((1<<yshift)-1))>>yshift;
	*ytiles = tile;

	*zplanes = 1;
	if(fmt==GX_TF_RGBA8 || fmt==GX_TF_Z24X8) *zplanes = 2;
}

void GX_SetCopyClear(GXColor color,u32 zvalue)
{
	u32 val;

	val = (_SHIFTL(color.a,8,8))|(color.r&0xff);
	GX_LOAD_BP_REG(0x4f000000|val);

	val = (_SHIFTL(color.g,8,8))|(color.b&0xff);
	GX_LOAD_BP_REG(0x50000000|val);

	val = zvalue&0x00ffffff;
	GX_LOAD_BP_REG(0x51000000|val);
}

void GX_SetCopyClamp(u8 clamp)
{
	_gx[0xab] = (_gx[0xab]&~1)|(clamp&1);
	_gx[0xab] = (_gx[0xab]&~2)|(clamp&2);
}

void GX_SetDispCopyGamma(u8 gamma)
{
	_gx[0xab] = (_gx[0xab]&~0x180)|(_SHIFTL(gamma,7,2));
}

void GX_SetCopyFilter(u8 aa,u8 sample_pattern[12][2],u8 vf,u8 vfilter[7])
{
	u32 reg01=0,reg02=0,reg03=0,reg04=0,reg53=0,reg54=0;

	if(aa) {
		reg01 = sample_pattern[0][0]&0xf;
		reg01 = (reg01&~0xf0)|(_SHIFTL(sample_pattern[0][1],4,4));
		reg01 = (reg01&~0xf00)|(_SHIFTL(sample_pattern[1][0],8,4));
		reg01 = (reg01&~0xf000)|(_SHIFTL(sample_pattern[1][1],12,4));
		reg01 = (reg01&~0xf0000)|(_SHIFTL(sample_pattern[2][0],16,4));
		reg01 = (reg01&~0xf00000)|(_SHIFTL(sample_pattern[2][1],20,4));
		reg01 = (reg01&~0xff000000)|(_SHIFTL(0x01,24,8));

		reg02 = sample_pattern[3][0]&0xf;
		reg02 = (reg02&~0xf0)|(_SHIFTL(sample_pattern[3][1],4,4));
		reg02 = (reg02&~0xf00)|(_SHIFTL(sample_pattern[4][0],8,4));
		reg02 = (reg02&~0xf000)|(_SHIFTL(sample_pattern[4][1],12,4));
		reg02 = (reg02&~0xf0000)|(_SHIFTL(sample_pattern[5][0],16,4));
		reg02 = (reg02&~0xf00000)|(_SHIFTL(sample_pattern[5][1],20,4));
		reg02 = (reg02&~0xff000000)|(_SHIFTL(0x02,24,8));

		reg03 = sample_pattern[6][0]&0xf;
		reg03 = (reg03&~0xf0)|(_SHIFTL(sample_pattern[6][1],4,4));
		reg03 = (reg03&~0xf00)|(_SHIFTL(sample_pattern[7][0],8,4));
		reg03 = (reg03&~0xf000)|(_SHIFTL(sample_pattern[7][1],12,4));
		reg03 = (reg03&~0xf0000)|(_SHIFTL(sample_pattern[8][0],16,4));
		reg03 = (reg03&~0xf00000)|(_SHIFTL(sample_pattern[8][1],20,4));
		reg03 = (reg03&~0xff000000)|(_SHIFTL(0x03,24,8));
	
		reg04 = sample_pattern[9][0]&0xf;
		reg04 = (reg04&~0xf0)|(_SHIFTL(sample_pattern[9][1],4,4));
		reg04 = (reg04&~0xf00)|(_SHIFTL(sample_pattern[10][0],8,4));
		reg04 = (reg04&~0xf000)|(_SHIFTL(sample_pattern[10][1],12,4));
		reg04 = (reg04&~0xf0000)|(_SHIFTL(sample_pattern[11][0],16,4));
		reg04 = (reg04&~0xf00000)|(_SHIFTL(sample_pattern[11][1],20,4));
		reg04 = (reg04&~0xff000000)|(_SHIFTL(0x04,24,8));
	} else {
		reg01 = 0x01666666;
		reg02 = 0x02666666;
		reg03 = 0x03666666;
		reg04 = 0x04666666;
	}
	GX_LOAD_BP_REG(reg01);
	GX_LOAD_BP_REG(reg02);
	GX_LOAD_BP_REG(reg03);
	GX_LOAD_BP_REG(reg04);

	reg53 = 0x53595000;
	reg54 = 0x54000015;
	if(vf) {
		reg53 = 0x53000000|(vfilter[0]&0x3f);
		reg53 = (reg53&~0xfc0)|(_SHIFTL(vfilter[1],6,6));
		reg53 = (reg53&~0x3f000)|(_SHIFTL(vfilter[2],12,6));
		reg53 = (reg53&~0xfc0000)|(_SHIFTL(vfilter[3],18,6));
		
		reg54 = 0x54000000|(vfilter[4]&0x3f);
		reg54 = (reg54&~0xfc0)|(_SHIFTL(vfilter[5],6,6));
		reg54 = (reg54&~0x3f000)|(_SHIFTL(vfilter[6],12,6));
	}
	GX_LOAD_BP_REG(reg53);
	GX_LOAD_BP_REG(reg54);
}

void GX_SetDispCopyFrame2Field(u8 mode)
{
	_gx[0xab] = (_gx[0xab]&~0x3000)|(_SHIFTL(mode,12,2));
}

u32 GX_SetDispCopyYScale(f32 yscale)
{
	u32 ht,yScale = 0;

	yScale = ((u32)(256.0f/yscale))&0x1ff;
	GX_LOAD_BP_REG(0x4e000000|yScale);

	_gx[0xab] = (_gx[0xab]&~0x400)|(_SHIFTL(((256-yScale)>0),10,1));
	ht = _SHIFTR(_gx[0xcc],12,10)+1;
	return __GX_GetNumXfbLines(ht,yScale);
}

void GX_SetDispCopyDst(u16 wd,u16 ht)
{
	_gx[0xcd] = (_gx[0xcd]&~0x3ff)|(_SHIFTR(wd,4,10));
	_gx[0xcd] = (_gx[0xcd]&~0xff000000)|(_SHIFTL(0x4d,24,8));
}

void GX_SetDispCopySrc(u16 left,u16 top,u16 wd,u16 ht)
{
	_gx[0xcb] = (_gx[0xcb]&~0x00ffffff)|XY(left,top);
	_gx[0xcb] = (_gx[0xcb]&~0xff000000)|(_SHIFTL(0x49,24,8));
	_gx[0xcc] = (_gx[0xcc]&~0x00ffffff)|XY((wd-1),(ht-1));
	_gx[0xcc] = (_gx[0xcc]&~0xff000000)|(_SHIFTL(0x4a,24,8));
}

void GX_CopyDisp(void *dest,u8 clear)
{
	u8 clflag;
	u32 val;

	if(clear) {
		val= (_gx[0xb8]&~0xf)|0xf;
		GX_LOAD_BP_REG(val);
		val = (_gx[0xb9]&~0x3);
		GX_LOAD_BP_REG(val);
	}
	
	clflag = 0;
	if(clear || (_gx[0xbb]&0x7)==0x0003) {
		if(_gx[0xbb]&0x40) {
			clflag = 1;
			val = (_gx[0xbb]&~0x40);
			GX_LOAD_BP_REG(val);
		}
	}
	
	GX_LOAD_BP_REG(_gx[0xcb]);  // set source top
	GX_LOAD_BP_REG(_gx[0xcc]);

	GX_LOAD_BP_REG(_gx[0xcd]);

	val = 0x4b000000|(_SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(dest),5,24));
	GX_LOAD_BP_REG(val);

	_gx[0xab] = (_gx[0xab]&~0x800)|(_SHIFTL(clear,11,1));
	_gx[0xab] = (_gx[0xab]&~0x4000)|0x4000;
	_gx[0xab] = (_gx[0xab]&~0xff000000)|(_SHIFTL(0x52,24,8));
	
	GX_LOAD_BP_REG(_gx[0xab]);

	if(clear) {
		GX_LOAD_BP_REG(_gx[0xb8]);
		GX_LOAD_BP_REG(_gx[0xb9]);
	}
	if(clflag) GX_LOAD_BP_REG(_gx[0xbb]);
}

void GX_CopyTex(void *dest,u8 clear)
{
	u8 clflag;
	u32 val;

	if(clear) {
		val = (_gx[0xb8]&~0xf)|0xf;
		GX_LOAD_BP_REG(val);
		val = (_gx[0xb9]&~0x3);
		GX_LOAD_BP_REG(val);
	}

	clflag = 0;
	val = _gx[0xbb];
	if(((u8*)_gx)[0x370] && (val&0x7)!=0x0003) {
		clflag = 1;
		val = (val&~0x7)|0x0003;
	}
	if(clear || (val&0x7)==0x0003) {
		if(val&0x40) {
			clflag = 1;
			val = (val&~0x40);
		}
	}
	if(clflag) GX_LOAD_BP_REG(val);

	val = 0x4b000000|(_SHIFTR(MEM_VIRTUAL_TO_PHYSICAL(dest),5,24));
	
	GX_LOAD_BP_REG(_gx[0xd8]);
	GX_LOAD_BP_REG(_gx[0xd9]);
	GX_LOAD_BP_REG(_gx[0xda]);
	GX_LOAD_BP_REG(val);

	_gx[0xdb] = (_gx[0xdb]&~0x800)|(_SHIFTL(clear,11,1));
	_gx[0xdb] = (_gx[0xdb]&~0x4000);
	_gx[0xdb] = (_gx[0xdb]&~0xff000000)|(_SHIFTL(0x52,24,8));
	GX_LOAD_BP_REG(_gx[0xdb]);

	if(clear) {
		GX_LOAD_BP_REG(_gx[0xb8]);
		GX_LOAD_BP_REG(_gx[0xb9]);
	}
	if(clflag) GX_LOAD_BP_REG(_gx[0xbb]);
}

void GX_SetTexCopySrc(u16 left,u16 top,u16 wd,u16 ht)
{
	_gx[0xd8] = (_gx[0xd8]&~0x00ffffff)|XY(left,top);
	_gx[0xd8] = (_gx[0xd8]&~0xff000000)|(_SHIFTL(0x49,24,8));
	_gx[0xd9] = (_gx[0xd9]&~0x00ffffff)|XY((wd-1),(ht-1));
	_gx[0xd9] = (_gx[0xd9]&~0xff000000)|(_SHIFTL(0x4a,24,8));
}

void GX_SetTexCopyDst(u16 wd,u16 ht,u32 fmt,u8 mipmap)
{
	u8 lfmt = fmt&0xf;
	u32 xtiles,ytiles,zplanes;

	__GetImageTileCount(fmt,wd,ht,&xtiles,&ytiles,&zplanes);
	_gx[0xda] = (_gx[0xda]&~0x3ff)|((xtiles*zplanes)&0x3ff);

	if(fmt==GX_TF_Z16) lfmt = 11;
	if(fmt==GX_CTF_YUVA8 || (fmt>=GX_TF_I4 && fmt<GX_TF_RGB565)) _gx[0xdb] = (_gx[0xdb]&~0x18000)|0x18000;
	else _gx[0xdb] = (_gx[0xdb]&~0x18000)|0x10000;

	_gx[0xdb] = (_gx[0xdb]&~0x8)|(lfmt&0x8);
	_gx[0xdb] = (_gx[0xdb]&~0x200)|(_SHIFTL(mipmap,9,1));
	_gx[0xdb] = (_gx[0xdb]&~0x70)|(_SHIFTL(lfmt,4,3));

	_gx[0xda] = (_gx[0xda]&~0xff000000)|(_SHIFTL(0x4d,24,8));

	((u8*)_gx)[0x370] = 0;
	((u8*)_gx)[0x370] = ((fmt&0x10)-16)?0:1;
}

void GX_ClearBoundingBox()
{
	GX_LOAD_BP_REG(0x550003ff);
	GX_LOAD_BP_REG(0x560003ff);
}

void GX_BeginDispList(void *list,u32 size)
{
	GXFifoObj *curr_fifo;

	curr_fifo = GX_GetCPUFifo();
	if(_gx[0x09]) 
		__GX_SetDirtyState();

	if(((u8*)_gx)[0x371]) 
		memcpy(_gx_saved_data,_gx,1280);

	_gx_dl_fifo.buf_start = (u32)list;
	_gx_dl_fifo.buf_end = (u32)list + size - 4;
	_gx_dl_fifo.size = size;

	_gx_dl_fifo.rd_ptr = (u32)list;
	_gx_dl_fifo.wt_ptr = (u32)list;
	_gx_dl_fifo.rdwt_dst = 0;
	
	((u8*)_gx)[0x372] = 1;

	GX_SaveCPUFifo(curr_fifo);
	_gxoldcpufifo = curr_fifo;

	GX_SetGPFifo((GXFifoObj*)&_gx_dl_fifo);
}

u32 GX_EndDispList()
{
	u32 val;
	u32 level,ret = 0;
	
	if(_gx[0x09])
		__GX_SetDirtyState();

	__GX_SaveCPUFifoAux(&_gx_dl_fifo);
	GX_SetCPUFifo(_gxoldcpufifo);

	val = _SHIFTR(_piReg[5],26,1);
	if(((u8*)_gx)[0x371]) {
		_CPU_ISR_Disable(level);
		memcpy(_gx,_gx_saved_data,1272);
		_CPU_ISR_Restore(level);
	}

	((u8*)_gx)[0x372] = 0;
	if(	_SHIFTR(_piReg[5],26,1)) ret = _gx_dl_fifo.rdwt_dst;

	return ret;
}

void GX_CallDispList(void *list,u32 nbytes)
{
	if(_gx[0x09]) 
		__GX_SetDirtyState();

	if(!_gx[0xf8])
		__GX_SendFlushPrim();
	
	FIFO_PUTU8(0x40);			//call displaylist
	FIFO_PUTU32(MEM_VIRTUAL_TO_PHYSICAL(list));
	FIFO_PUTU32(nbytes);
}

void GX_SetChanCtrl(s32 channel,u8 enable,u8 ambsrc,u8 matsrc,u8 litmask,u8 diff_fn,u8 attn_fn)
{
	u32 reg,difffn = (attn_fn==GX_AF_SPEC)?GX_DF_NONE:diff_fn;
	u32 val = (matsrc&1)|(_SHIFTL(enable,1,1))|(_SHIFTL(litmask,2,4))|(_SHIFTL(ambsrc,6,1))|(_SHIFTL(difffn,7,2))|(_SHIFTL(((GX_AF_NONE-attn_fn)>0),9,1))|(_SHIFTL((attn_fn&1),10,1))|(_SHIFTL((_SHIFTR(litmask,4,4)),11,4));

	reg = (channel&0x03);
	_gx[0xf4+reg] = val;
	_gx[0x09] |= (0x1000<<reg);

	if(channel==GX_COLOR0A0) {
		_gx[0xf6] = val;
		_gx[0x09] |= 0x5000;
	} else {
		_gx[0xf7] = val;
		_gx[0x09] |= 0xa000;
	}
}

void GX_SetChanAmbColor(s32 channel,GXColor color)
{
	u32 reg,val = (_SHIFTL(color.r,24,8))|(_SHIFTL(color.g,16,8))|(_SHIFTL(color.b,8,8))|0x00;
	switch(channel) {
		case GX_COLOR0:
			reg = 0;
			val |= (_gx[0xf0]&0xff); 
			break;
		case GX_COLOR1:
			reg = 1;
			val |= (_gx[0xf1]&0xff);
			break;
		case GX_ALPHA0:
			reg = 0;
			val = ((_gx[0xf0]&~0xff)|(color.a&0xff));
			break;
		case GX_ALPHA1:
			reg = 1;
			val = ((_gx[0xf1]&~0xff)|(color.a&0xff));
			break;
		case GX_COLOR0A0:
			reg = 0;
			val |= (color.a&0xFF);
			break;
		case GX_COLOR1A1:
			reg = 1;
			val |= (color.a&0xFF);
			break;
		default:
			return;
	}

	_gx[0xf0+reg] = val;
	_gx[0x09] |= (0x0100<<reg);
}

void GX_SetChanMatColor(s32 channel,GXColor color)
{
	u32 reg,val = (_SHIFTL(color.r,24,8))|(_SHIFTL(color.g,16,8))|(_SHIFTL(color.b,8,8))|0x00;
	switch(channel) {
		case GX_COLOR0:
			reg = 0;
			val |= (_gx[0xf2]&0xff);
			break;
		case GX_COLOR1:
			reg = 1;
			val |= (_gx[0xf3]&0xff);
			break;
		case GX_ALPHA0:
			reg = 0;
			val = ((_gx[0xf2]&~0xff)|(color.a&0xff));
			break;
		case GX_ALPHA1:
			reg = 1;
			val = ((_gx[0xf3]&~0xff)|(color.a&0xff));
			break;
		case GX_COLOR0A0:
			reg = 0;
			val |= (color.a&0xFF);
			break;
		case GX_COLOR1A1:
			reg = 1;
			val |= (color.a&0xFF);
			break;
		default:
			return;
	}

	_gx[0xf2+reg] = val;
	_gx[0x09]…