cmd.c.svn-base

realtek的8186芯片ADSL路由AP源代码

/******************************************************************
 *
 *	Cmd.c : Bootloader command parser routine
 *
 * History:
 * 10/23/2006  SH, Lee	Added flashsize, memsize, miisel commands
 *
 *****************************************************************/

#include "uart.h"
#include "zlib.h"
#include "board.h"
#include "mib.h"
#include "osk.h"	
#ifndef ERROR
#define ERROR 	-1
#endif

#ifndef OK
#define OK		0
#endif

#ifndef TRUE
#define TRUE	1
#endif

#ifndef FALSE
#define FALSE	0
#endif

#ifndef NULL
#define NULL	0
#endif

extern board_param_t bParam;

#ifdef CONFIG_RTL867X_LOADER_SUPPORT_HTTP_SERVER
#define LOADER_HELP \
	"help\n\r"\
	"info\n\r"\
	"reboot\n\r"\
	"run [app addr] [entry addr]\n\r"\
	"r [addr]\n\r"\
	"w [addr] [val]\n\r"\
	"d [addr] <len>\n\r"\
	"resetcfg\n\r"\
	"mac [\"clear\"/\"osk\"/mac address]\n\r"\
	"bootline\n\r"\
	"entry [address]\n\r"\
	"load [address]\n\r"\
	"app [address]\n\r"\
	"xmodem [address]\n\r"\
	"bootp\n\r"\
	"tftp [ip] [server ip] [file name]\n\r"\
	"web\n\r"
#else
#define LOADER_HELP \
	"help\n\r"\
	"info\n\r"\
	"reboot\n\r"\
	"run [app addr] [entry addr]\n\r"\
	"r [addr]\n\r"\
	"w [addr] [val]\n\r"\
	"d [addr] <len>\n\r"\
	"resetcfg\n\r"\
	"mac [\"clear\"/\"osk\"/mac address]\n\r"\
	"bootline\n\r"\
	"entry [address]\n\r"\
	"load [address]\n\r"\
	"app [address]\n\r"\
	"xmodem [address]\n\r"\
	"bootp\n\r"\
	"tftp [ip] [server ip] [file name]\n\r"
#endif

int s2mac(char *mac, char *mac_str)
{
char chk_str[17];
int i, j;

	strcpy(chk_str, "0123456789abcdef");
	if(strlen(mac_str)!=12)
		return ERROR;
	
	for(i=0; i<12; i++)
	{
		/* to lower case */
		if(mac_str[i]>='A' && mac_str[i]<='F')
			mac_str[i] -= 0x20;
		for(j=0;j<16;j++)
		{
			if(mac_str[i]==chk_str[j])
			{
				mac[i/2] = (mac[i/2] << 4) | j;
				break;
			}
		}
		if(j==16)
			return ERROR;	/* not a HEX string */
	}	
	return OK;
}

unsigned int sd_dump_default_addr = 0x80000000;

int dump_mem(unsigned int addr, int len)
{
unsigned char	*raw,ch;
int			row,col,rowsz; 

	raw = (unsigned char *)addr;
	if (len == 0) {
 		rowsz = 20;
	}
	else {
		rowsz = (len + 15)/16;
	}
	for (row=0;row<rowsz;row++)
	{ 	
	 	// Address
 		printf("0x%08X: ",(addr + row * 16));
 		
	 	// Show HEX
 		for (col=0;col<8;col++) {
 			printf("%02X ",raw[col]);
 		}
		//printf("- ");
 		for (col=8;col<16;col++) {
 			printf("%02X ",raw[col]);
 		}

 		// Show ASCII
	 	for (col=0;col<16;col++) {
 			if ((raw[col] < 0x20) || (raw[col] > 0x7e)) {
 				ch = '.';
 			}
 			else {
 				if ((raw[col] == 0x25) || (raw[col] == 0x5c))
 					ch = '.';
 				else
 					ch = raw[col];
 			}
 			printf("%c",ch);
 		}

 		raw += 16;

 		printf("\n\r");
	
	}	// end of for
	return TRUE;	
}



#define  ASCII_CR    0x0d
#define  ASCII_LF    0x0a
#define  ASCII_BS    0x08
#define  ASCII_BELL  0x07
#define  ASCII_TAB   0x09
#define  ASCII_XON   0x11
#define  ASCII_XOFF  0x13
#define	 ASCII_SPACE	0x20


