sys_main.c

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

/****************************************************************************
* Copyright  Storlink Corp 2005.  All rights reserved.                
*--------------------------------------------------------------------------
* Name			: sys_main.c
* Description	: 
*		Main entry of C files
* History
*
*	Date		Writer		Description
*	-----------	-----------	-------------------------------------------------
*	04/18/2005	Gary Chen	Create
*
****************************************************************************/
#include <define.h>
#include <board_config.h>
#include <sl2312.h>
#include <sys_fis.h>
#include <ide/ide.h>
#include <ide/ext2fs.h>

#define BOOT_CHK_KET_INTERVAL	(10 * 1000)		// 10ms 

UINT32 DRIVE_PCI_CLK = 0;

void sys_show_hw_cfg(void);
void sys_load_kernel(void);
void sys_load_kernel_from_flash(void);
void sys_load_kernel_from_ide(void);
int sys_verify_kernel_in_flash(void);

extern void board_show_version(void);
extern FILE_T *ext2fs_open(char *filepath);

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

#if 1	// SJC
extern void init_all_led_btn(void);
extern void set_led(unsigned char set, unsigned char pin);
extern void blink_leds(void);
extern unsigned char get_pin_state(unsigned char pin);
#endif
/*----------------------------------------------------------------------
* sl_main
*----------------------------------------------------------------------*/
void sl_main(void) 
{
	UINT64	delay_time;
	UINT32	delay_ticks;;
	int boot_menu = 0;
	
	
	
	hal_hardware_init();
	
	hal_flash_disable();
	uart_init(BOARD_UART_BAUD_RATE);
	sys_init_memory((char *)BOARD_BOOT2_MALLOC_BASE, BOARD_BOOT2_MALLOC_SIZE);
#if 1 // SJC
#else
	sl_cir_init();
#endif
	
	flash_init();

#ifdef BOARD_SUPPORT_FIS
	if (sys_fis_init() < 0)
		boot_menu = 1;
#endif
	
#ifdef BOARD_SUPPORT_VCTL
	sys_vctl_init();
#endif
	
	sys_init_cfg();
	
#if 1   // SJC
	init_all_led_btn();
	hal_delay_us(500 * 1000);		// delay 500ms
	// turn on power LED
	set_led(0, 7);
	if (get_pin_state(14) == 0) {
		int		cnt = 0, flg = 0;

		hal_delay_us(100 * 1000);		// delay 1 sec.
		if (get_pin_state(14) == 0) {
			printf("COPY BUTTON PRESSED\n");
			blink_leds();
			while (cnt < 10) {
				while (1) {
					if (get_pin_state(flg = 1) == 0) break;
					if (get_pin_state(flg = 3) == 0) break;
					if (get_pin_state(flg = 14) == 0) break;
				}
				cnt++;
				printf("CNT=%d BUTTON %d PRESSED!\n", cnt, flg);
				blink_leds();
			}
		}
	}
#endif
	printf("\n\n");
	board_show_version();
	REG32(SL2312_GLOBAL_BASE + 0x44)=0x80000000;
	sys_show_hw_cfg();
	sys_show_sw_cfg();
	
#ifdef BOARD_SUPPORT_IDE
	if (ide_init() == 0 || ext2fs_init() == 0)
		boot_menu = 1;			
#endif
	
	if (boot_menu || !sys_verify_kernel())
	{
		net_init();
		while (1)
		{
			ui_menu();
		}
	}

	printf("==> enter ^C to abort booting within %d seconds ...... \n", 
			BOARD_BOOT_TIMEOUT);
#if 1	// SJC
	set_led(1, 4);
	set_led(1, 6);
	set_led(1, 16);
	set_led(1, 17);
	set_led(1, 18);
#endif

	delay_ticks = (BOARD_BOOT_TIMEOUT * BOARD_TPS);
	delay_time = sys_get_ticks() + delay_ticks;
	
	while (sys_get_ticks() < delay_time)
	{
		unsigned char c;
		if (uart_scanc(&c) && c == BOOT_BREAK_KEY)
		{
			net_init();
			ui_menu();
			break;
		}
	}

    // load Kernel
    sys_load_kernel();
    
	net_init();
	while (1)
	{
		ui_menu();
	}
}

