24a0lib.c

s3c24a0固件测试代码 ? ? ? ? ?啊

//************************************************ 
// NAME    : 24a0lib.c
// DESC	  : library functions
// History : 01.20.2004 ver 0.0 
//************************************************


#include "def.h"
#include "option.h"
#include "24a0addr.h"
#include "24a0lib.h"
#include "24a0slib.h" 

#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

extern char Image$$RW$$Limit[];
void *mallocPt=Image$$RW$$Limit;

//===========================[ SYSTEM ]===================================================
//static int delayLoopCount = 400;
static int delayLoopCount = FCLK/10000/10;

void Delay(int time)
{
      // time=0: adjust the Delay function by WatchDog timer.
      // time>0: the number of loop time
      // resolution of time is 100us.
    int i,adjust=0;
    if(time==0) {
        time   = 200;
        adjust = 1;
        delayLoopCount = 400;
            //PCLK/1M,Watch-dog disable,1/64,interrupt disable,reset disable
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3); 
        rWTDAT = 0xffff;                              //for first update
        rWTCNT = 0xffff;                              //resolution=64us @any PCLK 
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3)|(1<<5); //Watch-dog timer start
    }
    for(;time>0;time--)
        for(i=0;i<delayLoopCount;i++);
    if(adjust==1) {
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3);   //Watch-dog timer stop
        i = 0xffff - rWTCNT;                     // 1count->64us, 200*400 cycle runtime = 64*i us
        delayLoopCount = 8000000/(i*64);         //200*400:64*i=1*x:100 -> x=80000*100/(64*i)   
    }
}

//===========================[ PORTS ]===================================================*
void Port_Init(void)
{
	//CAUTION:Follow the configuration order for setting the ports. 
	// 1) setting value(GPDAT) 
	// 2) setting control register  (GPCON_U,GPCON_M, GPCON_L))
	// 3) configure pull-up resistor(GPUP)  

	
	//rGPDAT = 0xffffffff;
	
	//Ports	:GP31			GP30		GP29		GP28		GP27			GP26			GP25	
	//Signal	:IrDA_RXD		IrDA_TXD	IrDA_SDVW	XuCTSn1		XkpCOL4  		XkpCOL3	  		XkpCOL2
	//Binary	:11				11			11			10			11				11				11
	//Ports	:GP24			GP23		GP22		GP21		GP20,			GP19
	//Signal	:XkpCOL1		XkpCOL0		XkpROW4	XkpROW3	XkpROW2		XkpROW1
	//Binary	:11				11			11			11			11				11
 	rGPCON_U = 0x3fbffff; 

	//Ports	:GP18			GP17			GP16				GP15			GP14			GP13				
	//Signal	:XkpROW0		Output(L3_MODE)	Output(L3_CLOCK)		Output(L3_DATA)	EINT14(SMC)		EINT13(ETHERNET)	
	//Binary	:11				01				01					01				10				10		
	//Ports	:GP12			GP11		
	//Signal	:EINT12(MODEM)	EINT11(SD)
	//Binary	:10				10				
	rGPCON_M = 0xd5aa;

	//Ports	:GP10			GP9			GP8				GP7					GP6				GP5				GP4			
	//Signal	:Reserved		EINT9(Switch)	Output(Keyboard)	Output(Keyboard/LED)	Output(LCD/LED)	Output(LCD/LED)	Output(LCD/LED)	
	//Binary	:10				10			01				01					01				01				01		
	//Ports	:GP3			GP2			GP1			GP0			
	//Signal	:Output(nDTR)	Input(DSR)	Output(SMC)	Output(SD)
	//Binary	:01				00			01			01		
	rGPCON_L = 0x255545;

	//disable pull-up function
	rGPPU = 0xffffffff;

	//External interrupt will be falling edge triggered.
	rEXTINTC0= 0x222;			//EINT2~0
	rEXTINTC1 = 0x22222222;		//EINT10~3
	rEXTINTC2 = 0x22222222;		//EINT18~11, falling edge & disabling filter

	//External port pull-up control
	//PERIPU[26]			PERIPU[24]		PERIPU[14]		PERIPU[13]		PERIPU[12]		PERIPU[11]		PERIPU[10]
	//XmsSDIO			XsdDAT[3:0]		XrADDR[25:18]	XciCDATA[7:0]	XmiADDR[10:0]	XmiDATA[7:0]		XspiCLK, XspiMOSI
	//PERIPU[9]			PERIPU[8]		PERIPU[4]		PERIPU[3]
	//X2sLRCK,X2sCLK	XspiMISO			XrDATA[15:0]		XpDATA[31:0]
	rPERIPU= 0x5007f14;		//disabling pull-up function

}


