/* WinTest.c
**
**    SCRAMmer V37.3 - 27th Aug 1992
**    ------------------------------
**
**		Copyright (c)		Giuliano C. Peritore
**								Via Amaseno, 6
**								04100 Latina
**								ITALY
**
**		Phone: (+39) 773 491692 Voice Only
**		EMAIL mc6040@mclink.it
*/

#include	<lattice/string.h>
#include	<lattice/stdio.h>
#include	<exec/types.h>
#include	<exec/memory.h>
#include	<exec/execbase.h>
#include	<devices/timer.h>
#include	<intuition/intuition.h>
#include	<utility/date.h>

#include	<clib/timer_protos.h>
#include	<clib/exec_protos.h>
#include	<clib/graphics_protos.h>
#include	<clib/utility_protos.h>
#include	<clib/gadtools_protos.h>
#include	<clib/intuition_protos.h>

#include	<pragma/exec_lib.pragma>
#include	<pragma/timer_lib.pragma>
#include	<pragma/graphics_lib.pragma>
#include	<pragma/utility_lib.pragma>
#include	<pragma/gadtools_lib.pragma>
#include	<pragma/intuition_lib.pragma>

#include	"SCRAMmer.h"

ULONG	TestFastInChip(ULONG,ULONG,ULONG);
ULONG	TestChipInFast(ULONG,ULONG,ULONG);
VOID	PageDetectOn(VOID);	/* 	Execute in Disable() */
VOID	PageDetectOff(VOID);	/* 	Execute in Disable() */
ULONG	ReadRamsey(VOID);
ULONG	ScramTest(ULONG);			/* 1 SCRAM, 2 PAGE, 0 NORAM */
VOID	RamTestR(ULONG);
VOID	RamTestW(ULONG);
VOID	Block(VOID);
VOID	UnBlock(VOID);

VOID	ShadowText(UWORD ,UWORD, struct RastPort *,char *msg);
VOID	NormalText(UWORD ,UWORD, struct RastPort *,char *msg);
LONG	request_user(struct Window *,char *, char *, char *);
VOID	CloseWindowSafely(struct Window *);

IMPORT	struct	Library			*GadToolsBase;
IMPORT	struct	IntuitionBase	*IntuitionBase;
IMPORT	struct	GfxBase			*GfxBase;

IMPORT	struct	Window	*main_window;
IMPORT	struct	Screen	*def_pub_scr;
IMPORT	struct	MsgPort	*userport;
IMPORT	struct	TextFont	*tf;
IMPORT	struct	TextAttr	ta;
IMPORT	UWORD		xfnt,yfnt,bfnt;
IMPORT	APTR		vi;
IMPORT	struct	ExecBase	*SysBase;

struct	Window	*test_win=0;
struct	Library			*TimerBase;

static	struct	Gadget	*glist;
static	struct	RastPort	*rport;
ULONG	bank[4];
UBYTE	size;
ULONG	read[4] ={0,0,0,0};
ULONG	write[4]={0,0,0,0};
ULONG	type[4]={0,0,0,0};
UBYTE *typestr[4];

#include	<exec/interrupts.h>
#include	<hardware/cia.h>
#include	<resources/cia.h>
#include	<clib/cia_protos.h>
/*#include <pragma/cia_lib.pragma>*/

#define	COUNTDOWN 20
#define	HICOUNT 0xff
#define  LOCOUNT 0xff

#define STOPA_AND CIACRAF_TODIN|CIACRAF_PBON|CIACRAF_OUTMODE|CIACRAF_SPMODE
#define STOPB_AND CIACRBF_ALARM|CIACRBF_PBON|CIACRBF_OUTMODE
#define STARTA_OR CIACRAF_START|CIACRAF_RUNMODE
#define STARTB_OR CIACRBF_START|CIACRBF_RUNMODE

VOID	CheckRAM(VOID);

struct	freetimer
{
	struct	Library	*ciabase;
	ULONG					timerbit;
	struct	CIA		*cia;
	UBYTE					*ciacr;
	UBYTE					*cialo;
	UBYTE					*ciahi;
	struct Interrupt	timerint;
	UBYTE					stopmask;
	UBYTE					startmask;
};

