timer.c

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

	//	if(variable0>TIMER_MAX_COUNT && variable1 > TIMER_MAX_COUNT
	//		&& variable2 > TIMER_MAX_COUNT && variable3 > TIMER_MAX_COUNT && variable4 > TIMER_MAX_COUNT)
//		{
//			break;
//		}

		if ( variable4 == 8 )
			break;

		/*	    
#if DEADZONE_TEST
		i=Uart_getc();	
		switch(i)
		{
			case 'j':
				j++;
				printf("j = %d\n",j);
				break;
			case 'k':
				j--;
				printf("j = %d\n",j);
				break;
			default:
				break;
		}
		rTCFG0 = rTCFG0 & (~((0xff)<<16)) | (j<<16);
		printf("rTCF0 = 0x%x\n",rTCFG0);
#else if(variable4 == 8)
		break;
#endif*/
	}
      
	//Delay(1); //To compensate timer error(<1 tick period)

	rTCON = 0x0; //Stop Timers

	if(variable4==8 && variable3==4 && variable2==2 && variable1==1 && variable0==1)
	{
		printf("Timer 0,1,2,3,4 Auto-reload Interrupt Test => OK!\n");
	}        
	else
	{
		printf("Timer 0,1,2,3,4 Auto-reload Interrupt Test => Fail............\n");
	}    
	printf("Timer0: %d (=1)\nTimer1: %d (=1)\nTimer2: %d (=2)\nTimer3: %d (=4)\nTimer4: %d (=8)\n",
		variable0,variable1,variable2,variable3,variable4);        
#if 0	
	/* OneShot Test */
  	variable0 = 0;variable1 = 0;variable2 = 0;variable3 = 0;variable4 = 0;
  	
  	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

	while(variable0 == 0);     
    
    Delay(1); //To compensate timer error(<1 tick period)
    rTCON = 0x0; //One-shot, Inverter off, No operation, Dead zone disable, Stop
   
    if(variable4==1 && variable3==1 && variable2==1 && variable1==1 && variable0==1)
    {
        printf("Timer 0,1,2,3,4 One-shot Interrupt Test => OK!\n");
    }        
    else
    {
        printf("Timer 0,1,2,3,4 One-shot Interrupt Test => Fail............\n");
    }    
    	printf("Timer0: %d (=1)\nTimer1: %d (=1)\nTimer2: %d (=1)\nTimer3: %d (=1)\nTimer4: %d (=1)\n",
        variable0,variable1,variable2,variable3,variable4);        
#endif
	/* Timer0,1,2,3,4 Interrupt Service is masked */
    rINTMSK |= (BIT_TIMER4 | BIT_TIMER3 | BIT_TIMER2 | BIT_TIMER1 | BIT_TIMER0);
	printf("Press any key\n");      
	while(!Uart_getc());       //Key board press check    
	
	rTCON = 0; //initialize  

	rPRIORITY = save_PRIORITY ;
    rINTMOD = save_INTMOD ;
    
}

//========================================================
// Timer Interrupt Request 
//========================================================
void __irq Timer0Done(void)
{
	// printf("timer 0 0x%x\n",rINTOFFSET);
	rSRCPND = BIT_TIMER0;       //Clear pending bit
	rINTPND = BIT_TIMER0;
	rINTPND;                    //Prevent an double interrupt pending
	variable0++;
	if ( isr_print )
		printf("0");
}

//---------------------------------------------------------------------
void __irq Timer1Done(void)
{
//	printf("timer 1 0x%x\n",rINTOFFSET);
	rSRCPND = BIT_TIMER1;       //Clear pending bit
	rINTPND = BIT_TIMER1;
	rINTPND;
	variable1++;
	if ( isr_print )
		printf("1");

}

//---------------------------------------------------------------------
void __irq Timer2Done(void)
{
	//printf("timer 2 0x%x\n",rINTOFFSET);
#if FIQ_TEST
	printf("FIQ timer 2 0x%x\n",rINTOFFSET);
#endif
	rSRCPND = BIT_TIMER2;       //Clear pending bit
	rINTPND = BIT_TIMER2;
	rINTPND;
	variable2++;  
	if ( isr_print )
		printf("2");

}

//---------------------------------------------------------------------
void __irq Timer3Done(void)
{
	//printf("timer 3 0x%x\n",rINTOFFSET);
	rSRCPND = BIT_TIMER3;       //Clear pending bit
	rINTPND = BIT_TIMER3;
	rINTPND;
	variable3++;
	if ( isr_print )
		printf("3");

}

//---------------------------------------------------------------------
void __irq Timer4Done(void)
{
	//printf("timer 4 0x%x\n",rINTOFFSET);
	rSRCPND = BIT_TIMER4;       //Clear pending bit
	rINTPND = BIT_TIMER4;
	rINTPND;
	variable4++;
	if ( isr_print )
		printf("4");
	// GPIO toggle signal for timer4 .
	if ( variable4 % 2 )
		rGPEDAT |= (1<<12);
	else
		rGPEDAT &= ~(1<<12);
}

