2410bios.c

本人水品有限

#include "def.h"
#include "2410addr.h"
#include "2410lib.h"
#include "2410slib.h"
#include "mmu.h"
#include "uart.h"
#include "timer.h"
#include "39vf160.h"
#include "LCD.h"
#include "PowerManage.h"

void call_linux(U32 a0, U32 a1, U32 a2);
void UsbMain(void);
void comdownload(void);
void NandWrite(void);
void NandLoadRun(void);
void NandErase(void);

#define START_ADDRESS   (_NONCACHE_STARTADDRESS)
//#define START_ADDRESS   (_NONCACHE_STARTADDRESS+0x2f00000)   
#define END_ADDRESS     (_NONCACHE_STARTADDRESS+0x2feff00)

#define PATTERN00       0x00000000
#define PATTERN01       0x55555555
#define PATTERN11       0xffffffff
#define PATTERN10       0xaaaaaaaa

#define PATTERNADDR     0               //1: Address = Pattern ,  0: Pattern
#define PATTERN_INVERT  1               //1: Pattern Invert    ,  0: Pattern Non Invert 

void mem_write_read (int address, int end_addr, int pattern);
extern U32 downloadAddress, downloadFileSize;
static EnvParams Env;
U32	Console_Uart = 0;
U32	Console_Baud = 115200;
char boot_params[256];

static short DsAutoBoot;
static short NorFlashSupport = 0 ;

volatile int PwrKeyChkEnd;

//*****************************************************************************
void GetBootParam(void)
{
	U16 cmd_cnt = 0;
	char tmp[256] = {0};
	
	puts("Set boot params, press Enter to finish, Esc to abort\n");
	while(1) {
		char c = getch();
		if(c==0x1b) 
			return;
		
		if(c==0xd)
			break;
		if((c==0x8)&&(cmd_cnt)) {			
			cmd_cnt -= 1;
			tmp[cmd_cnt] = 0;
			putch(c);
			putch(' ');
			putch(c);
		}
		else {
			if(cmd_cnt<255) {
				putch(c);
				tmp[cmd_cnt++] = c;
				tmp[cmd_cnt]   = 0;
			}
		}		
	}

	for(cmd_cnt=0; tmp[cmd_cnt]; cmd_cnt++)
		boot_params[cmd_cnt] = tmp[cmd_cnt];
	boot_params[cmd_cnt] = 0;			
}

//*****************************************************************************
static __inline int RtcAlmWake(void)
{	
	return ((rBCDHOUR==rALMHOUR)&&(rBCDMIN==rALMMIN));
}

//*****************************************************************************
static void ProgNorFlash(void)
{
	if(NorFlashSupport) {
		SectorProg(0, (U16 *)downloadAddress, downloadFileSize);
	}
}


//*****************************************************************************
void mem_write_read (int address, int end_addr, int pattern)
{
    int i, addr1, addr2;
    
    addr1 = 0x31000000;
    addr2 = 0x33feff00;
    
    Uart_Printf("\n*** Memory Test Pattern= 0x%08x and 0x%08x\n",pattern,~pattern);
   
//    Uart_Printf("Now, Writing ...\n");

    Uart_Printf("Memory Testing ...\n");    

    for(i=0;i<1000000;i++)
    {    
        *((U32 *)addr1) = pattern;
        *((U32 *)addr2) = ~pattern;            
    
   	    if (!(*((U32 *)addr1) == pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr1,pattern,*((U32 *)addr1));
        
   	    if (!(*((U32 *)addr2) == ~pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr2,~pattern,*((U32 *)addr2));        
            
        *((U32 *)addr1) = ~pattern;
        *((U32 *)addr2) = pattern;            
    
   	    if (!(*((U32 *)addr1) == ~pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr1,~pattern,*((U32 *)addr1));
        
   	    if (!(*((U32 *)addr2) == pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr2,pattern,*((U32 *)addr2));            
    }
    Uart_Printf("Testing Completed.\n");      	    
    //Uart_Printf("Press to any key. Continue...\n");
    //while(!Uart_GetKey());      
}
//*****************************************************************************
void SDRAM_Test(void)
{
 int i;
    
    Uart_Printf("\n[ Memory Write/Read/Compare Test ]\n");
    
//    Uart_Printf("Start Address= 0x%08x,  End Address= 0x%08x, Size= %d Bytes\n",
//               START_ADDRESS,END_ADDRESS,(END_ADDRESS-START_ADDRESS));    

    if (!PATTERNADDR)
    {
        
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xffff5555);   
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xaaaaffff);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x5555ffff);   
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xffffaaaa);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x0000ffff); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xffff0000);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xa5a5a5a5);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x5a5a5a5a);
        
        mem_write_read (START_ADDRESS, END_ADDRESS,  PATTERN00);    // 0x00000000
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x11111111);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x22222222);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x33333333); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x44444444);
        mem_write_read (START_ADDRESS, END_ADDRESS, PATTERN01);    // 0x55555555
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x66666666);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x77777777);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x88888888);  
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x99999999); 
        mem_write_read (START_ADDRESS, END_ADDRESS,  PATTERN10);    // 0xaaaaaaaa
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xbbbbbbbb);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xcccccccc); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xdddddddd); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xeeeeeeee);
        mem_write_read (START_ADDRESS, END_ADDRESS,  PATTERN11);    // 0xffffffff                                                                                                                                                          
        
