tblib.c

arm7s3c44b0x0里ps2口和lcd口驱动编程实例

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

#include "\inc\define.h"
#include "\inc\drives.h"
#include "\inc\TBlib.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[];
volatile unsigned char *downPt;
unsigned int fileSize;
void *mallocPt=Image$$RW$$Limit;

void (*restart)(void)=(void (*)(void))0x0;
void (*run)(void)=(void (*)(void))DOWNLOAD_ADDRESS;
//--------------------------------SYSTEM---------------------------------//

void SoftDelay(int ms)//64M, delay about 1ms
{
	int i,j,k;
	for(i=0;i<ms;i++)
	{
		for(j=0;j<256;j++);
		for(k=0;k<256;k++);
	}
}
//------------------------PORTS------------------------------//


/************************* UART ****************************/
static int whichUart=0;

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	RdURXH1();
    }
}

char Uart_WaiteKey(unsigned long timeout, int *error_p)
{
    char c;
    int state;
    
    if(whichUart==0)
    {	    
		while(!(rUTRSTAT0 & 0x1))    //Receive data ready
		{
		   if(!timeout)
		     break;
		   else
		     timeout--;
		}
		if(timeout==0)
		{
			c=0;
			state=-1;
		}
		else
		{
		    c=RdURXH0();
		    state=0;
		}
	}
    else
    {
		while(!(rUTRSTAT1 & 0x1))    //Receive data ready
		{
		   if(!timeout)
		     break;
		   else
		     timeout--;
		}
		if(timeout==0)
		{
			c=0;
			state=-1;
		}
		else
		{
		    c=RdURXH0();
		    state=0;
		}
    }
    *error_p=state;
    return(c);   
}

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 RdURXH1();
		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);
}

int Uart_RxReady(void)
{
	if(whichUart)
		return (rUTRSTAT1 & 0x1);	//Receive data ready
	else 
		return (rUTRSTAT0 & 0x1);	//Receive data ready
}


/******************** S3C44B0X EV. BOARD LED **********************/

void Led_Display(int LedStatus)
{
	if((LedStatus&0x01)==0x01)
		rPDATE=rPDATE&0x17f;
	else
		rPDATE=rPDATE|0x80;
	
	if((LedStatus&0x02)==0x02)
		rPDATE=rPDATE&0x1bf;
	else
		rPDATE=rPDATE|0x40;

	if((LedStatus&0x04)==0x04)
		rPDATE=rPDATE&0x1df;
	else
		rPDATE=rPDATE|0x20;

	if((LedStatus&0x08)==0x08)
		rPDATE=rPDATE&0x1ef;
	else
		rPDATE=rPDATE|0x10;
}

/*void Beep(int BeepStatus)
{
	if (BeepStatus==0)
		rPDATE=rPDATE|0x8;
	else
		rPDATE=rPDATE&0x1f7;

}
*/

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




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

unsigned char Readkey(void)
{
	unsigned char ch1,ch2;
	ch1=(rPDATG&0xf0);
	//Uart_Printf("\n key=%d",ch1);
	if(ch1!=0xf0)
	{
		Delay(10);
		ch2=(rPDATG&0xf0);
		//Uart_Printf("\n key=%d",ch2);
		if(ch1==ch2)//Confirm the key
		{
		   Beep(0x01,10);
		   Delay(20);
		   while((rPDATG&0xf0)!=0xf0);
		   Beep(0x00,10);
		   if (ch1==0x70)
		   return('S');
		   else if(ch1==0xb0)
		   return('C');
		   else if(ch1==0xd0)
		   return('E');
		   else if(ch1==0xe0)
		   return('O');
		}
	}
	return(0);
}

void _disable_(void)
{
    rI_ISPC=BIT_EINT0;
    rINTMSK|=(BIT_EINT0|BIT_GLOBAL);//0x01<<26;
		
	//rINTCON=0x2|rINTCON;
	
}

void _enable_(void)
{
    
    rI_ISPC=BIT_EINT0;
	rINTMSK&=(~(BIT_EINT0|BIT_GLOBAL));
	//rINTCON=0xfffffff9&rINTCON;
}

int _atoi_(char *str)
{
    int n=0;
    char c=1;

    while((c=*str++)&&(c>=0x30)&&(c<=0x39))
            n = n*10 + c-'0';
    return(n);
}



/****************************************************************
 *		ARMSYS7 S3C44B0X developer's notes						*  
 ****************************************************************

 1. 2005.5.17::
 
 ***************************************************************/




