booter.c

au1200下的boot代码

#include "booter.h"

#include "example.h"
#include "util.h"

#include "filesystem.h"
#include "flash.h"

#include "srec.h"
#include "elf.h"
#include "bin.h"
#include "bz2.h"

#include "pcmcia.h"
#include "nor.h"
#include "gpio.h"
#include "i2c.h"

#ifdef LCD_STATUS
#include "lcd_control.h"
#endif

#define APP_NAME		"AutoBoot"
#define APP_REVISION	"01.10"

void displayWelcomeScreen()
{
	printf("\n\n%s, Revision %s\n", APP_NAME, APP_REVISION);

	#ifdef _LCD_OUTPUT_
		lcdInit();
		lcdDisplayWelcomeScreen();
	#endif
}

void displayNoImage()
{
	printf("Unable to locate any bootable images\n");

	#ifdef _LCD_OUTPUT_
		lcdDisplayNoImage();
	#endif
}

void displayEntryPoint(void* entryPoint)
{
	printf("Program Entry Point: %X\n", entryPoint);
	printf("Executing Application\n");

	#ifdef _LCD_OUTPUT_
		lcdDisplayEntryPoint(entryPoint);
	#endif
}

char * t_argv[] = {0};
#ifdef SECUREBOOT
char * t_envp[] = {
"MAC=0",
"bootfile=/booter.rec",
"bootprot=tftp",
"bootserport=tty0",
"bootserver=192.168.0.1",
"ethaddr=00.00.1a.19.0b.f7",
"gateway=192.168.0.1",
"ipaddr=192.168.0.2",
"memsize=0x08000000",
"modetty0=115200,n,8,1,none",
"modetty1=115200,n,8,1,none",
"prompt=YAMON",
"subnetmask=255.255.255.0",
0,
};

#else
char * t_envp[] = {0};
#endif

int execute(void* address, int argc, char* argv[], char* env[])
{
	typedef int(*EXECUTE)(int, char**, char**);
	EXECUTE executeFunction = (EXECUTE) address;
	if( argc == NULL)
	{
		argc = 1;
		argv = t_argv;
		env = t_envp;
	}
	cpuDisableIrqs();

	return executeFunction(argc, (char**) argv, (char**) env);
}

void* findImage(const char** files, const char** addresses, void* jumpAddress)
{
	void* entryPoint;

#if defined(CONFIG_HWBLOCK_SD)
	(entryPoint = loadSDMS (files))		||
#endif
#if defined(CONFIG_HWBLOCK_NOR_FLASH)
	(entryPoint = loadFlash(addresses))	||
#endif
#if defined(CONFIG_HWBLOCK_IDE)
 	(entryPoint = loadIDE(files))		||
#endif
#if defined(CONFIG_HWBLOCK_PCMCIA)
	(entryPoint = loadPCMCIA(files))	||
#endif
	(entryPoint = jumpAddress);

	return entryPoint;
}

void* loadImage(DataFunctions functions, const char* fileName)
{
	void* entryPoint;
	char Bz2Name[9];
	char* Name = (char*)fileName;

	if (entryPoint = bz2LoadImage(functions, Name))
	{
		functions = getFlashFunctions();
		sprintf(Bz2Name, "%X", entryPoint);
		Name = Bz2Name;
	}

	if( (entryPoint = binLoadImage(functions, Name))	||
		(entryPoint = srecLoadImage(functions, Name))	||
		(entryPoint = elfLoadImage(functions, Name))	)
		return entryPoint;

	return (void*) 0;
}

#if defined(CONFIG_HWBLOCK_NOR_FLASH) | defined(CONFIG_HWBLOCK_NAND_FLASH)
void* loadFlash(const char** addresses)
{
	int i;
	void* entryPoint = 0;

	for(i = 0; addresses[i] != 0 && !entryPoint; ++i)
	{
		if(addresses[i][0] == 'N')	//Nand image
		{
			#ifdef CONFIG_HWBLOCK_NAND_FLASH
				entryPoint = loadImage(getNandFunctions(), addresses[i]);
			#endif
		}
		else
			entryPoint = loadImage(getFlashFunctions(), addresses[i]);
	}

	return entryPoint;
}
#endif

