📄 reg0299.c
字号:
RegExtClk = 4000000L; /* External Clock in Hz. */
#elif defined(STV0199_27MHZ)
RegExtClk = 27000000L; /* External Clock in Hz. */
#else
#error Must define STV0199_4MHZ or STV0199_27MHZ in makefile
#endif
/* REGISTER INITIALISATION */
/* ID */
AddReg(R_ID,"ID",0x00,0xA1);
AddField(R_ID,ID,"ID",0,8,UNSIGNED);
/* RCR */
AddReg(R_RCR,"RCR",0x01, 0x15 ); /* R(38) */
AddField(R_RCR,K,"K",6,2,UNSIGNED);
AddField(R_RCR,DIRCLK,"DIRCLK",5,1,UNSIGNED);
AddField(R_RCR,M,"M",0,5,UNSIGNED);
/* MCR */
AddReg(R_MCR,"MCR",0x02, 0x00 ); /* R(34) */
AddField(R_MCR,STDBY,"STDBY",7,1,UNSIGNED);
AddField(R_MCR,VCO,"VCO",6,1,UNSIGNED);
AddField(R_MCR,SERCLK,"SERCLK",3,1,UNSIGNED);
AddField(R_MCR,P,"P",0,3,UNSIGNED);
/* ACR */
AddReg(R_ACR,"ACR",0x03, 0x00 ); /* R(2A) */
AddField(R_ACR,ACR,"ACR",0,8,UNSIGNED);
/* F22RR */
AddReg(R_F22FR,"F22RR",0x04, 0x2A ); /* R(8E) */
AddField(R_F22FR,F22FR,"F22RR",0,8,UNSIGNED);
/* I2CRPT */
AddReg(R_I2CRPT,"I2CRPT",0x05, 0x0f /* 0x00 LP 260600 */ ); /* R(0F) */
AddField(R_I2CRPT,I2CT,"I2CT",7,1,UNSIGNED);
AddField(R_I2CRPT,SCLT,"SCLT",2,1,UNSIGNED);
AddField(R_I2CRPT,SDAT,"SDAT",0,1,UNSIGNED);
/* DACR1 */
AddReg(R_DACR1,"DACR1",0x06, 0x02 ); /* R(A2) */
AddField(R_DACR1,DACMODE,"DACMODE",5,3,UNSIGNED);
AddField(R_DACR1,DACMSB,"DACMSB",0,4,UNSIGNED);
/* DACR2 */
AddReg(R_DACR2,"DACR2",0x07,0x00);
AddField(R_DACR2,DACLSB,"DACLSB",0,8,UNSIGNED);
/* DISEQC */
AddReg(R_DISEQC,"DISEQC",0x08, 0x40 ); /* R(60) */
AddField(R_DISEQC,LOCKOUTPUT,"LOCKOUTPUT",6,2,UNSIGNED);
AddField(R_DISEQC,LOCKCONFIGURATION,"LOCKCONFIGURATION",5,1,UNSIGNED);
AddField(R_DISEQC,UNMODULATEDBURST,"UNMODULATEDBURST",2,1,UNSIGNED);
AddField(R_DISEQC,DISEQCMODE,"DISEQCMODE",0,2,UNSIGNED);
/* DISEQCFIFO */
AddReg(R_DISEQCFIFO,"DISEQCFIFO",0x09,0x00);
AddField(R_DISEQCFIFO,DISEQCFIFO,"DISEQCFIFO",0,8,UNSIGNED);
/* DISEQCSTATUS */
AddReg(R_DISEQCSTATUS,"DISEQCSTATUS",0x0A, 0x82 ); /* R(00) */
AddField(R_DISEQCSTATUS,INPORT,"INPUTPORT",7,1,UNSIGNED);
AddField(R_DISEQCSTATUS,SDATINPUTSTATE,"SDATINPUTSTATE",6,1,UNSIGNED);
AddField(R_DISEQCSTATUS,FIFOEMPTY,"FIFOEMPTY",1,1,UNSIGNED);
AddField(R_DISEQCSTATUS,FIFOFULL,"FIFOFULL",0,1,UNSIGNED);
/* RES */
AddReg(R_RES,"RES",0x0B,0x00);
AddField(R_RES,RESERVED,"RESERVED",0,8,UNSIGNED);
/* IOCFG */
AddReg(R_IOCFG,"IOCFG",0x0C, 0x51 ); /* R(F0) */
AddField(R_IOCFG,OP1CONTROL,"OP1CONTROL",7,1,UNSIGNED);
AddField(R_IOCFG,OP1VALUE,"OP1VALUE",6,1,UNSIGNED);
AddField(R_IOCFG,OP0CONTROL,"OP0CONTROL",5,1,UNSIGNED);
AddField(R_IOCFG,OP0VALUE,"OP0VALUE",4,1,UNSIGNED);
AddField(R_IOCFG,NYQUISTFILTER,"NYQUISTFILTER",1,2,UNSIGNED);
AddField(R_IOCFG,IQ,"IQ",0,1,UNSIGNED);
/* AGC1C */
AddReg(R_AGC1C,"AGC1C",0x0D, 0x81 ); /* 0x81 - VICKY - 290200 - changed to 0x82 according to eval report */
AddField(R_AGC1C,DCADJ,"DCADJ",7,1,UNSIGNED);
AddField(R_AGC1C,BETA_AGC1,"BETA_AGC1",0,3,UNSIGNED);
/* RTC */
AddReg(R_RTC,"RTC",0x0E,0x23);
AddField(R_RTC,ALPHA_TMG,"ALPHA_TMG",4,3,UNSIGNED);
AddField(R_RTC,BETA_TMG,"BETA_TMG",0,3,UNSIGNED);
/* AGC1R */
switch ( TunerGetType () )
{
case TNR_DST7900:
AddReg ( R_AGC1R,"AGC1R",0x0F, 0x92 ); /* 0x1A/0x54 - VICKY - 100200 - changed to 0x92 */
break;
case TNR_SU1200:
AddReg ( R_AGC1R,"AGC1R",0x0F, 0x92 ); /* 0x1A/0x54 - VICKY - 100200 - changed to 0x92 */
break;
default:
AddReg ( R_AGC1R,"AGC1R", 0x0F, 0x1A ); /* 0x1A/0x54 - VICKY - 100200 - changed to 0x92 */
break;
}
AddField(R_AGC1R,IAGC,"IAGC",7,1,UNSIGNED);
AddField(R_AGC1R,AGC1_REF,"AGC1_REF",0,6,UNSIGNED);
/* AGC2O */
AddReg(R_AGC2O,"AGC2O",0x10, 0x34 ); /* R(74) */
AddField(R_AGC2O,AGC2COEF,"AGC2COEF",5,3,UNSIGNED);
AddField(R_AGC2O,AGC2_REF,"AGC2_REF",0,5,UNSIGNED);
/* TLSR */
AddReg(R_TLSR,"TLSR",0x11, 0x84 ); /* R(88) */
AddField(R_TLSR,STEP_MINUS,"STEP_MINUS",4,4,UNSIGNED);
AddField(R_TLSR,STEP_PLUS,"STEP_PLUS",0,4,UNSIGNED);
/* CFD */
AddReg(R_CFD,"CFD",0x12, 0xB9 ); /* 0xB9- VICKY 060200 - changed to 0x39 for testing */
AddField(R_CFD,CFD_ALGO,"CFD_ALGO",7,1,UNSIGNED);
AddField(R_CFD,BETA_FC,"BETA_FC",4,3,UNSIGNED);
AddField(R_CFD,FDTC,"FDTC",2,2,UNSIGNED);
AddField(R_CFD,LDL,"LDL",0,2,UNSIGNED);
/* ACLC */
#ifndef USE_PHILIPS_ZIF
AddReg(R_ACLC,"ACLC",0x13, 0xBB ); /* 0x9B/0x88 - VICKY - 290200 - changed to 0xB5 according to eval report */
#else
AddReg(R_ACLC,"ACLC",0x13, 0xB5 ); /* Lp 13/10/00 - changed according to Philips tuner requirement*/
#endif
AddField(R_ACLC,DEROTATOR,"DEROTATOR",7,1,UNSIGNED);
AddField(R_ACLC,NOISEESTIMATORTIMECONSTANT,"NOISEESTIMATORTIMECONSTANT",4,2,UNSIGNED);
AddField(R_ACLC,ALPHA_CAR,"ALPHA_CAR",0,4,UNSIGNED);
/* BCLC */
#ifndef USE_PHILIPS_ZIF
AddReg(R_BCLC,"BCLC",0x14, 0x9E ); /* R(9E) */
#else
AddReg(R_BCLC,"BCLC",0x14, 0x8E ); /* Lp 13/10/00 - changed according to Philips tuner requirement */
#endif
AddField(R_BCLC,PHASE_DETECTOR_ALGO,"PHASE_DETECTOR_ALGO",6,2,UNSIGNED);
AddField(R_BCLC,BETA_CAR,"BETA_CAR",0,6,UNSIGNED);
/* CLDT */
AddReg(R_CLDT,"CLDT",0x15, 0xC9 /* 0xE3 */ ); /* 0xE3/0x14 - VICKY - 290200 - changed to C9 according to eval report */
AddField(R_CLDT,CLDT,"CLDT",0,8,SIGNED);
/* AGC1I */
AddReg(R_AGC1I,"AGC1I",0x16, 0x80 ); /* R(00) */
AddField(R_AGC1I,AGCINTEGRATORVALUE,"AGCINTEGRATORVALUE",0,8,SIGNED);
/* TLIR */
AddReg(R_TLIR,"TLIR",0x17, 0x18 ); /* R(00) */
AddField(R_TLIR,TLIR,"TLIR",0,8,UNSIGNED);
/* AGC2I1 */
AddReg(R_AGC2I1,"AGC2I1",0x18, 0xFF ); /* R(00) */
AddField(R_AGC2I1,AGC2INTEGRATORMSB,"AGC2INTEGRATORMSB",0,8,UNSIGNED);
/* AGC2I2 */
AddReg(R_AGC2I2,"AGC2I2",0x19, 0xFF ); /* R(00) */
AddField(R_AGC2I2,AGC2INTEGRATORLSB,"AGC2INTEGRATORLSB",0,8,UNSIGNED);
/* RTF */
AddReg(R_RTF,"RTF",0x1A, 0x82 ); /* R(00) */
AddField(R_RTF,RTF,"RTF",0,8,SIGNED);
/* VSTATUS */
AddReg(R_VSTATUS,"VSTATUS",0x1B,0x00);
AddField(R_VSTATUS,CF,"CF",7,1,UNSIGNED);
AddField(R_VSTATUS,PRF,"PRF",4,1,UNSIGNED);
AddField(R_VSTATUS,LK,"LK",3,1,UNSIGNED);
AddField(R_VSTATUS,CPR,"CPR",0,3,UNSIGNED);
/* CLDI */
AddReg(R_CLDI,"CLDI",0x1C, 0x7F ); /* R(00) */
AddField(R_CLDI,CLDI,"CLDI",0,8,SIGNED);
/* ERRCNT_HIGH */
AddReg(R_ERRCNT_HIGH,"ERRCNT_HIGH",0x1D,0x00);
AddField(R_ERRCNT_HIGH,ERRCNTMSB,"ERRCNTMSB",0,8,UNSIGNED);
/* ERRCNT_LOW */
AddReg(R_ERRCNT_LOW,"ERRCNT_LOW",0x1E,0x00);
AddField(R_ERRCNT_LOW,ERRCNTLSB,"ERRCNTLSB",0,8,UNSIGNED);
/* SFRH */
AddReg(R_SFRH,"SFRH",0x1F,0x00);
AddField(R_SFRH,SYMB_FREQH,"SYMB_FREQH",0,8,UNSIGNED);
/* SFRM */
AddReg(R_SFRM,"SFRM",0x20,0x00);
AddField(R_SFRM,SYMB_FREQM,"SYMB_FREQM",0,8,UNSIGNED);
/* SFRL */
AddReg(R_SFRL,"SRFL",0x21,0x00);
AddField(R_SFRL,SYMB_FREQL,"SYMB_FREQL",4,4,UNSIGNED);
/* CFRM */
AddReg(R_CFRM,"CFRM",0x22, 0x80 ); /* R(00) */
AddField(R_CFRM,DEROTATORFREQUENCYMSB,"DEROTATORFREQUENCYMSB",0,8,UNSIGNED);
/* CFRL */
AddReg(R_CFRL,"CFRL",0x23, 0x0B ); /* R(00) */
AddField(R_CFRL,DEROTATORFREQUENCYLSB,"DEROTATORFREQUENCYLSB",0,8,UNSIGNED);
/* NIRH */
AddReg(R_NIRH,"NIRH",0x24, 0x2B ); /* R(00) */
AddField(R_NIRH,NOISEINDICATORMSB,"NOISEINDICATORMSB",0,8,UNSIGNED);
/* NIRL */
AddReg(R_NIRL,"NIRL",0x25, 0x75 ); /* R(00) */
AddField(R_NIRL,NOISEINDICATORLSB,"NOISEINDICATORLSB",0,8,UNSIGNED);
/* VERROR */
AddReg(R_VERROR,"VERROR",0x26, 0x1A ); /* R(00) */
AddField(R_VERROR,ERRORRATE,"ERRORRATE",0,8,UNSIGNED);
/* FECM */
#if !defined(maly)
AddReg ( R_FECM, "FECM", 0x28, 0x00 ); /* 0x00/0x01 */ /* VICKY - 060200 - force output to be parrallel */
#else
AddReg ( R_FECM, "FECM", 0x28, 0x02 ); /* 0x00/0x01 */ /* VICKY - 060200 - force output to be serial */
#endif
AddField(R_FECM,FECMODE,"FECMODE",4,4,UNSIGNED);
AddField(R_FECM,OUTPUTTYPE,"OUTPUTTYPE",1,1,UNSIGNED);
AddField(R_FECM,OUTPUTIMPEDANCE,"OUTPUTIMPEDANCE",0,1,UNSIGNED);
/* VTH0 */
AddReg(R_VTH0,"VTH0",0x29, 0x1E ); /* 0x28 */ /* R(1E) */
AddField(R_VTH0,VTH0,"VTH0",0,8,UNSIGNED);
/* VTH1 */
AddReg(R_VTH1,"VTH1",0x2A, 0x14 ); /* R(1E) */
AddField(R_VTH1,VTH1,"VTH1",0,8,UNSIGNED);
/* VTH2 */
AddReg(R_VTH2,"VTH2",0x2B,0x0F);
AddField(R_VTH2,VTH2,"VTH2",0,8,UNSIGNED);
/* VTH3 */
AddReg(R_VTH3,"VTH3",0x2C,0x09);
AddField(R_VTH3,VTH3,"VTH3",0,8,UNSIGNED);
/* VTH4 */
AddReg(R_VTH4,"VTH4",0x2D,0x05);
AddField(R_VTH4,VTH4,"VTH4",0,8,UNSIGNED);
/* PR */
AddReg(R_PR,"PR",0x31,0x1F);
AddField(R_PR,RATE,"RATE",0,8,UNSIGNED);
/* VSEARCH */
AddReg(R_VSEARCH,"VSEARCH",0x32,0x19);
AddField(R_VSEARCH,SEARCHMODE,"SEARCHMODE",7,1,UNSIGNED);
AddField(R_VSEARCH,FREEZE,"FREEZE",6,1,UNSIGNED);
AddField(R_VSEARCH,SN,"SN",4,2,UNSIGNED);
AddField(R_VSEARCH,TO,"TO",2,2,UNSIGNED);
AddField(R_VSEARCH,H,"H",0,2,UNSIGNED);
/* RS */
AddReg(R_RS,"RS",0x33, 0xFC/*fe*/ ); /* 0xFC/ 0xF8 */ /* VICKY - 060200 - changed the output pol to be Hi-to-Lo */
AddField(R_RS,DEINTERLEAVER,"DEINTERLEAVER",7,1,UNSIGNED);
AddField(R_RS,SYNCHRO,"SYNCHRO",6,1,UNSIGNED);
AddField(R_RS,REEDSOLOMON,"REEDSOLOMON",5,1,UNSIGNED);
AddField(R_RS,DESCRAMBLER,"DESCRAMBLER",4,1,UNSIGNED);
AddField(R_RS,WRITEERRORBIT,"WRITEERRORBIT",3,1,UNSIGNED);
AddField(R_RS,BLOCKSYNCHRO,"BLOCKSYNCHRO",2,1,UNSIGNED);
AddField(R_RS,OUTPUTCLOCKPOLARITY,"OUTPUTCLOCKPOLARITY",1,1,UNSIGNED);
AddField(R_RS,OUTPUTCLOCKCONFIG,"OUTPUTCLOCKCONFIG",0,1,UNSIGNED);
/* ERRCNT */
AddReg(R_ERRCNT,"ERRCNT",0x34, 0x13 ); /* R(01) */
AddField(R_ERRCNT,ERRORMODE,"ERRORMODE",7,1,UNSIGNED);
AddField(R_ERRCNT,ERRORSOURCE,"ERRORSOURCE",4,2,UNSIGNED);
AddField(R_ERRCNT,NOE,"NOE",0,2,UNSIGNED);
/* TEST REGISTERS */
AddReg(R_TFEC1,"TFEC1",0x40, 0x00 ); /* R(01) */
AddField(R_TFEC1,TFEC1,"TFEC1",0,8,UNSIGNED);
AddReg(R_TFEC2,"TFEC2",0x41, 0x00 ); /* R(01) */
AddField(R_TFEC2,TFEC2,"TFEC2",0,8,UNSIGNED);
AddReg(R_TSTRAM1,"TSTRAM1",0x42, 0x00 ); /* R(01) */
AddField(R_TSTRAM1,TSTRAM1,"TSTRAM1",0,8,UNSIGNED);
AddReg(R_TSTRATE,"TSTRATE",0x43, 0x00 ); /* R(01) */
AddField(R_TSTRATE,TSTRATE,"TSTRATE",0,8,UNSIGNED);
AddReg(R_SELOUT,"SELOUT",0x44, 0x00 ); /* R(01) */
AddField(R_SELOUT,SELOUT,"SELOUT",0,8,UNSIGNED);
AddReg(R_FORCEIN,"FORCEIN",0x45, 0x00 ); /* R(01) */
AddField(R_FORCEIN,FORCEIN,"FORCEIN",0,8,UNSIGNED);
AddReg(R_TSRTESCK,"TSRTESCK",0x46, 0x00 ); /* R(01) */
AddField(R_TSRTESCK,TSRTESCK,"TSRTESCK",0,8,UNSIGNED);
AddReg(R_TSTOUT,"TSTOUT",0x47, 0x00 ); /* R(01) */
AddField(R_TSTOUT,TSTOUT,"TSTOUT",0,8,UNSIGNED);
AddReg(R_TSTR,"TSTR",0x48, 0x00 ); /* R(01) */
AddField(R_TSTR,TSTR,"TSTR",0,8,UNSIGNED);
AddReg(R_TAGC2,"TAGC2",0x49, 0x00 ); /* R(01) */
AddField(R_TAGC2,TAGC2,"TAGC2",0,8,UNSIGNED);
AddReg(R_TCTL,"TCTL",0x4A, 0x00 ); /* R(01) */
AddField(R_TCTL,TCTL,"TCTL",0,8,UNSIGNED);
AddReg(R_TCTL2,"TCTL2",0x4B, 0x00 ); /* R(01) */
AddField(R_TCTL2,TCTL2,"TCTL2",0,8,UNSIGNED);
AddReg(R_TAGC1,"TAGC1",0x4C, 0x00 ); /* R(01) */
AddField(R_TAGC1,TAGC1,"TAGC1",0,8,UNSIGNED);
AddReg(R_TSTFIFO,"TSTFIFO",0x4D, 0x00 ); /* R(01) */
AddField(R_TSTFIFO,TSTFIFO,"TSTFIFO",0,8,UNSIGNED);
AddReg(R_TSTVCO,"TSTVCO",0x4E, 0x00 ); /* R(01) */
AddField(R_TSTVCO,TSTVCO,"TSTVCO",0,8,UNSIGNED);
AddReg(R_GHOST,"GHOST",0x4F, 0x00 ); /* R(01) */
AddField(R_GHOST,GHOST,"GHOST",0,8,UNSIGNED);
RegReset();
}
/*****************************************************
**FUNCTION :: PowOf2
**ACTION :: Compute 2^n (where n is an integer)
**PARAMS IN :: number -> n
**PARAMS OUT:: NONE
**RETURN :: 2^n
*****************************************************/
long PowOf2(int number)
{
int 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(long _Value)
{
RegExtClk = _Value;
}
/*****************************************************
**FUNCTION :: RegGetExtClk
**ACTION :: Get the external clock value
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: External clock value
*****************************************************/
long RegGetExtClk(void)
{
return (RegExtClk);
}
/*****************************************************
**FUNCTION :: CalcRefFrequency
**ACTION :: Compute reference frequency
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: Reference frequency
*****************************************************/
long CalcRefFrequency(int k)
{
return (RegGetExtClk()/(k+1));
}
/*****************************************************
**FUNCTION :: CalcVCOFrequency
**ACTION :: Compute VCO frequency
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: VCO frequency
*****************************************************/
long CalcVCOFrequency(int k,int m)
{
return (CalcRefFrequency(k)*4*(m+1));
}
/*****************************************************
**FUNCTION :: RegGetVCOFreq
**ACTION :: Read registers and compute VCO frequency
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: VCO frequency
*****************************************************/
long RegGetVCOFreq(void)
{
/* Read register */
RegGetOneRegister(R_RCR);
return CalcVCOFrequency(FieldGetVal(K),FieldGetVal(M)); /* compute VCO freq */
}
/*****************************************************
**FUNCTION :: CalcF22Frequency
**ACTION :: Compute F22 frequency
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: F22 frequency
*****************************************************/
long CalcF22Frequency(int k,int m,int f22)
{
return (f22!=0) ? (CalcVCOFrequency(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(void)
{
/* Read registers */
RegGetOneRegister(R_RCR);
RegGetOneRegister(R_F22FR);
return CalcF22Frequency(FieldGetVal(K),
FieldGetVal(M),
FieldGetVal(F22FR)); /* Compute F22 freq */
}
/*****************************************************
**FUNCTION :: CalcMasterClkFrequency
**ACTION :: Compute Master clock frequency
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: Master Clock frequency
*****************************************************/
long CalcMasterClkFrequency(int stdby ,int dirclk ,int k ,int m, int p)
{
long
mclk;
if(stdby)
mclk=0;
else if(dirclk)
mclk=RegGetExtClk();
else
mclk=CalcVCOFrequency(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(void)
{
/* Read registers */
RegGetOneRegister(R_RCR);
RegGetOneRegister(R_MCR);
return CalcMasterClkFrequency(FieldGetVal(STDBY),
FieldGetVal(DIRCLK),
FieldGetVal(K),
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -