idle.c

s3c24a0固件测试代码 ? ? ? ? ?啊

/*****************************************
 NAME: IDLE.C
 DESC: IDLE(MMU) mode test code
 HISTORY:
 Jan.30.2004 : ver 0.0
******************************************/
#include "def.h"
#include "option.h"
#include "24a0addr.h"
#include "24a0lib.h"
#include "24a0slib.h" 
#include "stop.h"
#include "idle.h"

#define TESTYEAR 	(0x03)
#define TESTMONTH 	(0x12)
#define TESTDATE	(0x31)
#define TESTDAY		(0x06)  // SUN:1 MON:2 TUE:3 WED:4 THU:5 FRI:6 SAT:7   
#define TESTHOUR	(0x23)
#define TESTMIN		(0x59)
#define TESTSEC		(0x59)

#define TESTYEAR2	(0x04)
#define TESTMONTH2 	(0x01)
#define TESTDATE2	(0x01)
#define TESTDAY2	(0x07)  // SUN:1 MON:2 TUE:3 WED:4 THU:5 FRI:6 SAT:7   
#define TESTHOUR2	(0x00)
#define TESTMIN2	(0x00)
#define TESTSEC2	(0x00)

#define USE_RTC_ALARM	    (TRUE)
#define CHOOSE_EINT0_TYPE   (FALSE)//(TRUE)

#define EINT9COUNT 10

static volatile int m_cnt, m_flag;

static void __irq EintInt(void)//EINT0,1
{
//    rEINTMASK |= ( (BIT_EINTPEND_EINT1)|(BIT_EINTPEND_EINT0) );
//    rINTMSK |= (BIT_EINT0_2);

    if(rEINTPEND&(1<<0))    //if EINT0
    {
	rEINTPEND=BIT_EINTPEND_EINT0;
	Uart_Printf("EINT0 for IDLE wake-up.\n");
    }
    else if(rEINTPEND&(1<<1))//if EINT1
    {
	rEINTPEND=BIT_EINTPEND_EINT1;
	Uart_Printf("EINT1 for IDLE wake-up.\n");
    }
    else 
	Uart_Printf("EINT Error!!\n");

    ClearPending(BIT_EINT0_2);
}

static void __irq Eint9Int(void)//EINT9
{
//    rEINTMASK |=(BIT_EINTPEND_EINT9);
//    rINTMSK |= (BIT_EINT7_10);

    rEINTPEND=BIT_EINTPEND_EINT9;
    ClearPending(BIT_EINT7_10);
    Uart_Printf("EINT9 for IDLE wake-up.\n");
}

static void __irq AlarmInt(void)
{
//    rINTMSK=rINTMSK|(BIT_RTC);
    ClearPending(BIT_RTC);
    Uart_Printf("ALARM interrupt for IDLE wake-up.\n");
}

static void __irq ModemInt(void)
{
//    rINTMSK=rINTMSK|(BIT_MODEM);
    ClearPending(BIT_MODEM);
    Uart_Printf("Modem interrupt for IDLE wake-up.\n");
}

static void __irq Eint9IntHard(void)
{
    rEINTPEND=BIT_EINTPEND_EINT9;
    ClearPending(BIT_EINT7_10);

    if(m_cnt<EINT9COUNT)
    {
	m_cnt++;
	//if(m_cnt%10==0)Uart_Printf("#");
	Uart_Printf("%d ",m_cnt);
    }
    else
    {
       	m_flag=0;
	Uart_Printf("\nEINT9 final Count=%d\n",m_cnt);
    }
}

static void __irq PenDownInt(void)
{
//    rINTSUBMSK |= BIT_SUB_PENDN;
//    rINTMSK |= BIT_ADC_PENUP_DOWN;

    rSUBSRCPND=BIT_SUB_PENDN;
    ClearPending(BIT_ADC_PENUP_DOWN);
    Uart_Printf("Touch screen pen-down interrupt for IDLE wake-up.\n");
}

void SetAlarmWakeUp(int sec)
{
    rRTCCON = 0x1;		// R/W enable, 1/32768, Normal(merge), No reset
    rBCDYEAR = TESTYEAR; 	// '00
    rBCDMON  = TESTMONTH; 	// December
    rBCDDAY  = TESTDAY;		// SUN:1 MON:2 TUE:3 WED:4 THU:5 FRI:6 SAT:7
    rBCDDATE = TESTDATE; 	// 31th
    rBCDHOUR = TESTHOUR; 	// 23 hours
    rBCDMIN  = TESTMIN; 	// 59 minutes
    rBCDSEC  = TESTSEC; 	// 59 seconds
    
    rALMYEAR=TESTYEAR2 ; 	// '01.01.01.Saturday 00:00:09
    rALMMON =TESTMONTH2;
    rALMDATE=TESTDATE2;
    rALMHOUR=TESTHOUR2;
    rALMMIN =(TESTMIN2+0);
    rALMSEC =(TESTSEC2+sec);

    rRTCALM=0x7f;
    rRTCCON=0x0;   // R/W disable, 1/32768, Normal(merge), No reset
}

