zl10353.c

mstar 776 开发的车载dvd

	au8Data[0] = 0x34;
	au8Data[1] = 0xC0;
	if( MDrv_IIC_WriteBytes(ZL10353_devAddr, 1, &u8addr, 2, au8Data) == FALSE )
	{
		return FAIL;
	}

	//Addr=13, GAIN16XDB=81
	//u8addr = 0x9A;
	au8Data[0] = 0x51;
	au8Data[1] = 0xD0;
	if( MDrv_IIC_WriteBytes(ZL10353_devAddr, 1, &u8addr, 2, au8Data) == FALSE )
	{
		return FAIL;
	}

	return PASS;
}

/************************************************************************************
  Subject:    ZL10353 software based power on/down procedure
  Function:   ZL10353_Power_ON_OFF
  Parmeter:   mode
		1 --> Power ON
		0 --> Power OFF
  Return:     0(FAIL) mean I2C fail, 1(PASS) mean I2C success
  Remark:     Software Power ON/OFF function doesn't need re-power on initialization
*************************************************************************************/
BOOLEAN ZL10353_Power_ON_OFF ( U8 mode )
{
	U8 Reg_H50, Reg_H5A;

	//Read register 0x5A (RF_Lev bit)

	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x5A, &Reg_H5A ) == FALSE )
	{
		return FAIL;
	}

	if ( mode )
	{
		Reg_H50 = 0x0B;
	}
	else
	{
		Reg_H50 = 0x0C;
		CLRBIT( Reg_H5A, 7 );
	}

	//Write Register 0x50
	if ( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x50, Reg_H50 ) == FALSE )
	{
		return FAIL;
	}

	//Write Register 0x5A
	if ( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x5A, Reg_H5A ) == FALSE )
	{
		return FAIL;
	}

	return PASS;
}

/************************************************************************************
  Subject:    Indicates lock status of the OFDM
  Function:   ZL10353_Lock_Indicate
  Parmeter:   None
  Return:     -1(FAIL) mean I2C fail
	       0(NoLock) mean ZL10353 doesn't lock any OFDM signal
	       1(Lock) mean ZL10353 has already locked OFDM signal
  Remark:     Read bit5(FEC_Lock) of register 0x06
*************************************************************************************/
BOOLEAN ZL10353_Lock_Indicate ( void )
{
    U8 Reg_H06;

    //Read register 0x06
    if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x06, &Reg_H06 ) == FALSE )
    {
        //printf("Check Lock IIC Fail\n");
        return FAIL;
    }

    //Read bit5 (FEC_Lock)
    if ( Reg_H06 & 0x20 )
    {
        //printf("Tuner Lock \r\n");
        return PASS;
    }
    else
    {
        //printf("Tuner Not Lock \r\n");
        return FAIL;
    }
}

/****************************************************************************
  Subject:    Read the signal to noise ratio (SNR)
  Function:   ZL10353_GetSNR
  Parmeter:   None
  Return:     -1 mean I2C fail, otherwise I2C success then return SNR value
  Remark:     0 ~ 31.875dB (1/8 dB step)
*****************************************************************************/
float ZL10353_GetSNR ( void )
{
	U8 Reg_H10;

	//Read register 0x10
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x10, &Reg_H10 ) == FALSE )
	{
		return FAIL;
	}

	return ( ( float ) Reg_H10 * 0.125 ); //Reg_H10/255 * 100 (%)
}

/********************************************************************************
  Subject:    Read the RF level Measurement from 7 bit ADC (inside ZL10353)
  Function:   ZL10353_Get_RF_AGC_Level
  Parmeter:   None
  Return:     -1 mean I2C fail, otherwise I2C success then return RF level value
  Remark:     Read register 0x0E
*********************************************************************************/
int ZL10353_Get_RF_AGC_Level ( void )
{
	U8 Reg_H0E;
	unsigned int u16TempValue;
	//Read register 0x10
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x0E, &Reg_H0E ) == FALSE )
	{
		return FAIL;
	}
	u16TempValue=Reg_H0E;
	return ( u16TempValue * 100 / 127 );
}