#if defined(CONFIG_HWBLOCK_PCMCIA)
void* loadPCMCIA(const char** files)
{
	int i, j, slots;
	void* entryPoint = 0;

	for(i = 0; i < 2 && !entryPoint; ++i)
	{
		if(filesystemLoad(PCMCIA, i))
			for(j = 0; files[j] != 0 && !entryPoint; ++j)
				entryPoint = loadImage(getFilesystemFunctions(), files[j]);

		filesystemClose (PCMCIA, i);
	}

	return entryPoint;
}
#endif

#if defined(CONFIG_HWBLOCK_IDE)
void* loadIDE(const char** files)
{
	int i, j, disks;
	void* entryPoint = 0;

	if(filesystemLoad(IDE, 0))
		for(j = 0; files[j] != 0 && !entryPoint; ++j)
			entryPoint = loadImage(getFilesystemFunctions(), files[j]);

	filesystemClose (IDE, 0);

	return entryPoint;
}
#endif

#if defined(CONFIG_HWBLOCK_SD)
void* loadSDMS (const char** files)
{
	int i, j, slots;
	void* entryPoint = 0;

	for (i = 0; (i < SD_NUM_SLOTS) && (!entryPoint); ++i)
	{
		if (filesystemLoad (SDMS, i))
			for (j = 0; files[j] != 0 && !entryPoint; ++j)
				entryPoint = loadImage (getFilesystemFunctions (), files[j]);

		filesystemClose (SDMS, i);
	}

	return entryPoint;
}
#endif

void* loadBootImage()
{
	const char** files;
	const char** addresses;
	void* jumpAddress;
#ifdef SECUREBOOT
	if(HSSGetBootData(&files, &addresses, &jumpAddress))
#else
	if(platformGetBootData(&files, &addresses, &jumpAddress))
#endif
	{
		//printf("files: %X, address: %X, jump: %X\n", files, addresses, jumpAddress);
		return findImage(files, addresses, jumpAddress);

	}
}

#define CTRL_C          ('C'-0x40)

void doboot(unsigned int address, int argc, char* argv[], char* env[])
{
	void* entryPoint;
	char filename[9];

	if(address)
	{
		sprintf(filename, "%X", address);
		entryPoint = loadImage(getFlashFunctions(), filename);
	}
	else
	{	
		entryPoint = loadBootImage();
	}

	if(entryPoint)
	{
		displayEntryPoint(entryPoint);

#ifdef _LCD_OUTPUT_
		lcd_shutdown();
#endif
		execute(entryPoint, argc, argv, env);
#ifdef _LCD_OUTPUT_
		lcdInit();
#endif
	}
	else
	{
		displayNoImage();
	}
}

void doloadsrec(unsigned int len)
{
	int ch, count = 0;
	char *tmp = (char *)0xA3000000;
	DataFunctions functions;
	void* entryPoint;

	if(len == 0)
		len = 0xffffffff;

	while(len--)
	{
		ch = platformGetChar();
		if(ch == CTRL_C)
			break;
		count++;
		*tmp++ = ch;
	}

	if(count)
	{
		functions = getFlashFunctions();
		if(entryPoint = srecLoadImage(functions, "A3000000"))
			printf("Entry point: 0x%x\n", (int)entryPoint);
		else
			printf("Load srec file error\n");
	}
}

void doloadbin(void *dest, unsigned int len)
{
	char *tmp = (char *)dest;

	while(len--)
		*tmp++ = platformGetChar();
	printf("Load bin file sucessfully\n");
}

void docopy(unsigned int src, unsigned int dst, unsigned int len)
{
	unsigned int address;

	if(((src & 0xd0000000) == 0x80000000) &&
		((dst & 0xd0000000) == 0x90000000))
	{
		dst |= 0x20000000;

		printf("Copy 0x%x bytes from 0x%x to 0x%x\n", len, src, dst);
		printf("Eraseing...\n");

		for(address = dst & 0xffff0000; address < (dst + len); address += 0x00010000)
			nor_erase((void *)address);

		printf("Programing...\n");
		nor_program((void *)src, len, (void *)dst);
	}
}

