nscc_tuner.c

linux 下,lgs8gl5的驱动源代码,放血了,把所有的东东都弄上来了,会不会被老板杀了啊?

	   MTV10x_REFCLK = 16384; 
	   MultiFactor=1000;
	   sub_exp=14;
	   div_1=1;
	   div_2=1; // 16384== 2^14 
	   break;}
   }
   
   PLLN = (Freq*MultiFactor* PLLR/MTV10x_REFCLK ); 
   tmp = ((PLLR*Freq*MultiFactor/div_1) << (20-sub_exp) )/div_2;   
   PLLF = tmp - (PLLN<<20);
   
   DATA47 = 0x10; //default Value
   ReadData= sread(target,0x2f);
   if(ReadData.ACK_status==1)    DATA47 = (m_BYTE)(ReadData.read_data & 0x1f);
   
   if (PLLN<=66)   
   {   
       //4-prescaler
       PC4    = 1;
       PC8_16 = 0;
       DATA47 = (m_BYTE)(DATA47 | (PC4<<6) | (PC8_16<<5)); 
   }
   else
   {
       //8-prescaler
       PC4    = 0;
       PC8_16 = 0;
       DATA47 = (m_BYTE) (DATA47 | (PC4<<6) | (PC8_16<<5)); 
   }

   // do a reset operation 
   swrite(target, 0x27, 0x00 ); //added : v1.6.3 at PM 20:39 2007-07-26
   //PLL Reset Enable
   swrite(target, 0x2f, DATA47 );      //Reset Seq. 0 => 1  : //updated : v1.6.3 at PM 20:39 2007-07-26
   swrite(target, 0x2f, (m_BYTE) (DATA47 | 0x80));

   if ((PLLFREQ*2)<2592000)  // 648*1000*2*2 according to datasheet
      VCOSEL = 0;
   else   VCOSEL = 1;

   // read 0x09 register bit [5:0]
   _temper=0x0C;
   ReadData= sread(target, 0x09) ;  //To get Temperature sensor value
   if(ReadData.ACK_status==1)   _temper= (m_BYTE)(ReadData.read_data &0x3f ); // get low 6 bits 
   
   dpPhaseTuning(lofreq,_temper); //these value may changes: g_icp=0, g_convco=0, g_curTempState=HIGH_TEMP;
   
   if (lofreq>400000)  //if iRF=UHF
   {   
      swrite(target,0x1a, (m_BYTE)((g_icp<<2)| ((PLLN&0x300)>>8)));    // change 1C to 7C. 2007/07/09
   }
   else 
   {
       swrite(target,0x1a, (m_BYTE)( 0xFC | ( ( PLLN&0x300 ) >> 8 )) );
   }

   //PLL Setting
   swrite(target,0x1b, (m_BYTE)(PLLN & 0xFF));
   swrite(target,0x1c, (m_BYTE)( (DIVSEL<<4) | (VCOSEL<<7) | ((PLLF&0xF0000)>>16) ) );
   swrite(target,0x1d, (m_BYTE)( (PLLF&0x0FF00)>>8 )   );
   swrite(target,0x1e, (m_BYTE)( PLLF&0xFF ));
   swrite(target,0x15, (m_BYTE)( 0x38| ((lpfBW-3)& 0x07) ));

   //PLL Reset
   swrite(target,0x2f, DATA47);      //Reset Seq. 0 => 1 => 0 : //updated : v1.5 at PM 20:39 2007-06-8
   swrite(target,0x2f, (m_BYTE)( DATA47 | 0x80 ));
   swrite(target,0x2f, DATA47);
   
   swrite(target, 0x27, g_convco );
   if (lofreq>400000)    swrite(target, 0x29, 0xBF );	 
   return; 	
}
//*****************************************************************************
// Function:  calculate DIVSEL according to lofreq                                             
//  Input:   lofreq  -- Frequency point value in kHz unit 
//  Return:  m_DIVSEL -- DIVSEL in register 0x1C  
//*****************************************************************************
int  LO2PLL_Freq(m_DWORD lofreq)
{
   m_WORD fdefLoBoundFreq=940000;

   int	Seg_num, m_DIVSEL=0;
    
   Seg_num=(int)(lofreq/(fdefLoBoundFreq/16));

   while(Seg_num>0x01)
   {
     Seg_num=(Seg_num>>1);
     m_DIVSEL++;
   }
   return(m_DIVSEL) ;
}