void SetTouchWakeUp(void)
{
    rADCTSC=0xd0; //Pull up Enable
    Delay(1);
    rADCTSC=0xd3; //Waiting for interrupt mode
    //rADCDLY=0x0;
}


void SetModemWakeUp(void)
{
    rINT2AP=0x3ff; //AP side INT ready
}


void SelectEintType(void)
{
    int extintMode;
    Uart_Printf("1.L-level  2.H-level  3.F-edge  4.R-edge  5.B-edge\n");
    Uart_Printf("Select the EINT0 trigger type:");    
    extintMode=Uart_Getch();

    switch(extintMode)
    {
	case '1':
	    rEXTINTC0=( rEXTINTC0 & ~(7<<0) ) | (0<<0); //EINT0=low level triggered
    	    Uart_Printf("L-level\n");
    	    break;
	case '2':
    	    rEXTINTC0=( rEXTINTC0 & ~(7<<0) ) | (1<<0); //EINT0=high level triggered
    	    Uart_Printf("H-level\n");
    	    break;
	case '3':
    	    rEXTINTC0=( rEXTINTC0 & ~(7<<0) ) | (2<<0);  //EINT0=falling edge triggered
    	    Uart_Printf("F-edge\n");
    	    break;
	case '4':
    	    rEXTINTC0=( rEXTINTC0 & ~(7<<0) ) | (4<<0); //EINT0=rising edge triggered
    	    Uart_Printf("R-edge\n");
     	    break;
	case '5':
    	    rEXTINTC0=( rEXTINTC0 & ~(7<<0) ) | (6<<0); //EINT0=both edge triggered
    	    Uart_Printf("B-edge\n");
    	    break;
	default:
    	    break;
    }
}



/**********************
 *   IDLE mode test   *
 **********************/

void Test_IdleMode(void)
{
    int i;

    Uart_Printf("[IDLE Mode Test]\n");
    Uart_Printf("Check the current cunsumption.\n");

#if USE_RTC_ALARM
    Uart_Printf("After 10 seconds, S3C24A0X will wake up by RTC alarm interrupt.\n");
#endif

    Uart_Printf("S3C24A0X will wake up by EINT0, 1, 9, 11, Stylus down or Modem int.\n");

    //PWR_Lcd_Tft_16Bit_240320_On();
    //PWR_StartIIS();
    //PWR_StartTimer();

    rGPCON_L = ( rGPCON_L & ~((3<<18)|(3<<2)|3) ) | (2<<18)|(2<<2)|2; //GP0,1,9=EINT0,1,9
    rGPCON_M = ( rGPCON_M & ~(0x3) ) | 0x2; //GP11=EINT11

#if CHOOSE_EINT0_TYPE	   
    SelectEintType();
#else
    rEXTINTC0=( rEXTINTC0 & ~(7<<0) ) | (2<<0);	//EINT0= falling edge triggered
#endif

    rEXTINTC0=( rEXTINTC0 & ~(7<<4) ) | (0<<4);	//EINT1= low level triggered
    rEXTINTC1=( rEXTINTC1 & ~(7<<24) )| (2<<24);//EINT9= falling edge triggered
    rEXTINTC2=( rEXTINTC2 & ~(7<<0) ) | (2<<0);	//EINT11=falling edge triggered

    SetTouchWakeUp();

#if USE_RTC_ALARM
    SetAlarmWakeUp(10);
#endif

    SetModemWakeUp();
    
    rINTMSK=BIT_ALLMSK;
    rINTSUBMSK=BIT_SUB_ALLMSK;
    rEINTMASK=BIT_EINTPEND_ALLMSK;

    pISR_EINT0_2=(U32)EintInt;
    pISR_EINT7_10=(U32)Eint9Int;
    pISR_EINT11_14=(U32)EintInt;
    pISR_RTC=(U32)AlarmInt;
    pISR_MODEM=(U32)ModemInt;
    pISR_ADC_PENUP_DOWN=(U32)PenDownInt;

    //Clear sub interrupt pending
    rEINTPEND=BIT_EINTPEND_EINT0;
    rEINTPEND=BIT_EINTPEND_EINT1;
    rEINTPEND=BIT_EINTPEND_EINT9;
    rEINTPEND=BIT_EINTPEND_EINT11;
    rSUBSRCPND=(BIT_SUB_PENDN|BIT_SUB_PENUP);
    //Clear interrupt pending
    ClearPending(BIT_EINT0_2);
    ClearPending(BIT_EINT7_10);
    ClearPending(BIT_EINT11_14);
    ClearPending(BIT_RTC);
    ClearPending(BIT_MODEM);
    ClearPending(BIT_ADC_PENUP_DOWN);
 
    //Uart_Printf("rINTMSK=0x%x, rINTSUBMSK=0x%x, rEINTMASK=0x%x\n",rINTMSK, rINTSUBMSK, rEINTMASK);
    //rPWRMAN=rPWRMAN&~(1<<8)|(1<<8); //Mask touch screen wakeup
    
    //Unmask interrupt
    rINTMSK=rINTMSK&~(BIT_EINT0_2);
    rINTMSK=rINTMSK&~(BIT_EINT7_10);
    rINTMSK=rINTMSK&~(BIT_EINT11_14);
    rINTMSK=rINTMSK&~(BIT_RTC);
    rINTMSK=rINTMSK&~(BIT_MODEM);
    rINTMSK=rINTMSK&~(BIT_ADC_PENUP_DOWN);
    //Unmask sub interrupt 
    rEINTMASK=rEINTMASK&~(BIT_EINTPEND_EINT0);
    rEINTMASK=rEINTMASK&~(BIT_EINTPEND_EINT1);
    rEINTMASK=rEINTMASK&~(BIT_EINTPEND_EINT9);
    rEINTMASK=rEINTMASK&~(BIT_EINTPEND_EINT11);
    rINTSUBMSK=rINTSUBMSK&~(BIT_SUB_PENDN);

    Uart_Printf("\nEntering IDLE mode......\n\n");
    Uart_TxEmpty(0);

    rCLKCON=( rCLKCON & ~(1<<2) ) | (1<<2);  //enter IDLE mode.
    for(i=0;i<10;i++);   
    //wait until S3C24A0X enters IDLE mode.	
    //wait EINT, RTC alarm, Touch screen pen-down or Modem interrupt

    rCLKCON &= ~(1<<2); 
    rINTMSK=BIT_ALLMSK;
    //turn-off IDLE bit. IDLE bit should be turned off after wake-up.
    Uart_Printf("Return to Normal Mode.\n");
}