struct	CIA	*ciaa=(struct CIA*)0xbfe001;
struct	CIA	*ciab=(struct CIA*)0xbfd000;

void ExampleInterrupt(VOID)
{
	;
}

BOOL	TryTimer (struct freetimer *ft)
{
	if(!AddICRVector(ft->ciabase,CIAICRB_TA,&ft->timerint))
	{
		ft->timerbit=CIAICRB_TA;
		return(TRUE);
	}

	if(!AddICRVector(ft->ciabase,CIAICRB_TB,&ft->timerint))
	{
		ft->timerbit=CIAICRB_TB;
		return(TRUE);
	}
	return(FALSE);
}

BOOL	FindFreeTimer(struct freetimer *ft)
{
	struct	CIABase	*ciaabase,*ciabbase;

	if(ciaabase=OpenResource(CIAANAME))
	{
		ft->ciabase	=ciaabase;
		ft->cia		=ciaa;
		if(TryTimer(ft))
			return(TRUE);
	}
	else	request_user(test_win,GetString(MSG_SCRAMMER),GetString(MSG_NOCIAA),GetString(MSG_CANCEL));

	if(ciabbase=OpenResource(CIABNAME))
	{
		ft->ciabase	=ciabbase;
		ft->cia		=ciab;
		if(TryTimer(ft))
			return(TRUE);
	}
	else	request_user(test_win,GetString(MSG_SCRAMMER),GetString(MSG_NOCIAB),GetString(MSG_CANCEL));
	return(FALSE);
}

VOID	Timer(struct freetimer *ft,ULONG bn)
{
	register struct	CIA	*cia;
	ULONG	factor,rem,mean;
	int	i;

	cia=ft->cia;

	if(ft->timerbit==CIAICRB_TA)
	{
		ft->ciacr=&cia->ciacra;
		ft->cialo=&cia->ciatalo;
		ft->ciahi=&cia->ciatahi;

		ft->stopmask=STOPA_AND;
		ft->startmask=STARTA_OR;
	}
	else
	{
		ft->ciacr=&cia->ciacrb;
		ft->cialo=&cia->ciatblo;
		ft->ciahi=&cia->ciatbhi;

		ft->stopmask=STOPB_AND;
		ft->startmask=STARTB_OR;
	}

	*ft->ciacr&=ft->stopmask;

	Block();
	mean=0;
	for(i=0;i<16;i++)
	{
		*ft->cialo=0xff;
		*ft->ciahi=0xff;
		*ft->ciacr|=ft->startmask;
			RamTestR(bank[bn]);
		*ft->ciacr&=ft->stopmask;

		factor=(255-*ft->cialo)+(((255-*ft->ciahi))<<8);
		factor*=1000;
		rem=factor;
		factor/=SysBase->ex_EClockFrequency;
		rem-=factor*SysBase->ex_EClockFrequency;
		rem*=1000;
		rem/=SysBase->ex_EClockFrequency;
		factor=factor*1000+rem;

		mean+=factor;
	}
	read[bn]=mean/16;
	mean=0;
	for(i=0;i<16;i++)
	{
		*ft->cialo=0xff;
		*ft->ciahi=0xff;
		*ft->ciacr|=ft->startmask;
			RamTestW(bank[bn]);
		*ft->ciacr&=ft->stopmask;

		factor=(255-*ft->cialo)+(((255-*ft->ciahi))<<8);
		factor*=1000;
		rem=factor;
		factor/=SysBase->ex_EClockFrequency;
		rem-=factor*SysBase->ex_EClockFrequency;
		rem*=1000;
		rem/=SysBase->ex_EClockFrequency;
		factor=factor*1000+rem;

		mean+=factor;
	}
	write[bn]=mean/16;
	UnBlock();
}

VOID	CTestRAM(ULONG bn)
{
	struct	freetimer	ft;

	ft.timerint.is_Node.ln_Type=NT_INTERRUPT;
	ft.timerint.is_Node.ln_Pri=0;
	ft.timerint.is_Node.ln_Name="ETI_020_SCRAMmer_CIA";
	ft.timerint.is_Data=0;
	ft.timerint.is_Code=(APTR)ExampleInterrupt;

	if(FindFreeTimer(&ft))
	{
		WaitBlit();
		Disable();
		if(TypeOfMem((APTR)(bank[bn]+0x1000)))
		{
			Timer(&ft,bn);
		}
		else request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_NOEMPTYSOCK),GetString(MSG_CANCEL));
		Enable();
		RemICRVector(ft.ciabase,ft.timerbit,&ft.timerint);
	}
	else	request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_NOTIMER),GetString(MSG_CANCEL));
}

/*------------------------------------------------------------------*/
ULONG CSCRAMTest(ULONG b)
{
	ULONG	result,oldcache;
	UBYTE	ramsey;
	APTR	zone;

	if(zone=AllocMem(16,MEMF_CLEAR|MEMF_CHIP))
	{
		Disable();											/* Disable Interrupts */
		ramsey=ReadRamsey();
		oldcache=CacheControl(0L,0L);					/* Get CPU status */
		if(oldcache&CACRF_EnableD)						/* If data cache enabled */
			CacheControl(0,CACRF_EnableD);			/* then disable it */
		CopyMem((APTR)b,zone,16);						/* Save test zone data */
		result=ScramTest(b);								/* Perform test */
		CopyMem(zone,(APTR)b,16);						/* Reset test zone data */
		CacheControl(oldcache,0xffffffff);			/* Reset cache status */
		if(ramsey&0x01)
			PageDetectOn();
		Enable();											/* Enable interrupts */
		FreeMem(zone,16);
		return(result+1);
	}
	else	request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_NOMEMORY),GetString(MSG_CANCEL));
	return(0);
}

VOID	refresh_test(VOID)
{
	int	i;
	char	buf[]="12345678901234567890123456789012345678";

	ShadowText(X_SEP,Y_SEP*2+bfnt+yfnt*1,	rport,GetString(MSG_TEST1));
	ShadowText(X_SEP,Y_SEP*2+bfnt+yfnt*6,rport,GetString(MSG_TESTFASTCK));
	ShadowText(X_SEP,Y_SEP*2+bfnt+yfnt*7,rport,GetString(MSG_TESTCHIPCK));
	for(i=0;i<4;i++)
	{
		sprintf(buf,"%1.1d  %1.1d %08.8x %5.5s %8.8d %8.8d\0",i,size,bank[i],typestr[type[i]],read[i],write[i]);
		NormalText(X_SEP,Y_SEP*2+bfnt+yfnt*(i+2),	rport,buf);
	}
}


VOID	process_test(struct Gadget*g)
{
	switch(g->GadgetID)
	{
		case	1:
			switch(request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_CRASH),GetString(MSG_0123CAN)))
			{
				case	1:		/* Bank 0 */
					type[0]=CSCRAMTest(bank[0]);
				break;
				case	2:		/* Bank 1 */
					type[1]=CSCRAMTest(bank[1]);
				break;
				case	3:		/* Bank 2 */
					type[2]=CSCRAMTest(bank[2]);
				break;
				case	4:		/* Bank 3 */
					type[3]=CSCRAMTest(bank[3]);
				break;
			}
		break;
		case	2:
			switch(request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_TIMECRIT),GetString(MSG_0123CAN)))
			{
				case	1:		/* Bank 0 */
					CTestRAM(0);
				break;
				case	2:		/* Bank 1 */
					CTestRAM(1);
				break;
				case	3:		/* Bank 2 */
					CTestRAM(2);
				break;
				case	4:		/* Bank 3 */
					CTestRAM(3);
				break;
			}
		break;
		case	3:
			if(request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_TESTDANGER),GetString(MSG_CHECKCAN)))
				CheckRAM();
		break;
	}
	refresh_test();
}

