//#include <stdio.h>
#include "Option.h"
#include "2443addr.h"


//===========================[ SYSTEM ]===================================================

//--------------------------------------
//			System clock calculator
//--------------------------------------

static int delayLoopCount;

unsigned int MPLL;
unsigned int ARMCLK, HCLK, PCLK;
unsigned int ARMCLKdiv, HCLKdiv, PCLKdiv;


void SystemCLK(void) // edited by junon 060522
{
/*	unsigned int mdiv, pdiv, sdiv;

	mdiv = (rMPLLCON>>16)&0xff;
	pdiv = (rMPLLCON>>8)&0x3;
	sdiv = (rMPLLCON&0x3);

	MPLL = (2*(mdiv+8)*FIN) / (pdiv);
	MPLL >>= sdiv;

	ARMCLKdiv	=	(rCLKDIV0>>9) & 0xf; // [12:9]=ARMDIV -> 1/1 ~ 1/16
	HCLKdiv		=	rCLKDIV0 & ((3<<4)|3); // [5:4]=PREDIV, [0:1]=HCLKDIV
	PCLKdiv		=	(rCLKDIV0>>2) & 1;


	ARMCLK	=	MPLL / ( (ARMCLKdiv&(1<<3)+1) * (ARMCLKdiv&7+1) ); 
	HCLK	=	ARMCLK / ( (HCLKdiv&(3<<4)+1) * (HCLKdiv&3+1) ); 
*/	PCLK	=	50000000;

}


//===========================[ Global Library ]===========================================

//--------------------------------------
//			Delay 1 (Watchdog Timer)
//--------------------------------------

/*
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); 
        rWTCON = ((49)<<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
        rWTCON = ((49)<<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)   
    }
}

*/

//--------------------------------------
//			Delay 2 (Timer 4)
//--------------------------------------

volatile unsigned int TDelayRes = 1000;  // set resolution. [us order : 10us, 100us, 1000us=1ms, 10000us=10ms]
volatile unsigned int TDelayCount = 0;
volatile unsigned int TDelayDone = 0;

void __irq IrqTDelay(void) // Timer 4
{
    TDelayCount--;
    
    if (!TDelayCount)
    {
    	TDelayDone = 1;
		rTCON &= ~(1<<20); // stop timer
    }
    ClearPending(BIT_TIMER4);
}

void SetResTDelay(unsigned int time_res)
{
	TDelayRes = time_res;
}

void InitTDelayFunc(void)  // should be initialized before using TDelay(x)
{
    pISR_TIMER4 = (unsigned )IrqTDelay;
	
    ClearPending(BIT_TIMER4);
	rINTMSK &= ~BIT_TIMER4;

	// make 1MHz Timer clock = PCLK / Prescaler(PCLK/2M-1) + 1 / Divider(2)
	//rTCFG0	|=	(PCLK/2000000-1)<<8;		//  prescaler of timer0 [0:7], calc.
	rTCFG0	|=	(24)<<8;		//  prescaler of timer0 [0:7], calc.
	rTCFG1	&=	~(0xf<<16);				//  divider of timer0 [0:3], 1/2 divide
	
	rTCNTB0	=	TDelayRes - 1;		//	make interrupt by "T_RES" us interval.
	rTCMPB0	=	0;
}

void TDelay(unsigned int d_count)
{
	rINTMSK &= ~BIT_TIMER4;		

	TDelayCount = d_count;
	TDelayDone = 0;
	
	rTCON	|=	(1<<22) | (1<<21);	// auto reload, update data
	rTCON	=	rTCON & ~(1<<21) | (1<<20); // start timer4
	
	while(1)
		if (TDelayDone)	break;

	rINTMSK |= BIT_TIMER4;		
}


//--------------------------------------
//			Stopwatch (Timer 0)
//--------------------------------------

/*
volatile unsigned int TimeRes = 1000;  // set resolution. [us order : 10us, 100us, 1000us=1ms, 10000us=10ms]
volatile unsigned int TimeCount;

void __irq IrqStopwatch(void) // Timer 0
{
    TimeCount++;
    
    ClearPending(BIT_TIMER0);
}

void SetResStopwatch(unsigned int time_res)
{
	TimeRes = time_res;
}

void StartStopwatch(void)
{
    pISR_TIMER0= (unsigned )IrqStopwatch;
	
    ClearPending(BIT_TIMER0);
	rINTMSK &= ~BIT_TIMER0;

	TimeCount = 0;
	
	// make 1MHz Timer clock = PCLK / Prescaler(PCLK/2M-1) + 1 / Divider(2)
	rTCFG0	|=	PCLK/2000000-1;		//  prescaler of timer0 [0:7], calc. for Timer 0,1
	rTCFG1	&=	~(0xf);				//  divider of timer0 [0:3], 1/2 divide
	
	rTCNTB0	=	TimeRes - 1;		//	make interrupt by "T_RES" us interval.
	rTCMPB0	=	0;

	rTCON	|=	(1<<3) | (1<<1);	// auto reload, update data
	rTCON	=	rTCON & ~(1<<1) | (1); // start timer0
}

unsigned int EndStopwatch(void)
{
	unsigned int a;
	
	rTCON = 0; // stop timer
	a = TimeCount * TimeRes + (TimeRes - rTCNTO0);
	rINTMSK |= BIT_TIMER0;
	
	return a;  // unit => us
}

*/