nscc_tuner.c

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

// Function: Set the demodulator works in manual set mode  
// Input : 
//   FEC_Par: Bit[7] = Control Frame;
//            Bit[6:5] = Time Interleaver; 
//            Bit[4:2] = constellation; 
//            Bit[1:0] = code rate;
//   GI_mode: Bit[1:0] = Guard interval, 420 (0x00) or 945(0x02);
// Return: None
//**************************************************************************
void  DemodManualDetectSet(m_BYTE FEC_Par,int GI_mode)
{
    m_BYTE I2CSignalData,I2CSignalData2;
    I2C_READ myi2cRead; 

    if(GI_mode>=0)
	{ // write 0x04 with GI_mode
	  I2CSignalData=(m_BYTE)GI_mode;
	  swrite(lowDemodI2CAdr, 0x04,I2CSignalData);

	  // write 0x03 with 0x00
	  I2CSignalData=0x00;
	  swrite(lowDemodI2CAdr, 0x03,I2CSignalData);
	}

    // write 0x7d with FEC_Par
    I2CSignalData=FEC_Par;
    swrite(lowDemodI2CAdr, 0x7d,I2CSignalData);
 
    // write 0xC0 with FEC_Par
    I2CSignalData=FEC_Par;
    swrite(highDemodI2CAdr, 0xC0,I2CSignalData);
	
    // write 0x7e with 0x00
    I2CSignalData=0x00;
    swrite(lowDemodI2CAdr, 0x7e,I2CSignalData);

    // write 0xC1 with 0x00 
    I2CSignalData=0x00;
    swrite(highDemodI2CAdr, 0xC1,I2CSignalData); 
	

    // read demodulator 0xC5 register, bitand with 0xE0, and write back. 
    myi2cRead=sread (highDemodI2CAdr, 0xC5);
    if( myi2cRead.ACK_status ==1)
	   I2CSignalData       = myi2cRead.read_data;
    I2CSignalData=(m_BYTE)( (I2CSignalData&0x0e0) | 0x06 );
    swrite(highDemodI2CAdr, 0xC5,I2CSignalData); 
	

    myi2cRead=sread (lowDemodI2CAdr, 0x7c);
    if( myi2cRead.ACK_status ==1)
	   I2CSignalData       = myi2cRead.read_data;
    I2CSignalData=(m_BYTE)( (I2CSignalData&0x088) | 0x07);
    swrite(lowDemodI2CAdr, 0x7c,I2CSignalData);

	// add process for 8G54, Liu dong, 2008/04/17 
	if(GetDemodType()==Demod_8G54)
	{
        myi2cRead=sread (lowDemodI2CAdr, 0x04);
		if( myi2cRead.ACK_status ==1)    I2CSignalData       = myi2cRead.read_data;

		I2CSignalData2=0x07;
        myi2cRead=sread (lowDemodI2CAdr, 0x7C);
		if( myi2cRead.ACK_status ==1)    I2CSignalData2      = myi2cRead.read_data;

		if( (I2CSignalData & 0x03) == 0x01 && ((I2CSignalData2 & 0x80) == 0x80) )
		{
			swrite(highDemodI2CAdr, 0x81, 0x02);
			swrite(highDemodI2CAdr, 0x81, 0x03);
			swrite(highDemodI2CAdr, 0x88, 0x05);
		}
		else {
			swrite(highDemodI2CAdr, 0x81, 0x00);
			swrite(highDemodI2CAdr, 0x88, 0x04);
		}
	}


    DemodSoftReset();

    return;
}