VOID	open_test(VOID)
{
	UWORD	w,h;
	static	struct	Gadget		*gad;
	static	struct	NewGadget	ng;

	typestr[0]=GetString(MSG_TYPEUNTST);
	typestr[1]=GetString(MSG_TYPENORAM);
	typestr[2]=GetString(MSG_TYPESCRAM);
	typestr[3]=GetString(MSG_TYPENORM);

	gad=CreateContext(&glist);
	ng.ng_TextAttr=&ta;
	ng.ng_VisualInfo=vi;
	ng.ng_Width=		xfnt*12;
	ng.ng_Height=		yfnt;
	ng.ng_Flags=		PLACETEXT_IN;

	ng.ng_LeftEdge=	X_SEP;
	ng.ng_TopEdge=Y_SEP;		ng.ng_GadgetText=GetString(MSG_SCRAMTEST);	ng.ng_GadgetID=1;
	gad=CreateGadget(BUTTON_KIND,gad,&ng,TAG_DONE);
	ng.ng_LeftEdge=	X_SEP+xfnt*13;
	ng.ng_TopEdge=Y_SEP;		ng.ng_GadgetText=GetString(MSG_SPEEDTEST);	ng.ng_GadgetID=2;
	gad=CreateGadget(BUTTON_KIND,gad,&ng,TAG_DONE);
	ng.ng_LeftEdge=	X_SEP+xfnt*26;
	ng.ng_Width=		xfnt*11;
	ng.ng_TopEdge=Y_SEP;		ng.ng_GadgetText=GetString(MSG_TESTCHECK);	ng.ng_GadgetID=3;
	gad=CreateGadget(BUTTON_KIND,gad,&ng,TAG_DONE);

	if(gad)
	{
		w=(X_SEP*2) + 37*xfnt + (def_pub_scr->WBorLeft) + (def_pub_scr->WBorRight);
		h=(Y_SEP*3) + 8*yfnt + (def_pub_scr->WBorBottom) + (def_pub_scr->WBorTop) + (def_pub_scr->Font->ta_YSize) + 1;
		if(test_win=OpenWindowTags(NULL,
			WA_Left,			(def_pub_scr->Width-w)>>2,
			WA_Top,			(def_pub_scr->Height-h)>>2,
			WA_Width,		w,
			WA_Height,		h,
			WA_Flags,		WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_ACTIVATE|WFLG_RMBTRAP|WFLG_GIMMEZEROZERO|WFLG_SIMPLE_REFRESH,
			WA_AutoAdjust,	FALSE,
			WA_IDCMP,		NULL,
			WA_Title,		GetString(MSG_TESTWIN),
			WA_PubScreen,	def_pub_scr,TAG_END))
		{
			rport=test_win->RPort;
			SetFont(rport,tf);
			test_win->UserPort=userport;
			AddGList(test_win,glist,-1,-1,NULL);
			RefreshGList(glist,test_win,NULL,-1);
			GT_RefreshWindow(test_win,NULL);
			ModifyIDCMP(test_win,BUTTONIDCMP|IDCMP_CLOSEWINDOW|IDCMP_REFRESHWINDOW);
			switch(((ReadRamsey()&0x18)>>3))
			{
				case	0:
				case	2:
					bank[0]=FAST1BN1;
					bank[1]=FAST1BN2;
					bank[2]=FAST1BN3;
					bank[3]=FAST1BN4;
					size=1;
				break;
				case	1:
					bank[0]=FAST4BN1;
					bank[1]=FAST4BN2;
					bank[2]=FAST4BN3;
					bank[3]=FAST4BN4;
					size=4;
					request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_USING4MB),GetString(MSG_CANCEL));
				break;
				case	3:
					bank[0]=FAST4BN1;
					bank[1]=FAST4BN2;
					bank[2]=FAST4BN3;
					bank[3]=FAST4BN4;
					size=4;
				break;
			}
			refresh_test();
		}
		else
			request_user(main_window,GetString(MSG_SCRAMMER),GetString(MSG_NOWINDOW),GetString(MSG_CANCEL));
	}
	else
		request_user(main_window,GetString(MSG_SCRAMMER),GetString(MSG_NOGADGETS),GetString(MSG_CANCEL));
}

VOID	close_test(VOID)
{
	if(test_win)
	{	
		CloseWindowSafely(test_win);
		test_win=0;
	}
	FreeGadgets(glist);
	glist=0;
}

struct	check
{
	STRPTR	ch_Name;
	ULONG		ch_Start;
	ULONG		ch_Size;
	ULONG		ch_Mask;
};