int kbd_proc(char *buf, int len)
{
char kbd_cc;
int buf_idx = 0;

	while(1)
	{
	    kbd_cc=getchar();
	    switch(kbd_cc) {
		case ASCII_LF:
		case ASCII_CR:
			buf[buf_idx]='\0';
			printf("%c", ASCII_LF);
			return(1);
		case ASCII_TAB:
			buf[buf_idx]=ASCII_SPACE;
		    if(buf_idx<len)
			{
				buf_idx++;
				printf("%c", ASCII_SPACE);
			}
			else 
				printf("%c", ASCII_BELL);
			break;
		case ASCII_BS:
			if(buf_idx>0) {
				buf_idx--;
				printf("%c%c%c", ASCII_BS, ASCII_SPACE, ASCII_BS);
			}
			break;
		default:
			buf[buf_idx]=kbd_cc;
		    if(buf_idx<len)
		    {
				buf_idx++;
				printf("%c", kbd_cc);
			}
			else 
				printf("%c", ASCII_BELL);
	    }
	}
}


unsigned long str2UL(char *str) 
{
	unsigned long	ul;
	unsigned char	ch;
	int				i;
	
	ul = 0;
	if ((str[0] == '0' && str[1] == 'X') ||
		(str[0] == '0' && str[1] == 'x'))
	{
		// Hex Mode
		for (i=2;i<strlen(str);i++)	{			
			ch = IsHexNumber(str[i]);
			if (ch == 0xff)	{ /* illegal char. */
				break;
			}			
			ul <<= 4;
			ul |= ch;
		}
	}
	else {
		// DEC Mode
		for (i=0;i<strlen(str);i++)	{
		
			ch = str[i];				
			if (ch < '0' || ch > '9')	{ /* illegal char. */
				break;
			}			
			ul *= 10;
			ul += (ch - '0');
		}			
	}
	
	return ul;
}

char cmd_prompt[] = "<RTL8671>";
#define MAX_ARGS	20
#define MAX_ARG_LEN	20