//******************************************************************************
// Function: Change CONVCO value according to Temperature Sensor(0x27[0:4])
// Input: lofreq -- frequency in kHz unit 
//        temper -- Tuner 0x09 register content  
// Return: None
//******************************************************************************
void dpPhaseTuning(m_DWORD lofreq, m_BYTE temper)
{  
  if (fDegVcoApply)
  {
    if(g_VHFSet== VHFSupport) {
   	if (temper<=vlowDegBoundary)  //low boundary
	{
	  g_convco=rglowDegCONVCO_VHF; 
	  g_curTempState=LOW_TEMP;
	}
	else
	  if (temper>=vhighDegBoundary) //high boundary
	  {
		g_convco=rgHighDegCONVCO;
		g_curTempState=HIGH_TEMP;
	  }	
    }
   else {   	
    if (temper<=vlowDegBoundary)  //low boundary
    {
      g_convco=rglowDegCONDIV;
      g_icp=0x3F;
	  g_curTempState=LOW_TEMP;
    }
    else
      if (temper>=vhighDegBoundary) //high boundary
      {
	g_convco=rgHighDegCONDIV;
//	if (( lofreq > 610000  ) && ( lofreq < 648000  )) //610MHz ~ 648MHz
//	    g_icp=0x1F;
//	else  
		g_icp=0x3F;
	g_curTempState=HIGH_TEMP;
      }
      else
	  {  if (g_curTempState)
	     {
		 g_convco=rglowDegCONDIV;
		 g_icp=0x3F;
	      }
	     else
	      {	g_convco=rgHighDegCONDIV;
//		if (( lofreq > 610000  ) && ( lofreq < 648000  )) //610MHz ~ 648MHz
//		  g_icp=0x1F;
//		else  
g_icp=0x3F;
	      }	
	  }
     }
  }
  return;
}
//******************************************************************************
// Function: Do tuner temperature compensate, it can be called by processor 
//           for every 5~10 seconds. This may improve the tuner performance.  
//  
// Input: lofreq -- frequency in kHz unit 
// Return: None
//******************************************************************************
void    TunerTemperatureComp(long lofreq)
{  
    m_BYTE  Ori_Reg_0x1A,Reg_0x1A,_temper;
    I2C_READ ReadData;

    Ori_Reg_0x1A=0xFC; 
    _temper=0x0C;
    ReadData= sread(lowTunerI2CAdr, 0x09) ;  //To get Temperature sensor value
    if(ReadData.ACK_status==1)   _temper= (m_BYTE)(ReadData.read_data &0x3f ); // get low 6 bits 

    dpPhaseTuning(lofreq, _temper);

    ReadData= sread(lowTunerI2CAdr, 0x1A) ;  //To get Temperature sensor value
    if(ReadData.ACK_status==1)   Ori_Reg_0x1A=ReadData.read_data;

    // reserve bit 7, bit1 and bit 0
    Reg_0x1A= (m_BYTE)((g_icp <<2) | (Ori_Reg_0x1A & 0x83)); 
    // write g_icp into 0x1A register bit[6:2] 
    swrite(lowTunerI2CAdr, 0x1A, Reg_0x1A);
    swrite(lowTunerI2CAdr, 0x27, g_convco);

    return;
}

