main.c

三星s3c2440NBOOT

/****************************************************************
 NAME: u2440mon.c
 DESC: u2440mon entry point,menu,download
 HISTORY:
 Mar.25.2002:purnnamu: S3C2400X profile.c is ported for S3C2410X.
 Mar.27.2002:purnnamu: DMA is enabled.
 Apr.01.2002:purnnamu: isDownloadReady flag is added.
 Apr.10.2002:purnnamu: - Selecting menu is available in the waiting loop. 
                         So, isDownloadReady flag gets not needed
                       - UART ch.1 can be selected for the console.
 Aug.20.2002:purnnamu: revision number change 0.2 -> R1.1       
 Sep.03.2002:purnnamu: To remove the power noise in the USB signal, the unused CLKOUT0,1 is disabled.
 ****************************************************************/
#define	GLOBAL_CLK		1//hzh

#include <stdlib.h>
#include <string.h>
#include "def.h"
#include "option.h"
#include "2440addr.h"
#include "2440lib.h"
#include "2440slib.h"
#include "mmu.h"
#include "profile.h"
#include "memtest.h"

#include "usbmain.h"
#include "usbout.h"
#include "usblib.h"
#include "2440usb.h"

extern void Lcd_Tft_LTS350Q1_PE1_Init(void) ;
extern char Image$$RO$$Limit[];
extern char Image$$RO$$Base[];
extern char Image$$RW$$Limit[];
extern char Image$$RW$$Base[];
extern char Image$$ZI$$Limit[];
extern char Image$$ZI$$Base[];

void Isr_Init(void);
void HaltUndef(void);
void HaltSwi(void);
void HaltPabort(void);
void HaltDabort(void);
void Lcd_Off(void);
void WaitDownload(void);
void Menu(void);
void ClearMemory(void);


void Clk0_Enable(int clock_sel);	
void Clk1_Enable(int clock_sel);
void Clk0_Disable(void);
void Clk1_Disable(void);

//#define DOWNLOAD_ADDRESS _RAM_STARTADDRESS
volatile U32 downloadAddress;

void (*restart)(void)=(void (*)(void))0x0;
//void (*run)(void);	//don't use gloable variable, hzh!!!


volatile unsigned char *downPt;
volatile U32 downloadFileSize;
volatile U16 checkSum;
volatile unsigned int err=0;
volatile U32 totalDmaCount;

volatile int isUsbdSetConfiguration;

int download_run=0;
U32 tempDownloadAddress;
int menuUsed=0;

extern char Image$$RW$$Limit[];
U32 *pMagicNum=(U32 *)Image$$RW$$Limit;
int consoleNum;

/*************************************************************/
#include "bootpara.h"

extern BootParams boot_params;

int write_24c02(U8 *pBuf);
int read_24c02(U8 *pBuf);
void Led_Test(void);
void comdownload(void);
U32 GetFlashID(void);
int SectorProg(U32 begin, U16 *data, U32 size);

void NandErase(void);
void NandWrite(void);
void NandLoadRun(void);

#define	Uart_Printf	Uart_Printf

static U32 autorun_10ms;
static U32 autorun_ds;
static U8  WinceBoot=0;
static __irq void autorun_proc(void)
{
	ClearPending(BIT_TIMER4);

	if(autorun_ds)
		DisableIrq(BIT_TIMER4);
	
	autorun_10ms--;
	if(!autorun_10ms) {
	//	SET_IF();
		//Uart_Printf("\nrun...\n");
		if(boot_params.auto_boot.val==2)
		NandLoadRun();
		if(boot_params.auto_boot.val==1)
		WinceBoot=1;
	}
}

static void init_autorun_timer(int sec)
{
	U32 val = (PCLK>>4)/100-1;
	
	autorun_10ms = sec*100;
	
	pISR_TIMER4 = (U32)autorun_proc;
	
	rTCFG0 &= ~(0xff<<8);
	rTCFG0 |= 3<<8;			//prescaler = 3+1
	rTCFG1 &= ~(0xf<<16);
	rTCFG1 |= 1<<16;		//mux = 1/4

	rTCNTB4 = val;
	rTCON &= ~(0xf<<20);
	rTCON |= 7<<20;			//interval, inv-off, update TCNTB4&TCMPB4, start timer 4
	rTCON &= ~(2<<20);		//clear manual update bit
	EnableIrq(BIT_TIMER4);
}