//        mem_write_read (START_ADDRESS, END_ADDRESS, PATTERN01);    // 0x55555555 
//        mem_write_read (START_ADDRESS, END_ADDRESS, 0xa5a5a5a5);
 
        for (i=0;i<32;i++)          // Data Bit
            mem_write_read (START_ADDRESS, END_ADDRESS, (1<<i)); 
        for (i=0;i<31;i++)
            mem_write_read (START_ADDRESS, END_ADDRESS, (3<<i)); 
        for (i=0;i<30;i++)
            mem_write_read (START_ADDRESS, END_ADDRESS, (7<<i)); 
        for (i=0;i<29;i++)
            mem_write_read (START_ADDRESS, END_ADDRESS, (0xf<<i));           
                                                   
    }
    else
    {
        mem_write_read (START_ADDRESS, END_ADDRESS, PATTERN00);        
    }

    Uart_Printf("Memory Test Completed.\n");
}
/****************** by chang *****************************/
static void Set_Auto_Run(void)
{
	printf("Please Input Number:");
	Env.Os_Auto_Flag=getch()-'0';
	//Env.Os_Auto_Flag=1;
	printf("%x\n",Env.Os_Auto_Flag);
	NFSaveParams((char *)&Env);
}
/***************** by chang *****************************/
struct {
	void (*fun)(void);
	char *tip;
}CmdTip[] = {
				{UsbMain, "USB download file"},
				{comdownload, "Uart download file"},
				{NandWrite, "Write Nand flash with download file"},
				{NandLoadRun, "Load Pragram from Nand flash and run"},
				{NandErase, "Erase Nand flash regions"},
				//{ProgNorFlash, "Write NOR flash with download file"},
				{GetBootParam, "Set boot params"},
				{NandLoadRunW,"Run Wince"},
				{Set_Auto_Run,"Set AutoBoot parameter,1:linux 2:wince"},
				{EnterPowerOff, "Test Power off"},
				{SDRAM_Test, "test SDRAM Memory"},
				{0, 0}						
			};

static int Wince_Run=0;	
//*****************************************************************************
static void AutoBoot(U32 i)
{
	static cnt = 10;		//5s
	if(!--cnt) {
		ReleaseBiosTimerEvent(i);
		//if(!DsAutoBoot)
		//	NandLoadRun();
	if((!DsAutoBoot)&&(Env.Os_Auto_Flag==1))NandLoadRun();
	if(Env.Os_Auto_Flag==2)Wince_Run=1;
	//if((!DsAutoBoot)&&(Env.Os_Auto_Flag==2))NandLoadRun();
	}
	rGPBDAT ^= 1<<5;
}


struct st_date
{
    U32 year;
    U16 month;
   
    U16 day;
    U16 hour;
    U16 minute;
    U16 second;
};

void rtcsetdate(struct st_date *p_date)
{
	rRTCCON=0x01;
		
	rBCDYEAR= p_date->year;
 	rBCDMIN= p_date->minute;
 	rBCDDAY= p_date->day;
 	rBCDMON=p_date->month;
 	rBCDHOUR= p_date->hour;
 	rBCDSEC = p_date->second;

	rRTCCON =0x00;

}

void rtc_display(void)
{
	U32 year;
	U16 month,day,hour,minute,second;
	year = 0x2000+rBCDYEAR  ;		//年
	month = rBCDMON  ;		//月
	day = rBCDDAY  ;		//日	
//	eek = rBCDDAY  ;		//星期
	hour = rBCDHOUR  ;		//小时
	minute = rBCDMIN  ;		//分
	second = rBCDSEC  ;		//秒
   	Uart_Printf( "RTC time : %04x-%02x-%02x %02x:%02x:%02x\n", year, month, day, hour, minute, second );
}

void Isr_Eint0(void)
{
	ClearPending(BIT_EINT0);
	Uart_Printf("中断服务程序");
	Delay(10000);
	Uart_Printf("返回");
	Delay(100000);
}