//******************************************************************************
// Function: Check if Tuner I2C access is OK or not. read-write 0x1B register
// Input: target -- Tuner I2C device Address 
// Return: 0x03 -- all is ok  
//         bit1: read operation check result, 0 means error, 1 means ok. 
//         bit0: write operation check result, 0 means error, 1 means ok.
//******************************************************************************
int CheckTunerI2C(m_BYTE target)
{
   m_BYTE Ori_dat,Wri_dat,Read_dat;
   int ret_val=0;
   I2C_READ ReadData;

   Ori_dat=0x00;
   Read_dat=0xff;
   ReadData=sread (target, 0x1b);  // save original data 
   if(ReadData.ACK_status==1) 
   { Ori_dat=ReadData.read_data;
     ret_val=0x02;  // read is ok 
   }
   
   Wri_dat=(m_BYTE)((~Ori_dat) & 0xff);    // write Xor value 
   swrite(target, 0x1b , Wri_dat);

   ReadData=sread (target, 0x1b);  // read back 
   if(ReadData.ACK_status==1) Read_dat=ReadData.read_data;

   if(Read_dat==Wri_dat)
	   ret_val=(ret_val | 0x01);  // write is ok 

   swrite(target, 0x1b , Ori_dat);

   return(ret_val);
}

// ****************************************************************************
//  Function: calculate signal power using Tuner related registers 
//  Input: None
//  Return: signal power in 0.01dBm unit  
//  Note: The precise is about 5dB
// ****************************************************************************
int   TunerRSSICalc(unsigned int freq)
{
	I2C_READ myi2cRead;
 	int PowerDBValue=0; // in dBm unit
	unsigned char RF_AGC_LowByte,RF_AGC_HighByte,GVBB;
	unsigned char LNA_Gain = 0; /*shenghuai modify*/
	int RF_AGC;
	int CaseNumber;
	int Coef[5];
	int CompTab[2]={ 497,-530};
    int FreqTab[2]={474,858};
	int Freq_Comp,BBAGC_Part;
	unsigned char Val_0x3D,Val_0x3e,Val_0x3f;

	Freq_Comp= -( (CompTab[1]-CompTab[0]) *(freq-FreqTab[0])/ (FreqTab[1]-FreqTab[0]) + CompTab[0] ); //0.01dB

	GVBB=0;
	RF_AGC_HighByte=0;
	RF_AGC_LowByte=0;
	myi2cRead=sread (lowTunerI2CAdr, 0x05); 
	if (myi2cRead.ACK_status)
		RF_AGC_LowByte = myi2cRead.read_data;

	myi2cRead=sread (lowTunerI2CAdr, 0x06); 
	if (myi2cRead.ACK_status)
		RF_AGC_HighByte = myi2cRead.read_data; 

	RF_AGC= (RF_AGC_HighByte & 0x01);
	RF_AGC= (RF_AGC<<8) + RF_AGC_LowByte;
	
    myi2cRead=sread (lowTunerI2CAdr, 0x0d); 
	if (myi2cRead.ACK_status)
		LNA_Gain = myi2cRead.read_data; 
	
	LNA_Gain =(unsigned char) ( (LNA_Gain & 0x60 ) >> 5 );

	myi2cRead=sread (lowTunerI2CAdr, 0x04); 
	if (myi2cRead.ACK_status)
	   GVBB = myi2cRead.read_data; 
	GVBB= (unsigned char) ((GVBB&0xf0)>>4);

	Val_0x3D=0;
	Val_0x3e=0;
	Val_0x3f=0;
	
	myi2cRead=sread (lowDemodI2CAdr, 0x3d); 
	if (myi2cRead.ACK_status)	   Val_0x3D = myi2cRead.read_data; 
	
	myi2cRead=sread (lowDemodI2CAdr, 0x3e); 
	if (myi2cRead.ACK_status)	   Val_0x3e = myi2cRead.read_data; 
	
    myi2cRead=sread (lowDemodI2CAdr, 0x3f); 
	if (myi2cRead.ACK_status) 	Val_0x3f = (unsigned char)(myi2cRead.read_data & 0x1f);
    if (Val_0x3f & 0x10) Val_0x3f= (unsigned char)(Val_0x3f & 0x0f);// two's complement to offset binary
    else Val_0x3f= (unsigned char)(Val_0x3f|0x1f);      //

    BBAGC_Part= Val_0x3f;
    BBAGC_Part = ( BBAGC_Part <<8) + Val_0x3e; 

	CaseNumber=0; // default algorithm
	if(LNA_Gain==0 && GVBB==4)  CaseNumber=1; //[0,-31dBm], case 1 
	if(LNA_Gain==3 && GVBB==4 && RF_AGC<383)  CaseNumber=2; //[-34dBm,-59dBm], case 2
	if(LNA_Gain==3 && GVBB>4 && RF_AGC>=383)  CaseNumber=3; //[-61Bm,-93dBm], case 3
	if( (LNA_Gain==0 && GVBB>4) || (LNA_Gain==3 && GVBB<4) ) CaseNumber=4; //[-2,-52dBm], case 4 
	if(LNA_Gain==3 && GVBB>4 && RF_AGC<383)  CaseNumber=5; //[-53,-78dBm], case 5 
	if(GetTunerType(lowTunerI2CAdr)==Tuner_MTV102) CaseNumber=0; //use default formula
	if(Val_0x3f >= 0x10) CaseNumber=0;

	switch(CaseNumber)
	{  case 1:  { 
                  Coef[0]=-25;  Coef[1]=-1000; Coef[2]=-287; Coef[3]=-11400 ; Coef[4]=-310;  
				  BBAGC_Part=((Coef[3]*BBAGC_Part)/8192) + 5016;   // 5016 = Coef[3]*0.44
	              PowerDBValue=Coef[0]*RF_AGC+Coef[1]*LNA_Gain+Coef[2]*(GVBB-5)+BBAGC_Part+Coef[4]+Freq_Comp;
	              break;
				}
       case 2:  { 
	              Coef[0]=-13;  Coef[1]=-752; Coef[2]=214; Coef[3]=1000 ; Coef[4]=886; 
				  BBAGC_Part=((Coef[3]*BBAGC_Part)/8192)- 440;   // 440 = Coef[3]*0.44
	              PowerDBValue=Coef[0]*RF_AGC+Coef[1]*LNA_Gain+Coef[2]*(GVBB-5)+BBAGC_Part+Coef[4]+Freq_Comp;
	              break;
				}
       case 3:  { 
                  Coef[0]=-12;  Coef[1]=-952; Coef[2]=-347; Coef[3]=-11400 ; Coef[4]=120; 
				  BBAGC_Part=((Coef[3]*BBAGC_Part)/8192) + 5016;   // 502 = Coef[3]*0.44
	              PowerDBValue=Coef[0]*RF_AGC+Coef[1]*LNA_Gain+Coef[2]*(GVBB-5)+BBAGC_Part+Coef[4]+Freq_Comp;
	              break;
				}
       case 4:  {  
  				  Coef[0]=-12;  Coef[1]=-1000; Coef[2]=-330; Coef[3]=-11400 ; Coef[4]=70; 
				  BBAGC_Part=((Coef[3]*BBAGC_Part)/8192) + 5016;   // 5016 = Coef[3]*0.44
	              PowerDBValue=Coef[0]*RF_AGC+Coef[1]*LNA_Gain+Coef[2]*(GVBB-5)+BBAGC_Part+Coef[4]+Freq_Comp;             
	              break;
				}
       case 5:  { 
		          Coef[0]=-12;  Coef[1]=-952; Coef[2]=-280; Coef[3]=-11400 ; Coef[4]=120; 
				  BBAGC_Part=((Coef[3]*BBAGC_Part)/8192) + 5016;   // 502 = Coef[3]*0.44
		          PowerDBValue=Coef[0]*RF_AGC+Coef[1]*LNA_Gain+Coef[2]*(GVBB-5)+BBAGC_Part+Coef[4]+Freq_Comp;
	              break;
				}
       default:  {  // default formular
		          Coef[0]=-12;  Coef[1]=-830; Coef[2]=800;
	              PowerDBValue=RF_AGC*Coef[0]+LNA_Gain*Coef[1] +Coef[2];
                  BBAGC_Part=  -1000*BBAGC_Part/8192;
				  PowerDBValue=PowerDBValue-300*(GVBB-5)+BBAGC_Part + Freq_Comp;  // for 8934 case 
	              break;
				}
	}
	return(PowerDBValue);

}

