shell.c

44b0的uClinux的启动bios 有非常详细的注释 很难得的

- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/
int LoadFile2Mem(int argc, char *argv[])
{
	unsigned char key;

	if(argc<2)
		download_addr = DFT_DOWNLOAD_ADDR;
	else
		download_addr = strtoul((unsigned char*)argv[1]);

	ResetNic();
	Uart_Printf("No begin address for download, use address 0x%x\n", download_addr);
	Uart_Printf("Load image file from host\n");
	Uart_Printf("Type tftp -i %d.%d.%d.%d put filename at the host PC\n", (IP_ADDRESS>>24)&0xff, (IP_ADDRESS>>16)&0xff, (IP_ADDRESS>>8)&0xff, IP_ADDRESS&0xff);
	Uart_Printf("Press ESC key to exit\n");	

	download_begin = 1;
	download_end = 0;
	
	while (1) 
	{
		NetSever();
		if ((key=Uart_GetKey())==ESC_KEY)
		{
			Uart_SendByte('\n');
			download_begin = 0;
			return 0;
		}
		if(download_end)
		{
			download_begin = 0;
			download_end = 0;
			return 0;
		}
	}
}

/*
*************************************************************************************************************
- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/
int LoadFromUart(int argc, char *argv[])
{
	int start, time_out;
	int load_addr = DFT_DOWNLOAD_ADDR;
		
	if(argc>1)
	{
		start = strtoul((unsigned char*)argv[1]);
		if(load_addr>0)
			load_addr = start;						
	}
	start = load_addr;
	
	time_out = WAIT_TIME;	
	do{
		if(rUTRSTAT0&0x1)
		{
			*((unsigned char *)load_addr++) = Uart_GetKey();
			time_out = WAIT_TIME;
		}
	}while(--time_out);
	
	Uart_Printf("Received 0x%x bytes from serial port.\n", load_addr-start);
	
	return 0;
}
/*
*************************************************************************************************************
- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/

int RunProgram(int argc, char *argv[])
{
	unsigned char key;
	
	void (*fp)(void) = (void (*)(void))DFT_DOWNLOAD_ADDR;
	
	if(argc>1)
	{
		int	p = strtoul((unsigned char *)argv[1]);
		if(p>0)
			fp = (void (*)(void))p;			
	}
	
	Uart_Printf("Run program from 0x%x, are you aure? [y/n]", fp);
	
	while(1)
	{
		key = Uart_GetKey();
		if(key)
		{
			if(key=='y'||key=='Y')
			{
				Uart_SendByte(key);
				Uart_SendByte('\n');
				break;
			}
			if(key=='n'||key=='N')
			{
				Uart_SendByte(key);
				Uart_SendByte('\n');
				return 0;
			}				
		}
	}
	
	(*fp)();
	
	return 0;		
}
/*
*************************************************************************************************************
- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/

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

	if(argc<4)
	{		
		Uart_Printf("Arguments error!\n");
		Uart_Printf("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((unsigned char *)argv[1]);			
	data_begin = strtoul((unsigned char *)argv[2]);
	size       = strtoul((unsigned char *)argv[3]);
	
	if(size==0)
	{
		Uart_Printf("Write 0 Bytes!\n");
		return -1;
	}
	
	if(prog_begin==-1||data_begin==-1)		//
	{
		Uart_Printf("Arguments error\n");
		return -1;
	}	
	
	Uart_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)
	{
		key = Uart_GetKey();
		if(key)
		{
			if(key=='y'||key=='Y')
			{
				Uart_SendByte(key);
				Uart_SendByte('\n');
				break;
			}
			if(key=='n'||key=='N')
			{
				Uart_SendByte(key);
				Uart_SendByte('\n');
				return 0;
			}				
		}
	}		

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

	cache_cfg = rNCACHBE0;
	rNCACHBE0 = 0x20000000;
	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);	
	}

	rNCACHBE0 = cache_cfg;
	
	return 0;
}
/*
*************************************************************************************************************
- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/

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

	cache_cfg = rNCACHBE0;
	rNCACHBE0 = 0x20000000;
	FlashRead(src, (unsigned short *)DFT_DOWNLOAD_ADDR, size);
	rNCACHBE0 = cache_cfg;

	argv[1] = argv[2];
	argv[2] = tmp;
	ultostr((unsigned char *)tmp, DFT_DOWNLOAD_ADDR);
	
	ProgFlash(4, argv);

	return 0;
}

/*
*************************************************************************************************************
- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/
int BootLoader(int argc, char *argv[])
{
	unsigned char key;
	
	Uart_Printf("boot from flash, are you sure? [y/n]");
	while(1)
	{
		key = Uart_GetKey();
		if(key)
		{
			if(key=='y'||key=='Y')
			{
				void (*fp)(void) =(void (*)(void))BIOS_LOAD;
				Uart_SendByte(key);
				Uart_SendByte('\n');
				(*fp)();							
			}
			if(key=='n'||key=='N')
			{
				Uart_SendByte(key);
				Uart_SendByte('\n');
				break;	
			}
		}			
	}
	
	return 0;
}
/*
*************************************************************************************************************
- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/

int BackupBios(int argc, char *argv[])
{
	unsigned char key;
	unsigned int cache_cfg;

	Uart_Printf("move bios to the top of rom,are you sure? [y/n]");

	while(1)
	{
		key = Uart_GetKey();
		if(key)
		{
			if(key=='y'||key=='Y')
			{
				Uart_SendByte(key);
				Uart_SendByte('\n');
				break;
			}
			if(key=='n'||key=='N')
			{
				Uart_SendByte(key);
				Uart_SendByte('\n');
				return 0;
			}				
		}
	}		

	cache_cfg = rNCACHBE0;
	rNCACHBE0 = 0x20000000;
	FlashRead(0, (unsigned short *)DFT_DOWNLOAD_ADDR, 0xf000);
	SectorProg(BIOS_BASE, (unsigned short *)DFT_DOWNLOAD_ADDR, 0xf000);
	rNCACHBE0 = cache_cfg;

	return 0;
}
/*
*************************************************************************************************************
- 函数名称 : void RtcSetDay(TIME_STRUC *time)
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/

int MemoryDisplay(int argc, char*argv[])
{
	unsigned int sys_cfg;
	unsigned int src;
	unsigned int i, j;
	unsigned int *data;
	
	if(argc < 2)
		src = 0;
	else
	{
		src  = strtoul((unsigned char *)argv[1]);
		if(src%4 != 0) src-=src%4;
	}
	
	data = (unsigned int *)src;
	Uart_Printf("0x%8.8x: ",data);
	
	sys_cfg = rSYSCFG;
	rSYSCFG = 0x08;
	
	for(i=0;i<22;i++)
	{
		for(j=0;j<4;j++)
			Uart_Printf("%8.8x ",*data++);
		if(i<21)
			Uart_Printf("\n0x%8.8x: ",data);
	}
	Uart_SendByte('\n');

	rSYSCFG = sys_cfg;

	return 0;
}
/*
*************************************************************************************************************
- 函数名称 : int Flash2Mem(int argc, char*argv[])
- 函数说明 : 设定日
- 输入参数 : TIME_STRUC *time
- 输出参数 : 无
*************************************************************************************************************
*/