int cmd_proc(char *buf)
{
unsigned int	i;
char argv[MAX_ARGS][MAX_ARG_LEN+1];
int	argc = 0;
int arg_idx = 0;

	for(i=0; buf[i]!='\0'; i++)
	{
		if(buf[i]==' '){
			argv[argc][arg_idx]='\0';
			argc++;
			arg_idx=0;
		}
		else {
			if(arg_idx<MAX_ARG_LEN)
			{	
				argv[argc][arg_idx]=buf[i];
				arg_idx++;
			}
		}
	}
	argv[argc][arg_idx]='\0';
	if(arg_idx)
		argc++;

	if(!strcmp(argv[0], "help"))
	{	
		printf("%s", LOADER_HELP);
		printf("flashsize [1/2/4/8]\n\rmemsize [4/8/16]\n\rmiisel [0:Int.PHY 1:Ent.PHY]\n\r");	
	}
	else	
	if(!strcmp(argv[0], "reboot"))
	{
	void (*appStart)(void);
		appStart = (void*)0xbfc00000;
		appStart();
	}
	else
	if(!strcmp(argv[0], "r"))
		printf("%08x\n\r", *((unsigned int *)str2UL(argv[1])));
	else
	if(!strcmp(argv[0], "w"))
		*((unsigned int *)str2UL(argv[1])) = str2UL(argv[2]);
	else
	if(!strcmp(argv[0], "d"))
	{
	unsigned long daddr;
	int dlen;

		if(strlen(argv[1]))	// address field present
			daddr = str2UL(argv[1]);
		else
			daddr = sd_dump_default_addr;
		
		if(strlen(argv[2]))	// len field present
		{
			dlen = str2UL(argv[2]);
			//if(dlen>256)
			//	dlen = 256;
		}
		else
			dlen = 128;

		dump_mem(daddr, dlen);
		sd_dump_default_addr = daddr + dlen;
	}

	else
	if(!strcmp(argv[0], "ferase"))
	{
		int len;
		if (strlen(argv[2]))
			len = str2UL(argv[2]);
		else	
			len = 1;
		printf("erase %x len %x\n", str2UL(argv[1]), len);
		if(amd29lvEraseNV(str2UL(argv[1]), len) != OK) {
			printf("Config space 0 erase error!\n\r");
		}
	}
	else
	if(!strcmp(argv[0], "resetcfg"))
	{  
        char cfgbuffer[DEFAULT_SETTING_MAX_LEN+HW_SETTING_MAX_LEN+CURRENT_SETTING_MAX_LEN];
		//reset DS/CS and keep HS setting
		memset(cfgbuffer, 0xff, sizeof(cfgbuffer));
		memcpy(cfgbuffer+DEFAULT_SETTING_MAX_LEN, FLASH_BASE_ADDR+HW_SETTING_OFFSET, HW_SETTING_MAX_LEN);
		printf("reset configuration...\n\r");
		if(amd29lvEraseNV(DEFAULT_SETTING_OFFSET, DEFAULT_SETTING_MAX_LEN) != OK) {
			printf("Default setting erase error!\n\r");
		}
		if(amd29lvEraseNV(CURRENT_SETTING_OFFSET, CURRENT_SETTING_MAX_LEN) != OK) {
			printf("Current setting erase error!\n\r");
		}
		write_file(FLASH_BASE_ADDR+DEFAULT_SETTING_OFFSET, cfgbuffer, sizeof(cfgbuffer));
	}	
	else
	if(!strcmp(argv[0], "xmodem"))
	{
		xmodem_download(str2UL(argv[1]));
	}
	else
	if(!strcmp(argv[0], "run"))
	{
		if(argc==3)
		{
			run_gzip_file(str2UL(argv[1]), str2UL(argv[2]));
		}	
	}
	else
	if(!strcmp(argv[0], "mac"))
	{
		int i;
		get_param(&bParam);
		if(!strcmp(argv[1], "clear"))
		{
			memset(bParam.mac, 0, N_MAC*6);	
			if(set_param(&bParam)==ERROR)
				printf("set error!\n\r");
		}
		else
		if(!strcmp(argv[1], "osk"))
		{
			unsigned char *mac;
			/* find null record */
			for(i=0;i<N_MAC;i++)
			{
				mac = bParam.mac[i];
				if(!(mac[0]|mac[1]|mac[2]|mac[3]|mac[4]|mac[5]))
					break;
			}
			if(i<N_MAC)
			{
				if(s2mac(mac, argv[2])==OK)
				{										
					if (ERROR == set_osk_hwaddr(mac))
						printf("set error!\n\r");

				}
				else
					printf("ERROR!\n\r");
			}
			else
				printf("ERROR!\n\r");
			
		}
		else
		{
		char *mac;
			/* find null record */
			for(i=0;i<N_MAC;i++)
			{
				mac = bParam.mac[i];
				if(!(mac[0]|mac[1]|mac[2]|mac[3]|mac[4]|mac[5]))
					break;
			}
			if(i<N_MAC)
			{
				if(s2mac(mac, argv[1])==OK)
				{
					if(set_param(&bParam)==ERROR)
						printf("set error!\n\r");
				}
				else
					printf("ERROR!\n\r");
			}
			else
				printf("ERROR!\n\r");
		}
	}
	else
	if(!strcmp(argv[0], "info"))
	{
	int i;
		get_param(&bParam);
		print_banner();
		if(!strcmp(bParam.id, BOARD_PARAM_ID))
		{
			printf("BootLine: %s\n\r", bParam.bootline);
			for(i=0;i<N_MAC;i++)
			{
			unsigned char *mac = bParam.mac[i];
				if(mac[0]|mac[1]|mac[2]|mac[3]|mac[4]|mac[5])
					printf("MAC Address [%d]: %02X:%02X:%02X:%02X:%02X:%02X\n\r", i, \
						mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
				else
					break;
			}
			printf("Entry Point: 0x%08X\n\r", bParam.entry);
			printf("Load Address: 0x%08X\n\r", bParam.load);
			printf("Application Address: 0x%08X\n\r", bParam.app);
			
			printf("Flash Size: %dM\n\r", bParam.flash_size);
			printf("Memory Size: %dM\n\r", bParam.mem_size);
			printf("MII Selection: %x (0: Int. PHY  1: Ext. PHY)\n\r", bParam.MII_select);

			printf("\n\r");
		}
	}
	
	else
	if(!strcmp(argv[0], "bootp"))
	{
	unsigned int image_len;
	char *mac;
	char filename[32];
	char *load_buf;
	char *app_buf;
		get_param(&bParam);
		load_buf = (char*)bParam.load;
		app_buf = (char*)bParam.app;
		mac = bParam.mac[0];
		Lan_Initialize(mac);
        if ( bootpReceive (mac, &image_len, 0, 0, filename, load_buf) != 0 )
            printf("bootp ERROR\n\r");
		else
		{
			printf("writing file...\n\r");
			write_file(app_buf, load_buf, image_len);
		}
	}
	else
	if(!strcmp(argv[0], "tftp"))
	{
	char *mac;
	unsigned int image_len;
	unsigned int ip = inet_addr(argv[1]);
	unsigned int server = inet_addr(argv[2]);
	char * load_buf;
	char * app_buf;
	//////////////////////add by fang
	char * load_buf1;
	const int APPFLAG = APPLICATION_IMAGE ;
	unsigned char sig_n;
	///////
		get_param(&bParam);
		load_buf = (char*)bParam.load;
		app_buf = (char*)bParam.app;
		mac = bParam.mac[0];
		Lan_Initialize(mac);
        if ( bootpReceive (mac, &image_len, ip, server, argv[3], load_buf) != 0 )
              printf("TFTP ERROR\n\r");
	 else
	 {
			printf("Writing file...\n\r");
			for(sig_n = 0; sig_n<40; sig_n++)
			{
				 load_buf1 = load_buf + sig_n;
				//(IMGHDR*)load_buf1;
				//printf("the sig_n value is %d",sig_n);
				if(!memcmp(load_buf1,&APPFLAG,4))
				{
					image_len = image_len -sig_n;
					memcpy(load_buf,load_buf1,image_len);
					break;
				}
				
			}

			if(sig_n == 0 || sig_n == 40)
				printf("Find  no  signature in the image\n"); 
				
			//writeImage(load_buf+strlen(SIGNATURE));
			//printf("print for debug :%x%x%x",load_buf[0],load_buf[1],load_buf[2]);
			//load_buf1 = load_buf + strlen(SIGNATURE);
			if (writeImage(load_buf)) {
				printf("No header, assuming raw binary\n\r");
				write_file(app_buf, load_buf, image_len);
			}
				
		}
	}
	else
	if(!strcmp(argv[0], "bootline"))
	{
	char bbuf[BOARD_BOOTLINE_SZ];
		printf("Please enter new bootline: ");
		kbd_proc(bbuf, BOARD_BOOTLINE_SZ);
		get_param(&bParam);
		strcpy(bParam.bootline, bbuf);
		set_param(&bParam);
	}	
	else
	if(!strcmp(argv[0], "entry"))
	{
		get_param(&bParam);
		bParam.entry = str2UL(argv[1]);
		set_param(&bParam);
	}	
	else
	if(!strcmp(argv[0], "load"))
	{
		get_param(&bParam);
		bParam.load = str2UL(argv[1]);
		set_param(&bParam);
	}	
	else
	if(!strcmp(argv[0], "app"))
	{
		get_param(&bParam);
		bParam.app = str2UL(argv[1]);
		set_param(&bParam);
	}	
	
	else
	if(!strcmp(argv[0], "flashsize"))
	{
	  	int intval;	  	
		if(argv[1]){
			intval = str2UL(argv[1]);
			//Only support 1M/2M/4M/8M flash
			if(intval==1||intval==2||intval==4||intval==8) {
				get_param(&bParam);
				bParam.flash_size = intval;
				set_param(&bParam);
			} else {
				printf("Wrong flash size!\n\r");
			}
		}
	}	
	else
	if(!strcmp(argv[0], "memsize"))
	{
		int intval2;
		if(argv[1]) {
			intval2 = str2UL(argv[1]);
			//Only support 4M/8M/16M Memory
			if(intval2==4||intval2==8||intval2==16) {
				get_param(&bParam);
				bParam.mem_size = intval2;
				set_param(&bParam);
			} else {
				printf("Wrong memory size!\n\r");
			}
		}
	}	
	else
	if(!strcmp(argv[0], "miisel"))
	{
		if(argv[1]) {
			if(str2UL(argv[1])==0 || str2UL(argv[1])== 1) {
				get_param(&bParam);
				bParam.MII_select= str2UL(argv[1]);
				set_param(&bParam);
			} else {
				printf("Wrong MII selection setting!\n\r");
			}
		}
	}	

#ifdef CONFIG_RTL867X_LOADER_SUPPORT_HTTP_SERVER
	else
	if(!strcmp(argv[0], "web"))
	{
		get_param(&bParam);
	    rs_httpd();
	}	
#endif	
	else
	if(!strcmp(argv[0], "tt"))
	{
		printf("time=%d\n\r", get_sys_time());
	}	
		
	memset(argv, 0, sizeof(argv));
	printf("%s", cmd_prompt);
	return TRUE;
}