//**************************************************************************
// function: check if the auto Detection procedure is finished.  
// return: 0: fail; 1: success
//**************************************************************************
int  AutoDetectDoneCheck(void)
{
	m_BYTE I2CSignalData;
	I2C_READ myi2cRead; 
	int Demod_AutoDone;

	//check if 0xA4 F_AUTO and Done_Auto bits is 01b or not 
	Demod_AutoDone=0;
    myi2cRead=sread (lowDemodI2CAdr, 0xA4); 
	I2CSignalData=myi2cRead.read_data;
	//printk("auto data =%x\n",I2CSignalData);
	if (myi2cRead.ACK_status && (I2CSignalData & 0x03) == 0x01)
		Demod_AutoDone=1;
	else 	Demod_AutoDone=0;

	return(Demod_AutoDone);			
}
//*****************************************************************************
// Function:  Set the demodulator works in Auto-detect mode                   
// Input: None
// Return: None
//*****************************************************************************
void DemodSoftReset(void)
{
     	m_BYTE I2CSignalData;

	I2CSignalData=0x00;
	swrite (lowDemodI2CAdr, 0x02, I2CSignalData);

	I2CSignalData=0x01;
	swrite (lowDemodI2CAdr, 0x02, I2CSignalData);
	return;	
}  

//*****************************************************************************
// Function:  Set Guard Interval Mode                                          
// Input: GI_mode -- GI mode, GI_420(1/9) or GI_945(1/4)
//  1) interface is changed, add an input Parameters of GIPN_Mode 
//  2) add GI mode and GI power matching examination, 0x37 default value is 0x01 for GI420 and GI945
// Return: None
//****************************************************************************
void GIModeSet(int GI_mode, int GIPN_mode)
{
    m_BYTE I2CSignalData1=0,I2CSignalData2=0;
    I2C_READ myi2cRead;  
	// read 0x04 content 
	myi2cRead=sread(lowDemodI2CAdr, 0x04);
	if( myi2cRead.ACK_status ==1) I2CSignalData1=myi2cRead.read_data;
	// read 0x37 content 
	myi2cRead=sread(lowDemodI2CAdr, 0x37);
	if( myi2cRead.ACK_status ==1) I2CSignalData2=myi2cRead.read_data;

	if(GI_mode==GI_420 || GI_mode==GI_945 || GI_mode==GI_595)
	{ 
        I2CSignalData1=(unsigned char) ( (I2CSignalData1 & 0x0FC) | GI_mode );
  	    // write 0x04 with GI_mode 
		swrite (lowDemodI2CAdr, 0x04, I2CSignalData1);

		if(GI_mode==GI_595) GIPN_mode=GIPN_Constant;
		
		if(GIPN_mode==GIPN_Constant) I2CSignalData2=(unsigned char) (I2CSignalData2 | GIPN_Constant);
		else if (GIPN_mode==GIPN_Variable) I2CSignalData2=(unsigned char) (I2CSignalData2 & GIPN_Variable);

		swrite (lowDemodI2CAdr, 0x37, I2CSignalData2);
	}
	return;
}

//********************************************************************************
// Function: check the detected mode by read 0x7E register 
// Input: None  
// Return: 0x00 is manual mode, 0x01 is the auto-detected mode, -1 means I2C read Error. 
//********************************************************************************
int   CheckDetectMode(void)
{
    m_BYTE I2CSignalData;
    I2C_READ myi2cRead; 
 
    // read 0x7E 
    myi2cRead=sread(lowDemodI2CAdr, 0x7E);
    if( myi2cRead.ACK_status == 1)
    { 
		I2CSignalData = (myi2cRead.read_data & 0x01);  /*add 0x01*/
        return(I2CSignalData);
    }
    else return(-1); 	
}