/*----------------------------------------------------------------------
* sys_show_hw_cfg
*----------------------------------------------------------------------*/
void sys_show_hw_cfg(void)
{
	UINT32 i, j;
	int is_3316 = FALSE;
	char *status_msg[2]={"disabled", "enabled"};
#ifndef MIDWAY	
    int speed[]={125,116,108,100,91,83,75};
#else
	int speed[]={130,140,150,160,170,180,190,200};
#endif	
    i = (REG32(SL2312_GLOBAL_BASE + GLOBAL_ID) >> 0);
    printf("Processor: SL%x\n",i);
    if (i == GLOBAL_CHIP_ID)
    	is_3316 = TRUE;

	printf("CPU Rate: %d\n", hal_get_cpu_rate());

#if 0			
	printf("MMU: %s, I-CACHE: %s, D-CACHE: %s\n",
			status_msg[hal_get_mmu_status()],
			status_msg[hal_get_icache_status()],
			status_msg[hal_get_dcache_status()]);

	j = hal_detect_pci_clock();
    if (j > 8)
    	printf("Use External PCI Clock \n");
    else
    	printf("Use Internal PCI Clock \n");

	DRIVE_PCI_CLK = (j>8) ? 0 : BIT(5) ;

    i = REG32(SL2312_GLOBAL_BASE + GLOBAL_STATUS) & BIT(16) ;		// IDE channel 0
    if (i)
    	printf("IDE0 Enable       ");
    else
    	printf("PCI Enable        ");
    	
    if(is_3316) {
    	i = REG32(SL2312_GLOBAL_BASE + GLOBAL_STATUS) & BIT(17) ;		// IDE channel 1
    	if(i)
	    	printf("IDE1 Enable");
    	else
	    	printf("IDE1 Disable");
    }
    printf("\n");
#endif
    
#ifndef MIDWAY    
	i = REG32(SL2312_GLOBAL_BASE + GLOBAL_STATUS) & (BIT(0)|BIT(1)|BIT(2)) ;
    printf("AHB Bus Clock:%dMHz    Ratio:",speed[i]);
    j = (REG32(SL2312_GLOBAL_BASE + GLOBAL_STATUS) & (BIT(4)|BIT(5))) >> 4;   
    switch(j){
    	case 0:
    		printf("1/1\n");
    		break ;
    	case 1:
    		printf("3/2\n");
    		break ;
    	case 2:
    		printf("2/1\n");
    		break ;
    }
    
#else
	i = REG32(SL2312_GLOBAL_BASE + GLOBAL_STATUS) & (BIT(15)|BIT(16)|BIT(17)) ;
    printf("AHB Bus Clock:%dMHz    Ratio:",speed[(i>>15)]);
	j = (REG32(SL2312_GLOBAL_BASE + GLOBAL_STATUS) & (BIT(18)|BIT(19))) >> 18; 
	switch(j){
    	case 0:
    		printf("1/1\n");
    		break ;
    	case 1:
    		printf("3/2\n");
    		break ;
    	case 2:
    		printf("24/13\n");
    		break ;
    	case 3:
    		printf("2/1\n");
    		break ;
    }
    
#endif 
    i = REG32(SL2312_GLOBAL_BASE + GLOBAL_STATUS) ;
}

/*----------------------------------------------------------------------
* sys_load_kernel
*----------------------------------------------------------------------*/
void sys_load_kernel(void)
{
	#ifdef LOAD_FROM_IDE
		sys_load_kernel_from_ide();
	#else
		#ifdef BOARD_SUPPORT_FIS
    		fis_load_images();
		#else    
			sys_load_kernel_from_flash();
		#endif
	#endif
}

