sys_fis.c

某个ARM9板子的实际bootloader 对裁剪

/****************************************************************************
* Copyright  Storlink Corp 2005.  All rights reserved.                
*--------------------------------------------------------------------------
* Name			: sys_fis.c
* Description	: 
*		Handle FLASH Image System (FIS)
* History
*
*	Date		Writer		Description
*	-----------	-----------	-------------------------------------------------
*	08/01/2005	Gary Chen	Create
*
****************************************************************************/
#include <define.h>
#include <board_config.h>
#include <sl2312.h>
#include <sys_fis.h>

#ifdef BOARD_SUPPORT_FIS

//static unsigned char *fis_datap;
unsigned char *fis_datap;

static void fis_create_default(void);
//static unsigned long fis_desc_chksum(FIS_T *img);
unsigned long fis_desc_chksum(FIS_T *img);
static FIS_T *fis_get_free_image(void);
//static void fis_write_flash(void);
void fis_write_flash(void);

#ifdef BOARD_SUPPORT_TWO_CPU
extern char     _exception_handlers[];
extern char     _exception_handlers_end[];
#endif

/*----------------------------------------------------------------------
* sys_fis_init
*	looking for BOOT-1, BOOT-2, Kernel & RAM-Disk file image.
*	If Kernel & RAM-DISK files are found, return 0
*	If not found, create FIS with default Boot-1 and Boot-2 
*	return -1 if error
*----------------------------------------------------------------------*/
int sys_fis_init(void) 
{
	int i;
	FIS_T *img;
	char *datap;
	UINT32 ipaddr, netmask, gateway;
	
	fis_datap = (unsigned char *)sys_malloc(FIS_TOTAL_SIZE);
	if (!fis_datap)
	{
		printf("sys_fis_init: No free memory!\n");
		return -1;
	}
	
	// get image files from FLASH
	hal_flash_enable();
	memcpy(fis_datap, BOARD_FLASH_FIS_ADDR, FIS_TOTAL_SIZE);
	hal_flash_disable();
	
	// check FIS existed or not
	// create one if not found
	// check kernel
	img = fis_find_image(BOARD_FIS_BOOT_NAME);
	if (!img)
	{
		printf("FIS is not found! Create a default FIS!\n");
		fis_create_default();
		return -1;
	}
	
	// get IP address
	datap = img->data;
	ipaddr = str2ip(datap);
	datap += strlen(datap) + 1;
	netmask = str2ip(datap);
	datap += strlen(datap) + 1;
	gateway = str2ip(datap);
	sys_set_ip_addr(ipaddr);
	sys_set_ip_netmask(netmask);
	sys_set_ip_gateway(gateway);
	
	// check kernel
	img = fis_find_image(BOARD_FIS_KERNEL_NAME);
	if (!img || !img->file.mem_base || !img->file.entry_point)
	{
		printf("Cound not load the Kernel!\n");
		return -1;
	}
#if 1	// SJC
	img->file.size = BOARD_KERNEL_SIZE;
	img->desc_cksum = fis_desc_chksum(img);
#endif

	// check ram disk
#if (BOARD_RAM_DISK_SIZE != 0)
	img = fis_find_image(BOARD_FIS_RAM_DISK_NAME);
	if (!img || !img->file.mem_base)
	{
		printf("Cound not load the RAM Disk!\n");
		return -1;
	}
#endif
		
	return 0;
}

