timer.c

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

//=============================================================================
// File Name : Timer.c
// Function  : S3C2413 Watch-Dog and Timer
// Program   : Cha, gyu hwan
// Date      : November 11, 2005
// Version   : 0.0
// History
//   0.0 : Programming start (November 11,2005) 
//=============================================================================

#include <stdio.h>
#include <string.h>

#include "option.h"
#include "2413addr.h"
#include "system.h"
#include "timer.h"
#include "def.h"
#include "PLL.h"
#include "console.h"

#define FIQ_TEST 0		//if '1' then FIQ test mode
#define PRIORITY_TEST 0     //if '1' then PRIORITY test mode
#define DEADZONE_TEST 0


#define SLOPE 10

typedef struct tagDMA
{
	volatile U32 DISRC;	    //0x0
	volatile U32 DISRCC;    //0x4
	volatile U32 DIDST;	    //0x8
	volatile U32 DIDSTC;    //0xc
	volatile U32 DCON;	    //0x10
	volatile U32 DSTAT;	    //0x14
	volatile U32 DCSRC;	    //0x18
	volatile U32 DCDST;	    //0x1c
	volatile U32 DMASKTRIG; //0x20
	volatile U32 DMAREQSEL; //0x24
}DMA;

static volatile int dmaDone; 

volatile int variable0, variable1, variable2, variable3, variable4;
int isr_print;
unsigned char prescalerVal[2];
unsigned char deadZoneLength;
unsigned char mux[5];
unsigned char DMAmode;
unsigned short counterBuf[5],compareBuf[5];

//=========================================================================


//=========================================================================


void * timer_func[][2]=
{
	(void *)Test_Timer_User_setting,				"Test_Timer_User_setting         ",
	(void *)Test_TimerInt,          	        "Timer Interrupt        ",
	(void *)Test_Timer,                    		"Timer Tout             ",
	(void *)Test_TimerDma,  	                "Timer DMA              ",
	0,0
};

#define ACTIVATION_PRESCALER_SETTING rTCFG0 = (deadZoneLength<<16) | (prescalerVal[1]<<8) | (prescalerVal[0]);
#define ACTIVATION_MUX_SETTING rTCFG1 = ((DMAmode&0x07)<<20) | ((mux[4]&0x07)<<16) | ((mux[3]&0x07)<<12) \
			| ((mux[2]&0x07)<<8) | ((mux[1]&0x07)<<4) | (mux[0]&0x07);

#define ACTIVATION_COUNTER_BUF rTCNTB0 = counterBuf[0]; \
	rTCNTB1 = counterBuf[1]; \
	rTCNTB2 = counterBuf[2]; \
	rTCNTB3 = counterBuf[3]; \
	rTCNTB4 = counterBuf[4]; \
	rTCON = rTCON | (1<<1) | (1<<9) | (1<<13) | (1<<17) | (1<<21);

#define ACTIVATION_COMPARE_BUF rTCMPB0 = compareBuf[0]; \
	rTCMPB1 = compareBuf[1]; \
	rTCMPB2 = compareBuf[2]; \
	rTCMPB3 = compareBuf[3]; \
	rTCON = (1<<22) | (1<<20) | (1<<19) | (1<<16) | (1<<15) | (1<<12) | (1<<11) | (1<<8) | (1<<3) | 1;//0x599909;

void initTimerVal(void) {
	// dead zone = 1 , prescaler1 = 0, prescaler0 = 0
	prescalerVal[1] = 0;
	prescalerVal[0] = 0;
	deadZoneLength = 1;
	ACTIVATION_PRESCALER_SETTING

	// DMA no selection, 1/2
	mux[0] = mux[1] = mux[2] = mux[3] = mux[4] = 0;	// 1/2 input
	DMAmode = 0;	// noselect
	ACTIVATION_MUX_SETTING

	counterBuf[0] = counterBuf[1] = counterBuf[2] = counterBuf[3] = counterBuf[4] = 0;
	ACTIVATION_COUNTER_BUF
		
	compareBuf[0] = compareBuf[1] = compareBuf[2] = compareBuf[3] = compareBuf[4] = 0;
	ACTIVATION_COMPARE_BUF
}

