44blib.c

使用三星ARM7芯片S3C44B0

/************************************************
 * NAME    : 44BLIB.C				            *
 ************************************************/


#include "44b.h"
#include "44blib.h"
#include "def.h"
#include "option.h"

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

#define STACKSIZE    0xa00 //SVC satck size(do not use user stack)
#define HEAPEND     (_ISR_STARTADDRESS-STACKSIZE-0x500) // = 0xc7ff000
	//SVC Stack Area:0xc(e)7ff000-0xc(e)7ffaff

extern char Image$$RW$$Limit[];

void *mallocPt=Image$$RW$$Limit;


/************************* SYSTEM *************************/

void Delay(int time)
{
    int i;
	int delayLoopCount=400;

    for(;time>0;time--)
	for(i=0;i<delayLoopCount;i++);
}

void delay(int time)
{

    for(;time>0;time--);

}

/************************* PORTS ****************************/

void Port_Init(void)
{
    //ADB V1.0 B/D Status
    //USB D12SUSPD 
    //    PC0
    //LED D0  D1  D2
    //	  PC1 PC2 PC3
    //KEY K0  K1  K2  K3
    //	  PG4 PG5 PG6 PG7

    //CAUTION:Follow the configuration order for setting the ports. 
    // 1) setting value 
    // 2) setting control register 
    // 3) configure pull-up resistor.  
	     
    //16bit data bus configuration  
    //PORT A GROUP
    //rPCONA[9:0]
    //|BIT9  |.......................................................|BIT0
    //|ADDR24|ADDR23|ADDR22|ADDR21|ADDR20|ADDR19|ADDR18|ADDR17|ADDR16|ADDR0		      
    //|     0|     1|	  1|     1|     1|     1|     1|	 1|     1|    1
    rPCONA=0x1ff;	

    //PORT B GROUP
    //rPCONB[10:0]
    //|BIT10|....................................................|BIT0
    //|nGCS5|nGCS4|nGCS3|nGCS2|nGCS1|nWBE3|nWBE2|nSRAS|nSCAS|SCLK|SCKE
    //|    1|    1|    1|	 1|    1|    1|    1|	 1|    1|   1|   1
    rPDATB=0x3ff; 
    rPCONB=0x3ff;
    
    //PORT C GROUP
    //BUSWIDTH=16
    //PORT C GROUP(已修正)
    //rPCONC[31:0]
    //|GPC15|....................................................................|    GPC0
    //|BIT31|....................................................................|    BIT0
	//|LEDLOCK|LEDREM|Rxd |Txd1  |LEDSQL|LEDAFC|LEDAGC|PWRSHDN|VD4|VD5|VD6|VD7|KEYCLK|KEYDAT|RSTKEY|RSTDSP|
    //|   00|   00|     11|    11|    01|    01|    01|     01| 11| 00| 01| 01|    01|01(In/out)|01|    01
    //rPUPC[15:0]
    //|    0|    0|   1|   1|    1|    1|  1|    1|  0|  0|  0|  0|   1|   1|   1|       1
    rPDATC=0;	//All I/O Is High
    rPCONC=0xf555555;
    rPUPC=0;//0x3F0F;//PULL UP RESISTOR should be enabled to I/O


    //PORT D GROUP
    //rPCOND(已修正)
    //| BIT15|.........................|BIT0 
    //|VFRAME|VM|VLINE|VCLK|VD3|VD2|VD1|VD0
    //|    00|00|   00|	 00| 00| 00| 01| 00  
    rPDATD=0;
    Delay(1000);
    rPDATD=0xff;
    rPCOND= 0x4;
	rPUPD = 0;//0xff;
	//These pins must be set only after CPU's internal LCD controller is enable
	

    //PORT E GROUP
    //rPCONE(已修正)
    //| BIT17 |..............................|BIT0
    //      PE7|PE6|PE5|PE4|TOUT0|RXD0|TXD0| PE0
    //|     00| 00| 00|  01|  10|  10|  10|  00
    //|rPUPE[7:0]
    //        |  0|  0|   0|  0|  0|   1|   1|   0
//    rPDATE=0x1ff;  	//All I/O Is High
    rPCONE=0x1a8;//0x1555;
    rPDATE=0x0; 
//    rPCONE=0x20428;	//All NC is INPUT	
    rPUPE=0x06;	//PE8 do not have programmable pull-up resistor.  

    //PORT F GROUP
    //rPCONF[21:0](已修正)
    //| BIT21|....................................|  BIT0
	//|STB4|STB3|STB2|STB1|CPLD0|CPLD1|N/A|RFDAT|RFCLK|
    //| 001|001|  001| 001|  00 |  00 | 00|  01 |    01
    //rPUPF[8:0]
    //|   1|  1|    1|      1|  0|  0|  0|     1|     1
    rPDATF=0x1ff;	//All I/O Is High
    rPCONF=0x92405;
    rPUPF=0x1E3;

    //PORT G GROUP
    //rPCONG[15:0](已修正)
    //|BIT15|....................................|   BIT0
    //| N/A|ALARM2|ALARM1|CPLDINT|KEYINT|DSPINT|N/A|INT0
    //|  00|    00|    00|     11|    11|    11| 00| 11
    rPDATG=0xff;
    rPCONG=0x3F3;	
    rPUPG=0x0;		//should be enabled  
    rSPUCR=0x6; 	//D15-D0 pull-up disable

	//Define the Non_Cache area
	rNCACHBE0=(((Non_Cache_End)>>12)<<16)|((Non_Cache_Start)>>12); 
}

