syscon.c

三星2413芯片的测试代码,对进行驱动开发很有帮助.

//====================================================================
// File Name : syscon.c
// Function  : S3C2412 System Controller Test Code
// Date      : Apr. 21, 2006
// Version   : S3C2412
//====================================================================
 
#include "def.h"
#include "option.h"
#include "2413addr.h"
#include "Console.h"
#include "System.h" 

#include "syscon.h"
#include "power.h"
#include "clock.h"
#include "reset.h"

void __irq SlowEint0Int(void);


void Test_WDT(void);
volatile int slowExit;


void * func_syscon_test[][2]=
{	
	//                          			"0123456789012345678"
	(void *)Test_Power,						"Power Mode Test    ",
	(void *)Test_Clock,                     "Clock Test         ",
	(void *)Test_Reset,						"Reset Test         ",
	0,0
};

void Ch6_Syscon(void)
{
	int i;
	
	printf("\nSystem Controller Test.\n");

	// Battery fault setting.
	//rMISCCR = (rMISCCR & ~(0x7<<20)) | (1<<22) | (1<<21) | (0<<20);
		
	while(1)
	{
		i=0;
		printf("\n\n");
		while(1)
		{   //display menu
			printf("%2d:%s",i,func_syscon_test[i][1]);
			i++;
			if((int)(func_syscon_test[i][0])==0)
			{
				printf("\n");
				break;
			}
			if((i%3)==0)
			printf("\n");
		}

		printf("\nSelect (\"-1\" to exit) : ");
		i = GetIntNum();
		if(i==-1) break;		// return.
		if(i>=0 && (i<((sizeof(func_syscon_test)-1)/8)) )	// select and execute...
			( (void (*)(void)) (func_syscon_test[i][0]) )();
	}
	
	printf("\nThe end of Test on System Controller.\n");
}

void __irq Eint0Wakeup(void)
{
	rINTMSK |= BIT_EINT0;
	rEINTMASK |= BIT_EINT0;
	
	rEINTPEND |= BIT_EINT0;
	ClearPending(BIT_EINT0);
	//printf("\n &&E0&& \n");
	printf("[WU]EINT0 is occurred!\n");
	
	rEINTMASK &= ~BIT_EINT0;
	rINTMSK &= ~BIT_EINT0;
}

void __irq Eint1Wakeup(void)
{
	rINTMSK |= BIT_EINT1;
	rEINTMASK |= BIT_EINT1;
	
	rEINTPEND |= BIT_EINT1;
	ClearPending(BIT_EINT1);
	//printf("\n &&E1&& \n");
	printf("[WU]EINT1 is occurred!\n");
	
	rEINTMASK &= ~BIT_EINT1;
	rINTMSK &= ~BIT_EINT1;
}

void __irq Eint2Wakeup(void)
{
	rINTMSK |= BIT_EINT2;
	rEINTMASK |= BIT_EINT2;
	
	rEINTPEND |= BIT_EINT2;
	ClearPending(BIT_EINT2);
	//printf("\n &&E2&& \n");
	printf("[WU]EINT1 is occurred!\n");
	
	rEINTMASK &= ~BIT_EINT2;
	rINTMSK &= ~BIT_EINT2;
}

void __irq Eint3Wakeup(void)
{
	rINTMSK |= BIT_EINT3;
	rEINTMASK |= BIT_EINT3;
	
	rEINTPEND |= BIT_EINT3;
	ClearPending(BIT_EINT3);
	//printf("\n &&E3&& \n");
	printf("[WU]EINT1 is occurred!\n");
	
	rEINTMASK &= ~BIT_EINT3;
	rINTMSK &= ~BIT_EINT3;
}