struct check chkfst4[]=
{
	"U850Z",0x07c00000,0x00400000,0x0000000f,
	"U851Z",0x07c00000,0x00400000,0x000000f0,
	"U852Z",0x07c00000,0x00400000,0x00000f00,
	"U853Z",0x07c00000,0x00400000,0x0000f000,
	"U854Z",0x07c00000,0x00400000,0x000f0000,
	"U855Z",0x07c00000,0x00400000,0x00f00000,
	"U856Z",0x07c00000,0x00400000,0x0f000000,
	"U857Z",0x07c00000,0x00400000,0xf0000000,
	"U858Z",0x07800000,0x00400000,0x0000000f,
	"U859Z",0x07800000,0x00400000,0x000000f0,
	"U860Z",0x07800000,0x00400000,0x00000f00,
	"U861Z",0x07800000,0x00400000,0x0000f000,
	"U862Z",0x07800000,0x00400000,0x000f0000,
	"U863Z",0x07800000,0x00400000,0x00f00000,
	"U864Z",0x07800000,0x00400000,0x0f000000,
	"U865Z",0x07800000,0x00400000,0xf0000000,
	"U866Z",0x07400000,0x00400000,0x0000000f,
	"U867Z",0x07400000,0x00400000,0x000000f0,
	"U868Z",0x07400000,0x00400000,0x00000f00,
	"U869Z",0x07400000,0x00400000,0x0000f000,
	"U870Z",0x07400000,0x00400000,0x000f0000,
	"U871Z",0x07400000,0x00400000,0x00f00000,
	"U872Z",0x07400000,0x00400000,0x0f000000,
	"U873Z",0x07400000,0x00400000,0xf0000000,
	"U874Z",0x07000000,0x00400000,0x0000000f,
	"U875Z",0x07000000,0x00400000,0x000000f0,
	"U876Z",0x07000000,0x00400000,0x00000f00,
	"U877Z",0x07000000,0x00400000,0x0000f000,
	"U878Z",0x07000000,0x00400000,0x000f0000,
	"U879Z",0x07000000,0x00400000,0x00f00000,
	"U880Z",0x07000000,0x00400000,0x0f000000,
	"U881Z",0x07000000,0x00400000,0xf0000000,
};

struct check chkfst1[]=
{
	"U850-",0x07f00000,0x00100000,0x0000000f,
	"U851-",0x07f00000,0x00100000,0x000000f0,
	"U852-",0x07f00000,0x00100000,0x00000f00,
	"U853-",0x07f00000,0x00100000,0x0000f000,
	"U854-",0x07f00000,0x00100000,0x000f0000,
	"U855-",0x07f00000,0x00100000,0x00f00000,
	"U856-",0x07f00000,0x00100000,0x0f000000,
	"U857-",0x07f00000,0x00100000,0xf0000000,
	"U858Z",0x07e00000,0x00100000,0x0000000f,
	"U859Z",0x07e00000,0x00100000,0x000000f0,
	"U860Z",0x07e00000,0x00100000,0x00000f00,
	"U861Z",0x07e00000,0x00100000,0x0000f000,
	"U862Z",0x07e00000,0x00100000,0x000f0000,
	"U863Z",0x07e00000,0x00100000,0x00f00000,
	"U864Z",0x07e00000,0x00100000,0x0f000000,
	"U865Z",0x07e00000,0x00100000,0xf0000000,
	"U866Z",0x07d00000,0x00100000,0x0000000f,
	"U867Z",0x07d00000,0x00100000,0x000000f0,
	"U868Z",0x07d00000,0x00100000,0x00000f00,
	"U869Z",0x07d00000,0x00100000,0x0000f000,
	"U870Z",0x07d00000,0x00100000,0x000f0000,
	"U871Z",0x07d00000,0x00100000,0x00f00000,
	"U872Z",0x07d00000,0x00100000,0x0f000000,
	"U873Z",0x07d00000,0x00100000,0xf0000000,
	"U874Z",0x07c00000,0x00100000,0x0000000f,
	"U875Z",0x07c00000,0x00100000,0x000000f0,
	"U876Z",0x07c00000,0x00100000,0x00000f00,
	"U877Z",0x07c00000,0x00100000,0x0000f000,
	"U878Z",0x07c00000,0x00100000,0x000f0000,
	"U879Z",0x07c00000,0x00100000,0x00f00000,
	"U880Z",0x07c00000,0x00100000,0x0f000000,
	"U881Z",0x07c00000,0x00100000,0xf0000000,
};

