#include "types.h"
#include "console.h"
#include "utils.h"
#include "39vf160.h"


#define	MAX_CMD_LEN	128
#define	MAX_ARGS	MAX_CMD_LEN/4
#define	ENTER_KEY	0x0d
#define	BACK_KEY	0x08
#define	ESC_KEY		0x1b

int IP_ADDRESS = 0xc0a80064;
unsigned int SERIAL_BAUD;
#define	DFT_SERIAL_BAUD	57600

#define	DFT_DOWNLOAD_ADDR	0x8000
#define	DFT_PROGRAM_BEGIN	0
unsigned int download_addr;
unsigned int program_begin;	

const char PROMPT[] = "\\>";
const char star_line[] = "/*************************************************************/\n";
#define	prompt()	puts(PROMPT)

/************************************************/
int tftp_main(unsigned long ip, unsigned long addr, int method);

int LoadFile2Mem(int argc, char *argv[])
{
	
	if(argc<2)
	{
		download_addr = DFT_DOWNLOAD_ADDR;
		printf("No begin address for download, use default address 0x%x\n", download_addr);
	}
	else
		download_addr = strtoul(argv[1]);
	
	tftp_main(IP_ADDRESS, download_addr, 0);

	return 0;
}

int ProgFlash(int argc, char *argv[])
{
	unsigned int size = ~0;
	unsigned int data_begin = ~0;
	unsigned int prog_begin = ~0;
	int overwrite0 = 1;
	int modify_a0 = 0;
	unsigned int bios_load_addr;		 

	if(argc<4)
	{		
		puts("Arguments error!\n");
		puts("Usage:	prog a1 a2 size [-no0]\na1 = program begin address\na2 = data pointer to ram\nsize = program size(Bytes)\n-no0 = don't overwrite address 0\n");
		return -1;
	}	
		
	prog_begin = strtoul(argv[1]);			
	data_begin = strtoul(argv[2]);
	size       = strtoul(argv[3]);
	
	if(size==0)
	{
		puts("Write 0 Bytes!\n");
		return -1;
	}
	
	if(prog_begin==-1||data_begin==-1)		//
	{
		puts("Arguments error\n");
		return -1;
	}	
	
	printf("program flash begin @0x%x, from ram data @0x%x, size = %dBytes\nAre you sure? [y/n]", prog_begin, data_begin, size);
	while(1)
	{
		if(kbhit())
		{
			int key = getch();
			if(key=='y'||key=='Y')
			{
				putch(key);
				next_line();
				break;
			}
			if(key=='n'||key=='N')
			{
				putch(key);
				next_line();
				return 0;
			}				
		}
			
	}		

#define	__ROM_SIZE	0x200000
#define	BIOS_BASE	(__ROM_SIZE-0x10000)
#define	BIOS_LOAD	(__ROM_SIZE-4)
	
	if(argc>4)
		if(strncmp(argv[4], "-no0", 4)==0)
			overwrite0 = 0;		
	
	if((prog_begin==0)&&overwrite0)
	{
		unsigned int ins;
		
		
		ins = *(unsigned int *)data_begin;				
		if((ins>>24)==0xea)			// instruction:	b	xxxx, now just support b instruction!!!			
			bios_load_addr = ((ins&0xffffff)<<2)+8;
		else
			bios_load_addr = 4;		// other instruction, jump to 4
													
		bios_load_addr = (bios_load_addr-BIOS_LOAD-8)/4;
		bios_load_addr = (bios_load_addr&0xffffff)|0xea000000;					
				
		*(unsigned int *)data_begin = 0xea000000+(BIOS_BASE-8)/4;				
		
		modify_a0 = 1;
	}
	
	SectorProg(prog_begin, (unsigned short *)data_begin, size);
	
	if(modify_a0)
	{
		size = FlashSector(size-1)+SECTOR_SIZE;				
		
		FlashRead(FlashSector(BIOS_LOAD), (unsigned short *)(DFT_DOWNLOAD_ADDR+size), SECTOR_SIZE);			
		*(unsigned int *)(DFT_DOWNLOAD_ADDR+size+SECTOR_SIZE-4) = bios_load_addr;
		SectorProg(FlashSector(BIOS_LOAD), (unsigned short *)(DFT_DOWNLOAD_ADDR+size), SECTOR_SIZE);			
	}
		
	
	return 0;
}

void trans_to_boot(int, int);

int BootLoader(int argc, char *argv[])
{
	int key;
	
	puts("boot from flash, are you sure? [y/n]");
	while(1)
	{
		if(kbhit())
		{
			key = getch();
			if(key=='y'||key=='Y')
			{
				putch(key);
				next_line();
				trans_to_boot(BIOS_BASE, BIOS_LOAD);												
			}
			if(key=='n'||key=='N')
			{
				putch(key);
				next_line();
				break;	
			}
		}			
	}
	
	return 0;
}

int AutoProgFlash(int argc, char *argv[])
{
	char ch_tmp[3][10];
	char *para_ptr[4];	
		
	ultostr(ch_tmp[0], 0);	
	ultostr(ch_tmp[1], DFT_DOWNLOAD_ADDR);	 	
	ultostr(ch_tmp[2], tftp_main(IP_ADDRESS, DFT_DOWNLOAD_ADDR, 1));		
	
	para_ptr[1] = ch_tmp[0];
	para_ptr[2] = ch_tmp[1];
	para_ptr[3] = ch_tmp[2];	
	
	ProgFlash(4, para_ptr);
	return	0;	
}

