#include "def.h"
#include "option.h"
#include "2410addr.h"
#include "2410lib.h"
#include "2410slib.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)   
	}
}

//===========================[ 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
	rUFCON2 = 0x0;   //UART channel 2 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) -1 );   //Baud rate divisior register 0
	rUBRDIV0=( (int)(pclk/16./baud+0.5) -1 );   //Baud rate divisior register 0	
	
//UART1
	rULCON1 = 0x3;
	rUCON1  = 0x245;
	rUBRDIV1=( (int)(pclk/16./baud) -1 );
	
//UART2
	rULCON2 = 0x3;
	rUCON2  = 0x245;
	rUBRDIV2=( (int)(pclk/16./baud) -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 if(ch==1)
		while(!(rUTRSTAT1 & 0x4)); //Wait until tx shifter is empty.
		
	else if(ch==2)
		while(!(rUTRSTAT2 & 0x4)); //Wait until tx shifter is empty.
}

//=====================================================================
char Uart_Getch(void)
{
	if(whichUart==0)
	{	   
		while(!(rUTRSTAT0 & 0x1)); //Receive data ready
		return RdURXH0();
	}
	else if(whichUart==1)
	{	   
		while(!(rUTRSTAT1 & 0x1)); //Receive data ready
		return RdURXH1();
	}
	else if(whichUart==2)
	{
		while(!(rUTRSTAT2 & 0x1)); //Receive data ready
		return RdURXH2();
	}
	return 0;
}

//====================================================================
char Uart_GetKey(void)
{
	if(whichUart==0)
	{	   
		if(rUTRSTAT0 & 0x1)	//Receive data ready
			return RdURXH0();
		else
			return 0;
	}
	else if(whichUart==1)
	{
		if(rUTRSTAT1 & 0x1)	//Receive data ready
			return RdURXH1();
		else
			return 0;
	}
	else if(whichUart==2)
	{	   
		if(rUTRSTAT2 & 0x1)	//Receive data ready
			return RdURXH2();
		else
			return 0;
	}
	
	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 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)
{
	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(whichUart==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;
	}   
	else if(whichUart==2)
	{
		if(data=='\n')
		{
			while(!(rUTRSTAT2 & 0x2));
			Delay(10);				 //because the slow response of hyper_terminal 
			rUTXH2 = '\r';
		}
		while(!(rUTRSTAT2 & 0x2));   //Wait until THR is empty.
		Delay(10);
		rUTXH2 = 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);
}



//========================*[ 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

	  //Watch-dog timer enable & interrupt  disable
//	rWTCON = rWTCON |(1<<5) & !(1<<2);  //?
	rWTCON = rWTCON | (1<<5) | ~(1<<2);  //May 06, 2002 SOP
}

//=================================================================
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 = (hdivn<<1) | pdivn;	
	
	if(hdivn)
		MMU_SetAsyncBusMode();
	else 
		MMU_SetFastBusMode();
}


//========================**[ UPLL ]==============================*
void ChangeUPllValue(int mdiv,int pdiv,int sdiv)
{
	rUPLLCON = (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;
}