command.c

深圳优龙科技LPC2468开发板BIOS.

/*****************************************************************************
 *   command.c:  BIOSBOX 命令实现
 *
 *   Copyright(C) 2007, uCdragon
 *   All rights reserved.
 *
 *   History
 *   2007.03.16  [e-mail]
 *
******************************************************************************/
#include "def.h"
#include "board.h"
#include "utils.h"

#define DEFAULT_DOWN_ADDRESS  0x40004000
#define MAX_CMD_LEN           80
#define MAX_CMD_PARAM         5

//think of big endian,don't use *(U32 *)
#define b2l(pb) (pb[0] | (pb[1] << 8) | (pb[2] << 16) | (pb[3] << 24))

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

void BootLinux(U32 address);
void Help( int argc , char* argv[] );

U32 download_addr = DEFAULT_DOWN_ADDRESS;
U32 download_len = 0;

//中断入口内容不可确定,不要用中断
void LoadFromUart( int argc , char* argv[] )
{
	int i, size;
	U16 old_sum, check_sum;
	U8 * buf ;
	U8 temp[8];

	if(argc >= 2) download_addr = strtoul (argv[1]);

	buf = ( U8 * ) download_addr;

	printf( "Downing file from uart to 0x%x...\n" , download_addr );
	i = 0;
	while ( i < 4 )
		temp[i++] = getch();
	i = 0;
	size = b2l( temp ) - 4;
	while ( i < size )
		buf[i++] = getch();

	download_len = size - 2;	

	old_sum = ( buf[size - 1] << 8 ) | buf[size - 2];
	check_sum = 0;
	for ( size -= 3; size >= 0; size-- )
		check_sum += buf[size];
	if ( old_sum != check_sum )
	{
		puts( "\ncheck_sum error!\n" );
		download_len = 0;
	}
	else
		printf( "\nReceived %x bytes success\n" , download_len );
}

//*****************************************************************************
void RunProgram( int argc , char* argv[] )
{
	UTILS u = {getch,putch,puts,printf,Delay,SetInterrupt};
	int ( *fp ) ( PUTILS) = ( int ( * ) (PUTILS) ) download_addr;
	u.printf("running from 0x%0x\n",download_addr);
	( *fp ) ( &u );		//add by lqm
}

void UartLoadRun( int argc , char* argv[] )
{
	LoadFromUart( argc , argv );
	RunProgram( 0 , 0 );
}
typedef int (*ProgFunction)(U32,U32,U32);
void ProgCommon( int argc , char* argv[] ,ProgFunction fProg)
{
	U32 flash = (argc >= 2)? strtoul (argv[1]) : 0;
	U32 ram = (argc >= 3)? strtoul (argv[2]) : download_addr;
	U32 len =(argc >= 4)? strtoul (argv[3]) : download_len;
	if(len)
	{
		U32 result = fProg(flash,ram,len);
		if(result) printf("\nfailed to program %x\n",result);
	}
	else puts("nothing to program\n");
}
#if IAP_SUPPORT
int SectorProg(U32 begin, U32 data, U32 size);
void ProgFlash( int argc , char* argv[] )
{
	ProgCommon(argc,argv,SectorProg);
}
#endif //IAP_SUPPORT

void MemoryShow( int argc , char* argv[] )
{
	if ( argc >= 2 )
	{
		U32 address =  strtoul (argv[1]);
		U32 len = argc >=3 ? strtoul (argv[2]):1;
		U32 count = 0;
		printf("value of 0x%08x is ",address);
		while(len--) 
		{
			if(!(count++ & 7)) putch('\n');
			printf(" %08x",REGVALUE(address));
			address += 4;
		}
		putch('\n');
	}
	else printf("Usage : memd address [length]\n");
}
void MemorySet( int argc , char* argv[] )
{
	if ( argc >= 3)
	{
		U32 address =  strtoul (argv[1]);
		REGVALUE(address) =  strtoul (argv[2]);
		printf("value of 0x%-8x is 0x%x\n",address,REGVALUE(address));
	}
	else printf("Usage : mems address value\n");
}
void MemoryCopy(U32 * dest,U32 * src,U32 len)
{
	len >>= 2;
	while(len--) * dest ++ = * src ++;
}

