static sony_result_t X_oscen(sony_ascot2e_t *pTuner)
{
sony_result_t result = SONY_RESULT_OK;
SONY_TRACE_ENTER("X_oscen");
if((!pTuner) || (!pTuner->pI2c)){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_ARG);
}
/* XOSC_SEL setting (Max) */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x07, 0x1F);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_SLEEP(10);
/* Xtal oscillator current control setting */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x4C, 0x01);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* XOSC_SEL setting */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x07, 0x04);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_TRACE_RETURN(SONY_RESULT_OK);
}
INT32 try_to_lock_DVBT2_signal(struct nim_device *dev, BOOL NeedToInitSystem, BOOL NeedToConfigTuner)
{
UINT16 waitTime = 0;
INT32 result = ERR_FAILUE;
sony_demod_t * param = (sony_demod_t *)dev->priv;
param->plp_num = 0;
param->plp_id = 0;
param->plp_index = 0;
PRINTK_INFO("[%s]:line=%d\n ", __FUNCTION__,__LINE__);
if(NULL == dev)
{
return ERR_FAILUE;
}
else
{
PRINTK_INFO("[%s]:line=%d,NeedToInitSystem=%d,NeedToConfigTuner=%d,\n ", __FUNCTION__,__LINE__,NeedToInitSystem,NeedToConfigTuner);
}
result = DVBT2_change_PLP(dev, 0, NeedToInitSystem, NeedToConfigTuner,1); //for lock signal first.
//get_the_first_data_PLP_info
do
{
result = sony_demod_dvbt2_monitor_DataPLPs(param, (uint8_t *)&(param->all_plp_id),(uint8_t *)&(param->plp_num));
if (result == SONY_RESULT_OK)
{
UINT8 plp_idx;
PRINTK_INFO("\t[%s]: plp_num=%d\n ", __FUNCTION__, param->plp_num);
for (plp_idx=0; plp_idx < param->plp_num; ++plp_idx)
{
PRINTK_INFO("\t[plp_id=%d]\n", param->all_plp_id[plp_idx]);
}
break;
}
else if (result == SONY_RESULT_ERROR_HW_STATE)
{
if (waitTime >= DTV_DEMOD_TUNE_T2_L1POST_TIMEOUT)
{
PRINTK_INFO("%s() error: timeout for get the first data_PLP\r\n", __FUNCTION__);
param->plp_num = 0;
return ERR_FAILUE;
}
else
{
SONY_SLEEP (DEMOD_TUNE_POLL_INTERVAL); //10
waitTime += DEMOD_TUNE_POLL_INTERVAL;
}
}
else
{
PRINTK_INFO("%s()=%d error: Fail to get the first data_PLP\r\n", __FUNCTION__, result);
param->plp_num = 0;
return ERR_FAILUE; // Other (fatal) error.
}
}while (1);
return result;
}
sony_result_t sony_ascot2e_ShiftFRF(sony_ascot2e_t *pTuner, uint32_t frequencykHz)
{
sony_result_t result = SONY_RESULT_OK;
SONY_TRACE_ENTER("sony_ascot2e_ShiftFRF");
/* Argument check */
if((!pTuner) || (!pTuner->pI2c)){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_ARG);
}
/* State check */
if(pTuner->state != SONY_ASCOT2E_STATE_ACTIVE){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_SW_STATE);
}
/* In digital tuning, step size is 25kHz. (+ rounding) */
if(SONY_ASCOT2E_IS_DTV(pTuner->tvSystem)){
frequencykHz = ((frequencykHz + 25/2) / 25) * 25;
}
/* Tune using current system, no VCO calibration */
result = X_tune(pTuner, frequencykHz, pTuner->tvSystem, 0);
if(result != SONY_RESULT_OK){
SONY_TRACE_RETURN(result);
}
pTuner->frequencykHz = frequencykHz;
SONY_SLEEP(10);
result = X_tune_end(pTuner);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(result); }
SONY_TRACE_RETURN(SONY_RESULT_OK);
}
INT32 try_to_lock_next_data_plp(struct nim_device *dev, BOOL NeedToInitSystem, BOOL NeedToConfigTuner)
{
INT32 result = ERR_FAILUE;
sony_demod_t * param = (sony_demod_t *)dev->priv;
sony_dvbt2_l1pre_t L1Pre;
sony_dvbt2_plp_t plpInfo;
UINT8 retry = 0;
UINT8 plp_index = 0;
for (plp_index = param->plp_index+1; plp_index < param->plp_num; ++plp_index )
{
if (plp_index >= param->plp_num)
return ERR_FAILUE;
result = DVBT2_change_PLP(dev, param->all_plp_id[plp_index], FALSE, FALSE, 0);
for ( retry=0; retry<30; ++retry )
{
SONY_SLEEP (30);
if (param->autoscan_stop_flag)
return ERR_FAILUE;
if (param->do_not_wait_t2_signal_locked)
return ERR_FAILUE;
result = sony_demod_dvbt2_monitor_L1Pre(param, &L1Pre);//sony_dvb_demod_monitorT2_L1Pre
if (result != SONY_RESULT_OK)
{
PRINTK_INFO("%s(%d,%d)(plp_num=%d, all_plp_id[%d]=%d) error: sony_dvb_demod_monitorT2_L1Pre()=%d \r\n", __FUNCTION__,NeedToInitSystem,NeedToConfigTuner, param->plp_num, plp_index, param->all_plp_id[plp_index],result);
continue;
//return result;
}
// Get Active PLP information.
result = sony_demod_dvbt2_monitor_ActivePLP(param, SONY_DVBT2_PLP_DATA, &plpInfo);//sony_dvb_demod_monitorT2_ActivePLP
if (result != SONY_RESULT_OK)
{
PRINTK_INFO("%s(%d,%d)(plp_num=%d, all_plp_id[%d]=%d) error: sony_dvb_demod_monitorT2_ActivePLP()=%d \r\n", __FUNCTION__,NeedToInitSystem,NeedToConfigTuner, param->plp_num, plp_index, param->all_plp_id[plp_index],result);
continue;
//return result;
}
if (result == SONY_RESULT_OK)
{
if (plpInfo.type == SONY_DVBT2_PLP_TYPE_DATA1 || plpInfo.type == SONY_DVBT2_PLP_TYPE_DATA2)
{
if (plpInfo.id != param->all_plp_id[plp_index])
{
PRINTK_INFO("%s(%d,%d)(plp_num=%d, all_plp_id[%d]=%d), plpInfo.id=%d, error PLP locked: retry %d times.\r\n", __FUNCTION__, NeedToInitSystem,NeedToConfigTuner, param->plp_num, plp_index, param->all_plp_id[plp_index], plpInfo.id, retry);
continue;
}
else
break; //correct PLP is locked.
}
}
}
if (result == SONY_RESULT_OK && (plpInfo.id == param->all_plp_id[plp_index]) )
{
if (plpInfo.type == SONY_DVBT2_PLP_TYPE_DATA1 || plpInfo.type == SONY_DVBT2_PLP_TYPE_DATA2)
{
param->plp_id = plpInfo.id;
param->t2_system_id = L1Pre.systemId;
param->plp_index = plp_index;
if (retry!=0)
PRINTK_INFO("%s(%d,%d)(plp_num=%d, all_plp_id[%d]=%d), ok: retry %d times.\r\n", __FUNCTION__, NeedToInitSystem,NeedToConfigTuner, param->plp_num, plp_index, param->all_plp_id[plp_index], retry);
return SONY_RESULT_OK;
}
else
{
PRINTK_INFO("%s(%d,%d)(plp_num=%d, all_plp_id[%d]=%d), ok: retry %d times. error: Not DataPLP: (type=%d, id=%d)\r\n", __FUNCTION__, NeedToInitSystem,NeedToConfigTuner, param->plp_num, plp_index, param->all_plp_id[plp_index], retry, plpInfo.type, plpInfo.id);
}
}
else
{
PRINTK_INFO("%s(%d,%d)(plp_num=%d, all_plp_id[%d]=%d), error: fail to lock the PLP.\r\n", __FUNCTION__, NeedToInitSystem,NeedToConfigTuner, param->plp_num, plp_index, param->all_plp_id[plp_index], retry);
}
}
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;
}
static sony_result_t X_pon(sony_ascot2e_t *pTuner)
{
sony_result_t result = SONY_RESULT_OK;
SONY_TRACE_ENTER("X_pon");
if((!pTuner) || (!pTuner->pI2c)){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_ARG);
}
/* Xtal==41MHz special setting */
if(pTuner->xtalFreqMHz == 41){
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x44, 0x07);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
/* 0x01 - 0x04 */
{
uint8_t data[4];
/* Xtal frequency setting */
data[0] = (uint8_t)(pTuner->xtalFreqMHz);
/* VCO current setting */
data[1] = 0x06;
/* Logic wake up, CPU boot */
data[2] = 0xC4;
data[3] = 0x40;
result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x01, data, sizeof(data));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
/* 0x22 - 0x24 */
{
/* RFVGA optimization setting (RF_DIST0 - RF_DIST2) */
const uint8_t cdata[] = {0x10, 0x3F, 0x25};
result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x22, cdata, sizeof(cdata));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
/* PLL mode setting */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x28, 0x1E);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* RSSI setting */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x59, 0x04);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* Wait 80ms */
SONY_SLEEP(80);
/* Check CPU_STT/CPU_ERR */
{
uint8_t rdata[2];
result = pTuner->pI2c->ReadRegister(pTuner->pI2c, pTuner->i2cAddress, 0x1A, rdata, sizeof(rdata));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
if(rdata[0] != 0x00){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_HW_STATE); /* CPU_STT != 0x00 */
}
#ifndef SONY_ASCOT2E_IGNORE_NVM_ERROR /* For no NVM tuner evaluation */
if((rdata[1] & 0x3F) != 0x00){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_HW_STATE); /* CPU_ERR[5:0] != 0x00 (NVM Error) */
}
#endif /* SONY_ASCOT2E_IGNORE_NVM_ERROR */
}
/* Xtal oscillator current control setting */
if(!(pTuner->flags & SONY_ASCOT2E_CONFIG_EXT_REF)){
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x4C, 0x01);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
/* XOSC_SEL setting */
{
uint8_t data = 0;
if(pTuner->flags & SONY_ASCOT2E_CONFIG_EXT_REF){ /* Use external Xtal */
/* XOSC_SEL=0(disable) */
data = 0x00;
}else{
/* XOSC_SEL=100uA */
data = 0x04;
}
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x07, data);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
/* CPU deep sleep */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x04, 0x00);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* Logic sleep */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x03, 0xC0);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* Power save setting */
{
const uint8_t cdata[2] = {0x00, 0x04};
result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x14, cdata, sizeof(cdata));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x50, 0x01);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_TRACE_RETURN(SONY_RESULT_OK);
}
sony_result_t sony_ascot2e_RFFilterConfig(sony_ascot2e_t *pTuner, uint8_t coeff, uint8_t offset)
{
sony_result_t result = SONY_RESULT_OK;
SONY_TRACE_ENTER("sony_ascot2e_RFFilterConfig");
if((!pTuner) || (!pTuner->pI2c)){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_ARG);
}
if((pTuner->state != SONY_ASCOT2E_STATE_SLEEP) && (pTuner->state != SONY_ASCOT2E_STATE_ACTIVE)){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_SW_STATE);
}
if(pTuner->state == SONY_ASCOT2E_STATE_SLEEP){
if((pTuner->flags & SONY_ASCOT2E_CONFIG_SLEEP_DISABLEXTAL) && !(pTuner->flags & SONY_ASCOT2E_CONFIG_EXT_REF)){
/* Enable Xtal */
result = X_oscen(pTuner);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(result); }
}
}
/* Logic wake up, CPU wake up */
{
const uint8_t cdata[2] = {0xC4, 0x40};
result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x03, cdata, sizeof(cdata));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
{
uint8_t data[3];
/* Write VL_TRCKOUT_COEFF */
data[0] = coeff;
data[1] = 0x49;
data[2] = 0x03;
result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x16, data, sizeof(data));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_SLEEP(1);
/* Write VL_TRCKOUT_OFS */
data[0] = offset;
data[1] = 0x4B;
data[2] = 0x03;
result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x16, data, sizeof(data));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_SLEEP(1);
}
/* CPU deep sleep */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x04, 0x00);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* Logic sleep */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x03, 0xC0);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
if(pTuner->state == SONY_ASCOT2E_STATE_SLEEP){
if((pTuner->flags & SONY_ASCOT2E_CONFIG_SLEEP_DISABLEXTAL) && !(pTuner->flags & SONY_ASCOT2E_CONFIG_EXT_REF)){
/* Disable Xtal */
result = X_oscdis(pTuner);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(result); }
}
}
SONY_TRACE_RETURN(SONY_RESULT_OK);
}
static sony_result_t X_read_ss(sony_ascot2e_t *pTuner, uint8_t *pAGCReg, uint8_t *pRFAGCReg)
{
sony_result_t result = SONY_RESULT_OK;
SONY_TRACE_ENTER("X_read_ss");
/* pRFAGCReg can be NULL (RFAGC read is skipped) */
if((!pTuner) || (!pTuner->pI2c) || (!pAGCReg)){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_ARG);
}
if((pTuner->state != SONY_ASCOT2E_STATE_SLEEP) && (pTuner->state != SONY_ASCOT2E_STATE_ACTIVE)){
SONY_TRACE_RETURN(SONY_RESULT_ERROR_SW_STATE);
}
/* Logic wake up, CPU wake up */
{
const uint8_t cdata[2] = {0xC4, 0x40};
result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x03, cdata, sizeof(cdata));
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
/* ADC enable */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x59, 0x05);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* Timer reset */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x18, 0x00);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_SLEEP(1);
/* ADC start */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x04, 0xF0);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x5A, 0x01);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x04, 0x40);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* ADC read out */
result = pTuner->pI2c->ReadRegister(pTuner->pI2c, pTuner->i2cAddress, 0x5B, pAGCReg, 1);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
if(pRFAGCReg){
/* Connect AGC */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x59, 0x03);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* Timer reset */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x18, 0x00);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_SLEEP(1);
/* ADC start */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x04, 0xF0);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x5A, 0x01);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x04, 0x40);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* ADC read out */
result = pTuner->pI2c->ReadRegister(pTuner->pI2c, pTuner->i2cAddress, 0x5B, pRFAGCReg, 1);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
}
/* ADC disable */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x59, 0x04);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* CPU deep sleep */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x04, 0x00);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
/* Logic sleep */
result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x03, 0xC0);
if(result != SONY_RESULT_OK){ SONY_TRACE_RETURN(SONY_RESULT_ERROR_I2C); }
SONY_TRACE_RETURN(SONY_RESULT_OK);
}
static sony_result_t sony_tuner_ascot2e_Tune (sony_tuner_terr_cable_t * pTuner,
uint32_t frequencyKHz,
sony_dtv_system_t system,
sony_demod_bandwidth_t bandwidth)
{
sony_result_t result = SONY_RESULT_OK;
sony_ascot2e_tv_system_t dtvSystem;
SONY_TRACE_ENTER ("sony_tuner_ascot2e_Tune");
if (!pTuner || !pTuner->user) {
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
/* Call into underlying driver. Convert system, bandwidth into dtv system. */
if(TunMode==45){
switch (system) {
case SONY_DTV_SYSTEM_DVBC:
dtvSystem = SONY_ASCOT3_DTV_DVBC_8;
break;
case SONY_DTV_SYSTEM_DVBT:
switch (bandwidth) {
case SONY_DEMOD_BW_5_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT_5;
break;
case SONY_DEMOD_BW_6_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT_6;
break;
case SONY_DEMOD_BW_7_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT_7;
break;
case SONY_DEMOD_BW_8_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT_8;
break;
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
break;
case SONY_DTV_SYSTEM_DVBT2:
switch (bandwidth) {
case SONY_DEMOD_BW_1_7_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT2_1_7;
break;
case SONY_DEMOD_BW_5_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT2_5;
break;
case SONY_DEMOD_BW_6_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT2_6;
break;
case SONY_DEMOD_BW_7_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT2_7;
break;
case SONY_DEMOD_BW_8_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBT2_8;
break;
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
break;
case SONY_DTV_SYSTEM_DVBC2:
switch (bandwidth) {
case SONY_DEMOD_BW_6_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBC2_6;
break;
case SONY_DEMOD_BW_8_MHZ:
dtvSystem = SONY_ASCOT3_DTV_DVBC2_8;
break;
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
break;
/* Intentional fall-through */
case SONY_DTV_SYSTEM_UNKNOWN:
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
}
else{
switch (system) {
case SONY_DTV_SYSTEM_DVBC:
dtvSystem = SONY_ASCOT2E_DTV_DVBC;
break;
case SONY_DTV_SYSTEM_DVBT:
switch (bandwidth) {
case SONY_DEMOD_BW_5_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT_5;
break;
case SONY_DEMOD_BW_6_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT_6;
break;
case SONY_DEMOD_BW_7_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT_7;
break;
case SONY_DEMOD_BW_8_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT_8;
break;
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
break;
case SONY_DTV_SYSTEM_DVBT2:
switch (bandwidth) {
case SONY_DEMOD_BW_1_7_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT2_1_7;
break;
case SONY_DEMOD_BW_5_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT2_5;
break;
case SONY_DEMOD_BW_6_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT2_6;
break;
case SONY_DEMOD_BW_7_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT2_7;
break;
case SONY_DEMOD_BW_8_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBT2_8;
break;
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
break;
case SONY_DTV_SYSTEM_DVBC2:
switch (bandwidth) {
case SONY_DEMOD_BW_6_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBC2_6;
break;
case SONY_DEMOD_BW_8_MHZ:
dtvSystem = SONY_ASCOT2E_DTV_DVBC2_8;
break;
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
break;
/* Intentional fall-through */
case SONY_DTV_SYSTEM_UNKNOWN:
default:
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
}
}
if(TunMode==45)
result = sony_ascot3_Tune(((sony_ascot3_t *) pTuner->user), frequencyKHz, dtvSystem);
else
result = sony_ascot2e_Tune(((sony_ascot2e_t *) pTuner->user), frequencyKHz, dtvSystem);
if (result != SONY_RESULT_OK) {
pTuner->system = SONY_DTV_SYSTEM_UNKNOWN;
pTuner->frequencyKHz = 0;
pTuner->bandwidth = SONY_DEMOD_BW_UNKNOWN;
SONY_TRACE_RETURN (result);
}
/* Allow the tuner time to settle */
SONY_SLEEP(50);
if(TunMode==45)
result = sony_ascot3_TuneEnd((sony_ascot3_t *) pTuner->user);
else
result = sony_ascot2e_TuneEnd((sony_ascot2e_t *) pTuner->user);
if (result != SONY_RESULT_OK) {
pTuner->system = SONY_DTV_SYSTEM_UNKNOWN;
pTuner->frequencyKHz = 0;
pTuner->bandwidth = SONY_DEMOD_BW_UNKNOWN;
SONY_TRACE_RETURN (result);
}
/* Assign current values. */
pTuner->system = system;
if(TunMode==45)
pTuner->frequencyKHz = ((sony_ascot3_t *) pTuner->user)->frequencykHz;
else
pTuner->frequencyKHz = ((sony_ascot2e_t *) pTuner->user)->frequencykHz;
pTuner->bandwidth = bandwidth;
SONY_TRACE_RETURN (result);
}