void __irq Eint4_7Wakeup(void)
{
	volatile U32 eintpend;
	
	rINTMSK |= BIT_EINT4_7;
	rEINTMASK |= (0xf<<4);
	
	eintpend = rEINTPEND;	
	rEINTPEND = rEINTPEND;
	ClearPending(BIT_EINT4_7);
	switch((eintpend&0xf))
	{
		case 1:
			printf("[WU]EINT4 is occurred!\n");
			break;
		case 2:
			printf("[WU]EINT5 is occurred!\n");
			break;
		case 4:
			printf("[WU]EINT6 is occurred!\n");
			break;						
		case 8:
			printf("[WU]EINT7 is occurred!\n");
			break;
		default:
			printf("[EINT4-7] Wrong EINT!\n");
			break;
	}	
	
	rEINTMASK &= ~(eintpend);
	rINTMSK &= ~BIT_EINT4_7;
}

void __irq Eint8_23Wakeup(void)
{
	volatile U32 eintpend;
	
	rINTMSK |= BIT_EINT8_23;
	rEINTMASK |= (0xffff<<8);
	
	eintpend = rEINTPEND;	
	rEINTPEND = rEINTPEND;
	ClearPending(BIT_EINT8_23);
	switch((eintpend&0xffff00)>>8)
	{
		case 0x1:
			printf("[WU]EINT8 is occurred!\n");
			break;
		case 0x2:
			printf("[WU]EINT9 is occurred!\n");
			break;
		case 0x4:
			printf("[WU]EINT10 is occurred!\n");
			break;						
		case 0x8:
			printf("[WU]EINT11 is occurred!\n");
			break;
		case 0x10:
			printf("[WU]EINT12 is occurred!\n");
			break;
		case 0x20:
			printf("[WU]EINT13 is occurred!\n");
			break;
		case 0x40:
			printf("[WU]EINT14 is occurred!\n");
			break;						
		case 0x80:
			printf("[WU]EINT15 is occurred!\n");
			break;
		case 0x100:
			printf("[WU]EINT16 is occurred!\n");
			break;
		case 0x200:
			printf("[WU]EINT17 is occurred!\n");
			break;
		case 0x400:
			printf("[WU]EINT18 is occurred!\n");
			break;						
		case 0x800:
			printf("[WU]EINT19 is occurred!\n");
			break;
		case 0x1000:
			printf("[WU]EINT20 is occurred!\n");
			break;
		case 0x2000:
			printf("[WU]EINT21 is occurred!\n");
			break;
		case 0x4000:
			printf("[WU]EINT22 is occurred!\n");
			break;						
		case 0x8000:
			printf("[WU]EINT23 is occurred!\n");
			break;												
		default:
			printf("[EINT8-23] Wrong EINT!\n");
			break;
	}	
	
	rEINTMASK &= ~(eintpend);
	rINTMSK &= ~BIT_EINT8_23;
}


void __irq AlarmWakeup(void)
{
	rINTMSK |= BIT_RTC;
	ClearPending(BIT_RTC);
	//printf("\n **RTC** \n");
	printf("[WU]RTC ALARM is occurred!\n");
	rINTMSK &= ~BIT_RTC;
}

void __irq TickWakeup(void)
{
	rINTMSK |= BIT_TICK;
	ClearPending(BIT_TICK);
	printf("[WU]RTC TICK is occurred!\n");
	rINTMSK &= ~BIT_TICK;
}

void __irq BatteryFaultEvent(void)
{
	rINTMSK |= BIT_BAT_FLT;
	ClearPending(BIT_BAT_FLT);
	printf("[WU]Battery Fault is occurred!\n");
	rINTMSK &= ~BIT_BAT_FLT;
}

void SetAlarmWakeup(void)
{

	pISR_RTC = (U32)AlarmWakeup;
	
	rRTCCON = 0x1;	// R/W enable, 1/32768, Normal(merge), No reset

	rBCDYEAR = TESTYEAR;
	rBCDMON  = TESTMONTH;
	rBCDDAY  = TESTDAY;	// SUN:1 MON:2 TUE:3 WED:4 THU:5 FRI:6 SAT:7
	rBCDDATE = TESTDATE;
	rBCDHOUR = TESTHOUR;
	rBCDMIN  = TESTMIN;
	rBCDSEC  = TESTSEC;
	
	rALMYEAR=TESTYEAR2 ;
	rALMMON =TESTMONTH2;
	rALMDATE=TESTDATE2  ;
	rALMHOUR=TESTHOUR2 ;
	rALMMIN =TESTMIN2  ;
	rALMSEC =TESTSEC2+0x5;

	rRTCALM=0x7f;

	rRTCCON=0x0;   // R/W disable, 1/32768, Normal(merge), No reset
	
	rINTMSK &= ~BIT_RTC;
	printf("RTC Alarm is set for wake-up source\n");
}


