//====================================================================
// File Name : rtc.c
// Function  : S3C2443 RTC Test Program
// Date      : June. 5, 2006
// Version   : 0.0
// History
//   0.0 : Programming start (June. 05, 2006)
//====================================================================

#include <stdio.h>
#include <stdlib.h>

#include "2443addr.h"
#include "System.h"
#include "Exception.h"
#include "Console.h"
#include "def.h"
#include "rtc.h"

char *day[8] = {" ","Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
volatile U32 Tick=0, Alarm=0;

void * rtc_func[][2]=
{
	(void *)RTC_time_tick,		"RTC Time Tick Int Test",
	(void *)RTC_initialize,			"RTC time initialize        ",	
	(void *)Rtc_Alarm,			"RTC Alarm Test	",
	(void *)RTC_BATFLT,			"RTC battery falut check Test	",
	0,0
};

void Test_RTC(void)
{
	int i=0;
	
	while(1) {
		printf("\n");
		while(1)
		{   //display menu
	    	printf("%2d:%s",i,rtc_func[i][1]);
	    	i++;
	    	if((int)(rtc_func[i][0])==0)
	    	{
				printf("\n");
				break;
	    	}
	    	if((i%4)==0) printf("\n");
		}
		printf("\nSelect(-1 to exit): ");
		i = GetIntNum();

		if(i==-1) break;

		if(i>=0 && (i<(sizeof(rtc_func)/4)) ) 
	    	( (void (*)(void)) (rtc_func[i][0]) )();	// execute selected function.
	}
}


void RTC_initialize(void)
{
	int year,month,date,hour,min,sec;

	year =  6;
	month= 12;
	date = 31;
	hour = 23;
	min  = 59;
	sec  = 20;
	
    	rRTCCON  = rRTCCON  | 0x1;		//RTC Control enable

    	rBCDYEAR =( ((year/10)<<4) + (year%10) );
    	rBCDMON  =( ((month/10)<<4)+ (month%10));
    	rBCDDATE =( ((date/10)<<4) + (date%10) );     	
    	rBCDDAY  = rBCDDAY  & ~(0x7)  | 0x3;		//SUN:1 MON:2 TUE:3 WED:4 THU:5 FRI:6 SAT:7
    	rBCDHOUR =( ((hour/10)<<4) + (hour%10) );
    	rBCDMIN  =( ((min/10)<<4)  + (min%10)  );
    	rBCDSEC  =( ((sec/10)<<4)  + (sec%10)  );     	

    	//rRTCCON  = rRTCCON  & ~(0x1);	//RTC Control disable

  	while (!Uart_GetKey()){	
    		printf("%2x : %2x : %2x  %10s,  %2x/%2x/20%02x\n",rBCDHOUR,rBCDMIN,rBCDSEC,day[rBCDDAY],rBCDMON,rBCDDATE,rBCDYEAR);
  	}
}
void RTC_time_tick(void)
{
	int i;
	
	RTC_Init();

	printf("[0]1/16384\t[1]:1/8192[2]1/4096\t[3]1/2048\t[4]1/128\t[5]1/1\t[6]1/32768\t :");

	i=GetIntNum();

	rRTCCON = (rRTCCON & ~(0x7<<5)) | (i<<5);

	//printf(" rtcon = %08x\n", rRTCCON);
	
	switch(i)
		{
			// tick interval = 1/tick_clock * (tick_count +1)
			#if 1
			case 0: 	Tick_Count_Set(16384); break;
			case 1: 	Tick_Count_Set(8192); break;
			case 2: 	Tick_Count_Set(4096); break;
			case 3: 	Tick_Count_Set(2048); break;
			case 4: 	Tick_Count_Set(128); break;
			case 5: 	Tick_Count_Set(1); break;			
			case 6: 	
					rRTCCON &= ~(7<<5);
					rRTCCON |= (1<<4); 
					printf(" rtcon = %08x\n", rRTCCON);
					Tick_Count_Set(32767); 
					break;			
			default : break;
			
			#elif 0 // for tick interval test
			case 0: 	Tick_Count_Set(1); break;
			case 1: 	Tick_Count_Set(1); break;
			case 2: 	Tick_Count_Set(1); break;
			case 3: 	Tick_Count_Set(1); break;
			case 4: 	Tick_Count_Set(1); break;
			case 5: 	Tick_Count_Set(1); break;			
			case 6: 	
					rRTCCON &= ~(7<<5);
					rRTCCON |= (1<<4); 
					printf(" rtcon = %08x\n", rRTCCON);
					Tick_Count_Set(1); 
					break;			
			default : break;
			
			#elif 0 // for tick clock resolution
			case 0: 	Tick_Count_Set(2); break;
			case 1: 	Tick_Count_Set(2); break;
			case 2: 	Tick_Count_Set(2); break;
			case 3: 	Tick_Count_Set(2); break;
			case 4: 	Tick_Count_Set(2); break;
			case 5: 	Tick_Count_Set(2); break;			
			case 6: 	
					rRTCCON &= ~(7<<5);
					rRTCCON |= (1<<4); 
					printf(" rtcon = %08x\n", rRTCCON);
					Tick_Count_Set(2); 
					break;			
			default : break;
			
			#endif
		}

	
  	pISR_TICK = (U32)Rtc_Tick_ISR;
   	rINTMSK &= ~(BIT_TICK);

	// for checking tick interval
   	rGPHCON = (rGPHCON & ~(3<<26)) | (1<<26);
	rGPHDAT |= (1<<13);

    	
   	rTICNT0 |= (1<<7);	// Tick Time Interrupt Enable
    
    	
   	while(!Uart_GetKey()) {
    		
   		while(!Tick);	// Wait Tick Interrupt
		//printf("Tick cnt value = %08d\n", rTICNT0); // internal tick time counter register (s3C2443 only)
		Print_RTC();
  		Tick=0;
    	}
	
	rRTCCON &= ~(1<<4);
  	rTICNT0 &= ~(1<<7);	// Tick Time Interrupt Disable
   	rINTMSK |= (BIT_TICK);
   	ClearPending(BIT_TICK);
}

void Rtc_Alarm(void)
{
	int i;
	
    	printf("[ RTC Alarm Test for S3C2442 ]\n");

    	rRTCCON  = 0x01;                    //No reset, Merge BCD counters, 1/32768, RTC Control enable
    	rALMYEAR = TESTYEAR2 ;
    	rALMMON  = TESTMONTH2;
    	rALMDATE = TESTDATE2 ;
    	rALMHOUR = TESTHOUR2 ;
    	rALMMIN  = TESTMIN2  ;
    	rALMSEC  = TESTSEC2  ; 

		
		printf("Select alarm interrupt source  \n");
		printf("1:sec 2:min 3:hour 4:date 5:month 6:year\n");
		
		i = GetIntNum();
		rRTCALM  = (rRTCALM & ~(0x3f<<0))|(1<<(i-1)); //Global,Year,Month,Day,Hour,Minute,Second alarm enable
		printf( " rRTCALM = %08x\n", rRTCALM);
				
		printf("After 5 sec, alarm interrupt will occur.. \n");
		printf("alarm:%2x : %2x : %2x  %2x/%2x/20%02x\n",rALMHOUR,rALMMIN,rALMSEC,rALMMON,rALMDATE,rALMYEAR);
				
		RTC_Init();
		printf("curr:%2x : %2x : %2x  %2x/%2x/20%02x\n",rBCDHOUR,rBCDMIN,rBCDSEC,rBCDMON,rBCDDATE,rBCDYEAR);	
    	
    	Alarm = 0;
    	pISR_RTC = (unsigned int)Rtc_Alarm_ISR;
    	
    	rRTCALM  |= (1<<6);
    
       	rRTCCON  = 0x0;                     //No reset, Merge BCD counters, 1/32768, RTC Control disable
    	rINTMSK  = ~(BIT_RTC);

    	while(Alarm==0)
    	{
    		
    	};
    	printf("Alarmed:%2x : %2x : %2x  %10s,  %2x/%2x/20%02x\n",rBCDHOUR,rBCDMIN,rBCDSEC,day[rBCDDAY],rBCDMON,rBCDDATE,rBCDYEAR);
    	
    	rINTMSK = BIT_ALLMSK;
	    rRTCCON = 0x0;  //RTC  Control disable(for power consumption), 1/32768, Normal(merge), No reset}
	
}

void Tick_Count_Set(U32 count)
{
	rTICNT0 = count/256;
	rTICNT1 = count%256;
}

void Rtc_Alarm_Set()
{
   	rRTCCON  = rRTCCON  | 0x1;		//RTC Control enable

    	rALMHOUR =rBCDHOUR;
    	rALMMIN  =rBCDMIN;
    	rALMSEC  =rBCDSEC+5;

   	printf("After 5 second, Alarm Interrupt Occur\n");

  	//rRTCCON  = rRTCCON  & ~(0x1);	//RTC Control disable
}

void Print_RTC(void)
{
	int year,month,date,hour,min,sec,weekday;

   	rRTCCON  = rRTCCON  | 0x1;		//RTC Control enable
   		
    if(rBCDYEAR==0x99) 
       	year = 0x1999;
  	else 
       	year = 0x2000 + rBCDYEAR;
              	
	month   = rBCDMON;
	weekday = rBCDDAY;
	date    = rBCDDATE;
	hour    = rBCDHOUR;
	min     = rBCDMIN;
	sec     = rBCDSEC;

  	rRTCCON  = rRTCCON  & ~(0x1);	//RTC Control disable
	printf("%2x : %2x : %2x  %10s,  %2x/%2x/%4x\n",hour,min,sec,day[weekday],month,date,year);
}

void RTC_Init(void)
{

    rRTCCON  = rRTCCON  & ~(0xf)  | 0x1;            //No reset, Merge BCD counters, 1/32768, RTC Control enable
    
    rBCDYEAR = rBCDYEAR & ~(0xff) | TESTYEAR;
    rBCDMON  = rBCDMON  & ~(0x1f) | TESTMONTH;
    rBCDDATE = rBCDDATE & ~(0x3f) | TESTDATE;         
    rBCDDAY  = rBCDDAY  & ~(0x7)  | TESTDAY;       //SUN:1 MON:2 TUE:3 WED:4 THU:5 FRI:6 SAT:7
    rBCDHOUR = rBCDHOUR & ~(0x3f) | TESTHOUR;
    rBCDMIN  = rBCDMIN  & ~(0x7f) | TESTMIN;
    rBCDSEC  = rBCDSEC  & ~(0x7f) | TESTSEC;
    
    rRTCCON  = 0x0;             //No reset, Merge BCD counters, 1/32768, RTC Control disable    

}


void RTC_BATFLT(void)
{

	rRTCCON |= (1<<0); //must be set "1"
	printf(" when check the register set to 1 varying the VDDrtc voltage\n");
	printf(" change the VDDrtc value !!!\n");
	printf(" Once LOWBAT bit set, although the VDDrtc power off, this register keep the value\n");	
	printf(" \n");
	printf(" Setop down the VDDRTC volatage !!!!=rtcbat= %08x\n",rRTCLBAT);

	rRTCLBAT |= (1<<0);
	
	printf("rtc cleared = %08x\n",rRTCLBAT);
		
	while ( rRTCLBAT != 1 )
	{
		printf(">\b");
	}; 

	printf(" Check the VDDrtc voltage, and then adjust the RTC time value\n");

	rRTCLBAT |= (1<<0); // set "1" then cleared this bit.
	
	printf(" RTCBAT register = %08x\n",rRTCLBAT);

}


void __irq Rtc_Tick_ISR(void)
{
	rGPHDAT ^= (1<<13); // for test tick interval
	ClearPending(BIT_TICK);
	Tick=1;

	//printf(" RTC tick test OK\n");
}

void __irq Rtc_Alarm_ISR(void)
{
	ClearPending(BIT_RTC);
	Alarm=1;
	printf(" RTC alarm test OK\n");
}