struct check chkchp[]=
{
	"U259D",0x00000000,0x00100000,0x0000000f,
	"U260D",0x00000000,0x00100000,0x000000f0,
	"U261D",0x00000000,0x00100000,0x00000f00,
	"U262D",0x00000000,0x00100000,0x0000f000,
	"U263D",0x00000000,0x00100000,0x000f0000,
	"U264D",0x00000000,0x00100000,0x00f00000,
	"U265D",0x00000000,0x00100000,0x0f000000,
	"U266D",0x00000000,0x00100000,0xf0000000,
	"U267D",0x00100000,0x00100000,0x0000000f,
	"U268D",0x00100000,0x00100000,0x000000f0,
	"U269D",0x00100000,0x00100000,0x00000f00,
	"U270D",0x00100000,0x00100000,0x0000f000,
	"U271D",0x00100000,0x00100000,0x000f0000,
	"U272D",0x00100000,0x00100000,0x00f00000,
	"U273D",0x00100000,0x00100000,0x0f000000,
	"U274D",0x00100000,0x00100000,0xf0000000,
};

VOID	CheckRAM(VOID)
{
	ULONG	oldcache;
	int	i;
	struct	check	*chk;

	oldcache=CacheControl(0L,0L);					/* Get CPU status */
	if(oldcache&CACRF_EnableD)						/* If data cache enabled */
		CacheControl(0,CACRF_EnableD);			/* then disable it */

	switch(((ReadRamsey()&0x18)>>3))
	{
		case	0:
			request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_TESTNO11),GetString(MSG_CANCEL));
		break;
		case	1:
			request_user(test_win,GetString(MSG_TESTWIN),GetString(MSG_TESTUNKZI),GetString(MSG_CANCEL));
		break;
		case	2:		/*256k x 4 bit*/
			Disable();
			for(i=0;i<32;i++)
			{
				chk=&chkfst1[i];
				NormalText(X_SEP+16*xfnt,Y_SEP*2+bfnt+yfnt*6,rport,chk->ch_Name);
				if(TypeOfMem((APTR)(chk->ch_Start+0x1000)))
				{
					if(1==TestFastInChip(chk->ch_Start,chk->ch_Size,chk->ch_Mask))
					{
						Enable();
							request_user(test_win,GetString(MSG_BADCHIP),chk->ch_Name,GetString(MSG_CANCEL));
						Disable();
					}
				}
			}
			Enable();
		break;
		case	3:		/*1meg x 4bit*/
			Disable();
			for(i=0;i<32;i++)
			{
				chk=&chkfst4[i];
				NormalText(X_SEP+16*xfnt,Y_SEP*2+bfnt+yfnt*6,rport,chk->ch_Name);
				if(TypeOfMem((APTR)(chk->ch_Start+0x1000)))
				{
					if(TestFastInChip(chk->ch_Start,chk->ch_Size,chk->ch_Mask))
					{
						Enable();
						request_user(test_win,GetString(MSG_BADCHIP),chk->ch_Name,GetString(MSG_CANCEL));
						Disable();
					}
				}
			}
			Enable();
		break;
	}

	Disable();
	for(i=0;i<16;i++)
	{
		chk=&chkchp[i];
		NormalText(X_SEP+16*xfnt,Y_SEP*2+bfnt+yfnt*7,rport,chk->ch_Name);
		if(TypeOfMem((APTR)(chk->ch_Start+0x1000)))
		{
			if(1==TestChipInFast(chk->ch_Start,chk->ch_Size,chk->ch_Mask))
			{
				Enable();
				request_user(test_win,GetString(MSG_BADCHIP),chk->ch_Name,GetString(MSG_CANCEL));
				Disable();
			}
		}
	}
	Enable();
	NormalText(X_SEP+16*xfnt,Y_SEP*2+bfnt+yfnt*7,rport,"     ");
	NormalText(X_SEP+16*xfnt,Y_SEP*2+bfnt+yfnt*6,rport,"     ");
	CacheControl(oldcache,0xffffffff);			/* Reset cache status */
}