/********************************************************************************
  Subject:    Read the IF AGC level
  Function:   ZL10353_Get_IF_AGC_Level
  Parmeter:   None
  Return:     -1 mean I2C fail, otherwise I2C success then return IF level value
  Remark:     Read register 0x0A, 0x0B
*********************************************************************************/
int ZL10353_Get_IF_AGC_Level ( void )
{
	U8 Reg_H0A, Reg_H0B;
	unsigned long IF_Level;

	//Read register 0x0A
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x0A, &Reg_H0A ) == FALSE )
	{
		return FAIL;
	}
	//Read register 0x0B
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x0B, &Reg_H0B ) == FALSE )
	{
		return FAIL;
	}

	IF_Level = ( ( ( unsigned long ) Reg_H0A ) & 0x3F ) << 8 + ( unsigned long ) Reg_H0B;
	IF_Level = IF_Level * 100 / 16383;
	if ( IF_Level == 0 )
	{
		return 0;
	}

	return ( 100 - ( int ) IF_Level );
}

/*****************************************************************************
  Subject:    Read CAM Tuner status byte (By using ZL10353 register)
  Function:   Tuner_Read
  Parmeter:   Tuner Address
  Return :    -1 mean I2C fail, otherwise I2C success and return status value
  Remark:
******************************************************************************/
U8 Tuner_Read ( U8 device )
{
	U8 status_1, status_2;

	//Tuner_Addr, Register 0x67
	if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x67, device ) == FALSE )
	{
		return -1;
	}

	//Tuner_Go, Register 0x70
	if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x70, 0x02 ) == FALSE )
	{
		return -1;
	}

	MDrv_Timer_Delayms( 1 );

	//Status_1 check ! Register 0x07
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x07, &status_1 ) == FALSE )
	{
		return -1;
	}

	if ( status_1 & 0x0C )
	{
		return FAIL;
	}

	//Read Status_2, Register 0x08
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x08, &status_2 ) == FALSE )
	{
		return -1;
	}

	return status_2;
}

/************************************************************************************************
  Subject:    Program CAM Tuner by writing ZL10353 register
  Function:   ZL10353_Tuner_Programming
  Parmeter:   Tuner Address,data1,data2,data3,data4
  Return :    0(FAIL) mean I2C fail, 1(PASS) mean I2C success
  Remark:     Register 0x67 ~ 0x6B and Tuner_Go (0x70)
*************************************************************************************************/
BOOLEAN ZL10353_Tuner_Programming ( U8* pu8data )
{
	U8 i;
	//programming register 0x67,0x68,0x69,0x6A,0x6B
	u8addr = 0x67;
	for (i=0;i<5;i++)
		au8Data[i] = *(U8 *)(pu8data+i);

    //==========================================================
    // Write first time
	if( MDrv_IIC_WriteBytes(ZL10353_devAddr, 1, &u8addr, 5, au8Data) == FALSE )
	{
 		return FAIL;
	}
	//Tuner_GO, Register 0x70
	if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x70, 0x01 ) == FALSE )
	{
 		return FAIL;
	}
#if 0
    //==========================================================
	MDrv_Timer_Delayms( 10 );

    au8Data[3] = (au8Data[3]&0xC7)|0x18;
    au8Data[4] = 0xA0;

	if( MDrv_IIC_WriteBytes(ZL10353_devAddr, 1, &u8addr, 5, au8Data) == FALSE )
	{
 		return FAIL;
	}
	//Tuner_GO, Register 0x70
	if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x70, 0x01 ) == FALSE )
	{
 		return FAIL;
	}

    //==========================================================
	MDrv_Timer_Delayms( 100 );

    au8Data[3] = (au8Data[3]&0xC7)|0x18;
    au8Data[4] = 0x20;

	if( MDrv_IIC_WriteBytes(ZL10353_devAddr, 1, &u8addr, 5, au8Data) == FALSE )
	{
 		return FAIL;
	}
	//Tuner_GO, Register 0x70
	if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x70, 0x01 ) == FALSE )
	{
 		return FAIL;
	}

    //==========================================================
	//Status_1 check ! (Register 0x07)
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x07, &au8Data[0] ) == FALSE )
	{
 		return FAIL;
	}
	if ( au8Data[0] & 0x0C )
	{
 		return FAIL;
	}
#endif
	return PASS;
}

