/*------------------------------------------------------------------------------ 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_GetTPLock(struct cxd2837_state *state) { uint8_t syncState = 0; uint8_t tsLock = 0; uint8_t earlyUnlock = 0; #ifndef CONFIG_TH_CXD2837_DVBC_ENABLE unsigned int modulation_mode = state->mode; #endif sony_result_t result = SONY_RESULT_ERROR_UNLOCK; #ifdef CONFIG_TH_CXD2837_DVBC_ENABLE result = sony_demod_dvbc_monitor_SyncStat (state->device.pDemod, &syncState, &tsLock, &earlyUnlock); if (result == SONY_RESULT_OK) { // printk (" SyncStat | SyncStat | %lu\n", syncState); pr_dbg("debug27 DVB_C | TS Lock | %s\n", Common_YesNo[tsLock]); // printk ("T | Early Unlock | %s\n", Common_YesNo[earlyUnlock]); }else{ pr_dbg(" debug27 DVB_C | Error | %s\n", Common_Result[result]); } if (result != SONY_RESULT_OK) { return SONY_RESULT_ERROR_UNLOCK; } if(tsLock) return SONY_RESULT_OK; else return SONY_DEMOD_LOCK_RESULT_UNLOCKED; #else if(modulation_mode == 0){ result = sony_demod_dvbt_monitor_SyncStat (state->device.pDemod, &syncState, &tsLock, &earlyUnlock); if (result == SONY_RESULT_OK) { // printk (" SyncStat | SyncStat | %lu\n", syncState); pr_dbg ("T | TS Lock | %s\n", Common_YesNo[tsLock]); // printk ("T | Early Unlock | %s\n", Common_YesNo[earlyUnlock]); }else { pr_dbg(" SyncStat T | Error | %s\n", Common_Result[result]); } //printk ("-------------------------|-----------------|----------------- \n"); if (result != SONY_RESULT_OK) { return SONY_RESULT_ERROR_UNLOCK; } if(tsLock) return SONY_RESULT_OK; else return SONY_DEMOD_LOCK_RESULT_UNLOCKED; } else { syncState = 0; tsLock = 0; earlyUnlock = 0; result = sony_demod_dvbt2_monitor_SyncStat (state->device.pDemod, &syncState, &tsLock, &earlyUnlock); if (result == SONY_RESULT_OK) { // printk (" SyncStat | SyncStat | %lu\n", syncState); pr_dbg ("T2 | TS Lock | %s\n", Common_YesNo[tsLock]); // printk ("T2 | Early Unlock | %s\n", Common_YesNo[earlyUnlock]); }else { pr_dbg (" SyncStat T2 | Error | %s\n", Common_Result[result]); } //printk ("-------------------------|-----------------|----------------- \n"); if (result != SONY_RESULT_OK) { return SONY_RESULT_ERROR_UNLOCK; } if(tsLock) return SONY_RESULT_OK; else return SONY_DEMOD_LOCK_RESULT_UNLOCKED; } #endif }