--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/090730_RTL2832U_LINUX_Ver1.1.patch Wed Oct 27 09:27:24 2010 +0200
@@ -0,0 +1,27536 @@
+# HG changeset patch
+# Parent abd3aac6644e1a31020f4cdfdee84bde7ca1e1b4
+Import of 090730_RTL2832U_LINUX_Ver1.1.rar into ./linux/drivers/media/dvb/dvb-usb/
+
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/demod_rtl2832.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/demod_rtl2832.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,2828 @@
++/**
++
++@file
++
++@brief RTL2832 demod module definition
++
++One can manipulate RTL2832 demod through RTL2832 module.
++RTL2832 module is derived from DVB-T demod module.
++
++*/
++
++
++#include "demod_rtl2832.h"
++
++
++
++
++
++/**
++
++@brief RTL2832 demod module builder
++
++Use BuildRtl2832Module() to build RTL2832 module, set all module function pointers with the corresponding
++functions, and initialize module private variables.
++
++
++@param [in] ppDemod Pointer to RTL2832 demod module pointer
++@param [in] pDvbtDemodModuleMemory Pointer to an allocated DVB-T demod module memory
++@param [in] pRtl2832ExtraModuleMemory Pointer to an allocated RTL2832 extra module memory
++@param [in] pBaseInterfaceModuleMemory Pointer to an allocated base interface module memory
++@param [in] pI2cBridgeModuleMemory Pointer to an allocated I2C bridge module memory
++@param [in] DeviceAddr RTL2832 I2C device address
++@param [in] CrystalFreqHz RTL2832 crystal frequency in Hz
++@param [in] AppMode RTL2832 application mode for setting
++@param [in] UpdateFuncRefPeriodMs RTL2832 update function reference period in millisecond for setting
++@param [in] IsFunc1Enabled RTL2832 Function 1 enabling status for setting
++
++
++@note
++ -# One should call BuildRtl2832Module() to build RTL2832 module before using it.
++
++*/
++void
++BuildRtl2832Module(
++ DVBT_DEMOD_MODULE **ppDemod,
++ DVBT_DEMOD_MODULE *pDvbtDemodModuleMemory,
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr,
++ unsigned long CrystalFreqHz,
++ int AppMode,
++ unsigned long UpdateFuncRefPeriodMs,
++ int IsFunc1Enabled
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ RTL2832_EXTRA_MODULE *pExtra;
++
++
++
++ // Set demod module pointer,
++ *ppDemod = pDvbtDemodModuleMemory;
++
++ // Get demod module.
++ pDemod = *ppDemod;
++
++ // Set demod extra module pointer, base interface module pointer, and I2C bridge module pointer.
++ pDemod->pExtra = pRtl2832ExtraModuleMemory;
++ pDemod->pBaseInterface = pBaseInterfaceModuleMemory;
++ pDemod->pI2cBridge = pI2cBridgeModuleMemory;
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Set demod type.
++ pDemod->DemodType = DVBT_DEMOD_TYPE_RTL2832;
++
++ // Set demod I2C device address.
++ pDemod->DeviceAddr = DeviceAddr;
++
++ // Set demod crystal frequency in Hz.
++ pDemod->CrystalFreqHz = CrystalFreqHz;
++
++
++ // Initialize demod parameter setting status
++ pDemod->IsBandwidthModeSet = NO;
++ pDemod->IsIfFreqHzSet = NO;
++ pDemod->IsSpectrumModeSet = NO;
++
++
++ // Initialize demod register table.
++ rtl2832_InitRegTable(pDemod);
++
++
++ // Set I2C bridge demod arguments.
++ rtl2832_SetI2cBridgeModuleDemodArg(pDemod);
++
++
++ // Set demod module I2C function pointers with default functions.
++ pDemod->SetRegPage = dvbt_demod_default_SetRegPage;
++ pDemod->SetRegBytes = dvbt_demod_default_SetRegBytes;
++ pDemod->GetRegBytes = dvbt_demod_default_GetRegBytes;
++ pDemod->SetRegMaskBits = dvbt_demod_default_SetRegMaskBits;
++ pDemod->GetRegMaskBits = dvbt_demod_default_GetRegMaskBits;
++ pDemod->SetRegBits = dvbt_demod_default_SetRegBits;
++ pDemod->GetRegBits = dvbt_demod_default_GetRegBits;
++ pDemod->SetRegBitsWithPage = dvbt_demod_default_SetRegBitsWithPage;
++ pDemod->GetRegBitsWithPage = dvbt_demod_default_GetRegBitsWithPage;
++
++
++ // Set demod module manipulating function pointers with default functions.
++ pDemod->GetDemodType = dvbt_demod_default_GetDemodType;
++ pDemod->GetDeviceAddr = dvbt_demod_default_GetDeviceAddr;
++ pDemod->GetCrystalFreqHz = dvbt_demod_default_GetCrystalFreqHz;
++
++ pDemod->GetBandwidthMode = dvbt_demod_default_GetBandwidthMode;
++ pDemod->GetIfFreqHz = dvbt_demod_default_GetIfFreqHz;
++ pDemod->GetSpectrumMode = dvbt_demod_default_GetSpectrumMode;
++
++
++ // Set demod module manipulating function pointers with particular functions.
++ pDemod->IsConnectedToI2c = rtl2832_IsConnectedToI2c;
++ pDemod->SoftwareReset = rtl2832_SoftwareReset;
++ pDemod->Initialize = rtl2832_Initialize;
++ pDemod->SetBandwidthMode = rtl2832_SetBandwidthMode;
++ pDemod->SetIfFreqHz = rtl2832_SetIfFreqHz;
++ pDemod->SetSpectrumMode = rtl2832_SetSpectrumMode;
++
++ pDemod->IsTpsLocked = rtl2832_IsTpsLocked;
++ pDemod->IsSignalLocked = rtl2832_IsSignalLocked;
++
++ pDemod->GetSignalStrength = rtl2832_GetSignalStrength;
++ pDemod->GetSignalQuality = rtl2832_GetSignalQuality;
++
++ pDemod->GetBer = rtl2832_GetBer;
++ pDemod->GetSnrDb = rtl2832_GetSnrDb;
++
++ pDemod->GetRfAgc = rtl2832_GetRfAgc;
++ pDemod->GetIfAgc = rtl2832_GetIfAgc;
++ pDemod->GetDiAgc = rtl2832_GetDiAgc;
++
++ pDemod->GetTrOffsetPpm = rtl2832_GetTrOffsetPpm;
++ pDemod->GetCrOffsetHz = rtl2832_GetCrOffsetHz;
++
++ pDemod->GetConstellation = rtl2832_GetConstellation;
++ pDemod->GetHierarchy = rtl2832_GetHierarchy;
++ pDemod->GetCodeRateLp = rtl2832_GetCodeRateLp;
++ pDemod->GetCodeRateHp = rtl2832_GetCodeRateHp;
++ pDemod->GetGuardInterval = rtl2832_GetGuardInterval;
++ pDemod->GetFftMode = rtl2832_GetFftMode;
++
++ pDemod->UpdateFunction = rtl2832_UpdateFunction;
++ pDemod->ResetFunction = rtl2832_ResetFunction;
++
++
++ // Initialize demod extra module variables.
++ pExtra->AppMode = AppMode;
++
++
++ // Initialize demod Function 1 variables.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_NORMAL;
++
++ pExtra->IsFunc1Enabled = IsFunc1Enabled;
++
++ pExtra->Func1WaitTimeMax = DivideWithCeiling(RTL2832_FUNC1_WAIT_TIME_MS, UpdateFuncRefPeriodMs);
++ pExtra->Func1GettingTimeMax = DivideWithCeiling(RTL2832_FUNC1_GETTING_TIME_MS, UpdateFuncRefPeriodMs);
++ pExtra->Func1GettingNumEachTime = DivideWithCeiling(RTL2832_FUNC1_GETTING_NUM_MIN, pExtra->Func1GettingTimeMax + 1);
++
++ pExtra->Func1QamBak = 0xff;
++ pExtra->Func1HierBak = 0xff;
++ pExtra->Func1LpCrBak = 0xff;
++ pExtra->Func1HpCrBak = 0xff;
++ pExtra->Func1GiBak = 0xff;
++ pExtra->Func1FftBak = 0xff;
++
++
++ // Set demod extra module function pointers.
++ pExtra->GetAppMode = rtl2832_GetAppMode;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_IS_CONNECTED_TO_I2C
++
++*/
++void
++rtl2832_IsConnectedToI2c(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ )
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned char Nothing;
++
++
++
++ // Get base interface.
++ pBaseInterface = pDemod->pBaseInterface;
++
++
++ // Send read command.
++ // Note: The number of reading bytes must be greater than 0.
++ if(pBaseInterface->I2cRead(pBaseInterface, pDemod->DeviceAddr, &Nothing, LEN_1_BYTE) == FUNCTION_ERROR)
++ goto error_status_i2c_read;
++
++
++ // Set I2cConnectionStatus with YES.
++ *pAnswer = YES;
++
++
++ return;
++
++
++error_status_i2c_read:
++
++ // Set I2cConnectionStatus with NO.
++ *pAnswer = NO;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SOFTWARE_RESET
++
++*/
++int
++rtl2832_SoftwareReset(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ // Set SOFT_RST with 1. Then, set SOFT_RST with 0.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SOFT_RST, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SOFT_RST, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_INITIALIZE
++
++*/
++int
++rtl2832_Initialize(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ // Initializing table entry only used in Initialize()
++ typedef struct
++ {
++ int RegBitName;
++ unsigned long WritingValue;
++ }
++ INIT_TABLE_ENTRY;
++
++ // Initializing table entry with mode only used in Initialize()
++ typedef struct
++ {
++ int RegBitName;
++ unsigned long WritingValue[RTL2832_APPLICATION_MODE_NUM];
++ }
++ INIT_TABLE_ENTRY_WITH_MODE;
++
++
++
++ static const INIT_TABLE_ENTRY InitTable[RTL2832_INIT_TABLE_LEN] =
++ {
++ // RegBitName, WritingValue
++ {DVBT_AD_EN_REG, 0x1 },
++ {DVBT_AD_EN_REG1, 0x1 },
++ {DVBT_RSD_BER_FAIL_VAL, 0x2800 },
++ {DVBT_MGD_THD0, 0x10 },
++ {DVBT_MGD_THD1, 0x20 },
++ {DVBT_MGD_THD2, 0x20 },
++ {DVBT_MGD_THD3, 0x40 },
++ {DVBT_MGD_THD4, 0x22 },
++ {DVBT_MGD_THD5, 0x32 },
++ {DVBT_MGD_THD6, 0x37 },
++ {DVBT_MGD_THD7, 0x39 },
++ {DVBT_EN_BK_TRK, 0x0 },
++ {DVBT_EN_CACQ_NOTCH, 0x0 },
++ {DVBT_AD_AV_REF, 0x2a },
++ {DVBT_REG_PI, 0x3 },
++ {DVBT_PIP_ON, 0x0 },
++ {DVBT_CDIV_PH0, 0x8 },
++ {DVBT_CDIV_PH1, 0x8 },
++ {DVBT_SCALE1_B92, 0x4 },
++ {DVBT_SCALE1_B93, 0xb0 },
++ {DVBT_SCALE1_BA7, 0x78 },
++ {DVBT_SCALE1_BA9, 0x28 },
++ {DVBT_SCALE1_BAA, 0x59 },
++ {DVBT_SCALE1_BAB, 0x83 },
++ {DVBT_SCALE1_BAC, 0xd4 },
++ {DVBT_SCALE1_BB0, 0x65 },
++ {DVBT_SCALE1_BB1, 0x43 },
++ {DVBT_KB_P1, 0x1 },
++ {DVBT_KB_P2, 0x4 },
++ {DVBT_KB_P3, 0x7 },
++ {DVBT_K1_CR_STEP12, 0xa },
++ };
++
++ static const INIT_TABLE_ENTRY_WITH_MODE InitTableWithAppMode[RTL2832_INIT_TABLE_LEN_WITH_APP_MODE] =
++ {
++ // RegBitName, WritingValue for {Dongle, STB}
++ {DVBT_TRK_KS_P2, {0x4, 0x4}},
++ {DVBT_TRK_KS_I2, {0x7, 0x7}},
++ {DVBT_TR_THD_SET2, {0x6, 0x6}},
++ {DVBT_TRK_KC_I2, {0x5, 0x6}},
++ {DVBT_CR_THD_SET2, {0x1, 0x1}},
++ };
++
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ RTL2832_EXTRA_MODULE *pExtra;
++
++ int i;
++
++ int AppMode;
++
++
++
++ // Get base interface and demod extra module.
++ pBaseInterface = pDemod->pBaseInterface;
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++ // Get application mode.
++ pExtra->GetAppMode(pDemod, &AppMode);
++
++
++ // Initialize demod registers according to the initializing table.
++ for(i = 0; i < RTL2832_INIT_TABLE_LEN; i++)
++ {
++ if(pDemod->SetRegBitsWithPage(pDemod, InitTable[i].RegBitName, InitTable[i].WritingValue)
++ != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++ }
++
++
++ // Initialize demod registers according to the initializing table with application mode.
++ for(i = 0; i < RTL2832_INIT_TABLE_LEN_WITH_APP_MODE; i++)
++ {
++ if(pDemod->SetRegBitsWithPage(pDemod, InitTableWithAppMode[i].RegBitName,
++ InitTableWithAppMode[i].WritingValue[AppMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_BANDWIDTH_MODE
++
++*/
++int
++rtl2832_SetBandwidthMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int BandwidthMode
++ )
++{
++ static const unsigned char HlpfxTable[DVBT_BANDWIDTH_MODE_NUM][RTL2832_H_LPF_X_LEN] =
++ {
++ // H_LPF_X writing value for 6 MHz bandwidth
++ {
++ 0xf5, 0xff, 0x15, 0x38, 0x5d, 0x6d, 0x52, 0x07, 0xfa, 0x2f,
++ 0x53, 0xf5, 0x3f, 0xca, 0x0b, 0x91, 0xea, 0x30, 0x63, 0xb2,
++ 0x13, 0xda, 0x0b, 0xc4, 0x18, 0x7e, 0x16, 0x66, 0x08, 0x67,
++ 0x19, 0xe0,
++ },
++
++ // H_LPF_X writing value for 7 MHz bandwidth
++ {
++ 0xe7, 0xcc, 0xb5, 0xba, 0xe8, 0x2f, 0x67, 0x61, 0x00, 0xaf,
++ 0x86, 0xf2, 0xbf, 0x59, 0x04, 0x11, 0xb6, 0x33, 0xa4, 0x30,
++ 0x15, 0x10, 0x0a, 0x42, 0x18, 0xf8, 0x17, 0xd9, 0x07, 0x22,
++ 0x19, 0x10,
++ },
++
++ // H_LPF_X writing value for 8 MHz bandwidth
++ {
++ 0x09, 0xf6, 0xd2, 0xa7, 0x9a, 0xc9, 0x27, 0x77, 0x06, 0xbf,
++ 0xec, 0xf4, 0x4f, 0x0b, 0xfc, 0x01, 0x63, 0x35, 0x54, 0xa7,
++ 0x16, 0x66, 0x08, 0xb4, 0x19, 0x6e, 0x19, 0x65, 0x05, 0xc8,
++ 0x19, 0xe0,
++ },
++ };
++
++
++ unsigned long CrystalFreqHz;
++
++ long ConstWithBandwidthMode;
++
++ MPI MpiCrystalFreqHz;
++ MPI MpiConst, MpiVar0, MpiVar1, MpiNone;
++
++ unsigned long RsampRatio;
++
++ long CfreqOffRatioInt;
++ unsigned long CfreqOffRatioBinary;
++
++
++
++ // Get demod crystal frequency in Hz.
++ pDemod->GetCrystalFreqHz(pDemod, &CrystalFreqHz);
++
++
++ // Set H_LPF_X registers with HlpfxTable according to BandwidthMode.
++ if(pDemod->SetRegPage(pDemod, RTL2832_H_LPF_X_PAGE) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBytes(pDemod, RTL2832_H_LPF_X_ADDR, HlpfxTable[BandwidthMode], RTL2832_H_LPF_X_LEN) !=
++ FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Determine constant value with bandwidth mode.
++ switch(BandwidthMode)
++ {
++ default:
++ case DVBT_BANDWIDTH_6MHZ: ConstWithBandwidthMode = 48000000; break;
++ case DVBT_BANDWIDTH_7MHZ: ConstWithBandwidthMode = 56000000; break;
++ case DVBT_BANDWIDTH_8MHZ: ConstWithBandwidthMode = 64000000; break;
++ }
++
++
++ // Calculate RSAMP_RATIO value.
++ // Note: RSAMP_RATIO = floor(CrystalFreqHz * 7 * pow(2, 22) / ConstWithBandwidthMode)
++ MpiSetValue(&MpiCrystalFreqHz, CrystalFreqHz);
++ MpiSetValue(&MpiVar1, ConstWithBandwidthMode);
++ MpiSetValue(&MpiConst, 7);
++
++ MpiMul(&MpiVar0, MpiCrystalFreqHz, MpiConst);
++ MpiLeftShift(&MpiVar0, MpiVar0, 22);
++ MpiDiv(&MpiVar0, &MpiNone, MpiVar0, MpiVar1);
++
++ MpiGetValue(MpiVar0, (long *)&RsampRatio);
++
++
++ // Set RSAMP_RATIO with calculated value.
++ // Note: Use SetRegBitsWithPage() to set register bits with page setting.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_RSAMP_RATIO, RsampRatio) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Calculate CFREQ_OFF_RATIO value.
++ // Note: CFREQ_OFF_RATIO = - floor(ConstWithBandwidthMode * pow(2, 20) / (CrystalFreqHz * 7))
++ MpiSetValue(&MpiCrystalFreqHz, CrystalFreqHz);
++ MpiSetValue(&MpiVar0, ConstWithBandwidthMode);
++ MpiSetValue(&MpiConst, 7);
++
++ MpiLeftShift(&MpiVar0, MpiVar0, 20);
++ MpiMul(&MpiVar1, MpiCrystalFreqHz, MpiConst);
++ MpiDiv(&MpiVar0, &MpiNone, MpiVar0, MpiVar1);
++
++ MpiGetValue(MpiVar0, &CfreqOffRatioInt);
++ CfreqOffRatioInt = - CfreqOffRatioInt;
++
++ CfreqOffRatioBinary = SignedIntToBin(CfreqOffRatioInt, RTL2832_CFREQ_OFF_RATIO_BIT_NUM);
++
++
++ // Set CFREQ_OFF_RATIO with calculated value.
++ // Note: Use SetRegBitsWithPage() to set register bits with page setting.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CFREQ_OFF_RATIO, CfreqOffRatioBinary) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++
++ // Set demod bandwidth mode parameter.
++ pDemod->BandwidthMode = BandwidthMode;
++ pDemod->IsBandwidthModeSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_IF_FREQ_HZ
++
++*/
++int
++rtl2832_SetIfFreqHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long IfFreqHz
++ )
++{
++ unsigned long CrystalFreqHz;
++
++ unsigned long EnBbin;
++
++ MPI MpiCrystalFreqHz, MpiVar, MpiNone;
++
++ long PsetIffreqInt;
++ unsigned long PsetIffreqBinary;
++
++
++
++ // Get demod crystal frequency in Hz.
++ pDemod->GetCrystalFreqHz(pDemod, &CrystalFreqHz);
++
++
++ // Determine and set EN_BBIN value.
++ EnBbin = (IfFreqHz == IF_FREQ_0HZ) ? 0x1 : 0x0;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_EN_BBIN, EnBbin) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Calculate PSET_IFFREQ value.
++ // Note: PSET_IFFREQ = - floor((IfFreqHz % CrystalFreqHz) * pow(2, 22) / CrystalFreqHz)
++ MpiSetValue(&MpiCrystalFreqHz, CrystalFreqHz);
++
++ MpiSetValue(&MpiVar, (IfFreqHz % CrystalFreqHz));
++ MpiLeftShift(&MpiVar, MpiVar, RTL2832_PSET_IFFREQ_BIT_NUM);
++ MpiDiv(&MpiVar, &MpiNone, MpiVar, MpiCrystalFreqHz);
++
++ MpiGetValue(MpiVar, &PsetIffreqInt);
++ PsetIffreqInt = - PsetIffreqInt;
++
++ PsetIffreqBinary = SignedIntToBin(PsetIffreqInt, RTL2832_PSET_IFFREQ_BIT_NUM);
++
++
++ // Set PSET_IFFREQ with calculated value.
++ // Note: Use SetRegBitsWithPage() to set register bits with page setting.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_PSET_IFFREQ, PsetIffreqBinary) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Set demod IF frequnecy parameter.
++ pDemod->IfFreqHz = IfFreqHz;
++ pDemod->IsIfFreqHzSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_SPECTRUM_MODE
++
++*/
++int
++rtl2832_SetSpectrumMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int SpectrumMode
++ )
++{
++ unsigned long SpecInv;
++
++
++
++ // Determine SpecInv according to spectrum mode.
++ switch(SpectrumMode)
++ {
++ default:
++ case SPECTRUM_NORMAL: SpecInv = 0; break;
++ case SPECTRUM_INVERSE: SpecInv = 1; break;
++ }
++
++
++ // Set SPEC_INV with SpecInv.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SPEC_INV, SpecInv) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Set demod spectrum mode parameter.
++ pDemod->SpectrumMode = SpectrumMode;
++ pDemod->IsSpectrumModeSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_IS_TPS_LOCKED
++
++*/
++int
++rtl2832_IsTpsLocked(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ )
++{
++ unsigned long FsmStage;
++
++
++
++ // Get FSM stage from FSM_STAGE.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_FSM_STAGE, &FsmStage) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // Determine answer according to FSM stage.
++ if(FsmStage > 9)
++ *pAnswer = YES;
++ else
++ *pAnswer = NO;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_IS_SIGNAL_LOCKED
++
++*/
++int
++rtl2832_IsSignalLocked(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ )
++{
++ unsigned long FsmStage;
++
++
++
++ // Get FSM stage from FSM_STAGE.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_FSM_STAGE, &FsmStage) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // Determine answer according to FSM stage.
++ if(FsmStage == 11)
++ *pAnswer = YES;
++ else
++ *pAnswer = NO;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_SIGNAL_STRENGTH
++
++*/
++int
++rtl2832_GetSignalStrength(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pSignalStrength
++ )
++{
++ unsigned long FsmStage;
++ int IfAgc;
++
++
++
++ // Get FSM stage and IF AGC value.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_FSM_STAGE, &FsmStage) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ if(pDemod->GetIfAgc(pDemod, &IfAgc) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // Determine signal strength according to FSM stage and IF AGC value.
++ if(FsmStage < 10)
++ *pSignalStrength = 0;
++ else
++ *pSignalStrength = 55 - IfAgc / 182;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_SIGNAL_QUALITY
++
++*/
++int
++rtl2832_GetSignalQuality(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pSignalQuality
++ )
++{
++ unsigned long FsmStage, RsdBerEst;
++
++ MPI MpiVar;
++ long Var;
++
++
++
++ // Get FSM_STAGE and RSD_BER_EST.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_FSM_STAGE, &FsmStage) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RSD_BER_EST, &RsdBerEst) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // If demod is not signal-locked, set signal quality with zero.
++ if(FsmStage < 10)
++ {
++ *pSignalQuality = 0;
++ goto success_status_non_signal_lock;
++ }
++
++ // Determine signal quality according to RSD_BER_EST.
++ // Note: Map RSD_BER_EST value 8192 ~ 128 to 10 ~ 100
++ // Original formula: SignalQuality = 205 - 15 * log2(RSD_BER_EST)
++ // Adjusted formula: SignalQuality = ((205 << 5) - 15 * (log2(RSD_BER_EST) << 5)) >> 5
++ // If RSD_BER_EST > 8192, signal quality is 10.
++ // If RSD_BER_EST < 128, signal quality is 100.
++ if(RsdBerEst > 8192)
++ {
++ *pSignalQuality = 10;
++ }
++ else if(RsdBerEst < 128)
++ {
++ *pSignalQuality = 100;
++ }
++ else
++ {
++ MpiSetValue(&MpiVar, RsdBerEst);
++ MpiLog2(&MpiVar, MpiVar, RTL2832_SQ_FRAC_BIT_NUM);
++ MpiGetValue(MpiVar, &Var);
++
++ *pSignalQuality = ((205 << RTL2832_SQ_FRAC_BIT_NUM) - 15 * Var) >> RTL2832_SQ_FRAC_BIT_NUM;
++ }
++
++
++success_status_non_signal_lock:
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_BER
++
++*/
++int
++rtl2832_GetBer(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pBerNum,
++ unsigned long *pBerDen
++ )
++{
++ unsigned long RsdBerEst;
++
++
++
++ // Get RSD_BER_EST.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RSD_BER_EST, &RsdBerEst) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // Set BER numerator according to RSD_BER_EST.
++ *pBerNum = RsdBerEst;
++
++ // Set BER denominator.
++ *pBerDen = RTL2832_BER_DEN_VALUE;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_SNR_DB
++
++*/
++int
++rtl2832_GetSnrDb(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pSnrDbNum,
++ long *pSnrDbDen
++ )
++{
++ unsigned long FsmStage;
++ unsigned long CeEstEvm;
++ int Constellation, Hierarchy;
++
++ static const long SnrDbNumConst[DVBT_CONSTELLATION_NUM][DVBT_HIERARCHY_NUM] =
++ {
++ {122880, 122880, 122880, 122880, },
++ {146657, 146657, 156897, 171013, },
++ {167857, 167857, 173127, 181810, },
++ };
++
++ long Var;
++ MPI MpiCeEstEvm, MpiVar;
++
++
++
++ // Get FSM stage, CE_EST_EVM, constellation, and hierarchy.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_FSM_STAGE, &FsmStage) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_CE_EST_EVM, &CeEstEvm) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ if(pDemod->GetConstellation(pDemod, &Constellation) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ if(pDemod->GetHierarchy(pDemod, &Hierarchy) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++
++ // SNR dB formula
++ // Original formula: SNR_dB = 10 * log10(Norm * pow(2, 11) / CeEstEvm)
++ // Adjusted formula: SNR_dB = (SNR_DB_NUM_CONST - 10 * log2(CeEstEvm) * pow(2, SNR_FRAC_BIT_NUM)) / SNR_DB_DEN
++ // SNR_DB_NUM_CONST = 10 * log2(Norm * pow(2, 11)) * pow(2, SNR_FRAC_BIT_NUM)
++ // SNR_DB_DEN = log2(10) * pow(2, SNR_FRAC_BIT_NUM)
++ // Norm:
++ // None Alpha=1 Alpha=2 Alpha=4
++ // 4-QAM 2 2 2 2
++ // 16-QAM 10 10 20 52
++ // 64-QAM 42 42 60 108
++
++
++ // If FSM stage < 10, set CE_EST_EVM with max value.
++ if(FsmStage < 10)
++ CeEstEvm = RTL2832_CE_EST_EVM_MAX_VALUE;
++
++
++ // Calculate SNR dB numerator.
++ MpiSetValue(&MpiCeEstEvm, CeEstEvm);
++
++ MpiLog2(&MpiVar, MpiCeEstEvm, RTL2832_SNR_FRAC_BIT_NUM);
++
++ MpiGetValue(MpiVar, &Var);
++
++ *pSnrDbNum = SnrDbNumConst[Constellation][Hierarchy] - 10 * Var;
++
++
++ // Set SNR dB denominator.
++ *pSnrDbDen = RTL2832_SNR_DB_DEN;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_RF_AGC
++
++*/
++int
++rtl2832_GetRfAgc(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pRfAgc
++ )
++{
++ unsigned long Value;
++
++
++
++ // Get RF_AGC_VAL to Value.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RF_AGC_VAL, &Value) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // Convert Value to signed integer and store the signed integer to RfAgc.
++ *pRfAgc = (int)BinToSignedInt(Value, RTL2832_RF_AGC_REG_BIT_NUM);
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_IF_AGC
++
++*/
++int
++rtl2832_GetIfAgc(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pIfAgc
++ )
++{
++ unsigned long Value;
++
++
++
++ // Get IF_AGC_VAL to Value.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_IF_AGC_VAL, &Value) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // Convert Value to signed integer and store the signed integer to IfAgc.
++ *pIfAgc = (int)BinToSignedInt(Value, RTL2832_IF_AGC_REG_BIT_NUM);
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_DI_AGC
++
++*/
++int
++rtl2832_GetDiAgc(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char *pDiAgc
++ )
++{
++ unsigned long Value;
++
++
++
++ // Get DAGC_VAL to DiAgc.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_DAGC_VAL, &Value) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ *pDiAgc = (unsigned char)Value;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_TR_OFFSET_PPM
++
++*/
++int
++rtl2832_GetTrOffsetPpm(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pTrOffsetPpm
++ )
++{
++ unsigned long SfreqOffBinary;
++ long SfreqOffInt;
++
++ MPI MpiSfreqOffInt;
++ MPI MpiConst, MpiVar;
++
++
++ // Get SfreqOff binary value from SFREQ_OFF register bits.
++ // Note: The function GetRegBitsWithPage() will set register page automatically.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_SFREQ_OFF, &SfreqOffBinary) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_registers;
++
++ // Convert SfreqOff binary value to signed integer.
++ SfreqOffInt = BinToSignedInt(SfreqOffBinary, RTL2832_SFREQ_OFF_BIT_NUM);
++
++
++ // Get TR offset in ppm.
++ // Note: Original formula: TrOffsetPpm = (SfreqOffInt * 1000000) / pow(2, 24)
++ // Adjusted formula: TrOffsetPpm = (SfreqOffInt * 1000000) >> 24
++ MpiSetValue(&MpiSfreqOffInt, SfreqOffInt);
++ MpiSetValue(&MpiConst, 1000000);
++
++ MpiMul(&MpiVar, MpiSfreqOffInt, MpiConst);
++ MpiRightShift(&MpiVar, MpiVar, 24);
++
++ MpiGetValue(MpiVar, pTrOffsetPpm);
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_demod_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_CR_OFFSET_HZ
++
++*/
++int
++rtl2832_GetCrOffsetHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pCrOffsetHz
++ )
++{
++ int BandwidthMode;
++ int FftMode;
++
++ unsigned long CfreqOffBinary;
++ long CfreqOffInt;
++
++ long ConstWithBandwidthMode, ConstWithFftMode;
++
++ MPI MpiCfreqOffInt;
++ MPI MpiConstWithBandwidthMode, MpiConstWithFftMode;
++ MPI MpiConst, MpiVar0, MpiVar1, MpiNone;
++
++
++
++ // Get demod bandwidth mode.
++ if(pDemod->GetBandwidthMode(pDemod, &BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_bandwidth_mode;
++
++
++ // Get demod FFT mode.
++ if(pDemod->GetFftMode(pDemod, &FftMode) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_registers;
++
++
++ // Get CfreqOff binary value from CFREQ_OFF register bits.
++ // Note: The function GetRegBitsWithPage() will set register page automatically.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_CFREQ_OFF, &CfreqOffBinary) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_registers;
++
++ // Convert CfreqOff binary value to signed integer.
++ CfreqOffInt = BinToSignedInt(CfreqOffBinary, RTL2832_CFREQ_OFF_BIT_NUM);
++
++
++ // Determine constant value with bandwidth mode.
++ switch(BandwidthMode)
++ {
++ default:
++ case DVBT_BANDWIDTH_6MHZ: ConstWithBandwidthMode = 48000000; break;
++ case DVBT_BANDWIDTH_7MHZ: ConstWithBandwidthMode = 56000000; break;
++ case DVBT_BANDWIDTH_8MHZ: ConstWithBandwidthMode = 64000000; break;
++ }
++
++
++ // Determine constant value with FFT mode.
++ switch(FftMode)
++ {
++ default:
++ case DVBT_FFT_MODE_2K: ConstWithFftMode = 2048; break;
++ case DVBT_FFT_MODE_8K: ConstWithFftMode = 8192; break;
++ }
++
++
++ // Get Cr offset in Hz.
++ // Note: Original formula: CrOffsetHz = (CfreqOffInt * ConstWithBandwidthMode) / (ConstWithFftMode * 7 * 128)
++ // Adjusted formula: CrOffsetHz = (CfreqOffInt * ConstWithBandwidthMode) / ((ConstWithFftMode * 7) << 7)
++ MpiSetValue(&MpiCfreqOffInt, CfreqOffInt);
++ MpiSetValue(&MpiConstWithBandwidthMode, ConstWithBandwidthMode);
++ MpiSetValue(&MpiConstWithFftMode, ConstWithFftMode);
++ MpiSetValue(&MpiConst, 7);
++
++ MpiMul(&MpiVar0, MpiCfreqOffInt, MpiConstWithBandwidthMode);
++ MpiMul(&MpiVar1, MpiConstWithFftMode, MpiConst);
++ MpiLeftShift(&MpiVar1, MpiVar1, 7);
++ MpiDiv(&MpiVar0, &MpiNone, MpiVar0, MpiVar1);
++
++ MpiGetValue(MpiVar0, pCrOffsetHz);
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_demod_registers:
++error_status_get_demod_bandwidth_mode:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_CONSTELLATION
++
++*/
++int
++rtl2832_GetConstellation(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pConstellation
++ )
++{
++ unsigned long ReadingValue;
++
++
++ // Get TPS constellation information from RX_CONSTEL.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RX_CONSTEL, &ReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ switch(ReadingValue)
++ {
++ default:
++ case 0: *pConstellation = DVBT_CONSTELLATION_QPSK; break;
++ case 1: *pConstellation = DVBT_CONSTELLATION_16QAM; break;
++ case 2: *pConstellation = DVBT_CONSTELLATION_64QAM; break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_HIERARCHY
++
++*/
++int
++rtl2832_GetHierarchy(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pHierarchy
++ )
++{
++ unsigned long ReadingValue;
++
++
++ // Get TPS hierarchy infromation from RX_HIER.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RX_HIER, &ReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ switch(ReadingValue)
++ {
++ default:
++ case 0: *pHierarchy = DVBT_HIERARCHY_NONE; break;
++ case 1: *pHierarchy = DVBT_HIERARCHY_ALPHA_1; break;
++ case 2: *pHierarchy = DVBT_HIERARCHY_ALPHA_2; break;
++ case 3: *pHierarchy = DVBT_HIERARCHY_ALPHA_4; break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_CODE_RATE_LP
++
++*/
++int
++rtl2832_GetCodeRateLp(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pCodeRateLp
++ )
++{
++ unsigned long ReadingValue;
++
++
++ // Get TPS low-priority code rate infromation from RX_C_RATE_LP.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RX_C_RATE_LP, &ReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ switch(ReadingValue)
++ {
++ default:
++ case 0: *pCodeRateLp = DVBT_CODE_RATE_1_OVER_2; break;
++ case 1: *pCodeRateLp = DVBT_CODE_RATE_2_OVER_3; break;
++ case 2: *pCodeRateLp = DVBT_CODE_RATE_3_OVER_4; break;
++ case 3: *pCodeRateLp = DVBT_CODE_RATE_5_OVER_6; break;
++ case 4: *pCodeRateLp = DVBT_CODE_RATE_7_OVER_8; break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_CODE_RATE_HP
++
++*/
++int
++rtl2832_GetCodeRateHp(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pCodeRateHp
++ )
++{
++ unsigned long ReadingValue;
++
++
++ // Get TPS high-priority code rate infromation from RX_C_RATE_HP.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RX_C_RATE_HP, &ReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ switch(ReadingValue)
++ {
++ default:
++ case 0: *pCodeRateHp = DVBT_CODE_RATE_1_OVER_2; break;
++ case 1: *pCodeRateHp = DVBT_CODE_RATE_2_OVER_3; break;
++ case 2: *pCodeRateHp = DVBT_CODE_RATE_3_OVER_4; break;
++ case 3: *pCodeRateHp = DVBT_CODE_RATE_5_OVER_6; break;
++ case 4: *pCodeRateHp = DVBT_CODE_RATE_7_OVER_8; break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_GUARD_INTERVAL
++
++*/
++int
++rtl2832_GetGuardInterval(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pGuardInterval
++ )
++{
++ unsigned long ReadingValue;
++
++
++ // Get TPS guard interval infromation from GI_IDX.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_GI_IDX, &ReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ switch(ReadingValue)
++ {
++ default:
++ case 0: *pGuardInterval = DVBT_GUARD_INTERVAL_1_OVER_32; break;
++ case 1: *pGuardInterval = DVBT_GUARD_INTERVAL_1_OVER_16; break;
++ case 2: *pGuardInterval = DVBT_GUARD_INTERVAL_1_OVER_8; break;
++ case 3: *pGuardInterval = DVBT_GUARD_INTERVAL_1_OVER_4; break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_FFT_MODE
++
++*/
++int
++rtl2832_GetFftMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pFftMode
++ )
++{
++ unsigned long ReadingValue;
++
++
++ // Get TPS FFT mode infromation from FFT_MODE_IDX.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_FFT_MODE_IDX, &ReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ switch(ReadingValue)
++ {
++ default:
++ case 0: *pFftMode = DVBT_FFT_MODE_2K; break;
++ case 1: *pFftMode = DVBT_FFT_MODE_8K; break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_UPDATE_FUNCTION
++
++*/
++int
++rtl2832_UpdateFunction(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Execute Function 1 according to Function 1 enabling status
++ if(pExtra->IsFunc1Enabled == YES)
++ {
++ if(rtl2832_func1_Update(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_RESET_FUNCTION
++
++*/
++int
++rtl2832_ResetFunction(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Reset Function 1 settings according to Function 1 enabling status.
++ if(pExtra->IsFunc1Enabled == YES)
++ {
++ if(rtl2832_func1_Reset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see I2C_BRIDGE_FP_FORWARD_I2C_READING_CMD
++
++*/
++int
++rtl2832_ForwardI2cReadingCmd(
++ I2C_BRIDGE_MODULE *pI2cBridge,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned char TunerDeviceAddr;
++
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)pI2cBridge->pPrivateData;
++
++
++ // Get base interface.
++ pBaseInterface = pDemod->pBaseInterface;
++
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++
++ // Send I2C reading command.
++ if(pBaseInterface->I2cRead(pBaseInterface, TunerDeviceAddr, pReadingBytes, ByteNum) != FUNCTION_SUCCESS)
++ goto error_send_i2c_reading_command;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_send_i2c_reading_command:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see I2C_BRIDGE_FP_FORWARD_I2C_WRITING_CMD
++
++*/
++int
++rtl2832_ForwardI2cWritingCmd(
++ I2C_BRIDGE_MODULE *pI2cBridge,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned char TunerDeviceAddr;
++
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)pI2cBridge->pPrivateData;
++
++
++ // Get base interface.
++ pBaseInterface = pDemod->pBaseInterface;
++
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++
++ // Send I2C writing command.
++ if(pBaseInterface->I2cWrite(pBaseInterface, TunerDeviceAddr, pWritingBytes, ByteNum) != FUNCTION_SUCCESS)
++ goto error_send_i2c_writing_command;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_send_i2c_writing_command:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Initialize RTL2832 register table.
++
++Use rtl2832_InitRegTable() to initialize RTL2832 register table.
++
++
++@param [in] pDemod RTL2832 demod module pointer
++
++
++@note
++ -# The rtl2832_InitRegTable() function will be called by BuildRtl2832Module().
++
++*/
++void
++rtl2832_InitRegTable(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ static const DVBT_PRIMARY_REG_ENTRY PrimaryRegTable[RTL2832_REG_TABLE_LEN] =
++ {
++ // Software reset register
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_SOFT_RST, 0x1, 0x1, 2, 2},
++
++ // Tuner I2C forwording register
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_IIC_REPEAT, 0x1, 0x1, 3, 3},
++
++ // Registers for initialization
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_TR_WAIT_MIN_8K, 0x1, 0x88, 11, 2},
++ {DVBT_RSD_BER_FAIL_VAL, 0x1, 0x8f, 15, 0},
++ {DVBT_EN_BK_TRK, 0x1, 0xa6, 7, 7},
++ {DVBT_AD_EN_REG, 0x0, 0x8, 7, 7},
++ {DVBT_AD_EN_REG1, 0x0, 0x8, 6, 6},
++ {DVBT_EN_BBIN, 0x1, 0xb1, 0, 0},
++ {DVBT_MGD_THD0, 0x1, 0x95, 7, 0},
++ {DVBT_MGD_THD1, 0x1, 0x96, 7, 0},
++ {DVBT_MGD_THD2, 0x1, 0x97, 7, 0},
++ {DVBT_MGD_THD3, 0x1, 0x98, 7, 0},
++ {DVBT_MGD_THD4, 0x1, 0x99, 7, 0},
++ {DVBT_MGD_THD5, 0x1, 0x9a, 7, 0},
++ {DVBT_MGD_THD6, 0x1, 0x9b, 7, 0},
++ {DVBT_MGD_THD7, 0x1, 0x9c, 7, 0},
++ {DVBT_EN_CACQ_NOTCH, 0x1, 0x61, 4, 4},
++ {DVBT_AD_AV_REF, 0x0, 0x9, 6, 0},
++ {DVBT_REG_PI, 0x0, 0xa, 2, 0},
++ {DVBT_PIP_ON, 0x0, 0x21, 3, 3},
++ {DVBT_SCALE1_B92, 0x2, 0x92, 7, 0},
++ {DVBT_SCALE1_B93, 0x2, 0x93, 7, 0},
++ {DVBT_SCALE1_BA7, 0x2, 0xa7, 7, 0},
++ {DVBT_SCALE1_BA9, 0x2, 0xa9, 7, 0},
++ {DVBT_SCALE1_BAA, 0x2, 0xaa, 7, 0},
++ {DVBT_SCALE1_BAB, 0x2, 0xab, 7, 0},
++ {DVBT_SCALE1_BAC, 0x2, 0xac, 7, 0},
++ {DVBT_SCALE1_BB0, 0x2, 0xb0, 7, 0},
++ {DVBT_SCALE1_BB1, 0x2, 0xb1, 7, 0},
++ {DVBT_KB_P1, 0x1, 0x64, 3, 1},
++ {DVBT_KB_P2, 0x1, 0x64, 6, 4},
++ {DVBT_KB_P3, 0x1, 0x65, 2, 0},
++ {DVBT_OPT_ADC_IQ, 0x0, 0x6, 5, 4},
++ {DVBT_AD_AVI, 0x0, 0x9, 1, 0},
++ {DVBT_AD_AVQ, 0x0, 0x9, 3, 2},
++ {DVBT_K1_CR_STEP12, 0x2, 0xad, 9, 4},
++
++ // Registers for initialization according to mode
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_TRK_KS_P2, 0x1, 0x6f, 2, 0},
++ {DVBT_TRK_KS_I2, 0x1, 0x70, 5, 3},
++ {DVBT_TR_THD_SET2, 0x1, 0x72, 3, 0},
++ {DVBT_TRK_KC_P2, 0x1, 0x73, 5, 3},
++ {DVBT_TRK_KC_I2, 0x1, 0x75, 2, 0},
++ {DVBT_CR_THD_SET2, 0x1, 0x76, 7, 6},
++
++ // Registers for IF setting
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_PSET_IFFREQ, 0x1, 0x19, 21, 0},
++ {DVBT_SPEC_INV, 0x1, 0x15, 0, 0},
++
++ // Registers for bandwidth programming
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_RSAMP_RATIO, 0x1, 0x9f, 27, 2},
++ {DVBT_CFREQ_OFF_RATIO, 0x1, 0x9d, 23, 4},
++
++ // FSM stage register
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_FSM_STAGE, 0x3, 0x51, 6, 3},
++
++ // TPS content registers
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_RX_CONSTEL, 0x3, 0x3c, 3, 2},
++ {DVBT_RX_HIER, 0x3, 0x3c, 6, 4},
++ {DVBT_RX_C_RATE_LP, 0x3, 0x3d, 2, 0},
++ {DVBT_RX_C_RATE_HP, 0x3, 0x3d, 5, 3},
++ {DVBT_GI_IDX, 0x3, 0x51, 1, 0},
++ {DVBT_FFT_MODE_IDX, 0x3, 0x51, 2, 2},
++
++ // Performance measurement registers
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_RSD_BER_EST, 0x3, 0x4e, 15, 0},
++ {DVBT_CE_EST_EVM, 0x4, 0xc, 15, 0},
++
++ // AGC registers
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_RF_AGC_VAL, 0x3, 0x5b, 13, 0},
++ {DVBT_IF_AGC_VAL, 0x3, 0x59, 13, 0},
++ {DVBT_DAGC_VAL, 0x3, 0x5, 7, 0},
++
++ // TR offset and CR offset registers
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_SFREQ_OFF, 0x3, 0x18, 13, 0},
++ {DVBT_CFREQ_OFF, 0x3, 0x5f, 17, 0},
++
++ // AGC relative registers
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_POLAR_RF_AGC, 0x0, 0xe, 1, 1},
++ {DVBT_POLAR_IF_AGC, 0x0, 0xe, 0, 0},
++ {DVBT_AAGC_HOLD, 0x1, 0x4, 5, 5},
++ {DVBT_EN_RF_AGC, 0x1, 0x4, 6, 6},
++ {DVBT_EN_IF_AGC, 0x1, 0x4, 7, 7},
++ {DVBT_IF_AGC_MIN, 0x1, 0x8, 7, 0},
++ {DVBT_IF_AGC_MAX, 0x1, 0x9, 7, 0},
++ {DVBT_RF_AGC_MIN, 0x1, 0xa, 7, 0},
++ {DVBT_RF_AGC_MAX, 0x1, 0xb, 7, 0},
++ {DVBT_IF_AGC_MAN, 0x1, 0xc, 6, 6},
++ {DVBT_IF_AGC_MAN_VAL, 0x1, 0xc, 13, 0},
++ {DVBT_RF_AGC_MAN, 0x1, 0xe, 6, 6},
++ {DVBT_RF_AGC_MAN_VAL, 0x1, 0xe, 13, 0},
++ {DVBT_DAGC_TRG_VAL, 0x1, 0x12, 7, 0},
++ {DVBT_AGC_TARG_VAL_0, 0x1, 0x2, 0, 0},
++ {DVBT_AGC_TARG_VAL_8_1, 0x1, 0x3, 7, 0},
++ {DVBT_AAGC_LOOP_GAIN, 0x1, 0xc7, 5, 1},
++ {DVBT_LOOP_GAIN2_3_0, 0x1, 0x4, 4, 1},
++ {DVBT_LOOP_GAIN2_4, 0x1, 0x5, 7, 7},
++ {DVBT_LOOP_GAIN3, 0x1, 0xc8, 4, 0},
++ {DVBT_VTOP1, 0x1, 0x6, 5, 0},
++ {DVBT_VTOP2, 0x1, 0xc9, 5, 0},
++ {DVBT_VTOP3, 0x1, 0xca, 5, 0},
++ {DVBT_KRF1, 0x1, 0xcb, 7, 0},
++ {DVBT_KRF2, 0x1, 0x7, 7, 0},
++ {DVBT_KRF3, 0x1, 0xcd, 7, 0},
++ {DVBT_KRF4, 0x1, 0xce, 7, 0},
++
++ // TS interface registers
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_CKOUTPAR, 0x1, 0x7b, 5, 5},
++ {DVBT_CKOUT_PWR, 0x1, 0x7b, 6, 6},
++ {DVBT_SYNC_DUR, 0x1, 0x7b, 7, 7},
++ {DVBT_ERR_DUR, 0x1, 0x7c, 0, 0},
++ {DVBT_SYNC_LVL, 0x1, 0x7c, 1, 1},
++ {DVBT_ERR_LVL, 0x1, 0x7c, 2, 2},
++ {DVBT_VAL_LVL, 0x1, 0x7c, 3, 3},
++ {DVBT_SERIAL, 0x1, 0x7c, 4, 4},
++ {DVBT_SER_LSB, 0x1, 0x7c, 5, 5},
++ {DVBT_CDIV_PH0, 0x1, 0x7d, 3, 0},
++ {DVBT_CDIV_PH1, 0x1, 0x7d, 7, 4},
++ {DVBT_CKOUTPAR_PIP, 0x0, 0xb7, 4, 4},
++ {DVBT_CKOUT_PWR_PIP, 0x0, 0xb7, 3, 3},
++ {DVBT_SYNC_LVL_PIP, 0x0, 0xb7, 2, 2},
++ {DVBT_ERR_LVL_PIP, 0x0, 0xb7, 1, 1},
++ {DVBT_VAL_LVL_PIP, 0x0, 0xb7, 0, 0},
++ {DVBT_CKOUTPAR_PID, 0x0, 0xb9, 4, 4},
++ {DVBT_CKOUT_PWR_PID, 0x0, 0xb9, 3, 3},
++ {DVBT_SYNC_LVL_PID, 0x0, 0xb9, 2, 2},
++ {DVBT_ERR_LVL_PID, 0x0, 0xb9, 1, 1},
++ {DVBT_VAL_LVL_PID, 0x0, 0xb9, 0, 0},
++
++ // FSM state-holding register
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_SM_PASS, 0x1, 0x93, 11, 0},
++
++ // AD7 registers
++ // RegBitName, PageNo, RegStartAddr, MSB, LSB
++ {DVBT_AD7_SETTING, 0x0, 0x11, 15, 0},
++ {DVBT_RSSI_R, 0x3, 0x1, 6, 0},
++
++ // ACI detection registers
++ {DVBT_ACI_DET_IND, 0x3, 0x12, 0, 0},
++ };
++
++
++ int i;
++ int RegBitName;
++
++
++
++ // Initialize register table according to primary register table.
++ // Note: 1. Register table rows are sorted by register bit name key.
++ // 2. The default value of the IsAvailable variable is "NO".
++ for(i = 0; i < DVBT_REG_TABLE_LEN_MAX; i++)
++ pDemod->RegTable[i].IsAvailable = NO;
++
++ for(i = 0; i < RTL2832_REG_TABLE_LEN; i++)
++ {
++ RegBitName = PrimaryRegTable[i].RegBitName;
++
++ pDemod->RegTable[RegBitName].IsAvailable = YES;
++ pDemod->RegTable[RegBitName].PageNo = PrimaryRegTable[i].PageNo;
++ pDemod->RegTable[RegBitName].RegStartAddr = PrimaryRegTable[i].RegStartAddr;
++ pDemod->RegTable[RegBitName].Msb = PrimaryRegTable[i].Msb;
++ pDemod->RegTable[RegBitName].Lsb = PrimaryRegTable[i].Lsb;
++ }
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Set I2C bridge module demod arguments.
++
++RTL2832 builder will use rtl2832_SetI2cBridgeModuleDemodArg() to set I2C bridge module demod arguments.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@see BuildRtl2832Module()
++
++*/
++void
++rtl2832_SetI2cBridgeModuleDemodArg(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++
++
++ // Get I2C bridge module.
++ pI2cBridge = pDemod->pI2cBridge;
++
++ // Set I2C bridge module demod arguments.
++ pI2cBridge->pPrivateData = (void *)pDemod;
++ pI2cBridge->ForwardI2cReadingCmd = rtl2832_ForwardI2cReadingCmd;
++ pI2cBridge->ForwardI2cWritingCmd = rtl2832_ForwardI2cWritingCmd;
++
++
++ return;
++}
++
++
++
++
++
++/*
++
++@see RTL2832_FP_GET_APP_MODE
++
++*/
++void
++rtl2832_GetAppMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAppMode
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Get demod type from demod module.
++ *pAppMode = pExtra->AppMode;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Reset Function 1 variables and registers.
++
++One can use rtl2832_func1_Reset() to reset Function 1 variables and registers.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Reset Function 1 variables and registers successfully.
++@retval FUNCTION_ERROR Reset Function 1 variables and registers unsuccessfully.
++
++
++@note
++ -# Need to execute Function 1 reset function when change tuner RF frequency or demod parameters.
++ -# Function 1 update flow also employs Function 1 reset function.
++
++*/
++int
++rtl2832_func1_Reset(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++ // Reset demod Function 1 variables.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_NORMAL;
++ pExtra->Func1WaitTime = 0;
++ pExtra->Func1GettingTime = 0;
++ pExtra->Func1RsdBerEstSumNormal = 0;
++ pExtra->Func1RsdBerEstSumConfig1 = 0;
++ pExtra->Func1RsdBerEstSumConfig2 = 0;
++ pExtra->Func1RsdBerEstSumConfig3 = 0;
++
++
++ // Reset demod Function 1 registers.
++ if(rtl2832_func1_ResetReg(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Update demod registers with Function 1.
++
++One can use rtl2832_func1_Update() to update demod registers with Function 1.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Update demod registers with Function 1 successfully.
++@retval FUNCTION_ERROR Update demod registers with Function 1 unsuccessfully.
++
++*/
++int
++rtl2832_func1_Update(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++ int Answer;
++ int MinWeightedBerConfigMode;
++
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Run FSM.
++ switch(pExtra->Func1State)
++ {
++ case RTL2832_FUNC1_STATE_NORMAL:
++
++ // Ask if criterion is matched.
++ if(rtl2832_func1_IsCriterionMatched(pDemod, &Answer) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ if(Answer == YES)
++ {
++ // Accumulate RSD_BER_EST for normal case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumNormal) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset getting time counter.
++ pExtra->Func1GettingTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_NORMAL_GET_BER state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_NORMAL_GET_BER;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_NORMAL_GET_BER:
++
++ // Accumulate RSD_BER_EST for normal case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumNormal) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Use getting time counter to hold RTL2832_FUNC1_STATE_NORMAL_GET_BER state several times.
++ pExtra->Func1GettingTime += 1;
++
++ if(pExtra->Func1GettingTime >= pExtra->Func1GettingTimeMax)
++ {
++ // Set common registers for configuration 1, 2, and 3 case.
++ if(rtl2832_func1_SetCommonReg(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set registers with FFT mode for configuration 1, 2, and 3 case.
++ if(rtl2832_func1_SetRegWithFftMode(pDemod, pExtra->Func1FftBak) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set registers for configuration 1 case.
++ if(rtl2832_func1_SetRegWithConfigMode(pDemod, RTL2832_FUNC1_CONFIG_1) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset wait time counter.
++ pExtra->Func1WaitTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_CONFIG_1_WAIT state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_CONFIG_1_WAIT;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_CONFIG_1_WAIT:
++
++ // Use wait time counter to hold RTL2832_FUNC1_STATE_CONFIG_1_WAIT state several times.
++ pExtra->Func1WaitTime += 1;
++
++ if(pExtra->Func1WaitTime >= pExtra->Func1WaitTimeMax)
++ {
++ // Accumulate RSD_BER_EST for configuration 1 case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumConfig1) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset getting time counter.
++ pExtra->Func1GettingTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_CONFIG_1_GET_BER state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_CONFIG_1_GET_BER;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_CONFIG_1_GET_BER:
++
++ // Accumulate RSD_BER_EST for configuration 1 case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumConfig1) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Use getting time counter to hold RTL2832_FUNC1_STATE_CONFIG_1_GET_BER state several times.
++ pExtra->Func1GettingTime += 1;
++
++ if(pExtra->Func1GettingTime >= pExtra->Func1GettingTimeMax)
++ {
++ // Set registers for configuration 2 case.
++ if(rtl2832_func1_SetRegWithConfigMode(pDemod, RTL2832_FUNC1_CONFIG_2) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset wait time counter.
++ pExtra->Func1WaitTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_CONFIG_2_WAIT state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_CONFIG_2_WAIT;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_CONFIG_2_WAIT:
++
++ // Use wait time counter to hold RTL2832_FUNC1_STATE_CONFIG_2_WAIT state several times.
++ pExtra->Func1WaitTime += 1;
++
++ if(pExtra->Func1WaitTime >= pExtra->Func1WaitTimeMax)
++ {
++ // Accumulate RSD_BER_EST for configuration 2 case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumConfig2) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset getting time counter.
++ pExtra->Func1GettingTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_CONFIG_2_GET_BER state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_CONFIG_2_GET_BER;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_CONFIG_2_GET_BER:
++
++ // Accumulate RSD_BER_EST for configuration 2 case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumConfig2) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Use getting time counter to hold RTL2832_FUNC1_STATE_CONFIG_2_GET_BER state several times.
++ pExtra->Func1GettingTime += 1;
++
++ if(pExtra->Func1GettingTime >= pExtra->Func1GettingTimeMax)
++ {
++ // Set registers for configuration 3 case.
++ if(rtl2832_func1_SetRegWithConfigMode(pDemod, RTL2832_FUNC1_CONFIG_3) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset wait time counter.
++ pExtra->Func1WaitTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_CONFIG_3_WAIT state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_CONFIG_3_WAIT;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_CONFIG_3_WAIT:
++
++ // Use wait time counter to hold RTL2832_FUNC1_STATE_CONFIG_3_WAIT state several times.
++ pExtra->Func1WaitTime += 1;
++
++ if(pExtra->Func1WaitTime >= pExtra->Func1WaitTimeMax)
++ {
++ // Accumulate RSD_BER_EST for configuration 3 case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumConfig3) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset getting time counter.
++ pExtra->Func1GettingTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_CONFIG_3_GET_BER state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_CONFIG_3_GET_BER;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_CONFIG_3_GET_BER:
++
++ // Accumulate RSD_BER_EST for configuration 3 case.
++ if(rtl2832_func1_AccumulateRsdBerEst(pDemod, &pExtra->Func1RsdBerEstSumConfig3) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Use getting time counter to hold RTL2832_FUNC1_STATE_CONFIG_3_GET_BER state several times.
++ pExtra->Func1GettingTime += 1;
++
++ if(pExtra->Func1GettingTime >= pExtra->Func1GettingTimeMax)
++ {
++ // Determine minimum-weighted-BER configuration mode.
++ rtl2832_func1_GetMinWeightedBerConfigMode(pDemod, &MinWeightedBerConfigMode);
++
++ // Set registers with minimum-weighted-BER configuration mode.
++ switch(MinWeightedBerConfigMode)
++ {
++ case RTL2832_FUNC1_CONFIG_NORMAL:
++
++ // Reset registers for normal configuration.
++ if(rtl2832_func1_ResetReg(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ break;
++
++
++ case RTL2832_FUNC1_CONFIG_1:
++ case RTL2832_FUNC1_CONFIG_2:
++ case RTL2832_FUNC1_CONFIG_3:
++
++ // Set registers for minimum-weighted-BER configuration.
++ if(rtl2832_func1_SetRegWithConfigMode(pDemod, MinWeightedBerConfigMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ break;
++
++
++ default:
++
++ // Get error configuration mode, reset registers.
++ if(rtl2832_func1_ResetReg(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ break;
++ }
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset wait time counter.
++ pExtra->Func1WaitTime = 0;
++
++ // Go to RTL2832_FUNC1_STATE_DETERMINED_WAIT state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_DETERMINED_WAIT;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_DETERMINED_WAIT:
++
++ // Use wait time counter to hold RTL2832_FUNC1_STATE_CONFIG_3_WAIT state several times.
++ pExtra->Func1WaitTime += 1;
++
++ if(pExtra->Func1WaitTime >= pExtra->Func1WaitTimeMax)
++ {
++ // Go to RTL2832_FUNC1_STATE_DETERMINED state.
++ pExtra->Func1State = RTL2832_FUNC1_STATE_DETERMINED;
++ }
++
++ break;
++
++
++ case RTL2832_FUNC1_STATE_DETERMINED:
++
++ // Ask if criterion is matched.
++ if(rtl2832_func1_IsCriterionMatched(pDemod, &Answer) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ if(Answer == NO)
++ {
++ // Reset FSM.
++ // Note: rtl2832_func1_Reset() will set FSM state with RTL2832_FUNC1_STATE_NORMAL.
++ if(rtl2832_func1_Reset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++ }
++
++ break;
++
++
++ default:
++
++ // Get error state, reset FSM.
++ // Note: rtl2832_func1_Reset() will set FSM state with RTL2832_FUNC1_STATE_NORMAL.
++ if(rtl2832_func1_Reset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ break;
++ }
++
++
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Ask if criterion is matched for Function 1.
++
++One can use rtl2832_func1_IsCriterionMatched() to ask if criterion is matched for Function 1.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pAnswer Pointer to an allocated memory for storing answer
++
++
++@retval FUNCTION_SUCCESS Ask if criterion is matched for Function 1 successfully.
++@retval FUNCTION_ERROR Ask if criterion is matched for Function 1 unsuccessfully.
++
++*/
++int
++rtl2832_func1_IsCriterionMatched(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++ unsigned long FsmStage;
++
++ int Qam;
++ int Hier;
++ int LpCr;
++ int HpCr;
++ int Gi;
++ int Fft;
++
++ unsigned long Reg0, Reg1;
++
++ int BandwidthMode;
++
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Get FSM_STAGE.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_FSM_STAGE, &FsmStage) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++
++ // Get QAM.
++ if(pDemod->GetConstellation(pDemod, &Qam) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get hierarchy.
++ if(pDemod->GetHierarchy(pDemod, &Hier) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get low-priority code rate.
++ if(pDemod->GetCodeRateLp(pDemod, &LpCr) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get high-priority code rate.
++ if(pDemod->GetCodeRateHp(pDemod, &HpCr) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get guard interval.
++ if(pDemod->GetGuardInterval(pDemod, &Gi) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get FFT mode.
++ if(pDemod->GetFftMode(pDemod, &Fft) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Get REG_0 and REG_1.
++ if(pDemod->SetRegPage(pDemod, 0x3) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->GetRegMaskBits(pDemod, 0x22, 0, 0, &Reg0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->GetRegMaskBits(pDemod, 0x1a, 15, 3, &Reg1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Get bandwidth mode.
++ if(pDemod->GetBandwidthMode(pDemod, &BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Determine criterion answer.
++ *pAnswer =
++ (FsmStage == 11) &&
++
++ (Qam == pExtra->Func1QamBak) &&
++ (Hier == pExtra->Func1HierBak) &&
++ (LpCr == pExtra->Func1LpCrBak) &&
++ (HpCr == pExtra->Func1HpCrBak) &&
++ (Gi == pExtra->Func1GiBak) &&
++ (Fft == pExtra->Func1FftBak) &&
++
++ (Reg0 == 0x1) &&
++
++ ((BandwidthMode == DVBT_BANDWIDTH_8MHZ) &&
++ ( ((Fft == DVBT_FFT_MODE_2K) && (Reg1 > 1424) && (Reg1 < 1440)) ||
++ ((Fft == DVBT_FFT_MODE_8K) && (Reg1 > 5696) && (Reg1 < 5760)) ) );
++
++
++ // Backup TPS information.
++ pExtra->Func1QamBak = Qam;
++ pExtra->Func1HierBak = Hier;
++ pExtra->Func1LpCrBak = LpCr;
++ pExtra->Func1HpCrBak = HpCr;
++ pExtra->Func1GiBak = Gi;
++ pExtra->Func1FftBak = Fft;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++error_status_execute_function:
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Accumulate RSD_BER_EST value for Function 1.
++
++One can use rtl2832_func1_AccumulateRsdBerEst() to accumulate RSD_BER_EST for Function 1.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] pAccumulativeValue Accumulative RSD_BER_EST value
++
++
++@retval FUNCTION_SUCCESS Accumulate RSD_BER_EST for Function 1 successfully.
++@retval FUNCTION_ERROR Accumulate RSD_BER_EST for Function 1 unsuccessfully.
++
++*/
++int
++rtl2832_func1_AccumulateRsdBerEst(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pAccumulativeValue
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++ int i;
++ unsigned long RsdBerEst;
++
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Get RSD_BER_EST with assigned times.
++ for(i = 0; i < pExtra->Func1GettingNumEachTime; i++)
++ {
++ // Get RSD_BER_EST.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RSD_BER_EST, &RsdBerEst) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ // Accumulate RSD_BER_EST to accumulative value.
++ *pAccumulativeValue += RsdBerEst;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Reset registers for Function 1.
++
++One can use rtl2832_func1_ResetReg() to reset registers for Function 1.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Reset registers for Function 1 successfully.
++@retval FUNCTION_ERROR Reset registers for Function 1 unsuccessfully.
++
++*/
++int
++rtl2832_func1_ResetReg(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ // Reset Function 1 registers.
++ if(pDemod->SetRegPage(pDemod, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x65, 2, 0, 0x7) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x68, 5, 4, 0x3) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5b, 2, 0, 0x5) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5b, 5, 3, 0x5) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5c, 2, 0, 0x5) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5c, 5, 3, 0x5) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd0, 3, 2, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd1, 14, 0, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd3, 14, 0, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd5, 14, 0, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegPage(pDemod, 0x2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x1, 0, 0, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xb4, 7, 6, 0x3) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd2, 1, 1, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xb5, 7, 7, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set common registers for Function 1.
++
++One can use rtl2832_func1_SetCommonReg() to set common registers for Function 1.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Set common registers for Function 1 successfully.
++@retval FUNCTION_ERROR Set common registers for Function 1 unsuccessfully.
++
++*/
++int
++rtl2832_func1_SetCommonReg(
++ DVBT_DEMOD_MODULE *pDemod
++ )
++{
++ // Set common registers for Function 1.
++ if(pDemod->SetRegPage(pDemod, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x65, 2, 0, 0x5) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x68, 5, 4, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegPage(pDemod, 0x2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd2, 1, 1, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xb5, 7, 7, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set registers with FFT mode for Function 1.
++
++One can use rtl2832_func1_SetRegWithConfigMode() to set registers with FFT mode for Function 1.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] FftMode FFT mode for setting
++
++
++@retval FUNCTION_SUCCESS Set registers with FFT mode for Function 1 successfully.
++@retval FUNCTION_ERROR Set registers with FFT mode for Function 1 unsuccessfully.
++
++*/
++int
++rtl2832_func1_SetRegWithFftMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int FftMode
++ )
++{
++ typedef struct
++ {
++ unsigned long Reg0[DVBT_FFT_MODE_NUM];
++ unsigned long Reg1[DVBT_FFT_MODE_NUM];
++ }
++ FFT_REF_ENTRY;
++
++
++
++ static const FFT_REF_ENTRY FftRefTable =
++ {
++ // 2K mode, 8K mode
++ {0x0, 0x1 },
++ {0x3, 0x0 },
++ };
++
++
++
++ // Set registers with FFT mode for Function 1.
++ if(pDemod->SetRegPage(pDemod, 0x2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x1, 0, 0, FftRefTable.Reg0[FftMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xb4, 7, 6, FftRefTable.Reg1[FftMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set registers with configuration mode for Function 1.
++
++One can use rtl2832_func1_SetRegWithConfigMode() to set registers with configuration mode for Function 1.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] ConfigMode Configuration mode for setting
++
++
++@retval FUNCTION_SUCCESS Set registers with configuration mode for Function 1 successfully.
++@retval FUNCTION_ERROR Set registers with configuration mode for Function 1 unsuccessfully.
++
++
++@note
++ -# This function can not set RTL2832_FUNC1_CONFIG_NORMAL configuration mode.
++
++*/
++int
++rtl2832_func1_SetRegWithConfigMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int ConfigMode
++ )
++{
++ typedef struct
++ {
++ unsigned long Reg0[RTL2832_FUNC1_CONFIG_MODE_NUM];
++ unsigned long Reg1[RTL2832_FUNC1_CONFIG_MODE_NUM];
++ unsigned long Reg2[RTL2832_FUNC1_CONFIG_MODE_NUM];
++ unsigned long Reg3[RTL2832_FUNC1_CONFIG_MODE_NUM];
++ unsigned long Reg4[RTL2832_FUNC1_CONFIG_MODE_NUM];
++
++ unsigned long Reg5Ref[RTL2832_FUNC1_CONFIG_MODE_NUM];
++ unsigned long Reg6Ref[RTL2832_FUNC1_CONFIG_MODE_NUM];
++ unsigned long Reg7Ref[RTL2832_FUNC1_CONFIG_MODE_NUM];
++ }
++ CONFIG_REF_ENTRY;
++
++
++
++ static const CONFIG_REF_ENTRY ConfigRefTable =
++ {
++ // Config 1, Config 2, Config 3
++ {0x5, 0x4, 0x5 },
++ {0x5, 0x4, 0x7 },
++ {0x5, 0x4, 0x7 },
++ {0x7, 0x6, 0x5 },
++ {0x3, 0x3, 0x2 },
++
++ {4437, 4437, 4325 },
++ {6000, 5500, 6500 },
++ {6552, 5800, 5850 },
++ };
++
++ int BandwidthMode;
++
++ static const unsigned long Const[DVBT_BANDWIDTH_MODE_NUM] =
++ {
++ // 6Mhz, 7Mhz, 8Mhz
++ 48, 56, 64,
++ };
++
++ unsigned long Reg5, Reg6, Reg7;
++
++
++
++ // Get bandwidth mode.
++ if(pDemod->GetBandwidthMode(pDemod, &BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Calculate REG_5, REG_6, and REG_7 with bandwidth mode and configuration mode.
++ Reg5 = (ConfigRefTable.Reg5Ref[ConfigMode] * 7 * 2048 * 8) / (1000 * Const[BandwidthMode]);
++ Reg6 = (ConfigRefTable.Reg6Ref[ConfigMode] * 7 * 2048 * 8) / (1000 * Const[BandwidthMode]);
++ Reg7 = (ConfigRefTable.Reg7Ref[ConfigMode] * 7 * 2048 * 8) / (1000 * Const[BandwidthMode]);
++
++
++ // Set registers with bandwidth mode and configuration mode.
++ if(pDemod->SetRegPage(pDemod, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5b, 2, 0, ConfigRefTable.Reg0[ConfigMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5b, 5, 3, ConfigRefTable.Reg1[ConfigMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5c, 2, 0, ConfigRefTable.Reg2[ConfigMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0x5c, 5, 3, ConfigRefTable.Reg3[ConfigMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd0, 3, 2, ConfigRefTable.Reg4[ConfigMode]) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd1, 14, 0, Reg5) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd3, 14, 0, Reg6) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegMaskBits(pDemod, 0xd5, 14, 0, Reg7) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_registers:
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Get minimum-weighted-BER configuration mode for Function 1.
++
++One can use rtl2832_func1_GetMinWeightedBerConfigMode() to get minimum-weighted-BER configuration mode for Function 1.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pConfigMode Pointer to an allocated memory for storing configuration mode answer
++
++
++@retval FUNCTION_SUCCESS Get minimum-weighted-BER configuration mode for Function 1 successfully.
++@retval FUNCTION_ERROR Get minimum-weighted-BER configuration mode for Function 1 unsuccessfully.
++
++*/
++void
++rtl2832_func1_GetMinWeightedBerConfigMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pConfigMode
++ )
++{
++ RTL2832_EXTRA_MODULE *pExtra;
++
++ unsigned long WeightedBerNormal;
++ unsigned long WeightedBerConfig1;
++ unsigned long WeightedBerConfig2;
++ unsigned long WeightedBerConfig3;
++
++
++
++ // Get demod extra module.
++ pExtra = (RTL2832_EXTRA_MODULE *)pDemod->pExtra;
++
++
++ // Calculate weighted BER for all configuration mode
++ WeightedBerNormal = pExtra->Func1RsdBerEstSumNormal * 2;
++ WeightedBerConfig1 = pExtra->Func1RsdBerEstSumConfig1;
++ WeightedBerConfig2 = pExtra->Func1RsdBerEstSumConfig2;
++ WeightedBerConfig3 = pExtra->Func1RsdBerEstSumConfig3;
++
++
++ // Determine minimum-weighted-BER configuration mode.
++ if(WeightedBerNormal <= WeightedBerConfig1 &&
++ WeightedBerNormal <= WeightedBerConfig2 &&
++ WeightedBerNormal <= WeightedBerConfig3)
++ {
++ *pConfigMode = RTL2832_FUNC1_CONFIG_NORMAL;
++ }
++ else if(WeightedBerConfig1 <= WeightedBerNormal &&
++ WeightedBerConfig1 <= WeightedBerConfig2 &&
++ WeightedBerConfig1 <= WeightedBerConfig3)
++ {
++ *pConfigMode = RTL2832_FUNC1_CONFIG_1;
++ }
++ else if(WeightedBerConfig2 <= WeightedBerNormal &&
++ WeightedBerConfig2 <= WeightedBerConfig1 &&
++ WeightedBerConfig2 <= WeightedBerConfig3)
++ {
++ *pConfigMode = RTL2832_FUNC1_CONFIG_2;
++ }
++ else if(WeightedBerConfig3 <= WeightedBerNormal &&
++ WeightedBerConfig3 <= WeightedBerConfig1 &&
++ WeightedBerConfig3 <= WeightedBerConfig2)
++ {
++ *pConfigMode = RTL2832_FUNC1_CONFIG_3;
++ }
++
++
++ return;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/demod_rtl2832.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/demod_rtl2832.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,542 @@
++#ifndef __DEMOD_RTL2832_H
++#define __DEMOD_RTL2832_H
++
++/**
++
++@file
++
++@brief RTL2832 demod module declaration
++
++One can manipulate RTL2832 demod through RTL2832 module.
++RTL2832 module is derived from DVB-T demod module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the DVB-T demod example in dvbt_demod_base.h except the listed lines.
++
++
++
++#include "demod_rtl2832.h"
++
++
++...
++
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++ DVBT_DEMOD_MODULE DvbtDemodModuleMemory;
++ RTL2832_EXTRA_MODULE Rtl2832ExtraModuleMemory;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory;
++
++
++ ...
++
++
++
++ // Build RTL2832 demod module.
++ BuildRtl2832Module(
++ &pDemod,
++ &DvbtDemodModuleMemory,
++ &Rtl2832ExtraModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ 0x20, // I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // Crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_STB // Application mode is STB.
++ 50, // Update function reference period is 50 millisecond
++ ON // Function 1 enabling status is on.
++ );
++
++
++
++ // See the example for other DVB-T demod functions in dvbt_demod_base.h
++
++ ...
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "dvbt_demod_base.h"
++
++
++
++
++
++// Definitions
++
++// Initializing
++#define RTL2832_INIT_TABLE_LEN 31
++#define RTL2832_INIT_TABLE_LEN_WITH_APP_MODE 5
++
++
++// Bandwidth setting
++#define RTL2832_H_LPF_X_PAGE 1
++#define RTL2832_H_LPF_X_ADDR 0x1c
++#define RTL2832_H_LPF_X_LEN 32
++#define RTL2832_RATIO_PAGE 1
++#define RTL2832_RATIO_ADDR 0x9d
++#define RTL2832_RATIO_LEN 6
++
++
++// Bandwidth setting
++#define RTL2832_CFREQ_OFF_RATIO_BIT_NUM 20
++
++
++// IF frequency setting
++#define RTL2832_PSET_IFFREQ_BIT_NUM 22
++
++
++// Signal quality
++#define RTL2832_SQ_FRAC_BIT_NUM 5
++
++
++// BER
++#define RTL2832_BER_DEN_VALUE 1000000
++
++
++// SNR
++#define RTL2832_CE_EST_EVM_MAX_VALUE 65535
++#define RTL2832_SNR_FRAC_BIT_NUM 10
++#define RTL2832_SNR_DB_DEN 3402
++
++
++// AGC
++#define RTL2832_RF_AGC_REG_BIT_NUM 14
++#define RTL2832_IF_AGC_REG_BIT_NUM 14
++
++
++// TR offset and CR offset
++#define RTL2832_SFREQ_OFF_BIT_NUM 14
++#define RTL2832_CFREQ_OFF_BIT_NUM 18
++
++
++// Register table length
++#define RTL2832_REG_TABLE_LEN 112
++
++
++// Function 1
++#define RTL2832_FUNC1_WAIT_TIME_MS 500
++#define RTL2832_FUNC1_GETTING_TIME_MS 200
++#define RTL2832_FUNC1_GETTING_NUM_MIN 20
++
++
++
++/// Demod application modes
++enum RTL2832_APPLICATION_MODE
++{
++ RTL2832_APPLICATION_DONGLE,
++ RTL2832_APPLICATION_STB,
++};
++#define RTL2832_APPLICATION_MODE_NUM 2
++
++
++// Function 1
++enum RTL2832_FUNC1_CONFIG_MODE
++{
++ RTL2832_FUNC1_CONFIG_1,
++ RTL2832_FUNC1_CONFIG_2,
++ RTL2832_FUNC1_CONFIG_3,
++};
++#define RTL2832_FUNC1_CONFIG_MODE_NUM 3
++#define RTL2832_FUNC1_CONFIG_NORMAL -1
++
++
++enum RTL2832_FUNC1_STATE
++{
++ RTL2832_FUNC1_STATE_NORMAL,
++ RTL2832_FUNC1_STATE_NORMAL_GET_BER,
++ RTL2832_FUNC1_STATE_CONFIG_1_WAIT,
++ RTL2832_FUNC1_STATE_CONFIG_1_GET_BER,
++ RTL2832_FUNC1_STATE_CONFIG_2_WAIT,
++ RTL2832_FUNC1_STATE_CONFIG_2_GET_BER,
++ RTL2832_FUNC1_STATE_CONFIG_3_WAIT,
++ RTL2832_FUNC1_STATE_CONFIG_3_GET_BER,
++ RTL2832_FUNC1_STATE_DETERMINED_WAIT,
++ RTL2832_FUNC1_STATE_DETERMINED,
++};
++
++
++
++
++
++/// RTL2832 extra module
++typedef struct RTL2832_EXTRA_MODULE_TAG RTL2832_EXTRA_MODULE;
++
++
++
++
++
++/*
++
++@brief RTL2832 application mode getting function pointer
++
++One can use RTL2832_FP_GET_APP_MODE() to get RTL2832 application mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pAppMode Pointer to an allocated memory for storing demod application mode
++
++
++@retval FUNCTION_SUCCESS Get demod application mode successfully.
++@retval FUNCTION_ERROR Get demod application mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set RTL2832_FP_GET_APP_MODE() with the corresponding function.
++
++
++@see RTL2832_APPLICATION_MODE
++
++*/
++typedef void
++(*RTL2832_FP_GET_APP_MODE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAppMode
++ );
++
++
++
++
++
++struct RTL2832_EXTRA_MODULE_TAG
++{
++ // RTL2832 extra variables
++ int AppMode;
++
++ // RTL2832 update procedure enabling status
++ int IsFunc1Enabled;
++
++ // RTL2832 update Function 1 variables
++ int Func1State;
++
++ int Func1WaitTimeMax;
++ int Func1GettingTimeMax;
++ int Func1GettingNumEachTime;
++
++ int Func1WaitTime;
++ int Func1GettingTime;
++
++ unsigned long Func1RsdBerEstSumNormal;
++ unsigned long Func1RsdBerEstSumConfig1;
++ unsigned long Func1RsdBerEstSumConfig2;
++ unsigned long Func1RsdBerEstSumConfig3;
++
++ int Func1QamBak;
++ int Func1HierBak;
++ int Func1LpCrBak;
++ int Func1HpCrBak;
++ int Func1GiBak;
++ int Func1FftBak;
++
++
++ // RTL2832 extra function pointers
++ RTL2832_FP_GET_APP_MODE GetAppMode;
++};
++
++
++
++
++
++// Demod module builder
++void
++BuildRtl2832Module(
++ DVBT_DEMOD_MODULE **ppDemod,
++ DVBT_DEMOD_MODULE *pDvbtDemodModuleMemory,
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr,
++ unsigned long CrystalFreqHz,
++ int AppMode,
++ unsigned long UpdateFuncRefPeriodMs,
++ int IsFunc1Enabled
++ );
++
++
++
++
++
++// Manipulating functions
++void
++rtl2832_IsConnectedToI2c(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++);
++
++int
++rtl2832_SoftwareReset(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++int
++rtl2832_Initialize(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++int
++rtl2832_SetBandwidthMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int BandwidthMode
++ );
++
++int
++rtl2832_SetIfFreqHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long IfFreqHz
++ );
++
++int
++rtl2832_SetSpectrumMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int SpectrumMode
++ );
++
++int
++rtl2832_IsTpsLocked(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ );
++
++int
++rtl2832_IsSignalLocked(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ );
++
++int
++rtl2832_GetSignalStrength(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pSignalStrength
++ );
++
++int
++rtl2832_GetSignalQuality(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pSignalQuality
++ );
++
++int
++rtl2832_GetBer(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pBerNum,
++ unsigned long *pBerDen
++ );
++
++int
++rtl2832_GetSnrDb(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pSnrDbNum,
++ long *pSnrDbDen
++ );
++
++int
++rtl2832_GetRfAgc(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pRfAgc
++ );
++
++int
++rtl2832_GetIfAgc(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pIfAgc
++ );
++
++int
++rtl2832_GetDiAgc(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char *pDiAgc
++ );
++
++int
++rtl2832_GetTrOffsetPpm(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pTrOffsetPpm
++ );
++
++int
++rtl2832_GetCrOffsetHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pCrOffsetHz
++ );
++
++int
++rtl2832_GetConstellation(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pConstellation
++ );
++
++int
++rtl2832_GetHierarchy(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pHierarchy
++ );
++
++int
++rtl2832_GetCodeRateLp(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pCodeRateLp
++ );
++
++int
++rtl2832_GetCodeRateHp(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pCodeRateHp
++ );
++
++int
++rtl2832_GetGuardInterval(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pGuardInterval
++ );
++
++int
++rtl2832_GetFftMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pFftMode
++ );
++
++int
++rtl2832_UpdateFunction(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++int
++rtl2832_ResetFunction(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++
++
++
++
++// I2C command forwarding functions
++int
++rtl2832_ForwardI2cReadingCmd(
++ I2C_BRIDGE_MODULE *pI2cBridge,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ );
++
++int
++rtl2832_ForwardI2cWritingCmd(
++ I2C_BRIDGE_MODULE *pI2cBridge,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ );
++
++
++
++
++
++// Register table initializing
++void
++rtl2832_InitRegTable(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++
++
++
++
++// I2C birdge module demod argument setting
++void
++rtl2832_SetI2cBridgeModuleDemodArg(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++
++
++
++
++// RTL2832 extra functions
++void
++rtl2832_GetAppMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAppMode
++ );
++
++
++
++
++
++// RTL2832 dependence
++int
++rtl2832_func1_Reset(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++int
++rtl2832_func1_Update(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++int
++rtl2832_func1_IsCriterionMatched(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ );
++
++int
++rtl2832_func1_AccumulateRsdBerEst(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pAccumulativeValue
++ );
++
++int
++rtl2832_func1_ResetReg(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++int
++rtl2832_func1_SetCommonReg(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++int
++rtl2832_func1_SetRegWithFftMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int FftMode
++ );
++
++int
++rtl2832_func1_SetRegWithConfigMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int ConfigMode
++ );
++
++void
++rtl2832_func1_GetMinWeightedBerConfigMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pConfigMode
++ );
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/dvbt_demod_base.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/dvbt_demod_base.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,689 @@
++/**
++
++@file
++
++@brief DVB-T demod default function definition
++
++DVB-T demod default functions.
++
++*/
++
++#include "dvbt_demod_base.h"
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_REG_PAGE
++
++*/
++int
++dvbt_demod_default_SetRegPage(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long PageNo
++ )
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ struct dvb_usb_device *d;
++
++ // Get base interface.
++ pBaseInterface = pDemod->pBaseInterface;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d); //add by chialing
++
++ if( mutex_lock_interruptible(&d->usb_mutex) ) goto error;
++
++ pDemod->PageNo = PageNo;
++
++ mutex_unlock(&d->usb_mutex);
++
++ return FUNCTION_SUCCESS;
++
++error:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_REG_BYTES
++
++*/
++int
++dvbt_demod_default_SetRegBytes(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ )
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned int i, j;
++
++ unsigned char DeviceAddr;
++ unsigned char WritingBuffer[I2C_BUFFER_LEN];
++ unsigned char WritingByteNum, WritingByteNumMax, WritingByteNumRem;
++ unsigned char RegWritingAddr;
++
++ struct dvb_usb_device *d;
++
++ // Get base interface.
++ pBaseInterface = pDemod->pBaseInterface;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d); //add by chialing
++
++ // Get demod I2C device address.
++ pDemod->GetDeviceAddr(pDemod, &DeviceAddr);
++
++
++ // Calculate maximum writing byte number.
++ WritingByteNumMax = pBaseInterface->I2cWritingByteNumMax - LEN_1_BYTE;
++
++
++ // Set demod register bytes with writing bytes.
++ // Note: Set demod register bytes considering maximum writing byte number.
++ for(i = 0; i < ByteNum; i += WritingByteNumMax)
++ {
++ // Set register writing address.
++ RegWritingAddr = RegStartAddr + i;
++
++ // Calculate remainder writing byte number.
++ WritingByteNumRem = ByteNum - i;
++
++ // Determine writing byte number.
++ WritingByteNum = (WritingByteNumRem > WritingByteNumMax) ? WritingByteNumMax : WritingByteNumRem;
++
++
++ // Set writing buffer.
++ // Note: The I2C format of demod register byte setting is as follows:
++ // start_bit + (DeviceAddr | writing_bit) + RegWritingAddr + writing_bytes (WritingByteNum bytes) + stop_bit
++// WritingBuffer[0] = RegWritingAddr;
++
++ for(j = 0; j < WritingByteNum; j++)
++// WritingBuffer[LEN_1_BYTE + j] = pWritingBytes[i + j];
++ WritingBuffer[j] = pWritingBytes[i + j];
++
++ // Set demod register bytes with writing buffer.
++// if(pBaseInterface->I2cWrite(pBaseInterface, DeviceAddr, WritingBuffer, WritingByteNum + LEN_1_BYTE) !=
++// FUNCTION_SUCCESS)
++// goto error_status_set_demod_registers;
++
++ if(write_rtl2832_demod_register( d, DeviceAddr, pDemod->PageNo, RegWritingAddr, WritingBuffer, WritingByteNum )) goto error;
++
++
++ }
++
++
++ return FUNCTION_SUCCESS;
++error:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_REG_BYTES
++
++*/
++int
++dvbt_demod_default_GetRegBytes(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned int i;
++ unsigned char DeviceAddr;
++ unsigned char ReadingByteNum, ReadingByteNumMax, ReadingByteNumRem;
++ unsigned char RegReadingAddr;
++
++ struct dvb_usb_device *d;
++
++ // Get base interface.
++ pBaseInterface = pDemod->pBaseInterface;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d); //add by chialing
++
++ // Get demod I2C device address.
++ pDemod->GetDeviceAddr(pDemod, &DeviceAddr);
++
++
++ // Calculate maximum reading byte number.
++ ReadingByteNumMax = pBaseInterface->I2cReadingByteNumMax;
++
++
++ // Get demod register bytes.
++ // Note: Get demod register bytes considering maximum reading byte number.
++ for(i = 0; i < ByteNum; i += ReadingByteNumMax)
++ {
++ // Set register reading address.
++ RegReadingAddr = RegStartAddr + i;
++
++ // Calculate remainder reading byte number.
++ ReadingByteNumRem = ByteNum - i;
++
++ // Determine reading byte number.
++ ReadingByteNum = (ReadingByteNumRem > ReadingByteNumMax) ? ReadingByteNumMax : ReadingByteNumRem;
++
++
++ // Set demod register reading address.
++ // Note: The I2C format of demod register reading address setting is as follows:
++ // start_bit + (DeviceAddr | writing_bit) + RegReadingAddr + stop_bit
++// if(pBaseInterface->I2cWrite(pBaseInterface, DeviceAddr, &RegReadingAddr, LEN_1_BYTE) != FUNCTION_SUCCESS)
++// goto error_status_set_demod_register_reading_address;
++
++ // Get demod register bytes.
++ // Note: The I2C format of demod register byte getting is as follows:
++ // start_bit + (DeviceAddr | reading_bit) + reading_bytes (ReadingByteNum bytes) + stop_bit
++// if(pBaseInterface->I2cRead(pBaseInterface, DeviceAddr, &pReadingBytes[i], ReadingByteNum) != FUNCTION_SUCCESS)
++// goto error_status_get_demod_registers;
++
++
++ if(read_rtl2832_demod_register(d, DeviceAddr, pDemod->PageNo, RegReadingAddr, &pReadingBytes[i], ReadingByteNum)) goto error;
++
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++error:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_REG_MASK_BITS
++
++*/
++int
++dvbt_demod_default_SetRegMaskBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char Msb,
++ unsigned char Lsb,
++ const unsigned long WritingValue
++ )
++{
++ int i;
++
++ unsigned char ReadingBytes[LEN_4_BYTE];
++ unsigned char WritingBytes[LEN_4_BYTE];
++
++ unsigned char ByteNum;
++ unsigned long Mask;
++ unsigned char Shift;
++
++ unsigned long Value;
++
++
++ // Calculate writing byte number according to MSB.
++ ByteNum = Msb / BYTE_BIT_NUM + LEN_1_BYTE;
++
++
++ // Generate mask and shift according to MSB and LSB.
++ Mask = 0;
++
++ for(i = Lsb; i < (unsigned char)(Msb + 1); i++)
++ Mask |= 0x1 << i;
++
++ Shift = Lsb;
++
++
++ // Get demod register bytes according to register start adddress and byte number.
++ if(pDemod->GetRegBytes(pDemod, RegStartAddr, ReadingBytes, ByteNum) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_registers;
++
++
++ // Combine reading bytes into an unsigned integer value.
++ // Note: Put lower address byte on value MSB.
++ // Put upper address byte on value LSB.
++ Value = 0;
++
++ for(i = 0; i < ByteNum; i++)
++ Value |= (unsigned long)ReadingBytes[i] << (BYTE_SHIFT * (ByteNum - i -1));
++
++
++ // Reserve unsigned integer value unmask bit with mask and inlay writing value into it.
++ Value &= ~Mask;
++ Value |= (WritingValue << Shift) & Mask;
++
++
++ // Separate unsigned integer value into writing bytes.
++ // Note: Pick up lower address byte from value MSB.
++ // Pick up upper address byte from value LSB.
++ for(i = 0; i < ByteNum; i++)
++ WritingBytes[i] = (unsigned char)((Value >> (BYTE_SHIFT * (ByteNum - i -1))) & BYTE_MASK);
++
++
++ // Write demod register bytes with writing bytes.
++ if(pDemod->SetRegBytes(pDemod, RegStartAddr, WritingBytes, ByteNum) != FUNCTION_SUCCESS)
++ goto error_status_set_demod_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_demod_registers:
++error_status_set_demod_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_REG_MASK_BITS
++
++*/
++int
++dvbt_demod_default_GetRegMaskBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char Msb,
++ unsigned char Lsb,
++ unsigned long *pReadingValue
++ )
++{
++ int i;
++
++ unsigned char ReadingBytes[LEN_4_BYTE];
++
++ unsigned char ByteNum;
++ unsigned long Mask;
++ unsigned char Shift;
++
++ unsigned long Value;
++
++
++ // Calculate writing byte number according to MSB.
++ ByteNum = Msb / BYTE_BIT_NUM + LEN_1_BYTE;
++
++
++ // Generate mask and shift according to MSB and LSB.
++ Mask = 0;
++
++ for(i = Lsb; i < (unsigned char)(Msb + 1); i++)
++ Mask |= 0x1 << i;
++
++ Shift = Lsb;
++
++
++ // Get demod register bytes according to register start adddress and byte number.
++ if(pDemod->GetRegBytes(pDemod, RegStartAddr, ReadingBytes, ByteNum) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_registers;
++
++
++ // Combine reading bytes into an unsigned integer value.
++ // Note: Put lower address byte on value MSB.
++ // Put upper address byte on value LSB.
++ Value = 0;
++
++ for(i = 0; i < ByteNum; i++)
++ Value |= (unsigned long)ReadingBytes[i] << (BYTE_SHIFT * (ByteNum - i -1));
++
++
++ // Get register bits from unsigned integaer value with mask and shift
++ *pReadingValue = (Value & Mask) >> Shift;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_demod_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_REG_BITS
++
++*/
++int
++dvbt_demod_default_SetRegBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ const unsigned long WritingValue
++ )
++{
++ unsigned char RegStartAddr;
++ unsigned char Msb;
++ unsigned char Lsb;
++
++
++ // Check if register bit name is available.
++ if(pDemod->RegTable[RegBitName].IsAvailable == NO)
++ goto error_status_register_bit_name;
++
++
++ // Get register start address, MSB, and LSB from register table with register bit name key.
++ RegStartAddr = pDemod->RegTable[RegBitName].RegStartAddr;
++ Msb = pDemod->RegTable[RegBitName].Msb;
++ Lsb = pDemod->RegTable[RegBitName].Lsb;
++
++
++ // Set register mask bits.
++ if(pDemod->SetRegMaskBits(pDemod, RegStartAddr, Msb, Lsb, WritingValue) != FUNCTION_SUCCESS)
++ goto error_status_set_demod_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_register_bit_name:
++error_status_set_demod_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_REG_BITS
++
++*/
++int
++dvbt_demod_default_GetRegBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ unsigned long *pReadingValue
++ )
++{
++ unsigned char RegStartAddr;
++ unsigned char Msb;
++ unsigned char Lsb;
++
++
++ // Check if register bit name is available.
++ if(pDemod->RegTable[RegBitName].IsAvailable == NO)
++ goto error_status_register_bit_name;
++
++
++ // Get register start address, MSB, and LSB from register table with register bit name key.
++ RegStartAddr = pDemod->RegTable[RegBitName].RegStartAddr;
++ Msb = pDemod->RegTable[RegBitName].Msb;
++ Lsb = pDemod->RegTable[RegBitName].Lsb;
++
++
++ // Get register mask bits.
++ if(pDemod->GetRegMaskBits(pDemod, RegStartAddr, Msb, Lsb, pReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_register_bit_name:
++error_status_get_demod_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_SET_REG_BITS_WITH_PAGE
++
++*/
++int
++dvbt_demod_default_SetRegBitsWithPage(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ const unsigned long WritingValue
++ )
++{
++ unsigned long PageNo;
++
++
++ // Get register page number from register table with register bit name key.
++ PageNo = pDemod->RegTable[RegBitName].PageNo;
++
++
++ // Set register page number.
++ if(pDemod->SetRegPage(pDemod, PageNo) != FUNCTION_SUCCESS)
++ goto error_status_set_demod_registers;
++
++
++ // Set register mask bits with register bit name key.
++ if(pDemod->SetRegBits(pDemod, RegBitName, WritingValue) != FUNCTION_SUCCESS)
++ goto error_status_set_demod_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_demod_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_REG_BITS_WITH_PAGE
++
++*/
++int
++dvbt_demod_default_GetRegBitsWithPage(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ unsigned long *pReadingValue
++ )
++{
++ unsigned long PageNo;
++
++
++ // Get register page number from register table with register bit name key.
++ PageNo = pDemod->RegTable[RegBitName].PageNo;
++
++
++ // Set register page number.
++ if(pDemod->SetRegPage(pDemod, PageNo) != FUNCTION_SUCCESS)
++ goto error_status_set_demod_registers;
++
++
++ // Get register mask bits with register bit name key.
++ if(pDemod->GetRegBits(pDemod, RegBitName, pReadingValue) != FUNCTION_SUCCESS)
++ goto error_status_get_demod_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_demod_registers:
++error_status_get_demod_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_DEMOD_TYPE
++
++*/
++void
++dvbt_demod_default_GetDemodType(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pDemodType
++ )
++{
++ // Get demod type from demod module.
++ *pDemodType = pDemod->DemodType;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_DEVICE_ADDR
++
++*/
++void
++dvbt_demod_default_GetDeviceAddr(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char *pDeviceAddr
++ )
++{
++ // Get demod I2C device address from demod module.
++ *pDeviceAddr = pDemod->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_CRYSTAL_FREQ_HZ
++
++*/
++void
++dvbt_demod_default_GetCrystalFreqHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pCrystalFreqHz
++ )
++{
++ // Get demod crystal frequency in Hz from demod module.
++ *pCrystalFreqHz = pDemod->CrystalFreqHz;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_BANDWIDTH_MODE
++
++*/
++int
++dvbt_demod_default_GetBandwidthMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pBandwidthMode
++ )
++{
++ // Get demod bandwidth mode from demod module.
++ if(pDemod->IsBandwidthModeSet != YES)
++ goto error_status_get_demod_bandwidth_mode;
++
++ *pBandwidthMode = pDemod->BandwidthMode;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_demod_bandwidth_mode:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_IF_FREQ_HZ
++
++*/
++int
++dvbt_demod_default_GetIfFreqHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pIfFreqHz
++ )
++{
++ // Get demod IF frequency in Hz from demod module.
++ if(pDemod->IsIfFreqHzSet != YES)
++ goto error_status_get_demod_if_frequency;
++
++ *pIfFreqHz = pDemod->IfFreqHz;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_demod_if_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_DEMOD_FP_GET_SPECTRUM_MODE
++
++*/
++int
++dvbt_demod_default_GetSpectrumMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pSpectrumMode
++ )
++{
++ // Get demod spectrum mode from demod module.
++ if(pDemod->IsSpectrumModeSet != YES)
++ goto error_status_get_demod_spectrum_mode;
++
++ *pSpectrumMode = pDemod->SpectrumMode;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_demod_spectrum_mode:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++
++
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/dvbt_demod_base.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/dvbt_demod_base.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,2547 @@
++#ifndef __DVBT_DEMOD_BASE_H
++#define __DVBT_DEMOD_BASE_H
++
++/**
++
++@file
++
++@brief DVB-T demod base module definition
++
++DVB-T demod base module definitions contains demod module structure, demod funciton pointers, and demod definitions.
++
++
++
++@par Example:
++@code
++
++
++#include "demod_xxx.h"
++
++
++
++int
++CustomI2cRead(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++ return FUNCTION_ERROR;
++}
++
++
++
++int
++CustomI2cWrite(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++ return FUNCTION_ERROR;
++}
++
++
++
++void
++CustomWaitMs(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned long WaitTimeMs
++ )
++{
++ ...
++}
++
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE DvbtDemodModuleMemory;
++
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory;
++
++ int BandwidthMode;
++ unsigned long IfFreqHz;
++ int SpectrumMode;
++
++ int DemodType;
++ unsigned char DeviceAddr;
++ unsigned long CrystalFreqHz;
++
++ long RfAgc, IfAgc;
++ unsigned long DiAgc;
++
++ int Answer;
++ long TrOffsetPpm, CrOffsetHz;
++ unsigned long BerNum, BerDen;
++ double Ber;
++ long SnrDbNum, SnrDbDen;
++ double SnrDb;
++ unsigned long SignalStrength, SignalQuality;
++
++ int Constellation;
++ int Hierarchy;
++ int CodeRateLp;
++ int CodeRateHp;
++ int GuardInterval;
++ int FftMode;
++
++
++
++ // Build base interface module.
++ BuildBaseInterface(
++ &pBaseInterface,
++ &BaseInterfaceModuleMemory,
++ 9, // Set maximum I2C reading byte number with 9.
++ 8, // Set maximum I2C writing byte number with 8.
++ CustomI2cRead, // Employ CustomI2cRead() as basic I2C reading function.
++ CustomI2cWrite, // Employ CustomI2cWrite() as basic I2C writing function.
++ CustomWaitMs // Employ CustomWaitMs() as basic waiting function.
++ );
++
++
++ // Build DVB-T demod XXX module.
++ BuildXxxModule(
++ &pDemod,
++ &DvbtDemodModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ 0x20, // Demod I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // Demod crystal frequency is 28.8 MHz.
++ ... // Other arguments by each demod module
++ );
++
++
++
++
++
++ // ==== Initialize DVB-T demod and set its parameters =====
++
++ // Initialize demod.
++ pDemod->Initialize(pDemod);
++
++
++ // Set demod parameters. (bandwidth mode, IF frequency, spectrum mode)
++ // Note: In the example:
++ // 1. Bandwidth mode is 8 MHz.
++ // 2. IF frequency is 36.125 MHz.
++ // 3. Spectrum mode is SPECTRUM_INVERSE.
++ BandwidthMode = DVBT_BANDWIDTH_8MHZ;
++ IfFreqHz = IF_FREQ_36125000HZ;
++ SpectrumMode = SPECTRUM_INVERSE;
++
++ pDemod->SetBandwidthMode(pDemod, BandwidthMode);
++ pDemod->SetIfFreqHz(pDemod, IfFreqHz);
++ pDemod->SetSpectrumMode(pDemod, SpectrumMode);
++
++
++ // Need to set tuner before demod software reset.
++ // The order to set demod and tuner is not important.
++ // Note: One can use "pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1);"
++ // for tuner I2C command forwarding.
++
++
++ // Reset demod by software reset.
++ pDemod->SoftwareReset(pDemod);
++
++
++ // Wait maximum 1000 ms for demod converge.
++ for(i = 0; i < 25; i++)
++ {
++ // Wait 40 ms.
++ pBaseInterface->WaitMs(pBaseInterface, 40);
++
++ // Check signal lock status.
++ // Note: If Answer is YES, signal is locked.
++ // If Answer is NO, signal is not locked.
++ pDemod->IsSignalLocked(pDemod, &Answer);
++
++ if(Answer == YES)
++ {
++ // Signal is locked.
++ break;
++ }
++ }
++
++
++
++
++
++ // ==== Get DVB-T demod information =====
++
++ // Get demod type.
++ // Note: One can find demod type in MODULE_TYPE enumeration.
++ pDemod->GetDemodType(pDemod, &DemodType);
++
++ // Get demod I2C device address.
++ pDemod->GetDeviceAddr(pDemod, &DeviceAddr);
++
++ // Get demod crystal frequency in Hz.
++ pDemod->GetCrystalFreqHz(pDemod, &CrystalFreqHz);
++
++
++ // Ask demod if it is connected to I2C bus.
++ // Note: If Answer is YES, demod is connected to I2C bus.
++ // If Answer is NO, demod is not connected to I2C bus.
++ pDemod->IsConnectedToI2c(pDemod, &Answer);
++
++
++ // Get demod parameters. (bandwidth mode, IF frequency, spectrum mode)
++ pDemod->GetBandwidthMode(pDemod, &BandwidthMode);
++ pDemod->GetIfFreqHz(pDemod, &IfFreqHz);
++ pDemod->GetSpectrumMode(pDemod, &SpectrumMode);
++
++
++ // Get demod AGC value.
++ // Note: The range of RF AGC and IF AGC value is -8192 ~ 8191.
++ // The range of digital AGC value is 0 ~ 255.
++ pDemod->GetRfAgc(pDemod, &RfAgc);
++ pDemod->GetIfAgc(pDemod, &IfAgc);
++ pDemod->GetDiAgc(pDemod, &DiAgc);
++
++
++ // Get demod lock status.
++ // Note: If Answer is YES, it is locked.
++ // If Answer is NO, it is not locked.
++ pDemod->IsTpsLocked(pDemod, &Answer);
++ pDemod->IsSignalLocked(pDemod, &Answer);
++
++
++ // Get TR offset (symbol timing offset) in ppm.
++ pDemod->GetTrOffsetPpm(pDemod, &TrOffsetPpm);
++
++ // Get CR offset (RF frequency offset) in Hz.
++ pDemod->GetCrOffsetHz(pDemod, &CrOffsetHz);
++
++
++ // Get BER.
++ pDemod->GetBer(pDemod, &BerNum, &BerDen);
++ Ber = (double)BerNum / (double)BerDen;
++
++ // Get SNR in dB.
++ pDemod->GetSnrDb(pDemod, &SnrDbNum, &SnrDbDen);
++ SnrDb = (double)SnrDbNum / (double)SnrDbDen;
++
++
++ // Get signal strength.
++ // Note: 1. The range of SignalStrength is 0~100.
++ // 2. Need to map SignalStrength value to UI signal strength bar manually.
++ pDemod->GetSignalStrength(pDemod, &SignalStrength);
++
++ // Get signal quality.
++ // Note: 1. The range of SignalQuality is 0~100.
++ // 2. Need to map SignalQuality value to UI signal quality bar manually.
++ pDemod->GetSignalQuality(pDemod, &SignalQuality);
++
++
++ // Get TPS information.
++ // Note: One can find TPS information definitions in the enumerations as follows:
++ // 1. DVBT_CONSTELLATION_MODE.
++ // 2. DVBT_HIERARCHY_MODE.
++ // 3. DVBT_CODE_RATE_MODE. (for low-priority and high-priority code rate)
++ // 4. DVBT_GUARD_INTERVAL_MODE.
++ // 5. DVBT_FFT_MODE_MODE
++ pDemod->GetConstellation(pDemod, &Constellation);
++ pDemod->GetHierarchy(pDemod, &Hierarchy);
++ pDemod->GetCodeRateLp(pDemod, &CodeRateLp);
++ pDemod->GetCodeRateHp(pDemod, &CodeRateHp);
++ pDemod->GetGuardInterval(pDemod, &GuardInterval);
++ pDemod->GetFftMode(pDemod, &FftMode);
++
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "foundation.h"
++
++
++
++
++
++// Definitions
++
++// Page register address
++#define DVBT_DEMOD_PAGE_REG_ADDR 0x00
++
++
++// Bandwidth modes
++#define DVBT_BANDWIDTH_NONE -1
++enum DVBT_BANDWIDTH_MODE
++{
++ DVBT_BANDWIDTH_6MHZ,
++ DVBT_BANDWIDTH_7MHZ,
++ DVBT_BANDWIDTH_8MHZ,
++};
++#define DVBT_BANDWIDTH_MODE_NUM 3
++
++
++// Constellation
++enum DVBT_CONSTELLATION_MODE
++{
++ DVBT_CONSTELLATION_QPSK,
++ DVBT_CONSTELLATION_16QAM,
++ DVBT_CONSTELLATION_64QAM,
++};
++#define DVBT_CONSTELLATION_NUM 3
++
++
++// Hierarchy
++enum DVBT_HIERARCHY_MODE
++{
++ DVBT_HIERARCHY_NONE,
++ DVBT_HIERARCHY_ALPHA_1,
++ DVBT_HIERARCHY_ALPHA_2,
++ DVBT_HIERARCHY_ALPHA_4,
++};
++#define DVBT_HIERARCHY_NUM 4
++
++
++// Code rate
++enum DVBT_CODE_RATE_MODE
++{
++ DVBT_CODE_RATE_1_OVER_2,
++ DVBT_CODE_RATE_2_OVER_3,
++ DVBT_CODE_RATE_3_OVER_4,
++ DVBT_CODE_RATE_5_OVER_6,
++ DVBT_CODE_RATE_7_OVER_8,
++};
++#define DVBT_CODE_RATE_NUM 5
++
++
++// Guard interval
++enum DVBT_GUARD_INTERVAL_MODE
++{
++ DVBT_GUARD_INTERVAL_1_OVER_32,
++ DVBT_GUARD_INTERVAL_1_OVER_16,
++ DVBT_GUARD_INTERVAL_1_OVER_8,
++ DVBT_GUARD_INTERVAL_1_OVER_4,
++};
++#define DVBT_GUARD_INTERVAL_NUM 4
++
++
++// FFT mode
++enum DVBT_FFT_MODE_MODE
++{
++ DVBT_FFT_MODE_2K,
++ DVBT_FFT_MODE_8K,
++};
++#define DVBT_FFT_MODE_NUM 2
++
++
++
++
++
++// Register entry definitions
++
++// Register entry
++typedef struct
++{
++ int IsAvailable;
++ unsigned long PageNo;
++ unsigned char RegStartAddr;
++ unsigned char Msb;
++ unsigned char Lsb;
++}
++DVBT_REG_ENTRY;
++
++
++
++// Primary register entry
++typedef struct
++{
++ int RegBitName;
++ unsigned long PageNo;
++ unsigned char RegStartAddr;
++ unsigned char Msb;
++ unsigned char Lsb;
++}
++DVBT_PRIMARY_REG_ENTRY;
++
++
++
++
++
++// Register table dependence
++
++// Demod register bit names
++enum DVBT_REG_BIT_NAME
++{
++ // Software reset register
++ DVBT_SOFT_RST,
++
++ // Tuner I2C forwording register
++ DVBT_IIC_REPEAT,
++
++
++ // Registers for initializing
++ DVBT_TR_WAIT_MIN_8K,
++ DVBT_RSD_BER_FAIL_VAL,
++ DVBT_EN_BK_TRK,
++ DVBT_REG_PI,
++
++ DVBT_REG_PFREQ_1_0, // For RTL2830 only
++ DVBT_PD_DA8, // For RTL2830 only
++ DVBT_LOCK_TH, // For RTL2830 only
++ DVBT_BER_PASS_SCAL, // For RTL2830 only
++ DVBT_CE_FFSM_BYPASS, // For RTL2830 only
++ DVBT_ALPHAIIR_N, // For RTL2830 only
++ DVBT_ALPHAIIR_DIF, // For RTL2830 only
++ DVBT_EN_TRK_SPAN, // For RTL2830 only
++ DVBT_LOCK_TH_LEN, // For RTL2830 only
++ DVBT_CCI_THRE, // For RTL2830 only
++ DVBT_CCI_MON_SCAL, // For RTL2830 only
++ DVBT_CCI_M0, // For RTL2830 only
++ DVBT_CCI_M1, // For RTL2830 only
++ DVBT_CCI_M2, // For RTL2830 only
++ DVBT_CCI_M3, // For RTL2830 only
++ DVBT_SPEC_INIT_0, // For RTL2830 only
++ DVBT_SPEC_INIT_1, // For RTL2830 only
++ DVBT_SPEC_INIT_2, // For RTL2830 only
++
++ DVBT_AD_EN_REG, // For RTL2832 only
++ DVBT_AD_EN_REG1, // For RTL2832 only
++ DVBT_EN_BBIN, // For RTL2832 only
++ DVBT_MGD_THD0, // For RTL2832 only
++ DVBT_MGD_THD1, // For RTL2832 only
++ DVBT_MGD_THD2, // For RTL2832 only
++ DVBT_MGD_THD3, // For RTL2832 only
++ DVBT_MGD_THD4, // For RTL2832 only
++ DVBT_MGD_THD5, // For RTL2832 only
++ DVBT_MGD_THD6, // For RTL2832 only
++ DVBT_MGD_THD7, // For RTL2832 only
++ DVBT_EN_CACQ_NOTCH, // For RTL2832 only
++ DVBT_AD_AV_REF, // For RTL2832 only
++ DVBT_PIP_ON, // For RTL2832 only
++ DVBT_SCALE1_B92, // For RTL2832 only
++ DVBT_SCALE1_B93, // For RTL2832 only
++ DVBT_SCALE1_BA7, // For RTL2832 only
++ DVBT_SCALE1_BA9, // For RTL2832 only
++ DVBT_SCALE1_BAA, // For RTL2832 only
++ DVBT_SCALE1_BAB, // For RTL2832 only
++ DVBT_SCALE1_BAC, // For RTL2832 only
++ DVBT_SCALE1_BB0, // For RTL2832 only
++ DVBT_SCALE1_BB1, // For RTL2832 only
++ DVBT_KB_P1, // For RTL2832 only
++ DVBT_KB_P2, // For RTL2832 only
++ DVBT_KB_P3, // For RTL2832 only
++ DVBT_OPT_ADC_IQ, // For RTL2832 only
++ DVBT_AD_AVI, // For RTL2832 only
++ DVBT_AD_AVQ, // For RTL2832 only
++ DVBT_K1_CR_STEP12, // For RTL2832 only
++
++ // Registers for initializing according to mode
++ DVBT_TRK_KS_P2,
++ DVBT_TRK_KS_I2,
++ DVBT_TR_THD_SET2,
++ DVBT_TRK_KC_P2,
++ DVBT_TRK_KC_I2,
++ DVBT_CR_THD_SET2,
++
++ // Registers for IF setting
++ DVBT_PSET_IFFREQ,
++ DVBT_SPEC_INV,
++
++
++ // Registers for bandwidth programming
++ DVBT_BW_INDEX, // For RTL2830 only
++
++ DVBT_RSAMP_RATIO, // For RTL2832 only
++ DVBT_CFREQ_OFF_RATIO, // For RTL2832 only
++
++
++ // FSM stage register
++ DVBT_FSM_STAGE,
++
++ // TPS content registers
++ DVBT_RX_CONSTEL,
++ DVBT_RX_HIER,
++ DVBT_RX_C_RATE_LP,
++ DVBT_RX_C_RATE_HP,
++ DVBT_GI_IDX,
++ DVBT_FFT_MODE_IDX,
++
++ // Performance measurement registers
++ DVBT_RSD_BER_EST,
++ DVBT_CE_EST_EVM,
++
++ // AGC registers
++ DVBT_RF_AGC_VAL,
++ DVBT_IF_AGC_VAL,
++ DVBT_DAGC_VAL,
++
++ // TR offset and CR offset registers
++ DVBT_SFREQ_OFF,
++ DVBT_CFREQ_OFF,
++
++
++ // AGC relative registers
++ DVBT_POLAR_RF_AGC,
++ DVBT_POLAR_IF_AGC,
++ DVBT_AAGC_HOLD,
++ DVBT_EN_RF_AGC,
++ DVBT_EN_IF_AGC,
++ DVBT_IF_AGC_MIN,
++ DVBT_IF_AGC_MAX,
++ DVBT_RF_AGC_MIN,
++ DVBT_RF_AGC_MAX,
++ DVBT_IF_AGC_MAN,
++ DVBT_IF_AGC_MAN_VAL,
++ DVBT_RF_AGC_MAN,
++ DVBT_RF_AGC_MAN_VAL,
++ DVBT_DAGC_TRG_VAL,
++
++ DVBT_AGC_TARG_VAL, // For RTL2830 only
++ DVBT_LOOP_GAIN_3_0, // For RTL2830 only
++ DVBT_LOOP_GAIN_4, // For RTL2830 only
++ DVBT_VTOP, // For RTL2830 only
++ DVBT_KRF, // For RTL2830 only
++
++ DVBT_AGC_TARG_VAL_0, // For RTL2832 only
++ DVBT_AGC_TARG_VAL_8_1, // For RTL2832 only
++ DVBT_AAGC_LOOP_GAIN, // For RTL2832 only
++ DVBT_LOOP_GAIN2_3_0, // For RTL2832 only
++ DVBT_LOOP_GAIN2_4, // For RTL2832 only
++ DVBT_LOOP_GAIN3, // For RTL2832 only
++ DVBT_VTOP1, // For RTL2832 only
++ DVBT_VTOP2, // For RTL2832 only
++ DVBT_VTOP3, // For RTL2832 only
++ DVBT_KRF1, // For RTL2832 only
++ DVBT_KRF2, // For RTL2832 only
++ DVBT_KRF3, // For RTL2832 only
++ DVBT_KRF4, // For RTL2832 only
++
++
++ // TS interface registers
++ DVBT_CKOUTPAR,
++ DVBT_CKOUT_PWR,
++ DVBT_SYNC_DUR,
++ DVBT_ERR_DUR,
++ DVBT_SYNC_LVL,
++ DVBT_ERR_LVL,
++ DVBT_VAL_LVL,
++ DVBT_SERIAL,
++ DVBT_SER_LSB,
++ DVBT_CDIV_PH0,
++ DVBT_CDIV_PH1,
++
++ DVBT_CKOUTPAR_PIP, // For RTL2832 only
++ DVBT_CKOUT_PWR_PIP, // For RTL2832 only
++ DVBT_SYNC_LVL_PIP, // For RTL2832 only
++ DVBT_ERR_LVL_PIP, // For RTL2832 only
++ DVBT_VAL_LVL_PIP, // For RTL2832 only
++ DVBT_CKOUTPAR_PID, // For RTL2832 only
++ DVBT_CKOUT_PWR_PID, // For RTL2832 only
++ DVBT_SYNC_LVL_PID, // For RTL2832 only
++ DVBT_ERR_LVL_PID, // For RTL2832 only
++ DVBT_VAL_LVL_PID, // For RTL2832 only
++
++
++ // FSM state-holding register
++ DVBT_SM_PASS,
++
++ // Registers for function 2 (for RTL2830 only)
++ DVBT_UPDATE_REG_2,
++
++ // Registers for function 3 (for RTL2830 only)
++ DVBT_BTHD_P3,
++ DVBT_BTHD_D3,
++
++ // Registers for function 4 (for RTL2830 only)
++ DVBT_FUNC4_REG0,
++ DVBT_FUNC4_REG1,
++ DVBT_FUNC4_REG2,
++ DVBT_FUNC4_REG3,
++ DVBT_FUNC4_REG4,
++ DVBT_FUNC4_REG5,
++ DVBT_FUNC4_REG6,
++ DVBT_FUNC4_REG7,
++ DVBT_FUNC4_REG8,
++ DVBT_FUNC4_REG9,
++ DVBT_FUNC4_REG10,
++
++ // Registers for functin 5 (for RTL2830 only)
++ DVBT_FUNC5_REG0,
++ DVBT_FUNC5_REG1,
++ DVBT_FUNC5_REG2,
++ DVBT_FUNC5_REG3,
++ DVBT_FUNC5_REG4,
++ DVBT_FUNC5_REG5,
++ DVBT_FUNC5_REG6,
++ DVBT_FUNC5_REG7,
++ DVBT_FUNC5_REG8,
++ DVBT_FUNC5_REG9,
++ DVBT_FUNC5_REG10,
++ DVBT_FUNC5_REG11,
++ DVBT_FUNC5_REG12,
++ DVBT_FUNC5_REG13,
++ DVBT_FUNC5_REG14,
++ DVBT_FUNC5_REG15,
++ DVBT_FUNC5_REG16,
++ DVBT_FUNC5_REG17,
++ DVBT_FUNC5_REG18,
++
++ // AD7 registers (for RTL2832 only)
++ DVBT_AD7_SETTING,
++ DVBT_RSSI_R,
++
++ // ACI detection registers (for RTL2832 only)
++ DVBT_ACI_DET_IND,
++
++ // Test registers for test only
++ DVBT_TEST_REG_1,
++ DVBT_TEST_REG_2,
++ DVBT_TEST_REG_3,
++ DVBT_TEST_REG_4,
++
++ // Item terminator
++ DVBT_REG_BIT_NAME_ITEM_TERMINATOR,
++};
++
++
++
++// Register table length definitions
++#define DVBT_REG_TABLE_LEN_MAX DVBT_REG_BIT_NAME_ITEM_TERMINATOR
++
++
++
++
++
++// DVB-T demod module pre-definition
++typedef struct DVBT_DEMOD_MODULE_TAG DVBT_DEMOD_MODULE;
++
++
++
++
++
++/**
++
++@brief DVB-T demod register page setting function pointer
++
++Demod upper level functions will use DVBT_DEMOD_FP_SET_REG_PAGE() to set demod register page.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] PageNo Page number
++
++
++@retval FUNCTION_SUCCESS Set register page successfully with page number.
++@retval FUNCTION_ERROR Set register page unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_REG_PAGE() with the corresponding function.
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Set demod register page with page number 2.
++ pDemod->SetRegPage(pDemod, 2);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_REG_PAGE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long PageNo
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register byte setting function pointer
++
++Demod upper level functions will use DVBT_DEMOD_FP_SET_REG_BYTES() to set demod register bytes.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegStartAddr Demod register start address
++@param [in] pWritingBytes Pointer to writing bytes
++@param [in] ByteNum Writing byte number
++
++
++@retval FUNCTION_SUCCESS Set demod register bytes successfully with writing bytes.
++@retval FUNCTION_ERROR Set demod register bytes unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_REG_BYTES() with the corresponding function.
++ -# Need to set register page by DVBT_DEMOD_FP_SET_REG_PAGE() before using DVBT_DEMOD_FP_SET_REG_BYTES().
++
++
++@see DVBT_DEMOD_FP_SET_REG_PAGE, DVBT_DEMOD_FP_GET_REG_BYTES
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++ unsigned char WritingBytes[10];
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Set demod register bytes (page 1, address 0x17 ~ 0x1b) with 5 writing bytes.
++ pDemod->SetRegPage(pDemod, 1);
++ pDemod->SetRegBytes(pDemod, 0x17, WritingBytes, 5);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_REG_BYTES)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register byte getting function pointer
++
++Demod upper level functions will use DVBT_DEMOD_FP_GET_REG_BYTES() to get demod register bytes.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegStartAddr Demod register start address
++@param [out] pReadingBytes Pointer to an allocated memory for storing reading bytes
++@param [in] ByteNum Reading byte number
++
++
++@retval FUNCTION_SUCCESS Get demod register bytes successfully with reading byte number.
++@retval FUNCTION_ERROR Get demod register bytes unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_REG_BYTES() with the corresponding function.
++ -# Need to set register page by DVBT_DEMOD_FP_SET_REG_PAGE() before using DVBT_DEMOD_FP_GET_REG_BYTES().
++
++
++@see DVBT_DEMOD_FP_SET_REG_PAGE, DVBT_DEMOD_FP_SET_REG_BYTES
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++ unsigned char ReadingBytes[10];
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Get demod register bytes (page 1, address 0x17 ~ 0x1b) with reading byte number 5.
++ pDemod->SetRegPage(pDemod, 1);
++ pDemod->GetRegBytes(pDemod, 0x17, ReadingBytes, 5);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_REG_BYTES)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register mask bits setting function pointer
++
++Demod upper level functions will use DVBT_DEMOD_FP_SET_REG_MASK_BITS() to set demod register mask bits.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegStartAddr Demod register start address
++@param [in] Msb Mask MSB with 0-based index
++@param [in] Lsb Mask LSB with 0-based index
++@param [in] WritingValue The mask bits writing value
++
++
++@retval FUNCTION_SUCCESS Set demod register mask bits successfully with writing value.
++@retval FUNCTION_ERROR Set demod register mask bits unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_REG_MASK_BITS() with the corresponding function.
++ -# Need to set register page by DVBT_DEMOD_FP_SET_REG_PAGE() before using DVBT_DEMOD_FP_SET_REG_MASK_BITS().
++ -# The constraints of DVBT_DEMOD_FP_SET_REG_MASK_BITS() function usage are described as follows:
++ -# The mask MSB and LSB must be 0~31.
++ -# The mask MSB must be greater than or equal to LSB.
++
++
++@see DVBT_DEMOD_FP_SET_REG_PAGE, DVBT_DEMOD_FP_GET_REG_MASK_BITS
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Set demod register bits (page 1, address {0x18, 0x17} [12:5]) with writing value 0x1d.
++ pDemod->SetRegPage(pDemod, 1);
++ pDemod->SetRegMaskBits(pDemod, 0x17, 12, 5, 0x1d);
++
++
++ // Result:
++ //
++ // Writing value = 0x1d = 0001 1101 b
++ //
++ // Page 1
++ // Register address 0x17 0x18
++ // Register value xxx0 0011 b 101x xxxx b
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_REG_MASK_BITS)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char Msb,
++ unsigned char Lsb,
++ const unsigned long WritingValue
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register mask bits getting function pointer
++
++Demod upper level functions will use DVBT_DEMOD_FP_GET_REG_MASK_BITS() to get demod register mask bits.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegStartAddr Demod register start address
++@param [in] Msb Mask MSB with 0-based index
++@param [in] Lsb Mask LSB with 0-based index
++@param [out] pReadingValue Pointer to an allocated memory for storing reading value
++
++
++@retval FUNCTION_SUCCESS Get demod register mask bits successfully.
++@retval FUNCTION_ERROR Get demod register mask bits unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_REG_MASK_BITS() with the corresponding function.
++ -# Need to set register page by DVBT_DEMOD_FP_SET_REG_PAGE() before using DVBT_DEMOD_FP_GET_REG_MASK_BITS().
++ -# The constraints of DVBT_DEMOD_FP_GET_REG_MASK_BITS() function usage are described as follows:
++ -# The mask MSB and LSB must be 0~31.
++ -# The mask MSB must be greater than or equal to LSB.
++
++
++@see DVBT_DEMOD_FP_SET_REG_PAGE, DVBT_DEMOD_FP_SET_REG_MASK_BITS
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++ unsigned long ReadingValue;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Get demod register bits (page 1, address {0x18, 0x17} [12:5]).
++ pDemod->SetRegPage(pDemod, 1);
++ pDemod->GetRegMaskBits(pDemod, 0x17, 12, 5, &ReadingValue);
++
++
++ // Result:
++ //
++ // Page 1
++ // Register address 0x18 0x17
++ // Register value xxx0 0011 b 101x xxxx b
++ //
++ // Reading value = 0001 1101 b = 0x1d
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_REG_MASK_BITS)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char Msb,
++ unsigned char Lsb,
++ unsigned long *pReadingValue
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register bits setting function pointer
++
++Demod upper level functions will use DVBT_DEMOD_FP_SET_REG_BITS() to set demod register bits with bit name.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegBitName Pre-defined demod register bit name
++@param [in] WritingValue The mask bits writing value
++
++
++@retval FUNCTION_SUCCESS Set demod register bits successfully with bit name and writing value.
++@retval FUNCTION_ERROR Set demod register bits unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_REG_BITS() with the corresponding function.
++ -# Need to set register page before using DVBT_DEMOD_FP_SET_REG_BITS().
++ -# Register bit names are pre-defined keys for bit access, and one can find these in demod header file.
++
++
++@see DVBT_DEMOD_FP_SET_REG_PAGE, DVBT_DEMOD_FP_GET_REG_BITS
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Set demod register bits with bit name PSEUDO_REG_BIT_NAME and writing value 0x1d.
++ // The corresponding information of PSEUDO_REG_BIT_NAME is address {0x18, 0x17} [12:5] on page 1.
++ pDemod->SetRegPage(pDemod, 1);
++ pDemod->SetRegBits(pDemod, PSEUDO_REG_BIT_NAME, 0x1d);
++
++
++ // Result:
++ //
++ // Writing value = 0x1d = 0001 1101 b
++ //
++ // Page 1
++ // Register address 0x18 0x17
++ // Register value xxx0 0011 b 101x xxxx b
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_REG_BITS)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ const unsigned long WritingValue
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register bits getting function pointer
++
++Demod upper level functions will use DVBT_DEMOD_FP_GET_REG_BITS() to get demod register bits with bit name.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegBitName Pre-defined demod register bit name
++@param [out] pReadingValue Pointer to an allocated memory for storing reading value
++
++
++@retval FUNCTION_SUCCESS Get demod register bits successfully with bit name.
++@retval FUNCTION_ERROR Get demod register bits unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_REG_BITS() with the corresponding function.
++ -# Need to set register page before using DVBT_DEMOD_FP_GET_REG_BITS().
++ -# Register bit names are pre-defined keys for bit access, and one can find these in demod header file.
++
++
++@see DVBT_DEMOD_FP_SET_REG_PAGE, DVBT_DEMOD_FP_SET_REG_BITS
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++ unsigned long ReadingValue;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Get demod register bits with bit name PSEUDO_REG_BIT_NAME.
++ // The corresponding information of PSEUDO_REG_BIT_NAME is address {0x18, 0x17} [12:5] on page 1.
++ pDemod->SetRegPage(pDemod, 1);
++ pDemod->GetRegBits(pDemod, PSEUDO_REG_BIT_NAME, &ReadingValue);
++
++
++ // Result:
++ //
++ // Page 1
++ // Register address 0x18 0x17
++ // Register value xxx0 0011 b 101x xxxx b
++ //
++ // Reading value = 0001 1101 b = 0x1d
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_REG_BITS)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ unsigned long *pReadingValue
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register bits setting function pointer (with page setting)
++
++Demod upper level functions will use DVBT_DEMOD_FP_SET_REG_BITS_WITH_PAGE() to set demod register bits with bit name and
++page setting.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegBitName Pre-defined demod register bit name
++@param [in] WritingValue The mask bits writing value
++
++
++@retval FUNCTION_SUCCESS Set demod register bits successfully with bit name, page setting, and writing value.
++@retval FUNCTION_ERROR Set demod register bits unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_REG_BITS_WITH_PAGE() with the corresponding function.
++ -# Don't need to set register page before using DVBT_DEMOD_FP_SET_REG_BITS_WITH_PAGE().
++ -# Register bit names are pre-defined keys for bit access, and one can find these in demod header file.
++
++
++@see DVBT_DEMOD_FP_GET_REG_BITS_WITH_PAGE
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Set demod register bits with bit name PSEUDO_REG_BIT_NAME and writing value 0x1d.
++ // The corresponding information of PSEUDO_REG_BIT_NAME is address {0x18, 0x17} [12:5] on page 1.
++ pDemod->SetRegBitsWithPage(pDemod, PSEUDO_REG_BIT_NAME, 0x1d);
++
++
++ // Result:
++ //
++ // Writing value = 0x1d = 0001 1101 b
++ //
++ // Page 1
++ // Register address 0x18 0x17
++ // Register value xxx0 0011 b 101x xxxx b
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_REG_BITS_WITH_PAGE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ const unsigned long WritingValue
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod register bits getting function pointer (with page setting)
++
++Demod upper level functions will use DVBT_DEMOD_FP_GET_REG_BITS_WITH_PAGE() to get demod register bits with bit name and
++page setting.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] RegBitName Pre-defined demod register bit name
++@param [out] pReadingValue Pointer to an allocated memory for storing reading value
++
++
++@retval FUNCTION_SUCCESS Get demod register bits successfully with bit name and page setting.
++@retval FUNCTION_ERROR Get demod register bits unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_REG_BITS_WITH_PAGE() with the corresponding function.
++ -# Don't need to set register page before using DVBT_DEMOD_FP_GET_REG_BITS_WITH_PAGE().
++ -# Register bit names are pre-defined keys for bit access, and one can find these in demod header file.
++
++
++@see DVBT_DEMOD_FP_SET_REG_BITS_WITH_PAGE
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE AtscDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++ unsigned long ReadingValue;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &AtscDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Get demod register bits with bit name PSEUDO_REG_BIT_NAME.
++ // The corresponding information of PSEUDO_REG_BIT_NAME is address {0x18, 0x17} [12:5] on page 1.
++ pDemod->GetRegBitsWithPage(pDemod, PSEUDO_REG_BIT_NAME, &ReadingValue);
++
++
++ // Result:
++ //
++ // Page 1
++ // Register address 0x18 0x17
++ // Register value xxx0 0011 b 101x xxxx b
++ //
++ // Reading value = 0001 1101 b = 0x1d
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_REG_BITS_WITH_PAGE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ unsigned long *pReadingValue
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod type getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_DEMOD_TYPE() to get DVB-T demod type.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pDemodType Pointer to an allocated memory for storing demod type
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_DEMOD_TYPE() with the corresponding function.
++
++
++@see MODULE_TYPE
++
++*/
++typedef void
++(*DVBT_DEMOD_FP_GET_DEMOD_TYPE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pDemodType
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod I2C device address getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_DEVICE_ADDR() to get DVB-T demod I2C device address.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pDeviceAddr Pointer to an allocated memory for storing demod I2C device address
++
++
++@retval FUNCTION_SUCCESS Get demod device address successfully.
++@retval FUNCTION_ERROR Get demod device address unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_DEVICE_ADDR() with the corresponding function.
++
++*/
++typedef void
++(*DVBT_DEMOD_FP_GET_DEVICE_ADDR)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char *pDeviceAddr
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod crystal frequency getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_CRYSTAL_FREQ_HZ() to get DVB-T demod crystal frequency in Hz.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pCrystalFreqHz Pointer to an allocated memory for storing demod crystal frequency in Hz
++
++
++@retval FUNCTION_SUCCESS Get demod crystal frequency successfully.
++@retval FUNCTION_ERROR Get demod crystal frequency unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_CRYSTAL_FREQ_HZ() with the corresponding function.
++
++*/
++typedef void
++(*DVBT_DEMOD_FP_GET_CRYSTAL_FREQ_HZ)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pCrystalFreqHz
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod I2C bus connection asking function pointer
++
++One can use DVBT_DEMOD_FP_IS_CONNECTED_TO_I2C() to ask DVB-T demod if it is connected to I2C bus.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pAnswer Pointer to an allocated memory for storing answer
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_IS_CONNECTED_TO_I2C() with the corresponding function.
++
++*/
++typedef void
++(*DVBT_DEMOD_FP_IS_CONNECTED_TO_I2C)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod software resetting function pointer
++
++One can use DVBT_DEMOD_FP_SOFTWARE_RESET() to reset DVB-T demod by software reset.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Reset demod by software reset successfully.
++@retval FUNCTION_ERROR Reset demod by software reset unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SOFTWARE_RESET() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SOFTWARE_RESET)(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod initializing function pointer
++
++One can use DVBT_DEMOD_FP_INITIALIZE() to initialie DVB-T demod.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Initialize demod successfully.
++@retval FUNCTION_ERROR Initialize demod unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_INITIALIZE() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_INITIALIZE)(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod bandwidth mode setting function pointer
++
++One can use DVBT_DEMOD_FP_SET_DVBT_MODE() to set DVB-T demod bandwidth mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] BandwidthMode Bandwidth mode for setting
++
++
++@retval FUNCTION_SUCCESS Set demod bandwidth mode successfully.
++@retval FUNCTION_ERROR Set demod bandwidth mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_DVBT_MODE() with the corresponding function.
++
++
++@see DVBT_BANDWIDTH_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_BANDWIDTH_MODE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int BandwidthMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod IF frequency setting function pointer
++
++One can use DVBT_DEMOD_FP_SET_IF_FREQ_HZ() to set DVB-T demod IF frequency in Hz.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] IfFreqHz IF frequency in Hz for setting
++
++
++@retval FUNCTION_SUCCESS Set demod IF frequency successfully.
++@retval FUNCTION_ERROR Set demod IF frequency unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_IF_FREQ_HZ() with the corresponding function.
++
++
++@see IF_FREQ_HZ
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_IF_FREQ_HZ)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long IfFreqHz
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod spectrum mode setting function pointer
++
++One can use DVBT_DEMOD_FP_SET_SPECTRUM_MODE() to set DVB-T demod spectrum mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [in] SpectrumMode Spectrum mode for setting
++
++
++@retval FUNCTION_SUCCESS Set demod spectrum mode successfully.
++@retval FUNCTION_ERROR Set demod spectrum mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_SET_SPECTRUM_MODE() with the corresponding function.
++
++
++@see SPECTRUM_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_SET_SPECTRUM_MODE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int SpectrumMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod bandwidth mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_DVBT_MODE() to get DVB-T demod bandwidth mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pBandwidthMode Pointer to an allocated memory for storing demod bandwidth mode
++
++
++@retval FUNCTION_SUCCESS Get demod bandwidth mode successfully.
++@retval FUNCTION_ERROR Get demod bandwidth mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_DVBT_MODE() with the corresponding function.
++
++
++@see DVBT_DVBT_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_BANDWIDTH_MODE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pBandwidthMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod IF frequency getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_IF_FREQ_HZ() to get DVB-T demod IF frequency in Hz.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pIfFreqHz Pointer to an allocated memory for storing demod IF frequency in Hz
++
++
++@retval FUNCTION_SUCCESS Get demod IF frequency successfully.
++@retval FUNCTION_ERROR Get demod IF frequency unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_IF_FREQ_HZ() with the corresponding function.
++
++
++@see IF_FREQ_HZ
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_IF_FREQ_HZ)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pIfFreqHz
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod spectrum mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_SPECTRUM_MODE() to get DVB-T demod spectrum mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pSpectrumMode Pointer to an allocated memory for storing demod spectrum mode
++
++
++@retval FUNCTION_SUCCESS Get demod spectrum mode successfully.
++@retval FUNCTION_ERROR Get demod spectrum mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_SPECTRUM_MODE() with the corresponding function.
++
++
++@see SPECTRUM_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_SPECTRUM_MODE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pSpectrumMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod TPS lock asking function pointer
++
++One can use DVBT_DEMOD_FP_IS_TPS_LOCKED() to ask DVB-T demod if it is TPS-locked.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pAnswer Pointer to an allocated memory for storing answer
++
++
++@retval FUNCTION_SUCCESS Perform TPS lock asking to demod successfully.
++@retval FUNCTION_ERROR Perform TPS lock asking to demod unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_IS_TPS_LOCKED() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_IS_TPS_LOCKED)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod signal lock asking function pointer
++
++One can use DVBT_DEMOD_FP_IS_SIGNAL_LOCKED() to ask DVB-T demod if it is signal-locked.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pAnswer Pointer to an allocated memory for storing answer
++
++
++@retval FUNCTION_SUCCESS Perform signal lock asking to demod successfully.
++@retval FUNCTION_ERROR Perform signal lock asking to demod unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_IS_SIGNAL_LOCKED() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_IS_SIGNAL_LOCKED)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pAnswer
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod signal strength getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_SIGNAL_STRENGTH() to get signal strength.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pSignalStrength Pointer to an allocated memory for storing signal strength (value = 0 ~ 100)
++
++
++@retval FUNCTION_SUCCESS Get demod signal strength successfully.
++@retval FUNCTION_ERROR Get demod signal strength unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_SIGNAL_STRENGTH() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_SIGNAL_STRENGTH)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pSignalStrength
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod signal quality getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_SIGNAL_QUALITY() to get signal quality.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pSignalQuality Pointer to an allocated memory for storing signal quality (value = 0 ~ 100)
++
++
++@retval FUNCTION_SUCCESS Get demod signal quality successfully.
++@retval FUNCTION_ERROR Get demod signal quality unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_SIGNAL_QUALITY() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_SIGNAL_QUALITY)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pSignalQuality
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod BER getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_BER() to get BER.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pBerNum Pointer to an allocated memory for storing BER numerator
++@param [out] pBerDen Pointer to an allocated memory for storing BER denominator
++
++
++@retval FUNCTION_SUCCESS Get demod error rate value successfully.
++@retval FUNCTION_ERROR Get demod error rate value unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_BER() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_BER)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pBerNum,
++ unsigned long *pBerDen
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod SNR getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_SNR_DB() to get SNR in dB.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pSnrDbNum Pointer to an allocated memory for storing SNR dB numerator
++@param [out] pSnrDbDen Pointer to an allocated memory for storing SNR dB denominator
++
++
++@retval FUNCTION_SUCCESS Get demod SNR successfully.
++@retval FUNCTION_ERROR Get demod SNR unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_SNR_DB() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_SNR_DB)(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pSnrDbNum,
++ long *pSnrDbDen
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod RF AGC getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_RF_AGC() to get DVB-T demod RF AGC value.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pRfAgc Pointer to an allocated memory for storing RF AGC value
++
++
++@retval FUNCTION_SUCCESS Get demod RF AGC value successfully.
++@retval FUNCTION_ERROR Get demod RF AGC value unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_RF_AGC() with the corresponding function.
++ -# The range of RF AGC value is (-pow(2, 13)) ~ (pow(2, 13) - 1).
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_RF_AGC)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pRfAgc
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod IF AGC getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_IF_AGC() to get DVB-T demod IF AGC value.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pIfAgc Pointer to an allocated memory for storing IF AGC value
++
++
++@retval FUNCTION_SUCCESS Get demod IF AGC value successfully.
++@retval FUNCTION_ERROR Get demod IF AGC value unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_IF_AGC() with the corresponding function.
++ -# The range of IF AGC value is (-pow(2, 13)) ~ (pow(2, 13) - 1).
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_IF_AGC)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pIfAgc
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod digital AGC getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_DI_AGC() to get DVB-T demod digital AGC value.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pDiAgc Pointer to an allocated memory for storing digital AGC value
++
++
++@retval FUNCTION_SUCCESS Get demod digital AGC value successfully.
++@retval FUNCTION_ERROR Get demod digital AGC value unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_DI_AGC() with the corresponding function.
++ -# The range of digital AGC value is 0 ~ (pow(2, 8) - 1).
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_DI_AGC)(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char *pDiAgc
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod TR offset getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_TR_OFFSET_PPM() to get TR offset in ppm.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pTrOffsetPpm Pointer to an allocated memory for storing TR offset in ppm
++
++
++@retval FUNCTION_SUCCESS Get demod TR offset successfully.
++@retval FUNCTION_ERROR Get demod TR offset unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_TR_OFFSET_PPM() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_TR_OFFSET_PPM)(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pTrOffsetPpm
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod CR offset getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_CR_OFFSET_HZ() to get CR offset in Hz.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pCrOffsetHz Pointer to an allocated memory for storing CR offset in Hz
++
++
++@retval FUNCTION_SUCCESS Get demod CR offset successfully.
++@retval FUNCTION_ERROR Get demod CR offset unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_CR_OFFSET_HZ() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_CR_OFFSET_HZ)(
++ DVBT_DEMOD_MODULE *pDemod,
++ long *pCrOffsetHz
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod constellation mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_CONSTELLATION() to get DVB-T demod constellation mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pConstellation Pointer to an allocated memory for storing demod constellation mode
++
++
++@retval FUNCTION_SUCCESS Get demod constellation mode successfully.
++@retval FUNCTION_ERROR Get demod constellation mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_CONSTELLATION() with the corresponding function.
++
++
++@see DVBT_CONSTELLATION_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_CONSTELLATION)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pConstellation
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod hierarchy mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_HIERARCHY() to get DVB-T demod hierarchy mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pHierarchy Pointer to an allocated memory for storing demod hierarchy mode
++
++
++@retval FUNCTION_SUCCESS Get demod hierarchy mode successfully.
++@retval FUNCTION_ERROR Get demod hierarchy mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_HIERARCHY() with the corresponding function.
++
++
++@see DVBT_HIERARCHY_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_HIERARCHY)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pHierarchy
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod low-priority code rate mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_CODE_RATE_LP() to get DVB-T demod low-priority code rate mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pCodeRateLp Pointer to an allocated memory for storing demod low-priority code rate mode
++
++
++@retval FUNCTION_SUCCESS Get demod low-priority code rate mode successfully.
++@retval FUNCTION_ERROR Get demod low-priority code rate mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_CODE_RATE_LP() with the corresponding function.
++
++
++@see DVBT_CODE_RATE_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_CODE_RATE_LP)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pCodeRateLp
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod high-priority code rate mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_CODE_RATE_HP() to get DVB-T demod high-priority code rate mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pCodeRateHp Pointer to an allocated memory for storing demod high-priority code rate mode
++
++
++@retval FUNCTION_SUCCESS Get demod high-priority code rate mode successfully.
++@retval FUNCTION_ERROR Get demod high-priority code rate mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_CODE_RATE_HP() with the corresponding function.
++
++
++@see DVBT_CODE_RATE_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_CODE_RATE_HP)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pCodeRateHp
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod guard interval mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_GUARD_INTERVAL() to get DVB-T demod guard interval mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pGuardInterval Pointer to an allocated memory for storing demod guard interval mode
++
++
++@retval FUNCTION_SUCCESS Get demod guard interval mode successfully.
++@retval FUNCTION_ERROR Get demod guard interval mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_GUARD_INTERVAL() with the corresponding function.
++
++
++@see DVBT_GUARD_INTERVAL_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_GUARD_INTERVAL)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pGuardInterval
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod FFT mode getting function pointer
++
++One can use DVBT_DEMOD_FP_GET_FFT_MODE() to get DVB-T demod FFT mode.
++
++
++@param [in] pDemod The demod module pointer
++@param [out] pFftMode Pointer to an allocated memory for storing demod FFT mode
++
++
++@retval FUNCTION_SUCCESS Get demod FFT mode successfully.
++@retval FUNCTION_ERROR Get demod FFT mode unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_GET_FFT_MODE() with the corresponding function.
++
++
++@see DVBT_FFT_MODE_MODE
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_GET_FFT_MODE)(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pFftMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod updating function pointer
++
++One can use DVBT_DEMOD_FP_UPDATE_FUNCTION() to update demod register setting.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Update demod setting successfully.
++@retval FUNCTION_ERROR Update demod setting unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_UPDATE_FUNCTION() with the corresponding function.
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE DvbtDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &DvbtDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Execute ResetFunction() before demod software reset.
++ pDemod->ResetFunction(pDemod);
++
++ // Reset demod by software.
++ pDemod->SoftwareReset(pDemod);
++
++ ...
++
++ return 0;
++}
++
++
++void PeriodicallyExecutingFunction
++{
++ // Executing UpdateFunction() periodically.
++ pDemod->UpdateFunction(pDemod);
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_UPDATE_FUNCTION)(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T demod reseting function pointer
++
++One can use DVBT_DEMOD_FP_RESET_FUNCTION() to reset demod register setting.
++
++
++@param [in] pDemod The demod module pointer
++
++
++@retval FUNCTION_SUCCESS Reset demod setting successfully.
++@retval FUNCTION_ERROR Reset demod setting unsuccessfully.
++
++
++@note
++ -# Demod building function will set DVBT_DEMOD_FP_RESET_FUNCTION() with the corresponding function.
++
++
++
++@par Example:
++@code
++
++
++#include "demod_pseudo.h"
++
++
++int main(void)
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_DEMOD_MODULE DvbtDemodModuleMemory;
++ PSEUDO_EXTRA_MODULE PseudoExtraModuleMemory;
++
++
++ // Build pseudo demod module.
++ BuildPseudoDemodModule(&pDemod, &DvbtDemodModuleMemory, &PseudoExtraModuleMemory);
++
++ ...
++
++ // Execute ResetFunction() before demod software reset.
++ pDemod->ResetFunction(pDemod);
++
++ // Reset demod by software.
++ pDemod->SoftwareReset(pDemod);
++
++ ...
++
++ return 0;
++}
++
++
++void PeriodicallyExecutingFunction
++{
++ // Executing UpdateFunction() periodically.
++ pDemod->UpdateFunction(pDemod);
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_DEMOD_FP_RESET_FUNCTION)(
++ DVBT_DEMOD_MODULE *pDemod
++ );
++
++
++
++
++
++/// DVB-T demod module structure
++struct DVBT_DEMOD_MODULE_TAG
++{
++
++ unsigned long PageNo;
++
++ // Private variables
++ int DemodType;
++ unsigned char DeviceAddr;
++ unsigned long CrystalFreqHz;
++
++ int BandwidthMode;
++ unsigned long IfFreqHz;
++ int SpectrumMode;
++
++ int IsBandwidthModeSet;
++ int IsIfFreqHzSet;
++ int IsSpectrumModeSet;
++
++ void *pExtra; ///< Demod extra module used by driving module
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++
++ // Demod register table
++ DVBT_REG_ENTRY RegTable[DVBT_REG_TABLE_LEN_MAX];
++
++
++ // Demod I2C function pointers
++ DVBT_DEMOD_FP_SET_REG_PAGE SetRegPage;
++ DVBT_DEMOD_FP_SET_REG_BYTES SetRegBytes;
++ DVBT_DEMOD_FP_GET_REG_BYTES GetRegBytes;
++ DVBT_DEMOD_FP_SET_REG_MASK_BITS SetRegMaskBits;
++ DVBT_DEMOD_FP_GET_REG_MASK_BITS GetRegMaskBits;
++ DVBT_DEMOD_FP_SET_REG_BITS SetRegBits;
++ DVBT_DEMOD_FP_GET_REG_BITS GetRegBits;
++ DVBT_DEMOD_FP_SET_REG_BITS_WITH_PAGE SetRegBitsWithPage;
++ DVBT_DEMOD_FP_GET_REG_BITS_WITH_PAGE GetRegBitsWithPage;
++
++
++ // Demod manipulating function pointers
++ DVBT_DEMOD_FP_GET_DEMOD_TYPE GetDemodType;
++ DVBT_DEMOD_FP_GET_DEVICE_ADDR GetDeviceAddr;
++ DVBT_DEMOD_FP_GET_CRYSTAL_FREQ_HZ GetCrystalFreqHz;
++
++ DVBT_DEMOD_FP_IS_CONNECTED_TO_I2C IsConnectedToI2c;
++
++ DVBT_DEMOD_FP_SOFTWARE_RESET SoftwareReset;
++
++ DVBT_DEMOD_FP_INITIALIZE Initialize;
++ DVBT_DEMOD_FP_SET_BANDWIDTH_MODE SetBandwidthMode;
++ DVBT_DEMOD_FP_SET_IF_FREQ_HZ SetIfFreqHz;
++ DVBT_DEMOD_FP_SET_SPECTRUM_MODE SetSpectrumMode;
++ DVBT_DEMOD_FP_GET_BANDWIDTH_MODE GetBandwidthMode;
++ DVBT_DEMOD_FP_GET_IF_FREQ_HZ GetIfFreqHz;
++ DVBT_DEMOD_FP_GET_SPECTRUM_MODE GetSpectrumMode;
++
++ DVBT_DEMOD_FP_IS_TPS_LOCKED IsTpsLocked;
++ DVBT_DEMOD_FP_IS_SIGNAL_LOCKED IsSignalLocked;
++
++ DVBT_DEMOD_FP_GET_SIGNAL_STRENGTH GetSignalStrength;
++ DVBT_DEMOD_FP_GET_SIGNAL_QUALITY GetSignalQuality;
++
++ DVBT_DEMOD_FP_GET_BER GetBer;
++ DVBT_DEMOD_FP_GET_SNR_DB GetSnrDb;
++
++ DVBT_DEMOD_FP_GET_RF_AGC GetRfAgc;
++ DVBT_DEMOD_FP_GET_IF_AGC GetIfAgc;
++ DVBT_DEMOD_FP_GET_DI_AGC GetDiAgc;
++
++ DVBT_DEMOD_FP_GET_TR_OFFSET_PPM GetTrOffsetPpm;
++ DVBT_DEMOD_FP_GET_CR_OFFSET_HZ GetCrOffsetHz;
++
++ DVBT_DEMOD_FP_GET_CONSTELLATION GetConstellation;
++ DVBT_DEMOD_FP_GET_HIERARCHY GetHierarchy;
++ DVBT_DEMOD_FP_GET_CODE_RATE_LP GetCodeRateLp;
++ DVBT_DEMOD_FP_GET_CODE_RATE_HP GetCodeRateHp;
++ DVBT_DEMOD_FP_GET_GUARD_INTERVAL GetGuardInterval;
++ DVBT_DEMOD_FP_GET_FFT_MODE GetFftMode;
++
++ DVBT_DEMOD_FP_UPDATE_FUNCTION UpdateFunction;
++ DVBT_DEMOD_FP_RESET_FUNCTION ResetFunction;
++};
++
++
++
++
++
++
++
++// DVB-T demod default I2C functions
++int
++dvbt_demod_default_SetRegPage(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long PageNo
++ );
++
++int
++dvbt_demod_default_SetRegBytes(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ );
++
++int
++dvbt_demod_default_GetRegBytes(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ );
++
++int
++dvbt_demod_default_SetRegMaskBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char Msb,
++ unsigned char Lsb,
++ const unsigned long WritingValue
++ );
++
++int
++dvbt_demod_default_GetRegMaskBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char RegStartAddr,
++ unsigned char Msb,
++ unsigned char Lsb,
++ unsigned long *pReadingValue
++ );
++
++int
++dvbt_demod_default_SetRegBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ const unsigned long WritingValue
++ );
++
++int
++dvbt_demod_default_GetRegBits(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ unsigned long *pReadingValue
++ );
++
++int
++dvbt_demod_default_SetRegBitsWithPage(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ const unsigned long WritingValue
++ );
++
++int
++dvbt_demod_default_GetRegBitsWithPage(
++ DVBT_DEMOD_MODULE *pDemod,
++ int RegBitName,
++ unsigned long *pReadingValue
++ );
++
++
++
++
++
++// DVB-T demod default manipulating functions
++void
++dvbt_demod_default_GetDemodType(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pDemodType
++ );
++
++void
++dvbt_demod_default_GetDeviceAddr(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned char *pDeviceAddr
++ );
++
++void
++dvbt_demod_default_GetCrystalFreqHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pCrystalFreqHz
++ );
++
++int
++dvbt_demod_default_GetBandwidthMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pBandwidthMode
++ );
++
++int
++dvbt_demod_default_GetIfFreqHz(
++ DVBT_DEMOD_MODULE *pDemod,
++ unsigned long *pIfFreqHz
++ );
++
++int
++dvbt_demod_default_GetSpectrumMode(
++ DVBT_DEMOD_MODULE *pDemod,
++ int *pSpectrumMode
++ );
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/dvbt_nim_base.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/dvbt_nim_base.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,531 @@
++/**
++
++@file
++
++@brief DVB-T NIM base module definition
++
++DVB-T NIM base module definitions contains NIM module structure, NIM funciton pointers, NIM definitions, and NIM default
++functions.
++
++*/
++
++
++#include "dvbt_nim_base.h"
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_NIM_TYPE
++
++*/
++void
++dvbt_nim_default_GetNimType(
++ DVBT_NIM_MODULE *pNim,
++ int *pNimType
++ )
++{
++ // Get NIM type from NIM module.
++ *pNimType = pNim->NimType;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_SET_PARAMETERS
++
++*/
++int
++dvbt_nim_default_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ )
++{
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++
++ // Set tuner RF frequency in Hz.
++ if(pTuner->SetRfFreqHz(pTuner, RfFreqHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod bandwidth mode.
++ if(pDemod->SetBandwidthMode(pDemod, BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod particular registers.
++ if(pDemod->ResetFunction(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_PARAMETERS
++
++*/
++int
++dvbt_nim_default_GetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pRfFreqHz,
++ int *pBandwidthMode
++ )
++{
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++
++ // Get tuner RF frequency in Hz.
++ if(pTuner->GetRfFreqHz(pTuner, pRfFreqHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get demod bandwidth mode.
++ if(pDemod->GetBandwidthMode(pDemod, pBandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_IS_SIGNAL_PRESENT
++
++*/
++int
++dvbt_nim_default_IsSignalPresent(
++ DVBT_NIM_MODULE *pNim,
++ int *pAnswer
++ )
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ DVBT_DEMOD_MODULE *pDemod;
++ int i;
++
++
++ // Get base interface and demod module.
++ pBaseInterface = pNim->pBaseInterface;
++ pDemod = pNim->pDemod;
++
++
++ // Wait for signal present check.
++ for(i = 0; i < DEFAULT_DVBT_NIM_SINGAL_PRESENT_CHECK_TIMES_MAX; i++)
++ {
++ // Wait 20 ms.
++ pBaseInterface->WaitMs(pBaseInterface, 20);
++
++ // Check TPS present status on demod.
++ // Note: If TPS is locked, stop signal present check.
++ if(pDemod->IsTpsLocked(pDemod, pAnswer) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ if(*pAnswer == YES)
++ break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_IS_SIGNAL_LOCKED
++
++*/
++int
++dvbt_nim_default_IsSignalLocked(
++ DVBT_NIM_MODULE *pNim,
++ int *pAnswer
++ )
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ DVBT_DEMOD_MODULE *pDemod;
++ int i;
++
++
++ // Get base interface and demod module.
++ pBaseInterface = pNim->pBaseInterface;
++ pDemod = pNim->pDemod;
++
++
++ // Wait for signal lock check.
++ for(i = 0; i < DEFAULT_DVBT_NIM_SINGAL_LOCK_CHECK_TIMES_MAX; i++)
++ {
++ // Wait 20 ms.
++ pBaseInterface->WaitMs(pBaseInterface, 20);
++
++ // Check signal lock status on demod.
++ // Note: If signal is locked, stop signal lock check.
++ if(pDemod->IsSignalLocked(pDemod, pAnswer) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ if(*pAnswer == YES)
++ break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_SIGNAL_STRENGTH
++
++*/
++int
++dvbt_nim_default_GetSignalStrength(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pSignalStrength
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Get signal strength from demod.
++ if(pDemod->GetSignalStrength(pDemod, pSignalStrength) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_SIGNAL_QUALITY
++
++*/
++int
++dvbt_nim_default_GetSignalQuality(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pSignalQuality
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Get signal quality from demod.
++ if(pDemod->GetSignalQuality(pDemod, pSignalQuality) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_BER
++
++*/
++int
++dvbt_nim_default_GetBer(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pBerNum,
++ unsigned long *pBerDen
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Get BER from demod.
++ if(pDemod->GetBer(pDemod, pBerNum, pBerDen) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_SNR_DB
++
++*/
++int
++dvbt_nim_default_GetSnrDb(
++ DVBT_NIM_MODULE *pNim,
++ long *pSnrDbNum,
++ long *pSnrDbDen
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Get SNR in dB from demod.
++ if(pDemod->GetSnrDb(pDemod, pSnrDbNum, pSnrDbDen) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_TR_OFFSET_PPM
++
++*/
++int
++dvbt_nim_default_GetTrOffsetPpm(
++ DVBT_NIM_MODULE *pNim,
++ long *pTrOffsetPpm
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Get TR offset in ppm from demod.
++ if(pDemod->GetTrOffsetPpm(pDemod, pTrOffsetPpm) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_CR_OFFSET_HZ
++
++*/
++int
++dvbt_nim_default_GetCrOffsetHz(
++ DVBT_NIM_MODULE *pNim,
++ long *pCrOffsetHz
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Get CR offset in Hz from demod.
++ if(pDemod->GetCrOffsetHz(pDemod, pCrOffsetHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_GET_TPS_INFO
++
++*/
++int
++dvbt_nim_default_GetTpsInfo(
++ DVBT_NIM_MODULE *pNim,
++ int *pConstellation,
++ int *pHierarchy,
++ int *pCodeRateLp,
++ int *pCodeRateHp,
++ int *pGuardInterval,
++ int *pFftMode
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Get TPS constellation information from demod.
++ if(pDemod->GetConstellation(pDemod, pConstellation) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get TPS hierarchy information from demod.
++ if(pDemod->GetHierarchy(pDemod, pHierarchy) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get TPS low-priority code rate information from demod.
++ if(pDemod->GetCodeRateLp(pDemod, pCodeRateLp) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get TPS high-priority code rate information from demod.
++ if(pDemod->GetCodeRateHp(pDemod, pCodeRateHp) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get TPS guard interval information from demod.
++ if(pDemod->GetGuardInterval(pDemod, pGuardInterval) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get TPS FFT mode information from demod.
++ if(pDemod->GetFftMode(pDemod, pFftMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_UPDATE_FUNCTION
++
++*/
++int
++dvbt_nim_default_UpdateFunction(
++ DVBT_NIM_MODULE *pNim
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++
++ // Get demod module.
++ pDemod = pNim->pDemod;
++
++
++ // Update demod particular registers.
++ if(pDemod->UpdateFunction(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++
++
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/dvbt_nim_base.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/dvbt_nim_base.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,845 @@
++#ifndef __DVBT_NIM_BASE_H
++#define __DVBT_NIM_BASE_H
++
++/**
++
++@file
++
++@brief DVB-T NIM base module definition
++
++DVB-T NIM base module definitions contains NIM module structure, NIM funciton pointers, NIM definitions, and NIM default
++functions.
++
++
++
++@par Example:
++@code
++
++
++#include "nim_demodx_tunery.h"
++
++
++
++int
++CustomI2cRead(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++ return FUNCTION_ERROR;
++}
++
++
++
++int
++CustomI2cWrite(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++ return FUNCTION_ERROR;
++}
++
++
++
++void
++CustomWaitMs(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned long WaitTimeMs
++ )
++{
++ ...
++}
++
++
++
++int main(void)
++{
++ DVBT_NIM_MODULE *pNim;
++ DVBT_NIM_MODULE DvbtNimModuleMemory;
++ DEMODX_EXTRA_MODULE DemodxExtraModuleMemory;
++ TUNERY_EXTRA_MODULE TuneryExtraModuleMemory;
++
++ unsigned long RfFreqHz;
++ int BandwidthMode;
++
++ int Answer;
++ unsigned long SignalStrength, SignalQuality;
++ unsigned long BerNum, BerDen, PerNum, PerDen;
++ double Ber, Per;
++ unsigned long SnrDbNum, SnrDbDen;
++ double SnrDb;
++ long TrOffsetPpm, CrOffsetHz;
++
++ int Constellation;
++ int Hierarchy;
++ int CodeRateLp;
++ int CodeRateHp;
++ int GuardInterval;
++ int FftMode;
++
++
++
++ // Build Demod-X Tuner-Y NIM module.
++ BuildDemodxTuneryModule(
++ &pNim,
++ &DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ CustomI2cRead, // Employ CustomI2cRead() as basic I2C reading function.
++ CustomI2cWrite, // Employ CustomI2cWrite() as basic I2C writing function.
++ CustomWaitMs // Employ CustomWaitMs() as basic waiting function.
++
++ &DemodxExtraModuleMemory, // Employ Demod-X extra module.
++ 0x20, // The Demod-X I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The Demod-X crystal frequency is 28.8 MHz.
++ ... // Other arguments for Demod-X
++
++ &TunerxExtraModuleMemory, // Employ Tuner-Y extra module.
++ 0xc0, // The Tuner-Y I2C device address is 0xc0 in 8-bit format.
++ ... // Other arguments for Tuner-Y
++ );
++
++
++
++ // Get NIM type.
++ // Note: NIM types are defined in the MODULE_TYPE enumeration.
++ pNim->GetNimType(pNim, &NimType);
++
++
++
++
++
++
++
++ // ==== Initialize NIM and set its parameters =====
++
++ // Initialize NIM.
++ pNim->Initialize(pNim);
++
++ // Set NIM parameters. (RF frequency, bandwdith mode)
++ // Note: In the example:
++ // 1. RF frequency is 666 MHz.
++ // 2. Bandwidth mode is 8 MHz.
++ RfFreqHz = 666000000;
++ BandwidthMode = DVBT_BANDWIDTH_8MHZ;
++ pNim->SetParameters(pNim, RfFreqHz, BandwidthMode);
++
++
++
++
++
++ // ==== Get NIM information =====
++
++ // Get NIM parameters. (RF frequency, bandwdith mode)
++ pNim->GetParameters(pNim, &RfFreqHz, &BandwidthMode);
++
++
++ // Get signal present status.
++ // Note: 1. The IsSignalPresent() function will wait maximum 1000 ms for signal present check.
++ // 2. The argument Answer is YES when the NIM module has found DVB-T signal in the RF channel.
++ // 3. The argument Answer is NO when the NIM module does not find DVB-T signal in the RF channel.
++ // Recommendation: Use the IsSignalPresent() function for channel scan.
++ pNim->IsSignalPresent(pNim, &Answer);
++
++ // Get signal lock status.
++ // Note: 1. The IsSignalLocked() function will wait maximum 1000 ms for signal lock check.
++ // 2. The argument Answer is YES when the NIM module has locked DVB-T signal in the RF channel.
++ // At the same time, the NIM module sends TS packets through TS interface hardware pins.
++ // 3. The argument Answer is NO when the NIM module does not lock DVB-T signal in the RF channel.
++ // Recommendation: Use the IsSignalLocked() function for signal lock check.
++ pNim->IsSignalLocked(pNim, &Answer);
++
++
++ // Get signal strength.
++ // Note: 1. The range of SignalStrength is 0~100.
++ // 2. Need to map SignalStrength value to UI signal strength bar manually.
++ pNim->GetSignalStrength(pNim, &SignalStrength);
++
++ // Get signal quality.
++ // Note: 1. The range of SignalQuality is 0~100.
++ // 2. Need to map SignalQuality value to UI signal quality bar manually.
++ pNim->GetSignalQuality(pNim, &SignalQuality);
++
++
++ // Get BER.
++ pNim->GetBer(pNim, &BerNum, &BerDen);
++ Ber = (double)BerNum / (double)BerDen;
++
++ // Get SNR in dB.
++ pNim->GetSnrDb(pNim, &SnrDbNum, &SnrDbDen);
++ SnrDb = (double)SnrDbNum / (double)SnrDbDen;
++
++
++ // Get TR offset (symbol timing offset) in ppm.
++ pNim->GetTrOffsetPpm(pNim, &TrOffsetPpm);
++
++ // Get CR offset (RF frequency offset) in Hz.
++ pNim->GetCrOffsetHz(pNim, &CrOffsetHz);
++
++
++ // Get TPS information.
++ // Note: One can find TPS information definitions in the enumerations as follows:
++ // 1. DVBT_CONSTELLATION_MODE.
++ // 2. DVBT_HIERARCHY_MODE.
++ // 3. DVBT_CODE_RATE_MODE. (for low-priority and high-priority code rate)
++ // 4. DVBT_GUARD_INTERVAL_MODE.
++ // 5. DVBT_FFT_MODE_MODE
++ pNim->GetTpsInfo(pNim, &Constellation, &Hierarchy, &CodeRateLp, &CodeRateHp, &GuardInterval, &FftMode);
++
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "foundation.h"
++#include "tuner_base.h"
++#include "dvbt_demod_base.h"
++
++
++
++
++
++// Definitions
++#define DEFAULT_DVBT_NIM_SINGAL_PRESENT_CHECK_TIMES_MAX 1
++#define DEFAULT_DVBT_NIM_SINGAL_LOCK_CHECK_TIMES_MAX 1
++
++
++
++
++
++/// DVB-T NIM module pre-definition
++typedef struct DVBT_NIM_MODULE_TAG DVBT_NIM_MODULE;
++
++
++
++
++
++/**
++
++@brief DVB-T demod type getting function pointer
++
++One can use DVBT_NIM_FP_GET_NIM_TYPE() to get DVB-T NIM type.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pNimType Pointer to an allocated memory for storing NIM type
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_NIM_TYPE() with the corresponding function.
++
++
++@see MODULE_TYPE
++
++*/
++typedef void
++(*DVBT_NIM_FP_GET_NIM_TYPE)(
++ DVBT_NIM_MODULE *pNim,
++ int *pNimType
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM initializing function pointer
++
++One can use DVBT_NIM_FP_INITIALIZE() to initialie DVB-T NIM.
++
++
++@param [in] pNim The NIM module pointer
++
++
++@retval FUNCTION_SUCCESS Initialize NIM successfully.
++@retval FUNCTION_ERROR Initialize NIM unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_INITIALIZE() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_INITIALIZE)(
++ DVBT_NIM_MODULE *pNim
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM parameter setting function pointer
++
++One can use DVBT_NIM_FP_SET_PARAMETERS() to set DVB-T NIM parameters.
++
++
++@param [in] pNim The NIM module pointer
++@param [in] RfFreqHz RF frequency in Hz for setting
++@param [in] BandwidthMode Bandwidth mode for setting
++
++
++@retval FUNCTION_SUCCESS Set NIM parameters successfully.
++@retval FUNCTION_ERROR Set NIM parameters unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_SET_PARAMETERS() with the corresponding function.
++
++
++@see DVBT_BANDWIDTH_MODE
++
++*/
++typedef int
++(*DVBT_NIM_FP_SET_PARAMETERS)(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM parameter getting function pointer
++
++One can use DVBT_NIM_FP_GET_PARAMETERS() to get DVB-T NIM parameters.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pRfFreqHz Pointer to an allocated memory for storing NIM RF frequency in Hz
++@param [out] pBandwidthMode Pointer to an allocated memory for storing NIM bandwidth mode
++
++
++@retval FUNCTION_SUCCESS Get NIM parameters successfully.
++@retval FUNCTION_ERROR Get NIM parameters unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_PARAMETERS() with the corresponding function.
++
++
++@see DVBT_BANDWIDTH_MODE
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_PARAMETERS)(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pRfFreqHz,
++ int *pBandwidthMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM signal present asking function pointer
++
++One can use DVBT_NIM_FP_IS_SIGNAL_PRESENT() to ask DVB-T NIM if signal is present.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pAnswer Pointer to an allocated memory for storing answer
++
++
++@retval FUNCTION_SUCCESS Perform signal present asking to NIM successfully.
++@retval FUNCTION_ERROR Perform signal present asking to NIM unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_IS_SIGNAL_PRESENT() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_IS_SIGNAL_PRESENT)(
++ DVBT_NIM_MODULE *pNim,
++ int *pAnswer
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM signal lock asking function pointer
++
++One can use DVBT_NIM_FP_IS_SIGNAL_LOCKED() to ask DVB-T NIM if signal is locked.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pAnswer Pointer to an allocated memory for storing answer
++
++
++@retval FUNCTION_SUCCESS Perform signal lock asking to NIM successfully.
++@retval FUNCTION_ERROR Perform signal lock asking to NIM unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_IS_SIGNAL_LOCKED() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_IS_SIGNAL_LOCKED)(
++ DVBT_NIM_MODULE *pNim,
++ int *pAnswer
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM signal strength getting function pointer
++
++One can use DVBT_NIM_FP_GET_SIGNAL_STRENGTH() to get signal strength.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pSignalStrength Pointer to an allocated memory for storing signal strength (value = 0 ~ 100)
++
++
++@retval FUNCTION_SUCCESS Get NIM signal strength successfully.
++@retval FUNCTION_ERROR Get NIM signal strength unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_SIGNAL_STRENGTH() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_SIGNAL_STRENGTH)(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pSignalStrength
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM signal quality getting function pointer
++
++One can use DVBT_NIM_FP_GET_SIGNAL_QUALITY() to get signal quality.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pSignalQuality Pointer to an allocated memory for storing signal quality (value = 0 ~ 100)
++
++
++@retval FUNCTION_SUCCESS Get NIM signal quality successfully.
++@retval FUNCTION_ERROR Get NIM signal quality unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_SIGNAL_QUALITY() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_SIGNAL_QUALITY)(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pSignalQuality
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM BER value getting function pointer
++
++One can use DVBT_NIM_FP_GET_BER() to get BER.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pBerNum Pointer to an allocated memory for storing BER numerator
++@param [out] pBerDen Pointer to an allocated memory for storing BER denominator
++
++
++@retval FUNCTION_SUCCESS Get NIM BER value successfully.
++@retval FUNCTION_ERROR Get NIM BER value unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_BER() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_BER)(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pBerNum,
++ unsigned long *pBerDen
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM SNR getting function pointer
++
++One can use DVBT_NIM_FP_GET_SNR_DB() to get SNR in dB.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pSnrDbNum Pointer to an allocated memory for storing SNR dB numerator
++@param [out] pSnrDbDen Pointer to an allocated memory for storing SNR dB denominator
++
++
++@retval FUNCTION_SUCCESS Get NIM SNR successfully.
++@retval FUNCTION_ERROR Get NIM SNR unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_SNR_DB() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_SNR_DB)(
++ DVBT_NIM_MODULE *pNim,
++ long *pSnrDbNum,
++ long *pSnrDbDen
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM TR offset getting function pointer
++
++One can use DVBT_NIM_FP_GET_TR_OFFSET_PPM() to get TR offset in ppm.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pTrOffsetPpm Pointer to an allocated memory for storing TR offset in ppm
++
++
++@retval FUNCTION_SUCCESS Get NIM TR offset successfully.
++@retval FUNCTION_ERROR Get NIM TR offset unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_TR_OFFSET_PPM() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_TR_OFFSET_PPM)(
++ DVBT_NIM_MODULE *pNim,
++ long *pTrOffsetPpm
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM CR offset getting function pointer
++
++One can use DVBT_NIM_FP_GET_CR_OFFSET_HZ() to get CR offset in Hz.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pCrOffsetHz Pointer to an allocated memory for storing CR offset in Hz
++
++
++@retval FUNCTION_SUCCESS Get NIM CR offset successfully.
++@retval FUNCTION_ERROR Get NIM CR offset unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_CR_OFFSET_HZ() with the corresponding function.
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_CR_OFFSET_HZ)(
++ DVBT_NIM_MODULE *pNim,
++ long *pCrOffsetHz
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM TPS information getting function pointer
++
++One can use DVBT_NIM_FP_GET_TPS_INFO() to get TPS information.
++
++
++@param [in] pNim The NIM module pointer
++@param [out] pConstellation Pointer to an allocated memory for storing demod constellation mode
++@param [out] pHierarchy Pointer to an allocated memory for storing demod hierarchy mode
++@param [out] pCodeRateLp Pointer to an allocated memory for storing demod low-priority code rate mode
++@param [out] pCodeRateHp Pointer to an allocated memory for storing demod high-priority code rate mode
++@param [out] pGuardInterval Pointer to an allocated memory for storing demod guard interval mode
++@param [out] pFftMode Pointer to an allocated memory for storing demod FFT mode
++
++
++@retval FUNCTION_SUCCESS Get NIM TPS information successfully.
++@retval FUNCTION_ERROR Get NIM TPS information unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_GET_TPS_INFO() with the corresponding function.
++
++
++@see DVBT_CONSTELLATION_MODE, DVBT_HIERARCHY_MODE, DVBT_CODE_RATE_MODE, DVBT_GUARD_INTERVAL_MODE, DVBT_FFT_MODE_MODE
++
++*/
++typedef int
++(*DVBT_NIM_FP_GET_TPS_INFO)(
++ DVBT_NIM_MODULE *pNim,
++ int *pConstellation,
++ int *pHierarchy,
++ int *pCodeRateLp,
++ int *pCodeRateHp,
++ int *pGuardInterval,
++ int *pFftMode
++ );
++
++
++
++
++
++/**
++
++@brief DVB-T NIM updating function pointer
++
++One can use DVBT_NIM_FP_UPDATE_FUNCTION() to update NIM register setting.
++
++
++@param [in] pNim The NIM module pointer
++
++
++@retval FUNCTION_SUCCESS Update NIM setting successfully.
++@retval FUNCTION_ERROR Update NIM setting unsuccessfully.
++
++
++@note
++ -# NIM building function will set DVBT_NIM_FP_UPDATE_FUNCTION() with the corresponding function.
++
++
++
++@par Example:
++@code
++
++
++#include "nim_demodx_tunery.h"
++
++
++int main(void)
++{
++ DVBT_NIM_MODULE *pNim;
++ DVBT_NIM_MODULE DvbtNimModuleMemory;
++ DEMODX_EXTRA_MODULE DemodxExtraModuleMemory;
++ TUNERY_EXTRA_MODULE TuneryExtraModuleMemory;
++
++
++ // Build Demod-X Tuner-Y NIM module.
++ BuildDemodxTuneryModule(
++ ...
++ );
++
++ ...
++
++
++ return 0;
++}
++
++
++void PeriodicallyExecutingFunction
++{
++ // Executing UpdateFunction() periodically.
++ pNim->UpdateFunction(pNim);
++}
++
++
++@endcode
++
++*/
++typedef int
++(*DVBT_NIM_FP_UPDATE_FUNCTION)(
++ DVBT_NIM_MODULE *pNim
++ );
++
++
++
++
++
++/// DVB-T NIM module structure
++struct DVBT_NIM_MODULE_TAG
++{
++ // Private variables
++ int NimType;
++ int DemodTsInterfaceMode;
++
++ void *pExtra; ///< NIM extra module used by driving module
++
++
++ // Modules
++ BASE_INTERFACE_MODULE *pBaseInterface; ///< Base interface module pointer
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory; ///< Base interface module memory
++
++ I2C_BRIDGE_MODULE *pI2cBridge; ///< I2C bridge module pointer
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory; ///< I2C bridge module memory
++
++ TUNER_MODULE *pTuner; ///< Tuner module pointer
++ TUNER_MODULE TunerModuleMemory; ///< Tuner module memory
++
++ DVBT_DEMOD_MODULE *pDemod; ///< DVB-T demod module pointer
++ DVBT_DEMOD_MODULE DvbtDemodModuleMemory; ///< DVB-T demod module memory
++
++
++ // NIM manipulating functions
++ DVBT_NIM_FP_GET_NIM_TYPE GetNimType;
++ DVBT_NIM_FP_INITIALIZE Initialize;
++ DVBT_NIM_FP_SET_PARAMETERS SetParameters;
++ DVBT_NIM_FP_GET_PARAMETERS GetParameters;
++ DVBT_NIM_FP_IS_SIGNAL_PRESENT IsSignalPresent;
++ DVBT_NIM_FP_IS_SIGNAL_LOCKED IsSignalLocked;
++ DVBT_NIM_FP_GET_SIGNAL_STRENGTH GetSignalStrength;
++ DVBT_NIM_FP_GET_SIGNAL_QUALITY GetSignalQuality;
++ DVBT_NIM_FP_GET_BER GetBer;
++ DVBT_NIM_FP_GET_SNR_DB GetSnrDb;
++ DVBT_NIM_FP_GET_TR_OFFSET_PPM GetTrOffsetPpm;
++ DVBT_NIM_FP_GET_CR_OFFSET_HZ GetCrOffsetHz;
++ DVBT_NIM_FP_GET_TPS_INFO GetTpsInfo;
++ DVBT_NIM_FP_UPDATE_FUNCTION UpdateFunction;
++};
++
++
++
++
++
++
++
++// DVB-T NIM default manipulaing functions
++void
++dvbt_nim_default_GetNimType(
++ DVBT_NIM_MODULE *pNim,
++ int *pNimType
++ );
++
++int
++dvbt_nim_default_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ );
++
++int
++dvbt_nim_default_GetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pRfFreqHz,
++ int *pBandwidthMode
++ );
++
++int
++dvbt_nim_default_IsSignalPresent(
++ DVBT_NIM_MODULE *pNim,
++ int *pAnswer
++ );
++
++int
++dvbt_nim_default_IsSignalLocked(
++ DVBT_NIM_MODULE *pNim,
++ int *pAnswer
++ );
++
++int
++dvbt_nim_default_GetSignalStrength(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pSignalStrength
++ );
++
++int
++dvbt_nim_default_GetSignalQuality(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pSignalQuality
++ );
++
++int
++dvbt_nim_default_GetBer(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long *pBerNum,
++ unsigned long *pBerDen
++ );
++
++int
++dvbt_nim_default_GetSnrDb(
++ DVBT_NIM_MODULE *pNim,
++ long *pSnrDbNum,
++ long *pSnrDbDen
++ );
++
++int
++dvbt_nim_default_GetTrOffsetPpm(
++ DVBT_NIM_MODULE *pNim,
++ long *pTrOffsetPpm
++ );
++
++int
++dvbt_nim_default_GetCrOffsetHz(
++ DVBT_NIM_MODULE *pNim,
++ long *pCrOffsetHz
++ );
++
++int
++dvbt_nim_default_GetTpsInfo(
++ DVBT_NIM_MODULE *pNim,
++ int *pConstellation,
++ int *pHierarchy,
++ int *pCodeRateLp,
++ int *pCodeRateHp,
++ int *pGuardInterval,
++ int *pFftMode
++ );
++
++int
++dvbt_nim_default_UpdateFunction(
++ DVBT_NIM_MODULE *pNim
++ );
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/foundation.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/foundation.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,352 @@
++/**
++
++@file
++
++@brief Fundamental interface definition
++
++Fundamental interface contains base function pointers and some mathematics tools.
++
++*/
++
++
++#include "foundation.h"
++
++
++
++
++
++// Base interface builder
++void
++BuildBaseInterface(
++ BASE_INTERFACE_MODULE **ppBaseInterface,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ unsigned char I2cReadingByteNumMax,
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs
++ )
++{
++ // Set base interface module pointer.
++ *ppBaseInterface = pBaseInterfaceModuleMemory;
++
++
++ // Set all base interface function pointers and arguments.
++ (*ppBaseInterface)->I2cReadingByteNumMax = I2cReadingByteNumMax;
++ (*ppBaseInterface)->I2cWritingByteNumMax = I2cWritingByteNumMax;
++ (*ppBaseInterface)->I2cRead = I2cRead;
++ (*ppBaseInterface)->I2cWrite = I2cWrite;
++ (*ppBaseInterface)->WaitMs = WaitMs;
++ (*ppBaseInterface)->SetUserDefinedDataPointer = base_interface_SetUserDefinedDataPointer;
++ (*ppBaseInterface)->GetUserDefinedDataPointer = base_interface_GetUserDefinedDataPointer;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Set user defined data pointer of base interface structure for custom basic function implementation.
++
++@note
++ -# Base interface builder will set BASE_FP_SET_USER_DEFINED_DATA_POINTER() function pointer with
++ base_interface_SetUserDefinedDataPointer().
++
++@see BASE_FP_SET_USER_DEFINED_DATA_POINTER
++
++*/
++void
++base_interface_SetUserDefinedDataPointer(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ void *pUserDefinedData
++ )
++{
++ // Set user defined data pointer of base interface structure with user defined data pointer argument.
++ pBaseInterface->pUserDefinedData = pUserDefinedData;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Get user defined data pointer of base interface structure for custom basic function implementation.
++
++@note
++ -# Base interface builder will set BASE_FP_GET_USER_DEFINED_DATA_POINTER() function pointer with
++ base_interface_GetUserDefinedDataPointer().
++
++@see BASE_FP_GET_USER_DEFINED_DATA_POINTER
++
++*/
++void
++base_interface_GetUserDefinedDataPointer(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ void **ppUserDefinedData
++ )
++{
++ // Get user defined data pointer from base interface structure to the caller user defined data pointer.
++ *ppUserDefinedData = pBaseInterface->pUserDefinedData;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Convert signed integer to binary.
++
++Convert 2's complement signed integer to binary with bit number.
++
++
++@param [in] Value the converting value in 2's complement format
++@param [in] BitNum the bit number of the converting value
++
++
++@return Converted binary
++
++
++@note
++ The converting value must be -pow(2, BitNum - 1) ~ (pow(2, BitNum - 1) -1).
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++int main(void)
++{
++ long Value = -345;
++ unsigned long Binary;
++
++
++ // Convert 2's complement integer to binary with 10 bit number.
++ Binary = SignedIntToBin(Value, 10);
++
++
++ // Result in base 2:
++ // Value = 1111 1111 1111 1111 1111 1110 1010 0111 b = -345 (in 32-bit 2's complement format)
++ // Binary = 0000 0000 0000 0000 0000 0010 1010 0111 b = 679 (in 10-bit binary format)
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++unsigned long
++SignedIntToBin(
++ long Value,
++ unsigned char BitNum
++ )
++{
++ unsigned int i;
++ unsigned long Mask, Binary;
++
++
++
++ // Generate Mask according to BitNum.
++ Mask = 0;
++ for(i = 0; i < BitNum; i++)
++ Mask |= 0x1 << i;
++
++
++ // Convert signed integer to binary with Mask.
++ Binary = Value & Mask;
++
++
++ return Binary;
++}
++
++
++
++
++
++/**
++
++@brief Convert binary to signed integer.
++
++Convert binary to 2's complement signed integer with bit number.
++
++
++@param [in] Binary the converting binary
++@param [in] BitNum the bit number of the converting binary
++
++
++@return Converted 2's complement signed integer
++
++
++@note
++ The converting binary must be 0 ~ (pow(2, BitNum) - 1).
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++int main(void)
++{
++ unsigned long Binary = 679;
++ long Value;
++
++
++ // Convert binary to 2's complement integer with 10 bit number.
++ Value = BinToSignedInt(Binary, 10);
++
++
++ // Result in base 2:
++ // Binary = 0000 0000 0000 0000 0000 0010 1010 0111 b = 679 (in 10-bit binary format)
++ // Value = 1111 1111 1111 1111 1111 1110 1010 0111 b = -345 (in 32-bit 2's complement format)
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++long
++BinToSignedInt(
++ unsigned long Binary,
++ unsigned char BitNum
++ )
++{
++ int i;
++
++ unsigned char SignedBit;
++ unsigned long SignedBitExtension;
++
++ long Value;
++
++
++
++ // Get signed bit.
++ SignedBit = (unsigned char)((Binary >> (BitNum - 1)) & BIT_0_MASK);
++
++
++ // Generate signed bit extension.
++ SignedBitExtension = 0;
++
++ for(i = BitNum; i < LONG_BIT_NUM; i++)
++ SignedBitExtension |= SignedBit << i;
++
++
++ // Combine binary value and signed bit extension to signed integer value.
++ Value = (long)(Binary | SignedBitExtension);
++
++
++ return Value;
++}
++
++
++
++
++
++/**
++
++@brief Get devision reult with ceiling.
++
++Get unsigned devision reult with ceiling.
++
++
++@param [in] Dividend the dividend
++@param [in] Divisor the divisor
++
++
++@return Result with ceiling
++
++
++@note
++ The dividend and divisor must be unsigned integer.
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++int main(void)
++{
++ long Value;
++
++
++ // Get ceil(100 / 20) reult.
++ Value = DivideWithCeiling(100, 20);
++
++ // Result: Value = 5
++
++
++ // Get ceil(100 / 30) reult.
++ Value = DivideWithCeiling(100, 30);
++
++ // Result: Value = 4
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++unsigned long
++DivideWithCeiling(
++ unsigned long Dividend,
++ unsigned long Divisor
++ )
++{
++ unsigned long Result;
++
++
++ // Get primitive division result.
++ Result = Dividend / Divisor;
++
++ // Adjust primitive result with ceiling.
++ if(Dividend % Divisor > 0)
++ Result += 1;
++
++
++ return Result;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/foundation.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/foundation.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,891 @@
++#ifndef __FOUNDATION_H
++#define __FOUNDATION_H
++
++/**
++
++@file
++
++@brief Fundamental interface declaration
++
++Fundamental interface contains base function pointers and some mathematics tools.
++
++*/
++
++
++#include "i2c_bridge.h"
++#include "math_mpi.h"
++#include "dvb-usb.h"
++#include "rtl2832u_io.h"
++
++
++
++// Definitions
++
++// API version
++#define REALTEK_NIM_API_VERSION "Realtek NIM API 2008.12.04"
++
++
++
++// Constants
++#define INVALID_POINTER_VALUE 0
++#define NO_USE 0
++
++#define LEN_1_BYTE 1
++#define LEN_2_BYTE 2
++#define LEN_3_BYTE 3
++#define LEN_4_BYTE 4
++#define LEN_5_BYTE 5
++#define LEN_6_BYTE 6
++#define LEN_11_BYTE 11
++
++#define LEN_1_BIT 1
++
++#define BYTE_MASK 0xff
++#define BYTE_SHIFT 8
++#define BYTE_BIT_NUM 8
++#define LONG_BIT_NUM 32
++
++#define BIT_0_MASK 0x1
++#define BIT_1_MASK 0x2
++#define BIT_3_MASK 0x8
++#define BIT_4_MASK 0x10
++#define BIT_8_MASK 0x100
++#define BIT_7_SHIFT 7
++#define BIT_8_SHIFT 8
++
++
++
++// I2C buffer length
++// Note: I2C_BUFFER_LEN must be greater than I2cReadingByteNumMax and I2cWritingByteNumMax in BASE_INTERFACE_MODULE.
++#define I2C_BUFFER_LEN 128
++
++
++
++
++
++/// Module types
++enum MODULE_TYPE
++{
++ // DVB-T demod
++ DVBT_DEMOD_TYPE_RTL2830, ///< RTL2830 DVB-T demod
++ DVBT_DEMOD_TYPE_RTL2832, ///< RTL2832 DVB-T demod
++
++ // QAM demod
++ QAM_DEMOD_TYPE_RTL2840, ///< RTL2840 DVB-C demod
++ QAM_DEMOD_TYPE_RTL2810_OC, ///< RTL2810 OpenCable demod
++ QAM_DEMOD_TYPE_RTL2820_OC, ///< RTL2820 OpenCable demod
++ QAM_DEMOD_TYPE_RTD2885_QAM, ///< RTD2885 QAM demod
++
++ // OOB demod
++ OOB_DEMOD_TYPE_RTL2820_OOB, ///< RTL2820 OOB demod
++
++ // ATSC demod
++ ATSC_DEMOD_TYPE_RTL2820_ATSC, ///< RTL2820 ATSC demod
++ ATSC_DEMOD_TYPE_RTD2885_ATSC, ///< RTD2885 ATSC demod
++
++ // DTMB demod
++ DTMB_DEMOD_TYPE_RTL2836, ///< RTL2836 DTMB demod
++
++ // Tuner
++ TUNER_TYPE_TDCGG052D, ///< TDCG-G052D tuner (QAM)
++ TUNER_TYPE_TDCHG001D, ///< TDCH-G001D tuner (QAM)
++ TUNER_TYPE_TDQE3003A, ///< TDQE3-003A tuner (QAM)
++ TUNER_TYPE_DCT7045, ///< DCT-7045 tuner (QAM)
++ TUNER_TYPE_MT2062, ///< MT2062 tuner (QAM)
++ TUNER_TYPE_MXL5005S, ///< MxL5005S tuner (DVB-T, ATSC)
++ TUNER_TYPE_TDVMH715P, ///< TDVM-H751P tuner (QAM, OOB, ATSC)
++ TUNER_TYPE_UBA00AL, ///< UBA00AL tuner (QAM, ATSC)
++ TUNER_TYPE_MT2266, ///< MT2266 tuner (DVB-T)
++ TUNER_TYPE_FC2580, ///< FC2580 tuner (DVB-T)
++ TUNER_TYPE_TUA9001, ///< TUA9001 tuner (DVB-T)
++ TUNER_TYPE_DTT75300, ///< DTT-75300 tuner (DVB-T)
++ TUNER_TYPE_MXL5007T, ///< MxL5007T tuner (DVB-T, ATSC)
++
++ // DVB-T NIM
++ DVBT_NIM_USER_DEFINITION, ///< DVB-T NIM: User definition
++ DVBT_NIM_RTL2832_MT2266, ///< DVB-T NIM: RTL2832 + MT2266
++ DVBT_NIM_RTL2832_FC2580, ///< DVB-T NIM: RTL2832 + FC2580
++ DVBT_NIM_RTL2832_TUA9001, ///< DVB-T NIM: RTL2832 + TUA9001
++ DVBT_NIM_RTL2832_MXL5005S, ///< DVB-T NIM: RTL2832 + MxL5005S
++ DVBT_NIM_RTL2832_DTT75300, ///< DVB-T NIM: RTL2832 + DTT-75300
++ DVBT_NIM_RTL2832_MXL5007T, ///< DVB-T NIM: RTL2832 + MxL5007T
++
++ // QAM NIM
++ QAM_NIM_USER_DEFINITION, ///< QAM NIM: User definition
++ QAM_NIM_RTL2840_TDQE3003A, ///< QAM NIM: RTL2840 + TDQE3-003A
++ QAM_NIM_RTL2840_DCT7045, ///< QAM NIM: RTL2840 + DCT-7045
++ QAM_NIM_RTL2840_DCT7046, ///< QAM NIM: RTL2840 + DCT-7046
++ QAM_NIM_RTL2840_MT2062, ///< QAM NIM: RTL2840 + MT2062
++
++ // DCR NIM
++ DCR_NIM_RTL2820_TDVMH715P, ///< DCR NIM: RTL2820 + TDVM-H751P
++ DCR_NIM_RTD2885_UBA00AL, ///< DCR NIM: RTD2885 + UBA00AL
++
++ // DTMB NIM
++ DTMB_NIM_RTL2836_FC2580, ///< DTMB NIM: RTL2836 + FC2580
++};
++
++
++
++
++
++/// On/off status
++enum ON_OFF_STATUS
++{
++ OFF, ///< Off
++ ON, ///< On
++};
++
++
++/// Yes/no status
++enum YES_NO_STATUS
++{
++ NO, ///< No
++ YES, ///< Yes
++};
++
++
++/// Lock status
++enum LOCK_STATUS
++{
++ NOT_LOCKED, ///< Not locked
++ LOCKED, ///< Locked
++};
++
++
++/// Loss status
++enum LOSS_STATUS
++{
++ NOT_LOST, ///< Not lost
++ LOST, ///< Lost
++};
++
++
++/// Function return status
++enum FUNCTION_RETURN_STATUS
++{
++ FUNCTION_SUCCESS, ///< Execute function successfully.
++ FUNCTION_ERROR, ///< Execute function unsuccessfully.
++};
++
++
++/// Crystal frequency
++enum CRYSTAL_FREQ_HZ
++{
++ CRYSTAL_FREQ_4000000HZ = 4000000, ///< Crystal frequency = 4.0 MHz
++ CRYSTAL_FREQ_16000000HZ = 16000000, ///< Crystal frequency = 16.0 MHz
++ CRYSTAL_FREQ_16384000HZ = 16384000, ///< Crystal frequency = 16.384 MHz
++ CRYSTAL_FREQ_16457143HZ = 16457143, ///< Crystal frequency = 16.457 MHz
++ CRYSTAL_FREQ_25000000HZ = 25000000, ///< Crystal frequency = 25.0 MHz
++ CRYSTAL_FREQ_27000000HZ = 27000000, ///< Crystal frequency = 27.0 MHz
++ CRYSTAL_FREQ_28800000HZ = 28800000, ///< Crystal frequency = 28.8 MHz
++};
++
++
++/// IF frequency
++enum IF_FREQ_HZ
++{
++ IF_FREQ_0HZ = 0, ///< IF frequency = 0 MHz
++ IF_FREQ_4570000HZ = 4570000, ///< IF frequency = 4.57 MHz
++ IF_FREQ_4571429HZ = 4571429, ///< IF frequency = 4.571 MHz
++ IF_FREQ_36000000HZ = 36000000, ///< IF frequency = 36.0 MHz
++ IF_FREQ_36125000HZ = 36125000, ///< IF frequency = 36.125 MHz
++ IF_FREQ_36166667HZ = 36166667, ///< IF frequency = 36.167 MHz
++ IF_FREQ_43750000HZ = 43750000, ///< IF frequency = 43.75 MHz
++ IF_FREQ_44000000HZ = 44000000, ///< IF frequency = 44.0 MHz
++};
++
++
++/// Spectrum mode
++enum SPECTRUM_MODE
++{
++ SPECTRUM_NORMAL, ///< Normal spectrum
++ SPECTRUM_INVERSE, ///< Inverse spectrum
++};
++#define SPECTRUM_MODE_NUM 2
++
++
++/// TS interface mode
++enum TS_INTERFACE_MODE
++{
++ TS_INTERFACE_PARALLEL, ///< Parallel TS interface
++ TS_INTERFACE_SERIAL, ///< Serial TS interface
++};
++#define TS_INTERFACE_MODE_NUM 2
++
++
++
++
++
++/// Base interface module alias
++typedef struct BASE_INTERFACE_MODULE_TAG BASE_INTERFACE_MODULE;
++
++
++
++
++
++/**
++
++@brief Basic I2C reading function pointer
++
++Upper layer functions will use BASE_FP_I2C_READ() to read ByteNum bytes from I2C device to pReadingBytes buffer.
++
++
++@param [in] pBaseInterface The base interface module pointer
++@param [in] DeviceAddr I2C device address in 8-bit format
++@param [out] pReadingBytes Buffer pointer to an allocated memory for storing reading bytes
++@param [in] ByteNum Reading byte number
++
++
++@retval FUNCTION_SUCCESS Read bytes from I2C device with reading byte number successfully.
++@retval FUNCTION_ERROR Read bytes from I2C device unsuccessfully.
++
++
++@note
++ The requirements of BASE_FP_I2C_READ() function are described as follows:
++ -# Follow the I2C format for BASE_FP_I2C_READ(). \n
++ start_bit + (DeviceAddr | reading_bit) + reading_byte * ByteNum + stop_bit
++ -# Don't allocate memory on pReadingBytes.
++ -# Upper layer functions should allocate memory on pReadingBytes before using BASE_FP_I2C_READ().
++ -# Need to assign I2C reading funtion to BASE_FP_I2C_READ() for upper layer functions.
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++// Implement I2C reading funciton for BASE_FP_I2C_READ function pointer.
++int
++CustomI2cRead(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++
++ return FUNCTION_ERROR;
++}
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ unsigned char ReadingBytes[100];
++
++
++ // Assign implemented I2C reading funciton to BASE_FP_I2C_READ in base interface module.
++ BuildBaseInterface(&pBaseInterface, &BaseInterfaceModuleMemory, ..., ..., CustomI2cRead, ..., ...);
++
++ ...
++
++ // Use I2cRead() to read 33 bytes from I2C device and store reading bytes to ReadingBytes.
++ pBaseInterface->I2cRead(pBaseInterface, 0x20, ReadingBytes, 33);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*BASE_FP_I2C_READ)(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ );
++
++
++
++
++
++/**
++
++@brief Basic I2C writing function pointer
++
++Upper layer functions will use BASE_FP_I2C_WRITE() to write ByteNum bytes from pWritingBytes buffer to I2C device.
++
++
++@param [in] pBaseInterface The base interface module pointer
++@param [in] DeviceAddr I2C device address in 8-bit format
++@param [in] pWritingBytes Buffer pointer to writing bytes
++@param [in] ByteNum Writing byte number
++
++
++@retval FUNCTION_SUCCESS Write bytes to I2C device with writing bytes successfully.
++@retval FUNCTION_ERROR Write bytes to I2C device unsuccessfully.
++
++
++@note
++ The requirements of BASE_FP_I2C_WRITE() function are described as follows:
++ -# Follow the I2C format for BASE_FP_I2C_WRITE(). \n
++ start_bit + (DeviceAddr | writing_bit) + writing_byte * ByteNum + stop_bit
++ -# Need to assign I2C writing funtion to BASE_FP_I2C_WRITE() for upper layer functions.
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++// Implement I2C writing funciton for BASE_FP_I2C_WRITE function pointer.
++int
++CustomI2cWrite(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++
++ return FUNCTION_ERROR;
++}
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ unsigned char WritingBytes[100];
++
++
++ // Assign implemented I2C writing funciton to BASE_FP_I2C_WRITE in base interface module.
++ BuildBaseInterface(&pBaseInterface, &BaseInterfaceModuleMemory, ..., ..., ..., CustomI2cWrite, ...);
++
++ ...
++
++ // Use I2cWrite() to write 33 bytes from WritingBytes to I2C device.
++ pBaseInterface->I2cWrite(pBaseInterface, 0x20, WritingBytes, 33);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef int
++(*BASE_FP_I2C_WRITE)(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ );
++
++
++
++
++
++/**
++
++@brief Basic waiting function pointer
++
++Upper layer functions will use BASE_FP_WAIT_MS() to wait WaitTimeMs millisecond.
++
++
++@param [in] pBaseInterface The base interface module pointer
++@param [in] WaitTimeMs Waiting time in millisecond
++
++
++@note
++ The requirements of BASE_FP_WAIT_MS() function are described as follows:
++ -# Need to assign a waiting function to BASE_FP_WAIT_MS() for upper layer functions.
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++// Implement waiting funciton for BASE_FP_WAIT_MS function pointer.
++void
++CustomWaitMs(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned long WaitTimeMs
++ )
++{
++ ...
++
++ return;
++}
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++
++
++ // Assign implemented waiting funciton to BASE_FP_WAIT_MS in base interface module.
++ BuildBaseInterface(&pBaseInterface, &BaseInterfaceModuleMemory, ..., ..., ..., ..., CustomWaitMs);
++
++ ...
++
++ // Use WaitMs() to wait 30 millisecond.
++ pBaseInterface->WaitMs(pBaseInterface, 30);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef void
++(*BASE_FP_WAIT_MS)(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned long WaitTimeMs
++ );
++
++
++
++
++
++/**
++
++@brief User defined data pointer setting function pointer
++
++One can use BASE_FP_SET_USER_DEFINED_DATA_POINTER() to set user defined data pointer of base interface structure for
++custom basic function implementation.
++
++
++@param [in] pBaseInterface The base interface module pointer
++@param [in] pUserDefinedData Pointer to user defined data
++
++
++@note
++ One can use BASE_FP_GET_USER_DEFINED_DATA_POINTER() to get user defined data pointer of base interface structure for
++ custom basic function implementation.
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++// Implement I2C reading funciton for BASE_FP_I2C_READ function pointer.
++int
++CustomI2cRead(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ CUSTOM_USER_DEFINED_DATA *pUserDefinedData;
++
++
++ // Get user defined data pointer of base interface structure for custom I2C reading function.
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&pUserDefinedData);
++
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++
++ return FUNCTION_ERROR;
++}
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ unsigned char ReadingBytes[100];
++
++ CUSTOM_USER_DEFINED_DATA UserDefinedData;
++
++
++ // Assign implemented I2C reading funciton to BASE_FP_I2C_READ in base interface module.
++ BuildBaseInterface(&pBaseInterface, &BaseInterfaceModuleMemory, ..., ..., CustomI2cRead, ..., ...);
++
++ ...
++
++ // Set user defined data pointer of base interface structure for custom basic functions.
++ pBaseInterface->SetUserDefinedDataPointer(pBaseInterface, &UserDefinedData);
++
++ // Use I2cRead() to read 33 bytes from I2C device and store reading bytes to ReadingBytes.
++ pBaseInterface->I2cRead(pBaseInterface, 0x20, ReadingBytes, 33);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef void
++(*BASE_FP_SET_USER_DEFINED_DATA_POINTER)(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ void *pUserDefinedData
++ );
++
++
++
++
++
++/**
++
++@brief User defined data pointer getting function pointer
++
++One can use BASE_FP_GET_USER_DEFINED_DATA_POINTER() to get user defined data pointer of base interface structure for
++custom basic function implementation.
++
++
++@param [in] pBaseInterface The base interface module pointer
++@param [in] ppUserDefinedData Pointer to user defined data pointer
++
++
++@note
++ One can use BASE_FP_SET_USER_DEFINED_DATA_POINTER() to set user defined data pointer of base interface structure for
++ custom basic function implementation.
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++// Implement I2C reading funciton for BASE_FP_I2C_READ function pointer.
++int
++CustomI2cRead(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ CUSTOM_USER_DEFINED_DATA *pUserDefinedData;
++
++
++ // Get user defined data pointer of base interface structure for custom I2C reading function.
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&pUserDefinedData);
++
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++
++ return FUNCTION_ERROR;
++}
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ unsigned char ReadingBytes[100];
++
++ CUSTOM_USER_DEFINED_DATA UserDefinedData;
++
++
++ // Assign implemented I2C reading funciton to BASE_FP_I2C_READ in base interface module.
++ BuildBaseInterface(&pBaseInterface, &BaseInterfaceModuleMemory, ..., ..., CustomI2cRead, ..., ...);
++
++ ...
++
++ // Set user defined data pointer of base interface structure for custom basic functions.
++ pBaseInterface->SetUserDefinedDataPointer(pBaseInterface, &UserDefinedData);
++
++ // Use I2cRead() to read 33 bytes from I2C device and store reading bytes to ReadingBytes.
++ pBaseInterface->I2cRead(pBaseInterface, 0x20, ReadingBytes, 33);
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++typedef void
++(*BASE_FP_GET_USER_DEFINED_DATA_POINTER)(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ void **ppUserDefinedData
++ );
++
++
++
++
++
++/// Base interface module structure
++struct BASE_INTERFACE_MODULE_TAG
++{
++ // Variables and function pointers
++ unsigned char I2cReadingByteNumMax;
++ unsigned char I2cWritingByteNumMax;
++
++ BASE_FP_I2C_READ I2cRead;
++ BASE_FP_I2C_WRITE I2cWrite;
++ BASE_FP_WAIT_MS WaitMs;
++
++ BASE_FP_SET_USER_DEFINED_DATA_POINTER SetUserDefinedDataPointer;
++ BASE_FP_GET_USER_DEFINED_DATA_POINTER GetUserDefinedDataPointer;
++
++
++ // User defined data
++ void *pUserDefinedData;
++};
++
++
++
++
++
++/**
++
++@brief Base interface builder
++
++Use BuildBaseInterface() to build base interface for module functions to access basic functions.
++
++
++@param [in] ppBaseInterface Pointer to base interface module pointer
++@param [in] pBaseInterfaceModuleMemory Pointer to an allocated base interface module memory
++@param [in] I2cReadingByteNumMax Maximum I2C reading byte number for basic I2C reading function
++@param [in] I2cWritingByteNumMax Maximum I2C writing byte number for basic I2C writing function
++@param [in] I2cRead Basic I2C reading function pointer
++@param [in] I2cWrite Basic I2C writing function pointer
++@param [in] WaitMs Basic waiting function pointer
++
++
++@note
++ -# One should build base interface before using module functions.
++ -# The I2C reading format is described as follows:
++ start_bit + (device_addr | reading_bit) + reading_byte * byte_num + stop_bit
++ -# The I2cReadingByteNumMax is the maximum byte_num of the I2C reading format.
++ -# The I2C writing format is described as follows:
++ start_bit + (device_addr | writing_bit) + writing_byte * byte_num + stop_bit
++ -# The I2cWritingByteNumMax is the maximum byte_num of the I2C writing format.
++
++
++
++@par Example:
++@code
++
++
++#include "foundation.h"
++
++
++// Implement I2C reading funciton for BASE_FP_I2C_READ function pointer.
++int
++CustomI2cRead(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++
++ return FUNCTION_ERROR;
++}
++
++
++// Implement I2C writing funciton for BASE_FP_I2C_WRITE function pointer.
++int
++CustomI2cWrite(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++
++ return FUNCTION_ERROR;
++}
++
++
++// Implement waiting funciton for BASE_FP_WAIT_MS function pointer.
++void
++CustomWaitMs(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned long WaitTimeMs
++ )
++{
++ ...
++
++ return;
++}
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++
++
++ // Build base interface with the following settings.
++ //
++ // 1. Assign 9 to maximum I2C reading byte number.
++ // 2. Assign 8 to maximum I2C writing byte number.
++ // 3. Assign CustomI2cRead() to basic I2C reading function pointer.
++ // 4. Assign CustomI2cWrite() to basic I2C writing function pointer.
++ // 5. Assign CustomWaitMs() to basic waiting function pointer.
++ //
++ BuildBaseInterface(
++ &pBaseInterface,
++ &BaseInterfaceModuleMemory,
++ 9,
++ 8,
++ CustomI2cRead,
++ CustomI2cWrite,
++ CustomWaitMs
++ );
++
++ ...
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++void
++BuildBaseInterface(
++ BASE_INTERFACE_MODULE **ppBaseInterface,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ unsigned char I2cReadingByteNumMax,
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs
++ );
++
++
++
++
++
++// User data pointer of base interface structure setting and getting functions
++void
++base_interface_SetUserDefinedDataPointer(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ void *pUserDefinedData
++ );
++
++void
++base_interface_GetUserDefinedDataPointer(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ void **ppUserDefinedData
++ );
++
++
++
++
++
++// Math functions
++
++// Binary and signed integer converter
++unsigned long
++SignedIntToBin(
++ long Value,
++ unsigned char BitNum
++ );
++
++long
++BinToSignedInt(
++ unsigned long Binary,
++ unsigned char BitNum
++ );
++
++
++
++// Arithmetic
++unsigned long
++DivideWithCeiling(
++ unsigned long Dividend,
++ unsigned long Divisor
++ );
++
++
++
++
++
++
++
++
++
++
++
++/**
++
++@mainpage Realtek demod Source Code Manual
++
++@note
++ -# The Realtek demod API source code is designed for demod IC driver porting.
++ -# The API source code is written in C language without floating-point arithmetic.
++ -# One can use the API to manipulate Realtek demod IC.
++ -# The API will call custom underlayer functions through API base interface module.
++
++
++@par Important:
++ -# Please assign API base interface module with custom underlayer functions instead of modifying API source code.
++ -# Please see the example code to understand the relation bewteen API and custom system.
++
++*/
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/history.txt
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/history.txt Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,11 @@
++
++History of Realtek RTL2832U DVB-T Linux Driver:
++
++
++Ver 1.1 a. add customers' VID&PID
++ b. solve the bug that our module cann't be removed when the device is plugged out.
++
++Ver 1.0 support tuners--MT2266 FC2580 TUA9001 and MXL5007T
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/i2c_bridge.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/i2c_bridge.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,119 @@
++#ifndef __I2C_BRIDGE_H
++#define __I2C_BRIDGE_H
++
++/**
++
++@file
++
++@brief I2C bridge module
++
++I2C bridge module contains I2C forwarding function pointers.
++
++*/
++
++
++
++
++
++/// I2C bridge module pre-definition
++typedef struct I2C_BRIDGE_MODULE_TAG I2C_BRIDGE_MODULE;
++
++
++
++
++
++/**
++
++@brief I2C reading command forwarding function pointer
++
++Tuner upper level functions will use I2C_BRIDGE_FP_FORWARD_I2C_READING_CMD() to send tuner I2C reading command through
++demod.
++
++
++@param [in] pI2cBridge The I2C bridge module pointer
++@param [out] pReadingBytes Pointer to an allocated memory for storing reading bytes
++@param [in] ByteNum Reading byte number
++
++
++@retval FUNCTION_SUCCESS Forwarding I2C reading command successfully.
++@retval FUNCTION_ERROR Forwarding I2C reading command unsuccessfully.
++
++
++@note
++ -# Demod building function will set I2C_BRIDGE_FP_FORWARD_I2C_READING_CMD() with the corresponding function.
++
++*/
++typedef int
++(*I2C_BRIDGE_FP_FORWARD_I2C_READING_CMD)(
++ I2C_BRIDGE_MODULE *pI2cBridge,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ );
++
++
++
++
++
++/**
++
++@brief I2C writing command forwarding function pointer
++
++Tuner upper level functions will use I2C_BRIDGE_FP_FORWARD_I2C_WRITING_CMD() to send tuner I2C writing command through
++demod.
++
++
++@param [in] pI2cBridge The I2C bridge module pointer
++@param [out] pWritingBytes Pointer to writing bytes
++@param [in] ByteNum Writing byte number
++
++
++@retval FUNCTION_SUCCESS Forwarding I2C writing command successfully.
++@retval FUNCTION_ERROR Forwarding I2C writing command unsuccessfully.
++
++
++@note
++ -# Demod building function will set I2C_BRIDGE_FP_FORWARD_I2C_WRITING_CMD() with the corresponding function.
++
++*/
++typedef int
++(*I2C_BRIDGE_FP_FORWARD_I2C_WRITING_CMD)(
++ I2C_BRIDGE_MODULE *pI2cBridge,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ );
++
++
++
++
++
++/// I2C bridge module structure
++struct I2C_BRIDGE_MODULE_TAG
++{
++ // Private variables
++ void *pPrivateData;
++ unsigned char *pTunerDeviceAddr;
++
++
++ // I2C bridge function pointers
++ I2C_BRIDGE_FP_FORWARD_I2C_READING_CMD ForwardI2cReadingCmd; ///< I2C reading command forwading function pointer
++ I2C_BRIDGE_FP_FORWARD_I2C_WRITING_CMD ForwardI2cWritingCmd; ///< I2C writing command forwading function pointer
++
++};
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/math_mpi.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/math_mpi.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,1054 @@
++/**
++
++@file
++
++@brief Mutliple precision integer (MPI) arithmetic definition
++
++One can use to mutliple precision arithmetic to manipulate large signed integers.
++
++*/
++
++
++#include "math_mpi.h"
++
++
++
++
++
++/**
++
++@brief Set multiple precision signed integer value.
++
++Use MpiSetValue() to set multiple precision signed integer MPI value.
++
++
++@param [in] pMpiVar Pointer to an MPI variable
++@param [in] Value Value for setting
++
++
++@note
++ The MPI bit number will be minimized in MpiSetValue().
++
++*/
++void
++MpiSetValue(
++ MPI *pMpiVar,
++ long Value
++ )
++{
++ int i;
++ unsigned char SignedBit;
++ unsigned char ExtensionByte;
++
++
++
++ // Set MPI value according to ansigned value.
++ for(i = 0; i < MPI_LONG_BYTE_NUM; i++)
++ pMpiVar->Value[i] = (unsigned char)((Value >> (MPI_BYTE_SHIFT * i)) & MPI_BYTE_MASK);
++
++
++ // Get extension byte according to signed bit.
++ SignedBit = (unsigned char)((Value >> (MPI_LONG_BIT_NUM - 1)) & MPI_BIT_0_MASK);
++ ExtensionByte = (SignedBit == 0x0) ? 0x00 : 0xff;
++
++
++ // Extend MPI signed bit with extension byte stuff.
++ for(i = MPI_LONG_BYTE_NUM; i < MPI_VALUE_BYTE_NUM_MAX; i++)
++ pMpiVar->Value[i] = ExtensionByte;
++
++
++ // Minimize MPI bit number.
++ MpiMinimizeBitNum(pMpiVar);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Get multiple precision signed integer value.
++
++Use MpiGetValue() to get multiple precision unsigned integer MPI value.
++
++
++@param [in] MpiVar Pointer to an MPI variable
++@param [out] pValue Pointer to an allocated memory for getting MPI value
++
++
++@note
++ The necessary bit number of MPI value must be less than or equal to 32 bits.
++
++*/
++void
++MpiGetValue(
++ MPI MpiVar,
++ long *pValue
++ )
++{
++ int i;
++ unsigned long Value;
++
++
++
++ // Set value with zero.
++ Value = 0x0;
++
++
++ // Combine MPI value bytes into value.
++ for(i = 0; i < MPI_LONG_BYTE_NUM; i++)
++ Value |= MpiVar.Value[i] << (MPI_BYTE_SHIFT * i);
++
++
++ // Assigned value to value pointer.
++ *pValue = (long)Value;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Set multiple precision signed integer bit value.
++
++Use MpiSetBit() to set multiple precision signed integer MPI bit value.
++
++
++@param [in] pMpiVar Pointer to an MPI variable
++@param [in] BitPosition Bit position with zero-based index
++@param [in] BitValue Bit value for setting
++
++
++@note
++ Bit position must be 0 ~ (MPI bit number).
++
++*/
++void
++MpiSetBit(
++ MPI *pMpiVar,
++ unsigned long BitPosition,
++ unsigned char BitValue
++ )
++{
++ unsigned long TargetBytePos, TargetBitPos;
++
++
++
++ // Calculate target byte and bit position.
++ TargetBytePos = BitPosition / MPI_BYTE_BIT_NUM;
++ TargetBitPos = BitPosition % MPI_BYTE_BIT_NUM;
++
++
++ // Set MPI bit value according to calculated target byte and bit position.
++ pMpiVar->Value[TargetBytePos] &= (unsigned char)(~(0x1 << TargetBitPos));
++ pMpiVar->Value[TargetBytePos] |= (BitValue & MPI_BIT_0_MASK) << TargetBitPos;
++
++
++ return;
++}
++
++
++
++
++
++
++/**
++
++@brief Get multiple precision signed integer bit value.
++
++Use MpiGetBit() to get multiple precision unsigned integer MPI bit value.
++
++
++@param [in] MpiVar Pointer to an MPI variable
++@param [in] BitPosition Bit position with zero-based index
++@param [out] pBitValue Pointer to an allocated memory for getting MPI bit value
++
++
++@note
++ Bit position must be 0 ~ (MPI bit number).
++
++*/
++void
++MpiGetBit(
++ MPI MpiVar,
++ unsigned long BitPosition,
++ unsigned char *pBitValue
++ )
++{
++ unsigned long TargetBytePos, TargetBitPos;
++
++
++
++ // Calculate target byte and bit position.
++ TargetBytePos = BitPosition / MPI_BYTE_BIT_NUM;
++ TargetBitPos = BitPosition % MPI_BYTE_BIT_NUM;
++
++
++ // Get MPI bit value according to calculated target byte and bit position.
++ *pBitValue = (MpiVar.Value[TargetBytePos] >> TargetBitPos) & MPI_BIT_0_MASK;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Get multiple precision signed integer signed bit value.
++
++Use MpiGetBit() to get multiple precision unsigned integer MPI signed bit value.
++
++
++@param [in] MpiVar Pointer to an MPI variable
++@param [out] pSignedBitValue Pointer to an allocated memory for getting MPI signed bit value
++
++*/
++void
++MpiGetSignedBit(
++ MPI MpiVar,
++ unsigned char *pSignedBitValue
++ )
++{
++ // Get MPI variable signed bit.
++ MpiGetBit(MpiVar, MPI_VALUE_BIT_NUM_MAX - 1, pSignedBitValue);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Assign multiple precision signed integer with another one.
++
++Use MpiAssign() to assign multiple precision signed integer with another one.
++
++
++@param [out] pResult Pointer to an allocated memory for storing result
++@param [in] Operand Operand
++
++
++@note
++ The result bit number will be minimized in MpiAssign().
++
++*/
++void
++MpiAssign(
++ MPI *pResult,
++ MPI Operand
++ )
++{
++ unsigned int i;
++
++
++
++ // Copy value bytes from operand to result.
++ for(i = 0; i < MPI_VALUE_BYTE_NUM_MAX; i++)
++ pResult->Value[i] = Operand.Value[i];
++
++
++ // Minimize result bit nubmer.
++ MpiMinimizeBitNum(pResult);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Minus unary multiple precision signed integer.
++
++Use MpiUnaryMinus() to minus unary multiple precision signed integer.
++
++
++@param [out] pResult Pointer to an allocated memory for storing result
++@param [in] Operand Operand
++
++
++@note
++ The result bit number will be minimized in MpiUnaryMinus().
++
++*/
++void
++MpiUnaryMinus(
++ MPI *pResult,
++ MPI Operand
++ )
++{
++ unsigned int i;
++ MPI Const;
++
++
++
++ // Set result value byte with operand bitwise complement value byte.
++ for(i = 0; i < MPI_VALUE_BYTE_NUM_MAX; i++)
++ pResult->Value[i] = ~Operand.Value[i];
++
++
++ // Add result with 0x1.
++ // Note: MpiAdd() will minimize result bit number.
++ MpiSetValue(&Const, 0x1);
++ MpiAdd(pResult, *pResult, Const);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Add multiple precision signed integers.
++
++Use MpiAdd() to add multiple precision signed integers.
++
++
++@param [out] pSum Pointer to an allocated memory for storing sum
++@param [in] Augend Augend
++@param [in] Addend Addend
++
++
++@note
++ The sum bit number will be minimized in MpiAdd().
++
++*/
++void
++MpiAdd(
++ MPI *pSum,
++ MPI Augend,
++ MPI Addend
++ )
++{
++ unsigned int i;
++ unsigned long MiddleResult;
++ unsigned char Carry;
++
++
++ // Add augend and addend to sum form value LSB byte to value MSB byte.
++ Carry = 0;
++
++ for(i = 0; i < MPI_VALUE_BYTE_NUM_MAX; i++)
++ {
++ // Set current sum value byte and determine carry.
++ MiddleResult = Augend.Value[i] + Addend.Value[i] + Carry;
++ pSum->Value[i] = (unsigned char)(MiddleResult & MPI_BYTE_MASK);
++ Carry = (unsigned char)((MiddleResult >> MPI_BYTE_SHIFT) & MPI_BYTE_MASK);
++ }
++
++
++ // Minimize sum bit nubmer.
++ MpiMinimizeBitNum(pSum);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief subtract multiple precision signed integers.
++
++Use MpiSub() to subtract multiple precision signed integers.
++
++
++@param [out] pDifference Pointer to an allocated memory for storing difference
++@param [in] Minuend Minuend
++@param [in] Subtrahend Subtrahend
++
++
++@note
++ The difference bit number will be minimized in MpiSub().
++
++*/
++void
++MpiSub(
++ MPI *pDifference,
++ MPI Minuend,
++ MPI Subtrahend
++ )
++{
++ MPI MiddleResult;
++
++
++
++ // Take subtrahend unary minus value.
++ MpiUnaryMinus(&MiddleResult, Subtrahend);
++
++
++ // Add minuend and subtrahend unary minus value to difference.
++ // Note: MpiAdd() will minimize result bit number.
++ MpiAdd(pDifference, Minuend, MiddleResult);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Multiply arbitrary precision signed integers.
++
++Use MpiMul() to multiply arbitrary precision signed integers.
++
++
++@param [out] pProduct Pointer to an allocated memory for storing product
++@param [in] Multiplicand Multiplicand
++@param [in] Multiplicator Multiplicator
++
++
++@note
++ -# The sum of multiplicand and multiplicator bit number must be less MPI_VALUE_BIT_NUM_MAX.
++ -# The product bit number will be minimized in MpiMul().
++
++*/
++void
++MpiMul(
++ MPI *pProduct,
++ MPI Multiplicand,
++ MPI Multiplicator
++ )
++{
++ int i;
++
++ unsigned char MultiplicandSignedBit, MultiplicatorSignedBit;
++ MPI MultiplicandAbs, MultiplicatorAbs;
++
++ unsigned char CurrentBit;
++
++
++
++ // Get multiplicand signed bit.
++ MpiGetSignedBit(Multiplicand, &MultiplicandSignedBit);
++
++ // Take absolute value of multiplicand.
++ if(MultiplicandSignedBit == 0x0)
++ MpiAssign(&MultiplicandAbs, Multiplicand);
++ else
++ MpiUnaryMinus(&MultiplicandAbs, Multiplicand);
++
++
++ // Get multiplicator signed bit.
++ MpiGetSignedBit(Multiplicator, &MultiplicatorSignedBit);
++
++ // Take absolute value of multiplicator.
++ if(MultiplicatorSignedBit == 0x0)
++ MpiAssign(&MultiplicatorAbs, Multiplicator);
++ else
++ MpiUnaryMinus(&MultiplicatorAbs, Multiplicator);
++
++
++ // Multiply multiplicand and multiplicator from LSB bit to MSB bit.
++ MpiSetValue(pProduct, 0x0);
++
++ for(i = MPI_VALUE_BIT_NUM_MAX - 1; i > -1; i--)
++ {
++ // Shift product toward left with one bit.
++ MpiLeftShift(pProduct, *pProduct, 1);
++
++ // Get current absolute multiplicator bit value.
++ MpiGetBit(MultiplicatorAbs, i, &CurrentBit);
++
++ // If current multiplicator bit is 0x1, add absolute multiplicand value to product.
++ // Note: MpiAdd() will minimize result bit number.
++ if(CurrentBit == 0x1)
++ MpiAdd(pProduct, *pProduct, MultiplicandAbs);
++ }
++
++
++ // Determine the signed bit of product according to signed bits of multiplicand and multiplicator.
++ // Note: MpiUnaryMinus() will minimize result bit number.
++ if(MultiplicandSignedBit != MultiplicatorSignedBit)
++ MpiUnaryMinus(pProduct, *pProduct);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Divide arbitrary precision signed integers.
++
++Use MpiDiv() to divide arbitrary precision signed integers.
++
++
++@param [out] pQuotient Pointer to an allocated memory for storing quotient
++@param [out] pRemainder Pointer to an allocated memory for storing remainder
++@param [in] Dividend Dividend
++@param [in] Divisor Divisor
++
++
++@note
++ -# The dividend bit number must be minimized.
++ -# The divisor must be not equal to zero.
++ -# The product bit number will be minimized in MpiDiv().
++
++*/
++void
++MpiDiv(
++ MPI *pQuotient,
++ MPI *pRemainder,
++ MPI Dividend,
++ MPI Divisor
++ )
++{
++ unsigned int i;
++
++ unsigned char DividendSignedBit, DivisorSignedBit;
++ MPI DividendAbs, DivisorAbs;
++
++ unsigned long PrimaryDividendBitNum;
++ unsigned char ShiftBit;
++
++ MPI Const;
++ MPI MiddleResult;
++
++
++
++ // Get dividend signed bit.
++ MpiGetSignedBit(Dividend, &DividendSignedBit);
++
++ // Take absolute value of dividend.
++ if(DividendSignedBit == 0x0)
++ MpiAssign(&DividendAbs, Dividend);
++ else
++ MpiUnaryMinus(&DividendAbs, Dividend);
++
++
++ // Get divisor signed bit.
++ MpiGetSignedBit(Divisor, &DivisorSignedBit);
++
++ // Take absolute value of divisor.
++ if(DivisorSignedBit == 0x0)
++ MpiAssign(&DivisorAbs, Divisor);
++ else
++ MpiUnaryMinus(&DivisorAbs, Divisor);
++
++
++ // Get primary absolute dividend bit number.
++ PrimaryDividendBitNum = DividendAbs.BitNum;
++
++
++ // Get quotient and remainder by division algorithm.
++ MpiSetValue(pQuotient, 0x0);
++ MpiSetValue(pRemainder, 0x0);
++
++ for(i = 0; i < PrimaryDividendBitNum; i++)
++ {
++ // Shift quotient toward left with one bit.
++ // Note: MpiLeftShift() will minimize result bit number.
++ MpiLeftShift(pQuotient, *pQuotient, 1);
++
++ // Shift remainder toward left with one bit.
++ MpiLeftShift(pRemainder, *pRemainder, 1);
++
++ // Shift absolute dividend toward left with one bit.
++ MpiLeftShift(&DividendAbs, DividendAbs, 1);
++
++ // Set remainder LSB according to absolute dividend.
++ MpiGetBit(DividendAbs, PrimaryDividendBitNum, &ShiftBit);
++ MpiSetBit(pRemainder, 0, ShiftBit);
++
++ // If remainder is greater than or equal to absolute divisor,
++ // substract absolute divisor from remainder and set quotient LSB with one.
++ if(MpiGreaterThan(*pRemainder, DivisorAbs) || MpiEqualTo(*pRemainder, DivisorAbs))
++ {
++ MpiSub(pRemainder, *pRemainder, DivisorAbs);
++ MpiSetBit(pQuotient, 0, 0x1);
++ }
++ }
++
++
++ // Modify quotient according to dividend signed bit, divisor signed bit, and remainder.
++
++ // Determine the signed bit of quotient.
++ if(DividendSignedBit != DivisorSignedBit)
++ {
++ // Take unary minus quotient.
++ // Note: MpiUnaryMinus() will minimize result bit number.
++ MpiUnaryMinus(pQuotient, *pQuotient);
++
++ // If remainder is greater than zero, subtract 1 from quotient.
++ // Note: MpiSub() will minimize result bit number.
++ MpiSetValue(&Const, 0x0);
++
++ if(MpiGreaterThan(*pRemainder, Const))
++ {
++ MpiSetValue(&Const, 0x1);
++ MpiSub(pQuotient, *pQuotient, Const);
++ }
++ }
++
++
++ // Modify remainder according to dividend, divisor, and quotient.
++
++ // Remainder = dividend - divisor * quotient;
++ // Note: MpiSub() will minimize result bit number.
++ MpiMul(&MiddleResult, Divisor, *pQuotient);
++ MpiSub(pRemainder, Dividend, MiddleResult);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Shift multiple precision signed integer toward right.
++
++Use MpiRightShift() to shift arbitrary precision signed integer toward right with assigned bit number.
++
++
++@param [out] pResult Pointer to an allocated memory for storing result
++@param [in] Operand Operand
++@param [in] ShiftBitNum Shift bit number
++
++
++@note
++ -# The result MSB bits will be stuffed with signed bit
++ -# The result bit number will be minimized in MpiRightShift().
++
++*/
++void
++MpiRightShift(
++ MPI *pResult,
++ MPI Operand,
++ unsigned long ShiftBitNum
++ )
++{
++ unsigned int i;
++ unsigned long StuffBitNum;
++ unsigned char CurrentBit;
++ unsigned char SignedBit;
++
++
++
++ // Determine stuff bit number according to shift bit nubmer.
++ StuffBitNum = (ShiftBitNum < MPI_VALUE_BIT_NUM_MAX) ? ShiftBitNum : MPI_VALUE_BIT_NUM_MAX;
++
++
++ // Copy operand bits to result with stuff bit number.
++ for(i = 0; i < (MPI_VALUE_BIT_NUM_MAX - StuffBitNum); i++)
++ {
++ MpiGetBit(Operand, i + StuffBitNum, &CurrentBit);
++ MpiSetBit(pResult, i, CurrentBit);
++ }
++
++
++ // Get operand signed bit.
++ MpiGetSignedBit(Operand, &SignedBit);
++
++
++ // Stuff result MSB bits with signed bit.
++ for(i = (MPI_VALUE_BIT_NUM_MAX - StuffBitNum); i < MPI_VALUE_BIT_NUM_MAX; i++)
++ MpiSetBit(pResult, i, SignedBit);
++
++
++ // Minimize result bit number.
++ MpiMinimizeBitNum(pResult);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Shift multiple precision signed integer toward left.
++
++Use MpiLeftShift() to shift arbitrary precision signed integer toward left with assigned bit number.
++
++
++@param [out] pResult Pointer to an allocated memory for storing result
++@param [in] Operand Operand
++@param [in] ShiftBitNum Shift bit number
++
++
++@note
++ The result bit number will be minimized in MpiLeftShift().
++
++*/
++void
++MpiLeftShift(
++ MPI *pResult,
++ MPI Operand,
++ unsigned long ShiftBitNum
++ )
++{
++ unsigned int i;
++ unsigned long StuffBitNum;
++ unsigned char CurrentBit;
++
++
++ // Determine stuff bit number according to shift bit nubmer.
++ StuffBitNum = (ShiftBitNum < MPI_VALUE_BIT_NUM_MAX) ? ShiftBitNum : MPI_VALUE_BIT_NUM_MAX;
++
++
++ // Stuff result LSB bits with zeros
++ for(i = 0; i < StuffBitNum; i++)
++ MpiSetBit(pResult, i, 0x0);
++
++
++ // Copy operand bits to result with stuff bit number.
++ for(i = StuffBitNum; i < MPI_VALUE_BIT_NUM_MAX; i++)
++ {
++ MpiGetBit(Operand, i - StuffBitNum, &CurrentBit);
++ MpiSetBit(pResult, i, CurrentBit);
++ }
++
++
++ // Minimize result bit number.
++ MpiMinimizeBitNum(pResult);
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Compare multiple precision signed integes with equal-to criterion.
++
++Use MpiEqualTo() to compare multiple precision signed integes with equal-to criterion.
++
++
++@param [in] MpiLeft Left MPI
++@param [in] MpiRight Right MPI
++
++
++@retval MPI_NO "Left MPI == Right MPI" is false.
++@retval MPI_YES "Left MPI == Right MPI" is true.
++
++
++@note
++ The constants MPI_YES and MPI_NO are defined in MPI_YES_NO_STATUS enumeration.
++
++*/
++int
++MpiEqualTo(
++ MPI MpiLeft,
++ MPI MpiRight
++ )
++{
++ unsigned int i;
++
++
++
++ // Check not-equal-to condition.
++ for(i = 0; i < MPI_VALUE_BYTE_NUM_MAX; i++)
++ {
++ if(MpiLeft.Value[i] != MpiRight.Value[i])
++ goto condition_others;
++ }
++
++
++ // Right MPI is greater than left MPI.
++ return MPI_YES;
++
++
++condition_others:
++
++
++ // Other conditions.
++ return MPI_NO;
++}
++
++
++
++
++
++/**
++
++@brief Compare multiple precision signed integes with greater-than criterion.
++
++Use MpiGreaterThan() to compare multiple precision signed integes with greater-than criterion.
++
++
++@param [in] MpiLeft Left MPI
++@param [in] MpiRight Right MPI
++
++
++@retval MPI_NO "Left MPI > Right MPI" is false.
++@retval MPI_YES "Left MPI > Right MPI" is true.
++
++
++@note
++ The constants MPI_YES and MPI_NO are defined in MPI_YES_NO_STATUS enumeration.
++
++*/
++int
++MpiGreaterThan(
++ MPI MpiLeft,
++ MPI MpiRight
++ )
++{
++ MPI MiddleResult;
++ unsigned char SignedBit;
++
++
++
++ // Check equal-to condition.
++ if(MpiEqualTo(MpiLeft, MpiRight) == MPI_YES)
++ goto condition_others;
++
++
++ // Subtract right MPI form left MPI.
++ MpiSub(&MiddleResult, MpiLeft, MpiRight);
++
++
++ // Check less-than condition.
++ MpiGetSignedBit(MiddleResult, &SignedBit);
++
++ if(SignedBit == 0x1)
++ goto condition_others;
++
++
++ // Right MPI is greater than left MPI.
++ return MPI_YES;
++
++
++condition_others:
++
++
++ // Other conditions.
++ return MPI_NO;
++}
++
++
++
++
++
++/**
++
++@brief Compare multiple precision signed integes with less-than criterion.
++
++Use MpiLessThan() to compare multiple precision signed integes with less-than criterion.
++
++
++@param [in] MpiLeft Left MPI
++@param [in] MpiRight Right MPI
++
++
++@retval MPI_NO "Left MPI < Right MPI" is false.
++@retval MPI_YES "Left MPI < Right MPI" is true.
++
++
++@note
++ The constants MPI_YES and MPI_NO are defined in MPI_YES_NO_STATUS enumeration.
++
++*/
++int
++MpiLessThan(
++ MPI MpiLeft,
++ MPI MpiRight
++ )
++{
++ MPI MiddleResult;
++ unsigned char SignedBit;
++
++
++
++ // Check equal-to condition.
++ if(MpiEqualTo(MpiLeft, MpiRight) == MPI_YES)
++ goto condition_others;
++
++
++ // Subtract right MPI form left MPI.
++ MpiSub(&MiddleResult, MpiLeft, MpiRight);
++
++
++ // Check greater-than condition.
++ MpiGetSignedBit(MiddleResult, &SignedBit);
++
++ if(SignedBit == 0x0)
++ goto condition_others;
++
++
++ // Right MPI is less than left MPI.
++ return MPI_YES;
++
++
++condition_others:
++
++
++ // Other conditions.
++ return MPI_NO;
++}
++
++
++
++
++
++/**
++
++@brief Minimize multiple precision signed integer bit number.
++
++Use MpiMinimizeBitNum() to minimize multiple precision signed integer MPI bit number.
++
++
++@param [in] pMpiVar Pointer to an allocated memory for storing result
++
++*/
++void
++MpiMinimizeBitNum(
++ MPI *pMpiVar
++ )
++{
++ int i;
++ unsigned char SignedBit;
++ unsigned char BitValue;
++
++
++
++ // Get signed bit form MPI;
++ MpiGetSignedBit(*pMpiVar, &SignedBit);
++
++
++ // Find MPI MSB position.
++ // Note: The MSB of signed integer is the rightest signed bit.
++ for(i = (MPI_VALUE_BIT_NUM_MAX - 2); i > -1; i--)
++ {
++ // Get current bit value.
++ MpiGetBit(*pMpiVar, i, &BitValue);
++
++ // Compare current bit with signed bit.
++ if(BitValue != SignedBit)
++ break;
++ }
++
++
++ // Set MPI bit number.
++ // Note: MPI bit number must be greater than one.
++ pMpiVar->BitNum = (i == -1) ? 2 : (i + 2);
++
++
++ return;
++}
++
++
++
++
++
++
++/**
++
++@brief Calculate multiple precision signed integer logarithm with base 2.
++
++Use MpiMinimizeBitNum() to calculate multiple precision signed integer logarithm with base 2.
++
++
++@param [out] pResult Pointer to an allocated memory for storing result (unit: pow(2, - ResultFracBitNum))
++@param [in] MpiVar MPI variable for calculating
++@param [in] ResultFracBitNum Result fraction bit number
++
++
++@note
++ -# MPI variable bit number must be minimized.
++ -# MPI variable bit number must be less than (MPI_VALUE_BIT_NUM_MAX / 2 + 1).
++ -# MPI variable must be greater than zero.
++ -# If MPI variable is zero, the result is zero in MpiLog2().
++ -# The result bit number will be minimized in MpiLog2().
++
++*/
++void
++MpiLog2(
++ MPI *pResult,
++ MPI MpiVar,
++ unsigned long ResultFracBitNum
++ )
++{
++ unsigned int i;
++ MPI MiddleResult;
++ unsigned char BitValue;
++
++
++
++ // Get integer part of MPI logarithm result with base 2.
++ MpiSetValue(pResult, (long)(MpiVar.BitNum - 2));
++
++
++ // Get fraction part of MPI logarithm result with base 2 by logarithm algorithm.
++ // Note: Take middle result format as follows:
++ // x x . x x ~ x
++ // (integer part 2 bits) . (fraction part MPI_LOG_MIDDLE_RESULT_FRAC_BIT_NUM bits)
++
++ // Set middle result with initial value.
++ MpiLeftShift(&MiddleResult, MpiVar, (MPI_LOG_MIDDLE_RESULT_FRAC_BIT_NUM - MpiVar.BitNum + 2));
++
++ // Calculate result fraction bits.
++ for(i = 0; i < ResultFracBitNum; i++)
++ {
++ // Shift result toward left with one bit.
++ // Note: MpiLeftShift() will minimize result bit number.
++ MpiLeftShift(pResult, *pResult, 1);
++
++ // Square middle result.
++ MpiMul(&MiddleResult, MiddleResult, MiddleResult);
++
++ // Shift middle result toward right with fraction bit num.
++ MpiRightShift(&MiddleResult, MiddleResult, MPI_LOG_MIDDLE_RESULT_FRAC_BIT_NUM);
++
++ // Get middle result integer part bit 1.
++ MpiGetBit(MiddleResult, MPI_LOG_MIDDLE_RESULT_FRAC_BIT_NUM + 1, &BitValue);
++
++ // If middle result integer part bit 1 is equal to 0x1,
++ // shift middle result with one bit toward right and set result LSB with one.
++ if(BitValue == 0x1)
++ {
++ MpiRightShift(&MiddleResult, MiddleResult, 1);
++ MpiSetBit(pResult, 0, 0x1);
++ }
++ }
++
++
++ return;
++}
++
++
++
++
++
++
++
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/math_mpi.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/math_mpi.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,201 @@
++#ifndef __MATH_MPI_H
++#define __MATH_MPI_H
++
++/**
++
++@file
++
++@brief Mutliple precision integer (MPI) arithmetic declaration
++
++One can use to mutliple precision arithmetic to manipulate large signed integers.
++
++*/
++
++
++
++
++
++// Constant
++#define MPI_BYTE_BIT_NUM 8
++#define MPI_LONG_BYTE_NUM 4
++#define MPI_LONG_BIT_NUM 32
++
++
++
++// Mask and shift
++#define MPI_BYTE_MASK 0xff
++#define MPI_BYTE_SHIFT 8
++
++#define MPI_BIT_0_MASK 0x1
++#define MPI_BIT_7_SHIFT 7
++
++
++
++// Multiple precision integer definition
++#define MPI_VALUE_BYTE_NUM_MAX 10 ///< Maximum MPI value byte number
++#define MPI_VALUE_BIT_NUM_MAX (MPI_VALUE_BYTE_NUM_MAX * MPI_BYTE_BIT_NUM) ///< Maximum MPI value bit number
++
++/// Multiple precision integer structure
++typedef struct
++{
++ unsigned long BitNum;
++ unsigned char Value[MPI_VALUE_BYTE_NUM_MAX];
++}
++MPI;
++
++
++
++/// MPI yes/no status
++enum MPI_YES_NO_STATUS
++{
++ MPI_NO, ///< No
++ MPI_YES, ///< Yes
++};
++
++
++
++// Logarithm with base 2
++#define MPI_LOG_MIDDLE_RESULT_FRAC_BIT_NUM (MPI_VALUE_BIT_NUM_MAX / 2 - 2)
++
++
++
++
++
++// MPI access
++void
++MpiSetValue(
++ MPI *pMpiVar,
++ long Value
++ );
++
++void
++MpiGetValue(
++ MPI MpiVar,
++ long *pValue
++ );
++
++void
++MpiSetBit(
++ MPI *pMpiVar,
++ unsigned long BitPosition,
++ unsigned char BitValue
++ );
++
++void
++MpiGetBit(
++ MPI MpiVar,
++ unsigned long BitPosition,
++ unsigned char *pBitValue
++ );
++
++void
++MpiGetSignedBit(
++ MPI MpiVar,
++ unsigned char *pSignedBit
++ );
++
++
++
++// MPI operator
++void
++MpiAssign(
++ MPI *pResult,
++ MPI Operand
++ );
++
++void
++MpiUnaryMinus(
++ MPI *pResult,
++ MPI Operand
++ );
++
++void
++MpiAdd(
++ MPI *pSum,
++ MPI Augend,
++ MPI Addend
++ );
++
++void
++MpiSub(
++ MPI *pDifference,
++ MPI Minuend,
++ MPI Subtrahend
++ );
++
++void
++MpiMul(
++ MPI *pProduct,
++ MPI Multiplicand,
++ MPI Multiplicator
++ );
++
++void
++MpiDiv(
++ MPI *pQuotient,
++ MPI *pRemainder,
++ MPI Dividend,
++ MPI Divisor
++ );
++
++void
++MpiRightShift(
++ MPI *pResult,
++ MPI Operand,
++ unsigned long ShiftBitNum
++ );
++
++void
++MpiLeftShift(
++ MPI *pResult,
++ MPI Operand,
++ unsigned long ShiftBitNum
++ );
++
++int
++MpiEqualTo(
++ MPI MpiLeft,
++ MPI MpiRight
++ );
++
++int
++MpiGreaterThan(
++ MPI MpiLeft,
++ MPI MpiRight
++ );
++
++int
++MpiLessThan(
++ MPI MpiLeft,
++ MPI MpiRight
++ );
++
++void
++MpiMinimizeBitNum(
++ MPI *pMpiVar
++ );
++
++
++
++// MPI special function
++void
++MpiLog2(
++ MPI *pResult,
++ MPI MpiVar,
++ unsigned long ResultFracBitNum
++ );
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_fc2580.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_fc2580.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,387 @@
++/**
++
++@file
++
++@brief RTL2832 FC2580 NIM module definition
++
++One can manipulate RTL2832 FC2580 NIM through RTL2832 FC2580 NIM module.
++RTL2832 FC2580 NIM module is derived from DVB-T NIM module.
++
++*/
++
++
++#include "nim_rtl2832_fc2580.h"
++
++
++
++
++
++/**
++
++@brief RTL2832 FC2580 NIM module builder
++
++Use BuildRtl2832Fc2580Module() to build RTL2832 FC2580 NIM module, set all module function pointers with the
++corresponding functions, and initialize module private variables.
++
++
++@param [in] ppNim Pointer to RTL2832 FC2580 NIM module pointer
++@param [in] pDvbtNimModuleMemory Pointer to an allocated DVB-T NIM module memory
++@param [in] I2cReadingByteNumMax Maximum I2C reading byte number for basic I2C reading function
++@param [in] I2cWritingByteNumMax Maximum I2C writing byte number for basic I2C writing function
++@param [in] I2cRead Basic I2C reading function pointer
++@param [in] I2cWrite Basic I2C writing function pointer
++@param [in] WaitMs Basic waiting function pointer
++@param [in] pRtl2832ExtraModuleMemory Pointer to an allocated RTL2832 extra module memory
++@param [in] DemodDeviceAddr RTL2832 I2C device address
++@param [in] DemodCrystalFreqHz RTL2832 crystal frequency in Hz
++@param [in] DemodAppMode RTL2832 application mode for setting
++@param [in] DemodTsInterfaceMode RTL2832 TS interface mode for setting
++@param [in] pFc2580ExtraModuleMemory Pointer to an allocated FC2580 extra module memory
++@param [in] TunerDeviceAddr FC2580 I2C device address
++@param [in] TunerAgcMode FC2580 AGC mode
++
++
++@note
++ -# One should call BuildRtl2832Fc2580Module() to build RTL2832 FC2580 NIM module before using it.
++
++*/
++void
++BuildRtl2832Fc2580Module(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long DemodUpdateFuncRefPeriodMs,
++ int DemodIsFunc1Enabled,
++
++ FC2580_EXTRA_MODULE *pFc2580ExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr,
++ unsigned long TunerCrystalFreqHz,
++ int TunerAgcMode
++ )
++{
++ DVBT_NIM_MODULE *pNim;
++
++
++
++ // Set NIM module pointer with NIM module memory.
++ *ppNim = pDvbtNimModuleMemory;
++
++ // Get NIM module.
++ pNim = *ppNim;
++
++ // Set I2C bridge module pointer with I2C bridge module memory.
++ pNim->pI2cBridge = &pNim->I2cBridgeModuleMemory;
++
++ // Set NIM extra module pointer.
++ pNim->pExtra = INVALID_POINTER_VALUE;
++
++
++ // Set NIM type.
++ pNim->NimType = DVBT_NIM_RTL2832_FC2580;
++
++
++ // Build base interface module.
++ BuildBaseInterface(
++ &pNim->pBaseInterface,
++ &pNim->BaseInterfaceModuleMemory,
++ I2cReadingByteNumMax,
++ I2cWritingByteNumMax,
++ I2cRead,
++ I2cWrite,
++ WaitMs
++ );
++
++ // Build RTL2832 demod module.
++ BuildRtl2832Module(
++ &pNim->pDemod,
++ &pNim->DvbtDemodModuleMemory,
++ pRtl2832ExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ DemodDeviceAddr,
++ DemodCrystalFreqHz,
++ DemodAppMode,
++ DemodUpdateFuncRefPeriodMs,
++ DemodIsFunc1Enabled
++ );
++
++ // Build FC2580 tuner module.
++ BuildFc2580Module(
++ &pNim->pTuner,
++ &pNim->TunerModuleMemory,
++ pFc2580ExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ TunerDeviceAddr,
++ TunerCrystalFreqHz,
++ TunerAgcMode
++ );
++
++
++ // Set NIM module variables.
++ pNim->DemodTsInterfaceMode = DemodTsInterfaceMode;
++
++
++ // Set NIM module function pointers with default functions.
++ pNim->GetNimType = dvbt_nim_default_GetNimType;
++ pNim->GetParameters = dvbt_nim_default_GetParameters;
++ pNim->IsSignalPresent = dvbt_nim_default_IsSignalPresent;
++ pNim->IsSignalLocked = dvbt_nim_default_IsSignalLocked;
++ pNim->GetSignalStrength = dvbt_nim_default_GetSignalStrength;
++ pNim->GetSignalQuality = dvbt_nim_default_GetSignalQuality;
++ pNim->GetBer = dvbt_nim_default_GetBer;
++ pNim->GetSnrDb = dvbt_nim_default_GetSnrDb;
++ pNim->GetTrOffsetPpm = dvbt_nim_default_GetTrOffsetPpm;
++ pNim->GetCrOffsetHz = dvbt_nim_default_GetCrOffsetHz;
++ pNim->GetTpsInfo = dvbt_nim_default_GetTpsInfo;
++ pNim->UpdateFunction = dvbt_nim_default_UpdateFunction;
++
++ // Set NIM module function pointers with particular functions.
++ pNim->Initialize = rtl2832_fc2580_Initialize;
++ pNim->SetParameters = rtl2832_fc2580_SetParameters;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_INITIALIZE
++
++*/
++int
++rtl2832_fc2580_Initialize(
++ DVBT_NIM_MODULE *pNim
++ )
++{
++ typedef struct
++ {
++ int RegBitName;
++ unsigned long Value;
++ }
++ REG_VALUE_ENTRY;
++
++
++ static const REG_VALUE_ENTRY AdditionalInitRegValueTable[RTL2832_FC2580_ADDITIONAL_INIT_REG_TABLE_LEN] =
++ {
++ // RegBitName, Value
++ {DVBT_DAGC_TRG_VAL, 0x39 },
++ {DVBT_AGC_TARG_VAL_0, 0x0 },
++ {DVBT_AGC_TARG_VAL_8_1, 0x5a },
++ {DVBT_AAGC_LOOP_GAIN, 0x16 },
++ {DVBT_LOOP_GAIN2_3_0, 0x6 },
++ {DVBT_LOOP_GAIN2_4, 0x1 },
++ {DVBT_LOOP_GAIN3, 0x16 },
++ {DVBT_VTOP1, 0x35 },
++ {DVBT_VTOP2, 0x21 },
++ {DVBT_VTOP3, 0x21 },
++ {DVBT_KRF1, 0x0 },
++ {DVBT_KRF2, 0x40 },
++ {DVBT_KRF3, 0x10 },
++ {DVBT_KRF4, 0x10 },
++ {DVBT_IF_AGC_MIN, 0x80 },
++ {DVBT_IF_AGC_MAX, 0x7f },
++ {DVBT_RF_AGC_MIN, 0x9c },
++ {DVBT_RF_AGC_MAX, 0x7f },
++ {DVBT_POLAR_RF_AGC, 0x0 },
++ {DVBT_POLAR_IF_AGC, 0x0 },
++ {DVBT_AD7_SETTING, 0xe9f4 },
++ };
++
++
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ int i;
++
++ int RegBitName;
++ unsigned long Value;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Initialize tuner.
++ if(pTuner->Initialize(pTuner) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Initialize demod.
++ if(pDemod->Initialize(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod IF frequency with 0 Hz.
++ if(pDemod->SetIfFreqHz(pDemod, IF_FREQ_0HZ) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod spectrum mode with SPECTRUM_NORMAL.
++ if(pDemod->SetSpectrumMode(pDemod, SPECTRUM_NORMAL) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Set demod registers.
++ for(i = 0; i < RTL2832_FC2580_ADDITIONAL_INIT_REG_TABLE_LEN; i++)
++ {
++ // Get register bit name and its value.
++ RegBitName = AdditionalInitRegValueTable[i].RegBitName;
++ Value = AdditionalInitRegValueTable[i].Value;
++
++ // Set demod registers
++ if(pDemod->SetRegBitsWithPage(pDemod, RegBitName, Value) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++ }
++
++
++ // Set TS interface according to TS interface mode.
++ switch(pNim->DemodTsInterfaceMode)
++ {
++ case TS_INTERFACE_PARALLEL:
++
++ // Set demod TS interface with parallel mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++
++
++ default:
++ case TS_INTERFACE_SERIAL:
++
++ // Set demod TS interface with serial mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_SET_PARAMETERS
++
++*/
++int
++rtl2832_fc2580_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ )
++{
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ FC2580_EXTRA_MODULE *pTunerExtra;
++ int TunerBandwidthMode;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++ // Get tuner extra module.
++ pTunerExtra = (FC2580_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Set tuner RF frequency in Hz.
++ if(pTuner->SetRfFreqHz(pTuner, RfFreqHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Determine TunerBandwidthMode according to bandwidth mode.
++ switch(BandwidthMode)
++ {
++ default:
++ case DVBT_BANDWIDTH_6MHZ: TunerBandwidthMode = FC2580_BANDWIDTH_6000000HZ; break;
++ case DVBT_BANDWIDTH_7MHZ: TunerBandwidthMode = FC2580_BANDWIDTH_7000000HZ; break;
++ case DVBT_BANDWIDTH_8MHZ: TunerBandwidthMode = FC2580_BANDWIDTH_8000000HZ; break;
++ }
++
++ // Set tuner bandwidth mode with TunerBandwidthMode.
++ if(pTunerExtra->SetBandwidthMode(pTuner, TunerBandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Set demod bandwidth mode.
++ if(pDemod->SetBandwidthMode(pDemod, BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod particular registers.
++ if(pDemod->ResetFunction(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_fc2580.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_fc2580.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,146 @@
++#ifndef __NIM_RTL2832_FC2580
++#define __NIM_RTL2832_FC2580
++
++/**
++
++@file
++
++@brief RTL2832 FC2580 NIM module declaration
++
++One can manipulate RTL2832 FC2580 NIM through RTL2832 FC2580 NIM module.
++RTL2832 FC2580 NIM module is derived from DVB-T NIM module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the NIM example in dvbt_nim_base.h except the listed lines.
++
++
++
++#include "nim_rtl2832_fc2580.h"
++
++
++...
++
++
++
++int main(void)
++{
++ DVBT_NIM_MODULE *pNim;
++ DVBT_NIM_MODULE DvbtNimModuleMemory;
++ RTL2832_EXTRA_MODULE Rtl2832ExtraModuleMemory;
++ FC2580_EXTRA_MODULE Fc2580ExtraModuleMemory;
++
++ ...
++
++
++
++ // Build RTL2832 FC2580 NIM module.
++ BuildRtl2832Fc2580Module(
++ &pNim,
++ &DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ CustomI2cRead, // Employ CustomI2cRead() as basic I2C reading function.
++ CustomI2cWrite, // Employ CustomI2cWrite() as basic I2C writing function.
++ CustomWaitMs, // Employ CustomWaitMs() as basic waiting function.
++
++ &Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ 0x20, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_STB, // The RTL2832 application mode is STB mode.
++ 50, // The RTL2832 update function reference period is 50 millisecond
++ ON, // The RTL2832 Function 1 enabling status is on.
++
++ &Fc2580ExtraModuleMemory, // Employ FC2580 extra module for FC2580 module.
++ 0xac, // The FC2580 I2C device address is 0xac in 8-bit format.
++ CRYSTAL_FREQ_16384000HZ, // The FC2580 crystal frequency is 16.384 MHz.
++ FC2580_AGC_EXTERNAL // The FC2580 AGC mode is external AGC mode.
++ );
++
++
++
++ // See the example for other NIM functions in dvbt_nim_base.h
++
++ ...
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "demod_rtl2832.h"
++#include "tuner_fc2580.h"
++#include "dvbt_nim_base.h"
++
++
++
++
++
++// Definitions
++#define RTL2832_FC2580_ADDITIONAL_INIT_REG_TABLE_LEN 21
++
++
++
++
++
++// Builder
++void
++BuildRtl2832Fc2580Module(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long DemodUpdateFuncRefPeriodMs,
++ int DemodIsFunc1Enabled,
++
++ FC2580_EXTRA_MODULE *pFc2580ExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr,
++ unsigned long TunerCrystalFreqHz,
++ int TunerAgcMode
++ );
++
++
++
++
++
++// RTL2832 FC2580 NIM manipulaing functions
++int
++rtl2832_fc2580_Initialize(
++ DVBT_NIM_MODULE *pNim
++ );
++
++int
++rtl2832_fc2580_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ );
++
++
++
++
++
++
++
++#endif
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mt2266.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mt2266.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,1108 @@
++/**
++
++@file
++
++@brief RTL2832 MT2266 NIM module definition
++
++One can manipulate RTL2832 MT2266 NIM through RTL2832 MT2266 NIM module.
++RTL2832 MT2266 NIM module is derived from DVB-T NIM module.
++
++*/
++
++
++#include "nim_rtl2832_mt2266.h"
++
++
++
++
++
++/**
++
++@brief RTL2832 MT2266 NIM module builder
++
++Use BuildRtl2832Mt2266Module() to build RTL2832 MT2266 NIM module, set all module function pointers with the
++corresponding functions, and initialize module private variables.
++
++
++@param [in] ppNim Pointer to RTL2832 MT2266 NIM module pointer
++@param [in] pDvbtNimModuleMemory Pointer to an allocated DVB-T NIM module memory
++@param [in] I2cReadingByteNumMax Maximum I2C reading byte number for basic I2C reading function
++@param [in] I2cWritingByteNumMax Maximum I2C writing byte number for basic I2C writing function
++@param [in] I2cRead Basic I2C reading function pointer
++@param [in] I2cWrite Basic I2C writing function pointer
++@param [in] WaitMs Basic waiting function pointer
++@param [in] pRtl2832ExtraModuleMemory Pointer to an allocated RTL2832 extra module memory
++@param [in] DemodDeviceAddr RTL2832 I2C device address
++@param [in] DemodCrystalFreqHz RTL2832 crystal frequency in Hz
++@param [in] DemodAppMode RTL2832 application mode for setting
++@param [in] DemodTsInterfaceMode RTL2832 TS interface mode for setting
++@param [in] pMt2266ExtraModuleMemory Pointer to an allocated MT2266 extra module memory
++@param [in] TunerDeviceAddr MT2266 I2C device address
++
++
++@note
++ -# One should call BuildRtl2832Mt2266Module() to build RTL2832 MT2266 NIM module before using it.
++
++*/
++void
++BuildRtl2832Mt2266Module(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++ RTL2832_MT2266_EXTRA_MODULE *pRtl2832Mt2266ExtraModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long DemodUpdateFuncRefPeriodMs,
++ int DemodIsFunc1Enabled,
++
++ MT2266_EXTRA_MODULE *pMt2266ExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr
++ )
++{
++ DVBT_NIM_MODULE *pNim;
++ RTL2832_MT2266_EXTRA_MODULE *pExtra;
++
++
++
++ // Set NIM module pointer with NIM module memory.
++ *ppNim = pDvbtNimModuleMemory;
++
++ // Get NIM module.
++ pNim = *ppNim;
++
++ // Set I2C bridge module pointer with I2C bridge module memory.
++ pNim->pI2cBridge = &pNim->I2cBridgeModuleMemory;
++
++ // Set NIM extra module pointer.
++ pNim->pExtra = pRtl2832Mt2266ExtraModuleMemory;
++
++ // Get NIM extra module.
++ pExtra = (RTL2832_MT2266_EXTRA_MODULE *)pNim->pExtra;
++
++
++ // Set NIM type.
++ pNim->NimType = DVBT_NIM_RTL2832_MT2266;
++
++
++ // Build base interface module.
++ BuildBaseInterface(
++ &pNim->pBaseInterface,
++ &pNim->BaseInterfaceModuleMemory,
++ I2cReadingByteNumMax,
++ I2cWritingByteNumMax,
++ I2cRead,
++ I2cWrite,
++ WaitMs
++ );
++
++ // Build RTL2832 demod module.
++ BuildRtl2832Module(
++ &pNim->pDemod,
++ &pNim->DvbtDemodModuleMemory,
++ pRtl2832ExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ DemodDeviceAddr,
++ DemodCrystalFreqHz,
++ DemodAppMode,
++ DemodUpdateFuncRefPeriodMs,
++ DemodIsFunc1Enabled
++ );
++
++ // Build MT2266 tuner module.
++ BuildMt2266Module(
++ &pNim->pTuner,
++ &pNim->TunerModuleMemory,
++ pMt2266ExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ TunerDeviceAddr
++ );
++
++
++ // Set NIM module variables.
++ pNim->DemodTsInterfaceMode = DemodTsInterfaceMode;
++
++
++ // Set NIM module function pointers with default functions.
++ pNim->GetNimType = dvbt_nim_default_GetNimType;
++ pNim->GetParameters = dvbt_nim_default_GetParameters;
++ pNim->IsSignalPresent = dvbt_nim_default_IsSignalPresent;
++ pNim->IsSignalLocked = dvbt_nim_default_IsSignalLocked;
++ pNim->GetSignalStrength = dvbt_nim_default_GetSignalStrength;
++ pNim->GetSignalQuality = dvbt_nim_default_GetSignalQuality;
++ pNim->GetBer = dvbt_nim_default_GetBer;
++ pNim->GetSnrDb = dvbt_nim_default_GetSnrDb;
++ pNim->GetTrOffsetPpm = dvbt_nim_default_GetTrOffsetPpm;
++ pNim->GetCrOffsetHz = dvbt_nim_default_GetCrOffsetHz;
++ pNim->GetTpsInfo = dvbt_nim_default_GetTpsInfo;
++
++ // Set NIM module function pointers with particular functions.
++ pNim->Initialize = rtl2832_mt2266_Initialize;
++ pNim->SetParameters = rtl2832_mt2266_SetParameters;
++ pNim->UpdateFunction = rtl2832_mt2266_UpdateFunction;
++
++
++ // Initialize NIM extra module variables.
++ pExtra->LnaConfig = 0xff;
++ pExtra->UhfSens = 0xff;
++ pExtra->AgcCurrentState = 0xff;
++ pExtra->LnaGainOld = 0xffffffff;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_INITIALIZE
++
++*/
++int
++rtl2832_mt2266_Initialize(
++ DVBT_NIM_MODULE *pNim
++ )
++{
++ typedef struct
++ {
++ int RegBitName;
++ unsigned long Value;
++ }
++ REG_VALUE_ENTRY;
++
++
++ static const REG_VALUE_ENTRY AdditionalInitRegValueTable[RTL2832_MT2266_ADDITIONAL_INIT_REG_TABLE_LEN] =
++ {
++ // RegBitName, Value
++ {DVBT_DAGC_TRG_VAL, 0x39 },
++ {DVBT_AGC_TARG_VAL_0, 0x0 },
++ {DVBT_AGC_TARG_VAL_8_1, 0x5a },
++ {DVBT_AAGC_LOOP_GAIN, 0x16 },
++ {DVBT_LOOP_GAIN2_3_0, 0x6 },
++ {DVBT_LOOP_GAIN2_4, 0x1 },
++ {DVBT_LOOP_GAIN3, 0x16 },
++ {DVBT_VTOP1, 0x35 },
++ {DVBT_VTOP2, 0x21 },
++ {DVBT_VTOP3, 0x21 },
++ {DVBT_KRF1, 0x0 },
++ {DVBT_KRF2, 0x40 },
++ {DVBT_KRF3, 0x10 },
++ {DVBT_KRF4, 0x10 },
++ {DVBT_IF_AGC_MIN, 0xc0 }, // Note: The IF_AGC_MIN value will be set again by demod_pdcontrol_reset().
++ {DVBT_IF_AGC_MAX, 0x7f },
++ {DVBT_RF_AGC_MIN, 0x9c },
++ {DVBT_RF_AGC_MAX, 0x7f },
++ {DVBT_POLAR_RF_AGC, 0x1 },
++ {DVBT_POLAR_IF_AGC, 0x1 },
++ {DVBT_AD7_SETTING, 0xe9f4 },
++ };
++
++
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ int i;
++
++ int RegBitName;
++ unsigned long Value;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Initialize tuner.
++ if(pTuner->Initialize(pTuner) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Initialize demod.
++ if(pDemod->Initialize(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod IF frequency with 0 Hz.
++ if(pDemod->SetIfFreqHz(pDemod, IF_FREQ_0HZ) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod spectrum mode with SPECTRUM_NORMAL.
++ if(pDemod->SetSpectrumMode(pDemod, SPECTRUM_NORMAL) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Set demod registers.
++ for(i = 0; i < RTL2832_MT2266_ADDITIONAL_INIT_REG_TABLE_LEN; i++)
++ {
++ // Get register bit name and its value.
++ RegBitName = AdditionalInitRegValueTable[i].RegBitName;
++ Value = AdditionalInitRegValueTable[i].Value;
++
++ // Set demod registers
++ if(pDemod->SetRegBitsWithPage(pDemod, RegBitName, Value) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++ }
++
++
++ // Set TS interface according to TS interface mode.
++ switch(pNim->DemodTsInterfaceMode)
++ {
++ case TS_INTERFACE_PARALLEL:
++
++ // Set demod TS interface with parallel mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++
++
++ default:
++ case TS_INTERFACE_SERIAL:
++
++ // Set demod TS interface with serial mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_SET_PARAMETERS
++
++*/
++int
++rtl2832_mt2266_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ )
++{
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ MT2266_EXTRA_MODULE *pMt2266Extra;
++ Handle_t Mt2266Handle;
++ unsigned long BandwidthHz;
++
++ RTL2832_MT2266_EXTRA_MODULE *pRtl2832Mt2266Extra;
++
++ UData_t Status;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++ // Get tuner extra module.
++ pMt2266Extra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get tuner handle.
++ Mt2266Handle = pMt2266Extra->DeviceHandle;
++
++ // Get NIM extra module.
++ pRtl2832Mt2266Extra = (RTL2832_MT2266_EXTRA_MODULE *)pNim->pExtra;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Set tuner RF frequency in Hz.
++ if(pTuner->SetRfFreqHz(pTuner, RfFreqHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Determine BandwidthHz according to bandwidth mode.
++ switch(BandwidthMode)
++ {
++ default:
++ case DVBT_BANDWIDTH_6MHZ: BandwidthHz = MT2266_BANDWIDTH_6MHZ; break;
++ case DVBT_BANDWIDTH_7MHZ: BandwidthHz = MT2266_BANDWIDTH_7MHZ; break;
++ case DVBT_BANDWIDTH_8MHZ: BandwidthHz = MT2266_BANDWIDTH_8MHZ; break;
++ }
++
++ // Set tuner bandwidth in Hz with BandwidthHz.
++ if(pMt2266Extra->SetBandwidthHz(pTuner, BandwidthHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Set demod bandwidth mode.
++ if(pDemod->SetBandwidthMode(pDemod, BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod particular registers.
++ if(pDemod->ResetFunction(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Reset MT2266 update procedure.
++ Status = demod_pdcontrol_reset(pDemod, Mt2266Handle, &pRtl2832Mt2266Extra->AgcCurrentState);
++
++ if(MT_IS_ERROR(Status))
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_UPDATE_FUNCTION
++
++*/
++int
++rtl2832_mt2266_UpdateFunction(
++ DVBT_NIM_MODULE *pNim
++ )
++{
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++ MT2266_EXTRA_MODULE *pMt2266Extra;
++ RTL2832_MT2266_EXTRA_MODULE *pRtl2832Mt2266Extra;
++
++ Handle_t Mt2266Handle;
++ UData_t Status;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++ // Get tuner extra module and tuner handle.
++ pMt2266Extra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++ pMt2266Extra->GetHandle(pTuner, &Mt2266Handle);
++
++ // Get NIM extra module.
++ pRtl2832Mt2266Extra = (RTL2832_MT2266_EXTRA_MODULE *)pNim->pExtra;
++
++
++ // Update demod particular registers.
++ if(pDemod->UpdateFunction(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Update demod and tuner register setting.
++ Status = demod_pdcontrol(
++ pDemod,
++ Mt2266Handle,
++ &pRtl2832Mt2266Extra->LnaConfig,
++ &pRtl2832Mt2266Extra->UhfSens,
++ &pRtl2832Mt2266Extra->AgcCurrentState,
++ (u32t *)&pRtl2832Mt2266Extra->LnaGainOld
++ );
++
++ if(MT_IS_ERROR(Status))
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++// The following context is source code provided by Microtune.
++
++
++
++
++
++// Additional definition for mt_control.c
++UData_t
++demod_get_pd(
++ handle_t demod_handle,
++ u16t *pd_value
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ unsigned long RssiR;
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)demod_handle;
++
++ // Get RSSI_R value.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RSSI_R, &RssiR) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ // Set pd_value according to RSSI_R.
++ *pd_value = (u16t)RssiR;
++
++
++ return MT_OK;
++
++
++error_status_get_registers:
++ return MT_COMM_ERR;
++}
++
++
++
++UData_t
++demod_get_agc(
++ handle_t demod_handle,
++ u16t *rf_level,
++ u16t *bb_level
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ int RfAgc;
++ int IfAgc;
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)demod_handle;
++
++ // Get RF and IF AGC value.
++ if(pDemod->GetRfAgc(pDemod, &RfAgc) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ if(pDemod->GetIfAgc(pDemod, &IfAgc) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ // Convert RF and IF AGC value to proper format.
++ *rf_level = (u16t)((RfAgc + (1 << (RTL2832_RF_AGC_REG_BIT_NUM - 1))) *
++ (1 << (MT2266_DEMOD_ASSUMED_AGC_REG_BIT_NUM - RTL2832_RF_AGC_REG_BIT_NUM)));
++
++ *bb_level = (u16t)((IfAgc + (1 << (RTL2832_IF_AGC_REG_BIT_NUM - 1))) *
++ (1 << (MT2266_DEMOD_ASSUMED_AGC_REG_BIT_NUM - RTL2832_IF_AGC_REG_BIT_NUM)));
++
++
++ return MT_OK;
++
++
++error_status_get_registers:
++ return MT_COMM_ERR;
++}
++
++
++
++UData_t
++demod_set_bbagclim(
++ handle_t demod_handle,
++ int on_off_status
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++ unsigned long IfAgcMinBinary;
++ long IfAgcMinInt;
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)demod_handle;
++
++ // Get IF_AGC_MIN binary value.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_IF_AGC_MIN, &IfAgcMinBinary) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ // Convert IF_AGC_MIN binary value to integer.
++ IfAgcMinInt = BinToSignedInt(IfAgcMinBinary, RTL2832_MT2266_IF_AGC_MIN_BIT_NUM);
++
++ // Modify IF_AGC_MIN integer according to on_off_status.
++ switch(on_off_status)
++ {
++ case 1:
++
++ IfAgcMinInt += RTL2832_MT2266_IF_AGC_MIN_INT_STEP;
++
++ if(IfAgcMinInt > RTL2832_MT2266_IF_AGC_MIN_INT_MAX)
++ IfAgcMinInt = RTL2832_MT2266_IF_AGC_MIN_INT_MAX;
++
++ break;
++
++ default:
++ case 0:
++
++ IfAgcMinInt -= RTL2832_MT2266_IF_AGC_MIN_INT_STEP;
++
++ if(IfAgcMinInt < RTL2832_MT2266_IF_AGC_MIN_INT_MIN)
++ IfAgcMinInt = RTL2832_MT2266_IF_AGC_MIN_INT_MIN;
++
++ break;
++ }
++
++ // Convert modified IF_AGC_MIN integer to binary value.
++ IfAgcMinBinary = SignedIntToBin(IfAgcMinInt, RTL2832_MT2266_IF_AGC_MIN_BIT_NUM);
++
++ // Set IF_AGC_MIN with modified binary value.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IF_AGC_MIN, IfAgcMinBinary) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ return MT_OK;
++
++
++error_status_set_registers:
++error_status_get_registers:
++ return MT_COMM_ERR;
++}
++
++
++
++
++
++UData_t
++tuner_set_bw_normal(
++ handle_t tuner_handle,
++ handle_t demod_handle
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++ int DemodBandwidthMode;
++ unsigned int TunerBandwidthHz;
++ unsigned int TargetTunerBandwidthHz;
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)demod_handle;
++
++ // Get demod bandwidth mode.
++ if(pDemod->GetBandwidthMode(pDemod, &DemodBandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Determine tuner target bandwidth.
++ switch(DemodBandwidthMode)
++ {
++ case DVBT_BANDWIDTH_6MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_6MHZ; break;
++ case DVBT_BANDWIDTH_7MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_7MHZ; break;
++ default:
++ case DVBT_BANDWIDTH_8MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_8MHZ; break;
++ }
++
++ // Get tuner bandwidth.
++ if(MT_IS_ERROR(MT2266_GetParam(tuner_handle, MT2266_OUTPUT_BW, &TunerBandwidthHz)))
++ goto error_status_get_tuner_bandwidth;
++
++ // Set tuner bandwidth with normal setting according to demod bandwidth mode.
++ if(TunerBandwidthHz != TargetTunerBandwidthHz)
++ {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle, MT2266_OUTPUT_BW, TargetTunerBandwidthHz)))
++ goto error_status_set_tuner_bandwidth;
++ }
++
++
++ return MT_OK;
++
++
++error_status_set_tuner_bandwidth:
++error_status_get_tuner_bandwidth:
++error_status_execute_function:
++ return MT_COMM_ERR;
++}
++
++
++
++
++
++UData_t
++tuner_set_bw_narrow(
++ handle_t tuner_handle,
++ handle_t demod_handle
++ )
++{
++ DVBT_DEMOD_MODULE *pDemod;
++
++ int DemodBandwidthMode;
++ unsigned long AciDetInd;
++ unsigned int TunerBandwidthHz;
++ unsigned int TargetTunerBandwidthHz;
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)demod_handle;
++
++ // Get demod bandwidth mode.
++ if(pDemod->GetBandwidthMode(pDemod, &DemodBandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Get demod ACI_DET_IND.
++ if(pDemod->GetRegBitsWithPage(pDemod, DVBT_ACI_DET_IND, &AciDetInd) != FUNCTION_SUCCESS)
++ goto error_status_get_registers;
++
++ // Determine tuner target bandwidth according to ACI_DET_IND.
++ if(AciDetInd == 0x1)
++ {
++ // Choose narrow target bandwidth.
++ switch(DemodBandwidthMode)
++ {
++ case DVBT_BANDWIDTH_6MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_5MHZ; break;
++ case DVBT_BANDWIDTH_7MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_6MHZ; break;
++ default:
++ case DVBT_BANDWIDTH_8MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_7MHZ; break;
++ }
++ }
++ else
++ {
++ // Choose normal target bandwidth.
++ switch(DemodBandwidthMode)
++ {
++ case DVBT_BANDWIDTH_6MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_6MHZ; break;
++ case DVBT_BANDWIDTH_7MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_7MHZ; break;
++ default:
++ case DVBT_BANDWIDTH_8MHZ: TargetTunerBandwidthHz = MT2266_BANDWIDTH_8MHZ; break;
++ }
++ }
++
++ // Get tuner bandwidth.
++ if(MT_IS_ERROR(MT2266_GetParam(tuner_handle, MT2266_OUTPUT_BW, &TunerBandwidthHz)))
++ goto error_status_get_tuner_bandwidth;
++
++ // Set tuner bandwidth with normal setting according to demod bandwidth mode.
++ if(TunerBandwidthHz != TargetTunerBandwidthHz)
++ {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle, MT2266_OUTPUT_BW, TargetTunerBandwidthHz)))
++ goto error_status_set_tuner_bandwidth;
++ }
++
++
++ return MT_OK;
++
++
++error_status_set_tuner_bandwidth:
++error_status_get_tuner_bandwidth:
++error_status_get_registers:
++error_status_execute_function:
++ return MT_COMM_ERR;
++}
++
++
++
++
++
++// Microtune source code - mt_control.c
++
++
++
++UData_t demod_pdcontrol_reset(handle_t demod_handle, handle_t tuner_handle, u8t *agc_current_state) {
++
++ DVBT_DEMOD_MODULE *pDemod;
++ unsigned long BinaryValue;
++
++
++ // Get demod module.
++ pDemod = (DVBT_DEMOD_MODULE *)demod_handle;
++
++ // Reset AGC current state.
++ *agc_current_state = AGC_STATE_START;
++
++ // Calculate RTL2832_MT2266_IF_AGC_MIN_INT_MIN binary value.
++ BinaryValue = SignedIntToBin(RTL2832_MT2266_IF_AGC_MIN_INT_MIN, RTL2832_MT2266_IF_AGC_MIN_BIT_NUM);
++
++ // Set IF_AGC_MIN with binary value.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IF_AGC_MIN, BinaryValue) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Set tuner bandwidth with normal setting.
++ if(MT_IS_ERROR(tuner_set_bw_normal(tuner_handle, demod_handle)))
++ goto error_status_set_tuner_bandwidth;
++
++
++ return MT_OK;
++
++
++error_status_set_tuner_bandwidth:
++error_status_set_registers:
++ return MT_COMM_ERR;
++}
++
++
++
++UData_t demod_pdcontrol(handle_t demod_handle, handle_t tuner_handle, u8t* lna_config, u8t* uhf_sens,
++ u8t *agc_current_state, u32t *lna_gain_old) {
++
++ u16t pd_value;
++ u16t rf_level, bb_level;
++ u32t lna_gain;
++ u8t zin=0;
++
++// u8t temp[2];
++// u8t agc_bb_min;
++// demod_data_t* local_data;
++
++
++ u8t band=1; /* band=0: vhf, band=1: uhf low, band=2: uhf high */
++ u32t freq;
++
++ // AGC threshold values
++ u16t sens_on[] = {11479, 11479, 32763};
++ u16t sens_off[] = {36867, 36867, 44767};
++ u16t lin_off[] = {23619, 23619, 23619};
++ u16t lin_on[] = {38355, 38355, 38355};
++ u16t pd_upper[] = {85, 85, 85};
++ u16t pd_lower[] = {74, 74, 74};
++ u8t next_state;
++
++ // demod_data_t* local_data = (demod_data_t*)demod_handle;
++
++ if(MT_IS_ERROR(MT2266_GetParam(tuner_handle, MT2266_INPUT_FREQ, &freq))) goto error_status;
++ if(MT_IS_ERROR(MT2266_GetParam(tuner_handle, MT2266_LNA_GAIN, &lna_gain))) goto error_status;
++ if(MT_IS_ERROR(MT2266_GetReg(tuner_handle,0x1e,&zin))) goto error_status;
++
++ if (freq <= 250000000) band=0;
++ else if (freq < 660000000) band=1;
++ else band=2;
++
++ if(MT_IS_ERROR(demod_get_pd(demod_handle, &pd_value))) goto error_status;
++ if(MT_IS_ERROR(demod_get_agc(demod_handle, &rf_level, &bb_level))) goto error_status;
++
++ rf_level=0xffff-rf_level;
++ bb_level=0xffff-bb_level;
++
++/*
++#ifndef _HOST_DLL
++ uart_write_nr("St:");
++ uart_writedez(agc_current_state[num]);
++
++ uart_write_nr(" PD: ");
++ uart_writehex16(pd_value);
++
++ uart_write_nr(" AGC: ");
++ uart_writehex16(rf_level);
++ uart_writehex16(bb_level);
++#endif
++*/
++
++ next_state = *agc_current_state;
++
++ switch (*agc_current_state) {
++
++ case AGC_STATE_START : {
++ if ((int)lna_gain < LNAGAIN_MIN)
++ next_state=AGC_STATE_LNAGAIN_BELOW_MIN;
++ else if (lna_gain > LNAGAIN_MAX)
++ next_state=AGC_STATE_LNAGAIN_ABOVE_MAX;
++ else
++ next_state=AGC_STATE_NORMAL;
++ break;
++ }
++
++ case AGC_STATE_LNAGAIN_BELOW_MIN : {
++ if ((int)lna_gain < LNAGAIN_MIN )
++ next_state=AGC_STATE_LNAGAIN_BELOW_MIN;
++ else next_state=AGC_STATE_NORMAL;
++
++ break;
++ }
++
++ case AGC_STATE_LNAGAIN_ABOVE_MAX : {
++ if (lna_gain > LNAGAIN_MAX )
++ next_state=AGC_STATE_LNAGAIN_ABOVE_MAX;
++ else next_state=AGC_STATE_NORMAL;
++ break;
++ }
++
++ case AGC_STATE_NORMAL : {
++ if (rf_level > lin_on[band] ) {
++ *lna_gain_old = lna_gain;
++ next_state = AGC_STATE_MAS_GRANDE_SIGNAL;
++ }
++ else if (pd_value > pd_upper[band]) {
++ next_state = AGC_STATE_GRANDE_INTERFERER;
++ }
++ else if ( (pd_value < pd_lower[band]) && (lna_gain < LNAGAIN_MAX) ) {
++ next_state = AGC_STATE_NO_INTERFERER;
++ }
++ else if ( bb_level < sens_on[band]) {
++ next_state = AGC_STATE_SMALL_SIGNAL;
++ }
++ break;
++ }
++
++ case AGC_STATE_NO_INTERFERER : {
++ if (pd_value > pd_lower[band] )
++ next_state = AGC_STATE_MEDIUM_INTERFERER;
++ else if (pd_value < pd_lower[band] )
++ next_state = AGC_STATE_NORMAL;
++ else if ( lna_gain == LNAGAIN_MAX )
++ next_state = AGC_STATE_NORMAL;
++ break;
++ }
++
++ case AGC_STATE_MEDIUM_INTERFERER : {
++ if (pd_value > pd_upper[band] )
++ next_state = AGC_STATE_GRANDE_INTERFERER;
++ else if (pd_value < pd_lower[band] )
++ next_state = AGC_STATE_NO_INTERFERER;
++ break;
++ }
++
++
++ case AGC_STATE_GRANDE_INTERFERER : {
++ if (pd_value < pd_upper[band] )
++ next_state = AGC_STATE_MEDIUM_INTERFERER;
++ break;
++ }
++
++ case AGC_STATE_MAS_GRANDE_SIGNAL : {
++ if (rf_level < lin_on[band])
++ next_state = AGC_STATE_GRANDE_SIGNAL;
++ else if (pd_value > pd_upper[band]) {
++ next_state = AGC_STATE_GRANDE_INTERFERER;
++ }
++ break;
++ }
++
++ case AGC_STATE_MEDIUM_SIGNAL : {
++ if (rf_level > lin_off[band])
++ next_state = AGC_STATE_GRANDE_SIGNAL;
++ else if (lna_gain >= *lna_gain_old)
++ next_state = AGC_STATE_NORMAL;
++ else if (pd_value > pd_upper[band])
++ next_state = AGC_STATE_GRANDE_INTERFERER;
++ break;
++ }
++
++ case AGC_STATE_GRANDE_SIGNAL : {
++ if (rf_level > lin_on[band])
++ next_state = AGC_STATE_MAS_GRANDE_SIGNAL;
++ else if (rf_level < lin_off[band])
++ next_state = AGC_STATE_MEDIUM_SIGNAL;
++ else if (pd_value > pd_upper[band])
++ next_state = AGC_STATE_GRANDE_INTERFERER;
++ break;
++ }
++
++ case AGC_STATE_SMALL_SIGNAL : {
++ if (pd_value > pd_upper[band] )
++ next_state = AGC_STATE_GRANDE_INTERFERER;
++ else if (bb_level > sens_off[band])
++ next_state = AGC_STATE_NORMAL;
++ else if ( (bb_level < sens_on[band]) && (lna_gain == LNAGAIN_MAX) )
++ next_state = AGC_STATE_MAX_SENSITIVITY;
++ break;
++ }
++
++ case AGC_STATE_MAX_SENSITIVITY : {
++ if (bb_level > sens_off[band])
++ next_state = AGC_STATE_SMALL_SIGNAL;
++ break;
++ }
++
++ }
++
++ *agc_current_state = next_state;
++
++
++ switch (*agc_current_state) {
++
++ case AGC_STATE_LNAGAIN_BELOW_MIN : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_LNA_GAIN_INCR, LNAGAIN_MAX))) goto error_status;
++ break;
++ }
++
++ case AGC_STATE_LNAGAIN_ABOVE_MAX : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_LNA_GAIN_DECR, LNAGAIN_MIN))) goto error_status;
++ break;
++ }
++
++ case AGC_STATE_NORMAL : {
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,0))) goto error_status;
++ if (zin >= 2) {
++ zin -= 2;
++ if(MT_IS_ERROR(MT2266_SetReg(tuner_handle,0x1e,zin))) goto error_status;
++ }
++ break;
++ }
++
++ case AGC_STATE_NO_INTERFERER : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_LNA_GAIN_INCR, LNAGAIN_MAX))) goto error_status;
++ if (zin >= 2) {
++ zin -= 2;
++ if(MT_IS_ERROR(MT2266_SetReg(tuner_handle,0x1e,zin))) goto error_status;
++ }
++
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,0))) goto error_status;
++ break;
++ }
++
++ case AGC_STATE_MEDIUM_INTERFERER : {
++ if (zin >= 2) {
++ zin -= 2;
++ if(MT_IS_ERROR(MT2266_SetReg(tuner_handle,0x1e,zin))) goto error_status;
++ }
++
++ // Additional setting
++ // Set tuner with normal bandwidth.
++ if(MT_IS_ERROR(tuner_set_bw_normal(tuner_handle, demod_handle))) goto error_status;
++
++ break;
++ }
++
++ case AGC_STATE_GRANDE_INTERFERER : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_LNA_GAIN_DECR, LNAGAIN_MIN))) goto error_status;
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,1))) goto error_status;
++
++ // Additional setting
++ // Set tuner with narrow bandwidth.
++ if(MT_IS_ERROR(tuner_set_bw_narrow(tuner_handle, demod_handle))) goto error_status;
++
++ break;
++ }
++
++ case AGC_STATE_MEDIUM_SIGNAL : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_LNA_GAIN_INCR, LNAGAIN_MAX))) goto error_status;
++ if (zin >= 2) {
++ zin -= 2;
++ if(MT_IS_ERROR(MT2266_SetReg(tuner_handle,0x1e,zin))) goto error_status;
++ }
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,0))) goto error_status;
++ break;
++ }
++
++ case AGC_STATE_GRANDE_SIGNAL : {
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,0))) goto error_status;
++ break;
++ }
++
++ case AGC_STATE_MAS_GRANDE_SIGNAL : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_LNA_GAIN_DECR, LNAGAIN_MIN))) goto error_status;
++ if (lna_gain==0) {
++ if (zin <= 64) {
++ zin += 2;
++ if(MT_IS_ERROR(MT2266_SetReg(tuner_handle,0x1e,zin))) goto error_status;
++ }
++ }
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,0))) goto error_status;
++ break;
++ }
++
++ case AGC_STATE_SMALL_SIGNAL : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_LNA_GAIN_INCR, LNAGAIN_MAX))) goto error_status;
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_UHF_NORMAL,1))) goto error_status;
++ if (zin >= 2) {
++ zin -= 2;
++ if(MT_IS_ERROR(MT2266_SetReg(tuner_handle,0x1e,zin))) goto error_status;
++ }
++
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,0))) goto error_status;
++ *uhf_sens=0;
++ break;
++ }
++
++ case AGC_STATE_MAX_SENSITIVITY : {
++ if(MT_IS_ERROR(MT2266_SetParam(tuner_handle,MT2266_UHF_MAXSENS,1))) goto error_status;
++ if (zin >= 2) {
++ zin -= 2;
++ if(MT_IS_ERROR(MT2266_SetReg(tuner_handle,0x1e,zin))) goto error_status;
++ }
++ if(MT_IS_ERROR(demod_set_bbagclim(demod_handle,0))) goto error_status;
++ *uhf_sens=1;
++ break;
++ }
++ }
++
++ if(MT_IS_ERROR(MT2266_GetParam(tuner_handle, MT2266_LNA_GAIN,&lna_gain))) goto error_status;
++
++ *lna_config=(u8t)lna_gain;
++
++/*
++#ifndef _HOST_DLL
++ uart_write_nr(" LNA ");
++ uart_writedez(lna_gain);
++ uart_write_nr(" SENS ");
++ uart_writedez(*uhf_sens);
++ uart_write_nr(" Z ");
++ uart_writedez(zin);
++ uart_write(" ");
++#endif
++*/
++
++
++
++ return MT_OK;
++
++
++error_status:
++ return MT_COMM_ERR;
++}
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mt2266.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mt2266.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,266 @@
++#ifndef __NIM_RTL2832_MT2266
++#define __NIM_RTL2832_MT2266
++
++/**
++
++@file
++
++@brief RTL2832 MT2266 NIM module declaration
++
++One can manipulate RTL2832 MT2266 NIM through RTL2832 MT2266 NIM module.
++RTL2832 MT2266 NIM module is derived from DVB-T NIM module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the NIM example in dvbt_nim_base.h except the listed lines.
++
++
++
++#include "nim_rtl2832_mt2266.h"
++
++
++...
++
++
++
++int main(void)
++{
++ DVBT_NIM_MODULE *pNim;
++ DVBT_NIM_MODULE DvbtNimModuleMemory;
++ RTL2832_EXTRA_MODULE Rtl2832ExtraModuleMemory;
++ MT2266_EXTRA_MODULE Mt2266ExtraModuleMemory;
++
++ ...
++
++
++
++ // Build RTL2832 MT2266 NIM module.
++ BuildRtl2832Mt2266Module(
++ &pNim,
++ &DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ CustomI2cRead, // Employ CustomI2cRead() as basic I2C reading function.
++ CustomI2cWrite, // Employ CustomI2cWrite() as basic I2C writing function.
++ CustomWaitMs, // Employ CustomWaitMs() as basic waiting function.
++
++ &Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ 0x20, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_STB, // The RTL2832 application mode is STB mode.
++ 50, // The RTL2832 update function reference period is 50 millisecond
++ ON, // The RTL2832 Function 1 enabling status is on.
++
++ &Mt2266ExtraModuleMemory, // Employ MT2266 extra module for MT2266 module.
++ 0xc0 // The MT2266 I2C device address is 0xc0 in 8-bit format.
++ );
++
++
++
++ // See the example for other NIM functions in dvbt_nim_base.h
++
++ ...
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "demod_rtl2832.h"
++#include "tuner_mt2266.h"
++#include "dvbt_nim_base.h"
++
++
++
++
++
++// Definitions
++#define RTL2832_MT2266_ADDITIONAL_INIT_REG_TABLE_LEN 21
++
++#define RTL2832_MT2266_IF_AGC_MIN_BIT_NUM 8
++#define RTL2832_MT2266_IF_AGC_MIN_INT_MAX 36
++#define RTL2832_MT2266_IF_AGC_MIN_INT_MIN -64
++#define RTL2832_MT2266_IF_AGC_MIN_INT_STEP 0
++
++
++
++
++
++// RTL2832 MT2266 extra module
++typedef struct RTL2832_MT2266_EXTRA_MODULE_TAG RTL2832_MT2266_EXTRA_MODULE;
++struct RTL2832_MT2266_EXTRA_MODULE_TAG
++{
++ // Extra variables
++ unsigned char LnaConfig;
++ unsigned char UhfSens;
++ unsigned char AgcCurrentState;
++ unsigned long LnaGainOld;
++};
++
++
++
++
++
++// Builder
++void
++BuildRtl2832Mt2266Module(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++ RTL2832_MT2266_EXTRA_MODULE *pRtl2832Mt2266ExtraModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long DemodUpdateFuncRefPeriodMs,
++ int DemodIsFunc1Enabled,
++
++ MT2266_EXTRA_MODULE *pMt2266ExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr
++ );
++
++
++
++
++
++// RTL2832 MT2266 NIM manipulaing functions
++int
++rtl2832_mt2266_Initialize(
++ DVBT_NIM_MODULE *pNim
++ );
++
++int
++rtl2832_mt2266_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ );
++
++int
++rtl2832_mt2266_UpdateFunction(
++ DVBT_NIM_MODULE *pNim
++ );
++
++
++
++
++
++// The following context is source code provided by Microtune.
++
++
++
++
++
++// Additional definition for mt_control.c
++typedef unsigned char u8t;
++typedef unsigned short u16t;
++typedef unsigned long u32t;
++typedef void * handle_t;
++
++#define MT2266_DEMOD_ASSUMED_AGC_REG_BIT_NUM 16
++
++
++
++// Microtune source code - mt_control.c
++
++
++
++/* $Id: mt_control.c,v 1.6 2008/01/02 12:04:39 tune\tpinz Exp $ */
++/*!
++ * \file mt_control.c
++ * \author Thomas Pinz, Microtune GmbH&Co KG
++ * \author Marie-Curie-Str. 1, 85055 Ingolstadt
++ * \author E-Mail: thomas.pinz@microtune.com
++ */
++
++
++#define LNAGAIN_MIN 0
++#define LNAGAIN_MAX 14
++
++#define AGC_STATE_START 0
++#define AGC_STATE_LNAGAIN_BELOW_MIN 1
++#define AGC_STATE_LNAGAIN_ABOVE_MAX 2
++#define AGC_STATE_NORMAL 3
++#define AGC_STATE_NO_INTERFERER 4
++#define AGC_STATE_MEDIUM_INTERFERER 5
++#define AGC_STATE_GRANDE_INTERFERER 6
++#define AGC_STATE_MEDIUM_SIGNAL 7
++#define AGC_STATE_GRANDE_SIGNAL 8
++#define AGC_STATE_MAS_GRANDE_SIGNAL 9
++#define AGC_STATE_MAX_SENSITIVITY 10
++#define AGC_STATE_SMALL_SIGNAL 11
++
++
++UData_t
++demod_get_pd(
++ handle_t demod_handle,
++ u16t *pd_value
++ );
++
++UData_t
++demod_get_agc(
++ handle_t demod_handle,
++ u16t *rf_level,
++ u16t *bb_level
++ );
++
++UData_t
++demod_set_bbagclim(
++ handle_t demod_handle,
++ int on_off_status
++ );
++
++UData_t
++tuner_set_bw_normal(
++ handle_t tuner_handle,
++ handle_t demod_handle
++ );
++
++UData_t
++tuner_set_bw_narrow(
++ handle_t tuner_handle,
++ handle_t demod_handle
++ );
++
++UData_t
++demod_pdcontrol_reset(
++ handle_t demod_handle,
++ handle_t tuner_handle,
++ u8t *agc_current_state
++ );
++
++UData_t
++demod_pdcontrol(
++ handle_t demod_handle,
++ handle_t tuner_handle,
++ u8t* lna_config,
++ u8t* uhf_sens,
++ u8t *agc_current_state,
++ u32t *lna_gain_old
++ );
++
++
++
++
++
++
++
++#endif
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mxl5007t.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mxl5007t.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,397 @@
++/**
++
++@file
++
++@brief RTL2832 MxL5007T NIM module definition
++
++One can manipulate RTL2832 MxL5007T NIM through RTL2832 MxL5007T NIM module.
++RTL2832 MxL5007T NIM module is derived from DVB-T NIM module.
++
++*/
++
++
++#include "nim_rtl2832_mxl5007t.h"
++
++
++
++
++
++/**
++
++@brief RTL2832 MxL5007T NIM module builder
++
++Use BuildRtl2832Mxl5007tModule() to build RTL2832 MxL5007T NIM module, set all module function pointers with the
++corresponding functions, and initialize module private variables.
++
++
++@param [in] ppNim Pointer to RTL2832 MxL5007T NIM module pointer
++@param [in] pDvbtNimModuleMemory Pointer to an allocated DVB-T NIM module memory
++@param [in] I2cReadingByteNumMax Maximum I2C reading byte number for basic I2C reading function
++@param [in] I2cWritingByteNumMax Maximum I2C writing byte number for basic I2C writing function
++@param [in] I2cRead Basic I2C reading function pointer
++@param [in] I2cWrite Basic I2C writing function pointer
++@param [in] WaitMs Basic waiting function pointer
++@param [in] pRtl2832ExtraModuleMemory Pointer to an allocated RTL2832 extra module memory
++@param [in] DemodDeviceAddr RTL2832 I2C device address
++@param [in] DemodCrystalFreqHz RTL2832 crystal frequency in Hz
++@param [in] DemodAppMode RTL2832 application mode for setting
++@param [in] DemodTsInterfaceMode RTL2832 TS interface mode for setting
++@param [in] DemodUpdateFuncRefPeriodMs RTL2832 update function reference period in millisecond for setting
++@param [in] DemodIsFunc1Enabled RTL2832 Function 1 enabling status for setting
++@param [in] pMxl5007tExtraModuleMemory Pointer to an allocated Mxl5007T extra module memory
++@param [in] TunerDeviceAddr Mxl5007T I2C device address
++@param [in] TunerAgcMode Mxl5007T AGC mode
++
++
++@note
++ -# One should call BuildRtl2832Mxl5007tModule() to build RTL2832 MxL5007T NIM module before using it.
++
++*/
++void
++BuildRtl2832Mxl5007tModule(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long DemodUpdateFuncRefPeriodMs,
++ int DemodIsFunc1Enabled,
++
++ MXL5007T_EXTRA_MODULE *pMxl5007tExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr,
++ unsigned long TunerCrystalFreqHz,
++ int TunerClkOutMode,
++ int TunerClkOutAmpMode
++ )
++{
++ DVBT_NIM_MODULE *pNim;
++
++
++
++ // Set NIM module pointer with NIM module memory.
++ *ppNim = pDvbtNimModuleMemory;
++
++ // Get NIM module.
++ pNim = *ppNim;
++
++ // Set I2C bridge module pointer with I2C bridge module memory.
++ pNim->pI2cBridge = &pNim->I2cBridgeModuleMemory;
++
++ // Set NIM extra module pointer.
++ pNim->pExtra = INVALID_POINTER_VALUE;
++
++
++ // Set NIM type.
++ pNim->NimType = DVBT_NIM_RTL2832_MXL5007T;
++
++
++ // Build base interface module.
++ BuildBaseInterface(
++ &pNim->pBaseInterface,
++ &pNim->BaseInterfaceModuleMemory,
++ I2cReadingByteNumMax,
++ I2cWritingByteNumMax,
++ I2cRead,
++ I2cWrite,
++ WaitMs
++ );
++
++ // Build RTL2832 demod module.
++ BuildRtl2832Module(
++ &pNim->pDemod,
++ &pNim->DvbtDemodModuleMemory,
++ pRtl2832ExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ DemodDeviceAddr,
++ DemodCrystalFreqHz,
++ DemodAppMode,
++ DemodUpdateFuncRefPeriodMs,
++ DemodIsFunc1Enabled
++ );
++
++ // Build Mxl5007T tuner module.
++ BuildMxl5007tModule(
++ &pNim->pTuner,
++ &pNim->TunerModuleMemory,
++ pMxl5007tExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ TunerDeviceAddr,
++ TunerCrystalFreqHz,
++ RTL2832_MXL5007T_STANDARD_MODE_DEFAULT,
++ RTL2832_MXL5007T_IF_FREQ_HZ_DEFAULT,
++ RTL2832_MXL5007T_SPECTRUM_MODE_DEFAULT,
++ TunerClkOutMode,
++ TunerClkOutAmpMode,
++ RTL2832_MXL5007T_QAM_IF_DIFF_OUT_LEVEL_DEFAULT
++ );
++
++
++ // Set NIM module variables.
++ pNim->DemodTsInterfaceMode = DemodTsInterfaceMode;
++
++
++ // Set NIM module function pointers with default functions.
++ pNim->GetNimType = dvbt_nim_default_GetNimType;
++ pNim->GetParameters = dvbt_nim_default_GetParameters;
++ pNim->IsSignalPresent = dvbt_nim_default_IsSignalPresent;
++ pNim->IsSignalLocked = dvbt_nim_default_IsSignalLocked;
++ pNim->GetSignalStrength = dvbt_nim_default_GetSignalStrength;
++ pNim->GetSignalQuality = dvbt_nim_default_GetSignalQuality;
++ pNim->GetBer = dvbt_nim_default_GetBer;
++ pNim->GetSnrDb = dvbt_nim_default_GetSnrDb;
++ pNim->GetTrOffsetPpm = dvbt_nim_default_GetTrOffsetPpm;
++ pNim->GetCrOffsetHz = dvbt_nim_default_GetCrOffsetHz;
++ pNim->GetTpsInfo = dvbt_nim_default_GetTpsInfo;
++ pNim->UpdateFunction = dvbt_nim_default_UpdateFunction;
++
++ // Set NIM module function pointers with particular functions.
++ pNim->Initialize = rtl2832_mxl5007t_Initialize;
++ pNim->SetParameters = rtl2832_mxl5007t_SetParameters;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_INITIALIZE
++
++*/
++int
++rtl2832_mxl5007t_Initialize(
++ DVBT_NIM_MODULE *pNim
++ )
++{
++ typedef struct
++ {
++ int RegBitName;
++ unsigned long Value;
++ }
++ REG_VALUE_ENTRY;
++
++
++ static const REG_VALUE_ENTRY AdditionalInitRegValueTable[RTL2832_MXL5007T_ADDITIONAL_INIT_REG_TABLE_LEN] =
++ {
++ // RegBitName, Value
++ {DVBT_DAGC_TRG_VAL, 0x39 },
++ {DVBT_AGC_TARG_VAL_0, 0x0 },
++ {DVBT_AGC_TARG_VAL_8_1, 0x32 },
++ {DVBT_AAGC_LOOP_GAIN, 0x16 },
++ {DVBT_LOOP_GAIN2_3_0, 0x6 },
++ {DVBT_LOOP_GAIN2_4, 0x1 },
++ {DVBT_LOOP_GAIN3, 0x16 },
++ {DVBT_VTOP1, 0x35 },
++ {DVBT_VTOP2, 0x21 },
++ {DVBT_VTOP3, 0x21 },
++ {DVBT_KRF1, 0x0 },
++ {DVBT_KRF2, 0x40 },
++ {DVBT_KRF3, 0x10 },
++ {DVBT_KRF4, 0x10 },
++ {DVBT_IF_AGC_MIN, 0x80 },
++ {DVBT_IF_AGC_MAX, 0x7f },
++ {DVBT_RF_AGC_MIN, 0x80 },
++ {DVBT_RF_AGC_MAX, 0x7f },
++ {DVBT_POLAR_RF_AGC, 0x0 },
++ {DVBT_POLAR_IF_AGC, 0x0 },
++ {DVBT_AD7_SETTING, 0xe9d4 },
++ {DVBT_AD_EN_REG1, 0x0 },
++ {DVBT_CKOUT_PWR_PID, 0x0 },
++ };
++
++
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ int i;
++
++ int RegBitName;
++ unsigned long Value;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Initialize tuner.
++ if(pTuner->Initialize(pTuner) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Initialize demod.
++ if(pDemod->Initialize(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod IF frequency with NIM default.
++ if(pDemod->SetIfFreqHz(pDemod, RTL2832_MXL5007T_IF_FREQ_HZ_DEFAULT) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod spectrum mode with NIM default.
++ if(pDemod->SetSpectrumMode(pDemod, RTL2832_MXL5007T_SPECTRUM_MODE_DEFAULT) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Set demod registers.
++ for(i = 0; i < RTL2832_MXL5007T_ADDITIONAL_INIT_REG_TABLE_LEN; i++)
++ {
++ // Get register bit name and its value.
++ RegBitName = AdditionalInitRegValueTable[i].RegBitName;
++ Value = AdditionalInitRegValueTable[i].Value;
++
++ // Set demod registers
++ if(pDemod->SetRegBitsWithPage(pDemod, RegBitName, Value) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++ }
++
++
++ // Set TS interface according to TS interface mode.
++ switch(pNim->DemodTsInterfaceMode)
++ {
++ case TS_INTERFACE_PARALLEL:
++
++ // Set demod TS interface with parallel mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++
++
++ default:
++ case TS_INTERFACE_SERIAL:
++
++ // Set demod TS interface with serial mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_SET_PARAMETERS
++
++*/
++int
++rtl2832_mxl5007t_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ )
++{
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ MXL5007T_EXTRA_MODULE *pTunerExtra;
++ int TunerBandwidthMode;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++ // Get tuner extra module.
++ pTunerExtra = (MXL5007T_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Set tuner RF frequency in Hz.
++ if(pTuner->SetRfFreqHz(pTuner, RfFreqHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Determine TunerBandwidthMode according to bandwidth mode.
++ switch(BandwidthMode)
++ {
++ default:
++ case DVBT_BANDWIDTH_6MHZ: TunerBandwidthMode = MXL5007T_BANDWIDTH_6000000HZ; break;
++ case DVBT_BANDWIDTH_7MHZ: TunerBandwidthMode = MXL5007T_BANDWIDTH_7000000HZ; break;
++ case DVBT_BANDWIDTH_8MHZ: TunerBandwidthMode = MXL5007T_BANDWIDTH_8000000HZ; break;
++ }
++
++ // Set tuner bandwidth mode with TunerBandwidthMode.
++ if(pTunerExtra->SetBandwidthMode(pTuner, TunerBandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Set demod bandwidth mode.
++ if(pDemod->SetBandwidthMode(pDemod, BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod particular registers.
++ if(pDemod->ResetFunction(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mxl5007t.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_mxl5007t.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,155 @@
++#ifndef __NIM_RTL2832_MXL5007T
++#define __NIM_RTL2832_MXL5007T
++
++/**
++
++@file
++
++@brief RTL2832 MxL5007T NIM module declaration
++
++One can manipulate RTL2832 MxL5007T NIM through RTL2832 MxL5007T NIM module.
++RTL2832 MxL5007T NIM module is derived from DVB-T NIM module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the NIM example in dvbt_nim_base.h except the listed lines.
++
++
++
++#include "nim_rtl2832_mxl5007t.h"
++
++
++...
++
++
++
++int main(void)
++{
++ DVBT_NIM_MODULE *pNim;
++ DVBT_NIM_MODULE DvbtNimModuleMemory;
++ RTL2832_EXTRA_MODULE Rtl2832ExtraModuleMemory;
++ MXL5007T_EXTRA_MODULE Mxl5007tExtraModuleMemory;
++
++ ...
++
++
++
++ // Build RTL2832 MxL5007T NIM module.
++ BuildRtl2832Mxl5007tModule(
++ &pNim,
++ &DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ CustomI2cRead, // Employ CustomI2cRead() as basic I2C reading function.
++ CustomI2cWrite, // Employ CustomI2cWrite() as basic I2C writing function.
++ CustomWaitMs, // Employ CustomWaitMs() as basic waiting function.
++
++ &Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ 0x20, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_STB, // The RTL2832 application mode is STB mode.
++ TS_INTERFACE_SERIAL, // The RTL2832 TS interface mode is serial.
++ 50, // The RTL2832 update function reference period is 50 millisecond
++ ON, // The RTL2832 Function 1 enabling status is on.
++
++ &Mxl5007tExtraModuleMemory, // Employ Mxl5007T extra module for Mxl5007T module.
++ 0xc0, // The MxL5007T I2C device address is 0xc0 in 8-bit format.
++ CRYSTAL_FREQ_16000000HZ, // The MxL5007T Crystal frequency is 16.0 MHz.
++ MXL5007T_CLK_OUT_DISABLE, // The MxL5007T clock output mode is disabled.
++ MXL5007T_CLK_OUT_AMP_0 // The MxL5007T clock output amplitude is 0.
++ );
++
++
++
++ // See the example for other NIM functions in dvbt_nim_base.h
++
++ ...
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "demod_rtl2832.h"
++#include "tuner_mxl5007t.h"
++#include "dvbt_nim_base.h"
++
++
++
++
++
++// Definitions
++#define RTL2832_MXL5007T_ADDITIONAL_INIT_REG_TABLE_LEN 23
++
++// Default
++#define RTL2832_MXL5007T_STANDARD_MODE_DEFAULT MXL5007T_STANDARD_DVBT
++#define RTL2832_MXL5007T_IF_FREQ_HZ_DEFAULT IF_FREQ_4570000HZ
++#define RTL2832_MXL5007T_SPECTRUM_MODE_DEFAULT SPECTRUM_NORMAL
++#define RTL2832_MXL5007T_QAM_IF_DIFF_OUT_LEVEL_DEFAULT 0
++
++
++
++
++
++// Builder
++void
++BuildRtl2832Mxl5007tModule(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long DemodUpdateFuncRefPeriodMs,
++ int DemodIsFunc1Enabled,
++
++ MXL5007T_EXTRA_MODULE *pMxl5007tExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr,
++ unsigned long TunerCrystalFreqHz,
++ int TunerClkOutMode,
++ int TunerClkOutAmpMode
++ );
++
++
++
++
++
++// RTL2832 MxL5007T NIM manipulaing functions
++int
++rtl2832_mxl5007t_Initialize(
++ DVBT_NIM_MODULE *pNim
++ );
++
++int
++rtl2832_mxl5007t_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ );
++
++
++
++
++
++
++
++#endif
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_tua9001.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_tua9001.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,386 @@
++/**
++
++@file
++
++@brief RTL2832 TUA9001 NIM module definition
++
++One can manipulate RTL2832 TUA9001 NIM through RTL2832 TUA9001 NIM module.
++RTL2832 TUA9001 NIM module is derived from DVB-T NIM module.
++
++*/
++
++
++#include "nim_rtl2832_tua9001.h"
++
++
++
++
++
++/**
++
++@brief RTL2832 TUA9001 NIM module builder
++
++Use BuildRtl2832Tua9001Module() to build RTL2832 TUA9001 NIM module, set all module function pointers with the
++corresponding functions, and initialize module private variables.
++
++
++@param [in] ppNim Pointer to RTL2832 TUA9001 NIM module pointer
++@param [in] pDvbtNimModuleMemory Pointer to an allocated DVB-T NIM module memory
++@param [in] I2cReadingByteNumMax Maximum I2C reading byte number for basic I2C reading function
++@param [in] I2cWritingByteNumMax Maximum I2C writing byte number for basic I2C writing function
++@param [in] I2cRead Basic I2C reading function pointer
++@param [in] I2cWrite Basic I2C writing function pointer
++@param [in] WaitMs Basic waiting function pointer
++@param [in] pRtl2832ExtraModuleMemory Pointer to an allocated RTL2832 extra module memory
++@param [in] DemodDeviceAddr RTL2832 I2C device address
++@param [in] DemodCrystalFreqHz RTL2832 crystal frequency in Hz
++@param [in] DemodAppMode RTL2832 application mode for setting
++@param [in] DemodTsInterfaceMode RTL2832 TS interface mode for setting
++@param [in] pTua9001ExtraModuleMemory Pointer to an allocated TUA9001 extra module memory
++@param [in] TunerDeviceAddr TUA9001 I2C device address
++@param [in] TunerAgcMode TUA9001 AGC mode
++
++
++@note
++ -# One should call BuildRtl2832Tua9001Module() to build RTL2832 TUA9001 NIM module before using it.
++
++*/
++void
++BuildRtl2832Tua9001Module(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long DemodUpdateFuncRefPeriodMs,
++ int DemodIsFunc1Enabled,
++
++ TUA9001_EXTRA_MODULE *pTua9001ExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr
++ )
++{
++ DVBT_NIM_MODULE *pNim;
++
++
++
++ // Set NIM module pointer with NIM module memory.
++ *ppNim = pDvbtNimModuleMemory;
++
++ // Get NIM module.
++ pNim = *ppNim;
++
++ // Set I2C bridge module pointer with I2C bridge module memory.
++ pNim->pI2cBridge = &pNim->I2cBridgeModuleMemory;
++
++ // Set NIM extra module pointer.
++ pNim->pExtra = INVALID_POINTER_VALUE;
++
++
++ // Set NIM type.
++ pNim->NimType = DVBT_NIM_RTL2832_TUA9001;
++
++
++ // Build base interface module.
++ BuildBaseInterface(
++ &pNim->pBaseInterface,
++ &pNim->BaseInterfaceModuleMemory,
++ I2cReadingByteNumMax,
++ I2cWritingByteNumMax,
++ I2cRead,
++ I2cWrite,
++ WaitMs
++ );
++
++ // Build RTL2832 demod module.
++ BuildRtl2832Module(
++ &pNim->pDemod,
++ &pNim->DvbtDemodModuleMemory,
++ pRtl2832ExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ DemodDeviceAddr,
++ DemodCrystalFreqHz,
++ DemodAppMode,
++ DemodUpdateFuncRefPeriodMs,
++ DemodIsFunc1Enabled
++ );
++
++ // Build TUA9001 tuner module.
++ BuildTua9001Module(
++ &pNim->pTuner,
++ &pNim->TunerModuleMemory,
++ pTua9001ExtraModuleMemory,
++ &pNim->BaseInterfaceModuleMemory,
++ &pNim->I2cBridgeModuleMemory,
++ TunerDeviceAddr
++ );
++
++
++ // Set NIM module variables.
++ pNim->DemodTsInterfaceMode = DemodTsInterfaceMode;
++
++
++ // Set NIM module function pointers with default functions.
++ pNim->GetNimType = dvbt_nim_default_GetNimType;
++ pNim->GetParameters = dvbt_nim_default_GetParameters;
++ pNim->IsSignalPresent = dvbt_nim_default_IsSignalPresent;
++ pNim->IsSignalLocked = dvbt_nim_default_IsSignalLocked;
++ pNim->GetSignalStrength = dvbt_nim_default_GetSignalStrength;
++ pNim->GetSignalQuality = dvbt_nim_default_GetSignalQuality;
++ pNim->GetBer = dvbt_nim_default_GetBer;
++ pNim->GetSnrDb = dvbt_nim_default_GetSnrDb;
++ pNim->GetTrOffsetPpm = dvbt_nim_default_GetTrOffsetPpm;
++ pNim->GetCrOffsetHz = dvbt_nim_default_GetCrOffsetHz;
++ pNim->GetTpsInfo = dvbt_nim_default_GetTpsInfo;
++ pNim->UpdateFunction = dvbt_nim_default_UpdateFunction;
++
++ // Set NIM module function pointers with particular functions.
++ pNim->Initialize = rtl2832_tua9001_Initialize;
++ pNim->SetParameters = rtl2832_tua9001_SetParameters;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_INITIALIZE
++
++*/
++int
++rtl2832_tua9001_Initialize(
++ DVBT_NIM_MODULE *pNim
++ )
++{
++ typedef struct
++ {
++ int RegBitName;
++ unsigned long Value;
++ }
++ REG_VALUE_ENTRY;
++
++
++ static const REG_VALUE_ENTRY AdditionalInitRegValueTable[RTL2832_TUA9001_ADDITIONAL_INIT_REG_TABLE_LEN] =
++ {
++ // RegBitName, Value
++ {DVBT_DAGC_TRG_VAL, 0x39 },
++ {DVBT_AGC_TARG_VAL_0, 0x0 },
++ {DVBT_AGC_TARG_VAL_8_1, 0x5a },
++ {DVBT_AAGC_LOOP_GAIN, 0x16 },
++ {DVBT_LOOP_GAIN2_3_0, 0x6 },
++ {DVBT_LOOP_GAIN2_4, 0x1 },
++ {DVBT_LOOP_GAIN3, 0x16 },
++ {DVBT_VTOP1, 0x35 },
++ {DVBT_VTOP2, 0x21 },
++ {DVBT_VTOP3, 0x21 },
++ {DVBT_KRF1, 0x0 },
++ {DVBT_KRF2, 0x40 },
++ {DVBT_KRF3, 0x10 },
++ {DVBT_KRF4, 0x10 },
++ {DVBT_IF_AGC_MIN, 0x80 },
++ {DVBT_IF_AGC_MAX, 0x7f },
++ {DVBT_RF_AGC_MIN, 0x9c },
++ {DVBT_RF_AGC_MAX, 0x7f },
++ {DVBT_POLAR_RF_AGC, 0x0 },
++ {DVBT_POLAR_IF_AGC, 0x0 },
++ {DVBT_AD7_SETTING, 0xe9f4 },
++ {DVBT_OPT_ADC_IQ, 0x1 },
++ {DVBT_AD_AVI, 0x0 },
++ {DVBT_AD_AVQ, 0x0 },
++ };
++
++
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ int i;
++
++ int RegBitName;
++ unsigned long Value;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Initialize tuner.
++ if(pTuner->Initialize(pTuner) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Initialize demod.
++ if(pDemod->Initialize(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod IF frequency with 0 Hz.
++ if(pDemod->SetIfFreqHz(pDemod, IF_FREQ_0HZ) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Set demod spectrum mode with SPECTRUM_NORMAL.
++ if(pDemod->SetSpectrumMode(pDemod, SPECTRUM_NORMAL) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Set demod registers.
++ for(i = 0; i < RTL2832_TUA9001_ADDITIONAL_INIT_REG_TABLE_LEN; i++)
++ {
++ // Get register bit name and its value.
++ RegBitName = AdditionalInitRegValueTable[i].RegBitName;
++ Value = AdditionalInitRegValueTable[i].Value;
++
++ // Set demod registers
++ if(pDemod->SetRegBitsWithPage(pDemod, RegBitName, Value) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++ }
++
++
++ // Set TS interface according to TS interface mode.
++ switch(pNim->DemodTsInterfaceMode)
++ {
++ case TS_INTERFACE_PARALLEL:
++
++ // Set demod TS interface with parallel mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 9) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++
++
++ default:
++ case TS_INTERFACE_SERIAL:
++
++ // Set demod TS interface with serial mode.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_SERIAL, 1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH0, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_CDIV_PH1, 2) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ break;
++ }
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see DVBT_NIM_FP_SET_PARAMETERS
++
++*/
++int
++rtl2832_tua9001_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ )
++{
++ TUNER_MODULE *pTuner;
++ DVBT_DEMOD_MODULE *pDemod;
++
++ TUA9001_EXTRA_MODULE *pTunerExtra;
++ int TunerBandwidthMode;
++
++
++
++ // Get tuner module and demod module.
++ pTuner = pNim->pTuner;
++ pDemod = pNim->pDemod;
++
++ // Get tuner extra module.
++ pTunerExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Enable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x1) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++ // Set tuner RF frequency in Hz.
++ if(pTuner->SetRfFreqHz(pTuner, RfFreqHz) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Determine TunerBandwidthMode according to bandwidth mode.
++ switch(BandwidthMode)
++ {
++ default:
++ case DVBT_BANDWIDTH_6MHZ: TunerBandwidthMode = TUA9001_BANDWIDTH_6MHZ; break;
++ case DVBT_BANDWIDTH_7MHZ: TunerBandwidthMode = TUA9001_BANDWIDTH_7MHZ; break;
++ case DVBT_BANDWIDTH_8MHZ: TunerBandwidthMode = TUA9001_BANDWIDTH_8MHZ; break;
++ }
++
++ // Set tuner bandwidth mode with TunerBandwidthMode.
++ if(pTunerExtra->SetBandwidthMode(pTuner, TunerBandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Disable demod DVBT_IIC_REPEAT.
++ if(pDemod->SetRegBitsWithPage(pDemod, DVBT_IIC_REPEAT, 0x0) != FUNCTION_SUCCESS)
++ goto error_status_set_registers;
++
++
++ // Set demod bandwidth mode.
++ if(pDemod->SetBandwidthMode(pDemod, BandwidthMode) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++ // Reset demod particular registers.
++ if(pDemod->ResetFunction(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ // Reset demod by software reset.
++ if(pDemod->SoftwareReset(pDemod) != FUNCTION_SUCCESS)
++ goto error_status_execute_function;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_execute_function:
++error_status_set_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/nim_rtl2832_tua9001.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/nim_rtl2832_tua9001.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,142 @@
++#ifndef __NIM_RTL2832_TUA9001
++#define __NIM_RTL2832_TUA9001
++
++/**
++
++@file
++
++@brief RTL2832 TUA9001 NIM module declaration
++
++One can manipulate RTL2832 TUA9001 NIM through RTL2832 TUA9001 NIM module.
++RTL2832 TUA9001 NIM module is derived from DVB-T NIM module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the NIM example in dvbt_nim_base.h except the listed lines.
++
++
++
++#include "nim_rtl2832_tua9001.h"
++
++
++...
++
++
++
++int main(void)
++{
++ DVBT_NIM_MODULE *pNim;
++ DVBT_NIM_MODULE DvbtNimModuleMemory;
++ RTL2832_EXTRA_MODULE Rtl2832ExtraModuleMemory;
++ TUA9001_EXTRA_MODULE Tua9001ExtraModuleMemory;
++
++ ...
++
++
++
++ // Build RTL2832 TUA9001 NIM module.
++ BuildRtl2832Tua9001Module(
++ &pNim,
++ &DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ CustomI2cRead, // Employ CustomI2cRead() as basic I2C reading function.
++ CustomI2cWrite, // Employ CustomI2cWrite() as basic I2C writing function.
++ CustomWaitMs, // Employ CustomWaitMs() as basic waiting function.
++
++ &Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ 0x20, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_STB, // The RTL2832 application mode is STB mode.
++ 50, // The RTL2832 update function reference period is 50 millisecond
++ ON, // The RTL2832 Function 1 enabling status is on.
++
++ &Tua9001ExtraModuleMemory, // Employ TUA9001 extra module for TUA9001 module.
++ 0xac, // The TUA9001 I2C device address is 0xac in 8-bit format.
++ );
++
++
++
++ // See the example for other NIM functions in dvbt_nim_base.h
++
++ ...
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "demod_rtl2832.h"
++#include "tuner_tua9001.h"
++#include "dvbt_nim_base.h"
++
++
++
++
++
++// Definitions
++#define RTL2832_TUA9001_ADDITIONAL_INIT_REG_TABLE_LEN 24
++
++
++
++
++
++// Builder
++void
++BuildRtl2832Tua9001Module(
++ DVBT_NIM_MODULE **ppNim, // DVB-T NIM dependence
++ DVBT_NIM_MODULE *pDvbtNimModuleMemory,
++
++ unsigned char I2cReadingByteNumMax, // Base interface dependence
++ unsigned char I2cWritingByteNumMax,
++ BASE_FP_I2C_READ I2cRead,
++ BASE_FP_I2C_WRITE I2cWrite,
++ BASE_FP_WAIT_MS WaitMs,
++
++ RTL2832_EXTRA_MODULE *pRtl2832ExtraModuleMemory, // Demod dependence
++ unsigned char DemodDeviceAddr,
++ unsigned long DemodCrystalFreqHz,
++ int DemodAppMode,
++ int DemodTsInterfaceMode,
++ unsigned long UpdateFuncRefPeriodMs,
++ int IsFunc1Enabled,
++
++ TUA9001_EXTRA_MODULE *pTua9001ExtraModuleMemory, // Tuner dependence
++ unsigned char TunerDeviceAddr
++ );
++
++
++
++
++
++// RTL2832 TUA9001 NIM manipulaing functions
++int
++rtl2832_tua9001_Initialize(
++ DVBT_NIM_MODULE *pNim
++ );
++
++int
++rtl2832_tua9001_SetParameters(
++ DVBT_NIM_MODULE *pNim,
++ unsigned long RfFreqHz,
++ int BandwidthMode
++ );
++
++
++
++
++
++
++
++#endif
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/readme.txt
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/readme.txt Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,40 @@
++Driver Installation in Linux
++
++1. Download "v4l-dvb-(version)" source code from http://linuxtv.org/.
++
++2. Copy the folder 'rtl2832u_linux_driver' and "v4l-dvb-(version)" source code to the desktop.
++
++3. Click 'Applications' -> 'Accessories' -> 'Terminal' to enter the console mode.
++
++4. Type 'cd /root/Desktop/rtl2832u_linux_driver' to enter the folder.
++
++5. In the folder 'rtl2832u_linux_driver', type the following command to compile & install.
++
++ a. Type 'cp -f *.* /root/Desktop/v4l-dvb-(version)/linux/drivers/media/dvb/dvb-usb' to copy all files into v4l-dvb-(version) code.
++
++ b. add the following lines to Makefile in v4l-dvb-(version)/linux/drivers/media/dvb/dvb-usb.
++dvb-usb-rtl2832u-objs = demod_rtl2832.o dvbt_demod_base.o dvbt_nim_base.o foundation.o math_mpi.o nim_rtl2832_mxl5007t.o nim_rtl2832_fc2580.o nim_rtl2832_mt2266.o rtl2832u.o rtl2832u_fe.o rtl2832u_io.o tuner_mxl5007t.o tuner_fc2580.o tuner_mt2266.o tuner_tua9001.o nim_rtl2832_tua9001.o
++obj-$(CONFIG_DVB_USB_RTL2832U) += dvb-usb-rtl2832u.o
++
++ c. add the following lines to Kconfig in v4l-dvb-(version)/linux/drivers/media/dvb/dvb-usb.
++config DVB_USB_RTL2832U
++ tristate "Realtek RTL2832U DVB-T USB2.0 support"
++ depends on DVB_USB
++ help
++ Realtek RTL2832U DVB-T driver.
++
++ d. Type 'make clean'
++ d. Type 'make'
++ f. Type 'make install'
++
++6. Plug in our DVB-T USB device;
++
++7. Type 'lsmod | grep dvb', and it will show
++ dvb_usb_rtl2831u
++ dvb_usb
++ dvb_core
++ i2c_core
++
++ Your driver has been installed successfully.
++
++8. Install the applications --'Xine' and 'linuxtv-dvb-apps'.
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/rtl2832u.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/rtl2832u.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,287 @@
++
++#include <linux/module.h>
++#include <linux/version.h>
++
++#include "rtl2832u.h"
++#include "rtl2832u_io.h"
++
++int dvb_usb_rtl2832u_debug;
++module_param_named(debug,dvb_usb_rtl2832u_debug, int, 0644);
++MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2 (or-able))." DVB_USB_DEBUG_STATUS);
++
++//DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
++
++#define USB_EPA_CTL 0x0148
++
++
++static int rtl2832u_streaming_ctrl(struct dvb_usb_adapter *adap , int onoff)
++{
++ u8 data[2];
++ //3 to avoid scanning channels loss
++ if(onoff)
++ {
++ data[0] = data[1] = 0;
++ if ( write_usb_sys_char_bytes( adap->dev , RTD2832U_USB , USB_EPA_CTL , data , 2) ) goto error;
++ }
++ else
++ {
++ data[0] = 0x10; //3stall epa, set bit 4 to 1
++ data[1] = 0x02; //3reset epa, set bit 9 to 1
++ if ( write_usb_sys_char_bytes( adap->dev , RTD2832U_USB , USB_EPA_CTL , data , 2) ) goto error;
++ }
++
++ return 0;
++error:
++ return -1;
++}
++
++
++static int rtl2832u_frontend_attach(struct dvb_usb_adapter *adap)
++{
++ adap->fe = rtl2832u_fe_attach(adap->dev);
++ return 0;
++}
++
++
++static void rtl2832u_usb_disconnect(struct usb_interface *intf)
++{
++ try_module_get(THIS_MODULE);
++ dvb_usb_device_exit(intf);
++}
++
++
++static struct dvb_usb_device_properties rtl2832u_1st_properties;
++static struct dvb_usb_device_properties rtl2832u_2nd_properties;
++static struct dvb_usb_device_properties rtl2832u_3th_properties;
++
++
++static int rtl2832u_usb_probe(struct usb_interface *intf,
++ const struct usb_device_id *id)
++{
++ if ( ( 0== dvb_usb_device_init(intf,&rtl2832u_1st_properties,THIS_MODULE,NULL) )||
++ ( 0== dvb_usb_device_init(intf,&rtl2832u_2nd_properties,THIS_MODULE,NULL) ) ||
++ ( 0== dvb_usb_device_init(intf,&rtl2832u_3th_properties,THIS_MODULE,NULL) ))
++ return 0;
++
++ return -ENODEV;
++}
++
++static struct usb_device_id rtl2832u_usb_table [] = {
++ { USB_DEVICE(USB_VID_REALTEK, USB_PID_RTD2832U_WARM) },
++ { USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_AZUREWAVE_USB_WARM) },
++ { USB_DEVICE(USB_VID_KWORLD_1ST, USB_PID_KWORLD_WARM_6) },
++ { USB_DEVICE(USB_VID_DEXATEK, USB_PID_DEXATEK_USB_WARM) },
++ { USB_DEVICE(USB_VID_DEXATEK, USB_PID_DEXATEK_MINIUSB_WARM) },
++ { USB_DEVICE(USB_VID_DEXATEK, USB_PID_DEXATEK_5217_WARM) },
++
++ { USB_DEVICE(USB_VID_REALTEK, USB_PID_RTD2832U_2ND_WARM) },
++ { USB_DEVICE(USB_VID_GOLDENBRIDGE, USB_PID_GOLDENBRIDGE_WARM) },
++ { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_WARM) },
++ { USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_AZUREWAVE_MINI_WARM) },
++ { USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_AZUREWAVE_GPS_WARM) },
++ { USB_DEVICE(USB_VID_KWORLD_1ST, USB_PID_KWORLD_WARM_7) },
++
++ { USB_DEVICE(USB_VID_KWORLD_1ST, USB_PID_KWORLD_WARM_3) },
++ { USB_DEVICE(USB_VID_KWORLD_1ST, USB_PID_KWORLD_WARM_8) },
++ { USB_DEVICE(USB_VID_GTEK, USB_PID_GTEK_WARM) },
++ { 0 },
++};
++
++
++MODULE_DEVICE_TABLE(usb, rtl2832u_usb_table);
++
++static struct dvb_usb_device_properties rtl2832u_1st_properties = {
++
++ .num_adapters = 1,
++ .adapter =
++ {
++ {
++ .streaming_ctrl = rtl2832u_streaming_ctrl,
++ .frontend_attach = rtl2832u_frontend_attach,
++ //parameter for the MPEG2-data transfer
++ .stream =
++ {
++ .type = USB_BULK,
++ .count = RTD2831_URB_NUMBER,
++ .endpoint = 0x01, //data pipe
++ .u =
++ {
++ .bulk =
++ {
++ .buffersize = RTD2831_URB_SIZE,
++ }
++ }
++ },
++ }
++ },
++
++ .num_device_descs = 6,
++ .devices = {
++ { .name = "RTL2832U DVB-T USB DEVICE",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[0], NULL },
++ },
++ { .name = "DVB-T USB Dongle",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[1], NULL },
++ },
++ { .name = "USB DVB-T Device",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[2], NULL },
++ },
++ { .name = "DK DVBT DONGLE",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[3], NULL },
++ },
++ { .name = "DK mini DVBT DONGLE",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[4], NULL },
++ },
++ { .name = "DK 5217 DVBT DONGLE",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[5], NULL },
++ },
++ { NULL },
++ }
++};
++
++
++static struct dvb_usb_device_properties rtl2832u_2nd_properties = {
++
++ .num_adapters = 1,
++ .adapter =
++ {
++ {
++ .streaming_ctrl = rtl2832u_streaming_ctrl,
++ .frontend_attach = rtl2832u_frontend_attach,
++ //parameter for the MPEG2-data transfer
++ .stream =
++ {
++ .type = USB_BULK,
++ .count = RTD2831_URB_NUMBER,
++ .endpoint = 0x01, //data pipe
++ .u =
++ {
++ .bulk =
++ {
++ .buffersize = RTD2831_URB_SIZE,
++ }
++ }
++ },
++ }
++ },
++
++ .num_device_descs = 6,
++ .devices = {
++ { .name = "RTL2832U DVB-T USB DEVICE",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[6], NULL },
++ },
++ { .name = "RTL2832U DVB-T USB DEVICE",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[7], NULL },
++ },
++ { .name = "Digital TV Tuner Card",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[8], NULL },
++ },
++ { .name = "DVB-T FTA USB Half Minicard",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[9], NULL },
++ },
++ { .name = "DVB-T + GPS Minicard",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[10], NULL },
++ },
++ { .name = "UB450-T",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[11], NULL },
++ },
++ { NULL },
++ }
++};
++
++
++
++static struct dvb_usb_device_properties rtl2832u_3th_properties = {
++
++ .num_adapters = 1,
++ .adapter =
++ {
++ {
++ .streaming_ctrl = rtl2832u_streaming_ctrl,
++ .frontend_attach = rtl2832u_frontend_attach,
++ //parameter for the MPEG2-data transfer
++ .stream =
++ {
++ .type = USB_BULK,
++ .count = RTD2831_URB_NUMBER,
++ .endpoint = 0x01, //data pipe
++ .u =
++ {
++ .bulk =
++ {
++ .buffersize = RTD2831_URB_SIZE,
++ }
++ }
++ },
++ }
++ },
++
++ .num_device_descs = 3,
++ .devices = {
++ { .name = "USB DVB-T Device",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[12], NULL },
++ },
++ { .name = "USB DVB-T Device",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[13], NULL },
++ },
++ { .name = "RT DTV 2832U",
++ .cold_ids = { NULL, NULL },
++ .warm_ids = { &rtl2832u_usb_table[14], NULL },
++ },
++ { NULL },
++ }
++};
++
++
++
++
++static struct usb_driver rtl2832u_usb_driver = {
++ .name = "dvb_usb_rtl2832u",
++ .probe = rtl2832u_usb_probe,
++ .disconnect = rtl2832u_usb_disconnect,
++ .id_table = rtl2832u_usb_table,
++};
++
++
++static int __init rtl2832u_usb_module_init(void)
++{
++ int result;
++ if ((result = usb_register(&rtl2832u_usb_driver))) {
++ err("usb_register failed. (%d)",result);
++ return result;
++ }
++
++ return 0;
++}
++
++static void __exit rtl2832u_usb_module_exit(void)
++{
++ usb_deregister(&rtl2832u_usb_driver);
++}
++
++
++
++module_init(rtl2832u_usb_module_init);
++module_exit(rtl2832u_usb_module_exit);
++
++
++
++MODULE_AUTHOR("Realtek");
++MODULE_DESCRIPTION("Driver for the RTL2832U DVB-T USB2.0 device");
++MODULE_VERSION("1.1");
++MODULE_LICENSE("GPL");
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/rtl2832u.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/rtl2832u.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,56 @@
++
++#ifndef _RTL2832U_H_
++#define _RTL2832U_H_
++
++
++
++#include "dvb-usb.h"
++
++#define USB_VID_REALTEK 0x0BDA
++#define USB_PID_RTD2832U_WARM 0x2832
++#define USB_PID_RTD2832U_2ND_WARM 0x2838
++
++
++#define USB_VID_GOLDENBRIDGE 0x1680
++#define USB_PID_GOLDENBRIDGE_WARM 0xA332
++
++#define USB_VID_YUAN 0x1164
++#define USB_PID_YUAN_WARM 0x6601
++
++#define USB_VID_AZUREWAVE 0x13D3
++#define USB_PID_AZUREWAVE_MINI_WARM 0x3234
++#define USB_PID_AZUREWAVE_USB_WARM 0x3274
++#define USB_PID_AZUREWAVE_GPS_WARM 0x3282
++
++#define USB_VID_KWORLD_1ST 0x1B80
++#define USB_PID_KWORLD_WARM_6 0xD396
++#define USB_PID_KWORLD_WARM_3 0xD393
++#define USB_PID_KWORLD_WARM_7 0xD397
++#define USB_PID_KWORLD_WARM_8 0xD398
++
++
++#define USB_VID_DEXATEK 0x1D19
++#define USB_PID_DEXATEK_USB_WARM 0x1101
++#define USB_PID_DEXATEK_MINIUSB_WARM 0x1102
++#define USB_PID_DEXATEK_5217_WARM 0x1103
++
++
++#define USB_VID_GTEK 0x1F4D
++#define USB_PID_GTEK_WARM 0x0837
++
++
++
++
++
++
++#define RTD2831_URB_SIZE 4096
++#define RTD2831_URB_NUMBER 10
++
++
++
++extern struct dvb_frontend * rtl2832u_fe_attach(struct dvb_usb_device *d);
++
++#endif
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/rtl2832u_fe.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/rtl2832u_fe.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,1588 @@
++
++#include "rtl2832u_fe.h"
++#include "rtl2832u_io.h"
++#include "rtl2832u.h"
++
++
++#define UPDATE_PROCEDURE_PERIOD 500 //500ms
++
++
++
++
++static struct rtl2832_reg_addr rtl2832_reg_map[]= {
++ /* RTD2831_RMAP_INDEX_USB_CTRL_BIT5*/ { RTD2832U_USB, USB_CTRL, 5, 5 },
++ /* RTD2831_RMAP_INDEX_USB_STAT*/ { RTD2832U_USB, USB_STAT, 0, 7 },
++ /* RTD2831_RMAP_INDEX_USB_EPA_CTL*/ { RTD2832U_USB, USB_EPA_CTL, 0, 31 },
++ /* RTD2831_RMAP_INDEX_USB_SYSCTL*/ { RTD2832U_USB, USB_SYSCTL, 0, 31 },
++ /* RTD2831_RMAP_INDEX_USB_EPA_CFG*/ { RTD2832U_USB, USB_EPA_CFG, 0, 31 },
++ /* RTD2831_RMAP_INDEX_USB_EPA_MAXPKT*/ { RTD2832U_USB, USB_EPA_MAXPKT, 0, 31},
++ /* RTD2831_RMAP_INDEX_USB_EPA_FIFO_CFG*/ { RTD2832U_USB, USB_EPA_FIFO_CFG, 0, 31},
++
++ /* RTD2831_RMAP_INDEX_SYS_DEMOD_CTL*/ { RTD2832U_SYS, DEMOD_CTL, 0, 7 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL*/ { RTD2832U_SYS, GPIO_OUTPUT_VAL, 0, 7 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT3*/{ RTD2832U_SYS, GPIO_OUTPUT_EN, 3, 3 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT3*/ { RTD2832U_SYS, GPIO_DIR, 3, 3 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_CFG0_BIT67*/ { RTD2832U_SYS, GPIO_CFG0, 6, 7 },
++ /* RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1*/ { RTD2832U_SYS, DEMOD_CTL1, 0, 7 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT1*/{ RTD2832U_SYS, GPIO_OUTPUT_EN, 1, 1 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT1*/ { RTD2832U_SYS, GPIO_DIR, 1, 1 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT6*/{ RTD2832U_SYS, GPIO_OUTPUT_EN, 6, 6 },
++ /* RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT6*/ { RTD2832U_SYS, GPIO_DIR, 6, 6 },
++
++
++
++#if 0
++ /* RTD2831_RMAP_INDEX_SYS_GPD*/ { RTD2832U_SYS, GPD, 0, 7 },
++ /* RTD2831_RMAP_INDEX_SYS_GPOE*/ { RTD2832U_SYS, GPOE, 0, 7 },
++ /* RTD2831_RMAP_INDEX_SYS_GPO*/ { RTD2832U_SYS, GPO, 0, 7 },
++ /* RTD2831_RMAP_INDEX_SYS_SYS_0*/ { RTD2832U_SYS, SYS_0, 0, 7 },
++#endif
++
++};
++
++
++
++
++static void
++custom_wait_ms(
++ BASE_INTERFACE_MODULE* pBaseInterface,
++ unsigned long WaitTimeMs)
++{
++ platform_wait(WaitTimeMs);
++ return;
++}
++
++
++static int
++custom_i2c_read(
++ BASE_INTERFACE_MODULE* pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char* pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ struct dvb_usb_device *d;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++ if ( read_rtl2832_stdi2c( d, DeviceAddr , pReadingBytes , ByteNum ) ) goto error;
++
++ return 0;
++error:
++ return 1;
++}
++
++
++
++static int
++custom_i2c_write(
++ BASE_INTERFACE_MODULE* pBaseInterface,
++ unsigned char DeviceAddr,
++ const unsigned char* pWritingBytes,
++ unsigned char ByteNum)
++{
++ struct dvb_usb_device *d;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++ if ( write_rtl2832_stdi2c( d, DeviceAddr , (unsigned char*)pWritingBytes , ByteNum ) ) goto error;
++
++ return 0;
++error:
++ return 1;
++}
++
++
++
++static int
++read_usb_sys_register(
++ struct rtl2832_state* p_state,
++ rtl2832_reg_map_index reg_map_index,
++ int* p_val)
++{
++ RegType reg_type= rtl2832_reg_map[reg_map_index].reg_type;
++ unsigned short reg_addr= rtl2832_reg_map[reg_map_index].reg_addr;
++ int bit_low= rtl2832_reg_map[reg_map_index].bit_low;
++ int bit_high= rtl2832_reg_map[reg_map_index].bit_high;
++
++ int n_byte_read=(bit_high>> 3)+ 1;
++
++ *p_val= 0;
++ if (read_usb_sys_int_bytes(p_state->d, reg_type, reg_addr, n_byte_read, p_val)) goto error;
++
++ *p_val= ((*p_val>> bit_low) & rtl2832_reg_mask[bit_high- bit_low]);
++
++ return 0;
++
++error:
++ return 1;
++}
++
++
++
++
++static int
++write_usb_sys_register(
++ struct rtl2832_state* p_state,
++ rtl2832_reg_map_index reg_map_index,
++ int val_write)
++{
++ RegType reg_type= rtl2832_reg_map[reg_map_index].reg_type;
++ unsigned short reg_addr= rtl2832_reg_map[reg_map_index].reg_addr;
++ int bit_low= rtl2832_reg_map[reg_map_index].bit_low;
++ int bit_high= rtl2832_reg_map[reg_map_index].bit_high;
++
++ int n_byte_write= (bit_high>> 3)+ 1;
++ int val_read= 0;
++ int new_val_write;
++
++ if (read_usb_sys_int_bytes(p_state->d, reg_type, reg_addr, n_byte_write, &val_read)) goto error;
++
++ new_val_write= (val_read & (~(rtl2832_reg_mask[bit_high- bit_low]<< bit_low))) | (val_write<< bit_low);
++
++ if (write_usb_sys_int_bytes(p_state->d, reg_type, reg_addr, n_byte_write, new_val_write)) goto error;
++ return 0;
++
++error:
++ return 1;
++}
++
++
++
++static int
++set_tuner_power(
++ struct rtl2832_state* p_state,
++ unsigned char b_gpio4,
++ unsigned char onoff)
++{
++
++ int data;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL, &data) ) goto error;
++
++ if(b_gpio4)
++ {
++ if(onoff) data &= ~(BIT4); //set bit4 to 0
++ else data |= BIT4; //set bit4 to 1
++
++ }
++ else
++ {
++ if(onoff) data &= ~(BIT3); //set bit3 to 0
++ else data |= BIT3; //set bit3 to 1
++ }
++
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL,data) ) goto error;
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++error:
++ return 1;
++}
++
++
++
++static int
++set_demod_power(
++ struct rtl2832_state* p_state,
++ unsigned char onoff)
++{
++
++ int data;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL, &data) ) goto error;
++ if(onoff) data &= ~(BIT0); //set bit0 to 0
++ else data |= BIT0; //set bit0 to 1
++ data &= ~(BIT0); //3 Demod Power always ON => hw issue.
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL,data) ) goto error;
++
++ deb_info(" -%s \n", __FUNCTION__);
++ return 0;
++error:
++ return 1;
++}
++
++
++
++//3//////// Set GPIO3 "OUT" => Turn ON/OFF Tuner Power
++//3//////// Set GPIO3 "IN" => Button Wake UP (USB IF) , NO implement in rtl2832u linux driver
++
++static int
++gpio3_out_setting(
++ struct rtl2832_state* p_state)
++{
++ int data;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ // GPIO3_PAD Pull-HIGH, BIT76
++ data = 2;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_CFG0_BIT67,data) ) goto error;
++
++ // GPO_GPIO3 = 1, GPIO3 output value = 1
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL, &data) ) goto error;
++ data |= BIT3; //set bit3 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL,data) ) goto error;
++
++ // GPD_GPIO3=0, GPIO3 output direction
++ data = 0;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT3,data) ) goto error;
++
++ // GPOE_GPIO3=1, GPIO3 output enable
++ data = 1;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT3,data) ) goto error;
++
++ //BTN_WAKEUP_DIS = 1
++ data = 1;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_CTRL_BIT5,data) ) goto error;
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++error:
++ return 1;
++}
++
++
++
++
++
++
++static int
++usb_epa_fifo_reset(
++ struct rtl2832_state* p_state)
++{
++
++ int data;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ //3 reset epa fifo:
++ //3[9] Reset EPA FIFO
++ //3 [5] FIFO Flush,Write 1 to flush the oldest TS packet (a 188 bytes block)
++
++ data = 0x0210;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_CTL,data) ) goto error;
++
++ data = 0xffff;
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_CTL,&data) ) goto error;
++
++ if( (data & 0xffff) != 0x0210)
++ {
++ deb_info("Write error RTD2831_RMAP_INDEX_USB_EPA_CTL = 0x%x\n",data);
++ goto error;
++ }
++
++ data=0x0000;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_CTL,data) ) goto error;
++
++ data = 0xffff;
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_CTL,&data) ) goto error;
++
++ if( ( data & 0xffff) != 0x0000)
++ {
++ deb_info("Write error RTD2831_RMAP_INDEX_USB_EPA_CTL = 0x%x\n",data);
++ goto error;
++ }
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++
++error:
++ return 1;
++
++}
++
++
++
++static int
++usb_init_bulk_setting(
++ struct rtl2832_state* p_state)
++{
++
++ int data;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ //3 1.FULL packer mode(for bulk)
++ //3 2.DMA enable.
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_SYSCTL, &data) ) goto error;
++
++ data &=0xffffff00;
++ data |= 0x09;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_SYSCTL, data) ) goto error;
++
++ data=0;
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_SYSCTL, &data) ) goto error;
++
++ if((data&0xff)!=0x09)
++ {
++ deb_info("Open bulk FULL packet mode error!!\n");
++ goto error;
++ }
++
++ //3check epa config,
++ //3[9-8]:00, 1 transaction per microframe
++ //3[7]:1, epa enable
++ //3[6-5]:10, bulk mode
++ //3[4]:1, device to host
++ //3[3:0]:0001, endpoint number
++ data = 0;
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_CFG, &data) ) goto error;
++ if((data&0x0300)!=0x0000 || (data&0xff)!=0xd1)
++ {
++ deb_info("Open bulk EPA config error! data=0x%x \n" , data);
++ goto error;
++ }
++
++ //3 EPA maxsize packet
++ //3 512:highspeedbulk, 64:fullspeedbulk.
++ //3 940:highspeediso, 940:fullspeediso.
++
++ //3 get info :HIGH_SPEED or FULL_SPEED
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_STAT, &data) ) goto error;
++ if(data&0x01)
++ {
++ data = 0x00000200;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_MAXPKT, data) ) goto error;
++
++ data=0;
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_MAXPKT, &data) ) goto error;
++
++ if((data&0xffff)!=0x0200)
++ {
++ deb_info("Open bulk EPA max packet size error!\n");
++ goto error;
++ }
++
++ deb_info("HIGH SPEED\n");
++ }
++ else
++ {
++ data = 0x00000040;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_MAXPKT, data) ) goto error;
++
++ data=0;
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_MAXPKT, &data) ) goto error;
++
++ if((data&0xffff)!=0x0200)
++ {
++ deb_info("Open bulk EPA max packet size error!\n");
++ goto error;
++ }
++
++ deb_info("FULL SPEED\n");
++ }
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++
++error:
++ return 1;
++}
++
++
++static int
++usb_init_setting(
++ struct rtl2832_state* p_state)
++{
++
++ int data;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ if ( usb_init_bulk_setting(p_state) ) goto error;
++
++ //3 change fifo length of EPA
++ data = 0x00000014;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_FIFO_CFG, data) ) goto error;
++ data = 0xcccccccc;
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_USB_EPA_FIFO_CFG, &data) ) goto error;
++ if( (data & 0xff) != 0x14)
++ {
++ deb_info("Write error RTD2831_RMAP_INDEX_USB_EPA_FIFO_CFG =0x%x\n",data);
++ goto error;
++ }
++
++ if ( usb_epa_fifo_reset(p_state) ) goto error;
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++
++error:
++ return 1;
++}
++
++
++
++static int
++suspend_latch_setting(
++ struct rtl2832_state* p_state,
++ unsigned char resume)
++{
++
++ int data;
++ deb_info(" +%s \n", __FUNCTION__);
++
++ if (resume)
++ {
++ //3 Suspend_latch_en = 0 => Set BIT4 = 0
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1, &data) ) goto error;
++ data &= (~BIT4); //set bit4 to 0
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1,data) ) goto error;
++ }
++ else
++ {
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1, &data) ) goto error;
++ data |= BIT4; //set bit4 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1,data) ) goto error;
++ }
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++error:
++ return 1;
++
++}
++
++
++
++
++
++//3////// DEMOD_CTL1 => IR Setting , IR wakeup from suspend mode
++//3////// if resume =1, resume
++//3////// if resume = 0, suspend
++
++
++static int
++demod_ctl1_setting(
++ struct rtl2832_state* p_state,
++ unsigned char resume)
++{
++
++ int data;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ if(resume)
++ {
++ // IR_suspend
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1, &data) ) goto error;
++ data &= (~BIT2); //set bit2 to 0
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1,data) ) goto error;
++
++ //Clk_400k
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1, &data) ) goto error;
++ data &= (~BIT3); //set bit3 to 0
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1,data) ) goto error;
++ }
++ else
++ {
++ //Clk_400k
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1, &data) ) goto error;
++ data |= BIT3; //set bit3 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1,data) ) goto error;
++
++ // IR_suspend
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1, &data) ) goto error;
++ data |= BIT2; //set bit2 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1,data) ) goto error;
++ }
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++error:
++ return 1;
++
++}
++
++
++
++
++static int
++demod_ctl_setting(
++ struct rtl2832_state* p_state,
++ unsigned char resume)
++{
++
++ int data;
++ unsigned char tmp;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ if(resume)
++ {
++ // PLL setting
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data |= BIT7; //set bit7 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++
++
++ //2 + Begin LOCK
++ // Demod H/W Reset
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data &= (~BIT5); //set bit5 to 0
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data |= BIT5; //set bit5 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++
++ //3 reset page chache to 0
++ if ( read_rtl2832_demod_register(p_state->d, RTL2832_DEMOD_ADDR, 0, 1, &tmp, 1 ) ) goto error;
++ //2 -End LOCK
++
++ // delay 5ms
++ platform_wait(5);
++
++ // ADC_Q setting
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data |= BIT3; //set bit3 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++
++ // ADC_I setting
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data |= BIT6; //set bit3 to 1
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++ }
++ else
++ {
++
++ // ADC_I setting
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data &= (~BIT6); //set bit3 to 0
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++
++ // ADC_Q setting
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data &= (~BIT3); //set bit3 to 0
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++
++ // PLL setting
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL, &data) ) goto error;
++ data &= (~BIT7); //set bit7 to 0
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,data) ) goto error;
++
++ }
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++error:
++ return 1;
++
++}
++
++
++static int
++read_tuner_id_register(
++ struct rtl2832_state* p_state,
++ unsigned char tuner_addr,
++ unsigned char tuner_offset,
++ unsigned char* id_data,
++ unsigned char length)
++{
++ unsigned char i2c_repeater;
++ struct dvb_usb_device* d = p_state->d;
++
++ //2 + Begin LOCK
++ if(read_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++ i2c_repeater |= BIT3;
++ if(write_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++
++ if(read_rtl2832_tuner_register(d, tuner_addr, tuner_offset, id_data, length)) goto error;
++
++ if(read_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++ i2c_repeater &= (~BIT3);
++ if(write_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++ //2 - End LOCK
++ return 0;
++
++error:
++ return 1;
++}
++
++
++
++static int
++check_mxl5007t_chip_version(
++ struct rtl2832_state* p_state,
++ unsigned char *chipversion)
++{
++
++ unsigned char Buffer[LEN_2_BYTE];
++ unsigned char i2c_repeater;
++
++ struct dvb_usb_device* d = p_state->d;
++
++
++ Buffer[0] = (unsigned char)MXL5007T_I2C_READING_CONST;
++ Buffer[1] = (unsigned char)MXL5007T_CHECK_ADDRESS;
++
++
++ if(read_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++ i2c_repeater |= BIT3;
++ if(write_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++
++
++ write_rtl2832_stdi2c(d, MXL5007T_BASE_ADDRESS , Buffer, LEN_2_BYTE);
++
++ read_rtl2832_stdi2c(d, MXL5007T_BASE_ADDRESS, Buffer, LEN_1_BYTE);
++
++ if(read_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++ i2c_repeater &= (~BIT3);
++ if(write_rtl2832_demod_register(d, RTL2832_DEMOD_ADDR, 1, 1, &i2c_repeater, 1 )) goto error;
++
++
++
++ switch(Buffer[0])
++ {
++ case MXL5007T_CHECK_VALUE:
++ *chipversion = MxL_5007T_V4;
++ break;
++ default:
++ *chipversion = MxL_UNKNOWN_ID;
++ break;
++ }
++
++ return 0;
++
++error:
++
++ return 1;
++
++}
++
++
++
++
++
++
++static int
++check_tuner_type(
++ struct rtl2832_state *p_state)
++{
++ MT2266_EXTRA_MODULE *p_mt2266_extra;
++ unsigned char tuner_id_data[2];
++
++
++ if ((!read_tuner_id_register(p_state, MT2266_TUNER_ADDR, MT2266_OFFSET, tuner_id_data, LEN_1_BYTE)) &&
++ ( tuner_id_data[0] == MT2266_CHECK_VAL ))
++ {
++ p_state->tuner_type = RTL2832_TUNER_TYPE_MT2266;
++ }
++ else
++ {
++ if ((!read_tuner_id_register(p_state, FC2580_TUNER_ADDR, FC2580_OFFSET, tuner_id_data, LEN_1_BYTE)) &&
++ ((tuner_id_data[0]&(~BIT7)) == FC2580_CHECK_VAL ))
++ {
++ p_state->tuner_type = RTL2832_TUNER_TYPE_FC2580;
++ }
++ else
++ {
++ if ((!read_tuner_id_register(p_state, TUA9001_TUNER_ADDR, TUA9001_OFFSET, tuner_id_data, LEN_2_BYTE)) &&
++ (((tuner_id_data[0]<<8)|tuner_id_data[1]) == TUA9001_CHECK_VAL ))
++ {
++ p_state->tuner_type = RTL2832_TUNER_TYPE_TUA9001;
++
++ }
++ else
++ {
++ unsigned char chip_version;
++ if ((!check_mxl5007t_chip_version(p_state, &chip_version)) &&
++ (chip_version == MXL5007T_CHECK_VALUE) )
++ {
++ p_state->tuner_type = RTL2832_TUNER_TYPE_MXL5007T;
++ }
++ else
++ {
++
++ p_state->tuner_type = RTL2832_TUNER_TYPE_UNKNOWN;
++ }
++ }
++ }
++
++ }
++
++
++ if( p_state->tuner_type == RTL2832_TUNER_TYPE_MT2266)
++ {
++ //3 Build RTL2832 MT2266 NIM module.
++ BuildRtl2832Mt2266Module(
++ &p_state->pNim,
++ &p_state->DvbtNimModuleMemory,
++ &p_state->Rtl2832Mt2266ExtraModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ NULL,//custom_i2c_read, // Employ CustomI2cRead() as basic I2C reading function.
++ NULL,//custom_i2c_write, // Employ CustomI2cWrite() as basic I2C writing function.
++ custom_wait_ms, // Employ CustomWaitMs() as basic waiting function.
++
++ &p_state->Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ RTL2832_DEMOD_ADDR, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_DONGLE, // The RTL2832 application mode is STB mode.
++ TS_INTERFACE_PARALLEL,
++ 200, // The RTL2832 update function reference period is 200 millisecond
++ OFF, // The RTL2832 Function 1 enabling status is on.
++
++ &p_state->Mt2266ExtraModuleMemory, // Employ MT2266 extra module for MT2266 module.
++ MT2266_TUNER_ADDR // The MT2266 I2C device address is 0xc0 in 8-bit format.
++ );
++
++ p_mt2266_extra = (MT2266_EXTRA_MODULE *)(p_state->pNim->pTuner->pExtra);
++
++ if(p_mt2266_extra->OpenHandle(p_state->pNim->pTuner))
++ deb_info("%s : MT2266 Open Handle Failed....\n", __FUNCTION__);
++ p_state->is_mt2266_nim_module_built = 1;
++
++ deb_info("%s : MT2266 tuner on board...\n", __FUNCTION__);
++ }
++ else if( p_state->tuner_type == RTL2832_TUNER_TYPE_FC2580)
++ {
++
++ //3Build RTL2832 FC2580 NIM module.
++ BuildRtl2832Fc2580Module(
++ &p_state->pNim,
++ &p_state->DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ NULL,//custom_i2c_read, // Employ CustomI2cRead() as basic I2C reading function.
++ NULL,//custom_i2c_write, // Employ CustomI2cWrite() as basic I2C writing function.
++ custom_wait_ms, // Employ CustomWaitMs() as basic waiting function.
++
++ &p_state->Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ RTL2832_DEMOD_ADDR, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_DONGLE, // The RTL2832 application mode is STB mode.
++ TS_INTERFACE_PARALLEL,
++ 200, // The RTL2832 update function reference period is 200 millisecond
++ OFF, // The RTL2832 Function 1 enabling status is on.
++
++ &p_state->Fc2580ExtraModuleMemory, // Employ FC2580 extra module for FC2580 module.
++ FC2580_TUNER_ADDR, // The FC2580 I2C device address is 0xac in 8-bit format.
++ CRYSTAL_FREQ_16384000HZ, // The FC2580 crystal frequency is 16.384 MHz.
++ FC2580_AGC_INTERNAL // The FC2580 AGC mode is external AGC mode.
++ );
++
++ deb_info("%s : FC2580 tuner on board...\n", __FUNCTION__);
++ }
++ else if( p_state->tuner_type == RTL2832_TUNER_TYPE_TUA9001)
++ {
++
++ //3Build RTL2832 TUA9001 NIM module.
++ BuildRtl2832Tua9001Module(
++ &p_state->pNim,
++ &p_state->DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ NULL,//custom_i2c_read, // Employ CustomI2cRead() as basic I2C reading function.
++ NULL,//custom_i2c_write, // Employ CustomI2cWrite() as basic I2C writing function.
++ custom_wait_ms, // Employ CustomWaitMs() as basic waiting function.
++
++ &p_state->Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ RTL2832_DEMOD_ADDR, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_DONGLE, // The RTL2832 application mode is STB mode.
++ TS_INTERFACE_PARALLEL,
++ 200, // The RTL2832 update function reference period is 200 millisecond
++ OFF, // The RTL2832 Function 1 enabling status is on.
++
++ &p_state->TUA9001ExtraModuleMemory, // Employ TUA9001 extra module for FC2580 module.
++ TUA9001_TUNER_ADDR // The TUA9001 I2C device address is 0xc0 in 8-bit format.
++ );
++
++ deb_info("%s : TUA9001 tuner on board...\n", __FUNCTION__);
++ }
++ else if( p_state->tuner_type == RTL2832_TUNER_TYPE_MXL5007T)
++ {
++
++ //3Build RTL2832 MXL5007 NIM module.
++ BuildRtl2832Mxl5007tModule(
++ &p_state->pNim,
++ &p_state->DvbtNimModuleMemory,
++
++ 9, // Maximum I2C reading byte number is 9.
++ 8, // Maximum I2C writing byte number is 8.
++ custom_i2c_read, // Employ CustomI2cRead() as basic I2C reading function.
++ custom_i2c_write, // Employ CustomI2cWrite() as basic I2C writing function.
++ custom_wait_ms, // Employ CustomWaitMs() as basic waiting function.
++
++ &p_state->Rtl2832ExtraModuleMemory, // Employ RTL2832 extra module for RTL2832 module.
++ RTL2832_DEMOD_ADDR, // The RTL2832 I2C device address is 0x20 in 8-bit format.
++ CRYSTAL_FREQ_28800000HZ, // The RTL2832 crystal frequency is 28.8 MHz.
++ RTL2832_APPLICATION_DONGLE, // The RTL2832 application mode is STB mode.
++ TS_INTERFACE_PARALLEL,
++ 200, // The RTL2832 update function reference period is 200 millisecond
++ OFF, // The RTL2832 Function 1 enabling status is on.
++
++ &p_state->MXL5007TExtraModuleMemory, // Employ MxL5007T extra module for MxL5007T module.
++ MXL5007T_BASE_ADDRESS, // The MxL5007T I2C device address is 0xc0 in 8-bit format.
++ CRYSTAL_FREQ_16000000HZ, // The MxL5007T Crystal frequency is 16.0 MHz.
++ MXL5007T_CLK_OUT_DISABLE, // The MxL5007T clock output mode is disabled.
++ MXL5007T_CLK_OUT_AMP_0 // The MxL5007T clock output amplitude is 0.
++ );
++
++ deb_info("%s : MXL5007T tuner on board...\n", __FUNCTION__);
++ }
++ else
++ {
++ deb_info("%s : Unknown tuner on board...\n", __FUNCTION__);
++ goto error;
++ }
++
++ // Set user defined data pointer of base interface structure for custom basic functions.
++ p_state->pNim->pBaseInterface->SetUserDefinedDataPointer(p_state->pNim->pBaseInterface, p_state->d );
++
++
++ return 0;
++error:
++ return 1;
++}
++
++static int
++gpio1_output_enable_direction(
++ struct rtl2832_state* p_state)
++{
++ int data;
++ // GPD_GPIO1=0, GPIO1 output direction
++ data = 0;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT1,data) ) goto error;
++
++ // GPOE_GPIO1=1, GPIO1 output enable
++ data = 1;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT1,data) ) goto error;
++
++ return 0;
++error:
++ return 1;
++}
++
++
++static int
++gpio6_output_enable_direction(
++ struct rtl2832_state* p_state)
++{
++ int data;
++ // GPD_GPIO6=0, GPIO6 output direction
++ data = 0;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT6,data) ) goto error;
++
++ // GPOE_GPIO6=1, GPIO6 output enable
++ data = 1;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT6,data) ) goto error;
++
++ return 0;
++error:
++ return 1;
++}
++
++
++
++
++static int
++check_reset_parameters(
++ struct rtl2832_state* p_state,
++ unsigned long frequency,
++ enum fe_bandwidth bandwidth,
++ int* reset_needed)
++{
++
++ int is_lock;
++ unsigned int diff_ms;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++ *reset_needed = 1; //3initialize "reset_needed"
++
++ if( (p_state->current_frequency == frequency) && (p_state->current_bandwidth == bandwidth) )
++ {
++ if( p_state->pNim->IsSignalLocked(p_state->pNim, &is_lock) ) goto error;
++ diff_ms = 0;
++
++ while( !(is_lock == LOCKED || diff_ms > 200) )
++ {
++ platform_wait(40);
++ diff_ms += 40;
++ if( p_state->pNim->IsSignalLocked(p_state->pNim, &is_lock) ) goto error;
++ }
++
++ if (is_lock==YES)
++ {
++ *reset_needed = 0; //3 set "reset_needed" = 0
++ deb_info("%s : The same frequency = %d setting\n", __FUNCTION__, (int)frequency);
++ }
++ }
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ return 0;
++
++error:
++
++ *reset_needed = 1; //3 set "reset_needed" = 1
++ return 1;
++}
++
++
++/*
++void
++rtl2832_update_functions(struct work_struct *work)
++{
++ struct rtl2832_state* p_state = container_of( work , struct rtl2832_state , update_procedure_work.work);
++ unsigned long ber_num, ber_dem;
++ long snr_num = 0;
++ long snr_dem = 0;
++ long _snr= 0;
++
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ deb_info("+%s\n", __FUNCTION__);
++
++ p_state->pNim->UpdateFunction(p_state->pNim);
++ p_state->pNim->GetBer( p_state->pNim , &ber_num , &ber_dem);
++ p_state->pNim->GetSnrDb(p_state->pNim, &snr_num, &snr_dem) ;
++
++ _snr = snr_num / snr_dem;
++ if( _snr < 0 ) _snr = 0;
++
++ deb_info("-%s : ber = %lu, snr = %lu\n", __FUNCTION__,ber_num,_snr);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ schedule_delayed_work(&p_state->update_procedure_work,UPDATE_PROCEDURE_PERIOD);
++
++ return;
++
++mutex_error:
++ return;
++
++}
++
++*/
++
++
++static int
++rtl2832_init(
++ struct dvb_frontend* fe)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ deb_info(" +%s\n", __FUNCTION__);
++
++ //usb_reset_device(p_state->d->udev);
++
++ if( usb_init_setting(p_state) ) goto error;
++
++ if( gpio3_out_setting(p_state) ) goto error; //3Set GPIO3 OUT
++
++ if( demod_ctl1_setting(p_state , 1) ) goto error; //3 DEMOD_CTL1, resume = 1
++
++ if( set_demod_power(p_state , 1) ) goto error; //3 turn ON demod power
++
++ if( suspend_latch_setting(p_state , 1) ) goto error; //3 suspend_latch_en = 0, resume = 1
++
++ if( demod_ctl_setting(p_state , 1) ) goto error; //3 DEMOD_CTL, resume =1
++
++ //3 Auto detect Tuner Power Pin (GPIO3 or GPIO4)
++ if( set_tuner_power(p_state , 0 , 1) ) goto error; //3 turn ON tuner power, 1st try GPIO3
++
++ if( check_tuner_type(p_state) )
++ {
++ if(p_state->tuner_type == RTL2832_TUNER_TYPE_UNKNOWN)
++ {
++ if( set_tuner_power(p_state , 0 , 0) ) goto error; //3recover GPIO3 setting at 1st try
++ if( set_tuner_power(p_state , 1 , 1) ) goto error; //3 2nd try GPIO4
++ if( check_tuner_type(p_state) ) goto error;
++
++ p_state->pNim->pTuner->b_set_tuner_power_gpio4 = 1; //4 Tuner Power Pin : GPIO4
++ }
++ else
++ {
++ goto error;
++ }
++ }
++ else
++ {
++ p_state->pNim->pTuner->b_set_tuner_power_gpio4 = 0; //4 Tuner Power Pin : GPIO3
++ }
++
++
++ if( p_state->tuner_type == RTL2832_TUNER_TYPE_TUA9001)
++ {
++ if( gpio1_output_enable_direction(p_state) ) goto error;
++ }
++ else if( p_state->tuner_type == RTL2832_TUNER_TYPE_MXL5007T)
++ {
++ //3 MXL5007T : Set GPIO6 OUTPUT_EN & OUTPUT_DIR & OUTPUT_VAL for YUAN
++ int data;
++ if( gpio6_output_enable_direction(p_state) ) goto error;
++
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL, &data) ) goto error;
++ data |= BIT6;
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL,data) ) goto error;
++
++ }
++
++
++ //3 Nim initialize
++ if ( p_state->pNim->Initialize(p_state->pNim) ) goto error;
++
++ p_state->is_initial = 1;
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ //schedule_delayed_work(&(p_state->update_procedure_work), 0); //3 Initialize update function
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++ deb_info(" -%s error end\n", __FUNCTION__);
++
++ return -1;
++}
++
++
++static void
++rtl2832_release(
++ struct dvb_frontend* fe)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ MT2266_EXTRA_MODULE* p_mt2266_extra;
++
++ if( p_state->pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return;
++ }
++
++ if( p_state->is_mt2266_nim_module_built)
++ {
++ p_mt2266_extra = (MT2266_EXTRA_MODULE *)(p_state->pNim->pTuner->pExtra);
++ p_mt2266_extra->CloseHandle(p_state->pNim->pTuner);
++ p_state->is_mt2266_nim_module_built = 0;
++ }
++
++ if(p_state->is_initial)
++ {
++ // cancel_rearming_delayed_work( &(p_state->update_procedure_work) );
++ // flush_scheduled_work();
++ p_state->is_initial = 0;
++ }
++
++ kfree(p_state);
++
++ deb_info(" %s \n", __FUNCTION__);
++
++ return;
++}
++
++
++
++static int
++rtl2832_sleep(
++ struct dvb_frontend* fe)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ MT2266_EXTRA_MODULE* p_mt2266_extra;
++ DVBT_DEMOD_MODULE *pDemod;
++ DVBT_NIM_MODULE *pNim;
++ int data;
++
++// int page_no, addr_no;
++// unsigned char reg_value;
++
++
++ pNim = p_state->pNim;
++ pDemod = pNim->pDemod;
++
++ if( pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return -1;
++ }
++
++ if( p_state->is_mt2266_nim_module_built)
++ {
++ p_mt2266_extra = (MT2266_EXTRA_MODULE *)(p_state->pNim->pTuner->pExtra);
++ p_mt2266_extra->CloseHandle(p_state->pNim->pTuner);
++ p_state->is_mt2266_nim_module_built = 0;
++ }
++
++ if( p_state->is_initial )
++ {
++
++ // cancel_rearming_delayed_work( &(p_state->update_procedure_work) );
++ // flush_scheduled_work();
++ p_state->is_initial = 0;
++ }
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ deb_info(" +%s \n", __FUNCTION__);
++
++#if 0
++ //2 For debug
++ for( page_no = 0; page_no < 3; page_no++ )
++ {
++ pDemod->SetRegPage(pDemod, page_no);
++ for( addr_no = 0; addr_no < 256; addr_no++ )
++ {
++ pDemod->GetRegBytes(pDemod, addr_no, ®_value, 1);
++ printk("0x%x, 0x%x, 0x%x\n", page_no, addr_no, reg_value);
++ }
++ }
++#endif
++
++ if( p_state->tuner_type == RTL2832_TUNER_TYPE_MXL5007T)
++ {
++ //3 MXL5007T : Set GPIO6 OUTPUT_VAL OFF for YUAN
++ if ( read_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL, &data) ) goto error;
++ data &= (~BIT6);
++ if ( write_usb_sys_register(p_state, RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL,data) ) goto error;
++
++ }
++
++
++ if( demod_ctl1_setting(p_state , 0) ) goto error; //3 DEMOD_CTL1, resume = 0
++
++ if( set_tuner_power(p_state, p_state->pNim->pTuner->b_set_tuner_power_gpio4, 0) ) goto error; //3 turn OFF tuner power
++
++ if( demod_ctl_setting(p_state , 0) ) goto error; //3 DEMOD_CTL, resume =0
++ //2 for H/W reason
++ //if( suspend_latch_setting(p_state , 0) ) goto error; //3 suspend_latch_en = 1, resume = 0
++
++ //if( set_demod_power(p_state , 0) ) goto error; //3 turn OFF demod power
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++
++ return 1;
++}
++
++
++
++
++
++static int
++rtl2832_set_parameters(
++ struct dvb_frontend* fe,
++ struct dvb_frontend_parameters* param)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ struct dvb_ofdm_parameters* p_ofdm_param= ¶m->u.ofdm;
++ unsigned long frequency = param->frequency;
++ int bandwidth_mode;
++ int is_signal_present;
++ int reset_needed;
++
++
++ if( p_state->pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return -1;
++ }
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ deb_info(" +%s frequency = %lu , bandwidth = %u\n", __FUNCTION__, frequency ,p_ofdm_param->bandwidth);
++
++ if ( check_reset_parameters( p_state , frequency , p_ofdm_param->bandwidth, &reset_needed) ) goto error;
++ if( reset_needed == 0 )
++ {
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++ return 0;
++ }
++
++
++ switch (p_ofdm_param->bandwidth)
++ {
++ case BANDWIDTH_6_MHZ:
++ bandwidth_mode = DVBT_BANDWIDTH_6MHZ;
++ break;
++
++ case BANDWIDTH_7_MHZ:
++ bandwidth_mode = DVBT_BANDWIDTH_7MHZ;
++ break;
++
++ case BANDWIDTH_8_MHZ:
++ default:
++ bandwidth_mode = DVBT_BANDWIDTH_8MHZ;
++ break;
++ }
++
++ if ( p_state->pNim->SetParameters( p_state->pNim, frequency , bandwidth_mode ) ) goto error;
++
++
++ if ( p_state->pNim->IsSignalPresent( p_state->pNim, &is_signal_present) ) goto error;
++
++ deb_info(" %s : ****** Signal Present = %d ******\n", __FUNCTION__, is_signal_present);
++
++ p_state->current_frequency = frequency;
++ p_state->current_bandwidth = p_ofdm_param->bandwidth;
++
++ deb_info(" -%s \n", __FUNCTION__);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++ p_state->current_frequency = 0;
++ p_state->current_bandwidth = -1;
++ deb_info(" -%s error end\n", __FUNCTION__);
++
++ return -1;
++
++}
++
++
++
++static int
++rtl2832_get_parameters(
++ struct dvb_frontend* fe,
++ struct dvb_frontend_parameters* param)
++{
++ //struct rtl2832_state* p_state = fe->demodulator_priv;
++ return 0;
++}
++
++
++static int
++rtl2832_read_status(
++ struct dvb_frontend* fe,
++ fe_status_t* status)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ int is_lock;
++ unsigned long ber_num, ber_dem;
++ long snr_num, snr_dem, snr;
++
++
++ if( p_state->pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return -1;
++ }
++
++ *status = 0; //3initialize "status"
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ if( p_state->pNim->GetBer( p_state->pNim , &ber_num , &ber_dem) ) goto error;
++
++ if (p_state->pNim->GetSnrDb(p_state->pNim, &snr_num, &snr_dem) ) goto error;
++
++ if( p_state->pNim->IsSignalLocked(p_state->pNim, &is_lock) ) goto error;
++
++
++ if( is_lock==YES ) *status|= (FE_HAS_CARRIER| FE_HAS_VITERBI| FE_HAS_LOCK| FE_HAS_SYNC| FE_HAS_SIGNAL);
++
++ snr = snr_num/snr_dem;
++
++ deb_info("%s :******Signal Lock=%d******\n", __FUNCTION__, is_lock);
++ deb_info("%s : ber = 0x%x \n", __FUNCTION__, (unsigned int)ber_num);
++ deb_info("%s : snr = 0x%x \n", __FUNCTION__, (int)snr);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++ return -1;
++}
++
++
++
++static int
++rtl2832_read_ber(
++ struct dvb_frontend* fe,
++ u32* ber)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ unsigned long ber_num, ber_dem;
++
++ if( p_state->pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return -1;
++ }
++
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ if( p_state->pNim->GetBer( p_state->pNim , &ber_num , &ber_dem) )
++ {
++ *ber = 19616;
++ goto error;
++ }
++
++ *ber = ber_num;
++
++ deb_info(" %s : ber = 0x%x \n", __FUNCTION__, *ber);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++ return -1;
++}
++
++
++static int
++rtl2832_read_signal_strength(
++ struct dvb_frontend* fe,
++ u16* strength)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ unsigned long _strength;
++
++ if( p_state->pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return -1;
++ }
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ if( p_state->pNim->GetSignalStrength( p_state->pNim , &_strength) )
++ {
++ *strength = 0;
++ goto error;
++ }
++
++ *strength = (_strength<<8) | _strength;
++
++ deb_info(" %s : strength = 0x%x \n", __FUNCTION__, *strength);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++ return -1;
++}
++
++
++static int
++rtl2832_read_signal_quality(
++ struct dvb_frontend* fe,
++ u32* quality)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ unsigned long _quality;
++
++ if( p_state->pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return -1;
++ }
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ if ( p_state->pNim->GetSignalQuality( p_state->pNim , &_quality) )
++ {
++ *quality = 0;
++ goto error;
++ }
++
++ *quality = _quality;
++
++ deb_info(" %s : quality = 0x%x \n", __FUNCTION__, *quality);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++ return -1;
++}
++
++
++
++static int
++rtl2832_read_snr(
++ struct dvb_frontend* fe,
++ u16* snr)
++{
++ struct rtl2832_state* p_state = fe->demodulator_priv;
++ long snr_num = 0;
++ long snr_dem = 0;
++ long _snr= 0;
++
++ if( p_state->pNim== NULL)
++ {
++ deb_info(" %s pNim = NULL \n", __FUNCTION__);
++ return -1;
++ }
++
++ if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) goto mutex_error;
++
++ if (p_state->pNim->GetSnrDb(p_state->pNim, &snr_num, &snr_dem) )
++ {
++ *snr = 0;
++ goto error;
++ }
++
++ _snr = snr_num / snr_dem;
++
++ if( _snr < 0 ) _snr = 0;
++
++ *snr = _snr;
++
++ deb_info(" %s : snr = 0x%x \n", __FUNCTION__, *snr);
++
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++ return 0;
++
++error:
++ mutex_unlock(&p_state->i2c_repeater_mutex);
++
++mutex_error:
++ return -1;
++}
++
++
++
++static int
++rtl2832_get_tune_settings(
++ struct dvb_frontend* fe,
++ struct dvb_frontend_tune_settings* fe_tune_settings)
++{
++ deb_info(" %s : Do Nothing\n", __FUNCTION__);
++ fe_tune_settings->min_delay_ms = 1000;
++ return 0;
++}
++
++
++static int
++rtl2832_ts_bus_ctrl(
++ struct dvb_frontend* fe,
++ int acquire)
++{
++ deb_info(" %s : Do Nothing\n", __FUNCTION__);
++ return 0;
++}
++
++
++
++
++static struct dvb_frontend_ops rtl2832_ops;
++
++struct dvb_frontend* rtl2832u_fe_attach(struct dvb_usb_device *d)
++{
++
++ struct rtl2832_state* p_state= NULL;
++
++
++ deb_info("+%s\n", __FUNCTION__);
++
++ //3 linux fe_attach necessary setting
++ /*allocate memory for the internal state */
++ p_state = kzalloc(sizeof(struct rtl2832_state), GFP_KERNEL);
++ if (p_state == NULL) goto error;
++ memset(p_state,0,sizeof(*p_state));
++
++ p_state->is_mt2266_nim_module_built = 0; //initialize is_mt2266_nim_module_built
++ p_state->is_initial = 0; //initialize is_initial
++
++ p_state->d = d;
++
++ /* setup the state */
++ memcpy(&p_state->frontend.ops, &rtl2832_ops, sizeof(struct dvb_frontend_ops));
++ memset(&p_state->fep, 0, sizeof(struct dvb_frontend_parameters));
++
++ /* create dvb_frontend */
++ p_state->frontend.demodulator_priv = p_state;
++
++// INIT_DELAYED_WORK( &(p_state->update_procedure_work), rtl2832_update_functions);
++ mutex_init(&p_state->i2c_repeater_mutex);
++
++ deb_info("-%s\n", __FUNCTION__);
++ return &p_state->frontend;
++
++error:
++ return NULL;
++
++
++}
++
++
++
++static struct dvb_frontend_ops rtl2832_ops = {
++ .info = {
++ .name = "Realtek RTL2832 DVB-T",
++ .type = FE_OFDM,
++ .frequency_min = 174000000,
++ .frequency_max = 862000000,
++ .frequency_stepsize = 166667,
++ .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
++ FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
++ FE_CAN_FEC_AUTO |
++ FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
++ FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
++ FE_CAN_HIERARCHY_AUTO | FE_CAN_RECOVER |
++ FE_CAN_MUTE_TS
++ },
++
++ .init = rtl2832_init,
++ .release = rtl2832_release,
++
++ .sleep = rtl2832_sleep,
++
++ .set_frontend = rtl2832_set_parameters,
++ .get_frontend = rtl2832_get_parameters,
++ .get_tune_settings = rtl2832_get_tune_settings,
++
++ .read_status = rtl2832_read_status,
++ .read_ber = rtl2832_read_ber,
++ .read_signal_strength = rtl2832_read_signal_strength,
++ .read_snr = rtl2832_read_snr,
++ .read_ucblocks = rtl2832_read_signal_quality,
++ .ts_bus_ctrl = rtl2832_ts_bus_ctrl,
++};
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/rtl2832u_fe.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/rtl2832u_fe.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,207 @@
++
++#ifndef __RTL2832U_FE_H__
++#define __RTL2832U_FE_H__
++
++#include "nim_rtl2832_tua9001.h"
++#include "nim_rtl2832_mt2266.h"
++#include "nim_rtl2832_fc2580.h"
++#include "nim_rtl2832_mxl5007t.h"
++#include "rtl2832u_io.h"
++
++
++
++typedef enum{
++ RTL2832_TUNER_TYPE_MT2266 = 0,
++ RTL2832_TUNER_TYPE_FC2580,
++ RTL2832_TUNER_TYPE_TUA9001,
++ RTL2832_TUNER_TYPE_MXL5007T,
++ RTL2832_TUNER_TYPE_UNKNOWN,
++}RTL2832_TUNER_TYPE;
++
++
++
++struct rtl2832_state {
++ struct dvb_frontend frontend;
++ struct dvb_frontend_parameters fep;
++ struct dvb_usb_device* d;
++
++ struct mutex i2c_repeater_mutex;
++
++ unsigned long current_frequency;
++ enum fe_bandwidth current_bandwidth;
++
++ RTL2832_TUNER_TYPE tuner_type;
++ unsigned char is_mt2266_nim_module_built; //3 For close MT handle
++
++ //3if init() is called, is_initial is true ->check it to see if need to flush work queue
++ unsigned short is_initial;
++ //struct delayed_work update_procedure_work;
++
++ DVBT_NIM_MODULE* pNim;
++ DVBT_NIM_MODULE DvbtNimModuleMemory;
++ RTL2832_EXTRA_MODULE Rtl2832ExtraModuleMemory;
++ MT2266_EXTRA_MODULE Mt2266ExtraModuleMemory;
++ FC2580_EXTRA_MODULE Fc2580ExtraModuleMemory;
++ TUA9001_EXTRA_MODULE TUA9001ExtraModuleMemory;
++ MXL5007T_EXTRA_MODULE MXL5007TExtraModuleMemory;
++ RTL2832_MT2266_EXTRA_MODULE Rtl2832Mt2266ExtraModuleMemory;
++
++
++};
++
++
++
++#define RTL2832_DEMOD_ADDR 0x20
++#define MT2266_TUNER_ADDR 0xc0
++#define FC2580_TUNER_ADDR 0xac
++#define TUA9001_TUNER_ADDR 0xc0
++
++#define MT2266_OFFSET 0x00
++#define MT2266_CHECK_VAL 0x85
++
++#define FC2580_OFFSET 0x01
++#define FC2580_CHECK_VAL 0x56
++
++#define TUA9001_OFFSET 0x7e
++#define TUA9001_CHECK_VAL 0x2328
++
++#define MXL5007T_BASE_ADDRESS 0xc0
++#define MXL5007T_CHECK_ADDRESS 0xD9
++#define MXL5007T_CHECK_VALUE 0x14
++
++
++
++
++
++struct rtl2832_reg_addr{
++ RegType reg_type;
++ unsigned short reg_addr;
++ int bit_low;
++ int bit_high;
++};
++
++
++
++typedef enum{
++ RTD2831_RMAP_INDEX_USB_CTRL_BIT5 =0,
++ RTD2831_RMAP_INDEX_USB_STAT,
++ RTD2831_RMAP_INDEX_USB_EPA_CTL,
++ RTD2831_RMAP_INDEX_USB_SYSCTL,
++ RTD2831_RMAP_INDEX_USB_EPA_CFG,
++ RTD2831_RMAP_INDEX_USB_EPA_MAXPKT,
++ RTD2831_RMAP_INDEX_USB_EPA_FIFO_CFG,
++
++ RTD2831_RMAP_INDEX_SYS_DEMOD_CTL,
++ RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_VAL,
++ RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT3,
++ RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT3,
++ RTD2831_RMAP_INDEX_SYS_GPIO_CFG0_BIT67,
++ RTD2831_RMAP_INDEX_SYS_DEMOD_CTL1,
++ RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT1,
++ RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT1,
++ RTD2831_RMAP_INDEX_SYS_GPIO_OUTPUT_EN_BIT6,
++ RTD2831_RMAP_INDEX_SYS_GPIO_DIR_BIT6,
++#if 0
++ RTD2831_RMAP_INDEX_SYS_GPD,
++ RTD2831_RMAP_INDEX_SYS_GPOE,
++ RTD2831_RMAP_INDEX_SYS_GPO,
++ RTD2831_RMAP_INDEX_SYS_SYS_0,
++#endif
++
++} rtl2832_reg_map_index;
++
++
++
++#define USB_SYSCTL 0x0000
++#define USB_CTRL 0x0010
++#define USB_STAT 0x0014
++#define USB_EPA_CTL 0x0148
++#define USB_EPA_CFG 0x0144
++#define USB_EPA_MAXPKT 0x0158
++#define USB_EPA_FIFO_CFG 0x0160
++
++#define DEMOD_CTL 0x0000
++#define GPIO_OUTPUT_VAL 0x0001
++#define GPIO_OUTPUT_EN 0x0003
++#define GPIO_DIR 0x0004
++#define GPIO_CFG0 0x0007
++#define GPIO_CFG1 0x0008
++#define DEMOD_CTL1 0x000b
++
++
++static int rtl2832_reg_mask[32]= {
++ 0x00000001,
++ 0x00000003,
++ 0x00000007,
++ 0x0000000f,
++ 0x0000001f,
++ 0x0000003f,
++ 0x0000007f,
++ 0x000000ff,
++ 0x000001ff,
++ 0x000003ff,
++ 0x000007ff,
++ 0x00000fff,
++ 0x00001fff,
++ 0x00003fff,
++ 0x00007fff,
++ 0x0000ffff,
++ 0x0001ffff,
++ 0x0003ffff,
++ 0x0007ffff,
++ 0x000fffff,
++ 0x001fffff,
++ 0x003fffff,
++ 0x007fffff,
++ 0x00ffffff,
++ 0x01ffffff,
++ 0x03ffffff,
++ 0x07ffffff,
++ 0x0fffffff,
++ 0x1fffffff,
++ 0x3fffffff,
++ 0x7fffffff,
++ 0xffffffff
++};
++
++
++
++
++#define BIT0 0x00000001
++#define BIT1 0x00000002
++#define BIT2 0x00000004
++#define BIT3 0x00000008
++#define BIT4 0x00000010
++#define BIT5 0x00000020
++#define BIT6 0x00000040
++#define BIT7 0x00000080
++#define BIT8 0x00000100
++#define BIT9 0x00000200
++#define BIT10 0x00000400
++#define BIT11 0x00000800
++#define BIT12 0x00001000
++#define BIT13 0x00002000
++#define BIT14 0x00004000
++#define BIT15 0x00008000
++#define BIT16 0x00010000
++#define BIT17 0x00020000
++#define BIT18 0x00040000
++#define BIT19 0x00080000
++#define BIT20 0x00100000
++#define BIT21 0x00200000
++#define BIT22 0x00400000
++#define BIT23 0x00800000
++#define BIT24 0x01000000
++#define BIT25 0x02000000
++#define BIT26 0x04000000
++#define BIT27 0x08000000
++#define BIT28 0x10000000
++#define BIT29 0x20000000
++#define BIT30 0x40000000
++#define BIT31 0x80000000
++
++
++
++#endif // __RTD2830_PRIV_H__
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/rtl2832u_io.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/rtl2832u_io.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,635 @@
++
++
++#include "rtl2832u_io.h"
++#include <linux/time.h>
++
++#define ERROR_TRY_MAX_NUM 4
++
++
++
++void
++platform_wait(
++ unsigned long nMinDelayTime)
++{
++ // The unit of Sleep() waiting time is millisecond.
++ unsigned long usec;
++ do {
++ usec = (nMinDelayTime > 8000) ? 8000 : nMinDelayTime;
++ msleep(usec);
++ nMinDelayTime -= usec;
++ } while (nMinDelayTime > 0);
++
++ return;
++
++}
++
++
++
++
++
++static int
++read_usb_register(
++ struct dvb_usb_device* dib,
++ unsigned short offset,
++ unsigned char* data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_rcvctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_IN, /* USB message request type value */
++ (USB_BASE_ADDRESS<<8) + offset, /* USB message value */
++ 0x0100, /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ if (ret != bytelength)
++ {
++ deb_info(" %s: offset=0x%x, error code=0x%x !\n", __FUNCTION__, offset, ret);
++ return 1;
++ }
++
++ return 0;
++}
++
++
++
++static int
++write_usb_register(
++ struct dvb_usb_device* dib,
++ unsigned short offset,
++ unsigned char* data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++ unsigned char try_num;
++
++ try_num = 0;
++error_write_again:
++ try_num++;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_sndctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_OUT, /* USB message request type value */
++ (USB_BASE_ADDRESS<<8) + offset, /* USB message value */
++ 0x0110, /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ if (ret != bytelength)
++ {
++ deb_info("error try = %d, %s: offset=0x%x, error code=0x%x !\n",try_num ,__FUNCTION__, offset, ret);
++
++ if( try_num > ERROR_TRY_MAX_NUM ) goto error;
++ else goto error_write_again;
++ }
++
++ return 0;
++error:
++ return 1;
++ }
++
++
++
++
++static int
++read_sys_register(
++ struct dvb_usb_device* dib,
++ unsigned short offset,
++ unsigned char* data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_rcvctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_IN, /* USB message request type value */
++ (SYS_BASE_ADDRESS<<8) + offset, /* USB message value */
++ 0x0200, /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ if (ret != bytelength)
++ {
++ deb_info(" %s: offset=0x%x, error code=0x%x !\n", __FUNCTION__, offset, ret);
++ return 1;
++ }
++
++ return 0;
++
++ }
++
++
++static int
++write_sys_register(
++ struct dvb_usb_device* dib,
++ unsigned short offset,
++ unsigned char* data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++ unsigned char try_num;
++
++ try_num = 0;
++error_write_again:
++ try_num++;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_sndctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_OUT, /* USB message request type value */
++ (SYS_BASE_ADDRESS<<8) + offset, /* USB message value */
++ 0x0210, /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ if (ret != bytelength)
++ {
++ deb_info(" error try= %d, %s: offset=0x%x, error code=0x%x !\n",try_num, __FUNCTION__, offset, ret);
++ if( try_num > ERROR_TRY_MAX_NUM ) goto error;
++ else goto error_write_again;
++ }
++
++ return 0;
++error:
++ return 1;
++ }
++
++
++
++
++int
++read_rtl2832_demod_register(
++ struct dvb_usb_device*dib,
++ unsigned char demod_device_addr,
++ unsigned char page,
++ unsigned char offset,
++ unsigned char* data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++ int i;
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) goto error;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_rcvctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_IN, /* USB message request type value */
++ demod_device_addr + (offset<<8), /* USB message value */
++ (0x0000 + page), /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ mutex_unlock(&dib->usb_mutex);
++
++
++// deb_info("%s: ret=%d, DA=0x%x, len=%d, page=%d, offset=0x%x, data=(", __FUNCTION__, ret, demod_device_addr, bytelength,page, offset);
++// for(i = 0; i < bytelength; i++)
++// deb_info("0x%x,", data[i]);
++// deb_info(")\n");
++
++ if (ret != bytelength)
++ {
++ deb_info("error!! %s: ret=%d, DA=0x%x, len=%d, page=%d, offset=0x%x, data=(", __FUNCTION__, ret, demod_device_addr, bytelength,page, offset);
++ for(i = 0; i < bytelength; i++)
++ deb_info("0x%x,", data[i]);
++ deb_info(")\n");
++
++ goto error;
++ }
++
++ return 0;
++
++error:
++ return 1;
++}
++
++
++
++
++int
++write_rtl2832_demod_register(
++ struct dvb_usb_device*dib,
++ unsigned char demod_device_addr,
++ unsigned char page,
++ unsigned char offset,
++ unsigned char *data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++ unsigned char i, try_num;
++
++ try_num = 0;
++error_write_again:
++ try_num++;
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) goto error;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_sndctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_OUT, /* USB message request type value */
++ demod_device_addr + (offset<<8), /* USB message value */
++ (0x0010 + page), /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ mutex_unlock(&dib->usb_mutex);
++
++// deb_info("%s: ret=%d, DA=0x%x, len=%d, page=%d, offset=0x%x, data=(", __FUNCTION__, ret, demod_device_addr, bytelength, page,offset);
++// for(i = 0; i < bytelength; i++)
++// deb_info("0x%x,", data[i]);
++// deb_info(")\n");
++
++
++ if (ret != bytelength)
++ {
++ deb_info("error try = %d!! %s: ret=%d, DA=0x%x, len=%d, page=%d, offset=0x%x, data=(",try_num , __FUNCTION__, ret, demod_device_addr, bytelength,page,offset);
++ for(i = 0; i < bytelength; i++)
++ deb_info("0x%x,", data[i]);
++ deb_info(")\n");
++
++ if( try_num > ERROR_TRY_MAX_NUM ) goto error;
++ else goto error_write_again;
++ }
++
++ return 0;
++
++error:
++ return 1;
++ }
++
++
++
++
++
++
++int
++read_rtl2832_tuner_register(
++ struct dvb_usb_device *dib,
++ unsigned char device_address,
++ unsigned char offset,
++ unsigned char *data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++ int i;
++ unsigned char data_tmp[128];
++
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) goto error;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_rcvctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_IN, /* USB message request type value */
++ device_address+(offset<<8), /* USB message value */
++ 0x0300, /* USB message index value */
++ data_tmp, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ mutex_unlock(&dib->usb_mutex);
++
++// deb_info("%s: ret=%d, DA=0x%x, len=%d, offset=0x%x, data=(", __FUNCTION__, ret, device_address, bytelength,offset);
++// for(i = 0; i < bytelength; i++)
++// deb_info("0x%x,", data_tmp[i]);
++// deb_info(")\n");
++
++ if (ret != bytelength)
++ {
++ deb_info("error!! %s: ret=%d, DA=0x%x, len=%d, offset=0x%x, data=(", __FUNCTION__, ret, device_address, bytelength,offset);
++ for(i = 0; i < bytelength; i++)
++ deb_info("0x%x,", data_tmp[i]);
++ deb_info(")\n");
++
++ goto error;
++ }
++
++ memcpy(data,data_tmp,bytelength);
++
++ return 0;
++
++error:
++ return 1;
++
++
++}
++
++int write_rtl2832_tuner_register(
++ struct dvb_usb_device *dib,
++ unsigned char device_address,
++ unsigned char offset,
++ unsigned char *data,
++ unsigned short bytelength)
++{
++ int ret = -ENOMEM;
++ unsigned char i, try_num;
++
++ try_num = 0;
++error_write_again:
++ try_num++;
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) goto error;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_sndctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_OUT, /* USB message request type value */
++ device_address+(offset<<8), /* USB message value */
++ 0x0310, /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ mutex_unlock(&dib->usb_mutex);
++
++// deb_info("%s: ret=%d, DA=0x%x, len=%d, offset=0x%x, data=(", __FUNCTION__, ret, device_address, bytelength, offset);
++// for(i = 0; i < bytelength; i++)
++// deb_info("0x%x,", data[i]);
++// deb_info(")\n");
++
++
++ if (ret != bytelength)
++ {
++ deb_info("error try= %d!! %s: ret=%d, DA=0x%x, len=%d, offset=0x%x, data=(",try_num, __FUNCTION__, ret, device_address, bytelength, offset);
++ for(i = 0; i < bytelength; i++)
++ deb_info("0x%x,", data[i]);
++ deb_info(")\n");
++
++ if( try_num > ERROR_TRY_MAX_NUM ) goto error;
++ else goto error_write_again;
++ }
++
++ return 0;
++
++error:
++ return 1;
++ }
++
++
++
++
++int
++read_rtl2832_stdi2c(
++ struct dvb_usb_device* dib,
++ unsigned short dev_i2c_addr,
++ unsigned char* data,
++ unsigned short bytelength)
++{
++ int i;
++ int ret = -ENOMEM;
++ unsigned char try_num;
++ unsigned char data_tmp[128];
++
++ try_num = 0;
++error_write_again:
++ try_num ++;
++
++
++ if(bytelength >= 128)
++ {
++ deb_info("%s error bytelength >=128 \n", __FUNCTION__);
++ goto error;
++ }
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) goto error;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_rcvctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_IN, /* USB message request type value */
++ dev_i2c_addr, /* USB message value */
++ 0x0600, /* USB message index value */
++ data_tmp, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ mutex_unlock(&dib->usb_mutex);
++
++ if (ret != bytelength)
++ {
++ deb_info("error try= %d!! %s: ret=%d, DA=0x%x, len=%d, data=(",try_num, __FUNCTION__, ret, dev_i2c_addr, bytelength);
++ for(i = 0; i < bytelength; i++)
++ deb_info("0x%x,", data_tmp[i]);
++ deb_info(")\n");
++
++ if( try_num > ERROR_TRY_MAX_NUM ) goto error;
++ else goto error_write_again;
++ }
++
++ memcpy(data,data_tmp,bytelength);
++
++ return 0;
++error:
++ return 1;
++
++}
++
++
++
++int
++write_rtl2832_stdi2c(
++ struct dvb_usb_device* dib,
++ unsigned short dev_i2c_addr,
++ unsigned char* data,
++ unsigned short bytelength)
++{
++ int i;
++ int ret = -ENOMEM;
++ unsigned char try_num;
++
++ try_num = 0;
++error_write_again:
++ try_num ++;
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) goto error;
++
++ ret = usb_control_msg(dib->udev, /* pointer to device */
++ usb_sndctrlpipe( dib->udev,RTL2832_CTRL_ENDPOINT), /* pipe to control endpoint */
++ 0, /* USB message request value */
++ SKEL_VENDOR_OUT, /* USB message request type value */
++ dev_i2c_addr, /* USB message value */
++ 0x0610, /* USB message index value */
++ data, /* pointer to the receive buffer */
++ bytelength, /* length of the buffer */
++ DIBUSB_I2C_TIMEOUT); /* time to wait for the message to complete before timing out */
++
++ mutex_unlock(&dib->usb_mutex);
++
++ if (ret != bytelength)
++ {
++ deb_info("error try= %d!! %s: ret=%d, DA=0x%x, len=%d, data=(",try_num, __FUNCTION__, ret, dev_i2c_addr, bytelength);
++ for(i = 0; i < bytelength; i++)
++ deb_info("0x%x,", data[i]);
++ deb_info(")\n");
++
++ if( try_num > ERROR_TRY_MAX_NUM ) goto error;
++ else goto error_write_again;
++
++ }
++
++ return 0;
++
++error:
++ return 1;
++
++}
++
++
++
++
++
++
++//3for return PUCHAR value
++
++int
++read_usb_sys_char_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned char* buf,
++ unsigned short byte_num)
++{
++ int ret = 1;
++
++ if( byte_num != 1 && byte_num !=2 && byte_num !=4)
++ {
++ deb_info("error!! %s: length = %d \n", __FUNCTION__, byte_num);
++ return 1;
++ }
++
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) return 1;
++
++ if( type == RTD2832U_USB )
++ {
++ ret = read_usb_register( dib , byte_addr , buf , byte_num);
++ }
++ else if ( type == RTD2832U_SYS )
++ {
++ ret = read_sys_register( dib , byte_addr , buf , byte_num);
++ }
++
++ mutex_unlock(&dib->usb_mutex);
++
++ return ret;
++
++}
++
++
++
++int
++write_usb_sys_char_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned char* buf,
++ unsigned short byte_num)
++{
++ int ret = 1;
++
++ if( byte_num != 1 && byte_num !=2 && byte_num !=4)
++ {
++ deb_info("error!! %s: length = %d \n", __FUNCTION__, byte_num);
++ return 1;
++ }
++
++ if( mutex_lock_interruptible(&dib->usb_mutex) ) return 1;
++
++ if( type == RTD2832U_USB )
++ {
++ ret = write_usb_register( dib , byte_addr , buf , byte_num);
++ }
++ else if ( type == RTD2832U_SYS )
++ {
++ ret = write_sys_register( dib , byte_addr , buf , byte_num);
++ }
++
++ mutex_unlock(&dib->usb_mutex);
++
++ return ret;
++
++}
++
++
++//3for return INT value
++int
++read_usb_sys_int_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned short n_bytes,
++ int* p_val)
++{
++ int i;
++ u8 val[LEN_4_BYTE];
++ int nbit_shift;
++
++ *p_val= 0;
++
++ if (read_usb_sys_char_bytes( dib, type, byte_addr, val , n_bytes)) goto error;
++
++ for (i= 0; i< n_bytes; i++)
++ {
++ nbit_shift = i<<3 ;
++ *p_val = *p_val + (val[i]<<nbit_shift );
++ }
++
++ return 0;
++error:
++ return 1;
++
++}
++
++
++
++int
++write_usb_sys_int_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned short n_bytes,
++ int val)
++{
++ int i;
++ int nbit_shift;
++ u8 u8_val[LEN_4_BYTE];
++
++ for (i= n_bytes- 1; i>= 0; i--)
++ {
++ nbit_shift= i << 3;
++ u8_val[i] = (val>> nbit_shift) & 0xff;
++ }
++
++ if( write_usb_sys_char_bytes( dib , type , byte_addr, u8_val , n_bytes) ) goto error;
++
++ return 0;
++error:
++ return 1;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/rtl2832u_io.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/rtl2832u_io.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,206 @@
++
++
++
++#ifndef __USB_SYS_RTL2832_H__
++#define __USB_SYS_RTL2832_H__
++
++#include "dvb-usb.h"
++
++extern int dvb_usb_rtl2832u_debug;
++#define deb_info(args...) dprintk(dvb_usb_rtl2832u_debug,0x01,args)
++#define deb_xfer(args...) dprintk(dvb_usb_rtl2832u_debug,0x02,args)
++
++#define LEN_1_BYTE 1
++#define LEN_2_BYTE 2
++#define LEN_4_BYTE 4
++
++
++#define RTL2832_CTRL_ENDPOINT 0x00
++#define DIBUSB_I2C_TIMEOUT 5000
++
++#define SKEL_VENDOR_IN (USB_DIR_IN|USB_TYPE_VENDOR)
++#define SKEL_VENDOR_OUT (USB_DIR_OUT|USB_TYPE_VENDOR)
++
++#define SYS_BASE_ADDRESS 0x30 //0x3000
++#define USB_BASE_ADDRESS 0x20 //0x2000
++
++typedef enum { RTD2832U_USB =1, RTD2832U_SYS=2 } RegType;
++
++//3////////////////////////
++//3for return PUCHAR value
++//3///////////////////////
++
++int
++read_usb_sys_char_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned char* buf,
++ unsigned short byte_num);
++
++
++
++int
++write_usb_sys_char_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned char* buf,
++ unsigned short byte_num);
++
++
++
++//3//////////////////
++//3for return INT value
++//3//////////////////
++
++int
++read_usb_sys_int_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned short n_bytes,
++ int* p_val);
++
++
++int
++write_usb_sys_int_bytes(
++ struct dvb_usb_device* dib,
++ RegType type,
++ unsigned short byte_addr,
++ unsigned short n_bytes,
++ int val);
++
++/////////////////////////////////////
++
++void
++platform_wait(
++ unsigned long nMinDelayTime);
++
++
++
++#if 0
++//3//////////////////
++//3for std i2c r/w
++//3//////////////////
++
++int
++read_rtl2832_stdi2c(
++ struct dvb_usb_device* dib,
++ unsigned short dev_i2c_addr,
++ unsigned char* data,
++ unsigned short bytelength);
++
++int
++write_rtl2832_stdi2c(
++ struct dvb_usb_device* dib,
++ unsigned short dev_i2c_addr,
++ unsigned char* data,
++ unsigned short bytelength);
++
++#endif
++
++
++
++int
++read_rtl2832_demod_register(
++ struct dvb_usb_device*dib,
++ unsigned char demod_device_addr,
++ unsigned char page,
++ unsigned char offset,
++ unsigned char* data,
++ unsigned short bytelength);
++
++
++
++
++int
++write_rtl2832_demod_register(
++ struct dvb_usb_device*dib,
++ unsigned char demod_device_addr,
++ unsigned char page,
++ unsigned char offset,
++ unsigned char *data,
++ unsigned short bytelength);
++
++
++
++int
++read_rtl2832_tuner_register(
++ struct dvb_usb_device *dib,
++ unsigned char device_address,
++ unsigned char offset,
++ unsigned char *data,
++ unsigned short bytelength);
++
++
++
++
++int write_rtl2832_tuner_register(
++ struct dvb_usb_device *dib,
++ unsigned char device_address,
++ unsigned char offset,
++ unsigned char *data,
++ unsigned short bytelength);
++
++
++
++
++
++int
++ write_rtl2832_stdi2c(
++ struct dvb_usb_device* dib,
++ unsigned short dev_i2c_addr,
++ unsigned char* data,
++ unsigned short bytelength);
++
++
++
++int
++ read_rtl2832_stdi2c(
++ struct dvb_usb_device* dib,
++ unsigned short dev_i2c_addr,
++ unsigned char* data,
++ unsigned short bytelength);
++
++
++////////////////////////////////////
++
++#define BIT0 0x00000001
++#define BIT1 0x00000002
++#define BIT2 0x00000004
++#define BIT3 0x00000008
++#define BIT4 0x00000010
++#define BIT5 0x00000020
++#define BIT6 0x00000040
++#define BIT7 0x00000080
++#define BIT8 0x00000100
++#define BIT9 0x00000200
++#define BIT10 0x00000400
++#define BIT11 0x00000800
++#define BIT12 0x00001000
++#define BIT13 0x00002000
++#define BIT14 0x00004000
++#define BIT15 0x00008000
++#define BIT16 0x00010000
++#define BIT17 0x00020000
++#define BIT18 0x00040000
++#define BIT19 0x00080000
++#define BIT20 0x00100000
++#define BIT21 0x00200000
++#define BIT22 0x00400000
++#define BIT23 0x00800000
++#define BIT24 0x01000000
++#define BIT25 0x02000000
++#define BIT26 0x04000000
++#define BIT27 0x08000000
++#define BIT28 0x10000000
++#define BIT29 0x20000000
++#define BIT30 0x40000000
++#define BIT31 0x80000000
++
++
++#endif
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_base.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_base.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,365 @@
++#ifndef __TUNER_BASE_H
++#define __TUNER_BASE_H
++
++/**
++
++@file
++
++@brief Tuner base module definition
++
++Tuner base module definitions contains tuner module structure, tuner funciton pointers, and tuner definitions.
++
++
++
++@par Example:
++@code
++
++
++#include "demod_xxx.h"
++#include "tuner_xxx.h"
++
++
++
++int
++CustomI2cRead(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++ return FUNCTION_ERROR;
++}
++
++
++
++int
++CustomI2cWrite(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned char DeviceAddr,
++ const unsigned char *pWritingBytes,
++ unsigned char ByteNum
++ )
++{
++ ...
++
++ return FUNCTION_SUCCESS;
++
++error_status:
++ return FUNCTION_ERROR;
++}
++
++
++
++void
++CustomWaitMs(
++ BASE_INTERFACE_MODULE *pBaseInterface,
++ unsigned long WaitTimeMs
++ )
++{
++ ...
++}
++
++
++
++int main(void)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++
++ XXX_DEMOD_MODULE *pDemod;
++ XXX_DEMOD_MODULE XxxDemodModuleMemory;
++
++ TUNER_MODULE *pTuner;
++ TUNER_MODULE TunerModuleMemory;
++
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory;
++
++ unsigned long RfFreqHz;
++
++ int TunerType;
++ unsigned char DeviceAddr;
++
++
++
++ // Build base interface module.
++ BuildBaseInterface(
++ &pBaseInterface,
++ &BaseInterfaceModuleMemory,
++ 9, // Set maximum I2C reading byte number with 9.
++ 8, // Set maximum I2C writing byte number with 8.
++ CustomI2cRead, // Employ CustomI2cRead() as basic I2C reading function.
++ CustomI2cWrite, // Employ CustomI2cWrite() as basic I2C writing function.
++ CustomWaitMs // Employ CustomWaitMs() as basic waiting function.
++ );
++
++
++ // Build dmeod XXX module.
++ // Note: Demod module builder will set I2cBridgeModuleMemory for tuner I2C command forwarding.
++ // Must execute demod builder to set I2cBridgeModuleMemory before use tuner functions.
++ BuildDemodXxxModule(
++ &pDemod,
++ &XxxDemodModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ ... // Other arguments by each demod module
++ )
++
++
++ // Build tuner XXX module.
++ BuildTunerXxxModule(
++ &pTuner,
++ &TunerModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ 0xc0, // Tuner I2C device address is 0xc0 in 8-bit format.
++ ... // Other arguments by each demod module
++ );
++
++
++
++
++
++ // ==== Initialize tuner and set its parameters =====
++
++ // Initialize tuner.
++ pTuner->Initialize(pTuner);
++
++
++ // Set tuner parameters. (RF frequency)
++ // Note: In the example, RF frequency is 474 MHz.
++ RfFreqHz = 474000000;
++
++ pTuner->SetIfFreqHz(pTuner, RfFreqHz);
++
++
++
++
++
++ // ==== Get tuner information =====
++
++ // Get tuenr type.
++ // Note: One can find tuner type in MODULE_TYPE enumeration.
++ pTuner->GetTunerType(pTuner, &TunerType);
++
++ // Get tuner I2C device address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++
++ // Get tuner parameters. (RF frequency)
++ pTuner->GetRfFreqHz(pTuner, &RfFreqHz);
++
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "foundation.h"
++
++
++
++
++
++/// tuner module pre-definition
++typedef struct TUNER_MODULE_TAG TUNER_MODULE;
++
++
++
++
++
++/**
++
++@brief Tuner type getting function pointer
++
++One can use TUNER_FP_GET_TUNER_TYPE() to get tuner type.
++
++
++@param [in] pTuner The tuner module pointer
++@param [out] pTunerType Pointer to an allocated memory for storing tuner type
++
++
++@note
++ -# Tuner building function will set TUNER_FP_GET_TUNER_TYPE() with the corresponding function.
++
++
++@see TUNER_TYPE
++
++*/
++typedef void
++(*TUNER_FP_GET_TUNER_TYPE)(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ );
++
++
++
++
++
++/**
++
++@brief Tuner I2C device address getting function pointer
++
++One can use TUNER_FP_GET_DEVICE_ADDR() to get tuner I2C device address.
++
++
++@param [in] pTuner The tuner module pointer
++@param [out] pDeviceAddr Pointer to an allocated memory for storing tuner I2C device address
++
++
++@retval FUNCTION_SUCCESS Get tuner device address successfully.
++@retval FUNCTION_ERROR Get tuner device address unsuccessfully.
++
++
++@note
++ -# Tuner building function will set TUNER_FP_GET_DEVICE_ADDR() with the corresponding function.
++
++*/
++typedef void
++(*TUNER_FP_GET_DEVICE_ADDR)(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ );
++
++
++
++
++
++/**
++
++@brief Tuner initializing function pointer
++
++One can use TUNER_FP_INITIALIZE() to initialie tuner.
++
++
++@param [in] pTuner The tuner module pointer
++
++
++@retval FUNCTION_SUCCESS Initialize tuner successfully.
++@retval FUNCTION_ERROR Initialize tuner unsuccessfully.
++
++
++@note
++ -# Tuner building function will set TUNER_FP_INITIALIZE() with the corresponding function.
++
++*/
++typedef int
++(*TUNER_FP_INITIALIZE)(
++ TUNER_MODULE *pTuner
++ );
++
++
++
++
++
++/**
++
++@brief Tuner RF frequency setting function pointer
++
++One can use TUNER_FP_SET_RF_FREQ_HZ() to set tuner RF frequency in Hz.
++
++
++@param [in] pTuner The tuner module pointer
++@param [in] RfFreqHz RF frequency in Hz for setting
++
++
++@retval FUNCTION_SUCCESS Set tuner RF frequency successfully.
++@retval FUNCTION_ERROR Set tuner RF frequency unsuccessfully.
++
++
++@note
++ -# Tuner building function will set TUNER_FP_SET_RF_FREQ_HZ() with the corresponding function.
++
++*/
++typedef int
++(*TUNER_FP_SET_RF_FREQ_HZ)(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ );
++
++
++
++
++
++/**
++
++@brief Tuner RF frequency getting function pointer
++
++One can use TUNER_FP_GET_RF_FREQ_HZ() to get tuner RF frequency in Hz.
++
++
++@param [in] pTuner The tuner module pointer
++@param [in] pRfFreqHz Pointer to an allocated memory for storing demod RF frequency in Hz
++
++
++@retval FUNCTION_SUCCESS Get tuner RF frequency successfully.
++@retval FUNCTION_ERROR Get tuner RF frequency unsuccessfully.
++
++
++@note
++ -# Tuner building function will set TUNER_FP_GET_RF_FREQ_HZ() with the corresponding function.
++
++*/
++typedef int
++(*TUNER_FP_GET_RF_FREQ_HZ)(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ );
++
++
++
++
++
++/// Tuner module structure
++struct TUNER_MODULE_TAG
++{
++ unsigned char b_set_tuner_power_gpio4; //3add by chialing 2008.08.19
++ // Private variables
++ int TunerType; ///< Tuner type
++ unsigned char DeviceAddr; ///< Tuner I2C device address
++ unsigned long RfFreqHz; ///< Tuner RF frequency in Hz
++
++ int IsRfFreqHzSet; ///< Tuner RF frequency in Hz (setting status)
++
++ void *pExtra; ///< Tuner extra module used by driving module
++ BASE_INTERFACE_MODULE *pBaseInterface; ///< Base interface module
++ I2C_BRIDGE_MODULE *pI2cBridge; ///< I2C bridge module
++
++
++ // Tuner manipulating functions
++ TUNER_FP_GET_TUNER_TYPE GetTunerType; ///< Tuner type getting function pointer
++ TUNER_FP_GET_DEVICE_ADDR GetDeviceAddr; ///< Tuner I2C device address getting function pointer
++
++ TUNER_FP_INITIALIZE Initialize; ///< Tuner initializing function pointer
++ TUNER_FP_SET_RF_FREQ_HZ SetRfFreqHz; ///< Tuner RF frequency setting function pointer
++ TUNER_FP_GET_RF_FREQ_HZ GetRfFreqHz; ///< Tuner RF frequency getting function pointer
++
++};
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_fc2580.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_fc2580.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,992 @@
++/**
++
++@file
++
++@brief FC2580 tuner module definition
++
++One can manipulate FC2580 tuner through FC2580 module.
++FC2580 module is derived from tuner module.
++
++*/
++
++
++#include "tuner_fc2580.h"
++
++
++
++
++
++/**
++
++@brief FC2580 tuner module builder
++
++Use BuildFc2580Module() to build FC2580 module, set all module function pointers with the corresponding functions,
++and initialize module private variables.
++
++
++@param [in] ppTuner Pointer to FC2580 tuner module pointer
++@param [in] pTunerModuleMemory Pointer to an allocated tuner module memory
++@param [in] pFc2580ExtraModuleMemory Pointer to an allocated FC2580 extra module memory
++@param [in] pBaseInterfaceModuleMemory Pointer to an allocated base interface module memory
++@param [in] pI2cBridgeModuleMemory Pointer to an allocated I2C bridge module memory
++@param [in] DeviceAddr FC2580 I2C device address
++@param [in] AgcMode FC2580 AGC mode
++
++
++@note
++ -# One should call BuildFc2580Module() to build FC2580 module before using it.
++
++*/
++void
++BuildFc2580Module(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ FC2580_EXTRA_MODULE *pFc2580ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr,
++ unsigned long CrystalFreqHz,
++ int AgcMode
++ )
++{
++ TUNER_MODULE *pTuner;
++ FC2580_EXTRA_MODULE *pExtra;
++
++
++
++ // Set tuner module pointer.
++ *ppTuner = pTunerModuleMemory;
++
++ // Get tuner module.
++ pTuner = *ppTuner;
++
++ // Set tuner extra module pointer, base interface module pointer, and I2C bridge module pointer.
++ pTuner->pExtra = pFc2580ExtraModuleMemory;
++ pTuner->pBaseInterface = pBaseInterfaceModuleMemory;
++ pTuner->pI2cBridge = pI2cBridgeModuleMemory;
++
++ // Get tuner extra module.
++ pExtra = (FC2580_EXTRA_MODULE *)pTuner->pExtra;
++
++
++
++ // Set tuner type.
++ pTuner->TunerType = TUNER_TYPE_FC2580;
++
++ // Set tuner I2C device address.
++ pTuner->DeviceAddr = DeviceAddr;
++
++
++ // Initialize tuner parameter setting status.
++ pTuner->IsRfFreqHzSet = NO;
++
++
++ // Set I2C bridge tuner arguments.
++ fc2580_SetI2cBridgeModuleTunerArg(pTuner);
++
++
++ // Set tuner module manipulating function pointers.
++ pTuner->GetTunerType = fc2580_GetTunerType;
++ pTuner->GetDeviceAddr = fc2580_GetDeviceAddr;
++
++ pTuner->Initialize = fc2580_Initialize;
++ pTuner->SetRfFreqHz = fc2580_SetRfFreqHz;
++ pTuner->GetRfFreqHz = fc2580_GetRfFreqHz;
++
++
++ // Initialize tuner extra module variables.
++ pExtra->CrystalFreqHz = CrystalFreqHz;
++ pExtra->AgcMode = AgcMode;
++ pExtra->IsBandwidthModeSet = NO;
++
++ // Set tuner extra module function pointers.
++ pExtra->SetBandwidthMode = fc2580_SetBandwidthMode;
++ pExtra->GetBandwidthMode = fc2580_GetBandwidthMode;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_TUNER_TYPE
++
++*/
++void
++fc2580_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ )
++{
++ // Get tuner type from tuner module.
++ *pTunerType = pTuner->TunerType;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_DEVICE_ADDR
++
++*/
++void
++fc2580_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ )
++{
++ // Get tuner I2C device address from tuner module.
++ *pDeviceAddr = pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_INITIALIZE
++
++*/
++int
++fc2580_Initialize(
++ TUNER_MODULE *pTuner
++ )
++{
++ FC2580_EXTRA_MODULE *pExtra;
++ int AgcMode;
++ unsigned int CrystalFreqKhz;
++
++
++
++ // Get tuner extra module.
++ pExtra = (FC2580_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Get AGC mode.
++ AgcMode = pExtra->AgcMode;
++
++ // Initialize tuner with AGC mode.
++ // Note: CrystalFreqKhz = round(CrystalFreqHz / 1000)
++ CrystalFreqKhz = (unsigned int)((pExtra->CrystalFreqHz + 500) / 1000);
++
++ if(fc2580_set_init(pTuner, AgcMode, CrystalFreqKhz) != FCI_SUCCESS)
++ goto error_status_initialize_tuner;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_initialize_tuner:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_SET_RF_FREQ_HZ
++
++*/
++int
++fc2580_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ )
++{
++ FC2580_EXTRA_MODULE *pExtra;
++ unsigned int RfFreqKhz;
++ unsigned int CrystalFreqKhz;
++
++
++
++ // Get tuner extra module.
++ pExtra = (FC2580_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Set tuner RF frequency in KHz.
++ // Note: RfFreqKhz = round(RfFreqHz / 1000)
++ // CrystalFreqKhz = round(CrystalFreqHz / 1000)
++ RfFreqKhz = (unsigned int)((RfFreqHz + 500) / 1000);
++ CrystalFreqKhz = (unsigned int)((pExtra->CrystalFreqHz + 500) / 1000);
++
++ if(fc2580_set_freq(pTuner, RfFreqKhz, CrystalFreqKhz) != FCI_SUCCESS)
++ goto error_status_set_tuner_rf_frequency;
++
++
++ // Set tuner RF frequency parameter.
++ pTuner->RfFreqHz = RfFreqHz;
++ pTuner->IsRfFreqHzSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_RF_FREQ_HZ
++
++*/
++int
++fc2580_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ )
++{
++ // Get tuner RF frequency in Hz from tuner module.
++ if(pTuner->IsRfFreqHzSet != YES)
++ goto error_status_get_tuner_rf_frequency;
++
++ *pRfFreqHz = pTuner->RfFreqHz;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set FC2580 tuner bandwidth mode.
++
++*/
++int
++fc2580_SetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ )
++{
++ FC2580_EXTRA_MODULE *pExtra;
++ unsigned int CrystalFreqKhz;
++
++
++
++ // Get tuner extra module.
++ pExtra = (FC2580_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Set tuner bandwidth mode.
++ // Note: CrystalFreqKhz = round(CrystalFreqHz / 1000)
++ CrystalFreqKhz = (unsigned int)((pExtra->CrystalFreqHz + 500) / 1000);
++
++ if(fc2580_set_filter(pTuner, (unsigned char)BandwidthMode, CrystalFreqKhz) != FCI_SUCCESS)
++ goto error_status_set_tuner_bandwidth_mode;
++
++
++ // Set tuner bandwidth mode parameter.
++ pExtra->BandwidthMode = BandwidthMode;
++ pExtra->IsBandwidthModeSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_bandwidth_mode:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Get FC2580 tuner bandwidth mode.
++
++*/
++int
++fc2580_GetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ )
++{
++ FC2580_EXTRA_MODULE *pExtra;
++
++
++
++ // Get tuner extra module.
++ pExtra = (FC2580_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Get tuner bandwidth mode from tuner module.
++ if(pExtra->IsBandwidthModeSet != YES)
++ goto error_status_get_tuner_bandwidth_mode;
++
++ *pBandwidthMode = pExtra->BandwidthMode;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_bandwidth_mode:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set I2C bridge module tuner arguments.
++
++FC2580 builder will use fc2580_SetI2cBridgeModuleTunerArg() to set I2C bridge module tuner arguments.
++
++
++@param [in] pTuner The tuner module pointer
++
++
++@see BuildFc2580Module()
++
++*/
++void
++fc2580_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ )
++{
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++
++
++ // Get I2C bridge module.
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Set I2C bridge module tuner arguments.
++ pI2cBridge->pTunerDeviceAddr = &pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is source code provided by FCI.
++
++
++
++
++
++// FCI source code - fc2580_driver_v14011_r.c
++
++
++/*==============================================================================
++ FILE NAME : FC2580_driver_v1400_r.c
++
++ VERSION : 1.400_r
++
++ UPDATE : September 22. 2008
++
++==============================================================================*/
++
++/*==============================================================================
++
++ Chip ID of FC2580 is 0x56 or 0xAC(including I2C write bit)
++
++==============================================================================*/
++
++//#include "fc2580_driver_v1400_r.h"
++
++//fc2580_band_type curr_band = NO_BAND;
++//unsigned int freq_xtal = 16384;
++
++
++/*==============================================================================
++ milisecond delay function EXTERNAL FUNCTION
++
++ This function is a generic function which write a byte into fc2580's
++ specific address.
++
++ <input parameter>
++
++ a
++ length of wanted delay in milisecond unit
++
++==============================================================================*/
++void wait_msec(TUNER_MODULE *pTuner, int a)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++
++ // Get base interface.
++ pBaseInterface = pTuner->pBaseInterface;
++
++
++ // Wait time in millisecond.
++ pBaseInterface->WaitMs(pBaseInterface, (unsigned long)a);
++
++
++ return;
++}
++
++/*==============================================================================
++
++ fc2580 i2c write
++
++ This function is a generic function which write a byte into fc2580's
++ specific address.
++
++ <input parameter>
++
++ addr
++ fc2580's memory address\
++ type : byte
++
++ data
++ target data
++ type : byte
++
++==============================================================================*/
++fci_result_type fc2580_i2c_write( TUNER_MODULE *pTuner, unsigned char addr, unsigned char data )
++{
++ I2C_BRIDGE_MODULE *pI2cBridge;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned char TunerDeviceAddr;
++
++ struct dvb_usb_device *d;
++
++// unsigned char WritingBytes[2];
++ unsigned char WritingBytes[1];
++
++
++ // Get I2C bridge.
++ pI2cBridge = pTuner->pI2cBridge;
++ pBaseInterface = pTuner->pBaseInterface;
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++
++
++ // Set writing bytes.
++ // Note: The I2C format of tuner register byte setting is as follows:
++ // start_bit + (DeviceAddr | writing_bit) + addr + data + stop_bit
++// WritingBytes[0] = addr;
++// WritingBytes[1] = data;
++ WritingBytes[0] = data;
++
++ // Set tuner register bytes with writing buffer.
++// if(pI2cBridge->ForwardI2cWritingCmd(pI2cBridge, WritingBytes, LEN_2_BYTE) != FUNCTION_SUCCESS)
++// goto error_status_set_tuner_registers;
++
++
++ if (write_rtl2832_tuner_register(d, TunerDeviceAddr, addr, WritingBytes, LEN_1_BYTE)) goto error;
++
++
++ return FCI_SUCCESS;
++
++error:
++ return FCI_FAIL;
++};
++
++/*==============================================================================
++
++ fc2580 i2c read
++
++ This function is a generic function which gets called to read data from
++ fc2580's target memory address.
++
++ <input parameter>
++
++ addr
++ fc2580's memory address
++ type : byte
++
++
++ <return value>
++ data
++ a byte of data read out of target address 'addr'
++ type : byte
++
++==============================================================================*/
++fci_result_type fc2580_i2c_read( TUNER_MODULE *pTuner, unsigned char addr, unsigned char *read_data )
++{
++ I2C_BRIDGE_MODULE *pI2cBridge;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned char TunerDeviceAddr;
++
++ struct dvb_usb_device *d;
++
++
++ // Get I2C bridge.
++ pI2cBridge = pTuner->pI2cBridge;
++ pBaseInterface = pTuner->pBaseInterface;
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++
++
++ // Set tuner register reading address.
++ // Note: The I2C format of tuner register reading address setting is as follows:
++ // start_bit + (DeviceAddr | writing_bit) + addr + stop_bit
++// if(pI2cBridge->ForwardI2cWritingCmd(pI2cBridge, &addr, LEN_1_BYTE) != FUNCTION_SUCCESS)
++// goto error_status_set_tuner_register_reading_address;
++
++ // Get tuner register byte.
++ // Note: The I2C format of tuner register byte getting is as follows:
++ // start_bit + (DeviceAddr | reading_bit) + read_data + stop_bit
++// if(pI2cBridge->ForwardI2cReadingCmd(pI2cBridge, read_data, LEN_1_BYTE) != FUNCTION_SUCCESS)
++// goto error_status_get_tuner_registers;
++
++
++ if(read_rtl2832_tuner_register(d, TunerDeviceAddr, addr, read_data, LEN_1_BYTE)) goto error;
++
++ return FCI_SUCCESS;
++
++error:
++ return FCI_FAIL;
++};
++
++
++/*==============================================================================
++ fc2580 I2C Test
++
++ This function is a generic function which tests I2C interface's availability
++
++ by reading out it's I2C id data from reg. address '0x01'.
++
++ <input parameter>
++
++ None
++
++ <return value>
++ int
++ 1 : success - communication is avilable
++ 0 : fail - communication is unavailable
++
++
++==============================================================================*/
++//int fc2580_i2c_test( void )
++//{
++// return ( fc2580_i2c_read( 0x01 ) == 0x56 )? 0x01 : 0x00;
++//}
++
++
++
++
++/*==============================================================================
++ fc2580 initial setting
++
++ This function is a generic function which gets called to initialize
++
++ fc2580 in DVB-H mode or L-Band TDMB mode
++
++ <input parameter>
++
++ ifagc_mode
++ type : integer
++ 1 : Internal AGC
++ 2 : Voltage Control Mode
++
++==============================================================================*/
++fci_result_type fc2580_set_init( TUNER_MODULE *pTuner, int ifagc_mode, unsigned int freq_xtal )
++{
++ fci_result_type result = FCI_SUCCESS;
++
++ result &= fc2580_i2c_write(pTuner, 0x00, 0x00); /*** Confidential ***/
++ result &= fc2580_i2c_write(pTuner, 0x12, 0x86);
++ result &= fc2580_i2c_write(pTuner, 0x14, 0x5C);
++ result &= fc2580_i2c_write(pTuner, 0x16, 0x3C);
++ result &= fc2580_i2c_write(pTuner, 0x1F, 0xD2);
++ result &= fc2580_i2c_write(pTuner, 0x09, 0xD7);
++ result &= fc2580_i2c_write(pTuner, 0x0B, 0xD5);
++ result &= fc2580_i2c_write(pTuner, 0x0C, 0x32);
++ result &= fc2580_i2c_write(pTuner, 0x0E, 0x43);
++ result &= fc2580_i2c_write(pTuner, 0x21, 0x0A);
++ result &= fc2580_i2c_write(pTuner, 0x22, 0x82);
++ if( ifagc_mode == 1 )
++ {
++ result &= fc2580_i2c_write(pTuner, 0x45, 0x10); //internal AGC
++ result &= fc2580_i2c_write(pTuner, 0x4C, 0x00); //HOLD_AGC polarity
++ }
++ else if( ifagc_mode == 2 )
++ {
++ result &= fc2580_i2c_write(pTuner, 0x45, 0x20); //Voltage Control Mode
++ result &= fc2580_i2c_write(pTuner, 0x4C, 0x02); //HOLD_AGC polarity
++ }
++ result &= fc2580_i2c_write(pTuner, 0x3F, 0x88);
++ result &= fc2580_i2c_write(pTuner, 0x02, 0x0E);
++ result &= fc2580_i2c_write(pTuner, 0x58, 0x14);
++ result &= fc2580_set_filter(pTuner, 8, freq_xtal); //BW = 7.8MHz
++
++ return result;
++}
++
++
++/*==============================================================================
++ fc2580 frequency setting
++
++ This function is a generic function which gets called to change LO Frequency
++
++ of fc2580 in DVB-H mode or L-Band TDMB mode
++
++ <input parameter>
++ freq_xtal: kHz
++
++ f_lo
++ Value of target LO Frequency in 'kHz' unit
++ ex) 2.6GHz = 2600000
++
++==============================================================================*/
++fci_result_type fc2580_set_freq( TUNER_MODULE *pTuner, unsigned int f_lo, unsigned int freq_xtal )
++{
++ unsigned int f_diff, f_diff_shifted, n_val, k_val;
++ unsigned int f_vco, r_val, f_comp;
++ unsigned char pre_shift_bits = 4;// number of preshift to prevent overflow in shifting f_diff to f_diff_shifted
++ unsigned char data_0x18;
++ unsigned char data_0x02 = (USE_EXT_CLK<<5)|0x0E;
++
++ fc2580_band_type band = ( f_lo > 1000000 )? L_BAND : ( f_lo > 400000 )? UHF_BAND : VHF_BAND;
++
++ fci_result_type result = FCI_SUCCESS;
++
++ f_vco = ( band == UHF_BAND )? f_lo * 4 : (( band == L_BAND )? f_lo * 2 : f_lo * 12);
++ r_val = ( f_vco >= 2*76*freq_xtal )? 1 : ( f_vco >= 76*freq_xtal )? 2 : 4;
++ f_comp = freq_xtal/r_val;
++ n_val = ( f_vco / 2 ) / f_comp;
++
++ f_diff = f_vco - 2* f_comp * n_val;
++ f_diff_shifted = f_diff << ( 20 - pre_shift_bits );
++ k_val = f_diff_shifted / ( ( 2* f_comp ) >> pre_shift_bits );
++
++ if( f_diff_shifted - k_val * ( ( 2* f_comp ) >> pre_shift_bits ) >= ( f_comp >> pre_shift_bits ) )
++ k_val = k_val + 1;
++
++ if( f_vco >= BORDER_FREQ ) //Select VCO Band
++ data_0x02 = data_0x02 | 0x08; //0x02[3] = 1;
++ else
++ data_0x02 = data_0x02 & 0xF7; //0x02[3] = 0;
++
++// if( band != curr_band ) {
++ switch(band)
++ {
++ case UHF_BAND:
++ data_0x02 = (data_0x02 & 0x3F);
++
++ result &= fc2580_i2c_write(pTuner, 0x25, 0xF0);
++ result &= fc2580_i2c_write(pTuner, 0x27, 0x77);
++ result &= fc2580_i2c_write(pTuner, 0x28, 0x53);
++ result &= fc2580_i2c_write(pTuner, 0x29, 0x60);
++ result &= fc2580_i2c_write(pTuner, 0x30, 0x09);
++ result &= fc2580_i2c_write(pTuner, 0x50, 0x8C);
++ result &= fc2580_i2c_write(pTuner, 0x53, 0x50);
++
++ if( f_lo < 538000 )
++ result &= fc2580_i2c_write(pTuner, 0x5F, 0x13);
++ else
++ result &= fc2580_i2c_write(pTuner, 0x5F, 0x15);
++
++ if( f_lo < 538000 )
++ {
++ result &= fc2580_i2c_write(pTuner, 0x61, 0x07);
++ result &= fc2580_i2c_write(pTuner, 0x62, 0x06);
++ result &= fc2580_i2c_write(pTuner, 0x67, 0x06);
++ result &= fc2580_i2c_write(pTuner, 0x68, 0x08);
++ result &= fc2580_i2c_write(pTuner, 0x69, 0x10);
++ result &= fc2580_i2c_write(pTuner, 0x6A, 0x12);
++ }
++ else if( f_lo < 794000 )
++ {
++ result &= fc2580_i2c_write(pTuner, 0x61, 0x03);
++ result &= fc2580_i2c_write(pTuner, 0x62, 0x03);
++ result &= fc2580_i2c_write(pTuner, 0x67, 0x03); //ACI improve
++ result &= fc2580_i2c_write(pTuner, 0x68, 0x05); //ACI improve
++ result &= fc2580_i2c_write(pTuner, 0x69, 0x0C);
++ result &= fc2580_i2c_write(pTuner, 0x6A, 0x0E);
++ }
++ else
++ {
++ result &= fc2580_i2c_write(pTuner, 0x61, 0x07);
++ result &= fc2580_i2c_write(pTuner, 0x62, 0x06);
++ result &= fc2580_i2c_write(pTuner, 0x67, 0x07);
++ result &= fc2580_i2c_write(pTuner, 0x68, 0x09);
++ result &= fc2580_i2c_write(pTuner, 0x69, 0x10);
++ result &= fc2580_i2c_write(pTuner, 0x6A, 0x12);
++ }
++
++ result &= fc2580_i2c_write(pTuner, 0x63, 0x15);
++
++ result &= fc2580_i2c_write(pTuner, 0x6B, 0x0B);
++ result &= fc2580_i2c_write(pTuner, 0x6C, 0x0C);
++ result &= fc2580_i2c_write(pTuner, 0x6D, 0x78);
++ result &= fc2580_i2c_write(pTuner, 0x6E, 0x32);
++ result &= fc2580_i2c_write(pTuner, 0x6F, 0x14);
++ result &= fc2580_set_filter(pTuner, 8, freq_xtal); //BW = 7.8MHz
++ break;
++ case VHF_BAND:
++ data_0x02 = (data_0x02 & 0x3F) | 0x80;
++ result &= fc2580_i2c_write(pTuner, 0x27, 0x77);
++ result &= fc2580_i2c_write(pTuner, 0x28, 0x33);
++ result &= fc2580_i2c_write(pTuner, 0x29, 0x40);
++ result &= fc2580_i2c_write(pTuner, 0x30, 0x09);
++ result &= fc2580_i2c_write(pTuner, 0x50, 0x8C);
++ result &= fc2580_i2c_write(pTuner, 0x53, 0x50);
++ result &= fc2580_i2c_write(pTuner, 0x5F, 0x0F);
++ result &= fc2580_i2c_write(pTuner, 0x61, 0x07);
++ result &= fc2580_i2c_write(pTuner, 0x62, 0x00);
++ result &= fc2580_i2c_write(pTuner, 0x63, 0x15);
++ result &= fc2580_i2c_write(pTuner, 0x67, 0x03);
++ result &= fc2580_i2c_write(pTuner, 0x68, 0x05);
++ result &= fc2580_i2c_write(pTuner, 0x69, 0x10);
++ result &= fc2580_i2c_write(pTuner, 0x6A, 0x12);
++ result &= fc2580_i2c_write(pTuner, 0x6B, 0x08);
++ result &= fc2580_i2c_write(pTuner, 0x6C, 0x0A);
++ result &= fc2580_i2c_write(pTuner, 0x6D, 0x78);
++ result &= fc2580_i2c_write(pTuner, 0x6E, 0x32);
++ result &= fc2580_i2c_write(pTuner, 0x6F, 0x54);
++ result &= fc2580_set_filter(pTuner, 7, freq_xtal); //BW = 6.8MHz
++ break;
++ case L_BAND:
++ data_0x02 = (data_0x02 & 0x3F) | 0x40;
++ result &= fc2580_i2c_write(pTuner, 0x2B, 0x70);
++ result &= fc2580_i2c_write(pTuner, 0x2C, 0x37);
++ result &= fc2580_i2c_write(pTuner, 0x2D, 0xE7);
++ result &= fc2580_i2c_write(pTuner, 0x30, 0x09);
++ result &= fc2580_i2c_write(pTuner, 0x44, 0x20);
++ result &= fc2580_i2c_write(pTuner, 0x50, 0x8C);
++ result &= fc2580_i2c_write(pTuner, 0x53, 0x50);
++ result &= fc2580_i2c_write(pTuner, 0x5F, 0x0F);
++ result &= fc2580_i2c_write(pTuner, 0x61, 0x0F);
++ result &= fc2580_i2c_write(pTuner, 0x62, 0x00);
++ result &= fc2580_i2c_write(pTuner, 0x63, 0x13);
++ result &= fc2580_i2c_write(pTuner, 0x67, 0x00);
++ result &= fc2580_i2c_write(pTuner, 0x68, 0x02);
++ result &= fc2580_i2c_write(pTuner, 0x69, 0x0C);
++ result &= fc2580_i2c_write(pTuner, 0x6A, 0x0E);
++ result &= fc2580_i2c_write(pTuner, 0x6B, 0x08);
++ result &= fc2580_i2c_write(pTuner, 0x6C, 0x0A);
++ result &= fc2580_i2c_write(pTuner, 0x6D, 0xA0);
++ result &= fc2580_i2c_write(pTuner, 0x6E, 0x50);
++ result &= fc2580_i2c_write(pTuner, 0x6F, 0x14);
++ result &= fc2580_set_filter(pTuner, 1, freq_xtal); //BW = 1.53MHz
++ break;
++ default:
++ break;
++ }
++// curr_band = band;
++// }
++
++ //A command about AGC clock's pre-divide ratio
++ if( freq_xtal >= 28000 )
++ result &= fc2580_i2c_write(pTuner, 0x4B, 0x22 );
++
++ //Commands about VCO Band and PLL setting.
++ result &= fc2580_i2c_write(pTuner, 0x02, data_0x02);
++ data_0x18 = ( ( r_val == 1 )? 0x00 : ( ( r_val == 2 )? 0x10 : 0x20 ) ) + (unsigned char)(k_val >> 16);
++ result &= fc2580_i2c_write(pTuner, 0x18, data_0x18); //Load 'R' value and high part of 'K' values
++ result &= fc2580_i2c_write(pTuner, 0x1A, (unsigned char)( k_val >> 8 ) ); //Load middle part of 'K' value
++ result &= fc2580_i2c_write(pTuner, 0x1B, (unsigned char)( k_val ) ); //Load lower part of 'K' value
++ result &= fc2580_i2c_write(pTuner, 0x1C, (unsigned char)( n_val ) ); //Load 'N' value
++
++ //A command about UHF LNA Load Cap
++ if( band == UHF_BAND )
++ result &= fc2580_i2c_write(pTuner, 0x2D, ( f_lo <= (unsigned int)794000 )? 0x9F : 0x8F ); //LNA_OUT_CAP
++
++
++ return result;
++}
++
++
++/*==============================================================================
++ fc2580 filter BW setting
++
++ This function is a generic function which gets called to change Bandwidth
++
++ frequency of fc2580's channel selection filter
++
++ <input parameter>
++ freq_xtal: kHz
++
++ filter_bw
++ 1 : 1.53MHz(TDMB)
++ 6 : 6MHz (Bandwidth 6MHz)
++ 7 : 6.8MHz (Bandwidth 7MHz)
++ 8 : 7.8MHz (Bandwidth 8MHz)
++
++
++==============================================================================*/
++fci_result_type fc2580_set_filter( TUNER_MODULE *pTuner, unsigned char filter_bw, unsigned int freq_xtal )
++{
++ unsigned char cal_mon, i;
++ fci_result_type result = FCI_SUCCESS;
++
++ if(filter_bw == 1)
++ {
++ result &= fc2580_i2c_write(pTuner, 0x36, 0x1C);
++ result &= fc2580_i2c_write(pTuner, 0x37, (unsigned char)(4151*freq_xtal/1000000) );
++ result &= fc2580_i2c_write(pTuner, 0x39, 0x00);
++ result &= fc2580_i2c_write(pTuner, 0x2E, 0x09);
++ }
++ if(filter_bw == 6)
++ {
++ result &= fc2580_i2c_write(pTuner, 0x36, 0x18);
++ result &= fc2580_i2c_write(pTuner, 0x37, (unsigned char)(4400*freq_xtal/1000000) );
++ result &= fc2580_i2c_write(pTuner, 0x39, 0x00);
++ result &= fc2580_i2c_write(pTuner, 0x2E, 0x09);
++ }
++ else if(filter_bw == 7)
++ {
++ result &= fc2580_i2c_write(pTuner, 0x36, 0x18);
++ result &= fc2580_i2c_write(pTuner, 0x37, (unsigned char)(3910*freq_xtal/1000000) );
++ result &= fc2580_i2c_write(pTuner, 0x39, 0x80);
++ result &= fc2580_i2c_write(pTuner, 0x2E, 0x09);
++ }
++ else if(filter_bw == 8)
++ {
++ result &= fc2580_i2c_write(pTuner, 0x36, 0x18);
++ result &= fc2580_i2c_write(pTuner, 0x37, (unsigned char)(3300*freq_xtal/1000000) );
++ result &= fc2580_i2c_write(pTuner, 0x39, 0x80);
++ result &= fc2580_i2c_write(pTuner, 0x2E, 0x09);
++ }
++
++
++ for(i=0; i<5; i++)
++ {
++ wait_msec(pTuner, 5);//wait 5ms
++ result &= fc2580_i2c_read(pTuner, 0x2F, &cal_mon);
++ if( (cal_mon & 0xC0) != 0xC0)
++ {
++ result &= fc2580_i2c_write(pTuner, 0x2E, 0x01);
++ result &= fc2580_i2c_write(pTuner, 0x2E, 0x09);
++ }
++ else
++ break;
++ }
++
++ result &= fc2580_i2c_write(pTuner, 0x2E, 0x01);
++
++ return result;
++}
++
++/*==============================================================================
++ fc2580 RSSI function
++
++ This function is a generic function which returns fc2580's
++
++ current RSSI value.
++
++ <input parameter>
++ none
++
++ <return value>
++ int
++ rssi : estimated input power.
++
++==============================================================================*/
++//int fc2580_get_rssi(void) {
++//
++// unsigned char s_lna, s_rfvga, s_cfs, s_ifvga;
++// int ofs_lna, ofs_rfvga, ofs_csf, ofs_ifvga, rssi;
++//
++// fc2580_i2c_read(0x71, &s_lna );
++// fc2580_i2c_read(0x72, &s_rfvga );
++// fc2580_i2c_read(0x73, &s_cfs );
++// fc2580_i2c_read(0x74, &s_ifvga );
++//
++//
++// ofs_lna =
++// (curr_band==UHF_BAND)?
++// (s_lna==0)? 0 :
++// (s_lna==1)? -6 :
++// (s_lna==2)? -17 :
++// (s_lna==3)? -22 : -30 :
++// (curr_band==VHF_BAND)?
++// (s_lna==0)? 0 :
++// (s_lna==1)? -6 :
++// (s_lna==2)? -19 :
++// (s_lna==3)? -24 : -32 :
++// (curr_band==L_BAND)?
++// (s_lna==0)? 0 :
++// (s_lna==1)? -6 :
++// (s_lna==2)? -11 :
++// (s_lna==3)? -16 : -34 :
++// 0;//NO_BAND
++// ofs_rfvga = -s_rfvga+((s_rfvga>=11)? 1 : 0) + ((s_rfvga>=18)? 1 : 0);
++// ofs_csf = -6*s_cfs;
++// ofs_ifvga = s_ifvga/4;
++//
++// return rssi = ofs_lna+ofs_rfvga+ofs_csf+ofs_ifvga+OFS_RSSI;
++//
++//}
++
++/*==============================================================================
++ fc2580 Xtal frequency Setting
++
++ This function is a generic function which sets
++
++ the frequency of xtal.
++
++ <input parameter>
++
++ frequency
++ frequency value of internal(external) Xtal(clock) in kHz unit.
++
++==============================================================================*/
++//void fc2580_set_freq_xtal(unsigned int frequency) {
++//
++// freq_xtal = frequency;
++//
++//}
++
++
++
++
++
++
++
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_fc2580.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_fc2580.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,519 @@
++#ifndef __TUNER_FC2580_H
++#define __TUNER_FC2580_H
++
++/**
++
++@file
++
++@brief FC2580 tuner module declaration
++
++One can manipulate FC2580 tuner through FC2580 module.
++FC2580 module is derived from tuner module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the tuner example in tuner_base.h except the listed lines.
++
++
++
++#include "tuner_fc2580.h"
++
++
++...
++
++
++
++int main(void)
++{
++ TUNER_MODULE *pTuner;
++ FC2580_EXTRA_MODULE *pTunerExtra;
++
++ TUNER_MODULE TunerModuleMemory;
++ FC2580_EXTRA_MODULE Fc2580ExtraModuleMemory;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory;
++
++ unsigned long BandwidthMode;
++
++
++ ...
++
++
++
++ // Build FC2580 tuner module.
++ BuildFc2580Module(
++ &pTuner,
++ &TunerModuleMemory,
++ &Fc2580ExtraModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ 0xac, // I2C device address is 0xac in 8-bit format.
++ CRYSTAL_FREQ_16384000HZ, // Crystal frequency is 16.384 MHz.
++ FC2580_AGC_EXTERNAL // The FC2580 AGC mode is external AGC mode.
++ );
++
++
++
++
++
++ // Get FC2580 tuner extra module.
++ pTunerExtra = (T2266_EXTRA_MODULE *)(pTuner->pExtra);
++
++
++
++
++
++ // ==== Initialize tuner and set its parameters =====
++
++ ...
++
++ // Set FC2580 bandwidth.
++ pTunerExtra->SetBandwidthMode(pTuner, FC2580_BANDWIDTH_6MHZ);
++
++
++
++
++
++ // ==== Get tuner information =====
++
++ ...
++
++ // Get FC2580 bandwidth.
++ pTunerExtra->GetBandwidthMode(pTuner, &BandwidthMode);
++
++
++
++ // See the example for other tuner functions in tuner_base.h
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++
++
++
++#include "tuner_base.h"
++
++
++
++
++
++// The following context is source code provided by FCI.
++
++
++
++
++
++// FCI source code - fc2580_driver_v1400_r.h
++
++
++/*==============================================================================
++ FILE NAME : FC2580_driver_v1400_r.h
++
++ VERSION : 1.400_r
++
++ UPDATE : September 22. 2008
++
++==============================================================================*/
++
++/*==============================================================================
++
++ Chip ID of FC2580 is 0x56 or 0xAC(including I2C write bit)
++
++==============================================================================*/
++
++
++#define BORDER_FREQ 2600000 //2.6GHz : The border frequency which determines whether Low VCO or High VCO is used
++#define USE_EXT_CLK 0 //0 : Use internal XTAL Oscillator / 1 : Use External Clock input
++#define OFS_RSSI 57
++
++typedef enum {
++ UHF_BAND,
++ L_BAND,
++ VHF_BAND,
++ NO_BAND
++} fc2580_band_type;
++
++typedef enum {
++ FCI_FAIL,
++ FCI_SUCCESS
++} fci_result_type;
++
++/*==============================================================================
++ i2c command write EXTERNAL FUNCTION
++
++ This function is a generic function which write a byte into fc2580's
++ specific address.
++
++ <input parameter>
++
++ slave_id
++ i2c id of slave chip
++ type : byte
++
++ addr
++ memory address of slave chip
++ type : byte
++
++ data
++ target data
++ type : byte
++
++==============================================================================*/
++//extern fci_result_type i2c_write( unsigned char slave_id, unsigned char addr, unsigned char *data, unsigned char n );
++
++/*==============================================================================
++ i2c command write EXTERNAL FUNCTION
++
++ This function is a generic function which gets called to read data from
++ slave chip's target memory address.
++
++ <input parameter>
++
++ slave_id
++ i2c id of slave chip
++ type : byte
++
++ addr
++ memory address of slave chip
++ type : byte
++
++ <return value>
++ data
++ a byte of data read out of target address 'addr' of slave chip
++ type : byte
++
++==============================================================================*/
++//extern fci_result_type i2c_read( unsigned char slave_id, unsigned char addr, unsigned char *read_data, unsigned char n );
++
++/*==============================================================================
++ milisecond delay function EXTERNAL FUNCTION
++
++ This function is a generic function which write a byte into fc2580's
++ specific address.
++
++ <input parameter>
++
++ a
++ length of wanted delay in milisecond unit
++
++==============================================================================*/
++extern void wait_msec(TUNER_MODULE *pTuner, int a);
++
++
++
++/*==============================================================================
++ fc2580 i2c command write
++
++ This function is a generic function which write a byte into fc2580's
++ specific address.
++
++ <input parameter>
++
++ addr
++ fc2580's memory address
++ type : byte
++
++ data
++ target data
++ type : byte
++
++==============================================================================*/
++fci_result_type fc2580_i2c_write( TUNER_MODULE *pTuner, unsigned char addr, unsigned char data );
++
++/*==============================================================================
++ fc2580 i2c data read
++
++ This function is a generic function which gets called to read data from
++ fc2580's target memory address.
++
++ <input parameter>
++
++ addr
++ fc2580's memory address
++ type : byte
++
++
++ <return value>
++ data
++ a byte of data read out of target address 'addr'
++ type : byte
++
++==============================================================================*/
++fci_result_type fc2580_i2c_read( TUNER_MODULE *pTuner, unsigned char addr, unsigned char *read_data );
++
++/*==============================================================================
++ fc2580 initial setting
++
++ This function is a generic function which gets called to initialize
++
++ fc2580 in DVB-H mode or L-Band TDMB mode
++
++ <input parameter>
++
++ ifagc_mode
++ type : integer
++ 1 : Internal AGC
++ 2 : Voltage Control Mode
++
++==============================================================================*/
++fci_result_type fc2580_set_init( TUNER_MODULE *pTuner, int ifagc_mode, unsigned int freq_xtal );
++
++/*==============================================================================
++ fc2580 frequency setting
++
++ This function is a generic function which gets called to change LO Frequency
++
++ of fc2580 in DVB-H mode or L-Band TDMB mode
++
++ <input parameter>
++
++ f_lo
++ Value of target LO Frequency in 'kHz' unit
++ ex) 2.6GHz = 2600000
++
++==============================================================================*/
++fci_result_type fc2580_set_freq( TUNER_MODULE *pTuner, unsigned int f_lo, unsigned int freq_xtal );
++
++
++/*==============================================================================
++ fc2580 filter BW setting
++
++ This function is a generic function which gets called to change Bandwidth
++
++ frequency of fc2580's channel selection filter
++
++ <input parameter>
++
++ filter_bw
++ 1 : 1.53MHz(TDMB)
++ 6 : 6MHz
++ 7 : 7MHz
++ 8 : 7.8MHz
++
++
++==============================================================================*/
++fci_result_type fc2580_set_filter( TUNER_MODULE *pTuner, unsigned char filter_bw, unsigned int freq_xtal );
++
++/*==============================================================================
++ fc2580 RSSI function
++
++ This function is a generic function which returns fc2580's
++
++ current RSSI value.
++
++
++
++
++==============================================================================*/
++//int fc2580_get_rssi(void);
++
++/*==============================================================================
++ fc2580 Xtal frequency Setting
++
++ This function is a generic function which sets
++
++ the frequency of xtal.
++
++ <input parameter>
++
++ frequency
++ frequency value of internal(external) Xtal(clock) in kHz unit.
++
++==============================================================================*/
++//void fc2580_set_freq_xtal(unsigned int frequency);
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is FC2580 tuner API source code
++
++
++
++
++
++// Definitions
++
++// AGC mode
++enum FC2580_AGC_MODE
++{
++ FC2580_AGC_INTERNAL = 1,
++ FC2580_AGC_EXTERNAL = 2,
++};
++
++
++// Bandwidth mode
++enum FC2580_BANDWIDTH_MODE
++{
++ FC2580_BANDWIDTH_1530000HZ = 1,
++ FC2580_BANDWIDTH_6000000HZ = 6,
++ FC2580_BANDWIDTH_7000000HZ = 7,
++ FC2580_BANDWIDTH_8000000HZ = 8,
++};
++
++
++
++
++
++// FC2580 extra module
++typedef struct FC2580_EXTRA_MODULE_TAG FC2580_EXTRA_MODULE;
++
++
++
++
++
++// FC2580 bandwidth mode setting function pointer
++typedef int
++(*FC2580_FP_SET_BANDWIDTH_MODE)(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ );
++
++
++
++// FC2580 bandwidth mode getting function pointer
++typedef int
++(*FC2580_FP_GET_BANDWIDTH_MODE)(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ );
++
++
++
++
++
++// FC2580 extra module
++struct FC2580_EXTRA_MODULE_TAG
++{
++ // FC2580 extra variables
++ unsigned long CrystalFreqHz;
++ int AgcMode;
++ int BandwidthMode;
++ int IsBandwidthModeSet;
++
++ // FC2580 extra function pointers
++ FC2580_FP_SET_BANDWIDTH_MODE SetBandwidthMode;
++ FC2580_FP_GET_BANDWIDTH_MODE GetBandwidthMode;
++};
++
++
++
++
++
++// Builder
++void
++BuildFc2580Module(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ FC2580_EXTRA_MODULE *pFc2580ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr,
++ unsigned long CrystalFreqHz,
++ int AgcMode
++ );
++
++
++
++
++
++// Manipulaing functions
++void
++fc2580_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ );
++
++void
++fc2580_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ );
++
++int
++fc2580_Initialize(
++ TUNER_MODULE *pTuner
++ );
++
++int
++fc2580_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ );
++
++int
++fc2580_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ );
++
++
++
++
++
++// Extra manipulaing functions
++int
++fc2580_SetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ );
++
++int
++fc2580_GetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ );
++
++
++
++
++
++// I2C birdge module demod argument setting
++void
++fc2580_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ );
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_mt2266.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_mt2266.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,3331 @@
++/**
++
++@file
++
++@brief MT2266 tuner module definition
++
++One can manipulate MT2266 tuner through MT2266 module.
++MT2266 module is derived from tuner module.
++
++*/
++
++
++#include "tuner_mt2266.h"
++
++
++
++
++
++/**
++
++@brief MT2266 tuner module builder
++
++Use BuildMt2266Module() to build MT2266 module, set all module function pointers with the corresponding functions,
++and initialize module private variables.
++
++
++@param [in] ppTuner Pointer to MT2266 tuner module pointer
++@param [in] pTunerModuleMemory Pointer to an allocated tuner module memory
++@param [in] pMt2266ExtraModuleMemory Pointer to an allocated MT2266 extra module memory
++@param [in] pBaseInterfaceModuleMemory Pointer to an allocated base interface module memory
++@param [in] pI2cBridgeModuleMemory Pointer to an allocated I2C bridge module memory
++@param [in] DeviceAddr MT2266 I2C device address
++
++
++@note
++ -# One should call BuildMt2266Module() to build MT2266 module before using it.
++
++*/
++void
++BuildMt2266Module(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ MT2266_EXTRA_MODULE *pMt2266ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr
++ )
++{
++ TUNER_MODULE *pTuner;
++ MT2266_EXTRA_MODULE *pExtra;
++
++
++
++ // Set tuner module pointer.
++ *ppTuner = pTunerModuleMemory;
++
++ // Get tuner module.
++ pTuner = *ppTuner;
++
++ // Set tuner extra module pointer, base interface module pointer, and I2C bridge module pointer.
++ pTuner->pExtra = pMt2266ExtraModuleMemory;
++ pTuner->pBaseInterface = pBaseInterfaceModuleMemory;
++ pTuner->pI2cBridge = pI2cBridgeModuleMemory;
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++
++
++ // Set tuner type.
++ pTuner->TunerType = TUNER_TYPE_MT2266;
++
++ // Set tuner I2C device address.
++ pTuner->DeviceAddr = DeviceAddr;
++
++
++ // Initialize tuner parameter setting status.
++ pTuner->IsRfFreqHzSet = NO;
++
++
++ // Set I2C bridge tuner arguments.
++ mt2266_SetI2cBridgeModuleTunerArg(pTuner);
++
++
++ // Set tuner module manipulating function pointers.
++ pTuner->GetTunerType = mt2266_GetTunerType;
++ pTuner->GetDeviceAddr = mt2266_GetDeviceAddr;
++
++ pTuner->Initialize = mt2266_Initialize;
++ pTuner->SetRfFreqHz = mt2266_SetRfFreqHz;
++ pTuner->GetRfFreqHz = mt2266_GetRfFreqHz;
++
++
++ // Initialize tuner extra module variables.
++ pExtra->IsBandwidthHzSet = NO;
++
++ // Set tuner extra module function pointers.
++ pExtra->OpenHandle = mt2266_OpenHandle;
++ pExtra->CloseHandle = mt2266_CloseHandle;
++ pExtra->GetHandle = mt2266_GetHandle;
++ pExtra->SetBandwidthHz = mt2266_SetBandwidthHz;
++ pExtra->GetBandwidthHz = mt2266_GetBandwidthHz;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_TUNER_TYPE
++
++*/
++void
++mt2266_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ )
++{
++ // Get tuner type from tuner module.
++ *pTunerType = pTuner->TunerType;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_DEVICE_ADDR
++
++*/
++void
++mt2266_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ )
++{
++ // Get tuner I2C device address from tuner module.
++ *pDeviceAddr = pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_INITIALIZE
++
++*/
++int
++mt2266_Initialize(
++ TUNER_MODULE *pTuner
++ )
++{
++ MT2266_EXTRA_MODULE *pExtra;
++
++ Handle_t DeviceHandle;
++ UData_t Status;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get tuner handle.
++ DeviceHandle = pExtra->DeviceHandle;
++
++
++ // Re-initialize tuner.
++ Status = MT2266_ReInit(DeviceHandle);
++
++ if(MT_IS_ERROR(Status))
++ goto error_status_initialize_tuner;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_initialize_tuner:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_SET_RF_FREQ_HZ
++
++*/
++int
++mt2266_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ )
++{
++ MT2266_EXTRA_MODULE *pExtra;
++
++ Handle_t DeviceHandle;
++ UData_t Status;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get tuner handle.
++ DeviceHandle = pExtra->DeviceHandle;
++
++
++ // Set tuner RF frequency in Hz.
++ Status = MT2266_ChangeFreq(DeviceHandle, RfFreqHz);
++
++ if(MT_IS_ERROR(Status))
++ goto error_status_set_tuner_rf_frequency;
++
++
++ // Set tuner RF frequency parameter.
++ pTuner->RfFreqHz = RfFreqHz;
++ pTuner->IsRfFreqHzSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_RF_FREQ_HZ
++
++*/
++int
++mt2266_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ )
++{
++ // Get tuner RF frequency in Hz from tuner module.
++ if(pTuner->IsRfFreqHzSet != YES)
++ goto error_status_get_tuner_rf_frequency;
++
++ *pRfFreqHz = pTuner->RfFreqHz;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Open MT2266 tuner handle.
++
++*/
++int
++mt2266_OpenHandle(
++ TUNER_MODULE *pTuner
++ )
++{
++ MT2266_EXTRA_MODULE *pExtra;
++
++ unsigned char DeviceAddr;
++ UData_t Status;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get tuner I2C device address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++
++ // Open MT2266 handle.
++ // Note: 1. Must take tuner extra module DeviceHandle as handle input argument.
++ // 2. Take pTuner as user-defined data input argument.
++ Status = MT2266_Open(DeviceAddr, &pExtra->DeviceHandle, pTuner);
++
++ if(MT_IS_ERROR(Status))
++ goto error_status_open_mt2266_handle;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_open_mt2266_handle:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Close MT2266 tuner handle.
++
++*/
++int
++mt2266_CloseHandle(
++ TUNER_MODULE *pTuner
++ )
++{
++ MT2266_EXTRA_MODULE *pExtra;
++
++ Handle_t DeviceHandle;
++ UData_t Status;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get tuner handle.
++ DeviceHandle = pExtra->DeviceHandle;
++
++
++ // Close MT2266 handle.
++ Status = MT2266_Close(DeviceHandle);
++
++ if(MT_IS_ERROR(Status))
++ goto error_status_open_mt2266_handle;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_open_mt2266_handle:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Get MT2266 tuner handle.
++
++*/
++void
++mt2266_GetHandle(
++ TUNER_MODULE *pTuner,
++ void **pDeviceHandle
++ )
++{
++ MT2266_EXTRA_MODULE *pExtra;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get tuner handle.
++ *pDeviceHandle = pExtra->DeviceHandle;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@brief Set MT2266 tuner bandwidth in Hz.
++
++*/
++int
++mt2266_SetBandwidthHz(
++ TUNER_MODULE *pTuner,
++ unsigned long BandwidthHz
++ )
++{
++ MT2266_EXTRA_MODULE *pExtra;
++
++ Handle_t DeviceHandle;
++ UData_t Status;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get tuner handle.
++ DeviceHandle = pExtra->DeviceHandle;
++
++
++ // Set tuner bandwidth in Hz.
++ Status = MT2266_SetParam(DeviceHandle, MT2266_OUTPUT_BW, BandwidthHz);
++
++ if(MT_IS_ERROR(Status))
++ goto error_status_set_tuner_bandwidth;
++
++
++ // Set tuner bandwidth parameter.
++ pExtra->BandwidthHz = BandwidthHz;
++ pExtra->IsBandwidthHzSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_bandwidth:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Get MT2266 tuner bandwidth in Hz.
++
++*/
++int
++mt2266_GetBandwidthHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pBandwidthHz
++ )
++{
++ MT2266_EXTRA_MODULE *pExtra;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MT2266_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Get tuner bandwidth in Hz from tuner module.
++ if(pExtra->IsBandwidthHzSet != YES)
++ goto error_status_get_tuner_bandwidth;
++
++ *pBandwidthHz = pExtra->BandwidthHz;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_bandwidth:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set I2C bridge module tuner arguments.
++
++MT2266 builder will use mt2266_SetI2cBridgeModuleTunerArg() to set I2C bridge module tuner arguments.
++
++
++@param [in] pTuner The tuner module pointer
++
++
++@see BuildMt2266Module()
++
++*/
++void
++mt2266_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ )
++{
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++
++
++ // Get I2C bridge module.
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Set I2C bridge module tuner arguments.
++ pI2cBridge->pTunerDeviceAddr = &pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is source code provided by Microtune.
++
++
++
++
++
++// Microtune source code - mt_userdef.c
++
++
++/*****************************************************************************
++**
++** Name: mt_userdef.c
++**
++** Description: User-defined MicroTuner software interface
++**
++** Functions
++** Requiring
++** Implementation: MT_WriteSub
++** MT_ReadSub
++** MT_Sleep
++**
++** References: None
++**
++** Exports: None
++**
++** CVS ID: $Id: mt_userdef.c,v 1.2 2006/10/26 16:39:18 software Exp $
++** CVS Source: $Source: /export/home/cvsroot/software/tuners/MT2266/mt_userdef.c,v $
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++**
++*****************************************************************************/
++//#include "mt_userdef.h"
++
++
++/*****************************************************************************
++**
++** Name: MT_WriteSub
++**
++** Description: Write values to device using a two-wire serial bus.
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** addr - device serial bus address (value passed
++** as parameter to MTxxxx_Open)
++** subAddress - serial bus sub-address (Register Address)
++** pData - pointer to the Data to be written to the
++** device
++** cnt - number of bytes/registers to be written
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** user-defined
++**
++** Notes: This is a callback function that is called from the
++** the tuning algorithm. You MUST provide code for this
++** function to write data using the tuner's 2-wire serial
++** bus.
++**
++** The hUserData parameter is a user-specific argument.
++** If additional arguments are needed for the user's
++** serial bus read/write functions, this argument can be
++** used to supply the necessary information.
++** The hUserData parameter is initialized in the tuner's Open
++** function.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++**
++*****************************************************************************/
++UData_t MT_WriteSub(Handle_t hUserData,
++ UData_t addr,
++ U8Data subAddress,
++ U8Data *pData,
++ UData_t cnt)
++{
++// UData_t status = MT_OK; /* Status to be returned */
++ /*
++ ** ToDo: Add code here to implement a serial-bus write
++ ** operation to the MTxxxx tuner. If successful,
++ ** return MT_OK.
++ */
++/* return status; */
++
++
++ TUNER_MODULE *pTuner;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++ unsigned int i, j;
++
++ unsigned char RegStartAddr;
++ unsigned char *pWritingBytes;
++ unsigned char ByteNum;
++
++ unsigned char WritingBuffer[I2C_BUFFER_LEN];
++ unsigned char WritingByteNum, WritingByteNumMax, WritingByteNumRem;
++ unsigned char RegWritingAddr;
++ unsigned char TunerDeviceAddr;
++
++ struct dvb_usb_device *d;
++
++ // Get tuner module, base interface, and I2C bridge.
++ pTuner = (TUNER_MODULE *)hUserData;
++ pBaseInterface = pTuner->pBaseInterface;
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d); //add by chialing
++
++
++ // Get regiser start address, writing bytes, and byte number.
++ RegStartAddr = subAddress;
++ pWritingBytes = pData;
++ ByteNum = (unsigned char)cnt;
++
++
++ // Calculate maximum writing byte number.
++ WritingByteNumMax = pBaseInterface->I2cWritingByteNumMax - LEN_1_BYTE;
++
++
++ // Set tuner register bytes with writing bytes.
++ // Note: Set tuner register bytes considering maximum writing byte number.
++ for(i = 0; i < ByteNum; i += WritingByteNumMax)
++ {
++ // Set register writing address.
++ RegWritingAddr = RegStartAddr + i;
++
++ // Calculate remainder writing byte number.
++ WritingByteNumRem = ByteNum - i;
++
++ // Determine writing byte number.
++ WritingByteNum = (WritingByteNumRem > WritingByteNumMax) ? WritingByteNumMax : WritingByteNumRem;
++
++
++ // Set writing buffer.
++ // Note: The I2C format of tuner register byte setting is as follows:
++ // start_bit + (DeviceAddr | writing_bit) + RegWritingAddr + writing_bytes (WritingByteNum bytes) +
++ // stop_bit
++// WritingBuffer[0] = RegWritingAddr;
++
++ for(j = 0; j < WritingByteNum; j++)
++ WritingBuffer[j] = pWritingBytes[i + j];
++
++
++
++ // Set tuner register bytes with writing buffer.
++// if(pI2cBridge->ForwardI2cWritingCmd(pI2cBridge, WritingBuffer, WritingByteNum + LEN_1_BYTE) !=
++// FUNCTION_SUCCESS)
++// goto error_status_set_tuner_registers;
++
++ if(write_rtl2832_tuner_register( d, TunerDeviceAddr, RegWritingAddr, WritingBuffer, WritingByteNum )) goto error;
++
++
++ }
++
++
++ return MT_OK;
++
++error:
++
++ return MT_COMM_ERR;
++}
++
++
++/*****************************************************************************
++**
++** Name: MT_ReadSub
++**
++** Description: Read values from device using a two-wire serial bus.
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** addr - device serial bus address (value passed
++** as parameter to MTxxxx_Open)
++** subAddress - serial bus sub-address (Register Address)
++** pData - pointer to the Data to be written to the
++** device
++** cnt - number of bytes/registers to be written
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** user-defined
++**
++** Notes: This is a callback function that is called from the
++** the tuning algorithm. You MUST provide code for this
++** function to read data using the tuner's 2-wire serial
++** bus.
++**
++** The hUserData parameter is a user-specific argument.
++** If additional arguments are needed for the user's
++** serial bus read/write functions, this argument can be
++** used to supply the necessary information.
++** The hUserData parameter is initialized in the tuner's Open
++** function.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++**
++*****************************************************************************/
++UData_t MT_ReadSub(Handle_t hUserData,
++ UData_t addr,
++ U8Data subAddress,
++ U8Data *pData,
++ UData_t cnt)
++{
++ // UData_t status = MT_OK; /* Status to be returned */
++
++ /*
++ ** ToDo: Add code here to implement a serial-bus read
++ ** operation to the MTxxxx tuner. If successful,
++ ** return MT_OK.
++ */
++/* return status; */
++
++
++ TUNER_MODULE *pTuner;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++ unsigned int i;
++
++ unsigned char RegStartAddr;
++ unsigned char *pReadingBytes;
++ unsigned char ByteNum;
++
++ unsigned char ReadingByteNum, ReadingByteNumMax, ReadingByteNumRem;
++ unsigned char RegReadingAddr;
++
++ unsigned char TunerDeviceAddr;
++
++
++ struct dvb_usb_device *d;
++
++ // Get tuner module, base interface, and I2C bridge.
++ pTuner = (TUNER_MODULE *)hUserData;
++ pBaseInterface = pTuner->pBaseInterface;
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++
++
++ // Get regiser start address, writing bytes, and byte number.
++ RegStartAddr = subAddress;
++ pReadingBytes = pData;
++ ByteNum = (unsigned char)cnt;
++
++
++ // Calculate maximum reading byte number.
++ ReadingByteNumMax = pBaseInterface->I2cReadingByteNumMax;
++
++
++ // Get tuner register bytes.
++ // Note: Get tuner register bytes considering maximum reading byte number.
++ for(i = 0; i < ByteNum; i += ReadingByteNumMax)
++ {
++ // Set register reading address.
++ RegReadingAddr = RegStartAddr + i;
++
++ // Calculate remainder reading byte number.
++ ReadingByteNumRem = ByteNum - i;
++
++ // Determine reading byte number.
++ ReadingByteNum = (ReadingByteNumRem > ReadingByteNumMax) ? ReadingByteNumMax : ReadingByteNumRem;
++
++
++ // Set tuner register reading address.
++ // Note: The I2C format of tuner register reading address setting is as follows:
++ // start_bit + (DeviceAddr | writing_bit) + RegReadingAddr + stop_bit
++// if(pI2cBridge->ForwardI2cWritingCmd(pI2cBridge, &RegReadingAddr, LEN_1_BYTE) != FUNCTION_SUCCESS)
++// goto error_status_set_tuner_register_reading_address;
++
++ // Get tuner register bytes.
++ // Note: The I2C format of tuner register byte getting is as follows:
++ // start_bit + (DeviceAddr | reading_bit) + reading_bytes (ReadingByteNum bytes) + stop_bit
++// if(pI2cBridge->ForwardI2cReadingCmd(pI2cBridge, &pReadingBytes[i], ReadingByteNum) != FUNCTION_SUCCESS)
++// goto error_status_get_tuner_registers;
++
++ if(read_rtl2832_tuner_register(d, TunerDeviceAddr, RegReadingAddr, &pReadingBytes[i], ReadingByteNum)) goto error;
++
++ }
++
++ return MT_OK;
++
++error:
++ return MT_COMM_ERR;
++}
++
++
++/*****************************************************************************
++**
++** Name: MT_Sleep
++**
++** Description: Delay execution for "nMinDelayTime" milliseconds
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** nMinDelayTime - Delay time in milliseconds
++**
++** Returns: None.
++**
++** Notes: This is a callback function that is called from the
++** the tuning algorithm. You MUST provide code that
++** blocks execution for the specified period of time.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++**
++*****************************************************************************/
++void MT_Sleep(Handle_t hUserData,
++ UData_t nMinDelayTime)
++{
++ /*
++ ** ToDo: Add code here to implement a OS blocking
++ ** for a period of "nMinDelayTime" milliseconds.
++ */
++
++
++ TUNER_MODULE *pTuner;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++
++
++ // Get tuner module, base interface.
++ pTuner = (TUNER_MODULE *)hUserData;
++ pBaseInterface = pTuner->pBaseInterface;
++
++
++ // Wait nMinDelayTime milliseconds.
++ pBaseInterface->WaitMs(pBaseInterface, nMinDelayTime);
++
++
++ return;
++}
++
++
++#if defined(MT2060_CNT)
++#if MT2060_CNT > 0
++/*****************************************************************************
++**
++** Name: MT_TunerGain (MT2060 only)
++**
++** Description: Measure the relative tuner gain using the demodulator
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** pMeas - Tuner gain (1/100 of dB scale).
++** ie. 1234 = 12.34 (dB)
++**
++** Returns: status:
++** MT_OK - No errors
++** user-defined errors could be set
++**
++** Notes: This is a callback function that is called from the
++** the 1st IF location routine. You MUST provide
++** code that measures the relative tuner gain in a dB
++** (not linear) scale. The return value is an integer
++** value scaled to 1/100 of a dB.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 06-16-2004 DAD Original
++** N/A 11-30-2004 DAD Renamed from MT_DemodInputPower. This name
++** better describes what this function does.
++**
++*****************************************************************************/
++UData_t MT_TunerGain(Handle_t hUserData,
++ SData_t* pMeas)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++
++ /*
++ ** ToDo: Add code here to return the gain / power level measured
++ ** at the input to the demodulator.
++ */
++
++
++
++ return (status);
++}
++#endif
++#endif
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// Microtune source code - mt2266.c
++
++
++
++/*****************************************************************************
++**
++** Name: mt2266.c
++**
++** Copyright 2007 Microtune, Inc. All Rights Reserved
++**
++** This source code file contains confidential information and/or trade
++** secrets of Microtune, Inc. or its affiliates and is subject to the
++** terms of your confidentiality agreement with Microtune, Inc. or one of
++** its affiliates, as applicable.
++**
++*****************************************************************************/
++
++/*****************************************************************************
++**
++** Name: mt2266.c
++**
++** Description: Microtune MT2266 Tuner software interface.
++** Supports tuners with Part/Rev code: 0x85.
++**
++** Functions
++** Implemented: UData_t MT2266_Open
++** UData_t MT2266_Close
++** UData_t MT2266_ChangeFreq
++** UData_t MT2266_GetLocked
++** UData_t MT2266_GetParam
++** UData_t MT2266_GetReg
++** UData_t MT2266_GetUHFXFreqs
++** UData_t MT2266_GetUserData
++** UData_t MT2266_ReInit
++** UData_t MT2266_SetParam
++** UData_t MT2266_SetPowerModes
++** UData_t MT2266_SetReg
++** UData_t MT2266_SetUHFXFreqs
++**
++** References: AN-00010: MicroTuner Serial Interface Application Note
++** MicroTune, Inc.
++**
++** Exports: None
++**
++** Dependencies: MT_ReadSub(hUserData, IC_Addr, subAddress, *pData, cnt);
++** - Read byte(s) of data from the two-wire bus.
++**
++** MT_WriteSub(hUserData, IC_Addr, subAddress, *pData, cnt);
++** - Write byte(s) of data to the two-wire bus.
++**
++** MT_Sleep(hUserData, nMinDelayTime);
++** - Delay execution for x milliseconds
++**
++** CVS ID: $Id: mt2266.c,v 1.5 2007/10/02 18:43:17 software Exp $
++** CVS Source: $Source: /export/home/cvsroot/software/tuners/MT2266/mt2266.c,v $
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 06-08-2006 JWS Ver 1.01: Corrected problem with tuner ID check
++** N/A 11-01-2006 RSK Ver 1.02: Adding multiple-filter support
++** as well as Get/Set functions.
++** N/A 11-29-2006 DAD Ver 1.03: Parenthesis clarification for gcc
++** N/A 12-20-2006 RSK Ver 1.04: Adding fLO_FractionalTerm() usage.
++** 118 05-09-2007 RSK Ver 1.05: Adding Standard MTxxxx_Tune() API.
++**
++*****************************************************************************/
++//#include "mt2266.h"
++//#include <stdlib.h> /* for NULL */
++#define MT_NULL 0
++
++/* Version of this module */
++#define VERSION 10005 /* Version 01.05 */
++
++
++#ifndef MT2266_CNT
++#error You must define MT2266_CNT in the "mt_userdef.h" file
++#endif
++
++/*
++** Normally, the "reg" array in the tuner structure is used as a cache
++** containing the current value of the tuner registers. If the user's
++** application MUST change tuner registers without using the MT2266_SetReg
++** routine provided, he may compile this code with the __NO_CACHE__
++** variable defined.
++** The PREFETCH macro will insert code code to re-read tuner registers if
++** __NO_CACHE__ is defined. If it is not defined (normal) then PREFETCH
++** does nothing.
++*/
++
++#if defined(__NO_CACHE__)
++#define PREFETCH(var, cnt) \
++ if (MT_NO_ERROR(status)) \
++ status |= MT_ReadSub(pInfo->hUserData, pInfo->address, (var), &pInfo->reg[(var)], (cnt));
++#else
++#define PREFETCH(var, cnt)
++#endif
++
++
++
++/*
++** Two-wire serial bus subaddresses of the tuner registers.
++** Also known as the tuner's register addresses.
++*/
++enum MT2266_Register_Offsets
++{
++ MT2266_PART_REV = 0, /* 0x00 */
++ MT2266_LO_CTRL_1, /* 0x01 */
++ MT2266_LO_CTRL_2, /* 0x02 */
++ MT2266_LO_CTRL_3, /* 0x03 */
++ MT2266_SMART_ANT, /* 0x04 */
++ MT2266_BAND_CTRL, /* 0x05 */
++ MT2266_CLEARTUNE, /* 0x06 */
++ MT2266_IGAIN, /* 0x07 */
++ MT2266_BBFILT_1, /* 0x08 */
++ MT2266_BBFILT_2, /* 0x09 */
++ MT2266_BBFILT_3, /* 0x0A */
++ MT2266_BBFILT_4, /* 0x0B */
++ MT2266_BBFILT_5, /* 0x0C */
++ MT2266_BBFILT_6, /* 0x0D */
++ MT2266_BBFILT_7, /* 0x0E */
++ MT2266_BBFILT_8, /* 0x0F */
++ MT2266_RCC_CTRL, /* 0x10 */
++ MT2266_RSVD_11, /* 0x11 */
++ MT2266_STATUS_1, /* 0x12 */
++ MT2266_STATUS_2, /* 0x13 */
++ MT2266_STATUS_3, /* 0x14 */
++ MT2266_STATUS_4, /* 0x15 */
++ MT2266_STATUS_5, /* 0x16 */
++ MT2266_SRO_CTRL, /* 0x17 */
++ MT2266_RSVD_18, /* 0x18 */
++ MT2266_RSVD_19, /* 0x19 */
++ MT2266_RSVD_1A, /* 0x1A */
++ MT2266_RSVD_1B, /* 0x1B */
++ MT2266_ENABLES, /* 0x1C */
++ MT2266_RSVD_1D, /* 0x1D */
++ MT2266_RSVD_1E, /* 0x1E */
++ MT2266_RSVD_1F, /* 0x1F */
++ MT2266_GPO, /* 0x20 */
++ MT2266_RSVD_21, /* 0x21 */
++ MT2266_RSVD_22, /* 0x22 */
++ MT2266_RSVD_23, /* 0x23 */
++ MT2266_RSVD_24, /* 0x24 */
++ MT2266_RSVD_25, /* 0x25 */
++ MT2266_RSVD_26, /* 0x26 */
++ MT2266_RSVD_27, /* 0x27 */
++ MT2266_RSVD_28, /* 0x28 */
++ MT2266_RSVD_29, /* 0x29 */
++ MT2266_RSVD_2A, /* 0x2A */
++ MT2266_RSVD_2B, /* 0x2B */
++ MT2266_RSVD_2C, /* 0x2C */
++ MT2266_RSVD_2D, /* 0x2D */
++ MT2266_RSVD_2E, /* 0x2E */
++ MT2266_RSVD_2F, /* 0x2F */
++ MT2266_RSVD_30, /* 0x30 */
++ MT2266_RSVD_31, /* 0x31 */
++ MT2266_RSVD_32, /* 0x32 */
++ MT2266_RSVD_33, /* 0x33 */
++ MT2266_RSVD_34, /* 0x34 */
++ MT2266_RSVD_35, /* 0x35 */
++ MT2266_RSVD_36, /* 0x36 */
++ MT2266_RSVD_37, /* 0x37 */
++ MT2266_RSVD_38, /* 0x38 */
++ MT2266_RSVD_39, /* 0x39 */
++ MT2266_RSVD_3A, /* 0x3A */
++ MT2266_RSVD_3B, /* 0x3B */
++ MT2266_RSVD_3C, /* 0x3C */
++ END_REGS
++};
++
++/*
++** DefaultsEntry points to an array of U8Data used to initialize
++** various registers (the first byte is the starting subaddress)
++** and a count of the bytes (including subaddress) in the array.
++**
++** DefaultsList is an array of DefaultsEntry elements terminated
++** by an entry with a NULL pointer for the data array.
++*/
++typedef struct MT2266_DefaultsEntryTag
++{
++ U8Data *data;
++ UData_t cnt;
++} MT2266_DefaultsEntry;
++
++typedef MT2266_DefaultsEntry MT2266_DefaultsList[];
++
++#define DEF_LIST_ENTRY(a) {a, sizeof(a)/sizeof(U8Data) - 1}
++#define END_DEF_LIST {0,0}
++
++/*
++** Constants used by the tuning algorithm
++*/
++ /* REF_FREQ is now the actual crystal frequency */
++#define REF_FREQ (30000000UL) /* Reference oscillator Frequency (in Hz) */
++#define TUNE_STEP_SIZE (50UL) /* Tune in steps of 50 kHz */
++#define MIN_UHF_FREQ (350000000UL) /* Minimum UHF frequency (in Hz) */
++#define MAX_UHF_FREQ (900000000UL) /* Maximum UHF frequency (in Hz) */
++#define MIN_VHF_FREQ (174000000UL) /* Minimum VHF frequency (in Hz) */
++#define MAX_VHF_FREQ (230000000UL) /* Maximum VHF frequency (in Hz) */
++#define OUTPUT_BW (8000000UL) /* Output channel bandwidth (in Hz) */
++#define UHF_DEFAULT_FREQ (600000000UL) /* Default UHF input frequency (in Hz) */
++
++
++/*
++** The number of Tuner Registers
++*/
++static const UData_t Num_Registers = END_REGS;
++
++/*
++** Crossover Frequency sets for 2 filters, without and with attenuation.
++*/
++typedef struct
++{
++ MT2266_XFreq_Set xfreq[ MT2266_NUMBER_OF_XFREQ_SETS ];
++
++} MT2266_XFreqs_t;
++
++
++MT2266_XFreqs_t MT2266_default_XFreqs =
++{
++ /* xfreq */
++ {
++ /* uhf0 */
++ { /* < 0 MHz: 15+1 */
++ 0UL, /* 0 .. 0 MHz: 15 */
++ 0UL, /* 0 .. 443 MHz: 14 */
++ 443000 / TUNE_STEP_SIZE, /* 443 .. 470 MHz: 13 */
++ 470000 / TUNE_STEP_SIZE, /* 470 .. 496 MHz: 12 */
++ 496000 / TUNE_STEP_SIZE, /* 496 .. 525 MHz: 11 */
++ 525000 / TUNE_STEP_SIZE, /* 525 .. 552 MHz: 10 */
++ 552000 / TUNE_STEP_SIZE, /* 552 .. 580 MHz: 9 */
++ 580000 / TUNE_STEP_SIZE, /* 580 .. 657 MHz: 8 */
++ 657000 / TUNE_STEP_SIZE, /* 657 .. 682 MHz: 7 */
++ 682000 / TUNE_STEP_SIZE, /* 682 .. 710 MHz: 6 */
++ 710000 / TUNE_STEP_SIZE, /* 710 .. 735 MHz: 5 */
++ 735000 / TUNE_STEP_SIZE, /* 735 .. 763 MHz: 4 */
++ 763000 / TUNE_STEP_SIZE, /* 763 .. 802 MHz: 3 */
++ 802000 / TUNE_STEP_SIZE, /* 802 .. 840 MHz: 2 */
++ 840000 / TUNE_STEP_SIZE, /* 840 .. 877 MHz: 1 */
++ 877000 / TUNE_STEP_SIZE /* 877+ MHz: 0 */
++ },
++
++ /* uhf1 */
++ { /* < 443 MHz: 15+1 */
++ 443000 / TUNE_STEP_SIZE, /* 443 .. 470 MHz: 15 */
++ 470000 / TUNE_STEP_SIZE, /* 470 .. 496 MHz: 14 */
++ 496000 / TUNE_STEP_SIZE, /* 496 .. 525 MHz: 13 */
++ 525000 / TUNE_STEP_SIZE, /* 525 .. 552 MHz: 12 */
++ 552000 / TUNE_STEP_SIZE, /* 552 .. 580 MHz: 11 */
++ 580000 / TUNE_STEP_SIZE, /* 580 .. 605 MHz: 10 */
++ 605000 / TUNE_STEP_SIZE, /* 605 .. 632 MHz: 9 */
++ 632000 / TUNE_STEP_SIZE, /* 632 .. 657 MHz: 8 */
++ 657000 / TUNE_STEP_SIZE, /* 657 .. 682 MHz: 7 */
++ 682000 / TUNE_STEP_SIZE, /* 682 .. 710 MHz: 6 */
++ 710000 / TUNE_STEP_SIZE, /* 710 .. 735 MHz: 5 */
++ 735000 / TUNE_STEP_SIZE, /* 735 .. 763 MHz: 4 */
++ 763000 / TUNE_STEP_SIZE, /* 763 .. 802 MHz: 3 */
++ 802000 / TUNE_STEP_SIZE, /* 802 .. 840 MHz: 2 */
++ 840000 / TUNE_STEP_SIZE, /* 840 .. 877 MHz: 1 */
++ 877000 / TUNE_STEP_SIZE /* 877+ MHz: 0 */
++ },
++
++ /* uhf0_a */
++ { /* < 0 MHz: 15+1 */
++ 0UL, /* 0 .. 0 MHz: 15 */
++ 0UL, /* 0 .. 442 MHz: 14 */
++ 442000 / TUNE_STEP_SIZE, /* 442 .. 472 MHz: 13 */
++ 472000 / TUNE_STEP_SIZE, /* 472 .. 505 MHz: 12 */
++ 505000 / TUNE_STEP_SIZE, /* 505 .. 535 MHz: 11 */
++ 535000 / TUNE_STEP_SIZE, /* 535 .. 560 MHz: 10 */
++ 560000 / TUNE_STEP_SIZE, /* 560 .. 593 MHz: 9 */
++ 593000 / TUNE_STEP_SIZE, /* 593 .. 673 MHz: 8 */
++ 673000 / TUNE_STEP_SIZE, /* 673 .. 700 MHz: 7 */
++ 700000 / TUNE_STEP_SIZE, /* 700 .. 727 MHz: 6 */
++ 727000 / TUNE_STEP_SIZE, /* 727 .. 752 MHz: 5 */
++ 752000 / TUNE_STEP_SIZE, /* 752 .. 783 MHz: 4 */
++ 783000 / TUNE_STEP_SIZE, /* 783 .. 825 MHz: 3 */
++ 825000 / TUNE_STEP_SIZE, /* 825 .. 865 MHz: 2 */
++ 865000 / TUNE_STEP_SIZE, /* 865 .. 905 MHz: 1 */
++ 905000 / TUNE_STEP_SIZE /* 905+ MHz: 0 */
++ },
++
++ /* uhf1_a */
++ { /* < 442 MHz: 15+1 */
++ 442000 / TUNE_STEP_SIZE, /* 442 .. 472 MHz: 15 */
++ 472000 / TUNE_STEP_SIZE, /* 472 .. 505 MHz: 14 */
++ 505000 / TUNE_STEP_SIZE, /* 505 .. 535 MHz: 13 */
++ 535000 / TUNE_STEP_SIZE, /* 535 .. 560 MHz: 12 */
++ 560000 / TUNE_STEP_SIZE, /* 560 .. 593 MHz: 11 */
++ 593000 / TUNE_STEP_SIZE, /* 593 .. 620 MHz: 10 */
++ 620000 / TUNE_STEP_SIZE, /* 620 .. 647 MHz: 9 */
++ 647000 / TUNE_STEP_SIZE, /* 647 .. 673 MHz: 8 */
++ 673000 / TUNE_STEP_SIZE, /* 673 .. 700 MHz: 7 */
++ 700000 / TUNE_STEP_SIZE, /* 700 .. 727 MHz: 6 */
++ 727000 / TUNE_STEP_SIZE, /* 727 .. 752 MHz: 5 */
++ 752000 / TUNE_STEP_SIZE, /* 752 .. 783 MHz: 4 */
++ 783000 / TUNE_STEP_SIZE, /* 783 .. 825 MHz: 3 */
++ 825000 / TUNE_STEP_SIZE, /* 825 .. 865 MHz: 2 */
++ 865000 / TUNE_STEP_SIZE, /* 865 .. 905 MHz: 1 */
++ 905000 / TUNE_STEP_SIZE /* 905+ MHz: 0 */
++ }
++ }
++};
++
++typedef struct
++{
++ Handle_t handle;
++ Handle_t hUserData;
++ UData_t address;
++ UData_t version;
++ UData_t tuner_id;
++ UData_t f_Ref;
++ UData_t f_Step;
++ UData_t f_in;
++ UData_t f_LO;
++ UData_t f_bw;
++ UData_t band;
++ UData_t num_regs;
++ U8Data RC2_Value;
++ U8Data RC2_Nominal;
++ U8Data reg[END_REGS];
++
++ MT2266_XFreqs_t xfreqs;
++
++} MT2266_Info_t;
++
++static UData_t nMaxTuners = MT2266_CNT;
++static MT2266_Info_t MT2266_Info[MT2266_CNT];
++static MT2266_Info_t *Avail[MT2266_CNT];
++static UData_t nOpenTuners = 0;
++
++/*
++** Constants used to write a minimal set of registers when changing bands.
++** If the user wants a total reset, they should call MT2266_Open() again.
++** Skip 01, 02, 03, 04 (get overwritten anyways)
++** Write 05
++** Skip 06 - 18
++** Write 19 (diff for L-Band)
++** Skip 1A 1B 1C
++** Write 1D - 2B
++** Skip 2C - 3C
++*/
++
++static U8Data MT2266_VHF_defaults1[] =
++{
++ 0x05, /* address 0xC0, reg 0x05 */
++ 0x04, /* Reg 0x05 LBANDen = 1 (that's right)*/
++};
++static U8Data MT2266_VHF_defaults2[] =
++{
++ 0x19, /* address 0xC0, reg 0x19 */
++ 0x61, /* Reg 0x19 CAPto = 3*/
++};
++static U8Data MT2266_VHF_defaults3[] =
++{
++ 0x1D, /* address 0xC0, reg 0x1D */
++ 0xFE, /* reg 0x1D */
++ 0x00, /* reg 0x1E */
++ 0x00, /* reg 0x1F */
++ 0xB4, /* Reg 0x20 GPO = 1*/
++ 0x03, /* Reg 0x21 LBIASen = 1, UBIASen = 1*/
++ 0xA5, /* Reg 0x22 */
++ 0xA5, /* Reg 0x23 */
++ 0xA5, /* Reg 0x24 */
++ 0xA5, /* Reg 0x25 */
++ 0x82, /* Reg 0x26 CASCM = b0001 (bits reversed)*/
++ 0xAA, /* Reg 0x27 */
++ 0xF1, /* Reg 0x28 */
++ 0x17, /* Reg 0x29 */
++ 0x80, /* Reg 0x2A MIXbiasen = 1*/
++ 0x1F, /* Reg 0x2B */
++};
++
++static MT2266_DefaultsList MT2266_VHF_defaults = {
++ DEF_LIST_ENTRY(MT2266_VHF_defaults1),
++ DEF_LIST_ENTRY(MT2266_VHF_defaults2),
++ DEF_LIST_ENTRY(MT2266_VHF_defaults3),
++ END_DEF_LIST
++};
++
++static U8Data MT2266_UHF_defaults1[] =
++{
++ 0x05, /* address 0xC0, reg 0x05 */
++ 0x52, /* Reg 0x05 */
++};
++static U8Data MT2266_UHF_defaults2[] =
++{
++ 0x19, /* address 0xC0, reg 0x19 */
++ 0x61, /* Reg 0x19 CAPto = 3*/
++};
++static U8Data MT2266_UHF_defaults3[] =
++{
++ 0x1D, /* address 0xC0, reg 0x1D */
++ 0xDC, /* Reg 0x1D */
++ 0x00, /* Reg 0x1E */
++ 0x0A, /* Reg 0x1F */
++ 0xD4, /* Reg 0x20 GPO = 1*/
++ 0x03, /* Reg 0x21 LBIASen = 1, UBIASen = 1*/
++ 0x64, /* Reg 0x22 */
++ 0x64, /* Reg 0x23 */
++ 0x64, /* Reg 0x24 */
++ 0x64, /* Reg 0x25 */
++ 0x22, /* Reg 0x26 CASCM = b0100 (bits reversed)*/
++ 0xAA, /* Reg 0x27 */
++ 0xF2, /* Reg 0x28 */
++ 0x1E, /* Reg 0x29 */
++ 0x80, /* Reg 0x2A MIXbiasen = 1*/
++ 0x14, /* Reg 0x2B */
++};
++
++static MT2266_DefaultsList MT2266_UHF_defaults = {
++ DEF_LIST_ENTRY(MT2266_UHF_defaults1),
++ DEF_LIST_ENTRY(MT2266_UHF_defaults2),
++ DEF_LIST_ENTRY(MT2266_UHF_defaults3),
++ END_DEF_LIST
++};
++
++
++static UData_t UncheckedSet(MT2266_Info_t* pInfo,
++ U8Data reg,
++ U8Data val);
++
++static UData_t UncheckedGet(MT2266_Info_t* pInfo,
++ U8Data reg,
++ U8Data* val);
++
++
++/******************************************************************************
++**
++** Name: MT2266_Open
++**
++** Description: Initialize the tuner's register values.
++**
++** Parameters: MT2266_Addr - Serial bus address of the tuner.
++** hMT2266 - Tuner handle passed back.
++** hUserData - User-defined data, if needed for the
++** MT_ReadSub() & MT_WriteSub functions.
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch
++** MT_TUNER_INIT_ERR - Tuner initialization failed
++** MT_COMM_ERR - Serial bus communications error
++** MT_ARG_NULL - Null pointer argument passed
++** MT_TUNER_CNT_ERR - Too many tuners open
++**
++** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus
++** MT_WriteSub - Write byte(s) of data to the two-wire bus
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 11-01-2006 RSK Ver 1.02: Initialize Crossover Tables to Default
++**
++******************************************************************************/
++UData_t MT2266_Open(UData_t MT2266_Addr,
++ Handle_t* hMT2266,
++ Handle_t hUserData)
++{
++ UData_t status = MT_OK; /* Status to be returned. */
++ SData_t i, j;
++ MT2266_Info_t* pInfo = MT_NULL;
++
++ /* Check the argument before using */
++ if (hMT2266 == MT_NULL)
++ return MT_ARG_NULL;
++ *hMT2266 = MT_NULL;
++
++ /*
++ ** If this is our first tuner, initialize the address fields and
++ ** the list of available control blocks.
++ */
++ if (nOpenTuners == 0)
++ {
++ for (i=MT2266_CNT-1; i>=0; i--)
++ {
++ MT2266_Info[i].handle = MT_NULL;
++ MT2266_Info[i].address = MAX_UDATA;
++ MT2266_Info[i].hUserData = MT_NULL;
++
++ /* Reset the UHF Crossover Frequency tables on open/init. */
++ for (j=0; j< MT2266_NUM_XFREQS; j++ )
++ {
++ MT2266_Info[i].xfreqs.xfreq[MT2266_UHF0][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF0][j];
++ MT2266_Info[i].xfreqs.xfreq[MT2266_UHF1][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF1][j];
++ MT2266_Info[i].xfreqs.xfreq[MT2266_UHF0_ATTEN][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF0_ATTEN][j];
++ MT2266_Info[i].xfreqs.xfreq[MT2266_UHF1_ATTEN][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF1_ATTEN][j];
++ }
++
++ Avail[i] = &MT2266_Info[i];
++ }
++ }
++
++ /*
++ ** Look for an existing MT2266_State_t entry with this address.
++ */
++ for (i=MT2266_CNT-1; i>=0; i--)
++ {
++ /*
++ ** If an open'ed handle provided, we'll re-initialize that structure.
++ **
++ ** We recognize an open tuner because the address and hUserData are
++ ** the same as one that has already been opened
++ */
++ if ((MT2266_Info[i].address == MT2266_Addr) &&
++ (MT2266_Info[i].hUserData == hUserData))
++ {
++ pInfo = &MT2266_Info[i];
++ break;
++ }
++ }
++
++ /* If not found, choose an empty spot. */
++ if (pInfo == MT_NULL)
++ {
++ /* Check to see that we're not over-allocating. */
++ if (nOpenTuners == MT2266_CNT)
++ return MT_TUNER_CNT_ERR;
++
++ /* Use the next available block from the list */
++ pInfo = Avail[nOpenTuners];
++ nOpenTuners++;
++ }
++
++ pInfo->handle = (Handle_t) pInfo;
++ pInfo->hUserData = hUserData;
++ pInfo->address = MT2266_Addr;
++
++// status |= MT2266_ReInit((Handle_t) pInfo);
++
++ if (MT_IS_ERROR(status))
++ MT2266_Close((Handle_t) pInfo);
++ else
++ *hMT2266 = pInfo->handle;
++
++ return (status);
++}
++
++
++static UData_t IsValidHandle(MT2266_Info_t* handle)
++{
++ return ((handle != MT_NULL) && (handle->handle == handle)) ? 1 : 0;
++}
++
++
++/******************************************************************************
++**
++** Name: MT2266_Close
++**
++** Description: Release the handle to the tuner.
++**
++** Parameters: hMT2266 - Handle to the MT2266 tuner
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: mt_errordef.h - definition of error codes
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++******************************************************************************/
++UData_t MT2266_Close(Handle_t hMT2266)
++{
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) hMT2266;
++
++ if (!IsValidHandle(pInfo))
++ return MT_INV_HANDLE;
++
++ /* Remove the tuner from our list of tuners */
++ pInfo->handle = MT_NULL;
++ pInfo->address = MAX_UDATA;
++ pInfo->hUserData = MT_NULL;
++ nOpenTuners--;
++ Avail[nOpenTuners] = pInfo; /* Return control block to available list */
++
++ return MT_OK;
++}
++
++
++/******************************************************************************
++**
++** Name: Run_BB_RC_Cal2
++**
++** Description: Run Base Band RC Calibration (Method 2)
++** MT2266 B0 only, others return MT_OK
++**
++** Parameters: hMT2266 - Handle to the MT2266 tuner
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: mt_errordef.h - definition of error codes
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++******************************************************************************/
++static UData_t Run_BB_RC_Cal2(Handle_t h)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ U8Data tmp_rcc;
++ U8Data dumy;
++
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ /*
++ ** Set the crystal frequency in the calibration register
++ ** and enable RC calibration #2
++ */
++ PREFETCH(MT2266_RCC_CTRL, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++ tmp_rcc = pInfo->reg[MT2266_RCC_CTRL];
++ if (pInfo->f_Ref < (36000000 /*/ TUNE_STEP_SIZE*/))
++ tmp_rcc = (tmp_rcc & 0xDF) | 0x10;
++ else
++ tmp_rcc |= 0x30;
++ status |= UncheckedSet(pInfo, MT2266_RCC_CTRL, tmp_rcc);
++
++ /* Read RC Calibration value */
++ status |= UncheckedGet(pInfo, MT2266_STATUS_4, &dumy);
++
++ /* Disable RC Cal 2 */
++ status |= UncheckedSet(pInfo, MT2266_RCC_CTRL, pInfo->reg[MT2266_RCC_CTRL] & 0xEF);
++
++ /* Store RC Cal 2 value */
++ pInfo->RC2_Value = pInfo->reg[MT2266_STATUS_4];
++
++ if (pInfo->f_Ref < (36000000 /*/ TUNE_STEP_SIZE*/))
++ pInfo->RC2_Nominal = (U8Data) ((pInfo->f_Ref + 77570) / 155139);
++ else
++ pInfo->RC2_Nominal = (U8Data) ((pInfo->f_Ref + 93077) / 186154);
++
++ return (status);
++}
++
++
++/******************************************************************************
++**
++** Name: Set_BBFilt
++**
++** Description: Set Base Band Filter bandwidth
++** Based on SRO frequency & BB RC Calibration
++** User stores channel bw as 5-8 MHz. This routine
++** calculates a 3 dB corner bw based on 1/2 the bandwidth
++** and a bandwidth related constant.
++**
++** Parameters: hMT2266 - Handle to the MT2266 tuner
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: mt_errordef.h - definition of error codes
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++******************************************************************************/
++static UData_t Set_BBFilt(Handle_t h)
++{
++ UData_t f_3dB_bw;
++ U8Data BBFilt = 0;
++ U8Data Sel = 0;
++ SData_t TmpFilt;
++ SData_t i;
++ UData_t status = MT_OK; /* Status to be returned */
++
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ /* Check RC2_Value value */
++ if(pInfo->RC2_Value == 0)
++ return MT_UNKNOWN;
++
++ /*
++ ** Convert the channel bandwidth into a 3 dB bw by dividing it by 2
++ ** and subtracting 300, 250, 200, or 0 kHz based on 8, 7, 6, 5 MHz
++ ** channel bandwidth.
++ */
++ f_3dB_bw = (pInfo->f_bw / 2); /* bw -> bw/2 */
++ if (pInfo->f_bw > 7500000)
++ {
++ /* >3.75 MHz corner */
++ f_3dB_bw -= 300000;
++ Sel = 0x00;
++ TmpFilt = ((429916107 / pInfo->RC2_Value) * pInfo->RC2_Nominal) / f_3dB_bw - 81;
++ }
++ else if (pInfo->f_bw > 6500000)
++ {
++ /* >3.25 MHz .. 3.75 MHz corner */
++ f_3dB_bw -= 250000;
++ Sel = 0x00;
++ TmpFilt = ((429916107 / pInfo->RC2_Value) * pInfo->RC2_Nominal) / f_3dB_bw - 81;
++ }
++ else if (pInfo->f_bw > 5500000)
++ {
++ /* >2.75 MHz .. 3.25 MHz corner */
++ f_3dB_bw -= 200000;
++ Sel = 0x80;
++ TmpFilt = ((429916107 / pInfo->RC2_Value) * pInfo->RC2_Nominal) / f_3dB_bw - 113;
++ }
++ else
++ {
++ /* <= 2.75 MHz corner */
++ Sel = 0xC0;
++ TmpFilt = ((429916107 / pInfo->RC2_Value) * pInfo->RC2_Nominal) / f_3dB_bw - 129;
++ }
++
++ if (TmpFilt > 63)
++ TmpFilt = 63;
++ else if (TmpFilt < 0)
++ TmpFilt = 0;
++ BBFilt = ((U8Data) TmpFilt) | Sel;
++
++ for ( i = MT2266_BBFILT_1; i <= MT2266_BBFILT_8; i++ )
++ pInfo->reg[i] = BBFilt;
++
++ if (MT_NO_ERROR(status))
++ status |= MT_WriteSub(pInfo->hUserData,
++ pInfo->address,
++ MT2266_BBFILT_1,
++ &pInfo->reg[MT2266_BBFILT_1],
++ 8);
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetLocked
++**
++** Description: Checks to see if the PLL is locked.
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_DNC_UNLOCK - Downconverter PLL unlocked
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: MT_ReadSub - Read byte(s) of data from the serial bus
++** MT_Sleep - Delay execution for x milliseconds
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++UData_t MT2266_GetLocked(Handle_t h)
++{
++ const UData_t nMaxWait = 200; /* wait a maximum of 200 msec */
++ const UData_t nPollRate = 2; /* poll status bits every 2 ms */
++ const UData_t nMaxLoops = nMaxWait / nPollRate;
++ UData_t status = MT_OK; /* Status to be returned */
++ UData_t nDelays = 0;
++ U8Data statreg;
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ if (IsValidHandle(pInfo) == 0)
++ return MT_INV_HANDLE;
++
++ do
++ {
++ status |= UncheckedGet(pInfo, MT2266_STATUS_1, &statreg);
++
++ if ((MT_IS_ERROR(status)) || ((statreg & 0x40) == 0x40))
++ return (status);
++
++ MT_Sleep(pInfo->hUserData, nPollRate); /* Wait between retries */
++ }
++ while (++nDelays < nMaxLoops);
++
++ if ((statreg & 0x40) != 0x40)
++ status |= MT_DNC_UNLOCK;
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetParam
++**
++** Description: Gets a tuning algorithm parameter.
++**
++** This function provides access to the internals of the
++** tuning algorithm - mostly for testing purposes.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** param - Tuning algorithm parameter
++** (see enum MT2266_Param)
++** pValue - ptr to returned value
++**
++** param Description
++** ---------------------- --------------------------------
++** MT2266_IC_ADDR Serial Bus address of this tuner
++** MT2266_MAX_OPEN Max number of MT2266's that can be open
++** MT2266_NUM_OPEN Number of MT2266's currently open
++** MT2266_NUM_REGS Number of tuner registers
++** MT2266_SRO_FREQ crystal frequency
++** MT2266_STEPSIZE minimum tuning step size
++** MT2266_INPUT_FREQ input center frequency
++** MT2266_LO_FREQ LO Frequency
++** MT2266_OUTPUT_BW Output channel bandwidth
++** MT2266_RC2_VALUE Base band filter cal RC code (method 2)
++** MT2266_RC2_NOMINAL Base band filter nominal cal RC code
++** MT2266_RF_ADC RF attenuator A/D readback
++** MT2266_RF_ATTN RF attenuation (0-255)
++** MT2266_RF_EXT External control of RF atten
++** MT2266_LNA_GAIN LNA gain setting (0-15)
++** MT2266_BB_ADC BB attenuator A/D readback
++** MT2266_BB_ATTN Baseband attenuation (0-255)
++** MT2266_BB_EXT External control of BB atten
++**
++** Usage: status |= MT2266_GetParam(hMT2266,
++** MT2266_OUTPUT_BW,
++** &f_bw);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++** MT_ARG_RANGE - Invalid parameter requested
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_SetParam, MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++UData_t MT2266_GetParam(Handle_t h,
++ MT2266_Param param,
++ UData_t* pValue)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ U8Data tmp;
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ if (pValue == MT_NULL)
++ status |= MT_ARG_NULL;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ if (MT_NO_ERROR(status))
++ {
++ switch (param)
++ {
++ /* Serial Bus address of this tuner */
++ case MT2266_IC_ADDR:
++ *pValue = pInfo->address;
++ break;
++
++ /* Max # of MT2266's allowed to be open */
++ case MT2266_MAX_OPEN:
++ *pValue = nMaxTuners;
++ break;
++
++ /* # of MT2266's open */
++ case MT2266_NUM_OPEN:
++ *pValue = nOpenTuners;
++ break;
++
++ /* Number of tuner registers */
++ case MT2266_NUM_REGS:
++ *pValue = Num_Registers;
++ break;
++
++ /* crystal frequency */
++ case MT2266_SRO_FREQ:
++ *pValue = pInfo->f_Ref;
++ break;
++
++ /* minimum tuning step size */
++ case MT2266_STEPSIZE:
++ *pValue = pInfo->f_Step;
++ break;
++
++ /* input center frequency */
++ case MT2266_INPUT_FREQ:
++ *pValue = pInfo->f_in;
++ break;
++
++ /* LO Frequency */
++ case MT2266_LO_FREQ:
++ *pValue = pInfo->f_LO;
++ break;
++
++ /* Output Channel Bandwidth */
++ case MT2266_OUTPUT_BW:
++ *pValue = pInfo->f_bw;
++ break;
++
++ /* Base band filter cal RC code */
++ case MT2266_RC2_VALUE:
++ *pValue = (UData_t) pInfo->RC2_Value;
++ break;
++
++ /* Base band filter nominal cal RC code */
++ case MT2266_RC2_NOMINAL:
++ *pValue = (UData_t) pInfo->RC2_Nominal;
++ break;
++
++ /* RF attenuator A/D readback */
++ case MT2266_RF_ADC:
++ status |= UncheckedGet(pInfo, MT2266_STATUS_2, &tmp);
++ if (MT_NO_ERROR(status))
++ *pValue = (UData_t) tmp;
++ break;
++
++ /* BB attenuator A/D readback */
++ case MT2266_BB_ADC:
++ status |= UncheckedGet(pInfo, MT2266_STATUS_3, &tmp);
++ if (MT_NO_ERROR(status))
++ *pValue = (UData_t) tmp;
++ break;
++
++ /* RF attenuator setting */
++ case MT2266_RF_ATTN:
++ PREFETCH(MT2266_RSVD_1F, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++ if (MT_NO_ERROR(status))
++ *pValue = pInfo->reg[MT2266_RSVD_1F];
++ break;
++
++ /* BB attenuator setting */
++ case MT2266_BB_ATTN:
++ PREFETCH(MT2266_RSVD_2C, 3); /* Fetch register(s) if __NO_CACHE__ defined */
++ *pValue = pInfo->reg[MT2266_RSVD_2C]
++ + pInfo->reg[MT2266_RSVD_2D]
++ + pInfo->reg[MT2266_RSVD_2E] - 3;
++ break;
++
++ /* RF external / internal atten control */
++ case MT2266_RF_EXT:
++ PREFETCH(MT2266_GPO, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++ *pValue = ((pInfo->reg[MT2266_GPO] & 0x40) != 0x00);
++ break;
++
++ /* BB external / internal atten control */
++ case MT2266_BB_EXT:
++ PREFETCH(MT2266_RSVD_33, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++ *pValue = ((pInfo->reg[MT2266_RSVD_33] & 0x10) != 0x00);
++ break;
++
++ /* LNA gain setting (0-15) */
++ case MT2266_LNA_GAIN:
++ PREFETCH(MT2266_IGAIN, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++ *pValue = ((pInfo->reg[MT2266_IGAIN] & 0x3C) >> 2);
++ break;
++
++ case MT2266_EOP:
++ default:
++ status |= MT_ARG_RANGE;
++ }
++ }
++ return (status);
++}
++
++
++/****************************************************************************
++** LOCAL FUNCTION - DO NOT USE OUTSIDE OF mt2266.c
++**
++** Name: UncheckedGet
++**
++** Description: Gets an MT2266 register with minimal checking
++**
++** NOTE: This is a local function that performs the same
++** steps as the MT2266_GetReg function that is available
++** in the external API. It does not do any of the standard
++** error checking that the API function provides and should
++** not be called from outside this file.
++**
++** Parameters: *pInfo - Tuner control structure
++** reg - MT2266 register/subaddress location
++** *val - MT2266 register/subaddress value
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++** MT_ARG_RANGE - Argument out of range
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** Use this function if you need to read a register from
++** the MT2266.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++static UData_t UncheckedGet(MT2266_Info_t* pInfo,
++ U8Data reg,
++ U8Data* val)
++{
++ UData_t status; /* Status to be returned */
++
++#if defined(_DEBUG)
++ status = MT_OK;
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ if (val == MT_NULL)
++ status |= MT_ARG_NULL;
++
++ if (reg >= END_REGS)
++ status |= MT_ARG_RANGE;
++
++ if (MT_IS_ERROR(status))
++ return(status);
++#endif
++
++ status = MT_ReadSub(pInfo->hUserData, pInfo->address, reg, &pInfo->reg[reg], 1);
++
++ if (MT_NO_ERROR(status))
++ *val = pInfo->reg[reg];
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetReg
++**
++** Description: Gets an MT2266 register.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** reg - MT2266 register/subaddress location
++** *val - MT2266 register/subaddress value
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++** MT_ARG_RANGE - Argument out of range
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** Use this function if you need to read a register from
++** the MT2266.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++UData_t MT2266_GetReg(Handle_t h,
++ U8Data reg,
++ U8Data* val)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ if (val == MT_NULL)
++ status |= MT_ARG_NULL;
++
++ if (reg >= END_REGS)
++ status |= MT_ARG_RANGE;
++
++ if (MT_NO_ERROR(status))
++ status |= UncheckedGet(pInfo, reg, val);
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetUHFXFreqs
++**
++** Description: Retrieves the specified set of UHF Crossover Frequencies
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++**
++** Usage: MT2266_Freq_Set tmpFreqs;
++** status = MT2266_GetUHFXFreqs(hMT2266,
++** MT2266_UHF1_WITH_ATTENUATION,
++** tmpFreqs );
++** if (status & MT_ARG_RANGE)
++** // error, Invalid UHF Crossover Frequency Set requested.
++** else
++** for( int i = 0; i < MT2266_NUM_XFREQS; i++ )
++** . . .
++**
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_ARG_RANGE - freq_type is out of range.
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: freqs_buffer *must* be defined of type MT2266_Freq_Set
++** to assure sufficient space allocation!
++**
++** USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_SetUHFXFreqs
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 10-26-2006 RSK Original.
++**
++****************************************************************************/
++UData_t MT2266_GetUHFXFreqs(Handle_t h,
++ MT2266_UHFXFreq_Type freq_type,
++ MT2266_XFreq_Set freqs_buffer)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status = MT_INV_HANDLE;
++
++ if (freq_type >= MT2266_NUMBER_OF_XFREQ_SETS)
++ status |= MT_ARG_RANGE;
++
++ if (MT_NO_ERROR(status))
++ {
++ int i;
++
++ for( i = 0; i < MT2266_NUM_XFREQS; i++ )
++ {
++ freqs_buffer[i] = pInfo->xfreqs.xfreq[ freq_type ][i] * TUNE_STEP_SIZE / 1000;
++ }
++ }
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetUserData
++**
++** Description: Gets the user-defined data item.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** The hUserData parameter is a user-specific argument
++** that is stored internally with the other tuner-
++** specific information.
++**
++** For example, if additional arguments are needed
++** for the user to identify the device communicating
++** with the tuner, this argument can be used to supply
++** the necessary information.
++**
++** The hUserData parameter is initialized in the tuner's
++** Open function to NULL.
++**
++** See Also: MT2266_SetUserData, MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++UData_t MT2266_GetUserData(Handle_t h,
++ Handle_t* hUserData)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status = MT_INV_HANDLE;
++
++ if (hUserData == MT_NULL)
++ status |= MT_ARG_NULL;
++
++ if (MT_NO_ERROR(status))
++ *hUserData = pInfo->hUserData;
++
++ return (status);
++}
++
++
++/******************************************************************************
++**
++** Name: MT2266_ReInit
++**
++** Description: Initialize the tuner's register values.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch
++** MT_TUNER_INIT_ERR - Tuner initialization failed
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_COMM_ERR - Serial bus communications error
++**
++** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus
++** MT_WriteSub - Write byte(s) of data to the two-wire bus
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 06-08-2006 JWS Ver 1.01: Corrected problem with tuner ID check
++** N/A 11-01-2006 RSK Ver 1.02: Initialize XFreq Tables to Default
++** N/A 11-29-2006 DAD Ver 1.03: Parenthesis clarification
++**
++******************************************************************************/
++UData_t MT2266_ReInit(Handle_t h)
++{
++ int j;
++
++ U8Data MT2266_Init_Defaults1[] =
++ {
++ 0x01, /* Start w/register 0x01 */
++ 0x00, /* Reg 0x01 */
++ 0x00, /* Reg 0x02 */
++ 0x28, /* Reg 0x03 */
++ 0x00, /* Reg 0x04 */
++ 0x52, /* Reg 0x05 */
++ 0x99, /* Reg 0x06 */
++ 0x3F, /* Reg 0x07 */
++ };
++
++ U8Data MT2266_Init_Defaults2[] =
++ {
++ 0x17, /* Start w/register 0x17 */
++ 0x6D, /* Reg 0x17 */
++ 0x71, /* Reg 0x18 */
++ 0x61, /* Reg 0x19 */
++ 0xC0, /* Reg 0x1A */
++ 0xBF, /* Reg 0x1B */
++ 0xFF, /* Reg 0x1C */
++ 0xDC, /* Reg 0x1D */
++ 0x00, /* Reg 0x1E */
++ 0x0A, /* Reg 0x1F */
++ 0xD4, /* Reg 0x20 */
++ 0x03, /* Reg 0x21 */
++ 0x64, /* Reg 0x22 */
++ 0x64, /* Reg 0x23 */
++ 0x64, /* Reg 0x24 */
++ 0x64, /* Reg 0x25 */
++ 0x22, /* Reg 0x26 */
++ 0xAA, /* Reg 0x27 */
++ 0xF2, /* Reg 0x28 */
++ 0x1E, /* Reg 0x29 */
++ 0x80, /* Reg 0x2A */
++ 0x14, /* Reg 0x2B */
++ 0x01, /* Reg 0x2C */
++ 0x01, /* Reg 0x2D */
++ 0x01, /* Reg 0x2E */
++ 0x01, /* Reg 0x2F */
++ 0x01, /* Reg 0x30 */
++ 0x01, /* Reg 0x31 */
++ 0x7F, /* Reg 0x32 */
++ 0x5E, /* Reg 0x33 */
++ 0x3F, /* Reg 0x34 */
++ 0xFF, /* Reg 0x35 */
++ 0xFF, /* Reg 0x36 */
++ 0xFF, /* Reg 0x37 */
++ 0x00, /* Reg 0x38 */
++ 0x77, /* Reg 0x39 */
++ 0x0F, /* Reg 0x3A */
++ 0x2D, /* Reg 0x3B */
++ };
++
++ UData_t status = MT_OK; /* Status to be returned */
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++ U8Data BBVref;
++ U8Data tmpreg = 0;
++ U8Data statusreg = 0;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ /* Read the Part/Rev code from the tuner */
++ if (MT_NO_ERROR(status))
++ status |= UncheckedGet(pInfo, MT2266_PART_REV, &tmpreg);
++ if (MT_NO_ERROR(status) && (tmpreg != 0x85)) // MT226? B0
++ status |= MT_TUNER_ID_ERR;
++ else
++ {
++ /*
++ ** Read the status register 5
++ */
++ tmpreg = pInfo->reg[MT2266_RSVD_11] |= 0x03;
++ if (MT_NO_ERROR(status))
++ status |= UncheckedSet(pInfo, MT2266_RSVD_11, tmpreg);
++ tmpreg &= ~(0x02);
++ if (MT_NO_ERROR(status))
++ status |= UncheckedSet(pInfo, MT2266_RSVD_11, tmpreg);
++
++ /* Get and store the status 5 register value */
++ if (MT_NO_ERROR(status))
++ status |= UncheckedGet(pInfo, MT2266_STATUS_5, &statusreg);
++
++ /* MT2266 */
++ if (MT_IS_ERROR(status) || ((statusreg & 0x30) != 0x30))
++ status |= MT_TUNER_ID_ERR; /* Wrong tuner Part/Rev code */
++ }
++
++ if (MT_NO_ERROR(status))
++ {
++ /* Initialize the tuner state. Hold off on f_in and f_LO */
++ pInfo->version = VERSION;
++ pInfo->tuner_id = pInfo->reg[MT2266_PART_REV];
++ pInfo->f_Ref = REF_FREQ;
++ pInfo->f_Step = TUNE_STEP_SIZE * 1000; /* kHz -> Hz */
++ pInfo->f_in = UHF_DEFAULT_FREQ;
++ pInfo->f_LO = UHF_DEFAULT_FREQ;
++ pInfo->f_bw = OUTPUT_BW;
++ pInfo->band = MT2266_UHF_BAND;
++ pInfo->num_regs = END_REGS;
++
++ /* Reset the UHF Crossover Frequency tables on open/init. */
++ for (j=0; j< MT2266_NUM_XFREQS; j++ )
++ {
++ pInfo->xfreqs.xfreq[MT2266_UHF0][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF0][j];
++ pInfo->xfreqs.xfreq[MT2266_UHF1][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF1][j];
++ pInfo->xfreqs.xfreq[MT2266_UHF0_ATTEN][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF0_ATTEN][j];
++ pInfo->xfreqs.xfreq[MT2266_UHF1_ATTEN][j] = MT2266_default_XFreqs.xfreq[MT2266_UHF1_ATTEN][j];
++ }
++
++ /* Write the default values to the tuner registers. Default mode is UHF */
++ status |= MT_WriteSub(pInfo->hUserData,
++ pInfo->address,
++ MT2266_Init_Defaults1[0],
++ &MT2266_Init_Defaults1[1],
++ sizeof(MT2266_Init_Defaults1)/sizeof(U8Data)-1);
++ status |= MT_WriteSub(pInfo->hUserData,
++ pInfo->address,
++ MT2266_Init_Defaults2[0],
++ &MT2266_Init_Defaults2[1],
++ sizeof(MT2266_Init_Defaults2)/sizeof(U8Data)-1);
++ }
++
++ /* Read back all the registers from the tuner */
++ if (MT_NO_ERROR(status))
++ {
++ status |= MT_ReadSub(pInfo->hUserData, pInfo->address, 0, &pInfo->reg[0], END_REGS);
++ }
++
++ /*
++ ** Set reg[0x33] based on statusreg
++ */
++ if (MT_NO_ERROR(status))
++ {
++ BBVref = (((statusreg >> 6) + 2) & 0x03);
++ tmpreg = (pInfo->reg[MT2266_RSVD_33] & ~(0x60)) | (BBVref << 5);
++ status |= UncheckedSet(pInfo, MT2266_RSVD_33, tmpreg);
++ }
++
++ /* Run the baseband filter calibration */
++ if (MT_NO_ERROR(status))
++ status |= Run_BB_RC_Cal2(h);
++
++ /* Set the baseband filter bandwidth to the default */
++ if (MT_NO_ERROR(status))
++ status |= Set_BBFilt(h);
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetParam
++**
++** Description: Sets a tuning algorithm parameter.
++**
++** This function provides access to the internals of the
++** tuning algorithm. You can override many of the tuning
++** algorithm defaults using this function.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** param - Tuning algorithm parameter
++** (see enum MT2266_Param)
++** nValue - value to be set
++**
++** param Description
++** ---------------------- --------------------------------
++** MT2266_SRO_FREQ crystal frequency
++** MT2266_STEPSIZE minimum tuning step size
++** MT2266_INPUT_FREQ Center of input channel
++** MT2266_OUTPUT_BW Output channel bandwidth
++** MT2266_RF_ATTN RF attenuation (0-255)
++** MT2266_RF_EXT External control of RF atten
++** MT2266_LNA_GAIN LNA gain setting (0-15)
++** MT2266_LNA_GAIN_DECR Decrement LNA Gain (arg=min)
++** MT2266_LNA_GAIN_INCR Increment LNA Gain (arg=max)
++** MT2266_BB_ATTN Baseband attenuation (0-255)
++** MT2266_BB_EXT External control of BB atten
++** MT2266_UHF_MAXSENS Set for UHF max sensitivity mode
++** MT2266_UHF_NORMAL Set for UHF normal mode
++**
++** Usage: status |= MT2266_SetParam(hMT2266,
++** MT2266_STEPSIZE,
++** 50000);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_RANGE - Invalid parameter requested
++** or set value out of range
++** or non-writable parameter
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_GetParam, MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 11-29-2006 DAD Ver 1.03: Parenthesis clarification for gcc
++**
++****************************************************************************/
++UData_t MT2266_SetParam(Handle_t h,
++ MT2266_Param param,
++ UData_t nValue)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ U8Data tmpreg;
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ if (MT_NO_ERROR(status))
++ {
++ switch (param)
++ {
++ /* crystal frequency */
++ case MT2266_SRO_FREQ:
++ pInfo->f_Ref = nValue;
++ if (pInfo->f_Ref < 22000000)
++ {
++ /* Turn off f_SRO divide by 2 */
++ status |= UncheckedSet(pInfo,
++ MT2266_SRO_CTRL,
++ (U8Data) (pInfo->reg[MT2266_SRO_CTRL] &= 0xFE));
++ }
++ else
++ {
++ /* Turn on f_SRO divide by 2 */
++ status |= UncheckedSet(pInfo,
++ MT2266_SRO_CTRL,
++ (U8Data) (pInfo->reg[MT2266_SRO_CTRL] |= 0x01));
++ }
++ status |= Run_BB_RC_Cal2(h);
++ if (MT_NO_ERROR(status))
++ status |= Set_BBFilt(h);
++ break;
++
++ /* minimum tuning step size */
++ case MT2266_STEPSIZE:
++ pInfo->f_Step = nValue;
++ break;
++
++ /* Width of output channel */
++ case MT2266_OUTPUT_BW:
++ pInfo->f_bw = nValue;
++ status |= Set_BBFilt(h);
++ break;
++
++ /* BB attenuation (0-255) */
++ case MT2266_BB_ATTN:
++ if (nValue > 255)
++ status |= MT_ARG_RANGE;
++ else
++ {
++ UData_t BBA_Stage1;
++ UData_t BBA_Stage2;
++ UData_t BBA_Stage3;
++
++ BBA_Stage3 = (nValue > 102) ? 103 : nValue + 1;
++ BBA_Stage2 = (nValue > 175) ? 75 : nValue + 2 - BBA_Stage3;
++ BBA_Stage1 = (nValue > 176) ? nValue - 175 : 1;
++ pInfo->reg[MT2266_RSVD_2C] = (U8Data) BBA_Stage1;
++ pInfo->reg[MT2266_RSVD_2D] = (U8Data) BBA_Stage2;
++ pInfo->reg[MT2266_RSVD_2E] = (U8Data) BBA_Stage3;
++ pInfo->reg[MT2266_RSVD_2F] = (U8Data) BBA_Stage1;
++ pInfo->reg[MT2266_RSVD_30] = (U8Data) BBA_Stage2;
++ pInfo->reg[MT2266_RSVD_31] = (U8Data) BBA_Stage3;
++ status |= MT_WriteSub(pInfo->hUserData,
++ pInfo->address,
++ MT2266_RSVD_2C,
++ &pInfo->reg[MT2266_RSVD_2C],
++ 6);
++ }
++ break;
++
++ /* RF attenuation (0-255) */
++ case MT2266_RF_ATTN:
++ if (nValue > 255)
++ status |= MT_ARG_RANGE;
++ else
++ status |= UncheckedSet(pInfo, MT2266_RSVD_1F, (U8Data) nValue);
++ break;
++
++ /* RF external / internal atten control */
++ case MT2266_RF_EXT:
++ if (nValue == 0)
++ tmpreg = pInfo->reg[MT2266_GPO] &= ~0x40;
++ else
++ tmpreg = pInfo->reg[MT2266_GPO] |= 0x40;
++ status |= UncheckedSet(pInfo, MT2266_GPO, tmpreg);
++ break;
++
++ /* LNA gain setting (0-15) */
++ case MT2266_LNA_GAIN:
++ if (nValue > 15)
++ status |= MT_ARG_RANGE;
++ else
++ {
++ tmpreg = (pInfo->reg[MT2266_IGAIN] & 0xC3) | ((U8Data)nValue << 2);
++ status |= UncheckedSet(pInfo, MT2266_IGAIN, tmpreg);
++ }
++ break;
++
++ /* Decrement LNA Gain setting, argument is min LNA Gain setting */
++ case MT2266_LNA_GAIN_DECR:
++ if (nValue > 15)
++ status |= MT_ARG_RANGE;
++ else
++ {
++ PREFETCH(MT2266_IGAIN, 1);
++ if (MT_NO_ERROR(status) && ((U8Data) ((pInfo->reg[MT2266_IGAIN] & 0x3C) >> 2) > (U8Data) nValue))
++ status |= UncheckedSet(pInfo, MT2266_IGAIN, pInfo->reg[MT2266_IGAIN] - 0x04);
++ }
++ break;
++
++ /* Increment LNA Gain setting, argument is max LNA Gain setting */
++ case MT2266_LNA_GAIN_INCR:
++ if (nValue > 15)
++ status |= MT_ARG_RANGE;
++ else
++ {
++ PREFETCH(MT2266_IGAIN, 1);
++ if (MT_NO_ERROR(status) && ((U8Data) ((pInfo->reg[MT2266_IGAIN] & 0x3C) >> 2) < (U8Data) nValue))
++ status |= UncheckedSet(pInfo, MT2266_IGAIN, pInfo->reg[MT2266_IGAIN] + 0x04);
++ }
++ break;
++
++ /* BB external / internal atten control */
++ case MT2266_BB_EXT:
++ if (nValue == 0)
++ tmpreg = pInfo->reg[MT2266_RSVD_33] &= ~0x08;
++ else
++ tmpreg = pInfo->reg[MT2266_RSVD_33] |= 0x08;
++ status |= UncheckedSet(pInfo, MT2266_RSVD_33, tmpreg);
++ break;
++
++ /* Set for UHF max sensitivity mode */
++ case MT2266_UHF_MAXSENS:
++ PREFETCH(MT2266_BAND_CTRL, 1);
++ if (MT_NO_ERROR(status) && ((pInfo->reg[MT2266_BAND_CTRL] & 0x30) == 0x10))
++ status |= UncheckedSet(pInfo, MT2266_BAND_CTRL, pInfo->reg[MT2266_BAND_CTRL] ^ 0x30);
++ break;
++
++ /* Set for UHF normal mode */
++ case MT2266_UHF_NORMAL:
++ if (MT_NO_ERROR(status) && ((pInfo->reg[MT2266_BAND_CTRL] & 0x30) == 0x20))
++ status |= UncheckedSet(pInfo, MT2266_BAND_CTRL, pInfo->reg[MT2266_BAND_CTRL] ^ 0x30);
++ break;
++
++ /* These parameters are read-only */
++ case MT2266_IC_ADDR:
++ case MT2266_MAX_OPEN:
++ case MT2266_NUM_OPEN:
++ case MT2266_NUM_REGS:
++ case MT2266_INPUT_FREQ:
++ case MT2266_LO_FREQ:
++ case MT2266_RC2_VALUE:
++ case MT2266_RF_ADC:
++ case MT2266_BB_ADC:
++ case MT2266_EOP:
++ default:
++ status |= MT_ARG_RANGE;
++ }
++ }
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetPowerModes
++**
++** Description: Sets the bits in the MT2266_ENABLES register and the
++** SROsd bit in the MT2266_SROADC_CTRL register.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** flags - Bit mask of flags to indicate enabled
++** bits.
++**
++** Usage: status = MT2266_SetPowerModes(hMT2266, flags);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** The bits in the MT2266_ENABLES register and the
++** SROsd bit are set according to the supplied flags.
++**
++** The pre-defined flags are as follows:
++** MT2266_SROen
++** MT2266_LOen
++** MT2266_ADCen
++** MT2266_PDen
++** MT2266_DCOCen
++** MT2266_BBen
++** MT2266_MIXen
++** MT2266_LNAen
++** MT2266_ALL_ENABLES
++** MT2266_NO_ENABLES
++** MT2266_SROsd
++** MT2266_SRO_NOT_sd
++**
++** ONLY the enable bits (or SROsd bit) specified in the
++** flags parameter will be set. Any flag which is not
++** included, will cause that bit to be disabled.
++**
++** The ALL_ENABLES, NO_ENABLES, and SRO_NOT_sd constants
++** are for convenience. The NO_ENABLES and SRO_NOT_sd
++** do not actually have to be included, but are provided
++** for clarity.
++**
++** See Also: MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++UData_t MT2266_SetPowerModes(Handle_t h,
++ UData_t flags)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++ U8Data tmpreg;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ PREFETCH(MT2266_SRO_CTRL, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++ if (MT_NO_ERROR(status))
++ {
++ if (flags & MT2266_SROsd)
++ tmpreg = pInfo->reg[MT2266_SRO_CTRL] |= 0x10; /* set the SROsd bit */
++ else
++ tmpreg = pInfo->reg[MT2266_SRO_CTRL] &= 0xEF; /* clear the SROsd bit */
++ status |= UncheckedSet(pInfo, MT2266_SRO_CTRL, tmpreg);
++ }
++
++ PREFETCH(MT2266_ENABLES, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++
++ if (MT_NO_ERROR(status))
++ {
++ status |= UncheckedSet(pInfo, MT2266_ENABLES, (U8Data)(flags & 0xff));
++ }
++
++ return status;
++}
++
++
++/****************************************************************************
++** LOCAL FUNCTION - DO NOT USE OUTSIDE OF mt2266.c
++**
++** Name: UncheckedSet
++**
++** Description: Sets an MT2266 register.
++**
++** NOTE: This is a local function that performs the same
++** steps as the MT2266_SetReg function that is available
++** in the external API. It does not do any of the standard
++** error checking that the API function provides and should
++** not be called from outside this file.
++**
++** Parameters: *pInfo - Tuner control structure
++** reg - MT2266 register/subaddress location
++** val - MT2266 register/subaddress value
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_RANGE - Argument out of range
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** Sets a register value without any preliminary checking for
++** valid handles or register numbers.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++static UData_t UncheckedSet(MT2266_Info_t* pInfo,
++ U8Data reg,
++ U8Data val)
++{
++ UData_t status; /* Status to be returned */
++
++#if defined(_DEBUG)
++ status = MT_OK;
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ if (reg >= END_REGS)
++ status |= MT_ARG_RANGE;
++
++ if (MT_IS_ERROR(status))
++ return (status);
++#endif
++
++ status = MT_WriteSub(pInfo->hUserData, pInfo->address, reg, &val, 1);
++
++ if (MT_NO_ERROR(status))
++ pInfo->reg[reg] = val;
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetReg
++**
++** Description: Sets an MT2266 register.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** reg - MT2266 register/subaddress location
++** val - MT2266 register/subaddress value
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_RANGE - Argument out of range
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** Use this function if you need to override a default
++** register value
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++UData_t MT2266_SetReg(Handle_t h,
++ U8Data reg,
++ U8Data val)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status |= MT_INV_HANDLE;
++
++ if (reg >= END_REGS)
++ status |= MT_ARG_RANGE;
++
++ if (MT_NO_ERROR(status))
++ status |= UncheckedSet(pInfo, reg, val);
++
++ return (status);
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetUHFXFreqs
++**
++** Description: Assigns the specified set of UHF Crossover Frequencies
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++**
++** Usage: MT2266_Freq_Set tmpFreqs;
++** status = MT2266_GetUHFXFreqs(hMT2266,
++** MT2266_UHF1_WITH_ATTENUATION,
++** tmpFreqs );
++** ...
++** tmpFreqs[i] = <desired value>
++** ...
++** status = MT2266_SetUHFXFreqs(hMT2266,
++** MT2266_UHF1_WITH_ATTENUATION,
++** tmpFreqs );
++**
++** if (status & MT_ARG_RANGE)
++** // error, Invalid UHF Crossover Frequency Set requested.
++** else
++** for( int i = 0; i < MT2266_NUM_XFREQS; i++ )
++** . . .
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_ARG_RANGE - freq_type is out of range.
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: freqs_buffer *must* be defined of type MT2266_Freq_Set
++** to assure sufficient space allocation!
++**
++** USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_SetUHFXFreqs
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 10-26-2006 RSK Original.
++**
++****************************************************************************/
++UData_t MT2266_SetUHFXFreqs(Handle_t h,
++ MT2266_UHFXFreq_Type freq_type,
++ MT2266_XFreq_Set freqs_buffer)
++{
++ UData_t status = MT_OK; /* Status to be returned */
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ status = MT_INV_HANDLE;
++
++ if (freq_type >= MT2266_NUMBER_OF_XFREQ_SETS)
++ status |= MT_ARG_RANGE;
++
++ if (MT_NO_ERROR(status))
++ {
++ int i;
++
++ for( i = 0; i < MT2266_NUM_XFREQS; i++ )
++ {
++ pInfo->xfreqs.xfreq[ freq_type ][i] = freqs_buffer[i] * 1000 / TUNE_STEP_SIZE;
++ }
++ }
++
++ return (status);
++}
++
++
++/****************************************************************************
++** LOCAL FUNCTION
++**
++** Name: RoundToStep
++**
++** Description: Rounds the given frequency to the closes f_Step value
++** given the tuner ref frequency..
++**
++**
++** Parameters: freq - Frequency to be rounded (in Hz).
++** f_Step - Step size for the frequency (in Hz).
++** f_Ref - SRO frequency (in Hz).
++**
++** Returns: Rounded frequency.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++**
++****************************************************************************/
++static UData_t RoundToStep(UData_t freq, UData_t f_Step, UData_t f_ref)
++{
++ return f_ref * (freq / f_ref)
++ + f_Step * (((freq % f_ref) + (f_Step / 2)) / f_Step);
++}
++
++
++/****************************************************************************
++**
++** Name: fLO_FractionalTerm
++**
++** Description: Calculates the portion contributed by FracN / denom.
++**
++** This function preserves maximum precision without
++** risk of overflow. It accurately calculates
++** f_ref * num / denom to within 1 HZ with fixed math.
++**
++** Parameters: num - Fractional portion of the multiplier
++** denom - denominator portion of the ratio
++** This routine successfully handles denom values
++** up to and including 2^18.
++** f_Ref - SRO frequency. This calculation handles
++** f_ref as two separate 14-bit fields.
++** Therefore, a maximum value of 2^28-1
++** may safely be used for f_ref. This is
++** the genesis of the magic number "14" and the
++** magic mask value of 0x03FFF.
++**
++** Returns: f_ref * num / denom
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 12-20-2006 RSK Ver 1.04: Adding fLO_FractionalTerm() usage.
++**
++****************************************************************************/
++static UData_t fLO_FractionalTerm( UData_t f_ref,
++ UData_t num,
++ UData_t denom )
++{
++ UData_t t1 = (f_ref >> 14) * num;
++ UData_t term1 = t1 / denom;
++ UData_t loss = t1 % denom;
++ UData_t term2 = ( ((f_ref & 0x00003FFF) * num + (loss<<14)) + (denom/2) ) / denom;
++ return ((term1 << 14) + term2);
++}
++
++
++/****************************************************************************
++** LOCAL FUNCTION
++**
++** Name: CalcLOMult
++**
++** Description: Calculates Integer divider value and the numerator
++** value for LO's FracN PLL.
++**
++** This function assumes that the f_LO and f_Ref are
++** evenly divisible by f_LO_Step.
++**
++** Parameters: Div - OUTPUT: Whole number portion of the multiplier
++** FracN - OUTPUT: Fractional portion of the multiplier
++** f_LO - desired LO frequency.
++** denom - LO FracN denominator value
++** f_Ref - SRO frequency.
++**
++** Returns: Recalculated LO frequency.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 12-20-2006 RSK Ver 1.04: Adding fLO_FractionalTerm() usage.
++**
++****************************************************************************/
++static UData_t CalcLOMult(UData_t *Div,
++ UData_t *FracN,
++ UData_t f_LO,
++ UData_t denom,
++ UData_t f_Ref)
++{
++ UData_t a, b, i;
++ const SData_t TwoNShift = 13; // bits to shift to obtain 2^n qty
++ const SData_t RoundShift = 18; // bits to shift before rounding
++
++ /* Calculate the whole number portion of the divider */
++ *Div = f_LO / f_Ref;
++
++ /*
++ ** Calculate the FracN numerator 1 bit at a time. This keeps the
++ ** integer values from overflowing when large values are multiplied.
++ ** This loop calculates the fractional portion of F/20MHz accurate
++ ** to 32 bits. The 2^n factor is represented by the placement of
++ ** the value in the 32-bit word. Since we want as much accuracy
++ ** as possible, we'll leave it at the top of the word.
++ */
++ *FracN = 0;
++ a = f_LO;
++ for (i=32; i>0; --i)
++ {
++ b = 2*(a % f_Ref);
++ *FracN = (*FracN * 2) + (b >= f_Ref);
++ a = b;
++ }
++
++ /*
++ ** If the denominator is a 2^n - 1 value (the usual case) then the
++ ** value we really need is (F/20) * 2^n - (F/20). Shifting the
++ ** calculated (F/20) value to the right and subtracting produces
++ ** the desired result -- still accurate to 32 bits.
++ */
++ if ((denom & 0x01) != 0)
++ *FracN -= (*FracN >> TwoNShift);
++
++ /*
++ ** Now shift the result so that it is 1 bit bigger than we need,
++ ** use the low-order bit to round the remaining bits, and shift
++ ** to make the answer the desired size.
++ */
++ *FracN >>= RoundShift;
++ *FracN = (*FracN & 0x01) + (*FracN >> 1);
++
++ /* Check for rollover (cannot happen with 50 kHz step size) */
++ if (*FracN == (denom | 1))
++ {
++ *FracN = 0;
++ ++Div;
++ }
++
++
++ return (f_Ref * (*Div)) + fLO_FractionalTerm( f_Ref, *FracN, denom );
++}
++
++
++/****************************************************************************
++** LOCAL FUNCTION
++**
++** Name: GetCrossover
++**
++** Description: Determines the appropriate value in the set of
++** crossover frequencies.
++**
++** This function assumes that the crossover frequency table
++** ias been properly initialized in descending order.
++**
++** Parameters: f_in - The input frequency to use.
++** freqs - The array of crossover frequency entries.
++**
++** Returns: Index of crossover frequency band to use.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 10-27-2006 RSK Original
++**
++****************************************************************************/
++static U8Data GetCrossover( UData_t f_in, UData_t* freqs )
++{
++ U8Data idx;
++ U8Data retVal = 0;
++
++ for (idx=0; idx< (U8Data)MT2266_NUM_XFREQS; idx++)
++ {
++ if ( freqs[idx] >= f_in)
++ {
++ retVal = (U8Data)MT2266_NUM_XFREQS - idx;
++ break;
++ }
++ }
++
++ return retVal;
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_ChangeFreq
++**
++** Description: Change the tuner's tuned frequency to f_in.
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++** f_in - RF input center frequency (in Hz).
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_DNC_UNLOCK - Downconverter PLL unlocked
++** MT_COMM_ERR - Serial bus communications error
++** MT_FIN_RANGE - Input freq out of range
++** MT_DNC_RANGE - Downconverter freq out of range
++**
++** Dependencies: MUST CALL MT2266_Open BEFORE MT2266_ChangeFreq!
++**
++** MT_ReadSub - Read byte(s) of data from the two-wire-bus
++** MT_WriteSub - Write byte(s) of data to the two-wire-bus
++** MT_Sleep - Delay execution for x milliseconds
++** MT2266_GetLocked - Checks to see if the PLL is locked
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 11-01-2006 RSK Ver 1.02: Added usage of UFILT0 and UFILT1.
++** N/A 11-29-2006 DAD Ver 1.03: Parenthesis clarification
++** 118 05-09-2007 RSK Ver 1.05: Refactored to call _Tune() API.
++**
++****************************************************************************/
++UData_t MT2266_ChangeFreq(Handle_t h,
++ UData_t f_in) /* RF input center frequency */
++{
++ return (MT2266_Tune(h, f_in));
++}
++
++
++/****************************************************************************
++**
++** Name: MT2266_Tune
++**
++** Description: Change the tuner's tuned frequency to f_in.
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++** f_in - RF input center frequency (in Hz).
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_DNC_UNLOCK - Downconverter PLL unlocked
++** MT_COMM_ERR - Serial bus communications error
++** MT_FIN_RANGE - Input freq out of range
++** MT_DNC_RANGE - Downconverter freq out of range
++**
++** Dependencies: MUST CALL MT2266_Open BEFORE MT2266_Tune!
++**
++** MT_ReadSub - Read byte(s) of data from the two-wire-bus
++** MT_WriteSub - Write byte(s) of data to the two-wire-bus
++** MT_Sleep - Delay execution for x milliseconds
++** MT2266_GetLocked - Checks to see if the PLL is locked
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 11-01-2006 RSK Ver 1.02: Added usage of UFILT0 and UFILT1.
++** N/A 11-29-2006 DAD Ver 1.03: Parenthesis clarification
++** 118 05-09-2007 RSK Ver 1.05: Adding Standard MTxxxx_Tune() API.
++**
++****************************************************************************/
++UData_t MT2266_Tune(Handle_t h,
++ UData_t f_in) /* RF input center frequency */
++{
++ MT2266_Info_t* pInfo = (MT2266_Info_t*) h;
++
++ UData_t status = MT_OK; /* status of operation */
++ UData_t LO; /* LO register value */
++ UData_t Num; /* Numerator for LO reg. value */
++ UData_t ofLO; /* last time's LO frequency */
++ UData_t ofin; /* last time's input frequency */
++ U8Data LO_Band; /* LO Mode bits */
++ UData_t s_fRef; /* Ref Freq scaled for LO Band */
++ UData_t this_band; /* Band for the requested freq */
++ UData_t SROx2; /* SRO times 2 */
++
++ /* Verify that the handle passed points to a valid tuner */
++ if (IsValidHandle(pInfo) == 0)
++ return MT_INV_HANDLE;
++
++ /*
++ ** Save original input and LO value
++ */
++ ofLO = pInfo->f_LO;
++ ofin = pInfo->f_in;
++
++ /*
++ ** Assign in the requested input value
++ */
++ pInfo->f_in = f_in;
++
++ /*
++ ** Get the SRO multiplier value
++ */
++ SROx2 = (2 - (pInfo->reg[MT2266_SRO_CTRL] & 0x01));
++
++ /* Check f_Step value */
++ if(pInfo->f_Step == 0)
++ return MT_UNKNOWN;
++
++ /* Request an LO that is on a step size boundary */
++ pInfo->f_LO = RoundToStep(f_in, pInfo->f_Step, pInfo->f_Ref);
++
++ if (pInfo->f_LO < MIN_VHF_FREQ)
++ {
++ status |= MT_FIN_RANGE | MT_ARG_RANGE | MT_DNC_RANGE;
++ return status; /* Does not support frequencies below MIN_VHF_FREQ */
++ }
++ else if (pInfo->f_LO <= MAX_VHF_FREQ)
++ {
++ /* VHF Band */
++ s_fRef = pInfo->f_Ref * SROx2 / 4;
++ LO_Band = 0;
++ this_band = MT2266_VHF_BAND;
++ }
++ else if (pInfo->f_LO < MIN_UHF_FREQ)
++ {
++ status |= MT_FIN_RANGE | MT_ARG_RANGE | MT_DNC_RANGE;
++ return status; /* Does not support frequencies between MAX_VHF_FREQ & MIN_UHF_FREQ */
++ }
++ else if (pInfo->f_LO <= MAX_UHF_FREQ)
++ {
++ /* UHF Band */
++ s_fRef = pInfo->f_Ref * SROx2 / 2;
++ LO_Band = 1;
++ this_band = MT2266_UHF_BAND;
++ }
++ else
++ {
++ status |= MT_FIN_RANGE | MT_ARG_RANGE | MT_DNC_RANGE;
++ return status; /* Does not support frequencies above MAX_UHF_FREQ */
++ }
++
++ /*
++ ** Calculate the LO frequencies and the values to be placed
++ ** in the tuning registers.
++ */
++ pInfo->f_LO = CalcLOMult(&LO, &Num, pInfo->f_LO, 8191, s_fRef);
++
++ /*
++ ** If we have the same LO frequencies and we're already locked,
++ ** then just return without writing any registers.
++ */
++ if ((ofLO == pInfo->f_LO)
++ && ((pInfo->reg[MT2266_STATUS_1] & 0x40) == 0x40))
++ {
++ return (status);
++ }
++
++ /*
++ ** Reset defaults here if we're tuning into a new band
++ */
++ if (MT_NO_ERROR(status))
++ {
++ if (this_band != pInfo->band)
++ {
++ MT2266_DefaultsEntry *defaults = MT_NULL;
++ switch (this_band)
++ {
++ case MT2266_VHF_BAND:
++ defaults = &MT2266_VHF_defaults[0];
++ break;
++ case MT2266_UHF_BAND:
++ defaults = &MT2266_UHF_defaults[0];
++ break;
++ default:
++ status |= MT_ARG_RANGE;
++ }
++ if ( MT_NO_ERROR(status))
++ {
++ while (defaults->data && MT_NO_ERROR(status))
++ {
++ status |= MT_WriteSub(pInfo->hUserData, pInfo->address, defaults->data[0], &defaults->data[1], defaults->cnt);
++ defaults++;
++ }
++ /* re-read the new registers into the cached values */
++ status |= MT_ReadSub(pInfo->hUserData, pInfo->address, 0, &pInfo->reg[0], END_REGS);
++ pInfo->band = this_band;
++ }
++ }
++ }
++
++ /*
++ ** Place all of the calculated values into the local tuner
++ ** register fields.
++ */
++ if (MT_NO_ERROR(status))
++ {
++ pInfo->reg[MT2266_LO_CTRL_1] = (U8Data)(Num >> 8);
++ pInfo->reg[MT2266_LO_CTRL_2] = (U8Data)(Num & 0xFF);
++ pInfo->reg[MT2266_LO_CTRL_3] = (U8Data)(LO & 0xFF);
++
++ /*
++ ** Now write out the computed register values
++ */
++ status |= MT_WriteSub(pInfo->hUserData, pInfo->address, MT2266_LO_CTRL_1, &pInfo->reg[MT2266_LO_CTRL_1], 3);
++
++ if (pInfo->band == MT2266_UHF_BAND)
++ {
++ U8Data UFilt0 = 0; /* def when f_in > all */
++ U8Data UFilt1 = 0; /* def when f_in > all */
++ UData_t* XFreq0;
++ UData_t* XFreq1;
++ SData_t ClearTune_Fuse;
++ SData_t f_offset;
++ UData_t f_in_;
++
++ PREFETCH(MT2266_BAND_CTRL, 2); /* Fetch register(s) if __NO_CACHE__ defined */
++ PREFETCH(MT2266_STATUS_5, 1); /* Fetch register(s) if __NO_CACHE__ defined */
++
++ XFreq0 = (pInfo->reg[MT2266_BAND_CTRL] & 0x10) ? pInfo->xfreqs.xfreq[ MT2266_UHF0_ATTEN ] : pInfo->xfreqs.xfreq[ MT2266_UHF0 ];
++ XFreq1 = (pInfo->reg[MT2266_BAND_CTRL] & 0x10) ? pInfo->xfreqs.xfreq[ MT2266_UHF1_ATTEN ] : pInfo->xfreqs.xfreq[ MT2266_UHF1 ];
++
++ ClearTune_Fuse = pInfo->reg[MT2266_STATUS_5] & 0x07;
++ f_offset = (10000000) * ((ClearTune_Fuse > 3) ? (ClearTune_Fuse - 8) : ClearTune_Fuse);
++ f_in_ = (f_in - f_offset) / 1000 / TUNE_STEP_SIZE;
++
++ UFilt0 = GetCrossover( f_in_, XFreq0 );
++ UFilt1 = GetCrossover( f_in_, XFreq1 );
++
++ /* If UFilt == 16, set UBANDen and set UFilt = 15 */
++ if ( (UFilt0 == 16) || (UFilt1 == 16) )
++ {
++ pInfo->reg[MT2266_BAND_CTRL] |= 0x01;
++ if( UFilt0 > 0 ) UFilt0--;
++ if( UFilt1 > 0 ) UFilt1--;
++ }
++ else
++ pInfo->reg[MT2266_BAND_CTRL] &= ~(0x01);
++
++ pInfo->reg[MT2266_BAND_CTRL] =
++ (pInfo->reg[MT2266_BAND_CTRL] & 0x3F) | (LO_Band << 6);
++
++ pInfo->reg[MT2266_CLEARTUNE] = (UFilt1 << 4) | UFilt0;
++ /* Write UBANDsel [05] & ClearTune [06] */
++ status |= MT_WriteSub(pInfo->hUserData, pInfo->address, MT2266_BAND_CTRL, &pInfo->reg[MT2266_BAND_CTRL], 2);
++ }
++ }
++
++ /*
++ ** Check for LO lock
++ */
++ if (MT_NO_ERROR(status))
++ {
++ status |= MT2266_GetLocked(h);
++ }
++
++ return (status);
++}
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_mt2266.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_mt2266.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,1618 @@
++#ifndef __TUNER_MT2266_H
++#define __TUNER_MT2266_H
++
++/**
++
++@file
++
++@brief MT2266 tuner module declaration
++
++One can manipulate MT2266 tuner through MT2266 module.
++MT2266 module is derived from tunerd module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the tuner example in tuner_base.h except the listed lines.
++
++
++
++#include "tuner_mt2266.h"
++
++
++...
++
++
++
++int main(void)
++{
++ TUNER_MODULE *pTuner;
++ MT2266_EXTRA_MODULE *pTunerExtra;
++
++ TUNER_MODULE TunerModuleMemory;
++ MT2266_EXTRA_MODULE Mt2266ExtraModuleMemory;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory;
++
++ unsigned long BandwidthHz;
++
++
++ ...
++
++
++
++ // Build MT2266 tuner module.
++ BuildMt2266Module(
++ &pTuner,
++ &TunerModuleMemory,
++ &Mt2266ExtraModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ 0xc0 // I2C device address is 0xc0 in 8-bit format.
++ );
++
++
++
++
++
++ // Get MT2266 tuner extra module.
++ pTunerExtra = (T2266_EXTRA_MODULE *)(pTuner->pExtra);
++
++ // Open MT2266 handle.
++ pTunerExtra->OpenHandle(pTuner);
++
++
++
++
++
++ // ==== Initialize tuner and set its parameters =====
++
++ ...
++
++ // Set MT2266 bandwidth.
++ pTunerExtra->SetBandwidthHz(pTuner, MT2266_BANDWIDTH_6MHZ);
++
++
++
++
++
++ // ==== Get tuner information =====
++
++ ...
++
++ // Get MT2266 bandwidth.
++ pTunerExtra->GetBandwidthHz(pTuner, &BandwidthHz);
++
++
++
++
++
++ // Close MT2266 handle.
++ pTunerExtra->CloseHandle(pTuner);
++
++
++
++ // See the example for other tuner functions in tuner_base.h
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++
++
++
++// The following context is source code provided by Microtune.
++
++
++
++
++
++// Microtune source code - mt_errordef.h
++
++
++
++/*****************************************************************************
++**
++** Name: mt_errordef.h
++**
++** Description: Definition of bits in status/error word used by various
++** MicroTuner control programs.
++**
++** References: None
++**
++** Exports: None
++**
++** CVS ID: $Id: mt_errordef.h,v 1.1 2006/06/22 20:18:12 software Exp $
++** CVS Source: $Source: /export/home/cvsroot/software/tuners/MT2266/mt_errordef.h,v $
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 09-09-2004 JWS Original
++** 088 01-26-2005 DAD Added MT_TUNER_INIT_ERR.
++** N/A 12-09-2005 DAD Added MT_TUNER_TIMEOUT (info).
++**
++*****************************************************************************/
++
++/*
++** Note to users: DO NOT EDIT THIS FILE
++**
++** If you wish to rename any of the "user defined" bits,
++** it should be done in the user file that includes this
++** source file (e.g. mt_userdef.h)
++**
++*/
++
++
++
++/*
++** 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
++** 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
++** M U <- Info Codes --> <# Spurs> < User> <----- Err Codes ----->
++**
++** 31 = MT_ERROR - Master Error Flag. If set, check Err Codes for reason.
++** 30 = MT_USER_ERROR - User-declared error flag.
++** 29 = Unused
++** 28 = Unused
++** 27 = MT_DNC_RANGE
++** 26 = MT_UPC_RANGE
++** 25 = MT_FOUT_RANGE
++** 24 = MT_FIN_OUT_OF_RANGE
++** 23 = MT_SPUR_PRESENT - Unavoidable spur in output
++** 22 = MT_TUNER_TIMEOUT
++** 21 = Unused
++** 20 = Unused
++** 19 = MT_SPUR_CNT_MASK (MSB) - Count of avoided spurs
++** 18 = MT_SPUR_CNT_MASK
++** 17 = MT_SPUR_CNT_MASK
++** 16 = MT_SPUR_CNT_MASK
++** 15 = MT_SPUR_CNT_MASK (LSB)
++** 14 = MT_USER_DEFINED4 - User-definable bit (see MT_Userdef.h)
++** 13 = MT_USER_DEFINED3 - User-definable bit (see MT_Userdef.h)
++** 12 = MT_USER_DEFINED2 - User-definable bit (see MT_Userdef.h)
++** 11 = MT_USER_DEFINED1 - User-definable bit (see MT_Userdef.h)
++** 10 = Unused
++** 9 = MT_TUNER_INIT_ERR - Tuner initialization error
++** 8 = MT_TUNER_ID_ERR - Tuner Part Code / Rev Code mismatches expected value
++** 7 = MT_TUNER_CNT_ERR - Attempt to open more than MT_TUNER_CNT tuners
++** 6 = MT_ARG_NULL - Null pointer passed as argument
++** 5 = MT_ARG_RANGE - Argument value out of range
++** 4 = MT_INV_HANDLE - Tuner handle is invalid
++** 3 = MT_COMM_ERR - Serial bus communications error
++** 2 = MT_DNC_UNLOCK - Downconverter PLL is unlocked
++** 1 = MT_UPC_UNLOCK - Upconverter PLL is unlocked
++** 0 = MT_UNKNOWN - Unknown error
++*/
++#define MT_ERROR (1 << 31)
++#define MT_USER_ERROR (1 << 30)
++
++/* Macro to be used to check for errors */
++#define MT_IS_ERROR(s) (((s) >> 30) != 0)
++#define MT_NO_ERROR(s) (((s) >> 30) == 0)
++
++
++#define MT_OK (0x00000000)
++
++/* Unknown error */
++#define MT_UNKNOWN (0x80000001)
++
++/* Error: Upconverter PLL is not locked */
++#define MT_UPC_UNLOCK (0x80000002)
++
++/* Error: Downconverter PLL is not locked */
++#define MT_DNC_UNLOCK (0x80000004)
++
++/* Error: Two-wire serial bus communications error */
++#define MT_COMM_ERR (0x80000008)
++
++/* Error: Tuner handle passed to function was invalid */
++#define MT_INV_HANDLE (0x80000010)
++
++/* Error: Function argument is invalid (out of range) */
++#define MT_ARG_RANGE (0x80000020)
++
++/* Error: Function argument (ptr to return value) was NULL */
++#define MT_ARG_NULL (0x80000040)
++
++/* Error: Attempt to open more than MT_TUNER_CNT tuners */
++#define MT_TUNER_CNT_ERR (0x80000080)
++
++/* Error: Tuner Part Code / Rev Code mismatches expected value */
++#define MT_TUNER_ID_ERR (0x80000100)
++
++/* Error: Tuner Initialization failure */
++#define MT_TUNER_INIT_ERR (0x80000200)
++
++/* User-definable fields (see mt_userdef.h) */
++#define MT_USER_DEFINED1 (0x00001000)
++#define MT_USER_DEFINED2 (0x00002000)
++#define MT_USER_DEFINED3 (0x00004000)
++#define MT_USER_DEFINED4 (0x00008000)
++#define MT_USER_MASK (0x4000f000)
++#define MT_USER_SHIFT (12)
++
++/* Info: Mask of bits used for # of LO-related spurs that were avoided during tuning */
++#define MT_SPUR_CNT_MASK (0x001f0000)
++#define MT_SPUR_SHIFT (16)
++
++/* Info: Tuner timeout waiting for condition */
++#define MT_TUNER_TIMEOUT (0x00400000)
++
++/* Info: Unavoidable LO-related spur may be present in the output */
++#define MT_SPUR_PRESENT (0x00800000)
++
++/* Info: Tuner input frequency is out of range */
++#define MT_FIN_RANGE (0x01000000)
++
++/* Info: Tuner output frequency is out of range */
++#define MT_FOUT_RANGE (0x02000000)
++
++/* Info: Upconverter frequency is out of range (may be reason for MT_UPC_UNLOCK) */
++#define MT_UPC_RANGE (0x04000000)
++
++/* Info: Downconverter frequency is out of range (may be reason for MT_DPC_UNLOCK) */
++#define MT_DNC_RANGE (0x08000000)
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// Microtune source code - mt_userdef.h
++
++
++
++/*****************************************************************************
++**
++** Name: mt_userdef.h
++**
++** Description: User-defined data types needed by MicroTuner source code.
++**
++** Customers must provide the code for these functions
++** in the file "mt_userdef.c".
++**
++** Customers must verify that the typedef's in the
++** "Data Types" section are correct for their platform.
++**
++** Functions
++** Requiring
++** Implementation: MT_WriteSub
++** MT_ReadSub
++** MT_Sleep
++**
++** References: None
++**
++** Exports: None
++**
++** CVS ID: $Id: mt_userdef.h,v 1.1 2006/06/22 20:18:12 software Exp $
++** CVS Source: $Source: /export/home/cvsroot/software/tuners/MT2266/mt_userdef.h,v $
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++** 082 12-06-2004 JWS Multi-tuner support - requires MTxxxx_CNT
++** declarations
++**
++*****************************************************************************/
++#if !defined( __MT_USERDEF_H )
++#define __MT_USERDEF_H
++
++//#include "mt_errordef.h"
++
++#if defined( __cplusplus )
++extern "C" /* Use "C" external linkage */
++{
++#endif
++
++/*
++** Data Types
++*/
++typedef unsigned char U8Data; /* type corresponds to 8 bits */
++typedef unsigned int UData_t; /* type must be at least 32 bits */
++typedef int SData_t; /* type must be at least 32 bits */
++typedef void * Handle_t; /* memory pointer type */
++typedef double FData_t; /* floating point data type */
++
++#define MAX_UDATA 0xffffffff /* max value storable in UData_t */
++
++/*
++** Define an MTxxxx_CNT macro for each type of tuner that will be built
++** into your application (e.g., MT2121, MT2060). MT_TUNER_CNT
++** must be set to the SUM of all of the MTxxxx_CNT macros.
++**
++** #define MT2050_CNT (1)
++** #define MT2060_CNT (1)
++** #define MT2111_CNT (1)
++** #define MT2121_CNT (3)
++*/
++
++
++#if !defined( MT_TUNER_CNT )
++#define MT_TUNER_CNT (0) /* total num of MicroTuner tuners */
++#endif
++
++/*
++** Optional user-defined Error/Info Codes (examples below)
++**
++** This is the area where you can define user-specific error/info return
++** codes to be returned by any of the functions you are responsible for
++** writing such as MT_WriteSub() and MT_ReadSub. There are four bits
++** available in the status field for your use. When set, these
++** bits will be returned in the status word returned by any tuner driver
++** call. If you OR in the MT_ERROR bit as well, the tuner driver code
++** will treat the code as an error.
++**
++** The following are a few examples of errors you can provide.
++**
++** Example 1:
++** You might check to see the hUserData handle is correct and issue
++** MY_USERDATA_INVALID which would be defined like this:
++**
++** #define MY_USERDATA_INVALID (MT_USER_ERROR | MT_USER_DEFINED1)
++**
++**
++** Example 2:
++** You might be able to provide more descriptive two-wire bus errors:
++**
++** #define NO_ACK (MT_USER_ERROR | MT_USER_DEFINED1)
++** #define NO_NACK (MT_USER_ERROR | MT_USER_DEFINED2)
++** #define BUS_BUSY (MT_USER_ERROR | MT_USER_DEFINED3)
++**
++**
++** Example 3:
++** You can also provide information (non-error) feedback:
++**
++** #define MY_INFO_1 (MT_USER_DEFINED1)
++**
++**
++** Example 4:
++** You can combine the fields together to make a multi-bit field.
++** This one can provide the tuner number based off of the addr
++** passed to MT_WriteSub or MT_ReadSub. It assumes that
++** MT_USER_DEFINED4 through MT_USER_DEFINED1 are contiguously. If
++** TUNER_NUM were OR'ed into the status word on an error, you could
++** use this to identify which tuner had the problem (and whether it
++** was during a read or write operation).
++**
++** #define TUNER_NUM ((addr & 0x07) >> 1) << MT_USER_SHIFT
++**
++*/
++
++/*****************************************************************************
++**
++** Name: MT_WriteSub
++**
++** Description: Write values to device using a two-wire serial bus.
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** addr - device serial bus address (value passed
++** as parameter to MTxxxx_Open)
++** subAddress - serial bus sub-address (Register Address)
++** pData - pointer to the Data to be written to the
++** device
++** cnt - number of bytes/registers to be written
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** user-defined
++**
++** Notes: This is a callback function that is called from the
++** the tuning algorithm. You MUST provide code for this
++** function to write data using the tuner's 2-wire serial
++** bus.
++**
++** The hUserData parameter is a user-specific argument.
++** If additional arguments are needed for the user's
++** serial bus read/write functions, this argument can be
++** used to supply the necessary information.
++** The hUserData parameter is initialized in the tuner's Open
++** function.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++**
++*****************************************************************************/
++UData_t MT_WriteSub(Handle_t hUserData,
++ UData_t addr,
++ U8Data subAddress,
++ U8Data *pData,
++ UData_t cnt);
++
++
++/*****************************************************************************
++**
++** Name: MT_ReadSub
++**
++** Description: Read values from device using a two-wire serial bus.
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** addr - device serial bus address (value passed
++** as parameter to MTxxxx_Open)
++** subAddress - serial bus sub-address (Register Address)
++** pData - pointer to the Data to be written to the
++** device
++** cnt - number of bytes/registers to be written
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** user-defined
++**
++** Notes: This is a callback function that is called from the
++** the tuning algorithm. You MUST provide code for this
++** function to read data using the tuner's 2-wire serial
++** bus.
++**
++** The hUserData parameter is a user-specific argument.
++** If additional arguments are needed for the user's
++** serial bus read/write functions, this argument can be
++** used to supply the necessary information.
++** The hUserData parameter is initialized in the tuner's Open
++** function.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++**
++*****************************************************************************/
++UData_t MT_ReadSub(Handle_t hUserData,
++ UData_t addr,
++ U8Data subAddress,
++ U8Data *pData,
++ UData_t cnt);
++
++
++/*****************************************************************************
++**
++** Name: MT_Sleep
++**
++** Description: Delay execution for "nMinDelayTime" milliseconds
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** nMinDelayTime - Delay time in milliseconds
++**
++** Returns: None.
++**
++** Notes: This is a callback function that is called from the
++** the tuning algorithm. You MUST provide code that
++** blocks execution for the specified period of time.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 03-25-2004 DAD Original
++**
++*****************************************************************************/
++void MT_Sleep(Handle_t hUserData,
++ UData_t nMinDelayTime);
++
++
++#if defined(MT2060_CNT)
++#if MT2060_CNT > 0
++/*****************************************************************************
++**
++** Name: MT_TunerGain (for MT2060 only)
++**
++** Description: Measure the relative tuner gain using the demodulator
++**
++** Parameters: hUserData - User-specific I/O parameter that was
++** passed to tuner's Open function.
++** pMeas - Tuner gain (1/100 of dB scale).
++** ie. 1234 = 12.34 (dB)
++**
++** Returns: status:
++** MT_OK - No errors
++** user-defined errors could be set
++**
++** Notes: This is a callback function that is called from the
++** the 1st IF location routine. You MUST provide
++** code that measures the relative tuner gain in a dB
++** (not linear) scale. The return value is an integer
++** value scaled to 1/100 of a dB.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 06-16-2004 DAD Original
++** N/A 11-30-2004 DAD Renamed from MT_DemodInputPower. This name
++** better describes what this function does.
++**
++*****************************************************************************/
++UData_t MT_TunerGain(Handle_t hUserData,
++ SData_t* pMeas);
++#endif
++#endif
++
++#if defined( __cplusplus )
++}
++#endif
++
++#endif
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// Microtune source code - mt2266.h
++
++
++
++/*****************************************************************************
++**
++** Name: mt2266.h
++**
++** Copyright 2007 Microtune, Inc. All Rights Reserved
++**
++** This source code file contains confidential information and/or trade
++** secrets of Microtune, Inc. or its affiliates and is subject to the
++** terms of your confidentiality agreement with Microtune, Inc. or one of
++** its affiliates, as applicable.
++**
++*****************************************************************************/
++
++/*****************************************************************************
++**
++** Name: mt2266.h
++**
++** Description: Microtune MT2266 Tuner software interface.
++** Supports tuners with Part/Rev code: 0x85.
++**
++** Functions
++** Implemented: UData_t MT2266_Open
++** UData_t MT2266_Close
++** UData_t MT2266_ChangeFreq
++** UData_t MT2266_GetLocked
++** UData_t MT2266_GetParam
++** UData_t MT2266_GetReg
++** UData_t MT2266_GetUHFXFreqs
++** UData_t MT2266_GetUserData
++** UData_t MT2266_ReInit
++** UData_t MT2266_SetParam
++** UData_t MT2266_SetPowerModes
++** UData_t MT2266_SetReg
++** UData_t MT2266_SetUHFXFreqs
++** UData_t MT2266_Tune
++**
++** References: AN-00010: MicroTuner Serial Interface Application Note
++** MicroTune, Inc.
++**
++** Exports: None
++**
++** Dependencies: MT_ReadSub(hUserData, IC_Addr, subAddress, *pData, cnt);
++** - Read byte(s) of data from the two-wire bus.
++**
++** MT_WriteSub(hUserData, IC_Addr, subAddress, *pData, cnt);
++** - Write byte(s) of data to the two-wire bus.
++**
++** MT_Sleep(hUserData, nMinDelayTime);
++** - Delay execution for x milliseconds
++**
++** CVS ID: $Id: mt2266.h,v 1.3 2007/10/02 18:43:17 software Exp $
++** CVS Source: $Source: /export/home/cvsroot/software/tuners/MT2266/mt2266.h,v $
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 05-30-2006 DAD Ver 1.0: Modified version of mt2260.c (Ver 1.01).
++** N/A 11-01-2006 RSK Ver 1.02: Adding Get/Set UHFXFreq access functions.
++** 118 05-09-2007 RSK Ver 1.05: Adding Standard MTxxxx_Tune() API.
++**
++*****************************************************************************/
++#if !defined( __MT2266_H )
++#define __MT2266_H
++
++//#include "mt_userdef.h"
++
++#if defined( __cplusplus )
++extern "C" /* Use "C" external linkage */
++{
++#endif
++
++/*
++** Parameter for function MT2266_GetParam & MT2266_SetParam that
++** specifies the tuning algorithm parameter to be read/written.
++*/
++typedef enum
++{
++ /* tuner address set by MT2266_Open() */
++ MT2266_IC_ADDR,
++
++ /* max number of MT2266 tuners set by MT2266_CNT in mt_userdef.h */
++ MT2266_MAX_OPEN,
++
++ /* current number of open MT2266 tuners set by MT2266_Open() */
++ MT2266_NUM_OPEN,
++
++ /* Number of tuner registers */
++ MT2266_NUM_REGS,
++
++ /* crystal frequency (default: 18000000 Hz) */
++ MT2266_SRO_FREQ,
++
++ /* min tuning step size (default: 50000 Hz) */
++ MT2266_STEPSIZE,
++
++ /* input center frequency set by MT2266_ChangeFreq() */
++ MT2266_INPUT_FREQ,
++
++ /* LO Frequency set by MT2266_ChangeFreq() */
++ MT2266_LO_FREQ,
++
++ /* output channel bandwidth (default: 8000000 Hz) */
++ MT2266_OUTPUT_BW,
++
++ /* Base band filter calibration RC code (default: N/A) */
++ MT2266_RC2_VALUE,
++
++ /* Base band filter nominal cal RC code (default: N/A) */
++ MT2266_RC2_NOMINAL,
++
++ /* RF attenuator A/D readback (read-only) */
++ MT2266_RF_ADC,
++
++ /* BB attenuator A/D readback (read-only) */
++ MT2266_BB_ADC,
++
++ /* RF attenuator setting (default: varies) */
++ MT2266_RF_ATTN,
++
++ /* BB attenuator setting (default: varies) */
++ MT2266_BB_ATTN,
++
++ /* RF external / internal atten control (default: varies) */
++ MT2266_RF_EXT,
++
++ /* BB external / internal atten control (default: 1) */
++ MT2266_BB_EXT,
++
++ /* LNA gain setting (0-15) (default: varies) */
++ MT2266_LNA_GAIN,
++
++ /* Decrement LNA Gain (where arg=min LNA Gain value) */
++ MT2266_LNA_GAIN_DECR,
++
++ /* Increment LNA Gain (where arg=max LNA Gain value) */
++ MT2266_LNA_GAIN_INCR,
++
++ /* Set for UHF max sensitivity mode */
++ MT2266_UHF_MAXSENS,
++
++ /* Set for UHF normal mode */
++ MT2266_UHF_NORMAL,
++
++ MT2266_EOP /* last entry in enumerated list */
++} MT2266_Param;
++
++
++/*
++** Parameter for function MT2266_GetUHFXFreqs & MT2266_SetUHFXFreqs that
++** specifies the particular frequency crossover table to be read/written.
++*/
++typedef enum
++{
++ /* Reference the UHF 0 filter, without any attenuation */
++ MT2266_UHF0,
++
++ /* Reference the UHF 1 filter, without any attenuation */
++ MT2266_UHF1,
++
++ /* Reference the UHF 0 filter, with attenuation */
++ MT2266_UHF0_ATTEN,
++
++ /* Reference the UHF 1 filter, with attenuation */
++ MT2266_UHF1_ATTEN,
++
++ MT2266_NUMBER_OF_XFREQ_SETS /* last entry in enumerated list */
++
++} MT2266_UHFXFreq_Type;
++
++
++#define MT2266_NUM_XFREQS (16)
++
++typedef UData_t MT2266_XFreq_Set[ MT2266_NUM_XFREQS ];
++
++/*
++** Constants for Specifying Operating Band of the Tuner
++*/
++#define MT2266_VHF_BAND (0)
++#define MT2266_UHF_BAND (1)
++#define MT2266_L_BAND (2)
++
++/*
++** Constants for specifying power modes these values
++** are bit-mapped and can be added/OR'ed to indicate
++** multiple settings. Examples:
++** MT2266_SetPowerModes(h, MT2266_NO_ENABLES + MT22266_SROsd);
++** MT2266_SetPowerModes(h, MT2266_ALL_ENABLES | MT22266_SRO_NOT_sd);
++** MT2266_SetPowerModes(h, MT2266_NO_ENABLES + MT22266_SROsd);
++** MT2266_SetPowerModes(h, MT2266_SROen + MT22266_LOen + MT2266_ADCen);
++*/
++#define MT2266_SROen (0x01)
++#define MT2266_LOen (0x02)
++#define MT2266_ADCen (0x04)
++#define MT2266_PDen (0x08)
++#define MT2266_DCOCen (0x10)
++#define MT2266_BBen (0x20)
++#define MT2266_MIXen (0x40)
++#define MT2266_LNAen (0x80)
++#define MT2266_ALL_ENABLES (0xFF)
++#define MT2266_NO_ENABLES (0x00)
++#define MT2266_SROsd (0x100)
++#define MT2266_SRO_NOT_sd (0x000)
++
++/* ====== Functions which are declared in mt2266.c File ======= */
++
++/******************************************************************************
++**
++** Name: MT2266_Open
++**
++** Description: Initialize the tuner's register values.
++**
++** Usage: status = MT2266_Open(0xC0, &hMT2266, NULL);
++** if (MT_IS_ERROR(status))
++** // Check error codes for reason
++**
++** Parameters: MT2266_Addr - Serial bus address of the tuner.
++** hMT2266 - Tuner handle passed back.
++** hUserData - User-defined data, if needed for the
++** MT_ReadSub() & MT_WriteSub functions.
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch
++** MT_TUNER_INIT_ERR - Tuner initialization failed
++** MT_COMM_ERR - Serial bus communications error
++** MT_ARG_NULL - Null pointer argument passed
++** MT_TUNER_CNT_ERR - Too many tuners open
++**
++** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus
++** MT_WriteSub - Write byte(s) of data to the two-wire bus
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++******************************************************************************/
++UData_t MT2266_Open(UData_t MT2266_Addr,
++ Handle_t* hMT2266,
++ Handle_t hUserData);
++
++
++/******************************************************************************
++**
++** Name: MT2266_Close
++**
++** Description: Release the handle to the tuner.
++**
++** Parameters: hMT2266 - Handle to the MT2266 tuner
++**
++** Usage: status = MT2266_Close(hMT2266);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: mt_errordef.h - definition of error codes
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++******************************************************************************/
++UData_t MT2266_Close(Handle_t hMT2266);
++
++
++/****************************************************************************
++**
++** Name: MT2266_ChangeFreq
++**
++** Description: Change the tuner's tuned frequency to f_in.
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++** f_in - RF input center frequency (in Hz).
++**
++** Usage: status = MT2266_ChangeFreq(hMT2266, f_in);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_DNC_UNLOCK - Downconverter PLL unlocked
++** MT_COMM_ERR - Serial bus communications error
++** MT_FIN_RANGE - Input freq out of range
++** MT_DNC_RANGE - Downconverter freq out of range
++**
++** Dependencies: MUST CALL MT2266_Open BEFORE MT2266_ChangeFreq!
++**
++** MT_ReadSub - Read byte(s) of data from the two-wire-bus
++** MT_WriteSub - Write byte(s) of data to the two-wire-bus
++** MT_Sleep - Delay execution for x milliseconds
++** MT2266_GetLocked - Checks to see if the PLL is locked
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++******************************************************************************/
++UData_t MT2266_ChangeFreq(Handle_t h,
++ UData_t f_in);
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetLocked
++**
++** Description: Checks to see if the PLL is locked.
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++**
++** Usage: status = MT2266_GetLocked(hMT2266);
++** if (status & MT_DNC_UNLOCK)
++** // error!, PLL is unlocked
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_DNC_UNLOCK - Downconverter PLL unlocked
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: MT_ReadSub - Read byte(s) of data from the serial bus
++** MT_Sleep - Delay execution for x milliseconds
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++****************************************************************************/
++UData_t MT2266_GetLocked(Handle_t h);
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetParam
++**
++** Description: Gets a tuning algorithm parameter.
++**
++** This function provides access to the internals of the
++** tuning algorithm - mostly for testing purposes.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** param - Tuning algorithm parameter
++** (see enum MT2266_Param)
++** pValue - ptr to returned value
++**
++** param Description
++** ---------------------- --------------------------------
++** MT2266_IC_ADDR Serial Bus address of this tuner
++** MT2266_MAX_OPEN Max number of MT2266's that can be open
++** MT2266_NUM_OPEN Number of MT2266's currently open
++** MT2266_NUM_REGS Number of tuner registers
++** MT2266_SRO_FREQ crystal frequency
++** MT2266_STEPSIZE minimum tuning step size
++** MT2266_INPUT_FREQ input center frequency
++** MT2266_LO_FREQ LO Frequency
++** MT2266_OUTPUT_BW Output channel bandwidth
++** MT2266_RC2_VALUE Base band filter cal RC code (method 2)
++** MT2266_RF_ADC RF attenuator A/D readback
++** MT2266_RF_ATTN RF attenuation (0-255)
++** MT2266_RF_EXT External control of RF atten
++** MT2266_LNA_GAIN LNA gain setting (0-15)
++** MT2266_BB_ADC BB attenuator A/D readback
++** MT2266_BB_ATTN Baseband attenuation (0-255)
++** MT2266_BB_EXT External control of BB atten
++**
++** Usage: status |= MT2266_GetParam(hMT2266,
++** MT2266_OUTPUT_BW,
++** &f_bw);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++** MT_ARG_RANGE - Invalid parameter requested
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_SetParam, MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++****************************************************************************/
++UData_t MT2266_GetParam(Handle_t h,
++ MT2266_Param param,
++ UData_t* pValue);
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetReg
++**
++** Description: Gets an MT2266 register.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** reg - MT2266 register/subaddress location
++** *val - MT2266 register/subaddress value
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++** MT_ARG_RANGE - Argument out of range
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** Use this function if you need to read a register from
++** the MT2266.
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++****************************************************************************/
++UData_t MT2266_GetReg(Handle_t h,
++ U8Data reg,
++ U8Data* val);
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetUHFXFreqs
++**
++** Description: Retrieves the specified set of UHF Crossover Frequencies
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++**
++** Usage: MT2266_Freq_Set tmpFreqs;
++** status = MT2266_GetUHFXFreqs(hMT2266,
++** MT2266_UHF1_WITH_ATTENUATION,
++** tmpFreqs );
++** if (status & MT_ARG_RANGE)
++** // error, Invalid UHF Crossover Frequency Set requested.
++** else
++** for( int i = 0; i < MT2266_NUM_XFREQS; i++ )
++** . . .
++**
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_ARG_RANGE - freq_type is out of range.
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: freqs_buffer *must* be defined of type MT2266_Freq_Set
++** to assure sufficient space allocation!
++**
++** USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_SetUHFXFreqs
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 11-01-2006 RSK Original.
++**
++****************************************************************************/
++UData_t MT2266_GetUHFXFreqs(Handle_t h,
++ MT2266_UHFXFreq_Type freq_type,
++ MT2266_XFreq_Set freqs_buffer);
++
++
++/****************************************************************************
++**
++** Name: MT2266_GetUserData
++**
++** Description: Gets the user-defined data item.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++**
++** Usage: status = MT2266_GetUserData(hMT2266, &hUserData);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** The hUserData parameter is a user-specific argument
++** that is stored internally with the other tuner-
++** specific information.
++**
++** For example, if additional arguments are needed
++** for the user to identify the device communicating
++** with the tuner, this argument can be used to supply
++** the necessary information.
++**
++** The hUserData parameter is initialized in the tuner's
++** Open function to NULL.
++**
++** See Also: MT2266_SetUserData, MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++****************************************************************************/
++UData_t MT2266_GetUserData(Handle_t h,
++ Handle_t* hUserData);
++
++
++/******************************************************************************
++**
++** Name: MT2266_ReInit
++**
++** Description: Initialize the tuner's register values.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch
++** MT_TUNER_INIT_ERR - Tuner initialization failed
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_COMM_ERR - Serial bus communications error
++**
++** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus
++** MT_WriteSub - Write byte(s) of data to the two-wire bus
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++******************************************************************************/
++UData_t MT2266_ReInit(Handle_t h);
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetParam
++**
++** Description: Sets a tuning algorithm parameter.
++**
++** This function provides access to the internals of the
++** tuning algorithm. You can override many of the tuning
++** algorithm defaults using this function.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** param - Tuning algorithm parameter
++** (see enum MT2266_Param)
++** nValue - value to be set
++**
++** param Description
++** ---------------------- --------------------------------
++** MT2266_SRO_FREQ crystal frequency
++** MT2266_STEPSIZE minimum tuning step size
++** MT2266_INPUT_FREQ Center of input channel
++** MT2266_OUTPUT_BW Output channel bandwidth
++** MT2266_RF_ATTN RF attenuation (0-255)
++** MT2266_RF_EXT External control of RF atten
++** MT2266_LNA_GAIN LNA gain setting (0-15)
++** MT2266_LNA_GAIN_DECR Decrement LNA Gain (arg=min)
++** MT2266_LNA_GAIN_INCR Increment LNA Gain (arg=max)
++** MT2266_BB_ATTN Baseband attenuation (0-255)
++** MT2266_BB_EXT External control of BB atten
++** MT2266_UHF_MAXSENS Set for UHF max sensitivity mode
++** MT2266_UHF_NORMAL Set for UHF normal mode
++**
++** Usage: status |= MT2266_SetParam(hMT2266,
++** MT2266_STEPSIZE,
++** 50000);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_NULL - Null pointer argument passed
++** MT_ARG_RANGE - Invalid parameter requested
++** or set value out of range
++** or non-writable parameter
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_GetParam, MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++****************************************************************************/
++UData_t MT2266_SetParam(Handle_t h,
++ MT2266_Param param,
++ UData_t nValue);
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetPowerModes
++**
++** Description: Sets the bits in the MT2266_ENABLES register and the
++** SROsd bit in the MT2266_SROADC_CTRL register.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** flags - Bit mask of flags to indicate enabled
++** bits.
++**
++** Usage: status = MT2266_SetPowerModes(hMT2266, flags);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** The bits in the MT2266_ENABLES register and the
++** SROsd bit are set according to the supplied flags.
++**
++** The pre-defined flags are as follows:
++** MT2266_SROen
++** MT2266_LOen
++** MT2266_ADCen
++** MT2266_PDen
++** MT2266_DCOCen
++** MT2266_BBen
++** MT2266_MIXen
++** MT2266_LNAen
++** MT2266_ALL_ENABLES
++** MT2266_NO_ENABLES
++** MT2266_SROsd
++** MT2266_SRO_NOT_sd
++**
++** ONLY the enable bits (or SROsd bit) specified in the
++** flags parameter will be set. Any flag which is not
++** included, will cause that bit to be disabled.
++**
++** The ALL_ENABLES, NO_ENABLES, and SRO_NOT_sd constants
++** are for convenience. The NO_ENABLES and SRO_NOT_sd
++** do not actually have to be included, but are provided
++** for clarity.
++**
++** See Also: MT2266_Open
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++****************************************************************************/
++UData_t MT2266_SetPowerModes(Handle_t h,
++ UData_t flags);
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetReg
++**
++** Description: Sets an MT2266 register.
++**
++** Parameters: h - Tuner handle (returned by MT2266_Open)
++** reg - MT2266 register/subaddress location
++** val - MT2266 register/subaddress value
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_COMM_ERR - Serial bus communications error
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_ARG_RANGE - Argument out of range
++**
++** Dependencies: USERS MUST CALL MT2266_Open() FIRST!
++**
++** Use this function if you need to override a default
++** register value
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 02-03-2006 DAD/JWS Original.
++**
++****************************************************************************/
++UData_t MT2266_SetReg(Handle_t h,
++ U8Data reg,
++ U8Data val);
++
++
++/****************************************************************************
++**
++** Name: MT2266_SetUHFXFreqs
++**
++** Description: Retrieves the specified set of UHF Crossover Frequencies
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++**
++** Usage: MT2266_Freq_Set tmpFreqs;
++** status = MT2266_SetUHFXFreqs(hMT2266,
++** MT2266_UHF1_WITH_ATTENUATION,
++** tmpFreqs );
++** if (status & MT_ARG_RANGE)
++** // error, Invalid UHF Crossover Frequency Set requested.
++** else
++** for( int i = 0; i < MT2266_NUM_XFREQS; i++ )
++** . . .
++**
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_ARG_RANGE - freq_type is out of range.
++** MT_INV_HANDLE - Invalid tuner handle
++**
++** Dependencies: freqs_buffer *must* be defined of type MT2266_Freq_Set
++** to assure sufficient space allocation!
++**
++** USERS MUST CALL MT2266_Open() FIRST!
++**
++** See Also: MT2266_SetUHFXFreqs
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 11_01-2006 RSK Original.
++**
++****************************************************************************/
++UData_t MT2266_SetUHFXFreqs(Handle_t h,
++ MT2266_UHFXFreq_Type freq_type,
++ MT2266_XFreq_Set freqs_buffer);
++
++
++/****************************************************************************
++**
++** Name: MT2266_Tune
++**
++** Description: Change the tuner's tuned frequency to f_in.
++**
++** Parameters: h - Open handle to the tuner (from MT2266_Open).
++** f_in - RF input center frequency (in Hz).
++**
++** Usage: status = MT2266_Tune(hMT2266, f_in);
++**
++** Returns: status:
++** MT_OK - No errors
++** MT_INV_HANDLE - Invalid tuner handle
++** MT_DNC_UNLOCK - Downconverter PLL unlocked
++** MT_COMM_ERR - Serial bus communications error
++** MT_FIN_RANGE - Input freq out of range
++** MT_DNC_RANGE - Downconverter freq out of range
++**
++** Dependencies: MUST CALL MT2266_Open BEFORE MT2266_Tune!
++**
++** MT_ReadSub - Read byte(s) of data from the two-wire-bus
++** MT_WriteSub - Write byte(s) of data to the two-wire-bus
++** MT_Sleep - Delay execution for x milliseconds
++** MT2266_GetLocked - Checks to see if the PLL is locked
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** 118 05-09-2007 RSK Original API Introduction (was ChangeFreq).
++**
++******************************************************************************/
++UData_t MT2266_Tune(Handle_t h,
++ UData_t f_in);
++
++
++#if defined( __cplusplus )
++}
++#endif
++
++#endif
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is MT2266 tuner API source code
++
++
++
++
++
++/**
++
++@file
++
++@brief MT2266 tuner module declaration
++
++One can manipulate MT2266 tuner through MT2266 module.
++MT2266 module is derived from tuner module.
++
++*/
++
++
++#include "tuner_base.h"
++
++
++
++
++
++// Definitions
++
++// MT2266 API option
++#define __NO_CACHE__
++#define MT2266_CNT 4
++
++
++// Bandwidth modes
++enum MT2266_BANDWIDTH_HZ
++{
++ MT2266_BANDWIDTH_5MHZ = 5000000,
++ MT2266_BANDWIDTH_6MHZ = 6000000,
++ MT2266_BANDWIDTH_7MHZ = 7000000,
++ MT2266_BANDWIDTH_8MHZ = 8000000,
++};
++
++
++
++
++
++/// MT2266 extra module alias
++typedef struct MT2266_EXTRA_MODULE_TAG MT2266_EXTRA_MODULE;
++
++
++
++
++
++// MT2266 handle openning function pointer
++typedef int
++(*MT2266_FP_OPEN_HANDLE)(
++ TUNER_MODULE *pTuner
++ );
++
++
++
++// MT2266 handle closing function pointer
++typedef int
++(*MT2266_FP_CLOSE_HANDLE)(
++ TUNER_MODULE *pTuner
++ );
++
++
++
++// MT2266 handle getting function pointer
++typedef void
++(*MT2266_FP_GET_HANDLE)(
++ TUNER_MODULE *pTuner,
++ void **pDeviceHandle
++ );
++
++
++
++// MT2266 bandwidth setting function pointer
++typedef int
++(*MT2266_FP_SET_BANDWIDTH_HZ)(
++ TUNER_MODULE *pTuner,
++ unsigned long BandwidthHz
++ );
++
++
++
++// MT2266 bandwidth getting function pointer
++typedef int
++(*MT2266_FP_GET_BANDWIDTH_HZ)(
++ TUNER_MODULE *pTuner,
++ unsigned long *pBandwidthHz
++ );
++
++
++
++
++
++// MT2266 extra module
++struct MT2266_EXTRA_MODULE_TAG
++{
++ // MT2266 extra variables
++ void *DeviceHandle;
++ unsigned long BandwidthHz;
++ int IsBandwidthHzSet;
++
++ // MT2266 extra function pointers
++ MT2266_FP_OPEN_HANDLE OpenHandle;
++ MT2266_FP_CLOSE_HANDLE CloseHandle;
++ MT2266_FP_GET_HANDLE GetHandle;
++ MT2266_FP_SET_BANDWIDTH_HZ SetBandwidthHz;
++ MT2266_FP_GET_BANDWIDTH_HZ GetBandwidthHz;
++};
++
++
++
++
++
++// Builder
++void
++BuildMt2266Module(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ MT2266_EXTRA_MODULE *pMt2266ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr
++ );
++
++
++
++
++
++// Manipulaing functions
++void
++mt2266_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ );
++
++void
++mt2266_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ );
++
++int
++mt2266_Initialize(
++ TUNER_MODULE *pTuner
++ );
++
++int
++mt2266_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ );
++
++int
++mt2266_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ );
++
++
++
++
++
++// Extra manipulaing functions
++int
++mt2266_OpenHandle(
++ TUNER_MODULE *pTuner
++ );
++
++int
++mt2266_CloseHandle(
++ TUNER_MODULE *pTuner
++ );
++
++void
++mt2266_GetHandle(
++ TUNER_MODULE *pTuner,
++ void **pDeviceHandle
++ );
++
++int
++mt2266_SetBandwidthHz(
++ TUNER_MODULE *pTuner,
++ unsigned long BandwidthHz
++ );
++
++int
++mt2266_GetBandwidthHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pBandwidthHz
++ );
++
++
++
++
++
++// I2C birdge module demod argument setting
++void
++mt2266_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ );
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_mxl5007t.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_mxl5007t.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,1289 @@
++/**
++
++@file
++
++@brief MxL5007T tuner module definition
++
++One can manipulate MxL5007T tuner through MxL5007T module.
++MxL5007T module is derived from tuner module.
++
++*/
++
++
++#include "tuner_mxl5007t.h"
++
++
++
++
++
++/**
++
++@brief MxL5007T tuner module builder
++
++Use BuildMxl5007tModule() to build MxL5007T module, set all module function pointers with the corresponding functions,
++and initialize module private variables.
++
++
++@param [in] ppTuner Pointer to MxL5007T tuner module pointer
++@param [in] pTunerModuleMemory Pointer to an allocated tuner module memory
++@param [in] pMxl5007tExtraModuleMemory Pointer to an allocated MxL5007T extra module memory
++@param [in] pBaseInterfaceModuleMemory Pointer to an allocated base interface module memory
++@param [in] pI2cBridgeModuleMemory Pointer to an allocated I2C bridge module memory
++@param [in] DeviceAddr MxL5007T I2C device address
++@param [in] CrystalFreqHz MxL5007T crystal frequency in Hz
++@param [in] AgcMode MxL5007T AGC mode
++
++
++@note
++ -# One should call BuildMxl5007tModule() to build MxL5007T module before using it.
++
++*/
++void
++BuildMxl5007tModule(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ MXL5007T_EXTRA_MODULE *pMxl5007tExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr,
++ unsigned long CrystalFreqHz,
++ int StandardMode,
++ unsigned long IfFreqHz,
++ int SpectrumMode,
++ int ClkOutMode,
++ int ClkOutAmpMode,
++ long QamIfDiffOutLevel
++ )
++{
++ TUNER_MODULE *pTuner;
++ MXL5007T_EXTRA_MODULE *pExtra;
++ MxL5007_TunerConfigS *pTunerConfigS;
++
++
++
++ // Set tuner module pointer.
++ *ppTuner = pTunerModuleMemory;
++
++ // Get tuner module.
++ pTuner = *ppTuner;
++
++ // Set tuner extra module pointer, base interface module pointer, and I2C bridge module pointer.
++ pTuner->pExtra = pMxl5007tExtraModuleMemory;
++ pTuner->pBaseInterface = pBaseInterfaceModuleMemory;
++ pTuner->pI2cBridge = pI2cBridgeModuleMemory;
++
++ // Get tuner extra module.
++ pExtra = (MXL5007T_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Set and get MaxLinear-defined MxL5007T structure pointer.
++ pExtra->pTunerConfigS = &(pExtra->TunerConfigSMemory);
++ pTunerConfigS = pExtra->pTunerConfigS;
++
++ // Set additional definition tuner module pointer.
++ pTunerConfigS->pTuner = pTuner;
++
++
++
++ // Set tuner type.
++ pTuner->TunerType = TUNER_TYPE_MXL5007T;
++
++ // Set tuner I2C device address.
++ pTuner->DeviceAddr = DeviceAddr;
++
++
++ // Initialize tuner parameter setting status.
++ pTuner->IsRfFreqHzSet = NO;
++
++
++ // Set I2C bridge tuner arguments.
++ mxl5007t_SetI2cBridgeModuleTunerArg(pTuner);
++
++
++ // Set tuner module manipulating function pointers.
++ pTuner->GetTunerType = mxl5007t_GetTunerType;
++ pTuner->GetDeviceAddr = mxl5007t_GetDeviceAddr;
++
++ pTuner->Initialize = mxl5007t_Initialize;
++ pTuner->SetRfFreqHz = mxl5007t_SetRfFreqHz;
++ pTuner->GetRfFreqHz = mxl5007t_GetRfFreqHz;
++
++
++ // Initialize tuner extra module variables.
++ pExtra->IsBandwidthModeSet = NO;
++
++
++ // Initialize MaxLinear-defined MxL5007T structure variables.
++ // Note: The API doesn't use I2C device address of MaxLinear-defined MxL5007T structure.
++ switch(StandardMode)
++ {
++ default:
++ case MXL5007T_STANDARD_DVBT: pTunerConfigS->Mode = MxL_MODE_DVBT; break;
++ case MXL5007T_STANDARD_ATSC: pTunerConfigS->Mode = MxL_MODE_ATSC; break;
++ case MXL5007T_STANDARD_QAM: pTunerConfigS->Mode = MxL_MODE_CABLE; break;
++ case MXL5007T_STANDARD_ISDBT: pTunerConfigS->Mode = MxL_MODE_ISDBT; break;
++ }
++
++ pTunerConfigS->IF_Diff_Out_Level = (SINT32)QamIfDiffOutLevel;
++
++ switch(CrystalFreqHz)
++ {
++ default:
++ case CRYSTAL_FREQ_16000000HZ: pTunerConfigS->Xtal_Freq = MxL_XTAL_16_MHZ; break;
++ case CRYSTAL_FREQ_25000000HZ: pTunerConfigS->Xtal_Freq = MxL_XTAL_25_MHZ; break;
++ case CRYSTAL_FREQ_27000000HZ: pTunerConfigS->Xtal_Freq = MxL_XTAL_27_MHZ; break;
++ case CRYSTAL_FREQ_28800000HZ: pTunerConfigS->Xtal_Freq = MxL_XTAL_28_8_MHZ; break;
++ }
++
++ switch(IfFreqHz)
++ {
++ default:
++ case IF_FREQ_4570000HZ: pTunerConfigS->IF_Freq = MxL_IF_4_57_MHZ; break;
++ case IF_FREQ_44000000HZ: pTunerConfigS->IF_Freq = MxL_IF_44_MHZ; break;
++ }
++
++ switch(SpectrumMode)
++ {
++ default:
++ case SPECTRUM_NORMAL: pTunerConfigS->IF_Spectrum = MxL_NORMAL_IF; break;
++ case SPECTRUM_INVERSE: pTunerConfigS->IF_Spectrum = MxL_INVERT_IF; break;
++ }
++
++ switch(ClkOutMode)
++ {
++ default:
++ case MXL5007T_CLK_OUT_DISABLE: pTunerConfigS->ClkOut_Setting = MxL_CLKOUT_DISABLE; break;
++ case MXL5007T_CLK_OUT_ENABLE: pTunerConfigS->ClkOut_Setting = MxL_CLKOUT_ENABLE; break;
++ }
++
++ switch(ClkOutAmpMode)
++ {
++ default:
++ case MXL5007T_CLK_OUT_AMP_0: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_0; break;
++ case MXL5007T_CLK_OUT_AMP_1: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_1; break;
++ case MXL5007T_CLK_OUT_AMP_2: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_2; break;
++ case MXL5007T_CLK_OUT_AMP_3: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_3; break;
++ case MXL5007T_CLK_OUT_AMP_4: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_4; break;
++ case MXL5007T_CLK_OUT_AMP_5: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_5; break;
++ case MXL5007T_CLK_OUT_AMP_6: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_6; break;
++ case MXL5007T_CLK_OUT_AMP_7: pTunerConfigS->ClkOut_Amp = MxL_CLKOUT_AMP_7; break;
++ }
++
++ pTunerConfigS->BW_MHz = MXL5007T_BANDWIDTH_MODE_DEFAULT;
++ pTunerConfigS->RF_Freq_Hz = MXL5007T_RF_FREQ_HZ_DEFAULT;
++
++
++ // Set tuner extra module function pointers.
++ pExtra->SetBandwidthMode = mxl5007t_SetBandwidthMode;
++ pExtra->GetBandwidthMode = mxl5007t_GetBandwidthMode;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_TUNER_TYPE
++
++*/
++void
++mxl5007t_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ )
++{
++ // Get tuner type from tuner module.
++ *pTunerType = pTuner->TunerType;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_DEVICE_ADDR
++
++*/
++void
++mxl5007t_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ )
++{
++ // Get tuner I2C device address from tuner module.
++ *pDeviceAddr = pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_INITIALIZE
++
++*/
++int
++mxl5007t_Initialize(
++ TUNER_MODULE *pTuner
++ )
++{
++ MXL5007T_EXTRA_MODULE *pExtra;
++ MxL5007_TunerConfigS *pTunerConfigS;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MXL5007T_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get MaxLinear-defined MxL5007T structure.
++ pTunerConfigS = pExtra->pTunerConfigS;
++
++
++ // Initialize tuner.
++ if(MxL_Tuner_Init(pTunerConfigS) != MxL_OK)
++ goto error_status_initialize_tuner;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_initialize_tuner:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_SET_RF_FREQ_HZ
++
++*/
++int
++mxl5007t_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ )
++{
++ MXL5007T_EXTRA_MODULE *pExtra;
++ MxL5007_TunerConfigS *pTunerConfigS;
++
++ UINT32 Mxl5007tRfFreqHz;
++ MxL5007_BW_MHz Mxl5007tBandwidthMhz;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MXL5007T_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get MaxLinear-defined MxL5007T structure.
++ pTunerConfigS = pExtra->pTunerConfigS;
++
++
++ // Get bandwidth.
++ Mxl5007tBandwidthMhz = pTunerConfigS->BW_MHz;
++
++ // Set RF frequency.
++ Mxl5007tRfFreqHz = (UINT32)RfFreqHz;
++
++ // Set MxL5007T RF frequency and bandwidth.
++ if(MxL_Tuner_RFTune(pTunerConfigS, Mxl5007tRfFreqHz, Mxl5007tBandwidthMhz) != MxL_OK)
++ goto error_status_set_tuner_rf_frequency;
++
++
++ // Set tuner RF frequency parameter.
++ pTuner->RfFreqHz = RfFreqHz;
++ pTuner->IsRfFreqHzSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_RF_FREQ_HZ
++
++*/
++int
++mxl5007t_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ )
++{
++ // Get tuner RF frequency in Hz from tuner module.
++ if(pTuner->IsRfFreqHzSet != YES)
++ goto error_status_get_tuner_rf_frequency;
++
++ *pRfFreqHz = pTuner->RfFreqHz;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set MxL5007T tuner bandwidth mode.
++
++*/
++int
++mxl5007t_SetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ )
++{
++ MXL5007T_EXTRA_MODULE *pExtra;
++ MxL5007_TunerConfigS *pTunerConfigS;
++
++ UINT32 Mxl5007tRfFreqHz;
++ MxL5007_BW_MHz Mxl5007tBandwidthMhz;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MXL5007T_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get MaxLinear-defined MxL5007T structure.
++ pTunerConfigS = pExtra->pTunerConfigS;
++
++
++ // Get RF frequency.
++ Mxl5007tRfFreqHz = pTunerConfigS->RF_Freq_Hz;
++
++ // Set bandwidth.
++ switch(BandwidthMode)
++ {
++ case MXL5007T_BANDWIDTH_6000000HZ: Mxl5007tBandwidthMhz = MxL_BW_6MHz; break;
++ case MXL5007T_BANDWIDTH_7000000HZ: Mxl5007tBandwidthMhz = MxL_BW_7MHz; break;
++ case MXL5007T_BANDWIDTH_8000000HZ: Mxl5007tBandwidthMhz = MxL_BW_8MHz; break;
++
++ default: goto error_status_get_undefined_value;
++ }
++
++ // Set MxL5007T RF frequency and bandwidth.
++ if(MxL_Tuner_RFTune(pTunerConfigS, Mxl5007tRfFreqHz, Mxl5007tBandwidthMhz) != MxL_OK)
++ goto error_status_set_tuner_bandwidth;
++
++
++ // Set tuner bandwidth parameter.
++ pExtra->BandwidthMode = BandwidthMode;
++ pExtra->IsBandwidthModeSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_bandwidth:
++error_status_get_undefined_value:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Get MxL5007T tuner bandwidth mode.
++
++*/
++int
++mxl5007t_GetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ )
++{
++ MXL5007T_EXTRA_MODULE *pExtra;
++
++
++
++ // Get tuner extra module.
++ pExtra = (MXL5007T_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Get tuner bandwidth mode from tuner module.
++ if(pExtra->IsBandwidthModeSet != YES)
++ goto error_status_get_tuner_bandwidth_mode;
++
++ *pBandwidthMode = pExtra->BandwidthMode;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_bandwidth_mode:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set I2C bridge module tuner arguments.
++
++MXL5007T builder will use mxl5007t_SetI2cBridgeModuleTunerArg() to set I2C bridge module tuner arguments.
++
++
++@param [in] pTuner The tuner module pointer
++
++
++@see BuildMxl5007tModule()
++
++*/
++void
++mxl5007t_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ )
++{
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++
++
++ // Get I2C bridge module.
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Set I2C bridge module tuner arguments.
++ pI2cBridge->pTunerDeviceAddr = &pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is source code provided by MaxLinear.
++
++
++
++
++
++// MaxLinear source code - MxL_User_Define.c
++
++
++/*
++
++ Driver APIs for MxL5007 Tuner
++
++ Copyright, Maxlinear, Inc.
++ All Rights Reserved
++
++ File Name: MxL_User_Define.c
++
++ */
++
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++// //
++// I2C Functions (implement by customer) //
++// //
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++
++/******************************************************************************
++**
++** Name: MxL_I2C_Write
++**
++** Description: I2C write operations
++**
++** Parameters:
++** DeviceAddr - MxL5007 Device address
++** pArray - Write data array pointer
++** count - total number of array
++**
++** Returns: 0 if success
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 12-16-2007 khuang initial release.
++**
++******************************************************************************/
++//UINT32 MxL_I2C_Write(UINT8 DeviceAddr, UINT8* pArray, UINT32 count)
++UINT32 MxL_I2C_Write(MxL5007_TunerConfigS* myTuner, UINT8* pArray, UINT32 count)
++{
++ TUNER_MODULE *pTuner;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ I2C_BRIDGE_MODULE *pI2cBridge;
++ unsigned char WritingByteNumMax;
++
++ unsigned long i;
++ unsigned char Buffer[I2C_BUFFER_LEN];
++ int WritingIndex;
++
++ unsigned char *pData;
++ unsigned long DataLen;
++
++
++
++ // Get tuner module, base interface, and I2C bridge.
++ pTuner = myTuner->pTuner;
++ pBaseInterface = pTuner->pBaseInterface;
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Get writing byte and byte number.
++ pData = (unsigned char *)pArray;
++ DataLen = (unsigned long)count;
++
++ // Calculate MxL5007T maximum writing byte number.
++ // Note: MxL5007T maximum writing byte number must be a multiple of 2.
++ WritingByteNumMax = pBaseInterface->I2cWritingByteNumMax;
++ WritingByteNumMax = ((WritingByteNumMax % 2) == 0) ? WritingByteNumMax : (WritingByteNumMax - 1);
++
++
++ // Set register bytes.
++ // Note: The 2 kind of I2C formats of MxL5007T is described as follows:
++ // 1. start_bit + (device_addr | writing_bit) + (register_addr + writing_byte) * n + stop_bit
++ // ...
++ // start_bit + (device_addr | writing_bit) + (register_addr + writing_byte) * m + stop_bit
++ // 2. start_bit + (device_addr | writing_bit) + 0xff + stop_bit
++ for(i = 0, WritingIndex = 0; i < DataLen; i++, WritingIndex++)
++ {
++ // Put data into buffer.
++ Buffer[WritingIndex] = pData[i];
++
++ // If writing buffer is full or put data into buffer completely, send the I2C writing command with buffer.
++ if( (WritingIndex == (WritingByteNumMax - 1)) || (i == (DataLen - 1)) )
++ {
++ if(pI2cBridge->ForwardI2cWritingCmd(pI2cBridge, Buffer, (WritingIndex + LEN_1_BYTE)) != FUNCTION_SUCCESS)
++ goto error_status_set_tuner_registers;
++
++ WritingIndex = -1;
++ }
++ }
++
++
++ return MxL_OK;
++
++
++error_status_set_tuner_registers:
++ return MxL_ERR_OTHERS;
++}
++
++/******************************************************************************
++**
++** Name: MxL_I2C_Read
++**
++** Description: I2C read operations
++**
++** Parameters:
++** DeviceAddr - MxL5007 Device address
++** Addr - register address for read
++** *Data - data return
++**
++** Returns: 0 if success
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 12-16-2007 khuang initial release.
++**
++******************************************************************************/
++//UINT32 MxL_I2C_Read(UINT8 DeviceAddr, UINT8 Addr, UINT8* mData)
++UINT32 MxL_I2C_Read(MxL5007_TunerConfigS* myTuner, UINT8 Addr, UINT8* mData)
++{
++ TUNER_MODULE *pTuner;
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++ unsigned char Buffer[LEN_2_BYTE];
++
++
++
++ // Get tuner module and I2C bridge.
++ pTuner = myTuner->pTuner;
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Set tuner register reading address.
++ // Note: The I2C format of tuner register reading address setting is as follows:
++ // start_bit + (DeviceAddr | writing_bit) + 0xfb + RegReadingAddr + stop_bit
++ Buffer[0] = (unsigned char)MXL5007T_I2C_READING_CONST;
++ Buffer[1] = (unsigned char)Addr;
++ if(pI2cBridge->ForwardI2cWritingCmd(pI2cBridge, Buffer, LEN_2_BYTE) != FUNCTION_SUCCESS)
++ goto error_status_set_tuner_register_reading_address;
++
++ // Get tuner register bytes.
++ // Note: The I2C format of tuner register byte getting is as follows:
++ // start_bit + (DeviceAddr | reading_bit) + reading_byte + stop_bit
++ if(pI2cBridge->ForwardI2cReadingCmd(pI2cBridge, Buffer, LEN_1_BYTE) != FUNCTION_SUCCESS)
++ goto error_status_get_tuner_registers;
++
++ *mData = (UINT8)Buffer[0];
++
++
++ return MxL_OK;
++
++
++error_status_get_tuner_registers:
++error_status_set_tuner_register_reading_address:
++ return MxL_ERR_OTHERS;
++}
++
++/******************************************************************************
++**
++** Name: MxL_Delay
++**
++** Description: Delay function in milli-second
++**
++** Parameters:
++** mSec - milli-second to delay
++**
++** Returns: 0
++**
++** Revision History:
++**
++** SCR Date Author Description
++** -------------------------------------------------------------------------
++** N/A 12-16-2007 khuang initial release.
++**
++******************************************************************************/
++//void MxL_Delay(UINT32 mSec)
++void MxL_Delay(MxL5007_TunerConfigS* myTuner, UINT32 mSec)
++{
++ TUNER_MODULE *pTuner;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++
++
++ // Get tuner module and base interface.
++ pTuner = myTuner->pTuner;
++ pBaseInterface = pTuner->pBaseInterface;
++
++ // Wait in ms.
++ pBaseInterface->WaitMs(pBaseInterface, mSec);
++
++
++ return;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// MaxLinear source code - MxL5007.c
++
++
++/*
++ MxL5007 Source Code : V4.1.3
++
++ Copyright, Maxlinear, Inc.
++ All Rights Reserved
++
++ File Name: MxL5007.c
++
++ Description: The source code is for MxL5007 user to quickly integrate MxL5007 into their software.
++ There are two functions the user can call to generate a array of I2C command that's require to
++ program the MxL5007 tuner. The user should pass an array pointer and an integer pointer in to the
++ function. The funciton will fill up the array with format like follow:
++
++ addr1
++ data1
++ addr2
++ data2
++ ...
++
++ The user can then pass this array to their I2C function to perform progromming the tuner.
++*/
++//#include "StdAfx.h"
++//#include "MxL5007_Common.h"
++//#include "MxL5007.h"
++
++
++
++UINT32 MxL5007_Init(UINT8* pArray, // a array pointer that store the addr and data pairs for I2C write
++ UINT32* Array_Size, // a integer pointer that store the number of element in above array
++ UINT8 Mode,
++ SINT32 IF_Diff_Out_Level,
++ UINT32 Xtal_Freq_Hz,
++ UINT32 IF_Freq_Hz,
++ UINT8 Invert_IF,
++ UINT8 Clk_Out_Enable,
++ UINT8 Clk_Out_Amp
++ )
++{
++
++ UINT32 Reg_Index=0;
++ UINT32 Array_Index=0;
++
++ IRVType IRV_Init[]=
++ {
++ //{ Addr, Data}
++ { 0x02, 0x06},
++ { 0x03, 0x48},
++ { 0x05, 0x04},
++ { 0x06, 0x10},
++ { 0x2E, 0x15}, //Override
++ { 0x30, 0x10}, //Override
++ { 0x45, 0x58}, //Override
++ { 0x48, 0x19}, //Override
++ { 0x52, 0x03}, //Override
++ { 0x53, 0x44}, //Override
++ { 0x6A, 0x4B}, //Override
++ { 0x76, 0x00}, //Override
++ { 0x78, 0x18}, //Override
++ { 0x7A, 0x17}, //Override
++ { 0x85, 0x06}, //Override
++ { 0x01, 0x01}, //TOP_MASTER_ENABLE=1
++ { 0, 0}
++ };
++
++
++ IRVType IRV_Init_Cable[]=
++ {
++ //{ Addr, Data}
++ { 0x02, 0x06},
++ { 0x03, 0x48},
++ { 0x05, 0x04},
++ { 0x06, 0x10},
++ { 0x09, 0x3F},
++ { 0x0A, 0x3F},
++ { 0x0B, 0x3F},
++ { 0x2E, 0x15}, //Override
++ { 0x30, 0x10}, //Override
++ { 0x45, 0x58}, //Override
++ { 0x48, 0x19}, //Override
++ { 0x52, 0x03}, //Override
++ { 0x53, 0x44}, //Override
++ { 0x6A, 0x4B}, //Override
++ { 0x76, 0x00}, //Override
++ { 0x78, 0x18}, //Override
++ { 0x7A, 0x17}, //Override
++ { 0x85, 0x06}, //Override
++ { 0x01, 0x01}, //TOP_MASTER_ENABLE=1
++ { 0, 0}
++ };
++ //edit Init setting here
++
++ PIRVType myIRV;
++
++ switch(Mode)
++ {
++ case MxL_MODE_ISDBT: //ISDB-T Mode
++ myIRV = IRV_Init;
++ SetIRVBit(myIRV, 0x06, 0x1F, 0x10);
++ break;
++ case MxL_MODE_DVBT: //DVBT Mode
++ myIRV = IRV_Init;
++ SetIRVBit(myIRV, 0x06, 0x1F, 0x11);
++ break;
++ case MxL_MODE_ATSC: //ATSC Mode
++ myIRV = IRV_Init;
++ SetIRVBit(myIRV, 0x06, 0x1F, 0x12);
++ break;
++ case MxL_MODE_CABLE:
++ myIRV = IRV_Init_Cable;
++ SetIRVBit(myIRV, 0x09, 0xFF, 0xC1);
++ SetIRVBit(myIRV, 0x0A, 0xFF, 8-IF_Diff_Out_Level);
++ SetIRVBit(myIRV, 0x0B, 0xFF, 0x17);
++ break;
++
++
++ }
++
++ switch(IF_Freq_Hz)
++ {
++ case MxL_IF_4_MHZ:
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x00);
++ break;
++ case MxL_IF_4_5_MHZ: //4.5MHz
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x02);
++ break;
++ case MxL_IF_4_57_MHZ: //4.57MHz
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x03);
++ break;
++ case MxL_IF_5_MHZ:
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x04);
++ break;
++ case MxL_IF_5_38_MHZ: //5.38MHz
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x05);
++ break;
++ case MxL_IF_6_MHZ:
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x06);
++ break;
++ case MxL_IF_6_28_MHZ: //6.28MHz
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x07);
++ break;
++ case MxL_IF_9_1915_MHZ: //9.1915MHz
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x08);
++ break;
++ case MxL_IF_35_25_MHZ:
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x09);
++ break;
++ case MxL_IF_36_15_MHZ:
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x0a);
++ break;
++ case MxL_IF_44_MHZ:
++ SetIRVBit(myIRV, 0x02, 0x0F, 0x0B);
++ break;
++ }
++
++ if(Invert_IF)
++ SetIRVBit(myIRV, 0x02, 0x10, 0x10); //Invert IF
++ else
++ SetIRVBit(myIRV, 0x02, 0x10, 0x00); //Normal IF
++
++
++ switch(Xtal_Freq_Hz)
++ {
++ case MxL_XTAL_16_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x00); //select xtal freq & Ref Freq
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x00);
++ break;
++ case MxL_XTAL_20_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x10);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x01);
++ break;
++ case MxL_XTAL_20_25_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x20);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x02);
++ break;
++ case MxL_XTAL_20_48_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x30);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x03);
++ break;
++ case MxL_XTAL_24_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x40);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x04);
++ break;
++ case MxL_XTAL_25_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x50);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x05);
++ break;
++ case MxL_XTAL_25_14_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x60);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x06);
++ break;
++ case MxL_XTAL_27_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x70);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x07);
++ break;
++ case MxL_XTAL_28_8_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x80);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x08);
++ break;
++ case MxL_XTAL_32_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0x90);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x09);
++ break;
++ case MxL_XTAL_40_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0xA0);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x0A);
++ break;
++ case MxL_XTAL_44_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0xB0);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x0B);
++ break;
++ case MxL_XTAL_48_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0xC0);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x0C);
++ break;
++ case MxL_XTAL_49_3811_MHZ:
++ SetIRVBit(myIRV, 0x03, 0xF0, 0xD0);
++ SetIRVBit(myIRV, 0x05, 0x0F, 0x0D);
++ break;
++ }
++
++ if(!Clk_Out_Enable) //default is enable
++ SetIRVBit(myIRV, 0x03, 0x08, 0x00);
++
++ //Clk_Out_Amp
++ SetIRVBit(myIRV, 0x03, 0x07, Clk_Out_Amp);
++
++ //Generate one Array that Contain Data, Address
++ while (myIRV[Reg_Index].Num || myIRV[Reg_Index].Val)
++ {
++ pArray[Array_Index++] = myIRV[Reg_Index].Num;
++ pArray[Array_Index++] = myIRV[Reg_Index].Val;
++ Reg_Index++;
++ }
++
++ *Array_Size=Array_Index;
++ return 0;
++}
++
++
++UINT32 MxL5007_RFTune(UINT8* pArray, UINT32* Array_Size, UINT32 RF_Freq, UINT8 BWMHz)
++{
++ IRVType IRV_RFTune[]=
++ {
++ //{ Addr, Data}
++ { 0x0F, 0x00}, //abort tune
++ { 0x0C, 0x15},
++ { 0x0D, 0x40},
++ { 0x0E, 0x0E},
++ { 0x1F, 0x87}, //Override
++ { 0x20, 0x1F}, //Override
++ { 0x21, 0x87}, //Override
++ { 0x22, 0x1F}, //Override
++ { 0x80, 0x01}, //Freq Dependent Setting
++ { 0x0F, 0x01}, //start tune
++ { 0, 0}
++ };
++
++ UINT32 dig_rf_freq=0;
++ UINT32 temp;
++ UINT32 Reg_Index=0;
++ UINT32 Array_Index=0;
++ UINT32 i;
++ UINT32 frac_divider = 1000000;
++
++ switch(BWMHz)
++ {
++ case MxL_BW_6MHz: //6MHz
++ SetIRVBit(IRV_RFTune, 0x0C, 0x3F, 0x15); //set DIG_MODEINDEX, DIG_MODEINDEX_A, and DIG_MODEINDEX_CSF
++ break;
++ case MxL_BW_7MHz: //7MHz
++ SetIRVBit(IRV_RFTune, 0x0C, 0x3F, 0x2A);
++ break;
++ case MxL_BW_8MHz: //8MHz
++ SetIRVBit(IRV_RFTune, 0x0C, 0x3F, 0x3F);
++ break;
++ }
++
++
++ //Convert RF frequency into 16 bits => 10 bit integer (MHz) + 6 bit fraction
++ dig_rf_freq = RF_Freq / MHz;
++ temp = RF_Freq % MHz;
++ for(i=0; i<6; i++)
++ {
++ dig_rf_freq <<= 1;
++ frac_divider /=2;
++ if(temp > frac_divider)
++ {
++ temp -= frac_divider;
++ dig_rf_freq++;
++ }
++ }
++
++ //add to have shift center point by 7.8124 kHz
++ if(temp > 7812)
++ dig_rf_freq ++;
++
++ SetIRVBit(IRV_RFTune, 0x0D, 0xFF, (UINT8)dig_rf_freq);
++ SetIRVBit(IRV_RFTune, 0x0E, 0xFF, (UINT8)(dig_rf_freq>>8));
++
++ if (RF_Freq >=333*MHz)
++ SetIRVBit(IRV_RFTune, 0x80, 0x40, 0x40);
++
++ //Generate one Array that Contain Data, Address
++ while (IRV_RFTune[Reg_Index].Num || IRV_RFTune[Reg_Index].Val)
++ {
++ pArray[Array_Index++] = IRV_RFTune[Reg_Index].Num;
++ pArray[Array_Index++] = IRV_RFTune[Reg_Index].Val;
++ Reg_Index++;
++ }
++
++ *Array_Size=Array_Index;
++
++ return 0;
++}
++
++//local functions called by Init and RFTune
++UINT32 SetIRVBit(PIRVType pIRV, UINT8 Num, UINT8 Mask, UINT8 Val)
++{
++ while (pIRV->Num || pIRV->Val)
++ {
++ if (pIRV->Num==Num)
++ {
++ pIRV->Val&=~Mask;
++ pIRV->Val|=Val;
++ }
++ pIRV++;
++
++ }
++ return 0;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// MaxLinear source code - MxL5007_API.h
++
++
++/*
++
++ Driver APIs for MxL5007 Tuner
++
++ Copyright, Maxlinear, Inc.
++ All Rights Reserved
++
++ File Name: MxL5007_API.c
++
++ Version: 4.1.3
++*/
++
++
++//#include "StdAfx.h"
++//#include "MxL5007_API.h"
++//#include "MxL_User_Define.c"
++//#include "MxL5007.c"
++
++
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++// //
++// Tuner Functions //
++// //
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
++MxL_ERR_MSG MxL_Set_Register(MxL5007_TunerConfigS* myTuner, UINT8 RegAddr, UINT8 RegData)
++{
++ UINT32 Status=0;
++ UINT8 pArray[2];
++ pArray[0] = RegAddr;
++ pArray[1] = RegData;
++// Status = MxL_I2C_Write((UINT8)myTuner->I2C_Addr, pArray, 2);
++ Status = MxL_I2C_Write(myTuner, pArray, 2);
++ if(Status) return MxL_ERR_SET_REG;
++
++ return MxL_OK;
++
++}
++
++MxL_ERR_MSG MxL_Get_Register(MxL5007_TunerConfigS* myTuner, UINT8 RegAddr, UINT8 *RegData)
++{
++// if(MxL_I2C_Read((UINT8)myTuner->I2C_Addr, RegAddr, RegData))
++ if(MxL_I2C_Read(myTuner, RegAddr, RegData))
++ return MxL_ERR_GET_REG;
++ return MxL_OK;
++
++}
++
++MxL_ERR_MSG MxL_Soft_Reset(MxL5007_TunerConfigS* myTuner)
++{
++ UINT32 Status=0;
++ UINT8 reg_reset;
++ reg_reset = 0xFF;
++// if(MxL_I2C_Write((UINT8)myTuner->I2C_Addr, ®_reset, 1))
++ if(MxL_I2C_Write(myTuner, ®_reset, 1))
++ return MxL_ERR_OTHERS;
++
++ return MxL_OK;
++}
++
++MxL_ERR_MSG MxL_Loop_Through_On(MxL5007_TunerConfigS* myTuner, MxL5007_LoopThru isOn)
++{
++ UINT8 pArray[2]; // a array pointer that store the addr and data pairs for I2C write
++
++ pArray[0]=0x04;
++ if(isOn)
++ pArray[1]= 0x01;
++ else
++ pArray[1]= 0x0;
++
++// if(MxL_I2C_Write((UINT8)myTuner->I2C_Addr, pArray, 2))
++ if(MxL_I2C_Write(myTuner, pArray, 2))
++ return MxL_ERR_OTHERS;
++
++ return MxL_OK;
++}
++
++MxL_ERR_MSG MxL_Stand_By(MxL5007_TunerConfigS* myTuner)
++{
++ UINT8 pArray[4]; // a array pointer that store the addr and data pairs for I2C write
++
++ pArray[0] = 0x01;
++ pArray[1] = 0x0;
++ pArray[2] = 0x0F;
++ pArray[3] = 0x0;
++
++// if(MxL_I2C_Write((UINT8)myTuner->I2C_Addr, pArray, 4))
++ if(MxL_I2C_Write(myTuner, pArray, 4))
++ return MxL_ERR_OTHERS;
++
++ return MxL_OK;
++}
++
++MxL_ERR_MSG MxL_Wake_Up(MxL5007_TunerConfigS* myTuner)
++{
++ UINT8 pArray[2]; // a array pointer that store the addr and data pairs for I2C write
++
++ pArray[0] = 0x01;
++ pArray[1] = 0x01;
++
++// if(MxL_I2C_Write((UINT8)myTuner->I2C_Addr, pArray, 2))
++ if(MxL_I2C_Write(myTuner, pArray, 2))
++ return MxL_ERR_OTHERS;
++
++ if(MxL_Tuner_RFTune(myTuner, myTuner->RF_Freq_Hz, myTuner->BW_MHz))
++ return MxL_ERR_RFTUNE;
++
++ return MxL_OK;
++}
++
++MxL_ERR_MSG MxL_Tuner_Init(MxL5007_TunerConfigS* myTuner)
++{
++ UINT8 pArray[MAX_ARRAY_SIZE]; // a array pointer that store the addr and data pairs for I2C write
++ UINT32 Array_Size; // a integer pointer that store the number of element in above array
++
++ //Soft reset tuner
++ if(MxL_Soft_Reset(myTuner))
++ return MxL_ERR_INIT;
++
++ //perform initialization calculation
++ MxL5007_Init(pArray, &Array_Size, (UINT8)myTuner->Mode, myTuner->IF_Diff_Out_Level, (UINT32)myTuner->Xtal_Freq,
++ (UINT32)myTuner->IF_Freq, (UINT8)myTuner->IF_Spectrum, (UINT8)myTuner->ClkOut_Setting, (UINT8)myTuner->ClkOut_Amp);
++
++ //perform I2C write here
++// if(MxL_I2C_Write((UINT8)myTuner->I2C_Addr, pArray, Array_Size))
++ if(MxL_I2C_Write(myTuner, pArray, Array_Size))
++ return MxL_ERR_INIT;
++
++ return MxL_OK;
++}
++
++
++MxL_ERR_MSG MxL_Tuner_RFTune(MxL5007_TunerConfigS* myTuner, UINT32 RF_Freq_Hz, MxL5007_BW_MHz BWMHz)
++{
++ UINT32 Status=0;
++ UINT8 pArray[MAX_ARRAY_SIZE]; // a array pointer that store the addr and data pairs for I2C write
++ UINT32 Array_Size; // a integer pointer that store the number of element in above array
++
++ //Store information into struc
++ myTuner->RF_Freq_Hz = RF_Freq_Hz;
++ myTuner->BW_MHz = BWMHz;
++
++ //perform Channel Change calculation
++ MxL5007_RFTune(pArray,&Array_Size,RF_Freq_Hz,BWMHz);
++
++ //perform I2C write here
++// if(MxL_I2C_Write((UINT8)myTuner->I2C_Addr, pArray, Array_Size))
++ if(MxL_I2C_Write(myTuner, pArray, Array_Size))
++ return MxL_ERR_RFTUNE;
++
++ //wait for 3ms
++// MxL_Delay(3);
++ MxL_Delay(myTuner, 3);
++
++ return MxL_OK;
++}
++
++MxL5007_ChipVersion MxL_Check_ChipVersion(MxL5007_TunerConfigS* myTuner)
++{
++ UINT8 Data;
++// if(MxL_I2C_Read((UINT8)myTuner->I2C_Addr, 0xD9, &Data))
++ if(MxL_I2C_Read(myTuner, 0xD9, &Data))
++ return MxL_GET_ID_FAIL;
++
++ switch(Data)
++ {
++ case 0x14: return MxL_5007T_V4; break;
++ default: return MxL_UNKNOWN_ID;
++ }
++}
++
++MxL_ERR_MSG MxL_RFSynth_Lock_Status(MxL5007_TunerConfigS* myTuner, BOOL* isLock)
++{
++ UINT8 Data;
++ *isLock = MxL_FALSE;
++// if(MxL_I2C_Read((UINT8)myTuner->I2C_Addr, 0xD8, &Data))
++ if(MxL_I2C_Read(myTuner, 0xD8, &Data))
++ return MxL_ERR_OTHERS;
++ Data &= 0x0C;
++ if (Data == 0x0C)
++ *isLock = MxL_TRUE; //RF Synthesizer is Lock
++ return MxL_OK;
++}
++
++MxL_ERR_MSG MxL_REFSynth_Lock_Status(MxL5007_TunerConfigS* myTuner, BOOL* isLock)
++{
++ UINT8 Data;
++ *isLock = MxL_FALSE;
++// if(MxL_I2C_Read((UINT8)myTuner->I2C_Addr, 0xD8, &Data))
++ if(MxL_I2C_Read(myTuner, 0xD8, &Data))
++ return MxL_ERR_OTHERS;
++ Data &= 0x03;
++ if (Data == 0x03)
++ *isLock = MxL_TRUE; //REF Synthesizer is Lock
++ return MxL_OK;
++}
++
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_mxl5007t.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_mxl5007t.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,834 @@
++#ifndef __TUNER_MXL5007T_H
++#define __TUNER_MXL5007T_H
++
++/**
++
++@file
++
++@brief MxL5007T tuner module declaration
++
++One can manipulate MxL5007T tuner through MxL5007T module.
++MxL5007T module is derived from tuner module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the tuner example in tuner_base.h except the listed lines.
++
++
++
++#include "tuner_mxl5007t.h"
++
++
++...
++
++
++
++int main(void)
++{
++ TUNER_MODULE *pTuner;
++ MXL5007T_EXTRA_MODULE *pTunerExtra;
++
++ TUNER_MODULE TunerModuleMemory;
++ MXL5007T_EXTRA_MODULE Mxl5007tExtraModuleMemory;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory;
++
++ unsigned long BandwidthMode;
++
++
++ ...
++
++
++
++ // Build MxL5007T tuner module.
++ BuildMxl5007tModule(
++ &pTuner,
++ &TunerModuleMemory,
++ &Mxl5007tExtraModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ 0xc0, // I2C device address is 0xc0 in 8-bit format.
++ CRYSTAL_FREQ_16000000HZ, // Crystal frequency is 16.0 MHz.
++ MXL5007T_STANDARD_DVBT, // The MxL5007T standard mode is DVB-T.
++ IF_FREQ_4570000HZ, // The MxL5007T IF frequency is 4.57 MHz.
++ SPECTRUM_NORMAL, // The MxL5007T spectrum mode is normal.
++ MXL5007T_CLK_OUT_DISABLE, // The MxL5007T clock output mode is disabled.
++ MXL5007T_CLK_OUT_AMP_0, // The MxL5007T clock output amplitude is 0.
++ 0 // The MxL5007T QAM IF differential output level is 0 for cable only.
++ );
++
++
++
++
++
++ // Get MxL5007T tuner extra module.
++ pTunerExtra = (T2266_EXTRA_MODULE *)(pTuner->pExtra);
++
++
++
++
++
++ // ==== Initialize tuner and set its parameters =====
++
++ ...
++
++ // Set MXL5007T bandwidth.
++ pTunerExtra->SetBandwidthMode(pTuner, MXL5007T_BANDWIDTH_6MHZ);
++
++
++
++
++
++ // ==== Get tuner information =====
++
++ ...
++
++ // Get MXL5007T bandwidth.
++ pTunerExtra->GetBandwidthMode(pTuner, &BandwidthMode);
++
++
++
++ // See the example for other tuner functions in tuner_base.h
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++
++
++
++#include "tuner_base.h"
++
++
++
++
++
++// The following context is source code provided by MaxLinear.
++
++
++
++
++
++// MaxLinear source code - MxL5007_Common.h
++
++
++/*******************************************************************************
++ *
++ * FILE NAME : MxL_Common.h
++ *
++ * AUTHOR : Kyle Huang
++ * DATE CREATED : May 05, 2008
++ *
++ * DESCRIPTION :
++ *
++ *******************************************************************************
++ * Copyright (c) 2006, MaxLinear, Inc.
++ ******************************************************************************/
++
++//#ifndef __MXL5007_COMMON_H
++//#define __MXL5007_COMMON_H
++
++
++
++/******************************************************************************
++* User-Defined Types (Typedefs)
++******************************************************************************/
++
++
++/****************************************************************************
++* Imports and definitions for WIN32
++****************************************************************************/
++//#include <windows.h>
++typedef unsigned char UINT8;
++typedef unsigned short UINT16;
++typedef unsigned int UINT32;
++typedef char SINT8;
++typedef short SINT16;
++typedef int SINT32;
++//typedef float REAL32;
++
++// Additional definition
++#define BOOL int
++#define MxL_FALSE 0
++#define MxL_TRUE 1
++
++/****************************************************************************\
++* Imports and definitions for non WIN32 platforms *
++\****************************************************************************/
++/*
++typedef unsigned char UINT8;
++typedef unsigned short UINT16;
++typedef unsigned int UINT32;
++typedef char SINT8;
++typedef short SINT16;
++typedef int SINT32;
++typedef float REAL32;
++
++// create a boolean
++#ifndef __boolean__
++#define __boolean__
++typedef enum {FALSE=0,TRUE} BOOL;
++#endif //boolean
++*/
++
++
++/****************************************************************************\
++* Definitions for all platforms *
++\****************************************************************************/
++#ifndef NULL
++#define NULL (void*)0
++#endif
++
++
++
++/******************************/
++/* MxL5007 Err message */
++/******************************/
++typedef enum{
++ MxL_OK = 0,
++ MxL_ERR_INIT = 1,
++ MxL_ERR_RFTUNE = 2,
++ MxL_ERR_SET_REG = 3,
++ MxL_ERR_GET_REG = 4,
++ MxL_ERR_OTHERS = 10
++}MxL_ERR_MSG;
++
++/******************************/
++/* MxL5007 Chip verstion */
++/******************************/
++typedef enum{
++ MxL_UNKNOWN_ID = 0x00,
++ MxL_5007T_V4 = 0x14,
++ MxL_GET_ID_FAIL = 0xFF
++}MxL5007_ChipVersion;
++
++
++/******************************************************************************
++ CONSTANTS
++******************************************************************************/
++
++#ifndef MHz
++ #define MHz 1000000
++#endif
++
++#define MAX_ARRAY_SIZE 100
++
++
++// Enumeration of Mode
++// Enumeration of Mode
++typedef enum
++{
++ MxL_MODE_ISDBT = 0,
++ MxL_MODE_DVBT = 1,
++ MxL_MODE_ATSC = 2,
++ MxL_MODE_CABLE = 0x10
++} MxL5007_Mode ;
++
++typedef enum
++{
++ MxL_IF_4_MHZ = 4000000,
++ MxL_IF_4_5_MHZ = 4500000,
++ MxL_IF_4_57_MHZ = 4570000,
++ MxL_IF_5_MHZ = 5000000,
++ MxL_IF_5_38_MHZ = 5380000,
++ MxL_IF_6_MHZ = 6000000,
++ MxL_IF_6_28_MHZ = 6280000,
++ MxL_IF_9_1915_MHZ = 9191500,
++ MxL_IF_35_25_MHZ = 35250000,
++ MxL_IF_36_15_MHZ = 36150000,
++ MxL_IF_44_MHZ = 44000000
++} MxL5007_IF_Freq ;
++
++typedef enum
++{
++ MxL_XTAL_16_MHZ = 16000000,
++ MxL_XTAL_20_MHZ = 20000000,
++ MxL_XTAL_20_25_MHZ = 20250000,
++ MxL_XTAL_20_48_MHZ = 20480000,
++ MxL_XTAL_24_MHZ = 24000000,
++ MxL_XTAL_25_MHZ = 25000000,
++ MxL_XTAL_25_14_MHZ = 25140000,
++ MxL_XTAL_27_MHZ = 27000000,
++ MxL_XTAL_28_8_MHZ = 28800000,
++ MxL_XTAL_32_MHZ = 32000000,
++ MxL_XTAL_40_MHZ = 40000000,
++ MxL_XTAL_44_MHZ = 44000000,
++ MxL_XTAL_48_MHZ = 48000000,
++ MxL_XTAL_49_3811_MHZ = 49381100
++} MxL5007_Xtal_Freq ;
++
++typedef enum
++{
++ MxL_BW_6MHz = 6,
++ MxL_BW_7MHz = 7,
++ MxL_BW_8MHz = 8
++} MxL5007_BW_MHz;
++
++typedef enum
++{
++ MxL_NORMAL_IF = 0 ,
++ MxL_INVERT_IF
++
++} MxL5007_IF_Spectrum ;
++
++typedef enum
++{
++ MxL_LT_DISABLE = 0 ,
++ MxL_LT_ENABLE
++
++} MxL5007_LoopThru ;
++
++typedef enum
++{
++ MxL_CLKOUT_DISABLE = 0 ,
++ MxL_CLKOUT_ENABLE
++
++} MxL5007_ClkOut;
++
++typedef enum
++{
++ MxL_CLKOUT_AMP_0 = 0 ,
++ MxL_CLKOUT_AMP_1,
++ MxL_CLKOUT_AMP_2,
++ MxL_CLKOUT_AMP_3,
++ MxL_CLKOUT_AMP_4,
++ MxL_CLKOUT_AMP_5,
++ MxL_CLKOUT_AMP_6,
++ MxL_CLKOUT_AMP_7
++} MxL5007_ClkOut_Amp;
++
++typedef enum
++{
++ MxL_I2C_ADDR_96 = 96 ,
++ MxL_I2C_ADDR_97 = 97 ,
++ MxL_I2C_ADDR_98 = 98 ,
++ MxL_I2C_ADDR_99 = 99
++} MxL5007_I2CAddr ;
++
++//
++// MxL5007 TunerConfig Struct
++//
++typedef struct _MxL5007_TunerConfigS
++{
++ MxL5007_I2CAddr I2C_Addr;
++ MxL5007_Mode Mode;
++ SINT32 IF_Diff_Out_Level;
++ MxL5007_Xtal_Freq Xtal_Freq;
++ MxL5007_IF_Freq IF_Freq;
++ MxL5007_IF_Spectrum IF_Spectrum;
++ MxL5007_ClkOut ClkOut_Setting;
++ MxL5007_ClkOut_Amp ClkOut_Amp;
++ MxL5007_BW_MHz BW_MHz;
++ UINT32 RF_Freq_Hz;
++
++ // Additional definition
++ TUNER_MODULE *pTuner;
++
++} MxL5007_TunerConfigS;
++
++
++
++
++//#endif /* __MXL5007_COMMON_H__*/
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// MaxLinear source code - MxL5007.h
++
++
++
++/*
++
++ Driver APIs for MxL5007 Tuner
++
++ Copyright, Maxlinear, Inc.
++ All Rights Reserved
++
++ File Name: MxL5007.h
++
++ */
++
++
++//#include "MxL5007_Common.h"
++
++
++typedef struct
++{
++ UINT8 Num; //Register number
++ UINT8 Val; //Register value
++} IRVType, *PIRVType;
++
++
++UINT32 MxL5007_Init(UINT8* pArray, // a array pointer that store the addr and data pairs for I2C write
++ UINT32* Array_Size, // a integer pointer that store the number of element in above array
++ UINT8 Mode,
++ SINT32 IF_Diff_Out_Level,
++ UINT32 Xtal_Freq_Hz,
++ UINT32 IF_Freq_Hz,
++ UINT8 Invert_IF,
++ UINT8 Clk_Out_Enable,
++ UINT8 Clk_Out_Amp
++ );
++UINT32 MxL5007_RFTune(UINT8* pArray, UINT32* Array_Size,
++ UINT32 RF_Freq, // RF Frequency in Hz
++ UINT8 BWMHz // Bandwidth in MHz
++ );
++UINT32 SetIRVBit(PIRVType pIRV, UINT8 Num, UINT8 Mask, UINT8 Val);
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// MaxLinear source code - MxL5007.h
++
++
++
++/*
++
++ Driver APIs for MxL5007 Tuner
++
++ Copyright, Maxlinear, Inc.
++ All Rights Reserved
++
++ File Name: MxL5007_API.h
++
++ */
++//#ifndef __MxL5007_API_H
++//#define __MxL5007_API_H
++
++//#include "MxL5007_Common.h"
++
++/******************************************************************************
++**
++** Name: MxL_Set_Register
++**
++** Description: Write one register to MxL5007
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++** RegAddr - Register address to be written
++** RegData - Data to be written
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_SET_REG if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Set_Register(MxL5007_TunerConfigS* myTuner, UINT8 RegAddr, UINT8 RegData);
++
++/******************************************************************************
++**
++** Name: MxL_Get_Register
++**
++** Description: Read one register from MxL5007
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++** RegAddr - Register address to be read
++** RegData - Pointer to register read
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_GET_REG if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Get_Register(MxL5007_TunerConfigS* myTuner, UINT8 RegAddr, UINT8 *RegData);
++
++/******************************************************************************
++**
++** Name: MxL_Tuner_Init
++**
++** Description: MxL5007 Initialization
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_INIT if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Tuner_Init(MxL5007_TunerConfigS* );
++
++/******************************************************************************
++**
++** Name: MxL_Tuner_RFTune
++**
++** Description: Frequency tunning for channel
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++** RF_Freq_Hz - RF Frequency in Hz
++** BWMHz - Bandwidth 6, 7 or 8 MHz
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_RFTUNE if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Tuner_RFTune(MxL5007_TunerConfigS*, UINT32 RF_Freq_Hz, MxL5007_BW_MHz BWMHz);
++
++/******************************************************************************
++**
++** Name: MxL_Soft_Reset
++**
++** Description: Software Reset the MxL5007 Tuner
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_OTHERS if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Soft_Reset(MxL5007_TunerConfigS*);
++
++/******************************************************************************
++**
++** Name: MxL_Loop_Through_On
++**
++** Description: Turn On/Off on-chip Loop-through
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++** isOn - True to turn On Loop Through
++** - False to turn off Loop Through
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_OTHERS if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Loop_Through_On(MxL5007_TunerConfigS*, MxL5007_LoopThru);
++
++/******************************************************************************
++**
++** Name: MxL_Standby
++**
++** Description: Enter Standby Mode
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_OTHERS if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Stand_By(MxL5007_TunerConfigS*);
++
++/******************************************************************************
++**
++** Name: MxL_Wakeup
++**
++** Description: Wakeup from Standby Mode (Note: after wake up, please call RF_Tune again)
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_OTHERS if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_Wake_Up(MxL5007_TunerConfigS*);
++
++/******************************************************************************
++**
++** Name: MxL_Check_ChipVersion
++**
++** Description: Return the MxL5007 Chip ID
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++**
++** Returns: MxL_ChipVersion
++**
++******************************************************************************/
++MxL5007_ChipVersion MxL_Check_ChipVersion(MxL5007_TunerConfigS*);
++
++/******************************************************************************
++**
++** Name: MxL_RFSynth_Lock_Status
++**
++** Description: RF synthesizer lock status of MxL5007
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++** isLock - Pointer to Lock Status
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_OTHERS if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_RFSynth_Lock_Status(MxL5007_TunerConfigS* , BOOL* isLock);
++
++/******************************************************************************
++**
++** Name: MxL_REFSynth_Lock_Status
++**
++** Description: REF synthesizer lock status of MxL5007
++**
++** Parameters: myTuner - Pointer to MxL5007_TunerConfigS
++** isLock - Pointer to Lock Status
++**
++** Returns: MxL_ERR_MSG - MxL_OK if success
++** - MxL_ERR_OTHERS if fail
++**
++******************************************************************************/
++MxL_ERR_MSG MxL_REFSynth_Lock_Status(MxL5007_TunerConfigS* , BOOL* isLock);
++
++//#endif //__MxL5007_API_H
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is MxL5007T tuner API source code
++
++
++
++
++
++// Definitions
++
++// Standard mode
++enum MXL5007T_STANDARD_MODE
++{
++ MXL5007T_STANDARD_DVBT,
++ MXL5007T_STANDARD_ATSC,
++ MXL5007T_STANDARD_QAM,
++ MXL5007T_STANDARD_ISDBT,
++};
++
++
++// Clock output mode
++enum MXL5007T_CLK_OUT_MODE
++{
++ MXL5007T_CLK_OUT_DISABLE,
++ MXL5007T_CLK_OUT_ENABLE,
++};
++
++
++// Clock output amplitude mode
++enum MXL5007T_CLK_OUT_AMP_MODE
++{
++ MXL5007T_CLK_OUT_AMP_0,
++ MXL5007T_CLK_OUT_AMP_1,
++ MXL5007T_CLK_OUT_AMP_2,
++ MXL5007T_CLK_OUT_AMP_3,
++ MXL5007T_CLK_OUT_AMP_4,
++ MXL5007T_CLK_OUT_AMP_5,
++ MXL5007T_CLK_OUT_AMP_6,
++ MXL5007T_CLK_OUT_AMP_7,
++};
++
++
++// Bandwidth mode
++enum MXL5007T_BANDWIDTH_MODE
++{
++ MXL5007T_BANDWIDTH_6000000HZ,
++ MXL5007T_BANDWIDTH_7000000HZ,
++ MXL5007T_BANDWIDTH_8000000HZ,
++};
++
++
++
++// Constant
++#define MXL5007T_I2C_READING_CONST 0xfb
++
++// Default value
++#define MXL5007T_RF_FREQ_HZ_DEFAULT 44000000;
++#define MXL5007T_BANDWIDTH_MODE_DEFAULT MxL_BW_6MHz;
++
++
++
++
++
++// MxL5007T extra module
++typedef struct MXL5007T_EXTRA_MODULE_TAG MXL5007T_EXTRA_MODULE;
++
++
++
++
++
++// MxL5007T bandwidth mode setting function pointer
++typedef int
++(*MXL5007T_FP_SET_BANDWIDTH_MODE)(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ );
++
++
++
++// MxL5007T bandwidth mode getting function pointer
++typedef int
++(*MXL5007T_FP_GET_BANDWIDTH_MODE)(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ );
++
++
++
++
++
++// MxL5007T extra module
++struct MXL5007T_EXTRA_MODULE_TAG
++{
++ // MxL5007T extra variables
++ int BandwidthMode;
++ int IsBandwidthModeSet;
++
++ // MxL5007T MaxLinear-defined structure
++ MxL5007_TunerConfigS *pTunerConfigS;
++ MxL5007_TunerConfigS TunerConfigSMemory;
++
++ // MxL5007T extra function pointers
++ MXL5007T_FP_SET_BANDWIDTH_MODE SetBandwidthMode;
++ MXL5007T_FP_GET_BANDWIDTH_MODE GetBandwidthMode;
++};
++
++
++
++
++
++// Builder
++void
++BuildMxl5007tModule(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ MXL5007T_EXTRA_MODULE *pMxl5007tExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr,
++ unsigned long CrystalFreqHz,
++ int StandardMode,
++ unsigned long IfFreqHz,
++ int SpectrumMode,
++ int ClkOutMode,
++ int ClkOutAmpMode,
++ long QamIfDiffOutLevel
++ );
++
++
++
++
++
++// Manipulaing functions
++void
++mxl5007t_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ );
++
++void
++mxl5007t_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ );
++
++int
++mxl5007t_Initialize(
++ TUNER_MODULE *pTuner
++ );
++
++int
++mxl5007t_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ );
++
++int
++mxl5007t_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ );
++
++
++
++
++
++// Extra manipulaing functions
++int
++mxl5007t_SetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ );
++
++int
++mxl5007t_GetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ );
++
++
++
++
++
++// I2C birdge module demod argument setting
++void
++mxl5007t_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ );
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_tua9001.c
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_tua9001.c Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,1252 @@
++/**
++
++@file
++
++@brief TUA9001 tuner module definition
++
++One can manipulate TUA9001 tuner through TUA9001 module.
++TUA9001 module is derived from tuner module.
++
++*/
++
++
++#include "tuner_tua9001.h"
++
++
++
++
++
++/**
++
++@brief TUA9001 tuner module builder
++
++Use BuildTua9001Module() to build TUA9001 module, set all module function pointers with the corresponding functions,
++and initialize module private variables.
++
++
++@param [in] ppTuner Pointer to TUA9001 tuner module pointer
++@param [in] pTunerModuleMemory Pointer to an allocated tuner module memory
++@param [in] pTua9001ExtraModuleMemory Pointer to an allocated TUA9001 extra module memory
++@param [in] pBaseInterfaceModuleMemory Pointer to an allocated base interface module memory
++@param [in] pI2cBridgeModuleMemory Pointer to an allocated I2C bridge module memory
++@param [in] DeviceAddr TUA9001 I2C device address
++
++
++@note
++ -# One should call BuildTua9001Module() to build TUA9001 module before using it.
++
++*/
++void
++BuildTua9001Module(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ TUA9001_EXTRA_MODULE *pTua9001ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr
++ )
++{
++ TUNER_MODULE *pTuner;
++ TUA9001_EXTRA_MODULE *pExtra;
++
++
++
++ // Set tuner module pointer.
++ *ppTuner = pTunerModuleMemory;
++
++ // Get tuner module.
++ pTuner = *ppTuner;
++
++ // Set tuner extra module pointer, base interface module pointer, and I2C bridge module pointer.
++ pTuner->pExtra = pTua9001ExtraModuleMemory;
++ pTuner->pBaseInterface = pBaseInterfaceModuleMemory;
++ pTuner->pI2cBridge = pI2cBridgeModuleMemory;
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++
++
++ // Set tuner type.
++ pTuner->TunerType = TUNER_TYPE_TUA9001;
++
++ // Set tuner I2C device address.
++ pTuner->DeviceAddr = DeviceAddr;
++
++
++ // Initialize tuner parameter setting status.
++ pTuner->IsRfFreqHzSet = NO;
++
++ // Initialize tuner module variables.
++ // Note: Need to give both RF frequency and bandwidth for TUA9001 tuning function,
++ // so we have to give a default RF frequncy.
++ pTuner->RfFreqHz = TUA9001_RF_FREQ_HZ_DEFAULT;
++
++
++ // Set I2C bridge tuner arguments.
++ tua9001_SetI2cBridgeModuleTunerArg(pTuner);
++
++
++ // Set tuner module manipulating function pointers.
++ pTuner->GetTunerType = tua9001_GetTunerType;
++ pTuner->GetDeviceAddr = tua9001_GetDeviceAddr;
++
++ pTuner->Initialize = tua9001_Initialize;
++ pTuner->SetRfFreqHz = tua9001_SetRfFreqHz;
++ pTuner->GetRfFreqHz = tua9001_GetRfFreqHz;
++
++
++ // Initialize tuner extra module variables.
++ // Note: Need to give both RF frequency and bandwidth for TUA9001 tuning function,
++ // so we have to give a default bandwidth.
++ pExtra->BandwidthMode = TUA9001_BANDWIDTH_MODE_DEFAULT;
++ pExtra->IsBandwidthModeSet = NO;
++
++ // Set tuner extra module function pointers.
++ pExtra->SetBandwidthMode = tua9001_SetBandwidthMode;
++ pExtra->GetBandwidthMode = tua9001_GetBandwidthMode;
++ pExtra->GetRegBytesWithRegAddr = tua9001_GetRegBytesWithRegAddr;
++ pExtra->SetSysRegByte = tua9001_SetSysRegByte;
++ pExtra->GetSysRegByte = tua9001_GetSysRegByte;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_TUNER_TYPE
++
++*/
++void
++tua9001_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ )
++{
++ // Get tuner type from tuner module.
++ *pTunerType = pTuner->TunerType;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_DEVICE_ADDR
++
++*/
++void
++tua9001_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ )
++{
++ // Get tuner I2C device address from tuner module.
++ *pDeviceAddr = pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_INITIALIZE
++
++*/
++int
++tua9001_Initialize(
++ TUNER_MODULE *pTuner
++ )
++{
++ TUA9001_EXTRA_MODULE *pExtra;
++
++
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Initialize TUA9001 tuner.
++ if(initializeTua9001(pTuner) != TUNER_OK)
++ goto error_status_initialize_tuner;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_initialize_tuner:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_SET_RF_FREQ_HZ
++
++*/
++int
++tua9001_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ )
++{
++ TUA9001_EXTRA_MODULE *pExtra;
++
++ long RfFreqKhz;
++ int BandwidthMode;
++
++
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get bandwidth mode.
++ BandwidthMode = pExtra->BandwidthMode;
++
++ // Calculate RF frequency in KHz.
++ // Note: RfFreqKhz = round(RfFreqHz / 1000)
++ RfFreqKhz = (long)((RfFreqHz + 500) / 1000);
++
++ // Set TUA9001 RF frequency and bandwidth.
++ if(tuneTua9001(pTuner, RfFreqKhz, BandwidthMode) != TUNER_OK)
++ goto error_status_set_tuner_rf_frequency;
++
++
++ // Set tuner RF frequency parameter.
++ pTuner->RfFreqHz = (unsigned long)(RfFreqKhz * 1000);
++ pTuner->IsRfFreqHzSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@see TUNER_FP_GET_RF_FREQ_HZ
++
++*/
++int
++tua9001_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ )
++{
++ // Get tuner RF frequency in Hz from tuner module.
++ if(pTuner->IsRfFreqHzSet != YES)
++ goto error_status_get_tuner_rf_frequency;
++
++ *pRfFreqHz = pTuner->RfFreqHz;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_rf_frequency:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set TUA9001 tuner bandwidth mode.
++
++*/
++int
++tua9001_SetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ )
++{
++ TUA9001_EXTRA_MODULE *pExtra;
++
++ long RfFreqKhz;
++
++
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get RF frequncy in KHz.
++ // Note: Doesn't need to take round() of RfFreqHz, because its value unit is 1000 Hz.
++ RfFreqKhz = (long)(pTuner->RfFreqHz / 1000);
++
++ // Set TUA9001 RF frequency and bandwidth.
++ if(tuneTua9001(pTuner, RfFreqKhz, BandwidthMode) != TUNER_OK)
++ goto error_status_set_tuner_bandwidth;
++
++
++ // Set tuner bandwidth parameter.
++ pExtra->BandwidthMode = BandwidthMode;
++ pExtra->IsBandwidthModeSet = YES;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_tuner_bandwidth:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Get TUA9001 tuner bandwidth mode.
++
++*/
++int
++tua9001_GetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ )
++{
++ TUA9001_EXTRA_MODULE *pExtra;
++
++
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ // Get tuner bandwidth in Hz from tuner module.
++ if(pExtra->IsBandwidthModeSet != YES)
++ goto error_status_get_tuner_bandwidth;
++
++ *pBandwidthMode = pExtra->BandwidthMode;
++
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_bandwidth:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++//3 +BIg Lock in Upper Func to ON/OFF repeater
++/**
++
++@brief Get register bytes with address.
++
++*/
++int
++tua9001_GetRegBytesWithRegAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char DeviceAddr,
++ unsigned char RegAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ )
++{
++ // Get tuner register byte.
++// if(rtl2832usb_ReadWithRegAddr(DeviceAddr, RegAddr, pReadingBytes, ByteNum) != FUNCTION_SUCCESS)
++// goto error_status_get_tuner_registers_with_address;
++
++ I2C_BRIDGE_MODULE *pI2cBridge;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned char TunerDeviceAddr;
++
++ struct dvb_usb_device *d;
++
++
++ // Get I2C bridge.
++ pI2cBridge = pTuner->pI2cBridge;
++ pBaseInterface = pTuner->pBaseInterface;
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++
++ if( read_rtl2832_tuner_register( d, TunerDeviceAddr, RegAddr, pReadingBytes, ByteNum ) )
++ goto error_status_get_tuner_registers_with_address;
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_tuner_registers_with_address:
++ return FUNCTION_ERROR;
++}
++
++//3 -BIg Lock in Upper Func to ON/OFF repeater
++
++
++
++/**
++
++@brief Set system register byte.
++
++*/
++int
++tua9001_SetSysRegByte(
++ TUNER_MODULE *pTuner,
++ unsigned short RegAddr,
++ unsigned char WritingByte
++ )
++{
++ // Set demod system register byte.
++// if(RTK_SYS_Byte_Write(RegAddr, LEN_1_BYTE, &WritingByte) != TRUE)
++// goto error_status_set_system_registers;
++
++ I2C_BRIDGE_MODULE *pI2cBridge;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ struct dvb_usb_device *d;
++
++ // Get I2C bridge.
++ pI2cBridge = pTuner->pI2cBridge;
++ pBaseInterface = pTuner->pBaseInterface;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++
++ if ( write_usb_sys_char_bytes( d, RTD2832U_SYS, RegAddr, &WritingByte, LEN_1_BYTE) )
++ goto error_status_set_system_registers;
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_set_system_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Get system register byte.
++
++*/
++int
++tua9001_GetSysRegByte(
++ TUNER_MODULE *pTuner,
++ unsigned short RegAddr,
++ unsigned char *pReadingByte
++ )
++{
++ // Get demod system register byte.
++// if(RTK_SYS_Byte_Read(RegAddr, LEN_1_BYTE, pReadingByte) != TRUE)
++// goto error_status_get_system_registers;
++
++ I2C_BRIDGE_MODULE *pI2cBridge;
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ struct dvb_usb_device *d;
++
++ // Get I2C bridge.
++ pI2cBridge = pTuner->pI2cBridge;
++ pBaseInterface = pTuner->pBaseInterface;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++
++ if ( read_usb_sys_char_bytes(d, RTD2832U_SYS, RegAddr, pReadingByte, LEN_1_BYTE) )
++ goto error_status_get_system_registers;
++
++ return FUNCTION_SUCCESS;
++
++
++error_status_get_system_registers:
++ return FUNCTION_ERROR;
++}
++
++
++
++
++
++/**
++
++@brief Set I2C bridge module tuner arguments.
++
++TUA9001 builder will use tua9001_SetI2cBridgeModuleTunerArg() to set I2C bridge module tuner arguments.
++
++
++@param [in] pTuner The tuner module pointer
++
++
++@see BuildTua9001Module()
++
++*/
++void
++tua9001_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ )
++{
++ I2C_BRIDGE_MODULE *pI2cBridge;
++
++
++
++ // Get I2C bridge module.
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Set I2C bridge module tuner arguments.
++ pI2cBridge->pTunerDeviceAddr = &pTuner->DeviceAddr;
++
++
++ return;
++}
++
++
++
++
++
++// TUA9001 custom-implement functions
++
++
++int setRESETN (TUNER_MODULE *pTuner, unsigned int i_state)
++{
++ TUA9001_EXTRA_MODULE *pExtra;
++ unsigned char Byte;
++
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get GPO value.
++ if(pExtra->GetSysRegByte(pTuner, GPO_ADDR, &Byte) != FUNCTION_SUCCESS)
++ goto error_status_get_system_registers;
++
++ // Note: Hardware PCB has inverter in this pin, should give inverted value on GPIO3.
++ if (i_state == H_LEVEL)
++ {
++ /* set tuner RESETN pin to "H" */
++ // Note: The GPIO3 output value should be '0'.
++ if( pTuner->b_set_tuner_power_gpio4 ) Byte &= ~BIT_4_MASK;
++ else Byte &= ~BIT_3_MASK;
++ }
++ else
++ {
++ /* set tuner RESETN pin to "L" */
++ // Note: The GPIO3 output value should be '1'.
++ if( pTuner->b_set_tuner_power_gpio4 ) Byte |= BIT_4_MASK;
++ else Byte |= BIT_3_MASK;
++ }
++
++ // Set GPO value.
++ if(pExtra->SetSysRegByte(pTuner, GPO_ADDR, Byte) != FUNCTION_SUCCESS)
++ goto error_status_set_system_registers;
++
++
++ return TUNER_OK;
++
++
++error_status_set_system_registers:
++error_status_get_system_registers:
++ return TUNER_ERR;
++}
++
++
++
++int setRXEN (TUNER_MODULE *pTuner, unsigned int i_state)
++{
++ TUA9001_EXTRA_MODULE *pExtra;
++ unsigned char Byte;
++
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++ // Get GPO value.
++ if(pExtra->GetSysRegByte(pTuner, GPO_ADDR, &Byte) != FUNCTION_SUCCESS)
++ goto error_status_get_system_registers;
++
++ if (i_state == H_LEVEL)
++ {
++ /* set tuner RXEN pin to "H" */
++ // Note: The GPIO1 output value should be '1'.
++ Byte |= BIT_1_MASK;
++ }
++ else
++ {
++ /* set tuner RXEN pin to "L" */
++ // Note: The GPIO1 output value should be '0'.
++ Byte &= ~BIT_1_MASK;
++ }
++
++ // Set GPO value.
++ if(pExtra->SetSysRegByte(pTuner, GPO_ADDR, Byte) != FUNCTION_SUCCESS)
++ goto error_status_set_system_registers;
++
++
++ return TUNER_OK;
++
++
++error_status_set_system_registers:
++error_status_get_system_registers:
++ return TUNER_ERR;
++}
++
++
++
++int setCEN (TUNER_MODULE *pTuner, unsigned int i_state)
++{
++ // Do nothing.
++ // Note: Hardware PCB always gives 'H' to tuner CEN pin.
++ return TUNER_OK;
++}
++
++
++
++int waitloop (TUNER_MODULE *pTuner, unsigned int i_looptime)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++ unsigned long WaitTimeMs;
++
++
++ // Get base interface.
++ pBaseInterface = pTuner->pBaseInterface;
++
++ /* wait time = i_looptime * 1 uS */
++ // Note: 1. The unit of WaitMs() function is ms.
++ // 2. WaitTimeMs = ceil(i_looptime / 1000)
++ WaitTimeMs = i_looptime / 1000;
++
++ if((i_looptime % 1000) > 0)
++ WaitTimeMs += 1;
++
++ pBaseInterface->WaitMs(pBaseInterface, WaitTimeMs);
++
++
++ return TUNER_OK;
++}
++
++
++
++int i2cBusWrite (TUNER_MODULE *pTuner, unsigned char deviceAddress, unsigned char registerAddress, char *data,
++ unsigned int length)
++{
++ BASE_INTERFACE_MODULE *pBaseInterface;
++
++ unsigned char ByteNum;
++ unsigned char WritingBytes[I2C_BUFFER_LEN];
++ unsigned int i;
++
++ I2C_BRIDGE_MODULE *pI2cBridge;
++ unsigned char TunerDeviceAddr;
++ struct dvb_usb_device *d;
++
++ // Get base interface.
++ pBaseInterface = pTuner->pBaseInterface;
++
++ // Get I2C bridge.
++ pI2cBridge = pTuner->pI2cBridge;
++
++ // Get tuner device address.
++ TunerDeviceAddr = *pI2cBridge->pTunerDeviceAddr;
++
++ pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
++
++
++ /* I2C write data format */
++ /* STA device_address ACK register_address ACK H_Byte-Data ACK L_Byte-Data !ACK STO */
++
++ /* STA = start condition, ACK = Acknowledge, STO = stop condition */
++ /* *data = pointer to data source */
++ /* length = number of bytes to write */
++
++ // Determine byte number.
++ //ByteNum = length + LEN_1_BYTE;
++ ByteNum = length;
++
++ // Determine writing bytes.
++ //WritingBytes[0] = registerAddress;
++
++ for(i = 0; i < length; i++)
++ //WritingBytes[LEN_1_BYTE + i] = data[i];
++ WritingBytes[i] = data[i];
++
++ // Send I2C writing command.
++// if(pBaseInterface->I2cWrite(pBaseInterface, deviceAddress, WritingBytes, ByteNum) != FUNCTION_SUCCESS)
++// goto error_status_set_tuner_registers;
++
++
++ if( write_rtl2832_tuner_register( d, TunerDeviceAddr, registerAddress, WritingBytes, ByteNum ) )
++ goto error_status_set_tuner_registers;
++
++
++ return TUNER_OK;
++
++
++error_status_set_tuner_registers:
++ return TUNER_ERR;
++}
++
++
++
++int i2cBusRead (TUNER_MODULE *pTuner, unsigned char deviceAddress, unsigned char registerAddress, char *data,
++ unsigned int length)
++{
++ TUA9001_EXTRA_MODULE *pExtra;
++
++
++ // Get tuner extra module.
++ pExtra = (TUA9001_EXTRA_MODULE *)pTuner->pExtra;
++
++
++ /* I2C read data format */
++ /* STA device_address ACK register_address ACK STA H_Byte-Data ACK device_address_read ACK H_Byte-Data ACK L_Byte-Data ACKH STO */
++
++ /* STA = start condition, ACK = Acknowledge (generated by TUA9001), ACKH = Acknowledge (generated by Host), STO = stop condition */
++ /* *data = pointer to data destination */
++ /* length = number of bytes to read */
++
++ // Get tuner register bytes with address.
++ // Note: We must use re-start I2C reading format for TUA9001 tuner register reading.
++ if(pExtra->GetRegBytesWithRegAddr(pTuner, deviceAddress, registerAddress, data, length) != FUNCTION_SUCCESS)
++ goto error_status_get_tuner_registers;
++
++
++ return TUNER_OK;
++
++
++error_status_get_tuner_registers:
++ return TUNER_ERR;
++}
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is source code provided by Infineon.
++
++
++
++
++
++// Infineon source code - driver_tua9001.c
++
++
++/* ============================================================================
++** Copyright (C) 1997-2007 Infineon AG All rights reserved.
++** ============================================================================
++**
++** ============================================================================
++** Revision Information :
++** File name: driver_tua9001.c
++** Version: V 1.01
++** Date:
++**
++** ============================================================================
++** History:
++**
++** Date Author Comment
++** ----------------------------------------------------------------------------
++**
++** 2007.11.06 Walter Pichler created.
++** 2008.04.08 Walter Pichler adaption to TUA 9001E
++**
++** ============================================================================
++*/
++
++/*============================================================================
++Includes
++============================================================================*/
++
++//#include "driver_tua9001.h"
++//#include "driver_tua9001_NeededFunctions.h" /* Note: This function have to be provided by the user */
++
++/*============================================================================
++Local compiler keeys ( usage depends on the application )
++============================================================================*/
++
++#define CRYSTAL_26_MHZ
++//#define CRYSTAL_19.2_MHZ
++//#define CRYSTAL_20.48_MHZ
++
++//#define AGC_BY_IIC
++//#define AGC_BY_AGC_BUS
++#define AGC_BY_EXT_PIN
++
++
++/*============================================================================
++Named Constants Definitions ( usage depends on the application )
++============================================================================*/
++
++#define TUNERs_TUA9001_DEVADDR 0xC0
++
++/* Note: The correct device address depends hardware settings. See Datasheet
++ and User Manual for details. */
++
++/*============================================================================
++Local Named Constants Definitions
++============================================================================*/
++#define OPERATIONAL_MODE 0x03
++#define CHANNEL_BANDWITH 0x04
++#define SW_CONTR_TIME_SLICING 0x05
++#define BASEBAND_GAIN_CONTROL 0x06
++#define MANUAL_BASEBAND_GAIN 0x0b
++#define REFERENCE_FREQUENCY 0x1d
++#define CHANNEL_WORD 0x1f
++#define CHANNEL_OFFSET 0x20
++#define CHANNEL_FILTER_TRIMMING 0x2f
++#define OUTPUT_BUFFER 0x32
++#define RF_AGC_CONFIG_A 0x36
++#define RF_AGC_CONFIG_B 0x37
++#define UHF_LNA_SELECT 0x39
++#define LEVEL_DETECTOR 0x3a
++#define MIXER_CURRENT 0x3b
++#define PORT_CONTROL 0x3e
++#define CRYSTAL_TRIMMING 0x41
++#define CHANNEL_FILTER_STATUS 0x60
++#define SIG_STRENGHT_INDICATION 0x62
++#define PLL_LOCK 0x69
++#define RECEIVER_STATE 0x70
++#define RF_INPUT 0x71
++#define BASEBAND_GAIN 0x72
++#define CHIP_IDENT_CODE 0x7e
++#define CHIP_REVISION 0x7f
++
++#define TUNERs_TUA9001_BW_8 0xcf
++#define TUNERs_TUA9001_BW_7 0x10
++#define TUNERs_TUA9001_BW_6 0x20
++#define TUNERs_TUA9001_BW_5 0x30
++
++
++
++
++/*============================================================================
++ Types definition
++============================================================================*/
++
++
++
++
++/*============================================================================
++ Public Functions
++============================================================================*/
++
++
++/**
++ * tuner initialisation
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int initializeTua9001 (TUNER_MODULE *pTuner)
++{
++ unsigned int counter;
++ char i2cseq[2];
++ tunerReceiverState_t tunerState;
++ unsigned char DeviceAddr;
++
++ // Get tuner deviece address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++ /* Note: CEN may also be hard wired in the application*/
++ if(setCEN (pTuner, H_LEVEL) != TUNER_OK) goto error_status; /* asserting Chip enable */
++
++ if(setRESETN (pTuner, L_LEVEL) != TUNER_OK) goto error_status; /* asserting RESET */
++
++ if(setRXEN (pTuner, L_LEVEL) != TUNER_OK) goto error_status; /* RXEN to low >> IDLE STATE */
++
++ /* Note: 20ms assumes that all external power supplies are settled. If not, add more time here */
++ waitloop (pTuner, 20); /* wait for 20 uS */
++
++ if(setRESETN (pTuner, H_LEVEL) != TUNER_OK) goto error_status; /* de-asserting RESET */
++
++ /* This is to wait for the Crystal Oscillator to settle .. wait until IDLE mode is reached */
++ counter = 6;
++ do
++ {
++ counter --;
++ waitloop (pTuner, 1000); /* wait for 1 mS */
++ if(getReceiverStateTua9001 (pTuner, &tunerState) != TUNER_OK) goto error_status;
++ }while ((tunerState != IDLE) && (counter));
++
++ if (tunerState != IDLE)
++ return TUNER_ERR; /* error >> break initialization */
++
++ /**** Overwrite default register value ****/
++ i2cseq[0] = 0x65; /* Waiting time before PLL cal. start */
++ i2cseq[1] = 0x12;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x1e, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0xB8; /* VCO Varactor bias fine tuning */
++ i2cseq[1] = 0x88;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x25, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x54; /* LNA switching Threshold for UHF1/2 */
++ i2cseq[1] = 0x60;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x39, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x00;
++ i2cseq[1] = 0xC0;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x3b, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0xF0; /* LO- Path Set LDO output voltage */
++ i2cseq[1] = 0x00;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x3a, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x00; /* Set EXTAGC interval */
++ i2cseq[1] = 0x00;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x08, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x00; /* Set max. capacitive load */
++ i2cseq[1] = 0x30;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x32, i2cseq, 2) != TUNER_OK) goto error_status;
++
++
++ /**** Set Crystal Reference Frequency an Trim value ****/
++#if defined(CRYSTAL_26_MHZ) /* Frequency 26 MHz */
++ i2cseq[0] = 0x01;
++ i2cseq[1] = 0xB0;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x1d, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x70; /* NDK 3225 series 26 MHz XTAL */
++ i2cseq[1] = 0x3a;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x41, i2cseq, 2) != TUNER_OK) goto error_status;
++ i2cseq[0] = 0x1C;
++ i2cseq[1] = 0x78;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x40, i2cseq, 2) != TUNER_OK) goto error_status;
++
++#elif defined(CRYSTAL_19.2_MHZ) /* Frequency 19.2 MHz */
++ i2cseq[0] = 0x01;
++ i2cseq[1] = 0xA0;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x1d, i2cseq, 2) != TUNER_OK) goto error_status;
++ /* Note: Insert optimised register values for 0x40 / 0x41 for used crystal */
++ /* contact application support for further information */
++#elif defined(CRYSTAL_20.48_MHZ) /* Frequency 20,48 MHz */
++ i2cseq[0] = 0x01;
++ i2cseq[1] = 0xA8;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x1d, i2cseq, 2) != TUNER_OK) goto error_status;
++ /* Note: Insert optimised register values for 0x40 / 0x41 for used crystal */
++ /* contact application support for further information */
++#endif
++
++
++
++ /**** Set desired Analog Baseband AGC mode ****/
++#if defined (AGC_BY_IIC)
++ i2cseq[0] = 0x00; /* Bypass AGC controller >> IIC based AGC */
++ i2cseq[1] = 0x40;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x06, i2cseq, 2) != TUNER_OK) goto error_status;
++#elif defined(AGC_BY_AGC_BUS)
++ i2cseq[0] = 0x00; /* Digital AGC bus */
++ i2cseq[1] = 0x00; /* 0,5 dB steps */
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x06, i2cseq, 2) != TUNER_OK) goto error_status;
++#elif defined(AGC_BY_EXT_PIN)
++ i2cseq[0] = 0x40; /* Ext. AGC pin */
++ i2cseq[1] = 0x00;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x06, i2cseq, 2) != TUNER_OK) goto error_status;
++#endif
++
++
++ /**** set desired RF AGC parameter *****/
++ i2cseq[0] = 0x1c; /* Set Wideband Detector Current (100 uA) */
++ i2cseq[1] = 0x00;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x2c, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0xC0; /* Set RF AGC Threshold (-32.5dBm) */
++ i2cseq[1] = 0x13;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x36, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x6f; /* RF AGC Parameter */
++ i2cseq[1] = 0x18;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x37, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x00; /* aditional VCO settings */
++ i2cseq[1] = 0x08;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x27, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x00; /* aditional PLL settings */
++ i2cseq[1] = 0x01;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x2a, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ i2cseq[0] = 0x0a; /* VCM correction */
++ i2cseq[1] = 0x40;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x34, i2cseq, 2) != TUNER_OK) goto error_status;
++
++
++ return TUNER_OK;
++
++
++error_status:
++ return TUNER_ERR;
++}
++
++
++
++/**
++ * tuner tune
++ * @param i_freq tuning frequency
++ * @param i_bandwidth channel bandwidth
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int tuneTua9001 (TUNER_MODULE *pTuner, long i_freq, tunerDriverBW_t i_bandwidth)
++{
++ char i2cseq[2];
++ unsigned int divider_factor;
++ unsigned int ch_offset;
++ unsigned int counter;
++ unsigned int lo_path_settings;
++ tunerReceiverState_t tunerState;
++ unsigned char DeviceAddr;
++
++ // Get tuner deviece address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++
++
++ /* de-assert RXEN >> IDLE STATE */
++ if(setRXEN (pTuner, L_LEVEL) != TUNER_OK) goto error_status;
++
++
++ /* calculate divider factor */
++ if (i_freq < 1000000) /* divider factor and channel offset for UHF/VHF III */
++ {
++ ch_offset = 0x1C20; /* channel offset 150 MHz */
++ divider_factor = (unsigned int) (((i_freq - 150000) * 48) / 1000);
++ lo_path_settings = 0xb6de;
++ }
++
++ else /* calculate divider factor for L-Band Frequencies */
++ {
++ ch_offset = 0x5460; /* channel offset 450 MHz */
++ divider_factor = (unsigned int) (((i_freq - 450000) * 48) / 1000);
++ lo_path_settings = 0xbede;
++ }
++
++
++ // Set LO Path
++ i2cseq[0] = lo_path_settings >> 8;
++ i2cseq[1] = lo_path_settings & 0xff;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x2b, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ // Set channel offset
++ i2cseq [0] = ch_offset >> 8;
++ i2cseq [1] = ch_offset & 0xff;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x20, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ // Set Frequency
++ i2cseq [0] = divider_factor >> 8;
++ i2cseq [1] = divider_factor & 0xff;
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x1f, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ // Set bandwidth
++ if(i2cBusRead (pTuner, DeviceAddr, 0x04, i2cseq, 2) != TUNER_OK) goto error_status; /* get current register value */
++ i2cseq [0] &= TUNERs_TUA9001_BW_8;
++
++ switch (i_bandwidth)
++ {
++ case TUNER_BANDWIDTH_8MHZ:
++ // Do nothing.
++ break;
++ case TUNER_BANDWIDTH_7MHZ: i2cseq [0] |= TUNERs_TUA9001_BW_7;
++ break;
++ case TUNER_BANDWIDTH_6MHZ: i2cseq [0] |= TUNERs_TUA9001_BW_6;
++ break;
++ case TUNER_BANDWIDTH_5MHZ: i2cseq [0] |= TUNERs_TUA9001_BW_5;
++ break;
++ default:
++ goto error_status;
++ break;
++ }
++
++ if(i2cBusWrite (pTuner, DeviceAddr, 0x04, i2cseq, 2) != TUNER_OK) goto error_status;
++
++ /* assert RXEN >> RX STATE */
++ if(setRXEN (pTuner, H_LEVEL) != TUNER_OK) goto error_status;
++
++ /* This is to wait for the RX state to settle .. wait until RX mode is reached */
++ counter = 3;
++ do
++ {
++ counter --;
++ waitloop (pTuner, 1000); /* wait for 1 mS */
++ if(getReceiverStateTua9001 (pTuner, &tunerState) != TUNER_OK) goto error_status;
++ }while ((tunerState != RX) && (counter));
++
++ if (tunerState != RX)
++ {
++ if(setRXEN (pTuner, L_LEVEL) != TUNER_OK) goto error_status; /* d-assert RXEN >> IDLE STATE */
++ return TUNER_ERR; /* error >> tuning fail */
++ }
++
++ return TUNER_OK;
++
++
++error_status:
++ return TUNER_ERR;
++}
++
++
++/**
++ * Get pll locked state
++ * @param o_pll pll locked state
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int getPllLockedStateTua9001 (TUNER_MODULE *pTuner, tunerPllLocked_t *o_pll)
++{
++ char i2cseq[2];
++ unsigned char DeviceAddr;
++
++ // Get tuner deviece address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++ if(i2cBusRead (pTuner, DeviceAddr, 0x69, i2cseq, 2) != TUNER_OK) goto error_status; /* get current register value */
++
++ o_pll[0] = (i2cseq[1] & 0x08) ? PLL_LOCKED : PLL_NOT_LOCKED;
++
++ return TUNER_OK;
++
++
++error_status:
++ return TUNER_ERR;
++}
++
++
++/**
++ * Get tuner state
++ * @param o_tunerState tuner state
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int getReceiverStateTua9001 (TUNER_MODULE *pTuner, tunerReceiverState_t *o_tunerState)
++{
++ char i2cseq[2];
++ unsigned char DeviceAddr;
++
++ // Get tuner deviece address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++ if(i2cBusRead (pTuner, DeviceAddr, 0x70, i2cseq, 2) != TUNER_OK) goto error_status; /* get current register value */
++
++// switch (i2cseq[1] & ~0x1f)
++ // Note: Maybe the MSB byte is i2cseq[0]
++ // The original code looks like the MSB byte is i2cseq[1]
++ // Note: ~0x0f = 0xffffffe0, not 0xe0 --> i2cseq[0] & ~0x1f result is wrong.
++ switch (i2cseq[0] & 0xe0)
++ {
++ case 0x80: o_tunerState [0] = IDLE; break;
++ case 0x40: o_tunerState [0] = RX; break;
++ case 0x20: o_tunerState [0] = STANDBY;
++ }
++
++ return TUNER_OK;
++
++
++error_status:
++ return TUNER_ERR;
++}
++
++
++/**
++ * Get active input
++ * @param o_activeInput active input info
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int getActiveInputTua9001 (TUNER_MODULE *pTuner, tunerActiveInput_t *o_activeInput)
++{
++ char i2cseq[2];
++ unsigned char DeviceAddr;
++
++ // Get tuner deviece address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++ if(i2cBusRead (pTuner, DeviceAddr, 0x71, i2cseq, 2) != TUNER_OK) goto error_status; /* get current register value */
++
++// switch (i2cseq[1] & ~0x0f)
++ // Note: Maybe the MSB byte is i2cseq[0]
++ // The original code looks like the MSB byte is i2cseq[1]
++ // Note: ~0x0f = 0xfffffff0, not 0xf0 --> i2cseq[0] & ~0x0f result is wrong.
++ switch (i2cseq[0] & 0xf0)
++ {
++ case 0x80: o_activeInput [0] = L_INPUT_ACTIVE; break;
++ case 0x20: o_activeInput [0] = UHF_INPUT_ACTIVE; break;
++ case 0x10: o_activeInput [0] = VHF_INPUT_ACTIVE;
++ }
++
++ return TUNER_OK;
++
++
++error_status:
++ return TUNER_ERR;
++}
++
++
++/**
++ * Get baseband gain value
++ * @param o_basebandGain baseband gain value
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int getBasebandGainTua9001 (TUNER_MODULE *pTuner, char *o_basebandGain)
++{
++ char i2cseq[2];
++ unsigned char DeviceAddr;
++
++ // Get tuner deviece address.
++ pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
++
++ if(i2cBusRead (pTuner, DeviceAddr, 0x72, i2cseq, 2) != TUNER_OK) goto error_status; /* get current register value */
++// o_basebandGain [0] = i2cseq [1];
++ // Note: Maybe the MSB byte is i2cseq[0]
++ // The original code looks like the MSB byte is i2cseq[1]
++ o_basebandGain [0] = i2cseq [0];
++
++ return TUNER_OK;
++
++
++error_status:
++ return TUNER_ERR;
++}
++
++
++
+diff -r abd3aac6644e linux/drivers/media/dvb/dvb-usb/tuner_tua9001.h
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ b/linux/drivers/media/dvb/dvb-usb/tuner_tua9001.h Wed Oct 27 09:16:44 2010 +0200
+@@ -0,0 +1,572 @@
++#ifndef __TUNER_TUA9001_H
++#define __TUNER_TUA9001_H
++
++/**
++
++@file
++
++@brief TUA9001 tuner module declaration
++
++One can manipulate TUA9001 tuner through TUA9001 module.
++TUA9001 module is derived from tunerd module.
++
++
++
++@par Example:
++@code
++
++// The example is the same as the tuner example in tuner_base.h except the listed lines.
++
++
++
++#include "tuner_tua9001.h"
++
++
++...
++
++
++
++int main(void)
++{
++ TUNER_MODULE *pTuner;
++ TUA9001_EXTRA_MODULE *pTunerExtra;
++
++ TUNER_MODULE TunerModuleMemory;
++ TUA9001_EXTRA_MODULE Tua9001ExtraModuleMemory;
++ BASE_INTERFACE_MODULE BaseInterfaceModuleMemory;
++ I2C_BRIDGE_MODULE I2cBridgeModuleMemory;
++
++ int BandwidthMode;
++
++
++ ...
++
++
++
++ // Build TUA9001 tuner module.
++ BuildTua9001Module(
++ &pTuner,
++ &TunerModuleMemory,
++ &Tua9001ExtraModuleMemory,
++ &BaseInterfaceModuleMemory,
++ &I2cBridgeModuleMemory,
++ 0xc0 // I2C device address is 0xc0 in 8-bit format.
++ );
++
++
++
++
++
++ // Get TUA9001 tuner extra module.
++ pTunerExtra = (T2266_EXTRA_MODULE *)(pTuner->pExtra);
++
++
++
++
++
++ // ==== Initialize tuner and set its parameters =====
++
++ ...
++
++ // Set TUA9001 bandwidth.
++ pTunerExtra->SetBandwidthMode(pTuner, TUA9001_BANDWIDTH_6MHZ);
++
++
++
++
++
++ // ==== Get tuner information =====
++
++ ...
++
++ // Get TUA9001 bandwidth.
++ pTunerExtra->GetBandwidthMode(pTuner, &BandwidthMode);
++
++
++
++
++
++ // See the example for other tuner functions in tuner_base.h
++
++
++ return 0;
++}
++
++
++@endcode
++
++*/
++
++
++#include "tuner_base.h"
++//#include "i2c_rtl2832usb.h"
++
++
++
++
++
++// The following context is source code provided by Infineon.
++
++
++
++
++
++// Infineon source code - driver_tua9001.h
++
++
++
++/* ============================================================================
++** Copyright (C) 1997-2007 Infineon AG All rights reserved.
++** ============================================================================
++**
++** ============================================================================
++** Revision Information :
++** File name: driver_tua9001.h
++** Version:
++** Date:
++**
++** ============================================================================
++** History:
++**
++** Date Author Comment
++** ----------------------------------------------------------------------------
++**
++** 2007.11.06 Walter Pichler created.
++** ============================================================================
++*/
++
++
++/*============================================================================
++ Named Constants Definitions
++============================================================================*/
++
++#define TUNER_OK 0
++#define TUNER_ERR 0xff
++
++#define H_LEVEL 1
++#define L_LEVEL 0
++
++
++/*============================================================================
++ Types definition
++============================================================================*/
++
++
++typedef enum {
++ TUNER_BANDWIDTH_8MHZ,
++ TUNER_BANDWIDTH_7MHZ,
++ TUNER_BANDWIDTH_6MHZ,
++ TUNER_BANDWIDTH_5MHZ,
++ } tunerDriverBW_t;
++
++
++typedef enum {
++ PLL_LOCKED,
++ PLL_NOT_LOCKED
++ }tunerPllLocked_t;
++
++
++typedef enum {
++ STANDBY,
++ IDLE,
++ RX
++ } tunerReceiverState_t;
++
++
++typedef enum {
++ L_INPUT_ACTIVE,
++ UHF_INPUT_ACTIVE,
++ VHF_INPUT_ACTIVE
++ } tunerActiveInput_t;
++
++
++
++/*============================================================================
++ Public functions
++============================================================================*/
++
++/**
++ * tuner initialisation
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++extern int initializeTua9001 (TUNER_MODULE *pTuner);
++
++
++/**
++ * tuner tune
++ * @param i_freq tuning frequency
++ * @param i_bandwidth channel bandwidth
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++extern int tuneTua9001 (TUNER_MODULE *pTuner, long i_freq, tunerDriverBW_t i_bandwidth);
++
++
++/**
++ * Get tuner state
++ * @param o_tunerState tuner state
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++extern int getReceiverStateTua9001 (TUNER_MODULE *pTuner, tunerReceiverState_t *o_tunerState);
++
++/**
++ * Get active input
++ * @param o_activeInput active input info
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++extern int getActiveInputTua9001 (TUNER_MODULE *pTuner, tunerActiveInput_t *o_activeInput);
++
++
++/**
++ * Get baseband gain value
++ * @param o_basebandGain baseband gain value
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++extern int getBasebandGainTua9001 (TUNER_MODULE *pTuner, char *o_basebandGain);
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// Infineon source code - driver_tua9001_NeededFunctions.h
++
++
++
++/*========================================================================================================================
++ additional needed external funtions ( have to be provided by the user! )
++========================================================================================================================*/
++
++/**
++ * set / reset tuner reset input
++ * @param i_state level
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int setRESETN (TUNER_MODULE *pTuner, unsigned int i_state);
++
++
++/**
++ * set / reset tuner receive enable input
++ * @param i_state level
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int setRXEN (TUNER_MODULE *pTuner, unsigned int i_state);
++
++
++/**
++ * set / reset tuner chiop enable input
++ * @param i_state level
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int setCEN (TUNER_MODULE *pTuner, unsigned int i_state);
++
++
++/**
++ * waitloop
++ * @param i_looptime * 1uS
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++int waitloop (TUNER_MODULE *pTuner, unsigned int i_looptime);
++
++
++/**
++ * i2cBusWrite
++ * @param deviceAdress chip address
++ * @param registerAdress register address
++ * @param *data pointer to data source
++ * @param length number of bytes to transmit
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++ int i2cBusWrite (TUNER_MODULE *pTuner, unsigned char deviceAddress, unsigned char registerAddress, char *data,
++ unsigned int length);
++
++
++/**
++ * i2cBusRead
++ * @param deviceAdress chip address
++ * @param registerAdress register address
++ * @param *data pointer to data destination
++ * @param length number of bytes to read
++ * @retval TUNER_OK No error
++ * @retval TUNER_ERR Error
++*/
++
++ int i2cBusRead (TUNER_MODULE *pTuner, unsigned char deviceAddress, unsigned char registerAddress, char *data,
++ unsigned int length);
++
++/*========================================================================================================================
++ end of additional needed external funtions
++========================================================================================================================*/
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++// The following context is TUA9001 tuner API source code
++
++
++
++
++
++/**
++
++@file
++
++@brief TUA9001 tuner module declaration
++
++One can manipulate TUA9001 tuner through TUA9001 module.
++TUA9001 module is derived from tuner module.
++
++*/
++
++
++
++
++
++// Definitions
++
++// Constant
++#define GPO_ADDR 0x1
++
++// Bandwidth modes
++enum TUA9001_BANDWIDTH_MODE
++{
++ TUA9001_BANDWIDTH_5MHZ = TUNER_BANDWIDTH_5MHZ,
++ TUA9001_BANDWIDTH_6MHZ = TUNER_BANDWIDTH_6MHZ,
++ TUA9001_BANDWIDTH_7MHZ = TUNER_BANDWIDTH_7MHZ,
++ TUA9001_BANDWIDTH_8MHZ = TUNER_BANDWIDTH_8MHZ,
++};
++
++// Default value
++#define TUA9001_RF_FREQ_HZ_DEFAULT 50000000;
++#define TUA9001_BANDWIDTH_MODE_DEFAULT TUA9001_BANDWIDTH_5MHZ;
++
++
++
++
++
++/// TUA9001 extra module alias
++typedef struct TUA9001_EXTRA_MODULE_TAG TUA9001_EXTRA_MODULE;
++
++
++
++
++
++// Extra manipulaing function
++typedef int
++(*TUA9001_FP_SET_BANDWIDTH_MODE)(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ );
++
++typedef int
++(*TUA9001_FP_GET_BANDWIDTH_MODE)(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ );
++
++typedef int
++(*TUA9001_FP_GET_REG_BYTES_WITH_REG_ADDR)(
++ TUNER_MODULE *pTuner,
++ unsigned char DeviceAddr,
++ unsigned char RegAddr,
++ unsigned char *pReadingByte,
++ unsigned char ByteNum
++ );
++
++typedef int
++(*TUA9001_FP_SET_SYS_REG_BYTE)(
++ TUNER_MODULE *pTuner,
++ unsigned short RegAddr,
++ unsigned char WritingByte
++ );
++
++typedef int
++(*TUA9001_FP_GET_SYS_REG_BYTE)(
++ TUNER_MODULE *pTuner,
++ unsigned short RegAddr,
++ unsigned char *pReadingByte
++ );
++
++
++
++
++
++// TUA9001 extra module
++struct TUA9001_EXTRA_MODULE_TAG
++{
++ // TUA9001 extra variables
++ int BandwidthMode;
++ int IsBandwidthModeSet;
++
++ // TUA9001 extra function pointers
++ TUA9001_FP_SET_BANDWIDTH_MODE SetBandwidthMode;
++ TUA9001_FP_GET_BANDWIDTH_MODE GetBandwidthMode;
++ TUA9001_FP_GET_REG_BYTES_WITH_REG_ADDR GetRegBytesWithRegAddr;
++ TUA9001_FP_SET_SYS_REG_BYTE SetSysRegByte;
++ TUA9001_FP_GET_SYS_REG_BYTE GetSysRegByte;
++};
++
++
++
++
++
++// Builder
++void
++BuildTua9001Module(
++ TUNER_MODULE **ppTuner,
++ TUNER_MODULE *pTunerModuleMemory,
++ TUA9001_EXTRA_MODULE *pTua9001ExtraModuleMemory,
++ BASE_INTERFACE_MODULE *pBaseInterfaceModuleMemory,
++ I2C_BRIDGE_MODULE *pI2cBridgeModuleMemory,
++ unsigned char DeviceAddr
++ );
++
++
++
++
++
++// Manipulaing functions
++void
++tua9001_GetTunerType(
++ TUNER_MODULE *pTuner,
++ int *pTunerType
++ );
++
++void
++tua9001_GetDeviceAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char *pDeviceAddr
++ );
++
++int
++tua9001_Initialize(
++ TUNER_MODULE *pTuner
++ );
++
++int
++tua9001_SetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long RfFreqHz
++ );
++
++int
++tua9001_GetRfFreqHz(
++ TUNER_MODULE *pTuner,
++ unsigned long *pRfFreqHz
++ );
++
++
++
++
++
++// Extra manipulaing functions
++int
++tua9001_SetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int BandwidthMode
++ );
++
++int
++tua9001_GetBandwidthMode(
++ TUNER_MODULE *pTuner,
++ int *pBandwidthMode
++ );
++
++int
++tua9001_GetRegBytesWithRegAddr(
++ TUNER_MODULE *pTuner,
++ unsigned char DeviceAddr,
++ unsigned char RegAddr,
++ unsigned char *pReadingBytes,
++ unsigned char ByteNum
++ );
++
++int
++tua9001_SetSysRegByte(
++ TUNER_MODULE *pTuner,
++ unsigned short RegAddr,
++ unsigned char WritingByte
++ );
++
++int
++tua9001_GetSysRegByte(
++ TUNER_MODULE *pTuner,
++ unsigned short RegAddr,
++ unsigned char *pReadingByte
++ );
++
++
++
++
++
++// I2C birdge module demod argument setting
++void
++tua9001_SetI2cBridgeModuleTunerArg(
++ TUNER_MODULE *pTuner
++ );
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++#endif