//===========================[ UART ]==============================
static int whichUart=0;

void Uart_Init(int pclk,int baud)
{
    int i;
    
    if(pclk == 0)
    pclk    = PCLK;
    rUFCON0 = 0x0;   //UART channel 0 FIFO control register, FIFO disable
    rUFCON1 = 0x0;   //UART channel 1 FIFO control register, FIFO disable
    rUMCON0 = 0x0;   //UART chaneel 0 MODEM control register, AFC disable
    rUMCON1 = 0x0;   //UART chaneel 1 MODEM control register, AFC disable
    
//UART0
    rULCON0 = 0x3;   //Line control register : Normal,No parity,1 stop,8 bits
    
     //    [10]       [9]     		[8]		[7]        		[6]		[5]			[4]			[3:2]			[1:0]
     // Clock Sel  Tx Int  	Rx Int	Rx Time Out	Rx err 	Loop-back	Send break	Transmit Mode	Receive Mode
     //     0          1       		0         	0          		1        	0           		0            		01          			01
     //   PCLK       Level    	Pulse   	Disable    	Generate Normal      	Normal        	     Interrupt or Polling
    rUCON0  = 0x245;   // Control register

    rUBRDIV0=( (int)(pclk/16./baud+0.5) -1 );   //Baud rate divisior register 0    
    //rUBRDIV0=( (int)(pclk/16./baud) -1 );   //Baud rate divisior register 0, in 5410
    
//UART1
    rULCON1 = 0x3;
    rUCON1  = 0x245;
    rUBRDIV1=( (int)(pclk/16./baud) -1 );

    for(i=0;i<100;i++); 
}

//===================================================================
void Uart_Select(int ch)
{
    whichUart = ch;
}

//===================================================================
void Uart_TxEmpty(int ch)
{

	switch(ch) {
		case 0:
			while(!(rUTRSTAT0 & 0x4)); //Wait until tx shifter is empty.
			break;
		case 1:
			while(!(rUTRSTAT1 & 0x4)); //Wait until tx shifter is empty.
			break;
		default:
			break;
	}
}

//=====================================================================
char Uart_Getch(void)
{

	switch(whichUart) {
		case 0:
			while(!(rUTRSTAT0 & 0x1)); //Receive data ready
			return RdURXH0();
			break;
		case 1:
			while(!(rUTRSTAT1 & 0x1)); //Receive data ready
			return RdURXH1();
			break;
		default:
			break;
	}
}

//====================================================================
char Uart_GetKey(void)
{

	switch(whichUart) {
		case 0:
			if(rUTRSTAT0 & 0x1)    //Receive data ready
				return RdURXH0();
			else
				return 0;
			break;
		case 1:
			if(rUTRSTAT1 & 0x1)    //Receive data ready
				return RdURXH1();
			else
				return 0;
			break;
		default:
			break;
	}
}

//====================================================================
void Uart_GetString(char *string)
{
    char *string2 = string;
    char c;
    while((c = Uart_Getch())!='\r') {
        if(c=='\b') {
            if( (int)string2 < (int)string ) {
                Uart_Printf("\b \b");
                string--;
            }
        }
        else {
            *string++ = c;
            Uart_SendByte(c);
        }
    }
    *string='\0';
    Uart_SendByte('\n');
}

//=====================================================================
int Uart_GetIntNum(void)
{
    char str[30];
    char *string = str;
    int base     = 10;
    int minus    = 0;
    int result   = 0;
    int lastIndex;    
    int i;
    
    Uart_GetString(string);
    
    if(string[0]=='-') {
        minus = 1;
        string++;
    }
    
    if(string[0]=='0' && (string[1]=='x' || string[1]=='X')) {
        base    = 16;
        string += 2;
    }
    
    lastIndex = strlen(string) - 1;
    
    if(lastIndex<0)
        return -1;
    
    if(string[lastIndex]=='h' || string[lastIndex]=='H' ) {
        base = 16;
        string[lastIndex] = 0;
        lastIndex--;
    }

    if(base==10) {
        result = atoi(string);
        result = minus ? (-1*result):result;
    }
    else {
        for(i=0;i<=lastIndex;i++) {
            if(isalpha(string[i])) {
                if(isupper(string[i]))
                    result = (result<<4) + string[i] - 'A' + 10;
                else
                    result = (result<<4) + string[i] - 'a' + 10;
            }
            else
                result = (result<<4) + string[i] - '0';
        }
        result = minus ? (-1*result):result;
    }
    return result;
}

