/* * $Id: Cas2BRoutines.c,v 1.1 2011/07/08 03:43:59 megakiss Exp $ * $Revision: 1.1 $ * $DateTime: 2005/08/24 19:03:17 $ * $Change: 28028 $ * $Author: megakiss $ */ //#include #include "dsthalcommon.h" #include "dsthalcfg.h" #include "Cas2BRoutines.h" #include "IicComm.h" #include "SnrCalcTable.h" #include "TunerDTT7611.h" #include "TdquTuner.h"//ZhongYang #include "TunerDTT7612.h" #include "DTT7600Tuner.h" #include "TD6650TTuner.h" //kiki #include "TunerFQD1236.h" #include "ThomsonT2000Tuner.h" #include "Cas2BGeneralDefinitions.h" //kiki #include "XC3028.h" #include "VP13HRTuner.h" #include "Cas2BInitBuffers.h" #include "TunerFQD1236.h" extern UINT32 gdhlExtDbgLvl; #if (NIMTN_TYPE==NIMTN_DTT7611) #define SUPPORT_TUNER_DTT7611 1 #define SUPPORT_TUNER_TDQU 0 #elif (NIMTN_TYPE==NIMTN_TDQU) #define SUPPORT_TUNER_DTT7611 0 #define SUPPORT_TUNER_TDQU 1 #else #error You shall define NIMTN_TYPE. #endif #if 0 #define SUPPORT_TUNER_DTT7611 1 #define SUPPORT_TUNER_SN761662 0 #define SUPPORT_TUNER_DTT7612 0 #define SUPPORT_TUNER_THOMSON_T_2000 0 #define SUPPORT_TUNER_PHILIPS_TD6650T 0 #define SUPPORT_TUNER_XCEIVE_XC3028 0 #define SUPPORT_TUNER_DTT760x 0 #define SUPPORT_TUNER_MT2121 0 #define SUPPORT_TUNER_TDQU 0 #endif #if NIMTN_TYPE==NIMTN_DTT7611 extern int DTT7611_DTV_AGC, DTT7611_NTSC_AGC; extern CAS_2B_TYPE_RECEIVER_MODE g_Ntsc_Mode; #endif #if NIMTN_TYPE==NIMTN_FQD1236 int SetTunerFQD1236(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet, CHANNEL_TABLE_TYPE iChannelTable,TYPE_TUNERFQD1236_REF_DIVIDER_RATIO iRefDividerRatio , TYPE_TUNERFQD1236_AGC iAgc,TYPE_TUNER_AGC_MODE iAgcMode, CHARGE_PUMP iChargePump, TYPE_TUNERFQD1236_AGC_TIME_CONSTANT iAgcTimeConstant ); #endif unsigned int __stdcall SetChannel(CAS_2B_TUNER_PARAMETERS stTunerParameters,unsigned short usDelay,CAS_2B_CHANNEL_CHANGE_PARAMETERS* pstChannelChangeParameters) { ERROR_TYPE iError; if (0) { ; /* Just to make the following #if's work correctly */ } #if NIMTN_TYPE==NIMTN_DTT7611 #if SUPPORT_TUNER_DTT7611 else if(TUNER_DTT7611 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerDTT7611(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, TUNERDTT7611_REF_DIVIDER_RATIO_62_5,/*default value*/ pstChannelChangeParameters->iReceiverMode == g_Ntsc_Mode ? /*TUNERDTT7612_AGC_96*/(TYPE_TUNERDTT7612_AGC)DTT7611_NTSC_AGC : (TYPE_TUNERDTT7612_AGC)DTT7611_DTV_AGC, stTunerParameters.iAgcMode, (CHARGE_PUMP)TUNERDTT7611_CHARGE_PUMP_60,/*default value*/ TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC);/*default value*/ if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif//#if NIMTN_TYPE==NIMTN_DTT7611 #if NIMTN_TYPE==NIMTN_DTT7612 #if SUPPORT_TUNER_DTT7612 else if(TUNER_DTT7612 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerDTT7612(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, TUNERDTT7612_REF_DIVIDER_RATIO_62_5,/*default value*/ TUNERDTT7611_AGC_93,/*default value*/ stTunerParameters.iAgcMode, (CHARGE_PUMP)TUNERDTT7612_CHARGE_PUMP_60,/*default value*/ TUNERDTT7612_AGC_TIME_CONSTANT_2_SEC);/*default value*/ if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif//#if NIMTN_TYPE==NIMTN_DTT7612 #if NIMTN_TYPE==NIMTN_T2000 #if SUPPORT_TUNER_THOMSON_T_2000 else if(TUNER_THOMSON_T_2000 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerThomsonT2000(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue, TUNER_THOMSON_T2000_INTERNAL_AGC, (TYPE_TUNER_THOMSON_T2000_INPUT_SELECTION)stTunerParameters.iInputSelection, THOMSON_T2000_REF_DIVIDER_RATIO_62_5, (TYPE_TUNER_THOMSON_T2000_MODE)stTunerParameters.iAgcMode ); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif//#if NIMTN_TYPE==NIMTN_T2000 #if NIMTN_TYPE==NIMTN_TD6650T #if SUPPORT_TUNER_PHILIPS_TD6650T else if(TUNER_PHILIPS_TD6650T == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerTD6650T(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, TD6650T_REF_DIVIDER_RATIO_62_5 , TD6650T_AGC_TOP_124, TD6650T_ATC_2_SEC); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif//#if NIMTN_TYPE==NIMTN_TD6650T #if NIMTN_TYPE==NIMTN_XC3028 #if SUPPORT_TUNER_XCEIVE_XC3028 else if(TUNER_XCEIVE_XC3028 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerXC3028(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue,stTunerParameters.bLoadFirmware,stTunerParameters.iFirmwareMode); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif//#if NIMTN_TYPE==NIMTN_XC3028 #if SUPPORT_TUNER_DTT760x else if(TUNER_DTT760x == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerDTT760xATSC(stTunerParameters.iTunerSet, &(stTunerParameters.ulSetValue), stTunerParameters.iChannelTableType, TUNERDTT760xATSC_REF_DIVIDER_RATIO_62_5,/*default value*/ TUNERDTT760xATSC_AGC_94,/*default value*/ stTunerParameters.iAgcMode, TUNERDTT760xATSC_CHARGE_PUMP_60,/*default value*/ TUNERDTT760xATSC_AGC_TIME_CONSTANT_2_SEC); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #if NIMTN_TYPE==NIMTN_MT2121 #if SUPPORT_TUNER_MT2121 else if(TUNER_MT2121 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerMT2121(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, TUNER_MT2121_REF_DIVIDER_RATIO_62_5); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif//#if NIMTN_TYPE==NIMTN_MT2121 #if NIMTN_TYPE==NIMTN_TDQU #if SUPPORT_TUNER_TDQU else if(TUNER_TDQU == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerTdqu(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, TUNER_TDQU_REF_DIVIDER_RATIO_62_5,TUNER_TDQU_CHARGE_PUMP_70,TUNER_TDQU_AGST_0); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif #if NIMTN_TYPE==NIMTN_FQD1236 #if SUPPORT_TUNER_SN761662 else if(TUNER_SN761662 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerSN761662(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, SN761662TUNER_REF_DIVIDER_RATIO_50, SN761662TUNER_ATC_900NS, SN761662TUNER_CP_350, TYPE_SN761662TUNER_IFOSW_IFOUT1_DISABLE_IFOUT2_ENABLE, EN_TYPE_SN761662TUNER_AGC_TOP_LEVEL_0_111_LEVEL_1_106, TYPE_SN761662TUNER_RFAGC_SHIFT_XTALOUT_CONTROL_IFOUT_1_OUTPUT_DISABLE); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif #endif #if SUPPORT_TUNER_VP13HR else if(TUNER_VP13HR == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerVP13HR(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, TUNER_VP13HR_REF_DIVIDER_RATIO_62_5, stTunerParameters.bIsFMTrapOn, stTunerParameters.bIsAFTReq); if(CAS_2B_API_SUCCESS != iError) return iError; } #endif else{ DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"SetChannel: Unsupported tuner type"); return CAS_2B_UNDEFINED_TUNER_TYPE; } //if the pstChannelChangeParameters argument is NULL it means that we send only //the tuner PLL frequency if(NULL == pstChannelChangeParameters) return CAS_2B_API_SUCCESS; OS_mDelay( usDelay ); //send the cascade2B DSP channel change return Cas2BChannelChange(*pstChannelChangeParameters); } unsigned int __stdcall Cas2BChannelChange(CAS_2B_CHANNEL_CHANGE_PARAMETERS stChannelChangeParameters ) { unsigned int uiSendByte = 0,uiRes; unsigned char ucSend[3]; if((stChannelChangeParameters.iReceiverMode < CAS_2B_RECEIVER_MODE_VSB_8_TR) || (stChannelChangeParameters.iReceiverMode > CAS_2B_RECEIVER_MODE_POWER_DOWN)) return UNDEFINED_RECEIVER_MODE; uiSendByte = 0x8000;//bit 15 always On if((stChannelChangeParameters.iReceiverMode >= CAS_2B_RECEIVER_MODE_VSB_8_TR)&& (stChannelChangeParameters.iReceiverMode <= CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT)){ //SeT Channel Change data if((stChannelChangeParameters.iCarrierAcquisition != CARRIER_ACQUISITION_NORMAL) && (stChannelChangeParameters.iCarrierAcquisition != CARRIER_ACQUISITION_WIDE)) return UNDEFINED_CARRIER_ACQUISITION_TYPE; if(CARRIER_ACQUISITION_WIDE == stChannelChangeParameters.iCarrierAcquisition) uiSendByte |= 0x200; if((stChannelChangeParameters.iNtscSignalDetection != NORMAL_VSB) && (stChannelChangeParameters.iNtscSignalDetection != NTSC_SIGNAL_DETECTION)) return UNDEFINED_NTSC_SIGNAL_DETECTION; if(NTSC_SIGNAL_DETECTION == stChannelChangeParameters.iNtscSignalDetection) uiSendByte |= 0x400; } if(CAS_2B_RECEIVER_MODE_VSB_8_TR == stChannelChangeParameters.iReceiverMode){ if((stChannelChangeParameters.iInverseSpectrum != INVERSE_SPECTRUM_ON) && (stChannelChangeParameters.iInverseSpectrum != INVERSE_SPECTRUM_OFF)) return UNDEFINED_INVERSE_SPECTRUM_TYPE; if(INVERSE_SPECTRUM_ON == stChannelChangeParameters.iInverseSpectrum ) uiSendByte |= 0x100; } //set the 8 lsb bits switch(stChannelChangeParameters.iReceiverMode){ case CAS_2B_RECEIVER_MODE_VSB_8_TR: uiSendByte |= VSB_8_TR_MODE_NUMBER; break; case CAS_2B_RECEIVER_MODE_ITUB_64: uiSendByte |= ITUB_QAM_64_MODE_NUMBER; break; case CAS_2B_RECEIVER_MODE_ITUB_256: uiSendByte |= ITUB_QAM_256_MODE_NUMBER; break; case CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT: uiSendByte |= 0x2f; break; case CAS_2B_RECEIVER_MODE_AUDIO_US_BTSC: uiSendByte |= 0x30; break; case CAS_2B_RECEIVER_MODE_AUDIO_A2_KOREA: uiSendByte |= 0x31; break; case CAS_2B_RECEIVER_MODE_AUDIO_RADIO_FM: uiSendByte |= 0x32; break; case CAS_2B_RECEIVER_MODE_POWER_DOWN: uiSendByte |= 0xff; break; }//end of switch block he 8 lsb bits ucSend[1] = (char)(uiSendByte>> 8); ucSend[2] = (char)(uiSendByte); uiRes = SendToAddress(2, ucSend, 2); if (IIC_COM_SUCCESS != uiRes ) return uiRes; return CAS_2B_API_SUCCESS; } LOCK_STATUS __stdcall IsLocked(int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue( 0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return UNDEFINED_LOCK_STATUS; } *piError = (int) CAS_2B_API_SUCCESS; //now musk bit 8 to get the lock status if((0x100 & usReceivedWord) == 0x100) return LOCKED; else return UNLOCKED; } LOCK_STATUS __stdcall IsFECLocked(int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue( 0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return UNDEFINED_LOCK_STATUS; } *piError = (int) CAS_2B_API_SUCCESS; //now musk bit 9 to get the lock status if((0x200 & usReceivedWord) == 0x200) return LOCKED; else return UNLOCKED; } BOOLEAN __stdcall IsNtscChannelDetected(int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue( 0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return FALSE; } *piError = (int) CAS_2B_API_SUCCESS; //now musk bit 14 to get the NTSC lock status if((0x4000 & usReceivedWord) == 0x4000) return TRUE; else return FALSE; } unsigned char __stdcall GetMode(int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue( 0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } *piError = (int) CAS_2B_API_SUCCESS; //now musk bit 8 to get the mode return (0xff & usReceivedWord); } CAS_2B_TYPE_RECEIVER_MODE GetReceiveMode(int *piError) { unsigned char ucReceiverMode; ucReceiverMode = GetMode(piError); if (ucReceiverMode == 0x06 ) { //OS_DbgPrintf("CAS_2B_RECEIVER_MODE_VSB_8_TR \n"); return CAS_2B_RECEIVER_MODE_VSB_8_TR; } else if (ucReceiverMode == 0x23){ //OS_DbgPrintf("CAS_2B_RECEIVER_MODE_ITUB_64 \n"); return CAS_2B_RECEIVER_MODE_ITUB_64; } else if (ucReceiverMode == 0x25){ //OS_DbgPrintf("CAS_2B_RECEIVER_MODE_ITUB_256 \n"); return CAS_2B_RECEIVER_MODE_ITUB_256; } else{ //OS_DbgPrintf("CAS_2B_RECEIVER_MODE_VSB_8_TR(0x%x)\n",(int)ucReceiverMode); return CAS_2B_RECEIVER_MODE_ITUB_256;//default } } unsigned char __stdcall GetRfInverseSpectrum(int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue( 0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } //now musk bit 15 to get the rf Inverse spectrum status if(0x8000 & usReceivedWord) return 1; else return 0; } NUMERATOR_DENOMINATOR __stdcall GetSymbolRateFrequencyOffset(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError) { unsigned short usReceivedWord = 0; short sReceivedWord; NUMERATOR_DENOMINATOR stResult; stResult.Denominator.ulDenominator = 1; stResult.Numerator.ulNumerator = 0; // // Auto Detect이면, Receiver Mode를 직접 얻음. // if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) { iReceiverMode=GetReceiveMode(piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } } usReceivedWord = ReceiveTransmitRegisterValue( 3,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } if(usReceivedWord > 0x7fff) sReceivedWord = usReceivedWord - 0x10000; else sReceivedWord = usReceivedWord; if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode){// x/32767 stResult.Denominator.lDenominator = 10000; stResult.Numerator.lNumerator = (sReceivedWord* 8211); } else if(CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode){ stResult.Denominator.lDenominator = 100000; stResult.Numerator.lNumerator = 77167* sReceivedWord;// 10^6 * x *4096 } else if(CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode){ stResult.Denominator.lDenominator = 100000; stResult.Numerator.lNumerator = 81794* sReceivedWord; } else{ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } *piError = CAS_2B_API_SUCCESS; return stResult; } TYPE_ITUB_DE_INTERLEAVER_MODE __stdcall GetDiMode(int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue( 0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return((TYPE_ITUB_DE_INTERLEAVER_MODE)0); } usReceivedWord = (usReceivedWord & 0x3c00) >> 10; switch(usReceivedWord){ case 0: case 1: return ITUB_DE_INTERLEAVER_MODE_128_1; // break; case 2: return ITUB_DE_INTERLEAVER_MODE_128_2; // break; case 3: return ITUB_DE_INTERLEAVER_MODE_64_2; // break; case 4: return ITUB_DE_INTERLEAVER_MODE_128_2; // break; case 5: return ITUB_DE_INTERLEAVER_MODE_32_4; // break; case 6: return ITUB_DE_INTERLEAVER_MODE_128_4; // break; case 7: return ITUB_DE_INTERLEAVER_MODE_16_8; // break; case 9: return ITUB_DE_INTERLEAVER_MODE_8_16; // break; default: *piError = UNDEFINED_ITUB_DE_INTERLEAVER_MODE; return((TYPE_ITUB_DE_INTERLEAVER_MODE)0); } } unsigned short __stdcall GetSnrAfterEqualization(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError) { unsigned short usReceivedWord = 0; unsigned short usK=0; int iLogResult,iSNRResult; // // Auto Detect이면, Receiver Mode를 직접 얻음. // if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) { iReceiverMode=GetReceiveMode(piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } } if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode){ //calculate the K value //get transmit register 0 usReceivedWord = ReceiveTransmitRegisterValue(0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } //mask for bit 12 that holds the NTSC rejection filter Status if((0x1000 & usReceivedWord) == 0x1000) //0n usK = 3; else // off usK = 0; } //get the snr value usReceivedWord = ReceiveTransmitRegisterValue(2,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } //mask the received data 15 lsb bits if(0 == usReceivedWord){ *piError = (int) RECEIVED_ZERO_SNR_VALUE_FROM_THE_CASCADE; return 0; } iLogResult = CalcLog(usReceivedWord); if((CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)){ iSNRResult = VSB_ADD_TO_LOG - iLogResult - usK; } else if(CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode) iSNRResult = ITUB_QAM_64_ADD_TO_LOG - iLogResult; else if(CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode) iSNRResult = ITUB_QAM_256_ADD_TO_LOG - iLogResult; else{ *piError = SNR_IS_CALCULATED_ONLY_FOR_VSB_AND_ITUB; return 0; } return iSNRResult; } NUMERATOR_DENOMINATOR __stdcall GetPer(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError) { // unsigned short usReceivedWord = 0; NUMERATOR_DENOMINATOR stResult; int iBerFailedTransmitRegiterNumber; stResult.Denominator.ulDenominator = 1; stResult.Numerator.ulNumerator = 0; if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode) iBerFailedTransmitRegiterNumber = 13; else if((CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode) || (CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode)|| (CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT == iReceiverMode)) iBerFailedTransmitRegiterNumber = 11; else{ *piError = UNDEFINED_RECEIVER_MODE; return stResult; } stResult.Numerator.usNumerator = ReceiveTransmitRegisterValue(iBerFailedTransmitRegiterNumber,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } stResult.Denominator.usDenominator = ReceiveTransmitRegisterValue(14,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } *piError = CAS_2B_API_SUCCESS; return stResult; } NUMERATOR_DENOMINATOR __stdcall GetBer(int * piError) { unsigned short usBERCorrected,usBERFailed,usBERLimit; NUMERATOR_DENOMINATOR stResult; stResult.Denominator.ulDenominator = 1; stResult.Numerator.ulNumerator = 0; usBERCorrected = ReceiveTransmitRegisterValue(13,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } usBERFailed = ReceiveTransmitRegisterValue(11,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } usBERLimit = ReceiveTransmitRegisterValue(14,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } *piError = CAS_2B_API_SUCCESS; stResult.Numerator.ulNumerator = usBERCorrected + 4*7*usBERFailed; stResult.Denominator.ulDenominator = 7*122 * usBERLimit; return stResult; } unsigned char Get1SecSer(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(1,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } return (unsigned char)(usReceivedWord & 0xff); } unsigned char Get10SecSer(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(1,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } return (unsigned char)((usReceivedWord & 0xff00) >> 8); } unsigned int __stdcall GetEqualizerFeedForwardTaps(unsigned short* pusaReceivedFfTaps) { if(NULL == pusaReceivedFfTaps) return FUNCTION_RECEIVED_NULL_PARAMETER; return ReceiveVector(2,pusaReceivedFfTaps,96); } unsigned int __stdcall GetEqualizerFeedBackTaps(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,unsigned short* pusaReceivedFbTaps) { unsigned short usVectorLength; if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode) usVectorLength = 384; else if((CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode) || (CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode)|| (CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT == iReceiverMode)) usVectorLength = 96; else{ return UNDEFINED_RECEIVER_MODE; } if(NULL == pusaReceivedFbTaps) return FUNCTION_RECEIVED_NULL_PARAMETER; return ReceiveVector(3,pusaReceivedFbTaps,usVectorLength); } unsigned int __stdcall GetConstellationSamples(unsigned short usNumberOfConstellationSamples,unsigned short* pusaConstellationSamples) { if(NULL == pusaConstellationSamples) return FUNCTION_RECEIVED_NULL_PARAMETER; if(0 == usNumberOfConstellationSamples) return CAS_2B_API_SUCCESS; if(usNumberOfConstellationSamples > 4096) usNumberOfConstellationSamples = 4096; return ReceiveVector(5,pusaConstellationSamples,usNumberOfConstellationSamples); } unsigned int __stdcall SendVsbMessage(TYPE_VSB_CHANNEL_CONDITION iVsbChannelCondition,TYPE_VSB_NTSC_REJECTION_FILTER iVsbNtscRegectionFilter,TYPE_MPEG_OUTPUT_MODE iMpegOutputMode,TYPE_TUNER_PHASE_NOISE iTunerPhaseNoise) { unsigned char ucaSendData[3]; unsigned short usSendData = 0; if(VSB_CHANNEL_CONDITION_STATIC == iVsbChannelCondition) usSendData = 1; else if(VSB_CHANNEL_CONDITION_DYNAMIC == iVsbChannelCondition) usSendData = 2; else if(VSB_CHANNEL_CONDITION_FAST_DYNAMIC == iVsbChannelCondition) usSendData = 3; else if(VSB_CHANNEL_CONDITION_AUTO != iVsbChannelCondition) return UNDEFINED_CHANNEL_CONDITION; if(VSB_NTSC_REJECTION_FILTER_OFF == iVsbNtscRegectionFilter) usSendData |= 0x4; else if(VSB_NTSC_REJECTION_FILTER_ON == iVsbNtscRegectionFilter) usSendData |= 0xc; else if(VSB_NTSC_REJECTION_FILTER_AUTO != iVsbNtscRegectionFilter) return UNDEFINED_NTSC_REJECTION_FILTER; if(MPEG_OUTPUT_MODE_CONTROLED_BY_PRM_PINS == iMpegOutputMode) usSendData |= 0x00; else if(MPEG_OUTPUT_MODE_PARALLEL == iMpegOutputMode) usSendData |= 0x20; else if(MPEG_OUTPUT_MODE_SERIAL == iMpegOutputMode) usSendData |= 0x60; else return UNDEFINED_MPEG_SERIAL_OUTPUT_MODE; if(TUNER_PHASE_NOISE_HIGH == iTunerPhaseNoise) usSendData |= 0x40; else if(TUNER_PHASE_NOISE_NORMAL != iTunerPhaseNoise) return UNDEFINED_TUNER_PHASE_NOISE; ucaSendData[1] = (unsigned char)(usSendData >> 8); ucaSendData[2] = (unsigned char)usSendData; return SendToReceive(1, ucaSendData, 2); } unsigned int __stdcall SendItubMessage(TYPE_ITUB_DE_INTERLEAVER_MODE iItubDeInterlieverMode,TYPE_MPEG_OUTPUT_MODE iMpegOutputMode,TYPE_TUNER_PHASE_NOISE iTunerPhaseNoise) { unsigned char ucaSendData[3]; unsigned short usSendData = 0; if(ITUB_DE_INTERLEAVER_MODE_AUTOMATIC == iItubDeInterlieverMode) usSendData = 0xf; else if(ITUB_DE_INTERLEAVER_MODE_128_1 == iItubDeInterlieverMode) usSendData = 0x1; else if(ITUB_DE_INTERLEAVER_MODE_128_2 == iItubDeInterlieverMode) usSendData = 0x2; else if(ITUB_DE_INTERLEAVER_MODE_64_2 == iItubDeInterlieverMode) usSendData = 0x3; else if(ITUB_DE_INTERLEAVER_MODE_128_3 == iItubDeInterlieverMode) usSendData = 0x4; else if(ITUB_DE_INTERLEAVER_MODE_32_4 == iItubDeInterlieverMode) usSendData = 0x5; else if(ITUB_DE_INTERLEAVER_MODE_128_4 == iItubDeInterlieverMode) usSendData = 0x6; else if(ITUB_DE_INTERLEAVER_MODE_16_8 == iItubDeInterlieverMode) usSendData = 0x7; else if(ITUB_DE_INTERLEAVER_MODE_8_16 == iItubDeInterlieverMode) usSendData = 0x9; else return UNDEFINED_ITUB_DE_INTERLEAVER_MODE; if(MPEG_OUTPUT_MODE_CONTROLED_BY_PRM_PINS == iMpegOutputMode) usSendData |= 0x00; else if(MPEG_OUTPUT_MODE_PARALLEL == iMpegOutputMode) usSendData |= 0x20; else if(MPEG_OUTPUT_MODE_SERIAL == iMpegOutputMode) usSendData |= 0x60; else return UNDEFINED_MPEG_SERIAL_OUTPUT_MODE; if(TUNER_PHASE_NOISE_HIGH == iTunerPhaseNoise) usSendData |= 0x40; else if(TUNER_PHASE_NOISE_NORMAL != iTunerPhaseNoise) return UNDEFINED_TUNER_PHASE_NOISE; ucaSendData[1] = (unsigned char)(usSendData >> 8); ucaSendData[2] = (unsigned char)usSendData; return SendToReceive(1, ucaSendData, 2); } NUMERATOR_DENOMINATOR __stdcall GetAgcIfCommand(int * piError) { unsigned short usReceivedWord = 0; NUMERATOR_DENOMINATOR stResult; stResult.Numerator.lNumerator = 0; stResult.Denominator.lDenominator = 32768; //receive the AGC IF Command value from transmit register 5 usReceivedWord = ReceiveTransmitRegisterValue(5,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } if(usReceivedWord > 0x7fff) stResult.Numerator.lNumerator = usReceivedWord - 0x10000; else stResult.Numerator.lNumerator = usReceivedWord ; return stResult; } NUMERATOR_DENOMINATOR __stdcall GetAGCSensor(int * piError) { NUMERATOR_DENOMINATOR stResult; unsigned short usReceivedWord = 0; stResult.Numerator.lNumerator = 0; stResult.Denominator.lDenominator = 32768; usReceivedWord = ReceiveTransmitRegisterValue(6,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } if(usReceivedWord > 0x7fff) stResult.Numerator.lNumerator = usReceivedWord - 0x10000; else stResult.Numerator.lNumerator = usReceivedWord ; return stResult; } CAS_2B_CODE_VERSION __stdcall GetDSPFirmwareVersion(int * piError) { CAS_2B_CODE_VERSION stCodeVersion; *piError = ReceiveVector(1,stCodeVersion.usaVector,6); return stCodeVersion; } unsigned char __stdcall GetHardwareVersion(int * piError) { if(0 != SendHostControl(0xc0,0x0)){ *piError = SEND_HOST_CONTROL_FUNCTION_FAILED; return 0; } return ReceiveByteOfData((unsigned int *)piError); } long __stdcall GetCarrierOffset(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError) { unsigned short usReceivedWord = 0; long lTmp=0; short sReceivedData; //read the transmit 4 register value usReceivedWord = ReceiveTransmitRegisterValue(4,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } if(usReceivedWord > 0x7fff) sReceivedData = usReceivedWord - 0x10000; else sReceivedData = usReceivedWord; // // Auto Detect이면, Receiver Mode를 직접 얻음. // if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) { iReceiverMode=GetReceiveMode(piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } } if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode) lTmp = sReceivedData * VSB_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*VSB_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/VSB_CARRIER_OFFSET_FLOATING_POINT_DIVIDER; else if(CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode) lTmp = sReceivedData * ITUB_QAM_64_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*ITUB_QAM_64_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/ITUB_QAM_64_CARRIER_FLOATING_POINT_DIVIDER; else if(CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode) lTmp = sReceivedData * ITUB_QAM_256_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*ITUB_QAM_256_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/ITUB_QAM_256_CARRIER_FLOATING_POINT_DIVIDER; //now round the number to Khz if(lTmp > 0) lTmp = ((lTmp + 555)*1000)/1000; else lTmp = ((lTmp - 555)*1000)/1000; return (lTmp/1000); } long __stdcall GetNtscCarrierOffset(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError) { unsigned short usReceivedWord = 0; long lTmp = 0; short sReceivedData; int iTransmitIndex = 0; if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)//for backward compatibility - it works only for VSB iTransmitIndex = 12; //read the transmit 12 register value usReceivedWord = ReceiveTransmitRegisterValue(iTransmitIndex,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } if(usReceivedWord > 0x7fff) sReceivedData = usReceivedWord - 0x10000; else sReceivedData = usReceivedWord; if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)//for backward compatibility - it works only for VSB lTmp = sReceivedData * VSB_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*VSB_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/VSB_CARRIER_OFFSET_FLOATING_POINT_DIVIDER; //now round the number to Khz if(lTmp > 0) lTmp = ((lTmp + 555)*1000)/1000; else lTmp = ((lTmp - 555)*1000)/1000; return (lTmp/1000); } CHECKSUM_STATUS __stdcall GetChecksumFlag(int *piError) { unsigned char ucCheckumResult = 0; if(0 != SendHostControl(0xb0,0x0)){ *piError = SEND_HOST_CONTROL_FUNCTION_FAILED; return ((CHECKSUM_STATUS)0); } ucCheckumResult = ReceiveByteOfData((unsigned int *)piError); if(ucCheckumResult) return CHECKSUM_STATUS_CORRECT; else return CHECKSUM_STATUS_INCORRECT; } unsigned short __stdcall GetStatusReg(int *piError) { unsigned short statReg = 0; if(0 != SendHostControl(0xD0,0x0)){ *piError = SEND_HOST_CONTROL_FUNCTION_FAILED; return ((CHECKSUM_STATUS)0); } statReg = ReceiveWordOfData((unsigned int *)piError); return statReg; } unsigned short __stdcall GetChecksum(int *piError) { unsigned short statReg = 0; if(0 != SendHostControl(0xA0,0x0)){ *piError = SEND_HOST_CONTROL_FUNCTION_FAILED; return ((CHECKSUM_STATUS)0); } statReg = ReceiveWordOfData((unsigned int *)piError); return statReg; } unsigned int __stdcall ResetChecksum() { // unsigned char ucCheckumResult = 0; //reset the checksum register if(0 != SendHostControl(0x81,0x0)) return SEND_HOST_CONTROL_FUNCTION_FAILED; //set checksum meckanism to normal opration return SendHostControl(0x80,0x0); } #if SUPPORT_TUNER_DTT760x int SetTunerDTT760xATSC(TYPE_TUNERDTT760xATSC_SET_OPTION TunerSet, void* pvTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TUNERDTT760xATSC_REF_DIVIDER_RATIO iRefDividerRatio, TYPE_TUNERDTT760xATSC_AGC iAgc, BOOLEAN bUseExternalAgc , TYPE_TUNERDTT760xATSC_CHARGE_PUMP iChargePump, TYPE_TUNERDTT760xATSC_AGC_TIME_CONSTANT iAgcTimeConstant ) { unsigned int uiAgc,uiChargePump,uiAgcTimeConstant; int iRes; if((TUNERDTT760xATSC_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) && (TUNERDTT760xATSC_REF_DIVIDER_RATIO_50 != iRefDividerRatio)&& (TUNERDTT760xATSC_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) && (TUNERDTT760xATSC_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio)) return CASCADE_UNDEFINED_TUNER_DTT760xATSC_REF_DIVIDER_RATIO_TYPE; if(TUNERDTT760xATSC_AGC_91 == iAgc) uiAgc = 91; else if(TUNERDTT760xATSC_AGC_94 == iAgc) uiAgc = 94; else if(TUNERDTT760xATSC_AGC_97 == iAgc) uiAgc = 97; else if(TUNERDTT760xATSC_AGC_100 == iAgc) uiAgc = 100; else if(TUNERDTT760xATSC_AGC_103 == iAgc) uiAgc = 103; else if(TUNERDTT760xATSC_AGC_106 == iAgc) uiAgc = 106; else return CASCADE_UNDEFINED_TUNER_DTT760xATSC_AGC_TYPE; if(TUNERDTT760xATSC_CHARGE_PUMP_60 == iChargePump) uiChargePump = 60; else if(TUNERDTT760xATSC_CHARGE_PUMP_280 == iChargePump) uiChargePump = 280; else return CASCADE_UNDEFINED_TUNER_DTT760xATSC_CHRGE_PUMP_TYPE; if(TUNERDTT760xATSC_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant) uiAgcTimeConstant = 50; else if(TUNERDTT760xATSC_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant) uiAgcTimeConstant = 2; else return CASCADE_UNDEFINED_TUNER_DTT760xATSC_AGC_TIME_CONSTANT_TYPE; if( TUNERDTT760xATSC_SET_CHANNEL == TunerSet) iRes = TunerDTT760xATSCSendChannel(*((unsigned long*)pvTunerSet), iChannelTable,iRefDividerRatio,uiAgc, bUseExternalAgc,uiChargePump, uiAgcTimeConstant); else if( TUNERDTT760xATSC_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerDTT760xATSCSendFreq(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, bUseExternalAgc,uiChargePump, uiAgcTimeConstant); else if( TUNERDTT760xATSC_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerDTT760xATSCSendPicCarrier(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, bUseExternalAgc,uiChargePump, uiAgcTimeConstant); else return CASCADE_UNDEFINED_TUNER_DTT760xATSC_SET_OPTION_TYPE; switch(iRes){ case TUNER_DTT760xATSC_SUCCESS: return CAS_2B_API_SUCCESS; case TUNER_DTT760xATSC_CHANNEL_OUT_OF_RANGE: return CASCADE_TUNER_DTT760xATSC_CHANNEL_OUT_OF_RANGE; case TUNER_DTT760xATSC_N_VALU_OUT_OF_RANGE: return CASCADE_TUNER_DTT760xATSC_N_VALUE_OUT_OF_RANGE; case TUNER_DTT760xATSC_SEND_CONTROL_DATA_FAILED: case TUNER_DTT760xATSC_BEFORE_SEND_BYTES_FAILED: case TUNER_DTT760xATSC_AFTER_SEND_BYTES_FAILED: return CASCADE_TUNER_DTT760xATSC_SEND_CONTROL_DATA_FAILED; case TUNER_DTT760xATSC_FREQUENCY_VALUE_OUT_OF_RANGE: return CASCADE_TUNER_DTT760xATSC_FREQUENCY_VALUE_OUT_OF_RANGE; case TUNER_DTT760xATSC_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CASCADE_TUNER_DTT760xATSC_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY; default: return CASCADE_TUNER_DTT760xATSC_GENERAL_FAILIUR; } } #endif /* SUPPORT_TUNER_DTT760x */ #if NIMTN_TYPE==NIMTN_DTT7611 #if SUPPORT_TUNER_DTT7611 int __stdcall SetTunerDTT7611(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TUNERDTT7611_REF_DIVIDER_RATIO iRefDividerRatio , TYPE_TUNERDTT7611_AGC iAgc, TYPE_TUNER_AGC_MODE iAgcMode, CHARGE_PUMP iChargePump, TYPE_TUNERDTT7611_AGC_TIME_CONSTANT iAgcTimeConstant ) { unsigned int uiAgc,uiChargePump,uiAgcTimeConstant,uiAgcMode; int iRes; if((TUNERDTT7611_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) && (TUNERDTT7611_REF_DIVIDER_RATIO_50 != iRefDividerRatio) && (TUNERDTT7611_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) && (TUNERDTT7611_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio)) return CAS_2B_UNDEFINED_TUNER_DTT761X_REF_DIVIDER_RATIO_TYPE; if(TUNERDTT7611_AGC_102_A == iAgc) uiAgc = 0; else if(TUNERDTT7611_AGC_102_B == iAgc) uiAgc = 1; else if(TUNERDTT7611_AGC_99 == iAgc) uiAgc = 2; else if(TUNERDTT7611_AGC_96 == iAgc) uiAgc = 3; else if(TUNERDTT7611_AGC_93 == iAgc) uiAgc = 4; else if(TUNERDTT7611_AGC_90 == iAgc) uiAgc = 5; else if(TUNERDTT7611_AGC_WIDE_BAND_OFF == iAgc) uiAgc = 6; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TYPE; if(TUNERDTT7611_CHARGE_PUMP_60 == iChargePump) uiChargePump = 60; else if(TUNERDTT7611_CHARGE_PUMP_280 == iChargePump) uiChargePump = 280; else return CAS_2B_UNDEFINED_TUNER_DTT761X_CHRGE_PUMP_TYPE; if(TUNERDTT7611_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant) uiAgcTimeConstant = 50; else if(TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant) uiAgcTimeConstant = 2; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TIME_CONSTANT_TYPE; if(TUNER_AGC_MODE_INTERNAL_DIGITAL == iAgcMode ) uiAgcMode = 1; else if(TUNER_AGC_MODE_INTERNAL_ANALOG == iAgcMode) uiAgcMode = 2; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_MODE_TYPE; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerDTT7611SendChannel(*((unsigned long*)pvTunerSet),iChannelTable,iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerDTT7611SendFreq(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerDTT7611SendPicCarrier(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else return CAS_2B_UNDEFINED_TUNER_DTT761X_SET_OPTION_TYPE; switch(iRes){ case DTT7611_SUCCESS: return CAS_2B_API_SUCCESS; case DTT7611_CHANNEL_OUT_OF_RANGE: return CAS_2B_TUNER_DTT761X_CHANNEL_OUT_OF_RANGE; case DTT7611_COULD_NOT_SET_N: return CAS_2B_TUNER_DTT761X_N_VALUE_OUT_OF_RANGE; case DTT7611_SEND_CONTROL_DATA_FAILED: case DTT7611_BEFORE_SEND_BYTES_FAILED: case DTT7611_AFTER_SEND_BYTES_FAILED: return CAS_2B_TUNER_DTT761X_SEND_CONTROL_DATA_FAILED; case DTT7611_FREQUENCY_VALUE_OUT_OF_RANGE: return CAS_2B_TUNER_DTT761X_FREQUENCY_VALUE_OUT_OF_RANGE; case DTT7611_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_DTT761X_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY; default: return CAS_2B_TUNER_DTT761X_GENERAL_FAILIUR; } } #endif /* SUPPORT_TUNER_DTT7611 */ #endif #if NIMTN_TYPE==NIMTN_DTT7612 #if SUPPORT_TUNER_DTT7612 int __stdcall SetTunerDTT7612(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TUNERDTT7612_REF_DIVIDER_RATIO iRefDividerRatio , TYPE_TUNERDTT7612_AGC iAgc, TYPE_TUNER_AGC_MODE iAgcMode, CHARGE_PUMP iChargePump, TYPE_TUNERDTT7612_AGC_TIME_CONSTANT iAgcTimeConstant ) { unsigned int uiAgc,uiChargePump,uiAgcTimeConstant,uiAgcMode; int iRes; if((TUNERDTT7612_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) && (TUNERDTT7612_REF_DIVIDER_RATIO_50 != iRefDividerRatio) && (TUNERDTT7612_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) && (TUNERDTT7612_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio)) return CAS_2B_UNDEFINED_TUNER_DTT761X_REF_DIVIDER_RATIO_TYPE; if(TUNERDTT7612_AGC_102_A == iAgc) uiAgc = 0; else if(TUNERDTT7612_AGC_102_B == iAgc) uiAgc = 1; else if(TUNERDTT7612_AGC_99 == iAgc) uiAgc = 2; else if(TUNERDTT7612_AGC_96 == iAgc) uiAgc = 3; else if(TUNERDTT7612_AGC_93 == iAgc) uiAgc = 4; else if(TUNERDTT7612_AGC_90 == iAgc) uiAgc = 5; else if(TUNERDTT7612_AGC_WIDE_BAND_OFF == iAgc) uiAgc = 6; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TYPE; if(TUNERDTT7612_CHARGE_PUMP_60 == iChargePump) uiChargePump = 60; else if(TUNERDTT7612_CHARGE_PUMP_280 == iChargePump) uiChargePump = 280; else return CAS_2B_UNDEFINED_TUNER_DTT761X_CHRGE_PUMP_TYPE; if(TUNERDTT7612_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant) uiAgcTimeConstant = 50; else if(TUNERDTT7612_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant) uiAgcTimeConstant = 2; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TIME_CONSTANT_TYPE; if(TUNER_AGC_MODE_INTERNAL_DIGITAL == iAgcMode ) uiAgcMode = 1; else if(TUNER_AGC_MODE_INTERNAL_ANALOG == iAgcMode) uiAgcMode = 2; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_MODE_TYPE; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerDTT7612SendChannel(*((unsigned long*)pvTunerSet),iChannelTable,iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerDTT7612SendFreq(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerDTT7612SendPicCarrier(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else return CAS_2B_UNDEFINED_TUNER_DTT761X_SET_OPTION_TYPE; switch(iRes){ case DTT7612_SUCCESS: return CAS_2B_API_SUCCESS; case DTT7612_CHANNEL_OUT_OF_RANGE: return CAS_2B_TUNER_DTT761X_CHANNEL_OUT_OF_RANGE; case DTT7612_COULD_NOT_SET_N: return CAS_2B_TUNER_DTT761X_N_VALUE_OUT_OF_RANGE; case DTT7612_SEND_CONTROL_DATA_FAILED: case DTT7612_BEFORE_SEND_BYTES_FAILED: case DTT7612_AFTER_SEND_BYTES_FAILED: return CAS_2B_TUNER_DTT761X_SEND_CONTROL_DATA_FAILED; case DTT7612_FREQUENCY_VALUE_OUT_OF_RANGE: return CAS_2B_TUNER_DTT761X_FREQUENCY_VALUE_OUT_OF_RANGE; case DTT7612_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_DTT761X_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY; default: return CAS_2B_TUNER_DTT761X_GENERAL_FAILIUR; } } #endif #endif//#if NIMTN_TYPE==NIMTN_DTT7612 #if NIMTN_TYPE==NIMTN_T2000 #if SUPPORT_TUNER_THOMSON_T_2000 int __stdcall SetTunerThomsonT2000( TYPE_TUNER_THOMSON_T2000_SET_OPTION iTunerSet, void* pvTunerSet, TYPE_TUNER_THOMSON_T2000_AGC_SELECTION iAgcSelection, TYPE_TUNER_THOMSON_T2000_INPUT_SELECTION iInput, TYPE_THOMSON_T2000_REF_DIVIDER_RATIO iRefDividerRatio, TYPE_TUNER_THOMSON_T2000_MODE iMode ) { int iError; unsigned long ulRefDividerRatio = 1; switch(iRefDividerRatio){ case THOMSON_T2000_REF_DIVIDER_RATIO_166_6: ulRefDividerRatio = 166600; break; case THOMSON_T2000_REF_DIVIDER_RATIO_62_5: ulRefDividerRatio = 62500; break; case THOMSON_T2000_REF_DIVIDER_RATIO_50: ulRefDividerRatio = 50000; break; default: return TUNER_THOMSON_T2000_UNDEFINED_REF_DIVIDER_RATIO; } if(TUNER_THOMSON_T2000_SET_CHANNEL == iTunerSet) iError = TunerThomsonT2000SendChannel(*(unsigned long*) pvTunerSet,iAgcSelection,iInput,ulRefDividerRatio,iMode); else if(TUNER_THOMSON_T2000_SET_PIC_CARRIER == iTunerSet) iError = TunerThomsonT2000SendPicCarrier(*(unsigned long*) pvTunerSet,iAgcSelection,iInput,ulRefDividerRatio,iMode); else if(TUNER_THOMSON_T2000_SET_CENTER_FREQUENCY == iTunerSet) iError = TunerThomsonT2000SendCenterFreq(*(unsigned long*) pvTunerSet,iAgcSelection,iInput,ulRefDividerRatio,iMode); switch(iError){ case THOMSON_T2000_SEND_CONTROL_DATA_SUCCESS: return CAS_2B_API_SUCCESS; case THOMSON_T2000_SEND_CONTROL_DATA_FAILED: return TUNER_THOMSON_T2000_SEND_CONTROL_DATA_FAILED; case THOMSON_T2000_UNDEFINED_AGC_SELECTION: return TUNER_THOMSON_T2000_UNDEFINED_AGC_SELECTION; case THOMSON_T2000_UNDEFINED_INPUT: return TUNER_THOMSON_T2000_UNDEFINED_INPUT; case THOMSON_T2000_UNDEFINED_MODE: return TUNER_THOMSON_T2000_UNDEFINED_MODE; default: return TUNER_THOMSON_T2000_SEND_CONTROL_DATA_FAILED; } } #endif /* SUPPORT_TUNER_THOMSON_T_2000 */ #endif//#if NIMTN_TYPE==NIMTN_T2000 #if NIMTN_TYPE==NIMTN_TD6650T #if SUPPORT_TUNER_PHILIPS_TD6650T int __stdcall SetTunerTD6650T(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TD6650T_REF_DIVIDER_RATIO iReferenceDividerRatio , TYPE_TD6650T_AGC_TOP iAGCTakeOverPoint, TYPE_TD6650T_ATC iAtc) { int iRes; if((TD6650T_REF_DIVIDER_RATIO_62_5 != iReferenceDividerRatio) && (TD6650T_REF_DIVIDER_RATIO_142_86 != iReferenceDividerRatio) && (TD6650T_REF_DIVIDER_RATIO_166_67 != iReferenceDividerRatio) && (TD6650T_REF_DIVIDER_RATIO_50 != iReferenceDividerRatio)&& (TD6650T_REF_DIVIDER_RATIO_125 != iReferenceDividerRatio)) return CAS_2B_UNDEFINED_TUNER_TD6650T_REF_DIVIDER_RATIO_TYPE; if((TD6650T_AGC_TOP_124 != iAGCTakeOverPoint)&& (TD6650T_AGC_TOP_121 != iAGCTakeOverPoint)&& (TD6650T_AGC_TOP_118 != iAGCTakeOverPoint)&& (TD6650T_AGC_TOP_115 != iAGCTakeOverPoint)&& (TD6650T_AGC_TOP_112 != iAGCTakeOverPoint)&& (TD6650T_AGC_TOP_109 != iAGCTakeOverPoint)) return CAS_2B_UNDEFINED_TUNER_TD6650T_AGC_TYPE; if((TD6650T_ATC_2_SEC != iAtc)&& (TD6650T_ATC_50_MSEC != iAtc)) return CAS_2B_UNDEFINED_TUNER_TD6650T_AGC_TIME_CONSTANT_TYPE; if( TUNER_SET_CHANNEL == TunerSet) iRes = TD6650TSendChannel(*((unsigned long*)pvTunerSet),iChannelTable,iReferenceDividerRatio,iAGCTakeOverPoint, iAtc); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TD6650TSendFreq(*((unsigned long*)pvTunerSet),iChannelTable,iReferenceDividerRatio,iAGCTakeOverPoint, iAtc); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TD6650TSendPicCarrier(*((unsigned long*)pvTunerSet),iChannelTable,iReferenceDividerRatio,iAGCTakeOverPoint, iAtc); else return CAS_2B_UNDEFINED_TUNER_TD6650T_SET_OPTION_TYPE; switch(iRes){ case TD6650T_SUCCESS: return CAS_2B_API_SUCCESS; case TD6650T_FREQUENCY_VALUE_OUT_OF_RANGE: return CAS_2B_TUNER_TD6650T_FREQUENCY_VALUE_OUT_OF_RANGE; case TD6650T_BEFORE_SEND_BYTES_FAILED: return CAS_2B_TUNER_TD6650T_BEFORE_SEND_BYTES_FAILED; case TD6650T_AFTER_SEND_BYTES_FAILED: return CAS_2B_TUNER_TD6650T_AFTER_SEND_BYTES_FAILED; case TD6650T_SEND_CONTROL_DATA_FAILED: return CAS_2B_TUNER_TD6650T_SEND_CONTROL_DATA_FAILED; default: return CAS_2B_TUNER_TD6650T_GENERAL_FAILIUR; } } #endif #endif #if NIMTN_TYPE==NIMTN_XC3028 #if SUPPORT_TUNER_XCEIVE_XC3028 int __stdcall SetTunerXC3028(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet,BOOLEAN bLoadFirmware,TYPE_TUNER_FIRMAWARE_MODE iFirmwareMode) { int iRes; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerXC3028SendChannel(*((unsigned long*)pvTunerSet),bLoadFirmware,iFirmwareMode); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerXC3028SendCenterFreq(*((unsigned long*)pvTunerSet),bLoadFirmware,iFirmwareMode); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerXC3028SendPicCarrier(*((unsigned long*)pvTunerSet),bLoadFirmware,iFirmwareMode); else return CAS_2B_UNDEFINED_TUNER_XC3028_SET_OPTION_TYPE; switch(iRes){ case XC3028_SUCCESS: return CAS_2B_API_SUCCESS; case XC3028_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_XC3028_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY; case XC3028_FIRMWARE_MODE_NOT_DEFINED: return CAS_2B_TUNER_XC3028_FIRMWARE_MODE_NOT_DEFINED; case XC3028_COMMUNICATION_ERROR: return CAS_2B_TUNER_XC3028_COMMUNICATION_ERROR; case XC3028_DSP_MODE_NOT_DEFINED: return CAS_2B_TUNER_XC3028_DSP_MODE_NOT_DEFINED; default: return CAS_2B_TUNER_XC3028_GENERAL_FAILIUR; } } #endif /* SUPPORT_TUNER_XCEIVE_XC3028 */ #endif//#if NIMTN_TYPE==NIMTN_XC3028 #if NIMTN_TYPE==NIMTN_MT2121 #if SUPPORT_TUNER_MT2121 int __stdcall SetTunerMT2121(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TUNER_MT2121_REF_DIVIDER_RATIO iReferenceDividerRatio) { int iRes; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerMt2121SendChannel(ulTunerSet,iChannelTable,iReferenceDividerRatio); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerMt2121SendCenterFrequency(ulTunerSet,iChannelTable,iReferenceDividerRatio); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerMt2121SendPicCarrier(ulTunerSet,iChannelTable,iReferenceDividerRatio); else return CAS_2B_UNDEFINED_TUNER_MT2121_SET_OPTION_TYPE; switch(iRes){ case MT2121_SUCCESS: return CAS_2B_API_SUCCESS; case MT2121_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_MT2121_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY; case MT2121_BEFORE_SEND_BYTES_FAILED: case MT2121_AFTER_SEND_BYTES_FAILED: case MT2121_SEND_CONTROL_DATA_FAILED: return CAS_2B_TUNER_MT2121_COMMUNICATION_ERROR; default: return CAS_2B_TUNER_MT2121_GENERAL_FAILIUR; } } #endif #endif //#if NIMTN_TYPE==NIMTN_MT2121 #if NIMTN_TYPE==NIMTN_TDQU #if SUPPORT_TUNER_TDQU int __stdcall SetTunerTdqu(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TUNER_TDQU_REF_DIVIDER_RATIO iReferenceDividerRatio,TYPE_TUNER_TDQU_CHARGE_PUMP iChargePump,TYPE_TUNER_TDQU_AGST iAgst) { int iRes; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerTdquSendChannel(ulTunerSet,iChannelTable,iReferenceDividerRatio,iChargePump,iAgst); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerTdquSendCenterFrequency(ulTunerSet, iReferenceDividerRatio, iChargePump, iAgst); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerTdquSendPicCarrier( ulTunerSet,iReferenceDividerRatio, iChargePump, iAgst); else return CAS_2B_UNDEFINED_TUNER_SET_OPTION_TYPE; switch(iRes) { case TDQU_SUCCESS: return CAS_2B_API_SUCCESS; case TDQU_BEFORE_SEND_BYTES_FAILED: case TDQU_AFTER_SEND_BYTES_FAILED: case TDQU_SEND_CONTROL_DATA_FAILED: return CAS_2B_TUNER_TDQU_COMMUNICATION_ERROR; case TDQU_N_CALCULATION_FAILED: case TDQU_UNDEFINED_REFERENCE_DIVIDER_RATIO: case TDQU_UNDEFINED_CHURGE_PUMP: case TDQU_UNDEFINED_AGST: case TDQU_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_TDQU_PARAMETER_ERROR; default: return CAS_2B_TUNER_TDQU_GENERAL_FAILIUR; } } #endif /* SUPPORT_TUNER_TDQU */ #endif #if NIMTN_TYPE==NIMTN_FQD1236 int SetTunerFQD1236(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TUNERFQD1236_REF_DIVIDER_RATIO iRefDividerRatio , TYPE_TUNERFQD1236_AGC iAgc, TYPE_TUNER_AGC_MODE iAgcMode, CHARGE_PUMP iChargePump, TYPE_TUNERFQD1236_AGC_TIME_CONSTANT iAgcTimeConstant ) { unsigned int uiAgc,uiChargePump,uiAgcTimeConstant,uiAgcMode; int iRes; if((TUNERFQD1236_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) && (TUNERFQD1236_REF_DIVIDER_RATIO_50 != iRefDividerRatio) && (TUNERFQD1236_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) && (TUNERFQD1236_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio)) return CAS_2B_UNDEFINED_TUNER_DTT761X_REF_DIVIDER_RATIO_TYPE; if(TUNERFQD1236_AGC_115_A == iAgc) uiAgc = 0; else if(TUNERFQD1236_AGC_115_B == iAgc) uiAgc = 1; else if(TUNERFQD1236_AGC_112 == iAgc) uiAgc = 2; else if(TUNERFQD1236_AGC_109 == iAgc) uiAgc = 3; else if(TUNERFQD1236_AGC_106== iAgc) uiAgc = 4; else if(TUNERFQD1236_AGC_103 == iAgc) uiAgc = 5; else if(TUNERFQD1236_AGC_EXTERNAL_AGC == iAgc) uiAgc = 6; else if (TUNERFQD1236_AGC_DISABLED == iAgc) uiAgc = 7; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TYPE; if(TUNERFQD1236_CHARGE_PUMP_50 == iChargePump) uiChargePump = 50; else if(TUNERFQD1236_CHARGE_PUMP_250 == iChargePump) uiChargePump = 250; else return CAS_2B_UNDEFINED_TUNER_DTT761X_CHRGE_PUMP_TYPE; if(TUNERFQD1236_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant) uiAgcTimeConstant = 50; else if(TUNERFQD1236_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant) uiAgcTimeConstant = 2; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TIME_CONSTANT_TYPE; if(TUNER_AGC_MODE_INTERNAL_DIGITAL == iAgcMode ) uiAgcMode = 1; else if(TUNER_AGC_MODE_INTERNAL_ANALOG == iAgcMode) uiAgcMode = 2; else return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_MODE_TYPE; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerFQD1236SendCnannel(*((unsigned long*)pvTunerSet),iChannelTable,iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerFQD1236SendFreq(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerFQD1236SendPicCarrier(*((unsigned long*)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant); else return CAS_2B_UNDEFINED_TUNER_DTT761X_SET_OPTION_TYPE; switch(iRes){ case FQD1236_SUCCESS: return CAS_2B_API_SUCCESS; case FQD1236_CHANNEL_OUT_OF_RANGE: return CAS_2B_TUNER_DTT761X_CHANNEL_OUT_OF_RANGE; case FQD1236_COULD_NOT_SET_N: return CAS_2B_TUNER_DTT761X_N_VALUE_OUT_OF_RANGE; case FQD1236_SEND_CONTROL_DATA_FAILED: case FQD1236_BEFORE_SEND_BYTES_FAILED: case FQD1236_AFTER_SEND_BYTES_FAILED: return CAS_2B_TUNER_DTT761X_SEND_CONTROL_DATA_FAILED; case FQD1236_FREQUENCY_VALUE_OUT_OF_RANGE: return CAS_2B_TUNER_DTT761X_FREQUENCY_VALUE_OUT_OF_RANGE; case FQD1236_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_DTT761X_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY; default: return CAS_2B_TUNER_DTT761X_GENERAL_FAILIUR; } } #endif #if SUPPORT_TUNER_SN761662 int __stdcall SetTunerSN761662(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_SN761662TUNER_REF_DIVIDER_RATIO iRefDividerRatio,TYPE_SN761662TUNER_ATC iATC, TYPE_SN761662TUNER_CP iCP,TYPE_SN761662TUNER_IFOSW iIFOSW,TYPE_SN761662TUNER_AGC_TOP_LEVEL_0_LEVEL_1 iAGCTop, TYPE_SN761662TUNER_RFAGC_SHIFT_XTALOUT_CONTROL iRFAGCShiftXtalOut) { int iRes; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerSN761662SendChannel(ulTunerSet, iChannelTable, iRefDividerRatio, iATC, iCP, iIFOSW, iAGCTop, iRFAGCShiftXtalOut); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) iRes = TunerSN761662SendFreq(ulTunerSet, iRefDividerRatio, iATC, iCP, iIFOSW, iAGCTop, iRFAGCShiftXtalOut); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerSN761662SendPicCarrier(ulTunerSet,iRefDividerRatio, iATC, iCP, iIFOSW, iAGCTop, iRFAGCShiftXtalOut); else return CAS_2B_UNDEFINED_TUNER_SET_OPTION_TYPE; switch(iRes) { case SN761662_SUCCESS: return CAS_2B_API_SUCCESS; case SN761662_BEFORE_SEND_BYTES_FAILED: case SN761662_AFTER_SEND_BYTES_FAILED: case SN761662_SEND_CONTROL_DATA_FAILED: return CAS_2B_TUNER_SN761662_COMMUNICATION_ERROR; case SN761662_INCORRECT_RFAGC_SHIFT_XTALOUT_CONTROL: case SN761662_INCORRECT_IFOSW: case SN761662_INCORRECT_ATC: case SN761662_INCORRECT_REF_DIVIDER_RATIO: case SN761662_FREQUENCY_VALUE_OUT_OF_RANGE: case SN761662_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_SN761662_PARAMETER_ERROR; default: return CAS_2B_TUNER_SN761662_GENERAL_FAILIUR; } } #endif /* SUPPORT_TUNER_SN761662 */ #if SUPPORT_TUNER_VP13HR int __stdcall SetTunerVP13HR(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet, CHANNEL_TABLE_TYPE iChannelTable, TYPE_TUNER_VP13HR_REF_DIVIDER_RATIO iRefDividerRatio, BOOLEAN bIsFMTrap, BOOLEAN bIsAFTReq) { int iRes; if( TUNER_SET_CHANNEL == TunerSet) iRes = TunerVP13HRSendChannel(ulTunerSet, iChannelTable, iRefDividerRatio, FALSE, bIsAFTReq); else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet) if (bIsAFTReq) iRes = TunerVP13HRAFT(ulTunerSet,iRefDividerRatio, bIsFMTrap); else iRes = TunerVP13HRSendCenterFrequency(ulTunerSet, iRefDividerRatio, bIsFMTrap); else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet) iRes = TunerVP13HRSendPicCarrier(ulTunerSet, iRefDividerRatio, FALSE, bIsAFTReq); else return CAS_2B_UNDEFINED_TUNER_SET_OPTION_TYPE; switch(iRes) { case VP13HR_SUCCESS: return CAS_2B_API_SUCCESS; case VP13HR_BEFORE_SEND_BYTES_FAILED: case VP13HR_AFTER_SEND_BYTES_FAILED: case VP13HR_SEND_CONTROL_DATA_FAILED: return CAS_2B_TUNER_VP13HR_COMMUNICATION_ERROR; case VP13HR_N_CALCULATION_FAILED: case VP13HR_UNDEFINED_REFERENCE_DIVIDER_RATIO: case VP13HR_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY: return CAS_2B_TUNER_VP13HR_PARAMETER_ERROR; default: return CAS_2B_TUNER_VP13HR_GENERAL_FAILIUR; } } #endif int __stdcall SendCodeAndData(unsigned char * pucCodeToSend,unsigned long ulCodeBufferSize,unsigned char * pucDataToSend,unsigned long ulDataBufferSize) { unsigned long ulFileLengthInBytes = 0; unsigned char * pucBuffer = NULL; int iSize,i,iError; CHECKSUM_STATUS iCheckSumStatus; CAS_2B_CODE_VERSION stCodeVersion; unsigned char *puc2BCodeBuffer = (unsigned char *)0; unsigned char *puc2BDataBuffer = (unsigned char *)0; int i2BCodeSize = 0, i2BDataSize = 0; if((NULL == pucCodeToSend) || (NULL == pucDataToSend)) return FUNCTION_RECEIVED_NULL_PARAMETER; if(CAS_2B_API_SUCCESS != ResetChecksum()) { DHL_DbgPrintf(0,DHLDBG_EXT, "ERROR: line=%d\n", __LINE__); return RESET_CHECKSUM_FUNCTION_FAILED; } //first file that is sent is the code file and then the data file for(i =0;i<2;i++){ if(0 == i){ iSize = 4; // code size ulFileLengthInBytes = ulCodeBufferSize; pucBuffer = pucCodeToSend; } else{ iSize = 2; //data size ulFileLengthInBytes = ulDataBufferSize; pucBuffer = pucDataToSend; } if ((((ulFileLengthInBytes*10)/iSize) - ((ulFileLengthInBytes/iSize)*10)) != 0 ) { return FILE_SIZE_CAN_NOT_BE_DIVIDED_BY_DATA_SIZE; } //add the sub address if(0 == i)//code file pucBuffer[0] = 0x7e; else//data file pucBuffer[0] = 0x7d; if(IIC_COM_SUCCESS != OrenIicTransmit(CASCADE_WRITE_ADDRESS,pucBuffer, (int)ulFileLengthInBytes+1)){ return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED; } }//for(int i =0;i<2;i++) iCheckSumStatus = GetChecksumFlag(&iError); if((IIC_COM_SUCCESS != iError) ||(iCheckSumStatus != CHECKSUM_STATUS_CORRECT)) return CHECKSUM_IS_INCORRECT; //send run flag to see if the code suites Cas2C. if(CAS_2B_SEND_RUN_FLAG_FUNCTION_FAILED == SendCas2BRunFlag()){ return CAS_2B_SEND_RUN_FLAG_FUNCTION_FAILED; } stCodeVersion = GetDSPFirmwareVersion(&iError); if(iError != IIC_COM_SUCCESS){ DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR, LINE=%d, iError=%d\n", __LINE__, iError); return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED; } //check if the code suites Cas2C - if 3 first digits are 0 we need to switch code to Cas2B if((stCodeVersion.usaVector[0] & 0xFFF0) != 0) return CAS_2B_API_SUCCESS; if(stCodeVersion.usaVector[0] == 0x0001){ puc2BCodeBuffer = Cas2BNim03CodeBuffer; i2BCodeSize = iCas2BNim03CodeBufferSize; puc2BDataBuffer = Cas2BNim03DataBuffer; i2BDataSize = iCas2BNim03DataBufferSize; } else if(stCodeVersion.usaVector[0] == 0x0002){ puc2BCodeBuffer = Cas2BDoubleDeckerCodeBuffer; i2BCodeSize = iCas2BDoubleDeckerCodeBufferSize; puc2BDataBuffer = Cas2BDoubleDeckerDataBuffer; i2BDataSize = iCas2BDoubleDeckerDataBufferSize; } else if(stCodeVersion.usaVector[0] == 0x0003){ puc2BCodeBuffer = Cas2BXceiveCodeBuffer; i2BCodeSize = iCas2BXceiveCodeBufferSize; puc2BDataBuffer = Cas2BXceiveDataBuffer; i2BDataSize = iCas2BXceiveDataBufferSize; } //Reset checksum if(CAS_2B_API_SUCCESS != ResetChecksum()) return RESET_CHECKSUM_FUNCTION_FAILED; //Send code buffer if(IIC_COM_SUCCESS != OrenIicTransmit(CASCADE_WRITE_ADDRESS, puc2BCodeBuffer, i2BCodeSize)){ DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR, LINE=%d\n", __LINE__); return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED; } //Send data buffer if(IIC_COM_SUCCESS != OrenIicTransmit(CASCADE_WRITE_ADDRESS, puc2BDataBuffer, i2BDataSize)){ DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR, LINE=%d\n", __LINE__); return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED; } iCheckSumStatus = GetChecksumFlag(&iError); if((IIC_COM_SUCCESS != iError) ||(iCheckSumStatus != CHECKSUM_STATUS_CORRECT)) return CHECKSUM_IS_INCORRECT; return CAS_2B_API_SUCCESS; } int __stdcall SendCas2BRunFlag() { if (IIC_COM_SUCCESS != SendRunFlag()) { return CAS_2B_SEND_RUN_FLAG_FUNCTION_FAILED; } else return CAS_2B_API_SUCCESS; } int __stdcall SetReceiveRegister(unsigned char usReceiveRegisterNumber,unsigned short usReceiveRegisterValue) { unsigned char ucaSend[3]; if(usReceiveRegisterNumber > 7) return CAS_2B_ILLIGAL_RECEIVE_REGISTER_NUMBER; //send the data to the appropriate receive index ucaSend[1] = (char)(usReceiveRegisterValue >> 8); ucaSend[2] = (char)(usReceiveRegisterValue); if (IIC_COM_SUCCESS != SendToReceive(usReceiveRegisterNumber, ucaSend, 2) ) return CAS_2B_SET_RECEIVE_REGISTER_FUNCTION_FAILED; else return CAS_2B_API_SUCCESS; } unsigned short __stdcall GetTransmitRegisterValue(unsigned char ucTransmitRegiterNumber,int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue( 0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } return usReceivedWord; } #if SUPPORT_TUNER_DTT7611 || SUPPORT_TUNER_DTT7612 unsigned int __stdcall PerformChannelScan(CAS_2B_CHANNEL_SCAN_PARAMETERS stChannelScanParameters, CAS_2B_CHANNEL_SCAN_RESULT *pstaChannelScanResults,unsigned long* pulaInputFrequenciesTable) { TYPE_CHANNEL_SCAN_RECEIVER_MODE_PRIORITY iaReceiverModePriority[2]; int iPriorityIndex; CAS_2B_CHANNEL_CHANGE_PARAMETERS stChannelChangeParameters; CAS_2B_TUNER_PARAMETERS stTunerParameters; REF_DIVIDER_RATIO iRefDividerRatio=REF_DIVIDER_RATIO_31_25; unsigned long ulTmpFrequency /* ,ulWait */; unsigned int uiTmpChannelNumber=0,uiChannelIndex=0; LOCK_TYPE iLockType; /* int iaTunerCarrierOffset[] = {-12, -37, -62, -87, -112, -137, -162, -187, 187, 162, 137, 112, 87, 62, -37, 12}; */ uiChannelIndex = 0; //first check that the parameters are valid if(NULL == pstaChannelScanResults) return FUNCTION_RECEIVED_NULL_PARAMETER; if((stChannelScanParameters.iTunerType < TUNER_DTT7611) || (stChannelScanParameters.iTunerType > TUNER_DTT7612)) return CAS_2B_UNDEFINED_TUNER_TYPE; if((stChannelScanParameters.iReceiverModeFirstPriority < CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_VSB) || (stChannelScanParameters.iReceiverModeFirstPriority > CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB)){ return ILLIGAL_FIRST_MODE_PRIORITY_MODE; } else{//the first priority is ok if((stChannelScanParameters.iReceiverModeSecondPriority < CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_NONE) || (stChannelScanParameters.iReceiverModeSecondPriority > CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB)){ return ILLIGAL_SECOND_MODE_PRIORITY_MODE; } if(stChannelScanParameters.iReceiverModeSecondPriority == stChannelScanParameters.iReceiverModeFirstPriority) return TWO_PRIORITIES_HAVE_THE_SAME_RECEIVER_MODE; } if(SCAN_ACCORDING_TO_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){ switch(stChannelScanParameters.iChannelTableType){ case NA_TERRESTRIAL: if(76 != stChannelScanParameters.usResultsBufferSize) return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH; break; case NA_CATV: case IRC: case HRC: if(135 != stChannelScanParameters.usResultsBufferSize) return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH; break; default: return UNDEFINED_CHANNEL_TABLE_TYPE; } if((stChannelScanParameters.iChannelTableType == NA_CATV) || (stChannelScanParameters.iChannelTableType == IRC)) uiTmpChannelNumber = 1; else// NA_TERRESTRIAL or HRC uiTmpChannelNumber = 2; #if SUPPORT_TUNER_DTT7611 if(stChannelScanParameters.iTunerType == TUNER_DTT7611) ulTmpFrequency = TunerDTT7611GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); #endif #if SUPPORT_TUNER_DTT7612 if(stChannelScanParameters.iTunerType == TUNER_DTT7612) ulTmpFrequency = TunerDTT7612GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); #endif } else if(SCAN_ACCORDING_TO_FREQUENCY == stChannelScanParameters.iChannelScanFrequencyOption){ if(stChannelScanParameters.ulStartFrequency >= stChannelScanParameters.ulEndFrequency) return START_FREQUENCY_IS_BIGGER_THAN_END_FREQUENCY; ulTmpFrequency = stChannelScanParameters.ulStartFrequency; if(stChannelScanParameters.usResultsBufferSize < (unsigned int)((stChannelScanParameters.ulEndFrequency - stChannelScanParameters.ulStartFrequency)/stChannelScanParameters.ulStepSize)) return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH; } else if(SCAN_ACCORDING_TO_INPUT_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){ ulTmpFrequency = stChannelScanParameters.ulStartFrequency; if(stChannelScanParameters.usResultsBufferSize < stChannelScanParameters.usInputFrequencyTableSize) return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH; ulTmpFrequency = pulaInputFrequenciesTable[uiChannelIndex]; } iaReceiverModePriority[0] = stChannelScanParameters.iReceiverModeFirstPriority; iaReceiverModePriority[1] = stChannelScanParameters.iReceiverModeSecondPriority; iLockType = LOCK_TYPE_UNLOCKED; while(1){ pstaChannelScanResults[uiChannelIndex].ulFrequency = ulTmpFrequency; pstaChannelScanResults[uiChannelIndex].iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_UNLOCKED; for(iPriorityIndex = 0 ; iPriorityIndex < 2; iPriorityIndex++){ if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_NONE == iaReceiverModePriority[iPriorityIndex]) break; stChannelChangeParameters.iCarrierAcquisition = stChannelScanParameters.iCarrierAcquisition; stChannelChangeParameters.iInverseSpectrum = INVERSE_SPECTRUM_OFF; if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_VSB == iaReceiverModePriority[iPriorityIndex]){ stChannelChangeParameters.iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR; stTunerParameters.iAgcMode = TUNER_AGC_MODE_INTERNAL_DIGITAL; iRefDividerRatio = REF_DIVIDER_RATIO_62_5; if(stChannelScanParameters.bNtscCheck) stChannelChangeParameters.iNtscSignalDetection = NTSC_SIGNAL_DETECTION; else stChannelChangeParameters.iNtscSignalDetection = NORMAL_VSB; } if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB == iaReceiverModePriority[iPriorityIndex]){ stChannelChangeParameters.iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT; stTunerParameters.iAgcMode = TUNER_AGC_MODE_INTERNAL_DIGITAL; iRefDividerRatio = REF_DIVIDER_RATIO_62_5; if(stChannelScanParameters.bNtscCheck) stChannelChangeParameters.iNtscSignalDetection = NTSC_SIGNAL_DETECTION; else stChannelChangeParameters.iNtscSignalDetection = NORMAL_VSB; } #if SUPPORT_TUNER_DTT7611 //set the tuner frequency if(TUNER_DTT7611 == stChannelScanParameters.iTunerType){ if(CAS_2B_API_SUCCESS != SetTunerDTT7611(TUNER_SET_CENTER_FREQUENCY_KHZ, &ulTmpFrequency, stChannelScanParameters.iChannelTableType, (TYPE_TUNERDTT7611_REF_DIVIDER_RATIO)iRefDividerRatio, TUNERDTT7611_AGC_96, stTunerParameters.iAgcMode, CHARGE_PUMP_60, TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC)) return SEND_TUNER_FREQUENCY_FAILED; } #endif #if SUPPORT_TUNER_DTT7612 if(TUNER_DTT7612 == stChannelScanParameters.iTunerType){ if(CAS_2B_API_SUCCESS != SetTunerDTT7612(TUNER_SET_CENTER_FREQUENCY_KHZ, &ulTmpFrequency, stChannelScanParameters.iChannelTableType, (TYPE_TUNERDTT7612_REF_DIVIDER_RATIO)iRefDividerRatio, TUNERDTT7612_AGC_96, stTunerParameters.iAgcMode, CHARGE_PUMP_60, TUNERDTT7612_AGC_TIME_CONSTANT_2_SEC)) return SEND_TUNER_FREQUENCY_FAILED; } #endif if(TRUE == stChannelScanParameters.bPerformCascadeChannelChange){ //wait the tuner delay OS_Delay(stChannelScanParameters.ulDelay/11000); //send the cascade channel change only if it is needed if(CAS_2B_API_SUCCESS != Cas2BChannelChange(stChannelChangeParameters)){ break; } } OS_Delay(stChannelScanParameters.ulDelay/11000); //check the chip is locked. if the chip is locked //dont try all the ulNumberOfTries iLockType = CheckIfLocked(stChannelScanParameters.ulNumberOfTries,stChannelScanParameters.bNtscCheck,10); if(LOCK_TYPE_UNLOCKED != iLockType){ OS_Delay(stChannelScanParameters.ulDelay/11000); GetChipData(iaReceiverModePriority[iPriorityIndex],iLockType,&pstaChannelScanResults[uiChannelIndex]); break;//from iPriorityIndex } else{//not locked continue; } }//for(iPriorityIndex uiChannelIndex++; if(SCAN_ACCORDING_TO_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){ uiTmpChannelNumber++; if((NA_TERRESTRIAL == stChannelScanParameters.iChannelTableType)&&(uiChannelIndex > 75)) return CAS_2B_API_SUCCESS; else if(uiChannelIndex > 134) return CAS_2B_API_SUCCESS; #if SUPPORT_TUNER_DTT7611 if(stChannelScanParameters.iTunerType == TUNER_DTT7611) ulTmpFrequency = TunerDTT7611GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); #endif #if SUPPORT_TUNER_DTT7612 if(stChannelScanParameters.iTunerType == TUNER_DTT7612) ulTmpFrequency = TunerDTT7612GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); #endif } else if(SCAN_ACCORDING_TO_FREQUENCY == stChannelScanParameters.iChannelScanFrequencyOption){ ulTmpFrequency+= stChannelScanParameters.ulStepSize; if(ulTmpFrequency > stChannelScanParameters.ulEndFrequency) return CAS_2B_API_SUCCESS; } else if(SCAN_ACCORDING_TO_INPUT_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){ if(uiChannelIndex == stChannelScanParameters.usInputFrequencyTableSize) return CAS_2B_API_SUCCESS; ulTmpFrequency = pulaInputFrequenciesTable[uiChannelIndex]; } }//while(1) // return CAS_2B_API_SUCCESS; } #endif /* SUPPORT_TUNER_DTT7611 || SUPPORT_TUNER_DTT7612 */ unsigned char GetSignalQuality(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError) { unsigned char ucSnrMin,ucSnrMax,ucSnrValue,ucSignalQuality,ucSNRSignalQuality; unsigned char ucSERSignalQuality,uc1SecSERValue, uc10SecSERValue; LOCK_STATUS iLockStatus; // // Auto Detect이면, Receiver Mode를 직접 얻음. // if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) { iReceiverMode=GetReceiveMode(piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } } if((iReceiverMode != CAS_2B_RECEIVER_MODE_VSB_8_TR)&& (iReceiverMode != CAS_2B_RECEIVER_MODE_ITUB_64) && (iReceiverMode != CAS_2B_RECEIVER_MODE_ITUB_256)){ *piError = UNDEFINED_RECEIVER_MODE; return 0; } if(NULL == piError){ *piError = FUNCTION_RECEIVED_NULL_PARAMETER; return 0; } ucSnrValue = (unsigned char)GetSnrAfterEqualization(iReceiverMode,piError); if(CAS_2B_API_SUCCESS != *piError) return 0; uc1SecSERValue = Get1SecSer(piError); if(CAS_2B_API_SUCCESS != *piError) return 0; uc10SecSERValue = Get10SecSer(piError); if(CAS_2B_API_SUCCESS != *piError) return 0; iLockStatus = IsLocked(piError); if(CAS_2B_API_SUCCESS != *piError) return 0; ucSignalQuality = 0; switch(iReceiverMode) { case CAS_2B_RECEIVER_MODE_ITUB_64: ucSnrMin = 20; ucSnrMax = 30; break; case CAS_2B_RECEIVER_MODE_ITUB_256: ucSnrMin = 25; ucSnrMax = 35; break; case CAS_2B_RECEIVER_MODE_VSB_8_TR: ucSnrMin = 10; ucSnrMax = 30; break; default: // like VSB ucSnrMin = 0; ucSnrMax = 30; } //signal quality if(UNLOCKED == iLockStatus){ ucSignalQuality = 0; } else{ //Calculate Signal quality based on SNR ucSNRSignalQuality = ((ucSnrValue - ucSnrMin)*100)/(ucSnrMax-ucSnrMin); ucSERSignalQuality = 100 - ((100*uc1SecSERValue)/50); if(ucSNRSignalQuality < ucSERSignalQuality) ucSignalQuality = ucSNRSignalQuality; else ucSignalQuality = ucSERSignalQuality; } if(ucSignalQuality > 100) ucSignalQuality = 100; return ucSignalQuality; } #if 0 /* 9/27/05 - GetSignalStrength() now returns more accurate Signal strength */ unsigned long GetSignalStrength(int * piError, TYPE_AGC_AMPLIFIER iAGCAmplifierType) { NUMERATOR_DENOMINATOR stAGCSensor,stIFAGCCommand; unsigned long ulSignalStrength; int iReceivedWord, iEqualizerMode; if(NULL == piError){ *piError = FUNCTION_RECEIVED_NULL_PARAMETER; return 0; } stIFAGCCommand = GetAgcIfCommand(piError); if(CAS_2B_API_SUCCESS != *piError) return 0; stAGCSensor = GetAGCSensor(piError); if(CAS_2B_API_SUCCESS != *piError) return 0; if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3217){ if(stIFAGCCommand.Numerator.lNumerator >= 20613 /*AGC IF command value >= 0.62*/){ ulSignalStrength = (unsigned long)(388 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 176; } if(stIFAGCCommand.Numerator.lNumerator < 20613 && stIFAGCCommand.Numerator.lNumerator >= 13434/*if(dIfAGCCommandVal < 0.62 && dIfAGCCommandVal >= 0.41)*/){ ulSignalStrength = (unsigned long)(225 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 71; } if(stIFAGCCommand.Numerator.lNumerator < 13434/*if(dIfAGCCommandVal < 0.41)*/){ ulSignalStrength = (unsigned long)(((stAGCSensor.Numerator.lNumerator - 3277) /4915)*20) ; } } if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3219){ if(stIFAGCCommand.Numerator.lNumerator >= 13107 /*AGC IF command value >= 0.4*/){ ulSignalStrength = (unsigned long)(268 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 43; } if(stIFAGCCommand.Numerator.lNumerator < 13107 && stIFAGCCommand.Numerator.lNumerator >= 4915/*if(dIfAGCCommandVal < 0.4 && dIfAGCCommandVal >= 0.15)*/){ ulSignalStrength = (unsigned long)(180 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 7; } if(stIFAGCCommand.Numerator.lNumerator < 4915/*if(dIfAGCCommandVal < 0.15)*/){ ulSignalStrength = (unsigned long)(((stAGCSensor.Numerator.lNumerator - 3277) /4915)*20);// } } if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3221){ if(stIFAGCCommand.Numerator.lNumerator >= 6553 /*AGC IF command value >= 0.2*/){ ulSignalStrength = (unsigned long)(175 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 12; } if(stIFAGCCommand.Numerator.lNumerator < 4915/*if(dIfAGCCommandVal < 0.2)*/){ ulSignalStrength = (unsigned long)(((stAGCSensor.Numerator.lNumerator - 3277) /4915)*20);// } } if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_L06){ //receive Tx 10 iReceivedWord = ReceiveTransmitRegisterValue(10,piError); iEqualizerMode = (iReceivedWord & 0x0030) >> 4; if(iEqualizerMode == 0){ if(stIFAGCCommand.Numerator.lNumerator >= 20970 /*AGC IF command value >= 0.64*/){ ulSignalStrength = (unsigned long)(181 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 36; } if(stIFAGCCommand.Numerator.lNumerator < 20970 && stIFAGCCommand.Numerator.lNumerator >= 18350/*if(dIfAGCCommandVal < 0.64 && dIfAGCCommandVal >= 0.56)*/){ ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 26; } if(stIFAGCCommand.Numerator.lNumerator < 18350 && stIFAGCCommand.Numerator.lNumerator >= 17366/*if(dIfAGCCommandVal < 0.56 && dIfAGCCommandVal >= 0.53)*/){ ulSignalStrength = (unsigned long)(333 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 121; } if(stIFAGCCommand.Numerator.lNumerator < 17366 && stIFAGCCommand.Numerator.lNumerator >= 15072/*if(dIfAGCCommandVal < 0.53 && dIfAGCCommandVal >= 0.46)*/){ ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 58; } if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 10813/*if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.33)*/){ ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13; } if(stIFAGCCommand.Numerator.lNumerator < 10813 && stIFAGCCommand.Numerator.lNumerator >= 7208/*if(dIfAGCCommandVal < 0.33 && dIfAGCCommandVal >= 0.22)*/){ ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13; } if(stIFAGCCommand.Numerator.lNumerator < 7208/*if(dIfAGCCommandVal < 0.22)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(181 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 16; } } else{ if(stIFAGCCommand.Numerator.lNumerator >= 20315 /*AGC IF command value >= 0.62*/){ ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 44; } if(stIFAGCCommand.Numerator.lNumerator < 20315 && stIFAGCCommand.Numerator.lNumerator >= 17038/*if(dIfAGCCommandVal < 0.62 && dIfAGCCommandVal >= 0.52)*/){ ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 23; } if(stIFAGCCommand.Numerator.lNumerator < 17038 && stIFAGCCommand.Numerator.lNumerator >= 13106/*if(dIfAGCCommandVal < 0.52 && dIfAGCCommandVal >= 0.4)*/){ ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 5; } if(stIFAGCCommand.Numerator.lNumerator < 13106 && stIFAGCCommand.Numerator.lNumerator >= 8191/*if(dIfAGCCommandVal < 0.4 && dIfAGCCommandVal >= 0.25)*/){ ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 30; } if(stIFAGCCommand.Numerator.lNumerator < 8191/*if(dIfAGCCommandVal < 0.25)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 12; } } } if(ulSignalStrength > 100) ulSignalStrength = 100; return ulSignalStrength; } #else unsigned long GetSignalStrength(int * piError, TYPE_AGC_AMPLIFIER iAGCAmplifierType) { NUMERATOR_DENOMINATOR stAGCSensor,stIFAGCCommand; unsigned long ulSignalStrength = 0; int iReceivedWord, iEqualizerMode; if(NULL == piError){ *piError = FUNCTION_RECEIVED_NULL_PARAMETER; return 0; } //receive Tx 10 iReceivedWord = ReceiveTransmitRegisterValue(10,piError); if(CAS_2B_API_SUCCESS != *piError) return 0; //Get the equalizer mode iEqualizerMode = (iReceivedWord & 0x0030) >> 4; DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"iEqualizerMode = %x\n", (int)iEqualizerMode); stIFAGCCommand = GetAgcIfCommand(piError); if(CAS_2B_API_SUCCESS != *piError) return 0; stAGCSensor = GetAGCSensor(piError); if(CAS_2B_API_SUCCESS != *piError) return 0; if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3217){ if(iEqualizerMode == 0){ if(stIFAGCCommand.Numerator.lNumerator >= 20609 /*AGC IF command value >= 0.69*/){ ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 265; } if(stIFAGCCommand.Numerator.lNumerator < 20609 && stIFAGCCommand.Numerator.lNumerator >= 21298/*if(dIfAGCCommandVal < 0.69 && dIfAGCCommandVal >= 0.65)*/){ ulSignalStrength = (unsigned long)(375 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 179; } if(stIFAGCCommand.Numerator.lNumerator < 21298 && stIFAGCCommand.Numerator.lNumerator >= 19987/*if(dIfAGCCommandVal < 0.65 && dIfAGCCommandVal >= 0.61)*/){ ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 260; } if(stIFAGCCommand.Numerator.lNumerator < 19987 && stIFAGCCommand.Numerator.lNumerator >= 17694/*if(dIfAGCCommandVal < 0.61 && dIfAGCCommandVal >= 0.54)*/){ ulSignalStrength = (unsigned long)(285 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 129; } if(stIFAGCCommand.Numerator.lNumerator < 17694 && stIFAGCCommand.Numerator.lNumerator >= 11796/*if(dIfAGCCommandVal < 0.54 && dIfAGCCommandVal >= 0.36)*/){ ulSignalStrength = (unsigned long)(28 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 10; } if(stIFAGCCommand.Numerator.lNumerator < 11796/*if(dIfAGCCommandVal < 0.36)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(200 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 18; } } else{ if(stIFAGCCommand.Numerator.lNumerator >= 22281 /*AGC IF command value >= 0.68*/){ ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 260; } if(stIFAGCCommand.Numerator.lNumerator < 22281 && stIFAGCCommand.Numerator.lNumerator >= 20970/*if(dIfAGCCommandVal < 0.68 && dIfAGCCommandVal >= 0.64)*/){ ulSignalStrength = (unsigned long)(375 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 175; } if(stIFAGCCommand.Numerator.lNumerator < 20970 && stIFAGCCommand.Numerator.lNumerator >= 19660/*if(dIfAGCCommandVal < 0.64 && dIfAGCCommandVal >= 0.6)*/){ ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 255; } if(stIFAGCCommand.Numerator.lNumerator < 19660 && stIFAGCCommand.Numerator.lNumerator >= 17366/*if(dIfAGCCommandVal < 0.6 && dIfAGCCommandVal >= 0.53)*/){ ulSignalStrength = (unsigned long)(285 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 126; } if(stIFAGCCommand.Numerator.lNumerator < 17366 && stIFAGCCommand.Numerator.lNumerator >= 13106/*if(dIfAGCCommandVal < 0.53 && dIfAGCCommandVal >= 0.4)*/){ ulSignalStrength = (unsigned long)(38 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 5; } if(stIFAGCCommand.Numerator.lNumerator < 13106/*if(dIfAGCCommandVal < 0.4)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 13; } } } if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3219){ if(iEqualizerMode == 0){ if(stIFAGCCommand.Numerator.lNumerator >= 15400 /*AGC IF command value >= 0.47*/){ ulSignalStrength = (unsigned long)(222 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 22; } if(stIFAGCCommand.Numerator.lNumerator < 15400 && stIFAGCCommand.Numerator.lNumerator >= 13434/*if(dIfAGCCommandVal < 0.47 && dIfAGCCommandVal >= 0.41)*/){ ulSignalStrength = (unsigned long)(250 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 37; } if(stIFAGCCommand.Numerator.lNumerator < 13434 && stIFAGCCommand.Numerator.lNumerator >= 10813/*if(dIfAGCCommandVal < 0.31 && dIfAGCCommandVal >= 0.33)*/){ ulSignalStrength = (unsigned long)(250 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 37; } if(stIFAGCCommand.Numerator.lNumerator < 10813 && stIFAGCCommand.Numerator.lNumerator >= 6225/*if(dIfAGCCommandVal < 0.33 && dIfAGCCommandVal >= 0.19)*/){ ulSignalStrength = (unsigned long)(142 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 2; } if(stIFAGCCommand.Numerator.lNumerator < 6225 && stIFAGCCommand.Numerator.lNumerator >= 3932/*if(dIfAGCCommandVal < 0.19 && dIfAGCCommandVal >= 0.12)*/){ ulSignalStrength = (unsigned long)(71 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 12; } if(stIFAGCCommand.Numerator.lNumerator < 3932/*if(dIfAGCCommandVal < 0.12)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(200 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 18; } } else{ if(stIFAGCCommand.Numerator.lNumerator >= 15072 /*AGC IF command value >= 0.46*/){ ulSignalStrength = (unsigned long)(222 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 22; } if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 12779/*if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.39)*/){ ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 18; } if(stIFAGCCommand.Numerator.lNumerator < 12779 && stIFAGCCommand.Numerator.lNumerator >= 9830/*if(dIfAGCCommandVal < 0.39 && dIfAGCCommandVal >= 0.3)*/){ ulSignalStrength = (unsigned long)(222 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 21; } if(stIFAGCCommand.Numerator.lNumerator < 9830 && stIFAGCCommand.Numerator.lNumerator >= 4915/*if(dIfAGCCommandVal < 0.3 && dIfAGCCommandVal >= 0.15)*/){ ulSignalStrength = (unsigned long)(133 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 5; } if(stIFAGCCommand.Numerator.lNumerator < 4915 && stIFAGCCommand.Numerator.lNumerator >= 2293/*if(dIfAGCCommandVal < 0.15 && dIfAGCCommandVal >= 0.07)*/){ ulSignalStrength = (unsigned long)(62 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 16; } if(stIFAGCCommand.Numerator.lNumerator < 2293/*if(dIfAGCCommandVal < 0.07)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 13; } } } if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3221){ if(iEqualizerMode == 0){ if(stIFAGCCommand.Numerator.lNumerator >= 17694 /*AGC IF command value >= 0.54*/){ ulSignalStrength = (unsigned long)(142 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 7; } if(stIFAGCCommand.Numerator.lNumerator < 17694 && stIFAGCCommand.Numerator.lNumerator >= 15072/*if(dIfAGCCommandVal < 0.54 && dIfAGCCommandVal >= 0.46)*/){ ulSignalStrength = (unsigned long)(187 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 21; } if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 12780/*if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.39)*/){ ulSignalStrength = (unsigned long)(285 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 66; } if(stIFAGCCommand.Numerator.lNumerator < 9502 && stIFAGCCommand.Numerator.lNumerator >= 3276/*if(dIfAGCCommandVal < 0.39 && dIfAGCCommandVal >= 0.29)*/){ ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 33; } if(stIFAGCCommand.Numerator.lNumerator < 9502 && stIFAGCCommand.Numerator.lNumerator >= 3276/*if(dIfAGCCommandVal < 0.29 && dIfAGCCommandVal >= 0.1)*/){ ulSignalStrength = (unsigned long)(26 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 17; } if(stIFAGCCommand.Numerator.lNumerator < 3276/*if(dIfAGCCommandVal < 0.1)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(200 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 18; } } else{ if(stIFAGCCommand.Numerator.lNumerator >= 16711 /*AGC IF command value >= 0.51*/){ ulSignalStrength = (unsigned long)(143 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 7; } if(stIFAGCCommand.Numerator.lNumerator < 16711 && stIFAGCCommand.Numerator.lNumerator >= 14417/*if(dIfAGCCommandVal < 0.51 && dIfAGCCommandVal >= 0.44)*/){ ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 29; } if(stIFAGCCommand.Numerator.lNumerator < 14417 && stIFAGCCommand.Numerator.lNumerator >= 12451/*if(dIfAGCCommandVal < 0.44 && dIfAGCCommandVal >= 0.38)*/){ ulSignalStrength = (unsigned long)(333 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 81; } if(stIFAGCCommand.Numerator.lNumerator < 12451 && stIFAGCCommand.Numerator.lNumerator >= 8519/*if(dIfAGCCommandVal < 0.38 && dIfAGCCommandVal >= 0.26)*/){ ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 18; } if(stIFAGCCommand.Numerator.lNumerator < 8519 && stIFAGCCommand.Numerator.lNumerator >= 4915/*if(dIfAGCCommandVal < 0.26 && dIfAGCCommandVal >= 0.15)*/){ ulSignalStrength = (unsigned long)(50 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 13; } if(stIFAGCCommand.Numerator.lNumerator < 4915/*if(dIfAGCCommandVal < 0.15)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 13; } } } if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_L06){ if(iEqualizerMode == 0){ if(stIFAGCCommand.Numerator.lNumerator >= 20970 /*AGC IF command value >= 0.64*/){ ulSignalStrength = (unsigned long)(181 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 36; } if(stIFAGCCommand.Numerator.lNumerator < 20970 && stIFAGCCommand.Numerator.lNumerator >= 18350/*if(dIfAGCCommandVal < 0.64 && dIfAGCCommandVal >= 0.56)*/){ ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 26; } if(stIFAGCCommand.Numerator.lNumerator < 18350 && stIFAGCCommand.Numerator.lNumerator >= 17366/*if(dIfAGCCommandVal < 0.56 && dIfAGCCommandVal >= 0.53)*/){ ulSignalStrength = (unsigned long)(333 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 121; } if(stIFAGCCommand.Numerator.lNumerator < 17366 && stIFAGCCommand.Numerator.lNumerator >= 15072/*if(dIfAGCCommandVal < 0.53 && dIfAGCCommandVal >= 0.46)*/){ ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 58; } if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 10813/*if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.33)*/){ ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13; } if(stIFAGCCommand.Numerator.lNumerator < 10813 && stIFAGCCommand.Numerator.lNumerator >= 7208/*if(dIfAGCCommandVal < 0.33 && dIfAGCCommandVal >= 0.22)*/){ ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13; } if(stIFAGCCommand.Numerator.lNumerator < 7208/*if(dIfAGCCommandVal < 0.22)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(181 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 16; } } else{ if(stIFAGCCommand.Numerator.lNumerator >= 20315 /*AGC IF command value >= 0.62*/){ ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 44; } if(stIFAGCCommand.Numerator.lNumerator < 20315 && stIFAGCCommand.Numerator.lNumerator >= 17038/*if(dIfAGCCommandVal < 0.62 && dIfAGCCommandVal >= 0.52)*/){ ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 23; } if(stIFAGCCommand.Numerator.lNumerator < 17038 && stIFAGCCommand.Numerator.lNumerator >= 13106/*if(dIfAGCCommandVal < 0.52 && dIfAGCCommandVal >= 0.4)*/){ ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 5; } if(stIFAGCCommand.Numerator.lNumerator < 13106 && stIFAGCCommand.Numerator.lNumerator >= 8191/*if(dIfAGCCommandVal < 0.4 && dIfAGCCommandVal >= 0.25)*/){ ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 30; } if(stIFAGCCommand.Numerator.lNumerator < 8191/*if(dIfAGCCommandVal < 0.25)*/){ if(stAGCSensor.Numerator.lNumerator < 2950)/*if(dAGCSensor < 0.09)*/ ulSignalStrength = 0; else ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 12; } } } if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_DDM40){ ulSignalStrength = (stIFAGCCommand.Numerator.lNumerator * 150) / stAGCSensor.Denominator.lDenominator; } if(ulSignalStrength > 100) ulSignalStrength = 100; return ulSignalStrength; } #endif unsigned int __stdcall Cas2BOOBChannelChange(CAS_2B_OOB_CHANNEL_CHANGE_PARAMETERS stOOBChannelChangeParameters) { unsigned short usReceive6 = 0; unsigned char cSend[3]; int iRes; if(stOOBChannelChangeParameters.ulSetValue > 130000 || stOOBChannelChangeParameters.ulSetValue < 70000){ return OOB_FREQ_OUT_OF_RANGE; } usReceive6 |= 0x8000;//FDC CC flag usReceive6 |= ((stOOBChannelChangeParameters.bIsPowerDown ? 0:1) << 12); usReceive6 |= (stOOBChannelChangeParameters.iFDCMode << 13); iRes = ((stOOBChannelChangeParameters.ulSetValue + 44000)*1024/25000 - 4096); if(iRes > 4095){ return OOB_FREQ_OUT_OF_RANGE; } usReceive6 |= iRes; cSend[1] = (char)(usReceive6 >> 8); cSend[2] = (char)(usReceive6); if (IIC_COM_SUCCESS != SendToReceive(6, cSend, 2)){ return CAS_2B_SET_RECEIVE_REGISTER_FUNCTION_FAILED; } return CAS_2B_API_SUCCESS; } LOCK_STATUS __stdcall IsOOBLocked(int * piError) { unsigned short usReceivedWord = 0; usReceivedWord = ReceiveTransmitRegisterValue(18,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return UNDEFINED_LOCK_STATUS; } *piError = (int) CAS_2B_API_SUCCESS; //now musk bit 2 to get the lock status if((0x04 & usReceivedWord)) return LOCKED; else return UNLOCKED; } NUMERATOR_DENOMINATOR __stdcall GetOOBAgcIfCommand(int * piError) { unsigned short usReceivedWord = 0; NUMERATOR_DENOMINATOR stResult; stResult.Numerator.lNumerator = 0; stResult.Denominator.lDenominator = 256; //receive the AGC IF Command value from transmit register 21 usReceivedWord = ReceiveTransmitRegisterValue(21,piError); usReceivedWord >>=8; if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } stResult.Numerator.lNumerator = usReceivedWord ; return stResult; } long __stdcall GetOOBCarrierOffset(TYPE_FDC_MODE iFDCMode, int * piError) { unsigned short usReceivedWord = 0; long lTmp; short sReceivedData; //read the transmit 20 register value usReceivedWord = ReceiveTransmitRegisterValue(20,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } if(usReceivedWord > 0x7fff) sReceivedData = usReceivedWord - 0x10000; else sReceivedData = usReceivedWord; lTmp = sReceivedData * OOB_25_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*OOB_25_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/OOB_25_CARRIER_FLOATING_POINT_DIVIDER ; //now round the number to Khz if(lTmp > 0) lTmp = ((lTmp + 555)*1000)/1000; else lTmp = ((lTmp - 555)*1000)/1000; return (lTmp/1000); } unsigned short __stdcall GetOOBSnr(int * piError) { unsigned short usReceivedWord = 0; int iLogResult,iSNRResult; //get the snr value usReceivedWord = ReceiveTransmitRegisterValue(18,piError); //bits 6-15 usReceivedWord = ((usReceivedWord & 0xffc0) >> 6); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return 0; } //mask the received data 15 lsb bits if(0 == usReceivedWord){ *piError = (int) RECEIVED_ZERO_SNR_VALUE_FROM_THE_CASCADE; return 0; } iLogResult = CalcLog(usReceivedWord); iSNRResult = OOB_ADD_TO_LOG - iLogResult; return iSNRResult; } TYPE_AUDIO_CHANNEL_STATE __stdcall GetAudioChannelState(TYPE_AUDIO_CHANNEL iAudioChannel,int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return AUDIO_CHANNEL_STATE_UNDEFINED; } *piError = CAS_2B_API_SUCCESS; if(AUDIO_CHANNEL_LEFT == iAudioChannel){ usReceivedWord = (usReceivedWord & 0x700) >> 8; } else{//AUDIO_CHANNEL_RIGHT usReceivedWord = (usReceivedWord & 0x3800) >> 11; } switch(usReceivedWord){ case 0: return AUDIO_CHANNEL_STATE_MONO; case 1: return AUDIO_CHANNEL_STATE_LEFT; case 2: return AUDIO_CHANNEL_STATE_RIGHT; case 3: return AUDIO_CHANNEL_STATE_MONO_2; case 5: case 6: case 7: return AUDIO_CHANNEL_STATE_MUTE; default: *piError = RECEIVED_UNDEFINED_AUDIO_CHANNEL_STATE; return AUDIO_CHANNEL_STATE_UNDEFINED; } } BOOLEAN __stdcall IsStereoDetected(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return FALSE; } *piError = CAS_2B_API_SUCCESS; //get bit 14 usReceivedWord = (usReceivedWord & 0x4000) >> 14; if(1== usReceivedWord) return TRUE; else return FALSE; } BOOLEAN __stdcall IsBilingualSapDetected(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return FALSE; } *piError = CAS_2B_API_SUCCESS; //get bit 15 usReceivedWord = (usReceivedWord & 0x8000) >> 15; if(1== usReceivedWord) return TRUE; else return FALSE; } TYPE_AUDIO_DEVIATION_MODE __stdcall GetDeviationSensitivityMode(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(7,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return AUDIO_DEVIATION_UNDEFINED; } *piError = CAS_2B_API_SUCCESS; //get bits 11 usReceivedWord = (usReceivedWord & 0x0800) >> 11; if(usReceivedWord == 0) return AUDIO_DEVIATION_NORMAL; else return AUDIO_DEVIATION_HIGH_DEVIATION; } TYPE_AUDIO_STANDARD __stdcall GetAudioStandard(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(0,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return AUDIO_STANDARD_UNDEFINED; } *piError = CAS_2B_API_SUCCESS; //get bits 0-7 usReceivedWord = (usReceivedWord & 0x00ff); switch(usReceivedWord){ case 30: return AUDIO_STANDARD_BTSC; case 31: return AUDIO_STANDARD_KOREA; case 32: return AUDIO_STANDARD_RADIO_FM; default: *piError = (int) RECEIVED_UNDEFINED_AUDIO_STANDARD; return AUDIO_STANDARD_UNDEFINED; } } TYPE_AUDIO_MASTER_SLAVE_MODE __stdcall GetMasterSlaveMode(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(7,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return TYPE_AUDIO_UNDEFINED_MASTER_SLAVE_MODE; } *piError = CAS_2B_API_SUCCESS; //get bits 13 if((usReceivedWord & 0x2000)== 0x2000) return TYPE_AUDIO_MASTER_MODE; else return TYPE_AUDIO_SLAVE_MODE; } TYPE_SCL_TO_WS_RATIO __stdcall GetSclToWsRatio(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(8,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return TYPE_SCL_TO_WS_RATIO_UNDEFINED; } *piError = CAS_2B_API_SUCCESS; //get bits 8,9 switch((usReceivedWord & 0x0300) >> 8){ case 0: return TYPE_SCL_TO_WS_RATIO_32; case 1: return TYPE_SCL_TO_WS_RATIO_48; case 2: return TYPE_SCL_TO_WS_RATIO_64; default: return TYPE_SCL_TO_WS_RATIO_UNDEFINED; } } TYPE_IIS_OUT_RATE __stdcall GetIISOuputRate(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(8,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return TYPE_IIS_OUT_RATE_UNDEFINED; } *piError = CAS_2B_API_SUCCESS; //get bits 10, 11, 12 switch((usReceivedWord & 0x1c00) >> 10){ case 0: return TYPE_IIS_OUT_RATE_48; case 1: return TYPE_IIS_OUT_RATE_96; case 2: return TYPE_IIS_OUT_RATE_44_1; case 3: return TYPE_IIS_OUT_RATE_88_2; case 4: return TYPE_IIS_OUT_RATE_32; default: return TYPE_IIS_OUT_RATE_UNDEFINED; } } TYPE_IIS_MODE __stdcall GetIISMode(int * piError) { unsigned short usReceivedWord; usReceivedWord = ReceiveTransmitRegisterValue(8,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return TYPE_IIS_MODE_UNDEFINED; } *piError = CAS_2B_API_SUCCESS; //get bits 13,14 switch((usReceivedWord & 0x6000) >> 13){ case 0: return TYPE_IIS_MODE_IIS; case 1: return TYPE_IIS_MODE_LJ; case 2: return TYPE_IIS_MODE_RJ; default: return TYPE_IIS_MODE_UNDEFINED; } } NUMERATOR_DENOMINATOR __stdcall GetSoundCh1AGC(int * piError) { unsigned short usReceivedWord = 0; NUMERATOR_DENOMINATOR stResult; stResult.Numerator.lNumerator = 0; stResult.Denominator.lDenominator = 1024; usReceivedWord = ReceiveTransmitRegisterValue(2,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } stResult.Numerator.lNumerator = (usReceivedWord & 0x3ff); return stResult; } NUMERATOR_DENOMINATOR __stdcall GetSoundLeftOutputGain(int * piError) { unsigned short usReceivedWord = 0; NUMERATOR_DENOMINATOR stResult; stResult.Numerator.lNumerator = 0; stResult.Denominator.lDenominator = 64; usReceivedWord = ReceiveTransmitRegisterValue(1,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } stResult.Numerator.lNumerator = (usReceivedWord & 0xff); return stResult; } NUMERATOR_DENOMINATOR __stdcall GetSoundRightOutputGain(int * piError) { unsigned short usReceivedWord = 0; NUMERATOR_DENOMINATOR stResult; stResult.Numerator.lNumerator = 0; stResult.Denominator.lDenominator = 64; usReceivedWord = ReceiveTransmitRegisterValue(1,piError); if(IIC_COM_SUCCESS != *piError){ *piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED; return stResult; } stResult.Numerator.lNumerator = (usReceivedWord & 0xff00 >> 8); return stResult; } int __stdcall SendAudioMessage(unsigned char ucReceiveRegisterNumber, CAS_2B_AUDIO_MESSAGE_PARAMETERS stAudiomessageParameters) { unsigned char ucaSendData[3]; unsigned short usSendData = 0; switch(ucReceiveRegisterNumber){ //receiev 1; case 1: if(TRUE == stAudiomessageParameters.bAudioLeftChannelMute) usSendData = 0x1; if(TRUE == stAudiomessageParameters.bAudioRightChannelMute) usSendData |= 0x2; if(TRUE == stAudiomessageParameters.bAudioForcedMonoMode) usSendData |= 0x4; if(AUDIO_NR_SWITCH_SAP == stAudiomessageParameters.iNRSwithch) usSendData |= 0x8; usSendData |= stAudiomessageParameters.iStereoMode << 4; if(AUDIO_BILINGUAL_MODE_MONO2_MONO2 == stAudiomessageParameters.iBilingualMode) usSendData |= 0x40; if(TRUE == stAudiomessageParameters.bDeEmphasisOn) usSendData |= 0x400; if(TRUE == stAudiomessageParameters.bDbxOn) usSendData |= 0x800; usSendData |= stAudiomessageParameters.iHighDeviationMode << 13; if(TRUE == stAudiomessageParameters.bCh1PllPiIntegratorReset) usSendData |= 0x4000; if(TRUE == stAudiomessageParameters.bCh2PllPiIntegratorReset) usSendData |= 0x8000; break; //receiev 2 case 2: usSendData = stAudiomessageParameters.usLeftOutputGain; usSendData |= stAudiomessageParameters.usRightOutputGain << 8; break; //receiev 3 case 3: usSendData |= stAudiomessageParameters.iSclToWsDivisionFactor << 8; usSendData |= stAudiomessageParameters.iIisOutRate << 10; usSendData |= stAudiomessageParameters.iIisMode << 13; if(TYPE_AUDIO_MASTER_MODE == stAudiomessageParameters.iMasterSlaveMode) usSendData |= 0x8000; break; default: return RECEIVE_REGISTER_NUMBER_OUT_OF_RANGE; } ucaSendData[1] = (unsigned char)(usSendData >> 8); ucaSendData[2] = (unsigned char)usSendData; return SendToReceive(ucReceiveRegisterNumber, ucaSendData, 2); } void __stdcall InitAudioMessageStructToDefault(CAS_2B_AUDIO_MESSAGE_PARAMETERS* pstAudiomessageParameters) { if(NULL == pstAudiomessageParameters) return; //for receive 1 pstAudiomessageParameters->bAudioLeftChannelMute = FALSE; pstAudiomessageParameters->bAudioRightChannelMute = FALSE; pstAudiomessageParameters->bAudioForcedMonoMode = FALSE; pstAudiomessageParameters->iNRSwithch = AUDIO_NR_SWITCH_STEREO; pstAudiomessageParameters->iStereoMode = AUDIO_STEREO_MODE_LEFT_RIGHT; pstAudiomessageParameters->iBilingualMode = AUDIO_BILINGUAL_MODE_MONO2_MONO2; pstAudiomessageParameters->bDeEmphasisOn = TRUE; pstAudiomessageParameters->bDbxOn = TRUE; pstAudiomessageParameters->iHighDeviationMode = AUDIO_DEVIATION_NORMAL; pstAudiomessageParameters->bCh1PllPiIntegratorReset = FALSE; pstAudiomessageParameters->bCh2PllPiIntegratorReset = FALSE; //for receive 2 pstAudiomessageParameters->usLeftOutputGain = 65; pstAudiomessageParameters->usRightOutputGain = 65; //for receieve 3 pstAudiomessageParameters->iSclToWsDivisionFactor = TYPE_SCL_TO_WS_RATIO_64; pstAudiomessageParameters->iIisOutRate = TYPE_IIS_OUT_RATE_48; pstAudiomessageParameters->iIisMode = TYPE_IIS_MODE_LJ; pstAudiomessageParameters->iMasterSlaveMode = TYPE_AUDIO_SLAVE_MODE; } //************************************************************************* ///for internal use unsigned char _stdcall CalcLog(unsigned short usReceivedWord) { unsigned char ucResult = 1, ucValueToLog; ucValueToLog = (unsigned char)usReceivedWord; if(usReceivedWord > 10000){ ucValueToLog = usReceivedWord / 1000; ucResult = 60; //3 * 20 } else if(usReceivedWord > 100){ ucValueToLog = usReceivedWord / 100; ucResult = 40; // 2 * 20; } ucResult += GetLogFromTable(ucValueToLog); return ucResult; } unsigned char _stdcall GetLogFromTable(unsigned char ucValueToLog) { return ucLogValuesFrom1To100[ucValueToLog]; } int __stdcall GetChipData(TYPE_CHANNEL_SCAN_RECEIVER_MODE_PRIORITY iReceiverModePriority,LOCK_TYPE iLockType,CAS_2B_CHANNEL_SCAN_RESULT* pstChannelScanResult) { unsigned char ucTmp; int iError; CAS_2B_TYPE_RECEIVER_MODE iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR; if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)||(LOCK_TYPE_ANALOG == iLockType)) pstChannelScanResult->bNtscSignalDetected = TRUE; else pstChannelScanResult->bNtscSignalDetected = FALSE; if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_VSB == iReceiverModePriority){ if(LOCK_TYPE_ANALOG == iLockType){ pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_NTSC; iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR; } else{ //get the mode ucTmp = GetMode(&iError); if(iError != CAS_2B_API_SUCCESS) return iError; if(0x6 == ucTmp){ pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_VSB_8_TR; iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR; } else if(0x5 == ucTmp){ pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_VSB_16; iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR; } else return UNDEFINED_RECEIVER_MODE; } } else if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB == iReceiverModePriority ){ if(LOCK_TYPE_ANALOG == iLockType){ pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_NTSC; iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_256; } else{ //get the mode ucTmp = GetMode(&iError); if(iError != CAS_2B_API_SUCCESS) return iError; if(0x23 == ucTmp){ pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_ITUB_64; iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_64; } else if(0x25 == ucTmp){ pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_ITUB_256; iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_256; } else return UNDEFINED_RECEIVER_MODE; //get the DI mode command pstChannelScanResult->iDiMode = GetDiMode(&iError); if(iError != CAS_2B_API_SUCCESS) return iError; } } //get the carrier offset if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)||(LOCK_TYPE_DIGITAL == iLockType)){ pstChannelScanResult->lCarrierOffset = GetCarrierOffset(iReceiverMode,&iError); if(iError != CAS_2B_API_SUCCESS) return iError; } if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)||(LOCK_TYPE_ANALOG == iLockType)){ pstChannelScanResult->lNtscCarrierOffset = GetNtscCarrierOffset(iReceiverMode,&iError); if(iError != CAS_2B_API_SUCCESS) return iError; } if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)||(LOCK_TYPE_DIGITAL == iLockType)){ //get the SNR after equalization pstChannelScanResult->usSnr = GetSnrAfterEqualization(iReceiverMode,&iError); if(iError != CAS_2B_API_SUCCESS) return iError; //get the AGC IF command pstChannelScanResult->stAgcIfCommand = GetAgcIfCommand(&iError); if(iError != CAS_2B_API_SUCCESS) return iError; //get the Inverse spectrum command ucTmp = GetRfInverseSpectrum(&iError); if(iError != CAS_2B_API_SUCCESS) return iError; if(1 == ucTmp) pstChannelScanResult->bRfInverseSpectrum = TRUE; else pstChannelScanResult->bRfInverseSpectrum = FALSE; //get the Symbol rate freq pstChannelScanResult->stSymbolRateoffset = GetSymbolRateFrequencyOffset(iReceiverMode,&iError); if(iError != CAS_2B_API_SUCCESS) return iError; } return TRUE; } /* LOCK_TYPE __stdcall CheckIfLocked(unsigned long ulNumberOfTries,BOOLEAN bWithNtscCheck) { int iError; LOCK_STATUS iLockStatus; BOOLEAN bNtscChannelDetected; while(ulNumberOfTries){ iLockStatus = IsLocked(&iError); if(CAS_2B_API_SUCCESS != iError){ return LOCK_TYPE_UNLOCKED; } if(TRUE == bWithNtscCheck){ bNtscChannelDetected = IsNtscChannelDetected(&iError); if(CAS_2B_API_SUCCESS != iError){ return LOCK_TYPE_UNLOCKED; } } if(LOCKED == iLockStatus){ if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected)){ return LOCK_TYPE_DIGITAL_AND_ANALOG; } else return LOCK_TYPE_DIGITAL; } else{ if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected)) return LOCK_TYPE_ANALOG; else return LOCK_TYPE_UNLOCKED; } ulNumberOfTries--; } return LOCK_TYPE_UNLOCKED; } */ LOCK_TYPE __stdcall CheckIfLocked(unsigned long ulNumberOfTries,BOOLEAN bWithNtscCheck, unsigned long ulDelay) { int iError; LOCK_STATUS iLockStatus; BOOLEAN bNtscChannelDetected = 0; while(ulNumberOfTries){ OS_Delay(10);/* deley */ iLockStatus = IsLocked(&iError); if(CAS_2B_API_SUCCESS != iError){ return LOCK_TYPE_UNLOCKED; } if(TRUE == bWithNtscCheck){ bNtscChannelDetected = IsNtscChannelDetected(&iError); if(CAS_2B_API_SUCCESS != iError){ if (ulNumberOfTries == 0) return LOCK_TYPE_UNLOCKED; } } if(LOCKED == iLockStatus){ if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected)){ return LOCK_TYPE_DIGITAL_AND_ANALOG; } else return LOCK_TYPE_DIGITAL; } else{ if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected)) return LOCK_TYPE_ANALOG; else if (ulNumberOfTries == 0) return LOCK_TYPE_UNLOCKED; } ulNumberOfTries--; } return LOCK_TYPE_UNLOCKED; } BOOLEAN BeforeTunerSendBytes() { if(IIC_COM_SUCCESS != SendHostControl(0, 0)) return FALSE; else return TRUE; } BOOLEAN AfterTunerSendBytes() { if(IIC_COM_SUCCESS != SendHostControl(0x80, 0)) return FALSE; else return TRUE; } ///for internal use //*************************************************************************