void isr_function_setting(void){
	pISR_TIMER0 = (unsigned)Timer0Done;
	pISR_TIMER1 = (unsigned)Timer1Done;
	pISR_TIMER2 = (unsigned)Timer2Done;
	pISR_TIMER3 = (unsigned)Timer3Done;
	pISR_TIMER4 = (unsigned)Timer4Done;

	variable0=0;
	variable1=0;
	variable2=0;
	variable3=0;
	variable4=0;
	isr_print = FALSE;
}

void startAutoReload(void) {
	rTCON = rTCON | (1<<22) | (1<<19) | (1<<15) | (1<<11) | (1<<3);
}

void stopAutoReload(void) {
	rTCON = (1<<22) | (1<<19) | (1<<15) | (1<<11) | (1<<3);				// auto reload
	rTCON = rTCON | (1<<21) | (1<<17) | (1<<13) | (1<<9) | (1<<1);		// update
	rTCON = rTCON & ~((1<<22) | (1<<19) | (1<<15) | (1<<11) | (1<<3));	// one-shot mode
	rTCON = (1<<20) | (1<<16) | (1<<12) |(1<<8) | 1 ;					// start
//			| 
//	rTCON   = rTCON & ~(0xffffff) | 0x6aaa0a;         
	//Auto reload, Inverter off, Manual update, Dead zone disable, Stop  
//	rTCON   = rTCON & ~(0xffffff) | 0x1 |(0x1)<<8| (0x1)<<12 | (0x1)<<16 | (0x1)<<20 ; 
	//T0,1,2,3,4= One-shot,Inverter off,No operation,Dead zone disable,Start
}

void startTimer(void) {
	rTCON = rTCON | (1<<20) | (1<<16) | (1<<12) | ( 1<<8) | (1);
}

void stopTimer(void) {
	rTCON = rTCON & ~((1<<20) | (1<<16) | (1<<12) | ( 1<<8) | (1));
}

void startInverter() {
	rTCON = rTCON | (1<<18) | (1<<14) | (1<<10);
}

void stopInverter() {
	rTCON = rTCON & ~((1<<18) | (1<<14) | (1<<10));
}

void setPrescaler(int port, int value) {
	if ( port < 0 || port > 1 )
		return;

	if ( prescalerVal[port] + value < 0 )
		prescalerVal[port] = 0;
	else if ( prescalerVal[port] + value > 255 )
		prescalerVal[port] = 255;
	else
		prescalerVal[port] = prescalerVal[port] + value;
	
	ACTIVATION_PRESCALER_SETTING
}

void setDeadZone(int value) {
	if ( deadZoneLength + value < 0 )
		deadZoneLength = 0;
	else if (deadZoneLength + value > 255 )
		deadZoneLength = 255;
	else
		deadZoneLength = deadZoneLength + value;
	
	ACTIVATION_PRESCALER_SETTING
}

void setMux( int muxNumber) {
	if ( muxNumber < 0 || muxNumber > 4 )
		return;

	mux[muxNumber] = ((mux[muxNumber] + 1) & 0x07);
	ACTIVATION_MUX_SETTING
}

void setCounterBuf( int port, int value ) {
	if ( port < 0 || port > 4 )
		return;

	if ( counterBuf[port] + value < 0 ) {
		counterBuf[port] = 0;
	}
	else if ( counterBuf[port] + value > 0xffff ) {
		counterBuf[port] = 0xffff;
	}
	else {
		counterBuf[port] = counterBuf[port] + value;
	}
	ACTIVATION_COUNTER_BUF
	ACTIVATION_COMPARE_BUF
}