//=====================================================================
void Uart_SendByte(int data)
{

	switch(whichUart) {
		case 0:
			if(data=='\n') {
				while(!(rUTRSTAT0 & 0x2));
				Delay(10);				   //because the slow response of hyper_terminal 
				WrUTXH0('\r');
			}
			while(!(rUTRSTAT0 & 0x2));	 //Wait until THR is empty.
			Delay(10);
			WrUTXH0(data);
			break;
		case 1:
			if(data=='\n') {
				while(!(rUTRSTAT1 & 0x2));
				Delay(10);				   //because the slow response of hyper_terminal 
				rUTXH1 = '\r';
			}
			while(!(rUTRSTAT1 & 0x2));	 //Wait until THR is empty.
			Delay(10);
			rUTXH1 = data;
		default:
			break;
	} 
}               

//====================================================================
void Uart_SendString(char *pt)
{
    while(*pt)
        Uart_SendByte(*pt++);
}

//=====================================================================
//If you don't use vsUart_Printf(), the code size is reduced very much.
#if !USE_MAIN
void Uart_Printf(char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    Uart_SendString(string);
    va_end(ap);
}
#endif


//========================**[ BOARD LED ]=================================
void Led_Display(int data)
{
          //Active is low.(LED On)
          // GP7		GP6		GP5		GP4
          //LED3		LED2	LED0      LED1 
    rGPDAT = (rGPDAT & ~(0xf<<4)) | ((~data & 0xf)<<4);

}


//========================*[ Timer ]==============================**
void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON = ((PCLK/1000000-1)<<8)|(divider<<3);  //Watch-dog timer control register
    rWTDAT = 0xffff;  //Watch-dog timer data register
    rWTCNT = 0xffff;  //Watch-dog count register

      //Enable Watchdog timer with disabling Interrupt and Reset function.
    rWTCON = rWTCON | (1<<5);
}

//=================================================================
int Timer_Stop(void)
{
    rWTCON = ((PCLK/1000000-1)<<8);
    return (0xffff - rWTCNT);
}


//========================*[ MPLL ]==============================*
void ChangeMPllValue(int mdiv,int pdiv,int sdiv)
{
    rMPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}


//========================[ HCLK, PCLK ]===========================
/*
void ChangeClockDivider(int hdivn,int pdivn)
{
     // hdivn,pdivn FCLK:HCLK:PCLK
     //     0,0         1:1:1 
     //     0,1         1:1:2 
     //     1,0         1:2:2
     //     1,1         1:2:4
   // rCLKDIVN = (rCLKDIV & (~0x3)) | (hdivn<<1) | pdivn;    
    rCLKDIVN= (hdivn<<1) | pdivn;    
	rCLKDIVN |= (1<<4);
}
*/

//========================**[ UPLL ]==============================*
void ChangeUPllValue(int mdiv,int pdiv,int sdiv)
{
    rUPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}


//========================*[ General Library ]=====================*
#if !USE_MAIN

void * malloc(unsigned nbyte) 
//Very simple; Use malloc() & free() like Stack
//void *mallocPt=Image$$RW$$Limit;
{
    void *returnPt = mallocPt;

    mallocPt = (int *)mallocPt+nbyte/4+((nbyte%4)>0); //To align 4byte
    Uart_Printf("malloc is called:[%x~%x)\n",(U32)returnPt,(U32)mallocPt);

    if( (int)mallocPt > HEAPEND )
    {
        mallocPt = returnPt;
	Uart_Printf("malloc:no free space!!!\n");
		
        return NULL;
    }
    return returnPt;
}

//-------------------------------------------------------------------
void free(void *pt)
{
    mallocPt = pt;
    Uart_Printf("free() is called:[%x~)\n",(U32)pt);
	
}
#endif

