pll_test.c

Samsung S3C2443 Test program source code

/*======================================================================

 Project Name : S3C2443

 Copyright 2006 by Samsung Electronics, Inc.
 All rights reserved.

 Project Description :
 This software is only for verifying functions of the S3C2443. 
 Anybody can use this code without our permission.

 File Name    : PLL_test.c
 Description  : S3C2443 AC97 module code
 Author       : C.S. Jeon
 Dept         : AP
 Created Date : 2006.06.24
 Version      : 0.0
 History
   R0.0 (2006.06.15): C.S.Jeon draft
		- This code is derived from S3C2442 PLL change test code.
		- modified by junon 060623
		
=======================================================================*/

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

#include "def.h"
#include "option.h"
#include "system.h"
#include "console.h"

#include "2443addr.h"
#include "pll.h"
#include "pll_test.h"
//#include "memtest.h"

void Auto_Change_Pll(void);
void Test_PllOnOff(void);
void Test_Locktime(void);
void Test_EPLL_Locktime(void);
void Test_Clock_Divide(void);
void Change_Voltage(void);

// Sub function
U32 Calc_Locktime(U32 lock_time);


#if FIN==12000000
volatile unsigned int Mps_Val[][4]={
// MPLL_CLK,	 M,  P,  S.
	{300000000, 17,  1, 1},
	{300000000, 17,  1, 1},
	{348000000, 21,  1, 1},
	{348000000, 21,  1, 1},

	{402000000, 59,  2, 1},
	{402000000, 59,  2, 1},
	{420000000, 27,  1, 1},
	{420000000, 27,  1, 1},
	{432000000, 28,  1, 1},
	{438000000, 65,  2, 1},
	{450000000, 67,  2, 1},
	{462000000, 69,  2, 1},
	{468000000, 31,  1, 1},
	{480000000, 32,  1, 1},
	{492000000, 33,  1, 1},
	{498000000, 75,  2, 1},

	{510000000, 77,  2, 1},
	{510000000, 77,  2, 1},
	
	{522000000, 79,  2, 1},
	{522000000, 79,  2, 1},
	{528000000, 36,  1, 1},
	{534000000, 81,  2, 1},
	{534000000, 81,  2, 1},
	{540000000, 37,  1, 1},
	{546000000, 83,  2, 1},
	{560000000, 62,  3, 0},
	{568000000, 63,  3, 0},
	{576000000, 64,  3, 0},
	{584000000, 65,  3, 0},
	{592000000, 66,  3, 0},

	{600000000, 17,  1, 0},
	{612000000, 43,  2, 0},
	{624000000, 18,  1, 0},
	{632000000, 71,  3, 0},
	{640000000, 72,  3, 0},
	{648000000, 19,  1, 0},
	{660000000, 47,  2, 0},
	{672000000, 20,  1, 0},	
	{688000000, 78,  3, 0},

	{708000000, 51,  2, 0},
	{720000000, 22,  1, 0},
	{752000000, 86,  3, 0},
	{780000000, 57,  2, 0},

	{800000000, 92,  3, 0},
	{852000000, 63,  2, 0},
	{900000000, 67,  2, 0},

	{948000000, 71,  2, 0},

	{1008000000, 34,  1, 0},
	{1056000000, 36,  1, 0},
//	{1092000000, 83,  2, 0},

};

#endif

int No_Of_Mps_Val=sizeof(Mps_Val)/16;


void * func_pll_test[][2]=
{   
	//  						"123456789012345678901"
   	(void *)Test_Locktime,		"MPLL Locktime Test   ",
   	(void *)Test_EPLL_Locktime,	"EPLL Locktime Test   ", 
   	(void *)Test_Clock_Divide,	"Clock Divider Test   ", 
   	(void *)Manual_Change_Pll,	"Manual PLL Test      ", 
   	(void *)Auto_Change_Pll,	"Auto PLL Test        ", 
   	(void *)Test_PllOnOff,		"PLL On/Off Test      ", 
   	(void *)Change_Voltage,		"Arm voltage test     ",
   	(void *)System_Burden_Test,	"burden test       ", 
   	0,0
};


void Test_PLL(void)
{
	int i;
	
	
	rGPHCON=rGPHCON&~(0xf<<26)|(0xa<<26);
	//                                   CLKOUT1   CLKOUT0
	rMISCCR=rMISCCR&~((0x7<<8)|(0x7<<4))|(0x0<<8)|(0x1<<4);
	rCLKDIV0|=(1<<14);
		
	while(1)
	{
		i=0;
		printf("\n\n=============== PLL Function Test ===============\n\n");
		
		while(1)
		{   //display menu
			printf("%2d:%s",i,func_pll_test[i][1]);
			i++;
			if((int)(func_pll_test[i][0])==0)
			{
				printf("\n");
				break;
			}
			if((i%4)==0)
			printf("\n");
		}
		printf("\n======================================================\n");
		printf("Select #Item or Press Enter key to exit : ");
		i = GetIntNum(); 
		if(i==-1) break;		// return.
		if(i>=0 && (i<((sizeof(func_pll_test)-1)/8)) )	// select and execute...
			( (void (*)(void)) (func_pll_test[i][0]) )();
	}
	
}