void setCompareBuf( int port, int value ) {
	if ( port < 0 || port > 3 )
		return;

	if ( compareBuf[port] + value < 0 ) {
		compareBuf[port] = 0;
	}
	else if ( compareBuf[port] + value > counterBuf[port] ) {
		compareBuf[port] = counterBuf[port];
	}
	else {
		compareBuf[port] = compareBuf[port] + value;
	}
	ACTIVATION_COUNTER_BUF
	ACTIVATION_COMPARE_BUF
//	rTCON   = rTCON & ~(0xffffff) | 0x599909;
}

void printClockRate( void ) {
	int timer0, timer1, timer2, timer3, timer4;
	int muxData[8] = { 2, 4, 8, 16, 1, 1, 1, 1}; 
	timer0 = PCLK / (prescalerVal[0]+1) / muxData[mux[0]];
	timer1 = PCLK / (prescalerVal[0]+1) / muxData[mux[1]];
	timer2 = PCLK / (prescalerVal[1]+1) / muxData[mux[2]];
	timer3 = PCLK / (prescalerVal[1]+1) / muxData[mux[3]];
	timer4 = PCLK / (prescalerVal[1]+1) / muxData[mux[4]];
	printf ( "clock Rate : %d,%d,%d,%d,%d\n" , timer0, timer1, timer2, timer3, timer4 );
	printf ( "clock duration (us): %3.3f,%3.3f,%3.3f,%3.3f,%3.3f\n", (float)1000000*(counterBuf[0]+1)/timer0,
		(float)1000000*(counterBuf[1]+1)/timer1, (float)1000000*(counterBuf[2]+1)/timer2,
		(float)1000000*(counterBuf[3]+1)/timer3, (float)1000000*(counterBuf[4]+1)/timer4 );
	printf ( "high duration (us): %3.3f,%3.3f,%3.3f,%3.3f,%3.3f\n", (float)1000000*(compareBuf[0]+1)/timer0,
		(float)1000000*(compareBuf[1]+1)/timer1, (float)1000000*(compareBuf[2]+1)/timer2,
		(float)1000000*(compareBuf[3]+1)/timer3, (float)1000000*(compareBuf[4]+1)/timer4 );
}

void printMessage( void ) {
	printf ( "-------------------------------------------------------------\n" );
	printf ( "1: Start, 2: Stop\n" );
	printf ( "A: Dead Zone UP, Z: Dead Zone Down\n" );
	printf ( "S: Prescaler0 UP, X: Prescaler0 Down\n" );
	printf ( "D: Prescaler0 UP, C: Prescaler0 Down\n" );
	printf ( "F: Auto Reload Mode, V: One-Shot\n");
	printf ( "3: Mux0 Change, 4: Mux1 Change, 5: Mux2 Change, 6: Mux3 Change, 7: Mux4 Change\n" );
	printf ( "I: Inverter On, O: Inverter Off\n" );
	printf ( "GHJKL : UP counter, ghjkl : down counter \n");
	printf ( "BNM< : UP Compare, bnm, : Down compare \n");
	printf ( "P: Dead Zone Enable, p:Dead Zone Disable\n" );
	printf ( "[ : print Message, ] message off ,         / <- Timer4 ISR Start \n");
	printf ( "Q: exit\n" );
	printf ( "-----------------------value---------------------------------\n" );
	printClockRate();
	printf ( "dead Zone : %d[%x]\n", deadZoneLength, deadZoneLength);
	printf ( "prescaler0 : %d[%x], prescaler1 : %d[%x]\n" , prescalerVal[0], prescalerVal[0], prescalerVal[1], prescalerVal[1] );
	printf ( "Mux0:%x, Mux1:%x,Mux2:%x,Mux3:%x,Mux4:%x\n", mux[0],mux[1],mux[2],mux[3],mux[4] );
	printf ( "counterBuf: %d, %d, %d, %d, %d \n", counterBuf[0], counterBuf[1], counterBuf[2], counterBuf[3], counterBuf[4] );
	printf ( "compareBuf: %d, %d, %d, %d\n", compareBuf[0], compareBuf[1], compareBuf[2], compareBuf[3] );
}