int Flash2Mem(int argc, char*argv[])
{
	unsigned int src, dst, size, i;
	unsigned int cache_cfg;
	unsigned int *data_src, *data_dst;
	
	if(argc<4)
	{
		Uart_Printf("Usage : move a1 a2 size\n");
		Uart_Printf("a1 = src address, a2 = dst address, size = copy bytes (all in hex)\n");
		return -1;
	}

	src  = strtoul((unsigned char *)argv[1]);
	dst  = strtoul((unsigned char *)argv[2]);
	size = strtoul((unsigned char *)argv[3]);

	if(src==-1||dst==-1||size==-1||(dst-size)<src)
	{
		Uart_Printf("give error address\n");
		return	-1;
	}	
	data_src = (unsigned int *)src;
	data_dst = (unsigned int *)dst;

	cache_cfg = rNCACHBE0;
	rNCACHBE0 = 0x20000000;
	size = size%4 ? size/4+1 : size/4;
	for(i=0;i<size;i++)
		*data_dst++ = *data_src++;
	rNCACHBE0 = cache_cfg;

	Uart_Printf("move finished!\n");

	return 0;
}

void BootFromFlash(void)
{
    int p;
    unsigned int src = 0x10000, dst = 0x0c000000, size = 0x100000, i;
	unsigned int cache_cfg;
	unsigned int *data_src, *data_dst;
    void (*fp)(void) = (void (*)(void))RUN_ADDR;
    
    //cache_cfg = rNCACHBE0;
    //rNCACHBE0 = 0x20000000;
	//data_src = (unsigned int *)src;
	//data_dst = (unsigned int *)dst;
	data_src = (unsigned int *)0x10000;
	data_dst = (unsigned int *)0x0c000000;
	size = size%4 ? size/4+1 : size/4;
	for(i=0;i<size;i++)
	*data_dst++ = *data_src++;
	//rNCACHBE0 = cache_cfg;
	Delay(10);
	//run command
	p = 0x0c000000;
	fp = (void (*)(void))p;
	(*fp)();
}