//**************************************************************************
// Function: return GI detection current value    
// Input: None
// Return:  Guard Interval  
//
//**************************************************************************
int GetGISet(void)
{
   	I2C_READ myi2cRead;
   	int GI_detect_val,Auto_set;

   	GI_detect_val=-1;
   	Auto_set=-1;

   	myi2cRead=sread(lowDemodI2CAdr, 0x03);  // 0x03 
   	if( myi2cRead.ACK_status ==1)
   	{ 
    	Auto_set = myi2cRead.read_data;
    }
   	else 
   		return(GI_detect_val); 

   	if(Auto_set==0) 
   	{
       	myi2cRead=sread(lowDemodI2CAdr, 0x04);  // 0x04 , manual set value 
    	if( myi2cRead.ACK_status ==1)
		{ 
	  		GI_detect_val = myi2cRead.read_data;
		}
    	else 
    		return(GI_detect_val); 
    }
   else if(Auto_set==1){
	myi2cRead=sread(lowDemodI2CAdr, 0x44);  // 0x044 
	if( myi2cRead.ACK_status ==1)
	{ 
	  GI_detect_val = myi2cRead.read_data;
	}
	else return(GI_detect_val); 
    }

  return(GI_detect_val);
}
//*****************************************************************************
// Function:  Check the Demod lock status by checking Demod 0x4B register.                                    
// Input: None
// Return: Lock_flag -- lock status, 1 means lock, 0 no lock.
//*****************************************************************************
int  SignalLockCheck(void)
{  
   	I2C_READ myi2cRead;
   	int TunerI2C_status, DemodI2C_status1, DemodI2C_status2; //record the I2C access status 
   	int Tuner_pll_lock, Demod_CALOCK, Demod_AutoDone,lock_status; //record the bit status 
   	int check_mode; 
   	int Tuner0x06Lock,TunerADout;
    
   	TunerI2C_status=DemodI2C_status1=DemodI2C_status2=0;
   	Tuner_pll_lock=Demod_CALOCK=Demod_AutoDone=0;
    
   	check_mode = 1;

   	// check if the Tuner PLL is locked or not 
   	myi2cRead=sread (lowTunerI2CAdr, 0x06);
   	TunerI2C_status=myi2cRead.ACK_status;
   	if (TunerI2C_status && (myi2cRead.read_data&0x02) ==0x02) 
		Tuner0x06Lock=1; 
   	else 
   		Tuner0x06Lock=0; 

   	myi2cRead=sread (lowTunerI2CAdr, 0x04);
   	TunerI2C_status=myi2cRead.ACK_status;
   	TunerADout=0xff;   
   	if (TunerI2C_status) 
   		TunerADout=(myi2cRead.read_data&0x0f);

   	if ( ( ( TunerADout > TunerADOutMin ) && ( TunerADout < TunerADOutMax ) ) && Tuner0x06Lock )  //pll lock cross check
	  	Tuner_pll_lock=1;
   	else 
   		Tuner_pll_lock=0;

   	// check if Demod is locked or not 
   	myi2cRead=sread (lowDemodI2CAdr, 0x4b);
   	DemodI2C_status1=myi2cRead.ACK_status;                       // Access 0x4b register 
   	//if (DemodI2C_status1 && (myi2cRead.read_data & 0xc0) == 0xc0) // means the signal is not locked 
   	if (DemodI2C_status1 && (myi2cRead.read_data & 0x80) == 0x80) // means the signal is not locked 
		Demod_CALOCK=1;
   	else 
   		Demod_CALOCK=0;

   	if(Demod_CALOCK==1) 
   		Tuner_pll_lock=1;

   	if(CheckDetectMode()==1) // FEC auto-detected is enable
    {
		Demod_AutoDone = AutoDetectDoneCheck();
		check_mode=2;
    }

   //merge the three lock status together, [Auto_done,CA_Lock,PLL_Lock]
   	lock_status= Tuner_pll_lock + Demod_CALOCK*2 + Demod_AutoDone*4; 
   // printk("lock=%d check_mode= %d\n",lock_status,check_mode);
   	if (lock_status==0x07 && check_mode==2)  
   		return (1);
   	else if((lock_status & 0x03)==0x03 && check_mode==1) 
   		return (1);
   	else  
   		return (0);
}

