/** *SFILE**************************************************************** * FILE NAME : 1411x.cpp * AUTHOR : SOC Development Center, Channel Development Team, * Channel.cs * MODERATOR : * ISSUED To : * ISSUED Day : OCTOBER 4,2007 * VERSION : 2.05 * Init.Version : Initialization 2.04 * FILE DESCRIPTION: S5H1411 VSB/QAM Porting Code * ABBREVIATION : Update Sec_1411xInitialize Driver * Copyright (c) 2006~2007 Samsung Electronics, Inc. * All rights reserved. * * This software is the confidential and proprietary information * of Samsung Electronics, Inc("Confidential Information"). You * Shall not disclose such Confidential Information and shall use * it only in accordance with the terms of the license agreement * you entered into SAMSUNG. **************************************************************EFILE*/ #include "DHL_OSAL.h" #include "DHL_DEV_Priv.h" #include #include "S5H1411.h" /******************************************************************** MACRO CONSTANT DEFINITIONS ********************************************************************/ #define OK 0 #define IIC_1411x_TOP_RegId 0x72 #define IIC_1411x_QAM_RegId 0x74 /******************************************************************** MACRO FUNCTION DEFINITIONS ********************************************************************/ /******************************************************************** TYPE DEFINITION ********************************************************************/ /******************************************************************** EXTERN VARIABLES & FUNCTION PROTOTYPES DECLARATIONS ********************************************************************/ /******************************************************************** GLOBAL VARIABLES DEFINITIONS & FUNCTION PROTOTYPE DECLARATIONS ********************************************************************/ /******************************************************************** STATIC VARIABLES DEFINITIONS & FUNCTION PROTOTYPE DECLARATIONS ********************************************************************/ static int pChargePumpValue; static int VSB_Mode; DATA32 Sec_1411xGetMode(void); ///////////////// ///////////////// /////////////////// ///////////////// I2C Engine////////// //////////////// ///////////////// ///////////////// /////////////////// /* ************************************************************************ */ /* */ /* This function should be implemented by customers */ /* */ /* ************************************************************************ */ #if 1 /* void I2cStop() { return 1; } void I2cStart() { return 1; } */ I2C_STATUS WritetoTuner(I2C_STATUS nb_bytes_to_send, DATA08 *bytes_to_send) { return 1; } I2C_STATUS I2cWriteOneRegister(int Id, int Address , int Data) { DHL_RESULT dhr = DHL_OK; //SSdtReturn_t nRet = SSDT_ERR_NO; DATA16 chip_addr = Id; DATA08 sub_addr = Address; DATA08 data[2]; data[0]=(Data>>8) & 0xff; data[1]=Data & 0xff; dhr = dhl_i2c_write2(0,chip_addr,sub_addr,data,2); if(dhr != DHL_OK) { DHL_OS_Printf("|%s| fail to write demod(chip_addr:0x%x).\n", __FUNCTION__, Id); return 1; } else { return 0; } } I2C_STATUS I2cReadOneRegister(int Id, int Address) { DHL_RESULT dhr = DHL_OK; I2C_STATUS chip_addr = Id; DATA08 sub_addr = Address; DATA08 dummy[2]={0}; dhr = dhl_i2c_read2(0,chip_addr,sub_addr,dummy,2); if(dhr != DHL_OK) { DHL_OS_Printf("|%s| fail to read demod(chip_addr:0x%x).\n", __FUNCTION__, Id); } return (I2C_STATUS)(((unsigned int)dummy[0] << 8) | dummy[1]); } #endif /* *************************************************************** */ /* */ /* CODE PROVIDED BY Channel Team */ /* */ /* *************************************************************** */ ///////////////// ///////////////// /////////////////// ///////////////// SEMCO Tuner Function //////////////// ///////////////// ///////////////// /////////////////// /************************************************************************************************************************** * RF TUNING FUNCTION * Tuning Formula : calcFreq = ((chFreq + 44) / 50) * 1000; * calcFreq is the LO(local oscillator) setting vaule to convert the RF signal to IF signal. * Regardless of analogue signals and digital signals, the LO setting value is the same. For example, * For DTV Tuning, RF Freq. = 57MHz, IF Center. Freq=44MHz, calcFreq = ((57+44)/50)*1000= 2020. * For NTSC Tuning, RF Freq(Picture Freq.) = 55.25MHz, IF Picture Freq.=45.75MHz,calcFreq= * ((55.25+45.75)/50*1000 = 2020. Accordingly, DTV and analogue channels can be tuned with the * same scheme. **************************************************************************************************************************/ DATA32 SEMCOxTune(double chFreq) { int j; DATA_DOUBLE calcFreq; I2C_STATUS calcBuff; I2C_STATUS tunerData[6]; I2C_STATUS pChargePumpValue; /////////////////////////////////////////////////////////////////////////////////////////////// //// Making Charge Pump Current //// To optimize the phase noise performance, the "pChargePumpValue" needs to be set //// differently according to a channel frequency /////////////////////////////////////////////////////////////////////////////////////////////// if ((chFreq>36.0) && (chFreq<=170.0)) { if ((chFreq>48.0) && (chFreq<=100.0)) pChargePumpValue = 2; else if ((chFreq>100.0) && (chFreq<=112.0)) pChargePumpValue = 3; else if ((chFreq>112.0) && (chFreq<=132.0)) pChargePumpValue = 4; else if ((chFreq>132.0) && (chFreq<=140.0)) pChargePumpValue = 5; else if ((chFreq>140.0) && (chFreq<=170.0)) pChargePumpValue = 6; pChargePumpValue = (pChargePumpValue << 5) | 0x01; } else if ((chFreq>170.0) && (chFreq<=469.0)) { if ((chFreq>169.0) && (chFreq<=180.0)) pChargePumpValue = 1; else if ((chFreq>180.0) && (chFreq<=252.0)) pChargePumpValue = 2; else if ((chFreq>252.0) && (chFreq<=360.0)) pChargePumpValue = 3; else if ((chFreq>360.0) && (chFreq<=404.0)) pChargePumpValue = 4; else if ((chFreq>404.0) && (chFreq<=428.0)) pChargePumpValue = 5; else if ((chFreq>428.0) && (chFreq<=440.0)) pChargePumpValue = 6; else if ((chFreq>440.0) && (chFreq<=469.0)) pChargePumpValue = 7; pChargePumpValue = (pChargePumpValue << 5) | 0x02; } else if ((chFreq>469.0) && (chFreq<=864.0)) { if ((chFreq>469.0) && (chFreq<=560.0)) pChargePumpValue = 3; else if ((chFreq>560.0) && (chFreq<=632.0)) pChargePumpValue = 4; else if ((chFreq>632.0) && (chFreq<=708.0)) pChargePumpValue = 5; else if ((chFreq>708.0) && (chFreq<=824.0)) pChargePumpValue = 6; else if ((chFreq>824.0) && (chFreq<=864.0)) pChargePumpValue = 7; pChargePumpValue = (pChargePumpValue << 5) | 0x08; } else { pChargePumpValue = 1; } //////////////////////////////////////////////////////////////////////////////////////////// ////// Making chFreq. to Tune ////// //////////////////////////////////////////////////////////////////////////////////////////// calcFreq = ((chFreq + 44) / 50) * 1000; calcBuff = (int)calcFreq; tunerData[0] = 0xc2 ; //Semco Tuner ID tunerData[1] = (calcBuff >> 8) & 0x00FF; tunerData[2] = (calcBuff) & 0x00FF; tunerData[3] = 0xc3; tunerData[4] = pChargePumpValue; if(!Sec_1411xGetMode()) //VSB mode { tunerData[5] = 0x81; } else //QAM mode { tunerData[5] = 0x82; } for( j=0; j<6; j++) { WritetoTuner(6,tunerData); //physical channel tune } } /********************************************************************************************************* * S5H1411 Initialization Driver * Conditions: * Version:Init_Air 2.04 * Description: * This function is called to initialize the register values. * This function must be called once to run the system properly. * After this function is called, the VSB mode is set as a default. **********************************************************************************************************/ I2C_STATUS Sec_1411xInitialize(void) { I2C_STATUS result = OK; result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00 , 0x0071); //result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x08 , 0x0047); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x08 , 0x15); //default -> ATSC test // result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x38 , 0xe614); // result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x39 , 0x1d72); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1C , 0x0400); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1E , 0x0370); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1F , 0x342c); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x24 , 0x0231); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x25 , 0x1011); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x26 , 0x0f07); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x27 , 0x0F04); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x28 , 0x070f); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x29 , 0x2820); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2A , 0x102e); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2B , 0x0220); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2E , 0x0d0e); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2F , 0x1013); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x31 , 0x171b); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x32 , 0x0e0f); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x33 , 0x0f10); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x34 , 0x170e); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x35 , 0x4b10); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x36 , 0x0f17); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3C , 0x1577); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3D , 0x081A); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3E , 0x77ee); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x40 , 0x1e09); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x41 , 0x0f0c); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x42 , 0x1f10); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x4D , 0x0509); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x4E , 0x0a00); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x50 , 0x0000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x5B , 0x0000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x5C , 0x0008); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x57 , 0x1101); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x65 , 0x007c); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x68 , 0x0512); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x69 , 0x0258); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x70 , 0x0004); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x71 , 0x0007); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x76 , 0x00a9); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x78 , 0x3141); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x7A , 0x3141); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB3 , 0x8003); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB5 , 0xa6bb); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB6 , 0x0609); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB7 , 0x2f06); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB8 , 0x003f); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB9 , 0x2700); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBA , 0xfac8); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBE , 0x1003); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBF , 0x103F); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xCE , 0x2000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xCF , 0x0800); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD0 , 0x0800); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD1 , 0x0400); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD2 , 0x0800); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD3 , 0x2000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD4 , 0x3000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDB , 0x4a9b); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDC , 0x1000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDE , 0x0001); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDF , 0x0000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xE3 , 0x0301); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0xF3 , 0x0000); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0xF3 , 0x0001); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x08 , 0x0600); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x18 , 0x4201); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x1E , 0x6476); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x21 , 0x0830); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x0C , 0x5679); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x0D , 0x579b); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x24 , 0x0102); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x31 , 0x7488); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x32 , 0x0a08); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x3D , 0x8689); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x41 , 0x0f98); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x49 , 0x0048); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x57 , 0x2012); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x5D , 0x7676); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x04 , 0x0400); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x58 , 0x00c0); result |=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x5B , 0x0100); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xF7 , 0x0000); result |=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xF7 , 0x0001); return result; } /********************************************************************************************************* * S5H1411 Soft reset Driver * Conditions: When a channel is changed or LNA is on/off, this function is called. * Description: * This function is called in order to reset all software conditions. * But it does not reset register values. * Addr: 0xf7 * Value: 0x00 -> Chip Reset Start * Value: 0x01 -> Chip Reset End **********************************************************************************************************/ I2C_STATUS Sec_1411xSoftReset(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf7, 0x0000); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf7, 0x0001); return result; } /********************************************************************************************************* * S5H1411 Register Value reset Driver * Conditions: This function is called when the system needs initialization. * Description: * A register value is reset following this call. * The system needs to call initialization function to be run properly after this function is called. * Addr: 0xf3 * Value: * Following this call, a register value of the 0xf3 is changed from '0x01' to '0x00'. * After that the value is back to '0x01' automatically. **********************************************************************************************************/ I2C_STATUS Sec_1411xRegReset(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf3, 0x0000); return result; } /********************************************************************************************************* * S5H1411 Repeater Control Driver * Conditions: * Description: * This function is used to set the bypass mode or normal mode. (Repeater Enable or Disable) * In the bypass mode, the host PC controls a channel chip first and the channel chip controls * a tuner using GPIO. * Addr: 0xf5 * Value: 0x00 -> Tuner by pass close (Repeater Disable) ? Default mode * Value: 0x01 -> Tuner by pass open (Repeater Enable) **********************************************************************************************************/ I2C_STATUS Sec_1411xRepeaterEnable(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf5, 0x0001); return result; } I2C_STATUS Sec_1411xRepeaterDisable(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf5, 0x0000); return result; } /********************************************************************************************************* * S5H1411 VSB, QAM mode change Driver * Conditions: * Description: These functions set an 8-VSB & QAM (64/256) mode * Addr: 0xf6 * Value: 0x00 -> VSB mode (Default) * Value: 0x01 -> QAM mode * Addr: 0x16 * Value: 0x1101 -> QAM (Detect 64/256 qam automatically) * Value: 0x1100 -> QAM (Detect 64/256 qam manually) * Addr: 0x17 * Value: 0x0101 -> 64 QAM (Manual mode) * Value: 0x0111 -> 256 QAM (Manual mode) **********************************************************************************************************/ I2C_STATUS Sec_1411xVsbMode(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0071); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0000); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f1); Sec_1411xSoftReset(); return result; } I2C_STATUS Sec_1411xQamMode(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001); result |= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1101); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0); Sec_1411xSoftReset(); return result; } I2C_STATUS Sec_1411x64QamMode(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001); result |= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1100); result |= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x17, 0x0101); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0); Sec_1411xSoftReset(); return result; } I2C_STATUS Sec_1411x256QamMode(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001); result |= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1100); result |= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x17, 0x0111); result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0); Sec_1411xSoftReset(); return result; } /********************************************************************************************************* * S5H1411 Get Mode Driver * Conditions: * Description: This function get a mode(VSB/QAM) of S5H1411. * Addr: 0xf6 * Value: 0x00 -> VSB mode (Default) * Value: 0x01 -> QAM mode **********************************************************************************************************/ DATA32 Sec_1411xGetMode(void) { DATA32 mode; mode = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xf6); return mode; } /********************************************************************************************************* * S5H1411 Get QAM Mode Driver * Conditions: * Description: This function get a QAM mode(64/256). * Addr: 0xf0 * Value: 0x01 -> 256QAM mode * Value: 0x00 -> 64QAM mode **********************************************************************************************************/ DATA32 Sec_1411xGetQAMMode(void) { DATA32 qam_mode; qam_mode = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xf0) & 0x0001; return qam_mode; } /**************************************************************************************************** * S5H1411 Sleep mode change Driver * Conditions: * Description: * The software-based power down function is as follows. * This function is called in order to set a sleep on mode or sleep off mode. * Addr: 0xf4 * Value: 0x01 -> Sleep mode * Value: 0x00 -> Running mode ? Default mode ****************************************************************************************************/ I2C_STATUS Sec_1411xSleepOn(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf4,0x01); return result; } I2C_STATUS Sec_1411xSleepOff(void) { DATA32 result = OK; result |= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf4,0x00); Sec_1411xSoftReset(); return result; } /**************************************************************************************************** * S5H1411 VSB Sync Lock Check Driver * Conditions: VSB mode * Description: This function is used to check whether the sync detector is lock or not in VSB mode. * Addr: 0x5e * Value: [0] bit -> 1:Lock , 0: Unlock ****************************************************************************************************/ DATA32 Sec_1411xSyncLock(void) { DATA32 sync_lock; sync_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0x5e)) & 0x0001; return sync_lock; } /**************************************************************************************************** * S5H1411 VSB Equalizer Lock Check Driver * Conditions: VSB mode * Description: This function is used to check whether the equalizer is lock or not in VSB mode. * Addr: 0xf2 * Value: [13] bit -> 1:Lock , 0: Unlock ****************************************************************************************************/ DATA32 Sec_1411xVsbEqLock(void) { DATA32 eq_lock; eq_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2) >> 13) & 0x0001; return eq_lock; } /**************************************************************************************************** * S5H1411 VSB Fec Lock Check Driver * Conditions: VSB mode * Description: This function is used to check whether the FEC is lock or not in VSB mode. * Addr: 0xf2 * Value: [12] bit -> 1:Lock , 0: Unlock ****************************************************************************************************/ DATA32 Sec_1411xVSBFecLock(void) { DATA32 fec_lock; fec_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2) >> 12) & 0x0001; return fec_lock; } /**************************************************************************************************** * S5H1411 QAM Fec Lock Check Driver * Conditions: QAM mode * Description: This function is used to check whether the FEC is lock or not in QAM mode. * Addr: 0xf0 * Value: [4] bit -> 1:Lock , 0: Unlock ****************************************************************************************************/ DATA32 Sec_1411xQAMFec_Lock(void) { DATA32 fec_lock; fec_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf0) >> 4) & 0x0001; return fec_lock; } /**************************************************************************************************** * S5H1411 QAM Equalizer Lock Check Driver * Conditions: QAM mode * Description: This function is used to check whether the FEC is lock or not in QAM mode. * Addr: 0xf0 * Value: [8] bit -> 1:Lock , 0: Unlock ****************************************************************************************************/ DATA32 Sec_1411xQAMEq_Lock(void) { DATA32 eq_lock; eq_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf0) >> 8) & 0x0001; return eq_lock; } /**************************************************************************************************** * S5H1411 VSB/QAM Master Lock Check Driver * Conditions: VSB/QAM mode * Description: This function is used to check whether the channel chip is lock or not in VSB/QAM mode. * Addr: 0xf2 * Value: 15bit -> 1:Lock , 0: Unlock ****************************************************************************************************/ DATA32 Sec_1411xVsbQAM_Master_Lock(void) { DATA32 master_lock; master_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2)>>15) & 0x0001; //0x1 --> Master lock, 0x0 --> Master Unlock return master_lock; } /************************************************************************** * S5H1411 VSB SNR value(Signal Quality) Check Driver * Conditions: * Description : * This function lets the user's application software read a value * that is related to the SNR through the SNR Look Up Table in VSB mode. * Addr : 0xf2 * Value: [9:0] /**************************************************************************/ DATA_DOUBLE SnrLookUpTable(int SnrRead) { DATA_DOUBLE SnrLookUP; if (SnrRead > 0x39f )SnrLookUP = 30 ; else if(SnrRead > 0x39b) SnrLookUP = 29.5 ; else if(SnrRead > 0x397) SnrLookUP = 29 ; else if(SnrRead > 0x394) SnrLookUP = 28.5 ; else if(SnrRead > 0x38f) SnrLookUP = 28.0 ; else if(SnrRead > 0x38b) SnrLookUP = 27.5 ; else if(SnrRead > 0x387) SnrLookUP = 27.0 ; else if(SnrRead > 0x382) SnrLookUP = 26.5 ; else if(SnrRead > 0x37d) SnrLookUP = 26.0 ; else if(SnrRead > 0x377) SnrLookUP = 25.5 ; else if(SnrRead > 0x370) SnrLookUP = 25.0 ; else if(SnrRead > 0x36a) SnrLookUP = 24.5 ; else if(SnrRead > 0x364) SnrLookUP = 24.0 ; else if(SnrRead > 0x35b) SnrLookUP = 23.5 ; else if(SnrRead > 0x353) SnrLookUP = 23.0 ; else if(SnrRead > 0x349) SnrLookUP = 22.5 ; else if(SnrRead > 0x340) SnrLookUP = 22.0 ; else if(SnrRead > 0x337) SnrLookUP = 21.5 ; else if(SnrRead > 0x327) SnrLookUP = 21.0 ; else if(SnrRead > 0x31b) SnrLookUP = 20.5 ; else if(SnrRead > 0x310) SnrLookUP = 20.0 ; else if(SnrRead > 0x302) SnrLookUP = 19.5 ; else if(SnrRead > 0x2f3) SnrLookUP = 19.0 ; else if(SnrRead > 0x2e4) SnrLookUP = 18.5 ; else if(SnrRead > 0x2d7) SnrLookUP = 18.0 ; else if(SnrRead > 0x2cd) SnrLookUP = 17.5 ; else if(SnrRead > 0x2bb) SnrLookUP = 17.0 ; else if(SnrRead > 0x2a9) SnrLookUP = 16.5 ; else if(SnrRead > 0x29e) SnrLookUP = 16.0 ; else if(SnrRead > 0x284) SnrLookUP = 15.5 ; else if(SnrRead > 0x27a) SnrLookUP = 15.0 ; else if(SnrRead > 0x260) SnrLookUP = 14.5 ; else if(SnrRead > 0x23a) SnrLookUP = 14.0 ; else if(SnrRead > 0x224) SnrLookUP = 13.5 ; else if(SnrRead > 0x213) SnrLookUP = 13.0 ; else if(SnrRead > 0x204) SnrLookUP = 12.5 ; else if(SnrRead > 0x1fe) SnrLookUP = 12.0 ; else SnrLookUP = 0 ; return SnrLookUP; } DATA_DOUBLE Sec_1411xVsbSnrResultCheck(void) { DATA32 value; DATA_DOUBLE SnrValue; value = I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2); value = (value & 0x3ff); SnrValue = SnrLookUpTable(value); return SnrValue; } /********************************************************************************************************* * S5H1411 VSB Pre BER Count Check Driver * Conditions: * Description: * Error count value before TCM decoder * This function is used to check pre BER count. * Addr: 0xca * Value: [15:0] **********************************************************************************************************/ DATA_DOUBLE Sec_1411xPreBer(void) { DATA_DOUBLE pre_ber; pre_ber = (I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xca)) / 65534; return pre_ber; } /********************************************************************************************************* * S5H1411 VSB Post BER Count Check Driver * Conditions: * Description: * Error count value after TCM decoder * This function is used to check post BER count. * Addr: 0xcb * Value: [15:0] **********************************************************************************************************/ DATA_DOUBLE Sec_1411xPostBer(void) { DATA_DOUBLE post_ber; post_ber = (I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xcb)) / 65536; return post_ber; } /********************************************************************************************************* * S5H1411 VSB Packet Error Check Driver * Conditions: * Description: * Error count value after RS decoder * This function is used to count the packet error. * Addr: 0xc9 * Value: [15:0] **********************************************************************************************************/ DATA32 S5H1411x_UncorrectableError(void) { DATA32 unc_err; unc_err = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xc9); return unc_err; } /******************************************************************************************************************************* * S5H1411 TS Mode Set * Conditions: * Description:Through changing this register,it can control the MPEG data mode as parall or serial mode * Addr: 0xbd * Value: [8]:1 ? MPEG data are sent out as a byte. * Value: [8]:0 ? MPEG data are sent out bit by bit serially. *******************************************************************************************************************************/ DATA32 TS_Serial_Set() { DATA32 result; result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbd,0x1101); return (result); } DATA32 TS_Parallel_Set() { DATA32 result; result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbd,0x1001); return (result); } /******************************************************************************************************************************* * S5H1411 MPEG Output Timing Mode Set * Conditions: * Description:Through changing this register,it can control the MPEG timing mode.Refer to the datasheet document. * Addr: 0xbe * Value: [13:12]:00 - continous and inverting clk. * Value: [13:12]:01 - continous and non-inverting clk. * Value: [13:12]:10 - non-continous and inverting clk. * Value: [13:12]:11 - non-continous and non-inverting clk. *******************************************************************************************************************************/ DATA32 Cont_Invert_Set() { DATA32 result; result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x0003); return (result); } DATA32 Cont_Non_Invert_Set() { DATA32 result; result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x1003); return (result); } DATA32 Non_Cont_Invert_Set() { DATA32 result; result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x2003); return (result); } DATA32 Non_Cont_Non_Invert_Set() { DATA32 result; result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x3003); return (result); } /********************************************************************************************************* * S5H1411 QAM SNR value(Signal Strength) Check Driver * Conditions: * Description * This function lets the user's application software read a value that is related to the SNR through * the SNR Look Up Table in QAM mode. * Addr : 0xf1 * Value: [15:0] **********************************************************************************************************/ DATA_DOUBLE Qam64SnrLookUpTable(int SnrRead) { DATA_DOUBLE SnrLookUP; if (SnrRead< 0xaf0 ) SnrLookUP = 30 ; else if(SnrRead < 0xd80 ) SnrLookUP = 29 ; else if(SnrRead < 0x10a0 ) SnrLookUP = 28 ; else if(SnrRead < 0x14b5 ) SnrLookUP = 27 ; else if(SnrRead < 0x1590 ) SnrLookUP = 26.8 ; else if(SnrRead < 0x1680 ) SnrLookUP = 26.6 ; else if(SnrRead < 0x17b0 ) SnrLookUP = 26.4 ; else if(SnrRead < 0x18c0 ) SnrLookUP = 26.2 ; else if(SnrRead < 0x19b0 ) SnrLookUP = 26 ; else if(SnrRead < 0x1ad0 ) SnrLookUP = 25.8 ; else if(SnrRead < 0x1d00 ) SnrLookUP = 25.6 ; else if(SnrRead < 0x1da0 ) SnrLookUP = 25.4 ; else if(SnrRead < 0x1ef0 ) SnrLookUP = 25.2 ; else if(SnrRead < 0x2050 ) SnrLookUP = 25 ; else if(SnrRead < 0x20f0 ) SnrLookUP = 24.9 ; else if(SnrRead < 0x21d0 ) SnrLookUP = 24.8 ; else if(SnrRead < 0x22b0 ) SnrLookUP = 24.7 ; else if(SnrRead < 0x23a0 ) SnrLookUP = 24.6 ; else if(SnrRead < 0x2470 ) SnrLookUP = 24.5 ; else if(SnrRead < 0x24f0 ) SnrLookUP = 24.4 ; else if(SnrRead < 0x25a0 ) SnrLookUP = 24.3 ; else if(SnrRead < 0x26c0 ) SnrLookUP = 24.2 ; else if(SnrRead < 0x27b0 ) SnrLookUP = 24.1 ; else if(SnrRead < 0x28d0 ) SnrLookUP = 24 ; else if(SnrRead < 0x29b0 ) SnrLookUP = 23.9 ; else if(SnrRead < 0x2ad0 ) SnrLookUP = 23.8 ; else if(SnrRead < 0x2ba0 ) SnrLookUP = 23.7 ; else if(SnrRead < 0x2c80 ) SnrLookUP = 23.6 ; else if(SnrRead < 0x2d20 ) SnrLookUP = 23.5 ; else if(SnrRead < 0x2e00 ) SnrLookUP = 23.4 ; else if(SnrRead < 0x2f10 ) SnrLookUP = 23.3 ; else if(SnrRead < 0x3050 ) SnrLookUP = 23.2 ; else if(SnrRead < 0x3190 ) SnrLookUP = 23.1 ; else if(SnrRead < 0x3300 ) SnrLookUP = 23 ; else if(SnrRead < 0x3340 ) SnrLookUP = 22.9 ; else if(SnrRead < 0x3200 ) SnrLookUP = 22.8 ; else if(SnrRead < 0x3550 ) SnrLookUP = 22.7 ; else if(SnrRead < 0x3610 ) SnrLookUP = 22.6 ; else if(SnrRead < 0x3600 ) SnrLookUP = 22.5 ; else if(SnrRead < 0x3700 ) SnrLookUP = 22.4 ; else if(SnrRead < 0x3800 ) SnrLookUP = 22.3 ; else if(SnrRead < 0x3920 ) SnrLookUP = 22.2 ; else if(SnrRead < 0x3a20 ) SnrLookUP = 22.1 ; else if(SnrRead < 0x3b30 ) SnrLookUP = 22 ; else if(SnrRead < 0x3d00 ) SnrLookUP = 21.9 ; else if(SnrRead < 0x3e00 ) SnrLookUP = 21.8 ; else if(SnrRead < 0x4000 ) SnrLookUP = 21.7 ; else if(SnrRead < 0x4100 ) SnrLookUP = 21.6 ; else if(SnrRead < 0x4300 ) SnrLookUP = 21.5 ; else if(SnrRead < 0x4400 ) SnrLookUP = 21.4 ; else if(SnrRead < 0x4600 ) SnrLookUP = 21.3 ; else if(SnrRead < 0x4700 ) SnrLookUP = 21.2 ; else if(SnrRead < 0x4800 ) SnrLookUP = 21.1 ; else if(SnrRead < 0x4a00 ) SnrLookUP = 21 ; else if(SnrRead < 0x4b00 ) SnrLookUP = 20.9 ; else if(SnrRead < 0x4d00 ) SnrLookUP = 20.8 ; else if(SnrRead < 0x4f00 ) SnrLookUP = 20.7 ; else if(SnrRead < 0x5050 ) SnrLookUP = 20.6 ; else if(SnrRead < 0x5200 ) SnrLookUP = 20.5 ; else if(SnrRead < 0x53c0 ) SnrLookUP = 20.4 ; else if(SnrRead < 0x5450 ) SnrLookUP = 20.3 ; else if(SnrRead < 0x5650 ) SnrLookUP = 20.2 ; else if(SnrRead < 0x5820 ) SnrLookUP = 20.1 ; else if(SnrRead < 0x6000 ) SnrLookUP = 20 ; else SnrLookUP = 0; return SnrLookUP; } DATA_DOUBLE Qam256SnrLookUpTable(int SnrRead) { DATA_DOUBLE SnrLookUP; if (SnrRead < 0x970 ) SnrLookUP = 40 ; else if(SnrRead < 0xa90 ) SnrLookUP = 39 ; else if(SnrRead < 0xb90 ) SnrLookUP = 38 ; else if(SnrRead < 0xd90 ) SnrLookUP = 37 ; else if(SnrRead < 0xff0 ) SnrLookUP = 36 ; else if(SnrRead < 0x1240) SnrLookUP = 35 ; else if(SnrRead < 0x1345) SnrLookUP = 34.8 ; else if(SnrRead < 0x13c0) SnrLookUP = 34.6 ; else if(SnrRead < 0x14c0) SnrLookUP = 34.4 ; else if(SnrRead < 0x1500) SnrLookUP = 34.2 ; else if(SnrRead < 0x1610) SnrLookUP = 34 ; else if(SnrRead < 0x1700) SnrLookUP = 33.8 ; else if(SnrRead < 0x1800) SnrLookUP = 33.6 ; else if(SnrRead < 0x18b0) SnrLookUP = 33.4 ; else if(SnrRead < 0x1900) SnrLookUP = 33.2 ; else if(SnrRead < 0x1ab0) SnrLookUP = 33 ; else if(SnrRead < 0x1bc0) SnrLookUP = 32.8 ; else if(SnrRead < 0x1cb0) SnrLookUP = 32.6 ; else if(SnrRead < 0x1db0) SnrLookUP = 32.4 ; else if(SnrRead < 0x1eb0) SnrLookUP = 32.2 ; else if(SnrRead < 0x2030) SnrLookUP = 32 ; else if(SnrRead < 0x2200) SnrLookUP = 31.8 ; else if(SnrRead < 0x2280) SnrLookUP = 31.6 ; else if(SnrRead < 0x2410) SnrLookUP = 31.4 ; else if(SnrRead < 0x25b0) SnrLookUP = 31.2 ; else if(SnrRead < 0x27a0) SnrLookUP = 31 ; else if(SnrRead < 0x2840) SnrLookUP = 30.8 ; else if(SnrRead < 0x29d0) SnrLookUP = 30.6 ; else if(SnrRead < 0x2b10) SnrLookUP = 30.4 ; else if(SnrRead < 0x2d30) SnrLookUP = 30.2 ; else if(SnrRead < 0x2f20) SnrLookUP = 30 ; else if(SnrRead < 0x30c0) SnrLookUP = 29.8 ; else if(SnrRead < 0x3260) SnrLookUP = 29.7 ; else if(SnrRead < 0x32c0) SnrLookUP = 29.6 ; else if(SnrRead < 0x3300) SnrLookUP = 29.5 ; else if(SnrRead < 0x33b0) SnrLookUP = 29.4 ; else if(SnrRead < 0x34b0) SnrLookUP = 29.3 ; else if(SnrRead < 0x35a0) SnrLookUP = 29.2 ; else if(SnrRead < 0x3650) SnrLookUP = 29.1 ; else if(SnrRead < 0x3800) SnrLookUP = 29 ; else if(SnrRead < 0x3900) SnrLookUP = 28.9 ; else if(SnrRead < 0x3a50) SnrLookUP = 28.8 ; else if(SnrRead < 0x3b30) SnrLookUP = 28.7 ; else if(SnrRead < 0x3cb0) SnrLookUP = 28.6 ; else if(SnrRead < 0x3e20) SnrLookUP = 28.5 ; else if(SnrRead < 0x3fa0) SnrLookUP = 28.4 ; else if(SnrRead < 0x40a0) SnrLookUP = 28.3 ; else if(SnrRead < 0x41c0) SnrLookUP = 28.2 ; else if(SnrRead < 0x42f0) SnrLookUP = 28.1 ; else if(SnrRead < 0x44a0) SnrLookUP = 28 ; else if(SnrRead < 0x4600) SnrLookUP = 27.9 ; else if(SnrRead < 0x47b0) SnrLookUP = 27.8 ; else if(SnrRead < 0x4900) SnrLookUP = 27.7 ; else if(SnrRead < 0x4a00) SnrLookUP = 27.6 ; else if(SnrRead < 0x4ba0) SnrLookUP = 27.5 ; else if(SnrRead < 0x4d00) SnrLookUP = 27.4 ; else if(SnrRead < 0x4f00) SnrLookUP = 27.3 ; else if(SnrRead < 0x5000) SnrLookUP = 27.2 ; else if(SnrRead < 0x51f0) SnrLookUP = 27.1 ; else if(SnrRead < 0x53a0) SnrLookUP = 27 ; else if(SnrRead < 0x5520) SnrLookUP = 26.9 ; else if(SnrRead < 0x5700) SnrLookUP = 26.8 ; else if(SnrRead < 0x5800) SnrLookUP = 26.7 ; else if(SnrRead < 0x5a00) SnrLookUP = 26.6 ; else if(SnrRead < 0x5c00) SnrLookUP = 26.5 ; else if(SnrRead < 0x5d00) SnrLookUP = 26.4 ; else if(SnrRead < 0x5f00) SnrLookUP = 26.3 ; else if(SnrRead < 0x6000) SnrLookUP = 26.2 ; else if(SnrRead < 0x6200) SnrLookUP = 26.1 ; else if(SnrRead < 0x6400) SnrLookUP = 26 ; else SnrLookUP = 0; return SnrLookUP; } DATA_DOUBLE Sec_1411xQamSnrResultCheck(void) { DATA32 mse; DATA32 qam_mode; DATA_DOUBLE SnrValue=0; qam_mode = Sec_1411xGetQAMMode(); mse = I2cReadOneRegister(IIC_1411x_TOP_RegId , 0x00f1); switch(qam_mode){ case 0: SnrValue = Qam64SnrLookUpTable(mse); break; case 1: SnrValue = Qam256SnrLookUpTable(mse); break; } return SnrValue; } /******************************************************************************************************************************* * S5H1411 Get Auto Frequency OffSet Driver * Conditions:VSB mode * Description:This function get a auto-frequency control offset * Addr: 0x47,0x48 *******************************************************************************************************************************/ DATA_DOUBLE Sec_1411xAutoFreqOffset(void){ DATA32 afc_loop; DATA_DOUBLE constant; DATA_DOUBLE result_afc; DATA32 sign_afc; afc_loop = ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x47)<<16 ) | ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x48) ); sign_afc = (unsigned int)afc_loop>>23; constant = (double)21.52*(double)pow(10,3); if(sign_afc) { result_afc = -((afc_loop^0xffffff)+1)*(double)pow(2,-27)*constant; } else { result_afc = (afc_loop)*(double)pow(2,-27)*constant; } return result_afc; } /******************************************************************************************************************************* * S5H1411 Get Carrier Frequency OffSet Driver * Conditions:VSB mode * Description:This function get a fine carrier recovery offset. * Addr: 0x49,0x4a *******************************************************************************************************************************/ DATA_DOUBLE Sec_1411xCRFreqOffset(void){ DATA32 cr_loop; DATA_DOUBLE result_cr,constant; DATA32 sign_cr; cr_loop =( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x49)<<16 ) | ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4a)); sign_cr = (unsigned int)cr_loop>>23; constant = (double)21.52*(double)pow(10,3); if(sign_cr) { result_cr = -( ( (cr_loop)^0xffffff)+1)*(double)pow(2,-27)*constant; } else { result_cr = (cr_loop)*(double)pow(2,-27)*constant; } return result_cr; } /******************************************************************************************************************************* * S5H1411 Get Symbol Timing OffSet Driver * Conditions:VSB mode * Description:This function get a timing offset. * Addr: 0x4b,0x4c *******************************************************************************************************************************/ DATA_DOUBLE Sec_1411xVSBSTROffset(void){ DATA32 str_loop; DATA_DOUBLE result_str,constant; DATA32 sign_str; str_loop = ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4b)<<16 ) | ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4c)); sign_str = (unsigned int)str_loop>>23; constant = (double)21.52*(double)pow(10,6)/(double)24.69; if(sign_str) { result_str = -((str_loop^0xffffff)+1)*(double)pow(2,-29)*constant; } else { result_str = (str_loop)*(double)pow(2,-29)*constant; } return result_str; } /******************************************************************************************************************************* * S5H1411 Get PTL Frequency OffSet Driver * Conditions:QAM mode * Description:This function get a auto-frequency control offset * Addr: 0x61,0x62 *******************************************************************************************************************************/ DATA_DOUBLE Sec_1411xPTLFreqOffset(void){ DATA32 ptl_offset1,ptl_offset2; DATA_DOUBLE ptl_KHz; DATA_DOUBLE sym_rate; DATA_DOUBLE ad_rate = 24690000.0; if( Sec_1411xGetQAMMode()) sym_rate = 5360537.0; else sym_rate = 5056941.0; ptl_offset1 = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x61); ptl_offset2 = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x62); if(ptl_offset1>>15) ptl_offset1 = -1*((ptl_offset1^0xffff) + 1); else ptl_offset1 = ptl_offset1; if(ptl_offset2>>15) ptl_offset2 = -1*((ptl_offset2^0xffff) + 1); else ptl_offset2 = ptl_offset2; ptl_KHz = ((double)ptl_offset1*sym_rate + (double)ptl_offset2*ad_rate)/((double)0x8000)*0.001; return ptl_KHz; } /******************************************************************************************************************************* * S5H1411 Get Symbol Timing OffSet Driver * Conditions:QAM mode * Description:This function get a timing offset. * Addr: 0x3a *******************************************************************************************************************************/ DATA_DOUBLE Sec_1411xQAMSTROffset(void){ DATA32 str; DATA_DOUBLE str_ppm; DATA_DOUBLE ad_rate = 24690000.0; DATA_DOUBLE sym_rate; if( Sec_1411xGetQAMMode()) sym_rate = 5360537.0; else sym_rate = 5056941.0; str = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x3a); if(str>>15) str = -1*((str^0xffff) + 1); else str = str; str_ppm = 2.0*sym_rate*((double)str/(double)0x80000)/ad_rate*1000000.0; return str_ppm; } /******************************************************************************************************************************* * S5H1411 VSB playback stream driver * Conditions: Should be set only in VSB mode * Description: When the a74 captured stream is playing back continuously, this driver * improve the performance in VSB mode. This function should be called periodically. * Addr: 0x65 * Value: [0]:1 --> Calculated SNR from PN sequence. * Value: [0]:0 --> SNR *******************************************************************************************************************************/ I2C_STATUS PlayBack_StreamDriver() { #define EQ_SNR_THR 500 int Eq_tcm_snr = 0; int Eq_snr_tr_est = 0; int Eq_threshold; Eq_tcm_snr = I2cReadOneRegister(0x32, 0x9e)&0x3ff; //eq_tcm_snr. Eq_snr_tr_est = I2cReadOneRegister(0x32, 0x9f)&0x3ff; //EQ snr estimation during training sequence Eq_threshold=Eq_tcm_snr-Eq_snr_tr_est; if( !Sec_1411xGetMode() ) // VSB mode { if( Sec_1411xVsbEqLock()) // EQ lock { if(Eq_threshold>EQ_SNR_THR) { I2cWriteOneRegister(0x32, 0x65, 0x7d); return OK; } else { I2cWriteOneRegister(0x32, 0x65, 0x7c); return OK; } } //if Eq lock else{ I2cWriteOneRegister(0x32, 0x65, 0x7c); return OK; } } //if VSB else{ return OK; } } void set_demods(DATA16 chip_addr,DATA16 addr, DATA08 data) { I2cWriteOneRegister(chip_addr,addr, data); DHL_OS_Printf("0x%x = 0x%x\n", addr, data); } void get_demods(DATA16 chip_addr,DATA16 addr) { DATA16 data; data = I2cReadOneRegister(chip_addr,addr); DHL_OS_Printf("0x%x = 0x%x\n", addr, data); }