/***********************************************************************************************
  Subject:    Pre-Viterbi (OFDM output) bit error count
  Function:   ZL10353_PreViterbi
  Parmeter:   None
  Return :    -1 mean I2C fail or FEC doesn't lock
  Remark:     Pre-Viterbi BER = VIT_ERR_Cnt / (4 *(VIT_Err_Per * 65536 + 65535))
	      <PS> The default period of Viterbi decoder is 0xFF (67108860 bits)
************************************************************************************************/
float ZL10353_PreViterbi ( void )
{
	U8 Status_0;
	U8 Interrupt_2;
	//U8 value[3];
	//unsigned long BER;

	//Read FEC_Lock bit first ! (Status_0)
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x06, &Status_0 ) == FALSE )
	{
		return FAIL;
	}

	if (  !( Status_0 & 0x20 ) )
	{
		return FAIL;
	}

	//Read Interrupt_2 bit5 to ensure the end of Viterbi bit error count period
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x02, &Interrupt_2 ) == FALSE )
	{
		return FAIL;
	}

	if ( Interrupt_2 & 0x20 )
	{
		//Read register 0x2F/0x30/0x31

		#if 0 //Truman temp
		if(  IIC_Structure_Read( ZL10353_devAddr, 0x2F, value, 3 );
		if ( !Return_Value )
			return -1;

		BER = ( unsigned long ) value[0] << 16 + ( unsigned long ) value[1] << 8 + ( unsigned long ) value[2];
		return ( ( float ) BER / 67108860 );
		#endif
	}
}

/*****************************************************************************************************
  Subject:    Post-Viterbi (Viterbi decoder output) bit error count
  Function:   ZL10353_PostViterbi
  Parmeter:   None
  Return :    -1 mean I2C fail or FEC doesn't lock
  Remark:     Post Viterbi BER = RS_ERR_Cnt / (RS_Err_Per * 1024 * 1632)
	      <PS> The default period of Reed-Solomon decoder is 1024 RS block * 77 (128679936 bits)
******************************************************************************************************/
float ZL10353_PostViterbi ( void )
{
	U8 Status_0;
	U8 Interrupt_2;
	//U8 value[3];
	//unsigned long BER;

	//Read FEC_Lock bit first ! (Status_0)
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x06, &Status_0 ) == FALSE )
	{
		return FAIL;
	}

	if (  !( Status_0 & 0x20 ) )
	{
		return FAIL;
	}

	//Read Interrupt_2 bit5 to ensure the end of Viterbi bit error count period
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x02, &Interrupt_2 ) == FALSE )
	{
		return FAIL;
	}

	if ( Interrupt_2 & 0x04 )
	{
		//Read register 0x11/0x12/0x13
		#if 0 //Truman temp
		if(  IIC_Structure_Read( ZL10353_devAddr, 0x11, value, 3 );
		if ( if( = 1 )
			return -1;

		BER = ( unsigned long ) value[0] << 16 + ( unsigned long ) value[1] << 8 + ( unsigned long ) value[2];
		return ( ( float ) BER / ( 77 * 1024 * 1632 ) ); // BER/128679936 * 100 (%)
		#endif
	}
}

/**************************************************************************
  Subject:    ZL10353 HP LP Setting
  Function:   ZL10353_HP_LP_Setting
  Parmeter:   Channel_mode
		0 --> HP
		1 --> LP
  Return:     0(FAIL) mean I2C fail, 1(PASS) mean I2C success
  Remark:     Programming Register 0x6E
**************************************************************************/
BOOLEAN ZL10353_HP_LP_Setting ( U8 Channel_Mode )
{
	U8 Reg_H6E;

	//Read register 0x6E
	if ( MDrv_IIC_ReadByte( ZL10353_devAddr, 0x6E, &Reg_H6E ) == FALSE )
	{
		return FAIL;
	}

	switch ( Channel_Mode )
	{
		case 0:
			//HP
			CLRBIT( Reg_H6E, 7 );
			break;
		case 1:
			//LP
			SETBIT( Reg_H6E, 7 );
			break;
	}

	//Write register 0x6E
	if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x6E, Reg_H6E ) == FALSE )
	{
		return FAIL;
	}

	return PASS;
}

BOOLEAN ZL10353_RepeatControl ( BOOLEAN bEnable )
{
    U8 u8Temp;

    MDrv_IIC_ReadByte( ZL10353_devAddr, 0x62, &u8Temp );

    if(bEnable)
    {
        if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x62, u8Temp | 0x10 ) == FALSE )
            return FAIL;
    }
    else
    {
        if( MDrv_IIC_WriteByte( ZL10353_devAddr, 0x62, u8Temp & 0xEF ) == FALSE )
            return FAIL;
    }
    return PASS;
}

BOOLEAN ZL10353_FSM_Restart ( void)
{
	if(MDrv_IIC_WriteByte( ZL10353_devAddr, 0x71, 0x01 )==FALSE)
		return FALSE;
}


#undef _ZL10353_C_