INT32 try_to_lock_DVBT_signal(struct nim_device *dev, BOOL NeedToInitSystem,BOOL NeedToConfigTuner,NIM_CHANNEL_CHANGE_T *change_para)
{
sony_demod_t * pDemod = (sony_demod_t *)dev->priv;
sony_dvbt_tune_param_t TuneParam;
sony_result_t tuneResult;
if(SONY_DEMOD_BW_1_7_MHZ == change_para->bandwidth)
{
PRINTK_INFO("DVB-T not support 1.7MHZ!\n");
return ERR_FAILUE;
}
memset(&TuneParam,0,sizeof(TuneParam));
TuneParam.centerFreqKHz = change_para->freq;
TuneParam.bandwidth = change_para->bandwidth;
TuneParam.profile = change_para->priority; //SONY_DVBT_PROFILE_HP;
if( NeedToInitSystem || (pDemod->system != SONY_DTV_SYSTEM_DVBT))
{
pDemod->t2_signal = 0;
//to do...
}
tuneResult = sony_integ_dvbt_Tune(pDemod, &TuneParam,NeedToConfigTuner);
switch(tuneResult){
case SONY_RESULT_OK:
PRINTK_INFO("[SONY]DVB-T TS Locked.\n");
//(("DVB-T TS Locked.\n"));
return SUCCESS;
case SONY_RESULT_ERROR_UNLOCK:
PRINTK_INFO("[SONY]DVB-T TS Unlocked.\n");
//(("DVB-T TS Unlocked.\n"));
return ERR_FAILUE;
case SONY_RESULT_ERROR_TIMEOUT:
PRINTK_INFO("[SONY]DVB-T Wait TS Lock but Timeout.\n");
//(("DVB-T Wait TS Lock but Timeout.\n"));
return ERR_FAILUE;
default:
PRINTK_INFO("[SONY] default: in sony_integ_dvbt_Tune\n");
//(("Error in sony_integ_dvbt_Tune (%s)\n", sony_FormatResult(sony_result)));
return ERR_FAILUE;
}
}
/*------------------------------------------------------------------------------
Functions
------------------------------------------------------------------------------*/
int main (int argc, char *argv[])
{
sony_result_t result = SONY_RESULT_OK;
sony_result_t tuneResult = SONY_RESULT_OK;
sony_integ_t integ;
sony_demod_t demod;
sony_tuner_terr_cable_t tunerTerrCable;
// sony_ascot2d_t ascot2d;
sony_i2c_t i2c;
sony_i2c_t tunerI2C;
sony_dvbt_tune_param_t tuneParam;
// drvi2c_feusb_t feusb;
uint8_t i = 0;
argc = argc;
argv = argv;
Port_Init();
/*------------------------------------------------------------------------------
Setup / Initialisation
------------------------------------------------------------------------------*/
/* Create I2C interface for tuner and demosulator parts. GW (GateWay) members
provided but not required for tuner communication. I2C switching handled
internally in the driver using a repeater. */
i2c.gwAddress = 0x00; /* N/A */
i2c.gwSub = 0x00; /* N/A */
i2c.Read = Cxd2837_I2c_Read; /* Base level HW interfacing I2C read function */
i2c.Write = Cxd2837_I2c_Write; /* Base level HW interfacing I2C write function */
i2c.ReadRegister = sony_i2c_CommonReadRegister; /* Common wrapper function for multi byte Read operation */
i2c.WriteRegister = sony_i2c_CommonWriteRegister; /* Common wrapper function for multi byte Write operation */
i2c.WriteOneRegister = sony_i2c_CommonWriteOneRegister; /* Common wrapper function for single byte Write operation */
/* Setup I2C interfaces. */
tunerI2C.gwAddress = 0xc8;
tunerI2C.gwSub = 0x09; /* Connected via demod I2C gateway function. */
tunerI2C.Read = Cxd2837_I2c_ReadGw;
tunerI2C.Write = Cxd2837_I2c_WriteGw;
tunerI2C.ReadRegister = sony_i2c_CommonReadRegister;
tunerI2C.WriteRegister = sony_i2c_CommonWriteRegister;
tunerI2C.WriteOneRegister = sony_i2c_CommonWriteOneRegister;
/* Display driver credentials */
printf ("Driver Version : %s\n", SONY_DEMOD_DRIVER_VERSION);
printf ("Built : %s %s\n\n", SONY_DEMOD_DRIVER_RELEASE_DATE, SONY_DEMOD_DRIVER_RELEASE_TIME);
printf ("------------------------------------------\n");
printf (" Create / Inititialize \n");
printf ("------------------------------------------\n");
/* Create ASCOT2D tuner with the following parameters, please modify as appropriate :
* - XTal = 41MHz
* - Address = 0xC0
* - Configuration Flags = None
*/
{
uint8_t xtalFreqMHz = 41;
uint8_t i2cAddress = 0xc2;
uint32_t configFlags = 0;
result = mopll_tuner_Create (i2cAddress,xtalFreqMHz,&tunerI2C, 0, NULL, &tunerTerrCable);
if (result == SONY_RESULT_OK) {
printf (" Tuner Created with the following parameters:\n");
printf (" - Tuner Type : CXD2837 \n");
printf (" - XTal Frequency : %uMHz\n", xtalFreqMHz);
printf (" - I2C Address : %u\n", i2cAddress);
printf (" - Config Flags : %u\n\n", configFlags);
}
else {
printf (" Error: Unable to create Sony ASCOT2D tuner driver. (result = %s)\n", Common_Result[result]);
return -1;
}
}
/* Create the integration structure which contains the demodulaor and tuner part instances. This
* function also internally Creates the demodulator part. Once created the driver is in
* SONY_DEMOD_STATE_INVALID and must be initialized before calling a Tune / Scan or Monitor API.
*/
{
/* Modify the following to suit your implementation */
sony_demod_xtal_t xtalFreq = SONY_DEMOD_XTAL_41000KHz;
uint8_t i2cAddress = 0xc8;
/* Create parameters for integration structure:
* sony_integ_t * pInteg Integration object
* sony_demod_xtal_t xtalFreq Demodulator xTal frequency
* uint8_t i2cAddress Demodulator I2C address
* sony_i2c_t i2c Demodulator I2C driver
* sony_demod_t *pDemod Demodulator object
*
* Note: Set the following to NULL to disable control
* sony_tuner_terr_cable_t * pTunerTerrCable Terrestrial / Cable tuner object
* sony_tuner_sat_t * pTunerSat Satellite tuner object
* sony_lnbc_t * pLnbc LNB Controller object
*/
result = sony_integ_Create (&integ, xtalFreq, i2cAddress, &i2c, &demod
#ifdef SONY_DEMOD_SUPPORT_TERR_OR_CABLE
/* Terrestrial and Cable supported so include the tuner object into the Create API */
,&tunerTerrCable
#endif
#ifdef SONY_DEMOD_SUPPORT_DVBS_S2
/* Satellite supported so include the tuner and LNB objects into the Create API */
, NULL, NULL
#endif
);
if (result == SONY_RESULT_OK) {
printf (" Demod Created with the following parameters:\n");
printf (" - XTal Frequency : %s\n", Common_DemodXtal[xtalFreq]);
printf (" - I2C Address : %u\n\n", i2cAddress);
}
else {
printf (" Error: Unable to create demodulator driver. (result = %s)\n", Common_Result[result]);
return -1;
}
}
/* Initialize the tuner and demodulator parts to Terrestrial / Cable mode. Following this call the
* driver will be in SONY_DEMOD_STATE_SLEEP_T_C state. From here you can call any Shutdown, Sleep or Tune
* API for Terrestrial / Cable systems or call sony_integ_SleepS to transfer to Satellite mode.
*
* Note : Initialize API should only be called once at the start of the driver creation. Subsequent calls
* to any of the Tune API's do not require re-initialize.
*/
result = sony_integ_InitializeT_C (&integ);
if (result == SONY_RESULT_OK) {
printf (" Driver initialized, current state = SONY_DEMOD_STATE_SLEEP_T_C\n\n");
}
else {
printf (" Error: Unable to initialise the integration driver to terrestiral / cable mode. (result = %s)\n", Common_Result[result]);
return -1;
}
/* ---------------------------------------------------------------------------------
* Configure the Demodulator
* ------------------------------------------------------------------------------ */
/* DVB-T demodulator IF configuration Low IF tuner */
demod.iffreqConfig.configDVBT_5 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
demod.iffreqConfig.configDVBT_6 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
demod.iffreqConfig.configDVBT_7 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
demod.iffreqConfig.configDVBT_8 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
/* DVB-T2 demodulator IF configuration Low IF tuner */
demod.iffreqConfig.configDVBT2_5 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
demod.iffreqConfig.configDVBT2_6 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
demod.iffreqConfig.configDVBT2_7 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
demod.iffreqConfig.configDVBT2_8 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
/* DVB-C demodulator IF configuration Low IF tuner */
demod.iffreqConfig.configDVBC = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
/* DVB-C2 demodulator IF configuration Low IF tuner */
demod.iffreqConfig.configDVBC2_6 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
demod.iffreqConfig.configDVBC2_8 = SONY_DEMOD_MAKE_IFFREQ_CONFIG (36.167);
/* IFAGC setup. Modify to suit connected tuner. */
/* IFAGC positive, value = 0. */
#ifdef TUNER_IFAGCPOS
result = sony_demod_SetConfig (&demod, SONY_DEMOD_CONFIG_IFAGCNEG, 0);
if (result == SONY_RESULT_OK) {
printf (" Demodulator configured for Negative IFAGC.\n");
}
else {
printf (" Error: Unable to configure for Negative IFAGC. (result = %s)\n", Common_Result[result]);
return -1;
}
#endif
/* Spectrum Inversion setup. Modify to suit connected tuner. */
/* Spectrum inverted, value = 1. */
#ifdef TUNER_SPECTRUM_INV
result = sony_demod_SetConfig (&demod, SONY_DEMOD_CONFIG_SPECTRUM_INV, 1);
if (result == SONY_RESULT_OK) {
printf (" Demodulator configured for Inverted Spectrum.\n");
}
else {
printf (" Error: Unable to configure SPECTRUM_INV. (result = %s)\n", Common_Result[result]);
return -1;
}
#endif
/* RF level monitoring (RFAIN/RFAGC) enable/disable. */
/* Default is enabled. 1: Enable, 0: Disable. */
#ifdef TUNER_RFLVLMON_DISABLE
result = sony_demod_SetConfig (&demod, SONY_DEMOD_CONFIG_RFLVMON_ENABLE, 0);
if (result == SONY_RESULT_OK) {
printf (" Demodulator configured to enable RF level monitoring.\n");
}
else {
printf (" Error: Unable to configure RFLVMON_ENABLE. (result = %s)\n", Common_Result[result]);
return -1;
}
#endif
/* Demod tunerOptimize member allows the demod to be optimized internally when
connected to Sony RF parts. Please ensure this is set to
SONY_DEMOD_TUNER_OPTIMIZE_UNKNOWN for all other tuners */
#ifdef TUNER_SONY_ASCOT2D
demod.tunerOptimize = SONY_DEMOD_TUNER_OPTIMIZE_ASCOT2D;
#else
demod.tunerOptimize = SONY_DEMOD_TUNER_OPTIMIZE_UNKNOWN;
#endif
printf (" Demodulator optimised for %s tuner.\n\n", Common_TunerOptimize[demod.tunerOptimize]);
/* ---------------------------------------------------------------------------------
* Tune
* ------------------------------------------------------------------------------ */
printf ("------------------------------------------\n");
printf (" Tune \n");
printf ("------------------------------------------\n");
/* Configure the DVBT tune parameters based on the channel requirements */
tuneParam.bandwidth = SONY_DEMOD_BW_8_MHZ; /* Channel bandwidth */
tuneParam.centerFreqKHz = 634000; /* Channel centre frequency in KHz */
tuneParam.profile = SONY_DVBT_PROFILE_HP; /* Channel profile for hierachical modes. For non-hierachical use HP */
printf (" Tune to DVB-T signal with the following parameters:\n");
printf (" - Center Freq : %uKHz\n", tuneParam.centerFreqKHz);
printf (" - Bandwidth : %s\n", Common_Bandwidth[tuneParam.bandwidth]);
printf (" - Profile : %s\n", DVBT_Profile[tuneParam.profile]);
/* Perform DVBT Tune */
tuneResult = sony_integ_dvbt_Tune (&integ, &tuneParam);
printf (" - Result : %s\n\n", Common_Result[tuneResult]);
/* ---------------------------------------------------------------------------------
* Carrier Offset Compensation
* ------------------------------------------------------------------------------ */
/* Measure the current carrier offset and retune to compensate for cases outside the demodulator
* acquisition range. */
if ((tuneResult == SONY_RESULT_ERROR_TIMEOUT) || (tuneResult == SONY_RESULT_OK)) {
int32_t offsetHz = 0;
uint32_t stepHz = SONY_TUNER_OFFSET_CUTOFF_HZ;
/* Monitor carrier offset. */
result = sony_demod_dvbt_monitor_CarrierOffset (integ.pDemod, &offsetHz);
if (result != SONY_RESULT_OK) {
printf ("Error: Unable to monitor T carrier offset. (result = %s)\n", Common_Result[result]);
return -1;
}
printf (" DVB-T carrier offset of %ldHz detected.\n", offsetHz);
/* Carrier recovery loop locked (demod locked), compensate for the offset and retry tuning. */
stepHz = (stepHz + 1) / 2;
if ((uint32_t) abs (offsetHz) > stepHz) {
/* Tuners have only a fixed frequency step size (stepkHz), therefore we must query the tuner driver to get the actual
* center frequency set by the tuner. */
tuneParam.centerFreqKHz = (uint32_t) ((int32_t) integ.pTunerTerrCable->frequencyKHz + ((offsetHz + 500) / 1000));
printf (" Re-tuning to compensate offset. New parameters:\n");
printf (" - Center Freq : %uKHz\n", tuneParam.centerFreqKHz);
printf (" - Bandwidth : %s\n", Common_Bandwidth[tuneParam.bandwidth]);
printf (" - Profile : %s\n", DVBT_Profile[tuneParam.profile]);
tuneResult = sony_integ_dvbt_Tune (&integ, &tuneParam);
printf (" - Result : %s\n\n", Common_Result[tuneResult]);
}
else {
printf (" Carrier offset compensation not required.\n");
}
}
if (tuneResult != SONY_RESULT_OK) {
printf (" Error: Unable to get TS lock DVB-T signal at %lukHz. (status=%d, %s)\n", tuneParam.centerFreqKHz, tuneResult, Common_Result[result]);
return -1;
}
printf (" TS locked to DVB-T signal at %lukHz.\n\n", tuneParam.centerFreqKHz);
/* ---------------------------------------------------------------------------------
* Monitor the Channel
* ------------------------------------------------------------------------------ */
printf ("------------------------------------------\n");
printf (" Monitor \n");
printf ("------------------------------------------\n");
/* Allow the monitors time to settle */
SONY_SLEEP (1000);
for (i = 1; i <= MONITOR_LOOP_COUNT; i++) {
printf ("\n Monitor Iteration : %u \n\n",i);
printf ("-------------------------|-----------------|----------------- \n");
printf (" MONITOR NAME | PARAMETER | VALUE \n");
printf ("-------------------------|-----------------|----------------- \n");
#ifdef MONITOR_SYNCSTAT
{
uint8_t syncState = 0;
uint8_t tsLock = 0;
uint8_t earlyUnlock = 0;
result = sony_demod_dvbt_monitor_SyncStat (integ.pDemod, &syncState, &tsLock, &earlyUnlock);
if (result == SONY_RESULT_OK) {
printf (" SyncStat | SyncStat | %lu\n", syncState);
printf (" | TS Lock | %s\n", Common_YesNo[tsLock]);
printf (" | Early Unlock | %s\n", Common_YesNo[earlyUnlock]);
}
else {
printf (" SyncStat | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_IFAGCOUT
{
uint32_t ifAGCOut = 0;
result = sony_demod_dvbt_monitor_IFAGCOut (integ.pDemod, &ifAGCOut);
if (result == SONY_RESULT_OK) {
printf (" IFAGCOut | IF AGC | %lu\n", ifAGCOut);
}
else {
printf (" IFAGCOut | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_MODEGUARD
{
sony_dvbt_mode_t mode;
sony_dvbt_guard_t guard;
result = sony_demod_dvbt_monitor_ModeGuard (integ.pDemod, &mode, &guard);
if (result == SONY_RESULT_OK) {
printf (" ModeGuard | Mode | %s\n", DVBT_Mode[mode]);
printf (" | Guard Interval | %s\n", DVBT_GI[guard]);
}
else {
printf (" ModeGuard | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_CARRIEROFFSET
{
int32_t offset;
result = sony_demod_dvbt_monitor_CarrierOffset (integ.pDemod, &offset);
if (result == SONY_RESULT_OK) {
printf (" CarrierOffset | Carrier Offset | %dHz\n", offset);
}
else {
printf (" CarrierOffset | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_PREVITERBIBER
{
uint32_t ber;
result = sony_demod_dvbt_monitor_PreViterbiBER (integ.pDemod, &ber);
if (result == SONY_RESULT_OK) {
printf (" PreViterbiBER | Pre-Viterbi BER | %u x 10^-7\n", ber);
}
else {
printf (" PreViterbiBER | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_PRERSBER
{
uint32_t ber;
result = sony_demod_dvbt_monitor_PreRSBER (integ.pDemod, &ber);
if (result == SONY_RESULT_OK) {
printf (" PreRSBER | Pre-RS BER | %u x 10^-7\n", ber);
}
else {
printf (" PreRSBER | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_TPSINFO
{
sony_dvbt_tpsinfo_t tpsInfo;
result = sony_demod_dvbt_monitor_TPSInfo (integ.pDemod, &tpsInfo);
if (result == SONY_RESULT_OK) {
printf (" TPSInfo | Constellation | %s\n", DVBT_Constellation[tpsInfo.constellation]);
printf (" | Hierachy | %s\n", DVBT_Hier[tpsInfo.hierarchy]);
printf (" | Code Rate HP | %s\n", DVBT_CodeRate[tpsInfo.rateHP]);
printf (" | Code Rate LP | %s\n", DVBT_CodeRate[tpsInfo.rateLP]);
printf (" | Guard Interval | %s\n", DVBT_GI[tpsInfo.guard]);
printf (" | Mode | %s\n", DVBT_Mode[tpsInfo.mode]);
}
else {
printf (" TPSInfo | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_PACKETERRORNUMBER
{
uint32_t pen;
result = sony_demod_dvbt_monitor_PacketErrorNumber (integ.pDemod, &pen);
if (result == SONY_RESULT_OK) {
printf (" PacketErrorNumber | PEN | %u\n", pen);
}
else {
printf (" PacketErrorNumber | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_SPECTRUMSENSE
{
sony_demod_terr_cable_spectrum_sense_t sense;
result = sony_demod_dvbt_monitor_SpectrumSense (integ.pDemod, &sense);
if (result == SONY_RESULT_OK) {
printf (" SpectrumSense | Spectrum Sense | %s\n", Common_SpectrumSense[sense]);
}
else {
printf (" SpectrumSense | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_SNR
{
int32_t snr;
result = sony_demod_dvbt_monitor_SNR (integ.pDemod, &snr);
if (result == SONY_RESULT_OK) {
printf (" SNR | SNR | %ddB x 10^-3\n", snr);
}
else {
printf (" SNR | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_PPMOFFSET
{
int32_t ppmOffset;
result = sony_demod_dvbt_monitor_SamplingOffset (integ.pDemod, &ppmOffset);
if (result == SONY_RESULT_OK) {
printf (" SamplingOffset | PPM Offset | %d\n", ppmOffset);
}
else {
printf (" SamplingOffset | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_QUALITY
{
uint8_t quality;
result = sony_demod_dvbt_monitor_Quality (integ.pDemod, &quality);
if (result == SONY_RESULT_OK) {
printf (" Quality | SQI | %u\n", quality);
}
else {
printf (" Quality | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
#ifdef MONITOR_PER
{
uint32_t per;
result = sony_demod_dvbt_monitor_PER (integ.pDemod, &per);
if (result == SONY_RESULT_OK) {
printf (" PER | PER | %u x 10^-6\n", per);
}
else {
printf (" PER | Error | %s\n", Common_Result[result]);
}
printf ("-------------------------|-----------------|----------------- \n");
}
#endif
SONY_SLEEP (1000);
}
#if 0
/*------------------------------------------------------------------------------
Closing / Shutdown
------------------------------------------------------------------------------*/
/* Shutdown the demodulator and tuner parts, placing them into a low power mode. After this
* operation the driver will be in SONY_DEMOD_STATE_SHUTDOWN state. From this state you can
* call sony_integ_SleepT_C to return to Terrestrial / Cable mode, or sony_integ_SleepS to
* transition to Satellite operation. Both Sleep API's will load the demodulator configuration
* from memory to retain functionality from before Shutdown.
*
* Note : If sony_integ_InitializeT_C or sony_integ_InitializeS are called the configuration
* memory will be cleared and the demod will perform a SW reset of all device registers.
* This method of returning from Shutdown state is not recommended. */
printf ("\n------------------------------------------\n");
printf (" Shutdown / Finalize \n");
printf ("------------------------------------------\n");
result = sony_integ_Shutdown (&integ);
if (result == SONY_RESULT_OK) {
printf (" Demodulator and tuner put into Shutdown state.\n");
}
else {
printf (" Error: Unable to shutdown the integration driver. (result = %s)\n", Common_Result[result]);
return -1;
}
/* Finalise the I2C */
result = drvi2c_feusb_Finalize (&feusb);
if (result == SONY_RESULT_OK) {
printf (" I2C driver instance closed.\n");
}
else {
printf (" Error: Unable to finalize FEUSB I2C driver. (result = %s)\n", Common_Result[result]);
return -1;
}
#endif
return 0;
}
sony_result_t CXD2837_Scan(struct cxd2837_state *state,uint32_t startFreqkHz,uint8_t bwMHz)
{
#ifndef CONFIG_TH_CXD2837_DVBC_ENABLE
unsigned int modulation_mode=state->mode;
#endif
// sony_result_t result = SONY_RESULT_OK;
sony_result_t tuneResult = SONY_RESULT_OK;
// sony_integ_t integ;
// sony_demod_t demod;
// sony_tuner_terr_cable_t tunerTerrCable;
#ifdef SONY_EXAMPLE_TUNER_ASCOT2E
// sony_ascot2e_t ascot2e;
#endif
#ifdef SONY_EXAMPLE_TUNER_ASCOT3
// sony_ascot3_t ascot3;
#endif
// sony_i2c_t i2c;
#ifndef CONFIG_TH_CXD2837_DVBC_ENABLE
sony_dvbt2_tune_param_t tuneParam;
sony_dvbt_tune_param_t dvbttuneParam;
#endif
// int i;
#ifdef CONFIG_TH_CXD2837_DVBC_ENABLE
sony_dvbc_tune_param_t dvtcTunerParam;
dvtcTunerParam.centerFreqKHz = startFreqkHz/1000;
printk (" Tune to DVB-C signal with the following parameters:\n");
printk (" - Center Freq : %uKHz\n", dvtcTunerParam.centerFreqKHz);
/* Perform DVBC Tune */
tuneResult = sony_integ_dvbc_Tune (&(state->device), &dvtcTunerParam);
printk (" - DVBC - Result : %s\n\n", Common_Result[tuneResult]);
if (tuneResult == SONY_RESULT_OK) {
SONY_TRACE_RETURN (tuneResult);
}
return tuneResult;
#else
/*------------------------------------------------------------------------------
Scan - DVB-T/T2 multiple standard scan.
------------------------------------------------------------------------------*/
// printk ("------------------------------------------\n");
// printk (" Demodulator configuration \n");
// printk ("------------------------------------------\n");
if((modulation_mode==0))
{
/* Configure the DVBT tune parameters based on the channel requirements */
dvbttuneParam.bandwidth = bwMHz;//SONY_DEMOD_BW_8_MHZ; /* Channel bandwidth */
dvbttuneParam.centerFreqKHz = startFreqkHz/1000; /* Channel centre frequency in KHz */
dvbttuneParam.profile = SONY_DVBT_PROFILE_HP; /* Channel profile for hierachical modes. For non-hierachical use HP */
printk (" Tune to DVB-T signal with the following parameters:\n");
printk (" - Center Freq : %uKHz\n", dvbttuneParam.centerFreqKHz);
printk (" - Bandwidth : %s\n", Common_Bandwidth[dvbttuneParam.bandwidth]);
printk (" - Profile : %s\n", DVBT_Profile[dvbttuneParam.profile]);
/* Perform DVBT Tune */
tuneResult = sony_integ_dvbt_Tune (&(state->device), &dvbttuneParam);
printk (" - Result : %s\n\n", Common_Result[tuneResult]);
if (tuneResult == SONY_RESULT_OK) {
SONY_TRACE_RETURN (tuneResult);
}
}
else
{
/* Configure the DVBT2 tune parameters based on the channel requirements */
tuneParam.bandwidth = bwMHz;// SONY_DEMOD_BW_8_MHZ; /* Channel bandwidth */
tuneParam.centerFreqKHz = startFreqkHz/1000; /* Channel center frequency in KHz */
tuneParam.dataPlpId = 0; /* PLP ID where multiple PLP's are available */
tuneParam.profile = SONY_DVBT2_PROFILE_BASE; /* Channel profile is T2-Base */
/* Additional tune information fed back from the driver. This parameter should be checked
if the result from the tune call is SONY_RESULT_OK_CONFIRM. */
tuneParam.tuneInfo = SONY_DEMOD_DVBT2_TUNE_INFO_OK;
tuneParam.dataPlpId = plpidnew;
plpidold = plpidnew;
printk (" Tune to DVB-T2 signal with the following parameters:\n");
printk (" - Center Freq : %uKHz\n", tuneParam.centerFreqKHz);
printk (" - Bandwidth : %s\n", Common_Bandwidth[tuneParam.bandwidth]);
printk (" - PLP ID : %u\n", tuneParam.dataPlpId);
printk (" - Profile : %s\n", DVBT2_Profile[tuneParam.profile]);
/* Perform DVBT2 Tune */
tuneResult = sony_integ_dvbt2_Tune (&(state->device), &tuneParam);
printk (" - Result : %s\n", Common_Result[tuneResult]);
printk (" - Tune Info : %s\n\n", DVBT2_TuneInfo[tuneParam.tuneInfo]);
}
#endif
return tuneResult;
}