// ****************************************************************************
// Function: check if the demodulator auto-detect mode work normally  
// Input: GIChangeTimes -- indicate the number that GI changed times
// Return: success or not flag 
// ****************************************************************************
int DetectDemodMode(int GIChangeTimes)
{
    I2C_READ myi2cRead;
    int lock_flag=0;
    int ret_status;
    int GI_Val;
    unsigned char tmp_demod_mode;
    int DemodType;
	int GIMod,GIPN_Mod;

    lock_flag=SignalLockCheck(); 
    //printk("flg= %x\n",lock_flag);
	if (lock_flag) 
    {    	
		tmp_demod_mode = 0xff; 
        myi2cRead=sread (lowDemodI2CAdr, 0xA2); //auto-deteced result 
		if(myi2cRead.ACK_status ==1) 
			tmp_demod_mode  = myi2cRead.read_data;

		if(tmp_demod_mode != 0xff )
		{
            DemodType=GetDemodType();
            if(DemodType==Demod_8934) // for LGS8934 case 
		 	{
		    	// for LGS8934 case , it can not distinguish 00 and 240
		    	if((tmp_demod_mode & 0x60)!=0x60) 						
		     	{
					tmp_demod_mode=(m_BYTE) ( (tmp_demod_mode & 0x1f) | 0x40 );			
					DemodManualDetectSet(tmp_demod_mode,-1);
		      	}
		     	else
		     	{
		     		DemodManualDetectSet(tmp_demod_mode,-1); 
		     	}
		 	}
	    	else if(DemodType==Demod_8GL5 || DemodType==Demod_8G54)  // LGS8GL5 or LGS8G54 case 
		    {
		     	DemodManualDetectSet(tmp_demod_mode,-1); //for 8GL5 do not set manually.
			}
	 	}
  	 	ret_status=DetectOkOnLock;
  	 	//printk("ret_status= %x\n",ret_status);
	}
	else  
	{
		 GI_Val=GetGISet();  
         GIMod=GI_Val;
		 GIPN_Mod=GIPN_Constant;

		 switch(GIChangeTimes%5)   // first GI setting is begin from GI=420, PN Variable case 
		 {
			 case 1: {  // GI=420, PN constant case 
				GIMod = GI_420; GIPN_Mod=GIPN_Constant;
				break;
				}
			 case 2: { // GI=945, PN Variable case 
				GIMod = GI_945; GIPN_Mod=GIPN_Variable;
				break;
				}
			 case 3: {  // GI=945, PN constant case 
				GIMod = GI_945; GIPN_Mod=GIPN_Constant;
				break;
				}
			 case 4: { // GI=595, PN constant case 
				GIMod = GI_595; GIPN_Mod=GIPN_Constant;
				break;
				}
			 case 0: { // GI=420, PN Variable case 
				GIMod = GI_420; GIPN_Mod=GIPN_Variable;
				break;
				}
	         default: break;
		}
		GIModeSet(GIMod,GIPN_Mod);
        if( (GIChangeTimes%5)==4 ) swrite(lowDemodI2CAdr,0x24,0x05);
		Sleep(400);
        DemodSoftReset();
        ret_status=OnProcessNoLock;

	}	
	return(ret_status);
}

//*****************************************************************************************
//  Function: Init the Front-end board. 
//      Default working mode is Demod: parallel output
//      DMB-TH signal bandwidth is 8MHz 
//  Input: 
//    Freq: channel frequency value, in MHz unit 
//    PLLType: Tuner Crystal type 
//    InitMode: Init mode, 0 means need to set Tuner I2C working mode and check I2C bus
//  Output: success or fail flag
//***************************************************************************************** 
int FrontEndBoardInit(int Freq, int PLLType, int InitMode)
{
    int DemodType;
    if(InitMode == 0) 
    {  // need to set Tuner I2C bus type and check I2C bus 
		// here Get Tuner and Demod I2C address if needed. 
		if(0x03 != CheckDemodI2C()) 
			return(false);  // check if Demod I2C is error !
	  
		// first determine the Tuner I2C type 
		// set Tuner I2C bus type according to the Demodulator type 
        DemodType = GetDemodType();  
		if ((DemodType == Demod_8GL5) || (DemodType==Demod_8G54))
		{
			SetTunerI2CInternal(); //8GL5 or 8G54 type    
			printk("demodulator LGS8GL5%s found\n",(DemodType == Demod_8GL5)?"":"4");
		} 
		else 
		{
			SetTunerI2CExternal();
			printk("demodulator LGS8934 found\n");
	    }	    
	    
		if(0x03 != CheckTunerI2C(lowTunerI2CAdr)) 
			return(false);  // check if Tuner I2C is error !
    }