void Test_IdleModeHard(void)
{
    int i;

    Uart_Printf("[IDLE Mode Hard Test with Function Genenrator]\n");
    Uart_Printf("S3C24A0X will wake up by EINT9 at its falling edge.\n");
    Uart_TxEmpty(0);    //Wait until UART0 Tx buffer empty.

    m_cnt=0;
    m_flag=1;
    rGPCON_L=( rGPCON_L & ~(3<<18) ) | (2<<18); //GP9=EINT9
    rEXTINTC1=( rEXTINTC1 & ~(7<<24) ) | (2<<24); //EINT9=falling edge triggered
   
    pISR_EINT7_10=(U32)Eint9IntHard;
   
    rEINTPEND=BIT_EINTPEND_EINT9;
    ClearPending(BIT_EINT7_10);

    rINTMSK=rINTMSK&~(BIT_EINT7_10);
    rEINTMASK=rEINTMASK&~(BIT_EINTPEND_EINT9);
    
    while(m_flag)
    {
    	rCLKCON |= (1<<2);  //enter IDLE mode.
	//wait until S3C24A0X enters IDLE mode.	
	//wait EINT10 interrupt
	for(i=0;i<10;i++);   
	rCLKCON &= ~(1<<2);  //turn-off IDLE bit. IDLE bit should be turned off after wake-up.
    }

    Uart_Printf("Return to Normal Mode.\n");
}

/*********************
 * MMU IDLE mode test *
 *********************/

void Test_MMUIdleMode(void)
{
    int i;

    Uart_Printf("[MMU IDLE Mode Test]\n");
    Uart_Printf("This routine tests MMU registser7:Wait for interrupt function.\n");
    Uart_Printf("\nCheck the current cunsumption.\n");
#if USE_RTC_ALARM
    Uart_Printf("After 10 seconds, S3C24A0X will wake up by RTC alarm interrupt.\n");
#endif
    Uart_Printf("S3C24A0X will also wake up by EINT0.\n");
    Uart_TxEmpty(0);    //Wait until UART0 Tx buffer empty.

    rGPCON_L=( rGPCON_L & ~(3) ) | (2<<0); //GP0=EINT0
    rEXTINTC0=( rEXTINTC0 & ~(7<<0) ) | (2<<0); //EINT0=falling edge triggered

    pISR_EINT0_2=(U32)EintInt;
#if USE_RTC_ALARM
    pISR_RTC=(U32)AlarmInt;
#endif
    //Clear sub interrupt pending
    rEINTPEND=BIT_EINTPEND_EINT0;
    //Clear interrupt pending
    ClearPending(BIT_EINT0_2|BIT_RTC);

#if USE_RTC_ALARM
    SetAlarmWakeUp(10);
    //rRTCCON = 0x0;	// R/W disable, but interrupt will be generated.
#endif

    //Unmask interrupt
    rINTMSK=rINTMSK&~(BIT_EINT0_2|BIT_RTC);
    //Unmask sub interrupt 
    rEINTMASK=rEINTMASK&~(BIT_EINTPEND_EINT0);

    MMU_WaitForInterrupt();
     
    //wait until processor enters Low-power state.	
    //wait EINT0 interrupt or RTC alarm interrupt
    for(i=0;i<10;i++);   

    Uart_Printf("Return to Normal Mode.\n");
}