// lock time: user lock time setting time[us],
// lock_count: register setting value for wanted locktime.
#define TIME_OF_XTAL	((float)1000000/(float)FIN)	//us

U32 Calc_Locktime(U32 lock_time)
{
	U32 lock_count=0;

	lock_count = (U32)((float)lock_time/((float)TIME_OF_XTAL));

	return lock_count;
}

void Test_Locktime(void)
{
	int temp;
	int i,j, mval, pval, sval, fclk, hdiv_val, pdiv_val;
	U32 lock_time=300, lock_count=12048;	//Unit is us.
	U32 mpllcon_bk;

	// clock register backup.
	mpllcon_bk = rMPLLCON;

	printf("[MPLL Lock time test 100,000 times]\n");
	printf("Lock time range: 300us - %d [us]\n", (U32)(0xffff*TIME_OF_XTAL));
	printf("Input Lock time[us]: ");
	lock_time = GetIntNum();

	lock_count = Calc_Locktime(lock_time);	// lock_time [us]
	rLOCKCON0=(lock_count<<0); 
	printf("Locktime register value is %d(%xh).\n", rLOCKCON0&0xffff);
	
//	printf("Clock will be locked after LED7 is ON.\n");

	i=0;
		
	while(1) 
	{
		if(Uart_GetKey()!=0x0) 
			break;
		if(i>100000) 
			break;
		if(i%2) 
		{
			Led_Display(0x8);
			SetMPLL( 92, 3, 1);
			SystemCLK(0);
			ChangeSDRAMParameter(HCLK);
			Console();
			printf("[400MHz]\n");
		} 
		else 
		{		
			Led_Display(0x0);
			SetMPLL( 17, 1, 1);
			SystemCLK(0);
			ChangeSDRAMParameter(HCLK);
			Console();
			printf("[300MHz]\n");
		}
		//Delay(1000);
		i++;
	}	
	printf("[PLL Lock time test %d times end]\n",i-1);
}

void Test_EPLL_Locktime(void)
{
	int temp;
	int i,j, mval, pval, sval, fclk, hdiv_val, pdiv_val;
	U32 lock_time=150, lock_count=12048;	//Unit is us.
	U32 epllcon_bk;

	// clock register backup.
	epllcon_bk = rEPLLCON;
    
    
    printf("EPLLCON: %x.\n", rEPLLCON);
	printf("[EPLL Lock time test 100,000 times]\n");
	printf("Lock time range: 150us - %d [us]\n", (U32)(0xffff*TIME_OF_XTAL));
	printf("Input Lock time[us]: ");
	lock_time = GetIntNum();
	
	


	lock_count = Calc_Locktime(lock_time);	// lock_time [us]
	rLOCKCON1=(lock_count<<0);
	rCLKSRC|=(1<<6);  // EPLL Output
	SetEPLL( 40, 1, 1);
	rEPLLCON&=~(1<<24);  // EPLL ON 
	

	printf("Locktime register value is %d(%xh).\n", rLOCKCON1&0xffff, rLOCKCON1&0xffff);
    printf("CLKSRC:%x EPLLCON: %x", rCLKSRC, rEPLLCON);
    
    getchar();
	
//	printf("Clock will be locked after LED7 is ON.\n");

	i=0;
		
	while(1) 
	{
		if(Uart_GetKey()!=0x0) 
			break;
		if(i>100000) 
			break;
		if(i%2) 
		{
			Led_Display(0x8);
			SetEPLL( 40, 1, 1); // EPLL 96MHz
			printf(".");
	  	} 
		else 
		{		
			Led_Display(0x2);
			SetEPLL( 40, 1, 2);	 // EPLL 96MHz
			printf(",");
		}
		//Delay(1000);
		i++;
	}	
	printf("[PLL Lock time test %d times end]\n",i-1);
}