void Memcpy(void *s1, const void *s2, int n)
{
	int i;

	for (i = 0; i < n; i++)
		((char *)(s1))[i] = ((const char *)(s2))[i];
}

void Memset(void *s, const char ch, int n)
{
	int i;

	for (i = 0; i < n; i++)
		((char *)(s))[i] = ch;
}

U16 ntohs(unsigned short s)
{
	return (s >> 8) | (s << 8);
}

U32 ntohl(U32 num)
{
	return  ((num >> 24) & 0x000000ff) |
		((num >>  8) & 0x0000ff00) |
		((num <<  8) & 0x00ff0000) |
		((num << 24) & 0xff000000);
}

U16 htons(U16 s)
{
	return (s >> 8) | (s << 8);
}

U32 htonl(U32 num)
{
	return ntohl(num);
/*	return  ((l >> 24) & 0x000000ff) |
		((l >>  8) & 0x0000ff00) |
		((l <<  8) & 0x00ff0000) |
		((l << 24) & 0xff000000);*/
}

/*U32 strtoul(char *s)
{
	U32 ret;
	int i;

	ret = 0;

	while (*s != '\0') 
	{
		if (*s >= '0' && *s <= '9')
			i = *s - '0';
		else if (*s >= 'a' && *s <= 'f')
			i = *s - 'a' + 0xa;
		else if (*s >= 'A' && *s <= 'F')
			i = *s - 'A' + 0xa;
		else
			return -1;
		ret = (ret << 4) + i;
		s++;
	}

	return ret;
}
*/
void ultostr(char *s, U32 data)
{
	int i;
	
	s[8] = 0;
	for(i=7; i>=0; i--, data >>=4)
	{
		if((data&0xf)<=9)
			s[i] = (data&0xf)+'0';
		else
			s[i] = (data&0xf)+'a'-0x0a;
	}	
}

U32 strtobcd(char *s)
{
	unsigned long ret;
	int i;

	ret = 0;

	while (*s != '\0') 
	{
		if (*s >= '0' && *s <= '9')
			i = *s - '0';
		else
			return -1;
		ret = (ret << 4) + i;
		s++;
	}

	return ret;
}

U32 strtodec(char *str, int cnt)
{
	U32 i, data = 0;	
	
	for(i=0; i<cnt; i++)
	{
		data *= 10;
		if(str[i]<'0'||str[i]>'9')
			return -1;
		data += str[i]-'0';			
	}	
	return data;
}

int Strlen(const char *s)
{
	int i = 0;

	for(; *s; s++)
		i++;
	
	return i;
}

int Strncmp(const char *s1, const char *s2, int maxlen)
{
	int i;

	for(i = 0; i < maxlen; i++) 
	{
		if(s1[i] != s2[i])
			return ((int) s1[i]) - ((int) s2[i]);
		if(s1[i] == 0)
			return 0;
	}

	return 0;
}

/*---------------------printf and support routines ---------------------*/
/* print c count times */
void PutRepChar(char c, int count)
{
	while (count--) putch(c);
}

/* put string reverse */
void PutStringReverse(char *s, int index)
{
  while ((index--) > 0) putch(s[index]);
}

/*-------------------------------------------------------------------------*/
/* 
   prints value in radix, in a field width width, with fill
   character fill
   if radix is negative, print as signed quantity
   if width is negative, left justify
   if width is 0, use whatever is needed
   if fill is 0, use ' '
 */



/*-------------------------------------------------------------------------*/


#define vaStart(list, param) list = (char*)((int)&param + sizeof(param))
#define vaArg(list, type) ((type *)(list += sizeof(type)))[-1]
#define vaEnd(list)

int getyorn(void)
{
	char c;
	
	puts(" [y/n] ");
	while(1) 
	{		
		c = getch();
		if((c=='y')||(c=='Y')||(c=='n')||(c=='N'))
			break;
	}
	putch(c);
	putch('\n');
	return c&1;	//y&Y are odd, n&N are even
}

int GetParameter(char *str, int cnt)
{
	int i, key;	
	
	i = 0;
	while(1)
	{
		key = getch();
		if(key)
		{
			if(key == ENTER_KEY)
			{
				str[i] = 0;
				return i;
			}
			else if(key == BACK_KEY && i>0)
			{
				i--;
				printf("\b \b");
			}
			else if(key == 0x1b)   //key=='s'键值
			{
				//getch();
				//getch();
				return -1;
			}
			else if(key>=0x20 && key <=0x7e && i<cnt)
			{
				str[i++] = key;
				putch(key);
			}				
		}
	}	
}