void SetTimeTickWakeup(U32 TICsel, U32 TCnt)
{
	pISR_TICK = (U32)TickWakeup;
	
	rRTCCON = (rRTCCON&~(1<<4))|(TICsel<<4) ;
	rTICNT0 = (TCnt)/256;
	rTICNT1 = (TCnt)%256;
	
	rINTMSK &= ~BIT_TICK;
	
	rTICNT0 |= (1<<7);
	
	printf("RTC Tick is set for wake-up source\n");
}


void SetEintWakeup(U32 EintNumber, U32 SignalMethod, U32 Filter )
{	

	if(EintNumber < 8)
	{
		rGPFCON = (rGPFCON & ~(0x3<<(EintNumber*2)))|(0x2<<(EintNumber*2));
		rEXTINT0 = (rEXTINT0 & ~(0xf<<EintNumber*4))|
		           (Filter<<(EintNumber*4+3)|SignalMethod<<(EintNumber*4));		
	}
	else if(EintNumber < 16)
	{
		rGPGCON = (rGPGCON & ~(0x3<<((EintNumber-8)*2)))|(0x2<<((EintNumber-8)*2));
		rEXTINT1 = (rEXTINT1 & ~(0xf<<(EintNumber-8)*4))|
		           (Filter<<((EintNumber-8)*4+3)|SignalMethod<<((EintNumber-8)*4));		
	}
	else
	{
		printf("error: Wrong Wake-up Source !\n");
		return;
	}
	
	switch(EintNumber)
	{
		case 0:
			pISR_EINT0 = (U32)Eint0Wakeup;
			rEINTMASK &= ~(1<<EintNumber);
			rINTMSK &= ~(BIT_EINT0);
			break;
		case 1:
			pISR_EINT1 = (U32)Eint1Wakeup;
			rEINTMASK &= ~(1<<EintNumber);
			rINTMSK &= ~(BIT_EINT1);
			break;
		case 2:
			pISR_EINT2 = (U32)Eint2Wakeup;
			rEINTMASK &= ~(1<<EintNumber);
			rINTMSK &= ~(BIT_EINT2);
			break;
		case 3:
			pISR_EINT3 = (U32)Eint3Wakeup;
			rEINTMASK &= ~(1<<EintNumber);
			rINTMSK &= ~(BIT_EINT3);
			break;
		default:
			if(EintNumber < 8)
			{
				pISR_EINT4_7 = (U32)Eint4_7Wakeup;
				rEINTMASK &= ~(1<<EintNumber);
				rINTMSK &= ~(BIT_EINT4_7);
			}				
			else if(EintNumber < 16)
			{
				pISR_EINT8_23 = (U32)Eint8_23Wakeup;
				rEINTMASK &= ~(1<<EintNumber);
				rINTMSK &= ~(BIT_EINT8_23);
			}				
			else
			{
				printf("error: Wrong Wake-up Source!\n");
				return;
			}
			break;
	}
	printf("EINT%d is set for wake-up source\n", EintNumber);
}

void SetBatteryFaultEvent(U32 BatConfig)
{
	rPWRCFG = (rPWRCFG & ~(0x3))|(BatConfig);
	if(BatConfig==BATINT)
	{
		pISR_BAT_FLT = (U32)BatteryFaultEvent;
		rINTMSK &= ~(BIT_BAT_FLT);
	}
	if(BatConfig==BATESLEEP)
	{
		printf("Inform register is set!\n");
		rINFORM0 = 0x2BED2BED;
	}
}