/***********************************************************
Name	:  	Timer_Init
Function:	初始化系统定时器
Input	:	无
Return	:	无
说明	:	无
***********************************************************/
//extern void Timer3_TouchExe(void);
void Timer3_TouchExe_Init(void)
{
	rINTCON=0x5;    //Non-vectored,IRQ enable,FIQ disable 
    rINTMOD=0x0;    //All=IRQ mode
    
    //pISR_TIMER3=(unsigned)Timer3_TouchExe;
    rINTMSK=BIT_GLOBAL;
//    rINTMSK=~(BIT_GLOBAL|BIT_TIMER3);	//start timer INT
/*	
 *	Timer Clock Frequency = MCLK/pre/mux
 */	
    rTCFG0=0x00000f00;	//dead zone=0,pre2=0,pre1=0xf,pre0=0
    rTCFG1=0x00001000;	//all interrupt,mux5=1/2,mux2=1/2,mux3=1/4,mux2=1/2,mux1=1/2,mux0=1/2
    
    rTCNTB3=0xc350;		//(1/(60MHz/4/15))*0xc350=50ms
    					//(1/(60MHz/4/15))*0x4320=20ms
    rTCMPB3=0x0;

    rTCON=0x0020000;	//update T3
    rTCON=0x0090000;	//T3=auto reload,start	
}
/************************* UART ****************************/

static int whichUart=0;

void Uart_Init(int mclk,int baud)
{
    int i;
    if(mclk==0)
	mclk=MCLK;
    rUFCON0=0x0;     //FIFO disable
    rUFCON1=0x0;
    rUMCON0=0x0;
    rUMCON1=0x0;
//UART0
    rULCON0=0x3;     //Normal,No parity,1 stop,8 bit
    rUCON0=0x45;    //rx=edge,tx=level,disable timeout int.,enable rx error int.,normal,interrupt or polling
    rUBRDIV0=( (int)(mclk/16./baud + 0.5) -1 ); 
   

//UART1
    rULCON1=0x3;
    rUCON1=0x45;
    rUBRDIV1=( (int)(mclk/16./baud + 0.5) -1 );



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


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


void Uart_TxEmpty(int ch)
{
    if(ch==0)
	while(!(rUTRSTAT0 & 0x4)); //wait until tx shifter is empty.
    else
    	while(!(rUTRSTAT1 & 0x4)); //wait until tx shifter is empty.
}


char Uart_Getch(void)
{
    if(whichUart==0)
    {	    
	while(!(rUTRSTAT0 & 0x1)); //Receive data read
	return RdURXH0();
    }
    else
    {
	while(!(rUTRSTAT1 & 0x1)); //Receive data ready
	return	rURXH1;
    }
}


char Uart_GetKey(void)
{
    if(whichUart==0)
    {	    
	if(rUTRSTAT0 & 0x1)    //Receive data ready
    	    return RdURXH0();
	else
	    return 0;
    }
    else
    {
	if(rUTRSTAT1 & 0x1)    //Receive data ready
	    return rURXH1;
	else
	    return 0;
    }
}


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 lastIndex;
    int result=0;
    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( 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)
{
    if(whichUart==0)
    {
//	if(data=='\n')
//	{
	    while(!(rUTRSTAT0 & 0x2));
//	    Delay(10);	//because the slow response of hyper_terminal 
//	    rUTXH0='\r';//WrUTXH0('\r');
//	}
	while(!(rUTRSTAT0 & 0x2)); //Wait until THR is empty.
//	Delay(10);
	rUTXH0=data;//WrUTXH0(data);
    }
    else
    {
//	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;
    }	

}		


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


//if you don't use vsprintf(), the code size is reduced very much.
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);
}
void Uart_Puts(char *str)
{
	while(*str)
		Uart_SendByte(*str++);
}
/************************* GetKey *******************************/
U8 GetKey(void)
{
	U8 whichkey=0xf0;
	whichkey=rPDATG&0xf0;
	Delay(1000);
	if(whichkey!=rPDATG&0xf0)
		whichkey=0xf0;
	switch(whichkey)
    {
	case 0xe0:
	    return 1;
	case 0xd0:
	    return 2;
	case 0xb0:
	    return 3;
	case 0x70:
	    return 4;
	default :
	    return 0xff;
    }
}
        
/************************* WaitKey *******************************/
U8 WaitKey(void)
{
	U8 k;
	while(1) 
	{
		k=GetKey();
		if(k!=0xff)
			break;
	}
	return k;
}

/************************* ledblink *****************************/

void Led_Display(int LedStatus)
{
	//PC1,PC2,PC3 High available
    rPDATC=(rPDATC & 0x1f1) | ((LedStatus & 0x7)<<1);
}

/************************* beep *********************************/

void Beep(int BeepStatus)
{
	//PE5 Low available
	if (BeepStatus==0)
		rPDATE=rPDATE&0x1df;
	else
		rPDATE=rPDATE|0x020;
}

/************************* Timer ********************************/

void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3);
    rWTDAT=0xffff;
    rWTCNT=0xffff;   

    // 1/16/(65+1),nRESET & interrupt  disable
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3)|(1<<5);	
}


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


/************************* PLL ********************************/
void ChangePllValue(int mdiv,int pdiv,int sdiv)
{
    rPLLCON=(mdiv<<12)|(pdiv<<4)|sdiv;
}


/************************* General Library **********************/

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

    if( (int)mallocPt > HEAPEND )
    {
	mallocPt=returnPt;
	return NULL;
    }
    return returnPt;
}


void free(void *pt)
{
    mallocPt=pt;
}


void Cache_Flush(void)
{
    int i,saveSyscfg;
    
    saveSyscfg=rSYSCFG;

    rSYSCFG=SYSCFG_0KB; 		      
    for(i=0x10004000;i<0x10004800;i+=16)    
    {					   
	*((int *)i)=0x0;		   
    }
    rSYSCFG=saveSyscfg; 			    
}