reg0299.c

Zoran V966 DVD 解码 Soc芯片的源程序

	AddReg(handle,R_ACLC,"ACLC",0x13,0x88);
	AddField(handle,R_ACLC,DEROTATOR,"DEROTATOR",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_ACLC,NOISEESTIMATORTIMECONSTANT,"NOISEESTIMATORTIMECONSTANT",4,2,DEMOD_UNSIGNED);
	AddField(handle,R_ACLC,ALPHA_CAR,"ALPHA_CAR",0,4,DEMOD_UNSIGNED);

	/*	BCLC	*/
	AddReg(handle,R_BCLC,"BCLC",0x14,0x8d);
	AddField(handle,R_BCLC,PHASE_DETECTOR_ALGO,"PHASE_DETECTOR_ALGO",6,2,DEMOD_UNSIGNED);
	AddField(handle,R_BCLC,BETA_CAR,"BETA_CAR",0,6,DEMOD_UNSIGNED);

	/*	CLDT	*/
	AddReg(handle,R_CLDT,"CLDT",0x15,0xE3);
	AddField(handle,R_CLDT,CLDT,"CLDT",0,8,DEMOD_SIGNED);

	/*	AGC1I	*/
	AddReg(handle,R_AGC1I,"AGC1I",0x16,0xf9);
	AddField(handle,R_AGC1I,AGCINTEGRATORVALUE,"AGCINTEGRATORVALUE",0,8,DEMOD_SIGNED);

	/*	TLIR	*/
	AddReg(handle,R_TLIR,"TLIR",0x17,0x64);
	AddField(handle,R_TLIR,TLIR,"TLIR",0,8,DEMOD_UNSIGNED);

	/*	AGC2I1	*/
	AddReg(handle,R_AGC2I1,"AGC2I1",0x18,0xFF);
	AddField(handle,R_AGC2I1,AGC2INTEGRATORMSB,"AGC2INTEGRATORMSB",0,8,DEMOD_UNSIGNED);

	/*	AGC2I2	*/
	AddReg(handle,R_AGC2I2,"AGC2I2",0x19,0xFF);
	AddField(handle,R_AGC2I2,AGC2INTEGRATORLSB,"AGC2INTEGRATORLSB",0,8,DEMOD_UNSIGNED);

	/*	RTF	*/
	AddReg(handle,R_RTF,"RTF",0x1A,0xF7);
	AddField(handle,R_RTF,RTF,"RTF",0,8,DEMOD_SIGNED);

	/*	VSTATUS	*/
	AddReg(handle,R_VSTATUS,"VSTATUS",0x1B,0x99);
	AddField(handle,R_VSTATUS,CF,"CF",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_VSTATUS,PRF,"PRF",4,1,DEMOD_UNSIGNED);
	AddField(handle,R_VSTATUS,LK,"LK",3,1,DEMOD_UNSIGNED);
	AddField(handle,R_VSTATUS,CPR,"CPR",0,3,DEMOD_UNSIGNED);

	/*	CLDI	*/
	AddReg(handle,R_CLDI,"CLDI",0x1C,0x7b);
	AddField(handle,R_CLDI,CLDI,"CLDI",0,8,DEMOD_SIGNED);

	/*	ERRCNT_HIGH	*/
	AddReg(handle,R_ERRCNT_HIGH,"ERRCNT_HIGH",0x1D,0x24);
	AddField(handle,R_ERRCNT_HIGH,ERRCNTMSB,"ERRCNTMSB",0,8,DEMOD_UNSIGNED);

	/*	ERRCNT_LOW	*/
	AddReg(handle,R_ERRCNT_LOW,"ERRCNT_LOW",0x1E,0x24);
	AddField(handle,R_ERRCNT_LOW,ERRCNTLSB,"ERRCNTLSB",0,8,DEMOD_UNSIGNED);

	/*	SFRH	*/
	AddReg(handle,R_SFRH,"SFRH",0x1F,0x58);
	AddField(handle,R_SFRH,SYMB_FREQH,"SYMB_FREQH",0,8,DEMOD_UNSIGNED);

	/*	SFRM	*/
	AddReg(handle,R_SFRM,"SFRM",0x20,0x00);
	AddField(handle,R_SFRM,SYMB_FREQM,"SYMB_FREQM",0,8,DEMOD_UNSIGNED);

	/*	SFRL	*/
	AddReg(handle,R_SFRL,"SRFL",0x21,0x00);
	AddField(handle,R_SFRL,SYMB_FREQL,"SYMB_FREQL",4,4,DEMOD_UNSIGNED);

	/*	CFRM	*/
	AddReg(handle,R_CFRM,"CFRM",0x22,0xFF);
	AddField(handle,R_CFRM,DEROTATORFREQUENCYMSB,"DEROTATORFREQUENCYMSB",0,8,DEMOD_UNSIGNED);

	/*	CFRL	*/
	AddReg(handle,R_CFRL,"CFRL",0x23,0x00);
	AddField(handle,R_CFRL,DEROTATORFREQUENCYLSB,"DEROTATORFREQUENCYLSB",0,8,DEMOD_UNSIGNED);

	/*	NIRH	*/
	AddReg(handle,R_NIRH,"NIRH",0x24,0x1A);
	AddField(handle,R_NIRH,NOISEINDICATORMSB,"NOISEINDICATORMSB",0,8,DEMOD_UNSIGNED);

	/*	NIRL	*/
	AddReg(handle,R_NIRL,"NIRL",0x25,0x7B);
	AddField(handle,R_NIRL,NOISEINDICATORLSB,"NOISEINDICATORLSB",0,8,DEMOD_UNSIGNED);

	/*	VERROR	*/
	AddReg(handle,R_VERROR,"VERROR",0x26,0x17);
	AddField(handle,R_VERROR,ERRORRATE,"ERRORRATE",0,8,DEMOD_UNSIGNED);

	/*	FECM	*/
	AddReg(handle,R_FECM,"FECM",0x28,0x00);
	AddField(handle,R_FECM,FECMODE,"FECMODE",4,4,DEMOD_UNSIGNED);
	AddField(handle,R_FECM,OUTPUTTYPE,"OUTPUTTYPE",1,1,DEMOD_UNSIGNED);
	AddField(handle,R_FECM,OUTPUTIMPEDANCE,"OUTPUTIMPEDANCE",0,1,DEMOD_UNSIGNED);

	/*	VTH0	*/
	AddReg(handle,R_VTH0,"VTH0",0x29,0x1E);
	AddField(handle,R_VTH0,VTH0,"VTH0",0,8,DEMOD_UNSIGNED);

	/*	VTH1	*/
	AddReg(handle,R_VTH1,"VTH1",0x2A,0x14);
	AddField(handle,R_VTH1,VTH1,"VTH1",0,8,DEMOD_UNSIGNED);

	/*	VTH2	*/
	AddReg(handle,R_VTH2,"VTH2",0x2B,0x0F);
	AddField(handle,R_VTH2,VTH2,"VTH2",0,8,DEMOD_UNSIGNED);

	/*	VTH3	*/
	AddReg(handle,R_VTH3,"VTH3",0x2C,0x09);
	AddField(handle,R_VTH3,VTH3,"VTH3",0,8,DEMOD_UNSIGNED);

	/*	VTH4	*/
	AddReg(handle,R_VTH4,"VTH4",0x2D,0x07);
	AddField(handle,R_VTH4,VTH4,"VTH4",0,8,DEMOD_UNSIGNED);

	/*	PR	*/
	AddReg(handle,R_PR,"PR",0x31,0x1F);
	AddField(handle,R_PR,RATE,"RATE",0,8,DEMOD_UNSIGNED);

	/*	VSEARCH	*/
	AddReg(handle,R_VSEARCH,"VSEARCH",0x32,0x19);
	AddField(handle,R_VSEARCH,SEARCHMODE,"SEARCHMODE",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_VSEARCH,FREEZE,"FREEZE",6,1,DEMOD_UNSIGNED);
	AddField(handle,R_VSEARCH,SN,"SN",4,2,DEMOD_UNSIGNED);
	AddField(handle,R_VSEARCH,TO,"TO",2,2,DEMOD_UNSIGNED);
	AddField(handle,R_VSEARCH,H,"H",0,2,DEMOD_UNSIGNED);

	/*	RS	*/
 	AddReg(handle,R_RS,"RS",0x33,0xFC);  // For H58 frontend and step B

	AddField(handle,R_RS,DEINTERLEAVER,"DEINTERLEAVER",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_RS,SYNCHRO,"SYNCHRO",6,1,DEMOD_UNSIGNED);
	AddField(handle,R_RS,REEDSOLOMON,"REEDSOLOMON",5,1,DEMOD_UNSIGNED);
	AddField(handle,R_RS,DESCRAMBLER,"DESCRAMBLER",4,1,DEMOD_UNSIGNED);
	AddField(handle,R_RS,WRITEERRORBIT,"WRITEERRORBIT",3,1,DEMOD_UNSIGNED);
	AddField(handle,R_RS,BLOCKSYNCHRO,"BLOCKSYNCHRO",2,1,DEMOD_UNSIGNED);
	AddField(handle,R_RS,OUTPUTCLOCKPOLARITY,"OUTPUTCLOCKPOLARITY",1,1,DEMOD_UNSIGNED);
	AddField(handle,R_RS,OUTPUTCLOCKCONFIG,"OUTPUTCLOCKCONFIG",0,1,DEMOD_UNSIGNED);

	/*	ERRCNT	*/
	AddReg(handle,R_ERRCNT,"ERRCNT",0x34,0x13);
	AddField(handle,R_ERRCNT,ERRORMODE,"ERRORMODE",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_ERRCNT,ERRORSOURCE,"ERRORSOURCE",4,2,DEMOD_UNSIGNED);
	AddField(handle,R_ERRCNT,NOE,"NOE",0,2,DEMOD_UNSIGNED);

	/*	TEST REGISTERS	*/

	AddReg(handle,R_TFEC1,"TFEC1",0x40,0x00);
	AddField(handle,R_TFEC1,TFEC1,"TFEC1",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TFEC2,"TFEC2",0x41,0x00);
	AddField(handle,R_TFEC2,TFEC2,"TFEC2",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TSTRAM1,"TSTRAM1",0x42,0x00);
	AddField(handle,R_TSTRAM1,TSTRAM1,"TSTRAM1",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TSTRATE,"TSTRATE",0x43,0x00);
	AddField(handle,R_TSTRATE,TSTRATE,"TSTRATE",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_SELOUT,"SELOUT",0x44,0x00);
	AddField(handle,R_SELOUT,SELOUT,"SELOUT",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_FORCEIN,"FORCEIN",0x45,0x00);
	AddField(handle,R_FORCEIN,FORCEIN,"FORCEIN",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TSRTESCK,"TSRTESCK",0x46,0x00);
	AddField(handle,R_TSRTESCK,TSRTESCK,"TSRTESCK",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TSTOUT,"TSTOUT",0x47,0x00);
	AddField(handle,R_TSTOUT,TSTOUT,"TSTOUT",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TSTR,"TSTR",0x48,0x00);
	AddField(handle,R_TSTR,TSTR,"TSTR",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TAGC2,"TAGC2",0x49,0x00);
	AddField(handle,R_TAGC2,TAGC2,"TAGC2",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TCTL,"TCTL",0x4A,0x00);
	AddField(handle,R_TCTL,TCTL,"TCTL",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TCTL2,"TCTL2",0x4B,0x00);
	AddField(handle,R_TCTL2,TCTL2,"TCTL2",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TAGC1,"TAGC1",0x4C,0x00);
	AddField(handle,R_TAGC1,TAGC1,"TAGC1",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TSTFIFO,"TSTFIFO",0x4D,0x00);
	AddField(handle,R_TSTFIFO,TSTFIFO,"TSTFIFO",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_TSTVCO,"TSTVCO",0x4E,0x00);
	AddField(handle,R_TSTVCO,TSTVCO,"TSTVCO",0,8,DEMOD_UNSIGNED);

	AddReg(handle,R_GHOST,"GHOST",0x4F,0x00);
	AddField(handle,R_GHOST,GHOST,"GHOST",0,8,DEMOD_UNSIGNED);
	
	RegReset(handle);
}

