nscc_tuner.c

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

	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xE4,0xF5,0xA8,0xF5,0xB8,0xF5,0x88,0xF5,
	0x89,0xF5,0x87,0x75,0xD0,0x00,0x11,0x50,
	0x11,0x50,0xF4,0xF5,0x80,0xF5,0x90,0xF5,
	0xA0,0xF5,0xB0,0x75,0x81,0x30,0x80,0x01,
	0x32,0x90,0x80,0x12,0x74,0xFF,0xF0,0x90,
	0x80,0x13,0x74,0x1F,0xF0,0x90,0x80,0x23,
	0x74,0x01,0xF0,0x90,0x80,0x22,0xF0,0x90,
	0x00,0x48,0x74,0x00,0xF0,0x90,0x80,0x4D,
	0x74,0x05,0xF0,0x90,0x80,0x09,0xE0,0x60,
	0x21,0x12,0x00,0xDD,0x14,0x60,0x1B,0x12,
	0x00,0xDD,0x14,0x60,0x15,0x12,0x00,0xDD,
	0x14,0x60,0x0F,0x12,0x00,0xDD,0x14,0x60,
	0x09,0x12,0x00,0xDD,0x14,0x60,0x03,0x12,
	0x00,0xDD,0x90,0x80,0x42,0xE0,0x60,0x0B,
	0x14,0x60,0x0C,0x14,0x60,0x0D,0x14,0x60,
	0x0E,0x01,0xB3,0x74,0x04,0x01,0xB9,0x74,
	0x05,0x01,0xB9,0x74,0x07,0x01,0xB9,0x74,
	0x0A,0xC0,0xE0,0x74,0xC8,0x12,0x00,0xE2,
	0xD0,0xE0,0x14,0x70,0xF4,0x90,0x80,0x09,
	0xE0,0x70,0xAE,0x12,0x00,0xF6,0x12,0x00,
	0xFE,0x90,0x00,0x48,0xE0,0x04,0xF0,0x90,
	0x80,0x4E,0xF0,0x01,0x73,0x90,0x80,0x08,
	0xF0,0x22,0xF8,0x7A,0x0C,0x79,0xFD,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xD9,
	0xF6,0xDA,0xF2,0xD8,0xEE,0x22,0x90,0x80,
	0x65,0xE0,0x54,0xFD,0xF0,0x22,0x90,0x80,
	0x65,0xE0,0x44,0xC2,0xF0,0x22
};

//*****************************************************************************
// Function:   Main Function for Demodulator Initialization                     
// Input: DemodOutType -- Demodulator output type, parallel or serials 
// Return: None
//*****************************************************************************
void DemodInit(int DemodOutType)
{
   int DemodType;
   
   if(DemodOutType==DemodSerialOutType) DemodOutputSerialSet();
   else if (DemodOutType==DemodParallelOutType) DemodOutputParallelSet();

   DemodType=GetDemodType();   
   if(DemodType==Demod_8GL5)   	   ConfigDemod(AddrDataMemLGS8GL5);   	
   else if(DemodType==Demod_8934)  ConfigDemod(AddrDataMemLGS8934);  
   else if(DemodType==Demod_8G54)
   {
	   ConfigDemod(AddrDataMemLGS8G54);  
   	   SpecInitforLGS8G54();
   }

   //GIModeSet(GI_420, GIPN_Constant);  /*src*/
   GIModeSet(GI_420, GIPN_Variable);   /*debug*/
   DisableGIAutoDetect();
   DemodAutoDetectSet();
   DemodSoftReset();
   
   return;
}
//*****************************************************************************
// Function:  Configure Demod  chip                                            
// Input: AddrData -- Register address and Config data array 
// Return: None
//*****************************************************************************
void ConfigDemod(m_BYTE *AddrData)
{
   int i=0;
   m_BYTE addr, data,target;

   while (AddrData[i]!=0xFF)
   { 
     addr = AddrData[i++];
     data = AddrData[i++];
     if (addr>DemodSec1MaxAdr)  target = highDemodI2CAdr;  // change the I2C device address 
     else   target = lowDemodI2CAdr; 	
     swrite(target, addr, data);
   }  
   return;
}
// ******************************************************************
// function: special process for LGs8G54 init 
// input: None
// output: None
// ******************************************************************
void SpecInitforLGS8G54(void)
{
	int k;
	unsigned char Reg_val;

	swrite(highDemodI2CAdr,0x81,0x00);
    swrite(highDemodI2CAdr,0x82,0x00);
    swrite(highDemodI2CAdr,0x80,0x00);
    swrite(highDemodI2CAdr,0x83,0x00);
    swrite(highDemodI2CAdr,0x80,0x00);
	
	for( k=0; k<sizeof(LGS8G54_InitData_Reg); k++ )
	{
		swrite(highDemodI2CAdr,0x80,0x00);
		swrite(highDemodI2CAdr,0x82,(unsigned char)(k&0x0ff));
		swrite(highDemodI2CAdr,0x83,(unsigned char)(k>>8));
        
		Reg_val=LGS8G54_InitData_Reg[k++];
		swrite(highDemodI2CAdr,0x84,Reg_val);
	}

	swrite(highDemodI2CAdr,0x80,0x00);
	return;
}