void Eint0_Init(void)
{
	EnableIrq(BIT_EINT0);
	rEXTINT0 = rEXTINT0 | 0xff;
	rEXTINT0 = rEXTINT0 & 0x22;
	pISR_EINT0 = (U32)Isr_Eint0;
	ClearPending(BIT_EINT0);
}

/******************************************************************************
【功能说明】系统主函数
******************************************************************************/
void Main(void)
{
	int i;
	ChangeClockDivider(1, 1);	// 1:2:4//struct st_date tt1;//int i;
	ChangeMPllValue(161,3,1);	//FCLK=203.0Mhz
	SetClockDivider(1, 1);
	SetSysFclk(FCLK_203M);		//to save power, use 48M
	Port_Init();
	Isr_Init();
	Eint0_Init();
	Uart_Init(0, Console_Baud);
	Uart_Select(Console_Uart);	
#if 1			//bank0 modified to RO_START
 	MMU_Init();	
	//MMU should be reconfigured or turned off for the debugger, 
	//After downloading, MMU should be turned off for the MMU based program,such as WinCE.	
#else
	MMU_EnableICache();
	UsbMain();
#endif
    puts("\n\n\n\n");
	puts("http://www.hfrk.net \n");
	Uart_Printf("实时时钟测试程序");
	while(1)
    {
    	rGPFDAT = rGPFDAT & 0x3f;
    	Delay(10000);
		Uart_Printf("等待___");
		Delay(10000);
		puts("\n");
		puts("zai 再等待，显示时间：");
		Delay(10000);
		rtc_display();
		rGPFDAT = rGPFDAT | 0xc0;
		Delay(10000);
	}
//enable GPIO,UART0,PWM TIMER,NAND FLASH module clock
/*	EnableModuleClock(CLOCK_ALL);	
	LcdBackLightOn();
	Delay( 0 ) ;
	PwrKeyChkInit();
	if(RstStat&1) {
		puts("Power on reset\n");
//		EnterPowerOff();
	}
	if(RstStat&4) {
		puts("Watchdog reset\n");
//		EnterPowerOff();
	}
	if(RstStat&2) {
		puts("Power-off reset\n");
		if(RtcAlmWake()) {
			puts("Alarm wake up\n");
			printf("RTC hr : %d, min : %d\nALM hr : %d, min : %d\n", rBCDHOUR, rBCDMIN, rALMHOUR, rALMMIN);
		} else if( PwrKeyWake() ) {			
			PwrKeyChkEnd = 1;
			RequestBiosTimerEvent(1, PwrKeyChk);	//reload value = 1, 10ms*1 = 10ms
			while(PwrKeyChkEnd>0);
			if(PwrKeyChkEnd!=0)
				EnterPowerOff();
			puts("Power key wake up\n");
		}
	}	
	rMISCCR &= ~(0x3007);		//USB port0,1 = normal, D0~D31 pull-up enable
	Set_Tout1_Pwm( 60 ) ;
	if(rGPFDAT&0x1) {
	Test_Lcd_Tft_16Bpp_240_320();
	}
	else
	Test_Lcd_Tft();
	RequestBiosTimerEvent(50, AutoBoot);	//reload value = 50, 10ms*50 = 500ms
	NFSearchParams((char *)&Env);
	printf("Env.Os_Auto_Flag=%x\n",Env.Os_Auto_Flag);
	if(rBWSCON&6)
	{
		U32 nor_flash_id;
		
		nor_flash_id = GetFlashID();
		puts("NOR Flash Boot, ");
		printf("Read ID is : 0x%x\n", nor_flash_id);
		
		if ( (nor_flash_id==0x278200bf) | (nor_flash_id==0x234b00bf) )
		{
			NorFlashSupport = 1 ;
			if(nor_flash_id==0x278200bf)		puts("SST39VF160 found\n");
			if(nor_flash_id==0x234b00bf)		puts("SST39VF1601 found\n");
		}
		else
			printf( "Not supported NorFlash found!!!\n" ) ;
		
	}
	else 
		puts("NAND Flash Boot\n");
	while(1)
	{
		U8 idx=0;
		puts("\nPlease select function : \n");	
		for(i=0; CmdTip[i].fun!=0; i++)
			printf("%d : %s\n", i, CmdTip[i].tip);
		while((!idx)&&(Wince_Run!=1))
		{
			idx=getkey();
			//if(Wince_Run==1)NandLoadRunW();
			if((idx==0)&&(Wince_Run==1))NandLoadRunW();//(*CmdTip[7].fun)();
		}
		//if(Wince_Run==1)(*CmdTip[7].fun)();
		DsAutoBoot = 1;	//when get a key press, disable auto boot
		idx -= '0';
		printf("%x\n",idx);
		if(idx<i)
		{
			(*CmdTip[idx].fun)();
		}
		Wince_Run=0;
		
	}*/
}