/*****************************************************
**FUNCTION	::	PowOf2
**ACTION	::	Compute  2^n (where n is an integer) 
**PARAMS IN	::	number -> n
**PARAMS OUT::	NONE
**RETURN	::	2^n
*****************************************************/
long PowOf2(long number)
{
	INT32 i;
	long result=1;
	
	for(i=0;i<number;i++)
		result*=2;
		
	return result;
}

/*****************************************************
**FUNCTION	::	LongSqrt
**ACTION	::	Compute  the square root of n (where n is a long integer) 
**PARAMS IN	::	number -> n
**PARAMS OUT::	NONE
**RETURN	::	sqrt(n)
*****************************************************/
long LongSqrt(long Value)
{
	/* this routine performs a classical root extraction
	** on long integers */
	long Factor=1;
	long Root=1;
	long R;
	long Ltmp;
	
	if(Value<=1)
	  return (Value);
	
	Ltmp=Value;
	
	while (Ltmp>3)	
	{
		Factor<<=2;
		Ltmp>>=2;
	}
	
	R=Value-Factor; /*	Ratio	*/ 
	Factor>>=2;
	
	while(Factor>0)
	{
		Root<<=1;
		Ltmp=Root<<1;
		Ltmp*=Factor;
		Ltmp+=Factor;
		Factor>>=2;
		
		if(R-Ltmp>=0)
		{
			R=R-Ltmp;
			Root+=1;
		}
	}
	
	return (Root) ;
}