void ChangeSromParameter(unsigned int hclk, int bank)
{
    int acc0, acc1, acc2;
	
    // (Period of hclk(nano second))*1000 =1000000/(hclk/1000000.)
    acc0 = (int)(MINACC0/(1000000/(hclk/1000000.))+0.5)+1;	
    acc1 = (int)(MINACC1/(1000000/(hclk/1000000.))+0.5)+1;
    acc2 = (int)(MINACC2/(1000000/(hclk/1000000.))+0.5)+1;

    if(acc0<=2)
  	acc0=0;    	
    else if(acc0==3)
   	acc0=1;
    else if(acc0==4)
   	acc0=2;
    else if((4<acc0	)&&(acc0<=10))
   	acc0=3;
    else if((10<acc0)&&(acc0<=12))
   	acc0=4;
    else if((12<acc0)&&(acc0<=14))
   	acc0=5;
    else if((14<acc0)&&(acc0<=16))
   	acc0=6;	
    else if((16<acc0))
   	acc0=7;

    if(acc1<=2)
  	acc1=0;    	
    else if(acc1==3)
   	acc1=1;
    else if(acc1==4)
   	acc1=2;
    else if((4<acc1	)&&(acc1<=10))
   	acc1=3;
    else if((10<acc1)&&(acc1<=12))
   	acc1=4;
    else if((12<acc1)&&(acc1<=14))
   	acc1=5;
    else if((14<acc1)&&(acc1<=16))
   	acc1=6;	
    else if((16<acc1))
   	acc1=7;

    if(acc2<=2)
  	acc2=0;    	
    else if(acc2==3)
   	acc2=1;
    else if(acc2==4)
   	acc2=2;
    else if((4<acc2	)&&(acc2<=10))
   	acc2=3;
    else if((10<acc2)&&(acc2<=12))
   	acc2=4;
    else if((12<acc2)&&(acc2<=14))
   	acc2=5;
    else if((14<acc2)&&(acc2<=16))
   	acc2=6;	
    else if((16<acc2))
   	acc2=7;


switch(bank)
	{
	case 0:
	rSROM_BC0=(acc0<<8);
	break;	
	case 1:
	rSROM_BC1=(acc1<<8);
	break;
	case 2:
	rSROM_BC2=(acc2<<8);
	break;
	case 3:
	rSROM_BC0=(acc0<<8)|(1<<12);
	rSROM_BC1=(acc1<<8)|(1<<12);
	rSROM_BC2=(acc2<<8)|(1<<12);
	break;
	default:
	break;
	}	

}

void PreChangeSromParameter(int bank)
{
    switch(bank)
    {
    case 0:
    	rSROM_BC0=rSROM_BC0|(7<<8);//acc0 20clks
	break;
    case 1:	
	rSROM_BC1=rSROM_BC1|(7<<8);//acc1 20clks
	break;
    case 2:	
   	rSROM_BC2=rSROM_BC2|(7<<8);//acc2 20clks
	break;
    case 3:
	rSROM_BC0=rSROM_BC0|(7<<8);//acc0 20clks
	rSROM_BC1=rSROM_BC1|(7<<8);//acc1 20clks
	rSROM_BC2=rSROM_BC2|(7<<8);//acc2 20clks
	break;
    default:
	break;
    }	
}

void ChangeSdramParameter(unsigned int hclk)
{

    int ras1, rc1, rcd1, rp1;

    //(Period of hclk(nano second))*1000 =1000000/(hclk/1000000.)
    ras1 = (int)(MINRAS1/(1000000/(hclk/1000000.))+0.5)+1-1;
    rc1 = (int)(MINRC1/(1000000/(hclk/1000000.))+0.5)+1-1;
    rcd1 = (int)(MINRCD1/(1000000/(hclk/1000000.))+0.5)+1-1;
    rp1 = (int)(MINRP1/(1000000/(hclk/1000000.))+0.5)+1-1;
	
    rSDRAM_REFRESH= (REFPER/100.)*hclk/1000000;	
    rSDRAM_BANKCFG= (rSDRAM_BANKCFG&~(0xfff00))|(ras1<<16)|(rc1<<12)|(rcd1<<10)|(rp1<<8);

}

void PreChangeSdramParameter(void)
{
	rSDRAM_REFRESH =MINREFCYC;
	rSDRAM_BANKCFG =rSDRAM_BANKCFG|(15<<16)|(15<<12)|(3<<10)|(3<<8);//ras1:16clks, rc1:16clks, rcd1:4clks, rp1:4clks
}