/* * $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 "DST_CONFIG.h" #include "Cas2BRoutines.h" #include "IicComm.h" #include "SnrCalcTable.h" #include "TunerDTT7611.h" #include "TunerDTT7612.h" #include "DTT7600Tuner.h" #include "TD6650TTuner.h" //kiki #include "TunerFQD1236.h" #include "ThomsonT2000Tuner.h" #include "Cas2BGeneralDefinitions.h" //kiki #include "XC3028.h" #include "Cas2BInitBuffers.h" #include "TunerFQD1236.h" #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 NIMTN_TYPE==NIMTN_DTT7611 if(TUNER_DTT7611 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerDTT7611(stTunerParameters.iTunerSet, &(stTunerParameters.ulSetValue), stTunerParameters.iChannelTableType, TUNERDTT7611_REF_DIVIDER_RATIO_62_5,/*default value*/ TUNERDTT7611_AGC_93,/*default value*/ 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; }else #endif//#if NIMTN_TYPE==NIMTN_DTT7611 #if NIMTN_TYPE==NIMTN_DTT7612 if(TUNER_DTT7612 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerDTT7612(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue, stTunerParameters.iChannelTableType, TUNERDTT7612_REF_DIVIDER_RATIO_62_5,/*default value*/ TUNERDTT7612_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; }else #endif//#if NIMTN_TYPE==NIMTN_DTT7612 #if NIMTN_TYPE==NIMTN_T2000 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; }else #endif//#if NIMTN_TYPE==NIMTN_T2000 #if NIMTN_TYPE==NIMTN_TD6650T 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; }else #endif//#if NIMTN_TYPE==NIMTN_TD6650T #if NIMTN_TYPE==NIMTN_XC3028 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; }else #endif//#if NIMTN_TYPE==NIMTN_XC3028 #if NYMTN_TYPE != NIMTN_TDQU // xoceco에서 제거요청. xoceco일경우에만 제거. 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; }else #endif #if NIMTN_TYPE==NIMTN_MT2121 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; } else #endif//#if NIMTN_TYPE==NIMTN_MT2121 #if NIMTN_TYPE==NIMTN_TDQU 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_1_2_MA, TUNER_TDQU_AGST_MINUS_6); if(CAS_2B_API_SUCCESS != iError) return iError; }else #endif #if NIMTN_TYPE==NIMTN_FQD1236 if(TUNER_FQD1236 == stTunerParameters.iTunerType){ iError = (ERROR_TYPE)SetTunerFQD1236(stTunerParameters.iTunerSet, &(stTunerParameters.ulSetValue), stTunerParameters.iChannelTableType, TUNERFQD1236_REF_DIVIDER_RATIO_62_5,/*default value*/ TUNERFQD1236_AGC_106,/*default value*/ stTunerParameters.iAgcMode, CHARGE_PUMP_60,/*default value*/ TUNERFQD1236_AGC_TIME_CONSTANT_50_MS);/*default value*/ if(0 != iError) return iError; }else #endif { 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; #if 0 //wait a delay; ulDelay = usDelay * 10000; while(ulDelay != 0) ulDelay --; #else Demux_STCDelay(usDelay/11); #endif //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; } 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); } 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; 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; 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 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; 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; short sReceivedData; int iTransmitIndex; 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 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); } 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 = TunerDTT760xATSCSendCnannel(*((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; } } #if NIMTN_TYPE==NIMTN_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 = TunerDTT7611SendCnannel(*((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 #if NIMTN_TYPE==NIMTN_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 = TunerDTT7612SendCnannel(*((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//#if NIMTN_TYPE==NIMTN_DTT7612 #if NIMTN_TYPE==NIMTN_T2000 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 = TunerThomsonT2000SendCnannel(*(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//#if NIMTN_TYPE==NIMTN_T2000 #if NIMTN_TYPE==NIMTN_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 = TD6650TSendCnannel(*((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 #if NIMTN_TYPE==NIMTN_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 = TunerXC3028SendCnannel(*((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//#if NIMTN_TYPE==NIMTN_XC3028 #if NIMTN_TYPE==NIMTN_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 = TunerMt2121SendCnannel(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 //#if NIMTN_TYPE==NIMTN_MT2121 #if NIMTN_TYPE==NIMTN_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 = TunerTdquSendCnannel(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 #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 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, *puc2BDataBuffer; int i2BCodeSize = 0, i2BDataSize = 0; if((NULL == pucCodeToSend) || (NULL == pucDataToSend)) return FUNCTION_RECEIVED_NULL_PARAMETER; if(CAS_2B_API_SUCCESS != ResetChecksum()) 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 != IicTransmit(TLSys_DemodulatorI2CAddress(I2CWRITE),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){ 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 != IicTransmit(TLSys_DemodulatorI2CAddress(I2CWRITE), puc2BCodeBuffer, i2BCodeSize)){ return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED; } //Send data buffer if(IIC_COM_SUCCESS != IicTransmit(TLSys_DemodulatorI2CAddress(I2CWRITE), puc2BDataBuffer, i2BDataSize)){ 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 0//사용하지 않는다. 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(stChannelScanParameters.iTunerType < TUNER_DTT7611) ulTmpFrequency = TunerDTT7611GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); else ulTmpFrequency = TunerDTT7612GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); } 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; } //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; } else{//TUNER_DTT7612 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; } if(TRUE == stChannelScanParameters.bPerformCascadeChannelChange){ //wait the tuner delay #if 1 Demux_STCDelay(stChannelScanParameters.ulDelay/11000); #else ulWait = stChannelScanParameters.ulDelay; while(ulWait) ulWait--; #endif //send the cascade channel change only if it is needed if(CAS_2B_API_SUCCESS != Cas2BChannelChange(stChannelChangeParameters)){ break; } } #if 1 Demux_STCDelay(stChannelScanParameters.ulDelay/11000); #else ulWait = stChannelScanParameters.ulDelay; while(ulWait) ulWait--; #endif //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){ Demux_STCDelay(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(stChannelScanParameters.iTunerType < TUNER_DTT7611) ulTmpFrequency = TunerDTT7611GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); else ulTmpFrequency = TunerDTT7612GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType); } 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 unsigned char GetSignalQuality(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError) { unsigned char ucSnrMin,ucSnrMax,ucSnrValue,ucSignalQuality,ucSNRSignalQuality; unsigned char ucSERSignalQuality,uc1SecSERValue; LOCK_STATUS iLockStatus; 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; 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{ 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; } unsigned long GetSignalStrength(int * piError, TYPE_AGC_AMPLIFIER iAGCAmplifierType) { NUMERATOR_DENOMINATOR stAGCSensor,stIFAGCCommand; unsigned long ulSignalStrength; 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(ulSignalStrength > 100) ulSignalStrength = 100; return ulSignalStrength; } 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_MONO1_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; 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){ Demux_STCDelay(90 * ulDelay);/* 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 //*************************************************************************