44blib.c

uCOSII for s3c44b0xARM嵌入处理器SDT2.5开发环境

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


#include "..\inc\44b.h"
#include "..\inc\44blib.h"
#include "..\inc\def.h"
#include "..\inc\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) {
    
    for(;time>0;time--);

}

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

void Port_Init(void)
{
	// PORT A GROUP
	/*  BIT 9	8	7	6	5	4	3	2	1	0	*/
	/*  O	  A23	A22	A21	A20	A19	A18	A17	A16	A0	*/	      
	/*  0		1	1	1	1	1	1	1	1	1	*/
//新	rPCONA = 0x1ff;	

	// PORT B GROUP
	/*  BIT 10	9		8		7		6		5		4		3		2		1		0		*/
	/*	/CS5	/CS4	/CS3	/CS2	/CS1	nWBE3	nWBE2	/SRAS	/SCAS	SCLK	SCKE	*/
	/*	NC		NC		8019	NC		NC		NC		NC		Sdram	Sdram	Sdram	Sdram	*/
	/*	0,		0,   	1,   	0,    	0,    	0,      0,		1,    	1,    	1,   	1       */
//新	rPDATB = 0x04f;
//新	rPCONB = 0x10f;    
    
	//PORT C GROUP
	//BUSWIDTH=16													*/
	/*  PC15	14		13		12		11		10		9		8	*/
	/*	o		o		RXD1	TXD1	o		o		o		o	*/
	/*	NC		NC		NC		NC		NC		NC		EL_ON	nDISP_ON	*/
	/*  00		00		00		00		00		00		01		01	*/

	/*  PC7		6		5		4		3		2		1		0	*/
	/*  o		o		o		o		o		o		o		o	*/
	/*  VD4		VD5		VD6		VD7		NC		NC		NC		NC	*/
	/*  11		11		11		11		00		00		00		00	*/
//新	rPDATC = 0x0000;	//All IO is low
//新	rPCONC = 0x0005ff00;	
//新	rPUPC  = 0x3000;	//PULL UP RESISTOR should be enabled to I/O

	//PORT D GROUP
	/*  PORT D GROUP(I/O OR LCD)										*/
	/*  BIT7		6		5		4		3		2		1		0	*/
	/*  VF			VM		VLINE	VCLK	VD3		VD2		VD1		VD0	*/
	/*	01			01		01		01		01		01		01		01	*/
//新	rPDATD= 0x55;
//新	rPCOND= 0xaaaa;	
//新	rPUPD = 0x00;

	//These pins must be set only after CPU's internal LCD controller is enable
	//PORT E GROUP 
	/*  Bit 8		7		6		5		4		3		2		1		0		*/
	/*	ENDLAN		NC		led2	led1	led0	Beep	RXD0	TXD0	NC		*/ 
	/*  00			00		01		01		01		01		10		10		00		*/	
//新	rPDATE	= 0x157;
//新	rPCONE	= 0x1568;				
//新	rPUPE	= 0xff;
	
	//PORT F GROUP
	/*  Bit8		7		6		5		 4		3		2		1		0		*/   
	/*  NC			RXD1	TXD1	NC	 	NC		NC		NC		NC		NC		*/
	/*	000			010		010		000		 00		00		00		00		00		*/	
//新	rPDATF = 0x0;
//新	rPCONF = 0x024000;	 
//新	rPUPF  = 0x1d3;

	//PORT G GROUP
	/*  BIT7		6		5		4		3		2		1		0		*/
	/*	EINT7		EINT6	EINT5	EINT4	EINT3	EINT2	EINT1	EINT0	*/
	/*  KEY3		KEY2	KEY1	KEY0	NC		NC		ETH_INT	NC		*/
	/*	11 			11      11      11      00      00      11      00		*/
//新	rPDATG = 0xff;
//新	rPCONG = 0xff0c;	//enable extint0 extint1
//新	rPUPG  = 0x00;		//enabled pull up register
    
    	rSPUCR=0x7; 	//D15-D0 pull-up disable
    
	rEXTINT=0x0;	//All EXTINT0-7 Low level interrupt
	
	//Define the Non_Cache area
	//新rNCACHBE0=(((Non_Cache_End)>>12)<<16)|((Non_Cache_Start)>>12); 
	rNCACHBE0 = 0xc0000000;		//定义非Cache区,从0x0000000到0xbffffff	烧写FLASH时不能对FLASH cache
	//新rNCACHBE0=(((Non_Cache_End)>>12)<<16)|((Non_Cache_Start)>>12); 
}


/************************* 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
//    rULCON0=0x7;     //Normal,No parity,2 stop,8 bit
    rUCON0=0x245;    //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=0x7;     //Normal,No parity,2 stop,8 bit
    rULCON1=0x3;
    rUCON1=0x245;
    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 
	    WrUTXH0('\r');
	}
	while(!(rUTRSTAT0 & 0x2)); //Wait until THR is empty.
	Delay(10);
	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);
}


/********************BOARD 3 LED **********************/

void Led_Display(int LedStatus)
{
    ShowLed( LedStatus<<4 );
}

/********************BOARD BEEP************************/

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

/************************* 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; 			    
}