int WriteRegB(int argc, char *argv[])
{
	return WriteReg(argc, argv, 0);
}
int WriteRegW(int argc, char *argv[])
{
	return WriteReg(argc, argv, 1);
}
int WriteRegD(int argc, char *argv[])
{
	return WriteReg(argc, argv, 2);
}

int ReadRegB(int argc, char *argv[])
{
	return ReadReg(argc, argv, 0);
}
int ReadRegW(int argc, char *argv[])
{
	return ReadReg(argc, argv, 1);
}
int ReadRegD(int argc, char *argv[])
{
	return ReadReg(argc, argv, 2);
}

int ReadHDInfo(int argc, char *argv[])
{
	int i;
	
//	*(unsigned char *)0x600000c = 0xe0;
	*(unsigned char *)0x600000e = 0xec;
	
	while(*(volatile unsigned char *)0x600000e&0x80)printf("%x\n", *(volatile unsigned char *)0x600000e);
	//getch();
	for(i=0; i<256; i++)
		printf("%5x", *(unsigned short *)0x6000000);
			
	return 0;
}

/*****************************************************/
unsigned char GetStatus()
{
	return *(volatile unsigned char *)0x600000e;
}
int WaitNDrdy()
{
	int i;
	
	while(1)
	{
		if(GetStatus()&0x40)
			break;
		else
			for(i=100;i;i--);			
	}
	return 1;
}
int WaitNDrq()
{
	while(!(GetStatus()&8));	
	return 1;
}
int WaitBusy()
{
	while(GetStatus()&0x80);
	return 1;
}

int SelDevice()
{
	if(WaitBusy())
    {	

     	*(volatile unsigned char *)0x600000c = 0xa0;
        WaitNDrdy();
    }

    return 1;
}

int GetIdentify()
{
	int i, j;
   
    // Select device.
	if(SelDevice())
    {
	    // Send IDE IDENTIFY command.
	    *(volatile unsigned char *)0x600000e = 0xec;

	    if(WaitNDrq())
        {            
	        // Suck out 256 words. After waiting for one model that asserts busy
	        // after receiving the Packet Identify command.
	        for(i=0;i<256;i++)
	        {
	        	j = *(volatile unsigned short *)0x6000000;
	        }	        
        }
	    
	    // Work around for some IDE and one model Atapi that will present more than
	    // 256 words for the Identify data.	    
		
		while(GetStatus()&8)
        {
			// Suck out any remaining bytes and throw away.			    
			i = *(volatile unsigned short *)0x6000000;	    		
	    }
    }

	return 1;
}

int SetFeature()
{
	outportb(0x6000002, 0x03);
	outportb(0x6000004, 0x08);
	outportb(0x6000006, 0);
	outportb(0x6000008, 0);
	outportb(0x600000a, 0);
	outportb(0x600000e, 0xef);
	
	return 1;
}
int SetParameters()
{
   

	if(WaitBusy())
    {
    	// Set up registers for SET PARAMETER command.   	    
        outportb(0x600000c, 0xef);        
        outportb(0x6000004, 0x20);

        if(WaitNDrdy())
        {	        
	        // Send SET PARAMETER command.
	        // IDE_COMMAND_SET_DRIVE_PARAMETERS 0x91 (Init Device Parameter)	        
	        outportb(0x600000e, 0x91);
            WaitBusy();
        }
    }
    return 1;
}
int InitHardDisk(int argc, char *argv[])
{
	int i;
	
	*(unsigned int *)0x3ff5008 = 0;
	i = 1000;
	while(i--);
	*(unsigned int *)0x3ff5008 = 0xffffff;
	
	i = 100000;
	while(i--);
	
	if(SelDevice())
	{
		outportb(0x600000c, 0xa0);
	}


    while(1)
    {
        if(WaitNDrdy())            
            break;
        
    }	
    
    SetFeature();
    
    //if(SelDevice())
	//{
	//	GetIdentify();
	//}
	
	//SetParameters();
	
	return 1;	
}

/*********************************************************/
int Help(int argc, char *argv[]);

typedef int (*cmdproc)(int argc, char *argv[]);
typedef struct {
	const char *cmd;
	const char *hlp;
	cmdproc proc;
}CMD_STRUC;

CMD_STRUC CMD_INNER[] =
				{ 
					{"?", "help", Help},	
					{"load", "load file to memory", LoadFile2Mem},										
					{"comload", "load file from serial port", LoadFromUart},
					{"run", "run from ram", RunProgram},														
					{"ipcfg", "show or set IP address", SetIPAddr},
					{"setbaud", "set baud rate", SetBaudRate},
					{"prog", "program flash", ProgFlash},
					{"boot", "boot from flash", BootLoader},
					{"ap", "auto load image flie and program flash", AutoProgFlash},																			
					{"copy", "copy flash from src to dst address", CopyFlash},
					//{"wb", "", WriteRegB},
					//{"rb", "", ReadRegB},
					//{"ww", "", WriteRegW},
					//{"rw", "", ReadRegW},
					//{"wd", "", WriteRegD},
					//{"rd", "", ReadRegD},					
					//{"disk","", ReadHDInfo},
					//{"init", "", InitHardDisk},					
					{NULL, NULL, NULL}
				};