/*****************************************************
**FUNCTION	::	RegSetExtClk
**ACTION	::	Set the value of the external clock variable
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	NONE
*****************************************************/
void  RegSetExtClk(DEMOD_HANDLE handle, long _Value)
{
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;

	sDemodData->RegExtClk = _Value;
}
  
/*****************************************************
**FUNCTION	::	RegGetExtClk
**ACTION	::	Get the external clock value
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	External clock value
*****************************************************/
long  RegGetExtClk(DEMOD_HANDLE handle)
{
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;

	return (sDemodData->RegExtClk);
}



/*****************************************************
**FUNCTION	::	CalcRefFrequency
**ACTION	::	Compute reference frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Reference frequency
*****************************************************/
long CalcRefFrequency(DEMOD_HANDLE handle, INT32 k)
{
	return (RegGetExtClk(handle)/(k+1)); 
}

/*****************************************************
**FUNCTION	::	CalcVCOFrequency
**ACTION	::	Compute VCO frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	VCO frequency
*****************************************************/
long CalcVCOFrequency(DEMOD_HANDLE handle, INT32 k,INT32 m)
{
	return (CalcRefFrequency(handle, k)*4*(m+1)); 
}

/*****************************************************
**FUNCTION	::	RegGetVCOFreq
**ACTION	::	Read registers and compute VCO frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	VCO frequency
*****************************************************/
long RegGetVCOFreq(DEMOD_HANDLE handle)
{
	/*	Read register	*/
	RegGetOneRegister(handle,R_RCR);
	
	return CalcVCOFrequency(handle,FieldGetVal(handle,K),FieldGetVal(handle,M)); /*	compute VCO freq	*/
}