/*----------------------------------------------------------------------
* sys_run_apps
*----------------------------------------------------------------------*/
void sys_run_apps(void *entry)
{
    void (*apps_routine)(void);
    
    HAL_ICACHE_INVALIDATE_ALL();
    HAL_DCACHE_INVALIDATE_ALL();
    HAL_ICACHE_DISABLE();
    HAL_DCACHE_DISABLE(); 	
#ifdef MIDWAY
	//disable 17
	REG32(SL2312_GLOBAL_BASE + GLOBAL_MISC_CTRL) |= BIT(4) | BIT(2) | BIT(1) | BIT(0) | DRIVE_PCI_CLK;		// Disable Parall Flash PAD
	
	REG32(SL2312_GLOBAL_BASE + GLOBAL_RESET) |= BIT(2)|BIT(5)|BIT(6)|BIT(24) ;
    
    hal_delay_us(2); 		//delay
    
    REG32(SL2312_GLOBAL_BASE + GLOBAL_RESET) &= ~BIT(24) ; // external device reset resume
    
    hal_delay_us(2); 		//delay
    
#else    	
    REG32(SL2312_GLOBAL_BASE + GLOBAL_MISC_CTRL) |= BIT(0) | DRIVE_PCI_CLK;		// Disable Parall Flash PAD
	REG32(SL2312_GLOBAL_BASE + GLOBAL_RESET) |= BIT(5)|BIT(16) ;
    
    hal_delay_us(2); 		//delay
    
    REG32(SL2312_GLOBAL_BASE + GLOBAL_RESET) &= ~BIT(16) ; // external device reset resume
    
    hal_delay_us(2); 		//delay
#endif

	apps_routine = (void (*))(entry);
    apps_routine();
}

/*----------------------------------------------------------------------
* sys_load_kernel_from_ide
*----------------------------------------------------------------------*/
#ifdef LOAD_FROM_IDE
void sys_load_kernel_from_ide(void)
{
    unsigned long size, nbytes;
    unsigned long old_ints;
    int	cnt, err;

	// load Kernel 7 initrd
	cnt = 5;
	err = 1;
	while (cnt--)
	{
		initrd_fp = ext2fs_open((char *)sys_get_initrd_name());
		if (!initrd_fp)
			continue;
		size = ext2fs_file_size(initrd_fp);
		printf("Load %s size %d...", (char *)sys_get_initrd_name(), size);
		nbytes = ext2fs_read((void *)initrd_fp, (char *)sys_get_initrd_addr(), size);
		if (nbytes != size)
			printf("Failed!\nExpect read %lu bytes, but got %lu bytes.\n", size, nbytes);
		else
		{
			printf("OK.\n");
			err = 0;
			break;
		}
		ext2fs_close(initrd_fp);
	}
	if (!err)
	{
		cnt = 5;
		err = 1;
		while (cnt--)
		{
			kernel_fp = ext2fs_open((char *)sys_get_kernel_name());
			if (!kernel_fp)
				continue;
			size = ext2fs_file_size(kernel_fp);
			printf("Load %s size %d...", (char *)sys_get_kernel_name(), size);
			nbytes = ext2fs_read((void *)kernel_fp, (char *)sys_get_kernel_addr(), size);
			if (nbytes != size)
				printf("Failed!\nExpect read %lu bytes, but got %lu bytes.\n", size, nbytes);
			else
			{
				printf("OK.\n");
				err = 0;
				break;
			}
			ext2fs_close(kernel_fp);
		}
	}
	
	ext2fs_close(kernel_fp);
	ext2fs_close(initrd_fp);
	
	if(!err)
		sys_run_apps((void *)sys_get_kernel_addr());
	
}
#endif //  LOAD_FROM_IDE