void dogo(unsigned int address)
{
	void (*pfunc)() = (void *)address;

	(*pfunc)();
}

void dodump(unsigned int address, unsigned int len)
{
	unsigned char *pdata = (unsigned char *)address;
	int i;

	for (i = 0; i < len; i++)
	{
		printf("%2x ", pdata[i]);
		if ((i & 15) == 15)
			printf("\n");
	}
	if ((i & 15) != 0)
		printf("\n");
}

void dowrite(unsigned int address, unsigned int len, unsigned int val)
{
	unsigned char *pdata = (unsigned char *)address;
	int i;

	for (i = 0; i < len; i++)
		pdata[i] = (val >> (i * 8)) & 0xff;
}

void checkpower(void)
{
	unsigned char buf[2];

	buf[0] = 0x00;
	if (i2c_read(0x50 >> 1, buf, 1, 1)) {
		if ((buf[0] != 0) && (buf[0] <= 131)) {
			printf("low power: %d\n", buf[0]);

			buf[0] = 0x00;
			buf[1] = 0xfa;
			i2c_write(0x50 >> 1, buf, 2);
		}
	}
}

int main(int argc, char* argv[], char* env[])
{
	char cmd[256];
	unsigned int dst, src, len;
	cpuDisableIrqs();
	//i2cOpen();

	//displayWelcomeScreen();
/*	while(1)
		{
		platformPutChar('s');
		printf("hello world\n\r");
		msdelay(1000);
	};*/
	printf("booter SDRAM version\n\r");
	checkpower();
	printf("check power finished\n\r");
#ifdef SECUREBOOT
	if(authenticate())
		return(1); /* authentication failed */
#endif
/*
	// prepare IDE
#if defined(CONFIG_HWBLOCK_IDE)
	ide_init();

	checkpower();
#endif

	// manul or auto boot
#if defined(AUTO_BOOT_SWITCH)
	if(!!gpioRead(AUTO_BOOT_SWITCH) == AUTO_BOOT_SWITCH_ACTIVE)
		doboot(0, argc, argv, env);
#endif

#ifdef _LCD_OUTPUT_
		lcdDisplayEntryPoint(0);
#endif
*/
	while(1)
	{
		printf("\n\rsdram %s:>", APP_NAME);
		gets(cmd);

		checkpower();

		if(!strncmp(cmd, "boot", 4))
		{
			dst = 0;
			sscanf(&cmd[4], " 0x%x", &dst);
			doboot(dst, argc, argv, env);
		}
		else if(!strncmp(cmd, "loadsrec", 8))
		{
			if (sscanf(&cmd[7], " 0x%x", &len)== 1)
				doloadsrec(len);
		}
		else if(!strncmp(cmd, "loadbin", 7))
		{
			if (sscanf(&cmd[7], " 0x%x 0x%x", &dst, &len) == 2)
				doloadbin((void *)dst, len);
		}
		else if(!strncmp(cmd, "copy", 4))
		{
			if(sscanf(&cmd[4], " 0x%x 0x%x 0x%x", &src, &dst, &len) == 3)
				docopy(src, dst, len);
		}
		else if(!strncmp(cmd, "go", 2))
		{
			if(sscanf(&cmd[2], " 0x%x", &dst) == 1)
				dogo(dst);
		}
		else if(!strncmp(cmd, "dump", 4))
		{
			if (sscanf(&cmd[4], " 0x%x 0x%x", &src, &len) == 2)
				dodump(src, len);
		}
		else if(!strncmp(cmd, "write", 5))
		{
			if (sscanf(&cmd[5], " 0x%x 0x%x 0x%x", &dst, &len, &src) == 3)
				dowrite(dst, len, src);
		}
	}

	return 0;
}