开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
tcmu30311.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：126k
源码类别：

DVD

开发平台：

C/C++

tcmu30311.c：源码内容
  1. #include <gendef.h>    /* Generic Definitions system wide */
  2. #include <osp.h> 
  3. #include <i2c.h>     /* For I2C communication with the NIM */
  4. #include <dmd.h>        /* Macros, protos for demodulator interface */
  5. #include "tcmu30311.h"
  7. #define SUCCESS RETOK
  8. #define FAILURE RETFIAL1
  10. static UINT32 i2c_dmd_handle; /* stv0297 i2c handle */
  11. static UINT32 i2c_pll_handle; /* tuner i2c handle */
  13. static INT32   count;
  15. static  UINT32 InputQAMSize_MODE=64;
  16. static float InputFrequency ;   //Unit MHz 400.MHz
  17. static UINT32 InputSR ; //Unit KHz SR = 6.5Msps -> 6500
  18. static INT32 InputQAMSize; // 16,32,64,128,256
  19. static  KB_DMDModulation qam_mode;
  21. static INT32 _ExtClk; /* MasterClock */
  22. static FLAG_SAM RegTrigger;
  23. static INT32 RegNbI2cAccess;
  24. static FLAG_SAM RegTracking;
  25. static INT32 RegQAMSize;
  26. static INT32 RegSymbolRate;
  27. static FLAG_SAM Driv0297DataLost;
  28. static FLAG_SAM Driv0297DataLocked;
  29. static SIGNAL Driv0297Signal;
  30. static REGISTER RegMap [NBREG];
  31. static FIELD FieldMap[NBFIELD];
  34. static KB_DMDTunerParameters *TransponderCopy = NULL;
  35. #define QAM0297   0x00000297
  37. #define Tuner_Samsung 0x00030311
  38. #define Tuner_Thomson 0x00008722
  40. #define QAM0297_Revision 0x20
  42. #define Sysclk 57840000 //STV0297系统时钟频率 
  43. UINT32 SAMSignalVAGC(void);
  44. #define TUNER_PRINT_DEBUG 0
  46. UINT16  EXT_CLK=2880;
  48. static UINT32 SAMReadReg(UINT32 whichReg);
  49. int CheckInversion(void);
  51. /******************************************
  52. **函数名：SAMInit
  53. **输入：  无
  54. **输出：  无
  55. **功能：  初始化TCMU30311
  56. ********************************************/
  57. void SAMInit(KB_DMDTunerParameters *pParam)
  58. {
  59. TransponderCopy = pParam;
  60. QAM_Init();
  61. }
  62. UINT16 RegGetAGC2(void)
  63.   {
  64. UINT16 val=0;
  66. val = RegGetField(AGC2SD_LO);
  67. val += RegGetField(AGC2SD_HI)<<8;
  68. return(val);
  69.   }
  70. UINT32 SAMSignalVAGC(void)
  71. {
  72.    UINT32 value=0;
  73.    value=(unsigned short)(1000-(UINT16)RegGetAGC2()*1000/0x3ff);
  74.    if(value>300)  value-=10;
  75.      else if((value<20)&&(SAMCheckLock()))
  76.        value=(unsigned short)(RegGetAGC2()/8);
  77.    value/=4;       
  78.    return(value);
  79. }
  82. struct SigMap_t2
  83. {
  84. int agc;
  85. int dbuv;
  86. } g_sigmap[78] =
  87. {
  88. {117 , 301},
  89. {118, 308},
  90. {120, 314},
  91. {122, 322},
  92. {124, 331},
  93. {127, 341},
  94. {130, 354},
  95. {131, 358},
  96. {133, 369},
  97. {135, 377},
  98. {136, 380},
  99. {138, 391},
  100. {140, 399},
  101. {141, 408},
  102. {143, 418},
  103. {145, 429},
  104. {147, 439},
  105. {149, 454},
  106. {150, 459},
  107. {152, 468},
  108. {154, 478},
  109. {155, 491},
  110. {157, 500},
  111. {160, 502},
  112. {164, 505},
  113. {168, 507},
  114. {170, 507},
  115. {173, 509},
  116. {176, 509},
  117. {177, 511},
  118. {178, 512},
  119. {179, 513},
  120. {180, 513},
  121. {185, 522},
  122. {187, 534},
  123. {189, 544},
  124. {190, 557},
  125. {191, 563},
  126. {192, 583},
  127. {193, 593},
  128. {194, 611},
  129. {195, 628},
  130. {196, 649},
  131. {197, 663},
  132. {198, 678},
  133. {199, 687},
  134. {200, 701},
  135. {201, 711},
  136. {202, 731},
  137. {203, 740},
  138. {204, 751},
  139. {206, 764},
  140. {207, 770},
  141. {208, 780},
  142. {209, 789},
  143. {211, 802},
  144. {213, 811},
  145. {215, 820},
  146. {216, 830},
  147. {218, 839},
  148. {221, 851},
  149. {224, 865},
  150. {225, 871},
  151. {227, 880},
  152. {229, 890},
  153. {231, 902},
  154. {233, 912},
  155. {234, 920},
  156. {236, 930},
  157. {237, 942},
  158. {238, 951},
  159. {240, 966},
  160. {241, 971},
  161. {242, 980},
  162. {243, 991},
  163. {245, 1001},
  164. {246, 1011},
  165. {247, 1021},
  167. };
  168. //在要获取信号电平时先调用SAMSignalVAGC（），然后将返回直带入下面函数
  169. //信号质量直接调用SAMReadNoise（）
  171. INT32 QamagcToDbuv(UINT32 nQamagc)
  172. {
  173.     int ret = 0;
  174. int i;
  176. for(i = 0;i< 78;i++)
  177. {
  178. if(g_sigmap[i].agc >= nQamagc)
  179. {
  180. ret = g_sigmap[i].dbuv;
  181. break;
  182. }
  183. }
  185. return ret;
  186. }
  187. /******************************************
  188. **函数名：SAMCalSAMlateVAFC
  189. **输入：  无
  190. **输出：  频偏KHz
  191. **功能：  在载波恢复时计算频偏
  192. ********************************************/
  193. INT32 SAMCalSAMlateVAFC(void)
  194. {
  195. INT32 temp;
  196.     SAMWriteReg(STV_CRL_11,0xff);
  197. temp   = SAMReadReg(STV_CRL_6);
  198. temp  += SAMReadReg(STV_CRL_7)<<8;
  199. temp  += SAMReadReg(STV_CRL_8)<<16;
  200. temp  += (SAMReadReg(STV_CRL_9)& 0x0f)<<24;
  201. if (temp >= 0x08000000)
  202. {
  203.    temp -= 0x10000000 ; // 0x10000000 = 2**28  
  204. }
  205. temp /= 2684354L ;  // (2**28)/100 = 268435456/100
  206. return(temp);
  207. }
  208. UINT32 SAMReadBER(void)
  209. { 
  210.   UINT16 _ErrMode=0,err_hi0, err_lo0 , err_hi1 , err_lo1 ;
  211.    UINT16    BER ;
  212.    INT32    int_tmp,powt;
  213.    float double_tmp ;
  214.    UINT32 NByte ;
  215.    UINT8 times=0,Trackinglock=0; 
  216.    UINT32 BlocksBertBER       ;
  217.       
  218. RegSetField(NBYTE,4);
  219.       
  220.    while((times<10)&&(Trackinglock==0))                      
  221.      {
  222.    Trackinglock += RegGetField(SYNCSTATE) ;        
  223.       times++;
  224.     }
  225.  
  226.    if(Trackinglock==0)
  227.    { 
  228.       return(99999999);
  229.    }
  230.    err_hi0 = RegGetField(ERRCOUNT_HI) ;
  231.    err_lo0 = RegGetField(ERRCOUNT_LO) ;
  232.    err_hi1 = RegGetField(ERRCOUNT_HI) ;
  233.    err_lo1 = RegGetField(ERRCOUNT_LO) ;
  234.    if(err_hi0 == err_hi1)
  235.      BER = err_lo0 + (err_hi0 <<8) ;
  236.    else
  237.      BER = err_lo1 + (err_hi1 <<8) ;
  238.   if(_ErrMode == 0)
  239.      {
  240.       if(RegGetField(BERT_ON) == 0)
  241.  {
  242.   double_tmp = (float)BER ;
  243.   int_tmp = RegGetField(NBYTE) ;
  244.   NByte=1;powt=0;
  245.   while(powt<2*int_tmp + 12)
  246.     {
  247.      NByte=NByte*2;
  248.      powt++; 
  249.     }
  250.     
  251.   if(RegGetField(ERR_SOURCE) == 0)
  252.   {
  253.    double_tmp /= (8*NByte) ;
  254.   }
  255.   else
  256.   {
  257.   double_tmp /= NByte ;
  258.   }
  259.     BlocksBertBER = double_tmp*1000000000 ;
  260.     RegSetField(BERT_ON,1) ;
  261.  } 
  262.         if(SAMSignalVAGC()<44)
  263.           BlocksBertBER=78000000;
  264.       return (BlocksBertBER);  
  265.         
  266.      } 
  267.    return (BlocksBertBER);
  268. }
  270. UINT32 SAMReadNoise(void)
  271. {UINT32 NoiseVal;/*Add ,TestNoiseVal the testing function*/
  272.  NoiseVal=SAMReadReg(STV_EQU_8);
  273.   NoiseVal=NoiseVal<<8;
  274.  //TestNoiseVal=SAMReadReg(STV_EQU_7);
  275.    NoiseVal|=(SAMReadReg(STV_EQU_7)&0xff);
  276.   //Print("The output signal quality is %ld %xn",TestNoiseVal,NoiseVal);
  278.  //Print("The output signal quality is %ldn",NoiseVal);
  279.  
  280.  if(NoiseVal>12000)
  281.   NoiseVal=12000;
  282.  if(NoiseVal<6000) 
  283.   NoiseVal=6000;
  284.  NoiseVal=12000-NoiseVal;
  285.  NoiseVal/=60;
  286.   //Print("The output signal quality is %ldn",NoiseVal);
  287.  return NoiseVal;
  288.  
  289. }
  291. int    Driv_RF_Level[101];
  292. void init_RF_Level(void)
  293. {
  294.  Driv_RF_Level[99] = 0;
  295.  Driv_RF_Level[98] = 15;   
  296.  Driv_RF_Level[97] = 30;
  297.  Driv_RF_Level[96] = 44;
  298.  Driv_RF_Level[95] = 57;
  299.  Driv_RF_Level[94] = 70;
  300.  Driv_RF_Level[93] = 83;
  301.  Driv_RF_Level[92] = 94;
  302.  Driv_RF_Level[91] = 105;
  303.  Driv_RF_Level[90] = 115;
  304.  Driv_RF_Level[89] = 125;
  305.  Driv_RF_Level[88] = 134;
  306.  Driv_RF_Level[87] = 143;
  307.  Driv_RF_Level[86] = 152;
  308.  Driv_RF_Level[85] = 160;
  309.  Driv_RF_Level[84] = 169;
  310.  Driv_RF_Level[83] = 177;
  311.  Driv_RF_Level[82] = 184;
  312.  Driv_RF_Level[81] = 191;
  313.  Driv_RF_Level[80] = 198;
  314.  Driv_RF_Level[79] = 205;
  315.  Driv_RF_Level[78] = 213;
  316.  Driv_RF_Level[77] = 221;
  317.  Driv_RF_Level[76] = 229;
  318.  Driv_RF_Level[75] = 236;
  319.  Driv_RF_Level[74] = 243;
  320.  Driv_RF_Level[73] = 250;
  321.  Driv_RF_Level[72] = 256;
  322.  Driv_RF_Level[71] = 263;
  323.  Driv_RF_Level[70] = 269;
  324.  Driv_RF_Level[69] = 275;
  325.  Driv_RF_Level[68] = 282;
  326.  Driv_RF_Level[67] = 289;
  327.  Driv_RF_Level[66] = 296;
  328.  Driv_RF_Level[65] = 302;
  329.  Driv_RF_Level[64] = 308;
  330.  Driv_RF_Level[63] = 314;
  331.  Driv_RF_Level[62] = 320;
  332.  Driv_RF_Level[61] = 325;
  333.  Driv_RF_Level[60] = 330;
  334.  Driv_RF_Level[59] = 335;
  335.  Driv_RF_Level[58] = 339;
  336.  Driv_RF_Level[57] = 344;
  337.  Driv_RF_Level[56] = 348;
  338.  Driv_RF_Level[55] = 352;
  339.  Driv_RF_Level[54] = 356;
  340.  Driv_RF_Level[53] = 360;
  341.  Driv_RF_Level[52] = 364;
  342.  Driv_RF_Level[51] = 368;
  343.  Driv_RF_Level[50] = 372;
  344.  Driv_RF_Level[49] = 375;
  345.  Driv_RF_Level[48] = 378;
  346.  Driv_RF_Level[47] = 381;
  347.  Driv_RF_Level[46] = 384;
  348.  Driv_RF_Level[45] = 387;
  349.  Driv_RF_Level[44] = 390;
  350.  Driv_RF_Level[43] = 392;
  351.  Driv_RF_Level[42] = 395;
  352.  Driv_RF_Level[41] = 397;
  353.  Driv_RF_Level[40] = 400;
  354.  Driv_RF_Level[39] = 402;
  355.  Driv_RF_Level[38] = 405;
  356.  Driv_RF_Level[37] = 408;
  357.  Driv_RF_Level[36] = 411;
  358.  Driv_RF_Level[35] = 414;
  359.  Driv_RF_Level[34] = 417;
  360.  Driv_RF_Level[33] = 420;
  361.  Driv_RF_Level[32] = 423;
  362.  Driv_RF_Level[31] = 426;
  363.  Driv_RF_Level[30] = 429;
  364.  Driv_RF_Level[29] = 432;
  365.  Driv_RF_Level[28] = 435;
  366.  Driv_RF_Level[27] = 438;
  367.  Driv_RF_Level[26] = 441;
  368.  Driv_RF_Level[25] = 444;
  369.  Driv_RF_Level[24] = 455;
  370.  Driv_RF_Level[23] = 465;
  371.  Driv_RF_Level[22] = 480;
  372.  Driv_RF_Level[21] = 500;
  373.  Driv_RF_Level[20] = 520;
  374.  Driv_RF_Level[19] = 540;
  375.  Driv_RF_Level[18] = 560;
  376.  Driv_RF_Level[17] = 580;
  377.  Driv_RF_Level[16] = 600;
  378.  Driv_RF_Level[15] = 620;
  379.  Driv_RF_Level[14] = 640;
  380.  Driv_RF_Level[13] = 660;
  381.  Driv_RF_Level[12] = 680;
  382.  Driv_RF_Level[11] = 700;
  383.  Driv_RF_Level[10] = 720;
  384.  Driv_RF_Level[9] = 740;
  385.  Driv_RF_Level[8] = 760;
  386.  Driv_RF_Level[7] = 780;
  387.  Driv_RF_Level[6] = 805;
  388.  Driv_RF_Level[5] = 830;
  389.  Driv_RF_Level[4] = 855;
  390.  Driv_RF_Level[3] = 880;
  391.  Driv_RF_Level[2] = 910;
  392.  Driv_RF_Level[1] = 950;
  393.  Driv_RF_Level[0] = 1000;
  394.   
  395. }
  396.  /*{{{ Ber_counter ()*/
  397. int Ber_counter_counter = 0;
  398. int Ber_counter(void)
  399.     {
  400.  int iBer=0,iBerLow=0,iBerHigh=0;
  401.  return -1;
  402.  if(RegGetField( BERT_ON )==0)
  403.     {  
  404.   iBerLow=RegGetField( ERRCOUNT_LO );
  405.   iBerHigh=RegGetField( ERRCOUNT_HI );
  406.   RegSetField( ERRCOUNT_LO,0x00 );
  407.   RegSetField( ERRCOUNT_HI,0x00 );
  408.   RegSetField( BERT_ON,1 );
  409.   iBer=((iBerHigh&0x00ff)<<8 | (iBerLow&0x00ff))&0x0000ffff;
  410.   Ber_counter_counter++;
  411.   if(Ber_counter_counter>300)
  412.      {
  413.    Ber_counter_counter = 0;
  414.    //RegSTV0297reset() ;
  415. //   do_report_zmy(severity_info,"bern");
  416.    //RegResetAfterDI() ;
  417.   }
  418.   return iBer;
  419.      }
  420.      else
  421.      {
  422.   return -1;
  423.      }
  424.     }
  425. /*{{{ End Ber_counter ()*/
  426. static int ber_count = 0;
  427. static char signal_count = 0;
  428. static int strengh[4];
  429. static int quality[4];
  431. void ResetSignalArray(void)
  432. {
  433. int i;
  434. for(i=0; i<4; i++)
  435. {
  436. strengh[i]=0;
  437. quality[i]=0;
  438. }
  439. signal_count = 0;
  440. }
  441. boolean Check_Signal_Strenth_Quality(int *Signal_Strengh,int *Signal_Quality)
  442.           //int *Signal_BER_FixedPoint_Multiply_10,int *Signal_BER_Exponent)
  443. {
  444.  int ber_count_temp = 0;
  445.  int v_agc1,i;
  446.  int cn_value;
  447.  int *Signal_BER_FixedPoint_Multiply_10 = 0;
  448.  int *Signal_BER_Exponent = 0;
  449.  ber_count_temp = Ber_counter();
  450.  if(ber_count_temp != -1)
  451.  {
  452.   ber_count=ber_count_temp;
  453.  }
  454.  
  455.  if (0)
  456.  {
  457.   if(ber_count<1)
  458.   {
  459.    *Signal_BER_FixedPoint_Multiply_10 = 0;
  460.    *Signal_BER_Exponent = -8;
  461.   }
  462.   else if(ber_count<10)
  463.   {
  464.    *Signal_BER_FixedPoint_Multiply_10 = ber_count*10;
  465.    *Signal_BER_Exponent = -7;
  466.   }
  467.   else if(ber_count<83)
  468.   {
  469.    *Signal_BER_FixedPoint_Multiply_10 = (ber_count*100)/83;
  470.    *Signal_BER_Exponent = -6;
  471.   }
  472.   else if(ber_count<838)
  473.   {
  474.    *Signal_BER_FixedPoint_Multiply_10 = (ber_count*100)/838;
  475.    *Signal_BER_Exponent = -5;
  476.   }
  477.   else if(ber_count<8388)
  478.   {
  479.    *Signal_BER_FixedPoint_Multiply_10 = (ber_count*100)/8388;
  480.    *Signal_BER_Exponent = -4;
  481.   }
  482.   else if(ber_count<83886)
  483.   {
  484.    *Signal_BER_FixedPoint_Multiply_10 = (ber_count*100)/83886;
  485.    *Signal_BER_Exponent = -3;
  486.          }
  487.   else if(ber_count<838860)
  488.          {
  489.    *Signal_BER_FixedPoint_Multiply_10 = (ber_count*100)/838860;
  490.    *Signal_BER_Exponent = -2;
  491.          }
  492.   else if(ber_count<8388608)
  493.   {
  494.    *Signal_BER_FixedPoint_Multiply_10 = (ber_count*100)/8388608;
  495.    *Signal_BER_Exponent = -1;
  496.   }
  497.  }
  498.  v_agc1=(RegGetField(AGC2SD_HI)<<8) + RegGetField(AGC2SD_LO);
  499.  
  500.  for(i=99;i>0;i--)
  501.  {
  502.   if(v_agc1<Driv_RF_Level[i])
  503.    break;
  504.  }
  505.  if(v_agc1==0)
  506.  {
  507.   i=99;
  508.  }
  509.   printf("v_agc1 %d %dn",v_agc1,i);
  510.  *Signal_Strengh=i;
  511.  /*strengh[signal_count % 4] = i;
  512.  if (signal_count>=4)
  513.   *Signal_Strengh = (strengh[0]+strengh[1]+strengh[2]+strengh[3])/4;
  514.  else
  515.   *Signal_Strengh=i;*/
  516.  cn_value=(RegGetField(NOISE_EST_HI)<<8) + RegGetField(NOISE_EST_LO);
  517.  printf("v_agc1 %d %dn",v_agc1,cn_value);
  518.  
  519.  i = RegGetQAMSize()   ;
  520.  
  521.  switch(i)
  522.  {
  523.  case 16:
  524.   cn_value -= 1500;
  525.   break;
  526.  case 32:
  527.   cn_value -= 2200;
  528.   break;
  529.  case 64:
  530.   cn_value -= 2700;
  531.   break;
  532.  case 128:
  533.   cn_value -= 3600;
  534.   break;
  535.  case 256:
  536.   cn_value -= 5800;
  537.   break;
  538.  }
  539.  if(cn_value<0)
  540.    cn_value =0;
  541.  else
  542.  {
  543. if(cn_value>6500)
  544.   cn_value = 6500;
  545. cn_value = 6500 - cn_value;
  546. cn_value= cn_value*100/6500;
  547.  }
  548.  
  549.  if(cn_value>99)
  550.    cn_value=99;
  551.  *Signal_Quality = cn_value;
  552.  /*quality[signal_count % 4] = cn_value;
  554.  if (signal_count>=4)
  555.   *Signal_Quality = (quality[0]+quality[1]+quality[2]+quality[3])/4;
  556.  else
  557.   *Signal_Quality = cn_value;
  559.  signal_count++;*/
  560.  //cn_value -= ((((cn_value << 7) * (rand() % 100)) / 100) >> 7 );
  561.  //*Signal_Quality = 100 - ( 200000 - ((cn_value * 200000) / 100 ));
  562.  return FALSE;
  563. }
  565. UINT32 SAMReadSCOffset(void)
  566. {
  567. return(0);
  568. }
  569. UINT8 SAMReadUncor(void)
  570. {
  571. return(0);
  572. }
  573. INT32 SAMCheckLock(void)
  574. {
  575. UINT32 status=0,temp=0;
  576. while((temp<200)&&(status<2))
  577.   {status += ((SAMReadReg(STV_RS_DESC_15)&0x80)>>7);
  578.    temp++;
  579.   }
  580.   
  581. if(status) //读取SYNC寄存器的FEL位为HIGH表明QAM锁定，为低没锁定  
  582.     {
  583.    return (TRUE);
  584. }
  585. else
  586. {
  587. return (FALSE);
  588. }
  589. }
  591. void SAMReset(void)  
  592. {
  593. SAMWriteReg(STV_CTRL_1,1);
  594. SAMWriteReg(STV_CTRL_1,0);
  595. }
  596. void SAMStopConnect(void)
  597. {
  598. SAMReset();
  599. }
  600. void SAMSetQAMMode(UINT8 qammode)
  601. {
  602. UINT8 agcref,lockthr,mseth,aref,mode,temp;
  603. mode=qammode;
  604. SAMWriteReg(STV_CTRL_9,0x7f); 
  605. switch(mode)
  606. {
  607.      case 1 :      //SAM_QAM16
  608. SAMWriteReg(STV_EQU_0,0x08);
  609. SAMWriteReg(STV_EQU_1,0x58);
  610. SAMWriteReg(STV_STLOOP_3,0x04);
  611. SAMWriteReg(STV_DELAGC_7,0x60);
  612. SAMWriteReg(STV_WBAGC_11,0xe1);
  613. SAMWriteReg(STV_CRL_0,0x37);
  614. break;
  615. case 2 : //SAM_QAM32
  616. SAMWriteReg(STV_EQU_0,0x18);
  617. SAMWriteReg(STV_EQU_1,0x58);
  618. break;
  619. case 3 : //SAM_QAM64
  620. SAMWriteReg(STV_EQU_0,0x46);
  621. SAMWriteReg(STV_EQU_1,0x5a);
  622. break;
  623. case 4 : //SAM_QAM128
  624. SAMWriteReg(STV_EQU_0,0x28);
  625. SAMWriteReg(STV_EQU_1,0x58);
  626. SAMWriteReg(STV_WBAGC_11,0xfe);
  627. SAMWriteReg(STV_CRL_0,0x0d);
  628. SAMWriteReg(STV_CRL_1,0x4a);
  629. SAMWriteReg(STV_CRL_3,0x00);
  630. SAMWriteReg(STV_CRL_4,0x00);
  631. SAMWriteReg(STV_CRL_5,0x00);
  632. SAMWriteReg(STV_CRL_6,0x00);
  633. SAMWriteReg(STV_CRL_7,0xa5);
  634. SAMWriteReg(STV_CRL_8,0xf0);
  635. SAMWriteReg(STV_CRL_9,0x0f);
  636. break;
  637. case 5 : //SAM_QAM256
  638. SAMWriteReg(STV_EQU_0,0x38);
  639. SAMWriteReg(STV_EQU_1,0x58);
  640. SAMWriteReg(STV_WBAGC_11,0xff);
  641. SAMWriteReg(STV_CRL_0,0x0d);
  642. SAMWriteReg(STV_CRL_1,0x39);
  643. SAMWriteReg(STV_CRL_3,0x00);
  644. SAMWriteReg(STV_CRL_4,0x00);
  645. SAMWriteReg(STV_CRL_5,0x00);
  646. SAMWriteReg(STV_CRL_6,0x4c);
  647. SAMWriteReg(STV_CRL_7,0x7e);
  648. SAMWriteReg(STV_CRL_8,0xf6);
  649. SAMWriteReg(STV_CRL_9,0x0f);
  650. break;
  651. default :
  652. SAMWriteReg(STV_EQU_0,0x48);
  653. SAMWriteReg(STV_EQU_1,0x58);
  654. break;
  655. }
  656. }
  657. void SAMResetAll(void)  
  658. {
  659. SAMWriteReg(STV_CTRL_0,1);
  660. SAMWriteReg(STV_CTRL_0,0);
  661. }
  662. static UINT32 SAMReadReg(UINT32 whichReg)
  663. {
  664. INT32 nret;
  665.    UINT32 databyte=0;
  666.    UINT8  sout[1];
  668. sout[0] =(UINT8)(whichReg);
  669. if(KB_I2CWriteWithStop(i2c_dmd_handle, 1, sout) == RETOK)
  670. {
  671. if(KB_I2CReadWithStop(i2c_dmd_handle, 1, sout) == RETOK)
  672. {
  673. databyte = (UINT32)sout[0];
  674. }
  675. }
  676.     return(databyte);
  677. }
  678. INT32 SAMWriteReg( UINT32 whichReg,UINT32 writeValue)
  679. {
  680.     INT32 nret;
  681. UINT8  sout[2];
  683. sout[0] = (UINT8)(whichReg);
  684. sout[1] = (UINT8)(writeValue);
  686. nret = KB_I2CWriteWithStop(i2c_dmd_handle, 2, sout);
  687. if (RETOK== nret)
  688. {
  689. return(SUCCESS);
  690. }
  691. else
  692. {
  693. Print("[tcmu30311.c] SAMWriteReg(): write demod register fail.");
  694. //printf("-=whichReg=0x%x, writeValue=0x%x=-n", whichReg, writeValue);
  695. return (FAILURE);
  696. }
  697. }
  698. INT32 SAMStartConnect(void)
  699. {
  700. UINT32 temp,i;
  701. FLAG_SAM fSam;
  704. FLAG_SAM InputSpectrumInverse = AUTO;
  705. STTBX_Print(("[tcmu30311.c] SAMStartConnect():Fre=%d, SR=%d, QAM=%d.n",
  706.   TransponderCopy->frequency,
  707.   TransponderCopy->details.qam.symbolRatekSs,
  708.   TransponderCopy->details.qam.modulation));
  710. if((InputFrequency==(float)(TransponderCopy->frequency/1000)))
  711.   if(InputSR==(UINT32)(TransponderCopy->details.qam.symbolRatekSs))
  712.    if(qam_mode ==TransponderCopy->details.qam.modulation)
  713.    if(SAMReadReg(STV_RS_DESC_15)&0x80)
  714.    {
  715.       STTBX_Print(("[tcmu30311.c] SAMStartConnect(): Locked 1  :)n"));
  716.       return(TRUE);   
  717.    }
  718. InputFrequency=(float)(TransponderCopy->frequency/1000);
  719. InputSR=(UINT32)(TransponderCopy->details.qam.symbolRatekSs);
  721. if((InputFrequency == 0) || (InputSR == 0))
  722. {
  723. InputFrequency = 355;
  724.     InputSR = 6875;    
  725. }
  726. qam_mode = (TransponderCopy->details.qam.modulation);  
  727. switch(qam_mode)
  728. {
  729.     case QAM_16 :      //SAM_QAM16
  730. InputQAMSize = 16;
  731. break;
  732. case QAM_32 : //SAM_QAM32
  733. InputQAMSize = 32;
  734. break;
  736. case QAM_64 : //SAM_QAM64
  737. InputQAMSize = 64;
  738. break;
  740. case QAM_128 : //SAM_QAM128
  741. InputQAMSize = 128;
  742. break;
  744. case QAM_256 : //SAM_QAM256
  745. InputQAMSize = 256;
  746. break;
  748. default :
  749. InputQAMSize = 64;
  750. break;
  751. }
  753. InputQAMSize_MODE=InputQAMSize;
  754. fSam = Acquisition(InputFrequency,InputSR,InputQAMSize,InputSpectrumInverse);
  755. if (fSam == YES) 
  756.  {
  757.    CarrierStatusSetAcquisitionStatus();
  758. STTBX_Print(("[tcmu30311.c] SAMStartConnect(): Locked 2.n"));
  759.         return(TRUE);
  760.  }
  762. STTBX_Print(("[tcmu30311.c] SAMStartConnect(): unLocked.n"));
  763. return(FALSE);
  764. }
  765. UINT8 SAMRevision(void)
  766. {
  767. UINT8 Revision;
  768. Revision=SAMReadReg(STV_CTRL_0);
  769. return(Revision);
  770. }
  771. INT32 SAMSetTunerFrequency(UINT32 freq1)
  772. {
  773.     UINT8  value_data,temp;
  774.     UINT32 divide_rate,i,frequency;
  775.     UINT8 byte[4];
  776.   
  777.     UINT16  m_cnt;
  778.     float tuner_offset;
  779.     UINT8    TunerS[6]  ;
  781.     frequency=(UINT32)(freq1*1000); 
  782.    
  783.    
  784.    if(frequency>860000  || frequency<50000 )
  785.     { Print("nTuner frequency is %ldn",frequency);
  786.       Print("Tuner frequency is ERROR!n");
  787. return(FALSE);
  788.     }
  789.      
  790.   if((UINT16)EXT_CLK ==2880) /*Select thomson tuner*/
  791.    {
  792.     divide_rate=((frequency+36125)*10)/625;/*First_IF 36125 */
  793.     byte[0] = (UINT8) ((divide_rate & 0x00007f00) >> 8);
  794.     byte[1] = (UINT8) (divide_rate & 0x000000ff);
  795.     byte[2] = 0x8e;
  796.     if(frequency>=50000&&frequency<170000)
  797.     {
  798. byte[3]=0x01;  /* Tuner frequency is low band!*/
  799.     }
  800.     if(frequency>=170000&&frequency<468000)
  801.     {
  802. byte[3]=0x02; /* Tuner frequency is mid band!*/
  803.     }
  804.     if(frequency>=468000&&frequency<=860000)
  805.     {
  806. byte[3]=0x08; /* Tuner frequency is high band!*/
  807.     }
  808.     SAMWriteTunerReg(byte, IIC_TUNER_ADDRESS_TH);
  809.    }
  810.   else  /*Select thomson tuner*/
  811.    {
  812.     tuner_offset =(float) 36.125; /*PAL MHz */
  813.     if      (freq1 < 171.) TunerS[5] = 0x01;/*P0 = 1until   48.25 and 168.25*/
  814.       else if (freq1 < 468.) TunerS[5] = 0x02;/*P1 = 1 between 175.25 and 463.25*/
  815.       else if (freq1 < 960.) TunerS[5] = 0x08;/*P3 = 1 between 471.25 and 855.25*/
  816.     /*  else QAMPrint("Out of frequency range for tunern");*/
  817.     freq1 += tuner_offset;
  818.     m_cnt = (UINT16)(16.0 * freq1);
  820.     /* Compute tuner settings */
  821.     TunerS[1] = IIC_TUNER_ADDRESS_SAM;
  822.     TunerS[2] = (UINT8) 0x007f & (m_cnt >> 8);
  823.     TunerS[3] = (UINT8) 0x00ff & m_cnt;
  824.     TunerS[4] = (UINT8) 0x8E;    /*TCMU30311PTB new version*/
  825.     /* send this data */
  826.     /*I2cReadWrite(WRITE,TunerS[1],&TunerS[2],4); */
  827.     SAMWriteTunerReg(&TunerS[2], IIC_TUNER_ADDRESS_SAM);
  828.    
  829.    } 
  830. }
  832. INT32 SAMWriteTunerReg(UINT8 *cont,UINT8 DEMOD_ADD)
  833. {
  834.     //INT32 nret,temp;
  835. UINT8 sout[4];
  836. int i = 0;
  837. INT32 ret = RETFIAL1;
  838. //UINT8 i;
  839. sout[0] = cont[0];
  840. sout[1] = cont[1];
  841. sout[2] = cont[2];
  842. sout[3] = cont[3];
  844. while(i <= 3)
  845. {
  846. if(RETOK == KB_I2COpen(IIC_TUNER_ADDRESS_TH, &i2c_pll_handle))
  847. {
  848. SAMEnableIICTuner(); //打开TUNER的IIC
  849. ret = KB_I2CWriteWithStop(i2c_pll_handle, 4, sout);
  850. SAMDisableIICTuner(); //关闭TUNER的IIC
  851. if(ret == RETFIAL1)
  852. {
  853. i++;
  854. Print("[tcmu30311.c] SAMWriteTunerReg() :write to PLL. [%x] ================= n",i);
  855. }
  856. else
  857. {
  858. i = 10;
  859. }
  860. KB_I2CClose(i2c_pll_handle);
  861. }
  862. else
  863. {
  864. i ++;
  865. Print("+++++++++++++++++++++++++++++++++++++ error open iic pll n");
  866. }
  867. }
  868.    return(SUCCESS);
  869. }
  870. void SAMEnableIICTuner(void)
  871. {
  872. SAMWriteReg(STV_CTRL_7, 0x78);
  873. SAMWriteReg(STV_CTRL_6, 0xc8);
  874. }
  875. void SAMDisableIICTuner(void)
  876. {
  877. UINT32 temp;
  878. temp = SAMReadReg(STV_CTRL_6);
  879. temp = (temp & 0x7f);
  880. SAMWriteReg(STV_CTRL_6,temp);
  881. }
  883. UINT8 FieldCreateMask(INT32 field)
  884. {
  885. INT32 i;
  886. UINT8 mask=0;
  887. for (i = 0; i < FieldMap[field].Bits; i++)
  888. {
  889. mask <<= 1 ;
  890. mask +=  1 ;
  891. }
  892. mask = mask << FieldMap[field].Pos;
  893. return mask;
  894. }
  896. void RegSetOneRegister(INT32 reg_id, UINT8 Data)
  897. {
  898. SAMWriteReg(RegMap[reg_id].Addr,Data); //hcao
  899. RegMap[reg_id].Value=Data;
  900. return ;
  901. }
  903. INT32 RegGetOneRegister(INT32 reg_id)
  904. {
  905. RegMap[reg_id].Value=SAMReadReg(RegMap[reg_id].Addr);
  906.     return(RegMap[reg_id].Value) ;
  907. }
  909. void FieldSetVal(INT32 field, INT32 fieldval)
  910. {
  911. INT32 value;
  912. FIELD *pfield;
  913. pfield=&(FieldMap[field]);
  914. if(pfield->Type == SIGNED)
  915. fieldval = (fieldval > 0 ) ? fieldval : fieldval + (1<<pfield->Bits);
  916. fieldval = pfield->Mask & (fieldval << pfield->Pos);
  917. RegMap[pfield->Reg].Value = (RegMap[pfield->Reg].Value & (~pfield->Mask)) + fieldval;
  918. }
  920. void RegSetField(INT32 field,INT32 value)
  921. {
  922. INT32 valread;
  923. FIELD *pfield;
  924. pfield=&(FieldMap[field]);
  925. RegGetOneRegister(pfield->Reg);
  926. FieldSetVal(field,value);
  927. RegSetOneRegister(pfield->Reg,RegMap[pfield->Reg].Value);
  928. }
  930. INT32 FieldGetVal(INT32 field)
  931. {
  932. INT32 value;
  933. FIELD *pfield;
  934. pfield=&(FieldMap[field]);
  935. value= RegMap[pfield->Reg].Value;
  936. value=(RegMap[pfield->Reg].Value & pfield->Mask) >> pfield->Pos;
  937. if((pfield->Type == SIGNED)&&(value>=(1<<(pfield->Bits-1))))
  938. value = value - (1<<pfield->Bits);
  939. return value;
  940. }
  942. INT32 RegGetField(INT32 field)
  943. {
  944. INT32 mask = 0,
  945. val=0;
  946. FIELD *pfield;
  947. pfield=&(FieldMap[field]);
  948. RegGetOneRegister(pfield->Reg);
  949. return FieldGetVal(field);
  950. }
  952. void  QAM64_RegInit(void)
  953. {
  954. INT16 i;
  955. INT32 S32val;
  956. S32val = Driv0297Signal.QAMSize;
  957. /* EQU_0*/
  958. RegMap[EQU_0].Addr   = 0x00 ;
  959. RegMap[EQU_0].Reset  = 0x48 ;
  960. if(S32val == 16)
  961. RegMap[EQU_0].Reset  = 0x08 ;
  962. if(S32val == 32)
  963. RegMap[EQU_0].Reset  = 0x18 ;
  964. if(S32val == 64)
  965. RegMap[EQU_0].Value  = 0x48 ;  
  966. if(S32val == 128)
  967. RegMap[EQU_0].Value  = 0x28 ;  
  968. if(S32val == 256)
  969. RegMap[EQU_0].Value  = 0x38 ;  
  971. strcpy(RegMap[EQU_0].Name,"EQU_0") ;
  972. /* FIELDS*/
  973. strcpy(FieldMap[U_THRESHOLD].Name,"U_THRESHOLD") ;
  974. FieldMap[U_THRESHOLD].Reg  = EQU_0 ;
  975. FieldMap[U_THRESHOLD].Pos  = 0     ;
  976. FieldMap[U_THRESHOLD].Bits = 4     ;
  977. FieldMap[U_THRESHOLD].Type = UNSIGNED ;
  978. FieldMap[U_THRESHOLD].Mask = FieldCreateMask(U_THRESHOLD) ;
  979. strcpy(FieldMap[MODE_SELECT].Name,"MODE_SELECT") ;
  980. FieldMap[MODE_SELECT].Reg  = EQU_0 ;
  981. FieldMap[MODE_SELECT].Pos  = 4     ;
  982. FieldMap[MODE_SELECT].Bits = 3     ;
  983. FieldMap[MODE_SELECT].Type = UNSIGNED ;
  984. FieldMap[MODE_SELECT].Mask = FieldCreateMask(MODE_SELECT) ;
  985. /* EQU_1*/
  986. RegMap[EQU_1].Addr   = 0x01 ;
  987. RegMap[EQU_1].Reset  = 0x58 ;
  988. RegMap[EQU_1].Value  = 0x69 ;
  989. strcpy(RegMap[EQU_1].Name,"EQU_1") ;
  990. /* FIELDS*/
  991. strcpy(FieldMap[BLIND_U].Name,"BLIND_U") ;
  992. FieldMap[BLIND_U].Reg  = EQU_1 ;
  993. FieldMap[BLIND_U].Pos  = 0     ;
  994. FieldMap[BLIND_U].Bits = 4     ;
  995. FieldMap[BLIND_U].Type = UNSIGNED ;
  996. FieldMap[BLIND_U].Mask = FieldCreateMask(BLIND_U) ;
  997. strcpy(FieldMap[INITIAL_U].Name,"INITIAL_U") ;
  998. FieldMap[INITIAL_U].Reg  = EQU_1 ;
  999. FieldMap[INITIAL_U].Pos  = 4     ;
  1000. FieldMap[INITIAL_U].Bits = 4     ;
  1001. FieldMap[INITIAL_U].Type = UNSIGNED ;
  1002. FieldMap[INITIAL_U].Mask = FieldCreateMask(INITIAL_U) ;
  1003. /* EQU_2*/
  1004. RegMap[TST_EQU_2].Addr   = 0x02 ;
  1005. RegMap[TST_EQU_2].Reset  = 0x00 ;
  1006. RegMap[TST_EQU_2].Value  = 0x00 ;
  1007. strcpy(RegMap[TST_EQU_2].Name,"TEST:EQU_2") ;
  1008. /* EQU_3*/
  1009. RegMap[EQU_3].Addr   = 0x03 ;
  1010. RegMap[EQU_3].Reset  = 0x00 ;
  1011. RegMap[EQU_3].Value  = 0x00 ;
  1012. strcpy(RegMap[EQU_3].Name,"EQU_3") ;
  1013. /* FIELDS*/
  1014. strcpy(FieldMap[EQ_FSM_CTL].Name,"EQ_FSM_CTL") ;
  1015. FieldMap[EQ_FSM_CTL].Reg  = EQU_3 ;
  1016. FieldMap[EQ_FSM_CTL].Pos  = 0     ;
  1017. FieldMap[EQ_FSM_CTL].Bits = 2     ;
  1018. FieldMap[EQ_FSM_CTL].Type = UNSIGNED ;
  1019. FieldMap[EQ_FSM_CTL].Mask = FieldCreateMask(EQ_FSM_CTL) ;
  1020. /* FIELDS*/
  1021. strcpy(FieldMap[EQ_COEFF_CTL].Name,"EQ_COEFF_CTL") ;
  1022. FieldMap[EQ_COEFF_CTL].Reg  = EQU_3 ;
  1023. FieldMap[EQ_COEFF_CTL].Pos  = 2     ;
  1024. FieldMap[EQ_COEFF_CTL].Bits = 2     ;
  1025. FieldMap[EQ_COEFF_CTL].Type = UNSIGNED ;
  1026. FieldMap[EQ_COEFF_CTL].Mask = FieldCreateMask(EQ_COEFF_CTL) ;
  1027. /* EQU_4*/
  1028. RegMap[EQU_4].Addr   = 0x04 ;
  1029. RegMap[EQU_4].Reset  = 0x00 ;
  1030. RegMap[EQU_4].Value  = 0x00 ;
  1031. strcpy(RegMap[EQU_4].Name,"EQU_4") ;
  1032. /* FIELDS*/
  1033. strcpy(FieldMap[NBLIND].Name,"NBLIND") ;
  1034. FieldMap[NBLIND].Reg  = EQU_4 ;
  1035. FieldMap[NBLIND].Pos  = 0     ;
  1036. FieldMap[NBLIND].Bits = 1     ;
  1037. FieldMap[NBLIND].Type = UNSIGNED ;
  1038. FieldMap[NBLIND].Mask = FieldCreateMask(NBLIND) ;
  1039. /* EQU_7*/
  1040. RegMap[EQU_7].Addr   = 0x07 ;
  1041. RegMap[EQU_7].Reset  = 0x00 ;
  1042. RegMap[EQU_7].Value  = 0x00 ;
  1043. strcpy(RegMap[EQU_7].Name,"EQU_7") ;
  1044. /* FIELDS*/
  1045. strcpy(FieldMap[NOISE_EST_LO].Name,"NOISE_EST_LO") ;
  1046. FieldMap[NOISE_EST_LO].Reg  = EQU_7 ;
  1047. FieldMap[NOISE_EST_LO].Pos  = 0     ;
  1048. FieldMap[NOISE_EST_LO].Bits = 8     ;
  1049. FieldMap[NOISE_EST_LO].Type = UNSIGNED ;
  1050. FieldMap[NOISE_EST_LO].Mask = FieldCreateMask(NOISE_EST_LO) ;
  1051. /* EQU_8*/
  1052. RegMap[EQU_8].Addr   = 0x08 ;
  1053. RegMap[EQU_8].Reset  = 0x00 ;
  1054. RegMap[EQU_8].Value  = 0x00 ;
  1055. strcpy(RegMap[EQU_8].Name,"EQU_8") ;
  1056. /* FIELDS*/
  1057. strcpy(FieldMap[NOISE_EST_HI].Name,"NOISE_EST_HI") ;
  1058. FieldMap[NOISE_EST_HI].Reg  = EQU_8 ;
  1059. FieldMap[NOISE_EST_HI].Pos  = 0     ;
  1060. FieldMap[NOISE_EST_HI].Bits = 8     ;
  1061. FieldMap[NOISE_EST_HI].Type = UNSIGNED ;
  1062. FieldMap[NOISE_EST_HI].Mask = FieldCreateMask(NOISE_EST_HI) ;
  1063. /* INITDEM_0*/
  1064. RegMap[INITDEM_0].Addr   = 0x20 ;
  1065. RegMap[INITDEM_0].Reset  = 0x00 ;
  1066. RegMap[INITDEM_0].Value  = 0x00 ;
  1067. strcpy(RegMap[INITDEM_0].Name,"INITDEM_0") ;
  1068. /* FIELDS*/
  1069. strcpy(FieldMap[DEM_FQCY_LO].Name,"DEM_FQCY_LO") ;
  1070. FieldMap[DEM_FQCY_LO].Reg  = INITDEM_0 ;
  1071. FieldMap[DEM_FQCY_LO].Pos  = 0     ;
  1072. FieldMap[DEM_FQCY_LO].Bits = 8     ;
  1073. FieldMap[DEM_FQCY_LO].Type = UNSIGNED ;
  1074. FieldMap[DEM_FQCY_LO].Mask = FieldCreateMask(DEM_FQCY_LO) ;
  1075. /* INITDEM_1*/
  1076. RegMap[INITDEM_1].Addr   = 0x21 ;
  1077. RegMap[INITDEM_1].Reset  = 0x40 ;
  1078. RegMap[INITDEM_1].Value  = 0x00 ;
  1079. strcpy(RegMap[INITDEM_1].Name,"INITDEM_1") ;
  1080. /* FIELDS*/
  1081. strcpy(FieldMap[DEM_FQCY_HI].Name,"DEM_FQCY_HI") ;
  1082. FieldMap[DEM_FQCY_HI].Reg  = INITDEM_1 ;
  1083. FieldMap[DEM_FQCY_HI].Pos  = 0     ;
  1084. FieldMap[DEM_FQCY_HI].Bits = 8     ;
  1085. FieldMap[DEM_FQCY_HI].Type = UNSIGNED ;
  1086. FieldMap[DEM_FQCY_HI].Mask = FieldCreateMask(DEM_FQCY_HI) ;
  1087. FieldMap[DEM_FQCY_LO].Mask = FieldCreateMask(DEM_FQCY_LO) ;
  1088. /* INITDEM_2*/
  1089. RegMap[INITDEM_2].Addr   = 0x22 ;
  1090. RegMap[INITDEM_2].Reset  = 0x00 ;
  1091. RegMap[INITDEM_2].Value  = 0x00 ;
  1092. strcpy(RegMap[INITDEM_2].Name,"INITDEM_2") ;
  1093. /* FIELDS*/
  1094. strcpy(FieldMap[LATENCY].Name,"LATENCY") ;
  1095. FieldMap[LATENCY].Reg  = INITDEM_2 ;
  1096. FieldMap[LATENCY].Pos  = 0     ;
  1097. FieldMap[LATENCY].Bits = 8     ;
  1098. FieldMap[LATENCY].Type = UNSIGNED ;
  1099. FieldMap[LATENCY].Mask = FieldCreateMask(LATENCY) ;
  1100. /* INITDEM_3*/
  1101. RegMap[INITDEM_3].Addr   = 0x23 ;
  1102. RegMap[INITDEM_3].Reset  = 0x00 ;
  1103. RegMap[INITDEM_3].Value  = 0x00 ;
  1104. strcpy(RegMap[INITDEM_3].Name,"INITDEM_3") ;
  1105. /* FIELDS*/
  1106. strcpy(FieldMap[SCAN_STEP_LO].Name,"SCAN_STEP_LO") ;
  1107. FieldMap[SCAN_STEP_LO].Reg  = INITDEM_3 ;
  1108. FieldMap[SCAN_STEP_LO].Pos  = 0     ;
  1109. FieldMap[SCAN_STEP_LO].Bits = 8     ;
  1110. FieldMap[SCAN_STEP_LO].Type = UNSIGNED ;
  1111. FieldMap[SCAN_STEP_LO].Mask = FieldCreateMask(SCAN_STEP_LO) ;
  1112. /* INITDEM_4*/
  1113. RegMap[INITDEM_4].Addr   = 0x24 ;
  1114. RegMap[INITDEM_4].Reset  = 0x40 ;
  1115. RegMap[INITDEM_4].Value  = 0x40 ;
  1116. strcpy(RegMap[INITDEM_4].Name,"INITDEM_4") ;
  1117. /* FIELDS*/
  1118. strcpy(FieldMap[CHSCANITEN].Name,"CHSCANITEN") ;
  1119. FieldMap[CHSCANITEN].Reg  = INITDEM_4 ;
  1120. FieldMap[CHSCANITEN].Pos  = 7     ;
  1121. FieldMap[CHSCANITEN].Bits = 1     ;
  1122. FieldMap[CHSCANITEN].Type = UNSIGNED ;
  1123. FieldMap[CHSCANITEN].Mask = FieldCreateMask(CHSCANITEN) ;
  1124. /* FIELDS*/
  1125. strcpy(FieldMap[CHSCANITSOFT].Name,"CHSCANITSOFT") ;
  1126. FieldMap[CHSCANITSOFT].Reg  = INITDEM_4 ;
  1127. FieldMap[CHSCANITSOFT].Pos  = 6     ;
  1128. FieldMap[CHSCANITSOFT].Bits = 1     ;
  1129. FieldMap[CHSCANITSOFT].Type = UNSIGNED ;
  1130. FieldMap[CHSCANITSOFT].Mask = FieldCreateMask(CHSCANITSOFT) ;
  1131. /* FIELDS*/
  1132. strcpy(FieldMap[SCAN_STEP_HI].Name,"SCAN_STEP_HI") ;
  1133. FieldMap[SCAN_STEP_HI].Reg  = INITDEM_4 ;
  1134. FieldMap[SCAN_STEP_HI].Pos  = 0     ;
  1135. FieldMap[SCAN_STEP_HI].Bits = 6     ;
  1136. FieldMap[SCAN_STEP_HI].Type = UNSIGNED ;
  1137. FieldMap[SCAN_STEP_HI].Mask = FieldCreateMask(SCAN_STEP_HI) ;
  1138. /* INITDEM_5*/
  1139. RegMap[INITDEM_5].Addr   = 0x25 ;
  1140. RegMap[INITDEM_5].Reset  = 0x88 ;
  1141. RegMap[INITDEM_5].Value  = 0x08 ;
  1142. strcpy(RegMap[INITDEM_5].Name,"INITDEM_5") ;
  1143. /* FIELDS*/
  1144. strcpy(FieldMap[IN_DEMOD_EN].Name,"IN_DEMOD_EN") ;
  1145. FieldMap[IN_DEMOD_EN].Reg  = INITDEM_5 ;
  1146. FieldMap[IN_DEMOD_EN].Pos  = 7     ;
  1147. FieldMap[IN_DEMOD_EN].Bits = 1     ;
  1148. FieldMap[IN_DEMOD_EN].Type = UNSIGNED ;
  1149. FieldMap[IN_DEMOD_EN].Mask = FieldCreateMask(IN_DEMOD_EN) ;
  1150. /* FIELDS*/
  1151. strcpy(FieldMap[SCAN_ON].Name,"SCAN_ON") ;
  1152. FieldMap[SCAN_ON].Reg  = INITDEM_5 ;
  1153. FieldMap[SCAN_ON].Pos  = 6     ;
  1154. FieldMap[SCAN_ON].Bits = 1     ;
  1155. FieldMap[SCAN_ON].Type = UNSIGNED ;
  1156. FieldMap[SCAN_ON].Mask = FieldCreateMask(SCAN_ON) ;
  1157. /* FIELDS*/
  1158. strcpy(FieldMap[AUTOSTOP].Name,"AUTOSTOP") ;
  1159. FieldMap[AUTOSTOP].Reg  = INITDEM_5 ;
  1160. FieldMap[AUTOSTOP].Pos  = 5     ;
  1161. FieldMap[AUTOSTOP].Bits = 1     ;
  1162. FieldMap[AUTOSTOP].Type = UNSIGNED ;
  1163. FieldMap[AUTOSTOP].Mask = FieldCreateMask(AUTOSTOP) ;
  1164. /* FIELDS*/
  1165. strcpy(FieldMap[SCALE_A].Name,"SCALE_A") ;
  1166. FieldMap[SCALE_A].Reg  = INITDEM_5 ;
  1167. FieldMap[SCALE_A].Pos  = 4     ;
  1168. FieldMap[SCALE_A].Bits = 1     ;
  1169. FieldMap[SCALE_A].Type = UNSIGNED ;
  1170. FieldMap[SCALE_A].Mask = FieldCreateMask(SCALE_A) ;
  1171. /* FIELDS*/
  1172. strcpy(FieldMap[SCALE_B].Name,"SCALE_B") ;
  1173. FieldMap[SCALE_B].Reg  = INITDEM_5 ;
  1174. FieldMap[SCALE_B].Pos  = 2     ;
  1175. FieldMap[SCALE_B].Bits = 2     ;
  1176. FieldMap[SCALE_B].Type = UNSIGNED ;
  1177. FieldMap[SCALE_B].Mask = FieldCreateMask(SCALE_B) ;
  1178. /* DELAGC_0*/
  1179. RegMap[DELAGC_0].Addr   = 0x30 ;
  1180. RegMap[DELAGC_0].Reset  = 0xE6 ;
  1181. RegMap[DELAGC_0].Value  = 0x00 ;
  1182. strcpy(RegMap[DELAGC_0].Name,"DELAGC_0") ;
  1183. /* FIELDS*/
  1184. strcpy(FieldMap[AGC2MAX].Name,"AGC2MAX") ;
  1185. FieldMap[AGC2MAX].Reg  = DELAGC_0 ;
  1186. FieldMap[AGC2MAX].Pos  = 0     ;
  1187. FieldMap[AGC2MAX].Bits = 8     ;
  1188. FieldMap[AGC2MAX].Type = UNSIGNED ;
  1189. FieldMap[AGC2MAX].Mask = FieldCreateMask(AGC2MAX) ;
  1190. /* DELAGC_1*/
  1191. RegMap[DELAGC_1].Addr   = 0x31 ;
  1192. RegMap[DELAGC_1].Reset  = 0x91 ;
  1193. RegMap[DELAGC_1].Value  = 0x00 ;
  1194. strcpy(RegMap[DELAGC_1].Name,"DELAGC_1") ;
  1195. /* FIELDS*/
  1196. strcpy(FieldMap[AGC2MIN].Name,"AGC2MIN") ;
  1197. FieldMap[AGC2MIN].Reg  = DELAGC_1 ;
  1198. FieldMap[AGC2MIN].Pos  = 0     ;
  1199. FieldMap[AGC2MIN].Bits = 8     ;
  1200. FieldMap[AGC2MIN].Type = UNSIGNED ;
  1201. FieldMap[AGC2MIN].Mask = FieldCreateMask(AGC2MIN) ;
  1202. /* DELAGC_2*/
  1203. RegMap[DELAGC_2].Addr   = 0x32 ;
  1204. RegMap[DELAGC_2].Reset  = 0xFD ;
  1205. RegMap[DELAGC_2].Value  = 0x00 ;
  1206. strcpy(RegMap[DELAGC_2].Name,"DELAGC_2") ;
  1207. /* FIELDS*/
  1208. strcpy(FieldMap[AGC1MAX].Name,"AGC1MAX") ;
  1209. FieldMap[AGC1MAX].Reg  = DELAGC_2 ;
  1210. FieldMap[AGC1MAX].Pos  = 0     ;
  1211. FieldMap[AGC1MAX].Bits = 8     ;
  1212. FieldMap[AGC1MAX].Type = UNSIGNED ;
  1213. FieldMap[AGC1MAX].Mask = FieldCreateMask(AGC1MAX) ;
  1214. /* DELAGC_3*/
  1215. RegMap[DELAGC_3].Addr   = 0x33 ;
  1216. RegMap[DELAGC_3].Reset  = 0x44 ;
  1217. RegMap[DELAGC_3].Value  = 0x00 ;
  1218. strcpy(RegMap[DELAGC_3].Name,"DELAGC_3") ;
  1219. /* FIELDS*/
  1220. strcpy(FieldMap[AGC1MIN].Name,"AGC1MIN") ;
  1221. FieldMap[AGC1MIN].Reg  = DELAGC_3 ;
  1222. FieldMap[AGC1MIN].Pos  = 0     ;
  1223. FieldMap[AGC1MIN].Bits = 8     ;
  1224. FieldMap[AGC1MIN].Type = UNSIGNED ;
  1225. FieldMap[AGC1MIN].Mask = FieldCreateMask(AGC1MIN) ;
  1226. /* DELAGC_4*/
  1227. RegMap[DELAGC_4].Addr   = 0x34 ;
  1228. RegMap[DELAGC_4].Reset  = 0x29 ;
  1229. RegMap[DELAGC_4].Value  = 0x00 ;
  1230. strcpy(RegMap[DELAGC_4].Name,"DELAGC_4") ;
  1231. /* FIELDS*/
  1232. strcpy(FieldMap[RATIO_A].Name,"RATIO_A") ;
  1233. FieldMap[RATIO_A].Reg  = DELAGC_4 ;
  1234. FieldMap[RATIO_A].Pos  = 5     ;
  1235. FieldMap[RATIO_A].Bits = 3     ;
  1236. FieldMap[RATIO_A].Type = UNSIGNED ;
  1237. FieldMap[RATIO_A].Mask = FieldCreateMask(RATIO_A) ;
  1238. /* FIELDS*/
  1239. strcpy(FieldMap[RATIO_B].Name,"RATIO_B") ;
  1240. FieldMap[RATIO_B].Reg  = DELAGC_4 ;
  1241. FieldMap[RATIO_B].Pos  = 3     ;
  1242. FieldMap[RATIO_B].Bits = 2     ;
  1243. FieldMap[RATIO_B].Type = UNSIGNED ;
  1244. FieldMap[RATIO_B].Mask = FieldCreateMask(RATIO_B) ;
  1245. /* FIELDS*/
  1246. strcpy(FieldMap[RATIO_C].Name,"RATIO_C") ;
  1247. FieldMap[RATIO_C].Reg  = DELAGC_4 ;
  1248. FieldMap[RATIO_C].Pos  = 0     ;
  1249. FieldMap[RATIO_C].Bits = 3     ;
  1250. FieldMap[RATIO_C].Type = UNSIGNED ;
  1251. FieldMap[RATIO_C].Mask = FieldCreateMask(RATIO_C) ;
  1252. /* DELAGC_5*/
  1253. RegMap[DELAGC_5].Addr   = 0x35 ;
  1254. RegMap[DELAGC_5].Reset  = 0x8F ;
  1255. RegMap[DELAGC_5].Value  = 0x00 ;
  1256. strcpy(RegMap[DELAGC_5].Name,"DELAGC_5") ;
  1257. /* FIELDS*/
  1258. strcpy(FieldMap[AGC2_THRES].Name,"AGC2_THRES") ;
  1259. FieldMap[AGC2_THRES].Reg  = DELAGC_5 ;
  1260. FieldMap[AGC2_THRES].Pos  = 0     ;
  1261. FieldMap[AGC2_THRES].Bits = 8     ;
  1262. FieldMap[AGC2_THRES].Type = UNSIGNED ;
  1263. FieldMap[AGC2_THRES].Mask = FieldCreateMask(AGC2_THRES) ;
  1264. /* DELAGC_6*/
  1265. RegMap[DELAGC_6].Addr   = 0x36 ;
  1266. RegMap[DELAGC_6].Reset  = 0x80 ;
  1267. RegMap[DELAGC_6].Value  = 0x00 ;
  1268. strcpy(RegMap[DELAGC_6].Name,"DELAGC_6") ;
  1269. /* FIELDS*/
  1270. strcpy(FieldMap[DAGC_ON].Name,"DAGC_ON") ;
  1271. FieldMap[DAGC_ON].Reg  = DELAGC_6 ;
  1272. FieldMap[DAGC_ON].Pos  = 7     ;
  1273. FieldMap[DAGC_ON].Bits = 1     ;
  1274. FieldMap[DAGC_ON].Type = UNSIGNED ;
  1275. FieldMap[DAGC_ON].Mask = FieldCreateMask(DAGC_ON) ;
  1276. /* FIELDS*/
  1277. strcpy(FieldMap[FRZ2_CTRL].Name,"FRZ2_CTRL") ;
  1278. FieldMap[FRZ2_CTRL].Reg  = DELAGC_6 ;
  1279. FieldMap[FRZ2_CTRL].Pos  = 5     ;
  1280. FieldMap[FRZ2_CTRL].Bits = 2     ;
  1281. FieldMap[FRZ2_CTRL].Type = UNSIGNED ;
  1282. FieldMap[FRZ2_CTRL].Mask = FieldCreateMask(FRZ2_CTRL) ;
  1283. /* FIELDS*/
  1284. strcpy(FieldMap[FRZ1_CTRL].Name,"FRZ1_CTRL") ;
  1285. FieldMap[FRZ1_CTRL].Reg  = DELAGC_6 ;
  1286. FieldMap[FRZ1_CTRL].Pos  = 3     ;
  1287. FieldMap[FRZ1_CTRL].Bits = 2     ;
  1288. FieldMap[FRZ1_CTRL].Type = UNSIGNED ;
  1289. FieldMap[FRZ1_CTRL].Mask = FieldCreateMask(FRZ1_CTRL) ;
  1290. /* DELAGC_7*/
  1291. RegMap[DELAGC_7].Addr   = 0x37 ;
  1292. RegMap[DELAGC_7].Reset  = 0x70 ; 
  1293. RegMap[DELAGC_7].Value  = 0x00 ;
  1294. strcpy(RegMap[DELAGC_7].Name,"DELAGC_7") ;
  1295. /* FIELDS*/
  1296. strcpy(FieldMap[TIME_CST].Name,"TIME_CST") ;
  1297. FieldMap[TIME_CST].Reg  = DELAGC_7 ;
  1298. FieldMap[TIME_CST].Pos  = 4     ;
  1299. FieldMap[TIME_CST].Bits = 3     ;
  1300. FieldMap[TIME_CST].Type = UNSIGNED ;
  1301. FieldMap[TIME_CST].Mask = FieldCreateMask(TIME_CST) ;
  1302. /* FIELDS*/
  1303. strcpy(FieldMap[OVF_RATE_LO].Name,"OVF_RATE_LO") ;
  1304. FieldMap[OVF_RATE_LO].Reg  = DELAGC_7 ;
  1305. FieldMap[OVF_RATE_LO].Pos  = 0     ;
  1306. FieldMap[OVF_RATE_LO].Bits = 4     ;
  1307. FieldMap[OVF_RATE_LO].Type = UNSIGNED ;
  1308. FieldMap[OVF_RATE_LO].Mask = FieldCreateMask(OVF_RATE_LO) ;
  1309. /* FIELDS*/
  1310. strcpy(FieldMap[CORNER_RATE_LO].Name,"CORNER_RATE_LO") ;
  1311. FieldMap[CORNER_RATE_LO].Reg  = DELAGC_7 ;
  1312. FieldMap[CORNER_RATE_LO].Pos  = 0     ;
  1313. FieldMap[CORNER_RATE_LO].Bits = 4     ;
  1314. FieldMap[CORNER_RATE_LO].Type = UNSIGNED ;
  1315. FieldMap[CORNER_RATE_LO].Mask = FieldCreateMask(CORNER_RATE_LO) ;
  1316. /* DELAGC_8*/
  1317. RegMap[DELAGC_8].Addr   = 0x38 ;
  1318. RegMap[DELAGC_8].Reset  = 0x00 ;
  1319. RegMap[DELAGC_8].Value  = 0x00 ;
  1320. strcpy(RegMap[DELAGC_8].Name,"DELAGC_8") ;
  1321. /* FIELDS*/
  1322. strcpy(FieldMap[OVF_RATE_HI].Name,"OVF_RATE_HI") ;
  1323. FieldMap[OVF_RATE_HI].Reg  = DELAGC_8 ;
  1324. FieldMap[OVF_RATE_HI].Pos  = 0     ;
  1325. FieldMap[OVF_RATE_HI].Bits = 8     ;
  1326. FieldMap[OVF_RATE_HI].Type = UNSIGNED ;
  1327. FieldMap[OVF_RATE_HI].Mask = FieldCreateMask(OVF_RATE_HI) ;
  1328. /* FIELDS*/
  1329. strcpy(FieldMap[CORNER_RATE_HI].Name,"CORNER_RATE_HI") ;
  1330. FieldMap[CORNER_RATE_HI].Reg  = DELAGC_8 ;
  1331. FieldMap[CORNER_RATE_HI].Pos  = 0     ;
  1332. FieldMap[CORNER_RATE_HI].Bits = 8     ;
  1333. FieldMap[CORNER_RATE_HI].Type = UNSIGNED ;
  1334. FieldMap[CORNER_RATE_HI].Mask = FieldCreateMask(CORNER_RATE_HI) ;
  1335. /* WBAGC_0*/
  1336. RegMap[WBAGC_0].Addr   = 0x40 ;
  1337. RegMap[WBAGC_0].Reset  = 0x1A ;
  1338. RegMap[WBAGC_0].Value  = 0x1C ;
  1339. strcpy(RegMap[WBAGC_0].Name,"WBAGC_0") ;
  1340. /* FIELDS*/
  1341. strcpy(FieldMap[I_REF].Name,"I_REF") ;
  1342. FieldMap[I_REF].Reg  = WBAGC_0 ;
  1343. FieldMap[I_REF].Pos  = 0     ;
  1344. FieldMap[I_REF].Bits = 8     ;
  1345. FieldMap[I_REF].Type = UNSIGNED ;
  1346. FieldMap[I_REF].Mask = FieldCreateMask(I_REF) ;
  1347. /* WBAGC_1*/
  1348. RegMap[WBAGC_1].Addr   = 0x41 ;
  1349. RegMap[WBAGC_1].Reset  = 0x64 ;
  1350. RegMap[WBAGC_1].Value  = 0x00 ;
  1351. strcpy(RegMap[WBAGC_1].Name,"WBAGC_1") ;
  1352. /* FIELDS*/
  1353. strcpy(FieldMap[AGC2SD_LO].Name,"AGC2SD_LO") ;
  1354. FieldMap[AGC2SD_LO].Reg  = WBAGC_1 ;
  1355. FieldMap[AGC2SD_LO].Pos  = 0     ;
  1356. FieldMap[AGC2SD_LO].Bits = 8     ;
  1357. FieldMap[AGC2SD_LO].Type = UNSIGNED ;
  1358. FieldMap[AGC2SD_LO].Mask = FieldCreateMask(AGC2SD_LO) ;
  1359. /* WBAGC_2*/
  1360. RegMap[WBAGC_2].Addr   = 0x42 ;
  1361. RegMap[WBAGC_2].Reset  = 0x31 ;
  1362. RegMap[WBAGC_2].Value  = 0x02 ;
  1363. strcpy(RegMap[WBAGC_2].Name,"WBAGC_2") ;
  1364. /* FIELDS*/
  1365. strcpy(FieldMap[AGC2SD_HI].Name,"AGC2SD_HI") ;
  1366. FieldMap[AGC2SD_HI].Reg  = WBAGC_2 ;
  1367. FieldMap[AGC2SD_HI].Pos  = 0     ;
  1368. FieldMap[AGC2SD_HI].Bits = 2     ;
  1369. FieldMap[AGC2SD_HI].Type = UNSIGNED ;
  1370. FieldMap[AGC2SD_HI].Mask = FieldCreateMask(AGC2SD_HI) ;
  1372. strcpy(FieldMap[ACQ_THRESH].Name,"ACQ_THRESH") ;
  1373. FieldMap[ACQ_THRESH].Reg  = WBAGC_2 ;
  1374. FieldMap[ACQ_THRESH].Pos  = 2     ;
  1375. FieldMap[ACQ_THRESH].Bits = 4     ;
  1376. FieldMap[ACQ_THRESH].Type = UNSIGNED ;
  1377. FieldMap[ACQ_THRESH].Mask = FieldCreateMask(ACQ_THRESH) ;
  1378. /* WBAGC_3*/
  1379. RegMap[WBAGC_3].Addr   = 0x43 ;
  1380. RegMap[WBAGC_3].Reset  = 0x18 ;
  1381. RegMap[WBAGC_3].Value  = 0x20 ;
  1382. strcpy(RegMap[WBAGC_3].Name,"WBAGC_3") ;
  1383. /* FIELDS*/
  1384. strcpy(FieldMap[WAGC_CLR].Name,"WAGC_CLR") ;
  1385. FieldMap[WAGC_CLR].Reg  = WBAGC_3 ;
  1386. FieldMap[WAGC_CLR].Pos  = 6     ;
  1387. FieldMap[WAGC_CLR].Bits = 1     ;
  1388. FieldMap[WAGC_CLR].Type = UNSIGNED ;
  1389. FieldMap[WAGC_CLR].Mask = FieldCreateMask(WAGC_CLR) ;
  1390. /* FIELDS*/
  1391. strcpy(FieldMap[WAGC_INV].Name,"WAGC_INV") ;
  1392. FieldMap[WAGC_INV].Reg  = WBAGC_3 ;
  1393. FieldMap[WAGC_INV].Pos  = 5     ;
  1394. FieldMap[WAGC_INV].Bits = 1     ;
  1395. FieldMap[WAGC_INV].Type = UNSIGNED ;
  1396. FieldMap[WAGC_INV].Mask = FieldCreateMask(WAGC_INV) ;
  1397. /* FIELDS*/
  1398. strcpy(FieldMap[WAGC_EN].Name,"WAGC_EN") ;
  1399. FieldMap[WAGC_EN].Reg  = WBAGC_3 ;
  1400. FieldMap[WAGC_EN].Pos  = 4     ;
  1401. FieldMap[WAGC_EN].Bits = 1     ;
  1402. FieldMap[WAGC_EN].Type = UNSIGNED ;
  1403. FieldMap[WAGC_EN].Mask = FieldCreateMask(WAGC_EN) ;
  1404. /* FIELDS*/
  1405. strcpy(FieldMap[WAGC_ACQ].Name,"WAGC_ACQ") ;
  1406. FieldMap[WAGC_ACQ].Reg  = WBAGC_3 ;
  1407. FieldMap[WAGC_ACQ].Pos  = 3     ;
  1408. FieldMap[WAGC_ACQ].Bits = 1     ;
  1409. FieldMap[WAGC_ACQ].Type = UNSIGNED ;
  1410. FieldMap[WAGC_ACQ].Mask = FieldCreateMask(WAGC_ACQ) ;
  1411. /* FIELDS*/
  1412. strcpy(FieldMap[SWAP].Name,"SWAP") ;
  1413. FieldMap[SWAP].Reg  = WBAGC_3 ;
  1414. FieldMap[SWAP].Pos  = 2     ;
  1415. FieldMap[SWAP].Bits = 1     ;
  1416. FieldMap[SWAP].Type = UNSIGNED ;
  1417. FieldMap[SWAP].Mask = FieldCreateMask(SWAP) ;
  1418. /* WBAGC_4*/
  1419. RegMap[WBAGC_4].Addr   = 0x44 ;
  1420. RegMap[WBAGC_4].Reset  = 0xFF ;
  1421. RegMap[WBAGC_4].Value  = 0x00 ;
  1422. strcpy(RegMap[WBAGC_4].Name,"WBAGC_4") ;
  1423. /* FIELDS*/
  1424. strcpy(FieldMap[ROLL_LO].Name,"ROLL_LO") ;
  1425. FieldMap[ROLL_LO].Reg  = WBAGC_4 ;
  1426. FieldMap[ROLL_LO].Pos  = 0     ;
  1427. FieldMap[ROLL_LO].Bits = 8     ;
  1428. FieldMap[ROLL_LO].Type = UNSIGNED ;
  1429. FieldMap[ROLL_LO].Mask = FieldCreateMask(ROLL_LO) ;
  1430. /* WBAGC_5*/
  1431. RegMap[WBAGC_5].Addr   = 0x45 ;
  1432. RegMap[WBAGC_5].Reset  = 0x00 ;
  1433. RegMap[WBAGC_5].Value  = 0x00 ;
  1434. strcpy(RegMap[WBAGC_5].Name,"WBAGC_5") ;
  1435. /* FIELDS*/
  1436. strcpy(FieldMap[ACQ_COUNT_LO].Name,"ACQ_COUNT_LO") ;
  1437. FieldMap[ACQ_COUNT_LO].Reg  = WBAGC_5 ;
  1438. FieldMap[ACQ_COUNT_LO].Pos  = 0     ;
  1439. FieldMap[ACQ_COUNT_LO].Bits = 8     ;
  1440. FieldMap[ACQ_COUNT_LO].Type = UNSIGNED ;
  1441. FieldMap[ACQ_COUNT_LO].Mask = FieldCreateMask(ACQ_COUNT_LO) ;
  1442. /* WBAGC_6*/
  1443. RegMap[WBAGC_6].Addr   = 0x46 ;
  1444. RegMap[WBAGC_6].Reset  = 0x00 ;
  1445. RegMap[WBAGC_6].Value  = 0x00 ;
  1446. strcpy(RegMap[WBAGC_6].Name,"WBAGC_6") ;
  1447. /* FIELDS*/
  1448. strcpy(FieldMap[ACQ_COUNT_HI].Name,"ACQ_COUNT_HI") ;
  1449. FieldMap[ACQ_COUNT_HI].Reg  = WBAGC_6 ;
  1450. FieldMap[ACQ_COUNT_HI].Pos  = 0     ;
  1451. FieldMap[ACQ_COUNT_HI].Bits = 8     ;
  1452. FieldMap[ACQ_COUNT_HI].Type = UNSIGNED ;
  1453. FieldMap[ACQ_COUNT_HI].Mask = FieldCreateMask(ACQ_COUNT_HI) ;
  1454. /* WBAGC_9*/
  1455. RegMap[WBAGC_9].Addr   = 0x49 ;
  1456. RegMap[WBAGC_9].Reset  = 0x04 ;
  1457. RegMap[WBAGC_9].Value  = 0x04 ;
  1458. strcpy(RegMap[WBAGC_9].Name,"WBAGC_9") ;
  1459. /* FIELDS*/
  1460. strcpy(FieldMap[ROLL_HI].Name,"ROLL_HI") ;
  1461. FieldMap[ROLL_HI].Reg  = WBAGC_9 ;
  1462. FieldMap[ROLL_HI].Pos  = 0     ;
  1463. FieldMap[ROLL_HI].Bits = 8     ;
  1464. FieldMap[ROLL_HI].Type = UNSIGNED ;
  1465. FieldMap[ROLL_HI].Mask = FieldCreateMask(ROLL_HI) ;
  1466. /* WBAGC_10*/
  1467. RegMap[WBAGC_10].Addr   = 0x4A ;
  1468. RegMap[WBAGC_10].Reset  = 0x51 ;
  1469. RegMap[WBAGC_10].Value  = 0x00 ;
  1470. strcpy(RegMap[WBAGC_10].Name,"WBAGC_10") ;
  1471. /* FIELDS*/
  1472. strcpy(FieldMap[IF_PWM_LO].Name,"IF_PWM_LO") ;
  1473. FieldMap[IF_PWM_LO].Reg  = WBAGC_10 ;
  1474. FieldMap[IF_PWM_LO].Pos  = 0     ;
  1475. FieldMap[IF_PWM_LO].Bits = 8     ;
  1476. FieldMap[IF_PWM_LO].Type = UNSIGNED ;
  1477. FieldMap[IF_PWM_LO].Mask = FieldCreateMask(IF_PWM_LO) ;
  1478. /* FIELDS*/
  1479. strcpy(FieldMap[TARGET_RATE_LO].Name,"TARGET_RATE_LO") ;
  1480. FieldMap[TARGET_RATE_LO].Reg  = WBAGC_10 ;
  1481. FieldMap[TARGET_RATE_LO].Pos  = 0     ;
  1482. FieldMap[TARGET_RATE_LO].Bits = 8     ;
  1483. FieldMap[TARGET_RATE_LO].Type = UNSIGNED ;
  1484. FieldMap[TARGET_RATE_LO].Mask = FieldCreateMask(TARGET_RATE_LO) ;
  1485. /* WBAGC_11*/
  1486. RegMap[WBAGC_11].Addr   = 0x4B ;
  1487. RegMap[WBAGC_11].Reset  = 0xF8 ; /* orginal f8 */
  1488. RegMap[WBAGC_11].Value  = 0x00 ;
  1489. strcpy(RegMap[WBAGC_11].Name,"WBAGC_11") ;
  1490. /* FIELDS*/
  1491. strcpy(FieldMap[IF_PWM_HI].Name,"IF_PWM_HI") ;
  1492. FieldMap[IF_PWM_HI].Reg  = WBAGC_11 ;
  1493. FieldMap[IF_PWM_HI].Pos  = 0     ;
  1494. FieldMap[IF_PWM_HI].Bits = 8     ;
  1495. FieldMap[IF_PWM_HI].Type = UNSIGNED ;
  1496. FieldMap[IF_PWM_HI].Mask = FieldCreateMask(IF_PWM_HI) ;
  1497. /* FIELDS*/
  1498. strcpy(FieldMap[TARGET_RATE_HI].Name,"TARGET_RATE_HI") ;
  1499. FieldMap[TARGET_RATE_HI].Reg  = WBAGC_11 ;
  1500. FieldMap[TARGET_RATE_HI].Pos  = 0     ;
  1501. FieldMap[TARGET_RATE_HI].Bits = 8     ;
  1502. FieldMap[TARGET_RATE_HI].Type = UNSIGNED ;
  1503. FieldMap[TARGET_RATE_HI].Mask = FieldCreateMask(TARGET_RATE_HI) ;
  1504. /* STLOOP_2*/
  1505. RegMap[STLOOP_2].Addr   = 0x52 ;
  1506. RegMap[STLOOP_2].Reset  = 0x30 ;
  1507. RegMap[STLOOP_2].Value  = 0x00 ;
  1508. strcpy(RegMap[STLOOP_2].Name,"STLOOP_2") ;
  1509. /* FIELDS*/
  1510. strcpy(FieldMap[GAIN_SCALE_PATH0].Name,"GAIN_SCALE_PATH0") ;
  1511. FieldMap[GAIN_SCALE_PATH0].Reg  = STLOOP_2 ;
  1512. FieldMap[GAIN_SCALE_PATH0].Pos  = 5     ;
  1513. FieldMap[GAIN_SCALE_PATH0].Bits = 3     ;
  1514. FieldMap[GAIN_SCALE_PATH0].Type = UNSIGNED ;
  1515. FieldMap[GAIN_SCALE_PATH0].Mask = FieldCreateMask(GAIN_SCALE_PATH0) ;
  1516. /* FIELDS*/
  1517. strcpy(FieldMap[GAIN_SCALE_PATH1].Name,"GAIN_SCALE_PATH1") ;
  1518. FieldMap[GAIN_SCALE_PATH1].Reg  = STLOOP_2 ;
  1519. FieldMap[GAIN_SCALE_PATH1].Pos  = 2     ;
  1520. FieldMap[GAIN_SCALE_PATH1].Bits = 3     ;
  1521. FieldMap[GAIN_SCALE_PATH1].Type = UNSIGNED ;
  1522. FieldMap[GAIN_SCALE_PATH1].Mask = FieldCreateMask(GAIN_SCALE_PATH1) ;
  1523. /* FIELDS*/
  1524. strcpy(FieldMap[INTEGRAL_GAIN_HI].Name,"INTEGRAL_GAIN_HI") ;
  1525. FieldMap[INTEGRAL_GAIN_HI].Reg  = STLOOP_2 ;
  1526. FieldMap[INTEGRAL_GAIN_HI].Pos  = 0     ;
  1527. FieldMap[INTEGRAL_GAIN_HI].Bits = 2     ;
  1528. FieldMap[INTEGRAL_GAIN_HI].Type = UNSIGNED ;
  1529. FieldMap[INTEGRAL_GAIN_HI].Mask = FieldCreateMask(INTEGRAL_GAIN_HI) ;
  1530. /* STLOOP_3*/
  1531. RegMap[STLOOP_3].Addr   = 0x53 ;
  1532. RegMap[STLOOP_3].Reset  = 0x06 ; 
  1533. RegMap[STLOOP_3].Value  = 0x00 ;
  1534. strcpy(RegMap[STLOOP_3].Name,"STLOOP_3") ;
  1535. /* FIELDS*/
  1536. strcpy(FieldMap[DIRECT_GAIN_LO].Name,"DIRECT_GAIN_LO") ;
  1537. FieldMap[DIRECT_GAIN_LO].Reg  = STLOOP_3 ;
  1538. FieldMap[DIRECT_GAIN_LO].Pos  = 0     ;
  1539. FieldMap[DIRECT_GAIN_LO].Bits = 8     ;
  1540. FieldMap[DIRECT_GAIN_LO].Type = UNSIGNED ;
  1541. FieldMap[DIRECT_GAIN_LO].Mask = FieldCreateMask(DIRECT_GAIN_LO) ;
  1542. /* STLOOP_5*/
  1543. RegMap[STLOOP_5].Addr   = 0x55 ;
  1544. RegMap[STLOOP_5].Reset  = 0x6a ;
  1545. RegMap[STLOOP_5].Value  = 0x00 ;
  1546. strcpy(RegMap[STLOOP_5].Name,"STLOOP_5") ;
  1547. /* FIELDS*/
  1548. strcpy(FieldMap[SYMB_RATE_0].Name,"SYMB_RATE_0") ;
  1549. FieldMap[SYMB_RATE_0].Reg  = STLOOP_5 ;
  1550. FieldMap[SYMB_RATE_0].Pos  = 0     ;
  1551. FieldMap[SYMB_RATE_0].Bits = 8     ;
  1552. FieldMap[SYMB_RATE_0].Type = UNSIGNED ;
  1553. FieldMap[SYMB_RATE_0].Mask = FieldCreateMask(SYMB_RATE_0) ;
  1554. /* STLOOP_6*/
  1555. RegMap[STLOOP_6].Addr   = 0x56 ;
  1556. RegMap[STLOOP_6].Reset  = 0xA3 ;
  1557. RegMap[STLOOP_6].Value  = 0x00 ;
  1558. strcpy(RegMap[STLOOP_6].Name,"STLOOP_6") ;
  1559. /* FIELDS*/
  1560. strcpy(FieldMap[SYMB_RATE_1].Name,"SYMB_RATE_1") ;
  1561. FieldMap[SYMB_RATE_1].Reg  = STLOOP_6 ;
  1562. FieldMap[SYMB_RATE_1].Pos  = 0     ;
  1563. FieldMap[SYMB_RATE_1].Bits = 8     ;
  1564. FieldMap[SYMB_RATE_1].Type = UNSIGNED ;
  1565. FieldMap[SYMB_RATE_1].Mask = FieldCreateMask(SYMB_RATE_1) ;
  1566. /* STLOOP_7*/
  1567. RegMap[STLOOP_7].Addr   = 0x57 ;
  1568. RegMap[STLOOP_7].Reset  = 0x8B ;
  1569. RegMap[STLOOP_7].Value  = 0x00 ;
  1570. strcpy(RegMap[STLOOP_7].Name,"STLOOP_7") ;
  1571. /* FIELDS*/
  1572. strcpy(FieldMap[SYMB_RATE_2].Name,"SYMB_RATE_2") ;
  1573. FieldMap[SYMB_RATE_2].Reg  = STLOOP_7 ;
  1574. FieldMap[SYMB_RATE_2].Pos  = 0     ;
  1575. FieldMap[SYMB_RATE_2].Bits = 8     ;
  1576. FieldMap[SYMB_RATE_2].Type = UNSIGNED ;
  1577. FieldMap[SYMB_RATE_2].Mask = FieldCreateMask(SYMB_RATE_2) ;
  1578. /* STLOOP_8*/
  1579. RegMap[STLOOP_8].Addr   = 0x58 ;
  1580. RegMap[STLOOP_8].Reset  = 0x39 ;
  1581. RegMap[STLOOP_8].Value  = 0x00 ;
  1582. strcpy(RegMap[STLOOP_8].Name,"STLOOP_8") ;
  1583. /* FIELDS*/
  1584. strcpy(FieldMap[SYMB_RATE_3].Name,"SYMB_RATE_3") ;
  1585. FieldMap[SYMB_RATE_3].Reg  = STLOOP_8 ;
  1586. FieldMap[SYMB_RATE_3].Pos  = 0     ;
  1587. FieldMap[SYMB_RATE_3].Bits = 8     ;
  1588. FieldMap[SYMB_RATE_3].Type = UNSIGNED ;
  1589. FieldMap[SYMB_RATE_3].Mask = FieldCreateMask(SYMB_RATE_3) ;
  1590. /* STLOOP_9*/
  1591. RegMap[STLOOP_9].Addr   = 0x59 ;
  1592. RegMap[STLOOP_9].Reset  = 0x06 ;
  1593. RegMap[STLOOP_9].Value  = 0x00 ;
  1594. strcpy(RegMap[STLOOP_9].Name,"STLOOP_9") ;
  1595. /* FIELDS*/
  1596. strcpy(FieldMap[INTEGRAL_GAIN_LO].Name,"INTEGRAL_GAIN_LO") ;
  1597. FieldMap[INTEGRAL_GAIN_LO].Reg  = STLOOP_9 ;
  1598. FieldMap[INTEGRAL_GAIN_LO].Pos  = 0     ;
  1599. FieldMap[INTEGRAL_GAIN_LO].Bits = 5     ;
  1600. FieldMap[INTEGRAL_GAIN_LO].Type = UNSIGNED ;
  1601. FieldMap[INTEGRAL_GAIN_LO].Mask = FieldCreateMask(INTEGRAL_GAIN_LO) ;
  1602. /* FIELDS*/
  1603. strcpy(FieldMap[DIRECT_GAIN_HI].Name,"DIRECT_GAIN_HI") ;
  1604. FieldMap[DIRECT_GAIN_HI].Reg  = STLOOP_9 ;
  1605. FieldMap[DIRECT_GAIN_HI].Pos  = 5     ;
  1606. FieldMap[DIRECT_GAIN_HI].Bits = 3     ;
  1607. FieldMap[DIRECT_GAIN_HI].Type = UNSIGNED ;
  1608. FieldMap[DIRECT_GAIN_HI].Mask = FieldCreateMask(DIRECT_GAIN_HI) ;
  1609. /* STLOOP_10*/
  1610. RegMap[STLOOP_10].Addr   = 0x5A ;
  1611. RegMap[STLOOP_10].Reset  = 0x5E ;
  1612. RegMap[STLOOP_10].Value  = 0x5E ;
  1613. strcpy(RegMap[STLOOP_10].Name,"STLOOP_10") ;
  1614. /* FIELDS*/
  1615. strcpy(FieldMap[PHASE_EN].Name,"PHASE_EN") ;
  1616. FieldMap[PHASE_EN].Reg  = STLOOP_10 ;
  1617. FieldMap[PHASE_EN].Pos  = 6     ;
  1618. FieldMap[PHASE_EN].Bits = 1     ;
  1619. FieldMap[PHASE_EN].Type = UNSIGNED ;
  1620. FieldMap[PHASE_EN].Mask = FieldCreateMask(PHASE_EN) ;
  1621. /* FIELDS*/
  1622. strcpy(FieldMap[PHASE_CLR].Name,"PHASE_CLR") ;
  1623. FieldMap[PHASE_CLR].Reg  = STLOOP_10 ;
  1624. FieldMap[PHASE_CLR].Pos  = 5     ;
  1625. FieldMap[PHASE_CLR].Bits = 1     ;
  1626. FieldMap[PHASE_CLR].Type = UNSIGNED ;
  1627. FieldMap[PHASE_CLR].Mask = FieldCreateMask(PHASE_CLR) ;
  1628. /* FIELDS*/
  1629. strcpy(FieldMap[ERR_RANGE].Name,"ERR_RANGE") ;
  1630. FieldMap[ERR_RANGE].Reg  = STLOOP_10 ;
  1631. FieldMap[ERR_RANGE].Pos  = 0     ;
  1632. FieldMap[ERR_RANGE].Bits = 5     ;
  1633. FieldMap[ERR_RANGE].Type = UNSIGNED ;
  1634. FieldMap[ERR_RANGE].Mask = FieldCreateMask(ERR_RANGE) ;
  1635. /* STLOOP_11*/
  1636. RegMap[STLOOP_11].Addr   = 0x5B ;
  1637. RegMap[STLOOP_11].Reset  = 0x04 ;
  1638. RegMap[STLOOP_11].Value  = 0x05 ;
  1639. strcpy(RegMap[STLOOP_11].Name,"STLOOP_11") ;
  1640. /* FIELDS*/
  1641. strcpy(FieldMap[ALGOSEL].Name,"ALGOSEL") ;
  1642. FieldMap[ALGOSEL].Reg  = STLOOP_11 ;
  1643. FieldMap[ALGOSEL].Pos  = 4     ;
  1644. FieldMap[ALGOSEL].Bits = 2     ;
  1645. FieldMap[ALGOSEL].Type = UNSIGNED ;
  1646. FieldMap[ALGOSEL].Mask = FieldCreateMask(ALGOSEL) ;
  1647. /* FIELDS*/
  1648. strcpy(FieldMap[ERR_CLR].Name,"ERR_CLR") ;
  1649. FieldMap[ERR_CLR].Reg  = STLOOP_11 ;
  1650. FieldMap[ERR_CLR].Pos  = 1     ;
  1651. FieldMap[ERR_CLR].Bits = 1     ;
  1652. FieldMap[ERR_CLR].Type = UNSIGNED ;
  1653. FieldMap[ERR_CLR].Mask = FieldCreateMask(ERR_CLR) ;
  1654. /* FIELDS*/
  1655. strcpy(FieldMap[ERR_EN].Name,"ERR_EN") ;
  1656. FieldMap[ERR_EN].Reg  = STLOOP_11 ;
  1657. FieldMap[ERR_EN].Pos  = 0     ;
  1658. FieldMap[ERR_EN].Bits = 1     ;
  1659. FieldMap[ERR_EN].Type = UNSIGNED ;
  1660. FieldMap[ERR_EN].Mask = FieldCreateMask(ERR_EN) ;
  1661. /* CRL_0*/
  1662. RegMap[CRL_0].Addr   = 0x60 ;
  1663. RegMap[CRL_0].Reset  = 0x16 ;
  1664. RegMap[CRL_0].Value  = 0x00 ;
  1665. strcpy(RegMap[CRL_0].Name,"CRL_0") ;
  1666. /* FIELDS*/
  1667. strcpy(FieldMap[SWEEP_LO].Name,"SWEEP_LO") ;
  1668. FieldMap[SWEEP_LO].Reg  = CRL_0 ;
  1669. FieldMap[SWEEP_LO].Pos  = 0     ;
  1670. FieldMap[SWEEP_LO].Bits = 8     ;
  1671. FieldMap[SWEEP_LO].Type = UNSIGNED ;
  1672. FieldMap[SWEEP_LO].Mask = FieldCreateMask(SWEEP_LO) ;
  1673. /* CRL_1*/
  1674. RegMap[CRL_1].Addr   = 0x61 ;
  1675. RegMap[CRL_1].Reset  = 0x49 ; /*org 49*/
  1676. RegMap[CRL_1].Value  = 0x38 ; /*org 38*/
  1677. strcpy(RegMap[CRL_1].Name,"CRL_1") ;
  1678. /* FIELDS*/
  1679. strcpy(FieldMap[GAIN_INT].Name,"GAIN_INT") ;
  1680. FieldMap[GAIN_INT].Reg  = CRL_1 ;
  1681. FieldMap[GAIN_INT].Pos  = 0     ;
  1682. FieldMap[GAIN_INT].Bits = 4     ;
  1683. FieldMap[GAIN_INT].Type = UNSIGNED ;
  1684. FieldMap[GAIN_INT].Mask = FieldCreateMask(GAIN_INT) ;
  1685. /* FIELDS*/
  1686. strcpy(FieldMap[GAIN_DIR].Name,"GAIN_DIR") ;
  1687. FieldMap[GAIN_DIR].Reg  = CRL_1 ;
  1688. FieldMap[GAIN_DIR].Pos  = 4     ;
  1689. FieldMap[GAIN_DIR].Bits = 3     ;
  1690. FieldMap[GAIN_DIR].Type = UNSIGNED ;
  1691. FieldMap[GAIN_DIR].Mask = FieldCreateMask(GAIN_DIR) ;
  1692. /* CRL_2*/
  1693. RegMap[CRL_2].Addr   = 0x62 ;
  1694. RegMap[CRL_2].Reset  = 0x05 ;
  1695. RegMap[CRL_2].Value  = 0x06 ;
  1696. strcpy(RegMap[CRL_2].Name,"CRL_2") ;
  1697. /* FIELDS*/
  1698. strcpy(FieldMap[GAIN_INT_ADJ].Name,"GAIN_INT_ADJ") ;
  1699. FieldMap[GAIN_INT_ADJ].Reg  = CRL_2 ;
  1700. FieldMap[GAIN_INT_ADJ].Pos  = 0     ;
  1701. FieldMap[GAIN_INT_ADJ].Bits = 2     ;
  1702. FieldMap[GAIN_INT_ADJ].Type = UNSIGNED ;
  1703. FieldMap[GAIN_INT_ADJ].Mask = FieldCreateMask(GAIN_INT_ADJ) ;
  1704. /* FIELDS*/
  1705. strcpy(FieldMap[GAIN_DIR_ADJ].Name,"GAIN_DIR_ADJ") ;
  1706. FieldMap[GAIN_DIR_ADJ].Reg  = CRL_2 ;
  1707. FieldMap[GAIN_DIR_ADJ].Pos  = 2     ;
  1708. FieldMap[GAIN_DIR_ADJ].Bits = 2     ;
  1709. FieldMap[GAIN_DIR_ADJ].Type = UNSIGNED ;
  1710. FieldMap[GAIN_DIR_ADJ].Mask = FieldCreateMask(GAIN_DIR_ADJ) ;
  1711. /* CRL_3*/
  1712. RegMap[CRL_3].Addr   = 0x63 ;
  1713. RegMap[CRL_3].Reset  = 0x00 ;
  1714. RegMap[CRL_3].Value  = 0x00 ;
  1715. strcpy(RegMap[CRL_3].Name,"CRL_3") ;
  1716. /* FIELDS*/
  1717. strcpy(FieldMap[APHASE_0].Name,"APHASE_0") ;
  1718. FieldMap[APHASE_0].Reg  = CRL_3 ;
  1719. FieldMap[APHASE_0].Pos  = 0     ;
  1720. FieldMap[APHASE_0].Bits = 8     ;
  1721. FieldMap[APHASE_0].Type = UNSIGNED ;
  1722. FieldMap[APHASE_0].Mask = FieldCreateMask(APHASE_0) ;
  1723. /* CRL_4*/
  1724. RegMap[CRL_4].Addr   = 0x64 ;
  1725. RegMap[CRL_4].Reset  = 0x00 ;
  1726. RegMap[CRL_4].Value  = 0x00 ;
  1727. strcpy(RegMap[CRL_4].Name,"CRL_4") ;
  1728. /* FIELDS*/
  1729. strcpy(FieldMap[APHASE_1].Name,"APHASE_1") ;
  1730. FieldMap[APHASE_1].Reg  = CRL_4 ;
  1731. FieldMap[APHASE_1].Pos  = 0     ;
  1732. FieldMap[APHASE_1].Bits = 8     ;
  1733. FieldMap[APHASE_1].Type = UNSIGNED ;
  1734. FieldMap[APHASE_1].Mask = FieldCreateMask(APHASE_1) ;
  1735. /* CRL_5*/
  1736. RegMap[CRL_5].Addr   = 0x65 ;
  1737. RegMap[CRL_5].Reset  = 0x00 ;
  1738. RegMap[CRL_5].Value  = 0x00 ;
  1739. strcpy(RegMap[CRL_5].Name,"CRL_5") ;
  1740. /* FIELDS*/
  1741. strcpy(FieldMap[APHASE_2].Name,"APHASE_2") ;
  1742. FieldMap[APHASE_2].Reg  = CRL_5 ;
  1743. FieldMap[APHASE_2].Pos  = 0     ;
  1744. FieldMap[APHASE_2].Bits = 8     ;
  1745. FieldMap[APHASE_2].Type = UNSIGNED ;
  1746. FieldMap[APHASE_2].Mask = FieldCreateMask(APHASE_2) ;
  1747. /* CRL_6*/
  1748. RegMap[CRL_6].Addr   = 0x66 ;
  1749. RegMap[CRL_6].Reset  = 0xbf ;
  1750. RegMap[CRL_6].Value  = 0x00 ;
  1751. strcpy(RegMap[CRL_6].Name,"CRL_6") ;
  1752. /* FIELDS*/
  1753. strcpy(FieldMap[IPHASE_0].Name,"IPHASE_0") ;
  1754. FieldMap[IPHASE_0].Reg  = CRL_6 ;
  1755. FieldMap[IPHASE_0].Pos  = 0     ;
  1756. FieldMap[IPHASE_0].Bits = 8     ;
  1757. FieldMap[IPHASE_0].Type = UNSIGNED ;
  1758. FieldMap[IPHASE_0].Mask = FieldCreateMask(IPHASE_0) ;
  1759. /* CRL_7*/
  1760. RegMap[CRL_7].Addr   = 0x67 ;
  1762. RegMap[CRL_7].Reset  = 0x0D ;
  1763. RegMap[CRL_7].Value  = 0x00 ;
  1764. strcpy(RegMap[CRL_7].Name,"CRL_7") ;
  1765. /* FIELDS*/
  1766. strcpy(FieldMap[IPHASE_1].Name,"IPHASE_1") ;
  1767. FieldMap[IPHASE_1].Reg  = CRL_7 ;
  1768. FieldMap[IPHASE_1].Pos  = 0     ;
  1769. FieldMap[IPHASE_1].Bits = 8     ;
  1770. FieldMap[IPHASE_1].Type = UNSIGNED ;
  1771. FieldMap[IPHASE_1].Mask = FieldCreateMask(IPHASE_1) ;
  1772. /* CRL_8*/
  1773. RegMap[CRL_8].Addr   = 0x68 ;
  1774. RegMap[CRL_8].Reset  = 0xf8 ;
  1775. RegMap[CRL_8].Value  = 0x00 ;
  1776. strcpy(RegMap[CRL_8].Name,"CRL_8") ;
  1777. /* FIELDS*/
  1778. strcpy(FieldMap[IPHASE_2].Name,"IPHASE_2") ;
  1779. FieldMap[IPHASE_2].Reg  = CRL_8 ;
  1780. FieldMap[IPHASE_2].Pos  = 0      ;
  1781. FieldMap[IPHASE_2].Bits = 8     ;
  1782. FieldMap[IPHASE_2].Type = UNSIGNED ;
  1783. FieldMap[IPHASE_2].Mask = FieldCreateMask(IPHASE_2) ;
  1784. /* CRL_9*/
  1785. RegMap[CRL_9].Addr   = 0x69 ;
  1786. RegMap[CRL_9].Reset  = 0x0D ;
  1787. RegMap[CRL_9].Value  = 0x00 ;
  1788. strcpy(RegMap[CRL_9].Name,"CRL_9") ;
  1789. /* FIELDS*/
  1790. strcpy(FieldMap[IPHASE_3].Name,"IPHASE_3") ;
  1791. FieldMap[IPHASE_3].Reg  = CRL_9 ;
  1792. FieldMap[IPHASE_3].Pos  = 0     ;
  1793. FieldMap[IPHASE_3].Bits = 4     ;
  1794. FieldMap[IPHASE_3].Type = UNSIGNED ;
  1795. FieldMap[IPHASE_3].Mask = FieldCreateMask(IPHASE_3) ;
  1796. /* FIELDS*/
  1797. strcpy(FieldMap[SWEEP_HI].Name,"SWEEP_HI") ;
  1798. FieldMap[SWEEP_HI].Reg  = CRL_9 ;
  1799. FieldMap[SWEEP_HI].Pos  = 4     ;
  1800. FieldMap[SWEEP_HI].Bits = 4     ;
  1801. FieldMap[SWEEP_HI].Type = UNSIGNED ;
  1802. FieldMap[SWEEP_HI].Mask = FieldCreateMask(SWEEP_HI) ;
  1803. /* CRL_10*/
  1804. RegMap[CRL_10].Addr   = 0x6A ;
  1805. RegMap[CRL_10].Reset  = 0x03 ;
  1806. RegMap[CRL_10].Value  = 0x03 ;
  1807. strcpy(RegMap[CRL_10].Name,"CRL_10") ;
  1808. /* FIELDS*/
  1809. strcpy(FieldMap[SWEEP_EN].Name,"SWEEP_EN") ;
  1810. FieldMap[SWEEP_EN].Reg  = CRL_10 ;
  1811. FieldMap[SWEEP_EN].Pos  = 0     ;
  1812. FieldMap[SWEEP_EN].Bits = 1     ;
  1813. FieldMap[SWEEP_EN].Type = UNSIGNED ;
  1814. FieldMap[SWEEP_EN].Mask = FieldCreateMask(SWEEP_EN) ;
  1815. /* FIELDS*/
  1816. strcpy(FieldMap[PH_EN].Name,"PH_EN") ;
  1817. FieldMap[PH_EN].Reg  = CRL_10 ;
  1818. FieldMap[PH_EN].Pos  = 1     ;
  1819. FieldMap[PH_EN].Bits = 1     ;
  1820. FieldMap[PH_EN].Type = UNSIGNED ;
  1821. FieldMap[PH_EN].Mask = FieldCreateMask(PH_EN) ;
  1822. /* FIELDS*/
  1823. strcpy(FieldMap[DIR_EN].Name,"DIR_EN") ;
  1824. FieldMap[DIR_EN].Reg  = CRL_10 ;
  1825. FieldMap[DIR_EN].Pos  = 2     ;
  1826. FieldMap[DIR_EN].Bits = 1     ;
  1827. FieldMap[DIR_EN].Type = UNSIGNED ;
  1828. FieldMap[DIR_EN].Mask = FieldCreateMask(DIR_EN) ;
  1829. /* FIELDS*/
  1830. strcpy(FieldMap[INT_EN].Name,"INT_EN") ;
  1831. FieldMap[INT_EN].Reg  = CRL_10 ;
  1832. FieldMap[INT_EN].Pos  = 3      ;
  1833. FieldMap[INT_EN].Bits = 1      ;
  1834. FieldMap[INT_EN].Type = UNSIGNED ;
  1835. FieldMap[INT_EN].Mask = FieldCreateMask(INT_EN) ;
  1836. /* FIELDS*/
  1837. strcpy(FieldMap[DIR_DIS].Name,"DIR_DIS") ;
  1838. FieldMap[DIR_DIS].Reg  = CRL_10 ;
  1839. FieldMap[DIR_DIS].Pos  = 4      ;
  1840. FieldMap[DIR_DIS].Bits = 1      ;
  1841. FieldMap[DIR_DIS].Type = UNSIGNED ;
  1842. FieldMap[DIR_DIS].Mask = FieldCreateMask(DIR_DIS) ;
  1843. /* FIELDS*/
  1844. strcpy(FieldMap[INT_DIS].Name,"INT_DIS") ;
  1845. FieldMap[INT_DIS].Reg  = CRL_10 ;
  1846. FieldMap[INT_DIS].Pos  = 5      ;
  1847. FieldMap[INT_DIS].Bits = 1      ;
  1848. FieldMap[INT_DIS].Type = UNSIGNED ;
  1849. FieldMap[INT_DIS].Mask = FieldCreateMask(INT_DIS) ;
  1850. /* CRL_11*/
  1851. RegMap[CRL_11].Addr   = 0x6B ;
  1852. RegMap[CRL_11].Reset  = 0x92 ;
  1853. RegMap[CRL_11].Value  = 0x00 ;
  1854. strcpy(RegMap[CRL_11].Name,"CRL_11") ;
  1855. /* FIELDS*/
  1856. strcpy(FieldMap[CRL_SNAPSHOT].Name,"CRL_SNAPSHOT") ;
  1857. FieldMap[CRL_SNAPSHOT].Reg  = CRL_11 ;
  1858. FieldMap[CRL_SNAPSHOT].Pos  = 0     ;
  1859. FieldMap[CRL_SNAPSHOT].Bits = 8     ;
  1860. FieldMap[CRL_SNAPSHOT].Type = UNSIGNED ;
  1861. FieldMap[CRL_SNAPSHOT].Mask = FieldCreateMask(CRL_SNAPSHOT) ;
  1862. /* PMF_AGC_0*/
  1863. RegMap[PMFAGC_0].Addr   = 0x70 ;
  1864. RegMap[PMFAGC_0].Reset  = 0xFF ;
  1865. RegMap[PMFAGC_0].Value  = 0xFF ;
  1866. strcpy(RegMap[PMFAGC_0].Name,"PMFAGC_0") ;
  1867. /* FIELDS*/
  1868. strcpy(FieldMap[LOCK_THRES_LO].Name,"LOCK_THRES_LO") ;
  1869. FieldMap[LOCK_THRES_LO].Reg  = PMFAGC_0 ;
  1870. FieldMap[LOCK_THRES_LO].Pos  = 0     ;
  1871. FieldMap[LOCK_THRES_LO].Bits = 8     ;
  1872. FieldMap[LOCK_THRES_LO].Type = UNSIGNED ;
  1873. FieldMap[LOCK_THRES_LO].Mask = FieldCreateMask(LOCK_THRES_LO) ;
  1874. /* PMF_AGC_1*/
  1875. RegMap[PMFAGC_1].Addr   = 0x71 ;
  1876. RegMap[PMFAGC_1].Reset  = 0x04 ;
  1877. RegMap[PMFAGC_1].Value  = 0x00 ;
  1878. strcpy(RegMap[PMFAGC_1].Name,"PMFAGC_1") ;
  1879. /* FIELDS*/
  1880. strcpy(FieldMap[PMFA_F_UNLOCK].Name,"PMFA_F_UNLOCK") ;
  1881. FieldMap[PMFA_F_UNLOCK].Reg  = PMFAGC_1 ;
  1882. FieldMap[PMFA_F_UNLOCK].Pos  = 7     ;
  1883. FieldMap[PMFA_F_UNLOCK].Bits = 1     ;
  1884. FieldMap[PMFA_F_UNLOCK].Type = UNSIGNED ;
  1885. FieldMap[PMFA_F_UNLOCK].Mask = FieldCreateMask(PMFA_F_UNLOCK) ;
  1886. /* FIELDS*/
  1887. strcpy(FieldMap[PMFA_F_LOCK].Name,"PMFA_F_LOCK") ;
  1888. FieldMap[PMFA_F_LOCK].Reg  = PMFAGC_1 ;
  1889. FieldMap[PMFA_F_LOCK].Pos  = 6     ;
  1890. FieldMap[PMFA_F_LOCK].Bits = 1     ;
  1891. FieldMap[PMFA_F_LOCK].Type = UNSIGNED ;
  1892. FieldMap[PMFA_F_LOCK].Mask = FieldCreateMask(PMFA_F_LOCK) ;
  1893. /* FIELDS*/
  1894. strcpy(FieldMap[WBAGC_F_LOCK].Name,"WBAGC_F_LOCK") ;
  1895. FieldMap[WBAGC_F_LOCK].Reg  = PMFAGC_1 ;
  1896. FieldMap[WBAGC_F_LOCK].Pos  = 5     ;
  1897. FieldMap[WBAGC_F_LOCK].Bits = 1     ;
  1898. FieldMap[WBAGC_F_LOCK].Type = UNSIGNED ;
  1899. FieldMap[WBAGC_F_LOCK].Mask = FieldCreateMask(WBAGC_F_LOCK) ;
  1900. /* FIELDS*/
  1901. strcpy(FieldMap[UP_STOP].Name,"UP_STOP") ;
  1902. FieldMap[UP_STOP].Reg  = PMFAGC_1 ;
  1903. FieldMap[UP_STOP].Pos  = 4     ;
  1904. FieldMap[UP_STOP].Bits = 1     ;
  1905. FieldMap[UP_STOP].Type = UNSIGNED ;
  1906. FieldMap[UP_STOP].Mask = FieldCreateMask(UP_STOP) ;
  1907. /* FIELDS*/
  1908. strcpy(FieldMap[LOCK_THRES_HI].Name,"LOCK_THRES_HI") ;
  1909. FieldMap[LOCK_THRES_HI].Reg  = PMFAGC_1 ;
  1910. FieldMap[LOCK_THRES_HI].Pos  = 0     ;
  1911. FieldMap[LOCK_THRES_HI].Bits = 4     ;
  1912. FieldMap[LOCK_THRES_HI].Type = UNSIGNED ;
  1913. FieldMap[LOCK_THRES_HI].Mask = FieldCreateMask(LOCK_THRES_HI) ;
  1914. /* PMF_AGC_2*/
  1915. RegMap[PMFAGC_2].Addr   = 0x72 ;
  1916. RegMap[PMFAGC_2].Reset  = 0x00 ;
  1917. RegMap[PMFAGC_2].Value  = 0x00 ;
  1918. strcpy(RegMap[PMFAGC_2].Name,"PMFAGC_2") ;
  1919. /* FIELDS*/
  1920. strcpy(FieldMap[PMFA_ACC0].Name,"PMFA_ACC0") ;
  1921. FieldMap[PMFA_ACC0].Reg  = PMFAGC_2 ;
  1922. FieldMap[PMFA_ACC0].Pos  = 0     ;
  1923. FieldMap[PMFA_ACC0].Bits = 8     ;
  1924. FieldMap[PMFA_ACC0].Type = UNSIGNED ;
  1925. FieldMap[PMFA_ACC0].Mask = FieldCreateMask(PMFA_ACC0) ;
  1926. /* PMF_AGC_3*/
  1927. RegMap[PMFAGC_3].Addr   = 0x73 ;
  1928. RegMap[PMFAGC_3].Reset  = 0x00 ;
  1929. RegMap[PMFAGC_3].Value  = 0x00 ;
  1930. strcpy(RegMap[PMFAGC_3].Name,"PMFAGC_3") ;
  1931. /* FIELDS*/
  1932. strcpy(FieldMap[PMFA_ACC1].Name,"PMFA_ACC1") ;
  1933. FieldMap[PMFA_ACC1].Reg  = PMFAGC_3 ;
  1934. FieldMap[PMFA_ACC1].Pos  = 0     ;
  1935. FieldMap[PMFA_ACC1].Bits = 8     ;
  1936. FieldMap[PMFA_ACC1].Type = UNSIGNED ;
  1937. FieldMap[PMFA_ACC1].Mask = FieldCreateMask(PMFA_ACC1) ;
  1938. /* PMF_AGC_4*/
  1939. RegMap[PMFAGC_4].Addr   = 0x74 ;
  1940. RegMap[PMFAGC_4].Reset  = 0x00 ;
  1941. RegMap[PMFAGC_4].Value  = 0x00 ;
  1942. strcpy(RegMap[PMFAGC_4].Name,"PMFAGC_4") ;
  1943. /* FIELDS*/
  1944. strcpy(FieldMap[PMFA_LOCK_STATE].Name,"PMFA_LOCK_STATE") ;
  1945. FieldMap[PMFA_LOCK_STATE].Reg  = PMFAGC_4 ;
  1946. FieldMap[PMFA_LOCK_STATE].Pos  = 7     ;
  1947. FieldMap[PMFA_LOCK_STATE].Bits = 1     ;
  1948. FieldMap[PMFA_LOCK_STATE].Type = UNSIGNED ;
  1949. FieldMap[PMFA_LOCK_STATE].Mask = FieldCreateMask(PMFA_LOCK_STATE) ;
  1950. /* FIELDS*/
  1951. strcpy(FieldMap[PMFA_ACC2].Name,"PMFA_ACC2") ;
  1952. FieldMap[PMFA_ACC2].Reg  = PMFAGC_4 ;
  1953. FieldMap[PMFA_ACC2].Pos  = 0     ;
  1954. FieldMap[PMFA_ACC2].Bits = 4     ;
  1955. FieldMap[PMFA_ACC2].Type = UNSIGNED ;
  1956. FieldMap[PMFA_ACC2].Mask = FieldCreateMask(PMFA_ACC2) ;
  1957. /* CTRL_0*/
  1958. RegMap[CTRL_0].Addr   = 0x80 ;
  1959. RegMap[CTRL_0].Reset  = 0x20 ;
  1960. RegMap[CTRL_0].Value  = 0x00 ;
  1961. strcpy(RegMap[CTRL_0].Name,"CTRL_0") ;
  1962. /* FIELDS*/
  1963. strcpy(FieldMap[SOFT_RESET].Name,"SOFT_RESET") ;
  1964. FieldMap[SOFT_RESET].Reg  = CTRL_0 ;
  1965. FieldMap[SOFT_RESET].Pos  = 0     ;
  1966. FieldMap[SOFT_RESET].Bits = 1     ;
  1967. FieldMap[SOFT_RESET].Type = UNSIGNED ;
  1968. FieldMap[SOFT_RESET].Mask = FieldCreateMask(SOFT_RESET) ;
  1969. /* FIELDS*/
  1970. strcpy(FieldMap[VERSION].Name,"VERSION") ;
  1971. FieldMap[VERSION].Reg  = CTRL_0 ;
  1972. FieldMap[VERSION].Pos  = 4     ;
  1973. FieldMap[VERSION].Bits = 3     ;
  1974. FieldMap[VERSION].Type = UNSIGNED ;
  1975. FieldMap[VERSION].Mask = FieldCreateMask(VERSION) ;
  1976. /* CTRL_1*/
  1977. RegMap[CTRL_1].Addr   = 0x81 ;
  1978. RegMap[CTRL_1].Reset  = 0x00 ;
  1979. RegMap[CTRL_1].Value  = 0x00 ;
  1980. strcpy(RegMap[CTRL_1].Name,"CTRL_1") ;
  1981. /* FIELDS*/
  1982. strcpy(FieldMap[RESET_DI].Name,"RESET_DI") ;
  1983. FieldMap[RESET_DI].Reg  = CTRL_1 ;
  1984. FieldMap[RESET_DI].Pos  = 0     ;
  1985. FieldMap[RESET_DI].Bits = 1     ;
  1986. FieldMap[RESET_DI].Type = UNSIGNED ;
  1987. FieldMap[RESET_DI].Mask = FieldCreateMask(RESET_DI) ;
  1988. /* CTRL_2*/
  1989. RegMap[CTRL_2].Addr   = 0x82 ;
  1990. RegMap[CTRL_2].Reset  = 0x27 ;
  1991. RegMap[CTRL_2].Value  = 0x00 ;
  1992. strcpy(RegMap[CTRL_2].Name,"CTRL_2") ;
  1993. /* FIELDS*/
  1994. strcpy(FieldMap[RS_UNCORR].Name,"RS_UNCORR") ;
  1995. FieldMap[RS_UNCORR].Reg  = CTRL_2 ;
  1996. FieldMap[RS_UNCORR].Pos  = 5     ;
  1997. FieldMap[RS_UNCORR].Bits = 1     ;
  1998. FieldMap[RS_UNCORR].Type = UNSIGNED ;
  1999. FieldMap[RS_UNCORR].Mask = FieldCreateMask(RS_UNCORR) ;
  2000. /* FIELDS*/
  2001. strcpy(FieldMap[CORNER_LOCK].Name,"CORNER_LOCK") ;
  2002. FieldMap[CORNER_LOCK].Reg  = CTRL_2 ;
  2003. FieldMap[CORNER_LOCK].Pos  = 4     ;
  2004. FieldMap[CORNER_LOCK].Bits = 1     ;
  2005. FieldMap[CORNER_LOCK].Type = UNSIGNED ;
  2006. FieldMap[CORNER_LOCK].Mask = FieldCreateMask(CORNER_LOCK) ;
  2007. /* FIELDS*/
  2008. strcpy(FieldMap[EQU_LMS2].Name,"EQU_LMS2") ;
  2009. FieldMap[EQU_LMS2].Reg  = CTRL_2 ;
  2010. FieldMap[EQU_LMS2].Pos  = 3     ;
  2011. FieldMap[EQU_LMS2].Bits = 1     ;
  2012. FieldMap[EQU_LMS2].Type = UNSIGNED ;
  2013. FieldMap[EQU_LMS2].Mask = FieldCreateMask(EQU_LMS2) ;
  2014. /* FIELDS*/
  2015. strcpy(FieldMap[EQU_LMS1].Name,"EQU_LMS1") ;
  2016. FieldMap[EQU_LMS1].Reg  = CTRL_2 ;
  2017. FieldMap[EQU_LMS1].Pos  = 2     ;
  2018. FieldMap[EQU_LMS1].Bits = 1     ;
  2019. FieldMap[EQU_LMS1].Type = UNSIGNED ;
  2020. FieldMap[EQU_LMS1].Mask = FieldCreateMask(EQU_LMS1) ;
  2021. /* FIELDS*/
  2022. strcpy(FieldMap[PMFAGC_IT].Name,"PMFAGC_IT") ;
  2023. FieldMap[PMFAGC_IT].Reg  = CTRL_2 ;
  2024. FieldMap[PMFAGC_IT].Pos  = 1     ;
  2025. FieldMap[PMFAGC_IT].Bits = 1     ;
  2026. FieldMap[PMFAGC_IT].Type = UNSIGNED ;
  2027. FieldMap[PMFAGC_IT].Mask = FieldCreateMask(PMFAGC_IT) ;
  2028. /* FIELDS*/
  2029. strcpy(FieldMap[WBAGC_IT].Name,"WBAGC_IT") ;
  2030. FieldMap[WBAGC_IT].Reg  = CTRL_2 ;
  2031. FieldMap[WBAGC_IT].Pos  = 0     ;
  2032. FieldMap[WBAGC_IT].Bits = 1     ;
  2033. FieldMap[WBAGC_IT].Type = UNSIGNED ;
  2034. FieldMap[WBAGC_IT].Mask = FieldCreateMask(WBAGC_IT) ;
  2035. /* CTRL_3*/
  2036. RegMap[CTRL_3].Addr   = 0x83 ;
  2037. RegMap[CTRL_3].Reset  = 0x08 ;
  2038. RegMap[CTRL_3].Value  = 0x02 ;
  2039. strcpy(RegMap[CTRL_3].Name,"CTRL_3") ;
  2040. /* FIELDS*/
  2041. strcpy(FieldMap[J83C].Name,"J83C") ;
  2042. FieldMap[J83C].Reg  = CTRL_3;
  2043. FieldMap[J83C].Pos  = 0     ;
  2044. FieldMap[J83C].Bits = 1     ;
  2045. FieldMap[J83C].Type = UNSIGNED ;
  2046. FieldMap[J83C].Mask = FieldCreateMask(J83C) ;
  2047. /* FIELDS*/
  2048. strcpy(FieldMap[DFS].Name,"DFS") ;
  2049. FieldMap[DFS].Reg  = CTRL_3;
  2050. FieldMap[DFS].Pos  = 1     ;
  2051. FieldMap[DFS].Bits = 1     ;
  2052. FieldMap[DFS].Type = UNSIGNED ;
  2053. FieldMap[DFS].Mask = FieldCreateMask(DFS) ;
  2054. /* FIELDS*/
  2055. strcpy(FieldMap[SPEC_INV].Name,"SPEC_INV") ;
  2056. FieldMap[SPEC_INV].Reg  = CTRL_3;
  2057. FieldMap[SPEC_INV].Pos  = 3     ;
  2058. FieldMap[SPEC_INV].Bits = 1     ;
  2059. FieldMap[SPEC_INV].Type = UNSIGNED ;
  2060. FieldMap[SPEC_INV].Mask = FieldCreateMask(SPEC_INV) ;
  2061. /* FIELDS*/
  2062. strcpy(FieldMap[RESET_RS].Name,"RESET_RS") ;
  2063. FieldMap[RESET_RS].Reg  = CTRL_3;
  2064. FieldMap[RESET_RS].Pos  = 4     ;
  2065. FieldMap[RESET_RS].Bits = 1     ;
  2066. FieldMap[RESET_RS].Type = UNSIGNED ;
  2067. FieldMap[RESET_RS].Mask = FieldCreateMask(RESET_RS) ;
  2068. /* FIELDS*/
  2069. strcpy(FieldMap[TEST_SEL].Name,"TEST_SEL") ;
  2070. FieldMap[TEST_SEL].Reg  = CTRL_3;
  2071. FieldMap[TEST_SEL].Pos  = 5     ;
  2072. FieldMap[TEST_SEL].Bits = 3     ;
  2073. FieldMap[TEST_SEL].Type = UNSIGNED ;
  2074. FieldMap[TEST_SEL].Mask = FieldCreateMask(TEST_SEL) ;
  2075. /* CTRL_4*/
  2076. RegMap[CTRL_4].Addr   = 0x84 ;
  2077. RegMap[CTRL_4].Reset  = 0x02 ; 
  2078. RegMap[CTRL_4].Value  = 0x0A ;
  2079. strcpy(RegMap[CTRL_4].Name,"CTRL_4") ;
  2080. /* FIELDS*/
  2081. strcpy(FieldMap[RESET_EQL].Name,"RESET_EQL") ;
  2082. FieldMap[RESET_EQL].Reg  = CTRL_4 ;
  2083. FieldMap[RESET_EQL].Pos  = 0     ;
  2084. FieldMap[RESET_EQL].Bits = 1     ;
  2085. FieldMap[RESET_EQL].Type = UNSIGNED ;
  2086. FieldMap[RESET_EQL].Mask = FieldCreateMask(RESET_EQL) ;
  2087. /* FIELDS*/
  2088. strcpy(FieldMap[CKX2SEL].Name,"CKX2SEL") ;
  2089. FieldMap[CKX2SEL].Reg  = CTRL_4 ;
  2090. FieldMap[CKX2SEL].Pos  = 1     ;
  2091. FieldMap[CKX2SEL].Bits = 1     ;
  2092. FieldMap[CKX2SEL].Type = UNSIGNED ;
  2093. FieldMap[CKX2SEL].Mask = FieldCreateMask(CKX2SEL) ;
  2094. /* FIELDS*/
  2095. strcpy(FieldMap[CKX2DIS].Name,"CKX2DIS") ;
  2096. FieldMap[CKX2DIS].Reg  = CTRL_4 ;
  2097. FieldMap[CKX2DIS].Pos  = 2     ;
  2098. FieldMap[CKX2DIS].Bits = 1     ;
  2099. FieldMap[CKX2DIS].Type = UNSIGNED ;
  2100. FieldMap[CKX2DIS].Mask = FieldCreateMask(CKX2DIS) ;
  2101. /* FIELDS*/
  2102. strcpy(FieldMap[INVADCLK].Name,"INVADCLK") ;
  2103. FieldMap[INVADCLK].Reg  = CTRL_4 ;
  2104. FieldMap[INVADCLK].Pos  = 3     ;
  2105. FieldMap[INVADCLK].Bits = 1     ;
  2106. FieldMap[INVADCLK].Type = UNSIGNED ;
  2107. FieldMap[INVADCLK].Mask = FieldCreateMask(INVADCLK) ;
  2108. /* FIELDS*/
  2109. strcpy(FieldMap[M_OEN].Name,"M_OEN") ;
  2110. FieldMap[M_OEN].Reg  = CTRL_4 ;
  2111. FieldMap[M_OEN].Pos  = 4     ;
  2112. FieldMap[M_OEN].Bits = 1     ;
  2113. FieldMap[M_OEN].Type = UNSIGNED ;
  2114. FieldMap[M_OEN].Mask = FieldCreateMask(M_OEN) ;
  2115. /* FIELDS*/
  2116. strcpy(FieldMap[AGC_OD].Name,"AGC_OD") ;
  2117. FieldMap[AGC_OD].Reg  = CTRL_4 ;
  2118. FieldMap[AGC_OD].Pos  = 5     ;
  2119. FieldMap[AGC_OD].Bits = 1     ;
  2120. FieldMap[AGC_OD].Type = UNSIGNED ;
  2121. FieldMap[AGC_OD].Mask = FieldCreateMask(AGC_OD) ;
  2122. /* CTRL_5*/
  2123. RegMap[CTRL_5].Addr   = 0x85 ;
  2124. RegMap[CTRL_5].Reset  = 0xA2 ;
  2125. RegMap[CTRL_5].Value  = 0x00 ;
  2126. strcpy(RegMap[CTRL_5].Name,"CTRL_5") ;
  2127. /* FIELDS*/
  2128. strcpy(FieldMap[LOCKPOL].Name,"LOCKPOL") ;
  2129. FieldMap[LOCKPOL].Reg  = CTRL_5 ;
  2130. FieldMap[LOCKPOL].Pos  = 7     ;
  2131. FieldMap[LOCKPOL].Bits = 1     ;
  2132. FieldMap[LOCKPOL].Type = UNSIGNED ;
  2133. FieldMap[LOCKPOL].Mask = FieldCreateMask(LOCKPOL) ;
  2134. /* FIELDS*/
  2135. strcpy(FieldMap[DY_SY_MASK].Name,"DY_SY_MASK") ;
  2136. FieldMap[DY_SY_MASK].Reg  = CTRL_5 ;
  2137. FieldMap[DY_SY_MASK].Pos  = 6     ;
  2138. FieldMap[DY_SY_MASK].Bits = 1     ;
  2139. FieldMap[DY_SY_MASK].Type = UNSIGNED ;
  2140. FieldMap[DY_SY_MASK].Mask = FieldCreateMask(DY_SY_MASK) ;
  2141. /* FIELDS*/
  2142. strcpy(FieldMap[DY_SY_EV].Name,"DY_SY_EV") ;
  2143. FieldMap[DY_SY_EV].Reg  = CTRL_5 ;
  2144. FieldMap[DY_SY_EV].Pos  = 5     ;
  2145. FieldMap[DY_SY_EV].Bits = 1     ;
  2146. FieldMap[DY_SY_EV].Type = UNSIGNED ;
  2147. FieldMap[DY_SY_EV].Mask = FieldCreateMask(DY_SY_EV) ;
  2148. /* FIELDS*/
  2149. strcpy(FieldMap[DY_SY_DIR].Name,"DY_SY_DIR") ;
  2150. FieldMap[DY_SY_DIR].Reg  = CTRL_5 ;
  2151. FieldMap[DY_SY_DIR].Pos  = 4     ;
  2152. FieldMap[DY_SY_DIR].Bits = 1     ;
  2153. FieldMap[DY_SY_DIR].Type = UNSIGNED ;
  2154. FieldMap[DY_SY_DIR].Mask = FieldCreateMask(DY_SY_DIR) ;
  2155. /* FIELDS*/
  2156. strcpy(FieldMap[SYNC_MSK].Name,"SYNC_MSK") ;
  2157. FieldMap[SYNC_MSK].Reg  = CTRL_5 ;
  2158. FieldMap[SYNC_MSK].Pos  = 2     ;
  2159. FieldMap[SYNC_MSK].Bits = 1     ;
  2160. FieldMap[SYNC_MSK].Type = UNSIGNED ;
  2161. FieldMap[SYNC_MSK].Mask = FieldCreateMask(SYNC_MSK) ;
  2162. /* FIELDS*/
  2163. strcpy(FieldMap[SYNC_EV].Name,"SYNC_EV") ;
  2164. FieldMap[SYNC_EV].Reg  = CTRL_5 ;
  2165. FieldMap[SYNC_EV].Pos  = 1     ;
  2166. FieldMap[SYNC_EV].Bits = 1     ;
  2167. FieldMap[SYNC_EV].Type = UNSIGNED ;
  2168. FieldMap[SYNC_EV].Mask = FieldCreateMask(SYNC_EV) ;
  2169. /* FIELDS*/
  2170. strcpy(FieldMap[SYNC_DIR].Name,"SYNC_DIR") ;
  2171. FieldMap[SYNC_DIR].Reg  = CTRL_5 ;
  2172. FieldMap[SYNC_DIR].Pos  = 0     ;
  2173. FieldMap[SYNC_DIR].Bits = 1     ;
  2174. FieldMap[SYNC_DIR].Type = UNSIGNED ;
  2175. FieldMap[SYNC_DIR].Mask = FieldCreateMask(SYNC_DIR) ;
  2176. /* CTRL_6*/
  2177. RegMap[CTRL_6].Addr   = 0x86 ;
  2178. RegMap[CTRL_6].Reset  = 0x08 ;
  2179. RegMap[CTRL_6].Value  = 0x40 ;
  2180. strcpy(RegMap[CTRL_6].Name,"CTRL_6") ;
  2181. /* FIELDS*/
  2182. strcpy(FieldMap[I2CT_EN].Name,"I2CT_EN") ;
  2183. FieldMap[I2CT_EN].Reg  = CTRL_6 ;
  2184. FieldMap[I2CT_EN].Pos  = 7     ;
  2185. FieldMap[I2CT_EN].Bits = 1     ;
  2186. FieldMap[I2CT_EN].Type = UNSIGNED ;
  2187. FieldMap[I2CT_EN].Mask = FieldCreateMask(I2CT_EN) ;
  2188. /* FIELDS*/
  2189. strcpy(FieldMap[SCLT_OD].Name,"SCLT_OD") ;
  2190. FieldMap[SCLT_OD].Reg  = CTRL_6 ;
  2191. FieldMap[SCLT_OD].Pos  = 6     ;
  2192. FieldMap[SCLT_OD].Bits = 1     ;
  2193. FieldMap[SCLT_OD].Type = UNSIGNED ;
  2194. FieldMap[SCLT_OD].Mask = FieldCreateMask(SCLT_OD) ;
  2195. /* FIELDS*/
  2196. strcpy(FieldMap[EXTADCLK_EN].Name,"EXTADCLK_EN") ;
  2197. FieldMap[EXTADCLK_EN].Reg  = CTRL_6 ;
  2198. FieldMap[EXTADCLK_EN].Pos  = 5     ;
  2199. FieldMap[EXTADCLK_EN].Bits = 1     ;
  2200. FieldMap[EXTADCLK_EN].Type = UNSIGNED ;
  2201. FieldMap[EXTADCLK_EN].Mask = FieldCreateMask(EXTADCLK_EN) ;
  2202. /* FIELDS*/
  2203. strcpy(FieldMap[ITLOCKSEL].Name,"ITLOCKSEL") ;
  2204. FieldMap[ITLOCKSEL].Reg  = CTRL_6 ;
  2205. FieldMap[ITLOCKSEL].Pos  = 4     ;
  2206. FieldMap[ITLOCKSEL].Bits = 1     ;
  2207. FieldMap[ITLOCKSEL].Type = UNSIGNED ;
  2208. FieldMap[ITLOCKSEL].Mask = FieldCreateMask(ITLOCKSEL) ;
  2209. /* FIELDS*/
  2210. strcpy(FieldMap[ITPWMSEL].Name,"ITPWMSEL") ;
  2211. FieldMap[ITPWMSEL].Reg  = CTRL_6 ;
  2212. FieldMap[ITPWMSEL].Pos  = 3     ;
  2213. FieldMap[ITPWMSEL].Bits = 1     ;
  2214. FieldMap[ITPWMSEL].Type = UNSIGNED ;
  2215. FieldMap[ITPWMSEL].Mask = FieldCreateMask(ITPWMSEL) ;
  2216. /* FIELDS*/
  2217. strcpy(FieldMap[LOCKSCE].Name,"LOCKSCE") ;
  2218. FieldMap[LOCKSCE].Reg  = CTRL_6 ;
  2219. FieldMap[LOCKSCE].Pos  = 1     ;
  2220. FieldMap[LOCKSCE].Bits = 2     ;
  2221. FieldMap[LOCKSCE].Type = UNSIGNED ;
  2222. FieldMap[LOCKSCE].Mask = FieldCreateMask(LOCKSCE) ;
  2223. /* FIELDS*/
  2224. strcpy(FieldMap[TWB_ACT].Name,"TWB_ACT") ;
  2225. FieldMap[TWB_ACT].Reg  = CTRL_6 ;
  2226. FieldMap[TWB_ACT].Pos  = 0     ;
  2227. FieldMap[TWB_ACT].Bits = 1     ;
  2228. FieldMap[TWB_ACT].Type = UNSIGNED ;
  2229. FieldMap[TWB_ACT].Mask = FieldCreateMask(TWB_ACT) ;
  2230. /* CTRL_7*/
  2231. RegMap[CTRL_7].Addr   = 0x87 ;
  2232. RegMap[CTRL_7].Reset  = 0x63 ; 
  2233. RegMap[CTRL_7].Value  = 0x03 ;
  2234. strcpy(RegMap[CTRL_7].Name,"CTRL_7") ;
  2235. /* FIELDS*/
  2236. strcpy(FieldMap[SOURCESEL].Name,"SOURCESEL") ;
  2237. FieldMap[SOURCESEL].Reg  = CTRL_7 ;
  2238. FieldMap[SOURCESEL].Pos  = 7     ;
  2239. FieldMap[SOURCESEL].Bits = 1     ;
  2240. FieldMap[SOURCESEL].Type = UNSIGNED ;
  2241. FieldMap[SOURCESEL].Mask = FieldCreateMask(SOURCESEL) ;
  2242. /* FIELDS*/
  2243. strcpy(FieldMap[PRGCLKDIV].Name,"PRGCLKDIV") ;
  2244. FieldMap[PRGCLKDIV].Reg  = CTRL_7 ;
  2245. FieldMap[PRGCLKDIV].Pos  = 4     ;
  2246. FieldMap[PRGCLKDIV].Bits = 3     ;
  2247. FieldMap[PRGCLKDIV].Type = UNSIGNED ;
  2248. FieldMap[PRGCLKDIV].Mask = FieldCreateMask(PRGCLKDIV) ;
  2249. /* FIELDS*/
  2250. strcpy(FieldMap[AUXCLKSEL].Name,"AUXCLKSEL") ;
  2251. FieldMap[AUXCLKSEL].Reg  = CTRL_7 ;
  2252. FieldMap[AUXCLKSEL].Pos  = 3      ;
  2253. FieldMap[AUXCLKSEL].Bits = 1      ;
  2254. FieldMap[AUXCLKSEL].Type = UNSIGNED ;
  2255. FieldMap[AUXCLKSEL].Mask = FieldCreateMask(AUXCLKSEL) ;
  2256. /* FIELDS*/
  2257. strcpy(FieldMap[ITLOCK_OD].Name,"ITLOCK_OD") ;
  2258. FieldMap[ITLOCK_OD].Reg  = CTRL_7 ;
  2259. FieldMap[ITLOCK_OD].Pos  = 1      ;
  2260. FieldMap[ITLOCK_OD].Bits = 1      ;
  2261. FieldMap[ITLOCK_OD].Type = UNSIGNED ;
  2262. FieldMap[ITLOCK_OD].Mask = FieldCreateMask(ITLOCK_OD) ;
  2263. /* FIELDS*/
  2264. strcpy(FieldMap[ITPWM_OD].Name,"ITPWM_OD") ;
  2265. FieldMap[ITPWM_OD].Reg  = CTRL_7 ;
  2266. FieldMap[ITPWM_OD].Pos  = 0      ;
  2267. FieldMap[ITPWM_OD].Bits = 1      ;
  2268. FieldMap[ITPWM_OD].Type = UNSIGNED ;
  2269. FieldMap[ITPWM_OD].Mask = FieldCreateMask(ITPWM_OD) ;
  2270. /* CTRL_8*/
  2271. RegMap[CTRL_8].Addr   = 0x88 ;
  2272. RegMap[CTRL_8].Reset  = 0x00 ;
  2273. RegMap[CTRL_8].Value  = 0x00 ;
  2274. strcpy(RegMap[CTRL_8].Name,"CTRL_8") ;
  2275. /* FIELDS*/
  2276. strcpy(FieldMap[AGC12SEL].Name,"AGC12SEL") ;
  2277. FieldMap[AGC12SEL].Reg  = CTRL_8 ;
  2278. FieldMap[AGC12SEL].Pos  = 7      ;
  2279. FieldMap[AGC12SEL].Bits = 1      ;
  2280. FieldMap[AGC12SEL].Type = UNSIGNED ;
  2281. FieldMap[AGC12SEL].Mask = FieldCreateMask(AGC12SEL) ;
  2282. /* FIELDS*/
  2283. strcpy(FieldMap[AGC12B_EN].Name,"AGC12B_EN") ;
  2284. FieldMap[AGC12B_EN].Reg  = CTRL_8 ;
  2285. FieldMap[AGC12B_EN].Pos  = 6      ;
  2286. FieldMap[AGC12B_EN].Bits = 1      ;
  2287. FieldMap[AGC12B_EN].Type = UNSIGNED ;
  2288. FieldMap[AGC12B_EN].Mask = FieldCreateMask(AGC12B_EN) ;
  2289. /* FIELDS*/
  2290. strcpy(FieldMap[SIGMA_INV_1].Name,"SIGMA_INV_1") ;
  2291. FieldMap[SIGMA_INV_1].Reg  = CTRL_8 ;
  2292. FieldMap[SIGMA_INV_1].Pos  = 5      ;
  2293. FieldMap[SIGMA_INV_1].Bits = 1      ;
  2294. FieldMap[SIGMA_INV_1].Type = UNSIGNED ;
  2295. FieldMap[SIGMA_INV_1].Mask = FieldCreateMask(SIGMA_INV_1) ;
  2296. /* FIELDS*/
  2297. strcpy(FieldMap[SIGMA_INV_2].Name,"SIGMA_INV_2") ;
  2298. FieldMap[SIGMA_INV_2].Reg  = CTRL_8 ;
  2299. FieldMap[SIGMA_INV_2].Pos  = 4      ;
  2300. FieldMap[SIGMA_INV_2].Bits = 1      ;
  2301. FieldMap[SIGMA_INV_2].Type = UNSIGNED ;
  2302. FieldMap[SIGMA_INV_2].Mask = FieldCreateMask(SIGMA_INV_2) ;
  2303. /* FIELDS*/
  2304. strcpy(FieldMap[EN_CORNER_DET].Name,"EN_CORNER_DET") ;
  2305. FieldMap[EN_CORNER_DET].Reg  = CTRL_8 ;
  2306. FieldMap[EN_CORNER_DET].Pos  = 3      ;
  2307. FieldMap[EN_CORNER_DET].Bits = 1      ;
  2308. FieldMap[EN_CORNER_DET].Type = UNSIGNED ;
  2309. FieldMap[EN_CORNER_DET].Mask = FieldCreateMask(EN_CORNER_DET) ;
  2310. /* CTRL_9*/
  2311. RegMap[CTRL_9].Addr   = 0x89 ;
  2312. RegMap[CTRL_9].Reset  = 0x00 ;
  2313. RegMap[CTRL_9].Value  = 0x00 ;
  2314. strcpy(RegMap[CTRL_9].Name,"CTRL_9") ;
  2315. /* FIELDS*/
  2316. strcpy(FieldMap[AUTOQAMMODE_SEL].Name,"AUTOQAMMODE_SEL") ;
  2317. FieldMap[AUTOQAMMODE_SEL].Reg  = CTRL_9 ;
  2318. FieldMap[AUTOQAMMODE_SEL].Pos  = 7      ;
  2319. FieldMap[AUTOQAMMODE_SEL].Bits = 1      ;
  2320. FieldMap[AUTOQAMMODE_SEL].Type = UNSIGNED ;
  2321. FieldMap[AUTOQAMMODE_SEL].Mask = FieldCreateMask(AUTOQAMMODE_SEL) ;
  2322. /* FIELDS*/
  2323. strcpy(FieldMap[AUTOCONSTEL_TIMER].Name,"AUTOCONSTEL_TIMER") ;
  2324. FieldMap[AUTOCONSTEL_TIMER].Reg  = CTRL_9 ;
  2325. FieldMap[AUTOCONSTEL_TIMER].Pos  = 3      ;
  2326. FieldMap[AUTOCONSTEL_TIMER].Bits = 4      ;
  2327. FieldMap[AUTOCONSTEL_TIMER].Type = UNSIGNED ;
  2328. FieldMap[AUTOCONSTEL_TIMER].Mask = FieldCreateMask(AUTOCONSTEL_TIMER) ;
  2329. /* FIELDS*/
  2330. strcpy(FieldMap[AUTOSTOP_CONSTEL].Name,"AUTOSTOP_CONSTEL") ;
  2331. FieldMap[AUTOSTOP_CONSTEL].Reg  = CTRL_9 ;
  2332. FieldMap[AUTOSTOP_CONSTEL].Pos  = 2      ;
  2333. FieldMap[AUTOSTOP_CONSTEL].Bits = 1      ;
  2334. FieldMap[AUTOSTOP_CONSTEL].Type = UNSIGNED ;
  2335. FieldMap[AUTOSTOP_CONSTEL].Mask = FieldCreateMask(AUTOSTOP_CONSTEL) ;
  2336. /* FIELDS*/
  2337. strcpy(FieldMap[AUTOCONSTEL_ON].Name,"AUTOCONSTEL_ON") ;
  2338. FieldMap[AUTOCONSTEL_ON].Reg  = CTRL_9 ;
  2339. FieldMap[AUTOCONSTEL_ON].Pos  = 1      ;
  2340. FieldMap[AUTOCONSTEL_ON].Bits = 1      ;
  2341. FieldMap[AUTOCONSTEL_ON].Type = UNSIGNED ;
  2342. FieldMap[AUTOCONSTEL_ON].Mask = FieldCreateMask(AUTOCONSTEL_ON) ;
  2343. /* DEINT_SYNC_0*/
  2344. RegMap[DEINT_SYNC_0].Addr   = 0x90 ;
  2345. RegMap[DEINT_SYNC_0].Reset  = 0x00 ;
  2346. RegMap[DEINT_SYNC_0].Value  = 0x01 ;
  2347. strcpy(RegMap[DEINT_SYNC_0].Name,"DEINT_SYNC_0") ;
  2348. /* FIELDS*/
  2349. strcpy(FieldMap[DI_UNLOCK].Name,"DI_UNLOCK") ;
  2350. FieldMap[DI_UNLOCK].Reg  = DEINT_SYNC_0 ;
  2351. FieldMap[DI_UNLOCK].Pos  = 7     ;
  2352. FieldMap[DI_UNLOCK].Bits = 1     ;
  2353. FieldMap[DI_UNLOCK].Type = UNSIGNED ;
  2354. FieldMap[DI_UNLOCK].Mask = FieldCreateMask(DI_UNLOCK) ;
  2355. /* FIELDS*/
  2356. strcpy(FieldMap[DI_FREEZE].Name,"DI_FREEZE") ;
  2357. FieldMap[DI_FREEZE].Reg  = DEINT_SYNC_0 ;
  2358. FieldMap[DI_FREEZE].Pos  = 6     ;
  2359. FieldMap[DI_FREEZE].Bits = 1     ;
  2360. FieldMap[DI_FREEZE].Type = UNSIGNED ;
  2361. FieldMap[DI_FREEZE].Mask = FieldCreateMask(DI_FREEZE) ;
  2362. /* FIELDS*/
  2363. strcpy(FieldMap[MISMATCH].Name,"MISMATCH") ;
  2364. FieldMap[MISMATCH].Reg  = DEINT_SYNC_0 ;
  2365. FieldMap[MISMATCH].Pos  = 4     ;
  2366. FieldMap[MISMATCH].Bits = 2     ;
  2367. FieldMap[MISMATCH].Type = UNSIGNED ;
  2368. FieldMap[MISMATCH].Mask = FieldCreateMask(MISMATCH) ;
  2369. /* FIELDS*/
  2370. strcpy(FieldMap[ACQ_MODE].Name,"ACQ_MODE") ;
  2371. FieldMap[ACQ_MODE].Reg  = DEINT_SYNC_0 ;
  2372. FieldMap[ACQ_MODE].Pos  = 2     ;
  2373. FieldMap[ACQ_MODE].Bits = 2     ;
  2374. FieldMap[ACQ_MODE].Type = UNSIGNED ;
  2375. FieldMap[ACQ_MODE].Mask = FieldCreateMask(ACQ_MODE) ;
  2376. /* FIELDS*/
  2377. strcpy(FieldMap[TRKMODE].Name,"TRKMODE") ;
  2378. FieldMap[TRKMODE].Reg  = DEINT_SYNC_0 ;
  2379. FieldMap[TRKMODE].Pos  = 0     ;
  2380. FieldMap[TRKMODE].Bits = 2     ;
  2381. FieldMap[TRKMODE].Type = UNSIGNED ;
  2382. FieldMap[TRKMODE].Mask = FieldCreateMask(TRKMODE) ;
  2383. /* DEINT_SYNC_1*/
  2384. RegMap[DEINT_SYNC_1].Addr   = 0x91 ;
  2385. RegMap[DEINT_SYNC_1].Reset  = 0x04 ;
  2386. RegMap[DEINT_SYNC_1].Value  = 0x01 ;
  2387. strcpy(RegMap[DEINT_SYNC_1].Name,"DEINT_SYNC_1") ;
  2388. /* FIELDS*/
  2389. strcpy(FieldMap[SYNLOST].Name,"SYNLOST") ;
  2390. FieldMap[SYNLOST].Reg  = DEINT_SYNC_1 ;
  2391. FieldMap[SYNLOST].Pos  = 5     ;
  2392. FieldMap[SYNLOST].Bits = 1     ;
  2393. FieldMap[SYNLOST].Type = UNSIGNED ;
  2394. FieldMap[SYNLOST].Mask = FieldCreateMask(SYNLOST) ;
  2395. /* BERT_0*/
  2396. RegMap[BERT_0].Addr   = 0xA0 ;
  2397. RegMap[BERT_0].Reset  = 0x85 ; /*TIME 0.9SEC*/
  2398. RegMap[BERT_0].Value  = 0x00 ;
  2399. strcpy(RegMap[BERT_0].Name,"BERT_0") ;
  2400. /* FIELDS*/
  2401. strcpy(FieldMap[BERT_ON].Name,"BERT_ON") ;
  2402. FieldMap[BERT_ON].Reg  = BERT_0 ;
  2403. FieldMap[BERT_ON].Pos  = 7     ;
  2404. FieldMap[BERT_ON].Bits = 1     ;
  2405. FieldMap[BERT_ON].Type = UNSIGNED ;
  2406. FieldMap[BERT_ON].Mask = FieldCreateMask(BERT_ON) ;
  2407. /* FIELDS*/
  2408. strcpy(FieldMap[ERR_SOURCE].Name,"ERR_SOURCE") ;
  2409. FieldMap[ERR_SOURCE].Reg  = BERT_0 ;
  2410. FieldMap[ERR_SOURCE].Pos  = 4     ;
  2411. FieldMap[ERR_SOURCE].Bits = 1     ;
  2412. FieldMap[ERR_SOURCE].Type = UNSIGNED ;
  2413. FieldMap[ERR_SOURCE].Mask = FieldCreateMask(ERR_SOURCE) ;
  2414. /* FIELDS*/
  2415. strcpy(FieldMap[ERR_MODE].Name,"ERR_MODE") ;
  2416. FieldMap[ERR_MODE].Reg  = BERT_0 ;
  2417. FieldMap[ERR_MODE].Pos  = 3     ;
  2418. FieldMap[ERR_MODE].Bits = 1     ;
  2419. FieldMap[ERR_MODE].Type = UNSIGNED ;
  2420. FieldMap[ERR_MODE].Mask = FieldCreateMask(ERR_MODE) ;
  2421. /* FIELDS*/
  2422. strcpy(FieldMap[NBYTE].Name,"NBYTE") ;
  2423. FieldMap[NBYTE].Reg  = BERT_0 ;
  2424. FieldMap[NBYTE].Pos  = 0     ;
  2425. FieldMap[NBYTE].Bits = 3     ;
  2426. FieldMap[NBYTE].Type = UNSIGNED ;
  2427. FieldMap[NBYTE].Mask = FieldCreateMask(NBYTE) ;
  2428. /* BERT_1*/
  2429. RegMap[BERT_1].Addr   = 0xA1 ;
  2430. RegMap[BERT_1].Reset  = 0x22 ;
  2431. RegMap[BERT_1].Value  = 0x00 ;
  2432. strcpy(RegMap[BERT_1].Name,"BERT_1") ;
  2433. /* FIELDS*/
  2434. strcpy(FieldMap[ERRCOUNT_LO].Name,"ERRCOUNT_LO") ;
  2435. FieldMap[ERRCOUNT_LO].Reg  = BERT_1 ;
  2436. FieldMap[ERRCOUNT_LO].Pos  = 0     ;
  2437. FieldMap[ERRCOUNT_LO].Bits = 8     ;
  2438. FieldMap[ERRCOUNT_LO].Type = UNSIGNED ;
  2439. FieldMap[ERRCOUNT_LO].Mask = FieldCreateMask(ERRCOUNT_LO) ;
  2440. /* BERT_2*/
  2441. RegMap[BERT_2].Addr   = 0xA2 ;
  2442. RegMap[BERT_2].Reset  = 0x4C ;
  2443. RegMap[BERT_2].Value  = 0x00 ;
  2444. strcpy(RegMap[BERT_2].Name,"BERT_2") ;
  2445. /* FIELDS*/
  2446. strcpy(FieldMap[ERRCOUNT_HI].Name,"ERRCOUNT_HI") ;
  2447. FieldMap[ERRCOUNT_HI].Reg  = BERT_2 ;
  2448. FieldMap[ERRCOUNT_HI].Pos  = 0     ;
  2449. FieldMap[ERRCOUNT_HI].Bits = 8     ;
  2450. FieldMap[ERRCOUNT_HI].Type = UNSIGNED ;
  2451. FieldMap[ERRCOUNT_HI].Mask = FieldCreateMask(ERRCOUNT_HI) ;
  2452. /* DEINT_0*/
  2453. RegMap[DEINT_0].Addr   = 0xB0 ;
  2454. RegMap[DEINT_0].Reset  = 0x91 ;
  2455. RegMap[DEINT_0].Value  = 0x91 ;
  2456. strcpy(RegMap[DEINT_0].Name,"DEINT_0") ;
  2457. /* FIELDS*/
  2458. strcpy(FieldMap[USEINT].Name,"USEINT") ;
  2459. FieldMap[USEINT].Reg  = DEINT_0 ;
  2460. FieldMap[USEINT].Pos  = 7     ;
  2461. FieldMap[USEINT].Bits = 1     ;
  2462. FieldMap[USEINT].Type = UNSIGNED ;
  2463. FieldMap[USEINT].Mask = FieldCreateMask(USEINT) ;
  2464. /* FIELDS*/
  2465. strcpy(FieldMap[DAVIC].Name,"DAVIC") ;
  2466. FieldMap[DAVIC].Reg  = DEINT_0 ;
  2467. FieldMap[DAVIC].Pos  = 6     ;
  2468. FieldMap[DAVIC].Bits = 1     ;
  2469. FieldMap[DAVIC].Type = UNSIGNED ;
  2470. FieldMap[DAVIC].Mask = FieldCreateMask(DAVIC) ;
  2471. /* FIELDS*/
  2472. strcpy(FieldMap[M].Name,"M") ;
  2473. FieldMap[M].Reg  = DEINT_0 ;
  2474. FieldMap[M].Pos  = 0     ;
  2475. FieldMap[M].Bits = 5     ;
  2476. FieldMap[M].Type = UNSIGNED ;
  2477. FieldMap[M].Mask = FieldCreateMask(M) ;
  2478. /* DEINT_1*/
  2479. RegMap[DEINT_1].Addr   = 0xB1 ;
  2480. RegMap[DEINT_1].Reset  = 0x0B ;
  2481. RegMap[DEINT_1].Value  = 0x0B ;
  2482. strcpy(RegMap[DEINT_1].Name,"DEINT_1") ;
  2483. /* FIELDS*/
  2484. strcpy(FieldMap[DEPTH].Name,"DEPTH") ;
  2485. FieldMap[DEPTH].Reg  = DEINT_1 ;
  2486. FieldMap[DEPTH].Pos  = 0     ;
  2487. FieldMap[DEPTH].Bits = 8     ;
  2488. FieldMap[DEPTH].Type = UNSIGNED ;
  2489. FieldMap[DEPTH].Mask = FieldCreateMask(DEPTH) ;
  2490. /* OUTFORMAT_0*/
  2491. RegMap[OUTFORMAT_0].Addr   = 0xC0 ;
  2492. RegMap[OUTFORMAT_0].Reset  = 0x4b ; /*2001.03.02 papi*/
  2493. RegMap[OUTFORMAT_0].Value  = 0x4b ; /*2001.03.02*/
  2494. strcpy(RegMap[OUTFORMAT_0].Name,"OUTFORMAT_0") ;
  2495. /* FIELDS*/
  2496. strcpy(FieldMap[REFRESH47].Name,"REFRESH47") ;
  2497. FieldMap[REFRESH47].Reg  = OUTFORMAT_0 ;
  2498. FieldMap[REFRESH47].Pos  = 6     ;
  2499. FieldMap[REFRESH47].Bits = 1     ;
  2500. FieldMap[REFRESH47].Type = UNSIGNED ;
  2501. FieldMap[REFRESH47].Mask = FieldCreateMask(REFRESH47) ;
  2502. /* FIELDS*/
  2503. strcpy(FieldMap[BE_BYPASS].Name,"BE_BYPASS") ;
  2504. FieldMap[BE_BYPASS].Reg  = OUTFORMAT_0 ;
  2505. FieldMap[BE_BYPASS].Pos  = 5     ;
  2506. FieldMap[BE_BYPASS].Bits = 1     ;
  2507. FieldMap[BE_BYPASS].Type = UNSIGNED ;
  2508. FieldMap[BE_BYPASS].Mask = FieldCreateMask(BE_BYPASS) ;
  2509. /* FIELDS*/
  2510. strcpy(FieldMap[CKOUTPAR].Name,"CKOUTPAR") ;
  2511. FieldMap[CKOUTPAR].Reg  = OUTFORMAT_0 ;
  2512. FieldMap[CKOUTPAR].Pos  = 4     ;
  2513. FieldMap[CKOUTPAR].Bits = 1     ;
  2514. FieldMap[CKOUTPAR].Type = UNSIGNED ;
  2515. FieldMap[CKOUTPAR].Mask = FieldCreateMask(CKOUTPAR) ;
  2516. /* FIELDS*/
  2517. strcpy(FieldMap[CT_NBST].Name,"CT_NBST") ;
  2518. FieldMap[CT_NBST].Reg  = OUTFORMAT_0 ;
  2519. FieldMap[CT_NBST].Pos  = 3     ;
  2520. FieldMap[CT_NBST].Bits = 1     ;
  2521. FieldMap[CT_NBST].Type = UNSIGNED ;
  2522. FieldMap[CT_NBST].Mask = FieldCreateMask(CT_NBST) ;
  2523. /* FIELDS*/
  2524. strcpy(FieldMap[S_NP].Name,"S_NP") ;
  2525. FieldMap[S_NP].Reg  = OUTFORMAT_0 ;
  2526. FieldMap[S_NP].Pos  = 2     ;
  2527. FieldMap[S_NP].Bits = 1     ;
  2528. FieldMap[S_NP].Type = UNSIGNED ;
  2529. FieldMap[S_NP].Mask = FieldCreateMask(S_NP) ;
  2530. /* FIELDS*/
  2531. strcpy(FieldMap[TEI_ENA].Name,"TEI_ENA") ;
  2532. FieldMap[TEI_ENA].Reg  = OUTFORMAT_0 ;
  2533. FieldMap[TEI_ENA].Pos  = 1     ;
  2534. FieldMap[TEI_ENA].Bits = 1     ;
  2535. FieldMap[TEI_ENA].Type = UNSIGNED ;
  2536. FieldMap[TEI_ENA].Mask = FieldCreateMask(TEI_ENA) ;
  2537. /* FIELDS*/
  2538. strcpy(FieldMap[DS_ENA].Name,"DS_ENA") ;
  2539. FieldMap[DS_ENA].Reg  = OUTFORMAT_0 ;
  2540. FieldMap[DS_ENA].Pos  = 0     ;
  2541. FieldMap[DS_ENA].Bits = 1     ;
  2542. FieldMap[DS_ENA].Type = UNSIGNED ;
  2543. FieldMap[DS_ENA].Mask = FieldCreateMask(DS_ENA) ;
  2544. /* OUTFORMAT_1*/
  2545. RegMap[OUTFORMAT_1].Addr   = 0xC1 ;
  2546. RegMap[OUTFORMAT_1].Reset  = 0x00 ; /*2001.03.02 papi*/
  2547. RegMap[OUTFORMAT_1].Value  = 0x00 ;
  2548. strcpy(RegMap[OUTFORMAT_1].Name,"OUTFORMAT_1") ;
  2549. /* FIELDS*/
  2550. strcpy(FieldMap[SYNC_STRIP].Name,"SYNC_STRIP") ;
  2551. FieldMap[SYNC_STRIP].Reg  = OUTFORMAT_1 ;
  2552. FieldMap[SYNC_STRIP].Pos  = 7     ;
  2553. FieldMap[SYNC_STRIP].Bits = 1     ;
  2554. FieldMap[SYNC_STRIP].Type = UNSIGNED ;
  2555. FieldMap[SYNC_STRIP].Mask = FieldCreateMask(SYNC_STRIP) ;
  2556. /* FIELDS*/
  2557. strcpy(FieldMap[CI_EN].Name,"CI_EN") ;
  2558. FieldMap[CI_EN].Reg  = OUTFORMAT_1 ;
  2559. FieldMap[CI_EN].Pos  = 6     ;
  2560. FieldMap[CI_EN].Bits = 1     ;
  2561. FieldMap[CI_EN].Type = UNSIGNED ;
  2562. FieldMap[CI_EN].Mask = FieldCreateMask(CI_EN) ;
  2563. /* FIELDS*/
  2564. strcpy(FieldMap[CICLK_POL].Name,"CICLK_POL") ;
  2565. FieldMap[CICLK_POL].Reg  = OUTFORMAT_1 ;
  2566. FieldMap[CICLK_POL].Pos  = 5     ;
  2567. FieldMap[CICLK_POL].Bits = 1     ;
  2568. FieldMap[CICLK_POL].Type = UNSIGNED ;
  2569. FieldMap[CICLK_POL].Mask = FieldCreateMask(CICLK_POL) ;
  2570. /* FIELDS*/
  2571. strcpy(FieldMap[CICLK_BASE].Name,"CICLK_BASE") ;
  2572. FieldMap[CICLK_BASE].Reg  = OUTFORMAT_1 ;
  2573. FieldMap[CICLK_BASE].Pos  = 4     ;
  2574. FieldMap[CICLK_BASE].Bits = 1     ;
  2575. FieldMap[CICLK_BASE].Type = UNSIGNED ;
  2576. FieldMap[CICLK_BASE].Mask = FieldCreateMask(CICLK_BASE) ;
  2577. /* OUTFORMAT_2*/
  2578. RegMap[OUTFORMAT_2].Addr   = 0xC2 ;
  2579. RegMap[OUTFORMAT_2].Reset  = 0x00 ;
  2580. RegMap[OUTFORMAT_2].Value  = 0x24 ;
  2581. strcpy(RegMap[OUTFORMAT_2].Name,"OUTFORMAT_2") ;
  2582. /* FIELDS*/
  2583. strcpy(FieldMap[CI_DIVRANGE].Name,"CI_DIVRANGE") ;
  2584. FieldMap[CI_DIVRANGE].Reg  = OUTFORMAT_2 ;
  2585. FieldMap[CI_DIVRANGE].Pos  = 0     ;
  2586. FieldMap[CI_DIVRANGE].Bits = 6     ;
  2587. FieldMap[CI_DIVRANGE].Type = UNSIGNED ;
  2588. FieldMap[CI_DIVRANGE].Mask = FieldCreateMask(CI_DIVRANGE) ;
  2589. /* RS_DESC_0*/
  2590. RegMap[RS_DESC_0].Addr   = 0xD0 ;
  2591. RegMap[RS_DESC_0].Reset  = 0x6E ;
  2592. RegMap[RS_DESC_0].Value  = 0x00 ;
  2593. strcpy(RegMap[RS_DESC_0].Name,"RS_DESC_0") ;
  2594. /* FIELDS*/
  2595. strcpy(FieldMap[BK_CT_LO].Name,"BK_CT_LO") ;
  2596. FieldMap[BK_CT_LO].Reg  = RS_DESC_0 ;
  2597. FieldMap[BK_CT_LO].Pos  = 0     ;
  2598. FieldMap[BK_CT_LO].Bits = 8     ;
  2599. FieldMap[BK_CT_LO].Type = UNSIGNED ;
  2600. FieldMap[BK_CT_LO].Mask = FieldCreateMask(BK_CT_LO) ;
  2601. /* RS_DESC_1*/
  2602. RegMap[RS_DESC_1].Addr   = 0xD1 ;
  2603. RegMap[RS_DESC_1].Reset  = 0x01 ;
  2604. RegMap[RS_DESC_1].Value  = 0x00 ;
  2605. strcpy(RegMap[RS_DESC_1].Name,"RS_DESC_1") ;
  2606. /* FIELDS*/
  2607. strcpy(FieldMap[BK_CT_HI].Name,"BK_CT_HI") ;
  2608. FieldMap[BK_CT_HI].Reg  = RS_DESC_1 ;
  2609. FieldMap[BK_CT_HI].Pos  = 0     ;
  2610. FieldMap[BK_CT_HI].Bits = 8     ;
  2611. FieldMap[BK_CT_HI].Type = UNSIGNED ;
  2612. FieldMap[BK_CT_HI].Mask = FieldCreateMask(BK_CT_HI) ;
  2613. /* RS_DESC_2*/
  2614. RegMap[RS_DESC_2].Addr   = 0xD2 ;
  2615. RegMap[RS_DESC_2].Reset  = 0x00 ;
  2616. RegMap[RS_DESC_2].Value  = 0x00 ;
  2617. strcpy(RegMap[RS_DESC_2].Name,"RS_DESC_2") ;
  2618. /* FIELDS*/
  2619. strcpy(FieldMap[CORR_CT_LO].Name,"CORR_CT_LO") ;
  2620. FieldMap[CORR_CT_LO].Reg  = RS_DESC_2 ;
  2621. FieldMap[CORR_CT_LO].Pos  = 0     ;
  2622. FieldMap[CORR_CT_LO].Bits = 8     ;
  2623. FieldMap[CORR_CT_LO].Type = UNSIGNED ;
  2624. FieldMap[CORR_CT_LO].Mask = FieldCreateMask(CORR_CT_LO) ;
  2625. /* RS_DESC_3*/
  2626. RegMap[RS_DESC_3].Addr   = 0xD3 ;
  2627. RegMap[RS_DESC_3].Reset  = 0x00 ;
  2628. RegMap[RS_DESC_3].Value  = 0x00 ;
  2629. strcpy(RegMap[RS_DESC_3].Name,"RS_DESC_3") ;
  2630. /* FIELDS*/
  2631. strcpy(FieldMap[CORR_CT_HI].Name,"CORR_CT_HI") ;
  2632. FieldMap[CORR_CT_HI].Reg  = RS_DESC_3 ;
  2633. FieldMap[CORR_CT_HI].Pos  = 0     ;
  2634. FieldMap[CORR_CT_HI].Bits = 8     ;
  2635. FieldMap[CORR_CT_HI].Type = UNSIGNED ;
  2636. FieldMap[CORR_CT_HI].Mask = FieldCreateMask(CORR_CT_HI) ;
  2637. /* RS_DESC_4*/
  2638. RegMap[RS_DESC_4].Addr   = 0xD4 ;
  2639. RegMap[RS_DESC_4].Reset  = 0x6D ;
  2640. RegMap[RS_DESC_4].Value  = 0x00 ;
  2641. strcpy(RegMap[RS_DESC_4].Name,"RS_DESC_4") ;
  2642. /* FIELDS*/
  2643. strcpy(FieldMap[UNCORR_CT_LO].Name,"UNCORR_CT_LO") ;
  2644. FieldMap[UNCORR_CT_LO].Reg  = RS_DESC_4 ;
  2645. FieldMap[UNCORR_CT_LO].Pos  = 0     ;
  2646. FieldMap[UNCORR_CT_LO].Bits = 8     ;
  2647. FieldMap[UNCORR_CT_LO].Type = UNSIGNED ;
  2648. FieldMap[UNCORR_CT_LO].Mask = FieldCreateMask(UNCORR_CT_LO) ;
  2649. /* RS_DESC_5*/
  2650. RegMap[RS_DESC_5].Addr   = 0xD5 ;
  2651. RegMap[RS_DESC_5].Reset  = 0x01 ;
  2652. RegMap[RS_DESC_5].Value  = 0x00 ;
  2653. strcpy(RegMap[RS_DESC_5].Name,"RS_DESC_5") ;
  2654. /* FIELDS*/
  2655. strcpy(FieldMap[UNCORR_CT_HI].Name,"UNCORR_CT_HI") ;
  2656. FieldMap[UNCORR_CT_HI].Reg  = RS_DESC_5 ;
  2657. FieldMap[UNCORR_CT_HI].Pos  = 0     ;
  2658. FieldMap[UNCORR_CT_HI].Bits = 8     ;
  2659. FieldMap[UNCORR_CT_HI].Type = UNSIGNED ;
  2660. FieldMap[UNCORR_CT_HI].Mask = FieldCreateMask(UNCORR_CT_HI) ;
  2661. /* RS_DESC_14*/
  2662. RegMap[RS_DESC_14].Addr   = 0xDE ;
  2663. RegMap[RS_DESC_14].Reset  = 0x00 ;
  2664. RegMap[RS_DESC_14].Value  = 0x00 ;
  2665. strcpy(RegMap[RS_DESC_14].Name,"RS_DESC_14") ;
  2666. /* FIELDS*/
  2667. strcpy(FieldMap[DIS_UNLOCK].Name,"DIS_UNLOCK") ;
  2668. FieldMap[DIS_UNLOCK].Reg  = RS_DESC_14 ;
  2669. FieldMap[DIS_UNLOCK].Pos  = 2     ;
  2670. FieldMap[DIS_UNLOCK].Bits = 1     ;
  2671. FieldMap[DIS_UNLOCK].Type = UNSIGNED ;
  2672. FieldMap[DIS_UNLOCK].Mask = FieldCreateMask(DIS_UNLOCK) ;
  2673. /* FIELDS*/
  2674. strcpy(FieldMap[MODE].Name,"MODE") ;
  2675. FieldMap[MODE].Reg  = RS_DESC_14 ;
  2676. FieldMap[MODE].Pos  = 0     ;
  2677. FieldMap[MODE].Bits = 2     ;
  2678. FieldMap[MODE].Type = UNSIGNED ;
  2679. FieldMap[MODE].Mask = FieldCreateMask(MODE) ;
  2680. /* RS_DESC_15*/
  2681. RegMap[RS_DESC_15].Addr   = 0xDF ;
  2682. RegMap[RS_DESC_15].Reset  = 0x01 ;
  2683. RegMap[RS_DESC_15].Value  = 0x00 ;
  2684. strcpy(RegMap[RS_DESC_15].Name,"RS_DESC_15") ;
  2685. /* FIELDS*/
  2686. strcpy(FieldMap[CT_CLEAR].Name,"CT_CLEAR") ;
  2687. FieldMap[CT_CLEAR].Reg  = RS_DESC_15 ;
  2688. FieldMap[CT_CLEAR].Pos  = 0     ;
  2689. FieldMap[CT_CLEAR].Bits = 1     ;
  2690. FieldMap[CT_CLEAR].Type = UNSIGNED ;
  2691. FieldMap[CT_CLEAR].Mask = FieldCreateMask(CT_CLEAR) ;
  2692. /* FIELDS*/
  2693. strcpy(FieldMap[CT_HOLD].Name,"CT_HOLD") ;
  2694. FieldMap[CT_HOLD].Reg  = RS_DESC_15 ;
  2695. FieldMap[CT_HOLD].Pos  = 1     ;
  2696. FieldMap[CT_HOLD].Bits = 1     ;
  2697. FieldMap[CT_HOLD].Type = UNSIGNED ;
  2698. FieldMap[CT_HOLD].Mask = FieldCreateMask(CT_HOLD) ;
  2699. /* FIELDS*/
  2700. strcpy(FieldMap[RS_NOCORR].Name,"RS_NOCORR") ;
  2701. FieldMap[RS_NOCORR].Reg  = RS_DESC_15 ;
  2702. FieldMap[RS_NOCORR].Pos  = 2     ;
  2703. FieldMap[RS_NOCORR].Bits = 1     ;
  2704. FieldMap[RS_NOCORR].Type = UNSIGNED ;
  2705. FieldMap[RS_NOCORR].Mask = FieldCreateMask(RS_NOCORR) ;
  2706. /* FIELDS*/
  2707. strcpy(FieldMap[SYNCSTATE].Name,"SYNCSTATE") ;
  2708. FieldMap[SYNCSTATE].Reg  = RS_DESC_15 ;
  2709. FieldMap[SYNCSTATE].Pos  = 7     ;
  2710. FieldMap[SYNCSTATE].Bits = 1     ;
  2711. FieldMap[SYNCSTATE].Type = UNSIGNED ;
  2712. FieldMap[SYNCSTATE].Mask = FieldCreateMask(SYNCSTATE) ;
  2713. //RegTrigger      = NO ;
  2714. //RegNbI2cAccess  =  0 ;
  2715. //count           =  0 ;
  2716. //RegTracking     = NO ;
  2717.    
  2718.     RegSTV0297reset() ;
  2719.     RegResetAfterDI() ;
  2720.     RegReset()        ;
  2721.     
  2722.     _ExtClk = (INT32)(10*EXT_CLK) ;    
  2723. RegGetQAMSize()   ;
  2724. RegSetSymbolRate(Driv0297Signal.SymbolRate) ; 
  2725. return;
  2726. }
  2727. void QAM64_Regreset(void)
  2728. {
  2729. INT16 i;
  2730. INT32 S32val;
  2731.     RegSTV0297reset() ;
  2732.     RegResetAfterDI() ;
  2733. RegSetOneRegister(EQU_0,0x48);
  2734. RegSetOneRegister(EQU_1,0x58);    
  2735. RegSetOneRegister(EQU_3,0x00);
  2736. RegSetOneRegister(EQU_4,0x00);
  2737. RegSetOneRegister(EQU_7,0x00);
  2738. RegSetOneRegister(EQU_8,0x00);
  2739. RegSetOneRegister(INITDEM_0,0x00);
  2740. RegSetOneRegister(INITDEM_1,0x40);
  2741. RegSetOneRegister(INITDEM_2,0x00);
  2742. RegSetOneRegister(INITDEM_3,0x00);
  2743. RegSetOneRegister(INITDEM_4,0x40);
  2744. RegSetOneRegister(INITDEM_5,0x08);
  2745. RegSetOneRegister(DELAGC_0,0xE6);
  2746. RegSetOneRegister(DELAGC_1,0x91);
  2747. RegSetOneRegister(DELAGC_2,0xFD);
  2748. RegSetOneRegister(DELAGC_3,0x44);
  2749. RegSetOneRegister(DELAGC_4,0x29);
  2750. RegSetOneRegister(DELAGC_5,0x8F);
  2751. RegSetOneRegister(DELAGC_6,0x80);
  2752. RegSetOneRegister(DELAGC_7,0x70);
  2753. RegSetOneRegister(DELAGC_8,0x00);
  2754. RegSetOneRegister(WBAGC_0,0x1A);
  2755. RegSetOneRegister(WBAGC_1,0x64);
  2756. RegSetOneRegister(WBAGC_2,0x31);
  2757. RegSetOneRegister(WBAGC_3,0x18);
  2758. RegSetOneRegister(WBAGC_4,0xFF);
  2759. RegSetOneRegister(WBAGC_5,0x00);
  2760. RegSetOneRegister(WBAGC_6,0x00);
  2761. RegSetOneRegister(WBAGC_9,0x04);
  2762. RegSetOneRegister(WBAGC_10,0x51);
  2763. RegSetOneRegister(WBAGC_11,0xF8);
  2764. RegSetOneRegister(STLOOP_2,0x30);
  2765. RegSetOneRegister(STLOOP_3,0x06);
  2766. RegSetOneRegister(STLOOP_5,0x6A);
  2767. RegSetOneRegister(STLOOP_6,0xA3);
  2768. RegSetOneRegister(STLOOP_7,0x8B);
  2769. RegSetOneRegister(STLOOP_8,0x39);
  2770. RegSetOneRegister(STLOOP_9,0x06);
  2771. RegSetOneRegister(STLOOP_10,0x5E);
  2772. RegSetOneRegister(STLOOP_11,0x04);
  2773. RegSetOneRegister(CRL_0,0x16);
  2774. RegSetOneRegister(CRL_1,0x49);
  2775. RegSetOneRegister(CRL_2,0x05);
  2776. RegSetOneRegister(CRL_3,0x00);
  2777. RegSetOneRegister(CRL_4,0x00);
  2778. RegSetOneRegister(CRL_5,0x00);
  2779. RegSetOneRegister(CRL_6,0xBF);
  2780. RegSetOneRegister(CRL_7,0x0D);
  2781. RegSetOneRegister(CRL_8,0xF8);
  2782. RegSetOneRegister(CRL_9,0x0D);
  2783. RegSetOneRegister(CRL_10,0x03);
  2784. RegSetOneRegister(CRL_11,0x92);
  2785. RegSetOneRegister(PMFAGC_0,0xFF);
  2786. RegSetOneRegister(PMFAGC_1,0x04);
  2787. RegSetOneRegister(PMFAGC_2,0x00);
  2788. RegSetOneRegister(PMFAGC_3,0x00);
  2789. RegSetOneRegister(PMFAGC_4,0x00);
  2790. RegSetOneRegister(CTRL_0,0x20);
  2791. RegSetOneRegister(CTRL_1,0x00);
  2792. RegSetOneRegister(CTRL_2,0x27);
  2793. RegSetOneRegister(CTRL_3,0x08);
  2794. RegSetOneRegister(CTRL_4,0x02);
  2795. RegSetOneRegister(CTRL_5,0xA2);
  2796. RegSetOneRegister(CTRL_6,0x08);
  2797. RegSetOneRegister(CTRL_7,0x63);
  2798. RegSetOneRegister(CTRL_8,0x00);
  2799. RegSetOneRegister(CTRL_9,0x00);
  2800. RegSetOneRegister(DEINT_SYNC_0,0x00);
  2801. RegSetOneRegister(DEINT_SYNC_1,0x04);
  2802. RegSetOneRegister(BERT_0,0x85);
  2803. RegSetOneRegister(BERT_1,0x22);
  2804. RegSetOneRegister(BERT_2,0x4C);
  2805. RegSetOneRegister(DEINT_0,0x91);
  2806. RegSetOneRegister(DEINT_1,0x0B);
  2807. RegSetOneRegister(OUTFORMAT_0,0x4B);
  2808. RegSetOneRegister(OUTFORMAT_1,0x00);
  2809. RegSetOneRegister(OUTFORMAT_2,0x00);
  2810. RegSetOneRegister(RS_DESC_0,0x6E);
  2811. RegSetOneRegister(RS_DESC_1,0x01);
  2812. RegSetOneRegister(RS_DESC_2,0x00);
  2813. RegSetOneRegister(RS_DESC_3,0x00);
  2814. RegSetOneRegister(RS_DESC_4,0x6D);
  2815. RegSetOneRegister(RS_DESC_5,0x01);
  2816. RegSetOneRegister(RS_DESC_14,0x00);
  2817. RegSetOneRegister(RS_DESC_15,0x01);
  2818. //RegTrigger      = NO ;
  2819. //RegNbI2cAccess  =  0 ;
  2820. //count           =  0 ;
  2821. //RegTracking     = NO ;
  2822.     
  2823.     _ExtClk = (INT32)(10*EXT_CLK) ;   
  2824. RegGetQAMSize()   ;
  2825. RegSetSymbolRate(Driv0297Signal.SymbolRate) ; 
  2826. return;
  2827. }
  2829. void QAM256_Regreset(void)
  2830. {
  2831. INT16 i;
  2832. INT32 S32val;
  2833.     RegSTV0297reset() ;
  2834.     RegResetAfterDI() ;
  2835. RegSetOneRegister(EQU_0,0x38);
  2836. RegSetOneRegister(EQU_1,0x58); 
  2837. RegSetOneRegister(EQU_3,0x00);
  2838. RegSetOneRegister(EQU_4,0x01);
  2839. RegSetOneRegister(EQU_7,0xe8);
  2840. RegSetOneRegister(EQU_8,0x0b);
  2841. RegSetOneRegister(INITDEM_0,0x00);
  2842. RegSetOneRegister(INITDEM_1,0x40);
  2843. RegSetOneRegister(INITDEM_2,0x00);
  2844. RegSetOneRegister(INITDEM_3,0x00);
  2845. RegSetOneRegister(INITDEM_4,0x40);
  2846. RegSetOneRegister(INITDEM_5,0x08);
  2847. RegSetOneRegister(DELAGC_0,0xE6);
  2848. RegSetOneRegister(DELAGC_1,0x91);
  2849. RegSetOneRegister(DELAGC_2,0xFD);
  2850. RegSetOneRegister(DELAGC_3,0x44);
  2851. RegSetOneRegister(DELAGC_4,0x29);
  2852. RegSetOneRegister(DELAGC_5,0x8F);
  2853. RegSetOneRegister(DELAGC_6,0x80);
  2854. RegSetOneRegister(DELAGC_7,0x70);
  2855. RegSetOneRegister(DELAGC_8,0x00);
  2856. RegSetOneRegister(WBAGC_0,0x1A);
  2857. RegSetOneRegister(WBAGC_1,0x64);
  2858. RegSetOneRegister(WBAGC_2,0x31);
  2859. RegSetOneRegister(WBAGC_3,0x18);
  2860. RegSetOneRegister(WBAGC_4,0xFF);
  2861. RegSetOneRegister(WBAGC_5,0x00);
  2862. RegSetOneRegister(WBAGC_6,0x00);
  2863. RegSetOneRegister(WBAGC_9,0x04);
  2864. RegSetOneRegister(WBAGC_10,0x51);
  2865. RegSetOneRegister(WBAGC_11,0xFF);
  2866. RegSetOneRegister(STLOOP_2,0x30);
  2867. RegSetOneRegister(STLOOP_3,0x02);
  2868. RegSetOneRegister(STLOOP_5,0x6A);
  2869. RegSetOneRegister(STLOOP_6,0xA3);
  2870. RegSetOneRegister(STLOOP_7,0x8B);
  2871. RegSetOneRegister(STLOOP_8,0x39);
  2872. RegSetOneRegister(STLOOP_9,0x06);
  2873. RegSetOneRegister(STLOOP_10,0x5E);
  2874. RegSetOneRegister(STLOOP_11,0x04);
  2875. RegSetOneRegister(CRL_0,0x16);
  2876. RegSetOneRegister(CRL_1,0x29);
  2877. RegSetOneRegister(CRL_2,0x05);
  2878. RegSetOneRegister(CRL_3,0x00);
  2879. RegSetOneRegister(CRL_4,0x00);
  2880. RegSetOneRegister(CRL_5,0x00);
  2881. RegSetOneRegister(CRL_6,0xBF);
  2882. RegSetOneRegister(CRL_7,0x0D);
  2883. RegSetOneRegister(CRL_8,0xF8);
  2884. RegSetOneRegister(CRL_9,0x0D);
  2885. RegSetOneRegister(CRL_10,0x03);
  2886. RegSetOneRegister(CRL_11,0x92);
  2887. RegSetOneRegister(PMFAGC_0,0xFF);
  2888. RegSetOneRegister(PMFAGC_1,0x04);
  2889. RegSetOneRegister(PMFAGC_2,0x00);
  2890. RegSetOneRegister(PMFAGC_3,0x00);
  2891. RegSetOneRegister(PMFAGC_4,0x00);
  2892. RegSetOneRegister(CTRL_0,0x20);
  2893. RegSetOneRegister(CTRL_1,0x00);
  2894. RegSetOneRegister(CTRL_2,0x27);
  2895. RegSetOneRegister(CTRL_3,0x08);
  2896. RegSetOneRegister(CTRL_4,0x02);
  2897. RegSetOneRegister(CTRL_5,0xA2);
  2898. RegSetOneRegister(CTRL_6,0x08);
  2899. RegSetOneRegister(CTRL_7,0x63);
  2900. RegSetOneRegister(CTRL_8,0x00);
  2901. RegSetOneRegister(CTRL_9,0x00);
  2902. RegSetOneRegister(DEINT_SYNC_0,0x00);
  2903. RegSetOneRegister(DEINT_SYNC_1,0x04);
  2904. RegSetOneRegister(BERT_0,0x85);
  2905. RegSetOneRegister(BERT_1,0x22);
  2906. RegSetOneRegister(BERT_2,0x4C);
  2907. RegSetOneRegister(DEINT_0,0x91);
  2908. RegSetOneRegister(DEINT_1,0x0B);
  2909. RegSetOneRegister(OUTFORMAT_0,0x4B);
  2910. RegSetOneRegister(OUTFORMAT_1,0x00);
  2911. RegSetOneRegister(OUTFORMAT_2,0x00);
  2912. RegSetOneRegister(RS_DESC_0,0x6E);
  2913. RegSetOneRegister(RS_DESC_1,0x01);
  2914. RegSetOneRegister(RS_DESC_2,0x00);
  2915. RegSetOneRegister(RS_DESC_3,0x00);
  2916. RegSetOneRegister(RS_DESC_4,0x6D);
  2917. RegSetOneRegister(RS_DESC_5,0x01);
  2918. RegSetOneRegister(RS_DESC_14,0x00);
  2919. RegSetOneRegister(RS_DESC_15,0x01);
  2920. //RegTrigger      = NO ;
  2921. //RegNbI2cAccess  =  0 ;
  2922. //count           =  0 ;
  2923. //RegTracking     = NO ;
  2924.     
  2925.     _ExtClk = (INT32)(10*EXT_CLK) ;    
  2926. RegGetQAMSize()   ;
  2927. RegSetSymbolRate(Driv0297Signal.SymbolRate) ; 
  2928. return;
  2929. }
  2931. void QAM64_Regreset_TH(void)
  2932. {
  2933. INT16 i;
  2934. INT32 S32val;
  2935.     RegSTV0297reset() ;
  2936.     RegResetAfterDI() ;
  2937. RegSetOneRegister(EQU_0,0x4b);
  2938. RegSetOneRegister(EQU_1,0x58);
  2939.        /*    testmode RegSetOneRegister(EQU_2,0x00);*/
  2940. RegSetOneRegister(EQU_3,0x00);
  2941. RegSetOneRegister(EQU_4,0x01);
  2942. RegSetOneRegister(EQU_7,0x07);
  2943. RegSetOneRegister(EQU_8,0x1c);
  2944. RegSetOneRegister(INITDEM_0,0x00);
  2945. RegSetOneRegister(INITDEM_1,0x40);
  2946. RegSetOneRegister(INITDEM_2,0x0a);
  2947. RegSetOneRegister(INITDEM_3,0x00);
  2948. RegSetOneRegister(INITDEM_4,0x40);
  2949. RegSetOneRegister(INITDEM_5,0x08);
  2950. RegSetOneRegister(DELAGC_0,0xFF);
  2951. RegSetOneRegister(DELAGC_1,0x5C);
  2952. RegSetOneRegister(DELAGC_2,0xFF);
  2953. RegSetOneRegister(DELAGC_3,0x00);
  2954. RegSetOneRegister(DELAGC_4,0x32);
  2955. RegSetOneRegister(DELAGC_5,0x5C);
  2956. RegSetOneRegister(DELAGC_6,0x80);
  2957. RegSetOneRegister(DELAGC_7,0x30);
  2958. RegSetOneRegister(DELAGC_8,0x00);
  2959. RegSetOneRegister(WBAGC_0,0x1B);
  2960. RegSetOneRegister(WBAGC_1,0x9D);
  2961. RegSetOneRegister(WBAGC_2,0x30);
  2962. RegSetOneRegister(WBAGC_3,0x18);
  2963. RegSetOneRegister(WBAGC_4,0x58);
  2964. RegSetOneRegister(WBAGC_5,0x00);
  2965. RegSetOneRegister(WBAGC_6,0x00);
  2966. RegSetOneRegister(WBAGC_9,0x02);
  2967. RegSetOneRegister(WBAGC_10,0x33);
  2968. RegSetOneRegister(WBAGC_11,0xFF);
  2969. RegSetOneRegister(STLOOP_2,0x30);
  2970. RegSetOneRegister(STLOOP_3,0x08);
  2971. RegSetOneRegister(STLOOP_5,0x50);
  2972. RegSetOneRegister(STLOOP_6,0xBB);
  2973. RegSetOneRegister(STLOOP_7,0x18);
  2974. RegSetOneRegister(STLOOP_8,0x3D);
  2975. RegSetOneRegister(STLOOP_9,0x08);
  2976. RegSetOneRegister(STLOOP_10,0x1E);
  2977. RegSetOneRegister(STLOOP_11,0x04);
  2978. RegSetOneRegister(CRL_0,0x13);
  2979. RegSetOneRegister(CRL_1,0x39);
  2980. RegSetOneRegister(CRL_2,0x06);
  2981. RegSetOneRegister(CRL_3,0x00);
  2982. RegSetOneRegister(CRL_4,0x00);
  2983. RegSetOneRegister(CRL_5,0x00);
  2984. RegSetOneRegister(CRL_6,0x9E);
  2985. RegSetOneRegister(CRL_7,0xC4);
  2986. RegSetOneRegister(CRL_8,0x01);
  2987. RegSetOneRegister(CRL_9,0x00);
  2988. RegSetOneRegister(CRL_10,0x02);
  2989. RegSetOneRegister(CRL_11,0x0F);
  2990. RegSetOneRegister(PMFAGC_0,0xFF);
  2991. RegSetOneRegister(PMFAGC_1,0x04);
  2992. RegSetOneRegister(PMFAGC_2,0x00);
  2993. RegSetOneRegister(PMFAGC_3,0x00);
  2994. RegSetOneRegister(PMFAGC_4,0x00);
  2995. RegSetOneRegister(CTRL_0,0x20);
  2996. RegSetOneRegister(CTRL_1,0x00);
  2997. RegSetOneRegister(CTRL_2,0x0F);
  2998. RegSetOneRegister(CTRL_3,0x00);
  2999. RegSetOneRegister(CTRL_4,0x2A);
  3000. RegSetOneRegister(CTRL_5,0x00);
  3001. RegSetOneRegister(CTRL_6,0xC0);
  3002. RegSetOneRegister(CTRL_7,0x6B);
  3003. RegSetOneRegister(CTRL_8,0x00);
  3004. RegSetOneRegister(CTRL_9,0x00);
  3005. RegSetOneRegister(DEINT_SYNC_0,0x02);
  3006. RegSetOneRegister(DEINT_SYNC_1,0x04);
  3007. RegSetOneRegister(BERT_0,0x85);
  3008. RegSetOneRegister(BERT_1,0x49);
  3009. RegSetOneRegister(BERT_2,0x1A);
  3010. RegSetOneRegister(DEINT_0,0x91);
  3011. RegSetOneRegister(DEINT_1,0x0B);
  3012. RegSetOneRegister(OUTFORMAT_0,0x4b);
  3013. RegSetOneRegister(OUTFORMAT_1,0x00);
  3014. RegSetOneRegister(OUTFORMAT_2,0x00);/*0x24*/
  3015. RegSetOneRegister(RS_DESC_0,0x6e);/*f4*/
  3016. RegSetOneRegister(RS_DESC_1,0x01);/*0e*/
  3017. RegSetOneRegister(RS_DESC_2,0x00);/*25*/
  3018. RegSetOneRegister(RS_DESC_3,0x00);/*3a*/
  3019. RegSetOneRegister(RS_DESC_4,0x6d);/*00*/
  3020. RegSetOneRegister(RS_DESC_5,0x01);/*00*/
  3021. RegSetOneRegister(RS_DESC_14,0x00);
  3022. RegSetOneRegister(RS_DESC_15,0x81);
  3023. RegTrigger      = NO ;
  3024. RegNbI2cAccess  =  0 ;
  3025. count           =  0 ;
  3026. RegTracking     = NO ;
  3027.     /**/
  3028.     /**/
  3029.     _ExtClk = (INT32)(10*EXT_CLK) ;  /*unit Khz */
  3030.     /**/
  3031. RegGetQAMSize()   ;
  3032. /* RegSetSymbolRate(6500) ;  6.89 MBd */
  3033. RegSetSymbolRate(Driv0297Signal.SymbolRate) ; /* 6.89 MBd */
  3034. /**/
  3035. return;
  3036. }
  3038. void QAM256_Regreset_TH(void)
  3039. {
  3040. INT16 i;
  3041. INT32 S32val;
  3042.     RegSTV0297reset() ;
  3043.     RegResetAfterDI() ;
  3044. RegSetOneRegister(EQU_0,0x39);
  3045. RegSetOneRegister(EQU_1,0x69);
  3046.        /*    testmode RegSetOneRegister(EQU_2,0x00);*/
  3047. RegSetOneRegister(EQU_3,0x00);
  3048. RegSetOneRegister(EQU_4,0x01);
  3049. RegSetOneRegister(EQU_7,0x32);
  3050. RegSetOneRegister(EQU_8,0x1A);
  3051. RegSetOneRegister(INITDEM_0,0x00);
  3052. RegSetOneRegister(INITDEM_1,0x40);
  3053. RegSetOneRegister(INITDEM_2,0x0A);
  3054. RegSetOneRegister(INITDEM_3,0x00);
  3055. RegSetOneRegister(INITDEM_4,0x40);
  3056. RegSetOneRegister(INITDEM_5,0x08);
  3057. RegSetOneRegister(DELAGC_0,0xFF);
  3058. RegSetOneRegister(DELAGC_1,0x5C);
  3059. RegSetOneRegister(DELAGC_2,0xFF);
  3060. RegSetOneRegister(DELAGC_3,0x00);
  3061. RegSetOneRegister(DELAGC_4,0x32);
  3062. RegSetOneRegister(DELAGC_5,0x5C);
  3063. RegSetOneRegister(DELAGC_6,0x80);
  3064. RegSetOneRegister(DELAGC_7,0x00);
  3065. RegSetOneRegister(DELAGC_8,0x00);
  3066. RegSetOneRegister(WBAGC_0,0x1B);
  3067. RegSetOneRegister(WBAGC_1,0xBA);
  3068. RegSetOneRegister(WBAGC_2,0x30);
  3069. RegSetOneRegister(WBAGC_3,0x18);
  3070. RegSetOneRegister(WBAGC_4,0x58);
  3071. RegSetOneRegister(WBAGC_5,0x00);
  3072. RegSetOneRegister(WBAGC_6,0x00);
  3073. RegSetOneRegister(WBAGC_9,0x02);
  3074. RegSetOneRegister(WBAGC_10,0xFF);
  3075. RegSetOneRegister(WBAGC_11,0xFF);
  3076. RegSetOneRegister(STLOOP_2,0x30);
  3077. RegSetOneRegister(STLOOP_3,0x08);
  3078. RegSetOneRegister(STLOOP_5,0xC0);
  3079. RegSetOneRegister(STLOOP_6,0x92);
  3080. RegSetOneRegister(STLOOP_7,0x18);
  3081. RegSetOneRegister(STLOOP_8,0x3D);
  3082. RegSetOneRegister(STLOOP_9,0x08);
  3083. RegSetOneRegister(STLOOP_10,0x1E);
  3084. RegSetOneRegister(STLOOP_11,0x04);
  3085. RegSetOneRegister(CRL_0,0x13);
  3086. RegSetOneRegister(CRL_1,0x39);
  3087. RegSetOneRegister(CRL_2,0x06);
  3088. RegSetOneRegister(CRL_3,0x00);
  3089. RegSetOneRegister(CRL_4,0x00);
  3090. RegSetOneRegister(CRL_5,0x00);
  3091. RegSetOneRegister(CRL_6,0xA0);
  3092. RegSetOneRegister(CRL_7,0x7A);
  3093. RegSetOneRegister(CRL_8,0x4C);
  3094. RegSetOneRegister(CRL_9,0x00);
  3095. RegSetOneRegister(CRL_10,0x02);
  3096. RegSetOneRegister(CRL_11,0xC1);
  3097. RegSetOneRegister(PMFAGC_0,0xFF);
  3098. RegSetOneRegister(PMFAGC_1,0x04);
  3099. RegSetOneRegister(PMFAGC_2,0x00);
  3100. RegSetOneRegister(PMFAGC_3,0x00);
  3101. RegSetOneRegister(PMFAGC_4,0x00);
  3102. RegSetOneRegister(CTRL_0,0x20);
  3103. RegSetOneRegister(CTRL_1,0x00);
  3104. RegSetOneRegister(CTRL_2,0x1F);
  3105. RegSetOneRegister(CTRL_3,0x00);
  3106. RegSetOneRegister(CTRL_4,0x2A);
  3107. RegSetOneRegister(CTRL_5,0x00);
  3108. RegSetOneRegister(CTRL_6,0xC0);
  3109. RegSetOneRegister(CTRL_7,0x6B);
  3110. RegSetOneRegister(CTRL_8,0x00);
  3111. RegSetOneRegister(CTRL_9,0x00);
  3112. RegSetOneRegister(DEINT_SYNC_0,0x02);
  3113. RegSetOneRegister(DEINT_SYNC_1,0x04);
  3114. RegSetOneRegister(BERT_0,0x85);
  3115. RegSetOneRegister(BERT_1,0x75);
  3116. RegSetOneRegister(BERT_2,0x16);
  3117. RegSetOneRegister(DEINT_0,0x91);
  3118. RegSetOneRegister(DEINT_1,0x0B);
  3119. RegSetOneRegister(OUTFORMAT_0,0x4B);
  3120. RegSetOneRegister(OUTFORMAT_1,0x00);
  3121. RegSetOneRegister(OUTFORMAT_2,0x00);/*24*/
  3122. RegSetOneRegister(RS_DESC_0,0x6e);/*00*/
  3123. RegSetOneRegister(RS_DESC_1,0x01);/*00*/
  3124. RegSetOneRegister(RS_DESC_2,0x00);
  3125. RegSetOneRegister(RS_DESC_3,0x00);
  3126. RegSetOneRegister(RS_DESC_4,0x6D);
  3127. RegSetOneRegister(RS_DESC_5,0x01);/**/
  3128. RegSetOneRegister(RS_DESC_14,0x00);
  3129. RegSetOneRegister(RS_DESC_15,0x81);
  3130. RegTrigger      = NO ;
  3131. RegNbI2cAccess  =  0 ;
  3132. count           =  0 ;
  3133. RegTracking     = NO ;
  3134.     /**/
  3135.     /**/
  3136.     _ExtClk = (INT32)(10*EXT_CLK) ;  /*unit Khz */
  3137.     /**/
  3138. RegGetQAMSize()   ;
  3139. /* RegSetSymbolRate(6500) ;  6.89 MBd */
  3140. RegSetSymbolRate(Driv0297Signal.SymbolRate) ; /* 6.89 MBd */
  3141. /**/
  3142. return;
  3143. }
  3144. void RegSTV0297reset(void)
  3145.   {
  3146. RegSetField(SOFT_RESET,1);
  3147. RegSetField(SOFT_RESET,0);
  3148.   }
  3149. void RegResetAfterDI(void)
  3150.   {
  3151. RegSetField(RESET_DI,1);
  3152. RegSetField(RESET_DI,0);
  3153.    return ;
  3154.   }
  3156. void RegSetQAMSize(INT32 _QAMSize)
  3157.   {
  3158. INT32 QAMSize ;
  3159.     RegQAMSize = _QAMSize ;
  3160. switch (_QAMSize)
  3161.   {
  3162.    case 16:
  3163. QAMSize = 0; //QAM16 ;
  3164.    break;
  3165.    case 32:
  3166. QAMSize = 1; //QAM32 ;
  3167.    break;
  3168.    case 64:
  3169. QAMSize = 4; //QAM64 ;
  3170.    break;
  3171.    case 128:
  3172. QAMSize = 2; //QAM128 ;
  3173.    break;
  3174.    case 256:
  3175. QAMSize = 3; //QAM256 ;
  3176.    break;
  3177.    default:
  3178.        break;
  3179. }
  3180. RegSetField(MODE_SELECT, QAMSize);
  3181. return;
  3182.   }
  3183. INT32 RegGetQAMSize(void)
  3184.   {
  3185.     INT32 Value ;
  3186. Value = RegGetField(MODE_SELECT);
  3187. switch (Value)
  3188.   {
  3189.    case 0:
  3190. RegQAMSize = 16 ;
  3191.    break;
  3192.    case 1:
  3193. RegQAMSize = 32 ;
  3194.    break;
  3195.    case 4:
  3196. RegQAMSize = 64 ;
  3197.    break;
  3198.    case 2:
  3199. RegQAMSize = 128 ;
  3200.    break;
  3201.    case 3:
  3202. RegQAMSize = 256 ;
  3203.    break;
  3204.    default:
  3205.    break;
  3206. }
  3207. return(RegQAMSize);
  3208.   }
  3210. INT32 RegGetSymbolRate(void)
  3211.   {
  3212. INT32 regsym = 0L;
  3213. _ExtClk = (INT32)(10*EXT_CLK) ;  
  3214. regsym  = RegGetField(SYMB_RATE_0);
  3215. regsym += RegGetField(SYMB_RATE_1)<<8;
  3216. regsym += RegGetField(SYMB_RATE_2)<<16;
  3217. regsym += RegGetField(SYMB_RATE_3)<<24;   
  3218. regsym = regsym/4096L; // 4096 = 2**12 
  3219. regsym = (_ExtClk/ 8) * regsym; 
  3220. RegSymbolRate = regsym/131072L; // 131072 = 2**17 
  3221. if(RegSymbolRate == 0)
  3222. {
  3223. RegSymbolRate = 6875;
  3224. }
  3225. //Print("RegSymbolRate is %ldn",RegSymbolRate);
  3226. return(RegSymbolRate);
  3227.   }
  3228. void RegSetSymbolRate(INT32 _SymbolRate)
  3229.   {
  3230. INT32 tmp, ExtClk;
  3231. RegSymbolRate = _SymbolRate ;
  3232.     _ExtClk = (INT32)(10*EXT_CLK) ;  
  3233. ExtClk = _ExtClk/4;
  3234. tmp = 131072L * _SymbolRate;  // 131072 = 2**17  
  3235. tmp = tmp /ExtClk;
  3236. tmp = tmp * 8192L; // 8192L = 2**13 
  3237. //Print("tmp : %lx",tmp);
  3238. RegSetField(SYMB_RATE_0,tmp);
  3239. RegSetField(SYMB_RATE_1,(tmp>>8));
  3240. RegSetField(SYMB_RATE_2,(tmp>>16));
  3241. RegSetField(SYMB_RATE_3,(tmp>>24));    
  3242. return;
  3243.   }
  3245. INT32 RegGetSweepRate(void)
  3246.   {
  3247. INT16 swrate=0;
  3248. INT32 _SymbolRate;
  3249. INT32 tmp;
  3250. tmp  = RegGetField(SWEEP_LO);
  3251. tmp += RegGetField(SWEEP_HI)<<8;
  3252. _SymbolRate = RegSymbolRate / 0x10;
  3253. if (tmp & 0x00000800) {    
  3254. tmp = (~tmp + 1) & 0x00000FFF;
  3255. tmp = (tmp * _SymbolRate * 1000)/ 0x1000; /* 0x1000 = 2**12 */
  3256. tmp = (-tmp * 1000) / 0x1000;
  3257. }                  
  3258. else {
  3259. tmp = tmp & 0x00000FFF;
  3260. tmp = (tmp * _SymbolRate * 1000)/ 0x1000;
  3261. tmp = (tmp * 1000) / 0x1000;    
  3262. }
  3263. return(tmp);
  3264.   }
  3266. void RegSetSweepRate(INT16 _FShift)
  3267.   {
  3268. INT32 S32_tmp;
  3269. INT16 FShift ;
  3270. FShift = _FShift ;  /* in mS sweep = Fshift * 2^28/SR*/
  3271. RegSymbolRate = RegGetSymbolRate() ;   /* in KHz */
  3272. S32_tmp = FShift * 262144L ;   /* 262144 = 2*18 */
  3273. S32_tmp /= RegSymbolRate ;
  3274. S32_tmp *= 1024 ;
  3275. if(S32_tmp >= 0)
  3276.   S32_tmp += 500000 ;
  3277. else
  3278.   S32_tmp -= 500000 ;
  3279. S32_tmp /= 1000000 ;
  3280. RegSetField(SWEEP_LO,S32_tmp & 0xFF);
  3281. RegSetField(SWEEP_HI,(S32_tmp>>8) & 0x0F);
  3282. return;
  3283.   }
  3285. INT32 RegGetCarrierOffset(void)
  3286.   {
  3287.    INT32 S32_tmp;
  3288.    INT32 OldCarrierOffset ;
  3289. RegSetField(CRL_SNAPSHOT,0xFF) ;
  3290. S32_tmp  = RegGetField(IPHASE_0);
  3291. S32_tmp += RegGetField(IPHASE_1)<<8;
  3292. S32_tmp += RegGetField(IPHASE_2)<<16;
  3293. S32_tmp += RegGetField(IPHASE_3)<<24;
  3294. return(S32_tmp);
  3295.   }
  3296.  
  3297. void RegSetFrequencyOffset(INT32 _CarrierOffset)
  3298.  {
  3299. INT32 S32_tmp;
  3300. INT32 CarrierOffset ;
  3301. CarrierOffset = _CarrierOffset     ; 
  3302. S32_tmp = CarrierOffset * 26844L ;
  3303. if(S32_tmp < 0) S32_tmp += 0x10000000 ;
  3304. S32_tmp &= 0x0FFFFFFF ;
  3305. RegSetField(IPHASE_0,S32_tmp);
  3306. RegSetField(IPHASE_1,(S32_tmp>>8));
  3307. RegSetField(IPHASE_2,(S32_tmp>>16));
  3308. RegSetField(IPHASE_3,(S32_tmp>>24));
  3309. return;
  3310.   }
  3312. void Driv0297Init(void)
  3313.   {   
  3314.    RegSTV0297reset() ;
  3315.    RegReset() ;
  3316.    
  3317.    Driv0297DataLost   = NO ;
  3318.    Driv0297DataLocked = NO ;   
  3319.    Driv0297Signal.QAMSize    = 64     ;
  3320.    Driv0297Signal.SymbolRate = 6500   ;
  3321.    Driv0297Signal.Frequency  = 400000 ;   
  3322.    return ;
  3323.   }
  3325. void Driv0297DemodSetting(INT32 _Offset)
  3326.   {
  3327.    INT32 S32_tmp ;
  3328.    INT32 ExtClk ;
  3329.    INT32 S16_tmp ;
  3331.    RegSetField(IN_DEMOD_EN, 1);
  3332.    ExtClk = (INT32)(10*EXT_CLK) ;  
  3333.    S32_tmp  = 36125 + _Offset; 
  3334.    S32_tmp -= ExtClk;
  3335.    S32_tmp *= 65536 ;
  3336.    S32_tmp /= ExtClk;   
  3337.    if(S32_tmp > 65535) S32_tmp = 65535 ;
  3338.    S16_tmp = S32_tmp ;   
  3339.    RegSetField(DEM_FQCY_HI, S16_tmp>>8);
  3340.    RegSetField(DEM_FQCY_LO, S16_tmp);
  3341.    return;
  3342.   }
  3344. FLAG_SAM  Driv0297DataSearch(SIGNAL *_pSignal, INT32 _SweepRate, INT32 _CarrierOffset,
  3345. FLAG_SAM _SpectrumInversion, INT32 _InitDemodOffset)
  3346.   {
  3347.    INT32  TimeOut           ;
  3348.    INT32  LMS1TimeOut       ;
  3349.    INT32  LMS2TimeOut       ;
  3350.    INT32  FECTimeOut        ;
  3351.    INT32  NbSymbols         ;
  3352.    INT32  Log2QAMSize       ;
  3353.    INT32  AcqLoopsTime      ;
  3354.    INT32  AcqAGCTime        ;
  3355.    INT32  QAMSize           ;
  3356.    INT32  SweepRate         ;
  3357.    INT32  CarrierOffset     ;
  3358.    INT32  LMS1TrackingLock  ;
  3359.    INT32  LMS2TrackingLock  ;
  3360.    INT32  FECTrackingLock   ;
  3361.    UINT32 SymbolRate        ;
  3362.    INT32 Frequency         ;
  3363.    FLAG_SAM SpectrumInversion ;
  3364.    INT32  DataSearchTime    ;
  3365.    INT32  WBAGCLock         ;
  3366.    INT32  S16_tmp           ;
  3367.    INT32  initial_u         ;
  3368.    INT32  blind_u           ;
  3369.    INT32  u_threshold       ;
  3370.    INT32  AGC1Max, AGC1Min, AGC2Max, AGC2Min, AGC2Threshold  ;
  3371.    FLAG_SAM EndOfSearch       ;
  3372.    FLAG_SAM DataFound         ;
  3373.    
  3374.    DataFound         = NO                   ;
  3375.    EndOfSearch       = NO                   ;
  3376.    DataSearchTime    = 0                    ; 
  3377.    Frequency         = _pSignal->Frequency  ;
  3378.    QAMSize           = _pSignal->QAMSize    ;
  3379.    SymbolRate        = _pSignal->SymbolRate ; 
  3380.    SweepRate         = _SweepRate           ; 
  3381.    CarrierOffset     = _CarrierOffset       ;
  3382.    SpectrumInversion = _SpectrumInversion   ;
  3383.   
  3384.    AcqAGCTime = 20 ;
  3385.    switch (QAMSize)
  3386.    {
  3387.       case 16 :
  3388. NbSymbols = 45000 ;
  3389. Log2QAMSize = 4   ;
  3390. break;
  3391.       case 32 :
  3392. NbSymbols = 45000 ;
  3393. Log2QAMSize = 5   ;
  3394. break ;
  3395.       case 64 :
  3396. NbSymbols = 45000 ;
  3397. Log2QAMSize = 6   ;
  3398. break;
  3399.       case 128 :
  3400. NbSymbols = 45000 ;
  3401. Log2QAMSize = 7   ;
  3402. break ;
  3403.       case 256 :
  3404. NbSymbols = 45000 ;
  3405. Log2QAMSize = 8   ;
  3406. break;
  3407.    }
  3408.    if(SymbolRate == 0)
  3409.    {
  3410.     SymbolRate = 6875;
  3411.    }   
  3412.    AcqLoopsTime = (INT32)(NbSymbols/SymbolRate) ;  
  3413.  //  samDelay((unsigned )(AcqLoopsTime));
  3415.    /*
  3416.    if(SymbolRate <1500)
  3417.    LMS1TimeOut = 400 ;    
  3418.    else
  3419.    LMS1TimeOut = 200 ;   
  3421.    if(SymbolRate <1500)
  3422.    LMS2TimeOut = 300 ; 
  3423.    else
  3424.    LMS2TimeOut = 200 ;
  3425.    
  3426.    if(SymbolRate <1500) 
  3427.    FECTimeOut = 100;
  3428.    else
  3429.    FECTimeOut = 20;
  3430. */
  3432. if(SymbolRate <1500)
  3433. {
  3434. LMS1TimeOut = 400;
  3435. LMS2TimeOut = 300;
  3436. FECTimeOut = 100;
  3437. }
  3438. else
  3439. {
  3440. LMS1TimeOut = 200;
  3441. LMS2TimeOut = 200;
  3442. FECTimeOut = 20;
  3443. }
  3445. LMS1TimeOut /= 2;
  3446. LMS2TimeOut /= 2;
  3447. FECTimeOut /= 2;
  3449.    LoadRegisters() ;
  3450.    Driv0297DemodSetting(_InitDemodOffset) ;
  3451.    RegSetField(WAGC_EN,0x01) ;
  3452.   
  3453.    AGC2Max = RegGetField(AGC2MAX) ;
  3454.    AGC2Min = RegGetField(AGC2MIN) ;
  3455.    AGC1Max = RegGetField(AGC1MAX) ;
  3456.    AGC1Min = RegGetField(AGC1MIN) ;
  3457.    AGC2Threshold = RegGetField(AGC2_THRES) ;
  3458.   
  3459.    RegSetField(WAGC_EN,0x00) ;   
  3460.    RegSetField(AGC2SD_LO,0x00) ;
  3461.    RegSetField(AGC2SD_HI,0x01) ;   
  3462.    RegSetField(FRZ2_CTRL,0x00) ;  
  3463.    RegSetField(FRZ1_CTRL,0x00) ;             
  3464.    RegSetField(PMFA_F_UNLOCK,0x01) ;   
  3465.    RegSetField(PMFA_ACC0,0x00) ;
  3466.    RegSetField(PMFA_ACC1,0x00) ;
  3467.    RegSetField(PMFA_ACC2,0x00) ;   
  3468.    RegSetField(WAGC_ACQ,0x00) ;   
  3469.    RegSetField(PMFA_F_UNLOCK,0x00) ;   
  3470.    RegSetField(PHASE_CLR,0x01) ;   
  3471.    RegSetField(ERR_CLR,0x01) ;   
  3472.    RegSetField(ERR_CLR,0x00) ;   
  3473.    RegSetField(ERR_EN,0x00) ;   
  3474.    RegSetField(PHASE_EN,0x01) ;   
  3475.    RegSetField(SWEEP_EN,0) ;   
  3476.    RegSetField(RESET_DI,1) ;
  3477.    RegSetField(RESET_DI,0) ;   
  3478.    RegSetField(RESET_RS,1) ;
  3479.    RegSetField(RESET_RS,0) ;
  3480.    
  3481.    u_threshold = RegGetField(U_THRESHOLD) ;
  3482.    initial_u   = RegGetField(INITIAL_U) ;
  3483.    blind_u     = RegGetField(BLIND_U) ;
  3485.    RegSetField(RESET_EQL,1) ;
  3486.    RegSetField(RESET_EQL,0) ;   
  3487.    RegSetField(U_THRESHOLD,u_threshold) ;
  3488.    RegSetField(INITIAL_U,initial_u) ;
  3489.    RegSetField(BLIND_U,blind_u) ;   
  3490.    RegSetField(SOURCESEL,0) ;   
  3491.    RegSetField(APHASE_0,0x00) ;
  3492.    RegSetField(APHASE_1,0x00) ;
  3493.    RegSetField(APHASE_2,0x00) ;
  3494.    RegSetField(IPHASE_0,0x00) ;
  3495.    RegSetField(IPHASE_1,0x00) ;
  3496.    RegSetField(IPHASE_2,0x00) ;
  3497.    RegSetField(IPHASE_3,0x00) ;
  3498.    
  3499.    RegSetQAMSize(QAMSize) ;
  3500.    RegSetSymbolRate(SymbolRate) ; 
  3501.    /*Print("RegGetSymbolRate=%dn",RegGetSymbolRate());*/
  3502.    RegSetSweepRate(SweepRate)   ; 
  3503.    RegSetFrequencyOffset(CarrierOffset) ;
  3504.    RegSetField(SPEC_INV,SpectrumInversion) ;   
  3505.    samDelay(1);
  3506.    
  3507.    RegSetField(EN_CORNER_DET,0x01) ;   
  3508.    samDelay(1);   
  3510.    RegSetField(PHASE_CLR,0x00) ;  
  3511.    samDelay(1);
  3512.    RegSetField(SWEEP_EN,1) ;  
  3513.    RegSetField(WAGC_CLR,0x01) ;   
  3514.    RegSetField(WAGC_EN,0x01) ;
  3516.    WBAGCLock = 0 ;
  3517.    TimeOut = DataSearchTime + 50  ; 
  3518.    while((WBAGCLock == 0)&&(EndOfSearch == NO))
  3519.    {
  3520.      // samDelay(500);      
  3521.       DataSearchTime += 1 ;
  3522.       WBAGCLock = RegGetField(WAGC_ACQ) ;
  3523.       if((WBAGCLock == 1)||(DataSearchTime > TimeOut))
  3524.   EndOfSearch = YES ; 
  3525.    }    
  3526.    
  3527.    if(WBAGCLock == 0)
  3528.    {      
  3529.       return (DataFound);
  3530.    }
  3532. /*   samDelay(AcqAGCTime);    */
  3533.    DataSearchTime += AcqAGCTime ;
  3534.    EndOfSearch    = NO ;
  3535.    TimeOut = DataSearchTime + LMS1TimeOut ;
  3536.    S16_tmp = 0 ;
  3537.    while (EndOfSearch == NO)
  3538.    {
  3539.       samDelay(0);      
  3540.       DataSearchTime += 1 ;
  3541.       LMS1TrackingLock = RegGetField(EQU_LMS1) ;
  3542.       if(LMS1TrackingLock == 1)
  3543.    S16_tmp += 1 ;
  3544.       else
  3545.    S16_tmp = 0 ;
  3546.       if((S16_tmp >= 20)||(DataSearchTime > TimeOut))
  3547. EndOfSearch = YES ;
  3548.    }
  3550.    if(LMS1TrackingLock == 0)
  3551.      {     
  3552.        return (DataFound);
  3553.      }
  3555.      //Print("EQU_LMS1=%dn",LMS1TrackingLock);
  3556.     EndOfSearch    = NO ;
  3557.     TimeOut = DataSearchTime + LMS2TimeOut ; 
  3558.     S16_tmp = 0 ;
  3559.    while (EndOfSearch == NO)
  3560.      {
  3561.       samDelay(0);   
  3562.       DataSearchTime += 1 ;
  3563.       LMS2TrackingLock = RegGetField(EQU_LMS2) ;
  3564.       if(LMS2TrackingLock == 1)
  3565. S16_tmp += 1 ;
  3566.       else
  3567. S16_tmp = 0 ;
  3568.       if((S16_tmp >= 2)||(DataSearchTime > TimeOut))
  3569. EndOfSearch = YES ;
  3570.      }
  3572.    if(LMS2TrackingLock == 0)
  3573.    {     
  3574.        return (DataFound);
  3575.    }
  3576.    
  3577.    //Print("EQU_LMS2=%dn",LMS2TrackingLock);
  3578.    EndOfSearch    = NO ;
  3579.    TimeOut = DataSearchTime + FECTimeOut ;
  3580.    TimeOut += 100/2 ;
  3581.    FECTrackingLock=0;
  3582.    while (EndOfSearch == NO)
  3583.      {
  3584.       samDelay(1);
  3585.       DataSearchTime +=1 ;
  3586.       FECTrackingLock = RegGetField(SYNCSTATE) ; 
  3587.       if((FECTrackingLock == 1)||(DataSearchTime > TimeOut))
  3588. EndOfSearch = YES ;
  3589.      }   
  3590.      
  3591.     //Print("SYNCSTATE=%dn",FECTrackingLock);
  3592.    if(FECTrackingLock)
  3593.      {
  3594.       RegSetField(EN_CORNER_DET,0x00) ;
  3595.       DataFound = YES;
  3596.      }   
  3597.    if(DataFound == NO) return(DataFound) ;
  3598.    _pSignal->SymbolRate = RegGetSymbolRate() ;
  3599.    Driv0297Signal.QAMSize    = _pSignal->QAMSize    ;
  3600.    Driv0297Signal.SymbolRate = _pSignal->SymbolRate ;
  3601.    Driv0297Signal.Frequency  = _pSignal->Frequency  ;
  3603.    return (DataFound);
  3604.   }
  3605.   
  3606. FLAG_SAM Driv0297CarrierSearch(SIGNAL  *_pSignal, FLAG_SAM _SpectrumInversion,
  3607. INT32 _SweepRate, INT32 _CarrierOffset)
  3608.   {
  3609.    FLAG_SAM   DataFound ;
  3610.    INT32    CarrierOffset ;
  3611.    INT32   InitDemodOffset ;
  3612.    INT32    SweepRate ;
  3613.    DataFound = NO ;
  3614.    if(((_SweepRate > 0)&&(_CarrierOffset > 0))  ||
  3615.       ((_SweepRate < 0)&&(_CarrierOffset < 0))  ||
  3616.       (_SweepRate == 0))   return(DataFound) ;
  3617.    if(_SweepRate < 0)
  3618.      {
  3619.       SweepRate = -_SweepRate ;
  3620.       CarrierOffset = -_CarrierOffset ;
  3621.      }
  3622.    else
  3623.      {
  3624.       SweepRate = _SweepRate ;
  3625.       CarrierOffset = _CarrierOffset ; 
  3626.      }
  3627.    
  3628.     InitDemodOffset = 0 ;
  3629.     CarrierOffset = -500 ;   
  3630. if( _pSignal->QAMSize == 128)
  3631.     CarrierOffset = -11000 ;   
  3632.    
  3633. if(_SpectrumInversion ==AUTO)
  3634.     {
  3635. DataFound = Driv0297DataSearch(_pSignal, SweepRate, CarrierOffset, NO,
  3636.                            InitDemodOffset) ;
  3637. if(DataFound==NO)
  3638. {
  3639. //Print("error return 1 n");
  3640. if( CheckInversion()==NO)
  3641. {
  3642. DataFound = Driv0297DataSearch(_pSignal, SweepRate, CarrierOffset,
  3643. YES, InitDemodOffset) ;
  3644. }
  3645. }
  3646. if(DataFound==NO)
  3647. {
  3648. RegSetField(SPEC_INV,NO) ; 
  3649. //Print("error return 2 n");
  3650. }
  3651.     }
  3652.     else
  3653.     {  
  3654.    DataFound = Driv0297DataSearch(_pSignal, SweepRate, CarrierOffset, 
  3655.                                   _SpectrumInversion, InitDemodOffset) ;
  3656.     }  
  3657. //Print("come to here n");
  3658.     return (DataFound) ;
  3659. }
  3661. void CarrierStatusSetAcquisitionStatus(void)
  3662.   {
  3663.    INT16 Cornerlock;
  3664.    INT16 WBAGCLock ;
  3665.    INT16 PMFAGCLock ;
  3666.    INT16 LMS1lock     ;
  3667.    INT16 LMS2lock     ;
  3668.    INT16 Trackinglock ;
  3669.    INT16 status       ;
  3670.    
  3671.    WBAGCLock = RegGetField(WBAGC_IT) ;
  3672.    PMFAGCLock = RegGetField(PMFAGC_IT) ;
  3673.    LMS1lock = RegGetField(EQU_LMS1) ;
  3674.    LMS2lock = RegGetField(EQU_LMS2) ;
  3675.    Cornerlock = RegGetField(CORNER_LOCK);
  3676.    if(LMS1lock == 0)
  3677.      LMS2lock = 0 ;
  3678.    Trackinglock = RegGetField(SYNCSTATE) ;
  3679.    if(LMS2lock == 0)
  3680.      Trackinglock = 0 ;/* find faults lock*/
  3681.   /* Print("nAGC is     : WBAGC: %s  PMFAGC: %s", WBAGCLock?"Lock       ":"Out of Lock",PMFAGCLock?"Lock       ":"Out of Lock");
  3682.    Print("nEQU is     : EQU1 : %s  EQU2  : %s", LMS1lock?"Lock       ":"Out of Lock",LMS2lock?"Lock       ":"Out of Lock");
  3683.    Print("nFEC is     : %s",Trackinglock?"Lock       ":"Out of Lock");
  3684.    */
  3685.    return ;
  3686.   }
  3688. FLAG_SAM Acquisition(float _Freq1, UINT32 _SymbolRate,
  3689.  INT32 _QAMSize, FLAG_SAM _SpectrumInversion)
  3690. {
  3691. UINT8 u8val;
  3692. FLAG_SAM DataFound=NO;
  3693. SIGNAL  MySignal;
  3694. Driv0297Signal.QAMSize = _QAMSize;
  3695. Driv0297Signal.SymbolRate = _SymbolRate;
  3696. Driv0297Signal.Frequency = (INT32)(_Freq1*1000);
  3698. RegSetField(PRGCLKDIV,1);
  3699. samDelay(1);
  3700. RegSetField(I2CT_EN,0x01);
  3701. samDelay(1);
  3702. SAMSetTunerFrequency(_Freq1);
  3703. samDelay(1);
  3705. RegSetField(I2CT_EN,0x00);
  3706. samDelay(1);  
  3707. RegSetField(PRGCLKDIV,0);
  3708. samDelay(0);
  3710. if(Driv0297Signal.QAMSize == 64 )
  3711. {
  3712. RegSetField(DIRECT_GAIN_LO,6);
  3713. RegSetField(INTEGRAL_GAIN_LO,6);
  3714. }
  3715. else if(Driv0297Signal.QAMSize == 128 )
  3716. {
  3717. RegSetField(DIRECT_GAIN_LO,6);
  3718. RegSetField(INTEGRAL_GAIN_LO,6);
  3719. }
  3720. else if(Driv0297Signal.QAMSize == 256 )
  3721. {
  3722. RegSetField(DIRECT_GAIN_LO,6);
  3723. RegSetField(INTEGRAL_GAIN_LO,6);
  3724. if(Driv0297Signal.SymbolRate < 1500) 
  3725. {
  3726. RegSetField(DIRECT_GAIN_LO,4);
  3727. RegSetField(INTEGRAL_GAIN_LO,6);
  3728. }
  3729. }
  3730. else if(Driv0297Signal.QAMSize == 32 )
  3731. {
  3732. RegSetField(DIRECT_GAIN_LO,6);
  3733. RegSetField(INTEGRAL_GAIN_LO,6);
  3734. }
  3735. else  /* QAM 16 */
  3736. {
  3737. RegSetField(DIRECT_GAIN_LO,4);
  3738. RegSetField(INTEGRAL_GAIN_LO,6);
  3739. RegSetOneRegister(DELAGC_7,0x60) ;
  3740. }
  3742. RegSetField(ALGOSEL,0);
  3743. if(Driv0297Signal.QAMSize == 64 )
  3744. {
  3745. RegSetOneRegister(WBAGC_11,0xF8) ;
  3746. if(RegGetField(ALGOSEL) == 0) 
  3747. {
  3748. RegSetField(U_THRESHOLD,0x06);
  3749. RegSetField(INITIAL_U,0x05);
  3750. RegSetField(BLIND_U,0x0a);
  3751. }
  3752. else 
  3753. {
  3754. RegSetField(U_THRESHOLD,0x09);
  3755. RegSetField(INITIAL_U,0x06);
  3756. RegSetField(BLIND_U,0x09);
  3757. }
  3758. }
  3759. else if(Driv0297Signal.QAMSize == 32)
  3760. {
  3761. RegSetOneRegister(WBAGC_11,0xF0) ;
  3762. if(RegGetField(ALGOSEL) == 0) 
  3763. {
  3764. RegSetField(U_THRESHOLD,0x08);
  3765. RegSetField(INITIAL_U,0x05);
  3766. RegSetField(BLIND_U,0x08);
  3767. }
  3768. else 
  3769. {
  3770. RegSetField(U_THRESHOLD,0x09);
  3771. RegSetField(INITIAL_U,0x06);
  3772. RegSetField(BLIND_U,0x09);
  3773. }
  3774. }
  3775. else if(Driv0297Signal.QAMSize == 16)
  3776. {
  3777. RegSetOneRegister(WBAGC_11,0xE1) ;
  3778. if(RegGetField(ALGOSEL) == 0) 
  3779. {
  3780. RegSetField(U_THRESHOLD,0x08);
  3781. RegSetField(INITIAL_U,0x05);
  3782. RegSetField(BLIND_U,0x08);
  3783. }
  3784. else 
  3785. {
  3786. RegSetField(U_THRESHOLD,0x09);
  3787. RegSetField(INITIAL_U,0x06);
  3788. RegSetField(BLIND_U,0x09);
  3789. }
  3790. }
  3791. else if(Driv0297Signal.QAMSize == 128)
  3792. {
  3793. RegSetOneRegister(WBAGC_11,0xFE) ;
  3794. if(RegGetField(ALGOSEL) == 0) 
  3795. {
  3796. RegSetField(U_THRESHOLD,0x08);
  3797. RegSetField(INITIAL_U,0x05);
  3798. RegSetField(BLIND_U,0x08);
  3799. }
  3800. else 
  3801. {
  3802. RegSetField(U_THRESHOLD,0x09);
  3803. RegSetField(INITIAL_U,0x06);
  3804. RegSetField(BLIND_U,0x09);
  3805. }
  3806. }
  3807. else if(Driv0297Signal.QAMSize == 256)
  3808. {
  3809. RegSetOneRegister(WBAGC_11,0xFF) ;
  3810. if(RegGetField(ALGOSEL) == 0)
  3811. {
  3812. RegSetField(U_THRESHOLD,0x08);
  3813. RegSetField(INITIAL_U,0x05);
  3814. RegSetField(BLIND_U,0x08);
  3815. if(Driv0297Signal.SymbolRate <=1500)
  3816.        {
  3817. RegSetField(U_THRESHOLD,0x0A);
  3818. RegSetField(INITIAL_U,0x08);
  3819. RegSetField(BLIND_U,0x0A);
  3820.        } 
  3821. }
  3822. else 
  3823. {
  3824. RegSetField(U_THRESHOLD,0x0A);
  3825. RegSetField(INITIAL_U,0x07);
  3826. RegSetField(BLIND_U,0x0A);
  3827. }
  3828. }
  3829. else 
  3830. {
  3831. RegSetOneRegister(WBAGC_11,0xF8) ;
  3832. if(RegGetField(ALGOSEL) == 0) 
  3833. {
  3834. RegSetField(U_THRESHOLD,0x08);
  3835. RegSetField(INITIAL_U,0x05);
  3836. RegSetField(BLIND_U,0x08);
  3837. }
  3838. else 
  3839. {
  3840. RegSetField(U_THRESHOLD,0x09);
  3841. RegSetField(INITIAL_U,0x06);
  3842. RegSetField(BLIND_U,0x09);
  3843. }
  3844. }
  3845. MySignal.QAMSize    = Driv0297Signal.QAMSize    ;
  3846. MySignal.SymbolRate = Driv0297Signal.SymbolRate ;
  3847. MySignal.Frequency  = Driv0297Signal.Frequency  ;
  3849. if(Driv0297Signal.SymbolRate >=4500)
  3850. {
  3851. if(_QAMSize == 16)
  3852. {
  3853. RegSetField(GAIN_DIR,4);
  3854. RegSetField(GAIN_INT,8);
  3855. }
  3856. else if(_QAMSize == 32)
  3857. {
  3858. RegSetField(GAIN_DIR,4);
  3859. RegSetField(GAIN_INT,8);
  3860. }
  3861. else if(_QAMSize == 64)
  3862. {
  3863. RegSetField(GAIN_DIR,2);
  3864. RegSetField(GAIN_INT,9);
  3865. }
  3866. else if(_QAMSize == 128)
  3867. {
  3868. RegSetField(GAIN_DIR,3);
  3869. RegSetField(GAIN_INT,10);
  3870. }
  3871. else if(_QAMSize == 256)
  3872. {
  3873. RegSetField(GAIN_DIR,3);
  3874. RegSetField(GAIN_INT,9);
  3875. }
  3876. }
  3877. else if(3500 < Driv0297Signal.SymbolRate && Driv0297Signal.SymbolRate < 4500)
  3878. {
  3879. if(_QAMSize == 16)
  3880. {
  3881. RegSetField(GAIN_DIR,4);
  3882. RegSetField(GAIN_INT,9);
  3883. }
  3884. else if(_QAMSize == 32)
  3885. {
  3886. RegSetField(GAIN_DIR,4);
  3887. RegSetField(GAIN_INT,9);
  3888. }
  3889. else if(_QAMSize == 64)
  3890. {
  3891. RegSetField(GAIN_DIR,4);
  3892. RegSetField(GAIN_INT,10);
  3893. }
  3894. else if(_QAMSize == 128)
  3895. {
  3896. RegSetField(GAIN_DIR,4);
  3897. RegSetField(GAIN_INT,10);
  3898. }
  3899. else if(_QAMSize == 256)
  3900. {
  3901. RegSetField(GAIN_DIR,3);
  3902. RegSetField(GAIN_INT,9);
  3903. }
  3905. }
  3906. else if(1500 < Driv0297Signal.SymbolRate && Driv0297Signal.SymbolRate < 3500)
  3907. {
  3908. if(_QAMSize == 16)
  3909. {
  3910. RegSetField(GAIN_DIR,4);
  3911. RegSetField(GAIN_INT,9);
  3912. }
  3913. else if(_QAMSize == 32)
  3914. {
  3915. RegSetField(GAIN_DIR,4);
  3916. RegSetField(GAIN_INT,9);
  3917. }
  3918. else if(_QAMSize == 64)
  3919. {
  3920. RegSetField(GAIN_DIR,4);
  3921. RegSetField(GAIN_INT,10);
  3922. }
  3923. else if(_QAMSize == 128)
  3924. {
  3925. RegSetField(GAIN_DIR,4);
  3926. RegSetField(GAIN_INT,10);
  3927. }
  3928. else if(_QAMSize == 256)
  3929. {
  3930. RegSetField(GAIN_DIR,3);
  3931. RegSetField(GAIN_INT,9);
  3932. }
  3934. }
  3935. else /* SR <1500 */
  3936. {
  3937. if(_QAMSize == 16)
  3938. {
  3939. RegSetField(GAIN_DIR,4);
  3940. RegSetField(GAIN_INT,9);
  3941. }
  3942. else if(_QAMSize == 32)
  3943. {
  3944. RegSetField(GAIN_DIR,4);
  3945. RegSetField(GAIN_INT,9);
  3946. }
  3947. else if(_QAMSize == 64)
  3948. {
  3949. RegSetField(GAIN_DIR,4);
  3950. RegSetField(GAIN_INT,10);
  3951. }
  3952. else if(_QAMSize == 128)
  3953. {
  3954. RegSetField(GAIN_DIR,4);
  3955. RegSetField(GAIN_INT,10);
  3956. }
  3957. else if(_QAMSize == 256)
  3958. {
  3959. RegSetField(GAIN_DIR,3);   
  3960. RegSetField(GAIN_INT,9);  
  3961. }
  3963. }
  3964. //Print(" Driv0297Signal.SymbolRate is [%d] [%d]n",Driv0297Signal.SymbolRate,_QAMSize);
  3965. if(Driv0297Signal.SymbolRate >=6500)
  3966. {
  3967. if(_QAMSize == 16)
  3968. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,1400,-100); 
  3969. else if(_QAMSize == 32)
  3970. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,700,-100); 
  3971. else if(_QAMSize == 64)
  3972. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,600,-100); 
  3973. else if(_QAMSize == 128)
  3974. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,550,-700); 
  3975. else if(_QAMSize == 256)
  3976. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,Driv0297Signal.SymbolRate/20,-100); 
  3977. }
  3979. else if(3500 <= Driv0297Signal.SymbolRate && Driv0297Signal.SymbolRate< 6500)
  3980. {
  3981. if(_QAMSize == 16)
  3982. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,1200,-100); 
  3983. else if(_QAMSize == 32)
  3984. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,550,-100); 
  3985. else if(_QAMSize == 64)
  3986. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,600,-100); 
  3987. else if(_QAMSize == 128)
  3988. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,550,-700); 
  3989. else if(_QAMSize == 256)
  3990. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,Driv0297Signal.SymbolRate/20,-100); 
  3991. }
  3992. else if(1500 < Driv0297Signal.SymbolRate && Driv0297Signal.SymbolRate< 3500)
  3993. {
  3994. if(_QAMSize == 16)
  3995. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,600,-100); 
  3996. else if(_QAMSize == 32)
  3997. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,200,-100); 
  3998. else if(_QAMSize == 64)
  3999. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,500,-100);
  4000. else if(_QAMSize == 128)
  4001. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,500,-700); 
  4002. else if(_QAMSize == 256)
  4003. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,230,-100); 
  4004. }
  4005. else   /* SR <=1500 */
  4006. {
  4007. if(_QAMSize == 16)
  4008. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,500,-100); 
  4009. else if(_QAMSize == 32)
  4010. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,200,-100); 
  4011. else if(_QAMSize == 64)
  4012. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,230,-100); 
  4013. else if(_QAMSize == 128)
  4014. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,270,-100); 
  4015. else if(_QAMSize == 256)
  4016. DataFound=Driv0297CarrierSearch(&MySignal,_SpectrumInversion,290,-110); 
  4017.     }  
  4018.   return (DataFound);
  4019. }
  4021. void QAM_Init(void)
  4022. {
  4023. RegReset();
  4024. Driv0297Init();
  4025. QAM64_RegInit();
  4026. }
  4028. INT16 Check_Lock(void)
  4029. {
  4030.    INT16 LMS1lock     ;
  4031.    INT16 LMS2lock     ;
  4032.    INT16 Trackinglock ;
  4033.    INT16 status       ;
  4034.    RegSetOneRegister(CTRL_2,0x00) ; 
  4035.    LMS1lock = RegGetField(EQU_LMS1) ;             
  4036.    LMS2lock = RegGetField(EQU_LMS2) ;             
  4037.    if(LMS1lock == 0)                              
  4038.      LMS2lock = 0 ;                               
  4039.    Trackinglock = RegGetField(SYNCSTATE) ;        
  4040.    if(LMS2lock == 0)                              
  4041.      Trackinglock = 0 ;
  4042.    return Trackinglock;
  4043. }
  4044. void RegReset(void)
  4045. {
  4046. INT32 reg ;
  4047. for ( reg = 0 ; reg < NBREG ; reg++ )
  4048. {
  4049. RegSetOneRegister(reg,RegMap[reg].Reset);
  4050. }
  4051. }
  4052. int CheckInversion(void)
  4053. {
  4054.    if(( RegGetField(WBAGC_IT) &&RegGetField(PMFAGC_IT) && RegGetField(EQU_LMS1)&& RegGetField(EQU_LMS2) ))
  4055.    {
  4056. if(RegGetField(SYNCSTATE))
  4057. {
  4058. //Print("Spectral Right!!");
  4059. return YES;
  4060. }
  4061. else
  4062. {
  4063. //Print("Spectral Changed !!");
  4064. return NO;
  4065. }
  4066.    }
  4068.    return NO;
  4069. }
  4070. void LoadRegisters(void)
  4071.   { 
  4072.   /* RegStoreValue() ;
  4073.     RegSetOneRegister(RegSearchAddress(0x80 ),0x01 ) ; 
  4074.    RegSetOneRegister(RegSearchAddress(0x80 ),0x00 ) ; 
  4075.     RegReloadValue() ;
  4076.     */
  4077.     
  4078.        
  4079.     
  4080.    RegSetField(SOFT_RESET,1);
  4081.    RegSetField(SOFT_RESET,0);
  4082.   if((UINT16)EXT_CLK ==2880)  
  4083.     {if((InputQAMSize_MODE==128)||(InputQAMSize_MODE==256))
  4084.        QAM256_Regreset_TH();
  4085.      else QAM64_Regreset_TH();
  4086.      /*printf("THOMSON InputQAMSize =%dn",InputQAMSize);*/
  4087.     }
  4088.   else
  4089.    {
  4090.      if((InputQAMSize_MODE==128)||(InputQAMSize_MODE==256))
  4091.        QAM256_Regreset();
  4092.      else QAM64_Regreset(); 
  4093.  }   
  4094.       
  4095.     
  4096.     
  4097.     return ;
  4098.  }
  4099.  
  4100.  void RegStoreValue(void)
  4101.    {
  4102. INT32 reg ;
  4103. for ( reg = 0 ; reg < NBREG ; reg++ )
  4104. RegMap[reg].Store = RegMap[reg].Value ;
  4105. return;    
  4106.    }
  4107. INT32  RegSearchAddress(INT32 _Address)
  4108. {
  4109. INT32 Index=-1;
  4110. for(Index = 0; ((Index < NBREG)&&(RegMap[Index].Addr !=_Address)); Index++) ;
  4111. if(Index>= NBREG)
  4112. Index = -1 ;
  4113. return (Index);
  4114. }
  4115. void RegReloadValue(void)
  4116.    {
  4117. INT32 reg ;
  4118. for ( reg = 0 ; reg < NBREG ; reg++ )
  4119. {
  4120.    RegMap[reg].Value = RegMap[reg].Store ;
  4121.    RegSetOneRegister(reg,RegMap[reg].Value);
  4122.  }
  4123. return;   
  4124.    }
  4126.  
  4127.    
  4128. void samDelay(int n)
  4129. {      
  4130.     
  4131.     KB_OSPTaskDelay(n);
  4132.     
  4133. }
  4136. INT32 SAMDetect(UINT16 addr)
  4137. {
  4138. INT32 rc = DMD_TYPE_NONE;
  4139. UINT8 pllFound = 0;
  4142. if(RETOK == KB_I2COpen(IIC_ADDR_NIM_30311, &i2c_dmd_handle))
  4143. {
  4144. Print("[tcmu30311.c] SAMDetect(): i2c_dmd_handle = 0x%X.n",i2c_dmd_handle);
  4145. if(QAM0297_Revision == SAMRevision())
  4146. {
  4147. UINT8 sout[4];
  4149. sout[0] = 0x1B; /* TUNER DIVIDER BYTE1 */
  4150. sout[1] = 0x15; /* TUNER DIVIDER BYTE2 */
  4151. sout[2] = 0x02; /* TUNER CONTROL BYTE1 */
  4152. sout[3] = 0x02; /* TUNER CONTROL BYTE2 */
  4154. /*
  4155. ** has detect stv0297 exist. Now detect the pll type.
  4156. ** Write 4 bytes to the pll and confirm the operartion
  4157. ** result(success or failure). So can confirm which 
  4158. ** tuner is in use.
  4159. */
  4160. if(!pllFound)
  4161. {
  4162. if(RETOK == KB_I2COpen(IIC_TUNER_ADDRESS_TH, &i2c_pll_handle))
  4163. {
  4164.     Print("[tcmu30311.c] SAMDetect(): i2c_pll_handle = 0x%X.n",
  4165.   i2c_pll_handle);
  4166. SAMEnableIICTuner();
  4167. if(RETOK == KB_I2CWriteWithStop(i2c_pll_handle, 4, sout))
  4168. {
  4169. pllFound = 1;
  4170. EXT_CLK = 2880;
  4171. rc = DMD_TYPE_QAM;
  4172. }
  4173. else
  4174. {
  4175. KB_I2CClose(i2c_pll_handle);
  4176. }
  4177. SAMDisableIICTuner();
  4178. KB_I2CClose(i2c_pll_handle);
  4179. }
  4180. else
  4181. {
  4182. Print("[tcmu30311.c] SAMDetect(): open i2c_pll_handle failed.n");
  4183. }
  4184. }
  4186. if(!pllFound)
  4187. {
  4188. if(RETOK == KB_I2COpen(IIC_TUNER_ADDRESS_SAM, &i2c_pll_handle))
  4189. {
  4190. SAMEnableIICTuner();
  4191. if(RETOK == KB_I2CWriteWithStop(i2c_pll_handle, 4, sout))
  4192. {
  4193. pllFound = 1;
  4194. EXT_CLK = 2892;
  4195. rc = DMD_TYPE_QAM;
  4196. }
  4197. else
  4198. {
  4199. KB_I2CClose(i2c_pll_handle);
  4200. }
  4201. SAMDisableIICTuner();
  4202. }
  4203. }
  4204. }
  4205. else
  4206. {
  4207. KB_I2CClose(i2c_dmd_handle);
  4208. }
  4209. }
  4211. STTBX_Print(("demod type = %d, clock = %d.n", rc, EXT_CLK));
  4213. return rc;
  4214. }