void Test_Clock_Divide(void)
{
	int temp;
	int i,j, mval, pval, sval, fclk, hdiv_val, pdiv_val;
	U32 clkdiv0_bk;


    clkdiv0_bk=rCLKDIV0;
	   
	
	Uart_TxEmpty();
	SetCLKDIV( 0, 3, 3, 1);		 // 1:16:16
	SystemCLK(0);
	ChangeSDRAMParameter(HCLK);
	Console();
	
	
	printf("\n[Clock Divide Test]\n");
	printf("Probe CLKOUT0 and check FCLK, HCLK, PCLK\n");

	rGPHCON=rGPHCON&~(3<<26)|(2<<26);    // CLKOUT0 setting
	rGPHUDP&=~(3<<26);  // pull updown disable
	rMISCCR=rMISCCR&~(7<<4)|(2<<4);     // 2: FCLK, 3:HCLK, 4:PCLK
	printf("MPLLOUT is 400MHz\n");	
	printf("ARMCLK=MPLLOUT \n ");
	
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0<<9);
	getchar();
	SystemCLK(0);
	Console();

	printf("ARMCLK=MPLLOUT /2 \n ");
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0x8<<9);
	getchar();
	SystemCLK(0);
	Console();

	printf("ARMCLK=MPLLOUT /3 \n ");
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0x2<<9);
	getchar();
	SystemCLK(0);
	Console();

	printf("ARMCLK=MPLLOUT /4 \n ");
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0x9<<9);
	getchar();
	SystemCLK(0);
	Console();
 
	printf("ARMCLK=MPLLOUT /6 \n ");
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0xa<<9);
	getchar();
	SystemCLK(0);
	Console();

	printf("ARMCLK=MPLLOUT /8 \n ");
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0xb<<9);
	getchar();
	SystemCLK(0);
	Console();

	printf("ARMCLK=MPLLOUT /12 \n ");
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0xd<<9);
	getchar();
	SystemCLK(0);
	Console();

	printf("ARMCLK=MPLLOUT /16 \n ");
	rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0xf<<9);
	getchar();
	SystemCLK(0);
	Console();

    printf("MPLL:ARMCLK:HCLK:PCLK = 400MHz:400MHz:100MHz:50MHz\n ");
    printf("CLKOUT0 => HCLK \n ");
    rMISCCR=rMISCCR&~(7<<4)|(3<<4);     // 2: FCLK, 3:HCLK, 4:PCLK
    printf("HCLK=MPLLOUT/4 (400MHz /4) \n ");
    
    rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0x0<<9);
	rCLKDIV0=rCLKDIV0&~((0x3<<4)|(0x3<<0))|(0x1<<4)|(1<<0);
	SystemCLK(0);
	ChangeSDRAMParameter(HCLK);
	Console();
	getchar();

	printf("HCLK=MPLLOUT /6 (400MHz /6) \n ");
	
	rCLKDIV0=rCLKDIV0&~((0x3<<4)|(0x3<<0))|(0x2<<4)|(1<<0);
	getchar();
	SystemCLK(0);
	ChangeSDRAMParameter(HCLK);
	Console();

	printf("HCLK=MPLLOUT /8(400MHz /8) \n ");
	
	rCLKDIV0=rCLKDIV0&~((0x3<<4)|(0x3<<0))|(0x3<<4)|(1<<0);  
	getchar();
	SystemCLK(0);
	ChangeSDRAMParameter(HCLK);
	Console();

	printf("HCLK=MPLLOUT /12(400MHz /12) \n ");

	rCLKDIV0=rCLKDIV0&~((0x3<<4)|(0x3<<0))|(0x2<<4)|(3<<0);  
	getchar();
	SystemCLK(0);
	ChangeSDRAMParameter(HCLK);
	Console();

	printf("HCLK=MPLLOUT /16(400MHz /16) \n ");
	
	rCLKDIV0=rCLKDIV0&~((0x3<<4)|(0x3<<0))|(0x3<<4)|(3<<0); 
	getchar();
	SystemCLK(0);
	ChangeSDRAMParameter(HCLK);
	Console();
	
	
	printf("CLKOUT0 => PCLK \n ");
	
	rMISCCR=rMISCCR&~(7<<4)|(4<<4); 	// 2: FCLK, 3:HCLK, 4:PCLK
		
	printf("PCLK=HCLK (400MHz /16) \n ");
	
	rCLKDIV0=rCLKDIV0&~(0x1<<2)|(0x0<<2);  
	getchar();
	SystemCLK(0);
	Console();

	printf("PCLK=HCLK /2 (400MHz /32) \n ");
	
	rCLKDIV0=rCLKDIV0&~(0x1<<2)|(0x1<<2);  
	getchar();
	
	

    rCLKDIV0=rCLKDIV0&~(0xf<<9)|(0x0<<9);
	rCLKDIV0=rCLKDIV0&~((0x3<<4)|(0x3<<0))|(0x1<<4)|(1<<0);
	
    SystemCLK(0);
	ChangeSDRAMParameter(HCLK);
	Console();