#if MCI_SUPPORT
BOOL CheckMCI()
{
	if ( (CardType = MCI_CardInit()) == CARD_UNKNOWN )
	{
		puts("no card found\n");
		return FALSE;
	}
	printf("%s card found\n",CardType == MMC_CARD?"MMC":"SD");
	if ( MCI_Check_CID() != TRUE )
	{
		goto exit;
	}

	if ( MCI_Set_Address() != TRUE )
	{
		goto exit;
	}
	if ( MCI_Send_CSD() != TRUE )
	{
		goto exit;
	}
	if ( MCI_Select_Card() != TRUE )
	{
		goto exit;
	}
	if ( CardType == SD_CARD )
	{
		if ( MCI_Send_ACMD_Bus_Width( BUS_WIDTH_4BITS ) == FALSE )
		{
			goto exit;
		}
	}
	if ( MCI_Set_BlockLen( BLOCK_LENGTH ) != TRUE )
	{
		goto exit;
	}
	return TRUE;
exit:
	puts("Card is not ready,try again\n");
	return FALSE;

}
//loadm startblock blocknum toaddress
void LoadMCI(int argc , char* argv[] )
{
	U32 start = (argc >= 2) ? strtoul (argv[1]) : 0;
	U32 end = (argc >= 3) ? strtoul (argv[2]) : 1;
	if(argc >= 4) download_addr = strtoul (argv[3]);
	if(!end) end = 1;
	printf("Loading from MCI block %d-%d to 0x%x\n",start,end+start-1,download_addr);
	if(CheckMCI())
	{
		U32 buf = download_addr;
		download_len = end  << DATA_BLOCK_LEN;
		end+=start;
		while(start < end)
		{
			if ( MCI_Read_Block( start , (U32 *)buf) != TRUE )
			{
				download_len = 0;
				printf("Error reading block %d\n",start);
				return;
			}
			putch('.');
			start++;
			buf += BLOCK_LENGTH;
		}
	}
}
int ProgMCI2(U32 start, U32 buf, U32 size)
{
	printf("program from 0x%x,Len %d to block %x ?[n/y]\n",buf,size,start);
	if(getch() != 'y') 
	{
		puts("program cancelled\n");
		return 0;
	}
	size = (size + BLOCK_LENGTH -1) >> DATA_BLOCK_LEN; 
	if(CheckMCI())
	{
		while(size -- )
		{
			if ( MCI_Write_Block( start , (U32 *)buf) != TRUE )
			{
				return 1;
			}
			putch('.');
			start++;
			buf += BLOCK_LENGTH;
		}
	}
	return 0;
}
void ProgMCI( int argc , char* argv[] )
{
	ProgCommon(argc,argv,ProgMCI2);
}
#endif //MCI_SUPPORT
#if NAND_FLASH_SUPPORT
//loadm startblock blocknum toaddress
void LoadNand(int argc , char* argv[] )
{
	U32 start = (argc >= 2) ? strtoul (argv[1]) : 0;
	U32 end = (argc >= 3) ? strtoul (argv[2]) : 1;
	if(argc >= 4) download_addr = strtoul (argv[3]);
	if(!end) end = 1;
	printf("Loading from nand sector %d-%d to 0x%x\n",start,end+start-1,download_addr);
	if(NandInit())
	{
		U32 buf = download_addr;
		download_len = end  << NAND_SECTOR_SHIFT;
		end+=start;
		while(start < end)
		{
			NFReadPage( start, (U8 *)buf);
			putch('.');
			start++;
			buf += NAND_SECTOR_LEN;
		}
	}
	else printf("No nand flash found\n");
}
int ProgNand2(U32 start, U32 buf, U32 size)
{
	printf("program from 0x%x,Len %d to sector %x ?[n/y]\n",buf,size,start);
	if(getch() != 'y') 
	{
		puts("program cancelled\n");
		return 0;
	}
	size = (size + NAND_SECTOR_LEN -1) >> NAND_SECTOR_SHIFT; 
	if(NandInit())
	{
		U32 first = TRUE;
		while(size -- )
		{
			if(first || (!(start&(NAND_SECTOR_LEN -1))))
			{
				if(NFEraseBlock(start)) return 1;
				printf("erased %d\n",start);
				first = FALSE;
			}
			if ( NFWritePage( start, (U8 *)buf))
			{
				return 1;
			}
			putch('.');
			start++;
			buf += NAND_SECTOR_LEN;
		}
	}
	else printf("No nand flash found\n");
	return 0;
}
void ProgNand( int argc , char* argv[] )
{
	ProgCommon(argc,argv,ProgNand2);
}
#endif //NAND_FLASH_SUPPORT
const CMD_STRUC CMD_INNER[] =
{
	{"help", "show this list", Help}, 
	{"?", "show this list", Help},
	//{"setbaud", "set or show baud rate", ChangeBaud},
	{"comload", "download file by uart", LoadFromUart},
	{"comrun", "download file by uart and run", UartLoadRun},
	{"run", "run program", RunProgram},
	{"memd", "show memory", MemoryShow},
	{"mems", "set memory", MemorySet},
#if IAP_SUPPORT
	{"prog", "program flash", ProgFlash},
#endif //IAP_SUPPORT
#if MCI_SUPPORT
	{"progm", "program to mmc", ProgMCI},
	{"loadm", "load from mmc", LoadMCI},
#endif //MCI_SUPPORT
#if NAND_FLASH_SUPPORT
	{"progn", "program to nand flash", ProgNand},
	{"loadn", "load from nand flash", LoadNand},
#endif //NAND_FLASH_SUPPORT
	{0, 0, 0}
};

void Help( int argc , char* argv[] )
{
	int i;
	if(argc > 1) 
	{
		SecInitBoard();
		return;
	}
	for ( i = 0; CMD_INNER[i].cmd != 0; i++ )
	{
		if ( CMD_INNER[i].hlp != 0 )
		{
			printf( "%-8s  ------  %s\n" , CMD_INNER[i].cmd ,
				CMD_INNER[i].hlp );
		}
	}
}
int FindCommand(char * cmd)
{
	int i;
	for(i=0;CMD_INNER[i].cmd;i++) 
		if(strncmp(cmd,CMD_INNER[i].cmd,MAX_CMD_LEN) == 0) return i;
	return -1;
}
void ExcuteCommand(char * cmd)
{
	char buf[MAX_CMD_LEN];
	char * argv[MAX_CMD_PARAM];
	int argc = 0;
	int new_arg = 1;
	int index = 0;
	putch('\n');
	for(; *cmd && argc < MAX_CMD_PARAM; cmd++)
	{
		if(*cmd !=' ') buf[index++] = *cmd;
		
		if((*cmd != ' ') ^ new_arg) continue;
		if(new_arg) argv[argc++] = buf+index-1;
		else 
		{
			buf[index++] = 0; 
		}
		new_arg = !new_arg;
	}
	buf[index] = 0;
	if(argc)
	{
		index = FindCommand(argv[0]);
		if(index >= 0) CMD_INNER[index].proc(argc,argv);
		else printf("command not found :%s \n",argv[0]);
	}
}