/******************** Timer DMA Request Test ********************/										
void Test_TimerDma(void)
{
#if 1
	int i, j;
	int mux;
//	int counter[]={ 65536, 60000, 599999, 588888, 512345 };
//	int compare[]={ 30000, 30001, 30002, 30003, 40000};
	int counter[]={ 65500, 60000, 60000, 60000, 60000 };
	int compare[]={ 30000, 30001, 30002, 30003, 40000};

	for( j = 0; j<5;j++) {
		rTCFG0 = rTCFG0 & ~(0xffffff) | 0x0; //Dead zone=0, Prescaler0,1 = 0    

		rTCNTB0 = counter[j];
		rTCMPB0 = compare[j];

		rTCNTB1 = counter[j];
		rTCMPB1 = compare[j];

		rTCNTB2 = counter[j];
		rTCMPB2 = compare[j];

		rTCNTB3 = counter[j];
		rTCMPB3 = compare[j];

		rTCNTB4 = counter[j];

		rTCON  = rTCON & ~(0xffffff) | 0x1<<1 | 0x1<<9 | 0x1<<13 | 0x1<<17 | 0x1<<21 ; //Manual update 
	  	
	  	printf("\nTimer 0 DMA Request Test\n\n");

		rTCFG1 = rTCFG1 & ~(0xffffff) | 0x1 << 0 | 0x1 << 20; //Mux0 1/16, DMA Request Channel 0
	  	rTCON = 0x1 | 0x1<<3; //Auto reload, Start
	   	for(i=0 ; i < 4 ; i++)
	   	DMA_M2M_timer(0,_NONCACHE_STARTADDRESS,_NONCACHE_STARTADDRESS+0x800000,0x80000,0,0); //byte,single
		rTCON  = 0x0; //Timer Stop

		printf("\nTimer 1 DMA Request Test\n\n");
	  	
	  	rTCFG1 = rTCFG1 & ~(0xffffff) | 0x1 << 4 | 0x2 << 20; //Mux0 1/16, DMA Request Channel 2
	  	rTCON = 0x1<<8 | 0x1<<11; //Auto reload, Start
	  	for(i=0 ; i < 4 ; i++) 
	   	DMA_M2M_timer(2,_NONCACHE_STARTADDRESS,_NONCACHE_STARTADDRESS+0x800000,0x80000,0,0); //byte,single
		rTCON  = 0x0; 
		
		printf("\nTimer 2 DMA Request Test\n\n");
	  	
	  	rTCFG1 = rTCFG1 & ~(0xffffff) | 0x1 << 8 | 0x3 << 20; //Mux0 1/16, DMA Request Channel 3
	  	rTCON = 0x1<<12 | 0x1<<15; //Auto reload, Start
	  	for(i=0 ; i < 4 ; i++) 
	   	DMA_M2M_timer(3,_NONCACHE_STARTADDRESS,_NONCACHE_STARTADDRESS+0x800000,0x80000,0,0); //byte,single
		rTCON  = 0x0; 

		printf("\nTimer 3 DMA Request Test\n\n");
	  	
	  	rTCFG1 = rTCFG1 & ~(0xffffff) | 0x1 << 12 | 0x4 << 20; //Mux0 1/16, DMA Request Channel 0
	  	rTCON = 0x1<<16 | 0x1<<19; //Auto reload, Start
	  	for(i=0 ; i < 4 ; i++) 
	   	DMA_M2M_timer(0,_NONCACHE_STARTADDRESS,_NONCACHE_STARTADDRESS+0x800000,0x80000,0,0); //byte,single
		rTCON  = 0x0; 

		printf("\nTimer 4 DMA Request Test\n\n");
	  	
	  	rTCFG1 = rTCFG1 & ~(0xffffff) | 0x1 << 16 | 0x5 << 20; //Mux0 1/16, DMA Request Channel 2
	  	rTCON = 0x1<<20 | 0x1<<22; //Auto reload, Start
	  	for(i=0 ; i < 4 ; i++) 
	   	DMA_M2M_timer(2,_NONCACHE_STARTADDRESS,_NONCACHE_STARTADDRESS+0x800000,0x80000,0,0); //byte,single
		rTCON  = 0x0;
	}
	
	printf("Press any key\n");      
	while(!Uart_getc());       //Key board press check      
#else
    int i;
    
    rTCFG0 = rTCFG0 & ~(0xffffff) | 0x000021;         //PCLK =  67.5MHz , prescaler 0x15= 21 ===>2MHz)
    //rTCFG0 = rTCFG0 & ~(0xffffff) | 0x0; //Dead zone=0, Prescaler0,1 = 0    
    rTCFG1 = rTCFG1 & ~(0xffffff) | 0x0 << 0 | 0x1 << 20; //Mux0 1/16, DMA Request Channel 0
    
    rTCNTB0 = 10000;   
  	rTCMPB0 = 30000;
  	
  	rTCNTB1 = 65500;   
  	rTCMPB1 = 30000;
  	
  	rTCNTB2 = 65500;   
  	rTCMPB2 = 30000;
  	
  	rTCNTB3 = 65500;   
  	rTCMPB3 = 30000;
  	
  	rTCNTB4 = 65500;   
  	
  	rTCON  = rTCON & ~(0xffffff) | 0x1<<1 | 0x1<<9 | 0x1<<13 | 0x1<<17 | 0x1<<21 ; //Manual update 
  	
  	printf("\nTimer 0 DMA Request Test \n\n");
  	
  	// timer 0 DMA transfer test
   	for(i=0 ; i < 4 ; i++)
	DMA_M2M_timer(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0x80000, 0, 0);

	printf("Press any key\n");      
	while(!Uart_getc());       //Key board press check      
#endif
}
/***** Memory to Memory DMA Service Routine *****/
void DMA_M2M_timer(int ch,int srcAddr,int dstAddr,int tc,int dsz,int burst)
{
    int i,time;
    volatile U32 memSum0=0,memSum1=0;
    DMA *pDMA; //Pointer for DMA Special Register Structure 
    int length;
    
    length=tc*(burst ? 4:1)*((dsz==0)+(dsz==1)*2+(dsz==2)*4); //total data size(byte address)
    //     Counter value * burst size * data size     
    
    printf("[DMA%d MEM2MEM Test]\n",ch);

    switch(ch)
    {
    case 0:
    	pISR_DMA0=(int)Dma0Done; //DMA0 interrupt Vector Table Initialzation
    	rINTMSK&=~(BIT_DMA0);    //DMA0 interrupt Enable
    	pDMA=(void *)0x4b000000; //pDMA ponter indicate first addr. of DMA0 Special Register 
    	break;
    case 1:
    	pISR_DMA1=(int)Dma1Done; //DMA1 interrupt Vector Table Initialzation
    	rINTMSK&=~(BIT_DMA1);  
    	pDMA=(void *)0x4b000040;
    	break;
    case 2:
		pISR_DMA2=(int)Dma2Done; //DMA2 interrupt Vector Table Initialzation
    	rINTMSK&=~(BIT_DMA2);  
    	pDMA=(void *)0x4b000080;
	break;
    case 3:
        pISR_DMA3=(int)Dma3Done; //DMA3 interrupt Vector Table Initialzation
       	rINTMSK&=~(BIT_DMA3);  
       	pDMA=(void *)0x4b0000c0;
        break;
    }
                                                                                                                            
    printf("DMA%d %8xh->%8xh,size=%xh(tc=%xh),dsz=%d,burst=%d\n",ch,srcAddr,dstAddr,length,tc,dsz,burst);

    printf("Initialize the src.\n");
    
    for(i=srcAddr;i<(srcAddr+length);i+=4)
    {
    	*((U32 *)i)=i^0x55aa5aa5;
    	memSum0+=i^0x55aa5aa5;
    }

    
    printf("DMA%d start\n",ch);
    
    dmaDone=0;
    
    /* Value Setting of Current DMA Special Registers */
    pDMA->DISRC=srcAddr;
    pDMA->DISRCC=(0<<1)|(0<<0); //inc,AHB
    pDMA->DIDST=dstAddr;
    pDMA->DIDSTC=(0<<1)|(0<<0); //inc,AHB
    
    pDMA->DCON=tc|(1<<31)|(1<<30)|(1<<29)|(burst<<28)|(1<<27)|(0x3<<24)|(1<<23)|(1<<22)|(dsz<<20)|(tc);
    //HS,AHB,TC interrupt,whole, HWSource request mode,relaod off
    
    pDMA->DMASKTRIG= 0x1<<1; //DMA on,
	pDMA->DMAREQSEL= (0x9<<1)+(0x1);
	/* DMA Start */
    Timer_Start(3);//128us resolution	      
    
    while(dmaDone==0);
    
    time=Timer_Stop();
    
    printf("DMA transfer done. time=%f, %fMB/S\n",(float)time/ONESEC3, length/((float)time/ONESEC3)/1000000.);
    
    rINTMSK=BIT_ALLMSK;
    
    /* Check DMA Result */
    for(i=dstAddr;i<dstAddr+length;i+=4)
    {
    	memSum1+=*((U32 *)i)=i^0x55aa5aa5;
    }
    
    printf("memSum0=%x,memSum1=%x\n",memSum0,memSum1);
    if(memSum0==memSum1)
    	printf("DMA test result--------------------------------------O.K.\n");
    else 
    	printf("DMA test result--------------------------------------ERROR!!!\n");
}

/***** DMA Interrupt Service Routine *****/ 
static void __irq Dma0Done(void)
{
    ClearPending(BIT_DMA0);
    dmaDone=1;
}

static void __irq Dma1Done(void)
{
    ClearPending(BIT_DMA1);
    dmaDone=1;
}

static void __irq Dma2Done(void)
{
    ClearPending(BIT_DMA2);
    dmaDone=1;
}

static void __irq Dma3Done(void)
{
    ClearPending(BIT_DMA3);
    dmaDone=1;
}

void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON = ((PCLK/1000000-1)<<8)|(divider<<3);  //Watch-dog timer control register
    rWTDAT = 0xffff;  //Watch-dog timer data register
    rWTCNT = 0xffff;  //Watch-dog count register

      // Watch-dog timer enable & interrupt  disable
    rWTCON = (rWTCON & ~(1<<5) & ~(1<<2)) |(1<<5);
}

//=================================================================
int Timer_Stop(void)
{
    rWTCON = ((PCLK/1000000-1)<<8);
    return (0xffff - rWTCNT);
}