/*****************************************************
**FUNCTION	::	CalcF22Frequency
**ACTION	::	Compute F22 frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	F22 frequency
*****************************************************/
long CalcF22Frequency(DEMOD_HANDLE handle,INT32 k,INT32 m,INT32 f22)
{
	return (f22!=0) ? (CalcVCOFrequency(handle,k,m)/(128*f22)) : 0; 
}

/*****************************************************
**FUNCTION	::	RegGetF22Freq
**ACTION	::	Read registers and Compute F22 frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	F22 frequency
*****************************************************/
long RegGetF22Freq(DEMOD_HANDLE handle)
{

	/*	Read registers	*/
	RegGetOneRegister(handle,R_RCR);
	RegGetOneRegister(handle,R_F22FR);
	
	return CalcF22Frequency(handle,
							FieldGetVal(handle,K),
							FieldGetVal(handle,M),
							FieldGetVal(handle,F22FR));	/*	Compute F22 freq	*/
}

/*****************************************************
**FUNCTION	::	CalcMasterClkFrequency
**ACTION	::	Compute Master clock frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Master Clock frequency
*****************************************************/
long CalcMasterClkFrequency(DEMOD_HANDLE handle, INT32 stdby ,INT32 dirclk ,INT32 k ,INT32 m, INT32 p)
{
	long 
		mclk;
	
	if(stdby)
	{
		tr_printf(("standby!!!!!!!!!!!!!!!\n"));
		mclk=0;
	}
	else if(dirclk) 
	{
		//tr_printf(("RegGetExtClk\n"));
		mclk=RegGetExtClk(handle);  
	}
	else
	{
//		dbprintf(("CalcVCOFrequency\n"));
		mclk=CalcVCOFrequency(handle,k,m)/((2+(p%2))*PowOf2((p/2)+1));
	}
	
	return mclk; 
}

/*****************************************************
**FUNCTION	::	RegGetMasterFreq
**ACTION	::	Read registers and compute Master clock frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Master Clock frequency
*****************************************************/
long RegGetMasterFreq(DEMOD_HANDLE handle)
{

	/*	Read registers	*/
	RegGetOneRegister(handle,R_RCR);
	RegGetOneRegister(handle,R_MCR);
	
	return CalcMasterClkFrequency(handle,FieldGetVal(handle,STDBY),
									FieldGetVal(handle,DIRCLK),
									FieldGetVal(handle,K),
									FieldGetVal(handle,M),
									FieldGetVal(handle,P));	/*	Compute master clock freq	*/
}

/*****************************************************
**FUNCTION	::	CalcDerotatorFrequency
**ACTION	::	Compute Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
long CalcDerotatorFrequency(INT32 derotmsb,INT32 derotlsb, long fm)
{
	long dfreq;
	INT32 Itmp;
		
	Itmp = (derotmsb<<8)+derotlsb;
	dfreq =(((long)Itmp)*(fm/10000L))/65536L;
	dfreq *= 10;
	
	return dfreq; 
}

/*****************************************************
**FUNCTION	::	RegGetDerotatorFreq
**ACTION	::	Compute Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
long RegGetDerotatorFreq(DEMOD_HANDLE handle)
{

	/*	Read registers	*/
	RegGetRegisters(handle,R_CFRM,2);