//*****************************************************************************
//  Functions:   Initialization of LGS8934/LGS8GL5/LGS8G54 at start-up
//*****************************************************************************

 m_BYTE AddrDataMemLGS8GL5[40]= //8GL5 case , Internal ADC 
{
/* define the register address and data of LGS8gl5 that need to be initialized when power on */ 
 0x05,0x04, 
 0x07,0x1C,      // BB_SEL=1 because the MTV10X tuner output is I/Q signal; IF_SEL=1, set the negative center frequency for IF
                 //  0x1C: internal ADC
 0x09,0x00,      // Set the initial IF frequency of the automatic frequency control as 0Hz.
 0x0A,0x00,      //
 0x0B,0x00,      //
 0x0C,0x00,      //
 0x2c,0x00,      // add
 0x2d,0x00,      // set AGC_REF[15:8]; 
 0x2e,0xA2,      // set AGC_REF[20:16] and AGC_GAIN[2:0]; 
 0xC5,0x06,      // FEC auto reset
 0xC1,0x00, 
 0xC8,0xA2,      // not using Full iteration mode  
 0x02,0x00,      // Perform the soft reset.
 0x02,0x01,      // Disable soft reset.
 0xff,0xff
};


 m_BYTE AddrDataMemLGS8934[40]=  //8934 case , external ADC 
{
/* define the register address and data of LGS8934 that need to be initialized when power on */ 
 0x05,0x04, 
 0x07,0x9F,      // BB_SEL=1 because the MTV10X tuner output is I/Q signal; IF_SEL=1, set the negative center frequency for IF
                 // 0x9F: External ADC
 0x09,0x00,      // Set the initial IF frequency of the automatic frequency control as 0Hz.
 0x0A,0x00,      //
 0x0B,0x00,      //
 0x0C,0x00,      //
 0x2d,0x00,      // set AGC_REF[15:8]; 
 0x2e,0xA2,      // set AGC_REF[20:16] and AGC_GAIN[2:0]; 
 0xC5,0x06,      // FEC auto reset
 0xC1,0x00, 
 0xC8,0xA2,      // not using Full iteration mode   
 0x02,0x00,      // Perform the soft reset.
 0x02,0x01,      // Disable soft reset.
 0xff,0xff
};

 m_BYTE AddrDataMemLGS8G54[40]=  //8G54 case , external ADC 
{
/* define the register address and data of LGS8934 that need to be initialized when power on */ 
 0x05,0x04,
 0xBA,0x40, 
 0x07,0x9F,      // BB_SEL=1 because the MTV10X tuner output is I/Q signal; IF_SEL=1, set the negative center frequency for IF
                 // 0x9F: External ADC
 0x09,0x00,      // Set the initial IF frequency of the automatic frequency control as 0Hz.
 0x0A,0x00,      //
 0x0B,0x00,      //
 0x0C,0x00,      //
 0x2d,0x00,      // set AGC_REF[15:8]; 
 0x2e,0xA2,      // set AGC_REF[20:16] and AGC_GAIN[2:0]; 
 0xC5,0x06,      // FEC auto reset
 0xC1,0x00, 
 0xC8,0xA2,      // not using Full iteration mode   
 0x02,0x00,      // Perform the soft reset.
 0x02,0x01,      // Disable soft reset.
 0xff,0xff
};
m_BYTE LGS8G54_InitData_Reg[] =
{
	0x01,0x30,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,