static U32 cpu_freq;
static U32 UPLL;
static void cal_cpu_bus_clk(void)
{
	U32 val;
	U8 m, p, s;
	
	val = rMPLLCON;
	m = (val>>12)&0xff;
	p = (val>>4)&0x3f;
	s = val&3;

	//(m+8)*FIN*2 不要超出32位数!
	FCLK = ((m+8)*(FIN/100)*2)/((p+2)*(1<<s))*100;
	
	val = rCLKDIVN;
	m = (val>>1)&3;
	p = val&1;	
	val = rCAMDIVN;
	s = val>>8;
	
	switch (m) {
	case 0:
		HCLK = FCLK;
		break;
	case 1:
		HCLK = FCLK>>1;
		break;
	case 2:
		if(s&2)
			HCLK = FCLK>>3;
		else
			HCLK = FCLK>>2;
		break;
	case 3:
		if(s&1)
			HCLK = FCLK/6;
		else
			HCLK = FCLK/3;
		break;
	}
	
	if(p)
		PCLK = HCLK>>1;
	else
		PCLK = HCLK;
	
	if(s&0x10)
		cpu_freq = HCLK;
	else
		cpu_freq = FCLK;
		
	val = rUPLLCON;
	m = (val>>12)&0xff;
	p = (val>>4)&0x3f;
	s = val&3;
	UPLL = ((m+8)*FIN)/((p+2)*(1<<s));
	UCLK = (rCLKDIVN&8)?(UPLL>>1):UPLL;
}

int search_vend_params(void)
{
	U8 dat[256];
	VenderParams *pVP = (VenderParams *)dat;
	
	if(!read_24c02(dat)) {
		int i;
		
		for(i=0; i<256; i++)
			Uart_Printf("%c0x%02x", (i%16)?' ':'\n', dat[i]);
		
		i = 0;
		if(strncmp(vend_params.vid.flags, pVP->vid.flags, sizeof(vend_params.vid.flags))==0)
			vend_params.vid.val = pVP->vid.val;
		else
			i = -1;

		if(strncmp(vend_params.pid.flags, pVP->pid.flags, sizeof(vend_params.pid.flags))==0)
			vend_params.pid.val = pVP->pid.val;
		else
			i = -1;
		if(strncmp(vend_params.ser_l.flags, pVP->ser_l.flags, sizeof(vend_params.ser_l.flags))==0)
			vend_params.ser_l.val = pVP->ser_l.val;
		else
			i = -1;
		if(strncmp(vend_params.ser_h.flags, pVP->ser_h.flags, sizeof(vend_params.ser_h.flags))==0)
			vend_params.ser_h.val = pVP->ser_h.val;
		else
			i = -1;
		if(strncmp(vend_params.user_params.flags, pVP->user_params.flags, sizeof(vend_params.user_params.flags))==0) {
			vend_params.user_params.val = pVP->user_params.val;
			memcpy(vend_params.string, pVP->string, sizeof(vend_params.string));
		} else
			i = -1;
		
		//if it's string, make sure the last char is 0
		if(vend_params.user_params.val)
			vend_params.string[sizeof(vend_params.string)-1] = 0;
	
		return i;
	}

	return -2;
}

int save_vend_params(void)
{
	return write_24c02((U8 *)&vend_params);
}

/*************************************************************/

void Main(void)
{
	char *mode;
	int i;
	U8 key;
	U32 mpll_val, divn_upll=0;
    
	#if ADS10   
	__rt_lib_init(); //for ADS 1.0
	#endif

	Port_Init();
	// USB device detection control
/*	rGPGCON &= ~(3<<24);
	rGPGCON |=  (1<<24); // output
	rGPGUP  |=  (1<<12); // pullup disable
	rGPGDAT |=  (1<<12); // output	
*/	//masked by hzh

	//ChangeUPllValue(60,4,2);		// 48MHz
	//for(i=0; i<7; i++);
	//ChangeClockDivider(13,12);
	//ChangeMPllValue(97,1,2);		//296Mhz
	
/*
#if (FCLK==271500000)
	ChangeClockDivider(13,12);	//hzh
	ChangeMPllValue(173,2,2);	//271.5Mhz,2440A!
#elif (FCLK==304800000)
	ChangeClockDivider(13,12);	//hzh
	ChangeMPllValue(68,1,1);	//304.8MHz,2440A!
#elif (FCLK==200000000)
	ChangeMPllValue(92,4,1);	//200MHz,2440A!
	ChangeClockDivider(12,12);	//hzh
#elif (FCLK==240000000)
	ChangeClockDivider(13,12);	//hzh
	ChangeMPllValue(52,1,1);	//240MHz,2440A!
#elif (FCLK==300000000)
	ChangeClockDivider(14,11);	//hzh
	ChangeMPllValue(67,1,1);	//304.8MHz,2440A!
#elif (FCLK==320000000)
	ChangeClockDivider(14,11);	//hzh
	ChangeMPllValue(72,1,1);	//320MHz,2440A!
#elif (FCLK==330000000)
	ChangeClockDivider(14,11);	//hzh
	ChangeMPllValue(157,4,1);	//330MHz,2440A!
#elif (FCLK==340000000)
	ChangeClockDivider(14,11);	//hzh
	ChangeMPllValue(77,1,1);	//340MHz,2440A!
#elif (FCLK==350000000)
	ChangeClockDivider(14,11);	//hzh
	ChangeMPllValue(167,4,1);	//350MHz,2440A!
#elif (FCLK==360000000)
	ChangeClockDivider(14,12);	//hzh
	ChangeMPllValue(82,1,1);	//360MHz,2440A!
#elif (FCLK==380000000)
	ChangeClockDivider(14,12);	//hzh
	ChangeMPllValue(87,1,1);	//380MHz,2440A!
#elif (FCLK==400000000)
	ChangeClockDivider(14,12);	//hzh
	ChangeMPllValue(92,1,1);	//400MHz,2440A!
#endif
*/
	
	Isr_Init();
	
	//Led_Test();
	
	i = search_params();	//hzh, don't use 100M!
		//boot_params.cpu_clk.val = 3;
	switch (boot_params.cpu_clk.val) {
	case 0:	//200
		key = 12;
		mpll_val = (92<<12)|(4<<4)|(1);
		break;
	case 1:	//300
		key = 13;
		mpll_val = (67<<12)|(1<<4)|(1);
		break;
	case 2:	//400
		key = 14;
		mpll_val = (92<<12)|(1<<4)|(1);
		break;
	case 3:	//440!!!
		key = 14;
		mpll_val = (102<<12)|(1<<4)|(1);
		break;
	default:
		key = 14;
		mpll_val = (92<<12)|(1<<4)|(1);
		break;
	}
	//init FCLK=400M, so change MPLL first
	ChangeMPllValue((mpll_val>>12)&0xff, (mpll_val>>4)&0x3f, mpll_val&3);
	ChangeClockDivider(key, 12);
	cal_cpu_bus_clk();
	
	consoleNum=boot_params.serial_sel.val&1;	// Uart 1 select for debug.
	Uart_Init(0,115200);
	Uart_Select(0);
	
	Uart_SendByte('\n');
	Uart_Printf("+---------------------------------------------+\n");
	Uart_Printf("           YL2440 Bootloader VER 1.2\n");

/*	if(search_vend_params()) {
		Uart_Printf("Fail to found vender params!\n");
		save_vend_params();
	}*/
	
	if(vend_params.user_params.val)
		Uart_Printf("                %s\n", vend_params.string);
	Uart_Printf("+---------------------------------------------+\n");
	
	Uart_Printf("VID is 0x%08x, PID is 0x%08x\n", vend_params.vid.val, vend_params.pid.val);
	Uart_Printf("Serial NO. is %08x%08x\n", vend_params.ser_h.val, vend_params.ser_l.val);
	//Uart_Printf("BWSCON = 0x%08x\n", rBWSCON);
	Uart_Printf("CPU ID is 0x%08x\n", rGSTATUS1);
	
	if(!i)
		Uart_Printf("Found boot params\n"); 
	else if(i==-1) {
		Uart_Printf("Fail to found boot params!\n");
		save_params();
	} else if(i==-2)
			Uart_Printf("Fail to read EEPROM!\n");
		
	Uart_Printf("FCLK=%dMHz, HCLK=%dMHz, PCLK=%dMHz\nCPU is running at %dMHz\n",
					FCLK/MEGA, HCLK/MEGA, PCLK/MEGA, cpu_freq/MEGA);
	Uart_Printf("UPLL=%dMHz, UCLK=%dMHz\n", UPLL/MEGA, UCLK/MEGA);
	Uart_Printf("Serial port %d, Baud rate is %d.\n", boot_params.serial_sel.val, boot_params.serial_baud.val);
	Uart_Printf("Autoboot delay is %d seconds.\n", boot_params.boot_delay.val);
	if(boot_params.boot_delay.val)
		init_autorun_timer(boot_params.boot_delay.val);

	rMISCCR=rMISCCR&~(1<<3); // USBD is selected instead of USBH1 
	rMISCCR=rMISCCR&~(1<<13); // USB port 1 is enabled.

//
//  USBD should be initialized first of all.
//
	isUsbdSetConfiguration=0;
	
	rDSC0 = 0x2aa;
	rDSC1 = 0x2aaaaaaa;
	rCLKCON = 0xfffff0;

	Lcd_Tft_LTS350Q1_PE1_Init() ;		//LCD initial


#if 0
	UsbdMain(); 
	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();
		MMU_Init();	//hzh
		Delay(0);	//calibrate Delay() first, hzh
		Uart_Printf("NOR Flash ID is 0x%08x [Correct ONLY NorFlash Boot!]\n", GetFlashID());
  #ifdef DEBUG_VERSION
		comdownload();	//hzh
	//	SectorProg(0, (U16 *)downloadAddress, downloadFileSize);
		NandWrite();
  #endif
	UsbdMain(); 
#endif
//	Delay(0);  //calibrate Delay()
	
	pISR_SWI=(_ISR_STARTADDRESS+0xf0);	//for pSOS

	Led_Display(0x6);
    Uart_Printf( "Image$$RO$$Base  = 0x%x\n", Image$$RO$$Base );
	Uart_Printf( "Image$$RO$$Limit = 0x%x\n", Image$$RO$$Limit );
	Uart_Printf( "Image$$RW$$Base  = 0x%x\n", Image$$RW$$Base );
	Uart_Printf( "Image$$RW$$Limit = 0x%x\n", Image$$RW$$Limit );
    Uart_Printf( "Image$$ZI$$Base  = 0x%x\n", Image$$ZI$$Base );
    Uart_Printf( "Image$$ZI$$Limit = 0x%x\n", Image$$ZI$$Limit );

#if USBDMA
	mode="DMA";
#else
	mode="Int";
#endif

	// CLKOUT0/1 select.
	//Uart_Printf("CLKOUT0:MPLL in, CLKOUT1:RTC clock.\n");
	//Clk0_Enable(0);	// 0:MPLLin, 1:UPLL, 2:FCLK, 3:HCLK, 4:PCLK, 5:DCLK0
	//Clk1_Enable(2);	// 0:MPLLout, 1:UPLL, 2:RTC, 3:HCLK, 4:PCLK, 5:DCLK1	
	Clk0_Disable();
	Clk1_Disable();
	
	mpll_val = rMPLLCON;
	//Uart_Printf("DIVN_UPLL%x\n", divn_upll);
	//Uart_Printf("MPLLVal [M:%xh,P:%xh,S:%xh]\n", (mpll_val&(0xff<<12))>>12,(mpll_val&(0x3f<<4))>>4,(mpll_val&0x3));
	//Uart_Printf("CLKDIVN:%xh\n", rCLKDIVN);

	Uart_Printf("\n");