/*----------------------------------------------------------------------
* fis_load_images
* load image to dram
*----------------------------------------------------------------------*/
void fis_load_images(void)
{
	FIS_T *img;
	int i, j;
    unsigned long old_ints;
    unsigned long *dest, *srce, size;
    void (*apps_routine)(void);
    unsigned int    value;
#ifdef BOARD_SUPPORT_TWO_CPU
	unsigned char *p ;
	unsigned char *tgt0 ;
#endif  
	
    HAL_DISABLE_INTERRUPTS(old_ints);
    HAL_ICACHE_INVALIDATE_ALL();
    HAL_DCACHE_INVALIDATE_ALL();
    HAL_ICACHE_ENABLE();
    HAL_DCACHE_ENABLE();
    
	apps_routine = NULL;
	img = (FIS_T *)fis_datap;
	for (i=0; i<FIS_MAX_ENTRY; i++, img++)
	{
		if (img->file.name[0] != 0xff && img->file.name[0] != 0x00 &&
			img->desc_cksum == fis_desc_chksum(img) &&
			img->file.flash_base && img->file.mem_base)
		{
			if ((strncasecmp(img->file.name, BOARD_FIS_BOOT_NAME) == 0)
				|| (strncasecmp(img->file.name, BOARD_FIS_DIRECTORY_NAME) == 0))
			{
				continue;
			}
			if (!apps_routine && img->file.entry_point)
				apps_routine = (void *)img->file.entry_point;
				
    		srce=(unsigned long *)img->file.flash_base;
    		dest=(unsigned long *)img->file.mem_base;
    		//size = ((img->file.size + 3) & ~3)/ 4;

			printf("Load %s image from 0x%x to 0x%x size %d\n",
					img->file.name, img->file.flash_base, img->file.mem_base, img->file.size);
			
			hal_flash_enable();
			value = REG32(SL2312_FLASH_CTRL_BASE + 0x0c) & 0x1f00;	
			if((value&0x1000)==0x1000)
			{
				size = img->file.size;
				sys_memcpy(dest, srce, size );
			}
			else
			{
				size = ((img->file.size + 3) & ~3)/ 4;
    			for (j = 0; j < size; j++)
    				*dest++=*srce++;
			}
			hal_flash_disable();
		}
		
	}

#ifdef BOARD_SUPPORT_TWO_CPU

#if (CPU2_BOOT_OFFSET != 0)	
	// install vector
	//memset(dest,0xE1A00000,0x2000000);	// set 32MB as nop for safe
	size = (unsigned int)(&_exception_handlers_end[0] - &_exception_handlers[0]);
	p = (unsigned char *)(&_exception_handlers[0]);
	tgt0 = (unsigned char *)BOARD_DRAM_CPU2_ADDR;
	while(size--) {
		*tgt0 = *p;
		tgt0++; p++;
	}
#endif	
	HAL_ICACHE_INVALIDATE_ALL();
	HAL_DCACHE_INVALIDATE_ALL();
    
	printf("Start the 2nd CPU!\n");
	REG32(0x66000040) = CPU2_RAM_BASE + CPU2_RAM_SIZE;
	REG32(GLOBAL_CTRL_CPU1_REG) &= ~CPU1_RESET_BIT_MASK;
	
#endif
	
	if (apps_routine)
	{
		hal_interrupt_mask_all();
		HAL_DISABLE_INTERRUPTS(old_ints);
    	//HAL_ICACHE_INVALIDATE_ALL();
    	//HAL_DCACHE_INVALIDATE_ALL();
    	//HAL_ICACHE_DISABLE();
    	//HAL_DCACHE_DISABLE();
    
		sys_run_apps(apps_routine);
	}
	
	HAL_RESTORE_INTERRUPTS(old_ints);
    HAL_ICACHE_INVALIDATE_ALL();
    HAL_DCACHE_INVALIDATE_ALL();
    HAL_ICACHE_ENABLE();
}


/*----------------------------------------------------------------------
* sys_fis_list
*----------------------------------------------------------------------*/
void fis_ui_list(int type)
{
	FIS_T *img;
	int i;
	
	if (!fis_datap)
	{
		printf("No FIS!\n");
		return;
	}
	printf("Name              FLASH addr           Mem addr    Datalen     Entry point\n");
	img = (FIS_T *)fis_datap;
	for (i=0; i<FIS_MAX_ENTRY; i++, img++)
	{
		if (img->file.name[0] != 0xff && img->file.name[0] != 0x00 &&
			img->desc_cksum == fis_desc_chksum(img))
		{
			printf("%-16s  0x%08lX-%08lX  0x%08lX  0x%08lX  0x%08lX\n",
					img->file.name,
					img->file.flash_base,
					(img->file.size) ? img->file.flash_base+img->file.size-1 : img->file.flash_base,
					img->file.mem_base,
					img->file.data_length,
					img->file.entry_point);
		}
	}
}

/*----------------------------------------------------------------------
* fis_desc_chksum
*	do file descriptor check sum
*----------------------------------------------------------------------*/
unsigned long fis_desc_chksum(FIS_T *img)
{
	unsigned char *cp;
	unsigned long sum = 0;
	int i;
	
	cp  = (unsigned char *)img;
	for (i=0; i<(FIS_ENTRY_SIZE - 8); i++, cp++) // not include chksum field
		sum += *cp & 0xff;
	
	return sum;
}
	