int Help(int argc, char *argv[])
{
	int i;	
	
	for(i=0; CMD_INNER[i].cmd!=NULL; i++)
	{
		if(CMD_INNER[i].hlp!=NULL)
		{
			printf(CMD_INNER[i].cmd);
			puts("	------	");
			printf(CMD_INNER[i].hlp);
			putch('\n');
		}
	}
	
	return 0;
}

/************************************************/
static void ParseArgs(char *cmdline, int *argc, char **argv)
{
#define STATE_WHITESPACE	0
#define STATE_WORD			1

	char *c;
	int state = STATE_WHITESPACE;
	int i;

	*argc = 0;

	if(strlen(cmdline) == 0)
		return;

	/* convert all tabs into single spaces */
	c = cmdline;
	while(*c != '\0')
	{
		if(*c == '\t')
			*c = ' ';
		c++;
	}
	
	c = cmdline;
	i = 0;

	/* now find all words on the command line */
	while(*c != '\0')
	{
		if(state == STATE_WHITESPACE)
		{
			if(*c != ' ')
			{
				argv[i] = c;		//將argv[i]指向c
				i++;
				state = STATE_WORD;
			}
		}
		else
		{ /* state == STATE_WORD */
			if(*c == ' ')
			{
				*c = '\0';
				state = STATE_WHITESPACE;
			}
		}
		c++;
	}
	
	*argc = i;
#undef STATE_WHITESPACE
#undef STATE_WORD
}

static int GetCmdMatche(char *cmdline)
{
	int i;	
	
	for(i=0; CMD_INNER[i].cmd!=NULL; i++)
	{
		if(strncmp(CMD_INNER[i].cmd, cmdline, strlen(CMD_INNER[i].cmd))==0)
			return i;
	}
	
	return -1;
}

static int ParseCmd(char *cmdline, int cmd_len)
{
	int argc, num_commands;
	char *argv[8];

	ParseArgs(cmdline, &argc, argv);

	/* only whitespace */
	if(argc == 0) 
		return 0;
	
	num_commands = GetCmdMatche(argv[0]);
	if(num_commands<0)
		return -1;
		
	if(CMD_INNER[num_commands].proc!=NULL)	
		CMD_INNER[num_commands].proc(argc, argv);
				
	return 0;			
}

/************************************************/
#include "4510irq.h"
void ARMEnableInt(void);
void ARMDisableInt(void);
void IsrNetRx(void)
{
//	*(unsigned int *)UTXBUF0 = '@';	
	putch('#');	
}
void ISR_CS8900(void);

int main()
{
	char command[MAX_CMD_LEN];
	char key;
	int i;
//	unsigned short tmp[32];
	
	SERIAL_BAUD = DFT_SERIAL_BAUD;
	console_init(SERIAL_BAUD);
	next_line();
	puts(star_line);
	puts("Bios for download and program.\n");
	puts("Author Jerry\n");
	puts("Build date : "__DATE__" Time : "__TIME__"\n");	
	printf("Type ? for help.\n");
	puts(star_line);	
	prompt();
	
//		printf("%x", ReadSWPID());		
//		for(i = 0; i<32; i++)
//			tmp[i] = 32-i;
//		FlashProg(0x40000, tmp, 32);	
//		SectorErase(0x40000);

//		InitIrq();
//		SetIrqVector(INT_EXTINT0, (U32)ISR_CS8900);//(U32)IsrNetRx);
//		EnableIrq(INT_EXTINT0);
//		EnableIrq(INT_GLOBAL);
//		ARMEnableInt();
	
/*		while(1)
		{
			U32 i;
			
			SetIntTest(INT_EXTINT0);
			i = 1000000;
			while(i--);
		}*/					
	
	i = 0;
	
	for(;;)
	{
		if(kbhit())
		{
			key = getch();
			if(key==BACK_KEY)
			{			
				i -= i?1:0;
				putch(key);
			}
			else
			if(key==ENTER_KEY)
			{
				int tmp;
				command[i] = 0;
				next_line();
				tmp = ParseCmd(command, i);
				if(tmp<0)
					puts("Bad command\n");
				prompt();
				
				i = 0;
			}
			else
			{
				if(i<MAX_CMD_LEN-1)
					command[i++] = key;
					putch(key);
			}				
		}
	}
	
}

unsigned int pIrqStart, pIrqFinish, pIrqHandler;