// ******************************************************************
//  function: Check if Demodulator I2C access is ok or not 
//  c heck 0x03 and 0xc2 register, read-write-read again.  
//  return: 2 bits 
//   Bit0: indicate the write operation successful or not. 0: fail, 1: ok 
//   Bit1: indicate the read  operation successful or not. 0: fail, 1: ok  
//  
// ******************************************************************
int CheckDemodI2C(void)
{
    I2C_READ myi2cRead;
    m_BYTE OriData,WriteData,ReadData;
    int Ret_val=0;
    int Low_read=0,High_read=0,Low_write=0,High_write=0;
 
    myi2cRead=sread (lowDemodI2CAdr, 0x03);
    if( myi2cRead.ACK_status == 1) 
    { 
    	OriData  = myi2cRead.read_data;
		Low_read = 1;
	}
    else 
    { 
    	Low_read=0; 
		return(Ret_val);
	}

    WriteData= (m_BYTE)(( ~(OriData &0x01) ) & 0x01);
    swrite (lowDemodI2CAdr, 0x03,WriteData);  
    myi2cRead=sread (lowDemodI2CAdr, 0x03); 
    if( myi2cRead.ACK_status ==1) 
    { 
    	ReadData      = myi2cRead.read_data;
		Low_read=1;
	}
    else 
    { 
    	Low_read=0; 
		return(Ret_val);
	}
	
    if(ReadData==WriteData)
    {	
    	Low_write=1; 
	    Low_read=1;
	}
    else 
    {	
    	Low_write=0;
    }
  
    // resume the 0x03 value.
    swrite (lowDemodI2CAdr, 0x03,OriData); 
	
    // check 0x36 section 
    myi2cRead=sread (highDemodI2CAdr, 0xc2);
    if( myi2cRead.ACK_status ==1)   
    { 
    	OriData  = myi2cRead.read_data;
		High_read=1;
	}
    else 
    { 
    	High_read=0; 
	 	return(Ret_val);
	}

    WriteData= (m_BYTE)(( ~(OriData &0x07) ) & 0x07);
    swrite (highDemodI2CAdr, 0xC2,WriteData);  
    myi2cRead=sread (highDemodI2CAdr, 0xC2);
    if( myi2cRead.ACK_status ==1) 
    { 
    	ReadData  = myi2cRead.read_data;
		High_read=1;
	}
    else 
    { 
    	High_read=0; 
	 	return(Ret_val);
	}
	
    if(ReadData==WriteData)
    {	
    	High_write=1; 
		High_read=1;
	}
    else 
    {
    	High_write=0;
    }


    // resume the 0xc2 value.
    swrite (highDemodI2CAdr, 0xC2,OriData);

    if (Low_read && High_read)  Ret_val= (Ret_val | 0x02); //bit1=1
    else  Ret_val= (Ret_val & 0x01);  //bit1=0

    if (Low_write && High_write)  Ret_val= (Ret_val | 0x01); //bit0=1
    else  Ret_val= (Ret_val & 0x02);  //bit0=0
	
    return(Ret_val);  // 0x03 means all ok.
}
//*****************************************************************************
// Function:  Set Demodulator works in Serials output mode                                        
// Input: none
// Return: None
//*****************************************************************************
void DemodOutputSerialSet(void)
{
  m_BYTE MiscReadData;
  I2C_READ myi2cRead;

  MiscReadData=0x0f; //default value;
  myi2cRead=sread(highDemodI2CAdr,0xC2);  // read the 0xC2 register value 
  if(myi2cRead.ACK_status==1) MiscReadData=myi2cRead.read_data;
  MiscReadData=(m_BYTE)(MiscReadData|0x05);
  swrite(highDemodI2CAdr,0xC2,MiscReadData);  //set SERIAL=1, MPEGCLK=1;
  return ;
}
//*****************************************************************************
// Function:  Set Demodulator works in Serials output mode                                         
// Input: none
// Return: None
//*****************************************************************************
void    DemodOutputParallelSet(void)
{
  m_BYTE MiscReadData;
  I2C_READ myi2cRead;
  MiscReadData=0x0a; //default value; 
  myi2cRead=sread(highDemodI2CAdr,0xC2);  // read the 0xC2 register value 
  if(myi2cRead.ACK_status==1) MiscReadData=myi2cRead.read_data;
  MiscReadData=(m_BYTE)((MiscReadData & 0xfa) | 0x02);
  swrite(highDemodI2CAdr,0xC2,MiscReadData);  //set SERIAL=0, MPEGCLK=0;
  return ;
}