/*----------------------------------------------------------------------
* fis_find_image
*----------------------------------------------------------------------*/
FIS_T *fis_find_image(char *filename)
{
	FIS_T *img;
	int i;
	
	img = (FIS_T *)fis_datap;
	
	for (i=0; i<FIS_MAX_ENTRY; i++, img++)
	{
		if (img->file.name[0] == 0xff)
			break;
			
		if ((strncasecmp(filename, img->file.name) == 0) && 
			(img->desc_cksum == fis_desc_chksum(img)))
		{
			return img;
		}
	}
	return NULL;
}

/*----------------------------------------------------------------------
* fis_get_free_image
*----------------------------------------------------------------------*/
static FIS_T *fis_get_free_image(void)
{
	FIS_T *img;
	int i;
	
	img = (FIS_T *)fis_datap;
	
	for (i=0; i<FIS_MAX_ENTRY; i++, img++)
	{
		if (img->file.name[0] == 0xff || img->file.name[0] == 0
			|| img->desc_cksum != fis_desc_chksum(img))
			return img;
	}
	return NULL;
}


/*----------------------------------------------------------------------
* fis_create_default
*----------------------------------------------------------------------*/
static void fis_create_default(void)
{
	FIS_T	*img;
	UINT32 ipaddr, netmask, gateway;
	char *datap;
	
	img = (FIS_T *)fis_datap;
	
	memset((char *)fis_datap, -1, FIS_TOTAL_SIZE);
	
	// boot-1
	memset((char *)img, 0, FIS_ENTRY_SIZE);
	strcpy(img->file.name, BOARD_FIS_BOOT_NAME);
	img->file.flash_base	= BOARD_FLASH_BOOT_ADDR;
	img->file.mem_base		= 0;//BOARD_FLASH_BOOT_ADDR;
	img->file.size			= BOARD_FLASH_BOOT_SIZE;
	img->file.entry_point	= 0; //BOARD_FLASH_BOOT_ADDR;
	img->file.data_length	= BOARD_FLASH_BOOT_SIZE;
	
	ipaddr = sys_get_ip_addr();
	netmask = sys_get_ip_netmask();
	gateway = sys_get_ip_gateway();
	datap = img->data;
	sprintf(datap, "%d.%d.%d.%d",
			IP1(ipaddr), IP2(ipaddr), IP3(ipaddr), IP4(ipaddr));
	datap += strlen(datap) + 1;
	sprintf(datap, "%d.%d.%d.%d",
			IP1(netmask), IP2(netmask), IP3(netmask), IP4(netmask));
	datap += strlen(datap) + 1;
	sprintf(datap, "%d.%d.%d.%d",
			IP1(gateway), IP2(gateway), IP3(gateway), IP4(gateway));
	
	img->desc_cksum			= fis_desc_chksum(img);
	img++;
	
	// FIS directory
	memset((char *)img, 0, FIS_ENTRY_SIZE);
	strcpy(img->file.name, BOARD_FIS_DIRECTORY_NAME);
	img->file.flash_base	= BOARD_FLASH_FIS_ADDR;
	img->file.mem_base		= BOARD_FLASH_FIS_ADDR;
	img->file.size			= BOARD_FLASH_FIS_SIZE;
	img->file.entry_point	= 0;
	img->file.data_length	= FIS_TOTAL_SIZE;
	img->desc_cksum			= fis_desc_chksum(img);
	img++;
	
	// kernel
	memset((char *)img, 0, FIS_ENTRY_SIZE);
	strcpy(img->file.name, BOARD_FIS_KERNEL_NAME);
	img->file.flash_base	= BOARD_FLASH_KERNEL_ADDR;
	img->file.mem_base		= BOARD_DRAM_KERNEL_ADDR;
	img->file.size			= BOARD_KERNEL_SIZE;
//	img->file.entry_point	= BOARD_DRAM_KERNEL_ADDR;
	img->file.entry_point	= BOARD_DRAM_KERNEL_START_ADDR;
	img->file.data_length	= BOARD_KERNEL_SIZE;
	img->desc_cksum			= fis_desc_chksum(img);
	img++;
	
#if 1	// SJC
#else
	// Ram Disk
	memset((char *)img, 0, FIS_ENTRY_SIZE);