int CopyFlash(int argc, char *argv[])
{
	unsigned int src, dst, size;
	char tmp[10];
	
	if(argc<4)
	{
		puts("Usage : copy a1 a2 size\n");
		puts("a1 = src address, a2 = dst address, size = copy bytes (all in hex)\n");
		return -1;
	}
	
	src  = strtoul(argv[1]);
	dst  = strtoul(argv[2]);
	size = strtoul(argv[3]);
	if(src==-1||dst==-1||size==-1)
	{
		puts("give error address\n");
		return	-1;
	}	
	
	FlashRead(src, (unsigned short *)DFT_DOWNLOAD_ADDR, size);
	
	argv[1] = argv[2];
	argv[2] = tmp;
	ultostr(tmp, DFT_DOWNLOAD_ADDR);
	
	ProgFlash(4, argv);

	return 0;
}

int SetIPAddr(int argc, char *argv[])
{
	int i, j, err = 0;
	char *str;
	int ip[4];
	char ch = '.';
	
	if(argc<2)
	{
		printf("IP address : %u.%u.%u.%u\n", (IP_ADDRESS>>24)&0xff, (IP_ADDRESS>>16)&0xff, (IP_ADDRESS>>8)&0xff, IP_ADDRESS&0xff);
		return 0;
	}
	
	str = argv[1];
	
	for(j=0; j<4; j++)
	{
		if(j==3)
			ch = 0;
		i = 0;
		if(str[++i]!=ch)
			if(str[++i]!=ch)
				if(str[++i]!=ch)
					err = 1;
		str[i] = 0;
		ip[j] = CharToDec(str, i);
		if(ip[j]<0||ip[j]>254||err)
		{
			puts("IP address error\n");
			return -1;
		}			
		str += i+1;
	}
	
	printf("Set IP address : %u.%u.%u.%u\n", ip[0], ip[1], ip[2], ip[3]);					
	IP_ADDRESS = (ip[0]<<24)|(ip[1]<<16)|(ip[2]<<8)|ip[3];
	
	return 0;	
}

int LoadFromUart(int argc, char *argv[])
{
	int start, time_out;
	int load_addr = DFT_DOWNLOAD_ADDR;		
		
	if(argc>1)
	{
		start = strtoul(argv[1]);
		if(load_addr>0)
			load_addr = start;						
	}
	start = load_addr;
	
#define WAIT_TIME	0x500000	
	time_out = WAIT_TIME;	
	do{
		if(kbhit())
		{
			*((unsigned char *)load_addr++) = getkey();
			time_out = WAIT_TIME;
		}
	}while(--time_out);
	
	printf("Received 0x%x bytes from serial port.\n", load_addr-start);
	
	return 0;
#undef	WAIT_TIME	
}

int RunProgram(int argc, char *argv[])
{
	void (*fp)(void) = (void (*)(void))DFT_DOWNLOAD_ADDR;
	
	if(argc>1)
	{
		int	p = strtoul(argv[1]);
		if(p>0)
			fp = (void (*)(void))p;			
	}
	
	printf("Run program from 0x%x, are you aure? [y/n]", fp);
	
	while(1)
	{
		if(kbhit())
		{
			int key = getkey();
			if(key=='y'||key=='Y')
			{
				putch(key);
				next_line();
				break;
			}
			if(key=='n'||key=='N')
			{
				putch(key);
				next_line();
				return 0;
			}				
		}
	}
	
	(*fp)();
	
	return 0;		
}

extern unsigned int BaudParameters[6];
int SetBaudRate(int argc, char *argv[])
{
	int i;	
	
	for(i=0; i<6; i++)
		printf("%d : %d\n", i, BaudParameters[i]);
		
	puts("Please enter choice : ");
	
	while(1)
	{
		int ch = getch();
		
		if(ch<='6'||ch>='0')
		{
			SERIAL_BAUD = BaudParameters[ch-'0'];
			printf("Baud rate set to : %d\nPress any key to continue\n", SERIAL_BAUD);
			i = 0x4000;
			while(i--);		//wait transmit end
			console_init(SERIAL_BAUD);
			getch();
			break;
		}
			
	}	

	return 0;
}

/************************************************/
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", "show help", Help},
					{"?", "= help", Help},	
					{"load", "load file to memory", LoadFile2Mem},
					{"prog", "program flash", ProgFlash},
					{"boot", "boot from flash", BootLoader},
					{"ap", "auto load image flie and program flash", AutoProgFlash},
					{"comload", "load file from serial port", LoadFromUart},
					{"run", "run from ram", RunProgram},									
					{"copy", "copy flash from src to dst address", CopyFlash},
					{"ipcfg", "show or set IP address", SetIPAddr},
					{"setbaud", "set baud rate", SetBaudRate},
					{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[MAX_ARGS];

	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;			
}

/************************************************/

int main()
{
	char command[MAX_CMD_LEN];
	char key;
	int i;
//	unsigned short tmp[32];
	
	console_init(DFT_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 help 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);	
	
	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;