//*****************************************************************************
// Function:  Get Demodulator Chip Type                                       
// Input: None
// Return: DemodType -- Demodulator Type , 8GL5 or 8934 
//*****************************************************************************
int   GetDemodType(void)
{
    m_BYTE  Dat;
    I2C_READ myi2cRead;
    int DemodType;
    Dat=0xff; 	
    myi2cRead=sread (lowDemodI2CAdr, 0x00);
    if( myi2cRead.ACK_status ==1)  
    	Dat  = myi2cRead.read_data;
    if(Demod_8GL5ID == Dat)      
    {
    	DemodType = Demod_8GL5;
    }
    else if(Demod_8934ID == Dat) 
    {
    	DemodType = Demod_8934;
    }
    else if(Demod_8G54ID == Dat) 
    {
    	DemodType = Demod_8G54;
    }
    else 
    {
    	DemodType = Demod_8G44;
	}
    return(DemodType);
}
//*****************************************************************************
// Function:  Set Tuner I2C bus type as "From Demod type"                     
// Input: None
// Return: None
//*****************************************************************************
void  SetTunerI2CInternal(void)
{
   m_BYTE I2CSignalData;
   I2CSignalData=(0x80 | ((lowTunerI2CAdr)>>1));
   swrite(lowDemodI2CAdr, 0x01,I2CSignalData);    
   return;
}
//*****************************************************************************
// Function:  Set Tuner I2C bus type as "Bypass Demod type"                   
// Input: None
// Return: None
//*****************************************************************************
void  SetTunerI2CExternal(void)
{
  // write 0x01 with 0x00, set the Tuner I2C access path bypass Demod.  
  swrite(lowDemodI2CAdr, 0x01,0x00); 
  return;
}

//*****************************************************************************
// Function:  Disable GI Auto-detect mode                                          
// Input: none
// Return: None
//*****************************************************************************
void   DisableGIAutoDetect(void)
{
  swrite(lowDemodI2CAdr, 0x03,0x00); 
  return;
}
//*****************************************************************************
// Function:  Get current Demod working mode parameters according to 
//            "Auto-detect" mode setting status  (0x7E register setting)
//            The working mode parameters include Time interleaver, Code rate, Constellation etc.                                       
// Input: none
// Return: the TIM, QAM and Code rate parameters . return -1 means I2C read error.
//   FEC_Par: Bit[7]   = Control Frame;
//            Bit[6:5] = Time Interleaver; 
//            Bit[4:2] = constellation; 
//            Bit[1:0] = code rate;
//*****************************************************************************
int  GetFECPara(void)
{
   	m_BYTE FEC_para;
	I2C_READ myi2cRead;

	if(CheckDetectMode()==1)  // auto-detected mode , read 0xA2 register. 
	{
       	// read 0xA2 register 
	myi2cRead=sread (lowDemodI2CAdr, 0xA2);
       	if( myi2cRead.ACK_status ==1)  
       		{ FEC_para      = myi2cRead.read_data;
        	  return(FEC_para);
        	}
	}
	else  if(CheckDetectMode()==0) //manual mode , read 0x7D register. 
	{
       	// read 0x7D register 
	myi2cRead=sread (lowDemodI2CAdr, 0x7D);
        if( myi2cRead.ACK_status ==1)  
               	{ FEC_para      = myi2cRead.read_data;
        	  return(FEC_para);
        	}
	}
	
	return(-1);		
}

//*****************************************************************************
// Function:  Set the demodulator works in Auto-detect mode                                         
// Input: none
// Return: None
//*****************************************************************************
void DemodAutoDetectSet(void)
{
   	m_BYTE I2CSignalData;
	I2C_READ myi2cRead;
	
	I2CSignalData=0x06; //default value;
	// 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);
        swrite(highDemodI2CAdr, 0xC5,I2CSignalData); 
	
	// write 0x7e with 0x01 
	I2CSignalData=0x01;
	swrite(lowDemodI2CAdr, 0x7e,I2CSignalData); 

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

	// read demodulator 0x7C register, Do bitand with 0x88, bitOr with 0x07, and write back. 
	I2CSignalData=0x03; //default value;
	myi2cRead=sread (lowDemodI2CAdr, 0x7C);
        if( myi2cRead.ACK_status ==1)
	   I2CSignalData       = myi2cRead.read_data;
	
        I2CSignalData=(m_BYTE)( (I2CSignalData&0x88) | 0x07);
        swrite(lowDemodI2CAdr, 0x7C,I2CSignalData);
	
	// read demodulator 0xC3 register, bitand with 0xE0, and write back. 
	I2CSignalData=0x01; //default value;
	myi2cRead=sread (highDemodI2CAdr, 0xC3);
        if( myi2cRead.ACK_status ==1)
	   I2CSignalData       = myi2cRead.read_data;
        I2CSignalData=(m_BYTE)( (I2CSignalData&0xEF) | 0x10);
        swrite(highDemodI2CAdr, 0xC3,I2CSignalData);

	// add 0x37 register setting according to Joshua's suggestion
 	swrite(lowDemodI2CAdr, 0x37,0x01);  // not suitable for GI=545 case 

	 if(GetDemodType()==Demod_8G54)
	 {
		swrite(highDemodI2CAdr, 0x81,0x00);  
		swrite(highDemodI2CAdr, 0x88,0x04); 
	 }
	DemodSoftReset(); 

	return;
}

//**************************************************************************