/*----------------------------------------------------------------------
* sys_load_kernel_from_flash
*----------------------------------------------------------------------*/
#ifndef LOAD_FROM_IDE
void sys_load_kernel_from_flash(void)
{
    void (*apps_routine)(void);
    unsigned long i, j, *dest, *srce, size;
    unsigned long old_ints;
#ifdef BOARD_SUPPORT_TWO_CPU
	unsigned char *p ;
	unsigned char *tgt0 ;
#endif    	
	unsigned int    value;
	hal_interrupt_mask_all();
    
    HAL_DISABLE_INTERRUPTS(old_ints);
    HAL_ICACHE_INVALIDATE_ALL();
    HAL_DCACHE_INVALIDATE_ALL();
    HAL_ICACHE_ENABLE();
    HAL_DCACHE_ENABLE();
    
	// load Kernel
	printf("Load kernel from 0x%x to 0x%x size %d\n",
			BOARD_FLASH_KERNEL_ADDR, BOARD_DRAM_KERNEL_ADDR, BOARD_KERNEL_SIZE);
	
	hal_flash_enable();

    srce=(unsigned long *)(BOARD_FLASH_KERNEL_ADDR);
    dest=(unsigned long *)BOARD_DRAM_KERNEL_ADDR;
    size = BOARD_KERNEL_SIZE / sizeof(unsigned long);


	value = REG32(SL2312_FLASH_CTRL_BASE + 0x0c) & 0x1f00;	
	if((value&0x1000)==0x1000)
		sys_memcpy(dest, srce, BOARD_KERNEL_SIZE );
	else
	{
    for (i = 0; i < size; i++)
    	*dest++=*srce++;
	}
	hal_flash_disable();
	
#if (BOARD_RAM_DISK_SIZE != 0)
	// load RAM Disk
	printf("Load RAM DISK from 0x%x to 0x%x size %d\n",
			BOARD_FLASH_RAM_DISK_ADDR, BOARD_DRAM_RAM_DISK_ADDR, BOARD_RAM_DISK_SIZE);
	
	hal_flash_enable();

    srce=(unsigned long *)(BOARD_FLASH_RAM_DISK_ADDR);
    dest=(unsigned long *)BOARD_DRAM_RAM_DISK_ADDR;
    size = BOARD_RAM_DISK_SIZE / sizeof(unsigned long);

	value = REG32(SL2312_FLASH_CTRL_BASE + 0x0c) & 0x1f00;	
	if((value&0x1000)==0x1000)
		sys_memcpy(dest, srce, BOARD_RAM_DISK_SIZE );
	else
	{
    	for (i = 0; i < size; i++)
    		*dest++=*srce++;
	}
	hal_flash_disable();
#endif

#ifdef BOARD_SUPPORT_TWO_CPU
	// load CPU-1 image
	printf("Load CPU-2 code\n");
	
	hal_flash_enable();   
	
#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	
	srce=(unsigned long *)(BOARD_FLASH_CPU2_ADDR);
	dest=(unsigned long *)BOARD_DRAM_CPU2_ADDR;
	size = (BOARD_CPU2_SIZE / sizeof(unsigned long))/2;

	value = REG32(SL2312_FLASH_CTRL_BASE + 0x0c) & 0x1f00;	
	if((value&0x1000)==0x1000)
		sys_memcpy(dest, srce, BOARD_CPU2_SIZE );
	else
	{
    	for (i = 0; i < size; i++)
    		*dest++=*srce++;
	}
	hal_flash_disable();
	
	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

	sys_run_apps((void *)BOARD_DRAM_KERNEL_START_ADDR);

}
#endif //  LOAD_FROM_IDE

/*----------------------------------------------------------------------
* sys_verify_kernel
*----------------------------------------------------------------------*/
int sys_verify_kernel(void)
{
	#ifdef LOAD_FROM_IDE
	#else
		return sys_verify_kernel_in_flash();
	#endif
}

/*----------------------------------------------------------------------
* sys_verify_kernel_in_flash
*----------------------------------------------------------------------*/
#ifndef LOAD_FROM_IDE
int sys_verify_kernel_in_flash(void)
{
	unsigned int    value;
	char *datap;
	
	hal_flash_enable();
	value = REG32(SL2312_FLASH_CTRL_BASE + 0x0c) & 0x1f00;	
	if((value&0x1000)==0x1000)
	{
		//char datap[528];
		datap = (char *)malloc(528);
		if (!datap)
		{
			printf(("No free memory!\n"));
			return;
		}
		sys_memcpy(datap, BOARD_FLASH_KERNEL_ADDR, 0x200 );
	}	
	else
	{
		//char *datap;
		datap = (char *)BOARD_FLASH_KERNEL_ADDR;
	}

	if (*(UINT32 *)datap == 0xffffffff)
	{
		hal_flash_disable();
		printf("Illegal kernel image\n");
		if((value&0x1000)==0x1000)
			free(datap);
		return FALSE;
	}
	if((value&0x1000)==0x1000)
		free(datap);
	hal_flash_disable();
	return TRUE;
}
#endif