void Ch9_PwmTimer(void)
{
	int i;
	
	printf("Menu of Timer function\n");
	// Wait until memory stick is inserted.
	
	while(1) {
		TimerSubMessage();
		printf("\nSelect(-1 to exit): ");
		i = GetIntNum();
		//printf("IN:%d.\n\n", i);
		if(i==-1) break;
		
		if(i>=0 && (i<(sizeof(timer_func)/3)) ) 
	    		( (void (*)(void)) (timer_func[i][0]) )();	// execute selected function.
	}
}


void Test_Timer_User_setting(void) {
	char key;
	char end_function = 0;
	unsigned int rGPBCON_back;
	
	initTimerVal();
	isr_function_setting();
	rGPBCON_back= rGPBCON;

	rGPBCON=0x2aa;
	rGPGCON=rGPGCON|(3<<22);

	rGPEDN  = 0x1000;                  //Pull-up disable
	rGPECON = 0x01000000;              //GPE12
	
	while ( 1 ) {
		printMessage();
		key = Uart_getc();
		switch ( key ) {
			case '1':		// start Timer;
				startTimer();
				break;
			case '2':		// Stop Timer;
				stopTimer();
				break;
			case 'A':		// Dead Zone up
			case 'a':
				setDeadZone(SLOPE);
				break;
			case 'Z':		// Dead Zone Down
			case 'z':
				setDeadZone(-SLOPE);
				break;
			case 'S':		// Prescaler 0 Up
			case 's':
				setPrescaler(0,SLOPE);
				break;
			case 'X':		// Prescaler 0 Down
			case 'x':
				setPrescaler(0,-SLOPE);
				break;
			case 'D':		// Prescaler 1 Up
			case 'd':
				setPrescaler(1,SLOPE);
				break;
			case 'C':		// prescaler 1 Down
			case 'c':
				setPrescaler(1,-SLOPE);
				break;
			case '3':		// Mux0 Change
				setMux(0);
				break;
			case '4':		// Mux1 Change
				setMux(1);
				break;
			case '5':		// Mux2 Change
				setMux(2);
				break;
			case '6':		// Mux3 Change
				setMux(3);
				break;
			case '7':		// Mux4 Change
				setMux(4);
				break;
			case 'I':		// Inverter On
			case 'i':
				startInverter();
				break;
			case 'O':		// Inverter Off
			case 'o':
				stopInverter();
				break;
			case 'F':		// start auto reload mode
			case 'f':
				startAutoReload();
				break;
			case 'V':		// stop auto reload mode.
			case 'v':
				stopAutoReload();
				break;
			case 'G':		// Up counter
				setCounterBuf(0, SLOPE);
				break;
			case 'g':		// Down counter
				setCounterBuf(0, -SLOPE);
				break;
			case 'H':		// Up counter
				setCounterBuf(1, SLOPE);
				break;
			case 'h':		// Down counter
				setCounterBuf(1, -SLOPE);
				break;
			case 'J':		// Up counter
				setCounterBuf(2, SLOPE);
				break;
			case 'j':		// Down counter
				setCounterBuf(2, -SLOPE);
				break;
			case 'K':		// Up counter
				setCounterBuf(3, SLOPE);
				break;
			case 'k':		// Down counter
				setCounterBuf(3, -SLOPE);
				break;
			case 'L':		// Up counter
				setCounterBuf(4, SLOPE);
				break;
			case 'l':		// down counter
				setCounterBuf(4, -SLOPE);
				break;
			case 'B':		// Up compare
				setCompareBuf(0, SLOPE);
				break;
			case 'b':		// down compare
				setCompareBuf(0, -SLOPE);